ap_dbacc.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
// pre-processor mechanism so multiple inclusions don't cause compilation error

#ifndef _AP_DBACC_H
#define _AP_DBACC_H

#include "techtype.h"
#include "ap_common.h"
#include "stbhwtun.h"
#include "stbdpc.h"     // required for E_STB_DP_TMODE and E_STB_DP_BWIDTH
#include "stbsitab.h"   /* Required for E_ICON_COORD_SYSTEM */
#include "stbgc.h"

//---Constant and macro definitions for public use-----------------------------

#define ADB_INVALID_DVB_ID                0xffff

#define LINK_TYPE_CA_REPLACEMENT_SERVICE  0x03
#define LINK_TYPE_SERVICE_REPLACEMENT     0x05

// number of service names (default name + preferred names)
#define ADB_NUM_SERV_NAME_IDS    6

//maximum number of favgroups that can be handled by the database
#define ADB_MAX_FAVGROUPS        8

/* LNB freq bands */
#define LNB_C_BAND_FREQUENCY              5150

#define LNB_KU_BAND_FREQUENCY_MINIMUM     9750
#define LNB_KU_BAND_FREQUENCY_MAXIMUM     12000

#define LNB_KU_BAND_FREQUENCY_LOW         LNB_KU_BAND_FREQUENCY_MINIMUM
#define LNB_KU_BAND_FREQUENCY_HIGH        10600

//---Enumerations for public use-----------------------------------------------
typedef enum
{
   ADB_TRANSPORT_LIST_ALL       = 0xff,
   ADB_TRANSPORT_LIST_NOT_TUNED = 0x01,
   ADB_TRANSPORT_LIST_TUNED     = 0x02
} ADB_TRANSPORT_LIST_TYPE;

typedef enum
{
   ADB_SERVICE_LIST_UNKNOWN     = 0x0000,
   ADB_SERVICE_LIST_TV          = 0x0001,    // these definitions can be ORed together to make
   ADB_SERVICE_LIST_RADIO       = 0x0002,    // combinations, e.g.
   ADB_SERVICE_LIST_DATA        = 0x0004,    // ADB_SERVICE_LIST_TV | ADB_SERVICE_LIST_DATA
   ADB_SERVICE_LIST_DIGITAL     = 0x0007,
   ADB_SERVICE_LIST_IP          = 0x0020,    // IP services
   ADB_SERVICE_LIST_FREESAT     = 0x0040,    // Flag to say that MUST be valid freesat services
   ADB_SERVICE_LIST_ANALOG      = 0x0080,
   ADB_SERVICE_LIST_TV_DATA     = 0x0085,
   ADB_SERVICE_LIST_FAV_GROUP_A = 0x0100,
   ADB_SERVICE_LIST_FAV_GROUP_B = 0x0200,
   ADB_SERVICE_LIST_FAV_GROUP_C = 0x0400,
   ADB_SERVICE_LIST_FAV_GROUP_D = 0x0800,
   ADB_SERVICE_LIST_ALL         = (ADB_SERVICE_LIST_DIGITAL | ADB_SERVICE_LIST_ANALOG),
   ADB_SERVICE_LIST_FAV_LIST    = 0x8000
} ADB_SERVICE_LIST_TYPE;

/* Macro to define an ADB_SERVICE_LIST_TYPE for a favourite list */
#define ADB_LIST_TYPE_FROM_FAVLIST(id)  (((id) << 16) | ADB_SERVICE_LIST_FAV_LIST)
#define ADB_FAVLIST_FROM_LIST_TYPE(L)  (U8BIT)((L) >> 16)

typedef enum /* These values come from the 8bit service type field in the service descriptor */
{
   ADB_SERVICE_TYPE_TV                    = 0x01,
   ADB_SERVICE_TYPE_RADIO                 = 0x02,
   ADB_SERVICE_TYPE_TELETEXT              = 0x03,
   ADB_SERVICE_TYPE_NVOD_REF              = 0x04,
   ADB_SERVICE_TYPE_NVOD_TIMESHIFT        = 0x05,
   ADB_SERVICE_TYPE_MOSAIC                = 0x06,
   ADB_SERVICE_TYPE_AVC_RADIO             = 0x0a,
   ADB_SERVICE_TYPE_AVC_MOSAIC            = 0x0b,
   ADB_SERVICE_TYPE_DATA                  = 0x0c,
   ADB_SERVICE_TYPE_MPEG2_HD              = 0x11,
   ADB_SERVICE_TYPE_AVC_SD_TV             = 0x16,
   ADB_SERVICE_TYPE_AVC_SD_NVOD_TIMESHIFT = 0x17,
   ADB_SERVICE_TYPE_AVC_SD_NVOD_REF       = 0x18,
   ADB_SERVICE_TYPE_HD_TV                 = 0x19,
   ADB_SERVICE_TYPE_AVC_HD_NVOD_TIMESHIFT = 0x1a,
   ADB_SERVICE_TYPE_AVC_HD_NVOD_REF       = 0x1b,
   ADB_SERVICE_TYPE_UHD_TV                = 0x1f,
   /* Values beloow are chosen so that they do not conflict with broadcast values */
   ADB_SERVICE_TYPE_ANALOG                = 0x100,
   ADB_SERVICE_TYPE_DSD                   = 0x101,
   ADB_SERVICE_TYPE_VIRTUAL               = 0x102
} ADB_SERVICE_TYPE;

typedef enum
{
   /* Video stream types, from least to most preferred */
   ADB_VIDEO_STREAM,
   ADB_H264_VIDEO_STREAM,
   ADB_H265_VIDEO_STREAM,
   ADB_AVS_VIDEO_STREAM,

   /* Audio stream types */
   ADB_AUDIO_STREAM,
   ADB_AAC_AUDIO_STREAM,
   ADB_HEAAC_AUDIO_STREAM,
   ADB_HEAACv2_AUDIO_STREAM,
   ADB_AC3_AUDIO_STREAM,
   ADB_EAC3_AUDIO_STREAM,

   /* Other stream types */
   ADB_SUBTITLE_STREAM,
   ADB_DATA_STREAM,
   ADB_TTEXT_STREAM,

   ADB_UNKNOWN_STREAM
} ADB_STREAM_TYPE;

