nel/src/misc/bitmap_jpeg.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2014  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program 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 Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21
  22 #include "nel/misc/bitmap.h"
  23
  24 #ifdef USE_JPEG
  25 #define XMD_H
  26 #undef FAR
  27 #include "nel/misc/stream.h"
  28 #include "nel/misc/file.h"
  29 #include <csetjmp>
  30 extern "C"
  31 {
  32         #ifdef NL_COMP_MINGW
  33         #       define HAVE_BOOLEAN
  34         #endif
  35         #include <jpeglib.h>
  36 }
  37 #endif
  38
  39 using namespace std;
  40
  41 #ifdef DEBUG_NEW
  42         #define new DEBUG_NEW
  43 #endif
  44
  45 namespace NLMISC
  46 {
  47
  48 #ifdef USE_JPEG
  49
  50 static NLMISC::IStream *JPGStream = NULL;
  51 static const uint32 JPGBufferSize = 4096;
  52 static uint32 JPGStreamSize = 0;
  53 static char JPGBuffer[JPGBufferSize];
  54
  55 struct my_error_mgr
  56 {
  57         struct jpeg_error_mgr pub;
  58         jmp_buf setjmp_buffer;
  59 };
  60
  61 void my_error_exit(j_common_ptr cinfo)
  62 {
  63         my_error_mgr *myerr = (my_error_mgr *) cinfo->err;
  64
  65         nlwarning("error while processing JPEG image");
  66
  67         longjmp(myerr->setjmp_buffer, 1);
  68 }
  69
  70 static void jpgDecompressInit(j_decompress_ptr cinfo)
  71 {
  72         // get stream size if possible
  73         if (JPGStream->seek(0, IStream::end))
  74                 JPGStreamSize = JPGStream->getPos();
  75         else
  76                 nlwarning("can't get JPEG stream size");
  77
  78         // reset current position to the beginning
  79         JPGStream->seek(0, IStream::begin);
  80
  81         cinfo->src->next_input_byte = (unsigned char *)JPGBuffer;
  82         cinfo->src->bytes_in_buffer = 0;
  83 }
  84
  85 static boolean jpgDecompressFill(j_decompress_ptr cinfo)
  86 {
  87         uint length = std::min(JPGBufferSize, JPGStreamSize - JPGStream->getPos());
  88
  89         try
  90         {
  91                 JPGStream->serialBuffer((uint8*) JPGBuffer, length);
  92         }
  93         catch(...)
  94         {
  95                 nlwarning("error while reading JPEG image");
  96                 cinfo->src->next_input_byte = (unsigned char *)JPGBuffer;
  97                 cinfo->src->bytes_in_buffer = 0;
  98                 return FALSE;
  99         }
 100
 101         cinfo->src->next_input_byte = (unsigned char *)JPGBuffer;
 102         cinfo->src->bytes_in_buffer = length;
 103         return TRUE;
 104 }
 105
 106 static void jpgDecompressSkip(j_decompress_ptr cinfo, long num_bytes)
 107 {
 108         if (num_bytes > 0)
 109         {
 110                 while (num_bytes > (long) cinfo->src->bytes_in_buffer)
 111                 {
 112                         num_bytes -= (long) cinfo->src->bytes_in_buffer;
 113                         jpgDecompressFill(cinfo);
 114                 }
 115
 116                 cinfo->src->next_input_byte += (size_t) num_bytes;
 117                 cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
 118         }
 119 }
 120
 121 static void jpgDecompressTerm(j_decompress_ptr /* cinfo */)
 122 {
 123 }
 124
 125 static jpeg_source_mgr jpgSourceManager = { NULL, 0,
 126         jpgDecompressInit, jpgDecompressFill, jpgDecompressSkip, jpeg_resync_to_restart, jpgDecompressTerm };
 127
 128 /*-------------------------------------------------------------------*\
 129                                                         readJPG
 130 \*-------------------------------------------------------------------*/
 131 uint8 CBitmap::readJPG( NLMISC::IStream &f )
 132 {
 133         if(!f.isReading()) return false;
 134
 135         struct jpeg_decompress_struct cinfo;
 136
 137         // set up errors manager
 138         struct my_error_mgr jerr;
 139         cinfo.err = jpeg_std_error(&jerr.pub);
 140         jerr.pub.error_exit = my_error_exit;
 141
 142         if (setjmp(jerr.setjmp_buffer))
 143         {
 144                 jpeg_destroy_decompress(&cinfo);
 145                 nlwarning("failed to setjump");
 146                 return 0;
 147         }
 148
 149         // set the stream to read from
 150         JPGStream = &f;
 151
 152         // init decompress
 153         jpeg_create_decompress(&cinfo);
 154         cinfo.src = &jpgSourceManager;
 155
 156         // read header of image
 157         if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK)
 158         {
 159                 jpeg_destroy_decompress(&cinfo);
 160                 nlwarning("failed to read header");
 161                 return 0;
 162         }
 163
 164         uint dstChannels, srcChannels;
 165
 166         if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
 167         {
 168                 dstChannels = 1;
 169                 srcChannels = 1;
 170                 resize (cinfo.image_width, cinfo.image_height, _LoadGrayscaleAsAlpha ? Alpha : Luminance);
 171         }
 172         else
 173         {
 174                 // force conversion of color spaces in RGB
 175                 dstChannels = 4;
 176                 srcChannels = 3;
 177                 cinfo.out_color_space = JCS_RGB;
 178                 resize (cinfo.image_width, cinfo.image_height, RGBA);
 179         }
 180
 181         // start decompression of image data
 182         if (!jpeg_start_decompress(&cinfo))
 183         {
 184                 jpeg_destroy_decompress(&cinfo);
 185                 nlwarning("failed to start decompressing");
 186                 return 0;
 187         }
 188
 189         JSAMPARRAY buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo,
 190                 JPOOL_IMAGE, cinfo.output_width * cinfo.output_components, 1);
 191
 192         uint i, j;
 193
 194         while (cinfo.output_scanline < cinfo.output_height)
 195         {
 196                 const uint offset = cinfo.output_scanline * _Width * dstChannels;
 197
 198                 if (jpeg_read_scanlines(&cinfo, buffer, 1) != 1)
 199                 {
 200                         nlwarning("failed to read scanline");
 201                         break;
 202                 }
 203
 204                 for (i = 0; i < _Width; i++)
 205                 {
 206                         for (j = 0; j < srcChannels; ++j)
 207                                 _Data[0][offset+i*dstChannels+j] = buffer[0][i*srcChannels+j];
 208
 209                         if (PixelFormat == RGBA)
 210                                 _Data[0][offset+i*dstChannels+j] = 255;
 211                 }
 212         }
 213
 214         if (!jpeg_finish_decompress(&cinfo))
 215                 nlwarning("failed to finish decompressing");
 216
 217         jpeg_destroy_decompress(&cinfo);
 218
 219         JPGStream = NULL;
 220
 221         return uint8(srcChannels * 8);
 222 }
 223
 224 static void jpgCompressInit(j_compress_ptr cinfo)
 225 {
 226         cinfo->dest->next_output_byte = (unsigned char *)JPGBuffer;
 227         cinfo->dest->free_in_buffer = JPGBufferSize;
 228 }
 229
 230 static boolean jpgCompressEmpty(j_compress_ptr cinfo)
 231 {
 232         JPGStream->serialBuffer((uint8*) JPGBuffer, JPGBufferSize);
 233         cinfo->dest->next_output_byte = (unsigned char *)JPGBuffer;
 234         cinfo->dest->free_in_buffer = JPGBufferSize;
 235         return TRUE;
 236 }
 237
 238 static void jpgCompressTerm(j_compress_ptr cinfo)
 239 {
 240         if(JPGBufferSize - cinfo->dest->free_in_buffer > 0)
 241                 JPGStream->serialBuffer((uint8*) JPGBuffer, (uint)(JPGBufferSize - cinfo->dest->free_in_buffer));
 242 }
 243
 244 static jpeg_destination_mgr jpgDestinationManager = { 0, 0,
 245         jpgCompressInit, jpgCompressEmpty, jpgCompressTerm };
 246
 247 /*-------------------------------------------------------------------*\
 248                                                         writeJPG
 249 \*-------------------------------------------------------------------*/
 250 bool CBitmap::writeJPG( NLMISC::IStream &f, uint8 quality)
 251 {
 252         if (f.isReading()) return false;
 253
 254         if (PixelFormat > AlphaLuminance) return false;
 255         if (!_Width || !_Height) return false;
 256
 257         struct jpeg_compress_struct cinfo;
 258
 259         // set up errors manager
 260         struct my_error_mgr jerr;
 261         cinfo.err = jpeg_std_error(&jerr.pub);
 262         jerr.pub.error_exit = my_error_exit;
 263
 264         if (setjmp(jerr.setjmp_buffer))
 265         {
 266                 jpeg_destroy_compress(&cinfo);
 267                 nlwarning("failed to setjump");
 268                 return false;
 269         }
 270
 271         // set the stream to write to
 272         JPGStream = &f;
 273
 274         // init compress
 275         jpeg_create_compress(&cinfo);
 276
 277         uint srcChannels, dstChannels;
 278
 279         if (PixelFormat == RGBA)
 280         {
 281                 srcChannels = 4;
 282                 dstChannels = cinfo.input_components = 3;
 283                 cinfo.in_color_space = JCS_RGB;
 284         }
 285         else
 286         {
 287                 srcChannels = PixelFormat == AlphaLuminance ? 2:1;
 288                 dstChannels = cinfo.input_components = 1;
 289                 cinfo.in_color_space = JCS_GRAYSCALE;
 290         }
 291
 292         cinfo.image_width = _Width;
 293         cinfo.image_height = _Height;
 294         cinfo.dest = &jpgDestinationManager;
 295
 296         // set default compression parameters
 297         jpeg_set_defaults(&cinfo);
 298
 299         // set image quality
 300         jpeg_set_quality(&cinfo, quality, TRUE);
 301
 302         // start to compress image
 303         jpeg_start_compress(&cinfo, TRUE);
 304
 305         JSAMPROW row_pointer[1];
 306         row_pointer[0] = new uint8[_Width*dstChannels];
 307
 308         uint i, j;
 309
 310         while (cinfo.next_scanline < cinfo.image_height)
 311         {
 312                 const uint offset = cinfo.next_scanline * _Width * srcChannels;
 313
 314                 for (i = 0; i < _Width; ++i)
 315                 {
 316                         for (j = 0; j < dstChannels; ++j)
 317                         {
 318                                 row_pointer[0][i*dstChannels+j] = (uint8) _Data[0][offset + i*srcChannels+j];
 319                         }
 320                 }
 321
 322                 // write image scanline
 323                 if (jpeg_write_scanlines(&cinfo, row_pointer, 1) != 1)
 324                 {
 325                         nlwarning("failed to write scanline");
 326                         break;
 327                 }
 328         }
 329
 330         jpeg_finish_compress(&cinfo);
 331         jpeg_destroy_compress(&cinfo);
 332
 333         delete row_pointer[0];
 334         row_pointer[0] = NULL;
 335         JPGStream = NULL;
 336
 337         return true;
 338 }
 339
 340 #else
 341
 342 bool CBitmap::writeJPG( NLMISC::IStream &/* f */, uint8 /* quality */)
 343 {
 344         nlwarning ("You must compile NLMISC with USE_JPEG if you want jpeg support");
 345         return false;
 346 }
 347
 348 uint8 CBitmap::readJPG( NLMISC::IStream &/* f */)
 349 {
 350         nlwarning ("You must compile NLMISC with USE_JPEG if you want jpeg support");
 351         return 0;
 352 }
 353
 354 #endif
 355
 356 }