media/libjpeg/jdatadst.c

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