URL https://opencores.org/ocsvn/mpeg2fpga/mpeg2fpga/trunk

Subversion Repositories mpeg2fpga

[/] [mpeg2fpga/] [trunk/] [tools/] [mpeg2dec/] [getvlc.c] - Blame information for rev 2

Details | Compare with Previous | View Log


/* getvlc.c, variable length decoding                                       */
 
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
 
/*
 * Disclaimer of Warranty
 *
 * These software programs are available to the user without any license fee or
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
 * any and all warranties, whether express, implied, or statuary, including any
 * implied warranties or merchantability or of fitness for a particular
 * purpose.  In no event shall the copyright-holder be liable for any
 * incidental, punitive, or consequential damages of any kind whatsoever
 * arising from the use of these programs.
 *
 * This disclaimer of warranty extends to the user of these programs and user's
 * customers, employees, agents, transferees, successors, and assigns.
 *
 * The MPEG Software Simulation Group does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any third-party
 * patents.
 *
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
 * are subject to royalty fees to patent holders.  Many of these patents are
 * general enough such that they are unavoidable regardless of implementation
 * design.
 *
 */
 
#include <stdio.h>
 
#include "config.h"
#include "global.h"
#include "getvlc.h"
 
/* private prototypes */
/* generic picture macroblock type processing functions */
static int Get_I_macroblock_type _ANSI_ARGS_((void));
static int Get_P_macroblock_type _ANSI_ARGS_((void));
static int Get_B_macroblock_type _ANSI_ARGS_((void));
static int Get_D_macroblock_type _ANSI_ARGS_((void));
 
/* spatial picture macroblock type processing functions */
static int Get_I_Spatial_macroblock_type _ANSI_ARGS_((void));
static int Get_P_Spatial_macroblock_type _ANSI_ARGS_((void));
static int Get_B_Spatial_macroblock_type _ANSI_ARGS_((void));
static int Get_SNR_macroblock_type _ANSI_ARGS_((void));
 
int Get_macroblock_type()
{
  int macroblock_type = 0;
 
  if (ld->scalable_mode==SC_SNR)
    macroblock_type = Get_SNR_macroblock_type();
  else
  {
    switch (picture_coding_type)
    {
    case I_TYPE:
      macroblock_type = ld->pict_scal ? Get_I_Spatial_macroblock_type() : Get_I_macroblock_type();
      break;
    case P_TYPE:
      macroblock_type = ld->pict_scal ? Get_P_Spatial_macroblock_type() : Get_P_macroblock_type();
      break;
    case B_TYPE:
      macroblock_type = ld->pict_scal ? Get_B_Spatial_macroblock_type() : Get_B_macroblock_type();
      break;
    case D_TYPE:
      macroblock_type = Get_D_macroblock_type();
      break;
    default:
      printf("Get_macroblock_type(): unrecognized picture coding type\n");
      break;
    }
  }
 
  return macroblock_type;
}
 
static int Get_I_macroblock_type()
{
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(I) ");
#endif /* TRACE */
 
  if (Get_Bits1())
  {
#ifdef TRACE
    if (Trace_Flag)
      printf("(1): Intra (1)\n");
#endif /* TRACE */
    return 1;
  }
 
  if (!Get_Bits1())
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
  }
 
#ifdef TRACE
  if (Trace_Flag)
    printf("(01): Intra, Quant (17)\n");
#endif /* TRACE */
 
  return 17;
}
 
static char *MBdescr[]={
  "",                  "Intra",        "No MC, Coded",         "",
  "Bwd, Not Coded",    "",             "Bwd, Coded",           "",
  "Fwd, Not Coded",    "",             "Fwd, Coded",           "",
  "Interp, Not Coded", "",             "Interp, Coded",        "",
  "",                  "Intra, Quant", "No MC, Coded, Quant",  "",
  "",                  "",             "Bwd, Coded, Quant",    "",
  "",                  "",             "Fwd, Coded, Quant",    "",
  "",                  "",             "Interp, Coded, Quant", ""
};
 
static int Get_P_macroblock_type()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(P) (");
#endif /* TRACE */
 
  if ((code = Show_Bits(6))>=8)
  {
    code >>= 3;
    Flush_Buffer(PMBtab0[code].len);
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,3,PMBtab0[code].len);
      printf("): %s (%d)\n",MBdescr[(int)PMBtab0[code].val],PMBtab0[code].val);
    }
