static SANE_Status read_image_duplex(SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; SANE_Status st = SANE_STATUS_GOOD; unsigned read, side; int i; struct side { unsigned mx, eof; u8 *p; struct buf *buf; } a[2], *b; for (i = 0; i < 2; i++) { a[i].mx = BUF_SIZE; a[i].eof = 0; a[i].buf = &s->buf[i]; st = new_buf(&s->buf[i], &a[i].p); if (st) goto err; } for (b = &a[0], side = SIDE_FRONT; (!a[0].eof || !a[1].eof);) { pthread_testcancel(); if (b->mx == 0) { push_buf(b->buf, BUF_SIZE); st = new_buf(b->buf, &b->p); if (st) goto err; b->mx = BUF_SIZE; } st = kvs40xx_read_image_data(s, s->page, side, b->p + BUF_SIZE - b->mx, b->mx, &read); b->mx -= read; if (st) { if (st != INCORRECT_LENGTH && st != SANE_STATUS_EOF) goto err; if (st == SANE_STATUS_EOF) { b->eof = 1; push_buf(b->buf, BUF_SIZE - b->mx); } side ^= SIDE_BACK; b = &a[side == SIDE_FRONT ? 0 : 1]; } } err: for (i = 0; i < 2; i++) buf_set_st(&s->buf[i], st); return st; }
void *producer(void *arg) { int work_item = 1; while (1) { sleep( rand() % 5 ); sem_wait(&sem_producer); // Wait for empty slots pthread_mutex_lock(&mut_buf); push_buf(work_item++); // inside critical section with mut_buf lock sem_post(&sem_consumer); // Tell the consumer there's a new work item pthread_mutex_unlock(&mut_buf); } }
static void reader_send_eof( hb_work_private_t * r ) { int ii; // send eof buffers downstream to decoders to signal we're done. push_buf(r, r->job->fifo_mpeg2, hb_buffer_eof_init()); hb_audio_t *audio; for (ii = 0; (audio = hb_list_item(r->job->list_audio, ii)); ++ii) { if (audio->priv.fifo_in) push_buf(r, audio->priv.fifo_in, hb_buffer_eof_init()); } hb_subtitle_t *subtitle; for (ii = 0; (subtitle = hb_list_item(r->job->list_subtitle, ii)); ++ii) { if (subtitle->fifo_in && subtitle->source != SRTSUB) push_buf(r, subtitle->fifo_in, hb_buffer_eof_init()); } hb_log("reader: done. %d scr changes", r->demux.scr_changes); }
EAPI void eina_evlog(const char *event, void *obj, double srctime, const char *detail) { Eina_Evlog_Item *item; int size; char *strings; double now = get_time(); unsigned short detail_offset = 0; unsigned short event_size; eina_spinlock_take(&_evlog_lock); if (!_evlog_go) { eina_spinlock_release(&_evlog_lock); return; } size = sizeof(Eina_Evlog_Item); event_size = strlen(event) + 1; size += event_size; if (detail) { detail_offset = size; size += strlen(detail) + 1; } size = sizeof(double) * ((size + sizeof(double) - 1) / sizeof(double)); strings = push_buf(buf, size); item = (Eina_Evlog_Item *)strings; item->tim = now; item->srctim = srctime; item->thread = (unsigned long long)pthread_self(); item->obj = (unsigned long long)obj; item->event_offset = sizeof(Eina_Evlog_Item); item->detail_offset = detail_offset; item->event_next = size; strcpy(strings + sizeof(Eina_Evlog_Item), event); if (detail_offset > 0) strcpy(strings + detail_offset, detail); eina_spinlock_release(&_evlog_lock); }
static SANE_Status read_image_simplex(SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; SANE_Status st = SANE_STATUS_GOOD; for (; (!st || st == INCORRECT_LENGTH);) { unsigned read, mx; unsigned char *p = NULL; st = new_buf(&s->buf[0], &p); for (read = 0, mx = BUF_SIZE; mx && (!st || st == INCORRECT_LENGTH); mx -= read) { pthread_testcancel(); st = kvs40xx_read_image_data(s, s->page, SIDE_FRONT, p + BUF_SIZE - mx, mx, &read); } push_buf(&s->buf[0], BUF_SIZE - mx); } buf_set_st(&s->buf[0], st); return st; }
/*********************************************************************** * ReaderFunc *********************************************************************** * **********************************************************************/ static void ReaderFunc( void * _r ) { hb_reader_t * r = _r; hb_fifo_t ** fifos; hb_buffer_t * buf; hb_list_t * list; int n; int chapter = -1; int chapter_end = r->job->chapter_end; if ( r->title->type == HB_BD_TYPE ) { if ( !( r->bd = hb_bd_init( r->title->path ) ) ) return; } else if ( r->title->type == HB_DVD_TYPE ) { if ( !( r->dvd = hb_dvd_init( r->title->path ) ) ) return; } else if ( r->title->type == HB_STREAM_TYPE || r->title->type == HB_FF_STREAM_TYPE ) { if ( !( r->stream = hb_stream_open( r->title->path, r->title ) ) ) return; } else { // Unknown type, should never happen return; } if (r->bd) { if( !hb_bd_start( r->bd, r->title ) ) { hb_bd_close( &r->bd ); return; } if ( r->job->start_at_preview ) { // XXX code from DecodePreviews - should go into its own routine hb_bd_seek( r->bd, (float)r->job->start_at_preview / ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) ); } else if ( r->job->pts_to_start ) { // Note, bd seeks always put us to an i-frame. no need // to start decoding early using r->pts_to_start hb_bd_seek_pts( r->bd, r->job->pts_to_start ); r->job->pts_to_start = 0; r->start_found = 1; } else { hb_bd_seek_chapter( r->bd, r->job->chapter_start ); } if (r->job->angle > 1) { hb_bd_set_angle( r->bd, r->job->angle - 1 ); } } else if (r->dvd) { /* * XXX this code is a temporary hack that should go away if/when * chapter merging goes away in libhb/dvd.c * map the start and end chapter numbers to on-media chapter * numbers since chapter merging could cause the handbrake numbers * to diverge from the media numbers and, if our chapter_end is after * a media chapter that got merged, we'll stop ripping too early. */ int start = r->job->chapter_start; hb_chapter_t *chap = hb_list_item( r->title->list_chapter, chapter_end - 1 ); chapter_end = chap->index; if (start > 1) { chap = hb_list_item( r->title->list_chapter, start - 1 ); start = chap->index; } /* end chapter mapping XXX */ if( !hb_dvd_start( r->dvd, r->title, start ) ) { hb_dvd_close( &r->dvd ); return; } if (r->job->angle) { hb_dvd_set_angle( r->dvd, r->job->angle ); } if ( r->job->start_at_preview ) { // XXX code from DecodePreviews - should go into its own routine hb_dvd_seek( r->dvd, (float)r->job->start_at_preview / ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) ); } } else if ( r->stream && r->job->start_at_preview ) { // XXX code from DecodePreviews - should go into its own routine hb_stream_seek( r->stream, (float)( r->job->start_at_preview - 1 ) / ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) ); } else if ( r->stream && r->job->pts_to_start ) { int64_t pts_to_start = r->job->pts_to_start; // Find out what the first timestamp of the stream is // and then seek to the appropriate offset from it if ( ( buf = hb_stream_read( r->stream ) ) ) { if ( buf->start > 0 ) { pts_to_start += buf->start; r->pts_to_start += buf->start; r->job->pts_to_start += buf->start; } } if ( hb_stream_seek_ts( r->stream, pts_to_start ) >= 0 ) { // Seek takes us to the nearest I-frame before the timestamp // that we want. So we will retrieve the start time of the // first packet we get, subtract that from pts_to_start, and // inspect the reset of the frames in sync. r->start_found = 2; r->job->pts_to_start = pts_to_start; } } else if( r->stream ) { /* * Standard stream, seek to the starting chapter, if set, and track the * end chapter so that we end at the right time. */ int start = r->job->chapter_start; hb_chapter_t *chap = hb_list_item( r->title->list_chapter, chapter_end - 1 ); chapter_end = chap->index; if (start > 1) { chap = hb_list_item( r->title->list_chapter, start - 1 ); start = chap->index; } /* * Seek to the start chapter. */ hb_stream_seek_chapter( r->stream, start ); } list = hb_list_init(); while( !*r->die && !r->job->done ) { 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" ); break; } if( chapter > chapter_end ) { hb_log( "reader: end of chapter %d (media %d) reached at media chapter %d", r->job->chapter_end, chapter_end, chapter ); break; } if (r->bd) { if( (buf = hb_bd_read( r->bd )) == NULL ) { break; } } else if (r->dvd) { if( (buf = hb_dvd_read( r->dvd )) == NULL ) { break; } } else if (r->stream) { if ( (buf = hb_stream_read( r->stream )) == NULL ) { break; } if ( 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->start > 0 && buf->start < r->job->pts_to_start ) { r->job->pts_to_start -= buf->start; } else if ( buf->start >= r->job->pts_to_start ) { r->job->pts_to_start = 0; r->start_found = 1; } } } if( r->job->indepth_scan ) { /* * Need to update the progress during a subtitle scan */ hb_state_t state; #define p state.param.working state.state = HB_STATE_WORKING; p.progress = (double)chapter / (double)r->job->chapter_end; if( p.progress > 1.0 ) { p.progress = 1.0; } p.rate_avg = 0.0; p.hours = -1; p.minutes = -1; p.seconds = -1; hb_set_state( r->job->h, &state ); } (hb_demux[r->title->demuxer])( buf, list, &r->demux ); while( ( buf = hb_list_item( list, 0 ) ) ) { hb_list_rem( list, buf ); fifos = GetFifoForId( r->job, buf->id ); 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->start != -1 && buf->renderOffset != -1 && ( buf->id == r->title->video_id || is_audio( r, buf->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->id, buf->renderOffset ); } else { fifos = NULL; } } if( fifos ) { if ( buf->renderOffset != -1 ) { 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 ); } 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. buf->start = -1; buf->renderOffset = -1; } } } if ( buf->start != -1 ) { int64_t start = buf->start - r->scr_offset; if ( !r->start_found ) UpdateState( r, start ); if ( !r->start_found && start >= r->pts_to_start ) { // pts_to_start point found r->start_found = 1; } // This log is handy when you need to debug timing problems //hb_log("id %x scr_offset %ld start %ld --> %ld", // buf->id, r->scr_offset, buf->start, // buf->start - r->scr_offset); buf->start -= r->scr_offset; } if ( buf->renderOffset != -1 ) { if ( r->scr_changes == r->demux.scr_changes ) { // 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->renderOffset -= r->scr_offset; update_ipt( r, buf ); } } 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( n = 1; fifos[n] != NULL; n++) { hb_buffer_t *buf_copy = hb_buffer_init( buf->size ); hb_buffer_copy_settings( buf_copy, buf ); memcpy( buf_copy->data, buf->data, buf->size ); push_buf( r, fifos[n], buf_copy ); } push_buf( r, fifos[0], buf ); } else { hb_buffer_close( &buf ); } } } // send empty buffers downstream to video & audio decoders to signal we're done. if( !*r->die && !r->job->done ) { push_buf( r, r->job->fifo_mpeg2, hb_buffer_init(0) ); hb_audio_t *audio; for( n = 0; (audio = hb_list_item( r->job->title->list_audio, n)); ++n ) { if ( audio->priv.fifo_in ) push_buf( r, audio->priv.fifo_in, hb_buffer_init(0) ); } hb_subtitle_t *subtitle; for( n = 0; (subtitle = hb_list_item( r->job->title->list_subtitle, n)); ++n ) { if ( subtitle->fifo_in && subtitle->source == VOBSUB) push_buf( r, subtitle->fifo_in, hb_buffer_init(0) ); } } hb_list_empty( &list ); if (r->bd) { hb_bd_stop( r->bd ); hb_bd_close( &r->bd ); } else if (r->dvd) { hb_dvd_stop( r->dvd ); hb_dvd_close( &r->dvd ); } else if (r->stream) { hb_stream_close(&r->stream); } if ( r->stream_timing ) { free( r->stream_timing ); } hb_log( "reader: done. %d scr changes", r->demux.scr_changes ); if ( r->demux.dts_drops ) { hb_log( "reader: %d drops because DTS out of range", r->demux.dts_drops ); } free( r ); _r = NULL; }
int main(int argc, char* argv[]) { struct pipe p; void* h; void* h0, *h1, *h2; void* b; const void* b0, *b1, *b2; int s0, s1, s2; // init printf("%d\n", init_pipe(&p, 3, 2, 0x1)); #if 0 //get and push h0 = get_buf(&p, &b); printf("%p %p\n", h0, b); printf("%d\n", push_buf(&p, h0, 1)); print_pipe(&p); h0 = pull_buf(&p, 0, &b0, &s0); h1 = pull_buf(&p, 1, &b1, &s1); h2 = pull_buf(&p, 2, &b2, &s2); put_buf(&p, h0); put_buf(&p, h1); put_buf(&p, h2); print_pipe(&p); h0 = get_buf(&p, &b); printf("%p %p\n", h0, b); printf("%d\n", push_buf(&p, h0, 1)); #endif // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 1); // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 2); // dst pull 1 2 h2 = pull_buf(&p, 2, &b2, &s2); put_buf(&p, h2); h1 = pull_buf(&p, 1, &b1, &s1); put_buf(&p, h1); //print_pipe(&p); exit(0); // src push 1 2 (0 is full) h = get_buf(&p, &b); push_buf(&p, h, 3); //print_pipe(&p); exit(0); // dst pull 1 2 h2 = pull_buf(&p, 2, &b2, &s2); put_buf(&p, h2); h1 = pull_buf(&p, 1, &b1, &s1); put_buf(&p, h1); //print_pipe(&p); exit(0); // dst pull 1 2 h2 = pull_buf(&p, 2, &b2, &s2); put_buf(&p, h2); h1 = pull_buf(&p, 1, &b1, &s1); put_buf(&p, h1); //print_pipe(&p); exit(0); // dst pull 0 h0 = pull_buf(&p, 0, &b0, &s0); put_buf(&p, h0); // dst pull 0 h0 = pull_buf(&p, 0, &b0, &s0); put_buf(&p, h0); //print_pipe(&p); exit(0); // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 4); // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 5); // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 6); // src push 0 1 2 h = get_buf(&p, &b); push_buf(&p, h, 7); //print_pipe(&p); exit(0); // dst pull 0 h0 = pull_buf(&p, 0, &b0, &s0); put_buf(&p, h0); // dst pull 0 h0 = pull_buf(&p, 0, &b0, &s0); put_buf(&p, h0); h0 = pull_buf(&p, 0, &b0, &s0); printf("%p\n", h0); print_pipe(&p); exit(0); //should be src(0), dst0(0), dst1(2), dst2(2) #if 0 struct queue q; void* p; init_queue(&q, 5); printf("%d\n", enqueue(&q, (void*)1)); printf("%d\n", enqueue(&q, (void*)2)); printf("%d\n", enqueue(&q, (void*)3)); printf("%d\n", enqueue(&q, (void*)4)); printf("%d\n", enqueue(&q, (void*)5)); printf("%d\n", enqueue(&q, (void*)6)); printf("\n"); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("\n\n"); init_queue(&q, 7); printf("%d\n", enqueue(&q, (void*)1)); printf("%d\n", enqueue(&q, (void*)2)); printf("%d\n", enqueue(&q, (void*)3)); printf("%d\n", enqueue(&q, (void*)4)); printf("%d\n", enqueue(&q, (void*)5)); printf("%d\n", enqueue(&q, (void*)6)); printf("%d\n", enqueue(&q, (void*)7)); printf("%d\n", enqueue(&q, (void*)8)); printf("\n"); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); printf("%d ", dequeue(&q, &p)); printf("%p\n", p); #endif return 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; }