jdatadst.cpp (5394B)
1 /* 2 * jdatadst.c 3 * 4 * Copyright (C) 1994, 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 my_dest_ptr dest = (my_dest_ptr) cinfo->dest; 45 46 /* Allocate the output buffer --- it will be released when done with image */ 47 dest->buffer = (JOCTET *) 48 ( *cinfo->mem->alloc_small )( (j_common_ptr) cinfo, JPOOL_IMAGE, 49 OUTPUT_BUF_SIZE * SIZEOF( JOCTET ) ); 50 51 dest->pub.next_output_byte = dest->buffer; 52 dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; 53 } 54 55 56 /* 57 * Empty the output buffer --- called whenever buffer fills up. 58 * 59 * In typical applications, this should write the entire output buffer 60 * (ignoring the current state of next_output_byte & free_in_buffer), 61 * reset the pointer & count to the start of the buffer, and return TRUE 62 * indicating that the buffer has been dumped. 63 * 64 * In applications that need to be able to suspend compression due to output 65 * overrun, a FALSE return indicates that the buffer cannot be emptied now. 66 * In this situation, the compressor will return to its caller (possibly with 67 * an indication that it has not accepted all the supplied scanlines). The 68 * application should resume compression after it has made more room in the 69 * output buffer. Note that there are substantial restrictions on the use of 70 * suspension --- see the documentation. 71 * 72 * When suspending, the compressor will back up to a convenient restart point 73 * (typically the start of the current MCU). next_output_byte & free_in_buffer 74 * indicate where the restart point will be if the current call returns FALSE. 75 * Data beyond this point will be regenerated after resumption, so do not 76 * write it out when emptying the buffer externally. 77 */ 78 79 METHODDEF boolean 80 empty_output_buffer( j_compress_ptr cinfo ) { 81 my_dest_ptr dest = (my_dest_ptr) cinfo->dest; 82 83 if ( JFWRITE( dest->outfile, dest->buffer, OUTPUT_BUF_SIZE ) != 84 (size_t) OUTPUT_BUF_SIZE ) { 85 ERREXIT( cinfo, JERR_FILE_WRITE ); 86 } 87 88 dest->pub.next_output_byte = dest->buffer; 89 dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; 90 91 return TRUE; 92 } 93 94 95 /* 96 * Terminate destination --- called by jpeg_finish_compress 97 * after all data has been written. Usually needs to flush buffer. 98 * 99 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding 100 * application must deal with any cleanup that should happen even 101 * for error exit. 102 */ 103 104 METHODDEF void 105 term_destination( j_compress_ptr cinfo ) { 106 my_dest_ptr dest = (my_dest_ptr) cinfo->dest; 107 size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; 108 109 /* Write any data remaining in the buffer */ 110 if ( datacount > 0 ) { 111 if ( JFWRITE( dest->outfile, dest->buffer, datacount ) != datacount ) { 112 ERREXIT( cinfo, JERR_FILE_WRITE ); 113 } 114 } 115 fflush( dest->outfile ); 116 /* Make sure we wrote the output file OK */ 117 if ( ferror( dest->outfile ) ) { 118 ERREXIT( cinfo, JERR_FILE_WRITE ); 119 } 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 my_dest_ptr dest; 132 133 /* The destination object is made permanent so that multiple JPEG images 134 * can be written to the same file without re-executing jpeg_stdio_dest. 135 * This makes it dangerous to use this manager and a different destination 136 * manager serially with the same JPEG object, because their private object 137 * sizes may be different. Caveat programmer. 138 */ 139 if ( cinfo->dest == NULL ) {/* first time for this JPEG object? */ 140 cinfo->dest = (struct jpeg_destination_mgr *) 141 ( * cinfo->mem->alloc_small )( (j_common_ptr) cinfo, JPOOL_PERMANENT, 142 SIZEOF( my_destination_mgr ) ); 143 } 144 145 dest = (my_dest_ptr) cinfo->dest; 146 dest->pub.init_destination = init_destination; 147 dest->pub.empty_output_buffer = empty_output_buffer; 148 dest->pub.term_destination = term_destination; 149 dest->outfile = outfile; 150 }