1 /* 2 * jdatasrc.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-2011 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 decompression data source routines for the case of 13 * reading JPEG data from memory or from a file (or any stdio stream). 14 * While these routines are sufficient for most applications, 15 * some will want to use a different source manager. 16 * IMPORTANT: we assume that fread() will correctly transcribe an array of 17 * JOCTETs from 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 27 /* Expanded data source object for stdio input */ 28 29 typedef struct { 30 struct jpeg_source_mgr pub; /* public fields */ 31 32 FILE *infile; /* source stream */ 33 JOCTET *buffer; /* start of buffer */ 34 boolean start_of_file; /* have we gotten any data yet? */ 35 } my_source_mgr; 36 37 typedef my_source_mgr *my_src_ptr; 38 39 #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ 40 41 42 /* 43 * Initialize source --- called by jpeg_read_header 44 * before any data is actually read. 45 */ 46 47 METHODDEF(void) 48 init_source (j_decompress_ptr cinfo) 49 { 50 my_src_ptr src = (my_src_ptr) cinfo->src; 51 52 /* We reset the empty-input-file flag for each image, 53 * but we don't clear the input buffer. 54 * This is correct behavior for reading a series of images from one source. 55 */ 56 src->start_of_file = TRUE; 57 } 58 59 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) 60 METHODDEF(void) 61 init_mem_source (j_decompress_ptr cinfo) 62 { 63 /* no work necessary here */ 64 } 65 #endif 66 67 68 /* 69 * Fill the input buffer --- called whenever buffer is emptied. 70 * 71 * In typical applications, this should read fresh data into the buffer 72 * (ignoring the current state of next_input_byte & bytes_in_buffer), 73 * reset the pointer & count to the start of the buffer, and return TRUE 74 * indicating that the buffer has been reloaded. It is not necessary to 75 * fill the buffer entirely, only to obtain at least one more byte. 76 * 77 * There is no such thing as an EOF return. If the end of the file has been 78 * reached, the routine has a choice of ERREXIT() or inserting fake data into 79 * the buffer. In most cases, generating a warning message and inserting a 80 * fake EOI marker is the best course of action --- this will allow the 81 * decompressor to output however much of the image is there. However, 82 * the resulting error message is misleading if the real problem is an empty 83 * input file, so we handle that case specially. 84 * 85 * In applications that need to be able to suspend compression due to input 86 * not being available yet, a FALSE return indicates that no more data can be 87 * obtained right now, but more may be forthcoming later. In this situation, 88 * the decompressor will return to its caller (with an indication of the 89 * number of scanlines it has read, if any). The application should resume 90 * decompression after it has loaded more data into the input buffer. Note 91 * that there are substantial restrictions on the use of suspension --- see 92 * the documentation. 93 * 94 * When suspending, the decompressor will back up to a convenient restart point 95 * (typically the start of the current MCU). next_input_byte & bytes_in_buffer 96 * indicate where the restart point will be if the current call returns FALSE. 97 * Data beyond this point must be rescanned after resumption, so move it to 98 * the front of the buffer rather than discarding it. 99 */ 100 101 METHODDEF(boolean) 102 fill_input_buffer (j_decompress_ptr cinfo) 103 { 104 my_src_ptr src = (my_src_ptr) cinfo->src; 105 size_t nbytes; 106 107 nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE); 108 109 if (nbytes <= 0) { 110 if (src->start_of_file) /* Treat empty input file as fatal error */ 111 ERREXIT(cinfo, JERR_INPUT_EMPTY); 112 WARNMS(cinfo, JWRN_JPEG_EOF); 113 /* Insert a fake EOI marker */ 114 src->buffer[0] = (JOCTET) 0xFF; 115 src->buffer[1] = (JOCTET) JPEG_EOI; 116 nbytes = 2; 117 } 118 119 src->pub.next_input_byte = src->buffer; 120 src->pub.bytes_in_buffer = nbytes; 121 src->start_of_file = FALSE; 122 123 return TRUE; 124 } 125 126 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) 127 METHODDEF(boolean) 128 fill_mem_input_buffer (j_decompress_ptr cinfo) 129 { 130 static const JOCTET mybuffer[4] = { 131 (JOCTET) 0xFF, (JOCTET) JPEG_EOI, 0, 0 132 }; 133 134 /* The whole JPEG data is expected to reside in the supplied memory 135 * buffer, so any request for more data beyond the given buffer size 136 * is treated as an error. 137 */ 138 WARNMS(cinfo, JWRN_JPEG_EOF); 139 140 /* Insert a fake EOI marker */ 141 142 cinfo->src->next_input_byte = mybuffer; 143 cinfo->src->bytes_in_buffer = 2; 144 145 return TRUE; 146 } 147 #endif 148 149 150 /* 151 * Skip data --- used to skip over a potentially large amount of 152 * uninteresting data (such as an APPn marker). 153 * 154 * Writers of suspendable-input applications must note that skip_input_data 155 * is not granted the right to give a suspension return. If the skip extends 156 * beyond the data currently in the buffer, the buffer can be marked empty so 157 * that the next read will cause a fill_input_buffer call that can suspend. 158 * Arranging for additional bytes to be discarded before reloading the input 159 * buffer is the application writer's problem. 160 */ 161 162 METHODDEF(void) 163 skip_input_data (j_decompress_ptr cinfo, long num_bytes) 164 { 165 struct jpeg_source_mgr *src = cinfo->src; 166 167 /* Just a dumb implementation for now. Could use fseek() except 168 * it doesn't work on pipes. Not clear that being smart is worth 169 * any trouble anyway --- large skips are infrequent. 170 */ 171 if (num_bytes > 0) { 172 while (num_bytes > (long) src->bytes_in_buffer) { 173 num_bytes -= (long) src->bytes_in_buffer; 174 (void) (*src->fill_input_buffer) (cinfo); 175 /* note we assume that fill_input_buffer will never return FALSE, 176 * so suspension need not be handled. 177 */ 178 } 179 src->next_input_byte += (size_t) num_bytes; 180 src->bytes_in_buffer -= (size_t) num_bytes; 181 } 182 } 183 184 185 /* 186 * An additional method that can be provided by data source modules is the 187 * resync_to_restart method for error recovery in the presence of RST markers. 188 * For the moment, this source module just uses the default resync method 189 * provided by the JPEG library. That method assumes that no backtracking 190 * is possible. 191 */ 192 193 194 /* 195 * Terminate source --- called by jpeg_finish_decompress 196 * after all data has been read. Often a no-op. 197 * 198 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding 199 * application must deal with any cleanup that should happen even 200 * for error exit. 201 */ 202 203 METHODDEF(void) 204 term_source (j_decompress_ptr cinfo) 205 { 206 /* no work necessary here */ 207 } 208 209 210 /* 211 * Prepare for input from a stdio stream. 212 * The caller must have already opened the stream, and is responsible 213 * for closing it after finishing decompression. 214 */ 215 216 GLOBAL(void) 217 jpeg_stdio_src (j_decompress_ptr cinfo, FILE *infile) 218 { 219 my_src_ptr src; 220 221 /* The source object and input buffer are made permanent so that a series 222 * of JPEG images can be read from the same file by calling jpeg_stdio_src 223 * only before the first one. (If we discarded the buffer at the end of 224 * one image, we'd likely lose the start of the next one.) 225 */ 226 if (cinfo->src == NULL) { /* first time for this JPEG object? */ 227 cinfo->src = (struct jpeg_source_mgr *) 228 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 229 sizeof(my_source_mgr)); 230 src = (my_src_ptr) cinfo->src; 231 src->buffer = (JOCTET *) 232 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 233 INPUT_BUF_SIZE * sizeof(JOCTET)); 234 } else if (cinfo->src->init_source != init_source) { 235 /* It is unsafe to reuse the existing source manager unless it was created 236 * by this function. Otherwise, there is no guarantee that the opaque 237 * structure is the right size. Note that we could just create a new 238 * structure, but the old structure would not be freed until 239 * jpeg_destroy_decompress() was called. 240 */ 241 ERREXIT(cinfo, JERR_BUFFER_SIZE); 242 } 243 244 src = (my_src_ptr) cinfo->src; 245 src->pub.init_source = init_source; 246 src->pub.fill_input_buffer = fill_input_buffer; 247 src->pub.skip_input_data = skip_input_data; 248 src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ 249 src->pub.term_source = term_source; 250 src->infile = infile; 251 src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ 252 src->pub.next_input_byte = NULL; /* until buffer loaded */ 253 } 254 255 256 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED) 257 /* 258 * Prepare for input from a supplied memory buffer. 259 * The buffer must contain the whole JPEG data. 260 */ 261 262 GLOBAL(void) 263 jpeg_mem_src (j_decompress_ptr cinfo, 264 const unsigned char *inbuffer, unsigned long insize) 265 { 266 struct jpeg_source_mgr *src; 267 268 if (inbuffer == NULL || insize == 0) /* Treat empty input as fatal error */ 269 ERREXIT(cinfo, JERR_INPUT_EMPTY); 270 271 /* The source object is made permanent so that a series of JPEG images 272 * can be read from the same buffer by calling jpeg_mem_src only before 273 * the first one. 274 */ 275 if (cinfo->src == NULL) { /* first time for this JPEG object? */ 276 cinfo->src = (struct jpeg_source_mgr *) 277 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 278 sizeof(struct jpeg_source_mgr)); 279 } else if (cinfo->src->init_source != init_mem_source) { 280 /* It is unsafe to reuse the existing source manager unless it was created 281 * by this function. 282 */ 283 ERREXIT(cinfo, JERR_BUFFER_SIZE); 284 } 285 286 src = cinfo->src; 287 src->init_source = init_mem_source; 288 src->fill_input_buffer = fill_mem_input_buffer; 289 src->skip_input_data = skip_input_data; 290 src->resync_to_restart = jpeg_resync_to_restart; /* use default method */ 291 src->term_source = term_source; 292 src->bytes_in_buffer = (size_t) insize; 293 src->next_input_byte = (const JOCTET *) inbuffer; 294 } 295 #endif 296
