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