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 } 152
