X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fstream.c;h=998aac4c6f3d702d3ce87b9adcecc8fef76cfc20;hb=f93c2a10768843b2f8900695bb1ab276ffc168ab;hp=4b58bda41d165491816785b9a73d3587c248f4f7;hpb=8a47d343e5641fbce397c4e223d3c49eefc18a0a;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/stream.c b/libhb/stream.c old mode 100755 new mode 100644 index 4b58bda4..998aac4c --- a/libhb/stream.c +++ b/libhb/stream.c @@ -1,25 +1,95 @@ /* $Id$ This file is part of the HandBrake source code. - Homepage: . + Homepage: . It may be used under the terms of the GNU General Public License. */ +#include +#include +#include + #include "hb.h" +#include "hbffmpeg.h" #include "lang.h" #include "a52dec/a52.h" - -#include +#include "mp4v2/mp4v2.h" #define min(a, b) a < b ? a : b +/* + * This table defines how ISO MPEG stream type codes map to HandBrake + * codecs. It is indexed by the 8 bit stream type and contains the codec + * worker object id and a parameter for that worker proc (ignored except + * for the ffmpeg-based codecs in which case it is the ffmpeg codec id). + * + * Entries with a worker proc id of 0 or a kind of 'U' indicate that HB + * doesn't handle the stream type. + */ +typedef struct { + enum { N, U, A, V } kind; /* not handled / unknown / audio / video */ + int codec; /* HB worker object id of codec */ + int codec_param; /* param for codec (usually ffmpeg codec id) */ + const char* name; /* description of type */ +} stream2codec_t; + +#define st(id, kind, codec, codec_param, name) \ + [id] = { kind, codec, codec_param, name } + +static const stream2codec_t st2codec[256] = { + st(0x01, V, WORK_DECMPEG2, 0, "MPEG1"), + st(0x02, V, WORK_DECMPEG2, 0, "MPEG2"), + st(0x03, A, HB_ACODEC_MPGA, CODEC_ID_MP2, "MPEG1"), + st(0x04, A, HB_ACODEC_MPGA, CODEC_ID_MP2, "MPEG2"), + st(0x05, N, 0, 0, "ISO 13818-1 private section"), + st(0x06, U, 0, 0, "ISO 13818-1 PES private data"), + st(0x07, N, 0, 0, "ISO 13522 MHEG"), + st(0x08, N, 0, 0, "ISO 13818-1 DSM-CC"), + st(0x09, N, 0, 0, "ISO 13818-1 auxiliary"), + st(0x0a, N, 0, 0, "ISO 13818-6 encap"), + st(0x0b, N, 0, 0, "ISO 13818-6 DSM-CC U-N msgs"), + st(0x0c, N, 0, 0, "ISO 13818-6 Stream descriptors"), + st(0x0d, N, 0, 0, "ISO 13818-6 Sections"), + st(0x0e, N, 0, 0, "ISO 13818-1 auxiliary"), + st(0x0f, A, HB_ACODEC_MPGA, CODEC_ID_AAC, "ISO 13818-7 AAC Audio"), + st(0x10, V, WORK_DECAVCODECV, CODEC_ID_MPEG4, "MPEG4"), + st(0x11, A, HB_ACODEC_MPGA, CODEC_ID_AAC_LATM, "MPEG4 LATM AAC"), + st(0x12, U, 0, 0, "MPEG4 generic"), + + st(0x14, N, 0, 0, "ISO 13818-6 DSM-CC download"), + + st(0x1b, V, WORK_DECAVCODECV, CODEC_ID_H264, "H.264"), + + st(0x80, N, 0, 0, "DigiCipher II Video"), + st(0x81, A, HB_ACODEC_AC3, 0, "AC-3"), + st(0x82, A, HB_ACODEC_DCA, 0, "HDMV DTS"), + st(0x83, A, HB_ACODEC_LPCM, 0, "LPCM"), + st(0x84, A, 0, 0, "SDDS"), + st(0x85, U, 0, 0, "ATSC Program ID"), + st(0x86, A, HB_ACODEC_DCA, 0, "DTS-HD"), + st(0x87, A, 0, 0, "E-AC-3"), + + st(0x8a, A, HB_ACODEC_DCA, 0, "DTS"), + + st(0x91, A, HB_ACODEC_AC3, 0, "AC-3"), + st(0x92, N, 0, 0, "Subtitle"), + + st(0x94, A, 0, 0, "SDDS"), + st(0xa0, V, 0, 0, "MSCODEC"), + + st(0xea, V, WORK_DECAVCODECV, CODEC_ID_VC1, "VC1"), +}; +#undef st + typedef enum { hb_stream_type_unknown = 0, - hb_stream_type_transport, - hb_stream_type_program + transport, + program, + dvd_program, + ffmpeg } hb_stream_type_t; #define kMaxNumberVideoPIDS 1 -#define kMaxNumberAudioPIDS 15 +#define kMaxNumberAudioPIDS 31 #define kMaxNumberDecodeStreams (kMaxNumberVideoPIDS+kMaxNumberAudioPIDS) #define kMaxNumberPMTStreams 32 @@ -30,19 +100,26 @@ struct hb_stream_s int errors; /* total errors so far */ int last_error_frame; /* frame # at last error message */ int last_error_count; /* # errors at last error message */ + int packetsize; /* Transport Stream packet size */ - int64_t ts_lastpcr; /* the last pcr we found in the TS stream */ - int64_t ts_nextpcr; /* the next pcr to put in a PS packet */ + uint8_t need_keyframe; // non-zero if want to start at a keyframe + uint8_t ts_found_pcr; // non-zero if we've found at least one input pcr + int ts_pcr_out; // sequence number of most recent output pcr + int ts_pcr_in; // sequence number of most recent input pcr + int64_t ts_pcr; // most recent input pcr + int64_t ts_pcrhist[4]; // circular buffer of output pcrs - uint8_t *ts_buf[kMaxNumberDecodeStreams]; + uint8_t *ts_packet; /* buffer for one TS packet */ + hb_buffer_t *ts_buf[kMaxNumberDecodeStreams]; int ts_pos[kMaxNumberDecodeStreams]; - int8_t ts_foundfirst[kMaxNumberDecodeStreams]; int8_t ts_skipbad[kMaxNumberDecodeStreams]; int8_t ts_streamcont[kMaxNumberDecodeStreams]; - int8_t ts_start[kMaxNumberDecodeStreams]; + uint8_t ts_pkt_summary[kMaxNumberDecodeStreams][8]; - uint8_t *fwrite_buf; /* PS buffer (set by hb_ts_stream_decode) */ - uint8_t *fwrite_buf_orig; /* PS buffer start (set by hb_ts_stream_decode) */ + hb_buffer_t *fwrite_buf; /* PS buffer (set by hb_ts_stream_decode) */ + + int chapter; /* Chapter that we are currently in */ + int64_t chapter_end; /* HB time that the current chapter ends */ /* * Stuff before this point is dynamic state updated as we read the @@ -50,19 +127,31 @@ struct hb_stream_s * we learn during the initial scan but cache so it can be * reused during the conversion read. */ - int16_t ts_video_pids[kMaxNumberVideoPIDS]; - int16_t ts_audio_pids[kMaxNumberAudioPIDS]; - uint8_t ts_number_video_pids; uint8_t ts_number_audio_pids; + uint8_t ts_flags; // stream characteristics: +#define TS_HAS_PCR (1 << 0) // at least one PCR seen +#define TS_HAS_RAP (1 << 1) // Random Access Point bit seen +#define TS_HAS_RSEI (1 << 2) // "Restart point" SEI seen + uint8_t ts_IDRs; // # IDRs found during duration scan + + int16_t ts_video_pids[kMaxNumberVideoPIDS]; + int16_t ts_audio_pids[kMaxNumberAudioPIDS]; - uint8_t ts_streamid[kMaxNumberDecodeStreams]; - uint8_t ts_audio_stream_type[kMaxNumberDecodeStreams]; + uint32_t ts_format_id[kMaxNumberDecodeStreams]; +#define TS_FORMAT_ID_AC3 (('A' << 24) | ('C' << 16) | ('-' << 8) | '3') + uint8_t ts_stream_type[kMaxNumberDecodeStreams]; + uint8_t ts_multiplexed[kMaxNumberDecodeStreams]; char *path; FILE *file_handle; - hb_stream_type_t stream_type; - int opentype; + hb_stream_type_t hb_stream_type; + hb_title_t *title; + + AVFormatContext *ffmpeg_ic; + AVPacket *ffmpeg_pkt; + double ffmpeg_tsconv[MAX_STREAMS]; + uint8_t ffmpeg_video_id; struct { int lang_code; @@ -106,12 +195,19 @@ struct hb_stream_s static void hb_stream_duration(hb_stream_t *stream, hb_title_t *inTitle); static void hb_ts_stream_init(hb_stream_t *stream); static void hb_ts_stream_find_pids(hb_stream_t *stream); -static int hb_ts_stream_decode(hb_stream_t *stream, uint8_t *obuf); +static int hb_ts_stream_decode(hb_stream_t *stream, hb_buffer_t *obuf); static void hb_ts_stream_reset(hb_stream_t *stream); static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, int aud_pid_index); static void hb_ps_stream_find_audio_ids(hb_stream_t *stream, hb_title_t *title); -static off_t align_to_next_packet(FILE* f); +static off_t align_to_next_packet(hb_stream_t *stream); + +static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title ); +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 @@ -146,7 +242,65 @@ static void hb_stream_state_delete( hb_stream_t *ss ) free( ss ); } -static inline int check_ps_sync(const uint8_t *buf) +/* + * logging routines. + * these frontend hb_log because transport streams can have a lot of errors + * so we want to rate limit messages. this routine limits the number of + * messages to at most one per minute of video. other errors that occur + * during the minute are counted & the count is output with the next + * error msg we print. + */ +static void ts_warn_helper( hb_stream_t *stream, char *log, va_list args ) +{ + // limit error printing to at most one per minute of video (at 30fps) + ++stream->errors; + if ( stream->frames - stream->last_error_frame >= 30*60 ) + { + char msg[256]; + + vsnprintf( msg, sizeof(msg), log, args ); + + if ( stream->errors - stream->last_error_count < 10 ) + { + hb_log( "stream: error near frame %d: %s", stream->frames, msg ); + } + else + { + int Edelta = stream->errors - stream->last_error_count; + double Epcnt = (double)Edelta * 100. / + (stream->frames - stream->last_error_frame); + hb_log( "stream: %d new errors (%.0f%%) up to frame %d: %s", + Edelta, Epcnt, stream->frames, msg ); + } + stream->last_error_frame = stream->frames; + stream->last_error_count = stream->errors; + } +} + +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_start( args, log ); + ts_warn_helper( stream, log, args ); + va_end( args ); +} + +static void ts_err( hb_stream_t *stream, int curstream, char *log, ... ) +{ + va_list args; + va_start( args, log ); + ts_warn_helper( stream, log, args ); + va_end( args ); + + stream->ts_skipbad[curstream] = 1; + stream->ts_pos[curstream] = 0; + stream->ts_streamcont[curstream] = -1; +} + +static int check_ps_sync(const uint8_t *buf) { // a legal MPEG program stream must start with a Pack header in the // first four bytes. @@ -154,39 +308,68 @@ static inline int check_ps_sync(const uint8_t *buf) (buf[2] == 0x01) && (buf[3] == 0xba); } -static inline int check_ts_sync(const uint8_t *buf) +static int check_ps_sc(const uint8_t *buf) +{ + // a legal MPEG program stream must start with a Pack followed by a + // some other start code. If we've already verified the pack, this skip + // it and checks for a start code prefix. + int pos = 14 + ( buf[13] & 0x7 ); // skip over the PACK + return (buf[pos+0] == 0x00) && (buf[pos+1] == 0x00) && (buf[pos+2] == 0x01); +} + +static int check_ts_sync(const uint8_t *buf) { // must have initial sync byte, no scrambling & a legal adaptation ctrl return (buf[0] == 0x47) && ((buf[3] >> 6) == 0) && ((buf[3] >> 4) > 0); } -static inline int have_ts_sync(const uint8_t *buf) +static int have_ts_sync(const uint8_t *buf, int psize) { - return check_ts_sync(&buf[0*188]) && check_ts_sync(&buf[1*188]) && - check_ts_sync(&buf[2*188]) && check_ts_sync(&buf[3*188]) && - check_ts_sync(&buf[4*188]) && check_ts_sync(&buf[5*188]) && - check_ts_sync(&buf[6*188]) && check_ts_sync(&buf[7*188]); + return check_ts_sync(&buf[0*psize]) && check_ts_sync(&buf[1*psize]) && + check_ts_sync(&buf[2*psize]) && check_ts_sync(&buf[3*psize]) && + check_ts_sync(&buf[4*psize]) && check_ts_sync(&buf[5*psize]) && + check_ts_sync(&buf[6*psize]) && check_ts_sync(&buf[7*psize]); } static int hb_stream_check_for_ts(const uint8_t *buf) { // transport streams should have a sync byte every 188 bytes. - // search the first KB of buf looking for at least 8 consecutive + // search the first 8KB of buf looking for at least 8 consecutive // correctly located sync patterns. int offset = 0; - for ( offset = 0; offset < 1024; ++offset ) + for ( offset = 0; offset < 8*1024-8*188; ++offset ) { - if ( have_ts_sync( &buf[offset]) ) - return 1; + if ( have_ts_sync( &buf[offset], 188) ) + return 188 | (offset << 8); + if ( have_ts_sync( &buf[offset], 192) ) + return 192 | (offset << 8); + if ( have_ts_sync( &buf[offset], 204) ) + return 204 | (offset << 8); + if ( have_ts_sync( &buf[offset], 208) ) + return 208 | (offset << 8); } return 0; } static int hb_stream_check_for_ps(const uint8_t *buf) { - // program streams should have a Pack header every 2048 bytes. - // check that we have 4 of these. + // 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) +{ + // DVD program streams should have a Pack header every 2048 bytes. + // check that we have 4 of these in a row. return check_ps_sync(&buf[0*2048]) && check_ps_sync(&buf[1*2048]) && check_ps_sync(&buf[2*2048]) && check_ps_sync(&buf[3*2048]); } @@ -194,22 +377,43 @@ static int hb_stream_check_for_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) ) { - if ( hb_stream_check_for_ts(buf) != 0 ) + int psize; + if ( ( psize = hb_stream_check_for_ts(buf) ) != 0 ) { - hb_log("file is MPEG Transport Stream"); - stream->stream_type = hb_stream_type_transport; + int offset = psize >> 8; + psize &= 0xff; + hb_log("file is MPEG Transport Stream with %d byte packets" + " offset %d bytes", psize, offset); + stream->packetsize = psize; + stream->hb_stream_type = transport; hb_ts_stream_init(stream); + if ( !stream->ts_number_video_pids || !stream->ts_number_audio_pids ) + { + return 0; + } return 1; } - if ( hb_stream_check_for_ps(buf) != 0 ) + if ( hb_stream_check_for_dvd_ps(buf) != 0 ) { - hb_log("file is MPEG Program Stream"); - stream->stream_type = hb_stream_type_program; + hb_log("file is MPEG DVD Program Stream"); + stream->hb_stream_type = dvd_program; return 1; } + do + { + 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; } @@ -224,11 +428,16 @@ static void hb_stream_delete_dynamic( hb_stream_t *d ) int i=0; + if ( d->ts_packet ) + { + free( d->ts_packet ); + d->ts_packet = NULL; + } for (i = 0; i < kMaxNumberDecodeStreams; i++) { if (d->ts_buf[i]) { - free(d->ts_buf[i]); + hb_buffer_close(&(d->ts_buf[i])); d->ts_buf[i] = NULL; } } @@ -241,15 +450,45 @@ static void hb_stream_delete( hb_stream_t *d ) free( d ); } +static int audio_inactive( hb_stream_t *stream, int indx ) +{ + int aud_indx = indx - 1; + + if ( stream->ts_audio_pids[aud_indx] < 0 ) + { + // PID declared inactive by hb_stream_title_scan + return 1; + } + if ( stream->ts_audio_pids[aud_indx] == stream->pmt_info.PCR_PID ) + { + // PCR PID is always active + return 0; + } + + // see if we should make the stream inactive because scan.c didn't + // find a valid audio bitstream. + int i; + for ( i = 0; i < hb_list_count( stream->title->list_audio ); ++i ) + { + hb_audio_t *audio = hb_list_item( stream->title->list_audio, i ); + if ( audio->id == indx ) + { + return 0; + } + } + // not in the title's audio list - declare the PID inactive + stream->ts_audio_pids[aud_indx] = -stream->ts_audio_pids[aud_indx]; + return 1; +} + /*********************************************************************** * hb_stream_open *********************************************************************** * **********************************************************************/ -hb_stream_t * hb_stream_open( char *path, int opentype ) +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 ); @@ -271,31 +510,32 @@ hb_stream_t * hb_stream_open( char *path, int opentype ) * (even if we have saved state, the stream may have changed). */ hb_stream_t *ss = hb_stream_lookup( path ); - if ( opentype == 1 ) + if ( title && ss && ss->hb_stream_type != ffmpeg ) { - /* opening to read - we must have saved state */ - if ( ss == NULL ) - { - hb_log( "hb_stream_open: error: re-opening %s but no scan state", path ); - fclose( f ); - free( d ); - return NULL; - } /* * copy the saved state since we might be encoding the same stream * multiple times. */ memcpy( d, ss, sizeof(*d) ); d->file_handle = f; - d->opentype = opentype; + d->title = title; d->path = strdup( path ); - if ( d->stream_type == hb_stream_type_transport ) + if ( d->hb_stream_type == transport ) { + d->ts_packet = malloc( d->packetsize ); + int i = 0; for ( ; i < d->ts_number_video_pids + d->ts_number_audio_pids; i++) { - d->ts_buf[i] = malloc( HB_DVD_READ_BUFFER_SIZE ); + if ( i && audio_inactive( d, i ) ) + { + // this PID isn't wanted (we don't have a codec for it + // or scan didn't find audio parameters) + continue; + } + d->ts_buf[i] = hb_buffer_init(d->packetsize); + d->ts_buf[i]->size = 0; } hb_stream_seek( d, 0. ); } @@ -307,19 +547,30 @@ hb_stream_t * hb_stream_open( char *path, int opentype ) * If it's something we can deal with (MPEG2 PS or TS) return a stream * reference structure & null otherwise. */ - if ( ss != NULL ) { hb_stream_state_delete( ss ); } d->file_handle = f; - d->opentype = opentype; + d->title = title; d->path = strdup( path ); - if (d->path != NULL && hb_stream_get_type( d ) != 0 ) + if (d->path != NULL ) { - return d; + if ( hb_stream_get_type( d ) != 0 ) + { + return d; + } + fclose( d->file_handle ); + d->file_handle = NULL; + if ( ffmpeg_open( d, title ) ) + { + return d; + } + } + if ( d->file_handle ) + { + fclose( d->file_handle ); } - fclose( d->file_handle ); if (d->path) { free( d->path ); @@ -337,17 +588,27 @@ hb_stream_t * hb_stream_open( char *path, int opentype ) void hb_stream_close( hb_stream_t ** _d ) { hb_stream_t *stream = * _d; + + if ( stream->hb_stream_type == ffmpeg ) + { + ffmpeg_close( stream ); + hb_stream_delete( stream ); + *_d = NULL; + return; + } + if ( stream->frames ) { hb_log( "stream: %d good frames, %d errors (%.0f%%)", stream->frames, stream->errors, (double)stream->errors * 100. / (double)stream->frames ); } + /* * if the stream was opened for a scan, cache the result, otherwise delete * the state. */ - if ( stream->opentype == 0 ) + if ( stream->title == NULL ) { hb_stream_delete_dynamic( stream ); if ( stream_state_list == NULL ) @@ -368,19 +629,15 @@ void hb_stream_close( hb_stream_t ** _d ) * now have an audio codec, type, rate, etc., associated with them. At the end * of the scan we delete all the audio entries that weren't found by the scan * or don't have a format we support. This routine deletes audio entry 'indx' - * by copying all later entries down one slot. */ + * by setting its PID to an invalid value so no packet will match it. (We can't + * move any of the entries since the index of the entry is used as the id + * of the media stream for HB. */ static void hb_stream_delete_audio_entry(hb_stream_t *stream, int indx) { - int i; - - for (i = indx+1; i < stream->ts_number_audio_pids; ++i) + if ( stream->ts_audio_pids[indx] > 0 ) { - stream->ts_audio_pids[indx] = stream->ts_audio_pids[i]; - stream->ts_audio_stream_type[1 + indx] = stream->ts_audio_stream_type[1+i]; - stream->ts_streamid[1 + indx] = stream->ts_streamid[1 + i]; - ++indx; + stream->ts_audio_pids[indx] = -stream->ts_audio_pids[indx]; } - --stream->ts_number_audio_pids; } static int index_of_pid(int pid, hb_stream_t *stream) @@ -404,8 +661,12 @@ static int index_of_pid(int pid, hb_stream_t *stream) **********************************************************************/ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) { + if ( stream->hb_stream_type == ffmpeg ) + return ffmpeg_title_scan( 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 @@ -437,7 +698,7 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) // the elementary stream is an audio type. // - For program streams read the first 4MB and take every unique // audio stream we find. - if (stream->stream_type == hb_stream_type_transport) + if (stream->hb_stream_type == transport) { int i; @@ -450,16 +711,32 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) { free(audio); hb_stream_delete_audio_entry(stream, i); - --i; } } - // add the PCR PID if we don't already have it + // make sure we're grabbing the PCR PID if ( index_of_pid( stream->pmt_info.PCR_PID, stream ) < 0 ) { stream->ts_audio_pids[stream->ts_number_audio_pids++] = stream->pmt_info.PCR_PID; } + + // set the video id, codec & muxer + aTitle->video_id = 0; + aTitle->video_codec = st2codec[stream->ts_stream_type[0]].codec; + aTitle->video_codec_param = st2codec[stream->ts_stream_type[0]].codec_param; + aTitle->demuxer = HB_MPEG2_TS_DEMUXER; + + if ( ( stream->ts_flags & TS_HAS_PCR ) == 0 ) + { + hb_log( "transport stream missing PCRs - using video DTS instead" ); + } + + if ( stream->ts_IDRs < 1 ) + { + hb_log( "transport stream doesn't seem to have video IDR frames" ); + aTitle->flags |= HBTF_NO_IDR; + } } else { @@ -470,34 +747,186 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) } /* + * read the next transport stream packet from 'stream'. Return NULL if + * we hit eof & a pointer to the sync byte otherwise. + */ +static const uint8_t *next_packet( hb_stream_t *stream ) +{ + uint8_t *buf = stream->ts_packet + stream->packetsize - 188; + + while ( 1 ) + { + if ( fread(stream->ts_packet, 1, stream->packetsize, stream->file_handle) != + stream->packetsize ) + { + return NULL; + } + if (buf[0] == 0x47) + { + return buf; + } + // lost sync - back up to where we started then try to re-establish. + off_t pos = ftello(stream->file_handle) - stream->packetsize; + off_t pos2 = align_to_next_packet(stream); + if ( pos2 == 0 ) + { + hb_log( "next_packet: eof while re-establishing sync @ %"PRId64, pos ); + return NULL; + } + ts_warn( stream, "next_packet: sync lost @ %"PRId64", regained after %"PRId64" bytes", + pos, pos2 ); + } +} + +/* + * skip to the start of the next PACK header in program stream src_stream. + */ +static void skip_to_next_pack( hb_stream_t *src_stream ) +{ + // scan forward until we find the start of the next pack + uint32_t strt_code = -1; + int c; + + flockfile( src_stream->file_handle ); + while ( ( c = getc_unlocked( src_stream->file_handle ) ) != EOF ) + { + strt_code = ( strt_code << 8 ) | c; + if ( strt_code == 0x000001ba ) + // we found the start of the next pack + break; + } + funlockfile( src_stream->file_handle ); + + // if we didn't terminate on an eof back up so the next read + // starts on the pack boundary. + if ( c != EOF ) + { + fseeko( src_stream->file_handle, -4, SEEK_CUR ); + } +} + +static int isIframe( hb_stream_t *stream, const uint8_t *buf, int adapt_len ) +{ + // For mpeg2: look for a gop start or i-frame picture start + // for h.264: look for idr nal type or a slice header for an i-frame + // for vc1: look for a Sequence header + int i; + uint32_t strid = 0; + + + if ( stream->ts_stream_type[0] <= 2 ) + { + // This section of the code handles MPEG-1 and MPEG-2 video streams + for (i = 13 + adapt_len; i < 188; i++) + { + strid = (strid << 8) | buf[i]; + if ( ( strid >> 8 ) == 1 ) + { + // we found a start code + uint8_t id = strid; + switch ( id ) + { + case 0xB8: // group_start_code (GOP header) + case 0xB3: // sequence_header code + return 1; + + case 0x00: // picture_start_code + // picture_header, let's see if it's an I-frame + if (i<185) + { + // check if picture_coding_type == 1 + if ((buf[i+2] & (0x7 << 3)) == (1 << 3)) + { + // found an I-frame picture + return 1; + } + } + break; + } + } + } + // didn't find an I-frame + return 0; + } + if ( stream->ts_stream_type[0] == 0x1b ) + { + // we have an h.264 stream + for (i = 13 + adapt_len; i < 188; i++) + { + strid = (strid << 8) | buf[i]; + if ( ( strid >> 8 ) == 1 ) + { + // we found a start code - remove the ref_idc from the nal type + uint8_t nal_type = strid & 0x1f; + if ( nal_type == 0x05 ) + // h.264 IDR picture start + return 1; + } + } + // didn't find an I-frame + return 0; + } + if ( stream->ts_stream_type[0] == 0xea ) + { + // we have an vc1 stream + for (i = 13 + adapt_len; i < 188; i++) + { + strid = (strid << 8) | buf[i]; + if ( strid == 0x10f ) + { + // the ffmpeg vc1 decoder requires a seq hdr code in the first + // frame. + return 1; + } + } + // didn't find an I-frame + return 0; + } + + // we don't understand the stream type so just say "yes" otherwise + // we'll discard all the video. + return 1; +} + +/* * scan the next MB of 'stream' to find the next start packet for * the Packetized Elementary Stream associated with TS PID 'pid'. */ static const uint8_t *hb_ts_stream_getPEStype(hb_stream_t *stream, uint32_t pid) { - static uint8_t buf[188]; - int npack = 100000; // max packets to read + int npack = 300000; // max packets to read while (--npack >= 0) { - if (fread(buf, 1, 188, stream->file_handle) != 188) + const uint8_t *buf = next_packet( stream ); + if ( buf == NULL ) { hb_log("hb_ts_stream_getPEStype: EOF while searching for PID 0x%x", pid); return 0; } - if (buf[0] != 0x47) + + // while we're reading the stream, check if it has valid PCRs + // and/or random access points. + uint32_t pack_pid = ( (buf[1] & 0x1f) << 8 ) | buf[2]; + if ( pack_pid == stream->pmt_info.PCR_PID ) { - hb_log("hb_ts_stream_getPEStype: lost sync while searching for PID 0x%x", pid); - align_to_next_packet(stream->file_handle); - continue; + if ( ( buf[5] & 0x10 ) && + ( ( ( buf[3] & 0x30 ) == 0x20 ) || + ( ( buf[3] & 0x30 ) == 0x30 && buf[4] > 6 ) ) ) + { + stream->ts_flags |= TS_HAS_PCR; + } + } + if ( buf[5] & 0x40 ) + { + stream->ts_flags |= TS_HAS_RAP; } /* * The PES header is only in TS packets with 'start' set so we check * that first then check for the right PID. */ - if ((buf[1] & 0x40) == 0 || (buf[1] & 0x1f) != (pid >> 8) || - buf[2] != (pid & 0xff)) + if ((buf[1] & 0x40) == 0 || pack_pid != pid ) { // not a start packet or not the pid we want continue; @@ -520,7 +949,11 @@ static const uint8_t *hb_ts_stream_getPEStype(hb_stream_t *stream, uint32_t pid) udata += buf[4] + 1; break; } - return &buf[udata]; + /* PES hdr has to begin with an mpeg start code */ + if (buf[udata+0] == 0x00 && buf[udata+1] == 0x00 && buf[udata+2] == 0x01) + { + return &buf[udata]; + } } /* didn't find it */ @@ -540,7 +973,7 @@ static uint64_t hb_ps_stream_getVideoPTS(hb_stream_t *stream) hb_buffer_t *es; // 'buf' contains an MPEG2 PACK - get a list of all it's elementary streams - hb_demux_ps(buf, list); + hb_demux_ps( buf, list, 0 ); while ( ( es = hb_list_item( list, 0 ) ) ) { @@ -595,7 +1028,7 @@ struct pts_pos { uint64_t pts; /* PTS from video stream */ }; -#define NDURSAMPLES 16 +#define NDURSAMPLES 128 // get one (position, timestamp) sampple from a transport or program // stream. @@ -603,27 +1036,20 @@ static struct pts_pos hb_sample_pts(hb_stream_t *stream, uint64_t fpos) { struct pts_pos pp = { 0, 0 }; - if ( stream->stream_type == hb_stream_type_program ) - { - // round address down to nearest dvd sector start - fpos &=~ ( HB_DVD_READ_BUFFER_SIZE - 1 ); - fseeko( stream->file_handle, fpos, SEEK_SET ); - pp.pts = hb_ps_stream_getVideoPTS( stream ); - } - else + if ( stream->hb_stream_type == transport ) { const uint8_t *buf; fseeko( stream->file_handle, fpos, SEEK_SET ); - align_to_next_packet( stream->file_handle ); + align_to_next_packet( stream ); 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 ) | @@ -631,9 +1057,27 @@ static struct pts_pos hb_sample_pts(hb_stream_t *stream, uint64_t fpos) ( ( (uint64_t)buf[11] >> 1 ) << 15 ) | ( (uint64_t)buf[12] << 7 ) | ( (uint64_t)buf[13] >> 1 ); + + if ( isIframe( stream, buf, -4 ) ) + { + if ( stream->ts_IDRs < 255 ) + { + ++stream->ts_IDRs; + } + } + } + else + { + // round address down to nearest dvd sector start + fpos &=~ ( HB_DVD_READ_BUFFER_SIZE - 1 ); + fseeko( stream->file_handle, fpos, SEEK_SET ); + if ( stream->hb_stream_type == program ) + { + skip_to_next_pack( stream ); + } + pp.pts = hb_ps_stream_getVideoPTS( stream ); } pp.pos = ftello(stream->file_handle); - hb_log("hb_sample_pts: pts %lld at %llu", pp.pts, pp.pos ); return pp; } @@ -649,7 +1093,7 @@ static int dur_compare( const void *a, const void *b ) static double compute_stream_rate( struct pts_pos *pp, int n ) { int i, j; - double rates[NDURSAMPLES * NDURSAMPLES / 2]; + double rates[NDURSAMPLES * NDURSAMPLES / 8]; double *rp = rates; // the following nested loops compute the rates between all pairs. @@ -664,11 +1108,13 @@ static double compute_stream_rate( struct pts_pos *pp, int n ) // could easily fall in the inter-piece part of the data which // would give a bogus estimate. The 'ns' index creates an // asymmetry that favors locality. - int ns = i + ( n >> 1 ); + int ns = i + ( n >> 3 ); if ( ns > n ) ns = n; for ( j = i+1; j < ns; ++j ) { + if ( (uint64_t)(pp[j].pts - pp[i].pts) > 90000LL*3600*6 ) + break; if ( pp[j].pts != pp[i].pts && pp[j].pos > pp[i].pos ) { *rp = ((double)( pp[j].pts - pp[i].pts )) / @@ -715,48 +1161,236 @@ static void hb_stream_duration(hb_stream_t *stream, hb_title_t *inTitle) **********************************************************************/ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) { - if ( src_stream->stream_type == hb_stream_type_program ) + if ( src_stream->hb_stream_type == ffmpeg ) + { + return ffmpeg_read( src_stream, b ); + } + if ( src_stream->hb_stream_type == dvd_program ) { size_t amt_read = fread(b->data, HB_DVD_READ_BUFFER_SIZE, 1, src_stream->file_handle); return (amt_read > 0); } - return hb_ts_stream_decode( src_stream, b->data ); -} - -/*********************************************************************** - * hb_stream_seek - *********************************************************************** - * - **********************************************************************/ -int hb_stream_seek( hb_stream_t * src_stream, float f ) -{ - off_t stream_size, cur_pos, new_pos; - double pos_ratio = f; - cur_pos = ftello(src_stream->file_handle); - fseeko(src_stream->file_handle,0 ,SEEK_END); - stream_size = ftello(src_stream->file_handle); - new_pos = (off_t) ((double) (stream_size) * pos_ratio); - new_pos &=~ (HB_DVD_READ_BUFFER_SIZE - 1); - int r = fseeko(src_stream->file_handle, new_pos, SEEK_SET); - - if (r == -1) - { - fseeko(src_stream->file_handle, cur_pos, SEEK_SET); - return 0; - } - - if (src_stream->stream_type == hb_stream_type_transport) - { - // We need to drop the current decoder output and move - // forwards to the next transport stream packet. - hb_ts_stream_reset(src_stream); - } + if ( src_stream->hb_stream_type == program ) + { + // a general program stream has arbitrary sized pack's. we're + // currently positioned at the start of a pack so read up to but + // not including the start of the next, expanding the buffer + // as necessary. + uint8_t *cp = b->data; + uint8_t *ep = cp + b->alloc; + uint32_t strt_code = -1; + int c; + + // consume the first byte of the initial pack so we don't match on + // it in the loop below. + if ( ( c = getc( src_stream->file_handle ) ) == EOF ) + return 0; - return 1; -} + *cp++ = c; -static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang ) + flockfile( src_stream->file_handle ); + while ( ( c = getc_unlocked( src_stream->file_handle ) ) != EOF ) + { + strt_code = ( strt_code << 8 ) | c; + if ( strt_code == 0x000001ba ) + // we found the start of the next pack + break; + if ( cp >= ep ) + { + // need to expand the buffer + int curSize = cp - b->data; + hb_buffer_realloc( b, curSize * 2 ); + cp = b->data + curSize; + 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 ); + + // if we didn't terminate on an eof back up so the next read + // starts on the pack boundary. + b->size = cp - b->data; + if ( c != EOF ) + { + fseeko( src_stream->file_handle, -4, SEEK_CUR ); + // Only 3 of the 4 bytes read were added to the buffer. + b->size -= 3; + } + return 1; + } + return hb_ts_stream_decode( src_stream, b ); +} + +int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num ) +{ + + if ( stream->hb_stream_type != ffmpeg ) + { + // currently meaningliess for transport and program streams + return 1; + } + if ( !stream || !stream->title || + chapter_num > hb_list_count( stream->title->list_chapter ) ) + { + return 0; + } + + 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; + + int64_t pos = ( ( ( sum_dur - chapter->duration ) * AV_TIME_BASE ) / 90000 ); + + 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; +} + +/*********************************************************************** + * hb_stream_chapter + *********************************************************************** + * Return the number of the chapter that we are currently in. We store + * the chapter number starting from 0, so + 1 for the real chpater num. + **********************************************************************/ +int hb_stream_chapter( hb_stream_t * src_stream ) +{ + return( src_stream->chapter + 1 ); +} + +/*********************************************************************** + * hb_stream_seek + *********************************************************************** + * + **********************************************************************/ +int hb_stream_seek( hb_stream_t * stream, float f ) +{ + if ( stream->hb_stream_type == ffmpeg ) + { + return ffmpeg_seek( stream, f ); + } + off_t stream_size, cur_pos, new_pos; + double pos_ratio = f; + cur_pos = ftello( stream->file_handle ); + fseeko( stream->file_handle, 0, SEEK_END ); + stream_size = ftello( stream->file_handle ); + new_pos = (off_t) ((double) (stream_size) * pos_ratio); + new_pos &=~ (HB_DVD_READ_BUFFER_SIZE - 1); + + int r = fseeko( stream->file_handle, new_pos, SEEK_SET ); + if (r == -1) + { + fseeko( stream->file_handle, cur_pos, SEEK_SET ); + return 0; + } + + if ( stream->hb_stream_type == transport ) + { + // We need to drop the current decoder output and move + // forwards to the next transport stream packet. + hb_ts_stream_reset(stream); + if ( f > 0 ) + { + if ( stream->ts_IDRs ) + { + // the stream has IDRs so look for one. + stream->need_keyframe = 1; + } + } + else + { + // we're at the beginning - say we have video sync so that we + // won't drop initial SPS & PPS data on an AVC stream. + stream->need_keyframe = 0; + } + } + else if ( stream->hb_stream_type == program ) + { + skip_to_next_pack( stream ); + } + + 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]; + char *cp = name; + char *ep = cp + sizeof(name)-1; + + while ( *s && cp < ep ) + { + *cp++ = islower(*s)? toupper(*s) : *s; + ++s; + } + *cp = 0; + return name; +} + +static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang ) { /* XXX * This is a duplicate of code in dvd.c - it should get factored out @@ -764,12 +1398,37 @@ static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang ) * code or a lang pointer into the audio config & let the common description * formatting routine in scan.c do all the stuff below. */ + const char *codec_name; + AVCodecContext *cc; + + if ( audio->config.in.codec == HB_ACODEC_FFMPEG && + ( cc = hb_ffmpeg_context( audio->config.in.codec_param ) ) && + avcodec_find_decoder( cc->codec_id ) ) + { + codec_name = make_upper( avcodec_find_decoder( cc->codec_id )->name ); + if ( !strcmp( codec_name, "LIBFAAD" ) ) + { + codec_name = "AAC"; + } + } + else if ( audio->config.in.codec == HB_ACODEC_MPGA && + avcodec_find_decoder( audio->config.in.codec_param ) ) + { + codec_name = avcodec_find_decoder( audio->config.in.codec_param )->name; + } + else + { + codec_name = audio->config.in.codec == HB_ACODEC_AC3 ? "AC3" : + audio->config.in.codec == HB_ACODEC_DCA ? "DTS" : + audio->config.in.codec == HB_ACODEC_MPGA ? "MPEG" : + audio->config.in.codec == HB_ACODEC_LPCM ? "LPCM" : + audio->config.in.codec == HB_ACODEC_FFMPEG ? "FFMPEG" : + "Unknown"; + } snprintf( audio->config.lang.description, sizeof( audio->config.lang.description ), "%s (%s)", strlen(lang->native_name) ? lang->native_name : lang->eng_name, - audio->config.in.codec == HB_ACODEC_AC3 ? "AC3" : - audio->config.in.codec == HB_ACODEC_DCA ? "DTS" : - audio->config.in.codec == HB_ACODEC_MPGA ? "MPEG" : "LPCM" ); + codec_name ); snprintf( audio->config.lang.simple, sizeof( audio->config.lang.simple ), "%s", strlen(lang->native_name) ? lang->native_name : lang->eng_name ); snprintf( audio->config.lang.iso639_2, sizeof( audio->config.lang.iso639_2 ), @@ -784,47 +1443,100 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, const uint8_t *buf; fseeko(stream->file_handle, 0, SEEK_SET); - align_to_next_packet(stream->file_handle); + align_to_next_packet(stream); buf = hb_ts_stream_getPEStype(stream, stream->ts_audio_pids[aud_pid_index]); /* check that we found a PES header */ + uint8_t stype = 0; if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01) { - if (buf[3] == 0xbd) + stype = stream->ts_stream_type[1 + aud_pid_index]; + + // 0xbd ("private stream 1") is the normal container for non-ISO + // media - AC3/DCA/PCM/etc. + if ( buf[3] == 0xbd ) { - audio->id = 0x80bd | (aud_pid_index << 8); - audio->config.in.codec = HB_ACODEC_AC3; - hb_log("transport stream pid 0x%x (type 0x%x) is AC-3 audio id 0x%x", - stream->ts_audio_pids[aud_pid_index], - stream->ts_audio_stream_type[1 + aud_pid_index], - audio->id); - stream->ts_audio_stream_type[1 + aud_pid_index] = 0x81; - stream->ts_streamid[1 + aud_pid_index] = buf[3]; + if ( st2codec[stype].kind == U ) + { + // XXX assume unknown stream types are AC-3 (if they're not + // audio we'll find that out during the scan but if they're + // some other type of audio we'll end up ignoring them). + stype = 0x81; + stream->ts_stream_type[1 + aud_pid_index] = 0x81; + } + } + else if ( buf[3] == 0xfd ) + { + // 0xfd indicates an extended stream id (ISO 13818-1(2007)). + // the blu ray consortium apparently forgot to read the portion + // of the MPEG spec that says one PID should map to one media + // stream and multiplexed multiple types of audio into one PID + // using the extended stream identifier of the PES header to + // distinguish them. So we have to check if that's happening and + // if so tell the runtime what esid we want. + if ( st2codec[stype].kind == A && stype == 0x83 && + stream->ts_format_id[1 + aud_pid_index] == TS_FORMAT_ID_AC3 ) + { + // This is an interleaved TrueHD/AC-3 stream and the esid of + // the AC-3 is 0x76 + stream->ts_multiplexed[1 + aud_pid_index] = 0x76; + stype = 0x81; + stream->ts_stream_type[1 + aud_pid_index] = 0x81; + } + if ( st2codec[stype].kind == A && stype == 0x86 ) + { + // This is an interleaved DTS-HD/DTS stream and the esid of + // the DTS is 0x71 + stream->ts_multiplexed[1 + aud_pid_index] = 0x71; + stype = 0x82; + stream->ts_stream_type[1 + aud_pid_index] = 0x82; + } } else if ((buf[3] & 0xe0) == 0xc0) { - audio->id = buf[3] | aud_pid_index; - audio->config.in.codec = HB_ACODEC_MPGA; - hb_log("transport stream pid 0x%x (type 0x%x) is MPEG audio id 0x%x", - stream->ts_audio_pids[aud_pid_index], - stream->ts_audio_stream_type[1 + aud_pid_index], - audio->id); - stream->ts_audio_stream_type[1 + aud_pid_index] = 0x03; - stream->ts_streamid[1 + aud_pid_index] = buf[3]; + // 0xC0 - 0xCF are the normal containers for ISO-standard + // media (mpeg2 audio and mpeg4 AAC). + if ( st2codec[stype].kind == U ) + { + // XXX assume unknown stream types are MPEG audio + stype = 0x03; + stream->ts_stream_type[1 + aud_pid_index] = 0x03; + } + } + else + { + stype = 0; } } - fseeko(stream->file_handle, cur_pos, SEEK_SET); - if ( audio->config.in.codec ) + // if we found an audio stream type & HB has a codec that can decode it + // finish configuring the audio so we'll add it to the title's list. + if ( st2codec[stype].kind == A && st2codec[stype].codec ) { + audio->id = 1 + aud_pid_index; + audio->config.in.codec = st2codec[stype].codec; + audio->config.in.codec_param = st2codec[stype].codec_param; set_audio_description( audio, lang_for_code( stream->a52_info[aud_pid_index].lang_code ) ); + hb_log("transport stream pid 0x%x (type 0x%x) may be %s audio (id 0x%x)", + stream->ts_audio_pids[aud_pid_index], + stype, st2codec[stype].name, audio->id); } else { - hb_log("transport stream pid 0x%x (type 0x%x) isn't audio", - stream->ts_audio_pids[aud_pid_index], - stream->ts_audio_stream_type[1 + aud_pid_index]); + if ( buf ) + { + hb_log("transport stream pid 0x%x (type 0x%x, substream 0x%x) " + "isn't audio", stream->ts_audio_pids[aud_pid_index], + stream->ts_stream_type[1 + aud_pid_index], buf[3]); + } + else + { + hb_log("transport stream pid 0x%x (type 0x%x) isn't audio", + stream->ts_audio_pids[aud_pid_index], + stream->ts_stream_type[1 + aud_pid_index]); + } } + fseeko(stream->file_handle, cur_pos, SEEK_SET); return audio; } @@ -883,7 +1595,7 @@ static void hb_ps_stream_find_audio_ids(hb_stream_t *stream, hb_title_t *title) hb_buffer_t *es; // 'buf' contains an MPEG2 PACK - get a list of all it's elementary streams - hb_demux_ps(buf, list); + hb_demux_ps( buf, list, 0 ); while ( ( es = hb_list_item( list, 0 ) ) ) { @@ -929,54 +1641,52 @@ static void hb_ts_stream_init(hb_stream_t *stream) stream-> ts_audio_pids[i] = -1; } + stream->ts_packet = malloc( stream->packetsize ); + // Find the audio and video pids in the stream hb_ts_stream_find_pids(stream); - stream->ts_streamid[0] = 0xE0; // stream 0 must be video - for (i = 0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++) { // demuxing buffer for TS to PS conversion - stream->ts_buf[i] = malloc( HB_DVD_READ_BUFFER_SIZE ); + stream->ts_buf[i] = hb_buffer_init(stream->packetsize); + stream->ts_buf[i]->size = 0; } } -// ------------------------------------------------------------------------------------ +#define MAX_HOLE 208*80 -static off_t align_to_next_packet(FILE* f) +static off_t align_to_next_packet(hb_stream_t *stream) { - unsigned char buf[188*20]; - - off_t start = ftello(f); + uint8_t buf[MAX_HOLE]; off_t pos = 0; + off_t start = ftello(stream->file_handle); - if (fread(buf, 188*20, 1, f) == 1) - { - int found = 0; - while (!found && (pos < 188)) - { - found = 1; - int i = 0; - for (i = 0; i < 188*20; i += 188) - { - unsigned char c = buf[pos+i]; - // Check sync byte - if ((c != 0x47) && (c != 0x72) && (c != 0x29)) - { - // this offset failed, try next - found = 0; - pos++; - break; - } - } - } - } - - if (pos == 188) - pos = 0; // failed to find anything!!!!!? + if ( start >= stream->packetsize ) { + start -= stream->packetsize; + fseeko(stream->file_handle, start, SEEK_SET); + } - fseeko(f, start+pos, SEEK_SET); + if (fread(buf, sizeof(buf), 1, stream->file_handle) == 1) + { + const uint8_t *bp = buf; + int i; + for ( i = sizeof(buf); --i >= 0; ++bp ) + { + if ( have_ts_sync( bp, stream->packetsize ) ) + { + break; + } + } + if ( i >= 0 ) + { + pos = ( bp - buf ) - stream->packetsize + 188; + if ( pos < 0 ) + pos = 0; + } + } + fseeko(stream->file_handle, start+pos, SEEK_SET); return pos; } @@ -1051,10 +1761,19 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, { switch (dp[0]) { + case 5: // Registration descriptor + stream->ts_format_id[esindx+1] = (dp[2] << 24) | (dp[3] << 16) | + (dp[4] << 8) | dp[5]; + break; + case 10: // ISO_639_language descriptor 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; } @@ -1062,6 +1781,11 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, } } +static const char *stream_type_name (uint8_t stream_type) +{ + return st2codec[stream_type].name? st2codec[stream_type].name : "Unknown"; +} + int decode_program_map(hb_stream_t* stream) { bitbuf_t bb; @@ -1096,61 +1820,68 @@ int decode_program_map(hb_stream_t* stream) int cur_pos = 9 /* data after the section length field*/ + program_info_length; int done_reading_stream_types = 0; while (!done_reading_stream_types) - { - unsigned char stream_type = get_bits(&bb, 8); - get_bits(&bb, 3); - unsigned int elementary_PID = get_bits(&bb, 13); - get_bits(&bb, 4); - unsigned int ES_info_length = get_bits(&bb, 12); - - int i=0; - unsigned char *ES_info_buf = (unsigned char *) malloc(ES_info_length); - for (i=0; i < ES_info_length; i++) - { - ES_info_buf[i] = get_bits(&bb, 8); - } - - if (stream_type == 0x02) - { - if (stream->ts_number_video_pids <= kMaxNumberVideoPIDS) - stream->ts_number_video_pids++; - stream->ts_video_pids[stream->ts_number_video_pids-1] = elementary_PID; - } - 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) - stream->ts_number_audio_pids++; - stream->ts_audio_pids[i] = elementary_PID; - stream->ts_audio_stream_type[1 + i] = stream_type; - - if (ES_info_length > 0) - { - decode_element_descriptors(stream, i, ES_info_buf, ES_info_length); - } - } + { + unsigned char stream_type = get_bits(&bb, 8); + get_bits(&bb, 3); + unsigned int elementary_PID = get_bits(&bb, 13); + get_bits(&bb, 4); + unsigned int ES_info_length = get_bits(&bb, 12); + + int i=0; + unsigned char *ES_info_buf = (unsigned char *) malloc(ES_info_length); + for (i=0; i < ES_info_length; i++) + { + ES_info_buf[i] = get_bits(&bb, 8); + } + + + if ( index_of_pid( elementary_PID, stream ) < 0 ) + { + // 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 + { + // 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) + { + 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; + } + } + } - cur_pos += 5 /* stream header */ + ES_info_length; + cur_pos += 5 /* stream header */ + ES_info_length; - free(ES_info_buf); + free(ES_info_buf); - if (cur_pos >= section_length - 4 /* stop before the CRC */) - done_reading_stream_types = 1; - } + if (cur_pos >= section_length - 4 /* stop before the CRC */) + done_reading_stream_types = 1; + } free(descriptor_buf); return 1; } -// ------------------------------------------------------------------------------------ - -int build_program_map(unsigned char *buf, hb_stream_t *stream) +static int build_program_map(const uint8_t *buf, hb_stream_t *stream) { // Get adaption header info int adapt_len = 0; @@ -1170,19 +1901,6 @@ int build_program_map(unsigned char *buf, hb_stream_t *stream) // Get pointer length - only valid in packets with a start flag int pointer_len = 0; - if (start && stream->pmt_info.reading) - { - // We just finished a bunch of packets - parse the program map details - int decode_ok = 0; - if (stream->pmt_info.tablebuf[0] == 0x02) - decode_ok = decode_program_map(stream); - free(stream->pmt_info.tablebuf); - stream->pmt_info.tablebuf = NULL; - stream->pmt_info.tablepos = 0; - stream->pmt_info.reading = 0; - if (decode_ok) - return decode_ok; - } if (start) { @@ -1208,11 +1926,32 @@ int build_program_map(unsigned char *buf, hb_stream_t *stream) memcpy(stream->pmt_info.tablebuf + stream->pmt_info.tablepos, buf + 4 + adapt_len + pointer_len, amount_to_copy); stream->pmt_info.tablepos += amount_to_copy; } + if (stream->pmt_info.tablepos > 3) + { + // We have enough to check the section length + int length; + length = ((stream->pmt_info.tablebuf[1] << 8) + + stream->pmt_info.tablebuf[2]) & 0xFFF; + if (stream->pmt_info.tablepos > length + 1) + { + // We just finished a bunch of packets - parse the program map details + int decode_ok = 0; + if (stream->pmt_info.tablebuf[0] == 0x02) + decode_ok = decode_program_map(stream); + free(stream->pmt_info.tablebuf); + stream->pmt_info.tablebuf = NULL; + stream->pmt_info.tablepos = 0; + stream->pmt_info.reading = 0; + if (decode_ok) + return decode_ok; + } + + } return 0; } -int decode_PAT(unsigned char *buf, hb_stream_t *stream) +static int decode_PAT(const uint8_t *buf, hb_stream_t *stream) { unsigned char tablebuf[1024]; unsigned int tablepos = 0; @@ -1324,48 +2063,27 @@ int decode_PAT(unsigned char *buf, hb_stream_t *stream) static void hb_ts_stream_find_pids(hb_stream_t *stream) { - unsigned char buf[188]; - - // align to first packet - align_to_next_packet(stream->file_handle); + // 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 // to find the program map PID and then decode that to get the list of audio and video PIDs - int bytesReadInPacket = 0; for (;;) { - // Try to read packet.. - int bytesRead; - if ((bytesRead = fread(buf+bytesReadInPacket, 1, 188-bytesReadInPacket, stream->file_handle)) != 188-bytesReadInPacket) - { - if (bytesRead < 0) - bytesRead = 0; - bytesReadInPacket += bytesRead; + const uint8_t *buf = next_packet( stream ); + if ( buf == NULL ) + { hb_log("hb_ts_stream_find_pids - end of file"); break; } - else - { - bytesReadInPacket = 0; - } - - // Check sync byte - if ((buf[0] != 0x47) && (buf[0] != 0x72) && (buf[0] != 0x29)) - { - off_t pos = ftello(stream->file_handle) - 188; - off_t pos2 = align_to_next_packet(stream->file_handle); - if ( pos2 == 0 ) - { - hb_log( "hb_ts_stream_find_pids: eof while re-establishing sync @ %lld", - pos ); - break; - } - hb_log("hb_ts_stream_decode: sync lost @%lld, regained after %lld bytes", - pos, pos2 ); - continue; - } // Get pid int pid = (((buf[1] & 0x1F) << 8) | buf[2]) & 0x1FFF; @@ -1390,333 +2108,159 @@ static void hb_ts_stream_find_pids(hb_stream_t *stream) // on the first pat entry for which we find a matching program map PID. The ideal solution would // be to build a title choice popup from the PAT program number details and then select from // their - but right now the API's not capable of that. - if (pid == stream->pat_info[pat_index].program_map_PID) + if (stream->pat_info[pat_index].program_number != 0 && + pid == stream->pat_info[pat_index].program_map_PID) { if (build_program_map(buf, stream) > 0) break; } } // 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; } hb_log("hb_ts_stream_find_pids - found the following PIDS"); hb_log(" Video PIDS : "); - int i=0; + int i; for (i=0; i < stream->ts_number_video_pids; i++) { - hb_log(" 0x%x (%d)", stream->ts_video_pids[i], stream->ts_video_pids[i]); + hb_log( " 0x%x type %s (0x%x)", + stream->ts_video_pids[i], + stream_type_name(stream->ts_stream_type[i]), + stream->ts_stream_type[i]); } hb_log(" Audio PIDS : "); for (i = 0; i < stream->ts_number_audio_pids; i++) { - hb_log(" 0x%x (%d)", stream->ts_audio_pids[i], stream->ts_audio_pids[i]); + hb_log( " 0x%x type %s (0x%x)", + stream->ts_audio_pids[i], + stream_type_name(stream->ts_stream_type[i+1]), + stream->ts_stream_type[i+1] ); } } -static void fwrite64( hb_stream_t *stream, void *buf, int size ) +static void fwrite64( hb_stream_t *stream, void *buf, int len ) { - if ( (stream->fwrite_buf - stream->fwrite_buf_orig) + size > 2048 ) + if ( len > 0 ) { - hb_log( "steam fwrite64 buffer overflow - writing %d with %d already", - size, stream->fwrite_buf - stream->fwrite_buf_orig ); - return; + int pos = stream->fwrite_buf->size; + if ( pos + len > stream->fwrite_buf->alloc ) + { + int size = MAX(stream->fwrite_buf->alloc * 2, pos + len); + hb_buffer_realloc(stream->fwrite_buf, size); + } + memcpy( &(stream->fwrite_buf->data[pos]), buf, len ); + stream->fwrite_buf->size += len; } - memcpy( stream->fwrite_buf, buf, size ); - stream->fwrite_buf += size; -} - -static void write_pack(hb_stream_t* stream, uint64_t time, int stuffing) -{ - uint8_t buf[24]; - - buf[0] = 0x00; // pack id - buf[1] = 0x00; - buf[2] = 0x01; - buf[3] = 0xba; - - buf[4] = 0x44 | // SCR - ( ( ( time >> 30 ) & 7 ) << 3 ) | - ( ( time >> 28 ) & 3 ); - buf[5] = time >> 20; - buf[6] = 0x04 | - ( ( ( time >> 15 ) & 0x1f ) << 3 ) | - ( ( time >> 13 ) & 3 ); - buf[7] = time >> 5; - buf[8] = 0x04 | ( time << 3 ); - - buf[9] = 0x01; // SCR extension - - buf[10] = 384000 >> (22 - 8); // program mux rate - buf[11] = (uint8_t)( 384000 >> (22 - 16) ); - buf[12] = (uint8_t)( 384000 << 2 ) | 0x03; - - buf[13] = 0xf8 | stuffing; - - int i; - for (i = 0; i < stuffing; ++i ) - buf[14+i] = 0xff; - - fwrite64(stream, buf, 14 + stuffing ); -} - -static void pad_buffer(hb_stream_t* stream, int pad) -{ - pad -= 6; - - uint8_t buf[6]; - buf[0] = 0; - buf[1] = 0; - buf[2] = 0; - buf[3] = 0xbe; - buf[4] = pad >> 8; - buf[5] = pad; - - fwrite64(stream, buf, 6); - - buf[0] = 0xff; - while ( --pad >= 0 ) - { - fwrite64(stream, buf, 1); - } } -static void make_pes_header(hb_stream_t* stream, int len, uint8_t streamid) +// convert a PES PTS or DTS to an int64 +static int64_t pes_timestamp( const uint8_t *pes ) { - uint8_t buf[9]; - - memset(buf, 0, sizeof(buf) ); - buf[2] = 1; - buf[3] = streamid; - buf[4] = ( len + 3 ) >> 8; - buf[5] = len + 3; - buf[6] = 0x88; - - fwrite64(stream, buf, 9); + int64_t ts = ( (uint64_t)(pes[0] & 0xe ) << 29 ); + ts |= ( pes[1] << 22 ) | ( ( pes[2] >> 1 ) << 15 ) | + ( pes[3] << 7 ) | ( pes[4] >> 1 ); + return ts; } static void generate_output_data(hb_stream_t *stream, int curstream) { - uint8_t *tdat = stream->ts_buf[curstream]; - int len; - - // we always ship a PACK header plus all the data in our demux buf. - // AC3 audio also always needs it substream header. - len = 14 + stream->ts_pos[curstream]; - if ( stream->ts_audio_stream_type[curstream] == 0x81) - { - len += 4; - } - - if ( ! stream->ts_start[curstream] ) - { - // we're in the middle of a chunk of PES data - we need to add - // a 'continuation' PES header after the PACK header. - len += 9; - } - - // Write out pack header - // If we don't have 2048 bytes we need to pad to 2048. We can - // add a padding frame after our data but we need at least 7 - // bytes of space to do it (6 bytes of header & 1 of pad). If - // we have fewer than 7 bytes left we need to fill the excess - // space with stuffing bytes added to the pack header. - int stuffing = 0; - if ( len > HB_DVD_READ_BUFFER_SIZE ) + hb_buffer_t *buf = stream->fwrite_buf; + uint8_t *tdat = stream->ts_buf[curstream]->data; + + buf->id = curstream; + + // check if this packet was referenced to an older pcr and if that + // pcr was significantly different than the one we're using now. + // (the reason for the uint cast on the pcr difference is that the + // difference is significant if it advanced by more than 200ms or if + // it went backwards by any amount. The negative numbers look like huge + // unsigned ints so the cast allows both conditions to be checked at once. + int bufpcr = stream->ts_buf[curstream]->cur; + int curpcr = stream->ts_pcr_out; + if ( bufpcr && bufpcr < curpcr && + (uint64_t)(stream->ts_pcrhist[curpcr & 3] - stream->ts_pcrhist[bufpcr & 3]) > 200*90LL ) { - hb_log( "stream ts length botch %d", len ); + // we've sent up a new pcr but have a packet referenced to an + // old pcr and the difference was enough to trigger a discontinuity + // correction. smash the timestamps or we'll mess up the correction. + buf->start = -1; + buf->renderOffset = -1; } - if ( HB_DVD_READ_BUFFER_SIZE - len < 8) - { - stuffing = HB_DVD_READ_BUFFER_SIZE - len; - } - write_pack(stream, stream->ts_nextpcr, stuffing ); - stream->ts_nextpcr += 10; - - if ( stream->ts_start[curstream] ) + else { - // Start frames already have a PES header but we have modify it - // to map from TS PID to PS stream id. Also, if the stream is AC3 - // audio we have to insert an AC3 stream header between the end of - // the PES header and the start of the stream data. - - stream->ts_start[curstream] = 0; - tdat[3] = stream->ts_streamid[curstream]; - - uint16_t plen = stream->ts_pos[curstream] - 6; - if ( stream->ts_audio_stream_type[curstream] == 0x81) + if ( stream->ts_pcr_out != stream->ts_pcr_in ) { - // We have to add an AC3 header in front of the data. Add its - // size to the PES packet length. - plen += 4; - tdat[4] = plen >> 8; - tdat[5] = plen; - - // Write out the PES header - int hdrsize = 9 + tdat[8]; - fwrite64(stream, tdat, hdrsize); - - // add a four byte DVD ac3 stream header - uint8_t ac3_substream_id[4]; - int ssid = (curstream - stream->ts_number_video_pids) & 0xf; - ac3_substream_id[0] = 0x80 | ssid; // substream id - ac3_substream_id[1] = 0x01; // number of sync words - ac3_substream_id[2] = 0x00; // first offset (16 bits) - ac3_substream_id[3] = 0x02; - fwrite64(stream, ac3_substream_id, 4); - - // add the rest of the data - fwrite64(stream, tdat + hdrsize, stream->ts_pos[curstream] - hdrsize); + // we have a new pcr + stream->ts_pcr_out = stream->ts_pcr_in; + buf->stop = stream->ts_pcr; + stream->ts_pcrhist[stream->ts_pcr_out & 3] = stream->ts_pcr; } else { - // not audio - don't need to modify the stream so write what we've got - tdat[4] = plen >> 8; - tdat[5] = plen; - fwrite64( stream, tdat, stream->ts_pos[curstream] ); + buf->stop = -1; } - } - else - { - // data without a PES start header needs a simple 'continuation' - // PES header. AC3 audio also needs its substream header. - if ( stream->ts_audio_stream_type[curstream] != 0x81) + + // put the PTS & possible DTS into 'start' & 'renderOffset' then strip + // off the PES header. + if ( tdat[7] & 0xc0 ) { - make_pes_header(stream, stream->ts_pos[curstream], - stream->ts_streamid[curstream]); + buf->start = pes_timestamp( tdat + 9 ); + buf->renderOffset = ( tdat[7] & 0x40 )? pes_timestamp( tdat + 14 ) : + buf->start; } else { - make_pes_header(stream, stream->ts_pos[curstream] + 4, - stream->ts_streamid[curstream]); - - // add a four byte DVD ac3 stream header - uint8_t ac3_substream_id[4]; - int ssid = (curstream - stream->ts_number_video_pids) & 0xf; - ac3_substream_id[0] = 0x80 | ssid; // substream id - ac3_substream_id[1] = 0x01; // number of sync words - ac3_substream_id[2] = 0x00; // first offset (16 bits) - ac3_substream_id[3] = 0x02; - fwrite64(stream, ac3_substream_id, 4); + buf->start = -1; + buf->renderOffset = -1; } - fwrite64( stream, tdat, stream->ts_pos[curstream] ); } + int hlen = tdat[8] + 9; - // Write padding - int left = HB_DVD_READ_BUFFER_SIZE - len; - if ( left >= 8 ) - { - pad_buffer(stream, left); - } + fwrite64( stream, tdat + hlen, stream->ts_pos[curstream] - hlen ); stream->ts_pos[curstream] = 0; + stream->ts_buf[curstream]->size = 0; } -static void ts_warn_helper( hb_stream_t *stream, char *log, va_list args ) +static void hb_ts_stream_append_pkt(hb_stream_t *stream, int idx, const uint8_t *buf, int len) { - // limit error printing to at most one per minute of video (at 30fps) - ++stream->errors; - if ( stream->frames - stream->last_error_frame >= 30*60 ) + if (stream->ts_pos[idx] + len > stream->ts_buf[idx]->alloc) { - char msg[256]; + int size; - vsnprintf( msg, sizeof(msg), log, args ); - - if ( stream->errors - stream->last_error_count < 10 ) - { - hb_log( "stream: error near frame %d: %s", stream->frames, msg ); - } - else - { - int Edelta = stream->errors - stream->last_error_count; - double Epcnt = (double)Edelta * 100. / - (stream->frames - stream->last_error_frame); - hb_log( "stream: %d new errors (%.0f%%) up to frame %d: %s", - Edelta, Epcnt, stream->frames, msg ); - } - stream->last_error_frame = stream->frames; - stream->last_error_count = stream->errors; - } -} - -static void ts_warn( hb_stream_t *stream, char *log, ... ) -{ - va_list args; - va_start( args, log ); - ts_warn_helper( stream, log, args ); - va_end( args ); -} - -static void ts_err( hb_stream_t *stream, int curstream, char *log, ... ) -{ - va_list args; - va_start( args, log ); - ts_warn_helper( stream, log, args ); - va_end( args ); - - stream->ts_skipbad[curstream] = 1; - stream->ts_pos[curstream] = 0; - stream->ts_streamcont[curstream] = -1; -} - -static int isIframe( const uint8_t *buf, int adapt_len ) -{ - // Look for the Group of Pictures packet - int i; - uint32_t strid = 0; - - for (i = 4 + adapt_len; i < 188; i++) - { - strid = (strid << 8) | buf[i]; - switch ( strid ) - { - case 0x000001B8: // group_start_code (GOP header) - case 0x000001B3: // sequence_header code - return 1; - - case 0x00000100: // picture_start_code - // picture_header, let's see if it's an I-frame - if (i<185) - { - // check if picture_coding_type == 1 - if ((buf[i+2] & (0x7 << 3)) == (1 << 3)) - { - // found an I-frame picture - return 1; - } - } - break; - } - } - // didn't find an I frame - return 0; -} + size = MAX(stream->ts_buf[idx]->alloc * 2, stream->ts_pos[idx] + len); + hb_buffer_realloc(stream->ts_buf[idx], size); + } + memcpy(stream->ts_buf[idx]->data + stream->ts_pos[idx], buf, len); + stream->ts_pos[idx] += len; + stream->ts_buf[idx]->size += len; +} /*********************************************************************** * hb_ts_stream_decode *********************************************************************** * **********************************************************************/ -static int hb_ts_stream_decode( hb_stream_t *stream, uint8_t *obuf ) +static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) { - int64_t pcr = stream->ts_lastpcr; - int curstream; - uint8_t buf[188]; - /* * stash the output buffer pointer in our stream so we don't have to * pass it & its original value to everything we call. */ + obuf->size = 0; stream->fwrite_buf = obuf; - stream->fwrite_buf_orig = obuf; // spin until we get a packet of data from some stream or hit eof while ( 1 ) { - if ((fread(buf, 188, 1, stream->file_handle)) != 1) - { + int curstream; + + const uint8_t *buf = next_packet(stream); + if ( buf == NULL ) + { // end of file - we didn't finish filling our ps write buffer // so just discard the remainder (the partial buffer is useless) hb_log("hb_ts_stream_decode - eof"); @@ -1725,24 +2269,6 @@ static int hb_ts_stream_decode( hb_stream_t *stream, uint8_t *obuf ) /* This next section validates the packet */ - // Check sync byte - if ((buf[0] != 0x47) && (buf[0] != 0x72) && (buf[0] != 0x29)) - { - // lost sync - back up to where we started then try to - // re-establish sync. - off_t pos = ftello(stream->file_handle) - 188; - off_t pos2 = align_to_next_packet(stream->file_handle); - if ( pos2 == 0 ) - { - hb_log( "hb_ts_stream_decode: eof while re-establishing sync @ %lld", - pos ); - return 0; - } - ts_warn( stream, "hb_ts_stream_decode: sync lost @%lld, " - "regained after %lld bytes", pos, pos2 ); - continue; - } - // Get pid and use it to find stream state. int pid = ((buf[1] & 0x1F) << 8) | buf[2]; if ( ( curstream = index_of_pid( pid, stream ) ) < 0 ) @@ -1776,26 +2302,36 @@ static int hb_ts_stream_decode( hb_stream_t *stream, uint8_t *obuf ) } } - // if there's an adaptation header & PCR_flag is set - // get the PCR (Program Clock Reference) - if ( adapt_len > 7 && ( buf[5] & 0x10 ) != 0 ) + if ( adapt_len > 0 ) { - pcr = ( (uint64_t)buf[6] << (33 - 8) ) | - ( (uint64_t)buf[7] << (33 - 16) ) | - ( (uint64_t)buf[8] << (33 - 24) ) | - ( (uint64_t)buf[9] << (33 - 32) ) | - ( buf[10] >> 7 ); - stream->ts_nextpcr = pcr; - - // remember the pcr across calls to this routine - stream->ts_lastpcr = pcr; + if ( buf[5] & 0x40 ) + { + // found a random access point + } + // if there's an adaptation header & PCR_flag is set + // get the PCR (Program Clock Reference) + if ( adapt_len > 7 && ( buf[5] & 0x10 ) != 0 ) + { + stream->ts_pcr = ( (uint64_t)buf[6] << (33 - 8) ) | + ( (uint64_t)buf[7] << (33 - 16) ) | + ( (uint64_t)buf[8] << (33 - 24) ) | + ( (uint64_t)buf[9] << (33 - 32) ) | + ( buf[10] >> 7 ); + ++stream->ts_pcr_in; + stream->ts_found_pcr = 1; + } } - if ( pcr == -1 ) - { - // don't accumulate data until we get a pcr - continue; - } + // If we don't have a PCR yet but the stream has PCRs just loop + // so we don't process anything until we have a clock reference. + // Unfortunately the HD Home Run appears to null out the PCR so if + // we didn't detect a PCR during scan keep going and we'll use + // the video stream DTS for the PCR. + + if ( !stream->ts_found_pcr && ( stream->ts_flags & TS_HAS_PCR ) ) + { + continue; + } // Get continuity // Continuity only increments for adaption values of 0x3 or 0x01 @@ -1808,23 +2344,60 @@ static int hb_ts_stream_decode( hb_stream_t *stream, uint8_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] && (continuity != ( (stream->ts_streamcont[curstream] + 1) & 0xf ) ) ) { ts_err( stream, curstream, "continuity error: got %d expected %d", (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 */ @@ -1832,72 +2405,103 @@ static int hb_ts_stream_decode( hb_stream_t *stream, uint8_t *obuf ) { // Found a random access point (now we can start a frame/audio packet..) + if ( stream->need_keyframe ) + { + // we're looking for the first video frame because we're + // doing random access during 'scan' + if ( curstream != 0 || !isIframe( stream, buf, adapt_len ) ) + { + // not the video stream or didn't find an I frame + // but we'll only wait 255 video frames for an I frame. + if ( curstream != 0 || ++stream->need_keyframe ) + { + continue; + } + } + stream->need_keyframe = 0; + } + // If we were skipping a bad packet, start fresh on this new PES packet.. if (stream->ts_skipbad[curstream] == 1) { - // video skips to an iframe after a bad packet to minimize - // screen corruption - if ( curstream == 0 && !isIframe( buf, adapt_len ) ) - { - continue; - } stream->ts_skipbad[curstream] = 0; } - // If we don't have video yet, check to see if this is an - // i_frame (group of picture start) if ( curstream == 0 ) { - if ( !stream->ts_foundfirst[0] ) + ++stream->frames; + + // if we don't have a pcr yet use the dts from this frame + if ( !stream->ts_found_pcr ) { - if ( !isIframe( buf, adapt_len ) ) + // PES must begin with an mpeg start code & contain + // a DTS or PTS. + const uint8_t *pes = buf + adapt_len + 4; + if ( pes[0] != 0x00 || pes[1] != 0x00 || pes[2] != 0x01 || + ( pes[7] >> 6 ) == 0 ) { - // didn't find an I frame continue; } - stream->ts_foundfirst[0] = 1; + // if we have a dts use it otherwise use the pts + stream->ts_pcr = pes_timestamp( pes + ( pes[7] & 0x40? 14 : 9 ) ); + ++stream->ts_pcr_in; } - ++stream->frames; } - else if ( ! stream->ts_foundfirst[curstream] ) + + // if this is a multiplexed stream make sure this is the + // substream we want. + if ( stream->ts_multiplexed[curstream] ) { - // start other streams only after first video frame found. - if ( ! stream->ts_foundfirst[0] ) + // PES must begin with an mpeg start code & contain + // a DTS or PTS. + const uint8_t *pes = buf + adapt_len + 4; + if ( pes[0] != 0x00 || pes[1] != 0x00 || pes[2] != 0x01 || + pes[3] != 0xfd ) { + stream->ts_skipbad[curstream] = 1; continue; } - stream->ts_foundfirst[curstream] = 1; - } + // the last byte of the header is the extension id. see if + // it's the one we want. + if ( pes[pes[8]+8] != stream->ts_multiplexed[curstream] ) + { + stream->ts_skipbad[curstream] = 1; + continue; + } + } // If we have some data already on this stream, turn it into // a program stream packet. Then add the payload for this // packet to the current pid's buffer. if ( stream->ts_pos[curstream] ) { + // we have to ship the old packet before updating the pcr + // since the packet we've been accumulating is referenced + // to the old pcr. generate_output_data(stream, curstream); - stream->ts_start[curstream] = 1; - memcpy(stream->ts_buf[curstream], - buf + 4 + adapt_len, 184 - adapt_len); - stream->ts_pos[curstream] = 184 - adapt_len; + + // remember the pcr that was in effect when we started + // this packet. + stream->ts_buf[curstream]->cur = stream->ts_pcr_in; + hb_ts_stream_append_pkt(stream, curstream, buf + 4 + adapt_len, + 184 - adapt_len); return 1; } - stream->ts_start[curstream] = 1; + // remember the pcr that was in effect when we started this packet. + stream->ts_buf[curstream]->cur = stream->ts_pcr_in; } // Add the payload for this packet to the current buffer - if (!stream->ts_skipbad[curstream] && stream->ts_foundfirst[curstream] && - (184 - adapt_len) > 0) + if (!stream->ts_skipbad[curstream] && (184 - adapt_len) > 0) { - memcpy(stream->ts_buf[curstream] + stream->ts_pos[curstream], - buf + 4 + adapt_len, 184 - adapt_len); - stream->ts_pos[curstream] += 184 - adapt_len; - - // if the next TS packet could possibly overflow our 2K output buffer - // we need to generate a packet now. Overflow would be 184 bytes of - // data + the 9 byte PES hdr + the 14 byte PACK hdr = 211 bytes. - if ( stream->ts_pos[curstream] >= (HB_DVD_READ_BUFFER_SIZE - 216) ) + hb_ts_stream_append_pkt(stream, curstream, buf + 4 + adapt_len, + 184 - adapt_len); + // see if we've hit the end of this PES packet + const uint8_t *pes = stream->ts_buf[curstream]->data; + int len = ( pes[4] << 8 ) + pes[5] + 6; + if ( len > 6 && stream->ts_pos[curstream] == len && + pes[0] == 0x00 && pes[1] == 0x00 && pes[2] == 0x01 ) { - // we have enough data to make a PS packet generate_output_data(stream, curstream); return 1; } @@ -1905,11 +2509,6 @@ static int hb_ts_stream_decode( hb_stream_t *stream, uint8_t *obuf ) } } -/*********************************************************************** - * hb_ts_stream_reset - *********************************************************************** - * - **********************************************************************/ static void hb_ts_stream_reset(hb_stream_t *stream) { int i; @@ -1917,20 +2516,549 @@ static void hb_ts_stream_reset(hb_stream_t *stream) for (i=0; i < kMaxNumberDecodeStreams; i++) { stream->ts_pos[i] = 0; - stream->ts_foundfirst[i] = 0; - stream->ts_skipbad[i] = 0; + stream->ts_skipbad[i] = 1; stream->ts_streamcont[i] = -1; - stream->ts_start[i] = 0; } - stream->ts_lastpcr = -1; - stream->ts_nextpcr = -1; + stream->need_keyframe = 0; + + stream->ts_found_pcr = 0; + stream->ts_pcr_out = 0; + stream->ts_pcr_in = 0; + stream->ts_pcr = 0; stream->frames = 0; stream->errors = 0; stream->last_error_frame = -10000; stream->last_error_count = 0; - align_to_next_packet(stream->file_handle); + align_to_next_packet(stream); +} + +// ------------------------------------------------------------------ +// Support for reading media files via the ffmpeg libraries. + +static void ffmpeg_add_codec( hb_stream_t *stream, int stream_index ) +{ + // add a codec to the context here so it will be there when we + // read the first packet. + AVCodecContext *context = stream->ffmpeg_ic->streams[stream_index]->codec; + context->workaround_bugs = FF_BUG_AUTODETECT; + context->error_recognition = 1; + context->error_concealment = FF_EC_GUESS_MVS|FF_EC_DEBLOCK; + AVCodec *codec = avcodec_find_decoder( context->codec_id ); + hb_avcodec_open( context, codec ); } +// The ffmpeg stream reader / parser shares a lot of state with the +// decoder via a codec context kept in the AVStream of the reader's +// AVFormatContext. Since decoding is done in a different thread we +// have to somehow pass this codec context to the decoder and we have +// to do it before the first packet is read (so we can't put the info +// in the buf we'll send downstream). Decoders don't have any way to +// get to the stream directly (they're not passed the title or job +// pointers during a scan) so this is a back door for the decoder to +// get the codec context. We just stick the stream pointer in the next +// slot an array of pointers maintained as a circular list then return +// the index into the list combined with the ffmpeg stream index as the +// codec_param that will be passed to the decoder init routine. We make +// the list 'big' (enough for 1024 simultaneously open ffmpeg streams) +// so that we don't have to do a complicated allocator or worry about +// deleting entries on close. +// +// Entries can only be added to this list during a scan and are never +// deleted so the list access doesn't require locking. +static hb_stream_t **ffmpeg_streams; // circular list of stream pointers +static int ffmpeg_stream_cur; // where we put the last stream pointer +#define ffmpeg_sl_bits (10) // log2 stream list size (in entries) +#define ffmpeg_sl_size (1 << ffmpeg_sl_bits) + +// add a stream to the list & return the appropriate codec_param to access it +static int ffmpeg_codec_param( hb_stream_t *stream, int stream_index ) +{ + if ( !ffmpeg_streams ) + { + ffmpeg_streams = calloc( ffmpeg_sl_size, sizeof(stream) ); + } + + // the title scan adds all the ffmpeg media streams at once so we + // only add a new entry to our stream list if the stream is different + // than last time. + int slot = ffmpeg_stream_cur; + if ( ffmpeg_streams[slot] != stream ) + { + // new stream - put it in the next slot of the stream list + slot = ++ffmpeg_stream_cur & (ffmpeg_sl_size - 1); + ffmpeg_streams[slot] = stream; + } + + ffmpeg_add_codec( stream, stream_index ); + + return ( stream_index << ffmpeg_sl_bits ) | slot; +} + +// we're about to open 'title' to convert it - remap the stream associated +// with the video & audio codec params of the title to refer to 'stream' +// (the original scan stream was closed and no longer exists). +static void ffmpeg_remap_stream( hb_stream_t *stream, hb_title_t *title ) +{ + // 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); + ffmpeg_streams[slot] = stream; + + // add codecs for all the streams used by the title + ffmpeg_add_codec( stream, title->video_codec_param >> ffmpeg_sl_bits ); + + int i; + hb_audio_t *audio; + for ( i = 0; ( audio = hb_list_item( title->list_audio, i ) ); ++i ) + { + if ( audio->config.in.codec == HB_ACODEC_FFMPEG ) + { + ffmpeg_add_codec( stream, + audio->config.in.codec_param >> ffmpeg_sl_bits ); + } + } +} + +void *hb_ffmpeg_context( int codec_param ) +{ + int slot = codec_param & (ffmpeg_sl_size - 1); + int stream_index = codec_param >> ffmpeg_sl_bits; + return ffmpeg_streams[slot]->ffmpeg_ic->streams[stream_index]->codec; +} + +void *hb_ffmpeg_avstream( int codec_param ) +{ + int slot = codec_param & (ffmpeg_sl_size - 1); + int stream_index = codec_param >> ffmpeg_sl_bits; + return ffmpeg_streams[slot]->ffmpeg_ic->streams[stream_index]; +} + +static AVFormatContext *ffmpeg_deferred_close; + +static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title ) +{ + if ( ffmpeg_deferred_close ) + { + av_close_input_file( ffmpeg_deferred_close ); + ffmpeg_deferred_close = NULL; + } + AVFormatContext *ic; + + av_log_set_level( AV_LOG_ERROR ); + if ( av_open_input_file( &ic, stream->path, NULL, 0, NULL ) < 0 ) + { + return 0; + } + if ( av_find_stream_info( ic ) < 0 ) + goto fail; + + stream->ffmpeg_ic = ic; + 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 ) + { + // we're opening for read. scan passed out codec params that + // indexed its stream so we need to remap them so they point + // to this stream. + ffmpeg_remap_stream( stream, title ); + av_log_set_level( AV_LOG_ERROR ); + } + else + { + // we're opening for scan. let ffmpeg put some info into the + // log about what we've got. + av_log_set_level( AV_LOG_INFO ); + dump_format( ic, 0, stream->path, 0 ); + av_log_set_level( AV_LOG_ERROR ); + + // accept this file if it has at least one video stream we can decode + int i; + for (i = 0; i < ic->nb_streams; ++i ) + { + if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO ) + { + break; + } + } + if ( i >= ic->nb_streams ) + goto fail; + } + return 1; + + fail: + av_close_input_file( ic ); + return 0; +} + +static void ffmpeg_close( hb_stream_t *d ) +{ + // XXX since we're sharing the CodecContext with the downstream + // decoder proc we can't close the stream. We need to reference count + // this so we can close it when both are done with their instance but + // for now just defer the close until the next stream open or close. + if ( ffmpeg_deferred_close ) + { + av_close_input_file( ffmpeg_deferred_close ); + } + ffmpeg_deferred_close = d->ffmpeg_ic; + if ( d->ffmpeg_pkt != NULL ) + { + free( d->ffmpeg_pkt ); + d->ffmpeg_pkt = NULL; + } +} + +static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id ) +{ + AVStream *st = stream->ffmpeg_ic->streams[id]; + AVCodecContext *codec = st->codec; + + // scan will ignore any audio without a bitrate. Since we've already + // typed the audio in order to determine its codec we set up the audio + // paramters here. + if ( codec->bit_rate || codec->sample_rate ) + { + static const int chan2layout[] = { + HB_INPUT_CH_LAYOUT_MONO, // We should allow no audio really. + HB_INPUT_CH_LAYOUT_MONO, + HB_INPUT_CH_LAYOUT_STEREO, + HB_INPUT_CH_LAYOUT_2F1R, + HB_INPUT_CH_LAYOUT_2F2R, + HB_INPUT_CH_LAYOUT_3F2R, + HB_INPUT_CH_LAYOUT_4F2R, + HB_INPUT_CH_LAYOUT_STEREO, + HB_INPUT_CH_LAYOUT_STEREO, + }; + + hb_audio_t *audio = calloc( 1, sizeof(*audio) );; + + audio->id = id; + if ( codec->codec_id == CODEC_ID_AC3 ) + { + audio->config.in.codec = HB_ACODEC_AC3; + } + else if ( codec->codec_id == CODEC_ID_DTS ) + { + audio->config.in.codec = HB_ACODEC_DCA; + } + else + { + audio->config.in.codec = HB_ACODEC_FFMPEG; + audio->config.in.codec_param = ffmpeg_codec_param( stream, id ); + + audio->config.in.bitrate = codec->bit_rate? codec->bit_rate : 1; + audio->config.in.samplerate = codec->sample_rate; + audio->config.in.channel_layout = chan2layout[codec->channels & 7]; + } + + set_audio_description( audio, lang_for_code2( st->language ) ); + + hb_list_add( title->list_audio, audio ); + } +} + +static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) +{ + AVFormatContext *ic = stream->ffmpeg_ic; + + // '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 + char *sep = strrchr(stream->path, '/'); + if (sep) + strcpy(title->name, sep+1); + char *dot_term = strrchr(title->name, '.'); + if (dot_term) + *dot_term = '\0'; + + uint64_t dur = ic->duration * 90000 / AV_TIME_BASE; + title->duration = dur; + dur /= 90000; + title->hours = dur / 3600; + title->minutes = ( dur % 3600 ) / 60; + title->seconds = dur % 60; + + // set the title to decode the first video stream in the file + title->demuxer = HB_NULL_DEMUXER; + title->video_codec = 0; + int i; + for (i = 0; i < ic->nb_streams; ++i ) + { + if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO && + avcodec_find_decoder( ic->streams[i]->codec->codec_id ) && + title->video_codec == 0 ) + { + title->video_id = i; + stream->ffmpeg_video_id = i; + + // We have to use the 'internal' avcodec decoder because + // it needs to share the codec context from this video + // stream. The parser internal to av_read_frame + // passes a bunch of state info to the decoder via the context. + title->video_codec = WORK_DECAVCODECVI; + title->video_codec_param = ffmpeg_codec_param( stream, i ); + } + else if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO && + avcodec_find_decoder( ic->streams[i]->codec->codec_id ) ) + { + add_ffmpeg_audio( title, stream, i ); + } + } + + title->container_name = strdup( ic->iformat->name ); + title->data_rate = ic->bit_rate; + + hb_deep_log( 2, "Found ffmpeg %d chapters, container=%s", ic->nb_chapters, ic->iformat->name ); + + if( ic->nb_chapters != 0 ) + { + AVChapter *m; + uint64_t duration_sum = 0; + for( i = 0; i < ic->nb_chapters; i++ ) + if( ( m = ic->chapters[i] ) != NULL ) + { + hb_chapter_t * chapter; + chapter = calloc( sizeof( hb_chapter_t ), 1 ); + chapter->index = i+1; + chapter->duration = ( m->end / ( (double) m->time_base.num * m->time_base.den ) ) * 90000 - duration_sum; + duration_sum += chapter->duration; + chapter->hours = chapter->duration / 90000 / 3600; + 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=%"PRIu64", (%02i:%02i:%02i)", + chapter->index, chapter->title, + chapter->duration, chapter->hours, + chapter->minutes, chapter->seconds ); + hb_list_add( title->list_chapter, chapter ); + } + } + + /* + * Fill the metadata. + */ + decmetadata( title ); + + if( hb_list_count( title->list_chapter ) == 0 ) + { + // Need at least one chapter + hb_chapter_t * chapter; + chapter = calloc( sizeof( hb_chapter_t ), 1 ); + chapter->index = 1; + chapter->duration = title->duration; + chapter->hours = title->hours; + chapter->minutes = title->minutes; + chapter->seconds = title->seconds; + hb_list_add( title->list_chapter, chapter ); + } + + return title; +} + +static int64_t av_to_hb_pts( int64_t pts, double conv_factor ) +{ + if ( pts == AV_NOPTS_VALUE ) + return -1; + return (int64_t)( (double)pts * conv_factor ); +} + +static int ffmpeg_is_keyframe( hb_stream_t *stream ) +{ + uint8_t *pkt; + + switch ( stream->ffmpeg_ic->streams[stream->ffmpeg_video_id]->codec->codec_id ) + { + case CODEC_ID_VC1: + // XXX the VC1 codec doesn't mark key frames so to get previews + // 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 ) + return 1; + + return 0; + + case CODEC_ID_WMV3: + // XXX the ffmpeg WMV3 codec doesn't mark key frames. + // Only M$ could make I-frame detection this complicated: there + // are two to four bits of unused junk ahead of the frame type + // so we have to look at the sequence header to find out how much + // to skip. Then there are three different ways of coding the type + // depending on whether it's main or advanced profile then whether + // there are bframes or not so we have to look at the sequence + // header to get that. + pkt = stream->ffmpeg_pkt->data; + uint8_t *seqhdr = stream->ffmpeg_ic->streams[stream->ffmpeg_video_id]->codec->extradata; + int pshift = 2; + if ( ( seqhdr[3] & 0x02 ) == 0 ) + // no FINTERPFLAG + ++pshift; + if ( ( seqhdr[3] & 0x80 ) == 0 ) + // no RANGEREDUCTION + ++pshift; + if ( seqhdr[3] & 0x70 ) + // stream has b-frames + return ( ( pkt[0] >> pshift ) & 0x3 ) == 0x01; + + return ( ( pkt[0] >> pshift ) & 0x2 ) == 0; + + default: + break; + } + return ( stream->ffmpeg_pkt->flags & PKT_FLAG_KEY ); +} + +static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) +{ + int err; + again: + if ( ( err = av_read_frame( stream->ffmpeg_ic, stream->ffmpeg_pkt )) < 0 ) + { + // XXX the following conditional is to handle avi files that + // use M$ 'packed b-frames' and occasionally have negative + // sizes for the null frames these require. + if ( err != AVERROR_NOMEM || stream->ffmpeg_pkt->size >= 0 ) + // eof + return 0; + } + if ( stream->ffmpeg_pkt->size <= 0 ) + { + // M$ "invalid and inefficient" packed b-frames require 'null frames' + // following them to preserve the timing (since the packing puts two + // or more frames in what looks like one avi frame). The contents and + // size of these null frames are ignored by the ff_h263_decode_frame + // as long as they're < 20 bytes. We need a positive size so we use + // one byte if we're given a zero or negative size. We don't know + // if the pkt data points anywhere reasonable so we just stick a + // byte of zero in our outbound buf. + buf->size = 1; + *buf->data = 0; + } + else + { + if ( stream->ffmpeg_pkt->size > buf->alloc ) + { + // sometimes we get absurd sizes from ffmpeg + if ( stream->ffmpeg_pkt->size >= (1 << 25) ) + { + hb_log( "ffmpeg_read: pkt too big: %d bytes", stream->ffmpeg_pkt->size ); + av_free_packet( stream->ffmpeg_pkt ); + return ffmpeg_read( stream, buf ); + } + // need to expand buffer + hb_buffer_realloc( buf, stream->ffmpeg_pkt->size ); + } + memcpy( buf->data, stream->ffmpeg_pkt->data, stream->ffmpeg_pkt->size ); + buf->size = stream->ffmpeg_pkt->size; + } + buf->id = stream->ffmpeg_pkt->stream_index; + if ( buf->id == stream->ffmpeg_video_id ) + { + if ( stream->need_keyframe ) + { + // we've just done a seek (generally for scan or live preview) and + // want to start at a keyframe. Some ffmpeg codecs seek to a key + // frame but most don't. So we spin until we either get a keyframe + // or we've looked through 50 video frames without finding one. + if ( ! ffmpeg_is_keyframe( stream ) && ++stream->need_keyframe < 50 ) + { + av_free_packet( stream->ffmpeg_pkt ); + goto again; + } + stream->need_keyframe = 0; + } + ++stream->frames; + } + + // if we haven't done it already, compute a conversion factor to go + // from the ffmpeg timebase for the stream to HB's 90KHz timebase. + double tsconv = stream->ffmpeg_tsconv[stream->ffmpeg_pkt->stream_index]; + if ( ! tsconv ) + { + AVStream *s = stream->ffmpeg_ic->streams[stream->ffmpeg_pkt->stream_index]; + tsconv = 90000. * (double)s->time_base.num / (double)s->time_base.den; + stream->ffmpeg_tsconv[stream->ffmpeg_pkt->stream_index] = tsconv; + } + + buf->start = av_to_hb_pts( stream->ffmpeg_pkt->pts, tsconv ); + buf->renderOffset = av_to_hb_pts( stream->ffmpeg_pkt->dts, tsconv ); + if ( buf->renderOffset >= 0 && buf->start == -1 ) + { + 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 + * 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. + */ + 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+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 %"PRId64, + buf->new_chap, buf->start); + } else { + // Must have run out of chapters, stop looking. + stream->chapter_end = INT64_MAX; + } + } else { + buf->new_chap = 0; + } + av_free_packet( stream->ffmpeg_pkt ); + return 1; +} + +static int ffmpeg_seek( hb_stream_t *stream, float frac ) +{ + AVFormatContext *ic = stream->ffmpeg_ic; + if ( frac > 0. ) + { + int64_t pos = (double)ic->duration * (double)frac; + if ( ic->start_time != AV_NOPTS_VALUE && ic->start_time > 0 ) + { + pos += ic->start_time; + } + av_seek_frame( ic, -1, pos, 0 ); + stream->need_keyframe = 1; + } + else + { + av_seek_frame( ic, -1, 0LL, AVSEEK_FLAG_BACKWARD ); + } + 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 ); +}