[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [PATCH] jpeg image reader
|
From: |
Bean |
|
Subject: |
Re: [PATCH] jpeg image reader |
|
Date: |
Tue, 15 Jan 2008 00:36:26 +0800 |
On Jan 14, 2008 2:31 AM, Marco Gerards <address@hidden> wrote:
> > /*
> > * GRUB -- GRand Unified Bootloader
> > * Copyright (C) 2008 Free Software Foundation, Inc.
>
> Did you write all the code yourself?
yes, but i take some code segment from Independent JPEG Group's
implementation, such as idct transformation and ycrcb -> rgb
conversion.
> > static grub_uint8_t
> > get_byte (struct grub_jpeg_data *data)
>
> How about jpeg_get_byte or so? Or even add grub_. I have the feeling
> this will clash someday.
done.
> > id = get_byte (data);
> > ac = (id >> 4);
> > id &= 0xF;
> > if (id > 1)
> > {
> > grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: too many huffman table");
> > grub_longjmp (data->jumper, 1);
> > }
>
> How many are normally supported? Max 4, IIRC?
yes, 2 dc and 2 ac table.
> > n = 0;
> > for (i = 0; i < 16; i++)
> > n += count[i];
>
> What does this do?
it sums up the number of huff codes of length 1 to 16.
> > ss = get_byte (data);
> > if (!id)
> > {
> > data->vs = ss & 0xF;
> > data->hs = ss >> 4;
>
> What's ss, vs, hs?
ss is sampling factor, vs is vertical sampling, hs is horizontal
sampling, i add comment in the source.
please remind me if something is left out.
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/bitmap.h>
#include <grub/types.h>
#include <grub/normal.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/arg.h>
#include <grub/file.h>
/* Uncomment following define to enable JPEG debug. */
//#define JPEG_DEBUG
#define JPEG_ESC_CHAR 0xFF
#define JPEG_SAMPLING_1x1 0x11
typedef enum
{ /* JPEG marker codes */
M_SOF0 = 0xc0,
M_SOF1 = 0xc1,
M_SOF2 = 0xc2,
M_SOF3 = 0xc3,
M_SOF5 = 0xc5,
M_SOF6 = 0xc6,
M_SOF7 = 0xc7,
M_JPG = 0xc8,
M_SOF9 = 0xc9,
M_SOF10 = 0xca,
M_SOF11 = 0xcb,
M_SOF13 = 0xcd,
M_SOF14 = 0xce,
M_SOF15 = 0xcf,
M_DHT = 0xc4,
M_DAC = 0xcc,
M_RST0 = 0xd0,
M_RST1 = 0xd1,
M_RST2 = 0xd2,
M_RST3 = 0xd3,
M_RST4 = 0xd4,
M_RST5 = 0xd5,
M_RST6 = 0xd6,
M_RST7 = 0xd7,
M_SOI = 0xd8,
M_EOI = 0xd9,
M_SOS = 0xda,
M_DQT = 0xdb,
M_DNL = 0xdc,
M_DRI = 0xdd,
M_DHP = 0xde,
M_EXP = 0xdf,
M_APP0 = 0xe0,
M_APP1 = 0xe1,
M_APP2 = 0xe2,
M_APP3 = 0xe3,
M_APP4 = 0xe4,
M_APP5 = 0xe5,
M_APP6 = 0xe6,
M_APP7 = 0xe7,
M_APP8 = 0xe8,
M_APP9 = 0xe9,
M_APP10 = 0xea,
M_APP11 = 0xeb,
M_APP12 = 0xec,
M_APP13 = 0xed,
M_APP14 = 0xee,
M_APP15 = 0xef,
M_JPG0 = 0xf0,
M_JPG13 = 0xfd,
M_COM = 0xfe,
M_TEM = 0x01,
M_ERROR = 0x100
} jpeg_marker_t;
typedef int jpeg_data_unit_t[64];
struct grub_jpeg_data
{
grub_file_t file;
struct grub_video_bitmap **bitmap;
int image_width;
int image_height;
grub_uint8_t *huff_value[4];
int huff_offset[4][16];
int huff_maxval[4][16];
grub_uint8_t quan_table[2][64];
int comp_index[3][3];
jpeg_data_unit_t ydu[4];
jpeg_data_unit_t crdu;
jpeg_data_unit_t cbdu;
int crr_tab[256], cbb_tab[256], crg_tab[256], cbg_tab[256];
int vs, hs;
int dc_value[3];
int bit_mask, bit_save;
};
static grub_uint8_t
grub_jpeg_get_byte (struct grub_jpeg_data *data)
{
grub_uint8_t r;
r = 0;
grub_file_read (data->file, (char *) &r, 1);
return r;
}
static grub_uint16_t
grub_jpeg_get_word (struct grub_jpeg_data *data)
{
grub_uint16_t r;
r = 0;
grub_file_read (data->file, (char *) &r, sizeof (grub_uint16_t));
return grub_be_to_cpu16 (r);
}
static int
grub_jpeg_get_bit (struct grub_jpeg_data *data)
{
int ret;
if (data->bit_mask == 0)
{
data->bit_save = grub_jpeg_get_byte (data);
if (data->bit_save == JPEG_ESC_CHAR)
{
if (grub_jpeg_get_byte (data) != 0)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: invalid 0xFF in data stream");
return 0;
}
}
data->bit_mask = 0x80;
}
ret = ((data->bit_save & data->bit_mask) != 0);
data->bit_mask >>= 1;
return ret;
}
static int
grub_jpeg_get_number (struct grub_jpeg_data *data, int num)
{
int value, i, msb;
if (num == 0)
return 0;
msb = value = grub_jpeg_get_bit (data);
for (i = 1; i < num; i++)
value = (value << 1) + (grub_jpeg_get_bit (data) != 0);
if (!msb)
value += 1 - (1 << num);
return value;
}
static int
grub_jpeg_get_huff_code (struct grub_jpeg_data *data, int id)
{
int code, i;
code = 0;
for (i = 0; i < 16; i++)
{
code <<= 1;
if (grub_jpeg_get_bit (data))
code++;
if (code < data->huff_maxval[id][i])
return data->huff_value[id][code + data->huff_offset[id][i]];
}
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: huffman decode fails");
return 0;
}
static grub_err_t
grub_jpeg_decode_huff_table (struct grub_jpeg_data *data)
{
int id, ac, i, n, base, ofs;
grub_uint32_t next_marker;
grub_uint8_t count[16];
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
id = grub_jpeg_get_byte (data);
ac = (id >> 4);
id &= 0xF;
if (id > 1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: too many huffman tables");
if (grub_file_read (data->file, (char *) &count, sizeof (count)) !=
sizeof (count))
return grub_errno;
n = 0;
for (i = 0; i < 16; i++)
n += count[i];
id += ac * 2;
data->huff_value[id] = grub_malloc (n);
if (grub_errno)
return grub_errno;
if (grub_file_read (data->file, (char *) data->huff_value[id], n) != n)
return grub_errno;
base = 0;
ofs = 0;
for (i = 0; i < 16; i++)
{
base += count[i];
ofs += count[i];
data->huff_maxval[id][i] = base;
data->huff_offset[id][i] = ofs - base;
base <<= 1;
}
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in huffman table");
return grub_errno;
}
static grub_err_t
grub_jpeg_decode_quan_table (struct grub_jpeg_data *data)
{
int id;
grub_uint32_t next_marker;
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
id = grub_jpeg_get_byte (data);
if (id >= 0x10) /* upper 4-bit is precision */
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: only 8-bit precision is supported");
if (id > 1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: too many quantization tables");
if (grub_file_read (data->file, (char *) &data->quan_table[id], 64) != 64)
return grub_errno;
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: extra byte in quantization table");
return grub_errno;
}
static grub_err_t
grub_jpeg_decode_sof (struct grub_jpeg_data *data)
{
int i, cc;
grub_uint32_t next_marker;
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
if (grub_jpeg_get_byte (data) != 8)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: only 8-bit precision is supported");
data->image_height = grub_jpeg_get_word (data);
data->image_width = grub_jpeg_get_word (data);
if ((!data->image_height) || (!data->image_width))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid image size");
cc = grub_jpeg_get_byte (data);
if (cc != 3)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: component count must be 3");
for (i = 0; i < cc; i++)
{
int id, ss;
id = grub_jpeg_get_byte (data) - 1;
if ((id < 0) || (id >= 3))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
ss = grub_jpeg_get_byte (data); /* sampling factor */
if (!id)
{
data->vs = ss & 0xF; /* vertical sampling */
data->hs = ss >> 4; /* horizontal sampling */
if ((data->vs > 2) || (data->hs > 2))
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: sampling method nor supported");
}
else if (ss != JPEG_SAMPLING_1x1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: sampling method nor supported");
data->comp_index[id][0] = grub_jpeg_get_byte (data);
}
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sof");
return grub_errno;
}
#define DCTSIZE 8
#define CONST_BITS 8
#define PASS1_BITS 2
#define AANSCONST_BITS 14
#define IFAST_SCALE_BITS 2
#define FIX_1_082392200 ((int) 277) /* FIX(1.082392200) */
#define FIX_1_414213562 ((int) 362) /* FIX(1.414213562) */
#define FIX_1_847759065 ((int) 473) /* FIX(1.847759065) */
#define FIX_2_613125930 ((int) 669) /* FIX(2.613125930) */
#define ONE ((long) 1)
#define DESCALE(x,n) (((x) + (ONE << ((n)-1))) >> (n))
#define MULTIPLY(var,const) DESCALE((var) * (const), CONST_BITS)
static const grub_uint8_t natural_order[64] = {
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34,
27, 20, 13, 6, 7, 14, 21, 28,
35, 42, 49, 56, 57, 50, 43, 36,
29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46,
53, 60, 61, 54, 47, 55, 62, 63
};
static const int aanscales[64] = {
/* precomputed values scaled up by 14 bits */
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
};
static void
grub_jpeg_idct_transform (jpeg_data_unit_t du)
{
int *pd;
int ctr;
int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
int tmp10, tmp11, tmp12, tmp13;
int z5, z10, z11, z12, z13;
/* Pass 1: process columns from input, store into work array. */
pd = du;
for (ctr = DCTSIZE; ctr > 0; ctr--)
{
if ((pd[DCTSIZE * 1] | pd[DCTSIZE * 2] | pd[DCTSIZE * 3] |
pd[DCTSIZE * 4] | pd[DCTSIZE * 5] | pd[DCTSIZE * 6] |
pd[DCTSIZE * 7]) == 0)
{
pd[DCTSIZE * 1] = pd[DCTSIZE * 2]
= pd[DCTSIZE * 3] = pd[DCTSIZE * 4]
= pd[DCTSIZE * 5] = pd[DCTSIZE * 6]
= pd[DCTSIZE * 7] = pd[DCTSIZE * 0];
pd++; /* advance pointers to next column */
continue;
}
/* Even part */
tmp0 = pd[DCTSIZE * 0];
tmp1 = pd[DCTSIZE * 2];
tmp2 = pd[DCTSIZE * 4];
tmp3 = pd[DCTSIZE * 6];
tmp10 = tmp0 + tmp2; /* phase 3 */
tmp11 = tmp0 - tmp2;
tmp13 = tmp1 + tmp3; /* phases 5-3 */
tmp12 = MULTIPLY (tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
tmp0 = tmp10 + tmp13; /* phase 2 */
tmp3 = tmp10 - tmp13;
tmp1 = tmp11 + tmp12;
tmp2 = tmp11 - tmp12;
/* Odd part */
tmp4 = pd[DCTSIZE * 1];
tmp5 = pd[DCTSIZE * 3];
tmp6 = pd[DCTSIZE * 5];
tmp7 = pd[DCTSIZE * 7];
z13 = tmp6 + tmp5; /* phase 6 */
z10 = tmp6 - tmp5;
z11 = tmp4 + tmp7;
z12 = tmp4 - tmp7;
tmp7 = z11 + z13; /* phase 5 */
tmp11 = MULTIPLY (z11 - z13, FIX_1_414213562); /* 2*c4 */
z5 = MULTIPLY (z10 + z12, FIX_1_847759065); /* 2*c2 */
tmp10 = MULTIPLY (z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
tmp12 = MULTIPLY (z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
tmp6 = tmp12 - tmp7; /* phase 2 */
tmp5 = tmp11 - tmp6;
tmp4 = tmp10 + tmp5;
pd[DCTSIZE * 0] = (int) (tmp0 + tmp7);
pd[DCTSIZE * 7] = (int) (tmp0 - tmp7);
pd[DCTSIZE * 1] = (int) (tmp1 + tmp6);
pd[DCTSIZE * 6] = (int) (tmp1 - tmp6);
pd[DCTSIZE * 2] = (int) (tmp2 + tmp5);
pd[DCTSIZE * 5] = (int) (tmp2 - tmp5);
pd[DCTSIZE * 4] = (int) (tmp3 + tmp4);
pd[DCTSIZE * 3] = (int) (tmp3 - tmp4);
pd++; /* advance pointers to next column */
}
/* Pass 2: process rows from work array, store into output array. */
/* Note that we must descale the results by a factor of 8 == 2**3, */
/* and also undo the PASS1_BITS scaling. */
pd = du;
for (ctr = 0; ctr < DCTSIZE; ctr++)
{
/* Even part */
tmp10 = pd[0] + pd[4];
tmp11 = pd[0] - pd[4];
tmp13 = pd[2] + pd[6];
tmp12 = MULTIPLY (pd[2] - pd[6], FIX_1_414213562) - tmp13;
tmp0 = tmp10 + tmp13;
tmp3 = tmp10 - tmp13;
tmp1 = tmp11 + tmp12;
tmp2 = tmp11 - tmp12;
/* Odd part */
z13 = pd[5] + pd[3];
z10 = pd[5] - pd[3];
z11 = pd[1] + pd[7];
z12 = pd[1] - pd[7];
tmp7 = z11 + z13; /* phase 5 */
tmp11 = MULTIPLY (z11 - z13, FIX_1_414213562); /* 2*c4 */
z5 = MULTIPLY (z10 + z12, FIX_1_847759065); /* 2*c2 */
tmp10 = MULTIPLY (z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
tmp12 = MULTIPLY (z10, -FIX_2_613125930) + z5; /* -2*(c2+c6) */
tmp6 = tmp12 - tmp7; /* phase 2 */
tmp5 = tmp11 - tmp6;
tmp4 = tmp10 + tmp5;
/* Final output stage: scale down by a factor of 8 and range-limit */
pd[0] = DESCALE (tmp0 + tmp7, PASS1_BITS + 3) + 128;
pd[7] = DESCALE (tmp0 - tmp7, PASS1_BITS + 3) + 128;
pd[1] = DESCALE (tmp1 + tmp6, PASS1_BITS + 3) + 128;
pd[6] = DESCALE (tmp1 - tmp6, PASS1_BITS + 3) + 128;
pd[2] = DESCALE (tmp2 + tmp5, PASS1_BITS + 3) + 128;
pd[5] = DESCALE (tmp2 - tmp5, PASS1_BITS + 3) + 128;
pd[4] = DESCALE (tmp3 + tmp4, PASS1_BITS + 3) + 128;
pd[3] = DESCALE (tmp3 - tmp4, PASS1_BITS + 3) + 128;
pd += DCTSIZE; /* advance pointer to next row */
}
for (ctr = 0; ctr < 64; ctr++)
{
if (du[ctr] < 0)
du[ctr] = 0;
if (du[ctr] > 255)
du[ctr] = 255;
}
}
static void
grub_jpeg_decode_du (struct grub_jpeg_data *data, int id, jpeg_data_unit_t du)
{
int pos, h1, h2, qt;
grub_memset (du, 0, sizeof (jpeg_data_unit_t));
qt = data->comp_index[id][0];
h1 = data->comp_index[id][1];
h2 = data->comp_index[id][2];
data->dc_value[id] +=
grub_jpeg_get_number (data, grub_jpeg_get_huff_code (data, h1));
du[0] =
data->dc_value[id] * DESCALE ((int) data->quan_table[qt][0] *
(int) aanscales[0],
AANSCONST_BITS - IFAST_SCALE_BITS);
pos = 1;
while (pos < 64)
{
int num, val;
num = grub_jpeg_get_huff_code (data, h2);
if (!num)
break;
val = grub_jpeg_get_number (data, num & 0xF);
num >>= 4;
pos += num;
du[natural_order[pos]] =
val * DESCALE ((int) data->quan_table[qt][pos] *
(int) aanscales[natural_order[pos]], 14 - 2);
pos++;
}
grub_jpeg_idct_transform (du);
}
#define SCALEBITS 16 /* speediest right-shift on some machines */
#define ONE_HALF ((int) 1 << (SCALEBITS-1))
#define FIX(x) ((int) ((x) * (1L<<SCALEBITS) + 0.5))
static void
grub_jpeg_build_color_table (struct grub_jpeg_data *data)
{
int i, x;
for (i = 0, x = -128; i <= 255; i++, x++)
{
data->crr_tab[i] = (int) (FIX (1.40200) * x + ONE_HALF) >> SCALEBITS;
data->cbb_tab[i] = (int) (FIX (1.77200) * x + ONE_HALF) >> SCALEBITS;
data->crg_tab[i] = (-FIX (0.71414)) * x;
data->cbg_tab[i] = (-FIX (0.34414)) * x + ONE_HALF;
}
}
static void
grub_jpeg_ycrcb_to_rgb (struct grub_jpeg_data *data, int yy, int cr, int cb,
grub_uint8_t * rgb)
{
int dd;
/* Red */
dd = yy + data->crr_tab[cr];
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
/* Green */
dd = yy + ((data->cbg_tab[cb] + data->crg_tab[cr]) >> SCALEBITS);
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
/* Blue */
dd = yy + data->cbb_tab[cb];
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
}
static grub_err_t
grub_jpeg_decode_sos (struct grub_jpeg_data *data)
{
int i, cc, r1, c1, nr1, nc1, vb, hb;
grub_uint8_t *ptr1;
grub_uint32_t data_offset;
data_offset = data->file->offset;
data_offset += grub_jpeg_get_word (data);
cc = grub_jpeg_get_byte (data);
if (cc != 3)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: component count must be 3");
for (i = 0; i < cc; i++)
{
int id, ht;
id = grub_jpeg_get_byte (data) - 1;
if ((id < 0) || (id >= 3))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
ht = grub_jpeg_get_byte (data);
data->comp_index[id][1] = (ht >> 4);
data->comp_index[id][2] = (ht & 0xF) + 2;
}
grub_jpeg_get_byte (data); /* skip 3 unused bytes */
grub_jpeg_get_word (data);
if (data->file->offset != data_offset)
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sos");
if (grub_video_bitmap_create (data->bitmap, data->image_width,
data->image_height,
GRUB_VIDEO_BLIT_FORMAT_R8G8B8))
return grub_errno;
data->bit_mask = 0x0;
vb = data->vs * 8;
hb = data->hs * 8;
nr1 = (data->image_height + vb - 1) / vb;
nc1 = (data->image_width + hb - 1) / hb;
ptr1 = (*data->bitmap)->data;
for (r1 = 0; r1 < nr1;
r1++, ptr1 += (vb * data->image_width - hb * nc1) * 3)
for (c1 = 0; c1 < nc1; c1++, ptr1 += hb * 3)
{
int r2, c2, nr2, nc2;
grub_uint8_t *ptr2;
for (r2 = 0; r2 < data->vs; r2++)
for (c2 = 0; c2 < data->hs; c2++)
grub_jpeg_decode_du (data, 0, data->ydu[r2 * 2 + c2]);
grub_jpeg_decode_du (data, 1, data->cbdu);
grub_jpeg_decode_du (data, 2, data->crdu);
if (grub_errno)
return grub_errno;
nr2 = (r1 == nr1 - 1) ? (data->image_height - r1 * vb) : vb;
nc2 = (c1 == nc1 - 1) ? (data->image_width - c1 * hb) : hb;
ptr2 = ptr1;
for (r2 = 0; r2 < nr2; r2++, ptr2 += (data->image_width - nc2) * 3)
for (c2 = 0; c2 < nc2; c2++, ptr2 += 3)
{
int i0, yy, cr, cb;
i0 = (r2 / data->vs) * 8 + (c2 / data->hs);
cr = data->crdu[i0];
cb = data->cbdu[i0];
yy =
data->ydu[(r2 / 8) * 2 + (c2 / 8)][(r2 % 8) * 8 + (c2 % 8)];
grub_jpeg_ycrcb_to_rgb (data, yy, cr, cb, ptr2);
}
}
return grub_errno;
}
static grub_uint8_t
grub_jpeg_get_marker (struct grub_jpeg_data *data)
{
grub_uint8_t r;
r = grub_jpeg_get_byte (data);
if (r != JPEG_ESC_CHAR)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid maker");
return 0;
}
return grub_jpeg_get_byte (data);
}
static grub_err_t
grub_jpeg_decode_jpeg (struct grub_jpeg_data *data)
{
grub_jpeg_build_color_table (data);
if (grub_jpeg_get_marker (data) != M_SOI) /* Start Of Image */
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid jpeg file");
while (grub_errno == 0)
{
grub_uint8_t marker;
marker = grub_jpeg_get_marker (data);
if (grub_errno)
break;
#ifdef JPEG_DEBUG
grub_printf ("jpeg marker: %x\n", marker);
#endif
switch (marker)
{
case M_DHT: /* Define Huffman Table */
grub_jpeg_decode_huff_table (data);
break;
case M_DQT: /* Define Quantization Table */
grub_jpeg_decode_quan_table (data);
break;
case M_SOF0: /* Start Of Frame 0 */
grub_jpeg_decode_sof (data);
break;
case M_SOS: /* Start Of Scan */
grub_jpeg_decode_sos (data);
break;
case M_EOI: /* End Of Image */
return grub_errno;
default: /* Skip unrecognized marker */
{
grub_uint16_t sz;
sz = grub_jpeg_get_word (data);
if (grub_errno)
return (grub_errno);
grub_file_seek (data->file, data->file->offset + sz - 2);
}
}
}
return grub_errno;
}
static grub_err_t
grub_video_reader_jpeg (struct grub_video_bitmap **bitmap,
const char *filename)
{
grub_file_t file;
struct grub_jpeg_data *data;
file = grub_file_open (filename);
if (!file)
return grub_errno;
data = grub_malloc (sizeof (*data));
if (data != NULL)
{
int i;
grub_memset (data, 0, sizeof (*data));
data->file = file;
data->bitmap = bitmap;
grub_jpeg_decode_jpeg (data);
for (i = 0; i < 4; i++)
if (data->huff_value[i])
grub_free (data->huff_value[i]);
grub_free (data);
}
if (grub_errno != GRUB_ERR_NONE)
{
grub_video_bitmap_destroy (*bitmap);
*bitmap = 0;
}
grub_file_close (file);
return grub_errno;
}
#if defined(JPEG_DEBUG)
static grub_err_t
grub_cmd_jpegtest (struct grub_arg_list *state __attribute__ ((unused)),
int argc, char **args)
{
struct grub_video_bitmap *bitmap = 0;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
grub_video_reader_jpeg (&bitmap, args[0]);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
grub_video_bitmap_destroy (bitmap);
return GRUB_ERR_NONE;
}
#endif
static struct grub_video_bitmap_reader jpg_reader = {
.extension = ".jpg",
.reader = grub_video_reader_jpeg,
.next = 0
};
static struct grub_video_bitmap_reader jpeg_reader = {
.extension = ".jpeg",
.reader = grub_video_reader_jpeg,
.next = 0
};
GRUB_MOD_INIT (video_reader_jpeg)
{
grub_video_bitmap_reader_register (&jpg_reader);
grub_video_bitmap_reader_register (&jpeg_reader);
#if defined(JPEG_DEBUG)
grub_register_command ("jpegtest", grub_cmd_jpegtest,
GRUB_COMMAND_FLAG_BOTH, "jpegtest FILE",
"Tests loading of JPEG bitmap.", 0);
#endif
}
GRUB_MOD_FINI (video_reader_jpeg)
{
#if defined(JPEG_DEBUG)
grub_unregister_command ("jpegtest");
#endif
grub_video_bitmap_reader_unregister (&jpeg_reader);
grub_video_bitmap_reader_unregister (&jpg_reader);
}
--
Bean
- [PATCH] jpeg image reader, Bean, 2008/01/09
- Re: [PATCH] jpeg image reader, Bean, 2008/01/09
- Re: [PATCH] jpeg image reader, Vesa Jääskeläinen, 2008/01/09
- Re: [PATCH] jpeg image reader, Bean, 2008/01/10
- Re: [PATCH] jpeg image reader, Bean, 2008/01/12
- Re: [PATCH] jpeg image reader, Bean, 2008/01/13
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/13
- Re: [PATCH] jpeg image reader,
Bean <=
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/15
- Re: [PATCH] jpeg image reader, Robert Millan, 2008/01/15
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/15
- Re: [PATCH] jpeg image reader, Robert Millan, 2008/01/15
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/15
- Re: [PATCH] jpeg image reader, Bean, 2008/01/15
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/15
- Re: [PATCH] jpeg image reader, Bean, 2008/01/15
- Re: [PATCH] jpeg image reader, Marco Gerards, 2008/01/15
- Re: [PATCH] jpeg image reader, Bean, 2008/01/15