kc3-lang/avir/lancir.h

Tag - branch -master- tag -version-1.0avir-1.13.13.02.92.82.62.52.42.32.22.12.01.81.71.61.51.41.31.2

• Show log

  Commit

• Hash : 24034240
  Author :
  Date : 2021-10-03T09:31:06
  

  Version 3.0.
  Improved speed by 10-25% on upsizing by utilizing a special resizing function together with filter-less 2X upsizing. Does not apply to the de-interleaved (AVX) resizing.
  Minor LANCIR optimization.

Download

• lancir.h

• //$ nobt
  //$ nocpp
  
  /**
   * @file lancir.h
   *
   * @brief The self-contained "lancir" inclusion file.
   *
   * This is the self-contained inclusion file for the "LANCIR" image resizer,
   * part of the AVIR library.
   *
   * AVIR Copyright (c) 2015-2021 Aleksey Vaneev
   *
   * @mainpage
   *
   * @section intro_sec Introduction
   *
   * Description is available at https://github.com/avaneev/avir
   *
   * @section license License
   *
   * MIT License
   *
   * Copyright (c) 2015-2021 Aleksey Vaneev
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   * DEALINGS IN THE SOFTWARE.
   */
  
  #ifndef AVIR_CLANCIR_INCLUDED
  #define AVIR_CLANCIR_INCLUDED
  
  #include <string.h>
  #include <math.h>
  
  namespace avir {
  
  /**
   * The macro equals to "pi" constant, fills 53-bit floating point mantissa.
   * Undefined at the end of file.
   */
  
  #define LANCIR_PI 3.1415926535897932
  
  /**
   * @brief LANCIR image resizer class.
   *
   * The object of this class can be used to resize 1-4 channel images to any
   * required size. Resizing is performed by utilizing Lanczos filters, with
   * 8-bit precision. This class offers a kind of "optimal" Lanczos resampling
   * implementation.
   *
   * Object of this class can be allocated on stack.
   *
   * Note that object of this class does not free temporary buffers and
   * variables after the resizeImage() call (until object's destruction), these
   * buffers are reused on subsequent calls making batch resizing of same-size
   * images faster. This means resizing is not thread-safe: a separate object
   * should be created for each thread.
   */
  
  class CLancIR
  {
  private:
  	CLancIR( const CLancIR& )
  	{
  		// Unsupported.
  	}
  
  	CLancIR& operator = ( const CLancIR& )
  	{
  		// Unsupported.
  		return( *this );
  	}
  
  public:
  	CLancIR()
  		: FltBuf( NULL )
  		, FltBufLen( 0 )
  		, spv( NULL )
  		, spvlen( 0 )
  	{
  	}
  
  	~CLancIR()
  	{
  		delete[] FltBuf;
  		delete[] spv;
  	}
  
  	/**
  	 * Function resizes image.
  	 *
  	 * @param SrcBuf Source image buffer.
  	 * @param SrcWidth Source image width.
  	 * @param SrcHeight Source image height.
  	 * @param SrcScanlineSize Physical size of source scanline in elements
  	 * (not bytes). If this value is below 1, SrcWidth * ElCount will be
  	 * used as the physical source scanline size.
  	 * @param[out] NewBuf Buffer to accept the resized image. Can be equal to
  	 * SrcBuf if the size of the resized image is smaller or equal to source
  	 * image in size.
  	 * @param NewWidth New image width.
  	 * @param NewHeight New image height.
  	 * @param ElCount The number of elements (channels) used to store each
  	 * source and destination pixel (1-4).
  	 * @param kx0 Resizing step - horizontal (one output pixel corresponds to
  	 * "k" input pixels). A downsizing factor if > 1.0; upsizing factor
  	 * if <= 1.0. Multiply by -1 if you would like to bypass "ox" and "oy"
  	 * adjustment which is done by default to produce a centered image. If
  	 * step value equals 0, the step value will be chosen automatically.
  	 * @param ky0 Resizing step - vertical. Same as "kx".
  	 * @param ox Start X pixel offset within source image (can be negative).
  	 * Positive offset moves the image to the left.
  	 * @param oy Start Y pixel offset within source image (can be negative).
  	 * Positive offset moves the image to the top.
  	 * @tparam T Input and output buffer element's type. Can be uint8_t
  	 * (0-255 value range), uint16_t (0-65535 value range), float
  	 * (any value range), double (any value range). Larger integer types are
  	 * treated as uint16_t. Signed integer types are unsupported.
  	 */
  
  	template< class T >
  	void resizeImage( const T* const SrcBuf, const int SrcWidth,
  		const int SrcHeight, int SrcScanlineSize, T* const NewBuf,
  		const int NewWidth, const int NewHeight, const int ElCount,
  		const double kx0 = 0.0, const double ky0 = 0.0, double ox = 0.0,
  		double oy = 0.0 )
  	{
  		if( NewWidth <= 0 || NewHeight <= 0 )
  		{
  			return;
  		}
  
  		if( SrcWidth <= 0 || SrcHeight <= 0 )
  		{
  			memset( NewBuf, 0, (size_t) NewWidth * NewHeight * ElCount *
  				sizeof( T ));
  
  			return;
  		}
  
  		const double la = 3.0; // Lanczos "a".
  		double kx;
  		double ky;
  
  		if( kx0 == 0.0 )
  		{
  			kx = (double) SrcWidth / NewWidth;
  			ox += ( kx - 1.0 ) * 0.5;
  		}
  		else
  		if( kx0 > 0.0 )
  		{
  			kx = kx0;
  			ox += ( kx0 - 1.0 ) * 0.5;
  		}
  		else
  		{
  			kx = -kx0;
  		}
  
  		if( ky0 == 0.0 )
  		{
  			ky = (double) SrcHeight / NewHeight;
  			oy += ( ky - 1.0 ) * 0.5;
  		}
  		else
  		if( ky0 > 0.0 )
  		{
  			ky = ky0;
  			oy += ( ky0 - 1.0 ) * 0.5;
  		}
  		else
  		{
  			ky = -ky0;
  		}
  
  		if( rfh.update( la, kx ))
  		{
  			rsh.reset();
  			rsv.reset();
  		}
  
  		CResizeFilters* rfv; // Pointer to resizing filters for vertical
  			// resizing, may equal to "rfh" if the same stepping is in use.
  
  		if( ky == kx )
  		{
  			rfv = &rfh;
  		}
  		else
  		{
  			rfv = &rfv0;
  
  			if( rfv0.update( la, ky ))
  			{
  				rsv.reset();
  			}
  		}
  
  		rsh.update( kx, ox, ElCount, SrcWidth, NewWidth, rfh );
  		rsv.update( ky, oy, ElCount, SrcHeight, NewHeight, *rfv );
  
  		const int NewWidthE = NewWidth * ElCount;
  
  		if( SrcScanlineSize < 1 )
  		{
  			SrcScanlineSize = SrcWidth * ElCount;
  		}
  
  		// Allocate/resize temporary buffer.
  
  		const size_t FltBufLenNew = (size_t) NewWidthE * (size_t) SrcHeight;
  
  		if( FltBufLenNew > FltBufLen )
  		{
  			delete[] FltBuf;
  			FltBufLen = FltBufLenNew;
  			FltBuf = new float[ FltBufLen ];
  		}
  
  		// Perform horizontal resizing.
  
  		const T* ips = SrcBuf;
  		float* op = FltBuf;
  		int i;
  
  		if( ElCount == 3 )
  		{
  			for( i = 0; i < SrcHeight; i++ )
  			{
  				copyScanline3h( ips, rsh, SrcWidth );
  				resize3( op, NewWidth, rsh.pos, rfh.KernelLen );
  				ips += SrcScanlineSize;
  				op += NewWidthE;
  			}
  		}
  		else
  		if( ElCount == 1 )
  		{
  			for( i = 0; i < SrcHeight; i++ )
  			{
  				copyScanline1h( ips, rsh, SrcWidth );
  				resize1( op, NewWidth, rsh.pos, rfh.KernelLen );
  				ips += SrcScanlineSize;
  				op += NewWidthE;
  			}
  		}
  		else
  		if( ElCount == 4 )
  		{
  			for( i = 0; i < SrcHeight; i++ )
  			{
  				copyScanline4h( ips, rsh, SrcWidth );
  				resize4( op, NewWidth, rsh.pos, rfh.KernelLen );
  				ips += SrcScanlineSize;
  				op += NewWidthE;
  			}
  		}
  		else
  		if( ElCount == 2 )
  		{
  			for( i = 0; i < SrcHeight; i++ )
  			{
  				copyScanline2h( ips, rsh, SrcWidth );
  				resize2( op, NewWidth, rsh.pos, rfh.KernelLen );
  				ips += SrcScanlineSize;
  				op += NewWidthE;
  			}
  		}
  
  		// Perform vertical resizing.
  
  		const int spvlennew = NewHeight * ElCount;
  
  		if( spvlennew > spvlen )
  		{
  			delete[] spv;
  			spvlen = spvlennew;
  			spv = new float[ spvlen ];
  		}
  
  		const bool IsIOFloat = ( (T) 0.25 != 0 );
  		const int Clamp = ( sizeof( T ) == 1 ? 255 : 65535 );
  		const float* ip = FltBuf;
  		T* opd = NewBuf;
  
  		if( ElCount == 3 )
  		{
  			for( i = 0; i < NewWidth; i++ )
  			{
  				copyScanline3v( ip, rsv, SrcHeight, NewWidthE );
  				resize3( spv, NewHeight, rsv.pos, rfv -> KernelLen );
  				copyOutput3( spv, opd, NewHeight, NewWidthE, IsIOFloat,
  					Clamp );
  
  				ip += 3;
  				opd += 3;
  			}
  		}
  		else
  		if( ElCount == 1 )
  		{
  			for( i = 0; i < NewWidth; i++ )
  			{
  				copyScanline1v( ip, rsv, SrcHeight, NewWidthE );
  				resize1( spv, NewHeight, rsv.pos, rfv -> KernelLen );
  				copyOutput1( spv, opd, NewHeight, NewWidthE, IsIOFloat,
  					Clamp );
  
  				ip++;
  				opd++;
  			}
  		}
  		else
  		if( ElCount == 4 )
  		{
  			for( i = 0; i < NewWidth; i++ )
  			{
  				copyScanline4v( ip, rsv, SrcHeight, NewWidthE );
  				resize4( spv, NewHeight, rsv.pos, rfv -> KernelLen );
  				copyOutput4( spv, opd, NewHeight, NewWidthE, IsIOFloat,
  					Clamp );
  
  				ip += 4;
  				opd += 4;
  			}
  		}
  		else
  		if( ElCount == 2 )
  		{
  			for( i = 0; i < NewWidth; i++ )
  			{
  				copyScanline2v( ip, rsv, SrcHeight, NewWidthE );
  				resize2( spv, NewHeight, rsv.pos, rfv -> KernelLen );
  				copyOutput2( spv, opd, NewHeight, NewWidthE, IsIOFloat,
  					Clamp );
  
  				ip += 2;
  				opd += 2;
  			}
  		}
  	}
  
  protected:
  	float* FltBuf; ///< Intermediate resizing buffer.
  		///<
  	size_t FltBufLen; ///< Intermediate resizing buffer length.
  		///<
  	float* spv; ///< Scanline buffer for vertical resizing.
  		///<
  	int spvlen; ///< Length of "spv".
  		///<
  
  	/**
  	 * Function rounds a value and applies clamping.
  	 *
  	 * @param v Value to round and clamp.
  	 * @param Clamp High clamp level, low level is 0.
  	 */
  
  	static int roundclamp( const float v, const int Clamp )
  	{
  		if( v <= 0.0f )
  		{
  			return( 0 );
  		}
  
  		const int vr = (int) ( v + 0.5f );
  
  		if( vr > Clamp )
  		{
  			return( Clamp );
  		}
  
  		return( vr );
  	}
  
  	/**
  	 * Function performs final output of the resized scanline data to the
  	 * destination image buffer. Variants for 1-4-channel image.
  	 *
  	 * @param ip Input resized scanline.
  	 * @param op Output image buffer.
  	 * @param l Pixel count.
  	 * @param opinc "op" increment, should account ElCount.
  	 * @param IsIOFloat "True" if float output and no clamping is necessary.
  	 * @param Clamp Clamp high level, used if IsIOFloat is "false".
  	 */
  
  	template< class T >
  	static void copyOutput1( const float* ip, T* op, int l, const int opinc,
  		const bool IsIOFloat, const int Clamp )
  	{
  		if( IsIOFloat )
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) ip[ 0 ];
  				ip++;
  				op += opinc;
  				l--;
  			}
  		}
  		else
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
  				ip++;
  				op += opinc;
  				l--;
  			}
  		}
  	}
  
  	template< class T >
  	static void copyOutput2( const float* ip, T* op, int l, const int opinc,
  		const bool IsIOFloat, const int Clamp )
  	{
  		if( IsIOFloat )
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) ip[ 0 ];
  				op[ 1 ] = (T) ip[ 1 ];
  				ip += 2;
  				op += opinc;
  				l--;
  			}
  		}
  		else
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
  				op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
  				ip += 2;
  				op += opinc;
  				l--;
  			}
  		}
  	}
  
  	template< class T >
  	static void copyOutput3( const float* ip, T* op, int l, const int opinc,
  		const bool IsIOFloat, const int Clamp )
  	{
  		if( IsIOFloat )
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) ip[ 0 ];
  				op[ 1 ] = (T) ip[ 1 ];
  				op[ 2 ] = (T) ip[ 2 ];
  				ip += 3;
  				op += opinc;
  				l--;
  			}
  		}
  		else
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
  				op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
  				op[ 2 ] = (T) roundclamp( ip[ 2 ], Clamp );
  				ip += 3;
  				op += opinc;
  				l--;
  			}
  		}
  	}
  
  	template< class T >
  	static void copyOutput4( const float* ip, T* op, int l, const int opinc,
  		const bool IsIOFloat, const int Clamp )
  	{
  		if( IsIOFloat )
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) ip[ 0 ];
  				op[ 1 ] = (T) ip[ 1 ];
  				op[ 2 ] = (T) ip[ 2 ];
  				op[ 3 ] = (T) ip[ 3 ];
  				ip += 4;
  				op += opinc;
  				l--;
  			}
  		}
  		else
  		{
  			while( l > 0 )
  			{
  				op[ 0 ] = (T) roundclamp( ip[ 0 ], Clamp );
  				op[ 1 ] = (T) roundclamp( ip[ 1 ], Clamp );
  				op[ 2 ] = (T) roundclamp( ip[ 2 ], Clamp );
  				op[ 3 ] = (T) roundclamp( ip[ 3 ], Clamp );
  				ip += 4;
  				op += opinc;
  				l--;
  			}
  		}
  	}
  
  	class CResizeScanline;
  
  	/**
  	 * Class implements fractional delay filter bank calculation.
  	 */
  
  	class CResizeFilters
  	{
  		friend class CResizeScanline;
  
  	public:
  		int KernelLen; ///< Resampling filter kernel length, taps. Available
  			///< after the update() function call.
  			///<
  
  		CResizeFilters()
  			: FilterBuf( NULL )
  			, Filters( NULL )
  			, Prevla( -1.0 )
  			, Prevk( -1.0 )
  			, FilterBufLen( 0 )
  			, FiltersLen( 0 )
  		{
  		}
  
  		~CResizeFilters()
  		{
  			delete[] FilterBuf;
  			delete[] Filters;
  		}
  
  		/**
  		 * Function updates the resizing filter bank.
  		 *
  		 * @param la Lanczos "a" parameter value.
  		 * @param k Resizing step.
  		 * @return "True" if update occured and resizing positions should be
  		 * updated unconditionally.
  		 */
  
  		bool update( const double la, const double k )
  		{
  			if( la == Prevla && k == Prevk )
  			{
  				return( false );
  			}
  
  			Prevla = la;
  			Prevk = k;
  
  			NormFreq = ( k <= 1.0 ? 1.0 : 1.0 / k );
  			Freq = LANCIR_PI * NormFreq;
  			FreqA = LANCIR_PI * NormFreq / la;
  
  			Len2 = la / NormFreq;
  			fl2 = (int) ceil( Len2 );
  			KernelLen = fl2 + fl2;
  
  			FracCount = 607; // For 8-bit precision.
  			FracFill = 0;
  
  			const int FilterBufLenNew = ( FracCount + 1 ) * KernelLen;
  				// Add +1 to cover rare cases of fractional delay == 1.
  
  			if( FilterBufLenNew > FilterBufLen )
  			{
  				delete[] FilterBuf;
  				FilterBufLen = FilterBufLenNew;
  				FilterBuf = new float[ FilterBufLen ];
  			}
  
  			if( FracCount > FiltersLen )
  			{
  				delete[] Filters;
  				FiltersLen = FracCount;
  				Filters = new float*[ FiltersLen + 1 ];
  			}
  
  			memset( Filters, 0, ( FiltersLen + 1 ) * sizeof( float* ));
  
  			return( true );
  		}
  
  		/**
  		 * Function returns filter at the specified fractional offset. This
  		 * function can only be called before the prior update() function
  		 * call.
  		 *
  		 * @param x Fractional offset, [0; 1).
  		 */
  
  		float* getFilter( const double x )
  		{
  			const int Frac = (int) floor( x * FracCount );
  
  			if( Filters[ Frac ] == NULL )
  			{
  				Filters[ Frac ] = FilterBuf + FracFill * KernelLen;
  				FracFill++;
  				makeFilter( 1.0 - (double) Frac / FracCount, Filters[ Frac ]);
  				normalizeFilter( Filters[ Frac ]);
  			}
  
  			return( Filters[ Frac ]);
  		}
  
  	protected:
  		double NormFreq; ///< Normalized frequency of the filter.
  			///<
  		double Freq; ///< Circular frequency of the filter.
  			///<
  		double FreqA; ///< Circular frequency of the window function.
  			///<
  		double Len2; ///< Half resampling filter length, unrounded.
  			///<
  		int fl2; ///< Half resampling length, integer.
  			///<
  		int FracCount; ///< The number of fractional positions for which
  			///< filters are created.
  			///<
  		int FracFill; ///< The number of fractional positions filled in the
  			///< filter buffer.
  			///<
  		float* FilterBuf; ///< Buffer that holds all filters.
  			///<
  		float** Filters; ///< Fractional delay filters for all positions.
  			///< Filter pointers equal NULL if filter was not yet created.
  			///<
  		double Prevla; ///< Previous "la".
  			///<
  		double Prevk; ///< Previous "k".
  			///<
  		int FilterBufLen; ///< Allocated length of FilterBuf in elements.
  			///<
  		int FiltersLen; ///< Allocated length of Filters in elements.
  			///<
  
  		/**
  		 * @brief Sine signal generator class.
  		 *
  		 * Class implements sine signal generator without biasing, with
  		 * constructor-based initalization only. This generator uses
  		 * oscillator instead of "sin" function.
  		 */
  
  		class CSinGen
  		{
  		public:
  			/**
  			 * Constructor initializes *this sine signal generator.
  			 *
  			 * @param si Sine function increment, in radians.
  			 * @param ph Starting phase, in radians. Add 0.5 * LANCIR_PI for
  			 * cosine function.
  			 * @param g Gain value.
  			 */
  
  			CSinGen( const double si, const double ph, const double g = 1.0 )
  				: svalue1( sin( ph ) * g )
  				, svalue2( sin( ph - si ) * g )
  				, sincr( 2.0 * cos( si ))
  			{
  			}
  
  			/**
  			 * @return The next value of the sine function, without biasing.
  			 */
  
  			double generate()
  			{
  				const double res = svalue1;
  
  				svalue1 = sincr * res - svalue2;
  				svalue2 = res;
  
  				return( res );
  			}
  
  		private:
  			double svalue1; ///< Current sine value.
  				///<
  			double svalue2; ///< Previous sine value.
  				///<
  			double sincr; ///< Sine value increment.
  				///<
  		};
  
  		/**
  		 * Function creates filter for the specified fractional delay. The
  		 * update() function should be called prior to calling this function.
  		 * The created filter is not normalized, so it should be normalized
  		 * afterwards.
  		 *
  		 * @param FracDelay Fractional delay, 0 to 1, inclusive.
  		 * @param[out] Output filter buffer.
  		 * @tparam T Output buffer type.
  		 */
  
  		template< class T >
  		void makeFilter( const double FracDelay, T* op ) const
  		{
  			CSinGen f( Freq, Freq * ( FracDelay - fl2 ));
  			CSinGen fw( FreqA, FreqA * ( FracDelay - fl2 ), Len2 );
  
  			int t = -fl2;
  
  			if( t + FracDelay < -Len2 )
  			{
  				f.generate();
  				fw.generate();
  				*op = (T) 0.0;
  				op++;
  				t++;
  			}
  
  			int mt = ( FracDelay >= 1.0 - 1e-13 && FracDelay <= 1.0 + 1e-13 ?
  				-1 : 0 );
  
  			while( t < mt )
  			{
  				double ut = t + FracDelay;
  				*op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
  				op++;
  				t++;
  			}
  
  			double ut = t + FracDelay;
  
  			if( fabs( ut ) <= 1e-13 )
  			{
  				*op = (T) ( NormFreq * ( LANCIR_PI * LANCIR_PI ));
  				f.generate();
  				fw.generate();
  			}
  			else
  			{
  				*op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
  			}
  
  			mt = fl2 - 2;
  
  			while( t < mt )
  			{
  				op++;
  				t++;
  				ut = t + FracDelay;
  				*op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
  			}
  
  			op++;
  			t++;
  			ut = t + FracDelay;
  
  			if( ut > Len2 )
  			{
  				*op = (T) 0.0;
  			}
  			else
  			{
  				*op = (T) ( f.generate() * fw.generate() / ( ut * ut ));
  			}
  		}
  
  		/**
  		 * Function normalizes the specified filter so that it has unity gain
  		 * at DC.
  		 *
  		 * @param p Filter buffer pointer.
  		 * @tparam T Filter buffer type.
  		 */
  
  		template< class T >
  		void normalizeFilter( T* const p ) const
  		{
  			double s = 0.0;
  			int i;
  
  			for( i = 0; i < KernelLen; i++ )
  			{
  				s += p[ i ];
  			}
  
  			s = 1.0 / s;
  
  			for( i = 0; i < KernelLen; i++ )
  			{
  				p[ i ] = (T) ( p[ i ] * s );
  			}
  		}
  	};
  
  	/**
  	 * Structure defines source scanline positioning and filters for each
  	 * destination pixel.
  	 */
  
  	struct CResizePos
  	{
  		const float* ip; ///< Source image pixel pointer.
  			///<
  		float* flt; ///< Fractional delay filter.
  			///<
  	};
  
  	/**
  	 * Class contains resizing positioning and a temporary scanline buffer,
  	 * prepares source scanline positions for resize filtering.
  	 */
  
  	class CResizeScanline
  	{
  	public:
  		int padl; ///< Left-padding (in pixels) required for source scanline.
  			///< Available after the update() function call.
  			///<
  		int padr; ///< Right-padding (in pixels) required for source scanline.
  			///< Available after the update() function call.
  			///<
  		float* sp; ///< Source scanline buffer, with "padl" and "padr"
  			///< padding.
  			///<
  		CResizePos* pos; ///< Source scanline pointers (point to "sp")
  			///< and filters for each destination pixel position. Available
  			///< after the update() function call.
  			///<
  
  		CResizeScanline()
  			: sp( NULL )
  			, pos( NULL )
  			, PrevSrcLen( -1 )
  			, PrevDstLen( -1 )
  			, Prevk( 0.0 )
  			, Prevo( 0.0 )
  			, PrevElCount( 0 )
  			, splen( 0 )
  			, poslen( 0 )
  		{
  		}
  
  		~CResizeScanline()
  		{
  			delete[] sp;
  			delete[] pos;
  		}
  
  		/**
  		 * Function "resets" *this object so that the next update() call fully
  		 * updates the position buffer. Reset is necessary if the filter
  		 * object was updated.
  		 */
  
  		void reset()
  		{
  			PrevSrcLen = -1;
  		}
  
  		/**
  		 * Function updates resizing positions, updates "padl", "padr" and
  		 * "pos" buffer.
  		 *
  		 * @param k Resizing step.
  		 * @param o0 Initial source image offset.
  		 * @param SrcLen Source image scanline length, used to create a
  		 * scanline buffer without length pre-calculation.
  		 * @param DstLen Destination image scanline length.
  		 * @param rf Resizing filters object.
  		 */
  
  		void update( const double k, const double o0, const int ElCount,
  			const int SrcLen, const int DstLen, CResizeFilters& rf )
  		{
  			if( SrcLen == PrevSrcLen && DstLen == PrevDstLen &&
  				k == Prevk && o0 == Prevo && ElCount == PrevElCount )
  			{
  				return;
  			}
  
  			PrevSrcLen = SrcLen;
  			PrevDstLen = DstLen;
  			Prevk = k;
  			Prevo = o0;
  			PrevElCount = ElCount;
  
  			const int fl2m1 = rf.fl2 - 1;
  			padl = fl2m1 - (int) floor( o0 );
  
  			if( padl < 0 )
  			{
  				padl = 0;
  			}
  
  			padr = (int) floor( o0 + k * ( DstLen - 1 )) + rf.fl2 + 1 -
  				SrcLen;
  
  			if( padr < 0 )
  			{
  				padr = 0;
  			}
  
  			const int splennew = ( padl + SrcLen + padr ) * ElCount;
  
  			if( splennew > splen )
  			{
  				delete[] sp;
  				splen = splennew;
  				sp = new float[ splen ];
  			}
  
  			if( DstLen > poslen )
  			{
  				delete[] pos;
  				poslen = DstLen;
  				pos = new CResizePos[ poslen ];
  			}
  
  			const float* const spo = sp + ( padl - fl2m1 ) * ElCount;
  			int i;
  
  			for( i = 0; i < DstLen; i++ )
  			{
  				const double o = o0 + k * i;
  				const int ix = (int) floor( o );
  				pos[ i ].ip = spo + ix * ElCount;
  				pos[ i ].flt = rf.getFilter( o - ix );
  			}
  		}
  
  	protected:
  		int PrevSrcLen; ///< Previous SrcLen.
  			///<
  		int PrevDstLen; ///< Previous DstLen.
  			///<
  		double Prevk; ///< Previous "k".
  			///<
  		double Prevo; ///< Previous "o".
  			///<
  		int PrevElCount; ///< Previous pixel element count.
  			///<
  		int splen; ///< Allocated "sp" buffer length.
  			///<
  		int poslen; ///< Allocated "pos" buffer length.
  			///<
  	};
  
  	CResizeFilters rfh; ///< Resizing filters for horizontal resizing.
  		///<
  	CResizeFilters rfv0; ///< Resizing filters for vertical resizing (may not
  		///< be in use).
  		///<
  	CResizeScanline rsh; ///< Horizontal resize scanline.
  		///<
  	CResizeScanline rsv; ///< Vertical resize scanline.
  		///<
  
  	/**
  	 * Function copies scanline from the source buffer in its native format
  	 * to internal scanline buffer, in preparation for horizontal resizing.
  	 * Variants for 1-4-channel images.
  	 *
  	 * @param ip Source scanline buffer.
  	 * @param rs Scanline resizing positions object.
  	 * @param l Source scanline length, in pixels.
  	 * @param ipinc "ip" increment per pixel.
  	 */
  
  	template< class T >
  	static void copyScanline1h( const T* ip, CResizeScanline& rs, const int l )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op++;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			ip++;
  			op++;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op++;
  		}
  	}
  
  	template< class T >
  	static void copyScanline2h( const T* ip, CResizeScanline& rs, const int l )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op += 2;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			ip += 2;
  			op += 2;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op += 2;
  		}
  	}
  
  	template< class T >
  	static void copyScanline3h( const T* ip, CResizeScanline& rs, const int l )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op += 3;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			ip += 3;
  			op += 3;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op += 3;
  		}
  	}
  
  	template< class T >
  	static void copyScanline4h( const T* ip, CResizeScanline& rs, const int l )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			op += 4;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			ip += 4;
  			op += 4;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			op += 4;
  		}
  	}
  
  	/**
  	 * Function copies scanline from the source buffer in its native format
  	 * to internal scanline buffer, in preparation for vertical resizing.
  	 * Variants for 1-4-channel images.
  	 *
  	 * @param ip Source scanline buffer.
  	 * @param rs Scanline resizing positions object.
  	 * @param l Source scanline length, in pixels.
  	 * @param ipinc "ip" increment per pixel.
  	 */
  
  	template< class T >
  	static void copyScanline1v( const T* ip, CResizeScanline& rs, const int l,
  		const int ipinc )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op++;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			ip += ipinc;
  			op++;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op++;
  		}
  	}
  
  	template< class T >
  	static void copyScanline2v( const T* ip, CResizeScanline& rs, const int l,
  		const int ipinc )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op += 2;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			ip += ipinc;
  			op += 2;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op += 2;
  		}
  	}
  
  	template< class T >
  	static void copyScanline3v( const T* ip, CResizeScanline& rs, const int l,
  		const int ipinc )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op += 3;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			ip += ipinc;
  			op += 3;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op += 3;
  		}
  	}
  
  	template< class T >
  	static void copyScanline4v( const T* ip, CResizeScanline& rs, const int l,
  		const int ipinc )
  	{
  		float* op = rs.sp;
  		int i;
  
  		for( i = 0; i < rs.padl; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			op += 4;
  		}
  
  		for( i = 0; i < l - 1; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			ip += ipinc;
  			op += 4;
  		}
  
  		for( i = 0; i <= rs.padr; i++ )
  		{
  			op[ 0 ] = ip[ 0 ];
  			op[ 1 ] = ip[ 1 ];
  			op[ 2 ] = ip[ 2 ];
  			op[ 3 ] = ip[ 3 ];
  			op += 4;
  		}
  	}
  
  	#define LANCIR_LF_PRE \
  			CResizePos* const rpe = rp + DstLen; \
  			while( rp < rpe ) \
  			{ \
  				const float* ip = rp -> ip; \
  				const float* const flt = rp -> flt;
  
  	#define LANCIR_LF_POST \
  				rp++; \
  			}
  
  	/**
  	 * Function performs internal scanline resizing. Variants for 1-4-channel
  	 * images.
  	 *
  	 * @param op Destination buffer.
  	 * @param DstLen Destination length, in pixels.
  	 * @param rp Resizing positions and filters.
  	 * @param kl Filter kernel length, in taps.
  	 */
  
  	static void resize1( float* op, int DstLen, CResizePos* rp, const int kl )
  	{
  		if( kl == 6 )
  		{
  			LANCIR_LF_PRE
  			op[ 0 ] =
  				flt[ 0 ] * ip[ 0 ] +
  				flt[ 1 ] * ip[ 1 ] +
  				flt[ 2 ] * ip[ 2 ] +
  				flt[ 3 ] * ip[ 3 ] +
  				flt[ 4 ] * ip[ 4 ] +
  				flt[ 5 ] * ip[ 5 ];
  
  			op++;
  			LANCIR_LF_POST
  		}
  		else
  		{
  			LANCIR_LF_PRE
  			float sum = 0.0;
  			int i;
  
  			for( i = 0; i < kl; i++ )
  			{
  				sum += flt[ i ] * ip[ i ];
  			}
  
  			op[ 0 ] = sum;
  			op++;
  			LANCIR_LF_POST
  		}
  	}
  
  	static void resize2( float* op, int DstLen, CResizePos* rp, const int kl )
  	{
  		if( kl == 6 )
  		{
  			LANCIR_LF_PRE
  			op[ 0 ] =
  				flt[ 0 ] * ip[ 0 ] +
  				flt[ 1 ] * ip[ 2 ] +
  				flt[ 2 ] * ip[ 4 ] +
  				flt[ 3 ] * ip[ 6 ] +
  				flt[ 4 ] * ip[ 8 ] +
  				flt[ 5 ] * ip[ 10 ];
  
  			op[ 1 ] =
  				flt[ 0 ] * ip[ 1 ] +
  				flt[ 1 ] * ip[ 3 ] +
  				flt[ 2 ] * ip[ 5 ] +
  				flt[ 3 ] * ip[ 7 ] +
  				flt[ 4 ] * ip[ 9 ] +
  				flt[ 5 ] * ip[ 11 ];
  
  			op += 2;
  			LANCIR_LF_POST
  		}
  		else
  		{
  			LANCIR_LF_PRE
  			float sum[ 2 ];
  			sum[ 0 ] = 0.0;
  			sum[ 1 ] = 0.0;
  			int i;
  
  			for( i = 0; i < kl; i++ )
  			{
  				const float xx = flt[ i ];
  				sum[ 0 ] += xx * ip[ 0 ];
  				sum[ 1 ] += xx * ip[ 1 ];
  				ip += 2;
  			}
  
  			op[ 0 ] = sum[ 0 ];
  			op[ 1 ] = sum[ 1 ];
  			op += 2;
  			LANCIR_LF_POST
  		}
  	}
  
  	static void resize3( float* op, int DstLen, CResizePos* rp, const int kl )
  	{
  		if( kl == 6 )
  		{
  			LANCIR_LF_PRE
  			op[ 0 ] =
  				flt[ 0 ] * ip[ 0 ] +
  				flt[ 1 ] * ip[ 3 ] +
  				flt[ 2 ] * ip[ 6 ] +
  				flt[ 3 ] * ip[ 9 ] +
  				flt[ 4 ] * ip[ 12 ] +
  				flt[ 5 ] * ip[ 15 ];
  
  			op[ 1 ] =
  				flt[ 0 ] * ip[ 1 ] +
  				flt[ 1 ] * ip[ 4 ] +
  				flt[ 2 ] * ip[ 7 ] +
  				flt[ 3 ] * ip[ 10 ] +
  				flt[ 4 ] * ip[ 13 ] +
  				flt[ 5 ] * ip[ 16 ];
  
  			op[ 2 ] =
  				flt[ 0 ] * ip[ 2 ] +
  				flt[ 1 ] * ip[ 5 ] +
  				flt[ 2 ] * ip[ 8 ] +
  				flt[ 3 ] * ip[ 11 ] +
  				flt[ 4 ] * ip[ 14 ] +
  				flt[ 5 ] * ip[ 17 ];
  
  			op += 3;
  			LANCIR_LF_POST
  		}
  		else
  		{
  			LANCIR_LF_PRE
  			float sum[ 3 ];
  			sum[ 0 ] = 0.0;
  			sum[ 1 ] = 0.0;
  			sum[ 2 ] = 0.0;
  			int i;
  
  			for( i = 0; i < kl; i++ )
  			{
  				const float xx = flt[ i ];
  				sum[ 0 ] += xx * ip[ 0 ];
  				sum[ 1 ] += xx * ip[ 1 ];
  				sum[ 2 ] += xx * ip[ 2 ];
  				ip += 3;
  			}
  
  			op[ 0 ] = sum[ 0 ];
  			op[ 1 ] = sum[ 1 ];
  			op[ 2 ] = sum[ 2 ];
  			op += 3;
  			LANCIR_LF_POST
  		}
  	}
  
  	static void resize4( float* op, int DstLen, CResizePos* rp, const int kl )
  	{
  		LANCIR_LF_PRE
  		float sum[ 4 ];
  		sum[ 0 ] = 0.0;
  		sum[ 1 ] = 0.0;
  		sum[ 2 ] = 0.0;
  		sum[ 3 ] = 0.0;
  		int i;
  
  		for( i = 0; i < kl; i++ )
  		{
  			const float xx = flt[ i ];
  			sum[ 0 ] += xx * ip[ 0 ];
  			sum[ 1 ] += xx * ip[ 1 ];
  			sum[ 2 ] += xx * ip[ 2 ];
  			sum[ 3 ] += xx * ip[ 3 ];
  			ip += 4;
  		}
  
  		op[ 0 ] = sum[ 0 ];
  		op[ 1 ] = sum[ 1 ];
  		op[ 2 ] = sum[ 2 ];
  		op[ 3 ] = sum[ 3 ];
  		op += 4;
  		LANCIR_LF_POST
  	}
  
  	#undef LANCIR_LF_PRE
  	#undef LANCIR_LF_POST
  };
  
  #undef LANCIR_PI
  
  } // namespace avir
  
  #endif // AVIR_CLANCIR_INCLUDED
  

Download