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; startFrames()86 int32_t startFrames() const final { return mStartFrames; } 87 88 using SinkMetadatas = std::vector<record_track_metadata_v7_t>; 89 using MetadataInserter = std::back_insert_iterator<SinkMetadatas>; 90 void copyMetadataTo(MetadataInserter& backInserter) const final; 91 sinkBuffer()92 AudioBufferProvider::Buffer& sinkBuffer() final { return mSink; } synchronizedRecordState()93 audioflinger::SynchronizedRecordState& synchronizedRecordState() final { 94 return mSynchronizedRecordState; 95 } recordBufferConverter()96 RecordBufferConverter* recordBufferConverter() const final { return mRecordBufferConverter; } resamplerBufferProvider()97 ResamplerBufferProvider* resamplerBufferProvider() const final { 98 return mResamplerBufferProvider; 99 } 100 trackFlagsAsString()101 std::string trackFlagsAsString() const final { return toString(mFlags); } 102 103 private: 104 DISALLOW_COPY_AND_ASSIGN(RecordTrack); 105 106 protected: 107 // AudioBufferProvider interface 108 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; 109 // releaseBuffer() not overridden 110 111 private: 112 113 bool mOverflow; // overflow on most recent attempt to fill client buffer 114 115 AudioBufferProvider::Buffer mSink; // references client's buffer sink in shared memory 116 117 // sync event triggering actual audio capture. Frames read before this event will 118 // be dropped and therefore not read by the application. 119 sp<audioflinger::SyncEvent> mSyncStartEvent; 120 121 audioflinger::SynchronizedRecordState 122 mSynchronizedRecordState{mSampleRate}; // sampleRate defined in base 123 124 // used by resampler to find source frames 125 ResamplerBufferProvider* mResamplerBufferProvider; 126 127 // used by the record thread to convert frames to proper destination format 128 RecordBufferConverter *mRecordBufferConverter; 129 audio_input_flags_t mFlags; 130 131 bool mSilenced; 132 133 std::string mSharedAudioPackageName = {}; 134 int32_t mStartFrames = -1; 135 }; 136 137 // playback track, used by PatchPanel 138 class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord { 139 public: 140 PatchRecord(IAfRecordThread* recordThread, 141 uint32_t sampleRate, 142 audio_channel_mask_t channelMask, 143 audio_format_t format, 144 size_t frameCount, 145 void *buffer, 146 size_t bufferSize, 147 audio_input_flags_t flags, 148 const Timeout& timeout = {}, 149 audio_source_t source = AUDIO_SOURCE_DEFAULT); 150 ~PatchRecord() override; 151 getSource()152 Source* getSource() override { return nullptr; } 153 154 // AudioBufferProvider interface 155 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override; 156 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override; 157 158 // PatchProxyBufferProvider interface 159 status_t obtainBuffer(Proxy::Buffer* buffer, 160 const struct timespec* timeOut = nullptr) override; 161 void releaseBuffer(Proxy::Buffer* buffer) override; 162 writeFrames(const void * src,size_t frameCount,size_t frameSize)163 size_t writeFrames(const void* src, size_t frameCount, size_t frameSize) final { 164 return writeFrames(this, src, frameCount, frameSize); 165 } 166 167 protected: 168 /** Write the source data into the buffer provider. @return written frame count. */ 169 static size_t writeFrames(AudioBufferProvider* dest, const void* src, 170 size_t frameCount, size_t frameSize); 171 172 }; // end of PatchRecord 173 174 class PassthruPatchRecord : public PatchRecord, public Source { 175 public: 176 PassthruPatchRecord(IAfRecordThread* recordThread, 177 uint32_t sampleRate, 178 audio_channel_mask_t channelMask, 179 audio_format_t format, 180 size_t frameCount, 181 audio_input_flags_t flags, 182 audio_source_t source = AUDIO_SOURCE_DEFAULT); 183 getSource()184 Source* getSource() final { return static_cast<Source*>(this); } 185 186 // Source interface 187 status_t read(void* buffer, size_t bytes, size_t* read) final; 188 status_t getCapturePosition(int64_t* frames, int64_t* time) final; 189 status_t standby() final; 190 191 // AudioBufferProvider interface 192 // This interface is used by RecordThread to pass the data obtained 193 // from HAL or other source to the client. PassthruPatchRecord receives 194 // the data in 'obtainBuffer' so these calls are stubbed out. 195 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) final; 196 void releaseBuffer(AudioBufferProvider::Buffer* buffer) final; 197 198 // PatchProxyBufferProvider interface 199 // This interface is used from DirectOutputThread to acquire data from HAL. producesBufferOnDemand()200 bool producesBufferOnDemand() const final { return true; } 201 status_t obtainBuffer(Proxy::Buffer* buffer, const struct timespec* timeOut = nullptr) final; 202 void releaseBuffer(Proxy::Buffer* buffer) final; 203 204 private: 205 // This is to use with PatchRecord::writeFrames 206 struct PatchRecordAudioBufferProvider : public AudioBufferProvider { PatchRecordAudioBufferProviderPatchRecordAudioBufferProvider207 explicit PatchRecordAudioBufferProvider(PassthruPatchRecord& passthru) : 208 mPassthru(passthru) {} getNextBufferPatchRecordAudioBufferProvider209 status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) override { 210 return mPassthru.PatchRecord::getNextBuffer(buffer); 211 } releaseBufferPatchRecordAudioBufferProvider212 void releaseBuffer(AudioBufferProvider::Buffer* buffer) override { 213 return mPassthru.PatchRecord::releaseBuffer(buffer); 214 } 215 private: 216 PassthruPatchRecord& mPassthru; 217 }; 218 219 sp<StreamInHalInterface> obtainStream(sp<IAfThreadBase>* thread); readMutex()220 audio_utils::mutex& readMutex() const { return mReadMutex; } 221 222 PatchRecordAudioBufferProvider mPatchRecordAudioBufferProvider; 223 std::unique_ptr<void, decltype(free)*> mSinkBuffer; // frame size aligned continuous buffer 224 std::unique_ptr<void, decltype(free)*> mStubBuffer; // buffer used for AudioBufferProvider 225 size_t mUnconsumedFrames = 0; 226 mutable audio_utils::mutex mReadMutex{ 227 audio_utils::MutexOrder::kPassthruPatchRecord_ReadMutex}; 228 audio_utils::condition_variable mReadCV; 229 size_t mReadBytes = 0; // GUARDED_BY(readMutex()) 230 status_t mReadError = NO_ERROR; // GUARDED_BY(readMutex()) 231 int64_t mLastReadFrames = 0; // accessed on RecordThread only 232 }; 233 234 } // namespace android 235