LCOV - code coverage report
Current view: top level - frmts/gtiff/libtiff - tif_luv.c (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 154 912 16.9 %
Date: 2025-07-09 17:50:03 Functions: 14 51 27.5 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 1997 Greg Ward Larson
       3             :  * Copyright (c) 1997 Silicon Graphics, Inc.
       4             :  *
       5             :  * Permission to use, copy, modify, distribute, and sell this software and
       6             :  * its documentation for any purpose is hereby granted without fee, provided
       7             :  * that (i) the above copyright notices and this permission notice appear in
       8             :  * all copies of the software and related documentation, and (ii) the names of
       9             :  * Sam Leffler, Greg Larson and Silicon Graphics may not be used in any
      10             :  * advertising or publicity relating to the software without the specific,
      11             :  * prior written permission of Sam Leffler, Greg Larson and Silicon Graphics.
      12             :  *
      13             :  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
      14             :  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
      15             :  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
      16             :  *
      17             :  * IN NO EVENT SHALL SAM LEFFLER, GREG LARSON OR SILICON GRAPHICS BE LIABLE
      18             :  * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
      19             :  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
      20             :  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
      21             :  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
      22             :  * OF THIS SOFTWARE.
      23             :  */
      24             : 
      25             : #include "tiffiop.h"
      26             : #ifdef LOGLUV_SUPPORT
      27             : 
      28             : /*
      29             :  * TIFF Library.
      30             :  * LogLuv compression support for high dynamic range images.
      31             :  *
      32             :  * Contributed by Greg Larson.
      33             :  *
      34             :  * LogLuv image support uses the TIFF library to store 16 or 10-bit
      35             :  * log luminance values with 8 bits each of u and v or a 14-bit index.
      36             :  *
      37             :  * The codec can take as input and produce as output 32-bit IEEE float values
      38             :  * as well as 16-bit integer values.  A 16-bit luminance is interpreted
      39             :  * as a sign bit followed by a 15-bit integer that is converted
      40             :  * to and from a linear magnitude using the transformation:
      41             :  *
      42             :  *  L = 2^( (Le+.5)/256 - 64 )    # real from 15-bit
      43             :  *
      44             :  *  Le = floor( 256*(log2(L) + 64) )  # 15-bit from real
      45             :  *
      46             :  * The actual conversion to world luminance units in candelas per sq. meter
      47             :  * requires an additional multiplier, which is stored in the TIFFTAG_STONITS.
      48             :  * This value is usually set such that a reasonable exposure comes from
      49             :  * clamping decoded luminances above 1 to 1 in the displayed image.
      50             :  *
      51             :  * The 16-bit values for u and v may be converted to real values by dividing
      52             :  * each by 32768.  (This allows for negative values, which aren't useful as
      53             :  * far as we know, but are left in case of future improvements in human
      54             :  * color vision.)
      55             :  *
      56             :  * Conversion from (u,v), which is actually the CIE (u',v') system for
      57             :  * you color scientists, is accomplished by the following transformation:
      58             :  *
      59             :  *  u = 4*x / (-2*x + 12*y + 3)
      60             :  *  v = 9*y / (-2*x + 12*y + 3)
      61             :  *
      62             :  *  x = 9*u / (6*u - 16*v + 12)
      63             :  *  y = 4*v / (6*u - 16*v + 12)
      64             :  *
      65             :  * This process is greatly simplified by passing 32-bit IEEE floats
      66             :  * for each of three CIE XYZ coordinates.  The codec then takes care
      67             :  * of conversion to and from LogLuv, though the application is still
      68             :  * responsible for interpreting the TIFFTAG_STONITS calibration factor.
      69             :  *
      70             :  * By definition, a CIE XYZ vector of [1 1 1] corresponds to a neutral white
      71             :  * point of (x,y)=(1/3,1/3).  However, most color systems assume some other
      72             :  * white point, such as D65, and an absolute color conversion to XYZ then
      73             :  * to another color space with a different white point may introduce an
      74             :  * unwanted color cast to the image.  It is often desirable, therefore, to
      75             :  * perform a white point conversion that maps the input white to [1 1 1]
      76             :  * in XYZ, then record the original white point using the TIFFTAG_WHITEPOINT
      77             :  * tag value.  A decoder that demands absolute color calibration may use
      78             :  * this white point tag to get back the original colors, but usually it
      79             :  * will be ignored and the new white point will be used instead that
      80             :  * matches the output color space.
      81             :  *
      82             :  * Pixel information is compressed into one of two basic encodings, depending
      83             :  * on the setting of the compression tag, which is one of COMPRESSION_SGILOG
      84             :  * or COMPRESSION_SGILOG24.  For COMPRESSION_SGILOG, greyscale data is
      85             :  * stored as:
      86             :  *
      87             :  *   1       15
      88             :  *  |-+---------------|
      89             :  *
      90             :  * COMPRESSION_SGILOG color data is stored as:
      91             :  *
      92             :  *   1       15           8        8
      93             :  *  |-+---------------|--------+--------|
      94             :  *   S       Le           ue       ve
      95             :  *
      96             :  * For the 24-bit COMPRESSION_SGILOG24 color format, the data is stored as:
      97             :  *
      98             :  *       10           14
      99             :  *  |----------|--------------|
     100             :  *       Le'          Ce
     101             :  *
     102             :  * There is no sign bit in the 24-bit case, and the (u,v) chromaticity is
     103             :  * encoded as an index for optimal color resolution.  The 10 log bits are
     104             :  * defined by the following conversions:
     105             :  *
     106             :  *  L = 2^((Le'+.5)/64 - 12)    # real from 10-bit
     107             :  *
     108             :  *  Le' = floor( 64*(log2(L) + 12) )  # 10-bit from real
     109             :  *
     110             :  * The 10 bits of the smaller format may be converted into the 15 bits of
     111             :  * the larger format by multiplying by 4 and adding 13314.  Obviously,
     112             :  * a smaller range of magnitudes is covered (about 5 orders of magnitude
     113             :  * instead of 38), and the lack of a sign bit means that negative luminances
     114             :  * are not allowed.  (Well, they aren't allowed in the real world, either,
     115             :  * but they are useful for certain types of image processing.)
     116             :  *
     117             :  * The desired user format is controlled by the setting the internal
     118             :  * pseudo tag TIFFTAG_SGILOGDATAFMT to one of:
     119             :  *  SGILOGDATAFMT_FLOAT       = IEEE 32-bit float XYZ values
     120             :  *  SGILOGDATAFMT_16BIT       = 16-bit integer encodings of logL, u and v
     121             :  * Raw data i/o is also possible using:
     122             :  *  SGILOGDATAFMT_RAW         = 32-bit unsigned integer with encoded pixel
     123             :  * In addition, the following decoding is provided for ease of display:
     124             :  *  SGILOGDATAFMT_8BIT        = 8-bit default RGB gamma-corrected values
     125             :  *
     126             :  * For grayscale images, we provide the following data formats:
     127             :  *  SGILOGDATAFMT_FLOAT       = IEEE 32-bit float Y values
     128             :  *  SGILOGDATAFMT_16BIT       = 16-bit integer w/ encoded luminance
     129             :  *  SGILOGDATAFMT_8BIT        = 8-bit gray monitor values
     130             :  *
     131             :  * Note that the COMPRESSION_SGILOG applies a simple run-length encoding
     132             :  * scheme by separating the logL, u and v bytes for each row and applying
     133             :  * a PackBits type of compression.  Since the 24-bit encoding is not
     134             :  * adaptive, the 32-bit color format takes less space in many cases.
     135             :  *
     136             :  * Further control is provided over the conversion from higher-resolution
     137             :  * formats to final encoded values through the pseudo tag
     138             :  * TIFFTAG_SGILOGENCODE:
     139             :  *  SGILOGENCODE_NODITHER     = do not dither encoded values
     140             :  *  SGILOGENCODE_RANDITHER    = apply random dithering during encoding
     141             :  *
     142             :  * The default value of this tag is SGILOGENCODE_NODITHER for
     143             :  * COMPRESSION_SGILOG to maximize run-length encoding and
     144             :  * SGILOGENCODE_RANDITHER for COMPRESSION_SGILOG24 to turn
     145             :  * quantization errors into noise.
     146             :  */
     147             : 
     148             : #include <limits.h>
     149             : #include <math.h>
     150             : #include <stdio.h>
     151             : #include <stdlib.h>
     152             : #include <time.h>
     153             : 
     154             : /*
     155             :  * State block for each open TIFF
     156             :  * file using LogLuv compression/decompression.
     157             :  */
     158             : typedef struct logLuvState LogLuvState;
     159             : 
     160             : struct logLuvState
     161             : {
     162             :     int encoder_state; /* 1 if encoder correctly initialized */
     163             :     int user_datafmt;  /* user data format */
     164             :     int encode_meth;   /* encoding method */
     165             :     int pixel_size;    /* bytes per pixel */
     166             : 
     167             :     uint8_t *tbuf;    /* translation buffer */
     168             :     tmsize_t tbuflen; /* buffer length */
     169             :     void (*tfunc)(LogLuvState *, uint8_t *, tmsize_t);
     170             : 
     171             :     TIFFVSetMethod vgetparent; /* super-class method */
     172             :     TIFFVSetMethod vsetparent; /* super-class method */
     173             : };
     174             : 
     175             : #define DecoderState(tif) ((LogLuvState *)(tif)->tif_data)
     176             : #define EncoderState(tif) ((LogLuvState *)(tif)->tif_data)
     177             : 
     178             : #define SGILOGDATAFMT_UNKNOWN -1
     179             : 
     180             : #define MINRUN 4 /* minimum run length */
     181             : 
     182             : /*
     183             :  * Decode a string of 16-bit gray pixels.
     184             :  */
     185          40 : static int LogL16Decode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
     186             : {
     187             :     static const char module[] = "LogL16Decode";
     188          40 :     LogLuvState *sp = DecoderState(tif);
     189             :     int shft;
     190             :     tmsize_t i;
     191             :     tmsize_t npixels;
     192             :     unsigned char *bp;
     193             :     int16_t *tp;
     194             :     int16_t b;
     195             :     tmsize_t cc;
     196             :     int rc;
     197             : 
     198             :     (void)s;
     199          40 :     assert(s == 0);
     200          40 :     assert(sp != NULL);
     201             : 
     202          40 :     npixels = occ / sp->pixel_size;
     203             : 
     204          40 :     if (sp->user_datafmt == SGILOGDATAFMT_16BIT)
     205          20 :         tp = (int16_t *)op;
     206             :     else
     207             :     {
     208          20 :         if (sp->tbuflen < npixels)
     209             :         {
     210           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     211           0 :             return (0);
     212             :         }
     213          20 :         tp = (int16_t *)sp->tbuf;
     214             :     }
     215          40 :     _TIFFmemset((void *)tp, 0, npixels * sizeof(tp[0]));
     216             : 
     217          40 :     bp = (unsigned char *)tif->tif_rawcp;
     218          40 :     cc = tif->tif_rawcc;
     219             :     /* get each byte string */
     220         120 :     for (shft = 8; shft >= 0; shft -= 8)
     221             :     {
     222         168 :         for (i = 0; i < npixels && cc > 0;)
     223             :         {
     224          88 :             if (*bp >= 128)
     225             :             { /* run */
     226          44 :                 if (cc < 2)
     227           0 :                     break;
     228          44 :                 rc = *bp++ + (2 - 128);
     229          44 :                 b = (int16_t)(*bp++ << shft);
     230          44 :                 cc -= 2;
     231         862 :                 while (rc-- && i < npixels)
     232         818 :                     tp[i++] |= b;
     233             :             }
     234             :             else
     235             :             {               /* non-run */
     236          44 :                 rc = *bp++; /* nul is noop */
     237         826 :                 while (--cc && rc-- && i < npixels)
     238         782 :                     tp[i++] |= (int16_t)*bp++ << shft;
     239             :             }
     240             :         }
     241          80 :         if (i != npixels)
     242             :         {
     243           0 :             TIFFErrorExtR(tif, module,
     244             :                           "Not enough data at row %" PRIu32
     245             :                           " (short %" TIFF_SSIZE_FORMAT " pixels)",
     246             :                           tif->tif_row, npixels - i);
     247           0 :             tif->tif_rawcp = (uint8_t *)bp;
     248           0 :             tif->tif_rawcc = cc;
     249           0 :             return (0);
     250             :         }
     251             :     }
     252          40 :     (*sp->tfunc)(sp, op, npixels);
     253          40 :     tif->tif_rawcp = (uint8_t *)bp;
     254          40 :     tif->tif_rawcc = cc;
     255          40 :     return (1);
     256             : }
     257             : 
     258             : /*
     259             :  * Decode a string of 24-bit pixels.
     260             :  */
     261           0 : static int LogLuvDecode24(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
     262             : {
     263             :     static const char module[] = "LogLuvDecode24";
     264           0 :     LogLuvState *sp = DecoderState(tif);
     265             :     tmsize_t cc;
     266             :     tmsize_t i;
     267             :     tmsize_t npixels;
     268             :     unsigned char *bp;
     269             :     uint32_t *tp;
     270             : 
     271             :     (void)s;
     272           0 :     assert(s == 0);
     273           0 :     assert(sp != NULL);
     274             : 
     275           0 :     npixels = occ / sp->pixel_size;
     276             : 
     277           0 :     if (sp->user_datafmt == SGILOGDATAFMT_RAW)
     278           0 :         tp = (uint32_t *)op;
     279             :     else
     280             :     {
     281           0 :         if (sp->tbuflen < npixels)
     282             :         {
     283           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     284           0 :             return (0);
     285             :         }
     286           0 :         tp = (uint32_t *)sp->tbuf;
     287             :     }
     288             :     /* copy to array of uint32_t */
     289           0 :     bp = (unsigned char *)tif->tif_rawcp;
     290           0 :     cc = tif->tif_rawcc;
     291           0 :     for (i = 0; i < npixels && cc >= 3; i++)
     292             :     {
     293           0 :         tp[i] = bp[0] << 16 | bp[1] << 8 | bp[2];
     294           0 :         bp += 3;
     295           0 :         cc -= 3;
     296             :     }
     297           0 :     tif->tif_rawcp = (uint8_t *)bp;
     298           0 :     tif->tif_rawcc = cc;
     299           0 :     if (i != npixels)
     300             :     {
     301           0 :         TIFFErrorExtR(tif, module,
     302             :                       "Not enough data at row %" PRIu32
     303             :                       " (short %" TIFF_SSIZE_FORMAT " pixels)",
     304             :                       tif->tif_row, npixels - i);
     305           0 :         return (0);
     306             :     }
     307           0 :     (*sp->tfunc)(sp, op, npixels);
     308           0 :     return (1);
     309             : }
     310             : 
     311             : /*
     312             :  * Decode a string of 32-bit pixels.
     313             :  */
     314           0 : static int LogLuvDecode32(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
     315             : {
     316             :     static const char module[] = "LogLuvDecode32";
     317             :     LogLuvState *sp;
     318             :     int shft;
     319             :     tmsize_t i;
     320             :     tmsize_t npixels;
     321             :     unsigned char *bp;
     322             :     uint32_t *tp;
     323             :     uint32_t b;
     324             :     tmsize_t cc;
     325             :     int rc;
     326             : 
     327             :     (void)s;
     328           0 :     assert(s == 0);
     329           0 :     sp = DecoderState(tif);
     330           0 :     assert(sp != NULL);
     331             : 
     332           0 :     npixels = occ / sp->pixel_size;
     333             : 
     334           0 :     if (sp->user_datafmt == SGILOGDATAFMT_RAW)
     335           0 :         tp = (uint32_t *)op;
     336             :     else
     337             :     {
     338           0 :         if (sp->tbuflen < npixels)
     339             :         {
     340           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     341           0 :             return (0);
     342             :         }
     343           0 :         tp = (uint32_t *)sp->tbuf;
     344             :     }
     345           0 :     _TIFFmemset((void *)tp, 0, npixels * sizeof(tp[0]));
     346             : 
     347           0 :     bp = (unsigned char *)tif->tif_rawcp;
     348           0 :     cc = tif->tif_rawcc;
     349             :     /* get each byte string */
     350           0 :     for (shft = 24; shft >= 0; shft -= 8)
     351             :     {
     352           0 :         for (i = 0; i < npixels && cc > 0;)
     353             :         {
     354           0 :             if (*bp >= 128)
     355             :             { /* run */
     356           0 :                 if (cc < 2)
     357           0 :                     break;
     358           0 :                 rc = *bp++ + (2 - 128);
     359           0 :                 b = (uint32_t)*bp++ << shft;
     360           0 :                 cc -= 2;
     361           0 :                 while (rc-- && i < npixels)
     362           0 :                     tp[i++] |= b;
     363             :             }
     364             :             else
     365             :             {               /* non-run */
     366           0 :                 rc = *bp++; /* nul is noop */
     367           0 :                 while (--cc && rc-- && i < npixels)
     368           0 :                     tp[i++] |= (uint32_t)*bp++ << shft;
     369             :             }
     370             :         }
     371           0 :         if (i != npixels)
     372             :         {
     373           0 :             TIFFErrorExtR(tif, module,
     374             :                           "Not enough data at row %" PRIu32
     375             :                           " (short %" TIFF_SSIZE_FORMAT " pixels)",
     376             :                           tif->tif_row, npixels - i);
     377           0 :             tif->tif_rawcp = (uint8_t *)bp;
     378           0 :             tif->tif_rawcc = cc;
     379           0 :             return (0);
     380             :         }
     381             :     }
     382           0 :     (*sp->tfunc)(sp, op, npixels);
     383           0 :     tif->tif_rawcp = (uint8_t *)bp;
     384           0 :     tif->tif_rawcc = cc;
     385           0 :     return (1);
     386             : }
     387             : 
     388             : /*
     389             :  * Decode a strip of pixels.  We break it into rows to
     390             :  * maintain synchrony with the encode algorithm, which
     391             :  * is row by row.
     392             :  */
     393           2 : static int LogLuvDecodeStrip(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     394             : {
     395           2 :     tmsize_t rowlen = TIFFScanlineSize(tif);
     396             : 
     397           2 :     if (rowlen == 0)
     398           0 :         return 0;
     399             : 
     400           2 :     assert(cc % rowlen == 0);
     401          42 :     while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s))
     402             :     {
     403          40 :         bp += rowlen;
     404          40 :         cc -= rowlen;
     405             :     }
     406           2 :     return (cc == 0);
     407             : }
     408             : 
     409             : /*
     410             :  * Decode a tile of pixels.  We break it into rows to
     411             :  * maintain synchrony with the encode algorithm, which
     412             :  * is row by row.
     413             :  */
     414           0 : static int LogLuvDecodeTile(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     415             : {
     416           0 :     tmsize_t rowlen = TIFFTileRowSize(tif);
     417             : 
     418           0 :     if (rowlen == 0)
     419           0 :         return 0;
     420             : 
     421           0 :     assert(cc % rowlen == 0);
     422           0 :     while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s))
     423             :     {
     424           0 :         bp += rowlen;
     425           0 :         cc -= rowlen;
     426             :     }
     427           0 :     return (cc == 0);
     428             : }
     429             : 
     430             : /*
     431             :  * Encode a row of 16-bit pixels.
     432             :  */
     433           0 : static int LogL16Encode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     434             : {
     435             :     static const char module[] = "LogL16Encode";
     436           0 :     LogLuvState *sp = EncoderState(tif);
     437             :     int shft;
     438             :     tmsize_t i;
     439             :     tmsize_t j;
     440             :     tmsize_t npixels;
     441             :     uint8_t *op;
     442             :     int16_t *tp;
     443             :     int16_t b;
     444             :     tmsize_t occ;
     445           0 :     int rc = 0, mask;
     446             :     tmsize_t beg;
     447             : 
     448             :     (void)s;
     449           0 :     assert(s == 0);
     450           0 :     assert(sp != NULL);
     451           0 :     npixels = cc / sp->pixel_size;
     452             : 
     453           0 :     if (sp->user_datafmt == SGILOGDATAFMT_16BIT)
     454           0 :         tp = (int16_t *)bp;
     455             :     else
     456             :     {
     457           0 :         tp = (int16_t *)sp->tbuf;
     458           0 :         if (sp->tbuflen < npixels)
     459             :         {
     460           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     461           0 :             return (0);
     462             :         }
     463           0 :         (*sp->tfunc)(sp, bp, npixels);
     464             :     }
     465             :     /* compress each byte string */
     466           0 :     op = tif->tif_rawcp;
     467           0 :     occ = tif->tif_rawdatasize - tif->tif_rawcc;
     468           0 :     for (shft = 8; shft >= 0; shft -= 8)
     469             :     {
     470           0 :         for (i = 0; i < npixels; i += rc)
     471             :         {
     472           0 :             if (occ < 4)
     473             :             {
     474           0 :                 tif->tif_rawcp = op;
     475           0 :                 tif->tif_rawcc = tif->tif_rawdatasize - occ;
     476           0 :                 if (!TIFFFlushData1(tif))
     477           0 :                     return (0);
     478           0 :                 op = tif->tif_rawcp;
     479           0 :                 occ = tif->tif_rawdatasize - tif->tif_rawcc;
     480             :             }
     481           0 :             mask = 0xff << shft; /* find next run */
     482           0 :             for (beg = i; beg < npixels; beg += rc)
     483             :             {
     484           0 :                 b = (int16_t)(tp[beg] & mask);
     485           0 :                 rc = 1;
     486           0 :                 while (rc < 127 + 2 && beg + rc < npixels &&
     487           0 :                        (tp[beg + rc] & mask) == b)
     488           0 :                     rc++;
     489           0 :                 if (rc >= MINRUN)
     490           0 :                     break; /* long enough */
     491             :             }
     492           0 :             if (beg - i > 1 && beg - i < MINRUN)
     493             :             {
     494           0 :                 b = (int16_t)(tp[i] & mask); /*check short run */
     495           0 :                 j = i + 1;
     496           0 :                 while ((tp[j++] & mask) == b)
     497           0 :                     if (j == beg)
     498             :                     {
     499           0 :                         *op++ = (uint8_t)(128 - 2 + j - i);
     500           0 :                         *op++ = (uint8_t)(b >> shft);
     501           0 :                         occ -= 2;
     502           0 :                         i = beg;
     503           0 :                         break;
     504             :                     }
     505             :             }
     506           0 :             while (i < beg)
     507             :             { /* write out non-run */
     508           0 :                 if ((j = beg - i) > 127)
     509           0 :                     j = 127;
     510           0 :                 if (occ < j + 3)
     511             :                 {
     512           0 :                     tif->tif_rawcp = op;
     513           0 :                     tif->tif_rawcc = tif->tif_rawdatasize - occ;
     514           0 :                     if (!TIFFFlushData1(tif))
     515           0 :                         return (0);
     516           0 :                     op = tif->tif_rawcp;
     517           0 :                     occ = tif->tif_rawdatasize - tif->tif_rawcc;
     518             :                 }
     519           0 :                 *op++ = (uint8_t)j;
     520           0 :                 occ--;
     521           0 :                 while (j--)
     522             :                 {
     523           0 :                     *op++ = (uint8_t)(tp[i++] >> shft & 0xff);
     524           0 :                     occ--;
     525             :                 }
     526             :             }
     527           0 :             if (rc >= MINRUN)
     528             :             { /* write out run */
     529           0 :                 *op++ = (uint8_t)(128 - 2 + rc);
     530           0 :                 *op++ = (uint8_t)(tp[beg] >> shft & 0xff);
     531           0 :                 occ -= 2;
     532             :             }
     533             :             else
     534           0 :                 rc = 0;
     535             :         }
     536             :     }
     537           0 :     tif->tif_rawcp = op;
     538           0 :     tif->tif_rawcc = tif->tif_rawdatasize - occ;
     539             : 
     540           0 :     return (1);
     541             : }
     542             : 
     543             : /*
     544             :  * Encode a row of 24-bit pixels.
     545             :  */
     546           0 : static int LogLuvEncode24(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     547             : {
     548             :     static const char module[] = "LogLuvEncode24";
     549           0 :     LogLuvState *sp = EncoderState(tif);
     550             :     tmsize_t i;
     551             :     tmsize_t npixels;
     552             :     tmsize_t occ;
     553             :     uint8_t *op;
     554             :     uint32_t *tp;
     555             : 
     556             :     (void)s;
     557           0 :     assert(s == 0);
     558           0 :     assert(sp != NULL);
     559           0 :     npixels = cc / sp->pixel_size;
     560             : 
     561           0 :     if (sp->user_datafmt == SGILOGDATAFMT_RAW)
     562           0 :         tp = (uint32_t *)bp;
     563             :     else
     564             :     {
     565           0 :         tp = (uint32_t *)sp->tbuf;
     566           0 :         if (sp->tbuflen < npixels)
     567             :         {
     568           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     569           0 :             return (0);
     570             :         }
     571           0 :         (*sp->tfunc)(sp, bp, npixels);
     572             :     }
     573             :     /* write out encoded pixels */
     574           0 :     op = tif->tif_rawcp;
     575           0 :     occ = tif->tif_rawdatasize - tif->tif_rawcc;
     576           0 :     for (i = npixels; i--;)
     577             :     {
     578           0 :         if (occ < 3)
     579             :         {
     580           0 :             tif->tif_rawcp = op;
     581           0 :             tif->tif_rawcc = tif->tif_rawdatasize - occ;
     582           0 :             if (!TIFFFlushData1(tif))
     583           0 :                 return (0);
     584           0 :             op = tif->tif_rawcp;
     585           0 :             occ = tif->tif_rawdatasize - tif->tif_rawcc;
     586             :         }
     587           0 :         *op++ = (uint8_t)(*tp >> 16);
     588           0 :         *op++ = (uint8_t)(*tp >> 8 & 0xff);
     589           0 :         *op++ = (uint8_t)(*tp++ & 0xff);
     590           0 :         occ -= 3;
     591             :     }
     592           0 :     tif->tif_rawcp = op;
     593           0 :     tif->tif_rawcc = tif->tif_rawdatasize - occ;
     594             : 
     595           0 :     return (1);
     596             : }
     597             : 
     598             : /*
     599             :  * Encode a row of 32-bit pixels.
     600             :  */
     601           0 : static int LogLuvEncode32(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     602             : {
     603             :     static const char module[] = "LogLuvEncode32";
     604           0 :     LogLuvState *sp = EncoderState(tif);
     605             :     int shft;
     606             :     tmsize_t i;
     607             :     tmsize_t j;
     608             :     tmsize_t npixels;
     609             :     uint8_t *op;
     610             :     uint32_t *tp;
     611             :     uint32_t b;
     612             :     tmsize_t occ;
     613           0 :     int rc = 0;
     614             :     tmsize_t beg;
     615             : 
     616             :     (void)s;
     617           0 :     assert(s == 0);
     618           0 :     assert(sp != NULL);
     619             : 
     620           0 :     npixels = cc / sp->pixel_size;
     621             : 
     622           0 :     if (sp->user_datafmt == SGILOGDATAFMT_RAW)
     623           0 :         tp = (uint32_t *)bp;
     624             :     else
     625             :     {
     626           0 :         tp = (uint32_t *)sp->tbuf;
     627           0 :         if (sp->tbuflen < npixels)
     628             :         {
     629           0 :             TIFFErrorExtR(tif, module, "Translation buffer too short");
     630           0 :             return (0);
     631             :         }
     632           0 :         (*sp->tfunc)(sp, bp, npixels);
     633             :     }
     634             :     /* compress each byte string */
     635           0 :     op = tif->tif_rawcp;
     636           0 :     occ = tif->tif_rawdatasize - tif->tif_rawcc;
     637           0 :     for (shft = 24; shft >= 0; shft -= 8)
     638             :     {
     639           0 :         const uint32_t mask = 0xffU << shft; /* find next run */
     640           0 :         for (i = 0; i < npixels; i += rc)
     641             :         {
     642           0 :             if (occ < 4)
     643             :             {
     644           0 :                 tif->tif_rawcp = op;
     645           0 :                 tif->tif_rawcc = tif->tif_rawdatasize - occ;
     646           0 :                 if (!TIFFFlushData1(tif))
     647           0 :                     return (0);
     648           0 :                 op = tif->tif_rawcp;
     649           0 :                 occ = tif->tif_rawdatasize - tif->tif_rawcc;
     650             :             }
     651           0 :             for (beg = i; beg < npixels; beg += rc)
     652             :             {
     653           0 :                 b = tp[beg] & mask;
     654           0 :                 rc = 1;
     655           0 :                 while (rc < 127 + 2 && beg + rc < npixels &&
     656           0 :                        (tp[beg + rc] & mask) == b)
     657           0 :                     rc++;
     658           0 :                 if (rc >= MINRUN)
     659           0 :                     break; /* long enough */
     660             :             }
     661           0 :             if (beg - i > 1 && beg - i < MINRUN)
     662             :             {
     663           0 :                 b = tp[i] & mask; /* check short run */
     664           0 :                 j = i + 1;
     665           0 :                 while ((tp[j++] & mask) == b)
     666           0 :                     if (j == beg)
     667             :                     {
     668           0 :                         *op++ = (uint8_t)(128 - 2 + j - i);
     669           0 :                         *op++ = (uint8_t)(b >> shft);
     670           0 :                         occ -= 2;
     671           0 :                         i = beg;
     672           0 :                         break;
     673             :                     }
     674             :             }
     675           0 :             while (i < beg)
     676             :             { /* write out non-run */
     677           0 :                 if ((j = beg - i) > 127)
     678           0 :                     j = 127;
     679           0 :                 if (occ < j + 3)
     680             :                 {
     681           0 :                     tif->tif_rawcp = op;
     682           0 :                     tif->tif_rawcc = tif->tif_rawdatasize - occ;
     683           0 :                     if (!TIFFFlushData1(tif))
     684           0 :                         return (0);
     685           0 :                     op = tif->tif_rawcp;
     686           0 :                     occ = tif->tif_rawdatasize - tif->tif_rawcc;
     687             :                 }
     688           0 :                 *op++ = (uint8_t)j;
     689           0 :                 occ--;
     690           0 :                 while (j--)
     691             :                 {
     692           0 :                     *op++ = (uint8_t)(tp[i++] >> shft & 0xff);
     693           0 :                     occ--;
     694             :                 }
     695             :             }
     696           0 :             if (rc >= MINRUN)
     697             :             { /* write out run */
     698           0 :                 *op++ = (uint8_t)(128 - 2 + rc);
     699           0 :                 *op++ = (uint8_t)(tp[beg] >> shft & 0xff);
     700           0 :                 occ -= 2;
     701             :             }
     702             :             else
     703           0 :                 rc = 0;
     704             :         }
     705             :     }
     706           0 :     tif->tif_rawcp = op;
     707           0 :     tif->tif_rawcc = tif->tif_rawdatasize - occ;
     708             : 
     709           0 :     return (1);
     710             : }
     711             : 
     712             : /*
     713             :  * Encode a strip of pixels.  We break it into rows to
     714             :  * avoid encoding runs across row boundaries.
     715             :  */
     716           0 : static int LogLuvEncodeStrip(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     717             : {
     718           0 :     tmsize_t rowlen = TIFFScanlineSize(tif);
     719             : 
     720           0 :     if (rowlen == 0)
     721           0 :         return 0;
     722             : 
     723           0 :     assert(cc % rowlen == 0);
     724           0 :     while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
     725             :     {
     726           0 :         bp += rowlen;
     727           0 :         cc -= rowlen;
     728             :     }
     729           0 :     return (cc == 0);
     730             : }
     731             : 
     732             : /*
     733             :  * Encode a tile of pixels.  We break it into rows to
     734             :  * avoid encoding runs across row boundaries.
     735             :  */
     736           0 : static int LogLuvEncodeTile(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
     737             : {
     738           0 :     tmsize_t rowlen = TIFFTileRowSize(tif);
     739             : 
     740           0 :     if (rowlen == 0)
     741           0 :         return 0;
     742             : 
     743           0 :     assert(cc % rowlen == 0);
     744           0 :     while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
     745             :     {
     746           0 :         bp += rowlen;
     747           0 :         cc -= rowlen;
     748             :     }
     749           0 :     return (cc == 0);
     750             : }
     751             : 
     752             : /*
     753             :  * Encode/Decode functions for converting to and from user formats.
     754             :  */
     755             : 
     756             : #include "uvcode.h"
     757             : 
     758             : #ifndef UVSCALE
     759             : #define U_NEU 0.210526316
     760             : #define V_NEU 0.473684211
     761             : #define UVSCALE 410.
     762             : #endif
     763             : 
     764             : #ifndef M_LN2
     765             : #define M_LN2 0.69314718055994530942
     766             : #endif
     767             : #ifndef M_PI
     768             : #define M_PI 3.14159265358979323846
     769             : #endif
     770             : #undef log2 /* Conflict with C'99 function */
     771             : #define log2(x) ((1. / M_LN2) * log(x))
     772             : #undef exp2 /* Conflict with C'99 function */
     773             : #define exp2(x) exp(M_LN2 *(x))
     774             : 
     775             : #define TIFF_RAND_MAX 32767
     776             : 
     777             : // From POSIX.1-2001 as an example of an implementation of rand()
     778           0 : static uint32_t _TIFFRand()
     779             : {
     780             :     static uint32_t nCounter = 0;
     781           0 :     if (!nCounter)
     782           0 :         nCounter = (uint32_t)(time(NULL) & UINT32_MAX);
     783           0 :     ++nCounter;
     784           0 :     uint32_t nCounterLocal =
     785           0 :         (uint32_t)(((uint64_t)(nCounter)*1103515245U + 12345U) & UINT32_MAX);
     786           0 :     nCounter = nCounterLocal;
     787           0 :     return (nCounterLocal / 65536U) % (TIFF_RAND_MAX + 1);
     788             : };
     789             : 
     790           0 : static int tiff_itrunc(double x, int m)
     791             : {
     792           0 :     if (m == SGILOGENCODE_NODITHER)
     793           0 :         return (int)x;
     794           0 :     return (int)(x + _TIFFRand() * (1. / TIFF_RAND_MAX) - .5);
     795             : }
     796             : 
     797             : #if !LOGLUV_PUBLIC
     798             : static
     799             : #endif
     800             :     double
     801         400 :     LogL16toY(int p16) /* compute luminance from 16-bit LogL */
     802             : {
     803         400 :     int Le = p16 & 0x7fff;
     804             :     double Y;
     805             : 
     806         400 :     if (!Le)
     807           0 :         return (0.);
     808         400 :     Y = exp(M_LN2 / 256. * (Le + .5) - M_LN2 * 64.);
     809         400 :     return (!(p16 & 0x8000) ? Y : -Y);
     810             : }
     811             : 
     812             : #if !LOGLUV_PUBLIC
     813             : static
     814             : #endif
     815             :     int
     816           0 :     LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */
     817             : {
     818           0 :     if (Y >= 1.8371976e19)
     819           0 :         return (0x7fff);
     820           0 :     if (Y <= -1.8371976e19)
     821           0 :         return (0xffff);
     822           0 :     if (Y > 5.4136769e-20)
     823           0 :         return tiff_itrunc(256. * (log2(Y) + 64.), em);
     824           0 :     if (Y < -5.4136769e-20)
     825           0 :         return (~0x7fff | tiff_itrunc(256. * (log2(-Y) + 64.), em));
     826           0 :     return (0);
     827             : }
     828             : 
     829           0 : static void L16toY(LogLuvState *sp, uint8_t *op, tmsize_t n)
     830             : {
     831           0 :     int16_t *l16 = (int16_t *)sp->tbuf;
     832           0 :     float *yp = (float *)op;
     833             : 
     834           0 :     while (n-- > 0)
     835           0 :         *yp++ = (float)LogL16toY(*l16++);
     836           0 : }
     837             : 
     838          20 : static void L16toGry(LogLuvState *sp, uint8_t *op, tmsize_t n)
     839             : {
     840          20 :     int16_t *l16 = (int16_t *)sp->tbuf;
     841          20 :     uint8_t *gp = (uint8_t *)op;
     842             : 
     843         420 :     while (n-- > 0)
     844             :     {
     845         400 :         double Y = LogL16toY(*l16++);
     846         800 :         *gp++ = (uint8_t)((Y <= 0.)   ? 0
     847             :                           : (Y >= 1.) ? 255
     848         400 :                                       : (int)(256. * sqrt(Y)));
     849             :     }
     850          20 : }
     851             : 
     852           0 : static void L16fromY(LogLuvState *sp, uint8_t *op, tmsize_t n)
     853             : {
     854           0 :     int16_t *l16 = (int16_t *)sp->tbuf;
     855           0 :     float *yp = (float *)op;
     856             : 
     857           0 :     while (n-- > 0)
     858           0 :         *l16++ = (int16_t)(LogL16fromY(*yp++, sp->encode_meth));
     859           0 : }
     860             : 
     861             : #if !LOGLUV_PUBLIC
     862             : static
     863             : #endif
     864             :     void
     865           0 :     XYZtoRGB24(float *xyz, uint8_t *rgb)
     866             : {
     867             :     double r, g, b;
     868             :     /* assume CCIR-709 primaries */
     869           0 :     r = 2.690 * xyz[0] + -1.276 * xyz[1] + -0.414 * xyz[2];
     870           0 :     g = -1.022 * xyz[0] + 1.978 * xyz[1] + 0.044 * xyz[2];
     871           0 :     b = 0.061 * xyz[0] + -0.224 * xyz[1] + 1.163 * xyz[2];
     872             :     /* assume 2.0 gamma for speed */
     873             :     /* could use integer sqrt approx., but this is probably faster */
     874           0 :     rgb[0] = (uint8_t)((r <= 0.) ? 0 : (r >= 1.) ? 255 : (int)(256. * sqrt(r)));
     875           0 :     rgb[1] = (uint8_t)((g <= 0.) ? 0 : (g >= 1.) ? 255 : (int)(256. * sqrt(g)));
     876           0 :     rgb[2] = (uint8_t)((b <= 0.) ? 0 : (b >= 1.) ? 255 : (int)(256. * sqrt(b)));
     877           0 : }
     878             : 
     879             : #if !LOGLUV_PUBLIC
     880             : static
     881             : #endif
     882             :     double
     883           0 :     LogL10toY(int p10) /* compute luminance from 10-bit LogL */
     884             : {
     885           0 :     if (p10 == 0)
     886           0 :         return (0.);
     887           0 :     return (exp(M_LN2 / 64. * (p10 + .5) - M_LN2 * 12.));
     888             : }
     889             : 
     890             : #if !LOGLUV_PUBLIC
     891             : static
     892             : #endif
     893             :     int
     894           0 :     LogL10fromY(double Y, int em) /* get 10-bit LogL from Y */
     895             : {
     896           0 :     if (Y >= 15.742)
     897           0 :         return (0x3ff);
     898           0 :     else if (Y <= .00024283)
     899           0 :         return (0);
     900             :     else
     901           0 :         return tiff_itrunc(64. * (log2(Y) + 12.), em);
     902             : }
     903             : 
     904             : #define NANGLES 100
     905             : #define uv2ang(u, v)                                                           \
     906             :     ((NANGLES * .499999999 / M_PI) * atan2((v)-V_NEU, (u)-U_NEU) + .5 * NANGLES)
     907             : 
     908           0 : static int oog_encode(double u, double v) /* encode out-of-gamut chroma */
     909             : {
     910             :     static int oog_table[NANGLES];
     911             :     static int initialized = 0;
     912             :     register int i;
     913             : 
     914           0 :     if (!initialized)
     915             :     { /* set up perimeter table */
     916             :         double eps[NANGLES], ua, va, ang, epsa;
     917             :         int ui, vi, ustep;
     918           0 :         for (i = NANGLES; i--;)
     919           0 :             eps[i] = 2.;
     920           0 :         for (vi = UV_NVS; vi--;)
     921             :         {
     922           0 :             va = UV_VSTART + (vi + .5) * UV_SQSIZ;
     923           0 :             ustep = uv_row[vi].nus - 1;
     924           0 :             if (vi == UV_NVS - 1 || vi == 0 || ustep <= 0)
     925           0 :                 ustep = 1;
     926           0 :             for (ui = uv_row[vi].nus - 1; ui >= 0; ui -= ustep)
     927             :             {
     928           0 :                 ua = uv_row[vi].ustart + (ui + .5) * UV_SQSIZ;
     929           0 :                 ang = uv2ang(ua, va);
     930           0 :                 i = (int)ang;
     931           0 :                 epsa = fabs(ang - (i + .5));
     932           0 :                 if (epsa < eps[i])
     933             :                 {
     934           0 :                     oog_table[i] = uv_row[vi].ncum + ui;
     935           0 :                     eps[i] = epsa;
     936             :                 }
     937             :             }
     938             :         }
     939           0 :         for (i = NANGLES; i--;) /* fill any holes */
     940           0 :             if (eps[i] > 1.5)
     941             :             {
     942             :                 int i1, i2;
     943           0 :                 for (i1 = 1; i1 < NANGLES / 2; i1++)
     944           0 :                     if (eps[(i + i1) % NANGLES] < 1.5)
     945           0 :                         break;
     946           0 :                 for (i2 = 1; i2 < NANGLES / 2; i2++)
     947           0 :                     if (eps[(i + NANGLES - i2) % NANGLES] < 1.5)
     948           0 :                         break;
     949           0 :                 if (i1 < i2)
     950           0 :                     oog_table[i] = oog_table[(i + i1) % NANGLES];
     951             :                 else
     952           0 :                     oog_table[i] = oog_table[(i + NANGLES - i2) % NANGLES];
     953             :             }
     954           0 :         initialized = 1;
     955             :     }
     956           0 :     i = (int)uv2ang(u, v); /* look up hue angle */
     957           0 :     return (oog_table[i]);
     958             : }
     959             : 
     960             : #undef uv2ang
     961             : #undef NANGLES
     962             : 
     963             : #if !LOGLUV_PUBLIC
     964             : static
     965             : #endif
     966             :     int
     967           0 :     uv_encode(double u, double v, int em) /* encode (u',v') coordinates */
     968             : {
     969             :     unsigned int vi;
     970             :     int ui;
     971             : 
     972             :     /* check for NaN */
     973           0 :     if (u != u || v != v)
     974             :     {
     975           0 :         u = U_NEU;
     976           0 :         v = V_NEU;
     977             :     }
     978             : 
     979           0 :     if (v < UV_VSTART)
     980           0 :         return oog_encode(u, v);
     981           0 :     vi = tiff_itrunc((v - UV_VSTART) * (1. / UV_SQSIZ), em);
     982           0 :     if (vi >= UV_NVS)
     983           0 :         return oog_encode(u, v);
     984           0 :     if (u < uv_row[vi].ustart)
     985           0 :         return oog_encode(u, v);
     986           0 :     ui = tiff_itrunc((u - uv_row[vi].ustart) * (1. / UV_SQSIZ), em);
     987           0 :     if (ui >= uv_row[vi].nus)
     988           0 :         return oog_encode(u, v);
     989             : 
     990           0 :     return (uv_row[vi].ncum + ui);
     991             : }
     992             : 
     993             : #if !LOGLUV_PUBLIC
     994             : static
     995             : #endif
     996             :     int
     997           0 :     uv_decode(double *up, double *vp, int c) /* decode (u',v') index */
     998             : {
     999             :     unsigned int upper, lower;
    1000             :     int ui;
    1001             :     unsigned int vi;
    1002             : 
    1003           0 :     if (c < 0 || c >= UV_NDIVS)
    1004           0 :         return (-1);
    1005           0 :     lower = 0; /* binary search */
    1006           0 :     upper = UV_NVS;
    1007           0 :     while (upper - lower > 1)
    1008             :     {
    1009           0 :         vi = (lower + upper) >> 1;
    1010           0 :         ui = c - uv_row[vi].ncum;
    1011           0 :         if (ui > 0)
    1012           0 :             lower = vi;
    1013           0 :         else if (ui < 0)
    1014           0 :             upper = vi;
    1015             :         else
    1016             :         {
    1017           0 :             lower = vi;
    1018           0 :             break;
    1019             :         }
    1020             :     }
    1021           0 :     vi = lower;
    1022           0 :     ui = c - uv_row[vi].ncum;
    1023           0 :     *up = uv_row[vi].ustart + (ui + .5) * UV_SQSIZ;
    1024           0 :     *vp = UV_VSTART + (vi + .5) * UV_SQSIZ;
    1025           0 :     return (0);
    1026             : }
    1027             : 
    1028             : #if !LOGLUV_PUBLIC
    1029             : static
    1030             : #endif
    1031             :     void
    1032           0 :     LogLuv24toXYZ(uint32_t p, float *XYZ)
    1033             : {
    1034             :     int Ce;
    1035             :     double L, u, v, s, x, y;
    1036             :     /* decode luminance */
    1037           0 :     L = LogL10toY(p >> 14 & 0x3ff);
    1038           0 :     if (L <= 0.)
    1039             :     {
    1040           0 :         XYZ[0] = XYZ[1] = XYZ[2] = 0.;
    1041           0 :         return;
    1042             :     }
    1043             :     /* decode color */
    1044           0 :     Ce = p & 0x3fff;
    1045           0 :     if (uv_decode(&u, &v, Ce) < 0)
    1046             :     {
    1047           0 :         u = U_NEU;
    1048           0 :         v = V_NEU;
    1049             :     }
    1050           0 :     s = 1. / (6. * u - 16. * v + 12.);
    1051           0 :     x = 9. * u * s;
    1052           0 :     y = 4. * v * s;
    1053             :     /* convert to XYZ */
    1054           0 :     XYZ[0] = (float)(x / y * L);
    1055           0 :     XYZ[1] = (float)L;
    1056           0 :     XYZ[2] = (float)((1. - x - y) / y * L);
    1057             : }
    1058             : 
    1059             : #if !LOGLUV_PUBLIC
    1060             : static
    1061             : #endif
    1062             :     uint32_t
    1063           0 :     LogLuv24fromXYZ(float *XYZ, int em)
    1064             : {
    1065             :     int Le, Ce;
    1066             :     double u, v, s;
    1067             :     /* encode luminance */
    1068           0 :     Le = LogL10fromY(XYZ[1], em);
    1069             :     /* encode color */
    1070           0 :     s = XYZ[0] + 15. * XYZ[1] + 3. * XYZ[2];
    1071           0 :     if (!Le || s <= 0.)
    1072             :     {
    1073           0 :         u = U_NEU;
    1074           0 :         v = V_NEU;
    1075             :     }
    1076             :     else
    1077             :     {
    1078           0 :         u = 4. * XYZ[0] / s;
    1079           0 :         v = 9. * XYZ[1] / s;
    1080             :     }
    1081           0 :     Ce = uv_encode(u, v, em);
    1082           0 :     if (Ce < 0) /* never happens */
    1083           0 :         Ce = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
    1084             :     /* combine encodings */
    1085           0 :     return (Le << 14 | Ce);
    1086             : }
    1087             : 
    1088           0 : static void Luv24toXYZ(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1089             : {
    1090           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1091           0 :     float *xyz = (float *)op;
    1092             : 
    1093           0 :     while (n-- > 0)
    1094             :     {
    1095           0 :         LogLuv24toXYZ(*luv, xyz);
    1096           0 :         xyz += 3;
    1097           0 :         luv++;
    1098             :     }
    1099           0 : }
    1100             : 
    1101           0 : static void Luv24toLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1102             : {
    1103           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1104           0 :     int16_t *luv3 = (int16_t *)op;
    1105             : 
    1106           0 :     while (n-- > 0)
    1107             :     {
    1108             :         double u, v;
    1109             : 
    1110           0 :         *luv3++ = (int16_t)((*luv >> 12 & 0xffd) + 13314);
    1111           0 :         if (uv_decode(&u, &v, *luv & 0x3fff) < 0)
    1112             :         {
    1113           0 :             u = U_NEU;
    1114           0 :             v = V_NEU;
    1115             :         }
    1116           0 :         *luv3++ = (int16_t)(u * (1L << 15));
    1117           0 :         *luv3++ = (int16_t)(v * (1L << 15));
    1118           0 :         luv++;
    1119             :     }
    1120           0 : }
    1121             : 
    1122           0 : static void Luv24toRGB(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1123             : {
    1124           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1125           0 :     uint8_t *rgb = (uint8_t *)op;
    1126             : 
    1127           0 :     while (n-- > 0)
    1128             :     {
    1129             :         float xyz[3];
    1130             : 
    1131           0 :         LogLuv24toXYZ(*luv++, xyz);
    1132           0 :         XYZtoRGB24(xyz, rgb);
    1133           0 :         rgb += 3;
    1134             :     }
    1135           0 : }
    1136             : 
    1137           0 : static void Luv24fromXYZ(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1138             : {
    1139           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1140           0 :     float *xyz = (float *)op;
    1141             : 
    1142           0 :     while (n-- > 0)
    1143             :     {
    1144           0 :         *luv++ = LogLuv24fromXYZ(xyz, sp->encode_meth);
    1145           0 :         xyz += 3;
    1146             :     }
    1147           0 : }
    1148             : 
    1149           0 : static void Luv24fromLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1150             : {
    1151           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1152           0 :     int16_t *luv3 = (int16_t *)op;
    1153             : 
    1154           0 :     while (n-- > 0)
    1155             :     {
    1156             :         int Le, Ce;
    1157             : 
    1158           0 :         if (luv3[0] <= 0)
    1159           0 :             Le = 0;
    1160           0 :         else if (luv3[0] >= (1 << 12) + 3314)
    1161           0 :             Le = (1 << 10) - 1;
    1162           0 :         else if (sp->encode_meth == SGILOGENCODE_NODITHER)
    1163           0 :             Le = (luv3[0] - 3314) >> 2;
    1164             :         else
    1165           0 :             Le = tiff_itrunc(.25 * (luv3[0] - 3314.), sp->encode_meth);
    1166             : 
    1167           0 :         Ce = uv_encode((luv3[1] + .5) / (1 << 15), (luv3[2] + .5) / (1 << 15),
    1168             :                        sp->encode_meth);
    1169           0 :         if (Ce < 0) /* never happens */
    1170           0 :             Ce = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
    1171           0 :         *luv++ = (uint32_t)Le << 14 | Ce;
    1172           0 :         luv3 += 3;
    1173             :     }
    1174           0 : }
    1175             : 
    1176             : #if !LOGLUV_PUBLIC
    1177             : static
    1178             : #endif
    1179             :     void
    1180           0 :     LogLuv32toXYZ(uint32_t p, float *XYZ)
    1181             : {
    1182             :     double L, u, v, s, x, y;
    1183             :     /* decode luminance */
    1184           0 :     L = LogL16toY((int)p >> 16);
    1185           0 :     if (L <= 0.)
    1186             :     {
    1187           0 :         XYZ[0] = XYZ[1] = XYZ[2] = 0.;
    1188           0 :         return;
    1189             :     }
    1190             :     /* decode color */
    1191           0 :     u = 1. / UVSCALE * ((p >> 8 & 0xff) + .5);
    1192           0 :     v = 1. / UVSCALE * ((p & 0xff) + .5);
    1193           0 :     s = 1. / (6. * u - 16. * v + 12.);
    1194           0 :     x = 9. * u * s;
    1195           0 :     y = 4. * v * s;
    1196             :     /* convert to XYZ */
    1197           0 :     XYZ[0] = (float)(x / y * L);
    1198           0 :     XYZ[1] = (float)L;
    1199           0 :     XYZ[2] = (float)((1. - x - y) / y * L);
    1200             : }
    1201             : 
    1202             : #if !LOGLUV_PUBLIC
    1203             : static
    1204             : #endif
    1205             :     uint32_t
    1206           0 :     LogLuv32fromXYZ(float *XYZ, int em)
    1207             : {
    1208             :     unsigned int Le, ue, ve;
    1209             :     double u, v, s;
    1210             :     /* encode luminance */
    1211           0 :     Le = (unsigned int)LogL16fromY(XYZ[1], em);
    1212             :     /* encode color */
    1213           0 :     s = XYZ[0] + 15. * XYZ[1] + 3. * XYZ[2];
    1214           0 :     if (!Le || s <= 0.)
    1215             :     {
    1216           0 :         u = U_NEU;
    1217           0 :         v = V_NEU;
    1218             :     }
    1219             :     else
    1220             :     {
    1221           0 :         u = 4. * XYZ[0] / s;
    1222           0 :         v = 9. * XYZ[1] / s;
    1223             :     }
    1224           0 :     if (u <= 0.)
    1225           0 :         ue = 0;
    1226             :     else
    1227           0 :         ue = tiff_itrunc(UVSCALE * u, em);
    1228           0 :     if (ue > 255)
    1229           0 :         ue = 255;
    1230           0 :     if (v <= 0.)
    1231           0 :         ve = 0;
    1232             :     else
    1233           0 :         ve = tiff_itrunc(UVSCALE * v, em);
    1234           0 :     if (ve > 255)
    1235           0 :         ve = 255;
    1236             :     /* combine encodings */
    1237           0 :     return (Le << 16 | ue << 8 | ve);
    1238             : }
    1239             : 
    1240           0 : static void Luv32toXYZ(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1241             : {
    1242           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1243           0 :     float *xyz = (float *)op;
    1244             : 
    1245           0 :     while (n-- > 0)
    1246             :     {
    1247           0 :         LogLuv32toXYZ(*luv++, xyz);
    1248           0 :         xyz += 3;
    1249             :     }
    1250           0 : }
    1251             : 
    1252           0 : static void Luv32toLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1253             : {
    1254           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1255           0 :     int16_t *luv3 = (int16_t *)op;
    1256             : 
    1257           0 :     while (n-- > 0)
    1258             :     {
    1259             :         double u, v;
    1260             : 
    1261           0 :         *luv3++ = (int16_t)(*luv >> 16);
    1262           0 :         u = 1. / UVSCALE * ((*luv >> 8 & 0xff) + .5);
    1263           0 :         v = 1. / UVSCALE * ((*luv & 0xff) + .5);
    1264           0 :         *luv3++ = (int16_t)(u * (1L << 15));
    1265           0 :         *luv3++ = (int16_t)(v * (1L << 15));
    1266           0 :         luv++;
    1267             :     }
    1268           0 : }
    1269             : 
    1270           0 : static void Luv32toRGB(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1271             : {
    1272           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1273           0 :     uint8_t *rgb = (uint8_t *)op;
    1274             : 
    1275           0 :     while (n-- > 0)
    1276             :     {
    1277             :         float xyz[3];
    1278             : 
    1279           0 :         LogLuv32toXYZ(*luv++, xyz);
    1280           0 :         XYZtoRGB24(xyz, rgb);
    1281           0 :         rgb += 3;
    1282             :     }
    1283           0 : }
    1284             : 
    1285           0 : static void Luv32fromXYZ(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1286             : {
    1287           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1288           0 :     float *xyz = (float *)op;
    1289             : 
    1290           0 :     while (n-- > 0)
    1291             :     {
    1292           0 :         *luv++ = LogLuv32fromXYZ(xyz, sp->encode_meth);
    1293           0 :         xyz += 3;
    1294             :     }
    1295           0 : }
    1296             : 
    1297           0 : static void Luv32fromLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1298             : {
    1299           0 :     uint32_t *luv = (uint32_t *)sp->tbuf;
    1300           0 :     int16_t *luv3 = (int16_t *)op;
    1301             : 
    1302           0 :     if (sp->encode_meth == SGILOGENCODE_NODITHER)
    1303             :     {
    1304           0 :         while (n-- > 0)
    1305             :         {
    1306           0 :             *luv++ = (uint32_t)luv3[0] << 16 |
    1307           0 :                      (luv3[1] * (uint32_t)(UVSCALE + .5) >> 7 & 0xff00) |
    1308           0 :                      (luv3[2] * (uint32_t)(UVSCALE + .5) >> 15 & 0xff);
    1309           0 :             luv3 += 3;
    1310             :         }
    1311           0 :         return;
    1312             :     }
    1313           0 :     while (n-- > 0)
    1314             :     {
    1315           0 :         *luv++ =
    1316           0 :             (uint32_t)luv3[0] << 16 |
    1317           0 :             (tiff_itrunc(luv3[1] * (UVSCALE / (1 << 15)), sp->encode_meth)
    1318           0 :                  << 8 &
    1319           0 :              0xff00) |
    1320           0 :             (tiff_itrunc(luv3[2] * (UVSCALE / (1 << 15)), sp->encode_meth) &
    1321             :              0xff);
    1322           0 :         luv3 += 3;
    1323             :     }
    1324             : }
    1325             : 
    1326          20 : static void _logLuvNop(LogLuvState *sp, uint8_t *op, tmsize_t n)
    1327             : {
    1328             :     (void)sp;
    1329             :     (void)op;
    1330             :     (void)n;
    1331          20 : }
    1332             : 
    1333           1 : static int LogL16GuessDataFmt(TIFFDirectory *td)
    1334             : {
    1335             : #define PACK(s, b, f) (((b) << 6) | ((s) << 3) | (f))
    1336           1 :     switch (
    1337           1 :         PACK(td->td_samplesperpixel, td->td_bitspersample, td->td_sampleformat))
    1338             :     {
    1339           0 :         case PACK(1, 32, SAMPLEFORMAT_IEEEFP):
    1340           0 :             return (SGILOGDATAFMT_FLOAT);
    1341           1 :         case PACK(1, 16, SAMPLEFORMAT_VOID):
    1342             :         case PACK(1, 16, SAMPLEFORMAT_INT):
    1343             :         case PACK(1, 16, SAMPLEFORMAT_UINT):
    1344           1 :             return (SGILOGDATAFMT_16BIT);
    1345           0 :         case PACK(1, 8, SAMPLEFORMAT_VOID):
    1346             :         case PACK(1, 8, SAMPLEFORMAT_UINT):
    1347           0 :             return (SGILOGDATAFMT_8BIT);
    1348             :     }
    1349             : #undef PACK
    1350           0 :     return (SGILOGDATAFMT_UNKNOWN);
    1351             : }
    1352             : 
    1353           4 : static tmsize_t multiply_ms(tmsize_t m1, tmsize_t m2)
    1354             : {
    1355           4 :     return _TIFFMultiplySSize(NULL, m1, m2, NULL);
    1356             : }
    1357             : 
    1358           2 : static int LogL16InitState(TIFF *tif)
    1359             : {
    1360             :     static const char module[] = "LogL16InitState";
    1361           2 :     TIFFDirectory *td = &tif->tif_dir;
    1362           2 :     LogLuvState *sp = DecoderState(tif);
    1363             : 
    1364           2 :     assert(sp != NULL);
    1365           2 :     assert(td->td_photometric == PHOTOMETRIC_LOGL);
    1366             : 
    1367           2 :     if (td->td_samplesperpixel != 1)
    1368             :     {
    1369           0 :         TIFFErrorExtR(tif, module,
    1370             :                       "Sorry, can not handle LogL image with %s=%" PRIu16,
    1371           0 :                       "Samples/pixel", td->td_samplesperpixel);
    1372           0 :         return 0;
    1373             :     }
    1374             : 
    1375             :     /* for some reason, we can't do this in TIFFInitLogL16 */
    1376           2 :     if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN)
    1377           1 :         sp->user_datafmt = LogL16GuessDataFmt(td);
    1378           2 :     switch (sp->user_datafmt)
    1379             :     {
    1380           0 :         case SGILOGDATAFMT_FLOAT:
    1381           0 :             sp->pixel_size = sizeof(float);
    1382           0 :             break;
    1383           1 :         case SGILOGDATAFMT_16BIT:
    1384           1 :             sp->pixel_size = sizeof(int16_t);
    1385           1 :             break;
    1386           1 :         case SGILOGDATAFMT_8BIT:
    1387           1 :             sp->pixel_size = sizeof(uint8_t);
    1388           1 :             break;
    1389           0 :         default:
    1390           0 :             TIFFErrorExtR(tif, module,
    1391             :                           "No support for converting user data format to LogL");
    1392           0 :             return (0);
    1393             :     }
    1394           2 :     if (isTiled(tif))
    1395           0 :         sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
    1396           2 :     else if (td->td_rowsperstrip < td->td_imagelength)
    1397           0 :         sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
    1398             :     else
    1399           2 :         sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
    1400           2 :     if (multiply_ms(sp->tbuflen, sizeof(int16_t)) == 0 ||
    1401           2 :         (sp->tbuf = (uint8_t *)_TIFFmallocExt(
    1402           2 :              tif, sp->tbuflen * sizeof(int16_t))) == NULL)
    1403             :     {
    1404           0 :         TIFFErrorExtR(tif, module, "No space for SGILog translation buffer");
    1405           0 :         return (0);
    1406             :     }
    1407           2 :     return (1);
    1408             : }
    1409             : 
    1410           0 : static int LogLuvGuessDataFmt(TIFFDirectory *td)
    1411             : {
    1412             :     int guess;
    1413             : 
    1414             :     /*
    1415             :      * If the user didn't tell us their datafmt,
    1416             :      * take our best guess from the bitspersample.
    1417             :      */
    1418             : #define PACK(a, b) (((a) << 3) | (b))
    1419           0 :     switch (PACK(td->td_bitspersample, td->td_sampleformat))
    1420             :     {
    1421           0 :         case PACK(32, SAMPLEFORMAT_IEEEFP):
    1422           0 :             guess = SGILOGDATAFMT_FLOAT;
    1423           0 :             break;
    1424           0 :         case PACK(32, SAMPLEFORMAT_VOID):
    1425             :         case PACK(32, SAMPLEFORMAT_UINT):
    1426             :         case PACK(32, SAMPLEFORMAT_INT):
    1427           0 :             guess = SGILOGDATAFMT_RAW;
    1428           0 :             break;
    1429           0 :         case PACK(16, SAMPLEFORMAT_VOID):
    1430             :         case PACK(16, SAMPLEFORMAT_INT):
    1431             :         case PACK(16, SAMPLEFORMAT_UINT):
    1432           0 :             guess = SGILOGDATAFMT_16BIT;
    1433           0 :             break;
    1434           0 :         case PACK(8, SAMPLEFORMAT_VOID):
    1435             :         case PACK(8, SAMPLEFORMAT_UINT):
    1436           0 :             guess = SGILOGDATAFMT_8BIT;
    1437           0 :             break;
    1438           0 :         default:
    1439           0 :             guess = SGILOGDATAFMT_UNKNOWN;
    1440           0 :             break;
    1441             : #undef PACK
    1442             :     }
    1443             :     /*
    1444             :      * Double-check samples per pixel.
    1445             :      */
    1446           0 :     switch (td->td_samplesperpixel)
    1447             :     {
    1448           0 :         case 1:
    1449           0 :             if (guess != SGILOGDATAFMT_RAW)
    1450           0 :                 guess = SGILOGDATAFMT_UNKNOWN;
    1451           0 :             break;
    1452           0 :         case 3:
    1453           0 :             if (guess == SGILOGDATAFMT_RAW)
    1454           0 :                 guess = SGILOGDATAFMT_UNKNOWN;
    1455           0 :             break;
    1456           0 :         default:
    1457           0 :             guess = SGILOGDATAFMT_UNKNOWN;
    1458           0 :             break;
    1459             :     }
    1460           0 :     return (guess);
    1461             : }
    1462             : 
    1463           0 : static int LogLuvInitState(TIFF *tif)
    1464             : {
    1465             :     static const char module[] = "LogLuvInitState";
    1466           0 :     TIFFDirectory *td = &tif->tif_dir;
    1467           0 :     LogLuvState *sp = DecoderState(tif);
    1468             : 
    1469           0 :     assert(sp != NULL);
    1470           0 :     assert(td->td_photometric == PHOTOMETRIC_LOGLUV);
    1471             : 
    1472             :     /* for some reason, we can't do this in TIFFInitLogLuv */
    1473           0 :     if (td->td_planarconfig != PLANARCONFIG_CONTIG)
    1474             :     {
    1475           0 :         TIFFErrorExtR(tif, module,
    1476             :                       "SGILog compression cannot handle non-contiguous data");
    1477           0 :         return (0);
    1478             :     }
    1479           0 :     if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN)
    1480           0 :         sp->user_datafmt = LogLuvGuessDataFmt(td);
    1481           0 :     switch (sp->user_datafmt)
    1482             :     {
    1483           0 :         case SGILOGDATAFMT_FLOAT:
    1484           0 :             sp->pixel_size = 3 * sizeof(float);
    1485           0 :             break;
    1486           0 :         case SGILOGDATAFMT_16BIT:
    1487           0 :             sp->pixel_size = 3 * sizeof(int16_t);
    1488           0 :             break;
    1489           0 :         case SGILOGDATAFMT_RAW:
    1490           0 :             sp->pixel_size = sizeof(uint32_t);
    1491           0 :             break;
    1492           0 :         case SGILOGDATAFMT_8BIT:
    1493           0 :             sp->pixel_size = 3 * sizeof(uint8_t);
    1494           0 :             break;
    1495           0 :         default:
    1496           0 :             TIFFErrorExtR(
    1497             :                 tif, module,
    1498             :                 "No support for converting user data format to LogLuv");
    1499           0 :             return (0);
    1500             :     }
    1501           0 :     if (isTiled(tif))
    1502           0 :         sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
    1503           0 :     else if (td->td_rowsperstrip < td->td_imagelength)
    1504           0 :         sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
    1505             :     else
    1506           0 :         sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
    1507           0 :     if (multiply_ms(sp->tbuflen, sizeof(uint32_t)) == 0 ||
    1508           0 :         (sp->tbuf = (uint8_t *)_TIFFmallocExt(
    1509           0 :              tif, sp->tbuflen * sizeof(uint32_t))) == NULL)
    1510             :     {
    1511           0 :         TIFFErrorExtR(tif, module, "No space for SGILog translation buffer");
    1512           0 :         return (0);
    1513             :     }
    1514           0 :     return (1);
    1515             : }
    1516             : 
    1517           3 : static int LogLuvFixupTags(TIFF *tif)
    1518             : {
    1519             :     (void)tif;
    1520           3 :     return (1);
    1521             : }
    1522             : 
    1523           2 : static int LogLuvSetupDecode(TIFF *tif)
    1524             : {
    1525             :     static const char module[] = "LogLuvSetupDecode";
    1526           2 :     LogLuvState *sp = DecoderState(tif);
    1527           2 :     TIFFDirectory *td = &tif->tif_dir;
    1528             : 
    1529           2 :     tif->tif_postdecode = _TIFFNoPostDecode;
    1530           2 :     switch (td->td_photometric)
    1531             :     {
    1532           0 :         case PHOTOMETRIC_LOGLUV:
    1533           0 :             if (!LogLuvInitState(tif))
    1534           0 :                 break;
    1535           0 :             if (td->td_compression == COMPRESSION_SGILOG24)
    1536             :             {
    1537           0 :                 tif->tif_decoderow = LogLuvDecode24;
    1538           0 :                 switch (sp->user_datafmt)
    1539             :                 {
    1540           0 :                     case SGILOGDATAFMT_FLOAT:
    1541           0 :                         sp->tfunc = Luv24toXYZ;
    1542           0 :                         break;
    1543           0 :                     case SGILOGDATAFMT_16BIT:
    1544           0 :                         sp->tfunc = Luv24toLuv48;
    1545           0 :                         break;
    1546           0 :                     case SGILOGDATAFMT_8BIT:
    1547           0 :                         sp->tfunc = Luv24toRGB;
    1548           0 :                         break;
    1549             :                 }
    1550           0 :             }
    1551             :             else
    1552             :             {
    1553           0 :                 tif->tif_decoderow = LogLuvDecode32;
    1554           0 :                 switch (sp->user_datafmt)
    1555             :                 {
    1556           0 :                     case SGILOGDATAFMT_FLOAT:
    1557           0 :                         sp->tfunc = Luv32toXYZ;
    1558           0 :                         break;
    1559           0 :                     case SGILOGDATAFMT_16BIT:
    1560           0 :                         sp->tfunc = Luv32toLuv48;
    1561           0 :                         break;
    1562           0 :                     case SGILOGDATAFMT_8BIT:
    1563           0 :                         sp->tfunc = Luv32toRGB;
    1564           0 :                         break;
    1565             :                 }
    1566           0 :             }
    1567           0 :             return (1);
    1568           2 :         case PHOTOMETRIC_LOGL:
    1569           2 :             if (!LogL16InitState(tif))
    1570           0 :                 break;
    1571           2 :             tif->tif_decoderow = LogL16Decode;
    1572           2 :             switch (sp->user_datafmt)
    1573             :             {
    1574           0 :                 case SGILOGDATAFMT_FLOAT:
    1575           0 :                     sp->tfunc = L16toY;
    1576           0 :                     break;
    1577           1 :                 case SGILOGDATAFMT_8BIT:
    1578           1 :                     sp->tfunc = L16toGry;
    1579           1 :                     break;
    1580             :             }
    1581           2 :             return (1);
    1582           0 :         default:
    1583           0 :             TIFFErrorExtR(tif, module,
    1584             :                           "Inappropriate photometric interpretation %" PRIu16
    1585             :                           " for SGILog compression; %s",
    1586           0 :                           td->td_photometric, "must be either LogLUV or LogL");
    1587           0 :             break;
    1588             :     }
    1589           0 :     return (0);
    1590             : }
    1591             : 
    1592           0 : static int LogLuvSetupEncode(TIFF *tif)
    1593             : {
    1594             :     static const char module[] = "LogLuvSetupEncode";
    1595           0 :     LogLuvState *sp = EncoderState(tif);
    1596           0 :     TIFFDirectory *td = &tif->tif_dir;
    1597             : 
    1598           0 :     switch (td->td_photometric)
    1599             :     {
    1600           0 :         case PHOTOMETRIC_LOGLUV:
    1601           0 :             if (!LogLuvInitState(tif))
    1602           0 :                 return (0);
    1603           0 :             if (td->td_compression == COMPRESSION_SGILOG24)
    1604             :             {
    1605           0 :                 tif->tif_encoderow = LogLuvEncode24;
    1606           0 :                 switch (sp->user_datafmt)
    1607             :                 {
    1608           0 :                     case SGILOGDATAFMT_FLOAT:
    1609           0 :                         sp->tfunc = Luv24fromXYZ;
    1610           0 :                         break;
    1611           0 :                     case SGILOGDATAFMT_16BIT:
    1612           0 :                         sp->tfunc = Luv24fromLuv48;
    1613           0 :                         break;
    1614           0 :                     case SGILOGDATAFMT_RAW:
    1615           0 :                         break;
    1616           0 :                     default:
    1617           0 :                         goto notsupported;
    1618             :                 }
    1619             :             }
    1620             :             else
    1621             :             {
    1622           0 :                 tif->tif_encoderow = LogLuvEncode32;
    1623           0 :                 switch (sp->user_datafmt)
    1624             :                 {
    1625           0 :                     case SGILOGDATAFMT_FLOAT:
    1626           0 :                         sp->tfunc = Luv32fromXYZ;
    1627           0 :                         break;
    1628           0 :                     case SGILOGDATAFMT_16BIT:
    1629           0 :                         sp->tfunc = Luv32fromLuv48;
    1630           0 :                         break;
    1631           0 :                     case SGILOGDATAFMT_RAW:
    1632           0 :                         break;
    1633           0 :                     default:
    1634           0 :                         goto notsupported;
    1635             :                 }
    1636             :             }
    1637           0 :             break;
    1638           0 :         case PHOTOMETRIC_LOGL:
    1639           0 :             if (!LogL16InitState(tif))
    1640           0 :                 return (0);
    1641           0 :             tif->tif_encoderow = LogL16Encode;
    1642           0 :             switch (sp->user_datafmt)
    1643             :             {
    1644           0 :                 case SGILOGDATAFMT_FLOAT:
    1645           0 :                     sp->tfunc = L16fromY;
    1646           0 :                     break;
    1647           0 :                 case SGILOGDATAFMT_16BIT:
    1648           0 :                     break;
    1649           0 :                 default:
    1650           0 :                     goto notsupported;
    1651             :             }
    1652           0 :             break;
    1653           0 :         default:
    1654           0 :             TIFFErrorExtR(tif, module,
    1655             :                           "Inappropriate photometric interpretation %" PRIu16
    1656             :                           " for SGILog compression; %s",
    1657           0 :                           td->td_photometric, "must be either LogLUV or LogL");
    1658           0 :             return (0);
    1659             :     }
    1660           0 :     sp->encoder_state = 1;
    1661           0 :     return (1);
    1662           0 : notsupported:
    1663           0 :     TIFFErrorExtR(tif, module,
    1664             :                   "SGILog compression supported only for %s, or raw data",
    1665           0 :                   td->td_photometric == PHOTOMETRIC_LOGL ? "Y, L" : "XYZ, Luv");
    1666           0 :     return (0);
    1667             : }
    1668             : 
    1669           0 : static void LogLuvClose(TIFF *tif)
    1670             : {
    1671           0 :     LogLuvState *sp = (LogLuvState *)tif->tif_data;
    1672           0 :     TIFFDirectory *td = &tif->tif_dir;
    1673             : 
    1674           0 :     assert(sp != 0);
    1675             :     /*
    1676             :      * For consistency, we always want to write out the same
    1677             :      * bitspersample and sampleformat for our TIFF file,
    1678             :      * regardless of the data format being used by the application.
    1679             :      * Since this routine is called after tags have been set but
    1680             :      * before they have been recorded in the file, we reset them here.
    1681             :      * Note: this is really a nasty approach. See PixarLogClose
    1682             :      */
    1683           0 :     if (sp->encoder_state)
    1684             :     {
    1685             :         /* See PixarLogClose. Might avoid issues with tags whose size depends
    1686             :          * on those below, but not completely sure this is enough. */
    1687           0 :         td->td_samplesperpixel =
    1688           0 :             (td->td_photometric == PHOTOMETRIC_LOGL) ? 1 : 3;
    1689           0 :         td->td_bitspersample = 16;
    1690           0 :         td->td_sampleformat = SAMPLEFORMAT_INT;
    1691             :     }
    1692           0 : }
    1693             : 
    1694           3 : static void LogLuvCleanup(TIFF *tif)
    1695             : {
    1696           3 :     LogLuvState *sp = (LogLuvState *)tif->tif_data;
    1697             : 
    1698           3 :     assert(sp != 0);
    1699             : 
    1700           3 :     tif->tif_tagmethods.vgetfield = sp->vgetparent;
    1701           3 :     tif->tif_tagmethods.vsetfield = sp->vsetparent;
    1702             : 
    1703           3 :     if (sp->tbuf)
    1704           2 :         _TIFFfreeExt(tif, sp->tbuf);
    1705           3 :     _TIFFfreeExt(tif, sp);
    1706           3 :     tif->tif_data = NULL;
    1707             : 
    1708           3 :     _TIFFSetDefaultCompressionState(tif);
    1709           3 : }
    1710             : 
    1711          27 : static int LogLuvVSetField(TIFF *tif, uint32_t tag, va_list ap)
    1712             : {
    1713             :     static const char module[] = "LogLuvVSetField";
    1714          27 :     LogLuvState *sp = DecoderState(tif);
    1715             :     int bps, fmt;
    1716             : 
    1717          27 :     switch (tag)
    1718             :     {
    1719           1 :         case TIFFTAG_SGILOGDATAFMT:
    1720           1 :             sp->user_datafmt = (int)va_arg(ap, int);
    1721             :             /*
    1722             :              * Tweak the TIFF header so that the rest of libtiff knows what
    1723             :              * size of data will be passed between app and library, and
    1724             :              * assume that the app knows what it is doing and is not
    1725             :              * confused by these header manipulations...
    1726             :              */
    1727           1 :             switch (sp->user_datafmt)
    1728             :             {
    1729           0 :                 case SGILOGDATAFMT_FLOAT:
    1730           0 :                     bps = 32;
    1731           0 :                     fmt = SAMPLEFORMAT_IEEEFP;
    1732           0 :                     break;
    1733           0 :                 case SGILOGDATAFMT_16BIT:
    1734           0 :                     bps = 16;
    1735           0 :                     fmt = SAMPLEFORMAT_INT;
    1736           0 :                     break;
    1737           0 :                 case SGILOGDATAFMT_RAW:
    1738           0 :                     bps = 32;
    1739           0 :                     fmt = SAMPLEFORMAT_UINT;
    1740           0 :                     TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
    1741           0 :                     break;
    1742           1 :                 case SGILOGDATAFMT_8BIT:
    1743           1 :                     bps = 8;
    1744           1 :                     fmt = SAMPLEFORMAT_UINT;
    1745           1 :                     break;
    1746           0 :                 default:
    1747           0 :                     TIFFErrorExtR(
    1748           0 :                         tif, tif->tif_name,
    1749             :                         "Unknown data format %d for LogLuv compression",
    1750             :                         sp->user_datafmt);
    1751           0 :                     return (0);
    1752             :             }
    1753           1 :             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
    1754           1 :             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, fmt);
    1755             :             /*
    1756             :              * Must recalculate sizes should bits/sample change.
    1757             :              */
    1758           1 :             tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)-1;
    1759           1 :             tif->tif_scanlinesize = TIFFScanlineSize(tif);
    1760           1 :             return (1);
    1761           0 :         case TIFFTAG_SGILOGENCODE:
    1762           0 :             sp->encode_meth = (int)va_arg(ap, int);
    1763           0 :             if (sp->encode_meth != SGILOGENCODE_NODITHER &&
    1764           0 :                 sp->encode_meth != SGILOGENCODE_RANDITHER)
    1765             :             {
    1766           0 :                 TIFFErrorExtR(tif, module,
    1767             :                               "Unknown encoding %d for LogLuv compression",
    1768             :                               sp->encode_meth);
    1769           0 :                 return (0);
    1770             :             }
    1771           0 :             return (1);
    1772          26 :         default:
    1773          26 :             return (*sp->vsetparent)(tif, tag, ap);
    1774             :     }
    1775             : }
    1776             : 
    1777          49 : static int LogLuvVGetField(TIFF *tif, uint32_t tag, va_list ap)
    1778             : {
    1779          49 :     LogLuvState *sp = (LogLuvState *)tif->tif_data;
    1780             : 
    1781          49 :     switch (tag)
    1782             :     {
    1783           0 :         case TIFFTAG_SGILOGDATAFMT:
    1784           0 :             *va_arg(ap, int *) = sp->user_datafmt;
    1785           0 :             return (1);
    1786          49 :         default:
    1787          49 :             return (*sp->vgetparent)(tif, tag, ap);
    1788             :     }
    1789             : }
    1790             : 
    1791             : static const TIFFField LogLuvFields[] = {
    1792             :     {TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, FIELD_PSEUDO,
    1793             :      TRUE, FALSE, "SGILogDataFmt", NULL},
    1794             :     {TIFFTAG_SGILOGENCODE, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, FIELD_PSEUDO,
    1795             :      TRUE, FALSE, "SGILogEncode", NULL}};
    1796             : 
    1797           3 : int TIFFInitSGILog(TIFF *tif, int scheme)
    1798             : {
    1799             :     static const char module[] = "TIFFInitSGILog";
    1800             :     LogLuvState *sp;
    1801             : 
    1802           3 :     assert(scheme == COMPRESSION_SGILOG24 || scheme == COMPRESSION_SGILOG);
    1803             : 
    1804             :     /*
    1805             :      * Merge codec-specific tag information.
    1806             :      */
    1807           3 :     if (!_TIFFMergeFields(tif, LogLuvFields, TIFFArrayCount(LogLuvFields)))
    1808             :     {
    1809           0 :         TIFFErrorExtR(tif, module, "Merging SGILog codec-specific tags failed");
    1810           0 :         return 0;
    1811             :     }
    1812             : 
    1813             :     /*
    1814             :      * Allocate state block so tag methods have storage to record values.
    1815             :      */
    1816           3 :     tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(LogLuvState));
    1817           3 :     if (tif->tif_data == NULL)
    1818           0 :         goto bad;
    1819           3 :     sp = (LogLuvState *)tif->tif_data;
    1820           3 :     _TIFFmemset((void *)sp, 0, sizeof(*sp));
    1821           3 :     sp->user_datafmt = SGILOGDATAFMT_UNKNOWN;
    1822           3 :     sp->encode_meth = (scheme == COMPRESSION_SGILOG24) ? SGILOGENCODE_RANDITHER
    1823           3 :                                                        : SGILOGENCODE_NODITHER;
    1824           3 :     sp->tfunc = _logLuvNop;
    1825             : 
    1826             :     /*
    1827             :      * Install codec methods.
    1828             :      * NB: tif_decoderow & tif_encoderow are filled
    1829             :      *     in at setup time.
    1830             :      */
    1831           3 :     tif->tif_fixuptags = LogLuvFixupTags;
    1832           3 :     tif->tif_setupdecode = LogLuvSetupDecode;
    1833           3 :     tif->tif_decodestrip = LogLuvDecodeStrip;
    1834           3 :     tif->tif_decodetile = LogLuvDecodeTile;
    1835           3 :     tif->tif_setupencode = LogLuvSetupEncode;
    1836           3 :     tif->tif_encodestrip = LogLuvEncodeStrip;
    1837           3 :     tif->tif_encodetile = LogLuvEncodeTile;
    1838           3 :     tif->tif_close = LogLuvClose;
    1839           3 :     tif->tif_cleanup = LogLuvCleanup;
    1840             : 
    1841             :     /*
    1842             :      * Override parent get/set field methods.
    1843             :      */
    1844           3 :     sp->vgetparent = tif->tif_tagmethods.vgetfield;
    1845           3 :     tif->tif_tagmethods.vgetfield = LogLuvVGetField; /* hook for codec tags */
    1846           3 :     sp->vsetparent = tif->tif_tagmethods.vsetfield;
    1847           3 :     tif->tif_tagmethods.vsetfield = LogLuvVSetField; /* hook for codec tags */
    1848             : 
    1849           3 :     return (1);
    1850           0 : bad:
    1851           0 :     TIFFErrorExtR(tif, module, "%s: No space for LogLuv state block",
    1852             :                   tif->tif_name);
    1853           0 :     return (0);
    1854             : }
    1855             : #endif /* LOGLUV_SUPPORT */

Generated by: LCOV version 1.14