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