← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to video/readers/png.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
video/readers/png.c
1
 
/*
2
 
 *  GRUB  --  GRand Unified Bootloader
3
 
 *  Copyright (C) 2008,2009  Free Software Foundation, Inc.
4
 
 *
5
 
 *  GRUB is free software: you can redistribute it and/or modify
6
 
 *  it under the terms of the GNU General Public License as published by
7
 
 *  the Free Software Foundation, either version 3 of the License, or
8
 
 *  (at your option) any later version.
9
 
 *
10
 
 *  GRUB is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
17
 
 */
18
 
 
19
 
#include <grub/bitmap.h>
20
 
#include <grub/types.h>
21
 
#include <grub/normal.h>
22
 
#include <grub/dl.h>
23
 
#include <grub/mm.h>
24
 
#include <grub/misc.h>
25
 
#include <grub/bufio.h>
26
 
 
27
 
/* Uncomment following define to enable PNG debug.  */
28
 
//#define PNG_DEBUG
29
 
 
30
 
#define PNG_COLOR_MASK_PALETTE  1
31
 
#define PNG_COLOR_MASK_COLOR    2
32
 
#define PNG_COLOR_MASK_ALPHA    4
33
 
 
34
 
#define PNG_COLOR_TYPE_GRAY     0
35
 
#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
36
 
#define PNG_COLOR_TYPE_RGB      (PNG_COLOR_MASK_COLOR)
37
 
#define PNG_COLOR_TYPE_RGBA     (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
38
 
#define PNG_COLOR_TYPE_GRAYA    (PNG_COLOR_MASK_ALPHA)
39
 
 
40
 
#define PNG_COMPRESSION_BASE    0
41
 
 
42
 
#define PNG_INTERLACE_NONE      0
43
 
#define PNG_INTERLACE_ADAM7     1
44
 
 
45
 
#define PNG_FILTER_TYPE_BASE    0
46
 
 
47
 
#define PNG_FILTER_VALUE_NONE   0
48
 
#define PNG_FILTER_VALUE_SUB    1
49
 
#define PNG_FILTER_VALUE_UP     2
50
 
#define PNG_FILTER_VALUE_AVG    3
51
 
#define PNG_FILTER_VALUE_PAETH  4
52
 
#define PNG_FILTER_VALUE_LAST   5
53
 
 
54
 
#define PNG_CHUNK_IHDR          0x49484452
55
 
#define PNG_CHUNK_IDAT          0x49444154
56
 
#define PNG_CHUNK_IEND          0x49454e44
57
 
 
58
 
#define Z_DEFLATED              8
59
 
#define Z_FLAG_DICT             32
60
 
 
61
 
#define INFLATE_STORED          0
62
 
#define INFLATE_FIXED           1
63
 
#define INFLATE_DYNAMIC         2
64
 
 
65
 
#define WSIZE                   0x8000
66
 
 
67
 
#define DEFLATE_HCLEN_BASE      4
68
 
#define DEFLATE_HCLEN_MAX       19
69
 
#define DEFLATE_HLIT_BASE       257
70
 
#define DEFLATE_HLIT_MAX        288
71
 
#define DEFLATE_HDIST_BASE      1
72
 
#define DEFLATE_HDIST_MAX       30
73
 
 
74
 
#define DEFLATE_HUFF_LEN        16
75
 
 
76
 
#ifdef PNG_DEBUG
77
 
static grub_command_t cmd;
78
 
#endif
79
 
 
80
 
struct huff_table
81
 
{
82
 
  int *values, *maxval, *offset;
83
 
  int num_values, max_length;
84
 
};
85
 
 
86
 
struct grub_png_data
87
 
