-/*
+/*
* dvb_demux.c - DVB kernel demux API
*
* Copyright (C) 2000-2001 Ralph Metzler <ralph@convergence.de>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/string.h>
- #include <linux/crc32.h>
+#include <linux/crc32.h>
#include <asm/uaccess.h>
#include "dvb_demux.h"
-#define NOBUFS
-/*
+#define NOBUFS
+/*
** #define DVB_DEMUX_SECTION_LOSS_LOG to monitor payload loss in the syslog
*/
// #define DVB_DEMUX_SECTION_LOSS_LOG
-LIST_HEAD(dmx_muxs);
+static LIST_HEAD(dmx_muxs);
-int dmx_register_demux(struct dmx_demux *demux)
+static int dmx_register_demux(struct dmx_demux *demux)
{
demux->users = 0;
list_add(&demux->reg_list, &dmx_muxs);
return 0;
}
-int dmx_unregister_demux(struct dmx_demux* demux)
+static int dmx_unregister_demux(struct dmx_demux* demux)
{
struct list_head *pos, *n, *head=&dmx_muxs;
}
-struct list_head *dmx_get_demuxes(void)
-{
- if (list_empty(&dmx_muxs))
- return NULL;
-
- return &dmx_muxs;
-}
-
/******************************************************************************
* static inlined helper functions
******************************************************************************/
static inline u8 payload(const u8 *tsp)
{
- if (!(tsp[3]&0x10)) // no payload?
+ if (!(tsp[3] & 0x10)) // no payload?
return 0;
- if (tsp[3]&0x20) { // adaptation field?
- if (tsp[4]>183) // corrupted data?
+ if (tsp[3] & 0x20) { // adaptation field?
+ if (tsp[4] > 183) // corrupted data?
return 0;
else
return 184-1-tsp[4];
}
-void dvb_set_crc32(u8 *data, int length)
-{
- u32 crc;
-
- crc = crc32_be(~0, data, length);
-
- data[length] = (crc >> 24) & 0xff;
- data[length+1] = (crc >> 16) & 0xff;
- data[length+2] = (crc >> 8) & 0xff;
- data[length+3] = (crc) & 0xff;
-}
-
-
static u32 dvb_dmx_crc32 (struct dvb_demux_feed *f, const u8 *src, size_t len)
{
return (f->feed.sec.crc_val = crc32_be (f->feed.sec.crc_val, src, len));
* Software filter functions
******************************************************************************/
-static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed *feed, const u8 *buf)
+static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed *feed, const u8 *buf)
{
int count = payload(buf);
int p;
feed->peslen += count;
- return feed->cb.ts (&buf[p], count, NULL, 0, &feed->feed.ts, DMX_OK);
+ return feed->cb.ts (&buf[p], count, NULL, 0, &feed->feed.ts, DMX_OK);
}
-static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed *feed,
+static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed *feed,
struct dvb_demux_filter *f)
{
u8 neq = 0;
if (f->doneq && !neq)
return 0;
- return feed->cb.sec (feed->feed.sec.secbuf, feed->feed.sec.seclen,
- NULL, 0, &f->filter, DMX_OK);
+ return feed->cb.sec (feed->feed.sec.secbuf, feed->feed.sec.seclen,
+ NULL, 0, &f->filter, DMX_OK);
}
section_syntax_indicator = ((sec->secbuf[1] & 0x80) != 0);
if (section_syntax_indicator &&
demux->check_crc32(feed, sec->secbuf, sec->seclen))
- return -1;
+ return -1;
}
do {
*/
if(sec->secbuf[0] != 0xff || sec->secbuf[n-1] != 0xff)
{
- printk("dvb_demux.c section ts padding loss: %d/%d\n",
+ printk("dvb_demux.c section ts padding loss: %d/%d\n",
n, sec->tsfeedp);
printk("dvb_demux.c pad data:");
for(i = 0; i < n; i++)
printk(" %02x", sec->secbuf[i]);
printk("\n");
- }
- }
+ }
+ }
#endif
sec->tsfeedp = sec->secbufp = sec->seclen = 0;
sec->secbuf = sec->secbuf_base;
- }
+}
-/*
+/*
** Losless Section Demux 1.4.1 by Emard
** Valsecchi Patrick:
** - middle of section A (no PUSI)
-** - end of section A and start of section B
+** - end of section A and start of section B
** (with PUSI pointing to the start of the second section)
-**
+**
** In this case, without feed->pusi_seen you'll receive a garbage section
** consisting of the end of section A. Basically because tsfeedp
** is incemented and the use=0 condition is not raised
if(sec->tsfeedp + len > DMX_MAX_SECFEED_SIZE)
{
#ifdef DVB_DEMUX_SECTION_LOSS_LOG
- printk("dvb_demux.c section buffer full loss: %d/%d\n",
+ printk("dvb_demux.c section buffer full loss: %d/%d\n",
sec->tsfeedp + len - DMX_MAX_SECFEED_SIZE, DMX_MAX_SECFEED_SIZE);
#endif
len = DMX_MAX_SECFEED_SIZE - sec->tsfeedp;
for(n = 0; sec->secbufp + 2 < limit; n++)
{
seclen = section_length(sec->secbuf);
- if(seclen <= 0 || seclen > DMX_MAX_SECFEED_SIZE
+ if(seclen <= 0 || seclen > DMX_MAX_SECFEED_SIZE
|| seclen + sec->secbufp > limit)
return 0;
sec->seclen = seclen;
sec->crc_val = ~0;
/* dump [secbuf .. secbuf+seclen) */
if(feed->pusi_seen)
- dvb_dmx_swfilter_section_feed(feed);
+ dvb_dmx_swfilter_section_feed(feed);
#ifdef DVB_DEMUX_SECTION_LOSS_LOG
else
printk("dvb_demux.c pusi not seen, discarding section data\n");
#endif
sec->secbufp += seclen; /* secbufp and secbuf moving together is */
sec->secbuf += seclen; /* redundand but saves pointer arithmetic */
- }
-
- return 0;
}
+ return 0;
+}
+
-static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed *feed, const u8 *buf)
+static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed *feed, const u8 *buf)
{
u8 p, count;
int ccok, dc_i = 0;
u8 cc;
count = payload(buf);
-
+
if (count == 0) /* count == 0 if no payload or out of range */
- return -1;
+ return -1;
- p = 188-count; /* payload start */
+ p = 188 - count; /* payload start */
cc = buf[3] & 0x0f;
ccok = ((feed->cc + 1) & 0x0f) == cc;
}
#ifdef DVB_DEMUX_SECTION_LOSS_LOG
else
- if(count > 0)
+ if (count > 0)
printk("dvb_demux.c PUSI=1 but %d bytes lost\n", count);
#endif
} else {
if (feed->ts_type & TS_PAYLOAD_ONLY)
dvb_dmx_swfilter_payload(feed, buf);
else
- feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, DMX_OK);
+ feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, DMX_OK);
}
- if (feed->ts_type & TS_DECODER)
+ if (feed->ts_type & TS_DECODER)
if (feed->demux->write_to_decoder)
feed->demux->write_to_decoder(feed, buf, 188);
break;
((f)->feed.ts.is_filtering) && \
(((f)->ts_type & (TS_PACKET|TS_PAYLOAD_ONLY)) == TS_PACKET))
-void dvb_dmx_swfilter_packet(struct dvb_demux *demux, const u8 *buf)
+static void dvb_dmx_swfilter_packet(struct dvb_demux *demux, const u8 *buf)
{
struct dvb_demux_feed *feed;
struct list_head *pos, *head=&demux->feed_list;
continue;
if (feed->pid == pid) {
- dvb_dmx_swfilter_packet_type (feed, buf);
+ dvb_dmx_swfilter_packet_type(feed, buf);
if (DVR_FEED(feed))
continue;
}
feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, DMX_OK);
}
}
-EXPORT_SYMBOL(dvb_dmx_swfilter_packet);
void dvb_dmx_swfilter_packets(struct dvb_demux *demux, const u8 *buf, size_t count)
{
spin_lock(&demux->lock);
while (count--) {
- if(buf[0] == 0x47) {
- dvb_dmx_swfilter_packet(demux, buf);
+ if(buf[0] == 0x47) {
+ dvb_dmx_swfilter_packet(demux, buf);
}
buf += 188;
}
void dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, size_t count)
{
- int p = 0,i, j;
-
+ int p = 0, i, j;
+
spin_lock(&demux->lock);
if ((i = demux->tsbufp)) {
}
memcpy(&demux->tsbuf[i], buf, j);
if (demux->tsbuf[0] == 0x47)
- dvb_dmx_swfilter_packet(demux, demux->tsbuf);
+ dvb_dmx_swfilter_packet(demux, demux->tsbuf);
demux->tsbufp = 0;
p += j;
}
demux->tsbufp=i;
goto bailout;
}
- } else
+ } else
p++;
}
demux->tsbufp=i;
goto bailout;
}
- } else {
+ } else {
p++;
}
}
if (entry == feed)
return 1;
- return 0;
- }
+ return 0;
+}
static void dvb_demux_feed_add(struct dvb_demux_feed *feed)
{
printk(KERN_ERR "%s: feed not in list (type=%x state=%x pid=%x)\n",
__FUNCTION__, feed->type, feed->state, feed->pid);
goto out;
-}
+ }
list_del(&feed->list_head);
out:
spin_unlock_irq(&feed->demux->lock);
}
-static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type,
- enum dmx_ts_pes pes_type, size_t callback_length,
- size_t circular_buffer_size, int descramble,
+static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type,
+ enum dmx_ts_pes pes_type, size_t callback_length,
+ size_t circular_buffer_size, int descramble,
struct timespec timeout)
{
struct dvb_demux_feed *feed = (struct dvb_demux_feed *) ts_feed;
if (pid > DMX_MAX_PID)
return -EINVAL;
-
+
if (down_interruptible (&demux->mutex))
return -ERESTARTSYS;
return -EINVAL;
}
- if (demux->pesfilter[pes_type] &&
+ if (demux->pesfilter[pes_type] &&
demux->pesfilter[pes_type] != feed) {
up(&demux->mutex);
return -EINVAL;
}
#endif
}
-
+
feed->state = DMX_STATE_READY;
up(&demux->mutex);
return 0;
}
-
+
static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed* ts_feed)
{
struct dvb_demux_feed *feed = (struct dvb_demux_feed *) ts_feed;
if (down_interruptible (&demux->mutex))
return -ERESTARTSYS;
- if (feed->state<DMX_STATE_GO) {
+ if (feed->state < DMX_STATE_GO) {
up(&demux->mutex);
return -EINVAL;
}
return -ENODEV;
}
- ret = demux->stop_feed(feed);
+ ret = demux->stop_feed(feed);
spin_lock_irq(&demux->lock);
ts_feed->is_filtering = 0;
return ret;
}
-static int dvbdmx_allocate_ts_feed (struct dmx_demux *dmx, struct dmx_ts_feed **ts_feed,
+static int dvbdmx_allocate_ts_feed (struct dmx_demux *dmx, struct dmx_ts_feed **ts_feed,
dmx_ts_cb callback)
{
struct dvb_demux *demux = (struct dvb_demux *) dmx;
feed->filter->type = DMX_TYPE_TS;
feed->filter->feed = feed;
feed->filter->state = DMX_STATE_READY;
-
+
up(&demux->mutex);
return 0;
}
#ifndef NOBUFS
- vfree(feed->buffer);
- feed->buffer=0;
+ vfree(feed->buffer);
+ feed->buffer=0;
#endif
feed->state = DMX_STATE_FREE;
dvb_demux_feed_del(feed);
- feed->pid = 0xffff;
-
+ feed->pid = 0xffff;
+
if (feed->ts_type & TS_DECODER && feed->pes_type < DMX_TS_PES_OTHER)
demux->pesfilter[feed->pes_type] = NULL;
* dmx_section_feed API calls
******************************************************************************/
-static int dmx_section_feed_allocate_filter(struct dmx_section_feed* feed,
- struct dmx_section_filter** filter)
+static int dmx_section_feed_allocate_filter(struct dmx_section_feed* feed,
+ struct dmx_section_filter** filter)
{
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdemux=dvbdmxfeed->demux;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdemux = dvbdmxfeed->demux;
struct dvb_demux_filter *dvbdmxfilter;
if (down_interruptible (&dvbdemux->mutex))
return -ERESTARTSYS;
- dvbdmxfilter=dvb_dmx_filter_alloc(dvbdemux);
+ dvbdmxfilter = dvb_dmx_filter_alloc(dvbdemux);
if (!dvbdmxfilter) {
up(&dvbdemux->mutex);
return -EBUSY;
}
spin_lock_irq(&dvbdemux->lock);
- *filter=&dvbdmxfilter->filter;
- (*filter)->parent=feed;
- (*filter)->priv=NULL;
- dvbdmxfilter->feed=dvbdmxfeed;
- dvbdmxfilter->type=DMX_TYPE_SEC;
- dvbdmxfilter->state=DMX_STATE_READY;
-
- dvbdmxfilter->next=dvbdmxfeed->filter;
- dvbdmxfeed->filter=dvbdmxfilter;
+ *filter = &dvbdmxfilter->filter;
+ (*filter)->parent = feed;
+ (*filter)->priv = NULL;
+ dvbdmxfilter->feed = dvbdmxfeed;
+ dvbdmxfilter->type = DMX_TYPE_SEC;
+ dvbdmxfilter->state = DMX_STATE_READY;
+ dvbdmxfilter->next = dvbdmxfeed->filter;
+ dvbdmxfeed->filter = dvbdmxfilter;
spin_unlock_irq(&dvbdemux->lock);
+
up(&dvbdemux->mutex);
return 0;
}
-static int dmx_section_feed_set(struct dmx_section_feed* feed,
- u16 pid, size_t circular_buffer_size,
- int descramble, int check_crc)
+static int dmx_section_feed_set(struct dmx_section_feed* feed,
+ u16 pid, size_t circular_buffer_size,
+ int descramble, int check_crc)
{
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
- if (pid>0x1fff)
+ if (pid > 0x1fff)
return -EINVAL;
if (down_interruptible (&dvbdmx->mutex))
return -ERESTARTSYS;
-
+
dvb_demux_feed_add(dvbdmxfeed);
dvbdmxfeed->pid = pid;
- dvbdmxfeed->buffer_size=circular_buffer_size;
- dvbdmxfeed->descramble=descramble;
+ dvbdmxfeed->buffer_size = circular_buffer_size;
+ dvbdmxfeed->descramble = descramble;
if (dvbdmxfeed->descramble) {
up(&dvbdmx->mutex);
return -ENOSYS;
}
- dvbdmxfeed->feed.sec.check_crc=check_crc;
+ dvbdmxfeed->feed.sec.check_crc = check_crc;
+
#ifdef NOBUFS
- dvbdmxfeed->buffer=NULL;
+ dvbdmxfeed->buffer = NULL;
#else
dvbdmxfeed->buffer=vmalloc(dvbdmxfeed->buffer_size);
if (!dvbdmxfeed->buffer) {
return -ENOMEM;
}
#endif
- dvbdmxfeed->state=DMX_STATE_READY;
+
+ dvbdmxfeed->state = DMX_STATE_READY;
up(&dvbdmx->mutex);
return 0;
}
+
static void prepare_secfilters(struct dvb_demux_feed *dvbdmxfeed)
{
int i;
struct dvb_demux_filter *f;
struct dmx_section_filter *sf;
u8 mask, mode, doneq;
-
+
if (!(f=dvbdmxfeed->filter))
return;
do {
- sf=&f->filter;
- doneq=0;
+ sf = &f->filter;
+ doneq = 0;
for (i=0; i<DVB_DEMUX_MASK_MAX; i++) {
- mode=sf->filter_mode[i];
- mask=sf->filter_mask[i];
- f->maskandmode[i]=mask&mode;
- doneq|=f->maskandnotmode[i]=mask&~mode;
+ mode = sf->filter_mode[i];
+ mask = sf->filter_mask[i];
+ f->maskandmode[i] = mask & mode;
+ doneq |= f->maskandnotmode[i] = mask & ~mode;
}
- f->doneq=doneq ? 1 : 0;
- } while ((f=f->next));
+ f->doneq = doneq ? 1 : 0;
+ } while ((f = f->next));
}
static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
{
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
int ret;
if (down_interruptible (&dvbdmx->mutex))
return -ERESTARTSYS;
-
+
if (feed->is_filtering) {
up(&dvbdmx->mutex);
return -EBUSY;
}
+
if (!dvbdmxfeed->filter) {
up(&dvbdmx->mutex);
return -EINVAL;
dvbdmxfeed->feed.sec.tsfeedp = 0;
dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base;
- dvbdmxfeed->feed.sec.secbufp=0;
- dvbdmxfeed->feed.sec.seclen=0;
-
+ dvbdmxfeed->feed.sec.secbufp = 0;
+ dvbdmxfeed->feed.sec.seclen = 0;
+
if (!dvbdmx->start_feed) {
up(&dvbdmx->mutex);
return -ENODEV;
}
spin_lock_irq(&dvbdmx->lock);
- feed->is_filtering=1;
- dvbdmxfeed->state=DMX_STATE_GO;
+ feed->is_filtering = 1;
+ dvbdmxfeed->state = DMX_STATE_GO;
spin_unlock_irq(&dvbdmx->lock);
+
up(&dvbdmx->mutex);
return 0;
}
static int dmx_section_feed_stop_filtering(struct dmx_section_feed* feed)
{
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
int ret;
if (down_interruptible (&dvbdmx->mutex))
up(&dvbdmx->mutex);
return -ENODEV;
}
- ret=dvbdmx->stop_feed(dvbdmxfeed);
+
+ ret = dvbdmx->stop_feed(dvbdmxfeed);
+
spin_lock_irq(&dvbdmx->lock);
- dvbdmxfeed->state=DMX_STATE_READY;
- feed->is_filtering=0;
+ dvbdmxfeed->state = DMX_STATE_READY;
+ feed->is_filtering = 0;
spin_unlock_irq(&dvbdmx->lock);
+
up(&dvbdmx->mutex);
return ret;
}
-static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
+static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
struct dmx_section_filter* filter)
{
- struct dvb_demux_filter *dvbdmxfilter=(struct dvb_demux_filter *) filter, *f;
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdmx=dvbdmxfeed->demux;
+ struct dvb_demux_filter *dvbdmxfilter = (struct dvb_demux_filter *) filter, *f;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
if (down_interruptible (&dvbdmx->mutex))
return -ERESTARTSYS;
- if (dvbdmxfilter->feed!=dvbdmxfeed) {
+ if (dvbdmxfilter->feed != dvbdmxfeed) {
up(&dvbdmx->mutex);
return -EINVAL;
}
- if (feed->is_filtering)
+
+ if (feed->is_filtering)
feed->stop_filtering(feed);
-
+
spin_lock_irq(&dvbdmx->lock);
- f=dvbdmxfeed->filter;
+ f = dvbdmxfeed->filter;
if (f == dvbdmxfilter) {
- dvbdmxfeed->filter=dvbdmxfilter->next;
+ dvbdmxfeed->filter = dvbdmxfilter->next;
} else {
- while(f->next!=dvbdmxfilter)
- f=f->next;
- f->next=f->next->next;
+ while(f->next != dvbdmxfilter)
+ f = f->next;
+ f->next = f->next->next;
}
- dvbdmxfilter->state=DMX_STATE_FREE;
+
+ dvbdmxfilter->state = DMX_STATE_FREE;
spin_unlock_irq(&dvbdmx->lock);
up(&dvbdmx->mutex);
return 0;
}
-static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
+static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
struct dmx_section_feed **feed,
dmx_section_cb callback)
{
- struct dvb_demux *dvbdmx=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdmx = (struct dvb_demux *) demux;
struct dvb_demux_feed *dvbdmxfeed;
if (down_interruptible (&dvbdmx->mutex))
return -ERESTARTSYS;
- if (!(dvbdmxfeed=dvb_dmx_feed_alloc(dvbdmx))) {
+ if (!(dvbdmxfeed = dvb_dmx_feed_alloc(dvbdmx))) {
up(&dvbdmx->mutex);
return -EBUSY;
}
- dvbdmxfeed->type=DMX_TYPE_SEC;
- dvbdmxfeed->cb.sec=callback;
- dvbdmxfeed->demux=dvbdmx;
- dvbdmxfeed->pid=0xffff;
+
+ dvbdmxfeed->type = DMX_TYPE_SEC;
+ dvbdmxfeed->cb.sec = callback;
+ dvbdmxfeed->demux = dvbdmx;
+ dvbdmxfeed->pid = 0xffff;
dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base;
dvbdmxfeed->feed.sec.secbufp = dvbdmxfeed->feed.sec.seclen = 0;
dvbdmxfeed->feed.sec.tsfeedp = 0;
- dvbdmxfeed->filter=NULL;
- dvbdmxfeed->buffer=NULL;
+ dvbdmxfeed->filter = NULL;
+ dvbdmxfeed->buffer = NULL;
(*feed)=&dvbdmxfeed->feed.sec;
- (*feed)->is_filtering=0;
- (*feed)->parent=demux;
- (*feed)->priv=NULL;
-
- (*feed)->set=dmx_section_feed_set;
- (*feed)->allocate_filter=dmx_section_feed_allocate_filter;
- (*feed)->start_filtering=dmx_section_feed_start_filtering;
- (*feed)->stop_filtering=dmx_section_feed_stop_filtering;
+ (*feed)->is_filtering = 0;
+ (*feed)->parent = demux;
+ (*feed)->priv = NULL;
+
+ (*feed)->set = dmx_section_feed_set;
+ (*feed)->allocate_filter = dmx_section_feed_allocate_filter;
+ (*feed)->start_filtering = dmx_section_feed_start_filtering;
+ (*feed)->stop_filtering = dmx_section_feed_stop_filtering;
(*feed)->release_filter = dmx_section_feed_release_filter;
up(&dvbdmx->mutex);
return 0;
}
-static int dvbdmx_release_section_feed(struct dmx_demux *demux,
+static int dvbdmx_release_section_feed(struct dmx_demux *demux,
struct dmx_section_feed *feed)
{
- struct dvb_demux_feed *dvbdmxfeed=(struct dvb_demux_feed *) feed;
- struct dvb_demux *dvbdmx=(struct dvb_demux *) demux;
+ struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
+ struct dvb_demux *dvbdmx = (struct dvb_demux *) demux;
if (down_interruptible (&dvbdmx->mutex))
return -ERESTARTSYS;
return -EINVAL;
}
#ifndef NOBUFS
- vfree(dvbdmxfeed->buffer);
- dvbdmxfeed->buffer=0;
+ vfree(dvbdmxfeed->buffer);
+ dvbdmxfeed->buffer=0;
#endif
dvbdmxfeed->state=DMX_STATE_FREE;
dvb_demux_feed_del(dvbdmxfeed);
- dvbdmxfeed->pid = 0xffff;
+ dvbdmxfeed->pid = 0xffff;
up(&dvbdmx->mutex);
return 0;
static int dvbdmx_open(struct dmx_demux *demux)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
- if (dvbdemux->users>=MAX_DVB_DEMUX_USERS)
+ if (dvbdemux->users >= MAX_DVB_DEMUX_USERS)
return -EUSERS;
+
dvbdemux->users++;
return 0;
}
static int dvbdmx_close(struct dmx_demux *demux)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
- if (dvbdemux->users==0)
+ if (dvbdemux->users == 0)
return -ENODEV;
+
dvbdemux->users--;
//FIXME: release any unneeded resources if users==0
return 0;
static int dvbdmx_add_frontend(struct dmx_demux *demux, struct dmx_frontend *frontend)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
struct list_head *head = &dvbdemux->frontend_list;
list_add(&(frontend->connectivity_list), head);
static int dvbdmx_remove_frontend(struct dmx_demux *demux, struct dmx_frontend *frontend)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
- struct list_head *pos, *n, *head=&dvbdemux->frontend_list;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
+ struct list_head *pos, *n, *head = &dvbdemux->frontend_list;
list_for_each_safe (pos, n, head) {
if (DMX_FE_ENTRY(pos) == frontend) {
return 0;
}
}
+
return -ENODEV;
}
static struct list_head * dvbdmx_get_frontends(struct dmx_demux *demux)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
if (list_empty(&dvbdemux->frontend_list))
return NULL;
}
-int dvbdmx_connect_frontend(struct dmx_demux *demux, struct dmx_frontend *frontend)
+static int dvbdmx_connect_frontend(struct dmx_demux *demux, struct dmx_frontend *frontend)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
if (demux->frontend)
return -EINVAL;
-
+
if (down_interruptible (&dvbdemux->mutex))
return -ERESTARTSYS;
- demux->frontend=frontend;
+ demux->frontend = frontend;
up(&dvbdemux->mutex);
return 0;
}
-EXPORT_SYMBOL(dvbdmx_connect_frontend);
-int dvbdmx_disconnect_frontend(struct dmx_demux *demux)
+static int dvbdmx_disconnect_frontend(struct dmx_demux *demux)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
if (down_interruptible (&dvbdemux->mutex))
return -ERESTARTSYS;
- demux->frontend=NULL;
+ demux->frontend = NULL;
up(&dvbdemux->mutex);
return 0;
}
-EXPORT_SYMBOL(dvbdmx_disconnect_frontend);
static int dvbdmx_get_pes_pids(struct dmx_demux *demux, u16 *pids)
{
- struct dvb_demux *dvbdemux=(struct dvb_demux *) demux;
+ struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
memcpy(pids, dvbdemux->pids, 5*sizeof(u16));
return 0;
int i, err;
struct dmx_demux *dmx = &dvbdemux->dmx;
- dvbdemux->users=0;
- dvbdemux->filter=vmalloc(dvbdemux->filternum*sizeof(struct dvb_demux_filter));
+ dvbdemux->users = 0;
+ dvbdemux->filter = vmalloc(dvbdemux->filternum*sizeof(struct dvb_demux_filter));
+
if (!dvbdemux->filter)
return -ENOMEM;
- dvbdemux->feed=vmalloc(dvbdemux->feednum*sizeof(struct dvb_demux_feed));
+ dvbdemux->feed = vmalloc(dvbdemux->feednum*sizeof(struct dvb_demux_feed));
if (!dvbdemux->feed) {
vfree(dvbdemux->filter);
return -ENOMEM;
}
for (i=0; i<dvbdemux->filternum; i++) {
- dvbdemux->filter[i].state=DMX_STATE_FREE;
- dvbdemux->filter[i].index=i;
+ dvbdemux->filter[i].state = DMX_STATE_FREE;
+ dvbdemux->filter[i].index = i;
+ }
+ for (i=0; i<dvbdemux->feednum; i++) {
+ dvbdemux->feed[i].state = DMX_STATE_FREE;
+ dvbdemux->feed[i].index = i;
}
- for (i=0; i<dvbdemux->feednum; i++)
- dvbdemux->feed[i].state=DMX_STATE_FREE;
dvbdemux->frontend_list.next=
dvbdemux->frontend_list.prev=
&dvbdemux->frontend_list;
for (i=0; i<DMX_TS_PES_OTHER; i++) {
- dvbdemux->pesfilter[i]=NULL;
- dvbdemux->pids[i]=0xffff;
+ dvbdemux->pesfilter[i] = NULL;
+ dvbdemux->pids[i] = 0xffff;
}
INIT_LIST_HEAD(&dvbdemux->feed_list);
dvbdemux->playing = 0;
dvbdemux->recording = 0;
- dvbdemux->tsbufp=0;
+ dvbdemux->tsbufp = 0;
if (!dvbdemux->check_crc32)
dvbdemux->check_crc32 = dvb_dmx_crc32;
if (!dvbdemux->memcopy)
dvbdemux->memcopy = dvb_dmx_memcopy;
- dmx->frontend=NULL;
+ dmx->frontend = NULL;
dmx->reg_list.prev = dmx->reg_list.next = &dmx->reg_list;
- dmx->priv=(void *) dvbdemux;
- dmx->open=dvbdmx_open;
- dmx->close=dvbdmx_close;
- dmx->write=dvbdmx_write;
- dmx->allocate_ts_feed=dvbdmx_allocate_ts_feed;
- dmx->release_ts_feed=dvbdmx_release_ts_feed;
- dmx->allocate_section_feed=dvbdmx_allocate_section_feed;
- dmx->release_section_feed=dvbdmx_release_section_feed;
-
- dmx->descramble_mac_address=NULL;
- dmx->descramble_section_payload=NULL;
-
- dmx->add_frontend=dvbdmx_add_frontend;
- dmx->remove_frontend=dvbdmx_remove_frontend;
- dmx->get_frontends=dvbdmx_get_frontends;
- dmx->connect_frontend=dvbdmx_connect_frontend;
- dmx->disconnect_frontend=dvbdmx_disconnect_frontend;
- dmx->get_pes_pids=dvbdmx_get_pes_pids;
+ dmx->priv = (void *) dvbdemux;
+ dmx->open = dvbdmx_open;
+ dmx->close = dvbdmx_close;
+ dmx->write = dvbdmx_write;
+ dmx->allocate_ts_feed = dvbdmx_allocate_ts_feed;
+ dmx->release_ts_feed = dvbdmx_release_ts_feed;
+ dmx->allocate_section_feed = dvbdmx_allocate_section_feed;
+ dmx->release_section_feed = dvbdmx_release_section_feed;
+
+ dmx->descramble_mac_address = NULL;
+ dmx->descramble_section_payload = NULL;
+
+ dmx->add_frontend = dvbdmx_add_frontend;
+ dmx->remove_frontend = dvbdmx_remove_frontend;
+ dmx->get_frontends = dvbdmx_get_frontends;
+ dmx->connect_frontend = dvbdmx_connect_frontend;
+ dmx->disconnect_frontend = dvbdmx_disconnect_frontend;
+ dmx->get_pes_pids = dvbdmx_get_pes_pids;
+
sema_init(&dvbdemux->mutex, 1);
spin_lock_init(&dvbdemux->lock);
- if ((err = dmx_register_demux(dmx)) < 0)
+ if ((err = dmx_register_demux(dmx)) < 0)
return err;
return 0;
struct dmx_demux *dmx = &dvbdemux->dmx;
dmx_unregister_demux(dmx);
- vfree(dvbdemux->filter);
- vfree(dvbdemux->feed);
+ vfree(dvbdemux->filter);
+ vfree(dvbdemux->feed);
return 0;
}
EXPORT_SYMBOL(dvb_dmx_release);
-
git://git.onelab.eu / linux-2.6.git / blobdiff