getvlc.c

linux下的一款mpeg播放器

/* getvlc.c, variable length decoding                                       */

/* Copyright (C) 1994, 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 */
static int getIMBtype _ANSI_ARGS_((void));
static int getPMBtype _ANSI_ARGS_((void));
static int getBMBtype _ANSI_ARGS_((void));
static int getDMBtype _ANSI_ARGS_((void));
static int getspIMBtype _ANSI_ARGS_((void));
static int getspPMBtype _ANSI_ARGS_((void));
static int getspBMBtype _ANSI_ARGS_((void));
static int getSNRMBtype _ANSI_ARGS_((void));

int getMBtype()
{
  int mb_type;

  if (ld->scalable_mode==SC_SNR)
    mb_type = getSNRMBtype();
  else
  {
    switch (pict_type)
    {
    case I_TYPE:
      mb_type = ld->pict_scal ? getspIMBtype() : getIMBtype();
      break;
    case P_TYPE:
      mb_type = ld->pict_scal ? getspPMBtype() : getPMBtype();
      break;
    case B_TYPE:
      mb_type = ld->pict_scal ? getspBMBtype() : getBMBtype();
      break;
    case D_TYPE:
      /* MPEG-1 only, not implemented */
      mb_type = getDMBtype();
      break;
    }
  }

  return mb_type;
}

static int getIMBtype()
{
#ifdef TRACE
  if (trace)
    printf("mb_type(I) ");
#endif

  if (getbits1())
  {
#ifdef TRACE
    if (trace)
      printf("(1): Intra (1)\n");
#endif
    return 1;
  }

  if (!getbits1())
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
  }

#ifdef TRACE
  if (trace)
    printf("(01): Intra, Quant (17)\n");
#endif

  return 17;
}

#ifdef TRACE
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", ""
};
#endif

static int getPMBtype()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("mb_type(P) (");
#endif

  if ((code = showbits(6))>=8)
  {
    code >>= 3;
    flushbits(PMBtab0[code].len);
#ifdef TRACE
    if (trace)
    {
      printbits(code,3,PMBtab0[code].len);
      printf("): %s (%d)\n",MBdescr[PMBtab0[code].val],PMBtab0[code].val);
    }
#endif
    return PMBtab0[code].val;
  }

  if (code==0)
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

  flushbits(PMBtab1[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code,6,PMBtab1[code].len);
    printf("): %s (%d)\n",MBdescr[PMBtab1[code].val],PMBtab1[code].val);
  }
#endif

  return PMBtab1[code].val;
}

static int getBMBtype()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("mb_type(B) (");
#endif

  if ((code = showbits(6))>=8)
  {
    code >>= 2;
    flushbits(BMBtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,4,BMBtab0[code].len);
      printf("): %s (%d)\n",MBdescr[BMBtab0[code].val],BMBtab0[code].val);
    }
#endif

    return BMBtab0[code].val;
  }

  if (code==0)
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

  flushbits(BMBtab1[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code,6,BMBtab1[code].len);
    printf("): %s (%d)\n",MBdescr[BMBtab1[code].val],BMBtab1[code].val);
  }
#endif

  return BMBtab1[code].val;
}

static int getDMBtype()
{
  if (!getbits1())
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault=1;
  }

  return 1;
}

/* macroblock_type for pictures with spatial scalability */
static int getspIMBtype()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("mb_type(I,spat) (");
#endif

  code = showbits(4);

  if (code==0)
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

#ifdef TRACE
  if (trace)
  {
    printbits(code,4,spIMBtab[code].len);
    printf("): %02x\n",spIMBtab[code].val);
  }
#endif

  flushbits(spIMBtab[code].len);
  return spIMBtab[code].val;
}

static int getspPMBtype()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("mb_type(P,spat) (");
#endif

  code = showbits(7);

  if (code<2)
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

  if (code>=16)
  {
    code >>= 3;
    flushbits(spPMBtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,4,spPMBtab0[code].len);
      printf("): %02x\n",spPMBtab0[code].val);
    }