{
88
 
  grub_file_t file;
89
 
  struct grub_video_bitmap **bitmap;
90
 
 
91
 
  int bit_count, bit_save;
92
 
 
93
 
  grub_uint32_t next_offset;
94
 
 
95
 
  int image_width, image_height, bpp, is_16bit, raw_bytes;
96
 
  grub_uint8_t *image_data;
97
 
 
98
 
  int inside_idat, idat_remain;
99
 
 
100
 
  int code_values[DEFLATE_HLIT_MAX];
101
 
  int code_maxval[DEFLATE_HUFF_LEN];
102
 
  int code_offset[DEFLATE_HUFF_LEN];
103
 
 
104
 
  int dist_values[DEFLATE_HDIST_MAX];
105
 
  int dist_maxval[DEFLATE_HUFF_LEN];
106
 
  int dist_offset[DEFLATE_HUFF_LEN];
107
 
 
108
 
  struct huff_table code_table;
109
 
  struct huff_table dist_table;
110
 
 
111
 
  grub_uint8_t slide[WSIZE];
112
 
  int wp;
113
 
 
114
 
  grub_uint8_t *cur_rgb;
115
 
 
116
 
  int cur_column, cur_filter, first_line;
117
 
};
118
 
 
119
 
static grub_uint32_t
120
 
grub_png_get_dword (struct grub_png_data *data)
121
 
{
122
 
  grub_uint32_t r;
123
 
 
124
 
  r = 0;
125
 
  grub_file_read (data->file, &r, sizeof (grub_uint32_t));
126
 
 
127
 
  return grub_be_to_cpu32 (r);
128
 
}
129
 
 
130
 
static grub_uint8_t
131
 
grub_png_get_byte (struct grub_png_data *data)
132
 
{
133
 
  grub_uint8_t r;
134
 
 
135
 
  if ((data->inside_idat) && (data->idat_remain == 0))
136
 
    {
137
 
      grub_uint32_t len, type;
138
 
 
139
 
      do
140
 
        {
141
 
          /* Skip crc checksum.  */
142
 
          grub_png_get_dword (data);
143
 
 
144
 
          if (data->file->offset != data->next_offset)
145
 
            {
146
 
              grub_error (GRUB_ERR_BAD_FILE_TYPE,
147
 
                          "png: chunk size error");
148
 
              return 0;
149
 
            }
150
 
 
151
 
          len = grub_png_get_dword (data);
152
 
          type = grub_png_get_dword (data);
153
 
          if (type != PNG_CHUNK_IDAT)
154
 
            {
155
 
              grub_error (GRUB_ERR_BAD_FILE_TYPE,
156
 
                          "png: unexpected end of data");
157
 
              return 0;
158
 
            }
159
 
 
160
 
          data->next_offset = data->file->offset + len + 4;
161
 
        }
162
 
      while (len == 0);
163
 
      data->idat_remain = len;
164
 
    }
165
 
 
166
 
  r = 0;
167
 
  grub_file_read (data->file, &r, 1);
168
 
 
169
 
  if (data->inside_idat)
170
 
    data->idat_remain--;
171
 
 
172
 
  return r;
173
 
}
174
 
 
175
 
static int
176
 
grub_png_get_bits (struct grub_png_data *data, int num)
177
 
{
178
 
  int code, shift;
179
 
 
180
 
  if (data->bit_count == 0)
181
 
    {
182
 
      data->bit_save = grub_png_get_byte (data);
183
 
      data->bit_count = 8;
184
 
    }
185
 
 
186
 
  code = 0;
187
 
  shift = 0;
188
 
  while (grub_errno == 0)
189
 
    {
190
 
      int n;
191
 
 
192
 
      n = data->bit_count;
193
 
      if (n > num)
194
 
        n = num;
195
 
 
196
 
      code += (int) (data->bit_save & ((1 << n) - 1)) << shift;
197
 
      num -= n;
198
 
      if (!num)
199
 
        {
200
 
          data->bit_count -= n;
201
 
          data->bit_save >>= n;
202
 
          break;
203
 
        }
204
 
 
205
 
      shift += n;
206
 
 
207
 
      data->bit_save = grub_png_get_byte (data);
208
 
      data->bit_count = 8;
209
 
    }
210
 
 
211
 
  return code;
212
 
}
213
 
 
214
 
static grub_err_t
215
 
grub_png_decode_image_header (struct grub_png_data *data)
216
 
