grub-devel
[Top][All Lists]
Advanced

[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: Sat, 12 Jan 2008 16:51:33 +0800

Hi,

changes in this new version:

handle width/height that's not multiple of 8
add support for 1:1:1 sampling
skip unrecognized marker instead of error.
verify the size of sof, sos, quantization table and huffman table.

/*
 *  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>
#include <grub/setjmp.h>

/* Uncomment following define to enable JPEG debug.  */
//#define JPEG_DEBUG

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;

typedef int jpeg_data_unit[64];

struct grub_jpeg_data
{
  grub_file_t file;
  grub_jmp_buf jumper;

  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 ydu[4];
  jpeg_data_unit crdu;
  jpeg_data_unit cbdu;

  int Cr_r_tab[256], Cb_b_tab[256], Cr_g_tab[256], Cb_g_tab[256];

  int vs, hs;

  int dc_value[3];

  int bit_mask, bit_save;

  struct grub_video_bitmap **bitmap;
};


static grub_uint8_t
get_byte (struct grub_jpeg_data *data)
{
  grub_uint8_t r;

  if (grub_file_read (data->file, (char *) &r, 1) != 1)
    grub_longjmp (data->jumper, 1);

  return r;
}

static grub_uint16_t
get_word (struct grub_jpeg_data *data)
{
  grub_uint16_t r;

  if (grub_file_read (data->file, (char *) &r, 2) != 2)
    grub_longjmp (data->jumper, 1);

  return grub_be_to_cpu16 (r);
}

static int
get_bit (struct grub_jpeg_data *data)
{
  int ret;

  if (data->bit_mask == 0)
    {
      data->bit_save = get_byte (data);
      if (data->bit_save == 0xFF)
        {
          if (get_byte (data) != 0)
            {
              grub_error (GRUB_ERR_BAD_FILE_TYPE,
                          "jpeg: invalid 0xFF in data stream");
              grub_longjmp (data->jumper, 1);
            }
        }
      data->bit_mask = 0x80;
    }

  ret = (data->bit_save & data->bit_mask);
  data->bit_mask >>= 1;
  return ret;
}

static int
get_number (struct grub_jpeg_data *data, int num)
{
  int value, i, bit;

  if (num == 0)
    return 0;

  bit = get_bit (data);
  value = (bit != 0);
  for (i = 1; i < num; i++)
    value = value * 2 + (get_bit (data) != 0);
  if (!bit)
    value += 1 - (1 << num);

  return value;
}

static int
get_huff_code (struct grub_jpeg_data *data, int id)
{
  int code, i;

  code = 0;
  for (i = 0; i < 16; i++)
    {
      code <<= 1;
      if (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");
  grub_longjmp (data->jumper, 1);
  return 0;
}

static void
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 += get_word (data);

  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);
    }

  if (grub_file_read (data->file, (char *) &count, sizeof (count)) !=
      sizeof (count))
    grub_longjmp (data->jumper, 1);

  n = 0;
  for (i = 0; i < 16; i++)
    n += count[i];

  id += ac * 2;
  data->huff_value[id] = grub_malloc (n);
  if (data->huff_value[id] == NULL)
    grub_longjmp (data->jumper, 1);

  if (grub_file_read (data->file, (char *) data->huff_value[id], n) != n)
    grub_longjmp (data->jumper, 1);

  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");
      grub_longjmp (data->jumper, 1);
    }
}

static void
decode_quan_table (struct grub_jpeg_data *data)
{
  int id;
  grub_uint32_t next_marker;

  next_marker = data->file->offset;
  next_marker += get_word (data);

  id = get_byte (data);
  if (id >= 0x10)               /* upper 4-bit is precision  */
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE,
                  "jpeg: only 8-bit precision is supported");
      grub_longjmp (data->jumper, 1);
    }

  if (id > 1)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE,
                  "jpeg: too many quantization table");
      grub_longjmp (data->jumper, 1);
    }

  if (grub_file_read (data->file, (char *) &data->quan_table[id], 64) != 64)
    grub_longjmp (data->jumper, 1);

  if (data->file->offset != next_marker)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE,
                  "jpeg: extra byte in quantization table");
      grub_longjmp (data->jumper, 1);
    }
}

