/*
 * SDL - Simple DirectMedia Layer
 * CELL BE Support for PS3 Framebuffer
 * Copyright (C) 2008, 2009 International Business Machines Corporation
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
 * USA
 *
 *  Martin Lowinski  <lowinski [at] de [dot] ibm [ibm] com>
 *  Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com>
 *  SPE code based on research by:
 *  Rene Becker
 *  Thimo Emmerich
 */

#include "spu_common.h"

#include <spu_intrinsics.h>
#include <spu_mfcio.h>

// Debugging
//#define DEBUG

#ifdef DEBUG
#define deprintf(fmt, args... ) \
	fprintf( stdout, fmt, ##args ); \
	fflush( stdout );
#else
#define deprintf( fmt, args... )
#endif

struct scale_parms_t parms __attribute__((aligned(128)));

/* A maximum of 8 lines Y, therefore 4 lines V, 4 lines U are stored
 * there might be the need to retrieve misaligned data, adjust
 * incoming v and u plane to be able to handle this (add 128)
 */
unsigned char y_plane[2][(MAX_HDTV_WIDTH+128)*4] __attribute__((aligned(128)));
unsigned char v_plane[2][(MAX_HDTV_WIDTH+128)*2] __attribute__((aligned(128)));
unsigned char u_plane[2][(MAX_HDTV_WIDTH+128)*2] __attribute__((aligned(128)));

/* temp-buffer for scaling: 4 lines Y, therefore 2 lines V, 2 lines U */
unsigned char scaled_y_plane[2][MAX_HDTV_WIDTH*2] __attribute__((aligned(128)));
unsigned char scaled_v_plane[2][MAX_HDTV_WIDTH/2] __attribute__((aligned(128)));
unsigned char scaled_u_plane[2][MAX_HDTV_WIDTH/2] __attribute__((aligned(128)));

/* some vectors needed by the float to int conversion */
static const vector float vec_255 = { 255.0f, 255.0f, 255.0f, 255.0f };
static const vector float vec_0_1 = { 0.1f, 0.1f, 0.1f, 0.1f };

void bilinear_scale_line_w8(unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride);
void bilinear_scale_line_w16(unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride);

void scale_srcw16_dstw16();
void scale_srcw16_dstw32();
void scale_srcw32_dstw16();
void scale_srcw32_dstw32();

int main( unsigned long long spe_id __attribute__((unused)), unsigned long long argp )
{
	deprintf("[SPU] bilin_scaler_spu is up... (on SPE #%llu)\n", spe_id);
	/* DMA transfer for the input parameters */
	spu_mfcdma32(&parms, (unsigned int)argp, sizeof(struct scale_parms_t), TAG_INIT, MFC_GET_CMD);
	DMA_WAIT_TAG(TAG_INIT);

	deprintf("[SPU] Scale %ux%u to %ux%u\n", parms.src_pixel_width, parms.src_pixel_height,
			parms.dst_pixel_width, parms.dst_pixel_height);

	if(parms.src_pixel_width & 0x1f) {
		if(parms.dst_pixel_width & 0x1F) {
			deprintf("[SPU] Using scale_srcw16_dstw16\n");
			scale_srcw16_dstw16();
		} else {
			deprintf("[SPU] Using scale_srcw16_dstw32\n");
			scale_srcw16_dstw32();
		}
	} else {
		if(parms.dst_pixel_width & 0x1F) {
			deprintf("[SPU] Using scale_srcw32_dstw16\n");
			scale_srcw32_dstw16();
		} else {
			deprintf("[SPU] Using scale_srcw32_dstw32\n");
			scale_srcw32_dstw32();
		}
	}
	deprintf("[SPU] bilin_scaler_spu... done!\n");

	return 0;
}


/*
 * vfloat_to_vuint()
 *
 * converts a float vector to an unsinged int vector using saturated
 * arithmetic
 *
 * @param vec_s float vector for conversion
 * @returns converted unsigned int vector
 */
inline static vector unsigned int vfloat_to_vuint(vector float vec_s) {
	vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s);
	vec_s = spu_sel(vec_s, vec_0_1, select_1);

	vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255);
	vec_s = spu_sel(vec_s, vec_255, select_2);
	return spu_convtu(vec_s,0);
}


/*
 * scale_srcw16_dstw16()
 *
 * processes an input image of width 16
 * scaling is done to a width 16
 * result stored in RAM
 */
void scale_srcw16_dstw16() {
	// extract parameters
	unsigned char* dst_addr = (unsigned char *)parms.dstBuffer;

	unsigned int src_width = parms.src_pixel_width;
	unsigned int src_height = parms.src_pixel_height;
	unsigned int dst_width = parms.dst_pixel_width;
	unsigned int dst_height = parms.dst_pixel_height;

	// YVU
	unsigned int src_linestride_y = src_width;
	unsigned int src_dbl_linestride_y = src_width<<1;
	unsigned int src_linestride_vu = src_width>>1;
	unsigned int src_dbl_linestride_vu = src_width;

	// scaled YVU
	unsigned int scaled_src_linestride_y = dst_width;

	// ram addresses
	unsigned char* src_addr_y = parms.y_plane;
	unsigned char* src_addr_v = parms.v_plane;
	unsigned char* src_addr_u = parms.u_plane;

	// for handling misalignment, addresses are precalculated
	unsigned char* precalc_src_addr_v = src_addr_v;
	unsigned char* precalc_src_addr_u = src_addr_u;

	unsigned int dst_picture_size = dst_width*dst_height;

	// Sizes for destination
	unsigned int dst_dbl_linestride_y = dst_width<<1;
	unsigned int dst_dbl_linestride_vu = dst_width>>1;

	// Perform address calculation for Y, V and U in main memory with dst_addr as base
	unsigned char* dst_addr_main_memory_y = dst_addr;
	unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size;
	unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2);

	// calculate scale factors
	vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width );
	float y_scale = (float)src_height/(float)dst_height;

	// double buffered processing
	// buffer switching
	unsigned int curr_src_idx = 0;
	unsigned int curr_dst_idx = 0;
	unsigned int next_src_idx, next_dst_idx;

	// 2 lines y as output, upper and lowerline
	unsigned int curr_interpl_y_upper = 0;
	unsigned int next_interpl_y_upper;
	unsigned int curr_interpl_y_lower, next_interpl_y_lower;
	// only 1 line v/u output, both planes have the same dimension
	unsigned int curr_interpl_vu = 0;
	unsigned int next_interpl_vu;

	// weights, calculated in every loop iteration
	vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_y_upper;
	vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower;
	vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_vu;

	// line indices for the src picture
	float curr_src_y_upper = 0.0f, next_src_y_upper;
	float curr_src_y_lower, next_src_y_lower;
	float curr_src_vu = 0.0f, next_src_vu;

	// line indices for the dst picture
	unsigned int dst_y=0, dst_vu=0;

	// offset for the v and u plane to handle misalignement
	unsigned int curr_lsoff_v = 0, next_lsoff_v;
	unsigned int curr_lsoff_u = 0, next_lsoff_u;

	// calculate lower line indices
	curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale;
	curr_interpl_y_lower = (unsigned int)curr_src_y_lower;
	// lower line weight
	vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower );


	// start partially double buffered processing
	// get initial data, 2 sets of y, 1 set v, 1 set u
	mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 );
	mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y,
			(unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y),
			src_dbl_linestride_y,
			RETR_BUF,
			0, 0 );
	mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 );
	mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 );

	/* iteration loop
	 * within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved
	 * the scaled output is 2 lines y, 1 line v, 1 line u
	 * the yuv2rgb-converted output is stored to RAM
	 */
	for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) {
		dst_y = dst_vu<<1;

		// calculate next indices
		next_src_vu = ((float)dst_vu+1)*y_scale;
		next_src_y_upper = ((float)dst_y+2)*y_scale;
		next_src_y_lower = ((float)dst_y+3)*y_scale;

		next_interpl_vu = (unsigned int) next_src_vu;
		next_interpl_y_upper = (unsigned int) next_src_y_upper;
		next_interpl_y_lower = (unsigned int) next_src_y_lower;

		// calculate weight NORTH-SOUTH
		vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu );
		vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper );
		vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower );

		// get next lines
		next_src_idx = curr_src_idx^1;
		next_dst_idx = curr_dst_idx^1;

		// 4 lines y
		mfc_get( y_plane[next_src_idx],
				(unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );
		mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y,
				(unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );

		// 2 lines v
		precalc_src_addr_v = src_addr_v+(next_interpl_vu*src_linestride_vu);
		next_lsoff_v = ((unsigned int)precalc_src_addr_v)&0x0F;
		mfc_get( v_plane[next_src_idx],
				((unsigned int) precalc_src_addr_v)&0xFFFFFFF0,
				src_dbl_linestride_vu+(next_lsoff_v<<1),
				RETR_BUF+next_src_idx,
				0, 0 );
		// 2 lines u
		precalc_src_addr_u = src_addr_u+(next_interpl_vu*src_linestride_vu);
		next_lsoff_u = ((unsigned int)precalc_src_addr_u)&0x0F;
		mfc_get( u_plane[next_src_idx],
				((unsigned int) precalc_src_addr_u)&0xFFFFFFF0,
				src_dbl_linestride_vu+(next_lsoff_v<<1),
				RETR_BUF+next_src_idx,
				0, 0 );

		DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

		// scaling
		// work line y_upper
		bilinear_scale_line_w16( y_plane[curr_src_idx],
				scaled_y_plane[curr_src_idx],
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_upper,
				src_linestride_y );
		// work line y_lower
		bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
				scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_lower,
				src_linestride_y );
		// work line v
		bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v,
				scaled_v_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );
		// work line u
		bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u,
				scaled_u_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );


		// Store the result back to main memory into a destination buffer in YUV format
		//---------------------------------------------------------------------------------------------
		DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

		// Perform three DMA transfers to 3 different locations in the main memory!
		// dst_width:	Pixel width of destination image
		// dst_addr:	Destination address in main memory
		// dst_vu:	Counter which is incremented one by one
		// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)
		mfc_put(	scaled_y_plane[curr_src_idx],					// What from local store (addr)
				(unsigned int)dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
				dst_dbl_linestride_y,						// Two Y lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,						// Tag
				0, 0 );

		mfc_put(	scaled_v_plane[curr_src_idx],					// What from local store (addr)
				(unsigned int)dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,						// Two V lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,						// Tag
				0, 0 );

		mfc_put(	scaled_u_plane[curr_src_idx],					// What from local store (addr)
				(unsigned int)dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,						// Two U lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,						// Tag
				0, 0 );
		//---------------------------------------------------------------------------------------------


		// update for next cycle
		curr_src_idx = next_src_idx;
		curr_dst_idx = next_dst_idx;

		curr_interpl_y_upper = next_interpl_y_upper;
		curr_interpl_y_lower = next_interpl_y_lower;
		curr_interpl_vu = next_interpl_vu;

		vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper;
		vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower;
		vf_curr_NSweight_vu = vf_next_NSweight_vu;

		curr_src_y_upper = next_src_y_upper;
		curr_src_y_lower = next_src_y_lower;
		curr_src_vu = next_src_vu;

		curr_lsoff_v = next_lsoff_v;
		curr_lsoff_u = next_lsoff_u;
	}



	DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

	// scaling
	// work line y_upper
	bilinear_scale_line_w16( y_plane[curr_src_idx],
			scaled_y_plane[curr_src_idx],
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_upper,
			src_linestride_y );
	// work line y_lower
	bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
			scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_lower,
			src_linestride_y );
	// work line v
	bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v,
			scaled_v_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );
	// work line u
	bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u,
			scaled_u_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );


	// Store the result back to main memory into a destination buffer in YUV format
	//---------------------------------------------------------------------------------------------
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

	// Perform three DMA transfers to 3 different locations in the main memory!
	// dst_width:	Pixel width of destination image
	// dst_addr:	Destination address in main memory
	// dst_vu:	Counter which is incremented one by one
	// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)
	mfc_put(	scaled_y_plane[curr_src_idx],					// What from local store (addr)
			(unsigned int)dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
			dst_dbl_linestride_y,						// Two Y lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,						// Tag
			0, 0 );

	mfc_put(	scaled_v_plane[curr_src_idx],					// What from local store (addr)
			(unsigned int)dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,						// Two V lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,						// Tag
			0, 0 );

	mfc_put(	scaled_u_plane[curr_src_idx],					// What from local store (addr)
			(unsigned int)dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,						// Two U lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,						// Tag
			0, 0 );

	// wait for completion
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );
	//---------------------------------------------------------------------------------------------
}


