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.m0k.org/>.
   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 9 allows
  34  * any frame rate slower than 175fps.) 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 16 which is 2^(16-9+1) = 256 slots guarantees
  39  * no collisions down to a rate of 1.4 fps).
  40  */
  41 #define FRAME_INFO_MAX2 (9)     // 2^9 = 512; 90000/512 = 175 frames/sec
  42 #define FRAME_INFO_MIN2 (16)    // 2^16 = 65536; 90000/65536 = 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     int            chap_mark;   // saved chap mark when we're propagating it
  54     int64_t        dts_next;    // DTS start time value for next output frame
  55     int64_t        last_stop;   // Debugging - stop time of previous input frame
  56     int64_t        init_delay;
  57     int64_t        next_chap;
  58
  59     struct {
  60         int64_t duration;
  61     } frame_info[FRAME_INFO_SIZE];
  62
  63     char             filename[1024];
  64 };
  65
  66 /***********************************************************************
  67  * hb_work_encx264_init
  68  ***********************************************************************
  69  *
  70  **********************************************************************/
  71 int encx264Init( hb_work_object_t * w, hb_job_t * job )
  72 {
  73     x264_param_t       param;
  74     x264_nal_t       * nal;
  75     int                nal_count;
  76
  77     hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
  78     w->private_data = pv;
  79
  80     pv->job = job;
  81
  82     memset( pv->filename, 0, 1024 );
  83     hb_get_tempory_filename( job->h, pv->filename, "x264.log" );
  84
  85     x264_param_default( &param );
  86
  87     param.i_threads    = ( hb_get_cpu_count() * 3 / 2 );
  88     param.i_width      = job->width;
  89     param.i_height     = job->height;
  90     param.i_fps_num    = job->vrate;
  91     param.i_fps_den    = job->vrate_base;
  92
  93     if (job->vrate_base != 1080000)
  94     {
  95         /* If the fps isn't 25, adjust the key intervals. Add 1 because
  96            we want 24, not 23 with a truncated remainder.               */
  97         param.i_keyint_min     = (job->vrate / job->vrate_base) + 1;
  98         param.i_keyint_max = (10 * job->vrate / job->vrate_base) + 1;
  99         hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max);
 100     }
 101
 102     param.i_log_level  = X264_LOG_INFO;
 103     if( job->h264_level )
 104     {
 105         param.b_cabac     = 0;
 106         param.i_level_idc = job->h264_level;
 107         hb_log( "encx264: encoding at level %i",
 108                 param.i_level_idc );
 109     }
 110
 111     /* Slightly faster with minimal quality lost */
 112     param.analyse.i_subpel_refine = 4;
 113
 114     /*
 115         This section passes the string x264opts to libx264 for parsing into
 116         parameter names and values.
 117
 118         The string is set up like this:
 119         option1=value1:option2=value 2
 120
 121         So, you have to iterate through based on the colons, and then put
 122         the left side of the equals sign in "name" and the right side into
 123         "value." Then you hand those strings off to x264 for interpretation.
 124
 125         This is all based on the universal x264 option handling Loren
 126         Merritt implemented in the Mplayer/Mencoder project.
 127      */
 128
 129     if( job->x264opts != NULL && *job->x264opts != '\0' )
 130     {
 131         char *x264opts, *x264opts_start;
 132
 133         x264opts = x264opts_start = strdup(job->x264opts);
 134
 135         while( x264opts_start && *x264opts )
 136         {
 137             char *name = x264opts;
 138             char *value;
 139             int ret;
 140
 141             x264opts += strcspn( x264opts, ":" );
 142             if( *x264opts )
 143             {
 144                 *x264opts = 0;
 145                 x264opts++;
 146             }
 147
 148             value = strchr( name, '=' );
 149             if( value )
 150             {
 151                 *value = 0;
 152                 value++;
 153             }
 154
 155             /*
 156                When B-frames are enabled, the max frame count increments
 157                by 1 (regardless of the number of B-frames). If you don't
 158                change the duration of the video track when you mux, libmp4
 159                barfs.  So, check if the x264opts are using B-frames, and
 160                when they are, set the boolean job->areBframes as true.
 161              */
 162
 163             if( !( strcmp( name, "bframes" ) ) )
 164             {
 165                 if( atoi( value ) > 0 )
 166                 {
 167                     job->areBframes = 1;
 168                 }
 169             }
 170
 171             /* Note b-pyramid here, so the initial delay can be doubled */
 172             if( !( strcmp( name, "b-pyramid" ) ) )
 173             {
 174                 if( value != NULL )
 175                 {
 176                     if( atoi( value ) > 0 )
 177                     {
 178                         job->areBframes = 2;
 179                     }
 180                 }
 181                 else
 182                 {
 183                     job->areBframes = 2;
 184                 }
 185             }
 186
 187             /* Here's where the strings are passed to libx264 for parsing. */
 188             ret = x264_param_parse( &param, name, value );
 189
 190             /*  Let x264 sanity check the options for us*/
 191             if( ret == X264_PARAM_BAD_NAME )
 192                 hb_log( "x264 options: Unknown suboption %s", name );
 193             if( ret == X264_PARAM_BAD_VALUE )
 194                 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
 195         }
 196         free(x264opts_start);
 197     }
 198
 199
 200     if( job->pixel_ratio )
 201     {
 202         param.vui.i_sar_width = job->pixel_aspect_width;
 203         param.vui.i_sar_height = job->pixel_aspect_height;
 204
 205         hb_log( "encx264: encoding with stored aspect %d/%d",
 206                 param.vui.i_sar_width, param.vui.i_sar_height );
 207     }
 208
 209
 210     if( job->vquality >= 0.0 && job->vquality <= 1.0 )
 211     {
 212         switch( job->crf )
 213         {
 214             case 1:
 215                 /*Constant RF*/
 216                 param.rc.i_rc_method = X264_RC_CRF;
 217                 param.rc.f_rf_constant = 51 - job->vquality * 51;
 218                 hb_log( "encx264: Encoding at constant RF %f",
 219                         param.rc.f_rf_constant );
 220                 break;
 221
 222             case 0:
 223                 /*Constant QP*/
 224                 param.rc.i_rc_method = X264_RC_CQP;
 225                 param.rc.i_qp_constant = 51 - job->vquality * 51;
 226                 hb_log( "encx264: encoding at constant QP %d",
 227                         param.rc.i_qp_constant );
 228                 break;
 229         }
 230     }
 231     else
 232     {
 233         /* Rate control */
 234         param.rc.i_rc_method = X264_RC_ABR;
 235         param.rc.i_bitrate = job->vbitrate;
 236         switch( job->pass )
 237         {
 238             case 1:
 239                 param.rc.b_stat_write  = 1;
 240                 param.rc.psz_stat_out = pv->filename;
 241                 break;
 242             case 2:
 243                 param.rc.b_stat_read = 1;
 244                 param.rc.psz_stat_in = pv->filename;
 245                 break;
 246         }
 247     }
 248
 249     hb_log( "encx264: opening libx264 (pass %d)", job->pass );
 250     pv->x264 = x264_encoder_open( &param );
 251
 252     x264_encoder_headers( pv->x264, &nal, &nal_count );
 253
 254     /* Sequence Parameter Set */
 255     w->config->h264.sps_length = 1 + nal[1].i_payload;
 256     w->config->h264.sps[0] = 0x67;
 257     memcpy( &w->config->h264.sps[1], nal[1].p_payload, nal[1].i_payload );
 258
 259     /* Picture Parameter Set */
 260     w->config->h264.pps_length = 1 + nal[2].i_payload;
 261     w->config->h264.pps[0] = 0x68;
 262     memcpy( &w->config->h264.pps[1], nal[2].p_payload, nal[2].i_payload );
 263
 264     x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
 265                         job->width, job->height );
 266
 267     pv->x264_allocated_pic = pv->pic_in.img.plane[0];
 268
 269     pv->dts_next = -1;
 270     pv->next_chap = 0;
 271
 272     if (job->areBframes)
 273     {
 274         /* Basic initDelay value is the clockrate divided by the FPS
 275            -- the length of one frame in clockticks.                  */
 276         pv->init_delay = (float)90000 / (float)((float)job->vrate / (float)job->vrate_base);
 277
 278         /* 23.976-length frames are 3753.75 ticks long. That means 25%
 279            will come out as 3753, 75% will be 3754. The delay has to be
 280            the longest possible frame duration, 3754. However, 3753.75
 281            gets truncated to 3753, so if that's what it is, ++ it.     */
 282         if (pv->init_delay == 3753)
 283             pv->init_delay++;
 284
 285         /* For VFR, libhb sees the FPS as 29.97, but the longest frames
 286            will use the duration of frames running at 23.976fps instead.. */
 287         if (job->vfr)
 288         {
 289             pv->init_delay = 7506;
 290         }
 291
 292         /* The delay is 1 frames for regular b-frames, 2 for b-pyramid. */
 293         pv->init_delay *= job->areBframes;
 294     }
 295
 296     return 0;
 297 }
 298
 299 void encx264Close( hb_work_object_t * w )
 300 {
 301     hb_work_private_t * pv = w->private_data;
 302     /*
 303      * Patch the x264 allocated data back in so that x264 can free it
 304      * we have been using our own buffers during the encode to avoid copying.
 305      */
 306     pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
 307     x264_picture_clean( &pv->pic_in );
 308     x264_encoder_close( pv->x264 );
 309     free( pv );
 310     w->private_data = NULL;
 311
 312     /* TODO */
 313 }
 314
 315 /*
 316  * see comments in definition of 'frame_info' in pv struct for description
 317  * of what these routines are doing.
 318  */
 319 static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
 320 {
 321     int i = (in->start >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 322     pv->frame_info[i].duration = in->stop - in->start;
 323 }
 324
 325 static int64_t get_frame_duration( hb_work_private_t * pv, int64_t pts )
 326 {
 327     int i = (pts >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 328     return pv->frame_info[i].duration;
 329 }
 330
 331 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
 332                   hb_buffer_t ** buf_out )
 333 {
 334     hb_work_private_t * pv = w->private_data;
 335     hb_job_t    * job = pv->job;
 336     hb_buffer_t * in = *buf_in, * buf;
 337     x264_picture_t   pic_out;
 338     int           i_nal;
 339     x264_nal_t  * nal;
 340     int i;
 341
 342     if( in->data )
 343     {
 344         /*
 345          * Point x264 at our current buffers Y(UV) data.
 346          */
 347         pv->pic_in.img.plane[0] = in->data;
 348
 349         if( job->grayscale )
 350         {
 351             /* XXX x264 has currently no option for grayscale encoding */
 352             memset( pv->pic_in.img.plane[1], 0x80, job->width * job->height / 4 );
 353             memset( pv->pic_in.img.plane[2], 0x80, job->width * job->height / 4 );
 354         }
 355         else
 356         {
 357             /*
 358              * Point x264 at our buffers (Y)UV data
 359              */
 360             pv->pic_in.img.plane[1] = in->data + job->width * job->height;
 361             pv->pic_in.img.plane[2] = in->data + 5 * job->width *
 362                 job->height / 4;
 363         }
 364
 365         if( pv->dts_next == -1 )
 366         {
 367             /* we don't have a start time yet so use the first frame's
 368              * start. All other frame times will be determined by the
 369              * sum of the prior output frame durations in *DTS* order
 370              * (not by the order they arrive here). This timing change is
 371              * essential for VFR with b-frames but a complete nop otherwise.
 372              */
 373             pv->dts_next = in->start;
 374         }
 375         if( in->new_chap && job->chapter_markers )
 376         {
 377             /* chapters have to start with an IDR frame so request that this
 378                frame be coded as IDR. Since there may be up to 16 frames
 379                currently buffered in the encoder remember the timestamp so
 380                when this frame finally pops out of the encoder we'll mark
 381                its buffer as the start of a chapter. */
 382             pv->pic_in.i_type = X264_TYPE_IDR;
 383             if( pv->next_chap == 0 )
 384             {
 385                 pv->next_chap = in->start;
 386                 pv->chap_mark = in->new_chap;
 387             }
 388             /* don't let 'work_loop' put a chapter mark on the wrong buffer */
 389             in->new_chap = 0;
 390         }
 391         else
 392         {
 393             pv->pic_in.i_type = X264_TYPE_AUTO;
 394         }
 395         pv->pic_in.i_qpplus1 = 0;
 396
 397         /* XXX this is temporary debugging code to check that the upstream
 398          * modules (render & sync) have generated a continuous, self-consistent
 399          * frame stream with the current frame's start time equal to the
 400          * previous frame's stop time.
 401          */
 402         if( pv->last_stop != in->start )
 403         {
 404             hb_log("encx264 input continuity err: last stop %lld  start %lld",
 405                     pv->last_stop, in->start);
 406         }
 407         pv->last_stop = in->stop;
 408
 409         // Remember info about this frame that we need to pass across
 410         // the x264_encoder_encode call (since it reorders frames).
 411         save_frame_info( pv, in );
 412
 413         /* Feed the input DTS to x264 so it can figure out proper output PTS */
 414         pv->pic_in.i_pts = in->start;
 415
 416         x264_encoder_encode( pv->x264, &nal, &i_nal,
 417                              &pv->pic_in, &pic_out );
 418     }
 419     else
 420     {
 421         x264_encoder_encode( pv->x264, &nal, &i_nal,
 422                              NULL, &pic_out );
 423         /* No more delayed B frames */
 424         if( i_nal == 0 )
 425         {
 426             *buf_out = NULL;
 427             return HB_WORK_DONE;
 428         }
 429         else
 430         {
 431         /*  Since we output at least one more frame, drop another empty
 432             one onto our input fifo.  We'll keep doing this automatically
 433             until we stop getting frames out of the encoder. */
 434             hb_fifo_push(w->fifo_in, hb_buffer_init(0));
 435         }
 436     }
 437
 438     if( i_nal )
 439     {
 440         /* Should be way too large */
 441         buf        = hb_buffer_init( 3 * job->width * job->height / 2 );
 442         buf->size  = 0;
 443         buf->frametype   = 0;
 444
 445         /* Get next DTS value to use */
 446         int64_t dts_start = pv->dts_next;
 447
 448         /* compute the stop time based on the original frame's duration */
 449         int64_t dts_stop  = dts_start + get_frame_duration( pv, pic_out.i_pts );
 450         pv->dts_next = dts_stop;
 451
 452         for( i = 0; i < i_nal; i++ )
 453         {
 454             int size, data;
 455
 456             data = buf->alloc - buf->size;
 457             if( ( size = x264_nal_encode( buf->data + buf->size, &data,
 458                                           1, &nal[i] ) ) < 1 )
 459             {
 460                 continue;
 461             }
 462
 463             if( job->mux & HB_MUX_AVI )
 464             {
 465                 if( nal[i].i_ref_idc == NAL_PRIORITY_HIGHEST )
 466                 {
 467                     buf->frametype = HB_FRAME_KEY;
 468                 }
 469                 buf->size += size;
 470                 continue;
 471             }
 472
 473             /* H.264 in .mp4 */
 474             switch( buf->data[buf->size+4] & 0x1f )
 475             {
 476                 case 0x7:
 477                 case 0x8:
 478                     /* SPS, PPS */
 479                     break;
 480
 481                 default:
 482                     /* H.264 in mp4 (stolen from mp4creator) */
 483                     buf->data[buf->size+0] = ( ( size - 4 ) >> 24 ) & 0xFF;
 484                     buf->data[buf->size+1] = ( ( size - 4 ) >> 16 ) & 0xFF;
 485                     buf->data[buf->size+2] = ( ( size - 4 ) >>  8 ) & 0xFF;
 486                     buf->data[buf->size+3] = ( ( size - 4 ) >>  0 ) & 0xFF;
 487                     switch( pic_out.i_type )
 488                     {
 489                     /*  Decide what type of frame we have. */
 490                         case X264_TYPE_IDR:
 491                             buf->frametype = HB_FRAME_IDR;
 492                             /* if we have a chapter marker pending and this
 493                                frame's presentation time stamp is at or after
 494                                the marker's time stamp, use this as the
 495                                chapter start. */
 496                             if( pv->next_chap != 0 && pv->next_chap <= pic_out.i_pts )
 497                             {
 498                                 pv->next_chap = 0;
 499                                 buf->new_chap = pv->chap_mark;
 500                             }
 501                             break;
 502                         case X264_TYPE_I:
 503                             buf->frametype = HB_FRAME_I;
 504                             break;
 505                         case X264_TYPE_P:
 506                             buf->frametype = HB_FRAME_P;
 507                             break;
 508                         case X264_TYPE_B:
 509                             buf->frametype = HB_FRAME_B;
 510                             break;
 511                     /*  This is for b-pyramid, which has reference b-frames
 512                         However, it doesn't seem to ever be used... */
 513                         case X264_TYPE_BREF:
 514                             buf->frametype = HB_FRAME_BREF;
 515                             break;
 516                     /*  If it isn't the above, what type of frame is it?? */
 517                         default:
 518                             buf->frametype = 0;
 519                     }
 520
 521                     /* Since libx264 doesn't tell us when b-frames are
 522                        themselves reference frames, figure it out on our own. */
 523                     if( (buf->frametype == HB_FRAME_B) && (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) )
 524                         buf->frametype = HB_FRAME_BREF;
 525
 526                     /* Store the output presentation time stamp
 527                        from x264 for use by muxmp4 in off-setting
 528                        b-frames with the CTTS atom. */
 529                     buf->renderOffset = pic_out.i_pts - dts_start + pv->init_delay;
 530
 531                     buf->size += size;
 532             }
 533         }
 534         /* Send out the next dts values */
 535         buf->start = dts_start;
 536         buf->stop  = dts_stop;
 537     }
 538
 539     else
 540         buf = NULL;
 541
 542     *buf_out = buf;
 543
 544     return HB_WORK_OK;
 545 }