2 * dvb_demux.c - DVB kernel demux API
4 * Copyright (C) 2000-2001 Ralph Metzler <ralph@convergence.de>
5 * & Marcus Metzler <marcus@convergence.de>
6 * for convergence integrated media GmbH
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1
11 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 #include <linux/spinlock.h>
25 #include <linux/slab.h>
26 #include <linux/vmalloc.h>
27 #include <linux/module.h>
28 #include <linux/poll.h>
29 #include <linux/string.h>
30 #include <linux/crc32.h>
31 #include <asm/uaccess.h>
33 #include "dvb_demux.h"
37 ** #define DVB_DEMUX_SECTION_LOSS_LOG to monitor payload loss in the syslog
39 // #define DVB_DEMUX_SECTION_LOSS_LOG
42 /******************************************************************************
43 * static inlined helper functions
44 ******************************************************************************/
47 static inline u16
section_length(const u8
*buf
)
49 return 3+((buf
[1]&0x0f)<<8)+buf
[2];
53 static inline u16
ts_pid(const u8
*buf
)
55 return ((buf
[1]&0x1f)<<8)+buf
[2];
59 static inline u8
payload(const u8
*tsp
)
61 if (!(tsp
[3] & 0x10)) // no payload?
63 if (tsp
[3] & 0x20) { // adaptation field?
64 if (tsp
[4] > 183) // corrupted data?
73 static u32
dvb_dmx_crc32 (struct dvb_demux_feed
*f
, const u8
*src
, size_t len
)
75 return (f
->feed
.sec
.crc_val
= crc32_be (f
->feed
.sec
.crc_val
, src
, len
));
79 static void dvb_dmx_memcopy (struct dvb_demux_feed
*f
, u8
*d
, const u8
*s
, size_t len
)
85 /******************************************************************************
86 * Software filter functions
87 ******************************************************************************/
89 static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed
*feed
, const u8
*buf
)
91 int count
= payload(buf
);
103 ccok=((dvbdmxfeed->cc+1)&0x0f)==cc ? 1 : 0;
106 printk("missed packet!\n");
109 if (buf
[1] & 0x40) // PUSI ?
110 feed
->peslen
= 0xfffa;
112 feed
->peslen
+= count
;
114 return feed
->cb
.ts (&buf
[p
], count
, NULL
, 0, &feed
->feed
.ts
, DMX_OK
);
118 static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed
*feed
,
119 struct dvb_demux_filter
*f
)
124 for (i
=0; i
<DVB_DEMUX_MASK_MAX
; i
++) {
125 u8
xor = f
->filter
.filter_value
[i
] ^ feed
->feed
.sec
.secbuf
[i
];
127 if (f
->maskandmode
[i
] & xor)
130 neq
|= f
->maskandnotmode
[i
] & xor;
133 if (f
->doneq
&& !neq
)
136 return feed
->cb
.sec (feed
->feed
.sec
.secbuf
, feed
->feed
.sec
.seclen
,
137 NULL
, 0, &f
->filter
, DMX_OK
);
141 static inline int dvb_dmx_swfilter_section_feed (struct dvb_demux_feed
*feed
)
143 struct dvb_demux
*demux
= feed
->demux
;
144 struct dvb_demux_filter
*f
= feed
->filter
;
145 struct dmx_section_feed
*sec
= &feed
->feed
.sec
;
146 int section_syntax_indicator
;
148 if (!sec
->is_filtering
)
154 if (sec
->check_crc
) {
155 section_syntax_indicator
= ((sec
->secbuf
[1] & 0x80) != 0);
156 if (section_syntax_indicator
&&
157 demux
->check_crc32(feed
, sec
->secbuf
, sec
->seclen
))
162 if (dvb_dmx_swfilter_sectionfilter(feed
, f
) < 0)
164 } while ((f
= f
->next
) && sec
->is_filtering
);
172 static void dvb_dmx_swfilter_section_new(struct dvb_demux_feed
*feed
)
174 struct dmx_section_feed
*sec
= &feed
->feed
.sec
;
176 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
177 if(sec
->secbufp
< sec
->tsfeedp
)
179 int i
, n
= sec
->tsfeedp
- sec
->secbufp
;
181 /* section padding is done with 0xff bytes entirely.
182 ** due to speed reasons, we won't check all of them
183 ** but just first and last
185 if(sec
->secbuf
[0] != 0xff || sec
->secbuf
[n
-1] != 0xff)
187 printk("dvb_demux.c section ts padding loss: %d/%d\n",
189 printk("dvb_demux.c pad data:");
190 for(i
= 0; i
< n
; i
++)
191 printk(" %02x", sec
->secbuf
[i
]);
197 sec
->tsfeedp
= sec
->secbufp
= sec
->seclen
= 0;
198 sec
->secbuf
= sec
->secbuf_base
;
202 ** Losless Section Demux 1.4.1 by Emard
203 ** Valsecchi Patrick:
204 ** - middle of section A (no PUSI)
205 ** - end of section A and start of section B
206 ** (with PUSI pointing to the start of the second section)
208 ** In this case, without feed->pusi_seen you'll receive a garbage section
209 ** consisting of the end of section A. Basically because tsfeedp
210 ** is incemented and the use=0 condition is not raised
211 ** when the second packet arrives.
214 ** when demux is started, let feed->pusi_seen = 0 to
215 ** prevent initial feeding of garbage from the end of
216 ** previous section. When you for the first time see PUSI=1
217 ** then set feed->pusi_seen = 1
219 static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed
*feed
, const u8
*buf
, u8 len
)
221 struct dvb_demux
*demux
= feed
->demux
;
222 struct dmx_section_feed
*sec
= &feed
->feed
.sec
;
223 u16 limit
, seclen
, n
;
225 if(sec
->tsfeedp
>= DMX_MAX_SECFEED_SIZE
)
228 if(sec
->tsfeedp
+ len
> DMX_MAX_SECFEED_SIZE
)
230 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
231 printk("dvb_demux.c section buffer full loss: %d/%d\n",
232 sec
->tsfeedp
+ len
- DMX_MAX_SECFEED_SIZE
, DMX_MAX_SECFEED_SIZE
);
234 len
= DMX_MAX_SECFEED_SIZE
- sec
->tsfeedp
;
240 demux
->memcopy(feed
, sec
->secbuf_base
+ sec
->tsfeedp
, buf
, len
);
243 /* -----------------------------------------------------
244 ** Dump all the sections we can find in the data (Emard)
247 limit
= sec
->tsfeedp
;
248 if(limit
> DMX_MAX_SECFEED_SIZE
)
249 return -1; /* internal error should never happen */
251 /* to be sure always set secbuf */
252 sec
->secbuf
= sec
->secbuf_base
+ sec
->secbufp
;
254 for(n
= 0; sec
->secbufp
+ 2 < limit
; n
++)
256 seclen
= section_length(sec
->secbuf
);
257 if(seclen
<= 0 || seclen
> DMX_MAX_SECFEED_SIZE
258 || seclen
+ sec
->secbufp
> limit
)
260 sec
->seclen
= seclen
;
262 /* dump [secbuf .. secbuf+seclen) */
264 dvb_dmx_swfilter_section_feed(feed
);
265 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
267 printk("dvb_demux.c pusi not seen, discarding section data\n");
269 sec
->secbufp
+= seclen
; /* secbufp and secbuf moving together is */
270 sec
->secbuf
+= seclen
; /* redundand but saves pointer arithmetic */
277 static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed
*feed
, const u8
*buf
)
283 count
= payload(buf
);
285 if (count
== 0) /* count == 0 if no payload or out of range */
288 p
= 188 - count
; /* payload start */
291 ccok
= ((feed
->cc
+ 1) & 0x0f) == cc
;
295 /* adaption field present, check for discontinuity_indicator */
296 if ((buf
[4] > 0) && (buf
[5] & 0x80))
301 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
302 printk("dvb_demux.c discontinuity detected %d bytes lost\n", count
);
303 /* those bytes under sume circumstances will again be reported
304 ** in the following dvb_dmx_swfilter_section_new
307 /* Discontinuity detected. Reset pusi_seen = 0 to
308 ** stop feeding of suspicious data until next PUSI=1 arrives
311 dvb_dmx_swfilter_section_new(feed
);
315 // PUSI=1 (is set), section boundary is here
316 if (count
> 1 && buf
[p
] < count
) {
317 const u8
*before
= buf
+p
+1;
318 u8 before_len
= buf
[p
];
319 const u8
*after
= before
+before_len
;
320 u8 after_len
= count
-1-before_len
;
322 dvb_dmx_swfilter_section_copy_dump(feed
, before
, before_len
);
323 /* before start of new section, set pusi_seen = 1 */
325 dvb_dmx_swfilter_section_new(feed
);
326 dvb_dmx_swfilter_section_copy_dump(feed
, after
, after_len
);
328 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
331 printk("dvb_demux.c PUSI=1 but %d bytes lost\n", count
);
334 // PUSI=0 (is not set), no section boundary
335 const u8
*entire
= buf
+p
;
336 u8 entire_len
= count
;
338 dvb_dmx_swfilter_section_copy_dump(feed
, entire
, entire_len
);
344 static inline void dvb_dmx_swfilter_packet_type(struct dvb_demux_feed
*feed
, const u8
*buf
)
348 if (!feed
->feed
.ts
.is_filtering
)
350 if (feed
->ts_type
& TS_PACKET
) {
351 if (feed
->ts_type
& TS_PAYLOAD_ONLY
)
352 dvb_dmx_swfilter_payload(feed
, buf
);
354 feed
->cb
.ts(buf
, 188, NULL
, 0, &feed
->feed
.ts
, DMX_OK
);
356 if (feed
->ts_type
& TS_DECODER
)
357 if (feed
->demux
->write_to_decoder
)
358 feed
->demux
->write_to_decoder(feed
, buf
, 188);
362 if (!feed
->feed
.sec
.is_filtering
)
364 if (dvb_dmx_swfilter_section_packet(feed
, buf
) < 0)
365 feed
->feed
.sec
.seclen
= feed
->feed
.sec
.secbufp
=0;
373 #define DVR_FEED(f) \
374 (((f)->type == DMX_TYPE_TS) && \
375 ((f)->feed.ts.is_filtering) && \
376 (((f)->ts_type & (TS_PACKET|TS_PAYLOAD_ONLY)) == TS_PACKET))
378 static void dvb_dmx_swfilter_packet(struct dvb_demux
*demux
, const u8
*buf
)
380 struct dvb_demux_feed
*feed
;
381 struct list_head
*pos
, *head
=&demux
->feed_list
;
382 u16 pid
= ts_pid(buf
);
385 list_for_each(pos
, head
) {
386 feed
= list_entry(pos
, struct dvb_demux_feed
, list_head
);
388 if ((feed
->pid
!= pid
) && (feed
->pid
!= 0x2000))
391 /* copy each packet only once to the dvr device, even
392 * if a PID is in multiple filters (e.g. video + PCR) */
393 if ((DVR_FEED(feed
)) && (dvr_done
++))
396 if (feed
->pid
== pid
) {
397 dvb_dmx_swfilter_packet_type(feed
, buf
);
402 if (feed
->pid
== 0x2000)
403 feed
->cb
.ts(buf
, 188, NULL
, 0, &feed
->feed
.ts
, DMX_OK
);
407 void dvb_dmx_swfilter_packets(struct dvb_demux
*demux
, const u8
*buf
, size_t count
)
409 spin_lock(&demux
->lock
);
413 dvb_dmx_swfilter_packet(demux
, buf
);
418 spin_unlock(&demux
->lock
);
420 EXPORT_SYMBOL(dvb_dmx_swfilter_packets
);
423 void dvb_dmx_swfilter(struct dvb_demux
*demux
, const u8
*buf
, size_t count
)
427 spin_lock(&demux
->lock
);
429 if ((i
= demux
->tsbufp
)) {
430 if (count
< (j
=188-i
)) {
431 memcpy(&demux
->tsbuf
[i
], buf
, count
);
432 demux
->tsbufp
+= count
;
435 memcpy(&demux
->tsbuf
[i
], buf
, j
);
436 if (demux
->tsbuf
[0] == 0x47)
437 dvb_dmx_swfilter_packet(demux
, demux
->tsbuf
);
443 if (buf
[p
] == 0x47) {
444 if (count
-p
>= 188) {
445 dvb_dmx_swfilter_packet(demux
, buf
+p
);
449 memcpy(demux
->tsbuf
, buf
+p
, i
);
458 spin_unlock(&demux
->lock
);
460 EXPORT_SYMBOL(dvb_dmx_swfilter
);
462 void dvb_dmx_swfilter_204(struct dvb_demux
*demux
, const u8
*buf
, size_t count
)
466 spin_lock(&demux
->lock
);
468 if ((i
= demux
->tsbufp
)) {
469 if (count
< (j
=204-i
)) {
470 memcpy(&demux
->tsbuf
[i
], buf
, count
);
471 demux
->tsbufp
+= count
;
474 memcpy(&demux
->tsbuf
[i
], buf
, j
);
475 if ((demux
->tsbuf
[0] == 0x47)|(demux
->tsbuf
[0]==0xB8)) {
476 memcpy(tmppack
, demux
->tsbuf
, 188);
477 if (tmppack
[0] == 0xB8) tmppack
[0] = 0x47;
478 dvb_dmx_swfilter_packet(demux
, tmppack
);
485 if ((buf
[p
] == 0x47)|(buf
[p
] == 0xB8)) {
486 if (count
-p
>= 204) {
487 memcpy(tmppack
, buf
+p
, 188);
488 if (tmppack
[0] == 0xB8) tmppack
[0] = 0x47;
489 dvb_dmx_swfilter_packet(demux
, tmppack
);
493 memcpy(demux
->tsbuf
, buf
+p
, i
);
503 spin_unlock(&demux
->lock
);
505 EXPORT_SYMBOL(dvb_dmx_swfilter_204
);
508 static struct dvb_demux_filter
* dvb_dmx_filter_alloc(struct dvb_demux
*demux
)
512 for (i
=0; i
<demux
->filternum
; i
++)
513 if (demux
->filter
[i
].state
== DMX_STATE_FREE
)
516 if (i
== demux
->filternum
)
519 demux
->filter
[i
].state
= DMX_STATE_ALLOCATED
;
521 return &demux
->filter
[i
];
524 static struct dvb_demux_feed
* dvb_dmx_feed_alloc(struct dvb_demux
*demux
)
528 for (i
=0; i
<demux
->feednum
; i
++)
529 if (demux
->feed
[i
].state
== DMX_STATE_FREE
)
532 if (i
== demux
->feednum
)
535 demux
->feed
[i
].state
= DMX_STATE_ALLOCATED
;
537 return &demux
->feed
[i
];
540 static int dvb_demux_feed_find(struct dvb_demux_feed
*feed
)
542 struct dvb_demux_feed
*entry
;
544 list_for_each_entry(entry
, &feed
->demux
->feed_list
, list_head
)
551 static void dvb_demux_feed_add(struct dvb_demux_feed
*feed
)
553 spin_lock_irq(&feed
->demux
->lock
);
554 if (dvb_demux_feed_find(feed
)) {
555 printk(KERN_ERR
"%s: feed already in list (type=%x state=%x pid=%x)\n",
556 __FUNCTION__
, feed
->type
, feed
->state
, feed
->pid
);
560 list_add(&feed
->list_head
, &feed
->demux
->feed_list
);
562 spin_unlock_irq(&feed
->demux
->lock
);
565 static void dvb_demux_feed_del(struct dvb_demux_feed
*feed
)
567 spin_lock_irq(&feed
->demux
->lock
);
568 if (!(dvb_demux_feed_find(feed
))) {
569 printk(KERN_ERR
"%s: feed not in list (type=%x state=%x pid=%x)\n",
570 __FUNCTION__
, feed
->type
, feed
->state
, feed
->pid
);
574 list_del(&feed
->list_head
);
576 spin_unlock_irq(&feed
->demux
->lock
);
579 static int dmx_ts_feed_set (struct dmx_ts_feed
* ts_feed
, u16 pid
, int ts_type
,
580 enum dmx_ts_pes pes_type
, size_t callback_length
,
581 size_t circular_buffer_size
, int descramble
,
582 struct timespec timeout
)
584 struct dvb_demux_feed
*feed
= (struct dvb_demux_feed
*) ts_feed
;
585 struct dvb_demux
*demux
= feed
->demux
;
587 if (pid
> DMX_MAX_PID
)
590 if (down_interruptible (&demux
->mutex
))
593 if (ts_type
& TS_DECODER
) {
594 if (pes_type
>= DMX_TS_PES_OTHER
) {
599 if (demux
->pesfilter
[pes_type
] &&
600 demux
->pesfilter
[pes_type
] != feed
) {
605 demux
->pesfilter
[pes_type
] = feed
;
606 demux
->pids
[pes_type
] = pid
;
609 dvb_demux_feed_add(feed
);
612 feed
->buffer_size
= circular_buffer_size
;
613 feed
->descramble
= descramble
;
614 feed
->timeout
= timeout
;
615 feed
->cb_length
= callback_length
;
616 feed
->ts_type
= ts_type
;
617 feed
->pes_type
= pes_type
;
619 if (feed
->descramble
) {
624 if (feed
->buffer_size
) {
628 feed
->buffer
= vmalloc(feed
->buffer_size
);
636 feed
->state
= DMX_STATE_READY
;
643 static int dmx_ts_feed_start_filtering(struct dmx_ts_feed
* ts_feed
)
645 struct dvb_demux_feed
*feed
= (struct dvb_demux_feed
*) ts_feed
;
646 struct dvb_demux
*demux
= feed
->demux
;
649 if (down_interruptible (&demux
->mutex
))
652 if (feed
->state
!= DMX_STATE_READY
|| feed
->type
!= DMX_TYPE_TS
) {
657 if (!demux
->start_feed
) {
662 if ((ret
= demux
->start_feed(feed
)) < 0) {
667 spin_lock_irq(&demux
->lock
);
668 ts_feed
->is_filtering
= 1;
669 feed
->state
= DMX_STATE_GO
;
670 spin_unlock_irq(&demux
->lock
);
676 static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed
* ts_feed
)
678 struct dvb_demux_feed
*feed
= (struct dvb_demux_feed
*) ts_feed
;
679 struct dvb_demux
*demux
= feed
->demux
;
682 if (down_interruptible (&demux
->mutex
))
685 if (feed
->state
< DMX_STATE_GO
) {
690 if (!demux
->stop_feed
) {
695 ret
= demux
->stop_feed(feed
);
697 spin_lock_irq(&demux
->lock
);
698 ts_feed
->is_filtering
= 0;
699 feed
->state
= DMX_STATE_ALLOCATED
;
700 spin_unlock_irq(&demux
->lock
);
706 static int dvbdmx_allocate_ts_feed (struct dmx_demux
*dmx
, struct dmx_ts_feed
**ts_feed
,
709 struct dvb_demux
*demux
= (struct dvb_demux
*) dmx
;
710 struct dvb_demux_feed
*feed
;
712 if (down_interruptible (&demux
->mutex
))
715 if (!(feed
= dvb_dmx_feed_alloc(demux
))) {
720 feed
->type
= DMX_TYPE_TS
;
721 feed
->cb
.ts
= callback
;
724 feed
->peslen
= 0xfffa;
727 (*ts_feed
) = &feed
->feed
.ts
;
728 (*ts_feed
)->parent
= dmx
;
729 (*ts_feed
)->priv
= NULL
;
730 (*ts_feed
)->is_filtering
= 0;
731 (*ts_feed
)->start_filtering
= dmx_ts_feed_start_filtering
;
732 (*ts_feed
)->stop_filtering
= dmx_ts_feed_stop_filtering
;
733 (*ts_feed
)->set
= dmx_ts_feed_set
;
736 if (!(feed
->filter
= dvb_dmx_filter_alloc(demux
))) {
737 feed
->state
= DMX_STATE_FREE
;
742 feed
->filter
->type
= DMX_TYPE_TS
;
743 feed
->filter
->feed
= feed
;
744 feed
->filter
->state
= DMX_STATE_READY
;
751 static int dvbdmx_release_ts_feed(struct dmx_demux
*dmx
, struct dmx_ts_feed
*ts_feed
)
753 struct dvb_demux
*demux
= (struct dvb_demux
*) dmx
;
754 struct dvb_demux_feed
*feed
= (struct dvb_demux_feed
*) ts_feed
;
756 if (down_interruptible (&demux
->mutex
))
759 if (feed
->state
== DMX_STATE_FREE
) {
769 feed
->state
= DMX_STATE_FREE
;
770 feed
->filter
->state
= DMX_STATE_FREE
;
772 dvb_demux_feed_del(feed
);
776 if (feed
->ts_type
& TS_DECODER
&& feed
->pes_type
< DMX_TS_PES_OTHER
)
777 demux
->pesfilter
[feed
->pes_type
] = NULL
;
784 /******************************************************************************
785 * dmx_section_feed API calls
786 ******************************************************************************/
788 static int dmx_section_feed_allocate_filter(struct dmx_section_feed
* feed
,
789 struct dmx_section_filter
** filter
)
791 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
792 struct dvb_demux
*dvbdemux
= dvbdmxfeed
->demux
;
793 struct dvb_demux_filter
*dvbdmxfilter
;
795 if (down_interruptible (&dvbdemux
->mutex
))
798 dvbdmxfilter
= dvb_dmx_filter_alloc(dvbdemux
);
800 up(&dvbdemux
->mutex
);
804 spin_lock_irq(&dvbdemux
->lock
);
805 *filter
= &dvbdmxfilter
->filter
;
806 (*filter
)->parent
= feed
;
807 (*filter
)->priv
= NULL
;
808 dvbdmxfilter
->feed
= dvbdmxfeed
;
809 dvbdmxfilter
->type
= DMX_TYPE_SEC
;
810 dvbdmxfilter
->state
= DMX_STATE_READY
;
811 dvbdmxfilter
->next
= dvbdmxfeed
->filter
;
812 dvbdmxfeed
->filter
= dvbdmxfilter
;
813 spin_unlock_irq(&dvbdemux
->lock
);
815 up(&dvbdemux
->mutex
);
820 static int dmx_section_feed_set(struct dmx_section_feed
* feed
,
821 u16 pid
, size_t circular_buffer_size
,
822 int descramble
, int check_crc
)
824 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
825 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
830 if (down_interruptible (&dvbdmx
->mutex
))
833 dvb_demux_feed_add(dvbdmxfeed
);
835 dvbdmxfeed
->pid
= pid
;
836 dvbdmxfeed
->buffer_size
= circular_buffer_size
;
837 dvbdmxfeed
->descramble
= descramble
;
838 if (dvbdmxfeed
->descramble
) {
843 dvbdmxfeed
->feed
.sec
.check_crc
= check_crc
;
846 dvbdmxfeed
->buffer
= NULL
;
848 dvbdmxfeed
->buffer
=vmalloc(dvbdmxfeed
->buffer_size
);
849 if (!dvbdmxfeed
->buffer
) {
855 dvbdmxfeed
->state
= DMX_STATE_READY
;
861 static void prepare_secfilters(struct dvb_demux_feed
*dvbdmxfeed
)
864 struct dvb_demux_filter
*f
;
865 struct dmx_section_filter
*sf
;
866 u8 mask
, mode
, doneq
;
868 if (!(f
=dvbdmxfeed
->filter
))
873 for (i
=0; i
<DVB_DEMUX_MASK_MAX
; i
++) {
874 mode
= sf
->filter_mode
[i
];
875 mask
= sf
->filter_mask
[i
];
876 f
->maskandmode
[i
] = mask
& mode
;
877 doneq
|= f
->maskandnotmode
[i
] = mask
& ~mode
;
879 f
->doneq
= doneq
? 1 : 0;
880 } while ((f
= f
->next
));
884 static int dmx_section_feed_start_filtering(struct dmx_section_feed
*feed
)
886 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
887 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
890 if (down_interruptible (&dvbdmx
->mutex
))
893 if (feed
->is_filtering
) {
898 if (!dvbdmxfeed
->filter
) {
903 dvbdmxfeed
->feed
.sec
.tsfeedp
= 0;
904 dvbdmxfeed
->feed
.sec
.secbuf
= dvbdmxfeed
->feed
.sec
.secbuf_base
;
905 dvbdmxfeed
->feed
.sec
.secbufp
= 0;
906 dvbdmxfeed
->feed
.sec
.seclen
= 0;
908 if (!dvbdmx
->start_feed
) {
913 prepare_secfilters(dvbdmxfeed
);
915 if ((ret
= dvbdmx
->start_feed(dvbdmxfeed
)) < 0) {
920 spin_lock_irq(&dvbdmx
->lock
);
921 feed
->is_filtering
= 1;
922 dvbdmxfeed
->state
= DMX_STATE_GO
;
923 spin_unlock_irq(&dvbdmx
->lock
);
930 static int dmx_section_feed_stop_filtering(struct dmx_section_feed
* feed
)
932 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
933 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
936 if (down_interruptible (&dvbdmx
->mutex
))
939 if (!dvbdmx
->stop_feed
) {
944 ret
= dvbdmx
->stop_feed(dvbdmxfeed
);
946 spin_lock_irq(&dvbdmx
->lock
);
947 dvbdmxfeed
->state
= DMX_STATE_READY
;
948 feed
->is_filtering
= 0;
949 spin_unlock_irq(&dvbdmx
->lock
);
956 static int dmx_section_feed_release_filter(struct dmx_section_feed
*feed
,
957 struct dmx_section_filter
* filter
)
959 struct dvb_demux_filter
*dvbdmxfilter
= (struct dvb_demux_filter
*) filter
, *f
;
960 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
961 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
963 if (down_interruptible (&dvbdmx
->mutex
))
966 if (dvbdmxfilter
->feed
!= dvbdmxfeed
) {
971 if (feed
->is_filtering
)
972 feed
->stop_filtering(feed
);
974 spin_lock_irq(&dvbdmx
->lock
);
975 f
= dvbdmxfeed
->filter
;
977 if (f
== dvbdmxfilter
) {
978 dvbdmxfeed
->filter
= dvbdmxfilter
->next
;
980 while(f
->next
!= dvbdmxfilter
)
982 f
->next
= f
->next
->next
;
985 dvbdmxfilter
->state
= DMX_STATE_FREE
;
986 spin_unlock_irq(&dvbdmx
->lock
);
991 static int dvbdmx_allocate_section_feed(struct dmx_demux
*demux
,
992 struct dmx_section_feed
**feed
,
993 dmx_section_cb callback
)
995 struct dvb_demux
*dvbdmx
= (struct dvb_demux
*) demux
;
996 struct dvb_demux_feed
*dvbdmxfeed
;
998 if (down_interruptible (&dvbdmx
->mutex
))
1001 if (!(dvbdmxfeed
= dvb_dmx_feed_alloc(dvbdmx
))) {
1006 dvbdmxfeed
->type
= DMX_TYPE_SEC
;
1007 dvbdmxfeed
->cb
.sec
= callback
;
1008 dvbdmxfeed
->demux
= dvbdmx
;
1009 dvbdmxfeed
->pid
= 0xffff;
1010 dvbdmxfeed
->feed
.sec
.secbuf
= dvbdmxfeed
->feed
.sec
.secbuf_base
;
1011 dvbdmxfeed
->feed
.sec
.secbufp
= dvbdmxfeed
->feed
.sec
.seclen
= 0;
1012 dvbdmxfeed
->feed
.sec
.tsfeedp
= 0;
1013 dvbdmxfeed
->filter
= NULL
;
1014 dvbdmxfeed
->buffer
= NULL
;
1016 (*feed
)=&dvbdmxfeed
->feed
.sec
;
1017 (*feed
)->is_filtering
= 0;
1018 (*feed
)->parent
= demux
;
1019 (*feed
)->priv
= NULL
;
1021 (*feed
)->set
= dmx_section_feed_set
;
1022 (*feed
)->allocate_filter
= dmx_section_feed_allocate_filter
;
1023 (*feed
)->start_filtering
= dmx_section_feed_start_filtering
;
1024 (*feed
)->stop_filtering
= dmx_section_feed_stop_filtering
;
1025 (*feed
)->release_filter
= dmx_section_feed_release_filter
;
1031 static int dvbdmx_release_section_feed(struct dmx_demux
*demux
,
1032 struct dmx_section_feed
*feed
)
1034 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) feed
;
1035 struct dvb_demux
*dvbdmx
= (struct dvb_demux
*) demux
;
1037 if (down_interruptible (&dvbdmx
->mutex
))
1038 return -ERESTARTSYS
;
1040 if (dvbdmxfeed
->state
==DMX_STATE_FREE
) {
1045 vfree(dvbdmxfeed
->buffer
);
1046 dvbdmxfeed
->buffer
=0;
1048 dvbdmxfeed
->state
=DMX_STATE_FREE
;
1050 dvb_demux_feed_del(dvbdmxfeed
);
1052 dvbdmxfeed
->pid
= 0xffff;
1059 /******************************************************************************
1060 * dvb_demux kernel data API calls
1061 ******************************************************************************/
1063 static int dvbdmx_open(struct dmx_demux
*demux
)
1065 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1067 if (dvbdemux
->users
>= MAX_DVB_DEMUX_USERS
)
1075 static int dvbdmx_close(struct dmx_demux
*demux
)
1077 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1079 if (dvbdemux
->users
== 0)
1083 //FIXME: release any unneeded resources if users==0
1088 static int dvbdmx_write(struct dmx_demux
*demux
, const char *buf
, size_t count
)
1090 struct dvb_demux
*dvbdemux
=(struct dvb_demux
*) demux
;
1092 if ((!demux
->frontend
) || (demux
->frontend
->source
!= DMX_MEMORY_FE
))
1095 if (down_interruptible (&dvbdemux
->mutex
))
1096 return -ERESTARTSYS
;
1097 dvb_dmx_swfilter(dvbdemux
, buf
, count
);
1098 up(&dvbdemux
->mutex
);
1100 if (signal_pending(current
))
1106 static int dvbdmx_add_frontend(struct dmx_demux
*demux
, struct dmx_frontend
*frontend
)
1108 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1109 struct list_head
*head
= &dvbdemux
->frontend_list
;
1111 list_add(&(frontend
->connectivity_list
), head
);
1117 static int dvbdmx_remove_frontend(struct dmx_demux
*demux
, struct dmx_frontend
*frontend
)
1119 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1120 struct list_head
*pos
, *n
, *head
= &dvbdemux
->frontend_list
;
1122 list_for_each_safe (pos
, n
, head
) {
1123 if (DMX_FE_ENTRY(pos
) == frontend
) {
1133 static struct list_head
* dvbdmx_get_frontends(struct dmx_demux
*demux
)
1135 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1137 if (list_empty(&dvbdemux
->frontend_list
))
1139 return &dvbdemux
->frontend_list
;
1143 static int dvbdmx_connect_frontend(struct dmx_demux
*demux
, struct dmx_frontend
*frontend
)
1145 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1147 if (demux
->frontend
)
1150 if (down_interruptible (&dvbdemux
->mutex
))
1151 return -ERESTARTSYS
;
1153 demux
->frontend
= frontend
;
1154 up(&dvbdemux
->mutex
);
1159 static int dvbdmx_disconnect_frontend(struct dmx_demux
*demux
)
1161 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1163 if (down_interruptible (&dvbdemux
->mutex
))
1164 return -ERESTARTSYS
;
1166 demux
->frontend
= NULL
;
1167 up(&dvbdemux
->mutex
);
1172 static int dvbdmx_get_pes_pids(struct dmx_demux
*demux
, u16
*pids
)
1174 struct dvb_demux
*dvbdemux
= (struct dvb_demux
*) demux
;
1176 memcpy(pids
, dvbdemux
->pids
, 5*sizeof(u16
));
1181 int dvb_dmx_init(struct dvb_demux
*dvbdemux
)
1184 struct dmx_demux
*dmx
= &dvbdemux
->dmx
;
1186 dvbdemux
->users
= 0;
1187 dvbdemux
->filter
= vmalloc(dvbdemux
->filternum
*sizeof(struct dvb_demux_filter
));
1189 if (!dvbdemux
->filter
)
1192 dvbdemux
->feed
= vmalloc(dvbdemux
->feednum
*sizeof(struct dvb_demux_feed
));
1193 if (!dvbdemux
->feed
) {
1194 vfree(dvbdemux
->filter
);
1197 for (i
=0; i
<dvbdemux
->filternum
; i
++) {
1198 dvbdemux
->filter
[i
].state
= DMX_STATE_FREE
;
1199 dvbdemux
->filter
[i
].index
= i
;
1201 for (i
=0; i
<dvbdemux
->feednum
; i
++) {
1202 dvbdemux
->feed
[i
].state
= DMX_STATE_FREE
;
1203 dvbdemux
->feed
[i
].index
= i
;
1205 dvbdemux
->frontend_list
.next
=
1206 dvbdemux
->frontend_list
.prev
=
1207 &dvbdemux
->frontend_list
;
1208 for (i
=0; i
<DMX_TS_PES_OTHER
; i
++) {
1209 dvbdemux
->pesfilter
[i
] = NULL
;
1210 dvbdemux
->pids
[i
] = 0xffff;
1213 INIT_LIST_HEAD(&dvbdemux
->feed_list
);
1215 dvbdemux
->playing
= 0;
1216 dvbdemux
->recording
= 0;
1217 dvbdemux
->tsbufp
= 0;
1219 if (!dvbdemux
->check_crc32
)
1220 dvbdemux
->check_crc32
= dvb_dmx_crc32
;
1222 if (!dvbdemux
->memcopy
)
1223 dvbdemux
->memcopy
= dvb_dmx_memcopy
;
1225 dmx
->frontend
= NULL
;
1226 dmx
->priv
= (void *) dvbdemux
;
1227 dmx
->open
= dvbdmx_open
;
1228 dmx
->close
= dvbdmx_close
;
1229 dmx
->write
= dvbdmx_write
;
1230 dmx
->allocate_ts_feed
= dvbdmx_allocate_ts_feed
;
1231 dmx
->release_ts_feed
= dvbdmx_release_ts_feed
;
1232 dmx
->allocate_section_feed
= dvbdmx_allocate_section_feed
;
1233 dmx
->release_section_feed
= dvbdmx_release_section_feed
;
1235 dmx
->descramble_mac_address
= NULL
;
1236 dmx
->descramble_section_payload
= NULL
;
1238 dmx
->add_frontend
= dvbdmx_add_frontend
;
1239 dmx
->remove_frontend
= dvbdmx_remove_frontend
;
1240 dmx
->get_frontends
= dvbdmx_get_frontends
;
1241 dmx
->connect_frontend
= dvbdmx_connect_frontend
;
1242 dmx
->disconnect_frontend
= dvbdmx_disconnect_frontend
;
1243 dmx
->get_pes_pids
= dvbdmx_get_pes_pids
;
1245 sema_init(&dvbdemux
->mutex
, 1);
1246 spin_lock_init(&dvbdemux
->lock
);
1250 EXPORT_SYMBOL(dvb_dmx_init
);
1253 void dvb_dmx_release(struct dvb_demux
*dvbdemux
)
1255 vfree(dvbdemux
->filter
);
1256 vfree(dvbdemux
->feed
);
1258 EXPORT_SYMBOL(dvb_dmx_release
);