state->last_scr = scr;
}
-/* Basic MPEG demuxer */
-
-int hb_demux_ps( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
+static inline void save_chap( hb_psdemux_t *state, hb_buffer_t *buf )
{
- hb_buffer_t * buf_es;
- int pos = 0;
-
-#define d (buf_ps->data)
-
- /* pack_header */
- if( d[pos] != 0 || d[pos+1] != 0 ||
- d[pos+2] != 0x1 || d[pos+3] != 0xBA )
+ if ( state && buf->new_chap )
{
- hb_log( "hb_demux_ps: not a PS packet (%02x%02x%02x%02x)",
- d[pos], d[pos+1], d[pos+2], d[pos+3] );
- return 0;
+ state->new_chap = buf->new_chap;
+ buf->new_chap = 0;
}
- pos += 4; /* pack_start_code */
+}
+static inline void restore_chap( hb_psdemux_t *state, hb_buffer_t *buf )
+{
if ( state )
{
- /* extract the system clock reference (scr) */
- int64_t scr = ((uint64_t)(d[pos] & 0x38) << 27) |
- ((uint64_t)(d[pos] & 0x03) << 28) |
- ((uint64_t)(d[pos+1]) << 20) |
- ((uint64_t)(d[pos+2] >> 3) << 15) |
- ((uint64_t)(d[pos+2] & 3) << 13) |
- ((uint64_t)(d[pos+3]) << 5) |
- (d[pos+4] >> 3);
- check_mpeg_scr( state, scr, 300 );
+ buf->new_chap = state->new_chap;
+ state->new_chap = 0;
}
+}
- pos += 9; /* pack_header */
- pos += 1 + ( d[pos] & 0x7 ); /* stuffing bytes */
-
- /* system_header */
- if( d[pos] == 0 && d[pos+1] == 0 &&
- d[pos+2] == 0x1 && d[pos+3] == 0xBB )
- {
- int header_length;
+/* Basic MPEG demuxer */
- pos += 4; /* system_header_start_code */
- header_length = ( d[pos] << 8 ) + d[pos+1];
- pos += 2 + header_length;
- }
+void hb_demux_ps( hb_buffer_t * buf, hb_list_t * list_es, hb_psdemux_t* state )
+{
+ hb_buffer_t * buf_es;
+ int pos = 0;
- /* pes */
- while( pos + 6 < buf_ps->size &&
- d[pos] == 0 && d[pos+1] == 0 && d[pos+2] == 0x1 )
+ while ( buf )
{
- int id;
- int pes_packet_length;
- int pes_packet_end;
- int pes_header_d_length;
- int pes_header_end;
- int has_pts;
- int64_t pts = -1, dts = -1;
-
- pos += 3; /* packet_start_code_prefix */
- id = d[pos];
- pos += 1;
+ save_chap( state, buf );
+#define d (buf->data)
/* pack_header */
- if( id == 0xBA)
+ if( d[pos] != 0 || d[pos+1] != 0 ||
+ d[pos+2] != 0x1 || d[pos+3] != 0xBA )
{
- pos += 10 + (d[pos+9] & 7);
+ hb_log( "hb_demux_ps: not a PS packet (%02x%02x%02x%02x)",
+ d[pos], d[pos+1], d[pos+2], d[pos+3] );
+ hb_buffer_t *tmp = buf->next;
+ buf->next = NULL;
+ hb_buffer_close( &buf );
+ buf = tmp;
continue;
}
+ pos += 4; /* pack_start_code */
+
+ if ( state )
+ {
+ /* extract the system clock reference (scr) */
+ int64_t scr = ((uint64_t)(d[pos] & 0x38) << 27) |
+ ((uint64_t)(d[pos] & 0x03) << 28) |
+ ((uint64_t)(d[pos+1]) << 20) |
+ ((uint64_t)(d[pos+2] >> 3) << 15) |
+ ((uint64_t)(d[pos+2] & 3) << 13) |
+ ((uint64_t)(d[pos+3]) << 5) |
+ (d[pos+4] >> 3);
+ check_mpeg_scr( state, scr, 300 );
+ }
+
+ pos += 9; /* pack_header */
+ pos += 1 + ( d[pos] & 0x7 ); /* stuffing bytes */
/* system_header */
- if( id == 0xBB )
+ if( d[pos] == 0 && d[pos+1] == 0 &&
+ d[pos+2] == 0x1 && d[pos+3] == 0xBB )
{
int header_length;
+ pos += 4; /* system_header_start_code */
header_length = ( d[pos] << 8 ) + d[pos+1];
pos += 2 + header_length;
- continue;
}
- pes_packet_length = ( d[pos] << 8 ) + d[pos+1];
- pos += 2; /* pes_packet_length */
- pes_packet_end = pos + pes_packet_length;
-
- if( id != 0xE0 && id != 0xBD &&
- ( id & 0xC0 ) != 0xC0 )
+ /* pes */
+ while( pos + 6 < buf->size &&
+ d[pos] == 0 && d[pos+1] == 0 && d[pos+2] == 0x1 )
{
- /* Not interesting */
- pos = pes_packet_end;
- continue;
- }
+ int id;
+ int pes_packet_length;
+ int pes_packet_end;
+ int pes_header_d_length;
+ int pes_header_end;
+ int has_pts;
+ int64_t pts = -1, dts = -1;
+
+ pos += 3; /* packet_start_code_prefix */
+ id = d[pos];
+ pos += 1;
+
+ /* pack_header */
+ if( id == 0xBA)
+ {
+ pos += 10 + (d[pos+9] & 7);
+ continue;
+ }
- has_pts = d[pos+1] >> 6;
- pos += 2; /* Required headers */
+ /* system_header */
+ if( id == 0xBB )
+ {
+ int header_length;
- pes_header_d_length = d[pos];
- pos += 1;
- pes_header_end = pos + pes_header_d_length;
+ header_length = ( d[pos] << 8 ) + d[pos+1];
+ pos += 2 + header_length;
+ continue;
+ }
- if( has_pts )
- {
- pts = ( (uint64_t)(d[pos] & 0xe ) << 29 ) +
- ( d[pos+1] << 22 ) +
- ( ( d[pos+2] >> 1 ) << 15 ) +
- ( d[pos+3] << 7 ) +
- ( d[pos+4] >> 1 );
- if ( has_pts & 1 )
+ pes_packet_length = ( d[pos] << 8 ) + d[pos+1];
+ pos += 2; /* pes_packet_length */
+ pes_packet_end = pos + pes_packet_length;
+
+ if( id != 0xE0 && id != 0xBD &&
+ ( id & 0xC0 ) != 0xC0 )
{
- dts = ( (uint64_t)(d[pos+5] & 0xe ) << 29 ) +
- ( d[pos+6] << 22 ) +
- ( ( d[pos+7] >> 1 ) << 15 ) +
- ( d[pos+8] << 7 ) +
- ( d[pos+9] >> 1 );
+ /* Not interesting */
+ pos = pes_packet_end;
+ continue;
}
- else
+
+ has_pts = d[pos+1] >> 6;
+ pos += 2; /* Required headers */
+
+ pes_header_d_length = d[pos];
+ pos += 1;
+ pes_header_end = pos + pes_header_d_length;
+
+ if( has_pts )
{
- dts = pts;
+ pts = ( (uint64_t)(d[pos] & 0xe ) << 29 ) +
+ ( d[pos+1] << 22 ) +
+ ( ( d[pos+2] >> 1 ) << 15 ) +
+ ( d[pos+3] << 7 ) +
+ ( d[pos+4] >> 1 );
+ if ( has_pts & 1 )
+ {
+ dts = ( (uint64_t)(d[pos+5] & 0xe ) << 29 ) +
+ ( d[pos+6] << 22 ) +
+ ( ( d[pos+7] >> 1 ) << 15 ) +
+ ( d[pos+8] << 7 ) +
+ ( d[pos+9] >> 1 );
+ }
+ else
+ {
+ dts = pts;
+ }
}
- }
- pos = pes_header_end;
+ pos = pes_header_end;
- if( id == 0xBD )
- {
- id |= ( d[pos] << 8 );
- if( ( id & 0xF0FF ) == 0x80BD ) /* A52 */
+ if( id == 0xBD )
{
- pos += 4;
+ id |= ( d[pos] << 8 );
+ if( ( id & 0xF0FF ) == 0x80BD ) /* A52 */
+ {
+ pos += 4;
+ }
+ else if( ( id & 0xE0FF ) == 0x20BD || /* SPU */
+ ( id & 0xF0FF ) == 0xA0BD ) /* LPCM */
+ {
+ pos += 1;
+ }
}
- else if( ( id & 0xE0FF ) == 0x20BD || /* SPU */
- ( id & 0xF0FF ) == 0xA0BD ) /* LPCM */
+
+ /* Sanity check */
+ if( pos >= pes_packet_end )
{
- pos += 1;
+ pos = pes_packet_end;
+ continue;
}
- }
- /* Sanity check */
- if( pos >= pes_packet_end )
- {
- pos = pes_packet_end;
- continue;
- }
+ /* Here we hit we ES payload */
+ buf_es = hb_buffer_init( pes_packet_end - pos );
- /* Here we hit we ES payload */
- buf_es = hb_buffer_init( pes_packet_end - pos );
-
- buf_es->id = id;
- buf_es->start = pts;
- buf_es->renderOffset = dts;
- buf_es->stop = -1;
- if (id == 0xE0) {
- // Consume a chapter break, and apply it to the ES.
- buf_es->new_chap = buf_ps->new_chap;
- buf_ps->new_chap = 0;
- }
- memcpy( buf_es->data, d + pos, pes_packet_end - pos );
+ buf_es->id = id;
+ buf_es->start = pts;
+ buf_es->renderOffset = dts;
+ buf_es->stop = -1;
+ if ( state && id == 0xE0)
+ {
+ // Consume a chapter break, and apply it to the ES.
+ restore_chap( state, buf_es );
+ }
+ memcpy( buf_es->data, d + pos, pes_packet_end - pos );
- hb_list_add( list_es, buf_es );
+ hb_list_add( list_es, buf_es );
- pos = pes_packet_end;
+ pos = pes_packet_end;
+ }
+ hb_buffer_t *tmp = buf->next;
+ buf->next = NULL;
+ hb_buffer_close( &buf );
+ buf = tmp;
}
-
#undef d
-
- return 1;
}
// mpeg transport stream demuxer. the elementary stream headers have been
-// stripped off and buf_ps has all the info gleaned from them: id is set,
+// stripped off and buf has all the info gleaned from them: id is set,
// start contains the pts (if any), renderOffset contains the dts (if any)
// and stop contains the pcr (if it changed).
-int hb_demux_ts( hb_buffer_t *buf_ps, hb_list_t *list_es, hb_psdemux_t *state )
+void hb_demux_ts( hb_buffer_t *buf, hb_list_t *list_es, hb_psdemux_t *state )
{
- if ( state )
+ while ( buf )
{
- if ( buf_ps->discontinuity )
+ save_chap( state, buf );
+ if ( state )
{
- // Buffer has been flagged as a discontinuity. This happens
- // when a blueray changes clips.
- ++state->scr_changes;
- state->last_scr = buf_ps->start;
- }
+ if ( buf->discontinuity )
+ {
+ // Buffer has been flagged as a discontinuity. This happens
+ // when a blueray changes clips.
+ ++state->scr_changes;
+ state->last_scr = buf->start;
+ }
- // we're keeping track of timing (i.e., not in scan)
- // check if there's a new pcr in this packet
- if ( buf_ps->stop >= 0 )
- {
- // we have a new pcr
- check_mpeg_scr( state, buf_ps->stop, 300 );
- buf_ps->stop = -1;
- }
- if ( buf_ps->start >= 0 )
- {
- // Program streams have an SCR in every PACK header so they
- // can't lose their clock reference. But the PCR in Transport
- // streams is typically on <.1% of the packets. If a PCR
- // packet gets lost and it marks a clock discontinuity then
- // the data following it will be referenced to the wrong
- // clock & introduce huge gaps or throw our A/V sync off.
- // We try to protect against that here by sanity checking
- // timestamps against the current reference clock and discarding
- // packets where the DTS is "too far" from its clock.
- int64_t fdelta = buf_ps->start - state->last_scr;
- if ( fdelta < -300 * 90000LL || fdelta > 300 * 90000LL )
+ // we're keeping track of timing (i.e., not in scan)
+ // check if there's a new pcr in this packet
+ if ( buf->pcr >= 0 )
{
- // packet too far behind or ahead of its clock reference
- ++state->dts_drops;
- return 1;
+ // we have a new pcr
+ check_mpeg_scr( state, buf->pcr, 300 );
+ buf->pcr = -1;
}
- if ( state->last_pts >= 0 )
+ if ( buf->start >= 0 )
{
- fdelta = buf_ps->start - state->last_pts;
- if ( fdelta < -5 * 90000LL || fdelta > 5 * 90000LL )
+ // Program streams have an SCR in every PACK header so they
+ // can't lose their clock reference. But the PCR in Transport
+ // streams is typically on <.1% of the packets. If a PCR
+ // packet gets lost and it marks a clock discontinuity then
+ // the data following it will be referenced to the wrong
+ // clock & introduce huge gaps or throw our A/V sync off.
+ // We try to protect against that here by sanity checking
+ // timestamps against the current reference clock and discarding
+ // packets where the DTS is "too far" from its clock.
+ int64_t fdelta = buf->start - state->last_scr;
+ if ( fdelta < -300 * 90000LL || fdelta > 300 * 90000LL )
+ {
+ // packet too far behind or ahead of its clock reference
+ ++state->dts_drops;
+ hb_buffer_t *tmp = buf->next;
+ buf->next = NULL;
+ hb_buffer_close( &buf );
+ buf = tmp;
+ continue;
+ }
+ if ( state->last_pts >= 0 )
{
- // Packet too far from last. This may be a NZ TV broadcast
- // as they like to change the PCR without sending a PCR
- // update. Since it may be a while until they actually tell
- // us the new PCR use the PTS as the PCR.
- ++state->scr_changes;
- state->last_scr = buf_ps->start;
+ fdelta = buf->start - state->last_pts;
+ if ( fdelta < -5 * 90000LL || fdelta > 5 * 90000LL )
+ {
+ // Packet too far from last. This may be a NZ TV broadcast
+ // as they like to change the PCR without sending a PCR
+ // update. Since it may be a while until they actually tell
+ // us the new PCR use the PTS as the PCR.
+ ++state->scr_changes;
+ state->last_scr = buf->start;
+ }
}
+ state->last_pts = buf->start;
+ }
+
+ if ( buf->type == VIDEO_BUF )
+ {
+ restore_chap( state, buf );
}
- state->last_pts = buf_ps->start;
}
- }
- hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
- hb_buffer_swap_copy( buf_ps, buf );
- if (buf->type == VIDEO_BUF) {
- // Consume a chapter break
- buf_ps->new_chap = 0;
+ hb_buffer_t *tmp = buf->next;
+ buf->next = NULL;
+ hb_list_add( list_es, buf );
+ buf = tmp;
}
- hb_list_add( list_es, buf );
-
- return 1;
}
// "null" demuxer (makes a copy of input buf & returns it in list)
// used when the reader for some format includes its own demuxer.
// for example, ffmpeg.
-int hb_demux_null( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
+void hb_demux_null( hb_buffer_t * buf, hb_list_t * list_es, hb_psdemux_t* state )
{
- // if we don't have a time offset yet, use this timestamp as the offset.
- if ( state && state->scr_changes == 0 &&
- ( buf_ps->start >= 0 || buf_ps->renderOffset >= 0 ) )
+ while ( buf )
{
- ++state->scr_changes;
- state->last_scr = buf_ps->start >= 0 ? buf_ps->start : buf_ps->renderOffset;
- }
+ save_chap( state, buf );
+ if ( state )
+ {
+ // if we don't have a time offset yet,
+ // use this timestamp as the offset.
+ if ( state->scr_changes == 0 &&
+ ( buf->start >= 0 || buf->renderOffset >= 0 ) )
+ {
+ ++state->scr_changes;
+ state->last_scr = buf->start >= 0 ? buf->start : buf->renderOffset;
+ }
- hb_buffer_t *buf = hb_buffer_init( buf_ps->alloc );
- hb_buffer_swap_copy( buf_ps, buf );
- hb_list_add( list_es, buf );
+ if ( buf->type == VIDEO_BUF )
+ {
+ restore_chap( state, buf );
+ }
+ }
- return 1;
+ hb_buffer_t *tmp = buf->next;
+ buf->next = NULL;
+ hb_list_add( list_es, buf );
+ buf = tmp;
+ }
}
const hb_muxer_t hb_demux[] = { hb_demux_ps, hb_demux_ts, hb_demux_null };
#include "lang.h"
#include "a52dec/a52.h"
#include "mp4v2/mp4v2.h"
+#include "libbluray/bluray.h"
#define min(a, b) a < b ? a : b
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(0x0f, A, HB_ACODEC_MPGA, CODEC_ID_AAC, "AAC"),
st(0x10, V, WORK_DECAVCODECV, CODEC_ID_MPEG4, "MPEG4"),
- st(0x11, A, HB_ACODEC_MPGA, CODEC_ID_AAC_LATM, "MPEG4 LATM AAC"),
+ st(0x11, A, HB_ACODEC_MPGA, CODEC_ID_AAC_LATM, "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, HB_ACODEC_MPGA, CODEC_ID_PCM_BLURAY, "DigiCipher II Video/LPCM"),
- 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/TrueHD"),
- st(0x84, A, 0, 0, "SDDS/EAC3"),
- st(0x85, U, 0, 0, "ATSC Program ID/DTS-HD HRA"),
+ st(0x80, N, HB_ACODEC_MPGA, CODEC_ID_PCM_BLURAY, "Digicipher II Video"),
+ st(0x81, A, HB_ACODEC_AC3, 0, "AC3"),
+ st(0x82, A, HB_ACODEC_DCA, 0, "DTS"),
+ st(0x83, A, HB_ACODEC_LPCM, 0, "LPCM"),
+ st(0x84, U, 0, 0, "SDDS"),
+ st(0x85, U, 0, 0, "ATSC Program ID"),
st(0x86, A, HB_ACODEC_DCA, 0, "DTS-HD MA"),
- st(0x87, A, HB_ACODEC_MPGA, CODEC_ID_EAC3, "EAC3"),
+ st(0x87, A, HB_ACODEC_MPGA, CODEC_ID_EAC3, "E-AC3"),
st(0x8a, A, HB_ACODEC_DCA, 0, "DTS"),
- st(0x91, A, HB_ACODEC_AC3, 0, "AC-3"),
+ st(0x91, A, HB_ACODEC_AC3, 0, "AC3"),
st(0x92, N, 0, 0, "Subtitle"),
- st(0x94, A, 0, 0, "SDDS"),
+ st(0x94, U, 0, 0, "SDDS"),
st(0xa0, V, 0, 0, "MSCODEC"),
- st(0xea, V, WORK_DECAVCODECV, CODEC_ID_VC1, "VC1"),
+ st(0xea, V, WORK_DECAVCODECV, CODEC_ID_VC1, "VC-1"),
};
#undef st
} hb_stream_type_t;
#define kMaxNumberDecodeStreams 32
+#define kMaxNumberDecodeSubStreams 2
#define kMaxNumberPMTStreams 32
+typedef struct {
+ hb_buffer_t *buf;
+ hb_buffer_t *extra_buf;
+ int8_t skipbad;
+ int8_t continuity;
+ uint8_t pkt_summary[8];
+ int16_t pid;
+
+ uint32_t format_id;
+#define TS_FORMAT_ID_AC3 (('A' << 24) | ('C' << 16) | ('-' << 8) | '3')
+ uint8_t stream_type;
+ kind_t stream_kind;
+ int number_substreams;
+ uint8_t substream_type[kMaxNumberDecodeSubStreams];
+ uint8_t current_substream;
+ struct {
+ int lang_code;
+ int flags;
+ int rate;
+ int bitrate;
+ } a52_info;
+} hb_ts_stream_t;
struct hb_stream_s
{
int packetsize; /* Transport Stream packet size */
uint8_t need_keyframe; // non-zero if want to start at a keyframe
+ 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 */
+
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
+ int64_t ts_pcr_current; // circular buffer of output pcrs
uint8_t *ts_packet; /* buffer for one TS packet */
- hb_buffer_t *ts_buf[kMaxNumberDecodeStreams];
- 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 */
+ hb_ts_stream_t ts[kMaxNumberDecodeStreams];
/*
* Stuff before this point is dynamic state updated as we read the
#define TS_HAS_RSEI (1 << 2) // "Restart point" SEI seen
uint8_t ts_IDRs; // # IDRs found during duration scan
- int16_t ts_pids[kMaxNumberDecodeStreams];
-
- uint32_t ts_format_id[kMaxNumberDecodeStreams];
-#define TS_FORMAT_ID_AC3 (('A' << 24) | ('C' << 16) | ('-' << 8) | '3')
- uint8_t ts_stream_type[kMaxNumberDecodeStreams];
- kind_t ts_stream_kind[kMaxNumberDecodeStreams];
- uint8_t ts_multiplexed[kMaxNumberDecodeStreams];
char *path;
FILE *file_handle;
double ffmpeg_tsconv[MAX_STREAMS];
uint8_t ffmpeg_video_id;
- struct {
- int lang_code;
- int flags;
- int rate;
- int bitrate;
- } a52_info[kMaxNumberDecodeStreams];
-
struct
{
unsigned short program_number;
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, hb_buffer_t *obuf);
+static hb_buffer_t * hb_ts_stream_decode(hb_stream_t *stream);
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 idx);
+static void hb_ts_stream_set_audio_list(hb_list_t *list_audio, hb_stream_t *stream);
static void hb_ps_stream_find_audio_ids(hb_stream_t *stream, hb_title_t *title);
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 hb_buffer_t *ffmpeg_read( hb_stream_t *stream );
static int ffmpeg_seek( hb_stream_t *stream, float frac );
static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts );
static kind_t ts_stream_kind( hb_stream_t *stream, int curstream )
{
- return st2codec[stream->ts_stream_type[curstream]].kind;
+ return st2codec[stream->ts[curstream].stream_type].kind;
}
static int index_of_pid(hb_stream_t *stream, int pid)
int i;
for ( i = 0; i < stream->ts_number_pids; ++i )
- if ( pid == stream->ts_pids[i] )
+ {
+ if ( pid == stream->ts[i].pid )
+ {
return i;
+ }
+ }
return -1;
}
int i;
for ( i = 0; i < stream->ts_number_pids; ++i )
- if ( V == stream->ts_stream_kind[i] )
+ if ( V == stream->ts[i].stream_kind )
return i;
return -1;
ts_warn_helper( stream, log, args );
va_end( args );
- stream->ts_skipbad[curstream] = 1;
- stream->ts_pos[curstream] = 0;
- stream->ts_streamcont[curstream] = -1;
+ stream->ts[curstream].skipbad = 1;
+ stream->ts[curstream].continuity = -1;
}
static int check_ps_sync(const uint8_t *buf)
}
for (i = 0; i < kMaxNumberDecodeStreams; i++)
{
- if (d->ts_buf[i])
+ if (d->ts[i].buf)
{
- hb_buffer_close(&(d->ts_buf[i]));
- d->ts_buf[i] = NULL;
+ hb_buffer_close(&(d->ts[i].buf));
+ hb_buffer_close(&(d->ts[i].extra_buf));
+ d->ts[i].buf = NULL;
+ d->ts[i].extra_buf = NULL;
}
}
}
free( d );
}
+static int find_substream( hb_ts_stream_t *ts, int substream )
+{
+ int i, all_match = -1;
+
+ if ( ts->number_substreams == 0 )
+ return 0;
+
+ for ( i = 0; i < ts->number_substreams; i++ )
+ {
+ if ( ts->substream_type[i] == 0 )
+ all_match = 0;
+ if ( ts->substream_type[i] == substream )
+ {
+ return ts->substream_type[i];
+ }
+ }
+ return all_match;
+}
+
+static void remove_substream( hb_ts_stream_t *ts, int idx )
+{
+ int i;
+
+ for ( i = idx; i < ts->number_substreams-1; i++ )
+ {
+ ts->substream_type[i] = ts->substream_type[i+1];
+ }
+ ts->number_substreams--;
+}
+
static int audio_inactive( hb_stream_t *stream, int idx )
{
- int pid = stream->ts_pids[idx];
+ int pid = stream->ts[idx].pid;
if ( pid < 0 )
{
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 )
+ // Must go backwards thru the list of substreams because we may
+ // remove one which would shift the list down.
+ int j;
+ for ( j = stream->ts[idx].number_substreams - 1; j >= 0; j-- )
{
- hb_audio_t *audio = hb_list_item( stream->title->list_audio, i );
- if ( audio->id == pid )
+ int substream = stream->ts[idx].substream_type[j];
+
+ // 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 )
{
- return 0;
+ hb_audio_t *audio = hb_list_item( stream->title->list_audio, i );
+ if ( audio->id == ((substream << 16) | pid) )
+ {
+ return 0;
+ }
}
+ remove_substream( &stream->ts[idx], j );
}
// not in the title's audio list - declare the PID inactive
- stream->ts_pids[idx] = -stream->ts_pids[idx];
+ stream->ts[idx].pid = -stream->ts[idx].pid;
return 1;
}
int i;
for ( i = 0; i < d->ts_number_pids; i++)
{
- if ( d->ts_stream_kind[i] == A &&
+ if ( d->ts[i].stream_kind == A &&
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;
+ d->ts[i].buf = hb_buffer_init(d->packetsize);
+ d->ts[i].extra_buf = hb_buffer_init(d->packetsize);
+ d->ts[i].buf->size = 0;
+ d->ts[i].extra_buf->size = 0;
}
hb_stream_seek( d, 0. );
}
hb_stream_t *d = calloc( sizeof( hb_stream_t ), 1 );
if ( d == NULL )
{
- hb_log( "hb_bd_stream_open: can't allocate space for stream state" );
+ hb_error( "hb_bd_stream_open: can't allocate space for stream state" );
return NULL;
}
for (ii = 0; ii < kMaxNumberDecodeStreams; ii++)
{
- d->ts_streamcont[ii] = -1;
- d->ts_pids[ii] = -1;
+ d->ts[ii].continuity = -1;
+ d->ts[ii].pid = -1;
}
d->file_handle = NULL;
d->ts_packet = NULL;
d->ts_number_pids = 0;
- d->ts_pids[0] = title->video_id;
- d->ts_stream_type[0] = title->video_stream_type;
- d->ts_stream_kind[0] = V;
+ d->ts[0].pid = title->video_id;
+ d->ts[0].stream_type = title->video_stream_type;
+ d->ts[0].stream_kind = V;
+ d->ts[0].substream_type[0] = 0;
+ d->ts[0].number_substreams = 1;
d->ts_number_pids++;
hb_audio_t * audio;
for ( ii = 0; ( audio = hb_list_item( title->list_audio, ii ) ); ++ii )
{
- d->ts_pids[d->ts_number_pids] = audio->id;
- d->ts_stream_type[d->ts_number_pids] = audio->config.in.stream_type;
- d->ts_stream_kind[d->ts_number_pids] = A;
+ int pid = audio->id & 0xFFFF;
+ int idx = index_of_pid( d, pid );
- if ( d->ts_stream_type[d->ts_number_pids] == 0x83 &&
- title->reg_desc == STR4_TO_UINT32("HDMV") )
+ if ( idx < 0 )
{
- // This is an interleaved TrueHD/AC-3 stream and the esid of
- // the AC-3 is 0x76
- d->ts_multiplexed[d->ts_number_pids] = 0x76;
- d->ts_stream_type[d->ts_number_pids] = 0x81;
+ // New pid
+ d->ts[d->ts_number_pids].pid = audio->id & 0xFFFF;
+ d->ts[d->ts_number_pids].stream_type = audio->config.in.stream_type;
+ d->ts[d->ts_number_pids].substream_type[0] = audio->config.in.substream_type;
+ d->ts[d->ts_number_pids].number_substreams = 1;
+ d->ts[d->ts_number_pids].stream_kind = A;
+ d->ts_number_pids++;
}
- if ( d->ts_stream_type[d->ts_number_pids] == 0x86 &&
- title->reg_desc == STR4_TO_UINT32("HDMV") )
+ else if ( d->ts[idx].number_substreams < kMaxNumberDecodeSubStreams )
{
- // This is an interleaved DTS-HD MA/DTS stream and the esid of
- // the DTS is 0x71
- d->ts_multiplexed[d->ts_number_pids] = 0x71;
- d->ts_stream_type[d->ts_number_pids] = 0x82;
+ d->ts[idx].substream_type[d->ts[idx].number_substreams] =
+ audio->config.in.substream_type;
+ d->ts[idx].number_substreams++;
+ d->ts[idx].stream_kind = A;
}
- if ( d->ts_stream_type[d->ts_number_pids] == 0x85 &&
- title->reg_desc == STR4_TO_UINT32("HDMV") )
+ else
{
- // DTS-HD HRA audio in bluray has an stype of 0x85
- // which conflicts with ATSC Program ID
- // To distinguish, Bluray streams have a reg_desc of HDMV
- // This is an interleaved DTS-HD HRA/DTS stream and the esid of
- // the DTS is 0x71
- d->ts_multiplexed[d->ts_number_pids] = 0x71;
- d->ts_stream_type[d->ts_number_pids] = 0x82;
+ hb_error( "hb_bd_stream_open: Too many substreams. Dropping audio 0x%x.", audio->id );
}
- if ( d->ts_stream_type[d->ts_number_pids] == 0x84 &&
- title->reg_desc == STR4_TO_UINT32("HDMV") )
- {
- // EAC3 audio in bluray has an stype of 0x84
- // which conflicts with SDDS
- // To distinguish, Bluray streams have a reg_desc of HDMV
- d->ts_stream_type[d->ts_number_pids] = 0x87;
- }
-
- d->ts_number_pids++;
}
d->ts_flags = TS_HAS_RAP;
if ( index_of_pid( d, title->pcr_pid ) < 0 )
{
// BD PCR PID is specified to always be 0x1001
- d->ts_pids[d->ts_number_pids] = 0x1001;
- d->ts_stream_kind[d->ts_number_pids] = P;
+ d->ts[d->ts_number_pids].pid = 0x1001;
+ d->ts[d->ts_number_pids].stream_kind = P;
+ d->ts[d->ts_number_pids].number_substreams = 1;
+ d->ts[d->ts_number_pids].substream_type[0] = 0;
d->ts_number_pids++;
}
}
for ( ii = 0; ii < d->ts_number_pids; ii++ )
{
- d->ts_buf[ii] = hb_buffer_init(d->packetsize);
- d->ts_buf[ii]->size = 0;
+ d->ts[ii].buf = hb_buffer_init(d->packetsize);
+ d->ts[ii].extra_buf = hb_buffer_init(d->packetsize);
+ d->ts[ii].buf->size = 0;
+ d->ts[ii].extra_buf->size = 0;
}
return d;
* of the media stream for HB. */
static void hb_stream_delete_entry(hb_stream_t *stream, int indx)
{
- if ( stream->ts_pids[indx] > 0 )
+ if ( stream->ts[indx].pid > 0 )
{
- stream->ts_pids[indx] = -stream->ts_pids[indx];
+ stream->ts[indx].pid = -stream->ts[indx].pid;
}
}
{
int i;
- for (i=0; i < stream->ts_number_pids; i++)
- {
- hb_audio_t *audio = hb_ts_stream_set_audio_id_and_codec(stream, i);
- if ( audio )
- {
- hb_list_add( aTitle->list_audio, audio );
- }
- }
+ hb_ts_stream_set_audio_list(aTitle->list_audio, stream);
// make sure we're grabbing the PCR PID
if ( index_of_pid( stream, stream->pmt_info.PCR_PID ) < 0 )
{
- stream->ts_pids[stream->ts_number_pids] = stream->pmt_info.PCR_PID;
- stream->ts_stream_kind[stream->ts_number_pids] = P;
+ stream->ts[stream->ts_number_pids].pid = stream->pmt_info.PCR_PID;
+ stream->ts[stream->ts_number_pids].stream_kind = P;
+ stream->ts[stream->ts_number_pids].number_substreams = 1;
+ stream->ts[stream->ts_number_pids].substream_type[0] = 0;
stream->ts_number_pids++;
}
for (i = 0; i < stream->ts_number_pids; i++)
{
- kind_t kind = stream->ts_stream_kind[i];
+ kind_t kind = stream->ts[i].stream_kind;
if ( kind == N || kind == U )
{
return NULL;
}
- aTitle->video_id = stream->ts_pids[idx];
- aTitle->video_codec = st2codec[stream->ts_stream_type[idx]].codec;
- aTitle->video_codec_param = st2codec[stream->ts_stream_type[idx]].codec_param;
+ stream->ts[idx].number_substreams = 1;
+ stream->ts[idx].substream_type[0] = 0;
+ aTitle->video_id = stream->ts[idx].pid;
+ aTitle->video_codec = st2codec[stream->ts[idx].stream_type].codec;
+ aTitle->video_codec_param = st2codec[stream->ts[idx].stream_type].codec_param;
aTitle->demuxer = HB_MPEG2_TS_DEMUXER;
if ( ( stream->ts_flags & TS_HAS_PCR ) == 0 )
uint32_t strid = 0;
- if ( stream->ts_stream_type[0] <= 2 )
+ if ( stream->ts[0].stream_type <= 2 )
{
// This section of the code handles MPEG-1 and MPEG-2 video streams
for (i = 13 + adapt_len; i < 188; i++)
// didn't find an I-frame
return 0;
}
- if ( stream->ts_stream_type[0] == 0x1b )
+ if ( stream->ts[0].stream_type == 0x1b )
{
// we have an h.264 stream
for (i = 13 + adapt_len; i < 188; i++)
// didn't find an I-frame
return 0;
}
- if ( stream->ts_stream_type[0] == 0xea )
+ if ( stream->ts[0].stream_type == 0xea )
{
// we have an vc1 stream
for (i = 13 + adapt_len; i < 188; i++)
static uint64_t hb_ps_stream_getVideoPTS(hb_stream_t *stream)
{
- hb_buffer_t *buf = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
+ hb_buffer_t *buf;
hb_list_t *list = hb_list_init();
// how many blocks we read while searching for a video PES header
int blksleft = 1024;
uint64_t pts = 0;
- while (--blksleft >= 0 && hb_stream_read(stream, buf) == 1)
+ while (--blksleft >= 0 && (buf = hb_stream_read(stream)) != NULL)
{
hb_buffer_t *es;
- // 'buf' contains an MPEG2 PACK - get a list of all it's elementary streams
+ // 'buf' contains an MPEG2 PACK - get a list of all it's
+ // elementary streams
hb_demux_ps( buf, list, 0 );
while ( ( es = hb_list_item( list, 0 ) ) )
}
}
hb_list_empty( &list );
- hb_buffer_close(&buf);
return pts;
}
const uint8_t *buf;
fseeko( stream->file_handle, fpos, SEEK_SET );
align_to_next_packet( stream );
- int pid = stream->ts_pids[index_of_video(stream)];
+ int pid = stream->ts[index_of_video(stream)].pid;
buf = hb_ts_stream_getPEStype( stream, pid );
if ( buf == NULL )
{
***********************************************************************
*
**********************************************************************/
-int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b )
+hb_buffer_t * hb_stream_read( hb_stream_t * src_stream )
{
if ( src_stream->hb_stream_type == ffmpeg )
{
- return ffmpeg_read( src_stream, b );
+ return ffmpeg_read( src_stream );
}
if ( src_stream->hb_stream_type == dvd_program )
{
+ hb_buffer_t *b = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
size_t amt_read = fread(b->data, HB_DVD_READ_BUFFER_SIZE, 1,
src_stream->file_handle);
- return (amt_read > 0);
+ if (amt_read <= 0)
+ hb_buffer_close( &b );
+ return b;
}
if ( src_stream->hb_stream_type == program )
{
// 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
if ( ( c = getc( src_stream->file_handle ) ) == EOF )
return 0;
+ hb_buffer_t *b = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
+ uint8_t *cp = b->data;
+ uint8_t *ep = cp + b->alloc;
+ uint32_t strt_code = -1;
+
*cp++ = c;
flockfile( src_stream->file_handle );
// Only 3 of the 4 bytes read were added to the buffer.
b->size -= 3;
}
- return 1;
+ return b;
}
- return hb_ts_stream_decode( src_stream, b );
+ return hb_ts_stream_decode( src_stream );
}
void ffmpeg_flush_stream_buffers( hb_stream_t *stream )
return -1;
}
-static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang )
+static const char *stream_type_name (uint32_t reg_desc, uint8_t stream_type)
+{
+ if ( reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // Names for streams we know about.
+ switch ( stream_type )
+ {
+ case 0x80:
+ return "BD LPCM";
+
+ case 0x83:
+ return "TrueHD";
+
+ case 0x84:
+ return "E-AC3";
+
+ case 0x85:
+ return "DTS-HD HRA";
+
+ case 0x86:
+ return "DTS-HD MA";
+
+ default:
+ break;
+ }
+ }
+ return st2codec[stream_type].name ? st2codec[stream_type].name : "Unknown";
+}
+
+static void set_ts_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
const char *codec_name;
AVCodecContext *cc;
- if ( audio->config.in.codec == HB_ACODEC_FFMPEG &&
+ // Names for streams we know about.
+ if ( audio->config.in.stream_type == 0x80 &&
+ audio->config.in.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // LPCM audio in bluray have an stype of 0x80
+ codec_name = "BD LPCM";
+ }
+ else if ( audio->config.in.stream_type == 0x83 &&
+ audio->config.in.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // This is an interleaved TrueHD/AC-3 stream and the esid of
+ // the AC-3 is 0x76
+ if (audio->config.in.substream_type == HB_SUBSTREAM_BD_AC3)
+ codec_name = "AC3";
+ else
+ codec_name = "TrueHD";
+ }
+ else if ( audio->config.in.stream_type == 0x86 &&
+ audio->config.in.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // This is an interleaved DTS-HD MA/DTS stream and the
+ // esid of the DTS is 0x71
+ if (audio->config.in.substream_type == HB_SUBSTREAM_BD_DTS)
+ codec_name = "DTS";
+ else
+ codec_name = "DTS-HD MA";
+ }
+ else if ( audio->config.in.stream_type == 0x85 &&
+ audio->config.in.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // DTS-HD HRA audio in bluray has an stype of 0x85
+ // which conflicts with ATSC Program ID
+ // To distinguish, Bluray streams have a reg_desc of HDMV
+ // This is an interleaved DTS-HD HRA/DTS stream and the
+ // esid of the DTS is 0x71
+ if (audio->config.in.substream_type == HB_SUBSTREAM_BD_DTS)
+ codec_name = "DTS";
+ else
+ codec_name = "DTS-HD HRA";
+ }
+ else if ( audio->config.in.stream_type == 0x84 &&
+ audio->config.in.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // EAC3 audio in bluray has an stype of 0x84
+ // which conflicts with SDDS
+ // To distinguish, Bluray streams have a reg_desc of HDMV
+ codec_name = "E-AC3";
+ }
+ // For streams demuxed and decoded by ffmpeg, we have a cached context.
+ // Use it to get the name and profile information. Obtaining
+ // the profile requires that ffmpeg has already probed the stream.
+ else if ( audio->config.in.codec == HB_ACODEC_FFMPEG &&
( cc = hb_ffmpeg_context( audio->config.in.codec_param ) ) &&
avcodec_find_decoder( cc->codec_id ) )
{
AVCodec *codec = avcodec_find_decoder( cc->codec_id );
codec_name = codec->name;
- if ( !strcmp( codec_name, "DCA" ) )
- {
- codec_name = "DTS";
- }
const char *profile_name;
profile_name = av_get_profile_name( codec, cc->profile );
codec_name = profile_name;
}
}
+ else if ( st2codec[audio->config.in.stream_type].kind == A )
+ {
+ codec_name = stream_type_name(audio->config.in.reg_desc,
+ audio->config.in.stream_type);
+ }
+ // For streams demuxed by us and decoded by ffmpeg, we can lookup the
+ // decoder name.
else if ( audio->config.in.codec == HB_ACODEC_MPGA &&
avcodec_find_decoder( audio->config.in.codec_param ) )
{
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" :
+ audio->config.in.codec == HB_ACODEC_FFMPEG ? "FFmpeg" :
"Unknown";
}
snprintf( audio->config.lang.description,
"%s", lang->iso639_2);
}
-static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
- int idx)
+static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang )
{
- off_t cur_pos = ftello(stream->file_handle);
- hb_audio_t *audio = NULL;
- const uint8_t *buf;
- kind_t kind;
- uint8_t stype = 0;
+ /* XXX
+ * This is a duplicate of code in dvd.c - it should get factored out
+ * into a common routine. We probably should only be putting the 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;
- kind = stream->ts_stream_kind[idx];
+ // For streams demuxed and decoded by ffmpeg, we have a cached context.
+ // Use it to get the name and profile information. Obtaining
+ // the profile requires that ffmpeg has already probed the stream.
+ if ( audio->config.in.codec == HB_ACODEC_FFMPEG &&
+ ( cc = hb_ffmpeg_context( audio->config.in.codec_param ) ) &&
+ avcodec_find_decoder( cc->codec_id ) )
+ {
+ AVCodec *codec = avcodec_find_decoder( cc->codec_id );
+ codec_name = codec->name;
- if ( kind != A && kind != U && kind != N )
+ const char *profile_name;
+ profile_name = av_get_profile_name( codec, cc->profile );
+ if ( profile_name )
+ {
+ codec_name = profile_name;
+ }
+ }
+ // For streams demuxed by us and decoded by ffmpeg, we can lookup the
+ // decoder name.
+ else if ( audio->config.in.codec == HB_ACODEC_MPGA &&
+ avcodec_find_decoder( audio->config.in.codec_param ) )
{
- // Not audio
- return NULL;
+ codec_name = avcodec_find_decoder( audio->config.in.codec_param )->name;
}
- stype = stream->ts_stream_type[idx];
+ 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,
+ codec_name );
- fseeko(stream->file_handle, 0, SEEK_SET);
- align_to_next_packet(stream);
+ 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 ),
+ "%s", lang->iso639_2);
+}
- buf = hb_ts_stream_getPEStype(stream, stream->ts_pids[idx]);
+static void add_audio(int track, hb_list_t *list_audio, hb_stream_t *stream, int substream_type, uint32_t codec, uint32_t codec_param )
+{
+ hb_audio_t *audio;
+ hb_ts_stream_t *ts = &stream->ts[track];
- /* check that we found a PES header */
- if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
+ audio = calloc( sizeof( hb_audio_t ), 1 );
+
+ audio->id = (substream_type << 16) | ts->pid;
+ audio->config.in.reg_desc = stream->pmt_info.reg_desc;
+ audio->config.in.stream_type = ts->stream_type;
+ audio->config.in.substream_type = substream_type;
+
+ audio->config.in.codec = codec;
+ audio->config.in.codec_param = codec_param;
+
+ set_ts_audio_description( audio,
+ lang_for_code( ts->a52_info.lang_code ) );
+
+ hb_log("transport stream pid 0x%x (type 0x%x substream 0x%x) audio 0x%x",
+ ts->pid, ts->stream_type, substream_type, audio->id);
+
+ audio->config.in.track = track;
+ hb_list_add( list_audio, audio );
+}
+
+static void hb_ts_stream_set_audio_list(
+ hb_list_t *list_audio,
+ hb_stream_t *stream)
+{
+ off_t cur_pos;
+ const uint8_t *buf;
+ int i;
+
+ cur_pos = ftello(stream->file_handle);
+ for ( i = 0; i < stream->ts_number_pids; i++ )
{
- // 0xbd ("private stream 1") is the normal container for non-ISO
- // media - AC3/DCA/PCM/etc.
- if ( buf[3] == 0xbd )
+ stream->ts[i].substream_type[0] = 0;
+ stream->ts[i].number_substreams = 1;
+
+ if ( stream->ts[i].stream_type == 0x80 &&
+ stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
{
- if ( 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[idx] = 0x81;
- kind = A;
- }
- 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;
- }
+ // 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
+ stream->ts[i].stream_kind = A;
+ add_audio(i, list_audio, stream, 0,
+ HB_ACODEC_MPGA, CODEC_ID_PCM_BLURAY );
+ continue;
}
- 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[idx] == TS_FORMAT_ID_AC3 )
- {
- // This is an interleaved TrueHD/AC-3 stream and the esid of
- // the AC-3 is 0x76
- stream->ts_multiplexed[idx] = 0x76;
- stype = 0x81;
- stream->ts_stream_type[idx] = 0x81;
- kind = A;
- }
- if ( st2codec[stype].kind == A && stype == 0x86 )
- {
- // This is an interleaved DTS-HD MA/DTS stream and the esid of
- // the DTS is 0x71
- stream->ts_multiplexed[idx] = 0x71;
- stype = 0x82;
- stream->ts_stream_type[idx] = 0x82;
- kind = A;
- }
- if ( stype == 0x85 &&
- stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
- {
- // DTS-HD HRA audio in bluray has an stype of 0x85
- // which conflicts with ATSC Program ID
- // To distinguish, Bluray streams have a reg_desc of HDMV
- // This is an interleaved DTS-HD HRA/DTS stream and the esid of
- // the DTS is 0x71
- stream->ts_multiplexed[idx] = 0x71;
- stype = 0x82;
- stream->ts_stream_type[idx] = 0x82;
- kind = A;
- }
- if ( stype == 0x84 &&
- stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
- {
- // EAC3 audio in bluray has an stype of 0x84
- // which conflicts with SDDS
- // To distinguish, Bluray streams have a reg_desc of HDMV
- stype = 0x87;
- stream->ts_stream_type[idx] = 0x87;
- kind = A;
- }
+
+ // 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 ( stream->ts[i].stream_type == 0x83 &&
+ stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // This is an interleaved TrueHD/AC-3 stream and the esid of
+ // the AC-3 is 0x76
+ stream->ts[i].stream_kind = A;
+ stream->ts[i].substream_type[0] = HB_SUBSTREAM_BD_AC3;
+ add_audio(i, list_audio, stream, HB_SUBSTREAM_BD_AC3,
+ HB_ACODEC_AC3, 0 );
+ stream->ts[i].substream_type[1] = HB_SUBSTREAM_BD_TRUEHD;
+ add_audio(i, list_audio, stream, HB_SUBSTREAM_BD_TRUEHD,
+ HB_ACODEC_MPGA, CODEC_ID_TRUEHD );
+ stream->ts[i].number_substreams = 2;
+ continue;
}
- else if ((buf[3] & 0xe0) == 0xc0)
+ if ( stream->ts[i].stream_type == 0x86 &&
+ stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
+ {
+ // This is an interleaved DTS-HD MA/DTS stream and the
+ // esid of the DTS is 0x71
+ stream->ts[i].stream_kind = A;
+ stream->ts[i].substream_type[0] = HB_SUBSTREAM_BD_DTS;
+ add_audio(i, list_audio, stream, HB_SUBSTREAM_BD_DTS,
+ HB_ACODEC_DCA, 0 );
+ stream->ts[i].substream_type[1] = 0;
+ add_audio(i, list_audio, stream, 0, HB_ACODEC_MPGA, CODEC_ID_DTS );
+ stream->ts[i].number_substreams = 2;
+ continue;
+ }
+ if ( stream->ts[i].stream_type == 0x85 &&
+ stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
{
- // 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[idx] = 0x03;
- kind = A;
- }
+ // DTS-HD HRA audio in bluray has an stype of 0x85
+ // which conflicts with ATSC Program ID
+ // To distinguish, Bluray streams have a reg_desc of HDMV
+ // This is an interleaved DTS-HD HRA/DTS stream and the
+ // esid of the DTS is 0x71
+ stream->ts[i].stream_kind = A;
+ stream->ts[i].substream_type[0] = HB_SUBSTREAM_BD_DTS;
+ add_audio(i, list_audio, stream, HB_SUBSTREAM_BD_DTS,
+ HB_ACODEC_DCA, 0 );
+ stream->ts[i].substream_type[1] = 0;
+ add_audio(i, list_audio, stream, 0, HB_ACODEC_MPGA, CODEC_ID_DTS );
+ stream->ts[i].number_substreams = 2;
+ continue;
}
- else
+ if ( stream->ts[i].stream_type == 0x84 &&
+ stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
{
- stype = 0;
- kind = N;
+ // EAC3 audio in bluray has an stype of 0x84
+ // which conflicts with SDDS
+ // To distinguish, Bluray streams have a reg_desc of HDMV
+ stream->ts[i].stream_kind = A;
+ add_audio(i, list_audio, stream, 0, HB_ACODEC_MPGA, CODEC_ID_EAC3 );
+ continue;
}
- }
- // 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 ( kind == A && st2codec[stype].codec )
- {
- audio = calloc( sizeof( hb_audio_t ), 1 );
+ if ( stream->ts[i].stream_kind == A )
+ {
+ add_audio(i, list_audio, stream, 0,
+ st2codec[stream->ts[i].stream_type].codec,
+ st2codec[stream->ts[i].stream_type].codec_param );
+ continue;
+ }
- stream->ts_stream_kind[idx] = A;
- audio->id = stream->ts_pids[idx];
- 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[idx].lang_code ) );
- hb_log("transport stream pid 0x%x (type 0x%x) may be %s audio (id 0x%x)",
- stream->ts_pids[idx],
- stype, st2codec[stype].name, audio->id);
+ if ( stream->ts[i].stream_kind != U )
+ {
+ // Not audio
+ continue;
+ }
- }
- else
- {
- if ( buf )
+ // If we get here, we have a stream type that we are not yet
+ // sure about. Probe some data to see if it looks like
+ // a known stream type.
+ fseeko(stream->file_handle, 0, SEEK_SET);
+ align_to_next_packet(stream);
+
+ buf = hb_ts_stream_getPEStype(stream, stream->ts[i].pid);
+
+ /* check that we found a PES header */
+ if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
{
- hb_log("transport stream pid 0x%x (type 0x%x, substream 0x%x) "
- "isn't audio", stream->ts_pids[idx],
- stream->ts_stream_type[idx], buf[3]);
+ // 0xbd ("private stream 1") is the normal container for non-ISO
+ // media - AC3/DCA/PCM/etc.
+ if ( buf[3] == 0xbd )
+ {
+ // 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).
+ add_audio(i, list_audio, stream, 0, HB_ACODEC_AC3, 0 );
+ }
+ else if ((buf[3] & 0xe0) == 0xc0)
+ {
+ // XXX assume unknown stream types are MPEG audio
+ // 0xC0 - 0xCF are the normal containers for ISO-standard
+ // media (mpeg2 audio and mpeg4 AAC).
+ add_audio(i, list_audio, stream, 0,
+ HB_ACODEC_MPGA, CODEC_ID_MP2 );
+ }
+ else
+ {
+ hb_log("transport stream pid 0x%x (type 0x%x, substream 0x%x) "
+ "isn't audio", stream->ts[i].pid,
+ stream->ts[i].stream_type, buf[3]);
+ }
}
else
{
hb_log("transport stream pid 0x%x (type 0x%x) isn't audio",
- stream->ts_pids[idx],
- stream->ts_stream_type[idx]);
+ stream->ts[i].pid,
+ stream->ts[i].stream_type);
}
- }
- fseeko(stream->file_handle, cur_pos, SEEK_SET);
- return audio;
+ fseeko(stream->file_handle, cur_pos, SEEK_SET);
+ }
}
static void add_audio_to_title(hb_title_t *title, int id)
static void hb_ps_stream_find_audio_ids(hb_stream_t *stream, hb_title_t *title)
{
off_t cur_pos = ftello(stream->file_handle);
- hb_buffer_t *buf = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
+ hb_buffer_t *buf;
hb_list_t *list = hb_list_init();
// how many blocks we read while searching for audio streams
int blksleft = 4096;
// audio at the beginning (particularly for vobs).
hb_stream_seek(stream, 0.2f);
- while (--blksleft >= 0 && hb_stream_read(stream, buf) == 1)
+ while (--blksleft >= 0 && (buf = hb_stream_read(stream)) != NULL)
{
hb_buffer_t *es;
- // 'buf' contains an MPEG2 PACK - get a list of all it's elementary streams
+ // 'buf' contains an MPEG2 PACK - get a list of all it's
+ // elementary streams
hb_demux_ps( buf, list, 0 );
while ( ( es = hb_list_item( list, 0 ) ) )
}
}
hb_list_empty( &list );
- hb_buffer_close(&buf);
fseeko(stream->file_handle, cur_pos, SEEK_SET);
}
for (i=0; i < kMaxNumberDecodeStreams; i++)
{
- stream->ts_streamcont[i] = -1;
- stream-> ts_pids[i] = -1;
+ stream->ts[i].continuity = -1;
+ stream->ts[i].pid = -1;
+ stream->ts[i].number_substreams = 1;
+ stream->ts[i].substream_type[0] = 0;
}
stream->ts_packet = malloc( stream->packetsize );
for (i = 0; i < stream->ts_number_pids; i++)
{
// demuxing buffer for TS to PS conversion
- stream->ts_buf[i] = hb_buffer_init(stream->packetsize);
- stream->ts_buf[i]->size = 0;
+ stream->ts[i].buf = hb_buffer_init(stream->packetsize);
+ stream->ts[i].extra_buf = hb_buffer_init(stream->packetsize);
+ stream->ts[i].buf->size = 0;
+ stream->ts[i].extra_buf->size = 0;
}
}
switch (dp[0])
{
case 5: // Registration descriptor
- stream->ts_format_id[esindx] = (dp[2] << 24) | (dp[3] << 16) |
+ stream->ts[esindx].format_id = (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]));
+ stream->ts[esindx].a52_info.lang_code = lang_to_code(lang_for_code2((const char *)&dp[2]));
break;
case 0x6a: // DVB AC-3 descriptor
- stream->ts_stream_type[esindx] = 0x81;
+ stream->ts[esindx].stream_type = 0x81;
break;
case 0x7a: // DVB EAC-3 descriptor
- stream->ts_stream_type[esindx] = 0x87;
+ stream->ts[esindx].stream_type = 0x87;
break;
default:
}
}
-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;
i = stream->ts_number_pids;
if (i < kMaxNumberDecodeStreams)
{
- stream->ts_pids[i] = elementary_PID;
- stream->ts_stream_type[i] = stream_type;
+ stream->ts[i].pid = elementary_PID;
+ stream->ts[i].stream_type = stream_type;
+ stream->ts[i].number_substreams = 1;
+ stream->ts[i].substream_type[0] = 0;
if (ES_info_length > 0)
{
decode_element_descriptors(stream, i, ES_info_buf,
ES_info_length);
}
- stream->ts_stream_kind[i] = ts_stream_kind(stream, i);
+ stream->ts[i].stream_kind = ts_stream_kind(stream, i);
++stream->ts_number_pids;
}
}
int i;
for (i=0; i < stream->ts_number_pids; i++)
{
- if ( stream->ts_stream_kind[i] == V )
+ if ( stream->ts[i].stream_kind == V )
{
hb_log( " 0x%x type %s (0x%x)",
- stream->ts_pids[i],
- stream_type_name(stream->ts_stream_type[i]),
- stream->ts_stream_type[i]);
+ stream->ts[i].pid,
+ stream_type_name(stream->pmt_info.reg_desc,
+ stream->ts[i].stream_type),
+ stream->ts[i].stream_type);
}
}
hb_log(" Audio PIDS : ");
for (i = 0; i < stream->ts_number_pids; i++)
{
- if ( stream->ts_stream_kind[i] != V )
+ if ( stream->ts[i].stream_kind != V )
{
hb_log( " 0x%x type %s (0x%x)",
- stream->ts_pids[i],
- stream_type_name(stream->ts_stream_type[i]),
- stream->ts_stream_type[i] );
+ stream->ts[i].pid,
+ stream_type_name(stream->pmt_info.reg_desc,
+ stream->ts[i].stream_type),
+ stream->ts[i].stream_type );
}
}
}
-static void fwrite64( hb_stream_t *stream, void *buf, int len )
+static void fwrite64( hb_buffer_t * buf, void *data, int len )
{
if ( len > 0 )
{
- int pos = stream->fwrite_buf->size;
- if ( pos + len > stream->fwrite_buf->alloc )
+ int pos = buf->size;
+ if ( pos + len > buf->alloc )
{
- int size = MAX(stream->fwrite_buf->alloc * 2, pos + len);
- hb_buffer_realloc(stream->fwrite_buf, size);
+ int size = MAX(buf->alloc * 2, pos + len);
+ hb_buffer_realloc(buf, size);
}
- memcpy( &(stream->fwrite_buf->data[pos]), buf, len );
- stream->fwrite_buf->size += len;
+ memcpy( &(buf->data[pos]), data, len );
+ buf->size += len;
}
}
return ts;
}
-static void generate_output_data(hb_stream_t *stream, int curstream)
+static hb_buffer_t * generate_output_data(hb_stream_t *stream, int curstream)
{
- hb_buffer_t *buf = stream->fwrite_buf;
- uint8_t *tdat = stream->ts_buf[curstream]->data;
+ hb_buffer_t *buf = NULL, *first = NULL;
+ int substream, i;
- buf->id = stream->ts_pids[curstream];
- switch (stream->ts_stream_kind[curstream])
+ for ( i = 0; i < stream->ts[curstream].number_substreams; i++ )
{
- case A:
- buf->type = AUDIO_BUF;
- break;
+ substream = stream->ts[curstream].substream_type[i];
+ if ( substream == 0 ||
+ substream == stream->ts[curstream].current_substream )
+ {
+ uint8_t *tdat = stream->ts[curstream].buf->data;
+ int hlen = tdat[8] + 9;
+ int size = stream->ts[curstream].buf->size - hlen;
- case V:
- buf->type = VIDEO_BUF;
- break;
+ if ( size <= 0 )
+ continue;
- default:
- buf->type = OTHER_BUF;
- break;
- }
+ if ( first == NULL )
+ {
+ first = buf = hb_buffer_init( size );
+ }
+ else
+ {
+ hb_buffer_t * tmp;
+ tmp = hb_buffer_init( size );
+ buf->next = tmp;
+ buf = tmp;
+ }
+ buf->size = 0;
- // 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 )
- {
- // 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;
- }
- else
- {
- if ( stream->ts_pcr_out != stream->ts_pcr_in )
- {
- // 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
- {
- buf->stop = -1;
- }
+ buf->id = (substream << 16) | stream->ts[curstream].pid;
+ switch (stream->ts[curstream].stream_kind)
+ {
+ case A:
+ buf->type = AUDIO_BUF;
+ break;
- // put the PTS & possible DTS into 'start' & 'renderOffset' then strip
- // off the PES header.
- if ( tdat[7] & 0xc0 )
- {
- buf->start = pes_timestamp( tdat + 9 );
- buf->renderOffset = ( tdat[7] & 0x40 )? pes_timestamp( tdat + 14 ) :
- buf->start;
- }
- else
- {
- buf->start = -1;
- buf->renderOffset = -1;
- }
- }
- int hlen = tdat[8] + 9;
+ case V:
+ buf->type = VIDEO_BUF;
+ break;
+
+ default:
+ buf->type = OTHER_BUF;
+ break;
+ }
+
+ // 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.
+ int64_t bufpcr = stream->ts[curstream].buf->pcr;
+ int64_t curpcr = stream->ts_pcr_current;
+ if ( stream->ts[curstream].buf->cur < stream->ts_pcr_out &&
+ bufpcr != -1 && curpcr != -1 && curpcr - bufpcr > 200*90LL )
+ {
+ // 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;
+ buf->stop = -1;
+ buf->pcr = -1;
+ }
+ else
+ {
+ if ( stream->ts_pcr_out != stream->ts_pcr_in )
+ {
+ // we have a new pcr
+ stream->ts_pcr_out = stream->ts_pcr_in;
+ buf->pcr = stream->ts_pcr;
+ stream->ts_pcr_current = stream->ts_pcr;
+ }
+ else
+ {
+ buf->pcr = -1;
+ }
- fwrite64( stream, tdat + hlen, stream->ts_pos[curstream] - hlen );
+ // put the PTS & possible DTS into 'start' & 'renderOffset' then strip
+ // off the PES header.
+ if ( tdat[7] & 0xc0 )
+ {
+ buf->start = pes_timestamp( tdat + 9 );
+ buf->renderOffset = ( tdat[7] & 0x40 )? pes_timestamp( tdat + 14 ) :
+ buf->start;
+ }
+ else
+ {
+ buf->start = -1;
+ buf->renderOffset = -1;
+ }
+ }
- stream->ts_pos[curstream] = 0;
- stream->ts_buf[curstream]->size = 0;
+ fwrite64( buf, tdat + hlen, size );
+ }
+ }
+ stream->ts[curstream].buf->size = 0;
+ return first;
}
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)
+ if (stream->ts[idx].buf->size + len > stream->ts[idx].buf->alloc)
{
int size;
- size = MAX(stream->ts_buf[idx]->alloc * 2, stream->ts_pos[idx] + len);
- hb_buffer_realloc(stream->ts_buf[idx], size);
+ size = MAX(stream->ts[idx].buf->alloc * 2, stream->ts[idx].buf->size + len);
+ hb_buffer_realloc(stream->ts[idx].buf, size);
}
- memcpy(stream->ts_buf[idx]->data + stream->ts_pos[idx], buf, len);
- stream->ts_pos[idx] += len;
- stream->ts_buf[idx]->size += len;
+ memcpy(stream->ts[idx].buf->data + stream->ts[idx].buf->size, buf, len);
+ stream->ts[idx].buf->size += len;
}
/***********************************************************************
***********************************************************************
*
**********************************************************************/
-int hb_ts_decode_pkt( hb_stream_t *stream, const uint8_t * pkt, hb_buffer_t *obuf )
+hb_buffer_t * hb_ts_decode_pkt( hb_stream_t *stream, const uint8_t * pkt )
{
/*
* 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;
-
int video_index = index_of_video(stream);
-
int curstream;
+ hb_buffer_t *buf;
/* This next section validates the packet */
int pid = ((pkt[1] & 0x1F) << 8) | pkt[2];
if ( ( curstream = index_of_pid( stream, pid ) ) < 0 )
{
- return 0;
+ return NULL;
}
// Get error
if (errorbit)
{
ts_err( stream, curstream, "packet error bit set");
- return 0;
+ return NULL;
}
// Get adaption header info
if (adaption == 0)
{
ts_err( stream, curstream, "adaptation code 0");
- return 0;
+ return NULL;
}
else if (adaption == 0x2)
adapt_len = 184;
if (adapt_len > 184)
{
ts_err( stream, curstream, "invalid adapt len %d", adapt_len);
- return 0;
+ return NULL;
}
}
// 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 ) )
{
- return 0;
+ return NULL;
}
// Get continuity
if ( (adaption & 0x01) != 0 )
{
int continuity = (pkt[3] & 0xF);
- if ( continuity == stream->ts_streamcont[curstream] )
+ if ( continuity == stream->ts[curstream].continuity )
{
// Spliced transport streams can have duplicate
// continuity counts at the splice boundary.
{
memset(&summary[2], 0, 6);
}
- if ( memcmp( summary, stream->ts_pkt_summary[curstream], 8 ) == 0 )
+ if ( memcmp( summary, stream->ts[curstream].pkt_summary, 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.
- return 0;
+ return NULL;
}
}
- if ( !start && (stream->ts_streamcont[curstream] != -1) &&
- !stream->ts_skipbad[curstream] &&
- (continuity != ( (stream->ts_streamcont[curstream] + 1) & 0xf ) ) )
+ if ( !start && (stream->ts[curstream].continuity != -1) &&
+ !stream->ts[curstream].skipbad &&
+ (continuity != ( (stream->ts[curstream].continuity + 1) & 0xf ) ) )
{
- ts_err( stream, curstream, "continuity error: got %d expected %d",
+ ts_err( stream, curstream, "continuity error: got %d expected %d",
(int)continuity,
- (stream->ts_streamcont[curstream] + 1) & 0xf );
- stream->ts_streamcont[curstream] = continuity;
- return 0;
+ (stream->ts[curstream].continuity + 1) & 0xf );
+ stream->ts[curstream].continuity = continuity;
+ return NULL;
}
- stream->ts_streamcont[curstream] = continuity;
+ stream->ts[curstream].continuity = 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;
+ stream->ts[curstream].pkt_summary[0] = adaption;
+ stream->ts[curstream].pkt_summary[1] = adapt_len;
if (adapt_len + 4 + 6 + 9 <= 188)
{
- memcpy(&stream->ts_pkt_summary[curstream][2],
+ memcpy(&stream->ts[curstream].pkt_summary[2],
pkt+4+adapt_len+9, 6);
}
else
{
- memset(&stream->ts_pkt_summary[curstream][2], 0, 6);
+ memset(&stream->ts[curstream].pkt_summary[2], 0, 6);
}
}
/* If we get here the packet is valid - process its data */
+
if ( start )
{
// Found a random access point (now we can start a frame/audio packet..)
+ // PES must begin with an mpeg start code
+ const uint8_t *pes = pkt + adapt_len + 4;
+ if ( pes[0] != 0x00 || pes[1] != 0x00 || pes[2] != 0x01 )
+ {
+ ts_err( stream, curstream, "missing start code" );
+ stream->ts[curstream].skipbad = 1;
+ return NULL;
+ }
+
if ( stream->need_keyframe )
{
// we're looking for the first video frame because we're
// but we'll only wait 255 video frames for an I frame.
if ( curstream != video_index || ++stream->need_keyframe )
{
- return 0;
+ return NULL;
}
}
stream->need_keyframe = 0;
}
// If we were skipping a bad packet, start fresh on this new PES packet..
- if (stream->ts_skipbad[curstream] == 1)
+ if (stream->ts[curstream].skipbad == 1)
{
- stream->ts_skipbad[curstream] = 0;
+ stream->ts[curstream].skipbad = 0;
}
if ( curstream == video_index )
if ( pes[0] != 0x00 || pes[1] != 0x00 || pes[2] != 0x01 ||
( pes[7] >> 6 ) == 0 )
{
- return 0;
+ return NULL;
}
// if we have a dts use it otherwise use the pts
stream->ts_pcr = pes_timestamp( pes + ( pes[7] & 0x40?14:9 ) );
}
}
- // if this is a multiplexed stream make sure this is the
- // substream we want.
- if ( stream->ts_multiplexed[curstream] )
+ // the last byte of the header is the extension id. see if
+ // this could be a multiplexed stream
+ int substream = 0;
+ if ( pes[3] == 0xfd )
{
- // PES must begin with an mpeg start code & contain
- // a DTS or PTS.
- const uint8_t *pes = pkt + adapt_len + 4;
- if ( pes[0] != 0x00 || pes[1] != 0x00 || pes[2] != 0x01 ||
- pes[3] != 0xfd )
+ int out_substream = 0;
+ substream = pes[pes[8]+8];
+ out_substream = find_substream( &stream->ts[curstream], substream );
+ if ( out_substream < 0 )
{
- stream->ts_skipbad[curstream] = 1;
- return 0;
- }
- // 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;
- return 0;
+ buf = NULL;
+ if ( stream->ts[curstream].buf->size )
+ buf = generate_output_data(stream, curstream);
+
+ stream->ts[curstream].skipbad = 1;
+ return buf;
}
}
// 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] )
+ if ( stream->ts[curstream].buf->size )
{
// 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);
+ buf = generate_output_data(stream, curstream);
- // 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, pkt + 4 + adapt_len,
- 184 - adapt_len);
- return 1;
+ if ( buf )
+ {
+ // Output data is ready.
+ stream->ts[curstream].current_substream = substream;
+
+ // remember the pcr that was in effect when we started
+ // this packet.
+ stream->ts[curstream].buf->cur = stream->ts_pcr_in;
+ stream->ts[curstream].buf->pcr = stream->ts_pcr;
+ hb_ts_stream_append_pkt(stream, curstream, pkt + 4 + adapt_len,
+ 184 - adapt_len);
+ return buf;
+ }
}
// remember the pcr that was in effect when we started this packet.
- stream->ts_buf[curstream]->cur = stream->ts_pcr_in;
+ stream->ts[curstream].buf->cur = stream->ts_pcr_in;
+ stream->ts[curstream].buf->pcr = stream->ts_pcr;
+ stream->ts[curstream].current_substream = substream;
}
// Add the payload for this packet to the current buffer
- if (!stream->ts_skipbad[curstream] && (184 - adapt_len) > 0)
+ if (!stream->ts[curstream].skipbad && (184 - adapt_len) > 0)
{
hb_ts_stream_append_pkt(stream, curstream, pkt + 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;
+ const uint8_t *pes = stream->ts[curstream].buf->data;
int len = ( pes[4] << 8 ) + pes[5] + 6;
- if ( len > 6 && stream->ts_pos[curstream] == len &&
+ if ( len > 6 && stream->ts[curstream].buf->size == len &&
pes[0] == 0x00 && pes[1] == 0x00 && pes[2] == 0x01 )
{
- generate_output_data(stream, curstream);
- return 1;
+ buf = generate_output_data(stream, curstream);
+ if ( buf )
+ return buf;
}
}
- return 0;
+ return NULL;
}
-static int hb_ts_stream_decode( hb_stream_t *stream, hb_buffer_t *obuf )
+static hb_buffer_t * hb_ts_stream_decode( hb_stream_t *stream )
{
+ hb_buffer_t * b;
+
// spin until we get a packet of data from some stream or hit eof
while ( 1 )
{
// 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");
- return 0;
+ return NULL;
}
- if (hb_ts_decode_pkt( stream, buf, obuf ))
+ b = hb_ts_decode_pkt( stream, buf );
+ if ( b )
{
- return 1;
+ return b;
}
}
- return 0;
+ return NULL;
}
static void hb_ts_stream_reset(hb_stream_t *stream)
for (i=0; i < kMaxNumberDecodeStreams; i++)
{
- stream->ts_pos[i] = 0;
- stream->ts_skipbad[i] = 1;
- stream->ts_streamcont[i] = -1;
+ if ( stream->ts[i].buf )
+ stream->ts[i].buf->size = 0;
+ if ( stream->ts[i].extra_buf )
+ stream->ts[i].extra_buf->size = 0;
+ stream->ts[i].skipbad = 1;
+ stream->ts[i].continuity = -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->ts_pcr = -1;
+ stream->ts_pcr_current = -1;
stream->frames = 0;
stream->errors = 0;
return ( stream->ffmpeg_pkt->flags & PKT_FLAG_KEY );
}
-static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf )
+static hb_buffer_t * ffmpeg_read( hb_stream_t *stream )
{
int err;
+ hb_buffer_t * buf;
+
again:
if ( ( err = av_read_frame( stream->ffmpeg_ic, stream->ffmpeg_pkt )) < 0 )
{
// sizes for the null frames these require.
if ( err != AVERROR_NOMEM || stream->ffmpeg_pkt->size >= 0 )
// eof
- return 0;
+ return NULL;
+ }
+ if ( stream->ffmpeg_pkt->stream_index == 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 ( stream->ffmpeg_pkt->size <= 0 )
{
// 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 = hb_buffer_init( 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) )
{
- // 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 );
+ hb_log( "ffmpeg_read: pkt too big: %d bytes", stream->ffmpeg_pkt->size );
+ av_free_packet( stream->ffmpeg_pkt );
+ return ffmpeg_read( stream );
}
+ buf = hb_buffer_init( 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.
* 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;
+ enum CodecID ffmpeg_pkt_codec;
+ enum AVMediaType codec_type;
+ ffmpeg_pkt_codec = stream->ffmpeg_ic->streams[stream->ffmpeg_pkt->stream_index]->codec->codec_id;
+ codec_type = stream->ffmpeg_ic->streams[stream->ffmpeg_pkt->stream_index]->codec->codec_type;
+ switch ( codec_type )
+ {
+ case CODEC_TYPE_VIDEO:
+ buf->type = VIDEO_BUF;
+ break;
+
+ case CODEC_TYPE_AUDIO:
+ buf->type = AUDIO_BUF;
+ break;
+
+ case CODEC_TYPE_SUBTITLE:
+ buf->type = SUBTITLE_BUF;
+ break;
+
+ default:
+ buf->type = OTHER_BUF;
+ break;
+ }
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 );
}
/*
- * Check to see whether this video buffer is on a chapter
+ * Check to see whether this 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 )
+ if ( stream->ffmpeg_pkt->stream_index == stream->ffmpeg_video_id &&
+ buf->start >= stream->chapter_end )
{
hb_chapter_t *chapter = hb_list_item( stream->title->list_chapter,
stream->chapter+1 );
buf->new_chap = 0;
}
av_free_packet( stream->ffmpeg_pkt );
- return 1;
+ return buf;
}
static int ffmpeg_seek( hb_stream_t *stream, float frac )
projects / handbrake / commitdiff