/*
 * scale_srcw16_dstw32()
 *
 * processes an input image of width 16
 * scaling is done to a width 32
 * yuv2rgb conversion on a width of 32
 * result stored in RAM
 */
void scale_srcw16_dstw32() {
	// extract parameters
	unsigned char* dst_addr = (unsigned char *)parms.dstBuffer;

	unsigned int src_width = parms.src_pixel_width;
	unsigned int src_height = parms.src_pixel_height;
	unsigned int dst_width = parms.dst_pixel_width;
	unsigned int dst_height = parms.dst_pixel_height;

	// YVU
	unsigned int src_linestride_y = src_width;
	unsigned int src_dbl_linestride_y = src_width<<1;
	unsigned int src_linestride_vu = src_width>>1;
	unsigned int src_dbl_linestride_vu = src_width;
	// scaled YVU
	unsigned int scaled_src_linestride_y = dst_width;

	// ram addresses
	unsigned char* src_addr_y = parms.y_plane;
	unsigned char* src_addr_v = parms.v_plane;
	unsigned char* src_addr_u = parms.u_plane;

	unsigned int dst_picture_size = dst_width*dst_height;

	// Sizes for destination
	unsigned int dst_dbl_linestride_y = dst_width<<1;
	unsigned int dst_dbl_linestride_vu = dst_width>>1;

	// Perform address calculation for Y, V and U in main memory with dst_addr as base
	unsigned char* dst_addr_main_memory_y = dst_addr;
	unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size;
	unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2);


	// for handling misalignment, addresses are precalculated
	unsigned char* precalc_src_addr_v = src_addr_v;
	unsigned char* precalc_src_addr_u = src_addr_u;

	// calculate scale factors
	vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width );
	float y_scale = (float)src_height/(float)dst_height;

	// double buffered processing
	// buffer switching
	unsigned int curr_src_idx = 0;
	unsigned int curr_dst_idx = 0;
	unsigned int next_src_idx, next_dst_idx;

	// 2 lines y as output, upper and lowerline
	unsigned int curr_interpl_y_upper = 0;
	unsigned int next_interpl_y_upper;
	unsigned int curr_interpl_y_lower, next_interpl_y_lower;
	// only 1 line v/u output, both planes have the same dimension
	unsigned int curr_interpl_vu = 0;
	unsigned int next_interpl_vu;

	// weights, calculated in every loop iteration
	vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_y_upper;
	vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower;
	vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_vu;

	// line indices for the src picture
	float curr_src_y_upper = 0.0f, next_src_y_upper;
	float curr_src_y_lower, next_src_y_lower;
	float curr_src_vu = 0.0f, next_src_vu;

	// line indices for the dst picture
	unsigned int dst_y=0, dst_vu=0;

	// offset for the v and u plane to handle misalignement
	unsigned int curr_lsoff_v = 0, next_lsoff_v;
	unsigned int curr_lsoff_u = 0, next_lsoff_u;

	// calculate lower line idices
	curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale;
	curr_interpl_y_lower = (unsigned int)curr_src_y_lower;
	// lower line weight
	vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower );


	// start partially double buffered processing
	// get initial data, 2 sets of y, 1 set v, 1 set u
	mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 );
	mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y,
			(unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y),
			src_dbl_linestride_y,
			RETR_BUF,
			0, 0 );
	mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 );
	mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 );

	// iteration loop
	// within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved
	// the scaled output is 2 lines y, 1 line v, 1 line u
	// the yuv2rgb-converted output is stored to RAM
	for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) {
		dst_y = dst_vu<<1;

		// calculate next indices
		next_src_vu = ((float)dst_vu+1)*y_scale;
		next_src_y_upper = ((float)dst_y+2)*y_scale;
		next_src_y_lower = ((float)dst_y+3)*y_scale;

		next_interpl_vu = (unsigned int) next_src_vu;
		next_interpl_y_upper = (unsigned int) next_src_y_upper;
		next_interpl_y_lower = (unsigned int) next_src_y_lower;

		// calculate weight NORTH-SOUTH
		vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu );
		vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper );
		vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower );

		// get next lines
		next_src_idx = curr_src_idx^1;
		next_dst_idx = curr_dst_idx^1;

		// 4 lines y
		mfc_get( y_plane[next_src_idx],
				(unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );
		mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y,
				(unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );

		// 2 lines v
		precalc_src_addr_v = src_addr_v+(next_interpl_vu*src_linestride_vu);
		next_lsoff_v = ((unsigned int)precalc_src_addr_v)&0x0F;
		mfc_get( v_plane[next_src_idx],
				((unsigned int) precalc_src_addr_v)&0xFFFFFFF0,
				src_dbl_linestride_vu+(next_lsoff_v<<1),
				RETR_BUF+next_src_idx,
				0, 0 );
		// 2 lines u
		precalc_src_addr_u = src_addr_u+(next_interpl_vu*src_linestride_vu);
		next_lsoff_u = ((unsigned int)precalc_src_addr_u)&0x0F;
		mfc_get( u_plane[next_src_idx],
				((unsigned int) precalc_src_addr_u)&0xFFFFFFF0,
				src_dbl_linestride_vu+(next_lsoff_v<<1),
				RETR_BUF+next_src_idx,
				0, 0 );

		DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

		// scaling
		// work line y_upper
		bilinear_scale_line_w16( y_plane[curr_src_idx],
				scaled_y_plane[curr_src_idx],
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_upper,
				src_linestride_y );
		// work line y_lower
		bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
				scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_lower,
				src_linestride_y );
		// work line v
		bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v,
				scaled_v_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );
		// work line u
		bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u,
				scaled_u_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );

		//---------------------------------------------------------------------------------------------
		DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

		// Perform three DMA transfers to 3 different locations in the main memory!
		// dst_width:	Pixel width of destination image
		// dst_addr:	Destination address in main memory
		// dst_vu:	Counter which is incremented one by one
		// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

		mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int)  dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
				dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int)  dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );
		//---------------------------------------------------------------------------------------------


		// update for next cycle
		curr_src_idx = next_src_idx;
		curr_dst_idx = next_dst_idx;

		curr_interpl_y_upper = next_interpl_y_upper;
		curr_interpl_y_lower = next_interpl_y_lower;
		curr_interpl_vu = next_interpl_vu;

		vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper;
		vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower;
		vf_curr_NSweight_vu = vf_next_NSweight_vu;

		curr_src_y_upper = next_src_y_upper;
		curr_src_y_lower = next_src_y_lower;
		curr_src_vu = next_src_vu;

		curr_lsoff_v = next_lsoff_v;
		curr_lsoff_u = next_lsoff_u;
	}



	DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

	// scaling
	// work line y_upper
	bilinear_scale_line_w16( y_plane[curr_src_idx],
			scaled_y_plane[curr_src_idx],
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_upper,
			src_linestride_y );
	// work line y_lower
	bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
			scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_lower,
			src_linestride_y );
	// work line v
	bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v,
			scaled_v_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );
	// work line u
	bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u,
			scaled_u_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );

	//---------------------------------------------------------------------------------------------
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

	// Perform three DMA transfers to 3 different locations in the main memory!
	// dst_width:	Pixel width of destination image
	// dst_addr:	Destination address in main memory
	// dst_vu:	Counter which is incremented one by one
	// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

	mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
			dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	// wait for completion
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );
	//---------------------------------------------------------------------------------------------
}


