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 <stdio.h>
  36 #include <stdlib.h>
  37
  38 #include "config.h"
  39 #include "global.h"
  40
  41 /* initialize buffer, call once before first getbits or showbits */
  42
  43 void Initialize_Buffer()
  44 {
  45   ld->Incnt = 0;
  46   ld->Rdptr = ld->Rdbfr + 2048;
  47   ld->Rdmax = ld->Rdptr;
  48
  49 #ifdef VERIFY
  50   /*  only the verifier uses this particular bit counter
  51    *  Bitcnt keeps track of the current parser position with respect
  52    *  to the video elementary stream being decoded, regardless
  53    *  of whether or not it is wrapped within a systems layer stream
  54    */
  55   ld->Bitcnt = 0;
  56 #endif
  57
  58   ld->Bfr = 0;
  59   Flush_Buffer(0); /* fills valid data into bfr */
  60 }
  61
  62 void Fill_Buffer()
  63 {
  64   int Buffer_Level;
  65
  66   /*Buffer_Level = read(ld->Infile,ld->Rdbfr,2048);*/
  67   Buffer_Level = ld->read_stream(ld->Infile,ld->Rdbfr,2048);
  68   ld->Rdptr = ld->Rdbfr;
  69
  70   if (System_Stream_Flag)
  71     ld->Rdmax -= 2048;
  72
  73
  74   /* end of the bitstream file */
  75   if (Buffer_Level < 2048)
  76   {
  77     /* just to be safe */
  78     if (Buffer_Level < 0)
  79       Buffer_Level = 0;
  80
  81     /* pad until the next to the next 32-bit word boundary */
  82     while (Buffer_Level & 3)
  83       ld->Rdbfr[Buffer_Level++] = 0;
  84
  85     /* pad the buffer with sequence end codes */
  86     while (Buffer_Level < 2048)
  87     {
  88       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>24;
  89       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>16;
  90       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>8;
  91       ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE&0xff;
  92     }
  93   }
  94 }
  95
  96
  97 /* MPEG-1 system layer demultiplexer */
  98
  99 int Get_Byte()
 100 {
 101   while(ld->Rdptr >= ld->Rdbfr+2048)
 102   {
 103     /*read(ld->Infile,ld->Rdbfr,2048);*/
 104     ld->read_stream(ld->Infile,ld->Rdbfr,2048);
 105     ld->Rdptr -= 2048;
 106     ld->Rdmax -= 2048;
 107   }
 108   return *ld->Rdptr++;
 109 }
 110
 111 /* extract a 16-bit word from the bitstream buffer */
 112 int Get_Word()
 113 {
 114   int Val;
 115
 116   Val = Get_Byte();
 117   return (Val<<8) | Get_Byte();
 118 }
 119
 120
 121 /* return next n bits (right adjusted) without advancing */
 122
 123 unsigned int Show_Bits(N)
 124 int N;
 125 {
 126   return ld->Bfr >> (32-N);
 127 }
 128
 129
 130 /* return next bit (could be made faster than Get_Bits(1)) */
 131
 132 unsigned int Get_Bits1()
 133 {
 134   return Get_Bits(1);
 135 }
 136
 137
 138 /* advance by n bits */
 139
 140 void Flush_Buffer(N)
 141 int N;
 142 {
 143   int Incnt;
 144
 145   ld->Bfr <<= N;
 146
 147   Incnt = ld->Incnt -= N;
 148
 149   if (Incnt <= 24)
 150   {
 151     if (System_Stream_Flag && (ld->Rdptr >= ld->Rdmax-4))
 152     {
 153       do
 154       {
 155         if (ld->Rdptr >= ld->Rdmax)
 156           Next_Packet();
 157         ld->Bfr |= Get_Byte() << (24 - Incnt);
 158         Incnt += 8;
 159       }
 160       while (Incnt <= 24);
 161     }
 162     else if (ld->Rdptr < ld->Rdbfr+2044)
 163     {
 164       do
 165       {
 166         ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
 167         Incnt += 8;
 168       }
 169       while (Incnt <= 24);
 170     }
 171     else
 172     {
 173       do
 174       {
 175         if (ld->Rdptr >= ld->Rdbfr+2048)
 176           Fill_Buffer();
 177         ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
 178         Incnt += 8;
 179       }
 180       while (Incnt <= 24);
 181     }
 182     ld->Incnt = Incnt;
 183   }
 184
 185 #ifdef VERIFY
 186   ld->Bitcnt += N;
 187 #endif /* VERIFY */
 188
 189 }
 190
 191
 192 /* return next n bits (right adjusted) */
 193
 194 unsigned int Get_Bits(N)
 195 int N;
 196 {
 197   unsigned int Val;
 198
 199   Val = Show_Bits(N);
 200   Flush_Buffer(N);
 201
 202   return Val;
 203 }
 204