Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1624 giacomo 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
}