1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #include "mp4dec_lib.h"
19 #include "bitstream.h"
20 #include "vlc_decode.h"
21 #include "zigzag.h"
22
23 #define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
24 #include "osclconfig_compiler_warnings.h"
25
26 #ifdef PV_SUPPORT_MAIN_PROFILE
27 /* INTRA */
28 const static int mpeg_iqmat_def[NCOEFF_BLOCK] =
29 {
30 8, 17, 18, 19, 21, 23, 25, 27,
31 17, 18, 19, 21, 23, 25, 27, 28,
32 20, 21, 22, 23, 24, 26, 28, 30,
33 21, 22, 23, 24, 26, 28, 30, 32,
34 22, 23, 24, 26, 28, 30, 32, 35,
35 23, 24, 26, 28, 30, 32, 35, 38,
36 25, 26, 28, 30, 32, 35, 38, 41,
37 27, 28, 30, 32, 35, 38, 41, 45
38 };
39
40 /* INTER */
41 const static int mpeg_nqmat_def[64] =
42 {
43 16, 17, 18, 19, 20, 21, 22, 23,
44 17, 18, 19, 20, 21, 22, 23, 24,
45 18, 19, 20, 21, 22, 23, 24, 25,
46 19, 20, 21, 22, 23, 24, 26, 27,
47 20, 21, 22, 23, 25, 26, 27, 28,
48 21, 22, 23, 24, 26, 27, 28, 30,
49 22, 23, 24, 26, 27, 28, 30, 31,
50 23, 24, 25, 27, 28, 30, 31, 33
51 };
52 #endif
53
54 /* ======================================================================== */
55 /* Function : CalcNumBits() */
56 /* Purpose : */
57 /* In/out : */
58 /* Return : Calculate the minimum number of bits required to */
59 /* represent x. */
60 /* Note : This is an equivalent implementation of */
61 /* (long)ceil(log((double)x)/log(2.0)) */
62 /* Modified : */
63 /* ======================================================================== */
CalcNumBits(uint x)64 int CalcNumBits(uint x)
65 {
66 int i = 1;
67 while (x >>= 1) i++;
68 return i;
69 }
70
71
72
73 /***********************************************************CommentBegin******
74 *
75 * -- DecodeVolHeader -- Decode the header of a VOL
76 *
77 * 04/10/2000 : initial modification to the new PV-Decoder Lib format.
78 * 10/12/2001 : reject non compliant bitstreams
79 *
80 ***********************************************************CommentEnd********/
DecodeVOLHeader(VideoDecData * video,int layer)81 PV_STATUS DecodeVOLHeader(VideoDecData *video, int layer)
82 {
83 PV_STATUS status;
84 Vol *currVol;
85 BitstreamDecVideo *stream;
86 uint32 tmpvar, vol_shape;
87 uint32 startCode;
88 #ifdef PV_SUPPORT_MAIN_PROFILE
89 int *qmat, i, j;
90 #endif
91 int version_id = 1;
92 #ifdef PV_TOLERATE_VOL_ERRORS
93 uint32 profile = 0x01;
94 #endif
95 /* There's a "currLayer" variable inside videoDecData. */
96 /* However, we don't maintain it until we decode frame data. 04/05/2000 */
97 currVol = video->vol[layer];
98 stream = currVol->bitstream;
99 currVol->moduloTimeBase = 0;
100
101 /* Determine which start code for the decoder to begin with */
102 status = BitstreamShowBits32HC(stream, &startCode);
103
104 if (startCode == VISUAL_OBJECT_SEQUENCE_START_CODE)
105 { /* Bitstream Exhchange Fix 9/99 */
106 /* Bitstream Exchange requires we allow start with Video Object Sequence */
107 /* visual_object_sequence_start_code */
108 (void) BitstreamReadBits32HC(stream);
109 tmpvar = (uint32) BitstreamReadBits16(stream, 8); /* profile */
110 #ifndef PV_TOLERATE_VOL_ERRORS
111 if (layer) /* */
112 {
113 /* support SSPL0-2 */
114 if (tmpvar != 0x10 && tmpvar != 0x11 && tmpvar != 0x12 &&
115 tmpvar != 0xA1 && tmpvar != 0xA2 && tmpvar != 0xA3/* Core SP@L1-L3 */)
116 return PV_FAIL;
117 }
118 else
119 {
120 /* support SPL0-3 & SSPL0-2 */
121 if (tmpvar != 0x01 && tmpvar != 0x02 && tmpvar != 0x03 && tmpvar != 0x08 &&
122 tmpvar != 0x10 && tmpvar != 0x11 && tmpvar != 0x12 &&
123 tmpvar != 0x21 && tmpvar != 0x22 && /* Core Profile Levels */
124 tmpvar != 0xA1 && tmpvar != 0xA2 && tmpvar != 0xA3 &&
125 tmpvar != 0xF0 && tmpvar != 0xF1 && /* Advanced Simple Profile Levels*/
126 tmpvar != 0xF2 && tmpvar != 0xF3 &&
127 tmpvar != 0xF4 && tmpvar != 0xF5)
128 return PV_FAIL;
129 }
130 #else
131 profile = tmpvar;
132 #endif
133
134 // save the profile and level for the query
135 currVol->profile_level_id = (uint)tmpvar; // 6/10/04
136
137
138
139 status = BitstreamShowBits32HC(stream, &tmpvar);
140 if (tmpvar == USER_DATA_START_CODE)
141 {
142 /* Something has to be done with user data 11/11/99 */
143 status = DecodeUserData(stream);
144 if (status != PV_SUCCESS) return PV_FAIL;
145 }
146 /* visual_object_start_code */
147 BitstreamShowBits32HC(stream, &tmpvar);
148 if (tmpvar != VISUAL_OBJECT_START_CODE)
149 {
150 do
151 {
152 /* Search for VOL_HEADER */
153 status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
154 if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
155 BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
156 PV_BitstreamFlushBits(stream, 8);
157 }
158 while (tmpvar != VOL_START_CODE);
159 goto decode_vol;
160 }
161 else
162 {
163 BitstreamReadBits32HC(stream);
164 }
165
166 /* is_visual_object_identifier */
167 tmpvar = (uint32) BitstreamRead1Bits(stream);
168 if (tmpvar)
169 {
170 /* visual_object_verid */
171 tmpvar = (uint32) BitstreamReadBits16(stream, 4);
172 /* visual_object_priority */
173 tmpvar = (uint32) BitstreamReadBits16(stream, 3);
174 }
175 /* visual_object_type */
176 BitstreamShowBits32(stream, 4, &tmpvar);
177 if (tmpvar == 1)
178 { /* video_signal_type */
179 PV_BitstreamFlushBits(stream, 4);
180 tmpvar = (uint32) BitstreamRead1Bits(stream);
181 if (tmpvar == 1)
182 {
183 /* video_format */
184 tmpvar = (uint32) BitstreamReadBits16(stream, 3);
185 /* video_range */
186 tmpvar = (uint32) BitstreamRead1Bits(stream);
187 /* color_description */
188 tmpvar = (uint32) BitstreamRead1Bits(stream);
189 if (tmpvar == 1)
190 {
191 /* color_primaries */
192 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
193 /* transfer_characteristics */
194 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
195 /* matrix_coefficients */
196 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
197 }
198 }
199 }
200 else
201 {
202 do
203 {
204 /* Search for VOL_HEADER */
205 status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
206 if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
207 BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
208 PV_BitstreamFlushBits(stream, 8);
209 }
210 while (tmpvar != VOL_START_CODE);
211 goto decode_vol;
212 }
213
214 /* next_start_code() */
215 status = PV_BitstreamByteAlign(stream); /* 10/12/01 */
216 status = BitstreamShowBits32HC(stream, &tmpvar);
217
218 if (tmpvar == USER_DATA_START_CODE)
219 {
220 /* Something has to be done to deal with user data (parse it) 11/11/99 */
221 status = DecodeUserData(stream);
222 if (status != PV_SUCCESS) return PV_FAIL;
223 }
224 status = BitstreamShowBits32(stream, 27, &tmpvar); /* 10/12/01 */
225 }
226 else
227 {
228 /* tmpvar = 0; */ /* 10/12/01 */
229 status = BitstreamShowBits32(stream, 27, &tmpvar); /* uncomment this line if you want
230 to start decoding with a
231 video_object_start_code */
232 }
233
234 if (tmpvar == VO_START_CODE)
235 {
236 /*****
237 *
238 * Read the VOL header entries from the bitstream
239 *
240 *****/
241 /* video_object_start_code */
242 tmpvar = BitstreamReadBits32(stream, 27);
243 tmpvar = (uint32) BitstreamReadBits16(stream, 5);
244
245
246 /* video_object_layer_start_code */
247 BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
248 if (tmpvar != VOL_START_CODE)
249 {
250 status = BitstreamCheckEndBuffer(stream);
251 if (status == PV_END_OF_VOP)
252 {
253 video->shortVideoHeader = TRUE;
254 return PV_SUCCESS;
255 }
256 else
257 {
258 do
259 {
260 /* Search for VOL_HEADER */
261 status = PVSearchNextM4VFrame(stream);/* search 0x00 0x00 0x01 */
262 if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
263 BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
264 PV_BitstreamFlushBits(stream, 8); /* advance the byte ptr */
265 }
266 while (tmpvar != VOL_START_CODE);
267 }
268 }
269 else
270 {
271 PV_BitstreamFlushBits(stream, 8);
272 }
273
274 decode_vol:
275 PV_BitstreamFlushBits(stream, VOL_START_CODE_LENGTH - 8);
276 video->shortVideoHeader = 0;
277
278 /* vol_id (4 bits) */
279 currVol->volID = (int) BitstreamReadBits16(stream, 4);
280
281 /* RandomAccessible flag */
282 tmpvar = (uint32) BitstreamRead1Bits(stream);
283
284 /* object type */
285 tmpvar = (uint32) BitstreamReadBits16(stream, 8); /* */
286
287 #ifdef PV_TOLERATE_VOL_ERRORS
288 if (tmpvar == 0)
289 {
290 if (layer) /* */
291 {
292 /* support SSPL0-2 */
293 if (profile != 0x10 && profile != 0x11 && profile != 0x12)
294 return PV_FAIL;
295 tmpvar = 0x02;
296 }
297 else
298 {
299 /* support SPL0-3 & SSPL0-2 */
300 if (profile != 0x01 && profile != 0x02 && profile != 0x03 && profile != 0x08 &&
301 profile != 0x10 && profile != 0x11 && profile != 0x12)
302 return PV_FAIL;
303 tmpvar = 0x01;
304 }
305 profile |= 0x0100;
306 }
307 #endif
308
309 if (layer)
310 {
311 if (tmpvar != 0x02) return PV_FAIL;
312 }
313 else
314 {
315 if (tmpvar != 0x01) return PV_FAIL;
316 }
317
318 /* version id specified? */
319 tmpvar = (uint32) BitstreamRead1Bits(stream);
320 if (tmpvar == 1)
321 {
322 /* version ID */
323 version_id = (uint32) BitstreamReadBits16(stream, 4);
324 /* priority */
325 tmpvar = (uint32) BitstreamReadBits16(stream, 3);
326
327 }
328
329 /* aspect ratio info */
330 tmpvar = (uint32) BitstreamReadBits16(stream, 4);
331 if (tmpvar == 0) return PV_FAIL;
332 if (tmpvar == 0xf /* extended_par */)
333 {
334 /* width */
335 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
336 /* height */
337 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
338 }
339
340
341 /* control parameters present? */
342 tmpvar = (uint32) BitstreamRead1Bits(stream);
343
344 /* Get the parameters (skipped) */
345 /* 03/10/99 */
346 if (tmpvar)
347 {
348 /* chroma_format */
349 tmpvar = BitstreamReadBits16(stream, 2);
350 if (tmpvar != 1) return PV_FAIL;
351 /* low_delay */
352 tmpvar = BitstreamRead1Bits(stream);
353
354 /* vbv_parameters present? */
355 tmpvar = (uint32) BitstreamRead1Bits(stream);
356 if (tmpvar)
357 {
358 /* first_half_bit_rate */
359 BitstreamReadBits16(stream, 15);
360 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
361 /* latter_half_bit_rate */
362 BitstreamReadBits16(stream, 15);
363 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
364 /* first_half_vbv_buffer_size */
365 BitstreamReadBits16(stream, 15);
366 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
367 /* latter_half_vbv_buffer_size */
368 BitstreamReadBits16(stream, 3);
369 /* first_half_vbv_occupancy */
370 BitstreamReadBits16(stream, 11);
371 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
372 /* latter_half_vbv_occupancy */
373 BitstreamReadBits16(stream, 15);
374 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
375 }
376 }
377
378 /* video_object_layer_shape (2 bits), only 00 (rect) is supported for now */
379 vol_shape = (uint32) BitstreamReadBits16(stream, 2);
380 if (vol_shape) return PV_FAIL;
381
382 /* marker bit, 03/10/99 */
383 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
384
385 /* vop_time_increment_resolution */
386 currVol->timeIncrementResolution = BitstreamReadBits16(stream, 16);
387 if (currVol->timeIncrementResolution == 0) return PV_FAIL;
388
389 /* . since nbitsTimeIncRes will be used over and over again, */
390 /* we should put it in Vol structure. 04/12/2000. */
391 currVol->nbitsTimeIncRes = CalcNumBits((uint)currVol->timeIncrementResolution - 1);
392
393 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
394
395 /* fixed_vop_rate */
396 currVol->fixedVopRate = (int) BitstreamRead1Bits(stream);
397 if (currVol->fixedVopRate)
398 {
399 /* fixed_vop_time_increment */
400 tmpvar = BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);
401 }
402
403 /* marker bit */
404 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
405
406 /* video_object_layer_width (13 bits) */
407 video->displayWidth = video->width = (int) BitstreamReadBits16(stream, 13);
408
409 /* round up to a multiple of MB_SIZE. 08/09/2000 */
410 video->width = (video->width + 15) & -16;
411 // video->displayWidth += (video->displayWidth & 0x1); /* displayed image should be even size */
412
413 /* marker bit */
414 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
415
416 /* video_object_layer_height (13 bits) */
417 video->displayHeight = video->height = (int) BitstreamReadBits16(stream, 13);
418
419 /* round up to a multiple of MB_SIZE. 08/09/2000 */
420 video->height = (video->height + 15) & -16;
421 // video->displayHeight += (video->displayHeight & 0x1); /* displayed image should be even size */
422 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
423
424 /* 03/10/99 */
425 /* interlaced */
426 tmpvar = (uint32) BitstreamRead1Bits(stream);
427 if (tmpvar != 0)
428 {
429 mp4dec_log("DecodeVOLHeader(): Interlaced video is not supported.\n");
430 return PV_FAIL;
431 }
432
433 /* obmc_disable */
434 tmpvar = (uint32) BitstreamRead1Bits(stream);
435 if (tmpvar == 0) return PV_FAIL;
436
437 if (version_id == 1)
438 {
439 /* sprite_enable (1 bits) */
440 tmpvar = (uint32) BitstreamRead1Bits(stream);
441 if (tmpvar)
442 {
443 mp4dec_log("DecodeVOLHeader(): Sprite is not supported.\n");
444 return PV_FAIL;
445 }
446 }
447 else
448 {
449 /* For version 2, vol_sprite_usage has two bits. */
450 /* sprite_enable */
451 tmpvar = (uint32) BitstreamReadBits16(stream, 2);
452 if (tmpvar)
453 {
454 mp4dec_log("DecodeVOLHeader(): Sprite is not supported.\n");
455 return PV_FAIL;
456 }
457 }
458
459 /* not_8_bit */
460 if (BitstreamRead1Bits(stream))
461 {
462 /* quant_precision */
463 currVol->quantPrecision = BitstreamReadBits16(stream, 4);
464 /* bits_per_pixel */
465 currVol->bitsPerPixel = BitstreamReadBits16(stream, 4);
466 mp4dec_log("DecodeVOLHeader(): not an 8-bit stream.\n"); // For the time being we do not support != 8 bits
467
468 return PV_FAIL;
469 }
470 else
471 {
472 currVol->quantPrecision = 5;
473 currVol->bitsPerPixel = 8;
474 }
475
476 /* quant_type (1 bit) */
477 currVol->quantType = BitstreamRead1Bits(stream);
478 if (currVol->quantType)
479 {
480 #ifdef PV_SUPPORT_MAIN_PROFILE
481 /* load quantization matrices. 5/22/2000 */
482 /* load_intra_quant_mat (1 bit) */
483 qmat = currVol->iqmat;
484 currVol->loadIntraQuantMat = BitstreamRead1Bits(stream);
485 if (currVol->loadIntraQuantMat)
486 {
487 /* intra_quant_mat (8*64 bits) */
488 i = 0;
489 do
490 {
491 qmat[*(zigzag_inv+i)] = (int) BitstreamReadBits16(stream, 8);
492 }
493 while ((qmat[*(zigzag_inv+i)] != 0) && (++i < 64));
494
495 for (j = i; j < 64; j++)
496 qmat[*(zigzag_inv+j)] = qmat[*(zigzag_inv+i-1)];
497 }
498 else
499 {
500 oscl_memcpy(qmat, mpeg_iqmat_def, 64*sizeof(int));
501 }
502
503 qmat[0] = 0; /* necessary for switched && MPEG quant 07/09/01 */
504
505 /* load_nonintra_quant_mat (1 bit) */
506 qmat = currVol->niqmat;
507 currVol->loadNonIntraQuantMat = BitstreamRead1Bits(stream);
508 if (currVol->loadNonIntraQuantMat)
509 {
510 /* nonintra_quant_mat (8*64 bits) */
511 i = 0;
512 do
513 {
514 qmat[*(zigzag_inv+i)] = (int) BitstreamReadBits16(stream, 8);
515 }
516 while ((qmat[*(zigzag_inv+i)] != 0) && (++i < 64));
517
518 for (j = i; j < 64; j++)
519 qmat[*(zigzag_inv+j)] = qmat[*(zigzag_inv+i-1)];
520 }
521 else
522 {
523 oscl_memcpy(qmat, mpeg_nqmat_def, 64*sizeof(int));
524 }
525 #else
526 return PV_FAIL;
527 #endif
528 }
529
530 if (version_id != 1)
531 {
532 /* quarter_sample enabled */
533 tmpvar = BitstreamRead1Bits(stream);
534 if (tmpvar) return PV_FAIL;
535 }
536
537 /* complexity_estimation_disable */
538 currVol->complexity_estDisable = BitstreamRead1Bits(stream);
539 if (currVol->complexity_estDisable == 0)
540 {
541 currVol->complexity_estMethod = BitstreamReadBits16(stream, 2);
542
543 if (currVol->complexity_estMethod < 2)
544 {
545 /* shape_complexity_estimation_disable */
546 tmpvar = BitstreamRead1Bits(stream);
547 if (tmpvar == 0)
548 {
549 mp4dec_log("DecodeVOLHeader(): Shape Complexity estimation is not supported.\n");
550 return PV_FAIL;
551 }
552 /* texture_complexity_estimation_set_1_disable */
553 tmpvar = BitstreamRead1Bits(stream);
554 if (tmpvar == 0)
555 {
556 currVol->complexity.text_1 = BitstreamReadBits16(stream, 4);
557 }
558 /* marker bit */
559 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
560 /* texture_complexity_estimation_set_2_disable */
561 tmpvar = BitstreamRead1Bits(stream);
562 if (tmpvar == 0)
563 {
564 currVol->complexity.text_2 = BitstreamReadBits16(stream, 4);
565 }
566 /* motion_compensation_complexity_disable */
567 tmpvar = BitstreamRead1Bits(stream);
568 if (tmpvar == 0)
569 {
570 currVol->complexity.mc = BitstreamReadBits16(stream, 6);
571 }
572 /* marker bit */
573 if (!BitstreamRead1Bits(stream)) return PV_FAIL;
574
575 if (currVol->complexity_estMethod == 1)
576 { /* version2_complexity_estimation_disable */
577 tmpvar = BitstreamRead1Bits(stream);
578 if (tmpvar == 0)
579 {
580 mp4dec_log("DecodeVOLHeader(): sadct, quarter pel not supported.\n");
581 return PV_FAIL;
582 }
583 }
584 }
585 }
586
587 /* 03/10/99 */
588 /* resync_marker_disable */
589 currVol->errorResDisable = (int) BitstreamRead1Bits(stream);
590 /* data_partititioned */
591 currVol->dataPartitioning = (int) BitstreamRead1Bits(stream);
592
593 video->vlcDecCoeffIntra = &VlcDecTCOEFIntra;
594 video->vlcDecCoeffInter = &VlcDecTCOEFInter;
595
596 if (currVol->dataPartitioning)
597 {
598 if (layer) return PV_FAIL; /* */
599 /* reversible_vlc */
600 currVol->useReverseVLC = (int)BitstreamRead1Bits(stream);
601 if (currVol->useReverseVLC)
602 {
603 video->vlcDecCoeffIntra = &RvlcDecTCOEFIntra;
604 video->vlcDecCoeffInter = &RvlcDecTCOEFInter;
605 }
606 currVol->errorResDisable = 0;
607 }
608 else
609 {
610 currVol->useReverseVLC = 0;
611 }
612
613 if (version_id != 1)
614 {
615 /* newpred_enable */
616 tmpvar = BitstreamRead1Bits(stream);
617 if (tmpvar) return PV_FAIL;
618
619 /* reduced_resolution_vop */
620 tmpvar = BitstreamRead1Bits(stream);
621 if (tmpvar) return PV_FAIL;
622
623 }
624
625 /* Intra AC/DC prediction is always true */
626 video->intra_acdcPredDisable = 0;
627 /* scalability */
628 currVol->scalability = (int) BitstreamRead1Bits(stream);
629
630 if (currVol->scalability)
631 {
632 if (layer == 0) return PV_FAIL; /* */
633 /* hierarchy_type: 1 : temporal, 0 : spatial */
634 /* 03/10/99 */
635 currVol->scalType = (int) BitstreamRead1Bits(stream); /* */
636 if (!currVol->scalType) return PV_FAIL;
637
638 /* ref_layer_id (4 bits) */
639 currVol->refVolID = (int) BitstreamReadBits16(stream, 4);
640 if (layer) /* */
641 {
642 if (currVol->refVolID != video->vol[0]->volID) return PV_FAIL;
643 }
644 /* ref_layer_sampling_direc (1 bits) */
645 /* 1 : ref. layer has higher resolution */
646 /* 0 : ref. layer has equal or lower resolution */
647 currVol->refSampDir = (int) BitstreamRead1Bits(stream);
648 if (currVol->refSampDir) return PV_FAIL;
649
650 /* hor_sampling_factor_n (5 bits) */
651 currVol->horSamp_n = (int) BitstreamReadBits16(stream, 5);
652
653 /* hor_sampling_factor_m (5 bits) */
654 currVol->horSamp_m = (int) BitstreamReadBits16(stream, 5);
655
656 if (currVol->horSamp_m == 0) return PV_FAIL;
657 if (currVol->horSamp_n != currVol->horSamp_m) return PV_FAIL;
658
659 /* ver_sampling_factor_n (5 bits) */
660 currVol->verSamp_n = (int) BitstreamReadBits16(stream, 5);
661
662 /* ver_sampling_factor_m (5 bits) */
663 currVol->verSamp_m = (int) BitstreamReadBits16(stream, 5);
664
665 if (currVol->verSamp_m == 0) return PV_FAIL;
666 if (currVol->verSamp_n != currVol->verSamp_m) return PV_FAIL;
667
668
669 /* enhancement_type: 1 : partial region, 0 : full region */
670 /* 04/10/2000: we only support full region enhancement layer. */
671 if (BitstreamRead1Bits(stream)) return PV_FAIL;
672 }
673
674 PV_BitstreamByteAlign(stream);
675
676 status = BitstreamShowBits32HC(stream, &tmpvar);
677
678 /* if we hit the end of buffer, tmpvar == 0. 08/30/2000 */
679 if (tmpvar == USER_DATA_START_CODE)
680 {
681 status = DecodeUserData(stream);
682 /* you should not check for status here 03/19/2002 */
683 status = PV_SUCCESS;
684 }
685
686 /* Compute some convenience variables: 04/13/2000 */
687 video->nMBPerRow = video->width / MB_SIZE;
688 video->nMBPerCol = video->height / MB_SIZE;
689 video->nTotalMB = video->nMBPerRow * video->nMBPerCol;
690 video->nBitsForMBID = CalcNumBits((uint)video->nTotalMB - 1);
691 #ifdef PV_ANNEX_IJKT_SUPPORT
692 video->modified_quant = 0;
693 video->advanced_INTRA = 0;
694 video->deblocking = 0;
695 video->slice_structure = 0;
696 #endif
697 }
698 else
699 {
700 /* SHORT_HEADER */
701 status = BitstreamShowBits32(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);
702
703 if (tmpvar == SHORT_VIDEO_START_MARKER)
704 {
705 video->shortVideoHeader = TRUE;
706 }
707 else
708 {
709 do
710 {
711 /* Search for VOL_HEADER */
712 status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
713 if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
714 BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
715 PV_BitstreamFlushBits(stream, 8);
716 }
717 while (tmpvar != VOL_START_CODE);
718 goto decode_vol;
719 }
720 }
721 #ifdef PV_TOLERATE_VOL_ERRORS
722 if (profile > 0xFF || profile == 0)
723 {
724 return PV_BAD_VOLHEADER;
725 }
726 #endif
727
728 return status;
729 }
730
731
732 /***********************************************************CommentBegin******
733 *
734 * -- DecodeGOV -- Decodes the Group of VOPs from bitstream
735 *
736 * 04/20/2000 initial modification to the new PV-Decoder Lib format.
737 *
738 ***********************************************************CommentEnd********/
DecodeGOVHeader(BitstreamDecVideo * stream,uint32 * time_base)739 PV_STATUS DecodeGOVHeader(BitstreamDecVideo *stream, uint32 *time_base)
740 {
741 uint32 tmpvar, time_s;
742 int closed_gov, broken_link;
743
744 /* group_start_code (32 bits) */
745 // tmpvar = BitstreamReadBits32(stream, 32);
746
747 /* hours */
748 tmpvar = (uint32) BitstreamReadBits16(stream, 5);
749 time_s = tmpvar * 3600;
750
751 /* minutes */
752 tmpvar = (uint32) BitstreamReadBits16(stream, 6);
753 time_s += tmpvar * 60;
754
755 /* marker bit */
756 tmpvar = (uint32) BitstreamRead1Bits(stream);
757
758 /* seconds */
759 tmpvar = (uint32) BitstreamReadBits16(stream, 6);
760 time_s += tmpvar;
761
762 /* We have to check the timestamp here. If the sync timestamp is */
763 /* earlier than the previous timestamp or longer than 60 sec. */
764 /* after the previous timestamp, assume the GOV header is */
765 /* corrupted. 05/12/2000 */
766 *time_base = time_s; /* 02/27/2002 */
767 // *time_base = *time_base/1000;
768 // tmpvar = time_s - *time_base;
769 // if (tmpvar <= 60) *time_base = time_s;
770 // else return PV_FAIL;
771
772 tmpvar = (uint32) BitstreamRead1Bits(stream);
773 closed_gov = tmpvar;
774 tmpvar = (uint32) BitstreamRead1Bits(stream);
775 broken_link = tmpvar;
776
777 if ((closed_gov == 0) && (broken_link == 1))
778 {
779 return PV_SUCCESS; /* 03/15/2002 you can also return PV_FAIL */
780 }
781
782 PV_BitstreamByteAlign(stream);
783
784 BitstreamShowBits32HC(stream, &tmpvar);
785
786 while (tmpvar == USER_DATA_START_CODE) /* 03/15/2002 */
787 {
788 DecodeUserData(stream);
789 BitstreamShowBits32HC(stream, &tmpvar);
790 }
791
792 return PV_SUCCESS;
793 }
794
795 /***********************************************************CommentBegin******
796 *
797 * -- DecodeVopHeader -- Decodes the VOPheader information from the bitstream
798 *
799 * 04/12/2000 Initial port to the new PV decoder library format.
800 * 05/10/2000 Error resilient decoding of vop header.
801 *
802 ***********************************************************CommentEnd********/
DecodeVOPHeader(VideoDecData * video,Vop * currVop,Bool use_ext_timestamp)803 PV_STATUS DecodeVOPHeader(VideoDecData *video, Vop *currVop, Bool use_ext_timestamp)
804 {
805 PV_STATUS status = PV_SUCCESS;
806 Vol *currVol = video->vol[video->currLayer];
807 BitstreamDecVideo *stream = currVol->bitstream;
808 uint32 tmpvar;
809 int time_base;
810
811 /*****
812 * Read the VOP header from the bitstream (No shortVideoHeader Mode here!)
813 *****/
814 BitstreamShowBits32HC(stream, &tmpvar);
815
816 /* check if we have a GOV header here. 08/30/2000 */
817 if (tmpvar == GROUP_START_CODE)
818 {
819 tmpvar = BitstreamReadBits32HC(stream);
820 // rewindBitstream(stream, START_CODE_LENGTH); /* for backward compatibility */
821 status = DecodeGOVHeader(stream, &tmpvar);
822 if (status != PV_SUCCESS)
823 {
824 return status;
825 }
826 // use_ext_timestamp = TRUE; /* 02/08/2002 */
827 /* We should have a VOP header following the GOV header. 03/15/2001 */
828 BitstreamShowBits32HC(stream, &tmpvar);
829 }
830 #ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
831 currVop->timeStamp = -1;
832 #endif
833 if (tmpvar == VOP_START_CODE)
834 {
835 tmpvar = BitstreamReadBits32HC(stream);
836 }
837 else
838 {
839 PV_BitstreamFlushBits(stream, 8); // advance by a byte
840 status = PV_FAIL;
841 goto return_point;
842 }
843
844
845
846 /* vop_prediction_type (2 bits) */
847 currVop->predictionType = (int) BitstreamReadBits16(stream, 2);
848
849 /* modulo_time_base (? bits) */
850 time_base = -1;
851 do
852 {
853 time_base++;
854 tmpvar = (uint32) BitstreamRead1Bits(stream);
855 }
856 while (tmpvar == 1);
857
858
859
860 if (!use_ext_timestamp)
861 {
862 currVol->moduloTimeBase += 1000 * time_base; /* milliseconds based MTB 11/12/01 */
863 }
864
865 /* marker_bit (1 bit) */
866 if (!BitstreamRead1Bits(stream))
867 {
868 status = PV_FAIL;
869 goto return_point;
870 }
871
872 /* vop_time_increment (1-15 bits) in Nov_Compliant (1-16 bits) */
873 /* we always assumes fixed vop rate here */
874 currVop->timeInc = BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);
875
876
877 /* marker_bit (1 bit) */
878 if (!BitstreamRead1Bits(stream))
879 {
880 status = PV_FAIL;
881 goto return_point;
882 }
883
884 /* vop_coded */
885 currVop->vopCoded = (int) BitstreamRead1Bits(stream);
886
887
888 if (currVop->vopCoded == 0)
889 {
890 status = PV_SUCCESS;
891 goto return_point;
892 }
893
894
895 /* read vop_rounding_type */
896 if (currVop->predictionType == P_VOP)
897 {
898 currVop->roundingType = (int) BitstreamRead1Bits(stream);
899 }
900 else
901 {
902 currVop->roundingType = 0;
903 }
904
905 if (currVol->complexity_estDisable == 0)
906 {
907 if (currVol->complexity_estMethod < 2) /* OCT 2002 */
908 {
909 if ((currVol->complexity.text_1 >> 3) & 0x1) /* intra */
910 BitstreamReadBits16(stream, 8);
911 if (currVol->complexity.text_1 & 0x1) /* not_coded */
912 BitstreamReadBits16(stream, 8);
913 if ((currVol->complexity.text_2 >> 3) & 0x1) /* dct_coefs */
914 BitstreamReadBits16(stream, 8);
915 if ((currVol->complexity.text_2 >> 2) & 0x1) /* dct_lines */
916 BitstreamReadBits16(stream, 8);
917 if ((currVol->complexity.text_2 >> 1) & 0x1) /* vlc_symbols */
918 BitstreamReadBits16(stream, 8);
919 if (currVol->complexity.text_2 & 0x1) /* vlc_bits */
920 BitstreamReadBits16(stream, 4);
921
922 if (currVop->predictionType != I_VOP)
923 {
924 if ((currVol->complexity.text_1 >> 2) & 0x1) /* inter */
925 BitstreamReadBits16(stream, 8);
926 if ((currVol->complexity.text_1 >> 1) & 0x1) /* inter_4v */
927 BitstreamReadBits16(stream, 8);
928 if ((currVol->complexity.mc >> 5) & 0x1) /* apm */
929 BitstreamReadBits16(stream, 8);
930 if ((currVol->complexity.mc >> 4) & 0x1) /* npm */
931 BitstreamReadBits16(stream, 8);
932 /* interpolate_mc_q */
933 if ((currVol->complexity.mc >> 2) & 0x1) /* forw_back_mc_q */
934 BitstreamReadBits16(stream, 8);
935 if ((currVol->complexity.mc >> 1) & 0x1) /* halfpel2 */
936 BitstreamReadBits16(stream, 8);
937 if (currVol->complexity.mc & 0x1) /* halfpel4 */
938 BitstreamReadBits16(stream, 8);
939 }
940 if (currVop->predictionType == B_VOP)
941 {
942 if ((currVol->complexity.mc >> 3) & 0x1) /* interpolate_mc_q */
943 BitstreamReadBits16(stream, 8);
944 }
945 }
946 }
947
948 /* read intra_dc_vlc_thr */
949 currVop->intraDCVlcThr = (int) BitstreamReadBits16(stream, 3);
950
951 /* read vop_quant (currVol->quantPrecision bits) */
952 currVop->quantizer = (int16) BitstreamReadBits16(stream, currVol->quantPrecision);
953 if (currVop->quantizer == 0)
954 {
955 currVop->quantizer = video->prevVop->quantizer;
956 status = PV_FAIL;
957 goto return_point;
958 }
959
960
961 /* read vop_fcode_forward */
962 if (currVop->predictionType != I_VOP)
963 {
964 tmpvar = (uint32) BitstreamReadBits16(stream, 3);
965 if (tmpvar < 1)
966 {
967 currVop->fcodeForward = 1;
968 status = PV_FAIL;
969 goto return_point;
970 }
971 currVop->fcodeForward = tmpvar;
972 }
973 else
974 {
975 currVop->fcodeForward = 0;
976 }
977
978 /* read vop_fcode_backward */
979 if (currVop->predictionType == B_VOP)
980 {
981 tmpvar = (uint32) BitstreamReadBits16(stream, 3);
982 if (tmpvar < 1)
983 {
984 currVop->fcodeBackward = 1;
985 status = PV_FAIL;
986 goto return_point;
987 }
988 currVop->fcodeBackward = tmpvar;
989 }
990 else
991 {
992 currVop->fcodeBackward = 0;
993 }
994
995 if (currVol->scalability)
996 {
997 currVop->refSelectCode = (int) BitstreamReadBits16(stream, 2);
998 }
999
1000 return_point:
1001 return status;
1002 }
1003
1004
1005 /***********************************************************CommentBegin******
1006 *
1007 * -- VideoPlaneWithShortHeader -- Decodes the short_video_header information from the bitstream
1008 * Modified :
1009 04/23/2001. Remove the codes related to the
1010 "first pass" decoding. We use a different function
1011 to set up the decoder now.
1012 ***********************************************************CommentEnd********/
DecodeShortHeader(VideoDecData * video,Vop * currVop)1013 PV_STATUS DecodeShortHeader(VideoDecData *video, Vop *currVop)
1014 {
1015 PV_STATUS status = PV_SUCCESS;
1016 Vol *currVol = video->vol[0];
1017 BitstreamDecVideo *stream = currVol->bitstream;
1018 uint32 tmpvar;
1019 int32 size;
1020
1021 int extended_PTYPE = FALSE;
1022 int UFEP = 0, custom_PFMT = 0, custom_PCF = 0;
1023
1024 status = BitstreamShowBits32(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);
1025
1026 if (tmpvar != SHORT_VIDEO_START_MARKER)
1027 {
1028 status = PV_FAIL;
1029 goto return_point;
1030 }
1031
1032
1033 PV_BitstreamFlushBits(stream, SHORT_VIDEO_START_MARKER_LENGTH);
1034
1035 /* Temporal reference. Using vop_time_increment_resolution = 30000 */
1036 tmpvar = (uint32) BitstreamReadBits16(stream, 8);
1037 currVop->temporalRef = (int) tmpvar;
1038
1039
1040 currVop->timeInc = 0xff & (256 + currVop->temporalRef - video->prevVop->temporalRef);
1041 currVol->moduloTimeBase += currVop->timeInc; /* mseconds 11/12/01 */
1042 /* Marker Bit */
1043 if (!BitstreamRead1Bits(stream))
1044 {
1045 mp4dec_log("DecodeShortHeader(): Market bit wrong.\n");
1046 status = PV_FAIL;
1047 goto return_point;
1048 }
1049
1050 /* Zero Bit */
1051 if (BitstreamRead1Bits(stream))
1052 {
1053 mp4dec_log("DecodeShortHeader(): Zero bit wrong.\n");
1054 status = PV_FAIL;
1055 goto return_point;
1056 }
1057
1058 /*split_screen_indicator*/
1059 if (BitstreamRead1Bits(stream))
1060 {
1061 mp4dec_log("DecodeShortHeader(): Split Screen not supported.\n");
1062 VideoDecoderErrorDetected(video);
1063 }
1064
1065 /*document_freeze_camera*/
1066 if (BitstreamRead1Bits(stream))
1067 {
1068 mp4dec_log("DecodeShortHeader(): Freeze Camera not supported.\n");
1069 VideoDecoderErrorDetected(video);
1070 }
1071
1072 /*freeze_picture_release*/
1073 if (BitstreamRead1Bits(stream))
1074 {
1075 mp4dec_log("DecodeShortHeader(): Freeze Release not supported.\n");
1076 VideoDecoderErrorDetected(video);
1077 }
1078 /* source format */
1079 switch (BitstreamReadBits16(stream, 3))
1080 {
1081 case 1:
1082 if (video->size < 128*96)
1083 {
1084 status = PV_FAIL;
1085 goto return_point;
1086 }
1087 video->displayWidth = video->width = 128;
1088 video->displayHeight = video->height = 96;
1089 break;
1090
1091 case 2:
1092 if (video->size < 176*144)
1093 {
1094 status = PV_FAIL;
1095 goto return_point;
1096 }
1097 video->displayWidth = video->width = 176;
1098 video->displayHeight = video->height = 144;
1099 break;
1100
1101 case 3:
1102 if (video->size < 352*288)
1103 {
1104 status = PV_FAIL;
1105 goto return_point;
1106 }
1107 video->displayWidth = video->width = 352;
1108 video->displayHeight = video->height = 288;
1109 break;
1110
1111 case 4:
1112 if (video->size < 704*576)
1113 {
1114 status = PV_FAIL;
1115 goto return_point;
1116 }
1117 video->displayWidth = video->width = 704;
1118 video->displayHeight = video->height = 576;
1119 break;
1120
1121 case 5:
1122 if (video->size < 1408*1152)
1123 {
1124 status = PV_FAIL;
1125 goto return_point;
1126 }
1127 video->displayWidth = video->width = 1408;
1128 video->displayHeight = video->height = 1152;
1129 break;
1130
1131 case 7:
1132 extended_PTYPE = TRUE;
1133 break;
1134
1135 default:
1136 /* Msg("H.263 source format not legal\n"); */
1137 status = PV_FAIL;
1138 goto return_point;
1139 }
1140
1141
1142 currVop->roundingType = 0;
1143
1144 if (extended_PTYPE == FALSE)
1145 {
1146 currVop->predictionType = (int) BitstreamRead1Bits(stream);
1147
1148 /* four_reserved_zero_bits */
1149 if (BitstreamReadBits16(stream, 4))
1150 {
1151 mp4dec_log("DecodeShortHeader(): Reserved bits wrong.\n");
1152 status = PV_FAIL;
1153 goto return_point;
1154 }
1155 }
1156 else
1157 {
1158 UFEP = BitstreamReadBits16(stream, 3);
1159 if (UFEP == 1)
1160 {
1161 /* source format */
1162 switch (BitstreamReadBits16(stream, 3))
1163 {
1164 case 1:
1165 if (video->size < 128*96)
1166 {
1167 status = PV_FAIL;
1168 goto return_point;
1169 }
1170 video->displayWidth = video->width = 128;
1171 video->displayHeight = video->height = 96;
1172 break;
1173
1174 case 2:
1175 if (video->size < 176*144)
1176 {
1177 status = PV_FAIL;
1178 goto return_point;
1179 }
1180 video->displayWidth = video->width = 176;
1181 video->displayHeight = video->height = 144;
1182 break;
1183
1184 case 3:
1185 if (video->size < 352*288)
1186 {
1187 status = PV_FAIL;
1188 goto return_point;
1189 }
1190 video->displayWidth = video->width = 352;
1191 video->displayHeight = video->height = 288;
1192 break;
1193
1194 case 4:
1195 if (video->size < 704*576)
1196 {
1197 status = PV_FAIL;
1198 goto return_point;
1199 }
1200 video->displayWidth = video->width = 704;
1201 video->displayHeight = video->height = 576;
1202 break;
1203
1204 case 5:
1205 if (video->size < 1408*1152)
1206 {
1207 status = PV_FAIL;
1208 goto return_point;
1209 }
1210 video->displayWidth = video->width = 1408;
1211 video->displayHeight = video->height = 1152;
1212 break;
1213
1214 case 6:
1215 custom_PFMT = TRUE;
1216 break;
1217
1218 default:
1219 /* Msg("H.263 source format not legal\n"); */
1220 status = PV_FAIL;
1221 goto return_point;
1222 }
1223
1224 custom_PCF = BitstreamRead1Bits(stream);
1225 /* unrestricted MV */
1226 if (BitstreamRead1Bits(stream))
1227 {
1228 status = PV_FAIL;
1229 goto return_point;
1230 }
1231 /* SAC */
1232 if (BitstreamRead1Bits(stream))
1233 {
1234 status = PV_FAIL;
1235 goto return_point;
1236 }
1237
1238 /* AP */
1239 if (BitstreamRead1Bits(stream))
1240 {
1241 status = PV_FAIL;
1242 goto return_point;
1243 }
1244
1245 video->advanced_INTRA = BitstreamRead1Bits(stream);
1246
1247 video->deblocking = BitstreamRead1Bits(stream);
1248
1249 video->slice_structure = BitstreamRead1Bits(stream);
1250
1251 /* RPS, ISD, AIV */
1252 if (BitstreamReadBits16(stream, 3))
1253 {
1254 status = PV_FAIL;
1255 goto return_point;
1256 }
1257 video->modified_quant = BitstreamRead1Bits(stream);
1258
1259 /* Marker Bit and reserved*/
1260 if (BitstreamReadBits16(stream, 4) != 8)
1261 {
1262 status = PV_FAIL;
1263 goto return_point;
1264 }
1265 }
1266 #ifndef PV_ANNEX_IJKT_SUPPORT
1267 if (video->advanced_INTRA | video->deblocking | video->modified_quant | video->modified_quant)
1268 {
1269 status = PV_FAIL;
1270 goto return_point;
1271 }
1272 #endif
1273
1274 if (UFEP == 0 || UFEP == 1)
1275 {
1276 tmpvar = BitstreamReadBits16(stream, 3);
1277 if (tmpvar > 1)
1278 {
1279 status = PV_FAIL;
1280 goto return_point;
1281 }
1282 currVop->predictionType = tmpvar;
1283 /* RPR */
1284 if (BitstreamRead1Bits(stream))
1285 {
1286 status = PV_FAIL;
1287 goto return_point;
1288 }
1289
1290 /* RRU */
1291 if (BitstreamRead1Bits(stream))
1292 {
1293 status = PV_FAIL;
1294 goto return_point;
1295 }
1296 currVop->roundingType = (int) BitstreamRead1Bits(stream);
1297 if (BitstreamReadBits16(stream, 3) != 1)
1298 {
1299 status = PV_FAIL;
1300 goto return_point;
1301 }
1302 }
1303 else
1304 {
1305 status = PV_FAIL;
1306 goto return_point;
1307 }
1308 /* CPM */
1309 if (BitstreamRead1Bits(stream))
1310 {
1311 status = PV_FAIL;
1312 goto return_point;
1313 }
1314 /* CPFMT */
1315 if (custom_PFMT == 1 && UFEP == 1)
1316 {
1317 /* aspect ratio */
1318 tmpvar = BitstreamReadBits16(stream, 4);
1319 if (tmpvar == 0)
1320 {
1321 status = PV_FAIL;
1322 goto return_point;
1323 }
1324 /* Extended PAR */
1325 if (tmpvar == 0xF)
1326 {
1327 /* Read par_width and par_height but do nothing */
1328 /* par_width */
1329 tmpvar = BitstreamReadBits16(stream, 8);
1330
1331 /* par_height */
1332 tmpvar = BitstreamReadBits16(stream, 8);
1333 }
1334 tmpvar = BitstreamReadBits16(stream, 9);
1335
1336 video->displayWidth = (tmpvar + 1) << 2;
1337 video->width = (video->displayWidth + 15) & -16;
1338 /* marker bit */
1339 if (!BitstreamRead1Bits(stream))
1340 {
1341 status = PV_FAIL;
1342 goto return_point;
1343 }
1344 tmpvar = BitstreamReadBits16(stream, 9);
1345 if (tmpvar == 0)
1346 {
1347 status = PV_FAIL;
1348 goto return_point;
1349 }
1350 video->displayHeight = tmpvar << 2;
1351 video->height = (video->displayHeight + 15) & -16;
1352
1353 if (video->height * video->width > video->size)
1354 {
1355 status = PV_FAIL;
1356 goto return_point;
1357 }
1358
1359 video->nTotalMB = video->width / MB_SIZE * video->height / MB_SIZE;
1360
1361 if (video->nTotalMB <= 48)
1362 {
1363 video->nBitsForMBID = 6;
1364 }
1365 else if (video->nTotalMB <= 99)
1366 {
1367 video->nBitsForMBID = 7;
1368 }
1369 else if (video->nTotalMB <= 396)
1370 {
1371 video->nBitsForMBID = 9;
1372 }
1373 else if (video->nTotalMB <= 1584)
1374 {
1375 video->nBitsForMBID = 11;
1376 }
1377 else if (video->nTotalMB <= 6336)
1378 {
1379 video->nBitsForMBID = 13 ;
1380 }
1381 else if (video->nTotalMB <= 9216)
1382 {
1383 video->nBitsForMBID = 14 ;
1384 }
1385 else
1386 {
1387 status = PV_FAIL;
1388 goto return_point;
1389 }
1390 }
1391 if (UFEP == 1 && custom_PCF == 1)
1392 {
1393 BitstreamRead1Bits(stream);
1394
1395 tmpvar = BitstreamReadBits16(stream, 7);
1396 if (tmpvar == 0)
1397 {
1398 status = PV_FAIL;
1399 goto return_point;
1400 }
1401 }
1402
1403 if (custom_PCF == 1)
1404 {
1405 currVop->ETR = BitstreamReadBits16(stream, 2);
1406 }
1407
1408 if (UFEP == 1 && video->slice_structure == 1)
1409 {
1410 /* SSS */
1411 tmpvar = BitstreamReadBits16(stream, 2);
1412 if (tmpvar != 0)
1413 {
1414 status = PV_FAIL;
1415 goto return_point;
1416 }
1417 }
1418 }
1419
1420 /* Recalculate number of macroblocks per row & col since */
1421 /* the frame size can change. 04/23/2001. */
1422 video->nMBinGOB = video->nMBPerRow = video->width / MB_SIZE;
1423 video->nGOBinVop = video->nMBPerCol = video->height / MB_SIZE;
1424 video->nTotalMB = video->nMBPerRow * video->nMBPerCol;
1425 if (custom_PFMT == 0 || UFEP == 0)
1426 {
1427 video->nBitsForMBID = CalcNumBits((uint)video->nTotalMB - 1); /* otherwise calculate above */
1428 }
1429 size = (int32)video->width * video->height;
1430 if (video->currVop->predictionType == P_VOP && size > video->videoDecControls->size)
1431 {
1432 status = PV_FAIL;
1433 goto return_point;
1434 }
1435 video->videoDecControls->size = size;
1436 video->currVop->uChan = video->currVop->yChan + size;
1437 video->currVop->vChan = video->currVop->uChan + (size >> 2);
1438 video->prevVop->uChan = video->prevVop->yChan + size;
1439 video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
1440
1441
1442 currVop->quantizer = (int16) BitstreamReadBits16(stream, 5);
1443
1444 if (currVop->quantizer == 0) /* 04/03/01 */
1445 {
1446 currVop->quantizer = video->prevVop->quantizer;
1447 status = PV_FAIL;
1448 goto return_point;
1449 }
1450
1451
1452 /* Zero bit */
1453 if (extended_PTYPE == FALSE)
1454 {
1455 if (BitstreamRead1Bits(stream))
1456 {
1457 mp4dec_log("DecodeShortHeader(): Zero bit wrong.\n");
1458 status = PV_FAIL;
1459 goto return_point;
1460 }
1461 }
1462 /* pei */
1463 tmpvar = (uint32) BitstreamRead1Bits(stream);
1464
1465 while (tmpvar)
1466 {
1467 tmpvar = (uint32) BitstreamReadBits16(stream, 8); /* "PSPARE" */
1468 tmpvar = (uint32) BitstreamRead1Bits(stream); /* "PEI" */
1469 }
1470
1471 if (video->slice_structure) /* ANNEX_K */
1472 {
1473 if (!BitstreamRead1Bits(stream)) /* SEPB1 */
1474 {
1475 status = PV_FAIL;
1476 goto return_point;
1477 }
1478
1479 // if (currVol->nBitsForMBID //
1480 if (BitstreamReadBits16(stream, video->nBitsForMBID))
1481 {
1482 status = PV_FAIL; /* no ASO, RS support for Annex K */
1483 goto return_point;
1484 }
1485
1486 if (!BitstreamRead1Bits(stream)) /*SEPB3 */
1487 {
1488 status = PV_FAIL;
1489 goto return_point;
1490 }
1491
1492 }
1493 /* Setting of other VOP-header parameters */
1494 currVop->gobNumber = 0;
1495 currVop->vopCoded = 1;
1496
1497 currVop->intraDCVlcThr = 0;
1498 currVop->gobFrameID = 0; /* initial value, 05/22/00 */
1499 currVol->errorResDisable = 0;
1500 /*PutVopInterlaced(0,curr_vop); no implemented yet */
1501 if (currVop->predictionType != I_VOP)
1502 currVop->fcodeForward = 1;
1503 else
1504 currVop->fcodeForward = 0;
1505
1506 return_point:
1507
1508 return status;
1509 }
1510 /***********************************************************CommentBegin******
1511 *
1512 * -- PV_DecodeVop -- Decodes the VOP information from the bitstream
1513 *
1514 * 04/12/2000
1515 * Initial port to the new PV decoder library format.
1516 * This function is different from the one in MoMuSys MPEG-4
1517 * visual decoder. We handle combined mode with or withput
1518 * error resilience and H.263 mode through the sam path now.
1519 *
1520 * 05/04/2000
1521 * Added temporal scalability to the decoder.
1522 *
1523 ***********************************************************CommentEnd********/
PV_DecodeVop(VideoDecData * video)1524 PV_STATUS PV_DecodeVop(VideoDecData *video)
1525 {
1526 Vol *currVol = video->vol[video->currLayer];
1527 PV_STATUS status;
1528 uint32 tmpvar;
1529
1530 /*****
1531 * Do scalable or non-scalable decoding of the current VOP
1532 *****/
1533
1534 if (!currVol->scalability)
1535 {
1536 if (currVol->dataPartitioning)
1537 {
1538 /* Data partitioning mode comes here */
1539 status = DecodeFrameDataPartMode(video);
1540 }
1541 else
1542 {
1543 /* Combined mode with or without error resilience */
1544 /* and short video header comes here. */
1545 status = DecodeFrameCombinedMode(video);
1546 }
1547 }
1548 else
1549 {
1550 #ifdef DO_NOT_FOLLOW_STANDARD
1551 /* according to the standard, only combined mode is allowed */
1552 /* in the enhancement layer. 06/01/2000. */
1553 if (currVol->dataPartitioning)
1554 {
1555 /* Data partitioning mode comes here */
1556 status = DecodeFrameDataPartMode(video);
1557 }
1558 else
1559 {
1560 /* Combined mode with or without error resilience */
1561 /* and short video header comes here. */
1562 status = DecodeFrameCombinedMode(video);
1563 }
1564 #else
1565 status = DecodeFrameCombinedMode(video);
1566 #endif
1567 }
1568
1569 /* This part is for consuming Visual_object_sequence_end_code and EOS Code */ /* 10/15/01 */
1570 if (!video->shortVideoHeader)
1571 {
1572 /* at this point bitstream is expected to be byte aligned */
1573 BitstreamByteAlignNoForceStuffing(currVol->bitstream);
1574
1575 status = BitstreamShowBits32HC(currVol->bitstream, &tmpvar); /* 07/07/01 */
1576 if (tmpvar == VISUAL_OBJECT_SEQUENCE_END_CODE)/* VOS_END_CODE */
1577 {
1578 PV_BitstreamFlushBits(currVol->bitstream, 16);
1579 PV_BitstreamFlushBits(currVol->bitstream, 16);
1580 }
1581
1582 }
1583 else
1584 {
1585 #ifdef PV_ANNEX_IJKT_SUPPORT
1586 if (video->deblocking)
1587 {
1588 H263_Deblock(video->currVop->yChan, video->width, video->height, video->QPMB, video->headerInfo.Mode, 0, 0);
1589 H263_Deblock(video->currVop->uChan, video->width >> 1, video->height >> 1, video->QPMB, video->headerInfo.Mode, 1, video->modified_quant);
1590 H263_Deblock(video->currVop->vChan, video->width >> 1, video->height >> 1, video->QPMB, video->headerInfo.Mode, 1, video->modified_quant);
1591 }
1592 #endif
1593 /* Read EOS code for shortheader bitstreams */
1594 status = BitstreamShowBits32(currVol->bitstream, 22, &tmpvar);
1595 if (tmpvar == SHORT_VIDEO_END_MARKER)
1596 {
1597 PV_BitstreamFlushBits(currVol->bitstream, 22);
1598 }
1599 else
1600 {
1601 status = PV_BitstreamShowBitsByteAlign(currVol->bitstream, 22, &tmpvar);
1602 if (tmpvar == SHORT_VIDEO_END_MARKER)
1603 {
1604 PV_BitstreamByteAlign(currVol->bitstream);
1605 PV_BitstreamFlushBits(currVol->bitstream, 22);
1606 }
1607 }
1608 }
1609 return status;
1610 }
1611
1612
1613 /***********************************************************CommentBegin******
1614 *
1615 * -- CalcVopDisplayTime -- calculate absolute time when VOP is to be displayed
1616 *
1617 * 04/12/2000 Initial port to the new PV decoder library format.
1618 *
1619 ***********************************************************CommentEnd********/
CalcVopDisplayTime(Vol * currVol,Vop * currVop,int shortVideoHeader)1620 uint32 CalcVopDisplayTime(Vol *currVol, Vop *currVop, int shortVideoHeader)
1621 {
1622 uint32 display_time;
1623
1624
1625 /*****
1626 * Calculate the time when the VOP is to be displayed next
1627 *****/
1628
1629 if (!shortVideoHeader)
1630 {
1631 display_time = (uint32)(currVol->moduloTimeBase + (((int32)currVop->timeInc - (int32)currVol->timeInc_offset) * 1000) / ((int32)currVol->timeIncrementResolution)); /* 11/12/2001 */
1632 if (currVop->timeStamp >= display_time)
1633 {
1634 display_time += 1000; /* this case is valid if GOVHeader timestamp is ignored */
1635 }
1636 }
1637 else
1638 {
1639 display_time = (uint32)(currVol->moduloTimeBase * 33 + (currVol->moduloTimeBase * 11) / 30); /* 11/12/2001 */
1640 }
1641
1642 return(display_time);
1643 }
1644
1645