URL https://opencores.org/ocsvn/mb-jpeg/mb-jpeg/trunk

Subversion Repositories mb-jpeg

[/] [mb-jpeg/] [tags/] [arelease/] [decoder/] [PARSE.C] - Blame information for rev 66

Details | Compare with Previous | View Log


/*-----------------------------------------*/
/* File : parse.c, utilities for jfif view */
/* Author : Pierre Guerrier, march 1998    */
/*-----------------------------------------*/
 
#include 
#include 
#include 
 
 
 
/*---------------------------------------------------------------------*/
 
 
/* utility and counter to return the number of bits from file */
/* right aligned, masked, first bit towards MSB's               */
 
static unsigned char bit_count; /* available bits in the window */
static unsigned char window;
 
unsigned long
get_bits(FILE *fi, int number)
{
  int i, newbit;
  unsigned long result = 0;
  unsigned char aux, wwindow;
 
  if (!number)
    return 0;
 
  for (i = 0; i < number; i++) {
    if (bit_count == 0) {
      wwindow = fgetc(fi);
 
      if (wwindow == 0xFF)
        switch (aux = fgetc(fi)) {      /* skip stuffer 0 byte */
        case EOF:
        case 0xFF:
          fprintf(stderr, "%ld:\tERROR:\tRan out of bit stream\n", ftell(fi));
          aborted_stream(fi);
          break;
 
        case 0x00:
          stuffers++;
          break;
 
        default:
          if (RST_MK(0xFF00 | aux))
            fprintf(stderr, "%ld:\tERROR:\tSpontaneously found restart!\n",
                    ftell(fi));
          fprintf(stderr, "%ld:\tERROR:\tLost sync in bit stream\n",
                  ftell(fi));
          aborted_stream(fi);
          break;
        }
 
      bit_count = 8;
    }
    else wwindow = window;
    newbit = (wwindow>>7) & 1;
    window = wwindow << 1;
    bit_count--;
    result = (result << 1) | newbit;
  }
  return result;
}
 
 
void
clear_bits(void)
{
  bit_count = 0;
}
 
 
unsigned char
get_one_bit(FILE *fi)
{
  int newbit;
  unsigned char aux, wwindow;
 
  if (bit_count == 0) {
    wwindow = fgetc(fi);
 
    if (wwindow == 0xFF)
      switch (aux = fgetc(fi)) {        /* skip stuffer 0 byte */
      case EOF:
      case 0xFF:
        fprintf(stderr, "%ld:\tERROR:\tRan out of bit stream\n", ftell(fi));
        aborted_stream(fi);
        break;
 
      case 0x00:
        stuffers++;
        break;
 
      default:
        if (RST_MK(0xFF00 | aux))
          fprintf(stderr, "%ld:\tERROR:\tSpontaneously found restart!\n",
                  ftell(fi));
        fprintf(stderr, "%ld:\tERROR:\tLost sync in bit stream\n",
                ftell(fi));
        aborted_stream(fi);
        break;
      }
 
    bit_count = 8;
  }
  else
    wwindow = window;
 
  newbit = (wwindow >> 7) & 1;
  window = wwindow << 1;
  bit_count--;
  return newbit;
}
 
/*----------------------------------------------------------*/
 
 
unsigned int
get_size(FILE *fi)
{
  unsigned char aux;
 
  aux = fgetc(fi);
  return (aux << 8) | fgetc(fi);        /* big endian */
}
 
 
/*----------------------------------------------------------*/
 
 
void
skip_segment(FILE *fi)  /* skip a segment we don't want */
{
  unsigned int size;
  char  tag[5];
  int i;
 
  size = get_size(fi);
  if (size > 5) {
    for (i = 0; i < 4; i++)
      tag[i] = fgetc(fi);
    tag[4] = '\0';
    if (verbose)
      fprintf(stderr, "\tINFO:\tTag is %s\n", tag);
    size -= 4;
  }
  fseek(fi, size-2, SEEK_CUR);
}
 
 
/*----------------------------------------------------------------*/
/* find next marker of any type, returns it, positions just after */
/* EOF instead of marker if end of file met while searching ...   */
/*----------------------------------------------------------------*/
 
