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.
1484 Commits
32 Branches
293MB
Tree: f78ebb51ec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f78ebb51ec'
${ noResults }
FFmpeg/libavcodec/i386/mpegvideo_mmx.c

568 lines
17KB
Raw Blame History 

  1. /*

  2.  * The simplest mpeg encoder (well, it was the simplest!)

  3.  * Copyright (c) 2000,2001 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  *

  19.  * Optimized for ia32 cpus by Nick Kurshev <nickols_k@mail.ru>

  20.  * h263, mpeg1, mpeg2 dequantizer & draw_edges by Michael Niedermayer <michaelni@gmx.at>

  21.  */

  22. 

  23. #include "../dsputil.h"

  24. #include "../mpegvideo.h"

  25. #include "../avcodec.h"

  26. #include "../simple_idct.h"

  27. 

  28. extern UINT8 zigzag_direct_noperm[64];

  29. extern UINT16 inv_zigzag_direct16[64];

  30. extern UINT32 inverse[256];

  31. 

  32. static const unsigned long long int mm_wabs __attribute__ ((aligned(8))) = 0xffffffffffffffffULL;

  33. static const unsigned long long int mm_wone __attribute__ ((aligned(8))) = 0x0001000100010001ULL;

  34. 

  35. 

  36. static void dct_unquantize_h263_mmx(MpegEncContext *s,

  37.                                   DCTELEM *block, int n, int qscale)

  38. {

  39.     int level, qmul, qadd, nCoeffs;

  40. 

  41.     qmul = qscale << 1;

  42.     qadd = (qscale - 1) | 1;

  43. 

  44.     assert(s->block_last_index[n]>=0);

  45.         

  46.     if (s->mb_intra) {

  47.         if (!s->h263_aic) {

  48.             if (n < 4)

  49.                 level = block[0] * s->y_dc_scale;

  50.             else

  51.                 level = block[0] * s->c_dc_scale;

  52.         }else{

  53.             qadd = 0;

  54.             level= block[0];

  55.         }

  56.         nCoeffs=63;

  57.     } else {

  58. 	nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];

  59.         level = 0;/* keep gcc quiet */

  60.     }

  61. //printf("%d %d  ", qmul, qadd);

  62. asm volatile(

  63. 		"movd %1, %%mm6			\n\t" //qmul

  64. 		"packssdw %%mm6, %%mm6		\n\t"

  65. 		"packssdw %%mm6, %%mm6		\n\t"

  66. 		"movd %2, %%mm5			\n\t" //qadd

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

  68. 		"packssdw %%mm5, %%mm5		\n\t"

  69. 		"packssdw %%mm5, %%mm5		\n\t"

  70. 		"psubw %%mm5, %%mm7		\n\t"

  71. 		"pxor %%mm4, %%mm4		\n\t"

  72. 		".balign 16\n\t"

  73. 		"1:				\n\t"

  74. 		"movq (%0, %3), %%mm0		\n\t"

  75. 		"movq 8(%0, %3), %%mm1		\n\t"

  76. 

  77. 		"pmullw %%mm6, %%mm0		\n\t"

  78. 		"pmullw %%mm6, %%mm1		\n\t"

  79. 

  80. 		"movq (%0, %3), %%mm2		\n\t"

  81. 		"movq 8(%0, %3), %%mm3		\n\t"

  82. 

  83. 		"pcmpgtw %%mm4, %%mm2		\n\t" // block[i] < 0 ? -1 : 0

  84. 		"pcmpgtw %%mm4, %%mm3		\n\t" // block[i] < 0 ? -1 : 0

  85. 

  86. 		"pxor %%mm2, %%mm0		\n\t"

  87. 		"pxor %%mm3, %%mm1		\n\t"

  88. 

  89. 		"paddw %%mm7, %%mm0		\n\t"

  90. 		"paddw %%mm7, %%mm1		\n\t"

  91. 

  92. 		"pxor %%mm0, %%mm2		\n\t"

  93. 		"pxor %%mm1, %%mm3		\n\t"

  94. 

  95. 		"pcmpeqw %%mm7, %%mm0		\n\t" // block[i] == 0 ? -1 : 0

  96. 		"pcmpeqw %%mm7, %%mm1		\n\t" // block[i] == 0 ? -1 : 0

  97. 

  98. 		"pandn %%mm2, %%mm0		\n\t"

  99. 		"pandn %%mm3, %%mm1		\n\t"

  100. 

  101. 		"movq %%mm0, (%0, %3)		\n\t"

  102. 		"movq %%mm1, 8(%0, %3)		\n\t"

  103. 

  104. 		"addl $16, %3			\n\t"

  105. 		"jng 1b				\n\t"

  106. 		::"r" (block+nCoeffs), "g"(qmul), "g" (qadd), "r" (2*(-nCoeffs))

  107. 		: "memory"

  108. 	);

  109.         if(s->mb_intra)

  110.             block[0]= level;

  111. }

  112. 

  113. 

  114. /*

  115.   NK:

  116.   Note: looking at PARANOID:

  117.   "enable all paranoid tests for rounding, overflows, etc..."

  118. 

  119. #ifdef PARANOID

  120.                 if (level < -2048 || level > 2047)

  121.                     fprintf(stderr, "unquant error %d %d\n", i, level);

  122. #endif

  123.   We can suppose that result of two multiplications can't be greate of 0xFFFF

  124.   i.e. is 16-bit, so we use here only PMULLW instruction and can avoid

  125.   a complex multiplication.

  126. =====================================================

  127.  Full formula for multiplication of 2 integer numbers

  128.  which are represent as high:low words:

  129.  input: value1 = high1:low1

  130.         value2 = high2:low2

  131.  output: value3 = value1*value2

  132.  value3=high3:low3 (on overflow: modulus 2^32 wrap-around)

  133.  this mean that for 0x123456 * 0x123456 correct result is 0x766cb0ce4

  134.  but this algorithm will compute only 0x66cb0ce4

  135.  this limited by 16-bit size of operands

  136.  ---------------------------------

  137.  tlow1 = high1*low2

  138.  tlow2 = high2*low1

  139.  tlow1 = tlow1 + tlow2

  140.  high3:low3 = low1*low2

  141.  high3 += tlow1

  142. */

  143. static void dct_unquantize_mpeg1_mmx(MpegEncContext *s,

  144.                                      DCTELEM *block, int n, int qscale)

  145. {

  146.     int nCoeffs;

  147.     const UINT16 *quant_matrix;

  148. 

  149.     assert(s->block_last_index[n]>=0);

  150. 

  151.     nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ]+1;

  152. 

  153.     if (s->mb_intra) {

  154.         int block0;

  155.         if (n < 4) 

  156.             block0 = block[0] * s->y_dc_scale;

  157.         else

  158.             block0 = block[0] * s->c_dc_scale;

  159.         /* XXX: only mpeg1 */

  160.         quant_matrix = s->intra_matrix;

  161. asm volatile(

  162. 		"pcmpeqw %%mm7, %%mm7		\n\t"

  163. 		"psrlw $15, %%mm7		\n\t"

  164. 		"movd %2, %%mm6			\n\t"

  165. 		"packssdw %%mm6, %%mm6		\n\t"

  166. 		"packssdw %%mm6, %%mm6		\n\t"

  167.                 "movl %3, %%eax			\n\t"

  168. 		".balign 16\n\t"

  169. 		"1:				\n\t"

  170. 		"movq (%0, %%eax), %%mm0	\n\t"

  171. 		"movq 8(%0, %%eax), %%mm1	\n\t"

  172. 		"movq (%1, %%eax), %%mm4	\n\t"

  173. 		"movq 8(%1, %%eax), %%mm5	\n\t"

  174. 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]

  175. 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]

  176. 		"pxor %%mm2, %%mm2		\n\t"

  177. 		"pxor %%mm3, %%mm3		\n\t"

  178. 		"pcmpgtw %%mm0, %%mm2		\n\t" // block[i] < 0 ? -1 : 0

  179. 		"pcmpgtw %%mm1, %%mm3		\n\t" // block[i] < 0 ? -1 : 0

  180. 		"pxor %%mm2, %%mm0		\n\t"

  181. 		"pxor %%mm3, %%mm1		\n\t"

  182. 		"psubw %%mm2, %%mm0		\n\t" // abs(block[i])

  183. 		"psubw %%mm3, %%mm1		\n\t" // abs(block[i])

  184. 		"pmullw %%mm4, %%mm0		\n\t" // abs(block[i])*q

  185. 		"pmullw %%mm5, %%mm1		\n\t" // abs(block[i])*q

  186. 		"pxor %%mm4, %%mm4		\n\t"

  187. 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow

  188. 		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0

  189. 		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0

  190. 		"psraw $3, %%mm0		\n\t"

  191. 		"psraw $3, %%mm1		\n\t"

  192. 		"psubw %%mm7, %%mm0		\n\t"

  193. 		"psubw %%mm7, %%mm1		\n\t"

  194. 		"por %%mm7, %%mm0		\n\t"

  195. 		"por %%mm7, %%mm1		\n\t"

  196. 		"pxor %%mm2, %%mm0		\n\t"

  197. 		"pxor %%mm3, %%mm1		\n\t"

  198. 		"psubw %%mm2, %%mm0		\n\t"

  199. 		"psubw %%mm3, %%mm1		\n\t"

  200. 		"pandn %%mm0, %%mm4		\n\t"

  201. 		"pandn %%mm1, %%mm5		\n\t"

  202. 		"movq %%mm4, (%0, %%eax)	\n\t"

  203. 		"movq %%mm5, 8(%0, %%eax)	\n\t"

  204. 

  205. 		"addl $16, %%eax		\n\t"

  206. 		"js 1b				\n\t"

  207. 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)

  208. 		: "%eax", "memory"

  209. 	);    

  210.         block[0]= block0;

  211. 

  212.         } else {

  213.         quant_matrix = s->inter_matrix;

  214. asm volatile(

  215. 		"pcmpeqw %%mm7, %%mm7		\n\t"

  216. 		"psrlw $15, %%mm7		\n\t"

  217. 		"movd %2, %%mm6			\n\t"

  218. 		"packssdw %%mm6, %%mm6		\n\t"

  219. 		"packssdw %%mm6, %%mm6		\n\t"

  220.                 "movl %3, %%eax			\n\t"

  221. 		".balign 16\n\t"

  222. 		"1:				\n\t"

  223. 		"movq (%0, %%eax), %%mm0	\n\t"

  224. 		"movq 8(%0, %%eax), %%mm1	\n\t"

  225. 		"movq (%1, %%eax), %%mm4	\n\t"

  226. 		"movq 8(%1, %%eax), %%mm5	\n\t"

  227. 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]

  228. 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]

  229. 		"pxor %%mm2, %%mm2		\n\t"

  230. 		"pxor %%mm3, %%mm3		\n\t"

  231. 		"pcmpgtw %%mm0, %%mm2		\n\t" // block[i] < 0 ? -1 : 0

  232. 		"pcmpgtw %%mm1, %%mm3		\n\t" // block[i] < 0 ? -1 : 0

  233. 		"pxor %%mm2, %%mm0		\n\t"

  234. 		"pxor %%mm3, %%mm1		\n\t"

  235. 		"psubw %%mm2, %%mm0		\n\t" // abs(block[i])

  236. 		"psubw %%mm3, %%mm1		\n\t" // abs(block[i])

  237. 		"paddw %%mm0, %%mm0		\n\t" // abs(block[i])*2

  238. 		"paddw %%mm1, %%mm1		\n\t" // abs(block[i])*2

  239. 		"paddw %%mm7, %%mm0		\n\t" // abs(block[i])*2 + 1

  240. 		"paddw %%mm7, %%mm1		\n\t" // abs(block[i])*2 + 1

  241. 		"pmullw %%mm4, %%mm0		\n\t" // (abs(block[i])*2 + 1)*q

  242. 		"pmullw %%mm5, %%mm1		\n\t" // (abs(block[i])*2 + 1)*q

  243. 		"pxor %%mm4, %%mm4		\n\t"

  244. 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow

  245. 		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0

  246. 		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0

  247. 		"psraw $4, %%mm0		\n\t"

  248. 		"psraw $4, %%mm1		\n\t"

  249. 		"psubw %%mm7, %%mm0		\n\t"

  250. 		"psubw %%mm7, %%mm1		\n\t"

  251. 		"por %%mm7, %%mm0		\n\t"

  252. 		"por %%mm7, %%mm1		\n\t"

  253. 		"pxor %%mm2, %%mm0		\n\t"

  254. 		"pxor %%mm3, %%mm1		\n\t"

  255. 		"psubw %%mm2, %%mm0		\n\t"

  256. 		"psubw %%mm3, %%mm1		\n\t"

  257. 		"pandn %%mm0, %%mm4		\n\t"

  258. 		"pandn %%mm1, %%mm5		\n\t"

  259. 		"movq %%mm4, (%0, %%eax)	\n\t"

  260. 		"movq %%mm5, 8(%0, %%eax)	\n\t"

  261. 

  262. 		"addl $16, %%eax		\n\t"

  263. 		"js 1b				\n\t"

  264. 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)

  265. 		: "%eax", "memory"

  266. 	);

  267.     }

  268. 

  269. }

  270. 

  271. static void dct_unquantize_mpeg2_mmx(MpegEncContext *s,

  272.                                      DCTELEM *block, int n, int qscale)

  273. {

  274.     int nCoeffs;

  275.     const UINT16 *quant_matrix;

  276.     

  277.     assert(s->block_last_index[n]>=0);

  278. 

  279.     if(s->alternate_scan) nCoeffs= 63; //FIXME

  280.     else nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];

  281. 

  282.     if (s->mb_intra) {

  283.         int block0;

  284.         if (n < 4) 

  285.             block0 = block[0] * s->y_dc_scale;

  286.         else

  287.             block0 = block[0] * s->c_dc_scale;

  288.         quant_matrix = s->intra_matrix;

  289. asm volatile(

  290. 		"pcmpeqw %%mm7, %%mm7		\n\t"

  291. 		"psrlw $15, %%mm7		\n\t"

  292. 		"movd %2, %%mm6			\n\t"

  293. 		"packssdw %%mm6, %%mm6		\n\t"

  294. 		"packssdw %%mm6, %%mm6		\n\t"

  295.                 "movl %3, %%eax			\n\t"

  296. 		".balign 16\n\t"

  297. 		"1:				\n\t"

  298. 		"movq (%0, %%eax), %%mm0	\n\t"

  299. 		"movq 8(%0, %%eax), %%mm1	\n\t"

  300. 		"movq (%1, %%eax), %%mm4	\n\t"

  301. 		"movq 8(%1, %%eax), %%mm5	\n\t"

  302. 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]

  303. 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]

  304. 		"pxor %%mm2, %%mm2		\n\t"

  305. 		"pxor %%mm3, %%mm3		\n\t"

  306. 		"pcmpgtw %%mm0, %%mm2		\n\t" // block[i] < 0 ? -1 : 0

  307. 		"pcmpgtw %%mm1, %%mm3		\n\t" // block[i] < 0 ? -1 : 0

  308. 		"pxor %%mm2, %%mm0		\n\t"

  309. 		"pxor %%mm3, %%mm1		\n\t"

  310. 		"psubw %%mm2, %%mm0		\n\t" // abs(block[i])

  311. 		"psubw %%mm3, %%mm1		\n\t" // abs(block[i])

  312. 		"pmullw %%mm4, %%mm0		\n\t" // abs(block[i])*q

  313. 		"pmullw %%mm5, %%mm1		\n\t" // abs(block[i])*q

  314. 		"pxor %%mm4, %%mm4		\n\t"

  315. 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow

  316. 		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0

  317. 		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0

  318. 		"psraw $3, %%mm0		\n\t"

  319. 		"psraw $3, %%mm1		\n\t"

  320. 		"pxor %%mm2, %%mm0		\n\t"

  321. 		"pxor %%mm3, %%mm1		\n\t"

  322. 		"psubw %%mm2, %%mm0		\n\t"

  323. 		"psubw %%mm3, %%mm1		\n\t"

  324. 		"pandn %%mm0, %%mm4		\n\t"

  325. 		"pandn %%mm1, %%mm5		\n\t"

  326. 		"movq %%mm4, (%0, %%eax)	\n\t"

  327. 		"movq %%mm5, 8(%0, %%eax)	\n\t"

  328. 

  329. 		"addl $16, %%eax		\n\t"

  330. 		"jng 1b				\n\t"

  331. 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)

  332. 		: "%eax", "memory"

  333. 	);    

  334.         block[0]= block0;

  335.         //Note, we dont do mismatch control for intra as errors cannot accumulate

  336. 

  337.     } else {

  338.         quant_matrix = s->inter_matrix;

  339. asm volatile(

  340. 		"pcmpeqw %%mm7, %%mm7		\n\t"

  341.                 "psrlq $48, %%mm7		\n\t"

  342. 		"movd %2, %%mm6			\n\t"

  343. 		"packssdw %%mm6, %%mm6		\n\t"

  344. 		"packssdw %%mm6, %%mm6		\n\t"

  345.                 "movl %3, %%eax			\n\t"

  346. 		".balign 16\n\t"

  347. 		"1:				\n\t"

  348. 		"movq (%0, %%eax), %%mm0	\n\t"

  349. 		"movq 8(%0, %%eax), %%mm1	\n\t"

  350. 		"movq (%1, %%eax), %%mm4	\n\t"

  351. 		"movq 8(%1, %%eax), %%mm5	\n\t"

  352. 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]

  353. 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]

  354. 		"pxor %%mm2, %%mm2		\n\t"

  355. 		"pxor %%mm3, %%mm3		\n\t"

  356. 		"pcmpgtw %%mm0, %%mm2		\n\t" // block[i] < 0 ? -1 : 0

  357. 		"pcmpgtw %%mm1, %%mm3		\n\t" // block[i] < 0 ? -1 : 0

  358. 		"pxor %%mm2, %%mm0		\n\t"

  359. 		"pxor %%mm3, %%mm1		\n\t"

  360. 		"psubw %%mm2, %%mm0		\n\t" // abs(block[i])

  361. 		"psubw %%mm3, %%mm1		\n\t" // abs(block[i])

  362. 		"paddw %%mm0, %%mm0		\n\t" // abs(block[i])*2

  363. 		"paddw %%mm1, %%mm1		\n\t" // abs(block[i])*2

  364. 		"pmullw %%mm4, %%mm0		\n\t" // abs(block[i])*2*q

  365. 		"pmullw %%mm5, %%mm1		\n\t" // abs(block[i])*2*q

  366. 		"paddw %%mm4, %%mm0		\n\t" // (abs(block[i])*2 + 1)*q

  367. 		"paddw %%mm5, %%mm1		\n\t" // (abs(block[i])*2 + 1)*q

  368. 		"pxor %%mm4, %%mm4		\n\t"

  369. 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow

  370. 		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0

  371. 		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0

  372. 		"psrlw $4, %%mm0		\n\t"

  373. 		"psrlw $4, %%mm1		\n\t"

  374. 		"pxor %%mm2, %%mm0		\n\t"

  375. 		"pxor %%mm3, %%mm1		\n\t"

  376. 		"psubw %%mm2, %%mm0		\n\t"

  377. 		"psubw %%mm3, %%mm1		\n\t"

  378. 		"pandn %%mm0, %%mm4		\n\t"

  379. 		"pandn %%mm1, %%mm5		\n\t"

  380.                 "pxor %%mm4, %%mm7		\n\t"

  381.                 "pxor %%mm5, %%mm7		\n\t"

  382. 		"movq %%mm4, (%0, %%eax)	\n\t"

  383. 		"movq %%mm5, 8(%0, %%eax)	\n\t"

  384. 

  385. 		"addl $16, %%eax		\n\t"

  386. 		"jng 1b				\n\t"

  387.                 "movd 124(%0, %3), %%mm0	\n\t"

  388.                 "movq %%mm7, %%mm6		\n\t"

  389.                 "psrlq $32, %%mm7		\n\t"

  390.                 "pxor %%mm6, %%mm7		\n\t"

  391.                 "movq %%mm7, %%mm6		\n\t"

  392.                 "psrlq $16, %%mm7		\n\t"

  393.                 "pxor %%mm6, %%mm7		\n\t"

  394.                 "pslld $31, %%mm7		\n\t"

  395.                 "psrlq $15, %%mm7		\n\t"

  396.                 "pxor %%mm7, %%mm0		\n\t"

  397.                 "movd %%mm0, 124(%0, %3)	\n\t"

  398.                 

  399. 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "r" (-2*nCoeffs)

  400. 		: "%eax", "memory"

  401. 	);

  402.     }

  403. }

  404. 

  405. /* draw the edges of width 'w' of an image of size width, height 

  406.    this mmx version can only handle w==8 || w==16 */

  407. static void draw_edges_mmx(UINT8 *buf, int wrap, int width, int height, int w)

  408. {

  409.     UINT8 *ptr, *last_line;

  410.     int i;

  411. 

  412.     last_line = buf + (height - 1) * wrap;

  413.     /* left and right */

  414.     ptr = buf;

  415.     if(w==8)

  416.     {

  417. 	asm volatile(

  418. 		"1:				\n\t"

  419. 		"movd (%0), %%mm0		\n\t"

  420. 		"punpcklbw %%mm0, %%mm0		\n\t" 

  421. 		"punpcklwd %%mm0, %%mm0		\n\t"

  422. 		"punpckldq %%mm0, %%mm0		\n\t"

  423. 		"movq %%mm0, -8(%0)		\n\t"

  424. 		"movq -8(%0, %2), %%mm1		\n\t"

  425. 		"punpckhbw %%mm1, %%mm1		\n\t"

  426. 		"punpckhwd %%mm1, %%mm1		\n\t"

  427. 		"punpckhdq %%mm1, %%mm1		\n\t"

  428. 		"movq %%mm1, (%0, %2)		\n\t"

  429. 		"addl %1, %0			\n\t"

  430. 		"cmpl %3, %0			\n\t"

  431. 		" jb 1b				\n\t"

  432. 		: "+r" (ptr)

  433. 		: "r" (wrap), "r" (width), "r" (ptr + wrap*height)

  434. 	);

  435.     }

  436.     else

  437.     {

  438. 	asm volatile(

  439. 		"1:				\n\t"

  440. 		"movd (%0), %%mm0		\n\t"

  441. 		"punpcklbw %%mm0, %%mm0		\n\t" 

  442. 		"punpcklwd %%mm0, %%mm0		\n\t"

  443. 		"punpckldq %%mm0, %%mm0		\n\t"

  444. 		"movq %%mm0, -8(%0)		\n\t"

  445. 		"movq %%mm0, -16(%0)		\n\t"

  446. 		"movq -8(%0, %2), %%mm1		\n\t"

  447. 		"punpckhbw %%mm1, %%mm1		\n\t"

  448. 		"punpckhwd %%mm1, %%mm1		\n\t"

  449. 		"punpckhdq %%mm1, %%mm1		\n\t"

  450. 		"movq %%mm1, (%0, %2)		\n\t"

  451. 		"movq %%mm1, 8(%0, %2)		\n\t"

  452. 		"addl %1, %0			\n\t"

  453. 		"cmpl %3, %0			\n\t"

  454. 		" jb 1b				\n\t"		

  455. 		: "+r" (ptr)

  456. 		: "r" (wrap), "r" (width), "r" (ptr + wrap*height)

  457. 	);

  458.     }

  459.     

  460.     for(i=0;i<w;i+=4) {

  461.         /* top and bottom (and hopefully also the corners) */

  462. 	ptr= buf - (i + 1) * wrap - w;

  463. 	asm volatile(

  464. 		"1:				\n\t"

  465. 		"movq (%1, %0), %%mm0		\n\t"

  466. 		"movq %%mm0, (%0)		\n\t"

  467. 		"movq %%mm0, (%0, %2)		\n\t"

  468. 		"movq %%mm0, (%0, %2, 2)	\n\t"

  469. 		"movq %%mm0, (%0, %3)		\n\t"

  470. 		"addl $8, %0			\n\t"

  471. 		"cmpl %4, %0			\n\t"

  472. 		" jb 1b				\n\t"

  473. 		: "+r" (ptr)

  474. 		: "r" ((int)buf - (int)ptr - w), "r" (-wrap), "r" (-wrap*3), "r" (ptr+width+2*w)

  475. 	);

  476. 	ptr= last_line + (i + 1) * wrap - w;

  477. 	asm volatile(

  478. 		"1:				\n\t"

  479. 		"movq (%1, %0), %%mm0		\n\t"

  480. 		"movq %%mm0, (%0)		\n\t"

  481. 		"movq %%mm0, (%0, %2)		\n\t"

  482. 		"movq %%mm0, (%0, %2, 2)	\n\t"

  483. 		"movq %%mm0, (%0, %3)		\n\t"

  484. 		"addl $8, %0			\n\t"

  485. 		"cmpl %4, %0			\n\t"

  486. 		" jb 1b				\n\t"

  487. 		: "+r" (ptr)

  488. 		: "r" ((int)last_line - (int)ptr - w), "r" (wrap), "r" (wrap*3), "r" (ptr+width+2*w)

  489. 	);

  490.     }

  491. }

  492. 

  493. #undef HAVE_MMX2

  494. #define RENAME(a) a ## _MMX

  495. #include "mpegvideo_mmx_template.c"

  496. 

  497. #define HAVE_MMX2

  498. #undef RENAME

  499. #define RENAME(a) a ## _MMX2

  500. #include "mpegvideo_mmx_template.c"

  501. 

  502. /* external functions, from idct_mmx.c */

  503. void ff_mmx_idct(DCTELEM *block);

  504. void ff_mmxext_idct(DCTELEM *block);

  505. 

  506. /* XXX: those functions should be suppressed ASAP when all IDCTs are

  507.    converted */

  508. static void ff_libmpeg2mmx_idct_put(UINT8 *dest, int line_size, DCTELEM *block)

  509. {

  510.     ff_mmx_idct (block);

  511.     put_pixels_clamped_mmx(block, dest, line_size);

  512. }

  513. static void ff_libmpeg2mmx_idct_add(UINT8 *dest, int line_size, DCTELEM *block)

  514. {

  515.     ff_mmx_idct (block);

  516.     add_pixels_clamped_mmx(block, dest, line_size);

  517. }

  518. static void ff_libmpeg2mmx2_idct_put(UINT8 *dest, int line_size, DCTELEM *block)

  519. {

  520.     ff_mmxext_idct (block);

  521.     put_pixels_clamped_mmx(block, dest, line_size);

  522. }

  523. static void ff_libmpeg2mmx2_idct_add(UINT8 *dest, int line_size, DCTELEM *block)

  524. {

  525.     ff_mmxext_idct (block);

  526.     add_pixels_clamped_mmx(block, dest, line_size);

  527. }

  528. 

  529. void MPV_common_init_mmx(MpegEncContext *s)

  530. {

  531.     if (mm_flags & MM_MMX) {

  532.         int i;

  533.         const int dct_algo = s->avctx->dct_algo;

  534.         const int idct_algo= s->avctx->idct_algo;

  535.         

  536.         s->dct_unquantize_h263 = dct_unquantize_h263_mmx;

  537.         s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_mmx;

  538.         s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_mmx;

  539. 

  540.         draw_edges = draw_edges_mmx;

  541. 

  542.         if(dct_algo==FF_DCT_AUTO || dct_algo==FF_DCT_MMX){

  543.             s->fdct = ff_fdct_mmx;

  544. 

  545.             if(mm_flags & MM_MMXEXT){

  546.                 s->dct_quantize= dct_quantize_MMX2;

  547.             } else {

  548.                 s->dct_quantize= dct_quantize_MMX;

  549.             }

  550.         }

  551. 

  552.         if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SIMPLEMMX){

  553.             s->idct_put= ff_simple_idct_put_mmx;

  554.             s->idct_add= ff_simple_idct_add_mmx;

  555.             s->idct_permutation_type= FF_SIMPLE_IDCT_PERM;

  556.         }else if(idct_algo==FF_IDCT_LIBMPEG2MMX){

  557.             if(mm_flags & MM_MMXEXT){

  558.                 s->idct_put= ff_libmpeg2mmx2_idct_put;

  559.                 s->idct_add= ff_libmpeg2mmx2_idct_add;

  560.             }else{

  561.                 s->idct_put= ff_libmpeg2mmx_idct_put;

  562.                 s->idct_add= ff_libmpeg2mmx_idct_add;

  563.             }

  564.             s->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;

  565.         }

  566.     }

  567. }