Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 1 | /* |
2 | * jdatadst.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 compression data destination routines for the case of |
||
9 | * emitting JPEG data to a file (or any stdio stream). While these routines |
||
10 | * are sufficient for most applications, some will want to use a different |
||
11 | * destination manager. |
||
12 | * IMPORTANT: we assume that fwrite() will correctly transcribe an array of |
||
13 | * JOCTETs into 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 destination object for stdio output */ |
||
24 | |||
25 | typedef struct { |
||
26 | struct jpeg_destination_mgr pub; /* public fields */ |
||
27 | |||
28 | FILE * outfile; /* target stream */ |
||
29 | JOCTET * buffer; /* start of buffer */ |
||
30 | } my_destination_mgr; |
||
31 | |||
32 | typedef my_destination_mgr * my_dest_ptr; |
||
33 | |||
34 | #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ |
||
35 | |||
36 | |||
37 | /* |
||
38 | * Initialize destination --- called by jpeg_start_compress |
||
39 | * before any data is actually written. |
||
40 | */ |
||
41 | |||
42 | METHODDEF(void) |
||
43 | init_destination (j_compress_ptr cinfo) |
||
44 | { |
||
45 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; |
||
46 | |||
47 | /* Allocate the output buffer --- it will be released when done with image */ |
||
48 | dest->buffer = (JOCTET *) |
||
49 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
||
50 | OUTPUT_BUF_SIZE * SIZEOF(JOCTET)); |
||
51 | |||
52 | dest->pub.next_output_byte = dest->buffer; |
||
53 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; |
||
54 | } |
||
55 | |||
56 | |||
57 | /* |
||
58 | * Empty the output buffer --- called whenever buffer fills up. |
||
59 | * |
||
60 | * In typical applications, this should write the entire output buffer |
||
61 | * (ignoring the current state of next_output_byte & free_in_buffer), |
||
62 | * reset the pointer & count to the start of the buffer, and return TRUE |
||
63 | * indicating that the buffer has been dumped. |
||
64 | * |
||
65 | * In applications that need to be able to suspend compression due to output |
||
66 | * overrun, a FALSE return indicates that the buffer cannot be emptied now. |
||
67 | * In this situation, the compressor will return to its caller (possibly with |
||
68 | * an indication that it has not accepted all the supplied scanlines). The |
||
69 | * application should resume compression after it has made more room in the |
||
70 | * output buffer. Note that there are substantial restrictions on the use of |
||
71 | * suspension --- see the documentation. |
||
72 | * |
||
73 | * When suspending, the compressor will back up to a convenient restart point |
||
74 | * (typically the start of the current MCU). next_output_byte & free_in_buffer |
||
75 | * indicate where the restart point will be if the current call returns FALSE. |
||
76 | * Data beyond this point will be regenerated after resumption, so do not |
||
77 | * write it out when emptying the buffer externally. |
||
78 | */ |
||
79 | |||
80 | METHODDEF(boolean) |
||
81 | empty_output_buffer (j_compress_ptr cinfo) |
||
82 | { |
||
83 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; |
||
84 | |||
85 | if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) != |
||
86 | (size_t) OUTPUT_BUF_SIZE) |
||
87 | ERREXIT(cinfo, JERR_FILE_WRITE); |
||
88 | |||
89 | dest->pub.next_output_byte = dest->buffer; |
||
90 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; |
||
91 | |||
92 | return TRUE; |
||
93 | } |
||
94 | |||
95 | |||
96 | /* |
||
97 | * Terminate destination --- called by jpeg_finish_compress |
||
98 | * after all data has been written. Usually needs to flush buffer. |
||
99 | * |
||
100 | * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding |
||
101 | * application must deal with any cleanup that should happen even |
||
102 | * for error exit. |
||
103 | */ |
||
104 | |||
105 | METHODDEF(void) |
||
106 | term_destination (j_compress_ptr cinfo) |
||
107 | { |
||
108 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; |
||
109 | size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; |
||
110 | |||
111 | /* Write any data remaining in the buffer */ |
||
112 | if (datacount > 0) { |
||
113 | if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount) |
||
114 | ERREXIT(cinfo, JERR_FILE_WRITE); |
||
115 | } |
||
116 | fflush(dest->outfile); |
||
117 | /* Make sure we wrote the output file OK */ |
||
118 | if (ferror(dest->outfile)) |
||
119 | ERREXIT(cinfo, JERR_FILE_WRITE); |
||
120 | } |
||
121 | |||
122 | |||
123 | /* |
||
124 | * Prepare for output to a stdio stream. |
||
125 | * The caller must have already opened the stream, and is responsible |
||
126 | * for closing it after finishing compression. |
||
127 | */ |
||
128 | |||
129 | GLOBAL(void) |
||
130 | jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile) |
||
131 | { |
||
132 | my_dest_ptr dest; |
||
133 | |||
134 | /* The destination object is made permanent so that multiple JPEG images |
||
135 | * can be written to the same file without re-executing jpeg_stdio_dest. |
||
136 | * This makes it dangerous to use this manager and a different destination |
||
137 | * manager serially with the same JPEG object, because their private object |
||
138 | * sizes may be different. Caveat programmer. |
||
139 | */ |
||
140 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ |
||
141 | cinfo->dest = (struct jpeg_destination_mgr *) |
||
142 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, |
||
143 | SIZEOF(my_destination_mgr)); |
||
144 | } |
||
145 | |||
146 | dest = (my_dest_ptr) cinfo->dest; |
||
147 | dest->pub.init_destination = init_destination; |
||
148 | dest->pub.empty_output_buffer = empty_output_buffer; |
||
149 | dest->pub.term_destination = term_destination; |
||
150 | dest->outfile = outfile; |
||
151 | } |