1 /******************************************************************************
2 *
3 * Copyright (C) 2015 The Android Open Source Project
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 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 #include <string.h>
21 #ifdef __ANDROID__
22 #include <cutils/log.h>
23 #endif
24 #include "iv_datatypedef.h"
25 #include "iv.h"
26 #include "ivd.h"
27 #include "impeg2_macros.h"
28 #include "impeg2_buf_mgr.h"
29 #include "impeg2_disp_mgr.h"
30 #include "impeg2_defs.h"
31 #include "impeg2_inter_pred.h"
32 #include "impeg2_idct.h"
33 #include "impeg2_format_conv.h"
34 #include "impeg2_mem_func.h"
35 #include "impeg2_platform_macros.h"
36 #include "ithread.h"
37 #include "impeg2_job_queue.h"
38
39 #include "impeg2d.h"
40 #include "impeg2d_bitstream.h"
41 #include "impeg2d_api.h"
42 #include "impeg2d_structs.h"
43 #include "impeg2_globals.h"
44 #include "impeg2d_pic_proc.h"
45 #include "impeg2d_deinterlace.h"
46
47
48 /*****************************************************************************
49 * MPEG2 Constants for Parse Check
50 ******************************************************************************/
51 #define MPEG2_MAX_FRAME_RATE_CODE 8
52
53 /******************************************************************************
54 * Function Name : impeg2d_next_start_code
55 *
56 * Description : Peek for next_start_code from the stream_t.
57 *
58 * Arguments :
59 * dec : Decoder Context
60 *
61 * Values Returned : None
62 ******************************************************************************/
impeg2d_next_start_code(dec_state_t * ps_dec)63 void impeg2d_next_start_code(dec_state_t *ps_dec)
64 {
65 stream_t *ps_stream;
66 ps_stream = &ps_dec->s_bit_stream;
67 impeg2d_bit_stream_flush_to_byte_boundary(ps_stream);
68
69 while ((impeg2d_bit_stream_nxt(ps_stream,START_CODE_PREFIX_LEN) != START_CODE_PREFIX)
70 && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
71 {
72 impeg2d_bit_stream_get(ps_stream,8);
73 }
74 return;
75 }
76 /******************************************************************************
77 * Function Name : impeg2d_next_code
78 *
79 * Description : Peek for next_start_code from the stream_t.
80 *
81 * Arguments :
82 * dec : Decoder Context
83 *
84 * Values Returned : None
85 ******************************************************************************/
impeg2d_next_code(dec_state_t * ps_dec,UWORD32 u4_start_code_val)86 void impeg2d_next_code(dec_state_t *ps_dec, UWORD32 u4_start_code_val)
87 {
88 stream_t *ps_stream;
89 ps_stream = &ps_dec->s_bit_stream;
90 impeg2d_bit_stream_flush_to_byte_boundary(ps_stream);
91
92 while ((impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) != u4_start_code_val) &&
93 (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
94 {
95
96 if (impeg2d_bit_stream_get(ps_stream,8) != 0)
97 {
98 /* Ignore stuffing bit errors. */
99 }
100
101 }
102 return;
103 }
104 /******************************************************************************
105 * Function Name : impeg2d_peek_next_start_code
106 *
107 * Description : Peek for next_start_code from the stream_t.
108 *
109 * Arguments :
110 * dec : Decoder Context
111 *
112 * Values Returned : None
113 ******************************************************************************/
impeg2d_peek_next_start_code(dec_state_t * ps_dec)114 void impeg2d_peek_next_start_code(dec_state_t *ps_dec)
115 {
116 stream_t *ps_stream;
117 ps_stream = &ps_dec->s_bit_stream;
118 impeg2d_bit_stream_flush_to_byte_boundary(ps_stream);
119
120 while ((impeg2d_bit_stream_nxt(ps_stream,START_CODE_PREFIX_LEN) != START_CODE_PREFIX)
121 && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
122 {
123 impeg2d_bit_stream_get(ps_stream,8);
124 }
125 return;
126 }
127 /******************************************************************************
128 *
129 * Function Name : impeg2d_dec_seq_hdr
130 *
131 * Description : Decodes Sequence header information
132 *
133 * Arguments :
134 * dec : Decoder Context
135 *
136 * Values Returned : None
137 ******************************************************************************/
impeg2d_dec_seq_hdr(dec_state_t * ps_dec)138 IMPEG2D_ERROR_CODES_T impeg2d_dec_seq_hdr(dec_state_t *ps_dec)
139 {
140 stream_t *ps_stream;
141 ps_stream = &ps_dec->s_bit_stream;
142 UWORD16 u2_height;
143 UWORD16 u2_width;
144
145 if (impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) != SEQUENCE_HEADER_CODE)
146 {
147 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
148 return IMPEG2D_FRM_HDR_START_CODE_NOT_FOUND;
149
150 }
151 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
152
153 u2_width = impeg2d_bit_stream_get(ps_stream,12);
154 u2_height = impeg2d_bit_stream_get(ps_stream,12);
155
156 if (0 == u2_width || 0 == u2_height)
157 {
158 IMPEG2D_ERROR_CODES_T e_error = IMPEG2D_FRM_HDR_DECODE_ERR;
159 return e_error;
160 }
161
162 if ((u2_width != ps_dec->u2_horizontal_size)
163 || (u2_height != ps_dec->u2_vertical_size))
164 {
165 if (0 == ps_dec->u2_header_done)
166 {
167 /* This is the first time we are reading the resolution */
168 ps_dec->u2_horizontal_size = u2_width;
169 ps_dec->u2_vertical_size = u2_height;
170 if (0 == ps_dec->u4_frm_buf_stride)
171 {
172 ps_dec->u4_frm_buf_stride = (UWORD32) (u2_width);
173 }
174 }
175 else
176 {
177 if((u2_width > ps_dec->u2_create_max_width)
178 || (u2_height > ps_dec->u2_create_max_height))
179 {
180 IMPEG2D_ERROR_CODES_T e_error = IMPEG2D_UNSUPPORTED_DIMENSIONS;
181
182 ps_dec->u2_reinit_max_height = u2_height;
183 ps_dec->u2_reinit_max_width = u2_width;
184
185 return e_error;
186 }
187 else
188 {
189 /* The resolution has changed */
190 return (IMPEG2D_ERROR_CODES_T)IVD_RES_CHANGED;
191 }
192 }
193 }
194
195 if((ps_dec->u2_horizontal_size > ps_dec->u2_create_max_width)
196 || (ps_dec->u2_vertical_size > ps_dec->u2_create_max_height))
197 {
198 IMPEG2D_ERROR_CODES_T e_error = IMPEG2D_UNSUPPORTED_DIMENSIONS;
199 ps_dec->u2_reinit_max_height = ps_dec->u2_vertical_size;
200 ps_dec->u2_reinit_max_width = ps_dec->u2_horizontal_size;
201 return e_error;
202 }
203
204
205 /*------------------------------------------------------------------------*/
206 /* Flush the following as they are not being used */
207 /* aspect_ratio_info (4 bits) */
208 /*------------------------------------------------------------------------*/
209 ps_dec->u2_aspect_ratio_info = impeg2d_bit_stream_get(ps_stream,4);
210
211 /*------------------------------------------------------------------------*/
212 /* Frame rate code(4 bits) */
213 /*------------------------------------------------------------------------*/
214 ps_dec->u2_frame_rate_code = impeg2d_bit_stream_get(ps_stream,4);
215 if (ps_dec->u2_frame_rate_code > MPEG2_MAX_FRAME_RATE_CODE)
216 {
217 return IMPEG2D_FRM_HDR_DECODE_ERR;
218 }
219 /*------------------------------------------------------------------------*/
220 /* Flush the following as they are not being used */
221 /* bit_rate_value (18 bits) */
222 /*------------------------------------------------------------------------*/
223 impeg2d_bit_stream_flush(ps_stream,18);
224 GET_MARKER_BIT(ps_dec,ps_stream);
225 /*------------------------------------------------------------------------*/
226 /* Flush the following as they are not being used */
227 /* vbv_buffer_size_value(10 bits), constrained_parameter_flag (1 bit) */
228 /*------------------------------------------------------------------------*/
229 impeg2d_bit_stream_flush(ps_stream,11);
230
231 /*------------------------------------------------------------------------*/
232 /* Quantization matrix for the intra blocks */
233 /*------------------------------------------------------------------------*/
234 if(impeg2d_bit_stream_get_bit(ps_stream) == 1)
235 {
236 UWORD16 i;
237 for(i = 0; i < NUM_PELS_IN_BLOCK; i++)
238 {
239 ps_dec->au1_intra_quant_matrix[gau1_impeg2_inv_scan_zig_zag[i]] = (UWORD8)impeg2d_bit_stream_get(ps_stream,8);
240 }
241
242 }
243 else
244 {
245 memcpy(ps_dec->au1_intra_quant_matrix,gau1_impeg2_intra_quant_matrix_default,
246 NUM_PELS_IN_BLOCK);
247 }
248
249 /*------------------------------------------------------------------------*/
250 /* Quantization matrix for the inter blocks */
251 /*------------------------------------------------------------------------*/
252 if(impeg2d_bit_stream_get_bit(ps_stream) == 1)
253 {
254 UWORD16 i;
255 for(i = 0; i < NUM_PELS_IN_BLOCK; i++)
256 {
257 ps_dec->au1_inter_quant_matrix[gau1_impeg2_inv_scan_zig_zag[i]] = (UWORD8)impeg2d_bit_stream_get(ps_stream,8);
258 }
259 }
260 else
261 {
262 memcpy(ps_dec->au1_inter_quant_matrix,gau1_impeg2_inter_quant_matrix_default,
263 NUM_PELS_IN_BLOCK);
264 }
265 impeg2d_next_start_code(ps_dec);
266
267 return (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
268 }
269
270 /******************************************************************************
271 *
272 * Function Name : impeg2d_dec_seq_ext
273 *
274 * Description : Gets additional sequence data.
275 *
276 * Arguments :
277 * dec : Decoder Context
278 *
279 * Values Returned : None
280 ******************************************************************************/
impeg2d_dec_seq_ext(dec_state_t * ps_dec)281 IMPEG2D_ERROR_CODES_T impeg2d_dec_seq_ext(dec_state_t *ps_dec)
282 {
283 stream_t *ps_stream;
284
285 ps_stream = &ps_dec->s_bit_stream;
286
287 if (impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) != EXTENSION_START_CODE)
288 {
289 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
290 return IMPEG2D_FRM_HDR_START_CODE_NOT_FOUND;
291
292 }
293 /* Flush the extension start code */
294 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
295
296 /* Flush extension start code identifier */
297 impeg2d_bit_stream_flush(ps_stream,4);
298
299 /*----------------------------------------------------------------------*/
300 /* Profile and Level information */
301 /*----------------------------------------------------------------------*/
302 {
303 UWORD32 u4_esc_bit, u4_profile, u4_level;
304
305 /* Read the profile and level information */
306 /* check_profile_and_level: Table 8-1 */
307 /* [7:7] 1 Escape bit */
308 /* [6:4] 3 Profile identification */
309 /* [3:0] 4 Level identification */
310
311 u4_esc_bit = impeg2d_bit_stream_get_bit(ps_stream);
312 u4_profile = impeg2d_bit_stream_get(ps_stream,3);
313 u4_level = impeg2d_bit_stream_get(ps_stream,4);
314 UNUSED(u4_profile);
315 UNUSED(u4_level);
316 /*
317 if( escBit == 1 ||
318 profile < MPEG2_MAIN_PROFILE ||
319 level < MPEG2_MAIN_LEVEL)
320 */
321 if (1 == u4_esc_bit)
322 {
323 return IMPEG2D_PROF_LEVEL_NOT_SUPPORTED;
324 }
325 }
326
327 ps_dec->u2_progressive_sequence = impeg2d_bit_stream_get_bit(ps_stream);
328
329 /* Read the chrominance format */
330 if(impeg2d_bit_stream_get(ps_stream,2) != 0x1)
331 return IMPEG2D_CHROMA_FMT_NOT_SUP;
332
333 /* Read the 2 most significant bits from horizontal_size */
334 ps_dec->u2_horizontal_size += (impeg2d_bit_stream_get(ps_stream,2) << 12);
335
336 /* Read the 2 most significant bits from vertical_size */
337 ps_dec->u2_vertical_size += (impeg2d_bit_stream_get(ps_stream,2) << 12);
338
339 /*-----------------------------------------------------------------------*/
340 /* Flush the following as they are not used now */
341 /* bit_rate_extension 12 */
342 /* marker_bit 1 */
343 /* vbv_buffer_size_extension 8 */
344 /* low_delay 1 */
345 /*-----------------------------------------------------------------------*/
346 impeg2d_bit_stream_flush(ps_stream,12);
347 GET_MARKER_BIT(ps_dec,ps_stream);
348 impeg2d_bit_stream_flush(ps_stream,9);
349 /*-----------------------------------------------------------------------*/
350 /* frame_rate_extension_n 2 */
351 /* frame_rate_extension_d 5 */
352 /*-----------------------------------------------------------------------*/
353 ps_dec->u2_frame_rate_extension_n = impeg2d_bit_stream_get(ps_stream,2);
354 ps_dec->u2_frame_rate_extension_d = impeg2d_bit_stream_get(ps_stream,5);
355
356 return (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
357 }
358
359 /*******************************************************************************
360 *
361 * Function Name : impeg2d_dec_seq_disp_ext
362 *
363 * Description : This function is eqvt to sequence_display_extension() of
364 * standard. It flushes data present as it is not being used
365 *
366 * Arguments :
367 * dec : Decoder Context
368 *
369 * Values Returned : None
370 ******************************************************************************/
impeg2d_dec_seq_disp_ext(dec_state_t * ps_dec)371 void impeg2d_dec_seq_disp_ext(dec_state_t *ps_dec)
372 {
373 stream_t *ps_stream;
374 ps_stream = &ps_dec->s_bit_stream;
375
376 /*
377 sequence_display_extension()
378 {
379 extension_start_code_identifier 4
380 video_format 3
381 colour_description 1
382 if (colour_description)
383 {
384 colour_primaries 8
385 transfer_characteristics 8
386 matrix_coefficients 8
387 }
388 display_horizontal_size 14
389 marker_bit 1
390 display_vertical_size 14
391 next_start_code()
392 }
393 */
394
395 impeg2d_bit_stream_get(ps_stream, 4);
396 ps_dec->u1_video_format = impeg2d_bit_stream_get(ps_stream, 3);
397 ps_dec->u1_colour_description = impeg2d_bit_stream_get(ps_stream, 1);
398 ps_dec->u1_colour_primaries = 2;
399 ps_dec->u1_transfer_characteristics = 2;
400 ps_dec->u1_matrix_coefficients = 2;
401 if(ps_dec->u1_colour_description)
402 {
403 ps_dec->u1_colour_primaries = impeg2d_bit_stream_get(ps_stream, 8);
404 ps_dec->u1_transfer_characteristics = impeg2d_bit_stream_get(ps_stream, 8);
405 ps_dec->u1_matrix_coefficients = impeg2d_bit_stream_get(ps_stream, 8);
406 }
407
408 /* display_horizontal_size and display_vertical_size */
409 ps_dec->u2_display_horizontal_size = impeg2d_bit_stream_get(ps_stream,14);;
410 GET_MARKER_BIT(ps_dec,ps_stream);
411 ps_dec->u2_display_vertical_size = impeg2d_bit_stream_get(ps_stream,14);
412
413 ps_dec->u1_seq_disp_extn_present = 1;
414 impeg2d_next_start_code(ps_dec);
415 }
416
417
418 /*******************************************************************************
419 *
420 * Function Name : impeg2d_dec_seq_scale_ext
421 *
422 * Description : This function is eqvt to sequence_scalable_extension() of
423 * standard.
424 *
425 * Arguments : Decoder context
426 *
427 * Values Returned : None
428 *******************************************************************************/
impeg2d_dec_seq_scale_ext(dec_state_t * ps_dec)429 IMPEG2D_ERROR_CODES_T impeg2d_dec_seq_scale_ext(dec_state_t *ps_dec)
430 {
431 UNUSED(ps_dec);
432 return IMPEG2D_SCALABILITIY_NOT_SUPPORTED;
433 }
434
435 /*******************************************************************************
436 *
437 * Function Name : impeg2d_dec_quant_matrix_ext
438 *
439 * Description : Gets Intra and NonIntra quantizer matrix from the stream.
440 *
441 * Arguments : Decoder context
442 *
443 * Values Returned : None
444 *******************************************************************************/
impeg2d_dec_quant_matrix_ext(dec_state_t * ps_dec)445 void impeg2d_dec_quant_matrix_ext(dec_state_t *ps_dec)
446 {
447 stream_t *ps_stream;
448
449 ps_stream = &ps_dec->s_bit_stream;
450 /* Flush extension_start_code_identifier */
451 impeg2d_bit_stream_flush(ps_stream,4);
452
453 /*------------------------------------------------------------------------*/
454 /* Quantization matrix for the intra blocks */
455 /*------------------------------------------------------------------------*/
456 if(impeg2d_bit_stream_get(ps_stream,1) == 1)
457 {
458 UWORD16 i;
459 for(i = 0; i < NUM_PELS_IN_BLOCK; i++)
460 {
461 ps_dec->au1_intra_quant_matrix[gau1_impeg2_inv_scan_zig_zag[i]] = (UWORD8)impeg2d_bit_stream_get(ps_stream,8);
462 }
463
464 }
465
466
467 /*------------------------------------------------------------------------*/
468 /* Quantization matrix for the inter blocks */
469 /*------------------------------------------------------------------------*/
470 if(impeg2d_bit_stream_get(ps_stream,1) == 1)
471 {
472 UWORD16 i;
473 for(i = 0; i < NUM_PELS_IN_BLOCK; i++)
474 {
475 ps_dec->au1_inter_quant_matrix[gau1_impeg2_inv_scan_zig_zag[i]] = (UWORD8)impeg2d_bit_stream_get(ps_stream,8);
476 }
477 }
478
479 /* Note : chroma intra quantizer matrix and chroma non
480 intra quantizer matrix are not needed for 4:2:0 format */
481 impeg2d_next_start_code(ps_dec);
482 }
483 /*******************************************************************************
484 *
485 * Function Name : impeg2d_dec_pic_disp_ext
486 *
487 * Description : This function is eqvt to picture_display_extension() of
488 * standard.The parameters are not used by decoder
489 *
490 * Arguments : Pointer to dec_state_t
491 *
492 * Values Returned : Decoder context
493 *
494 * Values Returned : None
495 *******************************************************************************/
impeg2d_dec_pic_disp_ext(dec_state_t * ps_dec)496 void impeg2d_dec_pic_disp_ext(dec_state_t *ps_dec)
497 {
498 WORD16 i2_number_of_frame_centre_offsets ;
499 stream_t *ps_stream;
500
501 ps_stream = &ps_dec->s_bit_stream;
502 impeg2d_bit_stream_flush(ps_stream,4);
503
504 if (ps_dec->u2_progressive_sequence)
505 {
506 i2_number_of_frame_centre_offsets = (ps_dec->u2_repeat_first_field) ?
507 2 + ps_dec->u2_top_field_first : 1;
508 }
509 else
510 {
511 i2_number_of_frame_centre_offsets =
512 (ps_dec->u2_picture_structure != FRAME_PICTURE) ?
513 1 : 2 + ps_dec->u2_repeat_first_field;
514 }
515 while(i2_number_of_frame_centre_offsets--)
516 {
517 /* frame_centre_horizontal_offset */
518 impeg2d_bit_stream_get(ps_stream,16);
519 GET_MARKER_BIT(ps_dec,ps_stream);
520 /* frame_centre_vertical_offset */
521 impeg2d_bit_stream_get(ps_stream,16);
522 GET_MARKER_BIT(ps_dec,ps_stream);
523 }
524 impeg2d_next_start_code(ps_dec);
525 }
526
527 /*******************************************************************************
528 *
529 * Function Name : impeg2d_dec_itu_t_ext
530 *
531 * Description : This function is eqvt to ITU-T_extension() of
532 * standard.The parameters are not used by decoder
533 *
534 * Arguments : Decoder context
535 *
536 * Values Returned : None
537 *******************************************************************************/
impeg2d_dec_itu_t_ext(dec_state_t * ps_dec)538 void impeg2d_dec_itu_t_ext(dec_state_t *ps_dec)
539 {
540 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,EXT_ID_LEN);
541 impeg2d_next_start_code(ps_dec);
542 }
543
544 /*******************************************************************************
545 * Function Name : impeg2d_dec_copyright_ext
546 *
547 * Description : This function is eqvt to copyright_extension() of
548 * standard. The parameters are not used by decoder
549 *
550 * Arguments : Decoder context
551 *
552 * Values Returned : None
553 *******************************************************************************/
554
555
impeg2d_dec_copyright_ext(dec_state_t * ps_dec)556 void impeg2d_dec_copyright_ext(dec_state_t *ps_dec)
557 {
558 UWORD32 u4_bits_to_flush;
559
560 u4_bits_to_flush = COPYRIGHT_EXTENSION_LEN;
561
562 while(u4_bits_to_flush >= 32 )
563 {
564 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,32);
565 u4_bits_to_flush = u4_bits_to_flush - 32;
566 }
567
568 if(u4_bits_to_flush > 0)
569 {
570 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,u4_bits_to_flush);
571 }
572
573
574 impeg2d_next_start_code(ps_dec);
575 }
576 /*******************************************************************************
577 * Function Name : impeg2d_dec_cam_param_ext
578 *
579 * Description : This function is eqvt to camera_parameters_extension() of
580 * standard. The parameters are not used by decoder
581 *
582 * Arguments : Decoder context
583 *
584 * Values Returned : None
585 *******************************************************************************/
586
587
impeg2d_dec_cam_param_ext(dec_state_t * ps_dec)588 void impeg2d_dec_cam_param_ext(dec_state_t *ps_dec)
589 {
590
591 UWORD32 u4_bits_to_flush;
592
593 u4_bits_to_flush = CAMERA_PARAMETER_EXTENSION_LEN;
594
595 while(u4_bits_to_flush >= 32 )
596 {
597 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,32);
598 u4_bits_to_flush = u4_bits_to_flush - 32;
599 }
600
601 if(u4_bits_to_flush > 0)
602 {
603 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,u4_bits_to_flush);
604 }
605
606 impeg2d_next_start_code(ps_dec);
607 }
608
609 /*******************************************************************************
610 *
611 * Function Name : impeg2d_dec_grp_of_pic_hdr
612 *
613 * Description : Gets information at the GOP level.
614 *
615 * Arguments : Decoder context
616 *
617 * Values Returned : None
618 *******************************************************************************/
619
620
impeg2d_dec_grp_of_pic_hdr(dec_state_t * ps_dec)621 void impeg2d_dec_grp_of_pic_hdr(dec_state_t *ps_dec)
622 {
623
624 UWORD32 u4_bits_to_flush;
625
626 u4_bits_to_flush = GROUP_OF_PICTURE_LEN;
627
628 while(u4_bits_to_flush >= 32 )
629 {
630 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,32);
631 u4_bits_to_flush = u4_bits_to_flush - 32;
632 }
633
634 if(u4_bits_to_flush > 0)
635 {
636 impeg2d_bit_stream_flush(&ps_dec->s_bit_stream,u4_bits_to_flush);
637 }
638
639 }
640
641
642 /*******************************************************************************
643 *
644 * Function Name : impeg2d_dec_pic_hdr
645 *
646 * Description : Gets the picture header information.
647 *
648 * Arguments : Decoder context
649 *
650 * Values Returned : None
651 *******************************************************************************/
impeg2d_dec_pic_hdr(dec_state_t * ps_dec)652 IMPEG2D_ERROR_CODES_T impeg2d_dec_pic_hdr(dec_state_t *ps_dec)
653 {
654 stream_t *ps_stream;
655 ps_stream = &ps_dec->s_bit_stream;
656
657 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
658 /* Flush temporal reference */
659 impeg2d_bit_stream_get(ps_stream,10);
660
661 /* Picture type */
662 ps_dec->e_pic_type = (e_pic_type_t)impeg2d_bit_stream_get(ps_stream,3);
663 if((ps_dec->e_pic_type < I_PIC) || (ps_dec->e_pic_type > D_PIC))
664 {
665 impeg2d_next_code(ps_dec, PICTURE_START_CODE);
666 return IMPEG2D_INVALID_PIC_TYPE;
667 }
668
669 /* Flush vbv_delay */
670 impeg2d_bit_stream_get(ps_stream,16);
671
672 if(ps_dec->e_pic_type == P_PIC || ps_dec->e_pic_type == B_PIC)
673 {
674 ps_dec->u2_full_pel_forw_vector = impeg2d_bit_stream_get_bit(ps_stream);
675 ps_dec->u2_forw_f_code = impeg2d_bit_stream_get(ps_stream,3);
676 }
677 if(ps_dec->e_pic_type == B_PIC)
678 {
679 ps_dec->u2_full_pel_back_vector = impeg2d_bit_stream_get_bit(ps_stream);
680 ps_dec->u2_back_f_code = impeg2d_bit_stream_get(ps_stream,3);
681 }
682
683 if(ps_dec->u2_is_mpeg2 == 0)
684 {
685 ps_dec->au2_f_code[0][0] = ps_dec->au2_f_code[0][1] = ps_dec->u2_forw_f_code;
686 ps_dec->au2_f_code[1][0] = ps_dec->au2_f_code[1][1] = ps_dec->u2_back_f_code;
687 }
688
689 /*-----------------------------------------------------------------------*/
690 /* Flush the extra bit value */
691 /* */
692 /* while(impeg2d_bit_stream_nxt() == '1') */
693 /* { */
694 /* extra_bit_picture 1 */
695 /* extra_information_picture 8 */
696 /* } */
697 /* extra_bit_picture 1 */
698 /*-----------------------------------------------------------------------*/
699 while (impeg2d_bit_stream_nxt(ps_stream,1) == 1 &&
700 ps_stream->u4_offset < ps_stream->u4_max_offset)
701 {
702 impeg2d_bit_stream_get(ps_stream,9);
703 }
704 impeg2d_bit_stream_get_bit(ps_stream);
705 impeg2d_next_start_code(ps_dec);
706
707 return (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
708 }
709
710
711 /*******************************************************************************
712 *
713 * Function Name : impeg2d_dec_pic_coding_ext
714 *
715 * Description : Reads more picture level parameters
716 *
717 * Arguments :
718 * dec : Decoder context
719 *
720 * Values Returned : Error
721 *******************************************************************************/
impeg2d_dec_pic_coding_ext(dec_state_t * ps_dec)722 IMPEG2D_ERROR_CODES_T impeg2d_dec_pic_coding_ext(dec_state_t *ps_dec)
723 {
724 stream_t *ps_stream;
725 IMPEG2D_ERROR_CODES_T e_error = (IMPEG2D_ERROR_CODES_T) IV_SUCCESS;
726
727 ps_stream = &ps_dec->s_bit_stream;
728 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
729 /* extension code identifier */
730 impeg2d_bit_stream_get(ps_stream,4);
731
732 ps_dec->au2_f_code[0][0] = impeg2d_bit_stream_get(ps_stream,4);
733 ps_dec->au2_f_code[0][1] = impeg2d_bit_stream_get(ps_stream,4);
734 ps_dec->au2_f_code[1][0] = impeg2d_bit_stream_get(ps_stream,4);
735 ps_dec->au2_f_code[1][1] = impeg2d_bit_stream_get(ps_stream,4);
736 ps_dec->u2_intra_dc_precision = impeg2d_bit_stream_get(ps_stream,2);
737 ps_dec->u2_picture_structure = impeg2d_bit_stream_get(ps_stream,2);
738 if (ps_dec->u2_picture_structure < TOP_FIELD ||
739 ps_dec->u2_picture_structure > FRAME_PICTURE)
740 {
741 return IMPEG2D_FRM_HDR_DECODE_ERR;
742 }
743 ps_dec->u2_top_field_first = impeg2d_bit_stream_get_bit(ps_stream);
744 ps_dec->u2_frame_pred_frame_dct = impeg2d_bit_stream_get_bit(ps_stream);
745 ps_dec->u2_concealment_motion_vectors = impeg2d_bit_stream_get_bit(ps_stream);
746 ps_dec->u2_q_scale_type = impeg2d_bit_stream_get_bit(ps_stream);
747 ps_dec->u2_intra_vlc_format = impeg2d_bit_stream_get_bit(ps_stream);
748 ps_dec->u2_alternate_scan = impeg2d_bit_stream_get_bit(ps_stream);
749 ps_dec->u2_repeat_first_field = impeg2d_bit_stream_get_bit(ps_stream);
750 /* Flush chroma_420_type */
751 impeg2d_bit_stream_get_bit(ps_stream);
752
753 ps_dec->u2_progressive_frame = impeg2d_bit_stream_get_bit(ps_stream);
754 if (impeg2d_bit_stream_get_bit(ps_stream))
755 {
756 /* Flush v_axis, field_sequence, burst_amplitude, sub_carrier_phase */
757 impeg2d_bit_stream_flush(ps_stream,20);
758 }
759 impeg2d_next_start_code(ps_dec);
760
761
762 if(VERTICAL_SCAN == ps_dec->u2_alternate_scan)
763 {
764 ps_dec->pu1_inv_scan_matrix = (UWORD8 *)gau1_impeg2_inv_scan_vertical;
765 }
766 else
767 {
768 ps_dec->pu1_inv_scan_matrix = (UWORD8 *)gau1_impeg2_inv_scan_zig_zag;
769 }
770 return e_error;
771 }
772
773 /*******************************************************************************
774 *
775 * Function Name : impeg2d_dec_slice
776 *
777 * Description : Reads Slice level parameters and calls functions that
778 * decode individual MBs of slice
779 *
780 * Arguments :
781 * dec : Decoder context
782 *
783 * Values Returned : None
784 *******************************************************************************/
impeg2d_dec_slice(dec_state_t * ps_dec)785 IMPEG2D_ERROR_CODES_T impeg2d_dec_slice(dec_state_t *ps_dec)
786 {
787 stream_t *ps_stream;
788 UWORD32 u4_slice_vertical_position;
789 UWORD32 u4_slice_vertical_position_extension;
790 IMPEG2D_ERROR_CODES_T e_error;
791
792 ps_stream = &ps_dec->s_bit_stream;
793
794 /*------------------------------------------------------------------------*/
795 /* All the profiles supported require restricted slice structure. Hence */
796 /* there is no need to store slice_vertical_position. Note that max */
797 /* height supported does not exceed 2800 and scalablity is not supported */
798 /*------------------------------------------------------------------------*/
799
800 /* Remove the slice start code */
801 impeg2d_bit_stream_flush(ps_stream,START_CODE_PREFIX_LEN);
802 u4_slice_vertical_position = impeg2d_bit_stream_get(ps_stream, 8);
803 if(u4_slice_vertical_position > 2800)
804 {
805 u4_slice_vertical_position_extension = impeg2d_bit_stream_get(ps_stream, 3);
806 u4_slice_vertical_position += (u4_slice_vertical_position_extension << 7);
807 }
808
809 if((u4_slice_vertical_position > ps_dec->u2_num_vert_mb) ||
810 (u4_slice_vertical_position == 0))
811 {
812 return IMPEG2D_INVALID_VERT_SIZE;
813 }
814
815 // change the mb_y to point to slice_vertical_position
816 u4_slice_vertical_position--;
817 if (ps_dec->u2_mb_y != u4_slice_vertical_position)
818 {
819 ps_dec->u2_mb_y = u4_slice_vertical_position;
820 ps_dec->u2_mb_x = 0;
821
822 /* Update the number of MBs left, since we have probably missed a slice
823 * (that's why we see a mismatch between u2_mb_y and current position).
824 */
825 ps_dec->u2_num_mbs_left = (ps_dec->u2_num_vert_mb - ps_dec->u2_mb_y)
826 * ps_dec->u2_num_horiz_mb;
827 }
828 ps_dec->u2_first_mb = 1;
829
830 /*------------------------------------------------------------------------*/
831 /* Quant scale code decoding */
832 /*------------------------------------------------------------------------*/
833 {
834 UWORD16 u2_quant_scale_code;
835 u2_quant_scale_code = impeg2d_bit_stream_get(ps_stream,5);
836 ps_dec->u1_quant_scale = (ps_dec->u2_q_scale_type) ?
837 gau1_impeg2_non_linear_quant_scale[u2_quant_scale_code] : (u2_quant_scale_code << 1);
838 }
839
840 if (impeg2d_bit_stream_nxt(ps_stream,1) == 1)
841 {
842 impeg2d_bit_stream_flush(ps_stream,9);
843 /* Flush extra bit information */
844 while (impeg2d_bit_stream_nxt(ps_stream,1) == 1 &&
845 ps_stream->u4_offset < ps_stream->u4_max_offset)
846 {
847 impeg2d_bit_stream_flush(ps_stream,9);
848 }
849 }
850 impeg2d_bit_stream_get_bit(ps_stream);
851
852 /* Reset the DC predictors to reset values given in Table 7.2 at the start*/
853 /* of slice data */
854 ps_dec->u2_def_dc_pred[Y_LUMA] = 128 << ps_dec->u2_intra_dc_precision;
855 ps_dec->u2_def_dc_pred[U_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
856 ps_dec->u2_def_dc_pred[V_CHROMA] = 128 << ps_dec->u2_intra_dc_precision;
857 /*------------------------------------------------------------------------*/
858 /* dec->DecMBsinSlice() implements the following psuedo code from standard*/
859 /* do */
860 /* { */
861 /* macroblock() */
862 /* } while (impeg2d_bit_stream_nxt() != '000 0000 0000 0000 0000 0000') */
863 /*------------------------------------------------------------------------*/
864
865 e_error = ps_dec->pf_decode_slice(ps_dec);
866 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
867 {
868 return e_error;
869 }
870
871 /* Check for the MBy index instead of number of MBs left, because the
872 * number of MBs left in case of multi-thread decode is the number of MBs
873 * in that row only
874 */
875 if(ps_dec->u2_mb_y < ps_dec->u2_num_vert_mb)
876 impeg2d_next_start_code(ps_dec);
877
878 return (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
879 }
880
impeg2d_dec_pic_data_thread(dec_state_t * ps_dec)881 void impeg2d_dec_pic_data_thread(dec_state_t *ps_dec)
882 {
883 WORD32 i4_continue_decode;
884
885 WORD32 i4_cur_row, temp;
886 UWORD32 u4_bits_read;
887 WORD32 i4_dequeue_job;
888 IMPEG2D_ERROR_CODES_T e_error;
889
890 i4_cur_row = ps_dec->u2_mb_y + 1;
891
892 i4_continue_decode = 1;
893
894 i4_dequeue_job = 1;
895 do
896 {
897 if(i4_cur_row > ps_dec->u2_num_vert_mb)
898 {
899 i4_continue_decode = 0;
900 break;
901 }
902
903 {
904 if((ps_dec->i4_num_cores> 1) && (i4_dequeue_job))
905 {
906 job_t s_job;
907 IV_API_CALL_STATUS_T e_ret;
908 UWORD8 *pu1_buf;
909
910 e_ret = impeg2_jobq_dequeue(ps_dec->pv_jobq, &s_job, sizeof(s_job), 1, 1);
911 if(e_ret != IV_SUCCESS)
912 break;
913
914 if(CMD_PROCESS == s_job.i4_cmd)
915 {
916 pu1_buf = ps_dec->pu1_inp_bits_buf + s_job.i4_bistream_ofst;
917 impeg2d_bit_stream_init(&(ps_dec->s_bit_stream), pu1_buf,
918 (ps_dec->u4_num_inp_bytes - s_job.i4_bistream_ofst) + 8);
919 i4_cur_row = s_job.i2_start_mb_y;
920 ps_dec->i4_start_mb_y = s_job.i2_start_mb_y;
921 ps_dec->i4_end_mb_y = s_job.i2_end_mb_y;
922 ps_dec->u2_mb_x = 0;
923 ps_dec->u2_mb_y = ps_dec->i4_start_mb_y;
924 ps_dec->u2_num_mbs_left = (ps_dec->i4_end_mb_y - ps_dec->i4_start_mb_y) * ps_dec->u2_num_horiz_mb;
925
926 }
927 else
928 {
929 WORD32 start_row;
930 WORD32 num_rows;
931 start_row = s_job.i2_start_mb_y << 4;
932 num_rows = MIN((s_job.i2_end_mb_y << 4), ps_dec->u2_vertical_size);
933 num_rows -= start_row;
934
935 if(ps_dec->u4_deinterlace && (0 == ps_dec->u2_progressive_frame))
936 {
937 impeg2d_deinterlace(ps_dec,
938 ps_dec->ps_disp_pic,
939 ps_dec->ps_disp_frm_buf,
940 start_row,
941 num_rows);
942
943 }
944 else
945 {
946 impeg2d_format_convert(ps_dec, ps_dec->ps_disp_pic,
947 ps_dec->ps_disp_frm_buf,
948 start_row, num_rows);
949 }
950 break;
951
952 }
953
954 }
955 e_error = impeg2d_dec_slice(ps_dec);
956
957 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
958 {
959 impeg2d_next_start_code(ps_dec);
960 }
961 }
962
963 /* Detecting next slice start code */
964 while(1)
965 {
966 // skip (dec->u4_num_cores-1) rows
967 u4_bits_read = impeg2d_bit_stream_nxt(&ps_dec->s_bit_stream,START_CODE_LEN);
968 temp = u4_bits_read & 0xFF;
969 i4_continue_decode = (((u4_bits_read >> 8) == 0x01) && (temp) && (temp <= 0xAF));
970
971 if (1 == ps_dec->i4_num_cores && 0 == ps_dec->u2_num_mbs_left)
972 {
973 i4_continue_decode = 0;
974 #ifdef __ANDROID__
975 android_errorWriteLog(0x534e4554, "26070014");
976 #endif
977 }
978
979 if(i4_continue_decode)
980 {
981 /* If the slice is from the same row, then continue decoding without dequeue */
982 if((temp - 1) == i4_cur_row)
983 {
984 i4_dequeue_job = 0;
985 break;
986 }
987
988 if(temp < ps_dec->i4_end_mb_y)
989 {
990 i4_cur_row = ps_dec->u2_mb_y;
991 }
992 else
993 {
994 i4_dequeue_job = 1;
995 }
996 break;
997
998 }
999 else
1000 break;
1001 }
1002
1003 }while(i4_continue_decode);
1004 if(ps_dec->i4_num_cores > 1)
1005 {
1006 while(1)
1007 {
1008 job_t s_job;
1009 IV_API_CALL_STATUS_T e_ret;
1010
1011 e_ret = impeg2_jobq_dequeue(ps_dec->pv_jobq, &s_job, sizeof(s_job), 1, 1);
1012 if(e_ret != IV_SUCCESS)
1013 break;
1014 if(CMD_FMTCONV == s_job.i4_cmd)
1015 {
1016 WORD32 start_row;
1017 WORD32 num_rows;
1018 start_row = s_job.i2_start_mb_y << 4;
1019 num_rows = MIN((s_job.i2_end_mb_y << 4), ps_dec->u2_vertical_size);
1020 num_rows -= start_row;
1021 if(ps_dec->u4_deinterlace && (0 == ps_dec->u2_progressive_frame))
1022 {
1023 impeg2d_deinterlace(ps_dec,
1024 ps_dec->ps_disp_pic,
1025 ps_dec->ps_disp_frm_buf,
1026 start_row,
1027 num_rows);
1028
1029 }
1030 else
1031 {
1032 impeg2d_format_convert(ps_dec,
1033 ps_dec->ps_disp_pic,
1034 ps_dec->ps_disp_frm_buf,
1035 start_row,
1036 num_rows);
1037 }
1038 }
1039 }
1040 }
1041 else
1042 {
1043 if((NULL != ps_dec->ps_disp_pic) && ((0 == ps_dec->u4_share_disp_buf) || (IV_YUV_420P != ps_dec->i4_chromaFormat)))
1044 {
1045 if(ps_dec->u4_deinterlace && (0 == ps_dec->u2_progressive_frame))
1046 {
1047 impeg2d_deinterlace(ps_dec,
1048 ps_dec->ps_disp_pic,
1049 ps_dec->ps_disp_frm_buf,
1050 0,
1051 ps_dec->u2_vertical_size);
1052
1053 }
1054 else
1055 {
1056 impeg2d_format_convert(ps_dec, ps_dec->ps_disp_pic,
1057 ps_dec->ps_disp_frm_buf,
1058 0, ps_dec->u2_vertical_size);
1059 }
1060 }
1061 }
1062 }
1063
impeg2d_init_thread_dec_ctxt(dec_state_t * ps_dec,dec_state_t * ps_dec_thd,WORD32 i4_min_mb_y)1064 static WORD32 impeg2d_init_thread_dec_ctxt(dec_state_t *ps_dec,
1065 dec_state_t *ps_dec_thd,
1066 WORD32 i4_min_mb_y)
1067 {
1068 UNUSED(i4_min_mb_y);
1069 ps_dec_thd->i4_start_mb_y = 0;
1070 ps_dec_thd->i4_end_mb_y = ps_dec->u2_num_vert_mb;
1071 ps_dec_thd->u2_mb_x = 0;
1072 ps_dec_thd->u2_mb_y = 0;
1073 ps_dec_thd->u2_is_mpeg2 = ps_dec->u2_is_mpeg2;
1074 ps_dec_thd->u2_frame_width = ps_dec->u2_frame_width;
1075 ps_dec_thd->u2_frame_height = ps_dec->u2_frame_height;
1076 ps_dec_thd->u2_picture_width = ps_dec->u2_picture_width;
1077 ps_dec_thd->u2_horizontal_size = ps_dec->u2_horizontal_size;
1078 ps_dec_thd->u2_vertical_size = ps_dec->u2_vertical_size;
1079 ps_dec_thd->u2_create_max_width = ps_dec->u2_create_max_width;
1080 ps_dec_thd->u2_create_max_height = ps_dec->u2_create_max_height;
1081 ps_dec_thd->u2_header_done = ps_dec->u2_header_done;
1082 ps_dec_thd->u2_decode_header = ps_dec->u2_decode_header;
1083
1084 ps_dec_thd->u2_num_horiz_mb = ps_dec->u2_num_horiz_mb;
1085 ps_dec_thd->u2_num_vert_mb = ps_dec->u2_num_vert_mb;
1086 ps_dec_thd->u2_num_flds_decoded = ps_dec->u2_num_flds_decoded;
1087
1088 ps_dec_thd->u4_frm_buf_stride = ps_dec->u4_frm_buf_stride;
1089
1090 ps_dec_thd->u2_field_dct = ps_dec->u2_field_dct;
1091 ps_dec_thd->u2_read_dct_type = ps_dec->u2_read_dct_type;
1092
1093 ps_dec_thd->u2_read_motion_type = ps_dec->u2_read_motion_type;
1094 ps_dec_thd->u2_motion_type = ps_dec->u2_motion_type;
1095
1096 ps_dec_thd->pu2_mb_type = ps_dec->pu2_mb_type;
1097 ps_dec_thd->u2_fld_pic = ps_dec->u2_fld_pic;
1098 ps_dec_thd->u2_frm_pic = ps_dec->u2_frm_pic;
1099
1100 ps_dec_thd->u2_fld_parity = ps_dec->u2_fld_parity;
1101
1102 ps_dec_thd->au2_fcode_data[0] = ps_dec->au2_fcode_data[0];
1103 ps_dec_thd->au2_fcode_data[1] = ps_dec->au2_fcode_data[1];
1104
1105 ps_dec_thd->u1_quant_scale = ps_dec->u1_quant_scale;
1106
1107 ps_dec_thd->u2_num_mbs_left = ps_dec->u2_num_mbs_left;
1108 ps_dec_thd->u2_first_mb = ps_dec->u2_first_mb;
1109 ps_dec_thd->u2_num_skipped_mbs = ps_dec->u2_num_skipped_mbs;
1110
1111 memcpy(&ps_dec_thd->s_cur_frm_buf, &ps_dec->s_cur_frm_buf, sizeof(yuv_buf_t));
1112 memcpy(&ps_dec_thd->as_recent_fld[0][0], &ps_dec->as_recent_fld[0][0], sizeof(yuv_buf_t));
1113 memcpy(&ps_dec_thd->as_recent_fld[0][1], &ps_dec->as_recent_fld[0][1], sizeof(yuv_buf_t));
1114 memcpy(&ps_dec_thd->as_recent_fld[1][0], &ps_dec->as_recent_fld[1][0], sizeof(yuv_buf_t));
1115 memcpy(&ps_dec_thd->as_recent_fld[1][1], &ps_dec->as_recent_fld[1][1], sizeof(yuv_buf_t));
1116 memcpy(&ps_dec_thd->as_ref_buf, &ps_dec->as_ref_buf, sizeof(yuv_buf_t) * 2 * 2);
1117
1118
1119 ps_dec_thd->pf_decode_slice = ps_dec->pf_decode_slice;
1120
1121 ps_dec_thd->pf_vld_inv_quant = ps_dec->pf_vld_inv_quant;
1122
1123 memcpy(ps_dec_thd->pf_idct_recon, ps_dec->pf_idct_recon, sizeof(ps_dec->pf_idct_recon));
1124
1125 memcpy(ps_dec_thd->pf_mc, ps_dec->pf_mc, sizeof(ps_dec->pf_mc));
1126 ps_dec_thd->pf_interpolate = ps_dec->pf_interpolate;
1127 ps_dec_thd->pf_copy_mb = ps_dec->pf_copy_mb;
1128 ps_dec_thd->pf_fullx_halfy_8x8 = ps_dec->pf_fullx_halfy_8x8;
1129 ps_dec_thd->pf_halfx_fully_8x8 = ps_dec->pf_halfx_fully_8x8;
1130 ps_dec_thd->pf_halfx_halfy_8x8 = ps_dec->pf_halfx_halfy_8x8;
1131 ps_dec_thd->pf_fullx_fully_8x8 = ps_dec->pf_fullx_fully_8x8;
1132
1133 ps_dec_thd->pf_memset_8bit_8x8_block = ps_dec->pf_memset_8bit_8x8_block;
1134 ps_dec_thd->pf_memset_16bit_8x8_linear_block = ps_dec->pf_memset_16bit_8x8_linear_block;
1135 ps_dec_thd->pf_copy_yuv420p_buf = ps_dec->pf_copy_yuv420p_buf;
1136 ps_dec_thd->pf_fmt_conv_yuv420p_to_yuv422ile = ps_dec->pf_fmt_conv_yuv420p_to_yuv422ile;
1137 ps_dec_thd->pf_fmt_conv_yuv420p_to_yuv420sp_uv = ps_dec->pf_fmt_conv_yuv420p_to_yuv420sp_uv;
1138 ps_dec_thd->pf_fmt_conv_yuv420p_to_yuv420sp_vu = ps_dec->pf_fmt_conv_yuv420p_to_yuv420sp_vu;
1139
1140
1141 memcpy(ps_dec_thd->au1_intra_quant_matrix, ps_dec->au1_intra_quant_matrix, NUM_PELS_IN_BLOCK * sizeof(UWORD8));
1142 memcpy(ps_dec_thd->au1_inter_quant_matrix, ps_dec->au1_inter_quant_matrix, NUM_PELS_IN_BLOCK * sizeof(UWORD8));
1143 ps_dec_thd->pu1_inv_scan_matrix = ps_dec->pu1_inv_scan_matrix;
1144
1145
1146 ps_dec_thd->u2_progressive_sequence = ps_dec->u2_progressive_sequence;
1147 ps_dec_thd->e_pic_type = ps_dec->e_pic_type;
1148 ps_dec_thd->u2_full_pel_forw_vector = ps_dec->u2_full_pel_forw_vector;
1149 ps_dec_thd->u2_forw_f_code = ps_dec->u2_forw_f_code;
1150 ps_dec_thd->u2_full_pel_back_vector = ps_dec->u2_full_pel_back_vector;
1151 ps_dec_thd->u2_back_f_code = ps_dec->u2_back_f_code;
1152
1153 memcpy(ps_dec_thd->ai2_mv, ps_dec->ai2_mv, (2*2*2)*sizeof(WORD16));
1154 memcpy(ps_dec_thd->au2_f_code, ps_dec->au2_f_code, (2*2)*sizeof(UWORD16));
1155 ps_dec_thd->u2_intra_dc_precision = ps_dec->u2_intra_dc_precision;
1156 ps_dec_thd->u2_picture_structure = ps_dec->u2_picture_structure;
1157 ps_dec_thd->u2_top_field_first = ps_dec->u2_top_field_first;
1158 ps_dec_thd->u2_frame_pred_frame_dct = ps_dec->u2_frame_pred_frame_dct;
1159 ps_dec_thd->u2_concealment_motion_vectors = ps_dec->u2_concealment_motion_vectors;
1160 ps_dec_thd->u2_q_scale_type = ps_dec->u2_q_scale_type;
1161 ps_dec_thd->u2_intra_vlc_format = ps_dec->u2_intra_vlc_format;
1162 ps_dec_thd->u2_alternate_scan = ps_dec->u2_alternate_scan;
1163 ps_dec_thd->u2_repeat_first_field = ps_dec->u2_repeat_first_field;
1164 ps_dec_thd->u2_progressive_frame = ps_dec->u2_progressive_frame;
1165 ps_dec_thd->pu1_inp_bits_buf = ps_dec->pu1_inp_bits_buf;
1166 ps_dec_thd->u4_num_inp_bytes = ps_dec->u4_num_inp_bytes;
1167 ps_dec_thd->pv_jobq = ps_dec->pv_jobq;
1168 ps_dec_thd->pv_jobq_buf = ps_dec->pv_jobq_buf;
1169 ps_dec_thd->i4_jobq_buf_size = ps_dec->i4_jobq_buf_size;
1170
1171
1172 ps_dec_thd->u2_frame_rate_code = ps_dec->u2_frame_rate_code;
1173 ps_dec_thd->u2_frame_rate_extension_n = ps_dec->u2_frame_rate_extension_n;
1174 ps_dec_thd->u2_frame_rate_extension_d = ps_dec->u2_frame_rate_extension_d;
1175 ps_dec_thd->u2_framePeriod = ps_dec->u2_framePeriod;
1176 ps_dec_thd->u2_display_horizontal_size = ps_dec->u2_display_horizontal_size;
1177 ps_dec_thd->u2_display_vertical_size = ps_dec->u2_display_vertical_size;
1178 ps_dec_thd->u2_aspect_ratio_info = ps_dec->u2_aspect_ratio_info;
1179
1180 ps_dec_thd->ps_func_bi_direct = ps_dec->ps_func_bi_direct;
1181 ps_dec_thd->ps_func_forw_or_back = ps_dec->ps_func_forw_or_back;
1182 ps_dec_thd->pv_deinterlacer_ctxt = ps_dec->pv_deinterlacer_ctxt;
1183 ps_dec_thd->ps_deint_pic = ps_dec->ps_deint_pic;
1184
1185 return 0;
1186 }
1187
1188
impeg2d_get_slice_pos(dec_state_multi_core_t * ps_dec_state_multi_core)1189 WORD32 impeg2d_get_slice_pos(dec_state_multi_core_t *ps_dec_state_multi_core)
1190 {
1191 WORD32 u4_bits;
1192 WORD32 i4_row;
1193
1194
1195 dec_state_t *ps_dec = ps_dec_state_multi_core->ps_dec_state[0];
1196 WORD32 i4_prev_row;
1197 stream_t s_bitstrm;
1198 WORD32 i4_start_row;
1199 WORD32 i4_slice_bistream_ofst;
1200 WORD32 i;
1201 s_bitstrm = ps_dec->s_bit_stream;
1202 i4_prev_row = -1;
1203
1204 ps_dec_state_multi_core->ps_dec_state[0]->i4_start_mb_y = 0;
1205 ps_dec_state_multi_core->ps_dec_state[1]->i4_start_mb_y = -1;
1206 ps_dec_state_multi_core->ps_dec_state[2]->i4_start_mb_y = -1;
1207 ps_dec_state_multi_core->ps_dec_state[3]->i4_start_mb_y = -1;
1208
1209 ps_dec_state_multi_core->ps_dec_state[0]->i4_end_mb_y = ps_dec->u2_num_vert_mb;
1210 ps_dec_state_multi_core->ps_dec_state[1]->i4_end_mb_y = -1;
1211 ps_dec_state_multi_core->ps_dec_state[2]->i4_end_mb_y = -1;
1212 ps_dec_state_multi_core->ps_dec_state[3]->i4_end_mb_y = -1;
1213
1214 if(ps_dec->i4_num_cores == 1)
1215 return 0;
1216 /* Reset the jobq to start of the jobq buffer */
1217 impeg2_jobq_reset((jobq_t *)ps_dec->pv_jobq);
1218
1219 i4_start_row = -1;
1220 i4_slice_bistream_ofst = 0;
1221 while(1)
1222 {
1223 WORD32 i4_is_slice;
1224
1225 if(s_bitstrm.u4_offset + START_CODE_LEN >= s_bitstrm.u4_max_offset)
1226 {
1227 break;
1228 }
1229 u4_bits = impeg2d_bit_stream_nxt(&s_bitstrm,START_CODE_LEN);
1230
1231 i4_row = u4_bits & 0xFF;
1232
1233 /* Detect end of frame */
1234 i4_is_slice = (((u4_bits >> 8) == 0x01) && (i4_row) && (i4_row <= ps_dec->u2_num_vert_mb));
1235 if(!i4_is_slice)
1236 break;
1237
1238 i4_row -= 1;
1239
1240
1241 if(i4_prev_row < i4_row)
1242 {
1243 /* Create a job for previous slice row */
1244 if(i4_start_row != -1)
1245 {
1246 job_t s_job;
1247 IV_API_CALL_STATUS_T ret;
1248 s_job.i2_start_mb_y = i4_start_row;
1249 s_job.i2_end_mb_y = i4_row;
1250 s_job.i4_cmd = CMD_PROCESS;
1251 s_job.i4_bistream_ofst = i4_slice_bistream_ofst;
1252 ret = impeg2_jobq_queue(ps_dec->pv_jobq, &s_job, sizeof(s_job), 1, 0);
1253 if(ret != IV_SUCCESS)
1254 return ret;
1255
1256 }
1257 /* Store current slice's bitstream offset */
1258 i4_slice_bistream_ofst = s_bitstrm.u4_offset >> 3;
1259 i4_slice_bistream_ofst -= (size_t)s_bitstrm.pv_bs_buf & 3;
1260 i4_prev_row = i4_row;
1261
1262 /* Store current slice's row position */
1263 i4_start_row = i4_row;
1264
1265 }
1266 #ifdef __ANDROID__
1267 else if (i4_prev_row > i4_row)
1268 {
1269 android_errorWriteLog(0x534e4554, "26070014");
1270 }
1271 #endif
1272
1273 impeg2d_bit_stream_flush(&s_bitstrm, START_CODE_LEN);
1274
1275 // flush bytes till next start code
1276 /* Flush the bytes till a start code is encountered */
1277 while(impeg2d_bit_stream_nxt(&s_bitstrm, 24) != START_CODE_PREFIX)
1278 {
1279 impeg2d_bit_stream_get(&s_bitstrm, 8);
1280
1281 if(s_bitstrm.u4_offset >= s_bitstrm.u4_max_offset)
1282 {
1283 break;
1284 }
1285 }
1286 }
1287
1288 /* Create job for the last slice row */
1289 {
1290 job_t s_job;
1291 IV_API_CALL_STATUS_T e_ret;
1292 s_job.i2_start_mb_y = i4_start_row;
1293 s_job.i2_end_mb_y = ps_dec->u2_num_vert_mb;
1294 s_job.i4_cmd = CMD_PROCESS;
1295 s_job.i4_bistream_ofst = i4_slice_bistream_ofst;
1296 e_ret = impeg2_jobq_queue(ps_dec->pv_jobq, &s_job, sizeof(s_job), 1, 0);
1297 if(e_ret != IV_SUCCESS)
1298 return e_ret;
1299
1300 }
1301 if((NULL != ps_dec->ps_disp_pic) && ((0 == ps_dec->u4_share_disp_buf) || (IV_YUV_420P != ps_dec->i4_chromaFormat)))
1302 {
1303 for(i = 0; i < ps_dec->u2_vertical_size; i+=64)
1304 {
1305 job_t s_job;
1306 IV_API_CALL_STATUS_T ret;
1307 s_job.i2_start_mb_y = i;
1308 s_job.i2_start_mb_y >>= 4;
1309 s_job.i2_end_mb_y = (i + 64);
1310 s_job.i2_end_mb_y >>= 4;
1311 s_job.i4_cmd = CMD_FMTCONV;
1312 s_job.i4_bistream_ofst = 0;
1313 ret = impeg2_jobq_queue(ps_dec->pv_jobq, &s_job, sizeof(s_job), 1, 0);
1314 if(ret != IV_SUCCESS)
1315 return ret;
1316
1317 }
1318 }
1319
1320 impeg2_jobq_terminate(ps_dec->pv_jobq);
1321 ps_dec->i4_bytes_consumed = s_bitstrm.u4_offset >> 3;
1322 ps_dec->i4_bytes_consumed -= ((size_t)s_bitstrm.pv_bs_buf & 3);
1323
1324 return 0;
1325 }
1326
1327 /*******************************************************************************
1328 *
1329 * Function Name : impeg2d_dec_pic_data
1330 *
1331 * Description : It intializes several parameters and decodes a Picture
1332 * till any slice is left.
1333 *
1334 * Arguments :
1335 * dec : Decoder context
1336 *
1337 * Values Returned : None
1338 *******************************************************************************/
1339
impeg2d_dec_pic_data(dec_state_t * ps_dec)1340 void impeg2d_dec_pic_data(dec_state_t *ps_dec)
1341 {
1342
1343 WORD32 i;
1344 dec_state_multi_core_t *ps_dec_state_multi_core;
1345
1346 UWORD32 u4_error_code;
1347
1348 dec_state_t *ps_dec_thd;
1349 WORD32 i4_status;
1350 WORD32 i4_min_mb_y;
1351
1352
1353 /* Resetting the MB address and MB coordinates at the start of the Frame */
1354 ps_dec->u2_mb_x = ps_dec->u2_mb_y = 0;
1355 u4_error_code = 0;
1356
1357 ps_dec_state_multi_core = ps_dec->ps_dec_state_multi_core;
1358 impeg2d_get_slice_pos(ps_dec_state_multi_core);
1359
1360 i4_min_mb_y = 1;
1361 for(i=0; i < ps_dec->i4_num_cores - 1; i++)
1362 {
1363 // initialize decoder context for thread
1364 // launch dec->u4_num_cores-1 threads
1365
1366 ps_dec_thd = ps_dec_state_multi_core->ps_dec_state[i+1];
1367
1368 ps_dec_thd->ps_disp_pic = ps_dec->ps_disp_pic;
1369 ps_dec_thd->ps_disp_frm_buf = ps_dec->ps_disp_frm_buf;
1370
1371 i4_status = impeg2d_init_thread_dec_ctxt(ps_dec, ps_dec_thd, i4_min_mb_y);
1372 //impeg2d_dec_pic_data_thread(ps_dec_thd);
1373
1374 if(i4_status == 0)
1375 {
1376 ithread_create(ps_dec_thd->pv_codec_thread_handle, NULL, (void *)impeg2d_dec_pic_data_thread, ps_dec_thd);
1377 ps_dec_state_multi_core->au4_thread_launched[i + 1] = 1;
1378 i4_min_mb_y = ps_dec_thd->u2_mb_y + 1;
1379 }
1380 else
1381 {
1382 ps_dec_state_multi_core->au4_thread_launched[i + 1] = 0;
1383 break;
1384 }
1385 }
1386
1387 impeg2d_dec_pic_data_thread(ps_dec);
1388
1389 // wait for threads to complete
1390 for(i=0; i < (ps_dec->i4_num_cores - 1); i++)
1391 {
1392 if(ps_dec_state_multi_core->au4_thread_launched[i + 1] == 1)
1393 {
1394 ps_dec_thd = ps_dec_state_multi_core->ps_dec_state[i+1];
1395 ithread_join(ps_dec_thd->pv_codec_thread_handle, NULL);
1396 }
1397 }
1398
1399 ps_dec->u4_error_code = u4_error_code;
1400
1401 }
1402 /*******************************************************************************
1403 *
1404 * Function Name : impeg2d_flush_ext_and_user_data
1405 *
1406 * Description : Flushes the extension and user data present in the
1407 * stream_t
1408 *
1409 * Arguments :
1410 * dec : Decoder context
1411 *
1412 * Values Returned : None
1413 *******************************************************************************/
impeg2d_flush_ext_and_user_data(dec_state_t * ps_dec)1414 void impeg2d_flush_ext_and_user_data(dec_state_t *ps_dec)
1415 {
1416 UWORD32 u4_start_code;
1417 stream_t *ps_stream;
1418
1419 ps_stream = &ps_dec->s_bit_stream;
1420 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1421
1422 while((u4_start_code == EXTENSION_START_CODE || u4_start_code == USER_DATA_START_CODE) &&
1423 (ps_stream->u4_offset < ps_stream->u4_max_offset))
1424 {
1425 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
1426 while(impeg2d_bit_stream_nxt(ps_stream,START_CODE_PREFIX_LEN) != START_CODE_PREFIX &&
1427 (ps_stream->u4_offset < ps_stream->u4_max_offset))
1428 {
1429 impeg2d_bit_stream_flush(ps_stream,8);
1430 }
1431 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1432 }
1433 }
1434 /*******************************************************************************
1435 *
1436 * Function Name : impeg2d_dec_user_data
1437 *
1438 * Description : Flushes the user data present in the stream_t
1439 *
1440 * Arguments :
1441 * dec : Decoder context
1442 *
1443 * Values Returned : None
1444 *******************************************************************************/
impeg2d_dec_user_data(dec_state_t * ps_dec)1445 void impeg2d_dec_user_data(dec_state_t *ps_dec)
1446 {
1447 UWORD32 u4_start_code;
1448 stream_t *ps_stream;
1449
1450 ps_stream = &ps_dec->s_bit_stream;
1451 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1452
1453 while(u4_start_code == USER_DATA_START_CODE)
1454 {
1455 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
1456 while((impeg2d_bit_stream_nxt(ps_stream,START_CODE_PREFIX_LEN) != START_CODE_PREFIX) &&
1457 (ps_stream->u4_offset < ps_stream->u4_max_offset))
1458 {
1459 impeg2d_bit_stream_flush(ps_stream,8);
1460 }
1461 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1462 }
1463 }
1464 /*******************************************************************************
1465 * Function Name : impeg2d_dec_seq_ext_data
1466 *
1467 * Description : Decodes the extension data following Sequence
1468 * Extension. It flushes any user data if present
1469 *
1470 * Arguments :
1471 * dec : Decoder context
1472 *
1473 * Values Returned : None
1474 *******************************************************************************/
impeg2d_dec_seq_ext_data(dec_state_t * ps_dec)1475 IMPEG2D_ERROR_CODES_T impeg2d_dec_seq_ext_data(dec_state_t *ps_dec)
1476 {
1477 stream_t *ps_stream;
1478 UWORD32 u4_start_code;
1479 IMPEG2D_ERROR_CODES_T e_error;
1480
1481 e_error = (IMPEG2D_ERROR_CODES_T) IVD_ERROR_NONE;
1482
1483 ps_stream = &ps_dec->s_bit_stream;
1484 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1485 while( (u4_start_code == EXTENSION_START_CODE ||
1486 u4_start_code == USER_DATA_START_CODE) &&
1487 (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE == e_error &&
1488 (ps_stream->u4_offset < ps_stream->u4_max_offset))
1489 {
1490 if(u4_start_code == USER_DATA_START_CODE)
1491 {
1492 impeg2d_dec_user_data(ps_dec);
1493 }
1494 else
1495 {
1496 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
1497 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,EXT_ID_LEN);
1498 switch(u4_start_code)
1499 {
1500 case SEQ_DISPLAY_EXT_ID:
1501 impeg2d_dec_seq_disp_ext(ps_dec);
1502 break;
1503 case SEQ_SCALABLE_EXT_ID:
1504 e_error = IMPEG2D_SCALABILITIY_NOT_SUPPORTED;
1505 break;
1506 default:
1507 /* In case its a reserved extension code */
1508 impeg2d_bit_stream_flush(ps_stream,EXT_ID_LEN);
1509 impeg2d_peek_next_start_code(ps_dec);
1510 break;
1511 }
1512 }
1513 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1514 }
1515 return e_error;
1516 }
1517 /*******************************************************************************
1518 * Function Name : impeg2d_dec_pic_ext_data
1519 *
1520 * Description : Decodes the extension data following Picture Coding
1521 * Extension. It flushes any user data if present
1522 *
1523 * Arguments :
1524 * dec : Decoder context
1525 *
1526 * Values Returned : None
1527 *******************************************************************************/
impeg2d_dec_pic_ext_data(dec_state_t * ps_dec)1528 IMPEG2D_ERROR_CODES_T impeg2d_dec_pic_ext_data(dec_state_t *ps_dec)
1529 {
1530 stream_t *ps_stream;
1531 UWORD32 u4_start_code;
1532 IMPEG2D_ERROR_CODES_T e_error;
1533
1534 e_error = (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
1535
1536 ps_stream = &ps_dec->s_bit_stream;
1537 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1538 while ( (u4_start_code == EXTENSION_START_CODE ||
1539 u4_start_code == USER_DATA_START_CODE) &&
1540 (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE == e_error &&
1541 (ps_stream->u4_offset < ps_stream->u4_max_offset))
1542 {
1543 if(u4_start_code == USER_DATA_START_CODE)
1544 {
1545 impeg2d_dec_user_data(ps_dec);
1546 }
1547 else
1548 {
1549 impeg2d_bit_stream_flush(ps_stream,START_CODE_LEN);
1550 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,EXT_ID_LEN);
1551 switch(u4_start_code)
1552 {
1553 case QUANT_MATRIX_EXT_ID:
1554 impeg2d_dec_quant_matrix_ext(ps_dec);
1555 break;
1556 case COPYRIGHT_EXT_ID:
1557 impeg2d_dec_copyright_ext(ps_dec);
1558 break;
1559 case PIC_DISPLAY_EXT_ID:
1560 impeg2d_dec_pic_disp_ext(ps_dec);
1561 break;
1562 case CAMERA_PARAM_EXT_ID:
1563 impeg2d_dec_cam_param_ext(ps_dec);
1564 break;
1565 case ITU_T_EXT_ID:
1566 impeg2d_dec_itu_t_ext(ps_dec);
1567 break;
1568 case PIC_SPATIAL_SCALABLE_EXT_ID:
1569 case PIC_TEMPORAL_SCALABLE_EXT_ID:
1570 e_error = IMPEG2D_SCALABLITY_NOT_SUP;
1571 break;
1572 default:
1573 /* In case its a reserved extension code */
1574 impeg2d_bit_stream_flush(ps_stream,EXT_ID_LEN);
1575 impeg2d_next_start_code(ps_dec);
1576 break;
1577 }
1578 }
1579 u4_start_code = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1580 }
1581 return e_error;
1582 }
1583
1584 /*******************************************************************************
1585 *
1586 * Function Name : impeg2d_process_video_header
1587 *
1588 * Description : Processes video sequence header information
1589 *
1590 * Arguments :
1591 * dec : Decoder context
1592 *
1593 * Values Returned : None
1594 *******************************************************************************/
impeg2d_process_video_header(dec_state_t * ps_dec)1595 IMPEG2D_ERROR_CODES_T impeg2d_process_video_header(dec_state_t *ps_dec)
1596 {
1597 stream_t *ps_stream;
1598 ps_stream = &ps_dec->s_bit_stream;
1599 IMPEG2D_ERROR_CODES_T e_error;
1600
1601 impeg2d_next_code(ps_dec, SEQUENCE_HEADER_CODE);
1602 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1603 {
1604 e_error = impeg2d_dec_seq_hdr(ps_dec);
1605 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1606 {
1607 return e_error;
1608 }
1609 }
1610 else
1611 {
1612 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
1613 }
1614 if (impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) == EXTENSION_START_CODE)
1615 {
1616 /* MPEG2 Decoder */
1617 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1618 {
1619 e_error = impeg2d_dec_seq_ext(ps_dec);
1620 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1621 {
1622 return e_error;
1623 }
1624 }
1625 else
1626 {
1627 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
1628 }
1629 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1630 {
1631 e_error = impeg2d_dec_seq_ext_data(ps_dec);
1632 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1633 {
1634 return e_error;
1635 }
1636 }
1637 return impeg2d_init_video_state(ps_dec,MPEG_2_VIDEO);
1638 }
1639 else
1640 {
1641 /* MPEG1 Decoder */
1642 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1643 {
1644 impeg2d_flush_ext_and_user_data(ps_dec);
1645 }
1646 return impeg2d_init_video_state(ps_dec,MPEG_1_VIDEO);
1647 }
1648 }
1649 /*******************************************************************************
1650 *
1651 * Function Name : impeg2d_process_video_bit_stream
1652 *
1653 * Description : Processes video sequence header information
1654 *
1655 * Arguments :
1656 * dec : Decoder context
1657 *
1658 * Values Returned : None
1659 *******************************************************************************/
impeg2d_process_video_bit_stream(dec_state_t * ps_dec)1660 IMPEG2D_ERROR_CODES_T impeg2d_process_video_bit_stream(dec_state_t *ps_dec)
1661 {
1662 stream_t *ps_stream;
1663 UWORD32 u4_next_bits, u4_start_code_found;
1664 IMPEG2D_ERROR_CODES_T e_error;
1665
1666 ps_stream = &ps_dec->s_bit_stream;
1667 impeg2d_next_start_code(ps_dec);
1668 /* If the stream is MPEG-2 compliant stream */
1669 u4_start_code_found = 0;
1670
1671 if(ps_dec->u2_is_mpeg2)
1672 {
1673 /* MPEG2 decoding starts */
1674 while((u4_start_code_found == 0) && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
1675 {
1676 u4_next_bits = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1677
1678 if(u4_next_bits == SEQUENCE_HEADER_CODE)
1679 {
1680 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1681 {
1682 e_error = impeg2d_dec_seq_hdr(ps_dec);
1683 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1684 {
1685 return e_error;
1686 }
1687
1688 u4_start_code_found = 0;
1689
1690 }
1691 else
1692 {
1693 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
1694 }
1695
1696
1697 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1698 {
1699 IMPEG2D_ERROR_CODES_T e_error;
1700 e_error = impeg2d_dec_seq_ext(ps_dec);
1701 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1702 {
1703 return e_error;
1704 }
1705 u4_start_code_found = 0;
1706
1707 }
1708 else
1709 {
1710 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
1711 }
1712 }
1713 else if((u4_next_bits == USER_DATA_START_CODE) || (u4_next_bits == EXTENSION_START_CODE))
1714 {
1715 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1716 {
1717 impeg2d_dec_seq_ext_data(ps_dec);
1718 u4_start_code_found = 0;
1719
1720 }
1721
1722 }
1723 else if((ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1724 && (u4_next_bits == GOP_START_CODE))
1725 {
1726 impeg2d_dec_grp_of_pic_hdr(ps_dec);
1727 impeg2d_dec_user_data(ps_dec);
1728 u4_start_code_found = 0;
1729
1730 }
1731 else if((ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1732 && (u4_next_bits == PICTURE_START_CODE))
1733 {
1734
1735 e_error = impeg2d_dec_pic_hdr(ps_dec);
1736 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1737 {
1738 return e_error;
1739 }
1740 e_error = impeg2d_dec_pic_coding_ext(ps_dec);
1741 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1742 {
1743 return e_error;
1744 }
1745 e_error = impeg2d_dec_pic_ext_data(ps_dec);
1746 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1747 {
1748 return e_error;
1749 }
1750 impeg2d_pre_pic_dec_proc(ps_dec);
1751 impeg2d_dec_pic_data(ps_dec);
1752 impeg2d_post_pic_dec_proc(ps_dec);
1753 u4_start_code_found = 1;
1754 }
1755 else
1756
1757 {
1758 FLUSH_BITS(ps_dec->s_bit_stream.u4_offset, ps_dec->s_bit_stream.u4_buf, ps_dec->s_bit_stream.u4_buf_nxt, 8, ps_dec->s_bit_stream.pu4_buf_aligned);
1759
1760 }
1761 if(u4_start_code_found == 0)
1762 {
1763 impeg2d_next_start_code(ps_dec);
1764 /* In case a dec_pic_data call has not been made, the number of
1765 * bytes consumed in the previous header decode has to be
1766 * consumed. Not consuming it will result in zero bytes consumed
1767 * loops in case there are multiple headers and the second
1768 * or a future header has a resolution change/other error where
1769 * the bytes of the last header are not consumed.
1770 */
1771 ps_dec->i4_bytes_consumed = (ps_dec->s_bit_stream.u4_offset + 7) >> 3;
1772 ps_dec->i4_bytes_consumed -= ((size_t)ps_dec->s_bit_stream.pv_bs_buf & 3);
1773 }
1774 }
1775 if((u4_start_code_found == 0) && (ps_dec->s_bit_stream.u4_offset > ps_dec->s_bit_stream.u4_max_offset))
1776 {
1777 return IMPEG2D_FRM_HDR_START_CODE_NOT_FOUND;
1778 }
1779
1780 }
1781 /* If the stream is MPEG-1 compliant stream */
1782 else
1783 {
1784 while((u4_start_code_found == 0) && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
1785 {
1786 u4_next_bits = impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN);
1787
1788 if(impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) == SEQUENCE_HEADER_CODE)
1789 {
1790 if(ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset)
1791 {
1792 e_error = impeg2d_dec_seq_hdr(ps_dec);
1793 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1794 {
1795 return e_error;
1796 }
1797
1798 u4_start_code_found = 0;
1799 }
1800 else
1801 {
1802 return IMPEG2D_BITSTREAM_BUFF_EXCEEDED_ERR;
1803 }
1804 }
1805 else if((ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset) && (u4_next_bits == EXTENSION_START_CODE || u4_next_bits == USER_DATA_START_CODE))
1806 {
1807 impeg2d_flush_ext_and_user_data(ps_dec);
1808 u4_start_code_found = 0;
1809 }
1810
1811
1812 else if ((impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) == GOP_START_CODE)
1813 && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
1814 {
1815 impeg2d_dec_grp_of_pic_hdr(ps_dec);
1816 impeg2d_flush_ext_and_user_data(ps_dec);
1817 u4_start_code_found = 0;
1818 }
1819 else if ((impeg2d_bit_stream_nxt(ps_stream,START_CODE_LEN) == PICTURE_START_CODE)
1820 && (ps_dec->s_bit_stream.u4_offset < ps_dec->s_bit_stream.u4_max_offset))
1821 {
1822
1823 e_error = impeg2d_dec_pic_hdr(ps_dec);
1824 if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
1825 {
1826 return e_error;
1827 }
1828 impeg2d_flush_ext_and_user_data(ps_dec);
1829 impeg2d_pre_pic_dec_proc(ps_dec);
1830 impeg2d_dec_pic_data(ps_dec);
1831 impeg2d_post_pic_dec_proc(ps_dec);
1832 u4_start_code_found = 1;
1833 }
1834 else
1835 {
1836 FLUSH_BITS(ps_dec->s_bit_stream.u4_offset, ps_dec->s_bit_stream.u4_buf, ps_dec->s_bit_stream.u4_buf_nxt, 8, ps_dec->s_bit_stream.pu4_buf_aligned);
1837 }
1838 impeg2d_next_start_code(ps_dec);
1839 if (0 == u4_start_code_found)
1840 {
1841 /* In case a dec_pic_data call has not been made, the number of
1842 * bytes consumed in the previous header decode has to be
1843 * consumed. Not consuming it will result in zero bytes consumed
1844 * loops in case there are multiple headers and the second
1845 * or a future header has a resolution change/other error where
1846 * the bytes of the last header are not consumed.
1847 */
1848 ps_dec->i4_bytes_consumed = (ps_dec->s_bit_stream.u4_offset + 7) >> 3;
1849 ps_dec->i4_bytes_consumed -= ((size_t)ps_dec->s_bit_stream.pv_bs_buf & 3);
1850 }
1851 }
1852 if((u4_start_code_found == 0) && (ps_dec->s_bit_stream.u4_offset > ps_dec->s_bit_stream.u4_max_offset))
1853 {
1854 return IMPEG2D_FRM_HDR_START_CODE_NOT_FOUND;
1855 }
1856 }
1857
1858 return (IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE;
1859 }
1860