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

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

Audio

开发平台：

Visual C++

encoder.c：源码内容
  1. /*****************************************************************************
  2.  * x264: h264 encoder
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: encoder.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <math.h>
  28. #ifdef __WIN32__
  29. #include <windows.h>
  30. #define pthread_t               HANDLE
  31. #define pthread_create(t,u,f,d) *(t)=CreateThread(NULL,0,f,d,0,NULL)
  32. #define pthread_join(t,s)       { WaitForSingleObject(t,INFINITE); 
  33.                                   CloseHandle(t); } 
  34. #define HAVE_PTHREAD 1
  36. #elif defined(SYS_BEOS)
  37. #include <kernel/OS.h>
  38. #define pthread_t               thread_id
  39. #define pthread_create(t,u,f,d) { *(t)=spawn_thread(f,"",10,d); 
  40.                                   resume_thread(*(t)); }
  41. #define pthread_join(t,s)       wait_for_thread(t,(long*)s)
  42. #define HAVE_PTHREAD 1
  44. #elif HAVE_PTHREAD
  45. #include <pthread.h>
  46. #endif
  48. #include "common/common.h"
  49. #include "common/cpu.h"
  51. #include "set.h"
  52. #include "analyse.h"
  53. #include "ratecontrol.h"
  54. #include "macroblock.h"
  56. #if VISUALIZE
  57. #include "common/visualize.h"
  58. #endif
  60. //#define DEBUG_MB_TYPE
  61. //#define DEBUG_DUMP_FRAME
  62. //#define DEBUG_BENCHMARK
  64. #ifdef DEBUG_BENCHMARK
  65. static int64_t i_mtime_encode_frame = 0;
  66. static int64_t i_mtime_analyse = 0;
  67. static int64_t i_mtime_encode = 0;
  68. static int64_t i_mtime_write = 0;
  69. static int64_t i_mtime_filter = 0;
  70. #define TIMER_START( d ) 
  71.     { 
  72.         int64_t d##start = x264_mdate();
  74. #define TIMER_STOP( d ) 
  75.         d += x264_mdate() - d##start;
  76.     }
  77. #else
  78. #define TIMER_START( d )
  79. #define TIMER_STOP( d )
  80. #endif
  82. #define NALU_OVERHEAD 5 // startcode + NAL type costs 5 bytes per frame
  84. /****************************************************************************
  85.  *
  86.  ******************************* x264 libs **********************************
  87.  *
  88.  ****************************************************************************/
  89. static float x264_psnr( int64_t i_sqe, int64_t i_size )
  90. {
  91.     double f_mse = (double)i_sqe / ((double)65025.0 * (double)i_size);
  92.     if( f_mse <= 0.0000000001 ) /* Max 100dB */
  93.         return 100;
  95.     return (float)(-10.0 * log( f_mse ) / log( 10.0 ));
  96. }
  98. #ifdef DEBUG_DUMP_FRAME
  99. static void x264_frame_dump( x264_t *h, x264_frame_t *fr, char *name )
  100. {
  101.     FILE * f = fopen( name, "a" );
  102.     int i, y;
  104.     fseek( f, 0, SEEK_END );
  106.     for( i = 0; i < fr->i_plane; i++ )
  107.     {
  108.         for( y = 0; y < h->param.i_height / ( i == 0 ? 1 : 2 ); y++ )
  109.         {
  110.             fwrite( &fr->plane[i][y*fr->i_stride[i]], 1, h->param.i_width / ( i == 0 ? 1 : 2 ), f );
  111.         }
  112.     }
  113.     fclose( f );
  114. }
  115. #endif
  118. /* Fill "default" values */
  119. static void x264_slice_header_init( x264_t *h, x264_slice_header_t *sh,
  120.                                     x264_sps_t *sps, x264_pps_t *pps,
  121.                                     int i_type, int i_idr_pic_id, int i_frame, int i_qp )
  122. {
  123.     x264_param_t *param = &h->param;
  124.     int i;
  126.     /* First we fill all field */
  127.     sh->sps = sps;
  128.     sh->pps = pps;
  130.     sh->i_type      = i_type;
  131.     sh->i_first_mb  = 0;
  132.     sh->i_last_mb   = h->sps->i_mb_width * h->sps->i_mb_height;
  133.     sh->i_pps_id    = pps->i_id;
  135.     sh->i_frame_num = i_frame;
  137.     sh->b_field_pic = 0;    /* Not field support for now */
  138.     sh->b_bottom_field = 1; /* not yet used */
  140.     sh->i_idr_pic_id = i_idr_pic_id;
  142.     /* poc stuff, fixed later */
  143.     sh->i_poc_lsb = 0;
  144.     sh->i_delta_poc_bottom = 0;
  145.     sh->i_delta_poc[0] = 0;
  146.     sh->i_delta_poc[1] = 0;
  148.     sh->i_redundant_pic_cnt = 0;
  150.     if( !h->mb.b_direct_auto_read )
  151.     {
  152.         if( h->mb.b_direct_auto_write )
  153.             sh->b_direct_spatial_mv_pred = ( h->stat.i_direct_score[1] > h->stat.i_direct_score[0] );
  154.         else
  155.             sh->b_direct_spatial_mv_pred = ( param->analyse.i_direct_mv_pred == X264_DIRECT_PRED_SPATIAL );
  156.     }
  157.     /* else b_direct_spatial_mv_pred was read from the 2pass statsfile */
  159.     sh->b_num_ref_idx_override = 0;
  160.     sh->i_num_ref_idx_l0_active = 1;
  161.     sh->i_num_ref_idx_l1_active = 1;
  163.     sh->b_ref_pic_list_reordering_l0 = h->b_ref_reorder[0];
  164.     sh->b_ref_pic_list_reordering_l1 = h->b_ref_reorder[1];
  166.     /* If the ref list isn't in the default order, construct reordering header */
  167.     /* List1 reordering isn't needed yet */
  168.     if( sh->b_ref_pic_list_reordering_l0 )
  169.     {
  170.         int pred_frame_num = i_frame;
  171.         for( i = 0; i < h->i_ref0; i++ )
  172.         {
  173.             int diff = h->fref0[i]->i_frame_num - pred_frame_num;
  174.             if( diff == 0 )
  175.                 x264_log( h, X264_LOG_ERROR, "diff frame num == 0n" );
  176.             sh->ref_pic_list_order[0][i].idc = ( diff > 0 );
  177.             sh->ref_pic_list_order[0][i].arg = abs( diff ) - 1;
  178.             pred_frame_num = h->fref0[i]->i_frame_num;
  179.         }
  180.     }
  182.     sh->i_cabac_init_idc = param->i_cabac_init_idc;
  184.     sh->i_qp = i_qp;
  185.     sh->i_qp_delta = i_qp - pps->i_pic_init_qp;
  186.     sh->b_sp_for_swidth = 0;
  187.     sh->i_qs_delta = 0;
  189.     /* If effective qp <= 15, deblocking would have no effect anyway */
  190.     if( param->b_deblocking_filter
  191.         && ( h->mb.b_variable_qp
  192.         || 15 < i_qp + X264_MAX(param->i_deblocking_filter_alphac0, param->i_deblocking_filter_beta) ) )
  193.     {
  194.         sh->i_disable_deblocking_filter_idc = 0;
  195.     }
  196.     else
  197.     {
  198.         sh->i_disable_deblocking_filter_idc = 1;
  199.     }
  200.     sh->i_alpha_c0_offset = param->i_deblocking_filter_alphac0 << 1;
  201.     sh->i_beta_offset = param->i_deblocking_filter_beta << 1;
  202. }
  204. static void x264_slice_header_write( bs_t *s, x264_slice_header_t *sh, int i_nal_ref_idc )
  205. {
  206.     int i;
  208.     bs_write_ue( s, sh->i_first_mb );
  209.     bs_write_ue( s, sh->i_type + 5 );   /* same type things */
  210.     bs_write_ue( s, sh->i_pps_id );
  211.     bs_write( s, sh->sps->i_log2_max_frame_num, sh->i_frame_num );
  213.     if( sh->i_idr_pic_id >= 0 ) /* NAL IDR */
  214.     {
  215.         bs_write_ue( s, sh->i_idr_pic_id );
  216.     }
  218.     if( sh->sps->i_poc_type == 0 )
  219.     {
  220.         bs_write( s, sh->sps->i_log2_max_poc_lsb, sh->i_poc_lsb );
  221.         if( sh->pps->b_pic_order && !sh->b_field_pic )
  222.         {
  223.             bs_write_se( s, sh->i_delta_poc_bottom );
  224.         }
  225.     }
  226.     else if( sh->sps->i_poc_type == 1 && !sh->sps->b_delta_pic_order_always_zero )
  227.     {
  228.         bs_write_se( s, sh->i_delta_poc[0] );
  229.         if( sh->pps->b_pic_order && !sh->b_field_pic )
  230.         {
  231.             bs_write_se( s, sh->i_delta_poc[1] );
  232.         }
  233.     }
  235.     if( sh->pps->b_redundant_pic_cnt )
  236.     {
  237.         bs_write_ue( s, sh->i_redundant_pic_cnt );
  238.     }
  240.     if( sh->i_type == SLICE_TYPE_B )
  241.     {
  242.         bs_write1( s, sh->b_direct_spatial_mv_pred );
  243.     }
  244.     if( sh->i_type == SLICE_TYPE_P || sh->i_type == SLICE_TYPE_SP || sh->i_type == SLICE_TYPE_B )
  245.     {
  246.         bs_write1( s, sh->b_num_ref_idx_override );
  247.         if( sh->b_num_ref_idx_override )
  248.         {
  249.             bs_write_ue( s, sh->i_num_ref_idx_l0_active - 1 );
  250.             if( sh->i_type == SLICE_TYPE_B )
  251.             {
  252.                 bs_write_ue( s, sh->i_num_ref_idx_l1_active - 1 );
  253.             }
  254.         }
  255.     }
  257.     /* ref pic list reordering */
  258.     if( sh->i_type != SLICE_TYPE_I )
  259.     {
  260.         bs_write1( s, sh->b_ref_pic_list_reordering_l0 );
  261.         if( sh->b_ref_pic_list_reordering_l0 )
  262.         {
  263.             for( i = 0; i < sh->i_num_ref_idx_l0_active; i++ )
  264.             {
  265.                 bs_write_ue( s, sh->ref_pic_list_order[0][i].idc );
  266.                 bs_write_ue( s, sh->ref_pic_list_order[0][i].arg );
  267.                         
  268.             }
  269.             bs_write_ue( s, 3 );
  270.         }
  271.     }
  272.     if( sh->i_type == SLICE_TYPE_B )
  273.     {
  274.         bs_write1( s, sh->b_ref_pic_list_reordering_l1 );
  275.         if( sh->b_ref_pic_list_reordering_l1 )
  276.         {
  277.             for( i = 0; i < sh->i_num_ref_idx_l1_active; i++ )
  278.             {
  279.                 bs_write_ue( s, sh->ref_pic_list_order[1][i].idc );
  280.                 bs_write_ue( s, sh->ref_pic_list_order[1][i].arg );
  281.             }
  282.             bs_write_ue( s, 3 );
  283.         }
  284.     }
  286.     if( ( sh->pps->b_weighted_pred && ( sh->i_type == SLICE_TYPE_P || sh->i_type == SLICE_TYPE_SP ) ) ||
  287.         ( sh->pps->b_weighted_bipred == 1 && sh->i_type == SLICE_TYPE_B ) )
  288.     {
  289.         /* FIXME */
  290.     }
  292.     if( i_nal_ref_idc != 0 )
  293.     {
  294.         if( sh->i_idr_pic_id >= 0 )
  295.         {
  296.             bs_write1( s, 0 );  /* no output of prior pics flag */
  297.             bs_write1( s, 0 );  /* long term reference flag */
  298.         }
  299.         else
  300.         {
  301.             bs_write1( s, 0 );  /* adaptive_ref_pic_marking_mode_flag */
  302.         }
  303.     }
  305.     if( sh->pps->b_cabac && sh->i_type != SLICE_TYPE_I )
  306.     {
  307.         bs_write_ue( s, sh->i_cabac_init_idc );
  308.     }
  309.     bs_write_se( s, sh->i_qp_delta );      /* slice qp delta */
  311.     if( sh->pps->b_deblocking_filter_control )
  312.     {
  313.         bs_write_ue( s, sh->i_disable_deblocking_filter_idc );
  314.         if( sh->i_disable_deblocking_filter_idc != 1 )
  315.         {
  316.             bs_write_se( s, sh->i_alpha_c0_offset >> 1 );
  317.             bs_write_se( s, sh->i_beta_offset >> 1 );
  318.         }
  319.     }
  320. }
  322. /****************************************************************************
  323.  *
  324.  ****************************************************************************
  325.  ****************************** External API*********************************
  326.  ****************************************************************************
  327.  *
  328.  ****************************************************************************/
  330. static int x264_validate_parameters( x264_t *h )
  331. {
  332.     if( h->param.i_width <= 0 || h->param.i_height <= 0 )
  333.     {
  334.         x264_log( h, X264_LOG_ERROR, "invalid width x height (%dx%d)n",
  335.                   h->param.i_width, h->param.i_height );
  336.         return -1;
  337.     }
  339.     if( h->param.i_width % 2 || h->param.i_height % 2 )
  340.     {
  341.         x264_log( h, X264_LOG_ERROR, "width or height not divisible by 2 (%dx%d)n",
  342.                   h->param.i_width, h->param.i_height );
  343.         return -1;
  344.     }
  345.     if( h->param.i_csp != X264_CSP_I420 )
  346.     {
  347.         x264_log( h, X264_LOG_ERROR, "invalid CSP (only I420 supported)n" );
  348.         return -1;
  349.     }
  351.     h->param.i_threads = x264_clip3( h->param.i_threads, 1, X264_SLICE_MAX );
  352.     h->param.i_threads = X264_MIN( h->param.i_threads, (h->param.i_height + 15) / 16 );
  353. #if !(HAVE_PTHREAD)
  354.     if( h->param.i_threads > 1 )
  355.     {
  356.         x264_log( h, X264_LOG_WARNING, "not compiled with pthread support!n");
  357.         x264_log( h, X264_LOG_WARNING, "multislicing anyway, but you won't see any speed gain.n" );
  358.     }
  359. #endif
  361.     if( h->param.rc.b_cbr )
  362.         h->param.rc.i_rf_constant = 0;
  363.     if( h->param.rc.i_rf_constant > 0 )
  364.         h->param.rc.i_qp_constant = h->param.rc.i_rf_constant;
  365.     h->param.rc.i_rf_constant = x264_clip3( h->param.rc.i_rf_constant, 0, 51 );
  366.     h->param.rc.i_qp_constant = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
  367.     if( !h->param.rc.b_cbr && h->param.rc.i_qp_constant == 0 )
  368.     {
  369.         h->mb.b_lossless = 1;
  370.         h->param.analyse.b_transform_8x8 = 0;
  371.         h->param.i_cqm_preset = X264_CQM_FLAT;
  372.         h->param.psz_cqm_file = NULL;
  373.         h->param.rc.f_ip_factor = 1;
  374.         h->param.rc.f_pb_factor = 1;
  375.         h->param.analyse.b_psnr = 0;
  376.         h->param.analyse.i_chroma_qp_offset = 0;
  377.         h->param.analyse.i_trellis = 0;
  378.         h->param.analyse.b_fast_pskip = 0;
  379.         h->param.analyse.i_noise_reduction = 0;
  380.     }
  382.     if( ( h->param.i_width % 16 || h->param.i_height % 16 ) && !h->mb.b_lossless )
  383.     {
  384.         x264_log( h, X264_LOG_WARNING, 
  385.                   "width or height not divisible by 16 (%dx%d), compression will suffer.n",
  386.                   h->param.i_width, h->param.i_height );
  387.     }
  389.     h->param.i_frame_reference = x264_clip3( h->param.i_frame_reference, 1, 16 );
  390.     if( h->param.i_keyint_max <= 0 )
  391.         h->param.i_keyint_max = 1;
  392.     h->param.i_keyint_min = x264_clip3( h->param.i_keyint_min, 1, h->param.i_keyint_max/2+1 );
  394.     h->param.i_bframe = x264_clip3( h->param.i_bframe, 0, X264_BFRAME_MAX );
  395.     h->param.i_bframe_bias = x264_clip3( h->param.i_bframe_bias, -90, 100 );
  396.     h->param.b_bframe_pyramid = h->param.b_bframe_pyramid && h->param.i_bframe > 1;
  397.     h->param.b_bframe_adaptive = h->param.b_bframe_adaptive && h->param.i_bframe > 0;
  398.     h->mb.b_direct_auto_write = h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO
  399.                                 && h->param.i_bframe
  400.                                 && ( h->param.rc.b_stat_write || !h->param.rc.b_stat_read );
  402.     h->param.i_deblocking_filter_alphac0 = x264_clip3( h->param.i_deblocking_filter_alphac0, -6, 6 );
  403.     h->param.i_deblocking_filter_beta    = x264_clip3( h->param.i_deblocking_filter_beta, -6, 6 );
  405.     h->param.i_cabac_init_idc = x264_clip3( h->param.i_cabac_init_idc, 0, 2 );
  407.     if( h->param.i_cqm_preset < X264_CQM_FLAT || h->param.i_cqm_preset > X264_CQM_CUSTOM )
  408.         h->param.i_cqm_preset = X264_CQM_FLAT;
  410.     if( h->param.analyse.i_me_method < X264_ME_DIA ||
  411.         h->param.analyse.i_me_method > X264_ME_ESA )
  412.         h->param.analyse.i_me_method = X264_ME_HEX;
  413.     if( h->param.analyse.i_me_range < 4 )
  414.         h->param.analyse.i_me_range = 4;
  415.     if( h->param.analyse.i_me_range > 16 && h->param.analyse.i_me_method <= X264_ME_HEX )
  416.         h->param.analyse.i_me_range = 16;
  417.     h->param.analyse.i_subpel_refine = x264_clip3( h->param.analyse.i_subpel_refine, 1, 6 );
  418.     h->param.analyse.b_bframe_rdo = h->param.analyse.b_bframe_rdo && h->param.analyse.i_subpel_refine >= 6;
  419.     h->param.analyse.b_mixed_references = h->param.analyse.b_mixed_references && h->param.i_frame_reference > 1;
  420.     h->param.analyse.inter &= X264_ANALYSE_PSUB16x16|X264_ANALYSE_PSUB8x8|X264_ANALYSE_BSUB16x16|
  421.                               X264_ANALYSE_I4x4|X264_ANALYSE_I8x8;
  422.     h->param.analyse.intra &= X264_ANALYSE_I4x4|X264_ANALYSE_I8x8;
  423.     if( !(h->param.analyse.inter & X264_ANALYSE_PSUB16x16) )
  424.         h->param.analyse.inter &= ~X264_ANALYSE_PSUB8x8;
  425.     if( !h->param.analyse.b_transform_8x8 )
  426.     {
  427.         h->param.analyse.inter &= ~X264_ANALYSE_I8x8;
  428.         h->param.analyse.intra &= ~X264_ANALYSE_I8x8;
  429.     }
  430.     h->param.analyse.i_chroma_qp_offset = x264_clip3(h->param.analyse.i_chroma_qp_offset, -12, 12);
  431.     if( !h->param.b_cabac )
  432.         h->param.analyse.i_trellis = 0;
  433.     h->param.analyse.i_trellis = x264_clip3( h->param.analyse.i_trellis, 0, 2 );
  434.     h->param.analyse.i_noise_reduction = x264_clip3( h->param.analyse.i_noise_reduction, 0, 1<<16 );
  436.     {
  437.         const x264_level_t *l = x264_levels;
  438.         while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
  439.             l++;
  440.         if( l->level_idc == 0 )
  441.         {
  442.             x264_log( h, X264_LOG_ERROR, "invalid level_idc: %dn", h->param.i_level_idc );
  443.             return -1;
  444.         }
  445.         if( h->param.analyse.i_mv_range <= 0 )
  446.             h->param.analyse.i_mv_range = l->mv_range;
  447.         else
  448.             h->param.analyse.i_mv_range = x264_clip3(h->param.analyse.i_mv_range, 32, 2048);
  449.     }
  451.     if( h->param.rc.f_qblur < 0 )
  452.         h->param.rc.f_qblur = 0;
  453.     if( h->param.rc.f_complexity_blur < 0 )
  454.         h->param.rc.f_complexity_blur = 0;
  456.     /* ensure the booleans are 0 or 1 so they can be used in math */
  457. #define BOOLIFY(x) h->param.x = !!h->param.x
  458.     BOOLIFY( b_cabac );
  459.     BOOLIFY( b_deblocking_filter );
  460.     BOOLIFY( analyse.b_transform_8x8 );
  461.     BOOLIFY( analyse.b_weighted_bipred );
  462.     BOOLIFY( analyse.b_bidir_me );
  463.     BOOLIFY( analyse.b_chroma_me );
  464.     BOOLIFY( analyse.b_fast_pskip );
  465.     BOOLIFY( rc.b_cbr );
  466.     BOOLIFY( rc.b_stat_write );
  467.     BOOLIFY( rc.b_stat_read );
  468. #undef BOOLIFY
  470.     return 0;
  471. }
  473. /****************************************************************************
  474.  * x264_encoder_open:
  475.  ****************************************************************************/
  476. x264_t *x264_encoder_open   ( x264_param_t *param )
  477. {
  478.     x264_t *h = x264_malloc( sizeof( x264_t ) );
  479.     int i;
  481.     memset( h, 0, sizeof( x264_t ) );
  483.     /* Create a copy of param */
  484.     memcpy( &h->param, param, sizeof( x264_param_t ) );
  486.     if( x264_validate_parameters( h ) < 0 )
  487.     {
  488.         x264_free( h );
  489.         return NULL;
  490.     }
  492.     if( h->param.psz_cqm_file )
  493.         if( x264_cqm_parse_file( h, h->param.psz_cqm_file ) < 0 )
  494.         {
  495.             x264_free( h );
  496.             return NULL;
  497.         }
  499.     if( h->param.rc.psz_stat_out )
  500.         h->param.rc.psz_stat_out = strdup( h->param.rc.psz_stat_out );
  501.     if( h->param.rc.psz_stat_in )
  502.         h->param.rc.psz_stat_in = strdup( h->param.rc.psz_stat_in );
  503.     if( h->param.rc.psz_rc_eq )
  504.         h->param.rc.psz_rc_eq = strdup( h->param.rc.psz_rc_eq );
  506.     /* VUI */
  507.     if( h->param.vui.i_sar_width > 0 && h->param.vui.i_sar_height > 0 )
  508.     {
  509.         int i_w = param->vui.i_sar_width;
  510.         int i_h = param->vui.i_sar_height;
  511.         int a = i_w, b = i_h;
  513.         while( b != 0 )
  514.         {
  515.             int t = a;
  517.             a = b;
  518.             b = t % b;
  519.         }
  521.         i_w /= a;
  522.         i_h /= a;
  523.         while( i_w > 65535 || i_h > 65535 )
  524.         {
  525.             i_w /= 2;
  526.             i_h /= 2;
  527.         }
  529.         h->param.vui.i_sar_width = 0;
  530.         h->param.vui.i_sar_height = 0;
  531.         if( i_w == 0 || i_h == 0 )
  532.         {
  533.             x264_log( h, X264_LOG_ERROR, "cannot create valid sample aspect ration" );
  534.         }
  535.         else if( i_w == i_h )
  536.         {
  537.             x264_log( h, X264_LOG_INFO, "no need for a SARn" );
  538.         }
  539.         else
  540.         {
  541.             x264_log( h, X264_LOG_INFO, "using SAR=%d/%dn", i_w, i_h );
  542.             h->param.vui.i_sar_width = i_w;
  543.             h->param.vui.i_sar_height = i_h;
  544.         }
  545.     }
  548.     /* Init x264_t */
  549.     h->out.i_nal = 0;
  550.     h->out.i_bitstream = X264_MAX( 1000000, h->param.i_width * h->param.i_height * 1.7
  551.         * ( h->param.rc.b_cbr ? pow( 0.5, h->param.rc.i_qp_min )
  552.           : pow( 0.5, h->param.rc.i_qp_constant ) * X264_MAX( 1, h->param.rc.f_ip_factor )));
  553.     h->out.p_bitstream = x264_malloc( h->out.i_bitstream );
  555.     h->i_frame = 0;
  556.     h->i_frame_num = 0;
  557.     h->i_idr_pic_id = 0;
  559.     h->sps = &h->sps_array[0];
  560.     x264_sps_init( h->sps, 0, &h->param );
  562.     h->pps = &h->pps_array[0];
  563.     x264_pps_init( h->pps, 0, &h->param, h->sps);
  565.     x264_validate_levels( h );
  567.     x264_cqm_init( h );
  568.     
  569.     h->mb.i_mb_count = h->sps->i_mb_width * h->sps->i_mb_height;
  571.     /* Init frames. */
  572.     h->frames.i_delay = h->param.i_bframe;
  573.     h->frames.i_max_ref0 = h->param.i_frame_reference;
  574.     h->frames.i_max_ref1 = h->sps->vui.i_num_reorder_frames;
  575.     h->frames.i_max_dpb  = h->sps->vui.i_max_dec_frame_buffering + 1;
  576.     h->frames.b_have_lowres = !h->param.rc.b_stat_read
  577.         && ( h->param.rc.b_cbr || h->param.rc.i_rf_constant || h->param.b_bframe_adaptive );
  579.     for( i = 0; i < X264_BFRAME_MAX + 3; i++ )
  580.     {
  581.         h->frames.current[i] = NULL;
  582.         h->frames.next[i]    = NULL;
  583.         h->frames.unused[i]  = NULL;
  584.     }
  585.     for( i = 0; i < 1 + h->frames.i_delay; i++ )
  586.     {
  587.         h->frames.unused[i] =  x264_frame_new( h );
  588.     }
  589.     for( i = 0; i < h->frames.i_max_dpb; i++ )
  590.     {
  591.         h->frames.reference[i] = x264_frame_new( h );
  592.     }
  593.     h->frames.reference[h->frames.i_max_dpb] = NULL;
  594.     h->frames.i_last_idr = - h->param.i_keyint_max;
  595.     h->frames.i_input    = 0;
  596.     h->frames.last_nonb  = NULL;
  598.     h->i_ref0 = 0;
  599.     h->i_ref1 = 0;
  601.     h->fdec = h->frames.reference[0];
  603.     x264_macroblock_cache_init( h );
  604.     x264_rdo_init( );
  606.     /* init CPU functions */
  607.     x264_predict_16x16_init( h->param.cpu, h->predict_16x16 );
  608.     x264_predict_8x8c_init( h->param.cpu, h->predict_8x8c );
  609.     x264_predict_8x8_init( h->param.cpu, h->predict_8x8 );
  610.     x264_predict_4x4_init( h->param.cpu, h->predict_4x4 );
  612.     x264_pixel_init( h->param.cpu, &h->pixf );
  613.     x264_dct_init( h->param.cpu, &h->dctf );
  614.     x264_mc_init( h->param.cpu, &h->mc );
  615.     x264_csp_init( h->param.cpu, h->param.i_csp, &h->csp );
  616.     x264_quant_init( h, h->param.cpu, &h->quantf );
  617.     x264_deblock_init( h->param.cpu, &h->loopf );
  619.     memcpy( h->pixf.mbcmp,
  620.             ( h->mb.b_lossless || h->param.analyse.i_subpel_refine <= 1 ) ? h->pixf.sad : h->pixf.satd,
  621.             sizeof(h->pixf.mbcmp) );
  623.     /* rate control */
  624.     if( x264_ratecontrol_new( h ) < 0 )
  625.         return NULL;
  627.     x264_log( h, X264_LOG_INFO, "using cpu capabilities %s%s%s%s%s%sn",
  628.              param->cpu&X264_CPU_MMX ? "MMX " : "",
  629.              param->cpu&X264_CPU_MMXEXT ? "MMXEXT " : "",
  630.              param->cpu&X264_CPU_SSE ? "SSE " : "",
  631.              param->cpu&X264_CPU_SSE2 ? "SSE2 " : "",
  632.              param->cpu&X264_CPU_3DNOW ? "3DNow! " : "",
  633.              param->cpu&X264_CPU_ALTIVEC ? "Altivec " : "" );
  635.     h->thread[0] = h;
  636.     for( i = 1; i < param->i_threads; i++ )
  637.         h->thread[i] = x264_malloc( sizeof(x264_t) );
  639.     return h;
  640. }
  642. /****************************************************************************
  643.  * x264_encoder_reconfig:
  644.  ****************************************************************************/
  645. int x264_encoder_reconfig( x264_t *h, x264_param_t *param )
  646. {
  647.     h->param.i_bframe_bias = param->i_bframe_bias;
  648.     h->param.i_deblocking_filter_alphac0 = param->i_deblocking_filter_alphac0;
  649.     h->param.i_deblocking_filter_beta    = param->i_deblocking_filter_beta;
  650.     h->param.analyse.i_me_method = param->analyse.i_me_method;
  651.     h->param.analyse.i_me_range = param->analyse.i_me_range;
  652.     h->param.analyse.i_subpel_refine = param->analyse.i_subpel_refine;
  653.     h->param.analyse.i_trellis = param->analyse.i_trellis;
  654.     h->param.analyse.intra = param->analyse.intra;
  655.     h->param.analyse.inter = param->analyse.inter;
  657.     memcpy( h->pixf.mbcmp,
  658.             ( h->mb.b_lossless || h->param.analyse.i_subpel_refine <= 1 ) ? h->pixf.sad : h->pixf.satd,
  659.             sizeof(h->pixf.mbcmp) );
  661.     return x264_validate_parameters( h );
  662. }
  664. /* internal usage */
  665. static void x264_nal_start( x264_t *h, int i_type, int i_ref_idc )
  666. {
  667.     x264_nal_t *nal = &h->out.nal[h->out.i_nal];
  669.     nal->i_ref_idc = i_ref_idc;
  670.     nal->i_type    = i_type;
  672.     bs_align_0( &h->out.bs );   /* not needed */
  674.     nal->i_payload= 0;
  675.     nal->p_payload= &h->out.p_bitstream[bs_pos( &h->out.bs) / 8];
  676. }
  677. static void x264_nal_end( x264_t *h )
  678. {
  679.     x264_nal_t *nal = &h->out.nal[h->out.i_nal];
  681.     bs_align_0( &h->out.bs );   /* not needed */
  683.     nal->i_payload = &h->out.p_bitstream[bs_pos( &h->out.bs)/8] - nal->p_payload;
  685.     h->out.i_nal++;
  686. }
  688. /****************************************************************************
  689.  * x264_encoder_headers:
  690.  ****************************************************************************/
  691. int x264_encoder_headers( x264_t *h, x264_nal_t **pp_nal, int *pi_nal )
  692. {
  693.     /* init bitstream context */
  694.     h->out.i_nal = 0;
  695.     bs_init( &h->out.bs, h->out.p_bitstream, h->out.i_bitstream );
  697.     /* Put SPS and PPS */
  698.     if( h->i_frame == 0 )
  699.     {
  700.         /* identify ourself */
  701.         x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
  702.         x264_sei_version_write( h, &h->out.bs );
  703.         x264_nal_end( h );
  705.         /* generate sequence parameters */
  706.         x264_nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
  707.         x264_sps_write( &h->out.bs, h->sps );
  708.         x264_nal_end( h );
  710.         /* generate picture parameters */
  711.         x264_nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
  712.         x264_pps_write( &h->out.bs, h->pps );
  713.         x264_nal_end( h );
  714.     }
  715.     /* now set output*/
  716.     *pi_nal = h->out.i_nal;
  717.     *pp_nal = &h->out.nal[0];
  719.     return 0;
  720. }
  723. static void x264_frame_put( x264_frame_t *list[X264_BFRAME_MAX], x264_frame_t *frame )
  724. {
  725.     int i = 0;
  726.     while( list[i] ) i++;
  727.     list[i] = frame;
  728. }
  730. static void x264_frame_push( x264_frame_t *list[X264_BFRAME_MAX], x264_frame_t *frame )
  731. {
  732.     int i = 0;
  733.     while( list[i] ) i++;
  734.     while( i-- )
  735.         list[i+1] = list[i];
  736.     list[0] = frame;
  737. }
  739. static x264_frame_t *x264_frame_get( x264_frame_t *list[X264_BFRAME_MAX+1] )
  740. {
  741.     x264_frame_t *frame = list[0];
  742.     int i;
  743.     for( i = 0; list[i]; i++ )
  744.         list[i] = list[i+1];
  745.     return frame;
  746. }
  748. static void x264_frame_sort( x264_frame_t *list[X264_BFRAME_MAX+1], int b_dts )
  749. {
  750.     int i, b_ok;
  751.     do {
  752.         b_ok = 1;
  753.         for( i = 0; list[i+1]; i++ )
  754.         {
  755.             int dtype = list[i]->i_type - list[i+1]->i_type;
  756.             int dtime = list[i]->i_frame - list[i+1]->i_frame;
  757.             int swap = b_dts ? dtype > 0 || ( dtype == 0 && dtime > 0 )
  758.                              : dtime > 0;
  759.             if( swap )
  760.             {
  761.                 XCHG( x264_frame_t*, list[i], list[i+1] );
  762.                 b_ok = 0;
  763.             }
  764.         }
  765.     } while( !b_ok );
  766. }
  767. #define x264_frame_sort_dts(list) x264_frame_sort(list, 1)
  768. #define x264_frame_sort_pts(list) x264_frame_sort(list, 0)
  770. static inline void x264_reference_build_list( x264_t *h, int i_poc, int i_slice_type )
  771. {
  772.     int i;
  773.     int b_ok;
  775.     /* build ref list 0/1 */
  776.     h->i_ref0 = 0;
  777.     h->i_ref1 = 0;
  778.     for( i = 1; i < h->frames.i_max_dpb; i++ )
  779.     {
  780.         if( h->frames.reference[i]->i_poc >= 0 )
  781.         {
  782.             if( h->frames.reference[i]->i_poc < i_poc )
  783.             {
  784.                 h->fref0[h->i_ref0++] = h->frames.reference[i];
  785.             }
  786.             else if( h->frames.reference[i]->i_poc > i_poc )
  787.             {
  788.                 h->fref1[h->i_ref1++] = h->frames.reference[i];
  789.             }
  790.         }
  791.     }
  793.     /* Order ref0 from higher to lower poc */
  794.     do
  795.     {
  796.         b_ok = 1;
  797.         for( i = 0; i < h->i_ref0 - 1; i++ )
  798.         {
  799.             if( h->fref0[i]->i_poc < h->fref0[i+1]->i_poc )
  800.             {
  801.                 XCHG( x264_frame_t*, h->fref0[i], h->fref0[i+1] );
  802.                 b_ok = 0;
  803.                 break;
  804.             }
  805.         }
  806.     } while( !b_ok );
  807.     /* Order ref1 from lower to higher poc (bubble sort) for B-frame */
  808.     do
  809.     {
  810.         b_ok = 1;
  811.         for( i = 0; i < h->i_ref1 - 1; i++ )
  812.         {
  813.             if( h->fref1[i]->i_poc > h->fref1[i+1]->i_poc )
  814.             {
  815.                 XCHG( x264_frame_t*, h->fref1[i], h->fref1[i+1] );
  816.                 b_ok = 0;
  817.                 break;
  818.             }
  819.         }
  820.     } while( !b_ok );
  822.     /* In the standard, a P-frame's ref list is sorted by frame_num.
  823.      * We use POC, but check whether explicit reordering is needed */
  824.     h->b_ref_reorder[0] =
  825.     h->b_ref_reorder[1] = 0;
  826.     if( i_slice_type == SLICE_TYPE_P )
  827.     {
  828.         for( i = 0; i < h->i_ref0 - 1; i++ )
  829.             if( h->fref0[i]->i_frame_num < h->fref0[i+1]->i_frame_num )
  830.             {
  831.                 h->b_ref_reorder[0] = 1;
  832.                 break;
  833.             }
  834.     }
  836.     h->i_ref1 = X264_MIN( h->i_ref1, h->frames.i_max_ref1 );
  837.     h->i_ref0 = X264_MIN( h->i_ref0, h->frames.i_max_ref0 );
  838.     h->i_ref0 = X264_MIN( h->i_ref0, 16 - h->i_ref1 );
  839. }
  841. static inline void x264_reference_update( x264_t *h )
  842. {
  843.     int i;
  845.     /* apply deblocking filter to the current decoded picture */
  846.     if( !h->sh.i_disable_deblocking_filter_idc )
  847.     {
  848.         TIMER_START( i_mtime_filter );
  849.         x264_frame_deblocking_filter( h, h->sh.i_type );
  850.         TIMER_STOP( i_mtime_filter );
  851.     }
  852.     /* expand border */
  853.     x264_frame_expand_border( h->fdec );
  855.     /* create filtered images */
  856.     x264_frame_filter( h->param.cpu, h->fdec );
  858.     /* expand border of filtered images */
  859.     x264_frame_expand_border_filtered( h->fdec );
  861.     /* move lowres copy of the image to the ref frame */
  862.     for( i = 0; i < 4; i++)
  863.         XCHG( uint8_t*, h->fdec->lowres[i], h->fenc->lowres[i] );
  865.     /* adaptive B decision needs a pointer, since it can't use the ref lists */
  866.     if( h->sh.i_type != SLICE_TYPE_B )
  867.         h->frames.last_nonb = h->fdec;
  869.     /* move frame in the buffer */
  870.     h->fdec = h->frames.reference[h->frames.i_max_dpb-1];
  871.     for( i = h->frames.i_max_dpb-1; i > 0; i-- )
  872.     {
  873.         h->frames.reference[i] = h->frames.reference[i-1];
  874.     }
  875.     h->frames.reference[0] = h->fdec;
  876. }
  878. static inline void x264_reference_reset( x264_t *h )
  879. {
  880.     int i;
  882.     /* reset ref pictures */
  883.     for( i = 1; i < h->frames.i_max_dpb; i++ )
  884.     {
  885.         h->frames.reference[i]->i_poc = -1;
  886.     }
  887.     h->frames.reference[0]->i_poc = 0;
  888. }
  890. static inline void x264_slice_init( x264_t *h, int i_nal_type, int i_slice_type, int i_global_qp )
  891. {
  892.     /* ------------------------ Create slice header  ----------------------- */
  893.     if( i_nal_type == NAL_SLICE_IDR )
  894.     {
  895.         x264_slice_header_init( h, &h->sh, h->sps, h->pps, i_slice_type, h->i_idr_pic_id, h->i_frame_num - 1, i_global_qp );
  897.         /* increment id */
  898.         h->i_idr_pic_id = ( h->i_idr_pic_id + 1 ) % 65536;
  899.     }
  900.     else
  901.     {
  902.         x264_slice_header_init( h, &h->sh, h->sps, h->pps, i_slice_type, -1, h->i_frame_num - 1, i_global_qp );
  904.         /* always set the real higher num of ref frame used */
  905.         h->sh.b_num_ref_idx_override = 1;
  906.         h->sh.i_num_ref_idx_l0_active = h->i_ref0 <= 0 ? 1 : h->i_ref0;
  907.         h->sh.i_num_ref_idx_l1_active = h->i_ref1 <= 0 ? 1 : h->i_ref1;
  908.     }
  910.     h->fdec->i_frame_num = h->sh.i_frame_num;
  912.     if( h->sps->i_poc_type == 0 )
  913.     {
  914.         h->sh.i_poc_lsb = h->fdec->i_poc & ( (1 << h->sps->i_log2_max_poc_lsb) - 1 );
  915.         h->sh.i_delta_poc_bottom = 0;   /* XXX won't work for field */
  916.     }
  917.     else if( h->sps->i_poc_type == 1 )
  918.     {
  919.         /* FIXME TODO FIXME */
  920.     }
  921.     else
  922.     {
  923.         /* Nothing to do ? */
  924.     }
  926.     x264_macroblock_slice_init( h );
  927. }
  929. static int x264_slice_write( x264_t *h )
  930. {
  931.     int i_skip;
  932.     int mb_xy;
  933.     int i;
  935.     /* init stats */
  936.     memset( &h->stat.frame, 0, sizeof(h->stat.frame) );
  938.     /* Slice */
  939.     x264_nal_start( h, h->i_nal_type, h->i_nal_ref_idc );
  941.     /* Slice header */
  942.     x264_slice_header_write( &h->out.bs, &h->sh, h->i_nal_ref_idc );
  943.     if( h->param.b_cabac )
  944.     {
  945.         /* alignment needed */
  946.         bs_align_1( &h->out.bs );
  948.         /* init cabac */
  949.         x264_cabac_context_init( &h->cabac, h->sh.i_type, h->sh.i_qp, h->sh.i_cabac_init_idc );
  950.         x264_cabac_encode_init ( &h->cabac, &h->out.bs );
  951.     }
  952.     h->mb.i_last_qp = h->sh.i_qp;
  953.     h->mb.i_last_dqp = 0;
  955.     for( mb_xy = h->sh.i_first_mb, i_skip = 0; mb_xy < h->sh.i_last_mb; mb_xy++ )
  956.     {
  957.         const int i_mb_y = mb_xy / h->sps->i_mb_width;
  958.         const int i_mb_x = mb_xy % h->sps->i_mb_width;
  960.         int mb_spos = bs_pos(&h->out.bs);
  962.         /* load cache */
  963.         x264_macroblock_cache_load( h, i_mb_x, i_mb_y );
  965.         /* analyse parameters
  966.          * Slice I: choose I_4x4 or I_16x16 mode
  967.          * Slice P: choose between using P mode or intra (4x4 or 16x16)
  968.          * */
  969.         TIMER_START( i_mtime_analyse );
  970.         x264_macroblock_analyse( h );
  971.         TIMER_STOP( i_mtime_analyse );
  973.         /* encode this macrobock -> be carefull it can change the mb type to P_SKIP if needed */
  974.         TIMER_START( i_mtime_encode );
  975.         x264_macroblock_encode( h );
  976.         TIMER_STOP( i_mtime_encode );
  978.         TIMER_START( i_mtime_write );
  979.         if( h->param.b_cabac )
  980.         {
  981.             if( mb_xy > h->sh.i_first_mb )
  982.                 x264_cabac_encode_terminal( &h->cabac, 0 );
  984.             if( IS_SKIP( h->mb.i_type ) )
  985.                 x264_cabac_mb_skip( h, 1 );
  986.             else
  987.             {
  988.                 if( h->sh.i_type != SLICE_TYPE_I )
  989.                     x264_cabac_mb_skip( h, 0 );
  990.                 x264_macroblock_write_cabac( h, &h->cabac );
  991.             }
  992.         }
  993.         else
  994.         {
  995.             if( IS_SKIP( h->mb.i_type ) )
  996.                 i_skip++;
  997.             else
  998.             {
  999.                 if( h->sh.i_type != SLICE_TYPE_I )
  1000.                 {
  1001.                     bs_write_ue( &h->out.bs, i_skip );  /* skip run */
  1002.                     i_skip = 0;
  1003.                 }
  1004.                 x264_macroblock_write_cavlc( h, &h->out.bs );
  1005.             }
  1006.         }
  1007.         TIMER_STOP( i_mtime_write );
  1009. #if VISUALIZE
  1010.         if( h->param.b_visualize )
  1011.             x264_visualize_mb( h );
  1012. #endif
  1014.         /* save cache */
  1015.         x264_macroblock_cache_save( h );
  1017.         /* accumulate mb stats */
  1018.         h->stat.frame.i_mb_count[h->mb.i_type]++;
  1019.         if( !IS_SKIP(h->mb.i_type) && !IS_INTRA(h->mb.i_type) && !IS_DIRECT(h->mb.i_type) )
  1020.         {
  1021.             if( h->mb.i_partition != D_8x8 )
  1022.                 h->stat.frame.i_mb_count_size[ x264_mb_partition_pixel_table[ h->mb.i_partition ] ] += 4;
  1023.             else
  1024.                 for( i = 0; i < 4; i++ )
  1025.                     h->stat.frame.i_mb_count_size[ x264_mb_partition_pixel_table[ h->mb.i_sub_partition[i] ] ] ++;
  1026.             if( h->param.i_frame_reference > 1 )
  1027.             {
  1028.                 for( i = 0; i < 4; i++ )
  1029.                 {
  1030.                     int i_ref = h->mb.cache.ref[0][ x264_scan8[4*i] ];
  1031.                     if( i_ref >= 0 )
  1032.                         h->stat.frame.i_mb_count_ref[i_ref] ++;
  1033.                 }
  1034.             }
  1035.         }
  1036.         if( h->mb.i_cbp_luma && !IS_INTRA(h->mb.i_type) )
  1037.         {
  1038.             h->stat.frame.i_mb_count_8x8dct[0] ++;
  1039.             h->stat.frame.i_mb_count_8x8dct[1] += h->mb.b_transform_8x8;
  1040.         }
  1042.         if( h->mb.b_variable_qp )
  1043.             x264_ratecontrol_mb(h, bs_pos(&h->out.bs) - mb_spos);
  1044.     }
  1046.     if( h->param.b_cabac )
  1047.     {
  1048.         /* end of slice */
  1049.         x264_cabac_encode_terminal( &h->cabac, 1 );
  1050.     }
  1051.     else if( i_skip > 0 )
  1052.     {
  1053.         bs_write_ue( &h->out.bs, i_skip );  /* last skip run */
  1054.     }
  1056.     if( h->param.b_cabac )
  1057.     {
  1058.         x264_cabac_encode_flush( &h->cabac );
  1060.     }
  1061.     else
  1062.     {
  1063.         /* rbsp_slice_trailing_bits */
  1064.         bs_rbsp_trailing( &h->out.bs );
  1065.     }
  1067.     x264_nal_end( h );
  1069.     /* Compute misc bits */
  1070.     h->stat.frame.i_misc_bits = bs_pos( &h->out.bs )
  1071.                               + NALU_OVERHEAD * 8
  1072.                               - h->stat.frame.i_itex_bits
  1073.                               - h->stat.frame.i_ptex_bits
  1074.                               - h->stat.frame.i_hdr_bits;
  1076.     return 0;
  1077. }
  1079. static inline int x264_slices_write( x264_t *h )
  1080. {
  1081.     int i_frame_size;
  1083. #if VISUALIZE
  1084.     if( h->param.b_visualize )
  1085.         x264_visualize_init( h );
  1086. #endif
  1088.     if( h->param.i_threads == 1 )
  1089.     {
  1090.         x264_slice_write( h );
  1091.         i_frame_size = h->out.nal[h->out.i_nal-1].i_payload;
  1092.     }
  1093.     else
  1094.     {
  1095.         int i_nal = h->out.i_nal;
  1096.         int i_bs_size = h->out.i_bitstream / h->param.i_threads;
  1097.         int i;
  1098.         /* duplicate contexts */
  1099.         for( i = 0; i < h->param.i_threads; i++ )
  1100.         {
  1101.             x264_t *t = h->thread[i];
  1102.             if( i > 0 )
  1103.             {
  1104.                 memcpy( t, h, sizeof(x264_t) );
  1105.                 t->out.p_bitstream += i*i_bs_size;
  1106.                 bs_init( &t->out.bs, t->out.p_bitstream, i_bs_size );
  1107.             }
  1108.             t->sh.i_first_mb = (i    * h->sps->i_mb_height / h->param.i_threads) * h->sps->i_mb_width;
  1109.             t->sh.i_last_mb = ((i+1) * h->sps->i_mb_height / h->param.i_threads) * h->sps->i_mb_width;
  1110.             t->out.i_nal = i_nal + i;
  1111.         }
  1113.         /* dispatch */
  1114. #if HAVE_PTHREAD
  1115.         {
  1116.             pthread_t handles[X264_SLICE_MAX];
  1117.             void *status;
  1118.             for( i = 0; i < h->param.i_threads; i++ )
  1119.                 pthread_create( &handles[i], NULL, (void*)x264_slice_write, (void*)h->thread[i] );
  1120.             for( i = 0; i < h->param.i_threads; i++ )
  1121.                 pthread_join( handles[i], &status );
  1122.         }
  1123. #else
  1124.         for( i = 0; i < h->param.i_threads; i++ )
  1125.             x264_slice_write( h->thread[i] );
  1126. #endif
  1128.         /* merge contexts */
  1129.         i_frame_size = h->out.nal[i_nal].i_payload;
  1130.         for( i = 1; i < h->param.i_threads; i++ )
  1131.         {
  1132.             int j;
  1133.             x264_t *t = h->thread[i];
  1134.             h->out.nal[i_nal+i] = t->out.nal[i_nal+i];
  1135.             i_frame_size += t->out.nal[i_nal+i].i_payload;
  1136.             // all entries in stat.frame are ints
  1137.             for( j = 0; j < sizeof(h->stat.frame) / sizeof(int); j++ )
  1138.                 ((int*)&h->stat.frame)[j] += ((int*)&t->stat.frame)[j];
  1139.         }
  1140.         h->out.i_nal = i_nal + h->param.i_threads;
  1141.     }
  1143. #if VISUALIZE
  1144.     if( h->param.b_visualize )
  1145.     {
  1146.         x264_visualize_show( h );
  1147.         x264_visualize_close( h );
  1148.     }
  1149. #endif
  1151.     return i_frame_size;
  1152. }
  1154. /****************************************************************************
  1155.  * x264_encoder_encode:
  1156.  *  XXX: i_poc   : is the poc of the current given picture
  1157.  *       i_frame : is the number of the frame being coded
  1158.  *  ex:  type frame poc
  1159.  *       I      0   2*0
  1160.  *       P      1   2*3
  1161.  *       B      2   2*1
  1162.  *       B      3   2*2
  1163.  *       P      4   2*6
  1164.  *       B      5   2*4
  1165.  *       B      6   2*5
  1166.  ****************************************************************************/
  1167. int     x264_encoder_encode( x264_t *h,
  1168.                              x264_nal_t **pp_nal, int *pi_nal,
  1169.                              x264_picture_t *pic_in,
  1170.                              x264_picture_t *pic_out )
  1171. {
  1172.     x264_frame_t   *frame_psnr = h->fdec; /* just to keep the current decoded frame for psnr calculation */
  1173.     int     i_nal_type;
  1174.     int     i_nal_ref_idc;
  1175.     int     i_slice_type;
  1176.     int     i_frame_size;
  1178.     int i;
  1180.     int   i_global_qp;
  1182.     char psz_message[80];
  1184.     /* no data out */
  1185.     *pi_nal = 0;
  1186.     *pp_nal = NULL;
  1189.     /* ------------------- Setup new frame from picture -------------------- */
  1190.     TIMER_START( i_mtime_encode_frame );
  1191.     if( pic_in != NULL )
  1192.     {
  1193.         /* 1: Copy the picture to a frame and move it to a buffer */
  1194.         x264_frame_t *fenc = x264_frame_get( h->frames.unused );
  1196.         x264_frame_copy_picture( h, fenc, pic_in );
  1198.         if( h->param.i_width % 16 || h->param.i_height % 16 )
  1199.             x264_frame_expand_border_mod16( h, fenc );
  1201.         fenc->i_frame = h->frames.i_input++;
  1203.         x264_frame_put( h->frames.next, fenc );
  1205.         if( h->frames.b_have_lowres )
  1206.             x264_frame_init_lowres( h->param.cpu, fenc );
  1208.         if( h->frames.i_input <= h->frames.i_delay )
  1209.         {
  1210.             /* Nothing yet to encode */
  1211.             /* waiting for filling bframe buffer */
  1212.             pic_out->i_type = X264_TYPE_AUTO;
  1213.             return 0;
  1214.         }
  1215.     }
  1217.     if( h->frames.current[0] == NULL )
  1218.     {
  1219.         int bframes = 0;
  1220.         /* 2: Select frame types */
  1221.         if( h->frames.next[0] == NULL )
  1222.             return 0;
  1224.         x264_slicetype_decide( h );
  1226.         /* 3: move some B-frames and 1 non-B to encode queue */
  1227.         while( IS_X264_TYPE_B( h->frames.next[bframes]->i_type ) )
  1228.             bframes++;
  1229.         x264_frame_put( h->frames.current, x264_frame_get( &h->frames.next[bframes] ) );
  1230.         /* FIXME: when max B-frames > 3, BREF may no longer be centered after GOP closing */
  1231.         if( h->param.b_bframe_pyramid && bframes > 1 )
  1232.         {
  1233.             x264_frame_t *mid = x264_frame_get( &h->frames.next[bframes/2] );
  1234.             mid->i_type = X264_TYPE_BREF;
  1235.             x264_frame_put( h->frames.current, mid );
  1236.             bframes--;
  1237.         }
  1238.         while( bframes-- )
  1239.             x264_frame_put( h->frames.current, x264_frame_get( h->frames.next ) );
  1240.     }
  1241.     TIMER_STOP( i_mtime_encode_frame );
  1243.     /* ------------------- Get frame to be encoded ------------------------- */
  1244.     /* 4: get picture to encode */
  1245.     h->fenc = x264_frame_get( h->frames.current );
  1246.     if( h->fenc == NULL )
  1247.     {
  1248.         /* Nothing yet to encode (ex: waiting for I/P with B frames) */
  1249.         /* waiting for filling bframe buffer */
  1250.         pic_out->i_type = X264_TYPE_AUTO;
  1251.         return 0;
  1252.     }
  1254. do_encode:
  1256.     if( h->fenc->i_type == X264_TYPE_IDR )
  1257.     {
  1258.         h->frames.i_last_idr = h->fenc->i_frame;
  1259.     }
  1261.     /* ------------------- Setup frame context ----------------------------- */
  1262.     /* 5: Init data dependant of frame type */
  1263.     TIMER_START( i_mtime_encode_frame );
  1264.     if( h->fenc->i_type == X264_TYPE_IDR )
  1265.     {
  1266.         /* reset ref pictures */
  1267.         x264_reference_reset( h );
  1269.         i_nal_type    = NAL_SLICE_IDR;
  1270.         i_nal_ref_idc = NAL_PRIORITY_HIGHEST;
  1271.         i_slice_type = SLICE_TYPE_I;
  1272.     }
  1273.     else if( h->fenc->i_type == X264_TYPE_I )
  1274.     {
  1275.         i_nal_type    = NAL_SLICE;
  1276.         i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
  1277.         i_slice_type = SLICE_TYPE_I;
  1278.     }
  1279.     else if( h->fenc->i_type == X264_TYPE_P )
  1280.     {
  1281.         i_nal_type    = NAL_SLICE;
  1282.         i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
  1283.         i_slice_type = SLICE_TYPE_P;
  1284.     }
  1285.     else if( h->fenc->i_type == X264_TYPE_BREF )
  1286.     {
  1287.         i_nal_type    = NAL_SLICE;
  1288.         i_nal_ref_idc = NAL_PRIORITY_HIGH; /* maybe add MMCO to forget it? -> low */
  1289.         i_slice_type = SLICE_TYPE_B;
  1290.     }
  1291.     else    /* B frame */
  1292.     {
  1293.         i_nal_type    = NAL_SLICE;
  1294.         i_nal_ref_idc = NAL_PRIORITY_DISPOSABLE;
  1295.         i_slice_type = SLICE_TYPE_B;
  1296.     }
  1298.     h->fdec->i_poc =
  1299.     h->fenc->i_poc = 2 * (h->fenc->i_frame - h->frames.i_last_idr);
  1300.     h->fdec->i_type = h->fenc->i_type;
  1301.     h->fdec->i_frame = h->fenc->i_frame;
  1302.     h->fenc->b_kept_as_ref =
  1303.     h->fdec->b_kept_as_ref = i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE;
  1307.     /* ------------------- Init                ----------------------------- */
  1308.     /* build ref list 0/1 */
  1309.     x264_reference_build_list( h, h->fdec->i_poc, i_slice_type );
  1311.     /* Init the rate control */
  1312.     x264_ratecontrol_start( h, i_slice_type, h->fenc->i_qpplus1 );
  1313.     i_global_qp = x264_ratecontrol_qp( h );
  1315.     pic_out->i_qpplus1 =
  1316.     h->fdec->i_qpplus1 = i_global_qp + 1;
  1318.     if( i_slice_type == SLICE_TYPE_B )
  1319.         x264_macroblock_bipred_init( h );
  1321.     if( h->fenc->b_kept_as_ref )
  1322.         h->i_frame_num++;
  1324.     /* ------------------------ Create slice header  ----------------------- */
  1325.     x264_slice_init( h, i_nal_type, i_slice_type, i_global_qp );
  1327.     /* ---------------------- Write the bitstream -------------------------- */
  1328.     /* Init bitstream context */
  1329.     h->out.i_nal = 0;
  1330.     bs_init( &h->out.bs, h->out.p_bitstream, h->out.i_bitstream );
  1332.     if(h->param.b_aud){
  1333.         int pic_type;
  1335.         if(i_slice_type == SLICE_TYPE_I)
  1336.             pic_type = 0;
  1337.         else if(i_slice_type == SLICE_TYPE_P)
  1338.             pic_type = 1;
  1339.         else if(i_slice_type == SLICE_TYPE_B)
  1340.             pic_type = 2;
  1341.         else
  1342.             pic_type = 7;
  1344.         x264_nal_start(h, NAL_AUD, NAL_PRIORITY_DISPOSABLE);
  1345.         bs_write(&h->out.bs, 3, pic_type);
  1346.         bs_rbsp_trailing(&h->out.bs);
  1347.         x264_nal_end(h);
  1348.     }
  1350.     h->i_nal_type = i_nal_type;
  1351.     h->i_nal_ref_idc = i_nal_ref_idc;
  1353.     /* Write SPS and PPS */
  1354.     if( i_nal_type == NAL_SLICE_IDR && h->param.b_repeat_headers )
  1355.     {
  1356.         if( h->fenc->i_frame == 0 )
  1357.         {
  1358.             /* identify ourself */
  1359.             x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
  1360.             x264_sei_version_write( h, &h->out.bs );
  1361.             x264_nal_end( h );
  1362.         }
  1364.         /* generate sequence parameters */
  1365.         x264_nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
  1366.         x264_sps_write( &h->out.bs, h->sps );
  1367.         x264_nal_end( h );
  1369.         /* generate picture parameters */
  1370.         x264_nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
  1371.         x264_pps_write( &h->out.bs, h->pps );
  1372.         x264_nal_end( h );
  1373.     }
  1375.     /* Write frame */
  1376.     i_frame_size = x264_slices_write( h );
  1378.     /* restore CPU state (before using float again) */
  1379.     x264_cpu_restore( h->param.cpu );
  1381.     if( i_slice_type == SLICE_TYPE_P && !h->param.rc.b_stat_read 
  1382.         && h->param.i_scenecut_threshold >= 0 )
  1383.     {
  1384.         const int *mbs = h->stat.frame.i_mb_count;
  1385.         int i_mb_i = mbs[I_16x16] + mbs[I_8x8] + mbs[I_4x4];
  1386.         int i_mb_p = mbs[P_L0] + mbs[P_8x8];
  1387.         int i_mb_s = mbs[P_SKIP];
  1388.         int i_mb   = h->sps->i_mb_width * h->sps->i_mb_height;
  1389.         int64_t i_inter_cost = h->stat.frame.i_inter_cost;
  1390.         int64_t i_intra_cost = h->stat.frame.i_intra_cost;
  1392.         float f_bias;
  1393.         int i_gop_size = h->fenc->i_frame - h->frames.i_last_idr;
  1394.         float f_thresh_max = h->param.i_scenecut_threshold / 100.0;
  1395.         /* magic numbers pulled out of thin air */
  1396.         float f_thresh_min = f_thresh_max * h->param.i_keyint_min
  1397.                              / ( h->param.i_keyint_max * 4 );
  1398.         if( h->param.i_keyint_min == h->param.i_keyint_max )
  1399.              f_thresh_min= f_thresh_max;
  1401.         /* macroblock_analyse() doesn't further analyse skipped mbs,
  1402.          * so we have to guess their cost */
  1403.         if( i_mb_s < i_mb )
  1404.             i_intra_cost = i_intra_cost * i_mb / (i_mb - i_mb_s);
  1406.         if( i_gop_size < h->param.i_keyint_min / 4 )
  1407.             f_bias = f_thresh_min / 4;
  1408.         else if( i_gop_size <= h->param.i_keyint_min )
  1409.             f_bias = f_thresh_min * i_gop_size / h->param.i_keyint_min;
  1410.         else
  1411.         {
  1412.             f_bias = f_thresh_min
  1413.                      + ( f_thresh_max - f_thresh_min )
  1414.                        * ( i_gop_size - h->param.i_keyint_min )
  1415.                        / ( h->param.i_keyint_max - h->param.i_keyint_min );
  1416.         }
  1417.         f_bias = X264_MIN( f_bias, 1.0 );
  1419.         /* Bad P will be reencoded as I */
  1420.         if( i_mb_s < i_mb &&
  1421.             i_inter_cost >= (1.0 - f_bias) * i_intra_cost )
  1422.         {
  1423.             int b;
  1425.             x264_log( h, X264_LOG_DEBUG, "scene cut at %d Icost:%.0f Pcost:%.0f ratio:%.3f bias=%.3f lastIDR:%d (I:%d P:%d S:%d)n",
  1426.                       h->fenc->i_frame,
  1427.                       (double)i_intra_cost, (double)i_inter_cost,
  1428.                       (double)i_inter_cost / i_intra_cost,
  1429.                       f_bias, i_gop_size,
  1430.                       i_mb_i, i_mb_p, i_mb_s );
  1432.             /* Restore frame num */
  1433.             h->i_frame_num--;
  1435.             for( b = 0; h->frames.current[b] && IS_X264_TYPE_B( h->frames.current[b]->i_type ); b++ );
  1436.             if( b > 0 )
  1437.             {
  1438.                 /* If using B-frames, force GOP to be closed.
  1439.                  * Even if this frame is going to be I and not IDR, forcing a
  1440.                  * P-frame before the scenecut will probably help compression.
  1441.                  * 
  1442.                  * We don't yet know exactly which frame is the scene cut, so
  1443.                  * we can't assign an I-frame. Instead, change the previous
  1444.                  * B-frame to P, and rearrange coding order. */
  1446.                 if( h->param.b_bframe_adaptive || b > 1 )
  1447.                     h->fenc->i_type = X264_TYPE_AUTO;
  1448.                 x264_frame_sort_pts( h->frames.current );
  1449.                 x264_frame_push( h->frames.next, h->fenc );
  1450.                 h->fenc = h->frames.current[b-1];
  1451.                 h->frames.current[b-1] = NULL;
  1452.                 h->fenc->i_type = X264_TYPE_P;
  1453.                 x264_frame_sort_dts( h->frames.current );
  1454.             }
  1455.             /* Do IDR if needed */
  1456.             else if( i_gop_size >= h->param.i_keyint_min )
  1457.             {
  1458.                 x264_frame_t *tmp;
  1460.                 /* Reset */
  1461.                 h->i_frame_num = 0;
  1463.                 /* Reinit field of fenc */
  1464.                 h->fenc->i_type = X264_TYPE_IDR;
  1465.                 h->fenc->i_poc = 0;
  1467.                 /* Put enqueued frames back in the pool */
  1468.                 while( (tmp = x264_frame_get( h->frames.current ) ) != NULL )
  1469.                     x264_frame_put( h->frames.next, tmp );
  1470.                 x264_frame_sort_pts( h->frames.next );
  1471.             }
  1472.             else
  1473.             {
  1474.                 h->fenc->i_type = X264_TYPE_I;
  1475.             }
  1476.             goto do_encode;
  1477.         }
  1478.     }
  1480.     /* End bitstream, set output  */
  1481.     *pi_nal = h->out.i_nal;
  1482.     *pp_nal = h->out.nal;
  1484.     /* Set output picture properties */
  1485.     if( i_slice_type == SLICE_TYPE_I )
  1486.         pic_out->i_type = i_nal_type == NAL_SLICE_IDR ? X264_TYPE_IDR : X264_TYPE_I;
  1487.     else if( i_slice_type == SLICE_TYPE_P )
  1488.         pic_out->i_type = X264_TYPE_P;
  1489.     else
  1490.         pic_out->i_type = X264_TYPE_B;
  1491.     pic_out->i_pts = h->fenc->i_pts;
  1493.     pic_out->img.i_plane = h->fdec->i_plane;
  1494.     for(i = 0; i < 4; i++){
  1495.         pic_out->img.i_stride[i] = h->fdec->i_stride[i];
  1496.         pic_out->img.plane[i] = h->fdec->plane[i];
  1497.     }
  1499.     /* ---------------------- Update encoder state ------------------------- */
  1501.     /* handle references */
  1502.     if( i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE )
  1503.     {
  1504.         x264_reference_update( h );
  1505.     }
  1507.     /* increase frame count */
  1508.     h->i_frame++;
  1510.     /* restore CPU state (before using float again) */
  1511.     /* XXX: not needed? (done above) */
  1512.     x264_cpu_restore( h->param.cpu );
  1514.     /* update rc */
  1515.     x264_ratecontrol_end( h, i_frame_size * 8 );
  1517.     x264_frame_put( h->frames.unused, h->fenc );
  1519.     x264_noise_reduction_update( h );
  1521.     TIMER_STOP( i_mtime_encode_frame );
  1523.     /* ---------------------- Compute/Print statistics --------------------- */
  1524.     /* Slice stat */
  1525.     h->stat.i_slice_count[i_slice_type]++;
  1526.     h->stat.i_slice_size[i_slice_type] += i_frame_size + NALU_OVERHEAD;
  1527.     h->stat.i_slice_qp[i_slice_type] += i_global_qp;
  1529.     for( i = 0; i < 19; i++ )
  1530.         h->stat.i_mb_count[h->sh.i_type][i] += h->stat.frame.i_mb_count[i];
  1531.     for( i = 0; i < 2; i++ )
  1532.         h->stat.i_mb_count_8x8dct[i] += h->stat.frame.i_mb_count_8x8dct[i];
  1533.     if( h->sh.i_type != SLICE_TYPE_I )
  1534.     {
  1535.         for( i = 0; i < 7; i++ )
  1536.             h->stat.i_mb_count_size[h->sh.i_type][i] += h->stat.frame.i_mb_count_size[i];
  1537.         for( i = 0; i < 16; i++ )
  1538.             h->stat.i_mb_count_ref[h->sh.i_type][i] += h->stat.frame.i_mb_count_ref[i];
  1539.     }
  1540.     if( i_slice_type == SLICE_TYPE_B )
  1541.     {
  1542.         h->stat.i_direct_frames[ h->sh.b_direct_spatial_mv_pred ] ++;
  1543.         if( h->mb.b_direct_auto_write )
  1544.         {
  1545.             //FIXME somewhat arbitrary time constants
  1546.             if( h->stat.i_direct_score[0] + h->stat.i_direct_score[1] > h->mb.i_mb_count )
  1547.             {
  1548.                 for( i = 0; i < 2; i++ )
  1549.                     h->stat.i_direct_score[i] = h->stat.i_direct_score[i] * 9/10;
  1550.             }
  1551.             for( i = 0; i < 2; i++ )
  1552.                 h->stat.i_direct_score[i] += h->stat.frame.i_direct_score[i];
  1553.         }
  1554.     }
  1556.     if( h->param.analyse.b_psnr )
  1557.     {
  1558.         int64_t i_sqe_y, i_sqe_u, i_sqe_v;
  1560.         /* PSNR */
  1561.         i_sqe_y = x264_pixel_ssd_wxh( &h->pixf, frame_psnr->plane[0], frame_psnr->i_stride[0], h->fenc->plane[0], h->fenc->i_stride[0], h->param.i_width, h->param.i_height );
  1562.         i_sqe_u = x264_pixel_ssd_wxh( &h->pixf, frame_psnr->plane[1], frame_psnr->i_stride[1], h->fenc->plane[1], h->fenc->i_stride[1], h->param.i_width/2, h->param.i_height/2);
  1563.         i_sqe_v = x264_pixel_ssd_wxh( &h->pixf, frame_psnr->plane[2], frame_psnr->i_stride[2], h->fenc->plane[2], h->fenc->i_stride[2], h->param.i_width/2, h->param.i_height/2);
  1564.         x264_cpu_restore( h->param.cpu );
  1566.         h->stat.i_sqe_global[i_slice_type] += i_sqe_y + i_sqe_u + i_sqe_v;
  1567.         h->stat.f_psnr_average[i_slice_type] += x264_psnr( i_sqe_y + i_sqe_u + i_sqe_v, 3 * h->param.i_width * h->param.i_height / 2 );
  1568.         h->stat.f_psnr_mean_y[i_slice_type] += x264_psnr( i_sqe_y, h->param.i_width * h->param.i_height );
  1569.         h->stat.f_psnr_mean_u[i_slice_type] += x264_psnr( i_sqe_u, h->param.i_width * h->param.i_height / 4 );
  1570.         h->stat.f_psnr_mean_v[i_slice_type] += x264_psnr( i_sqe_v, h->param.i_width * h->param.i_height / 4 );
  1572.         snprintf( psz_message, 80, " PSNR Y:%2.2f U:%2.2f V:%2.2f",
  1573.                   x264_psnr( i_sqe_y, h->param.i_width * h->param.i_height ),
  1574.                   x264_psnr( i_sqe_u, h->param.i_width * h->param.i_height / 4),
  1575.                   x264_psnr( i_sqe_v, h->param.i_width * h->param.i_height / 4) );
  1576.         psz_message[79] = '';
  1577.     }
  1578.     else
  1579.     {
  1580.         psz_message[0] = '';
  1581.     }
  1582.     
  1583.     x264_log( h, X264_LOG_DEBUG,
  1584.                   "frame=%4d QP=%i NAL=%d Slice:%c Poc:%-3d I:%-4d P:%-4d SKIP:%-4d size=%d bytes%sn",
  1585.               h->i_frame - 1,
  1586.               i_global_qp,
  1587.               i_nal_ref_idc,
  1588.               i_slice_type == SLICE_TYPE_I ? 'I' : (i_slice_type == SLICE_TYPE_P ? 'P' : 'B' ),
  1589.               frame_psnr->i_poc,
  1590.               h->stat.frame.i_mb_count_i,
  1591.               h->stat.frame.i_mb_count_p,
  1592.               h->stat.frame.i_mb_count_skip,
  1593.               i_frame_size,
  1594.               psz_message );
  1597. #ifdef DEBUG_MB_TYPE
  1598. {
  1599.     static const char mb_chars[] = { 'i', 'i', 'I', 'C', 'P', '8', 'S',
  1600.         'D', '<', 'X', 'B', 'X', '>', 'B', 'B', 'B', 'B', '8', 'S' };
  1601.     int mb_xy;
  1602.     for( mb_xy = 0; mb_xy < h->sps->i_mb_width * h->sps->i_mb_height; mb_xy++ )
  1603.     {
  1604.         if( h->mb.type[mb_xy] < 19 && h->mb.type[mb_xy] >= 0 )
  1605.             fprintf( stderr, "%c ", mb_chars[ h->mb.type[mb_xy] ] );
  1606.         else
  1607.             fprintf( stderr, "? " );
  1609.         if( (mb_xy+1) % h->sps->i_mb_width == 0 )
  1610.             fprintf( stderr, "n" );
  1611.     }
  1612. }
  1613. #endif
  1615. #ifdef DEBUG_DUMP_FRAME
  1616.     /* Dump reconstructed frame */
  1617.     x264_frame_dump( h, frame_psnr, "fdec.yuv" );
  1618. #endif
  1619.     return 0;
  1620. }
  1622. /****************************************************************************
  1623.  * x264_encoder_close:
  1624.  ****************************************************************************/
  1625. void    x264_encoder_close  ( x264_t *h )
  1626. {
  1627. #ifdef DEBUG_BENCHMARK
  1628.     int64_t i_mtime_total = i_mtime_analyse + i_mtime_encode + i_mtime_write + i_mtime_filter + 1;
  1629. #endif
  1630.     int64_t i_yuv_size = 3 * h->param.i_width * h->param.i_height / 2;
  1631.     int i;
  1633. #ifdef DEBUG_BENCHMARK
  1634.     x264_log( h, X264_LOG_INFO,
  1635.               "analyse=%d(%lldms) encode=%d(%lldms) write=%d(%lldms) filter=%d(%lldms)n",
  1636.               (int)(100*i_mtime_analyse/i_mtime_total), i_mtime_analyse/1000,
  1637.               (int)(100*i_mtime_encode/i_mtime_total), i_mtime_encode/1000,
  1638.               (int)(100*i_mtime_write/i_mtime_total), i_mtime_write/1000,
  1639.               (int)(100*i_mtime_filter/i_mtime_total), i_mtime_filter/1000 );
  1640. #endif
  1642.     /* Slices used and PSNR */
  1643.     for( i=0; i<5; i++ )
  1644.     {
  1645.         static const int slice_order[] = { SLICE_TYPE_I, SLICE_TYPE_SI, SLICE_TYPE_P, SLICE_TYPE_SP, SLICE_TYPE_B };
  1646.         static const char *slice_name[] = { "P", "B", "I", "SP", "SI" };
  1647.         int i_slice = slice_order[i];
  1649.         if( h->stat.i_slice_count[i_slice] > 0 )
  1650.         {
  1651.             const int i_count = h->stat.i_slice_count[i_slice];
  1652.             if( h->param.analyse.b_psnr )
  1653.             {
  1654.                 x264_log( h, X264_LOG_INFO,
  1655.                           "slice %s:%-5d Avg QP:%5.2f  size:%6.0f  PSNR Mean Y:%5.2f U:%5.2f V:%5.2f Avg:%5.2f Global:%5.2fn",
  1656.                           slice_name[i_slice],
  1657.                           i_count,
  1658.                           (double)h->stat.i_slice_qp[i_slice] / i_count,
  1659.                           (double)h->stat.i_slice_size[i_slice] / i_count,
  1660.                           h->stat.f_psnr_mean_y[i_slice] / i_count, h->stat.f_psnr_mean_u[i_slice] / i_count, h->stat.f_psnr_mean_v[i_slice] / i_count,
  1661.                           h->stat.f_psnr_average[i_slice] / i_count,
  1662.                           x264_psnr( h->stat.i_sqe_global[i_slice], i_count * i_yuv_size ) );
  1663.             }
  1664.             else
  1665.             {
  1666.                 x264_log( h, X264_LOG_INFO,
  1667.                           "slice %s:%-5d Avg QP:%5.2f  size:%6.0fn",
  1668.                           slice_name[i_slice],
  1669.                           i_count,
  1670.                           (double)h->stat.i_slice_qp[i_slice] / i_count,
  1671.                           (double)h->stat.i_slice_size[i_slice] / i_count );
  1672.             }
  1673.         }
  1674.     }
  1676.     /* MB types used */
  1677.     if( h->stat.i_slice_count[SLICE_TYPE_I] > 0 )
  1678.     {
  1679.         const int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_I];
  1680.         const double i_count = h->stat.i_slice_count[SLICE_TYPE_I] * h->mb.i_mb_count / 100.0;
  1681.         x264_log( h, X264_LOG_INFO,
  1682.                   "mb I  I16..4: %4.1f%% %4.1f%% %4.1f%%n",
  1683.                   i_mb_count[I_16x16]/ i_count,
  1684.                   i_mb_count[I_8x8]  / i_count,
  1685.                   i_mb_count[I_4x4]  / i_count );
  1686.     }
  1687.     if( h->stat.i_slice_count[SLICE_TYPE_P] > 0 )
  1688.     {
  1689.         const int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_P];
  1690.         const int64_t *i_mb_size = h->stat.i_mb_count_size[SLICE_TYPE_P];
  1691.         const double i_count = h->stat.i_slice_count[SLICE_TYPE_P] * h->mb.i_mb_count / 100.0;
  1692.         x264_log( h, X264_LOG_INFO,
  1693.                   "mb P  I16..4: %4.1f%% %4.1f%% %4.1f%%  P16..4: %4.1f%% %4.1f%% %4.1f%% %4.1f%% %4.1f%%    skip:%4.1f%%n",
  1694.                   i_mb_count[I_16x16]/ i_count,
  1695.                   i_mb_count[I_8x8]  / i_count,
  1696.                   i_mb_count[I_4x4]  / i_count,
  1697.                   i_mb_size[PIXEL_16x16] / (i_count*4),
  1698.                   (i_mb_size[PIXEL_16x8] + i_mb_size[PIXEL_8x16]) / (i_count*4),
  1699.                   i_mb_size[PIXEL_8x8] / (i_count*4),
  1700.                   (i_mb_size[PIXEL_8x4] + i_mb_size[PIXEL_4x8]) / (i_count*4),
  1701.                   i_mb_size[PIXEL_4x4] / (i_count*4),
  1702.                   i_mb_count[P_SKIP] / i_count );
  1703.     }
  1704.     if( h->stat.i_slice_count[SLICE_TYPE_B] > 0 )
  1705.     {
  1706.         const int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_B];
  1707.         const int64_t *i_mb_size = h->stat.i_mb_count_size[SLICE_TYPE_B];
  1708.         const double i_count = h->stat.i_slice_count[SLICE_TYPE_B] * h->mb.i_mb_count / 100.0;
  1709.         x264_log( h, X264_LOG_INFO,
  1710.                   "mb B  I16..4: %4.1f%% %4.1f%% %4.1f%%  B16..8: %4.1f%% %4.1f%% %4.1f%%  direct:%4.1f%%  skip:%4.1f%%n",
  1711.                   i_mb_count[I_16x16]  / i_count,
  1712.                   i_mb_count[I_8x8]    / i_count,
  1713.                   i_mb_count[I_4x4]    / i_count,
  1714.                   i_mb_size[PIXEL_16x16] / (i_count*4),
  1715.                   (i_mb_size[PIXEL_16x8] + i_mb_size[PIXEL_8x16]) / (i_count*4),
  1716.                   i_mb_size[PIXEL_8x8] / (i_count*4),
  1717.                   i_mb_count[B_DIRECT] / i_count,
  1718.                   i_mb_count[B_SKIP]   / i_count );
  1719.     }
  1721.     x264_ratecontrol_summary( h );
  1723.     if( h->stat.i_slice_count[SLICE_TYPE_I] + h->stat.i_slice_count[SLICE_TYPE_P] + h->stat.i_slice_count[SLICE_TYPE_B] > 0 )
  1724.     {
  1725.         const int i_count = h->stat.i_slice_count[SLICE_TYPE_I] +
  1726.                             h->stat.i_slice_count[SLICE_TYPE_P] +
  1727.                             h->stat.i_slice_count[SLICE_TYPE_B];
  1728.         float fps = (float) h->param.i_fps_num / h->param.i_fps_den;
  1729. #define SUM3(p) (p[SLICE_TYPE_I] + p[SLICE_TYPE_P] + p[SLICE_TYPE_B])
  1730. #define SUM3b(p,o) (p[SLICE_TYPE_I][o] + p[SLICE_TYPE_P][o] + p[SLICE_TYPE_B][o])
  1731.         float f_bitrate = fps * SUM3(h->stat.i_slice_size) / i_count / 125;
  1733.         if( h->param.analyse.b_transform_8x8 )
  1734.         {
  1735.             int64_t i_i8x8 = SUM3b( h->stat.i_mb_count, I_8x8 );
  1736.             int64_t i_intra = i_i8x8 + SUM3b( h->stat.i_mb_count, I_4x4 )
  1737.                                      + SUM3b( h->stat.i_mb_count, I_16x16 );
  1738.             x264_log( h, X264_LOG_INFO, "8x8 transform  intra:%.1f%%  inter:%.1f%%n",
  1739.                       100. * i_i8x8 / i_intra,
  1740.                       100. * h->stat.i_mb_count_8x8dct[1] / h->stat.i_mb_count_8x8dct[0] );
  1741.         }
  1743.         if( h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO
  1744.             && h->stat.i_slice_count[SLICE_TYPE_B] )
  1745.         {
  1746.             x264_log( h, X264_LOG_INFO, "direct mvs  spatial:%.1f%%  temporal:%.1f%%n",
  1747.                       h->stat.i_direct_frames[1] * 100. / h->stat.i_slice_count[SLICE_TYPE_B],
  1748.                       h->stat.i_direct_frames[0] * 100. / h->stat.i_slice_count[SLICE_TYPE_B] );
  1749.         }
  1751.         if( h->param.i_frame_reference > 1 )
  1752.         {
  1753.             int i_slice;
  1754.             for( i_slice = 0; i_slice < 2; i_slice++ )
  1755.             {
  1756.                 char buf[200];
  1757.                 char *p = buf;
  1758.                 int64_t i_den = 0;
  1759.                 int i_max = 0;
  1760.                 for( i = 0; i < h->param.i_frame_reference; i++ )
  1761.                     if( h->stat.i_mb_count_ref[i_slice][i] )
  1762.                     {
  1763.                         i_den += h->stat.i_mb_count_ref[i_slice][i];
  1764.                         i_max = i;
  1765.                     }
  1766.                 if( i_max == 0 )
  1767.                     continue;
  1768.                 for( i = 0; i <= i_max; i++ )
  1769.                     p += sprintf( p, " %4.1f%%", 100. * h->stat.i_mb_count_ref[i_slice][i] / i_den );
  1770.                 x264_log( h, X264_LOG_INFO, "ref %c %sn", i_slice==SLICE_TYPE_P ? 'P' : 'B', buf );
  1771.             }
  1772.         }
  1774.         if( h->param.analyse.b_psnr )
  1775.             x264_log( h, X264_LOG_INFO,
  1776.                       "PSNR Mean Y:%6.3f U:%6.3f V:%6.3f Avg:%6.3f Global:%6.3f kb/s:%.2fn",
  1777.                       SUM3( h->stat.f_psnr_mean_y ) / i_count,
  1778.                       SUM3( h->stat.f_psnr_mean_u ) / i_count,
  1779.                       SUM3( h->stat.f_psnr_mean_v ) / i_count,
  1780.                       SUM3( h->stat.f_psnr_average ) / i_count,
  1781.                       x264_psnr( SUM3( h->stat.i_sqe_global ), i_count * i_yuv_size ),
  1782.                       f_bitrate );
  1783.         else
  1784.             x264_log( h, X264_LOG_INFO, "kb/s:%.1fn", f_bitrate );
  1785.     }
  1787.     /* frames */
  1788.     for( i = 0; i < X264_BFRAME_MAX + 3; i++ )
  1789.     {
  1790.         if( h->frames.current[i] ) x264_frame_delete( h->frames.current[i] );
  1791.         if( h->frames.next[i] )    x264_frame_delete( h->frames.next[i] );
  1792.         if( h->frames.unused[i] )  x264_frame_delete( h->frames.unused[i] );
  1793.     }
  1794.     /* ref frames */
  1795.     for( i = 0; i < h->frames.i_max_dpb; i++ )
  1796.     {
  1797.         x264_frame_delete( h->frames.reference[i] );
  1798.     }
  1800.     /* rc */
  1801.     x264_ratecontrol_delete( h );
  1803.     /* param */
  1804.     if( h->param.rc.psz_stat_out )
  1805.         free( h->param.rc.psz_stat_out );
  1806.     if( h->param.rc.psz_stat_in )
  1807.         free( h->param.rc.psz_stat_in );
  1808.     if( h->param.rc.psz_rc_eq )
  1809.         free( h->param.rc.psz_rc_eq );
  1811.     x264_macroblock_cache_end( h );
  1812.     x264_free( h->out.p_bitstream );
  1813.     for( i = 1; i < h->param.i_threads; i++ )
  1814.         x264_free( h->thread[i] );
  1815.     x264_free( h );
  1816. }