1 /* $Id: sync.c,v 1.38 2005/04/14 21:57:58 titer Exp $
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. */
10 #include "samplerate.h"
13 #undef INT64_MIN /* Because it isn't defined correctly in Zeta */
15 #define INT64_MIN (-9223372036854775807LL-1)
17 #define AC3_SAMPLES_PER_FRAME 1536
23 int64_t next_start; /* start time of next output frame */
24 int64_t next_pts; /* start time of next input frame */
25 int64_t first_drop; /* PTS of first 'went backwards' frame dropped */
26 int drop_count; /* count of 'time went backwards' drops */
38 struct hb_work_private_s
41 int busy; // bitmask with one bit for each active input
42 // (bit 0 = video; 1 = audio 0, 2 = audio 1, ...
43 // appropriate bit is cleared when input gets
44 // an eof buf. syncWork returns done when all
48 int64_t next_start; /* start time of next output frame */
49 int64_t next_pts; /* start time of next input frame */
50 int64_t first_drop; /* PTS of first 'went backwards' frame dropped */
51 int drop_count; /* count of 'time went backwards' drops */
52 int drops; /* frames dropped to make a cbr video stream */
53 int dups; /* frames duplicated to make a cbr video stream */
57 int chap_mark; /* to propagate chapter mark across a drop */
58 hb_buffer_t * cur; /* The next picture to process */
61 hb_sync_audio_t sync_audio[8];
62 int64_t audio_passthru_slip;
65 uint64_t st_counts[4];
70 /***********************************************************************
72 **********************************************************************/
73 static void InitAudio( hb_work_object_t * w, int i );
74 static void SyncVideo( hb_work_object_t * w );
75 static void SyncAudio( hb_work_object_t * w, int i );
76 static void InsertSilence( hb_work_object_t * w, int i, int64_t d );
77 static void UpdateState( hb_work_object_t * w );
79 /***********************************************************************
81 ***********************************************************************
82 * Initialize the work object
83 **********************************************************************/
84 int syncInit( hb_work_object_t * w, hb_job_t * job )
86 hb_title_t * title = job->title;
87 hb_chapter_t * chapter;
90 hb_work_private_t * pv;
92 pv = calloc( 1, sizeof( hb_work_private_t ) );
96 pv->pts_offset = INT64_MIN;
98 /* Calculate how many video frames we are expecting */
101 duration = job->pts_to_stop + 90000;
103 else if( job->frame_to_stop )
105 /* Set the duration to a rough estimate */
106 duration = ( job->frame_to_stop / ( job->vrate / job->vrate_base ) ) * 90000;
111 for( i = job->chapter_start; i <= job->chapter_end; i++ )
113 chapter = hb_list_item( title->list_chapter, i - 1 );
114 duration += chapter->duration;
117 /* 1 second safety so we're sure we won't miss anything */
119 pv->count_frames_max = duration * job->vrate / job->vrate_base / 90000;
121 hb_log( "sync: expecting %d video frames", pv->count_frames_max );
124 /* Initialize libsamplerate for every audio track we have */
125 if ( ! job->indepth_scan )
127 for( i = 0; i < hb_list_count( title->list_audio ) && i < 8; i++ )
129 pv->busy |= ( 1 << (i + 1) );
137 /***********************************************************************
139 ***********************************************************************
141 **********************************************************************/
142 void syncClose( hb_work_object_t * w )
144 hb_work_private_t * pv = w->private_data;
145 hb_job_t * job = pv->job;
146 hb_title_t * title = job->title;
147 hb_audio_t * audio = NULL;
152 hb_buffer_close( &pv->cur );
155 hb_log( "sync: got %d frames, %d expected",
156 pv->count_frames, pv->count_frames_max );
158 if (pv->drops || pv->dups )
160 hb_log( "sync: %d frames dropped, %d duplicated", pv->drops, pv->dups );
163 for( i = 0; i < hb_list_count( title->list_audio ); i++ )
165 audio = hb_list_item( title->list_audio, i );
166 if( audio->config.out.codec == HB_ACODEC_AC3 )
168 free( pv->sync_audio[i].ac3_buf );
172 src_delete( pv->sync_audio[i].state );
177 w->private_data = NULL;
180 /***********************************************************************
182 ***********************************************************************
183 * The root routine of this work abject
185 * The way this works is that we are syncing the audio to the PTS of
186 * the last video that we processed. That's why we skip the audio sync
187 * if we haven't got a valid PTS from the video yet.
189 **********************************************************************/
190 int syncWork( hb_work_object_t * w, hb_buffer_t ** unused1,
191 hb_buffer_t ** unused2 )
193 hb_work_private_t * pv = w->private_data;
199 for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
201 if ( pv->busy & ( 1 << (i + 1) ) )
205 return ( pv->busy? HB_WORK_OK : HB_WORK_DONE );
208 hb_work_object_t hb_sync =
217 static void InitAudio( hb_work_object_t * w, int i )
219 hb_work_private_t * pv = w->private_data;
220 hb_job_t * job = pv->job;
221 hb_title_t * title = job->title;
222 hb_sync_audio_t * sync;
224 sync = &pv->sync_audio[i];
225 sync->audio = hb_list_item( title->list_audio, i );
227 if( sync->audio->config.out.codec == HB_ACODEC_AC3 )
229 /* Have a silent AC-3 frame ready in case we have to fill a
235 codec = avcodec_find_encoder( CODEC_ID_AC3 );
236 c = avcodec_alloc_context();
238 c->bit_rate = sync->audio->config.in.bitrate;
239 c->sample_rate = sync->audio->config.in.samplerate;
240 c->channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( sync->audio->config.in.channel_layout );
242 if( hb_avcodec_open( c, codec ) < 0 )
244 hb_log( "sync: avcodec_open failed" );
248 zeros = calloc( AC3_SAMPLES_PER_FRAME *
249 sizeof( short ) * c->channels, 1 );
250 sync->ac3_size = sync->audio->config.in.bitrate * AC3_SAMPLES_PER_FRAME /
251 sync->audio->config.in.samplerate / 8;
252 sync->ac3_buf = malloc( sync->ac3_size );
254 if( avcodec_encode_audio( c, sync->ac3_buf, sync->ac3_size,
255 zeros ) != sync->ac3_size )
257 hb_log( "sync: avcodec_encode_audio failed" );
261 hb_avcodec_close( c );
266 /* Initialize libsamplerate */
268 sync->state = src_new( SRC_SINC_MEDIUM_QUALITY, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->config.out.mixdown), &error );
269 sync->data.end_of_input = 0;
273 /***********************************************************************
275 ***********************************************************************
277 **********************************************************************/
278 static void SyncVideo( hb_work_object_t * w )
280 hb_work_private_t * pv = w->private_data;
281 hb_buffer_t * cur, * next, * sub = NULL;
282 hb_job_t * job = pv->job;
283 hb_subtitle_t *subtitle;
286 if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) )
288 /* We haven't even got a frame yet */
294 /* we got an end-of-stream. Feed it downstream & signal that we're done. */
295 hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
298 * Push through any subtitle EOFs in case they were not synced through.
300 for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
302 subtitle = hb_list_item( job->list_subtitle, i );
303 if( subtitle->dest == PASSTHRUSUB )
305 hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
313 /* At this point we have a frame to process. Let's check
314 1) if we will be able to push into the fifo ahead
315 2) if the next frame is there already, since we need it to
316 compute the duration of the current frame*/
317 while( !hb_fifo_is_full( job->fifo_sync ) &&
318 ( next = hb_fifo_see( job->fifo_raw ) ) )
320 hb_buffer_t * buf_tmp;
322 if( next->size == 0 )
324 /* we got an end-of-stream. Feed it downstream & signal that
325 * we're done. Note that this means we drop the final frame of
326 * video (we don't know its duration). On DVDs the final frame
327 * is often strange and dropping it seems to be a good idea. */
328 hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
331 * Push through any subtitle EOFs in case they were not synced through.
333 for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
335 subtitle = hb_list_item( job->list_subtitle, i );
336 if( subtitle->dest == PASSTHRUSUB )
338 hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
344 if( pv->pts_offset == INT64_MIN )
346 /* This is our first frame */
348 if ( cur->start != 0 )
351 * The first pts from a dvd should always be zero but
352 * can be non-zero with a transport or program stream since
353 * we're not guaranteed to start on an IDR frame. If we get
354 * a non-zero initial PTS extend its duration so it behaves
355 * as if it started at zero so that our audio timing will
358 hb_log( "sync: first pts is %lld", cur->start );
364 * since the first frame is always 0 and the upstream reader code
365 * is taking care of adjusting for pts discontinuities, we just have
366 * to deal with the next frame's start being in the past. This can
367 * happen when the PTS is adjusted after data loss but video frame
368 * reordering causes some frames with the old clock to appear after
369 * the clock change. This creates frames that overlap in time which
370 * looks to us like time going backward. The downstream muxing code
371 * can deal with overlaps of up to a frame time but anything larger
372 * we handle by dropping frames here.
374 if ( (int64_t)( next->start - cur->start ) <= 0 ||
375 (int64_t)( (cur->start - pv->audio_passthru_slip ) - pv->next_pts ) < 0 )
377 if ( pv->first_drop == 0 )
379 pv->first_drop = next->start;
382 buf_tmp = hb_fifo_get( job->fifo_raw );
383 if ( buf_tmp->new_chap )
385 // don't drop a chapter mark when we drop the buffer
386 pv->chap_mark = buf_tmp->new_chap;
388 hb_buffer_close( &buf_tmp );
391 if ( pv->first_drop )
393 hb_log( "sync: video time didn't advance - dropped %d frames "
394 "(delta %d ms, current %lld, next %lld, dur %d)",
395 pv->drop_count, (int)( cur->start - pv->first_drop ) / 90,
396 cur->start, next->start, (int)( next->start - cur->start ) );
402 * Track the video sequence number localy so that we can sync the audio
403 * to it using the sequence number as well as the PTS.
405 pv->video_sequence = cur->sequence;
408 * Look for a subtitle for this frame.
410 * If found then it will be tagged onto a video buffer of the correct time and
411 * sent in to the render pipeline. This only needs to be done for VOBSUBs which
412 * get rendered, other types of subtitles can just sit in their raw_queue until
413 * delt with at muxing.
415 for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
417 subtitle = hb_list_item( job->list_subtitle, i );
420 * Rewrite timestamps on subtitles that need it (on raw queue).
422 if( subtitle->source == CC608SUB ||
423 subtitle->source == CC708SUB )
426 * Rewrite timestamps on subtitles that came from Closed Captions
427 * since they are using the MPEG2 timestamps.
429 while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
432 * Rewrite the timestamps as and when the video
433 * (cur->start) reaches the same timestamp as a
434 * closed caption (sub->start).
436 * What about discontinuity boundaries - not delt
439 * Bypass the sync fifo altogether.
443 sub = hb_fifo_get( subtitle->fifo_raw );
444 hb_fifo_push( subtitle->fifo_out, sub );
449 * Sync the subtitles to the incoming video, and use
450 * the matching converted video timestamp.
452 * Note that it doesn't appear that we need to convert
453 * timestamps, I guess that they were already correct,
454 * so just push them through for rendering.
457 if( sub->start < cur->start )
460 duration = sub->stop - sub->start;
461 sub = hb_fifo_get( subtitle->fifo_raw );
462 hb_fifo_push( subtitle->fifo_out, sub );
471 if( subtitle->source == VOBSUB )
474 while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
479 * EOF, pass it through immediately.
484 /* If two subtitles overlap, make the first one stop
485 when the second one starts */
486 sub2 = hb_fifo_see2( subtitle->fifo_raw );
487 if( sub2 && sub->stop > sub2->start )
489 sub->stop = sub2->start;
492 // hb_log("0x%x: video seq: %lld subtitle sequence: %lld",
493 // sub, cur->sequence, sub->sequence);
495 if( sub->sequence > cur->sequence )
498 * The video is behind where we are, so wait until
499 * it catches up to the same reader point on the
500 * DVD. Then our PTS should be in the same region
507 if( sub->stop > cur->start ) {
509 * The stop time is in the future, so fall through
510 * and we'll deal with it in the next block of
515 * There is a valid subtitle, is it time to display it?
517 if( sub->stop > sub->start)
520 * Normal subtitle which ends after it starts,
521 * check to see that the current video is between
524 if( cur->start > sub->start &&
525 cur->start < sub->stop )
528 * We should be playing this, so leave the
531 * fall through to display
533 if( ( sub->stop - sub->start ) < ( 2 * 90000 ) )
536 * Subtitle is on for less than three
537 * seconds, extend the time that it is
538 * displayed to make it easier to read.
539 * Make it 3 seconds or until the next
540 * subtitle is displayed.
542 * This is in response to Indochine which
543 * only displays subs for 1 second -
546 sub->stop = sub->start + ( 2 * 90000 );
548 sub2 = hb_fifo_see2( subtitle->fifo_raw );
550 if( sub2 && sub->stop > sub2->start )
552 sub->stop = sub2->start;
559 * Defer until the play point is within
568 * The end of the subtitle is less than the start,
569 * this is a sign of a PTS discontinuity.
571 if( sub->start > cur->start )
574 * we haven't reached the start time yet, or
575 * we have jumped backwards after having
576 * already started this subtitle.
578 if( cur->start < sub->stop )
581 * We have jumped backwards and so should
582 * continue displaying this subtitle.
584 * fall through to display.
590 * Defer until the play point is
591 * within the subtitle
597 * Play this subtitle as the start is
598 * greater than our video point.
600 * fall through to display/
610 * The subtitle is older than this picture, trash it
612 sub = hb_fifo_get( subtitle->fifo_raw );
613 hb_buffer_close( &sub );
617 /* If we have a subtitle for this picture, copy it */
618 /* FIXME: we should avoid this memcpy */
623 if( subtitle->dest == RENDERSUB )
625 if ( cur->sub == NULL )
628 * Tack onto the video buffer for rendering
630 cur->sub = hb_buffer_init( sub->size );
631 cur->sub->x = sub->x;
632 cur->sub->y = sub->y;
633 cur->sub->width = sub->width;
634 cur->sub->height = sub->height;
635 memcpy( cur->sub->data, sub->data, sub->size );
639 * Pass-Through, pop it off of the raw queue,
640 * rewrite times and make it available to be
643 uint64_t sub_duration;
644 sub = hb_fifo_get( subtitle->fifo_raw );
645 sub_duration = sub->stop - sub->start;
646 sub->start = cur->start;
647 buf_tmp = hb_fifo_see( job->fifo_raw );
648 int64_t duration = buf_tmp->start - cur->start;
649 sub->stop = sub->start + duration;
650 hb_fifo_push( subtitle->fifo_sync, sub );
654 * EOF - consume for rendered, else pass through
656 if( subtitle->dest == RENDERSUB )
658 sub = hb_fifo_get( subtitle->fifo_raw );
659 hb_buffer_close( &sub );
661 sub = hb_fifo_get( subtitle->fifo_raw );
662 hb_fifo_push( subtitle->fifo_out, sub );
670 * Adjust the pts of the current frame so that it's contiguous
671 * with the previous frame. The start time of the current frame
672 * has to be the end time of the previous frame and the stop
673 * time has to be the start of the next frame. We don't
674 * make any adjustments to the source timestamps other than removing
675 * the clock offsets (which also removes pts discontinuities).
676 * This means we automatically encode at the source's frame rate.
677 * MP2 uses an implicit duration (frames end when the next frame
678 * starts) but more advanced containers like MP4 use an explicit
679 * duration. Since we're looking ahead one frame we set the
680 * explicit stop time from the start time of the next frame.
683 pv->cur = cur = hb_fifo_get( job->fifo_raw );
685 pv->next_pts = cur->start;
686 int64_t duration = cur->start - buf_tmp->start;
689 hb_log( "sync: invalid video duration %lld, start %lld, next %lld",
690 duration, buf_tmp->start, next->start );
693 buf_tmp->start = pv->next_start;
694 pv->next_start += duration;
695 buf_tmp->stop = pv->next_start;
699 // we have a pending chapter mark from a recent drop - put it on this
700 // buffer (this may make it one frame late but we can't do any better).
701 buf_tmp->new_chap = pv->chap_mark;
705 /* Push the frame to the renderer */
706 hb_fifo_push( job->fifo_sync, buf_tmp );
711 if( job->frame_to_stop && pv->count_frames > job->frame_to_stop )
713 // Drop an empty buffer into our output to ensure that things
714 // get flushed all the way out.
715 hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
717 hb_log( "sync: reached %d frames, exiting early (%i busy)",
718 pv->count_frames, pv->busy );
722 /* Make sure we won't get more frames then expected */
723 if( pv->count_frames >= pv->count_frames_max * 2)
725 hb_log( "sync: got too many frames (%d), exiting early",
728 // Drop an empty buffer into our output to ensure that things
729 // get flushed all the way out.
730 hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
737 static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf,
738 hb_sync_audio_t *sync, hb_fifo_t *fifo, int i )
740 int64_t start = sync->next_start;
741 int64_t duration = buf->stop - buf->start;
743 sync->next_pts += duration;
745 if( audio->config.in.samplerate == audio->config.out.samplerate ||
746 audio->config.out.codec == HB_ACODEC_AC3 ||
747 audio->config.out.codec == HB_ACODEC_DCA )
750 * If we don't have to do sample rate conversion or this audio is
751 * pass-thru just send the input buffer downstream after adjusting
752 * its timestamps to make the output stream continuous.
757 /* Not pass-thru - do sample rate conversion */
758 int count_in, count_out;
759 hb_buffer_t * buf_raw = buf;
760 int channel_count = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown) *
763 count_in = buf_raw->size / channel_count;
765 * When using stupid rates like 44.1 there will always be some
766 * truncation error. E.g., a 1536 sample AC3 frame will turn into a
767 * 1536*44.1/48.0 = 1411.2 sample frame. If we just truncate the .2
768 * the error will build up over time and eventually the audio will
769 * substantially lag the video. libsamplerate will keep track of the
770 * fractional sample & give it to us when appropriate if we give it
771 * an extra sample of space in the output buffer.
773 count_out = ( duration * audio->config.out.samplerate ) / 90000 + 1;
775 sync->data.input_frames = count_in;
776 sync->data.output_frames = count_out;
777 sync->data.src_ratio = (double)audio->config.out.samplerate /
778 (double)audio->config.in.samplerate;
780 buf = hb_buffer_init( count_out * channel_count );
781 sync->data.data_in = (float *) buf_raw->data;
782 sync->data.data_out = (float *) buf->data;
783 if( src_process( sync->state, &sync->data ) )
785 /* XXX If this happens, we're screwed */
786 hb_log( "sync: audio %d src_process failed", i );
788 hb_buffer_close( &buf_raw );
790 buf->size = sync->data.output_frames_gen * channel_count;
791 duration = ( sync->data.output_frames_gen * 90000 ) /
792 audio->config.out.samplerate;
794 buf->frametype = HB_FRAME_AUDIO;
796 buf->stop = start + duration;
797 sync->next_start = start + duration;
798 hb_fifo_push( fifo, buf );
801 /***********************************************************************
803 ***********************************************************************
805 **********************************************************************/
806 static void SyncAudio( hb_work_object_t * w, int i )
808 hb_work_private_t * pv = w->private_data;
809 hb_job_t * job = pv->job;
810 hb_sync_audio_t * sync = &pv->sync_audio[i];
811 hb_audio_t * audio = sync->audio;
816 if( audio->config.out.codec == HB_ACODEC_AC3 ||
817 audio->config.out.codec == HB_ACODEC_DCA )
819 fifo = audio->priv.fifo_out;
823 fifo = audio->priv.fifo_sync;
826 while( !hb_fifo_is_full( fifo ) && ( buf = hb_fifo_see( audio->priv.fifo_raw ) ) )
828 start = buf->start - pv->audio_passthru_slip;
829 /* if the next buffer is an eof send it downstream */
830 if ( buf->size <= 0 )
832 buf = hb_fifo_get( audio->priv.fifo_raw );
833 hb_fifo_push( fifo, buf );
834 pv->busy &=~ (1 << (i + 1) );
837 if( job->frame_to_stop && pv->count_frames >= job->frame_to_stop )
839 hb_fifo_push( fifo, hb_buffer_init(0) );
840 pv->busy &=~ (1 << (i + 1) );
843 if ( (int64_t)( start - sync->next_pts ) < 0 )
845 // audio time went backwards.
846 // If our output clock is more than a half frame ahead of the
847 // input clock drop this frame to move closer to sync.
848 // Otherwise drop frames until the input clock matches the output clock.
849 if ( sync->first_drop || sync->next_start - start > 90*15 )
851 // Discard data that's in the past.
852 if ( sync->first_drop == 0 )
854 sync->first_drop = sync->next_pts;
857 buf = hb_fifo_get( audio->priv.fifo_raw );
858 hb_buffer_close( &buf );
861 sync->next_pts = start;
863 if ( sync->first_drop )
865 // we were dropping old data but input buf time is now current
866 hb_log( "sync: audio %d time went backwards %d ms, dropped %d frames "
867 "(next %lld, current %lld)", i,
868 (int)( sync->next_pts - sync->first_drop ) / 90,
869 sync->drop_count, sync->first_drop, sync->next_pts );
870 sync->first_drop = 0;
871 sync->drop_count = 0;
872 sync->next_pts = start;
874 if ( start - sync->next_pts >= (90 * 70) )
876 if ( start - sync->next_pts > (90000LL * 60) )
878 // there's a gap of more than a minute between the last
879 // frame and this. assume we got a corrupted timestamp
880 // and just drop the next buf.
881 hb_log( "sync: %d minute time gap in audio %d - dropping buf"
882 " start %lld, next %lld",
883 (int)((start - sync->next_pts) / (90000*60)),
884 i, start, sync->next_pts );
885 buf = hb_fifo_get( audio->priv.fifo_raw );
886 hb_buffer_close( &buf );
890 * there's a gap of at least 70ms between the last
891 * frame we processed & the next. Fill it with silence.
892 * Or in the case of DCA, skip some frames from the
895 if( sync->audio->config.out.codec == HB_ACODEC_DCA )
897 hb_log( "sync: audio gap %d ms. Skipping frames. Audio %d"
898 " start %lld, next %lld",
899 (int)((start - sync->next_pts) / 90),
900 i, start, sync->next_pts );
901 pv->audio_passthru_slip += (start - sync->next_pts);
904 hb_log( "sync: adding %d ms of silence to audio %d"
905 " start %lld, next %lld",
906 (int)((start - sync->next_pts) / 90),
907 i, start, sync->next_pts );
908 InsertSilence( w, i, start - sync->next_pts );
913 * When we get here we've taken care of all the dups and gaps in the
914 * audio stream and are ready to inject the next input frame into
917 buf = hb_fifo_get( audio->priv.fifo_raw );
918 OutputAudioFrame( job, audio, buf, sync, fifo, i );
922 static void InsertSilence( hb_work_object_t * w, int i, int64_t duration )
924 hb_work_private_t * pv = w->private_data;
925 hb_job_t *job = pv->job;
926 hb_sync_audio_t *sync = &pv->sync_audio[i];
930 // to keep pass-thru and regular audio in sync we generate silence in
931 // AC3 frame-sized units. If the silence duration isn't an integer multiple
932 // of the AC3 frame duration we will truncate or round up depending on
933 // which minimizes the timing error.
934 const int frame_dur = ( 90000 * AC3_SAMPLES_PER_FRAME ) /
935 sync->audio->config.in.samplerate;
936 int frame_count = ( duration + (frame_dur >> 1) ) / frame_dur;
938 while ( --frame_count >= 0 )
940 if( sync->audio->config.out.codec == HB_ACODEC_AC3 )
942 buf = hb_buffer_init( sync->ac3_size );
943 buf->start = sync->next_pts;
944 buf->stop = buf->start + frame_dur;
945 memcpy( buf->data, sync->ac3_buf, buf->size );
946 fifo = sync->audio->priv.fifo_out;
950 buf = hb_buffer_init( AC3_SAMPLES_PER_FRAME * sizeof( float ) *
951 HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
952 sync->audio->config.out.mixdown) );
953 buf->start = sync->next_pts;
954 buf->stop = buf->start + frame_dur;
955 memset( buf->data, 0, buf->size );
956 fifo = sync->audio->priv.fifo_sync;
958 OutputAudioFrame( job, sync->audio, buf, sync, fifo, i );
962 static void UpdateState( hb_work_object_t * w )
964 hb_work_private_t * pv = w->private_data;
967 if( !pv->count_frames )
969 pv->st_first = hb_get_date();
973 if( hb_get_date() > pv->st_dates[3] + 1000 )
975 memmove( &pv->st_dates[0], &pv->st_dates[1],
976 3 * sizeof( uint64_t ) );
977 memmove( &pv->st_counts[0], &pv->st_counts[1],
978 3 * sizeof( uint64_t ) );
979 pv->st_dates[3] = hb_get_date();
980 pv->st_counts[3] = pv->count_frames;
983 #define p state.param.working
984 state.state = HB_STATE_WORKING;
985 p.progress = (float) pv->count_frames / (float) pv->count_frames_max;
986 if( p.progress > 1.0 )
990 p.rate_cur = 1000.0 *
991 (float) ( pv->st_counts[3] - pv->st_counts[0] ) /
992 (float) ( pv->st_dates[3] - pv->st_dates[0] );
993 if( hb_get_date() > pv->st_first + 4000 )
996 p.rate_avg = 1000.0 * (float) pv->st_counts[3] /
997 (float) ( pv->st_dates[3] - pv->st_first );
998 eta = (float) ( pv->count_frames_max - pv->st_counts[3] ) /
1000 p.hours = eta / 3600;
1001 p.minutes = ( eta % 3600 ) / 60;
1002 p.seconds = eta % 60;
1013 hb_set_state( pv->job->h, &state );