#endif /* TRACE */
    return PMBtab0[code].val;
  }
 
  if (code==0)
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  Flush_Buffer(PMBtab1[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,6,PMBtab1[code].len);
    printf("): %s (%d)\n",MBdescr[(int)PMBtab1[code].val],PMBtab1[code].val);
  }
#endif /* TRACE */
 
  return PMBtab1[code].val;
}
 
static int Get_B_macroblock_type()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(B) (");
#endif /* TRACE */
 
  if ((code = Show_Bits(6))>=8)
  {
    code >>= 2;
    Flush_Buffer(BMBtab0[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,4,BMBtab0[code].len);
      printf("): %s (%d)\n",MBdescr[(int)BMBtab0[code].val],BMBtab0[code].val);
    }
#endif /* TRACE */
 
    return BMBtab0[code].val;
  }
 
  if (code==0)
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  Flush_Buffer(BMBtab1[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,6,BMBtab1[code].len);
    printf("): %s (%d)\n",MBdescr[(int)BMBtab1[code].val],BMBtab1[code].val);
  }
#endif /* TRACE */
 
  return BMBtab1[code].val;
}
 
static int Get_D_macroblock_type()
{
  if (!Get_Bits1())
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag=1;
  }
 
  return 1;
}
 
/* macroblock_type for pictures with spatial scalability */
static int Get_I_Spatial_macroblock_type()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(I,spat) (");
#endif /* TRACE */
 
  code = Show_Bits(4);
 
  if (code==0)
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,4,spIMBtab[code].len);
    printf("): %02x\n",spIMBtab[code].val);
  }
#endif /* TRACE */
 
  Flush_Buffer(spIMBtab[code].len);
  return spIMBtab[code].val;
}
 
static int Get_P_Spatial_macroblock_type()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(P,spat) (");
#endif /* TRACE */
 
  code = Show_Bits(7);
 
  if (code<2)
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  if (code>=16)
  {
    code >>= 3;
    Flush_Buffer(spPMBtab0[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,4,spPMBtab0[code].len);
      printf("): %02x\n",spPMBtab0[code].val);
    }
#endif /* TRACE */
 
    return spPMBtab0[code].val;
  }
 
  Flush_Buffer(spPMBtab1[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,7,spPMBtab1[code].len);
    printf("): %02x\n",spPMBtab1[code].val);
  }
#endif /* TRACE */
 
  return spPMBtab1[code].val;
}
 
static int Get_B_Spatial_macroblock_type()
{
  int code;
  VLCtab *p;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_type(B,spat) (");
#endif /* TRACE */
 
  code = Show_Bits(9);
 
  if (code>=64)
    p = &spBMBtab0[(code>>5)-2];
  else if (code>=16)
    p = &spBMBtab1[(code>>2)-4];
  else if (code>=8)
    p = &spBMBtab2[code-8];
  else
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  Flush_Buffer(p->len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,9,p->len);
    printf("): %02x\n",p->val);
  }
#endif /* TRACE */
 
  return p->val;
}
 
