src/gdcmmpeg2/src/mpeg2dec/getbits.c

   1 /* getbits.c, bit level routines                                            */
   2
   3 /*
   4  * All modifications (mpeg2decode -> mpeg2play) are
   5  * Copyright (C) 1996, Stefan Eckart. All Rights Reserved.
   6  */
   7
   8 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
   9
  10 /*
  11  * Disclaimer of Warranty
  12  *
  13  * These software programs are available to the user without any license fee or
  14  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  15  * any and all warranties, whether express, implied, or statuary, including any
  16  * implied warranties or merchantability or of fitness for a particular
  17  * purpose.  In no event shall the copyright-holder be liable for any
  18  * incidental, punitive, or consequential damages of any kind whatsoever
  19  * arising from the use of these programs.
  20  *
  21  * This disclaimer of warranty extends to the user of these programs and user's
  22  * customers, employees, agents, transferees, successors, and assigns.
  23  *
  24  * The MPEG Software Simulation Group does not represent or warrant that the
  25  * programs furnished hereunder are free of infringement of any third-party
  26  * patents.
  27  *
  28  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  29  * are subject to royalty fees to patent holders.  Many of these patents are
  30  * general enough such that they are unavoidable regardless of implementation
  31  * design.
  32  *
  33  */
  34
  35 #include "config.h"
  36 #include "global.h"
  37
  38 /* initialize buffer, call once before first getbits or showbits */
  39
  40 void Initialize_Buffer()
  41 {
  42   ld->Incnt = 0;
  43   ld->Rdptr = ld->Rdbfr + 2048;
  44   ld->Rdmax = ld->Rdptr;
  45
  46 #ifdef VERIFY
  47   /*  only the verifier uses this particular bit counter
  48    *  Bitcnt keeps track of the current parser position with respect
  49    *  to the video elementary stream being decoded, regardless
  50    *  of whether or not it is wrapped within a systems layer stream
  51    */
  52   ld->Bitcnt = 0;
  53 #endif
  54
  55   ld->Bfr = 0;
  56   Flush_Buffer(0); /* fills valid data into bfr */
  57 }
  58
  59 void Fill_Buffer()
  60 {
  61   int Buffer_Level;
  62
  63   Buffer_Level = ld->read_stream(ld->Infile,ld->Rdbfr,2048);
  64   ld->Rdptr = ld->Rdbfr;
  65
  66   if (System_Stream_Flag)
  67     ld->Rdmax -= 2048;
  68
  69
  70   /* end of the bitstream file */
  71   if (Buffer_Level < 2048)
  72   {
  73     /* just to be safe */
  74     if (Buffer_Level < 0)
  75       Buffer_Level = 0;
  76
  77     /* pad until the next to the next 32-bit word boundary */
  78     while (Buffer_Level & 3)
  79       ld->Rdbfr[Buffer_Level++] = 0;
  80
  81     /* pad the buffer with sequence end codes */
  82     while (Buffer_Level < 2048)
  83     {
  84       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>24;
  85       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>16;
  86       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>8;
  87       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE&0xff;
  88     }
  89   }
  90 }
  91
  92
  93 /* MPEG-1 system layer demultiplexer */
  94
  95 int Get_Byte()
  96 {
  97   while(ld->Rdptr >= ld->Rdbfr+2048)
  98   {
  99     ld->read_stream(ld->Infile,ld->Rdbfr,2048);
 100     ld->Rdptr -= 2048;
 101     ld->Rdmax -= 2048;
 102   }
 103   return *ld->Rdptr++;
 104 }
 105
 106 /* extract a 16-bit word from the bitstream buffer */
 107 int Get_Word()
 108 {
 109   int Val;
 110
 111   Val = Get_Byte();
 112   return (Val<<8) | Get_Byte();
 113 }
 114
 115
 116 /* return next n bits (right adjusted) without advancing */
 117
 118 unsigned int Show_Bits(N)
 119 int N;
 120 {
 121   return ld->Bfr >> (32-N);
 122 }
 123
 124
 125 /* return next bit (could be made faster than Get_Bits(1)) */
 126
 127 unsigned int Get_Bits1()
 128 {
 129   return Get_Bits(1);
 130 }
 131
 132
 133 /* advance by n bits */
 134
 135 void Flush_Buffer(N)
 136 int N;
 137 {
 138   int Incnt;
 139
 140   ld->Bfr <<= N;
 141
 142   Incnt = ld->Incnt -= N;
 143
 144   if (Incnt <= 24)
 145   {
 146     if (System_Stream_Flag && (ld->Rdptr >= ld->Rdmax-4))
 147     {
 148       do
 149       {
 150         if (ld->Rdptr >= ld->Rdmax)
 151           Next_Packet();
 152         ld->Bfr |= Get_Byte() << (24 - Incnt);
 153         Incnt += 8;
 154       }
 155       while (Incnt <= 24);
 156     }
 157     else if (ld->Rdptr < ld->Rdbfr+2044)
 158     {
 159       do
 160       {
 161         ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
 162         Incnt += 8;
 163       }
 164       while (Incnt <= 24);
 165     }
 166     else
 167     {
 168       do
 169       {
 170         if (ld->Rdptr >= ld->Rdbfr+2048)
 171           Fill_Buffer();
 172         ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
 173         Incnt += 8;
 174       }
 175       while (Incnt <= 24);
 176     }
 177     ld->Incnt = Incnt;
 178   }
 179
 180 #ifdef VERIFY
 181   ld->Bitcnt += N;
 182 #endif /* VERIFY */
 183
 184 }
 185
 186
 187 /* return next n bits (right adjusted) */
 188
 189 unsigned int Get_Bits(N)
 190 int N;
 191 {
 192   unsigned int Val;
 193
 194   Val = Show_Bits(N);
 195   Flush_Buffer(N);
 196
 197   return Val;
 198 }
 199