static hb_buffer_t * splice_discontinuity( hb_work_private_t *r, hb_buffer_t *buf ) { // Handle buffers that were split across a PCR discontinuity. // Rejoin them into a single buffer. hb_buffer_list_t * list = get_splice_list(r, buf->s.id); if (list != NULL) { hb_buffer_list_append(list, buf); if (buf->s.split) { return NULL; } int count = hb_buffer_list_count(list); if (count > 1) { int size = hb_buffer_list_size(list); hb_buffer_t * b = hb_buffer_init(size); buf = hb_buffer_list_head(list); b->s = buf->s; int pos = 0; while ((buf = hb_buffer_list_rem_head(list)) != NULL) { memcpy(b->data + pos, buf->data, buf->size); pos += buf->size; hb_buffer_close(&buf); } buf = b; } else { buf = hb_buffer_list_clear(list); } } return buf; }
/*********************************************************************** * DecodePreviews *********************************************************************** * Decode 10 pictures for the given title. * It assumes that data->reader and data->vts have successfully been * DVDOpen()ed and ifoOpen()ed. **********************************************************************/ static int DecodePreviews( hb_scan_t * data, hb_title_t * title, int flush ) { int i, npreviews = 0, abort = 0; hb_buffer_t * buf, * buf_es; hb_buffer_list_t list_es; int progressive_count = 0; int pulldown_count = 0; int doubled_frame_count = 0; int interlaced_preview_count = 0; int vid_samples = 0; int frame_wait = 0; int cc_wait = 10; int frames; hb_stream_t * stream = NULL; info_list_t * info_list; int abort_audio = 0; info_list = calloc(data->preview_count+1, sizeof(*info_list)); crop_record_t *crops = crop_record_init( data->preview_count ); hb_buffer_list_clear(&list_es); if( data->batch ) { hb_log( "scan: decoding previews for title %d (%s)", title->index, title->path ); } else { hb_log( "scan: decoding previews for title %d", title->index ); } if (data->bd) { hb_bd_start( data->bd, title ); hb_log( "scan: title angle(s) %d", title->angle_count ); } else if (data->dvd) { hb_dvd_start( data->dvd, title, 1 ); title->angle_count = hb_dvd_angle_count( data->dvd ); hb_log( "scan: title angle(s) %d", title->angle_count ); } else if (data->batch) { stream = hb_stream_open(data->h, title->path, title, 0); } else if (data->stream) { stream = hb_stream_open(data->h, data->path, title, 0); } if (title->video_codec == WORK_NONE) { hb_error("No video decoder set!"); free(info_list); crop_record_free(crops); hb_stream_close(&stream); return 0; } hb_work_object_t *vid_decoder = hb_get_work(data->h, title->video_codec); vid_decoder->codec_param = title->video_codec_param; vid_decoder->title = title; if (vid_decoder->init(vid_decoder, NULL)) { hb_error("Decoder init failed!"); free(info_list); crop_record_free(crops); free( vid_decoder ); hb_stream_close(&stream); return 0; } for( i = 0; i < data->preview_count; i++ ) { int j; UpdateState3(data, i + 1); if ( *data->die ) { free( info_list ); crop_record_free( crops ); vid_decoder->close( vid_decoder ); free( vid_decoder ); hb_stream_close(&stream); return 0; } if (data->bd) { if( !hb_bd_seek( data->bd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) { continue; } } if (data->dvd) { if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) { continue; } } else if (stream) { /* we start reading streams at zero rather than 1/11 because * short streams may have only one sequence header in the entire * file and we need it to decode any previews. * * Also, seeking to position 0 loses the palette of avi files * so skip initial seek */ if (i != 0) { if (!hb_stream_seek(stream, (float)i / (data->preview_count + 1.0))) { continue; } } else { hb_stream_set_need_keyframe(stream, 1); } } hb_deep_log( 2, "scan: preview %d", i + 1 ); if (flush && vid_decoder->flush) vid_decoder->flush( vid_decoder ); if (title->flags & HBTF_NO_IDR) { if (!flush) { // If we are doing the first previews decode attempt, // set this threshold high so that we get the best // quality frames possible. frame_wait = 100; } else { // If we failed to get enough valid frames in the first // previews decode attempt, lower the threshold to improve // our chances of getting something to work with. frame_wait = 10; } } else { // For certain mpeg-2 streams, libav is delivering a // dummy first frame that is all black. So always skip // one frame frame_wait = 1; } frames = 0; hb_buffer_t * vid_buf = NULL, * last_vid_buf = NULL; int packets = 0; vid_decoder->frame_count = 0; while (vid_decoder->frame_count < PREVIEW_READ_THRESH || (!AllAudioOK(title) && packets < 10000)) { if ((buf = read_buf(data, stream)) == NULL) { // If we reach EOF and no audio, don't continue looking for // audio abort_audio = 1; if (vid_buf != NULL || last_vid_buf != NULL) { break; } hb_log("Warning: Could not read data for preview %d, skipped", i + 1 ); // If we reach EOF and no video, don't continue looking for // video abort = 1; goto skip_preview; } packets++; if (buf->size <= 0) { // Ignore "null" frames hb_buffer_close(&buf); continue; } (hb_demux[title->demuxer])(buf, &list_es, 0 ); while ((buf_es = hb_buffer_list_rem_head(&list_es)) != NULL) { if( buf_es->s.id == title->video_id && vid_buf == NULL ) { vid_decoder->work( vid_decoder, &buf_es, &vid_buf ); // There are 2 conditions we decode additional // video frames for during scan. // 1. We did not detect IDR frames, so the initial video // frames may be corrupt. We docode extra frames to // increase the probability of a complete preview frame // 2. Some frames do not contain CC data, even though // CCs are present in the stream. So we need to decode // additional frames to find the CCs. if (vid_buf != NULL && (frame_wait || cc_wait)) { hb_work_info_t vid_info; if (vid_decoder->info(vid_decoder, &vid_info)) { if (is_close_to(vid_info.rate.den, 900900, 100) && (vid_buf->s.flags & PIC_FLAG_REPEAT_FIRST_FIELD)) { /* Potentially soft telecine material */ pulldown_count++; } if (vid_buf->s.flags & PIC_FLAG_REPEAT_FRAME) { // AVCHD-Lite specifies that all streams are // 50 or 60 fps. To produce 25 or 30 fps, camera // makers are repeating all frames. doubled_frame_count++; } if (is_close_to(vid_info.rate.den, 1126125, 100 )) { // Frame FPS is 23.976 (meaning it's // progressive), so start keeping track of // how many are reporting at that speed. When // enough show up that way, we want to make // that the overall title FPS. progressive_count++; } vid_samples++; } if (frames > 0 && vid_buf->s.frametype == HB_FRAME_I) frame_wait = 0; if (frame_wait || cc_wait) { hb_buffer_close(&last_vid_buf); last_vid_buf = vid_buf; vid_buf = NULL; if (frame_wait) frame_wait--; if (cc_wait) cc_wait--; } frames++; } } else if (!AllAudioOK(title) && !abort_audio) { LookForAudio( data, title, buf_es ); buf_es = NULL; } if ( buf_es ) hb_buffer_close( &buf_es ); } if (vid_buf && (abort_audio || AllAudioOK(title))) break; } hb_buffer_list_close(&list_es); if (vid_buf == NULL) { vid_buf = last_vid_buf; last_vid_buf = NULL; } hb_buffer_close(&last_vid_buf); if (vid_buf == NULL) { hb_log( "scan: could not get a decoded picture" ); continue; } /* Get size and rate infos */ hb_work_info_t vid_info; if( !vid_decoder->info( vid_decoder, &vid_info ) ) { /* * Could not fill vid_info, don't continue and try to use vid_info * in this case. */ hb_log( "scan: could not get a video information" ); hb_buffer_close( &vid_buf ); continue; } if (vid_info.geometry.width != vid_buf->f.width || vid_info.geometry.height != vid_buf->f.height) { hb_log( "scan: video geometry information does not match buffer" ); hb_buffer_close( &vid_buf ); continue; } remember_info( info_list, &vid_info ); /* Check preview for interlacing artifacts */ if( hb_detect_comb( vid_buf, 10, 30, 9, 10, 30, 9 ) ) { hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1); interlaced_preview_count++; } if( data->store_previews ) { hb_save_preview( data->h, title->index, i, vid_buf ); } /* Detect black borders */ int top, bottom, left, right; int h4 = vid_info.geometry.height / 4, w4 = vid_info.geometry.width / 4; // When widescreen content is matted to 16:9 or 4:3 there's sometimes // a thin border on the outer edge of the matte. On TV content it can be // "line 21" VBI data that's normally hidden in the overscan. For HD // content it can just be a diagnostic added in post production so that // the frame borders are visible. We try to ignore these borders so // we can crop the matte. The border width depends on the resolution // (12 pixels on 1080i looks visually the same as 4 pixels on 480i) // so we allow the border to be up to 1% of the frame height. const int border = vid_info.geometry.height / 100; for ( top = border; top < h4; ++top ) { if ( ! row_all_dark( vid_buf, top ) ) break; } if ( top <= border ) { // we never made it past the border region - see if the rows we // didn't check are dark or if we shouldn't crop at all. for ( top = 0; top < border; ++top ) { if ( ! row_all_dark( vid_buf, top ) ) break; } if ( top >= border ) { top = 0; } } for ( bottom = border; bottom < h4; ++bottom ) { if ( ! row_all_dark( vid_buf, vid_info.geometry.height - 1 - bottom ) ) break; } if ( bottom <= border ) { for ( bottom = 0; bottom < border; ++bottom ) { if ( ! row_all_dark( vid_buf, vid_info.geometry.height - 1 - bottom ) ) break; } if ( bottom >= border ) { bottom = 0; } } for ( left = 0; left < w4; ++left ) { if ( ! column_all_dark( vid_buf, top, bottom, left ) ) break; } for ( right = 0; right < w4; ++right ) { if ( ! column_all_dark( vid_buf, top, bottom, vid_info.geometry.width - 1 - right ) ) break; } // only record the result if all the crops are less than a quarter of // the frame otherwise we can get fooled by frames with a lot of black // like titles, credits & fade-thru-black transitions. if ( top < h4 && bottom < h4 && left < w4 && right < w4 ) { record_crop( crops, top, bottom, left, right ); } ++npreviews; skip_preview: /* Make sure we found audio rates and bitrates */ for( j = 0; j < hb_list_count( title->list_audio ); j++ ) { hb_audio_t * audio = hb_list_item( title->list_audio, j ); if ( audio->priv.scan_cache ) { hb_fifo_flush( audio->priv.scan_cache ); } } if (vid_buf) { hb_buffer_close( &vid_buf ); } if (abort) { break; } } UpdateState3(data, i); vid_decoder->close( vid_decoder ); free( vid_decoder ); if (stream != NULL) { hb_stream_close(&stream); } if ( npreviews ) { // use the most common frame info for our final title dimensions hb_work_info_t vid_info; most_common_info( info_list, &vid_info ); title->has_resolution_change = has_resolution_change( info_list ); if ( title->video_codec_name == NULL ) { title->video_codec_name = strdup( vid_info.name ); } title->geometry.width = vid_info.geometry.width; title->geometry.height = vid_info.geometry.height; if (vid_info.rate.num && vid_info.rate.den) { // if the frame rate is very close to one of our "common" // framerates, assume it actually is said frame rate; // e.g. some 24000/1001 sources may have a rate.den of 1126124 // instead of 1126125 const hb_rate_t *video_framerate = NULL; while ((video_framerate = hb_video_framerate_get_next(video_framerate)) != NULL) { if (is_close_to(vid_info.rate.den, video_framerate->rate, 100)) { vid_info.rate.den = video_framerate->rate; break; } } title->vrate = vid_info.rate; if( vid_info.rate.den == 900900 ) { if (vid_samples >= 4 && pulldown_count >= vid_samples / 4) { title->vrate.den = 1126125; hb_deep_log( 2, "Pulldown detected, setting fps to 23.976" ); } if (vid_samples >= 2 && progressive_count >= vid_samples / 2) { // We've already deduced that the frame rate is 23.976, // so set it back again. title->vrate.den = 1126125; hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976" ); } } if (vid_samples >= 2 && doubled_frame_count >= 3 * vid_samples / 4) { // We've detected that a significant number of the frames // have been doubled in duration by repeat flags. title->vrate.den = 2 * vid_info.rate.den; hb_deep_log(2, "Repeat frames detected, setting fps to %.3f", (float)title->vrate.num / title->vrate.den ); } } title->video_bitrate = vid_info.bitrate; if( vid_info.geometry.par.num && vid_info.geometry.par.den ) { title->geometry.par = vid_info.geometry.par; } title->color_prim = vid_info.color_prim; title->color_transfer = vid_info.color_transfer; title->color_matrix = vid_info.color_matrix; title->video_decode_support = vid_info.video_decode_support; // compute the aspect ratio based on the storage dimensions and PAR. hb_reduce(&title->dar.num, &title->dar.den, title->geometry.par.num * title->geometry.width, title->geometry.height * title->geometry.par.den); // For unknown reasons some French PAL DVDs put the original // content's aspect ratio into the mpeg PAR even though it's // the wrong PAR for the DVD. Apparently they rely on the fact // that DVD players ignore the content PAR and just use the // aspect ratio from the DVD metadata. So, if the aspect computed // from the PAR is different from the container's aspect we use // the container's aspect & recompute the PAR from it. if (data->dvd && (title->dar.num != title->container_dar.num || title->dar.den != title->container_dar.den)) { hb_log("scan: content PAR gives wrong aspect %d:%d; " "using container aspect %d:%d", title->dar.num, title->dar.den, title->container_dar.num, title->container_dar.den); title->dar = title->container_dar; hb_reduce(&title->geometry.par.num, &title->geometry.par.den, title->geometry.height * title->dar.num, title->geometry.width * title->dar.den); } // don't try to crop unless we got at least 3 previews if ( crops->n > 2 ) { sort_crops( crops ); // The next line selects median cropping - at least // 50% of the frames will have their borders removed. // Other possible choices are loose cropping (i = 0) where // no non-black pixels will be cropped from any frame and a // tight cropping (i = crops->n - (crops->n >> 2)) where at // least 75% of the frames will have their borders removed. i = crops->n >> 1; title->crop[0] = EVEN( crops->t[i] ); title->crop[1] = EVEN( crops->b[i] ); title->crop[2] = EVEN( crops->l[i] ); title->crop[3] = EVEN( crops->r[i] ); } hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, " "aspect %s, PAR %d:%d", npreviews, title->geometry.width, title->geometry.height, (float)title->vrate.num / title->vrate.den, title->crop[0], title->crop[1], title->crop[2], title->crop[3], aspect_to_string(&title->dar), title->geometry.par.num, title->geometry.par.den); if (title->video_decode_support != HB_DECODE_SUPPORT_SW) { hb_log("scan: supported video decoders:%s%s", !(title->video_decode_support & HB_DECODE_SUPPORT_SW) ? "" : " avcodec", !(title->video_decode_support & HB_DECODE_SUPPORT_QSV) ? "" : " qsv"); } if( interlaced_preview_count >= ( npreviews / 2 ) ) { hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.", interlaced_preview_count, npreviews); title->detected_interlacing = 1; } else { title->detected_interlacing = 0; } }
static int reader_work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t ** buf_out) { hb_work_private_t * r = w->private_data; hb_fifo_t ** fifos; hb_buffer_t * buf; hb_buffer_list_t list; int ii, chapter = -1; hb_buffer_list_clear(&list); if (r->bd) chapter = hb_bd_chapter( r->bd ); else if (r->dvd) chapter = hb_dvd_chapter( r->dvd ); else if (r->stream) chapter = hb_stream_chapter( r->stream ); if( chapter < 0 ) { hb_log( "reader: end of the title reached" ); reader_send_eof(r); return HB_WORK_DONE; } if( chapter > r->chapter_end ) { hb_log("reader: end of chapter %d (media %d) reached at media chapter %d", r->job->chapter_end, r->chapter_end, chapter); reader_send_eof(r); return HB_WORK_DONE; } if (r->bd) { if( (buf = hb_bd_read( r->bd )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } else if (r->dvd) { if( (buf = hb_dvd_read( r->dvd )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } else if (r->stream) { if ( (buf = hb_stream_read( r->stream )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } (hb_demux[r->title->demuxer])(buf, &list, &r->demux); while ((buf = hb_buffer_list_rem_head(&list)) != NULL) { fifos = GetFifoForId( r, buf->s.id ); if (fifos && r->stream && r->start_found == 2 ) { // We will inspect the timestamps of each frame in sync // to skip from this seek point to the timestamp we // want to start at. if (buf->s.start != AV_NOPTS_VALUE && buf->s.start < r->job->pts_to_start) { r->job->pts_to_start -= buf->s.start; } else if ( buf->s.start >= r->job->pts_to_start ) { r->job->pts_to_start = 0; } r->start_found = 1; } if ( fifos && ! r->saw_video && !r->job->indepth_scan ) { // The first data packet with a PTS from an audio or video stream // that we're decoding defines 'time zero'. Discard packets until // we get one. if (buf->s.start != AV_NOPTS_VALUE && buf->s.renderOffset != AV_NOPTS_VALUE && (buf->s.id == r->title->video_id || is_audio( r, buf->s.id))) { // force a new scr offset computation r->scr_changes = r->demux.scr_changes - 1; // create a stream state if we don't have one so the // offset will get computed correctly. id_to_st( r, buf, 1 ); r->saw_video = 1; hb_log( "reader: first SCR %"PRId64" id 0x%x DTS %"PRId64, r->demux.last_scr, buf->s.id, buf->s.renderOffset ); } else { fifos = NULL; } } if ( r->job->indepth_scan || fifos ) { if ( buf->s.renderOffset != AV_NOPTS_VALUE ) { if ( r->scr_changes != r->demux.scr_changes ) { // This is the first audio or video packet after an SCR // change. Compute a new scr offset that would make this // packet follow the last of this stream with the // correct average spacing. stream_timing_t *st = id_to_st( r, buf, 0 ); // if this is the video stream and we don't have // audio yet or this is an audio stream // generate a new scr if ( st->is_audio || ( st == r->stream_timing && !r->saw_audio ) ) { new_scr_offset( r, buf ); r->sub_scr_set = 0; } else { // defer the scr change until we get some // audio since audio has a timestamp per // frame but video & subtitles don't. Clear // the timestamps so the decoder will generate // them from the frame durations. if (is_subtitle(r, buf->s.id) && buf->s.start != AV_NOPTS_VALUE) { if (!r->sub_scr_set) { // We can't generate timestamps in the // subtitle decoder as we can for // audio & video. So we need to make // the closest guess that we can // for the subtitles start time here. int64_t last = r->stream_timing[0].last; r->scr_offset = buf->s.start - last; r->sub_scr_set = 1; } } else { buf->s.start = AV_NOPTS_VALUE; buf->s.renderOffset = AV_NOPTS_VALUE; } } } } if ( buf->s.start != AV_NOPTS_VALUE ) { int64_t start = buf->s.start - r->scr_offset; if (!r->start_found || r->job->indepth_scan) { UpdateState( r, start ); } if (r->job->indepth_scan && r->job->pts_to_stop && start >= r->pts_to_start + r->job->pts_to_stop) { // sync normally would terminate p-to-p // but sync doesn't run during indepth scan hb_log("reader: reached pts %"PRId64", exiting early", start); reader_send_eof(r); hb_buffer_list_close(&list); return HB_WORK_DONE; } if (!r->start_found && start >= r->pts_to_start) { // pts_to_start point found // Note that this code path only gets executed for // medai where we have not performed an initial seek // to get close to the start time. So the 'start' time // is the time since the first frame. if (r->stream) { // libav multi-threaded decoders can get into // a bad state if the initial data is not // decodable. So try to improve the chances of // a good start by waiting for an initial iframe hb_stream_set_need_keyframe(r->stream, 1); hb_buffer_close( &buf ); continue; } r->start_found = 1; // sync.c also pays attention to job->pts_to_start // It eats up the 10 second slack that we build in // to the start time here in reader (so that video // decode is clean at the start time). // sync.c expects pts_to_start to be relative to the // first timestamp it sees. if (r->job->pts_to_start > start) { r->job->pts_to_start -= start; } else { r->job->pts_to_start = 0; } } // This log is handy when you need to debug timing problems //hb_log("id %x scr_offset %"PRId64 // " start %"PRId64" --> %"PRId64"", // buf->s.id, r->scr_offset, buf->s.start, // buf->s.start - r->scr_offset); buf->s.start -= r->scr_offset; if ( buf->s.stop != AV_NOPTS_VALUE ) { buf->s.stop -= r->scr_offset; } } if ( buf->s.renderOffset != AV_NOPTS_VALUE ) { // This packet is referenced to the same SCR as the last. // Adjust timestamp to remove the System Clock Reference // offset then update the average inter-packet time // for this stream. buf->s.renderOffset -= r->scr_offset; update_ipt( r, buf ); } #if 0 // JAS: This was added to fix a rare "audio time went backward" // sync error I found in one sample. But it has a bad side // effect on DVDs, causing frequent "adding silence" sync // errors. So I am disabling it. else { update_ipt( r, buf ); } #endif } buf = splice_discontinuity(r, buf); if( fifos && buf != NULL ) { if ( !r->start_found ) { hb_buffer_close( &buf ); continue; } buf->sequence = r->sequence++; /* if there are mutiple output fifos, send a copy of the * buffer down all but the first (we have to not ship the * original buffer or we'll race with the thread that's * consuming the buffer & inject garbage into the data stream). */ for (ii = 1; fifos[ii] != NULL; ii++) { hb_buffer_t *buf_copy = hb_buffer_init(buf->size); buf_copy->s = buf->s; memcpy(buf_copy->data, buf->data, buf->size); push_buf(r, fifos[ii], buf_copy); } push_buf(r, fifos[0], buf); buf = NULL; } else { hb_buffer_close(&buf); } } hb_buffer_list_close(&list); return HB_WORK_OK; }
static int reader_work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t ** buf_out) { hb_work_private_t * r = w->private_data; hb_fifo_t ** fifos; hb_buffer_t * buf; hb_buffer_list_t list; int ii, chapter = -1; hb_buffer_list_clear(&list); if (r->bd) chapter = hb_bd_chapter( r->bd ); else if (r->dvd) chapter = hb_dvd_chapter( r->dvd ); else if (r->stream) chapter = hb_stream_chapter( r->stream ); if( chapter < 0 ) { hb_log( "reader: end of the title reached" ); reader_send_eof(r); return HB_WORK_DONE; } if( chapter > r->chapter_end ) { hb_log("reader: end of chapter %d (media %d) reached at media chapter %d", r->job->chapter_end, r->chapter_end, chapter); reader_send_eof(r); return HB_WORK_DONE; } if (r->bd) { if( (buf = hb_bd_read( r->bd )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } else if (r->dvd) { if( (buf = hb_dvd_read( r->dvd )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } else if (r->stream) { if ( (buf = hb_stream_read( r->stream )) == NULL ) { reader_send_eof(r); return HB_WORK_DONE; } } else { // This should never happen hb_error("Stream not initialized"); reader_send_eof(r); return HB_WORK_DONE; } (hb_demux[r->title->demuxer])(buf, &list, &r->demux); while ((buf = hb_buffer_list_rem_head(&list)) != NULL) { fifos = GetFifoForId( r, buf->s.id ); if (fifos && r->stream && !r->start_found) { // libav is allowing SSA subtitles to leak through that are // prior to the seek point. So only make the adjustment to // pts_to_start after we see the next video buffer. if (buf->s.id != r->job->title->video_id) { hb_buffer_close(&buf); continue; } // We will inspect the timestamps of each frame in sync // to skip from this seek point to the timestamp we // want to start at. if (buf->s.start != AV_NOPTS_VALUE && buf->s.start < r->job->pts_to_start) { r->job->pts_to_start -= buf->s.start; } else if ( buf->s.start >= r->job->pts_to_start ) { r->job->pts_to_start = 0; } r->start_found = 1; } if (buf->s.start != AV_NOPTS_VALUE && r->scr_changes != r->demux.scr_changes) { // First valid timestamp after an SCR change. Update // the per-stream scr sequence number r->scr_changes = r->demux.scr_changes; // libav tries to be too smart with timestamps and // enforces unnecessary conditions. One such condition // is that subtitle timestamps must be monotonically // increasing. To ensure this is the case, we calculate // an offset upon each SCR change that will guarantee this. // This is just a very rough SCR offset. A fine grained // offset that maintains proper sync is calculated in sync.c if (r->last_pts != AV_NOPTS_VALUE) { r->scr_offset = r->last_pts + 90000 - buf->s.start; } else { r->scr_offset = -buf->s.start; } } // Set the scr sequence that this buffer's timestamps are // referenced to. buf->s.scr_sequence = r->scr_changes; if (buf->s.start != AV_NOPTS_VALUE) { buf->s.start += r->scr_offset; } if (buf->s.renderOffset != AV_NOPTS_VALUE) { buf->s.renderOffset += r->scr_offset; } if (buf->s.start > r->last_pts) { r->last_pts = buf->s.start; UpdateState(r); } buf = splice_discontinuity(r, buf); if (fifos && buf != NULL) { /* if there are mutiple output fifos, send a copy of the * buffer down all but the first (we have to not ship the * original buffer or we'll race with the thread that's * consuming the buffer & inject garbage into the data stream). */ for (ii = 1; fifos[ii] != NULL; ii++) { hb_buffer_t *buf_copy = hb_buffer_init(buf->size); buf_copy->s = buf->s; memcpy(buf_copy->data, buf->data, buf->size); push_buf(r, fifos[ii], buf_copy); } push_buf(r, fifos[0], buf); buf = NULL; } else { hb_buffer_close(&buf); } } hb_buffer_list_close(&list); return HB_WORK_OK; }