Subversion Repositories shark

Rev

Rev 1086 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1085 pj 1
/* getvlc.c, variable length 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
#include "getvlc.h"
35
 
36
/* private prototypes */
37
/* generic picture macroblock type processing functions */
38
static int Get_I_macroblock_type _ANSI_ARGS_((void));
39
static int Get_P_macroblock_type _ANSI_ARGS_((void));
40
static int Get_B_macroblock_type _ANSI_ARGS_((void));
41
static int Get_D_macroblock_type _ANSI_ARGS_((void));
42
 
43
/* spatial picture macroblock type processing functions */
44
static int Get_I_Spatial_macroblock_type _ANSI_ARGS_((void));
45
static int Get_P_Spatial_macroblock_type _ANSI_ARGS_((void));
46
static int Get_B_Spatial_macroblock_type _ANSI_ARGS_((void));
47
static int Get_SNR_macroblock_type _ANSI_ARGS_((void));
48
 
49
int Get_macroblock_type()
50
{
51
  int macroblock_type = 0;
52
 
53
  if (ld->scalable_mode==SC_SNR)
54
    macroblock_type = Get_SNR_macroblock_type();
55
  else
56
  {
57
    switch (picture_coding_type)
58
    {
59
    case I_TYPE:
60
      macroblock_type = ld->pict_scal ? Get_I_Spatial_macroblock_type() : Get_I_macroblock_type();
61
      break;
62
    case P_TYPE:
63
      macroblock_type = ld->pict_scal ? Get_P_Spatial_macroblock_type() : Get_P_macroblock_type();
64
      break;
65
    case B_TYPE:
66
      macroblock_type = ld->pict_scal ? Get_B_Spatial_macroblock_type() : Get_B_macroblock_type();
67
      break;
68
    case D_TYPE:
69
      macroblock_type = Get_D_macroblock_type();
70
      break;
71
    default:
72
      printf("Get_macroblock_type(): unrecognized picture coding type\n");
73
      break;
74
    }
75
  }
76
 
77
  return macroblock_type;
78
}
79
 
80
static int Get_I_macroblock_type()
81
{
82
#ifdef TRACE
83
  if (Trace_Flag)
84
    printf("macroblock_type(I) ");
85
#endif /* TRACE */
86
 
87
  if (Get_Bits1())
88
  {
89
#ifdef TRACE
90
    if (Trace_Flag)
91
      printf("(1): Intra (1)\n");
92
#endif /* TRACE */
93
    return 1;
94
  }
95
 
96
  if (!Get_Bits1())
97
  {
98
    if (!Quiet_Flag)
99
      printf("Invalid macroblock_type code\n");
100
    Fault_Flag = 1;
101
  }
102
 
103
#ifdef TRACE
104
  if (Trace_Flag)
105
    printf("(01): Intra, Quant (17)\n");
106
#endif /* TRACE */
107
 
108
  return 17;
109
}
110
 
111
static char *MBdescr[]={
112
  "",                  "Intra",        "No MC, Coded",         "",
113
  "Bwd, Not Coded",    "",             "Bwd, Coded",           "",
114
  "Fwd, Not Coded",    "",             "Fwd, Coded",           "",
115
  "Interp, Not Coded", "",             "Interp, Coded",        "",
116
  "",                  "Intra, Quant", "No MC, Coded, Quant",  "",
117
  "",                  "",             "Bwd, Coded, Quant",    "",
118
  "",                  "",             "Fwd, Coded, Quant",    "",
119
  "",                  "",             "Interp, Coded, Quant", ""
120
};
121
 
