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        init_delay;
  59     int64_t        next_chap;
  60
  61     struct {
  62         int64_t duration;
  63     } frame_info[FRAME_INFO_SIZE];
  64
  65     char             filename[1024];
  66 };
  67
  68 /***********************************************************************
  69  * hb_work_encx264_init
  70  ***********************************************************************
  71  *
  72  **********************************************************************/
  73 int encx264Init( hb_work_object_t * w, hb_job_t * job )
  74 {
  75     x264_param_t       param;
  76     x264_nal_t       * nal;
  77     int                nal_count;
  78
  79     hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
  80     w->private_data = pv;
  81
  82     pv->job = job;
  83
  84     memset( pv->filename, 0, 1024 );
  85     hb_get_tempory_filename( job->h, pv->filename, "x264.log" );
  86
  87     x264_param_default( &param );
  88
  89     /* Default weightp to off for baseline,
  90        overridable through x264 option strings. */
  91     if( job->x264opts != NULL && *job->x264opts != '\0' )
  92     {
  93         char *x264opts, *x264opts_start;
  94
  95         x264opts = x264opts_start = strdup(job->x264opts);
  96
  97         while( x264opts_start && *x264opts )
  98         {
  99             char *name = x264opts;
 100             char *value;
 101
 102             x264opts += strcspn( x264opts, ":" );
 103             if( *x264opts )
 104             {
 105                 *x264opts = 0;
 106                 x264opts++;
 107             }
 108
 109             value = strchr( name, '=' );
 110             if( value )
 111             {
 112                 *value = 0;
 113                 value++;
 114             }
 115
 116             /*
 117                When B-frames are enabled, the max frame count increments
 118                by 1 (regardless of the number of B-frames). If you don't
 119                change the duration of the video track when you mux, libmp4
 120                barfs.  So, check if the x264opts aren't using B-frames, and
 121                when they aren't, set the boolean job->areBframes as false.
 122              */
 123             if( !( strcmp( name, "bframes" ) ) )
 124             {
 125                 if( atoi( value ) == 0 )
 126                 {
 127                     param.analyse.i_weighted_pred = X264_WEIGHTP_NONE;
 128                 }
 129             }
 130         }
 131     }
 132
 133     /* Enable metrics */
 134     param.analyse.b_psnr = 1;
 135     param.analyse.b_ssim = 1;
 136
 137     param.i_threads    = ( hb_get_cpu_count() * 3 / 2 );
 138     param.i_width      = job->width;
 139     param.i_height     = job->height;
 140     param.i_fps_num    = job->vrate;
 141     param.i_fps_den    = job->vrate_base;
 142
 143     /* Disable annexb. Inserts size into nal header instead of start code */
 144     param.b_annexb     = 0;
 145
 146     /* Set min:max key intervals ratio to 1:10 of fps.
 147      * This section is skipped if fps=25 (default).
 148      */
 149     if (job->vrate_base != 1080000)
 150     {
 151         if (job->pass == 2 && !job->cfr )
 152         {
 153             /* Even though the framerate might be different due to VFR,
 154                we still want the same keyframe intervals as the 1st pass,
 155                so the 1st pass stats won't conflict on frame decisions.    */
 156             hb_interjob_t * interjob = hb_interjob_get( job->h );
 157             param.i_keyint_min     = ( interjob->vrate / interjob->vrate_base ) + 1;
 158             param.i_keyint_max = ( 10 * interjob->vrate / interjob->vrate_base ) + 1;
 159         }
 160         else
 161         {
 162             int fps = job->vrate / job->vrate_base;
 163
 164             /* adjust +1 when fps has remainder to bump
 165                { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */
 166             if (job->vrate % job->vrate_base)
 167                 fps += 1;
 168
 169             param.i_keyint_min = fps;
 170             param.i_keyint_max = fps * 10;
 171         }
 172
 173         hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max);
 174     }
 175
 176     param.i_log_level  = X264_LOG_INFO;
 177     if( job->h264_level )
 178     {
 179         param.b_cabac     = 0;
 180         param.i_level_idc = job->h264_level;
 181         hb_log( "encx264: encoding at level %i",
 182                 param.i_level_idc );
 183     }
 184
 185     /* B-frames are on by default.*/
 186     job->areBframes = 1;
 187
 188     /*
 189         This section passes the string x264opts to libx264 for parsing into
 190         parameter names and values.
 191
 192         The string is set up like this:
 193         option1=value1:option2=value 2
 194
 195         So, you have to iterate through based on the colons, and then put
 196         the left side of the equals sign in "name" and the right side into
 197         "value." Then you hand those strings off to x264 for interpretation.
 198
 199         This is all based on the universal x264 option handling Loren
 200         Merritt implemented in the Mplayer/Mencoder project.
 201      */
 202
 203     if( job->x264opts != NULL && *job->x264opts != '\0' )
 204     {
 205         char *x264opts, *x264opts_start;
 206
 207         x264opts = x264opts_start = strdup(job->x264opts);
 208
 209         while( x264opts_start && *x264opts )
 210         {
 211             char *name = x264opts;
 212             char *value;
 213             int ret;
 214
 215             x264opts += strcspn( x264opts, ":" );
 216             if( *x264opts )
 217             {
 218                 *x264opts = 0;
 219                 x264opts++;
 220             }
 221
 222             value = strchr( name, '=' );
 223             if( value )
 224             {
 225                 *value = 0;
 226                 value++;
 227             }
 228
 229             /*
 230                When B-frames are enabled, the max frame count increments
 231                by 1 (regardless of the number of B-frames). If you don't
 232                change the duration of the video track when you mux, libmp4
 233                barfs.  So, check if the x264opts aren't using B-frames, and
 234                when they aren't, set the boolean job->areBframes as false.
 235              */
 236             if( !( strcmp( name, "bframes" ) ) )
 237             {
 238                 if( atoi( value ) == 0 )
 239                 {
 240                     job->areBframes = 0;
 241                 }
 242             }
 243
 244             /* Note b-pyramid here, so the initial delay can be doubled */
 245             if( !( strcmp( name, "b-pyramid" ) ) )
 246             {
 247                 if( value != NULL )
 248                 {
 249                     if( atoi( value ) > 0 )
 250                     {
 251                         job->areBframes = 2;
 252                     }
 253                 }
 254                 else
 255                 {
 256                     job->areBframes = 2;
 257                 }
 258                 if( value == NULL || !strcmp( value, "1" ) )
 259                 {
 260                     value = "normal";
 261                 }
 262                 else if( !strcmp( value, "0" ) )
 263                 {
 264                     value = "none";
 265                 }
 266             }
 267
 268             /* Here's where the strings are passed to libx264 for parsing. */
 269             ret = x264_param_parse( &param, name, value );
 270
 271             /*  Let x264 sanity check the options for us*/
 272             if( ret == X264_PARAM_BAD_NAME )
 273                 hb_log( "x264 options: Unknown suboption %s", name );
 274             if( ret == X264_PARAM_BAD_VALUE )
 275                 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
 276         }
 277         free(x264opts_start);
 278     }
 279
 280     /* set up the VUI color model & gamma to match what the COLR atom
 281      * set in muxmp4.c says. See libhb/muxmp4.c for notes. */
 282     if( job->color_matrix == 1 )
 283     {
 284         // ITU BT.601 DVD or SD TV content
 285         param.vui.i_colorprim = 6;
 286         param.vui.i_transfer = 1;
 287         param.vui.i_colmatrix = 6;
 288     }
 289     else if( job->color_matrix == 2 )
 290     {
 291         // ITU BT.709 HD content
 292         param.vui.i_colorprim = 1;
 293         param.vui.i_transfer = 1;
 294         param.vui.i_colmatrix = 1;
 295     }
 296     else if ( job->title->width >= 1280 || job->title->height >= 720 )
 297     {
 298         // we guess that 720p or above is ITU BT.709 HD content
 299         param.vui.i_colorprim = 1;
 300         param.vui.i_transfer = 1;
 301         param.vui.i_colmatrix = 1;
 302     }
 303     else
 304     {
 305         // ITU BT.601 DVD or SD TV content
 306         param.vui.i_colorprim = 6;
 307         param.vui.i_transfer = 1;
 308         param.vui.i_colmatrix = 6;
 309     }
 310
 311     if( job->anamorphic.mode )
 312     {
 313         param.vui.i_sar_width  = job->anamorphic.par_width;
 314         param.vui.i_sar_height = job->anamorphic.par_height;
 315
 316         hb_log( "encx264: encoding with stored aspect %d/%d",
 317                 param.vui.i_sar_width, param.vui.i_sar_height );
 318     }
 319
 320
 321     if( job->vquality > 0.0 && job->vquality < 1.0 )
 322     {
 323         /*Constant RF*/
 324         param.rc.i_rc_method = X264_RC_CRF;
 325         param.rc.f_rf_constant = 51 - job->vquality * 51;
 326         hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
 327     }
 328     else if( job->vquality == 0 || job->vquality >= 1.0 )
 329     {
 330         /* Use the vquality as a raw RF or QP
 331           instead of treating it like a percentage. */
 332         /*Constant RF*/
 333         param.rc.i_rc_method = X264_RC_CRF;
 334         param.rc.f_rf_constant = job->vquality;
 335         hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
 336     }
 337     else
 338     {
 339         /* Rate control */
 340         param.rc.i_rc_method = X264_RC_ABR;
 341         param.rc.i_bitrate = job->vbitrate;
 342         switch( job->pass )
 343         {
 344             case 1:
 345                 param.rc.b_stat_write  = 1;
 346                 param.rc.psz_stat_out = pv->filename;
 347                 break;
 348             case 2:
 349                 param.rc.b_stat_read = 1;
 350                 param.rc.psz_stat_in = pv->filename;
 351                 break;
 352         }
 353     }
 354
 355     hb_deep_log( 2, "encx264: opening libx264 (pass %d)", job->pass );
 356     pv->x264 = x264_encoder_open( &param );
 357
 358     x264_encoder_headers( pv->x264, &nal, &nal_count );
 359
 360     /* Sequence Parameter Set */
 361     memcpy(w->config->h264.sps, nal[1].p_payload + 4, nal[1].i_payload - 4);
 362     w->config->h264.sps_length = nal[1].i_payload - 4;
 363
 364     /* Picture Parameter Set */
 365     memcpy(w->config->h264.pps, nal[2].p_payload + 4, nal[2].i_payload - 4);
 366     w->config->h264.pps_length = nal[2].i_payload - 4;
 367
 368     x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
 369                         job->width, job->height );
 370
 371     pv->pic_in.img.i_stride[2] = pv->pic_in.img.i_stride[1] = ( ( job->width + 1 ) >> 1 );
 372     pv->x264_allocated_pic = pv->pic_in.img.plane[0];
 373
 374     if (job->areBframes)
 375     {
 376         /* Basic initDelay value is the clockrate divided by the FPS
 377            -- the length of one frame in clockticks.                  */
 378         pv->init_delay = 90000. / ((double)job->vrate / (double)job->vrate_base);
 379
 380         /* 23.976-length frames are 3753.75 ticks long on average but the DVD
 381            creates that average rate by repeating 59.95 fields so the max
 382            frame size is actually 4504.5 (3 field times). The field durations
 383            are computed based on quantized times (see below) so we need an extra
 384            two ticks to account for the rounding. */
 385         if (pv->init_delay == 3753)
 386             pv->init_delay = 4507;
 387
 388         /* frame rates are not exact in the DVD 90KHz PTS clock (they are
 389            exact in the DVD 27MHz system clock but we never see that) so the
 390            rates computed above are all +-1 due to quantization. Worst case
 391            is when a clock-rounded-down frame is adjacent to a rounded-up frame
 392            which makes one of the frames 2 ticks longer than the nominal
 393            frame time. */
 394         pv->init_delay += 2;
 395
 396         /* For VFR, libhb sees the FPS as 29.97, but the longest frames
 397            will use the duration of frames running at 23.976fps instead.
 398            Since detelecine occasionally makes mistakes and since we have
 399            to deal with some really horrible timing jitter from mkvs and
 400            mp4s encoded with low resolution clocks, make the delay very
 401            conservative if we're not doing CFR. */
 402         if ( job->cfr != 1 )
 403         {
 404             pv->init_delay *= 2;
 405         }
 406
 407         /* The delay is 1 frames for regular b-frames, 2 for b-pyramid. */
 408         pv->init_delay *= job->areBframes;
 409     }
 410     w->config->h264.init_delay = pv->init_delay;
 411
 412     return 0;
 413 }
 414
 415 void encx264Close( hb_work_object_t * w )
 416 {
 417     hb_work_private_t * pv = w->private_data;
 418
 419     if ( pv->frames_split )
 420     {
 421         hb_log( "encx264: %u frames had to be split (%u in, %u out)",
 422                 pv->frames_split, pv->frames_in, pv->frames_out );
 423     }
 424     /*
 425      * Patch the x264 allocated data back in so that x264 can free it
 426      * we have been using our own buffers during the encode to avoid copying.
 427      */
 428     pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
 429     x264_picture_clean( &pv->pic_in );
 430     x264_encoder_close( pv->x264 );
 431     free( pv );
 432     w->private_data = NULL;
 433
 434     /* TODO */
 435 }
 436
 437 /*
 438  * see comments in definition of 'frame_info' in pv struct for description
 439  * of what these routines are doing.
 440  */
 441 static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
 442 {
 443     int i = (in->start >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 444     pv->frame_info[i].duration = in->stop - in->start;
 445 }
 446
 447 static int64_t get_frame_duration( hb_work_private_t * pv, int64_t pts )
 448 {
 449     int i = (pts >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
 450     return pv->frame_info[i].duration;
 451 }
 452
 453 static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out,
 454                                 int i_nal, x264_nal_t *nal )
 455 {
 456     hb_buffer_t *buf = NULL;
 457     hb_work_private_t *pv = w->private_data;
 458     hb_job_t *job = pv->job;
 459
 460     /* Should be way too large */
 461     buf = hb_video_buffer_init( job->width, job->height );
 462     buf->size = 0;
 463     buf->frametype = 0;
 464
 465     // use the pts to get the original frame's duration.
 466     int64_t duration  = get_frame_duration( pv, pic_out->i_pts );
 467     buf->start = pic_out->i_pts;
 468     buf->stop  = pic_out->i_pts + duration;
 469
 470     /* Encode all the NALs we were given into buf.
 471        NOTE: This code assumes one video frame per NAL (but there can
 472              be other stuff like SPS and/or PPS). If there are multiple
 473              frames we only get the duration of the first which will
 474              eventually screw up the muxer & decoder. */
 475     int i;
 476     for( i = 0; i < i_nal; i++ )
 477     {
 478         int size = nal[i].i_payload;
 479         memcpy(buf->data + buf->size, nal[i].p_payload, size);
 480         if( size < 1 )
 481         {
 482             continue;
 483         }
 484
 485         if( job->mux & HB_MUX_AVI )
 486         {
 487             if( nal[i].i_ref_idc == NAL_PRIORITY_HIGHEST )
 488             {
 489                 buf->frametype = HB_FRAME_KEY;
 490             }
 491             buf->size += size;
 492             continue;
 493         }
 494
 495         /* H.264 in .mp4 or .mkv */
 496         switch( nal[i].i_type )
 497         {
 498             /* Sequence Parameter Set & Program Parameter Set go in the
 499              * mp4 header so skip them here
 500              */
 501             case NAL_SPS:
 502             case NAL_PPS:
 503                 continue;
 504
 505             case NAL_SLICE:
 506             case NAL_SLICE_IDR:
 507             case NAL_SEI:
 508             default:
 509                 break;
 510         }
 511
 512         /* Decide what type of frame we have. */
 513         switch( pic_out->i_type )
 514         {
 515             case X264_TYPE_IDR:
 516                 buf->frametype = HB_FRAME_IDR;
 517                 /* if we have a chapter marker pending and this
 518                    frame's presentation time stamp is at or after
 519                    the marker's time stamp, use this as the
 520                    chapter start. */
 521                 if( pv->next_chap != 0 && pv->next_chap <= pic_out->i_pts )
 522                 {
 523                     pv->next_chap = 0;
 524                     buf->new_chap = pv->chap_mark;
 525                 }
 526                 break;
 527
 528             case X264_TYPE_I:
 529                 buf->frametype = HB_FRAME_I;
 530                 break;
 531
 532             case X264_TYPE_P:
 533                 buf->frametype = HB_FRAME_P;
 534                 break;
 535
 536             case X264_TYPE_B:
 537                 buf->frametype = HB_FRAME_B;
 538                 break;
 539
 540         /*  This is for b-pyramid, which has reference b-frames
 541             However, it doesn't seem to ever be used... */
 542             case X264_TYPE_BREF:
 543                 buf->frametype = HB_FRAME_BREF;
 544                 break;
 545
 546             // If it isn't the above, what type of frame is it??
 547             default:
 548                 buf->frametype = 0;
 549                 break;
 550         }
 551
 552         /* Since libx264 doesn't tell us when b-frames are
 553            themselves reference frames, figure it out on our own. */
 554         if( (buf->frametype == HB_FRAME_B) &&
 555             (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) )
 556             buf->frametype = HB_FRAME_BREF;
 557
 558         /* Expose disposable bit to muxer. */
 559         if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE )
 560             buf->flags &= ~HB_FRAME_REF;
 561         else
 562             buf->flags |= HB_FRAME_REF;
 563
 564         buf->size += size;
 565     }
 566     // make sure we found at least one video frame
 567     if ( buf->size <= 0 )
 568     {
 569         // no video - discard the buf
 570         hb_buffer_close( &buf );
 571     }
 572     return buf;
 573 }
 574
 575 static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in )
 576 {
 577     hb_work_private_t *pv = w->private_data;
 578     hb_job_t *job = pv->job;
 579
 580     /* Point x264 at our current buffers Y(UV) data.  */
 581     pv->pic_in.img.plane[0] = in->data;
 582
 583     int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 );
 584     if( job->grayscale )
 585     {
 586         /* XXX x264 has currently no option for grayscale encoding */
 587         memset( pv->pic_in.img.plane[1], 0x80, uvsize );
 588         memset( pv->pic_in.img.plane[2], 0x80, uvsize );
 589     }
 590     else
 591     {
 592         /* Point x264 at our buffers (Y)UV data */
 593         pv->pic_in.img.plane[1] = in->data + job->width * job->height;
 594         pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize;
 595     }
 596     if( in->new_chap && job->chapter_markers )
 597     {
 598         /* chapters have to start with an IDR frame so request that this
 599            frame be coded as IDR. Since there may be up to 16 frames
 600            currently buffered in the encoder remember the timestamp so
 601            when this frame finally pops out of the encoder we'll mark
 602            its buffer as the start of a chapter. */
 603         pv->pic_in.i_type = X264_TYPE_IDR;
 604         if( pv->next_chap == 0 )
 605         {
 606             pv->next_chap = in->start;
 607             pv->chap_mark = in->new_chap;
 608         }
 609         /* don't let 'work_loop' put a chapter mark on the wrong buffer */
 610         in->new_chap = 0;
 611     }
 612     else
 613     {
 614         pv->pic_in.i_type = X264_TYPE_AUTO;
 615     }
 616     pv->pic_in.i_qpplus1 = 0;
 617
 618     /* XXX this is temporary debugging code to check that the upstream
 619      * modules (render & sync) have generated a continuous, self-consistent
 620      * frame stream with the current frame's start time equal to the
 621      * previous frame's stop time.
 622      */
 623     if( pv->last_stop != in->start )
 624     {
 625         hb_log("encx264 input continuity err: last stop %"PRId64"  start %"PRId64,
 626                 pv->last_stop, in->start);
 627     }
 628     pv->last_stop = in->stop;
 629
 630     // Remember info about this frame that we need to pass across
 631     // the x264_encoder_encode call (since it reorders frames).
 632     save_frame_info( pv, in );
 633
 634     /* Feed the input PTS to x264 so it can figure out proper output PTS */
 635     pv->pic_in.i_pts = in->start;
 636
 637     x264_picture_t pic_out;
 638     int i_nal;
 639     x264_nal_t *nal;
 640
 641     x264_encoder_encode( pv->x264, &nal, &i_nal, &pv->pic_in, &pic_out );
 642     if ( i_nal > 0 )
 643     {
 644         return nal_encode( w, &pic_out, i_nal, nal );
 645     }
 646     return NULL;
 647 }
 648
 649 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
 650                   hb_buffer_t ** buf_out )
 651 {
 652     hb_work_private_t *pv = w->private_data;
 653     hb_buffer_t *in = *buf_in;
 654
 655     *buf_out = NULL;
 656
 657     if( in->size <= 0 )
 658     {
 659         // EOF on input. Flush any frames still in the decoder then
 660         // send the eof downstream to tell the muxer we're done.
 661         x264_picture_t pic_out;
 662         int i_nal;
 663         x264_nal_t *nal;
 664         hb_buffer_t *last_buf = NULL;
 665
 666         while (1)
 667         {
 668             x264_encoder_encode( pv->x264, &nal, &i_nal, NULL, &pic_out );
 669             if ( i_nal <= 0 )
 670                 break;
 671
 672             hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal );
 673             if ( buf )
 674             {
 675                 ++pv->frames_out;
 676                 if ( last_buf == NULL )
 677                     *buf_out = buf;
 678                 else
 679                     last_buf->next = buf;
 680                 last_buf = buf;
 681             }
 682         }
 683         // Flushed everything - add the eof to the end of the chain.
 684         if ( last_buf == NULL )
 685             *buf_out = in;
 686         else
 687             last_buf->next = in;
 688
 689         *buf_in = NULL;
 690         return HB_WORK_DONE;
 691     }
 692
 693     // Not EOF - encode the packet & wrap it in a NAL
 694     ++pv->frames_in;
 695
 696     // if we're re-ordering frames, check if this frame is too large to reorder
 697     if ( pv->init_delay && in->stop - in->start > pv->init_delay )
 698     {
 699         // This frame's duration is larger than the time allotted for b-frame
 700         // reordering. That means that if it's used as a reference the decoder
 701         // won't be able to move it early enough to render it in correct
 702         // sequence & the playback will have odd jumps & twitches. To make
 703         // sure this doesn't happen we pretend this frame is multiple
 704         // frames, each with duration <= init_delay. Since each of these
 705         // new frames contains the same image the visual effect is identical
 706         // to the original but the resulting stream can now be coded without
 707         // error. We take advantage of the fact that x264 buffers frame
 708         // data internally to feed the same image into the encoder multiple
 709         // times, just changing its start & stop times each time.
 710         ++pv->frames_split;
 711         int64_t orig_stop = in->stop;
 712         int64_t new_stop = in->start;
 713         hb_buffer_t *last_buf = NULL;
 714
 715         // We want to spread the new frames uniformly over the total time
 716         // so that we don't end up with a very short frame at the end.
 717         // In the number of pieces calculation we add in init_delay-1 to
 718         // round up but not add an extra piece if the frame duration is
 719         // a multiple of init_delay. The final increment of frame_dur is
 720         // to restore the bits that got truncated by the divide on the
 721         // previous line. If we don't do this we end up with an extra tiny
 722         // frame at the end whose duration is npieces-1.
 723         int64_t frame_dur = orig_stop - new_stop;
 724         int64_t npieces = ( frame_dur + pv->init_delay - 1 ) / pv->init_delay;
 725         frame_dur /= npieces;
 726         ++frame_dur;
 727
 728         while ( in->start < orig_stop )
 729         {
 730             new_stop += frame_dur;
 731             if ( new_stop > orig_stop )
 732                 new_stop = orig_stop;
 733             in->stop = new_stop;
 734             hb_buffer_t *buf = x264_encode( w, in );
 735             if ( buf )
 736             {
 737                 ++pv->frames_out;
 738                 if ( last_buf == NULL )
 739                     *buf_out = buf;
 740                 else
 741                     last_buf->next = buf;
 742                 last_buf = buf;
 743             }
 744             in->start = new_stop;
 745         }
 746     }
 747     else
 748     {
 749         ++pv->frames_out;
 750         *buf_out = x264_encode( w, in );
 751     }
 752     return HB_WORK_OK;
 753 }