margi2/dvb_demux.c - diff

Return to dvb_demux.c CVS log

Up to [DVB] / margi2

Diff for /margi2/dvb_demux.c between versions 1.7 and 1.8

version 1.7, 2001/06/01 16:43:07	version 1.8, 2001/10/15 12:40:28
Line 28	Line 28

#include "dvb_demux.h"	#include "dvb_demux.h"

/* allocate no buffers, firmware buffers good enough	#ifdef MODULE
(and somewhere there is a memory leak ...) */	MODULE_DESCRIPTION("");
	MODULE_AUTHOR("Ralph Metzler, Marcus Metzler");
	#ifdef MODULE_LICENSE
	MODULE_LICENSE("GPL");
	#endif
	#endif

#define NOBUFS	#define NOBUFS

LIST_HEAD(dmx_muxs);	LIST_HEAD(dmx_muxs);
Line 45 int dmx_register_demux(dmx_demux_t *demu	Line 51 int dmx_register_demux(dmx_demux_t *demu
if (!strcmp(DMX_DIR_ENTRY(pos)->id, demux->id))	if (!strcmp(DMX_DIR_ENTRY(pos)->id, demux->id))
return -EEXIST;	return -EEXIST;
}	}

demux->users=0;	demux->users=0;
list_add(&(demux->reg_list), head);	list_add(&(demux->reg_list), head);
MOD_INC_USE_COUNT;	MOD_INC_USE_COUNT;
Line 60 int dmx_unregister_demux(dmx_demux_t* de	Line 65 int dmx_unregister_demux(dmx_demux_t* de
{	{
if (DMX_DIR_ENTRY(pos)==demux)	if (DMX_DIR_ENTRY(pos)==demux)
{	{
if (demux->users!=0)	if (demux->users>0)
return -EINVAL;	return -EINVAL;
list_del(pos);	list_del(pos);
MOD_DEC_USE_COUNT;	MOD_DEC_USE_COUNT;
Line 388 DvbDmxSWFilterPackets(dvb_demux_t *dvbdm	Line 393 DvbDmxSWFilterPackets(dvb_demux_t *dvbdm
{	{
dvb_demux_feed_t *dvbdmxfeed;	dvb_demux_feed_t *dvbdmxfeed;

	if ((dvbdmxfeed=dvbdmx->pid2feed[0x2000]))
	dvbdmxfeed->cb.ts((u8 )buf, count188, 0, 0,
	&dvbdmxfeed->feed.ts, DMX_OK);
for (; count>0; count--, buf+=188) {	for (; count>0; count--, buf+=188) {
if ((dvbdmxfeed=dvbdmx->pid2feed[ts_pid(buf)]))	if ((dvbdmxfeed=dvbdmx->pid2feed[ts_pid(buf)]))
DvbDmxSWFilterPacketType(dvbdmxfeed, buf);	DvbDmxSWFilterPacketType(dvbdmxfeed, buf);
//if ((dvbdmxfeed=dvbdmx->pid2feed[0x1fff]))
// DvbDmxSWFilterPacketType(dvbdmxfeed, buf);
}	}
}	}

Line 444 DvbDmxFilterAlloc(dvb_demux_t *dvbdmx)	Line 450 DvbDmxFilterAlloc(dvb_demux_t *dvbdmx)
for (i=0; i<dvbdmx->filternum; i++)	for (i=0; i<dvbdmx->filternum; i++)
if (dvbdmx->filter[i].state==DMX_STATE_FREE)	if (dvbdmx->filter[i].state==DMX_STATE_FREE)
break;	break;
if (i==dvbdmx->filternum)	if (i==dvbdmx->filternum)
return 0;	return 0;
dvbdmx->filter[i].state=DMX_STATE_ALLOCATED;	dvbdmx->filter[i].state=DMX_STATE_ALLOCATED;
return &dvbdmx->filter[i];	return &dvbdmx->filter[i];
Line 475 dmx_ts_feed_set_type(dmx_ts_feed_t *feed	Line 481 dmx_ts_feed_set_type(dmx_ts_feed_t *feed
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;

	down_interruptible(&dvbdmx->mutex);
dvbdmxfeed->ts_type=type;	dvbdmxfeed->ts_type=type;
dvbdmxfeed->pes_type=pes_type;	dvbdmxfeed->pes_type=pes_type;

if (dvbdmxfeed->ts_type & TS_DECODER) {	if (dvbdmxfeed->ts_type & TS_DECODER) {
if (pes_type >= DMX_TS_PES_OTHER)	if (pes_type >= DMX_TS_PES_OTHER) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
if (dvbdmx->pesfilter[pes_type] &&	if (dvbdmx->pesfilter[pes_type] &&
(dvbdmx->pesfilter[pes_type]!=dvbdmxfeed))	(dvbdmx->pesfilter[pes_type]!=dvbdmxfeed)) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
dvbdmx->pesfilter[pes_type]=dvbdmxfeed;	dvbdmx->pesfilter[pes_type]=dvbdmxfeed;
dvbdmx->pids[pes_type]=dvbdmxfeed->pid;	dvbdmx->pids[pes_type]=dvbdmxfeed->pid;
}	}
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

static int	static int
dmx_pid_set(__u16 pid, dvb_demux_feed_t *dvbdmxfeed)	dmx_pid_set(u16 pid, dvb_demux_feed_t *dvbdmxfeed)
{	{
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
dvb_demux_feed_t **pid2feed=dvbdmx->pid2feed;	dvb_demux_feed_t **pid2feed=dvbdmx->pid2feed;

if (pid>0x1fff)	if (pid>DMX_MAX_PID)
return -EINVAL;	return -EINVAL;
if (dvbdmxfeed->pid!=0xffff) {	if (dvbdmxfeed->pid!=0xffff) {
if (dvbdmxfeed->pid<=0x1fff)	if (dvbdmxfeed->pid<=DMX_MAX_PID)
pid2feed[dvbdmxfeed->pid]=0;	pid2feed[dvbdmxfeed->pid]=0;
dvbdmxfeed->pid=0xffff;	dvbdmxfeed->pid=0xffff;
}	}
if (pid2feed[pid])	if (pid2feed[pid]) {
return -EBUSY;	return -EBUSY;
	}
pid2feed[pid]=dvbdmxfeed;	pid2feed[pid]=dvbdmxfeed;
dvbdmxfeed->pid=pid;	dvbdmxfeed->pid=pid;
return 0;	return 0;
Line 513 dmx_pid_set(__u16 pid, dvb_demux_feed_t	Line 526 dmx_pid_set(__u16 pid, dvb_demux_feed_t

static int	static int
dmx_ts_feed_set(struct dmx_ts_feed_s* feed,	dmx_ts_feed_set(struct dmx_ts_feed_s* feed,
__u16 pid,	u16 pid,
size_t callback_length,	size_t callback_length,
size_t circular_buffer_size,	size_t circular_buffer_size,
int descramble,	int descramble,
Line 521 dmx_ts_feed_set(struct dmx_ts_feed_s* fe	Line 534 dmx_ts_feed_set(struct dmx_ts_feed_s* fe
)	)
{	{
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;
#if 0
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;

if (pid>0x1fff)
return -EINVAL;
if (dvbdmxfeed->pid!=0xffff) {
if (dvbdmxfeed->pid<=0x1fff)
dvbdmx->pid2feed[dvbdmxfeed->pid]=0;
dvbdmxfeed->pid=0xffff;
}
if (dvbdmx->pid2feed[pid])
return -EBUSY;

dvbdmx->pid2feed[pid]=dvbdmxfeed;
dvbdmxfeed->pid=pid;
#else
int ret;	int ret;

	down_interruptible(&dvbdmx->mutex);
ret=dmx_pid_set(pid, dvbdmxfeed);	ret=dmx_pid_set(pid, dvbdmxfeed);
if (ret<0)	if (ret<0) {
return ret;	up(&dvbdmx->mutex);
#endif	return ret;
	}
dvbdmxfeed->buffer_size=circular_buffer_size;	dvbdmxfeed->buffer_size=circular_buffer_size;
dvbdmxfeed->descramble=descramble;	dvbdmxfeed->descramble=descramble;
dvbdmxfeed->timeout=timeout;	dvbdmxfeed->timeout=timeout;
dvbdmxfeed->cb_length=callback_length;	dvbdmxfeed->cb_length=callback_length;
dvbdmxfeed->ts_type=TS_PACKET;	dvbdmxfeed->ts_type=TS_PACKET;

if (dvbdmxfeed->descramble)	if (dvbdmxfeed->descramble) {
	up(&dvbdmx->mutex);
return -ENOSYS;	return -ENOSYS;
	}

if (dvbdmxfeed->buffer_size) {	if (dvbdmxfeed->buffer_size) {
#ifdef NOBUFS	#ifdef NOBUFS
dvbdmxfeed->buffer=0;	dvbdmxfeed->buffer=0;
#else	#else
dvbdmxfeed->buffer=vmalloc(dvbdmxfeed->buffer_size);	dvbdmxfeed->buffer=vmalloc(dvbdmxfeed->buffer_size);
if (!dvbdmxfeed->buffer)	if (!dvbdmxfeed->buffer) {
	up(&dvbdmx->mutex);
return -ENOMEM;	return -ENOMEM;
	}
#endif	#endif
}	}
dvbdmxfeed->state=DMX_STATE_READY;	dvbdmxfeed->state=DMX_STATE_READY;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 573 dmx_ts_feed_start_filtering(struct dmx_t	Line 577 dmx_ts_feed_start_filtering(struct dmx_t
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
int ret;	int ret;

if (dvbdmxfeed->state!=DMX_STATE_READY)	down_interruptible(&dvbdmx->mutex);
	if (dvbdmxfeed->state!=DMX_STATE_READY \|\|
	dvbdmxfeed->type!=DMX_TYPE_TS) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
if (dvbdmxfeed->type!=DMX_TYPE_TS)	}
return -EINVAL;	if (!dvbdmx->start_feed) {
	up(&dvbdmx->mutex);
if (!dvbdmx->start_feed)
return -1;	return -1;
	}
ret=dvbdmx->start_feed(dvbdmxfeed);	ret=dvbdmx->start_feed(dvbdmxfeed);
if (ret<0)	if (ret<0) {
return ret;	up(&dvbdmx->mutex);
	return ret;
	}
feed->is_filtering=1;	feed->is_filtering=1;
dvbdmxfeed->state=DMX_STATE_GO;	dvbdmxfeed->state=DMX_STATE_GO;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 595 dmx_ts_feed_stop_filtering(struct dmx_ts	Line 605 dmx_ts_feed_stop_filtering(struct dmx_ts
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
int ret;	int ret;

//printk ("function : %s\n", __FUNCTION__);	down_interruptible(&dvbdmx->mutex);
if (dvbdmxfeed->state<DMX_STATE_GO)	if (dvbdmxfeed->state<DMX_STATE_GO) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
if (!dvbdmx->stop_feed)	}
	if (!dvbdmx->stop_feed) {
	up(&dvbdmx->mutex);
return -1;	return -1;
	}
ret=dvbdmx->stop_feed(dvbdmxfeed);	ret=dvbdmx->stop_feed(dvbdmxfeed);
feed->is_filtering=0;	feed->is_filtering=0;
dvbdmxfeed->state=DMX_STATE_ALLOCATED;	dvbdmxfeed->state=DMX_STATE_ALLOCATED;

	up(&dvbdmx->mutex);
return ret;	return ret;
}	}

Line 614 static int dvbdmx_allocate_ts_feed(dmx_d	Line 629 static int dvbdmx_allocate_ts_feed(dmx_d
dvb_demux_t dvbdmx=(dvb_demux_t ) demux;	dvb_demux_t dvbdmx=(dvb_demux_t ) demux;
dvb_demux_feed_t *dvbdmxfeed;	dvb_demux_feed_t *dvbdmxfeed;

if (!(dvbdmxfeed=DvbDmxFeedAlloc(dvbdmx)))	down_interruptible(&dvbdmx->mutex);
	if (!(dvbdmxfeed=DvbDmxFeedAlloc(dvbdmx))) {
	up(&dvbdmx->mutex);
return -EBUSY;	return -EBUSY;
	}
dvbdmxfeed->type=DMX_TYPE_TS;	dvbdmxfeed->type=DMX_TYPE_TS;
dvbdmxfeed->cb.ts=callback;	dvbdmxfeed->cb.ts=callback;
dvbdmxfeed->demux=dvbdmx;	dvbdmxfeed->demux=dvbdmx;
dvbdmxfeed->pid=0xffff;	dvbdmxfeed->pid=0xffff;
dvbdmxfeed->peslen=0xfffa;	dvbdmxfeed->peslen=0xfffa;
	dvbdmxfeed->buffer=0;

(*feed)=&dvbdmxfeed->feed.ts;	(*feed)=&dvbdmxfeed->feed.ts;
(*feed)->is_filtering=0;	(*feed)->is_filtering=0;
Line 635 static int dvbdmx_allocate_ts_feed(dmx_d	Line 653 static int dvbdmx_allocate_ts_feed(dmx_d

if (!(dvbdmxfeed->filter=DvbDmxFilterAlloc(dvbdmx))) {	if (!(dvbdmxfeed->filter=DvbDmxFilterAlloc(dvbdmx))) {
dvbdmxfeed->state=DMX_STATE_FREE;	dvbdmxfeed->state=DMX_STATE_FREE;
	up(&dvbdmx->mutex);
return -EBUSY;	return -EBUSY;
}	}

Line 642 static int dvbdmx_allocate_ts_feed(dmx_d	Line 661 static int dvbdmx_allocate_ts_feed(dmx_d
dvbdmxfeed->filter->feed=dvbdmxfeed;	dvbdmxfeed->filter->feed=dvbdmxfeed;
dvbdmxfeed->filter->state=DMX_STATE_READY;	dvbdmxfeed->filter->state=DMX_STATE_READY;

	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

static int dvbdmx_release_ts_feed(dmx_demux_t demux, dmx_ts_feed_t feed)	static int dvbdmx_release_ts_feed(dmx_demux_t demux, dmx_ts_feed_t feed)
{	{
	dvb_demux_t dvbdmx=(dvb_demux_t ) demux;
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;

if (dvbdmxfeed->state==DMX_STATE_FREE)	down_interruptible(&dvbdmx->mutex);
	if (dvbdmxfeed->state==DMX_STATE_FREE) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
	#ifndef NOBUFS
if (dvbdmxfeed->buffer) {	if (dvbdmxfeed->buffer) {
vfree(dvbdmxfeed->buffer);	vfree(dvbdmxfeed->buffer);
dvbdmxfeed->buffer=0;	dvbdmxfeed->buffer=0;
}	}
	#endif
dvbdmxfeed->state=DMX_STATE_FREE;	dvbdmxfeed->state=DMX_STATE_FREE;
dvbdmxfeed->filter->state=DMX_STATE_FREE;	dvbdmxfeed->filter->state=DMX_STATE_FREE;
if (dvbdmxfeed->pid!=0xffff) {	if (dvbdmxfeed->pid!=0xffff) {
if (dvbdmxfeed->pid<=0x1fff)	if (dvbdmxfeed->pid<=DMX_MAX_PID)
dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;	dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;
dvbdmxfeed->pid=0xffff;	dvbdmxfeed->pid=0xffff;
}	}

	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 673 static int dvbdmx_release_ts_feed(dmx_de	Line 700 static int dvbdmx_release_ts_feed(dmx_de
/*	/*
static int	static int
dmx_pes_feed_set(struct dmx_pes_feed_s* feed,	dmx_pes_feed_set(struct dmx_pes_feed_s* feed,
__u16 pid,	u16 pid,
size_t circular_buffer_size,	size_t circular_buffer_size,
int descramble,	int descramble,
struct timespec timeout)	struct timespec timeout)
Line 720 dmx_section_feed_allocate_filter(struct	Line 747 dmx_section_feed_allocate_filter(struct
dvb_demux_t *dvbdemux=dvbdmxfeed->demux;	dvb_demux_t *dvbdemux=dvbdmxfeed->demux;
dvb_demux_filter_t *dvbdmxfilter;	dvb_demux_filter_t *dvbdmxfilter;

	down_interruptible(&dvbdemux->mutex);
dvbdmxfilter=DvbDmxFilterAlloc(dvbdemux);	dvbdmxfilter=DvbDmxFilterAlloc(dvbdemux);
if (!dvbdmxfilter)	if (!dvbdmxfilter) {
	up(&dvbdemux->mutex);
return -ENOSPC;	return -ENOSPC;
	}
*filter=&dvbdmxfilter->filter;	*filter=&dvbdmxfilter->filter;
(*filter)->parent=feed;	(*filter)->parent=feed;
(*filter)->priv=0;	(*filter)->priv=0;
Line 734 dmx_section_feed_allocate_filter(struct	Line 763 dmx_section_feed_allocate_filter(struct

dvbdmxfilter->next=dvbdmxfeed->filter;	dvbdmxfilter->next=dvbdmxfeed->filter;
dvbdmxfeed->filter=dvbdmxfilter;	dvbdmxfeed->filter=dvbdmxfilter;
	up(&dvbdemux->mutex);
return 0;	return 0;
}	}

static int	static int
dmx_section_feed_set(struct dmx_section_feed_s* feed,	dmx_section_feed_set(struct dmx_section_feed_s* feed,
__u16 pid, size_t circular_buffer_size,	u16 pid, size_t circular_buffer_size,
int descramble, int check_crc)	int descramble, int check_crc)
{	{
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;
Line 747 dmx_section_feed_set(struct dmx_section_	Line 777 dmx_section_feed_set(struct dmx_section_

if (pid>0x1fff)	if (pid>0x1fff)
return -EINVAL;	return -EINVAL;
	down_interruptible(&dvbdmx->mutex);
if (dvbdmxfeed->pid!=0xffff) {	if (dvbdmxfeed->pid!=0xffff) {
dvbdmx->pid2feed[dvbdmxfeed->pid]=0;	dvbdmx->pid2feed[dvbdmxfeed->pid]=0;
dvbdmxfeed->pid=0xffff;	dvbdmxfeed->pid=0xffff;
}	}
if (dvbdmx->pid2feed[pid])	if (dvbdmx->pid2feed[pid]) {
return -EBUSY;	up(&dvbdmx->mutex);
	return -EBUSY;
	}
dvbdmx->pid2feed[pid]=dvbdmxfeed;	dvbdmx->pid2feed[pid]=dvbdmxfeed;
dvbdmxfeed->pid=pid;	dvbdmxfeed->pid=pid;

dvbdmxfeed->buffer_size=circular_buffer_size;	dvbdmxfeed->buffer_size=circular_buffer_size;
dvbdmxfeed->descramble=descramble;	dvbdmxfeed->descramble=descramble;
if (dvbdmxfeed->descramble)	if (dvbdmxfeed->descramble) {
	up(&dvbdmx->mutex);
return -ENOSYS;	return -ENOSYS;
	}

dvbdmxfeed->check_crc=check_crc;	dvbdmxfeed->check_crc=check_crc;
#ifdef NOBUFS	#ifdef NOBUFS
dvbdmxfeed->buffer=0;	dvbdmxfeed->buffer=0;
#else	#else
dvbdmxfeed->buffer=vmalloc(dvbdmxfeed->buffer_size);	dvbdmxfeed->buffer=vmalloc(dvbdmxfeed->buffer_size);
if (!dvbdmxfeed->buffer)	if (!dvbdmxfeed->buffer) {
	up(&dvbdmx->mutex);
return -ENOMEM;	return -ENOMEM;
	}
#endif	#endif
dvbdmxfeed->state=DMX_STATE_READY;	dvbdmxfeed->state=DMX_STATE_READY;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 780 dmx_section_feed_start_filtering(dmx_sec	Line 818 dmx_section_feed_start_filtering(dmx_sec
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
int ret;	int ret;

if (feed->is_filtering)	down_interruptible(&dvbdmx->mutex);
return -EBUSY;	if (feed->is_filtering) {
if (!dvbdmxfeed->filter)	up(&dvbdmx->mutex);
	return -EBUSY;
	}
	if (!dvbdmxfeed->filter) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
dvbdmxfeed->secbufp=0;	dvbdmxfeed->secbufp=0;
dvbdmxfeed->seclen=0;	dvbdmxfeed->seclen=0;

if (!dvbdmx->start_feed)	if (!dvbdmx->start_feed) {
	up(&dvbdmx->mutex);
return -1;	return -1;
	}
ret=dvbdmx->start_feed(dvbdmxfeed);	ret=dvbdmx->start_feed(dvbdmxfeed);
if (ret<0)	if (ret<0) {
return ret;	up(&dvbdmx->mutex);
	return ret;
	}
feed->is_filtering=1;	feed->is_filtering=1;
dvbdmxfeed->state=DMX_STATE_GO;	dvbdmxfeed->state=DMX_STATE_GO;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 805 dmx_section_feed_stop_filtering(struct d	Line 852 dmx_section_feed_stop_filtering(struct d
dvb_demux_t *dvbdmx=dvbdmxfeed->demux;	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
int ret;	int ret;

if (!dvbdmx->stop_feed)	down_interruptible(&dvbdmx->mutex);
	if (!dvbdmx->stop_feed) {
	up(&dvbdmx->mutex);
return -1;	return -1;
	}
ret=dvbdmx->stop_feed(dvbdmxfeed);	ret=dvbdmx->stop_feed(dvbdmxfeed);

dvbdmxfeed->state=DMX_STATE_READY;	dvbdmxfeed->state=DMX_STATE_READY;
feed->is_filtering=0;	feed->is_filtering=0;
	up(&dvbdmx->mutex);
return ret;	return ret;
}	}

Line 820 dmx_section_feed_release_filter(dmx_sect	Line 871 dmx_section_feed_release_filter(dmx_sect
{	{
dvb_demux_filter_t dvbdmxfilter=(dvb_demux_filter_t ) filter, *f;	dvb_demux_filter_t dvbdmxfilter=(dvb_demux_filter_t ) filter, *f;
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;
	dvb_demux_t *dvbdmx=dvbdmxfeed->demux;

if (dvbdmxfilter->feed!=dvbdmxfeed)	down_interruptible(&dvbdmx->mutex);
	if (dvbdmxfilter->feed!=dvbdmxfeed) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
if (feed->is_filtering)	if (feed->is_filtering)
feed->stop_filtering(feed);	feed->stop_filtering(feed);
//return -EBUSY;

f=dvbdmxfeed->filter;	f=dvbdmxfeed->filter;
if (f==dvbdmxfilter)	if (f==dvbdmxfilter)
dvbdmxfeed->filter=dvbdmxfilter->next;	dvbdmxfeed->filter=dvbdmxfilter->next;
Line 837 dmx_section_feed_release_filter(dmx_sect	Line 891 dmx_section_feed_release_filter(dmx_sect
}	}

dvbdmxfilter->state=DMX_STATE_FREE;	dvbdmxfilter->state=DMX_STATE_FREE;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 847 static int dvbdmx_allocate_section_feed(	Line 902 static int dvbdmx_allocate_section_feed(
dvb_demux_t dvbdmx=(dvb_demux_t ) demux;	dvb_demux_t dvbdmx=(dvb_demux_t ) demux;
dvb_demux_feed_t *dvbdmxfeed;	dvb_demux_feed_t *dvbdmxfeed;

if (!(dvbdmxfeed=DvbDmxFeedAlloc(dvbdmx)))	down_interruptible(&dvbdmx->mutex);
	if (!(dvbdmxfeed=DvbDmxFeedAlloc(dvbdmx))) {
	up(&dvbdmx->mutex);
return -EBUSY;	return -EBUSY;
	}
dvbdmxfeed->type=DMX_TYPE_SEC;	dvbdmxfeed->type=DMX_TYPE_SEC;
dvbdmxfeed->cb.sec=callback;	dvbdmxfeed->cb.sec=callback;
dvbdmxfeed->demux=dvbdmx;	dvbdmxfeed->demux=dvbdmx;
dvbdmxfeed->pid=0xffff;	dvbdmxfeed->pid=0xffff;
dvbdmxfeed->secbufp=0;	dvbdmxfeed->secbufp=0;
dvbdmxfeed->filter=0;	dvbdmxfeed->filter=0;
	dvbdmxfeed->buffer=0;

(*feed)=&dvbdmxfeed->feed.sec;	(*feed)=&dvbdmxfeed->feed.sec;
(*feed)->is_filtering=0;	(*feed)->is_filtering=0;
Line 865 static int dvbdmx_allocate_section_feed(	Line 924 static int dvbdmx_allocate_section_feed(
(*feed)->release_filter=dmx_section_feed_release_filter;	(*feed)->release_filter=dmx_section_feed_release_filter;
(*feed)->start_filtering=dmx_section_feed_start_filtering;	(*feed)->start_filtering=dmx_section_feed_start_filtering;
(*feed)->stop_filtering=dmx_section_feed_stop_filtering;	(*feed)->stop_filtering=dmx_section_feed_stop_filtering;

	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 872 static int dvbdmx_release_section_feed(d	Line 933 static int dvbdmx_release_section_feed(d
dmx_section_feed_t *feed)	dmx_section_feed_t *feed)
{	{
dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;	dvb_demux_feed_t dvbdmxfeed=(dvb_demux_feed_t ) feed;
	dvb_demux_t dvbdmx=(dvb_demux_t ) demux;

if (dvbdmxfeed->state==DMX_STATE_FREE)	down_interruptible(&dvbdmx->mutex);
	if (dvbdmxfeed->state==DMX_STATE_FREE) {
	up(&dvbdmx->mutex);
return -EINVAL;	return -EINVAL;
	}
	#ifndef NOBUFS
if (dvbdmxfeed->buffer) {	if (dvbdmxfeed->buffer) {
vfree(dvbdmxfeed->buffer);	vfree(dvbdmxfeed->buffer);
dvbdmxfeed->buffer=0;	dvbdmxfeed->buffer=0;
}	}
	#endif
dvbdmxfeed->state=DMX_STATE_FREE;	dvbdmxfeed->state=DMX_STATE_FREE;
dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;	dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;
if (dvbdmxfeed->pid!=0xffff)	if (dvbdmxfeed->pid!=0xffff)
dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;	dvbdmxfeed->demux->pid2feed[dvbdmxfeed->pid]=0;
	up(&dvbdmx->mutex);
return 0;	return 0;
}	}

Line 976 dvbdmx_get_frontends(dmx_demux_t *demux)	Line 1044 dvbdmx_get_frontends(dmx_demux_t *demux)
static int dvbdmx_connect_frontend(dmx_demux_t *demux,	static int dvbdmx_connect_frontend(dmx_demux_t *demux,
dmx_frontend_t *frontend)	dmx_frontend_t *frontend)
{	{
	dvb_demux_t dvbdemux=(dvb_demux_t ) demux;

if (demux->frontend)	if (demux->frontend)
return -EINVAL;	return -EINVAL;

	down_interruptible(&dvbdemux->mutex);
demux->frontend=frontend;	demux->frontend=frontend;
	up(&dvbdemux->mutex);
return 0;	return 0;
}	}

static int dvbdmx_disconnect_frontend(dmx_demux_t *demux)	static int dvbdmx_disconnect_frontend(dmx_demux_t *demux)
{	{
	dvb_demux_t dvbdemux=(dvb_demux_t ) demux;

	down_interruptible(&dvbdemux->mutex);
demux->frontend=NULL;	demux->frontend=NULL;
	up(&dvbdemux->mutex);
return 0;	return 0;
}	}

static int dvbdmx_get_pes_pids(dmx_demux_t demux, __u16 pids)	static int dvbdmx_get_pes_pids(dmx_demux_t demux, u16 pids)
{	{
dvb_demux_t dvbdemux=(dvb_demux_t ) demux;	dvb_demux_t dvbdemux=(dvb_demux_t ) demux;

memcpy(pids, dvbdemux->pids, 5*sizeof(__u16));	memcpy(pids, dvbdemux->pids, 5*sizeof(u16));
return 0;	return 0;
}	}

Line 1027 DvbDmxInit(dvb_demux_t *dvbdemux)	Line 1103 DvbDmxInit(dvb_demux_t *dvbdemux)
dvbdemux->pids[i]=0xffff;	dvbdemux->pids[i]=0xffff;
}	}
dvbdemux->playing=dvbdemux->recording=0;	dvbdemux->playing=dvbdemux->recording=0;
memset(dvbdemux->pid2feed, 0, 0x2000sizeof(dvb_demux_feed_t ));	memset(dvbdemux->pid2feed, 0, (DMX_MAX_PID+1)sizeof(dvb_demux_feed_t ));
dvbdemux->tsbufp=0;	dvbdemux->tsbufp=0;

dmx->frontend=0;	dmx->frontend=0;
Line 1053 DvbDmxInit(dvb_demux_t *dvbdemux)	Line 1129 DvbDmxInit(dvb_demux_t *dvbdemux)
dmx->connect_frontend=dvbdmx_connect_frontend;	dmx->connect_frontend=dvbdmx_connect_frontend;
dmx->disconnect_frontend=dvbdmx_disconnect_frontend;	dmx->disconnect_frontend=dvbdmx_disconnect_frontend;
dmx->get_pes_pids=dvbdmx_get_pes_pids;	dmx->get_pes_pids=dvbdmx_get_pes_pids;
	sema_init(&dvbdemux->mutex, 1);

if (dmx_register_demux(dmx)<0)	if (dmx_register_demux(dmx)<0)
return -1;	return -1;

sema_init(&dvbdemux->mutex, 1);
return 0;	return 0;
}	}

LinuxTV legacy CVS <linuxtv.org/cvs>

Removed from v.1.7
changed lines
	Added in v.1.8