all: clean up cDemux headers

include/ca.h

@@ -0,0 +1,126 @@
+/*
+ * dummy functions to implement ca_cs.h interface
+ */
+#if HAVE_DUCKBOX_HARDWARE || HAVE_ARM_HARDWARE
+#include "ca_ci.h"
+#else
+#ifndef __CA_LIBTRIPLE_H_
+#define __CA_LIBTRIPLE_H_
+
+#include <stdint.h>
+#include "cs_types.h"
+#include <vector>
+#include <set>
+typedef std::vector<u16>			CaIdVector;
+typedef std::vector<u16>::iterator		CaIdVectorIterator;
+typedef std::vector<u16>::const_iterator	CaIdVectorConstIterator;
+
+enum CA_INIT_MASK {
+	CA_INIT_SC = 1,
+	CA_INIT_CI,
+	CA_INIT_BOTH
+};
+
+enum CA_SLOT_TYPE {
+	CA_SLOT_TYPE_SMARTCARD,
+	CA_SLOT_TYPE_CI,
+	CA_SLOT_TYPE_ALL
+};
+
+enum CA_MESSAGE_FLAGS {
+	CA_MESSAGE_EMPTY		= (1 << 0),
+	CA_MESSAGE_HAS_PARAM1_DATA	= (1 << 1), // Free after use!
+	CA_MESSAGE_HAS_PARAM1_INT	= (1 << 2),
+	CA_MESSAGE_HAS_PARAM1_PTR	= (1 << 3),
+	CA_MESSAGE_HAS_PARAM2_INT	= (1 << 4),
+	CA_MESSAGE_HAS_PARAM2_PTR	= (1 << 5),
+	CA_MESSAGE_HAS_PARAM2_DATA	= (1 << 6),
+	CA_MESSAGE_HAS_PARAM3_DATA	= (1 << 7), // Free after use!
+	CA_MESSAGE_HAS_PARAM3_INT	= (1 << 8),
+	CA_MESSAGE_HAS_PARAM3_PTR	= (1 << 9),
+	CA_MESSAGE_HAS_PARAM4_INT	= (1 << 10),
+	CA_MESSAGE_HAS_PARAM4_PTR	= (1 << 11),
+	CA_MESSAGE_HAS_PARAM4_DATA	= (1 << 12),
+	CA_MESSAGE_HAS_PARAM5_INT	= (1 << 13),
+	CA_MESSAGE_HAS_PARAM5_PTR	= (1 << 14),
+	CA_MESSAGE_HAS_PARAM5_DATA	= (1 << 15),
+	CA_MESSAGE_HAS_PARAM6_INT	= (1 << 16),
+	CA_MESSAGE_HAS_PARAM6_PTR	= (1 << 17),
+	CA_MESSAGE_HAS_PARAM6_DATA	= (1 << 18),
+	CA_MESSAGE_HAS_PARAM1_LONG	= (1 << 19),
+	CA_MESSAGE_HAS_PARAM2_LONG	= (1 << 20),
+	CA_MESSAGE_HAS_PARAM3_LONG	= (1 << 21),
+	CA_MESSAGE_HAS_PARAM4_LONG	= (1 << 22)
+};
+
+enum CA_MESSAGE_MSGID {
+	CA_MESSAGE_MSG_INSERTED,
+	CA_MESSAGE_MSG_REMOVED,
+	CA_MESSAGE_MSG_INIT_OK,
+	CA_MESSAGE_MSG_INIT_FAILED,
+	CA_MESSAGE_MSG_MMI_MENU,
+	CA_MESSAGE_MSG_MMI_MENU_ENTER,
+	CA_MESSAGE_MSG_MMI_MENU_ANSWER,
+	CA_MESSAGE_MSG_MMI_LIST,
+	CA_MESSAGE_MSG_MMI_TEXT,
+	CA_MESSAGE_MSG_MMI_REQ_INPUT,
+	CA_MESSAGE_MSG_MMI_CLOSE,
+	CA_MESSAGE_MSG_INTERNAL,
+	CA_MESSAGE_MSG_PMT_ARRIVED,
+	CA_MESSAGE_MSG_CAPMT_ARRIVED,
+	CA_MESSAGE_MSG_CAT_ARRIVED,
+	CA_MESSAGE_MSG_ECM_ARRIVED,
+	CA_MESSAGE_MSG_EMM_ARRIVED,
+	CA_MESSAGE_MSG_CHANNEL_CHANGE,
+	CA_MESSAGE_MSG_GUI_READY,
+	CA_MESSAGE_MSG_EXIT
+};
+
+typedef std::set<int> ca_map_t;
+typedef ca_map_t::iterator ca_map_iterator_t;
+
+typedef struct CA_MESSAGE {
+	uint32_t MsgId;
+	enum CA_SLOT_TYPE SlotType;
+	int Slot;
+	uint32_t Flags;
+	union {
+		uint8_t *Data[4];
+		uint32_t Param[4];
+		void *Ptr[4];
+		uint64_t ParamLong[4];
+	} Msg;
+} CA_MESSAGE;
+
+class cCA {
+private:
+	cCA(void);
+public:
+	uint32_t GetNumberCISlots(void);
+	uint32_t GetNumberSmartCardSlots(void);
+	static cCA *GetInstance(void);
+	bool SendPMT(int Unit, unsigned char *Data, int Len, CA_SLOT_TYPE SlotType = CA_SLOT_TYPE_ALL);
+//	bool SendCAPMT(u64 /*Source*/, u8 /*DemuxSource*/, u8 /*DemuxMask*/, const unsigned char * /*CAPMT*/, u32 /*CAPMTLen*/, const unsigned char * /*RawPMT*/, u32 /*RawPMTLen*/) { return true; };
+	bool SendCAPMT(u64 /*Source*/, u8 /*DemuxSource*/, u8 /*DemuxMask*/, const unsigned char * /*CAPMT*/, u32 /*CAPMTLen*/, const unsigned char * /*RawPMT*/, u32 /*RawPMTLen*/, enum CA_SLOT_TYPE
+	/*SlotType*/, unsigned char /*scrambled = 0*/, ca_map_t /*camap = std::set<int>()*/, int /*mode = 0*/, bool /*enabled = false*/) { return true; };
+	bool SendMessage(const CA_MESSAGE *Msg);
+	void SetInitMask(enum CA_INIT_MASK InitMask);
+	int GetCAIDS(CaIdVector & /*Caids*/) { return 0; };
+	bool Start(void);
+	void Stop(void);
+	void Ready(bool Set);
+	void ModuleReset(enum CA_SLOT_TYPE, uint32_t Slot);
+	bool ModulePresent(enum CA_SLOT_TYPE, uint32_t Slot);
+	void ModuleName(enum CA_SLOT_TYPE, uint32_t Slot, char *Name);
+	void MenuEnter(enum CA_SLOT_TYPE, uint32_t Slot);
+	void MenuAnswer(enum CA_SLOT_TYPE, uint32_t Slot, uint32_t choice);
+	void InputAnswer(enum CA_SLOT_TYPE, uint32_t Slot, uint8_t * Data, int Len);
+	void MenuClose(enum CA_SLOT_TYPE, uint32_t Slot);
+	void SetTSClock(u32 /*Speed*/) { return; };
+	bool checkChannelID(u64 /*chanID*/) { return false; };
+	void setCheckLiveSlot(int /*check*/) { return; };
+	virtual ~cCA();
+};
+
+#endif // __CA_LIBTRIPLE_H_
+#endif // HAVE_DUCKBOX_HARDWARE

