fbui | Framebuffer-based graphical environment |
| download: https://git.y1.nz/archives/fbui.tar.gz | |
| README | Files | Log | Refs |
libfbui/MPEG/gethdr.c
1 /* gethdr.c, header decoding */
2
3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
4
5 /*
6 * Disclaimer of Warranty
7 *
8 * These software programs are available to the user without any license fee or
9 * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
10 * any and all warranties, whether express, implied, or statuary, including any
11 * implied warranties or merchantability or of fitness for a particular
12 * purpose. In no event shall the copyright-holder be liable for any
13 * incidental, punitive, or consequential damages of any kind whatsoever
14 * arising from the use of these programs.
15 *
16 * This disclaimer of warranty extends to the user of these programs and user's
17 * customers, employees, agents, transferees, successors, and assigns.
18 *
19 * The MPEG Software Simulation Group does not represent or warrant that the
20 * programs furnished hereunder are free of infringement of any third-party
21 * patents.
22 *
23 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
24 * are subject to royalty fees to patent holders. Many of these patents are
25 * general enough such that they are unavoidable regardless of implementation
26 * design.
27 *
28 */
29
30 #include <stdio.h>
31
32 #include "config.h"
33 #include "global.h"
34
35
36 /* private prototypes */
37 static void sequence_header _ANSI_ARGS_((void));
38 static void group_of_pictures_header _ANSI_ARGS_((void));
39 static void picture_header _ANSI_ARGS_((void));
40 static void extension_and_user_data _ANSI_ARGS_((void));
41 static void sequence_extension _ANSI_ARGS_((void));
42 static void sequence_display_extension _ANSI_ARGS_((void));
43 static void quant_matrix_extension _ANSI_ARGS_((void));
44 static void sequence_scalable_extension _ANSI_ARGS_((void));
45 static void picture_display_extension _ANSI_ARGS_((void));
46 static void picture_coding_extension _ANSI_ARGS_((void));
47 static void picture_spatial_scalable_extension _ANSI_ARGS_((void));
48 static void picture_temporal_scalable_extension _ANSI_ARGS_((void));
49 static int extra_bit_information _ANSI_ARGS_((void));
50 static void copyright_extension _ANSI_ARGS_((void));
51 static void user_data _ANSI_ARGS_((void));
52 static void user_data _ANSI_ARGS_((void));
53
54
55
56
57 /* introduced in September 1995 to assist spatial scalable decoding */
58 static void Update_Temporal_Reference_Tacking_Data _ANSI_ARGS_((void));
59 /* private variables */
60 static int Temporal_Reference_Base = 0;
61 static int True_Framenum_max = -1;
62 static int Temporal_Reference_GOP_Reset = 0;
63
64 #define RESERVED -1
65 static double frame_rate_Table[16] =
66 {
67 0.0,
68 ((23.0*1000.0)/1001.0),
69 24.0,
70 25.0,
71 ((30.0*1000.0)/1001.0),
72 30.0,
73 50.0,
74 ((60.0*1000.0)/1001.0),
75 60.0,
76
77 RESERVED,
78 RESERVED,
79 RESERVED,
80 RESERVED,
81 RESERVED,
82 RESERVED,
83 RESERVED
84 };
85
86 /*
87 * decode headers from one input stream
88 * until an End of Sequence or picture start code
89 * is found
90 */
91 int Get_Hdr()
92 {
93 unsigned int code;
94
95 for (;;)
96 {
97 /* look for next_start_code */
98 next_start_code();
99 code = Get_Bits32();
100
101 switch (code)
102 {
103 case SEQUENCE_HEADER_CODE:
104 sequence_header();
105 break;
106 case GROUP_START_CODE:
107 group_of_pictures_header();
108 break;
109 case PICTURE_START_CODE:
110 picture_header();
111 return 1;
112 break;
113 case SEQUENCE_END_CODE:
114 return 0;
115 break;
116 default:
117 if (!Quiet_Flag)
118 fprintf(stderr,"Unexpected next_start_code %08x (ignored)\n",code);
119 break;
120 }
121 }
122 }
123
124
125 /* align to start of next next_start_code */
126
127 void next_start_code()
128 {
129 /* byte align */
130 Flush_Buffer(ld->Incnt&7);
131 while (Show_Bits(24)!=0x01L)
132 Flush_Buffer(8);
133 }
134
135
136 /* decode sequence header */
137
138 static void sequence_header()
139 {
140 int i;
141 int pos;
142
143 pos = ld->Bitcnt;
144 horizontal_size = Get_Bits(12);
145 vertical_size = Get_Bits(12);
146 aspect_ratio_information = Get_Bits(4);
147 frame_rate_code = Get_Bits(4);
148 bit_rate_value = Get_Bits(18);
149 marker_bit("sequence_header()");
150 vbv_buffer_size = Get_Bits(10);
151 constrained_parameters_flag = Get_Bits(1);
152
153 if((ld->load_intra_quantizer_matrix = Get_Bits(1)))
154 {
155 for (i=0; i<64; i++)
156 ld->intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
157 }
158 else
159 {
160 for (i=0; i<64; i++)
161 ld->intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
162 }
163
164 if((ld->load_non_intra_quantizer_matrix = Get_Bits(1)))
165 {
166 for (i=0; i<64; i++)
167 ld->non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
168 }
169 else
170 {
171 for (i=0; i<64; i++)
172 ld->non_intra_quantizer_matrix[i] = 16;
173 }
174
175 /* copy luminance to chrominance matrices */
176 for (i=0; i<64; i++)
177 {
178 ld->chroma_intra_quantizer_matrix[i] =
179 ld->intra_quantizer_matrix[i];
180
181 ld->chroma_non_intra_quantizer_matrix[i] =
182 ld->non_intra_quantizer_matrix[i];
183 }
184
185 #ifdef VERBOSE
186 if (Verbose_Flag > NO_LAYER)
187 {
188 printf("sequence header (byte %d)\n",(pos>>3)-4);
189 if (Verbose_Flag > SEQUENCE_LAYER)
190 {
191 printf(" horizontal_size=%d\n",horizontal_size);
192 printf(" vertical_size=%d\n",vertical_size);
193 printf(" aspect_ratio_information=%d\n",aspect_ratio_information);
194 printf(" frame_rate_code=%d",frame_rate_code);
195 printf(" bit_rate_value=%d\n",bit_rate_value);
196 printf(" vbv_buffer_size=%d\n",vbv_buffer_size);
197 printf(" constrained_parameters_flag=%d\n",constrained_parameters_flag);
198 printf(" load_intra_quantizer_matrix=%d\n",ld->load_intra_quantizer_matrix);
199 printf(" load_non_intra_quantizer_matrix=%d\n",ld->load_non_intra_quantizer_matrix);
200 }
201 }
202 #endif /* VERBOSE */
203
204 #ifdef VERIFY
205 verify_sequence_header++;
206 #endif /* VERIFY */
207
208 extension_and_user_data();
209 }
210
211
212
213 /* decode group of pictures header */
214 /* ISO/IEC 13818-2 section 6.2.2.6 */
215 static void group_of_pictures_header()
216 {
217 int pos;
218
219 if (ld == &base)
220 {
221 Temporal_Reference_Base = True_Framenum_max + 1; /* *CH* */
222 Temporal_Reference_GOP_Reset = 1;
223 }
224 pos = ld->Bitcnt;
225 drop_flag = Get_Bits(1);
226 hour = Get_Bits(5);
227 minute = Get_Bits(6);
228 marker_bit("group_of_pictures_header()");
229 sec = Get_Bits(6);
230 frame = Get_Bits(6);
231 closed_gop = Get_Bits(1);
232 broken_link = Get_Bits(1);
233
234 #ifdef VERBOSE
235 if (Verbose_Flag > NO_LAYER)
236 {
237 printf("group of pictures (byte %d)\n",(pos>>3)-4);
238 if (Verbose_Flag > SEQUENCE_LAYER)
239 {
240 printf(" drop_flag=%d\n",drop_flag);
241 printf(" timecode %d:%02d:%02d:%02d\n",hour,minute,sec,frame);
242 printf(" closed_gop=%d\n",closed_gop);
243 printf(" broken_link=%d\n",broken_link);
244 }
245 }
246 #endif /* VERBOSE */
247
248 #ifdef VERIFY
249 verify_group_of_pictures_header++;
250 #endif /* VERIFY */
251
252 extension_and_user_data();
253
254 }
255
256
257 /* decode picture header */
258
259 /* ISO/IEC 13818-2 section 6.2.3 */
260 static void picture_header()
261 {
262 int pos;
263 int Extra_Information_Byte_Count;
264
265 /* unless later overwritten by picture_spatial_scalable_extension() */
266 ld->pict_scal = 0;
267
268 pos = ld->Bitcnt;
269 temporal_reference = Get_Bits(10);
270 picture_coding_type = Get_Bits(3);
271 vbv_delay = Get_Bits(16);
272
273 if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
274 {
275 full_pel_forward_vector = Get_Bits(1);
276 forward_f_code = Get_Bits(3);
277 }
278 if (picture_coding_type==B_TYPE)
279 {
280 full_pel_backward_vector = Get_Bits(1);
281 backward_f_code = Get_Bits(3);
282 }
283
284 #ifdef VERBOSE
285 if (Verbose_Flag>NO_LAYER)
286 {
287 printf("picture header (byte %d)\n",(pos>>3)-4);
288 if (Verbose_Flag>SEQUENCE_LAYER)
289 {
290 printf(" temporal_reference=%d\n",temporal_reference);
291 printf(" picture_coding_type=%d\n",picture_coding_type);
292 printf(" vbv_delay=%d\n",vbv_delay);
293 if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
294 {
295 printf(" full_pel_forward_vector=%d\n",full_pel_forward_vector);
296 printf(" forward_f_code =%d\n",forward_f_code);
297 }
298 if (picture_coding_type==B_TYPE)
299 {
300 printf(" full_pel_backward_vector=%d\n",full_pel_backward_vector);
301 printf(" backward_f_code =%d\n",backward_f_code);
302 }
303 }
304 }
305 #endif /* VERBOSE */
306
307 #ifdef VERIFY
308 verify_picture_header++;
309 #endif /* VERIFY */
310
311 Extra_Information_Byte_Count =
312 extra_bit_information();
313
314 extension_and_user_data();
315
316 /* update tracking information used to assist spatial scalability */
317 Update_Temporal_Reference_Tacking_Data();
318 }
319
320 /* decode slice header */
321
322 /* ISO/IEC 13818-2 section 6.2.4 */
323 int slice_header()
324 {
325 int slice_vertical_position_extension;
326 int quantizer_scale_code;
327 int pos;
328 int slice_picture_id_enable = 0;
329 int slice_picture_id = 0;
330 int extra_information_slice = 0;
331
332 pos = ld->Bitcnt;
333
334 slice_vertical_position_extension =
335 (ld->MPEG2_Flag && vertical_size>2800) ? Get_Bits(3) : 0;
336
337 if (ld->scalable_mode==SC_DP)
338 ld->priority_breakpoint = Get_Bits(7);
339
340 quantizer_scale_code = Get_Bits(5);
341 ld->quantizer_scale =
342 ld->MPEG2_Flag ? (ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1) : quantizer_scale_code;
343
344 /* slice_id introduced in March 1995 as part of the video corridendum
345 (after the IS was drafted in November 1994) */
346 if (Get_Bits(1))
347 {
348 ld->intra_slice = Get_Bits(1);
349
350 slice_picture_id_enable = Get_Bits(1);
351 slice_picture_id = Get_Bits(6);
352
353 extra_information_slice = extra_bit_information();
354 }
355 else
356 ld->intra_slice = 0;
357
358 #ifdef VERBOSE
359 if (Verbose_Flag>PICTURE_LAYER)
360 {
361 printf("slice header (byte %d)\n",(pos>>3)-4);
362 if (Verbose_Flag>SLICE_LAYER)
363 {
364 if (ld->MPEG2_Flag && vertical_size>2800)
365 printf(" slice_vertical_position_extension=%d\n",slice_vertical_position_extension);
366
367 if (ld->scalable_mode==SC_DP)
368 printf(" priority_breakpoint=%d\n",ld->priority_breakpoint);
369
370 printf(" quantizer_scale_code=%d\n",quantizer_scale_code);
371
372 printf(" slice_picture_id_enable = %d\n", slice_picture_id_enable);
373
374 if(slice_picture_id_enable)
375 printf(" slice_picture_id = %d\n", slice_picture_id);
376
377 }
378 }
379 #endif /* VERBOSE */
380
381 #ifdef VERIFY
382 verify_slice_header++;
383 #endif /* VERIFY */
384
385
386 return slice_vertical_position_extension;
387 }
388
389
390 /* decode extension and user data */
391 /* ISO/IEC 13818-2 section 6.2.2.2 */
392 static void extension_and_user_data()
393 {
394 int code,ext_ID;
395
396 next_start_code();
397
398 while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE)
399 {
400 if (code==EXTENSION_START_CODE)
401 {
402 Flush_Buffer32();
403 ext_ID = Get_Bits(4);
404 switch (ext_ID)
405 {
406 case SEQUENCE_EXTENSION_ID:
407 sequence_extension();
408 break;
409 case SEQUENCE_DISPLAY_EXTENSION_ID:
410 sequence_display_extension();
411 break;
412 case QUANT_MATRIX_EXTENSION_ID:
413 quant_matrix_extension();
414 break;
415 case SEQUENCE_SCALABLE_EXTENSION_ID:
416 sequence_scalable_extension();
417 break;
418 case PICTURE_DISPLAY_EXTENSION_ID:
419 picture_display_extension();
420 break;
421 case PICTURE_CODING_EXTENSION_ID:
422 picture_coding_extension();
423 break;
424 case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
425 picture_spatial_scalable_extension();
426 break;
427 case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
428 picture_temporal_scalable_extension();
429 break;
430 case COPYRIGHT_EXTENSION_ID:
431 copyright_extension();
432 break;
433 default:
434 fprintf(stderr,"reserved extension start code ID %d\n",ext_ID);
435 break;
436 }
437 next_start_code();
438 }
439 else
440 {
441 #ifdef VERBOSE
442 if (Verbose_Flag>NO_LAYER)
443 printf("user data\n");
444 #endif /* VERBOSE */
445 Flush_Buffer32();
446 user_data();
447 }
448 }
449 }
450
451
452 /* decode sequence extension */
453
454 /* ISO/IEC 13818-2 section 6.2.2.3 */
455 static void sequence_extension()
456 {
457 int horizontal_size_extension;
458 int vertical_size_extension;
459 int bit_rate_extension;
460 int vbv_buffer_size_extension;
461 int pos;
462
463 /* derive bit position for trace */
464 #ifdef VERBOSE
465 pos = ld->Bitcnt;
466 #endif
467
468 ld->MPEG2_Flag = 1;
469
470 ld->scalable_mode = SC_NONE; /* unless overwritten by sequence_scalable_extension() */
471 layer_id = 0; /* unless overwritten by sequence_scalable_extension() */
472
473 profile_and_level_indication = Get_Bits(8);
474 progressive_sequence = Get_Bits(1);
475 chroma_format = Get_Bits(2);
476 horizontal_size_extension = Get_Bits(2);
477 vertical_size_extension = Get_Bits(2);
478 bit_rate_extension = Get_Bits(12);
479 marker_bit("sequence_extension");
480 vbv_buffer_size_extension = Get_Bits(8);
481 low_delay = Get_Bits(1);
482 frame_rate_extension_n = Get_Bits(2);
483 frame_rate_extension_d = Get_Bits(5);
484
485 frame_rate = frame_rate_Table[frame_rate_code] *
486 ((frame_rate_extension_n+1)/(frame_rate_extension_d+1));
487
488 /* special case for 422 profile & level must be made */
489 if((profile_and_level_indication>>7) & 1)
490 { /* escape bit of profile_and_level_indication set */
491
492 /* 4:2:2 Profile @ Main Level */
493 if((profile_and_level_indication&15)==5)
494 {
495 profile = PROFILE_422;
496 level = MAIN_LEVEL;
497 }
498 }
499 else
500 {
501 profile = profile_and_level_indication >> 4; /* Profile is upper nibble */
502 level = profile_and_level_indication & 0xF; /* Level is lower nibble */
503 }
504
505
506 horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
507 vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
508
509
510 /* ISO/IEC 13818-2 does not define bit_rate_value to be composed of
511 * both the original bit_rate_value parsed in sequence_header() and
512 * the optional bit_rate_extension in sequence_extension_header().
513 * However, we use it for bitstream verification purposes.
514 */
515
516 bit_rate_value += (bit_rate_extension << 18);
517 bit_rate = ((double) bit_rate_value) * 400.0;
518 vbv_buffer_size += (vbv_buffer_size_extension << 10);
519
520 #ifdef VERBOSE
521 if (Verbose_Flag>NO_LAYER)
522 {
523 printf("sequence extension (byte %d)\n",(pos>>3)-4);
524
525 if (Verbose_Flag>SEQUENCE_LAYER)
526 {
527 printf(" profile_and_level_indication=%d\n",profile_and_level_indication);
528
529 if (profile_and_level_indication<128)
530 {
531 printf(" profile=%d, level=%d\n",profile,level);
532 }
533
534 printf(" progressive_sequence=%d\n",progressive_sequence);
535 printf(" chroma_format=%d\n",chroma_format);
536 printf(" horizontal_size_extension=%d\n",horizontal_size_extension);
537 printf(" vertical_size_extension=%d\n",vertical_size_extension);
538 printf(" bit_rate_extension=%d\n",bit_rate_extension);
539 printf(" vbv_buffer_size_extension=%d\n",vbv_buffer_size_extension);
540 printf(" low_delay=%d\n",low_delay);
541 printf(" frame_rate_extension_n=%d\n",frame_rate_extension_n);
542 printf(" frame_rate_extension_d=%d\n",frame_rate_extension_d);
543 }
544 }
545 #endif /* VERBOSE */
546
547 #ifdef VERIFY
548 verify_sequence_extension++;
549 #endif /* VERIFY */
550
551
552 }
553
554
555 /* decode sequence display extension */
556
557 static void sequence_display_extension()
558 {
559 int pos;
560
561 pos = ld->Bitcnt;
562 video_format = Get_Bits(3);
563 color_description = Get_Bits(1);
564
565 if (color_description)
566 {
567 color_primaries = Get_Bits(8);
568 transfer_characteristics = Get_Bits(8);
569 matrix_coefficients = Get_Bits(8);
570 }
571
572 display_horizontal_size = Get_Bits(14);
573 marker_bit("sequence_display_extension");
574 display_vertical_size = Get_Bits(14);
575
576 #ifdef VERBOSE
577 if (Verbose_Flag>NO_LAYER)
578 {
579 printf("sequence display extension (byte %d)\n",(pos>>3)-4);
580 if (Verbose_Flag>SEQUENCE_LAYER)
581 {
582
583 printf(" video_format=%d\n",video_format);
584 printf(" color_description=%d\n",color_description);
585
586 if (color_description)
587 {
588 printf(" color_primaries=%d\n",color_primaries);
589 printf(" transfer_characteristics=%d\n",transfer_characteristics);
590 printf(" matrix_coefficients=%d\n",matrix_coefficients);
591 }
592 printf(" display_horizontal_size=%d\n",display_horizontal_size);
593 printf(" display_vertical_size=%d\n",display_vertical_size);
594 }
595 }
596 #endif /* VERBOSE */
597
598 #ifdef VERIFY
599 verify_sequence_display_extension++;
600 #endif /* VERIFY */
601
602 }
603
604
605 /* decode quant matrix entension */
606 /* ISO/IEC 13818-2 section 6.2.3.2 */
607 static void quant_matrix_extension()
608 {
609 int i;
610 int pos;
611
612 pos = ld->Bitcnt;
613
614 if((ld->load_intra_quantizer_matrix = Get_Bits(1)))
615 {
616 for (i=0; i<64; i++)
617 {
618 ld->chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
619 = ld->intra_quantizer_matrix[scan[ZIG_ZAG][i]]
620 = Get_Bits(8);
621 }
622 }
623
624 if((ld->load_non_intra_quantizer_matrix = Get_Bits(1)))
625 {
626 for (i=0; i<64; i++)
627 {
628 ld->chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
629 = ld->non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
630 = Get_Bits(8);
631 }
632 }
633
634 if((ld->load_chroma_intra_quantizer_matrix = Get_Bits(1)))
635 {
636 for (i=0; i<64; i++)
637 ld->chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
638 }
639
640 if((ld->load_chroma_non_intra_quantizer_matrix = Get_Bits(1)))
641 {
642 for (i=0; i<64; i++)
643 ld->chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
644 }
645
646 #ifdef VERBOSE
647 if (Verbose_Flag>NO_LAYER)
648 {
649 printf("quant matrix extension (byte %d)\n",(pos>>3)-4);
650 printf(" load_intra_quantizer_matrix=%d\n",
651 ld->load_intra_quantizer_matrix);
652 printf(" load_non_intra_quantizer_matrix=%d\n",
653 ld->load_non_intra_quantizer_matrix);
654 printf(" load_chroma_intra_quantizer_matrix=%d\n",
655 ld->load_chroma_intra_quantizer_matrix);
656 printf(" load_chroma_non_intra_quantizer_matrix=%d\n",
657 ld->load_chroma_non_intra_quantizer_matrix);
658 }
659 #endif /* VERBOSE */
660
661 #ifdef VERIFY
662 verify_quant_matrix_extension++;
663 #endif /* VERIFY */
664
665 }
666
667
668 /* decode sequence scalable extension */
669 /* ISO/IEC 13818-2 section 6.2.2.5 */
670 static void sequence_scalable_extension()
671 {
672 int pos;
673
674 pos = ld->Bitcnt;
675
676 /* values (without the +1 offset) of scalable_mode are defined in
677 Table 6-10 of ISO/IEC 13818-2 */
678 ld->scalable_mode = Get_Bits(2) + 1; /* add 1 to make SC_DP != SC_NONE */
679
680 layer_id = Get_Bits(4);
681
682 if (ld->scalable_mode==SC_SPAT)
683 {
684 lower_layer_prediction_horizontal_size = Get_Bits(14);
685 marker_bit("sequence_scalable_extension()");
686 lower_layer_prediction_vertical_size = Get_Bits(14);
687 horizontal_subsampling_factor_m = Get_Bits(5);
688 horizontal_subsampling_factor_n = Get_Bits(5);
689 vertical_subsampling_factor_m = Get_Bits(5);
690 vertical_subsampling_factor_n = Get_Bits(5);
691 }
692
693 if (ld->scalable_mode==SC_TEMP)
694 Error("temporal scalability not implemented\n");
695
696 #ifdef VERBOSE
697 if (Verbose_Flag>NO_LAYER)
698 {
699 printf("sequence scalable extension (byte %d)\n",(pos>>3)-4);
700 if (Verbose_Flag>SEQUENCE_LAYER)
701 {
702 printf(" scalable_mode=%d\n",ld->scalable_mode-1);
703 printf(" layer_id=%d\n",layer_id);
704 if (ld->scalable_mode==SC_SPAT)
705 {
706 printf(" lower_layer_prediction_horiontal_size=%d\n",
707 lower_layer_prediction_horizontal_size);
708 printf(" lower_layer_prediction_vertical_size=%d\n",
709 lower_layer_prediction_vertical_size);
710 printf(" horizontal_subsampling_factor_m=%d\n",
711 horizontal_subsampling_factor_m);
712 printf(" horizontal_subsampling_factor_n=%d\n",
713 horizontal_subsampling_factor_n);
714 printf(" vertical_subsampling_factor_m=%d\n",
715 vertical_subsampling_factor_m);
716 printf(" vertical_subsampling_factor_n=%d\n",
717 vertical_subsampling_factor_n);
718 }
719 }
720 }
721 #endif /* VERBOSE */
722
723 #ifdef VERIFY
724 verify_sequence_scalable_extension++;
725 #endif /* VERIFY */
726
727 }
728
729
730 /* decode picture display extension */
731 /* ISO/IEC 13818-2 section 6.2.3.3. */
732 static void picture_display_extension()
733 {
734 int i;
735 int number_of_frame_center_offsets;
736 int pos;
737
738 pos = ld->Bitcnt;
739 /* based on ISO/IEC 13818-2 section 6.3.12
740 (November 1994) Picture display extensions */
741
742 /* derive number_of_frame_center_offsets */
743 if(progressive_sequence)
744 {
745 if(repeat_first_field)
746 {
747 if(top_field_first)
748 number_of_frame_center_offsets = 3;
749 else
750 number_of_frame_center_offsets = 2;
751 }
752 else
753 {
754 number_of_frame_center_offsets = 1;
755 }
756 }
757 else
758 {
759 if(picture_structure!=FRAME_PICTURE)
760 {
761 number_of_frame_center_offsets = 1;
762 }
763 else
764 {
765 if(repeat_first_field)
766 number_of_frame_center_offsets = 3;
767 else
768 number_of_frame_center_offsets = 2;
769 }
770 }
771
772
773 /* now parse */
774 for (i=0; i<number_of_frame_center_offsets; i++)
775 {
776 frame_center_horizontal_offset[i] = Get_Bits(16);
777 marker_bit("picture_display_extension, first marker bit");
778
779 frame_center_vertical_offset[i] = Get_Bits(16);
780 marker_bit("picture_display_extension, second marker bit");
781 }
782
783 #ifdef VERBOSE
784 if (Verbose_Flag>NO_LAYER)
785 {
786 printf("picture display extension (byte %d)\n",(pos>>3)-4);
787 if (Verbose_Flag>SEQUENCE_LAYER)
788 {
789
790 for (i=0; i<number_of_frame_center_offsets; i++)
791 {
792 printf(" frame_center_horizontal_offset[%d]=%d\n",i,
793 frame_center_horizontal_offset[i]);
794 printf(" frame_center_vertical_offset[%d]=%d\n",i,
795 frame_center_vertical_offset[i]);
796 }
797 }
798 }
799 #endif /* VERBOSE */
800
801 #ifdef VERIFY
802 verify_picture_display_extension++;
803 #endif /* VERIFY */
804
805 }
806
807
808 /* decode picture coding extension */
809 static void picture_coding_extension()
810 {
811 int pos;
812
813 pos = ld->Bitcnt;
814
815 f_code[0][0] = Get_Bits(4);
816 f_code[0][1] = Get_Bits(4);
817 f_code[1][0] = Get_Bits(4);
818 f_code[1][1] = Get_Bits(4);
819
820 intra_dc_precision = Get_Bits(2);
821 picture_structure = Get_Bits(2);
822 top_field_first = Get_Bits(1);
823 frame_pred_frame_dct = Get_Bits(1);
824 concealment_motion_vectors = Get_Bits(1);
825 ld->q_scale_type = Get_Bits(1);
826 intra_vlc_format = Get_Bits(1);
827 ld->alternate_scan = Get_Bits(1);
828 repeat_first_field = Get_Bits(1);
829 chroma_420_type = Get_Bits(1);
830 progressive_frame = Get_Bits(1);
831 composite_display_flag = Get_Bits(1);
832
833 if (composite_display_flag)
834 {
835 v_axis = Get_Bits(1);
836 field_sequence = Get_Bits(3);
837 sub_carrier = Get_Bits(1);
838 burst_amplitude = Get_Bits(7);
839 sub_carrier_phase = Get_Bits(8);
840 }
841
842 #ifdef VERBOSE
843 if (Verbose_Flag>NO_LAYER)
844 {
845 printf("picture coding extension (byte %d)\n",(pos>>3)-4);
846 if (Verbose_Flag>SEQUENCE_LAYER)
847 {
848 printf(" forward horizontal f_code=%d\n", f_code[0][0]);
849 printf(" forward vertical f_code=%d\n", f_code[0][1]);
850 printf(" backward horizontal f_code=%d\n", f_code[1][0]);
851 printf(" backward_vertical f_code=%d\n", f_code[1][1]);
852 printf(" intra_dc_precision=%d\n",intra_dc_precision);
853 printf(" picture_structure=%d\n",picture_structure);
854 printf(" top_field_first=%d\n",top_field_first);
855 printf(" frame_pred_frame_dct=%d\n",frame_pred_frame_dct);
856 printf(" concealment_motion_vectors=%d\n",concealment_motion_vectors);
857 printf(" q_scale_type=%d\n",ld->q_scale_type);
858 printf(" intra_vlc_format=%d\n",intra_vlc_format);
859 printf(" alternate_scan=%d\n",ld->alternate_scan);
860 printf(" repeat_first_field=%d\n",repeat_first_field);
861 printf(" chroma_420_type=%d\n",chroma_420_type);
862 printf(" progressive_frame=%d\n",progressive_frame);
863 printf(" composite_display_flag=%d\n",composite_display_flag);
864
865 if (composite_display_flag)
866 {
867 printf(" v_axis=%d\n",v_axis);
868 printf(" field_sequence=%d\n",field_sequence);
869 printf(" sub_carrier=%d\n",sub_carrier);
870 printf(" burst_amplitude=%d\n",burst_amplitude);
871 printf(" sub_carrier_phase=%d\n",sub_carrier_phase);
872 }
873 }
874 }
875 #endif /* VERBOSE */
876
877 #ifdef VERIFY
878 verify_picture_coding_extension++;
879 #endif /* VERIFY */
880 }
881
882
883 /* decode picture spatial scalable extension */
884 /* ISO/IEC 13818-2 section 6.2.3.5. */
885 static void picture_spatial_scalable_extension()
886 {
887 int pos;
888
889 pos = ld->Bitcnt;
890
891 ld->pict_scal = 1; /* use spatial scalability in this picture */
892
893 lower_layer_temporal_reference = Get_Bits(10);
894 marker_bit("picture_spatial_scalable_extension(), first marker bit");
895 lower_layer_horizontal_offset = Get_Bits(15);
896 if (lower_layer_horizontal_offset>=16384)
897 lower_layer_horizontal_offset-= 32768;
898 marker_bit("picture_spatial_scalable_extension(), second marker bit");
899 lower_layer_vertical_offset = Get_Bits(15);
900 if (lower_layer_vertical_offset>=16384)
901 lower_layer_vertical_offset-= 32768;
902 spatial_temporal_weight_code_table_index = Get_Bits(2);
903 lower_layer_progressive_frame = Get_Bits(1);
904 lower_layer_deinterlaced_field_select = Get_Bits(1);
905
906 #ifdef VERBOSE
907 if (Verbose_Flag>NO_LAYER)
908 {
909 printf("picture spatial scalable extension (byte %d)\n",(pos>>3)-4);
910 if (Verbose_Flag>SEQUENCE_LAYER)
911 {
912 printf(" lower_layer_temporal_reference=%d\n",lower_layer_temporal_reference);
913 printf(" lower_layer_horizontal_offset=%d\n",lower_layer_horizontal_offset);
914 printf(" lower_layer_vertical_offset=%d\n",lower_layer_vertical_offset);
915 printf(" spatial_temporal_weight_code_table_index=%d\n",
916 spatial_temporal_weight_code_table_index);
917 printf(" lower_layer_progressive_frame=%d\n",lower_layer_progressive_frame);
918 printf(" lower_layer_deinterlaced_field_select=%d\n",lower_layer_deinterlaced_field_select);
919 }
920 }
921 #endif /* VERBOSE */
922
923 #ifdef VERIFY
924 verify_picture_spatial_scalable_extension++;
925 #endif /* VERIFY */
926
927 }
928
929
930 /* decode picture temporal scalable extension
931 *
932 * not implemented
933 */
934 /* ISO/IEC 13818-2 section 6.2.3.4. */
935 static void picture_temporal_scalable_extension()
936 {
937 Error("temporal scalability not supported\n");
938
939 #ifdef VERIFY
940 verify_picture_temporal_scalable_extension++;
941 #endif /* VERIFY */
942 }
943
944
945 /* decode extra bit information */
946 /* ISO/IEC 13818-2 section 6.2.3.4. */
947 static int extra_bit_information()
948 {
949 int Byte_Count = 0;
950
951 while (Get_Bits1())
952 {
953 Flush_Buffer(8);
954 Byte_Count++;
955 }
956
957 return(Byte_Count);
958 }
959
960
961
962 /* ISO/IEC 13818-2 section 5.3 */
963 /* Purpose: this function is mainly designed to aid in bitstream conformance
964 testing. A simple Flush_Buffer(1) would do */
965 void marker_bit(text)
966 char *text;
967 {
968 int marker;
969
970 marker = Get_Bits(1);
971
972 #ifdef VERIFY
973 if(!marker)
974 printf("ERROR: %s--marker_bit set to 0",text);
975 #endif
976 }
977
978
979 /* ISO/IEC 13818-2 sections 6.3.4.1 and 6.2.2.2.2 */
980 static void user_data()
981 {
982 /* skip ahead to the next start code */
983 next_start_code();
984 }
985
986
987
988 /* Copyright extension */
989 /* ISO/IEC 13818-2 section 6.2.3.6. */
990 /* (header added in November, 1994 to the IS document) */
991
992
993 static void copyright_extension()
994 {
995 int pos;
996 int reserved_data;
997
998 pos = ld->Bitcnt;
999
1000
1001 copyright_flag = Get_Bits(1);
1002 copyright_identifier = Get_Bits(8);
1003 original_or_copy = Get_Bits(1);
1004
1005 /* reserved */
1006 reserved_data = Get_Bits(7);
1007
1008 marker_bit("copyright_extension(), first marker bit");
1009 copyright_number_1 = Get_Bits(20);
1010 marker_bit("copyright_extension(), second marker bit");
1011 copyright_number_2 = Get_Bits(22);
1012 marker_bit("copyright_extension(), third marker bit");
1013 copyright_number_3 = Get_Bits(22);
1014
1015 if(Verbose_Flag>NO_LAYER)
1016 {
1017 printf("copyright_extension (byte %d)\n",(pos>>3)-4);
1018 if (Verbose_Flag>SEQUENCE_LAYER)
1019 {
1020 printf(" copyright_flag =%d\n",copyright_flag);
1021
1022 printf(" copyright_identifier=%d\n",copyright_identifier);
1023
1024 printf(" original_or_copy = %d (original=1, copy=0)\n",
1025 original_or_copy);
1026
1027 printf(" copyright_number_1=%d\n",copyright_number_1);
1028 printf(" copyright_number_2=%d\n",copyright_number_2);
1029 printf(" copyright_number_3=%d\n",copyright_number_3);
1030 }
1031 }
1032
1033 #ifdef VERIFY
1034 verify_copyright_extension++;
1035 #endif /* VERIFY */
1036 }
1037
1038
1039
1040 /* introduced in September 1995 to assist Spatial Scalability */
1041 static void Update_Temporal_Reference_Tacking_Data()
1042 {
1043 static int temporal_reference_wrap = 0;
1044 static int temporal_reference_old = 0;
1045
1046 if (ld == &base) /* *CH* */
1047 {
1048 if (picture_coding_type!=B_TYPE && temporal_reference!=temporal_reference_old)
1049 /* check first field of */
1050 {
1051 /* non-B-frame */
1052 if (temporal_reference_wrap)
1053 {/* wrap occured at previous I- or P-frame */
1054 /* now all intervening B-frames which could
1055 still have high temporal_reference values are done */
1056 Temporal_Reference_Base += 1024;
1057 temporal_reference_wrap = 0;
1058 }
1059
1060 /* distinguish from a reset */
1061 if (temporal_reference<temporal_reference_old && !Temporal_Reference_GOP_Reset)
1062 temporal_reference_wrap = 1; /* we must have just passed a GOP-Header! */
1063
1064 temporal_reference_old = temporal_reference;
1065 Temporal_Reference_GOP_Reset = 0;
1066 }
1067
1068 True_Framenum = Temporal_Reference_Base + temporal_reference;
1069
1070 /* temporary wrap of TR at 1024 for M frames */
1071 if (temporal_reference_wrap && temporal_reference <= temporal_reference_old)
1072 True_Framenum += 1024;
1073
1074 True_Framenum_max = (True_Framenum > True_Framenum_max) ?
1075 True_Framenum : True_Framenum_max;
1076 }
1077 }
This webpage is intended to be an accessible preview of this repository. To get a fuller picture, clone it and use the git CLI.