home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / jlib / jdatadst.cpp < prev    next >
C/C++ Source or Header  |  2000-05-16  |  6KB  |  156 lines
  1. //-------------------------------------------------------------------------//
  2. //          Windows Graphics Programming: Win32 GDI and DirectDraw         //
  3. //                        ISBN  0-13-086985-6                              //
  4. //                                                                         //
  5. //  Modified by: Yuan, Feng                             www.fengyuan.com   //
  6. //  Changes    : C++, exception, in-memory source, BGR byte order          //
  7. //  Version    : 1.00.000, May 31, 2000                                    //
  8. //-------------------------------------------------------------------------//
  9.  
  10. /*
  11.  * jdatadst.c
  12.  *
  13.  * Copyright (C) 1994-1996, Thomas G. Lane.
  14.  * This file is part of the Independent JPEG Group's software.
  15.  * For conditions of distribution and use, see the accompanying README file.
  16.  *
  17.  * This file contains compression data destination routines for the case of
  18.  * emitting JPEG data to a file (or any stdio stream).  While these routines
  19.  * are sufficient for most applications, some will want to use a different
  20.  * destination manager.
  21.  * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
  22.  * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
  23.  * than 8 bits on your machine, you may need to do some tweaking.
  24.  */
  25.  
  26. /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
  27. #include "jinclude.h"
  28. #include "jpeglib.h"
  29. #include "jerror.h"
  30.  
  31.  
  32. /* Expanded data destination object for stdio output */
  33.  
  34. typedef struct {
  35.   struct jpeg_destination_mgr pub; /* public fields */
  36.  
  37.   FILE * outfile;        /* target stream */
  38.   JOCTET * buffer;        /* start of buffer */
  39. } my_destination_mgr;
  40.  
  41. typedef my_destination_mgr * my_dest_ptr;
  42.  
  43. #define OUTPUT_BUF_SIZE  4096    /* choose an efficiently fwrite'able size */
  44.  
  45.  
  46. /*
  47.  * Initialize destination --- called by jpeg_start_compress
  48.  * before any data is actually written.
  49.  */
  50.  
  51. void init_destination (j_compress_ptr cinfo)
  52. {
  53.     my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  54.  
  55.     /* Allocate the output buffer --- it will be released when done with image */
  56.     dest->buffer = (JOCTET *)
  57.         cinfo->mem->alloc_small(JPOOL_IMAGE, OUTPUT_BUF_SIZE * sizeof(JOCTET));
  58.  
  59.     dest->pub.next_output_byte = dest->buffer;
  60.     dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
  61. }
  62.  
  63.  
  64. /*
  65.  * Empty the output buffer --- called whenever buffer fills up.
  66.  *
  67.  * In typical applications, this should write the entire output buffer
  68.  * (ignoring the current state of next_output_byte & free_in_buffer),
  69.  * reset the pointer & count to the start of the buffer, and return TRUE
  70.  * indicating that the buffer has been dumped.
  71.  *
  72.  * In applications that need to be able to suspend compression due to output
  73.  * overrun, a FALSE return indicates that the buffer cannot be emptied now.
  74.  * In this situation, the compressor will return to its caller (possibly with
  75.  * an indication that it has not accepted all the supplied scanlines).  The
  76.  * application should resume compression after it has made more room in the
  77.  * output buffer.  Note that there are substantial restrictions on the use of
  78.  * suspension --- see the documentation.
  79.  *
  80.  * When suspending, the compressor will back up to a convenient restart point
  81.  * (typically the start of the current MCU). next_output_byte & free_in_buffer
  82.  * indicate where the restart point will be if the current call returns FALSE.
  83.  * Data beyond this point will be regenerated after resumption, so do not
  84.  * write it out when emptying the buffer externally.
  85.  */
  86.  
  87. boolean empty_output_buffer (j_compress_ptr cinfo)
  88. {
  89.   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  90.  
  91.   if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
  92.       (size_t) OUTPUT_BUF_SIZE)
  93.     cinfo->ERREXIT(JERR_FILE_WRITE);
  94.  
  95.   dest->pub.next_output_byte = dest->buffer;
  96.   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
  97.  
  98.   return TRUE;
  99. }
  100.  
  101.  
  102. /*
  103.  * Terminate destination --- called by jpeg_finish_compress
  104.  * after all data has been written.  Usually needs to flush buffer.
  105.  *
  106.  * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
  107.  * application must deal with any cleanup that should happen even
  108.  * for error exit.
  109.  */
  110.  
  111. void term_destination (j_compress_ptr cinfo)
  112. {
  113.   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  114.   size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
  115.  
  116.   /* Write any data remaining in the buffer */
  117.   if (datacount > 0) {
  118.     if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
  119.       cinfo->ERREXIT(JERR_FILE_WRITE);
  120.   }
  121.   fflush(dest->outfile);
  122.   /* Make sure we wrote the output file OK */
  123.   if (ferror(dest->outfile))
  124.     cinfo->ERREXIT(JERR_FILE_WRITE);
  125. }
  126.  
  127.  
  128. /*
  129.  * Prepare for output to a stdio stream.
  130.  * The caller must have already opened the stream, and is responsible
  131.  * for closing it after finishing compression.
  132.  */
  133.  
  134. GLOBAL(void)
  135. jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
  136. {
  137.   my_dest_ptr dest;
  138.  
  139.   /* The destination object is made permanent so that multiple JPEG images
  140.    * can be written to the same file without re-executing jpeg_stdio_dest.
  141.    * This makes it dangerous to use this manager and a different destination
  142.    * manager serially with the same JPEG object, because their private object
  143.    * sizes may be different.  Caveat programmer.
  144.    */
  145.   if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
  146.     cinfo->dest = (struct jpeg_destination_mgr *)
  147.       cinfo->mem->alloc_small(JPOOL_PERMANENT, sizeof(my_destination_mgr));
  148.   }
  149.  
  150.   dest = (my_dest_ptr) cinfo->dest;
  151.   dest->pub.init_destination = init_destination;
  152.   dest->pub.empty_output_buffer = empty_output_buffer;
  153.   dest->pub.term_destination = term_destination;
  154.   dest->outfile = outfile;
  155. }
  156.