1 /*
2 *
3 * Copyright 2015 Rockchip Electronics Co. LTD
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 #define MODULE_TAG "vp8d_parser"
18
19 #include <string.h>
20
21 #include "mpp_env.h"
22 #include "mpp_mem.h"
23 #include "mpp_debug.h"
24 #include "mpp_frame.h"
25
26 #include "vp8d_parser.h"
27 #include "vp8d_codec.h"
28
29 #define FUN_T(tag) \
30 do {\
31 if (VP8D_DBG_FUNCTION & vp8d_debug)\
32 { mpp_log("%s: line(%d), func(%s)", tag, __LINE__, __FUNCTION__); }\
33 } while (0)
34
35 static RK_U32 vp8d_debug = 0x0;
36
vp8hwdBoolStart(vpBoolCoder_t * bit_ctx,RK_U8 * buffer,RK_U32 len)37 static void vp8hwdBoolStart(vpBoolCoder_t *bit_ctx, RK_U8 *buffer, RK_U32 len)
38 {
39 FUN_T("FUN_IN");
40 bit_ctx->lowvalue = 0;
41 bit_ctx->range = 255;
42 bit_ctx->count = 8;
43 bit_ctx->buffer = buffer;
44 bit_ctx->pos = 0;
45
46 bit_ctx->value = (bit_ctx->buffer[0] << 24) + (bit_ctx->buffer[1] << 16)
47 + (bit_ctx->buffer[2] << 8) + (bit_ctx->buffer[3]);
48
49 bit_ctx->pos += 4;
50
51 bit_ctx->streamEndPos = len;
52 bit_ctx->strmError = bit_ctx->pos > bit_ctx->streamEndPos;
53
54 FUN_T("FUN_OUT");
55 }
56
vp8hwdDecodeBool(vpBoolCoder_t * bit_ctx,RK_S32 probability)57 static RK_U32 vp8hwdDecodeBool(vpBoolCoder_t *bit_ctx, RK_S32 probability)
58 {
59 RK_U32 bit = 0;
60 RK_U32 split;
61 RK_U32 bigsplit;
62 RK_U32 count = bit_ctx->count;
63 RK_U32 range = bit_ctx->range;
64 RK_U32 value = bit_ctx->value;
65
66 FUN_T("FUN_IN");
67 split = 1 + (((range - 1) * probability) >> 8);
68 bigsplit = (split << 24);
69 range = split;
70
71 if (value >= bigsplit) {
72 range = bit_ctx->range - split;
73 value = value - bigsplit;
74 bit = 1;
75 }
76
77 if (range >= 0x80) {
78 bit_ctx->value = value;
79 bit_ctx->range = range;
80 return bit;
81 } else {
82 do {
83 range += range;
84 value += value;
85
86 if (!--count) {
87 /* no more stream to read? */
88 if (bit_ctx->pos >= bit_ctx->streamEndPos) {
89 bit_ctx->strmError = 1;
90 mpp_log("vp8hwdDecodeBool read end");
91 break;
92 }
93 count = 8;
94 value |= bit_ctx->buffer[bit_ctx->pos];
95 bit_ctx->pos++;
96 }
97 } while (range < 0x80);
98 }
99
100
101 bit_ctx->count = count;
102 bit_ctx->value = value;
103 bit_ctx->range = range;
104
105 FUN_T("FUN_OUT");
106 return bit;
107 }
108
vp8hwdDecodeBool128(vpBoolCoder_t * bit_ctx)109 static RK_U32 vp8hwdDecodeBool128(vpBoolCoder_t *bit_ctx)
110 {
111 RK_U32 bit = 0;
112 RK_U32 split;
113 RK_U32 bigsplit;
114 RK_U32 count = bit_ctx->count;
115 RK_U32 range = bit_ctx->range;
116 RK_U32 value = bit_ctx->value;
117
118 FUN_T("FUN_IN");
119 split = (range + 1) >> 1;
120 bigsplit = (split << 24);
121 range = split;
122
123 if (value >= bigsplit) {
124 range = (bit_ctx->range - split);
125 value = (value - bigsplit);
126 bit = 1;
127 }
128
129 if (range >= 0x80) {
130 bit_ctx->value = value;
131 bit_ctx->range = range;
132
133 FUN_T("FUN_OUT");
134 return bit;
135 } else {
136 range <<= 1;
137 value <<= 1;
138
139 if (!--count) {
140 /* no more stream to read? */
141 if (bit_ctx->pos >= bit_ctx->streamEndPos) {
142 bit_ctx->strmError = 1;
143 mpp_log("vp8hwdDecodeBool128 read end");
144 return 0; /* any value, not valid */
145 }
146 count = 8;
147 value |= bit_ctx->buffer[bit_ctx->pos];
148 bit_ctx->pos++;
149 }
150 }
151
152 bit_ctx->count = count;
153 bit_ctx->value = value;
154 bit_ctx->range = range;
155
156 FUN_T("FUN_OUT");
157 return bit;
158 }
159
vp8hwdReadBits(vpBoolCoder_t * bit_ctx,RK_S32 bits)160 static RK_U32 vp8hwdReadBits(vpBoolCoder_t *bit_ctx, RK_S32 bits)
161 {
162 RK_U32 z = 0;
163 RK_S32 bit;
164
165 FUN_T("FUN_IN");
166 for (bit = bits - 1; bit >= 0; bit--) {
167 z |= (vp8hwdDecodeBool128(bit_ctx) << bit);
168 }
169
170 FUN_T("FUN_OUT");
171 return z;
172 }
173
ScaleDimension(RK_U32 orig,RK_U32 scale)174 static RK_U32 ScaleDimension( RK_U32 orig, RK_U32 scale )
175 {
176
177 FUN_T("FUN_IN");
178 switch (scale) {
179 case 0:
180 return orig;
181 break;
182 case 1: /* 5/4 */
183 return (5 * orig) / 4;
184 break;
185 case 2: /* 5/3 */
186 return (5 * orig) / 3;
187 break;
188 case 3: /* 2 */
189 return 2 * orig;
190 break;
191 }
192
193 FUN_T("FUN_OUT");
194 return orig;
195 }
196
DecodeQuantizerDelta(vpBoolCoder_t * bit_ctx)197 static RK_S32 DecodeQuantizerDelta(vpBoolCoder_t *bit_ctx)
198 {
199 RK_S32 result = 0;
200
201 FUN_T("FUN_IN");
202 if (vp8hwdDecodeBool128(bit_ctx)) {
203 result = vp8hwdReadBits(bit_ctx, 4);
204 if (vp8hwdDecodeBool128(bit_ctx))
205 result = -result;
206 }
207
208 FUN_T("FUN_OUT");
209 return result;
210 }
211
vp8d_parser_init(void * ctx,ParserCfg * parser_cfg)212 MPP_RET vp8d_parser_init(void *ctx, ParserCfg *parser_cfg)
213 {
214 MPP_RET ret = MPP_OK;
215 VP8DContext *c = (VP8DContext *)ctx;
216 VP8DParserContext_t *p = (VP8DParserContext_t *)c->parse_ctx;
217
218 FUN_T("FUN_IN");
219 if (p == NULL) {
220 p = (VP8DParserContext_t*)mpp_calloc(VP8DParserContext_t, 1);
221 if (NULL == p) {
222 mpp_err("vp8d malloc VP8DParserContext_t fail");
223 FUN_T("FUN_OUT");
224 return MPP_ERR_NOMEM;
225 }
226 c->parse_ctx = p;
227 }
228 p->packet_slots = parser_cfg->packet_slots;
229 p->frame_slots = parser_cfg->frame_slots;
230
231 mpp_buf_slot_setup(p->frame_slots, 15);
232
233 p->dxva_ctx = mpp_calloc(DXVA_PicParams_VP8, 1);
234
235 if (NULL == p->dxva_ctx) {
236 mpp_err("vp8d malloc dxva_ctx fail");
237 FUN_T("FUN_OUT");
238 return MPP_ERR_NOMEM;
239 }
240 p->decMode = VP8HWD_VP8;
241 p->bitstream_sw_buf = mpp_malloc(RK_U8, VP8D_BUF_SIZE_BITMEM);
242 mpp_packet_init(&p->input_packet, p->bitstream_sw_buf,
243 VP8D_BUF_SIZE_BITMEM);
244 p->max_stream_size = VP8D_BUF_SIZE_BITMEM;
245
246 FUN_T("FUN_OUT");
247 return ret;
248 }
249
vp8d_unref_frame(VP8DParserContext_t * p,VP8Frame * frame)250 static void vp8d_unref_frame(VP8DParserContext_t *p, VP8Frame *frame)
251 {
252
253 FUN_T("FUN_IN");
254 if (NULL == frame || frame->ref_count <= 0
255 || frame->slot_index >= 0x7f) {
256 mpp_err("ref count alreay is zero");
257 FUN_T("FUN_OUT");
258 return;
259 }
260
261 frame->ref_count--;
262 if (!frame->ref_count) {
263 if (frame->slot_index < 0x7f) {
264 MppBuffer framebuf = NULL;
265 if (frame->invisible) {
266 mpp_buf_slot_get_prop(p->frame_slots, frame->slot_index, SLOT_BUFFER, &framebuf);
267 mpp_buffer_put(framebuf);
268 frame->invisible = 0;
269 }
270 mpp_buf_slot_clr_flag(p->frame_slots, frame->slot_index, SLOT_CODEC_USE);
271 }
272 frame->slot_index = 0xff;
273 mpp_frame_deinit(&frame->f);
274 mpp_free(frame);
275 frame = NULL;
276 }
277
278 FUN_T("FUN_OUT");
279 return;
280 }
281
vp8d_unref_allframe(VP8DParserContext_t * p)282 static void vp8d_unref_allframe(VP8DParserContext_t *p)
283 {
284
285 FUN_T("FUN_IN");
286 if (NULL != p->frame_out) {
287 vp8d_unref_frame(p, p->frame_out);
288 p->frame_out = NULL;
289 }
290
291 if (NULL != p->frame_ref) {
292 vp8d_unref_frame(p, p->frame_ref);
293 p->frame_ref = NULL;
294 }
295
296 if (NULL != p->frame_golden) {
297 vp8d_unref_frame(p, p->frame_golden);
298 p->frame_golden = NULL;
299 }
300
301 if (NULL != p->frame_alternate) {
302 vp8d_unref_frame(p, p->frame_alternate);
303 p->frame_alternate = NULL;
304 }
305
306 FUN_T("FUN_OUT");
307 return;
308 }
309
vp8d_parser_deinit(void * ctx)310 MPP_RET vp8d_parser_deinit(void *ctx)
311 {
312 MPP_RET ret = MPP_OK;
313 VP8DContext *c = (VP8DContext *)ctx;
314 VP8DParserContext_t *p = (VP8DParserContext_t *)c->parse_ctx;
315
316 FUN_T("FUN_IN");
317
318 if (NULL != p->bitstream_sw_buf) {
319 mpp_free(p->bitstream_sw_buf);
320 p->bitstream_sw_buf = NULL;
321 }
322
323 if (NULL != p->dxva_ctx) {
324 mpp_free(p->dxva_ctx);
325 p->dxva_ctx = NULL;
326 }
327
328 vp8d_unref_allframe(p);
329
330 if (p->input_packet) {
331 mpp_packet_deinit(&p->input_packet);
332 p->input_packet = NULL;
333 }
334
335 if ( NULL != p) {
336 mpp_free(p);
337 }
338 FUN_T("FUN_OUT");
339 return ret;
340 }
341 /*!
342 ***********************************************************************
343 * \brief
344 * reset
345 ***********************************************************************
346 */
vp8d_parser_reset(void * ctx)347 MPP_RET vp8d_parser_reset(void *ctx)
348 {
349 MPP_RET ret = MPP_OK;
350 VP8DContext *c = (VP8DContext *)ctx;
351 VP8DParserContext_t *p = (VP8DParserContext_t *)c->parse_ctx;
352
353 FUN_T("FUN_IN");
354 vp8d_unref_allframe(p);
355 p->needKeyFrame = 0;
356 p->eos = 0;
357 FUN_T("FUN_OUT");
358 return ret;
359 }
360
361 /*!
362 ***********************************************************************
363 * \brief
364 * flush
365 ***********************************************************************
366 */
vp8d_parser_flush(void * ctx)367 MPP_RET vp8d_parser_flush(void *ctx)
368 {
369 MPP_RET ret = MPP_OK;
370
371 FUN_T("FUN_IN");
372 (void) ctx;
373 FUN_T("FUN_OUT");
374 return ret;
375 }
376
377 /*!
378 ***********************************************************************
379 * \brief
380 * control/perform
381 ***********************************************************************
382 */
vp8d_parser_control(void * ctx,MpiCmd cmd_type,void * param)383 MPP_RET vp8d_parser_control(void *ctx, MpiCmd cmd_type, void *param)
384 {
385 MPP_RET ret = MPP_OK;
386
387 FUN_T("FUN_IN");
388 (void)ctx;
389 (void)cmd_type;
390 (void)param;
391
392 FUN_T("FUN_OUT");
393 return ret;
394 }
395
396
397 /*!
398 ***********************************************************************
399 * \brief
400 * prepare
401 ***********************************************************************
402 */
403
vp8d_parser_split_frame(RK_U8 * src,RK_U32 src_size,RK_U8 * dst,RK_U32 * dst_size)404 static MPP_RET vp8d_parser_split_frame(RK_U8 *src, RK_U32 src_size,
405 RK_U8 *dst, RK_U32 *dst_size)
406 {
407 MPP_RET ret = MPP_OK;
408
409 FUN_T("FUN_IN");
410 memcpy(dst, src, src_size);;
411 *dst_size = src_size;
412
413 (void)dst;
414
415 FUN_T("FUN_OUT");
416 return ret;
417 }
418
419
vp8d_parser_prepare(void * ctx,MppPacket pkt,HalDecTask * task)420 MPP_RET vp8d_parser_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
421 {
422 MPP_RET ret = MPP_OK;
423 RK_U32 out_size = 0, len_in = 0;
424 RK_U8 * pos = NULL;
425 RK_U8 *buf = NULL;
426 VP8DContext *c = (VP8DContext *)ctx;
427
428 VP8DParserContext_t *p = (VP8DParserContext_t *)c->parse_ctx;
429 MppPacket input_packet = p->input_packet;
430
431 FUN_T("FUN_IN");
432 task->valid = 0;
433
434
435 buf = pos = mpp_packet_get_pos(pkt);
436 p->pts = mpp_packet_get_pts(pkt);
437
438 len_in = (RK_U32)mpp_packet_get_length(pkt),
439 p->eos = mpp_packet_get_eos(pkt);
440 // mpp_log("len_in = %d",len_in);
441 if (len_in > p->max_stream_size) {
442 mpp_free(p->bitstream_sw_buf);
443 p->bitstream_sw_buf = NULL;
444 p->bitstream_sw_buf = mpp_malloc(RK_U8, (len_in + 1024));
445 if (NULL == p->bitstream_sw_buf) {
446 mpp_err("vp8d_parser realloc fail");
447 return MPP_ERR_NOMEM;
448 }
449 p->max_stream_size = len_in + 1024;
450 }
451
452 vp8d_parser_split_frame(buf,
453 len_in,
454 p->bitstream_sw_buf,
455 &out_size);
456 pos += out_size;
457
458 mpp_packet_set_pos(pkt, pos);
459
460 if (out_size == 0 && p->eos) {
461 task->flags.eos = p->eos;
462 return ret;
463 }
464
465
466
467 // mpp_log("p->bitstream_sw_buf = 0x%x", p->bitstream_sw_buf);
468 // mpp_log("out_size = 0x%x", out_size);
469 mpp_packet_set_data(input_packet, p->bitstream_sw_buf);
470 mpp_packet_set_size(input_packet, p->max_stream_size);
471 mpp_packet_set_length(input_packet, out_size);
472 p->stream_size = out_size;
473 task->input_packet = input_packet;
474 task->valid = 1;
475
476 FUN_T("FUN_OUT");
477 return ret;
478 }
479
480 static MPP_RET
vp8d_convert_to_syntx(VP8DParserContext_t * p,HalDecTask * in_task)481 vp8d_convert_to_syntx( VP8DParserContext_t *p, HalDecTask *in_task)
482 {
483 MPP_RET ret = MPP_OK;
484 RK_U32 i, tmp;
485 RK_U32 byteOffset = 0, extraBytesPacked = 0;
486 DXVA_PicParams_VP8 *pic_param = p->dxva_ctx;
487
488 FUN_T("FUN_IN");
489 tmp = (p->bitstr.pos) * 8 + (8 - p->bitstr.count);
490
491 if (p->frameTagSize == 4)
492 tmp += 8;
493
494 if (p->decMode == VP8HWD_VP8 && p->keyFrame)
495 extraBytesPacked += 7;
496
497 tmp += extraBytesPacked * 8;
498 byteOffset = tmp / 8;
499 pic_param->stream_start_bit = (byteOffset & 0x07U) * 8;
500 byteOffset &= (~0x07U); /* align the base */
501 pic_param->stream_start_offset = byteOffset;
502
503 pic_param->stream_start_bit += (tmp & 0x7);
504
505 pic_param->frame_type = !p->keyFrame;
506 pic_param->stVP8Segments.segmentation_enabled = p->segmentationEnabled;
507 pic_param->stVP8Segments.update_mb_segmentation_map =
508 p->segmentationMapUpdate;
509 pic_param->mode_ref_lf_delta_enabled = p->modeRefLfEnabled;
510 pic_param->mb_no_coeff_skip = p->coeffSkipMode;
511 pic_param->width = p->width;
512 pic_param->height = p->height;
513 pic_param->decMode = p->decMode;
514 pic_param->filter_type = p->loopFilterType;
515 pic_param->sharpness = p->loopFilterSharpness;
516 pic_param->filter_level = p->loopFilterLevel;
517 pic_param->stVP8Segments.update_mb_segmentation_data =
518 p->segmentFeatureMode;
519 pic_param->version = p->vpVersion;
520 pic_param->bool_value = ((p->bitstr.value >> 24) & (0xFFU));
521 pic_param->bool_range = (p->bitstr.range & (0xFFU));
522 pic_param->frameTagSize = p->frameTagSize;
523 pic_param->streamEndPos = p->bitstr.streamEndPos;
524 pic_param->log2_nbr_of_dct_partitions = p->nbrDctPartitions;
525 pic_param->offsetToDctParts = p->offsetToDctParts;
526
527 pic_param->y1ac_delta_q = p->qpYAc;
528 pic_param->y1dc_delta_q = p->qpYDc;
529 pic_param->y2ac_delta_q = p->qpY2Ac;
530 pic_param->y2dc_delta_q = p->qpY2Dc;
531 pic_param->uvac_delta_q = p->qpChAc;
532 pic_param->uvdc_delta_q = p->qpChDc;
533 pic_param->probe_skip_false = p->probMbSkipFalse;
534 pic_param->prob_intra = p->probIntra;
535 pic_param->prob_last = p->probRefLast;
536 pic_param->prob_golden = p->probRefGolden;
537
538 memcpy(pic_param->vp8_coef_update_probs, p->entropy.probCoeffs,
539 sizeof(pic_param->vp8_coef_update_probs));
540 memcpy(pic_param->vp8_mv_update_probs, p->entropy.probMvContext,
541 sizeof(pic_param->vp8_mv_update_probs));
542
543 for ( i = 0; i < 3; i++) {
544 pic_param->intra_chroma_prob[i] = p->entropy.probChromaPredMode[i];
545 pic_param->stVP8Segments.mb_segment_tree_probs[i] = p->probSegment[i];
546 }
547
548 pic_param->ref_frame_sign_bias_golden = p->refFrameSignBias[0];
549 pic_param->ref_frame_sign_bias_altref = p->refFrameSignBias[1];
550
551
552 for (i = 0; i < 4; i++) {
553 pic_param->stVP8Segments.segment_feature_data[0][i] = p->segmentQp[i];
554 pic_param->ref_lf_deltas[i] = p->mbRefLfDelta[i];
555 pic_param->mode_lf_deltas[i] = p->mbModeLfDelta[i];
556 pic_param->stVP8Segments.segment_feature_data[1][i] =
557 p->segmentLoopfilter[i];
558 pic_param->intra_16x16_prob[i] = p->entropy.probLuma16x16PredMode[i];
559 }
560
561 p->dxva_ctx->CurrPic.Index7Bits = p->frame_out->slot_index;
562 memset(in_task->refer, -1, sizeof(in_task->refer));
563
564 if (p->frame_ref != NULL) {
565 pic_param->lst_fb_idx.Index7Bits = p->frame_ref->slot_index;
566 mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref->slot_index,
567 SLOT_HAL_INPUT);
568 in_task->refer[0] = p->frame_ref->slot_index;
569 } else {
570 pic_param->lst_fb_idx.Index7Bits = 0x7f;
571 }
572
573 if (p->frame_golden != NULL) {
574 pic_param->gld_fb_idx.Index7Bits = p->frame_golden->slot_index;
575 mpp_buf_slot_set_flag(p->frame_slots, p->frame_golden->slot_index,
576 SLOT_HAL_INPUT);
577 in_task->refer[1] = p->frame_golden->slot_index;
578 } else {
579 pic_param->gld_fb_idx.Index7Bits = 0x7f;
580 }
581
582 if (p->frame_alternate != NULL) {
583 pic_param->alt_fb_idx.Index7Bits = p->frame_alternate->slot_index;
584 mpp_buf_slot_set_flag(p->frame_slots, p->frame_alternate->slot_index,
585 SLOT_HAL_INPUT);
586 in_task->refer[2] = p->frame_alternate->slot_index;
587 } else {
588 pic_param->alt_fb_idx.Index7Bits = 0x7f;
589 }
590
591 memcpy(pic_param->dctPartitionOffsets, p->dctPartitionOffsets,
592 sizeof(p->dctPartitionOffsets));
593
594 FUN_T("FUN_OUT");
595 return ret;
596 }
597
vp8d_alloc_frame(VP8DParserContext_t * p)598 static MPP_RET vp8d_alloc_frame(VP8DParserContext_t *p)
599 {
600 MPP_RET ret = MPP_OK;
601
602 FUN_T("FUN_IN");
603 if (NULL == p->frame_out) {
604 p->frame_out = mpp_calloc(VP8Frame, 1);
605 if (NULL == p->frame_out) {
606 mpp_err("alloc vp8 frame fail");
607 return MPP_ERR_NOMEM;
608 }
609
610 if (NULL == p->frame_out->f) {
611 mpp_frame_init(&p->frame_out->f);
612 if (NULL == p->frame_out->f) {
613 mpp_err("alloc vp8 mpp frame fail");
614 return MPP_ERR_NOMEM;
615 }
616 }
617 p->frame_out->slot_index = 0xff;
618 p->frame_out->invisible = !p->showFrame;
619 }
620
621 if (p->frame_out->slot_index == 0xff) {
622 mpp_frame_set_width(p->frame_out->f, p->width);
623 mpp_frame_set_height(p->frame_out->f, p->height);
624 mpp_frame_set_hor_stride(p->frame_out->f, p->width);
625 mpp_frame_set_ver_stride(p->frame_out->f, p->height);
626 mpp_frame_set_errinfo(p->frame_out->f, 0);
627 mpp_frame_set_pts(p->frame_out->f, p->pts);
628 ret = mpp_buf_slot_get_unused(p->frame_slots,
629 &p->frame_out->slot_index);
630 if (MPP_OK != ret) {
631 mpp_err("vp8 buf_slot_get_unused get fail");
632 return ret;
633 }
634 mpp_buf_slot_set_prop(p->frame_slots, p->frame_out->slot_index,
635 SLOT_FRAME, p->frame_out->f);
636 mpp_buf_slot_set_flag(p->frame_slots, p->frame_out->slot_index,
637 SLOT_CODEC_USE);
638 mpp_buf_slot_set_flag(p->frame_slots, p->frame_out->slot_index,
639 SLOT_HAL_OUTPUT);
640 mpp_frame_set_mode(p->frame_out->f, 0);
641
642 if (p->showFrame) {
643 mpp_buf_slot_set_flag(p->frame_slots, p->frame_out->slot_index,
644 SLOT_QUEUE_USE);
645 mpp_buf_slot_enqueue(p->frame_slots, p->frame_out->slot_index,
646 QUEUE_DISPLAY);
647 }
648 p->frame_out->ref_count++;
649 }
650
651 FUN_T("FUN_OUT");
652 return ret;
653 }
654
vp8d_ref_frame(VP8Frame * frame)655 static void vp8d_ref_frame(VP8Frame *frame)
656 {
657
658 FUN_T("FUN_IN");
659 if ((NULL == frame) || (frame->slot_index >= 0x7f)) {
660 mpp_err("frame is null or slot_index is no valid");
661 return;
662 }
663 frame->ref_count++;
664
665 FUN_T("FUN_OUT");
666 }
667
668
vp8d_ref_update(VP8DParserContext_t * p)669 static MPP_RET vp8d_ref_update(VP8DParserContext_t *p)
670 {
671
672 FUN_T("FUN_IN");
673 if (p->decMode != VP8HWD_WEBP) {
674 if (p->copyBufferToAlternate == 1) {
675 if (NULL != p->frame_alternate) {
676 vp8d_unref_frame(p, p->frame_alternate);
677 p->frame_alternate = NULL;
678 }
679 p->frame_alternate = p->frame_ref;
680 vp8d_ref_frame(p->frame_alternate);
681 } else if (p->copyBufferToAlternate == 2) {
682 if (NULL != p->frame_alternate) {
683 vp8d_unref_frame(p, p->frame_alternate);
684 p->frame_alternate = NULL;
685 }
686 p->frame_alternate = p->frame_golden;
687 vp8d_ref_frame(p->frame_alternate);
688 }
689
690 if (p->copyBufferToGolden == 1) {
691 if (NULL != p->frame_golden) {
692 vp8d_unref_frame(p, p->frame_golden);
693 p->frame_golden = NULL;
694 }
695 p->frame_golden = p->frame_ref;
696 vp8d_ref_frame(p->frame_golden);
697 } else if (p->copyBufferToGolden == 2) {
698 if (NULL != p->frame_golden) {
699 vp8d_unref_frame(p, p->frame_golden);
700 p->frame_golden = NULL;
701 }
702 p->frame_golden = p->frame_alternate;
703 vp8d_ref_frame(p->frame_golden);
704 }
705
706 if (p->refreshGolden) {
707 if (NULL != p->frame_golden) {
708 vp8d_unref_frame(p, p->frame_golden);
709 p->frame_golden = NULL;
710 }
711 p->frame_golden = p->frame_out;
712 vp8d_ref_frame(p->frame_golden);
713 }
714
715 if (p->refreshAlternate) {
716 if (NULL != p->frame_alternate) {
717 vp8d_unref_frame(p, p->frame_alternate);
718 p->frame_alternate = NULL;
719 }
720 p->frame_alternate = p->frame_out;
721 vp8d_ref_frame(p->frame_out);
722 }
723
724 if (p->refreshLast) {
725 if (NULL != p->frame_ref) {
726 vp8d_unref_frame(p, p->frame_ref);
727 p->frame_ref = NULL;
728 }
729 p->frame_ref = p->frame_out;
730 vp8d_ref_frame(p->frame_ref);
731 }
732 vp8d_unref_frame(p, p->frame_out);
733 p->frame_out = NULL;
734 }
735
736 FUN_T("FUN_OUT");
737 return 0;
738 }
739
vp8hwdResetProbs(VP8DParserContext_t * p)740 static void vp8hwdResetProbs(VP8DParserContext_t *p)
741 {
742 RK_U32 i, j, k, l;
743 static const RK_U32 Vp7DefaultScan[] = {
744 0, 1, 4, 8, 5, 2, 3, 6,
745 9, 12, 13, 10, 7, 11, 14, 15,
746 };
747
748 FUN_T("FUN_IN");
749 for ( i = 0 ; i < 16 ; ++i )
750 p->vp7ScanOrder[i] = Vp7DefaultScan[i];
751
752
753 /* Intra-prediction modes */
754 p->entropy.probLuma16x16PredMode[0] = 112;
755 p->entropy.probLuma16x16PredMode[1] = 86;
756 p->entropy.probLuma16x16PredMode[2] = 140;
757 p->entropy.probLuma16x16PredMode[3] = 37;
758 p->entropy.probChromaPredMode[0] = 162;
759 p->entropy.probChromaPredMode[1] = 101;
760 p->entropy.probChromaPredMode[2] = 204;
761
762 for (i = 0; i < MAX_NBR_OF_MB_REF_LF_DELTAS; i++)
763 p->mbRefLfDelta[i] = 0;
764
765 for (i = 0; i < MAX_NBR_OF_MB_MODE_LF_DELTAS; i++)
766 p->mbModeLfDelta[i] = 0;
767
768 /* MV context */
769 k = 0;
770 if (p->decMode == VP8HWD_VP8) {
771 for ( i = 0 ; i < 2 ; ++i )
772 for ( j = 0 ; j < VP8_MV_PROBS_PER_COMPONENT ; ++j, ++k )
773 p->entropy.probMvContext[i][j] = Vp8DefaultMvProbs[i][j];
774 } else {
775 for ( i = 0 ; i < 2 ; ++i )
776 for ( j = 0 ; j < VP7_MV_PROBS_PER_COMPONENT ; ++j, ++k )
777 p->entropy.probMvContext[i][j] = Vp7DefaultMvProbs[i][j];
778 }
779
780 /* Coefficients */
781 for ( i = 0 ; i < 4 ; ++i )
782 for ( j = 0 ; j < 8 ; ++j )
783 for ( k = 0 ; k < 3 ; ++k )
784 for ( l = 0 ; l < 11 ; ++l )
785 p->entropy.probCoeffs[i][j][k][l] =
786 DefaultCoeffProbs[i][j][k][l];
787
788 FUN_T("FUN_OUT");
789 }
790
vp8hwdDecodeCoeffUpdate(VP8DParserContext_t * p)791 static void vp8hwdDecodeCoeffUpdate(VP8DParserContext_t *p)
792 {
793 RK_U32 i, j, k, l;
794
795 FUN_T("FUN_IN");
796 for ( i = 0; i < 4; i++ ) {
797 for ( j = 0; j < 8; j++ ) {
798 for ( k = 0; k < 3; k++ ) {
799 for ( l = 0; l < 11; l++ ) {
800 if (vp8hwdDecodeBool(&p->bitstr,
801 CoeffUpdateProbs[i][j][k][l]))
802 p->entropy.probCoeffs[i][j][k][l] =
803 vp8hwdReadBits(&p->bitstr, 8);
804 }
805 }
806 }
807 }
808 FUN_T("FUN_OUT");
809 }
810
vp8_header_parser(VP8DParserContext_t * p,RK_U8 * pbase,RK_U32 size)811 static MPP_RET vp8_header_parser(VP8DParserContext_t *p, RK_U8 *pbase,
812 RK_U32 size)
813 {
814 RK_U32 tmp;
815 int i, j;
816 vpBoolCoder_t *bit_ctx = &p->bitstr;
817
818 FUN_T("FUN_IN");
819 if (p->keyFrame) {
820 tmp = (pbase[0] << 16) | (pbase[1] << 8) | (pbase[2] << 0);
821 if (tmp != VP8_KEY_FRAME_START_CODE)
822 return MPP_ERR_PROTOL;
823 tmp = (pbase[3] << 0) | (pbase[4] << 8);
824 p->width = tmp & 0x3fff;
825 p->scaledWidth = ScaleDimension(p->width, tmp >> 14);
826 tmp = (pbase[5] << 0) | (pbase[6] << 8);
827 p->height = tmp & 0x3fff;
828 p->scaledHeight = ScaleDimension(p->height, tmp >> 14);
829 pbase += 7;
830 size -= 7;
831 }
832 vp8hwdBoolStart(bit_ctx, pbase, size);
833 if (p->keyFrame) {
834 p->colorSpace = (vpColorSpace_e)vp8hwdDecodeBool128(bit_ctx);
835 p->clamping = vp8hwdDecodeBool128(bit_ctx);
836 }
837 p->segmentationEnabled = vp8hwdDecodeBool128(bit_ctx);
838 p->segmentationMapUpdate = 0;
839 if (p->segmentationEnabled) {
840 p->segmentationMapUpdate = vp8hwdDecodeBool128(bit_ctx);
841 if (vp8hwdDecodeBool128(bit_ctx)) { /* Segmentation map update */
842 p->segmentFeatureMode = vp8hwdDecodeBool128(bit_ctx);
843 memset(&p->segmentQp[0], 0, MAX_NBR_OF_SEGMENTS * sizeof(RK_S32));
844 memset(&p->segmentLoopfilter[0], 0,
845 MAX_NBR_OF_SEGMENTS * sizeof(RK_S32));
846 for (i = 0; i < MAX_NBR_OF_SEGMENTS; i++) {
847 if (vp8hwdDecodeBool128(bit_ctx)) {
848 p->segmentQp[i] = vp8hwdReadBits(bit_ctx, 7);
849 if (vp8hwdDecodeBool128(bit_ctx))
850 p->segmentQp[i] = -p->segmentQp[i];
851 }
852 }
853 for (i = 0; i < MAX_NBR_OF_SEGMENTS; i++) {
854 if (vp8hwdDecodeBool128(bit_ctx)) {
855 p->segmentLoopfilter[i] = vp8hwdReadBits(bit_ctx, 6);
856 if (vp8hwdDecodeBool128(bit_ctx))
857 p->segmentLoopfilter[i] = -p->segmentLoopfilter[i];
858 }
859 }
860 }
861 if (p->segmentationMapUpdate) {
862 p->probSegment[0] = 255;
863 p->probSegment[1] = 255;
864 p->probSegment[2] = 255;
865 for (i = 0; i < 3; i++) {
866 if (vp8hwdDecodeBool128(bit_ctx)) {
867 p->probSegment[i] = vp8hwdReadBits(bit_ctx, 8);
868 }
869 }
870 }
871 if (bit_ctx->strmError) {
872 mpp_err_f("paser header stream no enough");
873 FUN_T("FUN_OUT");
874 return MPP_ERR_STREAM;
875 }
876 }
877 p->loopFilterType = vp8hwdDecodeBool128(bit_ctx);
878 p->loopFilterLevel = vp8hwdReadBits(bit_ctx, 6);
879 p->loopFilterSharpness = vp8hwdReadBits(bit_ctx, 3);
880 p->modeRefLfEnabled = vp8hwdDecodeBool128(bit_ctx);
881 if (p->modeRefLfEnabled) {
882 if (vp8hwdDecodeBool128(bit_ctx)) {
883 for (i = 0; i < MAX_NBR_OF_MB_REF_LF_DELTAS; i++) {
884 if (vp8hwdDecodeBool128(bit_ctx)) {
885 p->mbRefLfDelta[i] = vp8hwdReadBits(bit_ctx, 6);
886 if (vp8hwdDecodeBool128(bit_ctx))
887 p->mbRefLfDelta[i] = -p->mbRefLfDelta[i];
888 }
889 }
890 for (i = 0; i < MAX_NBR_OF_MB_MODE_LF_DELTAS; i++) {
891 if (vp8hwdDecodeBool128(&p->bitstr)) {
892 p->mbModeLfDelta[i] = vp8hwdReadBits(bit_ctx, 6);
893 if (vp8hwdDecodeBool128(bit_ctx))
894 p->mbModeLfDelta[i] = -p->mbModeLfDelta[i];
895 }
896 }
897 }
898 }
899 if (bit_ctx->strmError) {
900 mpp_err_f("paser header stream no enough");
901 FUN_T("FUN_OUT");
902 return MPP_ERR_STREAM;
903 }
904 p->nbrDctPartitions = vp8hwdReadBits(bit_ctx, 2);
905 p->qpYAc = vp8hwdReadBits(bit_ctx, 7);
906 p->qpYDc = DecodeQuantizerDelta(bit_ctx);
907 p->qpY2Dc = DecodeQuantizerDelta(bit_ctx);
908 p->qpY2Ac = DecodeQuantizerDelta(bit_ctx);
909 p->qpChDc = DecodeQuantizerDelta(bit_ctx);
910 p->qpChAc = DecodeQuantizerDelta(bit_ctx);
911 if (p->keyFrame) {
912 p->refreshGolden = 1;
913 p->refreshAlternate = 1;
914 p->copyBufferToGolden = 0;
915 p->copyBufferToAlternate = 0;
916
917 /* Refresh entropy probs */
918 p->refreshEntropyProbs = vp8hwdDecodeBool128(bit_ctx);
919
920 p->refFrameSignBias[0] = 0;
921 p->refFrameSignBias[1] = 0;
922 p->refreshLast = 1;
923 } else {
924 /* Refresh golden */
925 p->refreshGolden = vp8hwdDecodeBool128(bit_ctx);
926 /* Refresh alternate */
927 p->refreshAlternate = vp8hwdDecodeBool128(bit_ctx);
928 if ( p->refreshGolden == 0 ) {
929 /* Copy to golden */
930 p->copyBufferToGolden = vp8hwdReadBits(bit_ctx, 2);
931 } else
932 p->copyBufferToGolden = 0;
933
934 if ( p->refreshAlternate == 0 ) {
935 /* Copy to alternate */
936 p->copyBufferToAlternate = vp8hwdReadBits(bit_ctx, 2);
937 } else
938 p->copyBufferToAlternate = 0;
939
940 /* Sign bias for golden frame */
941 p->refFrameSignBias[0] = vp8hwdDecodeBool128(bit_ctx);
942 /* Sign bias for alternate frame */
943 p->refFrameSignBias[1] = vp8hwdDecodeBool128(bit_ctx);
944 /* Refresh entropy probs */
945 p->refreshEntropyProbs = vp8hwdDecodeBool128(bit_ctx);
946 /* Refresh last */
947 p->refreshLast = vp8hwdDecodeBool128(bit_ctx);
948 }
949
950 /* Make a "backup" of current entropy probabilities if refresh is not set */
951 if (p->refreshEntropyProbs == 0) {
952 memcpy((void*)&p->entropyLast, (void*)&p->entropy,
953 (unsigned long)sizeof(vp8EntropyProbs_t));
954 memcpy( (void*)p->vp7PrevScanOrder, (void*)p->vp7ScanOrder,
955 (unsigned long)sizeof(p->vp7ScanOrder));
956 }
957
958 vp8hwdDecodeCoeffUpdate(p);
959 p->coeffSkipMode = vp8hwdDecodeBool128(bit_ctx);
960 if (!p->keyFrame) {
961 RK_U32 mvProbs;
962 if (p->coeffSkipMode)
963 p->probMbSkipFalse = vp8hwdReadBits(bit_ctx, 8);
964 p->probIntra = vp8hwdReadBits(bit_ctx, 8);
965 p->probRefLast = vp8hwdReadBits(bit_ctx, 8);
966 p->probRefGolden = vp8hwdReadBits(bit_ctx, 8);
967 if (vp8hwdDecodeBool128(bit_ctx)) {
968 for (i = 0; i < 4; i++)
969 p->entropy.probLuma16x16PredMode[i] = vp8hwdReadBits(bit_ctx, 8);
970 }
971 if (vp8hwdDecodeBool128(bit_ctx)) {
972 for (i = 0; i < 3; i++)
973 p->entropy.probChromaPredMode[i] = vp8hwdReadBits(bit_ctx, 8);
974 }
975 mvProbs = VP8_MV_PROBS_PER_COMPONENT;
976 for ( i = 0 ; i < 2 ; ++i ) {
977 for ( j = 0 ; j < (RK_S32)mvProbs ; ++j ) {
978 if (vp8hwdDecodeBool(bit_ctx, MvUpdateProbs[i][j]) == 1) {
979 tmp = vp8hwdReadBits(bit_ctx, 7);
980 if ( tmp )
981 tmp = tmp << 1;
982 else
983 tmp = 1;
984 p->entropy.probMvContext[i][j] = tmp;
985 }
986 }
987 }
988 } else {
989 if (p->coeffSkipMode)
990 p->probMbSkipFalse = vp8hwdReadBits(bit_ctx, 8);
991 }
992 if (bit_ctx->strmError) {
993 mpp_err_f("paser header stream no enough");
994 FUN_T("FUN_OUT");
995 return MPP_ERR_STREAM;
996 }
997 FUN_T("FUN_OUT");
998 return MPP_OK;
999 }
1000
1001 static MPP_RET
vp7_header_parser(VP8DParserContext_t * p,RK_U8 * pbase,RK_U32 size)1002 vp7_header_parser(VP8DParserContext_t *p, RK_U8 *pbase, RK_U32 size)
1003 {
1004 RK_U32 tmp;
1005 int i, j;
1006
1007 FUN_T("FUN_IN");
1008 vpBoolCoder_t *bit_ctx = &p->bitstr;
1009 vp8hwdBoolStart(bit_ctx, pbase, size);
1010
1011 if (p->keyFrame) {
1012 p->width = vp8hwdReadBits(bit_ctx, 12);
1013 p->height = vp8hwdReadBits(bit_ctx, 12);
1014 tmp = vp8hwdReadBits(bit_ctx, 2);
1015 p->scaledWidth = ScaleDimension(p->width, tmp);
1016 tmp = vp8hwdReadBits(bit_ctx, 2);
1017 p->scaledHeight = ScaleDimension(p->height, tmp);
1018 }
1019 {
1020 const RK_U32 vp70FeatureBits[4] = { 7, 6, 0, 8 };
1021 const RK_U32 vp71FeatureBits[4] = { 7, 6, 0, 5 };
1022 const RK_U32 *featureBits;
1023 if (p->vpVersion == 0)
1024 featureBits = vp70FeatureBits;
1025 else
1026 featureBits = vp71FeatureBits;
1027 for (i = 0; i < MAX_NBR_OF_VP7_MB_FEATURES; i++) {
1028 if (vp8hwdDecodeBool128(bit_ctx)) {
1029 tmp = vp8hwdReadBits(bit_ctx, 8);
1030 for (j = 0; j < 3; j++) {
1031 if (vp8hwdDecodeBool128(bit_ctx))
1032 tmp = vp8hwdReadBits(bit_ctx, 8);
1033 }
1034 if (featureBits[i]) {
1035 for (j = 0; j < 4; j++) {
1036 if (vp8hwdDecodeBool128(bit_ctx))
1037 tmp = vp8hwdReadBits(bit_ctx, featureBits[i]);
1038 }
1039 }
1040 FUN_T("FUN_OUT");
1041 return MPP_ERR_PROTOL;
1042 }
1043
1044 }
1045 p->nbrDctPartitions = 0;
1046 }
1047 p->qpYAc = (RK_S32)vp8hwdReadBits(bit_ctx, 7 );
1048 p->qpYDc = vp8hwdReadBits(bit_ctx, 1 )
1049 ? (RK_S32)vp8hwdReadBits(bit_ctx, 7 ) : p->qpYAc;
1050 p->qpY2Dc = vp8hwdReadBits(bit_ctx, 1 )
1051 ? (RK_S32)vp8hwdReadBits(bit_ctx, 7 ) : p->qpYAc;
1052 p->qpY2Ac = vp8hwdReadBits(bit_ctx, 1 )
1053 ? (RK_S32)vp8hwdReadBits(bit_ctx, 7 ) : p->qpYAc;
1054 p->qpChDc = vp8hwdReadBits(bit_ctx, 1 )
1055 ? (RK_S32)vp8hwdReadBits(bit_ctx, 7 ) : p->qpYAc;
1056 p->qpChAc = vp8hwdReadBits(bit_ctx, 1 )
1057 ? (RK_S32)vp8hwdReadBits(bit_ctx, 7 ) : p->qpYAc;
1058 if (!p->keyFrame) {
1059 p->refreshGolden = vp8hwdDecodeBool128(bit_ctx);
1060 if (p->vpVersion >= 1) {
1061 p->refreshEntropyProbs = vp8hwdDecodeBool128(bit_ctx);
1062 p->refreshLast = vp8hwdDecodeBool128(bit_ctx);
1063 } else {
1064 p->refreshEntropyProbs = 1;
1065 p->refreshLast = 1;
1066 }
1067 } else {
1068 p->refreshGolden = 1;
1069 p->refreshAlternate = 1;
1070 p->copyBufferToGolden = 0;
1071 p->copyBufferToAlternate = 0;
1072 if (p->vpVersion >= 1)
1073 p->refreshEntropyProbs = vp8hwdDecodeBool128(bit_ctx);
1074 else
1075 p->refreshEntropyProbs = 1;
1076 p->refFrameSignBias[0] = 0;
1077 p->refFrameSignBias[1] = 0;
1078 p->refreshLast = 1;
1079 }
1080
1081 if (!p->refreshEntropyProbs) {
1082 memcpy(&p->entropyLast, &p->entropy,
1083 (unsigned long)sizeof(vp8EntropyProbs_t));
1084 memcpy(p->vp7PrevScanOrder, p->vp7ScanOrder,
1085 (unsigned long)sizeof(p->vp7ScanOrder));
1086 }
1087 if (p->refreshLast) {
1088 if (vp8hwdDecodeBool128(bit_ctx)) {
1089 tmp = vp8hwdReadBits(bit_ctx, 8);
1090 tmp = vp8hwdReadBits(bit_ctx, 8);
1091 FUN_T("FUN_OUT");
1092 return MPP_ERR_STREAM;
1093 }
1094 }
1095 if (p->vpVersion == 0) {
1096 p->loopFilterType = vp8hwdDecodeBool128(bit_ctx);
1097 }
1098 if (vp8hwdDecodeBool128(bit_ctx)) {
1099 static const RK_U32 Vp7DefaultScan[] = {
1100 0, 1, 4, 8, 5, 2, 3, 6,
1101 9, 12, 13, 10, 7, 11, 14, 15,
1102 };
1103 p->vp7ScanOrder[0] = 0;
1104 for (i = 1; i < 16; i++)
1105 p->vp7ScanOrder[i] = Vp7DefaultScan[vp8hwdReadBits(bit_ctx, 4)];
1106 }
1107 if (p->vpVersion >= 1)
1108 p->loopFilterType = vp8hwdDecodeBool128(bit_ctx);
1109 p->loopFilterLevel = vp8hwdReadBits(bit_ctx, 6);
1110 p->loopFilterSharpness = vp8hwdReadBits(bit_ctx, 3);
1111 vp8hwdDecodeCoeffUpdate(p);
1112 if (!p->keyFrame) {
1113 p->probIntra = vp8hwdReadBits(bit_ctx, 8);
1114 p->probRefLast = vp8hwdReadBits(bit_ctx, 8);
1115 if (vp8hwdDecodeBool128(bit_ctx)) {
1116 for (i = 0; i < 4; i++)
1117 p->entropy.probLuma16x16PredMode[i] =
1118 vp8hwdReadBits(bit_ctx, 8);
1119 }
1120 if (vp8hwdDecodeBool128(bit_ctx)) {
1121 for (i = 0; i < 3; i++)
1122 p->entropy.probChromaPredMode[i] = vp8hwdReadBits(bit_ctx, 8);
1123 }
1124 for ( i = 0 ; i < 2 ; ++i ) {
1125 for ( j = 0 ; j < VP7_MV_PROBS_PER_COMPONENT ; ++j ) {
1126 if (vp8hwdDecodeBool(bit_ctx, MvUpdateProbs[i][j])) {
1127 tmp = vp8hwdReadBits(bit_ctx, 7);
1128 if ( tmp )
1129 tmp = tmp << 1;
1130 else
1131 tmp = 1;
1132 p->entropy.probMvContext[i][j] = tmp;
1133 }
1134 }
1135 }
1136 }
1137 if (bit_ctx->strmError) {
1138 FUN_T("FUN_OUT");
1139 return MPP_ERR_PROTOL;
1140 }
1141
1142 FUN_T("FUN_OUT");
1143 return MPP_OK;
1144 }
1145
1146 static MPP_RET
vp8hwdSetPartitionOffsets(VP8DParserContext_t * p,RK_U8 * stream,RK_U32 len)1147 vp8hwdSetPartitionOffsets(VP8DParserContext_t *p, RK_U8 *stream, RK_U32 len)
1148 {
1149 RK_U32 i = 0;
1150 RK_U32 offset = 0;
1151 RK_U32 baseOffset;
1152 RK_U32 extraBytesPacked = 0;
1153
1154 FUN_T("FUN_IN");
1155 if (p->decMode == VP8HWD_VP8 && p->keyFrame)
1156 extraBytesPacked += 7;
1157
1158 stream += p->frameTagSize;
1159
1160 baseOffset = p->frameTagSize + p->offsetToDctParts
1161 + 3 * ( (1 << p->nbrDctPartitions) - 1);
1162
1163 stream += p->offsetToDctParts + extraBytesPacked;
1164 for ( i = 0 ; i < (RK_U32)(1 << p->nbrDctPartitions) - 1 ; ++i ) {
1165 RK_U32 tmp;
1166
1167 p->dctPartitionOffsets[i] = baseOffset + offset;
1168 tmp = stream[0] | (stream[1] << 8) | (stream[2] << 16);
1169 offset += tmp;
1170 stream += 3;
1171 }
1172 p->dctPartitionOffsets[i] = baseOffset + offset;
1173
1174 return (p->dctPartitionOffsets[i] < len ? MPP_OK : MPP_ERR_STREAM);
1175 }
1176
1177 static MPP_RET
decoder_frame_header(VP8DParserContext_t * p,RK_U8 * pbase,RK_U32 size)1178 decoder_frame_header(VP8DParserContext_t *p, RK_U8 *pbase, RK_U32 size)
1179 {
1180 MPP_RET ret;
1181
1182 FUN_T("FUN_IN");
1183 p->keyFrame = !(pbase[0] & 1);
1184 p->vpVersion = (pbase[0] >> 1) & 7;
1185 p->showFrame = 1;
1186 if (p->keyFrame && !p->needKeyFrame) {
1187 p->needKeyFrame = 1;
1188 } else {
1189 if (!p->needKeyFrame) {
1190 mpp_err("no found key frame");
1191 return MPP_NOK;
1192 }
1193 }
1194 if (p->decMode == VP8HWD_VP7) {
1195 p->offsetToDctParts = (pbase[0] >> 4) | (pbase[1] << 4) | (pbase[2] << 12);
1196 p->frameTagSize = p->vpVersion >= 1 ? 3 : 4;
1197 } else {
1198 p->offsetToDctParts = (pbase[0] >> 5) | (pbase[1] << 3) | (pbase[2] << 11);
1199 #if 0
1200 mpp_log("offsetToDctParts %d pbase[0] = 0x%x pbase[1] = 0x%x pbase[2] = 0x%x ",
1201 p->offsetToDctParts, pbase[0], pbase[1], pbase[2]);
1202 #endif
1203 p->showFrame = (pbase[0] >> 4) & 1;
1204 p->frameTagSize = 3;
1205 }
1206 pbase += p->frameTagSize;
1207 size -= p->frameTagSize;
1208 if (p->keyFrame)
1209 vp8hwdResetProbs(p);
1210 //mpp_log_f("p->decMode = %d", p->decMode);
1211 if (p->decMode == VP8HWD_VP8) {
1212 ret = vp8_header_parser(p, pbase, size);
1213 } else {
1214 ret = vp7_header_parser(p, pbase, size);
1215 }
1216 if (ret != MPP_OK) {
1217 return ret;
1218 }
1219 return MPP_OK;
1220 }
1221
vp8d_parser_parse(void * ctx,HalDecTask * in_task)1222 MPP_RET vp8d_parser_parse(void *ctx, HalDecTask *in_task)
1223 {
1224 MPP_RET ret = MPP_OK;
1225 VP8DContext *c = (VP8DContext *)ctx;
1226 VP8DParserContext_t *p = (VP8DParserContext_t *)c->parse_ctx;
1227 FUN_T("FUN_IN");
1228
1229 ret = decoder_frame_header(p, p->bitstream_sw_buf, p->stream_size);
1230
1231 if (MPP_OK != ret) {
1232 mpp_err("decoder_frame_header err ret %d", ret);
1233 FUN_T("FUN_OUT");
1234 return ret;
1235 }
1236
1237 vp8hwdSetPartitionOffsets(p, p->bitstream_sw_buf, p->stream_size);
1238
1239 ret = vp8d_alloc_frame(p);
1240 if (MPP_OK != ret) {
1241 mpp_err("vp8d_alloc_frame err ret %d", ret);
1242 FUN_T("FUN_OUT");
1243 return ret;
1244 }
1245
1246 vp8d_convert_to_syntx(p, in_task);
1247 /* Rollback entropy probabilities if refresh is not set */
1248 if (p->refreshEntropyProbs == 0) {
1249 memcpy((void*)&p->entropy, (void*)&p->entropyLast,
1250 (unsigned long)sizeof(vp8EntropyProbs_t));
1251 memcpy((void*)p->vp7ScanOrder, (void*)p->vp7PrevScanOrder,
1252 (unsigned long)sizeof(p->vp7ScanOrder));
1253 }
1254 in_task->syntax.data = (void *)p->dxva_ctx;
1255 in_task->syntax.number = 1;
1256 in_task->output = p->frame_out->slot_index;
1257 in_task->valid = 1;
1258 if (p->eos) {
1259 in_task->flags.eos = p->eos;
1260 }
1261 vp8d_ref_update(p);
1262
1263 FUN_T("FUN_OUT");
1264 return ret;
1265 }
1266
vp8d_parser_callback(void * ctx,void * hal_info)1267 MPP_RET vp8d_parser_callback(void *ctx, void *hal_info)
1268 {
1269 MPP_RET ret = MPP_OK;
1270 FUN_T("FUN_IN");
1271 (void)ctx;
1272 (void)hal_info;
1273 FUN_T("FUN_OUT");
1274 return ret;
1275 }
1276