开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
swscale.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：71k
源码类别：

多媒体

开发平台：

MultiPlatform

swscale.c：源码内容
  1. /*
  2.     Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17. */
  19. /*
  20.   supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8/Y800, YVU9/IF09
  21.   supported output formats: YV12, I420/IYUV, YUY2, UYVY, {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09
  22.   {BGR,RGB}{1,4,8,15,16} support dithering
  23.   
  24.   unscaled special converters (YV12=I420=IYUV, Y800=Y8)
  25.   YV12 -> {BGR,RGB}{1,4,8,15,16,24,32}
  26.   x -> x
  27.   YUV9 -> YV12
  28.   YUV9/YV12 -> Y800
  29.   Y800 -> YUV9/YV12
  30.   BGR24 -> BGR32 & RGB24 -> RGB32
  31.   BGR32 -> BGR24 & RGB32 -> RGB24
  32.   BGR15 -> BGR16
  33. */
  35. /* 
  36. tested special converters (most are tested actually but i didnt write it down ...)
  37.  YV12 -> BGR16
  38.  YV12 -> YV12
  39.  BGR15 -> BGR16
  40.  BGR16 -> BGR16
  41.  YVU9 -> YV12
  43. untested special converters
  44.   YV12/I420 -> BGR15/BGR24/BGR32 (its the yuv2rgb stuff, so it should be ok)
  45.   YV12/I420 -> YV12/I420
  46.   YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
  47.   BGR24 -> BGR32 & RGB24 -> RGB32
  48.   BGR32 -> BGR24 & RGB32 -> RGB24
  49.   BGR24 -> YV12
  50. */
  52. #include <inttypes.h>
  53. #include <string.h>
  54. #include <math.h>
  55. #include <stdio.h>
  56. #include "config.h"
  57. #include <assert.h>
  58. #ifdef HAVE_MALLOC_H
  59. #include <malloc.h>
  60. #else
  61. #include <stdlib.h>
  62. #endif
  63. #include "swscale.h"
  64. #include "swscale_internal.h"
  65. #include "common.h"
  66. #include "rgb2rgb.h"
  67. #define RUNTIME_CPUDETECT 1
  69. #undef MOVNTQ
  70. #undef PAVGB
  72. //#undef HAVE_MMX2
  73. //#define HAVE_3DNOW
  74. //#undef HAVE_MMX
  75. //#undef ARCH_X86
  76. //#define WORDS_BIGENDIAN
  77. #define DITHER1XBPP
  79. #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit
  81. #define RET 0xC3 //near return opcode for X86
  83. #ifdef MP_DEBUG
  84. #define ASSERT(x) assert(x);
  85. #else
  86. #define ASSERT(x) ;
  87. #endif
  89. #ifdef M_PI
  90. #define PI M_PI
  91. #else
  92. #define PI 3.14159265358979323846
  93. #endif
  95. //FIXME replace this with something faster
  96. #define isPlanarYUV(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_YVU9 
  97. || (x)==IMGFMT_444P || (x)==IMGFMT_422P || (x)==IMGFMT_411P)
  98. #define isYUV(x)       ((x)==IMGFMT_UYVY || (x)==IMGFMT_YUY2 || isPlanarYUV(x))
  99. #define isGray(x)      ((x)==IMGFMT_Y800)
  100. #define isRGB(x)       (((x)&IMGFMT_RGB_MASK)==IMGFMT_RGB)
  101. #define isBGR(x)       (((x)&IMGFMT_BGR_MASK)==IMGFMT_BGR)
  102. #define isSupportedIn(x)  ((x)==IMGFMT_YV12 || (x)==IMGFMT_YUY2 || (x)==IMGFMT_UYVY
  103. || (x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15
  104. || (x)==IMGFMT_RGB32|| (x)==IMGFMT_RGB24
  105. || (x)==IMGFMT_Y800 || (x)==IMGFMT_YVU9
  106. || (x)==IMGFMT_444P || (x)==IMGFMT_422P || (x)==IMGFMT_411P)
  107. #define isSupportedOut(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_YUY2 || (x)==IMGFMT_UYVY
  108. || (x)==IMGFMT_444P || (x)==IMGFMT_422P || (x)==IMGFMT_411P
  109. || isRGB(x) || isBGR(x)
  110. || (x)==IMGFMT_Y800 || (x)==IMGFMT_YVU9)
  111. #define isPacked(x)    ((x)==IMGFMT_YUY2 || (x)==IMGFMT_UYVY ||isRGB(x) || isBGR(x))
  113. #define RGB2YUV_SHIFT 16
  114. #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
  115. #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
  116. #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
  117. #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
  118. #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
  119. #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
  120. #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
  121. #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
  122. #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
  124. extern const int32_t Inverse_Table_6_9[8][4];
  126. /*
  127. NOTES
  128. Special versions: fast Y 1:1 scaling (no interpolation in y direction)
  130. TODO
  131. more intelligent missalignment avoidance for the horizontal scaler
  132. write special vertical cubic upscale version
  133. Optimize C code (yv12 / minmax)
  134. add support for packed pixel yuv input & output
  135. add support for Y8 output
  136. optimize bgr24 & bgr32
  137. add BGR4 output support
  138. write special BGR->BGR scaler
  139. */
  141. #define ABS(a) ((a) > 0 ? (a) : (-(a)))
  142. #define MIN(a,b) ((a) > (b) ? (b) : (a))
  143. #define MAX(a,b) ((a) < (b) ? (b) : (a))
  145. #ifdef ARCH_X86
  146. static uint64_t attribute_used __attribute__((aligned(8))) bF8=       0xF8F8F8F8F8F8F8F8LL;
  147. static uint64_t attribute_used __attribute__((aligned(8))) bFC=       0xFCFCFCFCFCFCFCFCLL;
  148. static uint64_t __attribute__((aligned(8))) w10=       0x0010001000100010LL;
  149. static uint64_t attribute_used __attribute__((aligned(8))) w02=       0x0002000200020002LL;
  150. static uint64_t attribute_used __attribute__((aligned(8))) bm00001111=0x00000000FFFFFFFFLL;
  151. static uint64_t attribute_used __attribute__((aligned(8))) bm00000111=0x0000000000FFFFFFLL;
  152. static uint64_t attribute_used __attribute__((aligned(8))) bm11111000=0xFFFFFFFFFF000000LL;
  153. static uint64_t attribute_used __attribute__((aligned(8))) bm01010101=0x00FF00FF00FF00FFLL;
  155. static volatile uint64_t attribute_used __attribute__((aligned(8))) b5Dither;
  156. static volatile uint64_t attribute_used __attribute__((aligned(8))) g5Dither;
  157. static volatile uint64_t attribute_used __attribute__((aligned(8))) g6Dither;
  158. static volatile uint64_t attribute_used __attribute__((aligned(8))) r5Dither;
  160. static uint64_t __attribute__((aligned(8))) dither4[2]={
  161. 0x0103010301030103LL,
  162. 0x0200020002000200LL,};
  164. static uint64_t __attribute__((aligned(8))) dither8[2]={
  165. 0x0602060206020602LL,
  166. 0x0004000400040004LL,};
  168. static uint64_t __attribute__((aligned(8))) b16Mask=   0x001F001F001F001FLL;
  169. static uint64_t attribute_used __attribute__((aligned(8))) g16Mask=   0x07E007E007E007E0LL;
  170. static uint64_t attribute_used __attribute__((aligned(8))) r16Mask=   0xF800F800F800F800LL;
  171. static uint64_t __attribute__((aligned(8))) b15Mask=   0x001F001F001F001FLL;
  172. static uint64_t attribute_used __attribute__((aligned(8))) g15Mask=   0x03E003E003E003E0LL;
  173. static uint64_t attribute_used __attribute__((aligned(8))) r15Mask=   0x7C007C007C007C00LL;
  175. static uint64_t attribute_used __attribute__((aligned(8))) M24A=   0x00FF0000FF0000FFLL;
  176. static uint64_t attribute_used __attribute__((aligned(8))) M24B=   0xFF0000FF0000FF00LL;
  177. static uint64_t attribute_used __attribute__((aligned(8))) M24C=   0x0000FF0000FF0000LL;
  179. #ifdef FAST_BGR2YV12
  180. static const uint64_t bgr2YCoeff  attribute_used __attribute__((aligned(8))) = 0x000000210041000DULL;
  181. static const uint64_t bgr2UCoeff  attribute_used __attribute__((aligned(8))) = 0x0000FFEEFFDC0038ULL;
  182. static const uint64_t bgr2VCoeff  attribute_used __attribute__((aligned(8))) = 0x00000038FFD2FFF8ULL;
  183. #else
  184. static const uint64_t bgr2YCoeff  attribute_used __attribute__((aligned(8))) = 0x000020E540830C8BULL;
  185. static const uint64_t bgr2UCoeff  attribute_used __attribute__((aligned(8))) = 0x0000ED0FDAC23831ULL;
  186. static const uint64_t bgr2VCoeff  attribute_used __attribute__((aligned(8))) = 0x00003831D0E6F6EAULL;
  187. #endif
  188. static const uint64_t bgr2YOffset attribute_used __attribute__((aligned(8))) = 0x1010101010101010ULL;
  189. static const uint64_t bgr2UVOffset attribute_used __attribute__((aligned(8)))= 0x8080808080808080ULL;
  190. static const uint64_t w1111       attribute_used __attribute__((aligned(8))) = 0x0001000100010001ULL;
  191. #endif
  193. // clipping helper table for C implementations:
  194. static unsigned char clip_table[768];
  196. static SwsVector *sws_getConvVec(SwsVector *a, SwsVector *b);
  197.   
  198. extern const uint8_t dither_2x2_4[2][8];
  199. extern const uint8_t dither_2x2_8[2][8];
  200. extern const uint8_t dither_8x8_32[8][8];
  201. extern const uint8_t dither_8x8_73[8][8];
  202. extern const uint8_t dither_8x8_220[8][8];
  204. #ifdef ARCH_X86
  205. void in_asm_used_var_warning_killer()
  206. {
  207.  volatile int i= bF8+bFC+w10+
  208.  bm00001111+bm00000111+bm11111000+b16Mask+g16Mask+r16Mask+b15Mask+g15Mask+r15Mask+
  209.  M24A+M24B+M24C+w02 + b5Dither+g5Dither+r5Dither+g6Dither+dither4[0]+dither8[0]+bm01010101;
  210.  if(i) i=0;
  211. }
  212. #endif
  214. static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
  215.     int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
  216.     uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW)
  217. {
  218. //FIXME Optimize (just quickly writen not opti..)
  219. int i;
  220. for(i=0; i<dstW; i++)
  221. {
  222. int val=1<<18;
  223. int j;
  224. for(j=0; j<lumFilterSize; j++)
  225. val += lumSrc[j][i] * lumFilter[j];
  227. dest[i]= MIN(MAX(val>>19, 0), 255);
  228. }
  230. if(uDest != NULL)
  231. for(i=0; i<chrDstW; i++)
  232. {
  233. int u=1<<18;
  234. int v=1<<18;
  235. int j;
  236. for(j=0; j<chrFilterSize; j++)
  237. {
  238. u += chrSrc[j][i] * chrFilter[j];
  239. v += chrSrc[j][i + 2048] * chrFilter[j];
  240. }
  242. uDest[i]= MIN(MAX(u>>19, 0), 255);
  243. vDest[i]= MIN(MAX(v>>19, 0), 255);
  244. }
  245. }
  248. #define YSCALE_YUV_2_PACKEDX_C(type) 
  249. for(i=0; i<(dstW>>1); i++){
  250. int j;
  251. int Y1=1<<18;
  252. int Y2=1<<18;
  253. int U=1<<18;
  254. int V=1<<18;
  255. type *r, *b, *g;
  256. const int i2= 2*i;
  258. for(j=0; j<lumFilterSize; j++)
  259. {
  260. Y1 += lumSrc[j][i2] * lumFilter[j];
  261. Y2 += lumSrc[j][i2+1] * lumFilter[j];
  262. }
  263. for(j=0; j<chrFilterSize; j++)
  264. {
  265. U += chrSrc[j][i] * chrFilter[j];
  266. V += chrSrc[j][i+2048] * chrFilter[j];
  267. }
  268. Y1>>=19;
  269. Y2>>=19;
  270. U >>=19;
  271. V >>=19;
  272. if((Y1|Y2|U|V)&256)
  273. {
  274. if(Y1>255)   Y1=255;
  275. else if(Y1<0)Y1=0;
  276. if(Y2>255)   Y2=255;
  277. else if(Y2<0)Y2=0;
  278. if(U>255)    U=255;
  279. else if(U<0) U=0;
  280. if(V>255)    V=255;
  281. else if(V<0) V=0;
  282. }
  283.                         
  284. #define YSCALE_YUV_2_RGBX_C(type) 
  285. YSCALE_YUV_2_PACKEDX_C(type)
  286. r = c->table_rV[V];
  287. g = c->table_gU[U] + c->table_gV[V];
  288. b = c->table_bU[U];
  290. #define YSCALE_YUV_2_PACKED2_C 
  291. for(i=0; i<(dstW>>1); i++){
  292. const int i2= 2*i;
  293. int Y1= (buf0[i2  ]*yalpha1+buf1[i2  ]*yalpha)>>19;
  294. int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>19;
  295. int U= (uvbuf0[i     ]*uvalpha1+uvbuf1[i     ]*uvalpha)>>19;
  296. int V= (uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19;
  298. #define YSCALE_YUV_2_RGB2_C(type) 
  299. YSCALE_YUV_2_PACKED2_C
  300. type *r, *b, *g;
  301. r = c->table_rV[V];
  302. g = c->table_gU[U] + c->table_gV[V];
  303. b = c->table_bU[U];
  305. #define YSCALE_YUV_2_PACKED1_C 
  306. for(i=0; i<(dstW>>1); i++){
  307. const int i2= 2*i;
  308. int Y1= buf0[i2  ]>>7;
  309. int Y2= buf0[i2+1]>>7;
  310. int U= (uvbuf1[i     ])>>7;
  311. int V= (uvbuf1[i+2048])>>7;
  313. #define YSCALE_YUV_2_RGB1_C(type) 
  314. YSCALE_YUV_2_PACKED1_C
  315. type *r, *b, *g;
  316. r = c->table_rV[V];
  317. g = c->table_gU[U] + c->table_gV[V];
  318. b = c->table_bU[U];
  320. #define YSCALE_YUV_2_PACKED1B_C 
  321. for(i=0; i<(dstW>>1); i++){
  322. const int i2= 2*i;
  323. int Y1= buf0[i2  ]>>7;
  324. int Y2= buf0[i2+1]>>7;
  325. int U= (uvbuf0[i     ] + uvbuf1[i     ])>>8;
  326. int V= (uvbuf0[i+2048] + uvbuf1[i+2048])>>8;
  328. #define YSCALE_YUV_2_RGB1B_C(type) 
  329. YSCALE_YUV_2_PACKED1B_C
  330. type *r, *b, *g;
  331. r = c->table_rV[V];
  332. g = c->table_gU[U] + c->table_gV[V];
  333. b = c->table_bU[U];
  335. #define YSCALE_YUV_2_ANYRGB_C(func, func2)
  336. switch(c->dstFormat)
  337. {
  338. case IMGFMT_BGR32:
  339. case IMGFMT_RGB32:
  340. func(uint32_t)
  341. ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];
  342. ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];
  343. }
  344. break;
  345. case IMGFMT_RGB24:
  346. func(uint8_t)
  347. ((uint8_t*)dest)[0]= r[Y1];
  348. ((uint8_t*)dest)[1]= g[Y1];
  349. ((uint8_t*)dest)[2]= b[Y1];
  350. ((uint8_t*)dest)[3]= r[Y2];
  351. ((uint8_t*)dest)[4]= g[Y2];
  352. ((uint8_t*)dest)[5]= b[Y2];
  353. dest+=6;
  354. }
  355. break;
  356. case IMGFMT_BGR24:
  357. func(uint8_t)
  358. ((uint8_t*)dest)[0]= b[Y1];
  359. ((uint8_t*)dest)[1]= g[Y1];
  360. ((uint8_t*)dest)[2]= r[Y1];
  361. ((uint8_t*)dest)[3]= b[Y2];
  362. ((uint8_t*)dest)[4]= g[Y2];
  363. ((uint8_t*)dest)[5]= r[Y2];
  364. dest+=6;
  365. }
  366. break;
  367. case IMGFMT_RGB16:
  368. case IMGFMT_BGR16:
  369. {
  370. const int dr1= dither_2x2_8[y&1    ][0];
  371. const int dg1= dither_2x2_4[y&1    ][0];
  372. const int db1= dither_2x2_8[(y&1)^1][0];
  373. const int dr2= dither_2x2_8[y&1    ][1];
  374. const int dg2= dither_2x2_4[y&1    ][1];
  375. const int db2= dither_2x2_8[(y&1)^1][1];
  376. func(uint16_t)
  377. ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
  378. ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
  379. }
  380. }
  381. break;
  382. case IMGFMT_RGB15:
  383. case IMGFMT_BGR15:
  384. {
  385. const int dr1= dither_2x2_8[y&1    ][0];
  386. const int dg1= dither_2x2_8[y&1    ][1];
  387. const int db1= dither_2x2_8[(y&1)^1][0];
  388. const int dr2= dither_2x2_8[y&1    ][1];
  389. const int dg2= dither_2x2_8[y&1    ][0];
  390. const int db2= dither_2x2_8[(y&1)^1][1];
  391. func(uint16_t)
  392. ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
  393. ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
  394. }
  395. }
  396. break;
  397. case IMGFMT_RGB8:
  398. case IMGFMT_BGR8:
  399. {
  400. const uint8_t * const d64= dither_8x8_73[y&7];
  401. const uint8_t * const d32= dither_8x8_32[y&7];
  402. func(uint8_t)
  403. ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];
  404. ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];
  405. }
  406. }
  407. break;
  408. case IMGFMT_RGB4:
  409. case IMGFMT_BGR4:
  410. {
  411. const uint8_t * const d64= dither_8x8_73 [y&7];
  412. const uint8_t * const d128=dither_8x8_220[y&7];
  413. func(uint8_t)
  414. ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]
  415.                  + ((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);
  416. }
  417. }
  418. break;
  419. case IMGFMT_RG4B:
  420. case IMGFMT_BG4B:
  421. {
  422. const uint8_t * const d64= dither_8x8_73 [y&7];
  423. const uint8_t * const d128=dither_8x8_220[y&7];
  424. func(uint8_t)
  425. ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];
  426. ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];
  427. }
  428. }
  429. break;
  430. case IMGFMT_RGB1:
  431. case IMGFMT_BGR1:
  432. {
  433. const uint8_t * const d128=dither_8x8_220[y&7];
  434. uint8_t *g= c->table_gU[128] + c->table_gV[128];
  435. for(i=0; i<dstW-7; i+=8){
  436. int acc;
  437. acc =       g[((buf0[i  ]*yalpha1+buf1[i  ]*yalpha)>>19) + d128[0]];
  438. acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];
  439. acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];
  440. acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];
  441. acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];
  442. acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];
  443. acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];
  444. acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];
  445. ((uint8_t*)dest)[0]= acc;
  446. dest++;
  447. }
  449. /*
  450. ((uint8_t*)dest)-= dstW>>4;
  451. {
  452. int acc=0;
  453. int left=0;
  454. static int top[1024];
  455. static int last_new[1024][1024];
  456. static int last_in3[1024][1024];
  457. static int drift[1024][1024];
  458. int topLeft=0;
  459. int shift=0;
  460. int count=0;
  461. const uint8_t * const d128=dither_8x8_220[y&7];
  462. int error_new=0;
  463. int error_in3=0;
  464. int f=0;
  466. for(i=dstW>>1; i<dstW; i++){
  467. int in= ((buf0[i  ]*yalpha1+buf1[i  ]*yalpha)>>19);
  468. int in2 = (76309 * (in - 16) + 32768) >> 16;
  469. int in3 = (in2 < 0) ? 0 : ((in2 > 255) ? 255 : in2);
  470. int old= (left*7 + topLeft + top[i]*5 + top[i+1]*3)/20 + in3
  471. + (last_new[y][i] - in3)*f/256;
  472. int new= old> 128 ? 255 : 0;
  474. error_new+= ABS(last_new[y][i] - new);
  475. error_in3+= ABS(last_in3[y][i] - in3);
  476. f= error_new - error_in3*4;
  477. if(f<0) f=0;
  478. if(f>256) f=256;
  480. topLeft= top[i];
  481. left= top[i]= old - new;
  482. last_new[y][i]= new;
  483. last_in3[y][i]= in3;
  485. acc+= acc + (new&1);
  486. if((i&7)==6){
  487. ((uint8_t*)dest)[0]= acc;
  488. ((uint8_t*)dest)++;
  489. }
  490. }
  491. }
  492. */
  493. }
  494. break;
  495. case IMGFMT_YUY2:
  496. func2
  497. ((uint8_t*)dest)[2*i2+0]= Y1;
  498. ((uint8_t*)dest)[2*i2+1]= U;
  499. ((uint8_t*)dest)[2*i2+2]= Y2;
  500. ((uint8_t*)dest)[2*i2+3]= V;
  501. }
  502. break;
  503. case IMGFMT_UYVY:
  504. func2
  505. ((uint8_t*)dest)[2*i2+0]= U;
  506. ((uint8_t*)dest)[2*i2+1]= Y1;
  507. ((uint8_t*)dest)[2*i2+2]= V;
  508. ((uint8_t*)dest)[2*i2+3]= Y2;
  509. }
  510. break;
  511. }
  514. static inline void yuv2packedXinC(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
  515.     int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
  516.     uint8_t *dest, int dstW, int y)
  517. {
  518. int i;
  519. switch(c->dstFormat)
  520. {
  521. case IMGFMT_RGB32:
  522. case IMGFMT_BGR32:
  523. YSCALE_YUV_2_RGBX_C(uint32_t)
  524. ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];
  525. ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];
  526. }
  527. break;
  528. case IMGFMT_RGB24:
  529. YSCALE_YUV_2_RGBX_C(uint8_t)
  530. ((uint8_t*)dest)[0]= r[Y1];
  531. ((uint8_t*)dest)[1]= g[Y1];
  532. ((uint8_t*)dest)[2]= b[Y1];
  533. ((uint8_t*)dest)[3]= r[Y2];
  534. ((uint8_t*)dest)[4]= g[Y2];
  535. ((uint8_t*)dest)[5]= b[Y2];
  536. dest+=6;
  537. }
  538. break;
  539. case IMGFMT_BGR24:
  540. YSCALE_YUV_2_RGBX_C(uint8_t)
  541. ((uint8_t*)dest)[0]= b[Y1];
  542. ((uint8_t*)dest)[1]= g[Y1];
  543. ((uint8_t*)dest)[2]= r[Y1];
  544. ((uint8_t*)dest)[3]= b[Y2];
  545. ((uint8_t*)dest)[4]= g[Y2];
  546. ((uint8_t*)dest)[5]= r[Y2];
  547. dest+=6;
  548. }
  549. break;
  550. case IMGFMT_RGB16:
  551. case IMGFMT_BGR16:
  552. {
  553. const int dr1= dither_2x2_8[y&1    ][0];
  554. const int dg1= dither_2x2_4[y&1    ][0];
  555. const int db1= dither_2x2_8[(y&1)^1][0];
  556. const int dr2= dither_2x2_8[y&1    ][1];
  557. const int dg2= dither_2x2_4[y&1    ][1];
  558. const int db2= dither_2x2_8[(y&1)^1][1];
  559. YSCALE_YUV_2_RGBX_C(uint16_t)
  560. ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
  561. ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
  562. }
  563. }
  564. break;
  565. case IMGFMT_RGB15:
  566. case IMGFMT_BGR15:
  567. {
  568. const int dr1= dither_2x2_8[y&1    ][0];
  569. const int dg1= dither_2x2_8[y&1    ][1];
  570. const int db1= dither_2x2_8[(y&1)^1][0];
  571. const int dr2= dither_2x2_8[y&1    ][1];
  572. const int dg2= dither_2x2_8[y&1    ][0];
  573. const int db2= dither_2x2_8[(y&1)^1][1];
  574. YSCALE_YUV_2_RGBX_C(uint16_t)
  575. ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
  576. ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
  577. }
  578. }
  579. break;
  580. case IMGFMT_RGB8:
  581. case IMGFMT_BGR8:
  582. {
  583. const uint8_t * const d64= dither_8x8_73[y&7];
  584. const uint8_t * const d32= dither_8x8_32[y&7];
  585. YSCALE_YUV_2_RGBX_C(uint8_t)
  586. ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];
  587. ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];
  588. }
  589. }
  590. break;
  591. case IMGFMT_RGB4:
  592. case IMGFMT_BGR4:
  593. {
  594. const uint8_t * const d64= dither_8x8_73 [y&7];
  595. const uint8_t * const d128=dither_8x8_220[y&7];
  596. YSCALE_YUV_2_RGBX_C(uint8_t)
  597. ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]
  598.                   +((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);
  599. }
  600. }
  601. break;
  602. case IMGFMT_RG4B:
  603. case IMGFMT_BG4B:
  604. {
  605. const uint8_t * const d64= dither_8x8_73 [y&7];
  606. const uint8_t * const d128=dither_8x8_220[y&7];
  607. YSCALE_YUV_2_RGBX_C(uint8_t)
  608. ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];
  609. ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];
  610. }
  611. }
  612. break;
  613. case IMGFMT_RGB1:
  614. case IMGFMT_BGR1:
  615. {
  616. const uint8_t * const d128=dither_8x8_220[y&7];
  617. uint8_t *g= c->table_gU[128] + c->table_gV[128];
  618. int acc=0;
  619. for(i=0; i<dstW-1; i+=2){
  620. int j;
  621. int Y1=1<<18;
  622. int Y2=1<<18;
  624. for(j=0; j<lumFilterSize; j++)
  625. {
  626. Y1 += lumSrc[j][i] * lumFilter[j];
  627. Y2 += lumSrc[j][i+1] * lumFilter[j];
  628. }
  629. Y1>>=19;
  630. Y2>>=19;
  631. if((Y1|Y2)&256)
  632. {
  633. if(Y1>255)   Y1=255;
  634. else if(Y1<0)Y1=0;
  635. if(Y2>255)   Y2=255;
  636. else if(Y2<0)Y2=0;
  637. }
  638. acc+= acc + g[Y1+d128[(i+0)&7]];
  639. acc+= acc + g[Y2+d128[(i+1)&7]];
  640. if((i&7)==6){
  641. ((uint8_t*)dest)[0]= acc;
  642. dest++;
  643. }
  644. }
  645. }
  646. break;
  647. case IMGFMT_YUY2:
  648. YSCALE_YUV_2_PACKEDX_C(void)
  649. ((uint8_t*)dest)[2*i2+0]= Y1;
  650. ((uint8_t*)dest)[2*i2+1]= U;
  651. ((uint8_t*)dest)[2*i2+2]= Y2;
  652. ((uint8_t*)dest)[2*i2+3]= V;
  653. }
  654.                 break;
  655. case IMGFMT_UYVY:
  656. YSCALE_YUV_2_PACKEDX_C(void)
  657. ((uint8_t*)dest)[2*i2+0]= U;
  658. ((uint8_t*)dest)[2*i2+1]= Y1;
  659. ((uint8_t*)dest)[2*i2+2]= V;
  660. ((uint8_t*)dest)[2*i2+3]= Y2;
  661. }
  662.                 break;
  663. }
  664. }
  667. //Note: we have C, X86, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
  668. //Plain C versions
  669. #if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT)
  670. #define COMPILE_C
  671. #endif
  673. #ifdef ARCH_POWERPC
  674. #ifdef HAVE_ALTIVEC
  675. #define COMPILE_ALTIVEC
  676. #endif //HAVE_ALTIVEC
  677. #endif //ARCH_POWERPC
  679. #ifdef ARCH_X86
  681. #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
  682. #define COMPILE_MMX
  683. #endif
  685. #if defined (HAVE_MMX2) || defined (RUNTIME_CPUDETECT)
  686. #define COMPILE_MMX2
  687. #endif
  689. #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
  690. #define COMPILE_3DNOW
  691. #endif
  692. #endif //ARCH_X86
  694. #undef HAVE_MMX
  695. #undef HAVE_MMX2
  696. #undef HAVE_3DNOW
  698. #ifdef COMPILE_C
  699. #undef HAVE_MMX
  700. #undef HAVE_MMX2
  701. #undef HAVE_3DNOW
  702. #undef HAVE_ALTIVEC
  703. #define RENAME(a) a ## _C
  704. #include "swscale_template.c"
  705. #endif
  707. #ifdef ARCH_POWERPC
  708. #ifdef COMPILE_ALTIVEC
  709. #undef RENAME
  710. #define HAVE_ALTIVEC
  711. #define RENAME(a) a ## _altivec
  712. #include "swscale_template.c"
  713. #endif
  714. #endif //ARCH_POWERPC
  716. #ifdef ARCH_X86
  718. //X86 versions
  719. /*
  720. #undef RENAME
  721. #undef HAVE_MMX
  722. #undef HAVE_MMX2
  723. #undef HAVE_3DNOW
  724. #define ARCH_X86
  725. #define RENAME(a) a ## _X86
  726. #include "swscale_template.c"
  727. */
  728. //MMX versions
  729. #ifdef COMPILE_MMX
  730. #undef RENAME
  731. #define HAVE_MMX
  732. #undef HAVE_MMX2
  733. #undef HAVE_3DNOW
  734. #define RENAME(a) a ## _MMX
  735. #include "swscale_template.c"
  736. #endif
  738. //MMX2 versions
  739. #ifdef COMPILE_MMX2
  740. #undef RENAME
  741. #define HAVE_MMX
  742. #define HAVE_MMX2
  743. #undef HAVE_3DNOW
  744. #define RENAME(a) a ## _MMX2
  745. #include "swscale_template.c"
  746. #endif
  748. //3DNOW versions
  749. #ifdef COMPILE_3DNOW
  750. #undef RENAME
  751. #define HAVE_MMX
  752. #undef HAVE_MMX2
  753. #define HAVE_3DNOW
  754. #define RENAME(a) a ## _3DNow
  755. #include "swscale_template.c"
  756. #endif
  758. #endif //ARCH_X86
  760. // minor note: the HAVE_xyz is messed up after that line so don't use it
  762. static double getSplineCoeff(double a, double b, double c, double d, double dist)
  763. {
  764. // printf("%f %f %f %f %fn", a,b,c,d,dist);
  765. if(dist<=1.0)  return ((d*dist + c)*dist + b)*dist +a;
  766. else return getSplineCoeff( 0.0, 
  767.  b+ 2.0*c + 3.0*d,
  768.         c + 3.0*d,
  769. -b- 3.0*c - 6.0*d,
  770. dist-1.0);
  771. }
  773. static inline void initFilter(int16_t **outFilter, int16_t **filterPos, int *outFilterSize, int xInc,
  774.       int srcW, int dstW, int filterAlign, int one, int flags,
  775.       SwsVector *srcFilter, SwsVector *dstFilter)
  776. {
  777. int i;
  778. int filterSize;
  779. int filter2Size;
  780. int minFilterSize;
  781. double *filter=NULL;
  782. double *filter2=NULL;
  783. #ifdef ARCH_X86
  784. if(flags & SWS_CPU_CAPS_MMX)
  785. asm volatile("emmsnt"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
  786. #endif
  788. // Note the +1 is for the MMXscaler which reads over the end
  789. *filterPos = (int16_t*)memalign(8, (dstW+1)*sizeof(int16_t));
  791. if(ABS(xInc - 0x10000) <10) // unscaled
  792. {
  793. int i;
  794. filterSize= 1;
  795. filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
  796. for(i=0; i<dstW*filterSize; i++) filter[i]=0;
  798. for(i=0; i<dstW; i++)
  799. {
  800. filter[i*filterSize]=1;
  801. (*filterPos)[i]=i;
  802. }
  804. }
  805. else if(flags&SWS_POINT) // lame looking point sampling mode
  806. {
  807. int i;
  808. int xDstInSrc;
  809. filterSize= 1;
  810. filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
  812. xDstInSrc= xInc/2 - 0x8000;
  813. for(i=0; i<dstW; i++)
  814. {
  815. int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
  817. (*filterPos)[i]= xx;
  818. filter[i]= 1.0;
  819. xDstInSrc+= xInc;
  820. }
  821. }
  822. else if((xInc <= (1<<16) && (flags&SWS_AREA)) || (flags&SWS_FAST_BILINEAR)) // bilinear upscale
  823. {
  824. int i;
  825. int xDstInSrc;
  826. if     (flags&SWS_BICUBIC) filterSize= 4;
  827. else if(flags&SWS_X      ) filterSize= 4;
  828. else    filterSize= 2; // SWS_BILINEAR / SWS_AREA 
  829. filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
  831. xDstInSrc= xInc/2 - 0x8000;
  832. for(i=0; i<dstW; i++)
  833. {
  834. int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
  835. int j;
  837. (*filterPos)[i]= xx;
  838. //Bilinear upscale / linear interpolate / Area averaging
  839. for(j=0; j<filterSize; j++)
  840. {
  841. double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
  842. double coeff= 1.0 - d;
  843. if(coeff<0) coeff=0;
  844. filter[i*filterSize + j]= coeff;
  845. xx++;
  846. }
  847. xDstInSrc+= xInc;
  848. }
  849. }
  850. else
  851. {
  852. double xDstInSrc;
  853. double sizeFactor, filterSizeInSrc;
  854. const double xInc1= (double)xInc / (double)(1<<16);
  855. int param= (flags&SWS_PARAM_MASK)>>SWS_PARAM_SHIFT;
  857. if     (flags&SWS_BICUBIC) sizeFactor= 4.0;
  858. else if(flags&SWS_X) sizeFactor= 8.0;
  859. else if(flags&SWS_AREA) sizeFactor= 1.0; //downscale only, for upscale it is bilinear
  860. else if(flags&SWS_GAUSS) sizeFactor= 8.0;   // infinite ;)
  861. else if(flags&SWS_LANCZOS) sizeFactor= param ? 2.0*param : 6.0;
  862. else if(flags&SWS_SINC) sizeFactor= 20.0; // infinite ;)
  863. else if(flags&SWS_SPLINE) sizeFactor= 20.0;  // infinite ;)
  864. else if(flags&SWS_BILINEAR) sizeFactor= 2.0;
  865. else {
  866. sizeFactor= 0.0; //GCC warning killer
  867. ASSERT(0)
  868. }
  870. if(xInc1 <= 1.0) filterSizeInSrc= sizeFactor; // upscale
  871. else filterSizeInSrc= sizeFactor*srcW / (double)dstW;
  873. filterSize= (int)ceil(1 + filterSizeInSrc); // will be reduced later if possible
  874. if(filterSize > srcW-2) filterSize=srcW-2;
  876. filter= (double*)memalign(16, dstW*sizeof(double)*filterSize);
  878. xDstInSrc= xInc1 / 2.0 - 0.5;
  879. for(i=0; i<dstW; i++)
  880. {
  881. int xx= (int)(xDstInSrc - (filterSize-1)*0.5 + 0.5);
  882. int j;
  883. (*filterPos)[i]= xx;
  884. for(j=0; j<filterSize; j++)
  885. {
  886. double d= ABS(xx - xDstInSrc)/filterSizeInSrc*sizeFactor;
  887. double coeff;
  888. if(flags & SWS_BICUBIC)
  889. {
  890. double A= param ? -param*0.01 : -0.60;
  892. // Equation is from VirtualDub
  893. if(d<1.0)
  894. coeff = (1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
  895. else if(d<2.0)
  896. coeff = (-4.0*A + 8.0*A*d - 5.0*A*d*d + A*d*d*d);
  897. else
  898. coeff=0.0;
  899. }
  900. /* else if(flags & SWS_X)
  901. {
  902. double p= param ? param*0.01 : 0.3;
  903. coeff = d ? sin(d*PI)/(d*PI) : 1.0;
  904. coeff*= pow(2.0, - p*d*d);
  905. }*/
  906. else if(flags & SWS_X)
  907. {
  908. double A= param ? param*0.1 : 1.0;
  910. if(d<1.0)
  911. coeff = cos(d*PI);
  912. else
  913. coeff=-1.0;
  914. if(coeff<0.0)  coeff= -pow(-coeff, A);
  915. else coeff=  pow( coeff, A);
  916. coeff= coeff*0.5 + 0.5;
  917. }
  918. else if(flags & SWS_AREA)
  919. {
  920. double srcPixelSize= 1.0/xInc1;
  921. if(d + srcPixelSize/2 < 0.5) coeff= 1.0;
  922. else if(d - srcPixelSize/2 < 0.5) coeff= (0.5-d)/srcPixelSize + 0.5;
  923. else coeff=0.0;
  924. }
  925. else if(flags & SWS_GAUSS)
  926. {
  927. double p= param ? param*0.1 : 3.0;
  928. coeff = pow(2.0, - p*d*d);
  929. }
  930. else if(flags & SWS_SINC)
  931. {
  932. coeff = d ? sin(d*PI)/(d*PI) : 1.0;
  933. }
  934. else if(flags & SWS_LANCZOS)
  935. {
  936. double p= param ? param : 3.0; 
  937. coeff = d ? sin(d*PI)*sin(d*PI/p)/(d*d*PI*PI/p) : 1.0;
  938. if(d>p) coeff=0;
  939. }
  940. else if(flags & SWS_BILINEAR)
  941. {
  942. coeff= 1.0 - d;
  943. if(coeff<0) coeff=0;
  944. }
  945. else if(flags & SWS_SPLINE)
  946. {
  947. double p=-2.196152422706632;
  948. coeff = getSplineCoeff(1.0, 0.0, p, -p-1.0, d);
  949. }
  950. else {
  951. coeff= 0.0; //GCC warning killer
  952. ASSERT(0)
  953. }
  955. filter[i*filterSize + j]= coeff;
  956. xx++;
  957. }
  958. xDstInSrc+= xInc1;
  959. }
  960. }
  962. /* apply src & dst Filter to filter -> filter2
  963.    free(filter);
  964. */
  965. ASSERT(filterSize>0)
  966. filter2Size= filterSize;
  967. if(srcFilter) filter2Size+= srcFilter->length - 1;
  968. if(dstFilter) filter2Size+= dstFilter->length - 1;
  969. ASSERT(filter2Size>0)
  970. filter2= (double*)memalign(8, filter2Size*dstW*sizeof(double));
  972. for(i=0; i<dstW; i++)
  973. {
  974. int j;
  975. SwsVector scaleFilter;
  976. SwsVector *outVec;
  978. scaleFilter.coeff= filter + i*filterSize;
  979. scaleFilter.length= filterSize;
  981. if(srcFilter) outVec= sws_getConvVec(srcFilter, &scaleFilter);
  982. else       outVec= &scaleFilter;
  984. ASSERT(outVec->length == filter2Size)
  985. //FIXME dstFilter
  987. for(j=0; j<outVec->length; j++)
  988. {
  989. filter2[i*filter2Size + j]= outVec->coeff[j];
  990. }
  992. (*filterPos)[i]+= (filterSize-1)/2 - (filter2Size-1)/2;
  994. if(outVec != &scaleFilter) sws_freeVec(outVec);
  995. }
  996. free(filter); filter=NULL;
  998. /* try to reduce the filter-size (step1 find size and shift left) */
  999. // Assume its near normalized (*0.5 or *2.0 is ok but * 0.001 is not)
  1000. minFilterSize= 0;
  1001. for(i=dstW-1; i>=0; i--)
  1002. {
  1003. int min= filter2Size;
  1004. int j;
  1005. double cutOff=0.0;
  1007. /* get rid off near zero elements on the left by shifting left */
  1008. for(j=0; j<filter2Size; j++)
  1009. {
  1010. int k;
  1011. cutOff += ABS(filter2[i*filter2Size]);
  1013. if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
  1015. /* preserve Monotonicity because the core can't handle the filter otherwise */
  1016. if(i<dstW-1 && (*filterPos)[i] >= (*filterPos)[i+1]) break;
  1018. // Move filter coeffs left
  1019. for(k=1; k<filter2Size; k++)
  1020. filter2[i*filter2Size + k - 1]= filter2[i*filter2Size + k];
  1021. filter2[i*filter2Size + k - 1]= 0.0;
  1022. (*filterPos)[i]++;
  1023. }
  1025. cutOff=0.0;
  1026. /* count near zeros on the right */
  1027. for(j=filter2Size-1; j>0; j--)
  1028. {
  1029. cutOff += ABS(filter2[i*filter2Size + j]);
  1031. if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
  1032. min--;
  1033. }
  1035. if(min>minFilterSize) minFilterSize= min;
  1036. }
  1038.         if (flags & SWS_CPU_CAPS_ALTIVEC) {
  1039.           // we can handle the special case 4,
  1040.           // so we don't want to go to the full 8
  1041.           if (minFilterSize < 5)
  1042.             filterAlign = 4;
  1044.           // we really don't want to waste our time
  1045.           // doing useless computation, so fall-back on
  1046.           // the scalar C code for very small filter.
  1047.           // vectorizing is worth it only if you have
  1048.           // decent-sized vector.
  1049.           if (minFilterSize < 3)
  1050.             filterAlign = 1;
  1051.         }
  1053. ASSERT(minFilterSize > 0)
  1054. filterSize= (minFilterSize +(filterAlign-1)) & (~(filterAlign-1));
  1055. ASSERT(filterSize > 0)
  1056. filter= (double*)memalign(8, filterSize*dstW*sizeof(double));
  1057. *outFilterSize= filterSize;
  1059. if(flags&SWS_PRINT_INFO)
  1060. MSG_INFO("SwScaler: reducing / aligning filtersize %d -> %dn", filter2Size, filterSize);
  1061. /* try to reduce the filter-size (step2 reduce it) */
  1062. for(i=0; i<dstW; i++)
  1063. {
  1064. int j;
  1066. for(j=0; j<filterSize; j++)
  1067. {
  1068. if(j>=filter2Size) filter[i*filterSize + j]= 0.0;
  1069. else    filter[i*filterSize + j]= filter2[i*filter2Size + j];
  1070. }
  1071. }
  1072. free(filter2); filter2=NULL;
  1075. //FIXME try to align filterpos if possible
  1077. //fix borders
  1078. for(i=0; i<dstW; i++)
  1079. {
  1080. int j;
  1081. if((*filterPos)[i] < 0)
  1082. {
  1083. // Move filter coeffs left to compensate for filterPos
  1084. for(j=1; j<filterSize; j++)
  1085. {
  1086. int left= MAX(j + (*filterPos)[i], 0);
  1087. filter[i*filterSize + left] += filter[i*filterSize + j];
  1088. filter[i*filterSize + j]=0;
  1089. }
  1090. (*filterPos)[i]= 0;
  1091. }
  1093. if((*filterPos)[i] + filterSize > srcW)
  1094. {
  1095. int shift= (*filterPos)[i] + filterSize - srcW;
  1096. // Move filter coeffs right to compensate for filterPos
  1097. for(j=filterSize-2; j>=0; j--)
  1098. {
  1099. int right= MIN(j + shift, filterSize-1);
  1100. filter[i*filterSize +right] += filter[i*filterSize +j];
  1101. filter[i*filterSize +j]=0;
  1102. }
  1103. (*filterPos)[i]= srcW - filterSize;
  1104. }
  1105. }
  1107. // Note the +1 is for the MMXscaler which reads over the end
  1108. *outFilter= (int16_t*)memalign(8, *outFilterSize*(dstW+1)*sizeof(int16_t));
  1109. memset(*outFilter, 0, *outFilterSize*(dstW+1)*sizeof(int16_t));
  1111. /* Normalize & Store in outFilter */
  1112. for(i=0; i<dstW; i++)
  1113. {
  1114. int j;
  1115. double error=0;
  1116. double sum=0;
  1117. double scale= one;
  1119. for(j=0; j<filterSize; j++)
  1120. {
  1121. sum+= filter[i*filterSize + j];
  1122. }
  1123. scale/= sum;
  1124. for(j=0; j<*outFilterSize; j++)
  1125. {
  1126. double v= filter[i*filterSize + j]*scale + error;
  1127. int intV= floor(v + 0.5);
  1128. (*outFilter)[i*(*outFilterSize) + j]= intV;
  1129. error = v - intV;
  1130. }
  1131. }
  1133. (*filterPos)[dstW]= (*filterPos)[dstW-1]; // the MMX scaler will read over the end
  1134. for(i=0; i<*outFilterSize; i++)
  1135. {
  1136. int j= dstW*(*outFilterSize);
  1137. (*outFilter)[j + i]= (*outFilter)[j + i - (*outFilterSize)];
  1138. }
  1140. free(filter);
  1141. }
  1143. #ifdef ARCH_X86
  1144. static void initMMX2HScaler(int dstW, int xInc, uint8_t *funnyCode, int16_t *filter, int32_t *filterPos, int numSplits)
  1145. {
  1146. uint8_t *fragmentA;
  1147. int imm8OfPShufW1A;
  1148. int imm8OfPShufW2A;
  1149. int fragmentLengthA;
  1150. uint8_t *fragmentB;
  1151. int imm8OfPShufW1B;
  1152. int imm8OfPShufW2B;
  1153. int fragmentLengthB;
  1154. int fragmentPos;
  1156. int xpos, i;
  1158. // create an optimized horizontal scaling routine
  1160. //code fragment
  1162. asm volatile(
  1163. "jmp 9f nt"
  1164. // Begin
  1165. "0: nt"
  1166. "movq (%%edx, %%eax), %%mm3 nt" 
  1167. "movd (%%ecx, %%esi), %%mm0 nt" 
  1168. "movd 1(%%ecx, %%esi), %%mm1 nt"
  1169. "punpcklbw %%mm7, %%mm1 nt"
  1170. "punpcklbw %%mm7, %%mm0 nt"
  1171. "pshufw $0xFF, %%mm1, %%mm1 nt"
  1172. "1: nt"
  1173. "pshufw $0xFF, %%mm0, %%mm0 nt"
  1174. "2: nt"
  1175. "psubw %%mm1, %%mm0 nt"
  1176. "movl 8(%%ebx, %%eax), %%esi nt"
  1177. "pmullw %%mm3, %%mm0 nt"
  1178. "psllw $7, %%mm1 nt"
  1179. "paddw %%mm1, %%mm0 nt"
  1181. "movq %%mm0, (%%edi, %%eax) nt"
  1183. "addl $8, %%eax nt"
  1184. // End
  1185. "9: nt"
  1186. // "int $3nt"
  1187. "leal 0b, %0 nt"
  1188. "leal 1b, %1 nt"
  1189. "leal 2b, %2 nt"
  1190. "decl %1 nt"
  1191. "decl %2 nt"
  1192. "subl %0, %1 nt"
  1193. "subl %0, %2 nt"
  1194. "leal 9b, %3 nt"
  1195. "subl %0, %3 nt"
  1198. :"=r" (fragmentA), "=r" (imm8OfPShufW1A), "=r" (imm8OfPShufW2A),
  1199. "=r" (fragmentLengthA)
  1200. );
  1202. asm volatile(
  1203. "jmp 9f nt"
  1204. // Begin
  1205. "0: nt"
  1206. "movq (%%edx, %%eax), %%mm3 nt" 
  1207. "movd (%%ecx, %%esi), %%mm0 nt" 
  1208. "punpcklbw %%mm7, %%mm0 nt"
  1209. "pshufw $0xFF, %%mm0, %%mm1 nt"
  1210. "1: nt"
  1211. "pshufw $0xFF, %%mm0, %%mm0 nt"
  1212. "2: nt"
  1213. "psubw %%mm1, %%mm0 nt"
  1214. "movl 8(%%ebx, %%eax), %%esi nt"
  1215. "pmullw %%mm3, %%mm0 nt"
  1216. "psllw $7, %%mm1 nt"
  1217. "paddw %%mm1, %%mm0 nt"
  1219. "movq %%mm0, (%%edi, %%eax) nt"
  1221. "addl $8, %%eax nt"
  1222. // End
  1223. "9: nt"
  1224. // "int $3nt"
  1225. "leal 0b, %0 nt"
  1226. "leal 1b, %1 nt"
  1227. "leal 2b, %2 nt"
  1228. "decl %1 nt"
  1229. "decl %2 nt"
  1230. "subl %0, %1 nt"
  1231. "subl %0, %2 nt"
  1232. "leal 9b, %3 nt"
  1233. "subl %0, %3 nt"
  1236. :"=r" (fragmentB), "=r" (imm8OfPShufW1B), "=r" (imm8OfPShufW2B),
  1237. "=r" (fragmentLengthB)
  1238. );
  1240. xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers
  1241. fragmentPos=0;
  1243. for(i=0; i<dstW/numSplits; i++)
  1244. {
  1245. int xx=xpos>>16;
  1247. if((i&3) == 0)
  1248. {
  1249. int a=0;
  1250. int b=((xpos+xInc)>>16) - xx;
  1251. int c=((xpos+xInc*2)>>16) - xx;
  1252. int d=((xpos+xInc*3)>>16) - xx;
  1254. filter[i  ] = (( xpos         & 0xFFFF) ^ 0xFFFF)>>9;
  1255. filter[i+1] = (((xpos+xInc  ) & 0xFFFF) ^ 0xFFFF)>>9;
  1256. filter[i+2] = (((xpos+xInc*2) & 0xFFFF) ^ 0xFFFF)>>9;
  1257. filter[i+3] = (((xpos+xInc*3) & 0xFFFF) ^ 0xFFFF)>>9;
  1258. filterPos[i/2]= xx;
  1260. if(d+1<4)
  1261. {
  1262. int maxShift= 3-(d+1);
  1263. int shift=0;
  1265. memcpy(funnyCode + fragmentPos, fragmentB, fragmentLengthB);
  1267. funnyCode[fragmentPos + imm8OfPShufW1B]=
  1268. (a+1) | ((b+1)<<2) | ((c+1)<<4) | ((d+1)<<6);
  1269. funnyCode[fragmentPos + imm8OfPShufW2B]=
  1270. a | (b<<2) | (c<<4) | (d<<6);
  1272. if(i+3>=dstW) shift=maxShift; //avoid overread
  1273. else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //Align
  1275. if(shift && i>=shift)
  1276. {
  1277. funnyCode[fragmentPos + imm8OfPShufW1B]+= 0x55*shift;
  1278. funnyCode[fragmentPos + imm8OfPShufW2B]+= 0x55*shift;
  1279. filterPos[i/2]-=shift;
  1280. }
  1282. fragmentPos+= fragmentLengthB;
  1283. }
  1284. else
  1285. {
  1286. int maxShift= 3-d;
  1287. int shift=0;
  1289. memcpy(funnyCode + fragmentPos, fragmentA, fragmentLengthA);
  1291. funnyCode[fragmentPos + imm8OfPShufW1A]=
  1292. funnyCode[fragmentPos + imm8OfPShufW2A]=
  1293. a | (b<<2) | (c<<4) | (d<<6);
  1295. if(i+4>=dstW) shift=maxShift; //avoid overread
  1296. else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //partial align
  1298. if(shift && i>=shift)
  1299. {
  1300. funnyCode[fragmentPos + imm8OfPShufW1A]+= 0x55*shift;
  1301. funnyCode[fragmentPos + imm8OfPShufW2A]+= 0x55*shift;
  1302. filterPos[i/2]-=shift;
  1303. }
  1305. fragmentPos+= fragmentLengthA;
  1306. }
  1308. funnyCode[fragmentPos]= RET;
  1309. }
  1310. xpos+=xInc;
  1311. }
  1312. filterPos[i/2]= xpos>>16; // needed to jump to the next part
  1313. }
  1314. #endif // ARCH_X86
  1316. static void globalInit(){
  1317.     // generating tables:
  1318.     int i;
  1319.     for(i=0; i<768; i++){
  1320. int c= MIN(MAX(i-256, 0), 255);
  1321. clip_table[i]=c;
  1322.     }
  1323. }
  1325. static SwsFunc getSwsFunc(int flags){
  1326.     
  1327. #ifdef RUNTIME_CPUDETECT
  1328. #ifdef ARCH_X86
  1329. // ordered per speed fasterst first
  1330. if(flags & SWS_CPU_CAPS_MMX2)
  1331. return swScale_MMX2;
  1332. else if(flags & SWS_CPU_CAPS_3DNOW)
  1333. return swScale_3DNow;
  1334. else if(flags & SWS_CPU_CAPS_MMX)
  1335. return swScale_MMX;
  1336. else
  1337. return swScale_C;
  1339. #else
  1340. #ifdef ARCH_POWERPC
  1341. if(flags & SWS_CPU_CAPS_ALTIVEC)
  1342.   return swScale_altivec;
  1343. else
  1344.   return swScale_C;
  1345. #endif
  1346. return swScale_C;
  1347. #endif
  1348. #else //RUNTIME_CPUDETECT
  1349. #ifdef HAVE_MMX2
  1350. return swScale_MMX2;
  1351. #elif defined (HAVE_3DNOW)
  1352. return swScale_3DNow;
  1353. #elif defined (HAVE_MMX)
  1354. return swScale_MMX;
  1355. #elif defined (HAVE_ALTIVEC)
  1356. return swScale_altivec;
  1357. #else
  1358. return swScale_C;
  1359. #endif
  1360. #endif //!RUNTIME_CPUDETECT
  1361. }
  1363. static int PlanarToNV12Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1364.              int srcSliceH, uint8_t* dstParam[], int dstStride[]){
  1365. uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
  1366. /* Copy Y plane */
  1367. if(dstStride[0]==srcStride[0])
  1368. memcpy(dst, src[0], srcSliceH*dstStride[0]);
  1369. else
  1370. {
  1371. int i;
  1372. uint8_t *srcPtr= src[0];
  1373. uint8_t *dstPtr= dst;
  1374. for(i=0; i<srcSliceH; i++)
  1375. {
  1376. memcpy(dstPtr, srcPtr, srcStride[0]);
  1377. srcPtr+= srcStride[0];
  1378. dstPtr+= dstStride[0];
  1379. }
  1380. }
  1381. dst = dstParam[1] + dstStride[1]*srcSliceY;
  1382. interleaveBytes( src[1],src[2],dst,c->srcW,srcSliceH,srcStride[1],srcStride[2],dstStride[0] );
  1384. return srcSliceH;
  1385. }
  1387. static int PlanarToYuy2Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1388.              int srcSliceH, uint8_t* dstParam[], int dstStride[]){
  1389. uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
  1391. yv12toyuy2( src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0] );
  1393. return srcSliceH;
  1394. }
  1396. static int PlanarToUyvyWrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1397.              int srcSliceH, uint8_t* dstParam[], int dstStride[]){
  1398. uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
  1400. yv12touyvy( src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0] );
  1402. return srcSliceH;
  1403. }
  1405. /* {RGB,BGR}{15,16,24,32} -> {RGB,BGR}{15,16,24,32} */
  1406. static int rgb2rgbWrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1407.    int srcSliceH, uint8_t* dst[], int dstStride[]){
  1408. const int srcFormat= c->srcFormat;
  1409. const int dstFormat= c->dstFormat;
  1410. const int srcBpp= ((srcFormat&0xFF) + 7)>>3;
  1411. const int dstBpp= ((dstFormat&0xFF) + 7)>>3;
  1412. const int srcId= (srcFormat&0xFF)>>2; // 1:0, 4:1, 8:2, 15:3, 16:4, 24:6, 32:8 
  1413. const int dstId= (dstFormat&0xFF)>>2;
  1414. void (*conv)(const uint8_t *src, uint8_t *dst, unsigned src_size)=NULL;
  1416. /* BGR -> BGR */
  1417. if(   (isBGR(srcFormat) && isBGR(dstFormat))
  1418.    || (isRGB(srcFormat) && isRGB(dstFormat))){
  1419. switch(srcId | (dstId<<4)){
  1420. case 0x34: conv= rgb16to15; break;
  1421. case 0x36: conv= rgb24to15; break;
  1422. case 0x38: conv= rgb32to15; break;
  1423. case 0x43: conv= rgb15to16; break;
  1424. case 0x46: conv= rgb24to16; break;
  1425. case 0x48: conv= rgb32to16; break;
  1426. case 0x63: conv= rgb15to24; break;
  1427. case 0x64: conv= rgb16to24; break;
  1428. case 0x68: conv= rgb32to24; break;
  1429. case 0x83: conv= rgb15to32; break;
  1430. case 0x84: conv= rgb16to32; break;
  1431. case 0x86: conv= rgb24to32; break;
  1432. default: MSG_ERR("swScaler: internal error %s -> %s convertern", 
  1433.  vo_format_name(srcFormat), vo_format_name(dstFormat)); break;
  1434. }
  1435. }else if(   (isBGR(srcFormat) && isRGB(dstFormat))
  1436.  || (isRGB(srcFormat) && isBGR(dstFormat))){
  1437. switch(srcId | (dstId<<4)){
  1438. case 0x33: conv= rgb15tobgr15; break;
  1439. case 0x34: conv= rgb16tobgr15; break;
  1440. case 0x36: conv= rgb24tobgr15; break;
  1441. case 0x38: conv= rgb32tobgr15; break;
  1442. case 0x43: conv= rgb15tobgr16; break;
  1443. case 0x44: conv= rgb16tobgr16; break;
  1444. case 0x46: conv= rgb24tobgr16; break;
  1445. case 0x48: conv= rgb32tobgr16; break;
  1446. case 0x63: conv= rgb15tobgr24; break;
  1447. case 0x64: conv= rgb16tobgr24; break;
  1448. case 0x66: conv= rgb24tobgr24; break;
  1449. case 0x68: conv= rgb32tobgr24; break;
  1450. case 0x83: conv= rgb15tobgr32; break;
  1451. case 0x84: conv= rgb16tobgr32; break;
  1452. case 0x86: conv= rgb24tobgr32; break;
  1453. case 0x88: conv= rgb32tobgr32; break;
  1454. default: MSG_ERR("swScaler: internal error %s -> %s convertern", 
  1455.  vo_format_name(srcFormat), vo_format_name(dstFormat)); break;
  1456. }
  1457. }else{
  1458. MSG_ERR("swScaler: internal error %s -> %s convertern", 
  1459.  vo_format_name(srcFormat), vo_format_name(dstFormat));
  1460. }
  1462. if(dstStride[0]*srcBpp == srcStride[0]*dstBpp)
  1463. conv(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
  1464. else
  1465. {
  1466. int i;
  1467. uint8_t *srcPtr= src[0];
  1468. uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
  1470. for(i=0; i<srcSliceH; i++)
  1471. {
  1472. conv(srcPtr, dstPtr, c->srcW*srcBpp);
  1473. srcPtr+= srcStride[0];
  1474. dstPtr+= dstStride[0];
  1475. }
  1476. }     
  1477. return srcSliceH;
  1478. }
  1480. static int bgr24toyv12Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1481.              int srcSliceH, uint8_t* dst[], int dstStride[]){
  1483. rgb24toyv12(
  1484. src[0], 
  1485. dst[0]+ srcSliceY    *dstStride[0], 
  1486. dst[1]+(srcSliceY>>1)*dstStride[1], 
  1487. dst[2]+(srcSliceY>>1)*dstStride[2],
  1488. c->srcW, srcSliceH, 
  1489. dstStride[0], dstStride[1], srcStride[0]);
  1490. return srcSliceH;
  1491. }
  1493. static int yvu9toyv12Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1494.              int srcSliceH, uint8_t* dst[], int dstStride[]){
  1495. int i;
  1497. /* copy Y */
  1498. if(srcStride[0]==dstStride[0]) 
  1499. memcpy(dst[0]+ srcSliceY*dstStride[0], src[0], srcStride[0]*srcSliceH);
  1500. else{
  1501. uint8_t *srcPtr= src[0];
  1502. uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
  1504. for(i=0; i<srcSliceH; i++)
  1505. {
  1506. memcpy(dstPtr, srcPtr, c->srcW);
  1507. srcPtr+= srcStride[0];
  1508. dstPtr+= dstStride[0];
  1509. }
  1510. }
  1512. if(c->dstFormat==IMGFMT_YV12){
  1513. planar2x(src[1], dst[1], c->chrSrcW, c->chrSrcH, srcStride[1], dstStride[1]);
  1514. planar2x(src[2], dst[2], c->chrSrcW, c->chrSrcH, srcStride[2], dstStride[2]);
  1515. }else{
  1516. planar2x(src[1], dst[2], c->chrSrcW, c->chrSrcH, srcStride[1], dstStride[2]);
  1517. planar2x(src[2], dst[1], c->chrSrcW, c->chrSrcH, srcStride[2], dstStride[1]);
  1518. }
  1519. return srcSliceH;
  1520. }
  1522. /**
  1523.  * bring pointers in YUV order instead of YVU
  1524.  */
  1525. static inline void sws_orderYUV(int format, uint8_t * sortedP[], int sortedStride[], uint8_t * p[], int stride[]){
  1526. if(format == IMGFMT_YV12 || format == IMGFMT_YVU9
  1527.            || format == IMGFMT_444P || format == IMGFMT_422P || format == IMGFMT_411P){
  1528. sortedP[0]= p[0];
  1529. sortedP[1]= p[2];
  1530. sortedP[2]= p[1];
  1531. sortedStride[0]= stride[0];
  1532. sortedStride[1]= stride[2];
  1533. sortedStride[2]= stride[1];
  1534. }
  1535. else if(isPacked(format) || isGray(format) || format == IMGFMT_Y8)
  1536. {
  1537. sortedP[0]= p[0];
  1538. sortedP[1]= 
  1539. sortedP[2]= NULL;
  1540. sortedStride[0]= stride[0];
  1541. sortedStride[1]= 
  1542. sortedStride[2]= 0;
  1543. }
  1544. else if(format == IMGFMT_I420 || format == IMGFMT_IYUV)
  1545. {
  1546. sortedP[0]= p[0];
  1547. sortedP[1]= p[1];
  1548. sortedP[2]= p[2];
  1549. sortedStride[0]= stride[0];
  1550. sortedStride[1]= stride[1];
  1551. sortedStride[2]= stride[2];
  1552. }else{
  1553. MSG_ERR("internal error in orderYUVn");
  1554. }
  1555. }
  1557. /* unscaled copy like stuff (assumes nearly identical formats) */
  1558. static int simpleCopy(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  1559.              int srcSliceH, uint8_t* dst[], int dstStride[]){
  1561. if(isPacked(c->srcFormat))
  1562. {
  1563. if(dstStride[0]==srcStride[0])
  1564. memcpy(dst[0] + dstStride[0]*srcSliceY, src[0], srcSliceH*dstStride[0]);
  1565. else
  1566. {
  1567. int i;
  1568. uint8_t *srcPtr= src[0];
  1569. uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
  1570. int length=0;
  1572. /* universal length finder */
  1573. while(length+c->srcW <= ABS(dstStride[0]) 
  1574.    && length+c->srcW <= ABS(srcStride[0])) length+= c->srcW;
  1575. ASSERT(length!=0);
  1577. for(i=0; i<srcSliceH; i++)
  1578. {
  1579. memcpy(dstPtr, srcPtr, length);
  1580. srcPtr+= srcStride[0];
  1581. dstPtr+= dstStride[0];
  1582. }
  1583. }
  1584. }
  1585. else 
  1586. { /* Planar YUV or gray */
  1587. int plane;
  1588. for(plane=0; plane<3; plane++)
  1589. {
  1590. int length= plane==0 ? c->srcW  : -((-c->srcW  )>>c->chrDstHSubSample);
  1591. int y=      plane==0 ? srcSliceY: -((-srcSliceY)>>c->chrDstVSubSample);
  1592. int height= plane==0 ? srcSliceH: -((-srcSliceH)>>c->chrDstVSubSample);
  1594. if((isGray(c->srcFormat) || isGray(c->dstFormat)) && plane>0)
  1595. {
  1596. if(!isGray(c->dstFormat))
  1597. memset(dst[plane], 128, dstStride[plane]*height);
  1598. }
  1599. else
  1600. {
  1601. if(dstStride[plane]==srcStride[plane])
  1602. memcpy(dst[plane] + dstStride[plane]*y, src[plane], height*dstStride[plane]);
  1603. else
  1604. {
  1605. int i;
  1606. uint8_t *srcPtr= src[plane];
  1607. uint8_t *dstPtr= dst[plane] + dstStride[plane]*y;
  1608. for(i=0; i<height; i++)
  1609. {
  1610. memcpy(dstPtr, srcPtr, length);
  1611. srcPtr+= srcStride[plane];
  1612. dstPtr+= dstStride[plane];
  1613. }
  1614. }
  1615. }
  1616. }
  1617. }
  1618. return srcSliceH;
  1619. }
  1621. static int remove_dup_fourcc(int fourcc)
  1622. {
  1623. switch(fourcc)
  1624. {
  1625.     case IMGFMT_I420:
  1626.     case IMGFMT_IYUV: return IMGFMT_YV12;
  1627.     case IMGFMT_Y8  : return IMGFMT_Y800;
  1628.     case IMGFMT_IF09: return IMGFMT_YVU9;
  1629.     default: return fourcc;
  1630. }
  1631. }
  1633. static void getSubSampleFactors(int *h, int *v, int format){
  1634. switch(format){
  1635. case IMGFMT_UYVY:
  1636. case IMGFMT_YUY2:
  1637. *h=1;
  1638. *v=0;
  1639. break;
  1640. case IMGFMT_YV12:
  1641. case IMGFMT_Y800: //FIXME remove after different subsamplings are fully implemented
  1642. *h=1;
  1643. *v=1;
  1644. break;
  1645. case IMGFMT_YVU9:
  1646. *h=2;
  1647. *v=2;
  1648. break;
  1649. case IMGFMT_444P:
  1650. *h=0;
  1651. *v=0;
  1652. break;
  1653. case IMGFMT_422P:
  1654. *h=1;
  1655. *v=0;
  1656. break;
  1657. case IMGFMT_411P:
  1658. *h=2;
  1659. *v=0;
  1660. break;
  1661. default:
  1662. *h=0;
  1663. *v=0;
  1664. break;
  1665. }
  1666. }
  1668. static uint16_t roundToInt16(int64_t f){
  1669. int r= (f + (1<<15))>>16;
  1670.      if(r<-0x7FFF) return 0x8000;
  1671. else if(r> 0x7FFF) return 0x7FFF;
  1672. else               return r;
  1673. }
  1675. /**
  1676.  * @param inv_table the yuv2rgb coeffs, normally Inverse_Table_6_9[x]
  1677.  * @param fullRange if 1 then the luma range is 0..255 if 0 its 16..235
  1678.  * @return -1 if not supported
  1679.  */
  1680. int sws_setColorspaceDetails(SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation){
  1681. int64_t crv =  inv_table[0];
  1682. int64_t cbu =  inv_table[1];
  1683. int64_t cgu = -inv_table[2];
  1684. int64_t cgv = -inv_table[3];
  1685. int64_t cy  = 1<<16;
  1686. int64_t oy  = 0;
  1688. if(isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;
  1689. memcpy(c->srcColorspaceTable, inv_table, sizeof(int)*4);
  1690. memcpy(c->dstColorspaceTable,     table, sizeof(int)*4);
  1692. c->brightness= brightness;
  1693. c->contrast  = contrast;
  1694. c->saturation= saturation;
  1695. c->srcRange  = srcRange;
  1696. c->dstRange  = dstRange;
  1698. c->uOffset=   0x0400040004000400LL;
  1699. c->vOffset=   0x0400040004000400LL;
  1701. if(!srcRange){
  1702. cy= (cy*255) / 219;
  1703. oy= 16<<16;
  1704. }
  1706. cy = (cy *contrast             )>>16;
  1707. crv= (crv*contrast * saturation)>>32;
  1708. cbu= (cbu*contrast * saturation)>>32;
  1709. cgu= (cgu*contrast * saturation)>>32;
  1710. cgv= (cgv*contrast * saturation)>>32;
  1712. oy -= 256*brightness;
  1714. c->yCoeff=    roundToInt16(cy *8192) * 0x0001000100010001ULL;
  1715. c->vrCoeff=   roundToInt16(crv*8192) * 0x0001000100010001ULL;
  1716. c->ubCoeff=   roundToInt16(cbu*8192) * 0x0001000100010001ULL;
  1717. c->vgCoeff=   roundToInt16(cgv*8192) * 0x0001000100010001ULL;
  1718. c->ugCoeff=   roundToInt16(cgu*8192) * 0x0001000100010001ULL;
  1719. c->yOffset=   roundToInt16(oy *   8) * 0x0001000100010001ULL;
  1721. yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation);
  1722. //FIXME factorize
  1724. #ifdef HAVE_ALTIVEC
  1725. yuv2rgb_altivec_init_tables (c, inv_table);
  1726. #endif
  1727. return 0;
  1728. }
  1730. /**
  1731.  * @return -1 if not supported
  1732.  */
  1733. int sws_getColorspaceDetails(SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation){
  1734. if(isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;
  1736. *inv_table = c->srcColorspaceTable;
  1737. *table     = c->dstColorspaceTable;
  1738. *srcRange  = c->srcRange;
  1739. *dstRange  = c->dstRange;
  1740. *brightness= c->brightness;
  1741. *contrast  = c->contrast;
  1742. *saturation= c->saturation;
  1744. return 0;
  1745. }
  1747. SwsContext *sws_getContext(int srcW, int srcH, int origSrcFormat, int dstW, int dstH, int origDstFormat, int flags,
  1748.                          SwsFilter *srcFilter, SwsFilter *dstFilter){
  1750. SwsContext *c;
  1751. int i;
  1752. int usesVFilter, usesHFilter;
  1753. int unscaled, needsDither;
  1754. int srcFormat, dstFormat;
  1755. SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
  1756. #ifdef ARCH_X86
  1757. if(flags & SWS_CPU_CAPS_MMX)
  1758. asm volatile("emmsnt"::: "memory");
  1759. #endif
  1761. #ifndef RUNTIME_CPUDETECT //ensure that the flags match the compiled variant if cpudetect is off
  1762. flags &= ~(SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_MMX2|SWS_CPU_CAPS_3DNOW|SWS_CPU_CAPS_ALTIVEC);
  1763. #ifdef HAVE_MMX2
  1764. flags |= SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_MMX2;
  1765. #elif defined (HAVE_3DNOW)
  1766. flags |= SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_3DNOW;
  1767. #elif defined (HAVE_MMX)
  1768. flags |= SWS_CPU_CAPS_MMX;
  1769. #elif defined (HAVE_ALTIVEC)
  1770. flags |= SWS_CPU_CAPS_ALTIVEC;
  1771. #endif
  1772. #endif
  1773. if(clip_table[512] != 255) globalInit();
  1774. if(rgb15to16 == NULL) sws_rgb2rgb_init(flags);
  1776. /* avoid duplicate Formats, so we don't need to check to much */
  1777. srcFormat = remove_dup_fourcc(origSrcFormat);
  1778. dstFormat = remove_dup_fourcc(origDstFormat);
  1780. unscaled = (srcW == dstW && srcH == dstH);
  1781. needsDither= (isBGR(dstFormat) || isRGB(dstFormat)) 
  1782.      && (dstFormat&0xFF)<24
  1783.      && ((dstFormat&0xFF)<(srcFormat&0xFF) || (!(isRGB(srcFormat) || isBGR(srcFormat))));
  1785. if(!isSupportedIn(srcFormat)) 
  1786. {
  1787. MSG_ERR("swScaler: %s is not supported as input formatn", vo_format_name(srcFormat));
  1788. return NULL;
  1789. }
  1790. if(!isSupportedOut(dstFormat))
  1791. {
  1792. MSG_ERR("swScaler: %s is not supported as output formatn", vo_format_name(dstFormat));
  1793. return NULL;
  1794. }
  1796. /* sanity check */
  1797. if(srcW<4 || srcH<1 || dstW<8 || dstH<1) //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code
  1798. {
  1799.  MSG_ERR("swScaler: %dx%d -> %dx%d is invalid scaling dimensionn", 
  1800. srcW, srcH, dstW, dstH);
  1801. return NULL;
  1802. }
  1804. if(!dstFilter) dstFilter= &dummyFilter;
  1805. if(!srcFilter) srcFilter= &dummyFilter;
  1807. c= memalign(64, sizeof(SwsContext));
  1808. memset(c, 0, sizeof(SwsContext));
  1810. c->srcW= srcW;
  1811. c->srcH= srcH;
  1812. c->dstW= dstW;
  1813. c->dstH= dstH;
  1814. c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;
  1815. c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;
  1816. c->flags= flags;
  1817. c->dstFormat= dstFormat;
  1818. c->srcFormat= srcFormat;
  1819. c->origDstFormat= origDstFormat;
  1820. c->origSrcFormat= origSrcFormat;
  1821.         c->vRounder= 4* 0x0001000100010001ULL;
  1823. usesHFilter= usesVFilter= 0;
  1824. if(dstFilter->lumV!=NULL && dstFilter->lumV->length>1) usesVFilter=1;
  1825. if(dstFilter->lumH!=NULL && dstFilter->lumH->length>1) usesHFilter=1;
  1826. if(dstFilter->chrV!=NULL && dstFilter->chrV->length>1) usesVFilter=1;
  1827. if(dstFilter->chrH!=NULL && dstFilter->chrH->length>1) usesHFilter=1;
  1828. if(srcFilter->lumV!=NULL && srcFilter->lumV->length>1) usesVFilter=1;
  1829. if(srcFilter->lumH!=NULL && srcFilter->lumH->length>1) usesHFilter=1;
  1830. if(srcFilter->chrV!=NULL && srcFilter->chrV->length>1) usesVFilter=1;
  1831. if(srcFilter->chrH!=NULL && srcFilter->chrH->length>1) usesHFilter=1;
  1833. getSubSampleFactors(&c->chrSrcHSubSample, &c->chrSrcVSubSample, srcFormat);
  1834. getSubSampleFactors(&c->chrDstHSubSample, &c->chrDstVSubSample, dstFormat);
  1836. // reuse chroma for 2 pixles rgb/bgr unless user wants full chroma interpolation
  1837. if((isBGR(dstFormat) || isRGB(dstFormat)) && !(flags&SWS_FULL_CHR_H_INT)) c->chrDstHSubSample=1;
  1839. // drop some chroma lines if the user wants it
  1840. c->vChrDrop= (flags&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;
  1841. c->chrSrcVSubSample+= c->vChrDrop;
  1843. // drop every 2. pixel for chroma calculation unless user wants full chroma
  1844. if((isBGR(srcFormat) || isRGB(srcFormat)) && !(flags&SWS_FULL_CHR_H_INP)) 
  1845. c->chrSrcHSubSample=1;
  1847. c->chrIntHSubSample= c->chrDstHSubSample;
  1848. c->chrIntVSubSample= c->chrSrcVSubSample;
  1850. // note the -((-x)>>y) is so that we allways round toward +inf
  1851. c->chrSrcW= -((-srcW) >> c->chrSrcHSubSample);
  1852. c->chrSrcH= -((-srcH) >> c->chrSrcVSubSample);
  1853. c->chrDstW= -((-dstW) >> c->chrDstHSubSample);
  1854. c->chrDstH= -((-dstH) >> c->chrDstVSubSample);
  1856. sws_setColorspaceDetails(c, Inverse_Table_6_9[SWS_CS_DEFAULT], 0, Inverse_Table_6_9[SWS_CS_DEFAULT] /* FIXME*/, 0, 0, 1<<16, 1<<16); 
  1858. /* unscaled special Cases */
  1859. if(unscaled && !usesHFilter && !usesVFilter)
  1860. {
  1861. /* yv12_to_nv12 */
  1862. if(srcFormat == IMGFMT_YV12 && dstFormat == IMGFMT_NV12)
  1863. {
  1864. c->swScale= PlanarToNV12Wrapper;
  1865. }
  1866. /* yuv2bgr */
  1867. if((srcFormat==IMGFMT_YV12 || srcFormat==IMGFMT_422P) && (isBGR(dstFormat) || isRGB(dstFormat)))
  1868. {
  1869. c->swScale= yuv2rgb_get_func_ptr(c);
  1870. }
  1872. if( srcFormat==IMGFMT_YVU9 && dstFormat==IMGFMT_YV12 )
  1873. {
  1874. c->swScale= yvu9toyv12Wrapper;
  1875. }
  1877. /* bgr24toYV12 */
  1878. if(srcFormat==IMGFMT_BGR24 && dstFormat==IMGFMT_YV12)
  1879. c->swScale= bgr24toyv12Wrapper;
  1881. /* rgb/bgr -> rgb/bgr (no dither needed forms) */
  1882. if(   (isBGR(srcFormat) || isRGB(srcFormat))
  1883.    && (isBGR(dstFormat) || isRGB(dstFormat)) 
  1884.    && !needsDither)
  1885. c->swScale= rgb2rgbWrapper;
  1887. /* LQ converters if -sws 0 or -sws 4*/
  1888. if(c->flags&(SWS_FAST_BILINEAR|SWS_POINT)){
  1889. /* rgb/bgr -> rgb/bgr (dither needed forms) */
  1890. if(  (isBGR(srcFormat) || isRGB(srcFormat))
  1891.   && (isBGR(dstFormat) || isRGB(dstFormat)) 
  1892.   && needsDither)
  1893. c->swScale= rgb2rgbWrapper;
  1895. /* yv12_to_yuy2 */
  1896. if(srcFormat == IMGFMT_YV12 && 
  1897.     (dstFormat == IMGFMT_YUY2 || dstFormat == IMGFMT_UYVY))
  1898. {
  1899. if (dstFormat == IMGFMT_YUY2)
  1900.     c->swScale= PlanarToYuy2Wrapper;
  1901. else
  1902.     c->swScale= PlanarToUyvyWrapper;
  1903. }
  1904. }
  1906. #ifdef HAVE_ALTIVEC
  1907. if ((c->flags & SWS_CPU_CAPS_ALTIVEC) &&
  1908.     ((srcFormat == IMGFMT_YV12 && 
  1909.       (dstFormat == IMGFMT_YUY2 || dstFormat == IMGFMT_UYVY)))) {
  1910.   // unscaled YV12 -> packed YUV, we want speed
  1911.   if (dstFormat == IMGFMT_YUY2)
  1912.     c->swScale= yv12toyuy2_unscaled_altivec;
  1913.   else
  1914.     c->swScale= yv12touyvy_unscaled_altivec;
  1915. }
  1916. #endif
  1918. /* simple copy */
  1919. if(   srcFormat == dstFormat
  1920.    || (isPlanarYUV(srcFormat) && isGray(dstFormat))
  1921.    || (isPlanarYUV(dstFormat) && isGray(srcFormat))
  1922.   )
  1923. {
  1924. c->swScale= simpleCopy;
  1925. }
  1927. if(c->swScale){
  1928. if(flags&SWS_PRINT_INFO)
  1929. MSG_INFO("SwScaler: using unscaled %s -> %s special convertern", 
  1930. vo_format_name(srcFormat), vo_format_name(dstFormat));
  1931. return c;
  1932. }
  1933. }
  1935. if(flags & SWS_CPU_CAPS_MMX2)
  1936. {
  1937. c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
  1938. if(!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR))
  1939. {
  1940. if(flags&SWS_PRINT_INFO)
  1941. MSG_INFO("SwScaler: output Width is not a multiple of 32 -> no MMX2 scalern");
  1942. }
  1943. if(usesHFilter) c->canMMX2BeUsed=0;
  1944. }
  1945. else
  1946. c->canMMX2BeUsed=0;
  1948. c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
  1949. c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
  1951. // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
  1952. // but only for the FAST_BILINEAR mode otherwise do correct scaling
  1953. // n-2 is the last chrominance sample available
  1954. // this is not perfect, but noone shuld notice the difference, the more correct variant
  1955. // would be like the vertical one, but that would require some special code for the
  1956. // first and last pixel
  1957. if(flags&SWS_FAST_BILINEAR)
  1958. {
  1959. if(c->canMMX2BeUsed)
  1960. {
  1961. c->lumXInc+= 20;
  1962. c->chrXInc+= 20;
  1963. }
  1964. //we don't use the x86asm scaler if mmx is available
  1965. else if(flags & SWS_CPU_CAPS_MMX)
  1966. {
  1967. c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
  1968. c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
  1969. }
  1970. }
  1972. /* precalculate horizontal scaler filter coefficients */
  1973. {
  1974. const int filterAlign=
  1975.   (flags & SWS_CPU_CAPS_MMX) ? 4 :
  1976.   (flags & SWS_CPU_CAPS_ALTIVEC) ? 8 :
  1977.   1;
  1979. initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
  1980.  srcW      ,       dstW, filterAlign, 1<<14,
  1981.  (flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC)  : flags,
  1982.  srcFilter->lumH, dstFilter->lumH);
  1983. initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
  1984.  c->chrSrcW, c->chrDstW, filterAlign, 1<<14,
  1985.  (flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags,
  1986.  srcFilter->chrH, dstFilter->chrH);
  1988. #ifdef ARCH_X86
  1989. // can't downscale !!!
  1990. if(c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR))
  1991. {
  1992. c->lumMmx2Filter   = (int16_t*)memalign(8, (dstW        /8+8)*sizeof(int16_t));
  1993. c->chrMmx2Filter   = (int16_t*)memalign(8, (c->chrDstW  /4+8)*sizeof(int16_t));
  1994. c->lumMmx2FilterPos= (int32_t*)memalign(8, (dstW      /2/8+8)*sizeof(int32_t));
  1995. c->chrMmx2FilterPos= (int32_t*)memalign(8, (c->chrDstW/2/4+8)*sizeof(int32_t));
  1997. initMMX2HScaler(      dstW, c->lumXInc, c->funnyYCode , c->lumMmx2Filter, c->lumMmx2FilterPos, 8);
  1998. initMMX2HScaler(c->chrDstW, c->chrXInc, c->funnyUVCode, c->chrMmx2Filter, c->chrMmx2FilterPos, 4);
  1999. }
  2000. #endif
  2001. } // Init Horizontal stuff
  2005. /* precalculate vertical scaler filter coefficients */
  2006. {
  2007. const int filterAlign=
  2008.   (flags & SWS_CPU_CAPS_ALTIVEC) ? 8 :
  2009.   1;
  2011. initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
  2012. srcH      ,        dstH, filterAlign, (1<<12)-4,
  2013. (flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC)  : flags,
  2014. srcFilter->lumV, dstFilter->lumV);
  2015. initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
  2016. c->chrSrcH, c->chrDstH, filterAlign, (1<<12)-4,
  2017. (flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags,
  2018. srcFilter->chrV, dstFilter->chrV);
  2019. }
  2021. // Calculate Buffer Sizes so that they won't run out while handling these damn slices
  2022. c->vLumBufSize= c->vLumFilterSize;
  2023. c->vChrBufSize= c->vChrFilterSize;
  2024. for(i=0; i<dstH; i++)
  2025. {
  2026. int chrI= i*c->chrDstH / dstH;
  2027. int nextSlice= MAX(c->vLumFilterPos[i   ] + c->vLumFilterSize - 1,
  2028.  ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));
  2030. nextSlice>>= c->chrSrcVSubSample;
  2031. nextSlice<<= c->chrSrcVSubSample;
  2032. if(c->vLumFilterPos[i   ] + c->vLumBufSize < nextSlice)
  2033. c->vLumBufSize= nextSlice - c->vLumFilterPos[i   ];
  2034. if(c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>c->chrSrcVSubSample))
  2035. c->vChrBufSize= (nextSlice>>c->chrSrcVSubSample) - c->vChrFilterPos[chrI];
  2036. }
  2038. // allocate pixbufs (we use dynamic allocation because otherwise we would need to
  2039. c->lumPixBuf= (int16_t**)memalign(4, c->vLumBufSize*2*sizeof(int16_t*));
  2040. c->chrPixBuf= (int16_t**)memalign(4, c->vChrBufSize*2*sizeof(int16_t*));
  2041. //Note we need at least one pixel more at the end because of the mmx code (just in case someone wanna replace the 4000/8000)
  2042. for(i=0; i<c->vLumBufSize; i++)
  2043. c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= (uint16_t*)memalign(8, 4000);
  2044. for(i=0; i<c->vChrBufSize; i++)
  2045. c->chrPixBuf[i]= c->chrPixBuf[i+c->vChrBufSize]= (uint16_t*)memalign(8, 8000);
  2047. //try to avoid drawing green stuff between the right end and the stride end
  2048. for(i=0; i<c->vLumBufSize; i++) memset(c->lumPixBuf[i], 0, 4000);
  2049. for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);
  2051. ASSERT(c->chrDstH <= dstH)
  2053. if(flags&SWS_PRINT_INFO)
  2054. {
  2055. #ifdef DITHER1XBPP
  2056. char *dither= " dithered";
  2057. #else
  2058. char *dither= "";
  2059. #endif
  2060. if(flags&SWS_FAST_BILINEAR)
  2061. MSG_INFO("nSwScaler: FAST_BILINEAR scaler, ");
  2062. else if(flags&SWS_BILINEAR)
  2063. MSG_INFO("nSwScaler: BILINEAR scaler, ");
  2064. else if(flags&SWS_BICUBIC)
  2065. MSG_INFO("nSwScaler: BICUBIC scaler, ");
  2066. else if(flags&SWS_X)
  2067. MSG_INFO("nSwScaler: Experimental scaler, ");
  2068. else if(flags&SWS_POINT)
  2069. MSG_INFO("nSwScaler: Nearest Neighbor / POINT scaler, ");
  2070. else if(flags&SWS_AREA)
  2071. MSG_INFO("nSwScaler: Area Averageing scaler, ");
  2072. else if(flags&SWS_BICUBLIN)
  2073. MSG_INFO("nSwScaler: luma BICUBIC / chroma BILINEAR scaler, ");
  2074. else if(flags&SWS_GAUSS)
  2075. MSG_INFO("nSwScaler: Gaussian scaler, ");
  2076. else if(flags&SWS_SINC)
  2077. MSG_INFO("nSwScaler: Sinc scaler, ");
  2078. else if(flags&SWS_LANCZOS)
  2079. MSG_INFO("nSwScaler: Lanczos scaler, ");
  2080. else if(flags&SWS_SPLINE)
  2081. MSG_INFO("nSwScaler: Bicubic spline scaler, ");
  2082. else
  2083. MSG_INFO("nSwScaler: ehh flags invalid?! ");
  2085. if(dstFormat==IMGFMT_BGR15 || dstFormat==IMGFMT_BGR16)
  2086. MSG_INFO("from %s to%s %s ", 
  2087. vo_format_name(srcFormat), dither, vo_format_name(dstFormat));
  2088. else
  2089. MSG_INFO("from %s to %s ", 
  2090. vo_format_name(srcFormat), vo_format_name(dstFormat));
  2092. if(flags & SWS_CPU_CAPS_MMX2)
  2093. MSG_INFO("using MMX2n");
  2094. else if(flags & SWS_CPU_CAPS_3DNOW)
  2095. MSG_INFO("using 3DNOWn");
  2096. else if(flags & SWS_CPU_CAPS_MMX)
  2097. MSG_INFO("using MMXn");
  2098. else if(flags & SWS_CPU_CAPS_ALTIVEC)
  2099. MSG_INFO("using AltiVecn");
  2100. else 
  2101. MSG_INFO("using Cn");
  2102. }
  2104. if(flags & SWS_PRINT_INFO)
  2105. {
  2106. if(flags & SWS_CPU_CAPS_MMX)
  2107. {
  2108. if(c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
  2109. MSG_V("SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scalingn");
  2110. else
  2111. {
  2112. if(c->hLumFilterSize==4)
  2113. MSG_V("SwScaler: using 4-tap MMX scaler for horizontal luminance scalingn");
  2114. else if(c->hLumFilterSize==8)
  2115. MSG_V("SwScaler: using 8-tap MMX scaler for horizontal luminance scalingn");
  2116. else
  2117. MSG_V("SwScaler: using n-tap MMX scaler for horizontal luminance scalingn");
  2119. if(c->hChrFilterSize==4)
  2120. MSG_V("SwScaler: using 4-tap MMX scaler for horizontal chrominance scalingn");
  2121. else if(c->hChrFilterSize==8)
  2122. MSG_V("SwScaler: using 8-tap MMX scaler for horizontal chrominance scalingn");
  2123. else
  2124. MSG_V("SwScaler: using n-tap MMX scaler for horizontal chrominance scalingn");
  2125. }
  2126. }
  2127. else
  2128. {
  2129. #ifdef ARCH_X86
  2130. MSG_V("SwScaler: using X86-Asm scaler for horizontal scalingn");
  2131. #else
  2132. if(flags & SWS_FAST_BILINEAR)
  2133. MSG_V("SwScaler: using FAST_BILINEAR C scaler for horizontal scalingn");
  2134. else
  2135. MSG_V("SwScaler: using C scaler for horizontal scalingn");
  2136. #endif
  2137. }
  2138. if(isPlanarYUV(dstFormat))
  2139. {
  2140. if(c->vLumFilterSize==1)
  2141. MSG_V("SwScaler: using 1-tap %s "scaler" for vertical scaling (YV12 like)n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2142. else
  2143. MSG_V("SwScaler: using n-tap %s scaler for vertical scaling (YV12 like)n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2144. }
  2145. else
  2146. {
  2147. if(c->vLumFilterSize==1 && c->vChrFilterSize==2)
  2148. MSG_V("SwScaler: using 1-tap %s "scaler" for vertical luminance scaling (BGR)n"
  2149.        "SwScaler:       2-tap scaler for vertical chrominance scaling (BGR)n",(flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2150. else if(c->vLumFilterSize==2 && c->vChrFilterSize==2)
  2151. MSG_V("SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2152. else
  2153. MSG_V("SwScaler: using n-tap %s scaler for vertical scaling (BGR)n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2154. }
  2156. if(dstFormat==IMGFMT_BGR24)
  2157. MSG_V("SwScaler: using %s YV12->BGR24 Convertern",
  2158. (flags & SWS_CPU_CAPS_MMX2) ? "MMX2" : ((flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C"));
  2159. else if(dstFormat==IMGFMT_BGR32)
  2160. MSG_V("SwScaler: using %s YV12->BGR32 Convertern", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2161. else if(dstFormat==IMGFMT_BGR16)
  2162. MSG_V("SwScaler: using %s YV12->BGR16 Convertern", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2163. else if(dstFormat==IMGFMT_BGR15)
  2164. MSG_V("SwScaler: using %s YV12->BGR15 Convertern", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");
  2166. MSG_V("SwScaler: %dx%d -> %dx%dn", srcW, srcH, dstW, dstH);
  2167. }
  2168. if(flags & SWS_PRINT_INFO)
  2169. {
  2170. MSG_DBG2("SwScaler:Lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%dn",
  2171. c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
  2172. MSG_DBG2("SwScaler:Chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%dn",
  2173. c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
  2174. }
  2176. c->swScale= getSwsFunc(flags);
  2177. return c;
  2178. }
  2180. /**
  2181.  * swscale warper, so we don't need to export the SwsContext.
  2182.  * assumes planar YUV to be in YUV order instead of YVU
  2183.  */
  2184. int sws_scale_ordered(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
  2185.                            int srcSliceH, uint8_t* dst[], int dstStride[]){
  2186. //copy strides, so they can safely be modified
  2187. int srcStride2[3]= {srcStride[0], srcStride[1], srcStride[2]};
  2188. int dstStride2[3]= {dstStride[0], dstStride[1], dstStride[2]};
  2189. return c->swScale(c, src, srcStride2, srcSliceY, srcSliceH, dst, dstStride2);
  2190. }
  2192. /**
  2193.  * swscale warper, so we don't need to export the SwsContext
  2194.  */
  2195. int sws_scale(SwsContext *c, uint8_t* srcParam[], int srcStrideParam[], int srcSliceY,
  2196.                            int srcSliceH, uint8_t* dstParam[], int dstStrideParam[]){
  2197. int srcStride[3];
  2198. int dstStride[3];
  2199. uint8_t *src[3];
  2200. uint8_t *dst[3];
  2201. sws_orderYUV(c->origSrcFormat, src, srcStride, srcParam, srcStrideParam);
  2202. sws_orderYUV(c->origDstFormat, dst, dstStride, dstParam, dstStrideParam);
  2203. //printf("sws: slice %d %dn", srcSliceY, srcSliceH);
  2205. return c->swScale(c, src, srcStride, srcSliceY, srcSliceH, dst, dstStride);
  2206. }
  2208. SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, 
  2209. float lumaSharpen, float chromaSharpen,
  2210. float chromaHShift, float chromaVShift,
  2211. int verbose)
  2212. {
  2213. SwsFilter *filter= malloc(sizeof(SwsFilter));
  2215. if(lumaGBlur!=0.0){
  2216. filter->lumH= sws_getGaussianVec(lumaGBlur, 3.0);
  2217. filter->lumV= sws_getGaussianVec(lumaGBlur, 3.0);
  2218. }else{
  2219. filter->lumH= sws_getIdentityVec();
  2220. filter->lumV= sws_getIdentityVec();
  2221. }
  2223. if(chromaGBlur!=0.0){
  2224. filter->chrH= sws_getGaussianVec(chromaGBlur, 3.0);
  2225. filter->chrV= sws_getGaussianVec(chromaGBlur, 3.0);
  2226. }else{
  2227. filter->chrH= sws_getIdentityVec();
  2228. filter->chrV= sws_getIdentityVec();
  2229. }
  2231. if(chromaSharpen!=0.0){
  2232. SwsVector *g= sws_getConstVec(-1.0, 3);
  2233. SwsVector *id= sws_getConstVec(10.0/chromaSharpen, 1);
  2234. g->coeff[1]=2.0;
  2235. sws_addVec(id, g);
  2236. sws_convVec(filter->chrH, id);
  2237. sws_convVec(filter->chrV, id);
  2238. sws_freeVec(g);
  2239. sws_freeVec(id);
  2240. }
  2242. if(lumaSharpen!=0.0){
  2243. SwsVector *g= sws_getConstVec(-1.0, 3);
  2244. SwsVector *id= sws_getConstVec(10.0/lumaSharpen, 1);
  2245. g->coeff[1]=2.0;
  2246. sws_addVec(id, g);
  2247. sws_convVec(filter->lumH, id);
  2248. sws_convVec(filter->lumV, id);
  2249. sws_freeVec(g);
  2250. sws_freeVec(id);
  2251. }
  2253. if(chromaHShift != 0.0)
  2254. sws_shiftVec(filter->chrH, (int)(chromaHShift+0.5));
  2256. if(chromaVShift != 0.0)
  2257. sws_shiftVec(filter->chrV, (int)(chromaVShift+0.5));
  2259. sws_normalizeVec(filter->chrH, 1.0);
  2260. sws_normalizeVec(filter->chrV, 1.0);
  2261. sws_normalizeVec(filter->lumH, 1.0);
  2262. sws_normalizeVec(filter->lumV, 1.0);
  2264. if(verbose) sws_printVec(filter->chrH);
  2265. if(verbose) sws_printVec(filter->lumH);
  2267.         return filter;
  2268. }
  2270. /**
  2271.  * returns a normalized gaussian curve used to filter stuff
  2272.  * quality=3 is high quality, lowwer is lowwer quality
  2273.  */
  2274. SwsVector *sws_getGaussianVec(double variance, double quality){
  2275. const int length= (int)(variance*quality + 0.5) | 1;
  2276. int i;
  2277. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2278. double middle= (length-1)*0.5;
  2279. SwsVector *vec= malloc(sizeof(SwsVector));
  2281. vec->coeff= coeff;
  2282. vec->length= length;
  2284. for(i=0; i<length; i++)
  2285. {
  2286. double dist= i-middle;
  2287. coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);
  2288. }
  2290. sws_normalizeVec(vec, 1.0);
  2292. return vec;
  2293. }
  2295. SwsVector *sws_getConstVec(double c, int length){
  2296. int i;
  2297. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2298. SwsVector *vec= malloc(sizeof(SwsVector));
  2300. vec->coeff= coeff;
  2301. vec->length= length;
  2303. for(i=0; i<length; i++)
  2304. coeff[i]= c;
  2306. return vec;
  2307. }
  2310. SwsVector *sws_getIdentityVec(void){
  2311. double *coeff= memalign(sizeof(double), sizeof(double));
  2312. SwsVector *vec= malloc(sizeof(SwsVector));
  2313. coeff[0]= 1.0;
  2315. vec->coeff= coeff;
  2316. vec->length= 1;
  2318. return vec;
  2319. }
  2321. void sws_normalizeVec(SwsVector *a, double height){
  2322. int i;
  2323. double sum=0;
  2324. double inv;
  2326. for(i=0; i<a->length; i++)
  2327. sum+= a->coeff[i];
  2329. inv= height/sum;
  2331. for(i=0; i<a->length; i++)
  2332. a->coeff[i]*= inv;
  2333. }
  2335. void sws_scaleVec(SwsVector *a, double scalar){
  2336. int i;
  2338. for(i=0; i<a->length; i++)
  2339. a->coeff[i]*= scalar;
  2340. }
  2342. static SwsVector *sws_getConvVec(SwsVector *a, SwsVector *b){
  2343. int length= a->length + b->length - 1;
  2344. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2345. int i, j;
  2346. SwsVector *vec= malloc(sizeof(SwsVector));
  2348. vec->coeff= coeff;
  2349. vec->length= length;
  2351. for(i=0; i<length; i++) coeff[i]= 0.0;
  2353. for(i=0; i<a->length; i++)
  2354. {
  2355. for(j=0; j<b->length; j++)
  2356. {
  2357. coeff[i+j]+= a->coeff[i]*b->coeff[j];
  2358. }
  2359. }
  2361. return vec;
  2362. }
  2364. static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b){
  2365. int length= MAX(a->length, b->length);
  2366. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2367. int i;
  2368. SwsVector *vec= malloc(sizeof(SwsVector));
  2370. vec->coeff= coeff;
  2371. vec->length= length;
  2373. for(i=0; i<length; i++) coeff[i]= 0.0;
  2375. for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
  2376. for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]+= b->coeff[i];
  2378. return vec;
  2379. }
  2381. static SwsVector *sws_diffVec(SwsVector *a, SwsVector *b){
  2382. int length= MAX(a->length, b->length);
  2383. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2384. int i;
  2385. SwsVector *vec= malloc(sizeof(SwsVector));
  2387. vec->coeff= coeff;
  2388. vec->length= length;
  2390. for(i=0; i<length; i++) coeff[i]= 0.0;
  2392. for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
  2393. for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]-= b->coeff[i];
  2395. return vec;
  2396. }
  2398. /* shift left / or right if "shift" is negative */
  2399. static SwsVector *sws_getShiftedVec(SwsVector *a, int shift){
  2400. int length= a->length + ABS(shift)*2;
  2401. double *coeff= memalign(sizeof(double), length*sizeof(double));
  2402. int i;
  2403. SwsVector *vec= malloc(sizeof(SwsVector));
  2405. vec->coeff= coeff;
  2406. vec->length= length;
  2408. for(i=0; i<length; i++) coeff[i]= 0.0;
  2410. for(i=0; i<a->length; i++)
  2411. {
  2412. coeff[i + (length-1)/2 - (a->length-1)/2 - shift]= a->coeff[i];
  2413. }
  2415. return vec;
  2416. }
  2418. void sws_shiftVec(SwsVector *a, int shift){
  2419. SwsVector *shifted= sws_getShiftedVec(a, shift);
  2420. free(a->coeff);
  2421. a->coeff= shifted->coeff;
  2422. a->length= shifted->length;
  2423. free(shifted);
  2424. }
  2426. void sws_addVec(SwsVector *a, SwsVector *b){
  2427. SwsVector *sum= sws_sumVec(a, b);
  2428. free(a->coeff);
  2429. a->coeff= sum->coeff;
  2430. a->length= sum->length;
  2431. free(sum);
  2432. }
  2434. void sws_subVec(SwsVector *a, SwsVector *b){
  2435. SwsVector *diff= sws_diffVec(a, b);
  2436. free(a->coeff);
  2437. a->coeff= diff->coeff;
  2438. a->length= diff->length;
  2439. free(diff);
  2440. }
  2442. void sws_convVec(SwsVector *a, SwsVector *b){
  2443. SwsVector *conv= sws_getConvVec(a, b);
  2444. free(a->coeff);  
  2445. a->coeff= conv->coeff;
  2446. a->length= conv->length;
  2447. free(conv);
  2448. }
  2450. SwsVector *sws_cloneVec(SwsVector *a){
  2451. double *coeff= memalign(sizeof(double), a->length*sizeof(double));
  2452. int i;
  2453. SwsVector *vec= malloc(sizeof(SwsVector));
  2455. vec->coeff= coeff;
  2456. vec->length= a->length;
  2458. for(i=0; i<a->length; i++) coeff[i]= a->coeff[i];
  2460. return vec;
  2461. }
  2463. void sws_printVec(SwsVector *a){
  2464. int i;
  2465. double max=0;
  2466. double min=0;
  2467. double range;
  2469. for(i=0; i<a->length; i++)
  2470. if(a->coeff[i]>max) max= a->coeff[i];
  2472. for(i=0; i<a->length; i++)
  2473. if(a->coeff[i]<min) min= a->coeff[i];
  2475. range= max - min;
  2477. for(i=0; i<a->length; i++)
  2478. {
  2479. int x= (int)((a->coeff[i]-min)*60.0/range +0.5);
  2480. MSG_DBG2("%1.3f ", a->coeff[i]);
  2481. for(;x>0; x--) MSG_DBG2(" ");
  2482. MSG_DBG2("|n");
  2483. }
  2484. }
  2486. void sws_freeVec(SwsVector *a){
  2487. if(!a) return;
  2488. if(a->coeff) free(a->coeff);
  2489. a->coeff=NULL;
  2490. a->length=0;
  2491. free(a);
  2492. }
  2494. void sws_freeFilter(SwsFilter *filter){
  2495. if(!filter) return;
  2497. if(filter->lumH) sws_freeVec(filter->lumH);
  2498. if(filter->lumV) sws_freeVec(filter->lumV);
  2499. if(filter->chrH) sws_freeVec(filter->chrH);
  2500. if(filter->chrV) sws_freeVec(filter->chrV);
  2501. free(filter);
  2502. }
  2505. void sws_freeContext(SwsContext *c){
  2506. int i;
  2507. if(!c) return;
  2509. if(c->lumPixBuf)
  2510. {
  2511. for(i=0; i<c->vLumBufSize; i++)
  2512. {
  2513. if(c->lumPixBuf[i]) free(c->lumPixBuf[i]);
  2514. c->lumPixBuf[i]=NULL;
  2515. }
  2516. free(c->lumPixBuf);
  2517. c->lumPixBuf=NULL;
  2518. }
  2520. if(c->chrPixBuf)
  2521. {
  2522. for(i=0; i<c->vChrBufSize; i++)
  2523. {
  2524. if(c->chrPixBuf[i]) free(c->chrPixBuf[i]);
  2525. c->chrPixBuf[i]=NULL;
  2526. }
  2527. free(c->chrPixBuf);
  2528. c->chrPixBuf=NULL;
  2529. }
  2531. if(c->vLumFilter) free(c->vLumFilter);
  2532. c->vLumFilter = NULL;
  2533. if(c->vChrFilter) free(c->vChrFilter);
  2534. c->vChrFilter = NULL;
  2535. if(c->hLumFilter) free(c->hLumFilter);
  2536. c->hLumFilter = NULL;
  2537. if(c->hChrFilter) free(c->hChrFilter);
  2538. c->hChrFilter = NULL;
  2540. if(c->vLumFilterPos) free(c->vLumFilterPos);
  2541. c->vLumFilterPos = NULL;
  2542. if(c->vChrFilterPos) free(c->vChrFilterPos);
  2543. c->vChrFilterPos = NULL;
  2544. if(c->hLumFilterPos) free(c->hLumFilterPos);
  2545. c->hLumFilterPos = NULL;
  2546. if(c->hChrFilterPos) free(c->hChrFilterPos);
  2547. c->hChrFilterPos = NULL;
  2549. if(c->lumMmx2Filter) free(c->lumMmx2Filter);
  2550. c->lumMmx2Filter=NULL;
  2551. if(c->chrMmx2Filter) free(c->chrMmx2Filter);
  2552. c->chrMmx2Filter=NULL;
  2553. if(c->lumMmx2FilterPos) free(c->lumMmx2FilterPos);
  2554. c->lumMmx2FilterPos=NULL;
  2555. if(c->chrMmx2FilterPos) free(c->chrMmx2FilterPos);
  2556. c->chrMmx2FilterPos=NULL;
  2557. if(c->yuvTable) free(c->yuvTable);
  2558. c->yuvTable=NULL;
  2560. free(c);
  2561. }