• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 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 #ifndef AUDIO_SINK_SV_IMPL_H
17 #define AUDIO_SINK_SV_IMPL_H
18 
19 #include "audio_sink.h"
20 #include "audio_renderer.h"
21 #include "audio_system_manager.h"
22 #include "audio_errors.h"
23 #include "task_queue.h"
24 
25 namespace OHOS {
26 namespace Media {
27 class AudioRendererMediaCallback : public AudioStandard::AudioRendererCallback {
28 public:
29     using InterruptCbFunc = std::function<void(GstBaseSink *, guint, guint, guint)>;
30     using StateCbFunc = std::function<void(GstBaseSink *, guint)>;
31     explicit AudioRendererMediaCallback(GstBaseSink *audioSink);
32     ~AudioRendererMediaCallback();
33     void SaveInterruptCallback(InterruptCbFunc interruptCb);
34     void SaveStateCallback(StateCbFunc stateCb);
35     void OnInterrupt(const AudioStandard::InterruptEvent &interruptEvent) override;
36     void OnStateChange(const AudioStandard::RendererState state,
37         const AudioStandard::StateChangeCmdType cmdType) override;
38 private:
39     GstBaseSink *audioSink_ = nullptr;
40     InterruptCbFunc interruptCb_ = nullptr;
41     StateCbFunc stateCb_ = nullptr;
42     TaskQueue taskQue_;
43 };
44 
45 class AudioServiceDiedCallback : public AudioStandard::AudioRendererPolicyServiceDiedCallback {
46 public:
47     explicit AudioServiceDiedCallback(GstBaseSink *audioSink);
48     using AudioDiedCbFunc = std::function<void(GstBaseSink *)>;
49     void SaveAudioPolicyServiceDiedCb(AudioDiedCbFunc diedCb);
50     void OnAudioPolicyServiceDied() override;
51 private:
52     AudioDiedCbFunc diedCb_ = nullptr;
53     GstBaseSink *audioSink_ = nullptr;
54 };
55 
56 class AudioSinkSvImpl : public AudioSink {
57 public:
58     explicit AudioSinkSvImpl(GstBaseSink *audioSink);
59     virtual ~AudioSinkSvImpl();
60 
61     GstCaps *GetCaps() override;
62     int32_t SetVolume(float volume) override;
63     int32_t GetVolume(float &volume) override;
64     int32_t GetMaxVolume(float &volume) override;
65     int32_t GetMinVolume(float &volume) override;
66     int32_t Prepare(int32_t appUid, int32_t appPid, uint32_t appTokenId) override;
67     int32_t Start() override;
68     int32_t Stop() override;
69     int32_t Pause() override;
70     int32_t Drain() override;
71     int32_t Flush() override;
72     int32_t Release() override;
73     int32_t SetParameters(uint32_t bitsPerSample, uint32_t channels, uint32_t sampleRate) override;
74     int32_t GetParameters(uint32_t &bitsPerSample, uint32_t &channels, uint32_t &sampleRate) override;
75     int32_t GetMinimumBufferSize(uint32_t &bufferSize) override;
76     int32_t GetMinimumFrameCount(uint32_t &frameCount) override;
77     int32_t Write(uint8_t *buffer, size_t size) override;
78     int32_t GetAudioTime(uint64_t &time) override;
79     int32_t GetLatency(uint64_t &latency) const override;
80     int32_t SetRendererInfo(int32_t desc, int32_t rendererFlags) override;
81     void SetAudioInterruptMode(int32_t interruptMode) override;
82     void SetAudioSinkCb(void (*interruptCb)(GstBaseSink *, guint, guint, guint),
83                         void (*stateCb)(GstBaseSink *, guint),
84                         void (*errorCb)(GstBaseSink *, const std::string &),
85                         void (*audioDiedCb)(GstBaseSink *)) override;
86     int32_t SetAudioEffectMode(int32_t effectMode) override;
87     int32_t GetAudioEffectMode(int32_t &effectMode) override;
88     bool Writeable() const override;
89 
90 private:
91     void OnError(std::string errMsg);
92     using ErrorCbFunc = std::function<void(GstBaseSink *, const std::string &)>;
93     ErrorCbFunc errorCb_ = nullptr;
94     GstBaseSink *audioSink_ = nullptr;
95     std::unique_ptr<OHOS::AudioStandard::AudioRenderer> audioRenderer_ = nullptr;
96     AudioStandard::AudioRendererOptions rendererOptions_ = {};
97     void InitChannelRange(GstCaps *caps) const;
98     void InitRateRange(GstCaps *caps) const;
99     void SetMuteVolumeBySysParam();
100     void SetAudioDumpBySysParam();
101     bool DisableAudioEffectBySysParam() const;
102     void DumpAudioBuffer(uint8_t *buffer, const size_t &bytesWritten, const size_t &bytesSingle);
103     bool isMute_ = false;
104     bool enableDump_ = false;
105     FILE *dumpFile_ = nullptr;
106     std::shared_ptr<AudioRendererMediaCallback> audioRendererMediaCallback_ = nullptr;
107     std::shared_ptr<AudioServiceDiedCallback> audioServiceDiedCallback_ = nullptr;
108 };
109 
110 class AudioSinkBypass : public AudioSinkSvImpl {
111 public:
AudioSinkBypass(GstBaseSink * audioSink)112     explicit AudioSinkBypass(GstBaseSink *audioSink) : AudioSinkSvImpl(audioSink) {}
113     virtual ~AudioSinkBypass() = default;
114 
SetVolume(float volume)115     int32_t SetVolume(float volume) override
116     {
117         (void)volume;
118         return MSERR_OK;
119     }
GetVolume(float & volume)120     int32_t GetVolume(float &volume) override
121     {
122         volume = 1.0; // default volume 1.0
123         return MSERR_OK;
124     }
GetMaxVolume(float & volume)125     int32_t GetMaxVolume(float &volume) override
126     {
127         volume = 1.0; // default max volume 1.0
128         return MSERR_OK;
129     }
GetMinVolume(float & volume)130     int32_t GetMinVolume(float &volume) override
131     {
132         volume = 0.0; // default min volume 0.0
133         return MSERR_OK;
134     }
Prepare(int32_t appUid,int32_t appPid,uint32_t appTokenId)135     int32_t Prepare(int32_t appUid, int32_t appPid, uint32_t appTokenId) override
136     {
137         (void)appUid;
138         (void)appPid;
139         (void)appTokenId;
140         return MSERR_OK;
141     }
Start()142     int32_t Start() override
143     {
144         return MSERR_OK;
145     }
Stop()146     int32_t Stop() override
147     {
148         return MSERR_OK;
149     }
Pause()150     int32_t Pause() override
151     {
152         return MSERR_OK;
153     }
Drain()154     int32_t Drain() override
155     {
156         return MSERR_OK;
157     }
Flush()158     int32_t Flush() override
159     {
160         return MSERR_OK;
161     }
Release()162     int32_t Release() override
163     {
164         return MSERR_OK;
165     }
SetParameters(uint32_t bitsPerSample,uint32_t channels,uint32_t sampleRate)166     int32_t SetParameters(uint32_t bitsPerSample, uint32_t channels, uint32_t sampleRate) override
167     {
168         (void)bitsPerSample;
169         (void)channels;
170         (void)sampleRate;
171         return MSERR_OK;
172     }
GetParameters(uint32_t & bitsPerSample,uint32_t & channels,uint32_t & sampleRate)173     int32_t GetParameters(uint32_t &bitsPerSample, uint32_t &channels, uint32_t &sampleRate) override
174     {
175         bitsPerSample = 16; // default bitsPerSample is 16
176         channels = 2; // default channels is 2
177         sampleRate = 44100; // default sampleRate is 44100
178         return MSERR_OK;
179     }
GetMinimumBufferSize(uint32_t & bufferSize)180     int32_t GetMinimumBufferSize(uint32_t &bufferSize) override
181     {
182         bufferSize = 3528; // default size is 3528
183         return MSERR_OK;
184     }
GetMinimumFrameCount(uint32_t & frameCount)185     int32_t GetMinimumFrameCount(uint32_t &frameCount) override
186     {
187         frameCount = 882; // default count is 882
188         return MSERR_OK;
189     }
Write(uint8_t * buffer,size_t size)190     int32_t Write(uint8_t *buffer, size_t size) override
191     {
192         (void)buffer;
193         (void)size;
194         return MSERR_OK;
195     }
GetAudioTime(uint64_t & time)196     int32_t GetAudioTime(uint64_t &time) override
197     {
198         (void)time;
199         return MSERR_OK;
200     }
GetLatency(uint64_t & latency)201     int32_t GetLatency(uint64_t &latency) const override
202     {
203         latency = 0;
204         return MSERR_OK;
205     }
SetRendererInfo(int32_t desc,int32_t rendererFlags)206     int32_t SetRendererInfo(int32_t desc, int32_t rendererFlags) override
207     {
208         (void)desc;
209         (void)rendererFlags;
210         return MSERR_OK;
211     }
SetAudioInterruptMode(int32_t interruptMode)212     void SetAudioInterruptMode(int32_t interruptMode) override
213     {
214         (void)interruptMode;
215     }
SetAudioSinkCb(void (* interruptCb)(GstBaseSink *,guint,guint,guint),void (* stateCb)(GstBaseSink *,guint),void (* errorCb)(GstBaseSink *,const std::string &),void (* audioDiedCb)(GstBaseSink *))216     void SetAudioSinkCb(void (*interruptCb)(GstBaseSink *, guint, guint, guint),
217                         void (*stateCb)(GstBaseSink *, guint),
218                         void (*errorCb)(GstBaseSink *, const std::string &),
219                         void (*audioDiedCb)(GstBaseSink *)) override
220     {
221         (void)interruptCb;
222         (void)stateCb;
223         (void)errorCb;
224         (void)audioDiedCb;
225     }
Writeable()226     bool Writeable() const override
227     {
228         return true;
229     }
230 };
231 } // namespace Media
232 } // namespace OHOS
233 #endif // AUDIO_SINK_SV_IMPL_H
234