ctools.c

DVBstream is based on the ts-rtp package available at http://www.linuxtv.org. It broadcasts a (subs

	return neof;
}

/*

   Transport Stream

*/

void init_ts(ts_packet *p){
	p->pid[0] = 0;
	p->pid[1] = 0;
	p->flags = 0;
	p->count = 0;
	p->adapt_length = 0;
	p->adapt_flags = 0;
	p->splice_count = 0;
	p->priv_dat_len = 0;
	p->priv_dat = NULL;
	p->adapt_ext_len = 0;
	p->adapt_eflags = 0;
	p->rest = 0;
	p->stuffing = 0;
}

void kill_ts(ts_packet *p){
	if (p->priv_dat)
		free(p->priv_dat);
	init_ts(p);
}



unsigned short pid_ts(ts_packet *p)
{
  return get_pid(p->pid);
}

int cwrite_ts(u8 *buf, ts_packet *p, long length){
	long count,i;
	u8 sync,dummy;

	sync = 0x47;
	memcpy(buf,&sync,1);
	count = 1;
	memcpy(buf+count,p->pid,2);
	count += 2;
	memcpy(buf+count,&p->flags,1);
	count++;

	 
	if (! (p->flags & ADAPT_FIELD) && (p->flags & PAYLOAD)){
		memcpy(buf+count,p->data,184);
		count += 184;
	} else {
		memcpy(buf+count,&p->adapt_length,1);
		count++;
		memcpy(buf+count,&p->adapt_flags,1);
		count++;

		if ( p->adapt_flags & PCR_FLAG ){
			memcpy(buf+count, p->pcr,6);
			count += 6;
		}
		if ( p->adapt_flags & OPCR_FLAG ){
			memcpy(buf+count, p->opcr,6);
			count += 6;
		}
		if ( p->adapt_flags & SPLICE_FLAG ){
			memcpy(buf+count, &p->splice_count,1);
			count++;
		}
		if( p->adapt_flags & TRANS_PRIV){
			memcpy(buf+count,&p->priv_dat_len,1);
			count++;
			memcpy(buf+count,p->priv_dat,p->priv_dat_len);
			count += p->priv_dat_len;
		}
			
		if( p->adapt_flags & ADAP_EXT_FLAG){
			memcpy(buf+count,&p->adapt_ext_len,1);
			count++;
			memcpy(buf+count,&p->adapt_eflags,1);
			count++;
		
			if( p->adapt_eflags & LTW_FLAG){
				memcpy(buf+count,p->ltw,2);
				count += 2;
			}
			if( p->adapt_eflags & PIECE_RATE){
				memcpy(buf+count,p->piece_rate,3);
				count += 3;
			}
			if( p->adapt_eflags & SEAM_SPLICE){
				memcpy(buf+count,p->dts,5);
				count += 5;
			}
		}
		dummy = 0xFF;
		for(i=0; i < p->stuffing ; i++){
			memcpy(buf+count,&dummy,1);
			count++;
		}
		if (p->flags & PAYLOAD){
			memcpy(buf+count,p->data,p->rest);
			count += p->rest;
		}
	} 


	return count;
}

void write_ts(int fd, ts_packet *p){
	long length;
	u8 buf[TS_SIZE];

	length = cwrite_ts(buf,p,TS_SIZE);
	write(fd,buf,length);
}