static int Get_SNR_macroblock_type()
{
  int code;
 
#ifdef TRACE                    /* *CH* */
  if (Trace_Flag)
    printf("macroblock_type(SNR) (");
#endif
 
  code = Show_Bits(3);
 
  if (code==0)
  {
    if (!Quiet_Flag)
      printf("Invalid macroblock_type code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  Flush_Buffer(SNRMBtab[code].len);
 
#ifdef TRACE                    /* *CH* */
  if (Trace_Flag)
  {
    Print_Bits(code,3,SNRMBtab[code].len);
    printf("): %s (%d)\n",MBdescr[(int)SNRMBtab[code].val],SNRMBtab[code].val);
  }
#endif 
 
 
  return SNRMBtab[code].val;
}
 
int Get_motion_code()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("motion_code (");
#endif /* TRACE */
 
  if (Get_Bits1())
  {
#ifdef TRACE
    if (Trace_Flag)
      printf("1): 0\n");
#endif /* TRACE */
    return 0;
  }
#ifdef TRACE
  else
  {
    if (Trace_Flag)
    {
      printf("0");
    }
  }
#endif /* TRACE */
 
 
  if ((code = Show_Bits(9))>=64)
  {
    code >>= 6;
    Flush_Buffer(MVtab0[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,3,MVtab0[code].len);
      printf("%d): %d\n",
        Show_Bits(1),Show_Bits(1)?-MVtab0[code].val:MVtab0[code].val);
    }
#endif /* TRACE */
 
    return Get_Bits1()?-MVtab0[code].val:MVtab0[code].val;
  }
 
  if (code>=24)
  {
    code >>= 3;
    Flush_Buffer(MVtab1[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,6,MVtab1[code].len);
      printf("%d): %d\n",
        Show_Bits(1),Show_Bits(1)?-MVtab1[code].val:MVtab1[code].val);
    }
#endif /* TRACE */
 
    return Get_Bits1()?-MVtab1[code].val:MVtab1[code].val;
  }
 
  if ((code-=12)<0)
  {
    if (!Quiet_Flag)
/* HACK */
      printf("Invalid motion_vector code (MBA %d, pic %d)\n", global_MBA, global_pic);
    Fault_Flag=1;
    return 0;
  }
 
  Flush_Buffer(MVtab2[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code+12,9,MVtab2[code].len);
    printf("%d): %d\n",
      Show_Bits(1),Show_Bits(1)?-MVtab2[code].val:MVtab2[code].val);
  }
#endif /* TRACE */
 
  return Get_Bits1() ? -MVtab2[code].val : MVtab2[code].val;
}
 
/* get differential motion vector (for dual prime prediction) */
int Get_dmvector()
{
#ifdef TRACE
  if (Trace_Flag)
    printf("dmvector (");
#endif /* TRACE */
 
  if (Get_Bits(1))
  {
#ifdef TRACE
    if (Trace_Flag)
      printf(Show_Bits(1) ? "11): -1\n" : "10): 1\n");
#endif /* TRACE */
    return Get_Bits(1) ? -1 : 1;
  }
  else
  {
#ifdef TRACE
    if (Trace_Flag)
      printf("0): 0\n");
#endif /* TRACE */
    return 0;
  }
}
 
int Get_coded_block_pattern()
{
  int code;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("coded_block_pattern_420 (");
#endif /* TRACE */
 
  if ((code = Show_Bits(9))>=128)
  {
    code >>= 4;
    Flush_Buffer(CBPtab0[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,5,CBPtab0[code].len);
      printf("): ");
      Print_Bits(CBPtab0[code].val,6,6);
      printf(" (%d)\n",CBPtab0[code].val);
    }
#endif /* TRACE */
 
    return CBPtab0[code].val;
  }
 
  if (code>=8)
  {
    code >>= 1;
    Flush_Buffer(CBPtab1[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,8,CBPtab1[code].len);
      printf("): ");
      Print_Bits(CBPtab1[code].val,6,6);
      printf(" (%d)\n",CBPtab1[code].val);
    }
#endif /* TRACE */
 
    return CBPtab1[code].val;
  }
 
  if (code<1)
  {
    if (!Quiet_Flag)
      printf("Invalid coded_block_pattern code\n");
    Fault_Flag = 1;
    return 0;
  }
 
  Flush_Buffer(CBPtab2[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code,9,CBPtab2[code].len);
    printf("): ");
    Print_Bits(CBPtab2[code].val,6,6);
    printf(" (%d)\n",CBPtab2[code].val);
  }
#endif /* TRACE */
 
  return CBPtab2[code].val;
}
 
int Get_macroblock_address_increment()
{
  int code, val;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("macroblock_address_increment (");
#endif /* TRACE */
 
  val = 0;
 
  while ((code = Show_Bits(11))<24)
  {
    if (code!=15) /* if not macroblock_stuffing */
    {
      if (code==8) /* if macroblock_escape */
      {
#ifdef TRACE
        if (Trace_Flag)
          printf("00000001000 ");
#endif /* TRACE */
 
        val+= 33;
      }
      else
      {
        if (!Quiet_Flag)
          printf("Invalid macroblock_address_increment code\n");
 
        Fault_Flag = 1;
        return 1;
      }
    }
    else /* macroblock suffing */
    {
#ifdef TRACE
      if (Trace_Flag)
        printf("00000001111 ");
#endif /* TRACE */
    }
 
    Flush_Buffer(11);
  }
 
  /* macroblock_address_increment == 1 */
  /* ('1' is in the MSB position of the lookahead) */
  if (code>=1024)
  {
    Flush_Buffer(1);
#ifdef TRACE
    if (Trace_Flag)
      printf("1): %d\n",val+1);
#endif /* TRACE */
    return val + 1;
  }
 
  /* codes 00010 ... 011xx */
  if (code>=128)
  {
    /* remove leading zeros */
    code >>= 6;
    Flush_Buffer(MBAtab1[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,5,MBAtab1[code].len);
      printf("): %d\n",val+MBAtab1[code].val);
    }
#endif /* TRACE */
 
 
    return val + MBAtab1[code].val;
  }
 
  /* codes 00000011000 ... 0000111xxxx */
  code-= 24; /* remove common base */
  Flush_Buffer(MBAtab2[code].len);
 
#ifdef TRACE
  if (Trace_Flag)
  {
    Print_Bits(code+24,11,MBAtab2[code].len);
    printf("): %d\n",val+MBAtab2[code].val);
  }
#endif /* TRACE */
 
  return val + MBAtab2[code].val;
}
 
/* combined MPEG-1 and MPEG-2 stage. parse VLC and
   perform dct_diff arithmetic.
 
   MPEG-1:  ISO/IEC 11172-2 section
   MPEG-2:  ISO/IEC 13818-2 section 7.2.1
 
   Note: the arithmetic here is presented more elegantly than
   the spec, yet the results, dct_diff, are the same.
*/
 
int Get_Luma_DC_dct_diff()
{
  int code, size, dct_diff;
#ifdef TRACE
  if (Trace_Flag)
    printf("dct_dc_size_luminance: (");
#endif /* TRACE */
 
  /* decode length */
  code = Show_Bits(5);
 
  if (code<31)
  {
    size = DClumtab0[code].val;
    Flush_Buffer(DClumtab0[code].len);
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,5,DClumtab0[code].len);
      printf("): %d",size);
    }
#endif /* TRACE */
  }
  else
  {
    code = Show_Bits(9) - 0x1f0;
    size = DClumtab1[code].val;
    Flush_Buffer(DClumtab1[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code+0x1f0,9,DClumtab1[code].len);
      printf("): %d",size);
    }
#endif /* TRACE */
  }
 
