#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
* 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 { N, U, A, V } kind; /* not handled / 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 */
st(0x1b, V, WORK_DECAVCODECV, CODEC_ID_H264, "H.264"),
- st(0x80, N, 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"),
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 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;
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
static int hb_stream_check_for_ps(const uint8_t *buf)
{
- // program streams should start with a PACK then some other mpeg start
- // code (usually a SYS but that might be missing if we only have a clip).
- return check_ps_sync(buf) && check_ps_sc(buf);
+ // program streams should start with a PACK then some other mpeg start
+ // code (usually a SYS but that might be missing if we only have a clip).
+ int offset = 0;
+
+ for ( offset = 0; offset < 8*1024-24; ++offset )
+ {
+ if ( check_ps_sync( &buf[offset] ) && check_ps_sc( &buf[offset] ) )
+ return 1;
+ }
+ return 0;
}
static int hb_stream_check_for_dvd_ps(const uint8_t *buf)
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) )
{
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;
}
// '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
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 ( 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;
}
{
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;
}
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];
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 ),
/* 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.
// 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 )
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 )
{
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)
// 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) may be %s audio (id 0x%x)",
stream->ts_audio_pids[aud_pid_index],
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;
}
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;
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);
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);
if ( index_of_pid( elementary_PID, stream ) < 0 )
{
- // already have this pid - do nothing
- }
- if (stream->ts_number_video_pids == 0 && st2codec[stream_type].kind == V )
- {
- stream->ts_video_pids[0] = elementary_PID;
- stream->ts_stream_type[0] = stream_type;
- stream->ts_number_video_pids = 1;
- }
- else
- {
- // Defined audio stream types are 0x81 for AC-3/A52 audio and 0x03
- // for mpeg audio. But content producers seem to use other
- // values (0x04 and 0x06 have both been observed) so at this point
- // we say everything that isn't a video pid is audio then at the end
- // of hb_stream_title_scan we'll figure out which are really audio
- // by looking at the PES headers.
- i = stream->ts_number_audio_pids;
- if (i < kMaxNumberAudioPIDS)
+ // don't have this pid yet
+ if (stream->ts_number_video_pids == 0 &&
+ st2codec[stream_type].kind == V )
+ {
+ stream->ts_video_pids[0] = elementary_PID;
+ stream->ts_stream_type[0] = stream_type;
+ stream->ts_number_video_pids = 1;
+ }
+ else
{
- stream->ts_audio_pids[i] = elementary_PID;
- stream->ts_stream_type[1 + i] = stream_type;
- if (ES_info_length > 0)
+ // Defined audio stream types are 0x81 for AC-3/A52 audio
+ // and 0x03 for mpeg audio. But content producers seem to
+ // use other values (0x04 and 0x06 have both been observed)
+ // so at this point we say everything that isn't a video
+ // pid is audio then at the end of hb_stream_title_scan
+ // we'll figure out which are really audio by looking at
+ // the PES headers.
+ i = stream->ts_number_audio_pids;
+ if (i < kMaxNumberAudioPIDS)
{
- decode_element_descriptors(stream, i, ES_info_buf,
- ES_info_length);
+ stream->ts_audio_pids[i] = elementary_PID;
+ stream->ts_stream_type[1 + i] = stream_type;
+ if (ES_info_length > 0)
+ {
+ decode_element_descriptors(stream, i, ES_info_buf,
+ ES_info_length);
+ }
+ ++stream->ts_number_audio_pids;
}
- ++stream->ts_number_audio_pids;
}
}
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)
}
}
// 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;
}
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] &&
(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 */
// 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;
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 =
+ hb_ff_layout_xlat(codec->channel_layout, codec->channels);
}
set_audio_description( audio, lang_for_code2( st->language ) );
// '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
{
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
}
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 );
+}