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

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

mpeg/mp3

开发平台：

Visual C++

inter_b.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. * 2005.1.5 CloudWu<sywu@sohu.com> Modify T264_get_direct_mv
  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 "portab.h"
  24. #include "stdio.h"
  25. #ifndef CHIP_DM642
  26. #include "memory.h"
  27. #endif
  28. #include "T264.h"
  29. #include "inter.h"
  30. #include "inter_b.h"
  31. #include "intra.h"
  32. #include "estimation.h"
  33. #include "utility.h"
  34. #include "interpolate.h"
  35. #include "bitstream.h"
  36. #include <assert.h>
  37. #include "block.h"
  39. static int32_t __inline
  40. T264_detect_direct_16x16(T264_t* t)
  41. {
  42.     T264_vector_t vec_direct[2][16];
  44.     T264_get_direct_mv(t, vec_direct);
  46.     if (memcmp(vec_direct, t->mb.vec, sizeof(vec_direct)) == 0)
  47.     {
  48.         return 1;
  49.     }
  51.     return 0;
  52. }
  54. uint32_t
  55. T264_mode_decision_interb_y(_RW T264_t* t)
  56. {
  57.     DECLARE_ALIGNED_MATRIX(pred_8x8, 16, 16, uint8_t, CACHE_SIZE);
  58.     DECLARE_ALIGNED_MATRIX(pred_16x8, 16, 16, uint8_t, CACHE_SIZE);
  59.     DECLARE_ALIGNED_MATRIX(pred_8x16, 16, 16, uint8_t, CACHE_SIZE);
  60. DECLARE_ALIGNED_MATRIX(pred_p16x16, 16, 16, uint8_t, CACHE_SIZE);
  61.     uint32_t sad;
  62.     uint32_t sad_16x8;
  63.     uint32_t sad_8x16;
  64. uint32_t sad_16x16;
  65.     uint32_t sad_min;
  66.     uint8_t sub_part[4];
  67.     uint8_t part;
  68.     uint8_t part_16x8[2];
  69.     uint8_t part_8x16[2];
  70.     uint8_t* p_min = t->mb.pred_p16x16;
  71. uint32_t i,j;
  73.     T264_vector_t vec_16x16[2][2], vec_8x8[4][2];
  74.     T264_vector_t vec_16x8[2][2];
  75.     T264_vector_t vec_8x16[2][2];
  76.     T264_vector_t vec_4x4[2][16];
  78.     sad_min = T264_mode_decision_inter_16x16b(t, vec_16x16, t->mb.pred_p16x16, &part);
  79.     t->mb.mb_mode = B_MODE;
  80.     copy_nvec(&vec_16x16[0][0], &t->mb.vec[0][0], 4, 4, 4);
  81.     copy_nvec(&vec_16x16[0][1], &t->mb.vec[1][0], 4, 4, 4);
  82.     t->mb.mb_part = MB_16x16;
  83.     t->mb.mb_part2[0] = part;
  84. /*
  85.     if (t->mb.is_copy)
  86.     {
  87.         t->mb.sad = sad_min;
  88.         
  89.         return sad_min;
  90.     }
  91.     */
  93.     if (t->param.block_size & SEARCH_16x8B)
  94.     {
  95.         vec_16x8[0][0].refno = vec_16x16[0][0].refno;
  96.         sad_16x8 = T264_mode_decision_inter_16x8b(t, vec_16x8, pred_16x8, part_16x8);
  97.         if (sad_16x8 < sad_min)
  98.         {
  99.             p_min = pred_16x8;
  100.             t->mb.mb_part = MB_16x8;
  101.             t->mb.mb_part2[0] = part_16x8[0];
  102.             t->mb.mb_part2[1] = part_16x8[1];
  103.             sad_min = sad_16x8;
  104.             copy_nvec(&vec_16x8[0][0], &t->mb.vec[0][0], 4, 2, 4);
  105.             copy_nvec(&vec_16x8[0][1], &t->mb.vec[1][0], 4, 2, 4);
  106.             copy_nvec(&vec_16x8[1][0], &t->mb.vec[0][8], 4, 2, 4);
  107.             copy_nvec(&vec_16x8[1][1], &t->mb.vec[1][8], 4, 2, 4);
  108.         }
  109.     }
  111.     if (t->param.block_size & SEARCH_8x16B)
  112.     {
  113.         vec_8x16[0][0].refno = vec_16x16[0][0].refno;
  114.         sad_8x16 = T264_mode_decision_inter_8x16b(t, vec_8x16, pred_8x16, part_8x16);
  115.         if (sad_8x16 < sad_min)
  116.         {
  117.             p_min = pred_8x16;
  118.             t->mb.mb_part = MB_8x16;
  119.             t->mb.mb_part2[0] = part_8x16[0];
  120.             t->mb.mb_part2[1] = part_8x16[1];
  121.             sad_min = sad_8x16;
  122.             copy_nvec(&vec_8x16[0][0], &t->mb.vec[0][0], 2, 4, 4);
  123.             copy_nvec(&vec_8x16[0][1], &t->mb.vec[1][0], 2, 4, 4);
  124.             copy_nvec(&vec_8x16[1][0], &t->mb.vec[0][2], 2, 4, 4);
  125.             copy_nvec(&vec_8x16[1][1], &t->mb.vec[1][2], 2, 4, 4);
  126.         }
  127.     }
  129.     if (t->param.block_size & SEARCH_8x8B)
  130.     {
  131.         sad = 0;
  132.         for(i = 0 ; i < 4 ; i ++)
  133.         {
  134. vec_8x8[i][0].refno = vec_16x16[0][0].refno;
  135.             sad += T264_mode_decision_inter_8x8b(t, i, vec_8x8[i], pred_8x8, &sub_part[i]);
  136.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec[0] =
  137.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec[0] =
  138.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec[0] =
  139.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec[0] = vec_8x8[i][0];
  141.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec[1] =
  142.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec[1] =
  143.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec[1] =
  144.             t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec[1] = vec_8x8[i][1];
  145.         }
  147.         if (sad < sad_min)
  148.         {
  149.             sad_min = sad;
  150.             t->mb.mb_part = MB_8x8;
  151.             p_min = pred_8x8;
  153.             t->mb.submb_part[0] = sub_part[0];
  154.             t->mb.submb_part[luma_index[4]] = sub_part[1];
  155.             t->mb.submb_part[luma_index[8]] = sub_part[2];
  156.             t->mb.submb_part[luma_index[12]] = sub_part[3];
  158.             t->mb.vec[0][0] =
  159.             t->mb.vec[0][1] = 
  160.             t->mb.vec[0][4] = 
  161.             t->mb.vec[0][5] = vec_8x8[0][0];
  162.             t->mb.vec[1][0] =
  163.             t->mb.vec[1][1] = 
  164.             t->mb.vec[1][4] = 
  165.             t->mb.vec[1][5] = vec_8x8[0][1];
  167.             t->mb.vec[0][2] =
  168.             t->mb.vec[0][3] = 
  169.             t->mb.vec[0][6] = 
  170.             t->mb.vec[0][7] = vec_8x8[1][0];
  171.             t->mb.vec[1][2] =
  172.             t->mb.vec[1][3] = 
  173.             t->mb.vec[1][6] = 
  174.             t->mb.vec[1][7] = vec_8x8[1][1];
  176.             t->mb.vec[0][8] =
  177.             t->mb.vec[0][9] = 
  178.             t->mb.vec[0][12] = 
  179.             t->mb.vec[0][13] = vec_8x8[2][0];
  180.             t->mb.vec[1][8] =
  181.             t->mb.vec[1][9] = 
  182.             t->mb.vec[1][12] = 
  183.             t->mb.vec[1][13] = vec_8x8[2][1];
  185.             t->mb.vec[0][10] =
  186.             t->mb.vec[0][11] = 
  187.             t->mb.vec[0][14] = 
  188.             t->mb.vec[0][15] = vec_8x8[3][0];
  189.             t->mb.vec[1][10] =
  190.             t->mb.vec[1][11] = 
  191.             t->mb.vec[1][14] = 
  192.             t->mb.vec[1][15] = vec_8x8[3][1];
  193.         }
  194.     }
  196. t->mb.is_copy = 0;
  197.     sad_16x16 = T264_mode_decision_inter_direct_16x16b(t, vec_4x4, pred_p16x16, &part);
  198. if(sad_16x16 < sad_min)
  199. {
  200. for(i = 0;i < 2; ++i)
  201. for(j = 0;j < 16; ++j)
  202. t->mb.vec[i][j] = vec_4x4[i][j];
  203. p_min = pred_p16x16;
  204. t->mb.is_copy = 1;
  205. t->mb.mb_part = MB_16x16;
  206. t->mb.mb_part2[0] = part; //part;
  207. sad_min = sad_16x16;
  208. }
  209.     if (t->flags & USE_INTRAININTER)
  210.         sad = T264_mode_decision_intra_y(t);
  211.     else
  212.         sad = -1;
  214.     if (sad <= sad_min)
  215.     {
  216. t->mb.is_copy = 0;
  217.         sad_min = sad;
  218.     }
  219.     else
  220.     {
  221.         t->mb.mb_mode = B_MODE;
  222.         if (p_min != t->mb.pred_p16x16)
  223.             memcpy(t->mb.pred_p16x16, p_min, 16 * 16 * sizeof(uint8_t));
  224. /*        if (t->mb.mb_part == MB_16x16)
  225.             t->mb.is_copy = T264_detect_direct_16x16(t);*/
  226.     }
  228.     t->mb.sad = sad_min;
  230.     return t->mb.sad;
  231. }
  233. #define MINPOSITIVE(x, y) (x >= 0 && y >= 0) ? T264_MIN(x, y) : T264_MAX(x, y)
  234. static int32_t __inline
  235. T264_get_ref_idx(T264_t* t, int32_t list)
  236. {
  237.     int32_t ref_idx;
  238.     T264_vector_t vec[3];
  240.     vec[0] = t->mb.vec_ref[VEC_LUMA - 1].vec[list];
  241.     vec[1] = t->mb.vec_ref[VEC_LUMA - 8].vec[list];
  242.     vec[2] = t->mb.vec_ref[VEC_LUMA - 4].vec[list];
  243.     if (vec[2].refno == -2)
  244.     {
  245.         vec[2] = t->mb.vec_ref[VEC_LUMA - 8 - 1].vec[list];
  246.     }
  248.     ref_idx = MINPOSITIVE(vec[1].refno, vec[2].refno);
  249.     ref_idx = MINPOSITIVE(vec[0].refno, ref_idx);
  251.     return ref_idx;
  252. }
  253. #undef MINPOSITIVE
  255. static void __inline
  256. T264_try_get_col_zero_mv(T264_t* t, T264_vector_t vec_direct[2][16], int32_t refl0, int32_t refl1)
  257. {
  258.     int32_t i;
  259.     T264_mb_context_t* mb_n = &t->ref[1][0]->mb[t->mb.mb_xy];
  261. if(refl0 == 0 || refl1 == 0)
  262.     for (i = 0 ; i < 4 * 4 ; i ++)
  263.     {
  264.         if (((mb_n->vec[0][i].refno == 0) && 
  265.             ABS(mb_n->vec[0][i].x) <= 1 &&
  266.             ABS(mb_n->vec[0][i].y) <= 1) ||
  267. ((mb_n->vec[0][i].refno == -1) && (mb_n->vec[1][i].refno == 0) &&
  268.             ABS(mb_n->vec[1][i].x) <= 1 && ABS(mb_n->vec[1][i].y) <= 1))
  269.         {
  270.             if (refl0 == 0)
  271.             {
  272.                 vec_direct[0][i].refno = 0;
  273.                 vec_direct[0][i].x = 0;
  274.                 vec_direct[0][i].y = 0;
  275.             }
  276.             if (refl1 == 0)
  277.             {
  278.                 vec_direct[1][i].refno = 0;
  279.                 vec_direct[1][i].x = 0;
  280.                 vec_direct[1][i].y = 0;
  281.             }
  282.         }
  283.     }
  284. }
  286. void
  287. T264_get_direct_mv(T264_t* t, T264_vector_t vec_direct[2][16])
  288. {
  289.     int32_t refl0, refl1;
  290.     uint8_t mb_part;
  292.     if (t->param.direct_flag)
  293.     {
  294.         // l0
  295.         refl0 = T264_get_ref_idx(t, 0);
  296.         refl1 = T264_get_ref_idx(t, 1);
  298.         // directZeroPredictionFlag = 1
  299.         if (refl0 < 0 && refl1 < 0)
  300.         {
  301. int i,j;
  302.             //memset(vec_direct, 0, sizeof(vec_direct));
  303. for(i = 0;i < 2;++i)
  304. for(j = 0;j < 16; ++j)
  305. {
  306. vec_direct[i][j].refno = 0;
  307. vec_direct[i][j].x = 0;
  308. vec_direct[i][j].y = 0;
  309. }
  310.             return;
  311.         }
  313.     mb_part = t->mb.mb_part; //save old
  314.     t->mb.mb_part = MB_16x16;
  316.         if (refl0 < 0)
  317.         {
  318.             vec_direct[0][0].refno = refl0;
  319.             vec_direct[0][0].x = vec_direct[0][0].y = 0;
  320.             copy_nvec(&vec_direct[0][0], &vec_direct[0][0], 4, 4, 4);
  321.         }
  322.         else
  323.         {
  324.             // when refl0 > 0 use T264_predict_mv
  325.             T264_vector_t vec;
  327.             vec.refno = refl0;
  328.             T264_predict_mv(t, 0, 0, 4, &vec); 
  329.             copy_nvec(&vec, &vec_direct[0][0], 4, 4, 4);
  330.         }
  332.         if (refl1 < 0)
  333.         {
  334.             vec_direct[1][0].refno = refl1;
  335.             vec_direct[1][0].x = vec_direct[1][0].y = 0;
  336.             copy_nvec(&vec_direct[1][0], &vec_direct[1][0], 4, 4, 4);
  337.         }
  338.         else
  339.         {
  340.             T264_vector_t vec;
  342.             vec.refno = refl1;
  343.             T264_predict_mv(t, 1, 0, 4, &vec); 
  344.             copy_nvec(&vec, &vec_direct[1][0], 4, 4, 4);
  345.         }
  347.         // colZeroFlag
  348.         T264_try_get_col_zero_mv(t, vec_direct, refl0, refl1);
  350. t->mb.mb_part = mb_part; //restore
  351.     }
  352.     else
  353.     {
  354.         assert(0);
  355.     }    
  356. }
  358. uint32_t
  359. T264_mode_decision_inter_direct_16x16b(_RW T264_t* t, T264_vector_t predVec[2][4 * 4], uint8_t* pred, uint8_t* part)
  360. {
  361.     uint32_t sad;
  363. T264_get_direct_mv(t,predVec);
  364. T264_mb4x4_interb_mc(t,predVec,pred);
  365. sad = t->cmp[MB_16x16](pred,16,t->mb.src_y,t->stride);
  366. *part = B_DIRECT_16x16;
  368. return sad;
  369. }
  371. uint32_t
  372. T264_mode_decision_inter_16x16b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
  373. {
  374.     DECLARE_ALIGNED_MATRIX(pred_l1, 16, 16, uint8_t, CACHE_SIZE);
  375.     DECLARE_ALIGNED_MATRIX(pred_bi, 16, 16, uint8_t, CACHE_SIZE);
  376.     
  377.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  378.     T264_search_context_t context;
  379.     int32_t num;
  380.     uint32_t sad_min, sad;
  381.     uint8_t* pred_l0 = pred;
  382.     uint8_t* p_min = pred_l0;
  383.     T264_vector_t vec_median;
  384.     int32_t i;
  385.     uint8_t* p_buf = pred_l1;
  387.     context.height = 16;
  388.     context.width  = 16;
  389.     context.limit_x= t->param.search_x;
  390.     context.limit_y= t->param.search_y;
  391.     context.vec    = vec;
  392.     context.mb_part= MB_16x16;
  393.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  395.     // list 0
  396.     vec[0].refno = 0;
  397.     get_pmv(t, 0, vec, MB_16x16, 0, 4, &num);
  398.     context.vec_num= num;
  399.     context.list_index = 0;
  401.     sad_min = t->search(t, &context);
  402.     sad_min+= REFCOST(context.vec_best.refno);
  403.     sad_min = T264_quarter_pixel_search(t, 0, t->mb.src_y, t->ref[0][context.vec_best.refno], context.offset, 
  404.         &context.vec_best, &vec[0], sad_min, 16, 16, p_min, MB_16x16);
  405.     for(i = 1 ; i < t->refl0_num ; i ++)
  406.     {
  407.         T264_vector_t vec_best_bak, vec_median_bak;
  408.         
  409.         vec_median_bak = vec[0];
  410.         vec_best_bak = context.vec_best;
  411.         
  412.         vec[0].refno = i;
  413.         get_pmv(t, 0, vec, MB_16x16, 0, 4, &num);
  414.         context.vec_num= 1;
  415.         sad = t->search(t, &context);
  416.         sad+= REFCOST(context.vec_best.refno);
  417.         sad = T264_quarter_pixel_search(t, 0, t->mb.src_y, t->ref[0][i], context.offset, 
  418.             &context.vec_best, &vec[0], sad, 16, 16, p_buf, MB_16x16);
  419.         if (sad < sad_min)
  420.         {
  421.             SWAP(uint8_t, p_buf, p_min);
  422.             sad_min = sad;
  423.         }
  424.         else
  425.         {
  426.             vec[0] = vec_median_bak;
  427.             context.vec_best = vec_best_bak;
  428.         }
  429.     }
  430.     if (p_min != pred_l0)
  431.     {
  432.         memcpy(pred_l0, p_min, sizeof(uint8_t) * 16 * 16);
  433.     }
  435.     vec_best[0][0] = context.vec_best;
  436.     vec_median = vec[0];
  437.     *part = B_L0_16x16;
  439.     // list 1
  440.     vec_best[0][1].refno = -1;
  441.     vec_best[0][1].x = 0;
  442.     vec_best[0][1].y = 0;
  443.     if (t->refl1_num > 0)
  444.     {
  445.         uint32_t sad_l1, sad_bi;
  447.         vec[0].refno = 0;
  448.         get_pmv(t, 1, vec, MB_16x16, 0, 4, &num);
  449.         context.vec_num = num;
  450.         context.list_index = 1;
  452.         sad_l1 = t->search(t, &context);
  453.         sad_l1+= REFCOST1(context.vec_best.refno);
  454.         sad_l1 = T264_quarter_pixel_search(t, 1, t->mb.src_y, t->ref[1][context.vec_best.refno], context.offset, 
  455.             &context.vec_best, &vec[0], sad_l1, 16, 16, pred_l1, MB_16x16);
  456.         vec_best[0][1] = context.vec_best;
  458.         t->pia[MB_16x16](pred_l0, pred_l1, 16, 16, pred_bi, 16);
  459.         sad_bi = t->cmp[MB_16x16](t->mb.src_y, t->stride, pred_bi, 16) + t->mb.lambda *
  460.             (eg_size_se(t->bs, vec_best[0][0].x - vec_median.x) +
  461.              eg_size_se(t->bs, vec_best[0][0].y - vec_median.y) +
  462.              eg_size_se(t->bs, vec_best[0][1].x - vec[0].x) +
  463.              eg_size_se(t->bs, vec_best[0][1].y - vec[0].y)) +
  464.              REFCOST(vec_best[0][0].refno);
  466.         if (sad_bi < sad_min)
  467.         {
  468.             sad_min = sad_bi;
  469.             *part = B_Bi_16x16;
  470.             memcpy(pred_l0, pred_bi, 256 * sizeof(uint8_t));
  471.         }
  472.         if (sad_l1 < sad_min)
  473.         {
  474.             sad_min = sad_l1;
  475.             *part = B_L1_16x16;
  476.             memcpy(pred_l0, pred_l1, 256 * sizeof(uint8_t));
  478.             vec_best[0][0].refno = -1;
  479.             vec_best[0][0].x = 0;
  480.             vec_best[0][0].y = 0;
  481.         }
  482.         if (*part == B_L0_16x16)
  483.         {
  484.             vec_best[0][1].refno = -1;
  485.             vec_best[0][1].x = 0;
  486.             vec_best[0][1].y = 0;
  487.         }
  488.     }
  489. //    t->mb.is_copy = T264_detect_direct_16x16(t, vec_best[0]);
  491.     return sad_min;
  492. }
  494. uint32_t
  495. T264_mode_decision_inter_16x8b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
  496. {
  497.     DECLARE_ALIGNED_MATRIX(pred_l1_m, 16, 16, uint8_t, CACHE_SIZE);
  498.     DECLARE_ALIGNED_MATRIX(pred_bi_m, 16, 16, uint8_t, CACHE_SIZE);
  500.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  501.     T264_search_context_t context;
  502.     int32_t num;
  503.     uint32_t sad_min;
  504.     uint32_t sad_all = 0;
  505.     uint8_t* pred_l0 = pred;
  506.     uint8_t* pred_l1 = pred_l1_m;
  507.     uint8_t* pred_bi = pred_bi_m;
  508.     T264_vector_t vec_median;
  509.     uint8_t old_part = t->mb.mb_part;
  510.     int32_t i;
  511.     uint8_t* src;
  513.     t->mb.mb_part = MB_16x8;
  515.     context.height = 8;
  516.     context.width  = 16;
  517.     context.limit_x= t->param.search_x;
  518.     context.limit_y= t->param.search_y;
  519.     context.vec    = vec;
  520.     context.mb_part= MB_16x8;
  521.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  522.     src = t->mb.src_y;
  524.     for (i = 0 ; i < 2 ; i ++)
  525.     {
  526.         // list 0
  527.         vec[0].refno = vec_best[0][0].refno;
  528.         get_pmv(t, 0, vec, MB_16x8, luma_index[8 * i], 4, &num);
  529.         context.vec_num= num;
  530.         context.list_index = 0;
  532.         sad_min = t->search(t, &context);
  533.         sad_min+= REFCOST(context.vec_best.refno);
  534.         sad_min = T264_quarter_pixel_search(t, 0, src, t->ref[0][context.vec_best.refno], context.offset, 
  535.             &context.vec_best, &vec[0], sad_min, 16, 8, pred_l0, MB_16x8);
  536.         vec_best[i][0] = context.vec_best;
  537.         vec_median = vec[0];
  538.         part[i] = B_L0_16x8;
  540.         // list 1
  541.         vec_best[i][1].refno = -1;
  542.         vec_best[i][1].x = 0;
  543.         vec_best[i][1].y = 0;
  544.         if (t->refl1_num > 0)
  545.         {
  546.             uint32_t sad_l1, sad_bi;
  548.             vec[0].refno = 0;
  549.             get_pmv(t, 1, vec, MB_16x8, luma_index[8 * i], 4, &num);
  550.             context.vec_num = num;
  551.             context.list_index = 1;
  553.             sad_l1 = t->search(t, &context);
  554.             sad_l1+= REFCOST1(context.vec_best.refno);
  555.             sad_l1 = T264_quarter_pixel_search(t, 1, src, t->ref[1][context.vec_best.refno], context.offset, 
  556.                 &context.vec_best, &vec[0], sad_l1, 16, 8, pred_l1, MB_16x8);
  557.             vec_best[i][1] = context.vec_best;
  559.             t->pia[MB_16x8](pred_l0, pred_l1, 16, 16, pred_bi, 16);
  560.             sad_bi = t->cmp[MB_16x8](src, t->stride, pred_bi, 16) + t->mb.lambda *
  561.                 (eg_size_se(t->bs, vec_best[i][0].x - vec_median.x) +
  562.                 eg_size_se(t->bs, vec_best[i][0].y - vec_median.y) +
  563.                 eg_size_se(t->bs, vec_best[i][1].x - vec[0].x) +
  564.                 eg_size_se(t->bs, vec_best[i][1].y - vec[0].y)) +
  565.                 REFCOST(vec_best[i][0].refno);
  567.             if (sad_bi < sad_min)
  568.             {
  569.                 sad_min = sad_bi;
  570.                 part[i] = B_Bi_16x8;
  571.                 memcpy(pred_l0, pred_bi, sizeof(uint8_t) * 16 * 8);
  572.             }
  573.             if (sad_l1 < sad_min)
  574.             {
  575.                 sad_min = sad_l1;
  576.                 part[i] = B_L1_16x8;
  577.                 memcpy(pred_l0, pred_l1, sizeof(uint8_t) * 16 * 8);
  579.                 vec_best[i][0].refno = -1;
  580.                 vec_best[i][0].x = 0;
  581.                 vec_best[i][0].y = 0;
  582.             }
  583.             if (part[i] == B_L0_16x8)
  584.             {
  585.                 vec_best[i][1].refno = -1;
  586.                 vec_best[i][1].x = 0;
  587.                 vec_best[i][1].y = 0;
  588.             }
  589.         }
  591.         pred_l0 += 16 * 8;
  592.         pred_l1 += 16 * 8;
  593.         pred_bi += 16 * 8;
  594.         t->mb.vec_ref[VEC_LUMA + 8].vec[0] = vec_best[i][0];
  595.         t->mb.vec_ref[VEC_LUMA + 8].vec[1] = vec_best[i][1];
  596.         context.offset += 8 * t->edged_stride;
  597.         src += 8 * t->stride;
  598.         sad_all += sad_min;
  599.     }
  600.     t->mb.mb_part = old_part;
  602.     return sad_all;
  603. }
  605. uint32_t
  606. T264_mode_decision_inter_8x16b(_RW T264_t* t, T264_vector_t vec_best[2][2], uint8_t* pred, uint8_t* part)
  607. {
  608.     DECLARE_ALIGNED_MATRIX(pred_l1_m, 16, 16, uint8_t, CACHE_SIZE);
  609.     DECLARE_ALIGNED_MATRIX(pred_bi_m, 16, 16, uint8_t, CACHE_SIZE);
  611.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  612.     T264_search_context_t context;
  613.     int32_t num;
  614.     uint32_t sad_min;
  615.     uint32_t sad_all = 0;
  616.     uint8_t* pred_l0 = pred;
  617.     uint8_t* pred_l1 = pred_l1_m;
  618.     uint8_t* pred_bi = pred_bi_m;
  619.     T264_vector_t vec_median;
  620.     uint8_t old_part = t->mb.mb_part;
  621.     int32_t i;
  622.     uint8_t* src;
  624.     t->mb.mb_part = MB_8x16;
  626.     context.height = 16;
  627.     context.width  = 8;
  628.     context.limit_x= t->param.search_x;
  629.     context.limit_y= t->param.search_y;
  630.     context.vec    = vec;
  631.     context.mb_part= MB_8x16;
  632.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  633.     src = t->mb.src_y;
  635.     for (i = 0 ; i < 2 ; i ++)
  636.     {
  637.         // list 0
  638.         vec[0].refno = vec_best[0][0].refno;
  639.         get_pmv(t, 0, vec, MB_8x16, luma_index[4 * i], 2, &num);
  640.         context.vec_num= num;
  641.         context.list_index = 0;
  643.         sad_min = t->search(t, &context);
  644.         sad_min+= REFCOST(context.vec_best.refno);
  645.         sad_min = T264_quarter_pixel_search(t, 0, src, t->ref[0][context.vec_best.refno], context.offset, 
  646.             &context.vec_best, &vec[0], sad_min, 8, 16, pred_l0, MB_8x16);
  647.         vec_best[i][0] = context.vec_best;
  648.         vec_median = vec[0];
  649.         part[i] = B_L0_8x16;
  651.         // list 1
  652.         vec_best[i][1].refno = -1;
  653.         vec_best[i][1].x = 0;
  654.         vec_best[i][1].y = 0;
  655.         if (t->refl1_num > 0)
  656.         {
  657.             uint32_t sad_l1, sad_bi;
  659.             vec[0].refno = 0;
  660.             get_pmv(t, 1, vec, MB_8x16, luma_index[4 * i], 2, &num);
  661.             context.vec_num = num;
  662.             context.list_index = 1;
  664.             sad_l1 = t->search(t, &context);
  665.             sad_l1+= REFCOST1(context.vec_best.refno);
  666.             sad_l1 = T264_quarter_pixel_search(t, 1, src, t->ref[1][context.vec_best.refno], context.offset, 
  667.                 &context.vec_best, &vec[0], sad_l1, 8, 16, pred_l1, MB_8x16);
  668.             vec_best[i][1] = context.vec_best;
  670.             t->pia[MB_8x16](pred_l0, pred_l1, 16, 16, pred_bi, 16);
  671.             sad_bi = t->cmp[MB_8x16](src, t->stride, pred_bi, 16) + t->mb.lambda *
  672.                 (eg_size_se(t->bs, vec_best[i][0].x - vec_median.x) +
  673.                 eg_size_se(t->bs, vec_best[i][0].y - vec_median.y) +
  674.                 eg_size_se(t->bs, vec_best[i][1].x - vec[0].x) +
  675.                 eg_size_se(t->bs, vec_best[i][1].y - vec[0].y)) +
  676.                 REFCOST(vec_best[i][0].refno);
  678.             if (sad_bi < sad_min)
  679.             {
  680.                 sad_min = sad_bi;
  681.                 part[i] = B_Bi_8x16;
  682.                 t->memcpy_stride_u(pred_bi, 8, 16, 16, pred_l0, 16);
  683.             }
  684.             if (sad_l1 < sad_min)
  685.             {
  686.                 sad_min = sad_l1;
  687.                 part[i] = B_L1_8x16;
  688.                 t->memcpy_stride_u(pred_l1, 8, 16, 16, pred_l0, 16);
  690.                 vec_best[i][0].refno = -1;
  691.                 vec_best[i][0].x = 0;
  692.                 vec_best[i][0].y = 0;
  693.             }
  694.             if (part[i] == B_L0_8x16)
  695.             {
  696.                 vec_best[i][1].refno = -1;
  697.                 vec_best[i][1].x = 0;
  698.                 vec_best[i][1].y = 0;
  699.             }
  700.         }
  702.         pred_l0 += 8;
  703.         pred_l1 += 8;
  704.         pred_bi += 8;
  705.         t->mb.vec_ref[VEC_LUMA + 1].vec[0] = vec_best[i][0];
  706.         t->mb.vec_ref[VEC_LUMA + 1].vec[1] = vec_best[i][1];
  707.         context.offset += 8;
  708.         src += 8;
  709.         sad_all += sad_min;
  710.     }
  711.     t->mb.mb_part = old_part;
  713.     return sad_all;
  714. }
  716. uint32_t
  717. T264_mode_decision_inter_8x8b(_RW T264_t * t, int32_t i, T264_vector_t vec_best[2], uint8_t* pred, uint8_t* part)
  718. {
  719.     DECLARE_ALIGNED_MATRIX(pred_l1, 16, 16, uint8_t, CACHE_SIZE);
  720.     DECLARE_ALIGNED_MATRIX(pred_bi, 16, 16, uint8_t, CACHE_SIZE);
  722.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  723.     T264_search_context_t context;
  724.     int32_t num;
  725.     uint32_t sad_min;
  726.     T264_vector_t vec_median;
  727.     uint8_t* pred_l0 = pred;
  728.     uint8_t* src = t->mb.src_y + (i / 2 * 8) * t->stride + i % 2 * 8;
  729.     uint8_t* dst = pred + i / 2 * 16 * 8 + i % 2 * 8;
  731.     context.height = 8;
  732.     context.width  = 8;
  733.     context.limit_x= t->param.search_x;
  734.     context.limit_y= t->param.search_y;
  735.     context.vec    = vec;
  736.     context.mb_part= MB_8x8;
  737.     context.offset = ((t->mb.mb_y << 4) + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + i % 2 * 8;
  739.     vec[0].refno = vec_best[0].refno;
  740.     get_pmv(t, 0, vec, MB_8x8, luma_index[4 * i], 2, &num);
  741.     context.vec_num= num;
  742.     context.list_index = 0;
  744.     sad_min = t->search(t, &context);
  745.     sad_min+= eg_size_ue(t->bs, B_L0_8x8) + REFCOST(context.vec_best.refno);
  746.     sad_min = T264_quarter_pixel_search(t, 0, src, t->ref[0][context.vec_best.refno], context.offset, 
  747.         &context.vec_best, &vec[0], sad_min, 8, 8, dst, MB_8x8);
  748.     vec_best[0] = context.vec_best;
  749.     vec_median = vec[0];
  750.     *part = B_L0_8x8;
  752.     // list 1
  753.     vec_best[1].refno = -1;
  754.     vec_best[1].x = 0;
  755.     vec_best[1].y = 0;
  756.     if (t->refl1_num > 0)
  757.     {
  758.         uint32_t sad_l1, sad_bi;
  760.         vec[0].refno = 0;
  761.         get_pmv(t, 1, vec, MB_8x8, luma_index[4 * i], 2, &num);
  762.         context.vec_num= num;
  763.         context.list_index = 1;
  765.         sad_l1 = t->search(t, &context);
  766.         sad_l1+= eg_size_ue(t->bs, B_L1_8x8) + REFCOST1(context.vec_best.refno);
  767.         sad_l1 = T264_quarter_pixel_search(t, 1, src, t->ref[1][context.vec_best.refno], context.offset, 
  768.             &context.vec_best, &vec[0], sad_l1, 8, 8, pred_l1, MB_8x8);
  769.         vec_best[1] = context.vec_best;
  771.         t->pia[MB_8x8](dst, pred_l1, 16, 16, pred_bi, 16);
  772.         sad_bi = t->cmp[MB_8x8](src, t->stride, pred_bi, 16) + t->mb.lambda *
  773.            (eg_size_se(t->bs, vec_best[0].x - vec_median.x) +
  774.             eg_size_se(t->bs, vec_best[0].y - vec_median.y) +
  775.             eg_size_se(t->bs, vec_best[1].x - vec[0].x) +
  776.             eg_size_se(t->bs, vec_best[1].y - vec[0].y) + 
  777.             2 * T264_MIN(context.vec_best.refno, 1)) +
  778.             eg_size_ue(t->bs, B_Bi_8x8) +
  779.             REFCOST(vec_best[0].refno);
  780.         if (sad_bi < sad_min)
  781.         {
  782.             sad_min = sad_bi;
  783.             *part = B_Bi_8x8;
  784.             t->memcpy_stride_u(pred_bi, 8, 8, 16, dst, 16);
  785.         }
  786.         if (sad_l1 < sad_min)
  787.         {
  788.             sad_min = sad_l1;
  789.             *part = B_L1_8x8;
  790.             t->memcpy_stride_u(pred_l1, 8, 8, 16, dst, 16);
  791.             
  792.             vec_best[0].refno = -1;
  793.             vec_best[0].x = 0;
  794.             vec_best[0].y = 0;
  795.         }
  796.         if (*part == B_L0_8x8)
  797.         {
  798.             vec_best[1].refno = -1;
  799.             vec_best[1].x = 0;
  800.             vec_best[1].y = 0;
  801.         }
  802.     }
  804.     return sad_min;
  805. }
  807. void
  808. T264_encode_interb_uv(_RW T264_t* t)
  809. {
  810.     DECLARE_ALIGNED_MATRIX(pred_u, 8, 8, uint8_t, CACHE_SIZE);
  811.     DECLARE_ALIGNED_MATRIX(pred_v, 8, 8, uint8_t, CACHE_SIZE);
  812.     DECLARE_ALIGNED_MATRIX(pred_u_l0, 8, 8, uint8_t, CACHE_SIZE);
  813.     DECLARE_ALIGNED_MATRIX(pred_v_l0, 8, 8, uint8_t, CACHE_SIZE);
  814.     DECLARE_ALIGNED_MATRIX(pred_u_l1, 8, 8, uint8_t, CACHE_SIZE);
  815.     DECLARE_ALIGNED_MATRIX(pred_v_l1, 8, 8, uint8_t, CACHE_SIZE);
  817.     T264_vector_t vec;
  818.     uint8_t* src, *dst;
  819.     int32_t i;
  821. if(t->mb.is_copy)
  822. {
  823. T264_mb4x4_interb_uv_mc(t,t->mb.vec,pred_u,pred_v);
  824. }else
  825.     switch (t->mb.mb_part)
  826.     {
  827.     case MB_16x16:
  828.         {
  829.             switch (t->mb.mb_part2[0])
  830.             {
  831.             case B_L0_16x16:
  832.                 vec = t->mb.vec[0][0];
  833.                 src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  834.                 dst = pred_u;
  835.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  836.                 src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  837.                 dst = pred_v;
  838.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  839.                 break;
  840.             case B_L1_16x16:
  841.                 vec = t->mb.vec[1][0];
  842.                 src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  843.                 dst = pred_u;
  844.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  845.                 src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  846.                 dst = pred_v;
  847.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  848.                 break;
  849.             case B_Bi_16x16:
  850.                 vec = t->mb.vec[0][0];
  851.                 src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  852.                 dst = pred_u_l0;
  853.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  854.                 src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  855.                 dst = pred_v_l0;
  856.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  858.                 vec = t->mb.vec[1][0];
  859.                 src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  860.                 dst = pred_u_l1;
  861.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  862.                 src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  863.                 dst = pred_v_l1;
  864.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  866.                 t->pia[MB_8x8](pred_u_l0, pred_u_l1, 8, 8, pred_u, 8);
  867.                 t->pia[MB_8x8](pred_v_l0, pred_v_l1, 8, 8, pred_v, 8);
  868.                 break;
  869.             }
  870.         }
  871.         break;
  872.     case MB_16x8:
  873.         {
  874.             for (i = 0 ; i < 2 ; i ++)
  875.             {
  876.                 switch (t->mb.mb_part2[i])
  877.                 {
  878.                 case B_L0_16x8:
  879.                     vec = t->mb.vec[0][i * 8];
  880.                     src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  881.                     dst = pred_u + i * 8 * 4;
  882.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  883.                     src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  884.                     dst = pred_v + i * 8 * 4;
  885.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  886.                     break;
  887.                 case B_L1_16x8:
  888.                     vec = t->mb.vec[1][i * 8];
  889.                     src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  890.                     dst = pred_u + i * 8 * 4;
  891.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  892.                     src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  893.                     dst = pred_v + i * 8 * 4;
  894.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  895.                     break;
  896.                 case B_Bi_16x8:
  897.                     vec = t->mb.vec[0][i * 8];
  898.                     src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  899.                     dst = pred_u_l0 + i * 8 * 4;
  900.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  901.                     src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  902.                     dst = pred_v_l0 + i * 8 * 4;
  903.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  905.                     vec = t->mb.vec[1][i * 8];
  906.                     src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  907.                     dst = pred_u_l1 + i * 8 * 4;
  908.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  909.                     src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  910.                     dst = pred_v_l1 + i * 8 * 4;
  911.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  913.                     t->pia[MB_8x4](pred_u_l0 + i * 8 * 4, pred_u_l1 + i * 8 * 4, 8, 8, pred_u + i * 8 * 4, 8);
  914.                     t->pia[MB_8x4](pred_v_l0 + i * 8 * 4, pred_v_l1 + i * 8 * 4, 8, 8, pred_v + i * 8 * 4, 8);
  915.                     break;
  916.                 }
  917.             }
  918.         }
  919.         break;
  920.     case MB_8x16:
  921.         {
  922.             for (i = 0 ; i < 2 ; i ++)
  923.             {
  924.                 switch (t->mb.mb_part2[i])
  925.                 {
  926.                 case B_L0_8x16:
  927.                     vec = t->mb.vec[0][i * 2];
  928.                     src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  929.                     dst = pred_u + i * 4;
  930.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  931.                     src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  932.                     dst = pred_v + i * 4;
  933.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  934.                     break;
  935.                 case B_L1_8x16:
  936.                     vec = t->mb.vec[1][i * 2];
  937.                     src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  938.                     dst = pred_u + i * 4;
  939.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  940.                     src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  941.                     dst = pred_v + i * 4;
  942.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  943.                     break;
  944.                 case B_Bi_8x16:
  945.                     vec = t->mb.vec[0][i * 2];
  946.                     src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  947.                     dst = pred_u_l0 + i * 4;
  948.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  949.                     src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  950.                     dst = pred_v_l0 + i * 4;
  951.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  953.                     vec = t->mb.vec[1][i * 2];
  954.                     src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  955.                     dst = pred_u_l1 + i * 4;
  956.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  957.                     src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + i * 4;
  958.                     dst = pred_v_l1 + i * 4;
  959.                     t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  961.                     t->pia[MB_4x8](pred_u_l0 + i * 4, pred_u_l1 + i * 4, 8, 8, pred_u + i * 4, 8);
  962.                     t->pia[MB_4x8](pred_v_l0 + i * 4, pred_v_l1 + i * 4, 8, 8, pred_v + i * 4, 8);
  963.                     break;
  964.                 }
  965.             }
  966.         }
  967.         break;
  968.     case MB_8x8:
  969.         for(i = 0 ; i < 4 ; i ++)
  970.         {
  971.             int32_t offset = i / 2 * 32 + i % 2 * 4;
  972.             switch(t->mb.submb_part[luma_index[4 * i]])
  973.             {
  974.             case B_L0_8x8:
  975.                 vec = t->mb.vec[0][luma_index[4 * i]];
  976.                 src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  977.                 dst = pred_u + offset;
  978.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  979.                 src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  980.                 dst = pred_v + offset;
  981.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  982.                 break;
  983.             case B_L1_8x8:
  984.                 vec = t->mb.vec[1][luma_index[4 * i]];
  985.                 src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  986.                 dst = pred_u + offset;
  987.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  988.                 src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  989.                 dst = pred_v + offset;
  990.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  991.                 break;
  992.             case B_Bi_8x8:
  993.                 vec = t->mb.vec[0][luma_index[4 * i]];
  994.                 src = t->ref[0][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  995.                 dst = pred_u_l0 + offset;
  996.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  997.                 src = t->ref[0][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  998.                 dst = pred_v_l0 + offset;
  999.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  1001.                 vec = t->mb.vec[1][luma_index[4 * i]];
  1002.                 src = t->ref[1][vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  1003.                 dst = pred_u_l1 + offset;
  1004.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  1005.                 src = t->ref[1][vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3) + i / 2 * 4) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + (i % 2 * 4);
  1006.                 dst = pred_v_l1 + offset;
  1007.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  1009.                 t->pia[MB_4x4](pred_u_l0 + offset, pred_u_l1 + offset, 8, 8, pred_u + offset, 8);
  1010.                 t->pia[MB_4x4](pred_v_l0 + offset, pred_v_l1 + offset, 8, 8, pred_v + offset, 8);
  1011.                 break;
  1012.             default:
  1013.                 break;
  1014.             }
  1015.         }
  1016.         break;
  1017.     default:
  1018.         break;
  1019.     }
  1021.     T264_transform_inter_uv(t, pred_u, pred_v);
  1022. }