{
217
 
  int color_type;
218
 
  int color_bits;
219
 
 
220
 
  data->image_width = grub_png_get_dword (data);
221
 
  data->image_height = grub_png_get_dword (data);
222
 
 
223
 
  if ((!data->image_height) || (!data->image_width))
224
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size");
225
 
 
226
 
  color_bits = grub_png_get_byte (data);
227
 
  if ((color_bits != 8) && (color_bits != 16))
228
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
229
 
                       "png: bit depth must be 8 or 16");
230
 
  data->is_16bit = (color_bits == 16);
231
 
 
232
 
  color_type = grub_png_get_byte (data);
233
 
  if (color_type == PNG_COLOR_TYPE_RGB)
234
 
    {
235
 
      if (grub_video_bitmap_create (data->bitmap, data->image_width,
236
 
                                    data->image_height,
237
 
                                    GRUB_VIDEO_BLIT_FORMAT_RGB_888))
238
 
        return grub_errno;
239
 
      data->bpp = 3;
240
 
    }
241
 
  else if (color_type == PNG_COLOR_TYPE_RGBA)
242
 
    {
243
 
      if (grub_video_bitmap_create (data->bitmap, data->image_width,
244
 
                                    data->image_height,
245
 
                                    GRUB_VIDEO_BLIT_FORMAT_RGBA_8888))
246
 
        return grub_errno;
247
 
      data->bpp = 4;
248
 
    }
249
 
  else
250
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
251
 
                       "png: color type not supported");
252
 
 
253
 
  if (data->is_16bit)
254
 
    {
255
 
      data->bpp <<= 1;
256
 
 
257
 
      data->image_data = grub_malloc (data->image_height *
258
 
                                      data->image_width *  data->bpp);
259
 
      if (grub_errno)
260
 
        return grub_errno;
261
 
 
262
 
      data->cur_rgb = data->image_data;
263
 
    }
264
 
  else
265
 
    {
266
 
      data->image_data = 0;
267
 
      data->cur_rgb = (*data->bitmap)->data;
268
 
    }
269
 
 
270
 
  data->raw_bytes = data->image_height * (data->image_width + 1) * data->bpp;
271
 
 
272
 
  data->cur_column = 0;
273
 
  data->first_line = 1;
274
 
 
275
 
  if (grub_png_get_byte (data) != PNG_COMPRESSION_BASE)
276
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
277
 
                       "png: compression method not supported");
278
 
 
279
 
  if (grub_png_get_byte (data) != PNG_FILTER_TYPE_BASE)
280
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
281
 
                       "png: filter method not supported");
282
 
 
283
 
  if (grub_png_get_byte (data) != PNG_INTERLACE_NONE)
284
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
285
 
                       "png: interlace method not supported");
286
 
 
287
 
  /* Skip crc checksum.  */
288
 
  grub_png_get_dword (data);
289
 
 
290
 
  return grub_errno;
291
 
}
292
 
 
293
 
/* Order of the bit length code lengths.  */
294
 
static const grub_uint8_t bitorder[] = {
295
 
  16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
296
 
};
297
 
 
298
 
/* Copy lengths for literal codes 257..285.  */
299
 
static const int cplens[] = {
300
 
  3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
301
 
  35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
302
 
};
303
 
 
304
 
/* Extra bits for literal codes 257..285.  */
305
 
static const grub_uint8_t cplext[] = {
306
 
  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
307
 
  3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
308
 
};                              /* 99==invalid  */
309
 
 
310
 
/* Copy offsets for distance codes 0..29.  */
311
 
static const int cpdist[] = {
312
 
  1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
313
 
  257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
314
 
  8193, 12289, 16385, 24577
315
 
};
316
 
 
317
 
/* Extra bits for distance codes.  */
318
 
static const grub_uint8_t cpdext[] = {
319
 
  0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
320
 
  7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
321
 
  12, 12, 13, 13
322
 
};
323
 
 
324
 
static void
325
 
grub_png_init_huff_table (struct huff_table *ht, int cur_maxlen,
326
 
                          int *cur_values, int *cur_maxval, int *cur_offset)
327
 
