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