#endif

    return spPMBtab0[code].val;
  }

  flushbits(spPMBtab1[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code,7,spPMBtab1[code].len);
    printf("): %02x\n",spPMBtab1[code].val);
  }
#endif

  return spPMBtab1[code].val;
}

static int getspBMBtype()
{
  int code;
  VLCtab *p;

#ifdef TRACE
  if (trace)
    printf("mb_type(B,spat) (");
#endif

  code = showbits(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)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

  flushbits(p->len);

#ifdef TRACE
  if (trace)
  {
    printbits(code,9,p->len);
    printf("): %02x\n",p->val);
  }
#endif

  return p->val;
}

static int getSNRMBtype()
{
  int code;

  code = showbits(3);

  if (code==0)
  {
    if (!quiet)
      fprintf(stderr,"Invalid macroblock_type code\n");
    fault = 1;
    return 0;
  }

  flushbits(SNRMBtab[code].len);
  return SNRMBtab[code].val;
}

int getMV()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("motion_code (");
#endif

  if (getbits1())
  {
#ifdef TRACE
    if (trace)
      printf("0): 0\n");
#endif
    return 0;
  }

  if ((code = showbits(9))>=64)
  {
    code >>= 6;
    flushbits(MVtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,3,MVtab0[code].len);
      printf("%d): %d\n",
        showbits(1),showbits(1)?-MVtab0[code].val:MVtab0[code].val);
    }
#endif

    return getbits1()?-MVtab0[code].val:MVtab0[code].val;
  }

  if (code>=24)
  {
    code >>= 3;
    flushbits(MVtab1[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,6,MVtab1[code].len);
      printf("%d): %d\n",
        showbits(1),showbits(1)?-MVtab1[code].val:MVtab1[code].val);
    }
#endif

    return getbits1()?-MVtab1[code].val:MVtab1[code].val;
  }

  if ((code-=12)<0)
  {
    if (!quiet)
      fprintf(stderr,"Invalid motion_vector code\n");
    fault=1;
    return 0;
  }

  flushbits(MVtab2[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code+12,9,MVtab2[code].len);
    printf("%d): %d\n",
      showbits(1),showbits(1)?-MVtab2[code].val:MVtab2[code].val);
  }
#endif

  return getbits1() ? -MVtab2[code].val : MVtab2[code].val;
}

/* get differential motion vector (for dual prime prediction) */
int getDMV()
{
#ifdef TRACE
  if (trace)
    printf("dmvector (");
#endif

  if (getbits(1))
  {
#ifdef TRACE
    if (trace)
      printf(showbits(1) ? "11): -1\n" : "10): 1\n");
#endif
    return getbits(1) ? -1 : 1;
  }
  else
  {
#ifdef TRACE
    if (trace)
      printf("0): 0\n");
#endif
    return 0;
  }
}

int getCBP()
{
  int code;

#ifdef TRACE
  if (trace)
    printf("coded_block_pattern_420 (");
#endif

  if ((code = showbits(9))>=128)
  {
    code >>= 4;
    flushbits(CBPtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,5,CBPtab0[code].len);
      printf("): ");
      printbits(CBPtab0[code].val,6,6);
      printf(" (%d)\n",CBPtab0[code].val);
    }
#endif

    return CBPtab0[code].val;
  }

  if (code>=8)
  {
    code >>= 1;
    flushbits(CBPtab1[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,8,CBPtab1[code].len);
      printf("): ");
      printbits(CBPtab1[code].val,6,6);
      printf(" (%d)\n",CBPtab1[code].val);
    }
#endif

    return CBPtab1[code].val;
  }

  if (code<1)
  {
    if (!quiet)
      fprintf(stderr,"Invalid coded_block_pattern code\n");
    fault = 1;
    return 0;
  }

  flushbits(CBPtab2[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code,9,CBPtab2[code].len);
    printf("): ");
    printbits(CBPtab2[code].val,6,6);
    printf(" (%d)\n",CBPtab2[code].val);
  }