{
328
 
  ht->values = cur_values;
329
 
  ht->maxval = cur_maxval;
330
 
  ht->offset = cur_offset;
331
 
  ht->num_values = 0;
332
 
  ht->max_length = cur_maxlen;
333
 
  grub_memset (cur_maxval, 0, sizeof (int) * cur_maxlen);
334
 
}
335
 
 
336
 
static void
337
 
grub_png_insert_huff_item (struct huff_table *ht, int code, int len)
338
 
{
339
 
  int i, n;
340
 
 
341
 
  if (len == 0)
342
 
    return;
343
 
 
344
 
  if (len > ht->max_length)
345
 
    {
346
 
      grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid code length");
347
 
      return;
348
 
    }
349
 
 
350
 
  n = 0;
351
 
  for (i = len; i < ht->max_length; i++)
352
 
    n += ht->maxval[i];
353
 
 
354
 
  for (i = 0; i < n; i++)
355
 
    ht->values[ht->num_values - i] = ht->values[ht->num_values - i - 1];
356
 
 
357
 
  ht->values[ht->num_values - n] = code;
358
 
  ht->num_values++;
359
 
  ht->maxval[len - 1]++;
360
 
}
361
 
 
362
 
static void
363
 
grub_png_build_huff_table (struct huff_table *ht)
364
 
{
365
 
  int base, ofs, i;
366
 
 
367
 
  base = 0;
368
 
  ofs = 0;
369
 
  for (i = 0; i < ht->max_length; i++)
370
 
    {
371
 
      base += ht->maxval[i];
372
 
      ofs += ht->maxval[i];
373
 
 
374
 
      ht->maxval[i] = base;
375
 
      ht->offset[i] = ofs - base;
376
 
 
377
 
      base <<= 1;
378
 
    }
379
 
}
380
 
 
381
 
static int
382
 
grub_png_get_huff_code (struct grub_png_data *data, struct huff_table *ht)
383
 
{
384
 
  int code, i;
385
 
 
386
 
  code = 0;
387
 
  for (i = 0; i < ht->max_length; i++)
388
 
    {
389
 
      code = (code << 1) + grub_png_get_bits (data, 1);
390
 
      if (code < ht->maxval[i])
391
 
        return ht->values[code + ht->offset[i]];
392
 
    }
393
 
  return 0;
394
 
}
395
 
 
396
 
static grub_err_t
397
 
grub_png_init_fixed_block (struct grub_png_data *data)
398
 
{
399
 
  int i;
400
 
 
401
 
  grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
402
 
                            data->code_values, data->code_maxval,
403
 
                            data->code_offset);
404
 
 
405
 
  for (i = 0; i < 144; i++)
406
 
    grub_png_insert_huff_item (&data->code_table, i, 8);
407
 
 
408
 
  for (; i < 256; i++)
409
 
    grub_png_insert_huff_item (&data->code_table, i, 9);
410
 
 
411
 
  for (; i < 280; i++)
412
 
    grub_png_insert_huff_item (&data->code_table, i, 7);
413
 
 
414
 
  for (; i < DEFLATE_HLIT_MAX; i++)
415
 
    grub_png_insert_huff_item (&data->code_table, i, 8);
416
 
 
417
 
  grub_png_build_huff_table (&data->code_table);
418
 
 
419
 
  grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
420
 
                            data->dist_values, data->dist_maxval,
421
 
                            data->dist_offset);
422
 
 
423
 
  for (i = 0; i < DEFLATE_HDIST_MAX; i++)
424
 
    grub_png_insert_huff_item (&data->dist_table, i, 5);
425
 
 
426
 
  grub_png_build_huff_table (&data->dist_table);
427
 
 
428
 
  return grub_errno;
429
 
}
430
 
 
431
 
static grub_err_t
432
 
grub_png_init_dynamic_block (struct grub_png_data *data)
433
 