unsigned int
get_next_MK(FILE *fi)
{
  unsigned int c;
  int ffmet = 0;
  int locpassed = -1;
 
  passed--;     /* as we fetch one anyway */
 
  while ((c = fgetc(fi)) != (unsigned int) EOF) {
    switch (c) {
    case 0xFF:
      ffmet = 1;
      break;
    case 0x00:
      ffmet = 0;
      break;
    default:
      if (locpassed > 1)
        fprintf(stderr, "NOTE: passed %d bytes\n", locpassed);
      if (ffmet)
        return (0xFF00 | c);
      ffmet = 0;
      break;
    }
    locpassed++;
    passed++;
  }
 
  return (unsigned int) EOF;
}
 
 
/*----------------------------------------------------------*/
/* loading and allocating of quantization table             */
/* table elements are in ZZ order (same as unpack output)   */
/*----------------------------------------------------------*/
 
int
load_quant_tables(FILE *fi)
{
  char aux;
  unsigned int size, n, i, id, x;
 
  size = get_size(fi); /* this is the tables' size */
  n = (size - 2) / 65;
 
  for (i = 0; i < n; i++) {
    aux = fgetc(fi);
    if (first_quad(aux) > 0) {
      fprintf(stderr, "\tERROR:\tBad QTable precision!\n");
      return -1;
    }
    id = second_quad(aux);
    if (verbose)
      fprintf(stderr, "\tINFO:\tLoading table %d\n", id);
    QTable[id] = (PBlock *) malloc(sizeof(PBlock));
    if (QTable[id] == NULL) {
      fprintf(stderr, "\tERROR:\tCould not allocate table storage!\n");
      exit(1);
    }
    QTvalid[id] = 1;
    for (x = 0; x < 64; x++)
      QTable[id]->linear[x] = fgetc(fi);
      /*
         -- This is useful to print out the table content --
         for (x = 0; x < 64; x++)
         fprintf(stderr, "%d\n", QTable[id]->linear[x]);
      */
  }
  return 0;
}
 
 
/*----------------------------------------------------------*/
/* initialise MCU block descriptors                         */
/*----------------------------------------------------------*/
 
int
init_MCU(void)
{
  int i, j, k, n, hmax = 0, vmax = 0;
 
  for (i = 0; i < 10; i++)
    MCU_valid[i] = -1;
 
  k = 0;
 
  for (i = 0; i < n_comp; i++) {
    if (comp[i].HS > hmax)
      hmax = comp[i].HS;
    if (comp[i].VS > vmax)
      vmax = comp[i].VS;
    n = comp[i].HS * comp[i].VS;
 
    comp[i].IDX = k;
    for (j = 0; j < n; j++) {
      MCU_valid[k] = i;
      MCU_buff[k] = (PBlock *) malloc(sizeof(PBlock));
      if (MCU_buff[k] == NULL) {
        fprintf(stderr, "\tERROR:\tCould not allocate MCU buffers!\n");
        exit(1);
      }
      k++;
      if (k == 10) {
        fprintf(stderr, "\tERROR:\tMax subsampling exceeded!\n");
        return -1;
      }
    }
  }
 
  MCU_sx = 8 * hmax;
  MCU_sy = 8 * vmax;
  for (i = 0; i < n_comp; i++) {
    comp[i].HDIV = (hmax / comp[i].HS > 1);     /* if 1 shift by 0 */
    comp[i].VDIV = (vmax / comp[i].VS > 1);     /* if 2 shift by one */
  }
 
  mx_size = ceil_div(x_size,MCU_sx);
  my_size = ceil_div(y_size,MCU_sy);
  rx_size = MCU_sx * floor_div(x_size,MCU_sx);
  ry_size = MCU_sy * floor_div(y_size,MCU_sy);
 
  return 0;
}
 
 
/*----------------------------------------------------------*/
/* this takes care for processing all the blocks in one MCU */
/*----------------------------------------------------------*/
 
