Mercurial Mercurial > oss > FCL > sf > mw > mmmw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
khronosfws/openmax_al/src/radio/xaradioitf.c
changeset 48 a493a607b5bf
parent 43 9894ed580e4a
child 53 eabc8c503852
equal deleted inserted replaced
44:8d0d228c94a2 48:a493a607b5bf 
     9 * Initial Contributors:
 
     9 * Initial Contributors:
 
    10 * Nokia Corporation - initial contribution.
 
    10 * Nokia Corporation - initial contribution.
 
    11 *
 
    11 *
 
    12 * Contributors:
 
    12 * Contributors:
 
    13 *
 
    13 *
 
    14 * Description:
 
    14 * Description: 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 #include <stdio.h>
 
    18 #include <stdio.h>
 
    19 #include <stdlib.h>
 
    19 #include <stdlib.h>
 
    20 #include <assert.h>
 
       
    21 #include <string.h>
 
    20 #include <string.h>
 
    22 #include "xaradioitf.h"
 
    21 #include "xaradioitf.h"
 
    23 #include "xaradioitfadaptation.h"
 
    22 #include "xaradioitfadaptation.h"
 
    24 #include "xathreadsafety.h"
 
    23 #include "xathreadsafety.h"
 
    25 
    24 
   195     XAresult ret = XA_RESULT_SUCCESS;
 
   194     XAresult ret = XA_RESULT_SUCCESS;
 
   196     XAuint8 range = 1; // Default to EuroAmerica
 
   195     XAuint8 range = 1; // Default to EuroAmerica
 
   197     XAuint32 minFreq;
 
   196     XAuint32 minFreq;
 
   198     XAuint32 maxFreq;
 
   197     XAuint32 maxFreq;
 
   199    	XAuint32 freqInterval;
 
   198    	XAuint32 freqInterval;
 
   200 
   199         
   201     XARadioItfImpl* impl = GetImpl(self);
 
   200     XARadioItfImpl* impl = GetImpl(self);
 
   202     DEBUG_API("->XARadioItfImpl_SetFrequency");
 
   201     DEBUG_API("->XARadioItfImpl_SetFrequency");
 
   203     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   202     XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
 
   204 
   203 
   205     if(!impl)
 
   204     if(!impl)
 
   207         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   206         XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   208         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   207         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
 
   209         DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   208         DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   210         return XA_RESULT_PARAMETER_INVALID;
 
   209         return XA_RESULT_PARAMETER_INVALID;
 
   211     }
 
   210     }
 
   212 
   211     
   213     // Check for valid entries:
 
   212     // Check for valid entries: 
   214  		ret = XARadioItfImpl_GetFreqRangeProperties(self, range, &minFreq, &maxFreq, &freqInterval);
 
   213  		ret = XARadioItfImpl_GetFreqRangeProperties(self, range, &minFreq, &maxFreq, &freqInterval);   
   215     if (ret != XA_RESULT_SUCCESS)
 
   214     if (ret != XA_RESULT_SUCCESS)
 
   216     {
 
   215     {
 
   217     	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   216     	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   218     	DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   217     	DEBUG_API("<-XARadioItfImpl_SetFrequency");    	
   219     	return ret;
 
   218     	return ret;
 
   220     }
 
   219     }		
   221 
   220     
   222     if ( (freq < minFreq) || (freq > maxFreq) )
 
   221     if ( (freq < minFreq) || (freq > maxFreq) )
 
   223     {
 
   222     {
 
   224     	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   223     	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   225     	DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   224     	DEBUG_API("<-XARadioItfImpl_SetFrequency");    	
   226     	return XA_RESULT_PARAMETER_INVALID;
 
   225     	return XA_RESULT_PARAMETER_INVALID;
 
   227     }
 
   226     }	  
   228 
   227            
   229    	ret = XARadioItfAdapt_SetFrequency( (XAAdaptationMMFCtx*)impl->adapCtx, freq );
 
   228    	ret = XARadioItfAdapt_SetFrequency( (XAAdaptationMMFCtx*)impl->adapCtx, freq );
 
   230 
   229 
   231     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   230     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   232     DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   231     DEBUG_API("<-XARadioItfImpl_SetFrequency");
 
   233     return ret;
 
   232     return ret;
 
   310         return XA_RESULT_PARAMETER_INVALID;
 
   309         return XA_RESULT_PARAMETER_INVALID;
 
   311     }
 
   310     }
 
   312 
   311 
   313     if (impl->squelch != squelch)
 
   312     if (impl->squelch != squelch)
 
   314     {
 
   313     {
 
   315         ret = XARadioItfAdapt_SetSquelch( squelch );
 
   314         ret = XARadioItfAdapt_SetSquelch( (XAAdaptationMMFCtx*)impl->adapCtx, squelch );
 
   316         if ( ret == XA_RESULT_SUCCESS )
 
   315         if ( ret == XA_RESULT_SUCCESS )
 
   317         {
 
   316         {
 
   318             impl->squelch = squelch;
 
   317             impl->squelch = squelch;
 
   319         }
 
   318         }
 
   320     }
 
   319     }
 
   371         ret = XARadioItfAdapt_SetStereoMode( (XAAdaptationMMFCtx*)impl->adapCtx, mode );
 
   370         ret = XARadioItfAdapt_SetStereoMode( (XAAdaptationMMFCtx*)impl->adapCtx, mode );
 
   372        	if ( ret == XA_RESULT_SUCCESS )
 
   371        	if ( ret == XA_RESULT_SUCCESS )
 
   373         {
 
   372         {
 
   374          	  impl->stereoMode = mode;
 
   373          	  impl->stereoMode = mode;
 
   375         }
 
   374         }
 
   376     }
 
   375     }    
   377     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   376     XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
 
   378     DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   377     DEBUG_API("<-XARadioItfImpl_SetStereoMode");
 
   379     return ret;
 
   378     return ret;
 
   380 }
 
   379 }
 
   381 
   380 
   492 
   491 
   493 /**
 
   492 /**
 
   494  * XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
 
   493  * XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
 
   495  * Description: Returns the number of preset slots the device has for storing the presets.
 
   494  * Description: Returns the number of preset slots the device has for storing the presets.
 
   496  **/
 
   495  **/
 
   497 XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
 
   496 XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32* pNumPresets)
 
   498 {
 
   497 {
 
   499     XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
 
   498     XAresult ret = XA_RESULT_SUCCESS;
 
   500 
   499     XAuint32 presetValue = 0;
 
       
   500     pNumPresets = &presetValue;
 
   501     DEBUG_API("->XARadioItfImpl_GetNumberOfPresets");
 
   501     DEBUG_API("->XARadioItfImpl_GetNumberOfPresets");
 
   502 
   502 
   503     return ret;
 
   503     return ret;
 
   504 }
 
   504 }
 
   505 
   505 
   517                                   XAuint32 freq,
 
   517                                   XAuint32 freq,
 
   518                                   XAuint8 range,
 
   518                                   XAuint8 range,
 
   519                                   XAuint32 mode,
 
   519                                   XAuint32 mode,
 
   520                                   const XAchar * name)
 
   520                                   const XAchar * name)
 
   521 {
 
   521 {
 
   522     XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
 
   522   //  XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED; Currently, this is not a valid error code for OpenMaxAL. Is proposed to be added.
 
       
   523   
       
   524     XAresult ret = XA_RESULT_PARAMETER_INVALID; // For now, use this error code.
 
   523 
   525 
   524     return ret;
 
   526     return ret;
 
   525 }
 
   527 }
 
   526 
   528 
   527 /**
 
   529 /**
 
   540                                   XAuint8 * pRange,
 
   542                                   XAuint8 * pRange,
 
   541                                   XAuint32 * pMode,
 
   543                                   XAuint32 * pMode,
 
   542                                   XAchar * pName,
 
   544                                   XAchar * pName,
 
   543                                   XAuint16 * pNameLength)
 
   545                                   XAuint16 * pNameLength)
 
   544 {
 
   546 {
 
   545 
   547  
   546     XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
 
   548     XAresult ret = XA_RESULT_SUCCESS;
 
   547 
   549     if (preset != 0)
 
       
   550         ret = XA_RESULT_PARAMETER_INVALID;
 
       
   551         
   548     DEBUG_API("<-XARadioItfImpl_GetPreset");
 
   552     DEBUG_API("<-XARadioItfImpl_GetPreset");
 
   549     return ret;
 
   553     return ret;
 
   550 }
 
   554 }
 
   551 
   555 
   552 /**
 
   556 /**
 
   610         self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;
 
   614         self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;
 
   611         self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;
 
   615         self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;
 
   612         self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;
 
   616         self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;
 
   613         self->itf.Seek = XARadioItfImpl_Seek;
 
   617         self->itf.Seek = XARadioItfImpl_Seek;
 
   614         self->itf.StopSeeking = XARadioItfImpl_StopSeeking;
 
   618         self->itf.StopSeeking = XARadioItfImpl_StopSeeking;
 
       
   619         self->itf.GetNumberOfPresets = XARadioItfImpl_GetNumberOfPresets;
 
       
   620         self->itf.SetPreset = XARadioItfImpl_SetPreset;
 
       
   621         self->itf.GetPreset = XARadioItfImpl_GetPreset;
 
   615         self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;
 
   622         self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;
 
   616 
   623 
   617         /* init variables */
 
   624         /* init variables */
 
   618 
   625 
   619         self->squelch = XA_BOOLEAN_FALSE;
 
   626         self->squelch = XA_BOOLEAN_FALSE;
 
   641     DEBUG_API("->XARadioItfImpl_Free");
 
   648     DEBUG_API("->XARadioItfImpl_Free");
 
   642     XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
 
   649     XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
 
   643     XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );
 
   650     XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );
 
   644 
   651 
   645     XARadioItfAdapt_Free();
 
   652     XARadioItfAdapt_Free();
 
   646     assert(self==self->self);
 
       
   647     free(self);
 
   653     free(self);
 
   648 
   654 
   649     XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
 
   655     XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
 
   650     DEBUG_API("<-XARadioItfImpl_Free");
 
   656     DEBUG_API("<-XARadioItfImpl_Free");
 
   651 }
 
   657 }
 
   656 void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
 
   662 void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
 
   657 {
 
   663 {
 
   658     XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;
 
   664     XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;
 
   659     XAuint32 eventData = 0;
 
   665     XAuint32 eventData = 0;
 
   660     XAboolean eventBoolean = XA_BOOLEAN_FALSE;
 
   666     XAboolean eventBoolean = XA_BOOLEAN_FALSE;
 
   661 
   667     
   662     DEBUG_API("->XARadioItfimpl_AdaptCb");
 
   668     DEBUG_API("->XARadioItfimpl_AdaptCb");
 
   663 
   669 
   664     if(!impl)
 
   670     if(!impl)
 
   665     {
 
   671     {
 
   666         DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
 
   672         DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
 
   667         DEBUG_API("<-XARadioItfImpl_AdaptCb");
 
   673         DEBUG_API("<-XARadioItfImpl_AdaptCb");
 
   668         return;
 
   674         return;
 
   669     }
 
   675     }
 
   670     assert(event);
 
   676     
   671 
   677     if (event)
 
   672     if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )
 
   678     {
 
   673     {
 
   679         if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )
 
   674         DEBUG_API("Frequency changed in adaptation");
 
   680         {
 
   675         eventData = *(XAuint32*)event->data;
 
   681             DEBUG_API("Frequency changed in adaptation"); 
   676         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, eventData, eventBoolean );
 
   682             eventData = *(XAuint32*)event->data;
 
   677     }
 
   683             impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, eventData, eventBoolean );
 
   678 
   684         }
 
   679     else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )
 
   685         else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )
 
   680     {
 
   686         {
 
   681         DEBUG_API("Frequency range changed in adaptation");
 
   687             DEBUG_API("Frequency range changed in adaptation");
 
   682 
   688             impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, eventData, eventBoolean  );
 
   683         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, eventData, eventBoolean  );
 
   689         }
 
   684     }
 
   690         else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )
 
   685 
   691         {
 
   686     else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )
 
   692             DEBUG_API("Seek complete in adaptation");
 
   687     {
 
   693        	    eventBoolean = *(XAboolean*)event->data;        
   688         DEBUG_API("Seek complete in adaptation");
 
   694             impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, eventData, eventBoolean  );     
   689        	eventBoolean = *(XAboolean*)event->data;
 
   695         }
 
   690         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, eventData, eventBoolean  );
 
   696         else if( event->eventid == XA_ADAPT_RADIO_STEREO_STATUS_CHANGED && impl->callback )
 
   691     }
 
   697         {
 
   692 
   698             DEBUG_API("Stereo status change in adaptation");
 
   693     else if( event->eventid == XA_ADAPT_RADIO_STEREO_STATUS_CHANGED && impl->callback )
 
   699             eventBoolean = *(XAboolean*)event->data;          
   694     {
 
   700             impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_STEREO_STATUS_CHANGED, eventData, eventBoolean  );
 
   695         DEBUG_API("Stereo status change in adaptation");
 
   701         } 
   696       	eventBoolean = *(XAboolean*)event->data;
 
   702         else if( event->eventid == XA_ADAPT_RADIO_SIGNAL_STRENGTH_CHANGED && impl->callback )
 
   697         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_STEREO_STATUS_CHANGED, eventData, eventBoolean  );
 
   703         {
 
   698     }
 
   704             DEBUG_API("Signal Strength Change in adaptation");
 
   699 
   705             impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SIGNAL_STRENGTH_CHANGED, eventData, eventBoolean  );
 
   700     else if( event->eventid == XA_ADAPT_RADIO_SIGNAL_STRENGTH_CHANGED && impl->callback )
 
   706         }
 
   701     {
 
   707     }      
   702         DEBUG_API("Signal Strength Change in adaptation");
 
       
   703         impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SIGNAL_STRENGTH_CHANGED, eventData, eventBoolean  );
 
       
   704     }
 
       
   705     else
 
   708     else
 
   706     {
 
   709     {
 
   707         /* do nothing */
 
   710         /* do nothing */
 
   708     }
 
   711     }
 
   709     DEBUG_API("<-XARadioItfimpl_AdaptCb");
 
   712     DEBUG_API("<-XARadioItfimpl_AdaptCb");
FCL/sf/mw/mmmw