]> Creatis software - gdcm.git/blob - src/gdcmmpeg2/src/mpeg2dec/getbits.c
Fix mistypings
[gdcm.git] / 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