arch/common/boot/grub2/video/readers/tga.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2006,2007  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/arg.h>
  26 #include <grub/file.h>
  27
  28 /* Uncomment following define to enable TGA debug.  */
  29 //#define TGA_DEBUG
  30
  31 #if defined(TGA_DEBUG)
  32 #define dump_int_field(x) grub_printf( #x " = %d (0x%04x)\n", x, x);
  33 #endif
  34
  35 enum
  36 {
  37   GRUB_TGA_IMAGE_TYPE_NONE = 0,
  38   GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_INDEXCOLOR = 1,
  39   GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR = 2,
  40   GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_BLACK_AND_WHITE = 3,
  41   GRUB_TGA_IMAGE_TYPE_RLE_INDEXCOLOR = 9,
  42   GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR = 10,
  43   GRUB_TGA_IMAGE_TYPE_RLE_BLACK_AND_WHITE = 11,
  44 };
  45
  46 enum
  47 {
  48   GRUB_TGA_COLOR_MAP_TYPE_NONE = 0,
  49   GRUB_TGA_COLOR_MAP_TYPE_INCLUDED = 1
  50 };
  51
  52 enum
  53 {
  54   GRUB_TGA_IMAGE_ORIGIN_RIGHT = 0x10,
  55   GRUB_TGA_IMAGE_ORIGIN_TOP   = 0x20
  56 };
  57
  58 struct grub_tga_header
  59 {
  60   grub_uint8_t id_length;
  61   grub_uint8_t color_map_type;
  62   grub_uint8_t image_type;
  63
  64   /* Color Map Specification.  */
  65   grub_uint16_t color_map_first_index;
  66   grub_uint16_t color_map_length;
  67   grub_uint8_t color_map_bpp;
  68
  69   /* Image Specification.  */
  70   grub_uint16_t image_x_origin;
  71   grub_uint16_t image_y_origin;
  72   grub_uint16_t image_width;
  73   grub_uint16_t image_height;
  74   grub_uint8_t image_bpp;
  75   grub_uint8_t image_descriptor;
  76 } __attribute__ ((packed));
  77
  78 static grub_err_t
  79 tga_load_truecolor_rle_R8G8B8 (struct grub_video_bitmap *bitmap,
  80                                struct grub_tga_header *header,
  81                                grub_file_t file)
  82 {
  83   unsigned int x;
  84   unsigned int y;
  85   grub_uint8_t type;
  86   grub_uint8_t *ptr;
  87   grub_uint8_t tmp[4]; /* Size should be max_bpp / 8.  */
  88   grub_uint8_t bytes_per_pixel;
  89
  90   bytes_per_pixel = header->image_bpp / 8;
  91
  92   for (y = 0; y < header->image_height; y++)
  93     {
  94       ptr = bitmap->data;
  95       if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
  96         ptr += y * bitmap->mode_info.pitch;
  97       else
  98         ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
  99
 100       for (x = 0; x < header->image_width;)
 101         {
 102           if (grub_file_read (file, (char *)&type, sizeof (type)) != sizeof(type))
 103             return grub_errno;
 104
 105           if (type & 0x80)
 106             {
 107               /* RLE-encoded packet.  */
 108               type &= 0x7f;
 109               type++;
 110
 111               if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 112                   != bytes_per_pixel)
 113                 return grub_errno;
 114
 115               while (type)
 116                 {
 117                   if (x < header->image_width)
 118                     {
 119                       ptr[0] = tmp[2];
 120                       ptr[1] = tmp[1];
 121                       ptr[2] = tmp[0];
 122                       ptr += 3;
 123                     }
 124
 125                   type--;
 126                   x++;
 127                 }
 128             }
 129           else
 130             {
 131               /* RAW-encoded packet.  */
 132               type++;
 133
 134               while (type)
 135                 {
 136                   if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 137                       != bytes_per_pixel)
 138                     return grub_errno;
 139
 140                   if (x < header->image_width)
 141                     {
 142                       ptr[0] = tmp[2];
 143                       ptr[1] = tmp[1];
 144                       ptr[2] = tmp[0];
 145                       ptr += 3;
 146                     }
 147
 148                   type--;
 149                   x++;
 150                 }
 151             }
 152         }
 153     }
 154   return GRUB_ERR_NONE;
 155 }
 156
 157 static grub_err_t
 158 tga_load_truecolor_rle_R8G8B8A8 (struct grub_video_bitmap *bitmap,
 159                                  struct grub_tga_header *header,
 160                                  grub_file_t file)
 161 {
 162   unsigned int x;
 163   unsigned int y;
 164   grub_uint8_t type;
 165   grub_uint8_t *ptr;
 166   grub_uint8_t tmp[4]; /* Size should be max_bpp / 8.  */
 167   grub_uint8_t bytes_per_pixel;
 168
 169   bytes_per_pixel = header->image_bpp / 8;
 170
 171   for (y = 0; y < header->image_height; y++)
 172     {
 173       ptr = bitmap->data;
 174       if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
 175         ptr += y * bitmap->mode_info.pitch;
 176       else
 177         ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
 178
 179       for (x = 0; x < header->image_width;)
 180         {
 181           if (grub_file_read (file, (char *)&type, sizeof (type)) != sizeof(type))
 182             return grub_errno;
 183
 184           if (type & 0x80)
 185             {
 186               /* RLE-encoded packet.  */
 187               type &= 0x7f;
 188               type++;
 189
 190               if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 191                   != bytes_per_pixel)
 192                 return grub_errno;
 193
 194               while (type)
 195                 {
 196                   if (x < header->image_width)
 197                     {
 198                       ptr[0] = tmp[2];
 199                       ptr[1] = tmp[1];
 200                       ptr[2] = tmp[0];
 201                       ptr[3] = tmp[3];
 202                       ptr += 4;
 203                     }
 204
 205                   type--;
 206                   x++;
 207                 }
 208             }
 209           else
 210             {
 211               /* RAW-encoded packet.  */
 212               type++;
 213
 214               while (type)
 215                 {
 216                   if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 217                       != bytes_per_pixel)
 218                     return grub_errno;
 219
 220                   if (x < header->image_width)
 221                     {
 222                       ptr[0] = tmp[2];
 223                       ptr[1] = tmp[1];
 224                       ptr[2] = tmp[0];
 225                       ptr[3] = tmp[3];
 226                       ptr += 4;
 227                     }
 228
 229                   type--;
 230                   x++;
 231                 }
 232             }
 233         }
 234     }
 235   return GRUB_ERR_NONE;
 236 }
 237
 238 static grub_err_t
 239 tga_load_truecolor_R8G8B8 (struct grub_video_bitmap *bitmap,
 240                            struct grub_tga_header *header,
 241                            grub_file_t file)
 242 {
 243   unsigned int x;
 244   unsigned int y;
 245   grub_uint8_t *ptr;
 246   grub_uint8_t tmp[4]; /* Size should be max_bpp / 8.  */
 247   grub_uint8_t bytes_per_pixel;
 248
 249   bytes_per_pixel = header->image_bpp / 8;
 250
 251   for (y = 0; y < header->image_height; y++)
 252     {
 253       ptr = bitmap->data;
 254       if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
 255         ptr += y * bitmap->mode_info.pitch;
 256       else
 257         ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
 258
 259       for (x = 0; x < header->image_width; x++)
 260         {
 261           if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 262               != bytes_per_pixel)
 263             return grub_errno;
 264
 265           ptr[0] = tmp[2];
 266           ptr[1] = tmp[1];
 267           ptr[2] = tmp[0];
 268
 269           ptr += 3;
 270         }
 271     }
 272   return GRUB_ERR_NONE;
 273 }
 274
 275 static grub_err_t
 276 tga_load_truecolor_R8G8B8A8 (struct grub_video_bitmap *bitmap,
 277                              struct grub_tga_header *header,
 278                              grub_file_t file)
 279 {
 280   unsigned int x;
 281   unsigned int y;
 282   grub_uint8_t *ptr;
 283   grub_uint8_t tmp[4]; /* Size should be max_bpp / 8.  */
 284   grub_uint8_t bytes_per_pixel;
 285
 286   bytes_per_pixel = header->image_bpp / 8;
 287
 288   for (y = 0; y < header->image_height; y++)
 289     {
 290       ptr = bitmap->data;
 291       if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
 292         ptr += y * bitmap->mode_info.pitch;
 293       else
 294         ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
 295
 296       for (x = 0; x < header->image_width; x++)
 297         {
 298           if (grub_file_read (file, (char *)&tmp[0], bytes_per_pixel)
 299               != bytes_per_pixel)
 300             return grub_errno;
 301
 302           ptr[0] = tmp[2];
 303           ptr[1] = tmp[1];
 304           ptr[2] = tmp[0];
 305           ptr[3] = tmp[3];
 306
 307           ptr += 4;
 308         }
 309     }
 310   return GRUB_ERR_NONE;
 311 }
 312
 313 static grub_err_t
 314 grub_video_reader_tga (struct grub_video_bitmap **bitmap,
 315                        const char *filename)
 316 {
 317   grub_file_t file;
 318   grub_ssize_t pos;
 319   struct grub_tga_header header;
 320   int has_alpha;
 321
 322   file = grub_file_open (filename);
 323   if (! file)
 324     return grub_errno;
 325
 326   /* TGA Specification states that we SHOULD start by reading
 327      ID from end of file, but we really don't care about that as we are
 328      not going to support developer area & extensions at this point.  */
 329
 330   /* Read TGA header from beginning of file.  */
 331   if (grub_file_read (file, (char*)&header, sizeof (header))
 332       != sizeof (header))
 333     {
 334       grub_file_close (file);
 335       return grub_errno;
 336     }
 337
 338   /* Skip ID field.  */
 339   pos = grub_file_tell (file);
 340   pos += header.id_length;
 341   grub_file_seek (file, pos);
 342   if (grub_errno != GRUB_ERR_NONE)
 343     {
 344       grub_file_close (file);
 345       return grub_errno;
 346     }
 347
 348 #if defined(TGA_DEBUG)
 349   grub_printf("tga: header\n");
 350   dump_int_field(header.id_length);
 351   dump_int_field(header.color_map_type);
 352   dump_int_field(header.image_type);
 353   dump_int_field(header.color_map_first_index);
 354   dump_int_field(header.color_map_length);
 355   dump_int_field(header.color_map_bpp);
 356   dump_int_field(header.image_x_origin);
 357   dump_int_field(header.image_y_origin);
 358   dump_int_field(header.image_width);
 359   dump_int_field(header.image_height);
 360   dump_int_field(header.image_bpp);
 361   dump_int_field(header.image_descriptor);
 362 #endif
 363
 364   /* Check that bitmap encoding is supported.  */
 365   switch (header.image_type)
 366     {
 367       case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
 368       case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
 369         break;
 370
 371       default:
 372         grub_file_close (file);
 373         return grub_error (GRUB_ERR_BAD_FILE_TYPE,
 374                            "Unsupported bitmap format (unknown encoding).");
 375     }
 376
 377   /* Check that bitmap depth is supported.  */
 378   switch (header.image_bpp)
 379     {
 380       case 24:
 381         has_alpha = 0;
 382         break;
 383
 384       case 32:
 385         has_alpha = 1;
 386         break;
 387
 388       default:
 389         grub_file_close (file);
 390         return grub_error (GRUB_ERR_BAD_FILE_TYPE,
 391                            "Unsupported bitmap format (bpp=%d).",
 392                            header.image_bpp);
 393     }
 394
 395   /* Allocate bitmap.  If there is alpha information store it too.  */
 396   if (has_alpha)
 397     {
 398       grub_video_bitmap_create (bitmap, header.image_width,
 399                                 header.image_height,
 400                                 GRUB_VIDEO_BLIT_FORMAT_R8G8B8A8);
 401       if (grub_errno != GRUB_ERR_NONE)
 402         {
 403           grub_file_close (file);
 404           return grub_errno;
 405         }
 406
 407       /* Load bitmap data.  */
 408       switch (header.image_type)
 409         {
 410           case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
 411             tga_load_truecolor_R8G8B8A8 (*bitmap, &header, file);
 412             break;
 413
 414           case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
 415             tga_load_truecolor_rle_R8G8B8A8 (*bitmap, &header, file);
 416             break;
 417         }
 418     }
 419   else
 420     {
 421       grub_video_bitmap_create (bitmap, header.image_width,
 422                                 header.image_height,
 423                                 GRUB_VIDEO_BLIT_FORMAT_R8G8B8);
 424       if (grub_errno != GRUB_ERR_NONE)
 425         {
 426           grub_file_close (file);
 427           return grub_errno;
 428         }
 429
 430       /* Load bitmap data.  */
 431       switch (header.image_type)
 432         {
 433           case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
 434             tga_load_truecolor_R8G8B8 (*bitmap, &header, file);
 435             break;
 436
 437           case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
 438             tga_load_truecolor_rle_R8G8B8 (*bitmap, &header, file);
 439             break;
 440         }
 441     }
 442
 443   /* If there was a loading problem, destroy bitmap.  */
 444   if (grub_errno != GRUB_ERR_NONE)
 445     {
 446       grub_video_bitmap_destroy (*bitmap);
 447       *bitmap = 0;
 448     }
 449
 450   grub_file_close (file);
 451   return grub_errno;
 452 }
 453
 454 #if defined(TGA_DEBUG)
 455 static grub_err_t
 456 grub_cmd_tgatest (struct grub_arg_list *state __attribute__ ((unused)),
 457                   int argc, char **args)
 458 {
 459   struct grub_video_bitmap *bitmap = 0;
 460
 461   if (argc != 1)
 462     return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
 463
 464   grub_video_reader_tga (&bitmap, args[0]);
 465   if (grub_errno != GRUB_ERR_NONE)
 466     return grub_errno;
 467
 468   grub_video_bitmap_destroy (bitmap);
 469
 470   return GRUB_ERR_NONE;
 471 }
 472 #endif
 473
 474 static struct grub_video_bitmap_reader tga_reader = {
 475   .extension = ".tga",
 476   .reader = grub_video_reader_tga,
 477   .next = 0
 478 };
 479
 480 GRUB_MOD_INIT(video_reader_tga)
 481 {
 482   grub_video_bitmap_reader_register (&tga_reader);
 483 #if defined(TGA_DEBUG)
 484   grub_register_command ("tgatest", grub_cmd_tgatest, GRUB_COMMAND_FLAG_BOTH,
 485                          "tgatest FILE", "Tests loading of TGA bitmap.", 0);
 486 #endif
 487 }
 488
 489 GRUB_MOD_FINI(video_reader_tga)
 490 {
 491 #if defined(TGA_DEBUG)
 492   grub_unregister_command ("tgatest");
 493 #endif
 494   grub_video_bitmap_reader_unregister (&tga_reader);
 495 }