static void
decode_sof (struct grub_jpeg_data *data)
{
  int nc, i;
  grub_uint32_t next_marker;

  next_marker = data->file->offset;
  next_marker += get_word (data);

  if (get_byte (data) != 8)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE,
                  "jpeg: only 8-bit precision is supported");
      grub_longjmp (data->jumper, 1);
    }

  data->image_height = get_word (data);
  data->image_width = get_word (data);

  if ((!data->image_height) || (!data->image_width))
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid image size");
      grub_longjmp (data->jumper, 1);
    }

  nc = get_byte (data);
  if (nc != 3)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: component count must be 3");
      grub_longjmp (data->jumper, 1);
    }

  for (i = 0; i < nc; i++)
    {
      int id, ss;

      id = get_byte (data) - 1;
      if ((id < 0) || (id >= 3))
        {
          grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
          grub_longjmp (data->jumper, 1);
        }
      ss = get_byte (data);
      if (!id)
        {
          int mask;

          data->vs = ss & 0xF;
          data->hs = ss >> 4;
          if ((data->vs > 2) || (data->hs > 2))
            {
              grub_error (GRUB_ERR_BAD_FILE_TYPE,
                          "jpeg: sampling method nor supported");
              grub_longjmp (data->jumper, 1);
            }

          mask = 8 * data->vs - 1;
          data->image_height = (data->image_height + mask) & (~mask);

          mask = 8 * data->hs - 1;
          data->image_width = (data->image_width + mask) & (~mask);
        }
      else if (ss != 0x11)
        {
          grub_error (GRUB_ERR_BAD_FILE_TYPE,
                      "jpeg: sampling method nor supported");
          grub_longjmp (data->jumper, 1);
        }
      data->comp_index[id][0] = get_byte (data);
    }

  if (data->file->offset != next_marker)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sof");
      grub_longjmp (data->jumper, 1);
    }
}

#define DCTSIZE     8

