X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fstream.c;h=998aac4c6f3d702d3ce87b9adcecc8fef76cfc20;hb=f93c2a10768843b2f8900695bb1ab276ffc168ab;hp=92907e1ef5f767074da8923cf3d1d650c733bec3;hpb=139bf384a85a15e3bd752d378c6232c7d70a4b66;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/stream.c b/libhb/stream.c index 92907e1e..998aac4c 100644 --- 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,6 +114,7 @@ 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) */ @@ -206,6 +207,7 @@ static void ffmpeg_close( hb_stream_t *d ); static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ); static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ); static int ffmpeg_seek( hb_stream_t *stream, float frac ); +static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts ); /* * streams have a bunch of state that's learned during the scan. We don't @@ -275,9 +277,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 +290,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 ); @@ -349,9 +354,16 @@ static int hb_stream_check_for_ts(const uint8_t *buf) static int hb_stream_check_for_ps(const uint8_t *buf) { - // program streams should start with a PACK then some other mpeg start - // code (usually a SYS but that might be missing if we only have a clip). - return check_ps_sync(buf) && check_ps_sc(buf); + // program streams should start with a PACK then some other mpeg start + // code (usually a SYS but that might be missing if we only have a clip). + int offset = 0; + + for ( offset = 0; offset < 8*1024-24; ++offset ) + { + if ( check_ps_sync( &buf[offset] ) && check_ps_sc( &buf[offset] ) ) + return 1; + } + return 0; } static int hb_stream_check_for_dvd_ps(const uint8_t *buf) @@ -365,6 +377,7 @@ static int hb_stream_check_for_dvd_ps(const uint8_t *buf) static int hb_stream_get_type(hb_stream_t *stream) { uint8_t buf[2048*4]; + int i = 64; if ( fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) ) { @@ -390,12 +403,17 @@ static int hb_stream_get_type(hb_stream_t *stream) stream->hb_stream_type = dvd_program; return 1; } - if ( hb_stream_check_for_ps(buf) != 0 ) + do { - hb_log("file is MPEG Program Stream"); - stream->hb_stream_type = program; - return 1; - } + if ( hb_stream_check_for_ps(buf) != 0 ) + { + hb_log("file is MPEG Program Stream"); + stream->hb_stream_type = program; + return 1; + } + // Seek back to handle start codes that run over end of last buffer + fseek( stream->file_handle, -28, SEEK_CUR ); + } while ( --i && fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) ); } return 0; } @@ -648,6 +666,7 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) // 'Barebones Title' hb_title_t *aTitle = hb_title_init( stream->path, 0 ); + aTitle->type = HB_STREAM_TYPE; aTitle->index = 1; // Copy part of the stream path to the title name @@ -751,10 +770,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 +1044,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 ) | @@ -1186,6 +1205,37 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) ep = b->data + b->alloc; } *cp++ = c; + // Non-video streams can emulate start codes, so we need + // to inspect PES packets and skip over their data + // sections to avoid mis-detection of the next pack header. + if ( ( strt_code >> 8 ) == 0x000001 && + ( strt_code & 0xff ) >= 0xbb ) + { + int len = 0; + c = getc_unlocked( src_stream->file_handle ); + if ( c == EOF ) + break; + len = c << 8; + c = getc_unlocked( src_stream->file_handle ); + if ( c == EOF ) + break; + len |= c; + if ( cp+len+2 > ep ) + { + // need to expand the buffer + int curSize = cp - b->data; + if ( curSize * 2 > curSize+len+2 ) + hb_buffer_realloc( b, curSize * 2 ); + else + hb_buffer_realloc( b, curSize + len + 2 ); + cp = b->data + curSize; + ep = b->data + b->alloc; + } + *cp++ = len >> 8; + *cp++ = len & 0xff; + fread( cp, 1, len, src_stream->file_handle ); + cp += len; + } } funlockfile( src_stream->file_handle ); @@ -1195,7 +1245,8 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) if ( c != EOF ) { fseeko( src_stream->file_handle, -4, SEEK_CUR ); - b->size -= 4; + // Only 3 of the 4 bytes read were added to the buffer. + b->size -= 3; } return 1; } @@ -1217,7 +1268,7 @@ int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num ) } int64_t sum_dur = 0; - hb_chapter_t *chapter; + hb_chapter_t *chapter = NULL; int i; for ( i = 0; i < chapter_num; ++i) { @@ -1229,13 +1280,24 @@ int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num ) int64_t pos = ( ( ( sum_dur - chapter->duration ) * AV_TIME_BASE ) / 90000 ); - hb_deep_log( 2, "Seeking to chapter %d: starts %lld, ends %lld, AV pos %lld", + 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); } + else + { + // ffmpeg has a bug that causes the first PTS after + // av_find_stream_info() is called to be incorrect. + // av_find_stream_info is called whenever opening a file + // with ffmpeg. av_seek_frame clears the condition + // that causes the problem. since hb_stream_seek_chapter + // is called before we start reading, make sure + // we do a seek here. + av_seek_frame( stream->ffmpeg_ic, -1, 0LL, AVSEEK_FLAG_BACKWARD ); + } return 1; } @@ -1304,6 +1366,15 @@ int hb_stream_seek( hb_stream_t * stream, float f ) return 1; } +int hb_stream_seek_ts( hb_stream_t * stream, int64_t ts ) +{ + if ( stream->hb_stream_type == ffmpeg ) + { + return ffmpeg_seek_ts( stream, ts ); + } + return -1; +} + static const char* make_upper( const char* s ) { static char name[8]; @@ -1691,7 +1762,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; @@ -1699,6 +1770,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; } @@ -1762,33 +1837,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_video_pids[0] = elementary_PID; + stream->ts_stream_type[0] = stream_type; + stream->ts_number_video_pids = 1; + } + else { - stream->ts_audio_pids[i] = elementary_PID; - stream->ts_stream_type[1 + i] = stream_type; - if (ES_info_length > 0) + // 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; } } @@ -1797,7 +1874,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); @@ -2039,7 +2116,7 @@ static void hb_ts_stream_find_pids(hb_stream_t *stream) } } // Keep going until we have a complete set of PIDs - if ((stream->ts_number_video_pids > 0) && (stream->ts_number_audio_pids > 0)) + if (stream->ts_number_video_pids > 0) break; } @@ -2267,11 +2344,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] && @@ -2281,10 +2378,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 */ @@ -2656,6 +2769,7 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) // 'Barebones Title' hb_title_t *title = hb_title_init( stream->path, 0 ); + title->type = HB_STREAM_TYPE; title->index = 1; // Copy part of the stream path to the title name @@ -2721,7 +2835,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 ); @@ -2768,7 +2882,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; @@ -2881,6 +2995,10 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) { buf->start = buf->renderOffset; } + else if ( buf->renderOffset == -1 && buf->start >= 0 ) + { + buf->renderOffset = buf->start; + } /* * Check to see whether this video buffer is on a chapter @@ -2893,12 +3011,13 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) if ( buf->id == stream->ffmpeg_video_id && buf->start >= stream->chapter_end ) { hb_chapter_t *chapter = hb_list_item( stream->title->list_chapter, - ++stream->chapter ); + stream->chapter+1 ); if( chapter ) { + stream->chapter++; stream->chapter_end += chapter->duration; buf->new_chap = stream->chapter + 1; - hb_deep_log( 2, "ffmpeg_read starting chapter %i at %lld", + 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. @@ -2930,3 +3049,16 @@ static int ffmpeg_seek( hb_stream_t *stream, float frac ) } return 1; } + +// Assumes that we are always seeking forward +static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts ) +{ + AVFormatContext *ic = stream->ffmpeg_ic; + int64_t pos; + + pos = ts * AV_TIME_BASE / 90000; + stream->need_keyframe = 1; + // Seek to the nearest timestamp before that requested where + // there is an I-frame + return av_seek_frame( ic, -1, pos, AVSEEK_FLAG_BACKWARD ); +}