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

521 lines
16KB
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. 

  27. extern uint8_t zigzag_direct_noperm[64];

  28. extern uint16_t inv_zigzag_direct16[64];

  29. extern uint32_t inverse[256];

  30. 

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

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

  33. 

  34. 

  35. static void dct_unquantize_h263_mmx(MpegEncContext *s,

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

  37. {

  38.     int level, qmul, qadd, nCoeffs;

  39. 

  40.     qmul = qscale << 1;

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

  42. 

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

  44.         

  45.     if (s->mb_intra) {

  46.         if (!s->h263_aic) {

  47.             if (n < 4)

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

  49.             else

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

  51.         }else{

  52.             qadd = 0;

  53.             level= block[0];

  54.         }

  55.         nCoeffs=63;

  56.     } else {

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

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

  59.     }

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

  61. asm volatile(

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

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

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

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

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

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

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

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

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

  71. 		".balign 16\n\t"

  72. 		"1:				\n\t"

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

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

  75. 

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

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

  78. 

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

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

  81. 

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

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

  84. 

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

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

  87. 

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

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

  90. 

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

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

  93. 

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

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

  96. 

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

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

  99. 

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

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

  102. 

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

  104. 		"jng 1b				\n\t"

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

  106. 		: "memory"

  107. 	);

  108.         if(s->mb_intra)

  109.             block[0]= level;

  110. }

  111. 

  112. 

  113. /*

  114.   NK:

  115.   Note: looking at PARANOID:

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

  117. 

  118. #ifdef PARANOID

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

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

  121. #endif

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

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

  124.   a complex multiplication.

  125. =====================================================

  126.  Full formula for multiplication of 2 integer numbers

  127.  which are represent as high:low words:

  128.  input: value1 = high1:low1

  129.         value2 = high2:low2

  130.  output: value3 = value1*value2

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

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

  133.  but this algorithm will compute only 0x66cb0ce4

  134.  this limited by 16-bit size of operands

  135.  ---------------------------------

  136.  tlow1 = high1*low2

  137.  tlow2 = high2*low1

  138.  tlow1 = tlow1 + tlow2

  139.  high3:low3 = low1*low2

  140.  high3 += tlow1

  141. */

  142. static void dct_unquantize_mpeg1_mmx(MpegEncContext *s,

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

  144. {

  145.     int nCoeffs;

  146.     const uint16_t *quant_matrix;

  147. 

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

  149. 

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

  151. 

  152.     if (s->mb_intra) {

  153.         int block0;

  154.         if (n < 4) 

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

  156.         else

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

  158.         /* XXX: only mpeg1 */

  159.         quant_matrix = s->intra_matrix;

  160. asm volatile(

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

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

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

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

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

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

  167. 		".balign 16\n\t"

  168. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  203. 

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

  205. 		"js 1b				\n\t"

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

  207. 		: "%eax", "memory"

  208. 	);    

  209.         block[0]= block0;

  210. 

  211.         } else {

  212.         quant_matrix = s->inter_matrix;

  213. asm volatile(

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

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

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

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

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

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

  220. 		".balign 16\n\t"

  221. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  260. 

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

  262. 		"js 1b				\n\t"

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

  264. 		: "%eax", "memory"

  265. 	);

  266.     }

  267. 

  268. }

  269. 

  270. static void dct_unquantize_mpeg2_mmx(MpegEncContext *s,

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

  272. {

  273.     int nCoeffs;

  274.     const uint16_t *quant_matrix;

  275.     

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

  277. 

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

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

  280. 

  281.     if (s->mb_intra) {

  282.         int block0;

  283.         if (n < 4) 

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

  285.         else

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

  287.         quant_matrix = s->intra_matrix;

  288. asm volatile(

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

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

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

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

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

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

  295. 		".balign 16\n\t"

  296. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  327. 

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

  329. 		"jng 1b				\n\t"

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

  331. 		: "%eax", "memory"

  332. 	);    

  333.         block[0]= block0;

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

  335. 

  336.     } else {

  337.         quant_matrix = s->inter_matrix;

  338. asm volatile(

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

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

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

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

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

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

  345. 		".balign 16\n\t"

  346. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  383. 

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

  385. 		"jng 1b				\n\t"

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

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

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

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

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

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

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

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

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

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

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

  397.                 

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

  399. 		: "%eax", "memory"

  400. 	);

  401.     }

  402. }

  403. 

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

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

  406. static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)

  407. {

  408.     uint8_t *ptr, *last_line;

  409.     int i;

  410. 

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

  412.     /* left and right */

  413.     ptr = buf;

  414.     if(w==8)

  415.     {

  416. 	asm volatile(

  417. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

  430. 		" jb 1b				\n\t"

  431. 		: "+r" (ptr)

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

  433. 	);

  434.     }

  435.     else

  436.     {

  437. 	asm volatile(

  438. 		"1:				\n\t"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  453. 		" jb 1b				\n\t"		

  454. 		: "+r" (ptr)

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

  456. 	);

  457.     }

  458.     

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

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

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

  462. 	asm volatile(

  463. 		"1:				\n\t"

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

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

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

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

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

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

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

  471. 		" jb 1b				\n\t"

  472. 		: "+r" (ptr)

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

  474. 	);

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

  476. 	asm volatile(

  477. 		"1:				\n\t"

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

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

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

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

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

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

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

  485. 		" jb 1b				\n\t"

  486. 		: "+r" (ptr)

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

  488. 	);

  489.     }

  490. }

  491. 

  492. #undef HAVE_MMX2

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

  494. #include "mpegvideo_mmx_template.c"

  495. 

  496. #define HAVE_MMX2

  497. #undef RENAME

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

  499. #include "mpegvideo_mmx_template.c"

  500. 

  501. void MPV_common_init_mmx(MpegEncContext *s)

  502. {

  503.     if (mm_flags & MM_MMX) {

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

  505.         

  506.         s->dct_unquantize_h263 = dct_unquantize_h263_mmx;

  507.         s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_mmx;

  508.         s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_mmx;

  509. 

  510.         draw_edges = draw_edges_mmx;

  511. 

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

  513.             if(mm_flags & MM_MMXEXT){

  514.                 s->dct_quantize= dct_quantize_MMX2;

  515.             } else {

  516.                 s->dct_quantize= dct_quantize_MMX;

  517.             }

  518.         }

  519.     }

  520. }