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

Subversion Repositories mpeg2fpga

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 kdv
/* 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
  ld->Rdptr = ld->Rdbfr;
68
 
69
  if (System_Stream_Flag)
70
    ld->Rdmax -= 2048;
71
 
72
 
73
  /* end of the bitstream file */
74
  if (Buffer_Level < 2048)
75
  {
76
    /* just to be safe */
77
    if (Buffer_Level < 0)
78
      Buffer_Level = 0;
79
 
80
    /* pad until the next to the next 32-bit word boundary */
81
    while (Buffer_Level & 3)
82
      ld->Rdbfr[Buffer_Level++] = 0;
83
 
84
        /* pad the buffer with sequence end codes */
85
    while (Buffer_Level < 2048)
86
    {
87
      ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>24;
88
      ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>16;
89
      ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE>>8;
90
      ld->Rdbfr[Buffer_Level++] = SEQUENCE_END_CODE&0xff;
91
    }
92
  }
93
}
94
 
95
 
96
/* MPEG-1 system layer demultiplexer */
97
 
98
int Get_Byte()
99
{
100
  while(ld->Rdptr >= ld->Rdbfr+2048)
101
  {
102
    read(ld->Infile,ld->Rdbfr,2048);
103
    ld->Rdptr -= 2048;
104
    ld->Rdmax -= 2048;
105
  }
106
  return *ld->Rdptr++;
107
}
108
 
109
/* extract a 16-bit word from the bitstream buffer */
110
int Get_Word()
111
{
112
  int Val;
113
 
114
  Val = Get_Byte();
115
  return (Val<<8) | Get_Byte();
116
}
117
 
118
 
119
/* return next n bits (right adjusted) without advancing */
120
 
121
unsigned int Show_Bits(N)
122
int N;
123
{
124
  return ld->Bfr >> (32-N);
125
}
126
 
127
 
128
/* return next bit (could be made faster than Get_Bits(1)) */
129
 
130
unsigned int Get_Bits1()
131
{
132
  return Get_Bits(1);
133
}
134
 
135
 
136
/* advance by n bits */
137
 
138
void Flush_Buffer(N)
139
int N;
140
{
141
  int Incnt;
142
 
143
  ld->Bfr <<= N;
144
 
145
  Incnt = ld->Incnt -= N;
146
 
147
  if (Incnt <= 24)
148
  {
149
    if (System_Stream_Flag && (ld->Rdptr >= ld->Rdmax-4))
150
    {
151
      do
152
      {
153
        if (ld->Rdptr >= ld->Rdmax)
154
          Next_Packet();
155
        ld->Bfr |= Get_Byte() << (24 - Incnt);
156
        Incnt += 8;
157
      }
158
      while (Incnt <= 24);
159
    }
160
    else if (ld->Rdptr < ld->Rdbfr+2044)
161
    {
162
      do
163
      {
164
        ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
165
        Incnt += 8;
166
      }
167
      while (Incnt <= 24);
168
    }
169
    else
170
    {
171
      do
172
      {
173
        if (ld->Rdptr >= ld->Rdbfr+2048)
174
          Fill_Buffer();
175
        ld->Bfr |= *ld->Rdptr++ << (24 - Incnt);
176
        Incnt += 8;
177
      }
178
      while (Incnt <= 24);
179
    }
180
    ld->Incnt = Incnt;
181
  }
182
 
183
#ifdef VERIFY 
184
  ld->Bitcnt += N;
185
#endif /* VERIFY */
186
 
187
}
188
 
189
 
190
/* return next n bits (right adjusted) */
191
 
192
unsigned int Get_Bits(N)
193
int N;
194
{
195
  unsigned int Val;
196
 
197
  Val = Show_Bits(N);
198
  Flush_Buffer(N);
199
 
200
  return Val;
201
}
202
 

powered by: WebSVN 2.1.0

© copyright 1999-2019 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.