include/ca_ci.h

@@ -0,0 +1,350 @@
+#ifndef __CA_H_
+#define __CA_H_
+
+#include <stdint.h>
+#include <asm/types.h>
+#include <pthread.h>
+#include <list>
+#include <queue>
+#include <vector>
+#include <set>
+
+#include "mmi.h"
+#include "cs_types.h"
+#include "cs_api.h"
+
+/* constants taken from dvb-apps */
+#define T_SB                0x80	// sb                           primitive   h<--m
+#define T_RCV               0x81	// receive                      primitive   h-->m
+#define T_CREATE_T_C        0x82	// create transport connection  primitive   h-->m
+#define T_C_T_C_REPLY       0x83	// ctc reply                    primitive   h<--m
+#define T_DELETE_T_C        0x84	// delete tc                    primitive   h<->m
+#define T_D_T_C_REPLY       0x85	// dtc reply                    primitive   h<->m
+#define T_REQUEST_T_C       0x86	// request transport connection primitive   h<--m
+#define T_NEW_T_C           0x87	// new tc / reply to t_request  primitive   h-->m
+#define T_T_C_ERROR         0x77	// error creating tc            primitive   h-->m
+#define T_DATA_LAST         0xA0	// convey data from higher      constructed h<->m
+#define T_DATA_MORE         0xA1	// convey data from higher      constructed h<->m
+
+/* max multi decrypt per ci-cam */
+#define CI_MAX_MULTI			5
+
+enum CA_INIT_MASK {
+	CA_INIT_SC = 1,
+	CA_INIT_CI,
+	CA_INIT_BOTH
+};
+
+enum CA_SLOT_TYPE {
+	CA_SLOT_TYPE_SMARTCARD,
+	CA_SLOT_TYPE_CI,
+	CA_SLOT_TYPE_ALL
+};
+
+enum CA_MESSAGE_FLAGS {
+	CA_MESSAGE_EMPTY		= (1 << 0),
+	CA_MESSAGE_HAS_PARAM1_DATA	= (1 << 1), /// Free after use!
+	CA_MESSAGE_HAS_PARAM1_INT	= (1 << 2),
+	CA_MESSAGE_HAS_PARAM1_PTR	= (1 << 3),
+	CA_MESSAGE_HAS_PARAM2_INT	= (1 << 4),
+	CA_MESSAGE_HAS_PARAM2_PTR	= (1 << 5),
+	CA_MESSAGE_HAS_PARAM2_DATA	= (1 << 6),
+	CA_MESSAGE_HAS_PARAM3_DATA	= (1 << 7), /// Free after use!
+	CA_MESSAGE_HAS_PARAM3_INT	= (1 << 8),
+	CA_MESSAGE_HAS_PARAM3_PTR	= (1 << 9),
+	CA_MESSAGE_HAS_PARAM4_INT	= (1 << 10),
+	CA_MESSAGE_HAS_PARAM4_PTR	= (1 << 11),
+	CA_MESSAGE_HAS_PARAM4_DATA	= (1 << 12),
+	CA_MESSAGE_HAS_PARAM5_INT	= (1 << 13),
+	CA_MESSAGE_HAS_PARAM5_PTR	= (1 << 14),
+	CA_MESSAGE_HAS_PARAM5_DATA	= (1 << 15),
+	CA_MESSAGE_HAS_PARAM6_INT	= (1 << 16),
+	CA_MESSAGE_HAS_PARAM6_PTR	= (1 << 17),
+	CA_MESSAGE_HAS_PARAM6_DATA	= (1 << 18),
+	CA_MESSAGE_HAS_PARAM1_LONG	= (1 << 19),
+	CA_MESSAGE_HAS_PARAM2_LONG	= (1 << 20),
+	CA_MESSAGE_HAS_PARAM3_LONG	= (1 << 21),
+	CA_MESSAGE_HAS_PARAM4_LONG	= (1 << 22)
+};
+
+enum CA_MESSAGE_MSGID {
+	CA_MESSAGE_MSG_INSERTED,
+	CA_MESSAGE_MSG_REMOVED,
+	CA_MESSAGE_MSG_INIT_OK,
+	CA_MESSAGE_MSG_INIT_FAILED,
+	CA_MESSAGE_MSG_MMI_MENU,
+	CA_MESSAGE_MSG_MMI_MENU_ENTER,
+	CA_MESSAGE_MSG_MMI_MENU_ANSWER,
+	CA_MESSAGE_MSG_MMI_LIST,
+	CA_MESSAGE_MSG_MMI_TEXT,
+	CA_MESSAGE_MSG_MMI_REQ_INPUT,
+	CA_MESSAGE_MSG_MMI_CLOSE,
+	CA_MESSAGE_MSG_INTERNAL,
+	CA_MESSAGE_MSG_PMT_ARRIVED,
+	CA_MESSAGE_MSG_CAPMT_ARRIVED,
+	CA_MESSAGE_MSG_CAT_ARRIVED,
+	CA_MESSAGE_MSG_ECM_ARRIVED,
+	CA_MESSAGE_MSG_EMM_ARRIVED,
+	CA_MESSAGE_MSG_CHANNEL_CHANGE,
+	CA_MESSAGE_MSG_GUI_READY,
+	CA_MESSAGE_MSG_EXIT
+};
+
+typedef struct CA_MESSAGE {
+	uint32_t MsgId;
+	enum CA_SLOT_TYPE SlotType;
+	int Slot;
+	uint32_t Flags;
+	union {
+		uint8_t *Data[4];
+		uint32_t Param[4];
+		void *Ptr[4];
+		uint64_t ParamLong[4];
+	} Msg;
+} CA_MESSAGE;
+
+typedef std::set<int> ca_map_t;
+typedef ca_map_t::iterator ca_map_iterator_t;
+
+typedef std::vector<u16>			bSIDVector;
+
+typedef std::vector<u16>			CaIdVector;
+typedef std::vector<u16>::iterator		CaIdVectorIterator;
+typedef std::vector<u16>::const_iterator	CaIdVectorConstIterator;
+
+#define CA_MESSAGE_SIZE		sizeof(CA_MESSAGE)
+#define CA_MESSAGE_ENTRIES	256
+#define CA_MESSAGE_ENTRIES_CI	128
+#define CA_MESSAGE_ENTRIES_SC	64
+
+#ifndef CS_CA_PDATA
+#define CS_CA_PDATA		void
+#endif
+
+typedef enum {
+	TUNER_A,
+	TUNER_B,
+	TUNER_C,
+	TUNER_D
+} source_t;
+
+typedef enum {
+	eDataTimeout,
+	eDataError,
+	eDataReady,
+	eDataWrite,
+	eDataStatusChanged
+} eData;
+
+typedef enum {
+	eStatusNone,
+	eStatusWait,
+	eStatusReset
+} eStatus;
+
+struct queueData
+{
+	__u8 prio;
+	unsigned char *data;
+	unsigned int len;
+	queueData(unsigned char *_data, unsigned int _len, __u8 _prio = 0)
+		:prio(_prio), data(_data), len(_len)
+	{
+
+	}
+	bool operator < ( const struct queueData &a ) const
+	{
+		return prio < a.prio;
+	}
+};
+
+class eDVBCIMMISession;
+class eDVBCIApplicationManagerSession;
+class eDVBCICAManagerSession;
+class eDVBCIContentControlManagerSession;
+
+typedef struct
+{
+	pthread_t slot_thread;
+	unsigned int slot;
+	int fd;
+	int connection_id;
+	eStatus status;
+
+	int receivedLen;
+	unsigned char* receivedData;
+
+	void* pClass;
+
+	bool pollConnection;
+	bool camIsReady;
+
+	eDVBCIMMISession* mmiSession;
+	eDVBCIApplicationManagerSession* appSession;
+	eDVBCICAManagerSession* camgrSession;
+	eDVBCIContentControlManagerSession* ccmgrSession;
+
+	bool hasAppManager;
+	bool hasMMIManager;
+	bool hasCAManager;
+	bool hasCCManager;
+	bool hasDateTime;
+	bool mmiOpened;
+	bool init;
+
+	bool ccmgr_ready;
+
+	char ci_dev[32];
+	char name[512];
+
+	bool newPids;
+	bool newCapmt;
+	bool multi;
+	bool recordUse[CI_MAX_MULTI];
+	bool liveUse[CI_MAX_MULTI];
+	u16 SID[CI_MAX_MULTI];
+	u64 TP;
+	int ci_use_count;
+	u32 pmtlen;
+	u8 source;
+	u8 camask;
+	unsigned char pmtdata[1024 * 4];
+
+	int counter;
+	CaIdVector cam_caids;
+	std::priority_queue<queueData> sendqueue;
+
+	std::vector<u16> pids;
+
+	bSIDVector bsids;
+	unsigned char lastKey[32];
+	unsigned char scrambled;
+	u8 lastParity;
+	bool DataLast;
+	bool DataRCV;
+	bool SidBlackListed;
+	/* private data */
+	void *private_data;
+
+} eDVBCISlot;
+
+eData sendData(eDVBCISlot *slot, unsigned char* data, int len);
+
+typedef std::list<eDVBCISlot*>::iterator SlotIt;
+
+/// CA module class
+class cCA {
+private:
+	/// Static instance of the CA module
+//	static cCA *inst;
+	/// Private constructor (singleton method)
+	cCA(void);
+	/// Private data for the CA module
+	CS_CA_PDATA *privateData;
+	/// set inputs with tuner letter in tsmux
+	void setInputs();
+	/// write ci info file to /tmp
+	void write_ci_info(int slot, CaIdVector caids);
+	/// delete ci info file
+	void del_ci_info(int slot);
+	/// extract audio / video pids from capmt 
+	void extractPids(eDVBCISlot* slot);
+	/// ci module is detected
+	void ci_inserted(eDVBCISlot* slot);
+	/// ci module is removed
+	void ci_removed(eDVBCISlot* slot);
+	/// decode the tpdu tag
+	void process_tpdu(eDVBCISlot* slot, unsigned char tpdu_tag, __u8* data, int asn_data_length, int con_id);
+	/// set flag of running ci record to false
+	bool StopRecordCI( u64 TP, u16 SID, u8 source, u32 calen);
+	/// set flag of running ci live-tv to false
+	bool StopLiveCI( u64 TP, u16 SID, u8 source, u32 calen);
+	/// find an unused ci slot for use with service
+	SlotIt FindFreeSlot(u64 tpid, u8 source, u16 sid, ca_map_t camap, u8 scrambled);
+	/// get slot iterator by slot number
+	SlotIt GetSlot(unsigned int slot);
+	/// send buffered capmt to ci modul
+	bool SendCaPMT(eDVBCISlot* slot);
+	/// send a dummy capmt to ci for deactivating
+	bool SendNullPMT(eDVBCISlot* slot);
+	/// set ci source
+	void setSource(eDVBCISlot* slot);
+	/// set demux source
+	void setInputSource(eDVBCISlot* slot, bool ci);
+	/// check if data in queue
+	bool checkQueueSize(eDVBCISlot* slot);
+	enum CA_INIT_MASK initMask;
+	int num_slots;
+	bool init;
+	void SendPMT();
+	pthread_mutex_t ciMutex;
+	std::list<eDVBCISlot*> slot_data;
+	pthread_t slot_thread;
+
+public:
+	/// sh4 unused
+	bool Init(void);
+	/// init ci and start the loop
+	cCA(int Slots);
+	/// Returns the number of CI slots
+	uint32_t GetNumberCISlots(void);
+	/// Returns the number of Smartcard slots
+	uint32_t GetNumberSmartCardSlots(void);
+	/// Singleton
+	static cCA *GetInstance(void);
+	/// Send PMT to a individual or to all available modules (DEPRECATED)
+	bool SendPMT(int Unit, unsigned char *Data, int Len, enum CA_SLOT_TYPE SlotType = CA_SLOT_TYPE_ALL);
+	/// Sends a message to the CA thread
+	bool SendMessage(const CA_MESSAGE *Msg);
+	/// Sets which modules to initialize. It is only
+	/// possible to change this once!
+	/// sh4 unused
+	void SetInitMask(enum CA_INIT_MASK InitMask);
+	/// Sets the frequency (in Hz) of the TS stream input (only valid for CI)
+	/// sh4 unused
+	void SetTSClock(u32 Speed);
+	/// Start the CA module
+	/// sh4 unused
+	bool Start(void);
+	/// Stops the CA module
+	/// sh4 unused
+	void Stop(void);
+	/// Notify that the GUI is ready to receive messages
+	/// (CA messages coming from a module)
+	/// sh4 unused
+	void Ready(bool Set);
+	/// Resets a module (if possible)
+	/// sh4 unused
+	void ModuleReset(enum CA_SLOT_TYPE, uint32_t Slot);
+	/// Checks if a module is present
+	bool ModulePresent(enum CA_SLOT_TYPE, uint32_t Slot);
+	/// Returns the module name in array Name
+	void ModuleName(enum CA_SLOT_TYPE, uint32_t Slot, char *Name);
+	/// Notify the module we want to enter menu
+	void MenuEnter(enum CA_SLOT_TYPE, uint32_t Slot);
+	/// Notify the module with our answer (choice nr)
+	void MenuAnswer(enum CA_SLOT_TYPE, uint32_t Slot, uint32_t choice);
+	/// Notify the module with our answer (binary)
+	void InputAnswer(enum CA_SLOT_TYPE, uint32_t Slot, uint8_t * Data, int Len);
+	/// Notify the module we closed the menu
+	void MenuClose(enum CA_SLOT_TYPE, uint32_t Slot);
+	/// Get the supported CAIDs
+	int GetCAIDS(CaIdVector &Caids);
+	/// Send a CA-PMT object and Raw unparsed PMT to the CA layer
+	bool SendCAPMT(u64 /*Source*/, u8 /*DemuxSource*/, u8 /*DemuxMask*/, const unsigned char * /*CAPMT*/, u32 /*CAPMTLen*/, const unsigned char * /*RawPMT*/, u32 /*RawPMTLen*/, enum CA_SLOT_TYPE SlotType = CA_SLOT_TYPE_ALL,
+		unsigned char scrambled = 0, ca_map_t camap = std::set<int>(), int mode = 0, bool enabled = false);
+	/// sh4 unused
+	bool SendDateTime(void);
+	/// the main loop
+	void slot_pollthread(void *c);
+	/// check if current channel uses any ci module
+	bool checkChannelID(u64 chanID);
+	/// set checking for live-tv use ci to true
+	void setCheckLiveSlot(int check);
+	/// as the name says
+	bool CheckCerts(void);
+	/// Virtual destructor
+	virtual ~cCA();
+};
+
+#endif ///__CA_H_

