package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-05 17:16:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[drm]: add android drm allocator support

Browse Source 
1. enable drm allocator in android
2. modify size calculating when alloc

Todo: wait for new interface of kernel to decide
use whether drm or ion as allocator

Change-Id: Ia6791d91d113b238be77088ae747012fb786d683
Signed-off-by: Jung Zhao <jung.zhao@rock-chips.com>
This commit is contained in:
Jung Zhao
2016-08-24 16:53:10 +08:00
parent e8a2c929ce
commit 70e2ebdb2b
6 changed files with 1450 additions and 1329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
osal/CMakeLists.txt
View File

@@ -1,7 +1,7 @@
# vim: syntax=cmake
if(${ANDROID})
set(OS_DIR android)
set(MPP_ALLOCATOR allocator/allocator_ion.c)
set(MPP_ALLOCATOR allocator/allocator_ion.c allocator/allocator_drm.c)
elseif(${UNIX})
set(OS_DIR linux)
set(MPP_ALLOCATOR allocator/allocator_ion.c allocator/allocator_drm.c)

225
osal/allocator/allocator_drm.c
View File

@@ -35,49 +35,48 @@
static RK_U32 drm_debug = 0;
#define DRM_FUNCTDRM (0x00000001)
#define DRM_FUNCTION (0x00000001)
#define DRM_DEVICE (0x00000002)
#define DRM_CLINET (0x00000004)
#define DRM_CLIENT (0x00000004)
#define DRM_IOCTL (0x00000008)
#define DRM_DETECT_IOMMU_DISABLE (0x0) /* use DRM_HEAP_TYPE_DMA */
#define DRM_DETECT_IOMMU_ENABLE (0x1) /* use DRM_HEAP_TYPE_SYSTEM */
#define DRM_DETECT_NO_DTS (0x2) /* use DRM_HEAP_TYPE_CARVEOUT */
#define drm_dbg(flag, fmt, ...) _mpp_dbg(drm_debug, flag, fmt, ## __VA_ARGS__)
#define drm_dbg(flag, fmt, ...) _mpp_dbg_f(drm_debug, flag, fmt, ## __VA_ARGS__)
static int drm_ioctl(int fd, int req, void *arg)
{
int ret = ioctl(fd, req, arg);
if (ret < 0) {
mpp_err("drm_ioctl %x failed with code %d: %s\n", req,
ret, strerror(errno));
return -errno;
}
int ret;
do {
ret = ioctl(fd, req, arg);
} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
drm_dbg(DRM_FUNCTION, "drm_ioctl %x with code %d: %s", req,
ret, strerror(errno));
return ret;
}
static int drm_alloc(int fd, size_t len, size_t align, unsigned int heap_mask,
unsigned int flags, RK_U32 *handle)
static void* drm_mmap(int fd, size_t len, int prot, int flags, loff_t offset)
{
int ret;
struct drm_mode_create_dumb dmcb;
memset(&dmcb, 0, sizeof(struct drm_mode_create_dumb));
dmcb.bpp = align;
dmcb.width = ((len + align) & (~align)) / align;
dmcb.height = 8;
dmcb.size = (len + align) & (~align);
static unsigned long pagesize_mask = 0;
if (handle == NULL)
return -EINVAL;
if (fd < 0)
return NULL;
ret = drm_ioctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &dmcb);
if (ret < 0)
return ret;
*handle = dmcb.handle;
(void)heap_mask;
(void)flags;
return ret;
if (!pagesize_mask)
pagesize_mask = getpagesize() - 1;
len = (len + pagesize_mask) & ~pagesize_mask;
if (offset & 4095) {
return NULL;
}
return mmap64(NULL, len, prot, flags, fd, offset);
}
static int drm_handle_to_fd(int fd, RK_U32 handle, int *map_fd, RK_U32 flags)
@@ -86,8 +85,8 @@ static int drm_handle_to_fd(int fd, RK_U32 handle, int *map_fd, RK_U32 flags)
struct drm_prime_handle dph;
memset(&dph, 0, sizeof(struct drm_prime_handle));
dph.handle = handle;
dph.fd = 1;
dph.flags = 0;
dph.fd = -1;
dph.flags = flags;
if (map_fd == NULL)
return -EINVAL;
@@ -99,24 +98,37 @@ static int drm_handle_to_fd(int fd, RK_U32 handle, int *map_fd, RK_U32 flags)
*map_fd = dph.fd;
drm_dbg(DRM_FUNCTION, "get fd %d", *map_fd);
if (*map_fd < 0) {
mpp_err("map ioctl returned negative fd\n");
return -EINVAL;
}
(void)flags;
return ret;
}
static int drm_free(int fd, RK_U32 handle)
static int drm_fd_to_handle(int fd, int map_fd, RK_U32 *handle, RK_U32 flags)
{
struct drm_mode_destroy_dumb data = {
.handle = handle,
};
return drm_ioctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &data);
int ret;
struct drm_prime_handle dph;
dph.fd = map_fd;
dph.flags = flags;
ret = drm_ioctl(fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &dph);
if (ret < 0) {
return ret;
}
*handle = dph.handle;
drm_dbg(DRM_FUNCTION, "get handle %d", *handle);
return ret;
}
static int drm_map(int fd, RK_U32 handle, size_t length, int prot,
int flags, off_t offset, unsigned char **ptr, int *map_fd)
int flags, unsigned char **ptr, int *map_fd)
{
int ret;
struct drm_mode_map_dumb dmmd;
@@ -129,22 +141,65 @@ static int drm_map(int fd, RK_U32 handle, size_t length, int prot,
return -EINVAL;
ret = drm_handle_to_fd(fd, handle, map_fd, 0);
drm_dbg(DRM_FUNCTION, "drm_map fd %d", *map_fd);
if (ret < 0)
return ret;
ret = drm_ioctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &dmmd);
if (ret < 0)
if (ret < 0) {
close(*map_fd);
return ret;
}
*ptr = mmap(NULL, length, prot, flags, *map_fd, dmmd.offset);
drm_dbg(DRM_FUNCTION, "dev fd %d length %d", fd, length);
*ptr = drm_mmap(fd, length, prot, flags, dmmd.offset);
if (*ptr == MAP_FAILED) {
close(*map_fd);
*map_fd = -1;
mpp_err("mmap failed: %s\n", strerror(errno));
return -errno;
}
(void)offset;
return ret;
}
static int drm_alloc(int fd, size_t len, size_t align, RK_U32 *handle)
{
int ret;
struct drm_mode_create_dumb dmcb;
drm_dbg(DRM_FUNCTION, "len %ld aligned %ld\n", len, align);
memset(&dmcb, 0, sizeof(struct drm_mode_create_dumb));
dmcb.bpp = 8;
dmcb.width = (len + align - 1) & (~(align - 1));
dmcb.height = 1;
dmcb.size = dmcb.width * dmcb.bpp;
drm_dbg(DRM_FUNCTION, "fd %d aligned %d size %lld\n", fd, align, dmcb.size);
if (handle == NULL)
return -EINVAL;
ret = drm_ioctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &dmcb);
if (ret < 0)
return ret;
*handle = dmcb.handle;
drm_dbg(DRM_FUNCTION, "get handle %d size %d", *handle, dmcb.size);
return ret;
}
static int drm_free(int fd, RK_U32 handle)
{
struct drm_mode_destroy_dumb data = {
.handle = handle,
};
return drm_ioctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &data);
}
#include <dirent.h>
static const char *search_name = NULL;
@@ -189,18 +244,28 @@ static RK_S32 find_dir_in_path(char *path, const char *dir_name, size_t max_leng
return new_path_len;
}
static char *dts_devices[] = {
"vpu_service",
"hevc_service",
"rkvdec",
"rkvenc",
};
static RK_S32 check_sysfs_iommu()
{
RK_U32 i = 0, found = 0;
RK_U32 i = 0;
RK_U32 dts_info_found = 0;
RK_U32 ion_info_found = 0;
RK_S32 ret = DRM_DETECT_IOMMU_DISABLE;
char path[256];
static char *dts_devices[] = {
"vpu_service",
"hevc_service",
"rkvdec",
"rkvenc",
};
static char *system_heaps[] = {
"vmalloc",
"system-heap",
};
mpp_env_get_u32("drm_debug", &drm_debug, 0);
#ifdef SOFIA_3GR_LINUX
return ret;
#endif
for (i = 0; i < MPP_ARRAY_ELEMS(dts_devices); i++) {
snprintf(path, sizeof(path), "/proc/device-tree");
@@ -216,14 +281,26 @@ static RK_S32 check_sysfs_iommu()
if (iommu_enabled)
ret = DRM_DETECT_IOMMU_ENABLE;
}
found = 1;
dts_info_found = 1;
break;
}
}
}
if (!found) {
mpp_err("can not find dts for all possible devices\n");
if (!dts_info_found) {
for (i = 0; i < MPP_ARRAY_ELEMS(system_heaps); i++) {
snprintf(path, sizeof(path), "/sys/kernel/debug/ion/heaps");
if (find_dir_in_path(path, system_heaps[i], sizeof(path))) {
mpp_log("%s found\n", system_heaps[i]);
ret = DRM_DETECT_IOMMU_ENABLE;
ion_info_found = 1;
break;
}
}
}
if (!dts_info_found && !ion_info_found) {
mpp_err("can not find any hint from all possible devices\n");
ret = DRM_DETECT_NO_DTS;
}
@@ -246,14 +323,14 @@ enum {
};
const char *dev_drm = "/dev/dri/card0";
static RK_S32 drm_heap_id = -1;
static RK_U32 drm_heap_mask = 1;
MPP_RET os_allocator_drm_open(void **ctx, size_t alignment)
{
RK_S32 fd;
allocator_ctx_drm *p;
drm_dbg(DRM_FUNCTION, "enter");
if (NULL == ctx) {
mpp_err("os_allocator_open Android do not accept NULL input\n");
return MPP_ERR_NULL_PTR;
@@ -278,13 +355,13 @@ MPP_RET os_allocator_drm_open(void **ctx, size_t alignment)
/*
* default drm use cma, do nothing here
*/
drm_heap_mask = (1 << DRM_HEAP_TYPE_CMA);
drm_heap_id = DRM_HEAP_TYPE_CMA;
p->alignment = alignment;
p->drm_device = fd;
*ctx = p;
}
drm_dbg(DRM_FUNCTION, "leave");
return MPP_OK;
}
@@ -299,16 +376,16 @@ MPP_RET os_allocator_drm_alloc(void *ctx, MppBufferInfo *info)
}
p = (allocator_ctx_drm *)ctx;
drm_dbg(DRM_FUNCTION, "alignment %d size %d", p->alignment, info->size);
ret = drm_alloc(p->drm_device, info->size, p->alignment,
drm_heap_mask, 0,
(RK_U32 *)&info->hnd);
if (ret) {
mpp_err("os_allocator_drm_alloc drm_alloc failed ret %d\n", ret);
return ret;
}
drm_dbg(DRM_FUNCTION, "handle %d", (RK_U32)((intptr_t)info->hnd));
ret = drm_map(p->drm_device, (RK_U32)((intptr_t)info->hnd), info->size,
PROT_READ | PROT_WRITE, MAP_SHARED, (off_t)0,
(unsigned char**)&info->ptr, &info->fd);
PROT_READ | PROT_WRITE, MAP_SHARED, (unsigned char **)&info->ptr, &info->fd);
if (ret) {
mpp_err("os_allocator_drm_alloc drm_map failed ret %d\n", ret);
return ret;
@@ -319,19 +396,35 @@ MPP_RET os_allocator_drm_alloc(void *ctx, MppBufferInfo *info)
MPP_RET os_allocator_drm_import(void *ctx, MppBufferInfo *data)
{
MPP_RET ret = MPP_OK;
(void)ctx;
allocator_ctx_drm *p = (allocator_ctx_drm *)ctx;
struct drm_mode_map_dumb dmmd;
memset(&dmmd, 0, sizeof(dmmd));
drm_dbg(DRM_FUNCTION, "enter");
// NOTE: do not use the original buffer fd,
// use dup fd to avoid unexpected external fd close
data->fd = dup(data->fd);
/* I don't know whether it is correct for drm */
data->ptr = mmap(NULL, data->size, PROT_READ | PROT_WRITE, MAP_SHARED, data->fd, 0);
ret = drm_fd_to_handle(p->drm_device, data->fd, (RK_U32 *)&data->hnd, 0);
drm_dbg(DRM_FUNCTION, "get handle %d", (RK_U32)(data->hnd));
dmmd.handle = (RK_U32)(data->hnd);
ret = drm_ioctl(p->drm_device, DRM_IOCTL_MODE_MAP_DUMB, &dmmd);
if (ret < 0)
return ret;
drm_dbg(DRM_FUNCTION, "dev fd %d length %d", p->drm_device, data->size);
data->ptr = drm_mmap(p->drm_device, data->size, PROT_READ | PROT_WRITE, MAP_SHARED, dmmd.offset);
if (data->ptr == MAP_FAILED) {
mpp_err_f("map error %s\n", strerror(errno));
ret = MPP_NOK;
close(data->fd);
data->fd = -1;
data->ptr = NULL;
mpp_err("mmap failed: %s\n", strerror(errno));
return -errno;
}
drm_dbg(DRM_FUNCTION, "leave");
return ret;
}
@@ -370,6 +463,7 @@ MPP_RET os_allocator_drm_close(void *ctx)
}
p = (allocator_ctx_drm *)ctx;
drm_dbg(DRM_FUNCTION, "close fd %d", p->drm_device);
ret = close(p->drm_device);
mpp_free(p);
if (ret < 0)
@@ -385,4 +479,3 @@ os_allocator allocator_drm = {
os_allocator_drm_release,
os_allocator_drm_close,
};