{
434
 
  int nl, nd, nb, i, prev;
435
 
  struct huff_table cl;
436
 
  int cl_values[sizeof (bitorder)];
437
 
  int cl_maxval[8];
438
 
  int cl_offset[8];
439
 
  grub_uint8_t lens[DEFLATE_HCLEN_MAX];
440
 
 
441
 
  nl = DEFLATE_HLIT_BASE + grub_png_get_bits (data, 5);
442
 
  nd = DEFLATE_HDIST_BASE + grub_png_get_bits (data, 5);
443
 
  nb = DEFLATE_HCLEN_BASE + grub_png_get_bits (data, 4);
444
 
 
445
 
  if ((nl > DEFLATE_HLIT_MAX) || (nd > DEFLATE_HDIST_MAX) ||
446
 
      (nb > DEFLATE_HCLEN_MAX))
447
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data");
448
 
 
449
 
  grub_png_init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset);
450
 
 
451
 
  for (i = 0; i < nb; i++)
452
 
    lens[bitorder[i]] = grub_png_get_bits (data, 3);
453
 
 
454
 
  for (; i < DEFLATE_HCLEN_MAX; i++)
455
 
    lens[bitorder[i]] = 0;
456
 
 
457
 
  for (i = 0; i < DEFLATE_HCLEN_MAX; i++)
458
 
    grub_png_insert_huff_item (&cl, i, lens[i]);
459
 
 
460
 
  grub_png_build_huff_table (&cl);
461
 
 
462
 
  grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
463
 
                            data->code_values, data->code_maxval,
464
 
                            data->code_offset);
465
 
 
466
 
  grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
467
 
                            data->dist_values, data->dist_maxval,
468
 
                            data->dist_offset);
469
 
 
470
 
  prev = 0;
471
 
  for (i = 0; i < nl + nd; i++)
472
 
    {
473
 
      int n, code;
474
 
      struct huff_table *ht;
475
 
 
476
 
      if (grub_errno)
477
 
        return grub_errno;
478
 
 
479
 
      if (i < nl)
480
 
        {
481
 
          ht = &data->code_table;
482
 
          code = i;
483
 
        }
484
 
      else
485
 
        {
486
 
          ht = &data->dist_table;
487
 
          code = i - nl;
488
 
        }
489
 
 
490
 
      n = grub_png_get_huff_code (data, &cl);
491
 
      if (n < 16)
492
 
        {
493
 
          grub_png_insert_huff_item (ht, code, n);
494
 
          prev = n;
495
 
        }
496
 
      else if (n == 16)
497
 
        {
498
 
          int c;
499
 
 
500
 
          c = 3 + grub_png_get_bits (data, 2);
501
 
          while (c > 0)
502
 
            {
503
 
              grub_png_insert_huff_item (ht, code++, prev);
504
 
              i++;
505
 
              c--;
506
 
            }
507
 
          i--;
508
 
        }
509
 
      else if (n == 17)
510
 
        i += 3 + grub_png_get_bits (data, 3) - 1;
511
 
      else
512
 
        i += 11 + grub_png_get_bits (data, 7) - 1;
513
 
    }
514
 
 
515
 
  grub_png_build_huff_table (&data->code_table);
516
 
  grub_png_build_huff_table (&data->dist_table);
517
 
 
518
 
  return grub_errno;
519
 
}
520
 
 
521
 
static grub_err_t
522
 
grub_png_output_byte (struct grub_png_data *data, grub_uint8_t n)
523
 
{
524
 
  int row_bytes;
525
 
 
526
 
  if (--data->raw_bytes < 0)
527
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "image size overflown");
528
 
 
529
 
  if (data->cur_column == 0)
530
 
    {
531
 
      if (n >= PNG_FILTER_VALUE_LAST)
532
 
        return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value");
533
 
 
534
 
      data->cur_filter = n;
535
 
    }
536
 
  else
537
 
    *(data->cur_rgb++) = n;
538
 
 
539
 
  data->cur_column++;
540
 
  row_bytes = data->image_width * data->bpp;
541
 
  if (data->cur_column == row_bytes + 1)