include/ca_cs.h

@@ -1 +1 @@
-#include "../common/ca.h"
+#include "ca.h"

include/cs_api.h

@@ -1,20 +1,37 @@
+/* compatibility header for tripledragon. I'm lazy, so I just left it
+   as "cs_api.h" so that I don't need too many ifdefs in the code */
+
+#ifndef __CS_API_H_
+#define __CS_API_H_
+
+#include "init_td.h"
 #include <config.h>
-#if HAVE_TRIPLEDRAGON
-#include "../libtriple/cs_api.h"
-#elif HAVE_DUCKBOX_HARDWARE
-#include "../libduckbox/cs_api.h"
-#elif HAVE_SPARK_HARDWARE
-#include "../libspark/cs_api.h"
-#elif HAVE_ARM_HARDWARE
-#include "../libarmbox/cs_api.h"
-#elif HAVE_AZBOX_HARDWARE
-#include "../azbox/cs_api.h"
-#elif HAVE_GENERIC_HARDWARE
-#if BOXMODEL_RASPI
-#include "../raspi/cs_api.h"
+
+typedef void (*cs_messenger) (unsigned int msg, unsigned int data);
+
+inline void cs_api_init()
+{
+	init_td_api();
+};
+
+inline void cs_api_exit()
+{
+	shutdown_td_api();
+};
+
+#define cs_malloc_uncached	malloc
+#define cs_free_uncached	free
+
+// Callback function helpers
+#if HAVE_DUCKBOX_HARDWARE || HAVE_ARM_HARDWARE
+void cs_register_messenger(cs_messenger messenger);
 #else
