libhb/sync.c

   1 /* $Id: sync.c,v 1.38 2005/04/14 21:57:58 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 "hb.h"
   8 #include "hbffmpeg.h"
   9 #include <stdio.h>
  10 #include "samplerate.h"
  11
  12 #ifdef INT64_MIN
  13 #undef INT64_MIN /* Because it isn't defined correctly in Zeta */
  14 #endif
  15 #define INT64_MIN (-9223372036854775807LL-1)
  16
  17 #define AC3_SAMPLES_PER_FRAME 1536
  18
  19 typedef struct
  20 {
  21     hb_lock_t * mutex;
  22     int         ref;        /* Reference count to tell us when it's unused */
  23     int         count_frames;
  24     int64_t     audio_passthru_slip;
  25     int64_t     video_pts_slip;
  26     int64_t     pts_offset;
  27
  28     /* Frame based point-to-point support */
  29     int64_t     audio_pts_thresh;
  30     int         start_found;
  31     hb_cond_t * next_frame;
  32     int         pts_count;
  33     int64_t   * first_pts;
  34 } hb_sync_common_t;
  35
  36 typedef struct
  37 {
  38     int          index;
  39     int64_t      next_start;    /* start time of next output frame */
  40     int64_t      next_pts;     /* start time of next input frame */
  41     int64_t      first_drop;   /* PTS of first 'went backwards' frame dropped */
  42     int          drop_count;   /* count of 'time went backwards' drops */
  43
  44     /* Raw */
  45     SRC_STATE  * state;
  46     SRC_DATA     data;
  47
  48     /* AC-3 */
  49     int          ac3_size;
  50     uint8_t    * ac3_buf;
  51 } hb_sync_audio_t;
  52
  53 typedef struct
  54 {
  55     /* Video */
  56     int        first_frame;
  57     int64_t    pts_skip;
  58     int64_t    next_start;    /* start time of next output frame */
  59     int64_t    next_pts;      /* start time of next input frame */
  60     int64_t    first_drop;    /* PTS of first 'went backwards' frame dropped */
  61     int        drop_count;    /* count of 'time went backwards' drops */
  62     int        drops;         /* frames dropped to make a cbr video stream */
  63     int        dups;          /* frames duplicated to make a cbr video stream */
  64     int        video_sequence;
  65     int        count_frames_max;
  66     int        chap_mark;     /* to propagate chapter mark across a drop */
  67     hb_buffer_t * cur;        /* The next picture to process */
  68
  69     /* Statistics */
  70     uint64_t   st_counts[4];
  71     uint64_t   st_dates[4];
  72     uint64_t   st_first;
  73 } hb_sync_video_t;
  74
  75 struct hb_work_private_s
  76 {
  77     hb_job_t * job;
  78     hb_sync_common_t * common;
  79     union
  80     {
  81         hb_sync_video_t video;
  82         hb_sync_audio_t audio;
  83     } type;
  84 };
  85
  86 /***********************************************************************
  87  * Local prototypes
  88  **********************************************************************/
  89 static void getPtsOffset( hb_work_object_t * w );
  90 static int  checkPtsOffset( hb_work_object_t * w );
  91 static void InitAudio( hb_job_t * job, hb_sync_common_t * common, int i );
  92 static void InsertSilence( hb_work_object_t * w, int64_t d );
  93 static void UpdateState( hb_work_object_t * w );
  94 static void UpdateSearchState( hb_work_object_t * w, int64_t start );
  95 static hb_buffer_t * OutputAudioFrame( hb_audio_t *audio, hb_buffer_t *buf,
  96                                        hb_sync_audio_t *sync );
  97
  98 /***********************************************************************
  99  * hb_work_sync_init
 100  ***********************************************************************
 101  * Initialize the work object
 102  **********************************************************************/
 103 hb_work_object_t * hb_sync_init( hb_job_t * job )
 104 {
 105     hb_title_t        * title = job->title;
 106     hb_chapter_t      * chapter;
 107     int                 i;
 108     uint64_t            duration;
 109     hb_work_private_t * pv;
 110     hb_sync_video_t   * sync;
 111     hb_work_object_t  * w;
 112     hb_work_object_t  * ret = NULL;
 113
 114     pv = calloc( 1, sizeof( hb_work_private_t ) );
 115     sync = &pv->type.video;
 116     pv->common = calloc( 1, sizeof( hb_sync_common_t ) );
 117     pv->common->ref++;
 118     pv->common->mutex = hb_lock_init();
 119     pv->common->audio_pts_thresh = 0;
 120     pv->common->next_frame = hb_cond_init();
 121     pv->common->pts_count = 1;
 122     if ( job->frame_to_start || job->pts_to_start )
 123     {
 124         pv->common->start_found = 0;
 125     }
 126     else
 127     {
 128         pv->common->start_found = 1;
 129     }
 130
 131     ret = w = hb_get_work( WORK_SYNC_VIDEO );
 132     w->private_data = pv;
 133     w->fifo_in = job->fifo_raw;
 134     w->fifo_out = job->fifo_sync;
 135
 136     pv->job            = job;
 137     pv->common->pts_offset   = INT64_MIN;
 138     sync->first_frame = 1;
 139
 140     if( job->pass == 2 )
 141     {
 142         /* We already have an accurate frame count from pass 1 */
 143         hb_interjob_t * interjob = hb_interjob_get( job->h );
 144         sync->count_frames_max = interjob->frame_count;
 145     }
 146     else
 147     {
 148         /* Calculate how many video frames we are expecting */
 149         if ( job->pts_to_stop )
 150         {
 151             duration = job->pts_to_stop + 90000;
 152         }
 153         else if( job->frame_to_stop )
 154         {
 155             /* Set the duration to a rough estimate */
 156             duration = ( job->frame_to_stop / ( title->rate / title->rate_base ) ) * 90000;
 157         }
 158         else
 159         {
 160             duration = 0;
 161             for( i = job->chapter_start; i <= job->chapter_end; i++ )
 162             {
 163                 chapter   = hb_list_item( title->list_chapter, i - 1 );
 164                 duration += chapter->duration;
 165             }
 166             duration += 90000;
 167             /* 1 second safety so we're sure we won't miss anything */
 168         }
 169         sync->count_frames_max = duration * title->rate / title->rate_base / 90000;
 170     }
 171
 172     hb_log( "sync: expecting %d video frames", sync->count_frames_max );
 173
 174     /* Initialize libsamplerate for every audio track we have */
 175     if ( ! job->indepth_scan )
 176     {
 177         for( i = 0; i < hb_list_count( title->list_audio ) && i < 8; i++ )
 178         {
 179             InitAudio( job, pv->common, i );
 180         }
 181     }
 182     pv->common->first_pts = malloc( sizeof(int64_t) * pv->common->pts_count );
 183     for ( i = 0; i < pv->common->pts_count; i++ )
 184         pv->common->first_pts[i] = INT64_MAX;
 185
 186     return ret;
 187 }
 188
 189 /***********************************************************************
 190  * Close Video
 191  ***********************************************************************
 192  *
 193  **********************************************************************/
 194 void syncVideoClose( hb_work_object_t * w )
 195 {
 196     hb_work_private_t * pv = w->private_data;
 197     hb_job_t          * job   = pv->job;
 198     hb_sync_video_t   * sync = &pv->type.video;
 199
 200     // Wake up audio sync if it's still waiting on condition.
 201     pv->common->pts_offset = 0;
 202     pv->common->start_found = 1;
 203     hb_cond_broadcast( pv->common->next_frame );
 204
 205     if( sync->cur )
 206     {
 207         hb_buffer_close( &sync->cur );
 208     }
 209
 210     hb_log( "sync: got %d frames, %d expected",
 211             pv->common->count_frames, sync->count_frames_max );
 212
 213     /* save data for second pass */
 214     if( job->pass == 1 )
 215     {
 216         /* Preserve frame count for better accuracy in pass 2 */
 217         hb_interjob_t * interjob = hb_interjob_get( job->h );
 218         interjob->frame_count = pv->common->count_frames;
 219         interjob->last_job = job->sequence_id;
 220         interjob->total_time = sync->next_start;
 221     }
 222
 223     if (sync->drops || sync->dups )
 224     {
 225         hb_log( "sync: %d frames dropped, %d duplicated",
 226                 sync->drops, sync->dups );
 227     }
 228
 229     hb_lock( pv->common->mutex );
 230     if ( --pv->common->ref == 0 )
 231     {
 232         hb_unlock( pv->common->mutex );
 233         hb_lock_close( &pv->common->mutex );
 234         free( pv->common );
 235     }
 236     else
 237     {
 238         hb_unlock( pv->common->mutex );
 239     }
 240
 241     free( pv );
 242     w->private_data = NULL;
 243 }
 244
 245 /***********************************************************************
 246  * syncVideoWork
 247  ***********************************************************************
 248  *
 249  **********************************************************************/
 250 int syncVideoWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
 251               hb_buffer_t ** buf_out )
 252 {
 253     hb_buffer_t * cur, * next, * sub = NULL;
 254     hb_work_private_t * pv = w->private_data;
 255     hb_job_t          * job = pv->job;
 256     hb_subtitle_t     * subtitle;
 257     hb_sync_video_t   * sync = &pv->type.video;
 258     int i;
 259
 260     *buf_out = NULL;
 261     next = *buf_in;
 262     *buf_in = NULL;
 263
 264     /* Wait for start of point-to-point encoding */
 265     if( !pv->common->start_found )
 266     {
 267         hb_sync_video_t   * sync = &pv->type.video;
 268
 269         if( next->size == 0 )
 270         {
 271             *buf_out = next;
 272             pv->common->start_found = 1;
 273             hb_cond_broadcast( pv->common->next_frame );
 274
 275             /*
 276              * Push through any subtitle EOFs in case they
 277              * were not synced through.
 278              */
 279             for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 280             {
 281                 subtitle = hb_list_item( job->list_subtitle, i );
 282                 if( subtitle->config.dest == PASSTHRUSUB )
 283                 {
 284                     if( subtitle->source == VOBSUB )
 285                         hb_fifo_push( subtitle->fifo_sync, hb_buffer_init( 0 ) );
 286                     else
 287                         hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
 288                 }
 289             }
 290             return HB_WORK_DONE;
 291         }
 292         if ( pv->common->count_frames < job->frame_to_start ||
 293              next->start < job->pts_to_start )
 294         {
 295             // Flush any subtitles that have pts prior to the
 296             // current frame
 297             for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 298             {
 299                 subtitle = hb_list_item( job->list_subtitle, i );
 300                 while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
 301                 {
 302                     if ( sub->start > next->start )
 303                         break;
 304                     sub = hb_fifo_get( subtitle->fifo_raw );
 305                     hb_buffer_close( &sub );
 306                 }
 307             }
 308             hb_lock( pv->common->mutex );
 309             // Tell the audio threads what must be dropped
 310             pv->common->audio_pts_thresh = next->start;
 311             hb_cond_broadcast( pv->common->next_frame );
 312             hb_unlock( pv->common->mutex );
 313
 314             UpdateSearchState( w, next->start );
 315             hb_buffer_close( &next );
 316
 317             return HB_WORK_OK;
 318         }
 319         hb_lock( pv->common->mutex );
 320         pv->common->start_found = 1;
 321         pv->common->count_frames = 0;
 322         hb_cond_broadcast( pv->common->next_frame );
 323         hb_unlock( pv->common->mutex );
 324         sync->st_first = 0;
 325     }
 326
 327     /* Wait till we can determine the initial pts of all streams */
 328     if( pv->common->pts_offset == INT64_MIN )
 329     {
 330         pv->common->first_pts[0] = next->start;
 331         hb_lock( pv->common->mutex );
 332         while( pv->common->pts_offset == INT64_MIN )
 333         {
 334             // Full fifos will make us wait forever, so get the
 335             // pts offset from the available streams if full
 336             if ( hb_fifo_is_full( job->fifo_raw ) )
 337             {
 338                 getPtsOffset( w );
 339                 hb_cond_broadcast( pv->common->next_frame );
 340             }
 341             else if ( checkPtsOffset( w ) )
 342                 hb_cond_broadcast( pv->common->next_frame );
 343             else
 344                 hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
 345         }
 346         hb_unlock( pv->common->mutex );
 347     }
 348
 349     if( !sync->cur )
 350     {
 351         sync->cur = next;
 352         if( sync->cur->size == 0 )
 353         {
 354             /* we got an end-of-stream as our first video packet?
 355              * Feed it downstream & signal that we're done.
 356              */
 357             *buf_out = hb_buffer_init( 0 );
 358
 359             pv->common->start_found = 1;
 360             hb_cond_broadcast( pv->common->next_frame );
 361
 362             /*
 363              * Push through any subtitle EOFs in case they
 364              * were not synced through.
 365              */
 366             for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 367             {
 368                 subtitle = hb_list_item( job->list_subtitle, i );
 369                 if( subtitle->config.dest == PASSTHRUSUB )
 370                 {
 371                     if( subtitle->source == VOBSUB )
 372                         hb_fifo_push( subtitle->fifo_sync, hb_buffer_init( 0 ) );
 373                     else
 374                         hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
 375                 }
 376             }
 377             return HB_WORK_DONE;
 378         }
 379         return HB_WORK_OK;
 380     }
 381     cur = sync->cur;
 382     /* At this point we have a frame to process. Let's check
 383         1) if we will be able to push into the fifo ahead
 384         2) if the next frame is there already, since we need it to
 385            compute the duration of the current frame*/
 386     if( next->size == 0 )
 387     {
 388         hb_buffer_close( &next );
 389
 390         cur->start = sync->next_start;
 391         cur->stop = cur->start + 90000. / ((double)job->vrate / (double)job->vrate_base);
 392
 393         /* Make sure last frame is reflected in frame count */
 394         pv->common->count_frames++;
 395
 396         /* Push the frame to the renderer */
 397         hb_fifo_push( job->fifo_sync, cur );
 398         sync->cur = NULL;
 399
 400         /* we got an end-of-stream. Feed it downstream & signal that
 401          * we're done. Note that this means we drop the final frame of
 402          * video (we don't know its duration). On DVDs the final frame
 403          * is often strange and dropping it seems to be a good idea. */
 404         *buf_out = hb_buffer_init( 0 );
 405
 406         /*
 407          * Push through any subtitle EOFs in case they were not synced through.
 408          */
 409         for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 410         {
 411             subtitle = hb_list_item( job->list_subtitle, i );
 412             if( subtitle->config.dest == PASSTHRUSUB )
 413             {
 414                 if( subtitle->source == VOBSUB )
 415                     hb_fifo_push( subtitle->fifo_sync, hb_buffer_init( 0 ) );
 416                 else
 417                     hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
 418             }
 419         }
 420         pv->common->start_found = 1;
 421         hb_cond_broadcast( pv->common->next_frame );
 422         return HB_WORK_DONE;
 423     }
 424
 425     /* Check for end of point-to-point frame encoding */
 426     if( job->frame_to_stop && pv->common->count_frames > job->frame_to_stop )
 427     {
 428         // Drop an empty buffer into our output to ensure that things
 429         // get flushed all the way out.
 430         hb_buffer_close( &sync->cur );
 431         hb_buffer_close( &next );
 432         *buf_out = hb_buffer_init( 0 );
 433         hb_log( "sync: reached %d frames, exiting early",
 434                 pv->common->count_frames );
 435
 436         /*
 437          * Push through any subtitle EOFs in case they were not synced through.
 438          */
 439         for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 440         {
 441             subtitle = hb_list_item( job->list_subtitle, i );
 442             if( subtitle->config.dest == PASSTHRUSUB )
 443             {
 444                 if( subtitle->source == VOBSUB )
 445                     hb_fifo_push( subtitle->fifo_sync, hb_buffer_init( 0 ) );
 446                 else
 447                     hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
 448             }
 449         }
 450         return HB_WORK_DONE;
 451     }
 452
 453     /* Check for end of point-to-point pts encoding */
 454     if( job->pts_to_stop && sync->next_start >= job->pts_to_stop )
 455     {
 456         // Drop an empty buffer into our output to ensure that things
 457         // get flushed all the way out.
 458         hb_log( "sync: reached pts %"PRId64", exiting early",
 459                 sync->cur->start );
 460         hb_buffer_close( &sync->cur );
 461         hb_buffer_close( &next );
 462         *buf_out = hb_buffer_init( 0 );
 463
 464         /*
 465          * Push through any subtitle EOFs in case they were not synced through.
 466          */
 467         for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 468         {
 469             subtitle = hb_list_item( job->list_subtitle, i );
 470             if( subtitle->config.dest == PASSTHRUSUB )
 471             {
 472                 if( subtitle->source == VOBSUB )
 473                     hb_fifo_push( subtitle->fifo_sync, hb_buffer_init( 0 ) );
 474                 else
 475                     hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
 476             }
 477         }
 478         return HB_WORK_DONE;
 479     }
 480
 481     if( sync->first_frame )
 482     {
 483         /* This is our first frame */
 484         if ( cur->start > pv->common->pts_offset )
 485         {
 486             /*
 487              * The first pts from a dvd should always be zero but
 488              * can be non-zero with a transport or program stream since
 489              * we're not guaranteed to start on an IDR frame. If we get
 490              * a non-zero initial PTS extend its duration so it behaves
 491              * as if it started at zero so that our audio timing will
 492              * be in sync.
 493              */
 494             hb_log( "sync: first pts is %"PRId64, cur->start );
 495             cur->start = pv->common->pts_offset;
 496         }
 497         sync->first_frame = 0;
 498     }
 499
 500     /*
 501      * since the first frame is always 0 and the upstream reader code
 502      * is taking care of adjusting for pts discontinuities, we just have
 503      * to deal with the next frame's start being in the past. This can
 504      * happen when the PTS is adjusted after data loss but video frame
 505      * reordering causes some frames with the old clock to appear after
 506      * the clock change. This creates frames that overlap in time which
 507      * looks to us like time going backward. The downstream muxing code
 508      * can deal with overlaps of up to a frame time but anything larger
 509      * we handle by dropping frames here.
 510      */
 511     hb_lock( pv->common->mutex );
 512     if ( (int64_t)( next->start - pv->common->video_pts_slip - cur->start ) <= 0 )
 513     {
 514         if ( sync->first_drop == 0 )
 515         {
 516             sync->first_drop = next->start;
 517         }
 518         ++sync->drop_count;
 519         if (next->start - cur->start > 0)
 520         {
 521             sync->pts_skip += next->start - cur->start;
 522             pv->common->video_pts_slip -= next->start - cur->start;
 523         }
 524         hb_unlock( pv->common->mutex );
 525         if ( next->new_chap )
 526         {
 527             // don't drop a chapter mark when we drop the buffer
 528             sync->chap_mark = next->new_chap;
 529         }
 530         hb_buffer_close( &next );
 531         return HB_WORK_OK;
 532     }
 533     hb_unlock( pv->common->mutex );
 534     if ( sync->first_drop )
 535     {
 536         hb_log( "sync: video time didn't advance - dropped %d frames "
 537                 "(delta %d ms, current %"PRId64", next %"PRId64", dur %d)",
 538                 sync->drop_count, (int)( cur->start - sync->first_drop ) / 90,
 539                 cur->start, next->start, (int)( next->start - cur->start ) );
 540         sync->first_drop = 0;
 541         sync->drop_count = 0;
 542     }
 543
 544     /*
 545      * Track the video sequence number localy so that we can sync the audio
 546      * to it using the sequence number as well as the PTS.
 547      */
 548     sync->video_sequence = cur->sequence;
 549
 550     /*
 551      * Look for a subtitle for this frame.
 552      *
 553      * If found then it will be tagged onto a video buffer of the correct time and
 554      * sent in to the render pipeline. This only needs to be done for VOBSUBs which
 555      * get rendered, other types of subtitles can just sit in their raw_queue until
 556      * delt with at muxing.
 557      */
 558     for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
 559     {
 560         subtitle = hb_list_item( job->list_subtitle, i );
 561
 562         /*
 563          * Rewrite timestamps on subtitles that need it (on raw queue).
 564          */
 565         if( subtitle->source == CC608SUB ||
 566             subtitle->source == CC708SUB ||
 567             subtitle->source == SRTSUB ||
 568             subtitle->source == UTF8SUB ||
 569             subtitle->source == TX3GSUB)
 570         {
 571             /*
 572              * Rewrite timestamps on subtitles that came from Closed Captions
 573              * since they are using the MPEG2 timestamps.
 574              */
 575             while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
 576             {
 577                 /*
 578                  * Rewrite the timestamps as and when the video
 579                  * (cur->start) reaches the same timestamp as a
 580                  * closed caption (sub->start).
 581                  *
 582                  * What about discontinuity boundaries - not delt
 583                  * with here - Van?
 584                  *
 585                  * Bypass the sync fifo altogether.
 586                  */
 587                 if( sub->size <= 0 )
 588                 {
 589                     sub = hb_fifo_get( subtitle->fifo_raw );
 590                     hb_fifo_push( subtitle->fifo_out, sub );
 591                     sub = NULL;
 592                     break;
 593                 } else {
 594                     /*
 595                      * Sync the subtitles to the incoming video, and use
 596                      * the matching converted video timestamp.
 597                      *
 598                      * Note that it doesn't appear that we need to convert
 599                      * timestamps, I guess that they were already correct,
 600                      * so just push them through for rendering.
 601                      *
 602                      */
 603                     if( sub->start < cur->start )
 604                     {
 605                         sub = hb_fifo_get( subtitle->fifo_raw );
 606                         hb_fifo_push( subtitle->fifo_out, sub );
 607                     } else {
 608                         sub = NULL;
 609                         break;
 610                     }
 611                 }
 612             }
 613         }
 614
 615         if( subtitle->source == VOBSUB )
 616         {
 617             hb_buffer_t * sub2;
 618             while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
 619             {
 620                 if( sub->size == 0 )
 621                 {
 622                     /*
 623                      * EOF, pass it through immediately.
 624                      */
 625                     break;
 626                 }
 627
 628                 /* If two subtitles overlap, make the first one stop
 629                    when the second one starts */
 630                 sub2 = hb_fifo_see2( subtitle->fifo_raw );
 631                 if( sub2 && sub->stop > sub2->start )
 632                 {
 633                     sub->stop = sub2->start;
 634                 }
 635
 636                 // hb_log("0x%x: video seq: %"PRId64" subtitle sequence: %"PRId64,
 637                 //       sub, cur->sequence, sub->sequence);
 638
 639                 if( sub->sequence > cur->sequence )
 640                 {
 641                     /*
 642                      * The video is behind where we are, so wait until
 643                      * it catches up to the same reader point on the
 644                      * DVD. Then our PTS should be in the same region
 645                      * as the video.
 646                      */
 647                     sub = NULL;
 648                     break;
 649                 }
 650
 651                 if( sub->stop > cur->start ) {
 652                     /*
 653                      * The stop time is in the future, so fall through
 654                      * and we'll deal with it in the next block of
 655                      * code.
 656                      */
 657
 658                     /*
 659                      * There is a valid subtitle, is it time to display it?
 660                      */
 661                     if( sub->stop > sub->start)
 662                     {
 663                         /*
 664                          * Normal subtitle which ends after it starts,
 665                          * check to see that the current video is between
 666                          * the start and end.
 667                          */
 668                         if( cur->start > sub->start &&
 669                             cur->start < sub->stop )
 670                         {
 671                             /*
 672                             * We should be playing this, so leave the
 673                             * subtitle in place.
 674                             *
 675                             * fall through to display
 676                             */
 677                             if( ( sub->stop - sub->start ) < ( 2 * 90000 ) )
 678                             {
 679                                 /*
 680                                  * Subtitle is on for less than three
 681                                  * seconds, extend the time that it is
 682                                  * displayed to make it easier to read.
 683                                  * Make it 3 seconds or until the next
 684                                  * subtitle is displayed.
 685                                  *
 686                                  * This is in response to Indochine which
 687                                  * only displays subs for 1 second -
 688                                  * too fast to read.
 689                                  */
 690                                 sub->stop = sub->start + ( 2 * 90000 );
 691
 692                                 sub2 = hb_fifo_see2( subtitle->fifo_raw );
 693
 694                                 if( sub2 && sub->stop > sub2->start )
 695                                 {
 696                                     sub->stop = sub2->start;
 697                                 }
 698                             }
 699                         }
 700                         else
 701                         {
 702                             /*
 703                              * Defer until the play point is within
 704                              * the subtitle
 705                              */
 706                             sub = NULL;
 707                         }
 708                     }
 709                     else
 710                     {
 711                         /*
 712                          * The end of the subtitle is less than the start,
 713                          * this is a sign of a PTS discontinuity.
 714                          */
 715                         if( sub->start > cur->start )
 716                         {
 717                             /*
 718                              * we haven't reached the start time yet, or
 719                              * we have jumped backwards after having
 720                              * already started this subtitle.
 721                              */
 722                             if( cur->start < sub->stop )
 723                             {
 724                                 /*
 725                                  * We have jumped backwards and so should
 726                                  * continue displaying this subtitle.
 727                                  *
 728                                  * fall through to display.
 729                                  */
 730                             }
 731                             else
 732                             {
 733                                 /*
 734                                  * Defer until the play point is
 735                                  * within the subtitle
 736                                  */
 737                                 sub = NULL;
 738                             }
 739                         } else {
 740                             /*
 741                             * Play this subtitle as the start is
 742                             * greater than our video point.
 743                             *
 744                             * fall through to display/
 745                             */
 746                         }
 747                     }
 748                         break;
 749                 }
 750                 else
 751                 {
 752
 753                     /*
 754                      * The subtitle is older than this picture, trash it
 755                      */
 756                     sub = hb_fifo_get( subtitle->fifo_raw );
 757                     hb_buffer_close( &sub );
 758                 }
 759             }
 760
 761             /* If we have a subtitle for this picture, copy it */
 762             /* FIXME: we should avoid this memcpy */
 763             if( sub )
 764             {
 765                 if( sub->size > 0 )
 766                 {
 767                     if( subtitle->config.dest == RENDERSUB )
 768                     {
 769                         if ( cur->sub == NULL )
 770                         {
 771                             /*
 772                              * Tack onto the video buffer for rendering
 773                              */
 774                             cur->sub         = hb_buffer_init( sub->size );
 775                             cur->sub->x      = sub->x;
 776                             cur->sub->y      = sub->y;
 777                             cur->sub->width  = sub->width;
 778                             cur->sub->height = sub->height;
 779                             memcpy( cur->sub->data, sub->data, sub->size );
 780                         }
 781                     } else {
 782                         /*
 783                          * Pass-Through, pop it off of the raw queue,
 784                          */
 785                         sub = hb_fifo_get( subtitle->fifo_raw );
 786                         hb_fifo_push( subtitle->fifo_sync, sub );
 787                     }
 788                 } else {
 789                     /*
 790                     * EOF - consume for rendered, else pass through
 791                     */
 792                     if( subtitle->config.dest == RENDERSUB )
 793                     {
 794                         sub = hb_fifo_get( subtitle->fifo_raw );
 795                         hb_buffer_close( &sub );
 796                     } else {
 797                         sub = hb_fifo_get( subtitle->fifo_raw );
 798                         hb_fifo_push( subtitle->fifo_sync, sub );
 799                     }
 800                 }
 801             }
 802         }
 803     } // end subtitles
 804
 805     /*
 806      * Adjust the pts of the current frame so that it's contiguous
 807      * with the previous frame. The start time of the current frame
 808      * has to be the end time of the previous frame and the stop
 809      * time has to be the start of the next frame.  We don't
 810      * make any adjustments to the source timestamps other than removing
 811      * the clock offsets (which also removes pts discontinuities).
 812      * This means we automatically encode at the source's frame rate.
 813      * MP2 uses an implicit duration (frames end when the next frame
 814      * starts) but more advanced containers like MP4 use an explicit
 815      * duration. Since we're looking ahead one frame we set the
 816      * explicit stop time from the start time of the next frame.
 817      */
 818     *buf_out = cur;
 819     sync->cur = cur = next;
 820     cur->sub = NULL;
 821     sync->next_pts = cur->start;
 822     int64_t duration = cur->start - sync->pts_skip - (*buf_out)->start;
 823     sync->pts_skip = 0;
 824     if ( duration <= 0 )
 825     {
 826         hb_log( "sync: invalid video duration %"PRId64", start %"PRId64", next %"PRId64"",
 827                 duration, (*buf_out)->start, next->start );
 828     }
 829
 830     (*buf_out)->start = sync->next_start;
 831     sync->next_start += duration;
 832     (*buf_out)->stop = sync->next_start;
 833
 834     if ( sync->chap_mark )
 835     {
 836         // we have a pending chapter mark from a recent drop - put it on this
 837         // buffer (this may make it one frame late but we can't do any better).
 838         (*buf_out)->new_chap = sync->chap_mark;
 839         sync->chap_mark = 0;
 840     }
 841
 842     /* Update UI */
 843     UpdateState( w );
 844
 845     return HB_WORK_OK;
 846 }
 847
 848 // sync*Init does nothing because sync has a special initializer
 849 // that takes care of initializing video and all audio tracks
 850 int syncVideoInit( hb_work_object_t * w, hb_job_t * job)
 851 {
 852     return 0;
 853 }
 854
 855 hb_work_object_t hb_sync_video =
 856 {
 857     WORK_SYNC_VIDEO,
 858     "Video Synchronization",
 859     syncVideoInit,
 860     syncVideoWork,
 861     syncVideoClose
 862 };
 863
 864 /***********************************************************************
 865  * Close Audio
 866  ***********************************************************************
 867  *
 868  **********************************************************************/
 869 void syncAudioClose( hb_work_object_t * w )
 870 {
 871     hb_work_private_t * pv    = w->private_data;
 872     hb_sync_audio_t   * sync  = &pv->type.audio;
 873
 874     if( w->audio->config.out.codec == HB_ACODEC_AC3 )
 875     {
 876         free( sync->ac3_buf );
 877     }
 878     else
 879     {
 880         src_delete( sync->state );
 881     }
 882
 883     hb_lock( pv->common->mutex );
 884     if ( --pv->common->ref == 0 )
 885     {
 886         hb_unlock( pv->common->mutex );
 887         hb_lock_close( &pv->common->mutex );
 888         free( pv->common );
 889     }
 890     else
 891     {
 892         hb_unlock( pv->common->mutex );
 893     }
 894
 895     free( pv );
 896     w->private_data = NULL;
 897 }
 898
 899 int syncAudioInit( hb_work_object_t * w, hb_job_t * job)
 900 {
 901     return 0;
 902 }
 903
 904 /***********************************************************************
 905  * SyncAudio
 906  ***********************************************************************
 907  *
 908  **********************************************************************/
 909 static int syncAudioWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
 910                        hb_buffer_t ** buf_out )
 911 {
 912     hb_work_private_t * pv = w->private_data;
 913     hb_job_t        * job = pv->job;
 914     hb_sync_audio_t * sync = &pv->type.audio;
 915     hb_buffer_t     * buf;
 916     int64_t start;
 917
 918     *buf_out = NULL;
 919     buf = *buf_in;
 920     *buf_in = NULL;
 921     /* if the next buffer is an eof send it downstream */
 922     if ( buf->size <= 0 )
 923     {
 924         hb_buffer_close( &buf );
 925         *buf_out = hb_buffer_init( 0 );
 926         return HB_WORK_DONE;
 927     }
 928
 929     /* Wait for start frame if doing point-to-point */
 930     hb_lock( pv->common->mutex );
 931     while ( !pv->common->start_found )
 932     {
 933         if ( buf->start < pv->common->audio_pts_thresh )
 934         {
 935             hb_buffer_close( &buf );
 936             hb_unlock( pv->common->mutex );
 937             return HB_WORK_OK;
 938         }
 939         while ( !pv->common->start_found &&
 940                 buf->start >= pv->common->audio_pts_thresh )
 941         {
 942             hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
 943         }
 944     }
 945     if ( buf->start < pv->common->audio_pts_thresh )
 946     {
 947         hb_buffer_close( &buf );
 948         hb_unlock( pv->common->mutex );
 949         return HB_WORK_OK;
 950     }
 951     hb_unlock( pv->common->mutex );
 952
 953     /* Wait till we can determine the initial pts of all streams */
 954     if( pv->common->pts_offset == INT64_MIN )
 955     {
 956         pv->common->first_pts[sync->index+1] = buf->start;
 957         hb_lock( pv->common->mutex );
 958         while( pv->common->pts_offset == INT64_MIN )
 959         {
 960             // Full fifos will make us wait forever, so get the
 961             // pts offset from the available streams if full
 962             if (hb_fifo_is_full(w->fifo_in))
 963             {
 964                 getPtsOffset( w );
 965                 hb_cond_broadcast( pv->common->next_frame );
 966             }
 967             else if ( checkPtsOffset( w ) )
 968                 hb_cond_broadcast( pv->common->next_frame );
 969             else
 970                 hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
 971         }
 972         hb_unlock( pv->common->mutex );
 973     }
 974
 975     if( job->frame_to_stop && pv->common->count_frames >= job->frame_to_stop )
 976     {
 977         hb_buffer_close( &buf );
 978         *buf_out = hb_buffer_init( 0 );
 979         return HB_WORK_DONE;
 980     }
 981
 982     if( job->pts_to_stop && sync->next_start >= job->pts_to_stop )
 983     {
 984         hb_buffer_close( &buf );
 985         *buf_out = hb_buffer_init( 0 );
 986         return HB_WORK_DONE;
 987     }
 988
 989     hb_lock( pv->common->mutex );
 990     start = buf->start - pv->common->audio_passthru_slip;
 991     hb_unlock( pv->common->mutex );
 992     if ( (int64_t)( start - sync->next_pts ) < 0 )
 993     {
 994         // audio time went backwards.
 995         // If our output clock is more than a half frame ahead of the
 996         // input clock drop this frame to move closer to sync.
 997         // Otherwise drop frames until the input clock matches the output clock.
 998         if ( sync->first_drop || sync->next_start - start > 90*15 )
 999         {
1000             // Discard data that's in the past.
1001             if ( sync->first_drop == 0 )
1002             {
1003                 sync->first_drop = sync->next_pts;
1004             }
1005             ++sync->drop_count;
1006             hb_buffer_close( &buf );
1007             return HB_WORK_OK;
1008         }
1009         sync->next_pts = start;
1010     }
1011     if ( sync->first_drop )
1012     {
1013         // we were dropping old data but input buf time is now current
1014         hb_log( "sync: audio %d time went backwards %d ms, dropped %d frames "
1015                 "(next %"PRId64", current %"PRId64")", w->audio->id,
1016                 (int)( sync->next_pts - sync->first_drop ) / 90,
1017                 sync->drop_count, sync->first_drop, sync->next_pts );
1018         sync->first_drop = 0;
1019         sync->drop_count = 0;
1020         sync->next_pts = start;
1021     }
1022     if ( start - sync->next_pts >= (90 * 70) )
1023     {
1024         if ( start - sync->next_pts > (90000LL * 60) )
1025         {
1026             // there's a gap of more than a minute between the last
1027             // frame and this. assume we got a corrupted timestamp
1028             // and just drop the next buf.
1029             hb_log( "sync: %d minute time gap in audio %d - dropping buf"
1030                     "  start %"PRId64", next %"PRId64,
1031                     (int)((start - sync->next_pts) / (90000*60)),
1032                     w->audio->id, start, sync->next_pts );
1033             hb_buffer_close( &buf );
1034             return HB_WORK_OK;
1035         }
1036         /*
1037          * there's a gap of at least 70ms between the last
1038          * frame we processed & the next. Fill it with silence.
1039          * Or in the case of DCA, skip some frames from the
1040          * other streams.
1041          */
1042         if( w->audio->config.out.codec == HB_ACODEC_DCA )
1043         {
1044             hb_log( "sync: audio gap %d ms. Skipping frames. Audio %d"
1045                     "  start %"PRId64", next %"PRId64,
1046                     (int)((start - sync->next_pts) / 90),
1047                     w->audio->id, start, sync->next_pts );
1048             hb_lock( pv->common->mutex );
1049             pv->common->audio_passthru_slip += (start - sync->next_pts);
1050             pv->common->video_pts_slip += (start - sync->next_pts);
1051             hb_unlock( pv->common->mutex );
1052             *buf_out = buf;
1053             return HB_WORK_OK;
1054         }
1055         hb_log( "sync: adding %d ms of silence to audio %d"
1056                 "  start %"PRId64", next %"PRId64,
1057                 (int)((start - sync->next_pts) / 90),
1058                 w->audio->id, start, sync->next_pts );
1059         InsertSilence( w, start - sync->next_pts );
1060     }
1061
1062     /*
1063      * When we get here we've taken care of all the dups and gaps in the
1064      * audio stream and are ready to inject the next input frame into
1065      * the output stream.
1066      */
1067     *buf_out = OutputAudioFrame( w->audio, buf, sync );
1068     return HB_WORK_OK;
1069 }
1070
1071 hb_work_object_t hb_sync_audio =
1072 {
1073     WORK_SYNC_AUDIO,
1074     "AudioSynchronization",
1075     syncAudioInit,
1076     syncAudioWork,
1077     syncAudioClose
1078 };
1079
1080 static void InitAudio( hb_job_t * job, hb_sync_common_t * common, int i )
1081 {
1082     hb_work_object_t  * w;
1083     hb_work_private_t * pv;
1084     hb_title_t        * title = job->title;
1085     hb_sync_audio_t   * sync;
1086
1087     pv = calloc( 1, sizeof( hb_work_private_t ) );
1088     sync = &pv->type.audio;
1089     sync->index = i;
1090     pv->job    = job;
1091     pv->common = common;
1092     pv->common->ref++;
1093     pv->common->pts_count++;
1094
1095     w = hb_get_work( WORK_SYNC_AUDIO );
1096     w->private_data = pv;
1097     w->audio = hb_list_item( title->list_audio, i );
1098     w->fifo_in = w->audio->priv.fifo_raw;
1099
1100     if( w->audio->config.out.codec == HB_ACODEC_AC3 ||
1101         w->audio->config.out.codec == HB_ACODEC_DCA )
1102     {
1103         w->fifo_out = w->audio->priv.fifo_out;
1104     }
1105     else
1106     {
1107         w->fifo_out = w->audio->priv.fifo_sync;
1108     }
1109
1110     if( w->audio->config.out.codec == HB_ACODEC_AC3 )
1111     {
1112         /* Have a silent AC-3 frame ready in case we have to fill a
1113            gap */
1114         AVCodec        * codec;
1115         AVCodecContext * c;
1116         short          * zeros;
1117
1118         codec = avcodec_find_encoder( CODEC_ID_AC3 );
1119         c     = avcodec_alloc_context();
1120
1121         c->bit_rate    = w->audio->config.in.bitrate;
1122         c->sample_rate = w->audio->config.in.samplerate;
1123         c->channels    = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( w->audio->config.in.channel_layout );
1124
1125         if( hb_avcodec_open( c, codec ) < 0 )
1126         {
1127             hb_log( "sync: avcodec_open failed" );
1128             return;
1129         }
1130
1131         zeros          = calloc( AC3_SAMPLES_PER_FRAME *
1132                                  sizeof( short ) * c->channels, 1 );
1133         sync->ac3_size = w->audio->config.in.bitrate * AC3_SAMPLES_PER_FRAME /
1134                              w->audio->config.in.samplerate / 8;
1135         sync->ac3_buf  = malloc( sync->ac3_size );
1136
1137         if( avcodec_encode_audio( c, sync->ac3_buf, sync->ac3_size,
1138                                   zeros ) != sync->ac3_size )
1139         {
1140             hb_log( "sync: avcodec_encode_audio failed" );
1141         }
1142
1143         free( zeros );
1144         hb_avcodec_close( c );
1145         av_free( c );
1146     }
1147     else
1148     {
1149         /* Initialize libsamplerate */
1150         int error;
1151         sync->state = src_new( SRC_SINC_MEDIUM_QUALITY,
1152             HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
1153                 w->audio->config.out.mixdown), &error );
1154         sync->data.end_of_input = 0;
1155     }
1156     hb_list_add( job->list_work, w );
1157 }
1158
1159 static hb_buffer_t * OutputAudioFrame( hb_audio_t *audio, hb_buffer_t *buf,
1160                                        hb_sync_audio_t *sync )
1161 {
1162     int64_t start = sync->next_start;
1163     int64_t duration = buf->stop - buf->start;
1164
1165     sync->next_pts += duration;
1166
1167     if( audio->config.in.samplerate == audio->config.out.samplerate ||
1168         audio->config.out.codec == HB_ACODEC_AC3 ||
1169         audio->config.out.codec == HB_ACODEC_DCA )
1170     {
1171         /*
1172          * If we don't have to do sample rate conversion or this audio is
1173          * pass-thru just send the input buffer downstream after adjusting
1174          * its timestamps to make the output stream continuous.
1175          */
1176     }
1177     else
1178     {
1179         /* Not pass-thru - do sample rate conversion */
1180         int count_in, count_out;
1181         hb_buffer_t * buf_raw = buf;
1182         int channel_count = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown) *
1183                             sizeof( float );
1184
1185         count_in  = buf_raw->size / channel_count;
1186         /*
1187          * When using stupid rates like 44.1 there will always be some
1188          * truncation error. E.g., a 1536 sample AC3 frame will turn into a
1189          * 1536*44.1/48.0 = 1411.2 sample frame. If we just truncate the .2
1190          * the error will build up over time and eventually the audio will
1191          * substantially lag the video. libsamplerate will keep track of the
1192          * fractional sample & give it to us when appropriate if we give it
1193          * an extra sample of space in the output buffer.
1194          */
1195         count_out = ( duration * audio->config.out.samplerate ) / 90000 + 1;
1196
1197         sync->data.input_frames = count_in;
1198         sync->data.output_frames = count_out;
1199         sync->data.src_ratio = (double)audio->config.out.samplerate /
1200                                (double)audio->config.in.samplerate;
1201
1202         buf = hb_buffer_init( count_out * channel_count );
1203         sync->data.data_in  = (float *) buf_raw->data;
1204         sync->data.data_out = (float *) buf->data;
1205         if( src_process( sync->state, &sync->data ) )
1206         {
1207             /* XXX If this happens, we're screwed */
1208             hb_log( "sync: audio %d src_process failed", audio->id );
1209         }
1210         hb_buffer_close( &buf_raw );
1211
1212         buf->size = sync->data.output_frames_gen * channel_count;
1213         duration = ( sync->data.output_frames_gen * 90000 ) /
1214                    audio->config.out.samplerate;
1215     }
1216     buf->frametype = HB_FRAME_AUDIO;
1217     buf->start = start;
1218     buf->stop  = start + duration;
1219     sync->next_start = start + duration;
1220     return buf;
1221 }
1222
1223 static void InsertSilence( hb_work_object_t * w, int64_t duration )
1224 {
1225     hb_work_private_t * pv = w->private_data;
1226     hb_sync_audio_t *sync = &pv->type.audio;
1227     hb_buffer_t     *buf;
1228     hb_fifo_t       *fifo;
1229
1230     // to keep pass-thru and regular audio in sync we generate silence in
1231     // AC3 frame-sized units. If the silence duration isn't an integer multiple
1232     // of the AC3 frame duration we will truncate or round up depending on
1233     // which minimizes the timing error.
1234     const int frame_dur = ( 90000 * AC3_SAMPLES_PER_FRAME ) /
1235                           w->audio->config.in.samplerate;
1236     int frame_count = ( duration + (frame_dur >> 1) ) / frame_dur;
1237
1238     while ( --frame_count >= 0 )
1239     {
1240         if( w->audio->config.out.codec == HB_ACODEC_AC3 )
1241         {
1242             buf        = hb_buffer_init( sync->ac3_size );
1243             buf->start = sync->next_pts;
1244             buf->stop  = buf->start + frame_dur;
1245             memcpy( buf->data, sync->ac3_buf, buf->size );
1246             fifo = w->audio->priv.fifo_out;
1247         }
1248         else
1249         {
1250             buf = hb_buffer_init( AC3_SAMPLES_PER_FRAME * sizeof( float ) *
1251                                      HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
1252                                          w->audio->config.out.mixdown) );
1253             buf->start = sync->next_pts;
1254             buf->stop  = buf->start + frame_dur;
1255             memset( buf->data, 0, buf->size );
1256             fifo = w->audio->priv.fifo_sync;
1257         }
1258         buf = OutputAudioFrame( w->audio, buf, sync );
1259         hb_fifo_push( fifo, buf );
1260     }
1261 }
1262
1263 static void UpdateState( hb_work_object_t * w )
1264 {
1265     hb_work_private_t * pv = w->private_data;
1266     hb_sync_video_t   * sync = &pv->type.video;
1267     hb_state_t state;
1268
1269     if( !pv->common->count_frames )
1270     {
1271         sync->st_first = hb_get_date();
1272         pv->job->st_pause_date = -1;
1273         pv->job->st_paused = 0;
1274     }
1275     pv->common->count_frames++;
1276
1277     if( hb_get_date() > sync->st_dates[3] + 1000 )
1278     {
1279         memmove( &sync->st_dates[0], &sync->st_dates[1],
1280                  3 * sizeof( uint64_t ) );
1281         memmove( &sync->st_counts[0], &sync->st_counts[1],
1282                  3 * sizeof( uint64_t ) );
1283         sync->st_dates[3]  = hb_get_date();
1284         sync->st_counts[3] = pv->common->count_frames;
1285     }
1286
1287 #define p state.param.working
1288     state.state = HB_STATE_WORKING;
1289     p.progress  = (float) pv->common->count_frames / (float) sync->count_frames_max;
1290     if( p.progress > 1.0 )
1291     {
1292         p.progress = 1.0;
1293     }
1294     p.rate_cur   = 1000.0 *
1295         (float) ( sync->st_counts[3] - sync->st_counts[0] ) /
1296         (float) ( sync->st_dates[3] - sync->st_dates[0] );
1297     if( hb_get_date() > sync->st_first + 4000 )
1298     {
1299         int eta;
1300         p.rate_avg = 1000.0 * (float) sync->st_counts[3] /
1301             (float) ( sync->st_dates[3] - sync->st_first - pv->job->st_paused);
1302         eta = (float) ( sync->count_frames_max - sync->st_counts[3] ) /
1303             p.rate_avg;
1304         p.hours   = eta / 3600;
1305         p.minutes = ( eta % 3600 ) / 60;
1306         p.seconds = eta % 60;
1307     }
1308     else
1309     {
1310         p.rate_avg = 0.0;
1311         p.hours    = -1;
1312         p.minutes  = -1;
1313         p.seconds  = -1;
1314     }
1315 #undef p
1316
1317     hb_set_state( pv->job->h, &state );
1318 }
1319
1320 static void UpdateSearchState( hb_work_object_t * w, int64_t start )
1321 {
1322     hb_work_private_t * pv = w->private_data;
1323     hb_sync_video_t   * sync = &pv->type.video;
1324     hb_state_t state;
1325     uint64_t now;
1326     double avg;
1327
1328     now = hb_get_date();
1329     if( !pv->common->count_frames )
1330     {
1331         sync->st_first = now;
1332         pv->job->st_pause_date = -1;
1333         pv->job->st_paused = 0;
1334     }
1335     pv->common->count_frames++;
1336
1337 #define p state.param.working
1338     state.state = HB_STATE_SEARCHING;
1339     if ( pv->job->frame_to_start )
1340         p.progress  = (float) pv->common->count_frames /
1341                       (float) pv->job->frame_to_start;
1342     else if ( pv->job->pts_to_start )
1343         p.progress  = (float) start / (float) pv->job->pts_to_start;
1344     else
1345         p.progress = 0;
1346     if( p.progress > 1.0 )
1347     {
1348         p.progress = 1.0;
1349     }
1350     if (now > sync->st_first)
1351     {
1352         int eta;
1353
1354         if ( pv->job->frame_to_start )
1355         {
1356             avg = 1000.0 * (double)pv->common->count_frames / (now - sync->st_first);
1357             eta = ( pv->job->frame_to_start - pv->common->count_frames ) / avg;
1358         }
1359         else if ( pv->job->pts_to_start )
1360         {
1361             avg = 1000.0 * (double)start / (now - sync->st_first);
1362             eta = ( pv->job->pts_to_start - start ) / avg;
1363         }
1364         p.hours   = eta / 3600;
1365         p.minutes = ( eta % 3600 ) / 60;
1366         p.seconds = eta % 60;
1367     }
1368     else
1369     {
1370         p.rate_avg = 0.0;
1371         p.hours    = -1;
1372         p.minutes  = -1;
1373         p.seconds  = -1;
1374     }
1375 #undef p
1376
1377     hb_set_state( pv->job->h, &state );
1378 }
1379
1380 static void getPtsOffset( hb_work_object_t * w )
1381 {
1382     hb_work_private_t * pv = w->private_data;
1383     int           i ;
1384     int64_t       first_pts = INT64_MAX;
1385
1386     for( i = 0; i < pv->common->pts_count; i++ )
1387     {
1388         if ( pv->common->first_pts[i] < first_pts )
1389             first_pts = pv->common->first_pts[i];
1390     }
1391     pv->common->audio_passthru_slip = pv->common->pts_offset = first_pts;
1392     return;
1393 }
1394
1395 static int checkPtsOffset( hb_work_object_t * w )
1396 {
1397     hb_work_private_t * pv = w->private_data;
1398     int           i ;
1399
1400     for( i = 0; i < pv->common->pts_count; i++ )
1401     {
1402         if ( pv->common->first_pts[i] == INT64_MAX )
1403             return 0;
1404     }
1405     getPtsOffset( w );
1406     return 1;
1407 }