Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_av / ec58800670ec93ebac13c5861e97c7e9c138ead9 / . / media / codec2 / sfplugin / CCodecConfig.cpp
blob: 3dbd666638f95e645b367a241e9530bddcd3a93b [file] [log] [blame]
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]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#include <cutils/properties.h>
20#include <log/log.h>
21
22#include <C2Component.h>
23#include <C2Debug.h>
24#include <C2Param.h>
25#include <util/C2InterfaceHelper.h>
26
27#include <media/stagefright/MediaCodecConstants.h>
28
29#include "CCodecConfig.h"
30#include "Codec2Mapper.h"
31
32#define DRC_DEFAULT_MOBILE_REF_LEVEL 64 /* 64*-0.25dB = -16 dB below full scale for mobile conf */
33#define DRC_DEFAULT_MOBILE_DRC_CUT 127 /* maximum compression of dynamic range for mobile conf */
34#define DRC_DEFAULT_MOBILE_DRC_BOOST 127 /* maximum compression of dynamic range for mobile conf */
35#define DRC_DEFAULT_MOBILE_DRC_HEAVY 1 /* switch for heavy compression for mobile conf */
36#define DRC_DEFAULT_MOBILE_DRC_EFFECT 3 /* MPEG-D DRC effect type; 3 => Limited playback range */
37#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) */
38// names of properties that can be used to override the default DRC settings
39#define PROP_DRC_OVERRIDE_REF_LEVEL "aac_drc_reference_level"
40#define PROP_DRC_OVERRIDE_CUT "aac_drc_cut"
41#define PROP_DRC_OVERRIDE_BOOST "aac_drc_boost"
42#define PROP_DRC_OVERRIDE_HEAVY "aac_drc_heavy"
43#define PROP_DRC_OVERRIDE_ENC_LEVEL "aac_drc_enc_target_level"
44#define PROP_DRC_OVERRIDE_EFFECT "ro.aac_drc_effect_type"
45
46namespace android {
47
48// CCodecConfig
49
50namespace {
51
52/**
53 * mapping between SDK and Codec 2.0 configurations.
54 */
55struct ConfigMapper {
56 /**
57 * Value mapper (C2Value => C2Value)
58 */
59 typedef std::function<C2Value(C2Value)> Mapper;
60
61 /// shorthand
62 typedef CCodecConfig::Domain Domain;
63
64 ConfigMapper(std::string mediaKey, C2String c2struct, C2String c2field)
65 : mDomain(Domain::ALL), mMediaKey(mediaKey), mStruct(c2struct), mField(c2field) { }
66
67 /// Limits this parameter to the given domain
68 ConfigMapper &limitTo(uint32_t domain) {
69 C2_CHECK(domain & Domain::GUARD_BIT);
70 mDomain = Domain(mDomain & domain);
71 return *this;
72 }
73
74 /// Adds SDK => Codec 2.0 mapper (should not be in the SDK format)
75 ConfigMapper &withMapper(Mapper mapper) {
76 C2_CHECK(!mMapper);
77 C2_CHECK(!mReverse);
78 mMapper = mapper;
79 return *this;
80 }
81
82 /// Adds SDK <=> Codec 2.0 value mappers
83 ConfigMapper &withMappers(Mapper mapper, Mapper reverse) {
84 C2_CHECK(!mMapper);
85 C2_CHECK(!mReverse);
86 mMapper = mapper;
87 mReverse = reverse;
88 return *this;
89 }
90
91 /// Adds SDK <=> Codec 2.0 value mappers based on C2Mapper
92 template<typename C2Type, typename SdkType=int32_t>
93 ConfigMapper &withC2Mappers() {
94 C2_CHECK(!mMapper);
95 C2_CHECK(!mReverse);
96 mMapper = [](C2Value v) -> C2Value {
97 SdkType sdkValue;
98 C2Type c2Value;
99 if (v.get(&sdkValue) && C2Mapper::map(sdkValue, &c2Value)) {
100 return c2Value;
101 }
102 return C2Value();
103 };
104 mReverse = [](C2Value v) -> C2Value {
105 SdkType sdkValue;
106 C2Type c2Value;
107 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<C2Type>::type;
108 if (v.get((C2ValueType*)&c2Value) && C2Mapper::map(c2Value, &sdkValue)) {
109 return sdkValue;
110 }
111 return C2Value();
112 };
113 return *this;
114 }
115
116 /// Maps from SDK values in an AMessage to a suitable C2Value.
117 C2Value mapFromMessage(const AMessage::ItemData &item) const {
118 C2Value value;
119 int32_t int32Value;
120 int64_t int64Value;
121 float floatValue;
122 double doubleValue;
123 if (item.find(&int32Value)) {
124 value = int32Value;
125 } else if (item.find(&int64Value)) {
126 value = int64Value;
127 } else if (item.find(&floatValue)) {
128 value = floatValue;
129 } else if (item.find(&doubleValue)) {
130 value = (float)doubleValue;
131 }
132 if (value.type() != C2Value::NO_INIT && mMapper) {
133 value = mMapper(value);
134 }
135 return value;
136 }
137
138 /// Maps from a C2Value to an SDK value in an AMessage.
139 AMessage::ItemData mapToMessage(C2Value value) const {
140 AMessage::ItemData item;
141 int32_t int32Value;
142 uint32_t uint32Value;
143 int64_t int64Value;
144 uint64_t uint64Value;
145 float floatValue;
146 if (value.type() != C2Value::NO_INIT && mReverse) {
147 value = mReverse(value);
148 }
149 if (value.get(&int32Value)) {
150 item.set(int32Value);
151 } else if (value.get(&uint32Value) && uint32Value <= uint32_t(INT32_MAX)) {
152 // SDK does not support unsigned values
153 item.set((int32_t)uint32Value);
154 } else if (value.get(&int64Value)) {
155 item.set(int64Value);
156 } else if (value.get(&uint64Value) && uint64Value <= uint64_t(INT64_MAX)) {
157 // SDK does not support unsigned values
158 item.set((int64_t)uint64Value);
159 } else if (value.get(&floatValue)) {
160 item.set(floatValue);
161 }
162 return item;
163 }
164
165 Domain domain() const { return mDomain; }
166 std::string mediaKey() const { return mMediaKey; }
167 std::string path() const { return mField.size() ? mStruct + '.' + mField : mStruct; }
168 Mapper mapper() const { return mMapper; }
169 Mapper reverse() const { return mReverse; }
170
171private:
172 Domain mDomain; ///< parameter domain (mask) containing port, kind and config domains
173 std::string mMediaKey; ///< SDK key
174 C2String mStruct; ///< Codec 2.0 struct name
175 C2String mField; ///< Codec 2.0 field name
176 Mapper mMapper; ///< optional SDK => Codec 2.0 value mapper
177 Mapper mReverse; ///< optional Codec 2.0 => SDK value mapper
178};
179
180template <typename PORT, typename STREAM>
181AString QueryMediaTypeImpl(
182 const std::shared_ptr<Codec2Client::Component> &component) {
183 AString mediaType;
184 std::vector<std::unique_ptr<C2Param>> queried;
185 c2_status_t c2err = component->query(
186 {}, { PORT::PARAM_TYPE, STREAM::PARAM_TYPE }, C2_DONT_BLOCK, &queried);
187 if (c2err != C2_OK && queried.size() == 0) {
188 ALOGD("Query media type failed => %s", asString(c2err));
189 } else {
190 PORT *portMediaType =
191 PORT::From(queried[0].get());
192 if (portMediaType) {
193 mediaType = AString(
194 portMediaType->m.value,
195 strnlen(portMediaType->m.value, portMediaType->flexCount()));
196 } else {
197 STREAM *streamMediaType = STREAM::From(queried[0].get());
198 if (streamMediaType) {
199 mediaType = AString(
200 streamMediaType->m.value,
201 strnlen(streamMediaType->m.value, streamMediaType->flexCount()));
202 }
203 }
204 ALOGD("read media type: %s", mediaType.c_str());
205 }
206 return mediaType;
207}
208
209AString QueryMediaType(
210 bool input, const std::shared_ptr<Codec2Client::Component> &component) {
211 typedef C2PortMediaTypeSetting P;
212 typedef C2StreamMediaTypeSetting S;
213 if (input) {
214 return QueryMediaTypeImpl<P::input, S::input>(component);
215 } else {
216 return QueryMediaTypeImpl<P::output, S::output>(component);
217 }
218}
219
220} // namespace
221
222/**
223 * Set of standard parameters used by CCodec that are exposed to MediaCodec.
224 */
225struct StandardParams {
226 typedef CCodecConfig::Domain Domain;
227
228 // standard (MediaCodec) params are keyed by media format key
229 typedef std::string SdkKey;
230
231 /// used to return reference to no config mappers in getConfigMappersForSdkKey
232 static const std::vector<ConfigMapper> NO_MAPPERS;
233
234 /// Returns Codec 2.0 equivalent parameters for an SDK format key.
235 const std::vector<ConfigMapper> &getConfigMappersForSdkKey(std::string key) const {
236 auto it = mConfigMappers.find(key);
237 if (it == mConfigMappers.end()) {
238 ALOGD("no c2 equivalents for %s", key.c_str());
239 return NO_MAPPERS;
240 }
241 ALOGV("found %zu eqs for %s", it->second.size(), key.c_str());
242 return it->second;
243 }
244
245 /**
246 * Adds a SDK <=> Codec 2.0 parameter mapping. Multiple Codec 2.0 parameters may map to a
247 * single SDK key, in which case they shall be ordered from least authoritative to most
248 * authoritative. When constructing SDK formats, the last mapped Codec 2.0 parameter that
249 * is supported by the component will determine the exposed value. (TODO: perhaps restrict this
250 * by domain.)
251 */
252 void add(const ConfigMapper &cm) {
253 auto it = mConfigMappers.find(cm.mediaKey());
254 ALOGV("%c%c%c%c %c%c%c %04x %9s %s => %s",
255 ((cm.domain() & Domain::IS_INPUT) ? 'I' : ' '),
256 ((cm.domain() & Domain::IS_OUTPUT) ? 'O' : ' '),
257 ((cm.domain() & Domain::IS_CODED) ? 'C' : ' '),
258 ((cm.domain() & Domain::IS_RAW) ? 'R' : ' '),
259 ((cm.domain() & Domain::IS_CONFIG) ? 'c' : ' '),
260 ((cm.domain() & Domain::IS_PARAM) ? 'p' : ' '),
261 ((cm.domain() & Domain::IS_READ) ? 'r' : ' '),
262 cm.domain(),
263 it == mConfigMappers.end() ? "adding" : "extending",
264 cm.mediaKey().c_str(), cm.path().c_str());
265 if (it == mConfigMappers.end()) {
266 std::vector<ConfigMapper> eqs = { cm };
267 mConfigMappers.emplace(cm.mediaKey(), eqs);
268 } else {
269 it->second.push_back(cm);
270 }
271 }
272
273 /**
274 * Returns all paths for a specific domain.
275 *
276 * \param any maximum domain mask. Returned parameters must match at least one of the domains
277 * in the mask.
278 * \param all minimum domain mask. Returned parameters must match all of the domains in the
279 * mask. This is restricted to the bits of the maximum mask.
280 */
281 std::vector<std::string> getPathsForDomain(
282 Domain any, Domain all = Domain::ALL) const {
283 std::vector<std::string> res;
284 for (const std::pair<std::string, std::vector<ConfigMapper>> &el : mConfigMappers) {
285 for (const ConfigMapper &cm : el.second) {
286 ALOGV("filtering %s %x %x %x %x", cm.path().c_str(), cm.domain(), any,
287 (cm.domain() & any), (cm.domain() & any & all));
288 if ((cm.domain() & any) && ((cm.domain() & any & all) == (any & all))) {
289 res.push_back(cm.path());
290 }
291 }
292 }
293 return res;
294 }
295
296 /**
297 * Returns SDK <=> Codec 2.0 mappings.
298 *
299 * TODO: replace these with better methods as this exposes the inner structure.
300 */
301 const std::map<SdkKey, std::vector<ConfigMapper>> getKeys() const {
302 return mConfigMappers;
303 }
304
305private:
306 std::map<SdkKey, std::vector<ConfigMapper>> mConfigMappers;
307};
308
309const std::vector<ConfigMapper> StandardParams::NO_MAPPERS;
310
311
312CCodecConfig::CCodecConfig()
313 : mInputFormat(new AMessage),
314 mOutputFormat(new AMessage),
315 mUsingSurface(false) { }
316
317void CCodecConfig::initializeStandardParams() {
318 typedef Domain D;
319 mStandardParams = std::make_shared<StandardParams>();
320 std::function<void(const ConfigMapper &)> add =
321 [params = mStandardParams](const ConfigMapper &cm) {
322 params->add(cm);
323 };
324 std::function<void(const ConfigMapper &)> deprecated = add;
325
326 // allow int32 or float SDK values and represent them as float
327 ConfigMapper::Mapper makeFloat = [](C2Value v) -> C2Value {
328 // convert from i32 to float
329 int32_t i32Value;
330 float fpValue;
331 if (v.get(&i32Value)) {
332 return (float)i32Value;
333 } else if (v.get(&fpValue)) {
334 return fpValue;
335 }
336 return C2Value();
337 };
338
339 ConfigMapper::Mapper negate = [](C2Value v) -> C2Value {
340 int32_t value;
341 if (v.get(&value)) {
342 return -value;
343 }
344 return C2Value();
345 };
346
347 add(ConfigMapper(KEY_MIME, C2_PARAMKEY_INPUT_MEDIA_TYPE, "value")
348 .limitTo(D::INPUT & D::READ));
349 add(ConfigMapper(KEY_MIME, C2_PARAMKEY_OUTPUT_MEDIA_TYPE, "value")
350 .limitTo(D::OUTPUT & D::READ));
351
352 add(ConfigMapper(KEY_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
353 .limitTo(D::ENCODER & D::OUTPUT));
354 // we also need to put the bitrate in the max bitrate field
355 add(ConfigMapper(KEY_MAX_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
356 .limitTo(D::ENCODER & D::READ & D::OUTPUT));
357 add(ConfigMapper(PARAMETER_KEY_VIDEO_BITRATE, C2_PARAMKEY_BITRATE, "value")
358 .limitTo(D::ENCODER & D::VIDEO & D::PARAM));
359 add(ConfigMapper(KEY_BITRATE_MODE, C2_PARAMKEY_BITRATE_MODE, "value")
360 .limitTo(D::ENCODER & D::CODED)
Harish Mahendrakar71cbb9d2019-05-21 11:21:27 -0700[diff] [blame]361 .withC2Mappers<C2Config::bitrate_mode_t>());
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]362 // remove when codecs switch to PARAMKEY and new modes
363 deprecated(ConfigMapper(KEY_BITRATE_MODE, "coded.bitrate-mode", "value")
364 .limitTo(D::ENCODER));
365 add(ConfigMapper(KEY_FRAME_RATE, C2_PARAMKEY_FRAME_RATE, "value")
366 .limitTo(D::VIDEO)
367 .withMappers(makeFloat, [](C2Value v) -> C2Value {
368 // read back always as int
369 float value;
370 if (v.get(&value)) {
371 return (int32_t)value;
372 }
373 return C2Value();
374 }));
375
376 add(ConfigMapper(KEY_MAX_INPUT_SIZE, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE, "value")
377 .limitTo(D::INPUT));
378 // remove when codecs switch to PARAMKEY
379 deprecated(ConfigMapper(KEY_MAX_INPUT_SIZE, "coded.max-frame-size", "value")
380 .limitTo(D::INPUT));
381
382 // Rotation
383 // Note: SDK rotation is clock-wise, while C2 rotation is counter-clock-wise
384 add(ConfigMapper(KEY_ROTATION, C2_PARAMKEY_VUI_ROTATION, "value")
385 .limitTo(D::VIDEO & D::CODED)
386 .withMappers(negate, negate));
387 add(ConfigMapper(KEY_ROTATION, C2_PARAMKEY_ROTATION, "value")
388 .limitTo(D::VIDEO & D::RAW)
389 .withMappers(negate, negate));
390
391 // android 'video-scaling'
392 add(ConfigMapper("android._video-scaling", C2_PARAMKEY_SURFACE_SCALING_MODE, "value")
393 .limitTo(D::VIDEO & D::DECODER & D::RAW));
394
395 // Color Aspects
396 //
397 // configure default for decoders
398 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "range")
399 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM))
400 .withC2Mappers<C2Color::range_t>());
401 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "transfer")
402 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM))
403 .withC2Mappers<C2Color::transfer_t>());
404 add(ConfigMapper("color-primaries", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "primaries")
405 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM)));
406 add(ConfigMapper("color-matrix", C2_PARAMKEY_DEFAULT_COLOR_ASPECTS, "matrix")
407 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::CODED & (D::CONFIG | D::PARAM)));
408
409 // read back final for decoder output (also, configure final aspects as well. This should be
410 // overwritten based on coded/default values if component supports color aspects, but is used
411 // as final values if component does not support aspects at all)
412 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_COLOR_ASPECTS, "range")
413 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW)
414 .withC2Mappers<C2Color::range_t>());
415 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_COLOR_ASPECTS, "transfer")
416 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW)
417 .withC2Mappers<C2Color::transfer_t>());
418 add(ConfigMapper("color-primaries", C2_PARAMKEY_COLOR_ASPECTS, "primaries")
419 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW));
420 add(ConfigMapper("color-matrix", C2_PARAMKEY_COLOR_ASPECTS, "matrix")
421 .limitTo((D::VIDEO | D::IMAGE) & D::DECODER & D::RAW));
422
423 // configure source aspects for encoders and read them back on the coded(!) port.
424 // This is to ensure muxing the desired aspects into the container.
425 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_COLOR_ASPECTS, "range")
426 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED)
427 .withC2Mappers<C2Color::range_t>());
428 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_COLOR_ASPECTS, "transfer")
429 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED)
430 .withC2Mappers<C2Color::transfer_t>());
431 add(ConfigMapper("color-primaries", C2_PARAMKEY_COLOR_ASPECTS, "primaries")
432 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED));
433 add(ConfigMapper("color-matrix", C2_PARAMKEY_COLOR_ASPECTS, "matrix")
434 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::CODED));
435
436 // read back coded aspects for encoders (on the raw port), but also configure
437 // desired aspects here.
438 add(ConfigMapper(KEY_COLOR_RANGE, C2_PARAMKEY_VUI_COLOR_ASPECTS, "range")
439 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW)
440 .withC2Mappers<C2Color::range_t>());
441 add(ConfigMapper(KEY_COLOR_TRANSFER, C2_PARAMKEY_VUI_COLOR_ASPECTS, "transfer")
442 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW)
443 .withC2Mappers<C2Color::transfer_t>());
444 add(ConfigMapper("color-primaries", C2_PARAMKEY_VUI_COLOR_ASPECTS, "primaries")
445 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW));
446 add(ConfigMapper("color-matrix", C2_PARAMKEY_VUI_COLOR_ASPECTS, "matrix")
447 .limitTo((D::VIDEO | D::IMAGE) & D::ENCODER & D::RAW));
448
449 // Dataspace
450 add(ConfigMapper("android._dataspace", C2_PARAMKEY_DATA_SPACE, "value")
451 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
452
453 // HDR
454 add(ConfigMapper("smpte2086.red.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.red.x")
455 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
456 add(ConfigMapper("smpte2086.red.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.red.y")
457 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
458 add(ConfigMapper("smpte2086.green.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.green.x")
459 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
460 add(ConfigMapper("smpte2086.green.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.green.y")
461 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
462 add(ConfigMapper("smpte2086.blue.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.blue.x")
463 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
464 add(ConfigMapper("smpte2086.blue.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.blue.y")
465 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
466 add(ConfigMapper("smpte2086.white.x", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.white.x")
467 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
468 add(ConfigMapper("smpte2086.white.y", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.white.y")
469 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
470 add(ConfigMapper("smpte2086.max-luminance", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.max-luminance")
471 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
472 add(ConfigMapper("smpte2086.min-luminance", C2_PARAMKEY_HDR_STATIC_INFO, "mastering.min-luminance")
473 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
474 add(ConfigMapper("cta861.max-cll", C2_PARAMKEY_HDR_STATIC_INFO, "max-cll")
475 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
476 add(ConfigMapper("cta861.max-fall", C2_PARAMKEY_HDR_STATIC_INFO, "max-fall")
477 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
478
479 add(ConfigMapper(std::string(KEY_FEATURE_) + FEATURE_SecurePlayback,
480 C2_PARAMKEY_SECURE_MODE, "value"));
481
Wonsik Kim9ca01d32019-04-01 14:45:47 -0700[diff] [blame]482 add(ConfigMapper(KEY_PREPEND_HEADERS_TO_SYNC_FRAMES,
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]483 C2_PARAMKEY_PREPEND_HEADER_MODE, "value")
484 .limitTo(D::ENCODER & D::VIDEO)
Wonsik Kim9ca01d32019-04-01 14:45:47 -0700[diff] [blame]485 .withMappers([](C2Value v) -> C2Value {
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]486 int32_t value;
Wonsik Kim9ca01d32019-04-01 14:45:47 -0700[diff] [blame]487 if (v.get(&value)) {
488 return value ? C2Value(C2Config::PREPEND_HEADER_TO_ALL_SYNC)
489 : C2Value(C2Config::PREPEND_HEADER_TO_NONE);
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]490 }
Wonsik Kim9ca01d32019-04-01 14:45:47 -0700[diff] [blame]491 return C2Value();
492 }, [](C2Value v) -> C2Value {
493 C2Config::prepend_header_mode_t value;
494 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(value)>::type;
495 if (v.get((C2ValueType *)&value)) {
496 switch (value) {
497 case C2Config::PREPEND_HEADER_TO_NONE: return 0;
498 case C2Config::PREPEND_HEADER_TO_ALL_SYNC: return 1;
499 case C2Config::PREPEND_HEADER_ON_CHANGE: [[fallthrough]];
500 default: return C2Value();
501 }
502 }
503 return C2Value();
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]504 }));
505 // remove when codecs switch to PARAMKEY
Wonsik Kim9ca01d32019-04-01 14:45:47 -0700[diff] [blame]506 deprecated(ConfigMapper(KEY_PREPEND_HEADERS_TO_SYNC_FRAMES,
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]507 "coding.add-csd-to-sync-frames", "value")
508 .limitTo(D::ENCODER & D::VIDEO));
509 // convert to timestamp base
510 add(ConfigMapper(KEY_I_FRAME_INTERVAL, C2_PARAMKEY_SYNC_FRAME_INTERVAL, "value")
Wonsik Kimec588002019-07-11 13:43:38 -0700[diff] [blame^]511 .limitTo(D::VIDEO & D::ENCODER & D::CONFIG)
512 .withMapper([](C2Value v) -> C2Value {
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]513 // convert from i32 to float
514 int32_t i32Value;
515 float fpValue;
516 if (v.get(&i32Value)) {
517 return int64_t(1000000) * i32Value;
518 } else if (v.get(&fpValue)) {
519 return int64_t(c2_min(1000000 * fpValue + 0.5, (double)INT64_MAX));
520 }
521 return C2Value();
522 }));
523 // remove when codecs switch to proper coding.gop (add support for calculating gop)
524 deprecated(ConfigMapper("i-frame-period", "coding.gop", "intra-period")
525 .limitTo(D::ENCODER & D::VIDEO));
526 add(ConfigMapper(KEY_INTRA_REFRESH_PERIOD, C2_PARAMKEY_INTRA_REFRESH, "period")
527 .limitTo(D::VIDEO & D::ENCODER)
528 .withMappers(makeFloat, [](C2Value v) -> C2Value {
529 // read back always as int
530 float value;
531 if (v.get(&value)) {
532 return (int32_t)value;
533 }
534 return C2Value();
535 }));
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]536 deprecated(ConfigMapper(PARAMETER_KEY_REQUEST_SYNC_FRAME,
537 "coding.request-sync", "value")
538 .limitTo(D::PARAM & D::ENCODER)
539 .withMapper([](C2Value) -> C2Value { return uint32_t(1); }));
540 add(ConfigMapper(PARAMETER_KEY_REQUEST_SYNC_FRAME,
541 C2_PARAMKEY_REQUEST_SYNC_FRAME, "value")
542 .limitTo(D::PARAM & D::ENCODER)
543 .withMapper([](C2Value) -> C2Value { return uint32_t(1); }));
544
545 add(ConfigMapper(KEY_OPERATING_RATE, C2_PARAMKEY_OPERATING_RATE, "value")
546 .limitTo(D::PARAM | D::CONFIG) // write-only
547 .withMapper(makeFloat));
548 // C2 priorities are inverted
549 add(ConfigMapper(KEY_PRIORITY, C2_PARAMKEY_PRIORITY, "value")
550 .withMappers(negate, negate));
551 // remove when codecs switch to PARAMKEY
552 deprecated(ConfigMapper(KEY_OPERATING_RATE, "ctrl.operating-rate", "value")
553 .withMapper(makeFloat));
554 deprecated(ConfigMapper(KEY_PRIORITY, "ctrl.priority", "value"));
555
556 add(ConfigMapper(KEY_WIDTH, C2_PARAMKEY_PICTURE_SIZE, "width")
557 .limitTo(D::VIDEO | D::IMAGE));
558 add(ConfigMapper(KEY_HEIGHT, C2_PARAMKEY_PICTURE_SIZE, "height")
559 .limitTo(D::VIDEO | D::IMAGE));
560
561 add(ConfigMapper("crop-left", C2_PARAMKEY_CROP_RECT, "left")
562 .limitTo(D::VIDEO | D::IMAGE));
563 add(ConfigMapper("crop-top", C2_PARAMKEY_CROP_RECT, "top")
564 .limitTo(D::VIDEO | D::IMAGE));
565 add(ConfigMapper("crop-width", C2_PARAMKEY_CROP_RECT, "width")
566 .limitTo(D::VIDEO | D::IMAGE));
567 add(ConfigMapper("crop-height", C2_PARAMKEY_CROP_RECT, "height")
568 .limitTo(D::VIDEO | D::IMAGE));
569
570 add(ConfigMapper(KEY_MAX_WIDTH, C2_PARAMKEY_MAX_PICTURE_SIZE, "width")
571 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
572 add(ConfigMapper(KEY_MAX_HEIGHT, C2_PARAMKEY_MAX_PICTURE_SIZE, "height")
573 .limitTo((D::VIDEO | D::IMAGE) & D::RAW));
574
575 add(ConfigMapper("csd-0", C2_PARAMKEY_INIT_DATA, "value")
576 .limitTo(D::OUTPUT & D::READ));
577
Pawin Vongmasa8be93112018-12-11 14:01:42 -0800[diff] [blame]578 add(ConfigMapper(KEY_HDR10_PLUS_INFO, C2_PARAMKEY_INPUT_HDR10_PLUS_INFO, "value")
579 .limitTo(D::VIDEO & D::PARAM & D::INPUT));
580
581 add(ConfigMapper(KEY_HDR10_PLUS_INFO, C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO, "value")
582 .limitTo(D::VIDEO & D::OUTPUT));
583
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]584 add(ConfigMapper(C2_PARAMKEY_TEMPORAL_LAYERING, C2_PARAMKEY_TEMPORAL_LAYERING, "")
585 .limitTo(D::ENCODER & D::VIDEO & D::OUTPUT));
586
587 // Pixel Format (use local key for actual pixel format as we don't distinguish between
588 // SDK layouts for flexible format and we need the actual SDK color format in the media format)
589 add(ConfigMapper("android._color-format", C2_PARAMKEY_PIXEL_FORMAT, "value")
590 .limitTo((D::VIDEO | D::IMAGE) & D::RAW)
591 .withMappers([](C2Value v) -> C2Value {
592 int32_t value;
593 if (v.get(&value)) {
594 switch (value) {
595 case COLOR_FormatSurface:
596 return (uint32_t)HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
597 case COLOR_FormatYUV420Flexible:
598 return (uint32_t)HAL_PIXEL_FORMAT_YCBCR_420_888;
599 case COLOR_FormatYUV420Planar:
600 case COLOR_FormatYUV420SemiPlanar:
601 case COLOR_FormatYUV420PackedPlanar:
602 case COLOR_FormatYUV420PackedSemiPlanar:
603 return (uint32_t)HAL_PIXEL_FORMAT_YV12;
604 default:
605 // TODO: support some sort of passthrough
606 break;
607 }
608 }
609 return C2Value();
610 }, [](C2Value v) -> C2Value {
611 uint32_t value;
612 if (v.get(&value)) {
613 switch (value) {
614 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
615 return COLOR_FormatSurface;
616 case HAL_PIXEL_FORMAT_YV12:
617 case HAL_PIXEL_FORMAT_YCBCR_420_888:
618 return COLOR_FormatYUV420Flexible;
619 default:
620 // TODO: support some sort of passthrough
621 break;
622 }
623 }
624 return C2Value();
625 }));
626
627 add(ConfigMapper(KEY_CHANNEL_COUNT, C2_PARAMKEY_CHANNEL_COUNT, "value")
628 .limitTo(D::AUDIO)); // read back to both formats
629 add(ConfigMapper(KEY_CHANNEL_COUNT, C2_PARAMKEY_CODED_CHANNEL_COUNT, "value")
630 .limitTo(D::AUDIO & D::CODED));
631
632 add(ConfigMapper(KEY_SAMPLE_RATE, C2_PARAMKEY_SAMPLE_RATE, "value")
633 .limitTo(D::AUDIO)); // read back to both port formats
634 add(ConfigMapper(KEY_SAMPLE_RATE, C2_PARAMKEY_CODED_SAMPLE_RATE, "value")
635 .limitTo(D::AUDIO & D::CODED));
636
637 add(ConfigMapper(KEY_PCM_ENCODING, C2_PARAMKEY_PCM_ENCODING, "value")
Pawin Vongmasa8be93112018-12-11 14:01:42 -0800[diff] [blame]638 .limitTo(D::AUDIO)
639 .withMappers([](C2Value v) -> C2Value {
640 int32_t value;
641 C2Config::pcm_encoding_t to;
642 if (v.get(&value) && C2Mapper::map(value, &to)) {
643 return to;
644 }
645 return C2Value();
646 }, [](C2Value v) -> C2Value {
647 C2Config::pcm_encoding_t value;
648 int32_t to;
649 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(value)>::type;
650 if (v.get((C2ValueType*)&value) && C2Mapper::map(value, &to)) {
651 return to;
652 }
653 return C2Value();
654 }));
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]655
656 add(ConfigMapper(KEY_IS_ADTS, C2_PARAMKEY_AAC_PACKAGING, "value")
657 .limitTo(D::AUDIO & D::CODED)
658 .withMappers([](C2Value v) -> C2Value {
659 int32_t value;
660 if (v.get(&value) && value) {
661 return C2Config::AAC_PACKAGING_ADTS;
662 }
663 return C2Value();
664 }, [](C2Value v) -> C2Value {
665 uint32_t value;
666 if (v.get(&value) && value == C2Config::AAC_PACKAGING_ADTS) {
667 return (int32_t)1;
668 }
669 return C2Value();
670 }));
671
672 std::shared_ptr<C2Mapper::ProfileLevelMapper> mapper =
673 C2Mapper::GetProfileLevelMapper(mCodingMediaType);
674
675 add(ConfigMapper(KEY_PROFILE, C2_PARAMKEY_PROFILE_LEVEL, "profile")
676 .limitTo(D::CODED)
677 .withMappers([mapper](C2Value v) -> C2Value {
678 C2Config::profile_t c2 = PROFILE_UNUSED;
679 int32_t sdk;
680 if (mapper && v.get(&sdk) && mapper->mapProfile(sdk, &c2)) {
681 return c2;
682 }
683 return PROFILE_UNUSED;
684 }, [mapper](C2Value v) -> C2Value {
685 C2Config::profile_t c2;
686 int32_t sdk;
687 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
688 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapProfile(c2, &sdk)) {
689 return sdk;
690 }
691 return C2Value();
692 }));
693
694 add(ConfigMapper(KEY_LEVEL, C2_PARAMKEY_PROFILE_LEVEL, "level")
695 .limitTo(D::CODED)
696 .withMappers([mapper](C2Value v) -> C2Value {
697 C2Config::level_t c2 = LEVEL_UNUSED;
698 int32_t sdk;
699 if (mapper && v.get(&sdk) && mapper->mapLevel(sdk, &c2)) {
700 return c2;
701 }
702 return LEVEL_UNUSED;
703 }, [mapper](C2Value v) -> C2Value {
704 C2Config::level_t c2;
705 int32_t sdk;
706 using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
707 if (mapper && v.get((C2ValueType*)&c2) && mapper->mapLevel(c2, &sdk)) {
708 return sdk;
709 }
710 return C2Value();
711 }));
712
713 // convert to dBFS and add default
714 add(ConfigMapper(KEY_AAC_DRC_TARGET_REFERENCE_LEVEL, C2_PARAMKEY_DRC_TARGET_REFERENCE_LEVEL, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]715 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]716 .withMapper([](C2Value v) -> C2Value {
717 int32_t value;
718 if (!v.get(&value) || value < 0) {
719 value = property_get_int32(PROP_DRC_OVERRIDE_REF_LEVEL, DRC_DEFAULT_MOBILE_REF_LEVEL);
720 }
721 return float(-0.25 * c2_min(value, 127));
722 }));
723
724 // convert to 0-1 (%) and add default
725 add(ConfigMapper(KEY_AAC_DRC_ATTENUATION_FACTOR, C2_PARAMKEY_DRC_ATTENUATION_FACTOR, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]726 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]727 .withMapper([](C2Value v) -> C2Value {
728 int32_t value;
729 if (!v.get(&value) || value < 0) {
730 value = property_get_int32(PROP_DRC_OVERRIDE_CUT, DRC_DEFAULT_MOBILE_DRC_CUT);
731 }
732 return float(c2_min(value, 127) / 127.);
733 }));
734
735 // convert to 0-1 (%) and add default
736 add(ConfigMapper(KEY_AAC_DRC_BOOST_FACTOR, C2_PARAMKEY_DRC_BOOST_FACTOR, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]737 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]738 .withMapper([](C2Value v) -> C2Value {
739 int32_t value;
740 if (!v.get(&value) || value < 0) {
741 value = property_get_int32(PROP_DRC_OVERRIDE_BOOST, DRC_DEFAULT_MOBILE_DRC_BOOST);
742 }
743 return float(c2_min(value, 127) / 127.);
744 }));
745
746 // convert to compression type and add default
747 add(ConfigMapper(KEY_AAC_DRC_HEAVY_COMPRESSION, C2_PARAMKEY_DRC_COMPRESSION_MODE, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]748 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]749 .withMapper([](C2Value v) -> C2Value {
750 int32_t value;
751 if (!v.get(&value) || value < 0) {
752 value = property_get_int32(PROP_DRC_OVERRIDE_HEAVY, DRC_DEFAULT_MOBILE_DRC_HEAVY);
753 }
754 return value == 1 ? C2Config::DRC_COMPRESSION_HEAVY : C2Config::DRC_COMPRESSION_LIGHT;
755 }));
756
757 // convert to dBFS and add default
758 add(ConfigMapper(KEY_AAC_ENCODED_TARGET_LEVEL, C2_PARAMKEY_DRC_ENCODED_TARGET_LEVEL, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]759 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]760 .withMapper([](C2Value v) -> C2Value {
761 int32_t value;
762 if (!v.get(&value) || value < 0) {
763 value = property_get_int32(PROP_DRC_OVERRIDE_ENC_LEVEL, DRC_DEFAULT_MOBILE_ENC_LEVEL);
764 }
765 return float(-0.25 * c2_min(value, 127));
766 }));
767
768 // convert to effect type (these map to SDK values) and add default
769 add(ConfigMapper(KEY_AAC_DRC_EFFECT_TYPE, C2_PARAMKEY_DRC_EFFECT_TYPE, "value")
Wonsik Kim0080d7e2019-06-06 14:20:26 -0700[diff] [blame]770 .limitTo(D::AUDIO & D::DECODER & D::CONFIG)
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]771 .withMapper([](C2Value v) -> C2Value {
772 int32_t value;
773 if (!v.get(&value) || value < -1 || value > 8) {
774 value = property_get_int32(PROP_DRC_OVERRIDE_EFFECT, DRC_DEFAULT_MOBILE_DRC_EFFECT);
775 // ensure value is within range
776 if (value < -1 || value > 8) {
777 value = DRC_DEFAULT_MOBILE_DRC_EFFECT;
778 }
779 }
780 return value;
781 }));
782
783 add(ConfigMapper(KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT, C2_PARAMKEY_MAX_CHANNEL_COUNT, "value")
784 .limitTo(D::AUDIO));
785
786 add(ConfigMapper(KEY_AAC_SBR_MODE, C2_PARAMKEY_AAC_SBR_MODE, "value")
787 .limitTo(D::AUDIO & D::ENCODER & D::CONFIG)
788 .withMapper([](C2Value v) -> C2Value {
789 int32_t value;
790 if (!v.get(&value) || value < 0) {
791 return C2Config::AAC_SBR_AUTO;
792 }
793 switch (value) {
794 case 0: return C2Config::AAC_SBR_OFF;
795 case 1: return C2Config::AAC_SBR_SINGLE_RATE;
796 case 2: return C2Config::AAC_SBR_DUAL_RATE;
797 default: return C2Config::AAC_SBR_AUTO + 1; // invalid value
798 }
799 }));
800
Harish Mahendrakar9a4c8eb2019-05-29 15:41:20 -0700[diff] [blame]801 add(ConfigMapper(KEY_QUALITY, C2_PARAMKEY_QUALITY, "value")
802 .limitTo(D::ENCODER & (D::CONFIG | D::PARAM)));
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]803 add(ConfigMapper(KEY_FLAC_COMPRESSION_LEVEL, C2_PARAMKEY_COMPLEXITY, "value")
804 .limitTo(D::AUDIO & D::ENCODER));
805 add(ConfigMapper("complexity", C2_PARAMKEY_COMPLEXITY, "value")
Harish Mahendrakar9a4c8eb2019-05-29 15:41:20 -0700[diff] [blame]806 .limitTo(D::ENCODER & (D::CONFIG | D::PARAM)));
Pawin Vongmasa36653902018-11-15 00:10:25 -0800[diff] [blame]807
808 add(ConfigMapper(KEY_GRID_COLUMNS, C2_PARAMKEY_TILE_LAYOUT, "columns")
809 .limitTo(D::IMAGE));
810 add(ConfigMapper(KEY_GRID_ROWS, C2_PARAMKEY_TILE_LAYOUT, "rows")
811 .limitTo(D::IMAGE));
812 add(ConfigMapper(KEY_TILE_WIDTH, C2_PARAMKEY_TILE_LAYOUT, "tile.width")
813 .limitTo(D::IMAGE));
814 add(ConfigMapper(KEY_TILE_HEIGHT, C2_PARAMKEY_TILE_LAYOUT, "tile.height")
815 .limitTo(D::IMAGE));
816
817 add(ConfigMapper(KEY_LATENCY, C2_PARAMKEY_PIPELINE_DELAY_REQUEST, "value")
818 .limitTo(D::VIDEO & D::ENCODER));
819
820 add(ConfigMapper(C2_PARAMKEY_INPUT_TIME_STRETCH, C2_PARAMKEY_INPUT_TIME_STRETCH, "value"));
821
822 /* still to do
823 constexpr char KEY_PUSH_BLANK_BUFFERS_ON_STOP[] = "push-blank-buffers-on-shutdown";
824
825 not yet used by MediaCodec, but defined as MediaFormat
826 KEY_AUDIO_SESSION_ID // we use "audio-hw-sync"
827 KEY_OUTPUT_REORDER_DEPTH
828 */
829}
830
831status_t CCodecConfig::initialize(
832 const std::shared_ptr<Codec2Client> &client,
833 const std::shared_ptr<Codec2Client::Component> &component) {
834 C2ComponentDomainSetting domain(C2Component::DOMAIN_OTHER);
835 C2ComponentKindSetting kind(C2Component::KIND_OTHER);
836
837 std::vector<std::unique_ptr<C2Param>> queried;
838 c2_status_t c2err = component->query({ &domain, &kind }, {}, C2_DONT_BLOCK, &queried);
839 if (c2err != C2_OK) {
840 ALOGD("Query domain & kind failed => %s", asString(c2err));
841 // TEMP: determine kind from component name
842 if (kind.value == C2Component::KIND_OTHER) {
843 if (component->getName().find("encoder") != std::string::npos) {
844 kind.value = C2Component::KIND_ENCODER;
845 } else if (component->getName().find("decoder") != std::string::npos) {
846 kind.value = C2Component::KIND_DECODER;
847 }
848 }
849
850 // TEMP: determine domain from media type (port (preferred) or stream #0)
851 if (domain.value == C2Component::DOMAIN_OTHER) {
852 AString mediaType = QueryMediaType(true /* input */, component);
853 if (mediaType.startsWith("audio/")) {
854 domain.value = C2Component::DOMAIN_AUDIO;
855 } else if (mediaType.startsWith("video/")) {
856 domain.value = C2Component::DOMAIN_VIDEO;
857 } else if (mediaType.startsWith("image/")) {
858 domain.value = C2Component::DOMAIN_IMAGE;
859 }
860 }
861 }
862
863 mDomain = (domain.value == C2Component::DOMAIN_VIDEO ? Domain::IS_VIDEO :
864 domain.value == C2Component::DOMAIN_IMAGE ? Domain::IS_IMAGE :
865 domain.value == C2Component::DOMAIN_AUDIO ? Domain::IS_AUDIO : Domain::OTHER_DOMAIN)
866 | (kind.value == C2Component::KIND_DECODER ? Domain::IS_DECODER :
867 kind.value == C2Component::KIND_ENCODER ? Domain::IS_ENCODER : Domain::OTHER_KIND);
868
869 mInputDomain = Domain(((mDomain & IS_DECODER) ? IS_CODED : IS_RAW) | IS_INPUT);
870 mOutputDomain = Domain(((mDomain & IS_ENCODER) ? IS_CODED : IS_RAW) | IS_OUTPUT);
871
872 ALOGV("domain is %#x (%u %u)", mDomain, domain.value, kind.value);
873
874 std::vector<C2Param::Index> paramIndices;
875 switch (kind.value) {
876 case C2Component::KIND_DECODER:
877 mCodingMediaType = QueryMediaType(true /* input */, component).c_str();
878 break;
879 case C2Component::KIND_ENCODER:
880 mCodingMediaType = QueryMediaType(false /* input */, component).c_str();
881 break;
882 default:
883 mCodingMediaType = "";
884 }
885
886 c2err = component->querySupportedParams(&mParamDescs);
887 if (c2err != C2_OK) {
888 ALOGD("Query supported params failed after returning %zu values => %s",
889 mParamDescs.size(), asString(c2err));
890 return UNKNOWN_ERROR;
891 }
892 for (const std::shared_ptr<C2ParamDescriptor> &desc : mParamDescs) {
893 mSupportedIndices.emplace(desc->index());
894 }
895
896 mReflector = client->getParamReflector();
897 if (mReflector == nullptr) {
898 ALOGE("Failed to get param reflector");
899 return UNKNOWN_ERROR;
900 }
901
902 // enumerate all fields
903 mParamUpdater = std::make_shared<ReflectedParamUpdater>();
904 mParamUpdater->clear();
905 mParamUpdater->supportWholeParam(
906 C2_PARAMKEY_TEMPORAL_LAYERING, C2StreamTemporalLayeringTuning::CORE_INDEX);
907 mParamUpdater->addParamDesc(mReflector, mParamDescs);
908
909 // TEMP: add some standard fields even if not reflected
910 if (kind.value == C2Component::KIND_ENCODER) {
911 mParamUpdater->addStandardParam<C2StreamInitDataInfo::output>(C2_PARAMKEY_INIT_DATA);
912 }
913 if (domain.value == C2Component::DOMAIN_IMAGE || domain.value == C2Component::DOMAIN_VIDEO) {
914 if (kind.value != C2Component::KIND_ENCODER) {
915 addLocalParam<C2StreamPictureSizeInfo::output>(C2_PARAMKEY_PICTURE_SIZE);
916 addLocalParam<C2StreamCropRectInfo::output>(C2_PARAMKEY_CROP_RECT);
917 addLocalParam(
918 new C2StreamPixelAspectRatioInfo::output(0u, 1u, 1u),
919 C2_PARAMKEY_PIXEL_ASPECT_RATIO);
920 addLocalParam(new C2StreamRotationInfo::output(0u, 0), C2_PARAMKEY_ROTATION);
921 addLocalParam(new C2StreamColorAspectsInfo::output(0u), C2_PARAMKEY_COLOR_ASPECTS);
922 addLocalParam<C2StreamDataSpaceInfo::output>(C2_PARAMKEY_DATA_SPACE);
923 addLocalParam<C2StreamHdrStaticInfo::output>(C2_PARAMKEY_HDR_STATIC_INFO);
924 addLocalParam(new C2StreamSurfaceScalingInfo::output(0u, VIDEO_SCALING_MODE_SCALE_TO_FIT),
925 C2_PARAMKEY_SURFACE_SCALING_MODE);
926 } else {
927 addLocalParam(new C2StreamColorAspectsInfo::input(0u), C2_PARAMKEY_COLOR_ASPECTS);
928 }
929 }
930
931 initializeStandardParams();
932
933 // subscribe to all supported standard (exposed) params
934 // TODO: limit this to params that are actually in the domain
935 std::vector<std::string> formatKeys = mStandardParams->getPathsForDomain(Domain(1 << 30));
936 std::vector<C2Param::Index> indices;
937 mParamUpdater->getParamIndicesForKeys(formatKeys, &indices);
938 mSubscribedIndices.insert(indices.begin(), indices.end());
939
940 // also subscribe to some non-SDK standard parameters
941 // for number of input/output buffers
942 mSubscribedIndices.emplace(C2PortSuggestedBufferCountTuning::input::PARAM_TYPE);
943 mSubscribedIndices.emplace(C2PortSuggestedBufferCountTuning::output::PARAM_TYPE);
944 mSubscribedIndices.emplace(C2ActualPipelineDelayTuning::PARAM_TYPE);
945 mSubscribedIndices.emplace(C2PortActualDelayTuning::input::PARAM_TYPE);
946 mSubscribedIndices.emplace(C2PortActualDelayTuning::output::PARAM_TYPE);
947 // for output buffer array allocation
948 mSubscribedIndices.emplace(C2StreamMaxBufferSizeInfo::output::PARAM_TYPE);
949 // init data (CSD)
950 mSubscribedIndices.emplace(C2StreamInitDataInfo::output::PARAM_TYPE);
951
952 return OK;
953}
954
955status_t CCodecConfig::subscribeToConfigUpdate(
956 const std::shared_ptr<Codec2Client::Component> &component,
957 const std::vector<C2Param::Index> &indices,
958 c2_blocking_t blocking) {
959 mSubscribedIndices.insert(indices.begin(), indices.end());
960 // TODO: enable this when components no longer crash on this config
961 if (mSubscribedIndices.size() != mSubscribedIndicesSize && false) {
962 std::vector<uint32_t> indices;
963 for (C2Param::Index ix : mSubscribedIndices) {
964 indices.push_back(ix);
965 }
966 std::unique_ptr<C2SubscribedParamIndicesTuning> subscribeTuning =
967 C2SubscribedParamIndicesTuning::AllocUnique(indices);
968 std::vector<std::unique_ptr<C2SettingResult>> results;
969 c2_status_t c2Err = component->config({ subscribeTuning.get() }, blocking, &results);
970 if (c2Err != C2_OK && c2Err != C2_BAD_INDEX) {
971 ALOGD("Failed to subscribe to parameters => %s", asString(c2Err));
972 // TODO: error
973 }
974 ALOGV("Subscribed to %zu params", mSubscribedIndices.size());
975 mSubscribedIndicesSize = mSubscribedIndices.size();
976 }
977 return OK;
978}
979
980status_t CCodecConfig::queryConfiguration(
981 const std::shared_ptr<Codec2Client::Component> &component) {
982 // query all subscribed parameters
983 std::vector<C2Param::Index> indices(mSubscribedIndices.begin(), mSubscribedIndices.end());
984 std::vector<std::unique_ptr<C2Param>> queried;
985 c2_status_t c2Err = component->query({}, indices, C2_MAY_BLOCK, &queried);
986 if (c2Err != OK) {
987 ALOGI("query failed after returning %zu values (%s)", queried.size(), asString(c2Err));
988 // TODO: error
989 }
990
991 updateConfiguration(queried, ALL);
992 return OK;
993}
994
995bool CCodecConfig::updateConfiguration(
996 std::vector<std::unique_ptr<C2Param>> &configUpdate, Domain domain) {
997 ALOGV("updating configuration with %zu params", configUpdate.size());
998 bool changed = false;
999 for (std::unique_ptr<C2Param> &p : configUpdate) {
1000 if (p && *p) {
1001 auto insertion = mCurrentConfig.emplace(p->index(), nullptr);
1002 if (insertion.second || *insertion.first->second != *p) {
1003 if (mSupportedIndices.count(p->index()) || mLocalParams.count(p->index())) {
1004 // only track changes in supported (reflected or local) indices
1005 changed = true;
1006 } else {
1007 ALOGV("an unlisted config was %s: %#x",
1008 insertion.second ? "added" : "updated", p->index());
1009 }
1010 }
1011 insertion.first->second = std::move(p);
1012 }
1013 }
1014
1015 ALOGV("updated configuration has %zu params (%s)", mCurrentConfig.size(),
1016 changed ? "CHANGED" : "no change");
1017 if (changed) {
1018 return updateFormats(domain);
1019 }
1020 return false;
1021}
1022
1023bool CCodecConfig::updateFormats(Domain domain) {
1024 // get addresses of params in the current config
1025 std::vector<C2Param*> paramPointers;
1026 for (const auto &it : mCurrentConfig) {
1027 paramPointers.push_back(it.second.get());
1028 }
1029
1030 ReflectedParamUpdater::Dict reflected = mParamUpdater->getParams(paramPointers);
1031 ALOGD("c2 config is %s", reflected.debugString().c_str());
1032
1033 bool changed = false;
1034 if (domain & mInputDomain) {
1035 sp<AMessage> oldFormat = mInputFormat;
1036 mInputFormat = mInputFormat->dup(); // trigger format changed
1037 mInputFormat->extend(getSdkFormatForDomain(reflected, mInputDomain));
1038 if (mInputFormat->countEntries() != oldFormat->countEntries()
1039 || mInputFormat->changesFrom(oldFormat)->countEntries() > 0) {
1040 changed = true;
1041 } else {
1042 mInputFormat = oldFormat; // no change
1043 }
1044 }
1045 if (domain & mOutputDomain) {
1046 sp<AMessage> oldFormat = mOutputFormat;
1047 mOutputFormat = mOutputFormat->dup(); // trigger output format changed
1048 mOutputFormat->extend(getSdkFormatForDomain(reflected, mOutputDomain));
1049 if (mOutputFormat->countEntries() != oldFormat->countEntries()
1050 || mOutputFormat->changesFrom(oldFormat)->countEntries() > 0) {
1051 changed = true;
1052 } else {
1053 mOutputFormat = oldFormat; // no change
1054 }
1055 }
1056 ALOGV_IF(changed, "format(s) changed");
1057 return changed;
1058}
1059
1060sp<AMessage> CCodecConfig::getSdkFormatForDomain(
1061 const ReflectedParamUpdater::Dict &reflected, Domain portDomain) const {
1062 sp<AMessage> msg = new AMessage;
1063 for (const std::pair<std::string, std::vector<ConfigMapper>> &el : mStandardParams->getKeys()) {
1064 for (const ConfigMapper &cm : el.second) {
1065 if ((cm.domain() & portDomain) == 0 // input-output-coded-raw
1066 || (cm.domain() & mDomain) != mDomain // component domain + kind (these must match)
1067 || (cm.domain() & IS_READ) == 0) {
1068 continue;
1069 }
1070 auto it = reflected.find(cm.path());
1071 if (it == reflected.end()) {
1072 continue;
1073 }
1074 C2Value c2Value;
1075 sp<ABuffer> bufValue;
1076 AString strValue;
1077 AMessage::ItemData item;
1078 if (it->second.find(&c2Value)) {
1079 item = cm.mapToMessage(c2Value);
1080 } else if (it->second.find(&bufValue)) {
1081 item.set(bufValue);
1082 } else if (it->second.find(&strValue)) {
1083 item.set(strValue);
1084 } else {
1085 ALOGD("unexpected untyped query value for key: %s", cm.path().c_str());
1086 continue;
1087 }
1088 msg->setItem(el.first.c_str(), item);
1089 }
1090 }
1091
1092 { // convert from Codec 2.0 rect to MediaFormat rect and add crop rect if not present
1093 int32_t left, top, width, height;
1094 if (msg->findInt32("crop-left", &left) && msg->findInt32("crop-width", &width)
1095 && msg->findInt32("crop-top", &top) && msg->findInt32("crop-height", &height)
1096 && left >= 0 && width >=0 && width <= INT32_MAX - left
1097 && top >= 0 && height >=0 && height <= INT32_MAX - top) {
1098 msg->removeEntryAt(msg->findEntryByName("crop-left"));
1099 msg->removeEntryAt(msg->findEntryByName("crop-top"));
1100 msg->removeEntryAt(msg->findEntryByName("crop-width"));
1101 msg->removeEntryAt(msg->findEntryByName("crop-height"));
1102 msg->setRect("crop", left, top, left + width - 1, top + height - 1);
1103 } else if (msg->findInt32("width", &width) && msg->findInt32("height", &height)) {
1104 msg->setRect("crop", 0, 0, width - 1, height - 1);
1105 }
1106 }
1107
1108 { // convert temporal layering to schema
1109 sp<ABuffer> tmp;
1110 if (msg->findBuffer(C2_PARAMKEY_TEMPORAL_LAYERING, &tmp) && tmp != nullptr) {
1111 C2StreamTemporalLayeringTuning *layering =
1112 C2StreamTemporalLayeringTuning::From(C2Param::From(tmp->data(), tmp->size()));
1113 if (layering && layering->m.layerCount > 0
1114 && layering->m.bLayerCount < layering->m.layerCount) {
1115 // check if this is webrtc compatible
1116 AString mime;
1117 if (msg->findString(KEY_MIME, &mime) &&
1118 mime.equalsIgnoreCase(MIMETYPE_VIDEO_VP8) &&
1119 layering->m.bLayerCount == 0 &&
1120 (layering->m.layerCount == 1
1121 || (layering->m.layerCount == 2
1122 && layering->flexCount() >= 1
1123 && layering->m.bitrateRatios[0] == .6f)
1124 || (layering->m.layerCount == 3
1125 && layering->flexCount() >= 2
1126 && layering->m.bitrateRatios[0] == .4f
1127 && layering->m.bitrateRatios[1] == .6f)
1128 || (layering->m.layerCount == 4
1129 && layering->flexCount() >= 3
1130 && layering->m.bitrateRatios[0] == .25f
1131 && layering->m.bitrateRatios[1] == .4f
1132 && layering->m.bitrateRatios[2] == .6f))) {
1133 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1134 "webrtc.vp8.%u-layer", layering->m.layerCount));
1135 } else if (layering->m.bLayerCount) {
1136 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1137 "android.generic.%u+%u",
1138 layering->m.layerCount - layering->m.bLayerCount,
1139 layering->m.bLayerCount));
1140 } else if (layering->m.bLayerCount) {
1141 msg->setString(KEY_TEMPORAL_LAYERING, AStringPrintf(
1142 "android.generic.%u", layering->m.layerCount));
1143 }
1144 }
1145 msg->removeEntryAt(msg->findEntryByName(C2_PARAMKEY_TEMPORAL_LAYERING));
1146 }
1147 }
1148
1149 { // convert color info
1150 C2Color::primaries_t primaries;
1151 C2Color::matrix_t matrix;
1152 if (msg->findInt32("color-primaries", (int32_t*)&primaries)
1153 && msg->findInt32("color-matrix", (int32_t*)&matrix)) {
1154 int32_t standard;
1155
1156 if (C2Mapper::map(primaries, matrix, &standard)) {
1157 msg->setInt32(KEY_COLOR_STANDARD, standard);
1158 }
1159
1160 msg->removeEntryAt(msg->findEntryByName("color-primaries"));
1161 msg->removeEntryAt(msg->findEntryByName("color-matrix"));
1162 }
1163
1164
1165 // calculate dataspace for raw graphic buffers if not specified by component, or if
1166 // using surface with unspecified aspects (as those must be defaulted which may change
1167 // the dataspace)
1168 if ((portDomain & IS_RAW) && (mDomain & (IS_IMAGE | IS_VIDEO))) {
1169 android_dataspace dataspace;
1170 ColorAspects aspects = {
1171 ColorAspects::RangeUnspecified, ColorAspects::PrimariesUnspecified,
1172 ColorAspects::TransferUnspecified, ColorAspects::MatrixUnspecified
1173 };
1174 ColorUtils::getColorAspectsFromFormat(msg, aspects);
1175 ColorAspects origAspects = aspects;
1176 if (mUsingSurface) {
1177 // get image size (default to HD)
1178 int32_t width = 1280;
1179 int32_t height = 720;
1180 int32_t left, top, right, bottom;
1181 if (msg->findRect("crop", &left, &top, &right, &bottom)) {
1182 width = right - left + 1;
1183 height = bottom - top + 1;
1184 } else {
1185 (void)msg->findInt32(KEY_WIDTH, &width);
1186 (void)msg->findInt32(KEY_HEIGHT, &height);
1187 }
1188 ColorUtils::setDefaultCodecColorAspectsIfNeeded(aspects, width, height);
1189 ColorUtils::setColorAspectsIntoFormat(aspects, msg);
1190 }
1191
1192 if (!msg->findInt32("android._dataspace", (int32_t*)&dataspace)
1193 || aspects.mRange != origAspects.mRange
1194 || aspects.mPrimaries != origAspects.mPrimaries
1195 || aspects.mTransfer != origAspects.mTransfer
1196 || aspects.mMatrixCoeffs != origAspects.mMatrixCoeffs) {
1197 dataspace = ColorUtils::getDataSpaceForColorAspects(aspects, true /* mayExpand */);
1198 msg->setInt32("android._dataspace", dataspace);
1199 }
1200 }
1201
1202 // HDR static info
1203
1204 C2HdrStaticMetadataStruct hdr;
1205 if (msg->findFloat("smpte2086.red.x", &hdr.mastering.red.x)
1206 && msg->findFloat("smpte2086.red.y", &hdr.mastering.red.y)
1207 && msg->findFloat("smpte2086.green.x", &hdr.mastering.green.x)
1208 && msg->findFloat("smpte2086.green.y", &hdr.mastering.green.y)
1209 && msg->findFloat("smpte2086.blue.x", &hdr.mastering.blue.x)
1210 && msg->findFloat("smpte2086.blue.y", &hdr.mastering.blue.y)
1211 && msg->findFloat("smpte2086.white.x", &hdr.mastering.white.x)
1212 && msg->findFloat("smpte2086.white.y", &hdr.mastering.white.y)
1213 && msg->findFloat("smpte2086.max-luminance", &hdr.mastering.maxLuminance)
1214 && msg->findFloat("smpte2086.min-luminance", &hdr.mastering.minLuminance)
1215 && msg->findFloat("cta861.max-cll", &hdr.maxCll)
1216 && msg->findFloat("cta861.max-fall", &hdr.maxFall)) {
1217 if (hdr.mastering.red.x >= 0 && hdr.mastering.red.x <= 1
1218 && hdr.mastering.red.y >= 0 && hdr.mastering.red.y <= 1
1219 && hdr.mastering.green.x >= 0 && hdr.mastering.green.x <= 1
1220 && hdr.mastering.green.y >= 0 && hdr.mastering.green.y <= 1
1221 && hdr.mastering.blue.x >= 0 && hdr.mastering.blue.x <= 1
1222 && hdr.mastering.blue.y >= 0 && hdr.mastering.blue.y <= 1
1223 && hdr.mastering.white.x >= 0 && hdr.mastering.white.x <= 1
1224 && hdr.mastering.white.y >= 0 && hdr.mastering.white.y <= 1
1225 && hdr.mastering.maxLuminance >= 0 && hdr.mastering.maxLuminance <= 65535
1226 && hdr.mastering.minLuminance >= 0 && hdr.mastering.minLuminance <= 6.5535
1227 && hdr.maxCll >= 0 && hdr.maxCll <= 65535
1228 && hdr.maxFall >= 0 && hdr.maxFall <= 65535) {
1229 HDRStaticInfo meta;
1230 meta.mID = meta.kType1;
1231 meta.sType1.mR.x = hdr.mastering.red.x / 0.00002 + 0.5;
1232 meta.sType1.mR.y = hdr.mastering.red.y / 0.00002 + 0.5;
1233 meta.sType1.mG.x = hdr.mastering.green.x / 0.00002 + 0.5;
1234 meta.sType1.mG.y = hdr.mastering.green.y / 0.00002 + 0.5;
1235 meta.sType1.mB.x = hdr.mastering.blue.x / 0.00002 + 0.5;
1236 meta.sType1.mB.y = hdr.mastering.blue.y / 0.00002 + 0.5;
1237 meta.sType1.mW.x = hdr.mastering.white.x / 0.00002 + 0.5;
1238 meta.sType1.mW.y = hdr.mastering.white.y / 0.00002 + 0.5;
1239 meta.sType1.mMaxDisplayLuminance = hdr.mastering.maxLuminance + 0.5;
1240 meta.sType1.mMinDisplayLuminance = hdr.mastering.minLuminance / 0.0001 + 0.5;
1241 meta.sType1.mMaxContentLightLevel = hdr.maxCll + 0.5;
1242 meta.sType1.mMaxFrameAverageLightLevel = hdr.maxFall + 0.5;
1243 msg->removeEntryAt(msg->findEntryByName("smpte2086.red.x"));
1244 msg->removeEntryAt(msg->findEntryByName("smpte2086.red.y"));
1245 msg->removeEntryAt(msg->findEntryByName("smpte2086.green.x"));
1246 msg->removeEntryAt(msg->findEntryByName("smpte2086.green.y"));
1247 msg->removeEntryAt(msg->findEntryByName("smpte2086.blue.x"));
1248 msg->removeEntryAt(msg->findEntryByName("smpte2086.blue.y"));
1249 msg->removeEntryAt(msg->findEntryByName("smpte2086.white.x"));
1250 msg->removeEntryAt(msg->findEntryByName("smpte2086.white.y"));
1251 msg->removeEntryAt(msg->findEntryByName("smpte2086.max-luminance"));
1252 msg->removeEntryAt(msg->findEntryByName("smpte2086.min-luminance"));
1253 msg->removeEntryAt(msg->findEntryByName("cta861.max-cll"));
1254 msg->removeEntryAt(msg->findEntryByName("cta861.max-fall"));
1255 msg->setBuffer(KEY_HDR_STATIC_INFO, ABuffer::CreateAsCopy(&meta, sizeof(meta)));
1256 } else {
1257 ALOGD("found invalid HDR static metadata %s", msg->debugString(8).c_str());
1258 }
1259 }
1260 }
1261
1262 ALOGV("converted to SDK values as %s", msg->debugString().c_str());
1263 return msg;
1264}
1265
1266/// converts an AMessage value to a ParamUpdater value
1267static void convert(const AMessage::ItemData &from, ReflectedParamUpdater::Value *to) {
1268 int32_t int32Value;
1269 int64_t int64Value;
1270 sp<ABuffer> bufValue;
1271 AString strValue;
1272 float floatValue;
1273 double doubleValue;
1274
1275 if (from.find(&int32Value)) {
1276 to->set(int32Value);
1277 } else if (from.find(&int64Value)) {
1278 to->set(int64Value);
1279 } else if (from.find(&bufValue)) {
1280 to->set(bufValue);
1281 } else if (from.find(&strValue)) {
1282 to->set(strValue);
1283 } else if (from.find(&floatValue)) {
1284 to->set(C2Value(floatValue));
1285 } else if (from.find(&doubleValue)) {
1286 // convert double to float
1287 to->set(C2Value((float)doubleValue));
1288 }
1289 // ignore all other AMessage types
1290}
1291
1292/// relaxes Codec 2.0 specific value types to SDK types (mainly removes signedness and counterness
1293/// from 32/64-bit values.)
1294static void relaxValues(ReflectedParamUpdater::Value &item) {
1295 C2Value c2Value;
1296 int32_t int32Value;
1297 int64_t int64Value;
1298 (void)item.find(&c2Value);
1299 if (c2Value.get(&int32Value) || c2Value.get((uint32_t*)&int32Value)
1300 || c2Value.get((c2_cntr32_t*)&int32Value)) {
1301 item.set(int32Value);
1302 } else if (c2Value.get(&int64Value)
1303 || c2Value.get((uint64_t*)&int64Value)
1304 || c2Value.get((c2_cntr64_t*)&int64Value)) {
1305 item.set(int64Value);
1306 }
1307}
1308
1309ReflectedParamUpdater::Dict CCodecConfig::getReflectedFormat(
1310 const sp<AMessage> &params_, Domain configDomain) const {
1311 // create a modifiable copy of params
1312 sp<AMessage> params = params_->dup();
1313 ALOGV("filtering with config domain %x", configDomain);
1314
1315 // convert some macro parameters to Codec 2.0 specific expressions
1316
1317 { // make i-frame-interval frame based
1318 float iFrameInterval;
1319 if (params->findAsFloat(KEY_I_FRAME_INTERVAL, &iFrameInterval)) {
1320 float frameRate;
1321 if (params->findAsFloat(KEY_FRAME_RATE, &frameRate)) {
1322 params->setInt32("i-frame-period",
1323 (frameRate <= 0 || iFrameInterval < 0)
1324 ? -1 /* no sync frames */
1325 : (int32_t)c2_min(iFrameInterval * frameRate + 0.5,
1326 (float)INT32_MAX));
1327 }
1328 }
1329 }
1330
1331 if (mDomain == (IS_VIDEO | IS_ENCODER)) {
1332 // convert capture-rate into input-time-stretch
1333 float frameRate, captureRate;
1334 if (params->findAsFloat(KEY_FRAME_RATE, &frameRate)) {
1335 if (!params->findAsFloat("time-lapse-fps", &captureRate)
1336 && !params->findAsFloat(KEY_CAPTURE_RATE, &captureRate)) {
1337 captureRate = frameRate;
1338 }
1339 if (captureRate > 0 && frameRate > 0) {
1340 params->setFloat(C2_PARAMKEY_INPUT_TIME_STRETCH, captureRate / frameRate);
1341 }
1342 }
1343 }
1344
1345 { // reflect temporal layering into a binary blob
1346 AString schema;
1347 if (params->findString(KEY_TEMPORAL_LAYERING, &schema)) {
1348 unsigned int numLayers = 0;
1349 unsigned int numBLayers = 0;
1350 int tags;
1351 char dummy;
1352 std::unique_ptr<C2StreamTemporalLayeringTuning::output> layering;
1353 if (sscanf(schema.c_str(), "webrtc.vp8.%u-layer%c", &numLayers, &dummy) == 1
1354 && numLayers > 0) {
1355 switch (numLayers) {
1356 case 1:
1357 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1358 {}, 0u, 1u, 0u);
1359 break;
1360 case 2:
1361 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1362 { .6f }, 0u, 2u, 0u);
1363 break;
1364 case 3:
1365 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1366 { .4f, .6f }, 0u, 3u, 0u);
1367 break;
1368 default:
1369 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1370 { .25f, .4f, .6f }, 0u, 4u, 0u);
1371 break;
1372 }
1373 } else if ((tags = sscanf(schema.c_str(), "android.generic.%u%c%u%c",
1374 &numLayers, &dummy, &numBLayers, &dummy))
1375 && (tags == 1 || (tags == 3 && dummy == '+'))
1376 && numLayers > 0 && numLayers < UINT32_MAX - numBLayers) {
1377 layering = C2StreamTemporalLayeringTuning::output::AllocUnique(
1378 {}, 0u, numLayers + numBLayers, numBLayers);
1379 } else {
1380 ALOGD("Ignoring unsupported ts-schema [%s]", schema.c_str());
1381 }
1382 if (layering) {
1383 params->setBuffer(C2_PARAMKEY_TEMPORAL_LAYERING,
1384 ABuffer::CreateAsCopy(layering.get(), layering->size()));
1385 }
1386 }
1387 }
1388
1389 { // convert from MediaFormat rect to Codec 2.0 rect
1390 int32_t offset;
1391 int32_t end;
1392 AMessage::ItemData item;
1393 if (params->findInt32("crop-left", &offset) && params->findInt32("crop-right", &end)
1394 && offset >= 0 && end >= offset - 1) {
1395 size_t ix = params->findEntryByName("crop-right");
1396 params->setEntryNameAt(ix, "crop-width");
1397 item.set(end - offset + 1);
1398 params->setEntryAt(ix, item);
1399 }
1400 if (params->findInt32("crop-top", &offset) && params->findInt32("crop-bottom", &end)
1401 && offset >= 0 && end >= offset - 1) {
1402 size_t ix = params->findEntryByName("crop-bottom");
1403 params->setEntryNameAt(ix, "crop-height");
1404 item.set(end - offset + 1);
1405 params->setEntryAt(ix, item);
1406 }
1407 }
1408
1409 { // convert color info
1410 int32_t standard;
1411 if (params->findInt32(KEY_COLOR_STANDARD, &standard)) {
1412 C2Color::primaries_t primaries;
1413 C2Color::matrix_t matrix;
1414
1415 if (C2Mapper::map(standard, &primaries, &matrix)) {
1416 params->setInt32("color-primaries", primaries);
1417 params->setInt32("color-matrix", matrix);
1418 }
1419 }
1420
1421 sp<ABuffer> hdrMeta;
1422 if (params->findBuffer(KEY_HDR_STATIC_INFO, &hdrMeta)
1423 && hdrMeta->size() == sizeof(HDRStaticInfo)) {
1424 HDRStaticInfo *meta = (HDRStaticInfo*)hdrMeta->data();
1425 if (meta->mID == meta->kType1) {
1426 params->setFloat("smpte2086.red.x", meta->sType1.mR.x * 0.00002);
1427 params->setFloat("smpte2086.red.y", meta->sType1.mR.y * 0.00002);
1428 params->setFloat("smpte2086.green.x", meta->sType1.mG.x * 0.00002);
1429 params->setFloat("smpte2086.green.y", meta->sType1.mG.y * 0.00002);
1430 params->setFloat("smpte2086.blue.x", meta->sType1.mB.x * 0.00002);
1431 params->setFloat("smpte2086.blue.y", meta->sType1.mB.y * 0.00002);
1432 params->setFloat("smpte2086.white.x", meta->sType1.mW.x * 0.00002);
1433 params->setFloat("smpte2086.white.y", meta->sType1.mW.y * 0.00002);
1434 params->setFloat("smpte2086.max-luminance", meta->sType1.mMaxDisplayLuminance);
1435 params->setFloat("smpte2086.min-luminance", meta->sType1.mMinDisplayLuminance * 0.0001);
1436 params->setFloat("cta861.max-cll", meta->sType1.mMaxContentLightLevel);
1437 params->setFloat("cta861.max-fall", meta->sType1.mMaxFrameAverageLightLevel);
1438 }
1439 }
1440 }
1441
1442 // this is to verify that we set proper signedness for standard parameters
1443 bool beVeryStrict = property_get_bool("debug.stagefright.ccodec_strict_type", false);
1444 // this is to allow vendors to use the wrong signedness for standard parameters
1445 bool beVeryLax = property_get_bool("debug.stagefright.ccodec_lax_type", false);
1446
1447 ReflectedParamUpdater::Dict filtered;
1448 for (size_t ix = 0; ix < params->countEntries(); ++ix) {
1449 AMessage::Type type;
1450 AString name = params->getEntryNameAt(ix, &type);
1451 AMessage::ItemData msgItem = params->getEntryAt(ix);
1452 ReflectedParamUpdater::Value item;
1453 convert(msgItem, &item); // convert item to param updater item
1454
1455 if (name.startsWith("vendor.")) {
1456 // vendor params pass through as is
1457 filtered.emplace(name.c_str(), item);
1458 continue;
1459 }
1460 // standard parameters may get modified, filtered or duplicated
1461 for (const ConfigMapper &cm : mStandardParams->getConfigMappersForSdkKey(name.c_str())) {
1462 // note: we ignore port domain for configuration
1463 if ((cm.domain() & configDomain)
1464 // component domain + kind (these must match)
1465 && (cm.domain() & mDomain) == mDomain) {
1466 // map arithmetic values, pass through string or buffer
1467 switch (type) {
1468 case AMessage::kTypeBuffer:
1469 case AMessage::kTypeString:
1470 break;
1471 case AMessage::kTypeInt32:
1472 case AMessage::kTypeInt64:
1473 case AMessage::kTypeFloat:
1474 case AMessage::kTypeDouble:
1475 // for now only map settings with mappers as we are not creating
1476 // signed <=> unsigned mappers
1477 // TODO: be precise about signed unsigned
1478 if (beVeryStrict || cm.mapper()) {
1479 item.set(cm.mapFromMessage(params->getEntryAt(ix)));
1480 // also allow to relax type strictness
1481 if (beVeryLax) {
1482 relaxValues(item);
1483 }
1484 }
1485 break;
1486 default:
1487 continue;
1488 }
1489 filtered.emplace(cm.path(), item);
1490 }
1491 }
1492 }
1493 ALOGV("filtered %s to %s", params->debugString(4).c_str(),
1494 filtered.debugString(4).c_str());
1495 return filtered;
1496}
1497
1498status_t CCodecConfig::getConfigUpdateFromSdkParams(
1499 std::shared_ptr<Codec2Client::Component> component,
1500 const sp<AMessage> &sdkParams, Domain configDomain,
1501 c2_blocking_t blocking,
1502 std::vector<std::unique_ptr<C2Param>> *configUpdate) const {
1503 ReflectedParamUpdater::Dict params = getReflectedFormat(sdkParams, configDomain);
1504
1505 std::vector<C2Param::Index> indices;
1506 mParamUpdater->getParamIndicesFromMessage(params, &indices);
1507 if (indices.empty()) {
1508 ALOGD("no recognized params in: %s", params.debugString().c_str());
1509 return OK;
1510 }
1511
1512 configUpdate->clear();
1513 std::vector<C2Param::Index> supportedIndices;
1514 for (C2Param::Index ix : indices) {
1515 if (mSupportedIndices.count(ix)) {
1516 supportedIndices.push_back(ix);
1517 } else if (mLocalParams.count(ix)) {
1518 // query local parameter here
1519 auto it = mCurrentConfig.find(ix);
1520 if (it != mCurrentConfig.end()) {
1521 configUpdate->emplace_back(C2Param::Copy(*it->second));
1522 }
1523 }
1524 }
1525
1526 c2_status_t err = component->query({ }, supportedIndices, blocking, configUpdate);
1527 if (err != C2_OK) {
1528 ALOGD("query failed after returning %zu params => %s", configUpdate->size(), asString(err));
1529 }
1530
1531 if (configUpdate->size()) {
1532 mParamUpdater->updateParamsFromMessage(params, configUpdate);
1533 }
1534 return OK;
1535}
1536
1537status_t CCodecConfig::setParameters(
1538 std::shared_ptr<Codec2Client::Component> component,
1539 std::vector<std::unique_ptr<C2Param>> &configUpdate,
1540 c2_blocking_t blocking) {
1541 status_t result = OK;
1542 if (configUpdate.empty()) {
1543 return OK;
1544 }
1545
1546 std::vector<C2Param::Index> indices;
1547 std::vector<C2Param *> paramVector;
1548 for (const std::unique_ptr<C2Param> &param : configUpdate) {
1549 if (mSupportedIndices.count(param->index())) {
1550 // component parameter
1551 paramVector.push_back(param.get());
1552 indices.push_back(param->index());
1553 } else if (mLocalParams.count(param->index())) {
1554 // handle local parameter here
1555 LocalParamValidator validator = mLocalParams.find(param->index())->second;
1556 c2_status_t err = C2_OK;
1557 std::unique_ptr<C2Param> copy = C2Param::Copy(*param);
1558 if (validator) {
1559 err = validator(copy);
1560 }
1561 if (err == C2_OK) {
1562 ALOGV("updated local parameter value for %s",
1563 mParamUpdater->getParamName(param->index()).c_str());
1564
1565 mCurrentConfig[param->index()] = std::move(copy);
1566 } else {
1567 ALOGD("failed to set parameter value for %s => %s",
1568 mParamUpdater->getParamName(param->index()).c_str(), asString(err));
1569 result = BAD_VALUE;
1570 }
1571 }
1572 }
1573 // update subscribed param indices
1574 subscribeToConfigUpdate(component, indices, blocking);
1575
1576 std::vector<std::unique_ptr<C2SettingResult>> failures;
1577 c2_status_t err = component->config(paramVector, blocking, &failures);
1578 if (err != C2_OK) {
1579 ALOGD("config failed => %s", asString(err));
1580 // This is non-fatal.
1581 }
1582 for (const std::unique_ptr<C2SettingResult> &failure : failures) {
1583 switch (failure->failure) {
1584 case C2SettingResult::BAD_VALUE:
1585 ALOGD("Bad parameter value");
1586 result = BAD_VALUE;
1587 break;
1588 default:
1589 ALOGV("failure = %d", int(failure->failure));
1590 break;
1591 }
1592 }
1593
1594 // Re-query parameter values in case config could not update them and update the current
1595 // configuration.
1596 configUpdate.clear();
1597 err = component->query({}, indices, blocking, &configUpdate);
1598 if (err != C2_OK) {
1599 ALOGD("query failed after returning %zu params => %s", configUpdate.size(), asString(err));
1600 }
1601 (void)updateConfiguration(configUpdate, ALL);
1602
1603 // TODO: error value
1604 return result;
1605}
1606
1607const C2Param *CCodecConfig::getConfigParameterValue(C2Param::Index index) const {
1608 auto it = mCurrentConfig.find(index);
1609 if (it == mCurrentConfig.end()) {
1610 return nullptr;
1611 } else {
1612 return it->second.get();
1613 }
1614}
1615
1616} // namespace android