Constants

DMXDEV_TYPE_NONE

no filter set.

DMXDEV_TYPE_SEC

section filter.

DMXDEV_TYPE_PES

Program Elementary Stream (PES) filter.

Constants

DMXDEV_STATE_FREE

indicates that the filter is freed.

DMXDEV_STATE_ALLOCATED

indicates that the filter was allocatedto be used.

DMXDEV_STATE_SET

indicates that the filter parameters are set.

DMXDEV_STATE_GO

indicates that the filter is running.

DMXDEV_STATE_DONE

indicates that a packet was already filteredand the filter is now disabled.Set only ifDMX_ONESHOT. Seedmx_sct_filter_params.

DMXDEV_STATE_TIMEDOUT

Indicates a timeout condition.

Definition:

struct dmxdev_feed {    u16 pid;    struct dmx_ts_feed *ts;    struct list_head next;};

Members

pid

Program ID to be filtered

ts

pointer tostructdmx_ts_feed

next

structlist_head pointing to the next feed.

Definition:

struct dmxdev_filter {    union {        struct dmx_section_filter *sec;    } filter;    union {        struct list_head ts;        struct dmx_section_feed *sec;    } feed;    union {        struct dmx_sct_filter_params sec;        struct dmx_pes_filter_params pes;    } params;    enum dmxdev_type type;    enum dmxdev_state state;    struct dmxdev *dev;    struct dvb_ringbuffer buffer;    struct dvb_vb2_ctx vb2_ctx;    struct mutex mutex;    struct timer_list timer;    int todo;    u8 secheader[3];};

Members

filter

auniondescribing a dmxdev filter.Currently used only for section filters.

filter.sec

astructdmx_section_filter pointer.For section filter only.

feed

auniondescribing a dmxdev feed.Depending on the filter type, it can be eitherfeed.ts orfeed.sec.

feed.ts

astructlist_head list.For TS and PES feeds.

feed.sec

astructdmx_section_feed pointer.For section feed only.

params

auniondescribing dmxdev filter parameters.Depending on the filter type, it can be eitherparams.sec orparams.pes.

params.sec

astructdmx_sct_filter_params embedded struct.For section filter only.

params.pes

astructdmx_pes_filter_params embedded struct.For PES filter only.

type

type of the dmxdev filter, as defined byenumdmxdev_type.

state

state of the dmxdev filter, as defined byenumdmxdev_state.

dev

pointer tostructdmxdev.

buffer

an embeddedstructdvb_ringbuffer buffer.

vb2_ctx

control struct for VB2 handler

mutex

protects the access tostructdmxdev_filter.

timer

structtimer_list embedded timer, used to check forfeed timeouts.Only for section filter.

todo

index for thesecheader.Only for section filter.

secheader

buffer cache to parse the section header.Only for section filter.

Definition:

