Merge git://git.videolan.org/x264
authorKieran Kunhya <kierank@ob-encoder.com>
Fri, 11 Jan 2013 23:28:18 +0000 (23:28 +0000)
committerKieran Kunhya <kierank@ob-encoder.com>
Fri, 11 Jan 2013 23:28:18 +0000 (23:28 +0000)
Conflicts:
encoder/encoder.c
encoder/ratecontrol.c
encoder/set.c

41 files changed:
1  2 
common/arm/quant-a.S
common/arm/quant.h
common/bitstream.c
common/bitstream.h
common/cabac.c
common/common.c
common/common.h
common/dct.c
common/dct.h
common/frame.c
common/frame.h
common/macroblock.c
common/macroblock.h
common/mc.c
common/mc.h
common/mvpred.c
common/pixel.c
common/predict.c
common/predict.h
common/quant.c
common/quant.h
common/set.c
common/set.h
common/x86/predict-a.asm
common/x86/predict.h
common/x86/quant-a.asm
configure
encoder/analyse.c
encoder/encoder.c
encoder/macroblock.c
encoder/macroblock.h
encoder/me.c
encoder/ratecontrol.c
encoder/rdo.c
encoder/set.c
encoder/set.h
encoder/slicetype.c
output/matroska.c
tools/checkasm.c
x264.c
x264.h

Simple merge
Simple merge
Simple merge
Simple merge
diff --cc common/cabac.c
Simple merge
diff --cc common/common.c
Simple merge
diff --cc common/common.h
Simple merge
diff --cc common/dct.c
Simple merge
diff --cc common/dct.h
Simple merge
diff --cc common/frame.c
Simple merge
diff --cc common/frame.h
Simple merge
Simple merge
Simple merge
diff --cc common/mc.c
Simple merge
diff --cc common/mc.h
Simple merge
diff --cc common/mvpred.c
Simple merge
diff --cc common/pixel.c
Simple merge
Simple merge
Simple merge
diff --cc common/quant.c
Simple merge
diff --cc common/quant.h
Simple merge
diff --cc common/set.c
Simple merge
diff --cc common/set.h
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc configure
Simple merge
Simple merge
@@@ -629,8 -577,8 +629,8 @@@ static int x264_validate_parameters( x2
          h->param.rc.i_qp_constant = h->param.rc.f_rf_constant + QP_BD_OFFSET;
          h->param.rc.i_bitrate = 0;
      }
