platform-abstractions/tizen/image-loaders/loader-jpeg-turbo.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // INTERNAL HEADERS
  19 #include "loader-jpeg.h"
  20 #include "resource-loading-client.h"
  21 #include <dali/integration-api/bitmap.h>
  22 #include <resource-loader/debug/resource-loader-debug.h>
  23 #include "platform-capabilities.h"
  24 #include "image-operations.h"
  25
  26 // EXTERNAL HEADERS
  27 #include <libexif/exif-data.h>
  28 #include <libexif/exif-loader.h>
  29 #include <libexif/exif-tag.h>
  30 #include <turbojpeg.h>
  31 #include <jpeglib.h>
  32 #include <cstring>
  33 #include <setjmp.h>
  34
  35 namespace Dali
  36 {
  37 using Integration::Bitmap;
  38
  39 namespace TizenPlatform
  40 {
  41
  42 namespace
  43 {
  44   const unsigned DECODED_PIXEL_SIZE = 3;
  45   const TJPF DECODED_PIXEL_LIBJPEG_TYPE = TJPF_RGB;
  46
  47   /** Transformations that can be applied to decoded pixels to respect exif orientation
  48    *  codes in image headers */
  49   enum JPGFORM_CODE
  50   {
  51     JPGFORM_NONE = 1, /* no transformation 0th-Row = top & 0th-Column = left */
  52     JPGFORM_FLIP_H,   /* horizontal flip 0th-Row = top & 0th-Column = right */
  53     JPGFORM_FLIP_V,   /* vertical flip   0th-Row = bottom & 0th-Column = right*/
  54     JPGFORM_TRANSPOSE, /* transpose across UL-to-LR axis  0th-Row = bottom & 0th-Column = left*/
  55     JPGFORM_TRANSVERSE,/* transpose across UR-to-LL axis  0th-Row = left   & 0th-Column = top*/
  56     JPGFORM_ROT_90,    /* 90-degree clockwise rotation  0th-Row = right  & 0th-Column = top*/
  57     JPGFORM_ROT_180,   /* 180-degree rotation  0th-Row = right  & 0th-Column = bottom*/
  58     JPGFORM_ROT_270    /* 270-degree clockwise (or 90 ccw) 0th-Row = left  & 0th-Column = bottom*/
  59   };
  60
  61   struct RGB888Type
  62   {
  63      char R;
  64      char G;
  65      char B;
  66   };
  67
  68   /**
  69    * @brief Error handling bookeeping for the JPEG Turbo library's
  70    * setjmp/longjmp simulated exceptions.
  71    */
  72   struct JpegErrorState {
  73     struct jpeg_error_mgr errorManager;
  74     jmp_buf jumpBuffer;
  75   };
  76
  77   /**
  78    * @brief Called by the JPEG library when it hits an error.
  79    * We jump out of the library so our loader code can return an error.
  80    */
  81   void  JpegErrorHandler ( j_common_ptr cinfo )
  82   {
  83     DALI_LOG_ERROR( "JpegErrorHandler(): libjpeg-turbo fatal error in JPEG decoding.\n" );
  84     /* cinfo->err really points to a JpegErrorState struct, so coerce pointer */
  85     JpegErrorState * myerr = reinterpret_cast<JpegErrorState *>( cinfo->err );
  86
  87     /* Return control to the setjmp point */
  88     longjmp( myerr->jumpBuffer, 1 );
  89   }
  90
  91   void JpegOutputMessageHandler( j_common_ptr cinfo )
  92   {
  93     /* Stop libjpeg from printing to stderr - Do Nothing */
  94   }
  95
  96   /**
  97    * LibJPEG Turbo tjDecompress2 API doesn't distinguish between errors that still allow
  98    * the JPEG to be displayed and fatal errors.
  99    */
 100   bool IsJpegErrorFatal( const std::string& errorMessage )
 101   {
 102     if( ( errorMessage.find("Corrupt JPEG data") != std::string::npos ) ||
 103         ( errorMessage.find("Invalid SOS parameters") != std::string::npos ) )
 104     {
 105       return false;
 106     }
 107     return true;
 108   }
 109
 110
 111   /** Simple struct to ensure xif data is deleted. */
 112   struct ExifAutoPtr
 113   {
 114     ExifAutoPtr( ExifData* data)
 115     :mData( data )
 116     {}
 117
 118     ~ExifAutoPtr()
 119     {
 120       exif_data_free( mData);
 121     }
 122     ExifData *mData;
 123   };
 124
 125   /** simple class to enforce clean-up of JPEG structures. */
 126   struct AutoJpg
 127   {
 128     AutoJpg(const tjhandle jpgHandle)
 129     : mHnd(jpgHandle)
 130     {
 131     }
 132
 133     ~AutoJpg()
 134     {
 135       // clean up JPG resources
 136       tjDestroy( mHnd );
 137     }
 138
 139     tjhandle GetHandle() const
 140     {
 141       return mHnd ;
 142     }
 143
 144   private:
 145     AutoJpg( const AutoJpg& ); //< not defined
 146     AutoJpg& operator= ( const AutoJpg& ); //< not defined
 147
 148     tjhandle mHnd;
 149   }; // struct AutoJpg;
 150
 151   /** RAII wrapper to free memory allocated by the jpeg-turbo library. */
 152   struct AutoJpgMem
 153   {
 154     AutoJpgMem(unsigned char * const tjMem)
 155     : mTjMem(tjMem)
 156     {
 157     }
 158
 159     ~AutoJpgMem()
 160     {
 161       tjFree(mTjMem);
 162     }
 163
 164     unsigned char * Get() const
 165     {
 166       return mTjMem;
 167     }
 168
 169   private:
 170     AutoJpgMem( const AutoJpgMem& ); //< not defined
 171     AutoJpgMem& operator= ( const AutoJpgMem& ); //< not defined
 172
 173     unsigned char * const mTjMem;
 174   };
 175
 176   // Workaround to avoid exceeding the maximum texture size
 177   const int MAX_TEXTURE_WIDTH  = 4096;
 178   const int MAX_TEXTURE_HEIGHT = 4096;
 179
 180 } // namespace
 181
 182 bool JpegRotate90 (unsigned char *buffer, int width, int height, int bpp);
 183 bool JpegRotate180(unsigned char *buffer, int width, int height, int bpp);
 184 bool JpegRotate270(unsigned char *buffer, int width, int height, int bpp);
 185 JPGFORM_CODE ConvertExifOrientation(ExifData* exifData);
 186 bool TransformSize( int requiredWidth, int requiredHeight,
 187                     FittingMode::Type fittingMode, SamplingMode::Type samplingMode,
 188                     JPGFORM_CODE transform,
 189                     int& preXformImageWidth, int& preXformImageHeight,
 190                     int& postXformImageWidth, int& postXformImageHeight );
 191
 192 bool LoadJpegHeader( FILE *fp, unsigned int &width, unsigned int &height )
 193 {
 194   // using libjpeg API to avoid having to read the whole file in a buffer
 195   struct jpeg_decompress_struct cinfo;
 196   struct JpegErrorState jerr;
 197   cinfo.err = jpeg_std_error( &jerr.errorManager );
 198
 199   jerr.errorManager.output_message = JpegOutputMessageHandler;
 200   jerr.errorManager.error_exit = JpegErrorHandler;
 201
 202   // On error exit from the JPEG lib, control will pass via JpegErrorHandler
 203   // into this branch body for cleanup and error return:
 204   if(setjmp(jerr.jumpBuffer))
 205   {
 206     jpeg_destroy_decompress(&cinfo);
 207     return false;
 208   }
 209
 210   jpeg_create_decompress( &cinfo );
 211
 212   jpeg_stdio_src( &cinfo, fp );
 213
 214   // Check header to see if it is  JPEG file
 215   if( jpeg_read_header( &cinfo, TRUE ) != JPEG_HEADER_OK )
 216   {
 217     width = height = 0;
 218     jpeg_destroy_decompress( &cinfo );
 219     return false;
 220   }
 221
 222   width = cinfo.image_width;
 223   height = cinfo.image_height;
 224
 225   jpeg_destroy_decompress( &cinfo );
 226   return true;
 227 }
 228
 229 bool LoadBitmapFromJpeg( const ResourceLoadingClient& client, const ImageLoader::Input& input, Integration::Bitmap& bitmap )
 230 {
 231   const int flags= 0;
 232   FILE* const fp = input.file;
 233
 234   if( fseek(fp,0,SEEK_END) )
 235   {
 236     DALI_LOG_ERROR("Error seeking to end of file\n");
 237     return false;
 238   }
 239
 240   long positionIndicator = ftell(fp);
 241   unsigned int jpegBufferSize = 0u;
 242   if( positionIndicator > -1L )
 243   {
 244     jpegBufferSize = static_cast<unsigned int>(positionIndicator);
 245   }
 246
 247   if( 0u == jpegBufferSize )
 248   {
 249     return false;
 250   }
 251
 252   if( fseek(fp, 0, SEEK_SET) )
 253   {
 254     DALI_LOG_ERROR("Error seeking to start of file\n");
 255     return false;
 256   }
 257
 258   Vector<unsigned char> jpegBuffer;
 259   try
 260   {
 261     jpegBuffer.Resize( jpegBufferSize );
 262   }
 263   catch(...)
 264   {
 265     DALI_LOG_ERROR( "Could not allocate temporary memory to hold JPEG file of size %uMB.\n", jpegBufferSize / 1048576U );
 266     return false;
 267   }
 268   unsigned char * const jpegBufferPtr = jpegBuffer.Begin();
 269
 270   // Pull the compressed JPEG image bytes out of a file and into memory:
 271   if( fread( jpegBufferPtr, 1, jpegBufferSize, fp ) != jpegBufferSize )
 272   {
 273     DALI_LOG_WARNING("Error on image file read.\n");
 274     return false;
 275   }
 276
 277   if( fseek(fp, 0, SEEK_SET) )
 278   {
 279     DALI_LOG_ERROR("Error seeking to start of file\n");
 280   }
 281
 282   // Allow early cancellation between the load and the decompress:
 283   client.InterruptionPoint();
 284
 285   AutoJpg autoJpg(tjInitDecompress());
 286
 287   if(autoJpg.GetHandle() == NULL)
 288   {
 289     DALI_LOG_ERROR("%s\n", tjGetErrorStr());
 290     return false;
 291   }
 292
 293   JPGFORM_CODE transform = JPGFORM_NONE;
 294
 295   if( input.reorientationRequested )
 296   {
 297     ExifAutoPtr exifData( exif_data_new_from_data(jpegBufferPtr, jpegBufferSize) );
 298     if( exifData.mData )
 299     {
 300       transform = ConvertExifOrientation(exifData.mData);
 301     }
 302   }
 303
 304   // Push jpeg data in memory buffer through TurboJPEG decoder to make a raw pixel array:
 305   int chrominanceSubsampling = -1;
 306   int preXformImageWidth = 0, preXformImageHeight = 0;
 307   if( tjDecompressHeader2( autoJpg.GetHandle(), jpegBufferPtr, jpegBufferSize, &preXformImageWidth, &preXformImageHeight, &chrominanceSubsampling ) == -1 )
 308   {
 309     DALI_LOG_ERROR("%s\n", tjGetErrorStr());
 310     // Do not set width and height to 0 or return early as this sometimes fails only on determining subsampling type.
 311   }
 312
 313   if(preXformImageWidth == 0 || preXformImageHeight == 0)
 314   {
 315     DALI_LOG_WARNING("Invalid Image!\n");
 316     return false;
 317   }
 318
 319   int requiredWidth  = input.scalingParameters.dimensions.GetWidth();
 320   int requiredHeight = input.scalingParameters.dimensions.GetHeight();
 321
 322   // If transform is a 90 or 270 degree rotation, the logical width and height
 323   // request from the client needs to be adjusted to account by effectively
 324   // rotating that too, and the final width and height need to be swapped:
 325   int postXformImageWidth = preXformImageWidth;
 326   int postXformImageHeight = preXformImageHeight;
 327
 328
 329   int scaledPreXformWidth   = preXformImageWidth;
 330   int scaledPreXformHeight  = preXformImageHeight;
 331   int scaledPostXformWidth  = postXformImageWidth;
 332   int scaledPostXformHeight = postXformImageHeight;
 333
 334   TransformSize( requiredWidth, requiredHeight,
 335                  input.scalingParameters.scalingMode,
 336                  input.scalingParameters.samplingMode,
 337                  transform,
 338                  scaledPreXformWidth, scaledPreXformHeight,
 339                  scaledPostXformWidth, scaledPostXformHeight );
 340
 341   // Allocate a bitmap and decompress the jpeg buffer into its pixel buffer:
 342
 343   unsigned char * const bitmapPixelBuffer =  bitmap.GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGB888, scaledPostXformWidth, scaledPostXformHeight);
 344
 345   // Allow early cancellation before decoding:
 346   client.InterruptionPoint();
 347
 348   if( tjDecompress2( autoJpg.GetHandle(), jpegBufferPtr, jpegBufferSize, bitmapPixelBuffer, scaledPreXformWidth, 0, scaledPreXformHeight, DECODED_PIXEL_LIBJPEG_TYPE, flags ) == -1 )
 349   {
 350     std::string errorString = tjGetErrorStr();
 351
 352     if( IsJpegErrorFatal( errorString ) )
 353     {
 354       DALI_LOG_ERROR("%s\n", errorString.c_str());
 355       return false;
 356     }
 357     else
 358     {
 359       DALI_LOG_WARNING("%s\n", errorString.c_str());
 360     }
 361   }
 362
 363   const unsigned int  bufferWidth  = GetTextureDimension( scaledPreXformWidth );
 364   const unsigned int  bufferHeight = GetTextureDimension( scaledPreXformHeight );
 365
 366   if( transform != JPGFORM_NONE )
 367   {
 368     // Allow early cancellation before shuffling pixels around on the CPU:
 369     client.InterruptionPoint();
 370   }
 371
 372   bool result = false;
 373   switch(transform)
 374   {
 375     case JPGFORM_NONE:
 376     {
 377       result = true;
 378       break;
 379     }
 380     // 3 orientation changes for a camera held perpendicular to the ground or upside-down:
 381     case JPGFORM_ROT_180:
 382     {
 383       result = JpegRotate180(bitmapPixelBuffer, bufferWidth, bufferHeight, DECODED_PIXEL_SIZE);
 384       break;
 385     }
 386     case JPGFORM_ROT_270:
 387     {
 388       result = JpegRotate270(bitmapPixelBuffer, bufferWidth, bufferHeight, DECODED_PIXEL_SIZE);
 389       break;
 390     }
 391     case JPGFORM_ROT_90:
 392     {
 393       result = JpegRotate90(bitmapPixelBuffer, bufferWidth, bufferHeight, DECODED_PIXEL_SIZE);
 394       break;
 395     }
 396     /// Less-common orientation changes, since they don't correspond to a camera's
 397     // physical orientation:
 398     case JPGFORM_FLIP_H:
 399     case JPGFORM_FLIP_V:
 400     case JPGFORM_TRANSPOSE:
 401     case JPGFORM_TRANSVERSE:
 402     {
 403       DALI_LOG_WARNING( "Unsupported JPEG Orientation transformation: %x.\n", transform );
 404       break;
 405     }
 406   }
 407   return result;
 408 }
 409
 410 ///@Todo: Move all these rotation functions to portable/image-operations and take "Jpeg" out of their names.
 411 bool JpegRotate90(unsigned char *buffer, int width, int height, int bpp)
 412 {
 413   int  w, iw, ih, hw = 0;
 414   int ix, iy = 0;
 415   iw = width;
 416   ih = height;
 417   Vector<unsigned char> data;
 418   data.Resize(width * height * bpp);
 419   unsigned char *dataPtr = data.Begin();
 420   memcpy(dataPtr, buffer, width * height * bpp);
 421   w = ih;
 422   ih = iw;
 423   iw = w;
 424   hw = iw * ih;
 425   hw = - hw - 1;
 426   switch(bpp)
 427   {
 428     case 3:
 429     {
 430       RGB888Type* to = reinterpret_cast<RGB888Type*>(buffer) + iw - 1;
 431       RGB888Type* from = reinterpret_cast<RGB888Type*>( dataPtr );
 432
 433       for(ix = iw; -- ix >= 0;)
 434       {
 435         for(iy = ih; -- iy >= 0; ++from )
 436         {
 437           *to = *from;
 438           to += iw;
 439         }
 440         to += hw;
 441       }
 442       break;
 443     }
 444
 445     default:
 446     {
 447       return false;
 448     }
 449   }
 450
 451   return true;
 452 }
 453
 454 bool JpegRotate180(unsigned char *buffer, int width, int height, int bpp)
 455 {
 456   int  ix, iw, ih, hw = 0;
 457   iw = width;
 458   ih = height;
 459   hw = iw * ih;
 460   ix = hw;
 461
 462   switch(bpp)
 463   {
 464     case 3:
 465     {
 466       RGB888Type tmp;
 467       RGB888Type* to = reinterpret_cast<RGB888Type*>(buffer) ;
 468       RGB888Type* from = reinterpret_cast<RGB888Type*>( buffer ) + hw - 1;
 469       for(; --ix >= (hw / 2); ++to, --from)
 470       {
 471         tmp = *to;
 472         *to = *from;
 473         *from = tmp;
 474       }
 475       break;
 476     }
 477
 478     default:
 479     {
 480       return false;
 481     }
 482   }
 483
 484   return true;
 485 }
 486
 487 bool JpegRotate270(unsigned char *buffer, int width, int height, int bpp)
 488 {
 489   int  w, iw, ih, hw = 0;
 490   int ix, iy = 0;
 491
 492   iw = width;
 493   ih = height;
 494   Vector<unsigned char> data;
 495   data.Resize(width * height * bpp);
 496   unsigned char *dataPtr = data.Begin();
 497   memcpy(dataPtr, buffer, width * height * bpp);
 498   w = ih;
 499   ih = iw;
 500   iw = w;
 501   hw = iw * ih;
 502
 503   switch(bpp)
 504   {
 505     case 3:
 506     {
 507       RGB888Type* to = reinterpret_cast<RGB888Type*>(buffer) + hw  - iw;
 508       RGB888Type* from = reinterpret_cast<RGB888Type*>( dataPtr );
 509
 510       w = -w;
 511       hw =  hw + 1;
 512       for(ix = iw; -- ix >= 0;)
 513       {
 514         for(iy = ih; -- iy >= 0;)
 515         {
 516           *to = *from;
 517           from += 1;
 518           to += w;
 519         }
 520         to += hw;
 521       }
 522       break;
 523     }
 524     default:
 525     {
 526       return false;
 527     }
 528   }
 529
 530   return true;
 531 }
 532
 533 bool EncodeToJpeg( const unsigned char* const pixelBuffer, Vector< unsigned char >& encodedPixels,
 534                    const std::size_t width, const std::size_t height, const Pixel::Format pixelFormat, unsigned quality )
 535 {
 536
 537   if( !pixelBuffer )
 538   {
 539     DALI_LOG_ERROR("Null input buffer\n");
 540     return false;
 541   }
 542
 543   // Translate pixel format enum:
 544   int jpegPixelFormat = -1;
 545
 546   switch( pixelFormat )
 547   {
 548     case Pixel::RGB888:
 549     {
 550       jpegPixelFormat = TJPF_RGB;
 551       break;
 552     }
 553     case Pixel::RGBA8888:
 554     {
 555       // Ignore the alpha:
 556       jpegPixelFormat = TJPF_RGBX;
 557       break;
 558     }
 559     case Pixel::BGRA8888:
 560     {
 561       // Ignore the alpha:
 562       jpegPixelFormat = TJPF_BGRX;
 563       break;
 564     }
 565     default:
 566     {
 567       DALI_LOG_ERROR( "Unsupported pixel format for encoding to JPEG.\n" );
 568       return false;
 569     }
 570   }
 571
 572   // Assert quality is in the documented allowable range of the jpeg-turbo lib:
 573   DALI_ASSERT_DEBUG( quality >= 1 );
 574   DALI_ASSERT_DEBUG( quality <= 100 );
 575   if( quality < 1 )
 576   {
 577     quality = 1;
 578   }
 579   if( quality > 100 )
 580   {
 581     quality = 100;
 582   }
 583
 584   // Initialise a JPEG codec:
 585   AutoJpg autoJpg( tjInitCompress() );
 586   {
 587     if( autoJpg.GetHandle() == NULL )
 588     {
 589       DALI_LOG_ERROR( "JPEG Compressor init failed: %s\n", tjGetErrorStr() );
 590       return false;
 591     }
 592
 593     // Run the compressor:
 594     unsigned char* dstBuffer = NULL;
 595     unsigned long dstBufferSize = 0;
 596     const int flags = 0;
 597
 598     if( tjCompress2( autoJpg.GetHandle(), const_cast<unsigned char*>(pixelBuffer), width, 0, height, jpegPixelFormat, &dstBuffer, &dstBufferSize, TJSAMP_444, quality, flags ) )
 599     {
 600       DALI_LOG_ERROR("JPEG Compression failed: %s\n", tjGetErrorStr());
 601       return false;
 602     }
 603
 604     // Safely wrap the jpeg codec's buffer in case we are about to throw, then
 605     // save the pixels to a persistent buffer that we own and let our cleaner
 606     // class clean up the buffer as it goes out of scope:
 607     AutoJpgMem cleaner( dstBuffer );
 608     encodedPixels.Resize( dstBufferSize );
 609     memcpy( encodedPixels.Begin(), dstBuffer, dstBufferSize );
 610   }
 611   return true;
 612 }
 613
 614
 615 JPGFORM_CODE ConvertExifOrientation(ExifData* exifData)
 616 {
 617   JPGFORM_CODE transform = JPGFORM_NONE;
 618   ExifEntry * const entry = exif_data_get_entry(exifData, EXIF_TAG_ORIENTATION);
 619   int orientation = 0;
 620   if( entry )
 621   {
 622     orientation = exif_get_short(entry->data, exif_data_get_byte_order(entry->parent->parent));
 623     switch( orientation )
 624     {
 625       case 1:
 626       {
 627         transform = JPGFORM_NONE;
 628         break;
 629       }
 630       case 2:
 631       {
 632         transform = JPGFORM_FLIP_H;
 633         break;
 634       }
 635       case 3:
 636       {
 637         transform = JPGFORM_FLIP_V;
 638         break;
 639       }
 640       case 4:
 641       {
 642         transform = JPGFORM_TRANSPOSE;
 643         break;
 644       }
 645       case 5:
 646       {
 647         transform = JPGFORM_TRANSVERSE;
 648         break;
 649       }
 650       case 6:
 651       {
 652         transform = JPGFORM_ROT_90;
 653         break;
 654       }
 655       case 7:
 656       {
 657         transform = JPGFORM_ROT_180;
 658         break;
 659       }
 660       case 8:
 661       {
 662         transform = JPGFORM_ROT_270;
 663         break;
 664       }
 665       default:
 666       {
 667         // Try to keep loading the file, but let app developer know there was something fishy:
 668         DALI_LOG_WARNING( "Incorrect/Unknown Orientation setting found in EXIF header of JPEG image (%x). Orientation setting will be ignored.\n", entry );
 669         break;
 670       }
 671     }
 672   }
 673   return transform;
 674 }
 675
 676 bool TransformSize( int requiredWidth, int requiredHeight,
 677                     FittingMode::Type fittingMode, SamplingMode::Type samplingMode,
 678                     JPGFORM_CODE transform,
 679                     int& preXformImageWidth, int& preXformImageHeight,
 680                     int& postXformImageWidth, int& postXformImageHeight )
 681 {
 682   bool success = true;
 683
 684   if( transform == JPGFORM_ROT_90 || transform == JPGFORM_ROT_270 )
 685   {
 686     std::swap( requiredWidth, requiredHeight );
 687     std::swap( postXformImageWidth, postXformImageHeight );
 688   }
 689
 690   // Apply the special rules for when there are one or two zeros in requested dimensions:
 691   const ImageDimensions correctedDesired = Internal::Platform::CalculateDesiredDimensions( ImageDimensions( postXformImageWidth, postXformImageHeight), ImageDimensions( requiredWidth, requiredHeight ) );
 692   requiredWidth = correctedDesired.GetWidth();
 693   requiredHeight = correctedDesired.GetHeight();
 694
 695   // Rescale image during decode using one of the decoder's built-in rescaling
 696   // ratios (expected to be powers of 2), keeping the final image at least as
 697   // wide and high as was requested:
 698
 699   int numFactors = 0;
 700   tjscalingfactor* factors = tjGetScalingFactors( &numFactors );
 701   if( factors == NULL )
 702   {
 703     DALI_LOG_WARNING("TurboJpeg tjGetScalingFactors error!\n");
 704     success = false;
 705   }
 706   else
 707   {
 708     // Internal jpeg downscaling is the same as our BOX_X sampling modes so only
 709     // apply it if the application requested one of those:
 710     // (use a switch case here so this code will fail to compile if other modes are added)
 711     bool downscale = true;
 712     switch( samplingMode )
 713     {
 714       case SamplingMode::BOX:
 715       case SamplingMode::BOX_THEN_NEAREST:
 716       case SamplingMode::BOX_THEN_LINEAR:
 717       case SamplingMode::DONT_CARE:
 718       {
 719         downscale = true;
 720         break;
 721       }
 722       case SamplingMode::NO_FILTER:
 723       case SamplingMode::NEAREST:
 724       case SamplingMode::LINEAR:
 725       {
 726         downscale = false;
 727         break;
 728       }
 729     }
 730
 731     int scaleFactorIndex( 0 );
 732     if( downscale )
 733     {
 734       // Find nearest supported scaling factor (factors are in sequential order, getting smaller)
 735       for( int i = 1; i < numFactors; ++i )
 736       {
 737         bool widthLessRequired  = TJSCALED( postXformImageWidth,  factors[i]) < requiredWidth;
 738         bool heightLessRequired = TJSCALED( postXformImageHeight, factors[i]) < requiredHeight;
 739         // If either scaled dimension is smaller than the desired one, we were done at the last iteration
 740         if ( (fittingMode == FittingMode::SCALE_TO_FILL) && (widthLessRequired || heightLessRequired) )
 741         {
 742           break;
 743         }
 744         // If both dimensions are smaller than the desired one, we were done at the last iteration:
 745         if ( (fittingMode == FittingMode::SHRINK_TO_FIT) && ( widthLessRequired && heightLessRequired ) )
 746         {
 747           break;
 748         }
 749         // If the width is smaller than the desired one, we were done at the last iteration:
 750         if ( fittingMode == FittingMode::FIT_WIDTH && widthLessRequired )
 751         {
 752           break;
 753         }
 754         // If the width is smaller than the desired one, we were done at the last iteration:
 755         if ( fittingMode == FittingMode::FIT_HEIGHT && heightLessRequired )
 756         {
 757           break;
 758         }
 759         // This factor stays is within our fitting mode constraint so remember it:
 760         scaleFactorIndex = i;
 761       }
 762     }
 763
 764     // Regardless of requested size, downscale to avoid exceeding the maximum texture size:
 765     for( int i = scaleFactorIndex; i < numFactors; ++i )
 766     {
 767       // Continue downscaling to below maximum texture size (if possible)
 768       scaleFactorIndex = i;
 769
 770       if( TJSCALED(postXformImageWidth,  (factors[i])) < MAX_TEXTURE_WIDTH &&
 771           TJSCALED(postXformImageHeight, (factors[i])) < MAX_TEXTURE_HEIGHT )
 772       {
 773         // Current scale-factor downscales to below maximum texture size
 774         break;
 775       }
 776     }
 777
 778     // We have finally chosen the scale-factor, return width/height values
 779     if( scaleFactorIndex > 0 )
 780     {
 781       preXformImageWidth   = TJSCALED(preXformImageWidth,   (factors[scaleFactorIndex]));
 782       preXformImageHeight  = TJSCALED(preXformImageHeight,  (factors[scaleFactorIndex]));
 783       postXformImageWidth  = TJSCALED(postXformImageWidth,  (factors[scaleFactorIndex]));
 784       postXformImageHeight = TJSCALED(postXformImageHeight, (factors[scaleFactorIndex]));
 785     }
 786   }
 787
 788   return success;
 789 }
 790
 791 ExifData* LoadExifData( FILE* fp )
 792 {
 793   ExifData*     exifData=NULL;
 794   ExifLoader*   exifLoader;
 795   unsigned char dataBuffer[1024];
 796
 797   if( fseek( fp, 0, SEEK_SET ) )
 798   {
 799     DALI_LOG_ERROR("Error seeking to start of file\n");
 800   }
 801   else
 802   {
 803     exifLoader = exif_loader_new ();
 804
 805     while( !feof(fp) )
 806     {
 807       int size = fread( dataBuffer, 1, sizeof( dataBuffer ), fp );
 808       if( size <= 0 )
 809       {
 810         break;
 811       }
 812       if( ! exif_loader_write( exifLoader, dataBuffer, size ) )
 813       {
 814         break;
 815       }
 816     }
 817
 818     exifData = exif_loader_get_data( exifLoader );
 819     exif_loader_unref( exifLoader );
 820   }
 821
 822   return exifData;
 823 }
 824
 825 bool LoadJpegHeader( const ImageLoader::Input& input, unsigned int& width, unsigned int& height )
 826 {
 827   unsigned int requiredWidth  = input.scalingParameters.dimensions.GetWidth();
 828   unsigned int requiredHeight = input.scalingParameters.dimensions.GetHeight();
 829   FILE* const fp = input.file;
 830
 831   bool success = false;
 832   if( requiredWidth == 0 && requiredHeight == 0 )
 833   {
 834     success = LoadJpegHeader( fp, width, height );
 835   }
 836   else
 837   {
 838     // Double check we get the same width/height from the header
 839     unsigned int headerWidth;
 840     unsigned int headerHeight;
 841     if( LoadJpegHeader( fp, headerWidth, headerHeight ) )
 842     {
 843       JPGFORM_CODE transform = JPGFORM_NONE;
 844
 845       if( input.reorientationRequested )
 846       {
 847         ExifAutoPtr exifData( LoadExifData( fp ) );
 848         if( exifData.mData )
 849         {
 850           transform = ConvertExifOrientation(exifData.mData);
 851         }
 852
 853         int preXformImageWidth = headerWidth;
 854         int preXformImageHeight = headerHeight;
 855         int postXformImageWidth = headerWidth;
 856         int postXformImageHeight = headerHeight;
 857
 858         success = TransformSize( requiredWidth, requiredHeight, input.scalingParameters.scalingMode, input.scalingParameters.samplingMode, transform, preXformImageWidth, preXformImageHeight, postXformImageWidth, postXformImageHeight );
 859         if(success)
 860         {
 861           width = postXformImageWidth;
 862           height = postXformImageHeight;
 863         }
 864       }
 865       else
 866       {
 867         success = true;
 868         width = headerWidth;
 869         height = headerHeight;
 870       }
 871     }
 872   }
 873   return success;
 874 }
 875
 876
 877 } // namespace TizenPlatform
 878
 879 } // namespace Dali