#define CONST_BITS  8
#define PASS1_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
idct_transform (jpeg_data_unit 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
decode_du (struct grub_jpeg_data *data, int id, jpeg_data_unit du)
{
  int pos, h1, h2, qt;

  grub_memset (du, 0, sizeof (jpeg_data_unit));

  qt = data->comp_index[id][0];
  h1 = data->comp_index[id][1];
  h2 = data->comp_index[id][2];

  data->dc_value[id] += get_number (data, get_huff_code (data, h1));

  du[0] =
    data->dc_value[id] * DESCALE ((int) data->quan_table[qt][0] *
                                  (int) aanscales[0], 14 - 2);
  pos = 1;
  while (pos < 64)
    {
      int num, val;

      num = get_huff_code (data, h2);
      if (!num)
        break;
      val = 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++;
    }

  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
build_color_table (struct grub_jpeg_data *data)
{
  int i, x;

  for (i = 0, x = -128; i <= 255; i++, x++)
    {
      data->Cr_r_tab[i] = (int) (FIX (1.40200) * x + ONE_HALF) >> SCALEBITS;
      data->Cb_b_tab[i] = (int) (FIX (1.77200) * x + ONE_HALF) >> SCALEBITS;
      data->Cr_g_tab[i] = (-FIX (0.71414)) * x;
      data->Cb_g_tab[i] = (-FIX (0.34414)) * x + ONE_HALF;
    }
}

static void
decode_sos (struct grub_jpeg_data *data)
{
  int nc, i, r1, c1, vb, hb;
  grub_uint8_t *ptr;
  grub_uint32_t data_offset;

  data_offset = data->file->offset;
  data_offset += get_word (data);

  nc = get_byte (data);

  if (nc != 3)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: component count must be 3");
      grub_longjmp (data->jumper, 1);
    }

  for (i = 0; i < nc; i++)
    {
      int id, ht;

      id = get_byte (data) - 1;
      if ((id < 0) || (id >= 3))
        {
          grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
          grub_longjmp (data->jumper, 1);
        }

      ht = get_byte (data);
      data->comp_index[id][1] = (ht >> 4);
      data->comp_index[id][2] = (ht & 0xF) + 2;
    }

  get_byte (data);              /* skip 3 unused bytes  */
  get_word (data);

  if (data->file->offset != data_offset)
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sos");
      grub_longjmp (data->jumper, 1);
    }

  if (grub_video_bitmap_create (data->bitmap, data->image_width,
                                data->image_height,
                                GRUB_VIDEO_BLIT_FORMAT_R8G8B8))
    grub_longjmp (data->jumper, 1);

  ptr = (*data->bitmap)->data;
  data->bit_mask = 0x0;

  vb = data->vs * 8;
  hb = data->hs * 8;

  for (r1 = 0; r1 < (data->image_height / vb); r1++)
    for (c1 = 0; c1 < (data->image_width / hb); c1++)
      {
        int r2, c2;

        for (r2 = 0; r2 < data->vs; r2++)
          for (c2 = 0; c2 < data->hs; c2++)
            decode_du (data, 0, data->ydu[r2 * 2 + c2]);

        decode_du (data, 1, data->cbdu);
        decode_du (data, 2, data->crdu);

        for (r2 = 0; r2 < vb; r2++)
          for (c2 = 0; c2 < hb; c2++)
            {
              int i0, i1, yy, cr, cb, dd;

              i0 = ((r1 * vb + r2) * data->image_width + c1 * hb + c2) * 3;
              i1 = (r2 / data->vs) * 8 + (c2 / data->hs);

              yy =
                data->ydu[(r2 / 8) * 2 + (c2 / 8)][(r2 % 8) * 8 + (c2 % 8)];
              cr = data->crdu[i1];
              cb = data->cbdu[i1];

              /* Red  */
              dd = yy + data->Cr_r_tab[cr];
              if (dd < 0)
                dd = 0;
              if (dd > 255)
                dd = 255;
              ptr[i0] = dd;

              /* Green  */
              dd =
                yy + ((data->Cb_g_tab[cb] + data->Cr_g_tab[cr]) >> SCALEBITS);
              if (dd < 0)
                dd = 0;
              if (dd > 255)
                dd = 255;
              ptr[i0 + 1] = dd;

              /* Blue  */
              dd = yy + data->Cb_b_tab[cb];
              if (dd < 0)
                dd = 0;
              if (dd > 255)
                dd = 255;
              ptr[i0 + 2] = dd;
            }
      }
}


static grub_uint8_t
get_marker (struct grub_jpeg_data *data)
{
  grub_uint8_t r;

  r = get_byte (data);

  if (r != 0xFF)                /* escape character  */
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid maker");
      grub_longjmp (data->jumper, 1);
    }

  return get_byte (data);
}

static void
decode_jpeg (struct grub_jpeg_data *data)
{
  build_color_table (data);

  if (get_marker (data) != M_SOI)       /* Start Of Image  */
    {
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid jpeg file");
      grub_longjmp (data->jumper, 1);
    }

  while (1)
    {
      grub_uint8_t marker;

      marker = get_marker (data);
#ifdef JPEG_DEBUG
      grub_printf ("jpeg marker: %x\n", marker);
#endif
      switch (marker)
        {
        case M_DHT:             /* Define Huffman Table  */
          decode_huff_table (data);
          break;
        case M_DQT:             /* Define Quantization Table  */
          decode_quan_table (data);
          break;
        case M_SOF0:            /* Start Of Frame 0  */
          decode_sof (data);
          break;
        case M_SOS:             /* Start Of Scan  */
          decode_sos (data);
          break;
        case M_EOI:             /* End Of Image  */
          return;
        default:                /* Skip unrecognized marker  */
          {
            grub_uint16_t sz;

            sz = get_word (data);
            grub_file_seek (data->file, data->file->offset + sz - 2);
          }
        }
    }
}

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;
      if (!grub_setjmp (data->jumper))
        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




reply via email to

[Prev in Thread] Current Thread [Next in Thread]