lib/jpeg.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <memory.h>
   4 #include "jpeg.h"
   5 #include "../config.h"
   6
   7 #ifdef HAVE_JPEGLIB
   8 #define HAVE_BOOLEAN
   9 #include <jpeglib.h>
  10
  11 #define OUTBUFFER_SIZE 0x8000
  12
  13 static FILE*fi;
  14 static JOCTET * buffer;
  15 static unsigned char*dest;
  16 static int len;
  17 static int destlen;
  18 static unsigned char*data;
  19 static int pos;
  20 static int size;
  21
  22 static void file_init_destination(j_compress_ptr cinfo)
  23 {
  24   struct jpeg_destination_mgr*dmgr =
  25       (struct jpeg_destination_mgr*)(cinfo->dest);
  26   buffer = (JOCTET*)malloc(OUTBUFFER_SIZE);
  27   if(!buffer) {
  28       perror("malloc");
  29       printf("Out of memory!\n");
  30       exit(1);
  31   }
  32   dmgr->next_output_byte = buffer;
  33   dmgr->free_in_buffer = OUTBUFFER_SIZE;
  34 }
  35
  36 static boolean file_empty_output_buffer(j_compress_ptr cinfo)
  37 {
  38   struct jpeg_destination_mgr*dmgr =
  39       (struct jpeg_destination_mgr*)(cinfo->dest);
  40   if(fi)
  41     fwrite(buffer, OUTBUFFER_SIZE, 1, fi);
  42   dmgr->next_output_byte = buffer;
  43   dmgr->free_in_buffer = OUTBUFFER_SIZE;
  44   return 1;
  45 }
  46
  47 static void file_term_destination(j_compress_ptr cinfo)
  48 { struct jpeg_destination_mgr*dmgr =
  49       (struct jpeg_destination_mgr*)(cinfo->dest);
  50   if(fi)
  51     fwrite(buffer, OUTBUFFER_SIZE-dmgr->free_in_buffer, 1, fi);
  52   free(buffer);
  53   buffer = 0;
  54   dmgr->free_in_buffer = 0;
  55 }
  56
  57 static void mem_init_destination(j_compress_ptr cinfo)
  58 {
  59   struct jpeg_destination_mgr*dmgr =
  60       (struct jpeg_destination_mgr*)(cinfo->dest);
  61   dmgr->next_output_byte = dest;
  62   dmgr->free_in_buffer = destlen;
  63 }
  64
  65 static boolean mem_empty_output_buffer(j_compress_ptr cinfo)
  66 {
  67     printf("jpeg mem overflow!\n");
  68     exit(1);
  69 }
  70
  71 static void mem_term_destination(j_compress_ptr cinfo)
  72 {
  73   struct jpeg_destination_mgr*dmgr =
  74       (struct jpeg_destination_mgr*)(cinfo->dest);
  75   len = destlen - dmgr->free_in_buffer;
  76   dmgr->free_in_buffer = 0;
  77 }
  78
  79 int jpeg_save(unsigned char*data, int width, int height, int quality, const char*filename)
  80 {
  81   struct jpeg_destination_mgr mgr;
  82   struct jpeg_compress_struct cinfo;
  83   struct jpeg_error_mgr jerr;
  84   int t;
  85
  86   if(filename)
  87     fi = fopen(filename, "wb");
  88   else
  89     fi = 0;
  90
  91   memset(&cinfo, 0, sizeof(cinfo));
  92   memset(&jerr, 0, sizeof(jerr));
  93   memset(&mgr, 0, sizeof(mgr));
  94   cinfo.err = jpeg_std_error(&jerr);
  95   jpeg_create_compress(&cinfo);
  96
  97   mgr.init_destination = file_init_destination;
  98   mgr.empty_output_buffer = file_empty_output_buffer;
  99   mgr.term_destination = file_term_destination;
 100   cinfo.dest = &mgr;
 101
 102   // init compression
 103
 104   cinfo.image_width  = width;
 105   cinfo.image_height = height;
 106   cinfo.input_components = 3;
 107   cinfo.in_color_space = JCS_RGB;
 108   jpeg_set_defaults(&cinfo);
 109   jpeg_set_quality(&cinfo,quality,TRUE);
 110
 111   //jpeg_write_tables(&cinfo);
 112   //jpeg_suppress_tables(&cinfo, TRUE);
 113   jpeg_start_compress(&cinfo, FALSE);
 114
 115   for(t=0;t<height;t++) {
 116     unsigned char*data2 = &data[width*3*t];
 117     jpeg_write_scanlines(&cinfo, &data2, 1);
 118   }
 119   jpeg_finish_compress(&cinfo);
 120
 121   if(fi)
 122     fclose(fi);
 123   jpeg_destroy_compress(&cinfo);
 124   return 1;
 125 }
 126
 127 int jpeg_save_to_file(unsigned char*data, int width, int height, int quality, FILE*_fi)
 128 {
 129   struct jpeg_destination_mgr mgr;
 130   struct jpeg_compress_struct cinfo;
 131   struct jpeg_error_mgr jerr;
 132   int t;
 133
 134   fi = _fi;
 135
 136   memset(&cinfo, 0, sizeof(cinfo));
 137   memset(&jerr, 0, sizeof(jerr));
 138   memset(&mgr, 0, sizeof(mgr));
 139   cinfo.err = jpeg_std_error(&jerr);
 140   jpeg_create_compress(&cinfo);
 141
 142   mgr.init_destination = file_init_destination;
 143   mgr.empty_output_buffer = file_empty_output_buffer;
 144   mgr.term_destination = file_term_destination;
 145   cinfo.dest = &mgr;
 146
 147   // init compression
 148
 149   cinfo.image_width  = width;
 150   cinfo.image_height = height;
 151   cinfo.input_components = 3;
 152   cinfo.in_color_space = JCS_RGB;
 153   jpeg_set_defaults(&cinfo);
 154   cinfo.dct_method = JDCT_IFAST;
 155   jpeg_set_quality(&cinfo,quality,TRUE);
 156
 157   //jpeg_write_tables(&cinfo);
 158   //jpeg_suppress_tables(&cinfo, TRUE);
 159   jpeg_start_compress(&cinfo, FALSE);
 160
 161   for(t=0;t<height;t++) {
 162     unsigned char*data2 = &data[width*3*t];
 163     jpeg_write_scanlines(&cinfo, &data2, 1);
 164   }
 165   jpeg_finish_compress(&cinfo);
 166   jpeg_destroy_compress(&cinfo);
 167   return 1;
 168 }
 169
 170 int jpeg_save_to_mem(unsigned char*data, int width, int height, int quality, unsigned char*_dest, int _destlen)
 171 {
 172   struct jpeg_destination_mgr mgr;
 173   struct jpeg_compress_struct cinfo;
 174   struct jpeg_error_mgr jerr;
 175   int t;
 176
 177   memset(&cinfo, 0, sizeof(cinfo));
 178   memset(&jerr, 0, sizeof(jerr));
 179   memset(&mgr, 0, sizeof(mgr));
 180   cinfo.err = jpeg_std_error(&jerr);
 181   jpeg_create_compress(&cinfo);
 182
 183   dest = _dest;
 184   len = 0;
 185   destlen = _destlen;
 186
 187   mgr.init_destination = mem_init_destination;
 188   mgr.empty_output_buffer = mem_empty_output_buffer;
 189   mgr.term_destination = mem_term_destination;
 190   cinfo.dest = &mgr;
 191
 192   // init compression
 193
 194   cinfo.image_width  = width;
 195   cinfo.image_height = height;
 196   cinfo.input_components = 3;
 197   cinfo.in_color_space = JCS_RGB;
 198   jpeg_set_defaults(&cinfo);
 199   cinfo.dct_method = JDCT_IFAST;
 200   jpeg_set_quality(&cinfo,quality,TRUE);
 201
 202   jpeg_start_compress(&cinfo, FALSE);
 203   for(t=0;t<height;t++) {
 204     unsigned char*data2 = &data[width*3*t];
 205     jpeg_write_scanlines(&cinfo, &data2, 1);
 206   }
 207   jpeg_finish_compress(&cinfo);
 208   jpeg_destroy_compress(&cinfo);
 209   return len;
 210 }
 211
 212 void mem_init_source (j_decompress_ptr cinfo)
 213 {
 214     struct jpeg_source_mgr* mgr = cinfo->src;
 215     mgr->next_input_byte = data;
 216     mgr->bytes_in_buffer = size;
 217     //printf("init %d\n", size - mgr->bytes_in_buffer);
 218 }
 219
 220 boolean mem_fill_input_buffer (j_decompress_ptr cinfo)
 221 {
 222     struct jpeg_source_mgr* mgr = cinfo->src;
 223     printf("fill %d\n", size - mgr->bytes_in_buffer);
 224     return 0;
 225 }
 226
 227 void mem_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 228 {
 229     struct jpeg_source_mgr* mgr = cinfo->src;
 230     printf("skip %d +%d\n", size - mgr->bytes_in_buffer, num_bytes);
 231     if(num_bytes<=0)
 232         return;
 233     mgr->next_input_byte += num_bytes;
 234     mgr->bytes_in_buffer -= num_bytes;
 235 }
 236
 237 boolean mem_resync_to_restart (j_decompress_ptr cinfo, int desired)
 238 {
 239     struct jpeg_source_mgr* mgr = cinfo->src;
 240     printf("resync %d\n", size - mgr->bytes_in_buffer);
 241     mgr->next_input_byte = data;
 242     mgr->bytes_in_buffer = size;
 243     return 1;
 244 }
 245
 246 void mem_term_source (j_decompress_ptr cinfo)
 247 {
 248     struct jpeg_source_mgr* mgr = cinfo->src;
 249     //printf("term %d\n", size - mgr->bytes_in_buffer);
 250 }
 251
 252 int jpeg_load_from_mem(unsigned char*_data, int _size, unsigned char*dest, int width, int height)
 253 {
 254     struct jpeg_decompress_struct cinfo;
 255     struct jpeg_error_mgr jerr;
 256     struct jpeg_source_mgr mgr;
 257     int y,x;
 258
 259     data = _data;
 260     size = _size;
 261
 262     jpeg_create_decompress(&cinfo);
 263
 264     mgr.next_input_byte = data;
 265     mgr.bytes_in_buffer = size;
 266     mgr.init_source        =mem_init_source ;
 267     mgr.fill_input_buffer  =mem_fill_input_buffer ;
 268     mgr.skip_input_data    =mem_skip_input_data ;
 269     mgr.resync_to_restart  =mem_resync_to_restart ;
 270     mgr.term_source        =mem_term_source ;
 271
 272     cinfo.err = jpeg_std_error(&jerr);
 273     cinfo.src = &mgr;
 274
 275     jpeg_read_header(&cinfo, TRUE);
 276     jpeg_start_decompress(&cinfo);
 277
 278     for(y=0;y<height;y++) {
 279         unsigned char*j = &dest[width*y*3];
 280         jpeg_read_scanlines(&cinfo,&j,1);
 281     }
 282
 283     jpeg_finish_decompress(&cinfo);
 284     jpeg_destroy_decompress(&cinfo);
 285     return 1;
 286 }
 287
 288 typedef struct _RGBA {
 289     unsigned char a,r,g,b;
 290 } RGBA;
 291
 292 typedef unsigned char U8;
 293
 294 int jpeg_load(const char*filename, unsigned char**dest, int*_width, int*_height)
 295 {
 296     struct jpeg_decompress_struct cinfo;
 297     struct jpeg_error_mgr jerr;
 298     struct jpeg_source_mgr mgr;
 299
 300     FILE*fi = fopen(filename, "rb");
 301     if(!fi) {
 302         fprintf(stderr, "Couldn't open file %s\n", filename);
 303         return 0;
 304     }
 305
 306     cinfo.err = jpeg_std_error(&jerr);
 307     jpeg_create_decompress(&cinfo);
 308     jpeg_stdio_src(&cinfo, fi);
 309     jpeg_read_header(&cinfo, TRUE);
 310     jpeg_start_decompress(&cinfo);
 311
 312     U8*scanline = (U8 *)malloc(4 * cinfo.output_width);
 313
 314     int width = *_width = cinfo.output_width;
 315     int height = *_height = cinfo.output_height;
 316     *dest = (unsigned char*)malloc(width*height*4);
 317
 318     int y;
 319     for (y=0;y<height;y++) {
 320         int x;
 321         U8 *js = scanline;
 322         RGBA*line = &((RGBA*)(*dest))[y*width];
 323
 324         jpeg_read_scanlines(&cinfo, &js, 1);
 325         if (cinfo.out_color_space == JCS_GRAYSCALE) {
 326             for (x = 0; x < width; x++) {
 327                 line[x].a = 255;
 328                 line[x].r = line[x].g = line[x].b = js[x];
 329             }
 330         } else if (cinfo.out_color_space == JCS_RGB) {
 331             for (x = width - 1; x >= 0; x--) {
 332                 line[x].a = 255;
 333                 line[x].r = js[x*3+0];
 334                 line[x].g = js[x*3+1];
 335                 line[x].b = js[x*3+2];
 336             }
 337         } else if (cinfo.out_color_space == JCS_YCCK) {
 338             fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
 339             return 0;
 340         } else if (cinfo.out_color_space == JCS_YCbCr) {
 341             for (x = 0; x < width; x++) {
 342                 int y = js[x * 3 + 0];
 343                 int u = js[x * 3 + 1];
 344                 int v = js[x * 3 + 1];
 345                 line[x].a = 255;
 346                 line[x].r = y + ((360 * (v - 128)) >> 8);
 347                 line[x].g = y - ((88 * (u - 128) + 183 * (v - 128)) >> 8);
 348                 line[x].b = y + ((455 * (u - 128)) >> 8);
 349             }
 350         } else if (cinfo.out_color_space == JCS_CMYK) {
 351             for (x = 0; x < width; x++) {
 352                 int white = 255 - js[x * 4 + 3];
 353                 line[x].a = 255;
 354                 line[x].r = white - ((js[x * 4] * white) >> 8);
 355                 line[x].g = white - ((js[x * 4 + 1] * white) >> 8);
 356                 line[x].b = white - ((js[x * 4 + 2] * white) >> 8);
 357             }
 358         }
 359     }
 360
 361     free(scanline);
 362
 363     jpeg_finish_decompress(&cinfo);
 364     jpeg_destroy_decompress(&cinfo);
 365     return 1;
 366 }
 367
 368 #else
 369
 370 int jpeg_save(unsigned char*data, int width, int height, int quality, const char*filename)
 371 {
 372     fprintf(stderr, "jpeg_save: No JPEG support compiled in\n");
 373     return 0;
 374 }
 375 int jpeg_save_to_file(unsigned char*data, int width, int height, int quality, FILE*fi)
 376 {
 377     fprintf(stderr, "jpeg_save_to_file: No JPEG support compiled in\n");
 378     return 0;
 379 }
 380 int jpeg_save_to_mem(unsigned char*data, int width, int height, int quality, unsigned char*dest, int destsize)
 381 {
 382     fprintf(stderr, "jpeg_save_tomem: No JPEG support compiled in\n");
 383     return 0;
 384 }
 385 int jpeg_load_from_mem(unsigned char*_data, int size, unsigned char*dest, int width, int height)
 386 {
 387     fprintf(stderr, "jpeg_load_from_mem: No JPEG support compiled in\n");
 388     return 0;
 389 }
 390 int jpeg_load(const char*filename, unsigned char**dest, int*_width, int*_height)
 391 {
 392     fprintf(stderr, "jpeg_load: No JPEG support compiled in\n");
 393     return 0;
 394 }
 395
 396 #endif