// sveconv.c
//
// Version 2.00 Datei hinzugefügt am 30.05.2001
//
// Funktion SVEconv420to422 (30.05.2001): Vertikale 1:2 Interpolation 
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV420
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV422
//
// Funktion SVEfast420to422 (04.06.2001): Vertikale 1:2 Interpolation, nur jede zweite Zeile
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV420
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV422
//
// Funktion SVEconv422to444 (30.05.2001): Horizontale 1:2 Interpolation 
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV422
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV444
//
// Funktion SVEconv444to422 (30.05.2001): Horizontales 2:1 Downsampling 
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV444
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV422
//
// Funktion SVEconv422to420 (30.05.2001): Vertikales 2:1 Downsampling 
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV444
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV422
//
// Funktion SVEfast444to420 (04.06.2001): Schnelle Interpolation der U/V-Layer
// input: u,v-Buffer (Jeweils unsigned char*) -> Originalstream im Format YUV444
//        Width,Height (long) -> Breite und Höhe des Originalstreams
// output:u,v-Buffer (Jeweils unsigned char*) -> Ausgabe im Format YUV420
//


#include <windows.h>
#include "config.h"
#include "global.h"

void SVEconv420to422(unsigned char* lpUin,unsigned char* lpVin,
					 unsigned char* lpUout,unsigned char* lpVout,
					 long iWidth,long iHeight)
{
	long w, h, j2, jm0;
	long jm6, jm5, jm4, jm3, jm2, jm1, jp1, jp2, jp3, jp4, jp5, jp6, jp7;
	unsigned char *pUin, *pVin, *pUout, *pVout;

	__asm
	{	
		mov eax, dword ptr [iWidth]
		sar eax, 0x01
		mov dword ptr [w], eax			// w = iWidth>>1

		mov eax, dword ptr [iHeight]
		sar eax, 0x01
		mov dword ptr [h], eax			// h = iHeight>>1

		mov edi, 0						// edi = Zeilenzähler
	Schleife1:

		mov eax, edi					// eax = j
		mov ecx, dword ptr [h]			// ecx = h
		sub ecx, 0x01
		mov edx, ecx					// edx = h (Vergleichsfeld)

		// jm0 ist j * w
		mov ebx, eax
		imul ebx, w
		mov dword ptr [jm0], ebx

		// Felder jm6 bis jm1 errechnen
		xor ebx, ebx
		cmp eax, 0x06
		jle Tagjm6nok
		mov ebx, eax
		sub ebx, 0x06
	Tagjm6nok:
		imul ebx, w
		mov dword ptr [jm6], ebx		// jm6 = (j<6) ? 0 : j-6;

		xor ebx, ebx
		cmp eax, 0x05
		jle Tagjm5nok
		mov ebx, eax
		sub ebx, 0x05
	Tagjm5nok:
		imul ebx, w
		mov dword ptr [jm5], ebx

		xor ebx, ebx
		cmp eax, 0x04
		jle Tagjm4nok
		mov ebx, eax
		sub ebx, 0x04
	Tagjm4nok:
		imul ebx, w
		mov dword ptr [jm4], ebx

		xor ebx, ebx
		cmp eax, 0x03
		jle Tagjm3nok
		mov ebx, eax
		sub ebx, 0x03
	Tagjm3nok:
		imul ebx, w
		mov dword ptr [jm3], ebx

		xor ebx, ebx
		cmp eax, 0x02
		jle Tagjm2nok
		mov ebx, eax
		sub ebx, 0x02
	Tagjm2nok:
		imul ebx, w
		mov dword ptr [jm2], ebx

		xor ebx, ebx
		cmp eax, 0x01
		jle Tagjm1nok
		mov ebx, eax
		sub ebx, 0x01
	Tagjm1nok:
		imul ebx, w
		mov dword ptr [jm1], ebx
 
	    // Felder jp1 bis jp7 errechnen
		mov ebx, ecx
		cmp eax, edx					// j < h - 1
		jge Tagjp1nok
		mov ebx, eax
		add ebx, 0x01
	Tagjp1nok:
		imul ebx, w
		mov dword ptr [jp1], ebx		// jp1 = (j<h-1) ? j+1 : h-1;

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp2nok
		mov ebx, eax
		add ebx, 0x02
	Tagjp2nok:
		imul ebx, w
		mov dword ptr [jp2], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp3nok
		mov ebx, eax
		add ebx, 0x03
	Tagjp3nok:
		imul ebx, w
		mov dword ptr [jp3], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp4nok
		mov ebx, eax
		add ebx, 0x04
	Tagjp4nok:
		imul ebx, w
		mov dword ptr [jp4], ebx
      
		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp5nok
		mov ebx, eax
		add ebx, 0x05
	Tagjp5nok:
		imul ebx, w
		mov dword ptr [jp5], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp6nok
		mov ebx, eax
		add ebx, 0x06
	Tagjp6nok:
		imul ebx, w
		mov dword ptr [jp6], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp7nok
		mov ebx, eax
		add ebx, 0x07
	Tagjp7nok:
		imul ebx, w
		mov dword ptr [jp7], ebx

		sal eax, 0x01
		mov dword ptr [j2], eax			// j2 = j<<1;

		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin], eax		// pUin = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin], eax		// pVin = lpVin;

		mov esi, 0						// esi = Spaltenzähler
		// for (i=0; i<w; i++)
	Schleife2:

		// Polyphase FIR filter coefficients (*256): 2 -10 35 242 -18 5 
        // New polyphase FIR filter coefficients (*256): 1 -7 30 248 -21 5 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add ecx, ebx					// ecx+= pUin[w*jm6]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add edx, ebx					// edx+= pVin[w*jm6]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add ecx, ebx					// ecx+=30*pUin[w*jm2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add edx, ebx					// edx+=30*pVin[w*jm2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add ecx, ebx					// ecx+=248*pUin[w*j]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add edx, ebx					// edx+=248*pVin[w*j]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add ecx, ebx					// ecx+=5*pUin[w*jp4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add edx, ebx					// edx+=5*pVin[w*jp4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub ecx, ebx					// ecx-=7*pUin[w*jm4]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub edx, ebx					// edx-=7*pVin[w*jm4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub ecx, ebx					// ecx-=21*pUin[w*jp2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub edx, ebx					// edx-=21*pVin[w*jp2]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU1ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU1nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU1ok
	TagU1nok:
		xor ecx, ecx					// ecx = 0
	TagU1ok:
		mov eax, dword ptr [j2]
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*j2]
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV1ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV1nok
		mov edx, 0xff					// edx = 255
		jmp TagV1ok
	TagV1nok:
		xor edx, edx					// edx = 0
	TagV1ok:
		mov eax, dword ptr [j2]
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*j2]
		mov byte ptr [eax], dl


        // Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 
        // New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add ecx, ebx					// ecx+= 7*pUin[w*jm4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add edx, ebx					// edx+= 7*pVin[w*jm4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add ecx, ebx					// ecx+=194*pUin[w*j]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add edx, ebx					// edx+=194*pVin[w*j]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add ecx, ebx					// ecx+=110*pUin[w*jp2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add edx, ebx					// edx+=110*pVin[w*jp2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add ecx, ebx					// ecx+=4*pUin[w*jp6]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add edx, ebx					// edx+=4*pVin[w*jp6]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub ecx, ebx					// ecx-=35*pUin[w*jm2]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub edx, ebx					// edx-=35*pVin[w*jm2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub ecx, ebx					// ecx-=24*pUin[w*jp4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub edx, ebx					// edx-=24*pVin[w*jp4]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU2ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU2nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU2ok
	TagU2nok:
		xor ecx, ecx					// ecx = 0
	TagU2ok:
		mov eax, dword ptr [j2]
		add eax, 0x02
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*(j2+2)]
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV2ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV2nok
		mov edx, 0xff					// edx = 255
		jmp TagV2ok
	TagV2nok:
		xor edx, edx					// edx = 0
	TagV2ok:
		mov eax, dword ptr [j2]
		add eax, 0x02
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*(j2+2)]
		mov byte ptr [eax], dl


        // Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 
        // New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add ecx, ebx					// ecx+=7*pUin[w*jp5]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add edx, ebx					// edx+=7*pVin[w*jp5]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add ecx, ebx					// ecx+=194*pUin[w*jp1]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add edx, ebx					// edx+=194*pVin[w*jp1]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add ecx, ebx					// ecx+=110*lppUin[w*jm1]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add edx, ebx					// edx+=110*lppVin[w*jm1]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add ecx, ebx					// ecx+=4*pUin[w*jm5]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add edx, ebx					// edx+=4*pVin[w*jm5]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub ecx, ebx					// ecx-=35*pUin[w*jp3]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jp3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub edx, ebx					// edx-=35*pUin[w*jp3]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub ecx, ebx					// ecx-=24*pUin[w*jm3]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub edx, ebx					// edx-=24*pVin[w*jm3]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU3ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU3nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU3ok
	TagU3nok:
		xor ecx, ecx					// ecx = 0
	TagU3ok:
		mov eax, dword ptr [j2]
		add eax, 0x01
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*(j2+1)]
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV3ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV3nok
		mov edx, 0xff					// edx = 255
		jmp TagV3ok
	TagV3nok:
		xor edx, edx					// edx = 0
	TagV3ok:
		mov eax, dword ptr [j2]
		add eax, 0x01
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*(j2+1)]
		mov byte ptr [eax], dl


        // Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 
        // New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp7]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add ecx, ebx					// ecx+=pUin[w*jp7]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp7]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add edx, ebx					// edx+=pVin[w*jp7]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add ecx, ebx					// ecx+=30*pUin[w*jp3]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add edx, ebx					// edx+=30*pVin[w*jp3]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add ecx, ebx					// ecx+=248*pUin[w*jp1]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add edx, ebx					// edx+=248*pVin[w*jp1]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add ecx, ebx					// ecx+=5*pUin[w*jm3]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add edx, ebx					// edx+=5*pVin[w*jm3]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub ecx, ebx					// ecx-=7*pUin[w*jp5]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jp5]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub edx, ebx					// edx-=7*pVin[w*jp5]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub ecx, ebx					// ecx-=21*pUin[w*jm1]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub edx, ebx					// edx-=21*pVin[w*jm1]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU4ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU4nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU4ok
	TagU4nok:
		xor ecx, ecx					// ecx = 0
	TagU4ok:
		mov eax, dword ptr [j2]
		add eax, 0x03
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*(j2+3)]
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV4ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV4nok
		mov edx, 0xff					// edx = 255
		jmp TagV4ok
	TagV4nok:
		xor edx, edx					// edx = 0
	TagV4ok:
		mov eax, dword ptr [j2]
		add eax, 0x03
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*(j2+3)]
		mov byte ptr [eax], dl

		inc dword ptr [pUin]
		inc dword ptr [pVin]
		inc dword ptr [pUout]
		inc dword ptr [pVout]

		add esi, 0x01
		cmp esi, w
		jl Schleife2

		add edi, 0x02
		cmp edi, h
		jl Schleife1

		emms
	}
}

