X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fmuxcommon.c;h=b6b5a2a579145bbd4cd525e12a34a32c46795b4c;hb=4f0019f03c2e85e8634150ff0c9a31bee6d35ce5;hp=13a8992245a1ad3bab82508b5a3f37d9398ff065;hpb=b6693a23e93f4bee393c715ac8e3da25e22dce3c;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/muxcommon.c b/libhb/muxcommon.c index 13a89922..b6b5a2a5 100644 --- a/libhb/muxcommon.c +++ b/libhb/muxcommon.c @@ -13,219 +13,503 @@ struct hb_mux_object_s typedef struct { - hb_job_t * job; - uint64_t pts; - -} hb_mux_t; + hb_buffer_t **fifo; + uint32_t in; // number of bufs put into fifo + uint32_t out; // number of bufs taken out of fifo + uint32_t flen; // fifo length (must be power of two) +} mux_fifo_t; typedef struct { - hb_fifo_t * fifo; hb_mux_data_t * mux_data; uint64_t frames; uint64_t bytes; - + mux_fifo_t mf; } hb_track_t; -static hb_track_t * GetTrack( hb_list_t * list ) +typedef struct { - hb_buffer_t * buf; - hb_track_t * track = NULL, * track2; - int64_t pts = 0; - int i; + hb_lock_t * mutex; + int ref; + int done; + hb_mux_object_t * m; + double pts; // end time of next muxing chunk + double interleave; // size in 90KHz ticks of media chunks we mux + uint32_t ntracks; // total number of tracks we're muxing + uint32_t eof; // bitmask of track with eof + uint32_t rdy; // bitmask of tracks ready to output + uint32_t allEof; // valid bits in eof (all tracks) + uint32_t allRdy; // valid bits in rdy (audio & video tracks) + hb_track_t * track[32]; // array of tracks to mux ('ntrack' elements) + // NOTE- this array could be dynamically + // allocated but the eof & rdy logic has to + // be changed to handle more than 32 tracks + // anyway so we keep it simple and fast. +} hb_mux_t; + +struct hb_work_private_s +{ + hb_job_t * job; + int track; + hb_mux_t * mux; +}; + +// The muxer handles two different kinds of media: Video and audio tracks +// are continuous: once they start they generate continuous, consecutive +// sequence of bufs until they end. The muxer will time align all continuous +// media tracks so that their data will be well interleaved in the output file. +// (Smooth, low latency playback with minimal player buffering requires that +// data that's going to be presented close together in time also be close +// together in the output file). Since HB's audio and video encoders run at +// different speeds, the time-aligning involves buffering *all* the continuous +// media tracks until a frame with a timestamp beyond the current alignment +// point arrives on the slowest fifo (usually the video encoder). +// +// The other kind of media, subtitles, close-captions, vobsubs and +// similar tracks, are intermittent. They generate frames sporadically or on +// human time scales (seconds) rather than near the video frame rate (milliseconds). +// If intermittent sources were treated like continuous sources huge sections of +// audio and video would get buffered waiting for the next subtitle to show up. +// To keep this from happening the muxer doesn't wait for intermittent tracks +// (essentially it assumes that they will always go through the HB processing +// pipeline faster than the associated video). They are still time aligned and +// interleaved at the appropriate point in the output file. - for( i = 0; i < hb_list_count( list ); i++ ) +// This routine adds another track for the muxer to process. The media input +// stream will be read from HandBrake fifo 'fifo'. Buffers read from that +// stream will be time-aligned with all the other media streams then passed +// to the container-specific 'mux' routine with argument 'mux_data' (see +// routine OutputTrackChunk). 'is_continuous' must be 1 for an audio or video +// track and 0 otherwise (see above). + +static void add_mux_track( hb_mux_t *mux, hb_mux_data_t *mux_data, + int is_continuous ) +{ + int max_tracks = sizeof(mux->track) / sizeof(*(mux->track)); + if ( mux->ntracks >= max_tracks ) { - track2 = hb_list_item( list, i ); - buf = hb_fifo_see( track2->fifo ); - if( !buf ) - { - // To make sure we don't camp on one fifo & prevent the others - // from making progress we take the earliest data of all the - // data that's currently available but we don't care if some - // fifos don't have data. - continue; - } - if( !track || buf->start < pts ) - { - track = track2; - pts = buf->start; - } + hb_error( "add_mux_track: too many tracks (>%d)", max_tracks ); + return; } - return track; + + hb_track_t *track = calloc( sizeof( hb_track_t ), 1 ); + track->mux_data = mux_data; + track->mf.flen = 8; + track->mf.fifo = calloc( sizeof(track->mf.fifo[0]), track->mf.flen ); + + int t = mux->ntracks++; + mux->track[t] = track; + mux->allEof |= 1 << t; + mux->allRdy |= is_continuous << t; } -static void MuxerFunc( void * _mux ) +static void mf_push( hb_mux_t * mux, int tk, hb_buffer_t *buf ) { - hb_mux_t * mux = _mux; - hb_job_t * job = mux->job; - hb_title_t * title = job->title; - hb_audio_t * audio; - hb_list_t * list; - hb_buffer_t * buf; - hb_track_t * track; - int i; - - hb_mux_object_t * m = NULL; + hb_track_t * track = mux->track[tk]; + uint32_t mask = track->mf.flen - 1; + uint32_t in = track->mf.in; - /* Get a real muxer */ - if( job->pass == 0 || job->pass == 2) + if ( ( ( in + 2 ) & mask ) == ( track->mf.out & mask ) ) { - switch( job->mux ) + if ( track->mf.flen >= 256 ) { - case HB_MUX_MP4: - case HB_MUX_PSP: - case HB_MUX_IPOD: - m = hb_mux_mp4_init( job ); - break; - case HB_MUX_AVI: - m = hb_mux_avi_init( job ); - break; - case HB_MUX_OGM: - m = hb_mux_ogm_init( job ); - break; - case HB_MUX_MKV: - m = hb_mux_mkv_init( job ); + mux->rdy = mux->allRdy; } } - - /* Wait for one buffer for each track */ - while( !*job->die && !job->done ) + if ( ( ( in + 1 ) & mask ) == ( track->mf.out & mask ) ) { - int ready; - - ready = 1; - if( !hb_fifo_size( job->fifo_mpeg4 ) ) + // fifo is full - expand it to double the current size. + // This is a bit tricky because when we change the size + // it changes the modulus (mask) used to convert the in + // and out counters to fifo indices. Since existing items + // will be referenced at a new location after the expand + // we can't just realloc the fifo. If there were + // hundreds of fifo entries it would be worth it to have code + // for each of the four possible before/after configurations + // but these fifos are small so we just allocate a new chunk + // of memory then do element by element copies using the old & + // new masks then free the old fifo's memory.. + track->mf.flen *= 2; + uint32_t nmask = track->mf.flen - 1; + hb_buffer_t **nfifo = malloc( track->mf.flen * sizeof(*nfifo) ); + int indx = track->mf.out; + while ( indx != track->mf.in ) { - ready = 0; - } - for( i = 0; i < hb_list_count( title->list_audio ); i++ ) - { - audio = hb_list_item( title->list_audio, i ); - if( !hb_fifo_size( audio->priv.fifo_out ) ) - { - ready = 0; - break; - } + nfifo[indx & nmask] = track->mf.fifo[indx & mask]; + ++indx; } + free( track->mf.fifo ); + track->mf.fifo = nfifo; + mask = nmask; + } + track->mf.fifo[in & mask] = buf; + track->mf.in = in + 1; +} - if( ready ) - { - break; - } +static hb_buffer_t *mf_pull( hb_track_t *track ) +{ + hb_buffer_t *b = NULL; + if ( track->mf.out != track->mf.in ) + { + // the fifo isn't empty + b = track->mf.fifo[track->mf.out & (track->mf.flen - 1)]; + ++track->mf.out; + } + return b; +} + +static hb_buffer_t *mf_peek( hb_track_t *track ) +{ + return track->mf.out == track->mf.in ? + NULL : track->mf.fifo[track->mf.out & (track->mf.flen - 1)]; +} - hb_snooze( 50 ); +static void MoveToInternalFifos( int tk, hb_mux_t *mux, hb_buffer_t * buf ) +{ + // move all the buffers on the track's fifo to our internal + // fifo so that (a) we don't deadlock in the reader and + // (b) we can control how data from multiple tracks is + // interleaved in the output file. + mf_push( mux, tk, buf ); + if ( buf->stop >= mux->pts ) + { + // buffer is past our next interleave point so + // note that this track is ready to be output. + mux->rdy |= ( 1 << tk ); } +} - /* Create file, write headers */ - if( job->pass == 0 || job->pass == 2 ) +static void OutputTrackChunk( hb_mux_t *mux, hb_track_t *track, hb_mux_object_t *m ) +{ + hb_buffer_t *buf; + + while ( ( buf = mf_peek( track ) ) != NULL && buf->start < mux->pts ) { - m->init( m ); + buf = mf_pull( track ); + track->frames += 1; + track->bytes += buf->size; + m->mux( m, track->mux_data, buf ); } +} + +static int muxWork( hb_work_object_t * w, hb_buffer_t ** buf_in, + hb_buffer_t ** buf_out ) +{ + hb_work_private_t * pv = w->private_data; + hb_job_t * job = pv->job; + hb_mux_t * mux = pv->mux; + hb_track_t * track; + int i; + hb_buffer_t * buf = *buf_in; - /* Build list of fifos we're interested in */ - list = hb_list_init(); + hb_lock( mux->mutex ); + if ( mux->done ) + { + hb_unlock( mux->mutex ); + return HB_WORK_DONE; + } - track = calloc( sizeof( hb_track_t ), 1 ); - track->fifo = job->fifo_mpeg4; - track->mux_data = job->mux_data; - hb_list_add( list, track ); + if ( buf->size <= 0 ) + { + // EOF - mark this track as done + hb_buffer_close( &buf ); + mux->eof |= ( 1 << pv->track ); + mux->rdy |= ( 1 << pv->track ); + } + else if ( ( job->pass != 0 && job->pass != 2 ) || + ( mux->eof & (1 << pv->track) ) ) + { + hb_buffer_close( &buf ); + } + else + { + MoveToInternalFifos( pv->track, mux, buf ); + } + *buf_in = NULL; - for( i = 0; i < hb_list_count( title->list_audio ); i++ ) + if ( ( mux->rdy & mux->allRdy ) != mux->allRdy ) { - audio = hb_list_item( title->list_audio, i ); - track = calloc( sizeof( hb_track_t ), 1 ); - track->fifo = audio->priv.fifo_out; - track->mux_data = audio->priv.mux_data; - hb_list_add( list, track ); + hb_unlock( mux->mutex ); + return HB_WORK_OK; } - int thread_sleep_interval = 50; - while( !*job->die && !job->done ) + // all tracks have at least 'interleave' ticks of data. Output + // all that we can in 'interleave' size chunks. + while ( ( mux->rdy & mux->allRdy ) == mux->allRdy ) { - if( !( track = GetTrack( list ) ) ) + for ( i = 0; i < mux->ntracks; ++i ) { - hb_snooze( thread_sleep_interval ); - continue; + track = mux->track[i]; + OutputTrackChunk( mux, track, mux->m ); + + // if the track is at eof or still has data that's past + // our next interleave point then leave it marked as rdy. + // Otherwise clear rdy. + if ( ( mux->eof & (1 << i) ) == 0 && + ( track->mf.out == track->mf.in || + track->mf.fifo[(track->mf.in-1) & (track->mf.flen-1)]->stop + < mux->pts + mux->interleave ) ) + { + mux->rdy &=~ ( 1 << i ); + } } - buf = hb_fifo_get( track->fifo ); - if( job->pass == 0 || job->pass == 2 ) + // if all the tracks are at eof we're just purging their + // remaining data -- keep going until all internal fifos are empty. + if ( mux->eof == mux->allEof ) { - m->mux( m, track->mux_data, buf ); - track->frames += 1; - track->bytes += buf->size; - mux->pts = buf->stop; + for ( i = 0; i < mux->ntracks; ++i ) + { + if ( mux->track[i]->mf.out != mux->track[i]->mf.in ) + { + break; + } + } + if ( i >= mux->ntracks ) + { + mux->done = 1; + hb_unlock( mux->mutex ); + return HB_WORK_DONE; + } } - hb_buffer_close( &buf ); + mux->pts += mux->interleave; } + hb_unlock( mux->mutex ); + return HB_WORK_OK; +} + +void muxClose( hb_work_object_t * w ) +{ + hb_work_private_t * pv = w->private_data; + hb_mux_t * mux = pv->mux; + hb_job_t * job = pv->job; + hb_track_t * track; + int i; - if( job->pass == 0 || job->pass == 2 ) + hb_lock( mux->mutex ); + if ( --mux->ref == 0 ) { - struct stat sb; - uint64_t bytes_total, frames_total; + // Update state before closing muxer. Closing the muxer + // may initiate optimization which can take a while and + // we want the muxing state to be visible while this is + // happening. + if( job->pass == 0 || job->pass == 2 ) + { + /* Update the UI */ + hb_state_t state; + state.state = HB_STATE_MUXING; + state.param.muxing.progress = 0; + hb_set_state( job->h, &state ); + } -#define p state.param.muxing - /* Update the UI */ - hb_state_t state; - state.state = HB_STATE_MUXING; - p.progress = 0; - hb_set_state( job->h, &state ); -#undef p - m->end( m ); + if( mux->m ) + { + mux->m->end( mux->m ); + free( mux->m ); + } - if( !stat( job->file, &sb ) ) + // we're all done muxing -- print final stats and cleanup. + if( job->pass == 0 || job->pass == 2 ) { - hb_log( "mux: file size, %lld bytes", (uint64_t) sb.st_size ); + struct stat sb; + uint64_t bytes_total, frames_total; - bytes_total = 0; - frames_total = 0; - for( i = 0; i < hb_list_count( list ); i++ ) + if( !stat( job->file, &sb ) ) { - track = hb_list_item( list, i ); - hb_log( "mux: track %d, %lld bytes, %.2f kbps", - i, track->bytes, - 90000.0 * track->bytes / mux->pts / 125 ); - if( !i && ( job->vquality < 0.0 || job->vquality > 1.0 ) ) + hb_deep_log( 2, "mux: file size, %"PRId64" bytes", (uint64_t) sb.st_size ); + + bytes_total = 0; + frames_total = 0; + for( i = 0; i < mux->ntracks; ++i ) { - /* Video */ - hb_log( "mux: video bitrate error, %+lld bytes", - track->bytes - mux->pts * job->vbitrate * - 125 / 90000 ); + track = mux->track[i]; + hb_log( "mux: track %d, %"PRId64" frames, %"PRId64" bytes, %.2f kbps, fifo %d", + i, track->frames, track->bytes, + 90000.0 * track->bytes / mux->pts / 125, + track->mf.flen ); + if( !i && ( job->vquality < 0.0 || job->vquality > 1.0 ) ) + { + /* Video */ + hb_deep_log( 2, "mux: video bitrate error, %+"PRId64" bytes", + (int64_t)(track->bytes - mux->pts * job->vbitrate * 125 / 90000) ); + } + bytes_total += track->bytes; + frames_total += track->frames; + } + + if( bytes_total && frames_total ) + { + hb_deep_log( 2, "mux: overhead, %.2f bytes per frame", + (float) ( sb.st_size - bytes_total ) / + frames_total ); } - bytes_total += track->bytes; - frames_total += track->frames; } + } + + for( i = 0; i < mux->ntracks; ++i ) + { + track = mux->track[i]; + if( track->mux_data ) + { + free( track->mux_data ); + free( track->mf.fifo ); + } + free( track ); + } + hb_unlock( mux->mutex ); + hb_lock_close( &mux->mutex ); + free( mux ); + } + else + { + hb_unlock( mux->mutex ); + } + free( pv ); + w->private_data = NULL; +} - if( bytes_total && frames_total ) +static void mux_loop( void * _w ) +{ + hb_work_object_t * w = _w; + hb_work_private_t * pv = w->private_data; + hb_job_t * job = pv->job; + hb_buffer_t * buf_in; + + while ( !*job->die && w->status != HB_WORK_DONE ) + { + buf_in = hb_fifo_get_wait( w->fifo_in ); + if ( pv->mux->done ) + break; + if ( buf_in == NULL ) + continue; + if ( *job->die ) + { + if( buf_in ) { - hb_log( "mux: overhead, %.2f bytes per frame", - (float) ( sb.st_size - bytes_total ) / - frames_total ); + hb_buffer_close( &buf_in ); } + break; + } + + w->status = w->work( w, &buf_in, NULL ); + if( buf_in ) + { + hb_buffer_close( &buf_in ); } } +} + +hb_work_object_t * hb_muxer_init( hb_job_t * job ) +{ + hb_title_t * title = job->title; + int i; + hb_mux_t * mux = calloc( sizeof( hb_mux_t ), 1 ); + hb_work_object_t * w; + hb_work_object_t * muxer; + + mux->mutex = hb_lock_init(); - free( m ); + // set up to interleave track data in blocks of 1 video frame time. + // (the best case for buffering and playout latency). The container- + // specific muxers can reblock this into bigger chunks if necessary. + mux->interleave = 90000. * (double)job->vrate_base / (double)job->vrate; + mux->pts = mux->interleave; - for( i = 0; i < hb_list_count( list ); i++ ) + /* Get a real muxer */ + if( job->pass == 0 || job->pass == 2) { - track = hb_list_item( list, i ); - if( track->mux_data ) + switch( job->mux ) + { + case HB_MUX_MP4: + case HB_MUX_PSP: + case HB_MUX_IPOD: + mux->m = hb_mux_mp4_init( job ); + break; + case HB_MUX_AVI: + mux->m = hb_mux_avi_init( job ); + break; + case HB_MUX_OGM: + mux->m = hb_mux_ogm_init( job ); + break; + case HB_MUX_MKV: + mux->m = hb_mux_mkv_init( job ); + break; + default: + hb_error( "No muxer selected, exiting" ); + *job->die = 1; + return NULL; + } + /* Create file, write headers */ + if( mux->m ) { - free( track->mux_data ); + mux->m->init( mux->m ); } - free( track ); } - hb_list_close( &list ); - free( mux ); + /* Initialize the work objects that will receive fifo data */ + + muxer = hb_get_work( WORK_MUX ); + muxer->private_data = calloc( sizeof( hb_work_private_t ), 1 ); + muxer->private_data->job = job; + muxer->private_data->mux = mux; + mux->ref++; + muxer->private_data->track = mux->ntracks; + muxer->fifo_in = job->fifo_mpeg4; + add_mux_track( mux, job->mux_data, 1 ); + muxer->done = &muxer->private_data->mux->done; + + for( i = 0; i < hb_list_count( title->list_audio ); i++ ) + { + hb_audio_t *audio = hb_list_item( title->list_audio, i ); + + w = hb_get_work( WORK_MUX ); + w->private_data = calloc( sizeof( hb_work_private_t ), 1 ); + w->private_data->job = job; + w->private_data->mux = mux; + mux->ref++; + w->private_data->track = mux->ntracks; + w->fifo_in = audio->priv.fifo_out; + add_mux_track( mux, audio->priv.mux_data, 1 ); + w->done = &job->done; + hb_list_add( job->list_work, w ); + w->thread = hb_thread_init( w->name, mux_loop, w, HB_NORMAL_PRIORITY ); + } + + for( i = 0; i < hb_list_count( title->list_subtitle ); i++ ) + { + hb_subtitle_t *subtitle = hb_list_item( title->list_subtitle, i ); + + if (subtitle->config.dest != PASSTHRUSUB) + continue; + + w = hb_get_work( WORK_MUX ); + w->private_data = calloc( sizeof( hb_work_private_t ), 1 ); + w->private_data->job = job; + w->private_data->mux = mux; + mux->ref++; + w->private_data->track = mux->ntracks; + w->fifo_in = subtitle->fifo_out; + add_mux_track( mux, subtitle->mux_data, 0 ); + w->done = &job->done; + hb_list_add( job->list_work, w ); + w->thread = hb_thread_init( w->name, mux_loop, w, HB_NORMAL_PRIORITY ); + } + return muxer; } -hb_thread_t * hb_muxer_init( hb_job_t * job ) +// muxInit does nothing because the muxer has a special initializer +// that takes care of initializing all muxer work objects +static int muxInit( hb_work_object_t * w, hb_job_t * job ) { - hb_mux_t * mux = calloc( sizeof( hb_mux_t ), 1 ); - mux->job = job; - return hb_thread_init( "muxer", MuxerFunc, mux, - HB_NORMAL_PRIORITY ); + return 0; } + +hb_work_object_t hb_muxer = +{ + WORK_MUX, + "Muxer", + muxInit, + muxWork, + muxClose +}; +