2008-01-22 Bean <bean123ch@gmail.com>
* conf/i386-pc.rmk (pkglib_MODULES): Add `jpeg.mod'.
(jpeg_mod_SOURCES): New variable.
(jpeg_mod_CFLAGS): Likewise.
(jpeg_mod_LDFLAGS): Likewise.
* video/readers/jpeg.c : New file.
This commit is contained in:
bean
parent
44023a2816
commit
34842f2d6b
4 changed files with 816 additions and 2 deletions
|
|
@ -1,3 +1,12 @@
|
|||
2008-01-22 Bean <bean123ch@gmail.com>
|
||||
|
||||
* conf/i386-pc.rmk (pkglib_MODULES): Add `jpeg.mod'.
|
||||
(jpeg_mod_SOURCES): New variable.
|
||||
(jpeg_mod_CFLAGS): Likewise.
|
||||
(jpeg_mod_LDFLAGS): Likewise.
|
||||
|
||||
* video/readers/jpeg.c : New file.
|
||||
|
||||
2008-01-22 Bean <bean123ch@gmail.com>
|
||||
|
||||
* fs/cpio.c (grub_cpio_find_file): Return GRUB_ERR_FILE_NOT_FOUND when
|
||||
|
|
|
|||
|
|
@ -918,7 +918,7 @@ pkglib_MODULES = biosdisk.mod _chain.mod _linux.mod linux.mod normal.mod \
|
|||
_multiboot.mod chain.mod multiboot.mod reboot.mod halt.mod \
|
||||
vbe.mod vbetest.mod vbeinfo.mod video.mod gfxterm.mod \
|
||||
videotest.mod play.mod bitmap.mod tga.mod cpuid.mod serial.mod \
|
||||
ata.mod vga.mod memdisk.mod
|
||||
ata.mod vga.mod memdisk.mod jpeg.mod
|
||||
|
||||
# For biosdisk.mod.
|
||||
biosdisk_mod_SOURCES = disk/i386/pc/biosdisk.c
|
||||
|
|
@ -2479,4 +2479,56 @@ fs-memdisk_mod-disk_memdisk.lst: disk/memdisk.c genfslist.sh
|
|||
memdisk_mod_CFLAGS = $(COMMON_CFLAGS)
|
||||
memdisk_mod_LDFLAGS = $(COMMON_LDFLAGS)
|
||||
|
||||
# For jpeg.mod.
|
||||
jpeg_mod_SOURCES = video/readers/jpeg.c
|
||||
CLEANFILES += jpeg.mod mod-jpeg.o mod-jpeg.c pre-jpeg.o jpeg_mod-video_readers_jpeg.o und-jpeg.lst
|
||||
ifneq ($(jpeg_mod_EXPORTS),no)
|
||||
CLEANFILES += def-jpeg.lst
|
||||
DEFSYMFILES += def-jpeg.lst
|
||||
endif
|
||||
MOSTLYCLEANFILES += jpeg_mod-video_readers_jpeg.d
|
||||
UNDSYMFILES += und-jpeg.lst
|
||||
|
||||
jpeg.mod: pre-jpeg.o mod-jpeg.o
|
||||
-rm -f $@
|
||||
$(TARGET_CC) $(jpeg_mod_LDFLAGS) $(TARGET_LDFLAGS) -Wl,-r,-d -o $@ $^
|
||||
$(STRIP) --strip-unneeded -K grub_mod_init -K grub_mod_fini -R .note -R .comment $@
|
||||
|
||||
pre-jpeg.o: $(jpeg_mod_DEPENDENCIES) jpeg_mod-video_readers_jpeg.o
|
||||
-rm -f $@
|
||||
$(TARGET_CC) $(jpeg_mod_LDFLAGS) $(TARGET_LDFLAGS) -Wl,-r,-d -o $@ jpeg_mod-video_readers_jpeg.o
|
||||
|
||||
mod-jpeg.o: mod-jpeg.c
|
||||
$(TARGET_CC) $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) $(jpeg_mod_CFLAGS) -c -o $@ $<
|
||||
|
||||
mod-jpeg.c: moddep.lst genmodsrc.sh
|
||||
sh $(srcdir)/genmodsrc.sh 'jpeg' $< > $@ || (rm -f $@; exit 1)
|
||||
|
||||
ifneq ($(jpeg_mod_EXPORTS),no)
|
||||
def-jpeg.lst: pre-jpeg.o
|
||||
$(NM) -g --defined-only -P -p $< | sed 's/^\([^ ]*\).*/\1 jpeg/' > $@
|
||||
endif
|
||||
|
||||
und-jpeg.lst: pre-jpeg.o
|
||||
echo 'jpeg' > $@
|
||||
$(NM) -u -P -p $< | cut -f1 -d' ' >> $@
|
||||
|
||||
jpeg_mod-video_readers_jpeg.o: video/readers/jpeg.c
|
||||
$(TARGET_CC) -Ivideo/readers -I$(srcdir)/video/readers $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) $(jpeg_mod_CFLAGS) -MD -c -o $@ $<
|
||||
-include jpeg_mod-video_readers_jpeg.d
|
||||
|
||||
CLEANFILES += cmd-jpeg_mod-video_readers_jpeg.lst fs-jpeg_mod-video_readers_jpeg.lst
|
||||
COMMANDFILES += cmd-jpeg_mod-video_readers_jpeg.lst
|
||||
FSFILES += fs-jpeg_mod-video_readers_jpeg.lst
|
||||
|
||||
cmd-jpeg_mod-video_readers_jpeg.lst: video/readers/jpeg.c gencmdlist.sh
|
||||
set -e; $(TARGET_CC) -Ivideo/readers -I$(srcdir)/video/readers $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) $(jpeg_mod_CFLAGS) -E $< | sh $(srcdir)/gencmdlist.sh jpeg > $@ || (rm -f $@; exit 1)
|
||||
|
||||
fs-jpeg_mod-video_readers_jpeg.lst: video/readers/jpeg.c genfslist.sh
|
||||
set -e; $(TARGET_CC) -Ivideo/readers -I$(srcdir)/video/readers $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) $(jpeg_mod_CFLAGS) -E $< | sh $(srcdir)/genfslist.sh jpeg > $@ || (rm -f $@; exit 1)
|
||||
|
||||
|
||||
jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
|
||||
jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
|
||||
|
||||
include $(srcdir)/conf/common.mk
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ pkglib_MODULES = biosdisk.mod _chain.mod _linux.mod linux.mod normal.mod \
|
|||
_multiboot.mod chain.mod multiboot.mod reboot.mod halt.mod \
|
||||
vbe.mod vbetest.mod vbeinfo.mod video.mod gfxterm.mod \
|
||||
videotest.mod play.mod bitmap.mod tga.mod cpuid.mod serial.mod \
|
||||
ata.mod vga.mod memdisk.mod
|
||||
ata.mod vga.mod memdisk.mod jpeg.mod
|
||||
|
||||
# For biosdisk.mod.
|
||||
biosdisk_mod_SOURCES = disk/i386/pc/biosdisk.c
|
||||
|
|
@ -272,4 +272,9 @@ memdisk_mod_SOURCES = disk/memdisk.c
|
|||
memdisk_mod_CFLAGS = $(COMMON_CFLAGS)
|
||||
memdisk_mod_LDFLAGS = $(COMMON_LDFLAGS)
|
||||
|
||||
# For jpeg.mod.
|
||||
jpeg_mod_SOURCES = video/readers/jpeg.c
|
||||
jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
|
||||
jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
|
||||
|
||||
include $(srcdir)/conf/common.mk
|
||||
|
|
|
|||
748
video/readers/jpeg.c
Normal file
748
video/readers/jpeg.c
Normal file
|
|
@ -0,0 +1,748 @@
|
|||
/*
|
||||
* 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
|
||||
|
||||
#define JPEG_MARKER_SOI 0xd8
|
||||
#define JPEG_MARKER_EOI 0xd9
|
||||
#define JPEG_MARKER_DHT 0xc4
|
||||
#define JPEG_MARKER_DQT 0xdb
|
||||
#define JPEG_MARKER_SOF0 0xc0
|
||||
#define JPEG_MARKER_SOS 0xda
|
||||
|
||||
#define SHIFT_BITS 8
|
||||
#define CONST(x) ((int) ((x) * (1L << SHIFT_BITS) + 0.5))
|
||||
|
||||
#define JPEG_UNIT_SIZE 8
|
||||
|
||||
static const grub_uint8_t jpeg_zigzag_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
|
||||
};
|
||||
|
||||
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 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 not supported");
|
||||
}
|
||||
else if (ss != JPEG_SAMPLING_1x1)
|
||||
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
|
||||
"jpeg: sampling method not 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;
|
||||
}
|
||||
|
||||
static void
|
||||
grub_jpeg_idct_transform (jpeg_data_unit_t du)
|
||||
{
|
||||
int *pd;
|
||||
int i;
|
||||
int t0, t1, t2, t3, t4, t5, t6, t7;
|
||||
int v0, v1, v2, v3, v4;
|
||||
|
||||
pd = du;
|
||||
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd++)
|
||||
{
|
||||
if ((pd[JPEG_UNIT_SIZE * 1] | pd[JPEG_UNIT_SIZE * 2] |
|
||||
pd[JPEG_UNIT_SIZE * 3] | pd[JPEG_UNIT_SIZE * 4] |
|
||||
pd[JPEG_UNIT_SIZE * 5] | pd[JPEG_UNIT_SIZE * 6] |
|
||||
pd[JPEG_UNIT_SIZE * 7]) == 0)
|
||||
{
|
||||
pd[JPEG_UNIT_SIZE * 0] <<= SHIFT_BITS;
|
||||
|
||||
pd[JPEG_UNIT_SIZE * 1] = pd[JPEG_UNIT_SIZE * 2]
|
||||
= pd[JPEG_UNIT_SIZE * 3] = pd[JPEG_UNIT_SIZE * 4]
|
||||
= pd[JPEG_UNIT_SIZE * 5] = pd[JPEG_UNIT_SIZE * 6]
|
||||
= pd[JPEG_UNIT_SIZE * 7] = pd[JPEG_UNIT_SIZE * 0];
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
t0 = pd[JPEG_UNIT_SIZE * 0];
|
||||
t1 = pd[JPEG_UNIT_SIZE * 2];
|
||||
t2 = pd[JPEG_UNIT_SIZE * 4];
|
||||
t3 = pd[JPEG_UNIT_SIZE * 6];
|
||||
|
||||
v4 = (t1 + t3) * CONST (0.541196100);
|
||||
|
||||
v0 = ((t0 + t2) << SHIFT_BITS);
|
||||
v1 = ((t0 - t2) << SHIFT_BITS);
|
||||
v2 = v4 - t3 * CONST (1.847759065);
|
||||
v3 = v4 + t1 * CONST (0.765366865);
|
||||
|
||||
t0 = v0 + v3;
|
||||
t3 = v0 - v3;
|
||||
t1 = v1 + v2;
|
||||
t2 = v1 - v2;
|
||||
|
||||
t4 = pd[JPEG_UNIT_SIZE * 7];
|
||||
t5 = pd[JPEG_UNIT_SIZE * 5];
|
||||
t6 = pd[JPEG_UNIT_SIZE * 3];
|
||||
t7 = pd[JPEG_UNIT_SIZE * 1];
|
||||
|
||||
v0 = t4 + t7;
|
||||
v1 = t5 + t6;
|
||||
v2 = t4 + t6;
|
||||
v3 = t5 + t7;
|
||||
|
||||
v4 = (v2 + v3) * CONST (1.175875602);
|
||||
|
||||
v0 *= CONST (0.899976223);
|
||||
v1 *= CONST (2.562915447);
|
||||
v2 = v2 * CONST (1.961570560) - v4;
|
||||
v3 = v3 * CONST (0.390180644) - v4;
|
||||
|
||||
t4 = t4 * CONST (0.298631336) - v0 - v2;
|
||||
t5 = t5 * CONST (2.053119869) - v1 - v3;
|
||||
t6 = t6 * CONST (3.072711026) - v1 - v2;
|
||||
t7 = t7 * CONST (1.501321110) - v0 - v3;
|
||||
|
||||
pd[JPEG_UNIT_SIZE * 0] = t0 + t7;
|
||||
pd[JPEG_UNIT_SIZE * 7] = t0 - t7;
|
||||
pd[JPEG_UNIT_SIZE * 1] = t1 + t6;
|
||||
pd[JPEG_UNIT_SIZE * 6] = t1 - t6;
|
||||
pd[JPEG_UNIT_SIZE * 2] = t2 + t5;
|
||||
pd[JPEG_UNIT_SIZE * 5] = t2 - t5;
|
||||
pd[JPEG_UNIT_SIZE * 3] = t3 + t4;
|
||||
pd[JPEG_UNIT_SIZE * 4] = t3 - t4;
|
||||
}
|
||||
|
||||
pd = du;
|
||||
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd += JPEG_UNIT_SIZE)
|
||||
{
|
||||
if ((pd[1] | pd[2] | pd[3] | pd[4] | pd[5] | pd[6] | pd[7]) == 0)
|
||||
{
|
||||
pd[0] >>= (SHIFT_BITS + 3);
|
||||
pd[1] = pd[2] = pd[3] = pd[4] = pd[5] = pd[6] = pd[7] = pd[0];
|
||||
continue;
|
||||
}
|
||||
|
||||
v4 = (pd[2] + pd[6]) * CONST (0.541196100);
|
||||
|
||||
v0 = (pd[0] + pd[4]) << SHIFT_BITS;
|
||||
v1 = (pd[0] - pd[4]) << SHIFT_BITS;
|
||||
v2 = v4 - pd[6] * CONST (1.847759065);
|
||||
v3 = v4 + pd[2] * CONST (0.765366865);
|
||||
|
||||
t0 = v0 + v3;
|
||||
t3 = v0 - v3;
|
||||
t1 = v1 + v2;
|
||||
t2 = v1 - v2;
|
||||
|
||||
t4 = pd[7];
|
||||
t5 = pd[5];
|
||||
t6 = pd[3];
|
||||
t7 = pd[1];
|
||||
|
||||
v0 = t4 + t7;
|
||||
v1 = t5 + t6;
|
||||
v2 = t4 + t6;
|
||||
v3 = t5 + t7;
|
||||
|
||||
v4 = (v2 + v3) * CONST (1.175875602);
|
||||
|
||||
v0 *= CONST (0.899976223);
|
||||
v1 *= CONST (2.562915447);
|
||||
v2 = v2 * CONST (1.961570560) - v4;
|
||||
v3 = v3 * CONST (0.390180644) - v4;
|
||||
|
||||
t4 = t4 * CONST (0.298631336) - v0 - v2;
|
||||
t5 = t5 * CONST (2.053119869) - v1 - v3;
|
||||
t6 = t6 * CONST (3.072711026) - v1 - v2;
|
||||
t7 = t7 * CONST (1.501321110) - v0 - v3;
|
||||
|
||||
pd[0] = (t0 + t7) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[7] = (t0 - t7) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[1] = (t1 + t6) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[6] = (t1 - t6) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[2] = (t2 + t5) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[5] = (t2 - t5) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[3] = (t3 + t4) >> (SHIFT_BITS * 2 + 3);
|
||||
pd[4] = (t3 - t4) >> (SHIFT_BITS * 2 + 3);
|
||||
}
|
||||
|
||||
for (i = 0; i < JPEG_UNIT_SIZE * JPEG_UNIT_SIZE; i++)
|
||||
{
|
||||
du[i] += 128;
|
||||
|
||||
if (du[i] < 0)
|
||||
du[i] = 0;
|
||||
if (du[i] > 255)
|
||||
du[i] = 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] * (int) data->quan_table[qt][0];
|
||||
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[jpeg_zigzag_order[pos]] = val * (int) data->quan_table[qt][pos];
|
||||
pos++;
|
||||
}
|
||||
|
||||
grub_jpeg_idct_transform (du);
|
||||
}
|
||||
|
||||
static void
|
||||
grub_jpeg_ycrcb_to_rgb (int yy, int cr, int cb, grub_uint8_t * rgb)
|
||||
{
|
||||
int dd;
|
||||
|
||||
cr -= 128;
|
||||
cb -= 128;
|
||||
|
||||
/* Red */
|
||||
dd = yy + ((cr * CONST (1.402)) >> SHIFT_BITS);
|
||||
if (dd < 0)
|
||||
dd = 0;
|
||||
if (dd > 255)
|
||||
dd = 255;
|
||||
*(rgb++) = dd;
|
||||
|
||||
/* Green */
|
||||
dd = yy - ((cb * CONST (0.34414) + cr * CONST (0.71414)) >> SHIFT_BITS);
|
||||
if (dd < 0)
|
||||
dd = 0;
|
||||
if (dd > 255)
|
||||
dd = 255;
|
||||
*(rgb++) = dd;
|
||||
|
||||
/* Blue */
|
||||
dd = yy + ((cb * CONST (1.772)) >> SHIFT_BITS);
|
||||
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 (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)
|
||||
{
|
||||
if (grub_jpeg_get_marker (data) != JPEG_MARKER_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 JPEG_MARKER_DHT: /* Define Huffman Table. */
|
||||
grub_jpeg_decode_huff_table (data);
|
||||
break;
|
||||
case JPEG_MARKER_DQT: /* Define Quantization Table. */
|
||||
grub_jpeg_decode_quan_table (data);
|
||||
break;
|
||||
case JPEG_MARKER_SOF0: /* Start Of Frame 0. */
|
||||
grub_jpeg_decode_sof (data);
|
||||
break;
|
||||
case JPEG_MARKER_SOS: /* Start Of Scan. */
|
||||
grub_jpeg_decode_sos (data);
|
||||
break;
|
||||
case JPEG_MARKER_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);
|
||||
}
|
||||
Loading…
Reference in a new issue