--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/gst_adaptation/xardsitfadaptation.c Fri May 14 16:22:35 2010 +0300
@@ -0,0 +1,877 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+
+#include "xaadaptationgst.h"
+#include "xaradioadaptctx.h"
+#include "xardsitfadaptation.h"
+#include "xaradioitfadaptation.h"
+
+/* emulated device data and constraints */
+
+#define NUM_OF_CHANNELS 2
+#define MAX_PS_STRING_LENGHT 17
+#define MAX_RT_STRING_LENGHT 129
+#define MAX_ODA_GROUP_SUBSCRIPTIONS 100
+#define MAX_PTY_STRING_SHORT_LENGHT 17
+#define MAX_PTY_STRING_LONG_LENGHT 33
+#define NONE_STRING_LENGHT 4
+
+/* emulated rds data structure */
+typedef struct
+{
+ XAuint32 frequency;
+ XAchar *progServiceName;
+ XAchar *radioText;
+ XAuint32 programmeType;
+ XAchar *ptyStringShort;
+ XAchar *ptyStringLong;
+ XAint16 programmeID;
+ XAboolean trafficAnnouncement;
+ XAboolean trafficProgramme;
+} RDSData;
+
+#define TRAFFIC_PROGRAMME_CHANNEL 0
+#define TRAFFIC_ANNOUNCEMENT_CHANNEL 0
+#define POPMUSIC_CHANNEL 1
+
+/* emulated rds data from channels */
+static const RDSData rdsData[NUM_OF_CHANNELS] = {
+ {88500000, (XAchar *)"Traffic", (XAchar *)"All your traffic needs", XA_RDSPROGRAMMETYPE_RDSPTY_NONE,
+ (XAchar *)"None", (XAchar *)"None", 0x0001, XA_BOOLEAN_TRUE, XA_BOOLEAN_TRUE },
+ {89300000, (XAchar *)"Popular", (XAchar *)"For the populous", XA_RDSPROGRAMMETYPE_RDSPTY_POPMUSIC,
+ (XAchar *)"Pop music", (XAchar *)"Pop music for the masses", 0x0002, XA_BOOLEAN_FALSE, XA_BOOLEAN_FALSE }
+};
+
+static const XAchar* noneString = (XAchar *)"None";
+
+static XAint16 subscribedODAGroups[MAX_ODA_GROUP_SUBSCRIPTIONS];
+static XAuint16 subscribedODAGroupCount = 0;
+
+static XAuint32 freqSetAfterSeek;
+
+const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx );
+void * XARDSItfAdapt_AsyncSeek(void* args);
+void * XARDSItfAdapt_AsyncGetODAGroup(void* args);
+
+/* exposing radio itf adaptation internal function here */
+XAresult XARadioItfAdapt_SyncSetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq);
+
+
+/*
+ * XAresult XARDSItfAdapt_QueryRDSSignal(XAAdaptationGstCtx *bCtx, XAboolean * isSignal)
+ */
+XAresult XARDSItfAdapt_QueryRDSSignal(XAAdaptationGstCtx *bCtx, XAboolean * isSignal)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_QueryRDSSignal");
+
+ if(!bCtx || !isSignal)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_QueryRDSSignal");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ if (GetCurrentRdsData(bCtx))
+ {
+ *isSignal = XA_BOOLEAN_TRUE;
+ }
+ else
+ {
+ *isSignal = XA_BOOLEAN_FALSE;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_QueryRDSSignal");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetProgrammeServiceName(XAAdaptationGstCtx *bCtx, XAchar * ps)
+ */
+XAresult XARDSItfAdapt_GetProgrammeServiceName(XAAdaptationGstCtx *bCtx, XAchar * ps)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetProgrammeServiceName");
+
+
+ if(!bCtx || !ps)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeServiceName");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ strncpy( (char *)ps, (char *)data->progServiceName, MAX_PS_STRING_LENGHT );
+ }
+ else
+ {
+ *ps = 0;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeServiceName");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetRadioText(XAAdaptationGstCtx *bCtx, XAchar * rt)
+ */
+XAresult XARDSItfAdapt_GetRadioText(XAAdaptationGstCtx *bCtx, XAchar * rt)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetRadioText");
+
+ if(!bCtx || !rt)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetRadioText");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ strncpy( (char *)rt, (char *)data->radioText, MAX_RT_STRING_LENGHT );
+ }
+ else
+ {
+ *rt = 0;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetRadioText");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetRadioTextPlus(XAAdaptationGstCtx *bCtx,
+ * XAuint8 contentType,
+ * XAchar * informationElement,
+ * XAchar * descriptor,
+ * XAuint8 * descriptorContentType)
+ */
+XAresult XARDSItfAdapt_GetRadioTextPlus(XAAdaptationGstCtx *bCtx,
+ XAuint8 contentType,
+ XAchar * informationElement,
+ XAchar * descriptor,
+ XAuint8 * descriptorContentType)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_GetRadioTextPlus");
+
+ if(!bCtx || contentType < XA_RDSRTPLUS_ITEMTITLE || contentType > XA_RDSRTPLUS_GETDATA
+ || !informationElement || !descriptor || !descriptorContentType)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetRadioTextPlus");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ *informationElement = 0;
+ *descriptorContentType = 0;
+
+ DEBUG_API("<-XARDSItfAdapt_GetRadioTextPlus");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetProgrammeType(XAAdaptationGstCtx *bCtx, XAuint32 * pty)
+ */
+XAresult XARDSItfAdapt_GetProgrammeType(XAAdaptationGstCtx *bCtx, XAuint32 * pty)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetProgrammeType");
+
+ if(!bCtx || !pty)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeType");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ *pty = data->programmeType;
+ }
+ else
+ {
+ *pty = 0;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeType");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetProgrammeTypeString(XAAdaptationGstCtx *bCtx,
+ * XAboolean isLengthMax16,
+ * XAchar * pty)
+ *
+ */
+XAresult XARDSItfAdapt_GetProgrammeTypeString(XAAdaptationGstCtx *bCtx,
+ XAboolean isLengthMax16,
+ XAchar * pty)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetProgrammeTypeString");
+
+ if(!bCtx || !pty)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeTypeString");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ if (isLengthMax16)
+ {
+ DEBUG_API_A1("Programme type string %s", data->ptyStringLong);
+ strncpy( (char *)pty, (char *)data->ptyStringLong, MAX_PTY_STRING_LONG_LENGHT );
+ }
+ else
+ {
+ DEBUG_API_A1("Programme type string %s", data->ptyStringShort);
+ strncpy( (char *)pty, (char *)data->ptyStringShort, MAX_PTY_STRING_SHORT_LENGHT );
+ }
+ }
+ else
+ {
+ DEBUG_API_A1("Programme type string %s", noneString);
+ strncpy( (char *)pty, (char *)noneString, NONE_STRING_LENGHT );
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeTypeString");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetProgrammeIdentificationCode(XAAdaptationGstCtx *bCtx, XAint16 * pi)
+ */
+XAresult XARDSItfAdapt_GetProgrammeIdentificationCode(XAAdaptationGstCtx *bCtx, XAint16 * pi)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetProgrammeIdentificationCode");
+
+ if(!bCtx || !pi)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeIdentificationCode");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ *pi = data->programmeID;
+ }
+ else
+ {
+ *pi = 0;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetProgrammeIdentificationCode");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetClockTime(XAAdaptationGstCtx *bCtx, XAtime * dateAndTime)
+ */
+XAresult XARDSItfAdapt_GetClockTime(XAAdaptationGstCtx *bCtx, XAtime * dateAndTime)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ time_t timeRet=0;
+ DEBUG_API("->XARDSItfAdapt_GetClockTime");
+
+ if(!bCtx || !dateAndTime)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetClockTime");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ timeRet = time(NULL);
+
+ if (timeRet == -1) /* could not get time for some reason */
+ {
+ ret = XA_RESULT_INTERNAL_ERROR;
+ }
+ else
+ {
+ *dateAndTime = timeRet;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetClockTime");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * ta)
+ */
+XAresult XARDSItfAdapt_GetTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * ta)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetTrafficAnnouncement");
+
+ if(!bCtx || !ta)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetTrafficAnnouncement");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ *ta = data->trafficAnnouncement;
+ }
+ else
+ {
+ *ta = XA_BOOLEAN_FALSE;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetTrafficAnnouncement");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean * tp)
+ */
+XAresult XARDSItfAdapt_GetTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean * tp)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ const RDSData* data;
+ DEBUG_API("->XARDSItfAdapt_GetTrafficProgramme");
+
+ if(!bCtx || !tp)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetTrafficProgramme");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ data = GetCurrentRdsData( bCtx );
+
+ if (data)
+ {
+ *tp = data->trafficProgramme;
+ }
+ else
+ {
+ *tp = XA_BOOLEAN_FALSE;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetTrafficProgramme");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SeekByProgrammeType(XAAdaptationGstCtx *bCtx,
+ * XAuint32 pty,
+ * XAboolean upwards)
+ */
+XAresult XARDSItfAdapt_SeekByProgrammeType(XAAdaptationGstCtx *bCtx,
+ XAuint32 pty,
+ XAboolean upwards)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ int pt_ret=0;
+ XARadioAdaptationCtx* mCtx = NULL;
+ DEBUG_API("->XARDSItfAdapt_SeekByProgrammeType");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ if (mCtx->state != XA_RADIO_IDLE)
+ {
+ // pthread_cancel(mCtx->emulationThread);
+ mCtx->state = XA_RADIO_IDLE;
+ }
+
+ if (pty == XA_RDSPROGRAMMETYPE_RDSPTY_POPMUSIC)
+ {
+ freqSetAfterSeek = rdsData[POPMUSIC_CHANNEL].frequency;
+ }
+ else
+ {
+ freqSetAfterSeek = mCtx->frequency;
+ }
+
+ mCtx->state = XA_RADIO_SEEKING;
+ pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);
+
+ if(pt_ret)
+ {
+ DEBUG_ERR_A1("could not create thread!! (%d)",ret);
+ DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SeekTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean upwards)
+ */
+XAresult XARDSItfAdapt_SeekTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean upwards)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ int pt_ret=0;
+ XARadioAdaptationCtx* mCtx = NULL;
+ DEBUG_API("->XARDSItfAdapt_SeekTrafficAnnouncement");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ if (mCtx->state != XA_RADIO_IDLE)
+ {
+ // pthread_cancel(mCtx->emulationThread);
+ mCtx->state = XA_RADIO_IDLE;
+ }
+
+ freqSetAfterSeek = rdsData[TRAFFIC_ANNOUNCEMENT_CHANNEL].frequency;
+
+ mCtx->state = XA_RADIO_SEEKING;
+ pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);
+
+ if(pt_ret)
+ {
+ DEBUG_ERR_A1("could not create thread!! (%d)",ret);
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SeekTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean upwards)
+ */
+XAresult XARDSItfAdapt_SeekTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean upwards)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ int pt_ret=0;
+ XARadioAdaptationCtx* mCtx = NULL;
+ DEBUG_API("->XARDSItfAdapt_SeekTrafficProgramme");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ if (mCtx->state != XA_RADIO_IDLE)
+ {
+ // pthread_cancel(mCtx->emulationThread);
+ mCtx->state = XA_RADIO_IDLE;
+ }
+
+ freqSetAfterSeek = rdsData[TRAFFIC_PROGRAMME_CHANNEL].frequency;
+
+ mCtx->state = XA_RADIO_SEEKING;
+ pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);
+
+ if(pt_ret)
+ {
+ DEBUG_ERR_A1("could not create thread!! (%d)",ret);
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");
+ return ret;
+}
+
+/*
+ * void * XARadioItfAdapt_AsyncSeek(void* args)
+ */
+void * XARDSItfAdapt_AsyncSeek(void* args)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XAAdaptationGstCtx *bCtx = (XAAdaptationGstCtx*)args;
+
+ XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ DEBUG_API("->XARDSItfAdapt_AsyncSeek");
+
+ usleep(100000); /* 1/10 seconds */
+
+ DEBUG_INFO("Seek done!");
+
+ ret = XARadioItfAdapt_SyncSetFrequency( bCtx, freqSetAfterSeek );
+ if (ret != XA_RESULT_SUCCESS)
+ {
+ DEBUG_ERR("XARadioItfAdapt_SyncSetFrequency FAILED");
+ }
+
+ /* Send event to RadioItf */
+ {
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_SEEK_COMPLETE, 0, NULL };
+ XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );
+ }
+ mCtx->state = XA_RADIO_IDLE;
+
+ DEBUG_API("<-XARDSItfAdapt_AsyncSeek");
+ pthread_exit(NULL);
+ return NULL;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean automatic)
+ */
+XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean automatic)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_SetAutomaticSwitching");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XA_RESULT_FEATURE_UNSUPPORTED;
+
+ DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean * automatic)
+ */
+XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean * automatic)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_GetAutomaticSwitching");
+
+ if(!bCtx || !automatic)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ /* Feature not supported */
+ *automatic = XA_BOOLEAN_FALSE;
+
+ DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean automatic)
+ */
+XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean automatic)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_SetAutomaticTrafficAnnouncement");
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XA_RESULT_FEATURE_UNSUPPORTED;
+
+ DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * automatic)
+ */
+XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * automatic)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARDSItfAdapt_GetAutomaticTrafficAnnouncement");
+
+ if(!bCtx || !automatic)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ *automatic = XA_BOOLEAN_FALSE;
+
+ DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationGstCtx *bCtx,
+ * XAint16 AID)
+ */
+XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationGstCtx *bCtx, XAint16 AID)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ int pt_ret=0;
+ XARadioAdaptationCtx* mCtx=NULL;
+ DEBUG_API("->XARDSItfAdapt_GetODAGroup");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_GetODAGroup");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ if (mCtx->rdsState != XA_RADIO_RDS_IDLE)
+ {
+ // pthread_cancel(mCtx->rdsEmulationThread);
+ mCtx->rdsState = XA_RADIO_RDS_IDLE;
+ DEBUG_INFO("Previous getodagroup async call cancelled")
+ }
+
+ pt_ret = pthread_create(&(mCtx->rdsEmulationThread), NULL, (XARDSItfAdapt_AsyncGetODAGroup),(void*)bCtx);
+
+ if(pt_ret)
+ {
+ DEBUG_ERR_A1("could not create thread!! (%d)",ret);
+ DEBUG_API("<-XARDSItfAdapt_GetODAGroup");
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_GetODAGroup");
+ return ret;
+}
+
+/*
+ * void * XARDSItfAdapt_AsyncGetODAGroup(void* args)
+ */
+void * XARDSItfAdapt_AsyncGetODAGroup(void* args)
+{
+ XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*)args;
+
+ DEBUG_API("->XARDSItfAdapt_AsyncGetODAGroup");
+ mCtx->rdsState = XA_RADIO_RDS_GETTING_ODA_GROUP;
+
+ DEBUG_INFO("Get oda group async wait")
+ usleep(100000); /* 1/10 seconds */
+
+ /* Send event */
+ {
+ XAAdaptEvent event = {XA_RDSITFEVENTS, XA_ADAPT_RDS_GET_ODA_GROUP_DONE, 0, NULL };
+ XAAdaptationBase_SendAdaptEvents(args, &event );
+ }
+ mCtx->rdsState = XA_RADIO_RDS_IDLE;
+ DEBUG_API("<-XARDSItfAdapt_AsyncGetODAGroup");
+ pthread_exit(NULL);
+ return NULL;
+}
+
+/*
+ * XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationGstCtx *bCtx,
+ * XAint16 group,
+ * XAboolean useErrorCorrection)
+ */
+XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationGstCtx *bCtx,
+ XAint16 group,
+ XAboolean useErrorCorrection)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XAuint8 index=0;
+ XAboolean groupFound = XA_BOOLEAN_FALSE;
+ DEBUG_API("->XARDSItfAdapt_SubscribeODAGroup");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ /* Look for group in list, if not there add it */
+ if (subscribedODAGroupCount < MAX_ODA_GROUP_SUBSCRIPTIONS)
+ {
+ for (index = 0; index < subscribedODAGroupCount; index++)
+ {
+ if (subscribedODAGroups[index] == group)
+ {
+ groupFound = XA_BOOLEAN_TRUE;
+ }
+ }
+ if (!groupFound)
+ {
+ subscribedODAGroups[subscribedODAGroupCount] = group;
+ subscribedODAGroupCount++;
+ }
+ }
+ else
+ {
+ DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");
+ DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationGstCtx *bCtx, XAint16 group)
+ */
+XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationGstCtx *bCtx, XAint16 group)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XAuint8 index=0;
+ DEBUG_API("->XARDSItfAdapt_UnsubscribeODAGroup");
+
+ if(!bCtx)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ /* Look for group in list, if found, remove it */
+ for (index = 0; index < subscribedODAGroupCount; index++)
+ {
+ if (subscribedODAGroups[index] == group)
+ {
+ subscribedODAGroups[index] = subscribedODAGroups[subscribedODAGroupCount-1];
+ subscribedODAGroupCount--;
+ }
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");
+ return ret;
+}
+
+/*
+ * XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationGstCtx *bCtx,
+ * XAint16* pGroups,
+ * XAuint32* pLength)
+ */
+XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationGstCtx *bCtx,
+ XAint16* pGroups,
+ XAuint32* pLength)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XAuint8 index=0;
+ DEBUG_API("->XARDSItfAdapt_ListODAGroupSubscriptions");
+
+ if(!bCtx || !pLength)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ if (!pGroups)
+ {
+ *pLength = subscribedODAGroupCount;
+ }
+ else
+ {
+ if (*pLength < subscribedODAGroupCount)
+ {
+ ret = XA_RESULT_BUFFER_INSUFFICIENT;
+ }
+ for (index = 0; index < *pLength; index++)
+ {
+ pGroups[index] = subscribedODAGroups[index];
+ }
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");
+ return ret;
+}
+
+/*
+ * const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx )
+ */
+const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx )
+{
+ XAuint8 index=0;
+ XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;
+
+ for (index = 0; index < NUM_OF_CHANNELS; index++ )
+ {
+ if (rdsData[index].frequency == mCtx->frequency)
+ {
+ DEBUG_API("<-GetCurrentRdsData");
+ return &(rdsData[index]);
+ }
+ }
+ DEBUG_API("<-GetCurrentRdsData");
+ return NULL;
+}
+
+
+/*
+ * void XARDSItfAdapt_Free(XAAdaptationGstCtx *bCtx)
+ */
+void XARDSItfAdapt_Free(XAAdaptationBaseCtx *bCtx)
+{
+ XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;
+ DEBUG_API("->XARDSItfAdapt_Free");
+
+ if (mCtx->state != XA_RADIO_IDLE)
+ {
+ // pthread_cancel(mCtx->emulationThread);
+ mCtx->state = XA_RADIO_IDLE;
+ }
+
+ if (mCtx->rdsState != XA_RADIO_RDS_IDLE)
+ {
+ // pthread_cancel(mCtx->rdsEmulationThread);
+ mCtx->rdsState = XA_RADIO_RDS_IDLE;
+ }
+
+ DEBUG_API("<-XARDSItfAdapt_Free");
+}