-#include "../generic-pc/cs_api.h"
-#endif
-#else
-#error neither HAVE_TRIPLEDRAGON nor HAVE_SPARK_HARDWARE defined
+static inline void cs_register_messenger(cs_messenger) { return; };
 #endif
+static inline void cs_deregister_messenger(void) { return; };
+
+/* compat... HD1 seems to be version 6. everything newer ist > 6... */
+static inline unsigned int cs_get_revision(void) { return 1; };
+static inline unsigned int cs_get_chip_type(void) { return 0; };
+extern int cnxt_debug;
+#endif //__CS_API_H_

include/cs_types.h

@@ -0,0 +1,23 @@
+/* pretty useless, but we don't need to work around this if
+ * we just copy it over... */
+
+#ifndef __CS_TYPES_H_
+#define __CS_TYPES_H_
+
+typedef enum
+{
+	AVSYNC_DISABLED,
+	AVSYNC_ENABLED,
+	AVSYNC_AUDIO_IS_MASTER
+} AVSYNC_TYPE;
+
+typedef unsigned long long	u64;
+typedef unsigned int		u32;
+typedef unsigned short		u16;
+typedef unsigned char		 u8;
+typedef signed long long	s64;
+typedef signed int		s32;
+typedef signed short		s16;
+typedef signed char		 s8;
+
+#endif // __CS_TYPES_H_