/*
 * scale_srcw32_dstw16()
 *
 * processes an input image of width 32
 * scaling is done to a width 16
 * yuv2rgb conversion on a width of 16
 * result stored in RAM
 */
void scale_srcw32_dstw16() {
	// extract parameters
	unsigned char* dst_addr = (unsigned char *)parms.dstBuffer;

	unsigned int src_width = parms.src_pixel_width;
	unsigned int src_height = parms.src_pixel_height;
	unsigned int dst_width = parms.dst_pixel_width;
	unsigned int dst_height = parms.dst_pixel_height;

	// YVU
	unsigned int src_linestride_y = src_width;
	unsigned int src_dbl_linestride_y = src_width<<1;
	unsigned int src_linestride_vu = src_width>>1;
	unsigned int src_dbl_linestride_vu = src_width;
	// scaled YVU
	unsigned int scaled_src_linestride_y = dst_width;

	// ram addresses
	unsigned char* src_addr_y = parms.y_plane;
	unsigned char* src_addr_v = parms.v_plane;
	unsigned char* src_addr_u = parms.u_plane;

	unsigned int dst_picture_size = dst_width*dst_height;

	// Sizes for destination
	unsigned int dst_dbl_linestride_y = dst_width<<1;
	unsigned int dst_dbl_linestride_vu = dst_width>>1;

	// Perform address calculation for Y, V and U in main memory with dst_addr as base
	unsigned char* dst_addr_main_memory_y = dst_addr;
	unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size;
	unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2);

	// calculate scale factors
	vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width );
	float y_scale = (float)src_height/(float)dst_height;

	// double buffered processing
	// buffer switching
	unsigned int curr_src_idx = 0;
	unsigned int curr_dst_idx = 0;
	unsigned int next_src_idx, next_dst_idx;

	// 2 lines y as output, upper and lowerline
	unsigned int curr_interpl_y_upper = 0;
	unsigned int next_interpl_y_upper;
	unsigned int curr_interpl_y_lower, next_interpl_y_lower;
	// only 1 line v/u output, both planes have the same dimension
	unsigned int curr_interpl_vu = 0;
	unsigned int next_interpl_vu;

	// weights, calculated in every loop iteration
	vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_y_upper;
	vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower;
	vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_vu;

	// line indices for the src picture
	float curr_src_y_upper = 0.0f, next_src_y_upper;
	float curr_src_y_lower, next_src_y_lower;
	float curr_src_vu = 0.0f, next_src_vu;

	// line indices for the dst picture
	unsigned int dst_y=0, dst_vu=0;

	// calculate lower line idices
	curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale;
	curr_interpl_y_lower = (unsigned int)curr_src_y_lower;
	// lower line weight
	vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower );


	// start partially double buffered processing
	// get initial data, 2 sets of y, 1 set v, 1 set u
	mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 );
	mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y,
			(unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y),
			src_dbl_linestride_y,
			RETR_BUF,
			0, 0 );
	mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 );
	mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 );

	// iteration loop
	// within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved
	// the scaled output is 2 lines y, 1 line v, 1 line u
	// the yuv2rgb-converted output is stored to RAM
	for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) {
		dst_y = dst_vu<<1;

		// calculate next indices
		next_src_vu = ((float)dst_vu+1)*y_scale;
		next_src_y_upper = ((float)dst_y+2)*y_scale;
		next_src_y_lower = ((float)dst_y+3)*y_scale;

		next_interpl_vu = (unsigned int) next_src_vu;
		next_interpl_y_upper = (unsigned int) next_src_y_upper;
		next_interpl_y_lower = (unsigned int) next_src_y_lower;

		// calculate weight NORTH-SOUTH
		vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu );
		vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper );
		vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower );

		// get next lines
		next_src_idx = curr_src_idx^1;
		next_dst_idx = curr_dst_idx^1;

		// 4 lines y
		mfc_get( y_plane[next_src_idx],
				(unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );
		mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y,
				(unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );

		// 2 lines v
		mfc_get( v_plane[next_src_idx],
				(unsigned int) src_addr_v+(next_interpl_vu*src_linestride_vu),
				src_dbl_linestride_vu,
				RETR_BUF+next_src_idx,
				0, 0 );
		// 2 lines u
		mfc_get( u_plane[next_src_idx],
				(unsigned int) src_addr_u+(next_interpl_vu*src_linestride_vu),
				src_dbl_linestride_vu,
				RETR_BUF+next_src_idx,
				0, 0 );

		DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

		// scaling
		// work line y_upper
		bilinear_scale_line_w16( y_plane[curr_src_idx],
				scaled_y_plane[curr_src_idx],
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_upper,
				src_linestride_y );
		// work line y_lower
		bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
				scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_lower,
				src_linestride_y );
		// work line v
		bilinear_scale_line_w16( v_plane[curr_src_idx],
				scaled_v_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );
		// work line u
		bilinear_scale_line_w16( u_plane[curr_src_idx],
				scaled_u_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );

		//---------------------------------------------------------------------------------------------
		DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

		// Perform three DMA transfers to 3 different locations in the main memory!
		// dst_width:	Pixel width of destination image
		// dst_addr:	Destination address in main memory
		// dst_vu:	Counter which is incremented one by one
		// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

		mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int)  dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
				dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int)  dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );
		//---------------------------------------------------------------------------------------------


		// update for next cycle
		curr_src_idx = next_src_idx;
		curr_dst_idx = next_dst_idx;

		curr_interpl_y_upper = next_interpl_y_upper;
		curr_interpl_y_lower = next_interpl_y_lower;
		curr_interpl_vu = next_interpl_vu;

		vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper;
		vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower;
		vf_curr_NSweight_vu = vf_next_NSweight_vu;

		curr_src_y_upper = next_src_y_upper;
		curr_src_y_lower = next_src_y_lower;
		curr_src_vu = next_src_vu;
	}



	DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

	// scaling
	// work line y_upper
	bilinear_scale_line_w16( y_plane[curr_src_idx],
			scaled_y_plane[curr_src_idx],
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_upper,
			src_linestride_y );
	// work line y_lower
	bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
			scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_lower,
			src_linestride_y );
	// work line v
	bilinear_scale_line_w16( v_plane[curr_src_idx],
			scaled_v_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );
	// work line u
	bilinear_scale_line_w16( u_plane[curr_src_idx],
			scaled_u_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );


	//---------------------------------------------------------------------------------------------
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

	// Perform three DMA transfers to 3 different locations in the main memory!
	// dst_width:	Pixel width of destination image
	// dst_addr:	Destination address in main memory
	// dst_vu:	Counter which is incremented one by one
	// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

	mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
			dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	// wait for completion
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );
	//---------------------------------------------------------------------------------------------
}


