source: rtems-graphics-toolkit/jpeg-8d/jdatadst.c @ 86b99f7

Last change on this file since 86b99f7 was 86b99f7, checked in by Alexandru-Sever Horin <alex.sever.h@…>, on Aug 1, 2012 at 10:40:32 PM

Added jpeg-8d version. Made modifications to compile for RTEMS, without man or binaries

  • Property mode set to 100644
File size: 8.3 KB
Line 
1/*
2 * jdatadst.c
3 *
4 * Copyright (C) 1994-1996, Thomas G. Lane.
5 * Modified 2009-2012 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 compression data destination routines for the case of
10 * emitting JPEG data to memory or to a file (or any stdio stream).
11 * While these routines are sufficient for most applications,
12 * some will want to use a different destination manager.
13 * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
14 * JOCTETs into 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#ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare malloc(),free() */
24extern void * malloc JPP((size_t size));
25extern void free JPP((void *ptr));
26#endif
27
28
29/* Expanded data destination object for stdio output */
30
31typedef struct {
32  struct jpeg_destination_mgr pub; /* public fields */
33
34  FILE * outfile;               /* target stream */
35  JOCTET * buffer;              /* start of buffer */
36} my_destination_mgr;
37
38typedef my_destination_mgr * my_dest_ptr;
39
40#define OUTPUT_BUF_SIZE  4096   /* choose an efficiently fwrite'able size */
41
42
43/* Expanded data destination object for memory output */
44
45typedef struct {
46  struct jpeg_destination_mgr pub; /* public fields */
47
48  unsigned char ** outbuffer;   /* target buffer */
49  unsigned long * outsize;
50  unsigned char * newbuffer;    /* newly allocated buffer */
51  JOCTET * buffer;              /* start of buffer */
52  size_t bufsize;
53} my_mem_destination_mgr;
54
55typedef my_mem_destination_mgr * my_mem_dest_ptr;
56
57
58/*
59 * Initialize destination --- called by jpeg_start_compress
60 * before any data is actually written.
61 */
62
63METHODDEF(void)
64init_destination (j_compress_ptr cinfo)
65{
66  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
67
68  /* Allocate the output buffer --- it will be released when done with image */
69  dest->buffer = (JOCTET *)
70      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
71                                  OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
72
73  dest->pub.next_output_byte = dest->buffer;
74  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
75}
76
77METHODDEF(void)
78init_mem_destination (j_compress_ptr cinfo)
79{
80  /* no work necessary here */
81}
82
83
84/*
85 * Empty the output buffer --- called whenever buffer fills up.
86 *
87 * In typical applications, this should write the entire output buffer
88 * (ignoring the current state of next_output_byte & free_in_buffer),
89 * reset the pointer & count to the start of the buffer, and return TRUE
90 * indicating that the buffer has been dumped.
91 *
92 * In applications that need to be able to suspend compression due to output
93 * overrun, a FALSE return indicates that the buffer cannot be emptied now.
94 * In this situation, the compressor will return to its caller (possibly with
95 * an indication that it has not accepted all the supplied scanlines).  The
96 * application should resume compression after it has made more room in the
97 * output buffer.  Note that there are substantial restrictions on the use of
98 * suspension --- see the documentation.
99 *
100 * When suspending, the compressor will back up to a convenient restart point
101 * (typically the start of the current MCU). next_output_byte & free_in_buffer
102 * indicate where the restart point will be if the current call returns FALSE.
103 * Data beyond this point will be regenerated after resumption, so do not
104 * write it out when emptying the buffer externally.
105 */
106
107METHODDEF(boolean)
108empty_output_buffer (j_compress_ptr cinfo)
109{
110  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
111
112  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
113      (size_t) OUTPUT_BUF_SIZE)
114    ERREXIT(cinfo, JERR_FILE_WRITE);
115
116  dest->pub.next_output_byte = dest->buffer;
117  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
118
119  return TRUE;
120}
121
122METHODDEF(boolean)
123empty_mem_output_buffer (j_compress_ptr cinfo)
124{
125  size_t nextsize;
126  JOCTET * nextbuffer;
127  my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;
128
129  /* Try to allocate new buffer with double size */
130  nextsize = dest->bufsize * 2;
131  nextbuffer = (JOCTET *) malloc(nextsize);
132
133  if (nextbuffer == NULL)
134    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
135
136  MEMCOPY(nextbuffer, dest->buffer, dest->bufsize);
137
138  if (dest->newbuffer != NULL)
139    free(dest->newbuffer);
140
141  dest->newbuffer = nextbuffer;
142
143  dest->pub.next_output_byte = nextbuffer + dest->bufsize;
144  dest->pub.free_in_buffer = dest->bufsize;
145
146  dest->buffer = nextbuffer;
147  dest->bufsize = nextsize;
148
149  return TRUE;
150}
151
152
153/*
154 * Terminate destination --- called by jpeg_finish_compress
155 * after all data has been written.  Usually needs to flush buffer.
156 *
157 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
158 * application must deal with any cleanup that should happen even
159 * for error exit.
160 */
161
162METHODDEF(void)
163term_destination (j_compress_ptr cinfo)
164{
165  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
166  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
167
168  /* Write any data remaining in the buffer */
169  if (datacount > 0) {
170    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
171      ERREXIT(cinfo, JERR_FILE_WRITE);
172  }
173  fflush(dest->outfile);
174  /* Make sure we wrote the output file OK */
175  if (ferror(dest->outfile))
176    ERREXIT(cinfo, JERR_FILE_WRITE);
177}
178
179METHODDEF(void)
180term_mem_destination (j_compress_ptr cinfo)
181{
182  my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo->dest;
183
184  *dest->outbuffer = dest->buffer;
185  *dest->outsize = dest->bufsize - dest->pub.free_in_buffer;
186}
187
188
189/*
190 * Prepare for output to a stdio stream.
191 * The caller must have already opened the stream, and is responsible
192 * for closing it after finishing compression.
193 */
194
195GLOBAL(void)
196jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
197{
198  my_dest_ptr dest;
199
200  /* The destination object is made permanent so that multiple JPEG images
201   * can be written to the same file without re-executing jpeg_stdio_dest.
202   * This makes it dangerous to use this manager and a different destination
203   * manager serially with the same JPEG object, because their private object
204   * sizes may be different.  Caveat programmer.
205   */
206  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
207    cinfo->dest = (struct jpeg_destination_mgr *)
208      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
209                                  SIZEOF(my_destination_mgr));
210  }
211
212  dest = (my_dest_ptr) cinfo->dest;
213  dest->pub.init_destination = init_destination;
214  dest->pub.empty_output_buffer = empty_output_buffer;
215  dest->pub.term_destination = term_destination;
216  dest->outfile = outfile;
217}
218
219
220/*
221 * Prepare for output to a memory buffer.
222 * The caller may supply an own initial buffer with appropriate size.
223 * Otherwise, or when the actual data output exceeds the given size,
224 * the library adapts the buffer size as necessary.
225 * The standard library functions malloc/free are used for allocating
226 * larger memory, so the buffer is available to the application after
227 * finishing compression, and then the application is responsible for
228 * freeing the requested memory.
229 */
230
231GLOBAL(void)
232jpeg_mem_dest (j_compress_ptr cinfo,
233               unsigned char ** outbuffer, unsigned long * outsize)
234{
235  my_mem_dest_ptr dest;
236
237  if (outbuffer == NULL || outsize == NULL)     /* sanity check */
238    ERREXIT(cinfo, JERR_BUFFER_SIZE);
239
240  /* The destination object is made permanent so that multiple JPEG images
241   * can be written to the same buffer without re-executing jpeg_mem_dest.
242   */
243  if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
244    cinfo->dest = (struct jpeg_destination_mgr *)
245      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
246                                  SIZEOF(my_mem_destination_mgr));
247  }
248
249  dest = (my_mem_dest_ptr) cinfo->dest;
250  dest->pub.init_destination = init_mem_destination;
251  dest->pub.empty_output_buffer = empty_mem_output_buffer;
252  dest->pub.term_destination = term_mem_destination;
253  dest->outbuffer = outbuffer;
254  dest->outsize = outsize;
255  dest->newbuffer = NULL;
256
257  if (*outbuffer == NULL || *outsize == 0) {
258    /* Allocate initial buffer */
259    dest->newbuffer = *outbuffer = (unsigned char *) malloc(OUTPUT_BUF_SIZE);
260    if (dest->newbuffer == NULL)
261      ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 10);
262    *outsize = OUTPUT_BUF_SIZE;
263  }
264
265  dest->pub.next_output_byte = dest->buffer = *outbuffer;
266  dest->pub.free_in_buffer = dest->bufsize = *outsize;
267}
Note: See TracBrowser for help on using the repository browser.