#ifdef TRACE
  if (Trace_Flag)
    printf(", dct_dc_differential (");
#endif /* TRACE */
 
  if (size==0)
    dct_diff = 0;
  else
  {
    dct_diff = Get_Bits(size);
#ifdef TRACE
    if (Trace_Flag)
      Print_Bits(dct_diff,size,size);
#endif /* TRACE */
    if ((dct_diff & (1<<(size-1)))==0)
      dct_diff-= (1<<size) - 1;
  }
 
#ifdef TRACE
  if (Trace_Flag)
    printf("): %d\n",dct_diff);
#endif /* TRACE */
 
  return dct_diff;
}
 
 
int Get_Chroma_DC_dct_diff()
{
  int code, size, dct_diff;
 
#ifdef TRACE
  if (Trace_Flag)
    printf("dct_dc_size_chrominance: (");
#endif /* TRACE */
 
  /* decode length */
  code = Show_Bits(5);
 
  if (code<31)
  {
    size = DCchromtab0[code].val;
    Flush_Buffer(DCchromtab0[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code,5,DCchromtab0[code].len);
      printf("): %d",size);
    }
#endif /* TRACE */
  }
  else
  {
    code = Show_Bits(10) - 0x3e0;
    size = DCchromtab1[code].val;
    Flush_Buffer(DCchromtab1[code].len);
 
#ifdef TRACE
    if (Trace_Flag)
    {
      Print_Bits(code+0x3e0,10,DCchromtab1[code].len);
      printf("): %d",size);
    }
#endif /* TRACE */
  }
 
#ifdef TRACE
  if (Trace_Flag)
    printf(", dct_dc_differential (");
#endif /* TRACE */
 
  if (size==0)
    dct_diff = 0;
  else
  {
    dct_diff = Get_Bits(size);
#ifdef TRACE
    if (Trace_Flag)
      Print_Bits(dct_diff,size,size);
#endif /* TRACE */
    if ((dct_diff & (1<<(size-1)))==0)
      dct_diff-= (1<<size) - 1;
  }
 
#ifdef TRACE
  if (Trace_Flag)
    printf("): %d\n",dct_diff);
#endif /* TRACE */
 
  return dct_diff;
}

Browse

Tools

Subversion Repositories mpeg2fpga