int read_ts (int f, ts_packet *p){
	u8 sync;
	int found=0;
	uint64_t po,q;
	int neof = 1;

	sync=0;
	while (neof > 0 && !found) {
		neof = read(f,&sync,1);
		if (sync == 0x47) 
			found = 1;
	}
	neof = read(f,p->pid,2);
	neof = read(f,&p->flags,1);
	p->count = p->flags & COUNT_MASK;
	 
	if (!(p->flags & ADAPT_FIELD) && (p->flags & PAYLOAD)){
		//no adapt. field only payload
		neof = read(f,p->data,184);
		p->rest = 184;
		return neof;
	} 

	if ( p->flags & ADAPT_FIELD ) {
		// adaption field
		neof = read(f,&p->adapt_length,1);
		po = lseek(f,0,SEEK_CUR);
		neof = read(f,&p->adapt_flags,1);

		if ( p->adapt_flags & PCR_FLAG )
			neof = read(f, p->pcr,6);

		if ( p->adapt_flags & OPCR_FLAG )
			neof = read(f, p->opcr,6);

		if ( p->adapt_flags & SPLICE_FLAG )
			neof = read(f, &p->splice_count,1);

		if( p->adapt_flags & TRANS_PRIV){
			neof = read(f,&p->priv_dat_len,1);
			p->priv_dat = (u8 *) malloc(p->priv_dat_len);
			neof = read(f,p->priv_dat,p->priv_dat_len);
		}
			
		if( p->adapt_flags & ADAP_EXT_FLAG){
			neof = read(f,&p->adapt_ext_len,1);
			neof = read(f,&p->adapt_eflags,1);
			if( p->adapt_eflags & LTW_FLAG)
				neof = read(f,p->ltw,2);
			
			if( p->adapt_eflags & PIECE_RATE)
				neof = read(f,p->piece_rate,3);
			
			if( p->adapt_eflags & SEAM_SPLICE)
				neof = read(f,p->dts,5);
		}
		q = lseek(f,0,SEEK_CUR);
		p->stuffing = p->adapt_length -(q-po);
		p->rest = 183-p->adapt_length;
		lseek(f,q+p->stuffing,SEEK_SET);
		if (p->flags & PAYLOAD) // payload
			neof = read(f,p->data,p->rest);
		else 
			lseek(f,q+p->rest,SEEK_SET);
	}
	return neof;
}

void cread_ts (char *buf, ts_packet *p, long length){
	u8 sync;
	int found=0;
	uint64_t po,q;
	long count=0;
	
	sync=0;
	while (count < length  && !found) {
		sync=buf[count];
		count++;
		if (sync == 0x47) 
			found = 1;
	}
	memcpy(p->pid,buf+count,2);
	count += 2;
	p->flags = buf[count];
	count++;
	p->count = p->flags & COUNT_MASK;
	 
	if (!(p->flags & ADAPT_FIELD) && (p->flags & PAYLOAD)){
		//no adapt. field only payload
		memcpy(p->data,buf+count,184);
		p->rest = 184;
		return;
	} 

	if ( p->flags & ADAPT_FIELD ) {
		// adaption field
		p->adapt_length = buf[count];
		count++;
		po = count;
		memcpy(&p->adapt_flags,buf+count,1);
		count++;

		if ( p->adapt_flags & PCR_FLAG ){
			memcpy( p->pcr,buf+count,6);
			count += 6;
		}
		if ( p->adapt_flags & OPCR_FLAG ){
			memcpy( p->opcr,buf+count,6);
			count += 6;
		}
		if ( p->adapt_flags & SPLICE_FLAG ){
			memcpy( &p->splice_count,buf+count,1);
			count++;
		}
		if( p->adapt_flags & TRANS_PRIV){
			memcpy(&p->priv_dat_len,buf+count,1);
			count++;
			p->priv_dat = (u8 *) malloc(p->priv_dat_len);
			memcpy(p->priv_dat,buf+count,p->priv_dat_len);
			count += p->priv_dat_len;
		}
			
		if( p->adapt_flags & ADAP_EXT_FLAG){
			memcpy(&p->adapt_ext_len,buf+count,1);
			count++;
			memcpy(&p->adapt_eflags,buf+count,1);
			count++;
			if( p->adapt_eflags & LTW_FLAG){
				memcpy(p->ltw,buf+count,2);
				count += 2;
			}
			if( p->adapt_eflags & PIECE_RATE){
				memcpy(p->piece_rate,buf+count,3);
				count += 3;
			}
			if( p->adapt_eflags & SEAM_SPLICE){
				memcpy(p->dts,buf+count,5);
				count += 5;
			}
		}
		q = count;
		p->stuffing = p->adapt_length -(q-po);
		p->rest = 183-p->adapt_length;
		count = q+p->stuffing;
		if (p->flags & PAYLOAD){ // payload
			memcpy(p->data,buf+count,p->rest);
			count += p->rest;
		} else 
			count = q+p->rest;
	}
}


/*

   Program Stream

*/


void init_ps(ps_packet *p)
{
	p->stuff_length=0xF8;
	p->data = NULL;
	p->sheader_length = 0;
	p->audio_bound = 0;
	p->video_bound = 0;
	p->npes = 0;
	p->mpeg = 2;
}

void kill_ps(ps_packet *p)
{
	if (p->data)
		free(p->data);
	init_ps(p);
}

void setlength_ps(ps_packet *p)
{
	short *ll;
	ll = (short *) p->sheader_llength;
	if (p->mpeg == 2)
		p->sheader_length = ntohs(*ll) - 6;
	else 
		p->sheader_length = ntohs(*ll);
}	

