X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fencx264.c;h=bd41839a127fa213ae86a64555bacd2a6cba5568;hb=033e32de9c380f54c7d1362a3979da205ebc3a29;hp=eb8d8426d22ff284a342b5a2c3e079812f63f380;hpb=746a8e0074297794f4dd1eeae4d463cd939057ab;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/encx264.c b/libhb/encx264.c index eb8d8426..bd41839a 100644 --- a/libhb/encx264.c +++ b/libhb/encx264.c @@ -50,6 +50,9 @@ struct hb_work_private_s x264_picture_t pic_in; uint8_t *x264_allocated_pic; + uint32_t frames_in; + uint32_t frames_out; + uint32_t frames_split; // number of frames we had to split int chap_mark; // saved chap mark when we're propagating it int64_t last_stop; // Debugging - stop time of previous input frame int64_t init_delay; @@ -72,7 +75,6 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) x264_param_t param; x264_nal_t * nal; int nal_count; - int nal_size; hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) ); w->private_data = pv; @@ -83,19 +85,91 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) hb_get_tempory_filename( job->h, pv->filename, "x264.log" ); x264_param_default( ¶m ); - + + /* Default weightp to off for baseline, + overridable through x264 option strings. */ + if( job->x264opts != NULL && *job->x264opts != '\0' ) + { + char *x264opts, *x264opts_start; + + x264opts = x264opts_start = strdup(job->x264opts); + + while( x264opts_start && *x264opts ) + { + char *name = x264opts; + char *value; + + x264opts += strcspn( x264opts, ":" ); + if( *x264opts ) + { + *x264opts = 0; + x264opts++; + } + + value = strchr( name, '=' ); + if( value ) + { + *value = 0; + value++; + } + + /* + When B-frames are enabled, the max frame count increments + by 1 (regardless of the number of B-frames). If you don't + change the duration of the video track when you mux, libmp4 + barfs. So, check if the x264opts aren't using B-frames, and + when they aren't, set the boolean job->areBframes as false. + */ + if( !( strcmp( name, "bframes" ) ) ) + { + if( atoi( value ) == 0 ) + { + param.analyse.i_weighted_pred = X264_WEIGHTP_NONE; + } + } + } + } + + /* Enable metrics */ + param.analyse.b_psnr = 1; + param.analyse.b_ssim = 1; + param.i_threads = ( hb_get_cpu_count() * 3 / 2 ); param.i_width = job->width; param.i_height = job->height; param.i_fps_num = job->vrate; param.i_fps_den = job->vrate_base; + /* Disable annexb. Inserts size into nal header instead of start code */ + param.b_annexb = 0; + + /* Set min:max key intervals ratio to 1:10 of fps. + * This section is skipped if fps=25 (default). + */ if (job->vrate_base != 1080000) { - /* If the fps isn't 25, adjust the key intervals. Add 1 because - we want 24, not 23 with a truncated remainder. */ - param.i_keyint_min = (job->vrate / job->vrate_base) + 1; - param.i_keyint_max = (10 * job->vrate / job->vrate_base) + 1; + if (job->pass == 2 && !job->cfr ) + { + /* Even though the framerate might be different due to VFR, + we still want the same keyframe intervals as the 1st pass, + so the 1st pass stats won't conflict on frame decisions. */ + hb_interjob_t * interjob = hb_interjob_get( job->h ); + param.i_keyint_min = ( interjob->vrate / interjob->vrate_base ) + 1; + param.i_keyint_max = ( 10 * interjob->vrate / interjob->vrate_base ) + 1; + } + else + { + int fps = job->vrate / job->vrate_base; + + /* adjust +1 when fps has remainder to bump + { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */ + if (job->vrate % job->vrate_base) + fps += 1; + + param.i_keyint_min = fps; + param.i_keyint_max = fps * 10; + } + hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max); } @@ -108,6 +182,9 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) param.i_level_idc ); } + /* B-frames are on by default.*/ + job->areBframes = 1; + /* This section passes the string x264opts to libx264 for parsing into parameter names and values. @@ -153,15 +230,14 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) When B-frames are enabled, the max frame count increments by 1 (regardless of the number of B-frames). If you don't change the duration of the video track when you mux, libmp4 - barfs. So, check if the x264opts are using B-frames, and - when they are, set the boolean job->areBframes as true. + barfs. So, check if the x264opts aren't using B-frames, and + when they aren't, set the boolean job->areBframes as false. */ - if( !( strcmp( name, "bframes" ) ) ) { - if( atoi( value ) > 0 ) + if( atoi( value ) == 0 ) { - job->areBframes = 1; + job->areBframes = 0; } } @@ -179,6 +255,14 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) { job->areBframes = 2; } + if( value == NULL || !strcmp( value, "1" ) ) + { + value = "normal"; + } + else if( !strcmp( value, "0" ) ) + { + value = "none"; + } } /* Here's where the strings are passed to libx264 for parsing. */ @@ -236,47 +320,19 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) if( job->vquality > 0.0 && job->vquality < 1.0 ) { - switch( job->crf ) - { - case 1: - /*Constant RF*/ - param.rc.i_rc_method = X264_RC_CRF; - param.rc.f_rf_constant = 51 - job->vquality * 51; - hb_log( "encx264: Encoding at constant RF %f", - param.rc.f_rf_constant ); - break; - - case 0: - /*Constant QP*/ - param.rc.i_rc_method = X264_RC_CQP; - param.rc.i_qp_constant = 51 - job->vquality * 51; - hb_log( "encx264: encoding at constant QP %d", - param.rc.i_qp_constant ); - break; - } + /*Constant RF*/ + param.rc.i_rc_method = X264_RC_CRF; + param.rc.f_rf_constant = 51 - job->vquality * 51; + hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant ); } else if( job->vquality == 0 || job->vquality >= 1.0 ) { /* Use the vquality as a raw RF or QP instead of treating it like a percentage. */ - switch( job->crf ) - { - case 1: - /*Constant RF*/ - param.rc.i_rc_method = X264_RC_CRF; - param.rc.f_rf_constant = job->vquality; - hb_log( "encx264: Encoding at constant RF %f", - param.rc.f_rf_constant ); - break; - - case 0: - /*Constant QP*/ - param.rc.i_rc_method = X264_RC_CQP; - param.rc.i_qp_constant = job->vquality; - hb_log( "encx264: encoding at constant QP %d", - param.rc.i_qp_constant ); - break; - } + /*Constant RF*/ + param.rc.i_rc_method = X264_RC_CRF; + param.rc.f_rf_constant = job->vquality; + hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant ); } else { @@ -302,12 +358,12 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) x264_encoder_headers( pv->x264, &nal, &nal_count ); /* Sequence Parameter Set */ - x264_nal_encode( w->config->h264.sps, &nal_size, 0, &nal[1] ); - w->config->h264.sps_length = nal_size; + memcpy(w->config->h264.sps, nal[1].p_payload + 4, nal[1].i_payload - 4); + w->config->h264.sps_length = nal[1].i_payload - 4; /* Picture Parameter Set */ - x264_nal_encode( w->config->h264.pps, &nal_size, 0, &nal[2] ); - w->config->h264.pps_length = nal_size; + memcpy(w->config->h264.pps, nal[2].p_payload + 4, nal[2].i_payload - 4); + w->config->h264.pps_length = nal[2].i_payload - 4; x264_picture_alloc( &pv->pic_in, X264_CSP_I420, job->width, job->height ); @@ -338,10 +394,14 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) pv->init_delay += 2; /* For VFR, libhb sees the FPS as 29.97, but the longest frames - will use the duration of frames running at 23.976fps instead.. */ - if (job->vfr) + will use the duration of frames running at 23.976fps instead. + Since detelecine occasionally makes mistakes and since we have + to deal with some really horrible timing jitter from mkvs and + mp4s encoded with low resolution clocks, make the delay very + conservative if we're not doing CFR. */ + if ( job->cfr != 1 ) { - pv->init_delay = 7506; + pv->init_delay *= 2; } /* The delay is 1 frames for regular b-frames, 2 for b-pyramid. */ @@ -355,6 +415,12 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) void encx264Close( hb_work_object_t * w ) { hb_work_private_t * pv = w->private_data; + + if ( pv->frames_split ) + { + hb_log( "encx264: %u frames had to be split (%u in, %u out)", + pv->frames_split, pv->frames_in, pv->frames_out ); + } /* * Patch the x264 allocated data back in so that x264 can free it * we have been using our own buffers during the encode to avoid copying. @@ -409,8 +475,8 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, int i; for( i = 0; i < i_nal; i++ ) { - int data = buf->alloc - buf->size; - int size = x264_nal_encode( buf->data + buf->size, &data, 1, &nal[i] ); + int size = nal[i].i_payload; + memcpy(buf->data + buf->size, nal[i].p_payload, size); if( size < 1 ) { continue; @@ -427,19 +493,21 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, } /* H.264 in .mp4 or .mkv */ - int naltype = buf->data[buf->size+4] & 0x1f; - if ( naltype == 0x7 || naltype == 0x8 ) + switch( nal[i].i_type ) { - // Sequence Parameter Set & Program Parameter Set go in the - // mp4 header so skip them here - continue; - } + /* Sequence Parameter Set & Program Parameter Set go in the + * mp4 header so skip them here + */ + case NAL_SPS: + case NAL_PPS: + continue; - /* H.264 in mp4 (stolen from mp4creator) */ - buf->data[buf->size+0] = ( ( size - 4 ) >> 24 ) & 0xFF; - buf->data[buf->size+1] = ( ( size - 4 ) >> 16 ) & 0xFF; - buf->data[buf->size+2] = ( ( size - 4 ) >> 8 ) & 0xFF; - buf->data[buf->size+3] = ( ( size - 4 ) >> 0 ) & 0xFF; + case NAL_SLICE: + case NAL_SLICE_IDR: + case NAL_SEI: + default: + break; + } /* Decide what type of frame we have. */ switch( pic_out->i_type ) @@ -487,6 +555,12 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) ) buf->frametype = HB_FRAME_BREF; + /* Expose disposable bit to muxer. */ + if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE ) + buf->flags &= ~HB_FRAME_REF; + else + buf->flags |= HB_FRAME_REF; + buf->size += size; } // make sure we found at least one video frame @@ -548,7 +622,7 @@ static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in ) */ if( pv->last_stop != in->start ) { - hb_log("encx264 input continuity err: last stop %lld start %lld", + hb_log("encx264 input continuity err: last stop %"PRId64" start %"PRId64, pv->last_stop, in->start); } pv->last_stop = in->stop; @@ -598,6 +672,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal ); if ( buf ) { + ++pv->frames_out; if ( last_buf == NULL ) *buf_out = buf; else @@ -616,6 +691,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, } // Not EOF - encode the packet & wrap it in a NAL + ++pv->frames_in; // if we're re-ordering frames, check if this frame is too large to reorder if ( pv->init_delay && in->stop - in->start > pv->init_delay ) @@ -631,6 +707,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, // error. We take advantage of the fact that x264 buffers frame // data internally to feed the same image into the encoder multiple // times, just changing its start & stop times each time. + ++pv->frames_split; int64_t orig_stop = in->stop; int64_t new_stop = in->start; hb_buffer_t *last_buf = NULL; @@ -657,6 +734,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t *buf = x264_encode( w, in ); if ( buf ) { + ++pv->frames_out; if ( last_buf == NULL ) *buf_out = buf; else @@ -668,6 +746,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, } else { + ++pv->frames_out; *buf_out = x264_encode( w, in ); } return HB_WORK_OK;