122
static int Get_P_macroblock_type()
123
{
124
  int code;
125
 
126
#ifdef TRACE
127
  if (Trace_Flag)
128
    printf("macroblock_type(P) (");
129
#endif /* TRACE */
130
 
131
  if ((code = Show_Bits(6))>=8)
132
  {
133
    code >>= 3;
134
    Flush_Buffer(PMBtab0[code].len);
135
#ifdef TRACE
136
    if (Trace_Flag)
137
    {
138
      Print_Bits(code,3,PMBtab0[code].len);
139
      printf("): %s (%d)\n",MBdescr[(int)PMBtab0[code].val],PMBtab0[code].val);
140
    }
141
#endif /* TRACE */
142
    return PMBtab0[code].val;
143
  }
144
 
145
  if (code==0)
146
  {
147
    if (!Quiet_Flag)
148
      printf("Invalid macroblock_type code\n");
149
    Fault_Flag = 1;
150
    return 0;
151
  }
152
 
153
  Flush_Buffer(PMBtab1[code].len);
154
 
155
#ifdef TRACE
156
  if (Trace_Flag)
157
  {
158
    Print_Bits(code,6,PMBtab1[code].len);
159
    printf("): %s (%d)\n",MBdescr[(int)PMBtab1[code].val],PMBtab1[code].val);
160
  }
161
#endif /* TRACE */
162
 
163
  return PMBtab1[code].val;
164
}
165
 
166
static int Get_B_macroblock_type()
167
{
168
  int code;
169
 
170
#ifdef TRACE
171
  if (Trace_Flag)
172
    printf("macroblock_type(B) (");
173
#endif /* TRACE */
174
 
175
  if ((code = Show_Bits(6))>=8)
176
  {
177
    code >>= 2;
178
    Flush_Buffer(BMBtab0[code].len);
179
 
180
#ifdef TRACE
181
    if (Trace_Flag)
182
    {
183
      Print_Bits(code,4,BMBtab0[code].len);
184
      printf("): %s (%d)\n",MBdescr[(int)BMBtab0[code].val],BMBtab0[code].val);
185
    }
186
#endif /* TRACE */
187
 
188
    return BMBtab0[code].val;
189
  }
190
 
191
  if (code==0)
192
  {
193
    if (!Quiet_Flag)
194
      printf("Invalid macroblock_type code\n");
195
    Fault_Flag = 1;
196
    return 0;
197
  }
198
 
199
  Flush_Buffer(BMBtab1[code].len);
200
 
201
#ifdef TRACE
202
  if (Trace_Flag)
203
  {
204
    Print_Bits(code,6,BMBtab1[code].len);
205
    printf("): %s (%d)\n",MBdescr[(int)BMBtab1[code].val],BMBtab1[code].val);
206
  }
207
#endif /* TRACE */
208
 
209
  return BMBtab1[code].val;
210
}
211
 
212
static int Get_D_macroblock_type()
213
{
214
  if (!Get_Bits1())
215
  {
216
    if (!Quiet_Flag)
217
      printf("Invalid macroblock_type code\n");
218
    Fault_Flag=1;
219
  }
220
 
221
  return 1;
222
}
223
 
224
/* macroblock_type for pictures with spatial scalability */
225
static int Get_I_Spatial_macroblock_type()
226
{
227
  int code;
228
 
229
#ifdef TRACE
230
  if (Trace_Flag)
231
    printf("macroblock_type(I,spat) (");
232
#endif /* TRACE */
233
 
234
  code = Show_Bits(4);
235
 
236
  if (code==0)
237
  {
238
    if (!Quiet_Flag)
239
      printf("Invalid macroblock_type code\n");
240
    Fault_Flag = 1;
241
    return 0;
242
  }
243
 
244
#ifdef TRACE
245
  if (Trace_Flag)
246
  {
247
    Print_Bits(code,4,spIMBtab[code].len);
248
    printf("): %02x\n",spIMBtab[code].val);
249
  }
250
#endif /* TRACE */
251
 
252
  Flush_Buffer(spIMBtab[code].len);
253
  return spIMBtab[code].val;
254
}
255
 
