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         {
 569             /*
 570              * Rewrite timestamps on subtitles that came from Closed Captions
 571              * since they are using the MPEG2 timestamps.
 572              */
 573             while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
 574             {
 575                 /*
 576                  * Rewrite the timestamps as and when the video
 577                  * (cur->start) reaches the same timestamp as a
 578                  * closed caption (sub->start).
 579                  *
 580                  * What about discontinuity boundaries - not delt
 581                  * with here - Van?
 582                  *
 583                  * Bypass the sync fifo altogether.
 584                  */
 585                 if( sub->size <= 0 )
 586                 {
 587                     sub = hb_fifo_get( subtitle->fifo_raw );
 588                     hb_fifo_push( subtitle->fifo_out, sub );
 589                     sub = NULL;
 590                     break;
 591                 } else {
 592                     /*
 593                      * Sync the subtitles to the incoming video, and use
 594                      * the matching converted video timestamp.
 595                      *
 596                      * Note that it doesn't appear that we need to convert
 597                      * timestamps, I guess that they were already correct,
 598                      * so just push them through for rendering.
 599                      *
 600                      */
 601                     if( sub->start < cur->start )
 602                     {
 603                         sub = hb_fifo_get( subtitle->fifo_raw );
 604                         hb_fifo_push( subtitle->fifo_out, sub );
 605                     } else {
 606                         sub = NULL;
 607                         break;
 608                     }
 609                 }
 610             }
 611         }
 612
 613         if( subtitle->source == VOBSUB )
 614         {
 615             hb_buffer_t * sub2;
 616             while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
 617             {
 618                 if( sub->size == 0 )
 619                 {
 620                     /*
 621                      * EOF, pass it through immediately.
 622                      */
 623                     break;
 624                 }
 625
 626                 /* If two subtitles overlap, make the first one stop
 627                    when the second one starts */
 628                 sub2 = hb_fifo_see2( subtitle->fifo_raw );
 629                 if( sub2 && sub->stop > sub2->start )
 630                 {
 631                     sub->stop = sub2->start;
 632                 }
 633
 634                 // hb_log("0x%x: video seq: %"PRId64" subtitle sequence: %"PRId64,
 635                 //       sub, cur->sequence, sub->sequence);
 636
 637                 if( sub->sequence > cur->sequence )
 638                 {
 639                     /*
 640                      * The video is behind where we are, so wait until
 641                      * it catches up to the same reader point on the
 642                      * DVD. Then our PTS should be in the same region
 643                      * as the video.
 644                      */
 645                     sub = NULL;
 646                     break;
 647                 }
 648
 649                 if( sub->stop > cur->start ) {
 650                     /*
 651                      * The stop time is in the future, so fall through
 652                      * and we'll deal with it in the next block of
 653                      * code.
 654                      */
 655
 656                     /*
 657                      * There is a valid subtitle, is it time to display it?
 658                      */
 659                     if( sub->stop > sub->start)
 660                     {
 661                         /*
 662                          * Normal subtitle which ends after it starts,
 663                          * check to see that the current video is between
 664                          * the start and end.
 665                          */
 666                         if( cur->start > sub->start &&
 667                             cur->start < sub->stop )
 668                         {
 669                             /*
 670                             * We should be playing this, so leave the
 671                             * subtitle in place.
 672                             *
 673                             * fall through to display
 674                             */
 675                             if( ( sub->stop - sub->start ) < ( 2 * 90000 ) )
 676                             {
 677                                 /*
 678                                  * Subtitle is on for less than three
 679                                  * seconds, extend the time that it is
 680                                  * displayed to make it easier to read.
 681                                  * Make it 3 seconds or until the next
 682                                  * subtitle is displayed.
 683                                  *
 684                                  * This is in response to Indochine which
 685                                  * only displays subs for 1 second -
 686                                  * too fast to read.
 687                                  */
 688                                 sub->stop = sub->start + ( 2 * 90000 );
 689
 690                                 sub2 = hb_fifo_see2( subtitle->fifo_raw );
 691
 692                                 if( sub2 && sub->stop > sub2->start )
 693                                 {
 694                                     sub->stop = sub2->start;
 695                                 }
 696                             }
 697                         }
 698                         else
 699                         {
 700                             /*
 701                              * Defer until the play point is within
 702                              * the subtitle
 703                              */
 704                             sub = NULL;
 705                         }
 706                     }
 707                     else
 708                     {
 709                         /*
 710                          * The end of the subtitle is less than the start,
 711                          * this is a sign of a PTS discontinuity.
 712                          */
 713                         if( sub->start > cur->start )
 714                         {
 715                             /*
 716                              * we haven't reached the start time yet, or
 717                              * we have jumped backwards after having
 718                              * already started this subtitle.
 719                              */
 720                             if( cur->start < sub->stop )
 721                             {
 722                                 /*
 723                                  * We have jumped backwards and so should
 724                                  * continue displaying this subtitle.
 725                                  *
 726                                  * fall through to display.
 727                                  */
 728                             }
 729                             else
 730                             {
 731                                 /*
 732                                  * Defer until the play point is
 733                                  * within the subtitle
 734                                  */
 735                                 sub = NULL;
 736                             }
 737                         } else {
 738                             /*
 739                             * Play this subtitle as the start is
 740                             * greater than our video point.
 741                             *
 742                             * fall through to display/
 743                             */
 744                         }
 745                     }
 746                         break;
 747                 }
 748                 else
 749                 {
 750
 751                     /*
 752                      * The subtitle is older than this picture, trash it
 753                      */
 754                     sub = hb_fifo_get( subtitle->fifo_raw );
 755                     hb_buffer_close( &sub );
 756                 }
 757             }
 758
 759             /* If we have a subtitle for this picture, copy it */
 760             /* FIXME: we should avoid this memcpy */
 761             if( sub )
 762             {
 763                 if( sub->size > 0 )
 764                 {
 765                     if( subtitle->config.dest == RENDERSUB )
 766                     {
 767                         if ( cur->sub == NULL )
 768                         {
 769                             /*
 770                              * Tack onto the video buffer for rendering
 771                              */
 772                             cur->sub         = hb_buffer_init( sub->size );
 773                             cur->sub->x      = sub->x;
 774                             cur->sub->y      = sub->y;
 775                             cur->sub->width  = sub->width;
 776                             cur->sub->height = sub->height;
 777                             memcpy( cur->sub->data, sub->data, sub->size );
 778                         }
 779                     } else {
 780                         /*
 781                          * Pass-Through, pop it off of the raw queue,
 782                          */
 783                         sub = hb_fifo_get( subtitle->fifo_raw );
 784                         hb_fifo_push( subtitle->fifo_sync, sub );
 785                     }
 786                 } else {
 787                     /*
 788                     * EOF - consume for rendered, else pass through
 789                     */
 790                     if( subtitle->config.dest == RENDERSUB )
 791                     {
 792                         sub = hb_fifo_get( subtitle->fifo_raw );
 793                         hb_buffer_close( &sub );
 794                     } else {
 795                         sub = hb_fifo_get( subtitle->fifo_raw );
 796                         hb_fifo_push( subtitle->fifo_sync, sub );
 797                     }
 798                 }
 799             }
 800         }
 801     } // end subtitles
 802
 803     /*
 804      * Adjust the pts of the current frame so that it's contiguous
 805      * with the previous frame. The start time of the current frame
 806      * has to be the end time of the previous frame and the stop
 807      * time has to be the start of the next frame.  We don't
 808      * make any adjustments to the source timestamps other than removing
 809      * the clock offsets (which also removes pts discontinuities).
 810      * This means we automatically encode at the source's frame rate.
 811      * MP2 uses an implicit duration (frames end when the next frame
 812      * starts) but more advanced containers like MP4 use an explicit
 813      * duration. Since we're looking ahead one frame we set the
 814      * explicit stop time from the start time of the next frame.
 815      */
 816     *buf_out = cur;
 817     sync->cur = cur = next;
 818     cur->sub = NULL;
 819     sync->next_pts = cur->start;
 820     int64_t duration = cur->start - sync->pts_skip - (*buf_out)->start;
 821     sync->pts_skip = 0;
 822     if ( duration <= 0 )
 823     {
 824         hb_log( "sync: invalid video duration %"PRId64", start %"PRId64", next %"PRId64"",
 825                 duration, (*buf_out)->start, next->start );
 826     }
 827
 828     (*buf_out)->start = sync->next_start;
 829     sync->next_start += duration;
 830     (*buf_out)->stop = sync->next_start;
 831
 832     if ( sync->chap_mark )
 833     {
 834         // we have a pending chapter mark from a recent drop - put it on this
 835         // buffer (this may make it one frame late but we can't do any better).
 836         (*buf_out)->new_chap = sync->chap_mark;
 837         sync->chap_mark = 0;
 838     }
 839
 840     /* Update UI */
 841     UpdateState( w );
 842
 843     return HB_WORK_OK;
 844 }
 845
 846 // sync*Init does nothing because sync has a special initializer
 847 // that takes care of initializing video and all audio tracks
 848 int syncVideoInit( hb_work_object_t * w, hb_job_t * job)
 849 {
 850     return 0;
 851 }
 852
 853 hb_work_object_t hb_sync_video =
 854 {
 855     WORK_SYNC_VIDEO,
 856     "Video Synchronization",
 857     syncVideoInit,
 858     syncVideoWork,
 859     syncVideoClose
 860 };
 861
 862 /***********************************************************************
 863  * Close Audio
 864  ***********************************************************************
 865  *
 866  **********************************************************************/
 867 void syncAudioClose( hb_work_object_t * w )
 868 {
 869     hb_work_private_t * pv    = w->private_data;
 870     hb_sync_audio_t   * sync  = &pv->type.audio;
 871
 872     if( w->audio->config.out.codec == HB_ACODEC_AC3 )
 873     {
 874         free( sync->ac3_buf );
 875     }
 876     else
 877     {
 878         src_delete( sync->state );
 879     }
 880
 881     hb_lock( pv->common->mutex );
 882     if ( --pv->common->ref == 0 )
 883     {
 884         hb_unlock( pv->common->mutex );
 885         hb_lock_close( &pv->common->mutex );
 886         free( pv->common );
 887     }
 888     else
 889     {
 890         hb_unlock( pv->common->mutex );
 891     }
 892
 893     free( pv );
 894     w->private_data = NULL;
 895 }
 896
 897 int syncAudioInit( hb_work_object_t * w, hb_job_t * job)
 898 {
 899     return 0;
 900 }
 901
 902 /***********************************************************************
 903  * SyncAudio
 904  ***********************************************************************
 905  *
 906  **********************************************************************/
 907 static int syncAudioWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
 908                        hb_buffer_t ** buf_out )
 909 {
 910     hb_work_private_t * pv = w->private_data;
 911     hb_job_t        * job = pv->job;
 912     hb_sync_audio_t * sync = &pv->type.audio;
 913     hb_buffer_t     * buf;
 914     int64_t start;
 915
 916     *buf_out = NULL;
 917     buf = *buf_in;
 918     *buf_in = NULL;
 919     /* if the next buffer is an eof send it downstream */
 920     if ( buf->size <= 0 )
 921     {
 922         hb_buffer_close( &buf );
 923         *buf_out = hb_buffer_init( 0 );
 924         return HB_WORK_DONE;
 925     }
 926
 927     /* Wait for start frame if doing point-to-point */
 928     hb_lock( pv->common->mutex );
 929     while ( !pv->common->start_found )
 930     {
 931         if ( buf->start < pv->common->audio_pts_thresh )
 932         {
 933             hb_buffer_close( &buf );
 934             hb_unlock( pv->common->mutex );
 935             return HB_WORK_OK;
 936         }
 937         while ( !pv->common->start_found &&
 938                 buf->start >= pv->common->audio_pts_thresh )
 939         {
 940             hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
 941         }
 942     }
 943     if ( buf->start < pv->common->audio_pts_thresh )
 944     {
 945         hb_buffer_close( &buf );
 946         hb_unlock( pv->common->mutex );
 947         return HB_WORK_OK;
 948     }
 949     hb_unlock( pv->common->mutex );
 950
 951     /* Wait till we can determine the initial pts of all streams */
 952     if( pv->common->pts_offset == INT64_MIN )
 953     {
 954         pv->common->first_pts[sync->index+1] = buf->start;
 955         hb_lock( pv->common->mutex );
 956         while( pv->common->pts_offset == INT64_MIN )
 957         {
 958             // Full fifos will make us wait forever, so get the
 959             // pts offset from the available streams if full
 960             if (hb_fifo_is_full(w->fifo_in))
 961             {
 962                 getPtsOffset( w );
 963                 hb_cond_broadcast( pv->common->next_frame );
 964             }
 965             else if ( checkPtsOffset( w ) )
 966                 hb_cond_broadcast( pv->common->next_frame );
 967             else
 968                 hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
 969         }
 970         hb_unlock( pv->common->mutex );
 971     }
 972
 973     if( job->frame_to_stop && pv->common->count_frames >= job->frame_to_stop )
 974     {
 975         hb_buffer_close( &buf );
 976         *buf_out = hb_buffer_init( 0 );
 977         return HB_WORK_DONE;
 978     }
 979
 980     if( job->pts_to_stop && sync->next_start >= job->pts_to_stop )
 981     {
 982         hb_buffer_close( &buf );
 983         *buf_out = hb_buffer_init( 0 );
 984         return HB_WORK_DONE;
 985     }
 986
 987     hb_lock( pv->common->mutex );
 988     start = buf->start - pv->common->audio_passthru_slip;
 989     hb_unlock( pv->common->mutex );
 990     if ( (int64_t)( start - sync->next_pts ) < 0 )
 991     {
 992         // audio time went backwards.
 993         // If our output clock is more than a half frame ahead of the
 994         // input clock drop this frame to move closer to sync.
 995         // Otherwise drop frames until the input clock matches the output clock.
 996         if ( sync->first_drop || sync->next_start - start > 90*15 )
 997         {
 998             // Discard data that's in the past.
 999             if ( sync->first_drop == 0 )
1000             {
1001                 sync->first_drop = sync->next_pts;
1002             }
1003             ++sync->drop_count;
1004             hb_buffer_close( &buf );
1005             return HB_WORK_OK;
1006         }
1007         sync->next_pts = start;
1008     }
1009     if ( sync->first_drop )
1010     {
1011         // we were dropping old data but input buf time is now current
1012         hb_log( "sync: audio %d time went backwards %d ms, dropped %d frames "
1013                 "(next %"PRId64", current %"PRId64")", w->audio->id,
1014                 (int)( sync->next_pts - sync->first_drop ) / 90,
1015                 sync->drop_count, sync->first_drop, sync->next_pts );
1016         sync->first_drop = 0;
1017         sync->drop_count = 0;
1018         sync->next_pts = start;
1019     }
1020     if ( start - sync->next_pts >= (90 * 70) )
1021     {
1022         if ( start - sync->next_pts > (90000LL * 60) )
1023         {
1024             // there's a gap of more than a minute between the last
1025             // frame and this. assume we got a corrupted timestamp
1026             // and just drop the next buf.
1027             hb_log( "sync: %d minute time gap in audio %d - dropping buf"
1028                     "  start %"PRId64", next %"PRId64,
1029                     (int)((start - sync->next_pts) / (90000*60)),
1030                     w->audio->id, start, sync->next_pts );
1031             hb_buffer_close( &buf );
1032             return HB_WORK_OK;
1033         }
1034         /*
1035          * there's a gap of at least 70ms between the last
1036          * frame we processed & the next. Fill it with silence.
1037          * Or in the case of DCA, skip some frames from the
1038          * other streams.
1039          */
1040         if( w->audio->config.out.codec == HB_ACODEC_DCA )
1041         {
1042             hb_log( "sync: audio gap %d ms. Skipping frames. Audio %d"
1043                     "  start %"PRId64", next %"PRId64,
1044                     (int)((start - sync->next_pts) / 90),
1045                     w->audio->id, start, sync->next_pts );
1046             hb_lock( pv->common->mutex );
1047             pv->common->audio_passthru_slip += (start - sync->next_pts);
1048             pv->common->video_pts_slip += (start - sync->next_pts);
1049             hb_unlock( pv->common->mutex );
1050             *buf_out = buf;
1051             return HB_WORK_OK;
1052         }
1053         hb_log( "sync: adding %d ms of silence to audio %d"
1054                 "  start %"PRId64", next %"PRId64,
1055                 (int)((start - sync->next_pts) / 90),
1056                 w->audio->id, start, sync->next_pts );
1057         InsertSilence( w, start - sync->next_pts );
1058     }
1059
1060     /*
1061      * When we get here we've taken care of all the dups and gaps in the
1062      * audio stream and are ready to inject the next input frame into
1063      * the output stream.
1064      */
1065     *buf_out = OutputAudioFrame( w->audio, buf, sync );
1066     return HB_WORK_OK;
1067 }
1068
1069 hb_work_object_t hb_sync_audio =
1070 {
1071     WORK_SYNC_AUDIO,
1072     "AudioSynchronization",
1073     syncAudioInit,
1074     syncAudioWork,
1075     syncAudioClose
1076 };
1077
1078 static void InitAudio( hb_job_t * job, hb_sync_common_t * common, int i )
1079 {
1080     hb_work_object_t  * w;
1081     hb_work_private_t * pv;
1082     hb_title_t        * title = job->title;
1083     hb_sync_audio_t   * sync;
1084
1085     pv = calloc( 1, sizeof( hb_work_private_t ) );
1086     sync = &pv->type.audio;
1087     sync->index = i;
1088     pv->job    = job;
1089     pv->common = common;
1090     pv->common->ref++;
1091     pv->common->pts_count++;
1092
1093     w = hb_get_work( WORK_SYNC_AUDIO );
1094     w->private_data = pv;
1095     w->audio = hb_list_item( title->list_audio, i );
1096     w->fifo_in = w->audio->priv.fifo_raw;
1097
1098     if( w->audio->config.out.codec == HB_ACODEC_AC3 ||
1099         w->audio->config.out.codec == HB_ACODEC_DCA )
1100     {
1101         w->fifo_out = w->audio->priv.fifo_out;
1102     }
1103     else
1104     {
1105         w->fifo_out = w->audio->priv.fifo_sync;
1106     }
1107
1108     if( w->audio->config.out.codec == HB_ACODEC_AC3 )
1109     {
1110         /* Have a silent AC-3 frame ready in case we have to fill a
1111            gap */
1112         AVCodec        * codec;
1113         AVCodecContext * c;
1114         short          * zeros;
1115
1116         codec = avcodec_find_encoder( CODEC_ID_AC3 );
1117         c     = avcodec_alloc_context();
1118
1119         c->bit_rate    = w->audio->config.in.bitrate;
1120         c->sample_rate = w->audio->config.in.samplerate;
1121         c->channels    = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( w->audio->config.in.channel_layout );
1122
1123         if( hb_avcodec_open( c, codec ) < 0 )
1124         {
1125             hb_log( "sync: avcodec_open failed" );
1126             return;
1127         }
1128
1129         zeros          = calloc( AC3_SAMPLES_PER_FRAME *
1130                                  sizeof( short ) * c->channels, 1 );
1131         sync->ac3_size = w->audio->config.in.bitrate * AC3_SAMPLES_PER_FRAME /
1132                              w->audio->config.in.samplerate / 8;
1133         sync->ac3_buf  = malloc( sync->ac3_size );
1134
1135         if( avcodec_encode_audio( c, sync->ac3_buf, sync->ac3_size,
1136                                   zeros ) != sync->ac3_size )
1137         {
1138             hb_log( "sync: avcodec_encode_audio failed" );
1139         }
1140
1141         free( zeros );
1142         hb_avcodec_close( c );
1143         av_free( c );
1144     }
1145     else
1146     {
1147         /* Initialize libsamplerate */
1148         int error;
1149         sync->state = src_new( SRC_SINC_MEDIUM_QUALITY,
1150             HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
1151                 w->audio->config.out.mixdown), &error );
1152         sync->data.end_of_input = 0;
1153     }
1154     hb_list_add( job->list_work, w );
1155 }
1156
1157 static hb_buffer_t * OutputAudioFrame( hb_audio_t *audio, hb_buffer_t *buf,
1158                                        hb_sync_audio_t *sync )
1159 {
1160     int64_t start = sync->next_start;
1161     int64_t duration = buf->stop - buf->start;
1162
1163     sync->next_pts += duration;
1164
1165     if( audio->config.in.samplerate == audio->config.out.samplerate ||
1166         audio->config.out.codec == HB_ACODEC_AC3 ||
1167         audio->config.out.codec == HB_ACODEC_DCA )
1168     {
1169         /*
1170          * If we don't have to do sample rate conversion or this audio is
1171          * pass-thru just send the input buffer downstream after adjusting
1172          * its timestamps to make the output stream continuous.
1173          */
1174     }
1175     else
1176     {
1177         /* Not pass-thru - do sample rate conversion */
1178         int count_in, count_out;
1179         hb_buffer_t * buf_raw = buf;
1180         int channel_count = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown) *
1181                             sizeof( float );
1182
1183         count_in  = buf_raw->size / channel_count;
1184         /*
1185          * When using stupid rates like 44.1 there will always be some
1186          * truncation error. E.g., a 1536 sample AC3 frame will turn into a
1187          * 1536*44.1/48.0 = 1411.2 sample frame. If we just truncate the .2
1188          * the error will build up over time and eventually the audio will
1189          * substantially lag the video. libsamplerate will keep track of the
1190          * fractional sample & give it to us when appropriate if we give it
1191          * an extra sample of space in the output buffer.
1192          */
1193         count_out = ( duration * audio->config.out.samplerate ) / 90000 + 1;
1194
1195         sync->data.input_frames = count_in;
1196         sync->data.output_frames = count_out;
1197         sync->data.src_ratio = (double)audio->config.out.samplerate /
1198                                (double)audio->config.in.samplerate;
1199
1200         buf = hb_buffer_init( count_out * channel_count );
1201         sync->data.data_in  = (float *) buf_raw->data;
1202         sync->data.data_out = (float *) buf->data;
1203         if( src_process( sync->state, &sync->data ) )
1204         {
1205             /* XXX If this happens, we're screwed */
1206             hb_log( "sync: audio %d src_process failed", audio->id );
1207         }
1208         hb_buffer_close( &buf_raw );
1209
1210         buf->size = sync->data.output_frames_gen * channel_count;
1211         duration = ( sync->data.output_frames_gen * 90000 ) /
1212                    audio->config.out.samplerate;
1213     }
1214     buf->frametype = HB_FRAME_AUDIO;
1215     buf->start = start;
1216     buf->stop  = start + duration;
1217     sync->next_start = start + duration;
1218     return buf;
1219 }
1220
1221 static void InsertSilence( hb_work_object_t * w, int64_t duration )
1222 {
1223     hb_work_private_t * pv = w->private_data;
1224     hb_sync_audio_t *sync = &pv->type.audio;
1225     hb_buffer_t     *buf;
1226     hb_fifo_t       *fifo;
1227
1228     // to keep pass-thru and regular audio in sync we generate silence in
1229     // AC3 frame-sized units. If the silence duration isn't an integer multiple
1230     // of the AC3 frame duration we will truncate or round up depending on
1231     // which minimizes the timing error.
1232     const int frame_dur = ( 90000 * AC3_SAMPLES_PER_FRAME ) /
1233                           w->audio->config.in.samplerate;
1234     int frame_count = ( duration + (frame_dur >> 1) ) / frame_dur;
1235
1236     while ( --frame_count >= 0 )
1237     {
1238         if( w->audio->config.out.codec == HB_ACODEC_AC3 )
1239         {
1240             buf        = hb_buffer_init( sync->ac3_size );
1241             buf->start = sync->next_pts;
1242             buf->stop  = buf->start + frame_dur;
1243             memcpy( buf->data, sync->ac3_buf, buf->size );
1244             fifo = w->audio->priv.fifo_out;
1245         }
1246         else
1247         {
1248             buf = hb_buffer_init( AC3_SAMPLES_PER_FRAME * sizeof( float ) *
1249                                      HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
1250                                          w->audio->config.out.mixdown) );
1251             buf->start = sync->next_pts;
1252             buf->stop  = buf->start + frame_dur;
1253             memset( buf->data, 0, buf->size );
1254             fifo = w->audio->priv.fifo_sync;
1255         }
1256         buf = OutputAudioFrame( w->audio, buf, sync );
1257         hb_fifo_push( fifo, buf );
1258     }
1259 }
1260
1261 static void UpdateState( hb_work_object_t * w )
1262 {
1263     hb_work_private_t * pv = w->private_data;
1264     hb_sync_video_t   * sync = &pv->type.video;
1265     hb_state_t state;
1266
1267     if( !pv->common->count_frames )
1268     {
1269         sync->st_first = hb_get_date();
1270         pv->job->st_pause_date = -1;
1271         pv->job->st_paused = 0;
1272     }
1273     pv->common->count_frames++;
1274
1275     if( hb_get_date() > sync->st_dates[3] + 1000 )
1276     {
1277         memmove( &sync->st_dates[0], &sync->st_dates[1],
1278                  3 * sizeof( uint64_t ) );
1279         memmove( &sync->st_counts[0], &sync->st_counts[1],
1280                  3 * sizeof( uint64_t ) );
1281         sync->st_dates[3]  = hb_get_date();
1282         sync->st_counts[3] = pv->common->count_frames;
1283     }
1284
1285 #define p state.param.working
1286     state.state = HB_STATE_WORKING;
1287     p.progress  = (float) pv->common->count_frames / (float) sync->count_frames_max;
1288     if( p.progress > 1.0 )
1289     {
1290         p.progress = 1.0;
1291     }
1292     p.rate_cur   = 1000.0 *
1293         (float) ( sync->st_counts[3] - sync->st_counts[0] ) /
1294         (float) ( sync->st_dates[3] - sync->st_dates[0] );
1295     if( hb_get_date() > sync->st_first + 4000 )
1296     {
1297         int eta;
1298         p.rate_avg = 1000.0 * (float) sync->st_counts[3] /
1299             (float) ( sync->st_dates[3] - sync->st_first - pv->job->st_paused);
1300         eta = (float) ( sync->count_frames_max - sync->st_counts[3] ) /
1301             p.rate_avg;
1302         p.hours   = eta / 3600;
1303         p.minutes = ( eta % 3600 ) / 60;
1304         p.seconds = eta % 60;
1305     }
1306     else
1307     {
1308         p.rate_avg = 0.0;
1309         p.hours    = -1;
1310         p.minutes  = -1;
1311         p.seconds  = -1;
1312     }
1313 #undef p
1314
1315     hb_set_state( pv->job->h, &state );
1316 }
1317
1318 static void UpdateSearchState( hb_work_object_t * w, int64_t start )
1319 {
1320     hb_work_private_t * pv = w->private_data;
1321     hb_sync_video_t   * sync = &pv->type.video;
1322     hb_state_t state;
1323     uint64_t now;
1324     double avg;
1325
1326     now = hb_get_date();
1327     if( !pv->common->count_frames )
1328     {
1329         sync->st_first = now;
1330         pv->job->st_pause_date = -1;
1331         pv->job->st_paused = 0;
1332     }
1333     pv->common->count_frames++;
1334
1335 #define p state.param.working
1336     state.state = HB_STATE_SEARCHING;
1337     if ( pv->job->frame_to_start )
1338         p.progress  = (float) pv->common->count_frames /
1339                       (float) pv->job->frame_to_start;
1340     else if ( pv->job->pts_to_start )
1341         p.progress  = (float) start / (float) pv->job->pts_to_start;
1342     else
1343         p.progress = 0;
1344     if( p.progress > 1.0 )
1345     {
1346         p.progress = 1.0;
1347     }
1348     if (now > sync->st_first)
1349     {
1350         int eta;
1351
1352         if ( pv->job->frame_to_start )
1353         {
1354             avg = 1000.0 * (double)pv->common->count_frames / (now - sync->st_first);
1355             eta = ( pv->job->frame_to_start - pv->common->count_frames ) / avg;
1356         }
1357         else if ( pv->job->pts_to_start )
1358         {
1359             avg = 1000.0 * (double)start / (now - sync->st_first);
1360             eta = ( pv->job->pts_to_start - start ) / avg;
1361         }
1362         p.hours   = eta / 3600;
1363         p.minutes = ( eta % 3600 ) / 60;
1364         p.seconds = eta % 60;
1365     }
1366     else
1367     {
1368         p.rate_avg = 0.0;
1369         p.hours    = -1;
1370         p.minutes  = -1;
1371         p.seconds  = -1;
1372     }
1373 #undef p
1374
1375     hb_set_state( pv->job->h, &state );
1376 }
1377
1378 static void getPtsOffset( hb_work_object_t * w )
1379 {
1380     hb_work_private_t * pv = w->private_data;
1381     int           i ;
1382     int64_t       first_pts = INT64_MAX;
1383
1384     for( i = 0; i < pv->common->pts_count; i++ )
1385     {
1386         if ( pv->common->first_pts[i] < first_pts )
1387             first_pts = pv->common->first_pts[i];
1388     }
1389     pv->common->audio_passthru_slip = pv->common->pts_offset = first_pts;
1390     return;
1391 }
1392
1393 static int checkPtsOffset( hb_work_object_t * w )
1394 {
1395     hb_work_private_t * pv = w->private_data;
1396     int           i ;
1397
1398     for( i = 0; i < pv->common->pts_count; i++ )
1399     {
1400         if ( pv->common->first_pts[i] == INT64_MAX )
1401             return 0;
1402     }
1403     getPtsOffset( w );
1404     return 1;
1405 }