Dependencies/libjpeg/jdatadst.c

   1 /*
   2  * jdatadst.c
   3  *
   4  * Copyright (C) 1994-1996, Thomas G. Lane.
   5  * Modified 2009 by Guido Vollbeding.
   6  * This file is part of the Independent JPEG Group's software.
   7  * For conditions of distribution and use, see the accompanying README file.
   8  *
   9  * This file contains compression data destination routines for the case of
  10  * emitting JPEG data to memory or to a file (or any stdio stream).
  11  * While these routines are sufficient for most applications,
  12  * some will want to use a different destination manager.
  13  * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
  14  * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
  15  * than 8 bits on your machine, you may need to do some tweaking.
  16  */
  17
  18 /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
  19 #include "jinclude.h"
  20 #include "jpeglib.h"
  21 #include "jerror.h"
  22
  23 #ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
  24 extern void * malloc JPP((size_t size));
  25 extern void free JPP((void *ptr));
  26 #endif
  27
  28
  29 /* Expanded data destination object for stdio output */
  30
  31 typedef struct {
  32   struct jpeg_destination_mgr pub; /* public fields */
  33
  34   FILE * outfile;               /* target stream */
  35   JOCTET * buffer;              /* start of buffer */
  36 } my_destination_mgr;
  37
  38 typedef my_destination_mgr * my_dest_ptr;
  39
  40 #define OUTPUT_BUF_SIZE  4096   /* choose an efficiently fwrite'able size */
  41
  42
  43 /* Expanded data destination object for memory output */
  44
  45 typedef struct {
  46   struct jpeg_destination_mgr pub; /* public fields */
  47
  48   unsigned char ** outbuffer;   /* target buffer */
  49   unsigned long * outsize;
  50   unsigned char * newbuffer;    /* newly allocated buffer */
  51   JOCTET * buffer;              /* start of buffer */
  52   size_t bufsize;
  53 } my_mem_destination_mgr;
  54
  55 typedef my_mem_destination_mgr * my_mem_dest_ptr;
  56
  57
  58 /*
  59  * Initialize destination --- called by jpeg_start_compress
  60  * before any data is actually written.
  61  */
  62
  63 METHODDEF(void)
  64 init_destination (j_compress_ptr cinfo)
  65 {
  66   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  67
  68   /* Allocate the output buffer --- it will be released when done with image */
  69   dest->buffer = (JOCTET *)
  70       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  71                                   OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
  72
  73   dest->pub.next_output_byte = dest->buffer;
  74   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
  75 }
  76
  77 METHODDEF(void)
  78 init_mem_destination (j_compress_ptr cinfo)
  79 {
  80   /* no work necessary here */
  81 }
  82
  83
  84 /*
  85  * Empty the output buffer --- called whenever buffer fills up.
  86  *
  87  * In typical applications, this should write the entire output buffer
  88  * (ignoring the current state of next_output_byte & free_in_buffer),
  89  * reset the pointer & count to the start of the buffer, and return TRUE
  90  * indicating that the buffer has been dumped.
  91  *
  92  * In applications that need to be able to suspend compression due to output
  93  * overrun, a FALSE return indicates that the buffer cannot be emptied now.
  94  * In this situation, the compressor will return to its caller (possibly with
  95  * an indication that it has not accepted all the supplied scanlines).  The
  96  * application should resume compression after it has made more room in the
  97  * output buffer.  Note that there are substantial restrictions on the use of
  98  * suspension --- see the documentation.
  99  *
 100  * When suspending, the compressor will back up to a convenient restart point
 101  * (typically the start of the current MCU). next_output_byte & free_in_buffer
 102  * indicate where the restart point will be if the current call returns FALSE.
 103  * Data beyond this point will be regenerated after resumption, so do not
 104  * write it out when emptying the buffer externally.
 105  */
 106
 107 METHODDEF(boolean)
 108 empty_output_buffer (j_compress_ptr cinfo)
 109 {
 110   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
 111
 112   if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
 113       (size_t) OUTPUT_BUF_SIZE)
 114     ERREXIT(cinfo, JERR_FILE_WRITE);
 115
 116   dest->pub.next_output_byte = dest->buffer;
 117   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
 118
 119   return TRUE;
 120 }
 121
 122 METHODDEF(boolean)
 123 empty_mem_output_buffer (j_compress_ptr cinfo)
 124 {
 125   size_t nextsize;
 126   JOCTET * nextbuffer;
 127   my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;
 128
 129   /* Try to allocate new buffer with double size */
 130   nextsize = dest->bufsize * 2;
 131   nextbuffer = malloc(nextsize);
 132
 133   if (nextbuffer == NULL)
 134     ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
 135
 136   MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);
 137
 138   if (dest->newbuffer != NULL)
 139     free(dest->newbuffer);
 140
 141   dest->newbuffer = nextbuffer;
 142
 143   dest->pub.next_output_byte = nextbuffer + dest->bufsize;
 144   dest->pub.free_in_buffer = dest->bufsize;
 145
 146   dest->buffer = nextbuffer;
 147   dest->bufsize = nextsize;
 148
 149   return TRUE;
 150 }
 151
 152
 153 /*
 154  * Terminate destination --- called by jpeg_finish_compress
 155  * after all data has been written.  Usually needs to flush buffer.
 156  *
 157  * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
 158  * application must deal with any cleanup that should happen even
 159  * for error exit.
 160  */
 161
 162 METHODDEF(void)
 163 term_destination (j_compress_ptr cinfo)
 164 {
 165   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
 166   size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
 167
 168   /* Write any data remaining in the buffer */
 169   if (datacount > 0) {
 170     if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
 171       ERREXIT(cinfo, JERR_FILE_WRITE);
 172   }
 173   fflush(dest->outfile);
 174   /* Make sure we wrote the output file OK */
 175   if (ferror(dest->outfile))
 176     ERREXIT(cinfo, JERR_FILE_WRITE);
 177 }
 178
 179 METHODDEF(void)
 180 term_mem_destination (j_compress_ptr cinfo)
 181 {
 182   my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;
 183
 184   *dest->outbuffer = dest->buffer;
 185   *dest->outsize = dest->bufsize - dest->pub.free_in_buffer;
 186 }
 187
 188
 189 /*
 190  * Prepare for output to a stdio stream.
 191  * The caller must have already opened the stream, and is responsible
 192  * for closing it after finishing compression.
 193  */
 194
 195 GLOBAL(void)
 196 jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
 197 {
 198   my_dest_ptr dest;
 199
 200   /* The destination object is made permanent so that multiple JPEG images
 201    * can be written to the same file without re-executing jpeg_stdio_dest.
 202    * This makes it dangerous to use this manager and a different destination
 203    * manager serially with the same JPEG object, because their private object
 204    * sizes may be different.  Caveat programmer.
 205    */
 206   if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
 207     cinfo->dest = (struct jpeg_destination_mgr *)
 208       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 209                                   SIZEOF(my_destination_mgr));
 210   }
 211
 212   dest = (my_dest_ptr) cinfo->dest;
 213   dest->pub.init_destination = init_destination;
 214   dest->pub.empty_output_buffer = empty_output_buffer;
 215   dest->pub.term_destination = term_destination;
 216   dest->outfile = outfile;
 217 }
 218
 219
 220 /*
 221  * Prepare for output to a memory buffer.
 222  * The caller may supply an own initial buffer with appropriate size.
 223  * Otherwise, or when the actual data output exceeds the given size,
 224  * the library adapts the buffer size as necessary.
 225  * The standard library functions malloc/free are used for allocating
 226  * larger memory, so the buffer is available to the application after
 227  * finishing compression, and then the application is responsible for
 228  * freeing the requested memory.
 229  */
 230
 231 GLOBAL(void)
 232 jpeg_mem_dest (j_compress_ptr cinfo,
 233                unsigned char ** outbuffer, unsigned long * outsize)
 234 {
 235   my_mem_dest_ptr dest;
 236
 237   if (outbuffer == NULL || outsize == NULL)     /* sanity check */
 238     ERREXIT(cinfo, JERR_BUFFER_SIZE);
 239
 240   /* The destination object is made permanent so that multiple JPEG images
 241    * can be written to the same buffer without re-executing jpeg_mem_dest.
 242    */
 243   if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
 244     cinfo->dest = (struct jpeg_destination_mgr *)
 245       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
 246                                   SIZEOF(my_mem_destination_mgr));
 247   }
 248
 249   dest = (my_mem_dest_ptr) cinfo->dest;
 250   dest->pub.init_destination = init_mem_destination;
 251   dest->pub.empty_output_buffer = empty_mem_output_buffer;
 252   dest->pub.term_destination = term_mem_destination;
 253   dest->outbuffer = outbuffer;
 254   dest->outsize = outsize;
 255   dest->newbuffer = NULL;
 256
 257   if (*outbuffer == NULL || *outsize == 0) {
 258     /* Allocate initial buffer */
 259     dest->newbuffer = *outbuffer = malloc(OUTPUT_BUF_SIZE);
 260     if (dest->newbuffer == NULL)
 261       ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
 262     *outsize = OUTPUT_BUF_SIZE;
 263   }
 264
 265   dest->pub.next_output_byte = dest->buffer = *outbuffer;
 266   dest->pub.free_in_buffer = dest->bufsize = *outsize;
 267 }