256
static int Get_P_Spatial_macroblock_type()
257
{
258
  int code;
259
 
260
#ifdef TRACE
261
  if (Trace_Flag)
262
    printf("macroblock_type(P,spat) (");
263
#endif /* TRACE */
264
 
265
  code = Show_Bits(7);
266
 
267
  if (code<2)
268
  {
269
    if (!Quiet_Flag)
270
      printf("Invalid macroblock_type code\n");
271
    Fault_Flag = 1;
272
    return 0;
273
  }
274
 
275
  if (code>=16)
276
  {
277
    code >>= 3;
278
    Flush_Buffer(spPMBtab0[code].len);
279
 
280
#ifdef TRACE
281
    if (Trace_Flag)
282
    {
283
      Print_Bits(code,4,spPMBtab0[code].len);
284
      printf("): %02x\n",spPMBtab0[code].val);
285
    }
286
#endif /* TRACE */
287
 
288
    return spPMBtab0[code].val;
289
  }
290
 
291
  Flush_Buffer(spPMBtab1[code].len);
292
 
293
#ifdef TRACE
294
  if (Trace_Flag)
295
  {
296
    Print_Bits(code,7,spPMBtab1[code].len);
297
    printf("): %02x\n",spPMBtab1[code].val);
298
  }
299
#endif /* TRACE */
300
 
301
  return spPMBtab1[code].val;
302
}
303
 
304
static int Get_B_Spatial_macroblock_type()
305
{
306
  int code;
307
  VLCtab *p;
308
 
309
#ifdef TRACE
310
  if (Trace_Flag)
311
    printf("macroblock_type(B,spat) (");
312
#endif /* TRACE */
313
 
314
  code = Show_Bits(9);
315
 
316
  if (code>=64)
317
    p = &spBMBtab0[(code>>5)-2];
318
  else if (code>=16)
319
    p = &spBMBtab1[(code>>2)-4];
320
  else if (code>=8)
321
    p = &spBMBtab2[code-8];
322
  else
323
  {
324
    if (!Quiet_Flag)
325
      printf("Invalid macroblock_type code\n");
326
    Fault_Flag = 1;
327
    return 0;
328
  }
329
 
330
  Flush_Buffer(p->len);
331
 
332
#ifdef TRACE
333
  if (Trace_Flag)
334
  {
335
    Print_Bits(code,9,p->len);
336
    printf("): %02x\n",p->val);
337
  }
338
#endif /* TRACE */
339
 
340
  return p->val;
341
}
342
 
343
static int Get_SNR_macroblock_type()
344
{
345
  int code;
346
 
347
#ifdef TRACE                    /* *CH* */
348
  if (Trace_Flag)
349
    printf("macroblock_type(SNR) (");
1110 pj 350
#endif
1085 pj 351
 
352
  code = Show_Bits(3);
353
 
354
  if (code==0)
355
  {
356
    if (!Quiet_Flag)
357
      printf("Invalid macroblock_type code\n");
358
    Fault_Flag = 1;
359
    return 0;
360
  }
361
 
362
  Flush_Buffer(SNRMBtab[code].len);
363
 
364
#ifdef TRACE                    /* *CH* */
365
  if (Trace_Flag)
366
  {
367
    Print_Bits(code,3,SNRMBtab[code].len);
368
    printf("): %s (%d)\n",MBdescr[(int)SNRMBtab[code].val],SNRMBtab[code].val);
369
  }
1110 pj 370
#endif
1085 pj 371
 
372
 
373
  return SNRMBtab[code].val;
374
}
375
 
