1 /*
2  * Copyright (C) 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ANDROID_SIMPLE_C2_INTERFACE_H_
18 #define ANDROID_SIMPLE_C2_INTERFACE_H_
19 
20 #include <C2Component.h>
21 #include <C2Config.h>
22 #include <util/C2InterfaceHelper.h>
23 
24 namespace android {
25 
26 /**
27  * Wrap a common interface object (such as Codec2Client::Interface, or C2InterfaceHelper into
28  * a C2ComponentInterface.
29  *
30  * \param T common interface type
31  */
32 template <typename T>
33 class SimpleC2Interface : public C2ComponentInterface {
34 public:
SimpleC2Interface(const char * name,c2_node_id_t id,const std::shared_ptr<T> & impl)35     SimpleC2Interface(const char *name, c2_node_id_t id, const std::shared_ptr<T> &impl)
36         : mName(name),
37           mId(id),
38           mImpl(impl) {
39     }
40 
41     ~SimpleC2Interface() override = default;
42 
43     // From C2ComponentInterface
getName()44     C2String getName() const override { return mName; }
getId()45     c2_node_id_t getId() const override { return mId; }
query_vb(const std::vector<C2Param * > & stackParams,const std::vector<C2Param::Index> & heapParamIndices,c2_blocking_t mayBlock,std::vector<std::unique_ptr<C2Param>> * const heapParams)46     c2_status_t query_vb(
47             const std::vector<C2Param*> &stackParams,
48             const std::vector<C2Param::Index> &heapParamIndices,
49             c2_blocking_t mayBlock,
50             std::vector<std::unique_ptr<C2Param>>* const heapParams) const override {
51         return mImpl->query(stackParams, heapParamIndices, mayBlock, heapParams);
52     }
config_vb(const std::vector<C2Param * > & params,c2_blocking_t mayBlock,std::vector<std::unique_ptr<C2SettingResult>> * const failures)53     c2_status_t config_vb(
54             const std::vector<C2Param*> &params,
55             c2_blocking_t mayBlock,
56             std::vector<std::unique_ptr<C2SettingResult>>* const failures) override {
57         return mImpl->config(params, mayBlock, failures);
58     }
createTunnel_sm(c2_node_id_t)59     c2_status_t createTunnel_sm(c2_node_id_t) override { return C2_OMITTED; }
releaseTunnel_sm(c2_node_id_t)60     c2_status_t releaseTunnel_sm(c2_node_id_t) override { return C2_OMITTED; }
querySupportedParams_nb(std::vector<std::shared_ptr<C2ParamDescriptor>> * const params)61     c2_status_t querySupportedParams_nb(
62             std::vector<std::shared_ptr<C2ParamDescriptor>> * const params) const override {
63         return mImpl->querySupportedParams(params);
64     }
querySupportedValues_vb(std::vector<C2FieldSupportedValuesQuery> & fields,c2_blocking_t mayBlock)65     c2_status_t querySupportedValues_vb(
66             std::vector<C2FieldSupportedValuesQuery> &fields,
67             c2_blocking_t mayBlock) const override {
68         return mImpl->querySupportedValues(fields, mayBlock);
69     }
70 
71 private:
72     C2String mName;
73     const c2_node_id_t mId;
74     const std::shared_ptr<T> mImpl;
75 };
76 
77 /**
78  * Utility classes for common interfaces.
79  */
80 template<>
81 class SimpleC2Interface<void> {
82 public:
83     /**
84      * Base Codec 2.0 parameters required for all components.
85      */
86     struct BaseParams : C2InterfaceHelper {
87         explicit BaseParams(
88                 const std::shared_ptr<C2ReflectorHelper> &helper,
89                 C2String name,
90                 C2Component::kind_t kind,
91                 C2Component::domain_t domain,
92                 C2String mediaType,
93                 std::vector<C2String> aliases = std::vector<C2String>());
94 
95         /// Marks that this component has no input latency. Otherwise, component must
96         /// add support for C2PortRequestedDelayTuning::input and C2PortActualDelayTuning::input.
97         void noInputLatency();
98 
99         /// Marks that this component has no output latency. Otherwise, component must
100         /// add support for C2PortRequestedDelayTuning::output and C2PortActualDelayTuning::output.
101         void noOutputLatency();
102 
103         /// Marks that this component has no pipeline latency. Otherwise, component must
104         /// add support for C2RequestedPipelineDelayTuning and C2ActualPipelineDelayTuning.
105         void noPipelineLatency();
106 
107         /// Marks that this component has no need for private buffers. Otherwise, component must
108         /// add support for C2MaxPrivateBufferCountTuning, C2PrivateAllocatorsTuning and
109         /// C2PrivateBlockPoolsTuning.
110         void noPrivateBuffers();
111 
112         /// Marks that this component holds no references to input buffers. Otherwise, component
113         /// must add support for C2StreamMaxReferenceAgeTuning::input and
114         /// C2StreamMaxReferenceCountTuning::input.
115         void noInputReferences();
116 
117         /// Marks that this component holds no references to output buffers. Otherwise, component
118         /// must add support for C2StreamMaxReferenceAgeTuning::output and
119         /// C2StreamMaxReferenceCountTuning::output.
120         void noOutputReferences();
121 
122         /// Marks that this component does not stretch time. Otherwise, component
123         /// must add support for C2ComponentTimeStretchTuning.
124         void noTimeStretch();
125 
126         std::shared_ptr<C2ApiLevelSetting> mApiLevel;
127         std::shared_ptr<C2ApiFeaturesSetting> mApiFeatures;
128 
129         std::shared_ptr<C2PlatformLevelSetting> mPlatformLevel;
130         std::shared_ptr<C2PlatformFeaturesSetting> mPlatformFeatures;
131 
132         std::shared_ptr<C2ComponentNameSetting> mName;
133         std::shared_ptr<C2ComponentAliasesSetting> mAliases;
134         std::shared_ptr<C2ComponentKindSetting> mKind;
135         std::shared_ptr<C2ComponentDomainSetting> mDomain;
136         std::shared_ptr<C2ComponentAttributesSetting> mAttrib;
137         std::shared_ptr<C2ComponentTimeStretchTuning> mTimeStretch;
138 
139         std::shared_ptr<C2PortMediaTypeSetting::input> mInputMediaType;
140         std::shared_ptr<C2PortMediaTypeSetting::output> mOutputMediaType;
141         std::shared_ptr<C2StreamBufferTypeSetting::input> mInputFormat;
142         std::shared_ptr<C2StreamBufferTypeSetting::output> mOutputFormat;
143 
144         std::shared_ptr<C2PortRequestedDelayTuning::input> mRequestedInputDelay;
145         std::shared_ptr<C2PortRequestedDelayTuning::output> mRequestedOutputDelay;
146         std::shared_ptr<C2RequestedPipelineDelayTuning> mRequestedPipelineDelay;
147 
148         std::shared_ptr<C2PortActualDelayTuning::input> mActualInputDelay;
149         std::shared_ptr<C2PortActualDelayTuning::output> mActualOutputDelay;
150         std::shared_ptr<C2ActualPipelineDelayTuning> mActualPipelineDelay;
151 
152         std::shared_ptr<C2StreamMaxReferenceAgeTuning::input> mMaxInputReferenceAge;
153         std::shared_ptr<C2StreamMaxReferenceCountTuning::input> mMaxInputReferenceCount;
154         std::shared_ptr<C2StreamMaxReferenceAgeTuning::output> mMaxOutputReferenceAge;
155         std::shared_ptr<C2StreamMaxReferenceCountTuning::output> mMaxOutputReferenceCount;
156         std::shared_ptr<C2MaxPrivateBufferCountTuning> mMaxPrivateBufferCount;
157 
158         std::shared_ptr<C2PortStreamCountTuning::input> mInputStreamCount;
159         std::shared_ptr<C2PortStreamCountTuning::output> mOutputStreamCount;
160 
161         std::shared_ptr<C2SubscribedParamIndicesTuning> mSubscribedParamIndices;
162         std::shared_ptr<C2PortSuggestedBufferCountTuning::input> mSuggestedInputBufferCount;
163         std::shared_ptr<C2PortSuggestedBufferCountTuning::output> mSuggestedOutputBufferCount;
164 
165         std::shared_ptr<C2CurrentWorkTuning> mCurrentWorkOrdinal;
166         std::shared_ptr<C2LastWorkQueuedTuning::input> mLastInputQueuedWorkOrdinal;
167         std::shared_ptr<C2LastWorkQueuedTuning::output> mLastOutputQueuedWorkOrdinal;
168 
169         std::shared_ptr<C2PortAllocatorsTuning::input> mInputAllocators;
170         std::shared_ptr<C2PortAllocatorsTuning::output> mOutputAllocators;
171         std::shared_ptr<C2PrivateAllocatorsTuning> mPrivateAllocators;
172         std::shared_ptr<C2PortBlockPoolsTuning::output> mOutputPoolIds;
173         std::shared_ptr<C2PrivateBlockPoolsTuning> mPrivatePoolIds;
174 
175         std::shared_ptr<C2TrippedTuning> mTripped;
176         std::shared_ptr<C2OutOfMemoryTuning> mOutOfMemory;
177 
178         std::shared_ptr<C2PortConfigCounterTuning::input> mInputConfigCounter;
179         std::shared_ptr<C2PortConfigCounterTuning::output> mOutputConfigCounter;
180         std::shared_ptr<C2ConfigCounterTuning> mDirectConfigCounter;
181     };
182 };
183 
184 template<typename T>
185 using SimpleInterface = SimpleC2Interface<T>;
186 
187 template<typename T, typename ...Args>
AllocSharedString(const Args (&...args),const char * str)188 std::shared_ptr<T> AllocSharedString(const Args(&... args), const char *str) {
189     size_t len = strlen(str) + 1;
190     std::shared_ptr<T> ret = T::AllocShared(len, args...);
191     strcpy(ret->m.value, str);
192     return ret;
193 }
194 
195 template<typename T, typename ...Args>
AllocSharedString(const Args (&...args),const std::string & str)196 std::shared_ptr<T> AllocSharedString(const Args(&... args), const std::string &str) {
197     std::shared_ptr<T> ret = T::AllocShared(str.length() + 1, args...);
198     strcpy(ret->m.value, str.c_str());
199     return ret;
200 }
201 
202 template <typename T>
203 struct Setter {
204     typedef typename std::remove_reference<T>::type type;
205 
NonStrictValueWithNoDepsSetter206     static C2R NonStrictValueWithNoDeps(
207             bool mayBlock, C2InterfaceHelper::C2P<type> &me) {
208         (void)mayBlock;
209         return me.F(me.v.value).validatePossible(me.v.value);
210     }
211 
NonStrictValuesWithNoDepsSetter212     static C2R NonStrictValuesWithNoDeps(
213             bool mayBlock, C2InterfaceHelper::C2P<type> &me) {
214         (void)mayBlock;
215         C2R res = C2R::Ok();
216         for (size_t ix = 0; ix < me.v.flexCount(); ++ix) {
217             res.plus(me.F(me.v.m.values[ix]).validatePossible(me.v.m.values[ix]));
218         }
219         return res;
220     }
221 
StrictValueWithNoDepsSetter222     static C2R StrictValueWithNoDeps(
223             bool mayBlock,
224             const C2InterfaceHelper::C2P<type> &old,
225             C2InterfaceHelper::C2P<type> &me) {
226         (void)mayBlock;
227         if (!me.F(me.v.value).supportsNow(me.v.value)) {
228             me.set().value = old.v.value;
229         }
230         return me.F(me.v.value).validatePossible(me.v.value);
231     }
232 };
233 
234 }  // namespace android
235 
236 #endif  // ANDROID_SIMPLE_C2_INTERFACE_H_
237