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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
predict.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：15k
源码类别：

mpeg/mp3

开发平台：

Visual C++

predict.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  *  T264 AVC CODEC
  4.  *
  5.  *  Copyright(C) 2004-2005 llcc <lcgate1@yahoo.com.cn>
  6.  *               2004-2005 visionany <visionany@yahoo.com.cn>
  7.  *
  8.  *
  9.  *  Cloud Wu 2004-9-30 add intra prediction mode 3-8
  10.  *
  11.  *  This program is free software ; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation ; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program ; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24.  *
  25.  ****************************************************************************/
  27. #include "portab.h"
  28. #include "predict.h"
  29. #ifndef CHIP_DM642
  30. #include <memory.h>
  31. #endif
  33. //
  34. // Vertical
  35. //
  36. void
  37. T264_predict_16x16_mode_0_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  38. {
  39.     int32_t i, j;
  41.     for(i = 0 ; i < 16 ; i ++)
  42.     {
  43.         for(j = 0 ; j < 16 ; j ++)
  44.         {
  45.             dst[j] = top[j];
  46.         }
  47.         dst += dst_stride;
  48.     }
  49. }
  51. //
  52. // Horizontal
  53. //
  54. void
  55. T264_predict_16x16_mode_1_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  56. {
  57.     int32_t i, j;
  59.     for(i = 0 ; i < 16 ; i ++)
  60.     {
  61.         for(j = 0 ; j < 16 ; j ++)
  62.         {
  63.             dst[j] = left[i];
  64.         }
  65.         dst += dst_stride;
  66.     }
  67. }
  69. //
  70. // top & left all available
  71. //
  72. void
  73. T264_predict_16x16_mode_2_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  74. {
  75.     int32_t H, V, m;
  76.     int32_t i, j;
  78.     H = V = 0;
  80.     for(i = 0 ; i < 16 ; i ++)
  81.     {
  82.         H += top[i];
  83.         V += left[i];
  84.     }
  86.     m = (H + V + 16) >> 5;
  88.     for(i = 0 ; i < 16 ; i ++)
  89.     {
  90.         for(j = 0 ; j < 16 ; j ++)
  91.         {
  92.             dst[j] = m;
  93.         }
  94.         dst += dst_stride;
  95.     }
  96. }
  98. //
  99. // top available
  100. //
  101. void
  102. T264_predict_16x16_mode_20_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  103. {
  104.     int32_t H, m;
  105.     int32_t i, j;
  107.     H = 0;
  109.     for(i = 0 ; i < 16 ; i ++)
  110.     {
  111.         H += top[i];
  112.     }
  114.     m = (H + 8) >> 4;
  116.     for(i = 0 ; i < 16 ; i ++)
  117.     {
  118.         for(j = 0 ; j < 16 ; j ++)
  119.         {
  120.             dst[j] = m;
  121.         }
  122.         dst += dst_stride;
  123.     }
  124. }
  126. //
  127. // left available
  128. //
  129. void
  130. T264_predict_16x16_mode_21_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  131. {
  132.     int32_t V, m;
  133.     int32_t i, j;
  135.     V = 0;
  137.     for(i = 0 ; i < 16 ; i ++)
  138.     {
  139.         V += left[i];
  140.     }
  142.     m = (V + 8) >> 4;
  144.     for(i = 0 ; i < 16 ; i ++)
  145.     {
  146.         for(j = 0 ; j < 16 ; j ++)
  147.         {
  148.             dst[j] = m;
  149.         }
  150.         dst += dst_stride;
  151.     }
  152. }
  154. //
  155. // none available
  156. //
  157. void
  158. T264_predict_16x16_mode_22_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  159. {
  160.     int32_t i, j;
  162.     for(i = 0 ; i < 16 ; i ++)
  163.     {
  164.         for(j = 0 ; j < 16 ; j ++)
  165.         {
  166.             dst[j] = 128;
  167.         }
  168.         dst += dst_stride;
  169.     }
  170. }
  172. //
  173. // Plane
  174. //
  175. void
  176. T264_predict_16x16_mode_3_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  177. {
  178.     int32_t a, b, c, H, V;
  179.     int32_t i, j;
  181.     H = V = 0;
  183.     for(i = 0 ; i < 8 ; i ++)
  184.     {
  185.         H += (i + 1) * (top[8 + i] - top[6 - i]);
  186.         V += (i + 1) * (left[8 + i] - left[6 - i]);
  187.     }
  189.     a = (left[15] + top[15]) << 4;
  190.     b = (5 * H + 32) >> 6;
  191.     c = (5 * V + 32) >> 6;
  193.     for(i = 0 ; i < 16 ; i ++)
  194.     {
  195.         for(j = 0 ; j < 16 ; j ++)
  196.         {
  197.             int32_t tmp = (a + b * (j - 7) + c * (i - 7) + 16) >> 5;
  198.             tmp = CLIP1(tmp);
  199.             dst[j] = tmp;
  200.         }
  201.         dst += dst_stride;
  202.     }
  203. }
  205. //Mode 0: Vertical
  206. void T264_predict_4x4_mode_0_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  207. {
  208.     int32_t i, j;
  209.     
  210.     for(i = 0; i < 4; i++)
  211.     {
  212.         for(j = 0; j < 4; j++)
  213.         {
  214.             dst[j] = top[j];
  215.         }
  216.         dst += dst_stride;
  217.     }
  218. }
  220. //Mode 1: Horizontal
  221. void T264_predict_4x4_mode_1_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  222. {
  223.     int32_t i, j;
  225.     for(i = 0; i < 4; i++)
  226.     {
  227.         for(j = 0; j < 4; j++)
  228.         {
  229.             dst[j] = left[i];
  230.         }
  231.         dst += dst_stride;
  232.     }
  233. }
  235. //Mode 2: DC
  236. void T264_predict_4x4_mode_2_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  237. {
  238.     int32_t i, j;
  239.     int32_t H, V, m;
  241.     H = V = 0;
  242.     for(i = 0; i < 4; i++)
  243.     {
  244.         H += top[i];
  245.         V += left[i];
  246.     }
  247.     m = (H + V + 4) >> 3;
  249.     for(i = 0; i < 4; i++)
  250.     {
  251.         for(j = 0; j < 4; j++)
  252.         {
  253.             dst[j] = m;
  254.         }
  255.         dst += dst_stride;
  256.     }
  257. }
  259. //Mode 20 DC top
  260. void T264_predict_4x4_mode_20_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  261. {
  262.     int32_t i, j;
  263.     int32_t V, m;
  265.     V = 0;
  266.     for(i = 0; i < 4; i++)
  267.     {
  268.         V += top[i];
  269.     }
  270.     m = (V + 2) >> 2;
  272.     for(i = 0; i < 4; i++)
  273.     {
  274.         for(j = 0; j < 4; j++)
  275.         {
  276.             dst[j] =  m;
  277.         }
  278.         dst += dst_stride;
  279.     }
  280. }
  282. //Mode 21 DC left
  283. void T264_predict_4x4_mode_21_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  284. {
  285.     int32_t i, j;
  286.     int32_t H, m;
  288.     H = 0;
  289.     for(i = 0; i < 4; i++)
  290.     {
  291.         H += left[i];
  292.     }
  293.     m = (H + 2) >> 2;
  295.     for(i = 0; i < 4; i++)
  296.     {
  297.         for(j = 0; j < 4; j++)
  298.         {
  299.             dst[j] = m;
  300.         }
  301.         dst += dst_stride;
  302.     }
  303. }
  305. //Mode 22 DC 128
  306. void T264_predict_4x4_mode_22_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  307. {
  308.     memset(dst,128,16);
  309. }
  311. //Mode 3 Intra_4x4_DIAGONAL_DOWNLEFT when Top are available
  312. void T264_predict_4x4_mode_3_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  313. {
  314. uint8_t *cur_dst = dst;
  316. *cur_dst = (top[0] + top[2] + (top[1] << 1) + 2) >> 2;
  317.     *(cur_dst + 1) = *(cur_dst + 4) = (top[1] + top[3] + (top[2] << 1) + 2) >> 2;
  318.     *(cur_dst + 2) = *(cur_dst + 5) = *(cur_dst + 8) = (top[2] + top[4] + (top[3] << 1) + 2) >> 2;
  319.     *(cur_dst + 3) =  *(cur_dst + 6) =  *(cur_dst + 9) =  *(cur_dst + 12) = (top[3] + top[5] + (top[4] << 1) + 2) >> 2;
  320.     *(cur_dst + 7) =  *(cur_dst + 10) = *(cur_dst + 13) = (top[4] + top[6] + (top[5] << 1) + 2) >> 2;
  321.     *(cur_dst + 11) =  *(cur_dst + 14) = (top[5] + top[7] + (top[6] << 1) + 2) >> 2;
  322.     *(cur_dst + 15) = (top[6] + (top[7] << 1) + top[7] + 2) >> 2;
  323. }
  325. //Mode 4 Intra_4x4_DIAGONAL_DOWNRIGHT when Top and left are available
  326. void T264_predict_4x4_mode_4_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  327. {
  328. uint8_t *cur_dst = dst;
  330.     *(cur_dst + 12) = (left[3] + (left[2] << 1) + left[1] + 2) >> 2; 
  331.     *(cur_dst + 8) = *(cur_dst + 13) = (left[2] + (left[1] << 1) + left[0] + 2) >> 2; 
  332.     *(cur_dst + 4) = *(cur_dst + 9) = *(cur_dst + 14) = (left[1] + (left[0] << 1) + *(left - 1) + 2) >> 2; 
  333.     *(cur_dst) = *(cur_dst + 5) = *(cur_dst + 10) = *(cur_dst + 15) = (left[0] + (*(left - 1) << 1) + top[0] + 2) >> 2; 
  334.     *(cur_dst + 1) = *(cur_dst + 6) = *(cur_dst + 11) = (*(top - 1) + (top[0] << 1) + top[1] + 2) >> 2;
  335.     *(cur_dst + 2) = *(cur_dst + 7) = (top[0] + (top[1] << 1) + top[2] + 2) >> 2;
  336.     *(cur_dst + 3) = (top[1] + (top[2] << 1) + top[3] + 2) >> 2;
  337. }
  339. //Mode 5 Intra_4x4_VERTICAL_RIGHT when Top and left are available
  340. void T264_predict_4x4_mode_5_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  341. {
  342. uint8_t *cur_dst = dst;
  344. *cur_dst = *(cur_dst + 9) = (*(top - 1) + top[0] + 1) >> 1;
  345.     *(cur_dst + 1) = *(cur_dst + 10) = (top[0] + top[1] + 1) >> 1;
  346.     *(cur_dst + 2) = *(cur_dst + 11) = (top[1] + top[2] + 1) >> 1;
  347.     *(cur_dst + 3) = (top[2] + top[3] + 1) >> 1;
  348.     *(cur_dst + 4) = *(cur_dst + 13) = (left[0] + (*(top - 1) << 1) + top[0] + 2) >> 2;
  349.     *(cur_dst + 5) = *(cur_dst + 14) = (*(top - 1) + (top[0] << 1) + top[1] + 2) >> 2;
  350.     *(cur_dst + 6) = *(cur_dst + 15) = (top[0] + (top[1] << 1) + top[2] + 2) >> 2;
  351.     *(cur_dst + 7) = (top[1] + (top[2] << 1) + top[3] + 2) >> 2;
  352.     *(cur_dst + 8) = (*(top - 1) + (left[0] << 1) + left[1] + 2) >> 2;
  353.     *(cur_dst + 12) = (left[0] + (left[1] << 1) + left[2] + 2) >> 2;
  355. }
  357. //Mode 6 Intra_4x4_HORIZONTAL_DOWN when Top and left are available
  358. void T264_predict_4x4_mode_6_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  359. {
  360. uint8_t *cur_dst = dst;
  362. *cur_dst = *(cur_dst + 6) = (*(top - 1) + left[0] + 1) >> 1;
  363.     *(cur_dst + 1) = *(cur_dst + 7) = (left[0] + (*(left - 1) << 1) + top[0] + 2) >> 2;
  364.     *(cur_dst + 2) = (*(top - 1) + (top[0] << 1) + top[1] + 2) >> 2;
  365.     *(cur_dst + 3) = (top[0] + (top[1] << 1) + top[2] + 2) >> 2;
  366.     *(cur_dst + 4) = *(cur_dst + 10) = (left[0] + left[1] + 1) >> 1;
  367.     *(cur_dst + 5) = *(cur_dst + 11) = (*(left - 1) + (left[0] << 1) + left[1] + 2) >> 2;
  368.     *(cur_dst + 8) = *(cur_dst + 14) = (left[1] + left[2] + 1) >> 1;
  369.     *(cur_dst + 9) = *(cur_dst + 15) = (left[0] + (left[1] << 1) + left[2] + 2) >> 2;
  370.     *(cur_dst + 12) = (left[2] + left[3] + 1) >> 1;
  371.     *(cur_dst + 13) = (left[1] + (left[2] << 1) + left[3] + 2)  >> 2;
  372. }
  374. //Mode 7 Intra_4x4_VERTICAL_LEFT when Top are available
  375. void T264_predict_4x4_mode_7_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  376. {
  377. uint8_t *cur_dst = dst;
  379. *cur_dst = (top[0] + top[1] + 1) >> 1;
  380.     *(cur_dst + 1) = *(cur_dst + 8) = (top[1] + top[2] + 1) >> 1;
  381.     *(cur_dst + 2) = *(cur_dst + 9) = (top[2] + top[3] + 1) >> 1;;
  382.     *(cur_dst + 3) = *(cur_dst + 10) = (top[3] + top[4] + 1) >> 1;
  383.     *(cur_dst + 11) = (top[4] + top[5] + 1) >> 1;
  384.     *(cur_dst + 4) = (top[0] + (top[1] << 1) + top[2] + 2) >> 2;
  385.     *(cur_dst + 5) = *(cur_dst + 12) = (top[1] + (top[2] << 1) + top[3] + 2) >> 2;
  386.     *(cur_dst + 6) = *(cur_dst + 13) = (top[2] + (top[3] << 1) + top[4] + 2) >> 2;
  387.     *(cur_dst + 7) = *(cur_dst + 14) = (top[3] + (top[4] << 1) + top[5] + 2) >> 2;
  388.     *(cur_dst + 15) = (top[4] + (top[5] << 1) + top[6] + 2) >> 2;
  389. }
  392. //Mode 8 Intra_4x4_HORIZONTAL_UP when Left are available
  393. void T264_predict_4x4_mode_8_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  394. {
  395. uint8_t *cur_dst = dst;
  397. *cur_dst = (left[0] + left[1] + 1) >> 1;
  398.     *(cur_dst + 1) = (left[0] + 2*left[1] + left[2] + 2) >> 2;
  399.     *(cur_dst + 2) = *(cur_dst + 4) = (left[1] + left[2] + 1) >> 1;
  400.     *(cur_dst + 3) = *(cur_dst + 5) = (left[1] + 2*left[2] + left[3] + 2) >> 2;
  401.     *(cur_dst + 6) = *(cur_dst + 8) = (left[2] + left[3] + 1) >> 1;
  402.     *(cur_dst + 7) = *(cur_dst + 9) = (left[2] +  (left[3] << 1) + left[3] + 2) >> 2;
  403.    *(cur_dst + 12) = *(cur_dst + 10) = *(cur_dst + 11) = *(cur_dst + 13) 
  404. = *(cur_dst + 14) = *(cur_dst + 15) = left[3];
  405. }
  407. //
  408. // Vertical
  409. //
  410. void
  411. T264_predict_8x8_mode_0_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  412. {
  413.     int32_t i, j;
  415.     for(i = 0 ; i < 8 ; i ++)
  416.     {
  417.         for(j = 0 ; j < 8 ; j ++)
  418.         {
  419.             dst[j] = top[j];
  420.         }
  421.         dst += dst_stride;
  422.     }
  423. }
  425. //
  426. // Horizontal
  427. //
  428. void
  429. T264_predict_8x8_mode_1_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  430. {
  431.     int32_t i, j;
  433.     for(i = 0 ; i < 8 ; i ++)
  434.     {
  435.         for(j = 0 ; j < 8 ; j ++)
  436.         {
  437.             dst[j] = left[i];
  438.         }
  439.         dst += dst_stride;
  440.     }
  441. }
  443. //
  444. // top & left all available
  445. //
  446. void
  447. T264_predict_8x8_mode_2_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  448. {
  449.     int32_t H1, V1;
  450.     int32_t H2, V2;
  451.     int32_t m[4];
  452.     int32_t i, j;
  454.     H1 = V1 = H2 = V2 = 0;
  456.     for(i = 0 ; i < 4 ; i ++)
  457.     {
  458.         H1   += top[i];
  459.         V1   += left[i];
  460.         H2   += top[i + 4];
  461.         V2   += left[i + 4];
  462.     }
  464.     m[0] = (H1 + V1 + 4) >> 3;
  465.     m[1] = (H2 + 2) >> 2;
  466.     m[2] = (V2 + 2) >> 2;
  467.     m[3] = (H2 + V2 + 4) >> 3;
  469.     for(i = 0 ; i < 4 ; i ++)
  470.     {
  471.         for(j = 0 ; j < 4 ; j ++)
  472.         {
  473.             dst[j] = m[0];
  474.         }
  475.         for(      ; j < 8 ; j ++)
  476.         {
  477.             dst[j] = m[1];
  478.         }
  479.         dst += dst_stride;
  480.     }
  481.     for(     ; i < 8 ; i ++)
  482.     {
  483.         for(j = 0 ; j < 4 ; j ++)
  484.         {
  485.             dst[j] = m[2];
  486.         }
  487.         for(      ; j < 8 ; j ++)
  488.         {
  489.             dst[j] = m[3];
  490.         }
  491.         dst += dst_stride;
  492.     }
  493. }
  495. //
  496. // top available
  497. //
  498. void
  499. T264_predict_8x8_mode_20_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  500. {
  501.     int32_t H1, m1;
  502.     int32_t H2, m2;
  503.     int32_t i, j;
  505.     H1 = H2 = 0;
  507.     for(i = 0 ; i < 4 ; i ++)
  508.     {
  509.         H1 += top[i];
  510.         H2 += top[i + 4];
  511.     }
  513.     m1 = (H1 + 2) >> 2;
  514.     m2 = (H2 + 2) >> 2;
  516.     for(i = 0 ; i < 8 ; i ++)
  517.     {
  518.         for(j = 0 ; j < 4 ; j ++)
  519.         {
  520.             dst[j] = m1;
  521.         }
  522.         for(      ; j < 8 ; j ++)
  523.         {
  524.             dst[j] = m2;
  525.         }
  526.         dst += dst_stride;
  527.     }
  528. }
  530. //
  531. // left available
  532. //
  533. void
  534. T264_predict_8x8_mode_21_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  535. {
  536.     int32_t V1, m1;
  537.     int32_t V2, m2;
  538.     int32_t i, j;
  540.     V1 = V2 = 0;
  542.     for(i = 0 ; i < 4 ; i ++)
  543.     {
  544.         V1 += left[i];
  545.         V2 += left[i + 4];
  546.     }
  548.     m1 = (V1 + 2) >> 2;
  549.     m2 = (V2 + 2) >> 2;
  551.     for(i = 0 ; i < 4 ; i ++)
  552.     {
  553.         for(j = 0 ; j < 8 ; j ++)
  554.         {
  555.             dst[j] = m1;
  556.         }
  557.         dst += dst_stride;
  558.     }
  559.     for(      ; i < 8 ; i ++)
  560.     {
  561.         for(j = 0 ; j < 8 ; j ++)
  562.         {
  563.             dst[j] = m2;
  564.         }
  565.         dst += dst_stride;
  566.     }
  567. }
  569. //
  570. // none available
  571. //
  572. void
  573. T264_predict_8x8_mode_22_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  574. {
  575.     int32_t i, j;
  577.     for(i = 0 ; i < 8 ; i ++)
  578.     {
  579.         for(j = 0 ; j < 8 ; j ++)
  580.         {
  581.             dst[j] = 128;
  582.         }
  583.         dst += dst_stride;
  584.     }
  585. }
  587. //
  588. // Plane
  589. //
  590. void
  591. T264_predict_8x8_mode_3_c(uint8_t* dst, int32_t dst_stride, uint8_t* top, uint8_t* left)
  592. {
  593.     int32_t a, b, c, H, V;
  594.     int32_t i, j;
  596.     H = V = 0;
  598.     for(i = 0 ; i < 4 ; i ++)
  599.     {
  600.         H += (i + 1) * (top[4 + i] - top[2 - i]);
  601.         V += (i + 1) * (left[4 + i] - left[2 - i]);
  602.     }
  604.     a = (left[7] + top[7]) << 4;
  605.     b = (17 * H + 16) >> 5;
  606.     c = (17 * V + 16) >> 5;
  608.     for(i = 0 ; i < 8 ; i ++)
  609.     {
  610.         for(j = 0 ; j < 8 ; j ++)
  611.         {
  612.             int32_t tmp = (a + b * (j - 3) + c * (i - 3) + 16) >> 5;
  613.             dst[j] = CLIP1(tmp);
  614.         }
  615.         dst += dst_stride;
  616.     }
  617. }