376
int Get_motion_code()
377
{
378
  int code;
379
 
380
#ifdef TRACE
381
  if (Trace_Flag)
382
    printf("motion_code (");
383
#endif /* TRACE */
384
 
385
  if (Get_Bits1())
386
  {
387
#ifdef TRACE
388
    if (Trace_Flag)
389
      printf("0): 0\n");
390
#endif /* TRACE */
391
    return 0;
392
  }
393
 
394
  if ((code = Show_Bits(9))>=64)
395
  {
396
    code >>= 6;
397
    Flush_Buffer(MVtab0[code].len);
398
 
399
#ifdef TRACE
400
    if (Trace_Flag)
401
    {
402
      Print_Bits(code,3,MVtab0[code].len);
403
      printf("%d): %d\n",
404
        Show_Bits(1),Show_Bits(1)?-MVtab0[code].val:MVtab0[code].val);
405
    }
406
#endif /* TRACE */
407
 
408
    return Get_Bits1()?-MVtab0[code].val:MVtab0[code].val;
409
  }
410
 
411
  if (code>=24)
412
  {
413
    code >>= 3;
414
    Flush_Buffer(MVtab1[code].len);
415
 
416
#ifdef TRACE
417
    if (Trace_Flag)
418
    {
419
      Print_Bits(code,6,MVtab1[code].len);
420
      printf("%d): %d\n",
421
        Show_Bits(1),Show_Bits(1)?-MVtab1[code].val:MVtab1[code].val);
422
    }
423
#endif /* TRACE */
424
 
425
    return Get_Bits1()?-MVtab1[code].val:MVtab1[code].val;
426
  }
427
 
428
  if ((code-=12)<0)
429
  {
430
    if (!Quiet_Flag)
431
/* HACK */
432
      printf("Invalid motion_vector code (MBA %d, pic %d)\n", global_MBA, global_pic);
433
    Fault_Flag=1;
434
    return 0;
435
  }
436
 
437
  Flush_Buffer(MVtab2[code].len);
438
 
439
#ifdef TRACE
440
  if (Trace_Flag)
441
  {
442
    Print_Bits(code+12,9,MVtab2[code].len);
443
    printf("%d): %d\n",
444
      Show_Bits(1),Show_Bits(1)?-MVtab2[code].val:MVtab2[code].val);
445
  }
446
#endif /* TRACE */
447
 
448
  return Get_Bits1() ? -MVtab2[code].val : MVtab2[code].val;
449
}
450
 
451
/* get differential motion vector (for dual prime prediction) */
452
int Get_dmvector()
453
{
454
#ifdef TRACE
455
  if (Trace_Flag)
456
    printf("dmvector (");
457
#endif /* TRACE */
458
 
459
  if (Get_Bits(1))
460
  {
461
#ifdef TRACE
462
    if (Trace_Flag)
463
      printf(Show_Bits(1) ? "11): -1\n" : "10): 1\n");
464
#endif /* TRACE */
465
    return Get_Bits(1) ? -1 : 1;
466
  }
467
  else
468
  {
469
#ifdef TRACE
470
    if (Trace_Flag)
471
      printf("0): 0\n");
472
#endif /* TRACE */
473
    return 0;
474
  }
475
}
476
 
477
int Get_coded_block_pattern()
478
{
479
  int code;
480
 
481
#ifdef TRACE
482
  if (Trace_Flag)
483
    printf("coded_block_pattern_420 (");
484
#endif /* TRACE */
485
 
486
  if ((code = Show_Bits(9))>=128)
487
  {
488
    code >>= 4;
489
    Flush_Buffer(CBPtab0[code].len);
490
 
491
#ifdef TRACE
492
    if (Trace_Flag)
493
    {
494
      Print_Bits(code,5,CBPtab0[code].len);
495
      printf("): ");
496
      Print_Bits(CBPtab0[code].val,6,6);
497
      printf(" (%d)\n",CBPtab0[code].val);
498
    }
499
#endif /* TRACE */
500
 
501
    return CBPtab0[code].val;
502
  }
503
 
504
  if (code>=8)
505
  {
506
    code >>= 1;
507
    Flush_Buffer(CBPtab1[code].len);
508
 
509
#ifdef TRACE
510
    if (Trace_Flag)
511
    {
512
      Print_Bits(code,8,CBPtab1[code].len);
513
      printf("): ");
514
      Print_Bits(CBPtab1[code].val,6,6);
515
      printf(" (%d)\n",CBPtab1[code].val);
516
    }
517
#endif /* TRACE */
518
 
519
    return CBPtab1[code].val;
520
  }
521
 
522
  if (code<1)
523
  {
524
    if (!Quiet_Flag)
525
      printf("Invalid coded_block_pattern code\n");
526
    Fault_Flag = 1;
527
    return 0;
528
  }
529
 
530
  Flush_Buffer(CBPtab2[code].len);
531
 
532
#ifdef TRACE
533
  if (Trace_Flag)
534
  {
535
    Print_Bits(code,9,CBPtab2[code].len);
536
    printf("): ");
537
    Print_Bits(CBPtab2[code].val,6,6);
538
    printf(" (%d)\n",CBPtab2[code].val);
539
  }
540
#endif /* TRACE */
541
 
542
  return CBPtab2[code].val;
543
}
544
 
