khronosfws/openmax_al/src/common/xaobjects.h
changeset 25 6f7ceef7b1d1
parent 19 4a629bc82c5e
equal deleted inserted replaced
21:2ed61feeead6 25:6f7ceef7b1d1
     1 /*
     1 /*
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
     3 * All rights reserved.
     3  * All rights reserved.
     4 * This component and the accompanying materials are made available
     4  * This component and the accompanying materials are made available
     5 * under the terms of "Eclipse Public License v1.0"
     5  * under the terms of "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     6  * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     8 *
     8  *
     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: Entry Point Functions to Create AL Objects
    15 *
    15  *
    16 */
    16  */
    17 /*All global definitions and declarations here */
    17 /*All global definitions and declarations here */
    18 
    18 
    19 #ifndef XAOBJECTS_H
    19 #ifndef XAOBJECTS_H
    20 #define XAOBJECTS_H
    20 #define XAOBJECTS_H
    21 
    21 
    26 
    26 
    27 /**
    27 /**
    28  * GLOBAL METHODS
    28  * GLOBAL METHODS
    29  */
    29  */
    30 
    30 
    31 
       
    32 /*
    31 /*
    33  * Engine
    32  * Engine
    34  */
    33  */
    35 XAresult XAEngineImpl_Create(XAObjectItf *pEngine,
    34 XAresult XAEngineImpl_Create(XAObjectItf *pEngine, XAuint32 numOptions,
    36                              XAuint32 numOptions,
    35         const XAEngineOption *pEngineOptions, XAuint32 numInterfaces,
    37                              const XAEngineOption *pEngineOptions,
    36         const XAInterfaceID *pInterfaceIds,
    38                              XAuint32 numInterfaces,
    37         const XAboolean *pInterfaceRequired);
    39                              const XAInterfaceID *pInterfaceIds,
       
    40                              const XAboolean *pInterfaceRequired);
       
    41 
    38 
    42 XAresult XAEngineImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
    39 XAresult XAEngineImpl_QueryNumSupportedInterfaces(
       
    40         XAuint32 *pNumSupportedInterfaces);
    43 
    41 
    44 XAresult XAEngineImpl_QuerySupportedInterfaces(XAuint32 index,
    42 XAresult XAEngineImpl_QuerySupportedInterfaces(XAuint32 index,
    45                                                XAInterfaceID *pInterfaceId);
    43         XAInterfaceID *pInterfaceId);
    46 
    44 
    47 /*
    45 /*
    48  * Media Player
    46  * Media Player
    49  */
    47  */
    50 XAresult XAMediaPlayerImpl_CreateMediaPlayer(   FrameworkMap* mapper,
    48 XAresult XAMediaPlayerImpl_CreateMediaPlayer(FrameworkMap* mapper,
    51                                                 XACapabilities* capabilities,
    49         XACapabilities* capabilities, XAObjectItf *pPlayer,
    52                                                 XAObjectItf *pPlayer,
    50         XADataSource *pDataSrc, XADataSource *pBankSrc,
    53                                                 XADataSource *pDataSrc,
    51         XADataSink *pAudioSnk, XADataSink *pImageVideoSnk,
    54                                                 XADataSource *pBankSrc,
    52         XADataSink *pVibra, XADataSink *pLEDArray, XAuint32 numInterfaces,
    55                                                 XADataSink *pAudioSnk,
    53         const XAInterfaceID *pInterfaceIds,
    56                                                 XADataSink *pImageVideoSnk,
    54         const XAboolean *pInterfaceRequired);
    57                                                 XADataSink *pVibra,
       
    58                                                 XADataSink *pLEDArray,
       
    59                                                 XAuint32 numInterfaces,
       
    60                                                 const XAInterfaceID *pInterfaceIds,
       
    61                                                 const XAboolean *pInterfaceRequired);
       
    62 
    55 
    63 XAresult XAMediaPlayerImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
    56 XAresult XAMediaPlayerImpl_QueryNumSupportedInterfaces(
       
    57         XAuint32 *pNumSupportedInterfaces);
    64 
    58 
    65 XAresult XAMediaPlayerImpl_QuerySupportedInterfaces(XAuint32 index,
    59 XAresult XAMediaPlayerImpl_QuerySupportedInterfaces(XAuint32 index,
    66                                                   XAInterfaceID *pInterfaceId);
    60         XAInterfaceID *pInterfaceId);
    67 
    61 
    68 /*
    62 /*
    69  * Metadata Extractor
    63  * Metadata Extractor
    70  */
    64  */
    71 XAresult XAMetadataExtractorImpl_Create(    FrameworkMap* mapper,
    65 XAresult XAMetadataExtractorImpl_Create(FrameworkMap* mapper,
    72                                             XACapabilities* capabilities,
    66         XACapabilities* capabilities, XAObjectItf *pMetadataExtractor,
    73                                             XAObjectItf *pMetadataExtractor,
    67         XADataSource *pDataSource, XAuint32 numInterfaces,
    74                                             XADataSource *pDataSource,
    68         const XAInterfaceID *pInterfaceIds,
    75                                             XAuint32 numInterfaces,
    69         const XAboolean *pInterfaceRequired);
    76                                             const XAInterfaceID *pInterfaceIds,
       
    77                                             const XAboolean *pInterfaceRequired );
       
    78 
    70 
    79 XAresult XAMetadataExtractorImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
    71 XAresult XAMetadataExtractorImpl_QueryNumSupportedInterfaces(
       
    72         XAuint32 *pNumSupportedInterfaces);
    80 
    73 
    81 XAresult XAMetadataExtractorImpl_QuerySupportedInterfaces(XAuint32 index,
    74 XAresult XAMetadataExtractorImpl_QuerySupportedInterfaces(XAuint32 index,
    82                                             XAInterfaceID *pInterfaceId);
    75         XAInterfaceID *pInterfaceId);
    83 
    76 
    84 /*
    77 /*
    85  * Output Mix
    78  * Output Mix
    86  */
    79  */
    87 XAresult XAOMixImpl_CreateOutputMix(    FrameworkMap* mapper,
    80 XAresult XAOMixImpl_CreateOutputMix(FrameworkMap* mapper,
    88                                         XACapabilities* capabilities,
    81         XACapabilities* capabilities, XAObjectItf *pMix,
    89                                         XAObjectItf *pMix,
    82         XAuint32 numInterfaces, const XAInterfaceID *pInterfaceIds,
    90                                         XAuint32 numInterfaces,
    83         const XAboolean *pInterfaceRequired);
    91                                         const XAInterfaceID *pInterfaceIds,
       
    92                                         const XAboolean *pInterfaceRequired );
       
    93 
    84 
    94 XAresult XAOMixImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
    85 XAresult XAOMixImpl_QueryNumSupportedInterfaces(
       
    86         XAuint32 *pNumSupportedInterfaces);
    95 
    87 
    96 XAresult XAOMixImpl_QuerySupportedInterfaces(XAuint32 index,
    88 XAresult XAOMixImpl_QuerySupportedInterfaces(XAuint32 index,
    97                                              XAInterfaceID *pInterfaceId);
    89         XAInterfaceID *pInterfaceId);
    98 
    90 
    99 /*
    91 /*
   100  * Media Recorder
    92  * Media Recorder
   101  */
    93  */
   102 XAresult XAMediaRecorderImpl_CreateMediaRecorder(FrameworkMap* mapper,
    94 XAresult XAMediaRecorderImpl_CreateMediaRecorder(FrameworkMap* mapper,
   103                                                  XACapabilities* capabilities,
    95         XACapabilities* capabilities, XAObjectItf* pRecorder,
   104                                                  XAObjectItf* pRecorder,
    96         XADataSource* pAudioSrc, XADataSource* pImageVideoSrc,
   105                                                  XADataSource* pAudioSrc,
    97         XADataSink* pDataSnk, XAuint32 numInterfaces,
   106                                                  XADataSource* pImageVideoSrc,
    98         const XAInterfaceID *pInterfaceIds,
   107                                                  XADataSink* pDataSnk,
    99         const XAboolean *pInterfaceRequired);
   108                                                  XAuint32 numInterfaces,
       
   109                                                  const XAInterfaceID *pInterfaceIds,
       
   110                                                  const XAboolean *pInterfaceRequired);
       
   111 
   100 
   112 XAresult XAMediaRecorderImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
   101 XAresult XAMediaRecorderImpl_QueryNumSupportedInterfaces(
       
   102         XAuint32 *pNumSupportedInterfaces);
   113 
   103 
   114 XAresult XAMediaRecorderImpl_QuerySupportedInterfaces(XAuint32 index,
   104 XAresult XAMediaRecorderImpl_QuerySupportedInterfaces(XAuint32 index,
   115                                                       XAInterfaceID *pInterfaceId);
   105         XAInterfaceID *pInterfaceId);
   116 
   106 
   117 /*
   107 /*
   118  * Camera Device
   108  * Camera Device
   119  */
   109  */
   120 XAresult XACameraDeviceImpl_CreateCameraDevice( FrameworkMap* mapper,
   110 XAresult XACameraDeviceImpl_CreateCameraDevice(FrameworkMap* mapper,
   121                                                 XACapabilities* capabilities,
   111         XACapabilities* capabilities, XAObjectItf* pDevice,
   122                                                 XAObjectItf* pDevice,
   112         XAuint32 deviceID, XAuint32 numInterfaces,
   123                                                 XAuint32 deviceID,
   113         const XAInterfaceID * pInterfaceIds,
   124                                                 XAuint32 numInterfaces,
   114         const XAboolean * pInterfaceRequired);
   125                                                 const XAInterfaceID * pInterfaceIds,
       
   126                                                 const XAboolean * pInterfaceRequired);
       
   127 
   115 
   128 XAresult XACameraDeviceImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
   116 XAresult XACameraDeviceImpl_QueryNumSupportedInterfaces(
       
   117         XAuint32 *pNumSupportedInterfaces);
   129 
   118 
   130 XAresult XACameraDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   119 XAresult XACameraDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   131                                                      XAInterfaceID *pInterfaceId);
   120         XAInterfaceID *pInterfaceId);
   132 
   121 
   133 /*
   122 /*
   134  * Radio Device
   123  * Radio Device
   135  */
   124  */
   136 XAresult XARadioDeviceImpl_CreateRadioDevice(   FrameworkMap* mapper,
   125 XAresult XARadioDeviceImpl_CreateRadioDevice( /*FrameworkMap* mapper,*/
   137                                                 XAObjectItf* pDevice,
   126 XAObjectItf* pDevice, XAuint32 numInterfaces,
   138                                                 XAuint32 numInterfaces,
   127         const XAInterfaceID * pInterfaceIds,
   139                                                 const XAInterfaceID * pInterfaceIds,
   128         const XAboolean * pInterfaceRequired);
   140                                                 const XAboolean * pInterfaceRequired);
       
   141 
   129 
   142 XAresult XARadioDeviceImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
   130 XAresult XARadioDeviceImpl_QueryNumSupportedInterfaces(
       
   131         XAuint32 *pNumSupportedInterfaces);
   143 
   132 
   144 XAresult XARadioDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   133 XAresult XARadioDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   145                                                     XAInterfaceID *pInterfaceId);
   134         XAInterfaceID *pInterfaceId);
   146 
   135 
   147 /*
   136 /*
   148  * Vibra Device
   137  * Vibra Device
   149  */
   138  */
   150 XAresult XAVibraDeviceImpl_CreateVibraDevice(   FrameworkMap* mapper,
   139 XAresult XAVibraDeviceImpl_CreateVibraDevice(FrameworkMap* mapper,
   151                                                 XAObjectItf* pDevice,
   140         XAObjectItf* pDevice, XAuint32 deviceID, XAuint32 numInterfaces,
   152                                                 XAuint32 deviceID,
   141         const XAInterfaceID * pInterfaceIds,
   153                                                 XAuint32 numInterfaces,
   142         const XAboolean * pInterfaceRequired);
   154                                                 const XAInterfaceID * pInterfaceIds,
       
   155                                                 const XAboolean * pInterfaceRequired);
       
   156 
   143 
   157 XAresult XAVibraDeviceImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
   144 XAresult XAVibraDeviceImpl_QueryNumSupportedInterfaces(
       
   145         XAuint32 *pNumSupportedInterfaces);
   158 
   146 
   159 XAresult XAVibraDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   147 XAresult XAVibraDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   160                                                     XAInterfaceID *pInterfaceId);
   148         XAInterfaceID *pInterfaceId);
   161 
   149 
   162 /*
   150 /*
   163  * LED Array
   151  * LED Array
   164  */
   152  */
   165 XAresult XALEDArrayDeviceImpl_CreateLEDArrayDevice( FrameworkMap* mapper,
   153 XAresult XALEDArrayDeviceImpl_CreateLEDArrayDevice(FrameworkMap* mapper,
   166                                                     XAObjectItf* pDevice,
   154         XAObjectItf* pDevice, XAuint32 deviceID, XAuint32 numInterfaces,
   167                                                     XAuint32 deviceID,
   155         const XAInterfaceID * pInterfaceIds,
   168                                                     XAuint32 numInterfaces,
   156         const XAboolean * pInterfaceRequired);
   169                                                     const XAInterfaceID * pInterfaceIds,
       
   170                                                     const XAboolean * pInterfaceRequired);
       
   171 
   157 
   172 XAresult XALEDArrayDeviceImpl_QueryNumSupportedInterfaces(XAuint32 *pNumSupportedInterfaces);
   158 XAresult XALEDArrayDeviceImpl_QueryNumSupportedInterfaces(
       
   159         XAuint32 *pNumSupportedInterfaces);
   173 
   160 
   174 XAresult XALEDArrayDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   161 XAresult XALEDArrayDeviceImpl_QuerySupportedInterfaces(XAuint32 index,
   175                                                     XAInterfaceID *pInterfaceId);
   162         XAInterfaceID *pInterfaceId);
   176 
       
   177 
   163 
   178 #endif /*XAOBJECTS_H */
   164 #endif /*XAOBJECTS_H */