mmmw_plat/openmax_al_api/tsrc/openmaxaltestmodule/src/engine/openmaxalaudioiodevicecapabilitiesitftests.cpp
changeset 14 80975da52420
equal deleted inserted replaced
12:5a06f39ad45b 14:80975da52420
       
     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: This file contains testclass implementation.
       
    15 *
       
    16 */
       
    17 
       
    18 // [INCLUDE FILES] - do not remove
       
    19 #include <e32svr.h>
       
    20 #include <StifParser.h>
       
    21 #include <StifTestInterface.h>
       
    22 #include "openmaxaltestmodule.h"
       
    23 
       
    24 // EXTERNAL DATA STRUCTURES
       
    25 //extern  ?external_data;
       
    26 
       
    27 // EXTERNAL FUNCTION PROTOTYPES  
       
    28 //extern ?external_function( ?arg_type,?arg_type );
       
    29 
       
    30 // CONSTANTS
       
    31 //const ?type ?constant_var = ?constant;
       
    32 
       
    33 // MACROS
       
    34 //#define ?macro ?macro_def
       
    35 
       
    36 // LOCAL CONSTANTS AND MACROS
       
    37 //const ?type ?constant_var = ?constant;
       
    38 //#define ?macro_name ?macro_def
       
    39 
       
    40 // MODULE DATA STRUCTURES
       
    41 //enum ?declaration
       
    42 //typedef ?declaration
       
    43 
       
    44 // LOCAL FUNCTION PROTOTYPES
       
    45 //?type ?function_name( ?arg_type, ?arg_type );
       
    46 
       
    47 // FORWARD DECLARATIONS
       
    48 //class ?FORWARD_CLASSNAME;
       
    49 void AvailAudioInputsChangedCallback(
       
    50         XAAudioIODeviceCapabilitiesItf caller,
       
    51         void * pContext,
       
    52         XAuint32 deviceID,
       
    53         XAint32 numInputs,
       
    54         XAboolean isNew
       
    55     );
       
    56 
       
    57 void AvailAudioOutputsChangedCallback(
       
    58         XAAudioIODeviceCapabilitiesItf caller,
       
    59         void * pContext,
       
    60         XAuint32 deviceID,
       
    61         XAint32 numInputs,
       
    62         XAboolean isNew
       
    63     );
       
    64 
       
    65 void DefaultDeviceIDMapChangedCallback (
       
    66     XAAudioIODeviceCapabilitiesItf caller,
       
    67     void * pContext,
       
    68     XAboolean isOutput,
       
    69     XAint32 numDevices);
       
    70     
       
    71 // ============================= LOCAL FUNCTIONS ===============================
       
    72 
       
    73 // -----------------------------------------------------------------------------
       
    74 // ?function_name ?description.
       
    75 // ?description
       
    76 // Returns: ?value_1: ?description
       
    77 //          ?value_n: ?description_line1
       
    78 //                    ?description_line2
       
    79 // -----------------------------------------------------------------------------
       
    80 //
       
    81 /*
       
    82 ?type ?function_name(
       
    83     ?arg_type arg,  // ?description
       
    84     ?arg_type arg)  // ?description
       
    85     {
       
    86 
       
    87     ?code  // ?comment
       
    88 
       
    89     // ?comment
       
    90     ?code
       
    91     }
       
    92 */
       
    93 
       
    94 TInt COpenMAXALTestModule::al_audioiodevcapitf_GetAvailableAudioInputs( CStifItemParser& aItem )
       
    95     {
       
    96     TInt status(KErrNone);
       
    97     XAresult res;
       
    98     
       
    99     TInt deviceId(0);
       
   100     XAint32 devId;
       
   101     XAuint32* deviceIdArr(NULL);
       
   102     
       
   103     status = aItem.GetNextInt(deviceId);
       
   104     if(!status)
       
   105         {
       
   106         devId = deviceId;
       
   107         if(m_AIODevCapItf)
       
   108             {
       
   109             res = (*m_AIODevCapItf)->GetAvailableAudioInputs(
       
   110                     m_AIODevCapItf, &devId, deviceIdArr);
       
   111             status = res;
       
   112             }
       
   113         else
       
   114             {
       
   115             status = KErrNotFound;
       
   116             }        
       
   117         }
       
   118     else
       
   119         {
       
   120         if(m_AIODevCapItf)
       
   121             {
       
   122             res = (*m_AIODevCapItf)->GetAvailableAudioInputs(
       
   123                     m_AIODevCapItf, &devId, NULL);
       
   124             status = res;
       
   125             }
       
   126         else
       
   127             {
       
   128             status = KErrNotFound;
       
   129             }        
       
   130         }
       
   131     return status;
       
   132     }
       
   133 
       
   134 TInt COpenMAXALTestModule::al_audioiodevcapitf_QueryAudioInputCapabilities( CStifItemParser& aItem )
       
   135     {
       
   136     TInt status(KErrNone);
       
   137     XAAudioInputDescriptor inputDesc;
       
   138     XAresult res;
       
   139     TUint deviceId(0);
       
   140     XAuint32 devId(0);
       
   141     
       
   142     status = aItem.GetNextInt(deviceId);
       
   143     if(!status)
       
   144         {
       
   145         devId = deviceId;
       
   146         if(m_AIODevCapItf)
       
   147             {
       
   148             res = (*m_AIODevCapItf)->QueryAudioInputCapabilities(
       
   149                     m_AIODevCapItf, devId, &inputDesc);
       
   150             status = res;
       
   151             }
       
   152         else
       
   153             {
       
   154             status = KErrNotFound;
       
   155             } 
       
   156         }
       
   157     return status;
       
   158     }
       
   159 
       
   160 TInt COpenMAXALTestModule::al_audioiodevcapitf_RegisterAvailableAudioInputsChangedCallback( CStifItemParser& /*aItem*/ )
       
   161     {
       
   162     TInt status(KErrNone);
       
   163     XAresult res;
       
   164     
       
   165     if(m_AIODevCapItf)
       
   166         {
       
   167         res = (*m_AIODevCapItf)->RegisterAvailableAudioInputsChangedCallback(
       
   168                 m_AIODevCapItf, AvailAudioInputsChangedCallback, (void*)this);
       
   169         status = res;
       
   170         }
       
   171     else
       
   172         {
       
   173         status = KErrNotFound;
       
   174         }            
       
   175     return status;
       
   176     }
       
   177 
       
   178 TInt COpenMAXALTestModule::al_audioiodevcapitf_GetAvailableAudioOutputs( CStifItemParser& aItem )
       
   179     {
       
   180     TInt status(KErrNone);
       
   181     XAresult res;
       
   182     
       
   183     TInt deviceId(0);
       
   184     XAint32 devId;
       
   185     XAuint32* deviceIdArr(NULL);
       
   186     
       
   187     status = aItem.GetNextInt(deviceId);
       
   188     if(!status)
       
   189         {
       
   190         devId = deviceId;
       
   191         if(m_AIODevCapItf)
       
   192             {
       
   193             res = (*m_AIODevCapItf)->GetAvailableAudioOutputs(
       
   194                     m_AIODevCapItf, &devId, deviceIdArr);
       
   195             status = res;
       
   196             }
       
   197         else
       
   198             {
       
   199             status = KErrNotFound;
       
   200             }        
       
   201         }
       
   202     else
       
   203         {
       
   204         if(m_AIODevCapItf)
       
   205             {
       
   206             res = (*m_AIODevCapItf)->GetAvailableAudioOutputs(
       
   207                     m_AIODevCapItf, &devId, NULL);
       
   208             status = res;
       
   209             }
       
   210         else
       
   211             {
       
   212             status = KErrNotFound;
       
   213             }        
       
   214         }
       
   215     return status;
       
   216     }
       
   217 
       
   218 TInt COpenMAXALTestModule::al_audioiodevcapitf_QueryAudioOutputCapabilities( CStifItemParser& aItem )
       
   219     {
       
   220     TInt status(KErrNone);
       
   221     XAAudioOutputDescriptor outputDesc;
       
   222     XAresult res;
       
   223     TUint deviceId(0);
       
   224     XAuint32 devId(0);
       
   225     
       
   226     status = aItem.GetNextInt(deviceId);
       
   227     if(!status)
       
   228         {
       
   229         devId = deviceId;
       
   230         if(m_AIODevCapItf)
       
   231             {
       
   232             res = (*m_AIODevCapItf)->QueryAudioOutputCapabilities(
       
   233                     m_AIODevCapItf, devId, &outputDesc);
       
   234             status = res;
       
   235             }
       
   236         else
       
   237             {
       
   238             status = KErrNotFound;
       
   239             } 
       
   240         }
       
   241     return status;
       
   242     }
       
   243 
       
   244 TInt COpenMAXALTestModule::al_audioiodevcapitf_RegisterAvailableAudioOutputsChangedCallback( CStifItemParser& /*aItem*/ )
       
   245     {
       
   246     TInt status(KErrNone);
       
   247     XAresult res;
       
   248     
       
   249     if(m_AIODevCapItf)
       
   250         {
       
   251         res = (*m_AIODevCapItf)->RegisterAvailableAudioOutputsChangedCallback(
       
   252                 m_AIODevCapItf, AvailAudioOutputsChangedCallback, (void*)this);
       
   253         status = res;
       
   254         }
       
   255     else
       
   256         {
       
   257         status = KErrNotFound;
       
   258         }            
       
   259     return status;
       
   260     }
       
   261 
       
   262 TInt COpenMAXALTestModule::al_audioiodevcapitf_RegisterDefaultDeviceIDMapChangedCallback( CStifItemParser& /*aItem*/ )
       
   263     {
       
   264     TInt status(KErrNone);
       
   265     XAresult res;
       
   266     
       
   267     if(m_AIODevCapItf)
       
   268         {
       
   269         res = (*m_AIODevCapItf)->RegisterDefaultDeviceIDMapChangedCallback(
       
   270                 m_AIODevCapItf, DefaultDeviceIDMapChangedCallback, (void*)this);
       
   271         status = res;
       
   272         }
       
   273     else
       
   274         {
       
   275         status = KErrNotFound;
       
   276         }            
       
   277     return status;
       
   278     }
       
   279 
       
   280 TInt COpenMAXALTestModule::al_audioiodevcapitf_GetAssociatedAudioInputs( CStifItemParser& aItem )
       
   281     {
       
   282     TInt status(KErrNone);
       
   283     XAresult res;
       
   284     
       
   285     TUint deviceId(0);
       
   286     TInt sizeArr(0);
       
   287     XAuint32 devId(0);
       
   288     XAint32 numInputs(0);
       
   289     XAuint32 deviceIdArr[2];
       
   290     
       
   291     status = aItem.GetNextInt(deviceId);
       
   292     if(!status)
       
   293         {
       
   294         devId = deviceId;
       
   295         status = aItem.GetNextInt(sizeArr);
       
   296         if(!status)
       
   297             {
       
   298             numInputs = sizeArr;
       
   299             if(m_AIODevCapItf)
       
   300                 {
       
   301                 res = (*m_AIODevCapItf)->GetAssociatedAudioInputs(
       
   302                         m_AIODevCapItf, devId, &numInputs, deviceIdArr);
       
   303                 status = res;
       
   304                 }
       
   305             else
       
   306                 {
       
   307                 status = KErrNotFound;
       
   308                 }        
       
   309             }
       
   310         else
       
   311             {
       
   312             if(m_AIODevCapItf)
       
   313                 {
       
   314                 res = (*m_AIODevCapItf)->GetAssociatedAudioInputs(
       
   315                         m_AIODevCapItf, devId,&numInputs, NULL);
       
   316                 status = res;
       
   317                 }
       
   318             else
       
   319                 {
       
   320                 status = KErrNotFound;
       
   321                 }                
       
   322             }
       
   323         }
       
   324     else
       
   325         {
       
   326         status = KErrGeneral;
       
   327         }
       
   328     return status;
       
   329     }
       
   330 
       
   331 TInt COpenMAXALTestModule::al_audioiodevcapitf_GetAssociatedAudioOutputs( CStifItemParser& aItem )
       
   332     {
       
   333     TInt status(KErrNone);
       
   334     XAresult res;
       
   335     
       
   336     TUint deviceId(0);
       
   337     TInt sizeArr(0);
       
   338     XAuint32 devId(0);
       
   339     XAint32 numOutputs(0);
       
   340     XAuint32 deviceIdArr[2];
       
   341     
       
   342     status = aItem.GetNextInt(deviceId);
       
   343     if(!status)
       
   344         {
       
   345         devId = deviceId;
       
   346         status = aItem.GetNextInt(sizeArr);
       
   347         if(!status)
       
   348             {
       
   349             numOutputs = sizeArr;
       
   350             if(m_AIODevCapItf)
       
   351                 {
       
   352                 res = (*m_AIODevCapItf)->GetAssociatedAudioOutputs(
       
   353                         m_AIODevCapItf, devId, &numOutputs, deviceIdArr);
       
   354                 status = res;
       
   355                 }
       
   356             else
       
   357                 {
       
   358                 status = KErrNotFound;
       
   359                 }        
       
   360             }
       
   361         else
       
   362             {
       
   363             if(m_AIODevCapItf)
       
   364                 {
       
   365                 res = (*m_AIODevCapItf)->GetAssociatedAudioOutputs(
       
   366                         m_AIODevCapItf, devId,&numOutputs, NULL);
       
   367                 status = res;
       
   368                 }
       
   369             else
       
   370                 {
       
   371                 status = KErrNotFound;
       
   372                 }                
       
   373             }
       
   374         }
       
   375     else
       
   376         {
       
   377         status = KErrGeneral;
       
   378         }
       
   379     return status;
       
   380     }
       
   381 
       
   382 TInt COpenMAXALTestModule::al_audioiodevcapitf_GetDefaultAudioDevices( CStifItemParser& aItem )
       
   383     {
       
   384     TInt status(KErrNone);
       
   385     XAresult res;
       
   386     
       
   387     TUint deviceId(0);
       
   388     TInt sizeArr(0);
       
   389     XAuint32 devId(0);
       
   390     XAint32 numOutputs(0);
       
   391     XAuint32 deviceIdArr[2];
       
   392     
       
   393     status = aItem.GetNextInt(deviceId, EHex);
       
   394     if(!status)
       
   395         {
       
   396         devId = deviceId;
       
   397         status = aItem.GetNextInt(sizeArr);
       
   398         if(!status)
       
   399             {
       
   400             numOutputs = sizeArr;
       
   401             if(m_AIODevCapItf)
       
   402                 {
       
   403                 res = (*m_AIODevCapItf)->GetDefaultAudioDevices(
       
   404                         m_AIODevCapItf, devId, &numOutputs, deviceIdArr);
       
   405                 status = res;
       
   406                 }
       
   407             else
       
   408                 {
       
   409                 status = KErrNotFound;
       
   410                 }        
       
   411             }
       
   412         else
       
   413             {
       
   414             if(m_AIODevCapItf)
       
   415                 {
       
   416                 res = (*m_AIODevCapItf)->GetDefaultAudioDevices(
       
   417                         m_AIODevCapItf, devId,&numOutputs, NULL);
       
   418                 status = res;
       
   419                 }
       
   420             else
       
   421                 {
       
   422                 status = KErrNotFound;
       
   423                 }                
       
   424             }
       
   425         }
       
   426     else
       
   427         {
       
   428         status = KErrGeneral;
       
   429         }
       
   430     return status;
       
   431     }
       
   432 
       
   433 TInt COpenMAXALTestModule::al_audioiodevcapitf_QuerySampleFormatsSupported( CStifItemParser& aItem )
       
   434     {
       
   435     TInt status(KErrNone);
       
   436     XAresult res;
       
   437     TInt sizeArr(0);
       
   438     TUint deviceId(0);
       
   439     TInt samplerate(0);
       
   440     XAuint32 devId(0);
       
   441     XAmilliHertz samplingrate;
       
   442     XAint32 deviceIdArr[20];
       
   443     XAint32 numSampleRates(0);
       
   444     
       
   445     status = aItem.GetNextInt(deviceId);
       
   446     if(!status)
       
   447         {
       
   448         devId = deviceId;
       
   449         status = aItem.GetNextInt(samplerate);
       
   450         if(!status)
       
   451             {
       
   452             samplingrate = samplerate;
       
   453             status = aItem.GetNextInt(sizeArr);
       
   454             if(!status)
       
   455                 {
       
   456                 numSampleRates = sizeArr;
       
   457                 if(m_AIODevCapItf)
       
   458                     {
       
   459                     res = (*m_AIODevCapItf)->QuerySampleFormatsSupported(
       
   460                             m_AIODevCapItf, devId, samplingrate, deviceIdArr, &numSampleRates);
       
   461                     status = res;
       
   462                     }
       
   463                 else
       
   464                     {
       
   465                     status = KErrNotFound;
       
   466                     }        
       
   467                 }
       
   468             else
       
   469                 {
       
   470                 if(m_AIODevCapItf)
       
   471                     {
       
   472                     res = (*m_AIODevCapItf)->QuerySampleFormatsSupported(
       
   473                             m_AIODevCapItf, devId, samplingrate, NULL, &numSampleRates);
       
   474                     status = res;
       
   475                     }
       
   476                 else
       
   477                     {
       
   478                     status = KErrNotFound;
       
   479                     }        
       
   480                 }
       
   481             }
       
   482         else
       
   483             {
       
   484             status = KErrGeneral;
       
   485             }
       
   486         }
       
   487     else
       
   488         {
       
   489         status = KErrGeneral;
       
   490         }
       
   491     return status;
       
   492     }
       
   493