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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
macroblock.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：54k
源码类别：

Audio

开发平台：

Visual C++

macroblock.c：源码内容
  1. /*****************************************************************************
  2.  * macroblock.c: h264 encoder library
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: macroblock.c,v 1.1 2004/06/03 19:27:06 fenrir Exp $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include <stdio.h>
  25. #include <string.h>
  27. #include "common.h"
  29. static const int dequant_mf[6][4][4] =
  30. {
  31.     { {10, 13, 10, 13}, {13, 16, 13, 16}, {10, 13, 10, 13}, {13, 16, 13, 16} },
  32.     { {11, 14, 11, 14}, {14, 18, 14, 18}, {11, 14, 11, 14}, {14, 18, 14, 18} },
  33.     { {13, 16, 13, 16}, {16, 20, 16, 20}, {13, 16, 13, 16}, {16, 20, 16, 20} },
  34.     { {14, 18, 14, 18}, {18, 23, 18, 23}, {14, 18, 14, 18}, {18, 23, 18, 23} },
  35.     { {16, 20, 16, 20}, {20, 25, 20, 25}, {16, 20, 16, 20}, {20, 25, 20, 25} },
  36.     { {18, 23, 18, 23}, {23, 29, 23, 29}, {18, 23, 18, 23}, {23, 29, 23, 29} }
  37. };
  39. int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
  40. {
  41.     const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
  42.     const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
  43.     const int m  = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
  44.                              x264_mb_pred_mode4x4_fix(mb) );
  46.     if( m < 0 )
  47.         return I_PRED_4x4_DC;
  49.     return m;
  50. }
  52. int x264_mb_predict_non_zero_code( x264_t *h, int idx )
  53. {
  54.     const int za = h->mb.cache.non_zero_count[x264_scan8[idx] - 1];
  55.     const int zb = h->mb.cache.non_zero_count[x264_scan8[idx] - 8];
  57.     int i_ret = za + zb;
  59.     if( i_ret < 0x80 )
  60.     {
  61.         i_ret = ( i_ret + 1 ) >> 1;
  62.     }
  63.     return i_ret & 0x7f;
  64. }
  66. int x264_mb_transform_8x8_allowed( x264_t *h )
  67. {
  68.     if( IS_SKIP( h->mb.i_type ) )
  69.         return 0;
  70.     if( h->mb.i_type == P_8x8 || h->mb.i_type == B_8x8 )
  71.     {
  72.         int i;
  73.         for( i = 0; i < 4; i++ )
  74.             if( !IS_SUB8x8(h->mb.i_sub_partition[i])
  75.                 || ( h->mb.i_sub_partition[i] == D_DIRECT_8x8 && !h->sps->b_direct8x8_inference ) )
  76.             {
  77.                 return 0;
  78.             }
  79.     }
  80.     if( h->mb.i_type == B_DIRECT && !h->sps->b_direct8x8_inference )
  81.         return 0;
  83.     return 1;
  84. }
  86. void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int mvp[2] )
  87. {
  88.     const int i8 = x264_scan8[idx];
  89.     const int i_ref= h->mb.cache.ref[i_list][i8];
  90.     int     i_refa = h->mb.cache.ref[i_list][i8 - 1];
  91.     int16_t *mv_a  = h->mb.cache.mv[i_list][i8 - 1];
  92.     int     i_refb = h->mb.cache.ref[i_list][i8 - 8];
  93.     int16_t *mv_b  = h->mb.cache.mv[i_list][i8 - 8];
  94.     int     i_refc = h->mb.cache.ref[i_list][i8 - 8 + i_width ];
  95.     int16_t *mv_c  = h->mb.cache.mv[i_list][i8 - 8 + i_width];
  97.     int i_count;
  99.     if( (idx&0x03) == 3 || ( i_width == 2 && (idx&0x3) == 2 )|| i_refc == -2 )
  100.     {
  101.         i_refc = h->mb.cache.ref[i_list][i8 - 8 - 1];
  102.         mv_c   = h->mb.cache.mv[i_list][i8 - 8 - 1];
  103.     }
  105.     if( h->mb.i_partition == D_16x8 )
  106.     {
  107.         if( idx == 0 && i_refb == i_ref )
  108.         {
  109.             mvp[0] = mv_b[0];
  110.             mvp[1] = mv_b[1];
  111.             return;
  112.         }
  113.         else if( idx != 0 && i_refa == i_ref )
  114.         {
  115.             mvp[0] = mv_a[0];
  116.             mvp[1] = mv_a[1];
  117.             return;
  118.         }
  119.     }
  120.     else if( h->mb.i_partition == D_8x16 )
  121.     {
  122.         if( idx == 0 && i_refa == i_ref )
  123.         {
  124.             mvp[0] = mv_a[0];
  125.             mvp[1] = mv_a[1];
  126.             return;
  127.         }
  128.         else if( idx != 0 && i_refc == i_ref )
  129.         {
  130.             mvp[0] = mv_c[0];
  131.             mvp[1] = mv_c[1];
  132.             return;
  133.         }
  134.     }
  136.     i_count = 0;
  137.     if( i_refa == i_ref ) i_count++;
  138.     if( i_refb == i_ref ) i_count++;
  139.     if( i_refc == i_ref ) i_count++;
  141.     if( i_count > 1 )
  142.     {
  143.         mvp[0] = x264_median( mv_a[0], mv_b[0], mv_c[0] );
  144.         mvp[1] = x264_median( mv_a[1], mv_b[1], mv_c[1] );
  145.     }
  146.     else if( i_count == 1 )
  147.     {
  148.         if( i_refa == i_ref )
  149.         {
  150.             mvp[0] = mv_a[0];
  151.             mvp[1] = mv_a[1];
  152.         }
  153.         else if( i_refb == i_ref )
  154.         {
  155.             mvp[0] = mv_b[0];
  156.             mvp[1] = mv_b[1];
  157.         }
  158.         else
  159.         {
  160.             mvp[0] = mv_c[0];
  161.             mvp[1] = mv_c[1];
  162.         }
  163.     }
  164.     else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
  165.     {
  166.         mvp[0] = mv_a[0];
  167.         mvp[1] = mv_a[1];
  168.     }
  169.     else
  170.     {
  171.         mvp[0] = x264_median( mv_a[0], mv_b[0], mv_c[0] );
  172.         mvp[1] = x264_median( mv_a[1], mv_b[1], mv_c[1] );
  173.     }
  174. }
  176. void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int mvp[2] )
  177. {
  178.     int     i_refa = h->mb.cache.ref[i_list][X264_SCAN8_0 - 1];
  179.     int16_t *mv_a  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 1];
  180.     int     i_refb = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8];
  181.     int16_t *mv_b  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8];
  182.     int     i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 + 4];
  183.     int16_t *mv_c  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 + 4];
  185.     int i_count;
  187.     if( i_refc == -2 )
  188.     {
  189.         i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 - 1];
  190.         mv_c   = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 - 1];
  191.     }
  193.     i_count = 0;
  194.     if( i_refa == i_ref ) i_count++;
  195.     if( i_refb == i_ref ) i_count++;
  196.     if( i_refc == i_ref ) i_count++;
  198.     if( i_count > 1 )
  199.     {
  200.         mvp[0] = x264_median( mv_a[0], mv_b[0], mv_c[0] );
  201.         mvp[1] = x264_median( mv_a[1], mv_b[1], mv_c[1] );
  202.     }
  203.     else if( i_count == 1 )
  204.     {
  205.         if( i_refa == i_ref )
  206.         {
  207.             mvp[0] = mv_a[0];
  208.             mvp[1] = mv_a[1];
  209.         }
  210.         else if( i_refb == i_ref )
  211.         {
  212.             mvp[0] = mv_b[0];
  213.             mvp[1] = mv_b[1];
  214.         }
  215.         else
  216.         {
  217.             mvp[0] = mv_c[0];
  218.             mvp[1] = mv_c[1];
  219.         }
  220.     }
  221.     else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
  222.     {
  223.         mvp[0] = mv_a[0];
  224.         mvp[1] = mv_a[1];
  225.     }
  226.     else
  227.     {
  228.         mvp[0] = x264_median( mv_a[0], mv_b[0], mv_c[0] );
  229.         mvp[1] = x264_median( mv_a[1], mv_b[1], mv_c[1] );
  230.     }
  231. }
  234. void x264_mb_predict_mv_pskip( x264_t *h, int mv[2] )
  235. {
  236.     int     i_refa = h->mb.cache.ref[0][X264_SCAN8_0 - 1];
  237.     int     i_refb = h->mb.cache.ref[0][X264_SCAN8_0 - 8];
  238.     int16_t *mv_a  = h->mb.cache.mv[0][X264_SCAN8_0 - 1];
  239.     int16_t *mv_b  = h->mb.cache.mv[0][X264_SCAN8_0 - 8];
  241.     if( i_refa == -2 || i_refb == -2 ||
  242.         ( i_refa == 0 && mv_a[0] == 0 && mv_a[1] == 0 ) ||
  243.         ( i_refb == 0 && mv_b[0] == 0 && mv_b[1] == 0 ) )
  244.     {
  245.         mv[0] = mv[1] = 0;
  246.     }
  247.     else
  248.     {
  249.         x264_mb_predict_mv_16x16( h, 0, 0, mv );
  250.     }
  251. }
  253. static int x264_mb_predict_mv_direct16x16_temporal( x264_t *h )
  254. {
  255.     int i_mb_4x4 = 16 * h->mb.i_mb_stride * h->mb.i_mb_y + 4 * h->mb.i_mb_x;
  256.     int i_mb_8x8 =  4 * h->mb.i_mb_stride * h->mb.i_mb_y + 2 * h->mb.i_mb_x;
  257.     int i8, i4;
  258.     int b8x8;
  259.     const int type_col = h->fref1[0]->mb_type[ h->mb.i_mb_xy ];
  260.     
  261.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, 0 );
  262.     
  263.     if( IS_INTRA( type_col ) )
  264.     {
  265.         x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
  266.         x264_macroblock_cache_mv(  h, 0, 0, 4, 4, 0, 0, 0 );
  267.         x264_macroblock_cache_mv(  h, 0, 0, 4, 4, 1, 0, 0 );
  268.         return 1;
  269.     }
  270.     b8x8 = h->sps->b_direct8x8_inference ||
  271.            (type_col != P_8x8 && type_col != B_SKIP && type_col != B_DIRECT && type_col != B_8x8);
  273.     for( i8 = 0; i8 < 4; i8++ )
  274.     {
  275.         const int x8 = i8%2;
  276.         const int y8 = i8/2;
  277.         const int i_part_8x8 = i_mb_8x8 + x8 + y8 * h->mb.i_b8_stride;
  278.         const int i_ref = h->mb.map_col_to_list0[ h->fref1[0]->ref[0][ i_part_8x8 ] ];
  280.         if( i_ref >= 0 )
  281.         {
  282.             const int dist_scale_factor = h->mb.dist_scale_factor[i_ref][0];
  284.             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
  286.             if( b8x8 )
  287.             {
  288.                 const int16_t *mv_col = h->fref1[0]->mv[0][ i_mb_4x4 + 3*x8 + 3*y8 * h->mb.i_b4_stride];
  289.                 int mv_l0[2];
  290.                 mv_l0[0] = ( dist_scale_factor * mv_col[0] + 128 ) >> 8;
  291.                 mv_l0[1] = ( dist_scale_factor * mv_col[1] + 128 ) >> 8;
  292.                 x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, mv_l0[0], mv_l0[1] );
  293.                 x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 1, mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1] );
  294.             }
  295.             else
  296.             {
  297.                 for( i4 = 0; i4 < 4; i4++ )
  298.                 {
  299.                     const int x4 = i4%2 + 2*x8;
  300.                     const int y4 = i4/2 + 2*y8;
  301.                     const int16_t *mv_col = h->fref1[0]->mv[0][ i_mb_4x4 + x4 + y4 * h->mb.i_b4_stride ];
  302.                     int mv_l0[2];
  303.                     mv_l0[0] = ( dist_scale_factor * mv_col[0] + 128 ) >> 8;
  304.                     mv_l0[1] = ( dist_scale_factor * mv_col[1] + 128 ) >> 8;
  305.                     x264_macroblock_cache_mv( h, x4, y4, 1, 1, 0, mv_l0[0], mv_l0[1] );
  306.                     x264_macroblock_cache_mv( h, x4, y4, 1, 1, 1, mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1] );
  307.                 }
  308.             }
  309.         }
  310.         else
  311.         {
  312.             /* the colocated ref isn't in the current list0 */
  313.             /* FIXME: we might still be able to use direct_8x8 on some partitions */
  314.             /* FIXME: with B-pyramid + extensive ref list reordering
  315.              *   (not currently used), we would also have to check
  316.              *   l1mv1 like in spatial mode */
  317.             return 0;
  318.         }
  319.     }
  321.     return 1;
  322. }
  324. static int x264_mb_predict_mv_direct16x16_spatial( x264_t *h )
  325. {
  326.     int ref[2];
  327.     int mv[2][2];
  328.     int i_list;
  329.     int i8, i4;
  330.     int b8x8;
  331.     const int8_t *l1ref0 = &h->fref1[0]->ref[0][ h->mb.i_b8_xy ];
  332.     const int8_t *l1ref1 = &h->fref1[0]->ref[1][ h->mb.i_b8_xy ];
  333.     const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->fref1[0]->mv[0][ h->mb.i_b4_xy ];
  334.     const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->fref1[0]->mv[1][ h->mb.i_b4_xy ];
  335.     const int type_col = h->fref1[0]->mb_type[ h->mb.i_mb_xy ];
  337.     for( i_list=0; i_list<2; i_list++ )
  338.     {
  339.         int i_refa = h->mb.cache.ref[i_list][X264_SCAN8_0 - 1];
  340.         int i_refb = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8];
  341.         int i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 + 4];
  342.         if( i_refc == -2 )
  343.             i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 - 1];
  345.         ref[i_list] = i_refa;
  346.         if( ref[i_list] < 0 || ( i_refb < ref[i_list] && i_refb >= 0 ))
  347.             ref[i_list] = i_refb;
  348.         if( ref[i_list] < 0 || ( i_refc < ref[i_list] && i_refc >= 0 ))
  349.             ref[i_list] = i_refc;
  350.         if( ref[i_list] < 0 )
  351.             ref[i_list] = -1;
  352.     }
  354.     if( ref[0] < 0 && ref[1] < 0 )
  355.     {
  356.         ref[0] = 
  357.         ref[1] = 0;
  358.         mv[0][0] = 
  359.         mv[0][1] = 
  360.         mv[1][0] = 
  361.         mv[1][1] = 0;
  362.     }
  363.     else
  364.     {
  365.         for( i_list=0; i_list<2; i_list++ )
  366.         {
  367.             if( ref[i_list] >= 0 )
  368.                 x264_mb_predict_mv_16x16( h, i_list, ref[i_list], mv[i_list] );
  369.             else
  370.                 mv[i_list][0] = mv[i_list][1] = 0;
  371.         }
  372.     }
  374.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, ref[0] );
  375.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, ref[1] );
  376.     x264_macroblock_cache_mv(  h, 0, 0, 4, 4, 0, mv[0][0], mv[0][1] );
  377.     x264_macroblock_cache_mv(  h, 0, 0, 4, 4, 1, mv[1][0], mv[1][1] );
  379.     if( IS_INTRA( type_col ) )
  380.         return 1;
  381.     b8x8 = h->sps->b_direct8x8_inference ||
  382.            (type_col != P_8x8 && type_col != B_SKIP && type_col != B_DIRECT && type_col != B_8x8);
  384.     /* col_zero_flag */
  385.     for( i8=0; i8<4; i8++ )
  386.     {
  387.         const int x8 = i8%2;
  388.         const int y8 = i8/2;
  389.         const int o8 = x8 + y8 * h->mb.i_b8_stride;
  390.         if( l1ref0[o8] == 0 || ( l1ref0[o8] < 0 && l1ref1[o8] == 0 ) )
  391.         {
  392.             const int16_t (*l1mv)[2] = (l1ref0[o8] == 0) ? l1mv0 : l1mv1;
  393.             if( b8x8 )
  394.             {
  395.                 const int16_t *mvcol = l1mv[3*x8 + 3*y8 * h->mb.i_b4_stride];
  396.                 if( abs( mvcol[0] ) <= 1 && abs( mvcol[1] ) <= 1 )
  397.                 {
  398.                     if( ref[0] == 0 )
  399.                         x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, 0, 0 );
  400.                     if( ref[1] == 0 )
  401.                         x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 1, 0, 0 );
  402.                 }
  403.             }
  404.             else
  405.             {
  406.                 for( i4=0; i4<4; i4++ )
  407.                 {
  408.                     const int x4 = i4%2 + 2*x8;
  409.                     const int y4 = i4/2 + 2*y8;
  410.                     const int16_t *mvcol = l1mv[x4 + y4 * h->mb.i_b4_stride];
  411.                     if( abs( mvcol[0] ) <= 1 && abs( mvcol[1] ) <= 1 )
  412.                     {
  413.                         if( ref[0] == 0 )
  414.                             x264_macroblock_cache_mv( h, x4, y4, 1, 1, 0, 0, 0 );
  415.                         if( ref[1] == 0 )
  416.                             x264_macroblock_cache_mv( h, x4, y4, 1, 1, 1, 0, 0 );
  417.                     }
  418.                 }
  419.             }
  420.         }
  421.     }
  423.     return 1;
  424. }
  426. int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed )
  427. {
  428.     int b_available;
  429.     if( h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_NONE )
  430.         return 0;
  431.     else if( h->sh.b_direct_spatial_mv_pred )
  432.         b_available = x264_mb_predict_mv_direct16x16_spatial( h );
  433.     else
  434.         b_available = x264_mb_predict_mv_direct16x16_temporal( h );
  436.     if( b_changed != NULL && b_available )
  437.     {
  438.         int type_col = h->fref1[0]->mb_type[ h->mb.i_mb_xy ];
  439.         if( IS_INTRA(type_col) || type_col == P_SKIP )
  440.         {
  441.             *b_changed = h->mb.cache.direct_ref[0][0] != h->mb.cache.ref[0][X264_SCAN8_0]
  442.                       || h->mb.cache.direct_ref[1][0] != h->mb.cache.ref[1][X264_SCAN8_0]
  443.                       || *(uint32_t*)h->mb.cache.direct_mv[0][X264_SCAN8_0] != *(uint32_t*)h->mb.cache.mv[0][X264_SCAN8_0]
  444.                       || *(uint32_t*)h->mb.cache.direct_mv[1][X264_SCAN8_0] != *(uint32_t*)h->mb.cache.mv[1][X264_SCAN8_0];
  445.         }
  446.         else
  447.         {
  448.             int i, l;
  449.             *b_changed = 0;
  450.             for( l = 0; l < 2; l++ )
  451.                 for( i = 0; i < 4; i++ )
  452.                     *b_changed |= h->mb.cache.direct_ref[l][i] != h->mb.cache.ref[l][x264_scan8[i*4]];
  453.             *b_changed = *b_changed || memcmp(h->mb.cache.direct_mv, h->mb.cache.mv, sizeof(h->mb.cache.mv));
  454.         }
  455.         if( !*b_changed )
  456.             return b_available;
  457.     }
  459.     /* cache ref & mv */
  460.     if( b_available )
  461.     {
  462.         int i, l;
  463.         for( l = 0; l < 2; l++ )
  464.             for( i = 0; i < 4; i++ )
  465.                 h->mb.cache.direct_ref[l][i] = h->mb.cache.ref[l][x264_scan8[i*4]];
  466.         memcpy(h->mb.cache.direct_mv, h->mb.cache.mv, sizeof(h->mb.cache.mv));
  467.     }
  469.     return b_available;
  470. }
  472. void x264_mb_load_mv_direct8x8( x264_t *h, int idx )
  473. {
  474.     const int x = 2*(idx%2);
  475.     const int y = 2*(idx/2);
  476.     int l;
  477.     x264_macroblock_cache_ref( h, x, y, 2, 2, 0, h->mb.cache.direct_ref[0][idx] );
  478.     x264_macroblock_cache_ref( h, x, y, 2, 2, 1, h->mb.cache.direct_ref[1][idx] );
  479.     for( l = 0; l < 2; l++ )
  480.     {
  481.         *(uint64_t*)h->mb.cache.mv[l][x264_scan8[idx*4]] =
  482.         *(uint64_t*)h->mb.cache.direct_mv[l][x264_scan8[idx*4]];
  483.         *(uint64_t*)h->mb.cache.mv[l][x264_scan8[idx*4]+8] =
  484.         *(uint64_t*)h->mb.cache.direct_mv[l][x264_scan8[idx*4]+8];
  485.     }
  486. }
  488. /* This just improves encoder performance, it's not part of the spec */
  489. void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int mvc[8][2], int *i_mvc )
  490. {
  491.     int16_t (*mvr)[2] = h->mb.mvr[i_list][i_ref];
  492.     int i = 0;
  494. #define SET_MVP(mvp) { 
  495.         mvc[i][0] = mvp[0]; 
  496.         mvc[i][1] = mvp[1]; 
  497.         i++; 
  498.     }
  500.     /* b_direct */
  501.     if( h->sh.i_type == SLICE_TYPE_B
  502.         && h->mb.cache.ref[i_list][x264_scan8[12]] == i_ref )
  503.     {
  504.         SET_MVP( h->mb.cache.mv[i_list][x264_scan8[12]] );
  505.     }
  507.     /* spatial predictors */
  508.     if( h->mb.i_neighbour & MB_LEFT )
  509.     {
  510.         int i_mb_l = h->mb.i_mb_xy - 1;
  511.         /* skip MBs didn't go through the whole search process, so mvr is undefined */
  512.         if( !IS_SKIP( h->mb.type[i_mb_l] ) )
  513.             SET_MVP( mvr[i_mb_l] );
  514.     }
  515.     if( h->mb.i_neighbour & MB_TOP )
  516.     {
  517.         int i_mb_t = h->mb.i_mb_xy - h->mb.i_mb_stride;
  518.         if( !IS_SKIP( h->mb.type[i_mb_t] ) )
  519.             SET_MVP( mvr[i_mb_t] );
  521.         if( h->mb.i_neighbour & MB_TOPLEFT && !IS_SKIP( h->mb.type[i_mb_t - 1] ) )
  522.             SET_MVP( mvr[i_mb_t-1] );
  523.         if( h->mb.i_mb_x < h->mb.i_mb_stride - 1 && !IS_SKIP( h->mb.type[i_mb_t + 1] ) )
  524.             SET_MVP( mvr[i_mb_t+1] );
  525.     }
  526. #undef SET_MVP
  528.     /* temporal predictors */
  529.     if( h->fref0[0]->i_ref[0] > 0 )
  530.     {
  531.         x264_frame_t *l0 = h->fref0[0];
  532.         int ref_col_cur, ref_col_prev = -1;
  533.         int scale = 0;
  535. #define SET_TMVP(dx, dy) { 
  536.             int i_b4 = h->mb.i_b4_xy + dx*4 + dy*4*h->mb.i_b4_stride; 
  537.             int i_b8 = h->mb.i_b8_xy + dx*2 + dy*2*h->mb.i_b8_stride; 
  538.             ref_col_cur = l0->ref[0][i_b8]; 
  539.             if( ref_col_cur >= 0 ) 
  540.             { 
  541.                 /* TODO: calc once per frame and tablize? */
  542.                 if( ref_col_cur != ref_col_prev ) 
  543.                     scale = 256 * (h->fenc->i_poc - h->fref0[i_ref]->i_poc) 
  544.                                 / (l0->i_poc - l0->ref_poc[0][ref_col_cur]); 
  545.                 mvc[i][0] = l0->mv[0][i_b4][0] * scale / 256; 
  546.                 mvc[i][1] = l0->mv[0][i_b4][1] * scale / 256; 
  547.                 i++; 
  548.                 ref_col_prev = ref_col_cur; 
  549.             } 
  550.         }
  552.         SET_TMVP(0,0);
  553.         if( h->mb.i_mb_x < h->sps->i_mb_width-1 )
  554.             SET_TMVP(1,0);
  555.         if( h->mb.i_mb_y < h->sps->i_mb_height-1 )
  556.             SET_TMVP(0,1);
  557. #undef SET_TMVP
  558.     }
  560.     *i_mvc = i;
  561. }
  563. static inline void x264_mb_mc_0xywh( x264_t *h, int x, int y, int width, int height )
  564. {
  565.     const int i8 = x264_scan8[0]+x+8*y;
  566.     const int i_ref = h->mb.cache.ref[0][i8];
  567.     const int mvx   = x264_clip3( h->mb.cache.mv[0][i8][0], h->mb.mv_min[0], h->mb.mv_max[0] );
  568.     const int mvy   = x264_clip3( h->mb.cache.mv[0][i8][1], h->mb.mv_min[1], h->mb.mv_max[1] );
  570.     h->mc.mc_luma( h->mb.pic.p_fref[0][i_ref], h->mb.pic.i_stride[0],
  571.                     &h->mb.pic.p_fdec[0][4*y*FDEC_STRIDE+4*x], FDEC_STRIDE,
  572.                     mvx + 4*4*x, mvy + 4*4*y, 4*width, 4*height );
  574.     h->mc.mc_chroma( &h->mb.pic.p_fref[0][i_ref][4][2*y*h->mb.pic.i_stride[1]+2*x], h->mb.pic.i_stride[1],
  575.                       &h->mb.pic.p_fdec[1][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE,
  576.                       mvx, mvy, 2*width, 2*height );
  578.     h->mc.mc_chroma( &h->mb.pic.p_fref[0][i_ref][5][2*y*h->mb.pic.i_stride[2]+2*x], h->mb.pic.i_stride[2],
  579.                       &h->mb.pic.p_fdec[2][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE,
  580.                       mvx, mvy, 2*width, 2*height );
  581. }
  582. static inline void x264_mb_mc_1xywh( x264_t *h, int x, int y, int width, int height )
  583. {
  584.     const int i8 = x264_scan8[0]+x+8*y;
  585.     const int i_ref = h->mb.cache.ref[1][i8];
  586.     const int mvx   = x264_clip3( h->mb.cache.mv[1][i8][0], h->mb.mv_min[0], h->mb.mv_max[0] );
  587.     const int mvy   = x264_clip3( h->mb.cache.mv[1][i8][1], h->mb.mv_min[1], h->mb.mv_max[1] );
  589.     h->mc.mc_luma( h->mb.pic.p_fref[1][i_ref], h->mb.pic.i_stride[0],
  590.                     &h->mb.pic.p_fdec[0][4*y*FDEC_STRIDE+4*x], FDEC_STRIDE,
  591.                     mvx + 4*4*x, mvy + 4*4*y, 4*width, 4*height );
  593.     h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref][4][2*y*h->mb.pic.i_stride[1]+2*x], h->mb.pic.i_stride[1],
  594.                       &h->mb.pic.p_fdec[1][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE,
  595.                       mvx, mvy, 2*width, 2*height );
  597.     h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref][5][2*y*h->mb.pic.i_stride[2]+2*x], h->mb.pic.i_stride[2],
  598.                       &h->mb.pic.p_fdec[2][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE,
  599.                       mvx, mvy, 2*width, 2*height );
  600. }
  602. static inline void x264_mb_mc_01xywh( x264_t *h, int x, int y, int width, int height )
  603. {
  604.     const int i8 = x264_scan8[0]+x+8*y;
  606.     const int i_ref1 = h->mb.cache.ref[1][i8];
  607.     const int mvx1   = x264_clip3( h->mb.cache.mv[1][i8][0], h->mb.mv_min[0], h->mb.mv_max[0] );
  608.     const int mvy1   = x264_clip3( h->mb.cache.mv[1][i8][1], h->mb.mv_min[1], h->mb.mv_max[1] );
  609.     DECLARE_ALIGNED( uint8_t, tmp[16*16], 16 );
  610.     int i_mode = x264_size2pixel[height][width];
  612.     x264_mb_mc_0xywh( h, x, y, width, height );
  614.     h->mc.mc_luma( h->mb.pic.p_fref[1][i_ref1], h->mb.pic.i_stride[0],
  615.                     tmp, 16, mvx1 + 4*4*x, mvy1 + 4*4*y, 4*width, 4*height );
  617.     if( h->param.analyse.b_weighted_bipred )
  618.     {
  619.         const int i_ref0 = h->mb.cache.ref[0][i8];
  620.         const int weight = h->mb.bipred_weight[i_ref0][i_ref1];
  622.         h->mc.avg_weight[i_mode]( &h->mb.pic.p_fdec[0][4*y*FDEC_STRIDE+4*x], FDEC_STRIDE, tmp, 16, weight );
  624.         h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref1][4][2*y*h->mb.pic.i_stride[1]+2*x], h->mb.pic.i_stride[1],
  625.                           tmp, 16, mvx1, mvy1, 2*width, 2*height );
  626.         h->mc.avg_weight[i_mode+3]( &h->mb.pic.p_fdec[1][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE, tmp, 16, weight );
  628.         h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref1][5][2*y*h->mb.pic.i_stride[2]+2*x], h->mb.pic.i_stride[2],
  629.                           tmp, 16, mvx1, mvy1, 2*width, 2*height );
  630.         h->mc.avg_weight[i_mode+3]( &h->mb.pic.p_fdec[2][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE, tmp, 16, weight );
  631.     }
  632.     else
  633.     {
  634.         h->mc.avg[i_mode]( &h->mb.pic.p_fdec[0][4*y*FDEC_STRIDE+4*x], FDEC_STRIDE, tmp, 16 );
  636.         h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref1][4][2*y*h->mb.pic.i_stride[1]+2*x], h->mb.pic.i_stride[1],
  637.                           tmp, 16, mvx1, mvy1, 2*width, 2*height );
  638.         h->mc.avg[i_mode+3]( &h->mb.pic.p_fdec[1][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE, tmp, 16 );
  640.         h->mc.mc_chroma( &h->mb.pic.p_fref[1][i_ref1][5][2*y*h->mb.pic.i_stride[2]+2*x], h->mb.pic.i_stride[2],
  641.                           tmp, 16, mvx1, mvy1, 2*width, 2*height );
  642.         h->mc.avg[i_mode+3]( &h->mb.pic.p_fdec[2][2*y*FDEC_STRIDE+2*x], FDEC_STRIDE, tmp, 16 );
  643.     }
  644. }
  646. static void x264_mb_mc_direct8x8( x264_t *h, int x, int y )
  647. {
  648.     const int i8 = x264_scan8[0] + x + 8*y;
  650.     /* FIXME: optimize based on current block size, not global settings? */
  651.     if( h->sps->b_direct8x8_inference )
  652.     {
  653.         if( h->mb.cache.ref[0][i8] >= 0 )
  654.             if( h->mb.cache.ref[1][i8] >= 0 )
  655.                 x264_mb_mc_01xywh( h, x, y, 2, 2 );
  656.             else
  657.                 x264_mb_mc_0xywh( h, x, y, 2, 2 );
  658.         else
  659.             x264_mb_mc_1xywh( h, x, y, 2, 2 );
  660.     }
  661.     else
  662.     {
  663.         if( h->mb.cache.ref[0][i8] >= 0 )
  664.         {
  665.             if( h->mb.cache.ref[1][i8] >= 0 )
  666.             {
  667.                 x264_mb_mc_01xywh( h, x+0, y+0, 1, 1 );
  668.                 x264_mb_mc_01xywh( h, x+1, y+0, 1, 1 );
  669.                 x264_mb_mc_01xywh( h, x+0, y+1, 1, 1 );
  670.                 x264_mb_mc_01xywh( h, x+1, y+1, 1, 1 );
  671.             }
  672.             else
  673.             {
  674.                 x264_mb_mc_0xywh( h, x+0, y+0, 1, 1 );
  675.                 x264_mb_mc_0xywh( h, x+1, y+0, 1, 1 );
  676.                 x264_mb_mc_0xywh( h, x+0, y+1, 1, 1 );
  677.                 x264_mb_mc_0xywh( h, x+1, y+1, 1, 1 );
  678.             }
  679.         }
  680.         else
  681.         {
  682.             x264_mb_mc_1xywh( h, x+0, y+0, 1, 1 );
  683.             x264_mb_mc_1xywh( h, x+1, y+0, 1, 1 );
  684.             x264_mb_mc_1xywh( h, x+0, y+1, 1, 1 );
  685.             x264_mb_mc_1xywh( h, x+1, y+1, 1, 1 );
  686.         }
  687.     }
  688. }
  690. void x264_mb_mc( x264_t *h )
  691. {
  692.     if( h->mb.i_type == P_L0 )
  693.     {
  694.         if( h->mb.i_partition == D_16x16 )
  695.         {
  696.             x264_mb_mc_0xywh( h, 0, 0, 4, 4 );
  697.         }
  698.         else if( h->mb.i_partition == D_16x8 )
  699.         {
  700.             x264_mb_mc_0xywh( h, 0, 0, 4, 2 );
  701.             x264_mb_mc_0xywh( h, 0, 2, 4, 2 );
  702.         }
  703.         else if( h->mb.i_partition == D_8x16 )
  704.         {
  705.             x264_mb_mc_0xywh( h, 0, 0, 2, 4 );
  706.             x264_mb_mc_0xywh( h, 2, 0, 2, 4 );
  707.         }
  708.     }
  709.     else if( h->mb.i_type == P_8x8 || h->mb.i_type == B_8x8 )
  710.     {
  711.         int i;
  712.         for( i = 0; i < 4; i++ )
  713.         {
  714.             const int x = 2*(i%2);
  715.             const int y = 2*(i/2);
  716.             switch( h->mb.i_sub_partition[i] )
  717.             {
  718.                 case D_L0_8x8:
  719.                     x264_mb_mc_0xywh( h, x, y, 2, 2 );
  720.                     break;
  721.                 case D_L0_8x4:
  722.                     x264_mb_mc_0xywh( h, x, y+0, 2, 1 );
  723.                     x264_mb_mc_0xywh( h, x, y+1, 2, 1 );
  724.                     break;
  725.                 case D_L0_4x8:
  726.                     x264_mb_mc_0xywh( h, x+0, y, 1, 2 );
  727.                     x264_mb_mc_0xywh( h, x+1, y, 1, 2 );
  728.                     break;
  729.                 case D_L0_4x4:
  730.                     x264_mb_mc_0xywh( h, x+0, y+0, 1, 1 );
  731.                     x264_mb_mc_0xywh( h, x+1, y+0, 1, 1 );
  732.                     x264_mb_mc_0xywh( h, x+0, y+1, 1, 1 );
  733.                     x264_mb_mc_0xywh( h, x+1, y+1, 1, 1 );
  734.                     break;
  735.                 case D_L1_8x8:
  736.                     x264_mb_mc_1xywh( h, x, y, 2, 2 );
  737.                     break;
  738.                 case D_L1_8x4:
  739.                     x264_mb_mc_1xywh( h, x, y+0, 2, 1 );
  740.                     x264_mb_mc_1xywh( h, x, y+1, 2, 1 );
  741.                     break;
  742.                 case D_L1_4x8:
  743.                     x264_mb_mc_1xywh( h, x+0, y, 1, 2 );
  744.                     x264_mb_mc_1xywh( h, x+1, y, 1, 2 );
  745.                     break;
  746.                 case D_L1_4x4:
  747.                     x264_mb_mc_1xywh( h, x+0, y+0, 1, 1 );
  748.                     x264_mb_mc_1xywh( h, x+1, y+0, 1, 1 );
  749.                     x264_mb_mc_1xywh( h, x+0, y+1, 1, 1 );
  750.                     x264_mb_mc_1xywh( h, x+1, y+1, 1, 1 );
  751.                     break;
  752.                 case D_BI_8x8:
  753.                     x264_mb_mc_01xywh( h, x, y, 2, 2 );
  754.                     break;
  755.                 case D_BI_8x4:
  756.                     x264_mb_mc_01xywh( h, x, y+0, 2, 1 );
  757.                     x264_mb_mc_01xywh( h, x, y+1, 2, 1 );
  758.                     break;
  759.                 case D_BI_4x8:
  760.                     x264_mb_mc_01xywh( h, x+0, y, 1, 2 );
  761.                     x264_mb_mc_01xywh( h, x+1, y, 1, 2 );
  762.                     break;
  763.                 case D_BI_4x4:
  764.                     x264_mb_mc_01xywh( h, x+0, y+0, 1, 1 );
  765.                     x264_mb_mc_01xywh( h, x+1, y+0, 1, 1 );
  766.                     x264_mb_mc_01xywh( h, x+0, y+1, 1, 1 );
  767.                     x264_mb_mc_01xywh( h, x+1, y+1, 1, 1 );
  768.                     break;
  769.                 case D_DIRECT_8x8:
  770.                     x264_mb_mc_direct8x8( h, x, y );
  771.                     break;
  772.             }
  773.         }
  774.     }
  775.     else if( h->mb.i_type == B_SKIP || h->mb.i_type == B_DIRECT )
  776.     {
  777.         x264_mb_mc_direct8x8( h, 0, 0 );
  778.         x264_mb_mc_direct8x8( h, 2, 0 );
  779.         x264_mb_mc_direct8x8( h, 0, 2 );
  780.         x264_mb_mc_direct8x8( h, 2, 2 );
  781.     }
  782.     else    /* B_*x* */
  783.     {
  784.         int b_list0[2];
  785.         int b_list1[2];
  787.         int i;
  789.         /* init ref list utilisations */
  790.         for( i = 0; i < 2; i++ )
  791.         {
  792.             b_list0[i] = x264_mb_type_list0_table[h->mb.i_type][i];
  793.             b_list1[i] = x264_mb_type_list1_table[h->mb.i_type][i];
  794.         }
  795.         if( h->mb.i_partition == D_16x16 )
  796.         {
  797.             if( b_list0[0] && b_list1[0] ) x264_mb_mc_01xywh( h, 0, 0, 4, 4 );
  798.             else if( b_list0[0] )          x264_mb_mc_0xywh ( h, 0, 0, 4, 4 );
  799.             else if( b_list1[0] )          x264_mb_mc_1xywh ( h, 0, 0, 4, 4 );
  800.         }
  801.         else if( h->mb.i_partition == D_16x8 )
  802.         {
  803.             if( b_list0[0] && b_list1[0] ) x264_mb_mc_01xywh( h, 0, 0, 4, 2 );
  804.             else if( b_list0[0] )          x264_mb_mc_0xywh ( h, 0, 0, 4, 2 );
  805.             else if( b_list1[0] )          x264_mb_mc_1xywh ( h, 0, 0, 4, 2 );
  807.             if( b_list0[1] && b_list1[1] ) x264_mb_mc_01xywh( h, 0, 2, 4, 2 );
  808.             else if( b_list0[1] )          x264_mb_mc_0xywh ( h, 0, 2, 4, 2 );
  809.             else if( b_list1[1] )          x264_mb_mc_1xywh ( h, 0, 2, 4, 2 );
  810.         }
  811.         else if( h->mb.i_partition == D_8x16 )
  812.         {
  813.             if( b_list0[0] && b_list1[0] ) x264_mb_mc_01xywh( h, 0, 0, 2, 4 );
  814.             else if( b_list0[0] )          x264_mb_mc_0xywh ( h, 0, 0, 2, 4 );
  815.             else if( b_list1[0] )          x264_mb_mc_1xywh ( h, 0, 0, 2, 4 );
  817.             if( b_list0[1] && b_list1[1] ) x264_mb_mc_01xywh( h, 2, 0, 2, 4 );
  818.             else if( b_list0[1] )          x264_mb_mc_0xywh ( h, 2, 0, 2, 4 );
  819.             else if( b_list1[1] )          x264_mb_mc_1xywh ( h, 2, 0, 2, 4 );
  820.         }
  821.     }
  822. }
  824. void x264_macroblock_cache_init( x264_t *h )
  825. {
  826.     int i, j;
  827.     int i_mb_count = h->mb.i_mb_count;
  829.     h->mb.i_mb_stride = h->sps->i_mb_width;
  830.     h->mb.i_b8_stride = h->sps->i_mb_width * 2;
  831.     h->mb.i_b4_stride = h->sps->i_mb_width * 4;
  833.     h->mb.qp  = x264_malloc( i_mb_count * sizeof(int8_t) );
  834.     h->mb.cbp = x264_malloc( i_mb_count * sizeof(int16_t) );
  835.     h->mb.skipbp = x264_malloc( i_mb_count * sizeof(int8_t) );
  836.     h->mb.mb_transform_size = x264_malloc( i_mb_count * sizeof(int8_t) );
  838.     /* 0 -> 3 top(4), 4 -> 6 : left(3) */
  839.     h->mb.intra4x4_pred_mode = x264_malloc( i_mb_count * 7 * sizeof( int8_t ) );
  841.     /* all coeffs */
  842.     h->mb.non_zero_count = x264_malloc( i_mb_count * 24 * sizeof( uint8_t ) );
  844.     if( h->param.b_cabac )
  845.     {
  846.         h->mb.chroma_pred_mode = x264_malloc( i_mb_count * sizeof( int8_t) );
  847.         h->mb.mvd[0] = x264_malloc( 2*16 * i_mb_count * sizeof( int16_t ) );
  848.         h->mb.mvd[1] = x264_malloc( 2*16 * i_mb_count * sizeof( int16_t ) );
  849.     }
  851.     for( i=0; i<2; i++ )
  852.     {
  853.         int i_refs = (i ? 1 : h->param.i_frame_reference) + h->param.b_bframe_pyramid;
  854.         for( j=0; j < i_refs && j < 16; j++ )
  855.             h->mb.mvr[i][j] = x264_malloc( 2 * i_mb_count * sizeof( int16_t ) );
  856.     }
  858.     /* init with not avaiable (for top right idx=7,15) */
  859.     memset( h->mb.cache.ref[0], -2, X264_SCAN8_SIZE * sizeof( int8_t ) );
  860.     memset( h->mb.cache.ref[1], -2, X264_SCAN8_SIZE * sizeof( int8_t ) );
  861. }
  862. void x264_macroblock_cache_end( x264_t *h )
  863. {
  864.     int i, j;
  865.     for( i=0; i<2; i++ )
  866.     {
  867.         int i_refs = i ? 1 + h->param.b_bframe_pyramid : h->param.i_frame_reference;
  868.         for( j=0; j < i_refs; j++ )
  869.             x264_free( h->mb.mvr[i][j] );
  870.     }
  871.     if( h->param.b_cabac )
  872.     {
  873.         x264_free( h->mb.chroma_pred_mode );
  874.         x264_free( h->mb.mvd[0] );
  875.         x264_free( h->mb.mvd[1] );
  876.     }
  877.     x264_free( h->mb.intra4x4_pred_mode );
  878.     x264_free( h->mb.non_zero_count );
  879.     x264_free( h->mb.mb_transform_size );
  880.     x264_free( h->mb.skipbp );
  881.     x264_free( h->mb.cbp );
  882.     x264_free( h->mb.qp );
  883. }
  884. void x264_macroblock_slice_init( x264_t *h )
  885. {
  886.     int i, j;
  888.     h->mb.mv[0] = h->fdec->mv[0];
  889.     h->mb.mv[1] = h->fdec->mv[1];
  890.     h->mb.ref[0] = h->fdec->ref[0];
  891.     h->mb.ref[1] = h->fdec->ref[1];
  892.     h->mb.type = h->fdec->mb_type;
  894.     h->fdec->i_ref[0] = h->i_ref0;
  895.     h->fdec->i_ref[1] = h->i_ref1;
  896.     for( i = 0; i < h->i_ref0; i++ )
  897.         h->fdec->ref_poc[0][i] = h->fref0[i]->i_poc;
  898.     if( h->sh.i_type == SLICE_TYPE_B )
  899.     {
  900.         for( i = 0; i < h->i_ref1; i++ )
  901.             h->fdec->ref_poc[1][i] = h->fref1[i]->i_poc;
  903.         h->mb.map_col_to_list0[-1] = -1;
  904.         h->mb.map_col_to_list0[-2] = -2;
  905.         for( i = 0; i < h->fref1[0]->i_ref[0]; i++ )
  906.         {
  907.             int poc = h->fref1[0]->ref_poc[0][i];
  908.             h->mb.map_col_to_list0[i] = -2;
  909.             for( j = 0; j < h->i_ref0; j++ )
  910.                 if( h->fref0[j]->i_poc == poc )
  911.                 {
  912.                     h->mb.map_col_to_list0[i] = j;
  913.                     break;
  914.                 }
  915.         }
  916.     }
  917.     if( h->sh.i_type == SLICE_TYPE_P )
  918.         memset( h->mb.cache.skip, 0, X264_SCAN8_SIZE * sizeof( int8_t ) );
  919. }
  922. void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y )
  923. {
  924.     const int i_mb_4x4 = 4*(i_mb_y * h->mb.i_b4_stride + i_mb_x);
  925.     const int i_mb_8x8 = 2*(i_mb_y * h->mb.i_b8_stride + i_mb_x);
  927.     int i_mb_xy = i_mb_y * h->mb.i_mb_stride + i_mb_x;
  928.     int i_top_xy = i_mb_xy - h->mb.i_mb_stride;
  929.     int i_left_xy = -1;
  930.     int i_top_type = -1;    /* gcc warn */
  931.     int i_left_type= -1;
  933.     int i;
  935.     /* init index */
  936.     h->mb.i_mb_x = i_mb_x;
  937.     h->mb.i_mb_y = i_mb_y;
  938.     h->mb.i_mb_xy = i_mb_xy;
  939.     h->mb.i_b8_xy = i_mb_8x8;
  940.     h->mb.i_b4_xy = i_mb_4x4;
  941.     h->mb.i_neighbour = 0;
  943.     /* fdec:      fenc:
  944.      * yyyyyyy
  945.      * yYYYY      YYYY
  946.      * yYYYY      YYYY
  947.      * yYYYY      YYYY
  948.      * yYYYY      YYYY
  949.      * uuu vvv    UUVV
  950.      * uUU vVV    UUVV
  951.      * uUU vVV
  952.      */
  953.     h->mb.pic.p_fenc[0] = h->mb.pic.fenc_buf;
  954.     h->mb.pic.p_fenc[1] = h->mb.pic.fenc_buf + 16*FENC_STRIDE;
  955.     h->mb.pic.p_fenc[2] = h->mb.pic.fenc_buf + 16*FENC_STRIDE + 8;
  956.     h->mb.pic.p_fdec[0] = h->mb.pic.fdec_buf + 2*FDEC_STRIDE;
  957.     h->mb.pic.p_fdec[1] = h->mb.pic.fdec_buf + 19*FDEC_STRIDE;
  958.     h->mb.pic.p_fdec[2] = h->mb.pic.fdec_buf + 19*FDEC_STRIDE + 16;
  960.     /* load picture pointers */
  961.     for( i = 0; i < 3; i++ )
  962.     {
  963.         const int w = (i == 0 ? 16 : 8);
  964.         const int i_stride = h->fdec->i_stride[i];
  965.         const uint8_t *plane_fdec = &h->fdec->plane[i][ w * (i_mb_x + i_mb_y * i_stride) ];
  966.         int   j;
  968.         h->mb.pic.i_stride[i] = i_stride;
  970.         h->mc.copy[i?PIXEL_8x8:PIXEL_16x16]( h->mb.pic.p_fenc[i], FENC_STRIDE,
  971.             &h->fenc->plane[i][ w * (i_mb_x + i_mb_y * i_stride) ], i_stride, w );
  972.         memcpy( &h->mb.pic.p_fdec[i][-1-FDEC_STRIDE], &plane_fdec[-1-i_stride], w*3/2+1 );
  973.         for( j = 0; j < w; j++ )
  974.             h->mb.pic.p_fdec[i][-1+j*FDEC_STRIDE] = plane_fdec[-1+j*i_stride];
  976.         for( j = 0; j < h->i_ref0; j++ )
  977.         {
  978.             h->mb.pic.p_fref[0][j][i==0 ? 0:i+3] = &h->fref0[j]->plane[i][ w * ( i_mb_x + i_mb_y * i_stride )];
  979.             h->mb.pic.p_fref[0][j][i+1] = &h->fref0[j]->filtered[i+1][ 16 * ( i_mb_x + i_mb_y * h->fdec->i_stride[0] )];
  980.         }
  981.         for( j = 0; j < h->i_ref1; j++ )
  982.         {
  983.             h->mb.pic.p_fref[1][j][i==0 ? 0:i+3] = &h->fref1[j]->plane[i][ w * ( i_mb_x + i_mb_y * i_stride )];
  984.             h->mb.pic.p_fref[1][j][i+1] = &h->fref1[j]->filtered[i+1][ 16 * ( i_mb_x + i_mb_y * h->fdec->i_stride[0] )];
  985.         }
  986.     }
  988.     if( h->fdec->integral )
  989.     {
  990.         for( i = 0; i < h->i_ref0; i++ )
  991.             h->mb.pic.p_integral[0][i] = &h->fref0[i]->integral[ 16 * ( i_mb_x + i_mb_y * h->fdec->i_stride[0] )];
  992.         for( i = 0; i < h->i_ref1; i++ )
  993.             h->mb.pic.p_integral[1][i] = &h->fref1[i]->integral[ 16 * ( i_mb_x + i_mb_y * h->fdec->i_stride[0] )];
  994.     }
  996.     /* load cache */
  997.     if( i_mb_xy >= h->sh.i_first_mb + h->mb.i_mb_stride )
  998.     {
  999.         h->mb.i_mb_type_top =
  1000.         i_top_type= h->mb.type[i_top_xy];
  1002.         h->mb.i_neighbour |= MB_TOP;
  1004.         /* load intra4x4 */
  1005.         h->mb.cache.intra4x4_pred_mode[x264_scan8[0] - 8] = h->mb.intra4x4_pred_mode[i_top_xy][0];
  1006.         h->mb.cache.intra4x4_pred_mode[x264_scan8[1] - 8] = h->mb.intra4x4_pred_mode[i_top_xy][1];
  1007.         h->mb.cache.intra4x4_pred_mode[x264_scan8[4] - 8] = h->mb.intra4x4_pred_mode[i_top_xy][2];
  1008.         h->mb.cache.intra4x4_pred_mode[x264_scan8[5] - 8] = h->mb.intra4x4_pred_mode[i_top_xy][3];
  1010.         /* load non_zero_count */
  1011.         h->mb.cache.non_zero_count[x264_scan8[0] - 8] = h->mb.non_zero_count[i_top_xy][10];
  1012.         h->mb.cache.non_zero_count[x264_scan8[1] - 8] = h->mb.non_zero_count[i_top_xy][11];
  1013.         h->mb.cache.non_zero_count[x264_scan8[4] - 8] = h->mb.non_zero_count[i_top_xy][14];
  1014.         h->mb.cache.non_zero_count[x264_scan8[5] - 8] = h->mb.non_zero_count[i_top_xy][15];
  1016.         h->mb.cache.non_zero_count[x264_scan8[16+0] - 8] = h->mb.non_zero_count[i_top_xy][16+2];
  1017.         h->mb.cache.non_zero_count[x264_scan8[16+1] - 8] = h->mb.non_zero_count[i_top_xy][16+3];
  1019.         h->mb.cache.non_zero_count[x264_scan8[16+4+0] - 8] = h->mb.non_zero_count[i_top_xy][16+4+2];
  1020.         h->mb.cache.non_zero_count[x264_scan8[16+4+1] - 8] = h->mb.non_zero_count[i_top_xy][16+4+3];
  1021.     }
  1022.     else
  1023.     {
  1024.         h->mb.i_mb_type_top = -1;
  1025.         
  1026.         /* load intra4x4 */
  1027.         h->mb.cache.intra4x4_pred_mode[x264_scan8[0] - 8] =
  1028.         h->mb.cache.intra4x4_pred_mode[x264_scan8[1] - 8] =
  1029.         h->mb.cache.intra4x4_pred_mode[x264_scan8[4] - 8] =
  1030.         h->mb.cache.intra4x4_pred_mode[x264_scan8[5] - 8] = -1;
  1032.         /* load non_zero_count */
  1033.         h->mb.cache.non_zero_count[x264_scan8[0] - 8] =
  1034.         h->mb.cache.non_zero_count[x264_scan8[1] - 8] =
  1035.         h->mb.cache.non_zero_count[x264_scan8[4] - 8] =
  1036.         h->mb.cache.non_zero_count[x264_scan8[5] - 8] =
  1037.         h->mb.cache.non_zero_count[x264_scan8[16+0] - 8] =
  1038.         h->mb.cache.non_zero_count[x264_scan8[16+1] - 8] =
  1039.         h->mb.cache.non_zero_count[x264_scan8[16+4+0] - 8] =
  1040.         h->mb.cache.non_zero_count[x264_scan8[16+4+1] - 8] = 0x80;
  1042.     }
  1044.     if( i_mb_x > 0 && i_mb_xy > h->sh.i_first_mb )
  1045.     {
  1046.         i_left_xy = i_mb_xy - 1;
  1047.         h->mb.i_mb_type_left =
  1048.         i_left_type = h->mb.type[i_left_xy];
  1050.         h->mb.i_neighbour |= MB_LEFT;
  1052.         /* load intra4x4 */
  1053.         h->mb.cache.intra4x4_pred_mode[x264_scan8[0 ] - 1] = h->mb.intra4x4_pred_mode[i_left_xy][4];
  1054.         h->mb.cache.intra4x4_pred_mode[x264_scan8[2 ] - 1] = h->mb.intra4x4_pred_mode[i_left_xy][5];
  1055.         h->mb.cache.intra4x4_pred_mode[x264_scan8[8 ] - 1] = h->mb.intra4x4_pred_mode[i_left_xy][6];
  1056.         h->mb.cache.intra4x4_pred_mode[x264_scan8[10] - 1] = h->mb.intra4x4_pred_mode[i_left_xy][3];
  1058.         /* load non_zero_count */
  1059.         h->mb.cache.non_zero_count[x264_scan8[0 ] - 1] = h->mb.non_zero_count[i_left_xy][5];
  1060.         h->mb.cache.non_zero_count[x264_scan8[2 ] - 1] = h->mb.non_zero_count[i_left_xy][7];
  1061.         h->mb.cache.non_zero_count[x264_scan8[8 ] - 1] = h->mb.non_zero_count[i_left_xy][13];
  1062.         h->mb.cache.non_zero_count[x264_scan8[10] - 1] = h->mb.non_zero_count[i_left_xy][15];
  1064.         h->mb.cache.non_zero_count[x264_scan8[16+0] - 1] = h->mb.non_zero_count[i_left_xy][16+1];
  1065.         h->mb.cache.non_zero_count[x264_scan8[16+2] - 1] = h->mb.non_zero_count[i_left_xy][16+3];
  1067.         h->mb.cache.non_zero_count[x264_scan8[16+4+0] - 1] = h->mb.non_zero_count[i_left_xy][16+4+1];
  1068.         h->mb.cache.non_zero_count[x264_scan8[16+4+2] - 1] = h->mb.non_zero_count[i_left_xy][16+4+3];
  1069.     }
  1070.     else
  1071.     {
  1072.         h->mb.i_mb_type_left = -1;
  1074.         h->mb.cache.intra4x4_pred_mode[x264_scan8[0 ] - 1] =
  1075.         h->mb.cache.intra4x4_pred_mode[x264_scan8[2 ] - 1] =
  1076.         h->mb.cache.intra4x4_pred_mode[x264_scan8[8 ] - 1] =
  1077.         h->mb.cache.intra4x4_pred_mode[x264_scan8[10] - 1] = -1;
  1079.         /* load non_zero_count */
  1080.         h->mb.cache.non_zero_count[x264_scan8[0 ] - 1] =
  1081.         h->mb.cache.non_zero_count[x264_scan8[2 ] - 1] =
  1082.         h->mb.cache.non_zero_count[x264_scan8[8 ] - 1] =
  1083.         h->mb.cache.non_zero_count[x264_scan8[10] - 1] =
  1084.         h->mb.cache.non_zero_count[x264_scan8[16+0] - 1] =
  1085.         h->mb.cache.non_zero_count[x264_scan8[16+2] - 1] =
  1086.         h->mb.cache.non_zero_count[x264_scan8[16+4+0] - 1] =
  1087.         h->mb.cache.non_zero_count[x264_scan8[16+4+2] - 1] = 0x80;
  1088.     }
  1090.     if( i_mb_x < h->sps->i_mb_width - 1 && i_top_xy + 1 >= h->sh.i_first_mb )
  1091.     {
  1092.         h->mb.i_neighbour |= MB_TOPRIGHT;
  1093.         h->mb.i_mb_type_topright = h->mb.type[ i_top_xy + 1 ];
  1094.     }
  1095.     else
  1096.         h->mb.i_mb_type_topright = -1;
  1097.     if( i_mb_x > 0 && i_top_xy - 1 >= h->sh.i_first_mb )
  1098.     {
  1099.         h->mb.i_neighbour |= MB_TOPLEFT;
  1100.         h->mb.i_mb_type_topleft = h->mb.type[ i_top_xy - 1 ];
  1101.     }
  1102.     else
  1103.         h->mb.i_mb_type_topleft = -1;
  1105.     if( h->param.analyse.b_transform_8x8 )
  1106.     {
  1107.         h->mb.cache.i_neighbour_transform_size =
  1108.             ( i_left_type >= 0 && h->mb.mb_transform_size[i_left_xy] )
  1109.           + ( i_top_type  >= 0 && h->mb.mb_transform_size[i_top_xy]  );
  1110.     }
  1112.     /* load ref/mv/mvd */
  1113.     if( h->sh.i_type != SLICE_TYPE_I )
  1114.     {
  1115.         const int s8x8 = h->mb.i_b8_stride;
  1116.         const int s4x4 = h->mb.i_b4_stride;
  1118.         int i_list;
  1120.         for( i_list = 0; i_list < (h->sh.i_type == SLICE_TYPE_B ? 2  : 1 ); i_list++ )
  1121.         {
  1122.             /*
  1123.             h->mb.cache.ref[i_list][x264_scan8[5 ]+1] =
  1124.             h->mb.cache.ref[i_list][x264_scan8[7 ]+1] =
  1125.             h->mb.cache.ref[i_list][x264_scan8[13]+1] = -2;
  1126.             */
  1128.             if( h->mb.i_neighbour & MB_TOPLEFT )
  1129.             {
  1130.                 const int i8 = x264_scan8[0] - 1 - 1*8;
  1131.                 const int ir = i_mb_8x8 - s8x8 - 1;
  1132.                 const int iv = i_mb_4x4 - s4x4 - 1;
  1133.                 h->mb.cache.ref[i_list][i8]  = h->mb.ref[i_list][ir];
  1134.                 h->mb.cache.mv[i_list][i8][0] = h->mb.mv[i_list][iv][0];
  1135.                 h->mb.cache.mv[i_list][i8][1] = h->mb.mv[i_list][iv][1];
  1136.             }
  1137.             else
  1138.             {
  1139.                 const int i8 = x264_scan8[0] - 1 - 1*8;
  1140.                 h->mb.cache.ref[i_list][i8] = -2;
  1141.                 h->mb.cache.mv[i_list][i8][0] = 0;
  1142.                 h->mb.cache.mv[i_list][i8][1] = 0;
  1143.             }
  1145.             if( h->mb.i_neighbour & MB_TOP )
  1146.             {
  1147.                 const int i8 = x264_scan8[0] - 8;
  1148.                 const int ir = i_mb_8x8 - s8x8;
  1149.                 const int iv = i_mb_4x4 - s4x4;
  1151.                 h->mb.cache.ref[i_list][i8+0] =
  1152.                 h->mb.cache.ref[i_list][i8+1] = h->mb.ref[i_list][ir + 0];
  1153.                 h->mb.cache.ref[i_list][i8+2] =
  1154.                 h->mb.cache.ref[i_list][i8+3] = h->mb.ref[i_list][ir + 1];
  1156.                 for( i = 0; i < 4; i++ )
  1157.                 {
  1158.                     h->mb.cache.mv[i_list][i8+i][0] = h->mb.mv[i_list][iv + i][0];
  1159.                     h->mb.cache.mv[i_list][i8+i][1] = h->mb.mv[i_list][iv + i][1];
  1160.                 }
  1161.             }
  1162.             else
  1163.             {
  1164.                 const int i8 = x264_scan8[0] - 8;
  1165.                 for( i = 0; i < 4; i++ )
  1166.                 {
  1167.                     h->mb.cache.ref[i_list][i8+i] = -2;
  1168.                     h->mb.cache.mv[i_list][i8+i][0] =
  1169.                     h->mb.cache.mv[i_list][i8+i][1] = 0;
  1170.                 }
  1171.             }
  1173.             if( h->mb.i_neighbour & MB_TOPRIGHT )
  1174.             {
  1175.                 const int i8 = x264_scan8[0] + 4 - 1*8;
  1176.                 const int ir = i_mb_8x8 - s8x8 + 2;
  1177.                 const int iv = i_mb_4x4 - s4x4 + 4;
  1179.                 h->mb.cache.ref[i_list][i8]  = h->mb.ref[i_list][ir];
  1180.                 h->mb.cache.mv[i_list][i8][0] = h->mb.mv[i_list][iv][0];
  1181.                 h->mb.cache.mv[i_list][i8][1] = h->mb.mv[i_list][iv][1];
  1182.             }
  1183.             else
  1184.             {
  1185.                 const int i8 = x264_scan8[0] + 4 - 1*8;
  1186.                 h->mb.cache.ref[i_list][i8] = -2;
  1187.                 h->mb.cache.mv[i_list][i8][0] = 0;
  1188.                 h->mb.cache.mv[i_list][i8][1] = 0;
  1189.             }
  1191.             if( h->mb.i_neighbour & MB_LEFT )
  1192.             {
  1193.                 const int i8 = x264_scan8[0] - 1;
  1194.                 const int ir = i_mb_8x8 - 1;
  1195.                 const int iv = i_mb_4x4 - 1;
  1197.                 h->mb.cache.ref[i_list][i8+0*8] =
  1198.                 h->mb.cache.ref[i_list][i8+1*8] = h->mb.ref[i_list][ir + 0*s8x8];
  1199.                 h->mb.cache.ref[i_list][i8+2*8] =
  1200.                 h->mb.cache.ref[i_list][i8+3*8] = h->mb.ref[i_list][ir + 1*s8x8];
  1202.                 for( i = 0; i < 4; i++ )
  1203.                 {
  1204.                     h->mb.cache.mv[i_list][i8+i*8][0] = h->mb.mv[i_list][iv + i*s4x4][0];
  1205.                     h->mb.cache.mv[i_list][i8+i*8][1] = h->mb.mv[i_list][iv + i*s4x4][1];
  1206.                 }
  1207.             }
  1208.             else
  1209.             {
  1210.                 const int i8 = x264_scan8[0] - 1;
  1211.                 for( i = 0; i < 4; i++ )
  1212.                 {
  1213.                     h->mb.cache.ref[i_list][i8+i*8] = -2;
  1214.                     h->mb.cache.mv[i_list][i8+i*8][0] =
  1215.                     h->mb.cache.mv[i_list][i8+i*8][1] = 0;
  1216.                 }
  1217.             }
  1219.             if( h->param.b_cabac )
  1220.             {
  1221.                 if( i_top_type >= 0 )
  1222.                 {
  1223.                     const int i8 = x264_scan8[0] - 8;
  1224.                     const int iv = i_mb_4x4 - s4x4;
  1225.                     for( i = 0; i < 4; i++ )
  1226.                     {
  1227.                         h->mb.cache.mvd[i_list][i8+i][0] = h->mb.mvd[i_list][iv + i][0];
  1228.                         h->mb.cache.mvd[i_list][i8+i][1] = h->mb.mvd[i_list][iv + i][1];
  1229.                     }
  1230.                 }
  1231.                 else
  1232.                 {
  1233.                     const int i8 = x264_scan8[0] - 8;
  1234.                     for( i = 0; i < 4; i++ )
  1235.                     {
  1236.                         h->mb.cache.mvd[i_list][i8+i][0] =
  1237.                         h->mb.cache.mvd[i_list][i8+i][1] = 0;
  1238.                     }
  1239.                 }
  1241.                 if( i_left_type >= 0 )
  1242.                 {
  1243.                     const int i8 = x264_scan8[0] - 1;
  1244.                     const int iv = i_mb_4x4 - 1;
  1245.                     for( i = 0; i < 4; i++ )
  1246.                     {
  1247.                         h->mb.cache.mvd[i_list][i8+i*8][0] = h->mb.mvd[i_list][iv + i*s4x4][0];
  1248.                         h->mb.cache.mvd[i_list][i8+i*8][1] = h->mb.mvd[i_list][iv + i*s4x4][1];
  1249.                     }
  1250.                 }
  1251.                 else
  1252.                 {
  1253.                     const int i8 = x264_scan8[0] - 1;
  1254.                     for( i = 0; i < 4; i++ )
  1255.                     {
  1256.                         h->mb.cache.mvd[i_list][i8+i*8][0] =
  1257.                         h->mb.cache.mvd[i_list][i8+i*8][1] = 0;
  1258.                     }
  1259.                 }
  1260.             }
  1261.         }
  1263.         /* load skip */
  1264.         if( h->sh.i_type == SLICE_TYPE_B && h->param.b_cabac )
  1265.         {
  1266.             memset( h->mb.cache.skip, 0, X264_SCAN8_SIZE * sizeof( int8_t ) );
  1267.             if( i_left_type >= 0 )
  1268.             {
  1269.                 h->mb.cache.skip[x264_scan8[0] - 1] = h->mb.skipbp[i_left_xy] & 0x2;
  1270.                 h->mb.cache.skip[x264_scan8[8] - 1] = h->mb.skipbp[i_left_xy] & 0x8;
  1271.             }
  1272.             if( i_top_type >= 0 )
  1273.             {
  1274.                 h->mb.cache.skip[x264_scan8[0] - 8] = h->mb.skipbp[i_top_xy] & 0x4;
  1275.                 h->mb.cache.skip[x264_scan8[4] - 8] = h->mb.skipbp[i_top_xy] & 0x8;
  1276.             }
  1277.         }
  1278.     }
  1280.     h->mb.i_neighbour4[0] =
  1281.     h->mb.i_neighbour8[0] = (h->mb.i_neighbour & (MB_TOP|MB_LEFT|MB_TOPLEFT))
  1282.                             | ((h->mb.i_neighbour & MB_TOP) ? MB_TOPRIGHT : 0);
  1283.     h->mb.i_neighbour4[4] =
  1284.     h->mb.i_neighbour4[1] = MB_LEFT | ((h->mb.i_neighbour & MB_TOP) ? (MB_TOP|MB_TOPLEFT|MB_TOPRIGHT) : 0);
  1285.     h->mb.i_neighbour4[2] =
  1286.     h->mb.i_neighbour4[8] =
  1287.     h->mb.i_neighbour4[10] =
  1288.     h->mb.i_neighbour8[2] = MB_TOP|MB_TOPRIGHT | ((h->mb.i_neighbour & MB_LEFT) ? (MB_LEFT|MB_TOPLEFT) : 0);
  1289.     h->mb.i_neighbour4[3] =
  1290.     h->mb.i_neighbour4[7] =
  1291.     h->mb.i_neighbour4[11] =
  1292.     h->mb.i_neighbour4[13] =
  1293.     h->mb.i_neighbour4[15] =
  1294.     h->mb.i_neighbour8[3] = MB_LEFT|MB_TOP|MB_TOPLEFT;
  1295.     h->mb.i_neighbour4[5] =
  1296.     h->mb.i_neighbour8[1] = MB_LEFT | (h->mb.i_neighbour & MB_TOPRIGHT)
  1297.                             | ((h->mb.i_neighbour & MB_TOP) ? MB_TOP|MB_TOPLEFT : 0);
  1298.     h->mb.i_neighbour4[6] =
  1299.     h->mb.i_neighbour4[9] =
  1300.     h->mb.i_neighbour4[12] =
  1301.     h->mb.i_neighbour4[14] = MB_LEFT|MB_TOP|MB_TOPLEFT|MB_TOPRIGHT;
  1302. }
  1304. void x264_macroblock_cache_save( x264_t *h )
  1305. {
  1306.     const int i_mb_xy = h->mb.i_mb_xy;
  1307.     const int i_mb_type = x264_mb_type_fix[h->mb.i_type];
  1308.     const int s8x8 = h->mb.i_b8_stride;
  1309.     const int s4x4 = h->mb.i_b4_stride;
  1310.     const int i_mb_4x4 = h->mb.i_b4_xy;
  1311.     const int i_mb_8x8 = h->mb.i_b8_xy;
  1313.     int i;
  1315.     for( i = 0; i < 3; i++ )
  1316.     {
  1317.         int w = i ? 8 : 16;
  1318.         h->mc.copy[i?PIXEL_8x8:PIXEL_16x16](
  1319.             &h->fdec->plane[i][ w * (h->mb.i_mb_x + h->mb.i_mb_y * h->fdec->i_stride[i]) ],
  1320.             h->fdec->i_stride[i],
  1321.             h->mb.pic.p_fdec[i], FDEC_STRIDE, w );
  1322.     }
  1324.     h->mb.type[i_mb_xy] = i_mb_type;
  1326.     if( h->mb.i_type != I_16x16 && h->mb.i_cbp_luma == 0 && h->mb.i_cbp_chroma == 0 )
  1327.         h->mb.i_qp = h->mb.i_last_qp;
  1328.     h->mb.qp[i_mb_xy] = h->mb.i_qp;
  1330.     h->mb.i_last_dqp = h->mb.i_qp - h->mb.i_last_qp;
  1331.     h->mb.i_last_qp = h->mb.i_qp;
  1333.     /* save intra4x4 */
  1334.     if( i_mb_type == I_4x4 )
  1335.     {
  1336.         h->mb.intra4x4_pred_mode[i_mb_xy][0] = h->mb.cache.intra4x4_pred_mode[x264_scan8[10] ];
  1337.         h->mb.intra4x4_pred_mode[i_mb_xy][1] = h->mb.cache.intra4x4_pred_mode[x264_scan8[11] ];
  1338.         h->mb.intra4x4_pred_mode[i_mb_xy][2] = h->mb.cache.intra4x4_pred_mode[x264_scan8[14] ];
  1339.         h->mb.intra4x4_pred_mode[i_mb_xy][3] = h->mb.cache.intra4x4_pred_mode[x264_scan8[15] ];
  1340.         h->mb.intra4x4_pred_mode[i_mb_xy][4] = h->mb.cache.intra4x4_pred_mode[x264_scan8[5] ];
  1341.         h->mb.intra4x4_pred_mode[i_mb_xy][5] = h->mb.cache.intra4x4_pred_mode[x264_scan8[7] ];
  1342.         h->mb.intra4x4_pred_mode[i_mb_xy][6] = h->mb.cache.intra4x4_pred_mode[x264_scan8[13] ];
  1343.     }
  1344.     else
  1345.     {
  1346.         h->mb.intra4x4_pred_mode[i_mb_xy][0] =
  1347.         h->mb.intra4x4_pred_mode[i_mb_xy][1] =
  1348.         h->mb.intra4x4_pred_mode[i_mb_xy][2] =
  1349.         h->mb.intra4x4_pred_mode[i_mb_xy][3] =
  1350.         h->mb.intra4x4_pred_mode[i_mb_xy][4] =
  1351.         h->mb.intra4x4_pred_mode[i_mb_xy][5] =
  1352.         h->mb.intra4x4_pred_mode[i_mb_xy][6] = I_PRED_4x4_DC;
  1353.     }
  1355.     if( i_mb_type == I_PCM )
  1356.     {
  1357.         h->mb.cbp[i_mb_xy] = 0x72f;   /* all set */
  1358.         for( i = 0; i < 16 + 2*4; i++ )
  1359.         {
  1360.             h->mb.non_zero_count[i_mb_xy][i] = 16;
  1361.         }
  1362.     }
  1363.     else
  1364.     {
  1365.         /* save non zero count */
  1366.         for( i = 0; i < 16 + 2*4; i++ )
  1367.         {
  1368.             h->mb.non_zero_count[i_mb_xy][i] = h->mb.cache.non_zero_count[x264_scan8[i]];
  1369.         }
  1370.     }
  1372.     if( h->mb.i_cbp_luma == 0 && h->mb.i_type != I_8x8 )
  1373.         h->mb.b_transform_8x8 = 0;
  1374.     h->mb.mb_transform_size[i_mb_xy] = h->mb.b_transform_8x8;
  1376.     if( !IS_INTRA( i_mb_type ) )
  1377.     {
  1378.         int i_list;
  1379.         for( i_list = 0; i_list < (h->sh.i_type == SLICE_TYPE_B ? 2  : 1 ); i_list++ )
  1380.         {
  1381.             int y,x;
  1383.             h->mb.ref[i_list][i_mb_8x8+0+0*s8x8] = h->mb.cache.ref[i_list][x264_scan8[0]];
  1384.             h->mb.ref[i_list][i_mb_8x8+1+0*s8x8] = h->mb.cache.ref[i_list][x264_scan8[4]];
  1385.             h->mb.ref[i_list][i_mb_8x8+0+1*s8x8] = h->mb.cache.ref[i_list][x264_scan8[8]];
  1386.             h->mb.ref[i_list][i_mb_8x8+1+1*s8x8] = h->mb.cache.ref[i_list][x264_scan8[12]];
  1388.             for( y = 0; y < 4; y++ )
  1389.             {
  1390.                 for( x = 0; x < 4; x++ )
  1391.                 {
  1392.                     h->mb.mv[i_list][i_mb_4x4+x+y*s4x4][0] = h->mb.cache.mv[i_list][x264_scan8[0]+x+8*y][0];
  1393.                     h->mb.mv[i_list][i_mb_4x4+x+y*s4x4][1] = h->mb.cache.mv[i_list][x264_scan8[0]+x+8*y][1];
  1394.                 }
  1395.             }
  1396.         }
  1397.     }
  1398.     else
  1399.     {
  1400.         int i_list;
  1401.         for( i_list = 0; i_list < (h->sh.i_type == SLICE_TYPE_B ? 2  : 1 ); i_list++ )
  1402.         {
  1403.             int y,x;
  1405.             h->mb.ref[i_list][i_mb_8x8+0+0*s8x8] =
  1406.             h->mb.ref[i_list][i_mb_8x8+1+0*s8x8] =
  1407.             h->mb.ref[i_list][i_mb_8x8+0+1*s8x8] =
  1408.             h->mb.ref[i_list][i_mb_8x8+1+1*s8x8] = -1;
  1410.             for( y = 0; y < 4; y++ )
  1411.             {
  1412.                 for( x = 0; x < 4; x++ )
  1413.                 {
  1414.                     h->mb.mv[i_list][i_mb_4x4+x+y*s4x4][0] = 0;
  1415.                     h->mb.mv[i_list][i_mb_4x4+x+y*s4x4][1] = 0;
  1416.                 }
  1417.             }
  1418.         }
  1419.     }
  1421.     if( h->param.b_cabac )
  1422.     {
  1423.         if( i_mb_type == I_4x4 || i_mb_type == I_16x16 )
  1424.             h->mb.chroma_pred_mode[i_mb_xy] = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
  1425.         else
  1426.             h->mb.chroma_pred_mode[i_mb_xy] = I_PRED_CHROMA_DC;
  1428.         if( !IS_INTRA( i_mb_type ) && !IS_SKIP( i_mb_type ) && !IS_DIRECT( i_mb_type ) )
  1429.         {
  1430.             int i_list;
  1431.             for( i_list  = 0; i_list < 2; i_list++ )
  1432.             {
  1433.                 const int s4x4 = 4 * h->mb.i_mb_stride;
  1434.                 int y,x;
  1435.                 for( y = 0; y < 4; y++ )
  1436.                 {
  1437.                     for( x = 0; x < 4; x++ )
  1438.                     {
  1439.                         h->mb.mvd[i_list][i_mb_4x4+x+y*s4x4][0] = h->mb.cache.mvd[i_list][x264_scan8[0]+x+8*y][0];
  1440.                         h->mb.mvd[i_list][i_mb_4x4+x+y*s4x4][1] = h->mb.cache.mvd[i_list][x264_scan8[0]+x+8*y][1];
  1441.                     }
  1442.                 }
  1443.             }
  1444.         }
  1445.         else
  1446.         {
  1447.             int i_list;
  1448.             for( i_list  = 0; i_list < 2; i_list++ )
  1449.             {
  1450.                 const int s4x4 = 4 * h->mb.i_mb_stride;
  1451.                 int y,x;
  1452.                 for( y = 0; y < 4; y++ )
  1453.                 {
  1454.                     for( x = 0; x < 4; x++ )
  1455.                     {
  1456.                         h->mb.mvd[i_list][i_mb_4x4+x+y*s4x4][0] = 0;
  1457.                         h->mb.mvd[i_list][i_mb_4x4+x+y*s4x4][1] = 0;
  1458.                     }
  1459.                 }
  1460.             }
  1461.         }
  1462.         if( h->sh.i_type == SLICE_TYPE_B )
  1463.         {
  1464.             if( i_mb_type == B_SKIP || i_mb_type == B_DIRECT )
  1465.                 h->mb.skipbp[i_mb_xy] = 0xf;
  1466.             else if( i_mb_type == B_8x8 )
  1467.             {
  1468.                 int skipbp = 0;
  1469.                 for( i = 0; i < 4; i++ )
  1470.                     skipbp |= ( h->mb.i_sub_partition[i] == D_DIRECT_8x8 ) << i;
  1471.                 h->mb.skipbp[i_mb_xy] = skipbp;
  1472.             }
  1473.             else
  1474.                 h->mb.skipbp[i_mb_xy] = 0;
  1475.         }
  1476.     }
  1477. }
  1479. void x264_macroblock_bipred_init( x264_t *h )
  1480. {
  1481.     int i_ref0, i_ref1;
  1482.     for( i_ref0 = 0; i_ref0 < h->i_ref0; i_ref0++ )
  1483.     {
  1484.         int poc0 = h->fref0[i_ref0]->i_poc;
  1485.         for( i_ref1 = 0; i_ref1 < h->i_ref1; i_ref1++ )
  1486.         {
  1487.             int dist_scale_factor;
  1488.             int poc1 = h->fref1[i_ref1]->i_poc;
  1489.             int td = x264_clip3( poc1 - poc0, -128, 127 );
  1490.             if( td == 0 /* || pic0 is a long-term ref */ )
  1491.                 dist_scale_factor = 256;
  1492.             else
  1493.             {
  1494.                 int tb = x264_clip3( h->fdec->i_poc - poc0, -128, 127 );
  1495.                 int tx = (16384 + (abs(td) >> 1)) / td;
  1496.                 dist_scale_factor = x264_clip3( (tb * tx + 32) >> 6, -1024, 1023 );
  1497.             }
  1498.             h->mb.dist_scale_factor[i_ref0][i_ref1] = dist_scale_factor;
  1500.             dist_scale_factor >>= 2;
  1501.             if( h->param.analyse.b_weighted_bipred
  1502.                   && dist_scale_factor >= -64
  1503.                   && dist_scale_factor <= 128 )
  1504.                 h->mb.bipred_weight[i_ref0][i_ref1] = 64 - dist_scale_factor;
  1505.             else
  1506.                 h->mb.bipred_weight[i_ref0][i_ref1] = 32;
  1507.         }
  1508.     }
  1509. }