static void setl_ps(ps_packet *p)
{
	setlength_ps(p);
	p->data = (u8 *) malloc(p->sheader_length);
}

int mux_ps(ps_packet *p)
{
	u32 mux = 0;
	u8 *i = (u8 *)&mux;

	i[1] = p->mux_rate[0];
	i[2] = p->mux_rate[1];
	i[3] = p->mux_rate[2];
	mux = ntohl(mux);
	mux = (mux >>2);
	return mux;
}

int rate_ps(ps_packet *p)
{
	u32 rate=0;
	u8 *i= (u8 *) &rate;

	i[1] = p->rate_bound[0] & 0x7F;
	i[2] = p->rate_bound[1];
	i[3] = p->rate_bound[2];
	
	rate = ntohl(rate);
	rate = (rate >> 1);
	return rate;
}


u32 scr_base_ps(ps_packet *p) // only 32 bit!!
{
	u32 base = 0;
	u8 *buf = (u8 *)&base;
	
	buf[0] |= (long int)((p->scr[0] & 0x18) << 3);
	buf[0] |= (long int)((p->scr[0] & 0x03) << 4);
	buf[0] |= (long int)((p->scr[1] & 0xF0) >> 4);
		 
	buf[1] |= (long int)((p->scr[1] & 0x0F) << 4);
	buf[1] |= (long int)((p->scr[2] & 0xF0) >> 4);

	buf[2] |= (long int)((p->scr[2] & 0x08) << 4);
	buf[2] |= (long int)((p->scr[2] & 0x03) << 5);
	buf[2] |= (long int)((p->scr[3] & 0xF8) >> 3);

	buf[3] |= (long int)((p->scr[3] & 0x07) << 5);
	buf[3] |= (long int)((p->scr[4] & 0xF8) >> 3);

	base = ntohl(base);
	return base;
}

u16 scr_ext_ps(ps_packet *p)
{
	short ext = 0;

	ext = (short)(p->scr[5] >> 1);
	ext += (short) (p->scr[4] &  0x03) * 128;

	return ext;
}

int cwrite_ps(u8 *buf, ps_packet *p, long length)
{
	long count,i;
	u8 headr1[4] = {0x00, 0x00, 0x01, 0xBA };
	u8 headr2[4] = {0x00, 0x00, 0x01, 0xBB };
	u8 buffy = 0xFF;

	
	memcpy(buf,headr1,4);
	count = 4;
	if (p->mpeg == 2){
		memcpy(buf+count,p->scr,6);
		count += 6;
		memcpy(buf+count,p->mux_rate,3);
		count += 3;
		memcpy(buf+count,&p->stuff_length,1);
		count++;
		for(i=0; i< (p->stuff_length & 3); i++){
			memcpy(buf+count,&buffy,1);
			count++;
		}
	} else {
		memcpy(buf+count,p->scr,5);
		count += 5;
		memcpy(buf+count,p->mux_rate,3);
		count += 3;
	}
	if (p->sheader_length){
		memcpy(buf+count,headr2,4);
		count += 4;
		memcpy(buf+count,p->sheader_llength,2);
		count += 2;
		if ( p->mpeg == 2){
			memcpy(buf+count,p->rate_bound,3);
			count += 3;
			memcpy(buf+count,&p->audio_bound,1);
			count++;
			memcpy(buf+count,&p->video_bound,1);
			count++;
			memcpy(buf+count,&p->reserved,1);
			count++;
		}
		memcpy(buf+count,p->data,p->sheader_length);
		count += p->sheader_length;
	}

	return count;
}

void write_ps(int fd, ps_packet *p){
	long length;
	u8 buf[PS_MAX];

	length = cwrite_ps(buf,p,PS_MAX);
	write(fd,buf,length);
}