void SVEfast420to422(unsigned char* lpUin,unsigned char* lpVin,
					  unsigned char* lpUout,unsigned char* lpVout,
					  long iWidth,long iHeight)
{
	long w, h, j2, jm0;
	long jm6, jm5, jm4, jm3, jm2, jm1, jp1, jp2, jp3, jp4, jp5, jp6, jp7;
	unsigned char *pUin, *pVin, *pUout, *pVout;

	__asm
	{	
		mov eax, dword ptr [iWidth]
		sar eax, 0x01
		mov dword ptr [w], eax			// w = iWidth>>1

		mov eax, dword ptr [iHeight]
		sar eax, 0x01
		mov dword ptr [h], eax			// h = iHeight>>1

		mov edi, 0						// edi = Zeilenzähler
	Schleife1:

		mov eax, edi					// eax = j
		mov ecx, dword ptr [h]			// ecx = h
		sub ecx, 0x01
		mov edx, ecx					// edx = h (Vergleichsfeld)

		// jm0 ist j * w
		mov ebx, eax
		imul ebx, w
		mov dword ptr [jm0], ebx

		// Felder jm6 bis jm1 errechnen
		xor ebx, ebx
		cmp eax, 0x06
		jle Tagjm6nok
		mov ebx, eax
		sub ebx, 0x06
	Tagjm6nok:
		imul ebx, w
		mov dword ptr [jm6], ebx		// jm6 = (j<6) ? 0 : j-6;

		xor ebx, ebx
		cmp eax, 0x05
		jle Tagjm5nok
		mov ebx, eax
		sub ebx, 0x05
	Tagjm5nok:
		imul ebx, w
		mov dword ptr [jm5], ebx

		xor ebx, ebx
		cmp eax, 0x04
		jle Tagjm4nok
		mov ebx, eax
		sub ebx, 0x04
	Tagjm4nok:
		imul ebx, w
		mov dword ptr [jm4], ebx

		xor ebx, ebx
		cmp eax, 0x03
		jle Tagjm3nok
		mov ebx, eax
		sub ebx, 0x03
	Tagjm3nok:
		imul ebx, w
		mov dword ptr [jm3], ebx

		xor ebx, ebx
		cmp eax, 0x02
		jle Tagjm2nok
		mov ebx, eax
		sub ebx, 0x02
	Tagjm2nok:
		imul ebx, w
		mov dword ptr [jm2], ebx

		xor ebx, ebx
		cmp eax, 0x01
		jle Tagjm1nok
		mov ebx, eax
		sub ebx, 0x01
	Tagjm1nok:
		imul ebx, w
		mov dword ptr [jm1], ebx
 

	    // Felder jp1 bis jp7 errechnen
		mov ebx, ecx
		cmp eax, edx					// j < h - 1
		jge Tagjp1nok
		mov ebx, eax
		add ebx, 0x01
	Tagjp1nok:
		imul ebx, w
		mov dword ptr [jp1], ebx		// jp1 = (j<h-1) ? j+1 : h-1;

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp2nok
		mov ebx, eax
		add ebx, 0x02
	Tagjp2nok:
		imul ebx, w
		mov dword ptr [jp2], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp3nok
		mov ebx, eax
		add ebx, 0x03
	Tagjp3nok:
		imul ebx, w
		mov dword ptr [jp3], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp4nok
		mov ebx, eax
		add ebx, 0x04
	Tagjp4nok:
		imul ebx, w
		mov dword ptr [jp4], ebx
      
		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp5nok
		mov ebx, eax
		add ebx, 0x05
	Tagjp5nok:
		imul ebx, w
		mov dword ptr [jp5], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp6nok
		mov ebx, eax
		add ebx, 0x06
	Tagjp6nok:
		imul ebx, w
		mov dword ptr [jp6], ebx

		sub edx, 0x01
		mov ebx, ecx
		cmp eax, edx
		jge Tagjp7nok
		mov ebx, eax
		add ebx, 0x07
	Tagjp7nok:
		imul ebx, w
		mov dword ptr [jp7], ebx

		sal eax, 0x01
		mov dword ptr [j2], eax			// j2 = j<<1;

		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin], eax		// pUin = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin], eax		// pVin = lpVin;

		mov esi, 0						// esi = Spaltenzähler
		// for (i=0; i<w; i++)
	Schleife2:

		// Polyphase FIR filter coefficients (*256): 2 -10 35 242 -18 5 
        // New polyphase FIR filter coefficients (*256): 1 -7 30 248 -21 5 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add ecx, ebx					// ecx+= pUin[w*jm6]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		add edx, ebx					// edx+= pVin[w*jm6]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add ecx, ebx					// ecx+=30*pUin[w*jm2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x1e
		add edx, ebx					// edx+=30*pVin[w*jm2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add ecx, ebx					// ecx+=248*pUin[w*j]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xf8
		add edx, ebx					// edx+=248*pVin[w*j]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add ecx, ebx					// ecx+=5*pUin[w*jp4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x05
		add edx, ebx					// edx+=5*pVin[w*jp4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub ecx, ebx					// ecx-=7*pUin[w*jm4]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		sub edx, ebx					// edx-=7*pVin[w*jm4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub ecx, ebx					// ecx-=21*pUin[w*jp2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x15
		sub edx, ebx					// edx-=21*pVin[w*jp2]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU1ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU1nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU1ok
	TagU1nok:
		xor ecx, ecx					// ecx = 0
	TagU1ok:
		mov eax, dword ptr [j2]
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*j2]
		mov byte ptr [eax], cl
		add eax, w
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV1ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV1nok
		mov edx, 0xff					// edx = 255
		jmp TagV1ok
	TagV1nok:
		xor edx, edx					// edx = 0
	TagV1ok:
		mov eax, dword ptr [j2]
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*j2]
		mov byte ptr [eax], dl
		add eax, w
		mov byte ptr [eax], dl


        // Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 
        // New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U
		mov edx, 0x80					// edx = 128	Summand für V

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add ecx, ebx					// ecx+= 7*pUin[w*jm4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x07
		add edx, ebx					// edx+= 7*pVin[w*jm4]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add ecx, ebx					// ecx+=194*pUin[w*j]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0xc2
		add edx, ebx					// edx+=194*pVin[w*j]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add ecx, ebx					// ecx+=110*pUin[w*jp2]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x6e
		add edx, ebx					// edx+=110*pVin[w*jp2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add ecx, ebx					// ecx+=4*pUin[w*jp6]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp6]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x04
		add edx, ebx					// edx+=4*pVin[w*jp6]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub ecx, ebx					// ecx-=35*pUin[w*jm2]
		mov eax, dword ptr [pVin]
		add eax, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x23
		sub edx, ebx					// edx-=35*pVin[w*jm2]

		mov eax, dword ptr [pUin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub ecx, ebx					// ecx-=24*pUin[w*jp4]
		mov eax, dword ptr [pVin]		
		add eax, dword ptr [jp4]
		xor ebx, ebx
		mov bl, byte ptr [eax]
		imul ebx, 0x18
		sub edx, ebx					// edx-=24*pVin[w*jp4]

		sar ecx, 0x08					// ecx >> 8
		sar edx, 0x08					// edx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagU2ok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagU2nok
		mov ecx, 0xff					// ecx = 255
		jmp TagU2ok
	TagU2nok:
		xor ecx, ecx					// ecx = 0
	TagU2ok:
		mov eax, dword ptr [j2]
		add eax, 0x02
		imul eax, w
		add eax, dword ptr [pUout]		// eax = pUout[w*(j2+2)]
		mov byte ptr [eax], cl
		add eax, w
		mov byte ptr [eax], cl

		cmp edx, 0x0100					// edx > 256 ?
		jl TagV2ok
		cmp edx, 0x1000					// edx < 0 ?
		jl TagV2nok
		mov edx, 0xff					// edx = 255
		jmp TagV2ok
	TagV2nok:
		xor edx, edx					// edx = 0
	TagV2ok:
		mov eax, dword ptr [j2]
		add eax, 0x02
		imul eax, w
		add eax, dword ptr [pVout]		// eax = pVout[w*(j2+2)]
		mov byte ptr [eax], dl
		add eax, w
		mov byte ptr [eax], dl

		add dword ptr [pUin], 0x01
		add dword ptr [pVin], 0x01
		add dword ptr [pUout], 0x01
		add dword ptr [pVout], 0x01

		add esi, 0x01
		cmp esi, w
		jl Schleife2

		add edi, 0x02
		cmp edi, h
		jl Schleife1

		emms
	}
}