/**
 * scale_srcw32_dstw32()
 *
 * processes an input image of width 32
 * scaling is done to a width 32
 * yuv2rgb conversion on a width of 32
 * result stored in RAM
 */
void scale_srcw32_dstw32() {
	// extract parameters
	unsigned char* dst_addr = (unsigned char *)parms.dstBuffer;

	unsigned int src_width = parms.src_pixel_width;
	unsigned int src_height = parms.src_pixel_height;
	unsigned int dst_width = parms.dst_pixel_width;
	unsigned int dst_height = parms.dst_pixel_height;

	// YVU
	unsigned int src_linestride_y = src_width;
	unsigned int src_dbl_linestride_y = src_width<<1;
	unsigned int src_linestride_vu = src_width>>1;
	unsigned int src_dbl_linestride_vu = src_width;

	// scaled YVU
	unsigned int scaled_src_linestride_y = dst_width;

	// ram addresses
	unsigned char* src_addr_y = parms.y_plane;
	unsigned char* src_addr_v = parms.v_plane;
	unsigned char* src_addr_u = parms.u_plane;

	unsigned int dst_picture_size = dst_width*dst_height;

	// Sizes for destination
	unsigned int dst_dbl_linestride_y = dst_width<<1;
	unsigned int dst_dbl_linestride_vu = dst_width>>1;

	// Perform address calculation for Y, V and U in main memory with dst_addr as base
	unsigned char* dst_addr_main_memory_y = dst_addr;
	unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size;
	unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2);

	// calculate scale factors
	vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width );
	float y_scale = (float)src_height/(float)dst_height;

	// double buffered processing
	// buffer switching
	unsigned int curr_src_idx = 0;
	unsigned int curr_dst_idx = 0;
	unsigned int next_src_idx, next_dst_idx;

	// 2 lines y as output, upper and lowerline
	unsigned int curr_interpl_y_upper = 0;
	unsigned int next_interpl_y_upper;
	unsigned int curr_interpl_y_lower, next_interpl_y_lower;
	// only 1 line v/u output, both planes have the same dimension
	unsigned int curr_interpl_vu = 0;
	unsigned int next_interpl_vu;

	// weights, calculated in every loop iteration
	vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_y_upper;
	vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower;
	vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f };
	vector float vf_next_NSweight_vu;

	// line indices for the src picture
	float curr_src_y_upper = 0.0f, next_src_y_upper;
	float curr_src_y_lower, next_src_y_lower;
	float curr_src_vu = 0.0f, next_src_vu;

	// line indices for the dst picture
	unsigned int dst_y=0, dst_vu=0;

	// calculate lower line idices
	curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale;
	curr_interpl_y_lower = (unsigned int)curr_src_y_lower;
	// lower line weight
	vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower );


	// start partially double buffered processing
	// get initial data, 2 sets of y, 1 set v, 1 set u
	mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 );
	mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y,
			(unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y),
			src_dbl_linestride_y,
			RETR_BUF,
			0, 0 );
	mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 );
	mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 );

	// iteration loop
	// within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved
	// the scaled output is 2 lines y, 1 line v, 1 line u
	// the yuv2rgb-converted output is stored to RAM
	for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) {
		dst_y = dst_vu<<1;

		// calculate next indices
		next_src_vu = ((float)dst_vu+1)*y_scale;
		next_src_y_upper = ((float)dst_y+2)*y_scale;
		next_src_y_lower = ((float)dst_y+3)*y_scale;

		next_interpl_vu = (unsigned int) next_src_vu;
		next_interpl_y_upper = (unsigned int) next_src_y_upper;
		next_interpl_y_lower = (unsigned int) next_src_y_lower;

		// calculate weight NORTH-SOUTH
		vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu );
		vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper );
		vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower );

		// get next lines
		next_src_idx = curr_src_idx^1;
		next_dst_idx = curr_dst_idx^1;

		// 4 lines y
		mfc_get( y_plane[next_src_idx],
				(unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );
		mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y,
				(unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y),
				src_dbl_linestride_y,
				RETR_BUF+next_src_idx,
				0, 0 );

		// 2 lines v
		mfc_get( v_plane[next_src_idx],
				(unsigned int) src_addr_v+(next_interpl_vu*src_linestride_vu),
				src_dbl_linestride_vu,
				RETR_BUF+next_src_idx,
				0, 0 );
		// 2 lines u
		mfc_get( u_plane[next_src_idx],
				(unsigned int) src_addr_u+(next_interpl_vu*src_linestride_vu),
				src_dbl_linestride_vu,
				RETR_BUF+next_src_idx,
				0, 0 );

		DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

		// scaling
		// work line y_upper
		bilinear_scale_line_w16( y_plane[curr_src_idx],
				scaled_y_plane[curr_src_idx],
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_upper,
				src_linestride_y );
		// work line y_lower
		bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
				scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
				dst_width,
				vf_x_scale,
				vf_curr_NSweight_y_lower,
				src_linestride_y );
		// work line v
		bilinear_scale_line_w16( v_plane[curr_src_idx],
				scaled_v_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );
		// work line u
		bilinear_scale_line_w16( u_plane[curr_src_idx],
				scaled_u_plane[curr_src_idx],
				dst_width>>1,
				vf_x_scale,
				vf_curr_NSweight_vu,
				src_linestride_vu );



		// Store the result back to main memory into a destination buffer in YUV format
		//---------------------------------------------------------------------------------------------
		DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

		// Perform three DMA transfers to 3 different locations in the main memory!
		// dst_width:	Pixel width of destination image
		// dst_addr:	Destination address in main memory
		// dst_vu:	Counter which is incremented one by one
		// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

		mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
				dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );

		mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
				(unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
				dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
				STR_BUF+curr_dst_idx,								// Tag
				0, 0 );
		//---------------------------------------------------------------------------------------------


		// update for next cycle
		curr_src_idx = next_src_idx;
		curr_dst_idx = next_dst_idx;

		curr_interpl_y_upper = next_interpl_y_upper;
		curr_interpl_y_lower = next_interpl_y_lower;
		curr_interpl_vu = next_interpl_vu;

		vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper;
		vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower;
		vf_curr_NSweight_vu = vf_next_NSweight_vu;

		curr_src_y_upper = next_src_y_upper;
		curr_src_y_lower = next_src_y_lower;
		curr_src_vu = next_src_vu;
	}



	DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) );

	// scaling
	// work line y_upper
	bilinear_scale_line_w16( y_plane[curr_src_idx],
			scaled_y_plane[curr_src_idx],
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_upper,
			src_linestride_y );
	// work line y_lower
	bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y,
			scaled_y_plane[curr_src_idx]+scaled_src_linestride_y,
			dst_width,
			vf_x_scale,
			vf_curr_NSweight_y_lower,
			src_linestride_y );
	// work line v
	bilinear_scale_line_w16( v_plane[curr_src_idx],
			scaled_v_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );
	// work line u
	bilinear_scale_line_w16( u_plane[curr_src_idx],
			scaled_u_plane[curr_src_idx],
			dst_width>>1,
			vf_x_scale,
			vf_curr_NSweight_vu,
			src_linestride_vu );


	// Store the result back to main memory into a destination buffer in YUV format
	//---------------------------------------------------------------------------------------------
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );

	// Perform three DMA transfers to 3 different locations in the main memory!
	// dst_width:	Pixel width of destination image
	// dst_addr:	Destination address in main memory
	// dst_vu:	Counter which is incremented one by one
	// dst_y:	Counter which is twice larger than dst_vu (dst_y = 2*dst_vu)

	mfc_put(	scaled_y_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y),	// Destination in main memory (addr)
			dst_dbl_linestride_y,								// Two Y lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_v_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu),	// Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two V lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	mfc_put(	scaled_u_plane[curr_src_idx],							// What from local store (addr)
			(unsigned int)  dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr)
			dst_dbl_linestride_vu,								// Two U lines (depending on the widht of the destination resolution)
			STR_BUF+curr_dst_idx,								// Tag
			0, 0 );

	// wait for completion
	DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) );
	//---------------------------------------------------------------------------------------------
}


