*/
static void
capmt_table_input(struct th_descrambler *td, struct service *t,
- struct th_stream *st, const uint8_t *data, int len)
+ struct elementary_stream *st, const uint8_t *data, int len)
{
capmt_service_t *ct = (capmt_service_t *)td;
capmt_t *capmt = ct->ct_capmt;
caid_t *c;
- c = LIST_FIRST(&st->st_caids);
+ c = LIST_FIRST(&st->es_caids);
if(c == NULL)
return;
/* ecmpid not already seen, add it to list */
cce = calloc(1, sizeof(capmt_caid_ecm_t));
cce->cce_caid = c->caid;
- cce->cce_ecmpid = st->st_pid;
+ cce->cce_ecmpid = st->es_pid;
LIST_INSERT_HEAD(&ct->ct_caid_ecm, cce, cce_link);
}
}
uint16_t sid = t->s_dvb_service_id;
- uint16_t ecmpid = st->st_pid;
+ uint16_t ecmpid = st->es_pid;
uint16_t transponder = 0;
/* don't do too much requests */
*
*/
static int
-capmt_descramble(th_descrambler_t *td, service_t *t, struct th_stream *st,
+capmt_descramble(th_descrambler_t *td, service_t *t, struct elementary_stream *st,
const uint8_t *tsb)
{
capmt_service_t *ct = (capmt_service_t *)td;
t->s_svcname,
t->s_dvb_mux_instance->tdmi_adapter->tda_adapter_num);
- th_stream_t *st;
+ elementary_stream_t *st;
/* create new capmt service */
ct = calloc(1, sizeof(capmt_service_t));
ct->ct_tsbcluster = malloc(ct->ct_cluster_size * 188);
ct->ct_seq = capmt->capmt_seq++;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- caid_t *c = LIST_FIRST(&st->st_caids);
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ caid_t *c = LIST_FIRST(&st->es_caids);
if(c == NULL)
continue;
/* add it to list */
cce = calloc(1, sizeof(capmt_caid_ecm_t));
cce->cce_caid = c->caid;
- cce->cce_ecmpid = st->st_pid;
+ cce->cce_ecmpid = st->es_pid;
LIST_INSERT_HEAD(&ct->ct_caid_ecm, cce, cce_link);
/* sending request will be based on first seen caid */
*/
static void
cwc_table_input(struct th_descrambler *td, struct service *t,
- struct th_stream *st, const uint8_t *data, int len)
+ struct elementary_stream *st, const uint8_t *data, int len)
{
cwc_service_t *ct = (cwc_service_t *)td;
uint16_t sid = t->s_dvb_service_id;
return;
LIST_FOREACH(ep, &ct->cs_pids, ep_link) {
- if(ep->ep_pid == st->st_pid)
+ if(ep->ep_pid == st->es_pid)
break;
}
if(ep == NULL) {
ep = calloc(1, sizeof(ecm_pid_t));
- ep->ep_pid = st->st_pid;
+ ep->ep_pid = st->es_pid;
LIST_INSERT_HEAD(&ct->cs_pids, ep, ep_link);
}
- LIST_FOREACH(c, &st->st_caids, link) {
+ LIST_FOREACH(c, &st->es_caids, link) {
if(cwc->cwc_caid == c->caid)
break;
}
tvhlog(LOG_DEBUG, "cwc",
"Sending ECM%s section=%d/%d, for service %s (seqno: %d) PID %d",
chaninfo, section, ep->ep_last_section, t->s_svcname, es->es_seq,
- st->st_pid);
+ st->es_pid);
es->es_time = getmonoclock();
break;
*
*/
static int
-cwc_descramble(th_descrambler_t *td, service_t *t, struct th_stream *st,
+cwc_descramble(th_descrambler_t *td, service_t *t, struct elementary_stream *st,
const uint8_t *tsb)
{
cwc_service_t *ct = (cwc_service_t *)td;
/**
*
*/
-static inline th_stream_t *
+static inline elementary_stream_t *
cwc_find_stream_by_caid(service_t *t, int caid)
{
- th_stream_t *st;
+ elementary_stream_t *st;
caid_t *c;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- LIST_FOREACH(c, &st->st_caids, link) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ LIST_FOREACH(c, &st->es_caids, link) {
if(c->caid == caid)
return st;
}
{
th_dvb_mux_instance_t *tdmi_dst;
service_t *t_src, *t_dst;
- th_stream_t *st_src, *st_dst;
+ elementary_stream_t *st_src, *st_dst;
caid_t *caid_src, *caid_dst;
tdmi_dst = dvb_mux_create(dst,
pthread_mutex_lock(&t_src->s_stream_mutex);
pthread_mutex_lock(&t_dst->s_stream_mutex);
- TAILQ_FOREACH(st_src, &t_src->s_components, st_link) {
+ TAILQ_FOREACH(st_src, &t_src->s_components, es_link) {
st_dst = service_stream_create(t_dst,
- st_src->st_pid,
- st_src->st_type);
+ st_src->es_pid,
+ st_src->es_type);
- memcpy(st_dst->st_lang, st_src->st_lang, 4);
- st_dst->st_frame_duration = st_src->st_frame_duration;
+ memcpy(st_dst->es_lang, st_src->es_lang, 4);
+ st_dst->es_frame_duration = st_src->es_frame_duration;
- LIST_FOREACH(caid_src, &st_src->st_caids, link) {
+ LIST_FOREACH(caid_src, &st_src->es_caids, link) {
caid_dst = malloc(sizeof(caid_t));
caid_dst->caid = caid_src->caid;
caid_dst->providerid = caid_src->providerid;
caid_dst->delete_me = 0;
- LIST_INSERT_HEAD(&st_dst->st_caids, caid_dst, link);
+ LIST_INSERT_HEAD(&st_dst->es_caids, caid_dst, link);
}
}
{
struct dmx_pes_filter_params dmx_param;
int fd;
- th_stream_t *st;
+ elementary_stream_t *st;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- if(st->st_pid >= 0x2000)
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ if(st->es_pid >= 0x2000)
continue;
- if(st->st_demuxer_fd != -1)
+ if(st->es_demuxer_fd != -1)
continue;
fd = tvh_open(tda->tda_demux_path, O_RDWR, 0);
- st->st_cc_valid = 0;
+ st->es_cc_valid = 0;
if(fd == -1) {
- st->st_demuxer_fd = -1;
+ st->es_demuxer_fd = -1;
tvhlog(LOG_ERR, "dvb",
"\"%s\" unable to open demuxer \"%s\" for pid %d -- %s",
t->s_identifier, tda->tda_demux_path,
- st->st_pid, strerror(errno));
+ st->es_pid, strerror(errno));
continue;
}
memset(&dmx_param, 0, sizeof(dmx_param));
- dmx_param.pid = st->st_pid;
+ dmx_param.pid = st->es_pid;
dmx_param.input = DMX_IN_FRONTEND;
dmx_param.output = DMX_OUT_TS_TAP;
dmx_param.pes_type = DMX_PES_OTHER;
tvhlog(LOG_ERR, "dvb",
"\"%s\" unable to configure demuxer \"%s\" for pid %d -- %s",
t->s_identifier, tda->tda_demux_path,
- st->st_pid, strerror(errno));
+ st->es_pid, strerror(errno));
close(fd);
fd = -1;
}
- st->st_demuxer_fd = fd;
+ st->es_demuxer_fd = fd;
}
}
dvb_transport_stop(service_t *t)
{
th_dvb_adapter_t *tda = t->s_dvb_mux_instance->tdmi_adapter;
- th_stream_t *st;
+ elementary_stream_t *st;
lock_assert(&global_lock);
LIST_REMOVE(t, s_active_link);
pthread_mutex_unlock(&tda->tda_delivery_mutex);
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- if(st->st_demuxer_fd != -1) {
- close(st->st_demuxer_fd);
- st->st_demuxer_fd = -1;
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ if(st->es_demuxer_fd != -1) {
+ close(st->es_demuxer_fd);
+ st->es_demuxer_fd = -1;
}
}
t->s_status = SERVICE_IDLE;
int
-h264_decode_seq_parameter_set(th_stream_t *st, bitstream_t *bs)
+h264_decode_seq_parameter_set(elementary_stream_t *st, bitstream_t *bs)
{
int profile_idc, level_idc, poc_type;
unsigned int sps_id, tmp, i, width, height;
int cbpsize = -1;
h264_private_t *p;
- if((p = st->st_priv) == NULL)
- p = st->st_priv = calloc(1, sizeof(h264_private_t));
+ if((p = st->es_priv) == NULL)
+ p = st->es_priv = calloc(1, sizeof(h264_private_t));
profile_idc= read_bits(bs, 8);
read_bits1(bs); //constraint_set0_flag
int
-h264_decode_pic_parameter_set(th_stream_t *st, bitstream_t *bs)
+h264_decode_pic_parameter_set(elementary_stream_t *st, bitstream_t *bs)
{
h264_private_t *p;
int pps_id, sps_id;
- if((p = st->st_priv) == NULL)
- p = st->st_priv = calloc(1, sizeof(h264_private_t));
+ if((p = st->es_priv) == NULL)
+ p = st->es_priv = calloc(1, sizeof(h264_private_t));
pps_id = read_golomb_ue(bs);
sps_id = read_golomb_ue(bs);
int
-h264_decode_slice_header(th_stream_t *st, bitstream_t *bs, int *pkttype,
+h264_decode_slice_header(elementary_stream_t *st, bitstream_t *bs, int *pkttype,
int *duration, int *isfield)
{
h264_private_t *p;
int slice_type, pps_id, sps_id, fnum;
- if((p = st->st_priv) == NULL)
+ if((p = st->es_priv) == NULL)
return -1;
read_golomb_ue(bs); /* first_mb_in_slice */
}
if(p->sps[sps_id].cbpsize != 0)
- st->st_vbv_size = p->sps[sps_id].cbpsize;
+ st->es_vbv_size = p->sps[sps_id].cbpsize;
- st->st_vbv_delay = -1;
+ st->es_vbv_delay = -1;
- if(p->sps[sps_id].width && p->sps[sps_id].height && !st->st_buf.sb_err)
+ if(p->sps[sps_id].width && p->sps[sps_id].height && !st->es_buf.sb_err)
parser_set_stream_vsize(st, p->sps[sps_id].width,
p->sps[sps_id].height *
(2 - p->sps[sps_id].mbs_only_flag));
if(p->sps[sps_id].aspect_num && p->sps[sps_id].aspect_den) {
- int w = p->sps[sps_id].aspect_num * st->st_width;
- int h = p->sps[sps_id].aspect_den * st->st_height;
+ int w = p->sps[sps_id].aspect_num * st->es_width;
+ int h = p->sps[sps_id].aspect_den * st->es_height;
if(w && h) {
int d = gcd(w, h);
- st->st_aspect_num = w / d;
- st->st_aspect_den = h / d;
+ st->es_aspect_num = w / d;
+ st->es_aspect_den = h / d;
}
} else {
- st->st_aspect_num = 0;
- st->st_aspect_den = 1;
+ st->es_aspect_num = 0;
+ st->es_aspect_den = 1;
}
return 0;
void *h264_nal_deescape(bitstream_t *bs, const uint8_t *data, int size);
-int h264_decode_seq_parameter_set(struct th_stream *st, bitstream_t *bs);
+int h264_decode_seq_parameter_set(struct elementary_stream *st, bitstream_t *bs);
-int h264_decode_pic_parameter_set(struct th_stream *st, bitstream_t *bs);
+int h264_decode_pic_parameter_set(struct elementary_stream *st, bitstream_t *bs);
-int h264_decode_slice_header(struct th_stream *st, bitstream_t *bs,
+int h264_decode_slice_header(struct elementary_stream *st, bitstream_t *bs,
int *pkttype, int *duration, int *isfield);
#endif /* PARSER_H264_H_ */
static void
-read_audio_specific_config(th_stream_t *st, latm_private_t *latm,
+read_audio_specific_config(elementary_stream_t *st, latm_private_t *latm,
bitstream_t *bs)
{
int aot, sr;
return;
sr = sri_to_rate(latm->sample_rate_index);
- st->st_frame_duration = 1024 * 90000 / sr;
+ st->es_frame_duration = 1024 * 90000 / sr;
latm->channel_config = read_bits(bs, 4);
static void
-read_stream_mux_config(th_stream_t *st, latm_private_t *latm, bitstream_t *bs)
+read_stream_mux_config(elementary_stream_t *st, latm_private_t *latm, bitstream_t *bs)
{
int audio_mux_version = read_bits(bs, 1);
latm->audio_mux_version_A = 0;
* Parse AAC LATM
*/
th_pkt_t *
-parse_latm_audio_mux_element(service_t *t, th_stream_t *st,
+parse_latm_audio_mux_element(service_t *t, elementary_stream_t *st,
const uint8_t *data, int len)
{
latm_private_t *latm;
init_rbits(&bs, data, len * 8);
- if((latm = st->st_priv) == NULL)
- latm = st->st_priv = calloc(1, sizeof(latm_private_t));
+ if((latm = st->es_priv) == NULL)
+ latm = st->es_priv = calloc(1, sizeof(latm_private_t));
if(!read_bits1(&bs))
read_stream_mux_config(st, latm, &bs);
if(slot_len * 8 > remaining_bits(&bs))
return NULL;
- if(st->st_curdts == PTS_UNSET)
+ if(st->es_curdts == PTS_UNSET)
return NULL;
- th_pkt_t *pkt = pkt_alloc(NULL, slot_len + 7, st->st_curdts, st->st_curdts);
+ th_pkt_t *pkt = pkt_alloc(NULL, slot_len + 7, st->es_curdts, st->es_curdts);
pkt->pkt_commercial = t->s_tt_commercial_advice;
- pkt->pkt_duration = st->st_frame_duration;
+ pkt->pkt_duration = st->es_frame_duration;
pkt->pkt_sri = latm->sample_rate_index;
pkt->pkt_channels = latm->channel_config;
for(i = 0; i < slot_len; i++)
*buf++ = read_bits(&bs, 8);
- st->st_curdts += st->st_frame_duration;
+ st->es_curdts += st->es_frame_duration;
return pkt;
}
#define PARSER_LATM_H_
th_pkt_t *parse_latm_audio_mux_element(struct service *t,
- struct th_stream *st,
+ struct elementary_stream *st,
const uint8_t *data, int len);
#endif /* PARSER_LATM_H_ */
}
-static int parse_mpeg2video(service_t *t, th_stream_t *st, size_t len,
+static int parse_mpeg2video(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-static int parse_h264(service_t *t, th_stream_t *st, size_t len,
+static int parse_h264(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-typedef int (packet_parser_t)(service_t *t, th_stream_t *st, size_t len,
+typedef int (packet_parser_t)(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-typedef void (aparser_t)(service_t *t, th_stream_t *st, th_pkt_t *pkt);
+typedef void (aparser_t)(service_t *t, elementary_stream_t *st, th_pkt_t *pkt);
-static void parse_sc(service_t *t, th_stream_t *st, const uint8_t *data,
+static void parse_sc(service_t *t, elementary_stream_t *st, const uint8_t *data,
int len, packet_parser_t *vp);
-static void parse_aac(service_t *t, th_stream_t *st, const uint8_t *data,
+static void parse_aac(service_t *t, elementary_stream_t *st, const uint8_t *data,
int len, int start);
-static void parse_subtitles(service_t *t, th_stream_t *st,
+static void parse_subtitles(service_t *t, elementary_stream_t *st,
const uint8_t *data, int len, int start);
-static int parse_mpa(service_t *t, th_stream_t *st, size_t len,
+static int parse_mpa(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-static int parse_mpa2(service_t *t, th_stream_t *st);
+static int parse_mpa2(service_t *t, elementary_stream_t *st);
-static int parse_ac3(service_t *t, th_stream_t *st, size_t len,
+static int parse_ac3(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-static int parse_eac3(service_t *t, th_stream_t *st, size_t len,
+static int parse_eac3(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
-static void parser_deliver(service_t *t, th_stream_t *st, th_pkt_t *pkt);
+static void parser_deliver(service_t *t, elementary_stream_t *st, th_pkt_t *pkt);
-static int parse_pes_header(service_t *t, th_stream_t *st,
+static int parse_pes_header(service_t *t, elementary_stream_t *st,
const uint8_t *buf, size_t len);
/**
* Parse raw mpeg data
*/
void
-parse_mpeg_ts(service_t *t, th_stream_t *st, const uint8_t *data,
+parse_mpeg_ts(service_t *t, elementary_stream_t *st, const uint8_t *data,
int len, int start, int err)
{
if(err)
- sbuf_err(&st->st_buf);
+ sbuf_err(&st->es_buf);
- switch(st->st_type) {
+ switch(st->es_type) {
case SCT_MPEG2VIDEO:
parse_sc(t, st, data, len, parse_mpeg2video);
break;
* Note: data does not include startcode and packet length
*/
void
-parse_mpeg_ps(service_t *t, th_stream_t *st, uint8_t *data, int len)
+parse_mpeg_ps(service_t *t, elementary_stream_t *st, uint8_t *data, int len)
{
int hlen;
if(len < 1)
return;
- switch(st->st_type) {
+ switch(st->es_type) {
case SCT_MPEG2AUDIO:
- sbuf_append(&st->st_buf_a, data, len);
+ sbuf_append(&st->es_buf_a, data, len);
parse_mpa2(t, st);
break;
* Parse AAC LATM
*/
static void
-parse_aac(service_t *t, th_stream_t *st, const uint8_t *data,
+parse_aac(service_t *t, elementary_stream_t *st, const uint8_t *data,
int len, int start)
{
int l, muxlen, p;
if(start) {
/* Payload unit start */
- st->st_parser_state = 1;
- st->st_parser_ptr = 0;
- sbuf_reset(&st->st_buf);
+ st->es_parser_state = 1;
+ st->es_parser_ptr = 0;
+ sbuf_reset(&st->es_buf);
}
- if(st->st_parser_state == 0)
+ if(st->es_parser_state == 0)
return;
- sbuf_append(&st->st_buf, data, len);
+ sbuf_append(&st->es_buf, data, len);
- if(st->st_parser_ptr == 0) {
+ if(st->es_parser_ptr == 0) {
int hlen;
- if(st->st_buf.sb_ptr < 9)
+ if(st->es_buf.sb_ptr < 9)
return;
hlen = parse_pes_header(t, st,
- st->st_buf.sb_data + 6, st->st_buf.sb_ptr - 6);
+ st->es_buf.sb_data + 6, st->es_buf.sb_ptr - 6);
if(hlen < 0)
return;
- st->st_parser_ptr += 6 + hlen;
+ st->es_parser_ptr += 6 + hlen;
}
- p = st->st_parser_ptr;
+ p = st->es_parser_ptr;
- while((l = st->st_buf.sb_ptr - p) > 3) {
- const uint8_t *d = st->st_buf.sb_data + p;
+ while((l = st->es_buf.sb_ptr - p) > 3) {
+ const uint8_t *d = st->es_buf.sb_data + p;
if(d[0] == 0x56 && (d[1] & 0xe0) == 0xe0) {
muxlen = (d[1] & 0x1f) << 8 | d[2];
p++;
}
}
- st->st_parser_ptr = p;
+ st->es_parser_ptr = p;
}
* derive further information.
*/
static void
-parse_sc(service_t *t, th_stream_t *st, const uint8_t *data, int len,
+parse_sc(service_t *t, elementary_stream_t *st, const uint8_t *data, int len,
packet_parser_t *vp)
{
- uint32_t sc = st->st_startcond;
+ uint32_t sc = st->es_startcond;
int i, r;
- sbuf_alloc(&st->st_buf, len);
+ sbuf_alloc(&st->es_buf, len);
for(i = 0; i < len; i++) {
- if(st->st_ssc_intercept == 1) {
+ if(st->es_ssc_intercept == 1) {
- if(st->st_ssc_ptr < sizeof(st->st_ssc_buf))
- st->st_ssc_buf[st->st_ssc_ptr] = data[i];
- st->st_ssc_ptr++;
+ if(st->es_ssc_ptr < sizeof(st->es_ssc_buf))
+ st->es_ssc_buf[st->es_ssc_ptr] = data[i];
+ st->es_ssc_ptr++;
- if(st->st_ssc_ptr < 5)
+ if(st->es_ssc_ptr < 5)
continue;
- uint16_t plen = st->st_ssc_buf[0] << 8 | st->st_ssc_buf[1];
- st->st_incomplete = plen >= 0xffdf;
+ uint16_t plen = st->es_ssc_buf[0] << 8 | st->es_ssc_buf[1];
+ st->es_incomplete = plen >= 0xffdf;
- int hlen = st->st_ssc_buf[4];
+ int hlen = st->es_ssc_buf[4];
- if(st->st_ssc_ptr < hlen + 5)
+ if(st->es_ssc_ptr < hlen + 5)
continue;
- parse_pes_header(t, st, st->st_ssc_buf + 2, hlen + 3);
- st->st_ssc_intercept = 0;
- if(st->st_buf.sb_ptr > 2)
- sc = st->st_buf.sb_data[st->st_buf.sb_ptr-3] << 16 |
- st->st_buf.sb_data[st->st_buf.sb_ptr-2] << 8 |
- st->st_buf.sb_data[st->st_buf.sb_ptr-1];
+ parse_pes_header(t, st, st->es_ssc_buf + 2, hlen + 3);
+ st->es_ssc_intercept = 0;
+ if(st->es_buf.sb_ptr > 2)
+ sc = st->es_buf.sb_data[st->es_buf.sb_ptr-3] << 16 |
+ st->es_buf.sb_data[st->es_buf.sb_ptr-2] << 8 |
+ st->es_buf.sb_data[st->es_buf.sb_ptr-1];
continue;
}
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = data[i];
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = data[i];
sc = sc << 8 | data[i];
if((sc & 0xffffff00) != 0x00000100)
continue;
}
- r = st->st_buf.sb_ptr - st->st_startcode_offset - 4;
+ r = st->es_buf.sb_ptr - st->es_startcode_offset - 4;
- if(r > 0 && st->st_startcode != 0) {
- r = vp(t, st, r, sc, st->st_startcode_offset);
+ if(r > 0 && st->es_startcode != 0) {
+ r = vp(t, st, r, sc, st->es_startcode_offset);
if(r == 3)
continue;
if(r == 4) {
- st->st_buf.sb_ptr -= 4;
- st->st_ssc_intercept = 1;
- st->st_ssc_ptr = 0;
+ st->es_buf.sb_ptr -= 4;
+ st->es_ssc_intercept = 1;
+ st->es_ssc_ptr = 0;
sc = -1;
continue;
}
r = 1;
}
- assert(st->st_buf.sb_data != NULL);
+ assert(st->es_buf.sb_data != NULL);
if(r == 2) {
// Drop packet
- st->st_buf.sb_ptr = st->st_startcode_offset;
+ st->es_buf.sb_ptr = st->es_startcode_offset;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 24;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 16;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 8;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc;
- st->st_startcode = sc;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 24;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 16;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 8;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc;
+ st->es_startcode = sc;
} else {
if(r == 1) {
/* Reset packet parser upon length error or if parser
tells us so */
- sbuf_reset(&st->st_buf);
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 24;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 16;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc >> 8;
- st->st_buf.sb_data[st->st_buf.sb_ptr++] = sc;
+ sbuf_reset(&st->es_buf);
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 24;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 16;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc >> 8;
+ st->es_buf.sb_data[st->es_buf.sb_ptr++] = sc;
}
- st->st_startcode = sc;
- st->st_startcode_offset = st->st_buf.sb_ptr - 4;
+ st->es_startcode = sc;
+ st->es_startcode_offset = st->es_buf.sb_ptr - 4;
}
}
- st->st_startcond = sc;
+ st->es_startcond = sc;
}
*
*/
static int
-depacketize(service_t *t, th_stream_t *st, size_t len,
+depacketize(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
- const uint8_t *buf = st->st_buf.sb_data + sc_offset;
- uint32_t sc = st->st_startcode;
+ const uint8_t *buf = st->es_buf.sb_data + sc_offset;
+ uint32_t sc = st->es_startcode;
int hlen, plen;
if((sc != 0x1bd && (sc & ~0x1f) != 0x1c0) || len < 9)
buf += hlen;
len -= hlen;
- sbuf_append(&st->st_buf_a, buf, len);
+ sbuf_append(&st->es_buf_a, buf, len);
return 0;
}
*
*/
static void
-makeapkt(service_t *t, th_stream_t *st, const void *buf,
+makeapkt(service_t *t, elementary_stream_t *st, const void *buf,
int len, int64_t dts, int duration, int channels, int sri)
{
parser_deliver(t, st, pkt);
- st->st_curdts = PTS_UNSET;
- st->st_nextdts = dts + duration;
+ st->es_curdts = PTS_UNSET;
+ st->es_nextdts = dts + duration;
}
*
*/
static int
-parse_mpa2(service_t *t, th_stream_t *st)
+parse_mpa2(service_t *t, elementary_stream_t *st)
{
int i, len;
const uint8_t *buf;
again:
- buf = st->st_buf_a.sb_data;
- len = st->st_buf_a.sb_ptr;
+ buf = st->es_buf_a.sb_data;
+ len = st->es_buf_a.sb_ptr;
for(i = 0; i < len - 4; i++) {
if(mpa_valid_frame(buf + i)) {
if(br && sr) {
int fsize = 144000 * br / sr + pad;
int duration = 90000 * 1152 / sr;
- int64_t dts = st->st_curdts;
+ int64_t dts = st->es_curdts;
int channels = (buf[i + 3] & 0xc0) == 0xc0 ? 1 : 2;
if(dts == PTS_UNSET)
- dts = st->st_nextdts;
+ dts = st->es_nextdts;
if(dts != PTS_UNSET &&
len >= i + fsize + 4 &&
makeapkt(t, st, buf + i, fsize, dts, duration,
channels, mpa_sri[(buf[i+2] >> 2) & 3]);
- sbuf_cut(&st->st_buf_a, i + fsize);
+ sbuf_cut(&st->es_buf_a, i + fsize);
goto again;
}
}
*
*/
static int
-parse_mpa(service_t *t, th_stream_t *st, size_t ilen,
+parse_mpa(service_t *t, elementary_stream_t *st, size_t ilen,
uint32_t next_startcode, int sc_offset)
{
int r;
static int
-parse_ac3(service_t *t, th_stream_t *st, size_t ilen,
+parse_ac3(service_t *t, elementary_stream_t *st, size_t ilen,
uint32_t next_startcode, int sc_offset)
{
int i, len;
return i;
again:
- buf = st->st_buf_a.sb_data;
- len = st->st_buf_a.sb_ptr;
+ buf = st->es_buf_a.sb_data;
+ len = st->es_buf_a.sb_ptr;
for(i = 0; i < len - 6; i++) {
const uint8_t *p = buf + i;
if(sr) {
int duration = 90000 * 1536 / sr;
- int64_t dts = st->st_curdts;
+ int64_t dts = st->es_curdts;
int sri = rate_to_sri(sr);
if(dts == PTS_UNSET)
- dts = st->st_nextdts;
+ dts = st->es_nextdts;
if(dts != PTS_UNSET && len >= i + fsize + 6 &&
ac3_valid_frame(p + fsize)) {
int channels = acmodtab[acmod] + lfeon;
makeapkt(t, st, p, fsize, dts, duration, channels, sri);
- sbuf_cut(&st->st_buf_a, i + fsize);
+ sbuf_cut(&st->es_buf_a, i + fsize);
goto again;
}
}
}
static int
-parse_eac3(service_t *t, th_stream_t *st, size_t ilen,
+parse_eac3(service_t *t, elementary_stream_t *st, size_t ilen,
uint32_t next_startcode, int sc_offset)
{
int i, len;
return i;
again:
- buf = st->st_buf_a.sb_data;
- len = st->st_buf_a.sb_ptr;
+ buf = st->es_buf_a.sb_data;
+ len = st->es_buf_a.sb_ptr;
for(i = 0; i < len - 6; i++) {
const uint8_t *p = buf + i;
}
- int64_t dts = st->st_curdts;
+ int64_t dts = st->es_curdts;
int sri = rate_to_sri(rate);
int acmod = (p[4] >> 1) & 0x7;
int duration = 90000 * 1536 / rate;
if(dts == PTS_UNSET)
- dts = st->st_nextdts;
+ dts = st->es_nextdts;
if(dts != PTS_UNSET && len >= i + fsize + 6 &&
eac3_valid_frame(p + fsize)) {
makeapkt(t, st, p, fsize, dts, duration, channels, sri);
- sbuf_cut(&st->st_buf_a, i + fsize);
+ sbuf_cut(&st->es_buf_a, i + fsize);
goto again;
}
}
* Extract DTS and PTS and update current values in stream
*/
static int
-parse_pes_header(service_t *t, th_stream_t *st,
+parse_pes_header(service_t *t, elementary_stream_t *st,
const uint8_t *buf, size_t len)
{
int64_t dts, pts, d;
} else
return hlen + 3;
- if(st->st_buf.sb_err) {
- st->st_curdts = PTS_UNSET;
- st->st_curpts = PTS_UNSET;
+ if(st->es_buf.sb_err) {
+ st->es_curdts = PTS_UNSET;
+ st->es_curpts = PTS_UNSET;
} else {
- st->st_curdts = dts;
- st->st_curpts = pts;
+ st->es_curdts = dts;
+ st->es_curpts = pts;
}
return hlen + 3;
err:
- st->st_curdts = PTS_UNSET;
- st->st_curpts = PTS_UNSET;
- limitedlog(&st->st_loglimit_pes, "TS", service_component_nicename(st),
+ st->es_curdts = PTS_UNSET;
+ st->es_curpts = PTS_UNSET;
+ limitedlog(&st->es_loglimit_pes, "TS", service_component_nicename(st),
"Corrupted PES header");
return -1;
}
* Parse mpeg2video picture start
*/
static int
-parse_mpeg2video_pic_start(service_t *t, th_stream_t *st, int *frametype,
+parse_mpeg2video_pic_start(service_t *t, elementary_stream_t *st, int *frametype,
bitstream_t *bs)
{
int v, pct;
v = read_bits(bs, 16); /* vbv_delay */
if(v == 0xffff)
- st->st_vbv_delay = -1;
+ st->es_vbv_delay = -1;
else
- st->st_vbv_delay = v;
+ st->es_vbv_delay = v;
return 0;
}
*
*/
void
-parser_set_stream_vsize(th_stream_t *st, int width, int height)
+parser_set_stream_vsize(elementary_stream_t *st, int width, int height)
{
int need_save = 0;
- if(st->st_width == 0 && st->st_height == 0) {
+ if(st->es_width == 0 && st->es_height == 0) {
need_save = 1;
- st->st_meta_change = 0;
+ st->es_meta_change = 0;
- } else if(st->st_width != width || st->st_height != height) {
+ } else if(st->es_width != width || st->es_height != height) {
- st->st_meta_change++;
- if(st->st_meta_change == 2)
+ st->es_meta_change++;
+ if(st->es_meta_change == 2)
need_save = 1;
} else {
- st->st_meta_change = 0;
+ st->es_meta_change = 0;
}
if(need_save) {
- st->st_width = width;
- st->st_height = height;
- service_request_save(st->st_service, 1);
+ st->es_width = width;
+ st->es_height = height;
+ service_request_save(st->es_service, 1);
}
}
* Parse mpeg2video sequence start
*/
static int
-parse_mpeg2video_seq_start(service_t *t, th_stream_t *st,
+parse_mpeg2video_seq_start(service_t *t, elementary_stream_t *st,
bitstream_t *bs)
{
int v, width, height, aspect;
height = read_bits(bs, 12);
aspect = read_bits(bs, 4);
- st->st_aspect_num = mpeg2_aspect[aspect][0];
- st->st_aspect_den = mpeg2_aspect[aspect][1];
+ st->es_aspect_num = mpeg2_aspect[aspect][0];
+ st->es_aspect_den = mpeg2_aspect[aspect][1];
- st->st_frame_duration = mpeg2video_framedurations[read_bits(bs, 4)];
+ st->es_frame_duration = mpeg2video_framedurations[read_bits(bs, 4)];
v = read_bits(bs, 18) * 400;
skip_bits(bs, 1);
v = read_bits(bs, 10) * 16 * 1024 / 8;
- st->st_vbv_size = v;
+ st->es_vbv_size = v;
parser_set_stream_vsize(st, width, height);
return 0;
*
*/
static void
-parser_global_data_move(th_stream_t *st, const uint8_t *data, size_t len)
+parser_global_data_move(elementary_stream_t *st, const uint8_t *data, size_t len)
{
int len2 = drop_trailing_zeroes(data, len);
- st->st_global_data = realloc(st->st_global_data,
- st->st_global_data_len + len2);
- memcpy(st->st_global_data + st->st_global_data_len, data, len2);
- st->st_global_data_len += len2;
+ st->es_global_data = realloc(st->es_global_data,
+ st->es_global_data_len + len2);
+ memcpy(st->es_global_data + st->es_global_data_len, data, len2);
+ st->es_global_data_len += len2;
- st->st_buf.sb_ptr -= len;
+ st->es_buf.sb_ptr -= len;
}
*
* Extract framerate (or duration to be more specific)
*
- * 'steal' the st->st_buffer and use it as 'pkt' buffer
+ * 'steal' the st->es_buffer and use it as 'pkt' buffer
*
*/
static int
-parse_mpeg2video(service_t *t, th_stream_t *st, size_t len,
+parse_mpeg2video(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
- const uint8_t *buf = st->st_buf.sb_data + sc_offset;
+ const uint8_t *buf = st->es_buf.sb_data + sc_offset;
bitstream_t bs;
int frametype;
init_rbits(&bs, buf + 4, (len - 4) * 8);
- switch(st->st_startcode) {
+ switch(st->es_startcode) {
case 0x000001e0 ... 0x000001ef:
/* System start codes for video */
if(len < 9)
case 0x00000100:
/* Picture start code */
- if(st->st_frame_duration == 0)
+ if(st->es_frame_duration == 0)
return 1;
if(parse_mpeg2video_pic_start(t, st, &frametype, &bs))
return 1;
- if(st->st_curpkt != NULL)
- pkt_ref_dec(st->st_curpkt);
+ if(st->es_curpkt != NULL)
+ pkt_ref_dec(st->es_curpkt);
- st->st_curpkt = pkt_alloc(NULL, 0, st->st_curpts, st->st_curdts);
- st->st_curpkt->pkt_frametype = frametype;
- st->st_curpkt->pkt_duration = st->st_frame_duration;
- st->st_curpkt->pkt_commercial = t->s_tt_commercial_advice;
+ st->es_curpkt = pkt_alloc(NULL, 0, st->es_curpts, st->es_curdts);
+ st->es_curpkt->pkt_frametype = frametype;
+ st->es_curpkt->pkt_duration = st->es_frame_duration;
+ st->es_curpkt->pkt_commercial = t->s_tt_commercial_advice;
break;
case 0x000001b3:
/* Sequence start code */
- if(!st->st_buf.sb_err) {
+ if(!st->es_buf.sb_err) {
if(parse_mpeg2video_seq_start(t, st, &bs))
return 1;
parser_global_data_move(st, buf, len);
switch(buf[4] >> 4) {
case 0x1:
// Sequence Extension
- if(!st->st_buf.sb_err)
+ if(!st->es_buf.sb_err)
parser_global_data_move(st, buf, len);
return 2;
case 0x2:
// Sequence Display Extension
- if(!st->st_buf.sb_err)
+ if(!st->es_buf.sb_err)
parser_global_data_move(st, buf, len);
return 2;
}
if(next_startcode == 0x100 || next_startcode > 0x1af) {
/* Last picture slice (because next not a slice) */
- th_pkt_t *pkt = st->st_curpkt;
+ th_pkt_t *pkt = st->es_curpkt;
if(pkt == NULL) {
/* no packet, may've been discarded by sanity checks here */
return 1;
}
- if(st->st_global_data) {
- pkt->pkt_header = pktbuf_make(st->st_global_data,
- st->st_global_data_len);
- st->st_global_data = NULL;
- st->st_global_data_len = 0;
+ if(st->es_global_data) {
+ pkt->pkt_header = pktbuf_make(st->es_global_data,
+ st->es_global_data_len);
+ st->es_global_data = NULL;
+ st->es_global_data_len = 0;
}
- pkt->pkt_payload = pktbuf_make(st->st_buf.sb_data,
- st->st_buf.sb_ptr - 4);
- pkt->pkt_duration = st->st_frame_duration;
+ pkt->pkt_payload = pktbuf_make(st->es_buf.sb_data,
+ st->es_buf.sb_ptr - 4);
+ pkt->pkt_duration = st->es_frame_duration;
parser_deliver(t, st, pkt);
- st->st_curpkt = NULL;
+ st->es_curpkt = NULL;
- st->st_buf.sb_data = malloc(st->st_buf.sb_size);
- if(st->st_buf.sb_data == NULL) {
+ st->es_buf.sb_data = malloc(st->es_buf.sb_size);
+ if(st->es_buf.sb_data == NULL) {
fprintf(stderr, "Unable to allocate %d bytes\n",
- st->st_buf.sb_size);
+ st->es_buf.sb_size);
abort();
}
/* If we know the frame duration, increase DTS accordingly */
- if(st->st_curdts != PTS_UNSET)
- st->st_curdts += st->st_frame_duration;
+ if(st->es_curdts != PTS_UNSET)
+ st->es_curdts += st->es_frame_duration;
/* PTS cannot be extrapolated (it's not linear) */
- st->st_curpts = PTS_UNSET;
+ st->es_curpts = PTS_UNSET;
return 1;
}
break;
case 0x000001b8:
// GOP header
- if(!st->st_buf.sb_err)
+ if(!st->es_buf.sb_err)
parser_global_data_move(st, buf, len);
return 2;
* H.264 parser
*/
static int
-parse_h264(service_t *t, th_stream_t *st, size_t len,
+parse_h264(service_t *t, elementary_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
- const uint8_t *buf = st->st_buf.sb_data + sc_offset;
- uint32_t sc = st->st_startcode;
+ const uint8_t *buf = st->es_buf.sb_data + sc_offset;
+ uint32_t sc = st->es_startcode;
int64_t d;
int l2, pkttype, duration, isfield;
bitstream_t bs;
/* System start codes for video */
if(len >= 9){
uint16_t plen = buf[4] << 8 | buf[5];
- if(plen >= 0xffe9) st->st_incomplete =1;
+ if(plen >= 0xffe9) st->es_incomplete =1;
parse_pes_header(t, st, buf + 6, len - 6);
}
- if(st->st_prevdts != PTS_UNSET && st->st_curdts != PTS_UNSET) {
- d = (st->st_curdts - st->st_prevdts) & 0x1ffffffffLL;
+ if(st->es_prevdts != PTS_UNSET && st->es_curdts != PTS_UNSET) {
+ d = (st->es_curdts - st->es_prevdts) & 0x1ffffffffLL;
if(d < 90000)
- st->st_frame_duration = d;
+ st->es_frame_duration = d;
}
- st->st_prevdts = st->st_curdts;
+ st->es_prevdts = st->es_curdts;
return 1;
}
if(sc == 0x10c) {
// Padding
- st->st_buf.sb_ptr -= len;
+ st->es_buf.sb_ptr -= len;
ret = 2;
} else {
switch(sc & 0x1f) {
case 7:
- if(!st->st_buf.sb_err) {
+ if(!st->es_buf.sb_err) {
void *f = h264_nal_deescape(&bs, buf + 3, len - 3);
h264_decode_seq_parameter_set(st, &bs);
free(f);
break;
case 8:
- if(!st->st_buf.sb_err) {
+ if(!st->es_buf.sb_err) {
void *f = h264_nal_deescape(&bs, buf + 3, len - 3);
h264_decode_pic_parameter_set(st, &bs);
free(f);
case 5: /* IDR+SLICE */
case 1:
- if(st->st_curpkt != NULL || st->st_frame_duration == 0)
+ if(st->es_curpkt != NULL || st->es_frame_duration == 0)
break;
l2 = len - 3 > 64 ? 64 : len - 3;
}
free(f);
- st->st_curpkt = pkt_alloc(NULL, 0, st->st_curpts, st->st_curdts);
- st->st_curpkt->pkt_frametype = pkttype;
- st->st_curpkt->pkt_field = isfield;
- st->st_curpkt->pkt_duration = duration ?: st->st_frame_duration;
- st->st_curpkt->pkt_commercial = t->s_tt_commercial_advice;
+ st->es_curpkt = pkt_alloc(NULL, 0, st->es_curpts, st->es_curdts);
+ st->es_curpkt->pkt_frametype = pkttype;
+ st->es_curpkt->pkt_field = isfield;
+ st->es_curpkt->pkt_duration = duration ?: st->es_frame_duration;
+ st->es_curpkt->pkt_commercial = t->s_tt_commercial_advice;
break;
default:
if(next_startcode >= 0x000001e0 && next_startcode <= 0x000001ef) {
/* Complete frame */
- if (st->st_incomplete) return 4;
- th_pkt_t *pkt = st->st_curpkt;
+ if (st->es_incomplete) return 4;
+ th_pkt_t *pkt = st->es_curpkt;
if(pkt != NULL) {
- if(st->st_global_data) {
- pkt->pkt_header = pktbuf_make(st->st_global_data,
- st->st_global_data_len);
- st->st_global_data = NULL;
- st->st_global_data_len = 0;
+ if(st->es_global_data) {
+ pkt->pkt_header = pktbuf_make(st->es_global_data,
+ st->es_global_data_len);
+ st->es_global_data = NULL;
+ st->es_global_data_len = 0;
}
- pkt->pkt_payload = pktbuf_make(st->st_buf.sb_data,
- st->st_buf.sb_ptr - 4);
+ pkt->pkt_payload = pktbuf_make(st->es_buf.sb_data,
+ st->es_buf.sb_ptr - 4);
parser_deliver(t, st, pkt);
- st->st_curpkt = NULL;
- st->st_buf.sb_data = malloc(st->st_buf.sb_size);
+ st->es_curpkt = NULL;
+ st->es_buf.sb_data = malloc(st->es_buf.sb_size);
- st->st_curdts = PTS_UNSET;
- st->st_curpts = PTS_UNSET;
+ st->es_curdts = PTS_UNSET;
+ st->es_curpts = PTS_UNSET;
}
return 1;
}
* http://broadcasting.ru/pdf-standard-specifications/subtitling/dvb-sub/en300743.v1.2.1.pdf
*/
static void
-parse_subtitles(service_t *t, th_stream_t *st, const uint8_t *data,
+parse_subtitles(service_t *t, elementary_stream_t *st, const uint8_t *data,
int len, int start)
{
th_pkt_t *pkt;
const uint8_t *d;
if(start) {
/* Payload unit start */
- st->st_parser_state = 1;
- st->st_buf.sb_err = 0;
- st->st_buf.sb_ptr = 0;
+ st->es_parser_state = 1;
+ st->es_buf.sb_err = 0;
+ st->es_buf.sb_ptr = 0;
}
- if(st->st_parser_state == 0)
+ if(st->es_parser_state == 0)
return;
- sbuf_append(&st->st_buf, data, len);
+ sbuf_append(&st->es_buf, data, len);
- if(st->st_buf.sb_ptr < 6)
+ if(st->es_buf.sb_ptr < 6)
return;
- d = st->st_buf.sb_data;
+ d = st->es_buf.sb_data;
uint32_t startcode = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | d[3];
if(startcode == 0x1be) {
- st->st_parser_state = 0;
+ st->es_parser_state = 0;
return;
}
psize = d[4] << 8 | d[5];
- if(st->st_buf.sb_ptr != psize + 6)
+ if(st->es_buf.sb_ptr != psize + 6)
return;
- st->st_parser_state = 0;
+ st->es_parser_state = 0;
- hlen = parse_pes_header(t, st, d + 6, st->st_buf.sb_ptr - 6);
+ hlen = parse_pes_header(t, st, d + 6, st->es_buf.sb_ptr - 6);
if(hlen < 0)
return;
// end_of_PES_data_field_marker
if(buf[psize - 1] == 0xff) {
- pkt = pkt_alloc(buf, psize - 1, st->st_curpts, st->st_curdts);
+ pkt = pkt_alloc(buf, psize - 1, st->es_curpts, st->es_curdts);
pkt->pkt_commercial = t->s_tt_commercial_advice;
parser_deliver(t, st, pkt);
}
*
*/
static void
-parser_deliver(service_t *t, th_stream_t *st, th_pkt_t *pkt)
+parser_deliver(service_t *t, elementary_stream_t *st, th_pkt_t *pkt)
{
- if(SCT_ISAUDIO(st->st_type) && pkt->pkt_pts != PTS_UNSET &&
+ if(SCT_ISAUDIO(st->es_type) && pkt->pkt_pts != PTS_UNSET &&
(t->s_current_pts == PTS_UNSET ||
pkt->pkt_pts > t->s_current_pts ||
pkt->pkt_pts < t->s_current_pts - 180000))
#if 0
printf("PARSE: %-12s %d %10"PRId64" %10"PRId64" %10d %10d\n",
- streaming_component_type2txt(st->st_type),
+ streaming_component_type2txt(st->es_type),
pkt->pkt_frametype,
pkt->pkt_dts,
pkt->pkt_pts,
pktbuf_len(pkt->pkt_payload));
#endif
- pkt->pkt_aspect_num = st->st_aspect_num;
- pkt->pkt_aspect_den = st->st_aspect_den;
+ pkt->pkt_aspect_num = st->es_aspect_num;
+ pkt->pkt_aspect_den = st->es_aspect_den;
- // avgstat_add(&st->st_rate, pkt->pkt_payloadlen, dispatch_clock);
+ // avgstat_add(&st->es_rate, pkt->pkt_payloadlen, dispatch_clock);
/**
* Input is ok
service_set_streaming_status_flags(t, TSS_PACKETS);
/* Forward packet */
- pkt->pkt_componentindex = st->st_index;
+ pkt->pkt_componentindex = st->es_index;
streaming_message_t *sm = streaming_msg_create_pkt(pkt);
#include "packet.h"
-void parse_mpeg_ts(struct service *t, struct th_stream *st,
+void parse_mpeg_ts(struct service *t, struct elementary_stream *st,
const uint8_t *data,
int len, int start, int err);
-void parse_mpeg_ps(struct service *t, struct th_stream *st,
+void parse_mpeg_ps(struct service *t, struct elementary_stream *st,
uint8_t *data, int len);
-void parser_enqueue_packet(struct service *t, struct th_stream *st,
+void parser_enqueue_packet(struct service *t, struct elementary_stream *st,
th_pkt_t *pkt);
-void parser_set_stream_vsize(struct th_stream *st, int width, int height);
+void parser_set_stream_vsize(struct elementary_stream *st, int width, int height);
extern const unsigned int mpeg2video_framedurations[16];
{
uint16_t prognum;
uint16_t pid;
- th_stream_t *st;
+ elementary_stream_t *st;
lock_assert(&t->s_stream_mutex);
if(prognum != 0) {
if(service_stream_find(t, pid) == NULL) {
st = service_stream_create(t, pid, SCT_PMT);
- st->st_section_docrc = 1;
- st->st_got_section = pmt_callback;
+ st->es_section_docrc = 1;
+ st->es_got_section = pmt_callback;
}
}
ptr += 4;
static int
psi_desc_add_ca(service_t *t, uint16_t caid, uint32_t provid, uint16_t pid)
{
- th_stream_t *st;
+ elementary_stream_t *st;
caid_t *c;
int r = 0;
r |= PMT_UPDATE_NEW_CA_STREAM;
}
- st->st_delete_me = 0;
+ st->es_delete_me = 0;
- st->st_position = 0x40000;
+ st->es_position = 0x40000;
- LIST_FOREACH(c, &st->st_caids, link) {
+ LIST_FOREACH(c, &st->es_caids, link) {
if(c->caid == caid) {
c->delete_me = 0;
c->providerid = provid;
c->delete_me = 0;
- LIST_INSERT_HEAD(&st->st_caids, c, link);
+ LIST_INSERT_HEAD(&st->es_caids, c, link);
r |= PMT_UPDATE_NEW_CAID;
return r;
}
int parent_pid, int *position)
{
int r = 0;
- th_stream_t *st;
+ elementary_stream_t *st;
while(size >= 5) {
int page = (ptr[3] & 0x7 ?: 8) * 100 + (ptr[4] >> 4) * 10 + (ptr[4] & 0xf);
st = service_stream_create(t, pid, SCT_TEXTSUB);
}
- st->st_delete_me = 0;
+ st->es_delete_me = 0;
- if(memcmp(st->st_lang, ptr, 3)) {
+ if(memcmp(st->es_lang, ptr, 3)) {
r |= PMT_UPDATE_LANGUAGE;
- memcpy(st->st_lang, ptr, 3);
+ memcpy(st->es_lang, ptr, 3);
}
- if(st->st_parent_pid != parent_pid) {
+ if(st->es_parent_pid != parent_pid) {
r |= PMT_UPDATE_PARENT_PID;
- st->st_parent_pid = parent_pid;
+ st->es_parent_pid = parent_pid;
}
- if(st->st_position != *position) {
- st->st_position = *position;
+ if(st->es_position != *position) {
+ st->es_position = *position;
r |= PMT_REORDERED;
}
(*position)++;
static int
pidcmp(const void *A, const void *B)
{
- th_stream_t *a = *(th_stream_t **)A;
- th_stream_t *b = *(th_stream_t **)B;
- return a->st_position - b->st_position;
+ elementary_stream_t *a = *(elementary_stream_t **)A;
+ elementary_stream_t *b = *(elementary_stream_t **)B;
+ return a->es_position - b->es_position;
}
static void
sort_pids(service_t *t)
{
- th_stream_t *st, **v;
+ elementary_stream_t *st, **v;
int num = 0, i = 0;
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ TAILQ_FOREACH(st, &t->s_components, es_link)
num++;
- v = alloca(num * sizeof(th_stream_t *));
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ v = alloca(num * sizeof(elementary_stream_t *));
+ TAILQ_FOREACH(st, &t->s_components, es_link)
v[i++] = st;
- qsort(v, num, sizeof(th_stream_t *), pidcmp);
+ qsort(v, num, sizeof(elementary_stream_t *), pidcmp);
TAILQ_INIT(&t->s_components);
for(i = 0; i < num; i++)
- TAILQ_INSERT_TAIL(&t->s_components, v[i], st_link);
+ TAILQ_INSERT_TAIL(&t->s_components, v[i], es_link);
}
uint8_t dtag, dlen;
uint16_t sid;
streaming_component_type_t hts_stream_type;
- th_stream_t *st, *next;
+ elementary_stream_t *st, *next;
char lang[4];
int update = 0;
int had_components;
/* Mark all streams for deletion */
if(delete) {
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- st->st_delete_me = 1;
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ st->es_delete_me = 1;
- LIST_FOREACH(c, &st->st_caids, link)
+ LIST_FOREACH(c, &st->es_caids, link)
c->delete_me = 1;
}
}
st = service_stream_create(t, pid, hts_stream_type);
}
- st->st_delete_me = 0;
+ st->es_delete_me = 0;
- if(st->st_position != position) {
+ if(st->es_position != position) {
update |= PMT_REORDERED;
- st->st_position = position;
+ st->es_position = position;
}
- if(memcmp(st->st_lang, lang, 4)) {
+ if(memcmp(st->es_lang, lang, 4)) {
update |= PMT_UPDATE_LANGUAGE;
- memcpy(st->st_lang, lang, 4);
+ memcpy(st->es_lang, lang, 4);
}
- if(composition_id != -1 && st->st_composition_id != composition_id) {
- st->st_composition_id = composition_id;
+ if(composition_id != -1 && st->es_composition_id != composition_id) {
+ st->es_composition_id = composition_id;
update |= PMT_UPDATE_COMPOSITION_ID;
}
- if(ancillary_id != -1 && st->st_ancillary_id != ancillary_id) {
- st->st_ancillary_id = ancillary_id;
+ if(ancillary_id != -1 && st->es_ancillary_id != ancillary_id) {
+ st->es_ancillary_id = ancillary_id;
update |= PMT_UPDATE_ANCILLARY_ID;
}
}
/* Scan again to see if any streams should be deleted */
for(st = TAILQ_FIRST(&t->s_components); st != NULL; st = next) {
- next = TAILQ_NEXT(st, st_link);
+ next = TAILQ_NEXT(st, es_link);
- for(c = LIST_FIRST(&st->st_caids); c != NULL; c = cn) {
+ for(c = LIST_FIRST(&st->es_caids); c != NULL; c = cn) {
cn = LIST_NEXT(c, link);
if(c->delete_me) {
LIST_REMOVE(c, link);
}
- if(st->st_delete_me) {
+ if(st->es_delete_me) {
service_stream_destroy(t, st);
update |= PMT_UPDATE_STREAM_DELETED;
}
void
psi_save_service_settings(htsmsg_t *m, service_t *t)
{
- th_stream_t *st;
+ elementary_stream_t *st;
htsmsg_t *sub;
htsmsg_add_u32(m, "pcr", t->s_pcr_pid);
lock_assert(&t->s_stream_mutex);
- TAILQ_FOREACH(st, &t->s_components, st_link) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
sub = htsmsg_create_map();
- htsmsg_add_u32(sub, "pid", st->st_pid);
- htsmsg_add_str(sub, "type", val2str(st->st_type, streamtypetab) ?: "?");
- htsmsg_add_u32(sub, "position", st->st_position);
+ htsmsg_add_u32(sub, "pid", st->es_pid);
+ htsmsg_add_str(sub, "type", val2str(st->es_type, streamtypetab) ?: "?");
+ htsmsg_add_u32(sub, "position", st->es_position);
- if(st->st_lang[0])
- htsmsg_add_str(sub, "language", st->st_lang);
+ if(st->es_lang[0])
+ htsmsg_add_str(sub, "language", st->es_lang);
- if(st->st_type == SCT_CA) {
+ if(st->es_type == SCT_CA) {
caid_t *c;
htsmsg_t *v = htsmsg_create_list();
- LIST_FOREACH(c, &st->st_caids, link) {
+ LIST_FOREACH(c, &st->es_caids, link) {
htsmsg_t *caid = htsmsg_create_map();
htsmsg_add_u32(caid, "caid", c->caid);
htsmsg_add_msg(sub, "caidlist", v);
}
- if(st->st_type == SCT_DVBSUB) {
- htsmsg_add_u32(sub, "compositionid", st->st_composition_id);
- htsmsg_add_u32(sub, "ancillartyid", st->st_ancillary_id);
+ if(st->es_type == SCT_DVBSUB) {
+ htsmsg_add_u32(sub, "compositionid", st->es_composition_id);
+ htsmsg_add_u32(sub, "ancillartyid", st->es_ancillary_id);
}
- if(st->st_type == SCT_TEXTSUB)
- htsmsg_add_u32(sub, "parentpid", st->st_parent_pid);
+ if(st->es_type == SCT_TEXTSUB)
+ htsmsg_add_u32(sub, "parentpid", st->es_parent_pid);
- if(st->st_type == SCT_MPEG2VIDEO || st->st_type == SCT_H264) {
- if(st->st_width && st->st_height) {
- htsmsg_add_u32(sub, "width", st->st_width);
- htsmsg_add_u32(sub, "height", st->st_height);
+ if(st->es_type == SCT_MPEG2VIDEO || st->es_type == SCT_H264) {
+ if(st->es_width && st->es_height) {
+ htsmsg_add_u32(sub, "width", st->es_width);
+ htsmsg_add_u32(sub, "height", st->es_height);
}
}
*
*/
static void
-add_caid(th_stream_t *st, uint16_t caid, uint32_t providerid)
+add_caid(elementary_stream_t *st, uint16_t caid, uint32_t providerid)
{
caid_t *c = malloc(sizeof(caid_t));
c->caid = caid;
c->providerid = providerid;
c->delete_me = 0;
- LIST_INSERT_HEAD(&st->st_caids, c, link);
+ LIST_INSERT_HEAD(&st->es_caids, c, link);
}
*
*/
static void
-load_legacy_caid(htsmsg_t *c, th_stream_t *st)
+load_legacy_caid(htsmsg_t *c, elementary_stream_t *st)
{
uint32_t a, b;
const char *v;
*
*/
static void
-load_caid(htsmsg_t *m, th_stream_t *st)
+load_caid(htsmsg_t *m, elementary_stream_t *st)
{
htsmsg_field_t *f;
htsmsg_t *c, *v = htsmsg_get_list(m, "caidlist");
htsmsg_t *c;
htsmsg_field_t *f;
uint32_t u32, pid;
- th_stream_t *st;
+ elementary_stream_t *st;
streaming_component_type_t type;
const char *v;
st = service_stream_create(t, pid, type);
if((v = htsmsg_get_str(c, "language")) != NULL)
- snprintf(st->st_lang, 4, "%s", v);
+ snprintf(st->es_lang, 4, "%s", v);
if(!htsmsg_get_u32(c, "position", &u32))
- st->st_position = u32;
+ st->es_position = u32;
load_legacy_caid(c, st);
load_caid(c, st);
if(type == SCT_DVBSUB) {
if(!htsmsg_get_u32(c, "compositionid", &u32))
- st->st_composition_id = u32;
+ st->es_composition_id = u32;
if(!htsmsg_get_u32(c, "ancillartyid", &u32))
- st->st_ancillary_id = u32;
+ st->es_ancillary_id = u32;
}
if(type == SCT_TEXTSUB) {
if(!htsmsg_get_u32(c, "parentpid", &u32))
- st->st_parent_pid = u32;
+ st->es_parent_pid = u32;
}
if(type == SCT_MPEG2VIDEO || type == SCT_H264) {
if(!htsmsg_get_u32(c, "width", &u32))
- st->st_width = u32;
+ st->es_width = u32;
if(!htsmsg_get_u32(c, "height", &u32))
- st->st_height = u32;
+ st->es_height = u32;
}
}
*/
static void
-got_pmt(struct service *t, th_stream_t *st,
+got_pmt(struct service *t, elementary_stream_t *st,
const uint8_t *table, int table_len)
{
if(table[0] != 2)
{
rawts_t *rt = opaque;
service_t *t;
- th_stream_t *st;
+ elementary_stream_t *st;
uint16_t prognum;
uint16_t pid;
if(service_stream_find(t, pid) == NULL) {
st = service_stream_create(t, pid, SCT_PMT);
- st->st_section_docrc = 1;
- st->st_got_section = got_pmt;
+ st->es_section_docrc = 1;
+ st->es_got_section = got_pmt;
}
pthread_mutex_unlock(&t->s_stream_mutex);
}
*
*/
static void
-stream_init(th_stream_t *st)
+stream_init(elementary_stream_t *st)
{
- st->st_cc_valid = 0;
+ st->es_cc_valid = 0;
- st->st_startcond = 0xffffffff;
- st->st_curdts = PTS_UNSET;
- st->st_curpts = PTS_UNSET;
- st->st_prevdts = PTS_UNSET;
+ st->es_startcond = 0xffffffff;
+ st->es_curdts = PTS_UNSET;
+ st->es_curpts = PTS_UNSET;
+ st->es_prevdts = PTS_UNSET;
- st->st_pcr_real_last = PTS_UNSET;
- st->st_pcr_last = PTS_UNSET;
- st->st_pcr_drift = 0;
- st->st_pcr_recovery_fails = 0;
+ st->es_pcr_real_last = PTS_UNSET;
+ st->es_pcr_last = PTS_UNSET;
+ st->es_pcr_drift = 0;
+ st->es_pcr_recovery_fails = 0;
- st->st_blank = 0;
+ st->es_blank = 0;
}
*
*/
static void
-stream_clean(th_stream_t *st)
+stream_clean(elementary_stream_t *st)
{
- if(st->st_demuxer_fd != -1) {
+ if(st->es_demuxer_fd != -1) {
// XXX: Should be in DVB-code perhaps
- close(st->st_demuxer_fd);
- st->st_demuxer_fd = -1;
+ close(st->es_demuxer_fd);
+ st->es_demuxer_fd = -1;
}
- free(st->st_priv);
- st->st_priv = NULL;
+ free(st->es_priv);
+ st->es_priv = NULL;
/* Clear reassembly buffers */
- st->st_startcode = 0;
+ st->es_startcode = 0;
- sbuf_free(&st->st_buf);
- sbuf_free(&st->st_buf_ps);
- sbuf_free(&st->st_buf_a);
+ sbuf_free(&st->es_buf);
+ sbuf_free(&st->es_buf_ps);
+ sbuf_free(&st->es_buf_a);
- if(st->st_curpkt != NULL) {
- pkt_ref_dec(st->st_curpkt);
- st->st_curpkt = NULL;
+ if(st->es_curpkt != NULL) {
+ pkt_ref_dec(st->es_curpkt);
+ st->es_curpkt = NULL;
}
- free(st->st_global_data);
- st->st_global_data = NULL;
- st->st_global_data_len = 0;
+ free(st->es_global_data);
+ st->es_global_data = NULL;
+ st->es_global_data_len = 0;
}
*
*/
void
-service_stream_destroy(service_t *t, th_stream_t *st)
+service_stream_destroy(service_t *t, elementary_stream_t *st)
{
if(t->s_status == SERVICE_RUNNING)
stream_clean(st);
- TAILQ_REMOVE(&t->s_components, st, st_link);
- free(st->st_nicename);
+ TAILQ_REMOVE(&t->s_components, st, es_link);
+ free(st->es_nicename);
free(st);
}
service_stop(service_t *t)
{
th_descrambler_t *td;
- th_stream_t *st;
+ elementary_stream_t *st;
gtimer_disarm(&t->s_receive_timer);
/**
* Clean up each stream
*/
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ TAILQ_FOREACH(st, &t->s_components, es_link)
stream_clean(st);
t->s_status = SERVICE_IDLE;
int
service_start(service_t *t, unsigned int weight, int force_start)
{
- th_stream_t *st;
+ elementary_stream_t *st;
int r, timeout = 2;
lock_assert(&global_lock);
/**
* Initialize stream
*/
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ TAILQ_FOREACH(st, &t->s_components, es_link)
stream_init(st);
pthread_mutex_unlock(&t->s_stream_mutex);
void
service_destroy(service_t *t)
{
- th_stream_t *st;
+ elementary_stream_t *st;
th_subscription_t *s;
channel_t *ch = t->s_ch;
free(t->s_provider);
while((st = TAILQ_FIRST(&t->s_components)) != NULL) {
- TAILQ_REMOVE(&t->s_components, st, st_link);
- free(st->st_nicename);
+ TAILQ_REMOVE(&t->s_components, st, es_link);
+ free(st->es_nicename);
free(st);
}
*
*/
static void
-service_stream_make_nicename(service_t *t, th_stream_t *st)
+service_stream_make_nicename(service_t *t, elementary_stream_t *st)
{
char buf[200];
- if(st->st_pid != -1)
+ if(st->es_pid != -1)
snprintf(buf, sizeof(buf), "%s: %s @ #%d",
service_nicename(t),
- streaming_component_type2txt(st->st_type), st->st_pid);
+ streaming_component_type2txt(st->es_type), st->es_pid);
else
snprintf(buf, sizeof(buf), "%s: %s",
service_nicename(t),
- streaming_component_type2txt(st->st_type));
+ streaming_component_type2txt(st->es_type));
- free(st->st_nicename);
- st->st_nicename = strdup(buf);
+ free(st->es_nicename);
+ st->es_nicename = strdup(buf);
}
{
char buf[200];
source_info_t si;
- th_stream_t *st;
+ elementary_stream_t *st;
lock_assert(&t->s_stream_mutex);
free(t->s_nicename);
t->s_nicename = strdup(buf);
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ TAILQ_FOREACH(st, &t->s_components, es_link)
service_stream_make_nicename(t, st);
}
/**
* Add a new stream to a service
*/
-th_stream_t *
+elementary_stream_t *
service_stream_create(service_t *t, int pid,
streaming_component_type_t type)
{
- th_stream_t *st;
+ elementary_stream_t *st;
int i = 0;
int idx = 0;
lock_assert(&t->s_stream_mutex);
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- if(st->st_index > idx)
- idx = st->st_index;
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ if(st->es_index > idx)
+ idx = st->es_index;
i++;
- if(pid != -1 && st->st_pid == pid)
+ if(pid != -1 && st->es_pid == pid)
return st;
}
- st = calloc(1, sizeof(th_stream_t));
- st->st_index = idx + 1;
- st->st_type = type;
+ st = calloc(1, sizeof(elementary_stream_t));
+ st->es_index = idx + 1;
+ st->es_type = type;
- TAILQ_INSERT_TAIL(&t->s_components, st, st_link);
- st->st_service = t;
+ TAILQ_INSERT_TAIL(&t->s_components, st, es_link);
+ st->es_service = t;
- st->st_pid = pid;
- st->st_demuxer_fd = -1;
+ st->es_pid = pid;
+ st->es_demuxer_fd = -1;
- avgstat_init(&st->st_rate, 10);
- avgstat_init(&st->st_cc_errors, 10);
+ avgstat_init(&st->es_rate, 10);
+ avgstat_init(&st->es_cc_errors, 10);
service_stream_make_nicename(t, st);
if(t->s_flags & S_DEBUG)
- tvhlog(LOG_DEBUG, "service", "Add stream %s", st->st_nicename);
+ tvhlog(LOG_DEBUG, "service", "Add stream %s", st->es_nicename);
if(t->s_status == SERVICE_RUNNING)
stream_init(st);
/**
* Add a new stream to a service
*/
-th_stream_t *
+elementary_stream_t *
service_stream_find(service_t *t, int pid)
{
- th_stream_t *st;
+ elementary_stream_t *st;
lock_assert(&t->s_stream_mutex);
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- if(st->st_pid == pid)
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ if(st->es_pid == pid)
return st;
}
return NULL;
streaming_start_t *
service_build_stream_start(service_t *t)
{
- th_stream_t *st;
+ elementary_stream_t *st;
int n = 0;
streaming_start_t *ss;
lock_assert(&t->s_stream_mutex);
- TAILQ_FOREACH(st, &t->s_components, st_link)
+ TAILQ_FOREACH(st, &t->s_components, es_link)
n++;
ss = calloc(1, sizeof(streaming_start_t) +
ss->ss_num_components = n;
n = 0;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
streaming_start_component_t *ssc = &ss->ss_components[n++];
- ssc->ssc_index = st->st_index;
- ssc->ssc_type = st->st_type;
- memcpy(ssc->ssc_lang, st->st_lang, 4);
- ssc->ssc_composition_id = st->st_composition_id;
- ssc->ssc_ancillary_id = st->st_ancillary_id;
- ssc->ssc_pid = st->st_pid;
- ssc->ssc_width = st->st_width;
- ssc->ssc_height = st->st_height;
+ ssc->ssc_index = st->es_index;
+ ssc->ssc_type = st->es_type;
+ memcpy(ssc->ssc_lang, st->es_lang, 4);
+ ssc->ssc_composition_id = st->es_composition_id;
+ ssc->ssc_ancillary_id = st->es_ancillary_id;
+ ssc->ssc_pid = st->es_pid;
+ ssc->ssc_width = st->es_width;
+ ssc->ssc_height = st->es_height;
}
t->s_setsourceinfo(t, &ss->ss_si);
}
const char *
-service_component_nicename(th_stream_t *st)
+service_component_nicename(elementary_stream_t *st)
{
- return st->st_nicename;
+ return st->es_nicename;
}
const char *
uint16_t
service_get_encryption(service_t *t)
{
- th_stream_t *st;
+ elementary_stream_t *st;
caid_t *c;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- switch(st->st_type) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ switch(st->es_type) {
case SCT_CA:
- LIST_FOREACH(c, &st->st_caids, link)
+ LIST_FOREACH(c, &st->es_caids, link)
if(c->caid != 0)
return c->caid;
break;
LIST_ENTRY(th_descrambler) td_service_link;
void (*td_table)(struct th_descrambler *d, struct service *t,
- struct th_stream *st,
+ struct elementary_stream *st,
const uint8_t *section, int section_len);
int (*td_descramble)(struct th_descrambler *d, struct service *t,
- struct th_stream *st, const uint8_t *tsb);
+ struct elementary_stream *st, const uint8_t *tsb);
void (*td_stop)(struct th_descrambler *d);
* Section callback, called when a PSI table is fully received
*/
typedef void (pid_section_callback_t)(struct service *t,
- struct th_stream *pi,
+ struct elementary_stream *pi,
const uint8_t *section, int section_len);
} caid_t;
-/*
+/**
* Stream, one media component for a service.
- *
- * XXX: This should be renamed to 'elementary_stream' or something
*/
-typedef struct th_stream {
+typedef struct elementary_stream {
- TAILQ_ENTRY(th_stream) st_link;
- int st_position;
- struct service *st_service;
+ TAILQ_ENTRY(elementary_stream) es_link;
+ int es_position;
+ struct service *es_service;
- streaming_component_type_t st_type;
- int st_index;
+ streaming_component_type_t es_type;
+ int es_index;
- uint16_t st_aspect_num;
- uint16_t st_aspect_den;
+ uint16_t es_aspect_num;
+ uint16_t es_aspect_den;
- char st_lang[4]; /* ISO 639 3-letter language code */
- uint16_t st_composition_id;
- uint16_t st_ancillary_id;
+ char es_lang[4]; /* ISO 639 3-letter language code */
+ uint16_t es_composition_id;
+ uint16_t es_ancillary_id;
- int16_t st_pid;
- uint16_t st_parent_pid; /* For subtitle streams originating from
+ int16_t es_pid;
+ uint16_t es_parent_pid; /* For subtitle streams originating from
a teletext stream. this is the pid
of the teletext stream */
- uint8_t st_cc; /* Last CC */
- uint8_t st_cc_valid; /* Is CC valid at all? */
+ uint8_t es_cc; /* Last CC */
+ uint8_t es_cc_valid; /* Is CC valid at all? */
- avgstat_t st_cc_errors;
- avgstat_t st_rate;
+ avgstat_t es_cc_errors;
+ avgstat_t es_rate;
- int st_demuxer_fd;
- int st_peak_presentation_delay; /* Max seen diff. of DTS and PTS */
+ int es_demuxer_fd;
+ int es_peak_presentation_delay; /* Max seen diff. of DTS and PTS */
- struct psi_section *st_section;
- int st_section_docrc; /* Set if we should verify CRC on tables */
- pid_section_callback_t *st_got_section;
- void *st_got_section_opaque;
+ struct psi_section *es_section;
+ int es_section_docrc; /* Set if we should verify CRC on tables */
+ pid_section_callback_t *es_got_section;
+ void *es_got_section_opaque;
/* PCR recovery */
- int st_pcr_recovery_fails;
- int64_t st_pcr_real_last; /* realtime clock when we saw last PCR */
- int64_t st_pcr_last; /* PCR clock when we saw last PCR */
- int64_t st_pcr_drift;
+ int es_pcr_recovery_fails;
+ int64_t es_pcr_real_last; /* realtime clock when we saw last PCR */
+ int64_t es_pcr_last; /* PCR clock when we saw last PCR */
+ int64_t es_pcr_drift;
/* For service stream packet reassembly */
- sbuf_t st_buf;
+ sbuf_t es_buf;
- uint32_t st_startcond;
- uint32_t st_startcode;
- uint32_t st_startcode_offset;
- int st_parser_state;
- int st_parser_ptr;
- void *st_priv; /* Parser private data */
+ uint32_t es_startcond;
+ uint32_t es_startcode;
+ uint32_t es_startcode_offset;
+ int es_parser_state;
+ int es_parser_ptr;
+ void *es_priv; /* Parser private data */
- sbuf_t st_buf_ps; // program stream reassembly (analogue adapters)
- sbuf_t st_buf_a; // Audio packet reassembly
+ sbuf_t es_buf_ps; // program stream reassembly (analogue adapters)
+ sbuf_t es_buf_a; // Audio packet reassembly
- uint8_t *st_global_data;
- int st_global_data_len;
- int st_incomplete;
- int st_ssc_intercept;
- int st_ssc_ptr;
- uint8_t st_ssc_buf[32];
+ uint8_t *es_global_data;
+ int es_global_data_len;
+ int es_incomplete;
+ int es_ssc_intercept;
+ int es_ssc_ptr;
+ uint8_t es_ssc_buf[32];
- struct th_pkt *st_curpkt;
- int64_t st_curpts;
- int64_t st_curdts;
- int64_t st_prevdts;
- int64_t st_nextdts;
- int st_frame_duration;
- int st_width;
- int st_height;
+ struct th_pkt *es_curpkt;
+ int64_t es_curpts;
+ int64_t es_curdts;
+ int64_t es_prevdts;
+ int64_t es_nextdts;
+ int es_frame_duration;
+ int es_width;
+ int es_height;
- int st_meta_change;
+ int es_meta_change;
/* CA ID's on this stream */
- struct caid_list st_caids;
+ struct caid_list es_caids;
- int st_vbv_size; /* Video buffer size (in bytes) */
- int st_vbv_delay; /* -1 if CBR */
+ int es_vbv_size; /* Video buffer size (in bytes) */
+ int es_vbv_delay; /* -1 if CBR */
/* */
- int st_delete_me; /* Temporary flag for deleting streams */
+ int es_delete_me; /* Temporary flag for deleting streams */
/* Error log limiters */
- loglimiter_t st_loglimit_cc;
- loglimiter_t st_loglimit_pes;
+ loglimiter_t es_loglimit_cc;
+ loglimiter_t es_loglimit_pes;
- char *st_nicename;
+ char *es_nicename;
/* Teletext subtitle */
- char st_blank; // Last subtitle was blank
+ char es_blank; // Last subtitle was blank
-} th_stream_t;
+} elementary_stream_t;
/**
/**
* Mutex to be held during streaming.
- * This mutex also protects all th_stream_t instances for this
+ * This mutex also protects all elementary_stream_t instances for this
* transport.
*/
pthread_mutex_t s_stream_mutex;
* For simple streaming sources (such as video4linux) keeping
* track of the video and audio stream is convenient.
*/
- th_stream_t *s_video;
- th_stream_t *s_audio;
+ elementary_stream_t *s_video;
+ elementary_stream_t *s_audio;
/**
* Average continuity errors
/**
* List of all components.
*/
- struct th_stream_queue s_components;
+ struct elementary_stream_queue s_components;
/**
const char *loginfo, int *errorp,
service_t *skip);
-th_stream_t *service_stream_find(service_t *t, int pid);
+elementary_stream_t *service_stream_find(service_t *t, int pid);
-th_stream_t *service_stream_create(service_t *t, int pid,
+elementary_stream_t *service_stream_create(service_t *t, int pid,
streaming_component_type_t type);
void service_set_priority(service_t *t, int prio);
void service_restart(service_t *t, int had_components);
-void service_stream_destroy(service_t *t, th_stream_t *st);
+void service_stream_destroy(service_t *t, elementary_stream_t *st);
void service_request_save(service_t *t, int restart);
const char *service_nicename(service_t *t);
-const char *service_component_nicename(th_stream_t *st);
+const char *service_component_nicename(elementary_stream_t *st);
const char *service_tss2text(int flags);
static void
-extract_subtitle(service_t *t, th_stream_t *st,
+extract_subtitle(service_t *t, elementary_stream_t *st,
tt_mag_t *ttm, int64_t pts)
{
int i, j, off = 0;
sub[off++] = '\n';
}
- if(off == 0 && st->st_blank)
+ if(off == 0 && st->es_blank)
return; // Avoid multiple blank subtitles
- st->st_blank = !off;
+ st->es_blank = !off;
- if(st->st_curpts == pts)
+ if(st->es_curpts == pts)
pts++; // Avoid non-monotonic PTS
- st->st_curpts = pts;
+ st->es_curpts = pts;
sub[off++] = 0;
th_pkt_t *pkt = pkt_alloc(sub, off, pts, pts);
- pkt->pkt_componentindex = st->st_index;
+ pkt->pkt_componentindex = st->es_index;
streaming_message_t *sm = streaming_msg_create_pkt(pkt);
streaming_pad_deliver(&t->s_streaming_pad, sm);
static void
-tt_subtitle_deliver(service_t *t, th_stream_t *parent, tt_mag_t *ttm)
+tt_subtitle_deliver(service_t *t, elementary_stream_t *parent, tt_mag_t *ttm)
{
- th_stream_t *st;
+ elementary_stream_t *st;
if(ttm->ttm_current_pts == PTS_UNSET)
return;
- TAILQ_FOREACH(st, &t->s_components, st_link) {
- if(parent->st_pid == st->st_parent_pid &&
- ttm->ttm_curpage == st->st_pid - PID_TELETEXT_BASE) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
+ if(parent->es_pid == st->es_parent_pid &&
+ ttm->ttm_curpage == st->es_pid - PID_TELETEXT_BASE) {
extract_subtitle(t, st, ttm, ttm->ttm_current_pts);
}
}
*
*/
static void
-tt_decode_line(service_t *t, th_stream_t *st, uint8_t *buf)
+tt_decode_line(service_t *t, elementary_stream_t *st, uint8_t *buf)
{
uint8_t mpag, line, s12, s34, c;
int page, magidx, i;
tt_mag_t *ttm;
tt_private_t *ttp;
- if(st->st_priv == NULL) {
+ if(st->es_priv == NULL) {
/* Allocate privdata for reassembly */
- ttp = st->st_priv = calloc(1, sizeof(tt_private_t));
+ ttp = st->es_priv = calloc(1, sizeof(tt_private_t));
} else {
- ttp = st->st_priv;
+ ttp = st->es_priv;
}
mpag = ham_decode(buf[0], buf[1]);
*
*/
static void
-teletext_scan_stream(service_t *t, th_stream_t *st)
+teletext_scan_stream(service_t *t, elementary_stream_t *st)
{
- tt_private_t *ttp = st->st_priv;
+ tt_private_t *ttp = st->es_priv;
tt_mag_t *ttm;
int i;
*
*/
void
-teletext_input(service_t *t, th_stream_t *st, const uint8_t *tsb)
+teletext_input(service_t *t, elementary_stream_t *st, const uint8_t *tsb)
{
int i, j;
const uint8_t *x;
#ifndef TELETEXT_H
#define TELETEXT_H
-void teletext_input(struct service *t, struct th_stream *st,
+void teletext_input(struct service *t, struct elementary_stream *st,
const uint8_t *tsb);
#endif /* TELETEXT_H */
got_section(const uint8_t *data, size_t len, void *opaque)
{
th_descrambler_t *td;
- th_stream_t *st = opaque;
- service_t *t = st->st_service;
+ elementary_stream_t *st = opaque;
+ service_t *t = st->es_service;
- if(st->st_type == SCT_CA) {
+ if(st->es_type == SCT_CA) {
LIST_FOREACH(td, &t->s_descramblers, td_service_link)
td->td_table(td, t, st, data, len);
- } else if(st->st_got_section != NULL) {
- st->st_got_section(t, st, data, len);
+ } else if(st->es_got_section != NULL) {
+ st->es_got_section(t, st, data, len);
}
}
* Continue processing of transport stream packets
*/
static void
-ts_recv_packet0(service_t *t, th_stream_t *st, const uint8_t *tsb)
+ts_recv_packet0(service_t *t, elementary_stream_t *st, const uint8_t *tsb)
{
int off, pusi, cc, error;
if(tsb[3] & 0x10) {
cc = tsb[3] & 0xf;
- if(st->st_cc_valid && cc != st->st_cc) {
+ if(st->es_cc_valid && cc != st->es_cc) {
/* Incorrect CC */
- limitedlog(&st->st_loglimit_cc, "TS", service_component_nicename(st),
+ limitedlog(&st->es_loglimit_cc, "TS", service_component_nicename(st),
"Continuity counter error");
avgstat_add(&t->s_cc_errors, 1, dispatch_clock);
- avgstat_add(&st->st_cc_errors, 1, dispatch_clock);
+ avgstat_add(&st->es_cc_errors, 1, dispatch_clock);
// Mark as error if this is not the first packet of a payload
if(!pusi)
error |= 0x2;
}
- st->st_cc_valid = 1;
- st->st_cc = (cc + 1) & 0xf;
+ st->es_cc_valid = 1;
+ st->es_cc = (cc + 1) & 0xf;
}
off = tsb[3] & 0x20 ? tsb[4] + 5 : 4;
- switch(st->st_type) {
+ switch(st->es_type) {
case SCT_CA:
case SCT_PAT:
case SCT_PMT:
- if(st->st_section == NULL)
- st->st_section = calloc(1, sizeof(struct psi_section));
+ if(st->es_section == NULL)
+ st->es_section = calloc(1, sizeof(struct psi_section));
- psi_section_reassemble(st->st_section, tsb, st->st_section_docrc,
+ psi_section_reassemble(st->es_section, tsb, st->es_section_docrc,
got_section, st);
break;
/**
* Recover PCR
*
- * st->st_pcr_drift will increase if our (system clock) runs faster
+ * st->es_pcr_drift will increase if our (system clock) runs faster
* than the stream PCR
*/
static void
-ts_extract_pcr(service_t *t, th_stream_t *st, const uint8_t *tsb,
+ts_extract_pcr(service_t *t, elementary_stream_t *st, const uint8_t *tsb,
int64_t *pcrp)
{
int64_t real, pcr, d;
real = getmonoclock();
- if(st->st_pcr_real_last != PTS_UNSET) {
- d = (real - st->st_pcr_real_last) - (pcr - st->st_pcr_last);
+ if(st->es_pcr_real_last != PTS_UNSET) {
+ d = (real - st->es_pcr_real_last) - (pcr - st->es_pcr_last);
if(d < -90000LL || d > 90000LL) {
- st->st_pcr_recovery_fails++;
- if(st->st_pcr_recovery_fails > 10) {
- st->st_pcr_recovery_fails = 0;
- st->st_pcr_real_last = PTS_UNSET;
+ st->es_pcr_recovery_fails++;
+ if(st->es_pcr_recovery_fails > 10) {
+ st->es_pcr_recovery_fails = 0;
+ st->es_pcr_real_last = PTS_UNSET;
}
return;
}
- st->st_pcr_recovery_fails = 0;
- st->st_pcr_drift += d;
+ st->es_pcr_recovery_fails = 0;
+ st->es_pcr_drift += d;
- if(t->s_pcr_pid == st->st_pid) {
+ if(t->s_pcr_pid == st->es_pid) {
/* This is the registered PCR PID, adjust service PCR drift
via an IIR filter */
- t->s_pcr_drift = (t->s_pcr_drift * 255 + st->st_pcr_drift) / 256;
+ t->s_pcr_drift = (t->s_pcr_drift * 255 + st->es_pcr_drift) / 256;
}
}
- st->st_pcr_last = pcr;
- st->st_pcr_real_last = real;
+ st->es_pcr_last = pcr;
+ st->es_pcr_real_last = real;
}
/**
void
ts_recv_packet1(service_t *t, const uint8_t *tsb, int64_t *pcrp)
{
- th_stream_t *st;
+ elementary_stream_t *st;
int pid, n, m, r;
th_descrambler_t *td;
int error = 0;
avgstat_add(&t->s_rate, 188, dispatch_clock);
if((tsb[3] & 0xc0) ||
- (t->s_scrambled_seen && st->st_type != SCT_CA &&
- st->st_type != SCT_PAT && st->st_type != SCT_PMT)) {
+ (t->s_scrambled_seen && st->es_type != SCT_CA &&
+ st->es_type != SCT_PAT && st->es_type != SCT_PMT)) {
/**
* Lock for descrambling, but only if packet was not in error
void
ts_recv_packet2(service_t *t, const uint8_t *tsb)
{
- th_stream_t *st;
+ elementary_stream_t *st;
int pid = (tsb[1] & 0x1f) << 8 | tsb[2];
if((st = service_stream_find(t, pid)) != NULL)
*/
static void
ts_muxer_raw_input(struct th_subscription *s, void *data, int len,
- th_stream_t *st, void *opaque)
+ elementary_stream_t *st, void *opaque)
{
th_muxer_t *tm = s->ths_muxer;
ts_muxer_t *ts = opaque;
static void
lookahead_dequeue(ts_muxer_t *ts, th_muxstream_t *tms)
{
- // th_stream_t *st = tms->tms_stream;
+ // elementary_stream_t *st = tms->tms_stream;
th_pkt_t *pkt;
th_muxpkt_t *tm;
th_refpkt_t *o;
ts_mux_packet_input(void *opaque, th_muxstream_t *tms, th_pkt_t *pkt)
{
ts_muxer_t *ts = opaque;
- th_stream_t *st = tms->tms_stream;
+ elementary_stream_t *st = tms->tms_stream;
th_refpkt_t *trp;
if(tms->tms_index == 0)
int pididx = PID_ES_BASE;
th_muxstream_t *tms;
th_muxer_t *tm;
- th_stream_t *st;
+ elementary_stream_t *st;
ts->ts_output = output;
LIST_HEAD(service_list, service);
RB_HEAD(service_tree, service);
TAILQ_HEAD(service_queue, service);
-LIST_HEAD(th_stream_list, th_stream);
-TAILQ_HEAD(th_stream_queue, th_stream);
+LIST_HEAD(elementary_stream_list, elementary_stream);
+TAILQ_HEAD(elementary_stream_queue, elementary_stream);
LIST_HEAD(th_muxer_list, th_muxer);
LIST_HEAD(th_muxstream_list, th_muxstream);
LIST_HEAD(th_descrambler_list, th_descrambler);
v4l_input(v4l_adapter_t *va)
{
service_t *t = va->va_current_service;
- th_stream_t *st;
+ elementary_stream_t *st;
uint8_t buf[4000];
uint8_t *ptr, *pkt;
int len, l, r;
}
if(va->va_lenlock == 2) {
- l = st->st_buf_ps.sb_size;
- st->st_buf_ps.sb_data = pkt = realloc(st->st_buf_ps.sb_data, l);
+ l = st->es_buf_ps.sb_size;
+ st->es_buf_ps.sb_data = pkt = realloc(st->es_buf_ps.sb_data, l);
- r = l - st->st_buf_ps.sb_ptr;
+ r = l - st->es_buf_ps.sb_ptr;
if(r > len)
r = len;
- memcpy(pkt + st->st_buf_ps.sb_ptr, ptr, r);
+ memcpy(pkt + st->es_buf_ps.sb_ptr, ptr, r);
ptr += r;
len -= r;
- st->st_buf_ps.sb_ptr += r;
- if(st->st_buf_ps.sb_ptr == l) {
+ st->es_buf_ps.sb_ptr += r;
+ if(st->es_buf_ps.sb_ptr == l) {
service_set_streaming_status_flags(t, TSS_MUX_PACKETS);
parse_mpeg_ps(t, st, pkt + 6, l - 6);
- st->st_buf_ps.sb_size = 0;
+ st->es_buf_ps.sb_size = 0;
va->va_startcode = 0;
} else {
- assert(st->st_buf_ps.sb_ptr < l);
+ assert(st->es_buf_ps.sb_ptr < l);
}
} else {
- st->st_buf_ps.sb_size = st->st_buf_ps.sb_size << 8 | *ptr;
+ st->es_buf_ps.sb_size = st->es_buf_ps.sb_size << 8 | *ptr;
va->va_lenlock++;
if(va->va_lenlock == 2) {
- st->st_buf_ps.sb_size += 6;
- st->st_buf_ps.sb_ptr = 6;
+ st->es_buf_ps.sb_size += 6;
+ st->es_buf_ps.sb_ptr = 6;
}
ptr++; len--;
}
htsbuf_queue_t *hq = &hc->hc_reply;
htsmsg_t *out, *streams, *c;
service_t *t;
- th_stream_t *st;
+ elementary_stream_t *st;
caid_t *ca;
char buf[128];
streams = htsmsg_create_list();
- TAILQ_FOREACH(st, &t->s_components, st_link) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
c = htsmsg_create_map();
- htsmsg_add_u32(c, "pid", st->st_pid);
+ htsmsg_add_u32(c, "pid", st->es_pid);
- htsmsg_add_str(c, "type", streaming_component_type2txt(st->st_type));
+ htsmsg_add_str(c, "type", streaming_component_type2txt(st->es_type));
- switch(st->st_type) {
+ switch(st->es_type) {
default:
htsmsg_add_str(c, "details", "");
break;
case SCT_CA:
buf[0] = 0;
- LIST_FOREACH(ca, &st->st_caids, link) {
+ LIST_FOREACH(ca, &st->es_caids, link) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
"%s (0x%04x) [0x%08x]",
psi_caid2name(ca->caid), ca->caid, ca->providerid);
case SCT_AC3:
case SCT_AAC:
case SCT_MPEG2AUDIO:
- htsmsg_add_str(c, "details", st->st_lang);
+ htsmsg_add_str(c, "details", st->es_lang);
break;
case SCT_DVBSUB:
snprintf(buf, sizeof(buf), "%s (%04x %04x)",
- st->st_lang, st->st_composition_id, st->st_ancillary_id);
+ st->es_lang, st->es_composition_id, st->es_ancillary_id);
htsmsg_add_str(c, "details", buf);
break;
case SCT_MPEG2VIDEO:
case SCT_H264:
buf[0] = 0;
- if(st->st_frame_duration)
+ if(st->es_frame_duration)
snprintf(buf, sizeof(buf), "%2.2f Hz",
- 90000.0 / st->st_frame_duration);
+ 90000.0 / st->es_frame_duration);
htsmsg_add_str(c, "details", buf);
break;
}
dumptransports(htsbuf_queue_t *hq, struct service_list *l, int indent)
{
service_t *t;
- th_stream_t *st;
+ elementary_stream_t *st;
outputtitle(hq, indent, "Transports (or services)");
LIST_FOREACH(t, l, s_group_link) {
htsbuf_qprintf(hq, "%*.s-------------------------------------------\n",
indent + 4, "");
- TAILQ_FOREACH(st, &t->s_components, st_link) {
+ TAILQ_FOREACH(st, &t->s_components, es_link) {
caid_t *caid;
htsbuf_qprintf(hq, "%*.s%-16s %-5d %-5d %-5s\n", indent + 4, "",
- streaming_component_type2txt(st->st_type),
- st->st_index,
- st->st_pid,
- st->st_lang[0] ? st->st_lang : "");
- LIST_FOREACH(caid, &st->st_caids, link) {
+ streaming_component_type2txt(st->es_type),
+ st->es_index,
+ st->es_pid,
+ st->es_lang[0] ? st->es_lang : "");
+ LIST_FOREACH(caid, &st->es_caids, link) {
htsbuf_qprintf(hq, "%*.sCAID %04x (%s) %08x\n", indent + 6, "",
caid->caid,
psi_caid2name(caid->caid),
projects / thirdparty / tvheadend.git / commitdiff
