1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <stdio.h>

    19 #include <stdlib.h>

    20 #include <assert.h>

    21 #include "xaengineitf.h"

    22 #include "xavibraitf.h"

    23 #include "xaledarrayitf.h"

    24 #ifdef _GSTREAMER_BACKEND_  

    25 #include "XAStaticCapsAdaptation.h"

    26 #endif

    27 

    28 /*static XAchar implementationText[] = "Implementation does not conform to AL Spec";*/

    29 

    30 

    31 /**

    32  * Base interface XAEngineItf implementation

    33  */

    34 XAresult XAEngineItfImpl_CreateCameraDevice(XAEngineItf self,

    35                                             XAObjectItf *pDevice,

    36                                             XAuint32 deviceID,

    37                                             XAuint32 numInterfaces,

    38                                             const XAInterfaceID *pInterfaceIds,

    39                                             const XAboolean *pInterfaceRequired)

    40 {

    41     return XACameraDeviceImpl_CreateCameraDevice( pDevice, deviceID,numInterfaces,

    42                                                   pInterfaceIds, pInterfaceRequired );

    43 }

    44 

    45 XAresult XAEngineItfImpl_CreateRadioDevice(XAEngineItf self,

    46                                             XAObjectItf *pDevice,

    47                                             XAuint32 numInterfaces,

    48                                             const XAInterfaceID *pInterfaceIds,

    49                                             const XAboolean *pInterfaceRequired)

    50 {

    51     return XARadioDeviceImpl_CreateRadioDevice( pDevice, numInterfaces,

    52                                                 pInterfaceIds, pInterfaceRequired );

    53 }

    54 

    55 XAresult XAEngineItfImpl_CreateLEDDevice(XAEngineItf self,

    56                                          XAObjectItf *pDevice,

    57                                          XAuint32 deviceID,

    58                                          XAuint32 numInterfaces,

    59                                          const XAInterfaceID *pInterfaceIds,

    60                                          const XAboolean *pInterfaceRequired)

    61 {

    62     return XALEDArrayDeviceImpl_CreateLEDArrayDevice( pDevice, deviceID, numInterfaces,

    63                                                       pInterfaceIds, pInterfaceRequired );

    64 }

    65 

    66 XAresult XAEngineItfImpl_CreateVibraDevice(XAEngineItf self,

    67                                            XAObjectItf *pDevice,

    68                                            XAuint32 deviceID,

    69                                            XAuint32 numInterfaces,

    70                                            const XAInterfaceID *pInterfaceIds,

    71                                            const XAboolean *pInterfaceRequired)

    72 {

    73     return XAVibraDeviceImpl_CreateVibraDevice( pDevice, deviceID, numInterfaces,

    74                                                 pInterfaceIds, pInterfaceRequired);

    75 }

    76 

    77 XAresult XAEngineItfImpl_CreateMediaPlayer(XAEngineItf self,

    78                                            XAObjectItf *pPlayer,

    79                                            XADataSource *pDataSrc,

    80                                            XADataSource *pBankSrc,

    81                                            XADataSink *pAudioSnk,

    82                                            XADataSink *pImageVideoSnk,

    83                                            XADataSink *pVibra,

    84                                            XADataSink *pLEDArray,

    85                                            XAuint32 numInterfaces,

    86                                            const XAInterfaceID *pInterfaceIds,

    87                                            const XAboolean *pInterfaceRequired)

    88 {

    89     return XAMediaPlayerImpl_CreateMediaPlayer(pPlayer, pDataSrc, pBankSrc, pAudioSnk,

    90                                              pImageVideoSnk, pVibra, pLEDArray,

    91                                              numInterfaces, pInterfaceIds, pInterfaceRequired);

    92 }

    93 

    94 XAresult XAEngineItfImpl_CreateMediaRecorder(XAEngineItf self,

    95                                              XAObjectItf * pRecorder,

    96                                              XADataSource * pAudioSrc,

    97                                              XADataSource * pImageVideoSrc,

    98                                              XADataSink * pDataSnk,

    99                                              XAuint32 numInterfaces,

   100                                              const XAInterfaceID * pInterfaceIds,

   101                                              const XAboolean * pInterfaceRequired)

   102 {

   103     return XAMediaRecorderImpl_CreateMediaRecorder(pRecorder, pAudioSrc, pImageVideoSrc, pDataSnk,

   104                                                    numInterfaces, pInterfaceIds, pInterfaceRequired);

   105 }

   106 

   107 XAresult XAEngineItfImpl_CreateOutputMix(XAEngineItf self,

   108                                          XAObjectItf *pMix,

   109                                          XAuint32 numInterfaces,

   110                                          const XAInterfaceID *pInterfaceIds,

   111                                          const XAboolean *pInterfaceRequired)

   112 {

   113     return XAOMixImpl_CreateOutputMix(pMix, numInterfaces,

   114                                       pInterfaceIds, pInterfaceRequired);

   115 }

   116 

   117 XAresult XAEngineItfImpl_CreateMetadataExtractor(XAEngineItf self,

   118                                                  XAObjectItf *pMetadataExtractor,

   119                                                  XADataSource *pDataSource,

   120                                                  XAuint32 numInterfaces,

   121                                                  const XAInterfaceID *pInterfaceIds,

   122                                                  const XAboolean *pInterfaceRequired)

   123 {

   124     return XAMetadataExtractorImpl_Create(pMetadataExtractor, pDataSource,

   125                                           numInterfaces, pInterfaceIds, pInterfaceRequired);

   126 }

   127 

   128 XAresult XAEngineItfImpl_CreateExtensionObject(XAEngineItf self,

   129                                                XAObjectItf *pObject,

   130                                                void *pParameters,

   131                                                XAuint32 objectID,

   132                                                XAuint32 numInterfaces,

   133                                                const XAInterfaceID *pInterfaceIds,

   134                                                const XAboolean *pInterfaceRequired)

   135 {

   136     DEBUG_API("->XAEngineItfImpl_CreateExtensionObject");

   137     /* no supported extensions */

   138     DEBUG_API("<-XAEngineItfImpl_CreateExtensionObject - XA_RESULT_FEATURE_UNSUPPORTED");

   139     return XA_RESULT_FEATURE_UNSUPPORTED;

   140 }

   141 

   142 XAresult XAEngineItfImpl_GetImplementationInfo(XAEngineItf self,

   143                                                XAuint32 *pMajor,

   144                                                XAuint32 *pMinor,

   145                                                XAuint32 *pStep,

   146                                                const XAchar *pImplementationText)

   147 {

   148     DEBUG_API("->XAEngineItfImpl_GetImplementationInfo");

   149 

   150     if( !pMajor || !pMinor || !pStep )

   151     {

   152         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   153         DEBUG_API("<-XAEngineItfImpl_GetImplementationInfo");

   154         return XA_RESULT_PARAMETER_INVALID;

   155     }

   156     /* OpenMAX AL API ver 1.0.1 */

   157     *pMajor = 1;

   158     *pMinor = 0;

   159     *pStep = 1;

   160     /*pImplementationText = (XAchar *) implementationText;*/

   161 

   162     DEBUG_API("<-XAEngineItfImpl_GetImplementationInfo");

   163     return XA_RESULT_SUCCESS;

   164 }

   165 

   166 XAresult XAEngineItfImpl_QuerySupportedProfiles(XAEngineItf self,

   167                                                 XAint16 *pProfilesSupported)

   168 {

   169     DEBUG_API("->XAEngineItfImpl_QuerySupportedProfiles");

   170 

   171     if( !pProfilesSupported )

   172     {

   173         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   174         DEBUG_API("<-XAEngineItfImpl_QuerySupportedProfiles");

   175         return XA_RESULT_PARAMETER_INVALID;

   176     }

   177     /* NOTE: enable +MIDI when/if XMF issues solved

   178      *        XA_PROFILES_MEDIA_PLAYER |

   179      *        XA_PROFILES_MEDIA_PLAYER_RECORDER |

   180      *        XA_PROFILES_PLUS_MIDI;

   181      */

   182     *pProfilesSupported = XA_PROFILES_MEDIA_PLAYER | XA_PROFILES_MEDIA_PLAYER_RECORDER;

   183 

   184     DEBUG_API("<-XAEngineItfImpl_QuerySupportedProfiles");

   185     return XA_RESULT_SUCCESS;

   186 }

   187 

   188 XAresult XAEngineItfImpl_QueryNumSupportedInterfaces(XAEngineItf self,

   189                                                      XAuint32 objectID,

   190                                                      XAuint32 *pNumSupportedInterfaces)

   191 {

   192     XAresult res = XA_RESULT_SUCCESS;

   193     DEBUG_API("->XAEngineItfImpl_QueryNumSupportedInterfaces");

   194 

   195     if( !pNumSupportedInterfaces )

   196     {

   197         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   198         DEBUG_API("<-XAEngineItfImpl_QueryNumSupportedInterfaces");

   199         return XA_RESULT_PARAMETER_INVALID;

   200     }

   201     *pNumSupportedInterfaces=0;

   202     switch(objectID)

   203     {

   204         case XA_OBJECTID_ENGINE:

   205             res = XAEngineImpl_QueryNumSupportedInterfaces(

   206                                             pNumSupportedInterfaces);

   207             break;

   208         case XA_OBJECTID_MEDIAPLAYER:

   209             res = XAMediaPlayerImpl_QueryNumSupportedInterfaces(

   210                                             pNumSupportedInterfaces);

   211             break;

   212         case XA_OBJECTID_MEDIARECORDER:

   213             res = XAMediaRecorderImpl_QueryNumSupportedInterfaces(

   214                                             pNumSupportedInterfaces);

   215             break;

   216         case XA_OBJECTID_OUTPUTMIX:

   217             res = XAOMixImpl_QueryNumSupportedInterfaces(

   218                                             pNumSupportedInterfaces);

   219             break;

   220         case XA_OBJECTID_CAMERADEVICE:

   221             res = XACameraDeviceImpl_QueryNumSupportedInterfaces(

   222                                             pNumSupportedInterfaces);

   223             break;

   224         case XA_OBJECTID_RADIODEVICE:

   225             res = XARadioDeviceImpl_QueryNumSupportedInterfaces(

   226                                             pNumSupportedInterfaces);

   227             break;

   228         case XA_OBJECTID_LEDDEVICE:

   229             res = XALEDArrayDeviceImpl_QueryNumSupportedInterfaces(

   230                                             pNumSupportedInterfaces);

   231             break;

   232         case XA_OBJECTID_VIBRADEVICE:

   233             res = XAVibraDeviceImpl_QueryNumSupportedInterfaces(

   234                                             pNumSupportedInterfaces);

   235             break;

   236         case XA_OBJECTID_METADATAEXTRACTOR:

   237             res = XAMetadataExtractorImpl_QueryNumSupportedInterfaces(

   238                                             pNumSupportedInterfaces);

   239             break;

   240         default:

   241             res = XA_RESULT_FEATURE_UNSUPPORTED;

   242             break;

   243     }

   244 

   245     DEBUG_API_A1("<-XAEngineItfImpl_QueryNumSupportedInterfaces %lu",res);

   246     return res;

   247 }

   248 

   249 XAresult XAEngineItfImpl_QuerySupportedInterfaces(XAEngineItf self,

   250                                                   XAuint32 objectID,

   251                                                   XAuint32 index,

   252                                                   XAInterfaceID *pInterfaceId)

   253 {

   254     XAresult res = XA_RESULT_SUCCESS;

   255     DEBUG_API("->XAEngineItfImpl_QuerySupportedInterfaces");

   256 

   257     if( !pInterfaceId )

   258     {

   259         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   260         DEBUG_API("<-XAEngineItfImpl_QuerySupportedInterfaces");

   261         return XA_RESULT_PARAMETER_INVALID;

   262     }

   263     *pInterfaceId = XA_IID_NULL;

   264     switch (objectID)

   265     {

   266         case XA_OBJECTID_ENGINE:

   267             res = XAEngineImpl_QuerySupportedInterfaces(

   268                                                 index, pInterfaceId);

   269             break;

   270         case XA_OBJECTID_MEDIAPLAYER:

   271             res = XAMediaPlayerImpl_QuerySupportedInterfaces(

   272                                                 index, pInterfaceId);

   273             break;

   274         case XA_OBJECTID_MEDIARECORDER:

   275             res = XAMediaRecorderImpl_QuerySupportedInterfaces(

   276                                                 index, pInterfaceId);

   277             break;

   278         case XA_OBJECTID_OUTPUTMIX:

   279             res = XAOMixImpl_QuerySupportedInterfaces(

   280                                                 index, pInterfaceId);

   281             break;

   282         case XA_OBJECTID_CAMERADEVICE:

   283             res = XACameraDeviceImpl_QuerySupportedInterfaces(

   284                                                 index, pInterfaceId );

   285             break;

   286         case XA_OBJECTID_RADIODEVICE:

   287             res = XARadioDeviceImpl_QuerySupportedInterfaces(

   288                                                 index, pInterfaceId );

   289             break;

   290         case XA_OBJECTID_LEDDEVICE:

   291             res = XALEDArrayDeviceImpl_QuerySupportedInterfaces(

   292                                                 index, pInterfaceId );

   293             break;

   294         case XA_OBJECTID_VIBRADEVICE:

   295             res = XAVibraDeviceImpl_QuerySupportedInterfaces(

   296                                                 index, pInterfaceId );

   297             break;

   298         case XA_OBJECTID_METADATAEXTRACTOR:

   299             res = XAMetadataExtractorImpl_QuerySupportedInterfaces(

   300                                                 index, pInterfaceId);

   301             break;

   302         default:

   303             res = XA_RESULT_FEATURE_UNSUPPORTED;

   304     }

   305 

   306     DEBUG_API_A1("<-XAEngineItfImpl_QuerySupportedInterfaces %lu", res);

   307     return res;

   308 }

   309 

   310 XAresult XAEngineItfImpl_QueryLEDCapabilities(XAEngineItf self,

   311                                               XAuint32 *pIndex,

   312                                               XAuint32 *pLEDDeviceID,

   313                                               XALEDDescriptor *pDescriptor)

   314 {

   315 #ifdef _GSTREAMER_BACKEND_  

   316     XALEDDescriptor descriptor;

   317 #endif    

   318     DEBUG_API("->XAEngineItfImpl_QueryLEDCapabilities");

   319 

   320     if( !pDescriptor )

   321     {   /*query number of devices*/

   322         if( !pIndex )

   323         {

   324             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   325             DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities");

   326             return XA_RESULT_PARAMETER_INVALID;

   327         }

   328         /* Number of devices */

   329         *pIndex = 1;

   330     }

   331     else

   332     {   

   333 #ifdef _GSTREAMER_BACKEND_  

   334         /* query device capabilities */

   335         if( pIndex )

   336         {

   337             if( *pIndex == 0 )

   338             {

   339                 if( !pLEDDeviceID )

   340                 {

   341                     DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   342                     DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities");

   343                     return XA_RESULT_PARAMETER_INVALID;

   344                 }

   345                 *pLEDDeviceID = XA_ADAPTID_LEDARRAY;

   346             }

   347             else

   348             {

   349                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   350                 DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities");

   351                 return XA_RESULT_PARAMETER_INVALID;

   352             }

   353         }

   354 

   355         if( *pLEDDeviceID == XA_ADAPTID_LEDARRAY )

   356         {

   357             descriptor.colorMask = COLOR_MASK;

   358             descriptor.ledCount = LED_COUNT;

   359             descriptor.primaryLED = PRIMARY_LED;

   360             *pDescriptor = descriptor;

   361         }

   362 #endif        

   363     }

   364     DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities");

   365     return XA_RESULT_SUCCESS;

   366 }

   367 

   368 XAresult XAEngineItfImpl_QueryVibraCapabilities(XAEngineItf self,

   369                                                 XAuint32 *pIndex,

   370                                                 XAuint32 *pVibraDeviceID,

   371                                                 XAVibraDescriptor *pDescriptor)

   372 {

   373 #ifdef _GSTREAMER_BACKEND_  

   374     XAVibraDescriptor descriptor;

   375 #endif

   376     DEBUG_API("->XAEngineItfImpl_QueryVibraCapabilities");

   377 

   378     if( !pDescriptor  )

   379     {   /*query number of devices*/

   380         if( !pIndex )

   381         {

   382             DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   383             DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities");

   384             return XA_RESULT_PARAMETER_INVALID;

   385         }

   386         /* Number of devices */

   387         *pIndex = 1;

   388     }

   389     else

   390     {   

   391 #ifdef _GSTREAMER_BACKEND_  

   392         /* query device capabilities */

   393         if( pIndex )

   394         {

   395             if( *pIndex == 0 )

   396             {

   397                 if( !pVibraDeviceID )

   398                 {

   399                     DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   400                     DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities");

   401                     return XA_RESULT_PARAMETER_INVALID;

   402                 }

   403 

   404                 *pVibraDeviceID = XA_ADAPTID_VIBRA;

   405             }

   406             else

   407             {

   408                 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   409                 DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities");

   410                 return XA_RESULT_PARAMETER_INVALID;

   411             }

   412         }

   413 

   414         if( *pVibraDeviceID == XA_ADAPTID_VIBRA )

   415         {

   416             descriptor.minFrequency = MIN_FREQUENCY;

   417             descriptor.maxFrequency = MAX_FREQUENCY;

   418             descriptor.supportsFrequency = XA_BOOLEAN_TRUE;

   419             descriptor.supportsIntensity = XA_BOOLEAN_TRUE;

   420             *pDescriptor = descriptor;

   421         }

   422 #endif        

   423     }

   424 

   425     DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities");

   426     return XA_RESULT_SUCCESS;

   427 }

   428 

   429 XAresult XAEngineItfImpl_QueryNumSupportedExtensions(XAEngineItf self,

   430                                                      XAuint32 *pNumExtensions)

   431 {

   432     DEBUG_API("->XAEngineItfImpl_QuerySupportedExtension");

   433     if(pNumExtensions==NULL)

   434     {

   435        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   436        DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension");

   437        return XA_RESULT_PARAMETER_INVALID;

   438     }

   439     /* no supported extensions */

   440     *pNumExtensions=0;

   441     DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension");

   442     return XA_RESULT_SUCCESS;

   443 }

   444 

   445 XAresult XAEngineItfImpl_QuerySupportedExtension(XAEngineItf self,

   446                                                XAuint32 index,

   447                                                XAchar *pExtensionName,

   448                                                XAint16 *pNameLength)

   449 {

   450     DEBUG_API("->XAEngineItfImpl_QuerySupportedExtension");

   451     /* no supported extensions => index is always wrong */

   452     DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   453     DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension");

   454     return XA_RESULT_PARAMETER_INVALID;

   455 }

   456 

   457 XAresult XAEngineItfImpl_IsExtensionSupported(XAEngineItf self,

   458                                             const XAchar *pExtensionName,

   459                                             XAboolean *pSupported)

   460 {

   461     DEBUG_API("->XAEngineItfImpl_IsExtensionSupported");

   462     if(pSupported==NULL)

   463     {

   464         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   465         DEBUG_API("<-XAEngineItfImpl_IsExtensionSupported");

   466         return XA_RESULT_PARAMETER_INVALID;

   467     }

   468     /* no supported extensions */

   469     *pSupported=XA_BOOLEAN_FALSE;

   470     DEBUG_API("<-XAEngineItfImpl_IsExtensionSupported");

   471     return XA_RESULT_SUCCESS;

   472 }

   473 

   474 /**

   475  * XAEngineItfImpl -specific methods

   476  **/

   477 XAEngineItfImpl* XAEngineItfImpl_Create()

   478 {

   479     XAEngineItfImpl* self = (XAEngineItfImpl*)

   480         calloc(1,sizeof(XAEngineItfImpl));

   481     DEBUG_API("->XAEngineItfImpl_Create");

   482 

   483     if( self )

   484     {

   485         /* init itf default implementation */

   486         self->itf.CreateCameraDevice = XAEngineItfImpl_CreateCameraDevice;

   487         self->itf.CreateRadioDevice = XAEngineItfImpl_CreateRadioDevice;

   488         self->itf.CreateLEDDevice = XAEngineItfImpl_CreateLEDDevice;

   489         self->itf.CreateVibraDevice = XAEngineItfImpl_CreateVibraDevice;

   490         self->itf.CreateMediaPlayer = XAEngineItfImpl_CreateMediaPlayer;

   491         self->itf.CreateMediaRecorder = XAEngineItfImpl_CreateMediaRecorder;

   492         self->itf.CreateOutputMix = XAEngineItfImpl_CreateOutputMix;

   493         self->itf.CreateMetadataExtractor = XAEngineItfImpl_CreateMetadataExtractor;

   494         self->itf.CreateExtensionObject = XAEngineItfImpl_CreateExtensionObject;

   495         self->itf.GetImplementationInfo = XAEngineItfImpl_GetImplementationInfo;

   496         self->itf.QuerySupportedProfiles = XAEngineItfImpl_QuerySupportedProfiles;

   497         self->itf.QueryNumSupportedInterfaces = XAEngineItfImpl_QueryNumSupportedInterfaces;

   498         self->itf.QuerySupportedInterfaces = XAEngineItfImpl_QuerySupportedInterfaces;

   499         self->itf.QueryLEDCapabilities = XAEngineItfImpl_QueryLEDCapabilities;

   500         self->itf.QueryVibraCapabilities = XAEngineItfImpl_QueryVibraCapabilities;

   501         self->itf.QueryNumSupportedExtensions = XAEngineItfImpl_QueryNumSupportedExtensions;

   502         self->itf.QuerySupportedExtension = XAEngineItfImpl_QuerySupportedExtension;

   503         self->itf.IsExtensionSupported = XAEngineItfImpl_IsExtensionSupported;

   504         self->self = self;

   505     }

   506     DEBUG_API("<-XAEngineItfImpl_Create");

   507     return self;

   508 }

   509 

   510 void XAEngineItfImpl_Free(XAEngineItfImpl* self)

   511 {

   512     DEBUG_API("->XAEngineItfImpl_Free");

   513     assert(self==self->self);

   514     free(self);

   515     DEBUG_API("<-XAEngineItfImpl_Free");

   516 }