JDATADST.c
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:7k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Note : this file is included as part of the Smaller Animals Software
  4. // JpegFile package. Though this file has not been modified from it's 
  5. // original IJG 6a form, it is not the responsibility on the Independent
  6. // JPEG Group to answer questions regarding this code.
  7. //
  8. // Any questions you have about this code should be addressed to :
  9. //
  10. // CHRISDL@PAGESZ.NET - the distributor of this package.
  11. //
  12. // Remember, by including this code in the JpegFile package, Smaller 
  13. // Animals Software assumes all responsibilities for answering questions
  14. // about it. If we (SA Software) can't answer your questions ourselves, we 
  15. // will direct you to people who can.
  16. //
  17. // Thanks, CDL.
  18. //
  19. ////////////////////////////////////////////////////////////////////////
  20. /*
  21.  * jdatadst.c
  22.  *
  23.  * Copyright (C) 1994-1996, Thomas G. Lane.
  24.  * This file is part of the Independent JPEG Group's software.
  25.  * For conditions of distribution and use, see the accompanying README file.
  26.  *
  27.  * This file contains compression data destination routines for the case of
  28.  * emitting JPEG data to a file (or any stdio stream).  While these routines
  29.  * are sufficient for most applications, some will want to use a different
  30.  * destination manager.
  31.  * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
  32.  * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
  33.  * than 8 bits on your machine, you may need to do some tweaking.
  34.  */
  35. /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
  36. #include "jinclude.h"
  37. #include "jpeglib.h"
  38. #include "jerror.h"
  39. //#include <winbase.h>
  40. /* Expanded data destination object for stdio output */
  41. typedef struct {
  42.   struct jpeg_destination_mgr pub; /* public fields */
  43.   FILE * outfile; /* target stream */
  44.   JOCTET * buffer; /* start of buffer */
  45. } my_destination_mgr;
  46. typedef my_destination_mgr * my_dest_ptr;
  47. #define OUTPUT_BUF_SIZE  4096 /* choose an efficiently fwrite'able size */
  48. /*
  49.  * Initialize destination --- called by jpeg_start_compress
  50.  * before any data is actually written.
  51.  */
  52. METHODDEF(void)
  53. init_destination (j_compress_ptr cinfo)
  54. {
  55.   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  56.   /* Allocate the output buffer --- it will be released when done with image */
  57.   dest->buffer = (JOCTET *)
  58.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  59.   OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
  60.   dest->pub.next_output_byte = dest->buffer;
  61.   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
  62. }
  63. /*
  64.  * Empty the output buffer --- called whenever buffer fills up.
  65.  *
  66.  * In typical applications, this should write the entire output buffer
  67.  * (ignoring the current state of next_output_byte & free_in_buffer),
  68.  * reset the pointer & count to the start of the buffer, and return TRUE
  69.  * indicating that the buffer has been dumped.
  70.  *
  71.  * In applications that need to be able to suspend compression due to output
  72.  * overrun, a FALSE return indicates that the buffer cannot be emptied now.
  73.  * In this situation, the compressor will return to its caller (possibly with
  74.  * an indication that it has not accepted all the supplied scanlines).  The
  75.  * application should resume compression after it has made more room in the
  76.  * output buffer.  Note that there are substantial restrictions on the use of
  77.  * suspension --- see the documentation.
  78.  *
  79.  * When suspending, the compressor will back up to a convenient restart point
  80.  * (typically the start of the current MCU). next_output_byte & free_in_buffer
  81.  * indicate where the restart point will be if the current call returns FALSE.
  82.  * Data beyond this point will be regenerated after resumption, so do not
  83.  * write it out when emptying the buffer externally.
  84.  */
  85. METHODDEF(unsigned int)
  86. empty_output_buffer (j_compress_ptr cinfo)
  87. {
  88.   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  89.   unsigned long l;
  90.   if (!cinfo->i_stream)
  91.   {
  92.    if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
  93.       (size_t) OUTPUT_BUF_SIZE)
  94.     ERREXIT(cinfo, JERR_FILE_WRITE);
  95.   }
  96.   else
  97.   {
  98. if(cinfo->l_size >= cinfo->l_point + OUTPUT_BUF_SIZE)
  99. {
  100.  for (l  = 0; l < OUTPUT_BUF_SIZE; l++)
  101.  cinfo->buffer[cinfo->l_point + l] = dest->buffer[l];
  102. }
  103.  cinfo->l_point += OUTPUT_BUF_SIZE;
  104.   }
  105.   dest->pub.next_output_byte = dest->buffer;
  106.   dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
  107.   return TRUE;
  108. }
  109. /*
  110.  * Terminate destination --- called by jpeg_finish_compress
  111.  * after all data has been written.  Usually needs to flush buffer.
  112.  *
  113.  * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
  114.  * application must deal with any cleanup that should happen even
  115.  * for error exit.
  116.  */
  117. METHODDEF(void)
  118. term_destination (j_compress_ptr cinfo)
  119. {
  120.   my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
  121.   size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
  122.   unsigned long l;
  123.   /* Write any data remaining in the buffer */
  124.   if (datacount > 0) {
  125. //DEL    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
  126. //DEL      ERREXIT(cinfo, JERR_FILE_WRITE);
  127.   if (!cinfo->i_stream)
  128.   {
  129.     if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
  130.       ERREXIT(cinfo, JERR_FILE_WRITE);
  131.   }
  132.   else
  133.   {
  134. if(cinfo->l_size >= cinfo->l_point + datacount)
  135. {
  136.  for (l  = 0; l < datacount; l++)
  137.  cinfo->buffer[cinfo->l_point + l] = dest->buffer[l];
  138. }
  139.  cinfo->l_point += datacount;
  140.   }
  141.   
  142.   
  143.   
  144.   }
  145.   //fflush(dest->outfile);
  146.   /* Make sure we wrote the output file OK */
  147.   //if (ferror(dest->outfile))
  148. //    ERREXIT(cinfo, JERR_FILE_WRITE);
  149. }
  150. /*
  151.  * Prepare for output to a stdio stream.
  152.  * The caller must have already opened the stream, and is responsible
  153.  * for closing it after finishing compression.
  154.  */
  155. GLOBAL(void)
  156. jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
  157. {
  158.   my_dest_ptr dest;
  159.   /* The destination object is made permanent so that multiple JPEG images
  160.    * can be written to the same file without re-executing jpeg_stdio_dest.
  161.    * This makes it dangerous to use this manager and a different destination
  162.    * manager serially with the same JPEG object, because their private object
  163.    * sizes may be different.  Caveat programmer.
  164.    */
  165.   if (cinfo->dest == NULL) { /* first time for this JPEG object? */
  166.     cinfo->dest = (struct jpeg_destination_mgr *)
  167.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
  168.   SIZEOF(my_destination_mgr));
  169.   }
  170.   dest = (my_dest_ptr) cinfo->dest;
  171.   dest->pub.init_destination = init_destination;
  172.   dest->pub.empty_output_buffer = empty_output_buffer;
  173.   dest->pub.term_destination = term_destination;
  174.   dest->outfile = outfile;
  175. }