X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fstream.c;h=538353e523023fc41479fbbeceb2b37dcd720c45;hb=033e32de9c380f54c7d1362a3979da205ebc3a29;hp=b50dff15e607d12a6a1547e44f3c76da9245025e;hpb=8d504c772777e38a76aa202d65f7d6c55c723f99;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/stream.c b/libhb/stream.c old mode 100755 new mode 100644 index b50dff15..538353e5 --- a/libhb/stream.c +++ b/libhb/stream.c @@ -89,7 +89,7 @@ typedef enum { } hb_stream_type_t; #define kMaxNumberVideoPIDS 1 -#define kMaxNumberAudioPIDS 15 +#define kMaxNumberAudioPIDS 31 #define kMaxNumberDecodeStreams (kMaxNumberVideoPIDS+kMaxNumberAudioPIDS) #define kMaxNumberPMTStreams 32 @@ -114,11 +114,12 @@ struct hb_stream_s int ts_pos[kMaxNumberDecodeStreams]; int8_t ts_skipbad[kMaxNumberDecodeStreams]; int8_t ts_streamcont[kMaxNumberDecodeStreams]; + uint8_t ts_pkt_summary[kMaxNumberDecodeStreams][8]; hb_buffer_t *fwrite_buf; /* PS buffer (set by hb_ts_stream_decode) */ int chapter; /* Chapter that we are currently in */ - uint64_t chapter_end; /* HB time that the current chapter ends */ + int64_t chapter_end; /* HB time that the current chapter ends */ /* * Stuff before this point is dynamic state updated as we read the @@ -275,9 +276,12 @@ static void ts_warn_helper( hb_stream_t *stream, char *log, va_list args ) } } +static void ts_warn( hb_stream_t*, char*, ... ) HB_WPRINTF(2,3); +static void ts_err( hb_stream_t*, int, char*, ... ) HB_WPRINTF(3,4); + static void ts_warn( hb_stream_t *stream, char *log, ... ) { - va_list args; + va_list args; va_start( args, log ); ts_warn_helper( stream, log, args ); va_end( args ); @@ -285,7 +289,7 @@ static void ts_warn( hb_stream_t *stream, char *log, ... ) static void ts_err( hb_stream_t *stream, int curstream, char *log, ... ) { - va_list args; + va_list args; va_start( args, log ); ts_warn_helper( stream, log, args ); va_end( args ); @@ -470,7 +474,7 @@ static int audio_inactive( hb_stream_t *stream, int indx ) **********************************************************************/ hb_stream_t * hb_stream_open( char *path, hb_title_t *title ) { - FILE *f = fopen( path, "r" ); + FILE *f = fopen( path, "rb" ); if ( f == NULL ) { hb_log( "hb_stream_open: open %s failed", path ); @@ -751,10 +755,10 @@ static const uint8_t *next_packet( hb_stream_t *stream ) off_t pos2 = align_to_next_packet(stream); if ( pos2 == 0 ) { - hb_log( "next_packet: eof while re-establishing sync @ %lld", pos ); + hb_log( "next_packet: eof while re-establishing sync @ %"PRId64, pos ); return NULL; } - ts_warn( stream, "next_packet: sync lost @ %lld, regained after %lld bytes", + ts_warn( stream, "next_packet: sync lost @ %"PRId64", regained after %"PRId64" bytes", pos, pos2 ); } } @@ -1025,12 +1029,12 @@ static struct pts_pos hb_sample_pts(hb_stream_t *stream, uint64_t fpos) buf = hb_ts_stream_getPEStype( stream, stream->ts_video_pids[0] ); if ( buf == NULL ) { - hb_log("hb_sample_pts: couldn't find video packet near %llu", fpos); + hb_log("hb_sample_pts: couldn't find video packet near %"PRIu64, fpos); return pp; } if ( ( buf[7] >> 7 ) != 1 ) { - hb_log("hb_sample_pts: no PTS in video packet near %llu", fpos); + hb_log("hb_sample_pts: no PTS in video packet near %"PRIu64, fpos); return pp; } pp.pts = ( ( (uint64_t)buf[9] >> 1 ) & 7 << 30 ) | @@ -1202,61 +1206,40 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) return hb_ts_stream_decode( src_stream, b ); } -/*********************************************************************** - * hb_stream_seek_chapter - *********************************************************************** - * - **********************************************************************/ int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num ) { - AVFormatContext *ic = stream->ffmpeg_ic; - uint64_t end_offset = 0; - uint64_t start_offset = 0; - uint64_t pos = 0; - hb_chapter_t *chapter = NULL; - int i; - if( !stream || !stream->title ) - { - return 0; - } if ( stream->hb_stream_type != ffmpeg ) { // currently meaningliess for transport and program streams return 1; } - - for( i = 0; i < chapter_num; i++) + if ( !stream || !stream->title || + chapter_num > hb_list_count( stream->title->list_chapter ) ) { - chapter = hb_list_item( stream->title->list_chapter, - i ); - - if( chapter ) - { - /* - * Seeking to a chapter means that we are in that chapter, - * so track which chapter we are in so that we can output - * the correct chapter numbers in buf->new_chap - */ - start_offset = end_offset; - end_offset += chapter->duration; - stream->chapter = i; - stream->chapter_end = end_offset; - } else { - return 0; - } + return 0; } - /* - * Is the the correct way to convert timebases? It seems to get it pretty - * much right - plus a few seconds, which is odd. - */ - pos = ((start_offset * AV_TIME_BASE) / 90000); + int64_t sum_dur = 0; + hb_chapter_t *chapter = NULL; + int i; + for ( i = 0; i < chapter_num; ++i) + { + chapter = hb_list_item( stream->title->list_chapter, i ); + sum_dur += chapter->duration; + } + stream->chapter = chapter_num - 1; + stream->chapter_end = sum_dur; - hb_deep_log( 2, "Seeking to chapter %d time (starts: %lld ends %lld) AV pos %lld", chapter_num-1, start_offset, end_offset, pos); + int64_t pos = ( ( ( sum_dur - chapter->duration ) * AV_TIME_BASE ) / 90000 ); - av_seek_frame( ic, -1, pos, 0); + hb_deep_log( 2, "Seeking to chapter %d: starts %"PRId64", ends %"PRId64", AV pos %"PRId64, + chapter_num, sum_dur - chapter->duration, sum_dur, pos); + if ( chapter_num > 1 && pos > 0 ) + { + av_seek_frame( stream->ffmpeg_ic, -1, pos, 0); + } return 1; } @@ -1712,7 +1695,7 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, switch (dp[0]) { case 5: // Registration descriptor - stream->ts_format_id[esindx] = (dp[2] << 24) | (dp[3] << 16) | + stream->ts_format_id[esindx+1] = (dp[2] << 24) | (dp[3] << 16) | (dp[4] << 8) | dp[5]; break; @@ -1720,6 +1703,10 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, stream->a52_info[esindx].lang_code = lang_to_code(lang_for_code2((const char *)&dp[2])); break; + case 0x6a: // DVB AC-3 descriptor + stream->ts_stream_type[esindx+1] = 0x81; + break; + default: break; } @@ -1783,33 +1770,35 @@ int decode_program_map(hb_stream_t* stream) if ( index_of_pid( elementary_PID, stream ) < 0 ) { - // already have this pid - do nothing - } - if (stream->ts_number_video_pids == 0 && st2codec[stream_type].kind == V ) - { - stream->ts_video_pids[0] = elementary_PID; - stream->ts_stream_type[0] = stream_type; - stream->ts_number_video_pids = 1; - } - else - { - // Defined audio stream types are 0x81 for AC-3/A52 audio and 0x03 - // for mpeg audio. But content producers seem to use other - // values (0x04 and 0x06 have both been observed) so at this point - // we say everything that isn't a video pid is audio then at the end - // of hb_stream_title_scan we'll figure out which are really audio - // by looking at the PES headers. - i = stream->ts_number_audio_pids; - if (i < kMaxNumberAudioPIDS) + // don't have this pid yet + if (stream->ts_number_video_pids == 0 && + st2codec[stream_type].kind == V ) { - stream->ts_audio_pids[i] = elementary_PID; - stream->ts_stream_type[1 + i] = stream_type; - if (ES_info_length > 0) + stream->ts_video_pids[0] = elementary_PID; + stream->ts_stream_type[0] = stream_type; + stream->ts_number_video_pids = 1; + } + else + { + // Defined audio stream types are 0x81 for AC-3/A52 audio + // and 0x03 for mpeg audio. But content producers seem to + // use other values (0x04 and 0x06 have both been observed) + // so at this point we say everything that isn't a video + // pid is audio then at the end of hb_stream_title_scan + // we'll figure out which are really audio by looking at + // the PES headers. + i = stream->ts_number_audio_pids; + if (i < kMaxNumberAudioPIDS) { - decode_element_descriptors(stream, i, ES_info_buf, - ES_info_length); + stream->ts_audio_pids[i] = elementary_PID; + stream->ts_stream_type[1 + i] = stream_type; + if (ES_info_length > 0) + { + decode_element_descriptors(stream, i, ES_info_buf, + ES_info_length); + } + ++stream->ts_number_audio_pids; } - ++stream->ts_number_audio_pids; } } @@ -1818,7 +1807,7 @@ int decode_program_map(hb_stream_t* stream) free(ES_info_buf); if (cur_pos >= section_length - 4 /* stop before the CRC */) - done_reading_stream_types = 1; + done_reading_stream_types = 1; } free(descriptor_buf); @@ -2007,7 +1996,13 @@ static int decode_PAT(const uint8_t *buf, hb_stream_t *stream) static void hb_ts_stream_find_pids(hb_stream_t *stream) { - // align to first packet + // To be different from every other broadcaster in the world, New Zealand TV + // changes PMTs (and thus video & audio PIDs) when 'programs' change. Since + // we may have the tail of the previous program at the beginning of this + // file, take our PMT from the middle of the file. + fseeko(stream->file_handle, 0, SEEK_END); + uint64_t fsize = ftello(stream->file_handle); + fseeko(stream->file_handle, fsize >> 1, SEEK_SET); align_to_next_packet(stream); // Read the Transport Stream Packets (188 bytes each) looking at first for PID 0 (the PAT PID), then decode that @@ -2282,11 +2277,31 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) int continuity = (buf[3] & 0xF); if ( continuity == stream->ts_streamcont[curstream] ) { - // we got a duplicate packet (usually used to introduce - // a PCR when one is needed). The only thing that can - // change in the dup is the PCR which we grabbed above - // so ignore the rest. - continue; + // Spliced transport streams can have duplicate + // continuity counts at the splice boundary. + // Test to see if the packet is really a duplicate + // by comparing packet summaries to see if they + // match. + uint8_t summary[8]; + + summary[0] = adaption; + summary[1] = adapt_len; + if (adapt_len + 4 + 6 + 9 <= 188) + { + memcpy(&summary[2], buf+4+adapt_len+9, 6); + } + else + { + memset(&summary[2], 0, 6); + } + if ( memcmp( summary, stream->ts_pkt_summary[curstream], 8 ) == 0 ) + { + // we got a duplicate packet (usually used to introduce + // a PCR when one is needed). The only thing that can + // change in the dup is the PCR which we grabbed above + // so ignore the rest. + continue; + } } if ( !start && (stream->ts_streamcont[curstream] != -1) && !stream->ts_skipbad[curstream] && @@ -2296,10 +2311,26 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) (int)continuity, (stream->ts_streamcont[curstream] + 1) & 0xf ); stream->ts_streamcont[curstream] = continuity; - continue; - } - stream->ts_streamcont[curstream] = continuity; - } + continue; + } + stream->ts_streamcont[curstream] = continuity; + + // Save a summary of this packet for later duplicate + // testing. The summary includes some header information + // and payload bytes. Should be enough to detect + // non-duplicates. + stream->ts_pkt_summary[curstream][0] = adaption; + stream->ts_pkt_summary[curstream][1] = adapt_len; + if (adapt_len + 4 + 6 + 9 <= 188) + { + memcpy(&stream->ts_pkt_summary[curstream][2], + buf+4+adapt_len+9, 6); + } + else + { + memset(&stream->ts_pkt_summary[curstream][2], 0, 6); + } + } /* If we get here the packet is valid - process its data */ @@ -2504,9 +2535,6 @@ static int ffmpeg_codec_param( hb_stream_t *stream, int stream_index ) // (the original scan stream was closed and no longer exists). static void ffmpeg_remap_stream( hb_stream_t *stream, hb_title_t *title ) { - // tell ffmpeg we want a pts on every frame it returns - stream->ffmpeg_ic->flags |= AVFMT_FLAG_GENPTS; - // all the video & audio came from the same stream so remapping // the video's stream slot takes care of everything. int slot = title->video_codec_param & (ffmpeg_sl_size - 1); @@ -2564,6 +2592,7 @@ static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title ) stream->hb_stream_type = ffmpeg; stream->ffmpeg_pkt = malloc(sizeof(*stream->ffmpeg_pkt)); av_init_packet( stream->ffmpeg_pkt ); + stream->chapter_end = INT64_MAX; if ( title ) { @@ -2727,7 +2756,7 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) AVChapter *m; uint64_t duration_sum = 0; for( i = 0; i < ic->nb_chapters; i++ ) - if( m = ic->chapters[i] ) + if( ( m = ic->chapters[i] ) != NULL ) { hb_chapter_t * chapter; chapter = calloc( sizeof( hb_chapter_t ), 1 ); @@ -2738,7 +2767,7 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) chapter->minutes = ( ( chapter->duration / 90000 ) % 3600 ) / 60; chapter->seconds = ( chapter->duration / 90000 ) % 60; strcpy( chapter->title, m->title ); - hb_deep_log( 2, "Added chapter %i, name='%s', dur=%llu, (%02i:%02i:%02i)", + hb_deep_log( 2, "Added chapter %i, name='%s', dur=%"PRIu64", (%02i:%02i:%02i)", chapter->index, chapter->title, chapter->duration, chapter->hours, chapter->minutes, chapter->seconds ); @@ -2785,7 +2814,7 @@ static int ffmpeg_is_keyframe( hb_stream_t *stream ) // we do it ourselves here. The decoder gets messed up if it // doesn't get a SEQ header first so we consider that to be a key frame. pkt = stream->ffmpeg_pkt->data; - if ( pkt[0] && pkt[1] && pkt[2] == 1 && pkt[3] == 0x0f ) + if ( !pkt[0] && !pkt[1] && pkt[2] == 1 && pkt[3] == 0x0f ) return 1; return 0; @@ -2901,48 +2930,26 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) /* * Check to see whether this video buffer is on a chapter - * boundary, if so mark it as such in the buffer. The chapters for - * a stream have a simple duration for each chapter. So we keep - * track of what chapter we are in currently, and when it is due - * to end. + * boundary, if so mark it as such in the buffer then advance + * chapter_end to the end of the next chapter. + * If there are no chapters, chapter_end is always initialized to INT64_MAX + * (roughly 3 million years at our 90KHz clock rate) so the test + * below handles both the chapters & no chapters case. */ - hb_deep_log( 3, "title=0x%x, job=0x%x, chapter_markers=%d, time=%lld, chapter=%d, end_chapter=%lld", - stream->title, - stream->title ? (stream->title->job ? stream->title->job : 0x0) : 0x0, - stream->title ? (stream->title->job ? stream->title->job->chapter_markers : 2) : 0x0, - buf->start, stream->chapter, stream->chapter_end); - - if( stream->title && - stream->title->job && - stream->title->job->chapter_markers && - buf->id == stream->ffmpeg_video_id && - buf->start >= stream->chapter_end ) + if ( buf->id == stream->ffmpeg_video_id && buf->start >= stream->chapter_end ) { - hb_chapter_t *chapter = NULL; - - /* - * Store when this chapter ends using HB time. - */ - chapter = hb_list_item( stream->title->list_chapter, - stream->chapter ); - + hb_chapter_t *chapter = hb_list_item( stream->title->list_chapter, + stream->chapter+1 ); if( chapter ) { - buf->new_chap = stream->chapter + 2; - - hb_deep_log( 2, "Starting chapter %i at %lld", buf->new_chap, buf->start); - hb_chapter_t *nextChapter = NULL; - nextChapter = hb_list_item( stream->title->list_chapter, - stream->chapter + 1 ); - if( nextChapter ) - stream->chapter_end += nextChapter->duration; stream->chapter++; - hb_deep_log( 2, "Looking for chapter %i at %lld", stream->chapter + 2, stream->chapter_end ); + stream->chapter_end += chapter->duration; + buf->new_chap = stream->chapter + 1; + hb_deep_log( 2, "ffmpeg_read starting chapter %i at %"PRId64, + buf->new_chap, buf->start); } else { - /* - * Must have run out of chapters, stop looking. - */ - stream->chapter_end = -1; + // Must have run out of chapters, stop looking. + stream->chapter_end = INT64_MAX; } } else { buf->new_chap = 0; @@ -2957,7 +2964,7 @@ static int ffmpeg_seek( hb_stream_t *stream, float frac ) if ( frac > 0. ) { int64_t pos = (double)ic->duration * (double)frac; - if ( ic->start_time != AV_NOPTS_VALUE ) + if ( ic->start_time != AV_NOPTS_VALUE && ic->start_time > 0 ) { pos += ic->start_time; }