X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fstream.c;h=24093e62a74d7bd072e99782454323683c70b007;hb=9972486f44c586225d98967441dcd3f3fd920636;hp=d5ab019d54d7c0009d04ecb600bbc519f74e92e7;hpb=80ad1c81fc5645d9eb010b119c614e6d282605ae;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/stream.c b/libhb/stream.c old mode 100755 new mode 100644 index d5ab019d..24093e62 --- a/libhb/stream.c +++ b/libhb/stream.c @@ -9,12 +9,17 @@ #include #include "hb.h" +#include "hbffmpeg.h" #include "lang.h" #include "a52dec/a52.h" -#include "libavcodec/avcodec.h" -#include "libavformat/avformat.h" +#include "mp4v2/mp4v2.h" #define min(a, b) a < b ? a : b +#define STR4_TO_UINT32(p) \ + ((((const uint8_t*)(p))[0] << 24) | \ + (((const uint8_t*)(p))[1] << 16) | \ + (((const uint8_t*)(p))[2] << 8) | \ + ((const uint8_t*)(p))[3]) /* * This table defines how ISO MPEG stream type codes map to HandBrake @@ -25,8 +30,9 @@ * Entries with a worker proc id of 0 or a kind of 'U' indicate that HB * doesn't handle the stream type. */ +typedef enum { N, U, A, V } kind_t; typedef struct { - enum { U = 1, A, V } kind; /* unknown / audio / video */ + kind_t 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 */ @@ -40,26 +46,26 @@ static const stream2codec_t st2codec[256] = { 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, U, 0, 0, "ISO 13818-1 private section"), + st(0x05, N, 0, 0, "ISO 13818-1 private section"), st(0x06, U, 0, 0, "ISO 13818-1 PES private data"), - st(0x07, U, 0, 0, "ISO 13522 MHEG"), - st(0x08, U, 0, 0, "ISO 13818-1 DSM-CC"), - st(0x09, U, 0, 0, "ISO 13818-1 auxiliary"), - st(0x0a, U, 0, 0, "ISO 13818-6 encap"), - st(0x0b, U, 0, 0, "ISO 13818-6 DSM-CC U-N msgs"), - st(0x0c, U, 0, 0, "ISO 13818-6 Stream descriptors"), - st(0x0d, U, 0, 0, "ISO 13818-6 Sections"), - st(0x0e, U, 0, 0, "ISO 13818-1 auxiliary"), + 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, U, 0, 0, "ISO 13818-6 DSM-CC download"), + st(0x14, N, 0, 0, "ISO 13818-6 DSM-CC download"), st(0x1b, V, WORK_DECAVCODECV, CODEC_ID_H264, "H.264"), - //st(0x80, U, 0, 0, "DigiCipher II Video"), + st(0x80, N, HB_ACODEC_MPGA, CODEC_ID_PCM_BLURAY, "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"), @@ -71,7 +77,7 @@ static const stream2codec_t st2codec[256] = { st(0x8a, A, HB_ACODEC_DCA, 0, "DTS"), st(0x91, A, HB_ACODEC_AC3, 0, "AC-3"), - st(0x92, U, 0, 0, "Subtitle"), + st(0x92, N, 0, 0, "Subtitle"), st(0x94, A, 0, 0, "SDDS"), st(0xa0, V, 0, 0, "MSCODEC"), @@ -89,7 +95,7 @@ typedef enum { } hb_stream_type_t; #define kMaxNumberVideoPIDS 1 -#define kMaxNumberAudioPIDS 15 +#define kMaxNumberAudioPIDS 31 #define kMaxNumberDecodeStreams (kMaxNumberVideoPIDS+kMaxNumberAudioPIDS) #define kMaxNumberPMTStreams 32 @@ -102,10 +108,8 @@ struct hb_stream_s int last_error_count; /* # errors at last error message */ int packetsize; /* Transport Stream packet size */ - int8_t need_keyframe; // non-zero if want to start at a keyframe - int8_t ts_no_RAP; // non-zero if there are no random access points - - int8_t ts_found_pcr; // non-zero if we've found at least one input pcr + 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 @@ -116,9 +120,13 @@ struct hb_stream_s int ts_pos[kMaxNumberDecodeStreams]; int8_t ts_skipbad[kMaxNumberDecodeStreams]; int8_t ts_streamcont[kMaxNumberDecodeStreams]; + uint8_t ts_pkt_summary[kMaxNumberDecodeStreams][8]; hb_buffer_t *fwrite_buf; /* PS buffer (set by hb_ts_stream_decode) */ + int chapter; /* Chapter that we are currently in */ + int64_t chapter_end; /* HB time that the current chapter ends */ + /* * Stuff before this point is dynamic state updated as we read the * stream. Stuff after this point is stream description state that @@ -127,6 +135,11 @@ struct hb_stream_s */ 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]; @@ -170,8 +183,8 @@ struct hb_stream_s int section_length; int program_number; unsigned int PCR_PID; + uint32_t reg_desc; int program_info_length; - unsigned char *progam_info_descriptor_data; struct { unsigned char stream_type; @@ -200,6 +213,7 @@ static void ffmpeg_close( hb_stream_t *d ); static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ); static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ); static int ffmpeg_seek( hb_stream_t *stream, float frac ); +static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts ); /* * streams have a bunch of state that's learned during the scan. We don't @@ -269,9 +283,12 @@ static void ts_warn_helper( hb_stream_t *stream, char *log, va_list args ) } } +static void ts_warn( hb_stream_t*, char*, ... ) HB_WPRINTF(2,3); +static void ts_err( hb_stream_t*, int, char*, ... ) HB_WPRINTF(3,4); + static void ts_warn( hb_stream_t *stream, char *log, ... ) { - va_list args; + va_list args; va_start( args, log ); ts_warn_helper( stream, log, args ); va_end( args ); @@ -279,7 +296,7 @@ static void ts_warn( hb_stream_t *stream, char *log, ... ) static void ts_err( hb_stream_t *stream, int curstream, char *log, ... ) { - va_list args; + va_list args; va_start( args, log ); ts_warn_helper( stream, log, args ); va_end( args ); @@ -297,14 +314,13 @@ static int check_ps_sync(const uint8_t *buf) (buf[2] == 0x01) && (buf[3] == 0xba); } -static int check_ps_sys(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 - // SYS. If we've already verified the pack, this skips over it and checks - // for the sys header. + // 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) && (buf[pos+3] == 0xbb); + return (buf[pos+0] == 0x00) && (buf[pos+1] == 0x00) && (buf[pos+2] == 0x01); } static int check_ts_sync(const uint8_t *buf) @@ -344,8 +360,16 @@ static int hb_stream_check_for_ts(const uint8_t *buf) static int hb_stream_check_for_ps(const uint8_t *buf) { - // program streams should start with a PACK then a SYS header. - return check_ps_sync(buf) && check_ps_sys(buf); + // program streams should start with a PACK then some other mpeg start + // code (usually a SYS but that might be missing if we only have a clip). + int offset = 0; + + for ( offset = 0; offset < 8*1024-24; ++offset ) + { + if ( check_ps_sync( &buf[offset] ) && check_ps_sc( &buf[offset] ) ) + return 1; + } + return 0; } static int hb_stream_check_for_dvd_ps(const uint8_t *buf) @@ -359,6 +383,7 @@ static int hb_stream_check_for_dvd_ps(const uint8_t *buf) static int hb_stream_get_type(hb_stream_t *stream) { uint8_t buf[2048*4]; + int i = 64; if ( fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) ) { @@ -384,12 +409,17 @@ static int hb_stream_get_type(hb_stream_t *stream) stream->hb_stream_type = dvd_program; return 1; } - if ( hb_stream_check_for_ps(buf) != 0 ) + do { - hb_log("file is MPEG Program Stream"); - stream->hb_stream_type = program; - return 1; - } + if ( hb_stream_check_for_ps(buf) != 0 ) + { + hb_log("file is MPEG Program Stream"); + stream->hb_stream_type = program; + return 1; + } + // Seek back to handle start codes that run over end of last buffer + fseek( stream->file_handle, -28, SEEK_CUR ); + } while ( --i && fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) ); } return 0; } @@ -426,6 +456,37 @@ 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 *********************************************************************** @@ -433,7 +494,7 @@ static void hb_stream_delete( hb_stream_t *d ) **********************************************************************/ 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 ); @@ -473,17 +534,16 @@ hb_stream_t * hb_stream_open( char *path, hb_title_t *title ) int i = 0; for ( ; i < d->ts_number_video_pids + d->ts_number_audio_pids; i++) { + 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. ); - - if ( d->packetsize == 188 ) - { - // Assume that an over-the-air transport stream can lose PCR - // packets and try to filter out the timing inconsistencies. - title->flaky_clock = 1; - } } return d; } @@ -580,7 +640,10 @@ void hb_stream_close( hb_stream_t ** _d ) * of the media stream for HB. */ static void hb_stream_delete_audio_entry(hb_stream_t *stream, int indx) { - stream->ts_audio_pids[indx] = -stream->ts_audio_pids[indx]; + if ( stream->ts_audio_pids[indx] > 0 ) + { + stream->ts_audio_pids[indx] = -stream->ts_audio_pids[indx]; + } } static int index_of_pid(int pid, hb_stream_t *stream) @@ -609,6 +672,7 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) // 'Barebones Title' hb_title_t *aTitle = hb_title_init( stream->path, 0 ); + aTitle->type = HB_STREAM_TYPE; aTitle->index = 1; // Copy part of the stream path to the title name @@ -668,6 +732,17 @@ hb_title_t * hb_stream_title_scan(hb_stream_t *stream) 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 { @@ -701,10 +776,10 @@ static const uint8_t *next_packet( hb_stream_t *stream ) off_t pos2 = align_to_next_packet(stream); if ( pos2 == 0 ) { - hb_log( "next_packet: eof while re-establishing sync @ %lld", pos ); + hb_log( "next_packet: eof while re-establishing sync @ %"PRId64, pos ); return NULL; } - ts_warn( stream, "next_packet: sync lost @ %lld, regained after %lld bytes", + ts_warn( stream, "next_packet: sync lost @ %"PRId64", regained after %"PRId64" bytes", pos, pos2 ); } } @@ -736,42 +811,87 @@ static void skip_to_next_pack( hb_stream_t *src_stream ) } } -/* - * scan the next MB of 'stream' to try to find a random access point - */ -static void hb_ts_stream_find_RAP( hb_stream_t *stream ) +static int isIframe( hb_stream_t *stream, const uint8_t *buf, int adapt_len ) { - off_t starting_point = ftello(stream->file_handle); - int npack = 300000; // max packets to read + // 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; - while (--npack >= 0) + + if ( stream->ts_stream_type[0] <= 2 ) { - off_t cur = ftello(stream->file_handle); - const uint8_t *buf = next_packet( stream ); - if ( buf == NULL ) - { - break; - } - switch (buf[3] & 0x30) + // This section of the code handles MPEG-1 and MPEG-2 video streams + for (i = 13 + adapt_len; i < 188; i++) { - case 0x00: // illegal - continue; - - case 0x20: // fill packet - case 0x30: // adaptation - if ( buf[5] & 0x40 ) + strid = (strid << 8) | buf[i]; + if ( ( strid >> 8 ) == 1 ) + { + // we found a start code + uint8_t id = strid; + switch ( id ) { - // found a random access point - fseeko( stream->file_handle, cur, SEEK_SET ); - return; + 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; } - continue; + } + } + // 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; } - /* didn't find it */ - fseeko( stream->file_handle, starting_point, SEEK_SET ); - stream->ts_no_RAP = 1; + // we don't understand the stream type so just say "yes" otherwise + // we'll discard all the video. + return 1; } /* @@ -791,12 +911,28 @@ static const uint8_t *hb_ts_stream_getPEStype(hb_stream_t *stream, uint32_t pid) return 0; } + // 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 ) + { + 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; @@ -898,7 +1034,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. @@ -914,12 +1050,12 @@ static struct pts_pos hb_sample_pts(hb_stream_t *stream, uint64_t fpos) buf = hb_ts_stream_getPEStype( stream, stream->ts_video_pids[0] ); if ( buf == NULL ) { - hb_log("hb_sample_pts: couldn't find video packet near %llu", fpos); + hb_log("hb_sample_pts: couldn't find video packet near %"PRIu64, fpos); return pp; } if ( ( buf[7] >> 7 ) != 1 ) { - hb_log("hb_sample_pts: no PTS in video packet near %llu", fpos); + hb_log("hb_sample_pts: no PTS in video packet near %"PRIu64, fpos); return pp; } pp.pts = ( ( (uint64_t)buf[9] >> 1 ) & 7 << 30 ) | @@ -927,6 +1063,14 @@ 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 { @@ -955,7 +1099,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. @@ -970,11 +1114,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 )) / @@ -1065,6 +1211,37 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) ep = b->data + b->alloc; } *cp++ = c; + // Non-video streams can emulate start codes, so we need + // to inspect PES packets and skip over their data + // sections to avoid mis-detection of the next pack header. + if ( ( strt_code >> 8 ) == 0x000001 && + ( strt_code & 0xff ) >= 0xbb ) + { + int len = 0; + c = getc_unlocked( src_stream->file_handle ); + if ( c == EOF ) + break; + len = c << 8; + c = getc_unlocked( src_stream->file_handle ); + if ( c == EOF ) + break; + len |= c; + if ( cp+len+2 > ep ) + { + // need to expand the buffer + int curSize = cp - b->data; + if ( curSize * 2 > curSize+len+2 ) + hb_buffer_realloc( b, curSize * 2 ); + else + hb_buffer_realloc( b, curSize + len + 2 ); + cp = b->data + curSize; + ep = b->data + b->alloc; + } + *cp++ = len >> 8; + *cp++ = len & 0xff; + fread( cp, 1, len, src_stream->file_handle ); + cp += len; + } } funlockfile( src_stream->file_handle ); @@ -1074,13 +1251,81 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b ) if ( c != EOF ) { fseeko( src_stream->file_handle, -4, SEEK_CUR ); - b->size -= 4; + // Only 3 of the 4 bytes read were added to the buffer. + b->size -= 3; } return 1; } return hb_ts_stream_decode( src_stream, b ); } +int64_t ffmpeg_initial_timestamp( hb_stream_t * stream ) +{ + AVStream *s = stream->ffmpeg_ic->streams[stream->ffmpeg_video_id]; + if ( s->nb_index_entries < 1 ) + return 0; + + return s->index_entries[0].timestamp; +} +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 ) + ffmpeg_initial_timestamp( stream ); + + 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, ffmpeg_initial_timestamp( stream ), 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 *********************************************************************** @@ -1114,12 +1359,11 @@ int hb_stream_seek( hb_stream_t * stream, float f ) hb_ts_stream_reset(stream); if ( f > 0 ) { - if ( !stream->ts_no_RAP ) + if ( stream->ts_IDRs ) { - // we're not at the beginning - try to find a random access point - hb_ts_stream_find_RAP( stream ); + // the stream has IDRs so look for one. + stream->need_keyframe = 1; } - stream->need_keyframe = 1; } else { @@ -1136,6 +1380,15 @@ int hb_stream_seek( hb_stream_t * stream, float f ) return 1; } +int hb_stream_seek_ts( hb_stream_t * stream, int64_t ts ) +{ + if ( stream->hb_stream_type == ffmpeg ) + { + return ffmpeg_seek_ts( stream, ts ); + } + return -1; +} + static const char* make_upper( const char* s ) { static char name[8]; @@ -1190,6 +1443,18 @@ static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang ) sizeof( audio->config.lang.description ), "%s (%s)", strlen(lang->native_name) ? lang->native_name : lang->eng_name, codec_name ); + + if (audio->config.in.codec == HB_ACODEC_FFMPEG) + { + int layout = audio->config.in.channel_layout; + char *desc = audio->config.lang.description + + strlen( audio->config.lang.description ); + sprintf( desc, " (%d.%d ch)", + HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) + + HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout), + HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) ); + } + 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 ), @@ -1209,9 +1474,12 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, /* check that we found a PES header */ uint8_t stype = 0; + kind_t kind; + if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01) { stype = stream->ts_stream_type[1 + aud_pid_index]; + kind = st2codec[stype].kind; // 0xbd ("private stream 1") is the normal container for non-ISO // media - AC3/DCA/PCM/etc. @@ -1224,6 +1492,15 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, // some other type of audio we'll end up ignoring them). stype = 0x81; stream->ts_stream_type[1 + aud_pid_index] = 0x81; + kind = st2codec[stype].kind; + } + if ( stype == 0x80 && + stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") ) + { + // LPCM audio in bluray have an stype of 0x80 + // 0x80 is used for other DigiCipher normally + // To distinguish, Bluray streams have a reg_desc of HDMV + kind = A; } } else if ( buf[3] == 0xfd ) @@ -1243,6 +1520,7 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, stream->ts_multiplexed[1 + aud_pid_index] = 0x76; stype = 0x81; stream->ts_stream_type[1 + aud_pid_index] = 0x81; + kind = st2codec[stype].kind; } if ( st2codec[stype].kind == A && stype == 0x86 ) { @@ -1251,6 +1529,7 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, stream->ts_multiplexed[1 + aud_pid_index] = 0x71; stype = 0x82; stream->ts_stream_type[1 + aud_pid_index] = 0x82; + kind = st2codec[stype].kind; } } else if ((buf[3] & 0xe0) == 0xc0) @@ -1262,23 +1541,25 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream, // XXX assume unknown stream types are MPEG audio stype = 0x03; stream->ts_stream_type[1 + aud_pid_index] = 0x03; + kind = st2codec[stype].kind; } } else { stype = 0; + kind = st2codec[stype].kind; } } // 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 ) + if ( 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, + 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) is %s audio id 0x%x", + 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); } @@ -1420,35 +1701,45 @@ static void hb_ts_stream_init(hb_stream_t *stream) static off_t align_to_next_packet(hb_stream_t *stream) { uint8_t buf[MAX_HOLE]; - off_t pos = 0; + off_t pos = 0; off_t start = ftello(stream->file_handle); + off_t orig; if ( start >= stream->packetsize ) { start -= stream->packetsize; fseeko(stream->file_handle, start, SEEK_SET); } + orig = start; - if (fread(buf, sizeof(buf), 1, stream->file_handle) == 1) - { - const uint8_t *bp = buf; - int i; - - for ( i = sizeof(buf); --i >= 0; ++bp ) + while (1) + { + if (fread(buf, sizeof(buf), 1, stream->file_handle) == 1) { - if ( have_ts_sync( bp, stream->packetsize ) ) + const uint8_t *bp = buf; + int i; + + for ( i = sizeof(buf) - 8 * stream->packetsize; --i >= 0; ++bp ) + { + if ( have_ts_sync( bp, stream->packetsize ) ) + { + break; + } + } + if ( i >= 0 ) { + pos = ( bp - buf ) - stream->packetsize + 188; break; } + fseeko(stream->file_handle, -8 * stream->packetsize, SEEK_CUR); + start = ftello(stream->file_handle); } - if ( i >= 0 ) + else { - pos = ( bp - buf ) - stream->packetsize + 188; - if ( pos < 0 ) - pos = 0; + return 0; } - } + } fseeko(stream->file_handle, start+pos, SEEK_SET); - return pos; + return start - orig + pos; } @@ -1523,7 +1814,7 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, switch (dp[0]) { case 5: // Registration descriptor - stream->ts_format_id[esindx] = (dp[2] << 24) | (dp[3] << 16) | + stream->ts_format_id[esindx+1] = (dp[2] << 24) | (dp[3] << 16) | (dp[4] << 8) | dp[5]; break; @@ -1531,6 +1822,10 @@ static void decode_element_descriptors(hb_stream_t* stream, int esindx, stream->a52_info[esindx].lang_code = lang_to_code(lang_for_code2((const char *)&dp[2])); break; + case 0x6a: // DVB AC-3 descriptor + stream->ts_stream_type[esindx+1] = 0x81; + break; + default: break; } @@ -1546,7 +1841,7 @@ static const char *stream_type_name (uint8_t stream_type) int decode_program_map(hb_stream_t* stream) { bitbuf_t bb; - set_buf(&bb, stream->pmt_info.tablebuf, stream->pmt_info.tablepos, 0); + set_buf(&bb, stream->pmt_info.tablebuf, stream->pmt_info.tablepos, 0); get_bits(&bb, 8); // table_id get_bits(&bb, 4); @@ -1561,22 +1856,44 @@ int decode_program_map(hb_stream_t* stream) get_bits(&bb, 8); // section_number get_bits(&bb, 8); // last_section_number get_bits(&bb, 3); - unsigned int PCR_PID = get_bits(&bb, 13); - stream->pmt_info.PCR_PID = PCR_PID; + stream->pmt_info.PCR_PID = get_bits(&bb, 13); get_bits(&bb, 4); - unsigned int program_info_length = get_bits(&bb, 12); + int program_info_length = get_bits(&bb, 12); stream->pmt_info.program_info_length = program_info_length; - int i=0; - unsigned char *descriptor_buf = (unsigned char *) malloc(program_info_length); - for (i = 0; i < program_info_length; i++) - { - descriptor_buf[i] = get_bits(&bb, 8); - } + int i; + for (i = 0; i < program_info_length - 2; ) + { + uint8_t tag, len; + tag = get_bits(&bb, 8); + len = get_bits(&bb, 8); + i += 2; + if ( i + len > program_info_length ) + { + break; + } + if (tag == 0x05 && len >= 4) + { + // registration descriptor + stream->pmt_info.reg_desc = get_bits(&bb, 32); + i += 4; + len -= 4; + } + int j; + for ( j = 0; j < len; j++ ) + { + get_bits(&bb, 8); + } + i += len; + } + for ( ; i < program_info_length; i++ ) + { + get_bits(&bb, 8); + } - int cur_pos = 9 /* data after the section length field*/ + program_info_length; - int done_reading_stream_types = 0; - while (!done_reading_stream_types) + 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); @@ -1594,33 +1911,35 @@ int decode_program_map(hb_stream_t* stream) if ( index_of_pid( elementary_PID, stream ) < 0 ) { - // already have this pid - do nothing - } - if (stream->ts_number_video_pids == 0 && st2codec[stream_type].kind == V ) - { - stream->ts_video_pids[0] = elementary_PID; - stream->ts_stream_type[0] = stream_type; - stream->ts_number_video_pids = 1; - } - else - { - // Defined audio stream types are 0x81 for AC-3/A52 audio and 0x03 - // for mpeg audio. But content producers seem to use other - // values (0x04 and 0x06 have both been observed) so at this point - // we say everything that isn't a video pid is audio then at the end - // of hb_stream_title_scan we'll figure out which are really audio - // by looking at the PES headers. - i = stream->ts_number_audio_pids; - if (i < kMaxNumberAudioPIDS) + // don't have this pid yet + if (stream->ts_number_video_pids == 0 && + st2codec[stream_type].kind == V ) { - stream->ts_audio_pids[i] = elementary_PID; - stream->ts_stream_type[1 + i] = stream_type; - if (ES_info_length > 0) + stream->ts_video_pids[0] = elementary_PID; + stream->ts_stream_type[0] = stream_type; + stream->ts_number_video_pids = 1; + } + else + { + // Defined audio stream types are 0x81 for AC-3/A52 audio + // and 0x03 for mpeg audio. But content producers seem to + // use other values (0x04 and 0x06 have both been observed) + // so at this point we say everything that isn't a video + // pid is audio then at the end of hb_stream_title_scan + // we'll figure out which are really audio by looking at + // the PES headers. + i = stream->ts_number_audio_pids; + if (i < kMaxNumberAudioPIDS) { - decode_element_descriptors(stream, i, ES_info_buf, - ES_info_length); + stream->ts_audio_pids[i] = elementary_PID; + stream->ts_stream_type[1 + i] = stream_type; + if (ES_info_length > 0) + { + decode_element_descriptors(stream, i, ES_info_buf, + ES_info_length); + } + ++stream->ts_number_audio_pids; } - ++stream->ts_number_audio_pids; } } @@ -1629,11 +1948,10 @@ int decode_program_map(hb_stream_t* stream) free(ES_info_buf); if (cur_pos >= section_length - 4 /* stop before the CRC */) - done_reading_stream_types = 1; + done_reading_stream_types = 1; } - free(descriptor_buf); - return 1; + return 1; } static int build_program_map(const uint8_t *buf, hb_stream_t *stream) @@ -1818,7 +2136,13 @@ static int decode_PAT(const uint8_t *buf, hb_stream_t *stream) static void hb_ts_stream_find_pids(hb_stream_t *stream) { - // align to first packet + // To be different from every other broadcaster in the world, New Zealand TV + // changes PMTs (and thus video & audio PIDs) when 'programs' change. Since + // we may have the tail of the previous program at the beginning of this + // file, take our PMT from the middle of the file. + fseeko(stream->file_handle, 0, SEEK_END); + uint64_t fsize = ftello(stream->file_handle); + fseeko(stream->file_handle, fsize >> 1, SEEK_SET); align_to_next_packet(stream); // Read the Transport Stream Packets (188 bytes each) looking at first for PID 0 (the PAT PID), then decode that @@ -1865,17 +2189,9 @@ static void hb_ts_stream_find_pids(hb_stream_t *stream) } } // Keep going until we have a complete set of PIDs - if ((stream->ts_number_video_pids > 0) && (stream->ts_number_audio_pids > 0)) + if (stream->ts_number_video_pids > 0) break; } - // XXX - until we figure out how to handle VC1 just bail when we find it so - // that ffmpeg will claim the input stream. - if ( stream->ts_stream_type[0] == 0xea ) - { - stream->ts_number_video_pids = 0; - stream->ts_number_audio_pids = 0; - return; - } hb_log("hb_ts_stream_find_pids - found the following PIDS"); hb_log(" Video PIDS : "); @@ -1900,16 +2216,17 @@ static void hb_ts_stream_find_pids(hb_stream_t *stream) static void fwrite64( hb_stream_t *stream, void *buf, int len ) { - int pos; - - pos = stream->fwrite_buf->size; - if ( pos + len > stream->fwrite_buf->alloc ) + if ( len > 0 ) { - int size = MAX(stream->fwrite_buf->alloc * 2, pos + len); - hb_buffer_realloc(stream->fwrite_buf, size); + 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->data[pos]), buf, len ); - stream->fwrite_buf->size += len; } // convert a PES PTS or DTS to an int64 @@ -1981,92 +2298,6 @@ static void generate_output_data(hb_stream_t *stream, int curstream) stream->ts_buf[curstream]->size = 0; } -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: ??? - 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; - - if ( stream->packetsize == 192 ) - { - // m2ts files have idr frames so keep looking for one - continue; - } - - // h.264 in ts files (ATSC or DVB video) often seem to be - // missing IDR frames so look for at least an I - if ( nal_type == 0x01 ) - { - // h.264 slice: has to be start MB 0 & type I (2, 4, 7 or 9) - uint8_t id = buf[i+1]; - if ( ( id >> 4 ) == 0x0b || ( id >> 2 ) == 0x25 || - id == 0x88 || id == 0x8a ) - { - 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; -} - static void hb_ts_stream_append_pkt(hb_stream_t *stream, int idx, const uint8_t *buf, int len) { if (stream->ts_pos[idx] + len > stream->ts_buf[idx]->alloc) @@ -2164,11 +2395,16 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) } } - // If we don't have a pcr yet, the right thing to do here would - // be a 'continue' so we don't process anything until we have a - // clock reference. Unfortunately the HD Home Run appears to null - // out the pcr field of some streams so we keep going & substitute - // the video stream dts for the pcr when there's no pcr. + // 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 @@ -2181,11 +2417,31 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) int continuity = (buf[3] & 0xF); if ( continuity == stream->ts_streamcont[curstream] ) { - // we got a duplicate packet (usually used to introduce - // a PCR when one is needed). The only thing that can - // change in the dup is the PCR which we grabbed above - // so ignore the rest. - continue; + // Spliced transport streams can have duplicate + // continuity counts at the splice boundary. + // Test to see if the packet is really a duplicate + // by comparing packet summaries to see if they + // match. + uint8_t summary[8]; + + summary[0] = adaption; + summary[1] = adapt_len; + if (adapt_len + 4 + 6 + 9 <= 188) + { + memcpy(&summary[2], buf+4+adapt_len+9, 6); + } + else + { + memset(&summary[2], 0, 6); + } + if ( memcmp( summary, stream->ts_pkt_summary[curstream], 8 ) == 0 ) + { + // we got a duplicate packet (usually used to introduce + // a PCR when one is needed). The only thing that can + // change in the dup is the PCR which we grabbed above + // so ignore the rest. + continue; + } } if ( !start && (stream->ts_streamcont[curstream] != -1) && !stream->ts_skipbad[curstream] && @@ -2195,10 +2451,26 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) (int)continuity, (stream->ts_streamcont[curstream] + 1) & 0xf ); stream->ts_streamcont[curstream] = continuity; - continue; - } - stream->ts_streamcont[curstream] = continuity; - } + continue; + } + stream->ts_streamcont[curstream] = continuity; + + // Save a summary of this packet for later duplicate + // testing. The summary includes some header information + // and payload bytes. Should be enough to detect + // non-duplicates. + stream->ts_pkt_summary[curstream][0] = adaption; + stream->ts_pkt_summary[curstream][1] = adapt_len; + if (adapt_len + 4 + 6 + 9 <= 188) + { + memcpy(&stream->ts_pkt_summary[curstream][2], + buf+4+adapt_len+9, 6); + } + else + { + memset(&stream->ts_pkt_summary[curstream][2], 0, 6); + } + } /* If we get here the packet is valid - process its data */ @@ -2210,10 +2482,14 @@ static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf ) { // we're looking for the first video frame because we're // doing random access during 'scan' - if (curstream != 0 || !isIframe( stream, buf, adapt_len ) ) + if ( curstream != 0 || !isIframe( stream, buf, adapt_len ) ) { // not the video stream or didn't find an I frame - continue; + // but we'll only wait 255 video frames for an I frame. + if ( curstream != 0 || ++stream->need_keyframe ) + { + continue; + } } stream->need_keyframe = 0; } @@ -2344,7 +2620,7 @@ static void ffmpeg_add_codec( hb_stream_t *stream, int stream_index ) context->error_recognition = 1; context->error_concealment = FF_EC_GUESS_MVS|FF_EC_DEBLOCK; AVCodec *codec = avcodec_find_decoder( context->codec_id ); - avcodec_open( context, codec ); + hb_avcodec_open( context, codec ); } // The ffmpeg stream reader / parser shares a lot of state with the @@ -2399,9 +2675,6 @@ static int ffmpeg_codec_param( hb_stream_t *stream, int stream_index ) // (the original scan stream was closed and no longer exists). static void ffmpeg_remap_stream( hb_stream_t *stream, hb_title_t *title ) { - // tell ffmpeg we want a pts on every frame it returns - stream->ffmpeg_ic->flags |= AVFMT_FLAG_GENPTS; - // all the video & audio came from the same stream so remapping // the video's stream slot takes care of everything. int slot = title->video_codec_param & (ffmpeg_sl_size - 1); @@ -2459,6 +2732,7 @@ static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title ) stream->hb_stream_type = ffmpeg; stream->ffmpeg_pkt = malloc(sizeof(*stream->ffmpeg_pkt)); av_init_packet( stream->ffmpeg_pkt ); + stream->chapter_end = INT64_MAX; if ( title ) { @@ -2517,24 +2791,19 @@ 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; + int layout; // 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. + layout = hb_ff_layout_xlat( codec->channel_layout, codec->channels ); + if ( !layout ) + { + // Unsupported layout + return; + } 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; @@ -2553,7 +2822,7 @@ static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int 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]; + audio->config.in.channel_layout = layout; } set_audio_description( audio, lang_for_code2( st->language ) ); @@ -2562,12 +2831,182 @@ static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id ) } } +/* + * Format: + * MkvVobSubtitlePrivateData = ( Line )* + * Line = FieldName ':' ' ' FieldValue '\n' + * FieldName = [^:]+ + * FieldValue = [^\n]+ + * + * The line of interest is: + * PaletteLine = "palette" ':' ' ' RRGGBB ( ',' ' ' RRGGBB )* + * + * More information on the format at: + * http://www.matroska.org/technical/specs/subtitles/images.html + */ +static int ffmpeg_parse_vobsub_extradata_mkv( AVCodecContext *codec, hb_subtitle_t *subtitle ) +{ + // lines = (string) codec->extradata; + char *lines = malloc( codec->extradata_size + 1 ); + if ( lines == NULL ) + return 1; + memcpy( lines, codec->extradata, codec->extradata_size ); + lines[codec->extradata_size] = '\0'; + + uint32_t rgb[16]; + int gotPalette = 0; + int gotDimensions = 0; + + char *curLine, *curLine_parserData; + for ( curLine = strtok_r( lines, "\n", &curLine_parserData ); + curLine; + curLine = strtok_r( NULL, "\n", &curLine_parserData ) ) + { + if (!gotPalette) + { + int numElementsRead = sscanf(curLine, "palette: " + "%06x, %06x, %06x, %06x, " + "%06x, %06x, %06x, %06x, " + "%06x, %06x, %06x, %06x, " + "%06x, %06x, %06x, %06x", + &rgb[0], &rgb[1], &rgb[2], &rgb[3], + &rgb[4], &rgb[5], &rgb[6], &rgb[7], + &rgb[8], &rgb[9], &rgb[10], &rgb[11], + &rgb[12], &rgb[13], &rgb[14], &rgb[15]); + + if (numElementsRead == 16) { + gotPalette = 1; + } + } + if (!gotDimensions) + { + int numElementsRead = sscanf(curLine, "size: %dx%d", + &subtitle->width, &subtitle->height); + + if (numElementsRead == 2) { + gotDimensions = 1; + } + } + if (gotPalette && gotDimensions) + break; + } + + if (subtitle->width == 0 || subtitle->height == 0) + { + subtitle->width = 720; + subtitle->height = 480; + } + + free( lines ); + + if ( gotPalette ) + { + int i; + for (i=0; i<16; i++) + subtitle->palette[i] = hb_rgb2yuv(rgb[i]); + return 0; + } + else + { + return 1; + } +} + +/* + * Format: 8-bit {0,Y,Cb,Cr} x 16 + */ +static int ffmpeg_parse_vobsub_extradata_mp4( AVCodecContext *codec, hb_subtitle_t *subtitle ) +{ + if ( codec->extradata_size != 4*16 ) + return 1; + + int i, j; + for ( i=0, j=0; i<16; i++, j+=4 ) + { + subtitle->palette[i] = + codec->extradata[j+1] << 16 | // Y + codec->extradata[j+2] << 8 | // Cb + codec->extradata[j+3] << 0; // Cr + } + if (codec->width <= 0 || codec->height <= 0) + { + subtitle->width = 720; + subtitle->height = 480; + } + else + { + subtitle->width = codec->width; + subtitle->height = codec->height; + } + return 0; +} + +/* + * Parses the 'subtitle->palette' information from the specific VOB subtitle track's private data. + * Returns 0 if successful or 1 if parsing failed or was incomplete. + */ +static int ffmpeg_parse_vobsub_extradata( AVCodecContext *codec, hb_subtitle_t *subtitle ) +{ + // XXX: Better if we actually chose the correct parser based on the input container + return + ffmpeg_parse_vobsub_extradata_mkv( codec, subtitle ) && + ffmpeg_parse_vobsub_extradata_mp4( codec, subtitle ); +} + +static void add_ffmpeg_subtitle( hb_title_t *title, hb_stream_t *stream, int id ) +{ + AVStream *st = stream->ffmpeg_ic->streams[id]; + AVCodecContext *codec = st->codec; + + hb_subtitle_t *subtitle = calloc( 1, sizeof(*subtitle) ); + + subtitle->id = id; + + switch ( codec->codec_id ) + { + case CODEC_ID_DVD_SUBTITLE: + subtitle->format = PICTURESUB; + subtitle->source = VOBSUB; + subtitle->config.dest = RENDERSUB; // By default render (burn-in) the VOBSUB. + if ( ffmpeg_parse_vobsub_extradata( codec, subtitle ) ) + hb_log( "add_ffmpeg_subtitle: malformed extradata for VOB subtitle track; " + "subtitle colors likely to be wrong" ); + break; + case CODEC_ID_TEXT: + subtitle->format = TEXTSUB; + subtitle->source = UTF8SUB; + subtitle->config.dest = PASSTHRUSUB; + break; + case CODEC_ID_MOV_TEXT: // TX3G + subtitle->format = TEXTSUB; + subtitle->source = TX3GSUB; + subtitle->config.dest = PASSTHRUSUB; + break; + case CODEC_ID_SSA: + subtitle->format = TEXTSUB; + subtitle->source = SSASUB; + subtitle->config.dest = PASSTHRUSUB; + break; + default: + hb_log( "add_ffmpeg_subtitle: unknown subtitle stream type: 0x%x", (int) codec->codec_id ); + free(subtitle); + return; + } + + iso639_lang_t *language = lang_for_code2( st->language ); + strcpy( subtitle->lang, language->eng_name ); + strncpy( subtitle->iso639_2, language->iso639_2, 4 ); + + hb_list_add(title->list_subtitle, subtitle); +} + 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 @@ -2585,16 +3024,6 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) title->minutes = ( dur % 3600 ) / 60; title->seconds = dur % 60; - // 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 ); - // set the title to decode the first video stream in the file title->demuxer = HB_NULL_DEMUXER; title->video_codec = 0; @@ -2605,6 +3034,13 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) avcodec_find_decoder( ic->streams[i]->codec->codec_id ) && title->video_codec == 0 ) { + AVCodecContext *context = ic->streams[i]->codec; + if ( context->pix_fmt != PIX_FMT_YUV420P && + !sws_isSupportedInput( context->pix_fmt ) ) + { + hb_log( "ffmpeg_title_scan: Unsupported color space" ); + continue; + } title->video_id = i; stream->ffmpeg_video_id = i; @@ -2620,11 +3056,59 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream ) { add_ffmpeg_audio( title, stream, i ); } + else if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_SUBTITLE ) + { + add_ffmpeg_subtitle( 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; } @@ -2635,6 +3119,52 @@ static int64_t av_to_hb_pts( int64_t pts, double conv_factor ) 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; @@ -2681,16 +3211,15 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) buf->id = stream->ffmpeg_pkt->stream_index; if ( buf->id == stream->ffmpeg_video_id ) { - if ( stream->need_keyframe && - stream->ffmpeg_ic->streams[stream->ffmpeg_video_id]->codec->codec_id == - CODEC_ID_VC1 ) + if ( stream->need_keyframe ) { - // XXX the VC1 codec doesn't seek to 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. - uint8_t *pkt = stream->ffmpeg_pkt->data; - if ( pkt[0] || pkt[1] || pkt[2] != 1 || pkt[3] != 0x0f ) + // 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; @@ -2714,6 +3243,65 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) { buf->start = buf->renderOffset; } + else if ( buf->renderOffset == -1 && buf->start >= 0 ) + { + buf->renderOffset = buf->start; + } + + /* + * Fill out buf->stop for subtitle packets + * + * libavcodec's MKV demuxer stores the duration of UTF-8 subtitles (CODEC_ID_TEXT) + * in the 'convergence_duration' field for some reason. + * + * Other subtitles' durations are stored in the 'duration' field. + * + * VOB subtitles (CODEC_ID_DVD_SUBTITLE) do not have their duration stored in + * either field. This is not a problem because the VOB decoder can extract this + * information from the packet payload itself. + * + * SSA subtitles (CODEC_ID_SSA) do not have their duration stored in + * either field. This is not a problem because the SSA decoder can extract this + * information from the packet payload itself. + */ + enum CodecID ffmpeg_pkt_codec = stream->ffmpeg_ic->streams[stream->ffmpeg_pkt->stream_index]->codec->codec_id; + if ( ffmpeg_pkt_codec == CODEC_ID_TEXT ) { + int64_t ffmpeg_pkt_duration = stream->ffmpeg_pkt->convergence_duration; + int64_t buf_duration = av_to_hb_pts( ffmpeg_pkt_duration, tsconv ); + buf->stop = buf->start + buf_duration; + } + if ( ffmpeg_pkt_codec == CODEC_ID_MOV_TEXT ) { + int64_t ffmpeg_pkt_duration = stream->ffmpeg_pkt->duration; + int64_t buf_duration = av_to_hb_pts( ffmpeg_pkt_duration, tsconv ); + buf->stop = buf->start + buf_duration; + } + + /* + * 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; } @@ -2721,15 +3309,32 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf ) static int ffmpeg_seek( hb_stream_t *stream, float frac ) { AVFormatContext *ic = stream->ffmpeg_ic; - int64_t pos = (double)ic->duration * (double)frac; - if ( pos ) + 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, pos, AVSEEK_FLAG_BACKWARD ); + 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 + ffmpeg_initial_timestamp( stream ); + 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 ); +}