542
 
    {
543
 
      grub_uint8_t *blank_line = NULL;
544
 
      grub_uint8_t *cur = data->cur_rgb - row_bytes;
545
 
      grub_uint8_t *left = cur;
546
 
      grub_uint8_t *up;
547
 
 
548
 
      if (data->first_line)
549
 
        {
550
 
          blank_line = grub_zalloc (row_bytes);
551
 
          if (blank_line == NULL)
552
 
            return grub_errno;
553
 
 
554
 
          up = blank_line;
555
 
        }
556
 
      else
557
 
        up = cur - row_bytes;
558
 
 
559
 
      switch (data->cur_filter)
560
 
        {
561
 
        case PNG_FILTER_VALUE_SUB:
562
 
          {
563
 
            int i;
564
 
 
565
 
            cur += data->bpp;
566
 
            for (i = data->bpp; i < row_bytes; i++, cur++, left++)
567
 
              *cur += *left;
568
 
 
569
 
            break;
570
 
          }
571
 
        case PNG_FILTER_VALUE_UP:
572
 
          {
573
 
            int i;
574
 
 
575
 
            for (i = 0; i < row_bytes; i++, cur++, up++)
576
 
              *cur += *up;
577
 
 
578
 
            break;
579
 
          }
580
 
        case PNG_FILTER_VALUE_AVG:
581
 
          {
582
 
            int i;
583
 
 
584
 
            for (i = 0; i < data->bpp; i++, cur++, up++)
585
 
              *cur += *up >> 1;
586
 
 
587
 
            for (; i < row_bytes; i++, cur++, up++, left++)
588
 
              *cur += ((int) *up + (int) *left) >> 1;
589
 
 
590
 
            break;
591
 
          }
592
 
        case PNG_FILTER_VALUE_PAETH:
593
 
          {
594
 
            int i;
595
 
            grub_uint8_t *upper_left = up;
596
 
 
597
 
            for (i = 0; i < data->bpp; i++, cur++, up++)
598
 
              *cur += *up;
599
 
 
600
 
            for (; i < row_bytes; i++, cur++, up++, left++, upper_left++)
601
 
              {
602
 
                int a, b, c, pa, pb, pc;
603
 
 
604
 
                a = *left;
605
 
                b = *up;
606
 
                c = *upper_left;
607
 
 
608
 
                pa = b - c;
609
 
                pb = a - c;
610
 
                pc = pa + pb;
611
 
 
612
 
                if (pa < 0)
613
 
                  pa = -pa;
614
 
 
615
 
                if (pb < 0)
616
 
                  pb = -pb;
617
 
 
618
 
                if (pc < 0)
619
 
                  pc = -pc;
620
 
 
621
 
                *cur += ((pa <= pb) && (pa <= pc)) ? a : (pb <= pc) ? b : c;
622
 
              }
623
 
          }
624
 
        }
625
 
 
626
 
      if (blank_line)
627
 
        grub_free (blank_line);
628
 
 
629
 
      data->cur_column = 0;
630
 
      data->first_line = 0;
631
 
    }
632
 
 
633
 
  return grub_errno;
634
 
}
635
 
 
636
 
static grub_err_t
637
 
grub_png_read_dynamic_block (struct grub_png_data *data)
638
 
{
639
 
  while (grub_errno == 0)
640
 
    {
641
 
      int n;
642
 
 
643
 
      n = grub_png_get_huff_code (data, &data->code_table);
644
 
      if (n < 256)
645
 
        {
646
 
          data->slide[data->wp] = n;
647
 
          grub_png_output_byte (data, n);
648
 
 
649
 
          data->wp++;
650
 
          if (data->wp >= WSIZE)
651
 
            data->wp = 0;
652
 
        }
653
 
      else if (n == 256)
654
 
        break;
655
 
      else
656
 
        {
657
 
          int len, dist, pos;
658
 
 
659
 
          n -= 257;
660
 
          len = cplens[n];
661
 
          if (cplext[n])
662
 
            len += grub_png_get_bits (data, cplext[n]);
663
 
 
664
 
          n = grub_png_get_huff_code (data, &data->dist_table);
665
 
          dist = cpdist[n];
666
 
          if (cpdext[n])
667
 
            dist += grub_png_get_bits (data, cpdext[n]);
668
 
 
669
 
          pos = data->wp - dist;
670
 
          if (pos < 0)
671
 
            pos += WSIZE;
672
 
 
673
 
          while (len > 0)
674
 
            {
675
 
              data->slide[data->wp] = data->slide[pos];
676
 
              grub_png_output_byte (data, data->slide[data->wp]);
677
 
 
678
 
              data->wp++;
679
 
              if (data->wp >= WSIZE)
680
 
                data->wp = 0;
681
 
 
682
 
              pos++;
683
 
              if (pos >= WSIZE)
684
 
                pos = 0;
685
 
 
686
 
              len--;
687
 
            }
688
 
        }
689
 
    }
690
 
 
691
 
  return grub_errno;
692
 
}
693
 
 
694
 
