Revert "[Tizen] Add codes for Dali Windows Backend"
[platform/core/uifw/dali-adaptor.git] / dali / internal / imaging / common / image-operations.cpp
1 /*
2  * Copyright (c) 2017 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 #include <dali/internal/imaging/common/image-operations.h>
19
20 // EXTERNAL INCLUDES
21 #include <cstring>
22 #include <stddef.h>
23 #include <cmath>
24 #include <limits>
25 #include <dali/integration-api/debug.h>
26 #include <dali/public-api/common/dali-vector.h>
27 #include <dali/public-api/math/vector2.h>
28 #include <third-party/resampler/resampler.h>
29 #include <dali/devel-api/adaptor-framework/image-loading.h>
30
31 // INTERNAL INCLUDES
32
33 namespace Dali
34 {
35 namespace Internal
36 {
37 namespace Platform
38 {
39
40 namespace
41 {
42
43 // The BORDER_FILL_VALUE is a single byte value that is used for horizontal and vertical borders.
44 // A value of 0x00 gives us transparency for pixel buffers with an alpha channel, or black otherwise.
45 // We can optionally use a Vector4 color here, but at reduced fill speed.
46 const uint8_t BORDER_FILL_VALUE( 0x00 );
47 // A maximum size limit for newly created bitmaps. ( 1u << 16 ) - 1 is chosen as we are using 16bit words for dimensions.
48 const unsigned int MAXIMUM_TARGET_BITMAP_SIZE( ( 1u << 16 ) - 1 );
49
50 // Constants used by the ImageResampler.
51 const float DEFAULT_SOURCE_GAMMA = 1.75f;   ///< Default source gamma value used in the Resampler() function. Partial gamma correction looks better on mips. Set to 1.0 to disable gamma correction.
52 const float FILTER_SCALE = 1.f;             ///< Default filter scale value used in the Resampler() function. Filter scale - values < 1.0 cause aliasing, but create sharper looking mips.
53
54 using Integration::Bitmap;
55 using Integration::BitmapPtr;
56 typedef unsigned char PixelBuffer;
57
58 /**
59  * @brief 4 byte pixel structure.
60  */
61 struct Pixel4Bytes
62 {
63   uint8_t r;
64   uint8_t g;
65   uint8_t b;
66   uint8_t a;
67 } __attribute__((packed, aligned(4))); //< Tell the compiler it is okay to use a single 32 bit load.
68
69 /**
70  * @brief RGB888 pixel structure.
71  */
72 struct Pixel3Bytes
73 {
74   uint8_t r;
75   uint8_t g;
76   uint8_t b;
77 } __attribute__((packed, aligned(1)));
78
79 /**
80  * @brief RGB565 pixel typedefed from a short.
81  *
82  * Access fields by manual shifting and masking.
83  */
84 typedef uint16_t PixelRGB565;
85
86 /**
87  * @brief a Pixel composed of two independent byte components.
88  */
89 struct Pixel2Bytes
90 {
91   uint8_t l;
92   uint8_t a;
93 } __attribute__((packed, aligned(2))); //< Tell the compiler it is okay to use a single 16 bit load.
94
95
96 #if defined(DEBUG_ENABLED)
97 /**
98  * Disable logging of image operations or make it verbose from the commandline
99  * as follows (e.g., for dali demo app):
100  * <code>
101  * LOG_IMAGE_OPERATIONS=0 dali-demo #< off
102  * LOG_IMAGE_OPERATIONS=3 dali-demo #< on, verbose
103  * </code>
104  */
105 Debug::Filter* gImageOpsLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_IMAGE_OPERATIONS" );
106 #endif
107
108 /** @return The greatest even number less than or equal to the argument. */
109 inline unsigned int EvenDown( const unsigned int a )
110 {
111   const unsigned int evened = a & ~1u;
112   return evened;
113 }
114
115 /**
116  * @brief Log bad parameters.
117  */
118 void ValidateScalingParameters( const unsigned int inputWidth,
119                                 const unsigned int inputHeight,
120                                 const unsigned int desiredWidth,
121                                 const unsigned int desiredHeight )
122 {
123   if( desiredWidth > inputWidth || desiredHeight > inputHeight )
124   {
125     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Upscaling not supported (%u, %u -> %u, %u).\n", inputWidth, inputHeight, desiredWidth, desiredHeight );
126   }
127
128   if( desiredWidth == 0u || desiredHeight == 0u )
129   {
130     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Downscaling to a zero-area target is pointless.\n" );
131   }
132
133   if( inputWidth == 0u || inputHeight == 0u )
134   {
135     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Zero area images cannot be scaled\n" );
136   }
137 }
138
139 /**
140  * @brief Do debug assertions common to all scanline halving functions.
141  * @note Inline and in anon namespace so should boil away in release builds.
142  */
143 inline void DebugAssertScanlineParameters( const uint8_t * const pixels, const unsigned int width )
144 {
145   DALI_ASSERT_DEBUG( pixels && "Null pointer." );
146   DALI_ASSERT_DEBUG( width > 1u && "Can't average fewer than two pixels." );
147   DALI_ASSERT_DEBUG( width < 131072u && "Unusually wide image: are you sure you meant to pass that value in?" );
148 }
149
150 /**
151  * @brief Assertions on params to functions averaging pairs of scanlines.
152  * @note Inline as intended to boil away in release.
153  */
154 inline void DebugAssertDualScanlineParameters( const uint8_t * const scanline1,
155                                                const uint8_t * const scanline2,
156                                                uint8_t* const outputScanline,
157                                                const size_t widthInComponents )
158 {
159   DALI_ASSERT_DEBUG( scanline1 && "Null pointer." );
160   DALI_ASSERT_DEBUG( scanline2 && "Null pointer." );
161   DALI_ASSERT_DEBUG( outputScanline && "Null pointer." );
162   DALI_ASSERT_DEBUG( ((scanline1 >= scanline2 + widthInComponents) || (scanline2 >= scanline1 + widthInComponents )) && "Scanlines alias." );
163   DALI_ASSERT_DEBUG( ((outputScanline >= (scanline2 + widthInComponents)) || (scanline2 >= (scanline1 + widthInComponents))) && "Scanline 2 aliases output." );
164 }
165
166 /**
167  * @brief Converts a scaling mode to the definition of which dimensions matter when box filtering as a part of that mode.
168  */
169 BoxDimensionTest DimensionTestForScalingMode( FittingMode::Type fittingMode )
170 {
171   BoxDimensionTest dimensionTest;
172   dimensionTest = BoxDimensionTestEither;
173
174   switch( fittingMode )
175   {
176     // Shrink to fit attempts to make one or zero dimensions smaller than the
177     // desired dimensions and one or two dimensions exactly the same as the desired
178     // ones, so as long as one dimension is larger than the desired size, box
179     // filtering can continue even if the second dimension is smaller than the
180     // desired dimensions:
181     case FittingMode::SHRINK_TO_FIT:
182     {
183       dimensionTest = BoxDimensionTestEither;
184       break;
185     }
186     // Scale to fill mode keeps both dimensions at least as large as desired:
187     case FittingMode::SCALE_TO_FILL:
188     {
189       dimensionTest = BoxDimensionTestBoth;
190       break;
191     }
192     // Y dimension is irrelevant when downscaling in FIT_WIDTH mode:
193     case FittingMode::FIT_WIDTH:
194     {
195       dimensionTest = BoxDimensionTestX;
196       break;
197     }
198     // X Dimension is ignored by definition in FIT_HEIGHT mode:
199     case FittingMode::FIT_HEIGHT:
200     {
201       dimensionTest = BoxDimensionTestY;
202       break;
203     }
204   }
205
206   return dimensionTest;
207 }
208
209 /**
210  * @brief Work out the dimensions for a uniform scaling of the input to map it
211  * into the target while effecting ShinkToFit scaling mode.
212  */
213 ImageDimensions FitForShrinkToFit( ImageDimensions target, ImageDimensions source )
214 {
215   // Scale the input by the least extreme of the two dimensions:
216   const float widthScale  = target.GetX() / float(source.GetX());
217   const float heightScale = target.GetY() / float(source.GetY());
218   const float scale = widthScale < heightScale ? widthScale : heightScale;
219
220   // Do no scaling at all if the result would increase area:
221   if( scale >= 1.0f )
222   {
223     return source;
224   }
225
226   return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
227 }
228
229 /**
230  * @brief Work out the dimensions for a uniform scaling of the input to map it
231  * into the target while effecting SCALE_TO_FILL scaling mode.
232  * @note An image scaled into the output dimensions will need either top and
233  * bottom or left and right to be cropped away unless the source was pre-cropped
234  * to match the destination aspect ratio.
235  */
236 ImageDimensions FitForScaleToFill( ImageDimensions target, ImageDimensions source )
237 {
238   DALI_ASSERT_DEBUG( source.GetX() > 0 && source.GetY() > 0  && "Zero-area rectangles should not be passed-in" );
239   // Scale the input by the least extreme of the two dimensions:
240   const float widthScale  = target.GetX() / float(source.GetX());
241   const float heightScale = target.GetY() / float(source.GetY());
242   const float scale = widthScale > heightScale ? widthScale : heightScale;
243
244   // Do no scaling at all if the result would increase area:
245   if( scale >= 1.0f )
246   {
247     return source;
248   }
249
250   return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
251 }
252
253 /**
254  * @brief Work out the dimensions for a uniform scaling of the input to map it
255  * into the target while effecting FIT_WIDTH scaling mode.
256  */
257 ImageDimensions FitForFitWidth( ImageDimensions target, ImageDimensions source )
258 {
259   DALI_ASSERT_DEBUG( source.GetX() > 0 && "Cant fit a zero-dimension rectangle." );
260   const float scale  = target.GetX() / float(source.GetX());
261
262   // Do no scaling at all if the result would increase area:
263   if( scale >= 1.0f )
264   {
265    return source;
266   }
267   return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
268 }
269
270 /**
271  * @brief Work out the dimensions for a uniform scaling of the input to map it
272  * into the target while effecting FIT_HEIGHT scaling mode.
273  */
274 ImageDimensions FitForFitHeight( ImageDimensions target, ImageDimensions source )
275 {
276   DALI_ASSERT_DEBUG( source.GetY() > 0 && "Cant fit a zero-dimension rectangle." );
277   const float scale = target.GetY() / float(source.GetY());
278
279   // Do no scaling at all if the result would increase area:
280   if( scale >= 1.0f )
281   {
282     return source;
283   }
284
285   return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
286 }
287
288 /**
289  * @brief Generate the rectangle to use as the target of a pixel sampling pass
290  * (e.g., nearest or linear).
291  */
292 ImageDimensions FitToScalingMode( ImageDimensions requestedSize, ImageDimensions sourceSize, FittingMode::Type fittingMode )
293 {
294   ImageDimensions fitDimensions;
295   switch( fittingMode )
296   {
297     case FittingMode::SHRINK_TO_FIT:
298     {
299       fitDimensions = FitForShrinkToFit( requestedSize, sourceSize );
300       break;
301     }
302     case FittingMode::SCALE_TO_FILL:
303     {
304       fitDimensions = FitForScaleToFill( requestedSize, sourceSize );
305       break;
306     }
307     case FittingMode::FIT_WIDTH:
308     {
309       fitDimensions = FitForFitWidth( requestedSize, sourceSize );
310       break;
311     }
312     case FittingMode::FIT_HEIGHT:
313     {
314       fitDimensions = FitForFitHeight( requestedSize, sourceSize );
315       break;
316     }
317   }
318
319   return fitDimensions;
320 }
321
322 /**
323  * @brief Calculate the number of lines on the X and Y axis that need to be
324  * either added or removed with repect to the specified fitting mode.
325  * (e.g., nearest or linear).
326  * @param[in]     sourceSize      The size of the source image
327  * @param[in]     fittingMode     The fitting mode to use
328  * @param[in/out] requestedSize   The target size that the image will be fitted to.
329  *                                If the source image is smaller than the requested size, the source is not scaled up.
330  *                                So we reduce the target size while keeping aspect by lowering resolution.
331  * @param[out]    scanlinesToCrop The number of scanlines to remove from the image (can be negative to represent Y borders required)
332  * @param[out]    columnsToCrop   The number of columns to remove from the image (can be negative to represent X borders required)
333  */
334 void CalculateBordersFromFittingMode(  ImageDimensions sourceSize, FittingMode::Type fittingMode, ImageDimensions& requestedSize, int& scanlinesToCrop, int& columnsToCrop )
335 {
336   const unsigned int sourceWidth( sourceSize.GetWidth() );
337   const unsigned int sourceHeight( sourceSize.GetHeight() );
338   const float targetAspect( static_cast< float >( requestedSize.GetWidth() ) / static_cast< float >( requestedSize.GetHeight() ) );
339   int finalWidth = 0;
340   int finalHeight = 0;
341
342   switch( fittingMode )
343   {
344     case FittingMode::FIT_WIDTH:
345     {
346       finalWidth = sourceWidth;
347       finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
348
349       columnsToCrop = 0;
350       scanlinesToCrop = -( finalHeight - sourceHeight );
351       break;
352     }
353
354     case FittingMode::FIT_HEIGHT:
355     {
356       finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
357       finalHeight = sourceHeight;
358
359       columnsToCrop = -( finalWidth - sourceWidth );
360       scanlinesToCrop = 0;
361       break;
362     }
363
364     case FittingMode::SHRINK_TO_FIT:
365     {
366       const float sourceAspect( static_cast< float >( sourceWidth ) / static_cast< float >( sourceHeight ) );
367       if( sourceAspect > targetAspect )
368       {
369         finalWidth = sourceWidth;
370         finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
371
372         columnsToCrop = 0;
373         scanlinesToCrop = -( finalHeight - sourceHeight );
374       }
375       else
376       {
377         finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
378         finalHeight = sourceHeight;
379
380         columnsToCrop = -( finalWidth - sourceWidth );
381         scanlinesToCrop = 0;
382       }
383       break;
384     }
385
386     case FittingMode::SCALE_TO_FILL:
387     {
388       const float sourceAspect( static_cast< float >( sourceWidth ) / static_cast< float >( sourceHeight ) );
389       if( sourceAspect > targetAspect )
390       {
391         finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
392         finalHeight = sourceHeight;
393
394         columnsToCrop = -( finalWidth - sourceWidth );
395         scanlinesToCrop = 0;
396       }
397       else
398       {
399         finalWidth = sourceWidth;
400         finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
401
402         columnsToCrop = 0;
403         scanlinesToCrop = -( finalHeight - sourceHeight );
404       }
405       break;
406     }
407   }
408
409   requestedSize.SetWidth( finalWidth );
410   requestedSize.SetHeight( finalHeight );
411 }
412
413 /**
414  * @brief Construct a pixel buffer object from a copy of the pixel array passed in.
415  */
416 Dali::Devel::PixelBuffer MakePixelBuffer( const uint8_t * const pixels, Pixel::Format pixelFormat, unsigned int width, unsigned int height )
417 {
418   DALI_ASSERT_DEBUG( pixels && "Null bitmap buffer to copy." );
419
420   // Allocate a pixel buffer to hold the image passed in:
421   auto newBitmap = Dali::Devel::PixelBuffer::New( width, height, pixelFormat );
422
423   // Copy over the pixels from the downscaled image that was generated in-place in the pixel buffer of the input bitmap:
424   memcpy( newBitmap.GetBuffer(), pixels, width * height * Pixel::GetBytesPerPixel( pixelFormat ) );
425   return newBitmap;
426 }
427
428 /**
429  * @brief Work out the desired width and height, accounting for zeros.
430  *
431  * @param[in] bitmapWidth Width of image before processing.
432  * @param[in] bitmapHeight Height of image before processing.
433  * @param[in] requestedWidth Width of area to scale image into. Can be zero.
434  * @param[in] requestedHeight Height of area to scale image into. Can be zero.
435  * @return Dimensions of area to scale image into after special rules are applied.
436  */
437 ImageDimensions CalculateDesiredDimensions( unsigned int bitmapWidth, unsigned int bitmapHeight, unsigned int requestedWidth, unsigned int requestedHeight )
438 {
439   unsigned int maxSize = Dali::GetMaxTextureSize();
440
441   // If no dimensions have been requested, default to the source ones:
442   if( requestedWidth == 0 && requestedHeight == 0 )
443   {
444     if( bitmapWidth <= maxSize && bitmapHeight <= maxSize )
445     {
446       return ImageDimensions( bitmapWidth, bitmapHeight );
447     }
448     else
449     {
450       // Calculate the size from the max texture size and the source image aspect ratio
451       if( bitmapWidth > bitmapHeight )
452       {
453         return ImageDimensions( maxSize, bitmapHeight * maxSize / static_cast< float >( bitmapWidth ) + 0.5f );
454       }
455       else
456       {
457         return ImageDimensions( bitmapWidth * maxSize / static_cast< float >( bitmapHeight ) + 0.5f, maxSize );
458       }
459     }
460   }
461
462   // If both dimensions have values requested, use them both:
463   if( requestedWidth != 0 && requestedHeight != 0 )
464   {
465     if( requestedWidth <= maxSize && requestedHeight <= maxSize )
466     {
467       return ImageDimensions( requestedWidth, requestedHeight );
468     }
469     else
470     {
471       // Calculate the size from the max texture size and the source image aspect ratio
472       if( requestedWidth > requestedHeight )
473       {
474         return ImageDimensions( maxSize, requestedHeight * maxSize / static_cast< float >( requestedWidth ) + 0.5f );
475       }
476       else
477       {
478         return ImageDimensions( requestedWidth * maxSize / static_cast< float >( requestedHeight ) + 0.5f, maxSize );
479       }
480     }
481   }
482
483   // Only one of the dimensions has been requested. Calculate the other from
484   // the requested one and the source image aspect ratio:
485   if( requestedWidth != 0 )
486   {
487     requestedWidth = std::min( requestedWidth, maxSize );
488     return ImageDimensions( requestedWidth, bitmapHeight / float(bitmapWidth) * requestedWidth + 0.5f );
489   }
490
491   requestedHeight = std::min( requestedHeight, maxSize );
492   return ImageDimensions( bitmapWidth / float(bitmapHeight) * requestedHeight + 0.5f, requestedHeight );
493 }
494
495 } // namespace - unnamed
496
497 ImageDimensions CalculateDesiredDimensions( ImageDimensions rawDimensions, ImageDimensions requestedDimensions )
498 {
499   return CalculateDesiredDimensions( rawDimensions.GetWidth(), rawDimensions.GetHeight(), requestedDimensions.GetWidth(), requestedDimensions.GetHeight() ) ;
500 }
501
502 /**
503  * @brief Apply cropping and padding for specified fitting mode.
504  *
505  * Once the bitmap has been (optionally) downscaled to an appropriate size, this method performs alterations
506  * based on the fitting mode.
507  *
508  * This will add vertical or horizontal borders if necessary.
509  * Crop the source image data vertically or horizontally if necessary.
510  * The aspect of the source image is preserved.
511  * If the source image is smaller than the desired size, the algorithm will modify the the newly created
512  *   bitmaps dimensions to only be as large as necessary, as a memory saving optimization. This will cause
513  *   GPU scaling to be performed at render time giving the same result with less texture traversal.
514  *
515  * @param[in] bitmap            The source pixel buffer to perform modifications on.
516  * @param[in] desiredDimensions The target dimensions to aim to fill based on the fitting mode.
517  * @param[in] fittingMode       The fitting mode to use.
518  *
519  * @return                      A new bitmap with the padding and cropping required for fitting mode applied.
520  *                              If no modification is needed or possible, the passed in bitmap is returned.
521  */
522 Dali::Devel::PixelBuffer CropAndPadForFittingMode( Dali::Devel::PixelBuffer& bitmap, ImageDimensions desiredDimensions, FittingMode::Type fittingMode );
523
524 /**
525  * @brief Adds horizontal or vertical borders to the source image.
526  *
527  * @param[in] targetPixels     The destination image pointer to draw the borders on.
528  * @param[in] bytesPerPixel    The number of bytes per pixel of the target pixel buffer.
529  * @param[in] targetDimensions The dimensions of the destination image.
530  * @param[in] padDimensions    The columns and scanlines to pad with borders.
531  */
532 void AddBorders( PixelBuffer *targetPixels, const unsigned int bytesPerPixel, const ImageDimensions targetDimensions, const ImageDimensions padDimensions );
533
534 Dali::Devel::PixelBuffer ApplyAttributesToBitmap( Dali::Devel::PixelBuffer bitmap, ImageDimensions dimensions, FittingMode::Type fittingMode, SamplingMode::Type samplingMode )
535 {
536   if( bitmap )
537   {
538     // Calculate the desired box, accounting for a possible zero component:
539     const ImageDimensions desiredDimensions  = CalculateDesiredDimensions( bitmap.GetWidth(), bitmap.GetHeight(), dimensions.GetWidth(), dimensions.GetHeight() );
540
541     // If a different size than the raw one has been requested, resize the image
542     // maximally using a repeated box filter without making it smaller than the
543     // requested size in either dimension:
544     bitmap = DownscaleBitmap( bitmap, desiredDimensions, fittingMode, samplingMode );
545
546     // Cut the bitmap according to the desired width and height so that the
547     // resulting bitmap has the same aspect ratio as the desired dimensions.
548     // Add crop and add borders if necessary depending on fitting mode.
549     if( bitmap )
550     {
551       bitmap = CropAndPadForFittingMode( bitmap, desiredDimensions, fittingMode );
552     }
553   }
554
555   return bitmap;
556 }
557
558 Dali::Devel::PixelBuffer CropAndPadForFittingMode( Dali::Devel::PixelBuffer& bitmap, ImageDimensions desiredDimensions, FittingMode::Type fittingMode )
559 {
560   const unsigned int inputWidth = bitmap.GetWidth();
561   const unsigned int inputHeight = bitmap.GetHeight();
562
563   if( desiredDimensions.GetWidth() < 1u || desiredDimensions.GetHeight() < 1u )
564   {
565     DALI_LOG_WARNING( "Image scaling aborted as desired dimensions too small (%u, %u).\n", desiredDimensions.GetWidth(), desiredDimensions.GetHeight() );
566   }
567   else if( inputWidth != desiredDimensions.GetWidth() || inputHeight != desiredDimensions.GetHeight() )
568   {
569     // Calculate any padding or cropping that needs to be done based on the fitting mode.
570     // Note: If the desired size is larger than the original image, the desired size will be
571     // reduced while maintaining the aspect, in order to save unnecessary memory usage.
572     int scanlinesToCrop = 0;
573     int columnsToCrop = 0;
574
575     CalculateBordersFromFittingMode( ImageDimensions( inputWidth, inputHeight ), fittingMode, desiredDimensions, scanlinesToCrop, columnsToCrop );
576
577     unsigned int desiredWidth( desiredDimensions.GetWidth() );
578     unsigned int desiredHeight( desiredDimensions.GetHeight() );
579
580     // Action the changes by making a new bitmap with the central part of the loaded one if required.
581     if( scanlinesToCrop != 0 || columnsToCrop != 0 )
582     {
583       // Split the adding and removing of scanlines and columns into separate variables,
584       // so we can use one piece of generic code to action the changes.
585       unsigned int scanlinesToPad = 0;
586       unsigned int columnsToPad = 0;
587       if( scanlinesToCrop < 0 )
588       {
589         scanlinesToPad = -scanlinesToCrop;
590         scanlinesToCrop = 0;
591       }
592       if( columnsToCrop < 0 )
593       {
594         columnsToPad = -columnsToCrop;
595         columnsToCrop = 0;
596       }
597
598       // If there is no filtering, then the final image size can become very large, exit if larger than maximum.
599       if( ( desiredWidth > MAXIMUM_TARGET_BITMAP_SIZE ) || ( desiredHeight > MAXIMUM_TARGET_BITMAP_SIZE ) ||
600           ( columnsToPad > MAXIMUM_TARGET_BITMAP_SIZE ) || ( scanlinesToPad > MAXIMUM_TARGET_BITMAP_SIZE ) )
601       {
602         DALI_LOG_WARNING( "Image scaling aborted as final dimensions too large (%u, %u).\n", desiredWidth, desiredHeight );
603         return bitmap;
604       }
605
606       // Create new PixelBuffer with the desired size.
607       const auto pixelFormat = bitmap.GetPixelFormat();
608
609       auto croppedBitmap = Devel::PixelBuffer::New( desiredWidth, desiredHeight, pixelFormat );
610
611       // Add some pre-calculated offsets to the bitmap pointers so this is not done within a loop.
612       // The cropping is added to the source pointer, and the padding is added to the destination.
613       const auto bytesPerPixel = Pixel::GetBytesPerPixel( pixelFormat );
614       const PixelBuffer * const sourcePixels = bitmap.GetBuffer() + ( ( ( ( scanlinesToCrop / 2 ) * inputWidth ) + ( columnsToCrop / 2 ) ) * bytesPerPixel );
615       PixelBuffer * const targetPixels = croppedBitmap.GetBuffer();
616       PixelBuffer * const targetPixelsActive = targetPixels + ( ( ( ( scanlinesToPad / 2 ) * desiredWidth ) + ( columnsToPad / 2 ) ) * bytesPerPixel );
617       DALI_ASSERT_DEBUG( sourcePixels && targetPixels );
618
619       // Copy the image data to the new bitmap.
620       // Optimize to a single memcpy if the left and right edges don't need a crop or a pad.
621       unsigned int outputSpan( desiredWidth * bytesPerPixel );
622       if( columnsToCrop == 0 && columnsToPad == 0 )
623       {
624         memcpy( targetPixelsActive, sourcePixels, ( desiredHeight - scanlinesToPad ) * outputSpan );
625       }
626       else
627       {
628         // The width needs to change (due to either a crop or a pad), so we copy a scanline at a time.
629         // Precalculate any constants to optimize the inner loop.
630         const unsigned int inputSpan( inputWidth * bytesPerPixel );
631         const unsigned int copySpan( ( desiredWidth - columnsToPad ) * bytesPerPixel );
632         const unsigned int scanlinesToCopy( desiredHeight - scanlinesToPad );
633
634         for( unsigned int y = 0; y < scanlinesToCopy; ++y )
635         {
636           memcpy( &targetPixelsActive[ y * outputSpan ], &sourcePixels[ y * inputSpan ], copySpan );
637         }
638       }
639
640       // Add vertical or horizontal borders to the final image (if required).
641       desiredDimensions.SetWidth( desiredWidth );
642       desiredDimensions.SetHeight( desiredHeight );
643       AddBorders( croppedBitmap.GetBuffer(), bytesPerPixel, desiredDimensions, ImageDimensions( columnsToPad, scanlinesToPad ) );
644       // Overwrite the loaded bitmap with the cropped version
645       bitmap = croppedBitmap;
646     }
647   }
648
649   return bitmap;
650 }
651
652 void AddBorders( PixelBuffer *targetPixels, const unsigned int bytesPerPixel, const ImageDimensions targetDimensions, const ImageDimensions padDimensions )
653 {
654   // Assign ints for faster access.
655   unsigned int desiredWidth( targetDimensions.GetWidth() );
656   unsigned int desiredHeight( targetDimensions.GetHeight() );
657   unsigned int columnsToPad( padDimensions.GetWidth() );
658   unsigned int scanlinesToPad( padDimensions.GetHeight() );
659   unsigned int outputSpan( desiredWidth * bytesPerPixel );
660
661   // Add letterboxing (symmetrical borders) if needed.
662   if( scanlinesToPad > 0 )
663   {
664     // Add a top border. Note: This is (deliberately) rounded down if padding is an odd number.
665     memset( targetPixels, BORDER_FILL_VALUE, ( scanlinesToPad / 2 ) * outputSpan );
666
667     // We subtract scanlinesToPad/2 from scanlinesToPad so that we have the correct
668     // offset for odd numbers (as the top border is 1 pixel smaller in these cases.
669     unsigned int bottomBorderHeight = scanlinesToPad - ( scanlinesToPad / 2 );
670
671     // Bottom border.
672     memset( &targetPixels[ ( desiredHeight - bottomBorderHeight ) * outputSpan ], BORDER_FILL_VALUE, bottomBorderHeight * outputSpan );
673   }
674   else if( columnsToPad > 0 )
675   {
676     // Add a left and right border.
677     // Left:
678     // Pre-calculate span size outside of loop.
679     unsigned int leftBorderSpanWidth( ( columnsToPad / 2 ) * bytesPerPixel );
680     for( unsigned int y = 0; y < desiredHeight; ++y )
681     {
682       memset( &targetPixels[ y * outputSpan ], BORDER_FILL_VALUE, leftBorderSpanWidth );
683     }
684
685     // Right:
686     // Pre-calculate the initial x offset as it is always the same for a small optimization.
687     // We subtract columnsToPad/2 from columnsToPad so that we have the correct
688     // offset for odd numbers (as the left border is 1 pixel smaller in these cases.
689     unsigned int rightBorderWidth = columnsToPad - ( columnsToPad / 2 );
690     PixelBuffer * const destPixelsRightBorder( targetPixels + ( ( desiredWidth - rightBorderWidth ) * bytesPerPixel ) );
691     unsigned int rightBorderSpanWidth = rightBorderWidth * bytesPerPixel;
692
693     for( unsigned int y = 0; y < desiredHeight; ++y )
694     {
695       memset( &destPixelsRightBorder[ y * outputSpan ], BORDER_FILL_VALUE, rightBorderSpanWidth );
696     }
697   }
698 }
699
700 Dali::Devel::PixelBuffer DownscaleBitmap( Dali::Devel::PixelBuffer bitmap,
701                                         ImageDimensions desired,
702                                         FittingMode::Type fittingMode,
703                                         SamplingMode::Type samplingMode )
704 {
705   // Source dimensions as loaded from resources (e.g. filesystem):
706   auto bitmapWidth  = bitmap.GetWidth();
707   auto bitmapHeight = bitmap.GetHeight();
708   // Desired dimensions (the rectangle to fit the source image to):
709   auto desiredWidth = desired.GetWidth();
710   auto desiredHeight = desired.GetHeight();
711
712   Dali::Devel::PixelBuffer outputBitmap { bitmap };
713
714   // If a different size than the raw one has been requested, resize the image:
715   if(
716       (desiredWidth > 0.0f) && (desiredHeight > 0.0f) &&
717       ((desiredWidth < bitmapWidth) || (desiredHeight < bitmapHeight)) )
718   {
719     auto pixelFormat = bitmap.GetPixelFormat();
720
721     // Do the fast power of 2 iterated box filter to get to roughly the right side if the filter mode requests that:
722     unsigned int shrunkWidth = -1, shrunkHeight = -1;
723     DownscaleInPlacePow2( bitmap.GetBuffer(), pixelFormat, bitmapWidth, bitmapHeight, desiredWidth, desiredHeight, fittingMode, samplingMode, shrunkWidth, shrunkHeight );
724
725     // Work out the dimensions of the downscaled bitmap, given the scaling mode and desired dimensions:
726     const ImageDimensions filteredDimensions = FitToScalingMode( ImageDimensions( desiredWidth, desiredHeight ), ImageDimensions( shrunkWidth, shrunkHeight ), fittingMode );
727     const unsigned int filteredWidth = filteredDimensions.GetWidth();
728     const unsigned int filteredHeight = filteredDimensions.GetHeight();
729
730     // Run a filter to scale down the bitmap if it needs it:
731     bool filtered = false;
732     if( filteredWidth < shrunkWidth || filteredHeight < shrunkHeight )
733     {
734       if( samplingMode == SamplingMode::LINEAR || samplingMode == SamplingMode::BOX_THEN_LINEAR ||
735           samplingMode == SamplingMode::NEAREST || samplingMode == SamplingMode::BOX_THEN_NEAREST )
736       {
737         outputBitmap = Dali::Devel::PixelBuffer::New( filteredWidth, filteredHeight, pixelFormat );
738
739         if( outputBitmap )
740         {
741           if( samplingMode == SamplingMode::LINEAR || samplingMode == SamplingMode::BOX_THEN_LINEAR )
742           {
743             LinearSample( bitmap.GetBuffer(), ImageDimensions(shrunkWidth, shrunkHeight), pixelFormat, outputBitmap.GetBuffer(), filteredDimensions );
744           }
745           else
746           {
747             PointSample( bitmap.GetBuffer(), shrunkWidth, shrunkHeight, pixelFormat, outputBitmap.GetBuffer(), filteredWidth, filteredHeight );
748           }
749           filtered = true;
750         }
751       }
752     }
753     // Copy out the 2^x downscaled, box-filtered pixels if no secondary filter (point or linear) was applied:
754     if( filtered == false && ( shrunkWidth < bitmapWidth || shrunkHeight < bitmapHeight ) )
755     {
756       outputBitmap = MakePixelBuffer( bitmap.GetBuffer(), pixelFormat, shrunkWidth, shrunkHeight );
757     }
758   }
759
760   return outputBitmap;
761 }
762
763 namespace
764 {
765 /**
766  * @brief Returns whether to keep box filtering based on whether downscaled dimensions will overshoot the desired ones aty the next step.
767  * @param test Which combination of the two dimensions matter for terminating the filtering.
768  * @param scaledWidth The width of the current downscaled image.
769  * @param scaledHeight The height of the current downscaled image.
770  * @param desiredWidth The target width for the downscaling.
771  * @param desiredHeight The target height for the downscaling.
772  */
773 bool ContinueScaling( BoxDimensionTest test, unsigned int scaledWidth, unsigned int scaledHeight, unsigned int desiredWidth, unsigned int desiredHeight )
774 {
775   bool keepScaling = false;
776   const unsigned int nextWidth = scaledWidth >> 1u;
777   const unsigned int nextHeight = scaledHeight >> 1u;
778
779   if( nextWidth >= 1u && nextHeight >= 1u )
780   {
781     switch( test )
782     {
783       case BoxDimensionTestEither:
784       {
785         keepScaling = nextWidth >= desiredWidth || nextHeight >= desiredHeight;
786         break;
787       }
788       case BoxDimensionTestBoth:
789       {
790         keepScaling = nextWidth >= desiredWidth && nextHeight >= desiredHeight;
791         break;
792       }
793       case BoxDimensionTestX:
794       {
795         keepScaling = nextWidth >= desiredWidth;
796         break;
797       }
798       case BoxDimensionTestY:
799       {
800         keepScaling = nextHeight >= desiredHeight;
801         break;
802       }
803     }
804   }
805
806   return keepScaling;
807 }
808
809 /**
810  * @brief A shared implementation of the overall iterative box filter
811  * downscaling algorithm.
812  *
813  * Specialise this for particular pixel formats by supplying the number of bytes
814  * per pixel and two functions: one for averaging pairs of neighbouring pixels
815  * on a single scanline, and a second for averaging pixels at corresponding
816  * positions on different scanlines.
817  **/
818 template<
819   int BYTES_PER_PIXEL,
820   void (*HalveScanlineInPlace)( unsigned char * const pixels, const unsigned int width ),
821   void (*AverageScanlines) ( const unsigned char * const scanline1, const unsigned char * const __restrict__ scanline2, unsigned char* const outputScanline, const unsigned int width )
822 >
823 void DownscaleInPlacePow2Generic( unsigned char * const pixels,
824                                   const unsigned int inputWidth,
825                                   const unsigned int inputHeight,
826                                   const unsigned int desiredWidth,
827                                   const unsigned int desiredHeight,
828                                   BoxDimensionTest dimensionTest,
829                                   unsigned& outWidth,
830                                   unsigned& outHeight )
831 {
832   if( pixels == 0 )
833   {
834     return;
835   }
836   ValidateScalingParameters( inputWidth, inputHeight, desiredWidth, desiredHeight );
837
838   // Scale the image until it would be smaller than desired, stopping if the
839   // resulting height or width would be less than 1:
840   unsigned int scaledWidth = inputWidth, scaledHeight = inputHeight;
841   while( ContinueScaling( dimensionTest, scaledWidth, scaledHeight, desiredWidth, desiredHeight ) )
842   {
843     const unsigned int lastWidth = scaledWidth;
844     scaledWidth  >>= 1u;
845     scaledHeight >>= 1u;
846
847     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Scaling to %u\t%u.\n", scaledWidth, scaledHeight );
848
849     const unsigned int lastScanlinePair = scaledHeight - 1;
850
851     // Scale pairs of scanlines until any spare one at the end is dropped:
852     for( unsigned int y = 0; y <= lastScanlinePair; ++y )
853     {
854       // Scale two scanlines horizontally:
855       HalveScanlineInPlace( &pixels[y * 2 * lastWidth * BYTES_PER_PIXEL], lastWidth );
856       HalveScanlineInPlace( &pixels[(y * 2 + 1) * lastWidth * BYTES_PER_PIXEL], lastWidth );
857
858       // Scale vertical pairs of pixels while the last two scanlines are still warm in
859       // the CPU cache(s):
860       // Note, better access patterns for cache-coherence are possible for very large
861       // images but even a 4k wide RGB888 image will use just 24kB of cache (4k pixels
862       // * 3 Bpp * 2 scanlines) for two scanlines on the first iteration.
863       AverageScanlines(
864           &pixels[y * 2 * lastWidth * BYTES_PER_PIXEL],
865           &pixels[(y * 2 + 1) * lastWidth * BYTES_PER_PIXEL],
866           &pixels[y * scaledWidth * BYTES_PER_PIXEL],
867           scaledWidth );
868     }
869   }
870
871   ///@note: we could finish off with one of two mutually exclusive passes, one squashing horizontally as far as possible, and the other vertically, if we knew a following cpu point or bilinear filter would restore the desired aspect ratio.
872   outWidth = scaledWidth;
873   outHeight = scaledHeight;
874 }
875
876 }
877
878 void HalveScanlineInPlaceRGB888( unsigned char * const pixels, const unsigned int width )
879 {
880   DebugAssertScanlineParameters( pixels, width );
881
882   const unsigned int lastPair = EvenDown( width - 2 );
883
884   for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
885   {
886     // Load all the byte pixel components we need:
887     const unsigned int c11 = pixels[pixel * 3];
888     const unsigned int c12 = pixels[pixel * 3 + 1];
889     const unsigned int c13 = pixels[pixel * 3 + 2];
890     const unsigned int c21 = pixels[pixel * 3 + 3];
891     const unsigned int c22 = pixels[pixel * 3 + 4];
892     const unsigned int c23 = pixels[pixel * 3 + 5];
893
894     // Save the averaged byte pixel components:
895     pixels[outPixel * 3]     = AverageComponent( c11, c21 );
896     pixels[outPixel * 3 + 1] = AverageComponent( c12, c22 );
897     pixels[outPixel * 3 + 2] = AverageComponent( c13, c23 );
898   }
899 }
900
901 void HalveScanlineInPlaceRGBA8888( unsigned char * const pixels, const unsigned int width )
902 {
903   DebugAssertScanlineParameters( pixels, width );
904   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
905
906   uint32_t* const alignedPixels = reinterpret_cast<uint32_t*>(pixels);
907
908   const unsigned int lastPair = EvenDown( width - 2 );
909
910   for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
911   {
912     const uint32_t averaged = AveragePixelRGBA8888( alignedPixels[pixel], alignedPixels[pixel + 1] );
913     alignedPixels[outPixel] = averaged;
914   }
915 }
916
917 void HalveScanlineInPlaceRGB565( unsigned char * pixels, unsigned int width )
918 {
919   DebugAssertScanlineParameters( pixels, width );
920   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
921
922   uint16_t* const alignedPixels = reinterpret_cast<uint16_t*>(pixels);
923
924   const unsigned int lastPair = EvenDown( width - 2 );
925
926   for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
927   {
928     const uint32_t averaged = AveragePixelRGB565( alignedPixels[pixel], alignedPixels[pixel + 1] );
929     alignedPixels[outPixel] = averaged;
930   }
931 }
932
933 void HalveScanlineInPlace2Bytes( unsigned char * const pixels, const unsigned int width )
934 {
935   DebugAssertScanlineParameters( pixels, width );
936
937   const unsigned int lastPair = EvenDown( width - 2 );
938
939   for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
940   {
941     // Load all the byte pixel components we need:
942     const unsigned int c11 = pixels[pixel * 2];
943     const unsigned int c12 = pixels[pixel * 2 + 1];
944     const unsigned int c21 = pixels[pixel * 2 + 2];
945     const unsigned int c22 = pixels[pixel * 2 + 3];
946
947     // Save the averaged byte pixel components:
948     pixels[outPixel * 2]     = AverageComponent( c11, c21 );
949     pixels[outPixel * 2 + 1] = AverageComponent( c12, c22 );
950   }
951 }
952
953 void HalveScanlineInPlace1Byte( unsigned char * const pixels, const unsigned int width )
954 {
955   DebugAssertScanlineParameters( pixels, width );
956
957   const unsigned int lastPair = EvenDown( width - 2 );
958
959   for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
960   {
961     // Load all the byte pixel components we need:
962     const unsigned int c1 = pixels[pixel];
963     const unsigned int c2 = pixels[pixel + 1];
964
965     // Save the averaged byte pixel component:
966     pixels[outPixel] = AverageComponent( c1, c2 );
967   }
968 }
969
970 /**
971  * @ToDo: Optimise for ARM using a 4 bytes at a time loop wrapped around the single ARMV6 instruction: UHADD8  R4, R0, R5. Note, this is not neon. It runs in the normal integer pipeline so there is no downside like a stall moving between integer and copro, or extra power for clocking-up the idle copro.
972  * if (widthInComponents >= 7) { word32* aligned1 = scanline1 + 3 & 3; word32* aligned1_end = scanline1 + widthInPixels & 3; while(aligned1 < aligned1_end) { UHADD8  *aligned1++, *aligned2++, *alignedoutput++ } .. + 0 to 3 spare pixels at each end.
973  */
974 void AverageScanlines1( const unsigned char * const scanline1,
975                         const unsigned char * const __restrict__ scanline2,
976                         unsigned char* const outputScanline,
977                         const unsigned int width )
978 {
979   DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width );
980
981   for( unsigned int component = 0; component < width; ++component )
982   {
983     outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
984   }
985 }
986
987 void AverageScanlines2( const unsigned char * const scanline1,
988                         const unsigned char * const __restrict__ scanline2,
989                         unsigned char* const outputScanline,
990                         const unsigned int width )
991 {
992   DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 2 );
993
994   for( unsigned int component = 0; component < width * 2; ++component )
995   {
996     outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
997   }
998 }
999
1000 void AverageScanlines3( const unsigned char * const scanline1,
1001                         const unsigned char * const __restrict__ scanline2,
1002                         unsigned char* const outputScanline,
1003                         const unsigned int width )
1004 {
1005   DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 3 );
1006
1007   for( unsigned int component = 0; component < width * 3; ++component )
1008   {
1009     outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
1010   }
1011 }
1012
1013 void AverageScanlinesRGBA8888( const unsigned char * const scanline1,
1014                                const unsigned char * const __restrict__ scanline2,
1015                                unsigned char * const outputScanline,
1016                                const unsigned int width )
1017 {
1018   DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 4 );
1019   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline1) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1020   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline2) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1021   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(outputScanline) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1022
1023   const uint32_t* const alignedScanline1 = reinterpret_cast<const uint32_t*>(scanline1);
1024   const uint32_t* const alignedScanline2 = reinterpret_cast<const uint32_t*>(scanline2);
1025   uint32_t* const alignedOutput = reinterpret_cast<uint32_t*>(outputScanline);
1026
1027   for( unsigned int pixel = 0; pixel < width; ++pixel )
1028   {
1029     alignedOutput[pixel] = AveragePixelRGBA8888( alignedScanline1[pixel], alignedScanline2[pixel] );
1030   }
1031 }
1032
1033 void AverageScanlinesRGB565( const unsigned char * const scanline1,
1034                              const unsigned char * const __restrict__ scanline2,
1035                              unsigned char * const outputScanline,
1036                              const unsigned int width )
1037 {
1038   DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 2 );
1039   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline1) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1040   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline2) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1041   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(outputScanline) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1042
1043   const uint16_t* const alignedScanline1 = reinterpret_cast<const uint16_t*>(scanline1);
1044   const uint16_t* const alignedScanline2 = reinterpret_cast<const uint16_t*>(scanline2);
1045   uint16_t* const alignedOutput = reinterpret_cast<uint16_t*>(outputScanline);
1046
1047   for( unsigned int pixel = 0; pixel < width; ++pixel )
1048   {
1049     alignedOutput[pixel] = AveragePixelRGB565( alignedScanline1[pixel], alignedScanline2[pixel] );
1050   }
1051 }
1052
1053 /// Dispatch to pixel format appropriate box filter downscaling functions.
1054 void DownscaleInPlacePow2( unsigned char * const pixels,
1055                            Pixel::Format pixelFormat,
1056                            unsigned int inputWidth,
1057                            unsigned int inputHeight,
1058                            unsigned int desiredWidth,
1059                            unsigned int desiredHeight,
1060                            FittingMode::Type fittingMode,
1061                            SamplingMode::Type samplingMode,
1062                            unsigned& outWidth,
1063                            unsigned& outHeight )
1064 {
1065   outWidth = inputWidth;
1066   outHeight = inputHeight;
1067   // Perform power of 2 iterated 4:1 box filtering if the requested filter mode requires it:
1068   if( samplingMode == SamplingMode::BOX || samplingMode == SamplingMode::BOX_THEN_NEAREST || samplingMode == SamplingMode::BOX_THEN_LINEAR )
1069   {
1070     // Check the pixel format is one that is supported:
1071     if( pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1072     {
1073       const BoxDimensionTest dimensionTest = DimensionTestForScalingMode( fittingMode );
1074
1075       if( pixelFormat == Pixel::RGBA8888 )
1076       {
1077         Internal::Platform::DownscaleInPlacePow2RGBA8888( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1078       }
1079       else if( pixelFormat == Pixel::RGB888 )
1080       {
1081         Internal::Platform::DownscaleInPlacePow2RGB888( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1082       }
1083       else if( pixelFormat == Pixel::RGB565 )
1084       {
1085         Internal::Platform::DownscaleInPlacePow2RGB565( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1086       }
1087       else if( pixelFormat == Pixel::LA88 )
1088       {
1089         Internal::Platform::DownscaleInPlacePow2ComponentPair( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1090       }
1091       else if( pixelFormat == Pixel::L8  || pixelFormat == Pixel::A8 )
1092       {
1093         Internal::Platform::DownscaleInPlacePow2SingleBytePerPixel( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1094       }
1095       else
1096       {
1097         DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1098       }
1099     }
1100   }
1101   else
1102   {
1103     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not shrunk: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1104   }
1105 }
1106
1107 void DownscaleInPlacePow2RGB888( unsigned char *pixels,
1108                                  unsigned int inputWidth,
1109                                  unsigned int inputHeight,
1110                                  unsigned int desiredWidth,
1111                                  unsigned int desiredHeight,
1112                                  BoxDimensionTest dimensionTest,
1113                                  unsigned& outWidth,
1114                                  unsigned& outHeight )
1115 {
1116   DownscaleInPlacePow2Generic<3, HalveScanlineInPlaceRGB888, AverageScanlines3>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1117 }
1118
1119 void DownscaleInPlacePow2RGBA8888( unsigned char * pixels,
1120                                    unsigned int inputWidth,
1121                                    unsigned int inputHeight,
1122                                    unsigned int desiredWidth,
1123                                    unsigned int desiredHeight,
1124                                    BoxDimensionTest dimensionTest,
1125                                    unsigned& outWidth,
1126                                    unsigned& outHeight )
1127 {
1128   DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1129   DownscaleInPlacePow2Generic<4, HalveScanlineInPlaceRGBA8888, AverageScanlinesRGBA8888>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1130 }
1131
1132 void DownscaleInPlacePow2RGB565( unsigned char * pixels,
1133                                  unsigned int inputWidth,
1134                                  unsigned int inputHeight,
1135                                  unsigned int desiredWidth,
1136                                  unsigned int desiredHeight,
1137                                  BoxDimensionTest dimensionTest,
1138                                  unsigned int& outWidth,
1139                                  unsigned int& outHeight )
1140 {
1141   DownscaleInPlacePow2Generic<2, HalveScanlineInPlaceRGB565, AverageScanlinesRGB565>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1142 }
1143
1144 /**
1145  * @copydoc DownscaleInPlacePow2RGB888
1146  *
1147  * For 2-byte formats such as lum8alpha8, but not packed 16 bit formats like RGB565.
1148  */
1149 void DownscaleInPlacePow2ComponentPair( unsigned char *pixels,
1150                                         unsigned int inputWidth,
1151                                         unsigned int inputHeight,
1152                                         unsigned int desiredWidth,
1153                                         unsigned int desiredHeight,
1154                                         BoxDimensionTest dimensionTest,
1155                                         unsigned& outWidth,
1156                                         unsigned& outHeight )
1157 {
1158   DownscaleInPlacePow2Generic<2, HalveScanlineInPlace2Bytes, AverageScanlines2>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1159 }
1160
1161 void DownscaleInPlacePow2SingleBytePerPixel( unsigned char * pixels,
1162                                              unsigned int inputWidth,
1163                                              unsigned int inputHeight,
1164                                              unsigned int desiredWidth,
1165                                              unsigned int desiredHeight,
1166                                              BoxDimensionTest dimensionTest,
1167                                              unsigned int& outWidth,
1168                                              unsigned int& outHeight )
1169 {
1170   DownscaleInPlacePow2Generic<1, HalveScanlineInPlace1Byte, AverageScanlines1>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1171 }
1172
1173 namespace
1174 {
1175
1176 /**
1177  * @brief Point sample an image to a new resolution (like GL_NEAREST).
1178  *
1179  * Template is used purely as a type-safe code generator in this one
1180  * compilation unit. Generated code is inlined into type-specific wrapper
1181  * functions below which are exported to rest of module.
1182  */
1183 template<typename PIXEL>
1184 inline void PointSampleAddressablePixels( const uint8_t * inPixels,
1185                                    unsigned int inputWidth,
1186                                    unsigned int inputHeight,
1187                                    uint8_t * outPixels,
1188                                    unsigned int desiredWidth,
1189                                    unsigned int desiredHeight )
1190 {
1191   DALI_ASSERT_DEBUG( ((desiredWidth <= inputWidth && desiredHeight <= inputHeight) ||
1192       outPixels >= inPixels + inputWidth * inputHeight * sizeof(PIXEL) || outPixels <= inPixels - desiredWidth * desiredHeight * sizeof(PIXEL)) &&
1193       "The input and output buffers must not overlap for an upscaling.");
1194   DALI_ASSERT_DEBUG( reinterpret_cast< uint64_t >( inPixels )  % sizeof(PIXEL) == 0 && "Pixel pointers need to be aligned to the size of the pixels (E.g., 4 bytes for RGBA, 2 bytes for RGB565, ...)." );
1195   DALI_ASSERT_DEBUG( reinterpret_cast< uint64_t >( outPixels ) % sizeof(PIXEL) == 0 && "Pixel pointers need to be aligned to the size of the pixels (E.g., 4 bytes for RGBA, 2 bytes for RGB565, ...)." );
1196
1197   if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1198   {
1199     return;
1200   }
1201   const PIXEL* const inAligned = reinterpret_cast<const PIXEL*>(inPixels);
1202   PIXEL* const       outAligned = reinterpret_cast<PIXEL*>(outPixels);
1203   const unsigned int deltaX = (inputWidth  << 16u) / desiredWidth;
1204   const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1205
1206   unsigned int inY = 0;
1207   for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1208   {
1209     // Round fixed point y coordinate to nearest integer:
1210     const unsigned int integerY = (inY + (1u << 15u)) >> 16u;
1211     const PIXEL* const inScanline = &inAligned[inputWidth * integerY];
1212     PIXEL* const outScanline = &outAligned[desiredWidth * outY];
1213
1214     DALI_ASSERT_DEBUG( integerY < inputHeight );
1215     DALI_ASSERT_DEBUG( reinterpret_cast<const uint8_t*>(inScanline) < ( inPixels + inputWidth * inputHeight * sizeof(PIXEL) ) );
1216     DALI_ASSERT_DEBUG( reinterpret_cast<uint8_t*>(outScanline) < ( outPixels + desiredWidth * desiredHeight * sizeof(PIXEL) ) );
1217
1218     unsigned int inX = 0;
1219     for( unsigned int outX = 0; outX < desiredWidth; ++outX )
1220     {
1221       // Round the fixed-point x coordinate to an integer:
1222       const unsigned int integerX = (inX + (1u << 15u)) >> 16u;
1223       const PIXEL* const inPixelAddress = &inScanline[integerX];
1224       const PIXEL pixel = *inPixelAddress;
1225       outScanline[outX] = pixel;
1226       inX += deltaX;
1227     }
1228     inY += deltaY;
1229   }
1230 }
1231
1232 }
1233
1234 // RGBA8888
1235 void PointSample4BPP( const unsigned char * inPixels,
1236                       unsigned int inputWidth,
1237                       unsigned int inputHeight,
1238                       unsigned char * outPixels,
1239                       unsigned int desiredWidth,
1240                       unsigned int desiredHeight )
1241 {
1242   PointSampleAddressablePixels<uint32_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1243 }
1244
1245 // RGB565, LA88
1246 void PointSample2BPP( const unsigned char * inPixels,
1247                       unsigned int inputWidth,
1248                       unsigned int inputHeight,
1249                       unsigned char * outPixels,
1250                       unsigned int desiredWidth,
1251                       unsigned int desiredHeight )
1252 {
1253   PointSampleAddressablePixels<uint16_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1254 }
1255
1256 // L8, A8
1257 void PointSample1BPP( const unsigned char * inPixels,
1258                       unsigned int inputWidth,
1259                       unsigned int inputHeight,
1260                       unsigned char * outPixels,
1261                       unsigned int desiredWidth,
1262                       unsigned int desiredHeight )
1263 {
1264   PointSampleAddressablePixels<uint8_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1265 }
1266
1267 /* RGB888
1268  * RGB888 is a special case as its pixels are not aligned addressable units.
1269  */
1270 void PointSample3BPP( const uint8_t * inPixels,
1271                       unsigned int inputWidth,
1272                       unsigned int inputHeight,
1273                       uint8_t * outPixels,
1274                       unsigned int desiredWidth,
1275                       unsigned int desiredHeight )
1276 {
1277   if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1278   {
1279     return;
1280   }
1281   const unsigned int BYTES_PER_PIXEL = 3;
1282
1283   // Generate fixed-point 16.16 deltas in input image coordinates:
1284   const unsigned int deltaX = (inputWidth  << 16u) / desiredWidth;
1285   const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1286
1287   // Step through output image in whole integer pixel steps while tracking the
1288   // corresponding locations in the input image using 16.16 fixed-point
1289   // coordinates:
1290   unsigned int inY = 0; //< 16.16 fixed-point input image y-coord.
1291   for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1292   {
1293     const unsigned int integerY = (inY + (1u << 15u)) >> 16u;
1294     const uint8_t* const inScanline = &inPixels[inputWidth * integerY * BYTES_PER_PIXEL];
1295     uint8_t* const outScanline = &outPixels[desiredWidth * outY * BYTES_PER_PIXEL];
1296     unsigned int inX = 0; //< 16.16 fixed-point input image x-coord.
1297
1298     for( unsigned int outX = 0; outX < desiredWidth * BYTES_PER_PIXEL; outX += BYTES_PER_PIXEL )
1299     {
1300       // Round the fixed-point input coordinate to the address of the input pixel to sample:
1301       const unsigned int integerX = (inX + (1u << 15u)) >> 16u;
1302       const uint8_t* const inPixelAddress = &inScanline[integerX * BYTES_PER_PIXEL];
1303
1304       // Issue loads for all pixel color components up-front:
1305       const unsigned int c0 = inPixelAddress[0];
1306       const unsigned int c1 = inPixelAddress[1];
1307       const unsigned int c2 = inPixelAddress[2];
1308       ///@ToDo: Optimise - Benchmark one 32bit load that will be unaligned 2/3 of the time + 3 rotate and masks, versus these three aligned byte loads, versus using an RGB packed, aligned(1) struct and letting compiler pick a strategy.
1309
1310       // Output the pixel components:
1311       outScanline[outX]     = c0;
1312       outScanline[outX + 1] = c1;
1313       outScanline[outX + 2] = c2;
1314
1315       // Increment the fixed-point input coordinate:
1316       inX += deltaX;
1317     }
1318
1319     inY += deltaY;
1320   }
1321 }
1322
1323 // Dispatch to a format-appropriate point sampling function:
1324 void PointSample( const unsigned char * inPixels,
1325                   unsigned int inputWidth,
1326                   unsigned int inputHeight,
1327                   Pixel::Format pixelFormat,
1328                   unsigned char * outPixels,
1329                   unsigned int desiredWidth,
1330                   unsigned int desiredHeight )
1331 {
1332   // Check the pixel format is one that is supported:
1333   if( pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1334   {
1335     if( pixelFormat == Pixel::RGB888 )
1336     {
1337       PointSample3BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1338     }
1339     else if( pixelFormat == Pixel::RGBA8888 )
1340     {
1341       PointSample4BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1342     }
1343     else if( pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 )
1344     {
1345       PointSample2BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1346     }
1347     else if( pixelFormat == Pixel::L8  || pixelFormat == Pixel::A8 )
1348     {
1349       PointSample1BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1350     }
1351     else
1352     {
1353       DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1354     }
1355   }
1356   else
1357   {
1358     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not point sampled: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1359   }
1360 }
1361
1362 // Linear sampling group below
1363
1364 namespace
1365 {
1366
1367 /** @brief Blend 4 pixels together using horizontal and vertical weights. */
1368 inline uint8_t BilinearFilter1BPPByte( uint8_t tl, uint8_t tr, uint8_t bl, uint8_t br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1369 {
1370   return BilinearFilter1Component( tl, tr, bl, br, fractBlendHorizontal, fractBlendVertical );
1371 }
1372
1373 /** @copydoc BilinearFilter1BPPByte */
1374 inline Pixel2Bytes BilinearFilter2Bytes( Pixel2Bytes tl, Pixel2Bytes tr, Pixel2Bytes bl, Pixel2Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1375 {
1376   Pixel2Bytes pixel;
1377   pixel.l = BilinearFilter1Component( tl.l, tr.l, bl.l, br.l, fractBlendHorizontal, fractBlendVertical );
1378   pixel.a = BilinearFilter1Component( tl.a, tr.a, bl.a, br.a, fractBlendHorizontal, fractBlendVertical );
1379   return pixel;
1380 }
1381
1382 /** @copydoc BilinearFilter1BPPByte */
1383 inline Pixel3Bytes BilinearFilterRGB888( Pixel3Bytes tl, Pixel3Bytes tr, Pixel3Bytes bl, Pixel3Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1384 {
1385   Pixel3Bytes pixel;
1386   pixel.r = BilinearFilter1Component( tl.r, tr.r, bl.r, br.r, fractBlendHorizontal, fractBlendVertical );
1387   pixel.g = BilinearFilter1Component( tl.g, tr.g, bl.g, br.g, fractBlendHorizontal, fractBlendVertical );
1388   pixel.b = BilinearFilter1Component( tl.b, tr.b, bl.b, br.b, fractBlendHorizontal, fractBlendVertical );
1389   return pixel;
1390 }
1391
1392 /** @copydoc BilinearFilter1BPPByte */
1393 inline PixelRGB565 BilinearFilterRGB565( PixelRGB565 tl, PixelRGB565 tr, PixelRGB565 bl, PixelRGB565 br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1394 {
1395   const PixelRGB565 pixel = (BilinearFilter1Component( tl >> 11u, tr >> 11u, bl >> 11u, br >> 11u, fractBlendHorizontal, fractBlendVertical ) << 11u) +
1396                             (BilinearFilter1Component( (tl >> 5u) & 63u, (tr >> 5u) & 63u, (bl >> 5u) & 63u, (br >> 5u) & 63u, fractBlendHorizontal, fractBlendVertical ) << 5u) +
1397                              BilinearFilter1Component( tl & 31u, tr & 31u, bl & 31u, br & 31u, fractBlendHorizontal, fractBlendVertical );
1398   return pixel;
1399 }
1400
1401 /** @copydoc BilinearFilter1BPPByte */
1402 inline Pixel4Bytes BilinearFilter4Bytes( Pixel4Bytes tl, Pixel4Bytes tr, Pixel4Bytes bl, Pixel4Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1403 {
1404   Pixel4Bytes pixel;
1405   pixel.r = BilinearFilter1Component( tl.r, tr.r, bl.r, br.r, fractBlendHorizontal, fractBlendVertical );
1406   pixel.g = BilinearFilter1Component( tl.g, tr.g, bl.g, br.g, fractBlendHorizontal, fractBlendVertical );
1407   pixel.b = BilinearFilter1Component( tl.b, tr.b, bl.b, br.b, fractBlendHorizontal, fractBlendVertical );
1408   pixel.a = BilinearFilter1Component( tl.a, tr.a, bl.a, br.a, fractBlendHorizontal, fractBlendVertical );
1409   return pixel;
1410 }
1411
1412 /**
1413  * @brief Generic version of bilinear sampling image resize function.
1414  * @note Limited to one compilation unit and exposed through type-specific
1415  * wrapper functions below.
1416  */
1417 template<
1418   typename PIXEL,
1419   PIXEL (*BilinearFilter) ( PIXEL tl, PIXEL tr, PIXEL bl, PIXEL br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical ),
1420   bool DEBUG_ASSERT_ALIGNMENT
1421 >
1422 inline void LinearSampleGeneric( const unsigned char * __restrict__ inPixels,
1423                        ImageDimensions inputDimensions,
1424                        unsigned char * __restrict__ outPixels,
1425                        ImageDimensions desiredDimensions )
1426 {
1427   const unsigned int inputWidth = inputDimensions.GetWidth();
1428   const unsigned int inputHeight = inputDimensions.GetHeight();
1429   const unsigned int desiredWidth = desiredDimensions.GetWidth();
1430   const unsigned int desiredHeight = desiredDimensions.GetHeight();
1431
1432   DALI_ASSERT_DEBUG( ((outPixels >= inPixels + inputWidth   * inputHeight   * sizeof(PIXEL)) ||
1433                       (inPixels >= outPixels + desiredWidth * desiredHeight * sizeof(PIXEL))) &&
1434                      "Input and output buffers cannot overlap.");
1435   if( DEBUG_ASSERT_ALIGNMENT )
1436   {
1437     DALI_ASSERT_DEBUG( reinterpret_cast< uint64_t >( inPixels )  % sizeof(PIXEL) == 0 && "Pixel pointers need to be aligned to the size of the pixels (E.g., 4 bytes for RGBA, 2 bytes for RGB565, ...)." );
1438     DALI_ASSERT_DEBUG( reinterpret_cast< uint64_t >( outPixels) % sizeof(PIXEL) == 0 && "Pixel pointers need to be aligned to the size of the pixels (E.g., 4 bytes for RGBA, 2 bytes for RGB565, ...)." );
1439   }
1440
1441   if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1442   {
1443     return;
1444   }
1445   const PIXEL* const inAligned = reinterpret_cast<const PIXEL*>(inPixels);
1446   PIXEL* const       outAligned = reinterpret_cast<PIXEL*>(outPixels);
1447   const unsigned int deltaX = (inputWidth  << 16u) / desiredWidth;
1448   const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1449
1450   unsigned int inY = 0;
1451   for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1452   {
1453     PIXEL* const outScanline = &outAligned[desiredWidth * outY];
1454
1455     // Find the two scanlines to blend and the weight to blend with:
1456     const unsigned int integerY1 = inY >> 16u;
1457     const unsigned int integerY2 = integerY1 >= inputHeight ? integerY1 : integerY1 + 1;
1458     const unsigned int inputYWeight = inY & 65535u;
1459
1460     DALI_ASSERT_DEBUG( integerY1 < inputHeight );
1461     DALI_ASSERT_DEBUG( integerY2 < inputHeight );
1462
1463     const PIXEL* const inScanline1 = &inAligned[inputWidth * integerY1];
1464     const PIXEL* const inScanline2 = &inAligned[inputWidth * integerY2];
1465
1466     unsigned int inX = 0;
1467     for( unsigned int outX = 0; outX < desiredWidth; ++outX )
1468     {
1469       // Work out the two pixel scanline offsets for this cluster of four samples:
1470       const unsigned int integerX1 = inX >> 16u;
1471       const unsigned int integerX2 = integerX1 >= inputWidth ? integerX1 : integerX1 + 1;
1472
1473       // Execute the loads:
1474       const PIXEL pixel1 = inScanline1[integerX1];
1475       const PIXEL pixel2 = inScanline2[integerX1];
1476       const PIXEL pixel3 = inScanline1[integerX2];
1477       const PIXEL pixel4 = inScanline2[integerX2];
1478       ///@ToDo Optimise - for 1 and 2  and 4 byte types to execute a single 2, 4, or 8 byte load per pair (caveat clamping) and let half of them be unaligned.
1479
1480       // Weighted bilinear filter:
1481       const unsigned int inputXWeight = inX & 65535u;
1482       outScanline[outX] = BilinearFilter( pixel1, pixel3, pixel2, pixel4, inputXWeight, inputYWeight );
1483
1484       inX += deltaX;
1485     }
1486     inY += deltaY;
1487   }
1488 }
1489
1490 }
1491
1492 // Format-specific linear scaling instantiations:
1493
1494 void LinearSample1BPP( const unsigned char * __restrict__ inPixels,
1495                        ImageDimensions inputDimensions,
1496                        unsigned char * __restrict__ outPixels,
1497                        ImageDimensions desiredDimensions )
1498 {
1499   LinearSampleGeneric<uint8_t, BilinearFilter1BPPByte, false>( inPixels, inputDimensions, outPixels, desiredDimensions );
1500 }
1501
1502 void LinearSample2BPP( const unsigned char * __restrict__ inPixels,
1503                        ImageDimensions inputDimensions,
1504                        unsigned char * __restrict__ outPixels,
1505                        ImageDimensions desiredDimensions )
1506 {
1507   LinearSampleGeneric<Pixel2Bytes, BilinearFilter2Bytes, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1508 }
1509
1510 void LinearSampleRGB565( const unsigned char * __restrict__ inPixels,
1511                        ImageDimensions inputDimensions,
1512                        unsigned char * __restrict__ outPixels,
1513                        ImageDimensions desiredDimensions )
1514 {
1515   LinearSampleGeneric<PixelRGB565, BilinearFilterRGB565, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1516 }
1517
1518 void LinearSample3BPP( const unsigned char * __restrict__ inPixels,
1519                        ImageDimensions inputDimensions,
1520                        unsigned char * __restrict__ outPixels,
1521                        ImageDimensions desiredDimensions )
1522 {
1523   LinearSampleGeneric<Pixel3Bytes, BilinearFilterRGB888, false>( inPixels, inputDimensions, outPixels, desiredDimensions );
1524 }
1525
1526 void LinearSample4BPP( const unsigned char * __restrict__ inPixels,
1527                        ImageDimensions inputDimensions,
1528                        unsigned char * __restrict__ outPixels,
1529                        ImageDimensions desiredDimensions )
1530 {
1531   LinearSampleGeneric<Pixel4Bytes, BilinearFilter4Bytes, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1532 }
1533
1534
1535 void Resample( const unsigned char * __restrict__ inPixels,
1536                ImageDimensions inputDimensions,
1537                unsigned char * __restrict__ outPixels,
1538                ImageDimensions desiredDimensions,
1539                Resampler::Filter filterType,
1540                int numChannels, bool hasAlpha )
1541 {
1542   // Got from the test.cpp of the ImageResampler lib.
1543   const float ONE_DIV_255 = 1.0f / 255.0f;
1544   const int MAX_UNSIGNED_CHAR = std::numeric_limits<uint8_t>::max();
1545   const int LINEAR_TO_SRGB_TABLE_SIZE = 4096;
1546   const int ALPHA_CHANNEL = hasAlpha ? (numChannels-1) : 0;
1547
1548   static bool loadColorSpaces = true;
1549   static float srgbToLinear[MAX_UNSIGNED_CHAR + 1];
1550   static unsigned char linearToSrgb[LINEAR_TO_SRGB_TABLE_SIZE];
1551
1552   if( loadColorSpaces ) // Only create the color space conversions on the first execution
1553   {
1554     loadColorSpaces = false;
1555
1556     for( int i = 0; i <= MAX_UNSIGNED_CHAR; ++i )
1557     {
1558       srgbToLinear[i] = pow( static_cast<float>( i ) * ONE_DIV_255, DEFAULT_SOURCE_GAMMA );
1559     }
1560
1561     const float invLinearToSrgbTableSize = 1.0f / static_cast<float>( LINEAR_TO_SRGB_TABLE_SIZE );
1562     const float invSourceGamma = 1.0f / DEFAULT_SOURCE_GAMMA;
1563
1564     for( int i = 0; i < LINEAR_TO_SRGB_TABLE_SIZE; ++i )
1565     {
1566       int k = static_cast<int>( 255.0f * pow( static_cast<float>( i ) * invLinearToSrgbTableSize, invSourceGamma ) + 0.5f );
1567       if( k < 0 )
1568       {
1569         k = 0;
1570       }
1571       else if( k > MAX_UNSIGNED_CHAR )
1572       {
1573         k = MAX_UNSIGNED_CHAR;
1574       }
1575       linearToSrgb[i] = static_cast<unsigned char>( k );
1576     }
1577   }
1578
1579   Resampler* resamplers[numChannels];
1580   Vector<float> samples[numChannels];
1581
1582   const int srcWidth = inputDimensions.GetWidth();
1583   const int srcHeight = inputDimensions.GetHeight();
1584   const int dstWidth = desiredDimensions.GetWidth();
1585   const int dstHeight = desiredDimensions.GetHeight();
1586
1587   // Now create a Resampler instance for each component to process. The first instance will create new contributor tables, which are shared by the resamplers
1588   // used for the other components (a memory and slight cache efficiency optimization).
1589   resamplers[0] = new Resampler( srcWidth,
1590                                  srcHeight,
1591                                  dstWidth,
1592                                  dstHeight,
1593                                  Resampler::BOUNDARY_CLAMP,
1594                                  0.0f,           // sample_low,
1595                                  1.0f,           // sample_high. Clamp output samples to specified range, or disable clamping if sample_low >= sample_high.
1596                                  filterType,    // The type of filter.
1597                                  NULL,           // Pclist_x,
1598                                  NULL,           // Pclist_y. Optional pointers to contributor lists from another instance of a Resampler.
1599                                  FILTER_SCALE,   // src_x_ofs,
1600                                  FILTER_SCALE ); // src_y_ofs. Offset input image by specified amount (fractional values okay).
1601   samples[0].Resize( srcWidth );
1602   for( int i = 1; i < numChannels; ++i )
1603   {
1604     resamplers[i] = new Resampler( srcWidth,
1605                                    srcHeight,
1606                                    dstWidth,
1607                                    dstHeight,
1608                                    Resampler::BOUNDARY_CLAMP,
1609                                    0.0f,
1610                                    1.0f,
1611                                    filterType,
1612                                    resamplers[0]->get_clist_x(),
1613                                    resamplers[0]->get_clist_y(),
1614                                    FILTER_SCALE,
1615                                    FILTER_SCALE );
1616     samples[i].Resize( srcWidth );
1617   }
1618
1619   const int srcPitch = srcWidth * numChannels;
1620   const int dstPitch = dstWidth * numChannels;
1621   int dstY = 0;
1622
1623   for( int srcY = 0; srcY < srcHeight; ++srcY )
1624   {
1625     const unsigned char* pSrc = &inPixels[srcY * srcPitch];
1626
1627     for( int x = 0; x < srcWidth; ++x )
1628     {
1629       for( int c = 0; c < numChannels; ++c )
1630       {
1631         if( c == ALPHA_CHANNEL && hasAlpha )
1632         {
1633           samples[c][x] = *pSrc++ * ONE_DIV_255;
1634         }
1635         else
1636         {
1637           samples[c][x] = srgbToLinear[*pSrc++];
1638         }
1639       }
1640     }
1641
1642     for( int c = 0; c < numChannels; ++c )
1643     {
1644       if( !resamplers[c]->put_line( &samples[c][0] ) )
1645       {
1646         DALI_ASSERT_DEBUG( !"Out of memory" );
1647       }
1648     }
1649
1650     for(;;)
1651     {
1652       int compIndex;
1653       for( compIndex = 0; compIndex < numChannels; ++compIndex )
1654       {
1655         const float* pOutputSamples = resamplers[compIndex]->get_line();
1656         if( !pOutputSamples )
1657         {
1658           break;
1659         }
1660
1661         const bool isAlphaChannel = ( compIndex == ALPHA_CHANNEL && hasAlpha );
1662         DALI_ASSERT_DEBUG( dstY < dstHeight );
1663         unsigned char* pDst = &outPixels[dstY * dstPitch + compIndex];
1664
1665         for( int x = 0; x < dstWidth; ++x )
1666         {
1667           if( isAlphaChannel )
1668           {
1669             int c = static_cast<int>( 255.0f * pOutputSamples[x] + 0.5f );
1670             if( c < 0 )
1671             {
1672               c = 0;
1673             }
1674             else if( c > MAX_UNSIGNED_CHAR )
1675             {
1676               c = MAX_UNSIGNED_CHAR;
1677             }
1678             *pDst = static_cast<unsigned char>( c );
1679           }
1680           else
1681           {
1682             int j = static_cast<int>( LINEAR_TO_SRGB_TABLE_SIZE * pOutputSamples[x] + 0.5f );
1683             if( j < 0 )
1684             {
1685               j = 0;
1686             }
1687             else if( j >= LINEAR_TO_SRGB_TABLE_SIZE )
1688             {
1689               j = LINEAR_TO_SRGB_TABLE_SIZE - 1;
1690             }
1691             *pDst = linearToSrgb[j];
1692           }
1693
1694           pDst += numChannels;
1695         }
1696       }
1697       if( compIndex < numChannels )
1698       {
1699         break;
1700       }
1701
1702       ++dstY;
1703     }
1704   }
1705
1706   // Delete the resamplers.
1707   for( int i = 0; i < numChannels; ++i )
1708   {
1709     delete resamplers[i];
1710   }
1711 }
1712
1713 void LanczosSample4BPP( const unsigned char * __restrict__ inPixels,
1714                         ImageDimensions inputDimensions,
1715                         unsigned char * __restrict__ outPixels,
1716                         ImageDimensions desiredDimensions )
1717 {
1718   Resample( inPixels, inputDimensions, outPixels, desiredDimensions, Resampler::LANCZOS4, 4, true );
1719 }
1720
1721 void LanczosSample1BPP( const unsigned char * __restrict__ inPixels,
1722                         ImageDimensions inputDimensions,
1723                         unsigned char * __restrict__ outPixels,
1724                         ImageDimensions desiredDimensions )
1725 {
1726   // For L8 images
1727   Resample( inPixels, inputDimensions, outPixels, desiredDimensions, Resampler::LANCZOS4, 1, false );
1728 }
1729
1730 // Dispatch to a format-appropriate linear sampling function:
1731 void LinearSample( const unsigned char * __restrict__ inPixels,
1732                    ImageDimensions inDimensions,
1733                    Pixel::Format pixelFormat,
1734                    unsigned char * __restrict__ outPixels,
1735                    ImageDimensions outDimensions )
1736 {
1737   // Check the pixel format is one that is supported:
1738   if( pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::RGB565 )
1739   {
1740     if( pixelFormat == Pixel::RGB888 )
1741     {
1742       LinearSample3BPP( inPixels, inDimensions, outPixels, outDimensions );
1743     }
1744     else if( pixelFormat == Pixel::RGBA8888 )
1745     {
1746       LinearSample4BPP( inPixels, inDimensions, outPixels, outDimensions );
1747     }
1748     else if( pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1749     {
1750       LinearSample1BPP( inPixels, inDimensions, outPixels, outDimensions );
1751     }
1752     else if( pixelFormat == Pixel::LA88 )
1753     {
1754       LinearSample2BPP( inPixels, inDimensions, outPixels, outDimensions );
1755     }
1756     else if ( pixelFormat == Pixel::RGB565 )
1757     {
1758       LinearSampleRGB565( inPixels, inDimensions, outPixels, outDimensions );
1759     }
1760     else
1761     {
1762       DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1763     }
1764   }
1765   else
1766   {
1767     DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not linear sampled: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1768   }
1769 }
1770
1771 } /* namespace Platform */
1772 } /* namespace Internal */
1773 } /* namespace Dali */