2 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include "image-operations.h"
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 <resampler.h>
29 #include <image-loading.h>
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 );
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.
54 using Integration::Bitmap;
55 using Integration::BitmapPtr;
56 typedef unsigned char PixelBuffer;
59 * @brief 4 byte pixel structure.
67 } __attribute__((packed, aligned(4))); //< Tell the compiler it is okay to use a single 32 bit load.
70 * @brief RGB888 pixel structure.
77 } __attribute__((packed, aligned(1)));
80 * @brief RGB565 pixel typedefed from a short.
82 * Access fields by manual shifting and masking.
84 typedef uint16_t PixelRGB565;
87 * @brief a Pixel composed of two independent byte components.
93 } __attribute__((packed, aligned(2))); //< Tell the compiler it is okay to use a single 16 bit load.
96 #if defined(DEBUG_ENABLED)
98 * Disable logging of image operations or make it verbose from the commandline
99 * as follows (e.g., for dali demo app):
101 * LOG_IMAGE_OPERATIONS=0 dali-demo #< off
102 * LOG_IMAGE_OPERATIONS=3 dali-demo #< on, verbose
105 Debug::Filter* gImageOpsLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_IMAGE_OPERATIONS" );
108 /** @return The greatest even number less than or equal to the argument. */
109 inline unsigned int EvenDown( const unsigned int a )
111 const unsigned int evened = a & ~1u;
116 * @brief Log bad parameters.
118 void ValidateScalingParameters( const unsigned int inputWidth,
119 const unsigned int inputHeight,
120 const unsigned int desiredWidth,
121 const unsigned int desiredHeight )
123 if( desiredWidth > inputWidth || desiredHeight > inputHeight )
125 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Upscaling not supported (%u, %u -> %u, %u).\n", inputWidth, inputHeight, desiredWidth, desiredHeight );
128 if( desiredWidth == 0u || desiredHeight == 0u )
130 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Downscaling to a zero-area target is pointless.\n" );
133 if( inputWidth == 0u || inputHeight == 0u )
135 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Zero area images cannot be scaled\n" );
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.
143 inline void DebugAssertScanlineParameters( const uint8_t * const pixels, const unsigned int width )
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?" );
151 * @brief Assertions on params to functions averaging pairs of scanlines.
152 * @note Inline as intended to boil away in release.
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 )
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." );
167 * @brief Converts a scaling mode to the definition of which dimensions matter when box filtering as a part of that mode.
169 BoxDimensionTest DimensionTestForScalingMode( FittingMode::Type fittingMode )
171 BoxDimensionTest dimensionTest;
172 dimensionTest = BoxDimensionTestEither;
174 switch( fittingMode )
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:
183 dimensionTest = BoxDimensionTestEither;
186 // Scale to fill mode keeps both dimensions at least as large as desired:
187 case FittingMode::SCALE_TO_FILL:
189 dimensionTest = BoxDimensionTestBoth;
192 // Y dimension is irrelevant when downscaling in FIT_WIDTH mode:
193 case FittingMode::FIT_WIDTH:
195 dimensionTest = BoxDimensionTestX;
198 // X Dimension is ignored by definition in FIT_HEIGHT mode:
199 case FittingMode::FIT_HEIGHT:
201 dimensionTest = BoxDimensionTestY;
206 return dimensionTest;
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.
213 ImageDimensions FitForShrinkToFit( ImageDimensions target, ImageDimensions source )
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;
220 // Do no scaling at all if the result would increase area:
226 return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
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.
236 ImageDimensions FitForScaleToFill( ImageDimensions target, ImageDimensions source )
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;
244 // Do no scaling at all if the result would increase area:
250 return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
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.
257 ImageDimensions FitForFitWidth( ImageDimensions target, ImageDimensions source )
259 DALI_ASSERT_DEBUG( source.GetX() > 0 && "Cant fit a zero-dimension rectangle." );
260 const float scale = target.GetX() / float(source.GetX());
262 // Do no scaling at all if the result would increase area:
267 return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
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.
274 ImageDimensions FitForFitHeight( ImageDimensions target, ImageDimensions source )
276 DALI_ASSERT_DEBUG( source.GetY() > 0 && "Cant fit a zero-dimension rectangle." );
277 const float scale = target.GetY() / float(source.GetY());
279 // Do no scaling at all if the result would increase area:
285 return ImageDimensions( source.GetX() * scale + 0.5f, source.GetY() * scale + 0.5f );
289 * @brief Generate the rectangle to use as the target of a pixel sampling pass
290 * (e.g., nearest or linear).
292 ImageDimensions FitToScalingMode( ImageDimensions requestedSize, ImageDimensions sourceSize, FittingMode::Type fittingMode )
294 ImageDimensions fitDimensions;
295 switch( fittingMode )
297 case FittingMode::SHRINK_TO_FIT:
299 fitDimensions = FitForShrinkToFit( requestedSize, sourceSize );
302 case FittingMode::SCALE_TO_FILL:
304 fitDimensions = FitForScaleToFill( requestedSize, sourceSize );
307 case FittingMode::FIT_WIDTH:
309 fitDimensions = FitForFitWidth( requestedSize, sourceSize );
312 case FittingMode::FIT_HEIGHT:
314 fitDimensions = FitForFitHeight( requestedSize, sourceSize );
319 return fitDimensions;
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)
334 void CalculateBordersFromFittingMode( ImageDimensions sourceSize, FittingMode::Type fittingMode, ImageDimensions& requestedSize, int& scanlinesToCrop, int& columnsToCrop )
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() ) );
342 switch( fittingMode )
344 case FittingMode::FIT_WIDTH:
346 finalWidth = sourceWidth;
347 finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
350 scanlinesToCrop = -( finalHeight - sourceHeight );
354 case FittingMode::FIT_HEIGHT:
356 finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
357 finalHeight = sourceHeight;
359 columnsToCrop = -( finalWidth - sourceWidth );
364 case FittingMode::SHRINK_TO_FIT:
366 const float sourceAspect( static_cast< float >( sourceWidth ) / static_cast< float >( sourceHeight ) );
367 if( sourceAspect > targetAspect )
369 finalWidth = sourceWidth;
370 finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
373 scanlinesToCrop = -( finalHeight - sourceHeight );
377 finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
378 finalHeight = sourceHeight;
380 columnsToCrop = -( finalWidth - sourceWidth );
386 case FittingMode::SCALE_TO_FILL:
388 const float sourceAspect( static_cast< float >( sourceWidth ) / static_cast< float >( sourceHeight ) );
389 if( sourceAspect > targetAspect )
391 finalWidth = static_cast< float >( sourceHeight ) * targetAspect;
392 finalHeight = sourceHeight;
394 columnsToCrop = -( finalWidth - sourceWidth );
399 finalWidth = sourceWidth;
400 finalHeight = static_cast< float >( sourceWidth ) / targetAspect;
403 scanlinesToCrop = -( finalHeight - sourceHeight );
409 requestedSize.SetWidth( finalWidth );
410 requestedSize.SetHeight( finalHeight );
414 * @brief Construct a bitmap with format and dimensions requested.
416 BitmapPtr MakeEmptyBitmap( Pixel::Format pixelFormat, unsigned int width, unsigned int height )
418 DALI_ASSERT_DEBUG( Pixel::GetBytesPerPixel(pixelFormat) && "Compressed formats not supported." );
420 // Allocate a pixel buffer to hold the image passed in:
421 Integration::BitmapPtr newBitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
422 newBitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, width, height, width, height );
427 * @brief Construct a bitmap object from a copy of the pixel array passed in.
429 BitmapPtr MakeBitmap( const uint8_t * const pixels, Pixel::Format pixelFormat, unsigned int width, unsigned int height )
431 DALI_ASSERT_DEBUG( pixels && "Null bitmap buffer to copy." );
433 // Allocate a pixel buffer to hold the image passed in:
434 Integration::BitmapPtr newBitmap = MakeEmptyBitmap( pixelFormat, width, height );
436 // Copy over the pixels from the downscaled image that was generated in-place in the pixel buffer of the input bitmap:
437 memcpy( newBitmap->GetBuffer(), pixels, width * height * Pixel::GetBytesPerPixel( pixelFormat ) );
442 * @brief Work out the desired width and height, accounting for zeros.
444 * @param[in] bitmapWidth Width of image before processing.
445 * @param[in] bitmapHeight Height of image before processing.
446 * @param[in] requestedWidth Width of area to scale image into. Can be zero.
447 * @param[in] requestedHeight Height of area to scale image into. Can be zero.
448 * @return Dimensions of area to scale image into after special rules are applied.
450 ImageDimensions CalculateDesiredDimensions( unsigned int bitmapWidth, unsigned int bitmapHeight, unsigned int requestedWidth, unsigned int requestedHeight )
452 unsigned int maxSize = Dali::GetMaxTextureSize();
454 // If no dimensions have been requested, default to the source ones:
455 if( requestedWidth == 0 && requestedHeight == 0 )
457 if( bitmapWidth <= maxSize && bitmapHeight <= maxSize )
459 return ImageDimensions( bitmapWidth, bitmapHeight );
463 // Calculate the size from the max texture size and the source image aspect ratio
464 if( bitmapWidth > bitmapHeight )
466 return ImageDimensions( maxSize, bitmapHeight * maxSize / static_cast< float >( bitmapWidth ) + 0.5f );
470 return ImageDimensions( bitmapWidth * maxSize / static_cast< float >( bitmapHeight ) + 0.5f, maxSize );
475 // If both dimensions have values requested, use them both:
476 if( requestedWidth != 0 && requestedHeight != 0 )
478 if( requestedWidth <= maxSize && requestedWidth <= maxSize )
480 return ImageDimensions( requestedWidth, requestedHeight );
484 // Calculate the size from the max texture size and the source image aspect ratio
485 if( requestedWidth > requestedHeight )
487 return ImageDimensions( maxSize, requestedHeight * maxSize / static_cast< float >( requestedWidth ) + 0.5f );
491 return ImageDimensions( requestedWidth * maxSize / static_cast< float >( requestedHeight ) + 0.5f, maxSize );
496 // Only one of the dimensions has been requested. Calculate the other from
497 // the requested one and the source image aspect ratio:
498 if( requestedWidth != 0 )
500 requestedWidth = std::min( requestedWidth, maxSize );
501 return ImageDimensions( requestedWidth, bitmapHeight / float(bitmapWidth) * requestedWidth + 0.5f );
504 requestedHeight = std::min( requestedHeight, maxSize );
505 return ImageDimensions( bitmapWidth / float(bitmapHeight) * requestedHeight + 0.5f, requestedHeight );
508 } // namespace - unnamed
510 ImageDimensions CalculateDesiredDimensions( ImageDimensions rawDimensions, ImageDimensions requestedDimensions )
512 return CalculateDesiredDimensions( rawDimensions.GetWidth(), rawDimensions.GetHeight(), requestedDimensions.GetWidth(), requestedDimensions.GetHeight() ) ;
516 * @brief Apply cropping and padding for specified fitting mode.
518 * Once the bitmap has been (optionally) downscaled to an appropriate size, this method performs alterations
519 * based on the fitting mode.
521 * This will add vertical or horizontal borders if necessary.
522 * Crop the source image data vertically or horizontally if necessary.
523 * The aspect of the source image is preserved.
524 * If the source image is smaller than the desired size, the algorithm will modify the the newly created
525 * bitmaps dimensions to only be as large as necessary, as a memory saving optimization. This will cause
526 * GPU scaling to be performed at render time giving the same result with less texture traversal.
528 * @param[in] bitmap The source bitmap to perform modifications on.
529 * @param[in] desiredDimensions The target dimensions to aim to fill based on the fitting mode.
530 * @param[in] fittingMode The fitting mode to use.
532 * @return A new bitmap with the padding and cropping required for fitting mode applied.
533 * If no modification is needed or possible, the passed in bitmap is returned.
535 Integration::BitmapPtr CropAndPadForFittingMode( Integration::BitmapPtr bitmap, ImageDimensions desiredDimensions, FittingMode::Type fittingMode );
538 * @brief Adds horizontal or vertical borders to the source image.
540 * @param[in] targetPixels The destination image pointer to draw the borders on.
541 * @param[in] bytesPerPixel The number of bytes per pixel of the target pixel buffer.
542 * @param[in] targetDimensions The dimensions of the destination image.
543 * @param[in] padDimensions The columns and scanlines to pad with borders.
545 void AddBorders( PixelBuffer *targetPixels, const unsigned int bytesPerPixel, const ImageDimensions targetDimensions, const ImageDimensions padDimensions );
547 BitmapPtr ApplyAttributesToBitmap( BitmapPtr bitmap, ImageDimensions dimensions, FittingMode::Type fittingMode, SamplingMode::Type samplingMode )
551 // Calculate the desired box, accounting for a possible zero component:
552 const ImageDimensions desiredDimensions = CalculateDesiredDimensions( bitmap->GetImageWidth(), bitmap->GetImageHeight(), dimensions.GetWidth(), dimensions.GetHeight() );
554 // If a different size than the raw one has been requested, resize the image
555 // maximally using a repeated box filter without making it smaller than the
556 // requested size in either dimension:
557 bitmap = DownscaleBitmap( *bitmap, desiredDimensions, fittingMode, samplingMode );
559 // Cut the bitmap according to the desired width and height so that the
560 // resulting bitmap has the same aspect ratio as the desired dimensions.
561 // Add crop and add borders if necessary depending on fitting mode.
562 if( bitmap && bitmap->GetPackedPixelsProfile() )
564 bitmap = CropAndPadForFittingMode( bitmap, desiredDimensions, fittingMode );
567 // Examine the image pixels remaining after cropping and scaling to see if all
568 // are opaque, allowing faster rendering, or some have non-1.0 alpha:
569 if( bitmap && bitmap->GetPackedPixelsProfile() && Pixel::HasAlpha( bitmap->GetPixelFormat() ) )
571 bitmap->GetPackedPixelsProfile()->TestForTransparency();
578 BitmapPtr CropAndPadForFittingMode( BitmapPtr bitmap, ImageDimensions desiredDimensions, FittingMode::Type fittingMode )
580 const unsigned int inputWidth = bitmap->GetImageWidth();
581 const unsigned int inputHeight = bitmap->GetImageHeight();
583 if( desiredDimensions.GetWidth() < 1u || desiredDimensions.GetHeight() < 1u )
585 DALI_LOG_WARNING( "Image scaling aborted as desired dimensions too small (%u, %u).\n", desiredDimensions.GetWidth(), desiredDimensions.GetHeight() );
587 else if( inputWidth != desiredDimensions.GetWidth() || inputHeight != desiredDimensions.GetHeight() )
589 // Calculate any padding or cropping that needs to be done based on the fitting mode.
590 // Note: If the desired size is larger than the original image, the desired size will be
591 // reduced while maintaining the aspect, in order to save unnecessary memory usage.
592 int scanlinesToCrop = 0;
593 int columnsToCrop = 0;
595 CalculateBordersFromFittingMode( ImageDimensions( inputWidth, inputHeight ), fittingMode, desiredDimensions, scanlinesToCrop, columnsToCrop );
597 unsigned int desiredWidth( desiredDimensions.GetWidth() );
598 unsigned int desiredHeight( desiredDimensions.GetHeight() );
600 // Action the changes by making a new bitmap with the central part of the loaded one if required.
601 if( scanlinesToCrop != 0 || columnsToCrop != 0 )
603 // Split the adding and removing of scanlines and columns into separate variables,
604 // so we can use one piece of generic code to action the changes.
605 unsigned int scanlinesToPad = 0;
606 unsigned int columnsToPad = 0;
607 if( scanlinesToCrop < 0 )
609 scanlinesToPad = -scanlinesToCrop;
612 if( columnsToCrop < 0 )
614 columnsToPad = -columnsToCrop;
618 // If there is no filtering, then the final image size can become very large, exit if larger than maximum.
619 if( ( desiredWidth > MAXIMUM_TARGET_BITMAP_SIZE ) || ( desiredHeight > MAXIMUM_TARGET_BITMAP_SIZE ) ||
620 ( columnsToPad > MAXIMUM_TARGET_BITMAP_SIZE ) || ( scanlinesToPad > MAXIMUM_TARGET_BITMAP_SIZE ) )
622 DALI_LOG_WARNING( "Image scaling aborted as final dimensions too large (%u, %u).\n", desiredWidth, desiredHeight );
626 // Create a new bitmap with the desired size.
627 BitmapPtr croppedBitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
628 Integration::Bitmap::PackedPixelsProfile *packedView = croppedBitmap->GetPackedPixelsProfile();
629 DALI_ASSERT_DEBUG( packedView );
630 const Pixel::Format pixelFormat = bitmap->GetPixelFormat();
631 packedView->ReserveBuffer( pixelFormat, desiredWidth, desiredHeight, desiredWidth, desiredHeight );
633 // Add some pre-calculated offsets to the bitmap pointers so this is not done within a loop.
634 // The cropping is added to the source pointer, and the padding is added to the destination.
635 const unsigned int bytesPerPixel = Pixel::GetBytesPerPixel( pixelFormat );
636 const PixelBuffer * const sourcePixels = bitmap->GetBuffer() + ( ( ( ( scanlinesToCrop / 2 ) * inputWidth ) + ( columnsToCrop / 2 ) ) * bytesPerPixel );
637 PixelBuffer * const targetPixels = croppedBitmap->GetBuffer();
638 PixelBuffer * const targetPixelsActive = targetPixels + ( ( ( ( scanlinesToPad / 2 ) * desiredWidth ) + ( columnsToPad / 2 ) ) * bytesPerPixel );
639 DALI_ASSERT_DEBUG( sourcePixels && targetPixels );
641 // Copy the image data to the new bitmap.
642 // Optimize to a single memcpy if the left and right edges don't need a crop or a pad.
643 unsigned int outputSpan( desiredWidth * bytesPerPixel );
644 if( columnsToCrop == 0 && columnsToPad == 0 )
646 memcpy( targetPixelsActive, sourcePixels, ( desiredHeight - scanlinesToPad ) * outputSpan );
650 // The width needs to change (due to either a crop or a pad), so we copy a scanline at a time.
651 // Precalculate any constants to optimize the inner loop.
652 const unsigned int inputSpan( inputWidth * bytesPerPixel );
653 const unsigned int copySpan( ( desiredWidth - columnsToPad ) * bytesPerPixel );
654 const unsigned int scanlinesToCopy( desiredHeight - scanlinesToPad );
656 for( unsigned int y = 0; y < scanlinesToCopy; ++y )
658 memcpy( &targetPixelsActive[ y * outputSpan ], &sourcePixels[ y * inputSpan ], copySpan );
662 // Add vertical or horizontal borders to the final image (if required).
663 desiredDimensions.SetWidth( desiredWidth );
664 desiredDimensions.SetHeight( desiredHeight );
665 AddBorders( croppedBitmap->GetBuffer(), bytesPerPixel, desiredDimensions, ImageDimensions( columnsToPad, scanlinesToPad ) );
666 // Overwrite the loaded bitmap with the cropped version
667 bitmap = croppedBitmap;
674 void AddBorders( PixelBuffer *targetPixels, const unsigned int bytesPerPixel, const ImageDimensions targetDimensions, const ImageDimensions padDimensions )
676 // Assign ints for faster access.
677 unsigned int desiredWidth( targetDimensions.GetWidth() );
678 unsigned int desiredHeight( targetDimensions.GetHeight() );
679 unsigned int columnsToPad( padDimensions.GetWidth() );
680 unsigned int scanlinesToPad( padDimensions.GetHeight() );
681 unsigned int outputSpan( desiredWidth * bytesPerPixel );
683 // Add letterboxing (symmetrical borders) if needed.
684 if( scanlinesToPad > 0 )
686 // Add a top border. Note: This is (deliberately) rounded down if padding is an odd number.
687 memset( targetPixels, BORDER_FILL_VALUE, ( scanlinesToPad / 2 ) * outputSpan );
689 // We subtract scanlinesToPad/2 from scanlinesToPad so that we have the correct
690 // offset for odd numbers (as the top border is 1 pixel smaller in these cases.
691 unsigned int bottomBorderHeight = scanlinesToPad - ( scanlinesToPad / 2 );
694 memset( &targetPixels[ ( desiredHeight - bottomBorderHeight ) * outputSpan ], BORDER_FILL_VALUE, bottomBorderHeight * outputSpan );
696 else if( columnsToPad > 0 )
698 // Add a left and right border.
700 // Pre-calculate span size outside of loop.
701 unsigned int leftBorderSpanWidth( ( columnsToPad / 2 ) * bytesPerPixel );
702 for( unsigned int y = 0; y < desiredHeight; ++y )
704 memset( &targetPixels[ y * outputSpan ], BORDER_FILL_VALUE, leftBorderSpanWidth );
708 // Pre-calculate the initial x offset as it is always the same for a small optimization.
709 // We subtract columnsToPad/2 from columnsToPad so that we have the correct
710 // offset for odd numbers (as the left border is 1 pixel smaller in these cases.
711 unsigned int rightBorderWidth = columnsToPad - ( columnsToPad / 2 );
712 PixelBuffer * const destPixelsRightBorder( targetPixels + ( ( desiredWidth - rightBorderWidth ) * bytesPerPixel ) );
713 unsigned int rightBorderSpanWidth = rightBorderWidth * bytesPerPixel;
715 for( unsigned int y = 0; y < desiredHeight; ++y )
717 memset( &destPixelsRightBorder[ y * outputSpan ], BORDER_FILL_VALUE, rightBorderSpanWidth );
722 Integration::BitmapPtr DownscaleBitmap( Integration::Bitmap& bitmap,
723 ImageDimensions desired,
724 FittingMode::Type fittingMode,
725 SamplingMode::Type samplingMode )
727 // Source dimensions as loaded from resources (e.g. filesystem):
728 const unsigned int bitmapWidth = bitmap.GetImageWidth();
729 const unsigned int bitmapHeight = bitmap.GetImageHeight();
730 // Desired dimensions (the rectangle to fit the source image to):
731 const unsigned int desiredWidth = desired.GetWidth();
732 const unsigned int desiredHeight = desired.GetHeight();
734 BitmapPtr outputBitmap( &bitmap );
736 // If a different size than the raw one has been requested, resize the image:
737 if( bitmap.GetPackedPixelsProfile() &&
738 (desiredWidth > 0.0f) && (desiredHeight > 0.0f) &&
739 ((desiredWidth < bitmapWidth) || (desiredHeight < bitmapHeight)) )
741 const Pixel::Format pixelFormat = bitmap.GetPixelFormat();
743 // Do the fast power of 2 iterated box filter to get to roughly the right side if the filter mode requests that:
744 unsigned int shrunkWidth = -1, shrunkHeight = -1;
745 DownscaleInPlacePow2( bitmap.GetBuffer(), pixelFormat, bitmapWidth, bitmapHeight, desiredWidth, desiredHeight, fittingMode, samplingMode, shrunkWidth, shrunkHeight );
747 // Work out the dimensions of the downscaled bitmap, given the scaling mode and desired dimensions:
748 const ImageDimensions filteredDimensions = FitToScalingMode( ImageDimensions( desiredWidth, desiredHeight ), ImageDimensions( shrunkWidth, shrunkHeight ), fittingMode );
749 const unsigned int filteredWidth = filteredDimensions.GetWidth();
750 const unsigned int filteredHeight = filteredDimensions.GetHeight();
752 // Run a filter to scale down the bitmap if it needs it:
753 bool filtered = false;
754 if( filteredWidth < shrunkWidth || filteredHeight < shrunkHeight )
756 if( samplingMode == SamplingMode::LINEAR || samplingMode == SamplingMode::BOX_THEN_LINEAR ||
757 samplingMode == SamplingMode::NEAREST || samplingMode == SamplingMode::BOX_THEN_NEAREST )
759 outputBitmap = MakeEmptyBitmap( pixelFormat, filteredWidth, filteredHeight );
762 if( samplingMode == SamplingMode::LINEAR || samplingMode == SamplingMode::BOX_THEN_LINEAR )
764 LinearSample( bitmap.GetBuffer(), ImageDimensions(shrunkWidth, shrunkHeight), pixelFormat, outputBitmap->GetBuffer(), filteredDimensions );
768 PointSample( bitmap.GetBuffer(), shrunkWidth, shrunkHeight, pixelFormat, outputBitmap->GetBuffer(), filteredWidth, filteredHeight );
774 // Copy out the 2^x downscaled, box-filtered pixels if no secondary filter (point or linear) was applied:
775 if( filtered == false && ( shrunkWidth < bitmapWidth || shrunkHeight < bitmapHeight ) )
777 outputBitmap = MakeBitmap( bitmap.GetBuffer(), pixelFormat, shrunkWidth, shrunkHeight );
787 * @brief Returns whether to keep box filtering based on whether downscaled dimensions will overshoot the desired ones aty the next step.
788 * @param test Which combination of the two dimensions matter for terminating the filtering.
789 * @param scaledWidth The width of the current downscaled image.
790 * @param scaledHeight The height of the current downscaled image.
791 * @param desiredWidth The target width for the downscaling.
792 * @param desiredHeight The target height for the downscaling.
794 bool ContinueScaling( BoxDimensionTest test, unsigned int scaledWidth, unsigned int scaledHeight, unsigned int desiredWidth, unsigned int desiredHeight )
796 bool keepScaling = false;
797 const unsigned int nextWidth = scaledWidth >> 1u;
798 const unsigned int nextHeight = scaledHeight >> 1u;
800 if( nextWidth >= 1u && nextHeight >= 1u )
804 case BoxDimensionTestEither:
806 keepScaling = nextWidth >= desiredWidth || nextHeight >= desiredHeight;
809 case BoxDimensionTestBoth:
811 keepScaling = nextWidth >= desiredWidth && nextHeight >= desiredHeight;
814 case BoxDimensionTestX:
816 keepScaling = nextWidth >= desiredWidth;
819 case BoxDimensionTestY:
821 keepScaling = nextHeight >= desiredHeight;
831 * @brief A shared implementation of the overall iterative box filter
832 * downscaling algorithm.
834 * Specialise this for particular pixel formats by supplying the number of bytes
835 * per pixel and two functions: one for averaging pairs of neighbouring pixels
836 * on a single scanline, and a second for averaging pixels at corresponding
837 * positions on different scanlines.
841 void (*HalveScanlineInPlace)( unsigned char * const pixels, const unsigned int width ),
842 void (*AverageScanlines) ( const unsigned char * const scanline1, const unsigned char * const __restrict__ scanline2, unsigned char* const outputScanline, const unsigned int width )
844 void DownscaleInPlacePow2Generic( unsigned char * const pixels,
845 const unsigned int inputWidth,
846 const unsigned int inputHeight,
847 const unsigned int desiredWidth,
848 const unsigned int desiredHeight,
849 BoxDimensionTest dimensionTest,
851 unsigned& outHeight )
857 ValidateScalingParameters( inputWidth, inputHeight, desiredWidth, desiredHeight );
859 // Scale the image until it would be smaller than desired, stopping if the
860 // resulting height or width would be less than 1:
861 unsigned int scaledWidth = inputWidth, scaledHeight = inputHeight;
862 while( ContinueScaling( dimensionTest, scaledWidth, scaledHeight, desiredWidth, desiredHeight ) )
864 const unsigned int lastWidth = scaledWidth;
868 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Scaling to %u\t%u.\n", scaledWidth, scaledHeight );
870 const unsigned int lastScanlinePair = scaledHeight - 1;
872 // Scale pairs of scanlines until any spare one at the end is dropped:
873 for( unsigned int y = 0; y <= lastScanlinePair; ++y )
875 // Scale two scanlines horizontally:
876 HalveScanlineInPlace( &pixels[y * 2 * lastWidth * BYTES_PER_PIXEL], lastWidth );
877 HalveScanlineInPlace( &pixels[(y * 2 + 1) * lastWidth * BYTES_PER_PIXEL], lastWidth );
879 // Scale vertical pairs of pixels while the last two scanlines are still warm in
881 // Note, better access patterns for cache-coherence are possible for very large
882 // images but even a 4k wide RGB888 image will use just 24kB of cache (4k pixels
883 // * 3 Bpp * 2 scanlines) for two scanlines on the first iteration.
885 &pixels[y * 2 * lastWidth * BYTES_PER_PIXEL],
886 &pixels[(y * 2 + 1) * lastWidth * BYTES_PER_PIXEL],
887 &pixels[y * scaledWidth * BYTES_PER_PIXEL],
892 ///@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.
893 outWidth = scaledWidth;
894 outHeight = scaledHeight;
899 void HalveScanlineInPlaceRGB888( unsigned char * const pixels, const unsigned int width )
901 DebugAssertScanlineParameters( pixels, width );
903 const unsigned int lastPair = EvenDown( width - 2 );
905 for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
907 // Load all the byte pixel components we need:
908 const unsigned int c11 = pixels[pixel * 3];
909 const unsigned int c12 = pixels[pixel * 3 + 1];
910 const unsigned int c13 = pixels[pixel * 3 + 2];
911 const unsigned int c21 = pixels[pixel * 3 + 3];
912 const unsigned int c22 = pixels[pixel * 3 + 4];
913 const unsigned int c23 = pixels[pixel * 3 + 5];
915 // Save the averaged byte pixel components:
916 pixels[outPixel * 3] = AverageComponent( c11, c21 );
917 pixels[outPixel * 3 + 1] = AverageComponent( c12, c22 );
918 pixels[outPixel * 3 + 2] = AverageComponent( c13, c23 );
922 void HalveScanlineInPlaceRGBA8888( unsigned char * const pixels, const unsigned int width )
924 DebugAssertScanlineParameters( pixels, width );
925 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
927 uint32_t* const alignedPixels = reinterpret_cast<uint32_t*>(pixels);
929 const unsigned int lastPair = EvenDown( width - 2 );
931 for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
933 const uint32_t averaged = AveragePixelRGBA8888( alignedPixels[pixel], alignedPixels[pixel + 1] );
934 alignedPixels[outPixel] = averaged;
938 void HalveScanlineInPlaceRGB565( unsigned char * pixels, unsigned int width )
940 DebugAssertScanlineParameters( pixels, width );
941 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
943 uint16_t* const alignedPixels = reinterpret_cast<uint16_t*>(pixels);
945 const unsigned int lastPair = EvenDown( width - 2 );
947 for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
949 const uint32_t averaged = AveragePixelRGB565( alignedPixels[pixel], alignedPixels[pixel + 1] );
950 alignedPixels[outPixel] = averaged;
954 void HalveScanlineInPlace2Bytes( unsigned char * const pixels, const unsigned int width )
956 DebugAssertScanlineParameters( pixels, width );
958 const unsigned int lastPair = EvenDown( width - 2 );
960 for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
962 // Load all the byte pixel components we need:
963 const unsigned int c11 = pixels[pixel * 2];
964 const unsigned int c12 = pixels[pixel * 2 + 1];
965 const unsigned int c21 = pixels[pixel * 2 + 2];
966 const unsigned int c22 = pixels[pixel * 2 + 3];
968 // Save the averaged byte pixel components:
969 pixels[outPixel * 2] = AverageComponent( c11, c21 );
970 pixels[outPixel * 2 + 1] = AverageComponent( c12, c22 );
974 void HalveScanlineInPlace1Byte( unsigned char * const pixels, const unsigned int width )
976 DebugAssertScanlineParameters( pixels, width );
978 const unsigned int lastPair = EvenDown( width - 2 );
980 for( unsigned int pixel = 0, outPixel = 0; pixel <= lastPair; pixel += 2, ++outPixel )
982 // Load all the byte pixel components we need:
983 const unsigned int c1 = pixels[pixel];
984 const unsigned int c2 = pixels[pixel + 1];
986 // Save the averaged byte pixel component:
987 pixels[outPixel] = AverageComponent( c1, c2 );
992 * @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.
993 * 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.
995 void AverageScanlines1( const unsigned char * const scanline1,
996 const unsigned char * const __restrict__ scanline2,
997 unsigned char* const outputScanline,
998 const unsigned int width )
1000 DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width );
1002 for( unsigned int component = 0; component < width; ++component )
1004 outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
1008 void AverageScanlines2( const unsigned char * const scanline1,
1009 const unsigned char * const __restrict__ scanline2,
1010 unsigned char* const outputScanline,
1011 const unsigned int width )
1013 DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 2 );
1015 for( unsigned int component = 0; component < width * 2; ++component )
1017 outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
1021 void AverageScanlines3( const unsigned char * const scanline1,
1022 const unsigned char * const __restrict__ scanline2,
1023 unsigned char* const outputScanline,
1024 const unsigned int width )
1026 DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 3 );
1028 for( unsigned int component = 0; component < width * 3; ++component )
1030 outputScanline[component] = AverageComponent( scanline1[component], scanline2[component] );
1034 void AverageScanlinesRGBA8888( const unsigned char * const scanline1,
1035 const unsigned char * const __restrict__ scanline2,
1036 unsigned char * const outputScanline,
1037 const unsigned int width )
1039 DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 4 );
1040 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline1) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1041 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline2) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1042 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(outputScanline) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1044 const uint32_t* const alignedScanline1 = reinterpret_cast<const uint32_t*>(scanline1);
1045 const uint32_t* const alignedScanline2 = reinterpret_cast<const uint32_t*>(scanline2);
1046 uint32_t* const alignedOutput = reinterpret_cast<uint32_t*>(outputScanline);
1048 for( unsigned int pixel = 0; pixel < width; ++pixel )
1050 alignedOutput[pixel] = AveragePixelRGBA8888( alignedScanline1[pixel], alignedScanline2[pixel] );
1054 void AverageScanlinesRGB565( const unsigned char * const scanline1,
1055 const unsigned char * const __restrict__ scanline2,
1056 unsigned char * const outputScanline,
1057 const unsigned int width )
1059 DebugAssertDualScanlineParameters( scanline1, scanline2, outputScanline, width * 2 );
1060 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline1) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1061 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(scanline2) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1062 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(outputScanline) & 1u) == 0u) && "Pointer should be 2-byte aligned for performance on some platforms." );
1064 const uint16_t* const alignedScanline1 = reinterpret_cast<const uint16_t*>(scanline1);
1065 const uint16_t* const alignedScanline2 = reinterpret_cast<const uint16_t*>(scanline2);
1066 uint16_t* const alignedOutput = reinterpret_cast<uint16_t*>(outputScanline);
1068 for( unsigned int pixel = 0; pixel < width; ++pixel )
1070 alignedOutput[pixel] = AveragePixelRGB565( alignedScanline1[pixel], alignedScanline2[pixel] );
1074 /// Dispatch to pixel format appropriate box filter downscaling functions.
1075 void DownscaleInPlacePow2( unsigned char * const pixels,
1076 Pixel::Format pixelFormat,
1077 unsigned int inputWidth,
1078 unsigned int inputHeight,
1079 unsigned int desiredWidth,
1080 unsigned int desiredHeight,
1081 FittingMode::Type fittingMode,
1082 SamplingMode::Type samplingMode,
1084 unsigned& outHeight )
1086 outWidth = inputWidth;
1087 outHeight = inputHeight;
1088 // Perform power of 2 iterated 4:1 box filtering if the requested filter mode requires it:
1089 if( samplingMode == SamplingMode::BOX || samplingMode == SamplingMode::BOX_THEN_NEAREST || samplingMode == SamplingMode::BOX_THEN_LINEAR )
1091 // Check the pixel format is one that is supported:
1092 if( pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1094 const BoxDimensionTest dimensionTest = DimensionTestForScalingMode( fittingMode );
1096 if( pixelFormat == Pixel::RGBA8888 )
1098 Internal::Platform::DownscaleInPlacePow2RGBA8888( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1100 else if( pixelFormat == Pixel::RGB888 )
1102 Internal::Platform::DownscaleInPlacePow2RGB888( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1104 else if( pixelFormat == Pixel::RGB565 )
1106 Internal::Platform::DownscaleInPlacePow2RGB565( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1108 else if( pixelFormat == Pixel::LA88 )
1110 Internal::Platform::DownscaleInPlacePow2ComponentPair( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1112 else if( pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1114 Internal::Platform::DownscaleInPlacePow2SingleBytePerPixel( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1118 DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1124 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not shrunk: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1128 void DownscaleInPlacePow2RGB888( unsigned char *pixels,
1129 unsigned int inputWidth,
1130 unsigned int inputHeight,
1131 unsigned int desiredWidth,
1132 unsigned int desiredHeight,
1133 BoxDimensionTest dimensionTest,
1135 unsigned& outHeight )
1137 DownscaleInPlacePow2Generic<3, HalveScanlineInPlaceRGB888, AverageScanlines3>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1140 void DownscaleInPlacePow2RGBA8888( unsigned char * pixels,
1141 unsigned int inputWidth,
1142 unsigned int inputHeight,
1143 unsigned int desiredWidth,
1144 unsigned int desiredHeight,
1145 BoxDimensionTest dimensionTest,
1147 unsigned& outHeight )
1149 DALI_ASSERT_DEBUG( ((reinterpret_cast<ptrdiff_t>(pixels) & 3u) == 0u) && "Pointer should be 4-byte aligned for performance on some platforms." );
1150 DownscaleInPlacePow2Generic<4, HalveScanlineInPlaceRGBA8888, AverageScanlinesRGBA8888>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1153 void DownscaleInPlacePow2RGB565( unsigned char * pixels,
1154 unsigned int inputWidth,
1155 unsigned int inputHeight,
1156 unsigned int desiredWidth,
1157 unsigned int desiredHeight,
1158 BoxDimensionTest dimensionTest,
1159 unsigned int& outWidth,
1160 unsigned int& outHeight )
1162 DownscaleInPlacePow2Generic<2, HalveScanlineInPlaceRGB565, AverageScanlinesRGB565>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1166 * @copydoc DownscaleInPlacePow2RGB888
1168 * For 2-byte formats such as lum8alpha8, but not packed 16 bit formats like RGB565.
1170 void DownscaleInPlacePow2ComponentPair( unsigned char *pixels,
1171 unsigned int inputWidth,
1172 unsigned int inputHeight,
1173 unsigned int desiredWidth,
1174 unsigned int desiredHeight,
1175 BoxDimensionTest dimensionTest,
1177 unsigned& outHeight )
1179 DownscaleInPlacePow2Generic<2, HalveScanlineInPlace2Bytes, AverageScanlines2>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1182 void DownscaleInPlacePow2SingleBytePerPixel( unsigned char * pixels,
1183 unsigned int inputWidth,
1184 unsigned int inputHeight,
1185 unsigned int desiredWidth,
1186 unsigned int desiredHeight,
1187 BoxDimensionTest dimensionTest,
1188 unsigned int& outWidth,
1189 unsigned int& outHeight )
1191 DownscaleInPlacePow2Generic<1, HalveScanlineInPlace1Byte, AverageScanlines1>( pixels, inputWidth, inputHeight, desiredWidth, desiredHeight, dimensionTest, outWidth, outHeight );
1198 * @brief Point sample an image to a new resolution (like GL_NEAREST).
1200 * Template is used purely as a type-safe code generator in this one
1201 * compilation unit. Generated code is inlined into type-specific wrapper
1202 * functions below which are exported to rest of module.
1204 template<typename PIXEL>
1205 inline void PointSampleAddressablePixels( const uint8_t * inPixels,
1206 unsigned int inputWidth,
1207 unsigned int inputHeight,
1208 uint8_t * outPixels,
1209 unsigned int desiredWidth,
1210 unsigned int desiredHeight )
1212 DALI_ASSERT_DEBUG( ((desiredWidth <= inputWidth && desiredHeight <= inputHeight) ||
1213 outPixels >= inPixels + inputWidth * inputHeight * sizeof(PIXEL) || outPixels <= inPixels - desiredWidth * desiredHeight * sizeof(PIXEL)) &&
1214 "The input and output buffers must not overlap for an upscaling.");
1215 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, ...)." );
1216 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, ...)." );
1218 if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1222 const PIXEL* const inAligned = reinterpret_cast<const PIXEL*>(inPixels);
1223 PIXEL* const outAligned = reinterpret_cast<PIXEL*>(outPixels);
1224 const unsigned int deltaX = (inputWidth << 16u) / desiredWidth;
1225 const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1227 unsigned int inY = 0;
1228 for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1230 // Round fixed point y coordinate to nearest integer:
1231 const unsigned int integerY = (inY + (1u << 15u)) >> 16u;
1232 const PIXEL* const inScanline = &inAligned[inputWidth * integerY];
1233 PIXEL* const outScanline = &outAligned[desiredWidth * outY];
1235 DALI_ASSERT_DEBUG( integerY < inputHeight );
1236 DALI_ASSERT_DEBUG( reinterpret_cast<const uint8_t*>(inScanline) < ( inPixels + inputWidth * inputHeight * sizeof(PIXEL) ) );
1237 DALI_ASSERT_DEBUG( reinterpret_cast<uint8_t*>(outScanline) < ( outPixels + desiredWidth * desiredHeight * sizeof(PIXEL) ) );
1239 unsigned int inX = 0;
1240 for( unsigned int outX = 0; outX < desiredWidth; ++outX )
1242 // Round the fixed-point x coordinate to an integer:
1243 const unsigned int integerX = (inX + (1u << 15u)) >> 16u;
1244 const PIXEL* const inPixelAddress = &inScanline[integerX];
1245 const PIXEL pixel = *inPixelAddress;
1246 outScanline[outX] = pixel;
1256 void PointSample4BPP( const unsigned char * inPixels,
1257 unsigned int inputWidth,
1258 unsigned int inputHeight,
1259 unsigned char * outPixels,
1260 unsigned int desiredWidth,
1261 unsigned int desiredHeight )
1263 PointSampleAddressablePixels<uint32_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1267 void PointSample2BPP( const unsigned char * inPixels,
1268 unsigned int inputWidth,
1269 unsigned int inputHeight,
1270 unsigned char * outPixels,
1271 unsigned int desiredWidth,
1272 unsigned int desiredHeight )
1274 PointSampleAddressablePixels<uint16_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1278 void PointSample1BPP( const unsigned char * inPixels,
1279 unsigned int inputWidth,
1280 unsigned int inputHeight,
1281 unsigned char * outPixels,
1282 unsigned int desiredWidth,
1283 unsigned int desiredHeight )
1285 PointSampleAddressablePixels<uint8_t>( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1289 * RGB888 is a special case as its pixels are not aligned addressable units.
1291 void PointSample3BPP( const uint8_t * inPixels,
1292 unsigned int inputWidth,
1293 unsigned int inputHeight,
1294 uint8_t * outPixels,
1295 unsigned int desiredWidth,
1296 unsigned int desiredHeight )
1298 if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1302 const unsigned int BYTES_PER_PIXEL = 3;
1304 // Generate fixed-point 16.16 deltas in input image coordinates:
1305 const unsigned int deltaX = (inputWidth << 16u) / desiredWidth;
1306 const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1308 // Step through output image in whole integer pixel steps while tracking the
1309 // corresponding locations in the input image using 16.16 fixed-point
1311 unsigned int inY = 0; //< 16.16 fixed-point input image y-coord.
1312 for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1314 const unsigned int integerY = (inY + (1u << 15u)) >> 16u;
1315 const uint8_t* const inScanline = &inPixels[inputWidth * integerY * BYTES_PER_PIXEL];
1316 uint8_t* const outScanline = &outPixels[desiredWidth * outY * BYTES_PER_PIXEL];
1317 unsigned int inX = 0; //< 16.16 fixed-point input image x-coord.
1319 for( unsigned int outX = 0; outX < desiredWidth * BYTES_PER_PIXEL; outX += BYTES_PER_PIXEL )
1321 // Round the fixed-point input coordinate to the address of the input pixel to sample:
1322 const unsigned int integerX = (inX + (1u << 15u)) >> 16u;
1323 const uint8_t* const inPixelAddress = &inScanline[integerX * BYTES_PER_PIXEL];
1325 // Issue loads for all pixel color components up-front:
1326 const unsigned int c0 = inPixelAddress[0];
1327 const unsigned int c1 = inPixelAddress[1];
1328 const unsigned int c2 = inPixelAddress[2];
1329 ///@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.
1331 // Output the pixel components:
1332 outScanline[outX] = c0;
1333 outScanline[outX + 1] = c1;
1334 outScanline[outX + 2] = c2;
1336 // Increment the fixed-point input coordinate:
1344 // Dispatch to a format-appropriate point sampling function:
1345 void PointSample( const unsigned char * inPixels,
1346 unsigned int inputWidth,
1347 unsigned int inputHeight,
1348 Pixel::Format pixelFormat,
1349 unsigned char * outPixels,
1350 unsigned int desiredWidth,
1351 unsigned int desiredHeight )
1353 // Check the pixel format is one that is supported:
1354 if( pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1356 if( pixelFormat == Pixel::RGB888 )
1358 PointSample3BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1360 else if( pixelFormat == Pixel::RGBA8888 )
1362 PointSample4BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1364 else if( pixelFormat == Pixel::RGB565 || pixelFormat == Pixel::LA88 )
1366 PointSample2BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1368 else if( pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1370 PointSample1BPP( inPixels, inputWidth, inputHeight, outPixels, desiredWidth, desiredHeight );
1374 DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1379 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not point sampled: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1383 // Linear sampling group below
1388 /** @brief Blend 4 pixels together using horizontal and vertical weights. */
1389 inline uint8_t BilinearFilter1BPPByte( uint8_t tl, uint8_t tr, uint8_t bl, uint8_t br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1391 return BilinearFilter1Component( tl, tr, bl, br, fractBlendHorizontal, fractBlendVertical );
1394 /** @copydoc BilinearFilter1BPPByte */
1395 inline Pixel2Bytes BilinearFilter2Bytes( Pixel2Bytes tl, Pixel2Bytes tr, Pixel2Bytes bl, Pixel2Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1398 pixel.l = BilinearFilter1Component( tl.l, tr.l, bl.l, br.l, fractBlendHorizontal, fractBlendVertical );
1399 pixel.a = BilinearFilter1Component( tl.a, tr.a, bl.a, br.a, fractBlendHorizontal, fractBlendVertical );
1403 /** @copydoc BilinearFilter1BPPByte */
1404 inline Pixel3Bytes BilinearFilterRGB888( Pixel3Bytes tl, Pixel3Bytes tr, Pixel3Bytes bl, Pixel3Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1407 pixel.r = BilinearFilter1Component( tl.r, tr.r, bl.r, br.r, fractBlendHorizontal, fractBlendVertical );
1408 pixel.g = BilinearFilter1Component( tl.g, tr.g, bl.g, br.g, fractBlendHorizontal, fractBlendVertical );
1409 pixel.b = BilinearFilter1Component( tl.b, tr.b, bl.b, br.b, fractBlendHorizontal, fractBlendVertical );
1413 /** @copydoc BilinearFilter1BPPByte */
1414 inline PixelRGB565 BilinearFilterRGB565( PixelRGB565 tl, PixelRGB565 tr, PixelRGB565 bl, PixelRGB565 br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1416 const PixelRGB565 pixel = (BilinearFilter1Component( tl >> 11u, tr >> 11u, bl >> 11u, br >> 11u, fractBlendHorizontal, fractBlendVertical ) << 11u) +
1417 (BilinearFilter1Component( (tl >> 5u) & 63u, (tr >> 5u) & 63u, (bl >> 5u) & 63u, (br >> 5u) & 63u, fractBlendHorizontal, fractBlendVertical ) << 5u) +
1418 BilinearFilter1Component( tl & 31u, tr & 31u, bl & 31u, br & 31u, fractBlendHorizontal, fractBlendVertical );
1422 /** @copydoc BilinearFilter1BPPByte */
1423 inline Pixel4Bytes BilinearFilter4Bytes( Pixel4Bytes tl, Pixel4Bytes tr, Pixel4Bytes bl, Pixel4Bytes br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical )
1426 pixel.r = BilinearFilter1Component( tl.r, tr.r, bl.r, br.r, fractBlendHorizontal, fractBlendVertical );
1427 pixel.g = BilinearFilter1Component( tl.g, tr.g, bl.g, br.g, fractBlendHorizontal, fractBlendVertical );
1428 pixel.b = BilinearFilter1Component( tl.b, tr.b, bl.b, br.b, fractBlendHorizontal, fractBlendVertical );
1429 pixel.a = BilinearFilter1Component( tl.a, tr.a, bl.a, br.a, fractBlendHorizontal, fractBlendVertical );
1434 * @brief Generic version of bilinear sampling image resize function.
1435 * @note Limited to one compilation unit and exposed through type-specific
1436 * wrapper functions below.
1440 PIXEL (*BilinearFilter) ( PIXEL tl, PIXEL tr, PIXEL bl, PIXEL br, unsigned int fractBlendHorizontal, unsigned int fractBlendVertical ),
1441 bool DEBUG_ASSERT_ALIGNMENT
1443 inline void LinearSampleGeneric( const unsigned char * __restrict__ inPixels,
1444 ImageDimensions inputDimensions,
1445 unsigned char * __restrict__ outPixels,
1446 ImageDimensions desiredDimensions )
1448 const unsigned int inputWidth = inputDimensions.GetWidth();
1449 const unsigned int inputHeight = inputDimensions.GetHeight();
1450 const unsigned int desiredWidth = desiredDimensions.GetWidth();
1451 const unsigned int desiredHeight = desiredDimensions.GetHeight();
1453 DALI_ASSERT_DEBUG( ((outPixels >= inPixels + inputWidth * inputHeight * sizeof(PIXEL)) ||
1454 (inPixels >= outPixels + desiredWidth * desiredHeight * sizeof(PIXEL))) &&
1455 "Input and output buffers cannot overlap.");
1456 if( DEBUG_ASSERT_ALIGNMENT )
1458 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, ...)." );
1459 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, ...)." );
1462 if( inputWidth < 1u || inputHeight < 1u || desiredWidth < 1u || desiredHeight < 1u )
1466 const PIXEL* const inAligned = reinterpret_cast<const PIXEL*>(inPixels);
1467 PIXEL* const outAligned = reinterpret_cast<PIXEL*>(outPixels);
1468 const unsigned int deltaX = (inputWidth << 16u) / desiredWidth;
1469 const unsigned int deltaY = (inputHeight << 16u) / desiredHeight;
1471 unsigned int inY = 0;
1472 for( unsigned int outY = 0; outY < desiredHeight; ++outY )
1474 PIXEL* const outScanline = &outAligned[desiredWidth * outY];
1476 // Find the two scanlines to blend and the weight to blend with:
1477 const unsigned int integerY1 = inY >> 16u;
1478 const unsigned int integerY2 = integerY1 >= inputHeight ? integerY1 : integerY1 + 1;
1479 const unsigned int inputYWeight = inY & 65535u;
1481 DALI_ASSERT_DEBUG( integerY1 < inputHeight );
1482 DALI_ASSERT_DEBUG( integerY2 < inputHeight );
1484 const PIXEL* const inScanline1 = &inAligned[inputWidth * integerY1];
1485 const PIXEL* const inScanline2 = &inAligned[inputWidth * integerY2];
1487 unsigned int inX = 0;
1488 for( unsigned int outX = 0; outX < desiredWidth; ++outX )
1490 // Work out the two pixel scanline offsets for this cluster of four samples:
1491 const unsigned int integerX1 = inX >> 16u;
1492 const unsigned int integerX2 = integerX1 >= inputWidth ? integerX1 : integerX1 + 1;
1494 // Execute the loads:
1495 const PIXEL pixel1 = inScanline1[integerX1];
1496 const PIXEL pixel2 = inScanline2[integerX1];
1497 const PIXEL pixel3 = inScanline1[integerX2];
1498 const PIXEL pixel4 = inScanline2[integerX2];
1499 ///@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.
1501 // Weighted bilinear filter:
1502 const unsigned int inputXWeight = inX & 65535u;
1503 outScanline[outX] = BilinearFilter( pixel1, pixel3, pixel2, pixel4, inputXWeight, inputYWeight );
1513 // Format-specific linear scaling instantiations:
1515 void LinearSample1BPP( const unsigned char * __restrict__ inPixels,
1516 ImageDimensions inputDimensions,
1517 unsigned char * __restrict__ outPixels,
1518 ImageDimensions desiredDimensions )
1520 LinearSampleGeneric<uint8_t, BilinearFilter1BPPByte, false>( inPixels, inputDimensions, outPixels, desiredDimensions );
1523 void LinearSample2BPP( const unsigned char * __restrict__ inPixels,
1524 ImageDimensions inputDimensions,
1525 unsigned char * __restrict__ outPixels,
1526 ImageDimensions desiredDimensions )
1528 LinearSampleGeneric<Pixel2Bytes, BilinearFilter2Bytes, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1531 void LinearSampleRGB565( const unsigned char * __restrict__ inPixels,
1532 ImageDimensions inputDimensions,
1533 unsigned char * __restrict__ outPixels,
1534 ImageDimensions desiredDimensions )
1536 LinearSampleGeneric<PixelRGB565, BilinearFilterRGB565, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1539 void LinearSample3BPP( const unsigned char * __restrict__ inPixels,
1540 ImageDimensions inputDimensions,
1541 unsigned char * __restrict__ outPixels,
1542 ImageDimensions desiredDimensions )
1544 LinearSampleGeneric<Pixel3Bytes, BilinearFilterRGB888, false>( inPixels, inputDimensions, outPixels, desiredDimensions );
1547 void LinearSample4BPP( const unsigned char * __restrict__ inPixels,
1548 ImageDimensions inputDimensions,
1549 unsigned char * __restrict__ outPixels,
1550 ImageDimensions desiredDimensions )
1552 LinearSampleGeneric<Pixel4Bytes, BilinearFilter4Bytes, true>( inPixels, inputDimensions, outPixels, desiredDimensions );
1556 void Resample( const unsigned char * __restrict__ inPixels,
1557 ImageDimensions inputDimensions,
1558 unsigned char * __restrict__ outPixels,
1559 ImageDimensions desiredDimensions,
1560 Resampler::Filter filterType,
1561 int numChannels, bool hasAlpha )
1563 // Got from the test.cpp of the ImageResampler lib.
1564 const float ONE_DIV_255 = 1.0f / 255.0f;
1565 const int MAX_UNSIGNED_CHAR = std::numeric_limits<uint8_t>::max();
1566 const int LINEAR_TO_SRGB_TABLE_SIZE = 4096;
1567 const int ALPHA_CHANNEL = hasAlpha ? (numChannels-1) : 0;
1569 static bool loadColorSpaces = true;
1570 static float srgbToLinear[MAX_UNSIGNED_CHAR + 1];
1571 static unsigned char linearToSrgb[LINEAR_TO_SRGB_TABLE_SIZE];
1573 if( loadColorSpaces ) // Only create the color space conversions on the first execution
1575 loadColorSpaces = false;
1577 for( int i = 0; i <= MAX_UNSIGNED_CHAR; ++i )
1579 srgbToLinear[i] = pow( static_cast<float>( i ) * ONE_DIV_255, DEFAULT_SOURCE_GAMMA );
1582 const float invLinearToSrgbTableSize = 1.0f / static_cast<float>( LINEAR_TO_SRGB_TABLE_SIZE );
1583 const float invSourceGamma = 1.0f / DEFAULT_SOURCE_GAMMA;
1585 for( int i = 0; i < LINEAR_TO_SRGB_TABLE_SIZE; ++i )
1587 int k = static_cast<int>( 255.0f * pow( static_cast<float>( i ) * invLinearToSrgbTableSize, invSourceGamma ) + 0.5f );
1592 else if( k > MAX_UNSIGNED_CHAR )
1594 k = MAX_UNSIGNED_CHAR;
1596 linearToSrgb[i] = static_cast<unsigned char>( k );
1600 Resampler* resamplers[numChannels];
1601 Vector<float> samples[numChannels];
1603 const int srcWidth = inputDimensions.GetWidth();
1604 const int srcHeight = inputDimensions.GetHeight();
1605 const int dstWidth = desiredDimensions.GetWidth();
1606 const int dstHeight = desiredDimensions.GetHeight();
1608 // Now create a Resampler instance for each component to process. The first instance will create new contributor tables, which are shared by the resamplers
1609 // used for the other components (a memory and slight cache efficiency optimization).
1610 resamplers[0] = new Resampler( srcWidth,
1614 Resampler::BOUNDARY_CLAMP,
1615 0.0f, // sample_low,
1616 1.0f, // sample_high. Clamp output samples to specified range, or disable clamping if sample_low >= sample_high.
1617 filterType, // The type of filter.
1619 NULL, // Pclist_y. Optional pointers to contributor lists from another instance of a Resampler.
1620 FILTER_SCALE, // src_x_ofs,
1621 FILTER_SCALE ); // src_y_ofs. Offset input image by specified amount (fractional values okay).
1622 samples[0].Resize( srcWidth );
1623 for( int i = 1; i < numChannels; ++i )
1625 resamplers[i] = new Resampler( srcWidth,
1629 Resampler::BOUNDARY_CLAMP,
1633 resamplers[0]->get_clist_x(),
1634 resamplers[0]->get_clist_y(),
1637 samples[i].Resize( srcWidth );
1640 const int srcPitch = srcWidth * numChannels;
1641 const int dstPitch = dstWidth * numChannels;
1644 for( int srcY = 0; srcY < srcHeight; ++srcY )
1646 const unsigned char* pSrc = &inPixels[srcY * srcPitch];
1648 for( int x = 0; x < srcWidth; ++x )
1650 for( int c = 0; c < numChannels; ++c )
1652 if( c == ALPHA_CHANNEL && hasAlpha )
1654 samples[c][x] = *pSrc++ * ONE_DIV_255;
1658 samples[c][x] = srgbToLinear[*pSrc++];
1663 for( int c = 0; c < numChannels; ++c )
1665 if( !resamplers[c]->put_line( &samples[c][0] ) )
1667 DALI_ASSERT_DEBUG( !"Out of memory" );
1674 for( compIndex = 0; compIndex < numChannels; ++compIndex )
1676 const float* pOutputSamples = resamplers[compIndex]->get_line();
1677 if( !pOutputSamples )
1682 const bool isAlphaChannel = ( compIndex == ALPHA_CHANNEL && hasAlpha );
1683 DALI_ASSERT_DEBUG( dstY < dstHeight );
1684 unsigned char* pDst = &outPixels[dstY * dstPitch + compIndex];
1686 for( int x = 0; x < dstWidth; ++x )
1688 if( isAlphaChannel )
1690 int c = static_cast<int>( 255.0f * pOutputSamples[x] + 0.5f );
1695 else if( c > MAX_UNSIGNED_CHAR )
1697 c = MAX_UNSIGNED_CHAR;
1699 *pDst = static_cast<unsigned char>( c );
1703 int j = static_cast<int>( LINEAR_TO_SRGB_TABLE_SIZE * pOutputSamples[x] + 0.5f );
1708 else if( j >= LINEAR_TO_SRGB_TABLE_SIZE )
1710 j = LINEAR_TO_SRGB_TABLE_SIZE - 1;
1712 *pDst = linearToSrgb[j];
1715 pDst += numChannels;
1718 if( compIndex < numChannels )
1727 // Delete the resamplers.
1728 for( int i = 0; i < numChannels; ++i )
1730 delete resamplers[i];
1734 void LanczosSample4BPP( const unsigned char * __restrict__ inPixels,
1735 ImageDimensions inputDimensions,
1736 unsigned char * __restrict__ outPixels,
1737 ImageDimensions desiredDimensions )
1739 Resample( inPixels, inputDimensions, outPixels, desiredDimensions, Resampler::LANCZOS4, 4, true );
1742 void LanczosSample1BPP( const unsigned char * __restrict__ inPixels,
1743 ImageDimensions inputDimensions,
1744 unsigned char * __restrict__ outPixels,
1745 ImageDimensions desiredDimensions )
1748 Resample( inPixels, inputDimensions, outPixels, desiredDimensions, Resampler::LANCZOS4, 1, false );
1751 // Dispatch to a format-appropriate linear sampling function:
1752 void LinearSample( const unsigned char * __restrict__ inPixels,
1753 ImageDimensions inDimensions,
1754 Pixel::Format pixelFormat,
1755 unsigned char * __restrict__ outPixels,
1756 ImageDimensions outDimensions )
1758 // Check the pixel format is one that is supported:
1759 if( pixelFormat == Pixel::RGB888 || pixelFormat == Pixel::RGBA8888 || pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 || pixelFormat == Pixel::LA88 || pixelFormat == Pixel::RGB565 )
1761 if( pixelFormat == Pixel::RGB888 )
1763 LinearSample3BPP( inPixels, inDimensions, outPixels, outDimensions );
1765 else if( pixelFormat == Pixel::RGBA8888 )
1767 LinearSample4BPP( inPixels, inDimensions, outPixels, outDimensions );
1769 else if( pixelFormat == Pixel::L8 || pixelFormat == Pixel::A8 )
1771 LinearSample1BPP( inPixels, inDimensions, outPixels, outDimensions );
1773 else if( pixelFormat == Pixel::LA88 )
1775 LinearSample2BPP( inPixels, inDimensions, outPixels, outDimensions );
1777 else if ( pixelFormat == Pixel::RGB565 )
1779 LinearSampleRGB565( inPixels, inDimensions, outPixels, outDimensions );
1783 DALI_ASSERT_DEBUG( false == "Inner branch conditions don't match outer branch." );
1788 DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Bitmap was not linear sampled: unsupported pixel format: %u.\n", unsigned(pixelFormat) );
1792 } /* namespace Platform */
1793 } /* namespace Internal */
1794 } /* namespace Dali */