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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
analyse.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：119k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

analyse.c：源码内容
  1. /*****************************************************************************
  2.  * analyse.c: h264 encoder library
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  7.  *          Loren Merritt <lorenm@u.washington.edu>
  8.  *          Jason Garrett-Glaser <darkshikari@gmail.com>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. #define _ISOC99_SOURCE
  26. #include <math.h>
  27. //配置MS VC环境 --@lia
  28. #ifndef _MSC_VER
  29. #include <unistd.h>
  30. #endif
  32. #include "common/common.h"
  33. #include "common/cpu.h"
  34. #include "macroblock.h"
  35. #include "me.h"
  36. #include "ratecontrol.h"
  37. #include "analyse.h"
  38. #include "rdo.c"
  40. //配置MS VC环境 --@lia
  41. #ifdef _MSC_VER
  42. #define log2f(x)     ((float)log((double)(x)))/(log((double)2))
  43. #endif
  45. typedef struct
  46. {
  47.     /* 16x16 */
  48.     int i_ref;
  49.     int       i_rd16x16;
  50.     x264_me_t me16x16;
  52.     /* 8x8 */
  53.     int       i_cost8x8;
  54.     /* [ref][0] is 16x16 mv, [ref][1..4] are 8x8 mv from partition [0..3] */
  55.     ALIGNED_4( int16_t mvc[32][5][2] );
  56.     x264_me_t me8x8[4];
  58.     /* Sub 4x4 */
  59.     int       i_cost4x4[4]; /* cost per 8x8 partition */
  60.     x264_me_t me4x4[4][4];
  62.     /* Sub 8x4 */
  63.     int       i_cost8x4[4]; /* cost per 8x8 partition */
  64.     x264_me_t me8x4[4][2];
  66.     /* Sub 4x8 */
  67.     int       i_cost4x8[4]; /* cost per 8x8 partition */
  68.     x264_me_t me4x8[4][2];
  70.     /* 16x8 */
  71.     int       i_cost16x8;
  72.     x264_me_t me16x8[2];
  74.     /* 8x16 */
  75.     int       i_cost8x16;
  76.     x264_me_t me8x16[2];
  78. } x264_mb_analysis_list_t;
  80. typedef struct
  81. {
  82.     /* conduct the analysis using this lamda and QP */
  83.     int i_lambda;
  84.     int i_lambda2;
  85.     int i_qp;
  86.     uint16_t *p_cost_mv;
  87.     uint16_t *p_cost_ref0;
  88.     uint16_t *p_cost_ref1;
  89.     int i_mbrd;
  92.     /* I: Intra part */
  93.     /* Take some shortcuts in intra search if intra is deemed unlikely */
  94.     int b_fast_intra;
  95.     int b_try_pskip;
  97.     /* Luma part */
  98.     int i_satd_i16x16;
  99.     int i_satd_i16x16_dir[7];
  100.     int i_predict16x16;
  102.     int i_satd_i8x8;
  103.     int i_cbp_i8x8_luma;
  104.     int i_satd_i8x8_dir[12][4];
  105.     int i_predict8x8[4];
  107.     int i_satd_i4x4;
  108.     int i_predict4x4[16];
  110.     int i_satd_pcm;
  112.     /* Chroma part */
  113.     int i_satd_i8x8chroma;
  114.     int i_satd_i8x8chroma_dir[4];
  115.     int i_predict8x8chroma;
  117.     /* II: Inter part P/B frame */
  118.     x264_mb_analysis_list_t l0;
  119.     x264_mb_analysis_list_t l1;
  121.     int i_cost16x16bi; /* used the same ref and mv as l0 and l1 (at least for now) */
  122.     int i_cost16x16direct;
  123.     int i_cost8x8bi;
  124.     int i_cost8x8direct[4];
  125.     int i_cost16x8bi;
  126.     int i_cost8x16bi;
  127.     int i_rd16x16bi;
  128.     int i_rd16x16direct;
  129.     int i_rd16x8bi;
  130.     int i_rd8x16bi;
  131.     int i_rd8x8bi;
  133.     int i_mb_partition16x8[2]; /* mb_partition_e */
  134.     int i_mb_partition8x16[2];
  135.     int i_mb_type16x8; /* mb_class_e */
  136.     int i_mb_type8x16;
  138.     int b_direct_available;
  140. } x264_mb_analysis_t;
  142. /* lambda = pow(2,qp/6-2) */
  143. const int x264_lambda_tab[52] = {
  144.    1, 1, 1, 1, 1, 1, 1, 1,  /*  0-7 */
  145.    1, 1, 1, 1,              /*  8-11 */
  146.    1, 1, 1, 1, 2, 2, 2, 2,  /* 12-19 */
  147.    3, 3, 3, 4, 4, 4, 5, 6,  /* 20-27 */
  148.    6, 7, 8, 9,10,11,13,14,  /* 28-35 */
  149.   16,18,20,23,25,29,32,36,  /* 36-43 */
  150.   40,45,51,57,64,72,81,91   /* 44-51 */
  151. };
  153. /* lambda2 = pow(lambda,2) * .9 * 256 */
  154. const int x264_lambda2_tab[52] = {
  155.     14,      18,      22,      28,     36,     45,     57,     72, /*  0 -  7 */
  156.     91,     115,     145,     182,    230,    290,    365,    460, /*  8 - 15 */
  157.    580,     731,     921,    1161,   1462,   1843,   2322,   2925, /* 16 - 23 */
  158.   3686,    4644,    5851,    7372,   9289,  11703,  14745,  18578, /* 24 - 31 */
  159.  23407,   29491,   37156,   46814,  58982,  74313,  93628, 117964, /* 32 - 39 */
  160. 148626,  187257,  235929,  297252, 374514, 471859, 594505, 749029, /* 40 - 47 */
  161. 943718, 1189010, 1498059, 1887436                                  /* 48 - 51 */
  162. };
  164. const uint8_t x264_exp2_lut[64] = {
  165.       1,   4,   7,  10,  13,  16,  19,  22,  25,  28,  31,  34,  37,  40,  44,  47,
  166.      50,  53,  57,  60,  64,  67,  71,  74,  78,  81,  85,  89,  93,  96, 100, 104,
  167.     108, 112, 116, 120, 124, 128, 132, 137, 141, 145, 150, 154, 159, 163, 168, 172,
  168.     177, 182, 186, 191, 196, 201, 206, 211, 216, 221, 226, 232, 237, 242, 248, 253,
  169. };
  171. const float x264_log2_lut[128] = {
  172.     0.00000, 0.01123, 0.02237, 0.03342, 0.04439, 0.05528, 0.06609, 0.07682,
  173.     0.08746, 0.09803, 0.10852, 0.11894, 0.12928, 0.13955, 0.14975, 0.15987,
  174.     0.16993, 0.17991, 0.18982, 0.19967, 0.20945, 0.21917, 0.22882, 0.23840,
  175.     0.24793, 0.25739, 0.26679, 0.27612, 0.28540, 0.29462, 0.30378, 0.31288,
  176.     0.32193, 0.33092, 0.33985, 0.34873, 0.35755, 0.36632, 0.37504, 0.38370,
  177.     0.39232, 0.40088, 0.40939, 0.41785, 0.42626, 0.43463, 0.44294, 0.45121,
  178.     0.45943, 0.46761, 0.47573, 0.48382, 0.49185, 0.49985, 0.50779, 0.51570,
  179.     0.52356, 0.53138, 0.53916, 0.54689, 0.55459, 0.56224, 0.56986, 0.57743,
  180.     0.58496, 0.59246, 0.59991, 0.60733, 0.61471, 0.62205, 0.62936, 0.63662,
  181.     0.64386, 0.65105, 0.65821, 0.66534, 0.67243, 0.67948, 0.68650, 0.69349,
  182.     0.70044, 0.70736, 0.71425, 0.72110, 0.72792, 0.73471, 0.74147, 0.74819,
  183.     0.75489, 0.76155, 0.76818, 0.77479, 0.78136, 0.78790, 0.79442, 0.80090,
  184.     0.80735, 0.81378, 0.82018, 0.82655, 0.83289, 0.83920, 0.84549, 0.85175,
  185.     0.85798, 0.86419, 0.87036, 0.87652, 0.88264, 0.88874, 0.89482, 0.90087,
  186.     0.90689, 0.91289, 0.91886, 0.92481, 0.93074, 0.93664, 0.94251, 0.94837,
  187.     0.95420, 0.96000, 0.96578, 0.97154, 0.97728, 0.98299, 0.98868, 0.99435,
  188. };
  190. /* Avoid an int/float conversion. */
  191. const float x264_log2_lz_lut[32] = {
  192.     31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
  193. };
  195. // should the intra and inter lambdas be different?
  196. // I'm just matching the behaviour of deadzone quant.
  197. static const int x264_trellis_lambda2_tab[2][52] = {
  198.     // inter lambda = .85 * .85 * 2**(qp/3. + 10 - LAMBDA_BITS)
  199.     {    46,      58,      73,      92,     117,     147,
  200.         185,     233,     294,     370,     466,     587,
  201.         740,     932,    1174,    1480,    1864,    2349,
  202.        2959,    3728,    4697,    5918,    7457,    9395,
  203.       11837,   14914,   18790,   23674,   29828,   37581,
  204.       47349,   59656,   75163,   94699,  119313,  150326,
  205.      189399,  238627,  300652,  378798,  477255,  601304,
  206.      757596,  954511, 1202608, 1515192, 1909022, 2405217,
  207.     3030384, 3818045, 4810435, 6060769 },
  208.     // intra lambda = .65 * .65 * 2**(qp/3. + 10 - LAMBDA_BITS)
  209.     {    27,      34,      43,      54,      68,      86,
  210.         108,     136,     172,     216,     273,     343,
  211.         433,     545,     687,     865,    1090,    1374,
  212.        1731,    2180,    2747,    3461,    4361,    5494,
  213.        6922,    8721,   10988,   13844,   17442,   21976,
  214.       27688,   34885,   43953,   55377,   69771,   87906,
  215.      110755,  139543,  175813,  221511,  279087,  351627,
  216.      443023,  558174,  703255,  886046, 1116348, 1406511,
  217.     1772093, 2232697, 2813022, 3544186 }
  218. };
  220. static const uint16_t x264_chroma_lambda2_offset_tab[] = {
  221.        16,    20,    25,    32,    40,    50,
  222.        64,    80,   101,   128,   161,   203,
  223.       256,   322,   406,   512,   645,   812,
  224.      1024,  1290,  1625,  2048,  2580,  3250,
  225.      4096,  5160,  6501,  8192, 10321, 13003,
  226.     16384, 20642, 26007, 32768, 41285, 52015,
  227.     65535
  228. };
  230. /* TODO: calculate CABAC costs */
  231. static const int i_mb_b_cost_table[X264_MBTYPE_MAX] = {
  232.     9, 9, 9, 9, 0, 0, 0, 1, 3, 7, 7, 7, 3, 7, 7, 7, 5, 9, 0
  233. };
  234. static const int i_mb_b16x8_cost_table[17] = {
  235.     0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 7, 5, 7, 9, 9, 9
  236. };
  237. static const int i_sub_mb_b_cost_table[13] = {
  238.     7, 5, 5, 3, 7, 5, 7, 3, 7, 7, 7, 5, 1
  239. };
  240. static const int i_sub_mb_p_cost_table[4] = {
  241.     5, 3, 3, 1
  242. };
  244. static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a );
  246. static uint16_t x264_cost_ref[92][3][33];
  247. static x264_pthread_mutex_t cost_ref_mutex = X264_PTHREAD_MUTEX_INITIALIZER;
  249. int x264_analyse_init_costs( x264_t *h, int qp )
  250. {
  251.     int i, j;
  252.     int lambda = x264_lambda_tab[qp];
  253.     if( h->cost_mv[lambda] )
  254.         return 0;
  255.     /* factor of 4 from qpel, 2 from sign, and 2 because mv can be opposite from mvp */
  256.     CHECKED_MALLOC( h->cost_mv[lambda], (4*4*2048 + 1) * sizeof(uint16_t) );
  257.     h->cost_mv[lambda] += 2*4*2048;
  258.     for( i = 0; i <= 2*4*2048; i++ )
  259.     {
  260.         h->cost_mv[lambda][-i] =
  261.         h->cost_mv[lambda][i]  = lambda * (log2f(i+1)*2 + 0.718f + !!i) + .5f;
  262.     }
  263.     x264_pthread_mutex_lock( &cost_ref_mutex );
  264.     for( i = 0; i < 3; i++ )
  265.         for( j = 0; j < 33; j++ )
  266.             x264_cost_ref[lambda][i][j] = i ? lambda * bs_size_te( i, j ) : 0;
  267.     x264_pthread_mutex_unlock( &cost_ref_mutex );
  268.     if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[lambda][0] )
  269.     {
  270.         for( j=0; j<4; j++ )
  271.         {
  272.             CHECKED_MALLOC( h->cost_mv_fpel[lambda][j], (4*2048 + 1) * sizeof(uint16_t) );
  273.             h->cost_mv_fpel[lambda][j] += 2*2048;
  274.             for( i = -2*2048; i < 2*2048; i++ )
  275.                 h->cost_mv_fpel[lambda][j][i] = h->cost_mv[lambda][i*4+j];
  276.         }
  277.     }
  278.     return 0;
  279. fail:
  280.     return -1;
  281. }
  283. void x264_analyse_free_costs( x264_t *h )
  284. {
  285.     int i, j;
  286.     for( i = 0; i < 92; i++ )
  287.     {
  288.         if( h->cost_mv[i] )
  289.             x264_free( h->cost_mv[i] - 2*4*2048 );
  290.         if( h->cost_mv_fpel[i][0] )
  291.             for( j = 0; j < 4; j++ )
  292.                 x264_free( h->cost_mv_fpel[i][j] - 2*2048 );
  293.     }
  294. }
  296. /* initialize an array of lambda*nbits for all possible mvs */
  297. static void x264_mb_analyse_load_costs( x264_t *h, x264_mb_analysis_t *a )
  298. {
  299.     a->p_cost_mv = h->cost_mv[a->i_lambda];
  300.     a->p_cost_ref0 = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l0_active-1,0,2)];
  301.     a->p_cost_ref1 = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l1_active-1,0,2)];
  302. }
  304. static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
  305. {
  306.     int i = h->param.analyse.i_subpel_refine - (h->sh.i_type == SLICE_TYPE_B);
  308.     /* mbrd == 1 -> RD mode decision */
  309.     /* mbrd == 2 -> RD refinement */
  310.     /* mbrd == 3 -> QPRD */
  311.     a->i_mbrd = (i>=6) + (i>=8) + (h->param.analyse.i_subpel_refine>=10);
  313.     /* conduct the analysis using this lamda and QP */
  314.     a->i_qp = h->mb.i_qp = i_qp;
  315.     h->mb.i_chroma_qp = h->chroma_qp_table[i_qp];
  317.     a->i_lambda = x264_lambda_tab[i_qp];
  318.     a->i_lambda2 = x264_lambda2_tab[i_qp];
  320.     h->mb.b_trellis = h->param.analyse.i_trellis > 1 && a->i_mbrd;
  321.     if( h->param.analyse.i_trellis )
  322.     {
  323.         h->mb.i_trellis_lambda2[0][0] = x264_trellis_lambda2_tab[0][h->mb.i_qp];
  324.         h->mb.i_trellis_lambda2[0][1] = x264_trellis_lambda2_tab[1][h->mb.i_qp];
  325.         h->mb.i_trellis_lambda2[1][0] = x264_trellis_lambda2_tab[0][h->mb.i_chroma_qp];
  326.         h->mb.i_trellis_lambda2[1][1] = x264_trellis_lambda2_tab[1][h->mb.i_chroma_qp];
  327.     }
  328.     h->mb.i_psy_rd_lambda = a->i_lambda;
  329.     /* Adjusting chroma lambda based on QP offset hurts PSNR but improves visual quality. */
  330.     h->mb.i_chroma_lambda2_offset = h->param.analyse.b_psy ? x264_chroma_lambda2_offset_tab[h->mb.i_qp-h->mb.i_chroma_qp+12] : 256;
  332.     h->mb.i_me_method = h->param.analyse.i_me_method;
  333.     h->mb.i_subpel_refine = h->param.analyse.i_subpel_refine;
  334.     h->mb.b_chroma_me = h->param.analyse.b_chroma_me && h->sh.i_type == SLICE_TYPE_P
  335.                         && h->mb.i_subpel_refine >= 5;
  337.     h->mb.b_transform_8x8 = 0;
  338.     h->mb.b_noise_reduction = 0;
  340.     /* I: Intra part */
  341.     a->i_satd_i16x16 =
  342.     a->i_satd_i8x8   =
  343.     a->i_satd_i4x4   =
  344.     a->i_satd_i8x8chroma = COST_MAX;
  346.     /* non-RD PCM decision is inaccurate (as is psy-rd), so don't do it */
  347.     a->i_satd_pcm = !h->mb.i_psy_rd && a->i_mbrd ? ((uint64_t)X264_PCM_COST*a->i_lambda2 + 128) >> 8 : COST_MAX;
  349.     a->b_fast_intra = 0;
  350.     h->mb.i_skip_intra =
  351.         h->mb.b_lossless ? 0 :
  352.         a->i_mbrd ? 2 :
  353.         !h->param.analyse.i_trellis && !h->param.analyse.i_noise_reduction;
  355.     /* II: Inter part P/B frame */
  356.     if( h->sh.i_type != SLICE_TYPE_I )
  357.     {
  358.         int i, j;
  359.         int i_fmv_range = 4 * h->param.analyse.i_mv_range;
  360.         // limit motion search to a slightly smaller range than the theoretical limit,
  361.         // since the search may go a few iterations past its given range
  362.         int i_fpel_border = 6; // umh: 1 for diamond, 2 for octagon, 2 for hpel
  364.         /* Calculate max allowed MV range */
  365. #define CLIP_FMV(mv) x264_clip3( mv, -i_fmv_range, i_fmv_range-1 )
  366.         h->mb.mv_min[0] = 4*( -16*h->mb.i_mb_x - 24 );
  367.         h->mb.mv_max[0] = 4*( 16*( h->sps->i_mb_width - h->mb.i_mb_x - 1 ) + 24 );
  368.         h->mb.mv_min_spel[0] = CLIP_FMV( h->mb.mv_min[0] );
  369.         h->mb.mv_max_spel[0] = CLIP_FMV( h->mb.mv_max[0] );
  370.         h->mb.mv_min_fpel[0] = (h->mb.mv_min_spel[0]>>2) + i_fpel_border;
  371.         h->mb.mv_max_fpel[0] = (h->mb.mv_max_spel[0]>>2) - i_fpel_border;
  372.         if( h->mb.i_mb_x == 0)
  373.         {
  374.             int mb_y = h->mb.i_mb_y >> h->sh.b_mbaff;
  375.             int mb_height = h->sps->i_mb_height >> h->sh.b_mbaff;
  376.             int thread_mvy_range = i_fmv_range;
  378.             if( h->param.i_threads > 1 )
  379.             {
  380.                 int pix_y = (h->mb.i_mb_y | h->mb.b_interlaced) * 16;
  381.                 int thresh = pix_y + h->param.analyse.i_mv_range_thread;
  382.                 for( i = (h->sh.i_type == SLICE_TYPE_B); i >= 0; i-- )
  383.                 {
  384.                     x264_frame_t **fref = i ? h->fref1 : h->fref0;
  385.                     int i_ref = i ? h->i_ref1 : h->i_ref0;
  386.                     for( j=0; j<i_ref; j++ )
  387.                     {
  388.                         x264_frame_cond_wait( fref[j], thresh );
  389.                         thread_mvy_range = X264_MIN( thread_mvy_range, fref[j]->i_lines_completed - pix_y );
  390.                     }
  391.                 }
  392.                 if( h->param.b_deterministic )
  393.                     thread_mvy_range = h->param.analyse.i_mv_range_thread;
  394.                 if( h->mb.b_interlaced )
  395.                     thread_mvy_range >>= 1;
  396.             }
  398.             h->mb.mv_min[1] = 4*( -16*mb_y - 24 );
  399.             h->mb.mv_max[1] = 4*( 16*( mb_height - mb_y - 1 ) + 24 );
  400.             h->mb.mv_min_spel[1] = x264_clip3( h->mb.mv_min[1], -i_fmv_range, i_fmv_range );
  401.             h->mb.mv_max_spel[1] = CLIP_FMV( h->mb.mv_max[1] );
  402.             h->mb.mv_max_spel[1] = X264_MIN( h->mb.mv_max_spel[1], thread_mvy_range*4 );
  403.             h->mb.mv_min_fpel[1] = (h->mb.mv_min_spel[1]>>2) + i_fpel_border;
  404.             h->mb.mv_max_fpel[1] = (h->mb.mv_max_spel[1]>>2) - i_fpel_border;
  405.         }
  406. #undef CLIP_FMV
  408.         a->l0.me16x16.cost =
  409.         a->l0.i_rd16x16    =
  410.         a->l0.i_cost8x8    = COST_MAX;
  412.         for( i = 0; i < 4; i++ )
  413.         {
  414.             a->l0.i_cost4x4[i] =
  415.             a->l0.i_cost8x4[i] =
  416.             a->l0.i_cost4x8[i] = COST_MAX;
  417.         }
  419.         a->l0.i_cost16x8   =
  420.         a->l0.i_cost8x16   = COST_MAX;
  421.         if( h->sh.i_type == SLICE_TYPE_B )
  422.         {
  423.             a->l1.me16x16.cost =
  424.             a->l1.i_rd16x16    =
  425.             a->l1.i_cost8x8    = COST_MAX;
  427.             for( i = 0; i < 4; i++ )
  428.             {
  429.                 a->l1.i_cost4x4[i] =
  430.                 a->l1.i_cost8x4[i] =
  431.                 a->l1.i_cost4x8[i] =
  432.                 a->i_cost8x8direct[i] = COST_MAX;
  433.             }
  435.             a->l1.i_cost16x8   =
  436.             a->l1.i_cost8x16   =
  437.             a->i_rd16x16bi     =
  438.             a->i_rd16x16direct =
  439.             a->i_rd8x8bi       =
  440.             a->i_rd16x8bi      =
  441.             a->i_rd8x16bi      =
  442.             a->i_cost16x16bi   =
  443.             a->i_cost16x16direct =
  444.             a->i_cost8x8bi     =
  445.             a->i_cost16x8bi    =
  446.             a->i_cost8x16bi    = COST_MAX;
  447.         }
  449.         /* Fast intra decision */
  450.         if( h->mb.i_mb_xy - h->sh.i_first_mb > 4 )
  451.         {
  452.             if(   IS_INTRA( h->mb.i_mb_type_left )
  453.                || IS_INTRA( h->mb.i_mb_type_top )
  454.                || IS_INTRA( h->mb.i_mb_type_topleft )
  455.                || IS_INTRA( h->mb.i_mb_type_topright )
  456.                || (h->sh.i_type == SLICE_TYPE_P && IS_INTRA( h->fref0[0]->mb_type[h->mb.i_mb_xy] ))
  457.                || (h->mb.i_mb_xy - h->sh.i_first_mb < 3*(h->stat.frame.i_mb_count[I_4x4] + h->stat.frame.i_mb_count[I_8x8] + h->stat.frame.i_mb_count[I_16x16])) )
  458.             { /* intra is likely */ }
  459.             else
  460.             {
  461.                 a->b_fast_intra = 1;
  462.             }
  463.         }
  464.         h->mb.b_skip_mc = 0;
  465.     }
  466. }
  470. /*
  471.  * Handle intra mb
  472.  */
  473. /* Max = 4 */
  474. static void predict_16x16_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
  475. {
  476.     int b_top = i_neighbour & MB_TOP;
  477.     int b_left = i_neighbour & MB_LEFT;
  478.     if( b_top && b_left )
  479.     {
  480.         /* top and left available */
  481.         *mode++ = I_PRED_16x16_V;
  482.         *mode++ = I_PRED_16x16_H;
  483.         *mode++ = I_PRED_16x16_DC;
  484.         *pi_count = 3;
  485.         if( i_neighbour & MB_TOPLEFT )
  486.         {
  487.             /* top left available*/
  488.             *mode++ = I_PRED_16x16_P;
  489.             *pi_count = 4;
  490.         }
  491.     }
  492.     else if( b_left )
  493.     {
  494.         /* left available*/
  495.         *mode++ = I_PRED_16x16_DC_LEFT;
  496.         *mode++ = I_PRED_16x16_H;
  497.         *pi_count = 2;
  498.     }
  499.     else if( b_top )
  500.     {
  501.         /* top available*/
  502.         *mode++ = I_PRED_16x16_DC_TOP;
  503.         *mode++ = I_PRED_16x16_V;
  504.         *pi_count = 2;
  505.     }
  506.     else
  507.     {
  508.         /* none available */
  509.         *mode = I_PRED_16x16_DC_128;
  510.         *pi_count = 1;
  511.     }
  512. }
  514. /* Max = 4 */
  515. static void predict_8x8chroma_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
  516. {
  517.     int b_top = i_neighbour & MB_TOP;
  518.     int b_left = i_neighbour & MB_LEFT;
  519.     if( b_top && b_left )
  520.     {
  521.         /* top and left available */
  522.         *mode++ = I_PRED_CHROMA_V;
  523.         *mode++ = I_PRED_CHROMA_H;
  524.         *mode++ = I_PRED_CHROMA_DC;
  525.         *pi_count = 3;
  526.         if( i_neighbour & MB_TOPLEFT )
  527.         {
  528.             /* top left available */
  529.             *mode++ = I_PRED_CHROMA_P;
  530.             *pi_count = 4;
  531.         }
  532.     }
  533.     else if( b_left )
  534.     {
  535.         /* left available*/
  536.         *mode++ = I_PRED_CHROMA_DC_LEFT;
  537.         *mode++ = I_PRED_CHROMA_H;
  538.         *pi_count = 2;
  539.     }
  540.     else if( b_top )
  541.     {
  542.         /* top available*/
  543.         *mode++ = I_PRED_CHROMA_DC_TOP;
  544.         *mode++ = I_PRED_CHROMA_V;
  545.         *pi_count = 2;
  546.     }
  547.     else
  548.     {
  549.         /* none available */
  550.         *mode = I_PRED_CHROMA_DC_128;
  551.         *pi_count = 1;
  552.     }
  553. }
  555. /* MAX = 9 */
  556. static void predict_4x4_mode_available( unsigned int i_neighbour,
  557.                                         int *mode, int *pi_count )
  558. {
  559.     int b_top = i_neighbour & MB_TOP;
  560.     int b_left = i_neighbour & MB_LEFT;
  561.     if( b_top && b_left )
  562.     {
  563.         *pi_count = 6;
  564.         *mode++ = I_PRED_4x4_DC;
  565.         *mode++ = I_PRED_4x4_H;
  566.         *mode++ = I_PRED_4x4_V;
  567.         *mode++ = I_PRED_4x4_DDL;
  568.         if( i_neighbour & MB_TOPLEFT )
  569.         {
  570.             *mode++ = I_PRED_4x4_DDR;
  571.             *mode++ = I_PRED_4x4_VR;
  572.             *mode++ = I_PRED_4x4_HD;
  573.             *pi_count += 3;
  574.         }
  575.         *mode++ = I_PRED_4x4_VL;
  576.         *mode++ = I_PRED_4x4_HU;
  577.     }
  578.     else if( b_left )
  579.     {
  580.         *mode++ = I_PRED_4x4_DC_LEFT;
  581.         *mode++ = I_PRED_4x4_H;
  582.         *mode++ = I_PRED_4x4_HU;
  583.         *pi_count = 3;
  584.     }
  585.     else if( b_top )
  586.     {
  587.         *mode++ = I_PRED_4x4_DC_TOP;
  588.         *mode++ = I_PRED_4x4_V;
  589.         *mode++ = I_PRED_4x4_DDL;
  590.         *mode++ = I_PRED_4x4_VL;
  591.         *pi_count = 4;
  592.     }
  593.     else
  594.     {
  595.         *mode++ = I_PRED_4x4_DC_128;
  596.         *pi_count = 1;
  597.     }
  598. }
  600. /* For trellis=2, we need to do this for both sizes of DCT, for trellis=1 we only need to use it on the chosen mode. */
  601. static void inline x264_psy_trellis_init( x264_t *h, int do_both_dct )
  602. {
  603.     ALIGNED_ARRAY_16( int16_t, dct8x8,[4],[8][8] );
  604.     ALIGNED_ARRAY_16( int16_t, dct4x4,[16],[4][4] );
  605.     ALIGNED_16( static uint8_t zero[16*FDEC_STRIDE] ) = {0};
  606.     int i;
  608.     if( do_both_dct || h->mb.b_transform_8x8 )
  609.     {
  610.         h->dctf.sub16x16_dct8( dct8x8, h->mb.pic.p_fenc[0], zero );
  611.         for( i = 0; i < 4; i++ )
  612.             h->zigzagf.scan_8x8( h->mb.pic.fenc_dct8[i], dct8x8[i] );
  613.     }
  614.     if( do_both_dct || !h->mb.b_transform_8x8 )
  615.     {
  616.         h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], zero );
  617.         for( i = 0; i < 16; i++ )
  618.             h->zigzagf.scan_4x4( h->mb.pic.fenc_dct4[i], dct4x4[i] );
  619.     }
  620. }
  622. /* Pre-calculate fenc satd scores for psy RD, minus DC coefficients */
  623. static inline void x264_mb_cache_fenc_satd( x264_t *h )
  624. {
  625.     ALIGNED_16( static uint8_t zero[16] ) = {0};
  626.     uint8_t *fenc;
  627.     int x, y, satd_sum = 0, sa8d_sum = 0;
  628.     if( h->param.analyse.i_trellis == 2 && h->mb.i_psy_trellis )
  629.         x264_psy_trellis_init( h, h->param.analyse.b_transform_8x8 );
  630.     if( !h->mb.i_psy_rd )
  631.         return;
  632.     for( y = 0; y < 4; y++ )
  633.         for( x = 0; x < 4; x++ )
  634.         {
  635.             fenc = h->mb.pic.p_fenc[0]+x*4+y*4*FENC_STRIDE;
  636.             h->mb.pic.fenc_satd[y][x] = h->pixf.satd[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )
  637.                                       - (h->pixf.sad[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )>>1);
  638.             satd_sum += h->mb.pic.fenc_satd[y][x];
  639.         }
  640.     for( y = 0; y < 2; y++ )
  641.         for( x = 0; x < 2; x++ )
  642.         {
  643.             fenc = h->mb.pic.p_fenc[0]+x*8+y*8*FENC_STRIDE;
  644.             h->mb.pic.fenc_sa8d[y][x] = h->pixf.sa8d[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )
  645.                                       - (h->pixf.sad[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )>>2);
  646.             sa8d_sum += h->mb.pic.fenc_sa8d[y][x];
  647.         }
  648.     h->mb.pic.fenc_satd_sum = satd_sum;
  649.     h->mb.pic.fenc_sa8d_sum = sa8d_sum;
  650. }
  652. static void x264_mb_analyse_intra_chroma( x264_t *h, x264_mb_analysis_t *a )
  653. {
  654.     int i;
  656.     int i_max;
  657.     int predict_mode[4];
  658.     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_8x8c && !h->mb.b_lossless;
  660.     uint8_t *p_dstc[2], *p_srcc[2];
  662.     if( a->i_satd_i8x8chroma < COST_MAX )
  663.         return;
  665.     /* 8x8 prediction selection for chroma */
  666.     p_dstc[0] = h->mb.pic.p_fdec[1];
  667.     p_dstc[1] = h->mb.pic.p_fdec[2];
  668.     p_srcc[0] = h->mb.pic.p_fenc[1];
  669.     p_srcc[1] = h->mb.pic.p_fenc[2];
  671.     predict_8x8chroma_mode_available( h->mb.i_neighbour_intra, predict_mode, &i_max );
  672.     a->i_satd_i8x8chroma = COST_MAX;
  673.     if( i_max == 4 && b_merged_satd )
  674.     {
  675.         int satdu[4], satdv[4];
  676.         h->pixf.intra_mbcmp_x3_8x8c( p_srcc[0], p_dstc[0], satdu );
  677.         h->pixf.intra_mbcmp_x3_8x8c( p_srcc[1], p_dstc[1], satdv );
  678.         h->predict_8x8c[I_PRED_CHROMA_P]( p_dstc[0] );
  679.         h->predict_8x8c[I_PRED_CHROMA_P]( p_dstc[1] );
  680.         satdu[I_PRED_CHROMA_P] =
  681.             h->pixf.mbcmp[PIXEL_8x8]( p_dstc[0], FDEC_STRIDE, p_srcc[0], FENC_STRIDE );
  682.         satdv[I_PRED_CHROMA_P] =
  683.             h->pixf.mbcmp[PIXEL_8x8]( p_dstc[1], FDEC_STRIDE, p_srcc[1], FENC_STRIDE );
  685.         for( i=0; i<i_max; i++ )
  686.         {
  687.             int i_mode = predict_mode[i];
  688.             int i_satd = satdu[i_mode] + satdv[i_mode]
  689.                        + a->i_lambda * bs_size_ue(i_mode);
  691.             a->i_satd_i8x8chroma_dir[i] = i_satd;
  692.             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
  693.         }
  694.     }
  695.     else
  696.     {
  697.         for( i=0; i<i_max; i++ )
  698.         {
  699.             int i_satd;
  700.             int i_mode = predict_mode[i];
  702.             /* we do the prediction */
  703.             if( h->mb.b_lossless )
  704.                 x264_predict_lossless_8x8_chroma( h, i_mode );
  705.             else
  706.             {
  707.                 h->predict_8x8c[i_mode]( p_dstc[0] );
  708.                 h->predict_8x8c[i_mode]( p_dstc[1] );
  709.             }
  711.             /* we calculate the cost */
  712.             i_satd = h->pixf.mbcmp[PIXEL_8x8]( p_dstc[0], FDEC_STRIDE,
  713.                                                p_srcc[0], FENC_STRIDE ) +
  714.                      h->pixf.mbcmp[PIXEL_8x8]( p_dstc[1], FDEC_STRIDE,
  715.                                                p_srcc[1], FENC_STRIDE ) +
  716.                      a->i_lambda * bs_size_ue( x264_mb_pred_mode8x8c_fix[i_mode] );
  718.             a->i_satd_i8x8chroma_dir[i] = i_satd;
  719.             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
  720.         }
  721.     }
  723.     h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
  724. }
  726. static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
  727. {
  728.     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
  729.     uint8_t  *p_src = h->mb.pic.p_fenc[0];
  730.     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
  732.     int i, idx;
  733.     int i_max;
  734.     int predict_mode[9];
  735.     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_16x16 && !h->mb.b_lossless;
  737.     /*---------------- Try all mode and calculate their score ---------------*/
  739.     /* 16x16 prediction selection */
  740.     predict_16x16_mode_available( h->mb.i_neighbour_intra, predict_mode, &i_max );
  742.     if( b_merged_satd && i_max == 4 )
  743.     {
  744.         h->pixf.intra_mbcmp_x3_16x16( p_src, p_dst, a->i_satd_i16x16_dir );
  745.         h->predict_16x16[I_PRED_16x16_P]( p_dst );
  746.         a->i_satd_i16x16_dir[I_PRED_16x16_P] =
  747.             h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE );
  748.         for( i=0; i<4; i++ )
  749.         {
  750.             int cost = a->i_satd_i16x16_dir[i] += a->i_lambda * bs_size_ue(i);
  751.             COPY2_IF_LT( a->i_satd_i16x16, cost, a->i_predict16x16, i );
  752.         }
  753.     }
  754.     else
  755.     {
  756.         for( i = 0; i < i_max; i++ )
  757.         {
  758.             int i_satd;
  759.             int i_mode = predict_mode[i];
  761.             if( h->mb.b_lossless )
  762.                 x264_predict_lossless_16x16( h, i_mode );
  763.             else
  764.                 h->predict_16x16[i_mode]( p_dst );
  766.             i_satd = h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE ) +
  767.                     a->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
  768.             COPY2_IF_LT( a->i_satd_i16x16, i_satd, a->i_predict16x16, i_mode );
  769.             a->i_satd_i16x16_dir[i_mode] = i_satd;
  770.         }
  771.     }
  773.     if( h->sh.i_type == SLICE_TYPE_B )
  774.         /* cavlc mb type prefix */
  775.         a->i_satd_i16x16 += a->i_lambda * i_mb_b_cost_table[I_16x16];
  776.     if( a->b_fast_intra && a->i_satd_i16x16 > 2*i_satd_inter )
  777.         return;
  779.     /* 8x8 prediction selection */
  780.     if( flags & X264_ANALYSE_I8x8 )
  781.     {
  782.         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
  783.         x264_pixel_cmp_t sa8d = (h->pixf.mbcmp[0] == h->pixf.satd[0]) ? h->pixf.sa8d[PIXEL_8x8] : h->pixf.mbcmp[PIXEL_8x8];
  784.         int i_satd_thresh = a->i_mbrd ? COST_MAX : X264_MIN( i_satd_inter, a->i_satd_i16x16 );
  785.         int i_cost = 0;
  786.         h->mb.i_cbp_luma = 0;
  787.         b_merged_satd = h->pixf.intra_mbcmp_x3_8x8 && !h->mb.b_lossless;
  789.         // FIXME some bias like in i4x4?
  790.         if( h->sh.i_type == SLICE_TYPE_B )
  791.             i_cost += a->i_lambda * i_mb_b_cost_table[I_8x8];
  793.         for( idx = 0;; idx++ )
  794.         {
  795.             int x = idx&1;
  796.             int y = idx>>1;
  797.             uint8_t *p_src_by = p_src + 8*x + 8*y*FENC_STRIDE;
  798.             uint8_t *p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
  799.             int i_best = COST_MAX;
  800.             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, 4*idx );
  802.             predict_4x4_mode_available( h->mb.i_neighbour8[idx], predict_mode, &i_max );
  803.             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
  805.             if( b_merged_satd && i_max == 9 )
  806.             {
  807.                 int satd[9];
  808.                 h->pixf.intra_mbcmp_x3_8x8( p_src_by, edge, satd );
  809.                 satd[i_pred_mode] -= 3 * a->i_lambda;
  810.                 for( i=2; i>=0; i-- )
  811.                 {
  812.                     int cost = a->i_satd_i8x8_dir[i][idx] = satd[i] + 4 * a->i_lambda;
  813.                     COPY2_IF_LT( i_best, cost, a->i_predict8x8[idx], i );
  814.                 }
  815.                 i = 3;
  816.             }
  817.             else
  818.                 i = 0;
  820.             for( ; i<i_max; i++ )
  821.             {
  822.                 int i_satd;
  823.                 int i_mode = predict_mode[i];
  825.                 if( h->mb.b_lossless )
  826.                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
  827.                 else
  828.                     h->predict_8x8[i_mode]( p_dst_by, edge );
  830.                 i_satd = sa8d( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE )
  831.                        + a->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
  833.                 COPY2_IF_LT( i_best, i_satd, a->i_predict8x8[idx], i_mode );
  834.                 a->i_satd_i8x8_dir[i_mode][idx] = i_satd;
  835.             }
  836.             i_cost += i_best;
  838.             if( idx == 3 || i_cost > i_satd_thresh )
  839.                 break;
  841.             /* we need to encode this block now (for next ones) */
  842.             h->predict_8x8[a->i_predict8x8[idx]]( p_dst_by, edge );
  843.             x264_mb_encode_i8x8( h, idx, a->i_qp );
  845.             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
  846.         }
  848.         if( idx == 3 )
  849.         {
  850.             a->i_satd_i8x8 = i_cost;
  851.             if( h->mb.i_skip_intra )
  852.             {
  853.                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i8x8_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
  854.                 h->mb.pic.i8x8_nnz_buf[0] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]];
  855.                 h->mb.pic.i8x8_nnz_buf[1] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]];
  856.                 h->mb.pic.i8x8_nnz_buf[2] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]];
  857.                 h->mb.pic.i8x8_nnz_buf[3] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]];
  858.                 h->mb.pic.i8x8_cbp = h->mb.i_cbp_luma;
  859.                 if( h->mb.i_skip_intra == 2 )
  860.                     h->mc.memcpy_aligned( h->mb.pic.i8x8_dct_buf, h->dct.luma8x8, sizeof(h->mb.pic.i8x8_dct_buf) );
  861.             }
  862.         }
  863.         else
  864.         {
  865.             static const uint16_t cost_div_fix8[3] = {1024,512,341};
  866.             a->i_satd_i8x8 = COST_MAX;
  867.             i_cost = (i_cost * cost_div_fix8[idx]) >> 8;
  868.         }
  869.         if( X264_MIN(i_cost, a->i_satd_i16x16) > i_satd_inter*(5+!!a->i_mbrd)/4 )
  870.             return;
  871.     }
  873.     /* 4x4 prediction selection */
  874.     if( flags & X264_ANALYSE_I4x4 )
  875.     {
  876.         int i_cost;
  877.         int i_satd_thresh = X264_MIN3( i_satd_inter, a->i_satd_i16x16, a->i_satd_i8x8 );
  878.         h->mb.i_cbp_luma = 0;
  879.         b_merged_satd = h->pixf.intra_mbcmp_x3_4x4 && !h->mb.b_lossless;
  880.         if( a->i_mbrd )
  881.             i_satd_thresh = i_satd_thresh * (10-a->b_fast_intra)/8;
  883.         i_cost = a->i_lambda * 24;    /* from JVT (SATD0) */
  884.         if( h->sh.i_type == SLICE_TYPE_B )
  885.             i_cost += a->i_lambda * i_mb_b_cost_table[I_4x4];
  887.         for( idx = 0;; idx++ )
  888.         {
  889.             uint8_t *p_src_by = p_src + block_idx_xy_fenc[idx];
  890.             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
  891.             int i_best = COST_MAX;
  892.             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, idx );
  894.             predict_4x4_mode_available( h->mb.i_neighbour4[idx], predict_mode, &i_max );
  896.             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
  897.                 /* emulate missing topright samples */
  898.                 *(uint32_t*) &p_dst_by[4 - FDEC_STRIDE] = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
  900.             if( b_merged_satd && i_max >= 6 )
  901.             {
  902.                 int satd[9];
  903.                 h->pixf.intra_mbcmp_x3_4x4( p_src_by, p_dst_by, satd );
  904.                 satd[i_pred_mode] -= 3 * a->i_lambda;
  905.                 for( i=2; i>=0; i-- )
  906.                     COPY2_IF_LT( i_best, satd[i] + 4 * a->i_lambda,
  907.                                  a->i_predict4x4[idx], i );
  908.                 i = 3;
  909.             }
  910.             else
  911.                 i = 0;
  913.             for( ; i<i_max; i++ )
  914.             {
  915.                 int i_satd;
  916.                 int i_mode = predict_mode[i];
  917.                 if( h->mb.b_lossless )
  918.                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
  919.                 else
  920.                     h->predict_4x4[i_mode]( p_dst_by );
  922.                 i_satd = h->pixf.mbcmp[PIXEL_4x4]( p_dst_by, FDEC_STRIDE,
  923.                                                    p_src_by, FENC_STRIDE )
  924.                        + a->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
  926.                 COPY2_IF_LT( i_best, i_satd, a->i_predict4x4[idx], i_mode );
  927.             }
  928.             i_cost += i_best;
  930.             if( i_cost > i_satd_thresh || idx == 15 )
  931.                 break;
  933.             /* we need to encode this block now (for next ones) */
  934.             h->predict_4x4[a->i_predict4x4[idx]]( p_dst_by );
  935.             x264_mb_encode_i4x4( h, idx, a->i_qp );
  937.             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
  938.         }
  939.         if( idx == 15 )
  940.         {
  941.             a->i_satd_i4x4 = i_cost;
  942.             if( h->mb.i_skip_intra )
  943.             {
  944.                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i4x4_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
  945.                 h->mb.pic.i4x4_nnz_buf[0] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 0]];
  946.                 h->mb.pic.i4x4_nnz_buf[1] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 2]];
  947.                 h->mb.pic.i4x4_nnz_buf[2] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[ 8]];
  948.                 h->mb.pic.i4x4_nnz_buf[3] = *(uint32_t*)&h->mb.cache.non_zero_count[x264_scan8[10]];
  949.                 h->mb.pic.i4x4_cbp = h->mb.i_cbp_luma;
  950.                 if( h->mb.i_skip_intra == 2 )
  951.                     h->mc.memcpy_aligned( h->mb.pic.i4x4_dct_buf, h->dct.luma4x4, sizeof(h->mb.pic.i4x4_dct_buf) );
  952.             }
  953.         }
  954.         else
  955.             a->i_satd_i4x4 = COST_MAX;
  956.     }
  957. }
  959. static void x264_intra_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_thresh )
  960. {
  961.     if( a->i_satd_i16x16 <= i_satd_thresh )
  962.     {
  963.         h->mb.i_type = I_16x16;
  964.         x264_analyse_update_cache( h, a );
  965.         a->i_satd_i16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  966.     }
  967.     else
  968.         a->i_satd_i16x16 = COST_MAX;
  970.     if( a->i_satd_i4x4 <= i_satd_thresh && a->i_satd_i4x4 < COST_MAX )
  971.     {
  972.         h->mb.i_type = I_4x4;
  973.         x264_analyse_update_cache( h, a );
  974.         a->i_satd_i4x4 = x264_rd_cost_mb( h, a->i_lambda2 );
  975.     }
  976.     else
  977.         a->i_satd_i4x4 = COST_MAX;
  979.     if( a->i_satd_i8x8 <= i_satd_thresh && a->i_satd_i8x8 < COST_MAX )
  980.     {
  981.         h->mb.i_type = I_8x8;
  982.         x264_analyse_update_cache( h, a );
  983.         a->i_satd_i8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
  984.         a->i_cbp_i8x8_luma = h->mb.i_cbp_luma;
  985.     }
  986.     else
  987.         a->i_satd_i8x8 = COST_MAX;
  988. }
  990. static void x264_intra_rd_refine( x264_t *h, x264_mb_analysis_t *a )
  991. {
  992.     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
  994.     int i, j, idx, x, y;
  995.     int i_max, i_mode, i_thresh;
  996.     uint64_t i_satd, i_best;
  997.     int predict_mode[9];
  998.     h->mb.i_skip_intra = 0;
  1000.     if( h->mb.i_type == I_16x16 )
  1001.     {
  1002.         int old_pred_mode = a->i_predict16x16;
  1003.         i_thresh = a->i_satd_i16x16_dir[old_pred_mode] * 9/8;
  1004.         i_best = a->i_satd_i16x16;
  1005.         predict_16x16_mode_available( h->mb.i_neighbour_intra, predict_mode, &i_max );
  1006.         for( i = 0; i < i_max; i++ )
  1007.         {
  1008.             int i_mode = predict_mode[i];
  1009.             if( i_mode == old_pred_mode || a->i_satd_i16x16_dir[i_mode] > i_thresh )
  1010.                 continue;
  1011.             h->mb.i_intra16x16_pred_mode = i_mode;
  1012.             i_satd = x264_rd_cost_mb( h, a->i_lambda2 );
  1013.             COPY2_IF_LT( i_best, i_satd, a->i_predict16x16, i_mode );
  1014.         }
  1015.     }
  1017.     /* RD selection for chroma prediction */
  1018.     predict_8x8chroma_mode_available( h->mb.i_neighbour_intra, predict_mode, &i_max );
  1019.     if( i_max > 1 )
  1020.     {
  1021.         i_thresh = a->i_satd_i8x8chroma * 5/4;
  1023.         for( i = j = 0; i < i_max; i++ )
  1024.             if( a->i_satd_i8x8chroma_dir[i] < i_thresh &&
  1025.                 predict_mode[i] != a->i_predict8x8chroma )
  1026.             {
  1027.                 predict_mode[j++] = predict_mode[i];
  1028.             }
  1029.         i_max = j;
  1031.         if( i_max > 0 )
  1032.         {
  1033.             int i_cbp_chroma_best = h->mb.i_cbp_chroma;
  1034.             int i_chroma_lambda = x264_lambda2_tab[h->mb.i_chroma_qp];
  1035.             /* the previous thing encoded was x264_intra_rd(), so the pixels and
  1036.              * coefs for the current chroma mode are still around, so we only
  1037.              * have to recount the bits. */
  1038.             i_best = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, a->i_predict8x8chroma, 0 );
  1039.             for( i = 0; i < i_max; i++ )
  1040.             {
  1041.                 i_mode = predict_mode[i];
  1042.                 if( h->mb.b_lossless )
  1043.                     x264_predict_lossless_8x8_chroma( h, i_mode );
  1044.                 else
  1045.                 {
  1046.                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
  1047.                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
  1048.                 }
  1049.                 /* if we've already found a mode that needs no residual, then
  1050.                  * probably any mode with a residual will be worse.
  1051.                  * so avoid dct on the remaining modes to improve speed. */
  1052.                 i_satd = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, i_mode, h->mb.i_cbp_chroma != 0x00 );
  1053.                 COPY3_IF_LT( i_best, i_satd, a->i_predict8x8chroma, i_mode, i_cbp_chroma_best, h->mb.i_cbp_chroma );
  1054.             }
  1055.             h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
  1056.             h->mb.i_cbp_chroma = i_cbp_chroma_best;
  1057.         }
  1058.     }
  1060.     if( h->mb.i_type == I_4x4 )
  1061.     {
  1062.         uint32_t pels[4] = {0}; // doesn't need initting, just shuts up a gcc warning
  1063.         int i_nnz = 0;
  1064.         for( idx = 0; idx < 16; idx++ )
  1065.         {
  1066.             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
  1067.             i_best = COST_MAX64;
  1069.             predict_4x4_mode_available( h->mb.i_neighbour4[idx], predict_mode, &i_max );
  1071.             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
  1072.                 /* emulate missing topright samples */
  1073.                 *(uint32_t*) &p_dst_by[4 - FDEC_STRIDE] = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
  1075.             for( i = 0; i < i_max; i++ )
  1076.             {
  1077.                 i_mode = predict_mode[i];
  1078.                 if( h->mb.b_lossless )
  1079.                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
  1080.                 else
  1081.                     h->predict_4x4[i_mode]( p_dst_by );
  1082.                 i_satd = x264_rd_cost_i4x4( h, a->i_lambda2, idx, i_mode );
  1084.                 if( i_best > i_satd )
  1085.                 {
  1086.                     a->i_predict4x4[idx] = i_mode;
  1087.                     i_best = i_satd;
  1088.                     pels[0] = *(uint32_t*)(p_dst_by+0*FDEC_STRIDE);
  1089.                     pels[1] = *(uint32_t*)(p_dst_by+1*FDEC_STRIDE);
  1090.                     pels[2] = *(uint32_t*)(p_dst_by+2*FDEC_STRIDE);
  1091.                     pels[3] = *(uint32_t*)(p_dst_by+3*FDEC_STRIDE);
  1092.                     i_nnz = h->mb.cache.non_zero_count[x264_scan8[idx]];
  1093.                 }
  1094.             }
  1096.             *(uint32_t*)(p_dst_by+0*FDEC_STRIDE) = pels[0];
  1097.             *(uint32_t*)(p_dst_by+1*FDEC_STRIDE) = pels[1];
  1098.             *(uint32_t*)(p_dst_by+2*FDEC_STRIDE) = pels[2];
  1099.             *(uint32_t*)(p_dst_by+3*FDEC_STRIDE) = pels[3];
  1100.             h->mb.cache.non_zero_count[x264_scan8[idx]] = i_nnz;
  1102.             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
  1103.         }
  1104.     }
  1105.     else if( h->mb.i_type == I_8x8 )
  1106.     {
  1107.         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
  1108.         for( idx = 0; idx < 4; idx++ )
  1109.         {
  1110.             uint64_t pels_h = 0;
  1111.             uint8_t pels_v[7];
  1112.             uint16_t i_nnz[2];
  1113.             uint8_t *p_dst_by;
  1114.             int j;
  1115.             int cbp_luma_new = 0;
  1116.             i_thresh = a->i_satd_i8x8_dir[a->i_predict8x8[idx]][idx] * 11/8;
  1118.             i_best = COST_MAX64;
  1119.             x = idx&1;
  1120.             y = idx>>1;
  1122.             p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
  1123.             predict_4x4_mode_available( h->mb.i_neighbour8[idx], predict_mode, &i_max );
  1124.             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
  1126.             for( i = 0; i < i_max; i++ )
  1127.             {
  1128.                 i_mode = predict_mode[i];
  1129.                 if( a->i_satd_i8x8_dir[i_mode][idx] > i_thresh )
  1130.                     continue;
  1131.                 if( h->mb.b_lossless )
  1132.                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
  1133.                 else
  1134.                     h->predict_8x8[i_mode]( p_dst_by, edge );
  1135.                 h->mb.i_cbp_luma = a->i_cbp_i8x8_luma;
  1136.                 i_satd = x264_rd_cost_i8x8( h, a->i_lambda2, idx, i_mode );
  1138.                 if( i_best > i_satd )
  1139.                 {
  1140.                     a->i_predict8x8[idx] = i_mode;
  1141.                     cbp_luma_new = h->mb.i_cbp_luma;
  1142.                     i_best = i_satd;
  1144.                     pels_h = *(uint64_t*)(p_dst_by+7*FDEC_STRIDE);
  1145.                     if( !(idx&1) )
  1146.                         for( j=0; j<7; j++ )
  1147.                             pels_v[j] = p_dst_by[7+j*FDEC_STRIDE];
  1148.                     i_nnz[0] = *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[4*idx+0]];
  1149.                     i_nnz[1] = *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[4*idx+2]];
  1150.                 }
  1151.             }
  1152.             a->i_cbp_i8x8_luma = cbp_luma_new;
  1153.             *(uint64_t*)(p_dst_by+7*FDEC_STRIDE) = pels_h;
  1154.             if( !(idx&1) )
  1155.                 for( j=0; j<7; j++ )
  1156.                     p_dst_by[7+j*FDEC_STRIDE] = pels_v[j];
  1157.             *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[4*idx+0]] = i_nnz[0];
  1158.             *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[4*idx+2]] = i_nnz[1];
  1160.             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
  1161.         }
  1162.     }
  1163. }
  1165. #define LOAD_FENC( m, src, xoff, yoff) 
  1166.     (m)->i_stride[0] = h->mb.pic.i_stride[0]; 
  1167.     (m)->i_stride[1] = h->mb.pic.i_stride[1]; 
  1168.     (m)->p_fenc[0] = &(src)[0][(xoff)+(yoff)*FENC_STRIDE]; 
  1169.     (m)->p_fenc[1] = &(src)[1][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE]; 
  1170.     (m)->p_fenc[2] = &(src)[2][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE];
  1172. #define LOAD_HPELS(m, src, list, ref, xoff, yoff) 
  1173.     (m)->p_fref[0] = &(src)[0][(xoff)+(yoff)*(m)->i_stride[0]]; 
  1174.     (m)->p_fref[1] = &(src)[1][(xoff)+(yoff)*(m)->i_stride[0]]; 
  1175.     (m)->p_fref[2] = &(src)[2][(xoff)+(yoff)*(m)->i_stride[0]]; 
  1176.     (m)->p_fref[3] = &(src)[3][(xoff)+(yoff)*(m)->i_stride[0]]; 
  1177.     (m)->p_fref[4] = &(src)[4][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; 
  1178.     (m)->p_fref[5] = &(src)[5][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; 
  1179.     (m)->integral = &h->mb.pic.p_integral[list][ref][(xoff)+(yoff)*(m)->i_stride[0]];
  1181. #define REF_COST(list, ref) 
  1182.     (a->p_cost_ref##list[ref])
  1184. static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
  1185. {
  1186.     x264_me_t m;
  1187.     int i_ref, i_mvc;
  1188.     ALIGNED_4( int16_t mvc[8][2] );
  1189.     int i_halfpel_thresh = INT_MAX;
  1190.     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
  1192.     /* 16x16 Search on all ref frame */
  1193.     m.i_pixel = PIXEL_16x16;
  1194.     m.p_cost_mv = a->p_cost_mv;
  1195.     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
  1197.     a->l0.me16x16.cost = INT_MAX;
  1198.     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
  1199.     {
  1200.         const int i_ref_cost = REF_COST( 0, i_ref );
  1201.         i_halfpel_thresh -= i_ref_cost;
  1202.         m.i_ref_cost = i_ref_cost;
  1203.         m.i_ref = i_ref;
  1205.         /* search with ref */
  1206.         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
  1207.         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
  1208.         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
  1209.         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
  1211.         /* early termination
  1212.          * SSD threshold would probably be better than SATD */
  1213.         if( i_ref == 0
  1214.             && a->b_try_pskip
  1215.             && m.cost-m.cost_mv < 300*a->i_lambda
  1216.             &&  abs(m.mv[0]-h->mb.cache.pskip_mv[0])
  1217.               + abs(m.mv[1]-h->mb.cache.pskip_mv[1]) <= 1
  1218.             && x264_macroblock_probe_pskip( h ) )
  1219.         {
  1220.             h->mb.i_type = P_SKIP;
  1221.             x264_analyse_update_cache( h, a );
  1222.             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
  1223.             return;
  1224.         }
  1226.         m.cost += i_ref_cost;
  1227.         i_halfpel_thresh += i_ref_cost;
  1229.         if( m.cost < a->l0.me16x16.cost )
  1230.             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
  1232.         /* save mv for predicting neighbors */
  1233.         *(uint32_t*)a->l0.mvc[i_ref][0] =
  1234.         *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
  1235.     }
  1237.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
  1238.     assert( a->l0.me16x16.mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
  1240.     h->mb.i_type = P_L0;
  1241.     if( a->i_mbrd )
  1242.     {
  1243.         x264_mb_cache_fenc_satd( h );
  1244.         if( a->l0.me16x16.i_ref == 0 && *(uint32_t*)a->l0.me16x16.mv == *(uint32_t*)h->mb.cache.pskip_mv )
  1245.         {
  1246.             h->mb.i_partition = D_16x16;
  1247.             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
  1248.             a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  1249.             if( !(h->mb.i_cbp_luma|h->mb.i_cbp_chroma) )
  1250.                 h->mb.i_type = P_SKIP;
  1251.         }
  1252.     }
  1253. }
  1255. static void x264_mb_analyse_inter_p8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
  1256. {
  1257.     x264_me_t m;
  1258.     int i_ref;
  1259.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1260.     int i_halfpel_thresh = INT_MAX;
  1261.     int *p_halfpel_thresh = /*h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : */NULL;
  1262.     int i;
  1263.     int i_maxref = h->mb.pic.i_fref[0]-1;
  1265.     h->mb.i_partition = D_8x8;
  1267.     /* early termination: if 16x16 chose ref 0, then evalute no refs older
  1268.      * than those used by the neighbors */
  1269.     if( i_maxref > 0 && a->l0.me16x16.i_ref == 0 &&
  1270.         h->mb.i_mb_type_top && h->mb.i_mb_type_left )
  1271.     {
  1272.         i_maxref = 0;
  1273.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 - 1 ] );
  1274.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 0 ] );
  1275.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 2 ] );
  1276.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 4 ] );
  1277.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 0 - 1 ] );
  1278.         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 2*8 - 1 ] );
  1279.     }
  1281.     for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
  1282.          *(uint32_t*)a->l0.mvc[i_ref][0] = *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy];
  1284.     for( i = 0; i < 4; i++ )
  1285.     {
  1286.         x264_me_t *l0m = &a->l0.me8x8[i];
  1287.         const int x8 = i%2;
  1288.         const int y8 = i/2;
  1290.         m.i_pixel = PIXEL_8x8;
  1291.         m.p_cost_mv = a->p_cost_mv;
  1293.         LOAD_FENC( &m, p_fenc, 8*x8, 8*y8 );
  1294.         l0m->cost = INT_MAX;
  1295.         for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
  1296.         {
  1297.             const int i_ref_cost = REF_COST( 0, i_ref );
  1298.             i_halfpel_thresh -= i_ref_cost;
  1299.             m.i_ref_cost = i_ref_cost;
  1300.             m.i_ref = i_ref;
  1302.             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
  1303.             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
  1304.             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
  1305.             x264_me_search_ref( h, &m, a->l0.mvc[i_ref], i+1, p_halfpel_thresh );
  1307.             m.cost += i_ref_cost;
  1308.             i_halfpel_thresh += i_ref_cost;
  1309.             *(uint32_t*)a->l0.mvc[i_ref][i+1] = *(uint32_t*)m.mv;
  1311.             if( m.cost < l0m->cost )
  1312.                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
  1313.         }
  1314.         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, l0m->mv );
  1315.         x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, l0m->i_ref );
  1317.         /* If CABAC is on and we're not doing sub-8x8 analysis, the costs
  1318.            are effectively zero. */
  1319.         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
  1320.             l0m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
  1321.     }
  1323.     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
  1324.                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
  1325.     /* P_8x8 ref0 has no ref cost */
  1326.     if( !h->param.b_cabac && !(a->l0.me8x8[0].i_ref | a->l0.me8x8[1].i_ref |
  1327.                                a->l0.me8x8[2].i_ref | a->l0.me8x8[3].i_ref) )
  1328.         a->l0.i_cost8x8 -= REF_COST( 0, 0 ) * 4;
  1329.     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  1330.     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  1331. }
  1333. static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
  1334. {
  1335.     const int i_ref = a->l0.me16x16.i_ref;
  1336.     const int i_ref_cost = h->param.b_cabac || i_ref ? REF_COST( 0, i_ref ) : 0;
  1337.     uint8_t  **p_fref = h->mb.pic.p_fref[0][i_ref];
  1338.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1339.     int i_mvc;
  1340.     int16_t (*mvc)[2] = a->l0.mvc[i_ref];
  1341.     int i;
  1343.     /* XXX Needed for x264_mb_predict_mv */
  1344.     h->mb.i_partition = D_8x8;
  1346.     i_mvc = 1;
  1347.     *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.me16x16.mv;
  1349.     for( i = 0; i < 4; i++ )
  1350.     {
  1351.         x264_me_t *m = &a->l0.me8x8[i];
  1352.         const int x8 = i%2;
  1353.         const int y8 = i/2;
  1355.         m->i_pixel = PIXEL_8x8;
  1356.         m->p_cost_mv = a->p_cost_mv;
  1357.         m->i_ref_cost = i_ref_cost;
  1358.         m->i_ref = i_ref;
  1360.         LOAD_FENC( m, p_fenc, 8*x8, 8*y8 );
  1361.         LOAD_HPELS( m, p_fref, 0, i_ref, 8*x8, 8*y8 );
  1362.         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
  1363.         x264_me_search( h, m, mvc, i_mvc );
  1365.         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, m->mv );
  1367.         *(uint32_t*)mvc[i_mvc] = *(uint32_t*)m->mv;
  1368.         i_mvc++;
  1370.         /* mb type cost */
  1371.         m->cost += i_ref_cost;
  1372.         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
  1373.             m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
  1374.     }
  1376.     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
  1377.                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
  1378.     /* theoretically this should include 4*ref_cost,
  1379.      * but 3 seems a better approximation of cabac. */
  1380.     if( h->param.b_cabac )
  1381.         a->l0.i_cost8x8 -= i_ref_cost;
  1382.     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  1383.     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  1384. }
  1386. static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a )
  1387. {
  1388.     x264_me_t m;
  1389.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1390.     ALIGNED_4( int16_t mvc[3][2] );
  1391.     int i, j;
  1393.     /* XXX Needed for x264_mb_predict_mv */
  1394.     h->mb.i_partition = D_16x8;
  1396.     for( i = 0; i < 2; i++ )
  1397.     {
  1398.         x264_me_t *l0m = &a->l0.me16x8[i];
  1399.         const int ref8[2] = { a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref };
  1400.         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
  1402.         m.i_pixel = PIXEL_16x8;
  1403.         m.p_cost_mv = a->p_cost_mv;
  1405.         LOAD_FENC( &m, p_fenc, 0, 8*i );
  1406.         l0m->cost = INT_MAX;
  1407.         for( j = 0; j < i_ref8s; j++ )
  1408.         {
  1409.             const int i_ref = ref8[j];
  1410.             const int i_ref_cost = REF_COST( 0, i_ref );
  1411.             m.i_ref_cost = i_ref_cost;
  1412.             m.i_ref = i_ref;
  1414.             /* if we skipped the 16x16 predictor, we wouldn't have to copy anything... */
  1415.             *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.mvc[i_ref][0];
  1416.             *(uint32_t*)mvc[1] = *(uint32_t*)a->l0.mvc[i_ref][2*i+1];
  1417.             *(uint32_t*)mvc[2] = *(uint32_t*)a->l0.mvc[i_ref][2*i+2];
  1419.             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 8*i );
  1420.             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, i_ref );
  1421.             x264_mb_predict_mv( h, 0, 8*i, 4, m.mvp );
  1422.             x264_me_search( h, &m, mvc, 3 );
  1424.             m.cost += i_ref_cost;
  1426.             if( m.cost < l0m->cost )
  1427.                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
  1428.         }
  1429.         x264_macroblock_cache_mv_ptr( h, 0, 2*i, 4, 2, 0, l0m->mv );
  1430.         x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, l0m->i_ref );
  1431.     }
  1433.     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
  1434. }
  1436. static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
  1437. {
  1438.     x264_me_t m;
  1439.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1440.     ALIGNED_4( int16_t mvc[3][2] );
  1441.     int i, j;
  1443.     /* XXX Needed for x264_mb_predict_mv */
  1444.     h->mb.i_partition = D_8x16;
  1446.     for( i = 0; i < 2; i++ )
  1447.     {
  1448.         x264_me_t *l0m = &a->l0.me8x16[i];
  1449.         const int ref8[2] = { a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref };
  1450.         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
  1452.         m.i_pixel = PIXEL_8x16;
  1453.         m.p_cost_mv = a->p_cost_mv;
  1455.         LOAD_FENC( &m, p_fenc, 8*i, 0 );
  1456.         l0m->cost = INT_MAX;
  1457.         for( j = 0; j < i_ref8s; j++ )
  1458.         {
  1459.             const int i_ref = ref8[j];
  1460.             const int i_ref_cost = REF_COST( 0, i_ref );
  1461.             m.i_ref_cost = i_ref_cost;
  1462.             m.i_ref = i_ref;
  1464.             *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.mvc[i_ref][0];
  1465.             *(uint32_t*)mvc[1] = *(uint32_t*)a->l0.mvc[i_ref][i+1];
  1466.             *(uint32_t*)mvc[2] = *(uint32_t*)a->l0.mvc[i_ref][i+3];
  1468.             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*i, 0 );
  1469.             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, i_ref );
  1470.             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
  1471.             x264_me_search( h, &m, mvc, 3 );
  1473.             m.cost += i_ref_cost;
  1475.             if( m.cost < l0m->cost )
  1476.                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
  1477.         }
  1478.         x264_macroblock_cache_mv_ptr( h, 2*i, 0, 2, 4, 0, l0m->mv );
  1479.         x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, l0m->i_ref );
  1480.     }
  1482.     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
  1483. }
  1485. static int x264_mb_analyse_inter_p4x4_chroma( x264_t *h, x264_mb_analysis_t *a, uint8_t **p_fref, int i8x8, int pixel )
  1486. {
  1487.     ALIGNED_8( uint8_t pix1[16*8] );
  1488.     uint8_t *pix2 = pix1+8;
  1489.     const int i_stride = h->mb.pic.i_stride[1];
  1490.     const int or = 4*(i8x8&1) + 2*(i8x8&2)*i_stride;
  1491.     const int oe = 4*(i8x8&1) + 2*(i8x8&2)*FENC_STRIDE;
  1493. #define CHROMA4x4MC( width, height, me, x, y ) 
  1494.     h->mc.mc_chroma( &pix1[x+y*16], 16, &p_fref[4][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1], width, height ); 
  1495.     h->mc.mc_chroma( &pix2[x+y*16], 16, &p_fref[5][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1], width, height );
  1497.     if( pixel == PIXEL_4x4 )
  1498.     {
  1499.         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][0], 0,0 );
  1500.         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][1], 2,0 );
  1501.         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][2], 0,2 );
  1502.         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][3], 2,2 );
  1503.     }
  1504.     else if( pixel == PIXEL_8x4 )
  1505.     {
  1506.         CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][0], 0,0 );
  1507.         CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][1], 0,2 );
  1508.     }
  1509.     else
  1510.     {
  1511.         CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][0], 0,0 );
  1512.         CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][1], 2,0 );
  1513.     }
  1515.     return h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[1][oe], FENC_STRIDE, pix1, 16 )
  1516.          + h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[2][oe], FENC_STRIDE, pix2, 16 );
  1517. }
  1519. static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
  1520. {
  1521.     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
  1522.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1523.     const int i_ref = a->l0.me8x8[i8x8].i_ref;
  1524.     int i4x4;
  1526.     /* XXX Needed for x264_mb_predict_mv */
  1527.     h->mb.i_partition = D_8x8;
  1529.     for( i4x4 = 0; i4x4 < 4; i4x4++ )
  1530.     {
  1531.         const int idx = 4*i8x8 + i4x4;
  1532.         const int x4 = block_idx_x[idx];
  1533.         const int y4 = block_idx_y[idx];
  1534.         const int i_mvc = (i4x4 == 0);
  1536.         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
  1538.         m->i_pixel = PIXEL_4x4;
  1539.         m->p_cost_mv = a->p_cost_mv;
  1541.         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
  1542.         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
  1544.         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
  1545.         x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );
  1547.         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 1, 0, m->mv );
  1548.     }
  1549.     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
  1550.                             a->l0.me4x4[i8x8][1].cost +
  1551.                             a->l0.me4x4[i8x8][2].cost +
  1552.                             a->l0.me4x4[i8x8][3].cost +
  1553.                             REF_COST( 0, i_ref ) +
  1554.                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
  1555.     if( h->mb.b_chroma_me )
  1556.         a->l0.i_cost4x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x4 );
  1557. }
  1559. static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
  1560. {
  1561.     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
  1562.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1563.     const int i_ref = a->l0.me8x8[i8x8].i_ref;
  1564.     int i8x4;
  1566.     /* XXX Needed for x264_mb_predict_mv */
  1567.     h->mb.i_partition = D_8x8;
  1569.     for( i8x4 = 0; i8x4 < 2; i8x4++ )
  1570.     {
  1571.         const int idx = 4*i8x8 + 2*i8x4;
  1572.         const int x4 = block_idx_x[idx];
  1573.         const int y4 = block_idx_y[idx];
  1574.         const int i_mvc = (i8x4 == 0);
  1576.         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
  1578.         m->i_pixel = PIXEL_8x4;
  1579.         m->p_cost_mv = a->p_cost_mv;
  1581.         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
  1582.         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
  1584.         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
  1585.         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
  1587.         x264_macroblock_cache_mv_ptr( h, x4, y4, 2, 1, 0, m->mv );
  1588.     }
  1589.     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost +
  1590.                             REF_COST( 0, i_ref ) +
  1591.                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x4];
  1592.     if( h->mb.b_chroma_me )
  1593.         a->l0.i_cost8x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_8x4 );
  1594. }
  1596. static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
  1597. {
  1598.     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
  1599.     uint8_t  **p_fenc = h->mb.pic.p_fenc;
  1600.     const int i_ref = a->l0.me8x8[i8x8].i_ref;
  1601.     int i4x8;
  1603.     /* XXX Needed for x264_mb_predict_mv */
  1604.     h->mb.i_partition = D_8x8;
  1606.     for( i4x8 = 0; i4x8 < 2; i4x8++ )
  1607.     {
  1608.         const int idx = 4*i8x8 + i4x8;
  1609.         const int x4 = block_idx_x[idx];
  1610.         const int y4 = block_idx_y[idx];
  1611.         const int i_mvc = (i4x8 == 0);
  1613.         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
  1615.         m->i_pixel = PIXEL_4x8;
  1616.         m->p_cost_mv = a->p_cost_mv;
  1618.         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
  1619.         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
  1621.         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
  1622.         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
  1624.         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 2, 0, m->mv );
  1625.     }
  1626.     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost +
  1627.                             REF_COST( 0, i_ref ) +
  1628.                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x8];
  1629.     if( h->mb.b_chroma_me )
  1630.         a->l0.i_cost4x8[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x8 );
  1631. }
  1633. static void x264_mb_analyse_inter_direct( x264_t *h, x264_mb_analysis_t *a )
  1634. {
  1635.     /* Assumes that fdec still contains the results of
  1636.      * x264_mb_predict_mv_direct16x16 and x264_mb_mc */
  1638.     uint8_t **p_fenc = h->mb.pic.p_fenc;
  1639.     uint8_t **p_fdec = h->mb.pic.p_fdec;
  1640.     int i;
  1642.     a->i_cost16x16direct = a->i_lambda * i_mb_b_cost_table[B_DIRECT];
  1643.     for( i = 0; i < 4; i++ )
  1644.     {
  1645.         const int x = (i&1)*8;
  1646.         const int y = (i>>1)*8;
  1647.         a->i_cost16x16direct +=
  1648.         a->i_cost8x8direct[i] =
  1649.             h->pixf.mbcmp[PIXEL_8x8]( &p_fenc[0][x+y*FENC_STRIDE], FENC_STRIDE, &p_fdec[0][x+y*FDEC_STRIDE], FDEC_STRIDE );
  1651.         /* mb type cost */
  1652.         a->i_cost8x8direct[i] += a->i_lambda * i_sub_mb_b_cost_table[D_DIRECT_8x8];
  1653.     }
  1654. }
  1656. #define WEIGHTED_AVG( size, pix, stride, src1, stride1, src2, stride2 ) 
  1657. { 
  1658.     h->mc.avg[size]( pix, stride, src1, stride1, src2, stride2, h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] ); 
  1659. }
  1661. static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
  1662. {
  1663.     ALIGNED_ARRAY_16( uint8_t, pix0,[16*16] );
  1664.     ALIGNED_ARRAY_16( uint8_t, pix1,[16*16] );
  1665.     uint8_t *src0, *src1;
  1666.     int stride0 = 16, stride1 = 16;
  1668.     x264_me_t m;
  1669.     int i_ref, i_mvc;
  1670.     ALIGNED_4( int16_t mvc[9][2] );
  1671.     int i_halfpel_thresh = INT_MAX;
  1672.     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
  1674.     /* 16x16 Search on all ref frame */
  1675.     m.i_pixel = PIXEL_16x16;
  1676.     m.p_cost_mv = a->p_cost_mv;
  1677.     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
  1679.     /* ME for List 0 */
  1680.     a->l0.me16x16.cost = INT_MAX;
  1681.     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
  1682.     {
  1683.         /* search with ref */
  1684.         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
  1685.         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
  1686.         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
  1687.         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
  1689.         /* add ref cost */
  1690.         m.cost += REF_COST( 0, i_ref );
  1692.         if( m.cost < a->l0.me16x16.cost )
  1693.         {
  1694.             a->l0.i_ref = i_ref;
  1695.             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
  1696.         }
  1698.         /* save mv for predicting neighbors */
  1699.         *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
  1700.     }
  1701.     /* subtract ref cost, so we don't have to add it for the other MB types */
  1702.     a->l0.me16x16.cost -= REF_COST( 0, a->l0.i_ref );
  1704.     /* ME for list 1 */
  1705.     i_halfpel_thresh = INT_MAX;
  1706.     p_halfpel_thresh = h->mb.pic.i_fref[1]>1 ? &i_halfpel_thresh : NULL;
  1707.     a->l1.me16x16.cost = INT_MAX;
  1708.     for( i_ref = 0; i_ref < h->mb.pic.i_fref[1]; i_ref++ )
  1709.     {
  1710.         /* search with ref */
  1711.         LOAD_HPELS( &m, h->mb.pic.p_fref[1][i_ref], 1, i_ref, 0, 0 );
  1712.         x264_mb_predict_mv_16x16( h, 1, i_ref, m.mvp );
  1713.         x264_mb_predict_mv_ref16x16( h, 1, i_ref, mvc, &i_mvc );
  1714.         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
  1716.         /* add ref cost */
  1717.         m.cost += REF_COST( 1, i_ref );
  1719.         if( m.cost < a->l1.me16x16.cost )
  1720.         {
  1721.             a->l1.i_ref = i_ref;
  1722.             h->mc.memcpy_aligned( &a->l1.me16x16, &m, sizeof(x264_me_t) );
  1723.         }
  1725.         /* save mv for predicting neighbors */
  1726.         *(uint32_t*)h->mb.mvr[1][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
  1727.     }
  1728.     /* subtract ref cost, so we don't have to add it for the other MB types */
  1729.     a->l1.me16x16.cost -= REF_COST( 1, a->l1.i_ref );
  1731.     /* Set global ref, needed for other modes? */
  1732.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
  1733.     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
  1735.     /* get cost of BI mode */
  1736.     src0 = h->mc.get_ref( pix0, &stride0,
  1737.                            h->mb.pic.p_fref[0][a->l0.i_ref], h->mb.pic.i_stride[0],
  1738.                            a->l0.me16x16.mv[0], a->l0.me16x16.mv[1], 16, 16 );
  1739.     src1 = h->mc.get_ref( pix1, &stride1,
  1740.                            h->mb.pic.p_fref[1][a->l1.i_ref], h->mb.pic.i_stride[0],
  1741.                            a->l1.me16x16.mv[0], a->l1.me16x16.mv[1], 16, 16 );
  1743.     h->mc.avg[PIXEL_16x16]( pix0, 16, src0, stride0, src1, stride1, h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
  1745.     a->i_cost16x16bi = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
  1746.                      + REF_COST( 0, a->l0.i_ref )
  1747.                      + REF_COST( 1, a->l1.i_ref )
  1748.                      + a->l0.me16x16.cost_mv
  1749.                      + a->l1.me16x16.cost_mv;
  1751.     /* mb type cost */
  1752.     a->i_cost16x16bi   += a->i_lambda * i_mb_b_cost_table[B_BI_BI];
  1753.     a->l0.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L0_L0];
  1754.     a->l1.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L1_L1];
  1755. }
  1757. static inline void x264_mb_cache_mv_p8x8( x264_t *h, x264_mb_analysis_t *a, int i )
  1758. {
  1759.     const int x = 2*(i%2);
  1760.     const int y = 2*(i/2);
  1762.     switch( h->mb.i_sub_partition[i] )
  1763.     {
  1764.         case D_L0_8x8:
  1765.             x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, a->l0.me8x8[i].mv );
  1766.             break;
  1767.         case D_L0_8x4:
  1768.             x264_macroblock_cache_mv_ptr( h, x, y+0, 2, 1, 0, a->l0.me8x4[i][0].mv );
  1769.             x264_macroblock_cache_mv_ptr( h, x, y+1, 2, 1, 0, a->l0.me8x4[i][1].mv );
  1770.             break;
  1771.         case D_L0_4x8:
  1772.             x264_macroblock_cache_mv_ptr( h, x+0, y, 1, 2, 0, a->l0.me4x8[i][0].mv );
  1773.             x264_macroblock_cache_mv_ptr( h, x+1, y, 1, 2, 0, a->l0.me4x8[i][1].mv );
  1774.             break;
  1775.         case D_L0_4x4:
  1776.             x264_macroblock_cache_mv_ptr( h, x+0, y+0, 1, 1, 0, a->l0.me4x4[i][0].mv );
  1777.             x264_macroblock_cache_mv_ptr( h, x+1, y+0, 1, 1, 0, a->l0.me4x4[i][1].mv );
  1778.             x264_macroblock_cache_mv_ptr( h, x+0, y+1, 1, 1, 0, a->l0.me4x4[i][2].mv );
  1779.             x264_macroblock_cache_mv_ptr( h, x+1, y+1, 1, 1, 0, a->l0.me4x4[i][3].mv );
  1780.             break;
  1781.         default:
  1782.             x264_log( h, X264_LOG_ERROR, "internal errorn" );
  1783.             break;
  1784.     }
  1785. }
  1787. #define CACHE_MV_BI(x,y,dx,dy,me0,me1,part) 
  1788.     if( x264_mb_partition_listX_table[0][part] ) 
  1789.     { 
  1790.         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, a->l0.i_ref ); 
  1791.         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 0, me0.mv ); 
  1792.     } 
  1793.     else 
  1794.     { 
  1795.         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, -1 ); 
  1796.         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, 0 ); 
  1797.         if( b_mvd ) 
  1798.             x264_macroblock_cache_mvd( h, x,y,dx,dy, 0, 0 ); 
  1799.     } 
  1800.     if( x264_mb_partition_listX_table[1][part] ) 
  1801.     { 
  1802.         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, a->l1.i_ref ); 
  1803.         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 1, me1.mv ); 
  1804.     } 
  1805.     else 
  1806.     { 
  1807.         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, -1 ); 
  1808.         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, 0 ); 
  1809.         if( b_mvd ) 
  1810.             x264_macroblock_cache_mvd( h, x,y,dx,dy, 1, 0 ); 
  1811.     }
  1813. static inline void x264_mb_cache_mv_b8x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
  1814. {
  1815.     int x = (i%2)*2;
  1816.     int y = (i/2)*2;
  1817.     if( h->mb.i_sub_partition[i] == D_DIRECT_8x8 )
  1818.     {
  1819.         x264_mb_load_mv_direct8x8( h, i );
  1820.         if( b_mvd )
  1821.         {
  1822.             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 0, 0 );
  1823.             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 1, 0 );
  1824.             x264_macroblock_cache_skip( h, x, y, 2, 2, 1 );
  1825.         }
  1826.     }
  1827.     else
  1828.     {
  1829.         CACHE_MV_BI( x, y, 2, 2, a->l0.me8x8[i], a->l1.me8x8[i], h->mb.i_sub_partition[i] );
  1830.     }
  1831. }
  1832. static inline void x264_mb_cache_mv_b16x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
  1833. {
  1834.     CACHE_MV_BI( 0, 2*i, 4, 2, a->l0.me16x8[i], a->l1.me16x8[i], a->i_mb_partition16x8[i] );
  1835. }
  1836. static inline void x264_mb_cache_mv_b8x16( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
  1837. {
  1838.     CACHE_MV_BI( 2*i, 0, 2, 4, a->l0.me8x16[i], a->l1.me8x16[i], a->i_mb_partition8x16[i] );
  1839. }
  1840. #undef CACHE_MV_BI
  1842. static void x264_mb_analyse_inter_b8x8( x264_t *h, x264_mb_analysis_t *a )
  1843. {
  1844.     uint8_t **p_fref[2] =
  1845.         { h->mb.pic.p_fref[0][a->l0.i_ref],
  1846.           h->mb.pic.p_fref[1][a->l1.i_ref] };
  1847.     ALIGNED_8( uint8_t pix[2][8*8] );
  1848.     int i, l;
  1850.     /* XXX Needed for x264_mb_predict_mv */
  1851.     h->mb.i_partition = D_8x8;
  1853.     a->i_cost8x8bi = 0;
  1855.     for( i = 0; i < 4; i++ )
  1856.     {
  1857.         const int x8 = i%2;
  1858.         const int y8 = i/2;
  1859.         int i_part_cost;
  1860.         int i_part_cost_bi = 0;
  1861.         int stride[2] = {8,8};
  1862.         uint8_t *src[2];
  1864.         for( l = 0; l < 2; l++ )
  1865.         {
  1866.             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
  1867.             x264_me_t *m = &lX->me8x8[i];
  1869.             m->i_pixel = PIXEL_8x8;
  1870.             m->p_cost_mv = a->p_cost_mv;
  1872.             LOAD_FENC( m, h->mb.pic.p_fenc, 8*x8, 8*y8 );
  1873.             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*x8, 8*y8 );
  1875.             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
  1876.             x264_me_search( h, m, &lX->me16x16.mv, 1 );
  1878.             x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, l, m->mv );
  1880.             /* BI mode */
  1881.             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
  1882.                                     m->mv[0], m->mv[1], 8, 8 );
  1883.             i_part_cost_bi += m->cost_mv;
  1884.             /* FIXME: ref cost */
  1885.         }
  1886.         h->mc.avg[PIXEL_8x8]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
  1887.         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x8]( a->l0.me8x8[i].p_fenc[0], FENC_STRIDE, pix[0], 8 )
  1888.                         + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
  1889.         a->l0.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
  1890.         a->l1.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
  1892.         i_part_cost = a->l0.me8x8[i].cost;
  1893.         h->mb.i_sub_partition[i] = D_L0_8x8;
  1894.         COPY2_IF_LT( i_part_cost, a->l1.me8x8[i].cost, h->mb.i_sub_partition[i], D_L1_8x8 );
  1895.         COPY2_IF_LT( i_part_cost, i_part_cost_bi, h->mb.i_sub_partition[i], D_BI_8x8 );
  1896.         COPY2_IF_LT( i_part_cost, a->i_cost8x8direct[i], h->mb.i_sub_partition[i], D_DIRECT_8x8 );
  1897.         a->i_cost8x8bi += i_part_cost;
  1899.         /* XXX Needed for x264_mb_predict_mv */
  1900.         x264_mb_cache_mv_b8x8( h, a, i, 0 );
  1901.     }
  1903.     /* mb type cost */
  1904.     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
  1905. }
  1907. static void x264_mb_analyse_inter_b16x8( x264_t *h, x264_mb_analysis_t *a )
  1908. {
  1909.     uint8_t **p_fref[2] =
  1910.         { h->mb.pic.p_fref[0][a->l0.i_ref],
  1911.           h->mb.pic.p_fref[1][a->l1.i_ref] };
  1912.     ALIGNED_ARRAY_16( uint8_t, pix,[2],[16*8] );
  1913.     ALIGNED_4( int16_t mvc[2][2] );
  1914.     int i, l;
  1916.     h->mb.i_partition = D_16x8;
  1917.     a->i_cost16x8bi = 0;
  1919.     for( i = 0; i < 2; i++ )
  1920.     {
  1921.         int i_part_cost;
  1922.         int i_part_cost_bi = 0;
  1923.         int stride[2] = {16,16};
  1924.         uint8_t *src[2];
  1926.         /* TODO: check only the list(s) that were used in b8x8? */
  1927.         for( l = 0; l < 2; l++ )
  1928.         {
  1929.             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
  1930.             x264_me_t *m = &lX->me16x8[i];
  1932.             m->i_pixel = PIXEL_16x8;
  1933.             m->p_cost_mv = a->p_cost_mv;
  1935.             LOAD_FENC( m, h->mb.pic.p_fenc, 0, 8*i );
  1936.             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 0, 8*i );
  1938.             *(uint32_t*)mvc[0] = *(uint32_t*)lX->me8x8[2*i].mv;
  1939.             *(uint32_t*)mvc[1] = *(uint32_t*)lX->me8x8[2*i+1].mv;
  1941.             x264_mb_predict_mv( h, l, 8*i, 2, m->mvp );
  1942.             x264_me_search( h, m, mvc, 2 );
  1944.             /* BI mode */
  1945.             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
  1946.                                     m->mv[0], m->mv[1], 16, 8 );
  1947.             /* FIXME: ref cost */
  1948.             i_part_cost_bi += m->cost_mv;
  1949.         }
  1950.         h->mc.avg[PIXEL_16x8]( pix[0], 16, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
  1951.         i_part_cost_bi += h->pixf.mbcmp[PIXEL_16x8]( a->l0.me16x8[i].p_fenc[0], FENC_STRIDE, pix[0], 16 );
  1953.         i_part_cost = a->l0.me16x8[i].cost;
  1954.         a->i_mb_partition16x8[i] = D_L0_8x8; /* not actually 8x8, only the L0 matters */
  1955.         if( a->l1.me16x8[i].cost < i_part_cost )
  1956.         {
  1957.             i_part_cost = a->l1.me16x8[i].cost;
  1958.             a->i_mb_partition16x8[i] = D_L1_8x8;
  1959.         }
  1960.         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
  1961.         {
  1962.             i_part_cost = i_part_cost_bi;
  1963.             a->i_mb_partition16x8[i] = D_BI_8x8;
  1964.         }
  1965.         a->i_cost16x8bi += i_part_cost;
  1967.         x264_mb_cache_mv_b16x8( h, a, i, 0 );
  1968.     }
  1970.     /* mb type cost */
  1971.     a->i_mb_type16x8 = B_L0_L0
  1972.         + (a->i_mb_partition16x8[0]>>2) * 3
  1973.         + (a->i_mb_partition16x8[1]>>2);
  1974.     a->i_cost16x8bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type16x8];
  1975. }
  1977. static void x264_mb_analyse_inter_b8x16( x264_t *h, x264_mb_analysis_t *a )
  1978. {
  1979.     uint8_t **p_fref[2] =
  1980.         { h->mb.pic.p_fref[0][a->l0.i_ref],
  1981.           h->mb.pic.p_fref[1][a->l1.i_ref] };
  1982.     ALIGNED_8( uint8_t pix[2][8*16] );
  1983.     ALIGNED_4( int16_t mvc[2][2] );
  1984.     int i, l;
  1986.     h->mb.i_partition = D_8x16;
  1987.     a->i_cost8x16bi = 0;
  1989.     for( i = 0; i < 2; i++ )
  1990.     {
  1991.         int i_part_cost;
  1992.         int i_part_cost_bi = 0;
  1993.         int stride[2] = {8,8};
  1994.         uint8_t *src[2];
  1996.         for( l = 0; l < 2; l++ )
  1997.         {
  1998.             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
  1999.             x264_me_t *m = &lX->me8x16[i];
  2001.             m->i_pixel = PIXEL_8x16;
  2002.             m->p_cost_mv = a->p_cost_mv;
  2004.             LOAD_FENC( m, h->mb.pic.p_fenc, 8*i, 0 );
  2005.             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*i, 0 );
  2007.             *(uint32_t*)mvc[0] = *(uint32_t*)lX->me8x8[i].mv;
  2008.             *(uint32_t*)mvc[1] = *(uint32_t*)lX->me8x8[i+2].mv;
  2010.             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
  2011.             x264_me_search( h, m, mvc, 2 );
  2013.             /* BI mode */
  2014.             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref,  m->i_stride[0],
  2015.                                     m->mv[0], m->mv[1], 8, 16 );
  2016.             /* FIXME: ref cost */
  2017.             i_part_cost_bi += m->cost_mv;
  2018.         }
  2020.         h->mc.avg[PIXEL_8x16]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
  2021.         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x16]( a->l0.me8x16[i].p_fenc[0], FENC_STRIDE, pix[0], 8 );
  2023.         i_part_cost = a->l0.me8x16[i].cost;
  2024.         a->i_mb_partition8x16[i] = D_L0_8x8;
  2025.         if( a->l1.me8x16[i].cost < i_part_cost )
  2026.         {
  2027.             i_part_cost = a->l1.me8x16[i].cost;
  2028.             a->i_mb_partition8x16[i] = D_L1_8x8;
  2029.         }
  2030.         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
  2031.         {
  2032.             i_part_cost = i_part_cost_bi;
  2033.             a->i_mb_partition8x16[i] = D_BI_8x8;
  2034.         }
  2035.         a->i_cost8x16bi += i_part_cost;
  2037.         x264_mb_cache_mv_b8x16( h, a, i, 0 );
  2038.     }
  2040.     /* mb type cost */
  2041.     a->i_mb_type8x16 = B_L0_L0
  2042.         + (a->i_mb_partition8x16[0]>>2) * 3
  2043.         + (a->i_mb_partition8x16[1]>>2);
  2044.     a->i_cost8x16bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type8x16];
  2045. }
  2047. static void x264_mb_analyse_p_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd )
  2048. {
  2049.     int thresh = i_satd * 5/4;
  2051.     h->mb.i_type = P_L0;
  2052.     if( a->l0.i_rd16x16 == COST_MAX && a->l0.me16x16.cost <= i_satd * 3/2 )
  2053.     {
  2054.         h->mb.i_partition = D_16x16;
  2055.         x264_analyse_update_cache( h, a );
  2056.         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  2057.     }
  2059.     if( a->l0.i_cost16x8 <= thresh )
  2060.     {
  2061.         h->mb.i_partition = D_16x8;
  2062.         x264_analyse_update_cache( h, a );
  2063.         a->l0.i_cost16x8 = x264_rd_cost_mb( h, a->i_lambda2 );
  2064.     }
  2065.     else
  2066.         a->l0.i_cost16x8 = COST_MAX;
  2068.     if( a->l0.i_cost8x16 <= thresh )
  2069.     {
  2070.         h->mb.i_partition = D_8x16;
  2071.         x264_analyse_update_cache( h, a );
  2072.         a->l0.i_cost8x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  2073.     }
  2074.     else
  2075.         a->l0.i_cost8x16 = COST_MAX;
  2077.     if( a->l0.i_cost8x8 <= thresh )
  2078.     {
  2079.         h->mb.i_type = P_8x8;
  2080.         h->mb.i_partition = D_8x8;
  2081.         if( h->param.analyse.inter & X264_ANALYSE_PSUB8x8 )
  2082.         {
  2083.             int i;
  2084.             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
  2085.             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
  2086.             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
  2087.             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
  2088.             /* FIXME: In the 8x8 blocks where RDO isn't run, the NNZ values used for context selection
  2089.              * for future blocks are those left over from previous RDO calls. */
  2090.             for( i = 0; i < 4; i++ )
  2091.             {
  2092.                 int costs[4] = {a->l0.i_cost4x4[i], a->l0.i_cost8x4[i], a->l0.i_cost4x8[i], a->l0.me8x8[i].cost};
  2093.                 int thresh = X264_MIN4( costs[0], costs[1], costs[2], costs[3] ) * 5 / 4;
  2094.                 int subtype, btype = D_L0_8x8;
  2095.                 uint64_t bcost = COST_MAX64;
  2096.                 for( subtype = D_L0_4x4; subtype <= D_L0_8x8; subtype++ )
  2097.                 {
  2098.                     uint64_t cost;
  2099.                     if( costs[subtype] > thresh || (subtype == D_L0_8x8 && bcost == COST_MAX64) )
  2100.                         continue;
  2101.                     h->mb.i_sub_partition[i] = subtype;
  2102.                     x264_mb_cache_mv_p8x8( h, a, i );
  2103.                     cost = x264_rd_cost_part( h, a->i_lambda2, i<<2, PIXEL_8x8 );
  2104.                     COPY2_IF_LT( bcost, cost, btype, subtype );
  2105.                 }
  2106.                 h->mb.i_sub_partition[i] = btype;
  2107.                 x264_mb_cache_mv_p8x8( h, a, i );
  2108.             }
  2109.         }
  2110.         else
  2111.             x264_analyse_update_cache( h, a );
  2112.         a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
  2113.     }
  2114.     else
  2115.         a->l0.i_cost8x8 = COST_MAX;
  2116. }
  2118. static void x264_mb_analyse_b_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
  2119. {
  2120.     int thresh = i_satd_inter * (17 + (!!h->mb.i_psy_rd))/16;
  2122.     if( a->b_direct_available && a->i_rd16x16direct == COST_MAX )
  2123.     {
  2124.         h->mb.i_type = B_DIRECT;
  2125.         /* Assumes direct/skip MC is still in fdec */
  2126.         /* Requires b-rdo to be done before intra analysis */
  2127.         h->mb.b_skip_mc = 1;
  2128.         x264_analyse_update_cache( h, a );
  2129.         a->i_rd16x16direct = x264_rd_cost_mb( h, a->i_lambda2 );
  2130.         h->mb.b_skip_mc = 0;
  2131.     }
  2133.     //FIXME not all the update_cache calls are needed
  2134.     h->mb.i_partition = D_16x16;
  2135.     /* L0 */
  2136.     if( a->l0.me16x16.cost <= thresh && a->l0.i_rd16x16 == COST_MAX )
  2137.     {
  2138.         h->mb.i_type = B_L0_L0;
  2139.         x264_analyse_update_cache( h, a );
  2140.         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  2141.     }
  2143.     /* L1 */
  2144.     if( a->l1.me16x16.cost <= thresh && a->l1.i_rd16x16 == COST_MAX )
  2145.     {
  2146.         h->mb.i_type = B_L1_L1;
  2147.         x264_analyse_update_cache( h, a );
  2148.         a->l1.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
  2149.     }
  2151.     /* BI */
  2152.     if( a->i_cost16x16bi <= thresh && a->i_rd16x16bi == COST_MAX )
  2153.     {
  2154.         h->mb.i_type = B_BI_BI;
  2155.         x264_analyse_update_cache( h, a );
  2156.         a->i_rd16x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
  2157.     }
  2159.     /* 8x8 */
  2160.     if( a->i_cost8x8bi <= thresh && a->i_rd8x8bi == COST_MAX )
  2161.     {
  2162.         h->mb.i_type = B_8x8;
  2163.         h->mb.i_partition = D_8x8;
  2164.         x264_analyse_update_cache( h, a );
  2165.         a->i_rd8x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
  2166.         x264_macroblock_cache_skip( h, 0, 0, 4, 4, 0 );
  2167.     }
  2169.     /* 16x8 */
  2170.     if( a->i_cost16x8bi <= thresh && a->i_rd16x8bi == COST_MAX )
  2171.     {
  2172.         h->mb.i_type = a->i_mb_type16x8;
  2173.         h->mb.i_partition = D_16x8;
  2174.         x264_analyse_update_cache( h, a );
  2175.         a->i_rd16x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
  2176.     }
  2178.     /* 8x16 */
  2179.     if( a->i_cost8x16bi <= thresh && a->i_rd8x16bi == COST_MAX )
  2180.     {
  2181.         h->mb.i_type = a->i_mb_type8x16;
  2182.         h->mb.i_partition = D_8x16;
  2183.         x264_analyse_update_cache( h, a );
  2184.         a->i_rd8x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
  2185.     }
  2186. }
  2188. static void x264_refine_bidir( x264_t *h, x264_mb_analysis_t *a )
  2189. {
  2190.     const int i_biweight = h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref];
  2191.     int i;
  2193.     if( IS_INTRA(h->mb.i_type) )
  2194.         return;
  2196.     switch( h->mb.i_partition )
  2197.     {
  2198.         case D_16x16:
  2199.             if( h->mb.i_type == B_BI_BI )
  2200.                 x264_me_refine_bidir_satd( h, &a->l0.me16x16, &a->l1.me16x16, i_biweight );
  2201.             break;
  2202.         case D_16x8:
  2203.             for( i=0; i<2; i++ )
  2204.                 if( a->i_mb_partition16x8[i] == D_BI_8x8 )
  2205.                     x264_me_refine_bidir_satd( h, &a->l0.me16x8[i], &a->l1.me16x8[i], i_biweight );
  2206.             break;
  2207.         case D_8x16:
  2208.             for( i=0; i<2; i++ )
  2209.                 if( a->i_mb_partition8x16[i] == D_BI_8x8 )
  2210.                     x264_me_refine_bidir_satd( h, &a->l0.me8x16[i], &a->l1.me8x16[i], i_biweight );
  2211.             break;
  2212.         case D_8x8:
  2213.             for( i=0; i<4; i++ )
  2214.                 if( h->mb.i_sub_partition[i] == D_BI_8x8 )
  2215.                     x264_me_refine_bidir_satd( h, &a->l0.me8x8[i], &a->l1.me8x8[i], i_biweight );
  2216.             break;
  2217.     }
  2218. }
  2220. static inline void x264_mb_analyse_transform( x264_t *h )
  2221. {
  2222.     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 && !h->mb.b_lossless )
  2223.     {
  2224.         int i_cost4, i_cost8;
  2225.         /* Only luma MC is really needed, but the full MC is re-used in macroblock_encode. */
  2226.         x264_mb_mc( h );
  2228.         i_cost8 = h->pixf.sa8d[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
  2229.                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
  2230.         i_cost4 = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
  2231.                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
  2233.         h->mb.b_transform_8x8 = i_cost8 < i_cost4;
  2234.         h->mb.b_skip_mc = 1;
  2235.     }
  2236. }
  2238. static inline void x264_mb_analyse_transform_rd( x264_t *h, x264_mb_analysis_t *a, int *i_satd, int *i_rd )
  2239. {
  2240.     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 )
  2241.     {
  2242.         int i_rd8;
  2243.         x264_analyse_update_cache( h, a );
  2244.         h->mb.b_transform_8x8 ^= 1;
  2245.         /* FIXME only luma is needed, but the score for comparison already includes chroma */
  2246.         i_rd8 = x264_rd_cost_mb( h, a->i_lambda2 );
  2248.         if( *i_rd >= i_rd8 )
  2249.         {
  2250.             if( *i_rd > 0 )
  2251.                 *i_satd = (int64_t)(*i_satd) * i_rd8 / *i_rd;
  2252.             *i_rd = i_rd8;
  2253.         }
  2254.         else
  2255.             h->mb.b_transform_8x8 ^= 1;
  2256.     }
  2257. }
  2259. /* Rate-distortion optimal QP selection.
  2260.  * FIXME: More than half of the benefit of this function seems to be
  2261.  * in the way it improves the coding of chroma DC (by decimating or
  2262.  * finding a better way to code a single DC coefficient.)
  2263.  * There must be a more efficient way to get that portion of the benefit
  2264.  * without doing full QP-RD, but RD-decimation doesn't seem to do the
  2265.  * trick. */
  2266. static inline void x264_mb_analyse_qp_rd( x264_t *h, x264_mb_analysis_t *a )
  2267. {
  2268.     int bcost, cost, direction, failures, prevcost, origcost;
  2269.     int orig_qp = h->mb.i_qp, bqp = h->mb.i_qp;
  2270.     int last_qp_tried = 0;
  2271.     origcost = bcost = x264_rd_cost_mb( h, a->i_lambda2 );
  2273.     /* If CBP is already zero, don't raise the quantizer any higher. */
  2274.     for( direction = h->mb.cbp[h->mb.i_mb_xy] ? 1 : -1; direction >= -1; direction-=2 )
  2275.     {
  2276.         /* Without psy-RD, require monotonicity when moving quant away from previous
  2277.          * macroblock's quant; allow 1 failure when moving quant towards previous quant.
  2278.          * With psy-RD, allow 1 failure when moving quant away from previous quant,
  2279.          * allow 2 failures when moving quant towards previous quant.
  2280.          * Psy-RD generally seems to result in more chaotic RD score-vs-quantizer curves. */
  2281.         int threshold = (!!h->mb.i_psy_rd);
  2282.         /* Raise the threshold for failures if we're moving towards the last QP. */
  2283.         if( ( h->mb.i_last_qp < orig_qp && direction == -1 ) ||
  2284.             ( h->mb.i_last_qp > orig_qp && direction ==  1 ) )
  2285.             threshold++;
  2286.         h->mb.i_qp = orig_qp;
  2287.         failures = 0;
  2288.         prevcost = origcost;
  2289.         h->mb.i_qp += direction;
  2290.         while( h->mb.i_qp >= h->param.rc.i_qp_min && h->mb.i_qp <= h->param.rc.i_qp_max )
  2291.         {
  2292.             if( h->mb.i_last_qp == h->mb.i_qp )
  2293.                 last_qp_tried = 1;
  2294.             h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
  2295.             cost = x264_rd_cost_mb( h, a->i_lambda2 );
  2296.             COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
  2298.             /* We can't assume that the costs are monotonic over QPs.
  2299.              * Tie case-as-failure seems to give better results. */
  2300.             if( cost < prevcost )
  2301.                 failures = 0;
  2302.             else
  2303.                 failures++;
  2304.             prevcost = cost;
  2306.             if( failures > threshold )
  2307.                 break;
  2308.             if( direction == 1 && !h->mb.cbp[h->mb.i_mb_xy] )
  2309.                 break;
  2310.             h->mb.i_qp += direction;
  2311.         }
  2312.     }
  2314.     /* Always try the last block's QP. */
  2315.     if( !last_qp_tried )
  2316.     {
  2317.         h->mb.i_qp = h->mb.i_last_qp;
  2318.         h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
  2319.         cost = x264_rd_cost_mb( h, a->i_lambda2 );
  2320.         COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
  2321.     }
  2323.     h->mb.i_qp = bqp;
  2324.     h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
  2326.     /* Check transform again; decision from before may no longer be optimal. */
  2327.     if( h->mb.i_qp != orig_qp && h->param.analyse.b_transform_8x8 &&
  2328.         x264_mb_transform_8x8_allowed( h ) )
  2329.     {
  2330.         h->mb.b_transform_8x8 ^= 1;
  2331.         cost = x264_rd_cost_mb( h, a->i_lambda2 );
  2332.         if( cost > bcost )
  2333.             h->mb.b_transform_8x8 ^= 1;
  2334.     }
  2335. }
  2337. /*****************************************************************************
  2338.  * x264_macroblock_analyse:
  2339.  *****************************************************************************/
  2340. void x264_macroblock_analyse( x264_t *h )
  2341. {
  2342.     x264_mb_analysis_t analysis;
  2343.     int i_cost = COST_MAX;
  2344.     int i;
  2346.     h->mb.i_qp = x264_ratecontrol_qp( h );
  2347.     if( h->param.rc.i_aq_mode )
  2348.     {
  2349.         x264_adaptive_quant( h );
  2350.         /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
  2351.          * to lower the bit cost of the qp_delta.  Don't do this if QPRD is enabled. */
  2352.         if( h->param.analyse.i_subpel_refine < 10 && abs(h->mb.i_qp - h->mb.i_last_qp) == 1 )
  2353.             h->mb.i_qp = h->mb.i_last_qp;
  2354.     }
  2356.     x264_mb_analyse_init( h, &analysis, h->mb.i_qp );
  2358.     /*--------------------------- Do the analysis ---------------------------*/
  2359.     if( h->sh.i_type == SLICE_TYPE_I )
  2360.     {
  2361.         if( analysis.i_mbrd )
  2362.             x264_mb_cache_fenc_satd( h );
  2363.         x264_mb_analyse_intra( h, &analysis, COST_MAX );
  2364.         if( analysis.i_mbrd )
  2365.             x264_intra_rd( h, &analysis, COST_MAX );
  2367.         i_cost = analysis.i_satd_i16x16;
  2368.         h->mb.i_type = I_16x16;
  2369.         COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, h->mb.i_type, I_4x4 );
  2370.         COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, h->mb.i_type, I_8x8 );
  2371.         if( analysis.i_satd_pcm < i_cost )
  2372.             h->mb.i_type = I_PCM;
  2374.         else if( analysis.i_mbrd >= 2 )
  2375.             x264_intra_rd_refine( h, &analysis );
  2376.     }
  2377.     else if( h->sh.i_type == SLICE_TYPE_P )
  2378.     {
  2379.         int b_skip = 0;
  2381.         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 0 );
  2383.         /* Fast P_SKIP detection */
  2384.         analysis.b_try_pskip = 0;
  2385.         if( h->param.analyse.b_fast_pskip )
  2386.         {
  2387.             if( h->param.i_threads > 1 && h->mb.cache.pskip_mv[1] > h->mb.mv_max_spel[1] )
  2388.                 // FIXME don't need to check this if the reference frame is done
  2389.                 {}
  2390.             else if( h->param.analyse.i_subpel_refine >= 3 )
  2391.                 analysis.b_try_pskip = 1;
  2392.             else if( h->mb.i_mb_type_left == P_SKIP ||
  2393.                      h->mb.i_mb_type_top == P_SKIP ||
  2394.                      h->mb.i_mb_type_topleft == P_SKIP ||
  2395.                      h->mb.i_mb_type_topright == P_SKIP )
  2396.                 b_skip = x264_macroblock_probe_pskip( h );
  2397.         }
  2399.         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 1 );
  2401.         if( b_skip )
  2402.         {
  2403.             h->mb.i_type = P_SKIP;
  2404.             h->mb.i_partition = D_16x16;
  2405.             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
  2406.         }
  2407.         else
  2408.         {
  2409.             const unsigned int flags = h->param.analyse.inter;
  2410.             int i_type;
  2411.             int i_partition;
  2412.             int i_thresh16x8;
  2413.             int i_satd_inter, i_satd_intra;
  2415.             x264_mb_analyse_load_costs( h, &analysis );
  2417.             x264_mb_analyse_inter_p16x16( h, &analysis );
  2419.             if( h->mb.i_type == P_SKIP )
  2420.                 return;
  2422.             if( flags & X264_ANALYSE_PSUB16x16 )
  2423.             {
  2424.                 if( h->param.analyse.b_mixed_references )
  2425.                     x264_mb_analyse_inter_p8x8_mixed_ref( h, &analysis );
  2426.                 else
  2427.                     x264_mb_analyse_inter_p8x8( h, &analysis );
  2428.             }
  2430.             /* Select best inter mode */
  2431.             i_type = P_L0;
  2432.             i_partition = D_16x16;
  2433.             i_cost = analysis.l0.me16x16.cost;
  2435.             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
  2436.                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
  2437.             {
  2438.                 i_type = P_8x8;
  2439.                 i_partition = D_8x8;
  2440.                 i_cost = analysis.l0.i_cost8x8;
  2442.                 /* Do sub 8x8 */
  2443.                 if( flags & X264_ANALYSE_PSUB8x8 )
  2444.                 {
  2445.                     for( i = 0; i < 4; i++ )
  2446.                     {
  2447.                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
  2448.                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
  2449.                         {
  2450.                             int i_cost8x8 = analysis.l0.i_cost4x4[i];
  2451.                             h->mb.i_sub_partition[i] = D_L0_4x4;
  2453.                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
  2454.                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost8x4[i],
  2455.                                          h->mb.i_sub_partition[i], D_L0_8x4 );
  2457.                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
  2458.                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost4x8[i],
  2459.                                          h->mb.i_sub_partition[i], D_L0_4x8 );
  2461.                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
  2462.                         }
  2463.                         x264_mb_cache_mv_p8x8( h, &analysis, i );
  2464.                     }
  2465.                     analysis.l0.i_cost8x8 = i_cost;
  2466.                 }
  2467.             }
  2469.             /* Now do 16x8/8x16 */
  2470.             i_thresh16x8 = analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[2].cost_mv;
  2471.             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
  2472.                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost + i_thresh16x8 )
  2473.             {
  2474.                 x264_mb_analyse_inter_p16x8( h, &analysis );
  2475.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost16x8, i_type, P_L0, i_partition, D_16x8 );
  2477.                 x264_mb_analyse_inter_p8x16( h, &analysis );
  2478.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x16, i_type, P_L0, i_partition, D_8x16 );
  2479.             }
  2481.             h->mb.i_partition = i_partition;
  2483.             /* refine qpel */
  2484.             //FIXME mb_type costs?
  2485.             if( analysis.i_mbrd )
  2486.             {
  2487.                 /* refine later */
  2488.             }
  2489.             else if( i_partition == D_16x16 )
  2490.             {
  2491.                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
  2492.                 i_cost = analysis.l0.me16x16.cost;
  2493.             }
  2494.             else if( i_partition == D_16x8 )
  2495.             {
  2496.                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
  2497.                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
  2498.                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
  2499.             }
  2500.             else if( i_partition == D_8x16 )
  2501.             {
  2502.                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
  2503.                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
  2504.                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
  2505.             }
  2506.             else if( i_partition == D_8x8 )
  2507.             {
  2508.                 int i8x8;
  2509.                 i_cost = 0;
  2510.                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
  2511.                 {
  2512.                     switch( h->mb.i_sub_partition[i8x8] )
  2513.                     {
  2514.                         case D_L0_8x8:
  2515.                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
  2516.                             i_cost += analysis.l0.me8x8[i8x8].cost;
  2517.                             break;
  2518.                         case D_L0_8x4:
  2519.                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
  2520.                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
  2521.                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
  2522.                                       analysis.l0.me8x4[i8x8][1].cost;
  2523.                             break;
  2524.                         case D_L0_4x8:
  2525.                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
  2526.                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
  2527.                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
  2528.                                       analysis.l0.me4x8[i8x8][1].cost;
  2529.                             break;
  2531.                         case D_L0_4x4:
  2532.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
  2533.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
  2534.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
  2535.                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
  2536.                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
  2537.                                       analysis.l0.me4x4[i8x8][1].cost +
  2538.                                       analysis.l0.me4x4[i8x8][2].cost +
  2539.                                       analysis.l0.me4x4[i8x8][3].cost;
  2540.                             break;
  2541.                         default:
  2542.                             x264_log( h, X264_LOG_ERROR, "internal error (!8x8 && !4x4)n" );
  2543.                             break;
  2544.                     }
  2545.                 }
  2546.             }
  2548.             if( h->mb.b_chroma_me )
  2549.             {
  2550.                 x264_mb_analyse_intra_chroma( h, &analysis );
  2551.                 x264_mb_analyse_intra( h, &analysis, i_cost - analysis.i_satd_i8x8chroma );
  2552.                 analysis.i_satd_i16x16 += analysis.i_satd_i8x8chroma;
  2553.                 analysis.i_satd_i8x8 += analysis.i_satd_i8x8chroma;
  2554.                 analysis.i_satd_i4x4 += analysis.i_satd_i8x8chroma;
  2555.             }
  2556.             else
  2557.                 x264_mb_analyse_intra( h, &analysis, i_cost );
  2559.             i_satd_inter = i_cost;
  2560.             i_satd_intra = X264_MIN3( analysis.i_satd_i16x16,
  2561.                                       analysis.i_satd_i8x8,
  2562.                                       analysis.i_satd_i4x4 );
  2564.             if( analysis.i_mbrd )
  2565.             {
  2566.                 x264_mb_analyse_p_rd( h, &analysis, X264_MIN(i_satd_inter, i_satd_intra) );
  2567.                 i_type = P_L0;
  2568.                 i_partition = D_16x16;
  2569.                 i_cost = analysis.l0.i_rd16x16;
  2570.                 COPY2_IF_LT( i_cost, analysis.l0.i_cost16x8, i_partition, D_16x8 );
  2571.                 COPY2_IF_LT( i_cost, analysis.l0.i_cost8x16, i_partition, D_8x16 );
  2572.                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x8, i_partition, D_8x8, i_type, P_8x8 );
  2573.                 h->mb.i_type = i_type;
  2574.                 h->mb.i_partition = i_partition;
  2575.                 if( i_cost < COST_MAX )
  2576.                     x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
  2577.                 x264_intra_rd( h, &analysis, i_satd_inter * 5/4 );
  2578.             }
  2580.             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
  2581.             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
  2582.             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
  2583.             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
  2585.             h->mb.i_type = i_type;
  2587.             if( analysis.i_mbrd >= 2 && h->mb.i_type != I_PCM )
  2588.             {
  2589.                 if( IS_INTRA( h->mb.i_type ) )
  2590.                 {
  2591.                     x264_intra_rd_refine( h, &analysis );
  2592.                 }
  2593.                 else if( i_partition == D_16x16 )
  2594.                 {
  2595.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.i_ref );
  2596.                     analysis.l0.me16x16.cost = i_cost;
  2597.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
  2598.                 }
  2599.                 else if( i_partition == D_16x8 )
  2600.                 {
  2601.                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  2602.                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  2603.                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].i_ref );
  2604.                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].i_ref );
  2605.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[0], analysis.i_lambda2, 0, 0 );
  2606.                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[1], analysis.i_lambda2, 8, 0 );
  2607.                 }
  2608.                 else if( i_partition == D_8x16 )
  2609.                 {
  2610.                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
  2611.                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
  2612.                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].i_ref );
  2613.                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].i_ref );
  2614.                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[0], analysis.i_lambda2, 0, 0 );
  2615.                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[1], analysis.i_lambda2, 4, 0 );
  2616.                 }
  2617.                 else if( i_partition == D_8x8 )
  2618.                 {
  2619.                     int i8x8;
  2620.                     x264_analyse_update_cache( h, &analysis );
  2621.                     for( i8x8 = 0; i8x8 < 4; i8x8++ )
  2622.                     {
  2623.                         if( h->mb.i_sub_partition[i8x8] == D_L0_8x8 )
  2624.                         {
  2625.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i8x8], analysis.i_lambda2, i8x8*4, 0 );
  2626.                         }
  2627.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_8x4 )
  2628.                         {
  2629.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  2630.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][1], analysis.i_lambda2, i8x8*4+2, 0 );
  2631.                         }
  2632.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x8 )
  2633.                         {
  2634.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  2635.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
  2636.                         }
  2637.                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x4 )
  2638.                         {
  2639.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
  2640.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
  2641.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][2], analysis.i_lambda2, i8x8*4+2, 0 );
  2642.                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][3], analysis.i_lambda2, i8x8*4+3, 0 );
  2643.                         }
  2644.                     }
  2645.                 }
  2646.             }
  2647.         }
  2648.     }
  2649.     else if( h->sh.i_type == SLICE_TYPE_B )
  2650.     {
  2651.         int i_bskip_cost = COST_MAX;
  2652.         int b_skip = 0;
  2654.         if( analysis.i_mbrd )
  2655.             x264_mb_cache_fenc_satd( h );
  2657.         h->mb.i_type = B_SKIP;
  2658.         if( h->mb.b_direct_auto_write )
  2659.         {
  2660.             /* direct=auto heuristic: prefer whichever mode allows more Skip macroblocks */
  2661.             for( i = 0; i < 2; i++ )
  2662.             {
  2663.                 int b_changed = 1;
  2664.                 h->sh.b_direct_spatial_mv_pred ^= 1;
  2665.                 analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, i && analysis.b_direct_available ? &b_changed : NULL );
  2666.                 if( analysis.b_direct_available )
  2667.                 {
  2668.                     if( b_changed )
  2669.                     {
  2670.                         x264_mb_mc( h );
  2671.                         b_skip = x264_macroblock_probe_bskip( h );
  2672.                     }
  2673.                     h->stat.frame.i_direct_score[ h->sh.b_direct_spatial_mv_pred ] += b_skip;
  2674.                 }
  2675.                 else
  2676.                     b_skip = 0;
  2677.             }
  2678.         }
  2679.         else
  2680.             analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, NULL );
  2682.         if( analysis.b_direct_available )
  2683.         {
  2684.             if( !h->mb.b_direct_auto_write )
  2685.                 x264_mb_mc( h );
  2686.             if( analysis.i_mbrd )
  2687.             {
  2688.                 i_bskip_cost = ssd_mb( h );
  2689.                 /* 6 = minimum cavlc cost of a non-skipped MB */
  2690.                 b_skip = h->mb.b_skip_mc = i_bskip_cost <= ((6 * analysis.i_lambda2 + 128) >> 8);
  2691.             }
  2692.             else if( !h->mb.b_direct_auto_write )
  2693.             {
  2694.                 /* Conditioning the probe on neighboring block types
  2695.                  * doesn't seem to help speed or quality. */
  2696.                 b_skip = x264_macroblock_probe_bskip( h );
  2697.             }
  2698.         }
  2700.         if( !b_skip )
  2701.         {
  2702.             const unsigned int flags = h->param.analyse.inter;
  2703.             int i_type;
  2704.             int i_partition;
  2705.             int i_satd_inter;
  2706.             h->mb.b_skip_mc = 0;
  2708.             x264_mb_analyse_load_costs( h, &analysis );
  2710.             /* select best inter mode */
  2711.             /* direct must be first */
  2712.             if( analysis.b_direct_available )
  2713.                 x264_mb_analyse_inter_direct( h, &analysis );
  2715.             x264_mb_analyse_inter_b16x16( h, &analysis );
  2717.             i_type = B_L0_L0;
  2718.             i_partition = D_16x16;
  2719.             i_cost = analysis.l0.me16x16.cost;
  2720.             COPY2_IF_LT( i_cost, analysis.l1.me16x16.cost, i_type, B_L1_L1 );
  2721.             COPY2_IF_LT( i_cost, analysis.i_cost16x16bi, i_type, B_BI_BI );
  2722.             COPY2_IF_LT( i_cost, analysis.i_cost16x16direct, i_type, B_DIRECT );
  2724.             if( analysis.i_mbrd && analysis.i_cost16x16direct <= i_cost * 33/32 )
  2725.             {
  2726.                 x264_mb_analyse_b_rd( h, &analysis, i_cost );
  2727.                 if( i_bskip_cost < analysis.i_rd16x16direct &&
  2728.                     i_bskip_cost < analysis.i_rd16x16bi &&
  2729.                     i_bskip_cost < analysis.l0.i_rd16x16 &&
  2730.                     i_bskip_cost < analysis.l1.i_rd16x16 )
  2731.                 {
  2732.                     h->mb.i_type = B_SKIP;
  2733.                     x264_analyse_update_cache( h, &analysis );
  2734.                     return;
  2735.                 }
  2736.             }
  2738.             if( flags & X264_ANALYSE_BSUB16x16 )
  2739.             {
  2740.                 x264_mb_analyse_inter_b8x8( h, &analysis );
  2741.                 if( analysis.i_cost8x8bi < i_cost )
  2742.                 {
  2743.                     i_type = B_8x8;
  2744.                     i_partition = D_8x8;
  2745.                     i_cost = analysis.i_cost8x8bi;
  2747.                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[1] ||
  2748.                         h->mb.i_sub_partition[2] == h->mb.i_sub_partition[3] )
  2749.                     {
  2750.                         x264_mb_analyse_inter_b16x8( h, &analysis );
  2751.                         COPY3_IF_LT( i_cost, analysis.i_cost16x8bi,
  2752.                                      i_type, analysis.i_mb_type16x8,
  2753.                                      i_partition, D_16x8 );
  2754.                     }
  2755.                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[2] ||
  2756.                         h->mb.i_sub_partition[1] == h->mb.i_sub_partition[3] )
  2757.                     {
  2758.                         x264_mb_analyse_inter_b8x16( h, &analysis );
  2759.                         COPY3_IF_LT( i_cost, analysis.i_cost8x16bi,
  2760.                                      i_type, analysis.i_mb_type8x16,
  2761.                                      i_partition, D_8x16 );
  2762.                     }
  2763.                 }
  2764.             }
  2766.             if( analysis.i_mbrd )
  2767.             {
  2768.                 /* refine later */
  2769.             }
  2770.             /* refine qpel */
  2771.             else if( i_partition == D_16x16 )
  2772.             {
  2773.                 analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
  2774.                 analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
  2775.                 if( i_type == B_L0_L0 )
  2776.                 {
  2777.                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
  2778.                     i_cost = analysis.l0.me16x16.cost
  2779.                            + analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
  2780.                 }
  2781.                 else if( i_type == B_L1_L1 )
  2782.                 {
  2783.                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
  2784.                     i_cost = analysis.l1.me16x16.cost
  2785.                            + analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
  2786.                 }
  2787.                 else if( i_type == B_BI_BI )
  2788.                 {
  2789.                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
  2790.                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
  2791.                 }
  2792.             }
  2793.             else if( i_partition == D_16x8 )
  2794.             {
  2795.                 for( i=0; i<2; i++ )
  2796.                 {
  2797.                     if( analysis.i_mb_partition16x8[i] != D_L1_8x8 )
  2798.                         x264_me_refine_qpel( h, &analysis.l0.me16x8[i] );
  2799.                     if( analysis.i_mb_partition16x8[i] != D_L0_8x8 )
  2800.                         x264_me_refine_qpel( h, &analysis.l1.me16x8[i] );
  2801.                 }
  2802.             }
  2803.             else if( i_partition == D_8x16 )
  2804.             {
  2805.                 for( i=0; i<2; i++ )
  2806.                 {
  2807.                     if( analysis.i_mb_partition8x16[i] != D_L1_8x8 )
  2808.                         x264_me_refine_qpel( h, &analysis.l0.me8x16[i] );
  2809.                     if( analysis.i_mb_partition8x16[i] != D_L0_8x8 )
  2810.                         x264_me_refine_qpel( h, &analysis.l1.me8x16[i] );
  2811.                 }
  2812.             }
  2813.             else if( i_partition == D_8x8 )
  2814.             {
  2815.                 for( i=0; i<4; i++ )
  2816.                 {
  2817.                     x264_me_t *m;
  2818.                     int i_part_cost_old;
  2819.                     int i_type_cost;
  2820.                     int i_part_type = h->mb.i_sub_partition[i];
  2821.                     int b_bidir = (i_part_type == D_BI_8x8);
  2823.                     if( i_part_type == D_DIRECT_8x8 )
  2824.                         continue;
  2825.                     if( x264_mb_partition_listX_table[0][i_part_type] )
  2826.                     {
  2827.                         m = &analysis.l0.me8x8[i];
  2828.                         i_part_cost_old = m->cost;
  2829.                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
  2830.                         m->cost -= i_type_cost;
  2831.                         x264_me_refine_qpel( h, m );
  2832.                         if( !b_bidir )
  2833.                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
  2834.                     }
  2835.                     if( x264_mb_partition_listX_table[1][i_part_type] )
  2836.                     {
  2837.                         m = &analysis.l1.me8x8[i];
  2838.                         i_part_cost_old = m->cost;
  2839.                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
  2840.                         m->cost -= i_type_cost;
  2841.                         x264_me_refine_qpel( h, m );
  2842.                         if( !b_bidir )
  2843.                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
  2844.                     }
  2845.                     /* TODO: update mvp? */
  2846.                 }
  2847.             }
  2849.             i_satd_inter = i_cost;
  2851.             if( analysis.i_mbrd )
  2852.             {
  2853.                 x264_mb_analyse_b_rd( h, &analysis, i_satd_inter );
  2854.                 i_type = B_SKIP;
  2855.                 i_cost = i_bskip_cost;
  2856.                 i_partition = D_16x16;
  2857.                 COPY2_IF_LT( i_cost, analysis.l0.i_rd16x16, i_type, B_L0_L0 );
  2858.                 COPY2_IF_LT( i_cost, analysis.l1.i_rd16x16, i_type, B_L1_L1 );
  2859.                 COPY2_IF_LT( i_cost, analysis.i_rd16x16bi, i_type, B_BI_BI );
  2860.                 COPY2_IF_LT( i_cost, analysis.i_rd16x16direct, i_type, B_DIRECT );
  2861.                 COPY3_IF_LT( i_cost, analysis.i_rd16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
  2862.                 COPY3_IF_LT( i_cost, analysis.i_rd8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
  2863.                 COPY3_IF_LT( i_cost, analysis.i_rd8x8bi, i_type, B_8x8, i_partition, D_8x8 );
  2865.                 h->mb.i_type = i_type;
  2866.                 h->mb.i_partition = i_partition;
  2867.             }
  2869.             x264_mb_analyse_intra( h, &analysis, i_satd_inter );
  2871.             if( analysis.i_mbrd )
  2872.             {
  2873.                 x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
  2874.                 x264_intra_rd( h, &analysis, i_satd_inter * 17/16 );
  2875.             }
  2877.             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
  2878.             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
  2879.             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
  2880.             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
  2882.             h->mb.i_type = i_type;
  2883.             h->mb.i_partition = i_partition;
  2885.             if( analysis.i_mbrd >= 2 && IS_INTRA( i_type ) && i_type != I_PCM )
  2886.                 x264_intra_rd_refine( h, &analysis );
  2887.             if( h->mb.i_subpel_refine >= 5 )
  2888.                 x264_refine_bidir( h, &analysis );
  2890.             if( analysis.i_mbrd >= 2 && i_type > B_DIRECT && i_type < B_SKIP )
  2891.             {
  2892.                 const int i_biweight = h->mb.bipred_weight[analysis.l0.i_ref][analysis.l1.i_ref];
  2893.                 x264_analyse_update_cache( h, &analysis );
  2895.                 if( i_partition == D_16x16 )
  2896.                 {
  2897.                     if( i_type == B_L0_L0 )
  2898.                     {
  2899.                         analysis.l0.me16x16.cost = i_cost;
  2900.                         x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
  2901.                     }
  2902.                     else if( i_type == B_L1_L1 )
  2903.                     {
  2904.                         analysis.l1.me16x16.cost = i_cost;
  2905.                         x264_me_refine_qpel_rd( h, &analysis.l1.me16x16, analysis.i_lambda2, 0, 1 );
  2906.                     }
  2907.                     else if( i_type == B_BI_BI )
  2908.                         x264_me_refine_bidir_rd( h, &analysis.l0.me16x16, &analysis.l1.me16x16, i_biweight, 0, analysis.i_lambda2 );
  2909.                 }
  2910.                 else if( i_partition == D_16x8 )
  2911.                 {
  2912.                     for( i = 0; i < 2; i++ )
  2913.                     {
  2914.                         h->mb.i_sub_partition[i*2] = h->mb.i_sub_partition[i*2+1] = analysis.i_mb_partition16x8[i];
  2915.                         if( analysis.i_mb_partition16x8[i] == D_L0_8x8 )
  2916.                             x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[i], analysis.i_lambda2, i*8, 0 );
  2917.                         else if( analysis.i_mb_partition16x8[i] == D_L1_8x8 )
  2918.                             x264_me_refine_qpel_rd( h, &analysis.l1.me16x8[i], analysis.i_lambda2, i*8, 1 );
  2919.                         else if( analysis.i_mb_partition16x8[i] == D_BI_8x8 )
  2920.                             x264_me_refine_bidir_rd( h, &analysis.l0.me16x8[i], &analysis.l1.me16x8[i], i_biweight, i*2, analysis.i_lambda2 );
  2921.                     }
  2922.                 }
  2923.                 else if( i_partition == D_8x16 )
  2924.                 {
  2925.                     for( i = 0; i < 2; i++ )
  2926.                     {
  2927.                         h->mb.i_sub_partition[i] = h->mb.i_sub_partition[i+2] = analysis.i_mb_partition8x16[i];
  2928.                         if( analysis.i_mb_partition8x16[i] == D_L0_8x8 )
  2929.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[i], analysis.i_lambda2, i*4, 0 );
  2930.                         else if( analysis.i_mb_partition8x16[i] == D_L1_8x8 )
  2931.                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x16[i], analysis.i_lambda2, i*4, 1 );
  2932.                         else if( analysis.i_mb_partition8x16[i] == D_BI_8x8 )
  2933.                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x16[i], &analysis.l1.me8x16[i], i_biweight, i, analysis.i_lambda2 );
  2934.                     }
  2935.                 }
  2936.                 else if( i_partition == D_8x8 )
  2937.                 {
  2938.                     for( i = 0; i < 4; i++ )
  2939.                     {
  2940.                         if( h->mb.i_sub_partition[i] == D_L0_8x8 )
  2941.                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i], analysis.i_lambda2, i*4, 0 );
  2942.                         else if( h->mb.i_sub_partition[i] == D_L1_8x8 )
  2943.                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x8[i], analysis.i_lambda2, i*4, 1 );
  2944.                         else if( h->mb.i_sub_partition[i] == D_BI_8x8 )
  2945.                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x8[i], &analysis.l1.me8x8[i], i_biweight, i, analysis.i_lambda2 );
  2946.                     }
  2947.                 }
  2948.             }
  2949.         }
  2950.     }
  2952.     x264_analyse_update_cache( h, &analysis );
  2954.     /* In rare cases we can end up qpel-RDing our way back to a larger partition size
  2955.      * without realizing it.  Check for this and account for it if necessary. */
  2956.     if( analysis.i_mbrd >= 2 )
  2957.     {
  2958.         /* Don't bother with bipred or 8x8-and-below, the odds are incredibly low. */
  2959. //C不支持这种数组赋值 --@lia
  2960. static /*const*/ uint8_t check_mv_lists[X264_MBTYPE_MAX] = {0};//{[P_L0]=1, [B_L0_L0]=1, [B_L1_L1]=2};
  2961.         int list = check_mv_lists[h->mb.i_type] - 1;
  2963. //C不支持这种数组赋值 --@lia
  2964. check_mv_lists[4]=1;
  2965. check_mv_lists[8]=1;
  2966. check_mv_lists[12]=2;
  2968.         if( list >= 0 && h->mb.i_partition != D_16x16 &&
  2969.             *(uint32_t*)&h->mb.cache.mv[list][x264_scan8[0]] == *(uint32_t*)&h->mb.cache.mv[list][x264_scan8[12]] &&
  2970.             h->mb.cache.ref[list][x264_scan8[0]] == h->mb.cache.ref[list][x264_scan8[12]] )
  2971.                 h->mb.i_partition = D_16x16;
  2972.     }
  2974.     if( !analysis.i_mbrd )
  2975.         x264_mb_analyse_transform( h );
  2977.     if( analysis.i_mbrd == 3 && !IS_SKIP(h->mb.i_type) )
  2978.         x264_mb_analyse_qp_rd( h, &analysis );
  2980.     h->mb.b_trellis = h->param.analyse.i_trellis;
  2981.     h->mb.b_noise_reduction = !!h->param.analyse.i_noise_reduction;
  2982.     if( !IS_SKIP(h->mb.i_type) && h->mb.i_psy_trellis && h->param.analyse.i_trellis == 1 )
  2983.         x264_psy_trellis_init( h, 0 );
  2984.     if( h->mb.b_trellis == 1 || h->mb.b_noise_reduction )
  2985.         h->mb.i_skip_intra = 0;
  2986. }
  2988. /*-------------------- Update MB from the analysis ----------------------*/
  2989. static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a  )
  2990. {
  2991.     int i;
  2993.     switch( h->mb.i_type )
  2994.     {
  2995.         case I_4x4:
  2996.             for( i = 0; i < 16; i++ )
  2997.                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = a->i_predict4x4[i];
  2999.             x264_mb_analyse_intra_chroma( h, a );
  3000.             break;
  3001.         case I_8x8:
  3002.             for( i = 0; i < 4; i++ )
  3003.                 x264_macroblock_cache_intra8x8_pred( h, 2*(i&1), 2*(i>>1), a->i_predict8x8[i] );
  3005.             x264_mb_analyse_intra_chroma( h, a );
  3006.             break;
  3007.         case I_16x16:
  3008.             h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
  3009.             x264_mb_analyse_intra_chroma( h, a );
  3010.             break;
  3012.         case I_PCM:
  3013.             break;
  3015.         case P_L0:
  3016.             switch( h->mb.i_partition )
  3017.             {
  3018.                 case D_16x16:
  3019.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
  3020.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
  3021.                     break;
  3023.                 case D_16x8:
  3024.                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].i_ref );
  3025.                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].i_ref );
  3026.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].mv );
  3027.                     x264_macroblock_cache_mv_ptr( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].mv );
  3028.                     break;
  3030.                 case D_8x16:
  3031.                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].i_ref );
  3032.                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].i_ref );
  3033.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].mv );
  3034.                     x264_macroblock_cache_mv_ptr( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].mv );
  3035.                     break;
  3037.                 default:
  3038.                     x264_log( h, X264_LOG_ERROR, "internal error P_L0 and partition=%dn", h->mb.i_partition );
  3039.                     break;
  3040.             }
  3041.             break;
  3043.         case P_8x8:
  3044.             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
  3045.             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
  3046.             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
  3047.             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
  3048.             for( i = 0; i < 4; i++ )
  3049.                 x264_mb_cache_mv_p8x8( h, a, i );
  3050.             break;
  3052.         case P_SKIP:
  3053.         {
  3054.             h->mb.i_partition = D_16x16;
  3055.             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
  3056.             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, h->mb.cache.pskip_mv );
  3057.             break;
  3058.         }
  3060.         case B_SKIP:
  3061.         case B_DIRECT:
  3062.             x264_mb_load_mv_direct8x8( h, 0 );
  3063.             x264_mb_load_mv_direct8x8( h, 1 );
  3064.             x264_mb_load_mv_direct8x8( h, 2 );
  3065.             x264_mb_load_mv_direct8x8( h, 3 );
  3066.             break;
  3068.         case B_8x8:
  3069.             /* optimize: cache might not need to be rewritten */
  3070.             for( i = 0; i < 4; i++ )
  3071.                 x264_mb_cache_mv_b8x8( h, a, i, 1 );
  3072.             break;
  3074.         default: /* the rest of the B types */
  3075.             switch( h->mb.i_partition )
  3076.             {
  3077.             case D_16x16:
  3078.                 switch( h->mb.i_type )
  3079.                 {
  3080.                 case B_L0_L0:
  3081.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
  3082.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
  3084.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
  3085.                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, 0 );
  3086.                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1, 0 );
  3087.                     break;
  3088.                 case B_L1_L1:
  3089.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
  3090.                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, 0 );
  3091.                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0, 0 );
  3093.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
  3094.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
  3095.                     break;
  3096.                 case B_BI_BI:
  3097.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
  3098.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
  3100.                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
  3101.                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
  3102.                     break;
  3103.                 }
  3104.                 break;
  3105.             case D_16x8:
  3106.                 x264_mb_cache_mv_b16x8( h, a, 0, 1 );
  3107.                 x264_mb_cache_mv_b16x8( h, a, 1, 1 );
  3108.                 break;
  3109.             case D_8x16:
  3110.                 x264_mb_cache_mv_b8x16( h, a, 0, 1 );
  3111.                 x264_mb_cache_mv_b8x16( h, a, 1, 1 );
  3112.                 break;
  3113.             default:
  3114.                 x264_log( h, X264_LOG_ERROR, "internal error (invalid MB type)n" );
  3115.                 break;
  3116.             }
  3117.     }
  3119. #ifndef NDEBUG
  3120.     if( h->param.i_threads > 1 && !IS_INTRA(h->mb.i_type) )
  3121.     {
  3122.         int l;
  3123.         for( l=0; l <= (h->sh.i_type == SLICE_TYPE_B); l++ )
  3124.         {
  3125.             int completed;
  3126.             int ref = h->mb.cache.ref[l][x264_scan8[0]];
  3127.             if( ref < 0 )
  3128.                 continue;
  3129.             completed = (l ? h->fref1 : h->fref0)[ ref >> h->mb.b_interlaced ]->i_lines_completed;
  3130.             if( (h->mb.cache.mv[l][x264_scan8[15]][1] >> (2 - h->mb.b_interlaced)) + h->mb.i_mb_y*16 > completed )
  3131.             {
  3132.                 x264_log( h, X264_LOG_WARNING, "internal error (MV out of thread range)n");
  3133.                 fprintf(stderr, "mb type: %d n", h->mb.i_type);
  3134.                 fprintf(stderr, "mv: l%dr%d (%d,%d) n", l, ref,
  3135.                                 h->mb.cache.mv[l][x264_scan8[15]][0],
  3136.                                 h->mb.cache.mv[l][x264_scan8[15]][1] );
  3137.                 fprintf(stderr, "limit: %d n", h->mb.mv_max_spel[1]);
  3138.                 fprintf(stderr, "mb_xy: %d,%d n", h->mb.i_mb_x, h->mb.i_mb_y);
  3139.                 fprintf(stderr, "completed: %d n", completed );
  3140.                 x264_log( h, X264_LOG_WARNING, "recovering by using intra moden");
  3141.                 x264_mb_analyse_intra( h, a, COST_MAX );
  3142.                 h->mb.i_type = I_16x16;
  3143.                 h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
  3144.                 x264_mb_analyse_intra_chroma( h, a );
  3145.             }
  3146.         }
  3147.     }
  3148. #endif
  3149. }
  3151. #include "slicetype.c"