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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
dsputil.c
资源名称：ffh264libxxxx.rar　[点击查看]
上传用户：shlianrong
上传日期：2022-07-08
资源大小：309k
文件大小：174k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

dsputil.c：源码内容
  1.     }
  2. }
  4. static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  5.     const int w=8;
  6.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  7.     int i;
  8.     for(i=0; i<w; i++)
  9.     {
  10.         const int srcB= src[-2*srcStride];
  11.         const int srcA= src[-1*srcStride];
  12.         const int src0= src[0 *srcStride];
  13.         const int src1= src[1 *srcStride];
  14.         const int src2= src[2 *srcStride];
  15.         const int src3= src[3 *srcStride];
  16.         const int src4= src[4 *srcStride];
  17.         const int src5= src[5 *srcStride];
  18.         const int src6= src[6 *srcStride];
  19.         const int src7= src[7 *srcStride];
  20.         const int src8= src[8 *srcStride];
  21.         const int src9= src[9 *srcStride];
  22.         const int src10=src[10*srcStride];
  23.         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));
  24.         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));
  25.         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));
  26.         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));
  27.         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));
  28.         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));
  29.         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));
  30.         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));
  31.         dst++;
  32.         src++;
  33.     }
  34. }
  36. static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){
  37.     const int h=8;
  38.     const int w=8;
  39.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  40.     int i;
  41.     src -= 2*srcStride;
  42.     for(i=0; i<h+5; i++)
  43.     {
  44.         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);
  45.         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);
  46.         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);
  47.         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);
  48.         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);
  49.         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);
  50.         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);
  51.         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);
  52.         tmp+=tmpStride;
  53.         src+=srcStride;
  54.     }
  55.     tmp -= tmpStride*(h+5-2);
  56.     for(i=0; i<w; i++)
  57.     {
  58.         const int tmpB= tmp[-2*tmpStride];
  59.         const int tmpA= tmp[-1*tmpStride];
  60.         const int tmp0= tmp[0 *tmpStride];
  61.         const int tmp1= tmp[1 *tmpStride];
  62.         const int tmp2= tmp[2 *tmpStride];
  63.         const int tmp3= tmp[3 *tmpStride];
  64.         const int tmp4= tmp[4 *tmpStride];
  65.         const int tmp5= tmp[5 *tmpStride];
  66.         const int tmp6= tmp[6 *tmpStride];
  67.         const int tmp7= tmp[7 *tmpStride];
  68.         const int tmp8= tmp[8 *tmpStride];
  69.         const int tmp9= tmp[9 *tmpStride];
  70.         const int tmp10=tmp[10*tmpStride];
  71.         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));
  72.         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));
  73.         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));
  74.         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));
  75.         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));
  76.         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));
  77.         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));
  78.         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));
  79.         dst++;
  80.         tmp++;
  81.     }
  82. }
  84. static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  85.     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);
  86.     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);
  87.     src += 8*srcStride;
  88.     dst += 8*dstStride;
  89.     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);
  90.     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);
  91. }
  93. static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  94.     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);
  95.     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);
  96.     src += 8*srcStride;
  97.     dst += 8*dstStride;
  98.     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);
  99.     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);
  100. }
  102. static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){
  103.     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);
  104.     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);
  105.     src += 8*srcStride;
  106.     dst += 8*dstStride;
  107.     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);
  108.     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);
  109. }
  111. #define H264_MC(OPNAME, SIZE) 
  112. static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){
  113.     OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);
  114. }
  116. static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){
  117.     uint8_t half[SIZE*SIZE];
  118.     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);
  119.     OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);
  120. }
  122. static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){
  123.     OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);
  124. }
  126. static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){
  127.     uint8_t half[SIZE*SIZE];
  128.     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);
  129.     OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);
  130. }
  132. static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){
  133.     uint8_t full[SIZE*(SIZE+5)];
  134.     uint8_t * const full_mid= full + SIZE*2;
  135.     uint8_t half[SIZE*SIZE];
  136.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  137.     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);
  138.     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);
  139. }
  141. static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){
  142.     uint8_t full[SIZE*(SIZE+5)];
  143.     uint8_t * const full_mid= full + SIZE*2;
  144.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  145.     OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);
  146. }
  148. static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){
  149.     uint8_t full[SIZE*(SIZE+5)];
  150.     uint8_t * const full_mid= full + SIZE*2;
  151.     uint8_t half[SIZE*SIZE];
  152.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  153.     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);
  154.     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);
  155. }
  157. static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){
  158.     uint8_t full[SIZE*(SIZE+5)];
  159.     uint8_t * const full_mid= full + SIZE*2;
  160.     uint8_t halfH[SIZE*SIZE];
  161.     uint8_t halfV[SIZE*SIZE];
  162.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  163.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  164.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  165.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  166. }
  168. static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){
  169.     uint8_t full[SIZE*(SIZE+5)];
  170.     uint8_t * const full_mid= full + SIZE*2;
  171.     uint8_t halfH[SIZE*SIZE];
  172.     uint8_t halfV[SIZE*SIZE];
  173.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  174.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  175.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  176.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  177. }
  179. static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){
  180.     uint8_t full[SIZE*(SIZE+5)];
  181.     uint8_t * const full_mid= full + SIZE*2;
  182.     uint8_t halfH[SIZE*SIZE];
  183.     uint8_t halfV[SIZE*SIZE];
  184.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  185.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  186.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  187.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  188. }
  190. static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){
  191.     uint8_t full[SIZE*(SIZE+5)];
  192.     uint8_t * const full_mid= full + SIZE*2;
  193.     uint8_t halfH[SIZE*SIZE];
  194.     uint8_t halfV[SIZE*SIZE];
  195.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  196.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  197.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  198.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  199. }
  201. static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){
  202.     int16_t tmp[SIZE*(SIZE+5)];
  203.     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);
  204. }
  206. static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){
  207.     int16_t tmp[SIZE*(SIZE+5)];
  208.     uint8_t halfH[SIZE*SIZE];
  209.     uint8_t halfHV[SIZE*SIZE];
  210.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  211.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  212.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);
  213. }
  215. static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){
  216.     int16_t tmp[SIZE*(SIZE+5)];
  217.     uint8_t halfH[SIZE*SIZE];
  218.     uint8_t halfHV[SIZE*SIZE];
  219.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  220.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  221.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);
  222. }
  224. static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){
  225.     uint8_t full[SIZE*(SIZE+5)];
  226.     uint8_t * const full_mid= full + SIZE*2;
  227.     int16_t tmp[SIZE*(SIZE+5)];
  228.     uint8_t halfV[SIZE*SIZE];
  229.     uint8_t halfHV[SIZE*SIZE];
  230.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  231.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  232.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  233.     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);
  234. }
  236. static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){
  237.     uint8_t full[SIZE*(SIZE+5)];
  238.     uint8_t * const full_mid= full + SIZE*2;
  239.     int16_t tmp[SIZE*(SIZE+5)];
  240.     uint8_t halfV[SIZE*SIZE];
  241.     uint8_t halfHV[SIZE*SIZE];
  242.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  243.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  244.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  245.     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);
  246. }
  248. #define op_avg(a, b)   a = (((a)+cm[((b) + 16)>>5]+1)>>1)
  249. #define op2_avg(a, b)  a = (((a)+cm[((b) + 512)>>10]+1)>>1)
  250. #define op_put(a, b)   a = cm[((b) + 16)>>5]
  251. #define op2_put(a, b)  a = cm[((b) + 512)>>10]
  253. H264_LOWPASS(avg_       , op_avg, op2_avg)
  254. H264_LOWPASS(put_       , op_put, op2_put)
  256. static av_unused void put_h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride)
  257. {
  258.     const int h=2;
  259.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  260.     int i;
  261.     for(i=0; i<h; i++)
  262.     {
  263.         /*OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));*/
  264. dst[0] = (((dst[0])+cm[(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3])) + 16)>>5]+1)>>1);
  265.         /*OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));*/
  266. dst[1] = (((dst[1])+cm[(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4])) + 16)>>5]+1)>>1);
  267.         dst+=dstStride;
  268.         src+=srcStride;
  269.     }
  270. }
  272. static av_unused void put_h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride)
  273. {
  274.     const int w=2;
  275.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  276.     int i;
  277.     for(i=0; i<w; i++)
  278.     {
  279.         const int srcB= src[-2*srcStride];
  280.         const int srcA= src[-1*srcStride];
  281.         const int src0= src[0 *srcStride];
  282.         const int src1= src[1 *srcStride];
  283.         const int src2= src[2 *srcStride];
  284.         const int src3= src[3 *srcStride];
  285.         const int src4= src[4 *srcStride];
  286.         /*OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));*/
  287. dst[0*dstStride] = (((dst[0*dstStride])+cm[(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3)) + 16)>>5]+1)>>1);
  288.         /*OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));*/
  289. dst[1*dstStride] = (((dst[1*dstStride])+cm[(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4)) + 16)>>5]+1)>>1);
  290.         dst++;
  291.         src++;
  292.     }
  293. }
  295. static av_unused void put_h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride)
  296. {
  297.     const int h=2;
  298.     const int w=2;
  299.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  300.     int i;
  301.     src -= 2*srcStride;
  302.     for(i=0; i<h+5; i++)
  303.     {
  304.         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);
  305.         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);
  306.         tmp+=tmpStride;
  307.         src+=srcStride;
  308.     }
  309.     tmp -= tmpStride*(h+5-2);
  310.     for(i=0; i<w; i++)
  311.     {
  312.         const int tmpB= tmp[-2*tmpStride];
  313.         const int tmpA= tmp[-1*tmpStride];
  314.         const int tmp0= tmp[0 *tmpStride];
  315.         const int tmp1= tmp[1 *tmpStride];
  316.         const int tmp2= tmp[2 *tmpStride];
  317.         const int tmp3= tmp[3 *tmpStride];
  318.         const int tmp4= tmp[4 *tmpStride];
  319.         /*OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));*/
  320. dst[0*dstStride] = (((dst[0*dstStride])+cm[(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3)) + 512)>>10]+1)>>1);
  321.         /*OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));*/
  322. dst[1*dstStride] = (((dst[1*dstStride])+cm[(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4)) + 512)>>10]+1)>>1);
  323.         dst++;
  324.         tmp++;
  325.     }
  326. }
  328. H264_MC(put_, 2)
  329. H264_MC(put_, 4)
  330. H264_MC(put_, 8)
  331. H264_MC(put_, 16)
  332. H264_MC(avg_, 4)
  333. H264_MC(avg_, 8)
  334. H264_MC(avg_, 16)
  336. #undef op_avg
  337. #undef op_put
  338. #undef op2_avg
  339. #undef op2_put
  340. #endif
  342. #define op_scale1(x)  block[x] = av_clip_uint8( (block[x]*weight + offset) >> log2_denom )
  343. #define op_scale2(x)  dst[x] = av_clip_uint8( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
  344. #define H264_WEIGHT(W,H) 
  345. static void weight_h264_pixels ## W ## x ## H ## _c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ 
  346.     int y; 
  347.     offset <<= log2_denom; 
  348.     if(log2_denom) offset += 1<<(log2_denom-1); 
  349.     for(y=0; y<H; y++, block += stride){ 
  350.         op_scale1(0); 
  351.         op_scale1(1); 
  352.         if(W==2) continue; 
  353.         op_scale1(2); 
  354.         op_scale1(3); 
  355.         if(W==4) continue; 
  356.         op_scale1(4); 
  357.         op_scale1(5); 
  358.         op_scale1(6); 
  359.         op_scale1(7); 
  360.         if(W==8) continue; 
  361.         op_scale1(8); 
  362.         op_scale1(9); 
  363.         op_scale1(10); 
  364.         op_scale1(11); 
  365.         op_scale1(12); 
  366.         op_scale1(13); 
  367.         op_scale1(14); 
  368.         op_scale1(15); 
  369.     } 
  370. } 
  371. static void biweight_h264_pixels ## W ## x ## H ## _c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ 
  372.     int y; 
  373.     offset = ((offset + 1) | 1) << log2_denom; 
  374.     for(y=0; y<H; y++, dst += stride, src += stride){ 
  375.         op_scale2(0); 
  376.         op_scale2(1); 
  377.         if(W==2) continue; 
  378.         op_scale2(2); 
  379.         op_scale2(3); 
  380.         if(W==4) continue; 
  381.         op_scale2(4); 
  382.         op_scale2(5); 
  383.         op_scale2(6); 
  384.         op_scale2(7); 
  385.         if(W==8) continue; 
  386.         op_scale2(8); 
  387.         op_scale2(9); 
  388.         op_scale2(10); 
  389.         op_scale2(11); 
  390.         op_scale2(12); 
  391.         op_scale2(13); 
  392.         op_scale2(14); 
  393.         op_scale2(15); 
  394.     } 
  395. }
  397. H264_WEIGHT(16,16)
  398. H264_WEIGHT(16,8)
  399. H264_WEIGHT(8,16)
  400. H264_WEIGHT(8,8)
  401. H264_WEIGHT(8,4)
  402. H264_WEIGHT(4,8)
  403. H264_WEIGHT(4,4)
  404. H264_WEIGHT(4,2)
  405. H264_WEIGHT(2,4)
  406. H264_WEIGHT(2,2)
  408. #undef op_scale1
  409. #undef op_scale2
  410. #undef H264_WEIGHT
  412. static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
  413.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  414.     int i;
  416.     for(i=0; i<h; i++){
  417.         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
  418.         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
  419.         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
  420.         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
  421.         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
  422.         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
  423.         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
  424.         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
  425.         dst+=dstStride;
  426.         src+=srcStride;
  427.     }
  428. }
  430. #ifdef CONFIG_CAVS_DECODER
  431. /* AVS specific */
  432. void ff_cavsdsp_init(DSPContext* c, AVCodecContext *avctx);
  434. void ff_put_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
  435.     put_pixels8_c(dst, src, stride, 8);
  436. }
  437. void ff_avg_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
  438.     avg_pixels8_c(dst, src, stride, 8);
  439. }
  440. void ff_put_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
  441.     put_pixels16_c(dst, src, stride, 16);
  442. }
  443. void ff_avg_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
  444.     avg_pixels16_c(dst, src, stride, 16);
  445. }
  446. #endif /* CONFIG_CAVS_DECODER */
  448. #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
  449. /* VC-1 specific */
  450. void ff_vc1dsp_init(DSPContext* c, AVCodecContext *avctx);
  452. void ff_put_vc1_mspel_mc00_c(uint8_t *dst, uint8_t *src, int stride, int rnd) {
  453.     put_pixels8_c(dst, src, stride, 8);
  454. }
  455. #endif /* CONFIG_VC1_DECODER||CONFIG_WMV3_DECODER */
  457. void ff_intrax8dsp_init(DSPContext* c, AVCodecContext *avctx);
  459. /* H264 specific */
  460. void ff_h264dspenc_init(DSPContext* c, AVCodecContext *avctx);
  462. #if defined(CONFIG_RV30_DECODER)
  463. void ff_rv30dsp_init(DSPContext* c, AVCodecContext *avctx);
  464. #endif /* CONFIG_RV30_DECODER */
  466. #if defined(CONFIG_RV40_DECODER)
  467. static void put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  468.     put_pixels16_xy2_c(dst, src, stride, 16);
  469. }
  470. static void avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  471.     avg_pixels16_xy2_c(dst, src, stride, 16);
  472. }
  473. static void put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  474.     put_pixels8_xy2_c(dst, src, stride, 8);
  475. }
  476. static void avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  477.     avg_pixels8_xy2_c(dst, src, stride, 8);
  478. }
  480. void ff_rv40dsp_init(DSPContext* c, AVCodecContext *avctx);
  481. #endif /* CONFIG_RV40_DECODER */
  483. static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
  484.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  485.     int i;
  487.     for(i=0; i<w; i++){
  488.         const int src_1= src[ -srcStride];
  489.         const int src0 = src[0          ];
  490.         const int src1 = src[  srcStride];
  491.         const int src2 = src[2*srcStride];
  492.         const int src3 = src[3*srcStride];
  493.         const int src4 = src[4*srcStride];
  494.         const int src5 = src[5*srcStride];
  495.         const int src6 = src[6*srcStride];
  496.         const int src7 = src[7*srcStride];
  497.         const int src8 = src[8*srcStride];
  498.         const int src9 = src[9*srcStride];
  499.         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
  500.         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
  501.         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
  502.         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
  503.         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
  504.         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
  505.         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
  506.         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
  507.         src++;
  508.         dst++;
  509.     }
  510. }
  512. static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
  513.     put_pixels8_c(dst, src, stride, 8);
  514. }
  516. static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
  517.     uint8_t half[64];
  518.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
  519.     put_pixels8_l2(dst, src, half, stride, stride, 8, 8);
  520. }
  522. static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
  523.     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
  524. }
  526. static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
  527.     uint8_t half[64];
  528.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
  529.     put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
  530. }
  532. static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
  533.     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
  534. }
  536. static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
  537.     uint8_t halfH[88];
  538.     uint8_t halfV[64];
  539.     uint8_t halfHV[64];
  540.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  541.     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
  542.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
  543.     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  544. }
  545. static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
  546.     uint8_t halfH[88];
  547.     uint8_t halfV[64];
  548.     uint8_t halfHV[64];
  549.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  550.     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
  551.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
  552.     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  553. }
  554. static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
  555.     uint8_t halfH[88];
  556.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  557.     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
  558. }
  559. /*
  560. static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
  561.     if(ENABLE_ANY_H263) {
  562.     int x;
  563.     const int strength= ff_h263_loop_filter_strength[qscale];
  565.     for(x=0; x<8; x++){
  566.         int d1, d2, ad1;
  567.         int p0= src[x-2*stride];
  568.         int p1= src[x-1*stride];
  569.         int p2= src[x+0*stride];
  570.         int p3= src[x+1*stride];
  571.         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
  573.         if     (d<-2*strength) d1= 0;
  574.         else if(d<-  strength) d1=-2*strength - d;
  575.         else if(d<   strength) d1= d;
  576.         else if(d< 2*strength) d1= 2*strength - d;
  577.         else                   d1= 0;
  579.         p1 += d1;
  580.         p2 -= d1;
  581.         if(p1&256) p1= ~(p1>>31);
  582.         if(p2&256) p2= ~(p2>>31);
  584.         src[x-1*stride] = p1;
  585.         src[x+0*stride] = p2;
  587.         ad1= FFABS(d1)>>1;
  589.         d2= av_clip((p0-p3)/4, -ad1, ad1);
  591.         src[x-2*stride] = p0 - d2;
  592.         src[x+  stride] = p3 + d2;
  593.     }
  594.     }
  595. }
  597. static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
  598.     if(ENABLE_ANY_H263) {
  599.     int y;
  600.     const int strength= ff_h263_loop_filter_strength[qscale];
  602.     for(y=0; y<8; y++){
  603.         int d1, d2, ad1;
  604.         int p0= src[y*stride-2];
  605.         int p1= src[y*stride-1];
  606.         int p2= src[y*stride+0];
  607.         int p3= src[y*stride+1];
  608.         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
  610.         if     (d<-2*strength) d1= 0;
  611.         else if(d<-  strength) d1=-2*strength - d;
  612.         else if(d<   strength) d1= d;
  613.         else if(d< 2*strength) d1= 2*strength - d;
  614.         else                   d1= 0;
  616.         p1 += d1;
  617.         p2 -= d1;
  618.         if(p1&256) p1= ~(p1>>31);
  619.         if(p2&256) p2= ~(p2>>31);
  621.         src[y*stride-1] = p1;
  622.         src[y*stride+0] = p2;
  624.         ad1= FFABS(d1)>>1;
  626.         d2= av_clip((p0-p3)/4, -ad1, ad1);
  628.         src[y*stride-2] = p0 - d2;
  629.         src[y*stride+1] = p3 + d2;
  630.     }
  631.     }
  632. }
  633. */
  634. static void h261_loop_filter_c(uint8_t *src, int stride){
  635.     int x,y,xy,yz;
  636.     int temp[64];
  638.     for(x=0; x<8; x++){
  639.         temp[x      ] = 4*src[x           ];
  640.         temp[x + 7*8] = 4*src[x + 7*stride];
  641.     }
  642.     for(y=1; y<7; y++){
  643.         for(x=0; x<8; x++){
  644.             xy = y * stride + x;
  645.             yz = y * 8 + x;
  646.             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
  647.         }
  648.     }
  650.     for(y=0; y<8; y++){
  651.         src[  y*stride] = (temp[  y*8] + 2)>>2;
  652.         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
  653.         for(x=1; x<7; x++){
  654.             xy = y * stride + x;
  655.             yz = y * 8 + x;
  656.             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
  657.         }
  658.     }
  659. }
  661. static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
  662. {
  663.     int i, d;
  664.     for( i = 0; i < 4; i++ ) {
  665.         if( tc0[i] < 0 ) {
  666.             pix += 4*ystride;
  667.             continue;
  668.         }
  669.         for( d = 0; d < 4; d++ ) {
  670.             const int p0 = pix[-1*xstride];
  671.             const int p1 = pix[-2*xstride];
  672.             const int p2 = pix[-3*xstride];
  673.             const int q0 = pix[0];
  674.             const int q1 = pix[1*xstride];
  675.             const int q2 = pix[2*xstride];
  677.             if( FFABS( p0 - q0 ) < alpha &&
  678.                 FFABS( p1 - p0 ) < beta &&
  679.                 FFABS( q1 - q0 ) < beta ) {
  681.                 int tc = tc0[i];
  682.                 int i_delta;
  684.                 if( FFABS( p2 - p0 ) < beta ) {
  685.                     pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
  686.                     tc++;
  687.                 }
  688.                 if( FFABS( q2 - q0 ) < beta ) {
  689.                     pix[   xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
  690.                     tc++;
  691.                 }
  693.                 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  694.                 pix[-xstride] = av_clip_uint8( p0 + i_delta );    /* p0' */
  695.                 pix[0]        = av_clip_uint8( q0 - i_delta );    /* q0' */
  696.             }
  697.             pix += ystride;
  698.         }
  699.     }
  700. }
  701. static void h264_v_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
  702. {
  703.     h264_loop_filter_luma_c(pix, stride, 1, alpha, beta, tc0);
  704. }
  705. static void h264_h_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
  706. {
  707.     h264_loop_filter_luma_c(pix, 1, stride, alpha, beta, tc0);
  708. }
  710. static inline void h264_loop_filter_luma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
  711. {
  712.     int d;
  713.     for( d = 0; d < 16; d++ ) {
  714.         const int p2 = pix[-3*xstride];
  715.         const int p1 = pix[-2*xstride];
  716.         const int p0 = pix[-1*xstride];
  718.         const int q0 = pix[ 0*xstride];
  719.         const int q1 = pix[ 1*xstride];
  720.         const int q2 = pix[ 2*xstride];
  722.         if( FFABS( p0 - q0 ) < alpha &&
  723.             FFABS( p1 - p0 ) < beta &&
  724.             FFABS( q1 - q0 ) < beta ) {
  726.             if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
  727.                 if( FFABS( p2 - p0 ) < beta)
  728.                 {
  729.                     const int p3 = pix[-4*xstride];
  730.                     /* p0', p1', p2' */
  731.                     pix[-1*xstride] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
  732.                     pix[-2*xstride] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
  733.                     pix[-3*xstride] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
  734.                 } else {
  735.                     /* p0' */
  736.                     pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  737.                 }
  738.                 if( FFABS( q2 - q0 ) < beta)
  739.                 {
  740.                     const int q3 = pix[3*xstride];
  741.                     /* q0', q1', q2' */
  742.                     pix[0*xstride] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
  743.                     pix[1*xstride] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
  744.                     pix[2*xstride] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
  745.                 } else {
  746.                     /* q0' */
  747.                     pix[0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  748.                 }
  749.             }else{
  750.                 /* p0', q0' */
  751.                 pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
  752.                 pix[ 0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
  753.             }
  754.         }
  755.         pix += ystride;
  756.     }
  757. }
  758. static void h264_v_loop_filter_luma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
  759. {
  760.     h264_loop_filter_luma_intra_c(pix, stride, 1, alpha, beta);
  761. }
  762. static void h264_h_loop_filter_luma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
  763. {
  764.     h264_loop_filter_luma_intra_c(pix, 1, stride, alpha, beta);
  765. }
  767. static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
  768. {
  769.     int i, d;
  770.     for( i = 0; i < 4; i++ ) {
  771.         const int tc = tc0[i];
  772.         if( tc <= 0 ) {
  773.             pix += 2*ystride;
  774.             continue;
  775.         }
  776.         for( d = 0; d < 2; d++ ) {
  777.             const int p0 = pix[-1*xstride];
  778.             const int p1 = pix[-2*xstride];
  779.             const int q0 = pix[0];
  780.             const int q1 = pix[1*xstride];
  782.             if( FFABS( p0 - q0 ) < alpha &&
  783.                 FFABS( p1 - p0 ) < beta &&
  784.                 FFABS( q1 - q0 ) < beta ) {
  786.                 int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
  788.                 pix[-xstride] = av_clip_uint8( p0 + delta );    /* p0' */
  789.                 pix[0]        = av_clip_uint8( q0 - delta );    /* q0' */
  790.             }
  791.             pix += ystride;
  792.         }
  793.     }
  794. }
  795. static void h264_v_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
  796. {
  797.     h264_loop_filter_chroma_c(pix, stride, 1, alpha, beta, tc0);
  798. }
  799. static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
  800. {
  801.     h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
  802. }
  804. static inline void h264_loop_filter_chroma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
  805. {
  806.     int d;
  807.     for( d = 0; d < 8; d++ ) {
  808.         const int p0 = pix[-1*xstride];
  809.         const int p1 = pix[-2*xstride];
  810.         const int q0 = pix[0];
  811.         const int q1 = pix[1*xstride];
  813.         if( FFABS( p0 - q0 ) < alpha &&
  814.             FFABS( p1 - p0 ) < beta &&
  815.             FFABS( q1 - q0 ) < beta ) {
  817.             pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
  818.             pix[0]        = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
  819.         }
  820.         pix += ystride;
  821.     }
  822. }
  823. static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
  824. {
  825.     h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);
  826. }
  827. static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
  828. {
  829.     h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
  830. }
  832. static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  833. {
  834.     int s, i;
  836.     s = 0;
  837.     for(i=0;i<h;i++) {
  838.         s += abs(pix1[0] - pix2[0]);
  839.         s += abs(pix1[1] - pix2[1]);
  840.         s += abs(pix1[2] - pix2[2]);
  841.         s += abs(pix1[3] - pix2[3]);
  842.         s += abs(pix1[4] - pix2[4]);
  843.         s += abs(pix1[5] - pix2[5]);
  844.         s += abs(pix1[6] - pix2[6]);
  845.         s += abs(pix1[7] - pix2[7]);
  846.         s += abs(pix1[8] - pix2[8]);
  847.         s += abs(pix1[9] - pix2[9]);
  848.         s += abs(pix1[10] - pix2[10]);
  849.         s += abs(pix1[11] - pix2[11]);
  850.         s += abs(pix1[12] - pix2[12]);
  851.         s += abs(pix1[13] - pix2[13]);
  852.         s += abs(pix1[14] - pix2[14]);
  853.         s += abs(pix1[15] - pix2[15]);
  854.         pix1 += line_size;
  855.         pix2 += line_size;
  856.     }
  857.     return s;
  858. }
  860. static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  861. {
  862.     int s, i;
  864.     s = 0;
  865.     for(i=0;i<h;i++) {
  866.         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
  867.         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
  868.         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
  869.         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
  870.         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
  871.         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
  872.         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
  873.         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
  874.         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
  875.         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
  876.         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
  877.         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
  878.         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
  879.         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
  880.         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
  881.         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
  882.         pix1 += line_size;
  883.         pix2 += line_size;
  884.     }
  885.     return s;
  886. }
  888. static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  889. {
  890.     int s, i;
  891.     uint8_t *pix3 = pix2 + line_size;
  893.     s = 0;
  894.     for(i=0;i<h;i++) {
  895.         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
  896.         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
  897.         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
  898.         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
  899.         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
  900.         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
  901.         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
  902.         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
  903.         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
  904.         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
  905.         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
  906.         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
  907.         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
  908.         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
  909.         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
  910.         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
  911.         pix1 += line_size;
  912.         pix2 += line_size;
  913.         pix3 += line_size;
  914.     }
  915.     return s;
  916. }
  918. static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  919. {
  920.     int s, i;
  921.     uint8_t *pix3 = pix2 + line_size;
  923.     s = 0;
  924.     for(i=0;i<h;i++) {
  925.         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
  926.         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
  927.         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
  928.         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
  929.         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
  930.         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
  931.         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
  932.         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
  933.         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
  934.         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
  935.         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
  936.         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
  937.         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
  938.         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
  939.         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
  940.         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
  941.         pix1 += line_size;
  942.         pix2 += line_size;
  943.         pix3 += line_size;
  944.     }
  945.     return s;
  946. }
  948. static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  949. {
  950.     int s, i;
  952.     s = 0;
  953.     for(i=0;i<h;i++) {
  954.         s += abs(pix1[0] - pix2[0]);
  955.         s += abs(pix1[1] - pix2[1]);
  956.         s += abs(pix1[2] - pix2[2]);
  957.         s += abs(pix1[3] - pix2[3]);
  958.         s += abs(pix1[4] - pix2[4]);
  959.         s += abs(pix1[5] - pix2[5]);
  960.         s += abs(pix1[6] - pix2[6]);
  961.         s += abs(pix1[7] - pix2[7]);
  962.         pix1 += line_size;
  963.         pix2 += line_size;
  964.     }
  965.     return s;
  966. }
  968. static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  969. {
  970.     int s, i;
  972.     s = 0;
  973.     for(i=0;i<h;i++) {
  974.         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
  975.         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
  976.         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
  977.         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
  978.         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
  979.         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
  980.         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
  981.         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
  982.         pix1 += line_size;
  983.         pix2 += line_size;
  984.     }
  985.     return s;
  986. }
  988. static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  989. {
  990.     int s, i;
  991.     uint8_t *pix3 = pix2 + line_size;
  993.     s = 0;
  994.     for(i=0;i<h;i++) {
  995.         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
  996.         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
  997.         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
  998.         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
  999.         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
  1000.         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
  1001.         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
  1002.         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
  1003.         pix1 += line_size;
  1004.         pix2 += line_size;
  1005.         pix3 += line_size;
  1006.     }
  1007.     return s;
  1008. }
  1010. static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  1011. {
  1012.     int s, i;
  1013.     uint8_t *pix3 = pix2 + line_size;
  1015.     s = 0;
  1016.     for(i=0;i<h;i++) {
  1017.         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
  1018.         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
  1019.         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
  1020.         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
  1021.         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
  1022.         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
  1023.         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
  1024.         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
  1025.         pix1 += line_size;
  1026.         pix2 += line_size;
  1027.         pix3 += line_size;
  1028.     }
  1029.     return s;
  1030. }
  1032. static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
  1033.     MpegEncContext *c = v;
  1034.     int score1=0;
  1035.     int score2=0;
  1036.     int x,y;
  1038.     for(y=0; y<h; y++){
  1039.         for(x=0; x<16; x++){
  1040.             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
  1041.         }
  1042.         if(y+1<h){
  1043.             for(x=0; x<15; x++){
  1044.                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
  1045.                              - s1[x+1] + s1[x+1+stride])
  1046.                         -FFABS(  s2[x  ] - s2[x  +stride]
  1047.                              - s2[x+1] + s2[x+1+stride]);
  1048.             }
  1049.         }
  1050.         s1+= stride;
  1051.         s2+= stride;
  1052.     }
  1054.     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
  1055.     else  return score1 + FFABS(score2)*8;
  1056. }
  1058. static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
  1059.     MpegEncContext *c = v;
  1060.     int score1=0;
  1061.     int score2=0;
  1062.     int x,y;
  1064.     for(y=0; y<h; y++){
  1065.         for(x=0; x<8; x++){
  1066.             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
  1067.         }
  1068.         if(y+1<h){
  1069.             for(x=0; x<7; x++){
  1070.                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
  1071.                              - s1[x+1] + s1[x+1+stride])
  1072.                         -FFABS(  s2[x  ] - s2[x  +stride]
  1073.                              - s2[x+1] + s2[x+1+stride]);
  1074.             }
  1075.         }
  1076.         s1+= stride;
  1077.         s2+= stride;
  1078.     }
  1080.     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
  1081.     else  return score1 + FFABS(score2)*8;
  1082. }
  1084. static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
  1085.     int i;
  1086.     unsigned int sum=0;
  1088.     for(i=0; i<8*8; i++){
  1089.         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
  1090.         int w= weight[i];
  1091.         b>>= RECON_SHIFT;
  1092.         assert(-512<b && b<512);
  1094.         sum += (w*b)*(w*b)>>4;
  1095.     }
  1096.     return sum>>2;
  1097. }
  1099. static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
  1100.     int i;
  1102.     for(i=0; i<8*8; i++){
  1103.         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
  1104.     }
  1105. }
  1107. /**
  1108.  * permutes an 8x8 block.
  1109.  * @param block the block which will be permuted according to the given permutation vector
  1110.  * @param permutation the permutation vector
  1111.  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
  1112.  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
  1113.  *                  (inverse) permutated to scantable order!
  1114.  */
  1115. void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
  1116. {
  1117.     int i;
  1118.     DCTELEM temp[64];
  1120.     if(last<=0) return;
  1121.     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
  1123.     for(i=0; i<=last; i++){
  1124.         const int j= scantable[i];
  1125.         temp[j]= block[j];
  1126.         block[j]=0;
  1127.     }
  1129.     for(i=0; i<=last; i++){
  1130.         const int j= scantable[i];
  1131.         const int perm_j= permutation[j];
  1132.         block[perm_j]= temp[j];
  1133.     }
  1134. }
  1136. static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
  1137.     return 0;
  1138. }
  1140. void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
  1141.     int i;
  1143.     memset(cmp, 0, sizeof(void*)*5);
  1145.     for(i=0; i<5; i++){
  1146.         switch(type&0xFF){
  1147.         case FF_CMP_SAD:
  1148.             cmp[i]= c->sad[i];
  1149.             break;
  1150.         case FF_CMP_SATD:
  1151.             cmp[i]= c->hadamard8_diff[i];
  1152.             break;
  1153.         case FF_CMP_SSE:
  1154.             cmp[i]= c->sse[i];
  1155.             break;
  1156.         case FF_CMP_DCT:
  1157.             cmp[i]= c->dct_sad[i];
  1158.             break;
  1159.         case FF_CMP_DCT264:
  1160.             cmp[i]= c->dct264_sad[i];
  1161.             break;
  1162.         case FF_CMP_DCTMAX:
  1163.             cmp[i]= c->dct_max[i];
  1164.             break;
  1165.         case FF_CMP_PSNR:
  1166.             cmp[i]= c->quant_psnr[i];
  1167.             break;
  1168.         case FF_CMP_BIT:
  1169.             cmp[i]= c->bit[i];
  1170.             break;
  1171.         case FF_CMP_RD:
  1172.             cmp[i]= c->rd[i];
  1173.             break;
  1174.         case FF_CMP_VSAD:
  1175.             cmp[i]= c->vsad[i];
  1176.             break;
  1177.         case FF_CMP_VSSE:
  1178.             cmp[i]= c->vsse[i];
  1179.             break;
  1180.         case FF_CMP_ZERO:
  1181.             cmp[i]= zero_cmp;
  1182.             break;
  1183.         case FF_CMP_NSSE:
  1184.             cmp[i]= c->nsse[i];
  1185.             break;
  1186. #ifdef CONFIG_SNOW_ENCODER
  1187.         case FF_CMP_W53:
  1188.             cmp[i]= c->w53[i];
  1189.             break;
  1190.         case FF_CMP_W97:
  1191.             cmp[i]= c->w97[i];
  1192.             break;
  1193. #endif
  1194.         default:
  1195.             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selectionn");
  1196.         }
  1197.     }
  1198. }
  1200. static void clear_block_c(DCTELEM *block)
  1201. {
  1202.     memset(block, 0, sizeof(DCTELEM)*64);
  1203. }
  1205. /**
  1206.  * memset(blocks, 0, sizeof(DCTELEM)*6*64)
  1207.  */
  1208. static void clear_blocks_c(DCTELEM *blocks)
  1209. {
  1210.     memset(blocks, 0, sizeof(DCTELEM)*6*64);
  1211. }
  1213. static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
  1214.     long i;
  1215.     for(i=0; i<=w-(long)sizeof(long); i+=(long)sizeof(long)){
  1216.         long a = *(long*)(src+i);
  1217.         long b = *(long*)(dst+i);
  1218.         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
  1219.     }
  1220.     for(; i<w; i++)
  1221.         dst[i+0] += src[i+0];
  1222. }
  1224. static void add_bytes_l2_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
  1225.     long i;
  1226.     for(i=0; i<=w-(long)sizeof(long); i+=(long)sizeof(long)){
  1227.         long a = *(long*)(src1+i);
  1228.         long b = *(long*)(src2+i);
  1229.         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
  1230.     }
  1231.     for(; i<w; i++)
  1232.         dst[i] = src1[i]+src2[i];
  1233. }
  1235. static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
  1236.     long i;
  1237. #ifndef HAVE_FAST_UNALIGNED
  1238.     if((long)src2 & (sizeof(long)-1)){
  1239.         for(i=0; i+7<w; i+=8){
  1240.             dst[i+0] = src1[i+0]-src2[i+0];
  1241.             dst[i+1] = src1[i+1]-src2[i+1];
  1242.             dst[i+2] = src1[i+2]-src2[i+2];
  1243.             dst[i+3] = src1[i+3]-src2[i+3];
  1244.             dst[i+4] = src1[i+4]-src2[i+4];
  1245.             dst[i+5] = src1[i+5]-src2[i+5];
  1246.             dst[i+6] = src1[i+6]-src2[i+6];
  1247.             dst[i+7] = src1[i+7]-src2[i+7];
  1248.         }
  1249.     }else
  1250. #endif
  1251.     for(i=0; i<=w-(long)sizeof(long); i+=(long)sizeof(long)){
  1252.         long a = *(long*)(src1+i);
  1253.         long b = *(long*)(src2+i);
  1254.         *(long*)(dst+i) = ((a|pb_80) - (b&pb_7f)) ^ ((a^b^pb_80)&pb_80);
  1255.     }
  1256.     for(; i<w; i++)
  1257.         dst[i+0] = src1[i+0]-src2[i+0];
  1258. }
  1260. static void sub_hfyu_median_prediction_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
  1261.     int i;
  1262.     uint8_t l, lt;
  1264.     l= *left;
  1265.     lt= *left_top;
  1267.     for(i=0; i<w; i++){
  1268.         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
  1269.         lt= src1[i];
  1270.         l= src2[i];
  1271.         dst[i]= l - pred;
  1272.     }
  1274.     *left= l;
  1275.     *left_top= lt;
  1276. }
  1278. #define BUTTERFLY2(o1,o2,i1,i2) 
  1279. o1= (i1)+(i2);
  1280. o2= (i1)-(i2);
  1282. #define BUTTERFLY1(x,y) 
  1283. {
  1284.     int a,b;
  1285.     a= x;
  1286.     b= y;
  1287.     x= a+b;
  1288.     y= a-b;
  1289. }
  1291. #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
  1293. static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
  1294.     int i;
  1295.     int temp[64];
  1296.     int sum=0;
  1298.     assert(h==8);
  1300.     for(i=0; i<8; i++){
  1301.         //FIXME try pointer walks
  1302.         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0]-dst[stride*i+0],src[stride*i+1]-dst[stride*i+1]);
  1303.         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2]-dst[stride*i+2],src[stride*i+3]-dst[stride*i+3]);
  1304.         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4]-dst[stride*i+4],src[stride*i+5]-dst[stride*i+5]);
  1305.         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6]-dst[stride*i+6],src[stride*i+7]-dst[stride*i+7]);
  1307.         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
  1308.         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
  1309.         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
  1310.         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
  1312.         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
  1313.         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
  1314.         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
  1315.         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
  1316.     }
  1318.     for(i=0; i<8; i++){
  1319.         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
  1320.         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
  1321.         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
  1322.         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
  1324.         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
  1325.         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
  1326.         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
  1327.         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
  1329.         sum +=
  1330.              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
  1331.             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
  1332.             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
  1333.             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
  1334.     }
  1335. #if 0
  1336. static int maxi=0;
  1337. if(sum>maxi){
  1338.     maxi=sum;
  1339.     printf("MAX:%dn", maxi);
  1340. }
  1341. #endif
  1342.     return sum;
  1343. }
  1345. static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
  1346.     int i;
  1347.     int temp[64];
  1348.     int sum=0;
  1350.     assert(h==8);
  1352.     for(i=0; i<8; i++){
  1353.         //FIXME try pointer walks
  1354.         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
  1355.         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
  1356.         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
  1357.         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
  1359.         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
  1360.         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
  1361.         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
  1362.         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
  1364.         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
  1365.         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
  1366.         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
  1367.         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
  1368.     }
  1370.     for(i=0; i<8; i++){
  1371.         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
  1372.         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
  1373.         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
  1374.         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
  1376.         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
  1377.         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
  1378.         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
  1379.         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
  1381.         sum +=
  1382.              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
  1383.             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
  1384.             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
  1385.             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
  1386.     }
  1388.     sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
  1390.     return sum;
  1391. }
  1393. static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1394.     MpegEncContext * const s= (MpegEncContext *)c;
  1395.     DECLARE_ALIGNED_16(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
  1396.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  1398.     assert(h==8);
  1400.     s->dsp.diff_pixels(temp, src1, src2, stride);
  1401.     s->dsp.fdct(temp);
  1402.     return s->dsp.sum_abs_dctelem(temp);
  1403. }
  1405. #ifdef CONFIG_GPL
  1406. #define DCT8_1D {
  1407.     const int s07 = SRC(0) + SRC(7);
  1408.     const int s16 = SRC(1) + SRC(6);
  1409.     const int s25 = SRC(2) + SRC(5);
  1410.     const int s34 = SRC(3) + SRC(4);
  1411.     const int a0 = s07 + s34;
  1412.     const int a1 = s16 + s25;
  1413.     const int a2 = s07 - s34;
  1414.     const int a3 = s16 - s25;
  1415.     const int d07 = SRC(0) - SRC(7);
  1416.     const int d16 = SRC(1) - SRC(6);
  1417.     const int d25 = SRC(2) - SRC(5);
  1418.     const int d34 = SRC(3) - SRC(4);
  1419.     const int a4 = d16 + d25 + (d07 + (d07>>1));
  1420.     const int a5 = d07 - d34 - (d25 + (d25>>1));
  1421.     const int a6 = d07 + d34 - (d16 + (d16>>1));
  1422.     const int a7 = d16 - d25 + (d34 + (d34>>1));
  1423.     DST(0,  a0 + a1     ) ;
  1424.     DST(1,  a4 + (a7>>2)) ;
  1425.     DST(2,  a2 + (a3>>1)) ;
  1426.     DST(3,  a5 + (a6>>2)) ;
  1427.     DST(4,  a0 - a1     ) ;
  1428.     DST(5,  a6 - (a5>>2)) ;
  1429.     DST(6, (a2>>1) - a3 ) ;
  1430.     DST(7, (a4>>2) - a7 ) ;
  1431. }
  1433. static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1434.     MpegEncContext * const s= (MpegEncContext *)c;
  1435.     DCTELEM dct[8][8];
  1436.     int i;
  1437.     int sum=0;
  1439.     s->dsp.diff_pixels(dct[0], src1, src2, stride);
  1441. #define SRC(x) dct[i][x]
  1442. #define DST(x,v) dct[i][x]= v
  1443.     for( i = 0; i < 8; i++ )
  1444.         DCT8_1D
  1445. #undef SRC
  1446. #undef DST
  1448. #define SRC(x) dct[x][i]
  1449. #define DST(x,v) sum += FFABS(v)
  1450.     for( i = 0; i < 8; i++ )
  1451.         DCT8_1D
  1452. #undef SRC
  1453. #undef DST
  1454.     return sum;
  1455. }
  1456. #endif
  1458. static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1459.     MpegEncContext * const s= (MpegEncContext *)c;
  1460.     DECLARE_ALIGNED_8(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
  1461.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  1462.     int sum=0, i;
  1464.     assert(h==8);
  1466.     s->dsp.diff_pixels(temp, src1, src2, stride);
  1467.     s->dsp.fdct(temp);
  1469.     for(i=0; i<64; i++)
  1470.         sum= FFMAX(sum, FFABS(temp[i]));
  1472.     return sum;
  1473. }
  1475. static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1476.     MpegEncContext * const s= (MpegEncContext *)c;
  1477.     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64*2/8]);
  1478.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  1479.     DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;
  1480.     int sum=0, i;
  1482.     assert(h==8);
  1483.     s->mb_intra=0;
  1485.     s->dsp.diff_pixels(temp, src1, src2, stride);
  1487.     memcpy(bak, temp, 64*sizeof(DCTELEM));
  1489.     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  1490.     s->dct_unquantize_inter(s, temp, 0, s->qscale);
  1491.     ff_simple_idct(temp); //FIXME
  1493.     for(i=0; i<64; i++)
  1494.         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
  1496.     return sum;
  1497. }
  1499. static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1500.     MpegEncContext * const s= (MpegEncContext *)c;
  1501.     const uint8_t *scantable= s->intra_scantable.permutated;
  1502.     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
  1503.     //DECLARE_ALIGNED_8 (uint64_t, aligned_bak[stride]);
  1504. uint64_t* aligned_bak = (uint64_t*)av_malloc(stride*sizeof(uint64_t));
  1505.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  1506.     uint8_t * const bak= (uint8_t*)aligned_bak;
  1507.     int i, last, run, bits, level, distortion, start_i;
  1508.     const int esc_length= s->ac_esc_length;
  1509.     uint8_t * length;
  1510.     uint8_t * last_length;
  1512.     assert(h==8);
  1514.     for(i=0; i<8; i++){
  1515.         ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];
  1516.         ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];
  1517.     }
  1519.     s->dsp.diff_pixels(temp, src1, src2, stride);
  1521.     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  1523.     bits=0;
  1525.     if (s->mb_intra) {
  1526.         start_i = 1;
  1527.         length     = s->intra_ac_vlc_length;
  1528.         last_length= s->intra_ac_vlc_last_length;
  1529.         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
  1530.     } else {
  1531.         start_i = 0;
  1532.         length     = s->inter_ac_vlc_length;
  1533.         last_length= s->inter_ac_vlc_last_length;
  1534.     }
  1536.     if(last>=start_i){
  1537.         run=0;
  1538.         for(i=start_i; i<last; i++){
  1539.             int j= scantable[i];
  1540.             level= temp[j];
  1542.             if(level){
  1543.                 level+=64;
  1544.                 if((level&(~127)) == 0){
  1545.                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
  1546.                 }else
  1547.                     bits+= esc_length;
  1548.                 run=0;
  1549.             }else
  1550.                 run++;
  1551.         }
  1552.         i= scantable[last];
  1554.         level= temp[i] + 64;
  1556.         assert(level - 64);
  1558.         if((level&(~127)) == 0){
  1559.             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
  1560.         }else
  1561.             bits+= esc_length;
  1563.     }
  1565.     if(last>=0){
  1566.         if(s->mb_intra)
  1567.             s->dct_unquantize_intra(s, temp, 0, s->qscale);
  1568.         else
  1569.             s->dct_unquantize_inter(s, temp, 0, s->qscale);
  1570.     }
  1572.     s->dsp.idct_add(bak, stride, temp);
  1574.     distortion= s->dsp.sse[1](NULL, bak, src1, stride, 8);
  1576. av_free(aligned_bak);
  1578.     return distortion + ((bits*s->qscale*s->qscale*109 + 64)>>7);
  1579. }
  1581. static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  1582.     MpegEncContext * const s= (MpegEncContext *)c;
  1583.     const uint8_t *scantable= s->intra_scantable.permutated;
  1584.     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
  1585.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  1586.     int i, last, run, bits, level, start_i;
  1587.     const int esc_length= s->ac_esc_length;
  1588.     uint8_t * length;
  1589.     uint8_t * last_length;
  1591.     assert(h==8);
  1593.     s->dsp.diff_pixels(temp, src1, src2, stride);
  1595.     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  1597.     bits=0;
  1599.     if (s->mb_intra) {
  1600.         start_i = 1;
  1601.         length     = s->intra_ac_vlc_length;
  1602.         last_length= s->intra_ac_vlc_last_length;
  1603.         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
  1604.     } else {
  1605.         start_i = 0;
  1606.         length     = s->inter_ac_vlc_length;
  1607.         last_length= s->inter_ac_vlc_last_length;
  1608.     }
  1610.     if(last>=start_i){
  1611.         run=0;
  1612.         for(i=start_i; i<last; i++){
  1613.             int j= scantable[i];
  1614.             level= temp[j];
  1616.             if(level){
  1617.                 level+=64;
  1618.                 if((level&(~127)) == 0){
  1619.                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
  1620.                 }else
  1621.                     bits+= esc_length;
  1622.                 run=0;
  1623.             }else
  1624.                 run++;
  1625.         }
  1626.         i= scantable[last];
  1628.         level= temp[i] + 64;
  1630.         assert(level - 64);
  1632.         if((level&(~127)) == 0){
  1633.             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
  1634.         }else
  1635.             bits+= esc_length;
  1636.     }
  1638.     return bits;
  1639. }
  1641. static int vsad_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
  1642.     int score=0;
  1643.     int x,y;
  1645.     for(y=1; y<h; y++){
  1646.         for(x=0; x<16; x+=4){
  1647.             score+= FFABS(s[x  ] - s[x  +stride]) + FFABS(s[x+1] - s[x+1+stride])
  1648.                    +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]);
  1649.         }
  1650.         s+= stride;
  1651.     }
  1653.     return score;
  1654. }
  1656. static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  1657.     int score=0;
  1658.     int x,y;
  1660.     for(y=1; y<h; y++){
  1661.         for(x=0; x<16; x++){
  1662.             score+= FFABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
  1663.         }
  1664.         s1+= stride;
  1665.         s2+= stride;
  1666.     }
  1668.     return score;
  1669. }
  1671. #define SQ(a) ((a)*(a))
  1672. static int vsse_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
  1673.     int score=0;
  1674.     int x,y;
  1676.     for(y=1; y<h; y++){
  1677.         for(x=0; x<16; x+=4){
  1678.             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])
  1679.                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
  1680.         }
  1681.         s+= stride;
  1682.     }
  1684.     return score;
  1685. }
  1687. static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  1688.     int score=0;
  1689.     int x,y;
  1691.     for(y=1; y<h; y++){
  1692.         for(x=0; x<16; x++){
  1693.             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
  1694.         }
  1695.         s1+= stride;
  1696.         s2+= stride;
  1697.     }
  1699.     return score;
  1700. }
  1702. static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
  1703.                                int size){
  1704.     int score=0;
  1705.     int i;
  1706.     for(i=0; i<size; i++)
  1707.         score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
  1708.     return score;
  1709. }
  1711. WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
  1712. WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
  1713. WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
  1714. #ifdef CONFIG_GPL
  1715. WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
  1716. #endif
  1717. WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
  1718. WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
  1719. WRAPPER8_16_SQ(rd8x8_c, rd16_c)
  1720. WRAPPER8_16_SQ(bit8x8_c, bit16_c)
  1722. static void vector_fmul_c(float *dst, const float *src, int len){
  1723.     int i;
  1724.     for(i=0; i<len; i++)
  1725.         dst[i] *= src[i];
  1726. }
  1728. static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
  1729.     int i;
  1730.     src1 += len-1;
  1731.     for(i=0; i<len; i++)
  1732.         dst[i] = src0[i] * src1[-i];
  1733. }
  1735. void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step){
  1736.     int i;
  1737.     for(i=0; i<len; i++)
  1738.         dst[i*step] = src0[i] * src1[i] + src2[i] + src3;
  1739. }
  1741. void ff_vector_fmul_window_c(float *dst, const float *src0, const float *src1, const float *win, float add_bias, int len){
  1742.     int i,j;
  1743.     dst += len;
  1744.     win += len;
  1745.     src0+= len;
  1746.     for(i=-len, j=len-1; i<0; i++, j--) {
  1747.         float s0 = src0[i];
  1748.         float s1 = src1[j];
  1749.         float wi = win[i];
  1750.         float wj = win[j];
  1751.         dst[i] = s0*wj - s1*wi + add_bias;
  1752.         dst[j] = s0*wi + s1*wj + add_bias;
  1753.     }
  1754. }
  1756. static void int32_to_float_fmul_scalar_c(float *dst, const int *src, float mul, int len){
  1757.     int i;
  1758.     for(i=0; i<len; i++)
  1759.         dst[i] = src[i] * mul;
  1760. }
  1762. static av_always_inline int float_to_int16_one(const float *src){
  1763.     int_fast32_t tmp = *(const int32_t*)src;
  1764.     if(tmp & 0xf0000){
  1765.         tmp = (0x43c0ffff - tmp)>>31;
  1766.         // is this faster on some gcc/cpu combinations?
  1767. //      if(tmp > 0x43c0ffff) tmp = 0xFFFF;
  1768. //      else                 tmp = 0;
  1769.     }
  1770.     return tmp - 0x8000;
  1771. }
  1773. void ff_float_to_int16_c(int16_t *dst, const float *src, long len){
  1774.     int i;
  1775.     for(i=0; i<len; i++)
  1776.         dst[i] = float_to_int16_one(src+i);
  1777. }
  1779. void ff_float_to_int16_interleave_c(int16_t *dst, const float **src, long len, int channels){
  1780.     int i,j,c;
  1781.     if(channels==2){
  1782.         for(i=0; i<len; i++){
  1783.             dst[2*i]   = float_to_int16_one(src[0]+i);
  1784.             dst[2*i+1] = float_to_int16_one(src[1]+i);
  1785.         }
  1786.     }else{
  1787.         for(c=0; c<channels; c++)
  1788.             for(i=0, j=c; i<len; i++, j+=channels)
  1789.                 dst[j] = float_to_int16_one(src[c]+i);
  1790.     }
  1791. }
  1793. static void add_int16_c(int16_t * v1, int16_t * v2, int order)
  1794. {
  1795.     while (order--)
  1796.        *v1++ += *v2++;
  1797. }
  1799. static void sub_int16_c(int16_t * v1, int16_t * v2, int order)
  1800. {
  1801.     while (order--)
  1802.         *v1++ -= *v2++;
  1803. }
  1805. static int32_t scalarproduct_int16_c(int16_t * v1, int16_t * v2, int order, int shift)
  1806. {
  1807.     int res = 0;
  1809.     while (order--)
  1810.         res += (*v1++ * *v2++) >> shift;
  1812.     return res;
  1813. }
  1815. #define W0 2048
  1816. #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
  1817. #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
  1818. #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
  1819. #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
  1820. #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
  1821. #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
  1822. #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
  1824. static void wmv2_idct_row(short * b)
  1825. {
  1826.     int s1,s2;
  1827.     int a0,a1,a2,a3,a4,a5,a6,a7;
  1828.     /*step 1*/
  1829.     a1 = W1*b[1]+W7*b[7];
  1830.     a7 = W7*b[1]-W1*b[7];
  1831.     a5 = W5*b[5]+W3*b[3];
  1832.     a3 = W3*b[5]-W5*b[3];
  1833.     a2 = W2*b[2]+W6*b[6];
  1834.     a6 = W6*b[2]-W2*b[6];
  1835.     a0 = W0*b[0]+W0*b[4];
  1836.     a4 = W0*b[0]-W0*b[4];
  1837.     /*step 2*/
  1838.     s1 = (181*(a1-a5+a7-a3)+128)>>8;//1,3,5,7,
  1839.     s2 = (181*(a1-a5-a7+a3)+128)>>8;
  1840.     /*step 3*/
  1841.     b[0] = (a0+a2+a1+a5 + (1<<7))>>8;
  1842.     b[1] = (a4+a6 +s1   + (1<<7))>>8;
  1843.     b[2] = (a4-a6 +s2   + (1<<7))>>8;
  1844.     b[3] = (a0-a2+a7+a3 + (1<<7))>>8;
  1845.     b[4] = (a0-a2-a7-a3 + (1<<7))>>8;
  1846.     b[5] = (a4-a6 -s2   + (1<<7))>>8;
  1847.     b[6] = (a4+a6 -s1   + (1<<7))>>8;
  1848.     b[7] = (a0+a2-a1-a5 + (1<<7))>>8;
  1849. }
  1850. static void wmv2_idct_col(short * b)
  1851. {
  1852.     int s1,s2;
  1853.     int a0,a1,a2,a3,a4,a5,a6,a7;
  1854.     /*step 1, with extended precision*/
  1855.     a1 = (W1*b[8*1]+W7*b[8*7] + 4)>>3;
  1856.     a7 = (W7*b[8*1]-W1*b[8*7] + 4)>>3;
  1857.     a5 = (W5*b[8*5]+W3*b[8*3] + 4)>>3;
  1858.     a3 = (W3*b[8*5]-W5*b[8*3] + 4)>>3;
  1859.     a2 = (W2*b[8*2]+W6*b[8*6] + 4)>>3;
  1860.     a6 = (W6*b[8*2]-W2*b[8*6] + 4)>>3;
  1861.     a0 = (W0*b[8*0]+W0*b[8*4]    )>>3;
  1862.     a4 = (W0*b[8*0]-W0*b[8*4]    )>>3;
  1863.     /*step 2*/
  1864.     s1 = (181*(a1-a5+a7-a3)+128)>>8;
  1865.     s2 = (181*(a1-a5-a7+a3)+128)>>8;
  1866.     /*step 3*/
  1867.     b[8*0] = (a0+a2+a1+a5 + (1<<13))>>14;
  1868.     b[8*1] = (a4+a6 +s1   + (1<<13))>>14;
  1869.     b[8*2] = (a4-a6 +s2   + (1<<13))>>14;
  1870.     b[8*3] = (a0-a2+a7+a3 + (1<<13))>>14;
  1872.     b[8*4] = (a0-a2-a7-a3 + (1<<13))>>14;
  1873.     b[8*5] = (a4-a6 -s2   + (1<<13))>>14;
  1874.     b[8*6] = (a4+a6 -s1   + (1<<13))>>14;
  1875.     b[8*7] = (a0+a2-a1-a5 + (1<<13))>>14;
  1876. }
  1877. void ff_wmv2_idct_c(short * block){
  1878.     int i;
  1880.     for(i=0;i<64;i+=8){
  1881.         wmv2_idct_row(block+i);
  1882.     }
  1883.     for(i=0;i<8;i++){
  1884.         wmv2_idct_col(block+i);
  1885.     }
  1886. }
  1887. /* XXX: those functions should be suppressed ASAP when all IDCTs are
  1888.  converted */
  1889. /*
  1890. static void ff_wmv2_idct_put_c(uint8_t *dest, int line_size, DCTELEM *block)
  1891. {
  1892.     ff_wmv2_idct_c(block);
  1893.     put_pixels_clamped_c(block, dest, line_size);
  1894. }
  1895. static void ff_wmv2_idct_add_c(uint8_t *dest, int line_size, DCTELEM *block)
  1896. {
  1897.     ff_wmv2_idct_c(block);
  1898.     add_pixels_clamped_c(block, dest, line_size);
  1899. }
  1900. */
  1901. static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
  1902. {
  1903.     j_rev_dct (block);
  1904.     put_pixels_clamped_c(block, dest, line_size);
  1905. }
  1906. static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
  1907. {
  1908.     j_rev_dct (block);
  1909.     add_pixels_clamped_c(block, dest, line_size);
  1910. }
  1912. static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
  1913. {
  1914.     j_rev_dct4 (block);
  1915.     put_pixels_clamped4_c(block, dest, line_size);
  1916. }
  1917. static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
  1918. {
  1919.     j_rev_dct4 (block);
  1920.     add_pixels_clamped4_c(block, dest, line_size);
  1921. }
  1923. static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
  1924. {
  1925.     j_rev_dct2 (block);
  1926.     put_pixels_clamped2_c(block, dest, line_size);
  1927. }
  1928. static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
  1929. {
  1930.     j_rev_dct2 (block);
  1931.     add_pixels_clamped2_c(block, dest, line_size);
  1932. }
  1934. static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
  1935. {
  1936.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  1938.     dest[0] = cm[(block[0] + 4)>>3];
  1939. }
  1940. static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
  1941. {
  1942.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  1944.     dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
  1945. }
  1947. static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
  1949. /* init static data */
  1950. void dsputil_static_init(void)
  1951. {
  1952.     int i;
  1954.     for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
  1955.     for(i=0;i<MAX_NEG_CROP;i++) {
  1956.         ff_cropTbl[i] = 0;
  1957.         ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
  1958.     }
  1960.     for(i=0;i<512;i++) {
  1961.         ff_squareTbl[i] = (i - 256) * (i - 256);
  1962.     }
  1964.     for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
  1965. }
  1967. int ff_check_alignment(void){
  1968.     static int did_fail=0;
  1969.     DECLARE_ALIGNED_16(int, aligned);
  1971.     if((long)&aligned & 15){
  1972.         if(!did_fail){
  1973. #if defined(HAVE_MMX) || defined(HAVE_ALTIVEC)
  1974.             av_log(NULL, AV_LOG_ERROR,
  1975.                 "Compiler did not align stack variables. Libavcodec has been miscompiledn"
  1976.                 "and may be very slow or crash. This is not a bug in libavcodec,n"
  1977.                 "but in the compiler. You may try recompiling using gcc >= 4.2.n"
  1978.                 "Do not report crashes to FFmpeg developers.n");
  1979. #endif
  1980.             did_fail=1;
  1981.         }
  1982.         return -1;
  1983.     }
  1984.     return 0;
  1985. }
  1987. void dsputil_init(DSPContext* c, AVCodecContext *avctx)
  1988. {
  1989.     int i;
  1991.     ff_check_alignment();
  1993. #ifdef CONFIG_ENCODERS
  1994.     if(avctx->dct_algo==FF_DCT_FASTINT) {
  1995.         c->fdct = fdct_ifast;
  1996.         c->fdct248 = fdct_ifast248;
  1997.     }
  1998.     else if(avctx->dct_algo==FF_DCT_FAAN) {
  1999.         c->fdct = ff_faandct;
  2000.         c->fdct248 = ff_faandct248;
  2001.     }
  2002.     else {
  2003.         c->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
  2004.         c->fdct248 = ff_fdct248_islow;
  2005.     }
  2006. #endif //CONFIG_ENCODERS
  2008.     if(avctx->lowres==1){
  2009.         if(avctx->idct_algo==FF_IDCT_INT || avctx->idct_algo==FF_IDCT_AUTO || !ENABLE_H264_DECODER){
  2010.             c->idct_put= ff_jref_idct4_put;
  2011.             c->idct_add= ff_jref_idct4_add;
  2012.         }else{
  2013.             c->idct_put= ff_h264_lowres_idct_put_c;
  2014.             c->idct_add= ff_h264_lowres_idct_add_c;
  2015.         }
  2016.         c->idct    = j_rev_dct4;
  2017.         c->idct_permutation_type= FF_NO_IDCT_PERM;
  2018.     }else if(avctx->lowres==2){
  2019.         c->idct_put= ff_jref_idct2_put;
  2020.         c->idct_add= ff_jref_idct2_add;
  2021.         c->idct    = j_rev_dct2;
  2022.         c->idct_permutation_type= FF_NO_IDCT_PERM;
  2023.     }else if(avctx->lowres==3){
  2024.         c->idct_put= ff_jref_idct1_put;
  2025.         c->idct_add= ff_jref_idct1_add;
  2026.         c->idct    = j_rev_dct1;
  2027.         c->idct_permutation_type= FF_NO_IDCT_PERM;
  2028.     }
  2029. else
  2030. {
  2031.         if(avctx->idct_algo==FF_IDCT_INT)
  2032. {
  2033.             c->idct_put= ff_jref_idct_put;
  2034.             c->idct_add= ff_jref_idct_add;
  2035.             c->idct    = j_rev_dct;
  2036.             c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
  2037.         }
  2038. /*else if((ENABLE_VP3_DECODER || ENABLE_VP5_DECODER || ENABLE_VP6_DECODER || ENABLE_THEORA_DECODER ) && avctx->idct_algo==FF_IDCT_VP3)
  2039. {
  2040.             c->idct_put= ff_vp3_idct_put_c;
  2041.             c->idct_add= ff_vp3_idct_add_c;
  2042.             c->idct    = ff_vp3_idct_c;
  2043.             c->idct_permutation_type= FF_NO_IDCT_PERM;
  2044.         }
  2045. else if(avctx->idct_algo==FF_IDCT_WMV2)
  2046. {
  2047.             c->idct_put= ff_wmv2_idct_put_c;
  2048.             c->idct_add= ff_wmv2_idct_add_c;
  2049.             c->idct    = ff_wmv2_idct_c;
  2050.             c->idct_permutation_type= FF_NO_IDCT_PERM;
  2051.         }
  2052. else if(avctx->idct_algo==FF_IDCT_FAAN)
  2053. {
  2054.             c->idct_put= ff_faanidct_put;
  2055.             c->idct_add= ff_faanidct_add;
  2056.             c->idct    = ff_faanidct;
  2057.             c->idct_permutation_type= FF_NO_IDCT_PERM;
  2058.         }
  2059. else if(ENABLE_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) 
  2060. {
  2061.             c->idct_put= ff_ea_idct_put_c;
  2062.             c->idct_permutation_type= FF_NO_IDCT_PERM;
  2063.         }*/
  2064. else
  2065. { //accurate/default
  2066.             c->idct_put= ff_simple_idct_put;
  2067.             c->idct_add= ff_simple_idct_add;
  2068.             c->idct    = ff_simple_idct;
  2069.             c->idct_permutation_type= FF_NO_IDCT_PERM;
  2070.         }
  2071.     }
  2073.     if (ENABLE_H264_DECODER) {
  2074.         c->h264_idct_add= ff_h264_idct_add_c;
  2075.         c->h264_idct8_add= ff_h264_idct8_add_c;
  2076.         c->h264_idct_dc_add= ff_h264_idct_dc_add_c;
  2077.         c->h264_idct8_dc_add= ff_h264_idct8_dc_add_c;
  2078.         c->h264_idct_add16     = ff_h264_idct_add16_c;
  2079.         c->h264_idct8_add4     = ff_h264_idct8_add4_c;
  2080.         c->h264_idct_add8      = ff_h264_idct_add8_c;
  2081.         c->h264_idct_add16intra= ff_h264_idct_add16intra_c;
  2082.     }
  2084.     c->get_pixels = get_pixels_c;
  2085.     c->diff_pixels = diff_pixels_c;
  2086.     c->put_pixels_clamped = put_pixels_clamped_c;
  2087.     c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
  2088.     c->add_pixels_clamped = add_pixels_clamped_c;
  2089.     c->add_pixels8 = add_pixels8_c;
  2090.     c->add_pixels4 = add_pixels4_c;
  2091.     c->sum_abs_dctelem = sum_abs_dctelem_c;
  2092.     c->gmc1 = gmc1_c;
  2093.     c->gmc = ff_gmc_c;
  2094.     c->clear_block = clear_block_c;
  2095.     c->clear_blocks = clear_blocks_c;
  2096.     c->pix_sum = pix_sum_c;
  2097.     c->pix_norm1 = pix_norm1_c;
  2099.     /* TODO [0] 16  [1] 8 */
  2100.     c->pix_abs[0][0] = pix_abs16_c;
  2101.     c->pix_abs[0][1] = pix_abs16_x2_c;
  2102.     c->pix_abs[0][2] = pix_abs16_y2_c;
  2103.     c->pix_abs[0][3] = pix_abs16_xy2_c;
  2104.     c->pix_abs[1][0] = pix_abs8_c;
  2105.     c->pix_abs[1][1] = pix_abs8_x2_c;
  2106.     c->pix_abs[1][2] = pix_abs8_y2_c;
  2107.     c->pix_abs[1][3] = pix_abs8_xy2_c;
  2109. #define dspfunc(PFX, IDX, NUM) 
  2110.     c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c;     
  2111.     c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## NUM ## _x2_c;  
  2112.     c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## NUM ## _y2_c;  
  2113.     c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## NUM ## _xy2_c
  2115.     dspfunc(put, 0, 16);
  2116.     dspfunc(put_no_rnd, 0, 16);
  2117.     dspfunc(put, 1, 8);
  2118.     dspfunc(put_no_rnd, 1, 8);
  2119.     dspfunc(put, 2, 4);
  2120.     dspfunc(put, 3, 2);
  2122.     dspfunc(avg, 0, 16);
  2123.     dspfunc(avg_no_rnd, 0, 16);
  2124.     dspfunc(avg, 1, 8);
  2125.     dspfunc(avg_no_rnd, 1, 8);
  2126.     dspfunc(avg, 2, 4);
  2127.     dspfunc(avg, 3, 2);
  2128. #undef dspfunc
  2130.     c->put_no_rnd_pixels_l2[0]= put_no_rnd_pixels16_l2_c;
  2131.     c->put_no_rnd_pixels_l2[1]= put_no_rnd_pixels8_l2_c;
  2133.     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
  2134.     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
  2135.     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
  2136.     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
  2137.     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
  2138.     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
  2139.     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
  2140.     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
  2141.     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
  2143.     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
  2144.     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
  2145.     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
  2146.     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
  2147.     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
  2148.     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
  2149.     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
  2150.     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
  2151.     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
  2153. #define dspfunc(PFX, IDX, NUM) 
  2154.     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; 
  2155.     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; 
  2156.     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; 
  2157.     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; 
  2158.     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; 
  2159.     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; 
  2160.     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; 
  2161.     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; 
  2162.     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; 
  2163.     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; 
  2164.     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; 
  2165.     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; 
  2166.     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; 
  2167.     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; 
  2168.     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; 
  2169.     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
  2171.     dspfunc(put_qpel, 0, 16);
  2172.     dspfunc(put_no_rnd_qpel, 0, 16);
  2174.     dspfunc(avg_qpel, 0, 16);
  2175.     /* dspfunc(avg_no_rnd_qpel, 0, 16); */
  2177.     dspfunc(put_qpel, 1, 8);
  2178.     dspfunc(put_no_rnd_qpel, 1, 8);
  2180.     dspfunc(avg_qpel, 1, 8);
  2181.     /* dspfunc(avg_no_rnd_qpel, 1, 8); */
  2183.     dspfunc(put_h264_qpel, 0, 16);
  2184.     dspfunc(put_h264_qpel, 1, 8);
  2185.     dspfunc(put_h264_qpel, 2, 4);
  2186.     dspfunc(put_h264_qpel, 3, 2);
  2187.     dspfunc(avg_h264_qpel, 0, 16);
  2188.     dspfunc(avg_h264_qpel, 1, 8);
  2189.     dspfunc(avg_h264_qpel, 2, 4);
  2191. #undef dspfunc
  2192.     c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_c;
  2193.     c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_c;
  2194.     c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_c;
  2195.     c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_c;
  2196.     c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_c;
  2197.     c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_c;
  2198.     c->put_no_rnd_h264_chroma_pixels_tab[0]= put_no_rnd_h264_chroma_mc8_c;
  2200.     c->weight_h264_pixels_tab[0]= weight_h264_pixels16x16_c;
  2201.     c->weight_h264_pixels_tab[1]= weight_h264_pixels16x8_c;
  2202.     c->weight_h264_pixels_tab[2]= weight_h264_pixels8x16_c;
  2203.     c->weight_h264_pixels_tab[3]= weight_h264_pixels8x8_c;
  2204.     c->weight_h264_pixels_tab[4]= weight_h264_pixels8x4_c;
  2205.     c->weight_h264_pixels_tab[5]= weight_h264_pixels4x8_c;
  2206.     c->weight_h264_pixels_tab[6]= weight_h264_pixels4x4_c;
  2207.     c->weight_h264_pixels_tab[7]= weight_h264_pixels4x2_c;
  2208.     c->weight_h264_pixels_tab[8]= weight_h264_pixels2x4_c;
  2209.     c->weight_h264_pixels_tab[9]= weight_h264_pixels2x2_c;
  2210.     c->biweight_h264_pixels_tab[0]= biweight_h264_pixels16x16_c;
  2211.     c->biweight_h264_pixels_tab[1]= biweight_h264_pixels16x8_c;
  2212.     c->biweight_h264_pixels_tab[2]= biweight_h264_pixels8x16_c;
  2213.     c->biweight_h264_pixels_tab[3]= biweight_h264_pixels8x8_c;
  2214.     c->biweight_h264_pixels_tab[4]= biweight_h264_pixels8x4_c;
  2215.     c->biweight_h264_pixels_tab[5]= biweight_h264_pixels4x8_c;
  2216.     c->biweight_h264_pixels_tab[6]= biweight_h264_pixels4x4_c;
  2217.     c->biweight_h264_pixels_tab[7]= biweight_h264_pixels4x2_c;
  2218.     c->biweight_h264_pixels_tab[8]= biweight_h264_pixels2x4_c;
  2219.     c->biweight_h264_pixels_tab[9]= biweight_h264_pixels2x2_c;
  2221.     c->draw_edges = draw_edges_c;
  2223. #ifdef CONFIG_CAVS_DECODER
  2224.     ff_cavsdsp_init(c,avctx);
  2225. #endif
  2226. #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
  2227.     ff_vc1dsp_init(c,avctx);
  2228. #endif
  2229. #if defined(CONFIG_WMV2_DECODER) || defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
  2230.     ff_intrax8dsp_init(c,avctx);
  2231. #endif
  2232. #if defined(CONFIG_H264_ENCODER)
  2233.     ff_h264dspenc_init(c,avctx);
  2234. #endif
  2235. #if defined(CONFIG_RV30_DECODER)
  2236.     ff_rv30dsp_init(c,avctx);
  2237. #endif
  2238. #if defined(CONFIG_RV40_DECODER)
  2239.     ff_rv40dsp_init(c,avctx);
  2240.     c->put_rv40_qpel_pixels_tab[0][15] = put_rv40_qpel16_mc33_c;
  2241.     c->avg_rv40_qpel_pixels_tab[0][15] = avg_rv40_qpel16_mc33_c;
  2242.     c->put_rv40_qpel_pixels_tab[1][15] = put_rv40_qpel8_mc33_c;
  2243.     c->avg_rv40_qpel_pixels_tab[1][15] = avg_rv40_qpel8_mc33_c;
  2244. #endif
  2246.     c->put_mspel_pixels_tab[0]= put_mspel8_mc00_c;
  2247.     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
  2248.     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
  2249.     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
  2250.     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
  2251.     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
  2252.     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
  2253.     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
  2255. #define SET_CMP_FUNC(name) 
  2256.     c->name[0]= name ## 16_c;
  2257.     c->name[1]= name ## 8x8_c;
  2259.     SET_CMP_FUNC(hadamard8_diff)
  2260.     c->hadamard8_diff[4]= hadamard8_intra16_c;
  2261.     SET_CMP_FUNC(dct_sad)
  2262.     SET_CMP_FUNC(dct_max)
  2263. #ifdef CONFIG_GPL
  2264.     SET_CMP_FUNC(dct264_sad)
  2265. #endif
  2266.     c->sad[0]= pix_abs16_c;
  2267.     c->sad[1]= pix_abs8_c;
  2268.     c->sse[0]= sse16_c;
  2269.     c->sse[1]= sse8_c;
  2270.     c->sse[2]= sse4_c;
  2271.     SET_CMP_FUNC(quant_psnr)
  2272.     SET_CMP_FUNC(rd)
  2273.     SET_CMP_FUNC(bit)
  2274.     c->vsad[0]= vsad16_c;
  2275.     c->vsad[4]= vsad_intra16_c;
  2276.     c->vsse[0]= vsse16_c;
  2277.     c->vsse[4]= vsse_intra16_c;
  2278.     c->nsse[0]= nsse16_c;
  2279.     c->nsse[1]= nsse8_c;
  2280. #ifdef CONFIG_SNOW_ENCODER
  2281.     c->w53[0]= w53_16_c;
  2282.     c->w53[1]= w53_8_c;
  2283.     c->w97[0]= w97_16_c;
  2284.     c->w97[1]= w97_8_c;
  2285. #endif
  2287.     c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
  2289.     c->add_bytes= add_bytes_c;
  2290.     c->add_bytes_l2= add_bytes_l2_c;
  2291.     c->diff_bytes= diff_bytes_c;
  2292.     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
  2293.     c->bswap_buf= bswap_buf;
  2294. #ifdef CONFIG_PNG_DECODER
  2295.     c->add_png_paeth_prediction= ff_add_png_paeth_prediction;
  2296. #endif
  2298.     c->h264_v_loop_filter_luma= h264_v_loop_filter_luma_c;
  2299.     c->h264_h_loop_filter_luma= h264_h_loop_filter_luma_c;
  2300.     c->h264_v_loop_filter_luma_intra= h264_v_loop_filter_luma_intra_c;
  2301.     c->h264_h_loop_filter_luma_intra= h264_h_loop_filter_luma_intra_c;
  2302.     c->h264_v_loop_filter_chroma= h264_v_loop_filter_chroma_c;
  2303.     c->h264_h_loop_filter_chroma= h264_h_loop_filter_chroma_c;
  2304.     c->h264_v_loop_filter_chroma_intra= h264_v_loop_filter_chroma_intra_c;
  2305.     c->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_c;
  2306.     c->h264_loop_filter_strength= NULL;
  2308.     /*if (ENABLE_ANY_H263) {
  2309.         c->h263_h_loop_filter= h263_h_loop_filter_c;
  2310.         c->h263_v_loop_filter= h263_v_loop_filter_c;
  2311.     }
  2313.     if (ENABLE_VP3_DECODER || ENABLE_THEORA_DECODER) {
  2314.         c->vp3_h_loop_filter= ff_vp3_h_loop_filter_c;
  2315.         c->vp3_v_loop_filter= ff_vp3_v_loop_filter_c;
  2316.     }*/
  2318.     c->h261_loop_filter= h261_loop_filter_c;
  2320.     c->try_8x8basis= try_8x8basis_c;
  2321.     c->add_8x8basis= add_8x8basis_c;
  2323. #ifdef CONFIG_SNOW_DECODER
  2324.     c->vertical_compose97i = ff_snow_vertical_compose97i;
  2325.     c->horizontal_compose97i = ff_snow_horizontal_compose97i;
  2326.     c->inner_add_yblock = ff_snow_inner_add_yblock;
  2327. #endif
  2329. #ifdef CONFIG_VORBIS_DECODER
  2330.     c->vorbis_inverse_coupling = vorbis_inverse_coupling;
  2331. #endif
  2332. #ifdef CONFIG_AC3_DECODER
  2333.     c->ac3_downmix = ff_ac3_downmix_c;
  2334. #endif
  2335. #ifdef CONFIG_FLAC_ENCODER
  2336.     c->flac_compute_autocorr = ff_flac_compute_autocorr;
  2337. #endif
  2338.     c->vector_fmul = vector_fmul_c;
  2339.     c->vector_fmul_reverse = vector_fmul_reverse_c;
  2340.     c->vector_fmul_add_add = ff_vector_fmul_add_add_c;
  2341.     c->vector_fmul_window = ff_vector_fmul_window_c;
  2342.     c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_c;
  2343.     c->float_to_int16 = ff_float_to_int16_c;
  2344.     c->float_to_int16_interleave = ff_float_to_int16_interleave_c;
  2345.     c->add_int16 = add_int16_c;
  2346.     c->sub_int16 = sub_int16_c;
  2347.     c->scalarproduct_int16 = scalarproduct_int16_c;
  2349.     c->shrink[0]= ff_img_copy_plane;
  2350.     c->shrink[1]= ff_shrink22;
  2351.     c->shrink[2]= ff_shrink44;
  2352.     c->shrink[3]= ff_shrink88;
  2354.     c->prefetch= just_return;
  2356.     memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));
  2357.     memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));
  2359.     /*if (ENABLE_MMX)      dsputil_init_mmx   (c, avctx);
  2360.     if (ENABLE_ARM)      dsputil_init_arm   (c, avctx);
  2361.     if (ENABLE_MLIB)     dsputil_init_mlib  (c, avctx);
  2362.     if (ENABLE_VIS)      dsputil_init_vis   (c, avctx);
  2363.     if (ENABLE_ALPHA)    dsputil_init_alpha (c, avctx);
  2364.     if (ENABLE_PPC)      dsputil_init_ppc   (c, avctx);
  2365.     if (ENABLE_MMI)      dsputil_init_mmi   (c, avctx);
  2366.     if (ENABLE_SH4)      dsputil_init_sh4   (c, avctx);
  2367.     if (ENABLE_BFIN)     dsputil_init_bfin  (c, avctx);*/
  2369.     for(i=0; i<64; i++){
  2370.         if(!c->put_2tap_qpel_pixels_tab[0][i])
  2371.             c->put_2tap_qpel_pixels_tab[0][i]= c->put_h264_qpel_pixels_tab[0][i];
  2372.         if(!c->avg_2tap_qpel_pixels_tab[0][i])
  2373.             c->avg_2tap_qpel_pixels_tab[0][i]= c->avg_h264_qpel_pixels_tab[0][i];
  2374.     }
  2376.     switch(c->idct_permutation_type){
  2377.     case FF_NO_IDCT_PERM:
  2378.         for(i=0; i<64; i++)
  2379.             c->idct_permutation[i]= i;
  2380.         break;
  2381.     case FF_LIBMPEG2_IDCT_PERM:
  2382.         for(i=0; i<64; i++)
  2383.             c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
  2384.         break;
  2385.     case FF_SIMPLE_IDCT_PERM:
  2386.         for(i=0; i<64; i++)
  2387.             c->idct_permutation[i]= simple_mmx_permutation[i];
  2388.         break;
  2389.     case FF_TRANSPOSE_IDCT_PERM:
  2390.         for(i=0; i<64; i++)
  2391.             c->idct_permutation[i]= ((i&7)<<3) | (i>>3);
  2392.         break;
  2393.     case FF_PARTTRANS_IDCT_PERM:
  2394.         for(i=0; i<64; i++)
  2395.             c->idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
  2396.         break;
  2397.     case FF_SSE2_IDCT_PERM:
  2398.         for(i=0; i<64; i++)
  2399.             c->idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];
  2400.         break;
  2401.     default:
  2402.         av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not setn");
  2403.     }
  2404. }