int
process_MCU(FILE *fi)
{
  int  i;
  long offset;
  int  goodrows, goodcolumns;
 
  if (MCU_column == mx_size) {
    MCU_column = 0;
    MCU_row++;
    if (MCU_row == my_size) {
      in_frame = 0;
      return 0;
    }
    if (verbose)
      fprintf(stderr, "%ld:\tINFO:\tProcessing stripe %d/%d\n", ftell(fi),
              MCU_row+1, my_size);
  }
 
  for (curcomp = 0; MCU_valid[curcomp] != -1; curcomp++) {
    unpack_block(fi, FBuff, MCU_valid[curcomp]); /* pass index to HT,QT,pred */
    IDCT(FBuff, MCU_buff[curcomp]);
  }
 
  /* YCrCb to RGB color space transform here */
  if (n_comp > 1)
    color_conversion();
  else
    memmove(ColorBuffer, MCU_buff[0], 64);
 
  /* cut last row/column as needed */
  if ((y_size != ry_size) && (MCU_row == (my_size - 1)))
    goodrows = y_size - ry_size;
  else
    goodrows = MCU_sy;
 
  if ((x_size != rx_size) && (MCU_column == (mx_size - 1)))
    goodcolumns = x_size - rx_size;
  else
    goodcolumns = MCU_sx;
 
  offset = n_comp * (MCU_row * MCU_sy * x_size + MCU_column * MCU_sx);
 
  for (i = 0; i < goodrows; i++)
    memmove(FrameBuffer + offset + n_comp * i * x_size,
            ColorBuffer + n_comp * i * MCU_sx,
            n_comp * goodcolumns);
 
  MCU_column++;
  return 1;
}

Browse

Tools

Subversion Repositories mb-jpeg

[/] [mb-jpeg/] [tags/] [arelease/] [decoder/] [PARSE.C] - Blame information for rev 66