typedef enum
{
   ADB_STREAM_LIST_ALL        = 0xff,
   ADB_VIDEO_LIST_STREAM      = 0x01,
   ADB_AUDIO_LIST_STREAM      = 0x02,
   ADB_SUBTITLE_LIST_STREAM   = 0x04,
   ADB_DATA_LIST_STREAM       = 0x08,
   ADB_TTEXT_LIST_STREAM      = 0x10,
   ADB_TTEXT_SUBT_LIST_STREAM = 0x20
} ADB_STREAM_LIST_TYPE;


typedef enum
{
   ADB_AUDIO_TYPE_UNDEFINED             = 0,
   ADB_AUDIO_TYPE_NORMAL                = 0, /* This name is deprecated and was incorrectly defined as 1
                                              * but is retained for backwards compatibility */
   ADB_AUDIO_TYPE_CLEAN_EFFECTS         = 1,
   ADB_AUDIO_TYPE_FOR_HEARING_IMPAIRED  = 2,
   ADB_AUDIO_TYPE_FOR_VISUALLY_IMPAIRED = 3
} ADB_AUDIO_TYPE;


typedef enum
{
   ADB_SUBTITLE_TYPE_DVB                    = 0x10,
   ADB_SUBTITLE_TYPE_DVB_4_3                = 0x11,
   ADB_SUBTITLE_TYPE_DVB_16_9               = 0x12,
   ADB_SUBTITLE_TYPE_DVB_221_1              = 0x13,
   ADB_SUBTITLE_TYPE_DVB_HD                 = 0x14,
   ADB_SUBTITLE_TYPE_DVB_HARD_HEARING       = 0x20,
   ADB_SUBTITLE_TYPE_DVB_HARD_HEARING_4_3   = 0x21,
   ADB_SUBTITLE_TYPE_DVB_HARD_HEARING_16_9  = 0x22,
   ADB_SUBTITLE_TYPE_DVB_HARD_HEARING_221_1 = 0x23,
   ADB_SUBTITLE_TYPE_DVB_HARD_HEARING_HD    = 0x24
} ADB_SUBTITLE_TYPE;

typedef enum
{
   ADB_TELETEXT_TYPE_INITIAL               = 0x01,
   ADB_TELETEXT_TYPE_SUBTITLE              = 0x02,
   ADB_TELETEXT_TYPE_ADDITIONAL_INFO       = 0x03,
   ADB_TELETEXT_TYPE_SCHEDULE              = 0x04,
   ADB_TELETEXT_TYPE_SUBTITLE_HARD_HEARING = 0x05
} ADB_TELETEXT_TYPE;

typedef enum
{
   ADB_EVENT_CONTENT_UNCLASSIFIED  = 0x00,
   ADB_EVENT_CONTENT_MOVIE         = 0x10,
   ADB_EVENT_CONTENT_NEWS          = 0x20,
   ADB_EVENT_CONTENT_ENTERTAINMENT = 0x30,
   ADB_EVENT_CONTENT_SPORT         = 0x40,
   ADB_EVENT_CONTENT_CHILD         = 0x50,
   ADB_EVENT_CONTENT_MUSIC         = 0x60,
   ADB_EVENT_CONTENT_ARTS          = 0x70,
   ADB_EVENT_CONTENT_SOCIAL        = 0x80,
   ADB_EVENT_CONTENT_EDUCATION     = 0x90,
   ADB_EVENT_CONTENT_LEISURE       = 0xA0,
   ADB_EVENT_CONTENT_SPECIAL       = 0xB0,
   ADB_EVENT_CONTENT_RESERVED1     = 0xC0,
   ADB_EVENT_CONTENT_RESERVED2     = 0xD0,
   ADB_EVENT_CONTENT_RESERVED3     = 0xE0,
   ADB_EVENT_CONTENT_USERDEFINED   = 0xF0,
} ADB_EVENT_CONTENT;

typedef enum
{
   FAV_GROUP_A   = 0x01,
   FAV_GROUP_B   = 0x02,
   FAV_GROUP_C   = 0x04,
   FAV_GROUP_D   = 0x08,
   FAV_GROUP_ALL = 0x0f
} ADB_FAV_GROUP;

typedef enum
{
   ADB_PROFILE_TYPE_BROADCAST,
   ADB_PROFILE_TYPE_CIPLUS
} ADB_PROFILE_TYPE;

//---Global type defs for public use-------------------------------------------

typedef struct
{
   E_STB_DP_LNB_TYPE type;
   E_STB_DP_LNB_POWER power;
   E_STB_DP_DISEQC_TONE diseqc_tone;
   E_STB_DP_DISEQC_CSWITCH c_switch;
   BOOLEAN is_22k;
   BOOLEAN is_12v;
   BOOLEAN is_pulse_posn;
   BOOLEAN is_diseqc_posn;
   BOOLEAN is_smatv;
   U8BIT diseqc_repeats;      // 0 to 3 inclusive
   U8BIT u_switch;            // 0 to 16 inclusive
   U8BIT unicable_chan;
   U32BIT unicable_if;
   U8BIT *name;
} ADB_LNB_SETTINGS;

typedef struct
{
   U8BIT stream_content;
   U8BIT component_type;
   U8BIT component_tag;
   U8BIT language_code[3];
} ADB_EVENT_COMPONENT_INFO;

typedef struct
{
   U8BIT *item_description;
   U8BIT *item;
} ADB_EVENT_ITEMIZED_INFO;

//---Global Function prototypes for public use---------------------------------

void ADB_ResetDatabase(void);

void ADB_SaveDatabase(void);

void ADB_SaveEventSchedule(E_STB_DP_SIGNAL_TYPE tuner_type, void *satellite);

