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 HARDWARE_GOOGLE_MEDIA_C2_V1_0_UTILS_CONFIGURABLE_H
18 #define HARDWARE_GOOGLE_MEDIA_C2_V1_0_UTILS_CONFIGURABLE_H
19 
20 #include <codec2/hidl/1.0/ConfigurableC2Intf.h>
21 
22 #include <C2Component.h>
23 #include <C2Param.h>
24 #include <C2.h>
25 
26 #include <hardware/google/media/c2/1.0/IConfigurable.h>
27 #include <hidl/Status.h>
28 
29 #include <memory>
30 
31 namespace hardware {
32 namespace google {
33 namespace media {
34 namespace c2 {
35 namespace V1_0 {
36 namespace utils {
37 
38 using ::android::hardware::hidl_array;
39 using ::android::hardware::hidl_memory;
40 using ::android::hardware::hidl_string;
41 using ::android::hardware::hidl_vec;
42 using ::android::hardware::Return;
43 using ::android::hardware::Void;
44 using ::android::sp;
45 
46 struct ComponentStore;
47 
48 /**
49  * Implementation of the IConfigurable interface that supports caching of
50  * supported parameters from a supplied ComponentStore.
51  *
52  * This is mainly the same for all of the configurable C2 interfaces though
53  * there are slight differences in the blocking behavior. This is handled in the
54  * ConfigurableC2Intf implementations.
55  */
56 struct CachedConfigurable : public IConfigurable {
57     CachedConfigurable(std::unique_ptr<ConfigurableC2Intf>&& intf);
58 
59     c2_status_t init(ComponentStore* store);
60 
61     // Methods from ::android::hardware::media::c2::V1_0::IConfigurable
62 
63     virtual Return<void> getName(getName_cb _hidl_cb) override;
64 
65     virtual Return<void> query(
66             const hidl_vec<uint32_t>& indices,
67             bool mayBlock,
68             query_cb _hidl_cb) override;
69 
70     virtual Return<void> config(
71             const hidl_vec<uint8_t>& inParams,
72             bool mayBlock,
73             config_cb _hidl_cb) override;
74 
75     virtual Return<void> querySupportedParams(
76             uint32_t start,
77             uint32_t count,
78             querySupportedParams_cb _hidl_cb) override;
79 
80     virtual Return<void> querySupportedValues(
81             const hidl_vec<FieldSupportedValuesQuery>& inFields,
82             bool mayBlock,
83             querySupportedValues_cb _hidl_cb) override;
84 
85 protected:
86     // Common Codec2.0 interface wrapper
87     std::unique_ptr<ConfigurableC2Intf> mIntf;
88 
89     // Cached supported params
90     std::vector<std::shared_ptr<C2ParamDescriptor>> mSupportedParams;
91 };
92 
93 /**
94  * Template that implements the `IConfigurable` interface for an inherited
95  * interface. Classes that implement a child interface `I` of `IConfigurable`
96  * can derive from `Configurable<I>`.
97  */
98 template <typename I>
99 struct Configurable : public I {
ConfigurableConfigurable100     Configurable(const sp<CachedConfigurable>& intf): mIntf(intf) {
101     }
102 
initConfigurable103     c2_status_t init(ComponentStore* store) {
104         return mIntf->init(store);
105     }
106 
107     // Methods from ::android::hardware::media::c2::V1_0::IConfigurable
108 
109     using getName_cb = typename I::getName_cb;
getNameConfigurable110     virtual Return<void> getName(getName_cb _hidl_cb) override {
111         return mIntf->getName(_hidl_cb);
112     }
113 
114     using query_cb = typename I::query_cb;
queryConfigurable115     virtual Return<void> query(
116             const hidl_vec<uint32_t>& indices,
117             bool mayBlock,
118             query_cb _hidl_cb) override {
119         return mIntf->query(indices, mayBlock, _hidl_cb);
120     }
121 
122     using config_cb = typename I::config_cb;
configConfigurable123     virtual Return<void> config(
124             const hidl_vec<uint8_t>& inParams,
125             bool mayBlock,
126             config_cb _hidl_cb) override {
127         return mIntf->config(inParams, mayBlock, _hidl_cb);
128     }
129 
130     using querySupportedParams_cb = typename I::querySupportedParams_cb;
querySupportedParamsConfigurable131     virtual Return<void> querySupportedParams(
132             uint32_t start,
133             uint32_t count,
134             querySupportedParams_cb _hidl_cb) override {
135         return mIntf->querySupportedParams(start, count, _hidl_cb);
136     }
137 
138     using querySupportedValues_cb = typename I::querySupportedValues_cb;
querySupportedValuesConfigurable139     virtual Return<void> querySupportedValues(
140             const hidl_vec<FieldSupportedValuesQuery>& inFields,
141             bool mayBlock,
142             querySupportedValues_cb _hidl_cb) override {
143         return mIntf->querySupportedValues(inFields, mayBlock, _hidl_cb);
144     }
145 
146 protected:
147     sp<CachedConfigurable> mIntf;
148 };
149 
150 }  // namespace utils
151 }  // namespace V1_0
152 }  // namespace c2
153 }  // namespace media
154 }  // namespace google
155 }  // namespace hardware
156 
157 #endif  // HARDWARE_GOOGLE_MEDIA_C2_V1_0_UTILS_CONFIGURABLE_H
158