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 void setBufferProvider(AudioBufferProvider *p) override; 82 83 // this function should be supplied by the derived class. It converts 84 // #frames in the *src pointer to the *dst pointer. It is public because 85 // some providers will allow this to work on arbitrary buffers outside 86 // of the internal buffers. 87 virtual void copyFrames(void *dst, const void *src, size_t frames) = 0; 88 89 protected: 90 const size_t mInputFrameSize; 91 const size_t mOutputFrameSize; 92 private: 93 AudioBufferProvider::Buffer mBuffer; 94 const size_t mLocalBufferFrameCount; 95 void *mLocalBufferData; 96 size_t mConsumed; 97 }; 98 99 // DownmixerBufferProvider derives from CopyBufferProvider to provide 100 // position dependent downmixing by an Audio Effect. 101 class DownmixerBufferProvider : public CopyBufferProvider { 102 public: 103 DownmixerBufferProvider(audio_channel_mask_t inputChannelMask, 104 audio_channel_mask_t outputChannelMask, audio_format_t format, 105 uint32_t sampleRate, int32_t sessionId, size_t bufferFrameCount); 106 virtual ~DownmixerBufferProvider(); 107 //Overrides 108 virtual void copyFrames(void *dst, const void *src, size_t frames); 109 110 bool isValid() const { return mDownmixInterface.get() != NULL; } 111 static status_t init(); 112 static bool isMultichannelCapable() { return sIsMultichannelCapable; } 113 114 protected: 115 sp<EffectsFactoryHalInterface> mEffectsFactory; 116 sp<EffectHalInterface> mDownmixInterface; 117 size_t mInFrameSize; 118 size_t mOutFrameSize; 119 sp<EffectBufferHalInterface> mInBuffer; 120 sp<EffectBufferHalInterface> mOutBuffer; 121 effect_config_t mDownmixConfig; 122 123 // effect descriptor for the downmixer used by the mixer 124 static effect_descriptor_t sDwnmFxDesc; 125 // indicates whether a downmix effect has been found and is usable by this mixer 126 static bool sIsMultichannelCapable; 127 // FIXME: should we allow effects outside of the framework? 128 // We need to here. A special ioId that must be <= -2 so it does not map to a session. 129 static const int32_t SESSION_ID_INVALID_AND_IGNORED = -2; 130 }; 131 132 // RemixBufferProvider derives from CopyBufferProvider to perform an 133 // upmix or downmix to the proper channel count and mask. 134 class RemixBufferProvider : public CopyBufferProvider { 135 public: 136 RemixBufferProvider(audio_channel_mask_t inputChannelMask, 137 audio_channel_mask_t outputChannelMask, audio_format_t format, 138 size_t bufferFrameCount); 139 //Overrides 140 virtual void copyFrames(void *dst, const void *src, size_t frames); 141 142 protected: 143 const audio_format_t mFormat; 144 const size_t mSampleSize; 145 const size_t mInputChannels; 146 const size_t mOutputChannels; 147 int8_t mIdxAry[sizeof(uint32_t) * 8]; // 32 bits => channel indices 148 }; 149 150 // ReformatBufferProvider derives from CopyBufferProvider to convert the input data 151 // to an acceptable mixer input format type. 152 class ReformatBufferProvider : public CopyBufferProvider { 153 public: 154 ReformatBufferProvider(int32_t channelCount, 155 audio_format_t inputFormat, audio_format_t outputFormat, 156 size_t bufferFrameCount); 157 virtual void copyFrames(void *dst, const void *src, size_t frames); 158 159 protected: 160 const uint32_t mChannelCount; 161 const audio_format_t mInputFormat; 162 const audio_format_t mOutputFormat; 163 }; 164 165 // ClampFloatBufferProvider derives from CopyBufferProvider to clamp floats inside -3db 166 class ClampFloatBufferProvider : public CopyBufferProvider { 167 public: 168 ClampFloatBufferProvider(int32_t channelCount, 169 size_t bufferFrameCount); 170 virtual void copyFrames(void *dst, const void *src, size_t frames); 171 172 protected: 173 const uint32_t mChannelCount; 174 }; 175 176 // TimestretchBufferProvider derives from PassthruBufferProvider for time stretching 177 class TimestretchBufferProvider : public PassthruBufferProvider { 178 public: 179 TimestretchBufferProvider(int32_t channelCount, 180 audio_format_t format, uint32_t sampleRate, 181 const AudioPlaybackRate &playbackRate); 182 virtual ~TimestretchBufferProvider(); 183 184 // Overrides AudioBufferProvider methods 185 virtual status_t getNextBuffer(Buffer* buffer); 186 virtual void releaseBuffer(Buffer* buffer); 187 188 // Overrides PassthruBufferProvider 189 virtual void reset(); 190 void setBufferProvider(AudioBufferProvider *p) override; 191 192 virtual status_t setPlaybackRate(const AudioPlaybackRate &playbackRate); 193 194 // processes frames 195 // dstBuffer is where to place the data 196 // dstFrames [in/out] is the desired frames (return with actual placed in buffer) 197 // srcBuffer is the source data 198 // srcFrames [in/out] is the available source frames (return with consumed) 199 virtual void processFrames(void *dstBuffer, size_t *dstFrames, 200 const void *srcBuffer, size_t *srcFrames); 201 202 protected: 203 const uint32_t mChannelCount; 204 const audio_format_t mFormat; 205 const uint32_t mSampleRate; // const for now (TODO change this) 206 const size_t mFrameSize; 207 AudioPlaybackRate mPlaybackRate; 208 209 private: 210 AudioBufferProvider::Buffer mBuffer; // for upstream request 211 size_t mLocalBufferFrameCount; // size of local buffer 212 void *mLocalBufferData; // internally allocated buffer for data returned 213 // to caller 214 size_t mRemaining; // remaining data in local buffer 215 sonicStream mSonicStream; // handle to sonic timestretch object 216 //FIXME: this dependency should be abstracted out 217 bool mFallbackFailErrorShown; // log fallback error only once 218 bool mAudioPlaybackRateValid; // flag for current parameters validity 219 }; 220 221 // AdjustChannelsBufferProvider derives from CopyBufferProvider to adjust sample data. 222 // Expands or contracts sample data from one interleaved channel format to another. 223 // Extra expanded channels are filled with zeros and put at the end of each audio frame. 224 // Contracted channels are copied to the end of the output buffer(storage should be 225 // allocated appropriately). 226 // Contracted channels could be written to output buffer. 227 class AdjustChannelsBufferProvider : public CopyBufferProvider { 228 public: 229 AdjustChannelsBufferProvider(audio_format_t format, size_t inChannelCount, 230 size_t outChannelCount, size_t frameCount) : AdjustChannelsBufferProvider( 231 format, inChannelCount, outChannelCount, 232 frameCount, AUDIO_FORMAT_INVALID, nullptr) { } 233 // Contracted data is converted to contractedFormat and put into contractedBuffer. 234 AdjustChannelsBufferProvider(audio_format_t format, size_t inChannelCount, 235 size_t outChannelCount, size_t frameCount, audio_format_t contractedFormat, 236 void* contractedBuffer); 237 //Overrides 238 status_t getNextBuffer(Buffer* pBuffer) override; 239 void copyFrames(void *dst, const void *src, size_t frames) override; 240 void reset() override; 241 242 void clearContractedFrames() { mContractedWrittenFrames = 0; } 243 244 protected: 245 const audio_format_t mFormat; 246 const size_t mInChannelCount; 247 const size_t mOutChannelCount; 248 const size_t mSampleSizeInBytes; 249 const size_t mFrameCount; 250 const size_t mContractedChannelCount; 251 const audio_format_t mContractedFormat; 252 void *mContractedBuffer; 253 size_t mContractedWrittenFrames; 254 size_t mContractedFrameSize; 255 }; 256 // ---------------------------------------------------------------------------- 257 } // namespace android 258 259 #endif // ANDROID_BUFFER_PROVIDERS_H 260