20
osal/android/os_allocator.c
View File

@@ -22,9 +22,11 @@
#include "os_mem.h"
#include "os_allocator.h"
#include "allocator_ion.h"
#include "allocator_drm.h"
#include "mpp_mem.h"
#include "mpp_log.h"
#include "mpp_common.h"
typedef struct {
RK_U32 alignment;
@@ -70,7 +72,7 @@ MPP_RET os_allocator_normal_alloc(void *ctx, MppBufferInfo *info)
MPP_RET os_allocator_normal_free(void *ctx, MppBufferInfo *info)
{
(void) ctx;
(void)ctx;
if (info->ptr)
os_free(info->ptr);
return MPP_OK;
@@ -89,7 +91,7 @@ MPP_RET os_allocator_normal_import(void *ctx, MppBufferInfo *info)
MPP_RET os_allocator_normal_release(void *ctx, MppBufferInfo *info)
{
(void) ctx;
(void)ctx;
mpp_assert(info->ptr);
mpp_assert(info->size);
info->ptr = NULL;
@@ -121,17 +123,25 @@ static os_allocator allocator_normal = {
MPP_RET os_allocator_get(os_allocator *api, MppBufferType type)
{
MPP_RET ret = MPP_OK;
switch (type) {
case MPP_BUFFER_TYPE_NORMAL :
case MPP_BUFFER_TYPE_V4L2 : {
*api = allocator_normal;
} break;
}
break;
case MPP_BUFFER_TYPE_ION : {
*api = allocator_ion;
} break;
}
break;
case MPP_BUFFER_TYPE_DRM : {
*api = allocator_drm;
}
break;
default : {
ret = MPP_NOK;
} break;
}
break;
}
return ret;
}

11
osal/linux/drm.h
View File

@@ -630,17 +630,17 @@ struct drm_get_cap {
/**
* DRM_CLIENT_CAP_UNIVERSAL_PLANES
*
* if set to 1, the DRM core will expose the full universal plane list
* (including primary and cursor planes).
* If set to 1, the DRM core will expose all planes (overlay, primary, and
* cursor) to userspace.
*/
#define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2
#define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2
/**
* DRM_CLIENT_CAP_ATOMIC
*
* If set to 1, the DRM core will allow atomic modesetting requests.
* If set to 1, the DRM core will expose atomic properties to userspace
*/
#define DRM_CLIENT_CAP_ATOMIC 3
#define DRM_CLIENT_CAP_ATOMIC 3
/** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
struct drm_set_client_cap {
@@ -816,7 +816,6 @@ struct drm_event_vblank {
#define DRM_CAP_PRIME 0x5
#define DRM_CAP_TIMESTAMP_MONOTONIC 0x6
#define DRM_CAP_ASYNC_PAGE_FLIP 0x7
#define DRM_CAP_ADDFB2_MODIFIERS 0x10
#define DRM_PRIME_CAP_IMPORT 0x1
#define DRM_PRIME_CAP_EXPORT 0x2

40
osal/linux/drm_mode.h
View File

@@ -92,6 +92,14 @@
#define DRM_MODE_DIRTY_ON 1
#define DRM_MODE_DIRTY_ANNOTATE 2
/* rotation property bits */
#define DRM_ROTATE_0 0
#define DRM_ROTATE_90 1
#define DRM_ROTATE_180 2
#define DRM_ROTATE_270 3
#define DRM_REFLECT_X 4
#define DRM_REFLECT_Y 5
struct drm_mode_modeinfo {
__u32 clock;
__u16 hdisplay, hsync_start, hsync_end, htotal, hskew;
@@ -259,6 +267,13 @@ struct drm_mode_get_connector {
#define DRM_MODE_PROP_OBJECT DRM_MODE_PROP_TYPE(1)
#define DRM_MODE_PROP_SIGNED_RANGE DRM_MODE_PROP_TYPE(2)
/* the PROP_ATOMIC flag is used to hide properties from userspace that
* is not aware of atomic properties. This is mostly to work around
* older userspace (DDX drivers) that read/write each prop they find,
* witout being aware that this could be triggering a lengthy modeset.
*/
#define DRM_MODE_PROP_ATOMIC 0x80000000
struct drm_mode_property_enum {
__u64 value;
char name[DRM_PROP_NAME_LEN];
@@ -322,8 +337,7 @@ struct drm_mode_fb_cmd {
__u32 handle;
};
#define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */
#define DRM_MODE_FB_MODIFIERS (1<<1) /* enables ->modifer[] */
#define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */
struct drm_mode_fb_cmd2 {
__u32 fb_id;
@@ -344,18 +358,10 @@ struct drm_mode_fb_cmd2 {
* So it would consist of Y as offset[0] and UV as
* offset[1]. Note that offset[0] will generally
* be 0.
*
* To accommodate tiled, compressed, etc formats, a per-plane
* modifier can be specified. The default value of zero
* indicates "native" format as specified by the fourcc.
* Vendor specific modifier token. This allows, for example,
* different tiling/swizzling pattern on different planes.
* See discussion above of DRM_FORMAT_MOD_xxx.
*/
__u32 handles[4];
__u32 pitches[4]; /* pitch for each plane */
__u32 offsets[4]; /* offset of each plane */
__u64 modifier[4]; /* ie, tiling, compressed (per plane) */
};
#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
@@ -517,9 +523,16 @@ struct drm_mode_destroy_dumb {
};
/* page-flip flags are valid, plus: */
#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100
#define DRM_MODE_ATOMIC_NONBLOCK 0x0200
#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400
#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100
#define DRM_MODE_ATOMIC_NONBLOCK 0x0200
#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400
#define DRM_MODE_ATOMIC_FLAGS (\
DRM_MODE_PAGE_FLIP_EVENT |\
DRM_MODE_PAGE_FLIP_ASYNC |\
DRM_MODE_ATOMIC_TEST_ONLY |\
DRM_MODE_ATOMIC_NONBLOCK |\
DRM_MODE_ATOMIC_ALLOW_MODESET)
struct drm_mode_atomic {
__u32 flags;
@@ -552,5 +565,4 @@ struct drm_mode_destroy_blob {
__u32 blob_id;
};
#endif

73
test/vpu_api_test.c
View File

@@ -73,15 +73,15 @@ typedef struct VpuApiEncInput {
} VpuApiEncInput;
static OptionInfo vpuApiCmd[] = {
{"i", "input_file", "input bitstream file"},
{"o", "output_file", "output bitstream file, "},
{"w", "width", "the width of input bitstream"},
{"h", "height", "the height of input bitstream"},
{"t", "codec_type", "the codec type, dec: deoder, enc: encoder, default: decoder"},
{"coding", "coding_type", "encoding type of the bitstream"},
{"vframes", "number", "set the number of video frames to record"},
{"ss", "time_off", "set the start time offset, use Ms as the unit."},
{"d", "disable", "disable the debug output info."},
{ "i", "input_file", "input bitstream file" },
{ "o", "output_file", "output bitstream file, " },
{ "w", "width", "the width of input bitstream" },
{ "h", "height", "the height of input bitstream" },
{ "t", "codec_type", "the codec type, dec: deoder, enc: encoder, default: decoder" },
{ "coding", "coding_type", "encoding type of the bitstream" },
{ "vframes", "number", "set the number of video frames to record" },
{ "ss", "time_off", "set the start time offset, use Ms as the unit." },
{ "d", "disable", "disable the debug output info." },
};
static void show_usage()
@@ -99,7 +99,7 @@ static RK_S32 show_help()
return 0;
}
static RK_S32 parse_options(int argc, char **argv, VpuApiDemoCmdContext_t* cmdCxt)
static RK_S32 parse_options(int argc, char **argv, VpuApiDemoCmdContext_t *cmdCxt)
{
char *opt;
RK_S32 optindex, handleoptions = 1, ret = 0;
@@ -219,7 +219,7 @@ PARSE_OPINIONS_OUT:
return ret;
}
static RK_S32 readBytesFromFile(RK_U8* buf, RK_S32 aBytes, FILE* file)
static RK_S32 readBytesFromFile(RK_U8 *buf, RK_S32 aBytes, FILE *file)
{
RK_S32 ret = 0;
@@ -238,8 +238,8 @@ static RK_S32 readBytesFromFile(RK_U8* buf, RK_S32 aBytes, FILE* file)
static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
{
FILE* pInFile = NULL;
FILE* pOutFile = NULL;
FILE *pInFile = NULL;
FILE *pOutFile = NULL;
struct VpuCodecContext *ctx = NULL;
RK_S32 nal = 0x00000001;
RK_S32 fileSize, ret, size;
@@ -292,7 +292,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
}
#ifdef FOR_TEST_ENCODE
ctx = (struct VpuCodecContext*)malloc(sizeof(struct VpuCodecContext));
ctx = (struct VpuCodecContext *)malloc(sizeof(struct VpuCodecContext));
if (!ctx) {
mpp_err("Input context has not been properly allocated");
return -1;
@@ -315,7 +315,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
memset(&enc_out_yuv, 0, sizeof(EncoderOut_t));
enc_out = &enc_out_yuv;
enc_out->data = (RK_U8*)malloc(cmd->width * cmd->height);
enc_out->data = (RK_U8 *)malloc(cmd->width * cmd->height);
if (enc_out->data == NULL) {
ENCODE_ERR_RET(ERROR_MEMORY);
}
@@ -338,7 +338,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
ctx->private_data = malloc(sizeof(EncParameter_t));
memset(ctx->private_data, 0, sizeof(EncParameter_t));
enc_param = (EncParameter_t*)ctx->private_data;
enc_param = (EncParameter_t *)ctx->private_data;
enc_param->width = cmd->width;
enc_param->height = cmd->height;
enc_param->format = ENC_INPUT_YUV420_PLANAR;
@@ -404,7 +404,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
if (enc_in && (enc_in->size == 0)) {
if (enc_in->buf == NULL) {
enc_in->buf = (RK_U8*)(malloc)(size);
enc_in->buf = (RK_U8 *)(malloc)(size);
if (enc_in->buf == NULL) {
ENCODE_ERR_RET(ERROR_MEMORY);
}
@@ -412,7 +412,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
}
if (api_enc_in->capability < ((RK_U32)size)) {
enc_in->buf = (RK_U8*)(realloc)((void*)(enc_in->buf), size);
enc_in->buf = (RK_U8 *)(realloc)((void *)(enc_in->buf), size);
if (enc_in->buf == NULL) {
ENCODE_ERR_RET(ERROR_MEMORY);
}
@@ -428,7 +428,7 @@ static RK_S32 vpu_encode_demo(VpuApiDemoCmdContext_t *cmd)
}
mpp_log("read one frame, size: %d, timeUs: %lld, filePos: %ld\n",
enc_in->size, enc_in->timeUs , ftell(pInFile));
enc_in->size, enc_in->timeUs, ftell(pInFile));
}
if ((ret = ctx->encode(ctx, enc_in, enc_out)) < 0) {
@@ -495,19 +495,19 @@ ENCODE_OUT:
static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
{
FILE* pInFile = NULL;
FILE* pOutFile = NULL;
struct VpuCodecContext* ctx = NULL;
FILE *pInFile = NULL;
FILE *pOutFile = NULL;
struct VpuCodecContext *ctx = NULL;
RK_S32 fileSize = 0, pkt_size = 0;
RK_S32 ret = 0;
RK_U32 frame_count = 0;
DecoderOut_t decOut;
VideoPacket_t demoPkt;
VideoPacket_t* pkt = NULL;
VideoPacket_t *pkt = NULL;
DecoderOut_t *pOut = NULL;
VPU_FRAME *frame = NULL;
RK_S64 fakeTimeUs = 0;
RK_U8* pExtra = NULL;
RK_U8 *pExtra = NULL;
RK_U32 extraSize = 0;
RK_U32 wAlign16 = 0;
RK_U32 hAlign16 = 0;
@@ -563,7 +563,7 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
memset(&decOut, 0, sizeof(DecoderOut_t));
pOut = &decOut;
pOut->data = (RK_U8*)(malloc)(sizeof(VPU_FRAME));
pOut->data = (RK_U8 *)(malloc)(sizeof(VPU_FRAME));
if (pOut->data == NULL) {
DECODE_ERR_RET(ERROR_MEMORY);
}
@@ -577,13 +577,13 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
/*
** read codec extra data from input stream file.
*/
if (readBytesFromFile((RK_U8*)(&extraSize), 4, pInFile)) {
if (readBytesFromFile((RK_U8 *)(&extraSize), 4, pInFile)) {
DECODE_ERR_RET(ERROR_IO);
}
mpp_log("codec extra data size: %d\n", extraSize);
pExtra = (RK_U8*)(malloc)(extraSize);
pExtra = (RK_U8 *)(malloc)(extraSize);
if (pExtra == NULL) {
DECODE_ERR_RET(ERROR_MEMORY);
}
@@ -620,12 +620,12 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
}
if (pkt && (pkt->size == 0)) {
if (readBytesFromFile((RK_U8*)(&pkt_size), 4, pInFile)) {
if (readBytesFromFile((RK_U8 *)(&pkt_size), 4, pInFile)) {
break;
}
if (pkt->data == NULL) {
pkt->data = (RK_U8*)(malloc)(pkt_size);
pkt->data = (RK_U8 *)(malloc)(pkt_size);
if (pkt->data == NULL) {
DECODE_ERR_RET(ERROR_MEMORY);
}
@@ -633,7 +633,7 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
}
if (pkt->capability < ((RK_U32)pkt_size)) {
pkt->data = (RK_U8*)(realloc)((void*)(pkt->data), pkt_size);
pkt->data = (RK_U8 *)(realloc)((void *)(pkt->data), pkt_size);
if (pkt->data == NULL) {
DECODE_ERR_RET(ERROR_MEMORY);
}
@@ -655,7 +655,14 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
/* note: must set out put size to 0 before do decoder. */
pOut->size = 0;
if ((ret = ctx->decode(ctx, pkt, pOut)) != 0) {
if (ctx->decode_sendstream(ctx, pkt) != 0) {
mpp_log("send packet failed");
DECODE_ERR_RET(ERROR_VPU_DECODE);
}
if ((ret = ctx->decode_getframe(ctx, pOut)) != 0) {
mpp_log("get decoded data failed\n");
DECODE_ERR_RET(ERROR_VPU_DECODE);
} else {
mpp_log("vpu decode one frame, out len: %d, left size: %d\n",
@@ -677,7 +684,7 @@ static RK_S32 vpu_decode_demo(VpuApiDemoCmdContext_t *cmd)
mpp_log("write %d frame(yuv420sp) data, %d bytes to file\n",
frame_count, frameSize);
fwrite((RK_U8*)(frame->vpumem.vir_addr), 1, frameSize, pOutFile);
fwrite((RK_U8 *)(frame->vpumem.vir_addr), 1, frameSize, pOutFile);
fflush(pOutFile);
}
@@ -743,7 +750,7 @@ int main(int argc, char **argv)
}
cmd = &demoCmdCtx;
memset (cmd, 0, sizeof(VpuApiDemoCmdContext_t));
memset(cmd, 0, sizeof(VpuApiDemoCmdContext_t));
cmd->codec_type = CODEC_DECODER;
if ((ret = parse_options(argc, argv, cmd)) != 0) {
if (ret == VPU_DEMO_PARSE_HELP_OK) {