/**
 * Copyright(c) 2011 Sunmedia Technologies - All Rights Reserved.
 *
 * @file
 *
 * @brief Definitions for DVB EPG.
 *
 * @note This file is from ETSI EN 300 468 and ISO 13818.
 *
 * @note D Book/E Book/Z Book/Nordig and freeview are defined here.
 *
 * This file is the EPG data which forms a part of DVB bitstreams.
 *
 * @htmlonly
 * The diagram below shows the DVB delivery model.
 * @endhtmlonly
 *
 * @image html dvb_delivery_model.PNG "DVB Delivery Model"
 *
 * @htmlonly
 * The diagram below shows the service information relationship.
 * @endhtmlonly
 *
 * @image html organization_service_information.PNG
 * "Service Information Relationship"
 */

#ifndef SUNMEDIA_MID_EPG_INCLUDED
#define SUNMEDIA_MID_EPG_INCLUDED

#include "types.h"
#include "umf_debug.h"
#ifdef CONFIG_EPG_USE_RESERVE_MM
extern void *EPG_MM_Malloc(size_t size);
extern void EPG_MM_Free(void *address);
#define EPG_MALLOC(size)	EPG_MM_Malloc(size)
#define EPG_FREE(ptr)	EPG_MM_Free(ptr)
#else
#define EPG_MALLOC(size)	malloc(size)
#define EPG_FREE(ptr)	free(ptr)
#endif

#define MAGIC_NO			(0x5678)

/** Match any service id */
#define RESERVED_SERVICE_ID			(0xFFFF)
/** Match any transport stream id */
#define RESERVED_TRANSPORT_ID		(0xFFFF)
/** Match any original network id */
#define RESERVED_ORIGINAL_NET_ID	(0xFFFF)

#define MAX_ISO_LANG_CODE 			(4)
#if 0//defined(CONFIG_DRAMSIZE) && CONFIG_DRAMSIZE == 64
#define MAX_DATA_SIZE				(255)
#define EPG_EXTEND_EVENT_DESC_NUM 	(16)
#else
#define MAX_DATA_SIZE 				(512)//(255)/* modify by qinhe on 2014/04/27 for new font show UTF8 length is 298 for si02_21c_2k_64qam_cr23_gi32_7.30.ts SIT888 & #2426_Russia_578000_DVBT.ts mantis 23917 */
#define EPG_EXTEND_EVENT_DESC_NUM 	(19) //(16) ,  increase to 19 for 16 is not enough for some event. mantis 0038265: [T1][RDA8528]DTV,DVB-C,播放ZDF_20110925_130918.TS,節目ZDF,進到EPG,在ZDF.umwelt按info key,最後面的內容有少. 
#endif

#define MAX_CONTENT_NUM_IN_CONTENT_DESCRIPTOR   (127)

