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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "CCodecConfig"
19
20 #include <initializer_list>
21
22 #include <cutils/properties.h>
23 #include <log/log.h>
24 #include <utils/NativeHandle.h>
25
26 #include <android-base/properties.h>
27
28 #include <C2Component.h>
29 #include <C2Param.h>
30 #include <util/C2InterfaceHelper.h>
31
32 #include <media/stagefright/CodecBase.h>
33 #include <media/stagefright/MediaCodecConstants.h>
34
35 #include "CCodecConfig.h"
36 #include "Codec2Mapper.h"
37
38 #define DRC_DEFAULT_MOBILE_REF_LEVEL 64 /* 64*-0.25dB = -16 dB below full scale for mobile conf */
39 #define DRC_DEFAULT_MOBILE_DRC_CUT 127 /* maximum compression of dynamic range for mobile conf */
40 #define DRC_DEFAULT_MOBILE_DRC_BOOST 127 /* maximum compression of dynamic range for mobile conf */
41 #define DRC_DEFAULT_MOBILE_DRC_HEAVY 1 /* switch for heavy compression for mobile conf */
42 #define DRC_DEFAULT_MOBILE_DRC_EFFECT 3 /* MPEG-D DRC effect type; 3 => Limited playback range */
43 #define DRC_DEFAULT_MOBILE_DRC_ALBUM 0 /* MPEG-D DRC album mode; 0 => album mode is disabled, 1 => album mode is enabled */
44 #define DRC_DEFAULT_MOBILE_OUTPUT_LOUDNESS -1 /* decoder output loudness; -1 => the value is unknown, otherwise dB step value (e.g. 64 for -16 dB) */
45 #define DRC_DEFAULT_MOBILE_ENC_LEVEL (-1) /* encoder target level; -1 => the value is unknown, otherwise dB step value (e.g. 64 for -16 dB) */
46 // names of properties that can be used to override the default DRC settings
47 #define PROP_DRC_OVERRIDE_REF_LEVEL "aac_drc_reference_level"
48 #define PROP_DRC_OVERRIDE_CUT "aac_drc_cut"
49 #define PROP_DRC_OVERRIDE_BOOST "aac_drc_boost"
50 #define PROP_DRC_OVERRIDE_HEAVY "aac_drc_heavy"
51 #define PROP_DRC_OVERRIDE_ENC_LEVEL "aac_drc_enc_target_level"
52 #define PROP_DRC_OVERRIDE_EFFECT "ro.aac_drc_effect_type"
53
54 namespace android {
55
56 // CCodecConfig
57
58 namespace {
59
C2ValueToMessageItem(const C2Value & value,AMessage::ItemData & item)60 void C2ValueToMessageItem(const C2Value &value, AMessage::ItemData &item) {
61 int32_t int32Value;
62 uint32_t uint32Value;
63 int64_t int64Value;
64 uint64_t uint64Value;
65 float floatValue;
66 if (value.get(&int32Value)) {
67 item.set(int32Value);
68 } else if (value.get(&uint32Value) && uint32Value <= uint32_t(INT32_MAX)) {
69 // SDK does not support unsigned values
70 item.set((int32_t)uint32Value);
71 } else if (value.get(&int64Value)) {
72 item.set(int64Value);
73 } else if (value.get(&uint64Value) && uint64Value <= uint64_t(INT64_MAX)) {
74 // SDK does not support unsigned values
75 item.set((int64_t)uint64Value);
76 } else if (value.get(&floatValue)) {
77 item.set(floatValue);
78 }
79 }
80
81 /**
82 * mapping between SDK and Codec 2.0 configurations.
83 */
84 struct ConfigMapper {
85 /**
86 * Value mapper (C2Value => C2Value)
87 */
88 typedef std::function<C2Value(C2Value)> Mapper;
89
90 /// shorthand
91 typedef CCodecConfig::Domain Domain;
92
ConfigMapperandroid::__anon8d2722470111::ConfigMapper93 ConfigMapper(std::string mediaKey, C2String c2struct, C2String c2field)
94 : mDomain(Domain::ALL), mMediaKey(mediaKey), mStruct(c2struct), mField(c2field) { }
95
96 /// Limits this parameter to the given domain
limitToandroid::__anon8d2722470111::ConfigMapper97 ConfigMapper &limitTo(uint32_t domain) {
98 C2_CHECK(domain & Domain::GUARD_BIT);
99 mDomain = Domain(mDomain & domain);
100 return *this;
101 }
102
103 /// Adds SDK => Codec 2.0 mapper (should not be in the SDK format)
withMapperandroid::__anon8d2722470111::ConfigMapper104 ConfigMapper &withMapper(Mapper mapper) {
105 C2_CHECK(!mMapper);
106 C2_CHECK(!mReverse);
107 mMapper = mapper;
108 return *this;
109 }
110
111 /// Adds SDK <=> Codec 2.0 value mappers
withMappersandroid::__anon8d2722470111::ConfigMapper112 ConfigMapper &withMappers(Mapper mapper, Mapper reverse) {
113 C2_CHECK(!mMapper);
114 C2_CHECK(!mReverse);
115 mMapper = mapper;
116 mReverse = reverse;
117 return *this;
118 }
119
120 /// Adds SDK <=> Codec 2.0 value mappers based on C2Mapper
121 template<typename C2Type, typename SdkType=int32_t>
withC2Mappersandroid::__anon8d2722470111::ConfigMapper122 ConfigMapper &withC2Mappers() {
123 C2_CHECK(!mMapper);
124 C2_CHECK(!mReverse);
125 mMapper = [](C2Value v) -> C2Value {
126 SdkType sdkValue;
127 C2Type c2Value;
128 if (v.get(&sdkValue) && C2Mapper::map(sdkValue, &c2Value)) {
129 return c2Value;
130 }
131 return C2Value();
132 };
133 mReverse = [](C2Value v) -> C2Value {
134 SdkType sdkValue;
135 C2Type c2Value;
136 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<C2Type>::type;
137 if (v.get((C2ValueType*)&c2Value) && C2Mapper::map(c2Value, &sdkValue)) {
138 return sdkValue;
139 }
140 return C2Value();
141 };
142 return *this;
143 }
144
145 /// Maps from SDK values in an AMessage to a suitable C2Value.
mapFromMessageandroid::__anon8d2722470111::ConfigMapper146 C2Value mapFromMessage(const AMessage::ItemData &item) const {
147 C2Value value;
148 int32_t int32Value;
149 int64_t int64Value;
150 float floatValue;
151 double doubleValue;
152 if (item.find(&int32Value)) {
153 value = int32Value;
154 } else if (item.find(&int64Value)) {
155 value = int64Value;
156 } else if (item.find(&floatValue)) {
157 value = floatValue;
158 } else if (item.find(&doubleValue)) {
159 value = (float)doubleValue;
160 }
161 if (value.type() != C2Value::NO_INIT && mMapper) {
162 value = mMapper(value);
163 }
164 return value;
165 }
166
167 /// Maps from a C2Value to an SDK value in an AMessage.
mapToMessageandroid::__anon8d2722470111::ConfigMapper168 AMessage::ItemData mapToMessage(C2Value value) const {
169 AMessage::ItemData item;
170 if (value.type() != C2Value::NO_INIT && mReverse) {
171 value = mReverse(value);
172 }
173 C2ValueToMessageItem(value, item);
174 return item;
175 }
176
domainandroid::__anon8d2722470111::ConfigMapper177 Domain domain() const { return mDomain; }
mediaKeyandroid::__anon8d2722470111::ConfigMapper178 std::string mediaKey() const { return mMediaKey; }
pathandroid::__anon8d2722470111::ConfigMapper179 std::string path() const { return mField.size() ? mStruct + '.' + mField : mStruct; }
mapperandroid::__anon8d2722470111::ConfigMapper180 Mapper mapper() const { return mMapper; }
reverseandroid::__anon8d2722470111::ConfigMapper181 Mapper reverse() const { return mReverse; }
182
183 private:
184 Domain mDomain; ///< parameter domain (mask) containing port, kind and config domains
185 std::string mMediaKey; ///< SDK key
186 C2String mStruct; ///< Codec 2.0 struct name
187 C2String mField; ///< Codec 2.0 field name
188 Mapper mMapper; ///< optional SDK => Codec 2.0 value mapper
189 Mapper mReverse; ///< optional Codec 2.0 => SDK value mapper
190 };
191
192 template <typename PORT, typename STREAM>
QueryMediaTypeImpl(const std::shared_ptr<Codec2Client::Configurable> & configurable)193 AString QueryMediaTypeImpl(
194 const std::shared_ptr<Codec2Client::Configurable> &configurable) {
195 AString mediaType;
196 std::vector<std::unique_ptr<C2Param>> queried;
197 c2_status_t c2err = configurable->query(
198 {}, { PORT::PARAM_TYPE, STREAM::PARAM_TYPE }, C2_DONT_BLOCK, &queried);
199 if (c2err != C2_OK && queried.size() == 0) {
200 ALOGD("Query media type failed => %s", asString(c2err));
201 } else {
202 PORT *portMediaType =
203 PORT::From(queried[0].get());
204 if (portMediaType) {
205 mediaType = AString(
206 portMediaType->m.value,
207 strnlen(portMediaType->m.value, portMediaType->flexCount()));
208 } else {
209 STREAM *streamMediaType = STREAM::From(queried[0].get());
210 if (streamMediaType) {
211 mediaType = AString(
212 streamMediaType->m.value,
213 strnlen(streamMediaType->m.value, streamMediaType->flexCount()));
214 }
215 }
216 ALOGD("read media type: %s", mediaType.c_str());
217 }
218 return mediaType;
219 }
220
QueryMediaType(bool input,const std::shared_ptr<Codec2Client::Configurable> & configurable)221 AString QueryMediaType(
222 bool input, const std::shared_ptr<Codec2Client::Configurable> &configurable) {
223 typedef C2PortMediaTypeSetting P;
224 typedef C2StreamMediaTypeSetting S;
225 if (input) {
226 return QueryMediaTypeImpl<P::input, S::input>(configurable);
227 } else {
228 return QueryMediaTypeImpl<P::output, S::output>(configurable);
229 }
230 }
231
232 } // namespace
233
234 /**
235 * Set of standard parameters used by CCodec that are exposed to MediaCodec.
236 */
237 struct StandardParams {
238 typedef CCodecConfig::Domain Domain;
239
240 // standard (MediaCodec) params are keyed by media format key
241 typedef std::string SdkKey;
242
243 /// used to return reference to no config mappers in getConfigMappersForSdkKey
244 static const std::vector<ConfigMapper> NO_MAPPERS;
245
246 /// Returns Codec 2.0 equivalent parameters for an SDK format key.
getConfigMappersForSdkKeyandroid::StandardParams247 const std::vector<ConfigMapper> &getConfigMappersForSdkKey(std::string key) const {
248 auto it = mConfigMappers.find(key);
249 if (it == mConfigMappers.end()) {
250 if (mComplained.count(key) == 0) {
251 ALOGD("no c2 equivalents for %s", key.c_str());
252 mComplained.insert(key);
253 }
254 return NO_MAPPERS;
255 }
256 ALOGV("found %zu eqs for %s", it->second.size(), key.c_str());
257 return it->second;
258 }
259
260 /**
261 * Adds a SDK <=> Codec 2.0 parameter mapping. Multiple Codec 2.0 parameters may map to a
262 * single SDK key, in which case they shall be ordered from least authoritative to most
263 * authoritative. When constructing SDK formats, the last mapped Codec 2.0 parameter that
264 * is supported by the component will determine the exposed value. (TODO: perhaps restrict this
265 * by domain.)
266 */
addandroid::StandardParams267 void add(const ConfigMapper &cm) {
268 auto it = mConfigMappers.find(cm.mediaKey());
269 ALOGV("%c%c%c%c %c%c%c %04x %9s %s => %s",
270 ((cm.domain() & Domain::IS_INPUT) ? 'I' : ' '),
271 ((cm.domain() & Domain::IS_OUTPUT) ? 'O' : ' '),
272 ((cm.domain() & Domain::IS_CODED) ? 'C' : ' '),
273 ((cm.domain() & Domain::IS_RAW) ? 'R' : ' '),
274 ((cm.domain() & Domain::IS_CONFIG) ? 'c' : ' '),
275 ((cm.domain() & Domain::IS_PARAM) ? 'p' : ' '),
276 ((cm.domain() & Domain::IS_READ) ? 'r' : ' '),
277 cm.domain(),
278 it == mConfigMappers.end() ? "adding" : "extending",
279 cm.mediaKey().c_str(), cm.path().c_str());
280 if (it == mConfigMappers.end()) {
281 std::vector<ConfigMapper> eqs = { cm };
282 mConfigMappers.emplace(cm.mediaKey(), eqs);
283 } else {
284 it->second.push_back(cm);
285 }
286 }
287
288 // Updates or adds a mapper for a "sdkkey"
updateConfigMappersForKeyandroid::StandardParams289 void updateConfigMappersForKey(const SdkKey& key,
290 const std::vector<ConfigMapper>& vec_cm) {
291 mConfigMappers.insert_or_assign(key, vec_cm);
292 }
293
294 /**
295 * Returns all paths for a specific domain.
296 *
297 * \param any maximum domain mask. Returned parameters must match at least one of the domains
298 * in the mask.
299 * \param all minimum domain mask. Returned parameters must match all of the domains in the
300 * mask. This is restricted to the bits of the maximum mask.
301 */
getPathsForDomainandroid::StandardParams302 std::vector<std::string> getPathsForDomain(
303 Domain any, Domain all = Domain::ALL) const {
304 std::vector<std::string> res;
305 for (const auto &[key, mappers] : mConfigMappers) {
306 for (const ConfigMapper &cm : mappers) {
307 ALOGV("filtering %s %x %x %x %x", cm.path().c_str(), cm.domain(), any,
308 (cm.domain() & any), (cm.domain() & any & all));
309 if ((cm.domain() & any) && ((cm.domain() & any & all) == (any & all))) {
310 res.push_back(cm.path());
311 }
312 }
313 }
314 return res;
315 }
316
317 /**
318 * Returns SDK <=> Codec 2.0 mappings.
319 *
320 * TODO: replace these with better methods as this exposes the inner structure.
321 */
getKeysandroid::StandardParams322 const std::map<SdkKey, std::vector<ConfigMapper>> getKeys() const {
323 return mConfigMappers;
324 }
325
326 private:
327 std::map<SdkKey, std::vector<ConfigMapper>> mConfigMappers;
328 mutable std::set<std::string> mComplained;
329 };
330
331 const std::vector<ConfigMapper> StandardParams::NO_MAPPERS;
332
333
CCodecConfig()334 CCodecConfig::CCodecConfig()
335 : mInputFormat(new AMessage),
336 mOutputFormat(new AMessage),
337 mUsingSurface(false),
338 mTunneled(false),
339 mPushBlankBuffersOnStop(false) { }
340
initializeStandardParams()341 void CCodecConfig::initializeStandardParams() {
342 typedef Domain D;
343 mStandardParams = std::make_shared<StandardParams>();
344 std::function<void(const ConfigMapper &)> add =
345 [params = mStandardParams](const ConfigMapper &cm) {
346 params->add(cm);
347 };
348 std::function<void(const ConfigMapper &)> deprecated = add;
349
350 // allow int32 or float SDK values and represent them as float
351 ConfigMapper::Mapper makeFloat = [](C2Value v) -> C2Value {
352 // convert from i32 to float
353 int32_t i32Value;
354 float fpValue;
355 if (v.get(&i32Value)) {
356 return (float)i32Value;
357 } else if (v.get(&fpValue)) {
358 return fpValue;
359 }
360 return C2Value();
361 };
362
363 ConfigMapper::Mapper negate = [](C2Value v) -> C2Value {
364 int32_t value;
365 if (v.get(&value)) {
366 return -value;
367 }
368 return C2Value();
369 };
370
371 add(ConfigMapper(KEY_MIME, C2_PARAMKEY_INPUT_MEDIA_TYPE, "value")
372 .limitTo(D::INPUT & D::READ));
373 add(ConfigMapper(KEY_MIME, C2_PARAMKEY_OUTPUT_MEDIA_TYPE, "value")
374 .limitTo(D::OUTPUT & D::READ));
375
376 add(ConfigMapper(KEY_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
377 .limitTo(D::ENCODER & D::CODED));
378 // Some audio decoders require bitrate information to be set
379 add(ConfigMapper(KEY_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
380 .limitTo(D::AUDIO & D::DECODER & D::CODED));
381 // we also need to put the bitrate in the max bitrate field
382 add(ConfigMapper(KEY_MAX_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
383 .limitTo(D::ENCODER & D::READ & D::OUTPUT));
384 add(ConfigMapper(PARAMETER_KEY_VIDEO_BITRATE, C2_PARAMKEY_BITRATE, "value")
385 .limitTo(D::ENCODER & D::VIDEO & D::PARAM));
386 add(ConfigMapper(KEY_BITRATE_MODE, C2_PARAMKEY_BITRATE_MODE, "value")
387 .limitTo(D::ENCODER & D::CODED)
388 .withC2Mappers<C2Config::bitrate_mode_t>());
389 // remove when codecs switch to PARAMKEY and new modes
390 deprecated(ConfigMapper(KEY_BITRATE_MODE, "coded.bitrate-mode", "value")
391 .limitTo(D::ENCODER));
392 add(ConfigMapper(KEY_FRAME_RATE, C2_PARAMKEY_FRAME_RATE, "value")
393 .limitTo(D::VIDEO)
394 .withMappers(makeFloat, [](C2Value v) -> C2Value {
395 // read back always as int
396 float value;
397 if (v.get(&value)) {
398 return (int32_t) (value + 0.5);
399 }
400 return C2Value();
401 }));
402
403 add(ConfigMapper(KEY_MAX_INPUT_SIZE, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE, "value")
404 .limitTo(D::INPUT));
405 // remove when codecs switch to PARAMKEY
406 deprecated(ConfigMapper(KEY_MAX_INPUT_SIZE, "coded.max-frame-size", "value")
407 .limitTo(D::INPUT));
408
409 // Rotation
410 // Note: SDK rotation is clock-wise, while C2 rotation is counter-clock-wise
411 add(ConfigMapper(KEY_ROTATION, C2_PARAMKEY_VUI_ROTATION, "value")
412 .limitTo((D::VIDEO | D::IMAGE) & D::CODED)
413 .withMappers(negate, negate));
414 add(ConfigMapper(KEY_ROTATION, C2_PARAMKEY_ROTATION, "value")
415 .limitTo((D::VIDEO | D::IMAGE) & D::RAW)
416 .withMappers(negate, negate));
417
418 // android 'video-scaling'
419 add(ConfigMapper("android._video-scaling", C2_PARAMKEY_SURFACE_SCALING_MODE, "value")
420 .limitTo(D::VIDEO & D::DECODER & D::RAW));
421
422 // Color Aspects
423 //
424 // configure default for decoders
425 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "range")
426 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM))
427 .withC2Mappers<C2Color::range_t>());
428 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "transfer")
429 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM))
430 .withC2Mappers<C2Color::transfer_t>());
431 add(ConfigMapper("color-primaries", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "primaries")
432 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM)));
433 add(ConfigMapper("color-matrix", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "matrix")
434 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM)));
435
436 // read back default for decoders. This is needed in case the component does not support
437 // color aspects. In that case, these values get copied to color-* keys.
438 // TRICKY: We read these values at raw port, since that's where we want to read these.
439 add(ConfigMapper("default-color-range", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "range")
440 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ)
441 .withC2Mappers<C2Color::range_t>());
442 add(ConfigMapper("default-color-transfer", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "transfer")
443 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ)
444 .withC2Mappers<C2Color::transfer_t>());
445 add(ConfigMapper("default-color-primaries", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "primaries")
446 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ));
447 add(ConfigMapper("default-color-matrix", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "matrix")
448 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ));
449
450 // read back final for decoder output (also, configure final aspects as well. This should be
451 // overwritten based on coded/default values if component supports color aspects, but is used
452 // as final values if component does not support aspects at all)
453 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_COLOR_ASPECTS, "range")
454 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ)
455 .withC2Mappers<C2Color::range_t>());
456 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_COLOR_ASPECTS, "transfer")
457 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ)
458 .withC2Mappers<C2Color::transfer_t>());
459 add(ConfigMapper("color-primaries", C2_PARAMKEY_COLOR_ASPECTS, "primaries")
460 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ));
461 add(ConfigMapper("color-matrix", C2_PARAMKEY_COLOR_ASPECTS, "matrix")
462 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::READ));
463
464 // configure transfer request
465 add(ConfigMapper("color-transfer-request", C2_PARAMKEY_COLOR_ASPECTS, "transfer")
466 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW & D::CONFIG)
467 .withC2Mappers<C2Color::transfer_t>());
468
469 // configure source aspects for encoders and read them back on the coded(!) port.
470 // This is to ensure muxing the desired aspects into the container.
471 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_COLOR_ASPECTS, "range")
472 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED)
473 .withC2Mappers<C2Color::range_t>());
474 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_COLOR_ASPECTS, "transfer")
475 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED)
476 .withC2Mappers<C2Color::transfer_t>());
477 add(ConfigMapper("color-primaries", C2_PARAMKEY_COLOR_ASPECTS, "primaries")
478 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED));
479 add(ConfigMapper("color-matrix", C2_PARAMKEY_COLOR_ASPECTS, "matrix")
480 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED));
481
482 // read back coded aspects for encoders (on the raw port), but also configure
483 // desired aspects here.
484 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_VUI_COLOR_ASPECTS, "range")
485 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW)
486 .withC2Mappers<C2Color::range_t>());
487 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_VUI_COLOR_ASPECTS, "transfer")
488 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW)
489 .withC2Mappers<C2Color::transfer_t>());
490 add(ConfigMapper("color-primaries", C2_PARAMKEY_VUI_COLOR_ASPECTS, "primaries")
491 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW));
492 add(ConfigMapper("color-matrix", C2_PARAMKEY_VUI_COLOR_ASPECTS, "matrix")
493 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW));
494
495 // Dataspace
496 add(ConfigMapper("android._dataspace", C2_PARAMKEY_DATA_SPACE, "value")
497 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
498
499 // HDR
500 add(ConfigMapper("smpte2086.red.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.red.x")
501 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
502 add(ConfigMapper("smpte2086.red.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.red.y")
503 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
504 add(ConfigMapper("smpte2086.green.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.green.x")
505 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
506 add(ConfigMapper("smpte2086.green.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.green.y")
507 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
508 add(ConfigMapper("smpte2086.blue.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.blue.x")
509 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
510 add(ConfigMapper("smpte2086.blue.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.blue.y")
511 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
512 add(ConfigMapper("smpte2086.white.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.white.x")
513 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
514 add(ConfigMapper("smpte2086.white.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.white.y")
515 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
516 add(ConfigMapper("smpte2086.max-luminance", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.max-luminance")
517 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
518 add(ConfigMapper("smpte2086.min-luminance", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.min-luminance")
519 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
520 add(ConfigMapper("cta861.max-cll", C2_PARAMKEY_HDR_STATIC_INFO, "max-cll")
521 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
522 add(ConfigMapper("cta861.max-fall", C2_PARAMKEY_HDR_STATIC_INFO, "max-fall")
523 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
524
525 add(ConfigMapper(C2_PARAMKEY_HDR_FORMAT, C2_PARAMKEY_HDR_FORMAT, "value")
526 .limitTo((D::VIDEO | D::IMAGE) & D::CODED & D::CONFIG));
527
528 add(ConfigMapper(std::string(KEY_FEATURE_) + FEATURE_SecurePlayback,
529 C2_PARAMKEY_SECURE_MODE, "value"));
530
531 add(ConfigMapper(KEY_PREPEND_HEADER_TO_SYNC_FRAMES,
532 C2_PARAMKEY_PREPEND_HEADER_MODE, "value")
533 .limitTo(D::ENCODER & D::VIDEO)
534 .withMappers([](C2Value v) -> C2Value {
535 int32_t value;
536 if (v.get(&value)) {
537 return value ? C2Value(C2Config::PREPEND_HEADER_TO_ALL_SYNC)
538 : C2Value(C2Config::PREPEND_HEADER_TO_NONE);
539 }
540 return C2Value();
541 }, [](C2Value v) -> C2Value {
542 C2Config::prepend_header_mode_t value;
543 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(value)>::type;
544 if (v.get((C2ValueType *)&value)) {
545 switch (value) {
546 case C2Config::PREPEND_HEADER_TO_NONE: return 0;
547 case C2Config::PREPEND_HEADER_TO_ALL_SYNC: return 1;
548 case C2Config::PREPEND_HEADER_ON_CHANGE: [[fallthrough]];
549 default: return C2Value();
550 }
551 }
552 return C2Value();
553 }));
554 // remove when codecs switch to PARAMKEY
555 deprecated(ConfigMapper(KEY_PREPEND_HEADER_TO_SYNC_FRAMES,
556 "coding.add-csd-to-sync-frames", "value")
557 .limitTo(D::ENCODER & D::VIDEO));
558 // convert to timestamp base
559 add(ConfigMapper(KEY_I_FRAME_INTERVAL, C2_PARAMKEY_SYNC_FRAME_INTERVAL, "value")
560 .limitTo(D::VIDEO & D::ENCODER & D::CONFIG)
561 .withMapper([](C2Value v) -> C2Value {
562 // convert from i32 to float
563 int32_t i32Value;
564 float fpValue;
565 if (v.get(&i32Value)) {
566 return int64_t(1000000) * i32Value;
567 } else if (v.get(&fpValue)) {
568 return int64_t(c2_min(1000000 * fpValue + 0.5, (double)INT64_MAX));
569 }
570 return C2Value();
571 }));
572 // remove when codecs switch to proper coding.gop (add support for calculating gop)
573 deprecated(ConfigMapper("i-frame-period", "coding.gop", "intra-period")
574 .limitTo(D::ENCODER & D::VIDEO));
575 add(ConfigMapper(KEY_INTRA_REFRESH_PERIOD, C2_PARAMKEY_INTRA_REFRESH, "period")
576 .limitTo(D::VIDEO & D::ENCODER)
577 .withMappers(makeFloat, [](C2Value v) -> C2Value {
578 // read back always as int
579 float value;
580 if (v.get(&value)) {
581 return (int32_t)value;
582 }
583 return C2Value();
584 }));
585 deprecated(ConfigMapper(PARAMETER_KEY_REQUEST_SYNC_FRAME,
586 "coding.request-sync", "value")
587 .limitTo(D::PARAM & D::ENCODER)
588 .withMapper([](C2Value) -> C2Value { return uint32_t(1); }));
589 add(ConfigMapper(PARAMETER_KEY_REQUEST_SYNC_FRAME,
590 C2_PARAMKEY_REQUEST_SYNC_FRAME, "value")
591 .limitTo(D::PARAM & D::ENCODER)
592 .withMapper([](C2Value) -> C2Value { return uint32_t(1); }));
593
594 add(ConfigMapper(KEY_OPERATING_RATE, C2_PARAMKEY_OPERATING_RATE, "value")
595 .limitTo(D::PARAM | D::CONFIG) // write-only
596 .withMapper(makeFloat));
597 // C2 priorities are inverted
598 add(ConfigMapper(KEY_PRIORITY, C2_PARAMKEY_PRIORITY, "value")
599 .withMappers(negate, negate));
600 // remove when codecs switch to PARAMKEY
601 deprecated(ConfigMapper(KEY_OPERATING_RATE, "ctrl.operating-rate", "value")
602 .withMapper(makeFloat));
603 deprecated(ConfigMapper(KEY_PRIORITY, "ctrl.priority", "value"));
604
605 add(ConfigMapper(KEY_WIDTH, C2_PARAMKEY_PICTURE_SIZE, "width")
606 .limitTo(D::VIDEO | D::IMAGE));
607 add(ConfigMapper(KEY_HEIGHT, C2_PARAMKEY_PICTURE_SIZE, "height")
608 .limitTo(D::VIDEO | D::IMAGE));
609
610 add(ConfigMapper("crop-left", C2_PARAMKEY_CROP_RECT, "left")
611 .limitTo(D::VIDEO | D::IMAGE));
612 add(ConfigMapper("crop-top", C2_PARAMKEY_CROP_RECT, "top")
613 .limitTo(D::VIDEO | D::IMAGE));
614 add(ConfigMapper("crop-width", C2_PARAMKEY_CROP_RECT, "width")
615 .limitTo(D::VIDEO | D::IMAGE));
616 add(ConfigMapper("crop-height", C2_PARAMKEY_CROP_RECT, "height")
617 .limitTo(D::VIDEO | D::IMAGE));
618
619 add(ConfigMapper(KEY_MAX_WIDTH, C2_PARAMKEY_MAX_PICTURE_SIZE, "width")
620 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
621 add(ConfigMapper(KEY_MAX_HEIGHT, C2_PARAMKEY_MAX_PICTURE_SIZE, "height")
622 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
623
624 add(ConfigMapper("csd-0", C2_PARAMKEY_INIT_DATA, "value")
625 .limitTo(D::OUTPUT & D::READ));
626
627 deprecated(ConfigMapper(KEY_HDR10_PLUS_INFO, C2_PARAMKEY_INPUT_HDR10_PLUS_INFO, "value")
628 .limitTo(D::VIDEO & D::PARAM & D::INPUT & (D::CONFIG | D::PARAM)));
629
630 deprecated(ConfigMapper(KEY_HDR10_PLUS_INFO, C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO, "value")
631 .limitTo(D::VIDEO & D::OUTPUT & D::READ));
632
633 add(ConfigMapper(
634 std::string(C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO) + ".type",
635 C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO, "type")
636 .limitTo(D::VIDEO & D::PARAM & D::INPUT & (D::CONFIG | D::PARAM)));
637
638 add(ConfigMapper(
639 std::string(C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO) + ".data",
640 C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO, "data")
641 .limitTo(D::VIDEO & D::PARAM & D::INPUT & (D::CONFIG | D::PARAM)));
642
643 add(ConfigMapper(
644 std::string(C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO) + ".type",
645 C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO, "type")
646 .limitTo(D::VIDEO & D::OUTPUT & D::READ));
647
648 add(ConfigMapper(
649 std::string(C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO) + ".data",
650 C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO, "data")
651 .limitTo(D::VIDEO & D::OUTPUT & D::READ));
652
653 add(ConfigMapper(C2_PARAMKEY_TEMPORAL_LAYERING, C2_PARAMKEY_TEMPORAL_LAYERING, "")
654 .limitTo(D::ENCODER & D::VIDEO & D::OUTPUT));
655
656 // Pixel Format (use local key for actual pixel format as we don't distinguish between
657 // SDK layouts for flexible format and we need the actual SDK color format in the media format)
658 add(ConfigMapper("android._color-format", C2_PARAMKEY_PIXEL_FORMAT, "value")
659 .limitTo((D::VIDEO | D::IMAGE) & D::RAW)
660 .withMappers([](C2Value v) -> C2Value {
661 int32_t value;
662 if (v.get(&value)) {
663 uint32_t result;
664 if (C2Mapper::mapPixelFormatFrameworkToCodec(value, &result)) {
665 return result;
666 }
667 }
668 return C2Value();
669 }, [](C2Value v) -> C2Value {
670 uint32_t value;
671 if (v.get(&value)) {
672 int32_t result;
673 if (C2Mapper::mapPixelFormatCodecToFramework(value, &result)) {
674 return result;
675 }
676 }
677 return C2Value();
678 }));
679
680 add(ConfigMapper(KEY_PIXEL_ASPECT_RATIO_WIDTH, C2_PARAMKEY_PIXEL_ASPECT_RATIO, "width")
681 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
682 add(ConfigMapper(KEY_PIXEL_ASPECT_RATIO_HEIGHT, C2_PARAMKEY_PIXEL_ASPECT_RATIO, "height")
683 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
684
685 add(ConfigMapper(KEY_CHANNEL_COUNT, C2_PARAMKEY_CHANNEL_COUNT, "value")
686 .limitTo(D::AUDIO)); // read back to both formats
687 add(ConfigMapper(KEY_CHANNEL_COUNT, C2_PARAMKEY_CODED_CHANNEL_COUNT, "value")
688 .limitTo(D::AUDIO & D::CODED));
689
690 add(ConfigMapper(KEY_SAMPLE_RATE, C2_PARAMKEY_SAMPLE_RATE, "value")
691 .limitTo(D::AUDIO)); // read back to both port formats
692 add(ConfigMapper(KEY_SAMPLE_RATE, C2_PARAMKEY_CODED_SAMPLE_RATE, "value")
693 .limitTo(D::AUDIO & D::CODED));
694
695 auto pcmEncodingMapper = [](C2Value v) -> C2Value {
696 int32_t value;
697 C2Config::pcm_encoding_t to;
698 if (v.get(&value) && C2Mapper::map(value, &to)) {
699 return to;
700 }
701 return C2Value();
702 };
703 auto pcmEncodingReverse = [](C2Value v) -> C2Value {
704 C2Config::pcm_encoding_t value;
705 int32_t to;
706 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(value)>::type;
707 if (v.get((C2ValueType*)&value) && C2Mapper::map(value, &to)) {
708 return to;
709 }
710 return C2Value();
711 };
712 add(ConfigMapper(KEY_PCM_ENCODING, C2_PARAMKEY_PCM_ENCODING, "value")
713 .limitTo(D::AUDIO)
714 .withMappers(pcmEncodingMapper, pcmEncodingReverse));
715 add(ConfigMapper("android._codec-pcm-encoding", C2_PARAMKEY_PCM_ENCODING, "value")
716 .limitTo(D::AUDIO & D::READ)
717 .withMappers(pcmEncodingMapper, pcmEncodingReverse));
718
719 add(ConfigMapper(KEY_IS_ADTS, C2_PARAMKEY_AAC_PACKAGING, "value")
720 .limitTo(D::AUDIO & D::CODED)
721 .withMappers([](C2Value v) -> C2Value {
722 int32_t value;
723 if (v.get(&value) && value) {
724 return C2Config::AAC_PACKAGING_ADTS;
725 }
726 return C2Value();
727 }, [](C2Value v) -> C2Value {
728 uint32_t value;
729 if (v.get(&value) && value == C2Config::AAC_PACKAGING_ADTS) {
730 return (int32_t)1;
731 }
732 return C2Value();
733 }));
734
735 std::shared_ptr<C2Mapper::ProfileLevelMapper> mapper =
736 C2Mapper::GetProfileLevelMapper(mCodingMediaType);
737
738 add(ConfigMapper(KEY_PROFILE, C2_PARAMKEY_PROFILE_LEVEL, "profile")
739 .limitTo(D::CODED)
740 .withMappers([mapper](C2Value v) -> C2Value {
741 C2Config::profile_t c2 = PROFILE_UNUSED;
742 int32_t sdk;
743 if (mapper && v.get(&sdk) && mapper->mapProfile(sdk, &c2)) {
744 return c2;
745 }
746 return PROFILE_UNUSED;
747 }, [mapper](C2Value v) -> C2Value {
748 C2Config::profile_t c2;
749 int32_t sdk;
750 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
751 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapProfile(c2, &sdk)) {
752 return sdk;
753 }
754 return C2Value();
755 }));
756
757 add(ConfigMapper(KEY_LEVEL, C2_PARAMKEY_PROFILE_LEVEL, "level")
758 .limitTo(D::CODED)
759 .withMappers([mapper](C2Value v) -> C2Value {
760 C2Config::level_t c2 = LEVEL_UNUSED;
761 int32_t sdk;
762 if (mapper && v.get(&sdk) && mapper->mapLevel(sdk, &c2)) {
763 return c2;
764 }
765 return LEVEL_UNUSED;
766 }, [mapper](C2Value v) -> C2Value {
767 C2Config::level_t c2;
768 int32_t sdk;
769 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
770 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapLevel(c2, &sdk)) {
771 return sdk;
772 }
773 return C2Value();
774 }));
775
776 add(ConfigMapper(KEY_AAC_PROFILE, C2_PARAMKEY_PROFILE_LEVEL, "profile")
777 .limitTo(D::AUDIO & D::ENCODER & (D::CONFIG | D::PARAM))
778 .withMapper([mapper](C2Value v) -> C2Value {
779 C2Config::profile_t c2 = PROFILE_UNUSED;
780 int32_t sdk;
781 if (mapper && v.get(&sdk) && mapper->mapProfile(sdk, &c2)) {
782 return c2;
783 }
784 return PROFILE_UNUSED;
785 }));
786
787 // convert to dBFS and add default
788 add(ConfigMapper(KEY_AAC_DRC_TARGET_REFERENCE_LEVEL, C2_PARAMKEY_DRC_TARGET_REFERENCE_LEVEL, "value")
789 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
790 .withMappers([](C2Value v) -> C2Value {
791 int32_t value;
792 if (!v.get(&value) || value < -1) {
793 value = property_get_int32(PROP_DRC_OVERRIDE_REF_LEVEL, DRC_DEFAULT_MOBILE_REF_LEVEL);
794 }
795 return float(-0.25 * c2_min(value, 127));
796 },[](C2Value v) -> C2Value {
797 float value;
798 if (v.get(&value)) {
799 return (int32_t) (-4. * value);
800 }
801 return C2Value();
802 }));
803
804 // convert to 0-1 (%) and add default
805 add(ConfigMapper(KEY_AAC_DRC_ATTENUATION_FACTOR, C2_PARAMKEY_DRC_ATTENUATION_FACTOR, "value")
806 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
807 .withMappers([](C2Value v) -> C2Value {
808 int32_t value;
809 if (!v.get(&value) || value < 0) {
810 value = property_get_int32(PROP_DRC_OVERRIDE_CUT, DRC_DEFAULT_MOBILE_DRC_CUT);
811 }
812 return float(c2_min(value, 127) / 127.);
813 },[](C2Value v) -> C2Value {
814 float value;
815 if (v.get(&value)) {
816 return (int32_t) (value * 127. + 0.5);
817 }
818 else {
819 return C2Value();
820 }
821 }));
822
823 // convert to 0-1 (%) and add default
824 add(ConfigMapper(KEY_AAC_DRC_BOOST_FACTOR, C2_PARAMKEY_DRC_BOOST_FACTOR, "value")
825 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
826 .withMappers([](C2Value v) -> C2Value {
827 int32_t value;
828 if (!v.get(&value) || value < 0) {
829 value = property_get_int32(PROP_DRC_OVERRIDE_BOOST, DRC_DEFAULT_MOBILE_DRC_BOOST);
830 }
831 return float(c2_min(value, 127) / 127.);
832 },[](C2Value v) -> C2Value {
833 float value;
834 if (v.get(&value)) {
835 return (int32_t) (value * 127. + 0.5);
836 }
837 else {
838 return C2Value();
839 }
840 }));
841
842 // convert to compression type and add default
843 add(ConfigMapper(KEY_AAC_DRC_HEAVY_COMPRESSION, C2_PARAMKEY_DRC_COMPRESSION_MODE, "value")
844 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM))
845 .withMapper([](C2Value v) -> C2Value {
846 int32_t value;
847 if (!v.get(&value) || value < 0) {
848 value = property_get_int32(PROP_DRC_OVERRIDE_HEAVY, DRC_DEFAULT_MOBILE_DRC_HEAVY);
849 }
850 return value == 1 ? C2Config::DRC_COMPRESSION_HEAVY : C2Config::DRC_COMPRESSION_LIGHT;
851 }));
852
853 // convert to dBFS and add default
854 add(ConfigMapper(KEY_AAC_ENCODED_TARGET_LEVEL, C2_PARAMKEY_DRC_ENCODED_TARGET_LEVEL, "value")
855 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
856 .withMappers([](C2Value v) -> C2Value {
857 int32_t value;
858 if (!v.get(&value) || value < 0) {
859 value = property_get_int32(PROP_DRC_OVERRIDE_ENC_LEVEL, DRC_DEFAULT_MOBILE_ENC_LEVEL);
860 }
861 return float(-0.25 * c2_min(value, 127));
862 },[](C2Value v) -> C2Value {
863 float value;
864 if (v.get(&value)) {
865 return (int32_t) (-4. * value);
866 }
867 else {
868 return C2Value();
869 }
870 }));
871
872 // convert to effect type (these map to SDK values) and add default
873 add(ConfigMapper(KEY_AAC_DRC_EFFECT_TYPE, C2_PARAMKEY_DRC_EFFECT_TYPE, "value")
874 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
875 .withMappers([](C2Value v) -> C2Value {
876 int32_t value;
877 if (!v.get(&value) || value < -1 || value > 8) {
878 value = property_get_int32(PROP_DRC_OVERRIDE_EFFECT, DRC_DEFAULT_MOBILE_DRC_EFFECT);
879 // ensure value is within range
880 if (value < -1 || value > 8) {
881 value = DRC_DEFAULT_MOBILE_DRC_EFFECT;
882 }
883 }
884 return value;
885 },[](C2Value v) -> C2Value {
886 int32_t value;
887 if (v.get(&value)) {
888 return value;
889 }
890 else {
891 return C2Value();
892 }
893 }));
894
895 // convert to album mode and add default
896 add(ConfigMapper(KEY_AAC_DRC_ALBUM_MODE, C2_PARAMKEY_DRC_ALBUM_MODE, "value")
897 .limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
898 .withMappers([](C2Value v) -> C2Value {
899 int32_t value;
900 if (!v.get(&value) || value < 0 || value > 1) {
901 value = DRC_DEFAULT_MOBILE_DRC_ALBUM;
902 // ensure value is within range
903 if (value < 0 || value > 1) {
904 value = DRC_DEFAULT_MOBILE_DRC_ALBUM;
905 }
906 }
907 return value;
908 },[](C2Value v) -> C2Value {
909 int32_t value;
910 if (v.get(&value)) {
911 return value;
912 }
913 else {
914 return C2Value();
915 }
916 }));
917
918 add(ConfigMapper(KEY_AAC_DRC_OUTPUT_LOUDNESS, C2_PARAMKEY_DRC_OUTPUT_LOUDNESS, "value")
919 .limitTo(D::OUTPUT & D::DECODER & D::READ)
920 .withMappers([](C2Value v) -> C2Value {
921 int32_t value;
922 if (!v.get(&value) || value < -1) {
923 value = DRC_DEFAULT_MOBILE_OUTPUT_LOUDNESS;
924 }
925 return float(-0.25 * c2_min(value, 127));
926 },[](C2Value v) -> C2Value {
927 float value;
928 if (v.get(&value)) {
929 return (int32_t) (-4. * value);
930 }
931 return C2Value();
932 }));
933
934 add(ConfigMapper(KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT, C2_PARAMKEY_MAX_CHANNEL_COUNT, "value")
935 .limitTo(D::AUDIO & (D::CONFIG | D::PARAM | D::READ)));
936
937 add(ConfigMapper(KEY_MAX_OUTPUT_CHANNEL_COUNT, C2_PARAMKEY_MAX_CHANNEL_COUNT, "value")
938 .limitTo(D::AUDIO & (D::CONFIG | D::PARAM | D::READ)));
939
940 add(ConfigMapper(KEY_CHANNEL_MASK, C2_PARAMKEY_CHANNEL_MASK, "value")
941 .limitTo(D::AUDIO & D::DECODER & D::READ));
942
943 add(ConfigMapper(KEY_CHANNEL_MASK, C2_PARAMKEY_CHANNEL_MASK, "value")
944 .limitTo(D::AUDIO & D::ENCODER & D::CONFIG));
945
946 add(ConfigMapper(KEY_AAC_SBR_MODE, C2_PARAMKEY_AAC_SBR_MODE, "value")
947 .limitTo(D::AUDIO & D::ENCODER & (D::CONFIG | D::PARAM | D::READ))
948 .withMapper([](C2Value v) -> C2Value {
949 int32_t value;
950 if (!v.get(&value) || value < 0) {
951 return C2Config::AAC_SBR_AUTO;
952 }
953 switch (value) {
954 case 0: return C2Config::AAC_SBR_OFF;
955 case 1: return C2Config::AAC_SBR_SINGLE_RATE;
956 case 2: return C2Config::AAC_SBR_DUAL_RATE;
957 default: return C2Config::AAC_SBR_AUTO + 1; // invalid value
958 }
959 }));
960
961 add(ConfigMapper("android._encoding-quality-level", C2_PARAMKEY_ENCODING_QUALITY_LEVEL, "value")
962 .limitTo(D::ENCODER & (D::CONFIG | D::PARAM)));
963 add(ConfigMapper(KEY_QUALITY, C2_PARAMKEY_QUALITY, "value")
964 .limitTo(D::ENCODER & (D::CONFIG | D::PARAM)));
965 add(ConfigMapper(KEY_FLAC_COMPRESSION_LEVEL, C2_PARAMKEY_COMPLEXITY, "value")
966 .limitTo(D::AUDIO & D::ENCODER));
967 add(ConfigMapper(KEY_COMPLEXITY, C2_PARAMKEY_COMPLEXITY, "value")
968 .limitTo(D::ENCODER & (D::CONFIG | D::PARAM)));
969
970 add(ConfigMapper(KEY_GRID_COLUMNS, C2_PARAMKEY_TILE_LAYOUT, "columns")
971 .limitTo(D::IMAGE));
972 add(ConfigMapper(KEY_GRID_ROWS, C2_PARAMKEY_TILE_LAYOUT, "rows")
973 .limitTo(D::IMAGE));
974 add(ConfigMapper(KEY_TILE_WIDTH, C2_PARAMKEY_TILE_LAYOUT, "tile.width")
975 .limitTo(D::IMAGE));
976 add(ConfigMapper(KEY_TILE_HEIGHT, C2_PARAMKEY_TILE_LAYOUT, "tile.height")
977 .limitTo(D::IMAGE));
978
979 add(ConfigMapper(KEY_LATENCY, C2_PARAMKEY_PIPELINE_DELAY_REQUEST, "value")
980 .limitTo(D::VIDEO & D::ENCODER));
981
982 add(ConfigMapper(C2_PARAMKEY_INPUT_TIME_STRETCH, C2_PARAMKEY_INPUT_TIME_STRETCH, "value"));
983
984 add(ConfigMapper(KEY_LOW_LATENCY, C2_PARAMKEY_LOW_LATENCY_MODE, "value")
985 .limitTo(D::DECODER & (D::CONFIG | D::PARAM))
986 .withMapper([](C2Value v) -> C2Value {
987 int32_t value = 0;
988 (void)v.get(&value);
989 return value == 0 ? C2_FALSE : C2_TRUE;
990 }));
991
992 add(ConfigMapper("android._trigger-tunnel-peek", C2_PARAMKEY_TUNNEL_START_RENDER, "value")
993 .limitTo(D::PARAM & D::VIDEO & D::DECODER)
994 .withMapper([](C2Value v) -> C2Value {
995 int32_t value = 0;
996 (void)v.get(&value);
997 return value == 0 ? C2_FALSE : C2_TRUE;
998 }));
999
1000 add(ConfigMapper("android._tunnel-peek-set-legacy", C2_PARAMKEY_TUNNEL_PEEK_MODE, "value")
1001 .limitTo(D::PARAM & D::VIDEO & D::DECODER)
1002 .withMapper([](C2Value v) -> C2Value {
1003 int32_t value = 0;
1004 (void)v.get(&value);
1005 return value == 0
1006 ? C2Value(C2PlatformConfig::SPECIFIED_PEEK)
1007 : C2Value(C2PlatformConfig::UNSPECIFIED_PEEK);
1008 }));
1009
1010 add(ConfigMapper(KEY_VIDEO_QP_AVERAGE, C2_PARAMKEY_AVERAGE_QP, "value")
1011 .limitTo(D::ENCODER & D::VIDEO & D::READ));
1012
1013 add(ConfigMapper(KEY_PICTURE_TYPE, C2_PARAMKEY_PICTURE_TYPE, "value")
1014 .limitTo(D::ENCODER & D::VIDEO & D::READ)
1015 .withMappers([](C2Value v) -> C2Value {
1016 int32_t sdk;
1017 C2Config::picture_type_t c2;
1018 if (v.get(&sdk) && C2Mapper::map(sdk, &c2)) {
1019 return C2Value(c2);
1020 }
1021 return C2Value();
1022 }, [](C2Value v) -> C2Value {
1023 C2Config::picture_type_t c2;
1024 int32_t sdk = PICTURE_TYPE_UNKNOWN;
1025 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
1026 if (v.get((C2ValueType*)&c2) && C2Mapper::map(c2, &sdk)) {
1027 return sdk;
1028 }
1029 return C2Value();
1030 }));
1031
1032 /* still to do
1033 not yet used by MediaCodec, but defined as MediaFormat
1034 KEY_AUDIO_SESSION_ID // we use "audio-hw-sync"
1035 KEY_OUTPUT_REORDER_DEPTH
1036 */
1037 }
1038
initialize(const std::shared_ptr<C2ParamReflector> & reflector,const std::shared_ptr<Codec2Client::Configurable> & configurable)1039 status_t CCodecConfig::initialize(
1040 const std::shared_ptr<C2ParamReflector> &reflector,
1041 const std::shared_ptr<Codec2Client::Configurable> &configurable) {
1042 C2ComponentDomainSetting domain(C2Component::DOMAIN_OTHER);
1043 C2ComponentKindSetting kind(C2Component::KIND_OTHER);
1044
1045 std::vector<std::unique_ptr<C2Param>> queried;
1046 c2_status_t c2err = configurable->query({ &domain, &kind }, {}, C2_DONT_BLOCK, &queried);
1047 if (c2err != C2_OK) {
1048 ALOGD("Query domain & kind failed => %s", asString(c2err));
1049 // TEMP: determine kind from component name
1050 if (kind.value == C2Component::KIND_OTHER) {
1051 if (configurable->getName().find("encoder") != std::string::npos) {
1052 kind.value = C2Component::KIND_ENCODER;
1053 } else if (configurable->getName().find("decoder") != std::string::npos) {
1054 kind.value = C2Component::KIND_DECODER;
1055 }
1056 }
1057
1058 // TEMP: determine domain from media type (port (preferred) or stream #0)
1059 if (domain.value == C2Component::DOMAIN_OTHER) {
1060 AString mediaType = QueryMediaType(true /* input */, configurable);
1061 if (mediaType.startsWith("audio/")) {
1062 domain.value = C2Component::DOMAIN_AUDIO;
1063 } else if (mediaType.startsWith("video/")) {
1064 domain.value = C2Component::DOMAIN_VIDEO;
1065 } else if (mediaType.startsWith("image/")) {
1066 domain.value = C2Component::DOMAIN_IMAGE;
1067 }
1068 }
1069 }
1070
1071 mDomain = (domain.value == C2Component::DOMAIN_VIDEO ? Domain::IS_VIDEO :
1072 domain.value == C2Component::DOMAIN_IMAGE ? Domain::IS_IMAGE :
1073 domain.value == C2Component::DOMAIN_AUDIO ? Domain::IS_AUDIO : Domain::OTHER_DOMAIN)
1074 | (kind.value == C2Component::KIND_DECODER ? Domain::IS_DECODER :
1075 kind.value == C2Component::KIND_ENCODER ? Domain::IS_ENCODER : Domain::OTHER_KIND);
1076
1077 mInputDomain = Domain(((mDomain & IS_DECODER) ? IS_CODED : IS_RAW) | IS_INPUT);
1078 mOutputDomain = Domain(((mDomain & IS_ENCODER) ? IS_CODED : IS_RAW) | IS_OUTPUT);
1079
1080 ALOGV("domain is %#x (%u %u)", mDomain, domain.value, kind.value);
1081
1082 std::vector<C2Param::Index> paramIndices;
1083 switch (kind.value) {
1084 case C2Component::KIND_DECODER:
1085 mCodingMediaType = QueryMediaType(true /* input */, configurable).c_str();
1086 break;
1087 case C2Component::KIND_ENCODER:
1088 mCodingMediaType = QueryMediaType(false /* input */, configurable).c_str();
1089 break;
1090 default:
1091 mCodingMediaType = "";
1092 }
1093
1094 c2err = configurable->querySupportedParams(&mParamDescs);
1095 if (c2err != C2_OK) {
1096 ALOGD("Query supported params failed after returning %zu values => %s",
1097 mParamDescs.size(), asString(c2err));
1098 return UNKNOWN_ERROR;
1099 }
1100 for (const std::shared_ptr<C2ParamDescriptor> &desc : mParamDescs) {
1101 mSupportedIndices.emplace(desc->index());
1102 }
1103
1104 mReflector = reflector;
1105 if (mReflector == nullptr) {
1106 ALOGE("Null param reflector");
1107 return UNKNOWN_ERROR;
1108 }
1109
1110 // enumerate all fields
1111 mParamUpdater = std::make_shared<ReflectedParamUpdater>();
1112 mParamUpdater->clear();
1113 mParamUpdater->supportWholeParam(
1114 C2_PARAMKEY_TEMPORAL_LAYERING, C2StreamTemporalLayeringTuning::CORE_INDEX);
1115 mParamUpdater->addParamDesc(mReflector, mParamDescs);
1116
1117 // TEMP: add some standard fields even if not reflected
1118 if (kind.value == C2Component::KIND_ENCODER) {
1119 mParamUpdater->addStandardParam<C2StreamInitDataInfo::output>(C2_PARAMKEY_INIT_DATA);
1120 }
1121 if (domain.value == C2Component::DOMAIN_IMAGE || domain.value == C2Component::DOMAIN_VIDEO) {
1122 if (kind.value != C2Component::KIND_ENCODER) {
1123 addLocalParam<C2StreamPictureSizeInfo::output>(C2_PARAMKEY_PICTURE_SIZE);
1124 addLocalParam<C2StreamCropRectInfo::output>(C2_PARAMKEY_CROP_RECT);
1125 addLocalParam(
1126 new C2StreamPixelAspectRatioInfo::output(0u, 1u, 1u),
1127 C2_PARAMKEY_PIXEL_ASPECT_RATIO);
1128 addLocalParam(new C2StreamRotationInfo::output(0u, 0), C2_PARAMKEY_ROTATION);
1129 addLocalParam(
1130 new C2StreamColorAspectsTuning::output(0u),
1131 C2_PARAMKEY_DEFAULT_COLOR_ASPECTS);
1132 addLocalParam<C2StreamDataSpaceInfo::output>(C2_PARAMKEY_DATA_SPACE);
1133 addLocalParam<C2StreamHdrStaticInfo::output>(C2_PARAMKEY_HDR_STATIC_INFO);
1134 addLocalParam(
1135 new C2StreamSurfaceScalingInfo::output(0u, VIDEO_SCALING_MODE_SCALE_TO_FIT),
1136 C2_PARAMKEY_SURFACE_SCALING_MODE);
1137 } else {
1138 addLocalParam(new C2StreamColorAspectsInfo::input(0u), C2_PARAMKEY_COLOR_ASPECTS);
1139
1140 if (domain.value == C2Component::DOMAIN_VIDEO) {
1141 addLocalParam(new C2AndroidStreamAverageBlockQuantizationInfo::output(0u, 0),
1142 C2_PARAMKEY_AVERAGE_QP);
1143 addLocalParam(new C2StreamPictureTypeInfo::output(0u, 0),
1144 C2_PARAMKEY_PICTURE_TYPE);
1145 }
1146 }
1147 }
1148
1149 initializeStandardParams();
1150
1151 // subscribe to all supported standard (exposed) params
1152 // TODO: limit this to params that are actually in the domain
1153 std::vector<std::string> formatKeys = mStandardParams->getPathsForDomain(Domain(1 << 30));
1154 std::vector<C2Param::Index> indices;
1155 mParamUpdater->getParamIndicesForKeys(formatKeys, &indices);
1156 mSubscribedIndices.insert(indices.begin(), indices.end());
1157
1158 // also subscribe to some non-SDK standard parameters
1159 // for number of input/output buffers
1160 mSubscribedIndices.emplace(C2PortSuggestedBufferCountTuning::input::PARAM_TYPE);
1161 mSubscribedIndices.emplace(C2PortSuggestedBufferCountTuning::output::PARAM_TYPE);
1162 mSubscribedIndices.emplace(C2ActualPipelineDelayTuning::PARAM_TYPE);
1163 mSubscribedIndices.emplace(C2PortActualDelayTuning::input::PARAM_TYPE);
1164 mSubscribedIndices.emplace(C2PortActualDelayTuning::output::PARAM_TYPE);
1165 // for output buffer array allocation
1166 mSubscribedIndices.emplace(C2StreamMaxBufferSizeInfo::output::PARAM_TYPE);
1167 // init data (CSD)
1168 mSubscribedIndices.emplace(C2StreamInitDataInfo::output::PARAM_TYPE);
1169
1170 for (const std::shared_ptr<C2ParamDescriptor> &desc : mParamDescs) {
1171 if (desc->index().isVendor()) {
1172 std::vector<std::string> keys;
1173 mParamUpdater->getKeysForParamIndex(desc->index(), &keys);
1174 for (const std::string &key : keys) {
1175 mVendorParams.insert_or_assign(key, desc);
1176 }
1177 }
1178 }
1179
1180 // Parameters that are not subscribed initially, but can be subscribed
1181 // upon explicit request.
1182 static const std::initializer_list<C2Param::Index> kOptionalParams = {
1183 C2AndroidStreamAverageBlockQuantizationInfo::output::PARAM_TYPE,
1184 C2StreamPictureTypeInfo::output::PARAM_TYPE,
1185 };
1186 for (const C2Param::Index &index : kOptionalParams) {
1187 mSubscribedIndices.erase(index);
1188 }
1189 subscribeToConfigUpdate(configurable, {}, C2_MAY_BLOCK);
1190
1191 return OK;
1192 }
1193
subscribeToConfigUpdate(const std::shared_ptr<Codec2Client::Configurable> & configurable,const std::vector<C2Param::Index> & indices,c2_blocking_t blocking)1194 status_t CCodecConfig::subscribeToConfigUpdate(
1195 const std::shared_ptr<Codec2Client::Configurable> &configurable,
1196 const std::vector<C2Param::Index> &indices,
1197 c2_blocking_t blocking) {
1198 static const int32_t kProductFirstApiLevel =
1199 base::GetIntProperty<int32_t>("ro.product.first_api_level", 0);
1200 static const int32_t kBoardApiLevel =
1201 base::GetIntProperty<int32_t>("ro.board.first_api_level", 0);
1202 static const int32_t kFirstApiLevel =
1203 (kBoardApiLevel != 0) ? kBoardApiLevel : kProductFirstApiLevel;
1204 mSubscribedIndices.insert(indices.begin(), indices.end());
1205 if (mSubscribedIndices.size() != mSubscribedIndicesSize
1206 && kFirstApiLevel >= __ANDROID_API_T__) {
1207 std::vector<uint32_t> indicesVector;
1208 for (C2Param::Index ix : mSubscribedIndices) {
1209 indicesVector.push_back(ix);
1210 }
1211 std::unique_ptr<C2SubscribedParamIndicesTuning> subscribeTuning =
1212 C2SubscribedParamIndicesTuning::AllocUnique(indicesVector);
1213 std::vector<std::unique_ptr<C2SettingResult>> results;
1214 c2_status_t c2Err = configurable->config({ subscribeTuning.get() }, blocking, &results);
1215 if (c2Err != C2_OK && c2Err != C2_BAD_INDEX) {
1216 ALOGD("Failed to subscribe to parameters => %s", asString(c2Err));
1217 // TODO: error
1218 }
1219 ALOGV("Subscribed to %zu params", mSubscribedIndices.size());
1220 mSubscribedIndicesSize = mSubscribedIndices.size();
1221 }
1222 #if defined(LOG_NDEBUG) && !LOG_NDEBUG
1223 ALOGV("subscribed to %zu params:", mSubscribedIndices.size());
1224 std::stringstream ss;
1225 for (const C2Param::Index &index : mSubscribedIndices) {
1226 ss << index << " ";
1227 if (ss.str().length() > 70) {
1228 ALOGV("%s", ss.str().c_str());
1229 std::stringstream().swap(ss);
1230 }
1231 }
1232 if (!ss.str().empty()) {
1233 ALOGV("%s", ss.str().c_str());
1234 }
1235 #endif
1236 return OK;
1237 }
1238
queryConfiguration(const std::shared_ptr<Codec2Client::Configurable> & configurable)1239 status_t CCodecConfig::queryConfiguration(
1240 const std::shared_ptr<Codec2Client::Configurable> &configurable) {
1241 // query all subscribed parameters
1242 std::vector<C2Param::Index> indices(mSubscribedIndices.begin(), mSubscribedIndices.end());
1243 std::vector<std::unique_ptr<C2Param>> queried;
1244 c2_status_t c2Err = configurable->query({}, indices, C2_MAY_BLOCK, &queried);
1245 if (c2Err != OK) {
1246 ALOGI("query failed after returning %zu values (%s)", queried.size(), asString(c2Err));
1247 // TODO: error
1248 }
1249
1250 updateConfiguration(queried, ALL);
1251 return OK;
1252 }
1253
updateConfiguration(std::vector<std::unique_ptr<C2Param>> & configUpdate,Domain domain)1254 bool CCodecConfig::updateConfiguration(
1255 std::vector<std::unique_ptr<C2Param>> &configUpdate, Domain domain) {
1256 ALOGV("updating configuration with %zu params", configUpdate.size());
1257 bool changed = false;
1258 for (std::unique_ptr<C2Param> &p : configUpdate) {
1259 if (p && *p) {
1260 // Allow unsubscribed vendor parameters to go through --- it may be
1261 // later handled by the format shaper.
1262 if (!p->isVendor() && mSubscribedIndices.count(p->index()) == 0) {
1263 ALOGV("updateConfiguration: skipped unsubscribed param %08x", p->index());
1264 continue;
1265 }
1266 auto insertion = mCurrentConfig.emplace(p->index(), nullptr);
1267 if (insertion.second || *insertion.first->second != *p) {
1268 if (mSupportedIndices.count(p->index()) || mLocalParams.count(p->index())) {
1269 // only track changes in supported (reflected or local) indices
1270 changed = true;
1271 } else {
1272 ALOGV("an unlisted config was %s: %#x",
1273 insertion.second ? "added" : "updated", p->index());
1274 }
1275 }
1276 insertion.first->second = std::move(p);
1277 }
1278 }
1279 if (mInputSurface
1280 && (domain & mOutputDomain)
1281 && mInputSurfaceDataspace != mInputSurface->getDataspace()) {
1282 changed = true;
1283 mInputSurfaceDataspace = mInputSurface->getDataspace();
1284 }
1285
1286 ALOGV("updated configuration has %zu params (%s)", mCurrentConfig.size(),
1287 changed ? "CHANGED" : "no change");
1288 if (changed) {
1289 return updateFormats(domain);
1290 }
1291 return false;
1292 }
1293
updateFormats(Domain domain)1294 bool CCodecConfig::updateFormats(Domain domain) {
1295 // get addresses of params in the current config
1296 std::vector<C2Param*> paramPointers;
1297 for (const auto &it : mCurrentConfig) {
1298 paramPointers.push_back(it.second.get());
1299 }
1300
1301 ReflectedParamUpdater::Dict reflected = mParamUpdater->getParams(paramPointers);
1302 std::string config = reflected.debugString();
1303 std::set<std::string> configLines;
1304 std::string diff;
1305 for (size_t start = 0; start != std::string::npos; ) {
1306 size_t end = config.find('\n', start);
1307 size_t count = (end == std::string::npos)
1308 ? std::string::npos
1309 : end - start + 1;
1310 std::string line = config.substr(start, count);
1311 configLines.insert(line);
1312 if (mLastConfig.count(line) == 0) {
1313 diff.append(line);
1314 }
1315 start = (end == std::string::npos) ? std::string::npos : end + 1;
1316 }
1317 if (!diff.empty()) {
1318 ALOGD("c2 config diff is %s", diff.c_str());
1319 }
1320 mLastConfig.swap(configLines);
1321
1322 bool changed = false;
1323 if (domain & mInputDomain) {
1324 sp<AMessage> oldFormat = mInputFormat;
1325 mInputFormat = mInputFormat->dup(); // trigger format changed
1326 mInputFormat->extend(getFormatForDomain(reflected, mInputDomain));
1327 if (mInputFormat->countEntries() != oldFormat->countEntries()
1328 || mInputFormat->changesFrom(oldFormat)->countEntries() > 0) {
1329 changed = true;
1330 } else {
1331 mInputFormat = oldFormat; // no change
1332 }
1333 }
1334 if (domain & mOutputDomain) {
1335 sp<AMessage> oldFormat = mOutputFormat;
1336 mOutputFormat = mOutputFormat->dup(); // trigger output format changed
1337 mOutputFormat->extend(getFormatForDomain(reflected, mOutputDomain));
1338 if (mOutputFormat->countEntries() != oldFormat->countEntries()
1339 || mOutputFormat->changesFrom(oldFormat)->countEntries() > 0) {
1340 changed = true;
1341 } else {
1342 mOutputFormat = oldFormat; // no change
1343 }
1344 }
1345 ALOGV_IF(changed, "format(s) changed");
1346 return changed;
1347 }
1348
getFormatForDomain(const ReflectedParamUpdater::Dict & reflected,Domain portDomain) const1349 sp<AMessage> CCodecConfig::getFormatForDomain(
1350 const ReflectedParamUpdater::Dict &reflected,
1351 Domain portDomain) const {
1352 sp<AMessage> msg = new AMessage;
1353 for (const auto &[key, mappers] : mStandardParams->getKeys()) {
1354 for (const ConfigMapper &cm : mappers) {
1355 if ((cm.domain() & portDomain) == 0 // input-output-coded-raw
1356 || (cm.domain() & mDomain) != mDomain // component domain + kind (these must match)
1357 || (cm.domain() & IS_READ) == 0) {
1358 continue;
1359 }
1360 auto it = reflected.find(cm.path());
1361 if (it == reflected.end()) {
1362 continue;
1363 }
1364 C2Value c2Value;
1365 sp<ABuffer> bufValue;
1366 AString strValue;
1367 AMessage::ItemData item;
1368 if (it->second.find(&c2Value)) {
1369 item = cm.mapToMessage(c2Value);
1370 } else if (it->second.find(&bufValue)) {
1371 item.set(bufValue);
1372 } else if (it->second.find(&strValue)) {
1373 item.set(strValue);
1374 } else {
1375 ALOGD("unexpected untyped query value for key: %s", cm.path().c_str());
1376 continue;
1377 }
1378 msg->setItem(key.c_str(), item);
1379 }
1380 }
1381
1382 bool input = (portDomain & Domain::IS_INPUT);
1383 std::vector<std::string> vendorKeys;
1384 for (const auto &[key, value] : reflected) {
1385 auto it = mVendorParams.find(key);
1386 if (it == mVendorParams.end()) {
1387 continue;
1388 }
1389 C2Param::Index index = it->second->index();
1390 if (mSubscribedIndices.count(index) == 0) {
1391 continue;
1392 }
1393 // For vendor parameters, we only care about direction
1394 if ((input && !index.forInput())
1395 || (!input && !index.forOutput())) {
1396 continue;
1397 }
1398 C2Value c2Value;
1399 sp<ABuffer> bufValue;
1400 AString strValue;
1401 AMessage::ItemData item;
1402 if (value.find(&c2Value)) {
1403 C2ValueToMessageItem(c2Value, item);
1404 } else if (value.find(&bufValue)) {
1405 item.set(bufValue);
1406 } else if (value.find(&strValue)) {
1407 item.set(strValue);
1408 } else {
1409 ALOGD("unexpected untyped query value for key: %s", key.c_str());
1410 continue;
1411 }
1412 msg->setItem(key.c_str(), item);
1413 }
1414
1415 { // convert from Codec 2.0 rect to MediaFormat rect and add crop rect if not present
1416 int32_t left, top, width, height;
1417 if (msg->findInt32("crop-left", &left) && msg->findInt32("crop-width", &width)
1418 && msg->findInt32("crop-top", &top) && msg->findInt32("crop-height", &height)
1419 && left >= 0 && width >=0 && width <= INT32_MAX - left
1420 && top >= 0 && height >=0 && height <= INT32_MAX - top) {
1421 msg->removeEntryAt(msg->findEntryByName("crop-left"));
1422 msg->removeEntryAt(msg->findEntryByName("crop-top"));
1423 msg->removeEntryAt(msg->findEntryByName("crop-width"));
1424 msg->removeEntryAt(msg->findEntryByName("crop-height"));
1425 msg->setRect("crop", left, top, left + width - 1, top + height - 1);
1426 } else if (msg->findInt32("width", &width) && msg->findInt32("height", &height)) {
1427 msg->setRect("crop", 0, 0, width - 1, height - 1);
1428 }
1429 }
1430
1431 { // convert temporal layering to schema
1432 sp<ABuffer> tmp;
1433 if (msg->findBuffer(C2_PARAMKEY_TEMPORAL_LAYERING, &tmp) && tmp != nullptr) {
1434 C2StreamTemporalLayeringTuning *layering =
1435 C2StreamTemporalLayeringTuning::From(C2Param::From(tmp->data(), tmp->size()));
1436 if (layering && layering->m.layerCount > 0
1437 && layering->m.bLayerCount < layering->m.layerCount) {
1438 // check if this is webrtc compatible
1439 AString mime;
1440 if (msg->findString(KEY_MIME, &mime) &&
1441 mime.equalsIgnoreCase(MIMETYPE_VIDEO_VP8) &&
1442 layering->m.bLayerCount == 0 &&
1443 (layering->m.layerCount == 1
1444 || (layering->m.layerCount == 2
1445 && layering->flexCount() >= 1
1446 && layering->m.bitrateRatios[0] == .6f)
1447 || (layering->m.layerCount == 3
1448 && layering->flexCount() >= 2
1449 && layering->m.bitrateRatios[0] == .4f
1450 && layering->m.bitrateRatios[1] == .6f)
1451 || (layering->m.layerCount == 4
1452 && layering->flexCount() >= 3
1453 && layering->m.bitrateRatios[0] == .25f
1454 && layering->m.bitrateRatios[1] == .4f
1455 && layering->m.bitrateRatios[2] == .6f))) {
1456 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1457 "webrtc.vp8.%u-layer", layering->m.layerCount));
1458 } else if (layering->m.bLayerCount) {
1459 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1460 "android.generic.%u+%u",
1461 layering->m.layerCount - layering->m.bLayerCount,
1462 layering->m.bLayerCount));
1463 } else if (layering->m.bLayerCount) {
1464 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1465 "android.generic.%u", layering->m.layerCount));
1466 }
1467 }
1468 msg->removeEntryAt(msg->findEntryByName(C2_PARAMKEY_TEMPORAL_LAYERING));
1469 }
1470 }
1471
1472 // Remove KEY_AAC_SBR_MODE from SDK message if it is outside supported range
1473 // as SDK doesn't have a way to signal default sbr mode based on profile and
1474 // requires that the key isn't present in format to signal that
1475 int sbrMode;
1476 if (msg->findInt32(KEY_AAC_SBR_MODE, &sbrMode) && (sbrMode < 0 || sbrMode > 2)) {
1477 msg->removeEntryAt(msg->findEntryByName(KEY_AAC_SBR_MODE));
1478 }
1479
1480 { // convert color info
1481 // move default color to color aspect if not read from the component
1482 int32_t tmp;
1483 int32_t range;
1484 if (msg->findInt32("default-color-range", &range)) {
1485 if (!msg->findInt32(KEY_COLOR_RANGE, &tmp)) {
1486 msg->setInt32(KEY_COLOR_RANGE, range);
1487 }
1488 msg->removeEntryAt(msg->findEntryByName("default-color-range"));
1489 }
1490 int32_t transfer;
1491 if (msg->findInt32("default-color-transfer", &transfer)) {
1492 if (!msg->findInt32(KEY_COLOR_TRANSFER, &tmp)) {
1493 msg->setInt32(KEY_COLOR_TRANSFER, transfer);
1494 }
1495 msg->removeEntryAt(msg->findEntryByName("default-color-transfer"));
1496 }
1497 C2Color::primaries_t primaries;
1498 if (msg->findInt32("default-color-primaries", (int32_t*)&primaries)) {
1499 if (!msg->findInt32("color-primaries", &tmp)) {
1500 msg->setInt32("color-primaries", primaries);
1501 }
1502 msg->removeEntryAt(msg->findEntryByName("default-color-primaries"));
1503 }
1504 C2Color::matrix_t matrix;
1505 if (msg->findInt32("default-color-matrix", (int32_t*)&matrix)) {
1506 if (!msg->findInt32("color-matrix", &tmp)) {
1507 msg->setInt32("color-matrix", matrix);
1508 }
1509 msg->removeEntryAt(msg->findEntryByName("default-color-matrix"));
1510 }
1511
1512 if (msg->findInt32("color-primaries", (int32_t*)&primaries)
1513 && msg->findInt32("color-matrix", (int32_t*)&matrix)) {
1514 int32_t standard;
1515
1516 if (C2Mapper::map(primaries, matrix, &standard)) {
1517 msg->setInt32(KEY_COLOR_STANDARD, standard);
1518 }
1519
1520 msg->removeEntryAt(msg->findEntryByName("color-primaries"));
1521 msg->removeEntryAt(msg->findEntryByName("color-matrix"));
1522 }
1523
1524 // calculate dataspace for raw graphic buffers if not specified by component, or if
1525 // using surface with unspecified aspects (as those must be defaulted which may change
1526 // the dataspace)
1527 if ((portDomain & IS_RAW) && (mDomain & (IS_IMAGE | IS_VIDEO))) {
1528 android_dataspace dataspace;
1529 ColorAspects aspects = {
1530 ColorAspects::RangeUnspecified, ColorAspects::PrimariesUnspecified,
1531 ColorAspects::TransferUnspecified, ColorAspects::MatrixUnspecified
1532 };
1533 ColorUtils::getColorAspectsFromFormat(msg, aspects);
1534 ColorAspects origAspects = aspects;
1535 if (mUsingSurface) {
1536 // get image size (default to HD)
1537 int32_t width = 1280;
1538 int32_t height = 720;
1539 int32_t left, top, right, bottom;
1540 if (msg->findRect("crop", &left, &top, &right, &bottom)) {
1541 width = right - left + 1;
1542 height = bottom - top + 1;
1543 } else {
1544 (void)msg->findInt32(KEY_WIDTH, &width);
1545 (void)msg->findInt32(KEY_HEIGHT, &height);
1546 }
1547 ColorUtils::setDefaultCodecColorAspectsIfNeeded(aspects, width, height);
1548 ColorUtils::setColorAspectsIntoFormat(aspects, msg);
1549 }
1550
1551 if (!msg->findInt32("android._dataspace", (int32_t*)&dataspace)
1552 || aspects.mRange != origAspects.mRange
1553 || aspects.mPrimaries != origAspects.mPrimaries
1554 || aspects.mTransfer != origAspects.mTransfer
1555 || aspects.mMatrixCoeffs != origAspects.mMatrixCoeffs) {
1556 dataspace = ColorUtils::getDataSpaceForColorAspects(aspects, true /* mayExpand */);
1557 msg->setInt32("android._dataspace", dataspace);
1558 }
1559 }
1560
1561 if (mInputSurface) {
1562 android_dataspace dataspace = mInputSurface->getDataspace();
1563 ColorUtils::convertDataSpaceToV0(dataspace);
1564 int32_t standard;
1565 ColorUtils::getColorConfigFromDataSpace(dataspace, &range, &standard, &transfer);
1566 if (range != 0) {
1567 msg->setInt32(KEY_COLOR_RANGE, range);
1568 }
1569 if (standard != 0) {
1570 msg->setInt32(KEY_COLOR_STANDARD, standard);
1571 }
1572 if (transfer != 0) {
1573 msg->setInt32(KEY_COLOR_TRANSFER, transfer);
1574 }
1575 msg->setInt32("android._dataspace", dataspace);
1576 }
1577
1578 // HDR static info
1579
1580 C2HdrStaticMetadataStruct hdr;
1581 if (msg->findFloat("smpte2086.red.x", &hdr.mastering.red.x)
1582 && msg->findFloat("smpte2086.red.y", &hdr.mastering.red.y)
1583 && msg->findFloat("smpte2086.green.x", &hdr.mastering.green.x)
1584 && msg->findFloat("smpte2086.green.y", &hdr.mastering.green.y)
1585 && msg->findFloat("smpte2086.blue.x", &hdr.mastering.blue.x)
1586 && msg->findFloat("smpte2086.blue.y", &hdr.mastering.blue.y)
1587 && msg->findFloat("smpte2086.white.x", &hdr.mastering.white.x)
1588 && msg->findFloat("smpte2086.white.y", &hdr.mastering.white.y)
1589 && msg->findFloat("smpte2086.max-luminance", &hdr.mastering.maxLuminance)
1590 && msg->findFloat("smpte2086.min-luminance", &hdr.mastering.minLuminance)
1591 && msg->findFloat("cta861.max-cll", &hdr.maxCll)
1592 && msg->findFloat("cta861.max-fall", &hdr.maxFall)) {
1593 if (hdr.mastering.red.x >= 0 && hdr.mastering.red.x <= 1
1594 && hdr.mastering.red.y >= 0 && hdr.mastering.red.y <= 1
1595 && hdr.mastering.green.x >= 0 && hdr.mastering.green.x <= 1
1596 && hdr.mastering.green.y >= 0 && hdr.mastering.green.y <= 1
1597 && hdr.mastering.blue.x >= 0 && hdr.mastering.blue.x <= 1
1598 && hdr.mastering.blue.y >= 0 && hdr.mastering.blue.y <= 1
1599 && hdr.mastering.white.x >= 0 && hdr.mastering.white.x <= 1
1600 && hdr.mastering.white.y >= 0 && hdr.mastering.white.y <= 1
1601 && hdr.mastering.maxLuminance >= 0 && hdr.mastering.maxLuminance <= 65535
1602 && hdr.mastering.minLuminance >= 0 && hdr.mastering.minLuminance <= 6.5535
1603 && hdr.maxCll >= 0 && hdr.maxCll <= 65535
1604 && hdr.maxFall >= 0 && hdr.maxFall <= 65535) {
1605 HDRStaticInfo meta;
1606 meta.mID = meta.kType1;
1607 meta.sType1.mR.x = hdr.mastering.red.x / 0.00002 + 0.5;
1608 meta.sType1.mR.y = hdr.mastering.red.y / 0.00002 + 0.5;
1609 meta.sType1.mG.x = hdr.mastering.green.x / 0.00002 + 0.5;
1610 meta.sType1.mG.y = hdr.mastering.green.y / 0.00002 + 0.5;
1611 meta.sType1.mB.x = hdr.mastering.blue.x / 0.00002 + 0.5;
1612 meta.sType1.mB.y = hdr.mastering.blue.y / 0.00002 + 0.5;
1613 meta.sType1.mW.x = hdr.mastering.white.x / 0.00002 + 0.5;
1614 meta.sType1.mW.y = hdr.mastering.white.y / 0.00002 + 0.5;
1615 meta.sType1.mMaxDisplayLuminance = hdr.mastering.maxLuminance + 0.5;
1616 meta.sType1.mMinDisplayLuminance = hdr.mastering.minLuminance / 0.0001 + 0.5;
1617 meta.sType1.mMaxContentLightLevel = hdr.maxCll + 0.5;
1618 meta.sType1.mMaxFrameAverageLightLevel = hdr.maxFall + 0.5;
1619 msg->setBuffer(KEY_HDR_STATIC_INFO, ABuffer::CreateAsCopy(&meta, sizeof(meta)));
1620 } else {
1621 ALOGD("found invalid HDR static metadata %s", msg->debugString(8).c_str());
1622 }
1623 msg->removeEntryAt(msg->findEntryByName("smpte2086.red.x"));
1624 msg->removeEntryAt(msg->findEntryByName("smpte2086.red.y"));
1625 msg->removeEntryAt(msg->findEntryByName("smpte2086.green.x"));
1626 msg->removeEntryAt(msg->findEntryByName("smpte2086.green.y"));
1627 msg->removeEntryAt(msg->findEntryByName("smpte2086.blue.x"));
1628 msg->removeEntryAt(msg->findEntryByName("smpte2086.blue.y"));
1629 msg->removeEntryAt(msg->findEntryByName("smpte2086.white.x"));
1630 msg->removeEntryAt(msg->findEntryByName("smpte2086.white.y"));
1631 msg->removeEntryAt(msg->findEntryByName("smpte2086.max-luminance"));
1632 msg->removeEntryAt(msg->findEntryByName("smpte2086.min-luminance"));
1633 msg->removeEntryAt(msg->findEntryByName("cta861.max-cll"));
1634 msg->removeEntryAt(msg->findEntryByName("cta861.max-fall"));
1635 }
1636
1637 // HDR dynamic info
1638 std::string keyPrefix = input ? C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO
1639 : C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO;
1640 std::string typeKey = keyPrefix + ".type";
1641 std::string dataKey = keyPrefix + ".data";
1642 int32_t type;
1643 sp<ABuffer> data;
1644 if (msg->findInt32(typeKey.c_str(), &type)
1645 && msg->findBuffer(dataKey.c_str(), &data)) {
1646 if (type == HDR_DYNAMIC_METADATA_TYPE_SMPTE_2094_40) {
1647 msg->setBuffer(KEY_HDR10_PLUS_INFO, data);
1648 msg->removeEntryAt(msg->findEntryByName(typeKey.c_str()));
1649 msg->removeEntryAt(msg->findEntryByName(dataKey.c_str()));
1650 }
1651 }
1652 }
1653
1654 ALOGV("converted to SDK values as %s", msg->debugString().c_str());
1655 return msg;
1656 }
1657
1658 /// converts an AMessage value to a ParamUpdater value
convert(const AMessage::ItemData & from,ReflectedParamUpdater::Value * to)1659 static void convert(const AMessage::ItemData &from, ReflectedParamUpdater::Value *to) {
1660 int32_t int32Value;
1661 int64_t int64Value;
1662 sp<ABuffer> bufValue;
1663 AString strValue;
1664 float floatValue;
1665 double doubleValue;
1666
1667 if (from.find(&int32Value)) {
1668 to->set(int32Value);
1669 } else if (from.find(&int64Value)) {
1670 to->set(int64Value);
1671 } else if (from.find(&bufValue)) {
1672 to->set(bufValue);
1673 } else if (from.find(&strValue)) {
1674 to->set(strValue);
1675 } else if (from.find(&floatValue)) {
1676 to->set(C2Value(floatValue));
1677 } else if (from.find(&doubleValue)) {
1678 // convert double to float
1679 to->set(C2Value((float)doubleValue));
1680 }
1681 // ignore all other AMessage types
1682 }
1683
1684 /// relaxes Codec 2.0 specific value types to SDK types (mainly removes signedness and counterness
1685 /// from 32/64-bit values.)
relaxValues(ReflectedParamUpdater::Value & item)1686 static void relaxValues(ReflectedParamUpdater::Value &item) {
1687 C2Value c2Value;
1688 int32_t int32Value;
1689 int64_t int64Value;
1690 (void)item.find(&c2Value);
1691 if (c2Value.get(&int32Value) || c2Value.get((uint32_t*)&int32Value)
1692 || c2Value.get((c2_cntr32_t*)&int32Value)) {
1693 item.set(int32Value);
1694 } else if (c2Value.get(&int64Value)
1695 || c2Value.get((uint64_t*)&int64Value)
1696 || c2Value.get((c2_cntr64_t*)&int64Value)) {
1697 item.set(int64Value);
1698 }
1699 }
1700
getReflectedFormat(const sp<AMessage> & params_,Domain configDomain) const1701 ReflectedParamUpdater::Dict CCodecConfig::getReflectedFormat(
1702 const sp<AMessage> ¶ms_, Domain configDomain) const {
1703 // create a modifiable copy of params
1704 sp<AMessage> params = params_->dup();
1705 ALOGV("filtering with config domain %x", configDomain);
1706
1707 // convert some macro parameters to Codec 2.0 specific expressions
1708
1709 { // make i-frame-interval frame based
1710 float iFrameInterval;
1711 if (params->findAsFloat(KEY_I_FRAME_INTERVAL, &iFrameInterval)) {
1712 float frameRate;
1713 if (params->findAsFloat(KEY_FRAME_RATE, &frameRate)) {
1714 params->setInt32("i-frame-period",
1715 (frameRate <= 0 || iFrameInterval < 0)
1716 ? -1 /* no sync frames */
1717 : (int32_t)c2_min(iFrameInterval * frameRate + 0.5,
1718 (float)INT32_MAX));
1719 }
1720 }
1721 }
1722
1723 if (mDomain == (IS_VIDEO | IS_ENCODER)) {
1724 // convert capture-rate into input-time-stretch
1725 float frameRate, captureRate;
1726 if (params->findAsFloat(KEY_FRAME_RATE, &frameRate)) {
1727 if (!params->findAsFloat("time-lapse-fps", &captureRate)
1728 && !params->findAsFloat(KEY_CAPTURE_RATE, &captureRate)) {
1729 captureRate = frameRate;
1730 }
1731 if (captureRate > 0 && frameRate > 0) {
1732 params->setFloat(C2_PARAMKEY_INPUT_TIME_STRETCH, captureRate / frameRate);
1733 }
1734 }
1735
1736 // add HDR format for video encoding
1737 if (configDomain == IS_CONFIG) {
1738 // don't assume here that transfer is set for HDR, only require it for HLG
1739 int transfer = 0;
1740 params->findInt32(KEY_COLOR_TRANSFER, &transfer);
1741
1742 int profile;
1743 if (params->findInt32(KEY_PROFILE, &profile)) {
1744 std::shared_ptr<C2Mapper::ProfileLevelMapper> mapper =
1745 C2Mapper::GetProfileLevelMapper(mCodingMediaType);
1746 C2Config::hdr_format_t c2 = C2Config::hdr_format_t::UNKNOWN;
1747 if (mapper && mapper->mapHdrFormat(profile, &c2)) {
1748 if (c2 == C2Config::hdr_format_t::HLG &&
1749 transfer != COLOR_TRANSFER_HLG) {
1750 c2 = C2Config::hdr_format_t::UNKNOWN;
1751 }
1752 params->setInt32(C2_PARAMKEY_HDR_FORMAT, c2);
1753 }
1754 }
1755 }
1756 }
1757
1758 { // reflect temporal layering into a binary blob
1759 AString schema;
1760 if (params->findString(KEY_TEMPORAL_LAYERING, &schema)) {
1761 unsigned int numLayers = 0;
1762 unsigned int numBLayers = 0;
1763 int tags;
1764 char dummy;
1765 std::unique_ptr<C2StreamTemporalLayeringTuning::output> layering;
1766 if (sscanf(schema.c_str(), "webrtc.vp8.%u-layer%c", &numLayers, &dummy) == 1
1767 && numLayers > 0) {
1768 switch (numLayers) {
1769 case 1:
1770 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1771 {}, 0u, 1u, 0u);
1772 break;
1773 case 2:
1774 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1775 { .6f }, 0u, 2u, 0u);
1776 break;
1777 case 3:
1778 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1779 { .4f, .6f }, 0u, 3u, 0u);
1780 break;
1781 default:
1782 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1783 { .25f, .4f, .6f }, 0u, 4u, 0u);
1784 break;
1785 }
1786 } else if ((tags = sscanf(schema.c_str(), "android.generic.%u%c%u%c",
1787 &numLayers, &dummy, &numBLayers, &dummy))
1788 && (tags == 1 || (tags == 3 && dummy == '+'))
1789 && numLayers > 0 && numLayers < UINT32_MAX - numBLayers) {
1790 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1791 {}, 0u, numLayers + numBLayers, numBLayers);
1792 } else {
1793 ALOGD("Ignoring unsupported ts-schema [%s]", schema.c_str());
1794 }
1795 if (layering) {
1796 params->setBuffer(C2_PARAMKEY_TEMPORAL_LAYERING,
1797 ABuffer::CreateAsCopy(layering.get(), layering->size()));
1798 }
1799 }
1800 }
1801
1802 { // convert from MediaFormat rect to Codec 2.0 rect
1803 int32_t offset;
1804 int32_t end;
1805 AMessage::ItemData item;
1806 if (params->findInt32("crop-left", &offset) && params->findInt32("crop-right", &end)
1807 && offset >= 0 && end >= offset - 1) {
1808 size_t ix = params->findEntryByName("crop-right");
1809 params->setEntryNameAt(ix, "crop-width");
1810 item.set(end - offset + 1);
1811 params->setEntryAt(ix, item);
1812 }
1813 if (params->findInt32("crop-top", &offset) && params->findInt32("crop-bottom", &end)
1814 && offset >= 0 && end >= offset - 1) {
1815 size_t ix = params->findEntryByName("crop-bottom");
1816 params->setEntryNameAt(ix, "crop-height");
1817 item.set(end - offset + 1);
1818 params->setEntryAt(ix, item);
1819 }
1820 }
1821
1822 { // convert color info
1823 int32_t standard;
1824 if (params->findInt32(KEY_COLOR_STANDARD, &standard)) {
1825 C2Color::primaries_t primaries;
1826 C2Color::matrix_t matrix;
1827
1828 if (C2Mapper::map(standard, &primaries, &matrix)) {
1829 params->setInt32("color-primaries", primaries);
1830 params->setInt32("color-matrix", matrix);
1831 }
1832 }
1833
1834 sp<ABuffer> hdrMeta;
1835 if (params->findBuffer(KEY_HDR_STATIC_INFO, &hdrMeta)
1836 && hdrMeta->size() == sizeof(HDRStaticInfo)) {
1837 HDRStaticInfo *meta = (HDRStaticInfo*)hdrMeta->data();
1838 if (meta->mID == meta->kType1) {
1839 params->setFloat("smpte2086.red.x", meta->sType1.mR.x * 0.00002);
1840 params->setFloat("smpte2086.red.y", meta->sType1.mR.y * 0.00002);
1841 params->setFloat("smpte2086.green.x", meta->sType1.mG.x * 0.00002);
1842 params->setFloat("smpte2086.green.y", meta->sType1.mG.y * 0.00002);
1843 params->setFloat("smpte2086.blue.x", meta->sType1.mB.x * 0.00002);
1844 params->setFloat("smpte2086.blue.y", meta->sType1.mB.y * 0.00002);
1845 params->setFloat("smpte2086.white.x", meta->sType1.mW.x * 0.00002);
1846 params->setFloat("smpte2086.white.y", meta->sType1.mW.y * 0.00002);
1847 params->setFloat("smpte2086.max-luminance", meta->sType1.mMaxDisplayLuminance);
1848 params->setFloat("smpte2086.min-luminance", meta->sType1.mMinDisplayLuminance * 0.0001);
1849 params->setFloat("cta861.max-cll", meta->sType1.mMaxContentLightLevel);
1850 params->setFloat("cta861.max-fall", meta->sType1.mMaxFrameAverageLightLevel);
1851 }
1852 }
1853
1854 sp<ABuffer> hdrDynamicInfo;
1855 if (params->findBuffer(KEY_HDR10_PLUS_INFO, &hdrDynamicInfo)) {
1856 for (const std::string &prefix : { C2_PARAMKEY_INPUT_HDR_DYNAMIC_INFO,
1857 C2_PARAMKEY_OUTPUT_HDR_DYNAMIC_INFO }) {
1858 params->setInt32((prefix + ".type").c_str(),
1859 HDR_DYNAMIC_METADATA_TYPE_SMPTE_2094_40);
1860 params->setBuffer((prefix + ".data").c_str(), hdrDynamicInfo);
1861 }
1862 }
1863 }
1864
1865 // this is to verify that we set proper signedness for standard parameters
1866 bool beVeryStrict = property_get_bool("debug.stagefright.ccodec_strict_type", false);
1867 // this is to allow vendors to use the wrong signedness for standard parameters
1868 bool beVeryLax = property_get_bool("debug.stagefright.ccodec_lax_type", false);
1869
1870 ReflectedParamUpdater::Dict filtered;
1871 for (size_t ix = 0; ix < params->countEntries(); ++ix) {
1872 AMessage::Type type;
1873 AString name = params->getEntryNameAt(ix, &type);
1874 AMessage::ItemData msgItem = params->getEntryAt(ix);
1875 ReflectedParamUpdater::Value item;
1876 convert(msgItem, &item); // convert item to param updater item
1877
1878 if (name.startsWith("vendor.")) {
1879 // vendor params pass through as is
1880 filtered.emplace(name.c_str(), item);
1881 continue;
1882 }
1883 // standard parameters may get modified, filtered or duplicated
1884 for (const ConfigMapper &cm : mStandardParams->getConfigMappersForSdkKey(name.c_str())) {
1885 // note: we ignore port domain for configuration
1886 if ((cm.domain() & configDomain)
1887 // component domain + kind (these must match)
1888 && (cm.domain() & mDomain) == mDomain) {
1889 // map arithmetic values, pass through string or buffer
1890 switch (type) {
1891 case AMessage::kTypeBuffer:
1892 case AMessage::kTypeString:
1893 break;
1894 case AMessage::kTypeInt32:
1895 case AMessage::kTypeInt64:
1896 case AMessage::kTypeFloat:
1897 case AMessage::kTypeDouble:
1898 // for now only map settings with mappers as we are not creating
1899 // signed <=> unsigned mappers
1900 // TODO: be precise about signed unsigned
1901 if (beVeryStrict || cm.mapper()) {
1902 item.set(cm.mapFromMessage(params->getEntryAt(ix)));
1903 // also allow to relax type strictness
1904 if (beVeryLax) {
1905 relaxValues(item);
1906 }
1907 }
1908 break;
1909 default:
1910 continue;
1911 }
1912 filtered.emplace(cm.path(), item);
1913 }
1914 }
1915 }
1916 ALOGV("filter src msg %s", params->debugString(4).c_str());
1917 ALOGV("filter dst params %s", filtered.debugString(4).c_str());
1918 return filtered;
1919 }
1920
getConfigUpdateFromSdkParams(std::shared_ptr<Codec2Client::Configurable> configurable,const sp<AMessage> & sdkParams,Domain configDomain,c2_blocking_t blocking,std::vector<std::unique_ptr<C2Param>> * configUpdate) const1921 status_t CCodecConfig::getConfigUpdateFromSdkParams(
1922 std::shared_ptr<Codec2Client::Configurable> configurable,
1923 const sp<AMessage> &sdkParams, Domain configDomain,
1924 c2_blocking_t blocking,
1925 std::vector<std::unique_ptr<C2Param>> *configUpdate) const {
1926 // update the mappers if we know something more of this format.
1927 // AV1 10b or 8b encoding request.
1928 AString mime;
1929 int32_t requestedSdkProfile = -1;
1930 if ((mDomain == (IS_VIDEO | IS_ENCODER)) &&
1931 sdkParams->findString(KEY_MIME, &mime) &&
1932 mime == MIMETYPE_VIDEO_AV1) {
1933
1934 sdkParams->findInt32(KEY_PROFILE, &requestedSdkProfile);
1935 bool is10bAv1EncodeRequested = (requestedSdkProfile == AV1ProfileMain10);
1936
1937 int32_t bitDepth = (is10bAv1EncodeRequested) ? 10 : 8;
1938 // we always initilze with an 8b mapper. Update this only if needed.
1939 if (bitDepth != 8) {
1940 std::shared_ptr<C2Mapper::ProfileLevelMapper> mapper =
1941 C2Mapper::GetBitDepthProfileLevelMapper(mCodingMediaType, bitDepth);
1942 mStandardParams->updateConfigMappersForKey(StandardParams::SdkKey(KEY_PROFILE),
1943 {
1944 ConfigMapper(KEY_PROFILE, C2_PARAMKEY_PROFILE_LEVEL, "profile")
1945 .limitTo(Domain::CODED)
1946 .withMappers([mapper](C2Value v) -> C2Value {
1947 C2Config::profile_t c2 = PROFILE_UNUSED;
1948 int32_t sdk;
1949 if (mapper && v.get(&sdk) && mapper->mapProfile(sdk, &c2)) {
1950 return c2;
1951 }
1952 return PROFILE_UNUSED;
1953 }, [mapper](C2Value v) -> C2Value {
1954 C2Config::profile_t c2;
1955 int32_t sdk;
1956 using C2ValueType =
1957 typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
1958 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapProfile(c2, &sdk)) {
1959 return sdk;
1960 }
1961 return C2Value();
1962 })});
1963 mStandardParams->updateConfigMappersForKey(StandardParams::SdkKey(KEY_LEVEL),
1964 {
1965 ConfigMapper(KEY_LEVEL, C2_PARAMKEY_PROFILE_LEVEL, "level")
1966 .limitTo(Domain::CODED)
1967 .withMappers([mapper](C2Value v) -> C2Value {
1968 C2Config::level_t c2 = LEVEL_UNUSED;
1969 int32_t sdk;
1970 if (mapper && v.get(&sdk) && mapper->mapLevel(sdk, &c2)) {
1971 return c2;
1972 }
1973 return LEVEL_UNUSED;
1974 }, [mapper](C2Value v) -> C2Value {
1975 C2Config::level_t c2;
1976 int32_t sdk;
1977 using C2ValueType =
1978 typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
1979 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapLevel(c2, &sdk)) {
1980 return sdk;
1981 }
1982 return C2Value();
1983 })});
1984 }
1985 }
1986
1987 ReflectedParamUpdater::Dict params = getReflectedFormat(sdkParams, configDomain);
1988
1989 std::vector<C2Param::Index> indices;
1990 mParamUpdater->getParamIndicesFromMessage(params, &indices);
1991 if (indices.empty()) {
1992 ALOGD("no recognized params in: %s", params.debugString().c_str());
1993 return OK;
1994 }
1995
1996 configUpdate->clear();
1997 std::vector<C2Param::Index> supportedIndices;
1998 for (C2Param::Index ix : indices) {
1999 if (mSupportedIndices.count(ix)) {
2000 supportedIndices.push_back(ix);
2001 } else if (mLocalParams.count(ix)) {
2002 // query local parameter here
2003 auto it = mCurrentConfig.find(ix);
2004 if (it != mCurrentConfig.end()) {
2005 configUpdate->emplace_back(C2Param::Copy(*it->second));
2006 }
2007 }
2008 }
2009
2010 c2_status_t err = configurable->query({ }, supportedIndices, blocking, configUpdate);
2011 if (err != C2_OK) {
2012 ALOGD("query failed after returning %zu params => %s", configUpdate->size(), asString(err));
2013 }
2014
2015 if (configUpdate->size()) {
2016 mParamUpdater->updateParamsFromMessage(params, configUpdate);
2017 }
2018 return OK;
2019 }
2020
setParameters(std::shared_ptr<Codec2Client::Configurable> configurable,std::vector<std::unique_ptr<C2Param>> & configUpdate,c2_blocking_t blocking)2021 status_t CCodecConfig::setParameters(
2022 std::shared_ptr<Codec2Client::Configurable> configurable,
2023 std::vector<std::unique_ptr<C2Param>> &configUpdate,
2024 c2_blocking_t blocking) {
2025 status_t result = OK;
2026 if (configUpdate.empty()) {
2027 return OK;
2028 }
2029
2030 std::vector<C2Param::Index> indices;
2031 std::vector<C2Param *> paramVector;
2032 for (const std::unique_ptr<C2Param> ¶m : configUpdate) {
2033 if (mSupportedIndices.count(param->index())) {
2034 // component parameter
2035 paramVector.push_back(param.get());
2036 indices.push_back(param->index());
2037 } else if (mLocalParams.count(param->index())) {
2038 // handle local parameter here
2039 LocalParamValidator validator = mLocalParams.find(param->index())->second;
2040 c2_status_t err = C2_OK;
2041 std::unique_ptr<C2Param> copy = C2Param::Copy(*param);
2042 if (validator) {
2043 err = validator(copy);
2044 }
2045 if (err == C2_OK) {
2046 ALOGV("updated local parameter value for %s",
2047 mParamUpdater->getParamName(param->index()).c_str());
2048
2049 mCurrentConfig[param->index()] = std::move(copy);
2050 } else {
2051 ALOGD("failed to set parameter value for %s => %s",
2052 mParamUpdater->getParamName(param->index()).c_str(), asString(err));
2053 result = BAD_VALUE;
2054 }
2055 }
2056 }
2057 // update subscribed param indices
2058 subscribeToConfigUpdate(configurable, indices, blocking);
2059
2060 std::vector<std::unique_ptr<C2SettingResult>> failures;
2061 c2_status_t err = configurable->config(paramVector, blocking, &failures);
2062 if (err != C2_OK) {
2063 ALOGD("config failed => %s", asString(err));
2064 // This is non-fatal.
2065 }
2066 for (const std::unique_ptr<C2SettingResult> &failure : failures) {
2067 switch (failure->failure) {
2068 case C2SettingResult::BAD_VALUE:
2069 ALOGD("Bad parameter value");
2070 result = BAD_VALUE;
2071 break;
2072 default:
2073 ALOGV("failure = %d", int(failure->failure));
2074 break;
2075 }
2076 }
2077
2078 // Re-query parameter values in case config could not update them and update the current
2079 // configuration.
2080 configUpdate.clear();
2081 err = configurable->query({}, indices, blocking, &configUpdate);
2082 if (err != C2_OK) {
2083 ALOGD("query failed after returning %zu params => %s", configUpdate.size(), asString(err));
2084 }
2085 (void)updateConfiguration(configUpdate, ALL);
2086
2087 // TODO: error value
2088 return result;
2089 }
2090
getConfigParameterValue(C2Param::Index index) const2091 const C2Param *CCodecConfig::getConfigParameterValue(C2Param::Index index) const {
2092 auto it = mCurrentConfig.find(index);
2093 if (it == mCurrentConfig.end()) {
2094 return nullptr;
2095 } else {
2096 return it->second.get();
2097 }
2098 }
2099
subscribeToAllVendorParams(const std::shared_ptr<Codec2Client::Configurable> & configurable,c2_blocking_t blocking)2100 status_t CCodecConfig::subscribeToAllVendorParams(
2101 const std::shared_ptr<Codec2Client::Configurable> &configurable,
2102 c2_blocking_t blocking) {
2103 for (const auto &[path, desc] : mVendorParams) {
2104 mSubscribedIndices.insert(desc->index());
2105 }
2106 return subscribeToConfigUpdate(configurable, {}, blocking);
2107 }
2108
querySupportedParameters(std::vector<std::string> * names)2109 status_t CCodecConfig::querySupportedParameters(std::vector<std::string> *names) {
2110 if (!names) {
2111 return BAD_VALUE;
2112 }
2113 names->clear();
2114 // TODO: expand to standard params
2115 for (const auto &[key, desc] : mVendorParams) {
2116 if (desc->isVisible()) {
2117 names->push_back(key);
2118 }
2119 }
2120 return OK;
2121 }
2122
describe(const std::string & name,CodecParameterDescriptor * desc)2123 status_t CCodecConfig::describe(const std::string &name, CodecParameterDescriptor *desc) {
2124 if (!desc) {
2125 return BAD_VALUE;
2126 }
2127 // TODO: expand to standard params
2128 desc->name = name;
2129 switch (mParamUpdater->getTypeForKey(name)) {
2130 case C2FieldDescriptor::INT32:
2131 case C2FieldDescriptor::UINT32:
2132 case C2FieldDescriptor::CNTR32:
2133 desc->type = AMessage::kTypeInt32;
2134 return OK;
2135 case C2FieldDescriptor::INT64:
2136 case C2FieldDescriptor::UINT64:
2137 case C2FieldDescriptor::CNTR64:
2138 desc->type = AMessage::kTypeInt64;
2139 return OK;
2140 case C2FieldDescriptor::FLOAT:
2141 desc->type = AMessage::kTypeFloat;
2142 return OK;
2143 case C2FieldDescriptor::STRING:
2144 desc->type = AMessage::kTypeString;
2145 return OK;
2146 case C2FieldDescriptor::BLOB:
2147 desc->type = AMessage::kTypeBuffer;
2148 return OK;
2149 default:
2150 return NAME_NOT_FOUND;
2151 }
2152 }
2153
subscribeToVendorConfigUpdate(const std::shared_ptr<Codec2Client::Configurable> & configurable,const std::vector<std::string> & names,c2_blocking_t blocking)2154 status_t CCodecConfig::subscribeToVendorConfigUpdate(
2155 const std::shared_ptr<Codec2Client::Configurable> &configurable,
2156 const std::vector<std::string> &names,
2157 c2_blocking_t blocking) {
2158 for (const std::string &name : names) {
2159 auto it = mVendorParams.find(name);
2160 if (it == mVendorParams.end()) {
2161 ALOGD("%s is not a recognized vendor parameter; ignored.", name.c_str());
2162 continue;
2163 }
2164 mSubscribedIndices.insert(it->second->index());
2165 }
2166 return subscribeToConfigUpdate(configurable, {}, blocking);
2167 }
2168
unsubscribeFromVendorConfigUpdate(const std::shared_ptr<Codec2Client::Configurable> & configurable,const std::vector<std::string> & names,c2_blocking_t blocking)2169 status_t CCodecConfig::unsubscribeFromVendorConfigUpdate(
2170 const std::shared_ptr<Codec2Client::Configurable> &configurable,
2171 const std::vector<std::string> &names,
2172 c2_blocking_t blocking) {
2173 for (const std::string &name : names) {
2174 auto it = mVendorParams.find(name);
2175 if (it == mVendorParams.end()) {
2176 ALOGD("%s is not a recognized vendor parameter; ignored.", name.c_str());
2177 continue;
2178 }
2179 mSubscribedIndices.erase(it->second->index());
2180 }
2181 return subscribeToConfigUpdate(configurable, {}, blocking);
2182 }
2183
2184 } // namespace android
2185