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