int read_ps (int f, ps_packet *p){
	u8 headr[4];
	pes_packet pes;
	int i,done;
	int found=0;
	uint64_t po = 0;
	uint64_t q = 0;
	long count = 0;
	int neof = 1;

	po = lseek(f,0,SEEK_CUR);
	while (neof > 0 && !found && count < MAX_SEARCH) {
		neof = read(f,&headr,4);
		if (headr[0] == 0x00 && headr[1] == 0x00 && headr[2] == 0x01){
			if ( headr[3] == 0xBA ) 
				found = 1;
			else 
				if ( headr[3] == 0xB9 ) break;
				else lseek(f,po+1,SEEK_SET);
		}
		count++;
	}
	
	if (found){
		neof = read(f,p->scr,6);
		if (p->scr[0] & 0x40)
			p->mpeg = 2;
		else
			p->mpeg = 1;

		if (p->mpeg == 2){
			neof = read(f,p->mux_rate,3);
			neof = read(f,&p->stuff_length,1);
			po = lseek(f,0,SEEK_CUR);
			lseek(f,po+(p->stuff_length & 3),SEEK_SET);
		} else {
			p->mux_rate[0] = p->scr[5]; //mpeg1 scr is only 5 bytes
			neof = read(f,p->mux_rate+1,2);
		}
			
		po = lseek(f,0,SEEK_CUR);
		neof = read(f,headr,4);
		if (headr[0] == 0x00 && headr[1] == 0x00 && 
		    headr[2] == 0x01 && headr[3] == 0xBB ) {
			neof = read(f,p->sheader_llength,2);
			setl_ps(p);
			if (p->mpeg == 2){
				neof = read(f,p->rate_bound,3);
				neof = read(f,&p->audio_bound,1);
				neof = read(f,&p->video_bound,1);
				neof = read(f,&p->reserved,1);
			}
			neof = read(f,p->data,p->sheader_length);
		} else {
			lseek(f,po,SEEK_SET);
			p->sheader_length = 0;
		}

		i = 0;
		done = 0;
		q = lseek(f,0,SEEK_CUR);
		do {
			po = lseek(f,0,SEEK_CUR);
			neof = read(f,headr,4);
			lseek(f,po,SEEK_SET);
			if ( headr[0] == 0x00 && headr[1] == 0x00 
			     && headr[2] == 0x01 && headr[3] != 0xBA){
				init_pes(&pes);
				neof = read_pes(f,&pes);
			        i++;
			} else done = 1;
			kill_pes(&pes);
		} while ( neof > 0 && !done);
		p->npes = i;
		lseek(f,q,SEEK_SET);
	} 
	return neof;
}

void cread_ps (char *buf, ps_packet *p, long length){
	u8 *headr;
	pes_packet pes;
	int i,done;
	int found=0;
	uint64_t po = 0;
	uint64_t q = 0;
	long count = 0;
	long c = 0;
	
	po = c;
	while ( count < length && !found && count < MAX_SEARCH) {
		headr = (u8 *)buf+c;
		c += 4;
		if (headr[0] == 0x00 && headr[1] == 0x00 && headr[2] == 0x01){
			if ( headr[3] == 0xBA ) 
				found = 1;
			else 
				if ( headr[3] == 0xB9 ) break;
				else c = po+1;
		}
		count++;
	}
	
	if (found){
		memcpy(p->scr,buf+c,6);
		c += 6;
		if (p->scr[0] & 0x40)
			p->mpeg = 2;
		else
			p->mpeg = 1;

		if (p->mpeg == 2){
			memcpy(p->mux_rate,buf+c,3);
			c += 3;
			memcpy(&p->stuff_length,buf+c,1);
			c++;
			po = c;
			c = po+(p->stuff_length & 3);
		} else {
			p->mux_rate[0] = p->scr[5]; //mpeg1 scr is only 5 bytes
			memcpy(p->mux_rate+1,buf+c,2);
			c += 2;
		}
			
		po = c;
		headr = (u8 *)buf+c;
		c += 4;
		if (headr[0] == 0x00 && headr[1] == 0x00 && 
		    headr[2] == 0x01 && headr[3] == 0xBB ) {
			memcpy(p->sheader_llength,buf+c,2);
			c += 2;
			setl_ps(p);
			if (p->mpeg == 2){
				memcpy(p->rate_bound,buf+c,3);
				c += 3;
				memcpy(&p->audio_bound,buf+c,1);
				c++;
				memcpy(&p->video_bound,buf+c,1);
				c++;
				memcpy(&p->reserved,buf+c,1);
				c++;
			}
			memcpy(p->data,buf+c,p->sheader_length);
			c += p->sheader_length;
		} else {
			c = po;
			p->sheader_length = 0;
		}

		i = 0;
		done = 0;
		q = c;
		do {
			headr = (u8 *)buf+c;
			if ( headr[0] == 0x00 && headr[1] == 0x00 
			     && headr[2] == 0x01 && headr[3] != 0xBA){
				init_pes(&pes);