545
int Get_macroblock_address_increment()
546
{
547
  int code, val;
548
 
549
#ifdef TRACE
550
  if (Trace_Flag)
551
    printf("macroblock_address_increment (");
552
#endif /* TRACE */
553
 
554
  val = 0;
555
 
556
  while ((code = Show_Bits(11))<24)
557
  {
558
    if (code!=15) /* if not macroblock_stuffing */
559
    {
560
      if (code==8) /* if macroblock_escape */
561
      {
562
#ifdef TRACE
563
        if (Trace_Flag)
564
          printf("00000001000 ");
565
#endif /* TRACE */
566
 
567
        val+= 33;
568
      }
569
      else
570
      {
571
        if (!Quiet_Flag)
572
          printf("Invalid macroblock_address_increment code\n");
573
 
574
        Fault_Flag = 1;
575
        return 1;
576
      }
577
    }
578
    else /* macroblock suffing */
579
    {
580
#ifdef TRACE
581
      if (Trace_Flag)
582
        printf("00000001111 ");
583
#endif /* TRACE */
584
    }
585
 
586
    Flush_Buffer(11);
587
  }
588
 
589
  /* macroblock_address_increment == 1 */
590
  /* ('1' is in the MSB position of the lookahead) */
591
  if (code>=1024)
592
  {
593
    Flush_Buffer(1);
594
#ifdef TRACE
595
    if (Trace_Flag)
596
      printf("1): %d\n",val+1);
597
#endif /* TRACE */
598
    return val + 1;
599
  }
600
 
601
  /* codes 00010 ... 011xx */
602
  if (code>=128)
603
  {
604
    /* remove leading zeros */
605
    code >>= 6;
606
    Flush_Buffer(MBAtab1[code].len);
607
 
608
#ifdef TRACE
609
    if (Trace_Flag)
610
    {
611
      Print_Bits(code,5,MBAtab1[code].len);
612
      printf("): %d\n",val+MBAtab1[code].val);
613
    }
614
#endif /* TRACE */
615
 
616
 
617
    return val + MBAtab1[code].val;
618
  }
619
 
620
  /* codes 00000011000 ... 0000111xxxx */
621
  code-= 24; /* remove common base */
622
  Flush_Buffer(MBAtab2[code].len);
623
 
624
#ifdef TRACE
625
  if (Trace_Flag)
626
  {
627
    Print_Bits(code+24,11,MBAtab2[code].len);
628
    printf("): %d\n",val+MBAtab2[code].val);
629
  }
630
#endif /* TRACE */
631
 
632
  return val + MBAtab2[code].val;
633
}
634
 
635
/* combined MPEG-1 and MPEG-2 stage. parse VLC and
636
   perform dct_diff arithmetic.
637
 
638
   MPEG-1:  ISO/IEC 11172-2 section
639
   MPEG-2:  ISO/IEC 13818-2 section 7.2.1
640
 
641
   Note: the arithmetic here is presented more elegantly than
642
   the spec, yet the results, dct_diff, are the same.
643
*/
644
 
