You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
529 lines
19 KiB
529 lines
19 KiB
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/* Classes vs. interfaces */
|
|
|
|
#include "sles_allinclusive.h"
|
|
|
|
|
|
#if USE_PROFILES & USE_PROFILES_GAME
|
|
|
|
// 3DGroup class
|
|
|
|
static const struct iid_vtable _3DGroup_interfaces[INTERFACES_3DGroup] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(C3DGroup, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(C3DGroup, mDynamicInterfaceManagement)},
|
|
{MPH_3DLOCATION, INTERFACE_IMPLICIT, offsetof(C3DGroup, m3DLocation)},
|
|
{MPH_3DDOPPLER, INTERFACE_DYNAMIC_GAME, offsetof(C3DGroup, m3DDoppler)},
|
|
{MPH_3DSOURCE, INTERFACE_EXPLICIT_GAME, offsetof(C3DGroup, m3DSource)},
|
|
{MPH_3DMACROSCOPIC, INTERFACE_OPTIONAL, offsetof(C3DGroup, m3DMacroscopic)},
|
|
};
|
|
|
|
static const ClassTable C3DGroup_class = {
|
|
_3DGroup_interfaces,
|
|
INTERFACES_3DGroup,
|
|
MPH_to_3DGroup,
|
|
"3DGroup",
|
|
sizeof(C3DGroup),
|
|
SL_OBJECTID_3DGROUP,
|
|
0, // OpenMAX AL object ID
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
C3DGroup_PreDestroy
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
// AudioPlayer class
|
|
|
|
static const struct iid_vtable AudioPlayer_interfaces[INTERFACES_AudioPlayer] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CAudioPlayer, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CAudioPlayer, mDynamicInterfaceManagement)},
|
|
{MPH_PLAY, INTERFACE_IMPLICIT, offsetof(CAudioPlayer, mPlay)},
|
|
{MPH_3DDOPPLER, INTERFACE_DYNAMIC_GAME, offsetof(CAudioPlayer, m3DDoppler)},
|
|
{MPH_3DGROUPING, INTERFACE_EXPLICIT_GAME, offsetof(CAudioPlayer, m3DGrouping)},
|
|
{MPH_3DLOCATION, INTERFACE_EXPLICIT_GAME, offsetof(CAudioPlayer, m3DLocation)},
|
|
{MPH_3DSOURCE, INTERFACE_EXPLICIT_GAME, offsetof(CAudioPlayer, m3DSource)},
|
|
{MPH_BUFFERQUEUE, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mBufferQueue)},
|
|
{MPH_EFFECTSEND, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mEffectSend)},
|
|
{MPH_MUTESOLO, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mMuteSolo)},
|
|
{MPH_METADATAEXTRACTION, INTERFACE_DYNAMIC,
|
|
offsetof(CAudioPlayer, mMetadataExtraction)},
|
|
{MPH_METADATATRAVERSAL, INTERFACE_DYNAMIC_GAME_MUSIC,
|
|
offsetof(CAudioPlayer, mMetadataTraversal)},
|
|
{MPH_PREFETCHSTATUS, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mPrefetchStatus)},
|
|
{MPH_RATEPITCH, INTERFACE_DYNAMIC_GAME, offsetof(CAudioPlayer, mRatePitch)},
|
|
{MPH_SEEK, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mSeek)},
|
|
// The base Volume interface is explicit, but portions are only for Game and Music profiles
|
|
{MPH_VOLUME, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mVolume)},
|
|
{MPH_3DMACROSCOPIC, INTERFACE_OPTIONAL, offsetof(CAudioPlayer, m3DMacroscopic)},
|
|
{MPH_BASSBOOST, INTERFACE_DYNAMIC, offsetof(CAudioPlayer, mBassBoost)},
|
|
{MPH_DYNAMICSOURCE, INTERFACE_OPTIONAL, offsetof(CAudioPlayer, mDynamicSource)},
|
|
{MPH_ENVIRONMENTALREVERB, INTERFACE_DYNAMIC,
|
|
offsetof(CAudioPlayer, mEnvironmentalReverb)},
|
|
{MPH_EQUALIZER, INTERFACE_DYNAMIC, offsetof(CAudioPlayer, mEqualizer)},
|
|
{MPH_PITCH, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CAudioPlayer, mPitch)},
|
|
{MPH_PRESETREVERB, INTERFACE_DYNAMIC, offsetof(CAudioPlayer, mPresetReverb)},
|
|
{MPH_PLAYBACKRATE, INTERFACE_DYNAMIC, offsetof(CAudioPlayer, mPlaybackRate)},
|
|
{MPH_VIRTUALIZER, INTERFACE_DYNAMIC, offsetof(CAudioPlayer, mVirtualizer)},
|
|
{MPH_VISUALIZATION, INTERFACE_OPTIONAL, offsetof(CAudioPlayer, mVisualization)},
|
|
#ifdef ANDROID
|
|
{MPH_ANDROIDEFFECT, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mAndroidEffect)},
|
|
{MPH_ANDROIDEFFECTSEND, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mAndroidEffectSend)},
|
|
{MPH_ANDROIDCONFIGURATION, INTERFACE_EXPLICIT_PREREALIZE,
|
|
offsetof(CAudioPlayer, mAndroidConfiguration)},
|
|
{MPH_ANDROIDBUFFERQUEUESOURCE, INTERFACE_EXPLICIT, offsetof(CAudioPlayer, mAndroidBufferQueue)},
|
|
#endif
|
|
};
|
|
|
|
static const ClassTable CAudioPlayer_class = {
|
|
AudioPlayer_interfaces,
|
|
INTERFACES_AudioPlayer,
|
|
MPH_to_AudioPlayer,
|
|
"AudioPlayer",
|
|
sizeof(CAudioPlayer),
|
|
SL_OBJECTID_AUDIOPLAYER,
|
|
0, // OpenMAX AL object ID
|
|
CAudioPlayer_Realize,
|
|
CAudioPlayer_Resume,
|
|
CAudioPlayer_Destroy,
|
|
CAudioPlayer_PreDestroy
|
|
};
|
|
|
|
|
|
#if (USE_PROFILES & USE_PROFILES_OPTIONAL) || defined(ANDROID)
|
|
|
|
// AudioRecorder class
|
|
|
|
static const struct iid_vtable AudioRecorder_interfaces[INTERFACES_AudioRecorder] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CAudioRecorder, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CAudioRecorder, mDynamicInterfaceManagement)},
|
|
{MPH_RECORD, INTERFACE_IMPLICIT, offsetof(CAudioRecorder, mRecord)},
|
|
{MPH_AUDIOENCODER, INTERFACE_EXPLICIT, offsetof(CAudioRecorder, mAudioEncoder)},
|
|
{MPH_BASSBOOST, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CAudioRecorder, mBassBoost)},
|
|
{MPH_DYNAMICSOURCE, INTERFACE_OPTIONAL, offsetof(CAudioRecorder, mDynamicSource)},
|
|
{MPH_EQUALIZER, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CAudioRecorder, mEqualizer)},
|
|
{MPH_VISUALIZATION, INTERFACE_OPTIONAL, offsetof(CAudioRecorder, mVisualization)},
|
|
{MPH_VOLUME, INTERFACE_OPTIONAL, offsetof(CAudioRecorder, mVolume)},
|
|
#ifdef ANDROID
|
|
{MPH_ANDROIDSIMPLEBUFFERQUEUE, INTERFACE_EXPLICIT, offsetof(CAudioRecorder, mBufferQueue)},
|
|
{MPH_ANDROIDCONFIGURATION, INTERFACE_EXPLICIT_PREREALIZE,
|
|
offsetof(CAudioRecorder, mAndroidConfiguration)},
|
|
/* marked explicit for Android implementation, not an SL ES explicit interface */
|
|
{MPH_ANDROIDACOUSTICECHOCANCELLATION, INTERFACE_EXPLICIT, offsetof(CAudioRecorder,
|
|
mAcousticEchoCancellation)},
|
|
/* marked explicit for Android implementation, not an SL ES explicit interface */
|
|
{MPH_ANDROIDAUTOMATICGAINCONTROL, INTERFACE_EXPLICIT, offsetof(CAudioRecorder,
|
|
mAutomaticGainControl)},
|
|
/* marked explicit for Android implementation, not an SL ES explicit interface */
|
|
{MPH_ANDROIDNOISESUPPRESSION, INTERFACE_EXPLICIT, offsetof(CAudioRecorder, mNoiseSuppression)},
|
|
#endif
|
|
};
|
|
|
|
static const ClassTable CAudioRecorder_class = {
|
|
AudioRecorder_interfaces,
|
|
INTERFACES_AudioRecorder,
|
|
MPH_to_AudioRecorder,
|
|
"AudioRecorder",
|
|
sizeof(CAudioRecorder),
|
|
SL_OBJECTID_AUDIORECORDER,
|
|
0, // OpenMAX AL object ID
|
|
CAudioRecorder_Realize,
|
|
CAudioRecorder_Resume,
|
|
CAudioRecorder_Destroy,
|
|
CAudioRecorder_PreDestroy
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
// Engine class
|
|
|
|
static const struct iid_vtable Engine_interfaces[INTERFACES_Engine] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CEngine, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CEngine, mDynamicInterfaceManagement)},
|
|
{MPH_ENGINE, INTERFACE_IMPLICIT, offsetof(CEngine, mEngine)},
|
|
{MPH_ENGINECAPABILITIES, INTERFACE_IMPLICIT_BASE, offsetof(CEngine, mEngineCapabilities)},
|
|
{MPH_THREADSYNC, INTERFACE_IMPLICIT_BASE, offsetof(CEngine, mThreadSync)},
|
|
{MPH_AUDIOIODEVICECAPABILITIES, INTERFACE_IMPLICIT_BASE,
|
|
offsetof(CEngine, mAudioIODeviceCapabilities)},
|
|
{MPH_AUDIODECODERCAPABILITIES, INTERFACE_EXPLICIT_BASE,
|
|
offsetof(CEngine, mAudioDecoderCapabilities)},
|
|
{MPH_AUDIOENCODERCAPABILITIES, INTERFACE_EXPLICIT_BASE,
|
|
offsetof(CEngine, mAudioEncoderCapabilities)},
|
|
{MPH_3DCOMMIT, INTERFACE_EXPLICIT_GAME, offsetof(CEngine, m3DCommit)},
|
|
{MPH_DEVICEVOLUME, INTERFACE_OPTIONAL, offsetof(CEngine, mDeviceVolume)},
|
|
{MPH_XAENGINE, INTERFACE_IMPLICIT, offsetof(CEngine, mXAEngine)},
|
|
#ifdef ANDROID
|
|
{MPH_ANDROIDEFFECTCAPABILITIES, INTERFACE_EXPLICIT,
|
|
offsetof(CEngine, mAndroidEffectCapabilities)},
|
|
#endif
|
|
{MPH_XAVIDEODECODERCAPABILITIES, INTERFACE_EXPLICIT,
|
|
offsetof(CEngine, mVideoDecoderCapabilities)},
|
|
};
|
|
|
|
static const ClassTable CEngine_class = {
|
|
Engine_interfaces,
|
|
INTERFACES_Engine,
|
|
MPH_to_Engine,
|
|
"Engine",
|
|
sizeof(CEngine),
|
|
SL_OBJECTID_ENGINE,
|
|
XA_OBJECTID_ENGINE,
|
|
CEngine_Realize,
|
|
CEngine_Resume,
|
|
CEngine_Destroy,
|
|
CEngine_PreDestroy
|
|
};
|
|
|
|
|
|
#if USE_PROFILES & USE_PROFILES_OPTIONAL
|
|
|
|
// LEDDevice class
|
|
|
|
static const struct iid_vtable LEDDevice_interfaces[INTERFACES_LEDDevice] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CLEDDevice, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CLEDDevice, mDynamicInterfaceManagement)},
|
|
{MPH_LED, INTERFACE_IMPLICIT, offsetof(CLEDDevice, mLEDArray)},
|
|
};
|
|
|
|
static const ClassTable CLEDDevice_class = {
|
|
LEDDevice_interfaces,
|
|
INTERFACES_LEDDevice,
|
|
MPH_to_LEDDevice,
|
|
"LEDDevice",
|
|
sizeof(CLEDDevice),
|
|
SL_OBJECTID_LEDDEVICE,
|
|
XA_OBJECTID_LEDDEVICE,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
#if USE_PROFILES & USE_PROFILES_GAME
|
|
|
|
// Listener class
|
|
|
|
static const struct iid_vtable Listener_interfaces[INTERFACES_Listener] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CListener, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CListener, mDynamicInterfaceManagement)},
|
|
{MPH_3DDOPPLER, INTERFACE_DYNAMIC_GAME, offsetof(CListener, m3DDoppler)},
|
|
{MPH_3DLOCATION, INTERFACE_EXPLICIT_GAME, offsetof(CListener, m3DLocation)},
|
|
};
|
|
|
|
static const ClassTable CListener_class = {
|
|
Listener_interfaces,
|
|
INTERFACES_Listener,
|
|
MPH_to_Listener,
|
|
"Listener",
|
|
sizeof(CListener),
|
|
SL_OBJECTID_LISTENER,
|
|
0, // OpenMAX AL object ID
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_MUSIC)
|
|
|
|
// MetadataExtractor class
|
|
|
|
static const struct iid_vtable MetadataExtractor_interfaces[INTERFACES_MetadataExtractor] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CMetadataExtractor, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CMetadataExtractor, mDynamicInterfaceManagement)},
|
|
{MPH_DYNAMICSOURCE, INTERFACE_IMPLICIT, offsetof(CMetadataExtractor, mDynamicSource)},
|
|
{MPH_METADATAEXTRACTION, INTERFACE_IMPLICIT, offsetof(CMetadataExtractor, mMetadataExtraction)},
|
|
{MPH_METADATATRAVERSAL, INTERFACE_IMPLICIT, offsetof(CMetadataExtractor, mMetadataTraversal)},
|
|
};
|
|
|
|
static const ClassTable CMetadataExtractor_class = {
|
|
MetadataExtractor_interfaces,
|
|
INTERFACES_MetadataExtractor,
|
|
MPH_to_MetadataExtractor,
|
|
"MetadataExtractor",
|
|
sizeof(CMetadataExtractor),
|
|
SL_OBJECTID_METADATAEXTRACTOR,
|
|
XA_OBJECTID_METADATAEXTRACTOR,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
#if USE_PROFILES & USE_PROFILES_GAME
|
|
|
|
// MidiPlayer class
|
|
|
|
static const struct iid_vtable MidiPlayer_interfaces[INTERFACES_MidiPlayer] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CMidiPlayer, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CMidiPlayer, mDynamicInterfaceManagement)},
|
|
{MPH_PLAY, INTERFACE_IMPLICIT, offsetof(CMidiPlayer, mPlay)},
|
|
{MPH_3DDOPPLER, INTERFACE_DYNAMIC_GAME, offsetof(C3DGroup, m3DDoppler)},
|
|
{MPH_3DGROUPING, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, m3DGrouping)},
|
|
{MPH_3DLOCATION, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, m3DLocation)},
|
|
{MPH_3DSOURCE, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, m3DSource)},
|
|
{MPH_BUFFERQUEUE, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, mBufferQueue)},
|
|
{MPH_EFFECTSEND, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, mEffectSend)},
|
|
{MPH_MUTESOLO, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, mMuteSolo)},
|
|
{MPH_METADATAEXTRACTION, INTERFACE_DYNAMIC_GAME, offsetof(CMidiPlayer, mMetadataExtraction)},
|
|
{MPH_METADATATRAVERSAL, INTERFACE_DYNAMIC_GAME, offsetof(CMidiPlayer, mMetadataTraversal)},
|
|
{MPH_MIDIMESSAGE, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mMIDIMessage)},
|
|
{MPH_MIDITIME, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mMIDITime)},
|
|
{MPH_MIDITEMPO, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mMIDITempo)},
|
|
{MPH_MIDIMUTESOLO, INTERFACE_EXPLICIT_GAME, offsetof(CMidiPlayer, mMIDIMuteSolo)},
|
|
{MPH_PREFETCHSTATUS, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mPrefetchStatus)},
|
|
{MPH_SEEK, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mSeek)},
|
|
{MPH_VOLUME, INTERFACE_EXPLICIT_GAME_PHONE, offsetof(CMidiPlayer, mVolume)},
|
|
{MPH_3DMACROSCOPIC, INTERFACE_OPTIONAL, offsetof(CMidiPlayer, m3DMacroscopic)},
|
|
{MPH_BASSBOOST, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mBassBoost)},
|
|
{MPH_DYNAMICSOURCE, INTERFACE_OPTIONAL, offsetof(CMidiPlayer, mDynamicSource)},
|
|
{MPH_ENVIRONMENTALREVERB, INTERFACE_DYNAMIC_OPTIONAL,
|
|
offsetof(CMidiPlayer, mEnvironmentalReverb)},
|
|
{MPH_EQUALIZER, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mEqualizer)},
|
|
{MPH_PITCH, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mPitch)},
|
|
{MPH_PRESETREVERB, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mPresetReverb)},
|
|
{MPH_PLAYBACKRATE, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mPlaybackRate)},
|
|
{MPH_VIRTUALIZER, INTERFACE_DYNAMIC_OPTIONAL, offsetof(CMidiPlayer, mVirtualizer)},
|
|
{MPH_VISUALIZATION, INTERFACE_OPTIONAL, offsetof(CMidiPlayer, mVisualization)},
|
|
};
|
|
|
|
static const ClassTable CMidiPlayer_class = {
|
|
MidiPlayer_interfaces,
|
|
INTERFACES_MidiPlayer,
|
|
MPH_to_MidiPlayer,
|
|
"MidiPlayer",
|
|
sizeof(CMidiPlayer),
|
|
SL_OBJECTID_MIDIPLAYER,
|
|
0, // OpenMAX AL object ID
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
// OutputMix class
|
|
|
|
static const struct iid_vtable OutputMix_interfaces[INTERFACES_OutputMix] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(COutputMix, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(COutputMix, mDynamicInterfaceManagement)},
|
|
{MPH_OUTPUTMIX, INTERFACE_IMPLICIT, offsetof(COutputMix, mOutputMix)},
|
|
#ifdef USE_OUTPUTMIXEXT
|
|
{MPH_OUTPUTMIXEXT, INTERFACE_UNAVAILABLE, offsetof(COutputMix, mOutputMixExt)},
|
|
#else
|
|
{MPH_OUTPUTMIXEXT, INTERFACE_UNAVAILABLE, 0},
|
|
#endif
|
|
{MPH_ENVIRONMENTALREVERB, INTERFACE_DYNAMIC,
|
|
offsetof(COutputMix, mEnvironmentalReverb)},
|
|
{MPH_EQUALIZER, INTERFACE_DYNAMIC, offsetof(COutputMix, mEqualizer)},
|
|
{MPH_PRESETREVERB, INTERFACE_DYNAMIC, offsetof(COutputMix, mPresetReverb)},
|
|
{MPH_VIRTUALIZER, INTERFACE_DYNAMIC, offsetof(COutputMix, mVirtualizer)},
|
|
// The overall Volume interface is explicit optional,
|
|
// but portions of Volume are mandated only in Game and Music profiles
|
|
{MPH_VOLUME, INTERFACE_OPTIONAL, offsetof(COutputMix, mVolume)},
|
|
{MPH_BASSBOOST, INTERFACE_DYNAMIC, offsetof(COutputMix, mBassBoost)},
|
|
{MPH_VISUALIZATION, INTERFACE_OPTIONAL, offsetof(COutputMix, mVisualization)},
|
|
#ifdef ANDROID
|
|
{MPH_ANDROIDEFFECT, INTERFACE_EXPLICIT, offsetof(COutputMix, mAndroidEffect)},
|
|
#endif
|
|
};
|
|
|
|
static const ClassTable COutputMix_class = {
|
|
OutputMix_interfaces,
|
|
INTERFACES_OutputMix,
|
|
MPH_to_OutputMix,
|
|
"OutputMix",
|
|
sizeof(COutputMix),
|
|
SL_OBJECTID_OUTPUTMIX,
|
|
XA_OBJECTID_OUTPUTMIX,
|
|
COutputMix_Realize,
|
|
COutputMix_Resume,
|
|
COutputMix_Destroy,
|
|
COutputMix_PreDestroy
|
|
};
|
|
|
|
|
|
#if USE_PROFILES & USE_PROFILES_OPTIONAL
|
|
|
|
// Vibra class
|
|
|
|
static const struct iid_vtable VibraDevice_interfaces[INTERFACES_VibraDevice] = {
|
|
{MPH_OBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CVibraDevice, mObject)},
|
|
{MPH_DYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CVibraDevice, mDynamicInterfaceManagement)},
|
|
{MPH_VIBRA, INTERFACE_IMPLICIT, offsetof(CVibraDevice, mVibra)},
|
|
};
|
|
|
|
static const ClassTable CVibraDevice_class = {
|
|
VibraDevice_interfaces,
|
|
INTERFACES_VibraDevice,
|
|
MPH_to_Vibra,
|
|
"VibraDevice",
|
|
sizeof(CVibraDevice),
|
|
SL_OBJECTID_VIBRADEVICE,
|
|
XA_OBJECTID_VIBRADEVICE,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
// Media player class
|
|
|
|
static const struct iid_vtable MediaPlayer_interfaces[INTERFACES_MediaPlayer] = {
|
|
{MPH_XAOBJECT, INTERFACE_IMPLICIT_PREREALIZE, offsetof(CMediaPlayer, mObject)},
|
|
{MPH_XADYNAMICINTERFACEMANAGEMENT, INTERFACE_IMPLICIT,
|
|
offsetof(CMediaPlayer, mDynamicInterfaceManagement)},
|
|
{MPH_XAPLAY, INTERFACE_IMPLICIT, offsetof(CMediaPlayer, mPlay)},
|
|
{MPH_XASTREAMINFORMATION, INTERFACE_EXPLICIT, offsetof(CMediaPlayer, mStreamInfo)},
|
|
{MPH_XAVOLUME, INTERFACE_IMPLICIT, offsetof(CMediaPlayer, mVolume)},
|
|
{MPH_XASEEK, INTERFACE_EXPLICIT, offsetof(CMediaPlayer, mSeek)},
|
|
{MPH_XAPREFETCHSTATUS, INTERFACE_EXPLICIT, offsetof(CMediaPlayer, mPrefetchStatus)},
|
|
#ifdef ANDROID
|
|
{MPH_ANDROIDBUFFERQUEUESOURCE, INTERFACE_EXPLICIT, offsetof(CMediaPlayer, mAndroidBufferQueue)},
|
|
#endif
|
|
};
|
|
|
|
static const ClassTable CMediaPlayer_class = {
|
|
MediaPlayer_interfaces,
|
|
INTERFACES_MediaPlayer,
|
|
MPH_to_MediaPlayer,
|
|
"MediaPlayer",
|
|
sizeof(CMediaPlayer),
|
|
0, // OpenSL ES object ID
|
|
XA_OBJECTID_MEDIAPLAYER,
|
|
CMediaPlayer_Realize,
|
|
CMediaPlayer_Resume,
|
|
CMediaPlayer_Destroy,
|
|
CMediaPlayer_PreDestroy
|
|
};
|
|
|
|
|
|
static const ClassTable * const slClasses[] = {
|
|
// Do not change order of these entries; they are in numerical order
|
|
&CEngine_class,
|
|
#if USE_PROFILES & USE_PROFILES_OPTIONAL
|
|
&CLEDDevice_class,
|
|
&CVibraDevice_class,
|
|
#else
|
|
NULL,
|
|
NULL,
|
|
#endif
|
|
&CAudioPlayer_class,
|
|
#if (USE_PROFILES & USE_PROFILES_OPTIONAL) || defined(ANDROID)
|
|
&CAudioRecorder_class,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_PHONE)
|
|
&CMidiPlayer_class,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
#if USE_PROFILES & USE_PROFILES_GAME
|
|
&CListener_class,
|
|
&C3DGroup_class,
|
|
#else
|
|
NULL,
|
|
NULL,
|
|
#endif
|
|
&COutputMix_class,
|
|
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_MUSIC)
|
|
&CMetadataExtractor_class
|
|
#else
|
|
NULL
|
|
#endif
|
|
};
|
|
|
|
|
|
static const ClassTable * const xaClasses[] = {
|
|
&CEngine_class,
|
|
#if USE_PROFILES & USE_PROFILES_OPTIONAL
|
|
&CLEDDevice_class,
|
|
&CVibraDevice_class,
|
|
#else
|
|
NULL,
|
|
NULL,
|
|
#endif
|
|
&CMediaPlayer_class,
|
|
#if 1
|
|
NULL,
|
|
NULL,
|
|
#else
|
|
&CMediaRecorder_class,
|
|
&CRadioDevice_class,
|
|
#endif
|
|
&COutputMix_class,
|
|
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_MUSIC)
|
|
&CMetadataExtractor_class,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
#if 1
|
|
NULL
|
|
#else
|
|
&CCameraDevice_class
|
|
#endif
|
|
};
|
|
|
|
|
|
/* \brief Map SL_OBJECTID to class or NULL if object ID not supported */
|
|
|
|
LI_API const ClassTable *objectIDtoClass(SLuint32 objectID)
|
|
{
|
|
// object ID is the engine and always present
|
|
assert(NULL != slClasses[0]);
|
|
SLuint32 slObjectID0 = slClasses[0]->mSLObjectID;
|
|
if ((slObjectID0 <= objectID) && ((slObjectID0 + sizeof(slClasses)/sizeof(slClasses[0])) >
|
|
objectID)) {
|
|
return slClasses[objectID - slObjectID0];
|
|
}
|
|
assert(NULL != xaClasses[0]);
|
|
SLuint32 xaObjectID0 = xaClasses[0]->mXAObjectID;
|
|
if ((xaObjectID0 <= objectID) && ((xaObjectID0 + sizeof(xaClasses)/sizeof(xaClasses[0])) >
|
|
objectID)) {
|
|
return xaClasses[objectID - xaObjectID0];
|
|
}
|
|
return NULL;
|
|
}
|