#endif

  return CBPtab2[code].val;
}

int getMBA()
{
  int code, val;

#ifdef TRACE
  if (trace)
    printf("macroblock_address_increment (");
#endif

  val = 0;

  while ((code = showbits(11))<24)
  {
    if (code!=15) /* if not macroblock_stuffing */
    {
      if (code==8) /* if macroblock_escape */
      {
#ifdef TRACE
        if (trace)
          printf("00000001000 ");
#endif

        val+= 33;
      }
      else
      {
        if (!quiet)
          fprintf(stderr,"Invalid macroblock_address_increment code\n");

        fault = 1;
        return 1;
      }
    }
#ifdef TRACE
    else if (trace)
      printf("00000001111 ");
#endif

    flushbits(11);
  }

  if (code>=1024)
  {
    flushbits(1);
#ifdef TRACE
    if (trace)
      printf("1): %d\n",val+1);
#endif
    return val + 1;
  }

  if (code>=128)
  {
    code >>= 6;
    flushbits(MBAtab1[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,5,MBAtab1[code].len);
      printf("): %d\n",val+MBAtab1[code].val);
    }
#endif

    return val + MBAtab1[code].val;
  }

  code-= 24;
  flushbits(MBAtab2[code].len);

#ifdef TRACE
  if (trace)
  {
    printbits(code+24,11,MBAtab2[code].len);
    printf("): %d\n",val+MBAtab2[code].val);
  }
#endif

  return val + MBAtab2[code].val;
}

int getDClum()
{
  int code, size, val;

#ifdef TRACE
  if (trace)
    printf("dct_dc_size_luminance: (");
#endif

  /* decode length */
  code = showbits(5);

  if (code<31)
  {
    size = DClumtab0[code].val;
    flushbits(DClumtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,5,DClumtab0[code].len);
      printf("): %d",size);
    }
#endif
  }
  else
  {
    code = showbits(9) - 0x1f0;
    size = DClumtab1[code].val;
    flushbits(DClumtab1[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code+0x1f0,9,DClumtab1[code].len);
      printf("): %d",size);
    }
#endif
  }

#ifdef TRACE
  if (trace)
    printf(", dct_dc_differential (");
#endif

  if (size==0)
    val = 0;
  else
  {
    val = getbits(size);
#ifdef TRACE
    if (trace)
      printbits(val,size,size);
#endif
    if ((val & (1<<(size-1)))==0)
      val-= (1<<size) - 1;
  }

#ifdef TRACE
  if (trace)
    printf("): %d\n",val);
#endif

  return val;
}

int getDCchrom()
{
  int code, size, val;

#ifdef TRACE
  if (trace)
    printf("dct_dc_size_chrominance: (");
#endif

  /* decode length */
  code = showbits(5);

  if (code<31)
  {
    size = DCchromtab0[code].val;
    flushbits(DCchromtab0[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code,5,DCchromtab0[code].len);
      printf("): %d",size);
    }
#endif
  }
  else
  {
    code = showbits(10) - 0x3e0;
    size = DCchromtab1[code].val;
    flushbits(DCchromtab1[code].len);

#ifdef TRACE
    if (trace)
    {
      printbits(code+0x3e0,10,DCchromtab1[code].len);
      printf("): %d",size);
    }
#endif
  }

#ifdef TRACE
  if (trace)
    printf(", dct_dc_differential (");
#endif

  if (size==0)
    val = 0;
  else
  {
    val = getbits(size);
#ifdef TRACE
    if (trace)
      printbits(val,size,size);
#endif
    if ((val & (1<<(size-1)))==0)
      val-= (1<<size) - 1;
  }

#ifdef TRACE
  if (trace)
    printf("): %d\n",val);
#endif

  return val;
}