645
int Get_Luma_DC_dct_diff()
646
{
647
  int code, size, dct_diff;
648
 
649
#ifdef TRACE
650
/*
651
  if (Trace_Flag)
652
    printf("dct_dc_size_luminance: (");
653
*/
654
#endif /* TRACE */
655
 
656
  /* decode length */
657
  code = Show_Bits(5);
658
 
659
  if (code<31)
660
  {
661
    size = DClumtab0[code].val;
662
    Flush_Buffer(DClumtab0[code].len);
663
#ifdef TRACE
664
/*
665
    if (Trace_Flag)
666
    {
667
      Print_Bits(code,5,DClumtab0[code].len);
668
      printf("): %d",size);
669
    }
670
*/
671
#endif /* TRACE */
672
  }
673
  else
674
  {
675
    code = Show_Bits(9) - 0x1f0;
676
    size = DClumtab1[code].val;
677
    Flush_Buffer(DClumtab1[code].len);
678
 
679
#ifdef TRACE
680
/*
681
    if (Trace_Flag)
682
    {
683
      Print_Bits(code+0x1f0,9,DClumtab1[code].len);
684
      printf("): %d",size);
685
    }
686
*/
687
#endif /* TRACE */
688
  }
689
 
690
#ifdef TRACE
691
/*
692
  if (Trace_Flag)
693
    printf(", dct_dc_differential (");
694
*/
695
#endif /* TRACE */
696
 
697
  if (size==0)
698
    dct_diff = 0;
699
  else
700
  {
701
    dct_diff = Get_Bits(size);
702
#ifdef TRACE
703
/*
704
    if (Trace_Flag)
705
      Print_Bits(dct_diff,size,size);
706
*/
707
#endif /* TRACE */
708
    if ((dct_diff & (1<<(size-1)))==0)
709
      dct_diff-= (1<<size) - 1;
710
  }
711
 
712
#ifdef TRACE
713
/*
714
  if (Trace_Flag)
715
    printf("): %d\n",dct_diff);
716
*/
717
#endif /* TRACE */
718
 
719
  return dct_diff;
720
}
721
 
722
 
723
int Get_Chroma_DC_dct_diff()
724
{
725
  int code, size, dct_diff;
726
 
727
#ifdef TRACE
728
/*
729
  if (Trace_Flag)
730
    printf("dct_dc_size_chrominance: (");
731
*/
732
#endif /* TRACE */
733
 
734
  /* decode length */
735
  code = Show_Bits(5);
736
 
737
  if (code<31)
738
  {
739
    size = DCchromtab0[code].val;
740
    Flush_Buffer(DCchromtab0[code].len);
741
 
742
#ifdef TRACE
743
/*
744
    if (Trace_Flag)
745
    {
746
      Print_Bits(code,5,DCchromtab0[code].len);
747
      printf("): %d",size);
748
    }
749
*/
750
#endif /* TRACE */
751
  }
752
  else
753
  {
754
    code = Show_Bits(10) - 0x3e0;
755
    size = DCchromtab1[code].val;
756
    Flush_Buffer(DCchromtab1[code].len);
757
 
758
#ifdef TRACE
759
/*
760
    if (Trace_Flag)
761
    {
762
      Print_Bits(code+0x3e0,10,DCchromtab1[code].len);
763
      printf("): %d",size);
764
    }
765
*/
766
#endif /* TRACE */
767
  }
768
 
769
#ifdef TRACE
770
/*
771
  if (Trace_Flag)
772
    printf(", dct_dc_differential (");
773
*/
774
#endif /* TRACE */
775
 
776
  if (size==0)
777
    dct_diff = 0;
778
  else
779
  {
780
    dct_diff = Get_Bits(size);
781
#ifdef TRACE
782
/*
783
    if (Trace_Flag)
784
      Print_Bits(dct_diff,size,size);
785
*/
786
#endif /* TRACE */
787
    if ((dct_diff & (1<<(size-1)))==0)
788
      dct_diff-= (1<<size) - 1;
789
  }
790
 
791
#ifdef TRACE
792
/*
793
  if (Trace_Flag)
794
    printf("): %d\n",dct_diff);
795
*/
796
#endif /* TRACE */
797
 
798
  return dct_diff;
799
}