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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
mpegvideo_mmx.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：22k
源码类别：

Windows CE

开发平台：

C/C++

mpegvideo_mmx.c：源码内容
  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.  */
  23. #include "../dsputil.h"
  24. #include "../mpegvideo.h"
  25. #include "../avcodec.h"
  26. #include "mmx.h"
  28. extern uint8_t zigzag_direct_noperm[64];
  29. extern uint16_t inv_zigzag_direct16[64];
  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;
  35. static void dct_unquantize_h263_intra_mmx(MpegEncContext *s,
  36.                                   DCTELEM *block, int n, int qscale)
  37. {
  38.     long level, qmul, qadd, nCoeffs;
  40.     qmul = qscale << 1;
  42.     assert(s->block_last_index[n]>=0 || s->h263_aic);
  43.         
  44.     if (!s->h263_aic) {
  45.         if (n < 4)
  46.             level = block[0] * s->y_dc_scale;
  47.         else
  48.             level = block[0] * s->c_dc_scale;
  49.         qadd = (qscale - 1) | 1;
  50.     }else{
  51.         qadd = 0;
  52.         level= block[0];
  53.     }
  54.     if(s->ac_pred)
  55.         nCoeffs=63;
  56.     else
  57.         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
  58. //printf("%d %d  ", qmul, qadd);
  59. asm volatile(
  60. "movd %1, %%mm6 nt" //qmul
  61. "packssdw %%mm6, %%mm6 nt"
  62. "packssdw %%mm6, %%mm6 nt"
  63. "movd %2, %%mm5 nt" //qadd
  64. "pxor %%mm7, %%mm7 nt"
  65. "packssdw %%mm5, %%mm5 nt"
  66. "packssdw %%mm5, %%mm5 nt"
  67. "psubw %%mm5, %%mm7 nt"
  68. "pxor %%mm4, %%mm4 nt"
  69. ".balign 16nt"
  70. "1: nt"
  71. "movq (%0, %3), %%mm0 nt"
  72. "movq 8(%0, %3), %%mm1 nt"
  74. "pmullw %%mm6, %%mm0 nt"
  75. "pmullw %%mm6, %%mm1 nt"
  77. "movq (%0, %3), %%mm2 nt"
  78. "movq 8(%0, %3), %%mm3 nt"
  80. "pcmpgtw %%mm4, %%mm2 nt" // block[i] < 0 ? -1 : 0
  81. "pcmpgtw %%mm4, %%mm3 nt" // block[i] < 0 ? -1 : 0
  83. "pxor %%mm2, %%mm0 nt"
  84. "pxor %%mm3, %%mm1 nt"
  86. "paddw %%mm7, %%mm0 nt"
  87. "paddw %%mm7, %%mm1 nt"
  89. "pxor %%mm0, %%mm2 nt"
  90. "pxor %%mm1, %%mm3 nt"
  92. "pcmpeqw %%mm7, %%mm0 nt" // block[i] == 0 ? -1 : 0
  93. "pcmpeqw %%mm7, %%mm1 nt" // block[i] == 0 ? -1 : 0
  95. "pandn %%mm2, %%mm0 nt"
  96. "pandn %%mm3, %%mm1 nt"
  98. "movq %%mm0, (%0, %3) nt"
  99. "movq %%mm1, 8(%0, %3) nt"
  101. "add $16, %3 nt"
  102. "jng 1b nt"
  103. ::"r" (block+nCoeffs), "g"(qmul), "g" (qadd), "r" (2*(-nCoeffs))
  104. : "memory"
  105. );
  106.         block[0]= level;
  107. }
  110. static void dct_unquantize_h263_inter_mmx(MpegEncContext *s,
  111.                                   DCTELEM *block, int n, int qscale)
  112. {
  113.     long qmul, qadd, nCoeffs;
  115.     qmul = qscale << 1;
  116.     qadd = (qscale - 1) | 1;
  118.     assert(s->block_last_index[n]>=0 || s->h263_aic);
  119.         
  120.     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
  121. //printf("%d %d  ", qmul, qadd);
  122. asm volatile(
  123. "movd %1, %%mm6 nt" //qmul
  124. "packssdw %%mm6, %%mm6 nt"
  125. "packssdw %%mm6, %%mm6 nt"
  126. "movd %2, %%mm5 nt" //qadd
  127. "pxor %%mm7, %%mm7 nt"
  128. "packssdw %%mm5, %%mm5 nt"
  129. "packssdw %%mm5, %%mm5 nt"
  130. "psubw %%mm5, %%mm7 nt"
  131. "pxor %%mm4, %%mm4 nt"
  132. ".balign 16nt"
  133. "1: nt"
  134. "movq (%0, %3), %%mm0 nt"
  135. "movq 8(%0, %3), %%mm1 nt"
  137. "pmullw %%mm6, %%mm0 nt"
  138. "pmullw %%mm6, %%mm1 nt"
  140. "movq (%0, %3), %%mm2 nt"
  141. "movq 8(%0, %3), %%mm3 nt"
  143. "pcmpgtw %%mm4, %%mm2 nt" // block[i] < 0 ? -1 : 0
  144. "pcmpgtw %%mm4, %%mm3 nt" // block[i] < 0 ? -1 : 0
  146. "pxor %%mm2, %%mm0 nt"
  147. "pxor %%mm3, %%mm1 nt"
  149. "paddw %%mm7, %%mm0 nt"
  150. "paddw %%mm7, %%mm1 nt"
  152. "pxor %%mm0, %%mm2 nt"
  153. "pxor %%mm1, %%mm3 nt"
  155. "pcmpeqw %%mm7, %%mm0 nt" // block[i] == 0 ? -1 : 0
  156. "pcmpeqw %%mm7, %%mm1 nt" // block[i] == 0 ? -1 : 0
  158. "pandn %%mm2, %%mm0 nt"
  159. "pandn %%mm3, %%mm1 nt"
  161. "movq %%mm0, (%0, %3) nt"
  162. "movq %%mm1, 8(%0, %3) nt"
  164. "add $16, %3 nt"
  165. "jng 1b nt"
  166. ::"r" (block+nCoeffs), "g"(qmul), "g" (qadd), "r" (2*(-nCoeffs))
  167. : "memory"
  168. );
  169. }
  172. /*
  173.   NK:
  174.   Note: looking at PARANOID:
  175.   "enable all paranoid tests for rounding, overflows, etc..."
  177. #ifdef PARANOID
  178.                 if (level < -2048 || level > 2047)
  179.                     fprintf(stderr, "unquant error %d %dn", i, level);
  180. #endif
  181.   We can suppose that result of two multiplications can't be greate of 0xFFFF
  182.   i.e. is 16-bit, so we use here only PMULLW instruction and can avoid
  183.   a complex multiplication.
  184. =====================================================
  185.  Full formula for multiplication of 2 integer numbers
  186.  which are represent as high:low words:
  187.  input: value1 = high1:low1
  188.         value2 = high2:low2
  189.  output: value3 = value1*value2
  190.  value3=high3:low3 (on overflow: modulus 2^32 wrap-around)
  191.  this mean that for 0x123456 * 0x123456 correct result is 0x766cb0ce4
  192.  but this algorithm will compute only 0x66cb0ce4
  193.  this limited by 16-bit size of operands
  194.  ---------------------------------
  195.  tlow1 = high1*low2
  196.  tlow2 = high2*low1
  197.  tlow1 = tlow1 + tlow2
  198.  high3:low3 = low1*low2
  199.  high3 += tlow1
  200. */
  201. static void dct_unquantize_mpeg1_intra_mmx(MpegEncContext *s,
  202.                                      DCTELEM *block, int n, int qscale)
  203. {
  204.     long nCoeffs;
  205.     const uint16_t *quant_matrix;
  206.     int block0;
  208.     assert(s->block_last_index[n]>=0);
  210.     nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ]+1;
  212.     if (n < 4) 
  213.         block0 = block[0] * s->y_dc_scale;
  214.     else
  215.         block0 = block[0] * s->c_dc_scale;
  216.     /* XXX: only mpeg1 */
  217.     quant_matrix = s->intra_matrix;
  218. asm volatile(
  219. "pcmpeqw %%mm7, %%mm7 nt"
  220. "psrlw $15, %%mm7 nt"
  221. "movd %2, %%mm6 nt"
  222. "packssdw %%mm6, %%mm6 nt"
  223. "packssdw %%mm6, %%mm6 nt"
  224. "mov %3, %%"REG_a" nt"
  225. ".balign 16nt"
  226. "1: nt"
  227. "movq (%0, %%"REG_a"), %%mm0 nt"
  228. "movq 8(%0, %%"REG_a"), %%mm1 nt"
  229. "movq (%1, %%"REG_a"), %%mm4 nt"
  230. "movq 8(%1, %%"REG_a"), %%mm5 nt"
  231. "pmullw %%mm6, %%mm4 nt" // q=qscale*quant_matrix[i]
  232. "pmullw %%mm6, %%mm5 nt" // q=qscale*quant_matrix[i]
  233. "pxor %%mm2, %%mm2 nt"
  234. "pxor %%mm3, %%mm3 nt"
  235. "pcmpgtw %%mm0, %%mm2 nt" // block[i] < 0 ? -1 : 0
  236. "pcmpgtw %%mm1, %%mm3 nt" // block[i] < 0 ? -1 : 0
  237. "pxor %%mm2, %%mm0 nt"
  238. "pxor %%mm3, %%mm1 nt"
  239. "psubw %%mm2, %%mm0 nt" // abs(block[i])
  240. "psubw %%mm3, %%mm1 nt" // abs(block[i])
  241. "pmullw %%mm4, %%mm0 nt" // abs(block[i])*q
  242. "pmullw %%mm5, %%mm1 nt" // abs(block[i])*q
  243. "pxor %%mm4, %%mm4 nt"
  244. "pxor %%mm5, %%mm5 nt" // FIXME slow
  245. "pcmpeqw (%0, %%"REG_a"), %%mm4 nt" // block[i] == 0 ? -1 : 0
  246. "pcmpeqw 8(%0, %%"REG_a"), %%mm5nt" // block[i] == 0 ? -1 : 0
  247. "psraw $3, %%mm0 nt"
  248. "psraw $3, %%mm1 nt"
  249. "psubw %%mm7, %%mm0 nt"
  250. "psubw %%mm7, %%mm1 nt"
  251. "por %%mm7, %%mm0 nt"
  252. "por %%mm7, %%mm1 nt"
  253. "pxor %%mm2, %%mm0 nt"
  254. "pxor %%mm3, %%mm1 nt"
  255. "psubw %%mm2, %%mm0 nt"
  256. "psubw %%mm3, %%mm1 nt"
  257. "pandn %%mm0, %%mm4 nt"
  258. "pandn %%mm1, %%mm5 nt"
  259. "movq %%mm4, (%0, %%"REG_a") nt"
  260. "movq %%mm5, 8(%0, %%"REG_a") nt"
  262. "add $16, %%"REG_a" nt"
  263. "js 1b nt"
  264. ::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
  265. : "%"REG_a, "memory"
  266. );    
  267.     block[0]= block0;
  268. }
  270. static void dct_unquantize_mpeg1_inter_mmx(MpegEncContext *s,
  271.                                      DCTELEM *block, int n, int qscale)
  272. {
  273.     long nCoeffs;
  274.     const uint16_t *quant_matrix;
  276.     assert(s->block_last_index[n]>=0);
  278.     nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ]+1;
  280.         quant_matrix = s->inter_matrix;
  281. asm volatile(
  282. "pcmpeqw %%mm7, %%mm7 nt"
  283. "psrlw $15, %%mm7 nt"
  284. "movd %2, %%mm6 nt"
  285. "packssdw %%mm6, %%mm6 nt"
  286. "packssdw %%mm6, %%mm6 nt"
  287. "mov %3, %%"REG_a" nt"
  288. ".balign 16nt"
  289. "1: nt"
  290. "movq (%0, %%"REG_a"), %%mm0 nt"
  291. "movq 8(%0, %%"REG_a"), %%mm1 nt"
  292. "movq (%1, %%"REG_a"), %%mm4 nt"
  293. "movq 8(%1, %%"REG_a"), %%mm5 nt"
  294. "pmullw %%mm6, %%mm4 nt" // q=qscale*quant_matrix[i]
  295. "pmullw %%mm6, %%mm5 nt" // q=qscale*quant_matrix[i]
  296. "pxor %%mm2, %%mm2 nt"
  297. "pxor %%mm3, %%mm3 nt"
  298. "pcmpgtw %%mm0, %%mm2 nt" // block[i] < 0 ? -1 : 0
  299. "pcmpgtw %%mm1, %%mm3 nt" // block[i] < 0 ? -1 : 0
  300. "pxor %%mm2, %%mm0 nt"
  301. "pxor %%mm3, %%mm1 nt"
  302. "psubw %%mm2, %%mm0 nt" // abs(block[i])
  303. "psubw %%mm3, %%mm1 nt" // abs(block[i])
  304. "paddw %%mm0, %%mm0 nt" // abs(block[i])*2
  305. "paddw %%mm1, %%mm1 nt" // abs(block[i])*2
  306. "paddw %%mm7, %%mm0 nt" // abs(block[i])*2 + 1
  307. "paddw %%mm7, %%mm1 nt" // abs(block[i])*2 + 1
  308. "pmullw %%mm4, %%mm0 nt" // (abs(block[i])*2 + 1)*q
  309. "pmullw %%mm5, %%mm1 nt" // (abs(block[i])*2 + 1)*q
  310. "pxor %%mm4, %%mm4 nt"
  311. "pxor %%mm5, %%mm5 nt" // FIXME slow
  312. "pcmpeqw (%0, %%"REG_a"), %%mm4 nt" // block[i] == 0 ? -1 : 0
  313. "pcmpeqw 8(%0, %%"REG_a"), %%mm5nt" // block[i] == 0 ? -1 : 0
  314. "psraw $4, %%mm0 nt"
  315. "psraw $4, %%mm1 nt"
  316. "psubw %%mm7, %%mm0 nt"
  317. "psubw %%mm7, %%mm1 nt"
  318. "por %%mm7, %%mm0 nt"
  319. "por %%mm7, %%mm1 nt"
  320. "pxor %%mm2, %%mm0 nt"
  321. "pxor %%mm3, %%mm1 nt"
  322. "psubw %%mm2, %%mm0 nt"
  323. "psubw %%mm3, %%mm1 nt"
  324. "pandn %%mm0, %%mm4 nt"
  325. "pandn %%mm1, %%mm5 nt"
  326. "movq %%mm4, (%0, %%"REG_a") nt"
  327. "movq %%mm5, 8(%0, %%"REG_a") nt"
  329. "add $16, %%"REG_a" nt"
  330. "js 1b nt"
  331. ::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
  332. : "%"REG_a, "memory"
  333. );
  334. }
  336. static void dct_unquantize_mpeg2_intra_mmx(MpegEncContext *s,
  337.                                      DCTELEM *block, int n, int qscale)
  338. {
  339.     long nCoeffs;
  340.     const uint16_t *quant_matrix;
  341.     int block0;
  342.     
  343.     assert(s->block_last_index[n]>=0);
  345.     if(s->alternate_scan) nCoeffs= 63; //FIXME
  346.     else nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
  348.     if (n < 4) 
  349.         block0 = block[0] * s->y_dc_scale;
  350.     else
  351.         block0 = block[0] * s->c_dc_scale;
  352.     quant_matrix = s->intra_matrix;
  353. asm volatile(
  354. "pcmpeqw %%mm7, %%mm7 nt"
  355. "psrlw $15, %%mm7 nt"
  356. "movd %2, %%mm6 nt"
  357. "packssdw %%mm6, %%mm6 nt"
  358. "packssdw %%mm6, %%mm6 nt"
  359. "mov %3, %%"REG_a" nt"
  360. ".balign 16nt"
  361. "1: nt"
  362. "movq (%0, %%"REG_a"), %%mm0 nt"
  363. "movq 8(%0, %%"REG_a"), %%mm1 nt"
  364. "movq (%1, %%"REG_a"), %%mm4 nt"
  365. "movq 8(%1, %%"REG_a"), %%mm5 nt"
  366. "pmullw %%mm6, %%mm4 nt" // q=qscale*quant_matrix[i]
  367. "pmullw %%mm6, %%mm5 nt" // q=qscale*quant_matrix[i]
  368. "pxor %%mm2, %%mm2 nt"
  369. "pxor %%mm3, %%mm3 nt"
  370. "pcmpgtw %%mm0, %%mm2 nt" // block[i] < 0 ? -1 : 0
  371. "pcmpgtw %%mm1, %%mm3 nt" // block[i] < 0 ? -1 : 0
  372. "pxor %%mm2, %%mm0 nt"
  373. "pxor %%mm3, %%mm1 nt"
  374. "psubw %%mm2, %%mm0 nt" // abs(block[i])
  375. "psubw %%mm3, %%mm1 nt" // abs(block[i])
  376. "pmullw %%mm4, %%mm0 nt" // abs(block[i])*q
  377. "pmullw %%mm5, %%mm1 nt" // abs(block[i])*q
  378. "pxor %%mm4, %%mm4 nt"
  379. "pxor %%mm5, %%mm5 nt" // FIXME slow
  380. "pcmpeqw (%0, %%"REG_a"), %%mm4 nt" // block[i] == 0 ? -1 : 0
  381. "pcmpeqw 8(%0, %%"REG_a"), %%mm5nt" // block[i] == 0 ? -1 : 0
  382. "psraw $3, %%mm0 nt"
  383. "psraw $3, %%mm1 nt"
  384. "pxor %%mm2, %%mm0 nt"
  385. "pxor %%mm3, %%mm1 nt"
  386. "psubw %%mm2, %%mm0 nt"
  387. "psubw %%mm3, %%mm1 nt"
  388. "pandn %%mm0, %%mm4 nt"
  389. "pandn %%mm1, %%mm5 nt"
  390. "movq %%mm4, (%0, %%"REG_a") nt"
  391. "movq %%mm5, 8(%0, %%"REG_a") nt"
  393. "add $16, %%"REG_a" nt"
  394. "jng 1b nt"
  395. ::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
  396. : "%"REG_a, "memory"
  397. );    
  398.     block[0]= block0;
  399.         //Note, we dont do mismatch control for intra as errors cannot accumulate
  400. }
  402. static void dct_unquantize_mpeg2_inter_mmx(MpegEncContext *s,
  403.                                      DCTELEM *block, int n, int qscale)
  404. {
  405.     long nCoeffs;
  406.     const uint16_t *quant_matrix;
  407.     
  408.     assert(s->block_last_index[n]>=0);
  410.     if(s->alternate_scan) nCoeffs= 63; //FIXME
  411.     else nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
  413.         quant_matrix = s->inter_matrix;
  414. asm volatile(
  415. "pcmpeqw %%mm7, %%mm7 nt"
  416.                 "psrlq $48, %%mm7 nt"
  417. "movd %2, %%mm6 nt"
  418. "packssdw %%mm6, %%mm6 nt"
  419. "packssdw %%mm6, %%mm6 nt"
  420. "mov %3, %%"REG_a" nt"
  421. ".balign 16nt"
  422. "1: nt"
  423. "movq (%0, %%"REG_a"), %%mm0 nt"
  424. "movq 8(%0, %%"REG_a"), %%mm1 nt"
  425. "movq (%1, %%"REG_a"), %%mm4 nt"
  426. "movq 8(%1, %%"REG_a"), %%mm5 nt"
  427. "pmullw %%mm6, %%mm4 nt" // q=qscale*quant_matrix[i]
  428. "pmullw %%mm6, %%mm5 nt" // q=qscale*quant_matrix[i]
  429. "pxor %%mm2, %%mm2 nt"
  430. "pxor %%mm3, %%mm3 nt"
  431. "pcmpgtw %%mm0, %%mm2 nt" // block[i] < 0 ? -1 : 0
  432. "pcmpgtw %%mm1, %%mm3 nt" // block[i] < 0 ? -1 : 0
  433. "pxor %%mm2, %%mm0 nt"
  434. "pxor %%mm3, %%mm1 nt"
  435. "psubw %%mm2, %%mm0 nt" // abs(block[i])
  436. "psubw %%mm3, %%mm1 nt" // abs(block[i])
  437. "paddw %%mm0, %%mm0 nt" // abs(block[i])*2
  438. "paddw %%mm1, %%mm1 nt" // abs(block[i])*2
  439. "pmullw %%mm4, %%mm0 nt" // abs(block[i])*2*q
  440. "pmullw %%mm5, %%mm1 nt" // abs(block[i])*2*q
  441. "paddw %%mm4, %%mm0 nt" // (abs(block[i])*2 + 1)*q
  442. "paddw %%mm5, %%mm1 nt" // (abs(block[i])*2 + 1)*q
  443. "pxor %%mm4, %%mm4 nt"
  444. "pxor %%mm5, %%mm5 nt" // FIXME slow
  445. "pcmpeqw (%0, %%"REG_a"), %%mm4 nt" // block[i] == 0 ? -1 : 0
  446. "pcmpeqw 8(%0, %%"REG_a"), %%mm5nt" // block[i] == 0 ? -1 : 0
  447. "psrlw $4, %%mm0 nt"
  448. "psrlw $4, %%mm1 nt"
  449. "pxor %%mm2, %%mm0 nt"
  450. "pxor %%mm3, %%mm1 nt"
  451. "psubw %%mm2, %%mm0 nt"
  452. "psubw %%mm3, %%mm1 nt"
  453. "pandn %%mm0, %%mm4 nt"
  454. "pandn %%mm1, %%mm5 nt"
  455.                 "pxor %%mm4, %%mm7 nt"
  456.                 "pxor %%mm5, %%mm7 nt"
  457. "movq %%mm4, (%0, %%"REG_a") nt"
  458. "movq %%mm5, 8(%0, %%"REG_a") nt"
  460. "add $16, %%"REG_a" nt"
  461. "jng 1b nt"
  462.                 "movd 124(%0, %3), %%mm0 nt"
  463.                 "movq %%mm7, %%mm6 nt"
  464.                 "psrlq $32, %%mm7 nt"
  465.                 "pxor %%mm6, %%mm7 nt"
  466.                 "movq %%mm7, %%mm6 nt"
  467.                 "psrlq $16, %%mm7 nt"
  468.                 "pxor %%mm6, %%mm7 nt"
  469.                 "pslld $31, %%mm7 nt"
  470.                 "psrlq $15, %%mm7 nt"
  471.                 "pxor %%mm7, %%mm0 nt"
  472.                 "movd %%mm0, 124(%0, %3) nt"
  473.                 
  474. ::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "r" (-2*nCoeffs)
  475. : "%"REG_a, "memory"
  476. );
  477. }
  479. /* draw the edges of width 'w' of an image of size width, height 
  480.    this mmx version can only handle w==8 || w==16 */
  481. static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
  482. {
  483.     uint8_t *ptr, *last_line;
  484.     int i;
  486.     last_line = buf + (height - 1) * wrap;
  487.     /* left and right */
  488.     ptr = buf;
  489.     if(w==8)
  490.     {
  491. asm volatile(
  492. "1: nt"
  493. "movd (%0), %%mm0 nt"
  494. "punpcklbw %%mm0, %%mm0 nt" 
  495. "punpcklwd %%mm0, %%mm0 nt"
  496. "punpckldq %%mm0, %%mm0 nt"
  497. "movq %%mm0, -8(%0) nt"
  498. "movq -8(%0, %2), %%mm1 nt"
  499. "punpckhbw %%mm1, %%mm1 nt"
  500. "punpckhwd %%mm1, %%mm1 nt"
  501. "punpckhdq %%mm1, %%mm1 nt"
  502. "movq %%mm1, (%0, %2) nt"
  503. "add %1, %0 nt"
  504. "cmp %3, %0 nt"
  505. " jb 1b nt"
  506. : "+r" (ptr)
  507. : "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
  508. );
  509.     }
  510.     else
  511.     {
  512. asm volatile(
  513. "1: nt"
  514. "movd (%0), %%mm0 nt"
  515. "punpcklbw %%mm0, %%mm0 nt" 
  516. "punpcklwd %%mm0, %%mm0 nt"
  517. "punpckldq %%mm0, %%mm0 nt"
  518. "movq %%mm0, -8(%0) nt"
  519. "movq %%mm0, -16(%0) nt"
  520. "movq -8(%0, %2), %%mm1 nt"
  521. "punpckhbw %%mm1, %%mm1 nt"
  522. "punpckhwd %%mm1, %%mm1 nt"
  523. "punpckhdq %%mm1, %%mm1 nt"
  524. "movq %%mm1, (%0, %2) nt"
  525. "movq %%mm1, 8(%0, %2) nt"
  526. "add %1, %0 nt"
  527. "cmp %3, %0 nt"
  528. " jb 1b nt"
  529. : "+r" (ptr)
  530. : "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
  531. );
  532.     }
  533.     
  534.     for(i=0;i<w;i+=4) {
  535.         /* top and bottom (and hopefully also the corners) */
  536. ptr= buf - (i + 1) * wrap - w;
  537. asm volatile(
  538. "1: nt"
  539. "movq (%1, %0), %%mm0 nt"
  540. "movq %%mm0, (%0) nt"
  541. "movq %%mm0, (%0, %2) nt"
  542. "movq %%mm0, (%0, %2, 2) nt"
  543. "movq %%mm0, (%0, %3) nt"
  544. "add $8, %0 nt"
  545. "cmp %4, %0 nt"
  546. " jb 1b nt"
  547. : "+r" (ptr)
  548. : "r" ((long)buf - (long)ptr - w), "r" ((long)-wrap), "r" ((long)-wrap*3), "r" (ptr+width+2*w)
  549. );
  550. ptr= last_line + (i + 1) * wrap - w;
  551. asm volatile(
  552. "1: nt"
  553. "movq (%1, %0), %%mm0 nt"
  554. "movq %%mm0, (%0) nt"
  555. "movq %%mm0, (%0, %2) nt"
  556. "movq %%mm0, (%0, %2, 2) nt"
  557. "movq %%mm0, (%0, %3) nt"
  558. "add $8, %0 nt"
  559. "cmp %4, %0 nt"
  560. " jb 1b nt"
  561. : "+r" (ptr)
  562. : "r" ((long)last_line - (long)ptr - w), "r" ((long)wrap), "r" ((long)wrap*3), "r" (ptr+width+2*w)
  563. );
  564.     }
  565. }
  567. static void  denoise_dct_mmx(MpegEncContext *s, DCTELEM *block){
  568.     const int intra= s->mb_intra;
  569.     int *sum= s->dct_error_sum[intra];
  570.     uint16_t *offset= s->dct_offset[intra];
  572.     s->dct_count[intra]++;
  574.     asm volatile(
  575.         "pxor %%mm7, %%mm7 nt"
  576.         "1: nt"
  577.         "pxor %%mm0, %%mm0 nt"
  578.         "pxor %%mm1, %%mm1 nt"
  579.         "movq (%0), %%mm2 nt"
  580.         "movq 8(%0), %%mm3 nt"
  581.         "pcmpgtw %%mm2, %%mm0 nt"
  582.         "pcmpgtw %%mm3, %%mm1 nt"
  583.         "pxor %%mm0, %%mm2 nt"
  584.         "pxor %%mm1, %%mm3 nt"
  585.         "psubw %%mm0, %%mm2 nt"
  586.         "psubw %%mm1, %%mm3 nt"
  587.         "movq %%mm2, %%mm4 nt"
  588.         "movq %%mm3, %%mm5 nt"
  589.         "psubusw (%2), %%mm2 nt"
  590.         "psubusw 8(%2), %%mm3 nt"
  591.         "pxor %%mm0, %%mm2 nt"
  592.         "pxor %%mm1, %%mm3 nt"
  593.         "psubw %%mm0, %%mm2 nt"
  594.         "psubw %%mm1, %%mm3 nt"
  595.         "movq %%mm2, (%0) nt"
  596.         "movq %%mm3, 8(%0) nt"
  597.         "movq %%mm4, %%mm2 nt"
  598.         "movq %%mm5, %%mm3 nt"
  599.         "punpcklwd %%mm7, %%mm4 nt"
  600.         "punpckhwd %%mm7, %%mm2 nt"
  601.         "punpcklwd %%mm7, %%mm5 nt"
  602.         "punpckhwd %%mm7, %%mm3 nt"
  603.         "paddd (%1), %%mm4 nt"
  604.         "paddd 8(%1), %%mm2 nt"
  605.         "paddd 16(%1), %%mm5 nt"
  606.         "paddd 24(%1), %%mm3 nt"
  607.         "movq %%mm4, (%1) nt"
  608.         "movq %%mm2, 8(%1) nt"
  609.         "movq %%mm5, 16(%1) nt"
  610.         "movq %%mm3, 24(%1) nt"
  611.         "add $16, %0 nt"
  612.         "add $32, %1 nt"
  613.         "add $16, %2 nt"
  614.         "cmp %3, %0 nt"
  615.             " jb 1b nt"
  616.         : "+r" (block), "+r" (sum), "+r" (offset)
  617.         : "r"(block+64)
  618.     );
  619. }
  621. static void  denoise_dct_sse2(MpegEncContext *s, DCTELEM *block){
  622.     const int intra= s->mb_intra;
  623.     int *sum= s->dct_error_sum[intra];
  624.     uint16_t *offset= s->dct_offset[intra];
  626.     s->dct_count[intra]++;
  628.     asm volatile(
  629.         "pxor %%xmm7, %%xmm7 nt"
  630.         "1: nt"
  631.         "pxor %%xmm0, %%xmm0 nt"
  632.         "pxor %%xmm1, %%xmm1 nt"
  633.         "movdqa (%0), %%xmm2 nt"
  634.         "movdqa 16(%0), %%xmm3 nt"
  635.         "pcmpgtw %%xmm2, %%xmm0 nt"
  636.         "pcmpgtw %%xmm3, %%xmm1 nt"
  637.         "pxor %%xmm0, %%xmm2 nt"
  638.         "pxor %%xmm1, %%xmm3 nt"
  639.         "psubw %%xmm0, %%xmm2 nt"
  640.         "psubw %%xmm1, %%xmm3 nt"
  641.         "movdqa %%xmm2, %%xmm4 nt"
  642.         "movdqa %%xmm3, %%xmm5 nt"
  643.         "psubusw (%2), %%xmm2 nt"
  644.         "psubusw 16(%2), %%xmm3 nt"
  645.         "pxor %%xmm0, %%xmm2 nt"
  646.         "pxor %%xmm1, %%xmm3 nt"
  647.         "psubw %%xmm0, %%xmm2 nt"
  648.         "psubw %%xmm1, %%xmm3 nt"
  649.         "movdqa %%xmm2, (%0) nt"
  650.         "movdqa %%xmm3, 16(%0) nt"
  651.         "movdqa %%xmm4, %%xmm6 nt"
  652.         "movdqa %%xmm5, %%xmm0 nt"
  653.         "punpcklwd %%xmm7, %%xmm4 nt"
  654.         "punpckhwd %%xmm7, %%xmm6 nt"
  655.         "punpcklwd %%xmm7, %%xmm5 nt"
  656.         "punpckhwd %%xmm7, %%xmm0 nt"
  657.         "paddd (%1), %%xmm4 nt"
  658.         "paddd 16(%1), %%xmm6 nt"
  659.         "paddd 32(%1), %%xmm5 nt"
  660.         "paddd 48(%1), %%xmm0 nt"
  661.         "movdqa %%xmm4, (%1) nt"
  662.         "movdqa %%xmm6, 16(%1) nt"
  663.         "movdqa %%xmm5, 32(%1) nt"
  664.         "movdqa %%xmm0, 48(%1) nt"
  665.         "add $32, %0 nt"
  666.         "add $64, %1 nt"
  667.         "add $32, %2 nt"
  668.         "cmp %3, %0 nt"
  669.             " jb 1b nt"
  670.         : "+r" (block), "+r" (sum), "+r" (offset)
  671.         : "r"(block+64)
  672.     );
  673. }
  675. #undef HAVE_MMX2
  676. #define RENAME(a) a ## _MMX
  677. #define RENAMEl(a) a ## _mmx
  678. #include "mpegvideo_mmx_template.c"
  680. #define HAVE_MMX2
  681. #undef RENAME
  682. #undef RENAMEl
  683. #define RENAME(a) a ## _MMX2
  684. #define RENAMEl(a) a ## _mmx2
  685. #include "mpegvideo_mmx_template.c"
  687. #undef RENAME
  688. #undef RENAMEl
  689. #define RENAME(a) a ## _SSE2
  690. #define RENAMEl(a) a ## _sse2
  691. #include "mpegvideo_mmx_template.c"
  693. void MPV_common_init_mmx(MpegEncContext *s)
  694. {
  695.     if (mm_flags & MM_MMX) {
  696.         const int dct_algo = s->avctx->dct_algo;
  697.         
  698.         s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_mmx;
  699.         s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_mmx;
  700.         s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_mmx;
  701.         s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_mmx;
  702.         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_mmx;
  703.         s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_mmx;
  705.         draw_edges = draw_edges_mmx;
  706.         
  707.         if (mm_flags & MM_SSE2) {
  708.     s->denoise_dct= denoise_dct_sse2;
  709. } else {
  710.          s->denoise_dct= denoise_dct_mmx;
  711. }
  713.         if(dct_algo==FF_DCT_AUTO || dct_algo==FF_DCT_MMX){
  714.             if(mm_flags & MM_SSE2){
  715.                 s->dct_quantize= dct_quantize_SSE2;
  716.             } else if(mm_flags & MM_MMXEXT){
  717.                 s->dct_quantize= dct_quantize_MMX2;
  718.             } else {
  719.                 s->dct_quantize= dct_quantize_MMX;
  720.             }
  721.         }
  722.     }
  723. }