1 /* 2 * jdatadst-tj.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) 2011, 2014, 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 #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ 33 34 35 /* Expanded data destination object for memory output */ 36 37 typedef struct { 38 struct jpeg_destination_mgr pub; /* public fields */ 39 40 unsigned char **outbuffer; /* target buffer */ 41 unsigned long *outsize; 42 unsigned char *newbuffer; /* newly allocated buffer */ 43 JOCTET *buffer; /* start of buffer */ 44 size_t bufsize; 45 boolean alloc; 46 } my_mem_destination_mgr; 47 48 typedef my_mem_destination_mgr *my_mem_dest_ptr; 49 50 51 /* 52 * Initialize destination --- called by jpeg_start_compress 53 * before any data is actually written. 54 */ 55 56 METHODDEF(void) 57 init_mem_destination(j_compress_ptr cinfo) 58 { 59 /* no work necessary here */ 60 } 61 62 63 /* 64 * Empty the output buffer --- called whenever buffer fills up. 65 * 66 * In typical applications, this should write the entire output buffer 67 * (ignoring the current state of next_output_byte & free_in_buffer), 68 * reset the pointer & count to the start of the buffer, and return TRUE 69 * indicating that the buffer has been dumped. 70 * 71 * In applications that need to be able to suspend compression due to output 72 * overrun, a FALSE return indicates that the buffer cannot be emptied now. 73 * In this situation, the compressor will return to its caller (possibly with 74 * an indication that it has not accepted all the supplied scanlines). The 75 * application should resume compression after it has made more room in the 76 * output buffer. Note that there are substantial restrictions on the use of 77 * suspension --- see the documentation. 78 * 79 * When suspending, the compressor will back up to a convenient restart point 80 * (typically the start of the current MCU). next_output_byte & free_in_buffer 81 * indicate where the restart point will be if the current call returns FALSE. 82 * Data beyond this point will be regenerated after resumption, so do not 83 * write it out when emptying the buffer externally. 84 */ 85 86 METHODDEF(boolean) 87 empty_mem_output_buffer(j_compress_ptr cinfo) 88 { 89 size_t nextsize; 90 JOCTET *nextbuffer; 91 my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest; 92 93 if (!dest->alloc) ERREXIT(cinfo, JERR_BUFFER_SIZE); 94 95 /* Try to allocate new buffer with double size */ 96 nextsize = dest->bufsize * 2; 97 nextbuffer = (JOCTET *)malloc(nextsize); 98 99 if (nextbuffer == NULL) 100 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); 101 102 MEMCOPY(nextbuffer, dest->buffer, dest->bufsize); 103 104 if (dest->newbuffer != NULL) 105 free(dest->newbuffer); 106 107 dest->newbuffer = nextbuffer; 108 109 dest->pub.next_output_byte = nextbuffer + dest->bufsize; 110 dest->pub.free_in_buffer = dest->bufsize; 111 112 dest->buffer = nextbuffer; 113 dest->bufsize = nextsize; 114 115 return TRUE; 116 } 117 118 119 /* 120 * Terminate destination --- called by jpeg_finish_compress 121 * after all data has been written. Usually needs to flush buffer. 122 * 123 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding 124 * application must deal with any cleanup that should happen even 125 * for error exit. 126 */ 127 128 METHODDEF(void) 129 term_mem_destination(j_compress_ptr cinfo) 130 { 131 my_mem_dest_ptr dest = (my_mem_dest_ptr)cinfo->dest; 132 133 if (dest->alloc) *dest->outbuffer = dest->buffer; 134 *dest->outsize = (unsigned long)(dest->bufsize - dest->pub.free_in_buffer); 135 } 136 137 138 /* 139 * Prepare for output to a memory buffer. 140 * The caller may supply an own initial buffer with appropriate size. 141 * Otherwise, or when the actual data output exceeds the given size, 142 * the library adapts the buffer size as necessary. 143 * The standard library functions malloc/free are used for allocating 144 * larger memory, so the buffer is available to the application after 145 * finishing compression, and then the application is responsible for 146 * freeing the requested memory. 147 */ 148 149 GLOBAL(void) 150 jpeg_mem_dest_tj(j_compress_ptr cinfo, unsigned char **outbuffer, 151 unsigned long *outsize, boolean alloc) 152 { 153 boolean reused = FALSE; 154 my_mem_dest_ptr dest; 155 156 if (outbuffer == NULL || outsize == NULL) /* sanity check */ 157 ERREXIT(cinfo, JERR_BUFFER_SIZE); 158 159 /* The destination object is made permanent so that multiple JPEG images 160 * can be written to the same buffer without re-executing jpeg_mem_dest. 161 */ 162 if (cinfo->dest == NULL) { /* first time for this JPEG object? */ 163 cinfo->dest = (struct jpeg_destination_mgr *) 164 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT, 165 sizeof(my_mem_destination_mgr)); 166 dest = (my_mem_dest_ptr)cinfo->dest; 167 dest->newbuffer = NULL; 168 dest->buffer = NULL; 169 } else if (cinfo->dest->init_destination != init_mem_destination) { 170 /* It is unsafe to reuse the existing destination manager unless it was 171 * created by this function. 172 */ 173 ERREXIT(cinfo, JERR_BUFFER_SIZE); 174 } 175 176 dest = (my_mem_dest_ptr)cinfo->dest; 177 dest->pub.init_destination = init_mem_destination; 178 dest->pub.empty_output_buffer = empty_mem_output_buffer; 179 dest->pub.term_destination = term_mem_destination; 180 if (dest->buffer == *outbuffer && *outbuffer != NULL && alloc) 181 reused = TRUE; 182 dest->outbuffer = outbuffer; 183 dest->outsize = outsize; 184 dest->alloc = alloc; 185 186 if (*outbuffer == NULL || *outsize == 0) { 187 if (alloc) { 188 /* Allocate initial buffer */ 189 dest->newbuffer = *outbuffer = (unsigned char *)malloc(OUTPUT_BUF_SIZE); 190 if (dest->newbuffer == NULL) 191 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10); 192 *outsize = OUTPUT_BUF_SIZE; 193 } else 194 ERREXIT(cinfo, JERR_BUFFER_SIZE); 195 } 196 197 dest->pub.next_output_byte = dest->buffer = *outbuffer; 198 if (!reused) 199 dest->bufsize = *outsize; 200 dest->pub.free_in_buffer = dest->bufsize; 201 } 202