return ret;
}
-u_int32 insert_scode_4_seq(struct vpu_ctx *ctx, u_int8 *src, u_int8 *dst, u_int32 vdec_std, u_int32 uPayloadSize)
+bool check_free_size_4_seq(struct vpu_ctx *ctx, u_int32 uPayloadSize)
{
struct queue_data *q_data = &ctx->q_data[V4L2_SRC];
+ pSTREAM_BUFFER_DESCRIPTOR_TYPE pStrBufDesc;
+ u_int32 nfreespace = 0;
u_int32 length = 0;
- switch (vdec_std) {
+ switch (q_data->vdec_std) {
+ case VPU_VIDEO_VC1:
+ length = VC1_MAX_SEQ_HEADER_SIZE + 16;
+ break;
+ case VPU_VIDEO_VP6:
+ length = uPayloadSize + 32;
+ break;
+ case VPU_VIDEO_VP8:
+ length = uPayloadSize + 72;
+ break;
+ case VPU_VIDEO_ASP:
+ length = uPayloadSize + 16;
+ break;
+ case VPU_VIDEO_SPK:
+ length = uPayloadSize + 32;
+ break;
+ case VPU_VIDEO_RV:
+ length = uPayloadSize + 16;
+ break;
+ case VPU_VIDEO_AVC:
+ case VPU_VIDEO_MPEG2:
+ case VPU_VIDEO_AVS:
+ case VPU_VIDEO_JPEG:
+ case VPU_VIDEO_AVC_MVC:
+ case VPU_VIDEO_HEVC:
+ case VPU_VIDEO_UNDEFINED:
+ length = uPayloadSize;
+ break;
+ default:
+ break;
+ }
+
+ pStrBufDesc = get_str_buffer_desc(ctx);
+ nfreespace = got_free_space(pStrBufDesc->wptr, pStrBufDesc->rptr,
+ pStrBufDesc->start, pStrBufDesc->end);
+ if (nfreespace < (length + MIN_SPACE)) {
+ vpu_dbg(LVL_INFO, "buffer_full: the circular buffer freespace < buffer_size\n");
+ return false;
+ }
+
+ return true;
+}
+
+u_int32 insert_scode_4_seq(struct vpu_ctx *ctx, u_int8 *src, u_int32 uPayloadSize)
+{
+ struct queue_data *q_data = &ctx->q_data[V4L2_SRC];
+ u_int32 length = 0;
+
+ if (!check_free_size_4_seq(ctx, uPayloadSize))
+ return 0;
+
+ switch (q_data->vdec_std) {
case VPU_VIDEO_VC1: {
if (q_data->fourcc == V4L2_PIX_FMT_VC1_ANNEX_G) {
- u_int8 Header[VC1_MAX_SEQ_HEADER_SIZE];
+ u_int8 payload_header[32] = {0};
+ u_int8 Header[VC1_MAX_SEQ_HEADER_SIZE] = {0};
u_int32 uWidth = q_data->width;
u_int32 uHeight = q_data->height; //Width & Height in the generic payload header are ignored
u_int32 FrameSize = 0x60;
u_int32 HeaderLen, NoError = 1;
+
//insert startcode for vc1
- insert_payload_header_vc1(dst, SCODE_NEW_SEQUENCE, 20, uWidth, uHeight);
+ insert_payload_header_vc1(payload_header, SCODE_NEW_SEQUENCE, 20, uWidth, uHeight);
+ copy_buffer_to_stream(ctx, payload_header, 16);
length = 16;
//insert RCV sequence header for vc1 v1, length=20
insert_RCV_seqhdr(Header, &HeaderLen, src, FrameSize, uWidth, uHeight, &NoError);
HeaderLen = RCV_HEADER_LEN - 4;
- memcpy(dst + 16, Header, HeaderLen);
+ copy_buffer_to_stream(ctx, Header, HeaderLen);
length += HeaderLen;
} else {
- u_int8 Header[VC1_MAX_SEQ_HEADER_SIZE];
+ u_int8 Header[VC1_MAX_SEQ_HEADER_SIZE] = {0};
u_int32 HeaderLen;
-
VC1CreateNALSeqHeader(Header, &HeaderLen, src, uPayloadSize,
(unsigned int *)src, VC1_MAX_SEQ_HEADER_SIZE);
if (VC1_IS_NOT_NAL(((unsigned int *)src)[0]))
HeaderLen -= 4;
- memcpy(dst, Header, HeaderLen);
+ copy_buffer_to_stream(ctx, Header, HeaderLen);
length += HeaderLen;
}
}
-
break;
case VPU_VIDEO_VP6: {
- vp6_scd_sequence_header(dst, q_data->width, q_data->height);
+ u_int8 seq_header[16] = {0};
+ u_int8 frame_header[16] = {0};
+
+ vp6_scd_sequence_header(seq_header, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, seq_header, 16);
length = 16;
- vp6_scd_frame_header(dst + length, q_data->width, q_data->height, uPayloadSize);
+ vp6_scd_frame_header(frame_header, q_data->width, q_data->height, uPayloadSize);
+ copy_buffer_to_stream(ctx, frame_header, 16);
length += 16;
- memcpy(dst + length, src, uPayloadSize);
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
length += uPayloadSize;
}
break;
case VPU_VIDEO_VP8: {
- u_int8 seq_header[32] = {0};
- u_int8 frame_header[8] = {0};
+ u_int8 scd_seq_header[16] = {0};
+ u_int8 ivf_seq_header[32] = {0};
+ u_int8 scd_frame_header[16] = {0};
+ u_int8 ivf_frame_header[8] = {0};
- vp8_scd_sequence_header(dst, q_data->width, q_data->height);
+ vp8_scd_sequence_header(scd_seq_header, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, scd_seq_header, 16);
length = 16;
- vp8_ivf_sequence_header(seq_header, q_data->width, q_data->height);
- memcpy(dst+length, seq_header, 32);
+ vp8_ivf_sequence_header(ivf_seq_header, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, ivf_seq_header, 32);
length += 32;
- vp8_scd_frame_header(dst + length, q_data->width, q_data->height, uPayloadSize + 8);
+ vp8_scd_frame_header(scd_frame_header, q_data->width, q_data->height, uPayloadSize + 8);
+ copy_buffer_to_stream(ctx, scd_frame_header, 16);
length += 16;
- vp8_ivf_frame_header(frame_header, uPayloadSize);
- memcpy(dst+length, frame_header, 8);
+ vp8_ivf_frame_header(ivf_frame_header, uPayloadSize);
+ copy_buffer_to_stream(ctx, ivf_frame_header, 8);
length += 8;
- memcpy(dst+length, src, uPayloadSize);
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
length += uPayloadSize;
}
break;
case VPU_VIDEO_ASP: {
if (q_data->fourcc == VPU_PIX_FMT_DIV3) {
- insert_payload_header_divx(dst, uPayloadSize, q_data->width, q_data->height);
+ u_int8 seq_header[16] = {0};
+
+ insert_payload_header_divx(seq_header, uPayloadSize, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, seq_header, 16);
length = 16;
- memcpy(dst+length, src, uPayloadSize);
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
length += uPayloadSize;
+ } else {
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
+ length = uPayloadSize;
}
}
break;
case VPU_VIDEO_SPK: {
+ u_int8 seq_header[16] = {0};
u_int8 frame_header[16] = {0};
- insert_seq_header_spk(dst, 0, q_data->width, q_data->height);
+
+ insert_seq_header_spk(seq_header, 0, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, seq_header, 16);
length = 16;
insert_frame_header_spk(frame_header, uPayloadSize, q_data->width, q_data->height);
- memcpy(dst+length, frame_header, 16);
+ copy_buffer_to_stream(ctx, frame_header, 16);
length += 16;
- memcpy(dst+length, src, uPayloadSize);
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
length += uPayloadSize;
}
break;
case VPU_VIDEO_RV: {
+ u_int8 seq_header[16] = {0};
+
if (strncmp((const char *)(src+8), "RV30", 4) == 0)
ctx->arv_type = ARV_8;
else
ctx->arv_type = ARV_9;
- insert_payload_header_arv(dst, SCODE_NEW_SEQUENCE, ctx->arv_type, uPayloadSize + 12, q_data->width, q_data->height);
+ insert_payload_header_arv(seq_header, SCODE_NEW_SEQUENCE, ctx->arv_type, uPayloadSize + 12, q_data->width, q_data->height);
+ copy_buffer_to_stream(ctx, seq_header, 16);
length = 16;
- memcpy(dst+length, src, uPayloadSize);
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
length += uPayloadSize;
}
break;
- default:
+ case VPU_VIDEO_AVC:
+ case VPU_VIDEO_MPEG2:
+ case VPU_VIDEO_AVS:
+ case VPU_VIDEO_JPEG:
+ case VPU_VIDEO_AVC_MVC:
+ case VPU_VIDEO_HEVC:
+ case VPU_VIDEO_UNDEFINED: {
+ copy_buffer_to_stream(ctx, src, uPayloadSize);
+ length = uPayloadSize;
+ }
break;
+ default:
+ break;
}
return length;
}
#define VC1_MAX_SEQ_HEADER_SIZE 256
u_int32 insert_scode_4_pic(struct vpu_ctx *ctx, u_int8 *dst, u_int8 *src, u_int32 vdec_std, u_int32 uPayloadSize);
-u_int32 insert_scode_4_seq(struct vpu_ctx *ctx, u_int8 *src, u_int8 *dst, u_int32 vdec_std, u_int32 uPayloadSize);
+u_int32 insert_scode_4_seq(struct vpu_ctx *ctx, u_int8 *src, u_int32 uPayloadSize);
u_int32 insert_scode_4_arv_slice(struct vpu_ctx *ctx, u_int8 *dst, struct VPU_FMT_INFO_ARV *arv_frame, u_int32 uPayloadSize);
struct VPU_FMT_INFO_ARV *get_arv_info(struct vpu_ctx *ctx, u_int8 *src, u_int32 size);
void put_arv_info(struct VPU_FMT_INFO_ARV *arv_frame);
static bool verify_frame_buffer_size(struct queue_data *q_data,
struct vb2_data_req *p_data_req);
static void add_buffer_to_queue(struct queue_data *q_data, struct vb2_data_req *data_req);
-static int copy_buffer_to_stream(struct vpu_ctx *ctx, void *buffer, uint32_t length);
static int send_abort_cmd(struct vpu_ctx *ctx);
static int send_stop_cmd(struct vpu_ctx *ctx);
static int vpu_dec_cmd_reset(struct vpu_ctx *ctx);
return DEC_MFD_XREG_SLV_BASE + MFD_MCX + MFD_MCX_OFF * ctx->str_index;
}
-static pSTREAM_BUFFER_DESCRIPTOR_TYPE get_str_buffer_desc(struct vpu_ctx *ctx)
+pSTREAM_BUFFER_DESCRIPTOR_TYPE get_str_buffer_desc(struct vpu_ctx *ctx)
{
pSTREAM_BUFFER_DESCRIPTOR_TYPE pStrBufDesc;
vpu_dec_request_cmd(ctx, idx, cmdid, cmdnum, local_cmddata);
}
-static void dump_input_data_to_local(struct vpu_ctx *ctx, void *src, u_int32 len, u_int32 first_flag)
+static void dump_input_data_to_local(struct vpu_ctx *ctx, void *src, u_int32 len)
{
struct file *fp;
mm_segment_t fs;
scnprintf(input_file, sizeof(input_file) - 1,
"/tmp/vpu_input_data_%d.bin", ctx->str_index);
- if (first_flag)
+ if (ctx->first_dump_data_flag) {
fp = filp_open(input_file, O_RDWR | O_TRUNC | O_CREAT, 0644);
- else
+ ctx->first_dump_data_flag = false;
+ } else {
fp = filp_open(input_file, O_RDWR | O_APPEND | O_CREAT, 0644);
+ }
if (IS_ERR(fp)) {
vpu_dbg(LVL_WARN, "warning: open file(%s) fail\n", input_file);
return;
}
static u32 transfer_buffer_to_firmware(struct vpu_ctx *ctx,
- void *input_buffer,
- uint32_t buffer_size,
+ struct vb2_buffer *vb,
uint32_t vdec_std)
{
pSTREAM_BUFFER_DESCRIPTOR_TYPE pStrBufDesc;
u_int32 length;
MediaIPFW_Video_CodecParams *pCodecPara;
struct queue_data *q_data = &ctx->q_data[V4L2_SRC];
+ void *input_buffer = (void *)vb2_plane_vaddr(vb, 0);
+ uint32_t buffer_size = vb->planes[0].bytesused;
+ struct vb2_v4l2_buffer *vbuf;
vpu_dbg(LVL_BIT_FUNC, "enter %s, start_flag %d, index=%d, firmware_started=%d\n",
__func__, ctx->start_flag, ctx->str_index, ctx->dev->firmware_started);
(pSharedInterface->FWVersion & 0x0000ff00) >> 8,
pSharedInterface->FWVersion & 0x000000ff);
- if (ctx->stream_buffer.dma_size < buffer_size + MIN_SPACE) {
- vpu_err("circular buffer size is set too small\n");
- return 0;
- }
- if (!ctx->start_code_bypass)
- length = insert_scode_4_seq(ctx, input_buffer, ctx->stream_buffer.dma_virt, vdec_std, buffer_size);
- else
- length = 0;
- if (length == 0) {
- memcpy(ctx->stream_buffer.dma_virt, input_buffer, buffer_size);
- length = buffer_size;
- }
- vpu_dbg(LVL_INFO, "transfer data from virt 0x%p: size:%d\n",
- ctx->stream_buffer.dma_virt, buffer_size);
- dump_input_data_to_local(ctx, ctx->stream_buffer.dma_virt, length, 1);
- mb();
pStrBufDesc = get_str_buffer_desc(ctx);
pStrBufDesc->wptr = ctx->stream_buffer.dma_phy;
pStrBufDesc->rptr = ctx->stream_buffer.dma_phy;
ctx->pre_pic_end_addr = pStrBufDesc->start;
ctx->beginning = pStrBufDesc->start;
- update_wptr(ctx, pStrBufDesc, ctx->stream_buffer.dma_phy + length);
+ if (!ctx->start_code_bypass) {
+ length = insert_scode_4_seq(ctx, input_buffer, buffer_size);
+ if (length == 0) {
+ vpu_err("circular buffer size is set too small\n");
+ return 0;
+ }
+ } else {
+ if (ctx->stream_buffer.dma_size < buffer_size + MIN_SPACE) {
+ vpu_err("circular buffer size is set too small\n");
+ return 0;
+ }
+ copy_buffer_to_stream(ctx, input_buffer, buffer_size);
+ length = buffer_size;
+ }
+ vpu_dbg(LVL_INFO, "transfer data from virt 0x%p: size:%d\n",
+ ctx->stream_buffer.dma_virt, buffer_size);
+
ctx->dev->shared_mem.pSharedInterface->pStreamBuffDesc[ctx->str_index][uStrBufIdx] =
(VPU_REG_BASE + get_str_buffer_desc_offset(ctx));
ctx->dev->shared_mem.pSharedInterface->DbgLogDesc.uDecStatusLogLevel = vpu_frmdbg_level;
/*initialize frame count*/
- if (single_seq_info_format(q_data)) {
+ vbuf = to_vb2_v4l2_buffer(vb);
+ if (single_seq_info_format(q_data)
+ || vbuf->flags & V4L2_NXP_BUF_FLAG_CODECCONFIG) {
ctx->frm_dis_delay = 0;
ctx->frm_dec_delay = 0;
ctx->frm_total_num = 0;
{
struct vpu_ctx *ctx = container_of(This, struct vpu_ctx, q_data[V4L2_SRC]);
struct vb2_data_req *p_data_req;
- void *data_mapped;
- uint32_t buffer_size = vb->planes[0].bytesused;
u32 frame_bytes;
int ret;
- data_mapped = (void *)vb2_plane_vaddr(vb, 0);
-
if (ctx->start_flag == true) {
ret = alloc_vpu_buffer(ctx);
if (ret) {
}
frame_bytes = transfer_buffer_to_firmware(ctx,
- data_mapped,
- buffer_size,
+ vb,
This->vdec_std);
#ifdef HANDLE_EOS
if (vb->planes[0].bytesused < vb->planes[0].length)
}
}
-static u_int32 got_free_space(u_int32 wptr, u_int32 rptr, u_int32 start, u_int32 end)
+u_int32 got_free_space(u_int32 wptr, u_int32 rptr, u_int32 start, u_int32 end)
{
u_int32 freespace = 0;
}
-static int copy_buffer_to_stream(struct vpu_ctx *ctx, void *buffer, uint32_t length)
+int copy_buffer_to_stream(struct vpu_ctx *ctx, void *buffer, uint32_t length)
{
pSTREAM_BUFFER_DESCRIPTOR_TYPE pStrBufDesc;
void *wptr_virt;
memcpy(wptr_virt, buffer, length);
wptr += length;
}
- dump_input_data_to_local(ctx, buffer, length, 0);
+ dump_input_data_to_local(ctx, buffer, length);
mb();
update_wptr(ctx, pStrBufDesc, wptr);
return length;
return true;
}
-static uint32_t insert_scode_4_seq_4_arv(struct vpu_ctx *ctx, u_int8 *input_buffer,
- u_int32 buffer_size, uint32_t uStrBufIdx)
-{
- struct vpu_dev *dev = ctx->dev;
- uint32_t index = ctx->str_index;
- pSTREAM_BUFFER_DESCRIPTOR_TYPE pStrBufDesc;
- uint32_t nfreespace = 0;
- u_int8 seq_header[256] = {0};
- uint32_t length = 0;
- struct queue_data *This = &ctx->q_data[V4L2_SRC];
-
- pStrBufDesc = get_str_buffer_desc(ctx);
- nfreespace = got_free_space(pStrBufDesc->wptr, pStrBufDesc->rptr,
- pStrBufDesc->start, pStrBufDesc->end);
-
- if (nfreespace < (buffer_size + 16 + MIN_SPACE)) {
- vpu_dbg(LVL_INFO, "buffer_full: the circular buffer freespace < buffer_size\n");
- return 0;
- }
-
- insert_payload_header_arv(seq_header, SCODE_NEW_SEQUENCE, ctx->arv_type,
- buffer_size + 12, This->width, This->height);
- length = copy_buffer_to_stream(ctx, seq_header, 16);
- length += copy_buffer_to_stream(ctx, input_buffer, buffer_size);
-
- dev->shared_mem.pSharedInterface->pStreamBuffDesc[index][uStrBufIdx] =
- (VPU_REG_BASE + get_str_buffer_desc_offset(ctx));
-
- return length;
-}
-
-static u_int32 check_single_seq_info(struct vb2_v4l2_buffer *vbuf, struct queue_data *q_data)
-{
- if (!(vbuf->flags & V4L2_NXP_BUF_FLAG_CODECCONFIG))
- return 0;
- return single_seq_info_format(q_data);
-}
-
static bool verify_decoded_frames(struct vpu_ctx *ctx)
{
pDEC_RPC_HOST_IFACE pSharedInterface = ctx->dev->shared_mem.pSharedInterface;
input_buffer = (void *)vb2_plane_vaddr(p_data_req->vb2_buf, 0);
vbuf = to_vb2_v4l2_buffer(p_data_req->vb2_buf);
- if (vbuf->flags & V4L2_NXP_BUF_FLAG_CODECCONFIG
- && This->vdec_std == VPU_VIDEO_RV)
- frame_bytes = insert_scode_4_seq_4_arv(ctx, input_buffer, buffer_size, uStrBufIdx);
+ if (vbuf->flags & V4L2_NXP_BUF_FLAG_CODECCONFIG)
+ frame_bytes = insert_scode_4_seq(ctx, input_buffer, buffer_size);
else
frame_bytes = update_stream_addr_vpu(ctx, input_buffer, buffer_size, uStrBufIdx);
record_log_info(ctx, LOG_PADDING, 0, 0);
}
- if (!check_single_seq_info(vbuf, This)) {
+ if (!(vbuf->flags & V4L2_NXP_BUF_FLAG_CODECCONFIG)) {
ctx->frm_dec_delay++;
ctx->frm_dis_delay++;
ctx->frm_total_num++;
ctx->b_dis_reorder = false;
ctx->start_code_bypass = false;
ctx->hang_status = false;
+ ctx->first_dump_data_flag = true;
INIT_LIST_HEAD(&ctx->cmd_q);
ctx->tsm = createTSManager(tsm_buffer_size);
if (!ctx->tsm)
bool hang_status;
bool fifo_low;
bool frame_decoded;
+ bool first_dump_data_flag;
u32 req_frame_count;
u_int32 mbi_count;
u_int32 mbi_size;
#define VPU_DECODED_EVENT_PERF_MASK (1 << 0)
#define VPU_READY_EVENT_PERF_MASK (1 << 1)
+pSTREAM_BUFFER_DESCRIPTOR_TYPE get_str_buffer_desc(struct vpu_ctx *ctx);
+u_int32 got_free_space(u_int32 wptr, u_int32 rptr, u_int32 start, u_int32 end);
+int copy_buffer_to_stream(struct vpu_ctx *ctx, void *buffer, uint32_t length);
+
#endif
projects / linux.git / commitdiff