1 /*
2  * Copyright (C) 2023 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 CODEC_AUDIO_CODEC_H
17 #define CODEC_AUDIO_CODEC_H
18 
19 #include "audio_base_codec.h"
20 #include "media_codec.h"
21 #include "avcodec_common.h"
22 #include "codecbase.h"
23 #include "nocopyable.h"
24 
25 namespace OHOS {
26 namespace MediaAVCodec {
27 class AudioCodec;
28 class AudioCodecCallback : public Media::AudioBaseCodecCallback {
29 public:
AudioCodecCallback(const std::shared_ptr<AudioCodec> &codec)30     AudioCodecCallback(const std::shared_ptr<AudioCodec> &codec) : codec_(codec) {}
~AudioCodecCallback()31     virtual ~AudioCodecCallback()
32     {
33         codec_ = nullptr;
34     }
35 
36     void OnError(Media::CodecErrorType errorType, int32_t errorCode) override;
37 
38     void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer) override;
39 
40 private:
41     std::shared_ptr<AudioCodec> codec_;
42 };
43 class AudioCodec : public std::enable_shared_from_this<AudioCodec>, public CodecBase {
44 public:
AudioCodec()45     explicit AudioCodec()
46     {
47         mediaCodec_ = std::make_shared<Media::MediaCodec>();
48     }
49     int32_t CreateCodecByName(const std::string &name) override
50     {
51         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Init(name)));
52     }
53 
54     int32_t Configure(const std::shared_ptr<Media::Meta> &meta) override
55     {
56         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Configure(meta)));
57     }
58     int32_t SetOutputBufferQueue(const sptr<Media::AVBufferQueueProducer> &bufferQueueProducer) override
59     {
60         return StatusToAVCodecServiceErrCode(
61             static_cast<Media::Status>(mediaCodec_->SetOutputBufferQueue(bufferQueueProducer)));
62     }
63 
SetCodecCallback(const std::shared_ptr<Media::CodecCallback> &codecCallback)64     int32_t SetCodecCallback(const std::shared_ptr<Media::CodecCallback> &codecCallback)
65     {
66         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetCodecCallback(codecCallback)));
67     }
68 
69     int32_t SetCallback(const std::shared_ptr<MediaCodecCallback> &codecCallback) override
70     {
71         callback_ = codecCallback;
72         std::shared_ptr<Media::AudioBaseCodecCallback> mediaCallback =
73             std::make_shared<AudioCodecCallback>(shared_from_this());
74         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetCodecCallback(mediaCallback)));
75     }
76 
77     int32_t Prepare() override
78     {
79         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Prepare()));
80     }
81 
82     sptr<Media::AVBufferQueueProducer> GetInputBufferQueue() override
83     {
84         return mediaCodec_->GetInputBufferQueue();
85     }
86 
87     int32_t Start() override
88     {
89         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Start()));
90     }
91 
92     int32_t Stop() override
93     {
94         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Stop()));
95     }
96 
97     int32_t Flush() override
98     {
99         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Flush()));
100     }
101 
102     int32_t Reset() override
103     {
104         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Reset()));
105     }
106 
107     int32_t Release() override
108     {
109         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Release()));
110     }
111 
112     int32_t NotifyEos() override
113     {
114         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->NotifyEos()));
115     }
116 
117     int32_t SetParameter(const std::shared_ptr<Media::Meta> &parameter) override
118     {
119         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetParameter(parameter)));
120     }
121 
122     int32_t GetOutputFormat(std::shared_ptr<Media::Meta> &parameter) override
123     {
124         return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->GetOutputFormat(parameter)));
125     }
126 
127     int32_t Configure(const MediaAVCodec::Format &format) override
128     {
129         (void)format;
130         return 0;
131     }
132     int32_t SetParameter(const MediaAVCodec::Format &format) override
133     {
134         (void)format;
135         return 0;
136     }
137 
138     int32_t GetOutputFormat(MediaAVCodec::Format &format) override
139     {
140         (void)format;
141         return 0;
142     }
143 
144     int32_t ReleaseOutputBuffer(uint32_t index) override
145     {
146         (void)index;
147         return 0;
148     }
149 
OnError(CodecErrorType errorType, int32_t errorCode)150     void OnError(CodecErrorType errorType, int32_t errorCode)
151     {
152         if (callback_ == nullptr) {
153             return;
154         }
155         switch (errorType) {
156             case CodecErrorType::CODEC_DRM_DECRYTION_FAILED:
157                 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_DECRYTION_FAILED,
158                     StatusToAVCodecServiceErrCode(static_cast<Media::Status>(errorCode)));
159                 break;
160             default:
161                 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL,
162                     StatusToAVCodecServiceErrCode(static_cast<Media::Status>(errorCode)));
163                 break;
164         }
165     }
166 
OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)167     void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
168     {
169         if (callback_) {
170             callback_->OnOutputBufferAvailable(0, outputBuffer);
171         }
172     }
173 
174 #ifdef SUPPORT_DRM
175     int32_t SetAudioDecryptionConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySession,
176                                      const bool svpFlag) override
177     {
178         return StatusToAVCodecServiceErrCode(
179             static_cast<Media::Status>(mediaCodec_->SetAudioDecryptionConfig(keySession, svpFlag)));
180     }
181 #endif
182 
183 private:
184     std::shared_ptr<Media::MediaCodec> mediaCodec_;
185     std::shared_ptr<MediaCodecCallback> callback_;
186 };
187 
OnError(Media::CodecErrorType errorType, int32_t errorCode)188 void AudioCodecCallback::OnError(Media::CodecErrorType errorType, int32_t errorCode)
189 {
190     if (codec_) {
191         codec_->OnError(errorType, errorCode);
192     }
193 }
194 
OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)195 void AudioCodecCallback::OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
196 {
197     if (codec_) {
198         codec_->OnOutputBufferDone(outputBuffer);
199     }
200 }
201 } // namespace MediaAVCodec
202 } // namespace OHOS
203 #endif