static grub_err_t
695
 
grub_png_decode_image_data (struct grub_png_data *data)
696
 
{
697
 
  grub_uint8_t cmf, flg;
698
 
  int final;
699
 
 
700
 
  cmf = grub_png_get_byte (data);
701
 
  flg = grub_png_get_byte (data);
702
 
 
703
 
  if ((cmf & 0xF) != Z_DEFLATED)
704
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
705
 
                       "png: only support deflate compression method");
706
 
 
707
 
  if (flg & Z_FLAG_DICT)
708
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE,
709
 
                       "png: dictionary not supported");
710
 
 
711
 
  do
712
 
    {
713
 
      int block_type;
714
 
 
715
 
      final = grub_png_get_bits (data, 1);
716
 
      block_type = grub_png_get_bits (data, 2);
717
 
 
718
 
      switch (block_type)
719
 
        {
720
 
        case INFLATE_STORED:
721
 
          {
722
 
            grub_uint16_t i, len;
723
 
 
724
 
            data->bit_count = 0;
725
 
            len = grub_png_get_byte (data);
726
 
            len += ((grub_uint16_t) grub_png_get_byte (data)) << 8;
727
 
 
728
 
            /* Skip NLEN field.  */
729
 
            grub_png_get_byte (data);
730
 
            grub_png_get_byte (data);
731
 
 
732
 
            for (i = 0; i < len; i++)
733
 
              grub_png_output_byte (data, grub_png_get_byte (data));
734
 
 
735
 
            break;
736
 
          }
737
 
 
738
 
        case INFLATE_FIXED:
739
 
          grub_png_init_fixed_block (data);
740
 
          grub_png_read_dynamic_block (data);
741
 
          break;
742
 
 
743
 
        case INFLATE_DYNAMIC:
744
 
          grub_png_init_dynamic_block (data);
745
 
          grub_png_read_dynamic_block (data);
746
 
          break;
747
 
 
748
 
        default:
749
 
          return grub_error (GRUB_ERR_BAD_FILE_TYPE,
750
 
                             "png: unknown block type");
751
 
        }
752
 
    }
753
 
  while ((!final) && (grub_errno == 0));
754
 
 
755
 
  /* Skip adler checksum.  */
756
 
  grub_png_get_dword (data);
757
 
 
758
 
  /* Skip crc checksum.  */
759
 
  grub_png_get_dword (data);
760
 
 
761
 
  return grub_errno;
762
 
}
763
 
 
764
 
static const grub_uint8_t png_magic[8] =
765
 
  { 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a };
766
 
 
767
 
static void
768
 
grub_png_convert_image (struct grub_png_data *data)
769
 
{
770
 
  int i;
771
 
  grub_uint8_t *d1, *d2;
772
 
 
773
 
  d1 = (*data->bitmap)->data;
774
 
  d2 = data->image_data + 1;
775
 
 
776
 
  /* Only copy the upper 8 bit.  */
777
 
  for (i = 0; i < (data->image_width * data->image_height * data->bpp >> 1);
778
 
       i++, d1++, d2+=2)
779
 
    *d1 = *d2;
780
 
}
781
 
 
782
 
static grub_err_t
783
 
grub_png_decode_png (struct grub_png_data *data)
784
 
