1 /*
2  * Copyright (c) 2021-2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifdef RECORDER_SUPPORT
17 
18 #define HST_LOG_TAG "AudioCaptureFilter"
19 
20 #include "pipeline/filters/source/audio_capture/audio_capture_filter.h"
21 #include "foundation/cpp_ext/algorithm_ext.h"
22 #include "foundation/log.h"
23 #include "pipeline/factory/filter_factory.h"
24 #include "pipeline/filters/common/buffer_calibration/audio_buffer_calibration.h"
25 #include "pipeline/filters/common/plugin_utils.h"
26 #include "plugin/common/plugin_attr_desc.h"
27 
28 namespace OHOS {
29 namespace Media {
30 namespace Pipeline {
31 using namespace Plugin;
32 
33 static AutoRegisterFilter<AudioCaptureFilter> g_registerFilterHelper("builtin.recorder.audiocapture");
34 
AudioCaptureFilter(const std::string & name)35 AudioCaptureFilter::AudioCaptureFilter(const std::string& name)
36     : FilterBase(name),
37       taskPtr_(nullptr),
38       plugin_(nullptr),
39       pluginAllocator_(nullptr),
40       pluginInfo_(nullptr),
41       bufferCalibration_(new AudioBufferCalibration)
42 {
43     filterType_ = FilterType::CAPTURE_SOURCE;
44     MEDIA_LOG_D("ctor called");
45 }
46 
~AudioCaptureFilter()47 AudioCaptureFilter::~AudioCaptureFilter()
48 {
49     MEDIA_LOG_D("dtor called");
50     if (taskPtr_) {
51         taskPtr_->Stop();
52     }
53     if (plugin_) {
54         plugin_->Deinit();
55     }
56 }
57 
GetWorkModes()58 std::vector<WorkMode> AudioCaptureFilter::GetWorkModes()
59 {
60     return {WorkMode::PUSH};
61 }
62 
SetAppInfoParams()63 void AudioCaptureFilter::SetAppInfoParams()
64 {
65     if (appTokenIdSpecified_) {
66         NOK_LOG(plugin_->SetParameter(Tag::APP_TOKEN_ID, appTokenId_));
67     }
68     if (appFullTokenIdSpecified_) {
69         NOK_LOG(plugin_->SetParameter(Tag::APP_FULL_TOKEN_ID, appFullTokenId_));
70     }
71     if (appUidSpecified_) {
72         NOK_LOG(plugin_->SetParameter(Tag::APP_UID, appUid_));
73     }
74     if (appPidSpecified_) {
75         NOK_LOG(plugin_->SetParameter(Tag::APP_PID, appPid_));
76     }
77 }
78 
ConfigureAudioSampleRate(const std::shared_ptr<Plugin::Meta> & audioMeta)79 ErrorCode AudioCaptureFilter::ConfigureAudioSampleRate(const std::shared_ptr<Plugin::Meta>& audioMeta)
80 {
81     uint32_t sampleRate = 0;
82     ErrorCode errorCode = ErrorCode::SUCCESS;
83     if (audioMeta->Get<Tag::AUDIO_SAMPLE_RATE>(sampleRate)) {
84         MEDIA_LOG_I("configure plugin with sample rate " PUBLIC_LOG_U32, sampleRate);
85         bufferCalibration_->SetParam(Tag::AUDIO_SAMPLE_RATE, sampleRate);
86         errorCode = TranslatePluginStatus(plugin_->SetParameter(Tag::AUDIO_SAMPLE_RATE, sampleRate));
87     }
88     return errorCode;
89 }
90 
ConfigureAudioChannels(const std::shared_ptr<Plugin::Meta> & audioMeta)91 ErrorCode AudioCaptureFilter::ConfigureAudioChannels(const std::shared_ptr<Plugin::Meta> &audioMeta)
92 {
93     uint32_t channels = 0;
94     ErrorCode errorCode = ErrorCode::SUCCESS;
95     if (audioMeta->Get<Tag::AUDIO_CHANNELS>(channels)) {
96         MEDIA_LOG_I("configure plugin with channel " PUBLIC_LOG_U32, channels);
97         bufferCalibration_->SetParam(Tag::AUDIO_CHANNELS, channels);
98         errorCode = TranslatePluginStatus(plugin_->SetParameter(Tag::AUDIO_CHANNELS, channelNum_));
99     }
100     return errorCode;
101 }
102 
ConfigureAudioBitRate(const std::shared_ptr<Plugin::Meta> & audioMeta)103 ErrorCode AudioCaptureFilter::ConfigureAudioBitRate(const std::shared_ptr<Plugin::Meta> &audioMeta)
104 {
105     int64_t bitRate = 0;
106     ErrorCode errorCode = ErrorCode::SUCCESS;
107     if (audioMeta->Get<Tag::MEDIA_BITRATE>(bitRate)) {
108         MEDIA_LOG_I("configure plugin with bitrate " PUBLIC_LOG_D64, bitRate);
109         errorCode = TranslatePluginStatus(plugin_->SetParameter(Tag::MEDIA_BITRATE, bitRate));
110     }
111     return errorCode;
112 }
113 
ConfigureSampleFormat(const std::shared_ptr<Plugin::Meta> & audioMeta)114 ErrorCode AudioCaptureFilter::ConfigureSampleFormat(const std::shared_ptr<Plugin::Meta> &audioMeta)
115 {
116     Plugin::AudioSampleFormat sampleFormat = Plugin::AudioSampleFormat::S16;
117     ErrorCode errorCode = ErrorCode::SUCCESS;
118     if (audioMeta->Get<Tag::AUDIO_SAMPLE_FORMAT>(sampleFormat)) {
119         bufferCalibration_->SetParam(Tag::AUDIO_SAMPLE_FORMAT, sampleFormat);
120         MEDIA_LOG_I("configure plugin with sampleFormat " PUBLIC_LOG_S, Plugin::GetAudSampleFmtNameStr(sampleFormat));
121         errorCode = TranslatePluginStatus(plugin_->SetParameter(Tag::AUDIO_SAMPLE_FORMAT, sampleFormat));
122     }
123     return errorCode;
124 }
125 
InitAndConfigWithMeta(const std::shared_ptr<Plugin::Meta> & audioMeta)126 ErrorCode AudioCaptureFilter::InitAndConfigWithMeta(const std::shared_ptr<Plugin::Meta>& audioMeta)
127 {
128     MEDIA_LOG_D("IN");
129     SetAppInfoParams();
130     ErrorCode err = TranslatePluginStatus(plugin_->Init());
131     FALSE_RETURN_V(err == ErrorCode::SUCCESS, err);
132     plugin_->SetCallback(this);
133     pluginAllocator_ = plugin_->GetAllocator();
134 
135     err = ConfigureAudioSampleRate(audioMeta);
136     FALSE_RETURN_V(err == ErrorCode::SUCCESS, err);
137 
138     err = ConfigureAudioChannels(audioMeta);
139     FALSE_RETURN_V(err == ErrorCode::SUCCESS, err);
140 
141     err = ConfigureAudioBitRate(audioMeta);
142     FALSE_RETURN_V(err == ErrorCode::SUCCESS, err);
143 
144     err = ConfigureSampleFormat(audioMeta);
145     FALSE_RETURN_V(err == ErrorCode::SUCCESS, err);
146 
147     return ErrorCode::SUCCESS;
148 }
149 
SetParameter(int32_t key,const Plugin::Any & value)150 ErrorCode AudioCaptureFilter::SetParameter(int32_t key, const Plugin::Any& value)
151 {
152     auto tag = static_cast<OHOS::Media::Plugin::Tag>(key);
153     switch (tag) {
154         case Tag::SRC_INPUT_TYPE:
155             inputTypeSpecified_ = AssignParameterIfMatch(tag, inputType_, value);
156             break;
157         case Tag::AUDIO_SAMPLE_RATE:
158             sampleRateSpecified_ = AssignParameterIfMatch(tag, sampleRate_, value);
159             break;
160         case Tag::AUDIO_CHANNELS:
161             channelNumSpecified_ = AssignParameterIfMatch(tag, channelNum_, value);
162             break;
163         case Tag::MEDIA_BITRATE:
164             bitRateSpecified_ = AssignParameterIfMatch(tag, bitRate_, value);
165             break;
166         case Tag::AUDIO_SAMPLE_FORMAT:
167             sampleFormatSpecified_ = AssignParameterIfMatch(tag, sampleFormat_, value);
168             break;
169         case Tag::AUDIO_CHANNEL_LAYOUT:
170             channelLayoutSpecified_ = AssignParameterIfMatch(tag, channelLayout_, value);
171             break;
172         case Tag::APP_TOKEN_ID:
173             appTokenIdSpecified_ = AssignParameterIfMatch(tag, appTokenId_, value);
174             break;
175         case Tag::APP_FULL_TOKEN_ID:
176             appFullTokenIdSpecified_ = AssignParameterIfMatch(tag, appFullTokenId_, value);
177             break;
178         case Tag::APP_UID:
179             appUidSpecified_ = AssignParameterIfMatch(tag, appUid_, value);
180             break;
181         case Tag::APP_PID:
182             appPidSpecified_ = AssignParameterIfMatch(tag, appPid_, value);
183             break;
184         default:
185             MEDIA_LOG_W("SetParameter: unknown key " PUBLIC_LOG_S "(" PUBLIC_LOG_D32 ")", GetTagStrName(tag), key);
186             break;
187     }
188     return ErrorCode::SUCCESS;
189 }
190 
GetParameter(int32_t key,Plugin::Any & value)191 ErrorCode AudioCaptureFilter::GetParameter(int32_t key, Plugin::Any& value)
192 {
193     Tag tag = static_cast<Plugin::Tag>(key);
194     switch (tag) {
195         case Tag::SRC_INPUT_TYPE: {
196             value = inputType_;
197             break;
198         }
199         case Tag::AUDIO_SAMPLE_RATE: {
200             value = sampleRate_;
201             break;
202         }
203         case Tag::AUDIO_CHANNELS: {
204             value = channelNum_;
205             break;
206         }
207         case Tag::MEDIA_BITRATE: {
208             value = bitRate_;
209             break;
210         }
211         case Tag::AUDIO_SAMPLE_FORMAT: {
212             value = sampleFormat_;
213             break;
214         }
215         default:
216             MEDIA_LOG_W("Unknown key " PUBLIC_LOG_S, GetTagStrName(tag));
217             break;
218     }
219     return ErrorCode::SUCCESS;
220 }
221 
PickPreferSampleFmt(const std::shared_ptr<Plugin::Meta> & meta,const Plugin::ValueType & val)222 void AudioCaptureFilter::PickPreferSampleFmt(const std::shared_ptr<Plugin::Meta>& meta, const Plugin::ValueType& val)
223 {
224     static constexpr AudioSampleFormat preferFmt = AudioSampleFormat::S16;
225     bool pickPreferFmt = false;
226     if (Any::IsSameTypeWith<FixedCapability<AudioSampleFormat>>(val) &&
227         preferFmt == Plugin::AnyCast<FixedCapability<AudioSampleFormat>>(val)) {
228         pickPreferFmt = true;
229     } else if (Any::IsSameTypeWith<FixedCapability<DiscreteCapability<AudioSampleFormat>>>(val)) {
230         const auto* fmts = Plugin::AnyCast<DiscreteCapability<AudioSampleFormat>>(&val);
231         pickPreferFmt = CppExt::AnyOf(fmts->begin(), fmts->end(), [&](AudioSampleFormat tmp) -> bool {
232             return preferFmt == tmp;
233         });
234     }
235     if (pickPreferFmt) {
236         FALSE_LOG(meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(preferFmt));
237     }
238 }
239 
PickPreferParameters()240 std::shared_ptr<Plugin::Meta> AudioCaptureFilter::PickPreferParameters()
241 {
242     auto preferMeta = std::make_shared<Plugin::Meta>();
243     if (capNegWithDownstream_.keys.count(Capability::Key::AUDIO_SAMPLE_FORMAT)) {
244         PickPreferSampleFmt(preferMeta, capNegWithDownstream_.keys.at(Capability::Key::AUDIO_SAMPLE_FORMAT));
245     }
246     return preferMeta;
247 }
248 
DoConfigure()249 ErrorCode AudioCaptureFilter::DoConfigure()
250 {
251     auto preferMeta = PickPreferParameters();
252     auto audioMeta = std::make_shared<Plugin::Meta>();
253     if (!MergeMetaWithCapability(*preferMeta, capNegWithDownstream_, *audioMeta)) {
254         MEDIA_LOG_E("cannot find available capability of plugin " PUBLIC_LOG_S, pluginInfo_->name.c_str());
255         return ErrorCode::ERROR_UNKNOWN;
256     }
257     Plugin::Meta upstreamParams;
258     Plugin::Meta downstreamParams;
259     if (!outPorts_[0]->Configure(audioMeta, upstreamParams, downstreamParams)) {
260         MEDIA_LOG_E("Configure downstream fail with " PUBLIC_LOG_S, Meta2String(*audioMeta).c_str());
261         return ErrorCode::ERROR_UNKNOWN;
262     }
263     return InitAndConfigWithMeta(audioMeta);
264 }
265 
Prepare()266 ErrorCode AudioCaptureFilter::Prepare()
267 {
268     MEDIA_LOG_I("Prepare entered.");
269     if (!taskPtr_) {
270         taskPtr_ = std::make_shared<OSAL::Task>("DataReader");
271         taskPtr_->RegisterHandler([this] { ReadLoop(); });
272     }
273     ErrorCode err = FindPlugin();
274     if (err != ErrorCode::SUCCESS || !plugin_) {
275         MEDIA_LOG_E("Find plugin fail");
276         return err;
277     }
278     err = DoConfigure();
279     if (err != ErrorCode::SUCCESS) {
280         MEDIA_LOG_E("DoConfigure fail");
281         return err;
282     }
283     err = TranslatePluginStatus(plugin_->Prepare());
284     if (err == ErrorCode::SUCCESS) {
285         MEDIA_LOG_D("media source send EVENT_READY");
286         OnEvent(Event{name_, EventType::EVENT_READY, {}});
287     }
288     return err;
289 }
290 
Start()291 ErrorCode AudioCaptureFilter::Start()
292 {
293     MEDIA_LOG_I("Start entered.");
294     eos_ = false;
295     auto res = ErrorCode::SUCCESS;
296     bufferCalibration_->Enable();
297     // start plugin firstly
298     if (plugin_) {
299         res = TranslatePluginStatus(plugin_->Start());
300     } else {
301         res = ErrorCode::ERROR_INVALID_OPERATION;
302     }
303     FALSE_RETURN_V_MSG_E(res == ErrorCode::SUCCESS, res, "start plugin failed");
304     // start task secondly
305     if (taskPtr_) {
306         taskPtr_->Start();
307     }
308     return res;
309 }
310 
Stop()311 ErrorCode AudioCaptureFilter::Stop()
312 {
313     MEDIA_LOG_I("Stop entered.");
314     FilterBase::Stop();
315     // stop task firstly
316     if (taskPtr_) {
317         taskPtr_->Stop();
318     }
319     bufferCalibration_->Reset();
320     latestBufferTime_ = HST_TIME_NONE;
321     latestPausedTime_ = HST_TIME_NONE;
322     totalPausedTime_ = 0;
323     refreshTotalPauseTime_ = false;
324     // stop plugin secondly
325     ErrorCode ret = ErrorCode::SUCCESS;
326     if (plugin_) {
327         ret = TranslatePluginStatus(plugin_->Stop());
328     }
329     return ret;
330 }
331 
Pause()332 ErrorCode AudioCaptureFilter::Pause()
333 {
334     MEDIA_LOG_I("Pause entered.");
335     FilterBase::Pause();
336     if (taskPtr_) {
337         taskPtr_->Pause();
338     }
339     latestPausedTime_ = latestBufferTime_;
340     ErrorCode ret = ErrorCode::SUCCESS;
341     if (plugin_) {
342         ret = TranslatePluginStatus(plugin_->Stop());
343     }
344     return ret;
345 }
346 
Resume()347 ErrorCode AudioCaptureFilter::Resume()
348 {
349     MEDIA_LOG_I("Resume entered.");
350     if (state_ == FilterState::PAUSED) {
351         refreshTotalPauseTime_ = true;
352     }
353     state_ = FilterState::RUNNING;
354     if (taskPtr_) {
355         taskPtr_->Start();
356     }
357     return plugin_ ? TranslatePluginStatus(plugin_->Start()) : ErrorCode::ERROR_INVALID_OPERATION;
358 }
359 
SendEos()360 ErrorCode AudioCaptureFilter::SendEos()
361 {
362     MEDIA_LOG_I("SendEos entered.");
363     auto buf = std::make_shared<AVBuffer>();
364     buf->flag |= BUFFER_FLAG_EOS;
365     SendBuffer(buf);
366     eos_ = true;
367     return ErrorCode::SUCCESS;
368 }
369 
InitPorts()370 void AudioCaptureFilter::InitPorts()
371 {
372     MEDIA_LOG_D("IN");
373     auto outPort = std::make_shared<OutPort>(this);
374     outPorts_.push_back(outPort);
375 }
376 
ReadLoop()377 void AudioCaptureFilter::ReadLoop()
378 {
379     if (eos_.load()) {
380         return;
381     }
382     uint64_t bufferSize = 0;
383     auto ret = plugin_->GetSize(bufferSize);
384     if (ret != Status::OK || bufferSize == 0) {
385         MEDIA_LOG_E("Get plugin buffer size fail");
386         return;
387     }
388     AVBufferPtr bufferPtr = std::make_shared<AVBuffer>(BufferMetaType::AUDIO);
389     ret = plugin_->Read(bufferPtr, bufferSize);
390     if (ret == Status::ERROR_AGAIN) {
391         MEDIA_LOG_D("plugin read return again");
392         return;
393     }
394     if (ret != Status::OK) {
395         SendEos();
396         return;
397     }
398     latestBufferTime_ = bufferPtr->pts;
399     if (refreshTotalPauseTime_) {
400         if (latestPausedTime_ != HST_TIME_NONE && latestBufferTime_ > latestPausedTime_) {
401             totalPausedTime_ += latestBufferTime_ - latestPausedTime_;
402         }
403         refreshTotalPauseTime_ = false;
404     }
405     bufferPtr->pts -= totalPausedTime_;
406     SendBuffer(bufferPtr);
407 }
408 
CreatePlugin(const std::shared_ptr<PluginInfo> & info,const std::string & name,PluginManager & manager)409 ErrorCode AudioCaptureFilter::CreatePlugin(const std::shared_ptr<PluginInfo>& info, const std::string& name,
410                                            PluginManager& manager)
411 {
412     if ((plugin_ != nullptr) && (pluginInfo_ != nullptr)) {
413         if (info->name == pluginInfo_->name && TranslatePluginStatus(plugin_->Reset()) == ErrorCode::SUCCESS) {
414             MEDIA_LOG_I("Reuse last plugin: " PUBLIC_LOG_S, name.c_str());
415             return ErrorCode::SUCCESS;
416         }
417         if (TranslatePluginStatus(plugin_->Deinit()) != ErrorCode::SUCCESS) {
418             MEDIA_LOG_E("Deinit last plugin: " PUBLIC_LOG_S " error", pluginInfo_->name.c_str());
419         }
420     }
421     plugin_ = manager.CreateSourcePlugin(name);
422     if (plugin_ == nullptr) {
423         MEDIA_LOG_E("PluginManager CreatePlugin " PUBLIC_LOG_S " fail", name.c_str());
424         return ErrorCode::ERROR_UNKNOWN;
425     }
426     pluginInfo_ = info;
427     MEDIA_LOG_I("Create new plugin: " PUBLIC_LOG_S " success", pluginInfo_->name.c_str());
428     return ErrorCode::SUCCESS;
429 }
430 
CheckSampleRate(const Plugin::Capability & cap)431 bool AudioCaptureFilter::CheckSampleRate(const Plugin::Capability& cap)
432 {
433     if (!sampleRateSpecified_) {
434         return true;
435     }
436     for (const auto& pairKey : cap.keys) {
437         if (pairKey.first != Capability::Key::AUDIO_SAMPLE_RATE ||
438             !Plugin::Any::IsSameTypeWith<DiscreteCapability<uint32_t>>(pairKey.second)) {
439             continue;
440         }
441         auto supportedSampleRateList = Plugin::AnyCast<DiscreteCapability<uint32_t>>(pairKey.second);
442         for (const auto& rate : supportedSampleRateList) {
443             if (rate == sampleRate_) {
444                 return true;
445             }
446         }
447     }
448     return false;
449 }
450 
CheckChannels(const Plugin::Capability & cap)451 bool AudioCaptureFilter::CheckChannels(const Plugin::Capability& cap)
452 {
453     if (!channelNumSpecified_) {
454         return true;
455     }
456     for (const auto& pairKey : cap.keys) {
457         if (pairKey.first != Capability::Key::AUDIO_CHANNELS ||
458             !Plugin::Any::IsSameTypeWith<DiscreteCapability<uint32_t>>(pairKey.second)) {
459             continue;
460         }
461         auto supportedChannelsList = Plugin::AnyCast<DiscreteCapability<uint32_t>>(pairKey.second);
462         for (const auto& channel : supportedChannelsList) {
463             if (channel == channelNum_) {
464                 return true;
465             }
466         }
467     }
468     return false;
469 }
470 
CheckSampleFormat(const Plugin::Capability & cap)471 bool AudioCaptureFilter::CheckSampleFormat(const Plugin::Capability& cap)
472 {
473     if (!channelNumSpecified_) {
474         return true;
475     }
476     for (const auto& pairKey : cap.keys) {
477         if (pairKey.first != Capability::Key::AUDIO_SAMPLE_FORMAT ||
478             !Plugin::Any::IsSameTypeWith<DiscreteCapability<Plugin::AudioSampleFormat>>(pairKey.second)) {
479             continue;
480         }
481         auto supportedSampleFormatList =
482             Plugin::AnyCast<DiscreteCapability<Plugin::AudioSampleFormat>>(pairKey.second);
483         for (const auto& fmt : supportedSampleFormatList) {
484             if (fmt == sampleFormat_) {
485                 return true;
486             }
487         }
488     }
489     return false;
490 }
491 
DoNegotiate(const CapabilitySet & outCaps)492 bool AudioCaptureFilter::DoNegotiate(const CapabilitySet &outCaps)
493 {
494     if (outCaps.empty()) {
495         MEDIA_LOG_E("audio capture plugin must have out caps");
496         return false;
497     }
498     for (const auto& outCap : outCaps) {
499         if (!CheckSampleRate(outCap) || !CheckChannels(outCap) || !CheckSampleFormat(outCap)) {
500             continue;
501         }
502         auto thisOut = std::make_shared<Plugin::Capability>();
503         *thisOut = outCap;
504         if (sampleFormatSpecified_) {
505             thisOut->keys[Capability::Key::AUDIO_SAMPLE_FORMAT] = sampleFormat_;
506         }
507         if (sampleRateSpecified_) {
508             thisOut->keys[Capability::Key::AUDIO_SAMPLE_RATE] = sampleRate_;
509         }
510         if (channelNumSpecified_) {
511             thisOut->keys[Capability::Key::AUDIO_CHANNELS] = channelNum_;
512         }
513         if (channelNum_ == 1) {
514             thisOut->keys[Capability::Key::AUDIO_CHANNEL_LAYOUT] = AudioChannelLayout::MONO;
515         } else if (channelNum_ == 2) { // 2 stereo
516             thisOut->keys[Capability::Key::AUDIO_CHANNEL_LAYOUT] = AudioChannelLayout::STEREO;
517         } else if (channelLayoutSpecified_) {
518             thisOut->keys[Capability::Key::AUDIO_CHANNEL_LAYOUT] = channelLayout_;
519         } else {
520             MEDIA_LOG_W("audio channel layout is unknown");
521         }
522         if (bitRateSpecified_) {
523             thisOut->keys[Capability::Key::MEDIA_BITRATE] = bitRate_;
524         }
525         Plugin::Meta upstreamParams;
526         Plugin::Meta downstreamParams;
527         if (outPorts_[0]->Negotiate(thisOut, capNegWithDownstream_, upstreamParams, downstreamParams)) {
528             MEDIA_LOG_I("Negotiate success");
529             return true;
530         }
531     }
532     return false;
533 }
534 
FindPlugin()535 ErrorCode AudioCaptureFilter::FindPlugin()
536 {
537     if (!inputTypeSpecified_) {
538         MEDIA_LOG_E("Must set input type first");
539         return ErrorCode::ERROR_INVALID_OPERATION;
540     }
541     PluginManager& pluginManager = PluginManager::Instance();
542     auto nameList = pluginManager.ListPlugins(PluginType::SOURCE);
543     for (const std::string& name : nameList) {
544         std::shared_ptr<PluginInfo> info = pluginManager.GetPluginInfo(PluginType::SOURCE, name);
545         MEDIA_LOG_I("name: " PUBLIC_LOG_S ", info->name: " PUBLIC_LOG_S, name.c_str(), info->name.c_str());
546         auto val = info->extra[PLUGIN_INFO_EXTRA_INPUT_TYPE];
547         if (Plugin::Any::IsSameTypeWith<Plugin::SrcInputType>(val)) {
548             auto supportInputType = OHOS::Media::Plugin::AnyCast<Plugin::SrcInputType>(val);
549             if (inputType_ == supportInputType && DoNegotiate(info->outCaps) &&
550                 CreatePlugin(info, name, pluginManager) == ErrorCode::SUCCESS) {
551                 MEDIA_LOG_I("CreatePlugin " PUBLIC_LOG_S " success", name_.c_str());
552                 return ErrorCode::SUCCESS;
553             }
554         }
555     }
556     MEDIA_LOG_I("Cannot find any plugin");
557     return ErrorCode::ERROR_UNSUPPORTED_FORMAT;
558 }
559 
SendBuffer(const std::shared_ptr<AVBuffer> & buffer)560 void AudioCaptureFilter::SendBuffer(const std::shared_ptr<AVBuffer>& buffer)
561 {
562     OSAL::ScopedLock lock(pushDataMutex_);
563     if (!eos_) {
564         bufferCalibration_->CorrectBuffer(buffer);
565         outPorts_[0]->PushData(buffer, -1);
566     }
567 }
568 
569 } // namespace Pipeline
570 } // namespace Media
571 } // namespace OHOS
572 #endif // RECORDER_SUPPORT