void ADB_DeleteServices(E_STB_DP_SIGNAL_TYPE tuner_type, void *satellite);

void ADB_ReleaseNameList(U8BIT **name_list, U16BIT num_names);

U16BIT ADB_GetNumLNBBands(void);

void* ADB_AddLNBBand(S_STB_DP_LNB_BAND *band_parameters, void *lnb_ptr);

void* ADB_GetNextLNBBand(void *band_ptr);

void* ADB_GetLNBBandLNB(void *band_ptr);

BOOLEAN ADB_GetLNBBandParameters(void *band_ptr, S_STB_DP_LNB_BAND *params);

void ADB_DeleteAssociatedLNBBands(void *lnb_ptr);

U16BIT ADB_GetNumSatellites(void);

void* ADB_AddSatellite(U8BIT *name_str, U16BIT dish_pos, U16BIT long_pos, BOOLEAN east_west, void *lnb_ptr);

void* ADB_GetNextSatellite(void *sat_ptr);

U8BIT* ADB_GetSatelliteName(void *sat_ptr);

void* ADB_GetSatelliteLNB(void *sat_ptr);

U16BIT ADB_GetSatelliteLongitude(void *sat_ptr);

BOOLEAN ADB_GetSatelliteDirection(void *sat_ptr);

U16BIT ADB_GetNumLNBs(void);

void* ADB_AddLNB(ADB_LNB_SETTINGS *settings);

void* ADB_GetNextLNB(void *lnb_ptr);

BOOLEAN ADB_GetLNBSettings(void *lnb_ptr, ADB_LNB_SETTINGS *settings);

U16BIT ADB_GetNumNetworks(void);

void ADB_GetNetworkList(void ***nlist_ptr, U16BIT *num_entries_ptr);

void ADB_ReleaseNetworkList(void **nlist);

U8BIT** ADB_GetNetworkListNames(void **nlist, U16BIT num_entries, BOOLEAN short_names);

U32BIT* ADB_GetNetworkListIds(void **nlist, U16BIT num_entries);

U8BIT* ADB_GetNetworkName(void *n_ptr);

U8BIT* ADB_GetNetworkNameByLang(void *n_ptr, U8BIT lang);

U16BIT ADB_GetNetworkId(void *n_ptr);

U8BIT ADB_GetNetworkTargetCountries(U32BIT **code_array);

U16BIT ADB_GetNetworkPrimaryTargetRegions(U32BIT country_code, U8BIT **code_array, U8BIT ***name_array);

U16BIT ADB_GetNetworkSecondaryTargetRegions(U32BIT country_code, U8BIT primary_region,
   U8BIT **code_array, U8BIT ***name_array);

U16BIT ADB_GetNetworkTertiaryTargetRegions(U32BIT country_code, U8BIT primary_region,
   U8BIT secondary_region, U16BIT **code_array, U8BIT ***name_array);

void* ADB_GetTunedNetwork(U8BIT path);

U16BIT ADB_GetNumTransports(void);

void* ADB_AddIPTransport(U16BIT onet_id, U16BIT tran_id, U8BIT *url);

void ADB_GetTransportList(void ***tlist_ptr, U16BIT *num_entries_ptr);

void ADB_GetTransportListForTunerType(E_STB_DP_SIGNAL_TYPE tuner_type, void ***tlist_ptr,
   U16BIT *num_entries_ptr);

void ADB_GetNetworkTransportList(void *n_ptr, void ***tlist_ptr, U16BIT *num_entries_ptr);

void ADB_ReleaseTransportList(void **tlist, U16BIT num_transports);

U8BIT** ADB_GetTransportListNames(void **tlist, U16BIT num_entries);

U32BIT* ADB_GetTransportListTids(void **tlist, U16BIT num_entries);

U32BIT* ADB_GetTransportListTunedStrengths(void **tlist, U16BIT num_entries);

U32BIT* ADB_GetTransportListOriginalNetworkIds(void **tlist, U16BIT num_entries);

U32BIT* ADB_GetTransportListFreqs(void **tlist, U16BIT num_entries);

E_STB_DP_SIGNAL_TYPE ADB_GetTransportSignalType(void *t_ptr);

U8BIT* ADB_GetTransportName(void *t_ptr);

U16BIT ADB_GetTransportTid(void *t_ptr);

U16BIT ADB_GetTransportOriginalNetworkId(void *t_ptr);

void* ADB_GetTransportNetworkPtr(void *t_ptr);

U32BIT ADB_GetTransportFreqHz(void *t_ptr);

U8BIT ADB_GetTransportBwidth(void *t_ptr);

S8BIT ADB_GetTransportOffset(void *t_ptr);

E_STB_TUNE_TCONST ADB_GetTransportConstellation(void *t_ptr);

E_STB_DP_TMODE ADB_GetTransportTerrMode(void *t_ptr);

E_STB_TUNE_TCODERATE ADB_GetTransportLpCodeRate(void *t_ptr);

E_STB_TUNE_TCODERATE ADB_GetTransportHpCodeRate(void *t_ptr);

E_STB_TUNE_TGUARDINT ADB_GetTransportGuardInt(void *t_ptr);

E_STB_TUNE_THIERARCHY ADB_GetTransportHierarchy(void *t_ptr);

E_STB_DP_CMODE ADB_GetTransportCableMode(void *t_ptr);

U16BIT ADB_GetTransportCableSymbolRate(void *t_ptr);

U16BIT ADB_GetTransportSatelliteSymbolRate(void *t_ptr);

U8BIT ADB_GetTransportTunedStrength(void *t_ptr);

U8BIT ADB_GetTransportTunedQuality(void *t_ptr);

void* ADB_GetFullSITransport(void *n_ptr);

void* ADB_GetEPGService(void *n_ptr);

void ADB_GetTransportTerrestrialTuningParams(void *t_ptr, E_STB_DP_TTYPE *terr_type, U32BIT *freq_hz,
   E_STB_DP_TMODE *mode, E_STB_DP_TBWIDTH *bwidth, U8BIT *plp_id);