{
785
 
  grub_uint8_t magic[8];
786
 
 
787
 
  if (grub_file_read (data->file, &magic[0], 8) != 8)
788
 
    return grub_errno;
789
 
 
790
 
  if (grub_memcmp (magic, png_magic, sizeof (png_magic)))
791
 
    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file");
792
 
 
793
 
  while (1)
794
 
    {
795
 
      grub_uint32_t len, type;
796
 
 
797
 
      len = grub_png_get_dword (data);
798
 
      type = grub_png_get_dword (data);
799
 
      data->next_offset = data->file->offset + len + 4;
800
 
 
801
 
      switch (type)
802
 
        {
803
 
        case PNG_CHUNK_IHDR:
804
 
          grub_png_decode_image_header (data);
805
 
          break;
806
 
 
807
 
        case PNG_CHUNK_IDAT:
808
 
          data->inside_idat = 1;
809
 
          data->idat_remain = len;
810
 
          data->bit_count = 0;
811
 
 
812
 
          grub_png_decode_image_data (data);
813
 
 
814
 
          data->inside_idat = 0;
815
 
          break;
816
 
 
817
 
        case PNG_CHUNK_IEND:
818
 
          if (data->is_16bit)
819
 
            grub_png_convert_image (data);
820
 
 
821
 
          return grub_errno;
822
 
 
823
 
        default:
824
 
          grub_file_seek (data->file, data->file->offset + len + 4);
825
 
        }
826
 
 
827
 
      if (grub_errno)
828
 
        break;
829
 
 
830
 
      if (data->file->offset != data->next_offset)
831
 
        return grub_error (GRUB_ERR_BAD_FILE_TYPE,
832
 
                           "png: chunk size error");
833
 
    }
834
 
 
835
 
  return grub_errno;
836
 
}
837
 
 
838
 
static grub_err_t
839
 
grub_video_reader_png (struct grub_video_bitmap **bitmap,
840
 
                       const char *filename)
841
 
{
842
 
  grub_file_t file;
843
 
  struct grub_png_data *data;
844
 
 
845
 
  file = grub_buffile_open (filename, 0);
846
 
  if (!file)
847
 
    return grub_errno;
848
 
 
849
 
  data = grub_zalloc (sizeof (*data));
850
 
  if (data != NULL)
851
 
    {
852
 
      data->file = file;
853
 
      data->bitmap = bitmap;
854
 
 
855
 
      grub_png_decode_png (data);
856
 
 
857
 
      grub_free (data->image_data);
858
 
      grub_free (data);
859
 
    }
860
 
 
861
 
  if (grub_errno != GRUB_ERR_NONE)
862
 
    {
863
 
      grub_video_bitmap_destroy (*bitmap);
864
 
      *bitmap = 0;
865
 
    }
866
 
 
867
 
  grub_file_close (file);
868
 
  return grub_errno;
869
 
}
870
 
 
871
 
#if defined(PNG_DEBUG)
872
 
static grub_err_t
873
 
grub_cmd_pngtest (grub_command_t cmd __attribute__ ((unused)),
874
 
                  int argc, char **args)
875
 
{
876
 
  struct grub_video_bitmap *bitmap = 0;
877
 
 
878
 
  if (argc != 1)
879
 
    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
880
 
 
881
 
  grub_video_reader_png (&bitmap, args[0]);
882
 
  if (grub_errno != GRUB_ERR_NONE)
883
 
    return grub_errno;
884
 
 
885
 
  grub_video_bitmap_destroy (bitmap);
886
 
 
887
 
  return GRUB_ERR_NONE;
888
 
}
889
 
#endif
890
 
 
891
 
static struct grub_video_bitmap_reader png_reader = {
892
 
  .extension = ".png",
893
 
  .reader = grub_video_reader_png,
894
 
  .next = 0
895
 
};
896
 
 
897
 
GRUB_MOD_INIT (png)
898
 
{
899
 
  grub_video_bitmap_reader_register (&png_reader);
900
 
#if defined(PNG_DEBUG)
901
 
  cmd = grub_register_command ("pngtest", grub_cmd_pngtest,
902
 
                               "FILE",
903
 
                               "Tests loading of PNG bitmap.");
904
 
#endif
905
 
}
906
 
 
907
 
GRUB_MOD_FINI (png)
908
 
{
909
 
#if defined(PNG_DEBUG)
910
 
  grub_unregister_command (cmd);
911
 
#endif
912
 
  grub_video_bitmap_reader_unregister (&png_reader);
913
 
}