BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3428a94f6b57d8d41235a742c5b29defce11fc93
BPI-CM9-Linux/aml-comp/hardware/aml-5.15/amlogic/media_modules/tools/player/vcodec.c
T

961 lines
28 KiB
C
Raw Normal View History

Import complete source tree
2026-08-13 11:28:40 +08:00
/*
* Copyright (c) 2014 Amlogic, Inc. All rights reserved.
*
* This source code is subject to the terms and conditions defined in the
* file 'LICENSE' which is part of this source code package.
*
* Description:
*/
/**
* @file codec_ctrl.c
* @brief Codec control lib functions
*
* @version 1.0.0
* @date 2011-02-24
*/
/* Copyright (C) 2007-2011, Amlogic Inc.
* All right reserved
*
*/
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include "vcodec.h"
#ifdef ANDROID
#include <android/log.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#define LOG_TAG "amcodec"
#define CODEC_PRINT(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#else
#define CODEC_PRINT(f,s...) fprintf(stderr,f,##s)
#endif
#define msleep(n) usleep(n*1000)
// ports
#define CODEC_VIDEO_ES_DEVICE "/dev/amstream_vbuf"
#define CODEC_VIDEO_ES_DEVICE_SCHED "/dev/amstream_vbuf_sched"
#define CODEC_VIDEO_ES_HEVC_DEVICE_SCHED "/dev/amstream_hevc_sched"
#define CODEC_TS_DEVICE "/dev/amstream_mpts"
#define CODEC_PS_DEVICE "/dev/amstream_mpps"
#define CODEC_RM_DEVICE "/dev/amstream_rm"
#define CODEC_VIDEO_HEVC_DEVICE "/dev/amstream_hevc"
#define CODEC_VIDEO_DVAVC_DEVICE "/dev/amstream_dves_avc"
#define CODEC_VIDEO_DVHEVC_DEVICE "/dev/amstream_dves_hevc"
#define CODEC_CNTL_DEVICE "/dev/amvideo"
#define CODEC_VIDEO_FRAME_DEVICE "/dev/amstream_vframe"
#define CODEC_HEVC_FRAME_DEVICE "/dev/amstream_hevc_frame"
/*#define CODEC_VIDEO_DVAV1_DEVICE "/dev/amstream_dves_av1"*/
// ioctl
#define AMSTREAM_IOC_MAGIC 'S'
#define AMSTREAM_IOC_VB_SIZE _IOW((AMSTREAM_IOC_MAGIC), 0x01, int)
#define AMSTREAM_IOC_VFORMAT _IOW((AMSTREAM_IOC_MAGIC), 0x04, int)
#define AMSTREAM_IOC_VID _IOW((AMSTREAM_IOC_MAGIC), 0x06, int)
#define AMSTREAM_IOC_VB_STATUS _IOR((AMSTREAM_IOC_MAGIC), 0x08, int)
#define AMSTREAM_IOC_SYSINFO _IOW((AMSTREAM_IOC_MAGIC), 0x0a, int)
#define AMSTREAM_IOC_PORT_INIT _IO((AMSTREAM_IOC_MAGIC), 0x11)
#define AMSTREAM_IOC_VPAUSE _IOW((AMSTREAM_IOC_MAGIC), 0x17, int)
#define AMSTREAM_IOC_SET_DRMMODE _IOW((AMSTREAM_IOC_MAGIC), 0x91, int)
#define AMSTREAM_IOC_GET_VERSION _IOR((AMSTREAM_IOC_MAGIC), 0xc0, int)
#define AMSTREAM_IOC_GET _IOWR((AMSTREAM_IOC_MAGIC), 0xc1, struct am_ioctl_parm)
#define AMSTREAM_IOC_SET _IOW((AMSTREAM_IOC_MAGIC), 0xc2, struct am_ioctl_parm)
#define AMSTREAM_IOC_GET_EX _IOWR((AMSTREAM_IOC_MAGIC), 0xc3, struct am_ioctl_parm_ex)
#define AMSTREAM_IOC_SET_CRC _IOW((AMSTREAM_IOC_MAGIC), 0xc9, struct usr_crc_info_t)
#define AMSTREAM_IOC_GET_CRC_CMP_RESULT _IOWR((AMSTREAM_IOC_MAGIC), 0xca, int)
// cmds
#define AMSTREAM_SET_VB_SIZE 0x102
#define AMSTREAM_SET_VFORMAT 0x105
#define AMSTREAM_SET_VID 0x107
#define AMSTREAM_PORT_INIT 0x111
#define AMSTREAM_SET_DRMMODE 0x11C
#define AMSTREAM_GET_EX_VB_STATUS 0x900
#define AMSTREAM_GET_EX_VDECSTAT 0x902
struct am_ioctl_parm {
union {
unsigned int data_32;
unsigned long long data_64;
int data_vformat;
char data[8];
};
unsigned int cmd;
char reserved[4];
};
struct am_io_param {
union {
int data;
int id;
};
int len;
union {
char buf[1];
struct buf_status status;
};
};
struct am_ioctl_parm_ex {
union {
struct buf_status status;
struct vdec_status vstatus;
char data[24];
};
unsigned int cmd;
char reserved[4];
};
struct vcodec_amd_table {
unsigned int cmd;
unsigned int parm_cmd;
};
static struct vcodec_amd_table cmd_tables[] = {
/*amstream*/
{ AMSTREAM_IOC_VB_SIZE, AMSTREAM_SET_VB_SIZE },
{ AMSTREAM_IOC_VFORMAT, AMSTREAM_SET_VFORMAT },
{ AMSTREAM_IOC_VID, AMSTREAM_SET_VID },
{ AMSTREAM_IOC_VB_STATUS, AMSTREAM_GET_EX_VB_STATUS },
{ AMSTREAM_IOC_PORT_INIT, AMSTREAM_PORT_INIT },
{ AMSTREAM_IOC_SET_DRMMODE, AMSTREAM_SET_DRMMODE },
{ 0, 0 },
};
static int support_new_cmd = 0;
static void vcodec_h_set_support_new_cmd(int value)
{
support_new_cmd = value;
}
static int vcodec_h_is_support_new_cmd()
{
return support_new_cmd;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_open Open codec devices by file name
*
* @param[in] port_addr File name of codec device
* @param[in] flags Open flags
*
* @return The handler of codec device
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_open(const char *port_addr, int flags)
{
int r;
int retry_open_times = 0;
retry_open:
r = open(port_addr, flags);
if (r < 0 /*&& r == EBUSY */) {
//--------------------------------
retry_open_times++;
if (retry_open_times == 1) {
CODEC_PRINT("Init [%s] failed,ret = %d error=%d retry_open!\n", port_addr, r, errno);
}
msleep(10);
if (retry_open_times < 1000) {
goto retry_open;
}
CODEC_PRINT("retry_open [%s] failed,ret = %d error=%d used_times=%d*10(ms)\n", port_addr, r, errno, retry_open_times);
//--------------------------------
//CODEC_PRINT("Init [%s] failed,ret = %d error=%d\n", port_addr, r, errno);
return r;
}
if (retry_open_times > 0) {
CODEC_PRINT("retry_open [%s] success,ret = %d error=%d used_times=%d*10(ms)\n", port_addr, r, errno, retry_open_times);
}
return (int)r;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_close Close codec devices
*
* @param[in] h Handler of codec device
*
* @return 0 for success
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_close(int h)
{
int r;
if (h >= 0) {
r = close(h);
if (r < 0) {
CODEC_PRINT("close failed,handle=%d,ret=%d errno=%d\n", h, r, errno);
}
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_control IOCTL commands for codec devices
*
* @param[in] h Codec device handler
* @param[in] cmd IOCTL commands
* @param[in] parameter IOCTL commands parameter
*
* @return 0 for success, non-0 for fail
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_control(int h, int cmd, unsigned long parameter)
{
int r;
if (h < 0) {
return -1;
}
r = ioctl(h, cmd, parameter);
if (r < 0) {
CODEC_PRINT("send control failed,handle=%d,cmd=%x,parameter=%lx, t=%x errno=%d\n", h, cmd, parameter, r, errno);
return r;
}
return 0;
}
static int vcodec_h_ioctl_set(int h, int subcmd, unsigned long parameter)
{
int r;
int cmd_new = AMSTREAM_IOC_SET;
unsigned long parm_new;
switch (subcmd) {
case AMSTREAM_SET_VB_SIZE:
case AMSTREAM_SET_VID:
case AMSTREAM_SET_DRMMODE: {
struct am_ioctl_parm parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm.data_32 = parameter;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
}
break;
case AMSTREAM_SET_VFORMAT: {
struct am_ioctl_parm parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm.data_vformat = parameter;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
}
break;
case AMSTREAM_PORT_INIT: {
struct am_ioctl_parm parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
}
break;
default: {
struct am_ioctl_parm parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm.data_32 = parameter;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
}
break;
}
if (r < 0) {
CODEC_PRINT("vcodec_h_ioctl_set failed,handle=%d,cmd=%x,parameter=%lx, t=%x errno=%d\n", h, subcmd, parameter, r, errno);
return r;
}
return 0;
}
static int vcodec_h_ioctl_get(int h, int subcmd, unsigned long parameter)
{
int r;
struct am_ioctl_parm parm;
unsigned long parm_new;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm.data_32 = *(unsigned int *)parameter;
parm_new = (unsigned long)&parm;
r = ioctl(h, AMSTREAM_IOC_GET, parm_new);
if (r < 0) {
CODEC_PRINT("vcodec_h_ioctl_get failed,handle=%d,subcmd=%x,parameter=%lx, t=%x errno=%d\n", h, subcmd, parameter, r, errno);
return r;
}
if (parameter != 0) {
*(unsigned int *)parameter = parm.data_32;
}
return 0;
}
static int get_old_cmd(unsigned int cmd)
{
struct vcodec_amd_table *p;
for (p = cmd_tables; p->cmd; p++) {
if (p->parm_cmd == cmd) {
return p->cmd;
}
}
return -1;
}
static int vcodec_h_ioctl_get_ex(int h, int subcmd, unsigned long parameter)
{
int r;
int cmd_new = AMSTREAM_IOC_GET_EX;
unsigned long parm_new;
switch (subcmd) {
case AMSTREAM_GET_EX_VB_STATUS: {
struct am_ioctl_parm_ex parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
if (r >= 0 && parameter != 0) {
memcpy((void *)parameter, &parm.status, sizeof(struct buf_status));
}
}
break;
case AMSTREAM_GET_EX_VDECSTAT: {
struct am_ioctl_parm_ex parm;
memset(&parm, 0, sizeof(parm));
parm.cmd = subcmd;
parm_new = (unsigned long)&parm;
r = ioctl(h, cmd_new, parm_new);
if (r >= 0 && parameter != 0) {
memcpy((void *)parameter, &parm.vstatus, sizeof(struct vdec_status));
}
}
break;
default:
r = -1;
break;
}
if (r < 0) {
CODEC_PRINT("vcodec_h_ioctl_get_ex failed,handle=%d,subcmd=%x,parameter=%lx, t=%x errno=%d\n", h, subcmd, parameter, r, errno);
return r;
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_control IOCTL commands for codec devices
*
* @param[in] h Codec device handler
* @param[in] cmd IOCTL commands
* @param[in] parameter IOCTL commands parameter
*
* @return 0 for success, non-0 for fail
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_ioctl(int h, unsigned int cmd, unsigned int subcmd, unsigned long parameter)
{
int r;
if (h < 0) {
return -1;
}
if (!vcodec_h_is_support_new_cmd()) {
int old_cmd = get_old_cmd(subcmd);
if (old_cmd == -1) {
return -1;
}
return vcodec_h_control(h, old_cmd, parameter);
}
switch (cmd) {
case AMSTREAM_IOC_SET:
r = vcodec_h_ioctl_set(h, subcmd, parameter);
break;
case AMSTREAM_IOC_GET:
r = vcodec_h_ioctl_get(h, subcmd, parameter);
break;
case AMSTREAM_IOC_GET_EX:
r = vcodec_h_ioctl_get_ex(h, subcmd, parameter);
break;
default:
r = ioctl(h, cmd, parameter);
break;
}
if (r < 0) {
CODEC_PRINT("vcodec_h_ioctl failed,handle=%d,cmd=%x,subcmd=%x, parameter=%lx, t=%x errno=%d\n", h, cmd, subcmd, parameter, r, errno);
return r;
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_read Read data from codec devices
*
* @param[in] handle Codec device handler
* @param[out] buffer Buffer for the data read from codec device
* @param[in] size Size of the data to be read
*
* @return read length or fail if < 0
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_read(int handle, void *buffer, int size)
{
int r;
r = read(handle, buffer, size);
if (r < 0) {
CODEC_PRINT("read failed,handle=%d,ret=%d errno=%d\n", handle, r, errno);
}
return r;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_h_write Write data to codec devices
*
* @param[in] handle Codec device handler
* @param[out] buffer Buffer for the data to be written to codec device
* @param[in] size Size of the data to be written
*
* @return write length or fail if < 0
*/
/* --------------------------------------------------------------------------*/
static int vcodec_h_write(int handle, void *buffer, int size)
{
int r;
r = write(handle, buffer, size);
if (r < 0 && errno != EAGAIN) {
CODEC_PRINT("write failed,handle=%d,ret=%d errno=%d\n", handle, r, errno);
}
return r;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_change_buf_size Change buffer size of codec device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return Success of fail error type
*/
/* --------------------------------------------------------------------------*/
static int vcodec_change_buf_size(vcodec_para_t *pcodec)
{
int r;
if (pcodec->vbuf_size > 0) {
r = vcodec_h_ioctl(pcodec->handle, AMSTREAM_IOC_SET, AMSTREAM_SET_VB_SIZE, pcodec->vbuf_size);
if (r < 0) {
return r;
}
}
return CODEC_ERROR_NONE;
}
/* --------------------------------------------------------------------------*/
/**
* @brief set_video_format Set video format to codec device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return 0 for success, or error type
*/
/* --------------------------------------------------------------------------*/
static int set_video_format(vcodec_para_t *pcodec)
{
int format = pcodec->video_type;
int r;
if (format < 0 || format > VFORMAT_MAX) {
return -CODEC_ERROR_VIDEO_TYPE_UNKNOWN;
}
r = vcodec_h_ioctl(pcodec->handle, AMSTREAM_IOC_SET, AMSTREAM_SET_VFORMAT, format);
if (pcodec->video_pid >= 0) {
r = vcodec_h_ioctl(pcodec->handle, AMSTREAM_IOC_SET, AMSTREAM_SET_VID, pcodec->video_pid);
if (r < 0) {
return r;
}
}
if (r < 0) {
return r;
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief set_video_vcodec_info Set video information(width, height...) to codec device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return 0 for success, or error type
*/
/* --------------------------------------------------------------------------*/
static int set_video_codec_info(vcodec_para_t *pcodec)
{
dec_sysinfo_t am_sysinfo = pcodec->am_sysinfo;
int r;
r = vcodec_h_control(pcodec->handle, AMSTREAM_IOC_SYSINFO, (unsigned long)&am_sysinfo);
if (r < 0) {
return r;
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_check_new_cmd Check new cmd for ioctl
*
*/
/* --------------------------------------------------------------------------*/
static inline void vcodec_check_new_cmd(int handle)
{
if (!vcodec_h_is_support_new_cmd()) {
int r;
int version = 0;
r = vcodec_h_control(handle, AMSTREAM_IOC_GET_VERSION, (unsigned long)&version);
if ((r == 0) && (version >= 0x20000)) {
CODEC_PRINT("vcodec_init amstream version : %d.%d\n", (version & 0xffff0000) >> 16, version & 0xffff);
vcodec_h_set_support_new_cmd(1);
} else {
CODEC_PRINT("vcodec_init amstream use old cmd\n");
vcodec_h_set_support_new_cmd(0);
}
}
}
static int vcodec_set_drmmode(vcodec_para_t *pcodec, unsigned int setval)
{
return vcodec_h_ioctl(pcodec->handle, AMSTREAM_IOC_SET, AMSTREAM_SET_DRMMODE, setval);
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_get_vbuf_state Get the state of video buffer by codec device
*
* @param[in] p Pointer of codec parameter structure
* @param[out] buf Pointer of buffer status structure to get video buffer state
*
* @return Success or fail type
*/
/* --------------------------------------------------------------------------*/
int vcodec_get_vbuf_state(vcodec_para_t *p, struct buf_status *buf)
{
int r;
if (vcodec_h_is_support_new_cmd()) {
struct buf_status status;
r = vcodec_h_ioctl(p->handle, AMSTREAM_IOC_GET_EX, AMSTREAM_GET_EX_VB_STATUS, (unsigned long)&status);
memcpy(buf, &status, sizeof(*buf));
} else {
struct am_io_param am_io;
r = vcodec_h_control(p->handle, AMSTREAM_IOC_VB_STATUS, (unsigned long)&am_io);
memcpy(buf, &am_io.status, sizeof(*buf));
}
return r;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_video_es_init Initialize the codec device for es video
*
* @param[in] pcodec Pointer of codec parameter structure
* sched Chose single mode device or stream mode device
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
static inline int vcodec_video_es_init(vcodec_para_t *pcodec, int sched)
{
int handle;
int r;
int codec_r;
int flags = O_WRONLY;
char *amstream_dev = CODEC_VIDEO_ES_DEVICE;
if (!pcodec->has_video) {
return CODEC_ERROR_NONE;
}
flags |= pcodec->noblock ? O_NONBLOCK : 0;
if (pcodec->video_type == VFORMAT_AV1) {
if (sched == FRAME_MODE)
amstream_dev = CODEC_HEVC_FRAME_DEVICE; //av1 hevc frame mode
else
amstream_dev = CODEC_VIDEO_HEVC_DEVICE;
} else if (pcodec->video_type == VFORMAT_HEVC ||
pcodec->video_type == VFORMAT_VP9 ||
pcodec->video_type == VFORMAT_AVS2 ||
pcodec->video_type == VFORMAT_AVS3 ||
pcodec->video_type == VFORMAT_H266) {
if (sched != SINGLE_MODE)
amstream_dev = CODEC_VIDEO_ES_HEVC_DEVICE_SCHED;
else
amstream_dev = CODEC_VIDEO_HEVC_DEVICE;
if ((pcodec->amld_enable) && (pcodec->video_type == VFORMAT_HEVC))
amstream_dev = CODEC_VIDEO_DVHEVC_DEVICE;
} else {
if ((pcodec->video_type == VFORMAT_H264) ||
(pcodec->video_type == VFORMAT_MPEG12) ||
(pcodec->video_type == VFORMAT_MPEG4) ||
(pcodec->video_type == VFORMAT_MJPEG)) {
if (sched != SINGLE_MODE)
amstream_dev = CODEC_VIDEO_ES_DEVICE_SCHED;
else
amstream_dev = CODEC_VIDEO_ES_DEVICE;
} else
amstream_dev = CODEC_VIDEO_ES_DEVICE;
if (pcodec->video_type == VFORMAT_H264 && pcodec->amld_enable)
amstream_dev = CODEC_VIDEO_DVAVC_DEVICE;
}
printf("vcodec open device %s \n", amstream_dev);
handle = vcodec_h_open(amstream_dev, flags);
if (handle < 0) {
return CODEC_OPEN_HANDLE_FAILED;
}
pcodec->handle = handle;
vcodec_check_new_cmd(handle);
r = set_video_format(pcodec);
if (r < 0) {
vcodec_h_close(handle);
codec_r = r;
CODEC_PRINT("%d,%s,%d\n", errno, __FUNCTION__, __LINE__);
return codec_r;
}
r = set_video_codec_info(pcodec);
if (r < 0) {
vcodec_h_close(handle);
codec_r = r;
CODEC_PRINT("%d,%s,%d\n", errno, __FUNCTION__, __LINE__);
return codec_r;
}
r = vcodec_set_drmmode(pcodec, pcodec->drmmode);
if (r < 0) {
vcodec_h_close(handle);
codec_r = r;
CODEC_PRINT("%d,%s,%d\n", errno, __FUNCTION__, __LINE__);
return codec_r;
}
return CODEC_ERROR_NONE;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_init Initialize the codec device based on stream type
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_init(vcodec_para_t *pcodec)
{
int ret;
pcodec->handle = -1;
pcodec->cntl_handle = -1;
switch (pcodec->stream_type) {
case STREAM_TYPE_ES_VIDEO:
ret = vcodec_video_es_init(pcodec, pcodec->mode);
break;
case STREAM_TYPE_UNKNOWN:
default:
return -CODEC_ERROR_STREAM_TYPE_UNKNOWN;
}
if (ret != 0) {
return ret;
}
ret = vcodec_init_cntl(pcodec);
if (ret != CODEC_ERROR_NONE) {
return ret;
}
ret = vcodec_change_buf_size(pcodec);
if (ret != 0) {
return -CODEC_ERROR_SET_BUFSIZE_FAILED;
}
ret = vcodec_h_ioctl(pcodec->handle, AMSTREAM_IOC_SET, AMSTREAM_PORT_INIT, 0);
if (ret != 0) {
return -CODEC_ERROR_INIT_FAILED;
}
return ret;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_write Write data to codec device
*
* @param[in] pcodec Pointer of codec parameter structure
* @param[in] buffer Buffer for data to be written
* @param[in] len Length of the data to be written
*
* @return Length of the written data, or fail if < 0
*/
/* --------------------------------------------------------------------------*/
int vcodec_write(vcodec_para_t *pcodec, void *buffer, int len)
{
return vcodec_h_write(pcodec->handle, buffer, len);
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_read Read data from codec device
*
* @param[in] pcodec Pointer of codec parameter structure
* @param[out] buffer Buffer for data read from codec device
* @param[in] len Length of the data to be read
*
* @return Length of the read data, or fail if < 0
*/
/* --------------------------------------------------------------------------*/
int vcodec_read(vcodec_para_t *pcodec, void *buffer, int len)
{
return vcodec_h_read(pcodec->handle, buffer, len);
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_close Close codec device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return 0 for success, or fail type if < 0
*/
/* --------------------------------------------------------------------------*/
int vcodec_close(vcodec_para_t *pcodec)
{
int res = 0;
res |= vcodec_close_cntl(pcodec);
res |= vcodec_h_close(pcodec->handle);
return res;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_pause Pause all playing(A/V) by codec device
*
* @param[in] p Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_pause(vcodec_para_t *p)
{
int ret = CODEC_ERROR_NONE;
if (p) {
if (p->has_video) {
ret = vcodec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 1);
}
} else {
ret = CODEC_ERROR_PARAMETER;
}
return ret;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_resume Resume playing(A/V) by codec device
*
* @param[in] p Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_resume(vcodec_para_t *p)
{
int ret = CODEC_ERROR_NONE;
if (p) {
if (p->has_video) {
ret = vcodec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 0);
}
} else {
ret = CODEC_ERROR_PARAMETER;
}
return ret;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_reset Reset codec device
*
* @param[in] p Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_reset(vcodec_para_t *p)
{
int ret;
ret = vcodec_close(p);
if (ret != 0) {
return ret;
}
ret = vcodec_init(p);
CODEC_PRINT("[%s:%d]ret=%x\n", __FUNCTION__, __LINE__, ret);
return ret;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_init_cntl Initialize the video control device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_init_cntl(vcodec_para_t *pcodec)
{
int cntl;
cntl = vcodec_h_open(CODEC_CNTL_DEVICE, O_RDWR);
if (cntl < 0) {
CODEC_PRINT("get %s failed\n", CODEC_CNTL_DEVICE);
return cntl;
}
pcodec->cntl_handle = cntl;
return CODEC_ERROR_NONE;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_close_cntl Close video control device
*
* @param[in] pcodec Pointer of codec parameter structure
*
* @return Success or fail error type
*/
/* --------------------------------------------------------------------------*/
int vcodec_close_cntl(vcodec_para_t *pcodec)
{
int res = CODEC_ERROR_NONE;
if (pcodec) {
if (pcodec->cntl_handle) {
res = vcodec_h_close(pcodec->cntl_handle);
}
}
return res;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_set_frame_cmp_crc write every frame crc for compare;
*
* @param[in] pcodec Pointer of codec parameter structure, crc poll pointer and size
*
* @return Success or fail error
*/
/* --------------------------------------------------------------------------*/
int vcodec_set_frame_cmp_crc(vcodec_para_t *vcodec, const int *crc, int size, int id)
{
int ret = -1;
struct usr_crc_info_t crc_info;
int i;
if (vcodec == NULL)
return -1;
for (i = 0; i < size; i++) {
crc_info.id = id; /* only for one instance */
crc_info.pic_num = i;
crc_info.y_crc = crc[i * 2];
crc_info.uv_crc = crc[i * 2 + 1];
ret = vcodec_h_control(vcodec->handle,
AMSTREAM_IOC_SET_CRC, (unsigned long)&crc_info);
if (ret < 0) {
printf("set frame compare crc32 value failed, i = %d\n", i);
return -1;
}
}
return 0;
}
/* --------------------------------------------------------------------------*/
/**
* @brief vcodec_get_crc_check_result get all crc cmp result
*
* @param[in] pcodec Pointer of codec parameter structure, Vdec ID
*
* @return Success or fail error type, cmp result.
*/
/* --------------------------------------------------------------------------*/
int vcodec_get_crc_check_result(vcodec_para_t *vcodec, int vdec_id)
{
int ret, result = 0x00ff;
if (vcodec == NULL)
return -1;
result &= vdec_id; /*set the vdec id */
ret = vcodec_h_control(vcodec->handle,
AMSTREAM_IOC_GET_CRC_CMP_RESULT, (unsigned long)&result);
//printf("get result ret = %d, result = %d\n", ret, result);
if (ret < 0)
return ret;
return result;
}
/* --------------------------------------------------------------------------*/
/**
* @brief is_dec_cmp_ongoing require decoding and compare crc num;
*
* @param[in] pcodec Pointer of codec parameter structure, Vdec ID.
*
* @return Fail error type, or rest compare frame num;
*/
/* --------------------------------------------------------------------------*/
int is_crc_cmp_ongoing(vcodec_para_t *vcodec, int vdec_id)
{
int ret = 0;
int rest_num = 0xff00;
if (vcodec == NULL)
return -1;
rest_num |= vdec_id;
ret = vcodec_h_control(vcodec->handle,
AMSTREAM_IOC_GET_CRC_CMP_RESULT, (unsigned long)&rest_num);
if (ret < 0)
return ret;
return rest_num;
}
Reference in New Issue Copy Permalink