Line No.	Rev	Author	Line
1	2	quickwayne	`/-----------------------------------------/`
2			`/* File : parse.c, utilities for jfif view */`
3			`/* Author : Pierre Guerrier, march 1998 */`
4			`/-----------------------------------------/`
5
6			`#include`
7			`#include`
8			`#include`
9
10
11
12			`/---------------------------------------------------------------------/`
13
14
15			`/* utility and counter to return the number of bits from file */`
16			`/* right aligned, masked, first bit towards MSB's */`
17
18			`static unsigned char bit_count; /* available bits in the window */`
19			`static unsigned char window;`
20
21			`unsigned long`
22			`get_bits(FILE *fi, int number)`
23			`{`
24			`int i, newbit;`
25			`unsigned long result = 0;`
26			`unsigned char aux, wwindow;`
27
28			`if (!number)`
29			`return 0;`
30
31			`for (i = 0; i < number; i++) {`
32			`if (bit_count == 0) {`
33			`wwindow = fgetc(fi);`
34
35			`if (wwindow == 0xFF)`
36			`switch (aux = fgetc(fi)) { /* skip stuffer 0 byte */`
37			`case EOF:`
38			`case 0xFF:`
39			`fprintf(stderr, "%ld:\tERROR:\tRan out of bit stream\n", ftell(fi));`
40			`aborted_stream(fi);`
41			`break;`
42
43			`case 0x00:`
44			`stuffers++;`
45			`break;`
46
47			`default:`
48			`if (RST_MK(0xFF00 \| aux))`
49			`fprintf(stderr, "%ld:\tERROR:\tSpontaneously found restart!\n",`
50			`ftell(fi));`
51			`fprintf(stderr, "%ld:\tERROR:\tLost sync in bit stream\n",`
52			`ftell(fi));`
53			`aborted_stream(fi);`
54			`break;`
55			`}`
56
57			`bit_count = 8;`
58			`}`
59			`else wwindow = window;`
60			`newbit = (wwindow>>7) & 1;`
61			`window = wwindow << 1;`
62			`bit_count--;`
63			`result = (result << 1) \| newbit;`
64			`}`
65			`return result;`
66			`}`
67
68
69			`void`
70			`clear_bits(void)`
71			`{`
72			`bit_count = 0;`
73			`}`
74
75
76			`unsigned char`
77			`get_one_bit(FILE *fi)`
78			`{`
79			`int newbit;`
80			`unsigned char aux, wwindow;`
81
82			`if (bit_count == 0) {`
83			`wwindow = fgetc(fi);`
84
85			`if (wwindow == 0xFF)`
86			`switch (aux = fgetc(fi)) { /* skip stuffer 0 byte */`
87			`case EOF:`
88			`case 0xFF:`
89			`fprintf(stderr, "%ld:\tERROR:\tRan out of bit stream\n", ftell(fi));`
90			`aborted_stream(fi);`
91			`break;`
92
93			`case 0x00:`
94			`stuffers++;`
95			`break;`
96
97			`default:`
98			`if (RST_MK(0xFF00 \| aux))`
99			`fprintf(stderr, "%ld:\tERROR:\tSpontaneously found restart!\n",`
100			`ftell(fi));`
101			`fprintf(stderr, "%ld:\tERROR:\tLost sync in bit stream\n",`
102			`ftell(fi));`
103			`aborted_stream(fi);`
104			`break;`
105			`}`
106
107			`bit_count = 8;`
108			`}`
109			`else`
110			`wwindow = window;`
111
112			`newbit = (wwindow >> 7) & 1;`
113			`window = wwindow << 1;`
114			`bit_count--;`
115			`return newbit;`
116			`}`
117
118			`/----------------------------------------------------------/`
119
120
121			`unsigned int`
122			`get_size(FILE *fi)`
123			`{`
124			`unsigned char aux;`
125
126			`aux = fgetc(fi);`
127			`return (aux << 8) \| fgetc(fi); /* big endian */`
128			`}`
129
130
131			`/----------------------------------------------------------/`
132
133
134			`void`
135			`skip_segment(FILE fi) / skip a segment we don't want */`
136			`{`
137			`unsigned int size;`
138			`char tag[5];`
139			`int i;`
140
141			`size = get_size(fi);`
142			`if (size > 5) {`
143			`for (i = 0; i < 4; i++)`
144			`tag[i] = fgetc(fi);`
145			`tag[4] = '\0';`
146			`if (verbose)`
147			`fprintf(stderr, "\tINFO:\tTag is %s\n", tag);`
148			`size -= 4;`
149			`}`
150			`fseek(fi, size-2, SEEK_CUR);`
151			`}`
152
153
154			`/----------------------------------------------------------------/`
155			`/* find next marker of any type, returns it, positions just after */`
156			`/* EOF instead of marker if end of file met while searching ... */`
157			`/----------------------------------------------------------------/`
158
159			`unsigned int`
160			`get_next_MK(FILE *fi)`
161			`{`
162			`unsigned int c;`
163			`int ffmet = 0;`
164			`int locpassed = -1;`
165
166			`passed--; /* as we fetch one anyway */`
167
168			`while ((c = fgetc(fi)) != (unsigned int) EOF) {`
169			`switch (c) {`
170			`case 0xFF:`
171			`ffmet = 1;`
172			`break;`
173			`case 0x00:`
174			`ffmet = 0;`
175			`break;`
176			`default:`
177			`if (locpassed > 1)`
178			`fprintf(stderr, "NOTE: passed %d bytes\n", locpassed);`
179			`if (ffmet)`
180			`return (0xFF00 \| c);`
181			`ffmet = 0;`
182			`break;`
183			`}`
184			`locpassed++;`
185			`passed++;`
186			`}`
187
188			`return (unsigned int) EOF;`
189			`}`
190
191
192			`/----------------------------------------------------------/`
193			`/* loading and allocating of quantization table */`
194			`/* table elements are in ZZ order (same as unpack output) */`
195			`/----------------------------------------------------------/`
196
197			`int`
198			`load_quant_tables(FILE *fi)`
199			`{`
200			`char aux;`
201			`unsigned int size, n, i, id, x;`
202
203			`size = get_size(fi); /* this is the tables' size */`
204			`n = (size - 2) / 65;`
205
206			`for (i = 0; i < n; i++) {`
207			`aux = fgetc(fi);`
208			`if (first_quad(aux) > 0) {`
209			`fprintf(stderr, "\tERROR:\tBad QTable precision!\n");`
210			`return -1;`
211			`}`
212			`id = second_quad(aux);`
213			`if (verbose)`
214			`fprintf(stderr, "\tINFO:\tLoading table %d\n", id);`
215			`QTable[id] = (PBlock *) malloc(sizeof(PBlock));`
216			`if (QTable[id] == NULL) {`
217			`fprintf(stderr, "\tERROR:\tCould not allocate table storage!\n");`
218			`exit(1);`
219			`}`
220			`QTvalid[id] = 1;`
221			`for (x = 0; x < 64; x++)`
222			`QTable[id]->linear[x] = fgetc(fi);`
223			`/*`
224			`-- This is useful to print out the table content --`
225			`for (x = 0; x < 64; x++)`
226			`fprintf(stderr, "%d\n", QTable[id]->linear[x]);`
227			`*/`
228			`}`
229			`return 0;`
230			`}`
231
232
233			`/----------------------------------------------------------/`
234			`/* initialise MCU block descriptors */`
235			`/----------------------------------------------------------/`
236
237			`int`
238			`init_MCU(void)`
239			`{`
240			`int i, j, k, n, hmax = 0, vmax = 0;`
241
242			`for (i = 0; i < 10; i++)`
243			`MCU_valid[i] = -1;`
244
245			`k = 0;`
246
247			`for (i = 0; i < n_comp; i++) {`
248			`if (comp[i].HS > hmax)`
249			`hmax = comp[i].HS;`
250			`if (comp[i].VS > vmax)`
251			`vmax = comp[i].VS;`
252			`n = comp[i].HS * comp[i].VS;`
253
254			`comp[i].IDX = k;`
255			`for (j = 0; j < n; j++) {`
256			`MCU_valid[k] = i;`
257			`MCU_buff[k] = (PBlock *) malloc(sizeof(PBlock));`
258			`if (MCU_buff[k] == NULL) {`
259			`fprintf(stderr, "\tERROR:\tCould not allocate MCU buffers!\n");`
260			`exit(1);`
261			`}`
262			`k++;`
263			`if (k == 10) {`
264			`fprintf(stderr, "\tERROR:\tMax subsampling exceeded!\n");`
265			`return -1;`
266			`}`
267			`}`
268			`}`
269
270			`MCU_sx = 8 * hmax;`
271			`MCU_sy = 8 * vmax;`
272			`for (i = 0; i < n_comp; i++) {`
273			`comp[i].HDIV = (hmax / comp[i].HS > 1); /* if 1 shift by 0 */`
274			`comp[i].VDIV = (vmax / comp[i].VS > 1); /* if 2 shift by one */`
275			`}`
276
277			`mx_size = ceil_div(x_size,MCU_sx);`
278			`my_size = ceil_div(y_size,MCU_sy);`
279			`rx_size = MCU_sx * floor_div(x_size,MCU_sx);`
280			`ry_size = MCU_sy * floor_div(y_size,MCU_sy);`
281
282			`return 0;`
283			`}`
284
285
286			`/----------------------------------------------------------/`
287			`/* this takes care for processing all the blocks in one MCU */`
288			`/----------------------------------------------------------/`
289
290			`int`
291			`process_MCU(FILE *fi)`
292			`{`
293			`int i;`
294			`long offset;`
295			`int goodrows, goodcolumns;`
296
297			`if (MCU_column == mx_size) {`
298			`MCU_column = 0;`
299			`MCU_row++;`
300			`if (MCU_row == my_size) {`
301			`in_frame = 0;`
302			`return 0;`
303			`}`
304			`if (verbose)`
305			`fprintf(stderr, "%ld:\tINFO:\tProcessing stripe %d/%d\n", ftell(fi),`
306			`MCU_row+1, my_size);`
307			`}`
308
309			`for (curcomp = 0; MCU_valid[curcomp] != -1; curcomp++) {`
310			`unpack_block(fi, FBuff, MCU_valid[curcomp]); /* pass index to HT,QT,pred */`
311			`IDCT(FBuff, MCU_buff[curcomp]);`
312			`}`
313
314			`/* YCrCb to RGB color space transform here */`
315			`if (n_comp > 1)`
316			`color_conversion();`
317			`else`
318			`memmove(ColorBuffer, MCU_buff[0], 64);`
319
320			`/* cut last row/column as needed */`
321			`if ((y_size != ry_size) && (MCU_row == (my_size - 1)))`
322			`goodrows = y_size - ry_size;`
323			`else`
324			`goodrows = MCU_sy;`
325
326			`if ((x_size != rx_size) && (MCU_column == (mx_size - 1)))`
327			`goodcolumns = x_size - rx_size;`
328			`else`
329			`goodcolumns = MCU_sx;`
330
331			`offset = n_comp * (MCU_row * MCU_sy * x_size + MCU_column * MCU_sx);`
332
333			`for (i = 0; i < goodrows; i++)`
334			`memmove(FrameBuffer + offset + n_comp * i * x_size,`
335			`ColorBuffer + n_comp * i * MCU_sx,`
336			`n_comp * goodcolumns);`
337
338			`MCU_column++;`
339			`return 1;`
340			`}`