home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / jlib / jutils.cpp < prev    next >
C/C++ Source or Header  |  2000-05-16  |  5KB  |  145 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.  * jutils.c
  12.  *
  13.  * Copyright (C) 1991-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 tables and miscellaneous utility routines needed
  18.  * for both compression and decompression.
  19.  * Note we prefix all global names with "j" to minimize conflicts with
  20.  * a surrounding application.
  21.  */
  22.  
  23. #define JPEG_INTERNALS
  24. #include "jinclude.h"
  25. #include "jpeglib.h"
  26.  
  27.  
  28. /*
  29.  * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
  30.  * of a DCT block read in natural order (left to right, top to bottom).
  31.  */
  32.  
  33. #if 0                /* This table is not actually needed in v6a */
  34.  
  35. const int jpeg_zigzag_order[DCTSIZE2] = {
  36.    0,  1,  5,  6, 14, 15, 27, 28,
  37.    2,  4,  7, 13, 16, 26, 29, 42,
  38.    3,  8, 12, 17, 25, 30, 41, 43,
  39.    9, 11, 18, 24, 31, 40, 44, 53,
  40.   10, 19, 23, 32, 39, 45, 52, 54,
  41.   20, 22, 33, 38, 46, 51, 55, 60,
  42.   21, 34, 37, 47, 50, 56, 59, 61,
  43.   35, 36, 48, 49, 57, 58, 62, 63
  44. };
  45.  
  46. #endif
  47.  
  48. /*
  49.  * jpeg_natural_order[i] is the natural-order position of the i'th element
  50.  * of zigzag order.
  51.  *
  52.  * When reading corrupted data, the Huffman decoders could attempt
  53.  * to reference an entry beyond the end of this array (if the decoded
  54.  * zero run length reaches past the end of the block).  To prevent
  55.  * wild stores without adding an inner-loop test, we put some extra
  56.  * "63"s after the real entries.  This will cause the extra coefficient
  57.  * to be stored in location 63 of the block, not somewhere random.
  58.  * The worst case would be a run-length of 15, which means we need 16
  59.  * fake entries.
  60.  */
  61.  
  62. const int jpeg_natural_order[DCTSIZE2+16] = {
  63.   0,  1,  8, 16,  9,  2,  3, 10,
  64.  17, 24, 32, 25, 18, 11,  4,  5,
  65.  12, 19, 26, 33, 40, 48, 41, 34,
  66.  27, 20, 13,  6,  7, 14, 21, 28,
  67.  35, 42, 49, 56, 57, 50, 43, 36,
  68.  29, 22, 15, 23, 30, 37, 44, 51,
  69.  58, 59, 52, 45, 38, 31, 39, 46,
  70.  53, 60, 61, 54, 47, 55, 62, 63,
  71.  63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
  72.  63, 63, 63, 63, 63, 63, 63, 63
  73. };
  74.  
  75.  
  76. /*
  77.  * Arithmetic utilities
  78.  */
  79.  
  80. GLOBAL(long)
  81. jdiv_round_up (long a, long b)
  82. /* Compute a/b rounded up to next integer, ie, ceil(a/b) */
  83. /* Assumes a >= 0, b > 0 */
  84. {
  85.   return (a + b - 1L) / b;
  86. }
  87.  
  88.  
  89. GLOBAL(long)
  90. jround_up (long a, long b)
  91. /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
  92. /* Assumes a >= 0, b > 0 */
  93. {
  94.   a += b - 1L;
  95.   return a - (a % b);
  96. }
  97.  
  98.  
  99. /* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
  100.  * and coefficient-block arrays.  This won't work on 80x86 because the arrays
  101.  * are FAR and we're assuming a small-pointer memory model.  However, some
  102.  * DOS compilers provide far-pointer versions of memcpy() and memset() even
  103.  * in the small-model libraries.  These will be used if USE_FMEM is defined.
  104.  * Otherwise, the routines below do it the hard way.  (The performance cost
  105.  * is not all that great, because these routines aren't very heavily used.)
  106.  */
  107.  
  108. #define FMEMCOPY(dest,src,size)    MEMCOPY(dest,src,size)
  109. #define FMEMZERO(target,size)    MEMZERO(target,size)
  110.  
  111.  
  112. GLOBAL(void)
  113. jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
  114.            JSAMPARRAY output_array, int dest_row,
  115.            int num_rows, JDIMENSION num_cols)
  116. /* Copy some rows of samples from one place to another.
  117.  * num_rows rows are copied from input_array[source_row++]
  118.  * to output_array[dest_row++]; these areas may overlap for duplication.
  119.  * The source and destination arrays must be at least as wide as num_cols.
  120.  */
  121. {
  122.     register JSAMPROW inptr, outptr;
  123.     register size_t count = (size_t) (num_cols * sizeof(JSAMPLE));
  124.     
  125.     input_array  += source_row;
  126.     output_array += dest_row;
  127.  
  128.     for (int row = num_rows; row > 0; row--) 
  129.     {
  130.         inptr = *input_array++;
  131.         outptr = *output_array++;
  132.         memcpy(outptr, inptr, count);
  133.     }
  134. }
  135.  
  136.  
  137. /* Copy a row of coefficient blocks from one place to another. */
  138. GLOBAL(void)
  139. jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks)
  140. {
  141.     memcpy(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
  142. }
  143.  
  144.  
  145.