include/dmx_hal.h

@@ -1,20 +1,97 @@
-#include <config.h>
-#if HAVE_TRIPLEDRAGON
-#include "../libtriple/dmx_td.h"
-#elif HAVE_DUCKBOX_HARDWARE
-#include "../libduckbox/dmx_lib.h"
-#elif HAVE_SPARK_HARDWARE
-#include "../libspark/dmx_lib.h"
-#elif HAVE_AZBOX_HARDWARE
-#include "../azbox/dmx_lib.h"
-#elif HAVE_ARM_HARDWARE
-#include "../libarmbox/dmx_lib.h"
-#elif HAVE_GENERIC_HARDWARE
-#if BOXMODEL_RASPI
-#include "../raspi/dmx_lib.h"
-#else
-#include "../generic-pc/dmx_lib.h"
-#endif
-#else
-#error neither HAVE_TRIPLEDRAGON nor HAVE_SPARK_HARDWARE defined
+/*
+ * (C) 2010-2013 Stefan Seyfried
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __dmx_hal__
+#define __dmx_hal__
+
+#include <cstdlib>
+#include <vector>
+#include <inttypes.h>
+/* at least on td, config.h needs to be included before... */
+#ifndef HAVE_TRIPLEDRAGON
+#include <linux/dvb/dmx.h>
+#else /* TRIPLEDRAGON */
+extern "C" {
+#include <hardware/xp/xp_osd_user.h>
+}
+#if defined DMX_FILTER_SIZE
+#undef DMX_FILTER_SIZE
 #endif
