plugins/image/bmp.cpp

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include "bmp.h"
  23
  24 #include "ifilesystem.h"
  25
  26 typedef unsigned char byte;
  27
  28 #include "imagelib.h"
  29 #include "bytestreamutils.h"
  30
  31
  32 typedef unsigned char PaletteEntry[4];
  33 typedef struct
  34 {
  35         char id[2];
  36         unsigned long fileSize;
  37         unsigned long reserved0;
  38         unsigned long bitmapDataOffset;
  39         unsigned long bitmapHeaderSize;
  40         unsigned long width;
  41         unsigned long height;
  42         unsigned short planes;
  43         unsigned short bitsPerPixel;
  44         unsigned long compression;
  45         unsigned long bitmapDataSize;
  46         unsigned long hRes;
  47         unsigned long vRes;
  48         unsigned long colors;
  49         unsigned long importantColors;
  50         PaletteEntry palette[256];
  51 } BMPHeader_t;
  52
  53 class ReadPixel8
  54 {
  55 PaletteEntry* m_palette;
  56 public:
  57 ReadPixel8( PaletteEntry* palette ) : m_palette( palette ){
  58 }
  59 void operator()( PointerInputStream& inputStream, byte*& pixbuf ) const {
  60         byte palIndex;
  61         inputStream.read( &palIndex, 1 );
  62         *pixbuf++ = m_palette[palIndex][2];
  63         *pixbuf++ = m_palette[palIndex][1];
  64         *pixbuf++ = m_palette[palIndex][0];
  65         *pixbuf++ = 0xff;
  66 }
  67 };
  68
  69 class ReadPixel16
  70 {
  71 public:
  72 void operator()( PointerInputStream& inputStream, byte*& pixbuf ) const {
  73         unsigned short shortPixel;
  74         inputStream.read( reinterpret_cast<byte*>( &shortPixel ), sizeof( unsigned short ) ); //!\todo Is this endian safe?
  75         *pixbuf++ = static_cast<byte>( shortPixel & ( 31 << 10 ) ) >> 7;
  76         *pixbuf++ = static_cast<byte>( shortPixel & ( 31 << 5 ) ) >> 2;
  77         *pixbuf++ = static_cast<byte>( shortPixel & ( 31 ) ) << 3;
  78         *pixbuf++ = 0xff;
  79 }
  80 };
  81
  82 class ReadPixel24
  83 {
  84 public:
  85 void operator()( PointerInputStream& inputStream, byte*& pixbuf ) const {
  86         byte bgr[3];
  87         inputStream.read( bgr, 3 );
  88         *pixbuf++ = bgr[2];
  89         *pixbuf++ = bgr[1];
  90         *pixbuf++ = bgr[0];
  91         *pixbuf++ = 255;
  92 }
  93 };
  94
  95 class ReadPixel32
  96 {
  97 public:
  98 void operator()( PointerInputStream& inputStream, byte*& pixbuf ) const {
  99         byte bgra[4];
 100         inputStream.read( bgra, 4 );
 101         *pixbuf++ = bgra[2];
 102         *pixbuf++ = bgra[1];
 103         *pixbuf++ = bgra[0];
 104         *pixbuf++ = bgra[3];
 105 }
 106 };
 107
 108 template<typename ReadPixel>
 109 void ReadBMP( PointerInputStream& inputStream, byte* bmpRGBA, int rows, int columns, ReadPixel readPixel ){
 110         for ( int row = rows - 1; row >= 0; row-- )
 111         {
 112                 byte* pixbuf = bmpRGBA + row * columns * 4;
 113
 114                 for ( int column = 0; column < columns; column++ )
 115                 {
 116                         readPixel( inputStream, pixbuf );
 117                 }
 118         }
 119 }
 120
 121 Image* LoadBMPBuff( PointerInputStream& inputStream, std::size_t length ){
 122         BMPHeader_t bmpHeader;
 123         inputStream.read( reinterpret_cast<byte*>( bmpHeader.id ), 2 );
 124         bmpHeader.fileSize = istream_read_uint32_le( inputStream );
 125         bmpHeader.reserved0 = istream_read_uint32_le( inputStream );
 126         bmpHeader.bitmapDataOffset = istream_read_uint32_le( inputStream );
 127         bmpHeader.bitmapHeaderSize = istream_read_uint32_le( inputStream );
 128         bmpHeader.width = istream_read_uint32_le( inputStream );
 129         bmpHeader.height = istream_read_uint32_le( inputStream );
 130         bmpHeader.planes = istream_read_uint16_le( inputStream );
 131         bmpHeader.bitsPerPixel = istream_read_uint16_le( inputStream );
 132         bmpHeader.compression = istream_read_uint32_le( inputStream );
 133         bmpHeader.bitmapDataSize = istream_read_uint32_le( inputStream );
 134         bmpHeader.hRes = istream_read_uint32_le( inputStream );
 135         bmpHeader.vRes = istream_read_uint32_le( inputStream );
 136         bmpHeader.colors = istream_read_uint32_le( inputStream );
 137         bmpHeader.importantColors = istream_read_uint32_le( inputStream );
 138
 139         if ( bmpHeader.bitsPerPixel == 8 ) {
 140                 int paletteSize = bmpHeader.colors * 4;
 141                 inputStream.read( reinterpret_cast<byte*>( bmpHeader.palette ), paletteSize );
 142         }
 143
 144         if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) {
 145                 globalErrorStream() << "LoadBMP: only Windows-style BMP files supported\n";
 146                 return 0;
 147         }
 148         if ( bmpHeader.fileSize != length ) {
 149                 globalErrorStream() << "LoadBMP: header size does not match file size (" << Unsigned( bmpHeader.fileSize ) << " vs. " << Unsigned( length ) << ")\n";
 150                 return 0;
 151         }
 152         if ( bmpHeader.compression != 0 ) {
 153                 globalErrorStream() << "LoadBMP: only uncompressed BMP files supported\n";
 154                 return 0;
 155         }
 156         if ( bmpHeader.bitsPerPixel < 8 ) {
 157                 globalErrorStream() << "LoadBMP: monochrome and 4-bit BMP files not supported\n";
 158                 return 0;
 159         }
 160
 161         int columns = bmpHeader.width;
 162         int rows = bmpHeader.height;
 163         if ( rows < 0 ) {
 164                 rows = -rows;
 165         }
 166
 167         RGBAImage* image = new RGBAImage( columns, rows );
 168
 169         switch ( bmpHeader.bitsPerPixel )
 170         {
 171         case 8:
 172                 ReadBMP( inputStream, image->getRGBAPixels(), rows, columns, ReadPixel8( bmpHeader.palette ) );
 173                 break;
 174         case 16:
 175                 ReadBMP( inputStream, image->getRGBAPixels(), rows, columns, ReadPixel16() );
 176                 break;
 177         case 24:
 178                 ReadBMP( inputStream, image->getRGBAPixels(), rows, columns, ReadPixel24() );
 179                 break;
 180         case 32:
 181                 ReadBMP( inputStream, image->getRGBAPixels(), rows, columns, ReadPixel32() );
 182                 break;
 183         default:
 184                 globalErrorStream() << "LoadBMP: illegal pixel_size '" << bmpHeader.bitsPerPixel << "'\n";
 185                 image->release();
 186                 return 0;
 187         }
 188         return image;
 189 }
 190
 191 Image* LoadBMP( ArchiveFile& file ){
 192         ScopedArchiveBuffer buffer( file );
 193         PointerInputStream inputStream( buffer.buffer );
 194         return LoadBMPBuff( inputStream, buffer.length );
 195 }