falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
24771 Commits
32 Branches
283MB
Tree: 48966b02cb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '48966b02cb'
${ noResults }
FFmpeg/libavcodec/h264pred.c

1304 lines
43KB
Raw Blame History 

  1. /*

  2.  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder

  3.  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

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

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

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. /**

  23.  * @file

  24.  * H.264 / AVC / MPEG4 part10 prediction functions.

  25.  * @author Michael Niedermayer <michaelni@gmx.at>

  26.  */

  27. 

  28. #include "avcodec.h"

  29. #include "mpegvideo.h"

  30. #include "h264pred.h"

  31. #include "mathops.h"

  32. 

  33. static void pred4x4_vertical_c(uint8_t *src, const uint8_t *topright, int stride){

  34.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  35.     ((uint32_t*)(src+0*stride))[0]= a;

  36.     ((uint32_t*)(src+1*stride))[0]= a;

  37.     ((uint32_t*)(src+2*stride))[0]= a;

  38.     ((uint32_t*)(src+3*stride))[0]= a;

  39. }

  40. 

  41. static void pred4x4_horizontal_c(uint8_t *src, const uint8_t *topright, int stride){

  42.     ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;

  43.     ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;

  44.     ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;

  45.     ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;

  46. }

  47. 

  48. static void pred4x4_dc_c(uint8_t *src, const uint8_t *topright, int stride){

  49.     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]

  50.                    + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;

  51. 

  52.     ((uint32_t*)(src+0*stride))[0]=

  53.     ((uint32_t*)(src+1*stride))[0]=

  54.     ((uint32_t*)(src+2*stride))[0]=

  55.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  56. }

  57. 

  58. static void pred4x4_left_dc_c(uint8_t *src, const uint8_t *topright, int stride){

  59.     const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;

  60. 

  61.     ((uint32_t*)(src+0*stride))[0]=

  62.     ((uint32_t*)(src+1*stride))[0]=

  63.     ((uint32_t*)(src+2*stride))[0]=

  64.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  65. }

  66. 

  67. static void pred4x4_top_dc_c(uint8_t *src, const uint8_t *topright, int stride){

  68.     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;

  69. 

  70.     ((uint32_t*)(src+0*stride))[0]=

  71.     ((uint32_t*)(src+1*stride))[0]=

  72.     ((uint32_t*)(src+2*stride))[0]=

  73.     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;

  74. }

  75. 

  76. static void pred4x4_128_dc_c(uint8_t *src, const uint8_t *topright, int stride){

  77.     ((uint32_t*)(src+0*stride))[0]=

  78.     ((uint32_t*)(src+1*stride))[0]=

  79.     ((uint32_t*)(src+2*stride))[0]=

  80.     ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;

  81. }

  82. 

  83. 

  84. #define LOAD_TOP_RIGHT_EDGE\

  85.     const int av_unused t4= topright[0];\

  86.     const int av_unused t5= topright[1];\

  87.     const int av_unused t6= topright[2];\

  88.     const int av_unused t7= topright[3];\

  89. 

  90. #define LOAD_DOWN_LEFT_EDGE\

  91.     const int av_unused l4= src[-1+4*stride];\

  92.     const int av_unused l5= src[-1+5*stride];\

  93.     const int av_unused l6= src[-1+6*stride];\

  94.     const int av_unused l7= src[-1+7*stride];\

  95. 

  96. #define LOAD_LEFT_EDGE\

  97.     const int av_unused l0= src[-1+0*stride];\

  98.     const int av_unused l1= src[-1+1*stride];\

  99.     const int av_unused l2= src[-1+2*stride];\

  100.     const int av_unused l3= src[-1+3*stride];\

  101. 

  102. #define LOAD_TOP_EDGE\

  103.     const int av_unused t0= src[ 0-1*stride];\

  104.     const int av_unused t1= src[ 1-1*stride];\

  105.     const int av_unused t2= src[ 2-1*stride];\

  106.     const int av_unused t3= src[ 3-1*stride];\

  107. 

  108. static void pred4x4_vertical_vp8_c(uint8_t *src, const uint8_t *topright, int stride){

  109.     const int lt= src[-1-1*stride];

  110.     LOAD_TOP_EDGE

  111.     LOAD_TOP_RIGHT_EDGE

  112.     uint32_t v = PACK_4U8((lt + 2*t0 + t1 + 2) >> 2,

  113.                             (t0 + 2*t1 + t2 + 2) >> 2,

  114.                             (t1 + 2*t2 + t3 + 2) >> 2,

  115.                             (t2 + 2*t3 + t4 + 2) >> 2);

  116. 

  117.     AV_WN32A(src+0*stride, v);

  118.     AV_WN32A(src+1*stride, v);

  119.     AV_WN32A(src+2*stride, v);

  120.     AV_WN32A(src+3*stride, v);

  121. }

  122. 

  123. static void pred4x4_horizontal_vp8_c(uint8_t *src, const uint8_t *topright, int stride){

  124.     const int lt= src[-1-1*stride];

  125.     LOAD_LEFT_EDGE

  126. 

  127.     AV_WN32A(src+0*stride, ((lt + 2*l0 + l1 + 2) >> 2)*0x01010101);

  128.     AV_WN32A(src+1*stride, ((l0 + 2*l1 + l2 + 2) >> 2)*0x01010101);

  129.     AV_WN32A(src+2*stride, ((l1 + 2*l2 + l3 + 2) >> 2)*0x01010101);

  130.     AV_WN32A(src+3*stride, ((l2 + 2*l3 + l3 + 2) >> 2)*0x01010101);

  131. }

  132. 

  133. static void pred4x4_down_right_c(uint8_t *src, const uint8_t *topright, int stride){

  134.     const int lt= src[-1-1*stride];

  135.     LOAD_TOP_EDGE

  136.     LOAD_LEFT_EDGE

  137. 

  138.     src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;

  139.     src[0+2*stride]=

  140.     src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;

  141.     src[0+1*stride]=

  142.     src[1+2*stride]=

  143.     src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;

  144.     src[0+0*stride]=

  145.     src[1+1*stride]=

  146.     src[2+2*stride]=

  147.     src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;

  148.     src[1+0*stride]=

  149.     src[2+1*stride]=

  150.     src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;

  151.     src[2+0*stride]=

  152.     src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  153.     src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  154. }

  155. 

  156. static void pred4x4_down_left_c(uint8_t *src, const uint8_t *topright, int stride){

  157.     LOAD_TOP_EDGE

  158.     LOAD_TOP_RIGHT_EDGE

  159. //    LOAD_LEFT_EDGE

  160. 

  161.     src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;

  162.     src[1+0*stride]=

  163.     src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;

  164.     src[2+0*stride]=

  165.     src[1+1*stride]=

  166.     src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;

  167.     src[3+0*stride]=

  168.     src[2+1*stride]=

  169.     src[1+2*stride]=

  170.     src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;

  171.     src[3+1*stride]=

  172.     src[2+2*stride]=

  173.     src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;

  174.     src[3+2*stride]=

  175.     src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;

  176.     src[3+3*stride]=(t6 + 3*t7 + 2)>>2;

  177. }

  178. 

  179. static void pred4x4_down_left_svq3_c(uint8_t *src, const uint8_t *topright, int stride){

  180.     LOAD_TOP_EDGE

  181.     LOAD_LEFT_EDGE

  182.     const av_unused int unu0= t0;

  183.     const av_unused int unu1= l0;

  184. 

  185.     src[0+0*stride]=(l1 + t1)>>1;

  186.     src[1+0*stride]=

  187.     src[0+1*stride]=(l2 + t2)>>1;

  188.     src[2+0*stride]=

  189.     src[1+1*stride]=

  190.     src[0+2*stride]=

  191.     src[3+0*stride]=

  192.     src[2+1*stride]=

  193.     src[1+2*stride]=

  194.     src[0+3*stride]=

  195.     src[3+1*stride]=

  196.     src[2+2*stride]=

  197.     src[1+3*stride]=

  198.     src[3+2*stride]=

  199.     src[2+3*stride]=

  200.     src[3+3*stride]=(l3 + t3)>>1;

  201. }

  202. 

  203. static void pred4x4_down_left_rv40_c(uint8_t *src, const uint8_t *topright, int stride){

  204.     LOAD_TOP_EDGE

  205.     LOAD_TOP_RIGHT_EDGE

  206.     LOAD_LEFT_EDGE

  207.     LOAD_DOWN_LEFT_EDGE

  208. 

  209.     src[0+0*stride]=(t0 + t2 + 2*t1 + 2 + l0 + l2 + 2*l1 + 2)>>3;

  210.     src[1+0*stride]=

  211.     src[0+1*stride]=(t1 + t3 + 2*t2 + 2 + l1 + l3 + 2*l2 + 2)>>3;

  212.     src[2+0*stride]=

  213.     src[1+1*stride]=

  214.     src[0+2*stride]=(t2 + t4 + 2*t3 + 2 + l2 + l4 + 2*l3 + 2)>>3;

  215.     src[3+0*stride]=

  216.     src[2+1*stride]=

  217.     src[1+2*stride]=

  218.     src[0+3*stride]=(t3 + t5 + 2*t4 + 2 + l3 + l5 + 2*l4 + 2)>>3;

  219.     src[3+1*stride]=

  220.     src[2+2*stride]=

  221.     src[1+3*stride]=(t4 + t6 + 2*t5 + 2 + l4 + l6 + 2*l5 + 2)>>3;

  222.     src[3+2*stride]=

  223.     src[2+3*stride]=(t5 + t7 + 2*t6 + 2 + l5 + l7 + 2*l6 + 2)>>3;

  224.     src[3+3*stride]=(t6 + t7 + 1 + l6 + l7 + 1)>>2;

  225. }

  226. 

  227. static void pred4x4_down_left_rv40_nodown_c(uint8_t *src, const uint8_t *topright, int stride){

  228.     LOAD_TOP_EDGE

  229.     LOAD_TOP_RIGHT_EDGE

  230.     LOAD_LEFT_EDGE

  231. 

  232.     src[0+0*stride]=(t0 + t2 + 2*t1 + 2 + l0 + l2 + 2*l1 + 2)>>3;

  233.     src[1+0*stride]=

  234.     src[0+1*stride]=(t1 + t3 + 2*t2 + 2 + l1 + l3 + 2*l2 + 2)>>3;

  235.     src[2+0*stride]=

  236.     src[1+1*stride]=

  237.     src[0+2*stride]=(t2 + t4 + 2*t3 + 2 + l2 + 3*l3 + 2)>>3;

  238.     src[3+0*stride]=

  239.     src[2+1*stride]=

  240.     src[1+2*stride]=

  241.     src[0+3*stride]=(t3 + t5 + 2*t4 + 2 + l3*4 + 2)>>3;

  242.     src[3+1*stride]=

  243.     src[2+2*stride]=

  244.     src[1+3*stride]=(t4 + t6 + 2*t5 + 2 + l3*4 + 2)>>3;

  245.     src[3+2*stride]=

  246.     src[2+3*stride]=(t5 + t7 + 2*t6 + 2 + l3*4 + 2)>>3;

  247.     src[3+3*stride]=(t6 + t7 + 1 + 2*l3 + 1)>>2;

  248. }

  249. 

  250. static void pred4x4_vertical_right_c(uint8_t *src, const uint8_t *topright, int stride){

  251.     const int lt= src[-1-1*stride];

  252.     LOAD_TOP_EDGE

  253.     LOAD_LEFT_EDGE

  254. 

  255.     src[0+0*stride]=

  256.     src[1+2*stride]=(lt + t0 + 1)>>1;

  257.     src[1+0*stride]=

  258.     src[2+2*stride]=(t0 + t1 + 1)>>1;

  259.     src[2+0*stride]=

  260.     src[3+2*stride]=(t1 + t2 + 1)>>1;

  261.     src[3+0*stride]=(t2 + t3 + 1)>>1;

  262.     src[0+1*stride]=

  263.     src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;

  264.     src[1+1*stride]=

  265.     src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;

  266.     src[2+1*stride]=

  267.     src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  268.     src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  269.     src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;

  270.     src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  271. }

  272. 

  273. static void pred4x4_vertical_left_c(uint8_t *src, const uint8_t *topright, int stride){

  274.     LOAD_TOP_EDGE

  275.     LOAD_TOP_RIGHT_EDGE

  276. 

  277.     src[0+0*stride]=(t0 + t1 + 1)>>1;

  278.     src[1+0*stride]=

  279.     src[0+2*stride]=(t1 + t2 + 1)>>1;

  280.     src[2+0*stride]=

  281.     src[1+2*stride]=(t2 + t3 + 1)>>1;

  282.     src[3+0*stride]=

  283.     src[2+2*stride]=(t3 + t4+ 1)>>1;

  284.     src[3+2*stride]=(t4 + t5+ 1)>>1;

  285.     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  286.     src[1+1*stride]=

  287.     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  288.     src[2+1*stride]=

  289.     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;

  290.     src[3+1*stride]=

  291.     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;

  292.     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;

  293. }

  294. 

  295. static void pred4x4_vertical_left_rv40(uint8_t *src, const uint8_t *topright, int stride,

  296.                                       const int l0, const int l1, const int l2, const int l3, const int l4){

  297.     LOAD_TOP_EDGE

  298.     LOAD_TOP_RIGHT_EDGE

  299. 

  300.     src[0+0*stride]=(2*t0 + 2*t1 + l1 + 2*l2 + l3 + 4)>>3;

  301.     src[1+0*stride]=

  302.     src[0+2*stride]=(t1 + t2 + 1)>>1;

  303.     src[2+0*stride]=

  304.     src[1+2*stride]=(t2 + t3 + 1)>>1;

  305.     src[3+0*stride]=

  306.     src[2+2*stride]=(t3 + t4+ 1)>>1;

  307.     src[3+2*stride]=(t4 + t5+ 1)>>1;

  308.     src[0+1*stride]=(t0 + 2*t1 + t2 + l2 + 2*l3 + l4 + 4)>>3;

  309.     src[1+1*stride]=

  310.     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  311.     src[2+1*stride]=

  312.     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;

  313.     src[3+1*stride]=

  314.     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;

  315.     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;

  316. }

  317. 

  318. static void pred4x4_vertical_left_rv40_c(uint8_t *src, const uint8_t *topright, int stride){

  319.     LOAD_LEFT_EDGE

  320.     LOAD_DOWN_LEFT_EDGE

  321. 

  322.     pred4x4_vertical_left_rv40(src, topright, stride, l0, l1, l2, l3, l4);

  323. }

  324. 

  325. static void pred4x4_vertical_left_rv40_nodown_c(uint8_t *src, const uint8_t *topright, int stride){

  326.     LOAD_LEFT_EDGE

  327. 

  328.     pred4x4_vertical_left_rv40(src, topright, stride, l0, l1, l2, l3, l3);

  329. }

  330. 

  331. static void pred4x4_vertical_left_vp8_c(uint8_t *src, const uint8_t *topright, int stride){

  332.     LOAD_TOP_EDGE

  333.     LOAD_TOP_RIGHT_EDGE

  334. 

  335.     src[0+0*stride]=(t0 + t1 + 1)>>1;

  336.     src[1+0*stride]=

  337.     src[0+2*stride]=(t1 + t2 + 1)>>1;

  338.     src[2+0*stride]=

  339.     src[1+2*stride]=(t2 + t3 + 1)>>1;

  340.     src[3+0*stride]=

  341.     src[2+2*stride]=(t3 + t4 + 1)>>1;

  342.     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  343.     src[1+1*stride]=

  344.     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;

  345.     src[2+1*stride]=

  346.     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;

  347.     src[3+1*stride]=

  348.     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;

  349.     src[3+2*stride]=(t4 + 2*t5 + t6 + 2)>>2;

  350.     src[3+3*stride]=(t5 + 2*t6 + t7 + 2)>>2;

  351. }

  352. 

  353. static void pred4x4_horizontal_up_c(uint8_t *src, const uint8_t *topright, int stride){

  354.     LOAD_LEFT_EDGE

  355. 

  356.     src[0+0*stride]=(l0 + l1 + 1)>>1;

  357.     src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  358.     src[2+0*stride]=

  359.     src[0+1*stride]=(l1 + l2 + 1)>>1;

  360.     src[3+0*stride]=

  361.     src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;

  362.     src[2+1*stride]=

  363.     src[0+2*stride]=(l2 + l3 + 1)>>1;

  364.     src[3+1*stride]=

  365.     src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;

  366.     src[3+2*stride]=

  367.     src[1+3*stride]=

  368.     src[0+3*stride]=

  369.     src[2+2*stride]=

  370.     src[2+3*stride]=

  371.     src[3+3*stride]=l3;

  372. }

  373. 

  374. static void pred4x4_horizontal_up_rv40_c(uint8_t *src, const uint8_t *topright, int stride){

  375.     LOAD_LEFT_EDGE

  376.     LOAD_DOWN_LEFT_EDGE

  377.     LOAD_TOP_EDGE

  378.     LOAD_TOP_RIGHT_EDGE

  379. 

  380.     src[0+0*stride]=(t1 + 2*t2 + t3 + 2*l0 + 2*l1 + 4)>>3;

  381.     src[1+0*stride]=(t2 + 2*t3 + t4 + l0 + 2*l1 + l2 + 4)>>3;

  382.     src[2+0*stride]=

  383.     src[0+1*stride]=(t3 + 2*t4 + t5 + 2*l1 + 2*l2 + 4)>>3;

  384.     src[3+0*stride]=

  385.     src[1+1*stride]=(t4 + 2*t5 + t6 + l1 + 2*l2 + l3 + 4)>>3;

  386.     src[2+1*stride]=

  387.     src[0+2*stride]=(t5 + 2*t6 + t7 + 2*l2 + 2*l3 + 4)>>3;

  388.     src[3+1*stride]=

  389.     src[1+2*stride]=(t6 + 3*t7 + l2 + 3*l3 + 4)>>3;

  390.     src[3+2*stride]=

  391.     src[1+3*stride]=(l3 + 2*l4 + l5 + 2)>>2;

  392.     src[0+3*stride]=

  393.     src[2+2*stride]=(t6 + t7 + l3 + l4 + 2)>>2;

  394.     src[2+3*stride]=(l4 + l5 + 1)>>1;

  395.     src[3+3*stride]=(l4 + 2*l5 + l6 + 2)>>2;

  396. }

  397. 

  398. static void pred4x4_horizontal_up_rv40_nodown_c(uint8_t *src, const uint8_t *topright, int stride){

  399.     LOAD_LEFT_EDGE

  400.     LOAD_TOP_EDGE

  401.     LOAD_TOP_RIGHT_EDGE

  402. 

  403.     src[0+0*stride]=(t1 + 2*t2 + t3 + 2*l0 + 2*l1 + 4)>>3;

  404.     src[1+0*stride]=(t2 + 2*t3 + t4 + l0 + 2*l1 + l2 + 4)>>3;

  405.     src[2+0*stride]=

  406.     src[0+1*stride]=(t3 + 2*t4 + t5 + 2*l1 + 2*l2 + 4)>>3;

  407.     src[3+0*stride]=

  408.     src[1+1*stride]=(t4 + 2*t5 + t6 + l1 + 2*l2 + l3 + 4)>>3;

  409.     src[2+1*stride]=

  410.     src[0+2*stride]=(t5 + 2*t6 + t7 + 2*l2 + 2*l3 + 4)>>3;

  411.     src[3+1*stride]=

  412.     src[1+2*stride]=(t6 + 3*t7 + l2 + 3*l3 + 4)>>3;

  413.     src[3+2*stride]=

  414.     src[1+3*stride]=l3;

  415.     src[0+3*stride]=

  416.     src[2+2*stride]=(t6 + t7 + 2*l3 + 2)>>2;

  417.     src[2+3*stride]=

  418.     src[3+3*stride]=l3;

  419. }

  420. 

  421. static void pred4x4_horizontal_down_c(uint8_t *src, const uint8_t *topright, int stride){

  422.     const int lt= src[-1-1*stride];

  423.     LOAD_TOP_EDGE

  424.     LOAD_LEFT_EDGE

  425. 

  426.     src[0+0*stride]=

  427.     src[2+1*stride]=(lt + l0 + 1)>>1;

  428.     src[1+0*stride]=

  429.     src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;

  430.     src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;

  431.     src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;

  432.     src[0+1*stride]=

  433.     src[2+2*stride]=(l0 + l1 + 1)>>1;

  434.     src[1+1*stride]=

  435.     src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;

  436.     src[0+2*stride]=

  437.     src[2+3*stride]=(l1 + l2+ 1)>>1;

  438.     src[1+2*stride]=

  439.     src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;

  440.     src[0+3*stride]=(l2 + l3 + 1)>>1;

  441.     src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;

  442. }

  443. 

  444. static void pred4x4_tm_vp8_c(uint8_t *src, const uint8_t *topright, int stride){

  445.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP - src[-1-stride];

  446.     uint8_t *top = src-stride;

  447.     int y;

  448. 

  449.     for (y = 0; y < 4; y++) {

  450.         uint8_t *cm_in = cm + src[-1];

  451.         src[0] = cm_in[top[0]];

  452.         src[1] = cm_in[top[1]];

  453.         src[2] = cm_in[top[2]];

  454.         src[3] = cm_in[top[3]];

  455.         src += stride;

  456.     }

  457. }

  458. 

  459. static void pred16x16_vertical_c(uint8_t *src, int stride){

  460.     int i;

  461.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  462.     const uint32_t b= ((uint32_t*)(src-stride))[1];

  463.     const uint32_t c= ((uint32_t*)(src-stride))[2];

  464.     const uint32_t d= ((uint32_t*)(src-stride))[3];

  465. 

  466.     for(i=0; i<16; i++){

  467.         ((uint32_t*)(src+i*stride))[0]= a;

  468.         ((uint32_t*)(src+i*stride))[1]= b;

  469.         ((uint32_t*)(src+i*stride))[2]= c;

  470.         ((uint32_t*)(src+i*stride))[3]= d;

  471.     }

  472. }

  473. 

  474. static void pred16x16_horizontal_c(uint8_t *src, int stride){

  475.     int i;

  476. 

  477.     for(i=0; i<16; i++){

  478.         ((uint32_t*)(src+i*stride))[0]=

  479.         ((uint32_t*)(src+i*stride))[1]=

  480.         ((uint32_t*)(src+i*stride))[2]=

  481.         ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;

  482.     }

  483. }

  484. 

  485. static void pred16x16_dc_c(uint8_t *src, int stride){

  486.     int i, dc=0;

  487. 

  488.     for(i=0;i<16; i++){

  489.         dc+= src[-1+i*stride];

  490.     }

  491. 

  492.     for(i=0;i<16; i++){

  493.         dc+= src[i-stride];

  494.     }

  495. 

  496.     dc= 0x01010101*((dc + 16)>>5);

  497. 

  498.     for(i=0; i<16; i++){

  499.         ((uint32_t*)(src+i*stride))[0]=

  500.         ((uint32_t*)(src+i*stride))[1]=

  501.         ((uint32_t*)(src+i*stride))[2]=

  502.         ((uint32_t*)(src+i*stride))[3]= dc;

  503.     }

  504. }

  505. 

  506. static void pred16x16_left_dc_c(uint8_t *src, int stride){

  507.     int i, dc=0;

  508. 

  509.     for(i=0;i<16; i++){

  510.         dc+= src[-1+i*stride];

  511.     }

  512. 

  513.     dc= 0x01010101*((dc + 8)>>4);

  514. 

  515.     for(i=0; i<16; i++){

  516.         ((uint32_t*)(src+i*stride))[0]=

  517.         ((uint32_t*)(src+i*stride))[1]=

  518.         ((uint32_t*)(src+i*stride))[2]=

  519.         ((uint32_t*)(src+i*stride))[3]= dc;

  520.     }

  521. }

  522. 

  523. static void pred16x16_top_dc_c(uint8_t *src, int stride){

  524.     int i, dc=0;

  525. 

  526.     for(i=0;i<16; i++){

  527.         dc+= src[i-stride];

  528.     }

  529.     dc= 0x01010101*((dc + 8)>>4);

  530. 

  531.     for(i=0; i<16; i++){

  532.         ((uint32_t*)(src+i*stride))[0]=

  533.         ((uint32_t*)(src+i*stride))[1]=

  534.         ((uint32_t*)(src+i*stride))[2]=

  535.         ((uint32_t*)(src+i*stride))[3]= dc;

  536.     }

  537. }

  538. 

  539. static void pred16x16_128_dc_c(uint8_t *src, int stride){

  540.     int i;

  541. 

  542.     for(i=0; i<16; i++){

  543.         ((uint32_t*)(src+i*stride))[0]=

  544.         ((uint32_t*)(src+i*stride))[1]=

  545.         ((uint32_t*)(src+i*stride))[2]=

  546.         ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;

  547.     }

  548. }

  549. 

  550. static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3, const int rv40){

  551.   int i, j, k;

  552.   int a;

  553.   uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  554.   const uint8_t * const src0 = src+7-stride;

  555.   const uint8_t *src1 = src+8*stride-1;

  556.   const uint8_t *src2 = src1-2*stride;      // == src+6*stride-1;

  557.   int H = src0[1] - src0[-1];

  558.   int V = src1[0] - src2[ 0];

  559.   for(k=2; k<=8; ++k) {

  560.     src1 += stride; src2 -= stride;

  561.     H += k*(src0[k] - src0[-k]);

  562.     V += k*(src1[0] - src2[ 0]);

  563.   }

  564.   if(svq3){

  565.     H = ( 5*(H/4) ) / 16;

  566.     V = ( 5*(V/4) ) / 16;

  567. 

  568.     /* required for 100% accuracy */

  569.     i = H; H = V; V = i;

  570.   }else if(rv40){

  571.     H = ( H + (H>>2) ) >> 4;

  572.     V = ( V + (V>>2) ) >> 4;

  573.   }else{

  574.     H = ( 5*H+32 ) >> 6;

  575.     V = ( 5*V+32 ) >> 6;

  576.   }

  577. 

  578.   a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);

  579.   for(j=16; j>0; --j) {

  580.     int b = a;

  581.     a += V;

  582.     for(i=-16; i<0; i+=4) {

  583.       src[16+i] = cm[ (b    ) >> 5 ];

  584.       src[17+i] = cm[ (b+  H) >> 5 ];

  585.       src[18+i] = cm[ (b+2*H) >> 5 ];

  586.       src[19+i] = cm[ (b+3*H) >> 5 ];

  587.       b += 4*H;

  588.     }

  589.     src += stride;

  590.   }

  591. }

  592. 

  593. static void pred16x16_plane_c(uint8_t *src, int stride){

  594.     pred16x16_plane_compat_c(src, stride, 0, 0);

  595. }

  596. 

  597. static void pred16x16_plane_svq3_c(uint8_t *src, int stride){

  598.     pred16x16_plane_compat_c(src, stride, 1, 0);

  599. }

  600. 

  601. static void pred16x16_plane_rv40_c(uint8_t *src, int stride){

  602.     pred16x16_plane_compat_c(src, stride, 0, 1);

  603. }

  604. 

  605. static void pred16x16_tm_vp8_c(uint8_t *src, int stride){

  606.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP - src[-1-stride];

  607.     uint8_t *top = src-stride;

  608.     int y;

  609. 

  610.     for (y = 0; y < 16; y++) {

  611.         uint8_t *cm_in = cm + src[-1];

  612.         src[0]  = cm_in[top[0]];

  613.         src[1]  = cm_in[top[1]];

  614.         src[2]  = cm_in[top[2]];

  615.         src[3]  = cm_in[top[3]];

  616.         src[4]  = cm_in[top[4]];

  617.         src[5]  = cm_in[top[5]];

  618.         src[6]  = cm_in[top[6]];

  619.         src[7]  = cm_in[top[7]];

  620.         src[8]  = cm_in[top[8]];

  621.         src[9]  = cm_in[top[9]];

  622.         src[10] = cm_in[top[10]];

  623.         src[11] = cm_in[top[11]];

  624.         src[12] = cm_in[top[12]];

  625.         src[13] = cm_in[top[13]];

  626.         src[14] = cm_in[top[14]];

  627.         src[15] = cm_in[top[15]];

  628.         src += stride;

  629.     }

  630. }

  631. 

  632. static void pred8x8_vertical_c(uint8_t *src, int stride){

  633.     int i;

  634.     const uint32_t a= ((uint32_t*)(src-stride))[0];

  635.     const uint32_t b= ((uint32_t*)(src-stride))[1];

  636. 

  637.     for(i=0; i<8; i++){

  638.         ((uint32_t*)(src+i*stride))[0]= a;

  639.         ((uint32_t*)(src+i*stride))[1]= b;

  640.     }

  641. }

  642. 

  643. static void pred8x8_horizontal_c(uint8_t *src, int stride){

  644.     int i;

  645. 

  646.     for(i=0; i<8; i++){

  647.         ((uint32_t*)(src+i*stride))[0]=

  648.         ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;

  649.     }

  650. }

  651. 

  652. static void pred8x8_128_dc_c(uint8_t *src, int stride){

  653.     int i;

  654. 

  655.     for(i=0; i<8; i++){

  656.         ((uint32_t*)(src+i*stride))[0]=

  657.         ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;

  658.     }

  659. }

  660. 

  661. static void pred8x8_left_dc_c(uint8_t *src, int stride){

  662.     int i;

  663.     int dc0, dc2;

  664. 

  665.     dc0=dc2=0;

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

  667.         dc0+= src[-1+i*stride];

  668.         dc2+= src[-1+(i+4)*stride];

  669.     }

  670.     dc0= 0x01010101*((dc0 + 2)>>2);

  671.     dc2= 0x01010101*((dc2 + 2)>>2);

  672. 

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

  674.         ((uint32_t*)(src+i*stride))[0]=

  675.         ((uint32_t*)(src+i*stride))[1]= dc0;

  676.     }

  677.     for(i=4; i<8; i++){

  678.         ((uint32_t*)(src+i*stride))[0]=

  679.         ((uint32_t*)(src+i*stride))[1]= dc2;

  680.     }

  681. }

  682. 

  683. static void pred8x8_left_dc_rv40_c(uint8_t *src, int stride){

  684.     int i;

  685.     int dc0;

  686. 

  687.     dc0=0;

  688.     for(i=0;i<8; i++)

  689.         dc0+= src[-1+i*stride];

  690.     dc0= 0x01010101*((dc0 + 4)>>3);

  691. 

  692.     for(i=0; i<8; i++){

  693.         ((uint32_t*)(src+i*stride))[0]=

  694.         ((uint32_t*)(src+i*stride))[1]= dc0;

  695.     }

  696. }

  697. 

  698. static void pred8x8_top_dc_c(uint8_t *src, int stride){

  699.     int i;

  700.     int dc0, dc1;

  701. 

  702.     dc0=dc1=0;

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

  704.         dc0+= src[i-stride];

  705.         dc1+= src[4+i-stride];

  706.     }

  707.     dc0= 0x01010101*((dc0 + 2)>>2);

  708.     dc1= 0x01010101*((dc1 + 2)>>2);

  709. 

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

  711.         ((uint32_t*)(src+i*stride))[0]= dc0;

  712.         ((uint32_t*)(src+i*stride))[1]= dc1;

  713.     }

  714.     for(i=4; i<8; i++){

  715.         ((uint32_t*)(src+i*stride))[0]= dc0;

  716.         ((uint32_t*)(src+i*stride))[1]= dc1;

  717.     }

  718. }

  719. 

  720. static void pred8x8_top_dc_rv40_c(uint8_t *src, int stride){

  721.     int i;

  722.     int dc0;

  723. 

  724.     dc0=0;

  725.     for(i=0;i<8; i++)

  726.         dc0+= src[i-stride];

  727.     dc0= 0x01010101*((dc0 + 4)>>3);

  728. 

  729.     for(i=0; i<8; i++){

  730.         ((uint32_t*)(src+i*stride))[0]=

  731.         ((uint32_t*)(src+i*stride))[1]= dc0;

  732.     }

  733. }

  734. 

  735. 

  736. static void pred8x8_dc_c(uint8_t *src, int stride){

  737.     int i;

  738.     int dc0, dc1, dc2, dc3;

  739. 

  740.     dc0=dc1=dc2=0;

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

  742.         dc0+= src[-1+i*stride] + src[i-stride];

  743.         dc1+= src[4+i-stride];

  744.         dc2+= src[-1+(i+4)*stride];

  745.     }

  746.     dc3= 0x01010101*((dc1 + dc2 + 4)>>3);

  747.     dc0= 0x01010101*((dc0 + 4)>>3);

  748.     dc1= 0x01010101*((dc1 + 2)>>2);

  749.     dc2= 0x01010101*((dc2 + 2)>>2);

  750. 

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

  752.         ((uint32_t*)(src+i*stride))[0]= dc0;

  753.         ((uint32_t*)(src+i*stride))[1]= dc1;

  754.     }

  755.     for(i=4; i<8; i++){

  756.         ((uint32_t*)(src+i*stride))[0]= dc2;

  757.         ((uint32_t*)(src+i*stride))[1]= dc3;

  758.     }

  759. }

  760. 

  761. //the following 4 function should not be optimized!

  762. static void pred8x8_mad_cow_dc_l0t(uint8_t *src, int stride){

  763.     pred8x8_top_dc_c(src, stride);

  764.     pred4x4_dc_c(src, NULL, stride);

  765. }

  766. 

  767. static void pred8x8_mad_cow_dc_0lt(uint8_t *src, int stride){

  768.     pred8x8_dc_c(src, stride);

  769.     pred4x4_top_dc_c(src, NULL, stride);

  770. }

  771. 

  772. static void pred8x8_mad_cow_dc_l00(uint8_t *src, int stride){

  773.     pred8x8_left_dc_c(src, stride);

  774.     pred4x4_128_dc_c(src + 4*stride    , NULL, stride);

  775.     pred4x4_128_dc_c(src + 4*stride + 4, NULL, stride);

  776. }

  777. 

  778. static void pred8x8_mad_cow_dc_0l0(uint8_t *src, int stride){

  779.     pred8x8_left_dc_c(src, stride);

  780.     pred4x4_128_dc_c(src    , NULL, stride);

  781.     pred4x4_128_dc_c(src + 4, NULL, stride);

  782. }

  783. 

  784. static void pred8x8_dc_rv40_c(uint8_t *src, int stride){

  785.     int i;

  786.     int dc0=0;

  787. 

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

  789.         dc0+= src[-1+i*stride] + src[i-stride];

  790.         dc0+= src[4+i-stride];

  791.         dc0+= src[-1+(i+4)*stride];

  792.     }

  793.     dc0= 0x01010101*((dc0 + 8)>>4);

  794. 

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

  796.         ((uint32_t*)(src+i*stride))[0]= dc0;

  797.         ((uint32_t*)(src+i*stride))[1]= dc0;

  798.     }

  799.     for(i=4; i<8; i++){

  800.         ((uint32_t*)(src+i*stride))[0]= dc0;

  801.         ((uint32_t*)(src+i*stride))[1]= dc0;

  802.     }

  803. }

  804. 

  805. static void pred8x8_plane_c(uint8_t *src, int stride){

  806.   int j, k;

  807.   int a;

  808.   uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  809.   const uint8_t * const src0 = src+3-stride;

  810.   const uint8_t *src1 = src+4*stride-1;

  811.   const uint8_t *src2 = src1-2*stride;      // == src+2*stride-1;

  812.   int H = src0[1] - src0[-1];

  813.   int V = src1[0] - src2[ 0];

  814.   for(k=2; k<=4; ++k) {

  815.     src1 += stride; src2 -= stride;

  816.     H += k*(src0[k] - src0[-k]);

  817.     V += k*(src1[0] - src2[ 0]);

  818.   }

  819.   H = ( 17*H+16 ) >> 5;

  820.   V = ( 17*V+16 ) >> 5;

  821. 

  822.   a = 16*(src1[0] + src2[8]+1) - 3*(V+H);

  823.   for(j=8; j>0; --j) {

  824.     int b = a;

  825.     a += V;

  826.     src[0] = cm[ (b    ) >> 5 ];

  827.     src[1] = cm[ (b+  H) >> 5 ];

  828.     src[2] = cm[ (b+2*H) >> 5 ];

  829.     src[3] = cm[ (b+3*H) >> 5 ];

  830.     src[4] = cm[ (b+4*H) >> 5 ];

  831.     src[5] = cm[ (b+5*H) >> 5 ];

  832.     src[6] = cm[ (b+6*H) >> 5 ];

  833.     src[7] = cm[ (b+7*H) >> 5 ];

  834.     src += stride;

  835.   }

  836. }

  837. 

  838. static void pred8x8_tm_vp8_c(uint8_t *src, int stride){

  839.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP - src[-1-stride];

  840.     uint8_t *top = src-stride;

  841.     int y;

  842. 

  843.     for (y = 0; y < 8; y++) {

  844.         uint8_t *cm_in = cm + src[-1];

  845.         src[0] = cm_in[top[0]];

  846.         src[1] = cm_in[top[1]];

  847.         src[2] = cm_in[top[2]];

  848.         src[3] = cm_in[top[3]];

  849.         src[4] = cm_in[top[4]];

  850.         src[5] = cm_in[top[5]];

  851.         src[6] = cm_in[top[6]];

  852.         src[7] = cm_in[top[7]];

  853.         src += stride;

  854.     }

  855. }

  856. 

  857. #define SRC(x,y) src[(x)+(y)*stride]

  858. #define PL(y) \

  859.     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;

  860. #define PREDICT_8x8_LOAD_LEFT \

  861.     const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \

  862.                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \

  863.     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \

  864.     const int l7 av_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2

  865. 

  866. #define PT(x) \

  867.     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;

  868. #define PREDICT_8x8_LOAD_TOP \

  869.     const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \

  870.                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \

  871.     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \

  872.     const int t7 av_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \

  873.                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2

  874. 

  875. #define PTR(x) \

  876.     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;

  877. #define PREDICT_8x8_LOAD_TOPRIGHT \

  878.     int t8, t9, t10, t11, t12, t13, t14, t15; \

  879.     if(has_topright) { \

  880.         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \

  881.         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \

  882.     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);

  883. 

  884. #define PREDICT_8x8_LOAD_TOPLEFT \

  885.     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2

  886. 

  887. #define PREDICT_8x8_DC(v) \

  888.     int y; \

  889.     for( y = 0; y < 8; y++ ) { \

  890.         ((uint32_t*)src)[0] = \

  891.         ((uint32_t*)src)[1] = v; \

  892.         src += stride; \

  893.     }

  894. 

  895. static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  896. {

  897.     PREDICT_8x8_DC(0x80808080);

  898. }

  899. static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  900. {

  901.     PREDICT_8x8_LOAD_LEFT;

  902.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;

  903.     PREDICT_8x8_DC(dc);

  904. }

  905. static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  906. {

  907.     PREDICT_8x8_LOAD_TOP;

  908.     const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;

  909.     PREDICT_8x8_DC(dc);

  910. }

  911. static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  912. {

  913.     PREDICT_8x8_LOAD_LEFT;

  914.     PREDICT_8x8_LOAD_TOP;

  915.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7

  916.                          +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;

  917.     PREDICT_8x8_DC(dc);

  918. }

  919. static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  920. {

  921.     PREDICT_8x8_LOAD_LEFT;

  922. #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\

  923.                ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y

  924.     ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);

  925. #undef ROW

  926. }

  927. static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  928. {

  929.     int y;

  930.     PREDICT_8x8_LOAD_TOP;

  931.     src[0] = t0;

  932.     src[1] = t1;

  933.     src[2] = t2;

  934.     src[3] = t3;

  935.     src[4] = t4;

  936.     src[5] = t5;

  937.     src[6] = t6;

  938.     src[7] = t7;

  939.     for( y = 1; y < 8; y++ )

  940.         *(uint64_t*)(src+y*stride) = *(uint64_t*)src;

  941. }

  942. static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  943. {

  944.     PREDICT_8x8_LOAD_TOP;

  945.     PREDICT_8x8_LOAD_TOPRIGHT;

  946.     SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;

  947.     SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;

  948.     SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;

  949.     SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;

  950.     SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;

  951.     SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;

  952.     SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;

  953.     SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;

  954.     SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;

  955.     SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;

  956.     SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;

  957.     SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;

  958.     SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;

  959.     SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;

  960.     SRC(7,7)= (t14 + 3*t15 + 2) >> 2;

  961. }

  962. static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  963. {

  964.     PREDICT_8x8_LOAD_TOP;

  965.     PREDICT_8x8_LOAD_LEFT;

  966.     PREDICT_8x8_LOAD_TOPLEFT;

  967.     SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;

  968.     SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;

  969.     SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;

  970.     SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;

  971.     SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;

  972.     SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;

  973.     SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;

  974.     SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;

  975.     SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;

  976.     SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;

  977.     SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;

  978.     SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;

  979.     SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;

  980.     SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;

  981.     SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;

  982. 

  983. }

  984. static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  985. {

  986.     PREDICT_8x8_LOAD_TOP;

  987.     PREDICT_8x8_LOAD_LEFT;

  988.     PREDICT_8x8_LOAD_TOPLEFT;

  989.     SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;

  990.     SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;

  991.     SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;

  992.     SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;

  993.     SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;

  994.     SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;

  995.     SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;

  996.     SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;

  997.     SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;

  998.     SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;

  999.     SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;

  1000.     SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;

  1001.     SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;

  1002.     SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;

  1003.     SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;

  1004.     SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;

  1005.     SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;

  1006.     SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;

  1007.     SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;

  1008.     SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;

  1009.     SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;

  1010.     SRC(7,0)= (t6 + t7 + 1) >> 1;

  1011. }

  1012. static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  1013. {

  1014.     PREDICT_8x8_LOAD_TOP;

  1015.     PREDICT_8x8_LOAD_LEFT;

  1016.     PREDICT_8x8_LOAD_TOPLEFT;

  1017.     SRC(0,7)= (l6 + l7 + 1) >> 1;

  1018.     SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;

  1019.     SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;

  1020.     SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;

  1021.     SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;

  1022.     SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;

  1023.     SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;

  1024.     SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;

  1025.     SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;

  1026.     SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;

  1027.     SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;

  1028.     SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;

  1029.     SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;

  1030.     SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;

  1031.     SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;

  1032.     SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;

  1033.     SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;

  1034.     SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;

  1035.     SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;

  1036.     SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;

  1037.     SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;

  1038.     SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;

  1039. }

  1040. static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  1041. {

  1042.     PREDICT_8x8_LOAD_TOP;

  1043.     PREDICT_8x8_LOAD_TOPRIGHT;

  1044.     SRC(0,0)= (t0 + t1 + 1) >> 1;

  1045.     SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;

  1046.     SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;

  1047.     SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;

  1048.     SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;

  1049.     SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;

  1050.     SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;

  1051.     SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;

  1052.     SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;

  1053.     SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;

  1054.     SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;

  1055.     SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;

  1056.     SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;

  1057.     SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;

  1058.     SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;

  1059.     SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;

  1060.     SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;

  1061.     SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;

  1062.     SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;

  1063.     SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;

  1064.     SRC(7,6)= (t10 + t11 + 1) >> 1;

  1065.     SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;

  1066. }

  1067. static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)

  1068. {

  1069.     PREDICT_8x8_LOAD_LEFT;

  1070.     SRC(0,0)= (l0 + l1 + 1) >> 1;

  1071.     SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;

  1072.     SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;

  1073.     SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;

  1074.     SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;

  1075.     SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;

  1076.     SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;

  1077.     SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;

  1078.     SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;

  1079.     SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;

  1080.     SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;

  1081.     SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;

  1082.     SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;

  1083.     SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;

  1084.     SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=

  1085.     SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=

  1086.     SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=

  1087.     SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;

  1088. }

  1089. #undef PREDICT_8x8_LOAD_LEFT

  1090. #undef PREDICT_8x8_LOAD_TOP

  1091. #undef PREDICT_8x8_LOAD_TOPLEFT

  1092. #undef PREDICT_8x8_LOAD_TOPRIGHT

  1093. #undef PREDICT_8x8_DC

  1094. #undef PTR

  1095. #undef PT

  1096. #undef PL

  1097. #undef SRC

  1098. 

  1099. static void pred4x4_vertical_add_c(uint8_t *pix, const DCTELEM *block, int stride){

  1100.     int i;

  1101.     pix -= stride;

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

  1103.         uint8_t v = pix[0];

  1104.         pix[1*stride]= v += block[0];

  1105.         pix[2*stride]= v += block[4];

  1106.         pix[3*stride]= v += block[8];

  1107.         pix[4*stride]= v +  block[12];

  1108.         pix++;

  1109.         block++;

  1110.     }

  1111. }

  1112. 

  1113. static void pred4x4_horizontal_add_c(uint8_t *pix, const DCTELEM *block, int stride){

  1114.     int i;

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

  1116.         uint8_t v = pix[-1];

  1117.         pix[0]= v += block[0];

  1118.         pix[1]= v += block[1];

  1119.         pix[2]= v += block[2];

  1120.         pix[3]= v +  block[3];

  1121.         pix+= stride;

  1122.         block+= 4;

  1123.     }

  1124. }

  1125. 

  1126. static void pred8x8l_vertical_add_c(uint8_t *pix, const DCTELEM *block, int stride){

  1127.     int i;

  1128.     pix -= stride;

  1129.     for(i=0; i<8; i++){

  1130.         uint8_t v = pix[0];

  1131.         pix[1*stride]= v += block[0];

  1132.         pix[2*stride]= v += block[8];

  1133.         pix[3*stride]= v += block[16];

  1134.         pix[4*stride]= v += block[24];

  1135.         pix[5*stride]= v += block[32];

  1136.         pix[6*stride]= v += block[40];

  1137.         pix[7*stride]= v += block[48];

  1138.         pix[8*stride]= v +  block[56];

  1139.         pix++;

  1140.         block++;

  1141.     }

  1142. }

  1143. 

  1144. static void pred8x8l_horizontal_add_c(uint8_t *pix, const DCTELEM *block, int stride){

  1145.     int i;

  1146.     for(i=0; i<8; i++){

  1147.         uint8_t v = pix[-1];

  1148.         pix[0]= v += block[0];

  1149.         pix[1]= v += block[1];

  1150.         pix[2]= v += block[2];

  1151.         pix[3]= v += block[3];

  1152.         pix[4]= v += block[4];

  1153.         pix[5]= v += block[5];

  1154.         pix[6]= v += block[6];

  1155.         pix[7]= v +  block[7];

  1156.         pix+= stride;

  1157.         block+= 8;

  1158.     }

  1159. }

  1160. 

  1161. static void pred16x16_vertical_add_c(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){

  1162.     int i;

  1163.     for(i=0; i<16; i++)

  1164.         pred4x4_vertical_add_c(pix + block_offset[i], block + i*16, stride);

  1165. }

  1166. 

  1167. static void pred16x16_horizontal_add_c(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){

  1168.     int i;

  1169.     for(i=0; i<16; i++)

  1170.         pred4x4_horizontal_add_c(pix + block_offset[i], block + i*16, stride);

  1171. }

  1172. 

  1173. static void pred8x8_vertical_add_c(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){

  1174.     int i;

  1175.     for(i=0; i<4; i++)

  1176.         pred4x4_vertical_add_c(pix + block_offset[i], block + i*16, stride);

  1177. }

  1178. 

  1179. static void pred8x8_horizontal_add_c(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){

  1180.     int i;

  1181.     for(i=0; i<4; i++)

  1182.         pred4x4_horizontal_add_c(pix + block_offset[i], block + i*16, stride);

  1183. }

  1184. 

  1185. 

  1186. /**

  1187.  * Set the intra prediction function pointers.

  1188.  */

  1189. void ff_h264_pred_init(H264PredContext *h, int codec_id){

  1190. //    MpegEncContext * const s = &h->s;

  1191. 

  1192.     if(codec_id != CODEC_ID_RV40){

  1193.         if(codec_id == CODEC_ID_VP8) {

  1194.             h->pred4x4[VERT_PRED       ]= pred4x4_vertical_vp8_c;

  1195.             h->pred4x4[HOR_PRED        ]= pred4x4_horizontal_vp8_c;

  1196.         } else {

  1197.             h->pred4x4[VERT_PRED       ]= pred4x4_vertical_c;

  1198.             h->pred4x4[HOR_PRED        ]= pred4x4_horizontal_c;

  1199.         }

  1200.         h->pred4x4[DC_PRED             ]= pred4x4_dc_c;

  1201.         if(codec_id == CODEC_ID_SVQ3)

  1202.             h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_svq3_c;

  1203.         else

  1204.             h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;

  1205.         h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;

  1206.         h->pred4x4[VERT_RIGHT_PRED     ]= pred4x4_vertical_right_c;

  1207.         h->pred4x4[HOR_DOWN_PRED       ]= pred4x4_horizontal_down_c;

  1208.         if (codec_id == CODEC_ID_VP8) {

  1209.             h->pred4x4[VERT_LEFT_PRED  ]= pred4x4_vertical_left_vp8_c;

  1210.         } else

  1211.             h->pred4x4[VERT_LEFT_PRED  ]= pred4x4_vertical_left_c;

  1212.         h->pred4x4[HOR_UP_PRED         ]= pred4x4_horizontal_up_c;

  1213.         h->pred4x4[LEFT_DC_PRED        ]= pred4x4_left_dc_c;

  1214.         h->pred4x4[TOP_DC_PRED         ]= pred4x4_top_dc_c;

  1215.         h->pred4x4[DC_128_PRED         ]= pred4x4_128_dc_c;

  1216.         if(codec_id == CODEC_ID_VP8)

  1217.             h->pred4x4[TM_VP8_PRED     ]= pred4x4_tm_vp8_c;

  1218.     }else{

  1219.         h->pred4x4[VERT_PRED           ]= pred4x4_vertical_c;

  1220.         h->pred4x4[HOR_PRED            ]= pred4x4_horizontal_c;

  1221.         h->pred4x4[DC_PRED             ]= pred4x4_dc_c;

  1222.         h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_rv40_c;

  1223.         h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;

  1224.         h->pred4x4[VERT_RIGHT_PRED     ]= pred4x4_vertical_right_c;

  1225.         h->pred4x4[HOR_DOWN_PRED       ]= pred4x4_horizontal_down_c;

  1226.         h->pred4x4[VERT_LEFT_PRED      ]= pred4x4_vertical_left_rv40_c;

  1227.         h->pred4x4[HOR_UP_PRED         ]= pred4x4_horizontal_up_rv40_c;

  1228.         h->pred4x4[LEFT_DC_PRED        ]= pred4x4_left_dc_c;

  1229.         h->pred4x4[TOP_DC_PRED         ]= pred4x4_top_dc_c;

  1230.         h->pred4x4[DC_128_PRED         ]= pred4x4_128_dc_c;

  1231.         h->pred4x4[DIAG_DOWN_LEFT_PRED_RV40_NODOWN]= pred4x4_down_left_rv40_nodown_c;

  1232.         h->pred4x4[HOR_UP_PRED_RV40_NODOWN]= pred4x4_horizontal_up_rv40_nodown_c;

  1233.         h->pred4x4[VERT_LEFT_PRED_RV40_NODOWN]= pred4x4_vertical_left_rv40_nodown_c;

  1234.     }

  1235. 

  1236.     h->pred8x8l[VERT_PRED           ]= pred8x8l_vertical_c;

  1237.     h->pred8x8l[HOR_PRED            ]= pred8x8l_horizontal_c;

  1238.     h->pred8x8l[DC_PRED             ]= pred8x8l_dc_c;

  1239.     h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;

  1240.     h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;

  1241.     h->pred8x8l[VERT_RIGHT_PRED     ]= pred8x8l_vertical_right_c;

  1242.     h->pred8x8l[HOR_DOWN_PRED       ]= pred8x8l_horizontal_down_c;

  1243.     h->pred8x8l[VERT_LEFT_PRED      ]= pred8x8l_vertical_left_c;

  1244.     h->pred8x8l[HOR_UP_PRED         ]= pred8x8l_horizontal_up_c;

  1245.     h->pred8x8l[LEFT_DC_PRED        ]= pred8x8l_left_dc_c;

  1246.     h->pred8x8l[TOP_DC_PRED         ]= pred8x8l_top_dc_c;

  1247.     h->pred8x8l[DC_128_PRED         ]= pred8x8l_128_dc_c;

  1248. 

  1249.     h->pred8x8[VERT_PRED8x8   ]= pred8x8_vertical_c;

  1250.     h->pred8x8[HOR_PRED8x8    ]= pred8x8_horizontal_c;

  1251.     if (codec_id != CODEC_ID_VP8) {

  1252.         h->pred8x8[PLANE_PRED8x8]= pred8x8_plane_c;

  1253.     } else

  1254.         h->pred8x8[PLANE_PRED8x8]= pred8x8_tm_vp8_c;

  1255.     if(codec_id != CODEC_ID_RV40 && codec_id != CODEC_ID_VP8){

  1256.         h->pred8x8[DC_PRED8x8     ]= pred8x8_dc_c;

  1257.         h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;

  1258.         h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;

  1259.         h->pred8x8[ALZHEIMER_DC_L0T_PRED8x8 ]= pred8x8_mad_cow_dc_l0t;

  1260.         h->pred8x8[ALZHEIMER_DC_0LT_PRED8x8 ]= pred8x8_mad_cow_dc_0lt;

  1261.         h->pred8x8[ALZHEIMER_DC_L00_PRED8x8 ]= pred8x8_mad_cow_dc_l00;

  1262.         h->pred8x8[ALZHEIMER_DC_0L0_PRED8x8 ]= pred8x8_mad_cow_dc_0l0;

  1263.     }else{

  1264.         h->pred8x8[DC_PRED8x8     ]= pred8x8_dc_rv40_c;

  1265.         h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_rv40_c;

  1266.         h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_rv40_c;

  1267.     }

  1268.     h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;

  1269. 

  1270.     h->pred16x16[DC_PRED8x8     ]= pred16x16_dc_c;

  1271.     h->pred16x16[VERT_PRED8x8   ]= pred16x16_vertical_c;

  1272.     h->pred16x16[HOR_PRED8x8    ]= pred16x16_horizontal_c;

  1273.     h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_c;

  1274.     switch(codec_id){

  1275.     case CODEC_ID_SVQ3:

  1276.        h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_svq3_c;

  1277.        break;

  1278.     case CODEC_ID_RV40:

  1279.        h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_rv40_c;

  1280.        break;

  1281.     case CODEC_ID_VP8:

  1282.        h->pred16x16[PLANE_PRED8x8  ]= pred16x16_tm_vp8_c;

  1283.        break;

  1284.     default:

  1285.        h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_c;

  1286.     }

  1287.     h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;

  1288.     h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;

  1289.     h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;

  1290. 

  1291.     //special lossless h/v prediction for h264

  1292.     h->pred4x4_add  [VERT_PRED   ]= pred4x4_vertical_add_c;

  1293.     h->pred4x4_add  [ HOR_PRED   ]= pred4x4_horizontal_add_c;

  1294.     h->pred8x8l_add [VERT_PRED   ]= pred8x8l_vertical_add_c;

  1295.     h->pred8x8l_add [ HOR_PRED   ]= pred8x8l_horizontal_add_c;

  1296.     h->pred8x8_add  [VERT_PRED8x8]= pred8x8_vertical_add_c;

  1297.     h->pred8x8_add  [ HOR_PRED8x8]= pred8x8_horizontal_add_c;

  1298.     h->pred16x16_add[VERT_PRED8x8]= pred16x16_vertical_add_c;

  1299.     h->pred16x16_add[ HOR_PRED8x8]= pred16x16_horizontal_add_c;

  1300. 

  1301.     if (ARCH_ARM) ff_h264_pred_init_arm(h, codec_id);

  1302.     if (HAVE_MMX) ff_h264_pred_init_x86(h, codec_id);

  1303. }