falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 Commits
32 Branches
748MB
Tree: 0f25d72b3f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0f25d72b3f'
${ noResults }
FFmpeg/postproc/swscale.c

795 lines
23KB
Raw Blame History 

  1. 

  2. // Software scaling and colorspace conversion routines for MPlayer

  3. 

  4. // Orginal C implementation by A'rpi/ESP-team <arpi@thot.banki.hu>

  5. // current version mostly by Michael Niedermayer (michaelni@gmx.at)

  6. 

  7. #include <inttypes.h>

  8. #include "../config.h"

  9. 

  10. //#undef HAVE_MMX2

  11. //#undef HAVE_MMX

  12. //#undef ARCH_X86

  13. #define DITHER16BPP

  14. //#define ALT_ERROR

  15. 

  16. #define RET 0xC3 //near return opcode

  17. /*

  18. NOTES

  19. 

  20. known BUGS with known cause (no bugreports please!)

  21. code reads 1 sample too much (might cause a sig11)

  22. 

  23. TODO

  24. check alignment off everything

  25. */

  26. 

  27. static uint64_t yCoeff=    0x2568256825682568LL;

  28. static uint64_t ubCoeff=   0x3343334333433343LL;

  29. static uint64_t vrCoeff=   0x40cf40cf40cf40cfLL;

  30. static uint64_t ugCoeff=   0xE5E2E5E2E5E2E5E2LL;

  31. static uint64_t vgCoeff=   0xF36EF36EF36EF36ELL;

  32. static uint64_t w80=       0x0080008000800080LL;

  33. static uint64_t w10=       0x0010001000100010LL;

  34. static uint64_t bm00000111=0x0000000000FFFFFFLL;

  35. static uint64_t bm11111000=0xFFFFFFFFFF000000LL;

  36. 

  37. static uint64_t b16Dither= 0x0004000400040004LL;

  38. static uint64_t b16Dither1=0x0004000400040004LL;

  39. static uint64_t b16Dither2=0x0602060206020602LL;

  40. static uint64_t g16Dither= 0x0002000200020002LL;

  41. static uint64_t g16Dither1=0x0002000200020002LL;

  42. static uint64_t g16Dither2=0x0301030103010301LL;

  43. 

  44. static uint64_t b16Mask=   0x001F001F001F001FLL;

  45. static uint64_t g16Mask=   0x07E007E007E007E0LL;

  46. static uint64_t r16Mask=   0xF800F800F800F800LL;

  47. static uint64_t temp0;

  48. 

  49. 

  50. // temporary storage for 4 yuv lines:

  51. // 16bit for now (mmx likes it more compact)

  52. static uint16_t pix_buf_y[4][2048];

  53. static uint16_t pix_buf_uv[2][2048*2];

  54. 

  55. // clipping helper table for C implementations:

  56. static unsigned char clip_table[768];

  57. 

  58. // yuv->rgb conversion tables:

  59. static    int yuvtab_2568[256];

  60. static    int yuvtab_3343[256];

  61. static    int yuvtab_0c92[256];

  62. static    int yuvtab_1a1e[256];

  63. static    int yuvtab_40cf[256];

  64. 

  65. 

  66. static uint8_t funnyYCode[10000];

  67. static uint8_t funnyUVCode[10000];

  68. 

  69. 

  70. // *** bilinear scaling and yuv->rgb conversion of yv12 slices:

  71. // *** Note: it's called multiple times while decoding a frame, first time y==0

  72. // *** Designed to upscale, but may work for downscale too.

  73. // s_xinc = (src_width << 16) / dst_width

  74. // s_yinc = (src_height << 16) / dst_height

  75. void SwScale_YV12slice_brg24(unsigned char* srcptr[],int stride[], int y, int h,

  76. 			     unsigned char* dstptr, int dststride, int dstw, int dstbpp,

  77. 			     unsigned int s_xinc,unsigned int s_yinc){

  78. 

  79. // scaling factors:

  80. //static int s_yinc=(vo_dga_src_height<<16)/vo_dga_vp_height;

  81. //static int s_xinc=(vo_dga_src_width<<8)/vo_dga_vp_width;

  82. 

  83. unsigned int s_xinc2;

  84. 

  85. static int s_srcypos; // points to the dst Pixels center in the source (0 is the center of pixel 0,0 in src)

  86. static int s_ypos;

  87. 

  88. // last horzontally interpolated lines, used to avoid unnecessary calculations

  89. static int s_last_ypos;

  90. static int s_last_y1pos;

  91. 

  92. static int static_dstw;

  93. 

  94. #ifdef HAVE_MMX2

  95. // used to detect a horizontal size change

  96. static int old_dstw= -1;

  97. static int old_s_xinc= -1;

  98. 

  99. #endif

  100. int canMMX2BeUsed=0;

  101. static int test=0;

  102. int srcWidth= (dstw*s_xinc + 0x8000)>>16;

  103. 

  104. #ifdef HAVE_MMX2

  105. canMMX2BeUsed= (s_xinc <= 0x10000 && (dstw&31)==0 && (srcWidth&15)==0) ? 1 : 0;

  106. #endif

  107. 

  108. // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst

  109. // n-2 is the last chrominance sample available

  110. // FIXME this is not perfect, but noone shuld notice the difference, the more correct variant

  111. // would be like the vertical one, but that would require some special code for the

  112. // first and last pixel

  113. if(canMMX2BeUsed) 	s_xinc+= 20;

  114. else			s_xinc = ((srcWidth-2)<<16)/(dstw-2) - 20;

  115. s_xinc2=s_xinc>>1;

  116. 

  117.   // force calculation of the horizontal interpolation of the first line

  118.   s_last_ypos=-99;

  119.   s_last_y1pos=-99;

  120. 

  121.   if(y==0){

  122.       s_srcypos= s_yinc/2 - 0x8000;

  123.       s_ypos=0;

  124. #ifdef HAVE_MMX2

  125. // cant downscale !!!

  126. 	if((old_s_xinc != s_xinc || old_dstw!=dstw) && canMMX2BeUsed)

  127. 	{

  128. 		uint8_t *fragment;

  129. 		int imm8OfPShufW1;

  130. 		int imm8OfPShufW2;

  131. 		int fragmentLength;

  132. 

  133. 		int xpos, xx, xalpha, i;

  134. 

  135. 		old_s_xinc= s_xinc;

  136. 		old_dstw= dstw;

  137. 

  138. 		static_dstw= dstw;

  139. 

  140. 		// create an optimized horizontal scaling routine

  141. 

  142. 		//code fragment

  143. 

  144. 		asm volatile(

  145. 			"jmp 9f				\n\t"

  146. 		// Begin

  147. 			"0:				\n\t"

  148. 			"movq (%%esi), %%mm0		\n\t" //FIXME Alignment

  149. 			"movq %%mm0, %%mm1		\n\t"

  150. 			"psrlq $8, %%mm0		\n\t"

  151. 			"punpcklbw %%mm7, %%mm1	\n\t"

  152. 			"movq %%mm2, %%mm3		\n\t"

  153. 			"punpcklbw %%mm7, %%mm0	\n\t"

  154. 			"addw %%bx, %%cx		\n\t" //2*xalpha += (4*s_xinc)&0xFFFF

  155. 			"pshufw $0xFF, %%mm1, %%mm1	\n\t"

  156. 			"1:				\n\t"

  157. 			"adcl %%edx, %%esi		\n\t" //xx+= (4*s_xinc)>>16 + carry

  158. 			"pshufw $0xFF, %%mm0, %%mm0	\n\t"

  159. 			"2:				\n\t"

  160. 			"psrlw $9, %%mm3		\n\t"

  161. 			"psubw %%mm1, %%mm0		\n\t"

  162. 			"pmullw %%mm3, %%mm0		\n\t"

  163. 			"paddw %%mm6, %%mm2		\n\t" // 2*alpha += xpos&0xFFFF

  164. 			"psllw $7, %%mm1		\n\t"

  165. 			"paddw %%mm1, %%mm0		\n\t"

  166. 

  167. 			"movq %%mm0, (%%edi, %%eax)	\n\t"

  168. 

  169. 			"addl $8, %%eax			\n\t"

  170. 		// End

  171. 			"9:				\n\t"

  172. //		"int $3\n\t"

  173. 			"leal 0b, %0			\n\t"

  174. 			"leal 1b, %1			\n\t"

  175. 			"leal 2b, %2			\n\t"

  176. 			"decl %1			\n\t"

  177. 			"decl %2			\n\t"

  178. 			"subl %0, %1			\n\t"

  179. 			"subl %0, %2			\n\t"

  180. 			"leal 9b, %3			\n\t"

  181. 			"subl %0, %3			\n\t"

  182. 			:"=r" (fragment), "=r" (imm8OfPShufW1), "=r" (imm8OfPShufW2),

  183. 			 "=r" (fragmentLength)

  184. 		);

  185. 

  186. 		xpos= 0; //s_xinc/2 - 0x8000; // difference between pixel centers

  187. 

  188. 		/* choose xinc so that all 8 parts fit exactly

  189. 		   Note: we cannot use just 1 part because it would not fit in the code cache */

  190. //		s_xinc2_diff= -((((s_xinc2*(dstw/8))&0xFFFF))/(dstw/8))-10;

  191. //		s_xinc_diff= -((((s_xinc*(dstw/8))&0xFFFF))/(dstw/8));

  192. #ifdef ALT_ERROR

  193. //		s_xinc2_diff+= ((0x10000/(dstw/8)));

  194. #endif

  195. //		s_xinc_diff= s_xinc2_diff*2;

  196. 

  197. //		s_xinc2+= s_xinc2_diff;

  198. //		s_xinc+= s_xinc_diff;

  199. 

  200. //		old_s_xinc= s_xinc;

  201. 

  202. 		for(i=0; i<dstw/8; i++)

  203. 		{

  204. 			int xx=xpos>>16;

  205. 

  206. 			if((i&3) == 0)

  207. 			{

  208. 				int a=0;

  209. 				int b=((xpos+s_xinc)>>16) - xx;

  210. 				int c=((xpos+s_xinc*2)>>16) - xx;

  211. 				int d=((xpos+s_xinc*3)>>16) - xx;

  212. 

  213. 				memcpy(funnyYCode + fragmentLength*i/4, fragment, fragmentLength);

  214. 

  215. 				funnyYCode[fragmentLength*i/4 + imm8OfPShufW1]=

  216. 				funnyYCode[fragmentLength*i/4 + imm8OfPShufW2]=

  217. 					a | (b<<2) | (c<<4) | (d<<6);

  218. 

  219. 				funnyYCode[fragmentLength*(i+4)/4]= RET;

  220. 			}

  221. 			xpos+=s_xinc;

  222. 		}

  223. 

  224. 		xpos= 0; //s_xinc2/2 - 0x10000; // difference between centers of chrom samples

  225. 		for(i=0; i<dstw/8; i++)

  226. 		{

  227. 			int xx=xpos>>16;

  228. 

  229. 			if((i&3) == 0)

  230. 			{

  231. 				int a=0;

  232. 				int b=((xpos+s_xinc2)>>16) - xx;

  233. 				int c=((xpos+s_xinc2*2)>>16) - xx;

  234. 				int d=((xpos+s_xinc2*3)>>16) - xx;

  235. 

  236. 				memcpy(funnyUVCode + fragmentLength*i/4, fragment, fragmentLength);

  237. 

  238. 				funnyUVCode[fragmentLength*i/4 + imm8OfPShufW1]=

  239. 				funnyUVCode[fragmentLength*i/4 + imm8OfPShufW2]=

  240. 					a | (b<<2) | (c<<4) | (d<<6);

  241. 

  242. 				funnyUVCode[fragmentLength*(i+4)/4]= RET;

  243. 			}

  244. 			xpos+=s_xinc2;

  245. 		}

  246. //		funnyCode[0]= RET;

  247. 	}

  248. 

  249. #endif // HAVE_MMX2

  250.   } // reset counters

  251. 

  252. 

  253.   while(1){

  254.     unsigned char *dest=dstptr+dststride*s_ypos;

  255.     int y0=(s_srcypos + 0xFFFF)>>16;  // first luminance source line number below the dst line

  256. 	// points to the dst Pixels center in the source (0 is the center of pixel 0,0 in src)

  257.     int srcuvpos= s_srcypos + s_yinc/2 - 0x8000;

  258.     int y1=(srcuvpos + 0x1FFFF)>>17; // first chrominance source line number below the dst line

  259.     int yalpha=((s_srcypos-1)&0xFFFF)>>7;

  260.     int yalpha1=yalpha^511;

  261.     int uvalpha=((srcuvpos-1)&0x1FFFF)>>8;

  262.     int uvalpha1=uvalpha^511;

  263.     uint16_t *buf0=pix_buf_y[y0&1];		// top line of the interpolated slice

  264.     uint16_t *buf1=pix_buf_y[((y0+1)&1)];	// bottom line of the interpolated slice

  265.     uint16_t *uvbuf0=pix_buf_uv[y1&1];		// top line of the interpolated slice

  266.     uint16_t *uvbuf1=pix_buf_uv[(y1+1)&1];	// bottom line of the interpolated slice

  267.     int i;

  268. 

  269.     // if this is before the first line than use only the first src line

  270.     if(y0==0) buf0= buf1;

  271.     if(y1==0) uvbuf0= uvbuf1; // yes we do have to check this, its not the same as y0==0

  272. 

  273.     if(y0>=y+h) break; // FIXME wrong, skips last lines, but they are dupliactes anyway

  274. 

  275.     // if this is after the last line than use only the last src line

  276.     if(y0>=y+h)

  277.     {

  278. 	buf1= buf0;

  279. 	s_last_ypos=y0;

  280.     }

  281.     if(y1>=(y+h)/2)

  282.     {

  283. 	uvbuf1= uvbuf0;

  284. 	s_last_y1pos=y1;

  285.     }

  286. 

  287. 

  288.     s_ypos++; s_srcypos+=s_yinc;

  289. 

  290.     //only interpolate the src line horizontally if we didnt do it allready

  291.     if(s_last_ypos!=y0){

  292.       unsigned char *src=srcptr[0]+(y0-y)*stride[0];

  293.       unsigned int xpos=0;

  294.       s_last_ypos=y0;

  295.       // *** horizontal scale Y line to temp buffer

  296. #ifdef ARCH_X86

  297. 

  298. #ifdef HAVE_MMX2

  299. 	if(canMMX2BeUsed)

  300. 	{

  301. 		asm volatile(

  302. 			"pxor %%mm7, %%mm7		\n\t"

  303. 			"pxor %%mm2, %%mm2		\n\t" // 2*xalpha

  304. 			"movd %5, %%mm6			\n\t" // s_xinc&0xFFFF

  305. 			"punpcklwd %%mm6, %%mm6		\n\t"

  306. 			"punpcklwd %%mm6, %%mm6		\n\t"

  307. 			"movq %%mm6, %%mm2		\n\t"

  308. 			"psllq $16, %%mm2		\n\t"

  309. 			"paddw %%mm6, %%mm2		\n\t"

  310. 			"psllq $16, %%mm2		\n\t"

  311. 			"paddw %%mm6, %%mm2		\n\t"

  312. 			"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=s_xinc&0xFF

  313. 			"movq %%mm2, temp0		\n\t"

  314. 			"movd %4, %%mm6			\n\t" //(s_xinc*4)&0xFFFF

  315. 			"punpcklwd %%mm6, %%mm6		\n\t"

  316. 			"punpcklwd %%mm6, %%mm6		\n\t"

  317. 			"xorl %%eax, %%eax		\n\t" // i

  318. 			"movl %0, %%esi			\n\t" // src

  319. 			"movl %1, %%edi			\n\t" // buf1

  320. 			"movl %3, %%edx			\n\t" // (s_xinc*4)>>16

  321. 			"xorl %%ecx, %%ecx		\n\t"

  322. 			"xorl %%ebx, %%ebx		\n\t"

  323. 			"movw %4, %%bx			\n\t" // (s_xinc*4)&0xFFFF

  324. 	//	"int $3\n\t"

  325. 			"call funnyYCode			\n\t"

  326. 			"movq temp0, %%mm2		\n\t"

  327. 			"xorl %%ecx, %%ecx		\n\t"

  328. 			"call funnyYCode			\n\t"

  329. 			"movq temp0, %%mm2		\n\t"

  330. 			"xorl %%ecx, %%ecx		\n\t"

  331. 			"call funnyYCode			\n\t"

  332. 			"movq temp0, %%mm2		\n\t"

  333. 			"xorl %%ecx, %%ecx		\n\t"

  334. 			"call funnyYCode			\n\t"

  335. 			"movq temp0, %%mm2		\n\t"

  336. 			"xorl %%ecx, %%ecx		\n\t"

  337. 			"call funnyYCode			\n\t"

  338. 			"movq temp0, %%mm2		\n\t"

  339. 			"xorl %%ecx, %%ecx		\n\t"

  340. 			"call funnyYCode			\n\t"

  341. 			"movq temp0, %%mm2		\n\t"

  342. 			"xorl %%ecx, %%ecx		\n\t"

  343. 			"call funnyYCode			\n\t"

  344. 			"movq temp0, %%mm2		\n\t"

  345. 			"xorl %%ecx, %%ecx		\n\t"

  346. 			"call funnyYCode			\n\t"

  347. 			:: "m" (src), "m" (buf1), "m" (dstw), "m" ((s_xinc*4)>>16),

  348. 			"m" ((s_xinc*4)&0xFFFF), "m" (s_xinc&0xFFFF)

  349. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"

  350. 		);

  351. 		for(i=dstw-1; (i*s_xinc)>>16 >=srcWidth-1; i--) buf1[i] = src[srcWidth-1]*128;

  352. 	}

  353. 	else

  354. 	{

  355. #endif

  356. 	//NO MMX just normal asm ... FIXME try/write funny MMX2 variant

  357. 	//FIXME add prefetch

  358. 	asm volatile(

  359. 		"xorl %%eax, %%eax		\n\t" // i

  360. 		"xorl %%ebx, %%ebx		\n\t" // xx

  361. 		"xorl %%ecx, %%ecx		\n\t" // 2*xalpha

  362. 		"1:				\n\t"

  363. 		"movzbl  (%0, %%ebx), %%edi	\n\t" //src[xx]

  364. 		"movzbl 1(%0, %%ebx), %%esi	\n\t" //src[xx+1]

  365. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  366. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  367. 		"shll $16, %%edi		\n\t"

  368. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  369. 		"movl %1, %%edi			\n\t"

  370. 		"shrl $9, %%esi			\n\t"

  371. 		"movw %%si, (%%edi, %%eax, 2)	\n\t"

  372. 		"addw %4, %%cx			\n\t" //2*xalpha += s_xinc&0xFF

  373. 		"adcl %3, %%ebx			\n\t" //xx+= s_xinc>>8 + carry

  374. 

  375. 		"movzbl (%0, %%ebx), %%edi	\n\t" //src[xx]

  376. 		"movzbl 1(%0, %%ebx), %%esi	\n\t" //src[xx+1]

  377. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  378. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  379. 		"shll $16, %%edi		\n\t"

  380. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  381. 		"movl %1, %%edi			\n\t"

  382. 		"shrl $9, %%esi			\n\t"

  383. 		"movw %%si, 2(%%edi, %%eax, 2)	\n\t"

  384. 		"addw %4, %%cx			\n\t" //2*xalpha += s_xinc&0xFF

  385. 		"adcl %3, %%ebx			\n\t" //xx+= s_xinc>>8 + carry

  386. 

  387. 

  388. 		"addl $2, %%eax			\n\t"

  389. 		"cmpl %2, %%eax			\n\t"

  390. 		" jb 1b				\n\t"

  391. 

  392. 

  393. 		:: "r" (src), "m" (buf1), "m" (dstw), "m" (s_xinc>>16), "m" (s_xinc&0xFFFF)

  394. 		: "%eax", "%ebx", "%ecx", "%edi", "%esi"

  395. 		);

  396. #ifdef HAVE_MMX2

  397. 	} //if MMX2 cant be used

  398. #endif

  399. #else

  400.       for(i=0;i<dstw;i++){

  401. 	register unsigned int xx=xpos>>16;

  402.         register unsigned int xalpha=(xpos&0xFFFF)>>9;

  403. 	buf1[i]=(src[xx]*(xalpha^127)+src[xx+1]*xalpha);

  404. 	xpos+=s_xinc;

  405.       }

  406. #endif

  407.     }

  408.       // *** horizontal scale U and V lines to temp buffer

  409.     if(s_last_y1pos!=y1){

  410.         unsigned char *src1=srcptr[1]+(y1-y/2)*stride[1];

  411.         unsigned char *src2=srcptr[2]+(y1-y/2)*stride[2];

  412.         int xpos=0;

  413. 	s_last_y1pos= y1;

  414. #ifdef ARCH_X86

  415. #ifdef HAVE_MMX2

  416. 	if(canMMX2BeUsed)

  417. 	{

  418. 		asm volatile(

  419. 		"pxor %%mm7, %%mm7		\n\t"

  420. 		"pxor %%mm2, %%mm2		\n\t" // 2*xalpha

  421. 		"movd %5, %%mm6			\n\t" // s_xinc&0xFFFF

  422. 		"punpcklwd %%mm6, %%mm6		\n\t"

  423. 		"punpcklwd %%mm6, %%mm6		\n\t"

  424. 		"movq %%mm6, %%mm2		\n\t"

  425. 		"psllq $16, %%mm2		\n\t"

  426. 		"paddw %%mm6, %%mm2		\n\t"

  427. 		"psllq $16, %%mm2		\n\t"

  428. 		"paddw %%mm6, %%mm2		\n\t"

  429. 		"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=s_xinc&0xFFFF

  430. 		"movq %%mm2, temp0		\n\t"

  431. 		"movd %4, %%mm6			\n\t" //(s_xinc*4)&0xFFFF

  432. 		"punpcklwd %%mm6, %%mm6		\n\t"

  433. 		"punpcklwd %%mm6, %%mm6		\n\t"

  434. 		"xorl %%eax, %%eax		\n\t" // i

  435. 		"movl %0, %%esi			\n\t" // src

  436. 		"movl %1, %%edi			\n\t" // buf1

  437. 		"movl %3, %%edx			\n\t" // (s_xinc*4)>>16

  438. 		"xorl %%ecx, %%ecx		\n\t"

  439. 		"xorl %%ebx, %%ebx		\n\t"

  440. 		"movw %4, %%bx			\n\t" // (s_xinc*4)&0xFFFF

  441. 

  442. //	"int $3\n\t"

  443. #define FUNNYUVCODE \

  444. 		"call funnyUVCode		\n\t"\

  445. 		"movq temp0, %%mm2		\n\t"\

  446. 		"xorl %%ecx, %%ecx		\n\t"

  447. 

  448. FUNNYUVCODE

  449. FUNNYUVCODE

  450. FUNNYUVCODE

  451. FUNNYUVCODE

  452. 

  453. FUNNYUVCODE

  454. FUNNYUVCODE

  455. FUNNYUVCODE

  456. FUNNYUVCODE

  457. 

  458. 

  459. 

  460. 		"xorl %%eax, %%eax		\n\t" // i

  461. 		"movl %6, %%esi			\n\t" // src

  462. 		"movl %1, %%edi			\n\t" // buf1

  463. 		"addl $4096, %%edi		\n\t"

  464. 

  465. FUNNYUVCODE

  466. FUNNYUVCODE

  467. FUNNYUVCODE

  468. FUNNYUVCODE

  469. 

  470. FUNNYUVCODE

  471. FUNNYUVCODE

  472. FUNNYUVCODE

  473. FUNNYUVCODE

  474. 

  475. 		:: "m" (src1), "m" (uvbuf1), "m" (dstw), "m" ((s_xinc2*4)>>16),

  476. 		  "m" ((s_xinc2*4)&0xFFFF), "m" (s_xinc2&0xFFFF), "m" (src2)

  477. 		: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"

  478. 	);

  479. 		for(i=dstw-1; (i*s_xinc2)>>16 >=srcWidth/2-1; i--)

  480. 		{

  481. 			uvbuf1[i] = src1[srcWidth/2-1]*128;

  482. 			uvbuf1[i+2048] = src2[srcWidth/2-1]*128;

  483. 		}

  484. 	}

  485. 	else

  486. 	{

  487. #endif

  488. 	asm volatile(

  489. 		"xorl %%eax, %%eax		\n\t" // i

  490. 		"xorl %%ebx, %%ebx		\n\t" // xx

  491. 		"xorl %%ecx, %%ecx		\n\t" // 2*xalpha

  492. 		"1:				\n\t"

  493. 		"movl %0, %%esi			\n\t"

  494. 		"movzbl  (%%esi, %%ebx), %%edi	\n\t" //src[xx]

  495. 		"movzbl 1(%%esi, %%ebx), %%esi	\n\t" //src[xx+1]

  496. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  497. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  498. 		"shll $16, %%edi		\n\t"

  499. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  500. 		"movl %1, %%edi			\n\t"

  501. 		"shrl $9, %%esi			\n\t"

  502. 		"movw %%si, (%%edi, %%eax, 2)	\n\t"

  503. 

  504. 		"movzbl  (%5, %%ebx), %%edi	\n\t" //src[xx]

  505. 		"movzbl 1(%5, %%ebx), %%esi	\n\t" //src[xx+1]

  506. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  507. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  508. 		"shll $16, %%edi		\n\t"

  509. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  510. 		"movl %1, %%edi			\n\t"

  511. 		"shrl $9, %%esi			\n\t"

  512. 		"movw %%si, 4096(%%edi, %%eax, 2)\n\t"

  513. 

  514. 		"addw %4, %%cx			\n\t" //2*xalpha += s_xinc&0xFF

  515. 		"adcl %3, %%ebx			\n\t" //xx+= s_xinc>>8 + carry

  516. 		"addl $1, %%eax			\n\t"

  517. 		"cmpl %2, %%eax			\n\t"

  518. 		" jb 1b				\n\t"

  519. 

  520. 

  521. 		:: "m" (src1), "m" (uvbuf1), "m" (dstw), "m" (s_xinc2>>16), "m" (s_xinc2&0xFFFF),

  522. 		"r" (src2)

  523. 		: "%eax", "%ebx", "%ecx", "%edi", "%esi"

  524. 		);

  525. #ifdef HAVE_MMX2

  526. 	} //if MMX2 cant be used

  527. #endif

  528. #else

  529.       for(i=0;i<dstw;i++){

  530. 	  register unsigned int xx=xpos>>16;

  531.           register unsigned int xalpha=(xpos&0xFFFF)>>9;

  532. 	  uvbuf1[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);

  533. 	  uvbuf1[i+2048]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);

  534. 	  xpos+=s_xinc2;

  535.       }

  536. #endif

  537.     }

  538. 

  539. 

  540.     // Note1: this code can be resticted to n*8 (or n*16) width lines to simplify optimization...

  541.     // Re: Note1: ok n*4 for now

  542.     // Note2: instead of using lookup tabs, mmx version could do the multiply...

  543.     // Re: Note2: yep

  544.     // Note3: maybe we should make separated 15/16, 24 and 32bpp version of this:

  545.     // Re: done (32 & 16) and 16 has dithering :) but 16 is untested

  546. #ifdef HAVE_MMX

  547. 	//FIXME write lq version with less uv ...

  548. 	//FIXME reorder / optimize

  549. 	if(dstbpp == 32)

  550. 	{

  551. 		asm volatile(

  552. 

  553. #define YSCALEYUV2RGB \

  554. 		"pxor %%mm7, %%mm7		\n\t"\

  555. 		"movd %6, %%mm6			\n\t" /*yalpha1*/\

  556. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  557. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  558. 		"movd %7, %%mm5			\n\t" /*uvalpha1*/\

  559. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  560. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  561. 		"xorl %%eax, %%eax		\n\t"\

  562. 		"1:				\n\t"\

  563. 		"movq (%0, %%eax, 2), %%mm0	\n\t" /*buf0[eax]*/\

  564. 		"movq (%1, %%eax, 2), %%mm1	\n\t" /*buf1[eax]*/\

  565. 		"movq (%2, %%eax,2), %%mm2	\n\t" /* uvbuf0[eax]*/\

  566. 		"movq (%3, %%eax,2), %%mm3	\n\t" /* uvbuf1[eax]*/\

  567. 		"psubw %%mm1, %%mm0		\n\t" /* buf0[eax] - buf1[eax]*/\

  568. 		"psubw %%mm3, %%mm2		\n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\

  569. 		"pmulhw %%mm6, %%mm0		\n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\

  570. 		"pmulhw %%mm5, %%mm2		\n\t" /* (uvbuf0[eax] - uvbuf1[eax])uvalpha1>>16*/\

  571. 		"psraw $7, %%mm1		\n\t" /* buf0[eax] - buf1[eax] >>7*/\

  572. 		"movq 4096(%2, %%eax,2), %%mm4	\n\t" /* uvbuf0[eax+2048]*/\

  573. 		"psraw $7, %%mm3		\n\t" /* uvbuf0[eax] - uvbuf1[eax] >>7*/\

  574. 		"paddw %%mm0, %%mm1		\n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\

  575. 		"movq 4096(%3, %%eax,2), %%mm0	\n\t" /* uvbuf1[eax+2048]*/\

  576. 		"paddw %%mm2, %%mm3		\n\t" /* uvbuf0[eax]uvalpha1 - uvbuf1[eax](1-uvalpha1)*/\

  577. 		"psubw %%mm0, %%mm4		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\

  578. 		"psubw w10, %%mm1		\n\t" /* Y-16*/\

  579. 		"psubw w80, %%mm3		\n\t" /* (U-128)*/\

  580. 		"psllw $3, %%mm1		\n\t" /* (y-16)*8*/\

  581. 		"psllw $3, %%mm3		\n\t" /*(U-128)8*/\

  582. 		"pmulhw yCoeff, %%mm1		\n\t"\

  583. \

  584. \

  585. 		"pmulhw %%mm5, %%mm4		\n\t" /* (uvbuf0[eax+2048] - uvbuf1[eax+2048])uvalpha1>>16*/\

  586. 		"movq %%mm3, %%mm2		\n\t" /* (U-128)8*/\

  587. 		"pmulhw ubCoeff, %%mm3		\n\t"\

  588. 		"psraw $7, %%mm0		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>7*/\

  589. 		"pmulhw ugCoeff, %%mm2		\n\t"\

  590. 		"paddw %%mm4, %%mm0		\n\t" /* uvbuf0[eax+2048]uvalpha1 - uvbuf1[eax+2048](1-uvalpha1)*/\

  591. 		"psubw w80, %%mm0		\n\t" /* (V-128)*/\

  592. 		"psllw $3, %%mm0		\n\t" /* (V-128)8*/\

  593. \

  594. \

  595. 		"movq %%mm0, %%mm4		\n\t" /* (V-128)8*/\

  596. 		"pmulhw vrCoeff, %%mm0		\n\t"\

  597. 		"pmulhw vgCoeff, %%mm4		\n\t"\

  598. 		"paddw %%mm1, %%mm3		\n\t" /* B*/\

  599. 		"paddw %%mm1, %%mm0		\n\t" /* R*/\

  600. 		"packuswb %%mm3, %%mm3		\n\t"\

  601. \

  602. 		"packuswb %%mm0, %%mm0		\n\t"\

  603. 		"paddw %%mm4, %%mm2		\n\t"\

  604. 		"paddw %%mm2, %%mm1		\n\t" /* G*/\

  605. \

  606. 		"packuswb %%mm1, %%mm1		\n\t"

  607. 

  608. YSCALEYUV2RGB

  609. 		"punpcklbw %%mm1, %%mm3		\n\t" // BGBGBGBG

  610. 		"punpcklbw %%mm7, %%mm0		\n\t" // R0R0R0R0

  611. 

  612. 		"movq %%mm3, %%mm1		\n\t"

  613. 		"punpcklwd %%mm0, %%mm3		\n\t" // BGR0BGR0

  614. 		"punpckhwd %%mm0, %%mm1		\n\t" // BGR0BGR0

  615. #ifdef HAVE_MMX2

  616. 		"movntq %%mm3, (%4, %%eax, 4)	\n\t"

  617. 		"movntq %%mm1, 8(%4, %%eax, 4)	\n\t"

  618. #else

  619. 		"movq %%mm3, (%4, %%eax, 4)	\n\t"

  620. 		"movq %%mm1, 8(%4, %%eax, 4)	\n\t"

  621. #endif

  622. 		"addl $4, %%eax			\n\t"

  623. 		"cmpl %5, %%eax			\n\t"

  624. 		" jb 1b				\n\t"

  625. 

  626. 

  627. 		:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstw),

  628. 		"m" (yalpha1), "m" (uvalpha1)

  629. 		: "%eax"

  630. 		);

  631. 	}

  632. 	else if(dstbpp==24)

  633. 	{

  634. 		asm volatile(

  635. 

  636. YSCALEYUV2RGB

  637. 

  638. 							// lsb ... msb

  639. 		"punpcklbw %%mm1, %%mm3		\n\t" // BGBGBGBG

  640. 		"punpcklbw %%mm7, %%mm0		\n\t" // R0R0R0R0

  641. 

  642. 		"movq %%mm3, %%mm1		\n\t"

  643. 		"punpcklwd %%mm0, %%mm3		\n\t" // BGR0BGR0

  644. 		"punpckhwd %%mm0, %%mm1		\n\t" // BGR0BGR0

  645. 

  646. 		"movq %%mm3, %%mm2		\n\t" // BGR0BGR0

  647. 		"psrlq $8, %%mm3		\n\t" // GR0BGR00

  648. 		"pand bm00000111, %%mm2		\n\t" // BGR00000

  649. 		"pand bm11111000, %%mm3		\n\t" // 000BGR00

  650. 		"por %%mm2, %%mm3		\n\t" // BGRBGR00

  651. 		"movq %%mm1, %%mm2		\n\t"

  652. 		"psllq $48, %%mm1		\n\t" // 000000BG

  653. 		"por %%mm1, %%mm3		\n\t" // BGRBGRBG

  654. 

  655. 		"movq %%mm2, %%mm1		\n\t" // BGR0BGR0

  656. 		"psrld $16, %%mm2		\n\t" // R000R000

  657. 		"psrlq $24, %%mm1		\n\t" // 0BGR0000

  658. 		"por %%mm2, %%mm1		\n\t" // RBGRR000

  659. 

  660. 		"movl %4, %%ebx			\n\t"

  661. 		"addl %%eax, %%ebx		\n\t"

  662. #ifdef HAVE_MMX2

  663. 		//FIXME Alignment

  664. 		"movntq %%mm3, (%%ebx, %%eax, 2)\n\t"

  665. 		"movntq %%mm1, 8(%%ebx, %%eax, 2)\n\t"

  666. #else

  667. 		"movd %%mm3, (%%ebx, %%eax, 2)	\n\t"

  668. 		"psrlq $32, %%mm3		\n\t"

  669. 		"movd %%mm3, 4(%%ebx, %%eax, 2)	\n\t"

  670. 		"movd %%mm1, 8(%%ebx, %%eax, 2)	\n\t"

  671. #endif

  672. 		"addl $4, %%eax			\n\t"

  673. 		"cmpl %5, %%eax			\n\t"

  674. 		" jb 1b				\n\t"

  675. 

  676. 		:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstw),

  677. 		"m" (yalpha1), "m" (uvalpha1)

  678. 		: "%eax", "%ebx"

  679. 		);

  680. 	}

  681. 	else if(dstbpp==16)

  682. 	{

  683. 		asm volatile(

  684. 

  685. YSCALEYUV2RGB

  686. #ifdef DITHER16BPP

  687. 		"paddusb g16Dither, %%mm1	\n\t"

  688. 		"paddusb b16Dither, %%mm0	\n\t"

  689. 		"paddusb b16Dither, %%mm3	\n\t"

  690. #endif

  691. 		"punpcklbw %%mm7, %%mm1		\n\t" // 0G0G0G0G

  692. 		"punpcklbw %%mm7, %%mm3		\n\t" // 0B0B0B0B

  693. 		"punpcklbw %%mm7, %%mm0		\n\t" // 0R0R0R0R

  694. 

  695. 		"psrlw $3, %%mm3		\n\t"

  696. 		"psllw $3, %%mm1		\n\t"

  697. 		"psllw $8, %%mm0		\n\t"

  698. 		"pand g16Mask, %%mm1		\n\t"

  699. 		"pand r16Mask, %%mm0		\n\t"

  700. 

  701. 		"por %%mm3, %%mm1		\n\t"

  702. 		"por %%mm1, %%mm0		\n\t"

  703. #ifdef HAVE_MMX2

  704. 		"movntq %%mm0, (%4, %%eax, 2)	\n\t"

  705. #else

  706. 		"movq %%mm0, (%4, %%eax, 2)	\n\t"

  707. #endif

  708. 		"addl $4, %%eax			\n\t"

  709. 		"cmpl %5, %%eax			\n\t"

  710. 		" jb 1b				\n\t"

  711. 

  712. 		:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstw),

  713. 		"m" (yalpha1), "m" (uvalpha1)

  714. 		: "%eax"

  715. 		);

  716. 	}

  717. #else

  718. 	if(dstbpp==32 || dstbpp==24)

  719. 	{

  720. 		for(i=0;i<dstw;i++){

  721. 			// vertical linear interpolation && yuv2rgb in a single step:

  722. 			int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>16)];

  723. 			int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>16);

  724. 			int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>16);

  725. 			dest[0]=clip_table[((Y + yuvtab_3343[U]) >>13)];

  726. 			dest[1]=clip_table[((Y + yuvtab_0c92[V] + yuvtab_1a1e[U]) >>13)];

  727. 			dest[2]=clip_table[((Y + yuvtab_40cf[V]) >>13)];

  728. 			dest+=dstbpp>>3;

  729. 		}

  730. 	}

  731. 	else if(dstbpp==16)

  732. 	{

  733. 		for(i=0;i<dstw;i++){

  734. 			// vertical linear interpolation && yuv2rgb in a single step:

  735. 			int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>16)];

  736. 			int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>16);

  737. 			int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>16);

  738. 

  739. 			((uint16_t*)dest)[0] =

  740. 				(clip_table[((Y + yuvtab_3343[U]) >>13)]>>3) |

  741. 				(clip_table[((Y + yuvtab_0c92[V] + yuvtab_1a1e[U]) >>13)]<<3)&0x07E0 |

  742. 				(clip_table[((Y + yuvtab_40cf[V]) >>13)]<<8)&0xF800;

  743. 			dest+=2;

  744. 		}

  745. 	}

  746. 	else if(dstbpp==15) //15bit FIXME how do i figure out if its 15 or 16?

  747. 	{

  748. 		for(i=0;i<dstw;i++){

  749. 			// vertical linear interpolation && yuv2rgb in a single step:

  750. 			int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>16)];

  751. 			int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>16);

  752. 			int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>16);

  753. 

  754. 			((uint16_t*)dest)[0] =

  755. 				(clip_table[((Y + yuvtab_3343[U]) >>13)]>>3) |

  756. 				(clip_table[((Y + yuvtab_0c92[V] + yuvtab_1a1e[U]) >>13)]<<2)&0x03E0 |

  757. 				(clip_table[((Y + yuvtab_40cf[V]) >>13)]<<7)&0x7C00;

  758. 			dest+=2;

  759. 		}

  760. 	}

  761. #endif

  762. 

  763. 	b16Dither= b16Dither1;

  764. 	b16Dither1= b16Dither2;

  765. 	b16Dither2= b16Dither;

  766. 

  767. 	g16Dither= g16Dither1;

  768. 	g16Dither1= g16Dither2;

  769. 	g16Dither2= g16Dither;

  770.   }

  771. 

  772. #ifdef HAVE_3DNOW

  773. 	asm volatile("femms");

  774. #elif defined (HAVE_MMX)

  775. 	asm volatile("emms");

  776. #endif

  777. }

  778. 

  779. 

  780. void SwScale_Init(){

  781.     // generating tables:

  782.     int i;

  783.     for(i=0;i<256;i++){

  784.         clip_table[i]=0;

  785.         clip_table[i+256]=i;

  786.         clip_table[i+512]=255;

  787. 	yuvtab_2568[i]=(0x2568*(i-16))+(256<<13);

  788. 	yuvtab_3343[i]=0x3343*(i-128);

  789. 	yuvtab_0c92[i]=-0x0c92*(i-128);

  790. 	yuvtab_1a1e[i]=-0x1a1e*(i-128);

  791. 	yuvtab_40cf[i]=0x40cf*(i-128);

  792.     }

  793. 

  794. }