Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 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 | }=> |