struct dmx_demux — Structure that contains the demux capabilities and callbacks.
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);
};  Bitfield of capability flags.
Front-end connected to the demux
Pointer to private data of the API client
   This function reserves the demux for use by the caller and, if
   necessary, initializes the demux. When the demux is no longer needed,
   the function close should be called. It should be possible for
   multiple clients to access the demux at the same time. Thus, the
   function implementation should increment the demux usage count when
   open is called and decrement it when close is called.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   It returns
   0 on success;
   -EUSERS, if maximum usage count was reached;
   -EINVAL, on bad parameter.
      
   This function reserves the demux for use by the caller and, if
   necessary, initializes the demux. When the demux is no longer needed,
   the function close should be called. It should be possible for
   multiple clients to access the demux at the same time. Thus, the
   function implementation should increment the demux usage count when
   open is called and decrement it when close is called.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   It returns
   0 on success;
   -ENODEV, if demux was not in use (e. g. no users);
   -EINVAL, on bad parameter.
      
   This function provides the demux driver with a memory buffer
   containing TS packets. Instead of receiving TS packets from the DVB
   front-end, the demux driver software will read packets from memory.
   Any clients of this demux with active TS, PES or Section filters will
   receive filtered data via the Demux callback API (see 0). The function
   returns when all the data in the buffer has been consumed by the demux.
   Demux hardware typically cannot read TS from memory. If this is the
   case, memory-based filtering has to be implemented entirely in software.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The buf function parameter contains a pointer to the TS data in
   kernel-space memory.
   The count 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.
      
   Allocates a new TS feed, which is used to filter the TS
   packets carrying a certain PID. The TS feed normally corresponds to a
   hardware PID filter on the demux chip.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The feed function parameter contains a pointer to the TS feed API and
   instance data.
   The callback function parameter contains a pointer to the callback
   function 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.
      
   Releases the resources allocated with allocate_ts_feed.
   Any filtering in progress on the TS feed should be stopped before
   calling this function.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The feed function parameter contains a pointer to the TS feed API and
   instance data.
   It returns
   0 on success;
   -EINVAL on bad parameter.
      
   Allocates a new section feed, i.e. a demux resource
   for filtering and receiving sections. On platforms with hardware
   support for section filtering, a section feed is directly mapped to
   the demux HW. On other platforms, TS packets are first PID filtered in
   hardware and a hardware section filter then emulated in software. The
   caller obtains an API pointer of type dmx_section_feed_t as an out
   parameter. Using this API the caller can set filtering parameters and
   start receiving sections.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The feed function parameter contains a pointer to the TS feed API and
   instance data.
   The callback function parameter contains a pointer to the callback
   function for passing received TS packet.
   It returns
   0 on success;
   -EBUSY, if no more TS feeds is available;
   -EINVAL, on bad parameter.
      
   Releases the resources allocated with
   allocate_section_feed, including allocated filters. Any filtering in
   progress on the section feed should be stopped before calling this
   function.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The feed function parameter contains a pointer to the TS feed API and
   instance data.
   It returns
   0 on success;
   -EINVAL, on bad parameter.
      
   Registers a connectivity between a demux and a front-end,
   i.e., indicates that the demux can be connected via a call to
   connect_frontend to use the given front-end as a TS source. The
   client of this function has to allocate dynamic or static memory for
   the frontend structure and initialize its fields before calling this
   function. This function is normally called during the driver
   initialization. The caller must not free the memory of the frontend
   struct before successfully calling remove_frontend.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The frontend function parameter contains a pointer to the front-end
   instance data.
   It returns
   0 on success;
   -EINVAL, on bad parameter.
      
   Indicates that the given front-end, registered by a call
   to add_frontend, can no longer be connected as a TS source by this
   demux. The function should be called when a front-end driver or a demux
   driver is removed from the system. If the front-end is in use, the
   function fails with the return value of -EBUSY. After successfully
   calling this function, the caller can free the memory of the frontend
   struct if it was dynamically allocated before the add_frontend
   operation.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The frontend function parameter contains a pointer to the front-end
   instance data.
   It returns
   0 on success;
   -ENODEV, if the front-end was not found,
   -EINVAL, on bad parameter.
      
   Provides the APIs of the front-ends that have been
   registered for this demux. Any of the front-ends obtained with this
   call can be used as a parameter for connect_frontend. The include
   file demux.h contains the macro DMX_FE_ENTRY for converting an
   element of the generic type struct list_head * to the type
   struct dmx_frontend *. The caller must not free the memory of any of
   the elements obtained via this function call.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   It returns a struct list_head pointer to the list of front-end
   interfaces, or NULL in the case of an empty list.
      
   Connects the TS output of the front-end to the input of
   the demux. A demux can only be connected to a front-end registered to
   the demux with the function add_frontend. It may or may not be
   possible to connect multiple demuxes to the same front-end, depending
   on the capabilities of the HW platform. When not used, the front-end
   should be released by calling disconnect_frontend.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The frontend function parameter contains a pointer to the front-end
   instance data.
   It returns
   0 on success;
   -EINVAL, on bad parameter.
      
   Disconnects the demux and a front-end previously
   connected by a connect_frontend call.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   It returns
   0 on success;
   -EINVAL on bad parameter.
      
   Get the PIDs for DMX_PES_AUDIO0, DMX_PES_VIDEO0,
   DMX_PES_TELETEXT0, DMX_PES_SUBTITLE0 and DMX_PES_PCR0.
   The demux function parameter contains a pointer to the demux API and
   instance data.
   The pids function parameter contains an array with five u16 elements
   where the PIDs will be stored.
   It returns
   0 on success;
   -EINVAL on bad parameter.