1 /*
2  * Copyright (c) 2023-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 HISTREAMER_PIPELINE_CORE_FILTER_BASE_H
17 #define HISTREAMER_PIPELINE_CORE_FILTER_BASE_H
18 #include <atomic>
19 #include <functional>
20 #include <list>
21 #include <memory>
22 #include "meta/meta.h"
23 #include "buffer/avbuffer_queue_producer.h"
24 #include "common/event.h"
25 #include "osal/task/mutex.h"
26 #include "osal/task/condition_variable.h"
27 #include "osal/task/task.h"
28 
29 namespace OHOS {
30 namespace Media {
31 namespace Pipeline {
32 
33 class Filter;
34 
35 enum class FilterType {
36     FILTERTYPE_SOURCE,
37     FILTERTYPE_DEMUXER,
38     FILTERTYPE_AENC,
39     FILTERTYPE_ADEC,
40     FILTERTYPE_VENC,
41     FILTERTYPE_VDEC,
42     FILTERTYPE_MUXER,
43     FILTERTYPE_VIDEODEC,
44     FILTERTYPE_ASINK,
45     FILTERTYPE_FSINK,
46     FILTERTYPE_SSINK,
47     AUDIO_CAPTURE,
48     AUDIO_DATA_SOURCE,
49     VIDEO_CAPTURE,
50     FILTERTYPE_VIDRESIZE,
51     TIMED_METADATA,
52     FILTERTYPE_MAX,
53 };
54 
55 enum class StreamType {
56     STREAMTYPE_PACKED,
57     STREAMTYPE_ENCODED_AUDIO,
58     STREAMTYPE_ENCODED_VIDEO,
59     STREAMTYPE_RAW_AUDIO,
60     STREAMTYPE_RAW_VIDEO,
61     STREAMTYPE_SUBTITLE,
62     STREAMTYPE_MAX,
63 };
64 
65 enum class FilterState {
66     CREATED,     // Filter created
67     INITIALIZED, // Init called
68     PREPARING,   // Prepare called
69     READY,       // Ready Event reported
70     RUNNING,     // Start called
71     PAUSED,      // Pause called
72     STOPPED,     // Stop called
73     RELEASED,    // Release called
74     ERROR,       // State fail
75 };
76 
77 enum class FilterCallBackCommand {
78     NEXT_FILTER_NEEDED,
79     NEXT_FILTER_REMOVED,
80     NEXT_FILTER_UPDATE,
81     FILTER_CALLBACK_COMMAND_MAX,
82 };
83 
84 class EventReceiver {
85 public:
86     virtual ~EventReceiver() = default;
87     virtual void OnEvent(const Event& event) = 0;
OnDfxEvent(const DfxEvent & event)88     virtual void OnDfxEvent(const DfxEvent& event)
89     {
90         (void)event;
91     }
NotifyRelease()92     virtual void NotifyRelease() {}
93 };
94 
95 class FilterCallback {
96 public:
97     virtual ~FilterCallback() = default;
98     virtual Status OnCallback(const std::shared_ptr<Filter>& filter, FilterCallBackCommand cmd, StreamType outType) = 0;
NotifyRelease()99     virtual void NotifyRelease() {}
100 };
101 
102 class FilterLinkCallback {
103 public:
104     virtual ~FilterLinkCallback() = default;
105     virtual void OnLinkedResult(const sptr<AVBufferQueueProducer>& queue, std::shared_ptr<Meta>& meta) = 0;
106     virtual void OnUnlinkedResult(std::shared_ptr<Meta>& meta) = 0;
107     virtual void OnUpdatedResult(std::shared_ptr<Meta>& meta) = 0;
108 };
109 
110 class Filter {
111 public:
112     explicit Filter(std::string name, FilterType type, bool asyncMode = false);
113 
114     virtual ~Filter();
115 
116     virtual void Init(const std::shared_ptr<EventReceiver>& receiver, const std::shared_ptr<FilterCallback>& callback);
117 
118     virtual void LinkPipeLine(const std::string &groupId) final;
119 
120     virtual Status Prepare() final;
121 
122     virtual Status Start() final;
123 
124     virtual Status Pause() final;
125 
126     virtual Status PauseDragging() final;
127 
128     virtual Status PauseAudioAlign() final;
129 
130     virtual Status Resume() final;
131 
132     virtual Status ResumeDragging() final;
133 
134     virtual Status ResumeAudioAlign() final;
135 
136     virtual Status Stop() final;
137 
138     virtual Status Flush() final;
139 
140     virtual Status Release() final;
141 
142     virtual Status Preroll() final;
143 
144     virtual Status WaitPrerollDone(bool render) final;
145 
146     virtual void StartFilterTask() final;
147 
148     virtual void PauseFilterTask() final;
149 
150     virtual Status SetPlayRange(int64_t start, int64_t end) final;
151 
152     virtual Status ProcessInputBuffer(int sendArg = 0, int64_t delayUs = 0) final;
153 
154     virtual Status ProcessOutputBuffer(int sendArg = 0, int64_t delayUs = 0, bool byIdx = false, uint32_t idx = 0,
155         int64_t renderTime = -1) final;
156 
157     virtual Status WaitAllState(FilterState state) final;
158 
159     virtual Status DoInitAfterLink();
160 
161     virtual Status DoPrepare();
162 
163     virtual Status DoStart();
164 
165     virtual Status DoPause();
166 
167     virtual Status DoPauseDragging();
168 
169     virtual Status DoPauseAudioAlign();
170 
171     virtual Status DoResume();
172 
173     virtual Status DoResumeDragging();
174 
175     virtual Status DoResumeAudioAlign();
176 
177     virtual Status DoStop();
178 
179     virtual Status DoFlush();
180 
181     virtual Status DoRelease();
182 
183     virtual Status DoPreroll();
184 
185     virtual Status DoWaitPrerollDone(bool render);
186 
187     virtual Status DoSetPlayRange(int64_t start, int64_t end);
188 
189     virtual Status DoProcessInputBuffer(int recvArg, bool dropFrame);
190 
191     virtual Status DoProcessOutputBuffer(int recvArg, bool dropFrame, bool byIdx, uint32_t idx, int64_t renderTime);
192 
193     virtual void SetParameter(const std::shared_ptr<Meta>& meta);
194 
195     virtual void GetParameter(std::shared_ptr<Meta>& meta);
196 
197     virtual Status LinkNext(const std::shared_ptr<Filter>& nextFilter, StreamType outType);
198 
199     virtual Status UpdateNext(const std::shared_ptr<Filter>& nextFilter, StreamType outType);
200 
201     virtual Status UnLinkNext(const std::shared_ptr<Filter>& nextFilter, StreamType outType);
202 
203     FilterType GetFilterType();
204 
205     virtual Status OnLinked(StreamType inType, const std::shared_ptr<Meta>& meta,
206                             const std::shared_ptr<FilterLinkCallback>& callback);
207 
208     virtual Status OnUpdated(StreamType inType, const std::shared_ptr<Meta>& meta,
209                              const std::shared_ptr<FilterLinkCallback>& callback);
210 
211     virtual Status OnUnLinked(StreamType inType, const std::shared_ptr<FilterLinkCallback>& callback);
212 
213     virtual Status ClearAllNextFilters();
214 
SetMuted(bool isMuted)215     virtual Status SetMuted(bool isMuted)
216     {
217         (void)isMuted;
218         return Status::OK;
219     }
220 protected:
221     std::string name_;
222 
223     std::shared_ptr<Meta> meta_;
224 
225     FilterType filterType_;
226 
227     std::vector<StreamType> supportedInStreams_;
228     std::vector<StreamType> supportedOutStreams_;
229 
230     std::map<StreamType, std::vector<std::shared_ptr<Filter>>> nextFiltersMap_;
231 
232     std::shared_ptr<EventReceiver> receiver_;
233 
234     std::shared_ptr<FilterCallback> callback_;
235 
236     std::map<StreamType, std::vector<std::shared_ptr<FilterLinkCallback>>> linkCallbackMaps_;
237 
238     std::string groupId_;
239 
240 private:
241     void ChangeState(FilterState state);
242 
243     void SetErrCode(Status errCode);
244 
245     Status GetErrCode();
246 
247     Status PrepareDone();
248 
249     Status StartDone();
250 
251     Status PauseDone();
252 
253     Status ResumeDone();
254 
255     Status StopDone();
256 
257     Status ReleaseDone();
258 
259     OHOS::Media::Mutex stateMutex_{};
260 
261     OHOS::Media::ConditionVariable cond_{};
262 
263     FilterState curState_{FilterState::CREATED};
264 
265     Status errCode_ = Status::OK;
266 
267     int64_t jobIdx_ = 0;
268 
269     int64_t processIdx_ = 0;
270 
271     int64_t jobIdxBase_ = 0;
272 
273     std::unique_ptr<Task> filterTask_;
274 
275     bool isAsyncMode_;
276 };
277 } // namespace Pipeline
278 } // namespace Media
279 } // namespace OHOS
280 #endif
281