void SVEconv422to444(unsigned char* lpUin,unsigned char* lpVin,
					 unsigned char* lpUout,unsigned char* lpVout,
					 long iWidth,long iHeight)
{
	long i, i2, w, j, im2, im1, ip1, ip2, ip3;
	unsigned char *pUin, *pVin, *pUout, *pVout;

	_asm
	{
		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin], eax		// pUin = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin], eax		// pVin = lpVin;

		mov eax, dword ptr [iWidth]
		sar eax, 0x01
		mov dword ptr [w], eax			// w = iWidth>>1

		mov dword ptr [j], 0			// j = 0
	Schleife1:
		mov dword ptr [i], 0			// i = 0
	Schleife2:
		mov eax, dword ptr [i]			// eax = i
		mov ecx, dword ptr [w]			// ecx = w
		mov edx, dword ptr [w]			// edx = w (Vergleichsfeld)

		cmp eax, 0x01
		jge Tagim1ok
		mov ebx, 0x0
		jmp Tagim1nok
	Tagim1ok:
		mov ebx, eax
		sub ebx, 0x01
	Tagim1nok:
		mov dword ptr [im1], ebx		// im1 = (i<1) ? 0 : i-1;

		cmp eax, 0x02
		jge Tagim2ok
		mov ebx, 0x0
		jmp Tagim2nok
	Tagim2ok:
		mov ebx, eax
		sub ebx, 0x02
	Tagim2nok:
		mov dword ptr [im2], ebx		// im2 = (i<2) ? 0 : i-2;

		sub edx, 0x01
		cmp eax, edx					// i < w-1
		jge Tagip1ok
		mov ebx, eax
		add ebx, 0x01
		jmp Tagip1nok
	Tagip1ok:
		mov ebx, ecx
		sub ebx, 0x01
	Tagip1nok:
		mov dword ptr [ip1], ebx		// ip1 = (i<w-1) ? i+1 : w-1;
		    
		sub edx, 0x01
		cmp eax, edx					// i < w-2
		jge Tagip2ok
		mov ebx, eax
		add ebx, 0x02
		jmp Tagip2nok
	Tagip2ok:
		mov ebx, ecx
		sub ebx, 0x01
	Tagip2nok:
		mov dword ptr [ip2], ebx		// ip2 = (i<w-2) ? i+2 : w-1;
		    
		sub edx, 0x01
		cmp eax, edx					// i < w-3
		jge Tagip3ok
		mov ebx, eax
		add ebx, 0x03
		jmp Tagip3nok
	Tagip3ok:
		mov ebx, ecx
		sub ebx, 0x01
	Tagip3nok:
		mov dword ptr [ip3], ebx		// ip3 = (i<w-3) ? i+3 : w-1;
		    
		sal eax, 0x01
		mov dword ptr [i2], eax			// i2 = i<<1;
		
		mov eax, dword ptr [i]
		add eax, dword ptr [pUin]
		mov ebx, dword ptr [i2]
		add ebx, dword ptr [pUout]
		mov cl, byte ptr [eax]
		mov byte ptr [ebx], cl // pUout[i2]=pUin[i]

		mov eax, dword ptr [i]
		add eax, dword ptr [pVin]
		mov ebx, dword ptr [i2]
		add ebx, dword ptr [pVout]
		mov cl, byte ptr [eax]
		mov byte ptr [ebx], cl // pVout[i2]=pVin[i]

		/* FIR filter coefficients (*256): 21 0 -52 0 159 256 159 0 -52 0 21 */
        /* even samples (0 0 256 0 0) */
		/* odd samples (21 -52 159 159 -52 21) */

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für U

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [im2]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x15
		add ecx, eax					// ecx+=21*(src1[im2]+src1[ip3]

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [i]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x9f
		add ecx, eax					// ecx+=159*(src1[i]+src1[ip1])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [im1]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip2]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x34
		sub ecx, eax					// ecx-=52*(src1[im1]+src1[ip2]

		sar ecx, 0x08					// ecx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagUok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagUnok
		mov ecx, 0xff					// ecx = 255
		jmp TagUok
	TagUnok:
		xor ecx, ecx					// ecx = 0
	TagUok:
		mov eax, dword ptr [i2]
		add eax, 0x01
		add eax, dword ptr [pUout]		// eax = dst1[i2+1]
		mov byte ptr [eax], cl

		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0x80					// ecx = 128	Summand für V

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [im2]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x15
		add ecx, eax					// ecx+=21*(src1[im2]+src1[ip3]

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [i]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x9f
		add ecx, eax					// ecx+=159*(src1[i]+src1[ip1])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [im1]
		xor eax, eax
		mov al, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip2]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x34
		sub ecx, eax					// ecx-=52*(src1[im1]+src1[ip2]

		sar ecx, 0x08					// ecx >> 8

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagVok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagVnok
		mov ecx, 0xff					// ecx = 255
		jmp TagVok
	TagVnok:
		xor ecx, ecx					// ecx = 0
	TagVok:
		mov eax, dword ptr [i2]
		add eax, 0x01
		add eax, dword ptr [pVout]		// eax = dst1[i2+1]
		mov byte ptr [eax], cl

		mov eax, dword ptr [i]
		add eax, 0x01
		mov dword ptr [i], eax
		cmp eax, w
		jl Schleife2

		mov eax, dword ptr [w]
		add dword ptr [pUin], eax
		add dword ptr [pVin], eax
		mov eax, dword ptr [iWidth]
		add dword ptr [pUout], eax
		add dword ptr [pVout], eax

		mov eax, dword ptr [j]
		add eax, 0x01
		mov dword ptr [j], eax
		cmp eax, iHeight
		jl Schleife1
	
		emms
	}
}

