File indexing completed on 2025-01-05 03:57:08

 /* -*- C++ -*-
  * Copyright 2019-2021 LibRaw LLC (info@libraw.org)
  *
 
  LibRaw is free software; you can redistribute it and/or modify
  it under the terms of the one of two licenses as you choose:
 
 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
    (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
 
 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
    (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
 
  */
 
 #include "../../internal/libraw_cxx_defs.h"
 
 void LibRaw::kodak_thumb_loader()
 {
   INT64 est_datasize =
       T.theight * T.twidth / 3; // is 0.3 bytes per pixel good estimate?
   if (ID.toffset < 0)
     throw LIBRAW_EXCEPTION_IO_CORRUPT;
 
   if (ID.toffset + est_datasize > ID.input->size() + THUMB_READ_BEYOND)
     throw LIBRAW_EXCEPTION_IO_EOF;
 
   if(INT64(T.theight) * INT64(T.twidth) > 1024ULL * 1024ULL * LIBRAW_MAX_THUMBNAIL_MB)
       throw LIBRAW_EXCEPTION_IO_CORRUPT;
 
   if (INT64(T.theight) * INT64(T.twidth) < 64ULL)
       throw LIBRAW_EXCEPTION_IO_CORRUPT;
 
   if(T.twidth < 16 || T.twidth > 8192 || T.theight < 16 || T.theight > 8192)
     throw LIBRAW_EXCEPTION_IO_CORRUPT;
 
   // some kodak cameras
   ushort s_height = S.height, s_width = S.width, s_iwidth = S.iwidth,
          s_iheight = S.iheight;
   ushort s_flags = libraw_internal_data.unpacker_data.load_flags;
   libraw_internal_data.unpacker_data.load_flags = 12;
   int s_colors = P1.colors;
   unsigned s_filters = P1.filters;
   ushort(*s_image)[4] = imgdata.image;
 
   S.height = T.theight;
   S.width = T.twidth;
   P1.filters = 0;
 
 #define Tformat libraw_internal_data.unpacker_data.thumb_format
 
 
   if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_YCBCR)
   {
     S.height += S.height & 1;
     S.width += S.width & 1;
   }
 
   S.iheight = S.height;
   S.iwidth = S.width;
 
   imgdata.image =
       (ushort(*)[4])calloc(S.iheight * S.iwidth, sizeof(*imgdata.image));
 
   ID.input->seek(ID.toffset, SEEK_SET);
   // read kodak thumbnail into T.image[]
   try
   {
       if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_YCBCR)
           kodak_ycbcr_load_raw();
       else if(Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_RGB)
         kodak_rgb_load_raw();
       else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_KODAK_THUMB)
         kodak_thumb_load_raw();
   }
   catch (...)
   {
     free(imgdata.image);
     imgdata.image = s_image;
 
     T.twidth = 0;
     S.width = s_width;
 
     S.iwidth = s_iwidth;
     S.iheight = s_iheight;
 
     T.theight = 0;
     S.height = s_height;
 
     T.tcolors = 0;
     P1.colors = s_colors;
 
     P1.filters = s_filters;
     T.tlength = 0;
     libraw_internal_data.unpacker_data.load_flags = s_flags;
     return;
   }
 
   // from scale_colors
   {
     double dmax;
     float scale_mul[4];
     int c, val;
     for (dmax = DBL_MAX, c = 0; c < 3; c++)
       if (dmax > C.pre_mul[c])
         dmax = C.pre_mul[c];
 
     for (c = 0; c < 3; c++)
       scale_mul[c] = (C.pre_mul[c] / dmax) * 65535.0 / C.maximum;
     scale_mul[3] = scale_mul[1];
 
     size_t size = S.height * S.width;
     for (unsigned i = 0; i < size * 4; i++)
     {
       val = imgdata.image[0][i];
       if (!val)
         continue;
       val *= scale_mul[i & 3];
       imgdata.image[0][i] = CLIP(val);
     }
   }
 
   // from convert_to_rgb
   ushort *img;
   int row, col;
 
   int(*t_hist)[LIBRAW_HISTOGRAM_SIZE] =
       (int(*)[LIBRAW_HISTOGRAM_SIZE])calloc(sizeof(*t_hist), 4);
 
   if (imgdata.idata.maker_index == LIBRAW_CAMERAMAKER_Canon) // Skip color conversion for canon PPM tiffs
   {
     for (img = imgdata.image[0], row = 0; row < S.height; row++)
       for (col = 0; col < S.width; col++, img += 4)
         for (int c = 0; c < P1.colors; c++)
           t_hist[c][img[c] >> 3]++;
   }
   else
   {
     float out[3], out_cam[3][4] = {{2.81761312f, -1.98369181f, 0.166078627f, 0},
                                    {-0.111855984f, 1.73688626f, -0.625030339f, 0},
                                    {-0.0379119813f, -0.891268849f, 1.92918086f, 0}};
     
     for (img = imgdata.image[0], row = 0; row < S.height; row++)
       for (col = 0; col < S.width; col++, img += 4)
       {
         out[0] = out[1] = out[2] = 0;
         int c;
         for (c = 0; c < 3; c++)
         {
           out[0] += out_cam[0][c] * img[c];
           out[1] += out_cam[1][c] * img[c];
           out[2] += out_cam[2][c] * img[c];
         }
         for (c = 0; c < 3; c++)
           img[c] = CLIP((int)out[c]);
         for (c = 0; c < P1.colors; c++)
           t_hist[c][img[c] >> 3]++;
       }
   }
 
   // from gamma_lut
   int(*save_hist)[LIBRAW_HISTOGRAM_SIZE] =
       libraw_internal_data.output_data.histogram;
   libraw_internal_data.output_data.histogram = t_hist;
 
   // make curve output curve!
   ushort *t_curve = (ushort *)calloc(sizeof(C.curve), 1);
   memmove(t_curve, C.curve, sizeof(C.curve));
   memset(C.curve, 0, sizeof(C.curve));
   {
     int perc, val, total, t_white = 0x2000, c;
 
     perc = S.width * S.height * 0.01; /* 99th percentile white level */
     if (IO.fuji_width)
       perc /= 2;
     if (!((O.highlight & ~2) || O.no_auto_bright))
       for (t_white = c = 0; c < P1.colors; c++)
       {
         for (val = 0x2000, total = 0; --val > 32;)
           if ((total += libraw_internal_data.output_data.histogram[c][val]) >
               perc)
             break;
         if (t_white < val)
           t_white = val;
       }
     gamma_curve(O.gamm[0], O.gamm[1], 2, (t_white << 3) / O.bright);
   }
 
   libraw_internal_data.output_data.histogram = save_hist;
   free(t_hist);
 
   // from write_ppm_tiff - copy pixels into bitmap
 
   int s_flip = imgdata.sizes.flip;
   if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_NO_ROTATE_FOR_KODAK_THUMBNAILS)
     imgdata.sizes.flip = 0;
 
   S.iheight = S.height;
   S.iwidth = S.width;
   if (S.flip & 4)
     SWAP(S.height, S.width);
 
   if (T.thumb)
     free(T.thumb);
   T.thumb = (char *)calloc(S.width * S.height, P1.colors);
   T.tlength = S.width * S.height * P1.colors;
 
   // from write_tiff_ppm
   {
     int soff = flip_index(0, 0);
     int cstep = flip_index(0, 1) - soff;
     int rstep = flip_index(1, 0) - flip_index(0, S.width);
 
     for (int rr = 0; rr < S.height; rr++, soff += rstep)
     {
       char *ppm = T.thumb + rr * S.width * P1.colors;
       for (int cc = 0; cc < S.width; cc++, soff += cstep)
         for (int c = 0; c < P1.colors; c++)
           ppm[cc * P1.colors + c] =
               imgdata.color.curve[imgdata.image[soff][c]] >> 8;
     }
   }
 
   memmove(C.curve, t_curve, sizeof(C.curve));
   free(t_curve);
 
   // restore variables
   free(imgdata.image);
   imgdata.image = s_image;
 
   if (imgdata.rawparams.options & LIBRAW_RAWOPTIONS_NO_ROTATE_FOR_KODAK_THUMBNAILS)
     imgdata.sizes.flip = s_flip;
 
   T.twidth = S.width;
   S.width = s_width;
 
   S.iwidth = s_iwidth;
   S.iheight = s_iheight;
 
   T.theight = S.height;
   S.height = s_height;
 
   T.tcolors = P1.colors;
   P1.colors = s_colors;
 
   P1.filters = s_filters;
   libraw_internal_data.unpacker_data.load_flags = s_flags;
 }
 
 // ������� thumbnail �� �����, ������ thumb_format � ������������ � ��������
 
 int LibRaw::thumbOK(INT64 maxsz)
 {
   if (!ID.input)
     return 0;
   if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 &&
                        load_raw == &LibRaw::broadcom_load_raw) // RPi
 #ifdef USE_6BY9RPI
       && !(imgdata.thumbnail.tlength > 0 && libraw_internal_data.unpacker_data.load_flags & 0x4000 &&
            (load_raw == &LibRaw::rpi_load_raw8 || load_raw == &LibRaw::nokia_load_raw ||
             load_raw == &LibRaw::rpi_load_raw12 || load_raw == &LibRaw::rpi_load_raw14))
 #endif
   )
     return 0;
   INT64 fsize = ID.input->size();
   if (fsize > 0xffffffffU)
     return 0; // No thumb for raw > 4Gb-1
   int tsize = 0;
   int tcol = (T.tcolors > 0 && T.tcolors < 4) ? T.tcolors : 3;
   if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_JPEG)
     tsize = T.tlength;
   else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_PPM)
     tsize = tcol * T.twidth * T.theight;
   else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_PPM16)
     tsize = tcol * T.twidth * T.theight *
             ((imgdata.rawparams.options & LIBRAW_RAWOPTIONS_USE_PPM16_THUMBS) ? 2 : 1);
 #ifdef USE_X3FTOOLS
   else if (Tformat == LIBRAW_INTERNAL_THUMBNAIL_X3F)
   {
     tsize = x3f_thumb_size();
   }
 #endif
   else // Kodak => no check
     tsize = 1;
   if (tsize < 0)
     return 0;
   if (maxsz > 0 && tsize > maxsz)
     return 0;
   return (tsize + ID.toffset <= fsize) ? 1 : 0;
 }
 
 int LibRaw::dcraw_thumb_writer(const char *fname)
 {
   //    CHECK_ORDER_LOW(LIBRAW_PROGRESS_THUMB_LOAD);
 
   if (!fname)
     return ENOENT;
 
   FILE *tfp = fopen(fname, "wb");
 
   if (!tfp)
     return errno;
 
   if (!T.thumb)
   {
     fclose(tfp);
     return LIBRAW_OUT_OF_ORDER_CALL;
   }
 
   try
   {
     switch (T.tformat)
     {
     case LIBRAW_THUMBNAIL_JPEG:
       jpeg_thumb_writer(tfp, T.thumb, T.tlength);
       break;
     case LIBRAW_THUMBNAIL_BITMAP:
       fprintf(tfp, "P%d\n%d %d\n255\n", T.tcolors == 1 ? 5 : 6,  T.twidth, T.theight);
       fwrite(T.thumb, 1, T.tlength, tfp);
       break;
     default:
       fclose(tfp);
       return LIBRAW_UNSUPPORTED_THUMBNAIL;
     }
     fclose(tfp);
     return 0;
   }
   catch (const std::bad_alloc&)
   {
       fclose(tfp);
       EXCEPTION_HANDLER(LIBRAW_EXCEPTION_ALLOC);
   }
   catch (const LibRaw_exceptions& err)
   {
     fclose(tfp);
     EXCEPTION_HANDLER(err);
   }
 }