/** Remove lator */
#define MID_EPG_DBG_FLAG				(0)
#define MID_EPG_ERROR_FLAG				(1)
/**< Debug and error print defines */
#if MID_EPG_DBG_FLAG
	#define EPG_PRINT(fmt, arg...) \
	do { \
		UMFDBG(0,"[Debug]%s: %d Line\n", __FUNCTION__, __LINE__); \
		UMFDBG(0,fmt, ##arg); \
	} while(0)
#else
	#define EPG_PRINT(fmt, arg...);
#endif
#if MID_EPG_ERROR_FLAG
	#define EPG_ERROR(fmt, arg...) \
		do { \
		UMFDBG(0,"[ERR]%s: %d Line\n", __FUNCTION__, __LINE__); \
		UMFDBG(0,fmt, ##arg); \
	} while(0)
#else
	#define EPG_ERROR(fmt, arg...);
#endif

#ifdef __cplusplus
extern "C"
{
#endif

/**
 * @brief The epg events types.
 */
typedef enum
{
	EVENT_TYPE_NOW = 0,
	EVENT_TYPE_NEXT,
	EVENT_TYPE_SCHEDULE,
	EVENT_TYPE_OTHER,
} MID_EPG_EventType;

/**
 * @brief ST Date
 */
typedef struct _ST_DATE
{
	UINT16 usYear; /**< year */
	UINT8 ucMonth; /**< month */
	UINT8 ucDay; /**< day */
} ST_DATE;

/**
 * @brief ST time
 */
typedef struct _ST_TIME
{
	UINT8  ucHour; /**< hour */
	UINT8  ucMin; /**< minute */
	UINT8  ucSec; /**< second */
} ST_TIME;

/**
 * @brief ST event date and time
 */
typedef struct _ST_EVENT_TIME
{
	ST_DATE	stStartDate;	/**< start date */
	ST_TIME stStartTime; /**< start time */
	ST_DATE stEndDate; /**< end date */
	ST_TIME stEndTime; /**< end time */
} ST_EVENT_TIME;

/**
 * @brief return types
 */
typedef enum
{
	MID_EPG_SUCCESS,
	MID_EPG_FAILED,
	MID_EPG_INVALID_PARAM,
	MID_EPG_STATE_ERROR,

} MID_EPG_Return_t;

/**
 * @brief Identifies a specific EPG Handle.
 *
 * It is an opaque type specific to the target implement. It is used to
 * identify the EPG.
 *
 * @note 0 is invalid handle.
 */
typedef INT32 MID_EPG_Handle_t;

/**
 * @brief Identifies a specific EPG event Handle.
 *
 * It is an opaque type specific to the target implement. It is used to
 * identify the EPG event.
 *
 * @note 0 is invalid handle.
 */
typedef UINT32 MID_EPG_EventHandle_t;

/**
 * The epg events that are passed to the application through callback
 */
typedef enum MID_EPGEvent_t
{
	EPG_EVENT_NOW_ADDED, /**< Now event added */
	EPG_EVENT_NOW_MODIFIED, /**< Now event modified */
	EPG_EVENT_NOW_DELETE, /**< Now event deleted */

	/** EPG Schedule Event */
	EPG_EVENT_ADDED,  /**< Entry added */
	EPG_EVENT_MODIFIED, /**< Entry modified(Reserved) */
	EPG_EVENT_DELETED, /**< Entry deleted */
	EPG_ALLEVENTS_DELETED, /**< All Events deleted */

	EPG_GET_SYSTEMTIME, /**< get current system time */
	EPG_CHECK_SRVEXIST, /**< check the service is exist in database */
} MID_EPGEvent_t;

/**
 * The epg mode, for example normal and time shift
 */
typedef enum MID_EPGMode_t
{
	EPG_MODE_NORMAL,
	EPG_MODE_TIMESHIFT,
} MID_EPGMode_t;

/**
 * @brief The prototype of the callback to be registed with epg.
 *
* @param enEvent EPG event, see #MID_EPGEvent_t.
 *
 * @param pParam A pointer to the EPG event that has changed, see #MID_EPGEventCallback_t.
 */
typedef	void (*fMidEpgCallback)(MID_EPGEvent_t enEvent, void* pParam);

/**
* struct MID_ServLocator_t
* @brief dvb service locator.
*
* This structure defines the dvb service locator.
*/
typedef struct MID_ServLocator_t
{
	/** Service information */
	UINT16 original_network_id; /**< Original network ID */
	UINT16 tranport_id; /**< transport id */
	UINT16 service_id; /**< service id */
} MID_ServLocator_t;

/**
* struct MID_EPGEventParam_t
* @brief epg callback parameter.
*
* This structure defines the parameter of epg callback.
*/
typedef struct MID_EPGEventCallback_t
{
	MID_EPG_EventHandle_t epg_handle;

	UINT16 event_id; /**< event id */
	UINT16 event_type; /** <event type */

	/** Service information */
	UINT16 original_network_id; /**< Original network ID */
	UINT16 tranport_id; /**< transport id */
	UINT16 service_id; /**< service id */

} MID_EPGEventCallback_t;

/**
* struct MID_EPGInit_t
* @brief EPG module initializing parameter.
*
* Structure defines the parameters to be set during initializing epg module.
*/
typedef struct MID_EPGInit_t
{
	UINT8 db_type; /**< Database type such as DVB-T, DVB-C or DVB-S etc */
	UINT8 epg_mode;
	UINT16 serv_max; /**< The maximum of services to cache */
	UINT32 total_size; /**< The epg total size */
	UINT32 capability; /**< Reserved for future */
	fMidEpgCallback fCallback; /**< EPG callback function */
} MID_EPGInit_t;

/**
* struct MID_EPGEventParam_t
* @brief epg callback parameter.
*
* This structure defines the parameter of epg callback.
*/
typedef struct MID_EPGEventInfo_t
{
	UINT16 event_id;
	/**
	* running status values:
	* 0 undefined
	* 1 not running
	* 2 starts in a few seconds
	* 3 pausing
	* 4 running
	* 5 service off-air
	* 6 and 7 reserved for future use
	*/
	UINT8 running_status;
	/**
	* free_CA_mode values:
	* 0 indicates that all the component streams of the service are not
	* scramble.
	* 1 indicates that access to one or more streams \a may be controlled
	* by a CA system.
	*/
	UINT8 free_CA_mode;

	UINT32 start_time; /**< Interpreted as a value from epoch time in second */
	UINT32 duration; /**< Duration of the event in second */
	UINT16 event_type; /** <event type */
} MID_EPGEventInfo_t;

/**
* struct MID_EPGEventDetails_t(#DESCR_SHORT_EVENT and #DESCR_EXTENDED_EVENT)
* @brief event descriptor structure for 0x4D
*
* The event descriptor provides the item of the event and a descriptor
* of the event in text form.
* see (ETSI EN 300 468 section 6.2.37 and 6.2.15).
*/
typedef struct
{
	UINT8 iso_639_code[MAX_ISO_LANG_CODE]; /**< ISO_639_language_code */

	UINT8 event_name_length; /**< length of the multilingual event name */
	UINT8 event_name[MAX_DATA_SIZE]; /**< name of the multilingual event name */

	UINT8 text_length; /**< length of the multilingual service_name */
	UINT8 text[MAX_DATA_SIZE]; /**< name of the multilingual service_name */

	UINT8 content_classify;
	UINT8 event_rating;
	UINT32 extend_num;
	UINT32 event_offset;
} MID_SIDesc_EventDetail_t;

/**
* struct MID_EPGEventDetails_t(#DESCR_SHORT_EVENT and #DESCR_EXTENDED_EVENT)
* @brief event descriptor structure for 0x4E.
*
* The event descriptor provides the item of the event and a descriptor
* of the event in text form.
* see (ETSI EN 300 468 section 6.2.37 and 6.2.15).
*/
typedef struct
{
	UINT8 iso_639_code[MAX_ISO_LANG_CODE]; /**< ISO_639_language_code */

	UINT8 item_name_length; /**< length of the multilingual service_provider_name */
	UINT8 item_name[MAX_DATA_SIZE]; /**< name of the multilingual service provider */

	UINT8 text_length; /**< length of the multilingual service_name */
	UINT8 text[MAX_DATA_SIZE]; /**< name of the multilingual service_name */
} MID_SIDesc_ExtEventDetail_t;

/**
 * @brief EIT Content_Nibble_Level_1_Type
 * Reference EN 300 468 clause 6.2.9 Content Descriptor.
 * Reference to table Content_nibble level 1 and 2 assignments
 */
typedef enum
{
	MID_EPG_CONTENT_TYPE_UNDEFINE = 0x0,
	MID_EPG_CONTENT_TYPE_MOVIE = 0x1,
	MID_EPG_CONTENT_TYPE_NEWS = 0x2,
	MID_EPG_CONTENT_TYPE_SHOW = 0x3,
	MID_EPG_CONTENT_TYPE_SPORTS = 0x4,
	MID_EPG_CONTENT_TYPE_CHILDREN_PROGRAM = 0x5,
	MID_EPG_CONTENT_TYPE_MUSIC = 0x6,
	MID_EPG_CONTENT_TYPE_ARTS= 0x7,
	MID_EPG_CONTENT_TYPE_SOCIAL= 0x8,
	MID_EPG_CONTENT_TYPE_EDUCATION = 0x9,
	MID_EPG_CONTENT_TYPE_LEISURE_HOBBIES = 0xA,
	MID_EPG_CONTENT_TYPE_SPECIAL = 0xB,

} MID_EPG_Content_Nibble_Level_1_Type_t;

/**
* struct MID_SIDesc_ContentDescriptor_t(#DESCR_CONTENT)
* @brief event descriptor structure for 0x54.
*
* The event descriptor provides the item of the event and a descriptor
* of the event in text form.
* see (ETSI EN 300 468 section 6.2.9).
*/
typedef struct
{
	UINT8 content_nibble_level_1;
} MID_SIDesc_ContentDescriptor_t;

/**
 * @brief Initializes the epg module.
 *
 * This attempts to initialize epg module, allocate the necessary resources.
 *
 * @param pstInitParam Initializing paramenter.
 *
 * @param handle The returned EPG module handle.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
 MID_EPG_Return_t MID_EPGInit(MID_EPGInit_t *pstInitParam, MID_EPG_Handle_t *handle);

/**
 * @brief Uninitializes the EPG module and deallocates resources.
 *
 * This attempts to uninitialize EPG module.
 *
 * @note Once the EPG module has been uninitialized, calling this API again
 * will do nothing and will simply return successful infomation.
 *
 * @param handle The EPG module handle retrived from #MID_EPGInit.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGDeInit(MID_EPG_Handle_t *handle);

/**
 * @brief Start EPG module appointed by EPG handle.
 *
 * Enables EPG processing.
 *
 * @note Once the EPG module has been started, calling this API again
 * will do nothing and will simply return successful infomation.
 *
 * @param handle The EPG module handle retrived from #MID_EPGInit.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGStart(MID_EPG_Handle_t handle);

/**
 * @brief Stop demux.
 *
 * Disables EPG processing.
 *
 * @note Once the EPG module has been stopped, calling this API again
 * will do nothing and will simply return successful infomation.
 *
 * @param handle The EPG module handle retrived from #MID_EPGInit.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGStop(MID_EPG_Handle_t handle);

/**
* === EPG Event navagation ===
*/
/**
 * @brief Get the first event in the list.
 *
 * This is used to get the frist event in the list.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param p_stServLoc Service locator.
 *
 * @param event_handle The returned event handle.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetFirstEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, MID_EPG_EventHandle_t *event_handle, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the last event in the list.
 *
 * This is used to get the last event in the list.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param p_stServLoc Service locator.
 *
 * @param event_handle The returned event handle.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetLastEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, MID_EPG_EventHandle_t *event_handle, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the next event referred by event_handle in the list.
 *
 * This is used to get the next event in the list.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The reference event handle. Each call the returned
 * event handle is put here.
 *
 * @return On success, Pointer to #EPGCACHE_Event_t is returned, On failure, #gsl_null
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetNextEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, MID_EPG_EventHandle_t *event_handle, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the previous event referred by p_stRef in the list.
 *
 * This is used to get the previous event in the list.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The reference event handle. Each call the returned
 * event handle is put here.
 *
 * @return On success, Pointer to #EPGCACHE_Event_t is returned, On failure, #gsl_null
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGPrevEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, MID_EPG_EventHandle_t *event_handle, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the event associated with time.
 *
 * This is used to the event associated with time in the list.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param p_stServLoc Service locator.
 *
 * @param time Anchor time.
 *
 * @param event_handle The returned event handle.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetEventAt(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, UINT32 time,
	MID_EPG_EventHandle_t *event_handle, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the curr or next.
 *
 * This is used to the event associated with event type.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param p_stServLoc Service locator.
 *
 * @param b_Curr get current event or next event.
 *
 * @param event_handle The returned event handle.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetCurrNextEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, bool  b_Curr,
	MID_EPG_EventHandle_t *event_handle);

/**
 * @brief Remove service(s) of  the EPG module and deallocates service resources.
 *
 * This attempts to remove service(s) of EPG module.
 *
 * @note When any of original network id, transport stream id or service id
 * is of insignificance. It means it does not care about the value and match
 * any.
 *
 * @note RESERVED_ORIGINAL_NET_ID means that original_network_id is of insignificance.
 *
 * @note RESERVED_TRANSPORT_ID means that transport_id is of insignificance.
 *
 * @note RESERVED_SERVICE_ID means that service_id is of insignificance.
 *
 * @param handle The EPG module handle retrived from #MID_EPGInit.
 *
 * @param stServLoc Service locator.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGClearChannel(MID_EPG_Handle_t handle,
	MID_ServLocator_t stServLoc);

/**
 * @brief Lock channels.
 *
 * This is used to lock channels to avoid removing from memory buffer.
 *
 * @note When this interface is called again, the previous settings are
 * removed automatically.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param p_stServLoc Service locator.
 *
 * @param channel_num The number of p_stServLoc.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGLockChannels(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, UINT16 channel_num);

/**
 * @brief Get the event information.
 *
 * This is used to get event information.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The event handle.
 *
 * @param p_stEventInfo Event information to be stored.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetEventInfo(MID_EPG_Handle_t handle,
	MID_EPG_EventHandle_t event_handle, MID_ServLocator_t *SrvLoc, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the event descriptor for 0x4D or 0x4E.
 *
 * This is used to get  0x4D or 0x4E descriptor.
 *
 * @note when the size is equal to zero, it means it receive the first
 * descriptor if existed.
 *
 * @note The memory for p_stEventDetail is allocated dynamically.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The event handle.
 *
 * @param tag The descriptor tag.
 *
 * @param lang Pointer to array of ISO 639 language code.
 *
 * @param size The size of array.
 *
 * @param p_stEventDetail Event descriptor(0x4D or 0x4E) to be stored.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetEventDetail(MID_EPG_Handle_t handle,
	MID_EPG_EventHandle_t event_handle, MID_ServLocator_t *SrvLoc, UINT8 **lang, UINT16 size,
	MID_SIDesc_EventDetail_t *p_stEventDetail, MID_EPGEventInfo_t *p_stEventInfo);

/**
 * @brief Get the event  0x4E.
 *
 * This is used to get  0x4E descriptor.
 *
 * @note when the size is equal to zero, it means it receive the first
 * descriptor if existed.
 *
 * @note The memory for p_stEventDetail is allocated dynamically.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The event handle.
 *
 * @param tag The descriptor tag.
 *
 * @param lang Pointer to array of ISO 639 language code.
 *
 * @param size The size of array.
 *
 * @param p_stEventDetail Event descriptor(0x4D or 0x4E) to be stored.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetExtendEvent(MID_EPG_Handle_t handle,
	MID_EPG_EventHandle_t event_handle, MID_ServLocator_t *SrvLoc, UINT8 **lang, UINT16 size,
	UINT16 *offset, MID_SIDesc_ExtEventDetail_t *p_stExtEventInfo);

/**
 * @brief Get the event descriptor.
 *
 * This is used to get epg descriptor.
 *
 * @note Currently this interface just returns raw descriptor data. and
 * maybe it will be modified later.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param event_handle The event handle.
 *
 * @param tag The descriptor tag.
 *
 * @param offset The offset to get the descriptor from.
 *
 * @param status When status is #gsl_true, the descriptor is parsed. If the
 * decDescTag is contained in buffer, but the parsing processing is not
 * implemented, then the raw data(including tag and length field) is returned
 * and the status is set to #gsl_false.
 *
 * @param pDesc Event descriptor data to be stored.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetDesc(MID_EPG_Handle_t handle,
	MID_EPG_EventHandle_t event_handle, MID_ServLocator_t *SrvLoc, UINT8 tag, UINT16 *offset, bool *status, void *pDesc);

/**
 * @brief Get the number of  events in the service.
 *
 * This is used to get the number of events in the service.
 *
 * @param handle The EPG cache handle retrived from #MID_EPGInit.
 *
 * @param count The returned total number of events.
 *
 * @return On success, MID_EPG_SUCCESS is returned, On failure, the other
 *        value is returned.
 */
MID_EPG_Return_t MID_EPGGetTotalEvent(MID_EPG_Handle_t handle,
	MID_ServLocator_t *p_stServLoc, UINT32 *count);

MID_EPG_Return_t MID_EPGSetCurrTSIDORGID(UINT16 ORGID, UINT16 TSID);

MID_EPG_Return_t MID_EPGSetCountryCode(INT8 *countrycode);

#ifdef SUPPORT_CLEAN_EX_DESCRIPTOR
MID_EPG_Return_t MID_EPGCleanExDescriptor(MID_EPG_Handle_t handle);

MID_EPG_Return_t MID_EPGReceiveExDescriptor(MID_EPG_Handle_t handle);
#endif

#ifdef SUPPORT_CLEAN_EPG
MID_EPG_Return_t MID_EPGCleanEPG(MID_EPG_Handle_t handle);

MID_EPG_Return_t MID_EPGReceiveEPG(MID_EPG_Handle_t handle);
#endif

#ifdef __cplusplus
}
#endif

#endif /* SUNMEDIA_MID_EPG_INCLUDED */