void SVEconv444to422(unsigned char* lpUin,unsigned char* lpVin,
					 unsigned char* lpUout,unsigned char* lpVout,
					 long iWidth,long iHeight)
{
	long j,i,i2,im1,im3,im5,ip1,ip3,ip5;
	unsigned char *pUin,*pVin,*pUout,*pVout;

	_asm
	{
		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin], eax		// pUin = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin], eax		// pVin = lpVin;

		mov dword ptr [j], 0			// j = 0 (Zeilenzähler)
	Schleife1:
		mov dword ptr [i], 0			// i = 0 (Spaltenzähler)
	Schleife2:
		mov eax, dword ptr [i]			// eax = i
		mov ecx, dword ptr [iWidth]		// ecx = iWidth - 1
		sub ecx, 0x01
		mov edx, ecx					// edx = iWidth - 1 (Vergleichsfeld)

		cmp eax, 0x01
		jge Tagim1ok
		mov ebx, 0x0
		jmp Tagim1nok
	Tagim1ok:
		mov ebx, eax
		sub ebx, 0x01
	Tagim1nok:
		mov dword ptr [im1], ebx		// im1 = (i<1) ? 0 : i-1;

		cmp eax, 0x03
		jge Tagim3ok
		mov ebx, 0x0
		jmp Tagim3nok
	Tagim3ok:
		mov ebx, eax
		sub ebx, 0x03
	Tagim3nok:
		mov dword ptr [im3], ebx		// im3 = (i<3) ? 0 : i-3;

		cmp eax, 0x05
		jge Tagim5ok
		mov ebx, 0x0
		jmp Tagim5nok
	Tagim5ok:
		mov ebx, eax
		sub ebx, 0x05
	Tagim5nok:
		mov dword ptr [im5], ebx		// im5 = (i<5) ? 0 : i-5;

		cmp eax, edx					// i < w-1
		jl Tagip1ok
		mov ebx, ecx
		jmp Tagip1nok
	Tagip1ok:
		mov ebx, eax
		add ebx, 0x01
	Tagip1nok:
		mov dword ptr [ip1], ebx		// ip1 = (i<iWidth-1) ? i+1 : w-1;

		sub edx, 0x02
		cmp eax, edx					// i < w-3
		jl Tagip3ok
		mov ebx, ecx
		jmp Tagip3nok
	Tagip3ok:
		mov ebx, eax
		add ebx, 0x03
	Tagip3nok:
		mov dword ptr [ip3], ebx		// ip3 = (i<iWidth-3) ? i+3 : w-1;
			
		sub edx, 0x02
		cmp eax, edx					// i < w-5
		jl Tagip5ok
		mov ebx, ecx
		jmp Tagip5nok
	Tagip5ok:
		mov ebx, eax
		add ebx, 0x05
	Tagip5nok:
		mov dword ptr [ip5], ebx		// ip5 = (i<iWidth-5) ? i+5 : w-1;
			
		sar eax, 0x01
		mov dword ptr [i2], eax			// i2 = i>>1;

		/* FIR filter coefficients (*512): 22 0 -52 0 159 256 159 0 -52 0 22 */
		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0xff					// ecx = 256	Summand für U

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [i]
		xor eax, eax
		mov al, byte ptr [edx]
		iMul eax, 0xff
		add ecx, eax					// ecx+=256*(pUin[i])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [im5]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip5]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x16
		add ecx, eax					// ecx+=22*(pUin[im5]+pUin[ip5])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [im1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip1]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x9f
		add ecx, eax					// ecx+=159*(pUin[im1]+pUin[ip1])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [im3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [ip3]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x34
		sub ecx, eax					// ecx-=52*(pUin[im3]+pUin[ip3])

		sar ecx, 0x09					// ecx >> 9

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagUok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagUnok
		mov ecx, 0xff					// ecx = 255
		jmp TagUok
	TagUnok:
		xor ecx, ecx					// ecx = 0
	TagUok:
		mov eax, dword ptr [pUout]		// eax = dst1[i2+1]
		add eax, dword ptr [i2]
		mov byte ptr [eax], cl

		mov ecx, 0xff					// ecx = 256	Summand für V

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [i]
		xor eax, eax
		mov al, byte ptr [edx]
		iMul eax, 0xff
		add ecx, eax					// ecx+=256*(pVin[i])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [im5]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip5]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x16
		add ecx, eax					// ecx+=22*(pVin[im5]+pVin[ip5])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [im1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip1]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x9f
		add ecx, eax					// ecx+=159*(pVin[im1]+pVin[ip1])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [im3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [ip3]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x34
		sub ecx, eax					// ecx-=52*(pVin[im3]+pVin[ip3])

		sar ecx, 0x09					// ecx >> 9

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagVok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagVnok
		mov ecx, 0xff					// ecx = 255
		jmp TagVok
	TagVnok:
		xor ecx, ecx					// ecx = 0
	TagVok:
		mov eax, dword ptr [pVout]		// eax = dst1[i2+1]
		add eax, dword ptr [i2]
		mov byte ptr [eax], cl

		mov eax, dword ptr [i]
		add eax, 0x02
		mov dword ptr [i], eax
		cmp eax, iWidth
		jl Schleife2

		mov eax, dword ptr [iWidth]
		add dword ptr [pUin], eax
		add dword ptr [pVin], eax
		sar eax, 0x01
		add dword ptr [pUout], eax
		add dword ptr [pVout], eax

		mov eax, dword ptr [j]
		add eax, 0x01
		mov dword ptr [j], eax
		cmp eax, iHeight
		jl Schleife1
	
		emms
	}
}

