1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_BUFFER_PROVIDERS_H 18 #define ANDROID_BUFFER_PROVIDERS_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include <media/AudioBufferProvider.h> 24 #include <media/AudioResamplerPublic.h> 25 #include <system/audio.h> 26 #include <system/audio_effect.h> 27 #include <utils/StrongPointer.h> 28 29 // external forward declaration from external/sonic/sonic.h 30 struct sonicStreamStruct; 31 typedef struct sonicStreamStruct *sonicStream; 32 33 namespace android { 34 35 class EffectBufferHalInterface; 36 class EffectHalInterface; 37 class EffectsFactoryHalInterface; 38 39 // ---------------------------------------------------------------------------- 40 41 class PassthruBufferProvider : public AudioBufferProvider { 42 public: 43 PassthruBufferProvider() : mTrackBufferProvider(NULL) { } 44 45 virtual ~PassthruBufferProvider() { } 46 47 // call this to release the buffer to the upstream provider. 48 // treat it as an audio discontinuity for future samples. 49 virtual void reset() { } 50 51 // set the upstream buffer provider. Consider calling "reset" before this function. 52 virtual void setBufferProvider(AudioBufferProvider *p) { 53 mTrackBufferProvider = p; 54 } 55 56 protected: 57 AudioBufferProvider *mTrackBufferProvider; 58 }; 59 60 // Base AudioBufferProvider class used for DownMixerBufferProvider, RemixBufferProvider, 61 // and ReformatBufferProvider. 62 // It handles a private buffer for use in converting format or channel masks from the 63 // input data to a form acceptable by the mixer. 64 // TODO: Make a ResamplerBufferProvider when integers are entirely removed from the 65 // processing pipeline. 66 class CopyBufferProvider : public PassthruBufferProvider { 67 public: 68 // Use a private buffer of bufferFrameCount frames (each frame is outputFrameSize bytes). 69 // If bufferFrameCount is 0, no private buffer is created and in-place modification of 70 // the upstream buffer provider's buffers is performed by copyFrames(). 71 CopyBufferProvider(size_t inputFrameSize, size_t outputFrameSize, 72 size_t bufferFrameCount); 73 virtual ~CopyBufferProvider(); 74 75 // Overrides AudioBufferProvider methods 76 virtual status_t getNextBuffer(Buffer *buffer); 77 virtual void releaseBuffer(Buffer *buffer); 78 79 // Overrides PassthruBufferProvider 80 virtual void reset(); 81 82 // this function should be supplied by the derived class. It converts 83 // #frames in the *src pointer to the *dst pointer. It is public because 84 // some providers will allow this to work on arbitrary buffers outside 85 // of the internal buffers. 86 virtual void copyFrames(void *dst, const void *src, size_t frames) = 0; 87 88 protected: 89 const size_t mInputFrameSize; 90 const size_t mOutputFrameSize; 91 private: 92 AudioBufferProvider::Buffer mBuffer; 93 const size_t mLocalBufferFrameCount; 94 void *mLocalBufferData; 95 size_t mConsumed; 96 }; 97 98 // DownmixerBufferProvider derives from CopyBufferProvider to provide 99 // position dependent downmixing by an Audio Effect. 100 class DownmixerBufferProvider : public CopyBufferProvider { 101 public: 102 DownmixerBufferProvider(audio_channel_mask_t inputChannelMask, 103 audio_channel_mask_t outputChannelMask, audio_format_t format, 104 uint32_t sampleRate, int32_t sessionId, size_t bufferFrameCount); 105 virtual ~DownmixerBufferProvider(); 106 //Overrides 107 virtual void copyFrames(void *dst, const void *src, size_t frames); 108 109 bool isValid() const { return mDownmixInterface.get() != NULL; } 110 static status_t init(); 111 static bool isMultichannelCapable() { return sIsMultichannelCapable; } 112 113 protected: 114 sp<EffectsFactoryHalInterface> mEffectsFactory; 115 sp<EffectHalInterface> mDownmixInterface; 116 size_t mInFrameSize; 117 size_t mOutFrameSize; 118 sp<EffectBufferHalInterface> mInBuffer; 119 sp<EffectBufferHalInterface> mOutBuffer; 120 effect_config_t mDownmixConfig; 121 122 // effect descriptor for the downmixer used by the mixer 123 static effect_descriptor_t sDwnmFxDesc; 124 // indicates whether a downmix effect has been found and is usable by this mixer 125 static bool sIsMultichannelCapable; 126 // FIXME: should we allow effects outside of the framework? 127 // We need to here. A special ioId that must be <= -2 so it does not map to a session. 128 static const int32_t SESSION_ID_INVALID_AND_IGNORED = -2; 129 }; 130 131 // RemixBufferProvider derives from CopyBufferProvider to perform an 132 // upmix or downmix to the proper channel count and mask. 133 class RemixBufferProvider : public CopyBufferProvider { 134 public: 135 RemixBufferProvider(audio_channel_mask_t inputChannelMask, 136 audio_channel_mask_t outputChannelMask, audio_format_t format, 137 size_t bufferFrameCount); 138 //Overrides 139 virtual void copyFrames(void *dst, const void *src, size_t frames); 140 141 protected: 142 const audio_format_t mFormat; 143 const size_t mSampleSize; 144 const size_t mInputChannels; 145 const size_t mOutputChannels; 146 int8_t mIdxAry[sizeof(uint32_t) * 8]; // 32 bits => channel indices 147 }; 148 149 // ReformatBufferProvider derives from CopyBufferProvider to convert the input data 150 // to an acceptable mixer input format type. 151 class ReformatBufferProvider : public CopyBufferProvider { 152 public: 153 ReformatBufferProvider(int32_t channelCount, 154 audio_format_t inputFormat, audio_format_t outputFormat, 155 size_t bufferFrameCount); 156 virtual void copyFrames(void *dst, const void *src, size_t frames); 157 158 protected: 159 const uint32_t mChannelCount; 160 const audio_format_t mInputFormat; 161 const audio_format_t mOutputFormat; 162 }; 163 164 // ClampFloatBufferProvider derives from CopyBufferProvider to clamp floats inside -3db 165 class ClampFloatBufferProvider : public CopyBufferProvider { 166 public: 167 ClampFloatBufferProvider(int32_t channelCount, 168 size_t bufferFrameCount); 169 virtual void copyFrames(void *dst, const void *src, size_t frames); 170 171 protected: 172 const uint32_t mChannelCount; 173 }; 174 175 // TimestretchBufferProvider derives from PassthruBufferProvider for time stretching 176 class TimestretchBufferProvider : public PassthruBufferProvider { 177 public: 178 TimestretchBufferProvider(int32_t channelCount, 179 audio_format_t format, uint32_t sampleRate, 180 const AudioPlaybackRate &playbackRate); 181 virtual ~TimestretchBufferProvider(); 182 183 // Overrides AudioBufferProvider methods 184 virtual status_t getNextBuffer(Buffer* buffer); 185 virtual void releaseBuffer(Buffer* buffer); 186 187 // Overrides PassthruBufferProvider 188 virtual void reset(); 189 190 virtual status_t setPlaybackRate(const AudioPlaybackRate &playbackRate); 191 192 // processes frames 193 // dstBuffer is where to place the data 194 // dstFrames [in/out] is the desired frames (return with actual placed in buffer) 195 // srcBuffer is the source data 196 // srcFrames [in/out] is the available source frames (return with consumed) 197 virtual void processFrames(void *dstBuffer, size_t *dstFrames, 198 const void *srcBuffer, size_t *srcFrames); 199 200 protected: 201 const uint32_t mChannelCount; 202 const audio_format_t mFormat; 203 const uint32_t mSampleRate; // const for now (TODO change this) 204 const size_t mFrameSize; 205 AudioPlaybackRate mPlaybackRate; 206 207 private: 208 AudioBufferProvider::Buffer mBuffer; // for upstream request 209 size_t mLocalBufferFrameCount; // size of local buffer 210 void *mLocalBufferData; // internally allocated buffer for data returned 211 // to caller 212 size_t mRemaining; // remaining data in local buffer 213 sonicStream mSonicStream; // handle to sonic timestretch object 214 //FIXME: this dependency should be abstracted out 215 bool mFallbackFailErrorShown; // log fallback error only once 216 bool mAudioPlaybackRateValid; // flag for current parameters validity 217 }; 218 219 // ---------------------------------------------------------------------------- 220 } // namespace android 221 222 #endif // ANDROID_BUFFER_PROVIDERS_H 223