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