/*
 * bilinear_scale_line_w8()
 *
 * processes a line of yuv-input, width has to be a multiple of 8
 * scaled yuv-output is written to local store buffer
 *
 * @param src buffer for 2 lines input
 * @param dst_ buffer for 1 line output
 * @param dst_width the width of the destination line
 * @param vf_x_scale a float vector, at each entry is the x_scale-factor
 * @param vf_NSweight a float vector, at each position is the weight NORTH/SOUTH for the current line
 * @param src_linestride the stride of the srcline
 */
void bilinear_scale_line_w8( unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride ) {

	unsigned char* dst = dst_;

	unsigned int dst_x;
	for( dst_x=0; dst_x<dst_width; dst_x+=8) {
		// address calculation for loading the 4 surrounding pixel of each calculated
		// destination pixel
		vector unsigned int vui_dst_x_tmp = spu_splats( dst_x );
		// lower range->first 4 pixel
		// upper range->next 4 pixel
		vector unsigned int vui_inc_dst_x_lower_range = { 0, 1, 2, 3 };
		vector unsigned int vui_inc_dst_x_upper_range = { 4, 5, 6, 7 };
		vector unsigned int vui_dst_x_lower_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_lower_range );
		vector unsigned int vui_dst_x_upper_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_upper_range );

		// calculate weight EAST-WEST
		vector float vf_dst_x_lower_range = spu_convtf( vui_dst_x_lower_range, 0 );
		vector float vf_dst_x_upper_range = spu_convtf( vui_dst_x_upper_range, 0 );
		vector float vf_src_x_lower_range = spu_mul( vf_dst_x_lower_range, vf_x_scale );
		vector float vf_src_x_upper_range = spu_mul( vf_dst_x_upper_range, vf_x_scale );
		vector unsigned int vui_interpl_x_lower_range = spu_convtu( vf_src_x_lower_range, 0 );
		vector unsigned int vui_interpl_x_upper_range = spu_convtu( vf_src_x_upper_range, 0 );
		vector float vf_interpl_x_lower_range = spu_convtf( vui_interpl_x_lower_range, 0 );
		vector float vf_interpl_x_upper_range = spu_convtf( vui_interpl_x_upper_range, 0 );
		vector float vf_EWweight_lower_range = spu_sub( vf_src_x_lower_range, vf_interpl_x_lower_range );
		vector float vf_EWweight_upper_range = spu_sub( vf_src_x_upper_range, vf_interpl_x_upper_range );

		// calculate address offset
		//
		// pixel NORTH WEST
		vector unsigned int vui_off_pixelNW_lower_range = vui_interpl_x_lower_range;
		vector unsigned int vui_off_pixelNW_upper_range = vui_interpl_x_upper_range;

		// pixel NORTH EAST-->(offpixelNW+1)
		vector unsigned int vui_add_1 = { 1, 1, 1, 1 };
		vector unsigned int vui_off_pixelNE_lower_range = spu_add( vui_off_pixelNW_lower_range, vui_add_1 );
		vector unsigned int vui_off_pixelNE_upper_range = spu_add( vui_off_pixelNW_upper_range, vui_add_1 );

		// SOUTH-WEST-->(offpixelNW+src_linestride)
		vector unsigned int vui_srclinestride = spu_splats( src_linestride );
		vector unsigned int vui_off_pixelSW_lower_range = spu_add( vui_srclinestride, vui_off_pixelNW_lower_range );
		vector unsigned int vui_off_pixelSW_upper_range = spu_add( vui_srclinestride, vui_off_pixelNW_upper_range );

		// SOUTH-EAST-->(offpixelNW+src_linestride+1)
		vector unsigned int vui_off_pixelSE_lower_range = spu_add( vui_srclinestride, vui_off_pixelNE_lower_range );
		vector unsigned int vui_off_pixelSE_upper_range = spu_add( vui_srclinestride, vui_off_pixelNE_upper_range );

		// calculate each address
		vector unsigned int vui_src_ls = spu_splats( (unsigned int) src );
		vector unsigned int vui_addr_pixelNW_lower_range = spu_add( vui_src_ls, vui_off_pixelNW_lower_range );
		vector unsigned int vui_addr_pixelNW_upper_range = spu_add( vui_src_ls, vui_off_pixelNW_upper_range );
		vector unsigned int vui_addr_pixelNE_lower_range = spu_add( vui_src_ls, vui_off_pixelNE_lower_range );
		vector unsigned int vui_addr_pixelNE_upper_range = spu_add( vui_src_ls, vui_off_pixelNE_upper_range );

		vector unsigned int vui_addr_pixelSW_lower_range = spu_add( vui_src_ls, vui_off_pixelSW_lower_range );
		vector unsigned int vui_addr_pixelSW_upper_range = spu_add( vui_src_ls, vui_off_pixelSW_upper_range );
		vector unsigned int vui_addr_pixelSE_lower_range = spu_add( vui_src_ls, vui_off_pixelSE_lower_range );
		vector unsigned int vui_addr_pixelSE_upper_range = spu_add( vui_src_ls, vui_off_pixelSE_upper_range );

		// get each pixel
		//
		// scalar load, afterwards insertion into the right position
		// NORTH WEST
		vector unsigned char null_vector = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
		vector unsigned char vuc_pixel_NW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 1 )),
				vuc_pixel_NW_lower_range, 7 );
		vuc_pixel_NW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 2 )),
				vuc_pixel_NW_lower_range, 11 );
		vuc_pixel_NW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 3 )),
				vuc_pixel_NW_lower_range, 15 );

		vector unsigned char vuc_pixel_NW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 1 )),
				vuc_pixel_NW_upper_range, 7 );
		vuc_pixel_NW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 2 )),
				vuc_pixel_NW_upper_range, 11 );
		vuc_pixel_NW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 3 )),
				vuc_pixel_NW_upper_range, 15 );

		// NORTH EAST
		vector unsigned char vuc_pixel_NE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 1 )),
				vuc_pixel_NE_lower_range, 7 );
		vuc_pixel_NE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 2 )),
				vuc_pixel_NE_lower_range, 11 );
		vuc_pixel_NE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 3 )),
				vuc_pixel_NE_lower_range, 15 );

		vector unsigned char vuc_pixel_NE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 1 )),
				vuc_pixel_NE_upper_range, 7 );
		vuc_pixel_NE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 2 )),
				vuc_pixel_NE_upper_range, 11 );
		vuc_pixel_NE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 3 )),
				vuc_pixel_NE_upper_range, 15 );


		// SOUTH WEST
		vector unsigned char vuc_pixel_SW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 1 )),
				vuc_pixel_SW_lower_range, 7 );
		vuc_pixel_SW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 2 )),
				vuc_pixel_SW_lower_range, 11 );
		vuc_pixel_SW_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 3 )),
				vuc_pixel_SW_lower_range, 15 );

		vector unsigned char vuc_pixel_SW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 1 )),
				vuc_pixel_SW_upper_range, 7 );
		vuc_pixel_SW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 2 )),
				vuc_pixel_SW_upper_range, 11 );
		vuc_pixel_SW_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 3 )),
				vuc_pixel_SW_upper_range, 15 );

		// SOUTH EAST
		vector unsigned char vuc_pixel_SE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 1 )),
				vuc_pixel_SE_lower_range, 7 );
		vuc_pixel_SE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 2 )),
				vuc_pixel_SE_lower_range, 11 );
		vuc_pixel_SE_lower_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 3 )),
				vuc_pixel_SE_lower_range, 15 );

		vector unsigned char vuc_pixel_SE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 1 )),
				vuc_pixel_SE_upper_range, 7 );
		vuc_pixel_SE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 2 )),
				vuc_pixel_SE_upper_range, 11 );
		vuc_pixel_SE_upper_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 3 )),
				vuc_pixel_SE_upper_range, 15 );


		// convert to float
		vector float vf_pixel_NW_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_lower_range, 0 );
		vector float vf_pixel_NW_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_upper_range, 0 );

		vector float vf_pixel_SW_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_lower_range, 0 );
		vector float vf_pixel_SW_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_upper_range, 0 );

		vector float vf_pixel_NE_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_lower_range, 0 );
		vector float vf_pixel_NE_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_upper_range, 0 );

		vector float vf_pixel_SE_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_lower_range, 0 );
		vector float vf_pixel_SE_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_upper_range, 0 );



		// first linear interpolation: EWtop
		// EWtop = NW + EWweight*(NE-NW)
		//
		// lower range
		vector float vf_EWtop_lower_range_tmp = spu_sub( vf_pixel_NE_lower_range, vf_pixel_NW_lower_range );
		vector float vf_EWtop_lower_range = spu_madd( vf_EWweight_lower_range,
								vf_EWtop_lower_range_tmp,
								vf_pixel_NW_lower_range );

		// upper range
		vector float vf_EWtop_upper_range_tmp = spu_sub( vf_pixel_NE_upper_range, vf_pixel_NW_upper_range );
		vector float vf_EWtop_upper_range = spu_madd( vf_EWweight_upper_range,
								vf_EWtop_upper_range_tmp,
								vf_pixel_NW_upper_range );



		// second linear interpolation: EWbottom
		// EWbottom = SW + EWweight*(SE-SW)
		//
		// lower range
		vector float vf_EWbottom_lower_range_tmp = spu_sub( vf_pixel_SE_lower_range, vf_pixel_SW_lower_range );
		vector float vf_EWbottom_lower_range = spu_madd( vf_EWweight_lower_range,
								vf_EWbottom_lower_range_tmp,
								vf_pixel_SW_lower_range );

		// upper range
		vector float vf_EWbottom_upper_range_tmp = spu_sub( vf_pixel_SE_upper_range, vf_pixel_SW_upper_range );
		vector float vf_EWbottom_upper_range = spu_madd( vf_EWweight_upper_range,
								vf_EWbottom_upper_range_tmp,
								vf_pixel_SW_upper_range );



		// third linear interpolation: the bilinear interpolated value
		// result = EWtop + NSweight*(EWbottom-EWtop);
		//
		// lower range
		vector float vf_result_lower_range_tmp = spu_sub( vf_EWbottom_lower_range, vf_EWtop_lower_range );
		vector float vf_result_lower_range = spu_madd( vf_NSweight,
								vf_result_lower_range_tmp,
								vf_EWtop_lower_range );

		// upper range
		vector float vf_result_upper_range_tmp = spu_sub( vf_EWbottom_upper_range, vf_EWtop_upper_range );
		vector float vf_result_upper_range = spu_madd( vf_NSweight,
								vf_result_upper_range_tmp,
								vf_EWtop_upper_range );


		// convert back: using saturated arithmetic
		vector unsigned int vui_result_lower_range = vfloat_to_vuint( vf_result_lower_range );
		vector unsigned int vui_result_upper_range = vfloat_to_vuint( vf_result_upper_range );

		// merge results->lower,upper
		vector unsigned char vuc_mask_merge_result = { 0x03, 0x07, 0x0B, 0x0F,
							       0x13, 0x17, 0x1B, 0x1F,
							       0x00, 0x00, 0x00, 0x00,
							       0x00, 0x00, 0x00, 0x00 };

		vector unsigned char vuc_result = spu_shuffle( (vector unsigned char) vui_result_lower_range,
								(vector unsigned char) vui_result_upper_range,
								vuc_mask_merge_result );

		// partial storing
		vector unsigned char vuc_mask_out = { 0x00, 0x00, 0x00, 0x00,
						      0x00, 0x00, 0x00, 0x00,
						      0xFF, 0xFF, 0xFF, 0xFF,
						      0xFF, 0xFF, 0xFF, 0xFF };


		// get currently stored data
		vector unsigned char vuc_orig = *((vector unsigned char*)dst);

		// clear currently stored data
		vuc_orig = spu_and( vuc_orig,
				spu_rlqwbyte( vuc_mask_out, ((unsigned int)dst)&0x0F) );

		// rotate result according to storing address
		vuc_result = spu_rlqwbyte( vuc_result, ((unsigned int)dst)&0x0F );

		// store result
		*((vector unsigned char*)dst) = spu_or( vuc_result,
							vuc_orig );
		dst += 8;
	}
}


