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

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

mpeg/mp3

开发平台：

Visual C++

t264enc.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.  *  This program is free software ; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation ; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program ; if not, write to the Free Software
  20.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21.  *
  22.  ****************************************************************************/
  23. #include "config.h"
  24. #include "stdio.h"
  25. #ifndef CHIP_DM642
  26. #include "memory.h"
  27. #endif
  29. #include "T264.h"
  30. #include "utility.h"
  31. #include "intra.h"
  32. #include "cavlc.h"
  33. #include "inter.h"
  34. #include "inter_b.h"
  35. #include "interpolate.h"
  36. #include "estimation.h"
  37. #include "deblock.h"
  38. #include "ratecontrol.h"
  39. #include "stat.h"
  40. #ifndef CHIP_DM642
  41. #include "sse2.h"
  42. #endif
  43. #include "math.h"
  44. #include "dct.h"
  45. #include "predict.h"
  46. #include "bitstream.h"
  47. #include "rbsp.h"
  48. #include "assert.h"
  49. #include "typedecision.h"
  50. //for CABAC
  51. #include "cabac_engine.h"
  52. #include "cabac.h"
  54. const int32_t chroma_qp[] =
  55. {
  56.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
  57.     11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 
  58.     21, 22, 23, 24, 25, 26, 27, 28, 29,
  59.     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
  60.     36, 36, 37, 37, 37, 38, 38, 38, 39, 39, 39, 39
  61. };
  63. //! convert from H.263 QP to H.26L quant given by: quant=pow(2,QP/6)
  64. static const int32_t qp_cost[52]=
  65. {
  66.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  67.     1, 1, 1, 1, 2, 2, 2, 2,
  68.     3, 3, 3, 4, 4, 4, 5, 6,
  69.     6, 7, 8, 9,10,11,13,14,
  70.     16,18,20,23,25,29,32,36,
  71.     40,45,51,57,64,72,81,91
  72. };
  74. void
  75. T264_mb_load_context(T264_t* t, int32_t mb_y, int32_t mb_x)
  76. {
  77.     int32_t qpc;
  78.     int32_t i, j;
  80.     t->mb.mb_x = mb_x;
  81.     t->mb.mb_y = mb_y;
  82.     t->mb.mb_xy = t->mb.mb_y * t->mb_stride + t->mb.mb_x;
  83.     t->mb.mb_neighbour = 0;
  84.     if (mb_x != 0)
  85.         t->mb.mb_neighbour |= MB_LEFT;
  86.     if (mb_y != 0)
  87.     {
  88.         t->mb.mb_neighbour |= MB_TOP;
  89.         //if (mb_x != t->mb_stride - 1) //just tell MB is not the top-most
  90.             t->mb.mb_neighbour |= MB_TOPRIGHT;
  91.     }
  92.     t->mb.src_y = t->cur.Y[0]  + (mb_y << 4) * t->stride    + (mb_x << 4);
  93.     t->mb.dst_y  = t->rec->Y[0] + (mb_y << 4) * t->edged_stride    + (mb_x << 4);
  94.     t->mb.src_u = t->cur.U     + (mb_y << 3) * t->stride_uv + (mb_x << 3);
  95.     t->mb.dst_u = t->rec->U + (mb_y << 3) * t->edged_stride_uv + (mb_x << 3);
  96.     t->mb.src_v = t->cur.V     + (mb_y << 3) * t->stride_uv + (mb_x << 3);
  97.     t->mb.dst_v = t->rec->V + (mb_y << 3) * t->edged_stride_uv + (mb_x << 3);
  99.     t->mb.mb_qp_delta = 0;
  100.     /* t->ps.chroma_qp_index_offset maybe modify in ratecontrol */
  101.     qpc = clip3(t->ps.chroma_qp_index_offset + t->qp_y, 0, 51);
  102.     t->qp_uv = chroma_qp[qpc];
  103.     t->mb.lambda = qp_cost[t->qp_y];
  105.     t->mb.context = &t->rec->mb[t->mb.mb_xy];
  107. /*for CABAC, init the mvd_ref */
  108. memset(&(t->mb.mvd_ref[0][0][0]), 0, sizeof(t->mb.mvd_ref));
  109. #define INITINVALIDVEC(vec) vec.refno = -2; vec.x = vec.y = 0;
  110.     INITINVALIDVEC(t->mb.vec_ref[0].vec[0]);
  111.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4].vec[0]);
  112.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 8].vec[0]);
  113.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 16].vec[0]);
  114.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 24].vec[0]);
  115.     INITINVALIDVEC(t->mb.vec_ref[0].vec[1]);
  116.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4].vec[1]);
  117.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 8].vec[1]);
  118.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 16].vec[1]);
  119.     INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 4 + 24].vec[1]);
  120.     
  121.     t->mb.vec_ref[0].part = -1;
  122.     t->mb.vec_ref[IPM_LUMA - 8 + 4].part      = -1;
  123.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 8].part  = -1;
  124.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 16].part = -1;
  125.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 24].part = -1;
  126.     
  127.     t->mb.vec_ref[0].subpart = -1;
  128.     t->mb.vec_ref[IPM_LUMA - 8 + 4].subpart      = -1;
  129.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 8].subpart  = -1;
  130.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 16].subpart = -1;
  131.     t->mb.vec_ref[IPM_LUMA - 8 + 4 + 24].subpart = -1;
  133.     memset(t->mb.submb_part, -1, sizeof(uint8_t) * 16);//t->mb.submb_part));
  134.     t->mb.mb_part = -1;
  135.     for(i = 0 ; i < 2 ; i ++)
  136.     {
  137.         for(j = 0 ; j < 16 ; j ++)
  138.         {
  139.             INITINVALIDVEC(t->mb.vec[i][j]);
  140.         }
  141.     }
  142.     t->mb.sad_ref[0] = t->mb.sad_ref[1] = t->mb.sad_ref[2] = 0;
  144.     //intra_4x4 prediction modes and non-zero counts
  145. if( mb_y > 0 )
  146.     {
  147.         int16_t top_xy  = t->mb.mb_xy - t->mb_stride;
  148.         /* intra 4x4 pred mode layout
  149.           ? x x x x
  150.             x
  151.             x
  152.             x
  153.             x
  154.          */        
  155.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 0] = t->rec->mb[top_xy].mode_i4x4[10];
  156.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 1] = t->rec->mb[top_xy].mode_i4x4[11];
  157.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 2] = t->rec->mb[top_xy].mode_i4x4[14];
  158.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 3] = t->rec->mb[top_xy].mode_i4x4[15];
  160.         t->mb.vec_ref[IPM_LUMA - 8 + 0].vec[0] = t->rec->mb[top_xy].vec[0][12];
  161.         t->mb.vec_ref[IPM_LUMA - 8 + 1].vec[0] = t->rec->mb[top_xy].vec[0][13];
  162.         t->mb.vec_ref[IPM_LUMA - 8 + 2].vec[0] = t->rec->mb[top_xy].vec[0][14];
  163.         t->mb.vec_ref[IPM_LUMA - 8 + 3].vec[0] = t->rec->mb[top_xy].vec[0][15];
  164.         t->mb.vec_ref[IPM_LUMA - 8 + 0].vec[1] = t->rec->mb[top_xy].vec[1][12];
  165.         t->mb.vec_ref[IPM_LUMA - 8 + 1].vec[1] = t->rec->mb[top_xy].vec[1][13];
  166.         t->mb.vec_ref[IPM_LUMA - 8 + 2].vec[1] = t->rec->mb[top_xy].vec[1][14];
  167.         t->mb.vec_ref[IPM_LUMA - 8 + 3].vec[1] = t->rec->mb[top_xy].vec[1][15];
  169.         t->mb.vec_ref[IPM_LUMA - 8 + 0].part = 
  170.         t->mb.vec_ref[IPM_LUMA - 8 + 1].part = 
  171.         t->mb.vec_ref[IPM_LUMA - 8 + 2].part = 
  172.         t->mb.vec_ref[IPM_LUMA - 8 + 3].part = t->rec->mb[top_xy].mb_part;
  174.         t->mb.vec_ref[IPM_LUMA - 8 + 0].subpart = t->rec->mb[top_xy].submb_part[12];
  175.         t->mb.vec_ref[IPM_LUMA - 8 + 1].subpart = t->rec->mb[top_xy].submb_part[13];
  176.         t->mb.vec_ref[IPM_LUMA - 8 + 2].subpart = t->rec->mb[top_xy].submb_part[14];
  177.         t->mb.vec_ref[IPM_LUMA - 8 + 3].subpart = t->rec->mb[top_xy].submb_part[15];
  179.         t->mb.sad_ref[1] = t->rec->mb[top_xy].sad;
  181. //for CABAC, load mvd
  182. t->mb.mvd_ref[0][IPM_LUMA - 8 + 0][0] = t->rec->mb[top_xy].mvd[0][12][0];
  183. t->mb.mvd_ref[0][IPM_LUMA - 8 + 0][1] = t->rec->mb[top_xy].mvd[0][12][1];
  185. t->mb.mvd_ref[0][IPM_LUMA - 8 + 1][0] = t->rec->mb[top_xy].mvd[0][13][0];
  186. t->mb.mvd_ref[0][IPM_LUMA - 8 + 1][1] = t->rec->mb[top_xy].mvd[0][13][1];
  188. t->mb.mvd_ref[0][IPM_LUMA - 8 + 2][0] = t->rec->mb[top_xy].mvd[0][14][0];
  189. t->mb.mvd_ref[0][IPM_LUMA - 8 + 2][1] = t->rec->mb[top_xy].mvd[0][14][1];
  191. t->mb.mvd_ref[0][IPM_LUMA - 8 + 3][0] = t->rec->mb[top_xy].mvd[0][15][0];
  192. t->mb.mvd_ref[0][IPM_LUMA - 8 + 3][1] = t->rec->mb[top_xy].mvd[0][15][1];
  194. t->mb.mvd_ref[1][IPM_LUMA - 8 + 0][0] = t->rec->mb[top_xy].mvd[1][12][0];
  195. t->mb.mvd_ref[1][IPM_LUMA - 8 + 0][1] = t->rec->mb[top_xy].mvd[1][12][1];
  197. t->mb.mvd_ref[1][IPM_LUMA - 8 + 1][0] = t->rec->mb[top_xy].mvd[1][13][0];
  198. t->mb.mvd_ref[1][IPM_LUMA - 8 + 1][1] = t->rec->mb[top_xy].mvd[1][13][1];
  200. t->mb.mvd_ref[1][IPM_LUMA - 8 + 2][0] = t->rec->mb[top_xy].mvd[1][14][0];
  201. t->mb.mvd_ref[1][IPM_LUMA - 8 + 2][1] = t->rec->mb[top_xy].mvd[1][14][1];
  203. t->mb.mvd_ref[1][IPM_LUMA - 8 + 3][0] = t->rec->mb[top_xy].mvd[1][15][0];
  204. t->mb.mvd_ref[1][IPM_LUMA - 8 + 3][1] = t->rec->mb[top_xy].mvd[1][15][1];
  206.         if (mb_x != t->mb_stride - 1)
  207.         {
  208.             int32_t righttop_xy = top_xy + 1;
  209.             t->mb.vec_ref[IPM_LUMA - 8 + 4].vec[0]     = t->rec->mb[righttop_xy].vec[0][12];
  210.             t->mb.vec_ref[IPM_LUMA - 8 + 4].vec[1]     = t->rec->mb[righttop_xy].vec[1][12];
  211.             t->mb.vec_ref[IPM_LUMA - 8 + 4].part    = t->rec->mb[righttop_xy].mb_part;
  212.             t->mb.vec_ref[IPM_LUMA - 8 + 4].subpart = t->rec->mb[righttop_xy].submb_part[12];
  213.             t->mb.sad_ref[2] = t->rec->mb[righttop_xy].sad;
  214.         }
  215.         /* nnz layout:
  216.           ? x x x x ? x x
  217.           x         x
  218.           x         x
  219.           x         ? x x
  220.           x         x
  221.                     x
  222.          */
  223.         t->mb.nnz_ref[NNZ_LUMA - 8 + 0] = t->rec->mb[top_xy].nnz[12];
  224.         t->mb.nnz_ref[NNZ_LUMA - 8 + 1] = t->rec->mb[top_xy].nnz[13];
  225.         t->mb.nnz_ref[NNZ_LUMA - 8 + 2] = t->rec->mb[top_xy].nnz[14];
  226.         t->mb.nnz_ref[NNZ_LUMA - 8 + 3] = t->rec->mb[top_xy].nnz[15];
  228.         t->mb.nnz_ref[NNZ_CHROMA0 - 8 + 0] = t->rec->mb[top_xy].nnz[18];
  229.         t->mb.nnz_ref[NNZ_CHROMA0 - 8 + 1] = t->rec->mb[top_xy].nnz[19];
  230.         t->mb.nnz_ref[NNZ_CHROMA1 - 8 + 0] = t->rec->mb[top_xy].nnz[22];
  231.         t->mb.nnz_ref[NNZ_CHROMA1 - 8 + 1] = t->rec->mb[top_xy].nnz[23];
  232.     }
  233.     else
  234.     {
  235.         /* load intra4x4 */
  236.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 0] = 
  237.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 1] = 
  238.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 2] = 
  239.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 8 + 3] = -1;
  241.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 0].vec[0]);
  242.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 1].vec[0]);
  243.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 2].vec[0]);
  244.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 3].vec[0]);
  245.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 0].vec[1]);
  246.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 1].vec[1]);
  247.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 2].vec[1]);
  248.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 8 + 3].vec[1]);
  250.         t->mb.vec_ref[IPM_LUMA - 8 + 0].part = 
  251.         t->mb.vec_ref[IPM_LUMA - 8 + 1].part = 
  252.         t->mb.vec_ref[IPM_LUMA - 8 + 2].part = 
  253.         t->mb.vec_ref[IPM_LUMA - 8 + 3].part = -1;
  255.         t->mb.vec_ref[IPM_LUMA - 8 + 0].subpart = 
  256.         t->mb.vec_ref[IPM_LUMA - 8 + 1].subpart = 
  257.         t->mb.vec_ref[IPM_LUMA - 8 + 2].subpart = 
  258.         t->mb.vec_ref[IPM_LUMA - 8 + 3].subpart = -1;
  260. //for CABAC, load mvd
  261. t->mb.mvd_ref[0][IPM_LUMA - 8 + 0][0] = 0;
  262. t->mb.mvd_ref[0][IPM_LUMA - 8 + 0][1] = 0;
  264. t->mb.mvd_ref[0][IPM_LUMA - 8 + 1][0] = 0;
  265. t->mb.mvd_ref[0][IPM_LUMA - 8 + 1][1] = 0;
  267. t->mb.mvd_ref[0][IPM_LUMA - 8 + 2][0] = 0;
  268. t->mb.mvd_ref[0][IPM_LUMA - 8 + 2][1] = 0;
  270. t->mb.mvd_ref[0][IPM_LUMA - 8 + 3][0] = 0;
  271. t->mb.mvd_ref[0][IPM_LUMA - 8 + 3][1] = 0;
  273. t->mb.mvd_ref[1][IPM_LUMA - 8 + 0][0] = 0;
  274. t->mb.mvd_ref[1][IPM_LUMA - 8 + 0][1] = 0;
  276. t->mb.mvd_ref[1][IPM_LUMA - 8 + 1][0] = 0;
  277. t->mb.mvd_ref[1][IPM_LUMA - 8 + 1][1] = 0;
  279. t->mb.mvd_ref[1][IPM_LUMA - 8 + 2][0] = 0;
  280. t->mb.mvd_ref[1][IPM_LUMA - 8 + 2][1] = 0;
  282. t->mb.mvd_ref[1][IPM_LUMA - 8 + 3][0] = 0;
  283. t->mb.mvd_ref[1][IPM_LUMA - 8 + 3][1] = 0;
  285.         t->mb.nnz_ref[NNZ_LUMA - 8 + 0] =
  286.         t->mb.nnz_ref[NNZ_LUMA - 8 + 1] =
  287.         t->mb.nnz_ref[NNZ_LUMA - 8 + 2] =
  288.         t->mb.nnz_ref[NNZ_LUMA - 8 + 3] = 0x80;
  290.         t->mb.nnz_ref[NNZ_CHROMA0 - 8 + 0] =
  291.         t->mb.nnz_ref[NNZ_CHROMA0 - 8 + 1] =
  292.         t->mb.nnz_ref[NNZ_CHROMA1 - 8 + 0] =
  293.         t->mb.nnz_ref[NNZ_CHROMA1 - 8 + 1] = 0x80;
  294.     }
  296.     if( mb_x > 0 )
  297.     {
  298.         int16_t left_xy  = t->mb.mb_xy - 1;
  300.         /* load intra4x4 */
  301.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 0] = t->rec->mb[left_xy].mode_i4x4[5];
  302.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 8] = t->rec->mb[left_xy].mode_i4x4[7];
  303.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 16] = t->rec->mb[left_xy].mode_i4x4[13];
  304.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 24] = t->rec->mb[left_xy].mode_i4x4[15];
  306.         t->mb.vec_ref[IPM_LUMA - 1 + 0].vec[0] = t->rec->mb[left_xy].vec[0][3];
  307.         t->mb.vec_ref[IPM_LUMA - 1 + 8].vec[0] = t->rec->mb[left_xy].vec[0][7];
  308.         t->mb.vec_ref[IPM_LUMA - 1 + 16].vec[0] = t->rec->mb[left_xy].vec[0][11];
  309.         t->mb.vec_ref[IPM_LUMA - 1 + 24].vec[0] = t->rec->mb[left_xy].vec[0][15];
  310.         t->mb.vec_ref[IPM_LUMA - 1 + 0].vec[1] = t->rec->mb[left_xy].vec[1][3];
  311.         t->mb.vec_ref[IPM_LUMA - 1 + 8].vec[1] = t->rec->mb[left_xy].vec[1][7];
  312.         t->mb.vec_ref[IPM_LUMA - 1 + 16].vec[1] = t->rec->mb[left_xy].vec[1][11];
  313.         t->mb.vec_ref[IPM_LUMA - 1 + 24].vec[1] = t->rec->mb[left_xy].vec[1][15];
  315.         t->mb.vec_ref[IPM_LUMA - 1 + 0].part = 
  316.         t->mb.vec_ref[IPM_LUMA - 1 + 8].part = 
  317.         t->mb.vec_ref[IPM_LUMA - 1 + 16].part =
  318.         t->mb.vec_ref[IPM_LUMA - 1 + 24].part = t->rec->mb[left_xy].mb_part;
  320.         t->mb.vec_ref[IPM_LUMA - 8 + 0].subpart = t->rec->mb[left_xy].submb_part[3];
  321.         t->mb.vec_ref[IPM_LUMA - 8 + 8].subpart = t->rec->mb[left_xy].submb_part[7];
  322.         t->mb.vec_ref[IPM_LUMA - 8 + 16].subpart = t->rec->mb[left_xy].submb_part[11];
  323.         t->mb.vec_ref[IPM_LUMA - 8 + 24].subpart = t->rec->mb[left_xy].submb_part[15];
  325.         t->mb.sad_ref[0] = t->rec->mb[left_xy].sad;
  327. //for CABAC, load mvd
  328. t->mb.mvd_ref[0][IPM_LUMA - 1 + 0][0] = t->rec->mb[left_xy].mvd[0][3][0];
  329. t->mb.mvd_ref[0][IPM_LUMA - 1 + 0][1] = t->rec->mb[left_xy].mvd[0][3][1];
  331. t->mb.mvd_ref[0][IPM_LUMA - 1 + 8][0] = t->rec->mb[left_xy].mvd[0][7][0];
  332. t->mb.mvd_ref[0][IPM_LUMA - 1 + 8][1] = t->rec->mb[left_xy].mvd[0][7][1];
  334. t->mb.mvd_ref[0][IPM_LUMA - 1 + 16][0] = t->rec->mb[left_xy].mvd[0][11][0];
  335. t->mb.mvd_ref[0][IPM_LUMA - 1 + 16][1] = t->rec->mb[left_xy].mvd[0][11][1];
  337. t->mb.mvd_ref[0][IPM_LUMA - 1 + 24][0] = t->rec->mb[left_xy].mvd[0][15][0];
  338. t->mb.mvd_ref[0][IPM_LUMA - 1 + 24][1] = t->rec->mb[left_xy].mvd[0][15][1];
  340. t->mb.mvd_ref[1][IPM_LUMA - 1 + 0][0] = t->rec->mb[left_xy].mvd[1][3][0];
  341. t->mb.mvd_ref[1][IPM_LUMA - 1 + 0][1] = t->rec->mb[left_xy].mvd[1][3][1];
  343. t->mb.mvd_ref[1][IPM_LUMA - 1 + 8][0] = t->rec->mb[left_xy].mvd[1][7][0];
  344. t->mb.mvd_ref[1][IPM_LUMA - 1 + 8][1] = t->rec->mb[left_xy].mvd[1][7][1];
  346. t->mb.mvd_ref[1][IPM_LUMA - 1 + 16][0] = t->rec->mb[left_xy].mvd[1][11][0];
  347. t->mb.mvd_ref[1][IPM_LUMA - 1 + 16][1] = t->rec->mb[left_xy].mvd[1][11][1];
  349. t->mb.mvd_ref[1][IPM_LUMA - 1 + 24][0] = t->rec->mb[left_xy].mvd[1][15][0];
  350. t->mb.mvd_ref[1][IPM_LUMA - 1 + 24][1] = t->rec->mb[left_xy].mvd[1][15][1];
  353.         /* load non_zero_count */
  354.         t->mb.nnz_ref[NNZ_LUMA - 1 + 0] = t->rec->mb[left_xy].nnz[3];
  355.         t->mb.nnz_ref[NNZ_LUMA - 1 + 8] = t->rec->mb[left_xy].nnz[7];
  356.         t->mb.nnz_ref[NNZ_LUMA - 1 + 16] = t->rec->mb[left_xy].nnz[11];
  357.         t->mb.nnz_ref[NNZ_LUMA - 1 + 24] = t->rec->mb[left_xy].nnz[15];
  359.         t->mb.nnz_ref[NNZ_CHROMA0 - 1 + 0] = t->rec->mb[left_xy].nnz[17];
  360.         t->mb.nnz_ref[NNZ_CHROMA0 - 1 + 8] = t->rec->mb[left_xy].nnz[19];
  361.         t->mb.nnz_ref[NNZ_CHROMA1 - 1 + 0] = t->rec->mb[left_xy].nnz[21];
  362.         t->mb.nnz_ref[NNZ_CHROMA1 - 1 + 8] = t->rec->mb[left_xy].nnz[23];
  363.     }
  364.     else
  365.     {
  366.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 0]  = 
  367.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 8]  = 
  368.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 16] =
  369.         t->mb.i4x4_pred_mode_ref[IPM_LUMA - 1 + 24] = -1;
  371.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 0].vec[0]);
  372.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 8].vec[0]);
  373.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 16].vec[0]);
  374.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 24].vec[0]);
  375.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 0].vec[1]);
  376.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 8].vec[1]);
  377.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 16].vec[1]);
  378.         INITINVALIDVEC(t->mb.vec_ref[IPM_LUMA - 1 + 24].vec[1]);
  380.         t->mb.vec_ref[IPM_LUMA - 1 + 0].part  = 
  381.         t->mb.vec_ref[IPM_LUMA - 1 + 8].part  = 
  382.         t->mb.vec_ref[IPM_LUMA - 1 + 16].part =
  383.         t->mb.vec_ref[IPM_LUMA - 1 + 24].part = -1;
  385.         t->mb.vec_ref[IPM_LUMA - 1 + 0].subpart  = 
  386.         t->mb.vec_ref[IPM_LUMA - 1 + 8].subpart  = 
  387.         t->mb.vec_ref[IPM_LUMA - 1 + 16].subpart =
  388.         t->mb.vec_ref[IPM_LUMA - 1 + 24].subpart = -1;
  390. //for CABAC, load mvd
  391. t->mb.mvd_ref[0][IPM_LUMA - 1 + 0][0] = 0;
  392. t->mb.mvd_ref[0][IPM_LUMA - 1 + 0][1] = 0;
  394. t->mb.mvd_ref[0][IPM_LUMA - 1 + 8][0] = 0;
  395. t->mb.mvd_ref[0][IPM_LUMA - 1 + 8][1] = 0;
  397. t->mb.mvd_ref[0][IPM_LUMA - 1 + 16][0] = 0;
  398. t->mb.mvd_ref[0][IPM_LUMA - 1 + 16][1] = 0;
  400. t->mb.mvd_ref[0][IPM_LUMA - 1 + 24][0] = 0;
  401. t->mb.mvd_ref[0][IPM_LUMA - 1 + 24][1] = 0;
  403. t->mb.mvd_ref[1][IPM_LUMA - 1 + 0][0] = 0;
  404. t->mb.mvd_ref[1][IPM_LUMA - 1 + 0][1] = 0;
  406. t->mb.mvd_ref[1][IPM_LUMA - 1 + 8][0] = 0;
  407. t->mb.mvd_ref[1][IPM_LUMA - 1 + 8][1] = 0;
  409. t->mb.mvd_ref[1][IPM_LUMA - 1 + 16][0] = 0;
  410. t->mb.mvd_ref[1][IPM_LUMA - 1 + 16][1] = 0;
  412. t->mb.mvd_ref[1][IPM_LUMA - 1 + 24][0] = 0;
  413. t->mb.mvd_ref[1][IPM_LUMA - 1 + 24][1] = 0;
  415.         t->mb.nnz_ref[NNZ_LUMA - 1 + 0]  =
  416.         t->mb.nnz_ref[NNZ_LUMA - 1 + 8]  =
  417.         t->mb.nnz_ref[NNZ_LUMA - 1 + 16] =
  418.         t->mb.nnz_ref[NNZ_LUMA - 1 + 24] = 0x80;
  420.         t->mb.nnz_ref[NNZ_CHROMA0 - 1 + 0] =
  421.         t->mb.nnz_ref[NNZ_CHROMA0 - 1 + 8] =
  422.         t->mb.nnz_ref[NNZ_CHROMA1 - 1 + 0] =
  423.         t->mb.nnz_ref[NNZ_CHROMA1 - 1 + 8] = 0x80;
  424.     }
  425.     if (mb_x > 0 && mb_y > 0)
  426.     {
  427.         int32_t lefttop_xy = t->mb.mb_xy - t->mb_stride - 1;
  428.         t->mb.vec_ref[0].vec[0] = t->rec->mb[lefttop_xy].vec[0][15];
  429.         t->mb.vec_ref[0].vec[1] = t->rec->mb[lefttop_xy].vec[1][15];
  430.         t->mb.vec_ref[0].subpart = t->rec->mb[lefttop_xy].submb_part[15];
  431.         t->mb.vec_ref[0].part = t->rec->mb[lefttop_xy].mb_part;
  432.     }
  433. //for CABAC
  434. t->mb.mb_mode_uv = Intra_8x8_DC;
  435. #undef INITINVALIDVEC
  436. }
  438. void
  439. T264_mb_save_context(T264_t* t)
  440. {
  441.     memcpy(t->mb.context, &t->mb, sizeof(*t->mb.context));
  442. }
  444. static void
  445. T264_reset_ref(T264_t* t)
  446. {
  447.     int32_t i;
  449.     for(i = 1 ; i < MAX_REFFRAMES ; i ++)
  450.     {
  451.         t->refn[i].poc = -1;
  452.     }
  453.     t->rec = &t->refn[0];
  454.     t->refn[0].poc = 0;
  455. }
  457. static void
  458. T264_load_ref(T264_t* t)
  459. {
  460.     int32_t i;
  462.     t->refl0_num = 0;
  463.     t->refl1_num = 0;
  464.     if (t->slice_type == SLICE_P)
  465.     {
  466.         for(i = 0 ; i < t->param.ref_num ; i ++)
  467.         {
  468.             if (t->refn[i + 1].poc >= 0)
  469.             {
  470.                 t->ref[0][t->refl0_num ++] = &t->refn[i + 1];
  471.             }
  472.         }
  473.     }
  474.     else if (t->slice_type == SLICE_B)
  475.     {
  476.         for(i = 0 ; i < t->param.ref_num; i ++)
  477.         {
  478.             if (t->refn[i + 1].poc < t->cur.poc)
  479.             {
  480.                 if (t->refn[i + 1].poc >= 0)
  481.                     t->ref[0][t->refl0_num ++] = &t->refn[i + 1];
  482.             }
  483.             else
  484.             {
  485.                 // yes, t->refn[i].poc already > 0
  486.                 t->ref[1][t->refl1_num ++] = &t->refn[i + 1];
  487.             }
  488.         }
  489.     }
  490. }
  492. void
  493. T264_extend_border(T264_t* t, T264_frame_t* f)
  494. {
  495.     int32_t i;
  496.     uint8_t* py0;
  497.     uint8_t* pu;
  498.     uint8_t* pv;
  499.     uint8_t* tmpy0;
  500.     uint8_t* tmpu;
  501.     uint8_t* tmpv;
  503.     // top, top-left, top-right
  504.     py0 = f->Y[0] - t->edged_stride;
  505.     pu = f->U - t->edged_stride_uv;
  506.     pv = f->V - t->edged_stride_uv;
  507.     for(i = 0 ; i < (EDGED_HEIGHT >> 1) ; i ++)
  508.     {
  509.         // y
  510.         memcpy(py0, f->Y[0], t->stride);
  511.         memset(py0 - EDGED_WIDTH, f->Y[0][0], EDGED_WIDTH);
  512.         memset(py0 + t->stride, f->Y[0][t->stride - 1], EDGED_WIDTH);
  513.         py0 -= t->edged_stride;
  515.         memcpy(py0, f->Y[0], t->stride);
  516.         memset(py0 - EDGED_WIDTH, f->Y[0][0], EDGED_WIDTH);
  517.         memset(py0 + t->stride, f->Y[0][t->stride - 1], EDGED_WIDTH);
  518.         py0 -= t->edged_stride;
  520.         // u
  521.         memcpy(pu, f->U, t->stride_uv);
  522.         memset(pu - (EDGED_WIDTH >> 1), f->U[0], EDGED_WIDTH >> 1);
  523.         memset(pu + t->stride_uv, f->U[t->stride_uv - 1], EDGED_WIDTH >> 1);
  524.         pu -= t->edged_stride_uv;
  526.         // V
  527.         memcpy(pv, f->V, t->stride_uv);
  528.         memset(pv - (EDGED_WIDTH >> 1), f->V[0], EDGED_WIDTH >> 1);
  529.         memset(pv + t->stride_uv, f->V[t->stride_uv - 1], EDGED_WIDTH >> 1);
  530.         pv -= t->edged_stride_uv;
  531.     }
  533.     // left & right
  534.     py0 = f->Y[0] - EDGED_WIDTH;
  535.     pu = f->U - (EDGED_WIDTH >> 1);
  536.     pv = f->V - (EDGED_WIDTH >> 1);
  537.     for(i = 0 ; i < (t->height >> 1) ; i ++)
  538.     {
  539.         // left
  540.         memset(py0, py0[EDGED_WIDTH], EDGED_WIDTH);
  541.         // right
  542.         memset(&py0[t->stride + EDGED_WIDTH], py0[t->stride + EDGED_WIDTH - 1], EDGED_WIDTH);
  543.         py0 += t->edged_stride;
  545.         memset(py0, py0[EDGED_WIDTH], EDGED_WIDTH);
  546.         memset(&py0[t->stride + EDGED_WIDTH], py0[t->stride + EDGED_WIDTH - 1], EDGED_WIDTH);
  547.         py0 += t->edged_stride;
  549.         // u
  550.         memset(pu, pu[EDGED_WIDTH >> 1], EDGED_WIDTH >> 1);
  551.         memset(&pu[t->stride_uv + (EDGED_WIDTH >> 1)], pu[t->stride_uv + (EDGED_WIDTH >> 1) - 1], EDGED_WIDTH >> 1);
  552.         pu += t->edged_stride_uv;
  554.         // v
  555.         memset(pv, pv[EDGED_WIDTH >> 1], EDGED_WIDTH >> 1);
  556.         memset(&pv[t->stride_uv + (EDGED_WIDTH >> 1)], pv[t->stride_uv + (EDGED_WIDTH >> 1) - 1], EDGED_WIDTH >> 1);
  557.         pv += t->edged_stride_uv;
  558.     }
  560.     // bottom, left-bottom,right-bottom
  561.     py0 = f->Y[0] + t->edged_stride * t->height;
  562.     tmpy0 = f->Y[0] + t->edged_stride * (t->height - 1);
  563.     pu = f->U + t->edged_stride_uv * (t->height >> 1);
  564.     tmpu = f->U + t->edged_stride_uv * ((t->height >> 1) - 1);
  565.     pv = f->V + t->edged_stride_uv * (t->height >> 1);
  566.     tmpv = f->V + t->edged_stride_uv * ((t->height >> 1)- 1);
  567.     for(i = 0 ; i < (EDGED_HEIGHT >> 1) ; i ++)
  568.     {
  569.         // y
  570.         memcpy(py0, tmpy0, t->stride);
  571.         memset(py0 - EDGED_WIDTH, tmpy0[0], EDGED_WIDTH);
  572.         memset(py0 + t->stride, tmpy0[t->stride - 1], EDGED_WIDTH);
  573.         py0 += t->edged_stride;
  575.         memcpy(py0, tmpy0, t->stride);
  576.         memset(py0 - EDGED_WIDTH, tmpy0[0], EDGED_WIDTH);
  577.         memset(py0 + t->stride, tmpy0[t->stride - 1], EDGED_WIDTH);
  578.         py0 += t->edged_stride;
  580.         // u
  581.         memcpy(pu, tmpu, t->stride_uv);
  582.         memset(pu - (EDGED_WIDTH >> 1), tmpu[0], EDGED_WIDTH >> 1);
  583.         memset(pu + t->stride_uv, tmpu[t->stride_uv - 1], EDGED_WIDTH >> 1);
  584.         pu += t->edged_stride_uv;
  586.         // v
  587.         memcpy(pv, tmpv, t->stride_uv);
  588.         memset(pv - (EDGED_WIDTH >> 1), tmpv[0], EDGED_WIDTH >> 1);
  589.         memset(pv + t->stride_uv, tmpv[t->stride_uv - 1], EDGED_WIDTH >> 1);
  590.         pv += t->edged_stride_uv;
  591.     }
  592. }
  594. void
  595. T264_interpolate_halfpel(T264_t* t, T264_frame_t* f)
  596. {
  597.     int32_t src_offset;
  598.     int32_t width, height;
  600.     if (t->flags & (USE_HALFPEL| USE_QUARTPEL))
  601.     {
  602.         src_offset = - 3;
  603.         width      = t->width + 3 + 2;
  604.         height     = t->height;
  605.         t->interpolate_halfpel_h(f->Y[0] + src_offset, t->edged_stride, f->Y[1] + src_offset, t->edged_stride, width, height);
  606.         // extend border
  607.         {
  608.             uint8_t* src, *dst;
  609.             int32_t i;
  610.             // left & right
  611.             dst = f->Y[1] - EDGED_WIDTH;
  612.             src = f->Y[1] - 3;
  613.             for(i = 0 ; i < t->height ; i ++)
  614.             {
  615.                 // left
  616.                 memset(dst, src[0], EDGED_WIDTH - 3);
  617.                 // right
  618.                 memset(&dst[t->stride + EDGED_WIDTH + 2], src[t->stride - 1 + 3 + 2], EDGED_WIDTH - 2);
  619.                 dst += t->edged_stride;
  620.                 src += t->edged_stride;
  621.             }
  622.             // top
  623.             dst = f->Y[1] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
  624.             src = f->Y[1] - EDGED_WIDTH;
  625.             for(i = 0 ; i < EDGED_HEIGHT ; i ++)
  626.             {
  627.                 memcpy(dst, src, t->edged_stride);
  628.                 dst += t->edged_stride;
  629.             }
  630.             // bottom
  631.             src = f->Y[1] + (t->height - 1) * t->edged_stride - EDGED_WIDTH;
  632.             dst = src + t->edged_stride;
  633.             for(i = 0 ; i < EDGED_HEIGHT ; i ++)
  634.             {
  635.                 memcpy(dst, src, t->edged_stride);
  636.                 dst += t->edged_stride;
  637.             }
  638.         }
  639.         src_offset = - 3 * t->edged_stride;
  640.         width      = t->width;
  641.         height     = t->height + 3 + 2;
  642.         t->interpolate_halfpel_v(f->Y[0] + src_offset, t->edged_stride, f->Y[2] + src_offset, t->edged_stride, width, height);
  643.         // extend border
  644.         {
  645.             uint8_t* src, *dst;
  646.             int32_t i;
  647.             // left & right
  648.             dst = f->Y[2] - 3 * t->edged_stride - EDGED_WIDTH;
  649.             src = f->Y[2] - 3 * t->edged_stride;
  650.             for(i = 0 ; i < t->height + 3 + 2 ; i ++)
  651.             {
  652.                 // left
  653.                 memset(dst, src[0], EDGED_WIDTH);
  654.                 // right
  655.                 memset(&dst[t->stride + EDGED_WIDTH], src[t->stride - 1], EDGED_WIDTH);
  656.                 dst += t->edged_stride;
  657.                 src += t->edged_stride;
  658.             }
  659.             // top
  660.             dst = f->Y[2] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
  661.             src = f->Y[2] - 3 * t->edged_stride - EDGED_WIDTH;
  662.             for(i = 0 ; i < EDGED_HEIGHT - 3 ; i ++)
  663.             {
  664.                 memcpy(dst, src, t->edged_stride);
  665.                 dst += t->edged_stride;
  666.             }
  667.             // bottom
  668.             src = f->Y[2] + (t->height + 2 - 1) * t->edged_stride - EDGED_WIDTH;
  669.             dst = src + t->edged_stride;
  670.             for(i = 0 ; i < EDGED_HEIGHT - 2 ; i ++)
  671.             {
  672.                 memcpy(dst, src, t->edged_stride);
  673.                 dst += t->edged_stride;
  674.             }
  675.         }
  676.         if (t->flags & USE_FASTINTERPOLATE)
  677.         {
  678.             // NOTE: here just offset -3 is not enough to complete reverting the origin implemention
  679.             //   in Y[2] its border is already extend 3 + 2, the idea border in Y[3] is -3 -3 2 2
  680.             // If u use USE_FASTINTERPOLATE we prefer the speed is the first condition we do not extend the border further
  681.             src_offset = - 3;
  682.             width      = t->width + 3 + 2;
  683.             height     = t->height;
  684.             t->interpolate_halfpel_h(f->Y[2] + src_offset, t->edged_stride, f->Y[3] + src_offset, t->edged_stride, width, height);
  685.             // extend border
  686.             {
  687.                 uint8_t* src, *dst;
  688.                 int32_t i;
  689.                 // left & right
  690.                 dst = f->Y[3] - EDGED_WIDTH;
  691.                 src = f->Y[3] - 3;
  692.                 for(i = 0 ; i < t->height ; i ++)
  693.                 {
  694.                     // left
  695.                     memset(dst, src[0], EDGED_WIDTH - 3);
  696.                     // right
  697.                     memset(&dst[t->stride + EDGED_WIDTH + 2], src[t->stride - 1 + 3 + 2], EDGED_WIDTH - 2);
  698.                     dst += t->edged_stride;
  699.                     src += t->edged_stride;
  700.                 }
  701.                 // top
  702.                 dst = f->Y[3] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
  703.                 src = f->Y[3] - EDGED_WIDTH;
  704.                 for(i = 0 ; i < EDGED_HEIGHT ; i ++)
  705.                 {
  706.                     memcpy(dst, src, t->edged_stride);
  707.                     dst += t->edged_stride;
  708.                 }
  709.                 // bottom
  710.                 src = f->Y[3] + (t->height - 1) * t->edged_stride - EDGED_WIDTH;
  711.                 dst = src + t->edged_stride;
  712.                 for(i = 0 ; i < EDGED_HEIGHT ; i ++)
  713.                 {
  714.                     memcpy(dst, src, t->edged_stride);
  715.                     dst += t->edged_stride;
  716.                 }
  717.             }
  718.         }
  719.         else
  720.         {
  721.             src_offset = - 3 * t->edged_stride - 3;
  722.             width      = t->width + 3 + 2;
  723.             height     = t->height + 3 + 2;
  724.             t->interpolate_halfpel_hv(f->Y[0] + src_offset, t->edged_stride, f->Y[3] + src_offset, t->edged_stride, width, height);
  725.             // extend border
  726.             {
  727.                 uint8_t* src, *dst;
  728.                 int32_t i;
  729.                 // left & right
  730.                 dst = f->Y[3] - 3 * t->edged_stride - EDGED_WIDTH;
  731.                 src = f->Y[3] - 3 * t->edged_stride - 3;
  732.                 for(i = 0 ; i < t->height + 3 + 2 ; i ++)
  733.                 {
  734.                     // left
  735.                     memset(dst, src[0], EDGED_WIDTH - 3);
  736.                     // right
  737.                     memset(&dst[t->stride + EDGED_WIDTH + 2], src[t->stride - 1 + 3 + 2], EDGED_WIDTH - 2);
  738.                     dst += t->edged_stride;
  739.                     src += t->edged_stride;
  740.                 }
  741.                 // top
  742.                 dst = f->Y[3] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
  743.                 src = f->Y[3] - 3 * t->edged_stride - EDGED_WIDTH;
  744.                 for(i = 0 ; i < EDGED_HEIGHT - 3 ; i ++)
  745.                 {
  746.                     memcpy(dst, src, t->edged_stride);
  747.                     dst += t->edged_stride;
  748.                 }
  749.                 // bottom
  750.                 src = f->Y[3] + (t->height + 2 - 1) * t->edged_stride - EDGED_WIDTH;
  751.                 dst = src + t->edged_stride;
  752.                 for(i = 0 ; i < EDGED_HEIGHT - 2 ; i ++)
  753.                 {
  754.                     memcpy(dst, src, t->edged_stride);
  755.                     dst += t->edged_stride;
  756.                 }
  757.             }
  758.         }
  759.     }
  760. }
  762. static void
  763. T264_save_ref(T264_t* t)
  764. {
  765.     int32_t i;
  766.     T264_frame_t tmp;
  767.     /* deblock filter exec here */
  768.     if (t->param.disable_filter == 0)
  769.         T264_deblock_frame(t, t->rec);
  770.     /* current only del with i,p */
  771.     T264_extend_border(t, t->rec);
  772.     T264_interpolate_halfpel(t, t->rec);
  774.     tmp = t->refn[t->param.ref_num];
  775.     t->refn[0].poc = t->poc;
  776.     for(i = t->param.ref_num ; i >= 1 ; i --)
  777.     {
  778.         t->refn[i] = t->refn[i - 1];
  779.     }
  781.     t->refn[0] = tmp;
  782.     t->rec = &t->refn[0];
  783. }
  785. void
  786. T264_mb_mode_decision(T264_t* t)
  787. {
  788.     if(t->slice_type == SLICE_P)
  789.     {
  790.         T264_mode_decision_interp_y(t);
  791.     }
  792.     else if(t->slice_type == SLICE_B)
  793.     {
  794.         T264_mode_decision_interb_y(t);
  795.     }
  796.     else if (t->slice_type == SLICE_I)
  797.     {
  798.         T264_mode_decision_intra_y(t);
  799.     }
  800. }
  802. void
  803. T264_mb_encode(T264_t* t)
  804. {
  805.     if(t->mb.mb_mode == P_MODE)
  806.     {
  807.         T264_encode_inter_y(t);
  808.         T264_encode_inter_uv(t);
  810.         t->stat.p_block_num[t->mb.mb_part] ++;
  811.     }
  812.     else if(t->mb.mb_mode == P_SKIP)
  813.     {
  814.         t->stat.skip_block_num++;
  815.     }
  816.     else if (t->mb.mb_mode == B_MODE)
  817.     {
  818.         T264_encode_inter_y(t);
  819.         T264_encode_interb_uv(t);
  821.         t->stat.p_block_num[0] ++;
  822.     }
  823.     else if (t->mb.mb_mode == I_4x4 || t->mb.mb_mode == I_16x16)
  824.     {
  825.         T264_encode_intra_y(t);
  827.         //
  828.         // Chroma
  829.         //
  830.         T264_mode_decision_intra_uv(t);
  831.         T264_encode_intra_uv(t);
  833.         t->stat.i_block_num[t->mb.mb_mode] ++;
  834.     }
  835. }
  837. static void
  838. T264_emms_c()
  839. {
  840. }
  842. void
  843. T264_init_cpu(T264_t* t)
  844. {
  845. #ifndef CHIP_DM642
  846.     if ((t->param.cpu & T264_CPU_FORCE) != T264_CPU_FORCE)
  847.     {
  848.         t->param.cpu = T264_detect_cpu(); 
  849.     }
  850. #endif
  851.     t->pred16x16[Intra_16x16_TOP]    = T264_predict_16x16_mode_0_c;
  852.     t->pred16x16[Intra_16x16_LEFT]   = T264_predict_16x16_mode_1_c;
  853.     t->pred16x16[Intra_16x16_DC]     = T264_predict_16x16_mode_2_c;
  854.     t->pred16x16[Intra_16x16_PLANE]  = T264_predict_16x16_mode_3_c;
  855.     t->pred16x16[Intra_16x16_DCTOP]  = T264_predict_16x16_mode_20_c;
  856.     t->pred16x16[Intra_16x16_DCLEFT] = T264_predict_16x16_mode_21_c;
  857.     t->pred16x16[Intra_16x16_DC128]  = T264_predict_16x16_mode_22_c;
  858.     
  859.     t->pred8x8[Intra_8x8_TOP]    = T264_predict_8x8_mode_0_c;
  860.     t->pred8x8[Intra_8x8_LEFT]   = T264_predict_8x8_mode_1_c;
  861.     t->pred8x8[Intra_8x8_DC]     = T264_predict_8x8_mode_2_c;
  862.     t->pred8x8[Intra_8x8_PLANE]  = T264_predict_8x8_mode_3_c;
  863.     t->pred8x8[Intra_8x8_DCTOP]  = T264_predict_8x8_mode_20_c;
  864.     t->pred8x8[Intra_8x8_DCLEFT] = T264_predict_8x8_mode_21_c;
  865.     t->pred8x8[Intra_8x8_DC128]  = T264_predict_8x8_mode_22_c;
  867.     t->pred4x4[Intra_4x4_TOP]    = T264_predict_4x4_mode_0_c;
  868.     t->pred4x4[Intra_4x4_LEFT]   = T264_predict_4x4_mode_1_c;
  869.     t->pred4x4[Intra_4x4_DC]     = T264_predict_4x4_mode_2_c;
  870.     t->pred4x4[Intra_4x4_DCTOP]  = T264_predict_4x4_mode_20_c;
  871.     t->pred4x4[Intra_4x4_DCLEFT] = T264_predict_4x4_mode_21_c;
  872.     t->pred4x4[Intra_4x4_DC128]  = T264_predict_4x4_mode_22_c;
  874.     t->pred4x4[Intra_4x4_DIAGONAL_DOWNLEFT]  = T264_predict_4x4_mode_3_c;
  875.     t->pred4x4[Intra_4x4_DIAGONAL_DOWNRIGHT]  = T264_predict_4x4_mode_4_c;
  876.     t->pred4x4[Intra_4x4_VERTICAL_RIGHT]  = T264_predict_4x4_mode_5_c;
  877.     t->pred4x4[Intra_4x4_HORIZONTAL_DOWN]  = T264_predict_4x4_mode_6_c;
  878.     t->pred4x4[Intra_4x4_VERTICAL_LEFT]  = T264_predict_4x4_mode_7_c;
  879.     t->pred4x4[Intra_4x4_HORIZONTAL_UP]  = T264_predict_4x4_mode_8_c;
  881.     if (t->flags & USE_SAD)
  882.     {
  883.         t->cmp[MB_16x16] = T264_sad_u_16x16_c;
  884.         t->cmp[MB_16x8]  = T264_sad_u_16x8_c;
  885.         t->cmp[MB_8x16]  = T264_sad_u_8x16_c;
  886.         t->cmp[MB_8x8]   = T264_sad_u_8x8_c;
  887.         t->cmp[MB_8x4]   = T264_sad_u_8x4_c;
  888.         t->cmp[MB_4x8]   = T264_sad_u_4x8_c;
  889.         t->cmp[MB_4x4]   = T264_sad_u_4x4_c;
  890.     }
  891.     else
  892.     {
  893.         t->cmp[MB_16x16] = T264_satd_u_16x16_c;
  894.         t->cmp[MB_16x8]  = T264_satd_u_16x8_c;
  895.         t->cmp[MB_8x16]  = T264_satd_u_8x16_c;
  896.         t->cmp[MB_8x8]   = T264_satd_u_8x8_c;
  897.         t->cmp[MB_8x4]   = T264_satd_u_8x4_c;
  898.         t->cmp[MB_4x8]   = T264_satd_u_4x8_c;
  899.         t->cmp[MB_4x4]   = T264_satd_u_4x4_c;
  900.     }
  902.     t->sad[MB_16x16] = T264_sad_u_16x16_c;
  903.     t->sad[MB_16x8]  = T264_sad_u_16x8_c;
  904.     t->sad[MB_8x16]  = T264_sad_u_8x16_c;
  905.     t->sad[MB_8x8]   = T264_sad_u_8x8_c;
  906.     t->sad[MB_8x4]   = T264_sad_u_8x4_c;
  907.     t->sad[MB_4x8]   = T264_sad_u_4x8_c;
  908.     t->sad[MB_4x4]   = T264_sad_u_4x4_c;
  909.     t->fdct4x4   = dct4x4_c;
  910.     t->fdct4x4dc = dct4x4dc_c;
  911.     t->fdct2x2dc = dct2x2dc_c;
  912.     t->idct4x4   = idct4x4_c;
  913.     t->idct4x4dc = idct4x4dc_c;
  914.     t->idct2x2dc = idct2x2dc_c;
  916.     t->quant4x4    = quant4x4_c;
  917.     t->quant4x4dc  = quant4x4dc_c;
  918.     t->quant2x2dc  = quant2x2dc_c;
  919.     t->iquant4x4   = iquant4x4_c;
  920.     t->iquant4x4dc = iquant4x4dc_c;
  921.     t->iquant2x2dc = iquant2x2dc_c;
  923.     t->expand8to16   = expand8to16_c;
  924.     t->contract16to8 = contract16to8_c;
  925.     t->contract16to8add = contract16to8add_c;
  926.     t->expand8to16sub   = expand8to16sub_c;
  927.     t->memcpy_stride_u = memcpy_stride_u_c;
  928.     t->eighth_pixel_mc_u = T264_eighth_pixel_mc_u_c;
  930.     t->interpolate_halfpel_h = interpolate_halfpel_h_c;
  931.     t->interpolate_halfpel_v = interpolate_halfpel_v_c;
  932.     t->interpolate_halfpel_hv = interpolate_halfpel_hv_c;
  934.     //t->pixel_avg = T264_pixel_avg_c;  //modify by wushangyun for pia optimization
  935.     t->pia[MB_16x16] = T264_pia_u_16x16_c;
  936.     t->pia[MB_16x8]  = T264_pia_u_16x8_c;
  937.     t->pia[MB_8x16]  = T264_pia_u_8x16_c;
  938.     t->pia[MB_8x8]   = T264_pia_u_8x8_c;
  939.     t->pia[MB_8x4]   = T264_pia_u_8x4_c;
  940.     t->pia[MB_4x8]   = T264_pia_u_4x8_c;
  941.     t->pia[MB_4x4]   = T264_pia_u_4x4_c;
  942.     t->pia[MB_2x2]   = T264_pia_u_2x2_c;
  944.     t->T264_satd_16x16_u = T264_satd_i16x16_u_c;
  945.     t->emms = T264_emms_c;
  946.     
  947.     // flags relative
  948.     if (t->flags & USE_FULLSEARCH)
  949.         t->search = T264_spiral_search_full;
  950.     else if (t->flags & USE_DIAMONDSEACH)
  951.         t->search = T264_search;
  952.     else
  953.         t->search = T264_search_full;
  955. #ifndef CHIP_DM642
  956.     if (t->param.cpu & T264_CPU_MMX)
  957.     {
  958.         t->emms = T264_emms_mmx;
  959.         t->fdct4x4 = dct4x4_mmx;
  960.         t->fdct4x4dc = dct4x4dc_mmx;
  961.         t->idct4x4 = idct4x4_mmx;
  962.         t->idct4x4dc = idct4x4dc_mmx;
  963.     t->contract16to8add = contract16to8add_mmx;
  964.     t->expand8to16sub   = expand8to16sub_mmx;
  965.     
  966.         t->pia[MB_4x8]   = T264_pia_u_4x8_mmx;
  967.         t->pia[MB_4x4]   = T264_pia_u_4x4_mmx;
  968.     }
  969.     if (t->param.cpu & T264_CPU_SSE)
  970.     {
  971.         if (t->flags & USE_SAD)
  972.         {
  973.             t->cmp[MB_8x16]  = T264_sad_u_8x16_sse;
  974.             t->cmp[MB_8x8]   = T264_sad_u_8x8_sse;
  975.             t->cmp[MB_8x4]   = T264_sad_u_8x4_sse;
  976.             t->cmp[MB_4x8]   = T264_sad_u_4x8_sse;
  977.             t->cmp[MB_4x4]   = T264_sad_u_4x4_sse;
  978.         }
  980.         t->pia[MB_16x16] = T264_pia_u_16x16_sse;
  981.         t->pia[MB_16x8]  = T264_pia_u_16x8_sse;
  982.         t->pia[MB_8x16]  = T264_pia_u_8x16_sse;
  983.         t->pia[MB_8x8]   = T264_pia_u_8x8_sse;
  984.         t->pia[MB_8x4]   = T264_pia_u_8x4_sse;
  986.         t->sad[MB_8x16]  = T264_sad_u_8x16_sse;
  987.         t->sad[MB_8x8]   = T264_sad_u_8x8_sse;
  988.         t->sad[MB_8x4]   = T264_sad_u_8x4_sse;
  989.         t->sad[MB_4x8]   = T264_sad_u_4x8_sse;
  990.         t->sad[MB_4x4]   = T264_sad_u_4x4_sse;
  991.     }
  992.     if (t->param.cpu & T264_CPU_SSE2)
  993.     {
  994.         t->quant4x4 = quant4x4_sse2;
  995.         t->iquant4x4 = iquant4x4_sse2;
  996.         if (t->flags & USE_SAD)
  997.         {
  998.             t->cmp[MB_16x16] = T264_sad_u_16x16_sse2;
  999.             t->cmp[MB_16x8]  = T264_sad_u_16x8_sse2;
  1000.         }
  1002.         t->sad[MB_16x16] = T264_sad_u_16x16_sse2;
  1003.         t->sad[MB_16x8]  = T264_sad_u_16x8_sse2;
  1004.         t->interpolate_halfpel_h = interpolate_halfpel_h_sse2;
  1005.         t->interpolate_halfpel_v = interpolate_halfpel_v_sse2;
  1006.         t->pia[MB_16x16] = T264_pia_u_16x16_sse2;
  1007.         t->pia[MB_16x8]  = T264_pia_u_16x8_sse2;
  1008.     }
  1009. #endif    
  1010. }
  1012. static void __inline
  1013. T264_init_frame(T264_t* t, uint8_t* src, T264_frame_t* f, int32_t poc)
  1014. {
  1015.     f->Y[0] = src;
  1016.     f->U = f->Y[0] + t->width * t->height;
  1017.     f->V = f->U + (t->width * t->height >> 2);
  1018.     f->poc = poc;
  1019. }
  1021. static void __inline
  1022. T264_pending_bframe(T264_t* t, uint8_t* src, int32_t poc)
  1023. {
  1024.     T264_frame_t* f = &t->pending_bframes[t->pending_bframes_num ++];
  1026.     memcpy(f->Y[0], src, t->height * t->width + (t->height * t->width >> 1));
  1028.     f->poc = poc;
  1029. }
  1031. // get non zero count & cbp
  1032. void
  1033. T264_mb_encode_post(T264_t* t)
  1034. {
  1035.     int32_t i, j;
  1036. //for CABAC
  1037. int32_t dc_nz, dc_nz0, dc_nz1, cbp_dc;
  1038. cbp_dc = 0;
  1040.     if (t->mb.mb_mode == I_16x16)
  1041.     {
  1042.         t->mb.cbp_y = 0;
  1043.         for(i = 0; i < 16 ; i ++)
  1044.         {
  1045.             int32_t x, y;
  1046.             const int32_t nz = array_non_zero_count(&(t->mb.dct_y_z[i][1]), 15);
  1047.             x = luma_inverse_x[i];
  1048.             y = luma_inverse_y[i];
  1049.             t->mb.nnz[luma_index[i]] = nz;
  1050.             t->mb.nnz_ref[NNZ_LUMA + y * 8 + x] = nz;
  1051.             if( nz > 0 )
  1052.             {
  1053.                 t->mb.cbp_y = 0x0f;
  1054.             }
  1055.         }
  1056. //for CABAC, record the DC non_zero
  1057. dc_nz = array_non_zero_count(&(t->mb.dc4x4_z[0]), 16);
  1058. if(dc_nz != 0)
  1059. {
  1060. cbp_dc = 1;
  1061. }
  1062.     }
  1063.     else
  1064.     {
  1065.         t->mb.cbp_y = 0;
  1066.         for(i = 0; i < 16; i ++)
  1067.         {
  1068.             int32_t x, y;
  1069.             const int32_t nz = array_non_zero_count(t->mb.dct_y_z[i], 16);
  1070.             x = luma_inverse_x[i];
  1071.             y = luma_inverse_y[i];
  1072.             t->mb.nnz[luma_index[i]] = nz;
  1073.             t->mb.nnz_ref[NNZ_LUMA + y * 8 + x] = nz;
  1074.             if( nz > 0 )
  1075.             {
  1076.                 t->mb.cbp_y |= 1 << (i / 4);
  1077.             }
  1078.         }
  1079.     }
  1081.     /* Calculate the chroma patern */
  1082.     t->mb.cbp_c = 0;
  1083.     for(i = 0; i < 8; i ++)
  1084.     {
  1085.         int32_t x, y;
  1086.         const int nz = array_non_zero_count(&(t->mb.dct_uv_z[i / 4][i % 4][1]), 15);
  1087.         t->mb.nnz[i + 16] = nz;
  1088.         if (i < 4)
  1089.         {
  1090.             x = i % 2;
  1091.             y = i / 2;
  1092.             t->mb.nnz_ref[NNZ_CHROMA0 + y * 8 + x] = nz;
  1093.         }
  1094.         else
  1095.         {
  1096.             int32_t j = i - 4;
  1097.             x = j % 2;
  1098.             y = j / 2;
  1099.             t->mb.nnz_ref[NNZ_CHROMA1 + y * 8 + x] = nz;
  1100.         }
  1101.         if( nz > 0 )
  1102.         {
  1103.             t->mb.cbp_c = 0x02;    /* dc+ac */
  1104.         }
  1105.     }
  1106. //for CABAC, chroma dc pattern
  1107. dc_nz0 = array_non_zero_count(t->mb.dc2x2_z[0], 4) > 0;
  1108. dc_nz1 = array_non_zero_count(t->mb.dc2x2_z[1], 4) > 0;
  1109.     if(t->mb.cbp_c == 0x00 &&
  1110.        (dc_nz0 || dc_nz1))
  1111.     {
  1112.         t->mb.cbp_c = 0x01;    /* dc only */
  1113.     }
  1114. if(dc_nz0)
  1115. cbp_dc |= 0x02;
  1116. if(dc_nz1)
  1117. cbp_dc |= 0x04;
  1119.     // really decide SKIP mode
  1120.     if(t->slice_type == SLICE_P)
  1121.     {
  1122.         if (t->mb.mb_part == MB_16x16 && t->mb.cbp_y == 0 && t->mb.cbp_c == 0 && t->mb.vec[0][0].refno == 0)
  1123.         {
  1124.             T264_vector_t vec;
  1125.             T264_predict_mv_skip(t, 0, &vec);
  1126.             if (vec.x == t->mb.vec[0][0].x &&
  1127.                 vec.y == t->mb.vec[0][0].y)
  1128.             {
  1129.                 t->mb.mb_part = MB_16x16;
  1130.                 t->mb.mb_mode = P_SKIP;
  1131.             }
  1132.         }
  1133.     }
  1134.     else if (t->slice_type == SLICE_B)
  1135.     {
  1136.         if (t->mb.is_copy && t->mb.cbp_y == 0 && t->mb.cbp_c == 0)
  1137.         {
  1138.             t->mb.mb_mode = B_SKIP;
  1139.         }
  1140.     }
  1142.     if (t->mb.mb_mode == I_4x4)
  1143.     {
  1144.         int8_t* p = t->mb.i4x4_pred_mode_ref;
  1145.         for(i = 0; i < 16 ; i ++)
  1146.         {
  1147.             int32_t x, y;
  1148.             x = luma_inverse_x[i];
  1149.             y = luma_inverse_y[i];
  1150.             p[IPM_LUMA + y * 8 + x] = t->mb.mode_i4x4[i];
  1151.         }
  1152.     }
  1153.     else
  1154.     {
  1155.         memset(t->mb.mode_i4x4, Intra_4x4_DC, 16 * sizeof(uint8_t));
  1156.     }
  1158.     if (t->mb.mb_mode != I_4x4 && t->mb.mb_mode != I_16x16)
  1159.     {
  1160.         for(i = 0 ; i < 16 ; i ++)
  1161.         {
  1162.             int32_t x, y;
  1163.             x = i % 4;
  1164.             y = i / 4;
  1165.             t->mb.vec_ref[VEC_LUMA + y * 8 + x].vec[0]     = t->mb.vec[0][i];
  1166.             t->mb.vec_ref[VEC_LUMA + y * 8 + x].vec[1]     = t->mb.vec[1][i];
  1167.             t->mb.vec_ref[VEC_LUMA + y * 8 + x].part    = t->mb.mb_part;
  1168.             t->mb.vec_ref[VEC_LUMA + y * 8 + x].subpart = t->mb.submb_part[i];
  1169.         }
  1170.     }
  1171.     else
  1172.     {
  1173.         memset(t->mb.submb_part, -1, sizeof(uint8_t) * 16);//t->mb.submb_part));
  1174.         t->mb.mb_part = -1;
  1175. #define INITINVALIDVEC(vec) vec.refno = -1; vec.x = vec.y = 0;
  1176.         for(i = 0 ; i < 2 ; i ++)
  1177.         {
  1178.             for(j = 0 ; j < 16 ; j ++)
  1179.             {
  1180.                 INITINVALIDVEC(t->mb.vec[i][j]);
  1181.             }
  1182.         }
  1183.     }
  1184. #undef INITINVALIDVEC
  1185. //for CABAC, cbp
  1186. t->mb.cbp = t->mb.cbp_y | (t->mb.cbp_c<<4) | (cbp_dc << 8);
  1187. }
  1189. static uint32_t
  1190. write_dst(uint8_t* src, int32_t nal_pos[4], int32_t nal_num, uint8_t* dst, int32_t dst_size)
  1191. {
  1192.     int32_t i, j, n;
  1193.     int32_t count;
  1194.     int32_t nal_len;
  1196.     n = 0;
  1197.     for(i = 0 ; i < nal_num - 1; i ++)
  1198.     {
  1199.         nal_len = nal_pos[i + 1] - nal_pos[i];
  1200.         
  1201.         // start code 00 00 00 01
  1202.         dst[n ++] = src[0];
  1203.         dst[n ++] = src[1];
  1204.         dst[n ++] = src[2];
  1205.         dst[n ++] = src[3];
  1206.         count = 0;
  1207.         for(j = 4 ; j < nal_len - 1; j ++)
  1208.         {
  1209.             if (src[j] == 0)
  1210.             {
  1211.                 count ++;
  1212.                 if (count >= 2 && src[j + 1] <= 3)
  1213.                 {
  1214.                     dst[n ++] = 0;
  1215.                     dst[n ++] = 3;
  1216.                     count = 0;
  1217.                     continue;
  1218.                 }
  1219.             }
  1220.             else
  1221.             {
  1222.                 count = 0;
  1223.             }
  1224.             dst[n ++] = src[j];
  1225.         }
  1226.         dst[n ++] = src[j];
  1227.         src += nal_len;
  1228.     }
  1230.     return n;
  1231. }
  1233. ///////////////////////////////////////////////////////////
  1234. // interface
  1235. T264_t*
  1236. T264_open(T264_param_t* para)
  1237. {
  1238.     T264_t* t;
  1239.     int32_t i;
  1241.     //
  1242.     // TODO: here check the input param if it is valid
  1243.     //
  1244.     if (para->flags & USE_FORCEBLOCKSIZE)
  1245.         para->flags |= USE_SUBBLOCK;
  1246.     if (para->flags & USE_QUARTPEL)
  1247.         para->flags |= USE_HALFPEL;
  1249.     t = T264_malloc(sizeof(T264_t), CACHE_SIZE);
  1250.     memset(t, 0, sizeof(T264_t));
  1252.     t->mb_width  = para->width >> 4;
  1253.     t->mb_height = para->height >> 4;
  1254.     t->mb_stride = t->mb_width;
  1255.     t->width  = t->mb_width << 4;
  1256.     t->height = t->mb_height << 4;
  1257.     t->edged_width = t->width + 2 * EDGED_WIDTH;
  1258.     t->edged_height = t->height + 2 * EDGED_HEIGHT;
  1259.     t->qp_y   = para->qp;
  1260.     t->flags  = para->flags;
  1262.     t->stride    = t->width;
  1263.     t->stride_uv = t->width >> 1;
  1264.     t->edged_stride = t->edged_width;
  1265.     t->edged_stride_uv = t->edged_width >> 1;
  1267.     t->bs = T264_malloc(sizeof(bs_t), CACHE_SIZE);
  1268.     t->bs_buf = T264_malloc(t->width * t->height << 1, CACHE_SIZE);
  1269.     para->direct_flag = 1;  /* force direct mode */
  1270.     if (para->b_num)
  1271.         para->ref_num ++;
  1273.     for(i = 0 ; i < para->ref_num + 1 ; i ++)
  1274.     {
  1275.         uint8_t* p = T264_malloc(t->edged_width * t->edged_height + (t->edged_width * t->edged_height >> 1), CACHE_SIZE);
  1276.         t->refn[i].Y[0] = p + EDGED_HEIGHT * t->edged_width + EDGED_WIDTH;
  1277.         t->refn[i].U = p + t->edged_width * t->edged_height + (t->edged_width * EDGED_HEIGHT >> 2) + (EDGED_WIDTH >> 1);
  1278.         t->refn[i].V = p + t->edged_width * t->edged_height + (t->edged_width * t->edged_height >> 2) + (t->edged_width * EDGED_HEIGHT >> 2) + (EDGED_WIDTH >> 1);
  1279.         t->refn[i].mb = T264_malloc(t->mb_height * t->mb_width * sizeof(T264_mb_context_t), CACHE_SIZE);
  1280.         p = T264_malloc(t->edged_width * t->edged_height * 3, CACHE_SIZE);
  1281.         t->refn[i].Y[1] = p + EDGED_HEIGHT * t->edged_width + EDGED_WIDTH;
  1282.         t->refn[i].Y[2] = t->refn[i].Y[1] + t->edged_width * t->edged_height;
  1283.         t->refn[i].Y[3] = t->refn[i].Y[2] + t->edged_width * t->edged_height;
  1284.     }
  1285.     for(i = 0 ; i < para->b_num ; i ++)
  1286.     {
  1287.         t->pending_bframes[i].Y[0] = T264_malloc(t->width * t->height + (t->width * t->height >> 1), CACHE_SIZE);
  1288.     }
  1290.     t->param = *para;
  1291.     t->idr_pic_id = -1;
  1292.     t->frame_id = 0;
  1293.     t->last_i_frame_id = 0;
  1295.     T264_init_cpu(t);
  1297.     if (para->enable_rc)
  1298.     {
  1299.         rc_create(t, &t->plugins[t->plug_num]);
  1300.         t->plugins[t->plug_num].proc(t, t->plugins[t->plug_num].handle, STATE_BEFORESEQ);
  1301.         t->plug_num ++;
  1302.     }
  1303.     if (para->enable_stat)
  1304.     {
  1305.         stat_create(t, &t->plugins[t->plug_num]);
  1306.         t->plugins[t->plug_num].proc(t, t->plugins[t->plug_num].handle, STATE_BEFORESEQ);
  1307.         t->plug_num ++;
  1308.     }
  1309.     if (t->flags & USE_EXTRASUBPELSEARCH)
  1310.         t->subpel_pts = 8;
  1311.     else
  1312.         t->subpel_pts = 4;
  1314.     return t;
  1315. }
  1317. void
  1318. T264_close(T264_t* t)
  1319. {
  1320.     int32_t i;
  1322.     for(i = 0 ; i < t->param.ref_num + 1 ; i ++)
  1323.     {
  1324.         T264_free(t->refn[i].Y[0] - (EDGED_HEIGHT * t->edged_width + EDGED_WIDTH));
  1325.         T264_free(t->refn[i].mb);
  1326.         T264_free(t->refn[i].Y[1] - (EDGED_HEIGHT * t->edged_width + EDGED_WIDTH));
  1327.     }
  1329.     for(i = 0 ; i < t->plug_num ; i ++)
  1330.     {
  1331.         t->plugins[i].close(t, &t->plugins[i]);
  1332.     }
  1334.     for(i = 0 ; i < t->param.b_num ; i ++)
  1335.     {
  1336.         T264_free(t->pending_bframes[i].Y[0]);
  1337.     }
  1338.     T264_free(t->bs_buf);
  1339.     T264_free(t->bs);
  1341.     T264_free(t);
  1342. }
  1344. static void __inline
  1345. T264_encode_frame(T264_t* t)
  1346. {
  1347.     int32_t i, j;
  1349. //for test, to be cleaned
  1350. //extern int frame_cabac, mb_cabac, slice_type_cabac;
  1351.     T264_load_ref(t);
  1353.     slice_header_init(t, &t->slice);
  1354.     slice_header_write(t, &t->slice);
  1356.     t->header_bits = eg_len(t->bs) * 8;
  1357.     t->sad_all = 0;
  1358. //for CABAC
  1359. if( t->param.cabac )
  1360. {
  1361. /* alignment needed */
  1362. BitstreamPadOne( t->bs );
  1364. /* init cabac */
  1365. T264_cabac_context_init( &t->cabac, t->slice_type, t->ps.pic_init_qp_minus26+26+t->slice.slice_qp_delta, t->slice.cabac_init_idc );
  1366. T264_cabac_encode_init ( &t->cabac, t->bs );
  1367. }
  1368.     for(i = 0 ; i < t->mb_height ; i ++)
  1369.     {
  1370.         for(j = 0 ; j < t->mb_width ; j ++)
  1371.         {
  1372.             T264_mb_load_context(t, i, j);
  1374.             T264_mb_mode_decision(t);
  1376.             T264_mb_encode(t);
  1378.             T264_mb_encode_post(t);
  1380. if(t->param.cabac)
  1381. {
  1382. T264_mb_save_context(t);
  1383. }
  1384. //SKIP
  1385.             if(t->mb.mb_mode == P_SKIP || t->mb.mb_mode == B_SKIP)
  1386.             {
  1387. if( t->param.cabac )
  1388. {
  1389. if( t->mb.mb_xy > 0 )
  1390. {
  1391. /* not end_of_slice_flag */
  1392. T264_cabac_encode_terminal( &t->cabac, 0 );
  1393. }
  1395. T264_cabac_mb_skip( t, 1 );
  1396. //for CABAC, set MVD to zero
  1397. memset(&(t->mb.context->mvd[0][0][0]), 0, sizeof(t->mb.context->mvd));
  1398. }
  1399. else
  1400. {
  1401.                     t->skip ++;
  1402.                 }
  1403.             }
  1404.             else
  1405.             {
  1406. if( t->param.cabac )
  1407. {
  1408. //for CABAC, set MVD to zero
  1409. memset(&(t->mb.mvd[0][0][0]), 0, sizeof(t->mb.mvd));
  1410. if( t->mb.mb_xy > 0 )
  1411. {
  1412. /* not end_of_slice_flag */
  1413. T264_cabac_encode_terminal( &t->cabac, 0 );
  1414. }
  1415. if( t->slice_type != SLICE_I )
  1416. {
  1417. T264_cabac_mb_skip( t, 0 );
  1418. }
  1419. T264_macroblock_write_cabac( t, t->bs );
  1420. memcpy(&(t->mb.context->mvd[0][0][0]), &(t->mb.mvd[0][0][0]), sizeof(t->mb.context->mvd));
  1421. }
  1422.                 else
  1423.                 {
  1424.                     T264_macroblock_write_cavlc(t);
  1425.                 }
  1426.             }
  1427. if(!t->param.cabac)
  1428. {
  1429.                 T264_mb_save_context(t);
  1430. }
  1431.             t->sad_all += t->mb.sad;
  1432.         }
  1433.     }
  1435. if( t->param.cabac )
  1436. {
  1437. /* end of slice */
  1438. T264_cabac_encode_terminal( &t->cabac, 1 );
  1439. }
  1440. else if (t->skip > 0)
  1441.     {
  1442.         eg_write_ue(t->bs, t->skip);
  1443.         t->skip = 0;
  1444.     }
  1446. if( t->param.cabac )
  1447. {
  1448. int i_cabac_word;
  1449. int pos;
  1450. T264_cabac_encode_flush( &t->cabac );
  1451. /* TODO cabac stuffing things (p209) */
  1452. pos = BitstreamPos( t->bs)/8;
  1453. i_cabac_word = (((3 * t->cabac.i_sym_cnt - 3 * 96 * t->mb_width * t->mb_height)/32) - pos)/3;
  1455. while( i_cabac_word > 0 )
  1456. {
  1457. BitstreamPutBits( t->bs, 16, 0x0000 );
  1458. i_cabac_word--;
  1459. }
  1460. }
  1462.     /* update current pic */
  1463.     if (t->slice_type != SLICE_B)
  1464.     {
  1465.         T264_save_ref(t);
  1466.         t->frame_num = (t->frame_num + 1) % (1 << (t->ss.log2_max_frame_num_minus4 + 4));
  1467.         t->poc += 2;
  1468.     }
  1470.     rbsp_trailing_bits(t);
  1471.     eg_flush(t->bs);
  1472. //for CABAC
  1473. if( t->param.cabac )
  1474. {
  1475. T264_cabac_model_update( &t->cabac, t->slice_type, t->ps.pic_init_qp_minus26+26 + t->slice.slice_qp_delta );
  1476. }
  1477. }
  1479. static int32_t __inline
  1480. T264_flush_frames(T264_t* t, uint8_t* dst, int32_t dst_size)
  1481. {
  1482.     int32_t i, j = 0;
  1483.     int32_t nal_pos[4];     // remember each nal start pos
  1484.     int32_t nal_num;
  1485.     int32_t len = 0;
  1486.     int32_t old_poc = t->poc;
  1488.     // b frames
  1489.     while (t->pending_bframes_num)
  1490.     {
  1491.         t->pending_bframes_num --;
  1492.         t->poc = t->pending_bframes[j].poc;
  1494.         eg_init(t->bs, t->bs_buf, dst_size);
  1495.         T264_init_frame(t, t->pending_bframes[j].Y[0], &t->cur, t->poc);
  1496.         nal_num = 0;
  1498.         nal_pos[nal_num ++] = eg_len(t->bs);
  1499.         nal_unit_init(&t->nal, 0, NAL_SLICE_NOPART);
  1500.         nal_unit_write(t, &t->nal);
  1502.         t->slice_type        = SLICE_B;
  1504.         for(i = 0 ; i < t->plug_num ; i ++)
  1505.         {
  1506.             t->plugins[i].proc(t, t->plugins[i].handle, STATE_BEFOREPIC);
  1507.         }
  1509. T264_encode_frame(t);
  1510.         nal_pos[nal_num ++] = eg_len(t->bs);
  1512.         len += write_dst(t->bs_buf, nal_pos, nal_num, dst + len, dst_size - len);
  1514.         t->emms();
  1515.  
  1516.         t->frame_bits = len * 8;
  1518.         for(i = 0 ; i < t->plug_num ; i ++)
  1519.         {
  1520.             t->plugins[i].proc(t, t->plugins[i].handle, STATE_AFTERPIC);
  1521.         }
  1523.         j ++;
  1524.     }
  1526.     t->poc = old_poc;
  1528.     return len;
  1529. }
  1531. int32_t
  1532. T264_encode(T264_t* t, uint8_t* src, uint8_t* dst, int32_t dst_size)
  1533. {
  1534.     int32_t i;
  1535.     int32_t nal_pos[5];     // remember each nal start pos
  1536.     int32_t nal_num = 0;
  1537.     int32_t len;
  1539.     eg_init(t->bs, t->bs_buf, dst_size);
  1540.     T264_init_frame(t, src, &t->cur, t->poc);
  1542.     t->slice_type = decision_slice_type(t);
  1543.     switch (t->slice_type)
  1544.     {
  1545.     case SLICE_P:
  1546.         nal_pos[nal_num ++] = eg_len(t->bs);
  1547.         nal_unit_init(&t->nal, 1, NAL_SLICE_NOPART);
  1548.         nal_unit_write(t, &t->nal);
  1550.         break;
  1551.     case SLICE_B:
  1552.         // buffer b frame
  1553.         T264_pending_bframe(t, src, t->poc);
  1554.         t->poc += 2;
  1555.         t->frame_id ++;
  1556.         t->frame_no ++;
  1558.         return 0;
  1559.     case SLICE_I:
  1560.         nal_pos[nal_num ++] = eg_len(t->bs);
  1561.         nal_unit_init(&t->nal, 1, NAL_SLICE_NOPART);
  1562.         nal_unit_write(t, &t->nal);
  1564.         /* reset when begin a new gop */
  1565.         t->frame_no = 0;
  1566.         t->last_i_frame_id = t->frame_id;
  1568.         for(i = 0 ; i < t->plug_num ; i ++)
  1569.         {
  1570.             t->plugins[i].proc(t, t->plugins[i].handle, STATE_BEFOREGOP);
  1571.         }
  1573.         break;
  1574.     case SLICE_IDR:
  1575.         // fixed slice type
  1576.         t->slice_type = SLICE_I;
  1577.         if (t->frame_id == 0)
  1578.         {
  1579.             /* only write once */
  1580.             T264_custom_set_t set;
  1581.             nal_pos[nal_num ++] = eg_len(t->bs);
  1582.             nal_unit_init(&t->nal, 1, NAL_CUSTOM_SET);
  1583.             nal_unit_write(t, &t->nal);
  1584.             custom_set_init(t, &set);
  1585.             custom_set_write(t, &set);
  1586.         }
  1587.         // first flush b frames
  1588.         len = T264_flush_frames(t, dst, dst_size);
  1589.         dst += len;
  1590.         dst_size -= len;
  1591.         len = 0;
  1593.         nal_pos[nal_num ++] = eg_len(t->bs);
  1594.         nal_unit_init(&t->nal, 1, NAL_SEQ_SET);
  1595.         nal_unit_write(t, &t->nal);
  1597.         seq_set_init(t, &t->ss);
  1598.         seq_set_write(t, &t->ss);
  1600.         nal_pos[nal_num ++] = eg_len(t->bs);
  1602.         nal_unit_init(&t->nal, 1, NAL_PIC_SET);
  1603.         nal_unit_write(t, &t->nal);
  1605.         pic_set_init(t, &t->ps);
  1606.         pic_set_write(t, &t->ps);
  1608.         nal_pos[nal_num ++] = eg_len(t->bs);
  1610.         nal_unit_init(&t->nal, 1, NAL_SLICE_IDR);
  1611.         nal_unit_write(t, &t->nal);
  1613.         t->idr_pic_id = (t->idr_pic_id + 1) % 65535;
  1614.         t->frame_num = 0;
  1615.         t->last_i_frame_id = t->frame_id;
  1617.         /* reset when begin a new gop */
  1618.         t->frame_no = 0;
  1619.         t->poc = 0;
  1621.         T264_reset_ref(t);
  1623.         for(i = 0 ; i < t->plug_num ; i ++)
  1624.         {
  1625.             t->plugins[i].proc(t, t->plugins[i].handle, STATE_BEFOREGOP);
  1626.         }
  1627.         break;
  1628.     default:
  1629.         assert(0);
  1630.         break;
  1631.     }
  1633.     t->frame_id ++;
  1634.     t->frame_no ++;
  1636.     for(i = 0 ; i < t->plug_num ; i ++)
  1637.     {
  1638.         t->plugins[i].proc(t, t->plugins[i].handle, STATE_BEFOREPIC);
  1639.     }
  1641.     // i or p frame
  1642.     T264_encode_frame(t);
  1643.     nal_pos[nal_num ++] = eg_len(t->bs);
  1645.     len = write_dst(t->bs_buf, nal_pos, nal_num, dst, dst_size);
  1647.     t->emms();
  1649.     t->frame_bits = len * 8;
  1650.     for(i = 0 ; i < t->plug_num ; i ++)
  1651.     {
  1652.         t->plugins[i].proc(t, t->plugins[i].handle, STATE_AFTERPIC);
  1653.     }
  1655.     len += T264_flush_frames(t, dst + len, dst_size - len);
  1657.     return len;
  1658. }