libhb/encx264.c

   1 /* $Id: encx264.c,v 1.21 2005/11/04 13:09:41 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include <stdarg.h>
   8
   9 #include "hb.h"
  10
  11 #include "x264.h"
  12
  13 int  encx264Init( hb_work_object_t *, hb_job_t * );
  14 int  encx264Work( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
  15 void encx264Close( hb_work_object_t * );
  16
  17 hb_work_object_t hb_encx264 =
  18 {
  19     WORK_ENCX264,
  20     "H.264/AVC encoder (libx264)",
  21     encx264Init,
  22     encx264Work,
  23     encx264Close
  24 };
  25
  26 #define DTS_BUFFER_SIZE 32
  27
  28 /*
  29  * The frame info struct remembers information about each frame across calls
  30  * to x264_encoder_encode. Since frames are uniquely identified by their
  31  * timestamp, we use some bits of the timestamp as an index. The LSB is
  32  * chosen so that two successive frames will have different values in the
  33  * bits over any plausible range of frame rates. (Starting with bit 8 allows
  34  * any frame rate slower than 352fps.) The MSB determines the size of the array.
  35  * It is chosen so that two frames can't use the same slot during the
  36  * encoder's max frame delay (set by the standard as 16 frames) and so
  37  * that, up to some minimum frame rate, frames are guaranteed to map to
  38  * different slots. (An MSB of 17 which is 2^(17-8+1) = 1024 slots guarantees
  39  * no collisions down to a rate of .7 fps).
  40  */
  41 #define FRAME_INFO_MAX2 (8)     // 2^8 = 256; 90000/256 = 352 frames/sec
  42 #define FRAME_INFO_MIN2 (17)    // 2^17 = 128K; 90000/131072 = 1.4 frames/sec
  43 #define FRAME_INFO_SIZE (1 << (FRAME_INFO_MIN2 - FRAME_INFO_MAX2 + 1))
  44 #define FRAME_INFO_MASK (FRAME_INFO_SIZE - 1)
  45
  46 struct hb_work_private_s
  47 {
  48     hb_job_t       * job;
  49     x264_t         * x264;
  50     x264_picture_t   pic_in;
  51     uint8_t         *x264_allocated_pic;
  52
  53     uint32_t       frames_in;
  54     uint32_t       frames_out;
  55     uint32_t       frames_split; // number of frames we had to split
  56     int            chap_mark;   // saved chap mark when we're propagating it
  57     int64_t        last_stop;   // Debugging - stop time of previous input frame
  58     int64_t        next_chap;
  59
  60     struct {
  61         int64_t duration;
  62     } frame_info[FRAME_INFO_SIZE];
  63
  64     char             filename[1024];
  65 };
  66
  67 /***********************************************************************
  68  * hb_work_encx264_init
  69  ***********************************************************************
  70  *
  71  **********************************************************************/
  72 int encx264Init( hb_work_object_t * w, hb_job_t * job )
  73 {
  74     x264_param_t       param;
  75     x264_nal_t       * nal;
  76     int                nal_count;
  77
  78     hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
  79     w->private_data = pv;
  80
  81     pv->job = job;
  82
  83     memset( pv->filename, 0, 1024 );
  84     hb_get_tempory_filename( job->h, pv->filename, "x264.log" );
  85
  86     x264_param_default( &param );
  87
  88     /* Default weightp to off for baseline,
  89        overridable through x264 option strings. */
  90     if( job->x264opts != NULL && *job->x264opts != '\0' )
  91     {
  92         char *x264opts, *x264opts_start;
  93
  94         x264opts = x264opts_start = strdup(job->x264opts);
  95
  96         while( x264opts_start && *x264opts )
  97         {
  98             char *name = x264opts;
  99             char *value;
 100
 101             x264opts += strcspn( x264opts, ":" );
 102             if( *x264opts )
 103             {
 104                 *x264opts = 0;
 105                 x264opts++;
 106             }
 107
 108             value = strchr( name, '=' );
 109             if( value )
 110             {
 111                 *value = 0;
 112                 value++;
 113             }
 114
 115             if( !( strcmp( name, "bframes" ) ) )
 116             {
 117                 if( atoi( value ) == 0 )
 118                 {
 119                     param.analyse.i_weighted_pred = X264_WEIGHTP_NONE;
 120                     hb_log("encx264: no bframes, disabling weight-p unless told otherwise");
 121                 }
 122             }
 123         }
 124     }
 125
 126     /* Enable metrics */
 127     param.analyse.b_psnr = 1;
 128     param.analyse.b_ssim = 1;
 129
 130     param.i_threads    = ( hb_get_cpu_count() * 3 / 2 );
 131     param.i_width      = job->width;
 132     param.i_height     = job->height;
 133     param.i_fps_num    = job->vrate;
 134     param.i_fps_den    = job->vrate_base;
 135     if ( job->cfr == 1 )
 136     {
 137         param.i_timebase_num   = 0;
 138         param.i_timebase_den   = 0;
 139         param.b_vfr_input = 0;
 140     }
 141     else
 142     {
 143         param.i_timebase_num   = 1;
 144         param.i_timebase_den   = 90000;
 145     }
 146
 147     /* Disable annexb. Inserts size into nal header instead of start code */
 148     param.b_annexb     = 0;
 149
 150     /* Set min:max key intervals ratio to 1:10 of fps.
 151      * This section is skipped if fps=25 (default).
 152      */
 153     if (job->vrate_base != 1080000)
 154     {
 155         if (job->pass == 2 && !job->cfr )
 156         {
 157             /* Even though the framerate might be different due to VFR,
 158                we still want the same keyframe intervals as the 1st pass,
 159                so the 1st pass stats won't conflict on frame decisions.    */
 160             hb_interjob_t * interjob = hb_interjob_get( job->h );
 161             param.i_keyint_max = ( ( 10 * (double)interjob->vrate / (double)interjob->vrate_base ) + 0.5 );
 162         }
 163         else
 164         {
 165             /* adjust +0.5 for when fps has remainder to bump
 166                { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */
 167             param.i_keyint_max = ( ( 10 * (double)job->vrate / (double)job->vrate_base ) + 0.5 );
 168         }
 169     }
 170
 171     param.i_log_level  = X264_LOG_INFO;
 172     if( job->h264_level )
 173     {
 174         param.b_cabac     = 0;
 175         param.i_level_idc = job->h264_level;
 176         hb_log( "encx264: encoding at level %i",
 177                 param.i_level_idc );
 178     }
 179
 180     /*
 181         This section passes the string x264opts to libx264 for parsing into
 182         parameter names and values.
 183
 184         The string is set up like this:
 185         option1=value1:option2=value 2
 186
 187         So, you have to iterate through based on the colons, and then put
 188         the left side of the equals sign in "name" and the right side into
 189         "value." Then you hand those strings off to x264 for interpretation.
 190
 191         This is all based on the universal x264 option handling Loren
 192         Merritt implemented in the Mplayer/Mencoder project.
 193      */
 194
 195     if( job->x264opts != NULL && *job->x264opts != '\0' )
 196     {
 197         char *x264opts, *x264opts_start;
 198
 199         x264opts = x264opts_start = strdup(job->x264opts);
 200
 201         while( x264opts_start && *x264opts )
 202         {
 203             char *name = x264opts;
 204             char *value;
 205             int ret;
 206
 207             x264opts += strcspn( x264opts, ":" );
 208             if( *x264opts )
 209             {
 210                 *x264opts = 0;
 211                 x264opts++;
 212             }
 213
 214             value = strchr( name, '=' );
 215             if( value )
 216             {
 217                 *value = 0;
 218                 value++;
 219             }
 220
 221             /* Here's where the strings are passed to libx264 for parsing. */
 222             ret = x264_param_parse( &param, name, value );
 223
 224             /*  Let x264 sanity check the options for us*/
 225             if( ret == X264_PARAM_BAD_NAME )
 226                 hb_log( "x264 options: Unknown suboption %s", name );
 227             if( ret == X264_PARAM_BAD_VALUE )
 228                 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
 229         }
 230         free(x264opts_start);
 231     }
 232
 233     /* B-frames are on by default.*/
 234     job->areBframes = 1;
 235
 236     if( param.i_bframe && param.i_bframe_pyramid )
 237     {
 238         /* Note b-pyramid here, so the initial delay can be doubled */
 239         job->areBframes = 2;
 240     }
 241     else if( !param.i_bframe )
 242     {
 243         /*
 244          When B-frames are enabled, the max frame count increments
 245          by 1 (regardless of the number of B-frames). If you don't
 246          change the duration of the video track when you mux, libmp4
 247          barfs.  So, check if the x264opts aren't using B-frames, and
 248          when they aren't, set the boolean job->areBframes as false.
 249          */
 250         job->areBframes = 0;
 251     }
 252
 253     if( param.i_keyint_min != X264_KEYINT_MIN_AUTO || param.i_keyint_max != 250 )
 254         hb_log("encx264: min-keyint: %i, keyint: %i", param.i_keyint_min == X264_KEYINT_MIN_AUTO ? param.i_keyint_max / 10 : param.i_keyint_min,
 255                                                       param.i_keyint_max);
 256
 257     /* set up the VUI color model & gamma to match what the COLR atom
 258      * set in muxmp4.c says. See libhb/muxmp4.c for notes. */
 259     if( job->color_matrix == 1 )
 260     {
 261         // ITU BT.601 DVD or SD TV content
 262         param.vui.i_colorprim = 6;
 263         param.vui.i_transfer = 1;
 264         param.vui.i_colmatrix = 6;
 265     }
 266     else if( job->color_matrix == 2 )
 267     {
 268         // ITU BT.709 HD content
 269         param.vui.i_colorprim = 1;
 270         param.vui.i_transfer = 1;
 271         param.vui.i_colmatrix = 1;
 272     }
 273     else if ( job->title->width >= 1280 || job->title->height >= 720 )
 274     {
 275         // we guess that 720p or above is ITU BT.709 HD content
 276         param.vui.i_colorprim = 1;
 277         param.vui.i_transfer = 1;
 278         param.vui.i_colmatrix = 1;
 279     }
 280     else
 281     {
 282         // ITU BT.601 DVD or SD TV content
 283         param.vui.i_colorprim = 6;
 284         param.vui.i_transfer = 1;
 285         param.vui.i_colmatrix = 6;
 286     }
 287
 288     if( job->anamorphic.mode )
 289     {
 290         param.vui.i_sar_width  = job->anamorphic.par_width;
 291         param.vui.i_sar_height = job->anamorphic.par_height;
 292
 293         hb_log( "encx264: encoding with stored aspect %d/%d",
 294                 param.vui.i_sar_width, param.vui.i_sar_height );
 295     }
 296
 297
 298     if( job->vquality > 0.0 && job->vquality < 1.0 )
 299     {
 300         /*Constant RF*/
 301         param.rc.i_rc_method = X264_RC_CRF;
 302         param.rc.f_rf_constant = 51 - job->vquality * 51;
 303         hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
 304     }
 305     else if( job->vquality == 0 || job->vquality >= 1.0 )
 306     {
 307         /* Use the vquality as a raw RF or QP
 308           instead of treating it like a percentage. */
 309         /*Constant RF*/
 310         param.rc.i_rc_method = X264_RC_CRF;
 311         param.rc.f_rf_constant = job->vquality;
 312         hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
 313     }
 314     else
 315     {
 316         /* Rate control */
 317         param.rc.i_rc_method = X264_RC_ABR;
 318         param.rc.i_bitrate = job->vbitrate;
 319         switch( job->pass )
 320         {
 321             case 1:
 322                 param.rc.b_stat_write  = 1;
 323                 param.rc.psz_stat_out = pv->filename;
 324                 break;
 325             case 2:
 326                 param.rc.b_stat_read = 1;
 327                 param.rc.psz_stat_in = pv->filename;
 328                 break;
 329         }
 330     }
 331
 332     hb_deep_log( 2, "encx264: opening libx264 (pass %d)", job->pass );
 333     pv->x264 = x264_encoder_open( &param );
 334
 335     x264_encoder_headers( pv->x264, &nal, &nal_count );
 336
 337     /* Sequence Parameter Set */
 338     memcpy(w->config->h264.sps, nal[0].p_payload + 4, nal[0].i_payload - 4);
 339     w->config->h264.sps_length = nal[0].i_payload - 4;
 340
 341     /* Picture Parameter Set */
 342     memcpy(w->config->h264.pps, nal[1].p_payload + 4, nal[1].i_payload - 4);
 343     w->config->h264.pps_length = nal[1].i_payload - 4;
 344
 345     x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
 346                         job->width, job->height );
 347
 348     pv->pic_in.img.i_stride[2] = pv->pic_in.img.i_stride[1] = ( ( job->width + 1 ) >> 1 );
 349     pv->x264_allocated_pic = pv->pic_in.img.plane[0];
 350
 351     return 0;
 352 }
 353
 354 void encx264Close( hb_work_object_t * w )
 355 {
 356     hb_work_private_t * pv = w->private_data;
 357
 358     if ( pv->frames_split )
 359     {
 360         hb_log( "encx264: %u frames had to be split (%u in, %u out)",
 361                 pv->frames_split, pv->frames_in, pv->frames_out );
 362     }
 363     /*
 364      * Patch the x264 allocated data back in so that x264 can free it
 365      * we have been using our own buffers during the encode to avoid copying.
 366      */
 367     pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
 368     x264_picture_clean( &pv->pic_in );
 369     x264_encoder_close( pv->x264 );
 370     free( pv );
 371     w->private_data = NULL;
 372
 373     /* TODO */
 374 }
 375
 376 /*
 377  * see comments in definition of 'frame_info' in pv struct for description
 378  * of what these routines are doing.
 379  */
 380 static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
 381 {
 382     int i = (in->start >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 383     pv->frame_info[i].duration = in->stop - in->start;
 384 }
 385
 386 static int64_t get_frame_duration( hb_work_private_t * pv, int64_t pts )
 387 {
 388     int i = (pts >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 389     return pv->frame_info[i].duration;
 390 }
 391
 392 static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out,
 393                                 int i_nal, x264_nal_t *nal )
 394 {
 395     hb_buffer_t *buf = NULL;
 396     hb_work_private_t *pv = w->private_data;
 397     hb_job_t *job = pv->job;
 398
 399     /* Should be way too large */
 400     buf = hb_video_buffer_init( job->width, job->height );
 401     buf->size = 0;
 402     buf->frametype = 0;
 403
 404     // use the pts to get the original frame's duration.
 405     int64_t duration  = get_frame_duration( pv, pic_out->i_pts );
 406     buf->start = pic_out->i_pts;
 407     buf->stop  = pic_out->i_pts + duration;
 408     buf->renderOffset = pic_out->i_dts;
 409     if ( !w->config->h264.init_delay && pic_out->i_dts < 0 )
 410     {
 411         w->config->h264.init_delay = -pic_out->i_dts;
 412     }
 413
 414     /* Encode all the NALs we were given into buf.
 415        NOTE: This code assumes one video frame per NAL (but there can
 416              be other stuff like SPS and/or PPS). If there are multiple
 417              frames we only get the duration of the first which will
 418              eventually screw up the muxer & decoder. */
 419     int i;
 420     for( i = 0; i < i_nal; i++ )
 421     {
 422         int size = nal[i].i_payload;
 423         memcpy(buf->data + buf->size, nal[i].p_payload, size);
 424         if( size < 1 )
 425         {
 426             continue;
 427         }
 428
 429         if( job->mux & HB_MUX_AVI )
 430         {
 431             if( nal[i].i_ref_idc == NAL_PRIORITY_HIGHEST )
 432             {
 433                 buf->frametype = HB_FRAME_KEY;
 434             }
 435             buf->size += size;
 436             continue;
 437         }
 438
 439         /* H.264 in .mp4 or .mkv */
 440         switch( nal[i].i_type )
 441         {
 442             /* Sequence Parameter Set & Program Parameter Set go in the
 443              * mp4 header so skip them here
 444              */
 445             case NAL_SPS:
 446             case NAL_PPS:
 447                 continue;
 448
 449             case NAL_SLICE:
 450             case NAL_SLICE_IDR:
 451             case NAL_SEI:
 452             default:
 453                 break;
 454         }
 455
 456         /* Decide what type of frame we have. */
 457         switch( pic_out->i_type )
 458         {
 459             case X264_TYPE_IDR:
 460                 buf->frametype = HB_FRAME_IDR;
 461                 /* if we have a chapter marker pending and this
 462                    frame's presentation time stamp is at or after
 463                    the marker's time stamp, use this as the
 464                    chapter start. */
 465                 if( pv->next_chap != 0 && pv->next_chap <= pic_out->i_pts )
 466                 {
 467                     pv->next_chap = 0;
 468                     buf->new_chap = pv->chap_mark;
 469                 }
 470                 break;
 471
 472             case X264_TYPE_I:
 473                 buf->frametype = HB_FRAME_I;
 474                 break;
 475
 476             case X264_TYPE_P:
 477                 buf->frametype = HB_FRAME_P;
 478                 break;
 479
 480             case X264_TYPE_B:
 481                 buf->frametype = HB_FRAME_B;
 482                 break;
 483
 484         /*  This is for b-pyramid, which has reference b-frames
 485             However, it doesn't seem to ever be used... */
 486             case X264_TYPE_BREF:
 487                 buf->frametype = HB_FRAME_BREF;
 488                 break;
 489
 490             // If it isn't the above, what type of frame is it??
 491             default:
 492                 buf->frametype = 0;
 493                 break;
 494         }
 495
 496         /* Since libx264 doesn't tell us when b-frames are
 497            themselves reference frames, figure it out on our own. */
 498         if( (buf->frametype == HB_FRAME_B) &&
 499             (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) )
 500             buf->frametype = HB_FRAME_BREF;
 501
 502         /* Expose disposable bit to muxer. */
 503         if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE )
 504             buf->flags &= ~HB_FRAME_REF;
 505         else
 506             buf->flags |= HB_FRAME_REF;
 507
 508         buf->size += size;
 509     }
 510     // make sure we found at least one video frame
 511     if ( buf->size <= 0 )
 512     {
 513         // no video - discard the buf
 514         hb_buffer_close( &buf );
 515     }
 516     return buf;
 517 }
 518
 519 static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in )
 520 {
 521     hb_work_private_t *pv = w->private_data;
 522     hb_job_t *job = pv->job;
 523
 524     /* Point x264 at our current buffers Y(UV) data.  */
 525     pv->pic_in.img.plane[0] = in->data;
 526
 527     int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 );
 528     if( job->grayscale )
 529     {
 530         /* XXX x264 has currently no option for grayscale encoding */
 531         memset( pv->pic_in.img.plane[1], 0x80, uvsize );
 532         memset( pv->pic_in.img.plane[2], 0x80, uvsize );
 533     }
 534     else
 535     {
 536         /* Point x264 at our buffers (Y)UV data */
 537         pv->pic_in.img.plane[1] = in->data + job->width * job->height;
 538         pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize;
 539     }
 540     if( in->new_chap && job->chapter_markers )
 541     {
 542         /* chapters have to start with an IDR frame so request that this
 543            frame be coded as IDR. Since there may be up to 16 frames
 544            currently buffered in the encoder remember the timestamp so
 545            when this frame finally pops out of the encoder we'll mark
 546            its buffer as the start of a chapter. */
 547         pv->pic_in.i_type = X264_TYPE_IDR;
 548         if( pv->next_chap == 0 )
 549         {
 550             pv->next_chap = in->start;
 551             pv->chap_mark = in->new_chap;
 552         }
 553         /* don't let 'work_loop' put a chapter mark on the wrong buffer */
 554         in->new_chap = 0;
 555     }
 556     else
 557     {
 558         pv->pic_in.i_type = X264_TYPE_AUTO;
 559     }
 560     pv->pic_in.i_qpplus1 = 0;
 561
 562     /* XXX this is temporary debugging code to check that the upstream
 563      * modules (render & sync) have generated a continuous, self-consistent
 564      * frame stream with the current frame's start time equal to the
 565      * previous frame's stop time.
 566      */
 567     if( pv->last_stop != in->start )
 568     {
 569         hb_log("encx264 input continuity err: last stop %"PRId64"  start %"PRId64,
 570                 pv->last_stop, in->start);
 571     }
 572     pv->last_stop = in->stop;
 573
 574     // Remember info about this frame that we need to pass across
 575     // the x264_encoder_encode call (since it reorders frames).
 576     save_frame_info( pv, in );
 577
 578     /* Feed the input PTS to x264 so it can figure out proper output PTS */
 579     pv->pic_in.i_pts = in->start;
 580
 581     x264_picture_t pic_out;
 582     int i_nal;
 583     x264_nal_t *nal;
 584
 585     x264_encoder_encode( pv->x264, &nal, &i_nal, &pv->pic_in, &pic_out );
 586     if ( i_nal > 0 )
 587     {
 588         return nal_encode( w, &pic_out, i_nal, nal );
 589     }
 590     return NULL;
 591 }
 592
 593 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
 594                   hb_buffer_t ** buf_out )
 595 {
 596     hb_work_private_t *pv = w->private_data;
 597     hb_buffer_t *in = *buf_in;
 598
 599     *buf_out = NULL;
 600
 601     if( in->size <= 0 )
 602     {
 603         // EOF on input. Flush any frames still in the decoder then
 604         // send the eof downstream to tell the muxer we're done.
 605         x264_picture_t pic_out;
 606         int i_nal;
 607         x264_nal_t *nal;
 608         hb_buffer_t *last_buf = NULL;
 609
 610         while ( x264_encoder_delayed_frames( pv->x264 ) )
 611         {
 612             x264_encoder_encode( pv->x264, &nal, &i_nal, NULL, &pic_out );
 613             if ( i_nal == 0 )
 614                 continue;
 615             if ( i_nal < 0 )
 616                 break;
 617
 618             hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal );
 619             if ( buf )
 620             {
 621                 ++pv->frames_out;
 622                 if ( last_buf == NULL )
 623                     *buf_out = buf;
 624                 else
 625                     last_buf->next = buf;
 626                 last_buf = buf;
 627             }
 628         }
 629         // Flushed everything - add the eof to the end of the chain.
 630         if ( last_buf == NULL )
 631             *buf_out = in;
 632         else
 633             last_buf->next = in;
 634
 635         *buf_in = NULL;
 636         return HB_WORK_DONE;
 637     }
 638
 639     // Not EOF - encode the packet & wrap it in a NAL
 640     ++pv->frames_in;
 641     ++pv->frames_out;
 642     *buf_out = x264_encode( w, in );
 643     return HB_WORK_OK;
 644 }