/*
 * bilinear_scale_line_w16()
 *
 * processes a line of yuv-input, width has to be a multiple of 16
 * scaled yuv-output is written to local store buffer
 *
 * @param src buffer for 2 lines input
 * @param dst_ buffer for 1 line output
 * @param dst_width the width of the destination line
 * @param vf_x_scale a float vector, at each entry is the x_scale-factor
 * @param vf_NSweight a float vector, at each position is the weight NORTH/SOUTH for the current line
 * @param src_linestride the stride of the srcline
 */
void bilinear_scale_line_w16( unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride ) {

	unsigned char* dst = dst_;

	unsigned int dst_x;
	for( dst_x=0; dst_x<dst_width; dst_x+=16) {
		// address calculation for loading the 4 surrounding pixel of each calculated
		// destination pixel
		vector unsigned int vui_dst_x_tmp = spu_splats( dst_x );
		// parallelised processing
		// first range->pixel 1 2 3 4
		// second range->pixel 5 6 7 8
		// third range->pixel 9 10 11 12
		// fourth range->pixel 13 14 15 16
		vector unsigned int vui_inc_dst_x_first_range = { 0, 1, 2, 3 };
		vector unsigned int vui_inc_dst_x_second_range = { 4, 5, 6, 7 };
		vector unsigned int vui_inc_dst_x_third_range = { 8, 9, 10, 11 };
		vector unsigned int vui_inc_dst_x_fourth_range = { 12, 13, 14, 15 };
		vector unsigned int vui_dst_x_first_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_first_range );
		vector unsigned int vui_dst_x_second_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_second_range );
		vector unsigned int vui_dst_x_third_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_third_range );
		vector unsigned int vui_dst_x_fourth_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_fourth_range );

		// calculate weight EAST-WEST
		vector float vf_dst_x_first_range = spu_convtf( vui_dst_x_first_range, 0 );
		vector float vf_dst_x_second_range = spu_convtf( vui_dst_x_second_range, 0 );
		vector float vf_dst_x_third_range = spu_convtf( vui_dst_x_third_range, 0 );
		vector float vf_dst_x_fourth_range = spu_convtf( vui_dst_x_fourth_range, 0 );
		vector float vf_src_x_first_range = spu_mul( vf_dst_x_first_range, vf_x_scale );
		vector float vf_src_x_second_range = spu_mul( vf_dst_x_second_range, vf_x_scale );
		vector float vf_src_x_third_range = spu_mul( vf_dst_x_third_range, vf_x_scale );
		vector float vf_src_x_fourth_range = spu_mul( vf_dst_x_fourth_range, vf_x_scale );
		vector unsigned int vui_interpl_x_first_range = spu_convtu( vf_src_x_first_range, 0 );
		vector unsigned int vui_interpl_x_second_range = spu_convtu( vf_src_x_second_range, 0 );
		vector unsigned int vui_interpl_x_third_range = spu_convtu( vf_src_x_third_range, 0 );
		vector unsigned int vui_interpl_x_fourth_range = spu_convtu( vf_src_x_fourth_range, 0 );
		vector float vf_interpl_x_first_range = spu_convtf( vui_interpl_x_first_range, 0 );
		vector float vf_interpl_x_second_range = spu_convtf( vui_interpl_x_second_range, 0 );
		vector float vf_interpl_x_third_range = spu_convtf( vui_interpl_x_third_range, 0 );
		vector float vf_interpl_x_fourth_range = spu_convtf( vui_interpl_x_fourth_range, 0 );
		vector float vf_EWweight_first_range = spu_sub( vf_src_x_first_range, vf_interpl_x_first_range );
		vector float vf_EWweight_second_range = spu_sub( vf_src_x_second_range, vf_interpl_x_second_range );
		vector float vf_EWweight_third_range = spu_sub( vf_src_x_third_range, vf_interpl_x_third_range );
		vector float vf_EWweight_fourth_range = spu_sub( vf_src_x_fourth_range, vf_interpl_x_fourth_range );

		// calculate address offset
		//
		// pixel NORTH WEST
		vector unsigned int vui_off_pixelNW_first_range = vui_interpl_x_first_range;
		vector unsigned int vui_off_pixelNW_second_range = vui_interpl_x_second_range;
		vector unsigned int vui_off_pixelNW_third_range = vui_interpl_x_third_range;
		vector unsigned int vui_off_pixelNW_fourth_range = vui_interpl_x_fourth_range;

		// pixel NORTH EAST-->(offpixelNW+1)
		vector unsigned int vui_add_1 = { 1, 1, 1, 1 };
		vector unsigned int vui_off_pixelNE_first_range = spu_add( vui_off_pixelNW_first_range, vui_add_1 );
		vector unsigned int vui_off_pixelNE_second_range = spu_add( vui_off_pixelNW_second_range, vui_add_1 );
		vector unsigned int vui_off_pixelNE_third_range = spu_add( vui_off_pixelNW_third_range, vui_add_1 );
		vector unsigned int vui_off_pixelNE_fourth_range = spu_add( vui_off_pixelNW_fourth_range, vui_add_1 );

		// SOUTH-WEST-->(offpixelNW+src_linestride)
		vector unsigned int vui_srclinestride = spu_splats( src_linestride );
		vector unsigned int vui_off_pixelSW_first_range = spu_add( vui_srclinestride, vui_off_pixelNW_first_range );
		vector unsigned int vui_off_pixelSW_second_range = spu_add( vui_srclinestride, vui_off_pixelNW_second_range );
		vector unsigned int vui_off_pixelSW_third_range = spu_add( vui_srclinestride, vui_off_pixelNW_third_range );
		vector unsigned int vui_off_pixelSW_fourth_range = spu_add( vui_srclinestride, vui_off_pixelNW_fourth_range );

		// SOUTH-EAST-->(offpixelNW+src_linestride+1)
		vector unsigned int vui_off_pixelSE_first_range = spu_add( vui_srclinestride, vui_off_pixelNE_first_range );
		vector unsigned int vui_off_pixelSE_second_range = spu_add( vui_srclinestride, vui_off_pixelNE_second_range );
		vector unsigned int vui_off_pixelSE_third_range = spu_add( vui_srclinestride, vui_off_pixelNE_third_range );
		vector unsigned int vui_off_pixelSE_fourth_range = spu_add( vui_srclinestride, vui_off_pixelNE_fourth_range );

		// calculate each address
		vector unsigned int vui_src_ls = spu_splats( (unsigned int) src );
		vector unsigned int vui_addr_pixelNW_first_range = spu_add( vui_src_ls, vui_off_pixelNW_first_range );
		vector unsigned int vui_addr_pixelNW_second_range = spu_add( vui_src_ls, vui_off_pixelNW_second_range );
		vector unsigned int vui_addr_pixelNW_third_range = spu_add( vui_src_ls, vui_off_pixelNW_third_range );
		vector unsigned int vui_addr_pixelNW_fourth_range = spu_add( vui_src_ls, vui_off_pixelNW_fourth_range );

		vector unsigned int vui_addr_pixelNE_first_range = spu_add( vui_src_ls, vui_off_pixelNE_first_range );
		vector unsigned int vui_addr_pixelNE_second_range = spu_add( vui_src_ls, vui_off_pixelNE_second_range );
		vector unsigned int vui_addr_pixelNE_third_range = spu_add( vui_src_ls, vui_off_pixelNE_third_range );
		vector unsigned int vui_addr_pixelNE_fourth_range = spu_add( vui_src_ls, vui_off_pixelNE_fourth_range );

		vector unsigned int vui_addr_pixelSW_first_range = spu_add( vui_src_ls, vui_off_pixelSW_first_range );
		vector unsigned int vui_addr_pixelSW_second_range = spu_add( vui_src_ls, vui_off_pixelSW_second_range );
		vector unsigned int vui_addr_pixelSW_third_range = spu_add( vui_src_ls, vui_off_pixelSW_third_range );
		vector unsigned int vui_addr_pixelSW_fourth_range = spu_add( vui_src_ls, vui_off_pixelSW_fourth_range );

		vector unsigned int vui_addr_pixelSE_first_range = spu_add( vui_src_ls, vui_off_pixelSE_first_range );
		vector unsigned int vui_addr_pixelSE_second_range = spu_add( vui_src_ls, vui_off_pixelSE_second_range );
		vector unsigned int vui_addr_pixelSE_third_range = spu_add( vui_src_ls, vui_off_pixelSE_third_range );
		vector unsigned int vui_addr_pixelSE_fourth_range = spu_add( vui_src_ls, vui_off_pixelSE_fourth_range );


		// get each pixel
		//
		// scalar load, afterwards insertion into the right position
		// NORTH WEST
		// first range
		vector unsigned char null_vector = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
		vector unsigned char vuc_pixel_NW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 1 )),
				vuc_pixel_NW_first_range, 7 );
		vuc_pixel_NW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 2 )),
				vuc_pixel_NW_first_range, 11 );
		vuc_pixel_NW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 3 )),
				vuc_pixel_NW_first_range, 15 );
		// second range
		vector unsigned char vuc_pixel_NW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 1 )),
				vuc_pixel_NW_second_range, 7 );
		vuc_pixel_NW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 2 )),
				vuc_pixel_NW_second_range, 11 );
		vuc_pixel_NW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 3 )),
				vuc_pixel_NW_second_range, 15 );
		// third range
		vector unsigned char vuc_pixel_NW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 1 )),
				vuc_pixel_NW_third_range, 7 );
		vuc_pixel_NW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 2 )),
				vuc_pixel_NW_third_range, 11 );
		vuc_pixel_NW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 3 )),
				vuc_pixel_NW_third_range, 15 );
		// fourth range
		vector unsigned char vuc_pixel_NW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 0 )), null_vector, 3 );
		vuc_pixel_NW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 1 )),
				vuc_pixel_NW_fourth_range, 7 );
		vuc_pixel_NW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 2 )),
				vuc_pixel_NW_fourth_range, 11 );
		vuc_pixel_NW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 3 )),
				vuc_pixel_NW_fourth_range, 15 );

		// NORTH EAST
		// first range
		vector unsigned char vuc_pixel_NE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 1 )),
				vuc_pixel_NE_first_range, 7 );
		vuc_pixel_NE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 2 )),
				vuc_pixel_NE_first_range, 11 );
		vuc_pixel_NE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 3 )),
				vuc_pixel_NE_first_range, 15 );
		// second range
		vector unsigned char vuc_pixel_NE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 1 )),
				vuc_pixel_NE_second_range, 7 );
		vuc_pixel_NE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 2 )),
				vuc_pixel_NE_second_range, 11 );
		vuc_pixel_NE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 3 )),
				vuc_pixel_NE_second_range, 15 );
		// third range
		vector unsigned char vuc_pixel_NE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 1 )),
				vuc_pixel_NE_third_range, 7 );
		vuc_pixel_NE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 2 )),
				vuc_pixel_NE_third_range, 11 );
		vuc_pixel_NE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 3 )),
				vuc_pixel_NE_third_range, 15 );
		// fourth range
		vector unsigned char vuc_pixel_NE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 0 )), null_vector, 3 );
		vuc_pixel_NE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 1 )),
				vuc_pixel_NE_fourth_range, 7 );
		vuc_pixel_NE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 2 )),
				vuc_pixel_NE_fourth_range, 11 );
		vuc_pixel_NE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 3 )),
				vuc_pixel_NE_fourth_range, 15 );

		// SOUTH WEST
		// first range
		vector unsigned char vuc_pixel_SW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 1 )),
				vuc_pixel_SW_first_range, 7 );
		vuc_pixel_SW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 2 )),
				vuc_pixel_SW_first_range, 11 );
		vuc_pixel_SW_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 3 )),
				vuc_pixel_SW_first_range, 15 );
		// second range
		vector unsigned char vuc_pixel_SW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 1 )),
				vuc_pixel_SW_second_range, 7 );
		vuc_pixel_SW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 2 )),
				vuc_pixel_SW_second_range, 11 );
		vuc_pixel_SW_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 3 )),
				vuc_pixel_SW_second_range, 15 );
		// third range
		vector unsigned char vuc_pixel_SW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 1 )),
				vuc_pixel_SW_third_range, 7 );
		vuc_pixel_SW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 2 )),
				vuc_pixel_SW_third_range, 11 );
		vuc_pixel_SW_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 3 )),
				vuc_pixel_SW_third_range, 15 );
		// fourth range
		vector unsigned char vuc_pixel_SW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 0 )), null_vector, 3 );
		vuc_pixel_SW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 1 )),
				vuc_pixel_SW_fourth_range, 7 );
		vuc_pixel_SW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 2 )),
				vuc_pixel_SW_fourth_range, 11 );
		vuc_pixel_SW_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 3 )),
				vuc_pixel_SW_fourth_range, 15 );

		// NORTH EAST
		// first range
		vector unsigned char vuc_pixel_SE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 1 )),
				vuc_pixel_SE_first_range, 7 );
		vuc_pixel_SE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 2 )),
				vuc_pixel_SE_first_range, 11 );
		vuc_pixel_SE_first_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 3 )),
				vuc_pixel_SE_first_range, 15 );
		// second range
		vector unsigned char vuc_pixel_SE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 1 )),
				vuc_pixel_SE_second_range, 7 );
		vuc_pixel_SE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 2 )),
				vuc_pixel_SE_second_range, 11 );
		vuc_pixel_SE_second_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 3 )),
				vuc_pixel_SE_second_range, 15 );
		// third range
		vector unsigned char vuc_pixel_SE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 1 )),
				vuc_pixel_SE_third_range, 7 );
		vuc_pixel_SE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 2 )),
				vuc_pixel_SE_third_range, 11 );
		vuc_pixel_SE_third_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 3 )),
				vuc_pixel_SE_third_range, 15 );
		// fourth range
		vector unsigned char vuc_pixel_SE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 0 )), null_vector, 3 );
		vuc_pixel_SE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 1 )),
				vuc_pixel_SE_fourth_range, 7 );
		vuc_pixel_SE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 2 )),
				vuc_pixel_SE_fourth_range, 11 );
		vuc_pixel_SE_fourth_range = spu_insert(
				*((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 3 )),
				vuc_pixel_SE_fourth_range, 15 );



		// convert to float
		vector float vf_pixel_NW_first_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_first_range, 0 );
		vector float vf_pixel_NW_second_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_second_range, 0 );
		vector float vf_pixel_NW_third_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_third_range, 0 );
		vector float vf_pixel_NW_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_fourth_range, 0 );

		vector float vf_pixel_NE_first_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_first_range, 0 );
		vector float vf_pixel_NE_second_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_second_range, 0 );
		vector float vf_pixel_NE_third_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_third_range, 0 );
		vector float vf_pixel_NE_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_fourth_range, 0 );

		vector float vf_pixel_SW_first_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_first_range, 0 );
		vector float vf_pixel_SW_second_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_second_range, 0 );
		vector float vf_pixel_SW_third_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_third_range, 0 );
		vector float vf_pixel_SW_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_fourth_range, 0 );

		vector float vf_pixel_SE_first_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_first_range, 0 );
		vector float vf_pixel_SE_second_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_second_range, 0 );
		vector float vf_pixel_SE_third_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_third_range, 0 );
		vector float vf_pixel_SE_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_fourth_range, 0 );

		// first linear interpolation: EWtop
		// EWtop = NW + EWweight*(NE-NW)
		//
		// first range
		vector float vf_EWtop_first_range_tmp = spu_sub( vf_pixel_NE_first_range, vf_pixel_NW_first_range );
		vector float vf_EWtop_first_range = spu_madd( vf_EWweight_first_range,
								vf_EWtop_first_range_tmp,
								vf_pixel_NW_first_range );

		// second range
		vector float vf_EWtop_second_range_tmp = spu_sub( vf_pixel_NE_second_range, vf_pixel_NW_second_range );
		vector float vf_EWtop_second_range = spu_madd( vf_EWweight_second_range,
								vf_EWtop_second_range_tmp,
								vf_pixel_NW_second_range );

		// third range
		vector float vf_EWtop_third_range_tmp = spu_sub( vf_pixel_NE_third_range, vf_pixel_NW_third_range );
		vector float vf_EWtop_third_range = spu_madd( vf_EWweight_third_range,
								vf_EWtop_third_range_tmp,
								vf_pixel_NW_third_range );

		// fourth range
		vector float vf_EWtop_fourth_range_tmp = spu_sub( vf_pixel_NE_fourth_range, vf_pixel_NW_fourth_range );
		vector float vf_EWtop_fourth_range = spu_madd( vf_EWweight_fourth_range,
								vf_EWtop_fourth_range_tmp,
								vf_pixel_NW_fourth_range );



		// second linear interpolation: EWbottom
		// EWbottom = SW + EWweight*(SE-SW)
		//
		// first range
		vector float vf_EWbottom_first_range_tmp = spu_sub( vf_pixel_SE_first_range, vf_pixel_SW_first_range );
		vector float vf_EWbottom_first_range = spu_madd( vf_EWweight_first_range,
								vf_EWbottom_first_range_tmp,
								vf_pixel_SW_first_range );

		// second range
		vector float vf_EWbottom_second_range_tmp = spu_sub( vf_pixel_SE_second_range, vf_pixel_SW_second_range );
		vector float vf_EWbottom_second_range = spu_madd( vf_EWweight_second_range,
								vf_EWbottom_second_range_tmp,
								vf_pixel_SW_second_range );
		// first range
		vector float vf_EWbottom_third_range_tmp = spu_sub( vf_pixel_SE_third_range, vf_pixel_SW_third_range );
		vector float vf_EWbottom_third_range = spu_madd( vf_EWweight_third_range,
								vf_EWbottom_third_range_tmp,
								vf_pixel_SW_third_range );

		// first range
		vector float vf_EWbottom_fourth_range_tmp = spu_sub( vf_pixel_SE_fourth_range, vf_pixel_SW_fourth_range );
		vector float vf_EWbottom_fourth_range = spu_madd( vf_EWweight_fourth_range,
								vf_EWbottom_fourth_range_tmp,
								vf_pixel_SW_fourth_range );



		// third linear interpolation: the bilinear interpolated value
		// result = EWtop + NSweight*(EWbottom-EWtop);
		//
		// first range
		vector float vf_result_first_range_tmp = spu_sub( vf_EWbottom_first_range, vf_EWtop_first_range );
		vector float vf_result_first_range = spu_madd( vf_NSweight,
								vf_result_first_range_tmp,
								vf_EWtop_first_range );

		// second range
		vector float vf_result_second_range_tmp = spu_sub( vf_EWbottom_second_range, vf_EWtop_second_range );
		vector float vf_result_second_range = spu_madd( vf_NSweight,
								vf_result_second_range_tmp,
								vf_EWtop_second_range );

		// third range
		vector float vf_result_third_range_tmp = spu_sub( vf_EWbottom_third_range, vf_EWtop_third_range );
		vector float vf_result_third_range = spu_madd( vf_NSweight,
								vf_result_third_range_tmp,
								vf_EWtop_third_range );

		// fourth range
		vector float vf_result_fourth_range_tmp = spu_sub( vf_EWbottom_fourth_range, vf_EWtop_fourth_range );
		vector float vf_result_fourth_range = spu_madd( vf_NSweight,
								vf_result_fourth_range_tmp,
								vf_EWtop_fourth_range );



		// convert back: using saturated arithmetic
		vector unsigned int vui_result_first_range = vfloat_to_vuint( vf_result_first_range );
		vector unsigned int vui_result_second_range = vfloat_to_vuint( vf_result_second_range );
		vector unsigned int vui_result_third_range = vfloat_to_vuint( vf_result_third_range );
		vector unsigned int vui_result_fourth_range = vfloat_to_vuint( vf_result_fourth_range );

		// merge results->lower,upper
		vector unsigned char vuc_mask_merge_result_first_second = { 0x03, 0x07, 0x0B, 0x0F,
							       		    0x13, 0x17, 0x1B, 0x1F,
							       		    0x00, 0x00, 0x00, 0x00,
							       		    0x00, 0x00, 0x00, 0x00 };

		vector unsigned char vuc_mask_merge_result_third_fourth = { 0x00, 0x00, 0x00, 0x00,
							       		    0x00, 0x00, 0x00, 0x00,
									    0x03, 0x07, 0x0B, 0x0F,
							       		    0x13, 0x17, 0x1B, 0x1F };

		vector unsigned char vuc_result_first_second =
						spu_shuffle( (vector unsigned char) vui_result_first_range,
								 (vector unsigned char) vui_result_second_range,
								vuc_mask_merge_result_first_second );

		vector unsigned char vuc_result_third_fourth =
						spu_shuffle( (vector unsigned char) vui_result_third_range,
								 (vector unsigned char) vui_result_fourth_range,
								vuc_mask_merge_result_third_fourth );

		// store result
		*((vector unsigned char*)dst) = spu_or( vuc_result_first_second,
							vuc_result_third_fourth );
		dst += 16;
	}
}