/*
* ISO 13818 stream multiplexer
* Copyright (C) 2001 Convergence Integrated Media GmbH Berlin
* Author: Oskar Schirmer (schirmer@scara.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Module: Split TS
* Purpose: Split a transport stream.
*
* This module examines a transport stream and collects the packets to
* the input stream buffers. PSI data is extracted (and stored in the
* files pat structures), descriptors are copied to the corresponding
* mapstreams.
*/
#include "global.h"
#include "error.h"
#include "input.h"
#include "splice.h"
#include "ts.h"
#include "pes.h"
#include "descref.h"
#include "splitpes.h"
#include "splitts.h"
#include "crc32.h"
static byte pusi, afcc, afflg1;
static int paylen;
/* Skip in input raw data buffer for TS-syncbyte.
* Precondition: f!=NULL
* Postcondition: if found: f->data.out indicates the syncbyte.
* Return: TRUE if found, FALSE otherwise
*/
static boolean ts_skip_to_syncbyte (file_descr *f)
{
int i, l, k;
boolean r = FALSE;
l = k = list_size (f->data);
i = f->data.out;
while ((l > 0)
&& ((f->data.ptr[i] != TS_SYNC_BYTE) || (r = TRUE, FALSE))) {
list_incr (i,f->data,1);
l -= 1;
}
k -= l;
if (k > 0) {
warn (LWAR,"Skipped",ETST,1,1,k);
f->skipped += k;
f->total += k;
list_incr (f->data.out,f->data,k);
}
return (r);
}
/* Determine the PID of a TS packet and other details.
* Procondition: d!=NULL points to a packet.
* Postcondition: Set global "Payload Unit Start Indicator", "Adaption Field
* Control & Continuity Counter", "Adataption Field Flags 1".
* Return: 13 bit PID.
*/
static int ts_packet_headinfo (refr_data *d)
{
int i, l;
i = d->out;
list_incr (i,*d,TS_PACKET_PID);
l = (pusi = d->ptr[i]) & 0x1F;
list_incr (i,*d,1);
l = (l << 8) | d->ptr[i];
list_incr (i,*d,1);
if (!((afcc = d->ptr[i]) & TS_AFC_BOTH)) {
l = TS_PID_NULL;
} else {
if (afcc & TS_AFC_ADAPT) {
byte aflen;
list_incr (i,*d,1);
if ((aflen = d->ptr[i]) == 0) {
afflg1 = 0x00;
} else {
list_incr (i,*d,1);
afflg1 = d->ptr[i];
}
paylen = TS_PACKET_SIZE - TS_PACKET_FLAGS1 - aflen;
} else {
paylen = TS_PACKET_SIZE - TS_PACKET_HEADSIZE;
}
}
warn (LSEC,"Packet PID",ETST,2,1,l);
warn (LDEB,"Packet PID",ETST,afcc,afflg1,paylen);
return (l);
}
/* Extract adaption field from a TS packet.
* Distribute the information as needed (to s, s->ctrl, etc).
* Precondition: f!=NULL, adf indicates a packet in f->data, s!=NULL is the
* destined data stream, m!=NULL the map stream, afcc and afflg1 set.
*/
static void ts_adaption_field (file_descr *f,
int adf,
stream_descr *s,
stream_descr *m)
{
warn (LDEB,"AdaptF",ETST,11,adf,afcc);
if (afcc & TS_AFC_ADAPT) {
list_incr (adf,f->data,TS_PACKET_FLAGS1+1);
if (afflg1 & TS_ADAPT_DISCONTI) {
}
if (afflg1 & TS_ADAPT_RANDOMAC) {
}
if (afflg1 & TS_ADAPT_PRIORITY) {
}
if (afflg1 & TS_ADAPT_PCRFLAG) {
clockref *pcr;
long b;
byte a;
pcr = &s->ctrl.ptr[s->ctrl.in].pcr;
a = f->data.ptr[adf];
list_incr (adf,f->data,1);
pcr->ba33 = (a >> 7) & 1;
b = (a << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
b = (b << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
b = (b << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
a = f->data.ptr[adf];
pcr->base = (b << 1) | ((a >> 7) & 1);
marker_check (a,0x7E,0x7E);
list_incr (adf,f->data,1);
pcr->ext = ((a & 1) << 8) | f->data.ptr[adf];
warn (LINF,"PCR",ETST,10,pcr->ba33,pcr->base);
pcr->valid = TRUE;
list_incr (adf,f->data,1);
/* attention ! what if it is not PCR_PID ? xxx */
if (S_ISREG (f->st_mode)) {
cref2msec (&m->u.m.conv, *pcr, &m->u.m.msectime);
} else {
cref2msec (&m->u.m.conv, *pcr, &m->u.m.msectime);
}
}
if (afflg1 & TS_ADAPT_OPCRFLAG) {
clockref *opcr;
long b;
byte a;
opcr = &s->ctrl.ptr[s->ctrl.in].opcr;
a = f->data.ptr[adf];
list_incr (adf,f->data,1);
opcr->ba33 = (a >> 7) & 1;
b = (a << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
b = (b << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
b = (b << 8) | f->data.ptr[adf];
list_incr (adf,f->data,1);
a = f->data.ptr[adf];
opcr->base = (b << 1) | ((a >> 7) & 1);
marker_check (a,0x7E,0x7E);
list_incr (adf,f->data,1);
opcr->ext = ((a & 1) << 8) | f->data.ptr[adf];
warn (LINF,"OPCR",ETST,10,opcr->ba33,opcr->base);
opcr->valid = TRUE;
s->u.d.has_opcr = TRUE;
list_incr (adf,f->data,1);
}
if (afflg1 & TS_ADAPT_SPLICING) {
list_incr (adf,f->data,1);
}
if (afflg1 & TS_ADAPT_TPRIVATE) {
byte tpdl;
tpdl = f->data.ptr[adf];
list_incr (adf,f->data,tpdl+1);
}
if (afflg1 & TS_ADAPT_EXTENSIO) {
byte afflg2, afel;
afel = f->data.ptr[adf];
list_incr (adf,f->data,1);
afflg2 = f->data.ptr[adf];
list_incr (adf,f->data,1);
if (afflg2 & TS_ADAPT2_LTWFLAG) {
list_incr (adf,f->data,2);
}
if (afflg2 & TS_ADAPT2_PIECEWRF) {
list_incr (adf,f->data,3);
}
if (afflg2 & TS_ADAPT2_SEAMLESS) {
list_incr (adf,f->data,5);
}
}
}
}
/* Parse one TS packet with given PID.
* Depending on the actual state (c->length) and the contents of the packet,
* provide the data into the stream and possibly complete a PES package.
* c->length keeps the progress of data acquisition, as follows:
* =0: initial, waiting for payload unit start indicator
* <-2, increasing: not yet enough data to evaluate the PES header
* =-2: evaluate the PES packet length field
* =-1: acquiring packet with unspecified length
* >0, decreasing: amount of data still missing
* =0: final, close PES packet, start new one
* Precondition: f!=NULL.
* Return: TRUE if something was processed, FALSE if no data/space available
*/
static boolean ts_data_stream (file_descr *f,
int pid)
{
stream_descr *s;
ctrl_buffer *c;
int i, fdo, sdi, adf;
warn (LDEB,"Data Packet",ETST,3,0,pid);
s = ts_file_stream (f,pid);
if (s != NULL) {
if (!list_full (s->ctrl)) {
c = &s->ctrl.ptr[s->ctrl.in];
if (c->length == -1) {
if (pusi & TS_UNIT_START) {
c->length = s->data.in - c->index;
warn (LINF,"Closed unbound packet",ETST,3,5,c->length);
f->payload += c->length;
c->sequence = f->sequence++;
c->scramble = 0;
c->msecread = msec_now ();
c->msecpush = s->u.d.mapstream->u.m.msectime;
list_incr (s->ctrl.in,s->ctrl,1);
c = &s->ctrl.ptr[s->ctrl.in];
c->length = 0;
c->pcr.valid = FALSE;
c->opcr.valid = FALSE;
}
}
if (c->length == 0) {
if (pusi & TS_UNIT_START) {
if (list_free (s->data) >=
(2*(PES_HEADER_SIZE-1+TS_PACKET_SIZE-TS_PACKET_HEADSIZE)-1)) {
if ((PES_HEADER_SIZE-1+TS_PACKET_SIZE-TS_PACKET_HEADSIZE)
> list_freeinend (s->data)) {
s->data.in = 0;
}
c->index = s->data.in;
c->length = -2 - PES_HEADER_SIZE;
} else {
return (FALSE);
}
} else {
f->skipped += TS_PACKET_SIZE;
list_incr (f->data.out,f->data,TS_PACKET_SIZE);
f->total += TS_PACKET_SIZE;
return (TRUE);
}
}
sdi = s->data.in;
fdo = adf = f->data.out;
list_incr (fdo,f->data,TS_PACKET_SIZE - paylen);
if (c->length == -1) {
if (list_freecachedin (s->data,sdi) >= paylen) {
i = list_freeinendcachedin (s->data,sdi);
if (i <= paylen) {
if (list_freecachedin (s->data,sdi) >=
(i + (sdi - c->index) + paylen)) {
sdi -= c->index;
memmove (&s->data.ptr[0],&s->data.ptr[c->index],sdi);
c->index = 0;
} else {
return (FALSE);
}
}
while (paylen > 0) {
i = MAX_DATA_RAWB - fdo;
if (i > paylen) {
i = paylen;
}
memcpy (&s->data.ptr[sdi],&f->data.ptr[fdo],i);
list_incr (sdi,s->data,i);
list_incr (fdo,f->data,i);
paylen -= i;
}
} else {
return (FALSE);
}
}
if (c->length < -2) {
c->length += paylen;
while (paylen > 0) {
i = MAX_DATA_RAWB - fdo;
if (i > paylen) {
i = paylen;
}
memcpy (&s->data.ptr[sdi],&f->data.ptr[fdo],i);
list_incr (sdi,s->data,i);
list_incr (fdo,f->data,i);
paylen -= i;
}
if (c->length > -2) {
c->length = -2;
}
}
if (c->length == -2) {
if ((s->data.ptr[c->index] != 0x00)
|| (s->data.ptr[c->index+1] != 0x00)
|| (s->data.ptr[c->index+2] != 0x01)) {
warn (LWAR,"Payload not good PES",ETST,3,3,0);
c->length = 0;
return (TRUE);
}
i = (s->data.ptr[c->index+PES_PACKET_LENGTH] << 8)
| s->data.ptr[c->index+PES_PACKET_LENGTH+1];
if (i == 0) {
warn (LSEC,"Payload length 0",ETST,3,4,0);
c->length = -1;
} else {
if (i > list_freeinendcachedin (s->data,c->index) - PES_HEADER_SIZE) {
if (list_freecachedin (s->data,sdi) <
(2 * (i + PES_HEADER_SIZE) - (sdi - c->index) - 1)) {
return (FALSE);
} else {
sdi -= c->index;
memmove (&s->data.ptr[0],&s->data.ptr[c->index],sdi);
c->index = 0;
}
} else {
if (list_freecachedin (s->data,sdi) <
(i + PES_HEADER_SIZE - (sdi - c->index))) {
return (FALSE);
}
}
c->length = i + PES_HEADER_SIZE - (sdi - c->index);
if (c->length < 0) {
warn (LWAR,"Too much payload",ETST,3,1,c->length);
c->length = 0;
}
}
}
if ((c->length > 0)
&& (paylen > 0)) {
if (paylen > c->length) {
warn (LWAR,"Too much payload",ETST,3,2,c->length);
paylen = c->length;
}
c->length -= paylen;
while (paylen > 0) {
i = MAX_DATA_RAWB - fdo;
if (i > paylen) {
i = paylen;
}
memcpy (&s->data.ptr[sdi],&f->data.ptr[fdo],i);
list_incr (sdi,s->data,i);
list_incr (fdo,f->data,i);
paylen -= i;
}
}
s->data.in = sdi;
f->data.out = fdo;
ts_adaption_field (f,adf,s,s->u.d.mapstream);
if (c->length == 0) {
c->length = s->data.in - c->index;
f->payload += c->length;
c->sequence = f->sequence++;
c->scramble = 0;
c->msecread = msec_now ();
c->msecpush = s->u.d.mapstream->u.m.msectime;
list_incr (s->ctrl.in,s->ctrl,1);
c = &s->ctrl.ptr[s->ctrl.in];
c->length = 0;
c->pcr.valid = FALSE;
c->opcr.valid = FALSE;
}
} else {
return (FALSE);
}
} else {
list_incr (f->data.out,f->data,TS_PACKET_SIZE);
}
f->total += TS_PACKET_SIZE;
return (TRUE);
}
/* Process changes that arise from a new PMT.
* Match the new PMT with the existing PAT/PMT and adjust this to
* reflect the changes in the TS. Try to keep PIDs etc stable.
* Precondition: f!=NULL, new!=NULL the partial new PMT
*/
static void remap_new_program (file_descr *f,
pmt_descr *new)
{
pmt_descr* p;
int i, j, k;
byte *d;
struct {
boolean tnew : 1;
boolean tpat : 1;
} treated[MAX_PMTSTREAMS];
warn (LINF,"Remap",ETST,7,new->descrlen,new->pmt_pid);
p = f->u.ts.pat;
while ((p != NULL) && (p->programnumber != new->programnumber)) {
p = p->next;
}
warn (LDEB,"Remap 2",ETST,p?p->streams:0,(long)f->u.ts.pat,p);
if (p != NULL) {
warn (LDEB,"Remap 2a",ETST,p->pmt_version,new->pmt_version,new);
if (p->pmt_version == new->pmt_version) {
/* check more here, or fall through ? */
p->pat_section = new->pat_section; /* announce presence */
return;
}
} else {
if ((p = malloc (sizeof(pmt_descr))) == NULL) {
warn (LERR,"PAT malloc failed",ETST,7,1,sizeof(pmt_descr));
return;
}
p->next = f->u.ts.pat;
p->programnumber = new->programnumber;
p->streams = 0;
f->u.ts.pat = p;
warn (LIMP,"Remap PAT",ETST,7,new->pat_section,new->pmt_pid);
}
p->pat_section = new->pat_section;
p->pmt_version = new->pmt_version;
p->pcr_pid = new->pcr_pid;
if (ts_file_stream(f,new->pmt_pid) == NULL) {
if ((ts_file_stream(f,new->pmt_pid) =
input_openstream (f,new->pmt_pid,0,0,sd_map,NULL)) == NULL) {
p->pat_section = -1;
return;
}
}
p->pmt_pid = new->pmt_pid;
memset (&treated[0],0,sizeof(treated));
i = new->streams;
while (--i >= 0) {
j = p->streams;
warn (LDEB,"Remap 3",ETST,0,i,j);
while ((--j >= 0)
&& (p->streamtype[j] != new->streamtype[i])
&& (p->stream[j] != new->stream[i])) {
}
if (j >= 0) {
treated[j].tpat = TRUE;
treated[i].tnew = TRUE;
warn (LIMP,"Remap Match",ETST,7,new->streamtype[i],new->stream[i]);
}
}
i = new->streams;
while (--i >= 0) {
if (!treated[i].tnew) {
j = p->streams;
while ((--j >= 0)
&& (treated[j].tpat)
&& (p->streamtype[j] != new->streamtype[i])) {
}
if (j >= 0) {
treated[j].tpat = TRUE;
warn (LIMP,"Remap Move",ETST,7,p->stream[j],new->stream[i]);
warn (LSEC,"Remap Move",ETST,7,p->streamtype[j],new->streamtype[i]);
if (ts_file_stream(f,p->stream[j]) != NULL) {
k = ts_file_stream(f,p->stream[j])->u.d.progs;
while (--k >= 0) {
ts_file_stream(f,new->stream[i]) =
connect_streamprog (
f,ts_file_stream(f,p->stream[j])->u.d.pdescr[k]->program_number,
new->stream[i],
ts_file_stream(f,p->stream[j])->stream_id,new->streamtype[i],
ts_file_stream(f,new->stream[i]),
ts_file_stream(f,new->pmt_pid),FALSE);
}
if (ts_file_stream(f,new->stream[i]) != NULL) {
ts_file_stream(f,new->stream[i])->u.d.trigger = TRUE;
}
ts_file_stream(f,p->stream[j])->endaction = ENDSTR_KILL;
} else {
/* was not used -> will not use */
}
} else {
warn (LIMP,"Remap New",ETST,7,new->streamtype[i],new->stream[i]);
}
}
}
j = p->streams;
while (--j >= 0) {
if (!(treated[j].tpat)) {
warn (LIMP,"Remap Close",ETST,7,p->streamtype[j],p->stream[j]);
ts_file_stream (f,p->stream[j])->endaction = ENDSTR_KILL;
}
}
p->streams = new->streams;
memcpy (p->stream,new->stream,p->streams * sizeof(p->stream[0]));
memcpy (p->streamtype,new->streamtype,p->streams * sizeof(p->streamtype[0]));
p->descrlen = i = new->descrlen;
if (i != 0) {
memcpy (p->elemdescr,new->elemdescr,i);
d = &p->elemdescr[0];
j = ((d[0] & 0x0F) << 8) + d[1];
i -= (j+2);
if (i >= 0) {
d += 2;
alloc_descriptor (ts_file_stream(f,p->pmt_pid),p->pmt_pid,
p->programnumber,p->pmt_version);
while (j > 1) {
d = put_descriptor_s (d,ts_file_stream(f,p->pmt_pid),&j);
}
if (j != 0) {
warn (LWAR,"PAT descr error",ETST,7,3,j);
} else {
finish_descriptor (ts_file_stream(f,p->pmt_pid));
while (i >= TS_PMTELEM_SIZE) {
k = ((d[1] & 0x1F) << 8) + d[2];
j = ((d[3] & 0x0F) << 8) + d[4];
i -= (j+TS_PMTELEM_SIZE);
if (i >= 0) {
d += TS_PMTELEM_SIZE;
alloc_descriptor (ts_file_stream(f,p->pmt_pid),k,
p->programnumber,p->pmt_version);
while (j > 1) {
d = put_descriptor_s (d,ts_file_stream(f,p->pmt_pid),&j);
}
if (j != 0) {
warn (LWAR,"PAT descr error",ETST,7,5,j);
i = -1;
} else {
finish_descriptor (ts_file_stream(f,p->pmt_pid));
}
}
}
if (i != 0) {
warn (LWAR,"PAT descr error",ETST,7,4,i);
}
}
} else {
warn (LWAR,"PAT descr error",ETST,7,2,i);
}
}
}
/* Unlink stream in an old program that will be released.
* Mark the corresponding streams to be closed as they cease.
* Precondition: f!=NULL, old!=NULL
*/
static void unmap_old_program (file_descr *f,
pmt_descr *old)
{
int i;
warn (LIMP,"Unmap",ETST,8,old->descrlen,old->pmt_pid);
i = old->streams;
while (--i >= 0) {
if (ts_file_stream (f,old->stream[i]) != NULL) {
warn (LIMP,"Unmap Close",ETST,8,old->streamtype[i],old->stream[i]);
ts_file_stream (f,old->stream[i])->endaction = ENDSTR_KILL;
}
}
if (ts_file_stream (f,old->pmt_pid) != NULL) {
ts_file_stream (f,old->pmt_pid)->endaction = ENDSTR_CLOSE;
}
}
/* Release old programs that are no longer valid.
* Old programs are marked with pat_section < 0.
* If f!=NULL, then also unmap all the old programs (used with current pat).
* Precondition: pp!=NULL.
*/
static void release_old_progs (file_descr *f,
pmt_descr **pp)
{
pmt_descr *p;
p = *pp;
while (p != NULL) {
if (p->pat_section < 0) {
if (f != NULL) {
unmap_old_program (f,p);
}
*pp = p->next;
free (p);
} else {
pp = &p->next;
}
p = *pp;
}
}
static void eval_pat_section (file_descr *f,
stream_descr *s,
int seclen,
int tsid,
int versionnb,
boolean curni,
int sectionnb,
int lastsecnb)
{
pmt_descr *p;
byte *d;
int i, l;
warn (LINF,"eval PAT",ETST,5,seclen,tsid);
if (curni) {
if (versionnb != f->u.ts.newpat_version) {
f->u.ts.newpat_version = versionnb;
p = f->u.ts.newpat;
while (p != NULL) {
p->pat_section = -1;
p = p->next;
}
}
d = &s->u.m.psi_data[TS_SECTIONHEAD];
l = seclen - TS_PATSECT_SIZE;
while (l >= TS_PATPROG_SIZE) {
i = (d[0] << 8) + d[1];
if (i != 0) {
p = f->u.ts.newpat;
while ((p != NULL) && (p->programnumber != i)) {
p = p->next;
}
warn (LDEB,"eval PAT 2",ETST,i,(long)f->u.ts.newpat,p);
if (p == NULL) {
if ((p = malloc (sizeof(pmt_descr))) == NULL) {
warn (LERR,"PAT malloc failed",ETST,5,3,sizeof(pmt_descr));
return;
}
p->next = f->u.ts.newpat;
p->pmt_version = 0xFF;
p->programnumber = i;
p->pcr_pid = 0;
p->streams = 0;
p->descrlen = 0;
f->u.ts.newpat = p;
}
p->pat_section = sectionnb;
p->pmt_pid = ((d[2] & 0x1F) << 8) + d[3];
}
d += TS_PATPROG_SIZE;
l -= TS_PATPROG_SIZE;
}
if (l != 0) {
warn (LWAR,"PAT data error",ETST,5,2,seclen);
} else {
if (sectionnb == lastsecnb) {
p = f->u.ts.pat;
while (p != NULL) {
warn (LDEB,"eval PAT 3",ETST,p->pcr_pid,p->pat_section,p);
p->pat_section = -1;
p = p->next;
}
release_old_progs (NULL,&f->u.ts.newpat);
p = f->u.ts.newpat;
while (p != NULL) {
remap_new_program (f,p);
p = p->next;
}
release_old_progs (f,&f->u.ts.pat);
}
}
} else {
if (versionnb == f->u.ts.pat_version) {
warn (LWAR,"Same PAT version w/o cni",ETST,5,1,versionnb);
}
}
}
static void eval_cat_section (file_descr *f,
stream_descr *s,
int seclen,
int versionnb,
boolean curni,
int sectionnb,
int lastsecnb)
{
}
static void eval_pmt_section (file_descr *f,
stream_descr *s,
int seclen,
int prognb,
int versionnb,
boolean curni)
{
pmt_descr *p;
int i, epid, esil;
byte *d;
byte styp;
warn (LINF,"eval PMT",ETST,6,seclen,prognb);
p = f->u.ts.newpat;
while ((p != NULL) && (p->programnumber != prognb)) {
p = p->next;
}
if (curni) {
if (p == NULL) {
warn (LWAR,"Program not in PAT",ETST,6,1,prognb);
} else {
p->pmt_version = versionnb;
p->pcr_pid = ((s->u.m.psi_data[TS_PMT_PCRPID] & 0x1F) << 8)
+ s->u.m.psi_data[TS_PMT_PCRPID+1];
p->streams = 0;
p->descrlen = seclen-TS_PMT_PILEN-CRC_SIZE;
memcpy (&p->elemdescr[0],&s->u.m.psi_data[TS_PMT_PILEN],
seclen-TS_PMT_PILEN-CRC_SIZE);
i = ((s->u.m.psi_data[TS_PMT_PILEN] & 0x0F) << 8)
+ s->u.m.psi_data[TS_PMT_PILEN+1];
d = &s->u.m.psi_data[TS_PMTSECTHEAD+i];
i = seclen - i - TS_PMTSECT_SIZE;
while (i >= TS_PMTELEM_SIZE) {
i -= TS_PMTELEM_SIZE;
styp = *d++;
epid = (*d++ & 0x1F) << 8;
epid = epid | *d++;
if ((epid >= TS_PID_LOWEST) && (epid <= TS_PID_HIGHEST)) {
p->stream[p->streams] = epid;
p->streamtype[p->streams] = styp;
p->streams += 1;
if ((ts_file_stream(f,epid) != NULL)
&& (ts_file_stream(f,epid)->streamdata == sd_data)
&& (ts_file_stream(f,epid)->u.d.mapstream == ts_file_stream(f,0))) {
ts_file_stream(f,epid)->u.d.mapstream = s;
warn (LIMP,"PMT stream caught",ETST,6,5,epid);
}
esil = (*d++ & 0x0F) << 8;
esil = esil | *d++;
d += esil;
i -= esil;
} else {
warn (LWAR,"PMT data error",ETST,6,3,epid);
i = -1;
}
}
if (i != 0) {
warn (LWAR,"PMT data error",ETST,6,2,i);
p->streams = 0;
} else {
remap_new_program (f,p);
release_old_progs (f,&f->u.ts.pat);
}
}
} else {
if ((p != NULL) && (versionnb == p->pmt_version)) {
warn (LWAR,"PMT next same version",ETST,6,4,versionnb);
}
}
}
/* Extract a partial PSI section from a TS packet.
* If complete, process its contents (via eval_*_section)
* Precondition: f!=NULL
* Return: TRUE if something was processed, FALSE if no data/space available
*/
static boolean ts_psi_table_section (file_descr *f,
int pid,
int tableid)
{
stream_descr *s;
int i, b, adf;
int seclen;
boolean complete;
warn (LDEB,"PSI",ETST,4,pid,tableid);
adf = f->data.out;
list_incr (f->data.out,f->data,TS_PACKET_SIZE - paylen);
s = ts_file_stream (f,pid);
if (pusi & TS_UNIT_START) {
i = f->data.ptr[f->data.out];
if (i >= paylen) {
warn (LWAR,"PSI pointer exceed",ETST,4,1,b);
s->u.m.psi_length = 0;
list_incr (f->data.out,f->data,paylen);
return (TRUE);
}
if (s->u.m.psi_length == 0) {
b = i + 1;
complete = FALSE;
} else {
seclen = s->u.m.psi_length + i;
b = 1;
complete = TRUE;
}
} else {
if (s->u.m.psi_length == 0) {
f->total += TS_PACKET_SIZE;
list_incr (f->data.out,f->data,paylen);
return (TRUE);
} else {
b = 0;
complete = FALSE;
}
}
list_incr (f->data.out,f->data,b);
b = paylen - b;
if (s->u.m.psi_length + b > sizeof(s->u.m.psi_data)) {
warn (LWAR,"PSI overflow",ETST,4,2,s->u.m.psi_length + b);
s->u.m.psi_length = 0;
list_incr (f->data.out,f->data,b);
return (TRUE);
}
ts_adaption_field (f,adf,s,s);
while (b > 0) {
i = MAX_DATA_RAWB - f->data.out;
if (i > b) {
i = b;
}
memcpy (&s->u.m.psi_data[s->u.m.psi_length],
&f->data.ptr[f->data.out],i);
list_incr (f->data.out,f->data,i);
s->u.m.psi_length += i;
b -= i;
}
if (complete) {
if (s->u.m.psi_length >= TS_HEADSLEN) {
i = ((s->u.m.psi_data[TS_SECTIONLEN] & 0x0F) << 8)
+ s->u.m.psi_data[TS_SECTIONLEN+1] + TS_HEADSLEN;
} else {
i = 0;
}
if (seclen != i) {
warn (LWAR,"PSI length wrong",ETST,4,i,seclen);
s->u.m.psi_length -= seclen;
memmove (&s->u.m.psi_data[0],&s->u.m.psi_data[seclen],s->u.m.psi_length);
complete = FALSE;
}
}
if (!complete) {
if (s->u.m.psi_length >= TS_HEADSLEN) {
seclen = ((s->u.m.psi_data[TS_SECTIONLEN] & 0x0F) << 8)
+ s->u.m.psi_data[TS_SECTIONLEN+1] + TS_HEADSLEN;
if (s->u.m.psi_length >= seclen) {
complete = TRUE;
}
}
}
while (complete) {
if (tableid < 0) {
if (marker_check (s->u.m.psi_data[TS_SECTIONLEN],0x00,0x40)) {
warn (LWAR,"PSI section syntax ind",ETST,4,5,
s->u.m.psi_data[TS_SECTIONLEN]);
}
} else if (s->u.m.psi_data[TS_TABLE_ID] == tableid) {
if (marker_check (s->u.m.psi_data[TS_SECTIONLEN],0x80,0xC0)) {
warn (LWAR,"PSI section syntax ind",ETST,4,6,
s->u.m.psi_data[TS_SECTIONLEN]);
} else {
unsigned char a;
a = s->u.m.psi_data[TS_VERSIONNB];
if ((i = update_crc_32_block (CRC_INIT_32,
&s->u.m.psi_data[0],seclen)) != 0) {
warn (LWAR,"PSI CRC error",ETST,4,11,i);
} else {
i = (s->u.m.psi_data[TS_TRANSPORTID] << 8)
+ s->u.m.psi_data[TS_TRANSPORTID+1];
switch (tableid) {
case TS_TABLEID_PAT:
if (seclen <= TS_MAX_SECTLEN) {
eval_pat_section (f,s,seclen,i,(a >> 1) & 0x1F,a & 1,
s->u.m.psi_data[TS_SECTIONNB],s->u.m.psi_data[TS_LASTSECNB]);
} else {
warn (LWAR,"PSI data error",ETST,4,8,seclen);
}
break;
case TS_TABLEID_CAT:
if ((i == 0xFFFF)
&& (seclen <= TS_MAX_SECTLEN)) {
eval_cat_section (f,s,seclen,(a >> 1) & 0x1F,a & 1,
s->u.m.psi_data[TS_SECTIONNB],s->u.m.psi_data[TS_LASTSECNB]);
} else {
warn (LWAR,"PSI data error",ETST,4,9,seclen);
}
break;
case TS_TABLEID_PMT:
if ((s->u.m.psi_data[TS_SECTIONNB] == 0)
&& (s->u.m.psi_data[TS_LASTSECNB] == 0)
&& (seclen <= TS_MAX_SECTLEN)
&& (seclen >= TS_PMTSECT_SIZE)) {
eval_pmt_section (f,s,seclen,i,(a >> 1) & 0x1F,a & 1);
} else {
warn (LWAR,"PSI data error",ETST,4,10,seclen);
}
break;
}
}
}
} else {
warn (LWAR,"PSI wrong table id",ETST,4,4,s->u.m.psi_data[TS_TABLE_ID]);
}
complete = FALSE;
s->u.m.psi_length -= seclen;
if (s->u.m.psi_length > 0) {
if (s->u.m.psi_data[seclen] == TS_TABLEID_STUFFING) {
s->u.m.psi_length = 0;
} else {
memmove (&s->u.m.psi_data[0],&s->u.m.psi_data[seclen],
s->u.m.psi_length);
if (s->u.m.psi_length >= TS_HEADSLEN) {
seclen = ((s->u.m.psi_data[TS_SECTIONLEN] & 0x0F) << 8)
+ s->u.m.psi_data[TS_SECTIONLEN+1] + TS_HEADSLEN;
if (s->u.m.psi_length >= seclen) {
complete = TRUE;
}
}
}
}
}
return (TRUE);
}
/* Check for a single tsauto entry, whether a given pes id matches
* For each program in source PAT/PMT check and connect if applicable.
* If none matches, but tsauto entry is sprg=unknown, check that sid.
* Precondition: f!=NULL.
* Return: TRUE, if at least one match, FALSE otherwise.
*/
static boolean split_autostreammatch (file_descr *f,
int pid,
byte sid,
tsauto_descr *a)
{
int i;
boolean match, inpmt;
pmt_descr *pmt;
match = FALSE;
inpmt = FALSE;
pmt = f->u.ts.pat;
while (pmt != NULL) {
i = pmt->streams;
while (--i >= 0) {
if (pmt->stream[i] == pid) {
warn (LINF,"Auto Streamtype",ETST,13,pmt->streamtype[i],pid);
inpmt = TRUE;
if (a == NULL) {
warn (LIMP,"Auto T",ETST,13,sid,pmt->programnumber);
ts_file_stream (f,pid) =
connect_streamprog (f,pmt->programnumber,pid,
-sid,
guess_streamtype(sid,pmt->streamtype[i]),
ts_file_stream (f,pid),
ts_file_stream (f,pmt->pmt_pid),TRUE);
match = TRUE;
i = 0;
} else {
if (a->sprg > 0) {
if (a->sprg == pmt->programnumber) {
if (a->ssid < 0) {
warn (LIMP,"Auto P",ETST,13,sid,a->tprg);
ts_file_stream (f,pid) =
connect_streamprog (f,a->tprg,pid,
-sid,
guess_streamtype(sid,pmt->streamtype[i]),
ts_file_stream (f,pid),
ts_file_stream (f,pmt->pmt_pid),TRUE);
match = TRUE;
i = 0;
} else if (a->ssid == sid) {
warn (LIMP,"Auto S",ETST,13,a->tsid,a->tprg);
ts_file_stream (f,pid) =
connect_streamprog (f,a->tprg,pid,
a->tsid,
guess_streamtype(a->tsid<0?-a->tsid:a->tsid,
pmt->streamtype[i]),
ts_file_stream (f,pid),
ts_file_stream (f,pmt->pmt_pid),TRUE);
match = TRUE;
i = 0;
}
}
}
}
}
}
pmt = pmt->next;
}
if ((!inpmt) /* pid not registered in PAT/PMT -> check for unknown sprg */
&& (a != NULL)
&& (a->sprg == 0)
&& (a->ssid == sid)) {
warn (LIMP,"Auto 0",ETST,9,a->tsid,a->tprg);
ts_file_stream (f,pid) =
connect_streamprog (f,a->tprg,pid,
a->tsid,
guess_streamtype(a->tsid<0?-a->tsid:a->tsid,-1),
ts_file_stream (f,pid),
ts_file_stream (f,0),TRUE);
match = TRUE;
}
return (match);
}
/* For a packet that does not belong to an active stream, check whether
* to open a stream for it automatically.
* Precondition: f!=NULL.
* Return: TRUE, if a stream was opened now, FALSE otherwise.
*/
static boolean split_autostream (file_descr *f,
int pid)
{
pmt_descr *pmt;
boolean r;
tsauto_descr *a;
tsauto_descr **aa;
warn (LDEB,"Auto Stream",ETST,9,0,pid);
r = FALSE;
if (pusi & TS_UNIT_START) {
if ((f->automatic)
|| (f->u.ts.tsauto != NULL)) {
if (paylen >= PES_HDCODE_SIZE) {
int x;
x = f->data.out;
list_incr (x,f->data,TS_PACKET_SIZE - paylen);
if (f->data.ptr[x] == 0x00) {
list_incr (x,f->data,1);
if (f->data.ptr[x] == 0x00) {
list_incr (x,f->data,1);
if (f->data.ptr[x] == 0x01) {
list_incr (x,f->data,1);
pmt = f->u.ts.pat;
while (pmt != NULL) {
if (pmt->pmt_pid == pid) {
warn (LWAR,"Auto PMT PID",ETST,9,r,pid);
return (r);
}
pmt = pmt->next;
}
if (f->automatic) {
split_autostreammatch (f,pid,f->data.ptr[x],NULL);
r = TRUE;
}
aa = &f->u.ts.tsauto;
a = *aa;
while (a != NULL) {
if (split_autostreammatch (f,pid,f->data.ptr[x],a)) {
r = TRUE;
if (a->ssid >= 0) {
*aa = a->next; /* delete single entries when matched */
free (a);
} else {
aa = &((a)->next);
}
} else {
aa = &((a)->next);
}
a = *aa;
}
}
}
}
}
}
}
return (r);
}
/* For a packet that does not belong to an active stream, check whether
* it is categorized to be unparsed SI.
* Precondition: f!=NULL, f->content==ct_transport.
* Return: higher bound of range, if it is unparsed SI, -1 otherwise.
*/
int split_unparsedsi (file_descr *f,
int pid)
{
tssi_descr *tssi;
tssi = f->u.ts.tssi;
while (tssi != NULL) {
warn (LDEB,"Split Chk SI",ETST,12,tssi->pid_low,tssi->pid_high);
if ((pid >= tssi->pid_low)
&& (pid <= tssi->pid_high)) {
warn (LDEB,"Split Chk SI",ETST,12,-1,pid);
return (tssi->pid_high);
}
tssi = tssi->next;
}
warn (LDEB,"Split Chk SI",ETST,12,pid,-1);
return (-1);
}
/* Extract one TS packet of not-to-be-parsed SI.
* Precondition: f!=NULL, pid is unparsed_si,
* list_size(f->data) >= TS_PACKET_SIZE.
* Return: TRUE if something was processed, FALSE if no data/space available
*/
static boolean ts_unparsed_si (file_descr *f)
{
stream_descr *s;
ctrl_buffer *c;
s = ts_file_stream (f,TS_UNPARSED_SI);
if (s != NULL) {
if (!list_full (s->ctrl)) {
c = &s->ctrl.ptr[s->ctrl.in];
if (list_free (s->data) >= (2*TS_PACKET_SIZE-1)) {
if (TS_PACKET_SIZE > list_freeinend (s->data)) {
s->data.in = 0;
}
c->index = s->data.in;
c->length = 0;
while (c->length < TS_PACKET_SIZE) {
int i;
i = MAX_DATA_RAWB - f->data.out;
if (i > (TS_PACKET_SIZE - c->length)) {
i = TS_PACKET_SIZE - c->length;
}
memcpy (&s->data.ptr[s->data.in],&f->data.ptr[f->data.out],i);
list_incr (s->data.in,s->data,i);
list_incr (f->data.out,f->data,i);
c->length += i;
}
f->payload += TS_PACKET_SIZE;
c->sequence = f->sequence++;
c->scramble = 0;
c->msecread = msec_now ();
/* c->msecpush not set, because there is no scr/pcr or similar available */
/*
c->pcr.valid = FALSE;
c->opcr.valid = FALSE;
*/
list_incr (s->ctrl.in,s->ctrl,1);
} else {
return (FALSE);
}
} else {
return (FALSE);
}
} else {
list_incr (f->data.out,f->data,TS_PACKET_SIZE);
}
f->total += TS_PACKET_SIZE;
return (TRUE);
}
/* Check an otherwise unused stream for PCR.
* Precondition: f!=NULL
*/
void split_checkpcrpid (file_descr *f,
int pid)
{
pmt_descr *pmt;
pmt = f->u.ts.pat;
while (pmt != NULL) {
if (pmt->pcr_pid == pid) {
ts_adaption_field (f,f->data.out,
ts_file_stream (f,pmt->pmt_pid),ts_file_stream (f,pmt->pmt_pid));
return;
/* only needed, if any of the streams is in use, but then the pcr
* evaluation might come too late. therefor eval always.
*/
}
pmt = pmt->next;
}
}
/* Split data from a TS stream.
* Precondition: f!=NULL
* Return: TRUE, if something was processed, FALSE if not enough data available
*/
boolean split_ts (file_descr *f)
{
int l, pid;
warn (LDEB,"Split TS",ETST,0,0,f);
if (ts_skip_to_syncbyte (f)) {
l = list_size (f->data);
if (l >= TS_PACKET_SIZE) {
pid = ts_packet_headinfo (&f->data);
if ((pid >= TS_PID_LOWEST) && (pid <= TS_PID_HIGHEST)) {
if (ts_file_stream (f,pid) != NULL) {
if (ts_file_stream (f,pid)->streamdata == sd_data) {
return (ts_data_stream (f,pid));
} else {
return (ts_psi_table_section (f,pid,TS_TABLEID_PMT));
}
} else {
if (split_autostream (f,pid)) {
return (ts_data_stream (f,pid));
}
if (split_unparsedsi (f,pid) >= 0) {
warn (LDEB,"Unparsed SI",ETST,0,2,pid);
return (ts_unparsed_si (f));
}
split_checkpcrpid (f,pid);
warn (LDEB,"Data Packet (ignored)",ETST,0,1,pid);
f->total += TS_PACKET_SIZE;
list_incr (f->data.out,f->data,TS_PACKET_SIZE);
return (TRUE);
}
} else if (pid == TS_PID_PAT) {
return (ts_psi_table_section (f,TS_PID_PAT,TS_TABLEID_PAT));
/*
} else if (pid == TS_PID_CAT) {
return (ts_psi_table_section (f,TS_PID_CAT,TS_TABLEID_CAT));
*/
} else if (pid == TS_PID_NULL) {
f->total += TS_PACKET_SIZE;
list_incr (f->data.out,f->data,TS_PACKET_SIZE);
return (TRUE);
} else if (split_unparsedsi (f,pid) >= 0) {
warn (LDEB,"Unparsed SI",ETST,0,3,pid);
return (ts_unparsed_si (f));
} else {
/* don't skip 188 here, because it might be an asynchronity */
f->skipped += 1;
f->total += 1;
list_incr (f->data.out,f->data,1);
return (TRUE);
}
}
}
return (FALSE);
}
LinuxTV legacy CVS <linuxtv.org/cvs>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to splitts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / multiplexer