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

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

mpeg/mp3

开发平台：

Visual C++

inter_test.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.  *   llcc 2004-9-23
  9.  *
  10.  *   Test for sub-pel search after integer pel search in mode dicision(call mode1)
  11.  *   vs only integer search in mode dicision in orgin design(call mode2).
  12.  *   test result(jm80 have modified to conform to our condition):
  13.  *   (1I + 299P), foreman.cif, qp = 30, no i16x16
  14.  *               8x16(bytes)   16x8(bytes)
  15.  *   jm80        743430        750905
  16.  *   t264        746615        756162
  17.  *   (mode1+spiral full search)
  18.  *   t264        745866        755622
  19.  *   (mode2+spiral full search)
  20.  *   t264        792700        801691
  21.  *   (mode1+pmvfast)
  22.  *   t264        793219        804540
  23.  *   (mode2+pmvfast)
  24.  *   NOTE: if u want to test this file, please change pred_p16x16[16 * 16] in t264.h 
  25.  *   to pred_p16x16[4][16 * 16].
  26.  *   Yes, we will keep our older design.
  27.  *
  28.  *  This program is free software ; you can redistribute it and/or modify
  29.  *  it under the terms of the GNU General Public License as published by
  30.  *  the Free Software Foundation ; either version 2 of the License, or
  31.  *  (at your option) any later version.
  32.  *
  33.  *  This program is distributed in the hope that it will be useful,
  34.  *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  35.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  36.  *  GNU General Public License for more details.
  37.  *
  38.  *  You should have received a copy of the GNU General Public License
  39.  *  along with this program ; if not, write to the Free Software
  40.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  41.  *
  42.  ****************************************************************************/
  44. #include "stdio.h"
  45. #include "memory.h"
  46. #include "T264.h"
  47. #include "inter.h"
  48. #include "intra.h"
  49. #include "estimation.h"
  50. #include "utility.h"
  51. #include "interpolate.h"
  53. void
  54. T264_predict_mv(T264_t* t, int32_t list, int32_t i, int32_t width, T264_vector_t* vec)
  55. {
  56.     int32_t n;
  57.     int32_t count = 0;
  58.     int32_t idx;
  59.     int32_t row;
  60.     int32_t col;
  61.     int32_t org;
  62.     T264_vector_t vec_n[3];
  64.     n = vec->refno;
  65.     org = i;
  66.     i = luma_index[i];
  68.     col = org % 4;
  69.     row = org / 4;
  71.     vec_n[0] = t->mb.vec_ref[VEC_LUMA - 1 + row * 8 + col].vec;
  72.     vec_n[1] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col].vec;
  73.     vec_n[2] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col + width].vec;
  74.     if (vec_n[2].refno == -2)
  75.     {
  76.         vec_n[2] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col - 1].vec;
  77.     }
  78.     if (((i & 3) == 3) || ((i & 3) == 2 && width == 2))
  79.     {
  80.         vec_n[2] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col - 1].vec;
  81.     }
  82.     if (t->mb.mb_part == MB_16x8)
  83.     {
  84.         if (i == 0 && n == vec_n[1].refno)
  85.         {
  86.             vec[0] = vec_n[1];
  87.             return;
  88.         }
  89.         else if (i != 0 && n == vec_n[0].refno)
  90.         {
  91.             vec[0] = vec_n[0];
  92.             return;
  93.         }
  94.     }
  95.     else if (t->mb.mb_part == MB_8x16)
  96.     {
  97.         if (i == 0 && n == vec_n[0].refno)
  98.         {
  99.             vec[0] = vec_n[0];
  100.             return;
  101.         }
  102.         else if (i != 0 && n == vec_n[2].refno)
  103.         {
  104.             vec[0] = vec_n[2];
  105.             return;
  106.         }
  107.     }
  109.     if (vec_n[0].refno == n)
  110.     {
  111.         count ++;
  112.         idx = 0;
  113.     }
  114.     if (vec_n[1].refno == n)
  115.     {
  116.         count ++;
  117.         idx = 1;
  118.     }
  119.     if (vec_n[2].refno == n)
  120.     {
  121.         count ++;
  122.         idx = 2;
  123.     }
  125.     if (count > 1)
  126.     {
  127.         vec[0].x = T264_median(vec_n[0].x, vec_n[1].x, vec_n[2].x);
  128.         vec[0].y = T264_median(vec_n[0].y, vec_n[1].y, vec_n[2].y);
  129.         return;
  130.     }
  131.     else if (count == 1)
  132.     {
  133.         vec[0] = vec_n[idx];
  134.         return;
  135.     }
  136.     else if (vec_n[1].refno == -2 && vec_n[2].refno == -2 && vec_n[0].refno != -2)
  137.     {
  138.         vec[0] = vec_n[0];
  139.     }
  140.     else
  141.     {
  142.         vec[0].x = T264_median(vec_n[0].x, vec_n[1].x, vec_n[2].x);
  143.         vec[0].y = T264_median(vec_n[0].y, vec_n[1].y, vec_n[2].y);
  144.         return;        
  145.     }
  146. }
  148. int32_t 
  149. T264_median(int32_t x, int32_t y, int32_t z)
  150. {
  151.     int32_t min, max;
  152.     if (x < y)
  153.     {
  154.         min = x;
  155.         max = y;
  156.     }
  157.     else
  158.     {
  159.         min = y;
  160.         max = x;
  161.     }
  163.     if (z < min)
  164.     {
  165.         min = z;
  166.     }
  167.     else if (z > max)
  168.     {
  169.         max = z;
  170.     }
  172.     return x + y + z - min - max;
  173. }
  175. void
  176. copy_nvec(T264_vector_t* src, T264_vector_t* dst, int32_t width, int32_t height, int32_t stride)
  177. {
  178.     int32_t i, j;
  180.     for(i = 0 ; i < height ; i ++)
  181.     {
  182.         for(j = 0 ; j < width ; j ++)
  183.         {
  184.             dst[j] = src[0];
  185.         }
  186.         dst += stride;
  187.     }
  188. }
  190. void
  191. T264_inter_p16x16_mode_available(T264_t* t, int32_t preds[], int32_t* modes)
  192. {
  193.     if (t->flags & USE_FORCEBLOCKSIZE)
  194.     {
  195.         *modes = 0;
  196.       
  197.         if (t->param.block_size & SEARCH_16x16P)
  198.             preds[(*modes) ++] = MB_16x16;
  199.         if (t->param.block_size & SEARCH_16x8P)
  200.             preds[(*modes) ++] = MB_16x8;
  201.         if (t->param.block_size & SEARCH_8x16P)
  202.             preds[(*modes) ++] = MB_8x16;
  204.         return ;
  205.     }
  207.     if ((t->mb.mb_neighbour & (MB_LEFT | MB_TOP)) == (MB_LEFT | MB_TOP))
  208.     {
  209.         *modes = 0;
  211.         preds[(*modes) ++] = MB_16x16;
  212.         if (t->mb.vec_ref[VEC_LUMA - 1].part == MB_16x8)
  213.         {
  214.             preds[(*modes) ++] = MB_16x8;
  215.         }
  216.         if (t->mb.vec_ref[VEC_LUMA - 8].part == MB_8x16)
  217.         {
  218.             preds[(*modes) ++] = MB_8x16;
  219.         }
  220.     }
  221.     else
  222.     {
  223.         // try all
  224.         preds[0] = MB_16x16;
  225.         preds[1] = MB_16x8;
  226.         preds[2] = MB_8x16;
  227.         *modes = 3;
  228.     }
  229. }
  231. void
  232. T264_inter_p8x8_mode_available(T264_t* t, int32_t preds[], int32_t* modes, int32_t sub_no)
  233. {
  234.     static const int32_t neighbour[] = 
  235.     {
  236.         0, MB_LEFT, MB_TOP, MB_LEFT| MB_TOP
  237.     };
  239.     int32_t mb_neighbour = t->mb.mb_neighbour| neighbour[sub_no];
  241.     if (t->flags & USE_FORCEBLOCKSIZE)
  242.     {
  243.         *modes = 0;
  245.         if (t->param.block_size & SEARCH_8x8P)
  246.             preds[(*modes) ++] = MB_8x8;
  247.         if (t->param.block_size & SEARCH_8x4P)
  248.             preds[(*modes) ++] = MB_8x4;
  249.         if (t->param.block_size & SEARCH_4x8P)
  250.             preds[(*modes) ++] = MB_4x8;
  251.         if (t->param.block_size & SEARCH_4x4P)
  252.             preds[(*modes) ++] = MB_4x4;
  254.         return ;
  255.     }
  257.     if ((mb_neighbour & (MB_LEFT | MB_TOP)) == (MB_LEFT | MB_TOP))
  258.     {
  259.         *modes = 0;
  261.         preds[*modes ++] = MB_8x8;
  262.         if (t->mb.vec_ref[VEC_LUMA - 8 + sub_no / 2 * 16 + sub_no % 2 * 4].part == MB_8x4)
  263.         {
  264.             preds[*modes ++] = MB_8x4;
  265.         }
  266.         if (t->mb.vec_ref[VEC_LUMA - 1 + sub_no / 2 * 16 + sub_no % 2 * 4].part == MB_4x8)
  267.         {
  268.             preds[*modes ++] = MB_4x8;
  269.         }
  270.         if (t->mb.vec_ref[VEC_LUMA - 8 + sub_no / 2 * 16 + sub_no % 2 * 4].part == MB_4x4 || 
  271.             t->mb.vec_ref[VEC_LUMA - 1 + sub_no / 2 * 16 + sub_no % 2 * 4].part == MB_4x4)
  272.         {
  273.             preds[*modes ++] = MB_4x4;
  274.         }
  275.     }
  276.     else
  277.     {
  278.         // try all
  279.         preds[0] = MB_8x8;
  280.         preds[1] = MB_8x4;
  281.         preds[2] = MB_4x8;
  282.         preds[3] = MB_4x4;
  283.         *modes = 4;
  284.     }
  285. }
  287. uint32_t
  288. T264_mode_decision_inter_y(_RW T264_t* t)
  289. {
  290.     uint32_t sad;
  291.     uint32_t sad_min = -1;
  292.     uint8_t best_mode;
  293.     uint8_t part;
  294.     int32_t i, n;
  295.     int32_t preds[7];
  296.     int32_t modes;
  297.     search_data_t s0;
  298.     subpart_search_data_t s1;
  299.     T264_vector_t vec_bak[16 * 16]; 
  301.     typedef uint32_t (*p16x16_function_t)(T264_t*, search_data_t* s);
  302.     static p16x16_function_t p16x16_function[] = 
  303.     {
  304.         T264_mode_decision_inter_16x16p,
  305.         T264_mode_decision_inter_16x8p,
  306.         T264_mode_decision_inter_8x16p
  307.     };
  309.     T264_inter_p16x16_mode_available(t, preds, &modes);
  311.     best_mode = P_L0;
  313. //SKIP
  314. /* if(modes > 0) 
  315. {
  316. sad = p16x16_function[0](t, &s0);
  317. if(t->mb.mb_mode == P_SKIP)
  318. {
  319. sad_min = sad;
  320. return sad_min;
  321. }
  322. else
  323. {
  324. sad_min = sad;
  325. part = 0;
  326. }
  327. }
  329.  */
  330.     for(n = 0 ; n < modes ; n ++)
  331.     {
  332.         int32_t mode = preds[n];
  333.         memcpy(vec_bak, t->mb.vec, sizeof(vec_bak));
  334.         sad = p16x16_function[mode](t, &s0);
  336.         if (sad < sad_min)
  337.         {
  338.             part = mode;
  339.             sad_min = sad;
  340.         }
  341.         else
  342.         {
  343.             memcpy(t->mb.vec, vec_bak, sizeof(vec_bak));
  344.         }
  345.     }
  347.     if (t->flags & USE_SUBBLOCK)
  348.     {
  349.         uint32_t sub_sad_all = 0;
  351.         typedef uint32_t (*p8x8_function_t)(T264_t*, int32_t, subpart_search_data_t* s);
  352.         static p8x8_function_t p8x8_function[] = 
  353.         {
  354.             T264_mode_decision_inter_8x8p,
  355.             T264_mode_decision_inter_8x8p,
  356.             T264_mode_decision_inter_8x4p,
  357.             T264_mode_decision_inter_4x8p,
  358.             T264_mode_decision_inter_4x4p
  359.         };
  361.         for(i = 0 ; i < 4 ; i ++)
  362.         {
  363.             uint32_t sub_sad;
  364.             uint32_t sub_sad_min = -1;
  366.             T264_inter_p8x8_mode_available(t, preds, &modes, i);
  368.             for(n = 0 ; n < modes ; n ++)
  369.             {
  370.                 int32_t mode = preds[n];
  371.                 T264_vector_t vec_bak[4];
  373.                 vec_bak[0] = t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0];
  374.                 vec_bak[1] = t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1];
  375.                 vec_bak[2] = t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4];
  376.                 vec_bak[3] = t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5];
  378.                 sub_sad = p8x8_function[mode - MB_8x8](t, i, &s1);
  380.                 if (sub_sad < sub_sad_min)
  381.                 {
  382.                     sub_sad_min = sub_sad;
  383.                     t->mb.submb_part[i / 2 * 8 + i % 2 * 2 + 0] = mode;
  384.                     t->mb.submb_part[i / 2 * 8 + i % 2 * 2 + 1] = mode;
  385.                     t->mb.submb_part[i / 2 * 8 + i % 2 * 2 + 4] = mode;
  386.                     t->mb.submb_part[i / 2 * 8 + i % 2 * 2 + 5] = mode;
  387.                 }
  388.                 else
  389.                 {
  390.                     // restore current best mode
  391.                     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec = vec_bak[0];
  392.                     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec = vec_bak[1];
  393.                     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec = vec_bak[2];
  394.                     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec = vec_bak[3];
  396.                     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0] = vec_bak[0];
  397.                     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1] = vec_bak[1];
  398.                     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4] = vec_bak[2];
  399.                     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5] = vec_bak[3];
  400.                 }
  401.             }
  403.             sub_sad_all += sub_sad_min;
  404.         }
  406.         if (sub_sad_all < sad_min)
  407.         {
  408.             part = MB_8x8;
  409.             sad_min = sub_sad_all;
  410.         }
  411.     }
  413.     sad = T264_mode_decision_intra_y(t);
  414.     // xxx
  415.     if (0 && sad <= sad_min)
  416.     {
  417.         best_mode = t->mb.mb_mode;
  418.         sad_min = sad;
  419.     }
  420.     else
  421.     {
  422.         t->mb.mb_part = part;
  423.     }
  425.     t->mb.mb_mode = best_mode;
  426.     t->mb.sad = sad_min;
  428.     return sad_min;
  429. }
  431. /*
  432.   0   median
  433.     1   left
  434.     2   top
  435.     3   topright
  436.     4   topleft
  437.     5   0, 0
  438.     6   last frame
  439.  */
  440. static void
  441. get_pmv(T264_t* t, T264_vector_t* vec, int32_t part, int32_t idx, int32_t width, int32_t* n)
  442. {
  443.     int32_t count = 0;
  444.     int32_t row;
  445.     int32_t col;
  446.     int32_t i;
  448.     vec->refno = 0;
  449.     T264_predict_mv(t, 0, idx, width, vec);
  450.     
  451.     idx = luma_index[idx];
  452.     col = idx % 4;
  453.     row = idx / 4;
  455.     vec[1] = t->mb.vec_ref[VEC_LUMA - 1 + row * 8 + col].vec;   // left
  456.     vec[2] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col].vec;   // top
  457.     vec[3] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col + width].vec;   // top right
  458.     vec[4] = t->mb.vec_ref[VEC_LUMA - 8 + row * 8 + col - 1].vec;       // left top
  460.     for(i = 0 ; i < t->param.ref_num ; i ++)
  461.     {
  462.         if (i != vec[0].refno)
  463.         {
  464.             vec[5 + i].x = vec[0].x;
  465.             vec[5 + i].y = vec[0].y;
  466.         }
  467.         else
  468.         {
  469.             vec[5 + i].x = vec[5 + i].y = 0;
  470.         }
  471.         vec[5 + i].refno = i;
  472.     }
  473.     *n = 5 + t->param.ref_num;
  474. }
  476. uint32_t
  477. T264_mode_decision_inter_16x16p(_RW T264_t* t, search_data_t* s)
  478. {
  479.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  480.     T264_search_context_t context;
  481.     int32_t num;
  482. uint8_t is_skip = 0;
  484.     get_pmv(t, vec, MB_16x16, 0, 4, &num);
  486.     context.height = 16;
  487.     context.width  = 16;
  488.     context.limit_x= t->param.search_x;
  489.     context.limit_y= t->param.search_y;
  490.     context.vec    = vec;
  491.     context.vec_num= num;
  492.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  494.     s->src[0] = t->mb.src_y;
  495.     s->sad[0] = t->search(t, &context);
  496.     s->vec[0] = context.vec_best;
  497.     s->ref[0] = t->refl0[s->vec[0].refno];
  498.     s->offset[0] = context.offset;
  499.     s->vec_median[0] = vec[0];
  501.     s->sad[0] = T264_quarter_pixel_search(t, s->src[0], s->ref[0], s->offset[0], &s->vec[0], &s->vec_median[0], s->sad[0], 16, 16, t->mb.pred_p16x16[0]);
  502.     copy_nvec(&s->vec[0], &t->mb.vec[0][0], 4, 4, 4);
  503. /*/SKIP
  504. /*
  505. if(t->mb.mb_x == 0 || t->mb.mb_y == 0)
  506. {
  507. if(s->vec[0].x == 0 && s->vec[0].y == 0 && s->vec[0].refno == 0)
  508. is_skip = 1;
  509. }
  510. else
  511. {
  512. if(s->vec[0].x == context.vec[0].x && s->vec[0].y == context.vec[0].y 
  513. && s->vec[0].refno == 0 && context.vec[0].refno == 0)
  514. is_skip = 1;
  515. }
  516. */
  518. /*
  520. //SKIP
  521. if(   ((t->mb.mb_neighbour & MB_LEFT) != MB_LEFT && s->vec[0].x == 0 && s->vec[0].y == 0)
  522.        || ((t->mb.mb_neighbour & MB_TOP) != MB_TOP && s->vec[0].x == 0 && s->vec[0].y == 0)
  523. //    || (t->mb.vec_ref[VEC_LUMA - 1].vec.refno == 0 && t->mb.vec_ref[VEC_LUMA - 1].vec.x == 0 && t->mb.vec_ref[VEC_LUMA - 1].vec.y == 0 && s->vec[0].x == 0 && s->vec[0].y == 0)
  524. //    || (t->mb.vec_ref[VEC_LUMA - 8].vec.refno == 0 && t->mb.vec_ref[VEC_LUMA - 8].vec.x == 0 && t->mb.vec_ref[VEC_LUMA - 8].vec.y == 0 && s->vec[0].x == 0 && s->vec[0].y == 0)
  525.    )
  526. {
  527. sad = T264_quarter_pixel_search(t, s->src[0], s->ref[0], s->offset[0], &s->vec[0], &s->vec_median[0], s->sad[0], 16, 16, t->mb.pred_p16x16);
  528.         copy_nvec(&s->vec[0], &t->mb.vec[0][0], 4, 4, 4);
  529.     t->mb.mb_mode = P_SKIP;
  530. t->mb.mb_part = MB_16x16;
  531. t->mb.sad = sad;
  532. }
  534. else if(s->vec[0].x == context.vec[0].x && s->vec[0].y == context.vec[0].y 
  535. && s->vec[0].refno == 0 && context.vec[0].refno == 0)
  536. {
  537. //All residual zero?
  538. int32_t nz = 0;
  539. int32_t idx;
  540. sad = T264_quarter_pixel_search(t, s->src[0], s->ref[0], s->offset[0], &s->vec[0], &s->vec_median[0], s->sad[0], 16, 16, t->mb.pred_p16x16);
  541.         copy_nvec(&s->vec[0], &t->mb.vec[0][0], 4, 4, 4);
  542. T264_encode_inter_y(t);
  543. for(idx = 0; idx < 16; idx++)
  544. nz += array_non_zero_count(t->mb.dct_y_z[idx], 16);
  545. // T264_encode_inter_uv(t);
  546. // for(idx = 0; idx < 8; idx++)
  547. // nz += array_non_zero_count(t->mb.dct_uv_z[idx / 4][idx % 4], 16);
  548. if(nz == 0)
  549. {
  550. //            if ((t->mb.mb_neighbour & MB_LEFT) != MB_LEFT || (t->mb.mb_neighbour & MB_TOP) != MB_TOP ||
  551. //                (t->mb.vec_ref[VEC_LUMA - 1].vec.refno == 0 && t->mb.vec_ref[VEC_LUMA - 1].vec.x == 0 && t->mb.vec_ref[VEC_LUMA - 1].vec.y == 0) ||
  552. //                (t->mb.vec_ref[VEC_LUMA - 8].vec.refno == 0 && t->mb.vec_ref[VEC_LUMA - 8].vec.x == 0 && t->mb.vec_ref[VEC_LUMA - 8].vec.y == 0))
  553. //            {
  554. //                uint32_t flags = t->flags;
  555. //                s->vec[0].x = s->vec[0].y = s->vec[0].refno = 0;
  556. //                copy_nvec(&s->vec[0], &t->mb.vec[0][0], 4, 4, 4);
  557. //                t->flags &= ~(USE_HALFPEL |USE_QUARTPEL);
  558. //                sad = T264_quarter_pixel_search(t, s->src[0], s->ref[0], s->offset[0], &s->vec[0], &s->vec_median[0], s->sad[0], 16, 16, t->mb.pred_p16x16);
  559. //                t->flags = flags;
  560. //                T264_encode_inter_y(t);
  561. //            }
  562.             T264_encode_inter_uv(t);
  563.     t->mb.mb_mode = P_SKIP;
  564. t->mb.mb_part = MB_16x16;
  565. t->mb.sad = sad;
  567. if(context.vec[0].x !=0 && context.vec[0].y != 0)
  568. printf("MVx=%d,MVy=%dn",context.vec[0].x,context.vec[0].y);
  569. }
  570. else
  571. {
  572. t->mb.mb_mode = P_L0;
  573. t->mb.mb_part = MB_16x16;
  574. }
  575. }
  576. */
  579.     return s->sad[0];
  580. }
  582. uint32_t
  583. T264_mode_decision_inter_16x8p(_RW T264_t* t, search_data_t* s)
  584. {
  585.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  586.     T264_search_context_t context;
  587.     int32_t num;
  588.     uint8_t old_part = t->mb.mb_part;
  590.     t->mb.mb_part = MB_16x8;
  592.     get_pmv(t, vec, MB_16x8, 0, 4, &num);
  594.     context.height = 8;
  595.     context.width  = 16;
  596.     context.limit_x= t->param.search_x;
  597.     context.limit_y= t->param.search_y;
  598.     context.vec    = vec;
  599.     context.vec_num= num;
  600.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  602.     s->src[1] = t->mb.src_y;
  603.     s->sad[1] = t->search(t, &context);
  604.     s->vec[1] = context.vec_best;
  605.     s->ref[1] = t->refl0[s->vec[1].refno];
  606.     s->offset[1] = context.offset;
  607.     s->vec_median[1] = vec[0];
  609.     s->sad[1] = T264_quarter_pixel_search(t, s->src[1], s->ref[1], s->offset[1], &s->vec[1], &s->vec_median[1], s->sad[1], 16, 8, t->mb.pred_p16x16[1]);
  610.     copy_nvec(&s->vec[1], &t->mb.vec[0][0], 4, 2, 4);
  611.     t->mb.vec_ref[VEC_LUMA + 8].vec = s->vec[1];
  612.     get_pmv(t, vec, MB_16x8, luma_index[8], 4, &num);
  614.     s->src[2] = t->mb.src_y + 8 * t->stride;
  615.     context.offset += 8 * t->edged_stride;
  616.     s->sad[2] = t->search(t, &context);
  617.     s->vec[2] = context.vec_best;
  618.     s->ref[2] = t->refl0[s->vec[2].refno];
  619.     s->offset[2] = context.offset;
  620.     s->vec_median[2] = vec[0];
  622.     s->sad[2] = T264_quarter_pixel_search(t, s->src[2], s->ref[2], s->offset[2], &s->vec[2], &s->vec_median[2], s->sad[2], 16, 8, t->mb.pred_p16x16[1] + 16 * 8);
  623.     copy_nvec(&s->vec[2], &t->mb.vec[0][8], 4, 2, 4);
  625.     t->mb.mb_part = old_part;
  627.     return s->sad[1] + s->sad[2];
  628. }
  630. uint32_t
  631. T264_mode_decision_inter_8x16p(_RW T264_t * t, search_data_t* s)
  632. {
  633.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  634.     T264_search_context_t context;
  635.     int32_t num;
  636.     uint8_t old_part = t->mb.mb_part;
  638.     t->mb.mb_part = MB_8x16;
  639.     get_pmv(t, vec, MB_8x16, 0, 2, &num);
  641.     context.height = 16;
  642.     context.width  = 8;
  643.     context.limit_x= t->param.search_x;
  644.     context.limit_y= t->param.search_y;
  645.     context.vec    = vec;
  646.     context.vec_num= num;
  647.     context.offset = (t->mb.mb_y << 4) * t->edged_stride + (t->mb.mb_x << 4);
  649.     s->src[3] = t->mb.src_y;
  650.     s->sad[3] = t->search(t, &context);
  651.     s->vec[3] = context.vec_best;
  652.     s->ref[3] = t->refl0[s->vec[3].refno];
  653.     s->offset[3] = context.offset;
  654.     s->vec_median[3] = vec[0];
  656.     s->sad[3] = T264_quarter_pixel_search(t, s->src[3], s->ref[3], s->offset[3], &s->vec[3], &s->vec_median[3], s->sad[3], 8, 16, t->mb.pred_p16x16[2]);
  657.     copy_nvec(&s->vec[3], &t->mb.vec[0][0], 2, 4, 4);
  658.     t->mb.vec_ref[VEC_LUMA + 1].vec = s->vec[3];
  659.     // xxx
  660.     //printf("mb: %d, x: %d, y: %d, sad: %dn", t->mb.mb_xy, s->vec[3].x, s->vec[3].y, s->sad[3]);
  662.     get_pmv(t, vec, MB_8x16, luma_index[4], 2, &num);
  664.     s->src[4] = t->mb.src_y + 8;
  665.     context.offset += 8;
  666.     s->sad[4] = t->search(t, &context);
  667.     s->vec[4] = context.vec_best;
  668.     s->ref[4] = t->refl0[s->vec[4].refno];
  669.     s->offset[4] = context.offset;
  670.     s->vec_median[4] = vec[0];
  672.     s->sad[4] = T264_quarter_pixel_search(t, s->src[4], s->ref[4], s->offset[4], &s->vec[4], &s->vec_median[4], s->sad[4], 8, 16, t->mb.pred_p16x16[2] + 8);
  673.     copy_nvec(&s->vec[4], &t->mb.vec[0][2], 2, 4, 4);
  675.     t->mb.mb_part = old_part;
  677.     // xxx
  678.     //printf("mb: %d, x: %d, y: %d, sad: %dn", t->mb.mb_xy, s->vec[4].x, s->vec[4].y, s->sad[4]);
  680.     return s->sad[3] + s->sad[4];
  681. }
  683. uint32_t
  684. T264_mode_decision_inter_8x8p(_RW T264_t * t, int32_t i, subpart_search_data_t* s)
  685. {
  686.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  687.     T264_search_context_t context;
  688.     int32_t num;
  690.     get_pmv(t, vec, MB_8x8, luma_index[4 * i], 2, &num);
  692.     context.height = 8;
  693.     context.width  = 8;
  694.     context.limit_x= t->param.search_x;
  695.     context.limit_y= t->param.search_y;
  696.     context.vec    = vec;
  697.     context.vec_num= num;
  698.     context.offset = ((t->mb.mb_y << 4) + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + i % 2 * 8;
  700.     s->src[i][0] = t->mb.src_y + (i / 2 * 8) * t->stride + i % 2 * 8;
  701.     s->sad[i][0] = t->search(t, &context);
  702.     s->vec[i][0] = context.vec_best;
  703.     s->offset[i][0] = context.offset;
  704.     s->ref[i][0] = t->refl0[s->vec[i][0].refno];
  705.     s->vec_median[i][0] = vec[0];
  707.     s->sad[i][0] = T264_quarter_pixel_search(t, s->src[i][0], s->ref[i][0], s->offset[i][0], &s->vec[i][0], &s->vec_median[i][0], s->sad[i][0], 8, 8, t->mb.pred_p16x16[3] + i / 2 * 16 * 8 + i % 2 * 8);
  709.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec =
  710.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec =
  711.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec =
  712.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec = s->vec[i][0];
  714.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0] = s->vec[i][0];
  715.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1] = s->vec[i][0];
  716.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4] = s->vec[i][0];
  717.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5] = s->vec[i][0];
  718.     // xxx
  719.     printf("mb: %d, x: %d, y: %d, mx: %d, my: %d, sad: %dn", t->mb.mb_xy, s->vec[i][0].x, s->vec[i][0].y, vec[0].x, vec[0].y, s->sad[i][0]);
  721.     return s->sad[i][0];
  722. }
  724. uint32_t
  725. T264_mode_decision_inter_8x4p(_RW T264_t * t, int32_t i, subpart_search_data_t* s)
  726. {
  727.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  728.     T264_search_context_t context;
  729.     int32_t num;
  731.     get_pmv(t, vec, MB_8x4, luma_index[4 * i + 0], 2, &num);
  733.     context.height = 4;
  734.     context.width  = 8;
  735.     context.limit_x= t->param.search_x;
  736.     context.limit_y= t->param.search_y;
  737.     context.vec    = vec;
  738.     context.vec_num= num;
  739.     context.offset = ((t->mb.mb_y << 4) + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + i % 2 * 8;
  741.     s->src[i][1] = t->mb.src_y + (i / 2 * 8) * t->stride + i % 2 * 8;
  742.     s->sad[i][1] = t->search(t, &context);
  743.     s->vec[i][1] = context.vec_best;
  744.     s->offset[i][1] = context.offset;
  745.     s->ref[i][1] = t->refl0[s->vec[i][1].refno];
  746.     s->vec_median[i][1] = vec[0];
  748.     s->sad[i][1] = T264_quarter_pixel_search(t, s->src[i][1], s->ref[i][1], s->offset[i][1], &s->vec[i][1], &s->vec_median[i][1], s->sad[i][1], 8, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8);
  749.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec =
  750.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec = s->vec[i][1];
  751.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0] = s->vec[i][1];
  752.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1] = s->vec[i][1];
  753.     get_pmv(t, vec, MB_8x4, luma_index[4 * i + 2], 2, &num);
  755.     s->src[i][2] = s->src[i][1] + 4 * t->stride;
  756.     context.offset += 4 * t->edged_stride;
  757.     s->sad[i][2] = t->search(t, &context);
  758.     s->vec[i][2] = context.vec_best;
  759.     s->offset[i][2] = context.offset;
  760.     s->ref[i][2] = t->refl0[s->vec[i][2].refno];
  761.     s->vec_median[i][2] = vec[0];
  763.     s->sad[i][2] = T264_quarter_pixel_search(t, s->src[i][2], s->ref[i][2], s->offset[i][2], &s->vec[i][2], &s->vec_median[i][2], s->sad[i][2], 8, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8 + 16 * 4);
  764.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec =
  765.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec = s->vec[i][2];
  766.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4] = s->vec[i][2];
  767.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5] = s->vec[i][2];
  769.     return s->sad[i][1] + s->sad[i][2];
  770. }
  772. uint32_t
  773. T264_mode_decision_inter_4x8p(_RW T264_t * t, int32_t i, subpart_search_data_t* s)
  774. {
  775.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  776.     T264_search_context_t context;
  777.     int32_t num;
  779.     get_pmv(t, vec, MB_4x8, luma_index[4 * i + 0], 1, &num);
  781.     context.height = 8;
  782.     context.width  = 4;
  783.     context.limit_x= t->param.search_x;
  784.     context.limit_y= t->param.search_y;
  785.     context.vec    = vec;
  786.     context.vec_num= num;
  787.     context.offset = ((t->mb.mb_y << 4) + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + i % 2 * 8;
  789.     s->src[i][3] = t->mb.src_y + (i / 2 * 8) * t->stride + i % 2 * 8;
  790.     s->sad[i][3] = t->search(t, &context);
  791.     s->vec[i][3] = context.vec_best;
  792.     s->offset[i][3] = context.offset;
  793.     s->ref[i][3] = t->refl0[s->vec[i][3].refno];
  794.     s->vec_median[i][3] = vec[0];
  796.     s->sad[i][3] = T264_quarter_pixel_search(t, s->src[i][3], s->ref[i][3], s->offset[i][3], &s->vec[i][3], &s->vec[i][3], s->sad[i][3], 4, 8, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8);
  798.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec =
  799.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec = s->vec[i][3];
  800.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0] = s->vec[i][3];
  801.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4] = s->vec[i][3];
  802.     get_pmv(t, vec, MB_4x8, luma_index[4 * i + 1], 1, &num);
  804.     s->src[i][4] = s->src[i][3] + 4;
  805.     context.offset += 4;
  806.     s->sad[i][4] = t->search(t, &context);
  807.     s->vec[i][4] = context.vec_best;
  808.     s->offset[i][4] = context.offset;
  809.     s->ref[i][4] = t->refl0[s->vec[i][4].refno];
  810.     s->vec_median[i][4] = vec[0];
  812.     s->sad[i][4] = T264_quarter_pixel_search(t, s->src[i][4], s->ref[i][4], s->offset[i][4], &s->vec[i][4], &s->vec[i][4], s->sad[i][4], 4, 8, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8 + 4);
  813.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec =
  814.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec = s->vec[i][4];
  815.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1] = s->vec[i][4];
  816.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5] = s->vec[i][4];
  818.     return s->sad[i][3] + s->sad[i][4];
  819. }
  821. uint32_t
  822. T264_mode_decision_inter_4x4p(_RW T264_t * t, int32_t i, subpart_search_data_t* s)
  823. {
  824.     T264_vector_t vec[5 + 10];  // NOTE: max 10 refs
  825.     T264_search_context_t context;
  826.     int32_t num;
  828.     get_pmv(t, vec, MB_4x4, luma_index[4 * i + 0], 1, &num);
  830.     context.height = 4;
  831.     context.width  = 4;
  832.     context.limit_x= t->param.search_x;
  833.     context.limit_y= t->param.search_y;
  834.     context.vec    = vec;
  835.     context.vec_num= num;
  836.     context.offset = ((t->mb.mb_y << 4) + i / 2 * 8) * t->edged_stride + (t->mb.mb_x << 4) + i % 2 * 8;
  838.     s->src[i][5] = t->mb.src_y + (i / 2 * 8) * t->stride + i % 2 * 8;
  839.     s->sad[i][5] = t->search(t, &context);
  840.     s->vec[i][5] = context.vec_best;
  841.     s->offset[i][5] = context.offset;
  842.     s->ref[i][5] = t->refl0[s->vec[i][5].refno];
  843.     s->vec_median[i][5] = vec[0];
  845.     s->sad[i][5] = T264_quarter_pixel_search(t, s->src[i][5], s->ref[i][5], s->offset[i][5], &s->vec[i][5], &s->vec[i][5], s->sad[i][5], 4, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8);
  846.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 0].vec =
  847.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 0] = s->vec[i][5];
  848.     get_pmv(t, vec, MB_4x4, luma_index[4 * i + 1], 1, &num);
  850.     s->src[i][6] = s->src[i][5] + 4;
  851.     context.offset += 4;
  852.     s->sad[i][6] = t->search(t, &context);
  853.     s->vec[i][6] = context.vec_best;
  854.     s->offset[i][6] = context.offset;
  855.     s->ref[i][6] = t->refl0[s->vec[i][6].refno];
  856.     s->vec_median[i][6] = vec[0];
  858.     s->sad[i][6] = T264_quarter_pixel_search(t, s->src[i][6], s->ref[i][6], s->offset[i][6], &s->vec[i][6], &s->vec[i][6], s->sad[i][6], 4, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8 + 4);
  859.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 1].vec =
  860.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 1] = s->vec[i][6];
  861.     get_pmv(t, vec, MB_4x4, luma_index[4 * i + 2], 1, &num);
  863.     s->src[i][7] = s->src[i][5] + 4 * t->stride;
  864.     context.offset += 4 * t->edged_stride - 4;
  865.     s->sad[i][7] = t->search(t, &context);
  866.     s->vec[i][7] = context.vec_best;
  867.     s->offset[i][7] = context.offset;
  868.     s->ref[i][7] = t->refl0[s->vec[i][7].refno];
  869.     s->vec_median[i][7] = vec[0];
  871.     s->sad[i][7] = T264_quarter_pixel_search(t, s->src[i][7], s->ref[i][7], s->offset[i][7], &s->vec[i][7], &s->vec[i][7], s->sad[i][7], 4, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8 + 16 * 4);
  872.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 8].vec =
  873.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 4] = s->vec[i][7];
  874.     get_pmv(t, vec, MB_4x4, luma_index[4 * i + 3], 1, &num);
  876.     s->src[i][8] = s->src[i][7] + 4;
  877.     context.offset += 4;
  878.     s->sad[i][8] = t->search(t, &context);
  879.     s->vec[i][8] = context.vec_best;
  880.     s->offset[i][8] = context.offset;
  881.     s->ref[i][8] = t->refl0[s->vec[i][8].refno];
  882.     s->vec_median[i][8] = vec[0];
  884.     s->sad[i][8] = T264_quarter_pixel_search(t, s->src[i][8], s->ref[i][8], s->offset[i][8], &s->vec[i][8], &s->vec[i][8], s->sad[i][8], 4, 4, t->mb.pred_p8x8 + i / 2 * 16 * 8 + i % 2 * 8 + 16 * 4 + 4);
  885.     t->mb.vec_ref[VEC_LUMA + i / 2 * 16 + i % 2 * 2 + 9].vec =
  886.     t->mb.vec[0][i / 2 * 8 + i % 2 * 2 + 5] = s->vec[i][8];
  888.     return s->sad[i][5] + s->sad[i][6] + s->sad[i][7] + s->sad[i][8];
  889. }
  891. void
  892. T264_encode_inter_16x16p(_RW T264_t* t, uint8_t* pred)
  893. {
  894.     DECLARE_ALIGNED_MATRIX(dct, 16, 16, int16_t, 16);
  896.     int32_t qp = t->qp_y;
  897.     int32_t i;
  898.     int16_t* curdct;
  900.     t->expand8to16sub(pred, 16 / 4, 16 / 4, dct, t->mb.src_y, t->stride);
  901.     curdct = dct;
  902.     for(i = 0 ; i < 16 ; i ++)
  903.     {
  904.         t->fdct4x4(curdct);
  906.         t->quant4x4(curdct, qp, FALSE);
  907.         scan_zig_4x4(t->mb.dct_y_z[luma_index[i]], curdct);
  908.         t->iquant4x4(curdct, qp);
  909.         t->idct4x4(curdct);
  911.         curdct += 16;
  912.     }
  914.     t->contract16to8add(dct, 16 / 4, 16 / 4, pred, t->mb.dst_y, t->edged_stride);
  915. }
  917. void
  918. T264_encode_inter_y(_RW T264_t* t)
  919. {
  920.     T264_encode_inter_16x16p(t, t->mb.pred_p16x16[t->mb.mb_part]);
  921. }
  923. // NOTE: this routine will merge with T264_encode_intra_uv
  924. void
  925. T264_transform_inter_uv(_RW T264_t* t, uint8_t* pred_u, uint8_t* pred_v)
  926. {
  927.     DECLARE_ALIGNED_MATRIX(dct, 10, 8, int16_t, CACHE_SIZE);
  929.     int32_t qp = t->qp_uv;
  930.     int32_t i, j;
  931.     int16_t* curdct;
  932.     uint8_t* start;
  933.     uint8_t* dst;
  934.     uint8_t* src;
  936.     start = pred_u;
  937.     src   = t->mb.src_u;
  938.     dst   = t->mb.dst_u;
  939.     for(j = 0 ; j < 2 ; j ++)
  940.     {
  941.         t->expand8to16sub(start, 8 / 4, 8 / 4, dct, src, t->stride_uv);
  942.         curdct = dct;
  943.         for(i = 0 ; i < 4 ; i ++)
  944.         {
  945.             t->fdct4x4(curdct);
  946.             dct[64 + i] = curdct[0];
  948.             t->quant4x4(curdct, qp, FALSE);
  949.             scan_zig_4x4(t->mb.dct_uv_z[j][i], curdct);
  950.             t->iquant4x4(curdct, qp);
  952.             curdct += 16;
  953.         }
  954.         t->fdct2x2dc(curdct);
  955.         t->quant2x2dc(curdct, qp, FALSE);
  956.         scan_zig_2x2(t->mb.dc2x2_z[j], curdct);
  957.         t->iquant2x2dc(curdct, qp);
  958.         t->idct2x2dc(curdct);
  960.         curdct = dct;
  961.         for(i = 0 ; i < 4 ; i ++)
  962.         {
  963.             curdct[0] = dct[64 + i];
  964.             t->idct4x4(curdct);
  965.             curdct += 16;
  966.         }
  968.         t->contract16to8add(dct, 8 / 4, 8 / 4, start, dst, t->edged_stride_uv);
  970.         //
  971.         // change to v
  972.         //
  973.         start = pred_v;
  974.         dst   = t->mb.dst_v;
  975.         src   = t->mb.src_v;
  976.     }
  977. }
  979. void
  980. T264_encode_inter_uv(_RW T264_t* t)
  981. {
  982.     DECLARE_ALIGNED_MATRIX(pred_u, 8, 8, uint8_t, CACHE_SIZE);
  983.     DECLARE_ALIGNED_MATRIX(pred_v, 8, 8, uint8_t, CACHE_SIZE);
  985.     T264_vector_t vec;
  986.     uint8_t* src, *dst;
  987.     uint8_t* src_u, *dst_u;
  988.     int32_t i;
  990.     switch (t->mb.mb_part)
  991.     {
  992.     case MB_16x16:
  993.         vec = t->mb.vec[0][0];
  994.         src = t->refl0[vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  995.         dst = pred_u;
  996.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  997.         src = t->refl0[vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  998.         dst = pred_v;
  999.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 8);
  1000.         break;
  1001.     case MB_16x8:
  1002.         vec = t->mb.vec[0][0];
  1003.         src_u = t->refl0[vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  1004.         dst_u = pred_u;
  1005.         t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 8, 4);
  1006.         src = t->refl0[vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  1007.         dst = pred_v;
  1008.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  1010.         vec = t->mb.vec[0][luma_index[8]];
  1011.         src_u = t->refl0[vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) +
  1012.             4 * t->edged_stride_uv;
  1013.         dst_u += 4 * 8;
  1014.         t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 8, 4);
  1015.         src = t->refl0[vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + 
  1016.             4 * t->edged_stride_uv;
  1017.         dst += 4 * 8;
  1018.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 8, 4);
  1019.         break;
  1020.     case MB_8x16:
  1021.         vec = t->mb.vec[0][0];
  1022.         src_u = t->refl0[vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  1023.         dst_u = pred_u;
  1024.         t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 4, 8);
  1025.         src = t->refl0[vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3);
  1026.         dst = pred_v;
  1027.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  1029.         vec = t->mb.vec[0][luma_index[4]];
  1030.         src_u = t->refl0[vec.refno]->U + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + 4;
  1031.         dst_u += 4;
  1032.         t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 4, 8);
  1033.         src = t->refl0[vec.refno]->V + ((t->mb.mb_y << 3) + (vec.y >> 3)) * t->edged_stride_uv + (t->mb.mb_x << 3) + (vec.x >> 3) + 4;
  1034.         dst += 4;
  1035.         t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 8);
  1036.         break;
  1037.     case MB_8x8:
  1038.     case MB_8x8ref0:
  1039.         for(i = 0 ; i < 4 ; i ++)
  1040.         {
  1041.             switch(t->mb.submb_part[luma_index[4 * i]])
  1042.             {
  1043.             case MB_8x8:
  1044.                 vec = t->mb.vec[0][luma_index[4 * i]];
  1045.                 src = t->refl0[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);
  1046.                 dst = pred_u + i / 2 * 32 + i % 2 * 4;
  1047.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  1048.                 src = t->refl0[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);
  1049.                 dst = pred_v + i / 2 * 32 + i % 2 * 4;
  1050.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 4);
  1051.                 break;
  1052.             case MB_8x4:
  1053.                 vec = t->mb.vec[0][luma_index[4 * i]];
  1054.                 src_u = t->refl0[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);
  1055.                 dst_u = pred_u + i / 2 * 32 + i % 2 * 4;
  1056.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 4, 2);
  1057.                 src = t->refl0[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);
  1058.                 dst = pred_v + i / 2 * 32 + i % 2 * 4;
  1059.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 2);
  1061.                 vec = t->mb.vec[0][luma_index[4 * i + 2]];
  1062.                 src_u = t->refl0[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) + 
  1063.                     2 * t->edged_stride_uv;
  1064.                 dst_u += 2 * 8;
  1065.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 4, 2);
  1066.                 src = t->refl0[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) +
  1067.                     2 * t->edged_stride_uv;
  1068.                 dst += 2 * 8;
  1069.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 4, 2);
  1070.                 break;
  1071.             case MB_4x8:
  1072.                 vec = t->mb.vec[0][luma_index[4 * i]];
  1073.                 src_u = t->refl0[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);
  1074.                 dst_u = pred_u + i / 2 * 32 + i % 2 * 4;
  1075.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 4);
  1076.                 src = t->refl0[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);
  1077.                 dst = pred_v + i / 2 * 32 + i % 2 * 4;
  1078.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 4);
  1080.                 vec = t->mb.vec[0][luma_index[4 * i + 1]];
  1081.                 src_u = t->refl0[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) + 2;
  1082.                 dst_u += 2;
  1083.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 4);
  1084.                 src = t->refl0[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) + 2;
  1085.                 dst += 2;
  1086.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 4);
  1087.                 break;
  1088.             case MB_4x4:
  1089.                 vec = t->mb.vec[0][luma_index[4 * i]];
  1090.                 src_u = t->refl0[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);
  1091.                 dst_u = pred_u + i / 2 * 32 + i % 2 * 4;
  1092.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 2);
  1093.                 src = t->refl0[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);
  1094.                 dst = pred_v + i / 2 * 32 + i % 2 * 4;
  1095.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 2);
  1097.                 vec = t->mb.vec[0][luma_index[4 * i + 1]];
  1098.                 src_u = t->refl0[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) + 2;
  1099.                 dst_u += 2;
  1100.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 2);
  1101.                 src = t->refl0[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) + 2;
  1102.                 dst += 2;
  1103.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 2);
  1105.                 vec = t->mb.vec[0][luma_index[4 * i + 2]];
  1106.                 src_u = t->refl0[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) + 
  1107.                     2 * t->edged_stride_uv;
  1108.                 dst_u += 2 * 8 - 2;
  1109.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 2);
  1110.                 src = t->refl0[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) + 
  1111.                     2 * t->edged_stride_uv;
  1112.                 dst += 2 * 8 - 2;
  1113.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 2);
  1115.                 vec = t->mb.vec[0][luma_index[4 * i + 3]];
  1116.                 src_u = t->refl0[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) +
  1117.                     2 * t->edged_stride_uv + 2;
  1118.                 dst_u += 2;
  1119.                 t->eighth_pixel_mc_u(src_u, t->edged_stride_uv, dst_u, vec.x, vec.y, 2, 2);
  1120.                 src = t->refl0[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) + 
  1121.                     2 * t->edged_stride_uv + 2;
  1122.                 dst += 2;
  1123.                 t->eighth_pixel_mc_u(src, t->edged_stride_uv, dst, vec.x, vec.y, 2, 2);
  1124.                 break;
  1125.             default:
  1126.                 break;
  1127.             }
  1128.         }
  1129.         break;
  1130.     default:
  1131.         break;
  1132.     }
  1134.     T264_transform_inter_uv(t, pred_u, pred_v);
  1135. }