void ADB_GetTransportAnalogTuningParams(void *t_ptr, U32BIT *freq_hz, S8BIT *offset,
   E_STB_DP_ANALOG_VIDEO_TYPE *vtype);

void ADB_GetTransportCableTuningParams(void *t_ptr, U32BIT *freq_hz, E_STB_DP_CMODE *mode,
   U16BIT *symrate);

void ADB_GetTransportSatTuningParams(void *t_ptr, U32BIT *freq_hz, E_STB_DP_POLARITY *polarity,
   U16BIT *symrate, E_STB_DP_FEC *fec, BOOLEAN *dvb_s2, E_STB_DP_MODULATION *modulation);

void* ADB_GetTransportSatellite(void *t_ptr);

void* ADB_GetTransportFromIds(U16BIT net_id, U16BIT onet_id, U16BIT tran_id);

void ADB_SetTunedTransport(U8BIT path, void *t_ptr);

void* ADB_GetTunedTransport(U8BIT path);

void* ADB_AddServiceUsingDsd(U8BIT *data, U16BIT service_id);

void* ADB_AddIPService(void *t_ptr, U16BIT service_id, ADB_SERVICE_TYPE type, U8BIT *name, U16BIT lcn,
   U8BIT *url, U16BIT port, E_STB_DP_FEC_LAYER fec_layer, S_STB_DP_FEC_LAYER_INFO *fec_info);

U16BIT ADB_GetNumServices(void);

U16BIT ADB_GetNumServicesInList(U32BIT list_type, BOOLEAN inc_hidden);

void ADB_GetServiceList(U32BIT list_type, void ***slist_ptr, U16BIT *num_entries_ptr);

void ADB_GetServiceListIncludingHidden(U32BIT list_type, void ***slist_ptr, U16BIT *num_entries_ptr,
   BOOLEAN ignore_selectable);

U16BIT ADB_GetNumDeletedServices(E_STB_DP_SIGNAL_TYPE tuner_type);

U16BIT ADB_GetDeletedServiceList(E_STB_DP_SIGNAL_TYPE tuner_type, void ***slist_ptr);

void ADB_GetTransportServiceList(void *t_ptr, void ***slist_ptr, U16BIT *num_entries_ptr);

void ADB_GetNetworkServiceList(void *n_ptr, void ***slist_ptr, U16BIT *num_entries_ptr);

void ADB_GetUnavailableServiceList(void ***slist_ptr, U16BIT *num_entries_ptr);

void ADB_GetLockedServiceList(void ***slist_ptr, U16BIT *num_entries_ptr);

void ADB_ReleaseServiceList(void **slist, U16BIT num_servs);

void ADB_GetServiceListLockedSubset(void **slist, U16BIT num_entries,
   void ***locked_slist_ptr, U16BIT *locked_num_entries_ptr);

void ADB_SortServiceListAlphabetically(void **slist, U16BIT num_entries, BOOLEAN short_name);

BOOLEAN ADB_IsValidService(void *serv_ptr);

E_STB_DP_SIGNAL_TYPE ADB_GetServiceSignalType(void *s_ptr, BOOLEAN *is_sig2);

void* ADB_GetNextServiceInList(U32BIT list_type, void *serv);

void* ADB_GetPrevServiceInList(U32BIT list_type, void *serv);

void* ADB_FindServiceByLcn(U32BIT list_type, U16BIT lcn, BOOLEAN show_unselectable);

void* ADB_FindServiceByNearestLcn(U32BIT list_type, U16BIT lcn);

void* ADB_FindServiceByIds(U16BIT onet_id, U16BIT tid, U16BIT sid);

U16BIT ADB_FindLcnInServiceList(U16BIT lcn, void **slist_ptr, U16BIT num_entries);

U16BIT ADB_FindNearestLcnInServiceList(U16BIT lcn, void **slist_ptr, U16BIT num_entries);

U16BIT ADB_FindServiceInList(void *s_ptr, void **slist_ptr, U16BIT num_entries);

U8BIT** ADB_GetServiceListFullNames(void **slist, U16BIT num_entries, BOOLEAN use_pref_names);

U8BIT** ADB_GetServiceListShortNames(void **slist, U16BIT num_entries, BOOLEAN use_pref_names);

U16BIT* ADB_GetServiceListLcns(void **slist, U16BIT num_entries);

