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