[/] [mpeg2fpga/] [trunk/] [tools/] [mpeg2dec/] [getvlc.c] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	kdv	`/* 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) (");`
350			`#endif`
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			`}`
370			`#endif`
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("1): 0\n");`
390			`#endif /* TRACE */`
391			`return 0;`
392			`}`
393			`#ifdef TRACE`
394			`else`
395			`{`
396			`if (Trace_Flag)`
397			`{`
398			`printf("0");`
399			`}`
400			`}`
401			`#endif /* TRACE */`
402
403
404			`if ((code = Show_Bits(9))>=64)`
405			`{`
406			`code >>= 6;`
407			`Flush_Buffer(MVtab0[code].len);`
408
409			`#ifdef TRACE`
410			`if (Trace_Flag)`
411			`{`
412			`Print_Bits(code,3,MVtab0[code].len);`
413			`printf("%d): %d\n",`
414			`Show_Bits(1),Show_Bits(1)?-MVtab0[code].val:MVtab0[code].val);`
415			`}`
416			`#endif /* TRACE */`
417
418			`return Get_Bits1()?-MVtab0[code].val:MVtab0[code].val;`
419			`}`
420
421			`if (code>=24)`
422			`{`
423			`code >>= 3;`
424			`Flush_Buffer(MVtab1[code].len);`
425
426			`#ifdef TRACE`
427			`if (Trace_Flag)`
428			`{`
429			`Print_Bits(code,6,MVtab1[code].len);`
430			`printf("%d): %d\n",`
431			`Show_Bits(1),Show_Bits(1)?-MVtab1[code].val:MVtab1[code].val);`
432			`}`
433			`#endif /* TRACE */`
434
435			`return Get_Bits1()?-MVtab1[code].val:MVtab1[code].val;`
436			`}`
437
438			`if ((code-=12)<0)`
439			`{`
440			`if (!Quiet_Flag)`
441			`/* HACK */`
442			`printf("Invalid motion_vector code (MBA %d, pic %d)\n", global_MBA, global_pic);`
443			`Fault_Flag=1;`
444			`return 0;`
445			`}`
446
447			`Flush_Buffer(MVtab2[code].len);`
448
449			`#ifdef TRACE`
450			`if (Trace_Flag)`
451			`{`
452			`Print_Bits(code+12,9,MVtab2[code].len);`
453			`printf("%d): %d\n",`
454			`Show_Bits(1),Show_Bits(1)?-MVtab2[code].val:MVtab2[code].val);`
455			`}`
456			`#endif /* TRACE */`
457
458			`return Get_Bits1() ? -MVtab2[code].val : MVtab2[code].val;`
459			`}`
460
461			`/* get differential motion vector (for dual prime prediction) */`
462			`int Get_dmvector()`
463			`{`
464			`#ifdef TRACE`
465			`if (Trace_Flag)`
466			`printf("dmvector (");`
467			`#endif /* TRACE */`
468
469			`if (Get_Bits(1))`
470			`{`
471			`#ifdef TRACE`
472			`if (Trace_Flag)`
473			`printf(Show_Bits(1) ? "11): -1\n" : "10): 1\n");`
474			`#endif /* TRACE */`
475			`return Get_Bits(1) ? -1 : 1;`
476			`}`
477			`else`
478			`{`
479			`#ifdef TRACE`
480			`if (Trace_Flag)`
481			`printf("0): 0\n");`
482			`#endif /* TRACE */`
483			`return 0;`
484			`}`
485			`}`
486
487			`int Get_coded_block_pattern()`
488			`{`
489			`int code;`
490
491			`#ifdef TRACE`
492			`if (Trace_Flag)`
493			`printf("coded_block_pattern_420 (");`
494			`#endif /* TRACE */`
495
496			`if ((code = Show_Bits(9))>=128)`
497			`{`
498			`code >>= 4;`
499			`Flush_Buffer(CBPtab0[code].len);`
500
501			`#ifdef TRACE`
502			`if (Trace_Flag)`
503			`{`
504			`Print_Bits(code,5,CBPtab0[code].len);`
505			`printf("): ");`
506			`Print_Bits(CBPtab0[code].val,6,6);`
507			`printf(" (%d)\n",CBPtab0[code].val);`
508			`}`
509			`#endif /* TRACE */`
510
511			`return CBPtab0[code].val;`
512			`}`
513
514			`if (code>=8)`
515			`{`
516			`code >>= 1;`
517			`Flush_Buffer(CBPtab1[code].len);`
518
519			`#ifdef TRACE`
520			`if (Trace_Flag)`
521			`{`
522			`Print_Bits(code,8,CBPtab1[code].len);`
523			`printf("): ");`
524			`Print_Bits(CBPtab1[code].val,6,6);`
525			`printf(" (%d)\n",CBPtab1[code].val);`
526			`}`
527			`#endif /* TRACE */`
528
529			`return CBPtab1[code].val;`
530			`}`
531
532			`if (code<1)`
533			`{`
534			`if (!Quiet_Flag)`
535			`printf("Invalid coded_block_pattern code\n");`
536			`Fault_Flag = 1;`
537			`return 0;`
538			`}`
539
540			`Flush_Buffer(CBPtab2[code].len);`
541
542			`#ifdef TRACE`
543			`if (Trace_Flag)`
544			`{`
545			`Print_Bits(code,9,CBPtab2[code].len);`
546			`printf("): ");`
547			`Print_Bits(CBPtab2[code].val,6,6);`
548			`printf(" (%d)\n",CBPtab2[code].val);`
549			`}`
550			`#endif /* TRACE */`
551
552			`return CBPtab2[code].val;`
553			`}`
554
555			`int Get_macroblock_address_increment()`
556			`{`
557			`int code, val;`
558
559			`#ifdef TRACE`
560			`if (Trace_Flag)`
561			`printf("macroblock_address_increment (");`
562			`#endif /* TRACE */`
563
564			`val = 0;`
565
566			`while ((code = Show_Bits(11))<24)`
567			`{`
568			`if (code!=15) /* if not macroblock_stuffing */`
569			`{`
570			`if (code==8) /* if macroblock_escape */`
571			`{`
572			`#ifdef TRACE`
573			`if (Trace_Flag)`
574			`printf("00000001000 ");`
575			`#endif /* TRACE */`
576
577			`val+= 33;`
578			`}`
579			`else`
580			`{`
581			`if (!Quiet_Flag)`
582			`printf("Invalid macroblock_address_increment code\n");`
583
584			`Fault_Flag = 1;`
585			`return 1;`
586			`}`
587			`}`
588			`else /* macroblock suffing */`
589			`{`
590			`#ifdef TRACE`
591			`if (Trace_Flag)`
592			`printf("00000001111 ");`
593			`#endif /* TRACE */`
594			`}`
595
596			`Flush_Buffer(11);`
597			`}`
598
599			`/* macroblock_address_increment == 1 */`
600			`/* ('1' is in the MSB position of the lookahead) */`
601			`if (code>=1024)`
602			`{`
603			`Flush_Buffer(1);`
604			`#ifdef TRACE`
605			`if (Trace_Flag)`
606			`printf("1): %d\n",val+1);`
607			`#endif /* TRACE */`
608			`return val + 1;`
609			`}`
610
611			`/* codes 00010 ... 011xx */`
612			`if (code>=128)`
613			`{`
614			`/* remove leading zeros */`
615			`code >>= 6;`
616			`Flush_Buffer(MBAtab1[code].len);`
617
618			`#ifdef TRACE`
619			`if (Trace_Flag)`
620			`{`
621			`Print_Bits(code,5,MBAtab1[code].len);`
622			`printf("): %d\n",val+MBAtab1[code].val);`
623			`}`
624			`#endif /* TRACE */`
625
626
627			`return val + MBAtab1[code].val;`
628			`}`
629
630			`/* codes 00000011000 ... 0000111xxxx */`
631			`code-= 24; /* remove common base */`
632			`Flush_Buffer(MBAtab2[code].len);`
633
634			`#ifdef TRACE`
635			`if (Trace_Flag)`
636			`{`
637			`Print_Bits(code+24,11,MBAtab2[code].len);`
638			`printf("): %d\n",val+MBAtab2[code].val);`
639			`}`
640			`#endif /* TRACE */`
641
642			`return val + MBAtab2[code].val;`
643			`}`
644
645			`/* combined MPEG-1 and MPEG-2 stage. parse VLC and`
646			`perform dct_diff arithmetic.`
647
648			`MPEG-1: ISO/IEC 11172-2 section`
649			`MPEG-2: ISO/IEC 13818-2 section 7.2.1`
650
651			`Note: the arithmetic here is presented more elegantly than`
652			`the spec, yet the results, dct_diff, are the same.`
653			`*/`
654
655			`int Get_Luma_DC_dct_diff()`
656			`{`
657			`int code, size, dct_diff;`
658			`#ifdef TRACE`
659			`if (Trace_Flag)`
660			`printf("dct_dc_size_luminance: (");`
661			`#endif /* TRACE */`
662
663			`/* decode length */`
664			`code = Show_Bits(5);`
665
666			`if (code<31)`
667			`{`
668			`size = DClumtab0[code].val;`
669			`Flush_Buffer(DClumtab0[code].len);`
670			`#ifdef TRACE`
671			`if (Trace_Flag)`
672			`{`
673			`Print_Bits(code,5,DClumtab0[code].len);`
674			`printf("): %d",size);`
675			`}`
676			`#endif /* TRACE */`
677			`}`
678			`else`
679			`{`
680			`code = Show_Bits(9) - 0x1f0;`
681			`size = DClumtab1[code].val;`
682			`Flush_Buffer(DClumtab1[code].len);`
683
684			`#ifdef TRACE`
685			`if (Trace_Flag)`
686			`{`
687			`Print_Bits(code+0x1f0,9,DClumtab1[code].len);`
688			`printf("): %d",size);`
689			`}`
690			`#endif /* TRACE */`
691			`}`
692
693			`#ifdef TRACE`
694			`if (Trace_Flag)`
695			`printf(", dct_dc_differential (");`
696			`#endif /* TRACE */`
697
698			`if (size==0)`
699			`dct_diff = 0;`
700			`else`
701			`{`
702			`dct_diff = Get_Bits(size);`
703			`#ifdef TRACE`
704			`if (Trace_Flag)`
705			`Print_Bits(dct_diff,size,size);`
706			`#endif /* TRACE */`
707			`if ((dct_diff & (1<<(size-1)))==0)`
708			`dct_diff-= (1<<size) - 1;`
709			`}`
710
711			`#ifdef TRACE`
712			`if (Trace_Flag)`
713			`printf("): %d\n",dct_diff);`
714			`#endif /* TRACE */`
715
716			`return dct_diff;`
717			`}`
718
719
720			`int Get_Chroma_DC_dct_diff()`
721			`{`
722			`int code, size, dct_diff;`
723
724			`#ifdef TRACE`
725			`if (Trace_Flag)`
726			`printf("dct_dc_size_chrominance: (");`
727			`#endif /* TRACE */`
728
729			`/* decode length */`
730			`code = Show_Bits(5);`
731
732			`if (code<31)`
733			`{`
734			`size = DCchromtab0[code].val;`
735			`Flush_Buffer(DCchromtab0[code].len);`
736
737			`#ifdef TRACE`
738			`if (Trace_Flag)`
739			`{`
740			`Print_Bits(code,5,DCchromtab0[code].len);`
741			`printf("): %d",size);`
742			`}`
743			`#endif /* TRACE */`
744			`}`
745			`else`
746			`{`
747			`code = Show_Bits(10) - 0x3e0;`
748			`size = DCchromtab1[code].val;`
749			`Flush_Buffer(DCchromtab1[code].len);`
750
751			`#ifdef TRACE`
752			`if (Trace_Flag)`
753			`{`
754			`Print_Bits(code+0x3e0,10,DCchromtab1[code].len);`
755			`printf("): %d",size);`
756			`}`
757			`#endif /* TRACE */`
758			`}`
759
760			`#ifdef TRACE`
761			`if (Trace_Flag)`
762			`printf(", dct_dc_differential (");`
763			`#endif /* TRACE */`
764
765			`if (size==0)`
766			`dct_diff = 0;`
767			`else`
768			`{`
769			`dct_diff = Get_Bits(size);`
770			`#ifdef TRACE`
771			`if (Trace_Flag)`
772			`Print_Bits(dct_diff,size,size);`
773			`#endif /* TRACE */`
774			`if ((dct_diff & (1<<(size-1)))==0)`
775			`dct_diff-= (1<<size) - 1;`
776			`}`
777
778			`#ifdef TRACE`
779			`if (Trace_Flag)`
780			`printf("): %d\n",dct_diff);`
781			`#endif /* TRACE */`
782
783			`return dct_diff;`
784			`}`