void SVEconv422to420(unsigned char* lpUin,unsigned char* lpVin,
					 unsigned char* lpUout,unsigned char* lpVout,
					 long iWidth,long iHeight)
{
	long w, i, j, jm0, jm5, jm4, jm3, jm2, jm1;
	long jp1, jp2, jp3, jp4, jp5, jp6;
	unsigned char *pUin,*pVin,*pUout,*pVout;

	_asm
	{
		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [iWidth]
		sar eax, 0x01
		mov dword ptr [w], eax			// w = iWidth >> 1

		mov dword ptr [j], 0			// j = 0 (Zeilenzähler)
	Schleife1:

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin], eax		// pUin = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin], eax		// pVin = lpVin;

		mov eax, dword ptr [j]			// eax = j
		mov ecx, dword ptr [iHeight]	// ecx = iHeight - 1
		sub ecx, 0x01
		mov edx, ecx					// edx = iHeight - 1 (Vergleichsfeld)

		// Achtung, hier werden alle Werte mit w multipliziert,
		// da sich der Sourcepointer immer auf den gesamten Frame bezieht
		mov ebx, eax
		iMul ebx, w
		mov dword ptr [jm0], ebx		// jm0 = j;

		cmp eax, 0x01
		jge Tagjm1ok
		xor ebx, ebx
		jmp Tagjm1nok
	Tagjm1ok:
		mov ebx, eax
		sub ebx, 0x01
	Tagjm1nok:
		iMul ebx, w
		mov dword ptr [jm1], ebx		// jm1 = (j<1) ? 0 : j-1;

		cmp eax, 0x02
		jge Tagjm2ok
		xor ebx, ebx
		jmp Tagjm2nok
	Tagjm2ok:
		mov ebx, eax
		sub ebx, 0x02
	Tagjm2nok:
		iMul ebx, w
		mov dword ptr [jm2], ebx		// jm2 = (j<2) ? 0 : j-2;

		cmp eax, 0x03
		jge Tagjm3ok
		xor ebx, ebx
		jmp Tagjm3nok
	Tagjm3ok:
		mov ebx, eax
		sub ebx, 0x03
	Tagjm3nok:
		iMul ebx, w
		mov dword ptr [jm3], ebx		// jm3 = (j<3) ? 0 : j-3;

		cmp eax, 0x04
		jge Tagjm4ok
		xor ebx, ebx
		jmp Tagjm4nok
	Tagjm4ok:
		mov ebx, eax
		sub ebx, 0x04
	Tagjm4nok:
		iMul ebx, w
		mov dword ptr [jm4], ebx		// jm4 = (j<4) ? 0 : j-4;

		cmp eax, 0x05
		jge Tagjm5ok
		xor ebx, ebx
		jmp Tagjm5nok
	Tagjm5ok:
		mov ebx, eax
		sub ebx, 0x05
	Tagjm5nok:
		iMul ebx, w
		mov dword ptr [jm5], ebx		// jm5 = (j<5) ? 0 : j-5;

		cmp eax, edx
		jl Tagjp1ok
		mov ebx, ecx
		jmp Tagjp1nok
	Tagjp1ok:
		mov ebx, eax
		add ebx, 0x01
	Tagjp1nok:
		iMul ebx, w
		mov dword ptr [jp1], ebx		// jp1 = (j<iHeight-1) ? j+1 : iHeight-1;

		sub edx, 0x01
		cmp eax, edx
		jl Tagjp2ok
		mov ebx, ecx
		jmp Tagjp2nok
	Tagjp2ok:
		mov ebx, eax
		add ebx, 0x02
	Tagjp2nok:
		iMul ebx, w
		mov dword ptr [jp2], ebx		// jp2 = (j<iHeight-2) ? j+2 : iHeight-1;

		sub edx, 0x01
		cmp eax, edx
		jl Tagjp3ok
		mov ebx, ecx
		jmp Tagjp3nok
	Tagjp3ok:
		mov ebx, eax
		add ebx, 0x03
	Tagjp3nok:
		iMul ebx, w
		mov dword ptr [jp3], ebx		// jp3 = (j<iHeight-3) ? j+3 : iHeight-1;

		sub edx, 0x01
		cmp eax, edx
		jl Tagjp4ok
		mov ebx, ecx
		jmp Tagjp4nok
	Tagjp4ok:
		mov ebx, eax
		add ebx, 0x04
	Tagjp4nok:
		iMul ebx, w
		mov dword ptr [jp4], ebx		// jp4 = (j<iHeight-4) ? j+4 : iHeight-1;

		sub edx, 0x01
		cmp eax, edx
		jl Tagjp5ok
		mov ebx, ecx
		jmp Tagjp5nok
	Tagjp5ok:
		mov ebx, eax
		add ebx, 0x05
	Tagjp5nok:
		iMul ebx, w
		mov dword ptr [jp5], ebx		// jp5 = (j<iHeight-5) ? j+5 : iHeight-1;

		sub edx, 0x01
		cmp eax, edx
		jl Tagjp6ok
		mov ebx, ecx
		jmp Tagjp6nok
	Tagjp6ok:
		mov ebx, eax
		add ebx, 0x06
	Tagjp6nok:
		iMul ebx, w
		mov dword ptr [jp6], ebx		// jp6 = (j<iHeight-6) ? j+6 : iHeight-1;

		mov dword ptr [i], 0			// i = 0 (Spaltenzähler)
	Schleife2:

		/* FIR filter with 0.5 sample interval phase shift */
		// Achtung, erstmal alle positiven Parameter
		mov ecx, 0xff					// ecx = 256	Summand für U

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp1]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0xe4
		add ecx, eax					// ecx+=228*(pUin[jm0]+pUin[jp1])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp2]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x46
		add ecx, eax					// ecx+=70*(pUin[jm1]+pUin[jp2])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp5]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x0b
		add ecx, eax					// ecx+=11*(pUin[jm4]+pUin[jp5])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm5]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp6]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x05
		add ecx, eax					// ecx+=5*(pUin[jm5]+pUin[jp6])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp3]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x25
		sub ecx, eax					// ecx-=37*(pUin[jm2]+pUin[jp3])

		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pUin]		
		add edx, dword ptr [jp4]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x15
		sub ecx, eax					// ecx-=21*(pUin[jm3]+pUin[jp4])

		sar ecx, 0x09					// ecx >> 9

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagUok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagUnok
		mov ecx, 0xff					// ecx = 255
		jmp TagUok
	TagUnok:
		xor ecx, ecx					// ecx = 0
	TagUok:
		mov eax, dword ptr [pUout]		// eax = pUout[i]
		add eax, dword ptr [i]
		mov byte ptr [eax], cl

		mov ecx, 0xff					// ecx = 256	Summand für V

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm0]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp1]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0xe4
		add ecx, eax					// ecx+=228*(pVin[jm0]+pVin[jp1])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm1]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp2]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x46
		add ecx, eax					// ecx+=70*(pVin[jm1]+pVin[jp2])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm4]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp5]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x0b
		add ecx, eax					// ecx+=11*(pVin[jm4]+pVin[jp5])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm5]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp6]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x05
		add ecx, eax					// ecx+=5*(pVin[jm5]+pVin[jp6])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm2]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp3]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x25
		sub ecx, eax					// ecx-=37*(pVin[jm2]+pVin[jp3])

		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jm3]
		xor ebx, ebx
		mov bl, byte ptr [edx]
		mov edx, dword ptr [pVin]		
		add edx, dword ptr [jp4]
		xor eax, eax
		mov al, byte ptr [edx]
		add eax, ebx
		iMul eax, 0x15
		sub ecx, eax					// ecx-=21*(pVin[jm3]+pVin[jp4])

		sar ecx, 0x09					// ecx >> 9

		cmp ecx, 0x0100					// ecx > 256 ?
		jl TagVok
		cmp ecx, 0x1000					// ecx < 0 ?
		jl TagVnok
		mov ecx, 0xff					// ecx = 255
		jmp TagVok
	TagVnok:
		xor ecx, ecx					// ecx = 0
	TagVok:
		mov eax, dword ptr [pVout]		// eax = pVout[i]
		add eax, dword ptr [i]
		mov byte ptr [eax], cl

		mov eax, dword ptr [pUin]
		add eax, 0x01
		mov dword ptr [pUin], eax		// pUin++

		mov eax, dword ptr [pVin]
		add eax, 0x01
		mov dword ptr [pVin], eax		// pVin++

		mov eax, dword ptr [i]
		add eax, 0x01
		mov dword ptr [i], eax
		cmp eax, w
		jl Schleife2

		mov eax, dword ptr [w]
		add dword ptr [pUout], eax
		add dword ptr [pVout], eax

		mov eax, dword ptr [j]
		add eax, 0x02
		mov dword ptr [j], eax
		cmp eax, iHeight
		jl Schleife1
	
		emms
	}
}

