libhb/reader.c

   1 /* reader.c
   2
   3    Copyright (c) 2003-2015 HandBrake Team
   4    This file is part of the HandBrake source code
   5    Homepage: <http://handbrake.fr/>.
   6    It may be used under the terms of the GNU General Public License v2.
   7    For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
   8  */
   9 #include "hb.h"
  10
  11 static int  hb_reader_init( hb_work_object_t * w, hb_job_t * job );
  12 static void hb_reader_close( hb_work_object_t * w );
  13
  14 hb_work_object_t hb_reader =
  15 {
  16     WORK_READER,
  17     "Reader",
  18     hb_reader_init,
  19     NULL,
  20     hb_reader_close,
  21     NULL,
  22     NULL
  23 };
  24
  25 typedef struct
  26 {
  27     int    startup;
  28     double average; // average time between packets
  29     double filtered_average; // average time between packets
  30     int64_t last;   // last timestamp seen on this stream
  31     int id;         // stream id
  32     int is_audio;   // != 0 if this is an audio stream
  33     int valid;      // Stream timing is not valid until next scr.
  34 } stream_timing_t;
  35
  36 struct hb_work_private_s
  37 {
  38     hb_handle_t  * h;
  39     hb_job_t     * job;
  40     hb_title_t   * title;
  41     volatile int * die;
  42
  43     hb_bd_t      * bd;
  44     hb_dvd_t     * dvd;
  45     hb_stream_t  * stream;
  46
  47     stream_timing_t *stream_timing;
  48     int64_t        scr_offset;
  49     int            sub_scr_set;
  50     hb_psdemux_t   demux;
  51     int            scr_changes;
  52     uint32_t       sequence;
  53     uint8_t        st_slots;        // size (in slots) of stream_timing array
  54     uint8_t        saw_video;       // != 0 if we've seen video
  55     uint8_t        saw_audio;       // != 0 if we've seen audio
  56
  57     int            start_found;     // found pts_to_start point
  58     int64_t        pts_to_start;
  59     uint64_t       st_first;
  60     uint64_t       duration;
  61     hb_fifo_t    * fifos[100];
  62 };
  63
  64 /***********************************************************************
  65  * Local prototypes
  66  **********************************************************************/
  67 static hb_fifo_t ** GetFifoForId( hb_work_private_t * r, int id );
  68 static void UpdateState( hb_work_private_t  * r, int64_t start);
  69
  70 /***********************************************************************
  71  * hb_reader_init
  72  ***********************************************************************
  73  *
  74  **********************************************************************/
  75 static int hb_reader_open( hb_work_private_t * r )
  76 {
  77     if ( r->title->type == HB_BD_TYPE )
  78     {
  79         if ( !( r->bd = hb_bd_init( r->h, r->title->path ) ) )
  80             return 1;
  81     }
  82     else if ( r->title->type == HB_DVD_TYPE )
  83     {
  84         if ( !( r->dvd = hb_dvd_init( r->h, r->title->path ) ) )
  85             return 1;
  86     }
  87     else if ( r->title->type == HB_STREAM_TYPE ||
  88               r->title->type == HB_FF_STREAM_TYPE )
  89     {
  90         if (!(r->stream = hb_stream_open(r->h, r->title->path, r->title, 0)))
  91             return 1;
  92     }
  93     else
  94     {
  95         // Unknown type, should never happen
  96         return 1;
  97     }
  98     return 0;
  99 }
 100
 101 static int hb_reader_init( hb_work_object_t * w, hb_job_t * job )
 102 {
 103     hb_work_private_t * r;
 104
 105     r = calloc( sizeof( hb_work_private_t ), 1 );
 106     w->private_data = r;
 107
 108     r->h     = job->h;
 109     r->job   = job;
 110     r->title = job->title;
 111     r->die   = job->die;
 112     r->sequence = 0;
 113
 114     r->st_slots = 4;
 115     r->stream_timing = calloc( sizeof(stream_timing_t), r->st_slots );
 116     r->stream_timing[0].id = r->title->video_id;
 117     r->stream_timing[0].average = 90000. * (double)job->vrate.den /
 118                                            job->vrate.num;
 119     r->stream_timing[0].filtered_average = r->stream_timing[0].average;
 120     r->stream_timing[0].last = -r->stream_timing[0].average;
 121     r->stream_timing[0].valid = 1;
 122     r->stream_timing[0].startup = 10;
 123     r->stream_timing[1].id = -1;
 124
 125     r->demux.last_scr = AV_NOPTS_VALUE;
 126
 127     if ( !job->pts_to_start )
 128         r->start_found = 1;
 129     else
 130     {
 131         // The frame at the actual start time may not be an i-frame
 132         // so can't be decoded without starting a little early.
 133         // sync.c will drop early frames.
 134         // Starting a little over 10 seconds early
 135         r->pts_to_start = MAX(0, job->pts_to_start - 1000000);
 136     }
 137
 138     if (job->pts_to_stop)
 139     {
 140         r->duration = job->pts_to_start + job->pts_to_stop;
 141     }
 142     else if (job->frame_to_stop)
 143     {
 144         int frames = job->frame_to_start + job->frame_to_stop;
 145         r->duration = (int64_t)frames * job->title->vrate.den * 90000 /
 146                                job->title->vrate.num;
 147     }
 148     else
 149     {
 150         hb_chapter_t *chapter;
 151         int ii;
 152
 153         r->duration = 0;
 154         for (ii = job->chapter_start; ii < job->chapter_end; ii++)
 155         {
 156             chapter = hb_list_item( job->title->list_chapter, ii - 1);
 157             r->duration += chapter->duration;
 158         }
 159     }
 160
 161     // The stream needs to be open before starting the reader thead
 162     // to prevent a race with decoders that may share information
 163     // with the reader. Specifically avcodec needs this.
 164     if ( hb_reader_open( r ) )
 165     {
 166         free( r->stream_timing );
 167         free( r );
 168         return 1;
 169     }
 170     return 0;
 171 }
 172
 173
 174 static void hb_reader_close( hb_work_object_t * w )
 175 {
 176     hb_work_private_t * r = w->private_data;
 177
 178     if (r->bd)
 179     {
 180         hb_bd_stop( r->bd );
 181         hb_bd_close( &r->bd );
 182     }
 183     else if (r->dvd)
 184     {
 185         hb_dvd_stop( r->dvd );
 186         hb_dvd_close( &r->dvd );
 187     }
 188     else if (r->stream)
 189     {
 190         hb_stream_close(&r->stream);
 191     }
 192
 193     if ( r->stream_timing )
 194     {
 195         free( r->stream_timing );
 196     }
 197
 198     free( r );
 199 }
 200
 201 static void push_buf( const hb_work_private_t *r, hb_fifo_t *fifo, hb_buffer_t *buf )
 202 {
 203     while ( !*r->die && !r->job->done )
 204     {
 205         if ( hb_fifo_full_wait( fifo ) )
 206         {
 207             hb_fifo_push( fifo, buf );
 208             buf = NULL;
 209             break;
 210         }
 211     }
 212     if ( buf )
 213     {
 214         hb_buffer_close( &buf );
 215     }
 216 }
 217
 218 static int is_audio( hb_work_private_t *r, int id )
 219 {
 220     int i;
 221     hb_audio_t *audio;
 222
 223     for( i = 0; ( audio = hb_list_item( r->title->list_audio, i ) ); ++i )
 224     {
 225         if ( audio->id == id )
 226         {
 227             return 1;
 228         }
 229     }
 230     return 0;
 231 }
 232
 233 static int is_subtitle( hb_work_private_t *r, int id )
 234 {
 235     int i;
 236     hb_subtitle_t *sub;
 237
 238     for( i = 0; ( sub = hb_list_item( r->title->list_subtitle, i ) ); ++i )
 239     {
 240         if ( sub->id == id )
 241         {
 242             return 1;
 243         }
 244     }
 245     return 0;
 246 }
 247
 248 // The MPEG STD (Standard Target Decoder) essentially requires that we keep
 249 // per-stream timing so that when there's a timing discontinuity we can
 250 // seemlessly join packets on either side of the discontinuity. This join
 251 // requires that we know the timestamp of the previous packet and the
 252 // average inter-packet time (since we position the new packet at the end
 253 // of the previous packet). The next four routines keep track of this
 254 // per-stream timing.
 255
 256 // find or create the per-stream timing state for 'buf'
 257
 258 static stream_timing_t *id_to_st( hb_work_private_t *r, const hb_buffer_t *buf, int valid )
 259 {
 260     stream_timing_t *st = r->stream_timing;
 261     while ( st->id != buf->s.id && st->id != -1)
 262     {
 263         ++st;
 264     }
 265     // if we haven't seen this stream add it.
 266     if ( st->id == -1 )
 267     {
 268         // we keep the steam timing info in an array with some power-of-two
 269         // number of slots. If we don't have two slots left (one for our new
 270         // entry plus one for the "-1" eol) we need to expand the array.
 271         int slot = st - r->stream_timing;
 272         if ( slot + 1 >= r->st_slots )
 273         {
 274             r->st_slots *= 2;
 275             r->stream_timing = realloc( r->stream_timing, r->st_slots *
 276                                         sizeof(*r->stream_timing) );
 277             st = r->stream_timing + slot;
 278         }
 279         st->id = buf->s.id;
 280         st->average = 30.*90.;
 281         st->filtered_average = st->average;
 282         st->startup = 10;
 283         st->last = -st->average;
 284         if ( ( st->is_audio = is_audio( r, buf->s.id ) ) != 0 )
 285         {
 286             r->saw_audio = 1;
 287         }
 288         st[1].id = -1;
 289         st->valid = valid;
 290     }
 291     return st;
 292 }
 293
 294 // update the average inter-packet time of the stream associated with 'buf'
 295 // using a recursive low-pass filter with a 16 packet time constant.
 296
 297 static void update_ipt( hb_work_private_t *r, const hb_buffer_t *buf )
 298 {
 299     stream_timing_t *st = id_to_st( r, buf, 1 );
 300
 301     if (buf->s.renderOffset == AV_NOPTS_VALUE)
 302     {
 303         st->last += st->filtered_average;
 304         return;
 305     }
 306
 307     double dt = buf->s.renderOffset - st->last;
 308
 309     // Protect against spurious bad timestamps
 310     // timestamps should only move forward and by reasonable increments
 311     if ( dt > 0 && dt < 5 * 90000LL )
 312     {
 313         if( st->startup )
 314         {
 315             st->average += ( dt - st->average ) * (1./4.);
 316             st->startup--;
 317         }
 318         else
 319         {
 320             st->average += ( dt - st->average ) * (1./32.);
 321         }
 322         // Ignore outliers
 323         if (dt < 1.5 * st->average)
 324         {
 325             st->filtered_average += ( dt - st->filtered_average ) * (1./32.);
 326         }
 327     }
 328     st->last = buf->s.renderOffset;
 329     st->valid = 1;
 330 }
 331
 332 // use the per-stream state associated with 'buf' to compute a new scr_offset
 333 // such that 'buf' will follow the previous packet of this stream separated
 334 // by the average packet time of the stream.
 335
 336 static void new_scr_offset( hb_work_private_t *r, hb_buffer_t *buf )
 337 {
 338     stream_timing_t *st = id_to_st( r, buf, 1 );
 339     int64_t last;
 340     if ( !st->valid )
 341     {
 342         // !valid means we've not received any previous data
 343         // for this stream.  There is no 'last' packet time.
 344         // So approximate it with video's last time.
 345         last = r->stream_timing[0].last;
 346         st->valid = 1;
 347     }
 348     else
 349     {
 350         last = st->last;
 351     }
 352     int64_t nxt = last + st->filtered_average;
 353     r->scr_offset = buf->s.renderOffset - nxt;
 354     // This log is handy when you need to debug timing problems...
 355     //hb_log("id %x last %"PRId64" avg %g nxt %"PRId64" renderOffset %"PRId64
 356     //       " scr_offset %"PRId64"",
 357     //    buf->s.id, last, st->filtered_average, nxt,
 358     //    buf->s.renderOffset, r->scr_offset);
 359     r->scr_changes = r->demux.scr_changes;
 360 }
 361
 362 /***********************************************************************
 363  * ReaderFunc
 364  ***********************************************************************
 365  *
 366  **********************************************************************/
 367 void ReadLoop( void * _w )
 368 {
 369     hb_work_object_t * w = _w;
 370     hb_work_private_t  * r = w->private_data;
 371     hb_fifo_t   ** fifos;
 372     hb_buffer_t  * buf = NULL;
 373     hb_list_t    * list;
 374     int            n;
 375     int            chapter = -1;
 376     int            chapter_end = r->job->chapter_end;
 377     uint8_t        done = 0;
 378
 379     if (r->bd)
 380     {
 381         if( !hb_bd_start( r->bd, r->title ) )
 382         {
 383             hb_bd_close( &r->bd );
 384             return;
 385         }
 386         if ( r->job->start_at_preview )
 387         {
 388             // XXX code from DecodePreviews - should go into its own routine
 389             hb_bd_seek( r->bd, (float)r->job->start_at_preview /
 390                          ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
 391         }
 392         else if ( r->job->pts_to_start )
 393         {
 394             // Note, bd seeks always put us to an i-frame.  no need
 395             // to start decoding early using r->pts_to_start
 396             hb_bd_seek_pts( r->bd, r->job->pts_to_start );
 397             r->duration -= r->job->pts_to_start;
 398             r->job->pts_to_start = 0;
 399             r->start_found = 1;
 400         }
 401         else
 402         {
 403             hb_bd_seek_chapter( r->bd, r->job->chapter_start );
 404         }
 405         if (r->job->angle > 1)
 406         {
 407             hb_bd_set_angle( r->bd, r->job->angle - 1 );
 408         }
 409     }
 410     else if (r->dvd)
 411     {
 412         /*
 413          * XXX this code is a temporary hack that should go away if/when
 414          *     chapter merging goes away in libhb/dvd.c
 415          * map the start and end chapter numbers to on-media chapter
 416          * numbers since chapter merging could cause the handbrake numbers
 417          * to diverge from the media numbers and, if our chapter_end is after
 418          * a media chapter that got merged, we'll stop ripping too early.
 419          */
 420         int start = r->job->chapter_start;
 421         hb_chapter_t *chap = hb_list_item( r->job->list_chapter, chapter_end - 1 );
 422
 423         chapter_end = chap->index;
 424         if (start > 1)
 425         {
 426            chap = hb_list_item( r->job->list_chapter, start - 1 );
 427            start = chap->index;
 428         }
 429         /* end chapter mapping XXX */
 430
 431         if( !hb_dvd_start( r->dvd, r->title, start ) )
 432         {
 433             hb_dvd_close( &r->dvd );
 434             return;
 435         }
 436         if (r->job->angle)
 437         {
 438             hb_dvd_set_angle( r->dvd, r->job->angle );
 439         }
 440
 441         if ( r->job->start_at_preview )
 442         {
 443             // XXX code from DecodePreviews - should go into its own routine
 444             hb_dvd_seek( r->dvd, (float)r->job->start_at_preview /
 445                          ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
 446         }
 447     }
 448     else if ( r->stream && r->job->start_at_preview )
 449     {
 450
 451         // XXX code from DecodePreviews - should go into its own routine
 452         hb_stream_seek( r->stream, (float)( r->job->start_at_preview - 1 ) /
 453                         ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
 454
 455     }
 456     else if ( r->stream && r->job->pts_to_start )
 457     {
 458         if ( hb_stream_seek_ts( r->stream, r->job->pts_to_start ) >= 0 )
 459         {
 460             // Seek takes us to the nearest I-frame before the timestamp
 461             // that we want.  So we will retrieve the start time of the
 462             // first packet we get, subtract that from pts_to_start, and
 463             // inspect the reset of the frames in sync.
 464             r->start_found = 2;
 465             r->duration -= r->job->pts_to_start;
 466         }
 467         // hb_stream_seek_ts does nothing for TS streams and will return
 468         // an error.
 469     }
 470     else if( r->stream )
 471     {
 472         /*
 473          * Standard stream, seek to the starting chapter, if set, and track the
 474          * end chapter so that we end at the right time.
 475          */
 476         int start = r->job->chapter_start;
 477         hb_chapter_t *chap = hb_list_item( r->job->list_chapter, chapter_end - 1 );
 478
 479         chapter_end = chap->index;
 480         if (start > 1)
 481         {
 482             chap = hb_list_item( r->job->list_chapter, start - 1 );
 483             start = chap->index;
 484         }
 485
 486         /*
 487          * Seek to the start chapter.
 488          */
 489         hb_stream_seek_chapter( r->stream, start );
 490     }
 491
 492     list  = hb_list_init();
 493
 494     while(!*r->die && !r->job->done && !done)
 495     {
 496         if (r->bd)
 497             chapter = hb_bd_chapter( r->bd );
 498         else if (r->dvd)
 499             chapter = hb_dvd_chapter( r->dvd );
 500         else if (r->stream)
 501             chapter = hb_stream_chapter( r->stream );
 502
 503         if( chapter < 0 )
 504         {
 505             hb_log( "reader: end of the title reached" );
 506             break;
 507         }
 508         if( chapter > chapter_end )
 509         {
 510             hb_log( "reader: end of chapter %d (media %d) reached at media chapter %d",
 511                     r->job->chapter_end, chapter_end, chapter );
 512             break;
 513         }
 514
 515         if (buf == NULL)
 516         {
 517             if (r->bd)
 518             {
 519                 if( (buf = hb_bd_read( r->bd )) == NULL )
 520                 {
 521                     break;
 522                 }
 523             }
 524             else if (r->dvd)
 525             {
 526                 if( (buf = hb_dvd_read( r->dvd )) == NULL )
 527                 {
 528                     break;
 529                 }
 530             }
 531             else if (r->stream)
 532             {
 533                 if ( (buf = hb_stream_read( r->stream )) == NULL )
 534                 {
 535                   break;
 536                 }
 537             }
 538         }
 539
 540         (hb_demux[r->title->demuxer])( buf, list, &r->demux );
 541
 542         while( ( buf = hb_list_item( list, 0 ) ) )
 543         {
 544             hb_list_rem( list, buf );
 545             fifos = GetFifoForId( r, buf->s.id );
 546
 547             if (fifos && r->stream && r->start_found == 2 )
 548             {
 549                 // We will inspect the timestamps of each frame in sync
 550                 // to skip from this seek point to the timestamp we
 551                 // want to start at.
 552                 if (buf->s.start != AV_NOPTS_VALUE &&
 553                     buf->s.start < r->job->pts_to_start)
 554                 {
 555                     r->job->pts_to_start -= buf->s.start;
 556                 }
 557                 else if ( buf->s.start >= r->job->pts_to_start )
 558                 {
 559                     r->job->pts_to_start = 0;
 560                 }
 561                 r->start_found = 1;
 562             }
 563
 564             if ( fifos && ! r->saw_video && !r->job->indepth_scan )
 565             {
 566                 // The first data packet with a PTS from an audio or video stream
 567                 // that we're decoding defines 'time zero'. Discard packets until
 568                 // we get one.
 569                 if (buf->s.start != AV_NOPTS_VALUE &&
 570                     buf->s.renderOffset != AV_NOPTS_VALUE &&
 571                      (buf->s.id == r->title->video_id ||
 572                       is_audio( r, buf->s.id)))
 573                 {
 574                     // force a new scr offset computation
 575                     r->scr_changes = r->demux.scr_changes - 1;
 576                     // create a stream state if we don't have one so the
 577                     // offset will get computed correctly.
 578                     id_to_st( r, buf, 1 );
 579                     r->saw_video = 1;
 580                     hb_log( "reader: first SCR %"PRId64" id 0x%x DTS %"PRId64,
 581                             r->demux.last_scr, buf->s.id, buf->s.renderOffset );
 582                 }
 583                 else
 584                 {
 585                     fifos = NULL;
 586                 }
 587             }
 588
 589             if ( r->job->indepth_scan || fifos )
 590             {
 591                 if ( buf->s.renderOffset != AV_NOPTS_VALUE )
 592                 {
 593                     if ( r->scr_changes != r->demux.scr_changes )
 594                     {
 595                         // This is the first audio or video packet after an SCR
 596                         // change. Compute a new scr offset that would make this
 597                         // packet follow the last of this stream with the
 598                         // correct average spacing.
 599                         stream_timing_t *st = id_to_st( r, buf, 0 );
 600
 601                         // if this is the video stream and we don't have
 602                         // audio yet or this is an audio stream
 603                         // generate a new scr
 604                         if ( st->is_audio ||
 605                              ( st == r->stream_timing && !r->saw_audio ) )
 606                         {
 607                             new_scr_offset( r, buf );
 608                             r->sub_scr_set = 0;
 609                         }
 610                         else
 611                         {
 612                             // defer the scr change until we get some
 613                             // audio since audio has a timestamp per
 614                             // frame but video & subtitles don't. Clear
 615                             // the timestamps so the decoder will generate
 616                             // them from the frame durations.
 617                             if (is_subtitle(r, buf->s.id) &&
 618                                 buf->s.start != AV_NOPTS_VALUE)
 619                             {
 620                                 if (!r->sub_scr_set)
 621                                 {
 622                                     // We can't generate timestamps in the
 623                                     // subtitle decoder as we can for
 624                                     // audio & video.  So we need to make
 625                                     // the closest guess that we can
 626                                     // for the subtitles start time here.
 627                                     int64_t last = r->stream_timing[0].last;
 628                                     r->scr_offset = buf->s.start - last;
 629                                     r->sub_scr_set = 1;
 630                                 }
 631                             }
 632                             else
 633                             {
 634                                 buf->s.start = AV_NOPTS_VALUE;
 635                                 buf->s.renderOffset = AV_NOPTS_VALUE;
 636                             }
 637                         }
 638                     }
 639                 }
 640                 if ( buf->s.start != AV_NOPTS_VALUE )
 641                 {
 642                     int64_t start = buf->s.start - r->scr_offset;
 643
 644                     if (!r->start_found || r->job->indepth_scan)
 645                     {
 646                         UpdateState( r, start );
 647                     }
 648
 649                     if (r->job->indepth_scan && r->job->pts_to_stop &&
 650                         start >= r->pts_to_start + r->job->pts_to_stop)
 651                     {
 652                         // sync normally would terminate p-to-p
 653                         // but sync doesn't run during indepth scan
 654                         hb_log( "reader: reached pts %"PRId64", exiting early", start );
 655                         done = 1;
 656                         break;
 657                     }
 658
 659                     if (!r->start_found && start >= r->pts_to_start)
 660                     {
 661                         // pts_to_start point found
 662                         r->start_found = 1;
 663                         if (r->stream)
 664                         {
 665                             // libav multi-threaded decoders can get into
 666                             // a bad state if the initial data is not
 667                             // decodable.  So try to improve the chances of
 668                             // a good start by waiting for an initial iframe
 669                             hb_stream_set_need_keyframe(r->stream, 1);
 670                             hb_buffer_close( &buf );
 671                             continue;
 672                         }
 673                     }
 674                     // This log is handy when you need to debug timing problems
 675                     //hb_log("id %x scr_offset %"PRId64
 676                     //       " start %"PRId64" --> %"PRId64"",
 677                     //        buf->s.id, r->scr_offset, buf->s.start,
 678                     //        buf->s.start - r->scr_offset);
 679                     buf->s.start -= r->scr_offset;
 680                     if ( buf->s.stop != AV_NOPTS_VALUE )
 681                     {
 682                         buf->s.stop -= r->scr_offset;
 683                     }
 684                 }
 685                 if ( buf->s.renderOffset != AV_NOPTS_VALUE )
 686                 {
 687                     // This packet is referenced to the same SCR as the last.
 688                     // Adjust timestamp to remove the System Clock Reference
 689                     // offset then update the average inter-packet time
 690                     // for this stream.
 691                     buf->s.renderOffset -= r->scr_offset;
 692                     update_ipt( r, buf );
 693                 }
 694 #if 0
 695                 // JAS: This was added to fix a rare "audio time went backward"
 696                 // sync error I found in one sample.  But it has a bad side
 697                 // effect on DVDs, causing frequent "adding silence" sync
 698                 // errors. So I am disabling it.
 699                 else
 700                 {
 701                     update_ipt( r, buf );
 702                 }
 703 #endif
 704             }
 705             if( fifos )
 706             {
 707                 if ( !r->start_found )
 708                 {
 709                     hb_buffer_close( &buf );
 710                     continue;
 711                 }
 712
 713                 buf->sequence = r->sequence++;
 714                 /* if there are mutiple output fifos, send a copy of the
 715                  * buffer down all but the first (we have to not ship the
 716                  * original buffer or we'll race with the thread that's
 717                  * consuming the buffer & inject garbage into the data stream). */
 718                 for( n = 1; fifos[n] != NULL; n++)
 719                 {
 720                     hb_buffer_t *buf_copy = hb_buffer_init( buf->size );
 721                     buf_copy->s = buf->s;
 722                     memcpy( buf_copy->data, buf->data, buf->size );
 723                     push_buf( r, fifos[n], buf_copy );
 724                 }
 725                 push_buf( r, fifos[0], buf );
 726                 buf = NULL;
 727             }
 728             else
 729             {
 730                 hb_buffer_close( &buf );
 731             }
 732         }
 733     }
 734
 735     // send empty buffers downstream to video & audio decoders to signal we're done.
 736     if( !*r->die && !r->job->done )
 737     {
 738         push_buf(r, r->job->fifo_mpeg2, hb_buffer_eof_init());
 739
 740         hb_audio_t *audio;
 741         for( n = 0; (audio = hb_list_item( r->job->list_audio, n)); ++n )
 742         {
 743             if ( audio->priv.fifo_in )
 744                 push_buf(r, audio->priv.fifo_in, hb_buffer_eof_init());
 745         }
 746
 747         hb_subtitle_t *subtitle;
 748         for( n = 0; (subtitle = hb_list_item( r->job->list_subtitle, n)); ++n )
 749         {
 750             if ( subtitle->fifo_in && subtitle->source == VOBSUB)
 751                 push_buf(r, subtitle->fifo_in, hb_buffer_eof_init());
 752         }
 753     }
 754
 755     hb_list_empty( &list );
 756
 757     hb_log( "reader: done. %d scr changes", r->demux.scr_changes );
 758 }
 759
 760 static void UpdateState( hb_work_private_t  * r, int64_t start)
 761 {
 762     hb_state_t state;
 763     uint64_t now;
 764     double avg;
 765
 766     now = hb_get_date();
 767     if( !r->st_first )
 768     {
 769         r->st_first = now;
 770     }
 771
 772     hb_get_state2(r->job->h, &state);
 773 #define p state.param.working
 774     if ( !r->job->indepth_scan )
 775     {
 776         state.state = HB_STATE_SEARCHING;
 777         p.progress  = (float) start / (float) r->job->pts_to_start;
 778     }
 779     else
 780     {
 781         state.state = HB_STATE_WORKING;
 782         p.progress  = (float) start / (float) r->duration;
 783     }
 784     if( p.progress > 1.0 )
 785     {
 786         p.progress = 1.0;
 787     }
 788     p.rate_cur = 0.0;
 789     p.rate_avg = 0.0;
 790     if (now > r->st_first)
 791     {
 792         int eta;
 793
 794         avg = 1000.0 * (double)start / (now - r->st_first);
 795         if ( !r->job->indepth_scan )
 796             eta = ( r->job->pts_to_start - start ) / avg;
 797         else
 798             eta = ( r->duration - start ) / avg;
 799         p.hours   = eta / 3600;
 800         p.minutes = ( eta % 3600 ) / 60;
 801         p.seconds = eta % 60;
 802     }
 803     else
 804     {
 805         p.hours    = -1;
 806         p.minutes  = -1;
 807         p.seconds  = -1;
 808     }
 809 #undef p
 810
 811     hb_set_state( r->job->h, &state );
 812 }
 813 /***********************************************************************
 814  * GetFifoForId
 815  ***********************************************************************
 816  *
 817  **********************************************************************/
 818 static hb_fifo_t ** GetFifoForId( hb_work_private_t * r, int id )
 819 {
 820     hb_job_t      * job = r->job;
 821     hb_title_t    * title = job->title;
 822     hb_audio_t    * audio;
 823     hb_subtitle_t * subtitle;
 824     int             i, n, count;
 825
 826     memset(r->fifos, 0, sizeof(r->fifos));
 827
 828     if( id == title->video_id )
 829     {
 830         if (job->indepth_scan && !job->frame_to_stop)
 831         {
 832             /*
 833              * Ditch the video here during the indepth scan until
 834              * we can improve the MPEG2 decode performance.
 835              *
 836              * But if we specify a stop frame, we must decode the
 837              * frames in order to count them.
 838              */
 839             return NULL;
 840         }
 841         else
 842         {
 843             r->fifos[0] = job->fifo_mpeg2;
 844             return r->fifos;
 845         }
 846     }
 847
 848     count = hb_list_count( job->list_subtitle );
 849     count = count > 99 ? 99 : count;
 850     for( i = n = 0; i < count; i++ )
 851     {
 852         subtitle =  hb_list_item( job->list_subtitle, i );
 853         if (id == subtitle->id)
 854         {
 855             /* pass the subtitles to be processed */
 856             r->fifos[n++] = subtitle->fifo_in;
 857         }
 858     }
 859     if ( n != 0 )
 860     {
 861         return r->fifos;
 862     }
 863
 864     if( !job->indepth_scan )
 865     {
 866         for( i = n = 0; i < hb_list_count( job->list_audio ); i++ )
 867         {
 868             audio = hb_list_item( job->list_audio, i );
 869             if( id == audio->id )
 870             {
 871                 r->fifos[n++] = audio->priv.fifo_in;
 872             }
 873         }
 874
 875         if( n != 0 )
 876         {
 877             return r->fifos;
 878         }
 879     }
 880
 881     return NULL;
 882 }
 883