LCOV - app.info - media/libjpeg/jutils.c

LCOV - code coverage report
| Current view: | directory - media/libjpeg - jutils.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 20 | 17 | 85.0 %
| Date: | 2012-07-07 | Functions: | 5 | 4 | 80.0 %

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

Generated by: LCOV version 1.7