// Funktion SVEfast444to420: Schnelle Interpolation der U/V-Layer
void SVEfast444to420(unsigned char* lpUin,unsigned char* lpVin,
					 unsigned char* lpUout,unsigned char* lpVout,
					 long iWidth,long iHeight)
{
	unsigned char *pUin1, *pVin1,*pUin2, *pVin2, *pUout, *pVout;

	_asm
	{
		mov eax, dword ptr [lpUout]		
		mov dword ptr [pUout], eax		// pUout = lpUout;

		mov eax, dword ptr [lpVout]		
		mov dword ptr [pVout], eax		// pVout = lpVout;

		mov eax, dword ptr [lpUin]		
		mov dword ptr [pUin1], eax		// pUin1 = lpUin;

		mov eax, dword ptr [lpVin]		
		mov dword ptr [pVin1], eax		// pVin1 = lpVin;

		mov eax, dword ptr [lpUin]		
		add eax, iWidth
		mov dword ptr [pUin2], eax		// pUin2 = lpUin+iWidth;

		mov eax, dword ptr [lpVin]		
		add eax, iWidth
		mov dword ptr [pVin2], eax		// pVin2 = lpVin+iWidth;

		mov esi, dword ptr [iHeight]
		imul esi, iWidth
		sar esi, 0x02					// esi = (iWidth*iHeight)>>2 = Anzahl zu erzeugender Punkte

		xor edi, edi					// edi = 0 (Punktezähler)
		xor edx, edx					// edx = 0 (Spaltenzähler)
		xor ecx, ecx					// ecx = 0 (Byte-Feld)
	Schleife:
		xor ebx, ebx					// ebx = Rechenfeld
		mov eax, dword ptr [pUin1]
		mov cl, byte ptr [eax]
		add ebx, ecx
		inc eax
		mov cl, byte ptr [eax]
		add ebx, ecx
		inc eax
		mov dword ptr [pUin1], eax
		mov eax, dword ptr [pUin2]
		mov cl, byte ptr [eax]
		inc eax
		add ebx, ecx
		mov cl, byte ptr [eax]
		inc eax
		add ebx, ecx
		mov dword ptr [pUin2], eax
		sar ebx, 0x02
		mov eax, dword ptr [pUout]
		mov byte ptr [eax], bl
		inc eax
		mov dword ptr [pUout], eax

		xor ebx, ebx					// ebx = Rechenfeld
		mov eax, dword ptr [pVin1]
		mov cl, byte ptr [eax]
		add ebx, ecx
		inc eax
		mov cl, byte ptr [eax]
		add ebx, ecx
		inc eax
		mov dword ptr [pVin1], eax
		mov eax, dword ptr [pVin2]
		mov cl, byte ptr [eax]
		inc eax
		add ebx, ecx
		mov cl, byte ptr [eax]
		inc eax
		add ebx, ecx
		mov dword ptr [pVin2], eax
		sar ebx, 0x02
		mov eax, dword ptr [pVout]
		mov byte ptr [eax], bl
		inc eax
		mov dword ptr [pVout], eax

		inc edx
		inc edx
		cmp edx, iWidth
		jl TagNext
		xor edx, edx
		mov eax, dword ptr [pUin2]
		mov dword ptr [pUin1], eax
		add eax, iWidth
		mov dword ptr [pUin2], eax
		mov eax, dword ptr [pVin2]
		mov dword ptr [pVin1], eax
		add eax, iWidth
		mov dword ptr [pVin2], eax
	TagNext:
		inc edi
		cmp edi, esi
		jl Schleife

		emms
	}
}
