1 /* 2 ** 3 ** Copyright 2012, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #pragma once 19 20 #include "TrackBase.h" 21 22 #include <android/content/AttributionSourceState.h> 23 #include <audio_utils/mutex.h> 24 #include <datapath/AudioStreamIn.h> // struct Source 25 26 namespace android { 27 28 // record track 29 class RecordTrack : public TrackBase, public virtual IAfRecordTrack { 30 public: 31 RecordTrack(IAfRecordThread* thread, 32 const sp<Client>& client, 33 const audio_attributes_t& attr, 34 uint32_t sampleRate, 35 audio_format_t format, 36 audio_channel_mask_t channelMask, 37 size_t frameCount, 38 void *buffer, 39 size_t bufferSize, 40 audio_session_t sessionId, 41 pid_t creatorPid, 42 const AttributionSourceState& attributionSource, 43 audio_input_flags_t flags, 44 track_type type, 45 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE, 46 int32_t startFrames = -1); 47 ~RecordTrack() override; 48 status_t initCheck() const final; 49 50 status_t start(AudioSystem::sync_event_t event, audio_session_t triggerSession) final; 51 void stop() final; 52 void destroy() final; 53 void invalidate() final; 54 55 // clear the buffer overflow flag clearOverflow()56 void clearOverflow() final { mOverflow = false; } 57 // set the buffer overflow flag and return previous value setOverflow()58 bool setOverflow() final { bool tmp = mOverflow; mOverflow = true; 59 return tmp; } 60 61 void appendDumpHeader(String8& result) const final; 62 void appendDump(String8& result, bool active) const final; 63 64 void handleSyncStartEvent(const sp<audioflinger::SyncEvent>& event) final; 65 void clearSyncStartEvent() final; 66 67 void updateTrackFrameInfo(int64_t trackFramesReleased, 68 int64_t sourceFramesRead, 69 uint32_t halSampleRate, 70 const ExtendedTimestamp ×tamp) final; 71 isFastTrack()72 bool isFastTrack() const final { return (mFlags & AUDIO_INPUT_FLAG_FAST) != 0; } isDirect()73 bool isDirect() const final 74 { return (mFlags & AUDIO_INPUT_FLAG_DIRECT) != 0; } 75 76 void setSilenced(bool silenced) final; isSilenced()77 bool isSilenced() const final { return mSilenced; } 78 79 status_t getActiveMicrophones( 80 std::vector<media::MicrophoneInfoFw>* activeMicrophones) const final; 81 82 status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) final; 83 status_t setPreferredMicrophoneFieldDimension(float zoom) final; 84 status_t shareAudioHistory(const std::string& sharedAudioPackageName, 85 int64_t sharedAudioStartMs) final; 86 status_t setParameters(const String8& keyValuePairs) final; startFrames()87 int32_t startFrames() const final { return mStartFrames; } 88 89 using SinkMetadatas = std::vector<record_track_metadata_v7_t>; 90 using MetadataInserter = std::back_insert_iterator<SinkMetadatas>; 91 void copyMetadataTo(MetadataInserter& backInserter) const final; 92 sinkBuffer()93 AudioBufferProvider::Buffer& sinkBuffer() final { return mSink; } synchronizedRecordState()94 audioflinger::SynchronizedRecordState& synchronizedRecordState() final { 95 return mSynchronizedRecordState; 96 } recordBufferConverter()97 RecordBufferConverter* recordBufferConverter() const final { return mRecordBufferConverter; } resamplerBufferProvider()98 ResamplerBufferProvider* resamplerBufferProvider() const final { 99 return mResamplerBufferProvider; 100 } 101 trackFlagsAsString()102 std::string trackFlagsAsString() const final { return toString(mFlags); } 103 104 private: 105 DISALLOW_COPY_AND_ASSIGN(RecordTrack); 106 107 protected: 108 // AudioBufferProvider interface 109 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; 110 // releaseBuffer() not overridden 111 112 private: 113 114 bool mOverflow; // overflow on most recent attempt to fill client buffer 115 116 AudioBufferProvider::Buffer mSink; // references client's buffer sink in shared memory 117 118 // sync event triggering actual audio capture. Frames read before this event will 119 // be dropped and therefore not read by the application. 120 sp<audioflinger::SyncEvent> mSyncStartEvent; 121 122 audioflinger::SynchronizedRecordState 123 mSynchronizedRecordState{mSampleRate}; // sampleRate defined in base 124 125 // used by resampler to find source frames 126 ResamplerBufferProvider* mResamplerBufferProvider; 127 128 // used by the record thread to convert frames to proper destination format 129 RecordBufferConverter *mRecordBufferConverter; 130 audio_input_flags_t mFlags; 131 132 bool mSilenced; 133 134 std::string mSharedAudioPackageName = {}; 135 int32_t mStartFrames = -1; 136 }; 137 138 // playback track, used by PatchPanel 139 class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord { 140 public: 141 PatchRecord(IAfRecordThread* recordThread, 142 uint32_t sampleRate, 143 audio_channel_mask_t channelMask, 144 audio_format_t format, 145 size_t frameCount, 146 void *buffer, 147 size_t bufferSize, 148 audio_input_flags_t flags, 149 const Timeout& timeout = {}, 150 audio_source_t source = AUDIO_SOURCE_DEFAULT); 151 ~PatchRecord() override; 152 getSource()153 Source* getSource() override { return nullptr; } 154 155 // AudioBufferProvider interface 156 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; 157 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override; 158 159 // PatchProxyBufferProvider interface 160 status_t obtainBuffer(Proxy::Buffer* buffer, 161 const struct timespec* timeOut = nullptr) override; 162 void releaseBuffer(Proxy::Buffer* buffer) override; 163 writeFrames(const void * src,size_t frameCount,size_t frameSize)164 size_t writeFrames(const void* src, size_t frameCount, size_t frameSize) final { 165 return writeFrames(this, src, frameCount, frameSize); 166 } 167 168 protected: 169 /** Write the source data into the buffer provider. @return written frame count. */ 170 static size_t writeFrames(AudioBufferProvider* dest, const void* src, 171 size_t frameCount, size_t frameSize); 172 173 }; // end of PatchRecord 174 175 class PassthruPatchRecord : public PatchRecord, public Source { 176 public: 177 PassthruPatchRecord(IAfRecordThread* recordThread, 178 uint32_t sampleRate, 179 audio_channel_mask_t channelMask, 180 audio_format_t format, 181 size_t frameCount, 182 audio_input_flags_t flags, 183 audio_source_t source = AUDIO_SOURCE_DEFAULT); 184 getSource()185 Source* getSource() final { return static_cast<Source*>(this); } 186 187 // Source interface 188 status_t read(void* buffer, size_t bytes, size_t* read) final; 189 status_t getCapturePosition(int64_t* frames, int64_t* time) final; 190 status_t standby() final; 191 192 // AudioBufferProvider interface 193 // This interface is used by RecordThread to pass the data obtained 194 // from HAL or other source to the client. PassthruPatchRecord receives 195 // the data in 'obtainBuffer' so these calls are stubbed out. 196 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final; 197 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final; 198 199 // PatchProxyBufferProvider interface 200 // This interface is used from DirectOutputThread to acquire data from HAL. producesBufferOnDemand()201 bool producesBufferOnDemand() const final { return true; } 202 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final; 203 void releaseBuffer(Proxy::Buffer* buffer) final; 204 205 private: 206 // This is to use with PatchRecord::writeFrames 207 struct PatchRecordAudioBufferProvider : public AudioBufferProvider { PatchRecordAudioBufferProviderPatchRecordAudioBufferProvider208 explicit PatchRecordAudioBufferProvider(PassthruPatchRecord& passthru) : 209 mPassthru(passthru) {} getNextBufferPatchRecordAudioBufferProvider210 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override { 211 return mPassthru.PatchRecord::getNextBuffer(buffer); 212 } releaseBufferPatchRecordAudioBufferProvider213 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override { 214 return mPassthru.PatchRecord::releaseBuffer(buffer); 215 } 216 private: 217 PassthruPatchRecord& mPassthru; 218 }; 219 220 sp<StreamInHalInterface> obtainStream(sp<IAfThreadBase>* thread); readMutex()221 audio_utils::mutex& readMutex() const { return mReadMutex; } 222 223 PatchRecordAudioBufferProvider mPatchRecordAudioBufferProvider; 224 std::unique_ptr<void, decltype(free)*> mSinkBuffer; // frame size aligned continuous buffer 225 std::unique_ptr<void, decltype(free)*> mStubBuffer; // buffer used for AudioBufferProvider 226 size_t mUnconsumedFrames = 0; 227 mutable audio_utils::mutex mReadMutex{ 228 audio_utils::MutexOrder::kPassthruPatchRecord_ReadMutex}; 229 audio_utils::condition_variable mReadCV; 230 size_t mReadBytes = 0; // GUARDED_BY(readMutex()) 231 status_t mReadError = NO_ERROR; // GUARDED_BY(readMutex()) 232 int64_t mLastReadFrames = 0; // accessed on RecordThread only 233 }; 234 235 } // namespace android 236