jpeg.c

   1 /*
   2         Copyright (C) 2002  Mathieu Olivier
   3
   4         This program is free software; you can redistribute it and/or
   5         modify it under the terms of the GNU General Public License
   6         as published by the Free Software Foundation; either version 2
   7         of the License, or (at your option) any later version.
   8
   9         This program is distributed in the hope that it will be useful,
  10         but WITHOUT ANY WARRANTY; without even the implied warranty of
  11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13         See the GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to:
  17
  18                 Free Software Foundation, Inc.
  19                 59 Temple Place - Suite 330
  20                 Boston, MA  02111-1307, USA
  21
  22 */
  23
  24
  25 #include "quakedef.h"
  26 #include "image.h"
  27 #include "jpeg.h"
  28
  29
  30 /*
  31 =================================================================
  32
  33   Minimal set of definitions from the JPEG lib
  34
  35   WARNING: for a matter of simplicity, several pointer types are
  36   casted to "void*", and most enumerated values are not included
  37
  38 =================================================================
  39 */
  40
  41 // jboolean is qbyte instead of int on Win32
  42 #ifdef WIN32
  43 typedef qbyte jboolean;
  44 #else
  45 typedef int jboolean;
  46 #endif
  47
  48 #define JPEG_LIB_VERSION  62  // Version 6b
  49
  50 typedef void *j_common_ptr;
  51 typedef struct jpeg_compress_struct *j_compress_ptr;
  52 typedef struct jpeg_decompress_struct *j_decompress_ptr;
  53 typedef enum
  54 {
  55         JCS_UNKNOWN,
  56         JCS_GRAYSCALE,
  57         JCS_RGB,
  58         JCS_YCbCr,
  59         JCS_CMYK,
  60         JCS_YCCK
  61 } J_COLOR_SPACE;
  62 typedef enum {JPEG_DUMMY1} J_DCT_METHOD;
  63 typedef enum {JPEG_DUMMY2} J_DITHER_MODE;
  64 typedef unsigned int JDIMENSION;
  65
  66 #define JPOOL_PERMANENT 0       // lasts until master record is destroyed
  67 #define JPOOL_IMAGE             1       // lasts until done with image/datastream
  68
  69 #define JPEG_EOI        0xD9  // EOI marker code
  70
  71 #define JMSG_STR_PARM_MAX  80
  72
  73 #define DCTSIZE2 64
  74 #define NUM_QUANT_TBLS 4
  75 #define NUM_HUFF_TBLS 4
  76 #define NUM_ARITH_TBLS 16
  77 #define MAX_COMPS_IN_SCAN 4
  78 #define C_MAX_BLOCKS_IN_MCU 10
  79 #define D_MAX_BLOCKS_IN_MCU 10
  80
  81 struct jpeg_memory_mgr
  82 {
  83   void* (*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
  84   void (*alloc_large) ();
  85   void (*alloc_sarray) ();
  86   void (*alloc_barray) ();
  87   void (*request_virt_sarray) ();
  88   void (*request_virt_barray) ();
  89   void (*realize_virt_arrays) ();
  90   void (*access_virt_sarray) ();
  91   void (*access_virt_barray) ();
  92   void (*free_pool) ();
  93   void (*self_destruct) ();
  94
  95   long max_memory_to_use;
  96   long max_alloc_chunk;
  97 };
  98
  99 struct jpeg_error_mgr
 100 {
 101         void (*error_exit) (j_common_ptr cinfo);
 102         void (*emit_message) (j_common_ptr cinfo, int msg_level);
 103         void (*output_message) (j_common_ptr cinfo);
 104         void (*format_message) (j_common_ptr cinfo, char * buffer);
 105         void (*reset_error_mgr) (j_common_ptr cinfo);
 106         int msg_code;
 107         union {
 108                 int i[8];
 109                 char s[JMSG_STR_PARM_MAX];
 110         } msg_parm;
 111         int trace_level;
 112         long num_warnings;
 113         const char * const * jpeg_message_table;
 114         int last_jpeg_message;
 115         const char * const * addon_message_table;
 116         int first_addon_message;
 117         int last_addon_message;
 118 };
 119
 120 struct jpeg_source_mgr
 121 {
 122         const qbyte *next_input_byte;
 123         size_t bytes_in_buffer;
 124
 125         void (*init_source) (j_decompress_ptr cinfo);
 126         jboolean (*fill_input_buffer) (j_decompress_ptr cinfo);
 127         void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
 128         jboolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
 129         void (*term_source) (j_decompress_ptr cinfo);
 130 };
 131
 132 struct jpeg_decompress_struct
 133 {
 134         struct jpeg_error_mgr *err;             // USED
 135         struct jpeg_memory_mgr *mem;    // USED
 136
 137         void *progress;
 138         void *client_data;
 139         jboolean is_decompressor;
 140         int global_state;
 141
 142         struct jpeg_source_mgr *src;    // USED
 143         JDIMENSION image_width;                 // USED
 144         JDIMENSION image_height;                // USED
 145
 146         int num_components;
 147         J_COLOR_SPACE jpeg_color_space;
 148         J_COLOR_SPACE out_color_space;
 149         unsigned int scale_num, scale_denom;
 150         double output_gamma;
 151         jboolean buffered_image;
 152         jboolean raw_data_out;
 153         J_DCT_METHOD dct_method;
 154         jboolean do_fancy_upsampling;
 155         jboolean do_block_smoothing;
 156         jboolean quantize_colors;
 157         J_DITHER_MODE dither_mode;
 158         jboolean two_pass_quantize;
 159         int desired_number_of_colors;
 160         jboolean enable_1pass_quant;
 161         jboolean enable_external_quant;
 162         jboolean enable_2pass_quant;
 163         JDIMENSION output_width;
 164
 165         JDIMENSION output_height;       // USED
 166
 167         int out_color_components;
 168
 169         int output_components;          // USED
 170
 171         int rec_outbuf_height;
 172         int actual_number_of_colors;
 173         void *colormap;
 174
 175         JDIMENSION output_scanline;     // USED
 176
 177         int input_scan_number;
 178         JDIMENSION input_iMCU_row;
 179         int output_scan_number;
 180         JDIMENSION output_iMCU_row;
 181         int (*coef_bits)[DCTSIZE2];
 182         void *quant_tbl_ptrs[NUM_QUANT_TBLS];
 183         void *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
 184         void *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
 185         int data_precision;
 186         void *comp_info;
 187         jboolean progressive_mode;
 188         jboolean arith_code;
 189         qbyte arith_dc_L[NUM_ARITH_TBLS];
 190         qbyte arith_dc_U[NUM_ARITH_TBLS];
 191         qbyte arith_ac_K[NUM_ARITH_TBLS];
 192         unsigned int restart_interval;
 193         jboolean saw_JFIF_marker;
 194         qbyte JFIF_major_version;
 195         qbyte JFIF_minor_version;
 196         qbyte density_unit;
 197         unsigned short X_density;
 198         unsigned short Y_density;
 199         jboolean saw_Adobe_marker;
 200         qbyte Adobe_transform;
 201         jboolean CCIR601_sampling;
 202         void *marker_list;
 203         int max_h_samp_factor;
 204         int max_v_samp_factor;
 205         int min_DCT_scaled_size;
 206         JDIMENSION total_iMCU_rows;
 207         void *sample_range_limit;
 208         int comps_in_scan;
 209         void *cur_comp_info[MAX_COMPS_IN_SCAN];
 210         JDIMENSION MCUs_per_row;
 211         JDIMENSION MCU_rows_in_scan;
 212         int blocks_in_MCU;
 213         int MCU_membership[D_MAX_BLOCKS_IN_MCU];
 214         int Ss, Se, Ah, Al;
 215         int unread_marker;
 216         void *master;
 217         void *main;
 218         void *coef;
 219         void *post;
 220         void *inputctl;
 221         void *marker;
 222         void *entropy;
 223         void *idct;
 224         void *upsample;
 225         void *cconvert;
 226         void *cquantize;
 227 };
 228
 229
 230 struct jpeg_compress_struct
 231 {
 232         struct jpeg_error_mgr *err;
 233         struct jpeg_memory_mgr *mem;
 234         void *progress;
 235         void *client_data;
 236         jboolean is_decompressor;
 237         int global_state;
 238
 239         void *dest;
 240         JDIMENSION image_width;
 241         JDIMENSION image_height;
 242         int input_components;
 243         J_COLOR_SPACE in_color_space;
 244         double input_gamma;
 245         int data_precision;
 246
 247         int num_components;
 248         J_COLOR_SPACE jpeg_color_space;
 249         void *comp_info;
 250         void *quant_tbl_ptrs[NUM_QUANT_TBLS];
 251         void *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
 252         void *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
 253         qbyte arith_dc_L[NUM_ARITH_TBLS];
 254         qbyte arith_dc_U[NUM_ARITH_TBLS];
 255         qbyte arith_ac_K[NUM_ARITH_TBLS];
 256
 257         int num_scans;
 258         const void *scan_info;
 259         jboolean raw_data_in;
 260         jboolean arith_code;
 261         jboolean optimize_coding;
 262         jboolean CCIR601_sampling;
 263         int smoothing_factor;
 264         J_DCT_METHOD dct_method;
 265
 266         unsigned int restart_interval;
 267         int restart_in_rows;
 268
 269         jboolean write_JFIF_header;
 270         qbyte JFIF_major_version;
 271         qbyte JFIF_minor_version;
 272         qbyte density_unit;
 273         unsigned short X_density;
 274         unsigned short Y_density;
 275         jboolean write_Adobe_marker;
 276         JDIMENSION next_scanline;
 277
 278         jboolean progressive_mode;
 279         int max_h_samp_factor;
 280         int max_v_samp_factor;
 281         JDIMENSION total_iMCU_rows;
 282         int comps_in_scan;
 283         void *cur_comp_info[MAX_COMPS_IN_SCAN];
 284         JDIMENSION MCUs_per_row;
 285         JDIMENSION MCU_rows_in_scan;
 286         int blocks_in_MCU;
 287         int MCU_membership[C_MAX_BLOCKS_IN_MCU];
 288         int Ss, Se, Ah, Al;
 289
 290         void *master;
 291         void *main;
 292         void *prep;
 293         void *coef;
 294         void *marker;
 295         void *cconvert;
 296         void *downsample;
 297         void *fdct;
 298         void *entropy;
 299         void *script_space;
 300         int script_space_size;
 301 };
 302
 303 struct jpeg_destination_mgr
 304 {
 305         qbyte* next_output_byte;
 306         size_t free_in_buffer;
 307
 308         void (*init_destination) (j_compress_ptr cinfo);
 309         jboolean (*empty_output_buffer) (j_compress_ptr cinfo);
 310         void (*term_destination) (j_compress_ptr cinfo);
 311 };
 312
 313
 314 /*
 315 =================================================================
 316
 317   DarkPlaces definitions
 318
 319 =================================================================
 320 */
 321
 322 // Functions exported from libjpeg
 323 #define qjpeg_create_compress(cinfo) \
 324         qjpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_compress_struct))
 325 #define qjpeg_create_decompress(cinfo) \
 326         qjpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct))
 327
 328 static void (*qjpeg_CreateCompress) (j_compress_ptr cinfo, int version, size_t structsize);
 329 static void (*qjpeg_CreateDecompress) (j_decompress_ptr cinfo, int version, size_t structsize);
 330 static void (*qjpeg_destroy_compress) (j_compress_ptr cinfo);
 331 static void (*qjpeg_destroy_decompress) (j_decompress_ptr cinfo);
 332 static void (*qjpeg_finish_compress) (j_compress_ptr cinfo);
 333 static jboolean (*qjpeg_finish_decompress) (j_decompress_ptr cinfo);
 334 static jboolean (*qjpeg_resync_to_restart) (j_decompress_ptr cinfo, int desired);
 335 static int (*qjpeg_read_header) (j_decompress_ptr cinfo, jboolean require_image);
 336 static JDIMENSION (*qjpeg_read_scanlines) (j_decompress_ptr cinfo, qbyte** scanlines, JDIMENSION max_lines);
 337 static void (*qjpeg_set_defaults) (j_compress_ptr cinfo);
 338 static void (*qjpeg_set_quality) (j_compress_ptr cinfo, int quality, jboolean force_baseline);
 339 static jboolean (*qjpeg_start_compress) (j_compress_ptr cinfo, jboolean write_all_tables);
 340 static jboolean (*qjpeg_start_decompress) (j_decompress_ptr cinfo);
 341 static struct jpeg_error_mgr* (*qjpeg_std_error) (struct jpeg_error_mgr *err);
 342 static JDIMENSION (*qjpeg_write_scanlines) (j_compress_ptr cinfo, qbyte** scanlines, JDIMENSION num_lines);
 343
 344 static dllfunction_t jpegfuncs[] =
 345 {
 346         {"jpeg_CreateCompress",         (void **) &qjpeg_CreateCompress},
 347         {"jpeg_CreateDecompress",       (void **) &qjpeg_CreateDecompress},
 348         {"jpeg_destroy_compress",       (void **) &qjpeg_destroy_compress},
 349         {"jpeg_destroy_decompress",     (void **) &qjpeg_destroy_decompress},
 350         {"jpeg_finish_compress",        (void **) &qjpeg_finish_compress},
 351         {"jpeg_finish_decompress",      (void **) &qjpeg_finish_decompress},
 352         {"jpeg_resync_to_restart",      (void **) &qjpeg_resync_to_restart},
 353         {"jpeg_read_header",            (void **) &qjpeg_read_header},
 354         {"jpeg_read_scanlines",         (void **) &qjpeg_read_scanlines},
 355         {"jpeg_set_defaults",           (void **) &qjpeg_set_defaults},
 356         {"jpeg_set_quality",            (void **) &qjpeg_set_quality},
 357         {"jpeg_start_compress",         (void **) &qjpeg_start_compress},
 358         {"jpeg_start_decompress",       (void **) &qjpeg_start_decompress},
 359         {"jpeg_std_error",                      (void **) &qjpeg_std_error},
 360         {"jpeg_write_scanlines",        (void **) &qjpeg_write_scanlines},
 361         {NULL, NULL}
 362 };
 363
 364 // Handle for JPEG DLL
 365 dllhandle_t jpeg_dll = NULL;
 366
 367 static qbyte jpeg_eoi_marker [2] = {0xFF, JPEG_EOI};
 368 static qboolean error_in_jpeg;
 369
 370 // Our own output manager for JPEG compression
 371 typedef struct
 372 {
 373         struct jpeg_destination_mgr pub;
 374
 375         qfile_t* outfile;
 376         qbyte* buffer;
 377 } my_destination_mgr;
 378 typedef my_destination_mgr* my_dest_ptr;
 379
 380
 381 /*
 382 =================================================================
 383
 384   DLL load & unload
 385
 386 =================================================================
 387 */
 388
 389 /*
 390 ====================
 391 JPEG_OpenLibrary
 392
 393 Try to load the JPEG DLL
 394 ====================
 395 */
 396 qboolean JPEG_OpenLibrary (void)
 397 {
 398         const char* dllnames [] =
 399         {
 400 #if defined(WIN64)
 401                 "libjpeg64.dll",
 402 #elif defined(WIN32)
 403                 "libjpeg.dll",
 404 #elif defined(MACOSX)
 405                 "libjpeg.62.dylib",
 406 #else
 407                 "libjpeg.so.62",
 408                 "libjpeg.so",
 409 #endif
 410                 NULL
 411         };
 412
 413         // Already loaded?
 414         if (jpeg_dll)
 415                 return true;
 416
 417         // Load the DLL
 418         if (! Sys_LoadLibrary (dllnames, &jpeg_dll, jpegfuncs))
 419         {
 420                 Con_Printf ("JPEG support disabled\n");
 421                 return false;
 422         }
 423
 424         Con_Printf ("JPEG support enabled\n");
 425         return true;
 426 }
 427
 428
 429 /*
 430 ====================
 431 JPEG_CloseLibrary
 432
 433 Unload the JPEG DLL
 434 ====================
 435 */
 436 void JPEG_CloseLibrary (void)
 437 {
 438         Sys_UnloadLibrary (&jpeg_dll);
 439 }
 440
 441
 442 /*
 443 =================================================================
 444
 445         JPEG decompression
 446
 447 =================================================================
 448 */
 449
 450 static void JPEG_Noop (j_decompress_ptr cinfo) {}
 451
 452 static jboolean JPEG_FillInputBuffer (j_decompress_ptr cinfo)
 453 {
 454     // Insert a fake EOI marker
 455     cinfo->src->next_input_byte = jpeg_eoi_marker;
 456     cinfo->src->bytes_in_buffer = 2;
 457
 458         return TRUE;
 459 }
 460
 461 static void JPEG_SkipInputData (j_decompress_ptr cinfo, long num_bytes)
 462 {
 463     if (cinfo->src->bytes_in_buffer <= (unsigned long)num_bytes)
 464         {
 465                 cinfo->src->bytes_in_buffer = 0;
 466                 return;
 467         }
 468
 469     cinfo->src->next_input_byte += num_bytes;
 470     cinfo->src->bytes_in_buffer -= num_bytes;
 471 }
 472
 473 static void JPEG_MemSrc (j_decompress_ptr cinfo, const qbyte *buffer)
 474 {
 475         cinfo->src = cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof (struct jpeg_source_mgr));
 476
 477         cinfo->src->next_input_byte = buffer;
 478         cinfo->src->bytes_in_buffer = fs_filesize;
 479
 480         cinfo->src->init_source = JPEG_Noop;
 481         cinfo->src->fill_input_buffer = JPEG_FillInputBuffer;
 482         cinfo->src->skip_input_data = JPEG_SkipInputData;
 483         cinfo->src->resync_to_restart = qjpeg_resync_to_restart; // use the default method
 484         cinfo->src->term_source = JPEG_Noop;
 485 }
 486
 487 static void JPEG_ErrorExit (j_common_ptr cinfo)
 488 {
 489         ((struct jpeg_decompress_struct*)cinfo)->err->output_message (cinfo);
 490         error_in_jpeg = true;
 491 }
 492
 493
 494 /*
 495 ====================
 496 JPEG_LoadImage
 497
 498 Load a JPEG image into a RGBA buffer
 499 ====================
 500 */
 501 qbyte* JPEG_LoadImage (const qbyte *f, int matchwidth, int matchheight)
 502 {
 503         struct jpeg_decompress_struct cinfo;
 504         struct jpeg_error_mgr jerr;
 505         qbyte *image_rgba, *scanline;
 506         unsigned int line;
 507
 508         // No DLL = no JPEGs
 509         if (!jpeg_dll)
 510                 return NULL;
 511
 512         cinfo.err = qjpeg_std_error (&jerr);
 513         qjpeg_create_decompress (&cinfo);
 514         JPEG_MemSrc (&cinfo, f);
 515         qjpeg_read_header (&cinfo, TRUE);
 516         qjpeg_start_decompress (&cinfo);
 517
 518         image_width = cinfo.image_width;
 519         image_height = cinfo.image_height;
 520
 521         if ((matchwidth && image_width != matchwidth) || (matchheight && image_height != matchheight))
 522         {
 523                 qjpeg_finish_decompress (&cinfo);
 524                 qjpeg_destroy_decompress (&cinfo);
 525                 return NULL;
 526         }
 527         if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
 528         {
 529                 Con_Printf("JPEG_LoadImage: invalid image size %ix%i\n", image_width, image_height);
 530                 return NULL;
 531         }
 532
 533         image_rgba = Mem_Alloc(tempmempool, image_width * image_height * 4);
 534         scanline = Mem_Alloc(tempmempool, image_width * cinfo.output_components);
 535         if (!image_rgba || !scanline)
 536         {
 537                 if (!image_rgba)
 538                         Mem_Free (image_rgba);
 539
 540                 Con_Printf("JPEG_LoadImage: not enough memory for %i by %i image\n", image_width, image_height);
 541                 qjpeg_finish_decompress (&cinfo);
 542                 qjpeg_destroy_decompress (&cinfo);
 543                 return NULL;
 544         }
 545
 546         // Decompress the image, line by line
 547         line = 0;
 548         while (cinfo.output_scanline < cinfo.output_height)
 549         {
 550                 qbyte *buffer_ptr;
 551                 int ind;
 552
 553                 qjpeg_read_scanlines (&cinfo, &scanline, 1);
 554
 555                 // Convert the image to RGBA
 556                 switch (cinfo.output_components)
 557                 {
 558                         // RGB images
 559                         case 3:
 560                                 buffer_ptr = &image_rgba[image_width * line * 4];
 561                                 for (ind = 0; ind < image_width * 3; ind += 3, buffer_ptr += 4)
 562                                 {
 563                                         buffer_ptr[0] = scanline[ind];
 564                                         buffer_ptr[1] = scanline[ind + 1];
 565                                         buffer_ptr[2] = scanline[ind + 2];
 566                                         buffer_ptr[3] = 255;
 567                                 }
 568                                 break;
 569
 570                         // Greyscale images (default to it, just in case)
 571                         case 1:
 572                         default:
 573                                 buffer_ptr = &image_rgba[image_width * line * 4];
 574                                 for (ind = 0; ind < image_width; ind++, buffer_ptr += 4)
 575                                 {
 576                                         buffer_ptr[0] = scanline[ind];
 577                                         buffer_ptr[1] = scanline[ind];
 578                                         buffer_ptr[2] = scanline[ind];
 579                                         buffer_ptr[3] = 255;
 580                                 }
 581                 }
 582
 583                 line++;
 584         }
 585         Mem_Free (scanline);
 586
 587         qjpeg_finish_decompress (&cinfo);
 588         qjpeg_destroy_decompress (&cinfo);
 589
 590         return image_rgba;
 591 }
 592
 593
 594 /*
 595 =================================================================
 596
 597   JPEG compression
 598
 599 =================================================================
 600 */
 601
 602 #define JPEG_OUTPUT_BUF_SIZE 4096
 603 static void JPEG_InitDestination (j_compress_ptr cinfo)
 604 {
 605         my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
 606         dest->buffer = (qbyte*)cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_IMAGE, JPEG_OUTPUT_BUF_SIZE * sizeof(qbyte));
 607         dest->pub.next_output_byte = dest->buffer;
 608         dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
 609 }
 610
 611 static jboolean JPEG_EmptyOutputBuffer (j_compress_ptr cinfo)
 612 {
 613         my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
 614
 615         if (FS_Write (dest->outfile, dest->buffer, JPEG_OUTPUT_BUF_SIZE) != (size_t) JPEG_OUTPUT_BUF_SIZE)
 616         {
 617                 error_in_jpeg = true;
 618                 return false;
 619         }
 620
 621         dest->pub.next_output_byte = dest->buffer;
 622         dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
 623         return true;
 624 }
 625
 626 static void JPEG_TermDestination (j_compress_ptr cinfo)
 627 {
 628         my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
 629         size_t datacount = JPEG_OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
 630
 631         // Write any data remaining in the buffer
 632         if (datacount > 0)
 633                 if (FS_Write (dest->outfile, dest->buffer, datacount) != (fs_offset_t)datacount)
 634                         error_in_jpeg = true;
 635 }
 636
 637 static void JPEG_MemDest (j_compress_ptr cinfo, qfile_t* outfile)
 638 {
 639         my_dest_ptr dest;
 640
 641         // First time for this JPEG object?
 642         if (cinfo->dest == NULL)
 643                 cinfo->dest = (struct jpeg_destination_mgr *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_destination_mgr));
 644
 645         dest = (my_dest_ptr)cinfo->dest;
 646         dest->pub.init_destination = JPEG_InitDestination;
 647         dest->pub.empty_output_buffer = JPEG_EmptyOutputBuffer;
 648         dest->pub.term_destination = JPEG_TermDestination;
 649         dest->outfile = outfile;
 650 }
 651
 652
 653 /*
 654 ====================
 655 JPEG_SaveImage_preflipped
 656
 657 Save a preflipped JPEG image to a file
 658 ====================
 659 */
 660 qboolean JPEG_SaveImage_preflipped (const char *filename, int width, int height, qbyte *data)
 661 {
 662         struct jpeg_compress_struct cinfo;
 663         struct jpeg_error_mgr jerr;
 664         qbyte *scanline;
 665         unsigned int offset, linesize;
 666         qfile_t* file;
 667
 668         // No DLL = no JPEGs
 669         if (!jpeg_dll)
 670         {
 671                 Con_Print("You need the libjpeg library to save JPEG images\n");
 672                 return false;
 673         }
 674
 675         // Open the file
 676         file = FS_Open (filename, "wb", true, false);
 677         if (!file)
 678                 return false;
 679
 680         cinfo.err = qjpeg_std_error (&jerr);
 681         cinfo.err->error_exit = JPEG_ErrorExit;
 682         error_in_jpeg = false;
 683
 684         qjpeg_create_compress (&cinfo);
 685         JPEG_MemDest (&cinfo, file);
 686
 687         // Set the parameters for compression
 688         cinfo.image_width = width;
 689         cinfo.image_height = height;
 690         cinfo.in_color_space = JCS_RGB;
 691         cinfo.input_components = 3;
 692         qjpeg_set_defaults (&cinfo);
 693         qjpeg_set_quality (&cinfo, scr_screenshot_jpeg_quality.value * 100, TRUE);
 694         qjpeg_start_compress (&cinfo, true);
 695
 696         // Compress each scanline
 697         linesize = cinfo.image_width * 3;
 698         offset = linesize * (cinfo.image_height - 1);
 699         while (cinfo.next_scanline < cinfo.image_height)
 700         {
 701                 scanline = &data[offset - cinfo.next_scanline * linesize];
 702
 703                 qjpeg_write_scanlines (&cinfo, &scanline, 1);
 704                 if (error_in_jpeg)
 705                         break;
 706         }
 707
 708         qjpeg_finish_compress (&cinfo);
 709         qjpeg_destroy_compress (&cinfo);
 710
 711         FS_Close (file);
 712         return true;
 713 }