-     if( (h->param.rc.i_rc_method == X264_RC_CQP || h->param.rc.i_rc_method == X264_RC_CRF)
+     if( b_open && (h->param.rc.i_rc_method == X264_RC_CQP || h->param.rc.i_rc_method == X264_RC_CRF)
 -        && h->param.rc.i_qp_constant == 0 )
 +        && h->param.rc.i_qp_constant == 0 && !MPEG2 )
      {
          h->mb.b_lossless = 1;
          h->param.i_cqm_preset = X264_CQM_FLAT;
@@@ -2446,17 -2236,13 +2446,14 @@@ static int x264_slice_write( x264_t *h 
      /* Slice header */
      x264_macroblock_thread_init( h );
  
-     /* If this isn't the first slice in the threadslice, set the slice QP
-      * equal to the last QP in the previous slice for more accurate
-      * CABAC initialization. */
-     if( h->sh.i_first_mb != h->i_threadslice_start * h->mb.i_mb_width )
-     {
-         h->sh.i_qp = h->mb.i_last_qp;
-         h->sh.i_qp_delta = h->sh.i_qp - h->pps->i_pic_init_qp;
-     }
+     /* Set the QP equal to the first QP in the slice for more accurate CABAC initialization. */
+     h->mb.i_mb_xy = h->sh.i_first_mb;
+     h->sh.i_qp = x264_ratecontrol_mb_qp( h );
+     h->sh.i_qp = SPEC_QP( h->sh.i_qp );
+     h->sh.i_qp_delta = h->sh.i_qp - h->pps->i_pic_init_qp;
  
 -    x264_slice_header_write( &h->out.bs, &h->sh, h->i_nal_ref_idc );
 +    if( !MPEG2 )
 +        x264_slice_header_write( &h->out.bs, &h->sh, h->i_nal_ref_idc );
      if( h->param.b_cabac )
      {
          /* alignment needed */
Simple merge
Simple merge
diff --cc encoder/me.c
Simple merge
@@@ -1127,9 -1114,11 +1128,11 @@@ parse_error
                  x264_log( h, X264_LOG_ERROR, "statistics are damaged at line %d, parser out=%d\n", i, e );
                  return -1;
              }
-             rce->qscale = qp2qscale( h, qp );
 -            rce->qscale = qp2qscale( qp_rc );
++            rce->qscale = qp2qscale( h, qp_rc );
+             total_qp_aq += qp_aq;
              p = next;
          }
+         h->pps->i_pic_init_qp = SPEC_QP( (int)(total_qp_aq / rc->num_entries + 0.5) );
  
          x264_free( stats_buf );
  
diff --cc encoder/rdo.c
Simple merge
diff --cc encoder/set.c
@@@ -633,11 -575,11 +633,11 @@@ int x264_sei_version_write( x264_t *h, 
  
      memcpy( payload, uuid, 16 );
      sprintf( payload+16, "x264 - core %d%s - H.264/MPEG-4 AVC codec - "
-              "Copy%s 2003-2012 - http://www.videolan.org/x264.html - options: %s",
+              "Copy%s 2003-2013 - http://www.videolan.org/x264.html - options: %s",
               X264_BUILD, X264_VERSION, HAVE_GPL?"left":"right", opts );
      length = strlen(payload)+1;
 -
 -    x264_sei_write( s, (uint8_t *)payload, length, SEI_USER_DATA_UNREGISTERED );
 +    MPEG2 ? x264_user_data_write_mpeg2( s, (uint8_t *)payload, length ) :
 +            x264_sei_write( s, (uint8_t *)payload, length, SEI_USER_DATA_UNREGISTERED );
  
      x264_free( opts );
      x264_free( payload );
@@@ -783,357 -725,25 +783,357 @@@ void x264_sei_dec_ref_pic_marking_write
      x264_sei_write( s, tmp_buf, bs_pos( &q ) / 8, SEI_DEC_REF_PIC_MARKING );
  }
  
 +/* MPEG-2 */
 +static void x264_write_cqm_mpeg2( x264_t *h, bs_t *s, int chroma )
 +{
 +    uint8_t temp[64];
 +    int b_keyframe = h->fenc ? h->fenc->b_keyframe : 1;
 +
 +    if( chroma )
 +    {
 +        // load_chroma_intra_quantiser_matrix
 +        if( b_keyframe &&
 +            memcmp( h->pps->scaling_list[CQM_8IC],
 +                    h->pps->scaling_list[CQM_8IY], 64*sizeof(uint8_t) ) )
 +        {
 +            bs_write1( s, 1 );
 +            zigzag_scan_8x8_cqm( temp, h->pps->scaling_list[CQM_8IC] );
 +            bs_write( s, 8, 8 ); // first value must be 8
 +            for( int i = 1; i < 64; i++ )
 +                bs_write( s, 8, temp[i] );
 +        }
 +        else
 +            bs_write1( s, 0 );
 +
 +        // load_chroma_non_intra_quantiser_matrix
 +        if( memcmp( h->pps->scaling_list[CQM_8PC],
 +                    h->pps->scaling_list[CQM_8PY], 64*sizeof(uint8_t) ) )
 +        {
 +            bs_write1( s, 1 );
 +            zigzag_scan_8x8_cqm( temp, h->pps->scaling_list[CQM_8PC] );
 +            for( int i = 0; i < 64; i++ )
 +                bs_write( s, 8, temp[i] );
 +        }
 +        else
 +            bs_write1( s, 0 );
 +    }
 +    else
 +    {
 +        // load_intra_quantiser_matrix
 +        if( b_keyframe &&
 +            memcmp( h->pps->scaling_list[CQM_8IY], x264_cqm_intra_mpeg2, 64*sizeof(uint8_t) ) )
 +        {
 +            bs_write1( s, 1 );
 +            zigzag_scan_8x8_cqm( temp, h->pps->scaling_list[CQM_8IY] );
 +            bs_write( s, 8, 8 ); // first value must be 8
 +            for( int i = 1; i < 64; i++ )
 +                bs_write( s, 8, temp[i] );
 +        }
 +        else
 +            bs_write1( s, 0 );
 +
 +        // load_non_intra_quantiser_matrix
 +        if( memcmp( h->pps->scaling_list[CQM_8PY], x264_cqm_flat16, 64*sizeof(uint8_t) ) )
 +        {
 +            bs_write1( s, 1 );
 +            zigzag_scan_8x8_cqm( temp, h->pps->scaling_list[CQM_8PY] );
 +            for( int i = 0; i < 64; i++ )
 +                bs_write( s, 8, temp[i] );
 +        }
 +        else
 +            bs_write1( s, 0 );
 +    }
 +}
 +
 +void x264_seq_header_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    int i;
 +    bs_realign( s );
 +
 +    bs_write( s, 12, h->param.i_width & 0xfff );  // horizontal_size_value
 +    bs_write( s, 12, h->param.i_height & 0xfff ); // vertical_size_value
 +    bs_write( s, 4, h->param.vui.i_aspect_ratio_information ); // aspect_ratio_information
 +    bs_write( s, 4, h->sps->i_frame_rate_code ); // frame_rate_code
 +
 +    /* If vbv parameters are not set, choose a common value. */
 +    if( h->param.rc.i_vbv_max_bitrate > 0 )
 +        i = ((h->param.rc.i_vbv_max_bitrate * 1000 + 399) / 400) & 0x3ffff;
 +    else if( h->param.i_width > 720 )
 +        i = 48500; // ATSC A/53, (19400 * 1000 + 399) / 400
 +    else
 +        i = 24500; // DVD, (9800 * 1000 + 399) / 400
 +    bs_write( s, 18, i ); // bit_rate_value
 +
 +    bs_write1( s, 1 ); // marker_bit
 +
 +    if( h->param.rc.i_vbv_buffer_size > 0 )
 +        i = ((h->param.rc.i_vbv_buffer_size * 1000 + 16383) / 16384) & 0x3ff;
 +    else if( h->param.i_width > 720 )
 +        i = 488; // ATSC A/53, (7995 * 1000 + 16383) / 16384
 +    else
 +        i = 112; // DVD, (1835 * 1000 + 16383) / 16384
 +    bs_write( s, 10, i ); // vbv_buffer_size_value
 +
 +    bs_write1( s, 0 ); // constrained_parameters_flag
 +
 +    x264_write_cqm_mpeg2( h, s, 0 );
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_seq_extension_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    x264_sps_t *sps = h->sps;
 +    bs_realign( s );
 +
 +    bs_write( s, 4, MPEG2_SEQ_EXT_ID );   // extension_start_code_identifier
 +    bs_write1( s, sps->i_profile_idc == MPEG2_PROFILE_422 ); // escape bit
 +    bs_write( s, 3, sps->i_profile_idc ); // profile identification
 +
 +    int level;
 +    if( sps->i_profile_idc == MPEG2_PROFILE_422 )
 +        level = sps->i_level_idc == X264_MPEG2_LEVEL_HIGH ? 2 : 5;
 +    else
 +        level = sps->i_level_idc;
 +    bs_write( s, 4, level ); // level identification
 +
 +    bs_write1( s, !( PARAM_INTERLACED || h->param.b_fake_interlaced ||
 +                     h->param.b_pulldown ) ); // progressive_sequence
 +    bs_write( s, 2, sps->i_chroma_format_idc ); // chroma_format
 +    bs_write( s, 2, (h->param.i_width >> 12) & 0x3 );  // horizontal_size_extension
 +    bs_write( s, 2, (h->param.i_height >> 12) & 0x3 ); // vertical_size_extension
 +    bs_write( s, 12, (h->param.rc.i_vbv_max_bitrate * 1000 + 399) / 400 >> 18 & 0xfff );   // bit_rate_extension
 +    bs_write1( s, 1 );   // marker_bit
 +    bs_write( s, 8, (h->param.rc.i_vbv_buffer_size * 1000 + 16383) / 16384 >> 10 & 0xff ); // vbv_buffer_size_extension
 +    bs_write1( s, 0 );   // low_delay
 +    bs_write( s, 2, 0 ); // frame_rate_extension_n
 +    bs_write( s, 5, 0 ); // frame_rate_extension_d
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_seq_disp_extension_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    x264_sps_t *sps = h->sps;
 +    bs_realign( s );
 +
 +    bs_write( s, 4, MPEG2_SEQ_DISPLAY_EXT_ID ); // extension_start_code_identifier
 +    bs_write( s, 3, sps->vui.i_vidformat );    // video_format
 +    bs_write1( s, sps->vui.b_color_description_present ); // colour_description
 +    if( sps->vui.b_color_description_present )
 +    {
 +        bs_write( s, 8, sps->vui.i_colorprim );
 +        bs_write( s, 8, sps->vui.i_transfer );
 +        bs_write( s, 8, sps->vui.i_colmatrix );
 +    }
 +    bs_write( s, 14, h->param.i_width - h->param.crop_rect.i_left - h->param.crop_rect.i_right ); // display_horizontal_size
 +    bs_write1( s, 1 ); // marker_bit
 +    bs_write( s, 14, h->param.i_height - h->param.crop_rect.i_top - h->param.crop_rect.i_bottom ); // display_vertical_size
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_gop_header_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    bs_realign( s );
 +
 +    int hrs, min, sec;
 +    int frames = h->i_frame;
 +    int fps = h->param.i_fps_num > 60 ? h->param.i_fps_num / 1000 : h->param.i_fps_num;
 +
 +    hrs = frames  / ( 60 * 60 * fps );
 +    frames -= hrs * ( 60 * 60 * fps );
 +    min = frames  / ( 60 * fps );
 +    frames -= min * ( 60 * fps );
 +    sec = frames  / ( fps );
 +    frames -= sec * ( fps );
 +
 +    // timecode
 +    bs_write1( s, 0 );   // drop_frame_flag
 +    bs_write( s, 5, hrs % 24 ); // time_code_hours
 +    bs_write( s, 6, min ); // time_code_minutes
 +    bs_write1( s, 1 );   // marker_bit
 +    bs_write( s, 6, sec ); // time_code_seconds
 +    bs_write( s, 6, frames ); // time_code_pictures
 +
 +    bs_write1( s, h->fenc->i_frame == h->fenc->i_coded ); // closed_gop
 +    bs_write1( s, 0 );   // broken_link
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_pic_header_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    bs_realign( s );
 +
 +    int temporal_ref;
 +    if( IS_X264_TYPE_I( h->fenc->i_type ) )
 +        temporal_ref = h->fenc->i_frame - h->fenc->i_coded;
 +    else
 +        temporal_ref = h->fenc->i_frame - h->frames.i_last_temporal_ref;
 +    bs_write( s, 10, temporal_ref % 1024 ); // temporal_reference
 +    bs_write( s, 3, IS_X264_TYPE_I( h->fenc->i_type ) ? 1 : h->fenc->i_type == X264_TYPE_P ? 2 : 3 ); // picture_coding_type
 +    bs_write( s, 16, 0xffff ); // vbv_delay FIXME
 +    if( !IS_X264_TYPE_I( h->fenc->i_type ) )
 +    {
 +        bs_write1( s, 0 );   // full_pel_forward_vector
 +        bs_write( s, 3, 7 ); // forward_f_code
 +
 +        if( h->fenc->i_type == X264_TYPE_B )
 +        {
 +            bs_write1( s, 0 );   // full_pel_forward_vector
 +            bs_write( s, 3, 7 ); // forward_f_code
 +        }
 +    }
 +    bs_write1( s, 0 ); // extra_bit_picture
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_pic_coding_extension_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    x264_param_t *param = &h->param;
 +
 +    bs_realign( s );
 +
 +    bs_write( s, 4, MPEG2_PIC_CODING_EXT_ID ); // extension_start_code_identifier
 +
 +    // FIXME decide fcodes during lookahead
 +    int fcode_max[2];
 +    switch( param->i_level_idc )
 +    {
 +    case X264_MPEG2_LEVEL_LOW:
 +        fcode_max[0] = 7;
 +        fcode_max[1] = 4;
 +        break;
 +    case X264_MPEG2_LEVEL_MAIN:
 +        fcode_max[0] = 8;
 +        fcode_max[1] = 5;
 +        break;
 +    default:
 +        fcode_max[0] = 9;
 +        fcode_max[1] = 5;
 +    }
 +    h->fenc->mv_fcode[0][0] = h->fenc->mv_fcode[1][0] = fcode_max[0];
 +    h->fenc->mv_fcode[0][1] = h->fenc->mv_fcode[1][1] = fcode_max[1];
 +
 +    // f_code[s][t]
 +    if( IS_X264_TYPE_I( h->fenc->i_type ) )
 +        bs_write( s, 16, 0xffff );
 +    else if( h->fenc->i_type == X264_TYPE_P )
 +    {
 +        for( int i = 0; i < 2; i++ )
 +            bs_write( s, 4, h->fenc->mv_fcode[0][i] );
 +        bs_write( s, 8, 0xff );
 +    }
 +    else
 +    {
 +        for( int j = 0; j < 2; j++ )
 +            for( int i = 0; i < 2; i++ )
 +                bs_write( s, 4, h->fenc->mv_fcode[j][i] );
 +    }
 +    bs_write( s, 2, param->i_intra_dc_precision ); // intra_dc_precision
 +    bs_write( s, 2, 3 ); // picture_structure (support for frame pictures only)
 +    bs_write1( s, ( PARAM_INTERLACED || param->b_fake_interlaced  || param->b_pulldown ) ? h->fenc->b_tff : 0 ); // top_field_first
 +    bs_write1( s, !( PARAM_INTERLACED || param->b_fake_interlaced ) ); // frame_pred_frame_dct
 +    bs_write1( s, 0 ); // concealment_motion_vectors
 +    bs_write1( s, param->b_nonlinear_quant ); // q_scale_type
 +    bs_write1( s, param->b_alt_intra_vlc );   // intra_vlc_format
 +    bs_write1( s, param->b_alternate_scan );  // alternate_scan
 +    bs_write1( s, h->fenc->b_rff ); // repeat_first_field
 +    bs_write1( s, CHROMA_FORMAT == CHROMA_420 ? !( PARAM_INTERLACED || param->b_fake_interlaced ) : 0 ); // chroma_420_type
 +    bs_write1( s, !( PARAM_INTERLACED || param->b_fake_interlaced ) ); // progressive_frame
 +    bs_write1( s, 0 ); // composite_display_flag
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_quant_matrix_extension_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    bs_realign( s );
 +
 +    bs_write( s, 4, MPEG2_QUANT_MATRIX_EXT_ID ); // extension_start_code_identifier
 +
 +    if( !h->fenc->b_keyframe )
 +        x264_write_cqm_mpeg2( h, s, 0 );
 +    else
 +    {
 +        bs_write1( s, 0 ); // load_intra_quantiser_matrix
 +        bs_write1( s, 0 ); // load_non_intra_quantiser_matrix
 +    }
 +
 +    if( CHROMA_FORMAT == CHROMA_422 )
 +        x264_write_cqm_mpeg2( h, s, 1 );
 +    else
 +    {
 +        bs_write1( s, 0 ); // load_chroma_intra_quantiser_matrix
 +        bs_write1( s, 0 ); // load_chroma_non_intra_quantiser_matrix
 +    }
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_pic_display_extension_write_mpeg2( x264_t *h, bs_t *s )
 +{
 +    bs_realign( s );
 +
 +    bs_write( s, 4, MPEG2_PIC_DISPLAY_EXT_ID ); // extension_start_code_identifier
 +
 +    int progressive_sequence = !( PARAM_INTERLACED || h->param.b_fake_interlaced || h->param.b_pulldown );
 +    int offsets = progressive_sequence ? h->fenc->b_rff ? h->fenc->b_tff ? 3 : 2 : 1 :
 +                  h->fenc->b_rff ? 3 : 2;
 +
 +    int cx = h->param.i_width / 2;
 +    int cy = h->param.i_height / 2;
 +    for( int i = 0; i < offsets; i++ )
 +    {
 +        bs_write( s, 16, ( cx - h->param.crop_rect.i_left ) * 16 ); // frame_centre_horizontal_offset
 +        bs_write1( s, 1 ); // marker_bit
 +        bs_write( s, 16, ( cy - h->param.crop_rect.i_top ) * 16 ); // frame_centre_vertical_offset
 +        bs_write1( s, 1 ); // marker_bit
 +    }
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
 +void x264_user_data_write_mpeg2( bs_t *s, uint8_t *payload, int payload_size )
 +{
 +    bs_realign( s );
 +
 +    for( int i = 0; i < payload_size; i++ ) // payload cannot contain a start code
 +        bs_write( s, 8, payload[i] );
 +
 +    bs_align_0( s );
 +    bs_flush( s );
 +}
 +
  const x264_level_t x264_levels[] =
  {
-     { 10,    1485,    99,   152064,     64,    175,  64, 64,  0, 2, 0, 0, 1 },
-     {  9,    1485,    99,   152064,    128,    350,  64, 64,  0, 2, 0, 0, 1 }, /* "1b" */
-     { 11,    3000,   396,   345600,    192,    500, 128, 64,  0, 2, 0, 0, 1 },
-     { 12,    6000,   396,   912384,    384,   1000, 128, 64,  0, 2, 0, 0, 1 },
-     { 13,   11880,   396,   912384,    768,   2000, 128, 64,  0, 2, 0, 0, 1 },
-     { 20,   11880,   396,   912384,   2000,   2000, 128, 64,  0, 2, 0, 0, 1 },
-     { 21,   19800,   792,  1824768,   4000,   4000, 256, 64,  0, 2, 0, 0, 0 },
-     { 22,   20250,  1620,  3110400,   4000,   4000, 256, 64,  0, 2, 0, 0, 0 },
-     { 30,   40500,  1620,  3110400,  10000,  10000, 256, 32, 22, 2, 0, 1, 0 },
-     { 31,  108000,  3600,  6912000,  14000,  14000, 512, 16, 60, 4, 1, 1, 0 },
-     { 32,  216000,  5120,  7864320,  20000,  20000, 512, 16, 60, 4, 1, 1, 0 },
-     { 40,  245760,  8192, 12582912,  20000,  25000, 512, 16, 60, 4, 1, 1, 0 },
-     { 41,  245760,  8192, 12582912,  50000,  62500, 512, 16, 24, 2, 1, 1, 0 },
-     { 42,  522240,  8704, 13369344,  50000,  62500, 512, 16, 24, 2, 1, 1, 1 },
-     { 50,  589824, 22080, 42393600, 135000, 135000, 512, 16, 24, 2, 1, 1, 1 },
-     { 51,  983040, 36864, 70778880, 240000, 240000, 512, 16, 24, 2, 1, 1, 1 },
-     { 52, 2073600, 36864, 70778880, 240000, 240000, 512, 16, 24, 2, 1, 1, 1 },
+     { 10,    1485,    99,    396,     64,    175,  64, 64,  0, 2, 0, 0, 1 },
+     {  9,    1485,    99,    396,    128,    350,  64, 64,  0, 2, 0, 0, 1 }, /* "1b" */
+     { 11,    3000,   396,    900,    192,    500, 128, 64,  0, 2, 0, 0, 1 },
+     { 12,    6000,   396,   2376,    384,   1000, 128, 64,  0, 2, 0, 0, 1 },
+     { 13,   11880,   396,   2376,    768,   2000, 128, 64,  0, 2, 0, 0, 1 },
+     { 20,   11880,   396,   2376,   2000,   2000, 128, 64,  0, 2, 0, 0, 1 },
+     { 21,   19800,   792,   4752,   4000,   4000, 256, 64,  0, 2, 0, 0, 0 },
+     { 22,   20250,  1620,   8100,   4000,   4000, 256, 64,  0, 2, 0, 0, 0 },
+     { 30,   40500,  1620,   8100,  10000,  10000, 256, 32, 22, 2, 0, 1, 0 },
+     { 31,  108000,  3600,  18000,  14000,  14000, 512, 16, 60, 4, 1, 1, 0 },
+     { 32,  216000,  5120,  20480,  20000,  20000, 512, 16, 60, 4, 1, 1, 0 },
+     { 40,  245760,  8192,  32768,  20000,  25000, 512, 16, 60, 4, 1, 1, 0 },
+     { 41,  245760,  8192,  32768,  50000,  62500, 512, 16, 24, 2, 1, 1, 0 },
+     { 42,  522240,  8704,  34816,  50000,  62500, 512, 16, 24, 2, 1, 1, 1 },
+     { 50,  589824, 22080, 110400, 135000, 135000, 512, 16, 24, 2, 1, 1, 1 },
+     { 51,  983040, 36864, 184320, 240000, 240000, 512, 16, 24, 2, 1, 1, 1 },
+     { 52, 2073600, 36864, 184320, 240000, 240000, 512, 16, 24, 2, 1, 1, 1 },
      { 0 }
  };
  
@@@ -1180,48 -763,32 +1180,50 @@@ int x264_validate_levels( x264_t *h, in
                       h->sps->i_profile_idc==PROFILE_HIGH10 ? 12 :
                       h->sps->i_profile_idc==PROFILE_HIGH ? 5 : 4;
  
 -    const x264_level_t *l = x264_levels;
 -    while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
 -        l++;
 -
 -    if( l->frame_size < mbs
 -        || l->frame_size*8 < h->sps->i_mb_width * h->sps->i_mb_width
 -        || l->frame_size*8 < h->sps->i_mb_height * h->sps->i_mb_height )
 -        ERROR( "frame MB size (%dx%d) > level limit (%d)\n",
 -               h->sps->i_mb_width, h->sps->i_mb_height, l->frame_size );
 -    if( dpb > l->dpb )
 -        ERROR( "DPB size (%d frames, %d mbs) > level limit (%d frames, %d mbs)\n",
 -                h->sps->vui.i_max_dec_frame_buffering, dpb, l->dpb / mbs, l->dpb );
 -
 -#define CHECK( name, limit, val ) \
 -    if( (val) > (limit) ) \
 -        ERROR( name " (%"PRId64") > level limit (%d)\n", (int64_t)(val), (limit) );
 -
 -    CHECK( "VBV bitrate", (l->bitrate * cbp_factor) / 4, h->param.rc.i_vbv_max_bitrate );
 -    CHECK( "VBV buffer", (l->cpb * cbp_factor) / 4, h->param.rc.i_vbv_buffer_size );
 -    CHECK( "MV range", l->mv_range, h->param.analyse.i_mv_range );
 -    CHECK( "interlaced", !l->frame_only, h->param.b_interlaced );
 -    CHECK( "fake interlaced", !l->frame_only, h->param.b_fake_interlaced );
 -
 -    if( h->param.i_fps_den > 0 )
 -        CHECK( "MB rate", l->mbps, (int64_t)mbs * h->param.i_fps_num / h->param.i_fps_den );
 +    if( MPEG2 )
 +    {
 +        const x264_level_mpeg2_t *l = x264_levels_mpeg2;
 +        while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
 +            l++;
 +        CHECK( "framerate", l->fps_code, h->sps->i_frame_rate_code );
 +
 +        if( h->param.i_fps_den > 0 )
 +            CHECK( "luminance sample rate", l->luma_main, h->param.i_width * h->param.i_height *
 +                                                          h->param.i_fps_num / h->param.i_fps_den );
 +        CHECK( "width", l->width, h->param.i_width );
 +        CHECK( "height", l->height, h->param.i_height );
 +        // CHECK( "max bitrate", l->bitrate, h->param.rc.i_vbv_max_bitrate );
 +        // CHECK( "vbv size", l->vbv, h->param.rc.i_vbv_buffer_size );
 +        CHECK( "Vertical MV range", l->mv_max_v >> h->param.b_interlaced, h->param.analyse.i_mv_range );
 +    }
 +    else
 +    {
 +        const x264_level_t *l = x264_levels;
 +        while( l->level_idc != 0 && l->level_idc != h->param.i_level_idc )
 +            l++;
 +
 +        if( l->frame_size < mbs
 +            || l->frame_size*8 < h->sps->i_mb_width * h->sps->i_mb_width
 +            || l->frame_size*8 < h->sps->i_mb_height * h->sps->i_mb_height )
 +            ERROR( "frame MB size (%dx%d) > level limit (%d)\n",
 +                   h->sps->i_mb_width, h->sps->i_mb_height, l->frame_size );
 +        if( dpb > l->dpb )
-             ERROR( "DPB size (%d frames, %d bytes) > level limit (%d frames, %d bytes)\n",
-                     h->sps->vui.i_max_dec_frame_buffering, dpb, (int)(l->dpb / (384*mbs)), l->dpb );
++            ERROR( "DPB size (%d frames, %d mbs) > level limit (%d frames, %d mbs)\n",
++                    h->sps->vui.i_max_dec_frame_buffering, dpb, l->dpb / mbs, l->dpb );
++
++    #define CHECK( name, limit, val ) \
++        if( (val) > (limit) ) \
++            ERROR( name " (%"PRId64") > level limit (%d)\n", (int64_t)(val), (limit) );
 +
 +        CHECK( "VBV bitrate", (l->bitrate * cbp_factor) / 4, h->param.rc.i_vbv_max_bitrate );
 +        CHECK( "VBV buffer", (l->cpb * cbp_factor) / 4, h->param.rc.i_vbv_buffer_size );
 +        CHECK( "MV range", l->mv_range, h->param.analyse.i_mv_range );
 +        CHECK( "interlaced", !l->frame_only, h->param.b_interlaced );
 +        CHECK( "fake interlaced", !l->frame_only, h->param.b_fake_interlaced );
 +
 +        if( h->param.i_fps_den > 0 )
 +            CHECK( "MB rate", l->mbps, (int64_t)mbs * h->param.i_fps_num / h->param.i_fps_den );
-         /* TODO check the rest of the limits */
 +    }
  
 -    /* TODO check the rest of the limits */
      return ret;
  }
diff --cc encoder/set.h
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc x264.c
Simple merge
diff --cc x264.h
Simple merge