struct dmxdev {    struct dvb_device *dvbdev;    struct dvb_device *dvr_dvbdev;    struct dmxdev_filter *filter;    struct dmx_demux *demux;    int filternum;    int capabilities;    unsigned int may_do_mmap:1;    unsigned int exit:1;#define DMXDEV_CAP_DUPLEX 1;    struct dmx_frontend *dvr_orig_fe;    struct dvb_ringbuffer dvr_buffer;#define DVR_BUFFER_SIZE (10*188*1024);    struct dvb_vb2_ctx dvr_vb2_ctx;    struct mutex mutex;    spinlock_t lock;};

Members

dvbdev

pointer tostructdvb_device associated withthe demux device node.

dvr_dvbdev

pointer tostructdvb_device associated withthe dvr device node.

filter

pointer tostructdmxdev_filter.

demux

pointer tostructdmx_demux.

filternum

number of filters.

capabilities

demux capabilities as defined byenumdmx_demux_caps.

may_do_mmap

flag used to indicate if the device may do mmap.

exit

flag to indicate that the demux is being released.

dvr_orig_fe

pointer tostructdmx_frontend.

dvr_buffer

embeddedstructdvb_ringbuffer for DVB output.

dvr_vb2_ctx

control struct for VB2 handler

mutex

protects the usage of this structure.

lock

protects access todmxdev->filter->data.

Parameters

structdmxdev*dmxdev

pointer tostructdmxdev.

structdvb_adapter*adap

pointer tostructdvb_adapter.

Parameters

structdmxdev*dmxdev

pointer tostructdmxdev.

Constants

DMX_TYPE_TS

feed is in TS mode.

DMX_TYPE_SEC

feed is in Section mode.

Constants

DMX_STATE_FREE

indicates that the filter is freed.

DMX_STATE_ALLOCATED

indicates that the filter was allocatedto be used.

DMX_STATE_READY

indicates that the filter is readyto be used.

DMX_STATE_GO

indicates that the filter is running.

Definition:

struct dvb_demux_filter {    struct dmx_section_filter filter;    u8 maskandmode[DMX_MAX_FILTER_SIZE];    u8 maskandnotmode[DMX_MAX_FILTER_SIZE];    bool doneq;    struct dvb_demux_filter *next;    struct dvb_demux_feed *feed;    int index;    enum dvb_dmx_state state;    enum dvb_dmx_filter_type type;};

Members

filter

Section filter as defined bystructdmx_section_filter.

maskandmode

logicaland bit mask.

maskandnotmode

logicalandnot bit mask.

doneq

flag that indicates when a filter is ready.

next

pointer to the next section filter.

feed

structdvb_demux_feed pointer.

index

index of the used demux filter.

state

state of the filter as described byenumdvb_dmx_state.

type

type of the filter as describedbyenumdvb_dmx_filter_type.

Definition:

struct dvb_demux_feed {    union {        struct dmx_ts_feed ts;        struct dmx_section_feed sec;    } feed;    union {        dmx_ts_cb ts;        dmx_section_cb sec;    } cb;    struct dvb_demux *demux;    void *priv;    enum dvb_dmx_filter_type type;    enum dvb_dmx_state state;    u16 pid;    ktime_t timeout;    struct dvb_demux_filter *filter;    u32 buffer_flags;    enum ts_filter_type ts_type;    enum dmx_ts_pes pes_type;    int cc;    bool pusi_seen;    u16 peslen;    struct list_head list_head;    unsigned int index;};

Members

feed

auniondescribing a digital TV feed.Depending on the feed type, it can be eitherfeed.ts orfeed.sec.

feed.ts

astructdmx_ts_feed pointer.For TS feed only.

feed.sec

astructdmx_section_feed pointer.For section feed only.

cb

auniondescribing digital TV callbacks.Depending on the feed type, it can be eithercb.ts orcb.sec.

cb.ts

admx_ts_cb() calback function pointer.For TS feed only.

cb.sec

admx_section_cb() callback function pointer.For section feed only.

demux

pointer tostructdvb_demux.

priv

private data that can optionally be used by a DVB driver.

type

type of the filter, as defined byenumdvb_dmx_filter_type.

state

state of the filter as defined byenumdvb_dmx_state.

pid

PID to be filtered.

timeout

feed timeout.

filter

pointer tostructdvb_demux_filter.

buffer_flags

Buffer flags used to report discontinuity users via DVBmemory mapped API, as defined byenumdmx_buffer_flags.

ts_type

type of TS, as defined byenumts_filter_type.

pes_type

type of PES, as defined byenumdmx_ts_pes.

cc

MPEG-TS packet continuity counter

pusi_seen

if true, indicates that a discontinuity was detected.it is used to prevent feeding of garbage from previous section.

peslen

length of the PES (Packet Elementary Stream).

list_head

head for the list of digital TV demux feeds.

index

a unique index for each feed. Can be used as hardwarepid filter index.

Definition:

struct dvb_demux {    struct dmx_demux dmx;    void *priv;    int filternum;    int feednum;    int (*start_feed)(struct dvb_demux_feed *feed);    int (*stop_feed)(struct dvb_demux_feed *feed);    int (*write_to_decoder)(struct dvb_demux_feed *feed, const u8 *buf, size_t len);    u32 (*check_crc32)(struct dvb_demux_feed *feed, const u8 *buf, size_t len);    void (*memcopy)(struct dvb_demux_feed *feed, u8 *dst, const u8 *src, size_t len);    int users;#define MAX_DVB_DEMUX_USERS 10;    struct dvb_demux_filter *filter;    struct dvb_demux_feed *feed;    struct list_head frontend_list;    struct dvb_demux_feed *pesfilter[DMX_PES_OTHER];    u16 pids[DMX_PES_OTHER];#define DMX_MAX_PID 0x2000;    struct list_head feed_list;    u8 tsbuf[204];    int tsbufp;    struct mutex mutex;    spinlock_t lock;    uint8_t *cnt_storage;    ktime_t speed_last_time;    uint32_t speed_pkts_cnt;};

Members

dmx

embeddedstructdmx_demux with demux capabilitiesand callbacks.

priv

private data that can optionally be used bya DVB driver.

filternum

maximum amount of DVB filters.

feednum

maximum amount of DVB feeds.

start_feed

callback routine to be called in order to starta DVB feed.

stop_feed

callback routine to be called in order to stopa DVB feed.

write_to_decoder

callback routine to be called if the feed is TS andit is routed to an A/V decoder, when a new TS packetis received.Used only on av7110-av.c.

check_crc32

callback routine to check CRC. If not initialized,dvb_demux will use an internal one.

memcopy

callback routine to memcopy received data.If not initialized, dvb_demux will default tomemcpy().

users

counter for the number of demux opened file descriptors.Currently, it is limited to 10 users.

filter

pointer tostructdvb_demux_filter.

feed

pointer tostructdvb_demux_feed.

frontend_list

structlist_head with frontends used by the demux.

pesfilter

array ofstructdvb_demux_feed with the PES typesthat will be filtered.

pids

list of filtered program IDs.

feed_list

structlist_head with feeds.

tsbuf

temporary buffer used internally to store TS packets.

tsbufp

temporary buffer index used internally.

mutex

pointer tostructmutex used to protect feed setlogic.

lock

pointer tospinlock_t, used to protect buffer handling.

cnt_storage

buffer used for TS/TEI continuity check.

speed_last_time

ktime_t used for TS speed check.

speed_pkts_cnt

packets count used for TS speed check.

Parameters

structdvb_demux*demux

structdvb_demux to be initialized.

Description

Before being able to register a digital TV demux struct, driversshould call this routine. On its typical usage, some fields shouldbe initialized at the driver before calling it.

A typical usecase is:

dvb->demux.dmx.capabilities =        DMX_TS_FILTERING | DMX_SECTION_FILTERING |        DMX_MEMORY_BASED_FILTERING;dvb->demux.priv       = dvb;dvb->demux.filternum  = 256;dvb->demux.feednum    = 256;dvb->demux.start_feed = driver_start_feed;dvb->demux.stop_feed  = driver_stop_feed;ret = dvb_dmx_init(&dvb->demux);if (ret < 0)        return ret;

Parameters

structdvb_demux*demux

structdvb_demux to be released.

Description

The DVB core internally allocates data atdemux. This routinereleases those data. Please notice that thestructitelf is notreleased, as it can be embedded on other structs.

Parameters

structdvb_demux*demux

pointer tostructdvb_demux

constu8*buf

buffer with data to be filtered

size_tcount

number of MPEG-TS packets with size of 188.

Description

The routine will discard a DVB packet that don’t start with 0x47.

Use this routine if the DVB demux fills MPEG-TS buffers that arealready aligned.

NOTE

Thebuf size should have size equal tocount*188.

Parameters

structdvb_demux*demux

pointer tostructdvb_demux

constu8*buf

buffer with data to be filtered

size_tcount

number of MPEG-TS packets with size of 188.

Description

If a DVB packet doesn’t start with 0x47, it will seek for the firstbyte that starts with 0x47.

Use this routine if the DVB demux fill buffers that may not start witha packet start mark (0x47).

NOTE

Thebuf size should have size equal tocount*188.

Parameters

structdvb_demux*demux

pointer tostructdvb_demux

constu8*buf

buffer with data to be filtered

size_tcount

number of MPEG-TS packets with size of 204.

Description

If a DVB packet doesn’t start with 0x47, it will seek for the firstbyte that starts with 0x47.

Use this routine if the DVB demux fill buffers that may not start witha packet start mark (0x47).

NOTE

Thebuf size should have size equal tocount*204.

Parameters

structdvb_demux*demux

pointer tostructdvb_demux

constu8*buf

buffer with data

size_tcount

number of packets to be passed. The actual size of each packetdepends on thedvb_demux->feed->cb.ts logic.

Description

Use it if the driver needs to deliver the raw payload to userspace withoutpassing through the kernel demux. That is meant to support somedelivery systems that aren’t based on MPEG-TS.

This function relies ondvb_demux->feed->cb.ts to actually handle thebuffer.

Constants

TS_PACKET

Send TS packets (188 bytes) to callback (default).

TS_PAYLOAD_ONLY

In case TS_PACKET is set, only send the TS payload(<=184 bytes per packet) to callback

TS_DECODER

Send stream to built-in decoder (if present).

TS_DEMUX

In case TS_PACKET is set, send the TS to the demuxdevice, not to the dvr device

Definition:

struct dmx_ts_feed {    int is_filtering;    struct dmx_demux *parent;    void *priv;    int (*set)(struct dmx_ts_feed *feed, u16 pid, int type, enum dmx_ts_pes pes_type, ktime_t timeout);    int (*start_filtering)(struct dmx_ts_feed *feed);    int (*stop_filtering)(struct dmx_ts_feed *feed);};

Members

is_filtering

Set to non-zero when filtering in progress

parent

pointer tostructdmx_demux

priv

pointer to private data of the API client

set

sets the TS filter

start_filtering

starts TS filtering

stop_filtering

stops TS filtering

Definition:

struct dmx_section_filter {    u8 filter_value[DMX_MAX_FILTER_SIZE];    u8 filter_mask[DMX_MAX_FILTER_SIZE];    u8 filter_mode[DMX_MAX_FILTER_SIZE];    struct dmx_section_feed *parent;    void *priv;};

Members

filter_value

Contains up to 16 bytes (128 bits) of the TS section headerthat will be matched by the section filter

filter_mask

Contains a 16 bytes (128 bits) filter mask with the bitsspecified byfilter_value that will be used on the filtermatch logic.

filter_mode

Contains a 16 bytes (128 bits) filter mode.

parent

Back-pointer tostructdmx_section_feed.

priv

Pointer to private data of the API client.

Definition:

struct dmx_section_feed {    int is_filtering;    struct dmx_demux *parent;    void *priv;    int check_crc;    int (*set)(struct dmx_section_feed *feed, u16 pid, int check_crc);    int (*allocate_filter)(struct dmx_section_feed *feed, struct dmx_section_filter **filter);    int (*release_filter)(struct dmx_section_feed *feed, struct dmx_section_filter *filter);    int (*start_filtering)(struct dmx_section_feed *feed);    int (*stop_filtering)(struct dmx_section_feed *feed);};

Members

is_filtering

Set to non-zero when filtering in progress

parent

pointer tostructdmx_demux

priv

pointer to private data of the API client

check_crc

If non-zero, check the CRC values of filtered sections.

set

sets the section filter

allocate_filter

This function is used to allocate a section filter onthe demux. It should only be called when no filteringis in progress on this section feed. If a filter cannotbe allocated, the function fails with -ENOSPC.

release_filter

This function releases all the resources of apreviously allocated section filter. The functionshould not be called while filtering is in progresson this section feed. After calling this function,the caller should not try to dereference the filterpointer.

start_filtering

starts section filtering

stop_filtering

stops section filtering

Parameters

constu8*buffer1

Pointer to the start of the filtered TS packets.

size_tbuffer1_length

Length of the TS data in buffer1.

constu8*buffer2

Pointer to the tail of the filtered TS packets, or NULL.

size_tbuffer2_length

Length of the TS data in buffer2.

structdmx_ts_feed*source

Indicates which TS feed is the source of the callback.

u32*buffer_flags

Address where buffer flags are stored. Those areused to report discontinuity users via DVBmemory mapped API, as defined byenumdmx_buffer_flags.

Description

This function callback prototype, provided by the client of the demux API,is called from the demux code. The function is only called when filteringon a TS feed has been enabled using thestart_filtering() function atthedmx_demux.Any TS packets that match the filter settings are copied to a circularbuffer. The filtered TS packets are delivered to the client using thiscallback function.It is expected that thebuffer1 andbuffer2 callback parameters point toaddresses within the circular buffer, but other implementations are alsopossible. Note that the called party should not try to free the memorythebuffer1 andbuffer2 parameters point to.

When this function is called, thebuffer1 parameter typically points tothe start of the first undelivered TS packet within a circular buffer.Thebuffer2 buffer parameter is normally NULL, except when the receivedTS packets have crossed the last address of the circular buffer and“wrapped” to the beginning of the buffer. In the latter case thebuffer1parameter would contain an address within the circular buffer, while thebuffer2 parameter would contain the first address of the circular buffer.The number of bytes delivered with this function (i.e.buffer1_length +buffer2_length) is usually equal to the value of callback_length parametergiven in theset() function, with one exception: if a timeout occurs beforereceiving callback_length bytes of TS data, any undelivered packets areimmediately delivered to the client by calling this function. The timeoutduration is controlled by theset() function in the TS Feed API.

If a TS packet is received with errors that could not be fixed by theTS-level forward error correction (FEC), the Transport_error_indicatorflag of the TS packet header should be set. The TS packet should not bediscarded, as the error can possibly be corrected by a higher layerprotocol. If the called party is slow in processing the callback, itis possible that the circular buffer eventually fills up. If this happens,the demux driver should discard any TS packets received while the bufferis full and return -EOVERFLOW.

The type of data returned to the callback can be selected by thedmx_ts_feed.**set** function. The type parameter decides if the rawTS packet (TS_PACKET) or just the payload (TS_PACKET|TS_PAYLOAD_ONLY)should be returned. If additionally the TS_DECODER bit is set the streamwill also be sent to the hardware MPEG decoder.

• 0, on success;

• -EOVERFLOW, on buffer overflow.

Parameters

constu8*buffer1

Pointer to the start of the filtered section, e.g.within the circular buffer of the demux driver.

size_tbuffer1_len

Length of the filtered section data inbuffer1,including headers and CRC.

constu8*buffer2

Pointer to the tail of the filtered section data,or NULL. Useful to handle the wrapping of acircular buffer.

size_tbuffer2_len

Length of the filtered section data inbuffer2,including headers and CRC.

structdmx_section_filter*source

Indicates which section feed is the source of thecallback.

u32*buffer_flags

Address where buffer flags are stored. Those areused to report discontinuity users via DVBmemory mapped API, as defined byenumdmx_buffer_flags.

Description

This function callback prototype, provided by the client of the demux API,is called from the demux code. The function is only called whenfiltering of sections has been enabled using the functiondmx_ts_feed.**start_filtering**. When the demux driver has received acomplete section that matches at least one section filter, the clientis notified via this callback function. Normally this function is calledfor each received section; however, it is also possible to delivermultiple sections with one callback, for example when the system loadis high. If an error occurs while receiving a section, thisfunction should be called with the corresponding error type set in thesuccess field, whether or not there is data to deliver. The Section Feedimplementation should maintain a circular buffer for received sections.However, this is not necessary if the Section Feed API is implemented asa client of the TS Feed API, because the TS Feed implementation thenbuffers the received data. The size of the circular buffer can beconfigured using thedmx_ts_feed.**set** function in the Section Feed API.If there is no room in the circular buffer when a new section is received,the section must be discarded. If this happens, the value of the successparameter should be DMX_OVERRUN_ERROR on the next callback.

Constants

DMX_MEMORY_FE

The source of the demux is memory. It means thatthe MPEG-TS to be filtered comes from userspace,via write() syscall.

DMX_FRONTEND_0

The source of the demux is a frontend connectedto the demux.

Definition:

struct dmx_frontend {    struct list_head connectivity_list;    enum dmx_frontend_source source;};

Members

connectivity_list

List of front-ends that can be connected to aparticular demux;

source

Type of the frontend.

Constants

DMX_TS_FILTERING

set if TS filtering is supported;

DMX_SECTION_FILTERING

set if section filtering is supported;

DMX_MEMORY_BASED_FILTERING

set if write() available.

Parameters

list

list ofstructdmx_frontend

Definition:

struct dmx_demux {    enum dmx_demux_caps capabilities;    struct dmx_frontend *frontend;    void *priv;    int (*open)(struct dmx_demux *demux);    int (*close)(struct dmx_demux *demux);    int (*write)(struct dmx_demux *demux, const char __user *buf, size_t count);    int (*allocate_ts_feed)(struct dmx_demux *demux, struct dmx_ts_feed **feed, dmx_ts_cb callback);    int (*release_ts_feed)(struct dmx_demux *demux, struct dmx_ts_feed *feed);    int (*allocate_section_feed)(struct dmx_demux *demux, struct dmx_section_feed **feed, dmx_section_cb callback);    int (*release_section_feed)(struct dmx_demux *demux, struct dmx_section_feed *feed);    int (*add_frontend)(struct dmx_demux *demux, struct dmx_frontend *frontend);    int (*remove_frontend)(struct dmx_demux *demux, struct dmx_frontend *frontend);    struct list_head *(*get_frontends)(struct dmx_demux *demux);    int (*connect_frontend)(struct dmx_demux *demux, struct dmx_frontend *frontend);    int (*disconnect_frontend)(struct dmx_demux *demux);    int (*get_pes_pids)(struct dmx_demux *demux, u16 *pids);};

Members

capabilities

Bitfield of capability flags.

frontend

Front-end connected to the demux

priv

Pointer to private data of the API client

open

This function reserves the demux for use by the caller and, ifnecessary, initializes the demux. When the demux is no longer needed,the functionclose should be called. It should be possible formultiple clients to access the demux at the same time. Thus, thefunction implementation should increment the demux usage count whenopen is called and decrement it whenclose is called.Thedemux function parameter contains a pointer to the demux API andinstance data.It returns:0 on success;-EUSERS, if maximum usage count was reached;-EINVAL, on bad parameter.

close

This function reserves the demux for use by the caller and, ifnecessary, initializes the demux. When the demux is no longer needed,the functionclose should be called. It should be possible formultiple clients to access the demux at the same time. Thus, thefunction implementation should increment the demux usage count whenopen is called and decrement it whenclose is called.Thedemux function parameter contains a pointer to the demux API andinstance data.It returns:0 on success;-ENODEV, if demux was not in use (e. g. no users);-EINVAL, on bad parameter.

write

This function provides the demux driver with a memory buffercontaining TS packets. Instead of receiving TS packets from the DVBfront-end, the demux driver software will read packets from memory.Any clients of this demux with active TS, PES or Section filters willreceive filtered data via the Demux callback API (see 0). The functionreturns when all the data in the buffer has been consumed by the demux.Demux hardware typically cannot read TS from memory. If this is thecase, memory-based filtering has to be implemented entirely in software.Thedemux function parameter contains a pointer to the demux API andinstance data.Thebuf function parameter contains a pointer to the TS data inkernel-space memory.Thecount function parameter contains the length of the TS data.It returns:0 on success;-ERESTARTSYS, if mutex lock was interrupted;-EINTR, if a signal handling is pending;-ENODEV, if demux was removed;-EINVAL, on bad parameter.

allocate_ts_feed

Allocates a new TS feed, which is used to filter the TSpackets carrying a certain PID. The TS feed normally corresponds to ahardware PID filter on the demux chip.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefeed function parameter contains a pointer to the TS feed API andinstance data.Thecallback function parameter contains a pointer to the callbackfunction for passing received TS packet.It returns:0 on success;-ERESTARTSYS, if mutex lock was interrupted;-EBUSY, if no more TS feeds is available;-EINVAL, on bad parameter.

release_ts_feed

Releases the resources allocated withallocate_ts_feed.Any filtering in progress on the TS feed should be stopped beforecalling this function.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefeed function parameter contains a pointer to the TS feed API andinstance data.It returns:0 on success;-EINVAL on bad parameter.

allocate_section_feed

Allocates a new section feed, i.e. a demux resourcefor filtering and receiving sections. On platforms with hardwaresupport for section filtering, a section feed is directly mapped tothe demux HW. On other platforms, TS packets are first PID filtered inhardware and a hardware section filter then emulated in software. Thecaller obtains an API pointer of type dmx_section_feed_t as an outparameter. Using this API the caller can set filtering parameters andstart receiving sections.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefeed function parameter contains a pointer to the TS feed API andinstance data.Thecallback function parameter contains a pointer to the callbackfunction for passing received TS packet.It returns:0 on success;-EBUSY, if no more TS feeds is available;-EINVAL, on bad parameter.

release_section_feed

Releases the resources allocated withallocate_section_feed, including allocated filters. Any filtering inprogress on the section feed should be stopped before calling thisfunction.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefeed function parameter contains a pointer to the TS feed API andinstance data.It returns:0 on success;-EINVAL, on bad parameter.

add_frontend

Registers a connectivity between a demux and a front-end,i.e., indicates that the demux can be connected via a call toconnect_frontend to use the given front-end as a TS source. Theclient of this function has to allocate dynamic or static memory forthe frontend structure and initialize its fields before calling thisfunction. This function is normally called during the driverinitialization. The caller must not free the memory of the frontendstructbefore successfully callingremove_frontend.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefrontend function parameter contains a pointer to the front-endinstance data.It returns:0 on success;-EINVAL, on bad parameter.

remove_frontend

Indicates that the given front-end, registered by a calltoadd_frontend, can no longer be connected as a TS source by thisdemux. The function should be called when a front-end driver or a demuxdriver is removed from the system. If the front-end is in use, thefunction fails with the return value of -EBUSY. After successfullycalling this function, the caller can free the memory of the frontendstruct if it was dynamically allocated before theadd_frontendoperation.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefrontend function parameter contains a pointer to the front-endinstance data.It returns:0 on success;-ENODEV, if the front-end was not found,-EINVAL, on bad parameter.

get_frontends

Provides the APIs of the front-ends that have beenregistered for this demux. Any of the front-ends obtained with thiscall can be used as a parameter forconnect_frontend. The includefile demux.h contains the macroDMX_FE_ENTRY() for converting anelement of the generic type structlist_head * to the typestructdmx_frontend. The caller must not free the memory of any ofthe elements obtained via this function call.The **demux* function parameter contains a pointer to the demux API andinstance data.It returns astructlist_head pointer to the list of front-endinterfaces, or NULL in the case of an empty list.

connect_frontend

Connects the TS output of the front-end to the input ofthe demux. A demux can only be connected to a front-end registered tothe demux with the functionadd_frontend. It may or may not bepossible to connect multiple demuxes to the same front-end, dependingon the capabilities of the HW platform. When not used, the front-endshould be released by callingdisconnect_frontend.Thedemux function parameter contains a pointer to the demux API andinstance data.Thefrontend function parameter contains a pointer to the front-endinstance data.It returns:0 on success;-EINVAL, on bad parameter.

disconnect_frontend

Disconnects the demux and a front-end previouslyconnected by aconnect_frontend call.Thedemux function parameter contains a pointer to the demux API andinstance data.It returns:0 on success;-EINVAL on bad parameter.

get_pes_pids

Get the PIDs for DMX_PES_AUDIO0, DMX_PES_VIDEO0,DMX_PES_TELETEXT0, DMX_PES_SUBTITLE0 and DMX_PES_PCR0.Thedemux function parameter contains a pointer to the demux API andinstance data.Thepids function parameter contains an array with five u16 elementswhere the PIDs will be stored.It returns:0 on success;-EINVAL on bad parameter.