+#define DMX_FILTER_SIZE FILTER_LENGTH
+#endif /* TRIPLEDRAGON */
+
+#include <cs_types.h>
+
+#define MAX_DMX_UNITS 4
+
+typedef enum
+{
+	DMX_INVALID = 0,
+	DMX_VIDEO_CHANNEL = 1,
+	DMX_AUDIO_CHANNEL,
+	DMX_PES_CHANNEL,
+	DMX_PSI_CHANNEL,
+	DMX_PIP_CHANNEL,
+	DMX_TP_CHANNEL,
+	DMX_PCR_ONLY_CHANNEL
+} DMX_CHANNEL_TYPE;
+
+typedef struct
+{
+	int fd;
+	unsigned short pid;
+} pes_pids;
+
+class cRecord;
+class cPlayback;
+class cDemux
+{
+	friend class cRecord;
+	friend class cPlayback;
+	public:
+		bool Open(DMX_CHANNEL_TYPE pes_type, void * x = NULL, int y = 0);
+		void Close(void);
+		bool Start(bool record = false);
+		bool Stop(void);
+		int Read(unsigned char *buff, int len, int Timeout = 0);
+		bool sectionFilter(unsigned short pid, const unsigned char * const filter, const unsigned char * const mask, int len, int Timeout = 0, const unsigned char * const negmask = NULL);
+		bool pesFilter(const unsigned short pid);
+		void SetSyncMode(AVSYNC_TYPE mode);
+		void * getBuffer();
+		void * getChannel();
+		DMX_CHANNEL_TYPE getChannelType(void) { return dmx_type; };
+		bool addPid(unsigned short pid);
+		void getSTC(int64_t * STC);
+		int getUnit(void);
+		static bool SetSource(int unit, int source);
+		static int GetSource(int unit);
+		int getFD(void) { return fd; };		/* needed by cPlayback class */
+		cDemux(int num = 0);
+		~cDemux();
+	private:
+		void removePid(unsigned short Pid);	/* needed by cRecord class */
+		int num;
+		int fd;
+		int buffersize;
+		uint16_t pid;
+		uint8_t flt;
+		std::vector<pes_pids> pesfds;
+		DMX_CHANNEL_TYPE dmx_type;
+		void *pdata;
+};
+
+#endif //__dmx_hal__