U16BIT* ADB_GetServiceListOrigLcns(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListUnavailableFlag(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListNewFlag(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListLockedFlag(void **slist, U16BIT num_entries);

void ADB_SetServiceListLockedFlag(void **slist, U16BIT num_entries, BOOLEAN locked);

U32BIT* ADB_GetServiceListScrambledFlag(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListHdFlag(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListHiddenFlag(void **slist, U16BIT num_entries);

U8BIT** ADB_GetServiceListNetworkNames(void **slist, U16BIT num_entries);

U8BIT** ADB_GetServiceListTransportNames(void **slist, U16BIT num_entries);

U32BIT* ADB_GetServiceListTransportStrengths(void **slist, U16BIT num_entries);

void ADB_SetServiceHiddenFlag(void *s_ptr, BOOLEAN hidden);

BOOLEAN ADB_GetServiceHiddenFlag(void *s_ptr);

BOOLEAN ADB_GetServiceSelectableFlag(void *s_ptr);

BOOLEAN ADB_GetServiceLcnEditable(void *s_ptr);

void ADB_SetServiceDeletedFlag(void *s_ptr, BOOLEAN deleted);

U8BIT* ADB_GetServiceFullName(void *s_ptr, BOOLEAN use_pref_name);

U8BIT* ADB_GetServiceShortName(void *s_ptr, BOOLEAN use_pref_name);

U8BIT* ADB_GetServiceFullNameByLangAndPrefId(void *s_ptr, U8BIT lang, U8BIT pref_name_id);

U8BIT* ADB_GetServiceShortNameByLangAndPrefId(void *s_ptr, U8BIT lang, U8BIT pref_name_id);

U16BIT ADB_GetServiceLcn(void *s_ptr);

void ADB_SetServiceLcn(void *s_ptr, U16BIT lcn);

U16BIT ADB_GetServiceId(void *s_ptr);

void ADB_GetServiceIds(void *s_ptr, U16BIT *onet_id, U16BIT *trans_id, U16BIT *serv_id);

void ADB_SetServiceScheduleState(void *s_ptr, BOOLEAN state);

BOOLEAN ADB_GetServiceScheduleState(void *s_ptr);

void ADB_SetServiceNowNextState(void *s_ptr, BOOLEAN state);

BOOLEAN ADB_GetServiceNowNextState(void *s_ptr);

void ADB_SortServicesByLcn(void);

U16BIT ADB_GetServiceOrigLcn(void *s_ptr);

U16BIT ADB_GetServicePCRPid(void *s_ptr);

U16BIT ADB_GetServiceAudioPid(void *s_ptr);

ADB_STREAM_TYPE ADB_GetServiceAudioType(void *s_ptr);

U16BIT ADB_GetServiceVideoPid(void *s_ptr);

ADB_STREAM_TYPE ADB_GetServiceVideoType(void *s_ptr);

U16BIT ADB_GetServiceTextPid(void *s_ptr);

BOOLEAN ADB_GetServiceIsHd(void *s_ptr);

U16BIT ADB_GetRequiredAudioPid(void *s_ptr);

U16BIT ADB_GetRequiredADPid(void *s_ptr, BOOLEAN *broadcast_mix);

E_STB_DP_AUDIO_MODE ADB_GetRequiredAudioMode(void *s_ptr);

U16BIT ADB_GetRequiredTtextPid(void *s_ptr, BOOLEAN for_subtitles, U8BIT *magazine, U8BIT *page);

U16BIT ADB_GetRequiredSubtitleParams(void *s_ptr, U16BIT *cpage_ptr, U16BIT *apage_ptr);

ADB_SERVICE_TYPE ADB_GetServiceType(void *s_ptr);

U8BIT* ADB_GetServiceProviderName(void *s_ptr);

U8BIT* ADB_GetServiceProviderNameByLang(void *s_ptr, U8BIT lang);

BOOLEAN ADB_GetServiceUnavailableFlag(void *s_ptr);

U8BIT ADB_GetServiceRunningStatus(void *s_ptr);

BOOLEAN ADB_GetServiceNotRunningFlag(void *s_ptr);

BOOLEAN ADB_GetServiceNewFlag(void *s_ptr);

BOOLEAN ADB_GetServiceLockedFlag(void *s_ptr);

void ADB_ToggleServiceLockedFlag(void *s_ptr);

void ADB_SetServiceLockedFlag(void *s_ptr, BOOLEAN locked);

BOOLEAN ADB_GetServiceScrambledFlag(void *s_ptr);

BOOLEAN ADB_GetServiceHasCaDesc(void *s_ptr);

BOOLEAN ADB_GetServiceDoNotScramble(void *s_ptr);

U8BIT ADB_GetServiceContentProtectionLevel(void *s_ptr);

BOOLEAN ADB_IsFreesatService(void *s_ptr);

U16BIT ADB_GetFreesatServiceId(void *s_ptr);

void* ADB_GetServiceTransportPtr(void *s_ptr);

U8BIT* ADB_GetServiceDefaultAuthority(void *serv_ptr);

void ADB_ServiceAddRCTLink(void *serv_ptr, void *link_ptr);

void ADB_ServiceReleaseRCTLinks(void *serv_ptr);

U8BIT ADB_GetServiceNumRCTLinks(void *serv_ptr);

void* ADB_GetServiceRCTLinks(void *serv_ptr, U8BIT *num_links);

void* ADB_GetNextRCTLink(void *link_ptr);

void ADB_ReleaseRCTLinks(void *links);

U8BIT* ADB_GetRCTLinkPromoText(void *link_ptr);

BOOLEAN ADB_IsRCTLinkGroupTrailer(void *link_ptr);

U8BIT* ADB_GetRCTLinkName(void *link_ptr);

U8BIT* ADB_GetRCTLinkUriString(void *link_ptr);

BOOLEAN ADB_ServiceRCTCanUseDefaultIcon(void *serv_ptr);

BOOLEAN ADB_ServiceGetRCTIcon(void *serv_ptr, U8BIT **icon_data, U32BIT *data_size, BOOLEAN *pos_valid,
   U16BIT *x_pos, U16BIT *y_pos, U16BIT *width, U16BIT *height, E_ICON_COORD_SYSTEM *coord_system);

BOOLEAN ADB_ServiceAddImageIcon(void *serv_ptr, void *icon_ptr);

void* ADB_GetAlternativeService(void *s_ptr, U8BIT alt_serv_type);

U16BIT ADB_ServiceGetSubtitlePid(void *serv_ptr, ADB_SUBT_INFO *subt_info);

BOOLEAN ADB_ServiceHasSubtitles(void *serv_ptr, E_SUBTITLE_FORMAT *subs_format);

void ADB_SetTunedService(U8BIT path, void *s_ptr);

void* ADB_GetTunedService(U8BIT path);

void ADB_DeleteServiceRec(void *s_ptr);

U16BIT ADB_GetNumStreams(void *serv_ptr, ADB_STREAM_LIST_TYPE stream_list_type);

void ADB_GetStreamList(void *serv_ptr, ADB_STREAM_LIST_TYPE stream_list_type, void ***streamlist_ptr, U16BIT *num_entries_ptr);

void ADB_ReleaseStreamList(void **streamlist_ptr, U16BIT num_entries);

ADB_STREAM_TYPE ADB_GetStreamType(void *stream_ptr);

U8BIT ADB_GetStreamNumTags(void *stream_ptr);

U8BIT ADB_GetStreamTag(void *stream_ptr, U8BIT index);

U8BIT ADB_GetStreamNumCaptionServices(void *stream_ptr);

BOOLEAN ADB_GetCaptionServiceDigitalCc(void *stream_ptr, U8BIT index);

U8BIT ADB_GetCaptionServiceNumber(void *stream_ptr, U8BIT index);

BOOLEAN ADB_GetCaptionServiceEasyReader(void *stream_ptr, U8BIT index);

BOOLEAN ADB_GetCaptionServiceWideAspectRatio(void *stream_ptr, U8BIT index);

U32BIT ADB_GetCaptionServiceLangCode(void *stream_ptr, U8BIT index);

U16BIT ADB_GetStreamTagContentType(void *stream_ptr, U8BIT index);

U16BIT ADB_GetStreamPID(void *stream_ptr);

BOOLEAN ADB_GetStreamInUse(void *stream_ptr);

S8BIT ADB_GetStreamCcInUse(void *stream_ptr);

BOOLEAN ADB_GetStreamHasCaDesc(void *stream_ptr);

U8BIT ADB_GetStreamComponentType(void *stream_ptr);

U32BIT ADB_GetAudioStreamLangCode(void *stream_ptr);

ADB_AUDIO_TYPE ADB_GetAudioStreamType(void *stream_ptr);

E_STB_DP_AUDIO_MODE ADB_GetAudioStreamMode(void *stream_ptr);

U32BIT ADB_GetTtextStreamLangCode(void *stream_ptr);

U8BIT ADB_GetTtextStreamType(void *stream_ptr);

U8BIT ADB_GetTtextStreamMagazine(void *stream_ptr);

U8BIT ADB_GetTtextStreamPage(void *stream_ptr);

U32BIT ADB_GetSubtitleStreamLangCode(void *stream_ptr);

ADB_SUBTITLE_TYPE ADB_GetSubtitleStreamType(void *stream_ptr);

U16BIT ADB_GetSubtitleStreamCompositionPage(void *stream_ptr);

U16BIT ADB_GetSubtitleStreamAncillaryPage(void *stream_ptr);

void ADB_SetAudioLang(U32BIT country_code, U8BIT lang_id);

void ADB_SetSecondaryAudioLang(U32BIT country_code, U8BIT lang_id);

void ADB_SetTextLang(U32BIT country_code, U8BIT lang_id);

void ADB_SetSecondaryTextLang(U32BIT country_code, U8BIT lang_id);

// now/next and schedule events

void ADB_GetNowNextEvents(void *serv_ptr, void **now_event, void **next_event);

void ADB_GetEventSchedule(BOOLEAN include_old_events, void *serv_ptr, void ***elist_ptr,
   U16BIT *num_entries_ptr);

void ADB_GetEventScheduleByGenre(ADB_EVENT_CONTENT genre, BOOLEAN include_old_events,
   void *serv_ptr, void ***elist_ptr, U16BIT *num_entries_ptr);

void ADB_ReleaseEventData(void *event_ptr);

void ADB_ReleaseEventList(void **elist, U16BIT num_entries);

void ADB_DeleteServiceEvents(void *serv_ptr, BOOLEAN delete_now_next);

void ADB_DeleteAllServiceEvents(BOOLEAN delete_now_next);

void* ADB_GetEvent(void *serv_ptr, U16BIT event_id);

U8BIT* ADB_GetEventSIDescriptorData(void *serv_ptr, U16BIT event_id, U8BIT dtag_id,
   S16BIT ext_dtag_id, U32BIT private_data_specifier, U16BIT *desc_len);

void ADB_ReleaseEventSIDescriptorData(U8BIT *desc_data, U16BIT desc_len);

void* ADB_EarlierEvent(void *serv_ptr, U32DHMS time);

void* ADB_LaterEvent(void *serv_ptr, U32DHMS time);

void* ADB_GetEarlierEvent(void *serv_ptr, U16BIT date, U8BIT hour, U8BIT min);

void* ADB_GetLaterEvent(void *serv_ptr, U16BIT date, U8BIT hour, U8BIT min);

void* ADB_FindEventFromTime(U32DHMS time, void *serv_ptr);

void* ADB_FindEITScheduleEventFromTime(U32DHMS time, void *serv_ptr);

U32DHMS ADB_GetEventStartDateTime(void *event_ptr);

U32DHMS ADB_GetEventDuration(void *event_ptr);

U32DHMS ADB_GetEventEndDateTime(void *event_ptr);

U16BIT ADB_GetEventStartDate(void *event_ptr);

U8BIT ADB_GetEventStartHour(void *event_ptr);

U8BIT ADB_GetEventStartMin(void *event_ptr);

U8BIT ADB_GetEventStartSecs(void *event_ptr);

U8BIT ADB_GetEventDurationHour(void *event_ptr);

U8BIT ADB_GetEventDurationMin(void *event_ptr);

U8BIT ADB_GetEventDurationSecs(void *event_ptr);

#if 0

BOOLEAN ADB_GetEventEndDateTime(void *event_ptr, U16BIT *end_date, U8BIT *end_hour, U8BIT *end_min);
#endif

BOOLEAN ADB_GetEventSubtitlesAvailFlag(void *event_ptr);

ADB_EVENT_CONTENT ADB_GetEventContentDesc(void *event_ptr);

U8BIT* ADB_GetEventContentData(void *event_ptr, U8BIT *p_len);

U8BIT ADB_GetEventParentalAge(void *event_ptr);

U8BIT* ADB_GetEventName(void *event_ptr);

U8BIT* ADB_GetEventDescription(void *event_ptr);

BOOLEAN ADB_GetEventHasExtendedDescription(void *event_ptr);

U8BIT* ADB_GetEventExtendedDescription(void *event_ptr);

U8BIT* ADB_GetEventGuidance(void *event_ptr, void *serv_ptr, U8BIT *type, U8BIT *mode);

U16BIT ADB_GetEventId(void *event_ptr);

BOOLEAN ADB_GetEventAudioDescriptionFlag(void *event_ptr);

BOOLEAN ADB_GetEventFreeToAir(void *event_ptr);

BOOLEAN ADB_GetEventDoNotScramble(void *event_ptr);

BOOLEAN ADB_GetEventHDLinkageInfo(void *event_ptr, BOOLEAN verify_event, BOOLEAN only_simulcast,
   void **hd_serv_ptr, void **hd_event_ptr);

BOOLEAN ADB_IsSameEvent(void *event1_ptr, void *event2_ptr);

U8BIT* ADB_GetEventFullProgrammeCrid(void *serv_ptr, void *event_ptr);

U8BIT* ADB_GetEventProgrammeCrid(void *serv_ptr, void *event_ptr);

U8BIT* ADB_GetFullCrid(void *serv_ptr, U8BIT *event_str);

U8BIT ADB_GetEventNumSeriesCrids(void *event_ptr);

U8BIT* ADB_GetEventSeriesCrid(U8BIT index, void *serv_ptr, void *event_ptr);

U8BIT ADB_GetEventNumRecommendationCrids(void *event_ptr);

U8BIT* ADB_GetEventRecommendationCrid(U8BIT index, void *serv_ptr, void *event_ptr);

U8BIT ADB_GetEventComponentList(void *event_ptr, ADB_EVENT_COMPONENT_INFO **component_list);

BOOLEAN ADB_IsSplitProgrammeCrid(U8BIT *crid);

U8BIT* ADB_GetAuthorityFromCrid(U8BIT *crid);

void* ADB_FindEventFromCrid(U8BIT *prog_crid, void *original_event_ptr, void **serv_ptr);

U8BIT ADB_GetServiceFavGroups(void *s_ptr);

void ADB_SetServiceFavGroups(void *s_ptr, U8BIT groups);

#if 0

void ADB_UnsetServiceFavGroupBit(void *s_ptr, U8BIT fgrp_bit);

void ADB_SetServiceTaggedFavGroupBit(U32BIT *tag_array, void **slist, U16BIT num_entries, U8BIT fgrp_bit);

void ADB_UnsetServiceTaggedFavGroupBit(U32BIT *tag_array, void **slist, U16BIT num_entries, U8BIT fgrp_bit);
#endif

void ADB_SetReqdAudioStreamSettings(void *s_ptr, BOOLEAN valid, U32BIT lang_code,
   ADB_AUDIO_TYPE audio_type, ADB_STREAM_TYPE stream_type);

void ADB_SetReqdAudioStreamPID(void *s_ptr, BOOLEAN valid, U16BIT pid);

void ADB_GetReqdAudioStreamSettings(void *s_ptr, BOOLEAN *valid, U32BIT *lang_code,
   ADB_AUDIO_TYPE *audio_type, ADB_STREAM_TYPE *stream_type);

void ADB_SetReqdSubtitleStreamSettings(void *s_ptr, BOOLEAN valid, U32BIT lang_code, ADB_SUBTITLE_TYPE subt_type);

void ADB_GetReqdSubtitleStreamSettings(void *s_ptr, BOOLEAN *valid, U32BIT *lang_code, ADB_SUBTITLE_TYPE *subt_type);

void ADB_SetReqdTeletextStreamSettings(void *s_ptr, BOOLEAN valid, U32BIT lang_code, ADB_TELETEXT_TYPE ttext_type);

void ADB_GetReqdTeletextStreamSettings(void *s_ptr, BOOLEAN *valid, U32BIT *lang_code, ADB_TELETEXT_TYPE *ttext_type);

void ADB_SetReqdCcStreamSettings(void *s_ptr, BOOLEAN valid, U32BIT lang_code, BOOLEAN digital_cc,
   U8BIT caption_service, BOOLEAN easy_reader, BOOLEAN wide_aspect_ratio);

void ADB_GetReqdCcStreamSettings(void *s_ptr, BOOLEAN *valid, U32BIT *lang_code, BOOLEAN *digital_cc,
   U8BIT *caption_service, BOOLEAN *easy_reader, BOOLEAN *wide_aspect_ratio);

void* ADB_AddCridRecord(U8BIT *crid, BOOLEAN series, BOOLEAN recommended);

void ADB_SaveCridRecord(void *c_ptr);

void* ADB_FindCridRecord(U8BIT *crid_str);

void ADB_SetCridDateTime(void *c_ptr, U32DHMS datetime);

void ADB_SetCridService(void *c_ptr, U16BIT serv_id);

void ADB_SetCridProgrammeName(void *c_ptr, U8BIT *prog_name);

U8BIT* ADB_GetCridProgrammeName(void *c_ptr);

BOOLEAN ADB_IsProgrammeCrid(void *c_ptr);

BOOLEAN ADB_IsSeriesCrid(void *c_ptr);

BOOLEAN ADB_IsRecommendationCrid(void *c_ptr);

void ADB_SetCridDoNotDelete(void *c_ptr, BOOLEAN do_not_delete);

BOOLEAN ADB_GetCridDoNotDelete(void *c_ptr);

void ADB_UpdateCridEitDate(void *c_ptr);

U8BIT* ADB_GetCridString(void *c_ptr);

U32DHMS ADB_GetCridDateTime(void *c_ptr);

U16BIT ADB_GetCridService(void *c_ptr);

U16BIT ADB_GetCridEitDate(void *c_ptr);

void ADB_DeleteCridRecord(void *c_ptr);

void ADB_GetCridRecordList(void ***clist_ptr, U16BIT *num_entries_ptr, BOOLEAN inc_series_crids,
   BOOLEAN inc_rec_crids, BOOLEAN inc_prog_crids);

void ADB_ReleaseCridRecordList(void **crid_list, U16BIT num_entries);

U16BIT ADB_GetProfileList(void ***profile_list, U16BIT *active_profile);

void ADB_ReleaseProfileList(void **profile_list, U16BIT num_profiles);

ADB_PROFILE_TYPE ADB_GetProfileType(void *profile);

ADB_SERVICE_LIST_TYPE ADB_GetServiceListTypeForCurrentProfile(void);

#ifdef COMMON_INTERFACE

void* ADB_FindProfileForModule(U32BIT module);

BOOLEAN ADB_DeleteProfile(void *profile);

U8BIT* ADB_GetProfileName(void *profile);

void ADB_MarkCIModulePresent(U16BIT cicam_onet_id, U32BIT cicam_id);

void ADB_MarkCIModuleNotPresent(U32BIT module);

BOOLEAN ADB_GetProfileModulePresent(void *profile);

U32BIT ADB_GetProfileModule(void *profile);

BOOLEAN ADB_GetProfileCAMInfo(void *profile, U16BIT *cicam_onet_id, U32BIT *cicam_id);

BOOLEAN ADB_SetProfileSearchRequired(void *profile, BOOLEAN search_required, U16BIT date,
   U8BIT hour, U8BIT min);

BOOLEAN ADB_GetProfileSearchRequired(void *profile);

BOOLEAN ADB_GetProfileSearchDateTime(void *profile, U16BIT *date, U8BIT *hours, U8BIT *mins);

void ADB_SetProfileSearchTimer(U32BIT cicam_id, U32BIT timer_handle);

U32BIT ADB_GetProfileSearchTimer(void *profile);

void ADB_DeleteCicamTimerbyHandle(U32BIT timer_handle);

BOOLEAN ADB_GetServiceSDTReceived(void *s_ptr);

U8BIT* ADB_GetServiceCIProtectionDesc(void *s_ptr);

BOOLEAN ADB_HasCIProtectionExpired(void *s_ptr);
#endif

U8BIT* ADB_GetServicePMTData(void *s_ptr, U16BIT *data_len);

U16BIT ADB_GetServicePmtPid(void *s_ptr);

U16BIT ADB_GetServiceAitPid(void *s_ptr);

U8BIT* ADB_GetServiceFullURL(void *s_ptr, U16BIT *port);

E_STB_DP_FEC_LAYER ADB_GetServiceFecLayer(void *s_ptr, S_STB_DP_FEC_LAYER_INFO *fec_info);

BOOLEAN ADB_ImportDB(U8BIT *filename);

BOOLEAN ADB_ExportDB(U8BIT *filename);

BOOLEAN ADB_ExportEPG(U8BIT *filename, U16BIT utc_date_filter, U32BIT type, BOOLEAN use_dvb_uri);

U16BIT ADB_GetNumFavouriteLists(void);

BOOLEAN ADB_AddFavouriteList(U8BIT *name, U32BIT user_data, S16BIT index, U8BIT *list_id);

U8BIT ADB_GetFavouriteListIdByIndex(U16BIT index);

U8BIT ADB_GetFavouriteListByUserData(U32BIT user_data);

U8BIT* ADB_GetFavouriteListName(U8BIT list_id);

BOOLEAN ADB_SetFavouriteListName(U8BIT list_id, U8BIT *name);

U32BIT ADB_GetFavouriteListUserData(U8BIT list_id);

void ADB_SetFavouriteListUserData(U8BIT list_id, U32BIT user_data);

BOOLEAN ADB_MoveFavouriteListTo(U8BIT list_id, S16BIT index);

void ADB_DeleteFavouriteList(U8BIT list_id);

BOOLEAN ADB_AddServiceToFavouriteList(U8BIT list_id, void *serv_ptr, S16BIT index);

BOOLEAN ADB_MoveFavouriteListServiceTo(U8BIT list_id, void *serv_ptr, S16BIT index);

BOOLEAN ADB_MoveFavouriteListServiceFromTo(U8BIT list_id, S16BIT current_index, S16BIT new_index);

void ADB_DeleteServiceFromFavouriteList(U8BIT list_id, void *serv_ptr);

void ADB_DeleteAllServicesFromFavouriteList(U8BIT list_id);

#ifdef DEBUG_PRINT_DATABASE

void ADB_PrintDatabase(void);
#endif


//---Global Function prototypes for internal use---------------------------------
void ADB_Initialise(void);

#if 0

void ADB_ReloadDBRam(void);
#endif

void ADB_PrepareDatabaseForSearch(E_STB_DP_SIGNAL_TYPE tuner_type, void *satellite,
   BOOLEAN retune, BOOLEAN manual_search);

void ADB_FinaliseDatabaseAfterSearch(BOOLEAN save_changes, E_STB_DP_SIGNAL_TYPE tuner_type, void *satellite,
   BOOLEAN search_completed, BOOLEAN clear_new_flags, BOOLEAN manual_search);

BOOLEAN ADB_AreLcnsDuplicated(E_STB_DP_SIGNAL_TYPE tuner_type);

void ADB_AllocateLcns(E_STB_DP_SIGNAL_TYPE tuner_type);

void ADB_ReleaseDatabaseSearchData(void);

void ADB_ReportNoSignalDuringSearch(void *t_ptr);

BOOLEAN ADB_GetTransportSearchFlag(void *t_ptr);

void ADB_SetTransportSearchFlag(void *t_ptr, BOOLEAN state);

#if 0
void ADB_SetServiceListTaggedLockedFlag(U32BIT *tag_array, void **slist, U16BIT num_entries, BOOLEAN locked);
#endif

E_STB_DP_AUDIO_CODEC ADB_GetAudioCodecFromStream(ADB_STREAM_TYPE audio_stream_type);

E_STB_DP_VIDEO_CODEC ADB_GetVideoCodecFromStream(ADB_STREAM_TYPE video_stream_type);

void* ADB_GetEventService(void *event_ptr);

ADB_EVENT_ITEMIZED_INFO* ADB_GetEventItemizedDescription(void *event_ptr, U16BIT *num_items_ptr);

void ADB_ReleaseEventItemizedInfo(ADB_EVENT_ITEMIZED_INFO *event_itemized_info, U16BIT num_of_items);

#endif //  _AP_DBACC_H