include/mmi.h

@@ -6,7 +6,7 @@
 #define MAX_MMI_CHOICE_TEXT_LEN		255
 
 typedef enum {
-	MMI_TOP_MENU_SUBS		= 1,
+	MMI_TOP_MENU_SUBS = 1,
 	MMI_TOP_MENU_EVENTS,
 	MMI_TOP_MENU_TOKENS,
 	MMI_TOP_MENU_PIN,
@@ -15,13 +15,13 @@ typedef enum {
 } MMI_MENU_CURRENT;
 
 typedef enum {
-	MMI_MENU_LEVEL_MAIN	= 0,
+	MMI_MENU_LEVEL_MAIN = 0,
 	MMI_MENU_LEVEL_MATURE,
 	MMI_MENU_LEVEL_ASK_PIN_MATURE
 } MMI_MENU_LEVEL;
 
 typedef enum {
-	MMI_PIN_LEVEL_ASK_OLD	= 0,
+	MMI_PIN_LEVEL_ASK_OLD = 0,
 	MMI_PIN_LEVEL_CHECK_CURRENT,
 	MMI_PIN_LEVEL_ASK_REPEAT,
 	MMI_PIN_LEVEL_CHECK_AND_CHANGE
@@ -44,7 +44,7 @@ typedef struct {
 } MMI_ENQUIRY_INFO;
 
 /* compat */
-#define enguiryText	 enquiryText
+#define enguiryText      enquiryText
 #define MMI_ENGUIRY_INFO MMI_ENQUIRY_INFO
 
 #endif // __MMI_H_