1 /*
2 * Copyright 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 "C2SoftAvcEnc"
19 #include <log/log.h>
20 #include <utils/misc.h>
21
22 #include <algorithm>
23
24 #include <media/hardware/VideoAPI.h>
25 #include <media/stagefright/MediaDefs.h>
26 #include <media/stagefright/MediaErrors.h>
27 #include <media/stagefright/MetaData.h>
28 #include <media/stagefright/foundation/AUtils.h>
29
30 #include <C2Debug.h>
31 #include <Codec2Mapper.h>
32 #include <C2PlatformSupport.h>
33 #include <Codec2BufferUtils.h>
34 #include <SimpleC2Interface.h>
35 #include <util/C2InterfaceHelper.h>
36
37 #include "C2SoftAvcEnc.h"
38 #include "ih264e.h"
39 #include "ih264e_error.h"
40
41 namespace android {
42
43 namespace {
44
45 constexpr char COMPONENT_NAME[] = "c2.android.avc.encoder";
46 constexpr uint32_t kMinOutBufferSize = 524288;
ParseGop(const C2StreamGopTuning::output & gop,uint32_t * syncInterval,uint32_t * iInterval,uint32_t * maxBframes)47 void ParseGop(
48 const C2StreamGopTuning::output &gop,
49 uint32_t *syncInterval, uint32_t *iInterval, uint32_t *maxBframes) {
50 uint32_t syncInt = 1;
51 uint32_t iInt = 1;
52 for (size_t i = 0; i < gop.flexCount(); ++i) {
53 const C2GopLayerStruct &layer = gop.m.values[i];
54 if (layer.count == UINT32_MAX) {
55 syncInt = 0;
56 } else if (syncInt <= UINT32_MAX / (layer.count + 1)) {
57 syncInt *= (layer.count + 1);
58 }
59 if ((layer.type_ & I_FRAME) == 0) {
60 if (layer.count == UINT32_MAX) {
61 iInt = 0;
62 } else if (iInt <= UINT32_MAX / (layer.count + 1)) {
63 iInt *= (layer.count + 1);
64 }
65 }
66 if (layer.type_ == C2Config::picture_type_t(P_FRAME | B_FRAME) && maxBframes) {
67 *maxBframes = layer.count;
68 }
69 }
70 if (syncInterval) {
71 *syncInterval = syncInt;
72 }
73 if (iInterval) {
74 *iInterval = iInt;
75 }
76 }
77
78 } // namespace
79
80 class C2SoftAvcEnc::IntfImpl : public SimpleInterface<void>::BaseParams {
81 public:
IntfImpl(const std::shared_ptr<C2ReflectorHelper> & helper)82 explicit IntfImpl(const std::shared_ptr<C2ReflectorHelper> &helper)
83 : SimpleInterface<void>::BaseParams(
84 helper,
85 COMPONENT_NAME,
86 C2Component::KIND_ENCODER,
87 C2Component::DOMAIN_VIDEO,
88 MEDIA_MIMETYPE_VIDEO_AVC) {
89 noPrivateBuffers(); // TODO: account for our buffers here
90 noInputReferences();
91 noOutputReferences();
92 noTimeStretch();
93 setDerivedInstance(this);
94
95 addParameter(
96 DefineParam(mUsage, C2_PARAMKEY_INPUT_STREAM_USAGE)
97 .withConstValue(new C2StreamUsageTuning::input(
98 0u, (uint64_t)C2MemoryUsage::CPU_READ))
99 .build());
100
101 addParameter(
102 DefineParam(mAttrib, C2_PARAMKEY_COMPONENT_ATTRIBUTES)
103 .withConstValue(new C2ComponentAttributesSetting(
104 C2Component::ATTRIB_IS_TEMPORAL))
105 .build());
106
107 addParameter(
108 DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE)
109 .withDefault(new C2StreamPictureSizeInfo::input(0u, 16, 16))
110 .withFields({
111 C2F(mSize, width).inRange(2, 2560, 2),
112 C2F(mSize, height).inRange(2, 2560, 2),
113 })
114 .withSetter(SizeSetter)
115 .build());
116
117 addParameter(
118 DefineParam(mGop, C2_PARAMKEY_GOP)
119 .withDefault(C2StreamGopTuning::output::AllocShared(
120 0 /* flexCount */, 0u /* stream */))
121 .withFields({C2F(mGop, m.values[0].type_).any(),
122 C2F(mGop, m.values[0].count).any()})
123 .withSetter(GopSetter)
124 .build());
125
126 addParameter(
127 DefineParam(mPictureQuantization, C2_PARAMKEY_PICTURE_QUANTIZATION)
128 .withDefault(C2StreamPictureQuantizationTuning::output::AllocShared(
129 0 /* flexCount */, 0u /* stream */))
130 .withFields({C2F(mPictureQuantization, m.values[0].type_).oneOf(
131 {C2Config::picture_type_t(I_FRAME),
132 C2Config::picture_type_t(P_FRAME),
133 C2Config::picture_type_t(B_FRAME)}),
134 C2F(mPictureQuantization, m.values[0].min).any(),
135 C2F(mPictureQuantization, m.values[0].max).any()})
136 .withSetter(PictureQuantizationSetter)
137 .build());
138
139 addParameter(
140 DefineParam(mActualInputDelay, C2_PARAMKEY_INPUT_DELAY)
141 .withDefault(new C2PortActualDelayTuning::input(DEFAULT_B_FRAMES))
142 .withFields({C2F(mActualInputDelay, value).inRange(0, MAX_B_FRAMES)})
143 .calculatedAs(InputDelaySetter, mGop)
144 .build());
145
146 addParameter(
147 DefineParam(mFrameRate, C2_PARAMKEY_FRAME_RATE)
148 .withDefault(new C2StreamFrameRateInfo::output(0u, 1.))
149 // TODO: More restriction?
150 .withFields({C2F(mFrameRate, value).greaterThan(0.)})
151 .withSetter(Setter<decltype(*mFrameRate)>::StrictValueWithNoDeps)
152 .build());
153
154 addParameter(
155 DefineParam(mBitrateMode, C2_PARAMKEY_BITRATE_MODE)
156 .withDefault(new C2StreamBitrateModeTuning::output(0u, C2Config::BITRATE_VARIABLE))
157 .withFields({C2F(mBitrateMode, value).oneOf({
158 C2Config::BITRATE_CONST,
159 C2Config::BITRATE_VARIABLE,
160 C2Config::BITRATE_IGNORE})
161 })
162 .withSetter(Setter<decltype(*mBitrateMode)>::StrictValueWithNoDeps)
163 .build());
164
165 addParameter(
166 DefineParam(mBitrate, C2_PARAMKEY_BITRATE)
167 .withDefault(new C2StreamBitrateInfo::output(0u, 64000))
168 .withFields({C2F(mBitrate, value).inRange(4096, 12000000)})
169 .withSetter(BitrateSetter)
170 .build());
171
172 addParameter(
173 DefineParam(mIntraRefresh, C2_PARAMKEY_INTRA_REFRESH)
174 .withDefault(new C2StreamIntraRefreshTuning::output(
175 0u, C2Config::INTRA_REFRESH_DISABLED, 0.))
176 .withFields({
177 C2F(mIntraRefresh, mode).oneOf({
178 C2Config::INTRA_REFRESH_DISABLED, C2Config::INTRA_REFRESH_ARBITRARY }),
179 C2F(mIntraRefresh, period).any()
180 })
181 .withSetter(IntraRefreshSetter)
182 .build());
183
184 addParameter(
185 DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
186 .withDefault(new C2StreamProfileLevelInfo::output(
187 0u, PROFILE_AVC_CONSTRAINED_BASELINE, LEVEL_AVC_4_1))
188 .withFields({
189 C2F(mProfileLevel, profile).oneOf({
190 PROFILE_AVC_BASELINE,
191 PROFILE_AVC_CONSTRAINED_BASELINE,
192 PROFILE_AVC_MAIN,
193 }),
194 C2F(mProfileLevel, level).oneOf({
195 LEVEL_AVC_1,
196 LEVEL_AVC_1B,
197 LEVEL_AVC_1_1,
198 LEVEL_AVC_1_2,
199 LEVEL_AVC_1_3,
200 LEVEL_AVC_2,
201 LEVEL_AVC_2_1,
202 LEVEL_AVC_2_2,
203 LEVEL_AVC_3,
204 LEVEL_AVC_3_1,
205 LEVEL_AVC_3_2,
206 LEVEL_AVC_4,
207 LEVEL_AVC_4_1,
208 LEVEL_AVC_4_2,
209 LEVEL_AVC_5,
210 }),
211 })
212 .withSetter(ProfileLevelSetter, mSize, mFrameRate, mBitrate)
213 .build());
214
215 addParameter(
216 DefineParam(mRequestSync, C2_PARAMKEY_REQUEST_SYNC_FRAME)
217 .withDefault(new C2StreamRequestSyncFrameTuning::output(0u, C2_FALSE))
218 .withFields({C2F(mRequestSync, value).oneOf({ C2_FALSE, C2_TRUE }) })
219 .withSetter(Setter<decltype(*mRequestSync)>::NonStrictValueWithNoDeps)
220 .build());
221
222 addParameter(
223 DefineParam(mSyncFramePeriod, C2_PARAMKEY_SYNC_FRAME_INTERVAL)
224 .withDefault(new C2StreamSyncFrameIntervalTuning::output(0u, 1000000))
225 .withFields({C2F(mSyncFramePeriod, value).any()})
226 .withSetter(Setter<decltype(*mSyncFramePeriod)>::StrictValueWithNoDeps)
227 .build());
228
229 addParameter(
230 DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
231 .withDefault(new C2StreamColorAspectsInfo::input(
232 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
233 C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
234 .withFields({
235 C2F(mColorAspects, range).inRange(
236 C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
237 C2F(mColorAspects, primaries).inRange(
238 C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
239 C2F(mColorAspects, transfer).inRange(
240 C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
241 C2F(mColorAspects, matrix).inRange(
242 C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
243 })
244 .withSetter(ColorAspectsSetter)
245 .build());
246
247 addParameter(
248 DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
249 .withDefault(new C2StreamColorAspectsInfo::output(
250 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
251 C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
252 .withFields({
253 C2F(mCodedColorAspects, range).inRange(
254 C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
255 C2F(mCodedColorAspects, primaries).inRange(
256 C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
257 C2F(mCodedColorAspects, transfer).inRange(
258 C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
259 C2F(mCodedColorAspects, matrix).inRange(
260 C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
261 })
262 .withSetter(CodedColorAspectsSetter, mColorAspects)
263 .build());
264 }
265
InputDelaySetter(bool mayBlock,C2P<C2PortActualDelayTuning::input> & me,const C2P<C2StreamGopTuning::output> & gop)266 static C2R InputDelaySetter(
267 bool mayBlock,
268 C2P<C2PortActualDelayTuning::input> &me,
269 const C2P<C2StreamGopTuning::output> &gop) {
270 (void)mayBlock;
271 uint32_t maxBframes = 0;
272 ParseGop(gop.v, nullptr, nullptr, &maxBframes);
273 me.set().value = maxBframes;
274 return C2R::Ok();
275 }
276
BitrateSetter(bool mayBlock,C2P<C2StreamBitrateInfo::output> & me)277 static C2R BitrateSetter(bool mayBlock, C2P<C2StreamBitrateInfo::output> &me) {
278 (void)mayBlock;
279 C2R res = C2R::Ok();
280 if (me.v.value <= 4096) {
281 me.set().value = 4096;
282 }
283 return res;
284 }
285
286
SizeSetter(bool mayBlock,const C2P<C2StreamPictureSizeInfo::input> & oldMe,C2P<C2StreamPictureSizeInfo::input> & me)287 static C2R SizeSetter(bool mayBlock, const C2P<C2StreamPictureSizeInfo::input> &oldMe,
288 C2P<C2StreamPictureSizeInfo::input> &me) {
289 (void)mayBlock;
290 C2R res = C2R::Ok();
291 if (!me.F(me.v.width).supportsAtAll(me.v.width)) {
292 res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.width)));
293 me.set().width = oldMe.v.width;
294 }
295 if (!me.F(me.v.height).supportsAtAll(me.v.height)) {
296 res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.height)));
297 me.set().height = oldMe.v.height;
298 }
299 return res;
300 }
301
ProfileLevelSetter(bool mayBlock,C2P<C2StreamProfileLevelInfo::output> & me,const C2P<C2StreamPictureSizeInfo::input> & size,const C2P<C2StreamFrameRateInfo::output> & frameRate,const C2P<C2StreamBitrateInfo::output> & bitrate)302 static C2R ProfileLevelSetter(
303 bool mayBlock,
304 C2P<C2StreamProfileLevelInfo::output> &me,
305 const C2P<C2StreamPictureSizeInfo::input> &size,
306 const C2P<C2StreamFrameRateInfo::output> &frameRate,
307 const C2P<C2StreamBitrateInfo::output> &bitrate) {
308 (void)mayBlock;
309 if (!me.F(me.v.profile).supportsAtAll(me.v.profile)) {
310 me.set().profile = PROFILE_AVC_CONSTRAINED_BASELINE;
311 }
312
313 struct LevelLimits {
314 C2Config::level_t level;
315 float mbsPerSec;
316 uint64_t mbs;
317 uint32_t bitrate;
318 };
319 constexpr LevelLimits kLimits[] = {
320 { LEVEL_AVC_1, 1485, 99, 64000 },
321 // Decoder does not properly handle level 1b.
322 // { LEVEL_AVC_1B, 1485, 99, 128000 },
323 { LEVEL_AVC_1_1, 3000, 396, 192000 },
324 { LEVEL_AVC_1_2, 6000, 396, 384000 },
325 { LEVEL_AVC_1_3, 11880, 396, 768000 },
326 { LEVEL_AVC_2, 11880, 396, 2000000 },
327 { LEVEL_AVC_2_1, 19800, 792, 4000000 },
328 { LEVEL_AVC_2_2, 20250, 1620, 4000000 },
329 { LEVEL_AVC_3, 40500, 1620, 10000000 },
330 { LEVEL_AVC_3_1, 108000, 3600, 14000000 },
331 { LEVEL_AVC_3_2, 216000, 5120, 20000000 },
332 { LEVEL_AVC_4, 245760, 8192, 20000000 },
333 { LEVEL_AVC_4_1, 245760, 8192, 50000000 },
334 { LEVEL_AVC_4_2, 522240, 8704, 50000000 },
335 { LEVEL_AVC_5, 589824, 22080, 135000000 },
336 };
337
338 uint64_t mbs = uint64_t((size.v.width + 15) / 16) * ((size.v.height + 15) / 16);
339 float mbsPerSec = float(mbs) * frameRate.v.value;
340
341 // Check if the supplied level meets the MB / bitrate requirements. If
342 // not, update the level with the lowest level meeting the requirements.
343
344 bool found = false;
345 // By default needsUpdate = false in case the supplied level does meet
346 // the requirements. For Level 1b, we want to update the level anyway,
347 // so we set it to true in that case.
348 bool needsUpdate = false;
349 if (me.v.level == LEVEL_AVC_1B || !me.F(me.v.level).supportsAtAll(me.v.level)) {
350 needsUpdate = true;
351 }
352 for (const LevelLimits &limit : kLimits) {
353 if (mbs <= limit.mbs && mbsPerSec <= limit.mbsPerSec &&
354 bitrate.v.value <= limit.bitrate) {
355 // This is the lowest level that meets the requirements, and if
356 // we haven't seen the supplied level yet, that means we don't
357 // need the update.
358 if (needsUpdate) {
359 ALOGD("Given level %x does not cover current configuration: "
360 "adjusting to %x", me.v.level, limit.level);
361 me.set().level = limit.level;
362 }
363 found = true;
364 break;
365 }
366 if (me.v.level == limit.level) {
367 // We break out of the loop when the lowest feasible level is
368 // found. The fact that we're here means that our level doesn't
369 // meet the requirement and needs to be updated.
370 needsUpdate = true;
371 }
372 }
373 if (!found || me.v.level > LEVEL_AVC_5) {
374 // We set to the highest supported level.
375 me.set().level = LEVEL_AVC_5;
376 }
377
378 return C2R::Ok();
379 }
380
IntraRefreshSetter(bool mayBlock,C2P<C2StreamIntraRefreshTuning::output> & me)381 static C2R IntraRefreshSetter(bool mayBlock, C2P<C2StreamIntraRefreshTuning::output> &me) {
382 (void)mayBlock;
383 C2R res = C2R::Ok();
384 if (me.v.period < 1) {
385 me.set().mode = C2Config::INTRA_REFRESH_DISABLED;
386 me.set().period = 0;
387 } else {
388 // only support arbitrary mode (cyclic in our case)
389 me.set().mode = C2Config::INTRA_REFRESH_ARBITRARY;
390 }
391 return res;
392 }
393
GopSetter(bool mayBlock,C2P<C2StreamGopTuning::output> & me)394 static C2R GopSetter(bool mayBlock, C2P<C2StreamGopTuning::output> &me) {
395 (void)mayBlock;
396 for (size_t i = 0; i < me.v.flexCount(); ++i) {
397 const C2GopLayerStruct &layer = me.v.m.values[0];
398 if (layer.type_ == C2Config::picture_type_t(P_FRAME | B_FRAME)
399 && layer.count > MAX_B_FRAMES) {
400 me.set().m.values[i].count = MAX_B_FRAMES;
401 }
402 }
403 return C2R::Ok();
404 }
405
PictureQuantizationSetter(bool mayBlock,C2P<C2StreamPictureQuantizationTuning::output> & me)406 static C2R PictureQuantizationSetter(bool mayBlock,
407 C2P<C2StreamPictureQuantizationTuning::output> &me) {
408 (void)mayBlock;
409
410 // these are the ones we're going to set, so want them to default
411 // to the DEFAULT values for the codec
412 int32_t iMin = DEFAULT_I_QP_MIN, pMin = DEFAULT_P_QP_MIN, bMin = DEFAULT_B_QP_MIN;
413 int32_t iMax = DEFAULT_I_QP_MAX, pMax = DEFAULT_P_QP_MAX, bMax = DEFAULT_B_QP_MAX;
414
415 for (size_t i = 0; i < me.v.flexCount(); ++i) {
416 const C2PictureQuantizationStruct &layer = me.v.m.values[i];
417
418 if (layer.type_ == C2Config::picture_type_t(I_FRAME)) {
419 iMax = layer.max;
420 iMin = layer.min;
421 ALOGV("iMin %d iMax %d", iMin, iMax);
422 } else if (layer.type_ == C2Config::picture_type_t(P_FRAME)) {
423 pMax = layer.max;
424 pMin = layer.min;
425 ALOGV("pMin %d pMax %d", pMin, pMax);
426 } else if (layer.type_ == C2Config::picture_type_t(B_FRAME)) {
427 bMax = layer.max;
428 bMin = layer.min;
429 ALOGV("bMin %d bMax %d", bMin, bMax);
430 }
431 }
432
433 ALOGV("PictureQuantizationSetter(entry): i %d-%d p %d-%d b %d-%d",
434 iMin, iMax, pMin, pMax, bMin, bMax);
435
436 // min is clamped to [AVC_QP_MIN, max] to avoid error
437 // cases where layer.min > layer.max
438 iMax = std::clamp(iMax, AVC_QP_MIN, AVC_QP_MAX);
439 iMin = std::clamp(iMin, AVC_QP_MIN, iMax);
440 pMax = std::clamp(pMax, AVC_QP_MIN, AVC_QP_MAX);
441 pMin = std::clamp(pMin, AVC_QP_MIN, pMax);
442 bMax = std::clamp(bMax, AVC_QP_MIN, AVC_QP_MAX);
443 bMin = std::clamp(bMin, AVC_QP_MIN, bMax);
444
445 // put them back into the structure
446 for (size_t i = 0; i < me.v.flexCount(); ++i) {
447 const C2PictureQuantizationStruct &layer = me.v.m.values[i];
448
449 if (layer.type_ == C2Config::picture_type_t(I_FRAME)) {
450 me.set().m.values[i].max = iMax;
451 me.set().m.values[i].min = iMin;
452 }
453 if (layer.type_ == C2Config::picture_type_t(P_FRAME)) {
454 me.set().m.values[i].max = pMax;
455 me.set().m.values[i].min = pMin;
456 }
457 if (layer.type_ == C2Config::picture_type_t(B_FRAME)) {
458 me.set().m.values[i].max = bMax;
459 me.set().m.values[i].min = bMin;
460 }
461 }
462
463 ALOGV("PictureQuantizationSetter(exit): i %d-%d p %d-%d b %d-%d",
464 iMin, iMax, pMin, pMax, bMin, bMax);
465
466 return C2R::Ok();
467 }
468
ColorAspectsSetter(bool mayBlock,C2P<C2StreamColorAspectsInfo::input> & me)469 static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input> &me) {
470 (void)mayBlock;
471 if (me.v.range > C2Color::RANGE_OTHER) {
472 me.set().range = C2Color::RANGE_OTHER;
473 }
474 if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
475 me.set().primaries = C2Color::PRIMARIES_OTHER;
476 }
477 if (me.v.transfer > C2Color::TRANSFER_OTHER) {
478 me.set().transfer = C2Color::TRANSFER_OTHER;
479 }
480 if (me.v.matrix > C2Color::MATRIX_OTHER) {
481 me.set().matrix = C2Color::MATRIX_OTHER;
482 }
483 return C2R::Ok();
484 }
485
CodedColorAspectsSetter(bool mayBlock,C2P<C2StreamColorAspectsInfo::output> & me,const C2P<C2StreamColorAspectsInfo::input> & coded)486 static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output> &me,
487 const C2P<C2StreamColorAspectsInfo::input> &coded) {
488 (void)mayBlock;
489 me.set().range = coded.v.range;
490 me.set().primaries = coded.v.primaries;
491 me.set().transfer = coded.v.transfer;
492 me.set().matrix = coded.v.matrix;
493 return C2R::Ok();
494 }
495
getProfile_l() const496 IV_PROFILE_T getProfile_l() const {
497 switch (mProfileLevel->profile) {
498 case PROFILE_AVC_CONSTRAINED_BASELINE: [[fallthrough]];
499 case PROFILE_AVC_BASELINE: return IV_PROFILE_BASE;
500 case PROFILE_AVC_MAIN: return IV_PROFILE_MAIN;
501 default:
502 ALOGD("Unrecognized profile: %x", mProfileLevel->profile);
503 return IV_PROFILE_DEFAULT;
504 }
505 }
506
getLevel_l() const507 UWORD32 getLevel_l() const {
508 struct Level {
509 C2Config::level_t c2Level;
510 UWORD32 avcLevel;
511 };
512 constexpr Level levels[] = {
513 { LEVEL_AVC_1, 10 },
514 { LEVEL_AVC_1B, 9 },
515 { LEVEL_AVC_1_1, 11 },
516 { LEVEL_AVC_1_2, 12 },
517 { LEVEL_AVC_1_3, 13 },
518 { LEVEL_AVC_2, 20 },
519 { LEVEL_AVC_2_1, 21 },
520 { LEVEL_AVC_2_2, 22 },
521 { LEVEL_AVC_3, 30 },
522 { LEVEL_AVC_3_1, 31 },
523 { LEVEL_AVC_3_2, 32 },
524 { LEVEL_AVC_4, 40 },
525 { LEVEL_AVC_4_1, 41 },
526 { LEVEL_AVC_4_2, 42 },
527 { LEVEL_AVC_5, 50 },
528 };
529 for (const Level &level : levels) {
530 if (mProfileLevel->level == level.c2Level) {
531 return level.avcLevel;
532 }
533 }
534 ALOGD("Unrecognized level: %x", mProfileLevel->level);
535 return 41;
536 }
537
getSyncFramePeriod_l() const538 uint32_t getSyncFramePeriod_l() const {
539 if (mSyncFramePeriod->value < 0 || mSyncFramePeriod->value == INT64_MAX) {
540 return 0;
541 }
542 double period = mSyncFramePeriod->value / 1e6 * mFrameRate->value;
543 return (uint32_t)c2_max(c2_min(period + 0.5, double(UINT32_MAX)), 1.);
544 }
545
546 // unsafe getters
getSize_l() const547 std::shared_ptr<C2StreamPictureSizeInfo::input> getSize_l() const { return mSize; }
getIntraRefresh_l() const548 std::shared_ptr<C2StreamIntraRefreshTuning::output> getIntraRefresh_l() const { return mIntraRefresh; }
getFrameRate_l() const549 std::shared_ptr<C2StreamFrameRateInfo::output> getFrameRate_l() const { return mFrameRate; }
getBitrateMode_l() const550 std::shared_ptr<C2StreamBitrateModeTuning::output> getBitrateMode_l() const {
551 return mBitrateMode;
552 }
getBitrate_l() const553 std::shared_ptr<C2StreamBitrateInfo::output> getBitrate_l() const { return mBitrate; }
getRequestSync_l() const554 std::shared_ptr<C2StreamRequestSyncFrameTuning::output> getRequestSync_l() const { return mRequestSync; }
getGop_l() const555 std::shared_ptr<C2StreamGopTuning::output> getGop_l() const { return mGop; }
getPictureQuantization_l() const556 std::shared_ptr<C2StreamPictureQuantizationTuning::output> getPictureQuantization_l() const
557 { return mPictureQuantization; }
getCodedColorAspects_l() const558 std::shared_ptr<C2StreamColorAspectsInfo::output> getCodedColorAspects_l() const {
559 return mCodedColorAspects;
560 }
561
562 private:
563 std::shared_ptr<C2StreamUsageTuning::input> mUsage;
564 std::shared_ptr<C2StreamPictureSizeInfo::input> mSize;
565 std::shared_ptr<C2StreamFrameRateInfo::output> mFrameRate;
566 std::shared_ptr<C2StreamRequestSyncFrameTuning::output> mRequestSync;
567 std::shared_ptr<C2StreamIntraRefreshTuning::output> mIntraRefresh;
568 std::shared_ptr<C2StreamBitrateInfo::output> mBitrate;
569 std::shared_ptr<C2StreamBitrateModeTuning::output> mBitrateMode;
570 std::shared_ptr<C2StreamProfileLevelInfo::output> mProfileLevel;
571 std::shared_ptr<C2StreamSyncFrameIntervalTuning::output> mSyncFramePeriod;
572 std::shared_ptr<C2StreamGopTuning::output> mGop;
573 std::shared_ptr<C2StreamPictureQuantizationTuning::output> mPictureQuantization;
574 std::shared_ptr<C2StreamColorAspectsInfo::input> mColorAspects;
575 std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
576 };
577
578 #define ive_api_function ih264e_api_function
579
580 namespace {
581
582 // From external/libavc/encoder/ih264e_bitstream.h
583 constexpr uint32_t MIN_STREAM_SIZE = 0x800;
584
GetCPUCoreCount()585 static size_t GetCPUCoreCount() {
586 long cpuCoreCount = 1;
587 #if defined(_SC_NPROCESSORS_ONLN)
588 cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN);
589 #else
590 // _SC_NPROC_ONLN must be defined...
591 cpuCoreCount = sysconf(_SC_NPROC_ONLN);
592 #endif
593 CHECK(cpuCoreCount >= 1);
594 ALOGV("Number of CPU cores: %ld", cpuCoreCount);
595 return (size_t)cpuCoreCount;
596 }
597
598 } // namespace
599
C2SoftAvcEnc(const char * name,c2_node_id_t id,const std::shared_ptr<IntfImpl> & intfImpl)600 C2SoftAvcEnc::C2SoftAvcEnc(
601 const char *name, c2_node_id_t id, const std::shared_ptr<IntfImpl> &intfImpl)
602 : SimpleC2Component(std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)),
603 mIntf(intfImpl),
604 mIvVideoColorFormat(IV_YUV_420P),
605 mAVCEncProfile(IV_PROFILE_BASE),
606 mAVCEncLevel(41),
607 mStarted(false),
608 mSawInputEOS(false),
609 mSignalledError(false),
610 mCodecCtx(nullptr),
611 mOutBlock(nullptr),
612 mOutBufferSize(kMinOutBufferSize) {
613
614 // If dump is enabled, then open create an empty file
615 GENERATE_FILE_NAMES();
616 CREATE_DUMP_FILE(mInFile);
617 CREATE_DUMP_FILE(mOutFile);
618
619 initEncParams();
620 }
621
~C2SoftAvcEnc()622 C2SoftAvcEnc::~C2SoftAvcEnc() {
623 onRelease();
624 }
625
onInit()626 c2_status_t C2SoftAvcEnc::onInit() {
627 return C2_OK;
628 }
629
onStop()630 c2_status_t C2SoftAvcEnc::onStop() {
631 return C2_OK;
632 }
633
onReset()634 void C2SoftAvcEnc::onReset() {
635 // TODO: use IVE_CMD_CTL_RESET?
636 releaseEncoder();
637 if (mOutBlock) {
638 mOutBlock.reset();
639 }
640 initEncParams();
641 }
642
onRelease()643 void C2SoftAvcEnc::onRelease() {
644 releaseEncoder();
645 if (mOutBlock) {
646 mOutBlock.reset();
647 }
648 }
649
onFlush_sm()650 c2_status_t C2SoftAvcEnc::onFlush_sm() {
651 // TODO: use IVE_CMD_CTL_FLUSH?
652 return C2_OK;
653 }
654
initEncParams()655 void C2SoftAvcEnc::initEncParams() {
656 mCodecCtx = nullptr;
657 mMemRecords = nullptr;
658 mNumMemRecords = DEFAULT_MEM_REC_CNT;
659 mHeaderGenerated = 0;
660 mNumCores = GetCPUCoreCount();
661 mArch = DEFAULT_ARCH;
662 mSliceMode = DEFAULT_SLICE_MODE;
663 mSliceParam = DEFAULT_SLICE_PARAM;
664 mHalfPelEnable = DEFAULT_HPEL;
665 mIInterval = DEFAULT_I_INTERVAL;
666 mIDRInterval = DEFAULT_IDR_INTERVAL;
667 mDisableDeblkLevel = DEFAULT_DISABLE_DEBLK_LEVEL;
668 mEnableFastSad = DEFAULT_ENABLE_FAST_SAD;
669 mEnableAltRef = DEFAULT_ENABLE_ALT_REF;
670 mEncSpeed = DEFAULT_ENC_SPEED;
671 mIntra4x4 = DEFAULT_INTRA4x4;
672 mConstrainedIntraFlag = DEFAULT_CONSTRAINED_INTRA;
673 mPSNREnable = DEFAULT_PSNR_ENABLE;
674 mReconEnable = DEFAULT_RECON_ENABLE;
675 mEntropyMode = DEFAULT_ENTROPY_MODE;
676 mBframes = DEFAULT_B_FRAMES;
677
678 mTimeStart = mTimeEnd = systemTime();
679 }
680
setDimensions()681 c2_status_t C2SoftAvcEnc::setDimensions() {
682 ive_ctl_set_dimensions_ip_t s_dimensions_ip;
683 ive_ctl_set_dimensions_op_t s_dimensions_op;
684 IV_STATUS_T status;
685
686 s_dimensions_ip.e_cmd = IVE_CMD_VIDEO_CTL;
687 s_dimensions_ip.e_sub_cmd = IVE_CMD_CTL_SET_DIMENSIONS;
688 s_dimensions_ip.u4_ht = mSize->height;
689 s_dimensions_ip.u4_wd = mSize->width;
690
691 s_dimensions_ip.u4_timestamp_high = -1;
692 s_dimensions_ip.u4_timestamp_low = -1;
693
694 s_dimensions_ip.u4_size = sizeof(ive_ctl_set_dimensions_ip_t);
695 s_dimensions_op.u4_size = sizeof(ive_ctl_set_dimensions_op_t);
696
697 status = ive_api_function(mCodecCtx, &s_dimensions_ip, &s_dimensions_op);
698 if (status != IV_SUCCESS) {
699 ALOGE("Unable to set frame dimensions = 0x%x\n",
700 s_dimensions_op.u4_error_code);
701 return C2_CORRUPTED;
702 }
703 return C2_OK;
704 }
705
setNumCores()706 c2_status_t C2SoftAvcEnc::setNumCores() {
707 IV_STATUS_T status;
708 ive_ctl_set_num_cores_ip_t s_num_cores_ip;
709 ive_ctl_set_num_cores_op_t s_num_cores_op;
710 s_num_cores_ip.e_cmd = IVE_CMD_VIDEO_CTL;
711 s_num_cores_ip.e_sub_cmd = IVE_CMD_CTL_SET_NUM_CORES;
712 s_num_cores_ip.u4_num_cores = MIN(mNumCores, CODEC_MAX_CORES);
713 s_num_cores_ip.u4_timestamp_high = -1;
714 s_num_cores_ip.u4_timestamp_low = -1;
715 s_num_cores_ip.u4_size = sizeof(ive_ctl_set_num_cores_ip_t);
716
717 s_num_cores_op.u4_size = sizeof(ive_ctl_set_num_cores_op_t);
718
719 status = ive_api_function(
720 mCodecCtx, (void *) &s_num_cores_ip, (void *) &s_num_cores_op);
721 if (status != IV_SUCCESS) {
722 ALOGE("Unable to set processor params = 0x%x\n",
723 s_num_cores_op.u4_error_code);
724 return C2_CORRUPTED;
725 }
726 return C2_OK;
727 }
728
setFrameRate()729 c2_status_t C2SoftAvcEnc::setFrameRate() {
730 ive_ctl_set_frame_rate_ip_t s_frame_rate_ip;
731 ive_ctl_set_frame_rate_op_t s_frame_rate_op;
732 IV_STATUS_T status;
733
734 s_frame_rate_ip.e_cmd = IVE_CMD_VIDEO_CTL;
735 s_frame_rate_ip.e_sub_cmd = IVE_CMD_CTL_SET_FRAMERATE;
736
737 s_frame_rate_ip.u4_src_frame_rate = mFrameRate->value + 0.5;
738 s_frame_rate_ip.u4_tgt_frame_rate = mFrameRate->value + 0.5;
739
740 s_frame_rate_ip.u4_timestamp_high = -1;
741 s_frame_rate_ip.u4_timestamp_low = -1;
742
743 s_frame_rate_ip.u4_size = sizeof(ive_ctl_set_frame_rate_ip_t);
744 s_frame_rate_op.u4_size = sizeof(ive_ctl_set_frame_rate_op_t);
745
746 status = ive_api_function(mCodecCtx, &s_frame_rate_ip, &s_frame_rate_op);
747 if (status != IV_SUCCESS) {
748 ALOGE("Unable to set frame rate = 0x%x\n",
749 s_frame_rate_op.u4_error_code);
750 return C2_CORRUPTED;
751 }
752 return C2_OK;
753 }
754
setIpeParams()755 c2_status_t C2SoftAvcEnc::setIpeParams() {
756 ive_ctl_set_ipe_params_ip_t s_ipe_params_ip;
757 ive_ctl_set_ipe_params_op_t s_ipe_params_op;
758 IV_STATUS_T status;
759
760 s_ipe_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
761 s_ipe_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_IPE_PARAMS;
762
763 s_ipe_params_ip.u4_enable_intra_4x4 = mIntra4x4;
764 s_ipe_params_ip.u4_enc_speed_preset = mEncSpeed;
765 s_ipe_params_ip.u4_constrained_intra_pred = mConstrainedIntraFlag;
766
767 s_ipe_params_ip.u4_timestamp_high = -1;
768 s_ipe_params_ip.u4_timestamp_low = -1;
769
770 s_ipe_params_ip.u4_size = sizeof(ive_ctl_set_ipe_params_ip_t);
771 s_ipe_params_op.u4_size = sizeof(ive_ctl_set_ipe_params_op_t);
772
773 status = ive_api_function(mCodecCtx, &s_ipe_params_ip, &s_ipe_params_op);
774 if (status != IV_SUCCESS) {
775 ALOGE("Unable to set ipe params = 0x%x\n",
776 s_ipe_params_op.u4_error_code);
777 return C2_CORRUPTED;
778 }
779 return C2_OK;
780 }
781
setBitRate()782 c2_status_t C2SoftAvcEnc::setBitRate() {
783 ive_ctl_set_bitrate_ip_t s_bitrate_ip;
784 ive_ctl_set_bitrate_op_t s_bitrate_op;
785 IV_STATUS_T status;
786
787 s_bitrate_ip.e_cmd = IVE_CMD_VIDEO_CTL;
788 s_bitrate_ip.e_sub_cmd = IVE_CMD_CTL_SET_BITRATE;
789
790 s_bitrate_ip.u4_target_bitrate = mBitrate->value;
791
792 s_bitrate_ip.u4_timestamp_high = -1;
793 s_bitrate_ip.u4_timestamp_low = -1;
794
795 s_bitrate_ip.u4_size = sizeof(ive_ctl_set_bitrate_ip_t);
796 s_bitrate_op.u4_size = sizeof(ive_ctl_set_bitrate_op_t);
797
798 status = ive_api_function(mCodecCtx, &s_bitrate_ip, &s_bitrate_op);
799 if (status != IV_SUCCESS) {
800 ALOGE("Unable to set bit rate = 0x%x\n", s_bitrate_op.u4_error_code);
801 return C2_CORRUPTED;
802 }
803 return C2_OK;
804 }
805
setFrameType(IV_PICTURE_CODING_TYPE_T e_frame_type)806 c2_status_t C2SoftAvcEnc::setFrameType(IV_PICTURE_CODING_TYPE_T e_frame_type) {
807 ive_ctl_set_frame_type_ip_t s_frame_type_ip;
808 ive_ctl_set_frame_type_op_t s_frame_type_op;
809 IV_STATUS_T status;
810 s_frame_type_ip.e_cmd = IVE_CMD_VIDEO_CTL;
811 s_frame_type_ip.e_sub_cmd = IVE_CMD_CTL_SET_FRAMETYPE;
812
813 s_frame_type_ip.e_frame_type = e_frame_type;
814
815 s_frame_type_ip.u4_timestamp_high = -1;
816 s_frame_type_ip.u4_timestamp_low = -1;
817
818 s_frame_type_ip.u4_size = sizeof(ive_ctl_set_frame_type_ip_t);
819 s_frame_type_op.u4_size = sizeof(ive_ctl_set_frame_type_op_t);
820
821 status = ive_api_function(mCodecCtx, &s_frame_type_ip, &s_frame_type_op);
822 if (status != IV_SUCCESS) {
823 ALOGE("Unable to set frame type = 0x%x\n",
824 s_frame_type_op.u4_error_code);
825 return C2_CORRUPTED;
826 }
827 return C2_OK;
828 }
829
setQp()830 c2_status_t C2SoftAvcEnc::setQp() {
831 ive_ctl_set_qp_ip_t s_qp_ip;
832 ive_ctl_set_qp_op_t s_qp_op;
833 IV_STATUS_T status;
834
835 ALOGV("in setQp()");
836
837 // set the defaults
838 s_qp_ip.e_cmd = IVE_CMD_VIDEO_CTL;
839 s_qp_ip.e_sub_cmd = IVE_CMD_CTL_SET_QP;
840
841 // we resolved out-of-bound and unspecified values in PictureQuantizationSetter()
842 // so we can start with defaults that are overridden as needed.
843 int32_t iMin = DEFAULT_I_QP_MIN, pMin = DEFAULT_P_QP_MIN, bMin = DEFAULT_B_QP_MIN;
844 int32_t iMax = DEFAULT_I_QP_MAX, pMax = DEFAULT_P_QP_MAX, bMax = DEFAULT_B_QP_MAX;
845
846 IntfImpl::Lock lock = mIntf->lock();
847
848 std::shared_ptr<C2StreamPictureQuantizationTuning::output> qp =
849 mIntf->getPictureQuantization_l();
850 for (size_t i = 0; i < qp->flexCount(); ++i) {
851 const C2PictureQuantizationStruct &layer = qp->m.values[i];
852
853 if (layer.type_ == C2Config::picture_type_t(I_FRAME)) {
854 iMax = layer.max;
855 iMin = layer.min;
856 ALOGV("iMin %d iMax %d", iMin, iMax);
857 } else if (layer.type_ == C2Config::picture_type_t(P_FRAME)) {
858 pMax = layer.max;
859 pMin = layer.min;
860 ALOGV("pMin %d pMax %d", pMin, pMax);
861 } else if (layer.type_ == C2Config::picture_type_t(B_FRAME)) {
862 bMax = layer.max;
863 bMin = layer.min;
864 ALOGV("bMin %d bMax %d", bMin, bMax);
865 }
866 }
867
868 s_qp_ip.u4_i_qp_max = iMax;
869 s_qp_ip.u4_i_qp_min = iMin;
870 s_qp_ip.u4_p_qp_max = pMax;
871 s_qp_ip.u4_p_qp_min = pMin;
872 s_qp_ip.u4_b_qp_max = bMax;
873 s_qp_ip.u4_b_qp_min = bMin;
874
875 // ensure initial qp values are within our newly configured bounds...
876 s_qp_ip.u4_i_qp = std::clamp(DEFAULT_I_QP, iMin, iMax);
877 s_qp_ip.u4_p_qp = std::clamp(DEFAULT_P_QP, pMin, pMax);
878 s_qp_ip.u4_b_qp = std::clamp(DEFAULT_B_QP, bMin, bMax);
879
880 ALOGV("setQp(): i %d-%d p %d-%d b %d-%d", iMin, iMax, pMin, pMax, bMin, bMax);
881
882
883 s_qp_ip.u4_timestamp_high = -1;
884 s_qp_ip.u4_timestamp_low = -1;
885
886 s_qp_ip.u4_size = sizeof(ive_ctl_set_qp_ip_t);
887 s_qp_op.u4_size = sizeof(ive_ctl_set_qp_op_t);
888
889 status = ive_api_function(mCodecCtx, &s_qp_ip, &s_qp_op);
890 if (status != IV_SUCCESS) {
891 ALOGE("Unable to set qp 0x%x\n", s_qp_op.u4_error_code);
892 return C2_CORRUPTED;
893 }
894 return C2_OK;
895 }
896
setEncMode(IVE_ENC_MODE_T e_enc_mode)897 c2_status_t C2SoftAvcEnc::setEncMode(IVE_ENC_MODE_T e_enc_mode) {
898 IV_STATUS_T status;
899 ive_ctl_set_enc_mode_ip_t s_enc_mode_ip;
900 ive_ctl_set_enc_mode_op_t s_enc_mode_op;
901
902 s_enc_mode_ip.e_cmd = IVE_CMD_VIDEO_CTL;
903 s_enc_mode_ip.e_sub_cmd = IVE_CMD_CTL_SET_ENC_MODE;
904
905 s_enc_mode_ip.e_enc_mode = e_enc_mode;
906
907 s_enc_mode_ip.u4_timestamp_high = -1;
908 s_enc_mode_ip.u4_timestamp_low = -1;
909
910 s_enc_mode_ip.u4_size = sizeof(ive_ctl_set_enc_mode_ip_t);
911 s_enc_mode_op.u4_size = sizeof(ive_ctl_set_enc_mode_op_t);
912
913 status = ive_api_function(mCodecCtx, &s_enc_mode_ip, &s_enc_mode_op);
914 if (status != IV_SUCCESS) {
915 ALOGE("Unable to set in header encode mode = 0x%x\n",
916 s_enc_mode_op.u4_error_code);
917 return C2_CORRUPTED;
918 }
919 return C2_OK;
920 }
921
setVbvParams()922 c2_status_t C2SoftAvcEnc::setVbvParams() {
923 ive_ctl_set_vbv_params_ip_t s_vbv_ip;
924 ive_ctl_set_vbv_params_op_t s_vbv_op;
925 IV_STATUS_T status;
926
927 s_vbv_ip.e_cmd = IVE_CMD_VIDEO_CTL;
928 s_vbv_ip.e_sub_cmd = IVE_CMD_CTL_SET_VBV_PARAMS;
929
930 s_vbv_ip.u4_vbv_buf_size = 0;
931 s_vbv_ip.u4_vbv_buffer_delay = 1000;
932
933 s_vbv_ip.u4_timestamp_high = -1;
934 s_vbv_ip.u4_timestamp_low = -1;
935
936 s_vbv_ip.u4_size = sizeof(ive_ctl_set_vbv_params_ip_t);
937 s_vbv_op.u4_size = sizeof(ive_ctl_set_vbv_params_op_t);
938
939 status = ive_api_function(mCodecCtx, &s_vbv_ip, &s_vbv_op);
940 if (status != IV_SUCCESS) {
941 ALOGE("Unable to set VBV params = 0x%x\n", s_vbv_op.u4_error_code);
942 return C2_CORRUPTED;
943 }
944 return C2_OK;
945 }
946
setAirParams()947 c2_status_t C2SoftAvcEnc::setAirParams() {
948 ive_ctl_set_air_params_ip_t s_air_ip;
949 ive_ctl_set_air_params_op_t s_air_op;
950 IV_STATUS_T status;
951
952 s_air_ip.e_cmd = IVE_CMD_VIDEO_CTL;
953 s_air_ip.e_sub_cmd = IVE_CMD_CTL_SET_AIR_PARAMS;
954
955 s_air_ip.e_air_mode =
956 (mIntraRefresh->mode == C2Config::INTRA_REFRESH_DISABLED || mIntraRefresh->period < 1)
957 ? IVE_AIR_MODE_NONE : IVE_AIR_MODE_CYCLIC;
958 s_air_ip.u4_air_refresh_period = mIntraRefresh->period;
959
960 s_air_ip.u4_timestamp_high = -1;
961 s_air_ip.u4_timestamp_low = -1;
962
963 s_air_ip.u4_size = sizeof(ive_ctl_set_air_params_ip_t);
964 s_air_op.u4_size = sizeof(ive_ctl_set_air_params_op_t);
965
966 status = ive_api_function(mCodecCtx, &s_air_ip, &s_air_op);
967 if (status != IV_SUCCESS) {
968 ALOGE("Unable to set air params = 0x%x\n", s_air_op.u4_error_code);
969 return C2_CORRUPTED;
970 }
971 return C2_OK;
972 }
973
setMeParams()974 c2_status_t C2SoftAvcEnc::setMeParams() {
975 IV_STATUS_T status;
976 ive_ctl_set_me_params_ip_t s_me_params_ip;
977 ive_ctl_set_me_params_op_t s_me_params_op;
978
979 s_me_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
980 s_me_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_ME_PARAMS;
981
982 s_me_params_ip.u4_enable_fast_sad = mEnableFastSad;
983 s_me_params_ip.u4_enable_alt_ref = mEnableAltRef;
984
985 s_me_params_ip.u4_enable_hpel = mHalfPelEnable;
986 s_me_params_ip.u4_enable_qpel = DEFAULT_QPEL;
987 s_me_params_ip.u4_me_speed_preset = DEFAULT_ME_SPEED;
988 s_me_params_ip.u4_srch_rng_x = DEFAULT_SRCH_RNG_X;
989 s_me_params_ip.u4_srch_rng_y = DEFAULT_SRCH_RNG_Y;
990
991 s_me_params_ip.u4_timestamp_high = -1;
992 s_me_params_ip.u4_timestamp_low = -1;
993
994 s_me_params_ip.u4_size = sizeof(ive_ctl_set_me_params_ip_t);
995 s_me_params_op.u4_size = sizeof(ive_ctl_set_me_params_op_t);
996
997 status = ive_api_function(mCodecCtx, &s_me_params_ip, &s_me_params_op);
998 if (status != IV_SUCCESS) {
999 ALOGE("Unable to set me params = 0x%x\n", s_me_params_op.u4_error_code);
1000 return C2_CORRUPTED;
1001 }
1002 return C2_OK;
1003 }
1004
setGopParams()1005 c2_status_t C2SoftAvcEnc::setGopParams() {
1006 IV_STATUS_T status;
1007 ive_ctl_set_gop_params_ip_t s_gop_params_ip;
1008 ive_ctl_set_gop_params_op_t s_gop_params_op;
1009
1010 s_gop_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1011 s_gop_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_GOP_PARAMS;
1012
1013 s_gop_params_ip.u4_i_frm_interval = mIInterval;
1014 s_gop_params_ip.u4_idr_frm_interval = mIDRInterval;
1015
1016 s_gop_params_ip.u4_timestamp_high = -1;
1017 s_gop_params_ip.u4_timestamp_low = -1;
1018
1019 s_gop_params_ip.u4_size = sizeof(ive_ctl_set_gop_params_ip_t);
1020 s_gop_params_op.u4_size = sizeof(ive_ctl_set_gop_params_op_t);
1021
1022 status = ive_api_function(mCodecCtx, &s_gop_params_ip, &s_gop_params_op);
1023 if (status != IV_SUCCESS) {
1024 ALOGE("Unable to set GOP params = 0x%x\n",
1025 s_gop_params_op.u4_error_code);
1026 return C2_CORRUPTED;
1027 }
1028 return C2_OK;
1029 }
1030
setProfileParams()1031 c2_status_t C2SoftAvcEnc::setProfileParams() {
1032 IntfImpl::Lock lock = mIntf->lock();
1033
1034 IV_STATUS_T status;
1035 ive_ctl_set_profile_params_ip_t s_profile_params_ip;
1036 ive_ctl_set_profile_params_op_t s_profile_params_op;
1037
1038 s_profile_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1039 s_profile_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_PROFILE_PARAMS;
1040
1041 s_profile_params_ip.e_profile = mIntf->getProfile_l();
1042 if (s_profile_params_ip.e_profile == IV_PROFILE_BASE) {
1043 s_profile_params_ip.u4_entropy_coding_mode = 0;
1044 } else {
1045 s_profile_params_ip.u4_entropy_coding_mode = 1;
1046 }
1047 s_profile_params_ip.u4_timestamp_high = -1;
1048 s_profile_params_ip.u4_timestamp_low = -1;
1049
1050 s_profile_params_ip.u4_size = sizeof(ive_ctl_set_profile_params_ip_t);
1051 s_profile_params_op.u4_size = sizeof(ive_ctl_set_profile_params_op_t);
1052 lock.unlock();
1053
1054 status = ive_api_function(mCodecCtx, &s_profile_params_ip, &s_profile_params_op);
1055 if (status != IV_SUCCESS) {
1056 ALOGE("Unable to set profile params = 0x%x\n",
1057 s_profile_params_op.u4_error_code);
1058 return C2_CORRUPTED;
1059 }
1060 return C2_OK;
1061 }
1062
setDeblockParams()1063 c2_status_t C2SoftAvcEnc::setDeblockParams() {
1064 IV_STATUS_T status;
1065 ive_ctl_set_deblock_params_ip_t s_deblock_params_ip;
1066 ive_ctl_set_deblock_params_op_t s_deblock_params_op;
1067
1068 s_deblock_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1069 s_deblock_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_DEBLOCK_PARAMS;
1070
1071 s_deblock_params_ip.u4_disable_deblock_level = mDisableDeblkLevel;
1072
1073 s_deblock_params_ip.u4_timestamp_high = -1;
1074 s_deblock_params_ip.u4_timestamp_low = -1;
1075
1076 s_deblock_params_ip.u4_size = sizeof(ive_ctl_set_deblock_params_ip_t);
1077 s_deblock_params_op.u4_size = sizeof(ive_ctl_set_deblock_params_op_t);
1078
1079 status = ive_api_function(mCodecCtx, &s_deblock_params_ip, &s_deblock_params_op);
1080 if (status != IV_SUCCESS) {
1081 ALOGE("Unable to enable/disable deblock params = 0x%x\n",
1082 s_deblock_params_op.u4_error_code);
1083 return C2_CORRUPTED;
1084 }
1085 return C2_OK;
1086 }
1087
logVersion()1088 void C2SoftAvcEnc::logVersion() {
1089 ive_ctl_getversioninfo_ip_t s_ctl_ip;
1090 ive_ctl_getversioninfo_op_t s_ctl_op;
1091 UWORD8 au1_buf[512];
1092 IV_STATUS_T status;
1093
1094 s_ctl_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1095 s_ctl_ip.e_sub_cmd = IVE_CMD_CTL_GETVERSION;
1096 s_ctl_ip.u4_size = sizeof(ive_ctl_getversioninfo_ip_t);
1097 s_ctl_op.u4_size = sizeof(ive_ctl_getversioninfo_op_t);
1098 s_ctl_ip.pu1_version = au1_buf;
1099 s_ctl_ip.u4_version_bufsize = sizeof(au1_buf);
1100
1101 status = ive_api_function(mCodecCtx, (void *) &s_ctl_ip, (void *) &s_ctl_op);
1102
1103 if (status != IV_SUCCESS) {
1104 ALOGE("Error in getting version: 0x%x", s_ctl_op.u4_error_code);
1105 } else {
1106 ALOGV("Ittiam encoder version: %s", (char *)s_ctl_ip.pu1_version);
1107 }
1108 return;
1109 }
1110
setVuiParams()1111 c2_status_t C2SoftAvcEnc::setVuiParams()
1112 {
1113 ColorAspects sfAspects;
1114 if (!C2Mapper::map(mColorAspects->primaries, &sfAspects.mPrimaries)) {
1115 sfAspects.mPrimaries = android::ColorAspects::PrimariesUnspecified;
1116 }
1117 if (!C2Mapper::map(mColorAspects->range, &sfAspects.mRange)) {
1118 sfAspects.mRange = android::ColorAspects::RangeUnspecified;
1119 }
1120 if (!C2Mapper::map(mColorAspects->matrix, &sfAspects.mMatrixCoeffs)) {
1121 sfAspects.mMatrixCoeffs = android::ColorAspects::MatrixUnspecified;
1122 }
1123 if (!C2Mapper::map(mColorAspects->transfer, &sfAspects.mTransfer)) {
1124 sfAspects.mTransfer = android::ColorAspects::TransferUnspecified;
1125 }
1126 int32_t primaries, transfer, matrixCoeffs;
1127 bool range;
1128 ColorUtils::convertCodecColorAspectsToIsoAspects(sfAspects,
1129 &primaries,
1130 &transfer,
1131 &matrixCoeffs,
1132 &range);
1133 ih264e_vui_ip_t s_vui_params_ip {};
1134 ih264e_vui_op_t s_vui_params_op {};
1135
1136 s_vui_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
1137 s_vui_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_VUI_PARAMS;
1138
1139 s_vui_params_ip.u1_video_signal_type_present_flag = 1;
1140 s_vui_params_ip.u1_colour_description_present_flag = 1;
1141 s_vui_params_ip.u1_colour_primaries = primaries;
1142 s_vui_params_ip.u1_transfer_characteristics = transfer;
1143 s_vui_params_ip.u1_matrix_coefficients = matrixCoeffs;
1144 s_vui_params_ip.u1_video_full_range_flag = range;
1145
1146 s_vui_params_ip.u4_size = sizeof(ih264e_vui_ip_t);
1147 s_vui_params_op.u4_size = sizeof(ih264e_vui_op_t);
1148
1149 IV_STATUS_T status = ih264e_api_function(mCodecCtx, &s_vui_params_ip,
1150 &s_vui_params_op);
1151 if(status != IV_SUCCESS)
1152 {
1153 ALOGE("Unable to set vui params = 0x%x\n",
1154 s_vui_params_op.u4_error_code);
1155 return C2_CORRUPTED;
1156 }
1157 return C2_OK;
1158 }
1159
initEncoder()1160 c2_status_t C2SoftAvcEnc::initEncoder() {
1161 IV_STATUS_T status;
1162 WORD32 level;
1163
1164 CHECK(!mStarted);
1165
1166 c2_status_t errType = C2_OK;
1167
1168 std::shared_ptr<C2StreamGopTuning::output> gop;
1169 {
1170 IntfImpl::Lock lock = mIntf->lock();
1171 mSize = mIntf->getSize_l();
1172 mBitrateMode = mIntf->getBitrateMode_l();
1173 mBitrate = mIntf->getBitrate_l();
1174 mFrameRate = mIntf->getFrameRate_l();
1175 mIntraRefresh = mIntf->getIntraRefresh_l();
1176 mAVCEncLevel = mIntf->getLevel_l();
1177 mIInterval = mIntf->getSyncFramePeriod_l();
1178 mIDRInterval = mIntf->getSyncFramePeriod_l();
1179 gop = mIntf->getGop_l();
1180 mColorAspects = mIntf->getCodedColorAspects_l();
1181 }
1182 if (gop && gop->flexCount() > 0) {
1183 uint32_t syncInterval = 1;
1184 uint32_t iInterval = 1;
1185 uint32_t maxBframes = 0;
1186 ParseGop(*gop, &syncInterval, &iInterval, &maxBframes);
1187 if (syncInterval > 0) {
1188 ALOGD("Updating IDR interval from GOP: old %u new %u", mIDRInterval, syncInterval);
1189 mIDRInterval = syncInterval;
1190 }
1191 if (iInterval > 0) {
1192 ALOGD("Updating I interval from GOP: old %u new %u", mIInterval, iInterval);
1193 mIInterval = iInterval;
1194 }
1195 if (mBframes != maxBframes) {
1196 ALOGD("Updating max B frames from GOP: old %u new %u", mBframes, maxBframes);
1197 mBframes = maxBframes;
1198 }
1199 }
1200 uint32_t width = mSize->width;
1201 uint32_t height = mSize->height;
1202
1203 mStride = width;
1204
1205 // Assume worst case output buffer size to be equal to number of bytes in input
1206 mOutBufferSize = std::max(width * height * 3 / 2, kMinOutBufferSize);
1207
1208 // TODO
1209 mIvVideoColorFormat = IV_YUV_420P;
1210
1211 ALOGD("Params width %d height %d level %d colorFormat %d bframes %d", width,
1212 height, mAVCEncLevel, mIvVideoColorFormat, mBframes);
1213
1214 /* Getting Number of MemRecords */
1215 {
1216 iv_num_mem_rec_ip_t s_num_mem_rec_ip;
1217 iv_num_mem_rec_op_t s_num_mem_rec_op;
1218
1219 s_num_mem_rec_ip.u4_size = sizeof(iv_num_mem_rec_ip_t);
1220 s_num_mem_rec_op.u4_size = sizeof(iv_num_mem_rec_op_t);
1221
1222 s_num_mem_rec_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
1223
1224 status = ive_api_function(nullptr, &s_num_mem_rec_ip, &s_num_mem_rec_op);
1225
1226 if (status != IV_SUCCESS) {
1227 ALOGE("Get number of memory records failed = 0x%x\n",
1228 s_num_mem_rec_op.u4_error_code);
1229 return C2_CORRUPTED;
1230 }
1231
1232 mNumMemRecords = s_num_mem_rec_op.u4_num_mem_rec;
1233 }
1234
1235 /* Allocate array to hold memory records */
1236 if (mNumMemRecords > SIZE_MAX / sizeof(iv_mem_rec_t)) {
1237 ALOGE("requested memory size is too big.");
1238 return C2_CORRUPTED;
1239 }
1240 mMemRecords = (iv_mem_rec_t *)malloc(mNumMemRecords * sizeof(iv_mem_rec_t));
1241 if (nullptr == mMemRecords) {
1242 ALOGE("Unable to allocate memory for hold memory records: Size %zu",
1243 mNumMemRecords * sizeof(iv_mem_rec_t));
1244 mSignalledError = true;
1245 return C2_CORRUPTED;
1246 }
1247
1248 {
1249 iv_mem_rec_t *ps_mem_rec;
1250 ps_mem_rec = mMemRecords;
1251 for (size_t i = 0; i < mNumMemRecords; i++) {
1252 ps_mem_rec->u4_size = sizeof(iv_mem_rec_t);
1253 ps_mem_rec->pv_base = nullptr;
1254 ps_mem_rec->u4_mem_size = 0;
1255 ps_mem_rec->u4_mem_alignment = 0;
1256 ps_mem_rec->e_mem_type = IV_NA_MEM_TYPE;
1257
1258 ps_mem_rec++;
1259 }
1260 }
1261
1262 /* Getting MemRecords Attributes */
1263 {
1264 ih264e_fill_mem_rec_ip_t s_ih264e_mem_rec_ip = {};
1265 ih264e_fill_mem_rec_op_t s_ih264e_mem_rec_op = {};
1266 iv_fill_mem_rec_ip_t *ps_fill_mem_rec_ip = &s_ih264e_mem_rec_ip.s_ive_ip;
1267 iv_fill_mem_rec_op_t *ps_fill_mem_rec_op = &s_ih264e_mem_rec_op.s_ive_op;
1268
1269 ps_fill_mem_rec_ip->u4_size = sizeof(ih264e_fill_mem_rec_ip_t);
1270 ps_fill_mem_rec_op->u4_size = sizeof(ih264e_fill_mem_rec_op_t);
1271
1272 ps_fill_mem_rec_ip->e_cmd = IV_CMD_FILL_NUM_MEM_REC;
1273 ps_fill_mem_rec_ip->ps_mem_rec = mMemRecords;
1274 ps_fill_mem_rec_ip->u4_num_mem_rec = mNumMemRecords;
1275 ps_fill_mem_rec_ip->u4_max_wd = width;
1276 ps_fill_mem_rec_ip->u4_max_ht = height;
1277 ps_fill_mem_rec_ip->u4_max_level = mAVCEncLevel;
1278 ps_fill_mem_rec_ip->e_color_format = DEFAULT_INP_COLOR_FORMAT;
1279 ps_fill_mem_rec_ip->u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
1280 ps_fill_mem_rec_ip->u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
1281 ps_fill_mem_rec_ip->u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
1282 ps_fill_mem_rec_ip->u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
1283
1284 status = ive_api_function(nullptr, &s_ih264e_mem_rec_ip, &s_ih264e_mem_rec_op);
1285
1286 if (status != IV_SUCCESS) {
1287 ALOGE("Fill memory records failed = 0x%x\n",
1288 ps_fill_mem_rec_op->u4_error_code);
1289 return C2_CORRUPTED;
1290 }
1291 }
1292
1293 /* Allocating Memory for Mem Records */
1294 {
1295 WORD32 total_size;
1296 iv_mem_rec_t *ps_mem_rec;
1297 total_size = 0;
1298 ps_mem_rec = mMemRecords;
1299
1300 for (size_t i = 0; i < mNumMemRecords; i++) {
1301 ps_mem_rec->pv_base = ive_aligned_malloc(
1302 ps_mem_rec->u4_mem_alignment, ps_mem_rec->u4_mem_size);
1303 if (ps_mem_rec->pv_base == nullptr) {
1304 ALOGE("Allocation failure for mem record id %zu size %u\n", i,
1305 ps_mem_rec->u4_mem_size);
1306 return C2_CORRUPTED;
1307
1308 }
1309 total_size += ps_mem_rec->u4_mem_size;
1310
1311 ps_mem_rec++;
1312 }
1313 }
1314
1315 /* Codec Instance Creation */
1316 {
1317 ih264e_init_ip_t s_enc_ip = {};
1318 ih264e_init_op_t s_enc_op = {};
1319
1320 ive_init_ip_t *ps_init_ip = &s_enc_ip.s_ive_ip;
1321 ive_init_op_t *ps_init_op = &s_enc_op.s_ive_op;
1322
1323 mCodecCtx = (iv_obj_t *)mMemRecords[0].pv_base;
1324 mCodecCtx->u4_size = sizeof(iv_obj_t);
1325 mCodecCtx->pv_fxns = (void *)ive_api_function;
1326
1327 ps_init_ip->u4_size = sizeof(ih264e_init_ip_t);
1328 ps_init_op->u4_size = sizeof(ih264e_init_op_t);
1329
1330 ps_init_ip->e_cmd = IV_CMD_INIT;
1331 ps_init_ip->u4_num_mem_rec = mNumMemRecords;
1332 ps_init_ip->ps_mem_rec = mMemRecords;
1333 ps_init_ip->u4_max_wd = width;
1334 ps_init_ip->u4_max_ht = height;
1335 ps_init_ip->u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
1336 ps_init_ip->u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
1337 ps_init_ip->u4_max_level = mAVCEncLevel;
1338 ps_init_ip->e_inp_color_fmt = mIvVideoColorFormat;
1339
1340 if (mReconEnable || mPSNREnable) {
1341 ps_init_ip->u4_enable_recon = 1;
1342 } else {
1343 ps_init_ip->u4_enable_recon = 0;
1344 }
1345
1346 switch (mBitrateMode->value) {
1347 case C2Config::BITRATE_IGNORE:
1348 ps_init_ip->e_rc_mode = IVE_RC_NONE;
1349 break;
1350 case C2Config::BITRATE_CONST:
1351 ps_init_ip->e_rc_mode = IVE_RC_CBR_NON_LOW_DELAY;
1352 break;
1353 case C2Config::BITRATE_VARIABLE:
1354 ps_init_ip->e_rc_mode = IVE_RC_STORAGE;
1355 break;
1356 default:
1357 ps_init_ip->e_rc_mode = DEFAULT_RC_MODE;
1358 break;
1359 break;
1360 }
1361 ps_init_ip->e_recon_color_fmt = DEFAULT_RECON_COLOR_FORMAT;
1362 ps_init_ip->u4_max_framerate = DEFAULT_MAX_FRAMERATE;
1363 ps_init_ip->u4_max_bitrate = DEFAULT_MAX_BITRATE;
1364 ps_init_ip->u4_num_bframes = mBframes;
1365 ps_init_ip->e_content_type = IV_PROGRESSIVE;
1366 ps_init_ip->u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
1367 ps_init_ip->u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
1368 ps_init_ip->e_slice_mode = mSliceMode;
1369 ps_init_ip->u4_slice_param = mSliceParam;
1370 ps_init_ip->e_arch = mArch;
1371 ps_init_ip->e_soc = DEFAULT_SOC;
1372
1373 status = ive_api_function(mCodecCtx, &s_enc_ip, &s_enc_op);
1374
1375 if (status != IV_SUCCESS) {
1376 ALOGE("Init encoder failed = 0x%x\n", ps_init_op->u4_error_code);
1377 return C2_CORRUPTED;
1378 }
1379 }
1380
1381 /* Get Codec Version */
1382 logVersion();
1383
1384 /* set processor details */
1385 setNumCores();
1386
1387 /* Video control Set Frame dimensions */
1388 setDimensions();
1389
1390 /* Video control Set Frame rates */
1391 setFrameRate();
1392
1393 /* Video control Set IPE Params */
1394 setIpeParams();
1395
1396 /* Video control Set Bitrate */
1397 setBitRate();
1398
1399 /* Video control Set QP */
1400 setQp();
1401
1402 /* Video control Set AIR params */
1403 setAirParams();
1404
1405 /* Video control Set VBV params */
1406 setVbvParams();
1407
1408 /* Video control Set Motion estimation params */
1409 setMeParams();
1410
1411 /* Video control Set GOP params */
1412 setGopParams();
1413
1414 /* Video control Set Deblock params */
1415 setDeblockParams();
1416
1417 /* Video control Set Profile params */
1418 setProfileParams();
1419
1420 /* Video control Set VUI params */
1421 setVuiParams();
1422
1423 /* Video control Set in Encode header mode */
1424 setEncMode(IVE_ENC_MODE_HEADER);
1425
1426 ALOGV("init_codec successfull");
1427
1428 mSpsPpsHeaderReceived = false;
1429 mStarted = true;
1430
1431 return C2_OK;
1432 }
1433
releaseEncoder()1434 c2_status_t C2SoftAvcEnc::releaseEncoder() {
1435 IV_STATUS_T status = IV_SUCCESS;
1436 iv_retrieve_mem_rec_ip_t s_retrieve_mem_ip;
1437 iv_retrieve_mem_rec_op_t s_retrieve_mem_op;
1438 iv_mem_rec_t *ps_mem_rec;
1439
1440 if (!mStarted) {
1441 return C2_OK;
1442 }
1443
1444 s_retrieve_mem_ip.u4_size = sizeof(iv_retrieve_mem_rec_ip_t);
1445 s_retrieve_mem_op.u4_size = sizeof(iv_retrieve_mem_rec_op_t);
1446 s_retrieve_mem_ip.e_cmd = IV_CMD_RETRIEVE_MEMREC;
1447 s_retrieve_mem_ip.ps_mem_rec = mMemRecords;
1448
1449 status = ive_api_function(mCodecCtx, &s_retrieve_mem_ip, &s_retrieve_mem_op);
1450
1451 if (status != IV_SUCCESS) {
1452 ALOGE("Unable to retrieve memory records = 0x%x\n",
1453 s_retrieve_mem_op.u4_error_code);
1454 return C2_CORRUPTED;
1455 }
1456
1457 /* Free memory records */
1458 ps_mem_rec = mMemRecords;
1459 for (size_t i = 0; i < s_retrieve_mem_op.u4_num_mem_rec_filled; i++) {
1460 if (ps_mem_rec) ive_aligned_free(ps_mem_rec->pv_base);
1461 else {
1462 ALOGE("memory record is null.");
1463 return C2_CORRUPTED;
1464 }
1465 ps_mem_rec++;
1466 }
1467
1468 if (mMemRecords) free(mMemRecords);
1469
1470 // clear other pointers into the space being free()d
1471 mCodecCtx = nullptr;
1472
1473 mStarted = false;
1474
1475 return C2_OK;
1476 }
1477
setEncodeArgs(ive_video_encode_ip_t * ps_encode_ip,ive_video_encode_op_t * ps_encode_op,const C2GraphicView * const input,uint8_t * base,uint32_t capacity,uint64_t workIndex)1478 c2_status_t C2SoftAvcEnc::setEncodeArgs(
1479 ive_video_encode_ip_t *ps_encode_ip,
1480 ive_video_encode_op_t *ps_encode_op,
1481 const C2GraphicView *const input,
1482 uint8_t *base,
1483 uint32_t capacity,
1484 uint64_t workIndex) {
1485 iv_raw_buf_t *ps_inp_raw_buf;
1486 memset(ps_encode_ip, 0, sizeof(*ps_encode_ip));
1487 memset(ps_encode_op, 0, sizeof(*ps_encode_op));
1488
1489 ps_inp_raw_buf = &ps_encode_ip->s_inp_buf;
1490 ps_encode_ip->s_out_buf.pv_buf = base;
1491 ps_encode_ip->s_out_buf.u4_bytes = 0;
1492 ps_encode_ip->s_out_buf.u4_bufsize = capacity;
1493 ps_encode_ip->u4_size = sizeof(ive_video_encode_ip_t);
1494 ps_encode_op->u4_size = sizeof(ive_video_encode_op_t);
1495
1496 ps_encode_ip->e_cmd = IVE_CMD_VIDEO_ENCODE;
1497 ps_encode_ip->pv_bufs = nullptr;
1498 ps_encode_ip->pv_mb_info = nullptr;
1499 ps_encode_ip->pv_pic_info = nullptr;
1500 ps_encode_ip->u4_mb_info_type = 0;
1501 ps_encode_ip->u4_pic_info_type = 0;
1502 ps_encode_ip->u4_is_last = 0;
1503 ps_encode_ip->u4_timestamp_high = workIndex >> 32;
1504 ps_encode_ip->u4_timestamp_low = workIndex & 0xFFFFFFFF;
1505 ps_encode_op->s_out_buf.pv_buf = nullptr;
1506
1507 /* Initialize color formats */
1508 memset(ps_inp_raw_buf, 0, sizeof(iv_raw_buf_t));
1509 ps_inp_raw_buf->u4_size = sizeof(iv_raw_buf_t);
1510 ps_inp_raw_buf->e_color_fmt = mIvVideoColorFormat;
1511 if (input == nullptr) {
1512 if (mSawInputEOS) {
1513 ps_encode_ip->u4_is_last = 1;
1514 }
1515 return C2_OK;
1516 }
1517
1518 if (input->width() < mSize->width ||
1519 input->height() < mSize->height) {
1520 /* Expect width height to be configured */
1521 ALOGW("unexpected Capacity Aspect %d(%d) x %d(%d)", input->width(),
1522 mSize->width, input->height(), mSize->height);
1523 return C2_BAD_VALUE;
1524 }
1525 ALOGV("width = %d, height = %d", input->width(), input->height());
1526 const C2PlanarLayout &layout = input->layout();
1527 uint8_t *yPlane = const_cast<uint8_t *>(input->data()[C2PlanarLayout::PLANE_Y]);
1528 uint8_t *uPlane = const_cast<uint8_t *>(input->data()[C2PlanarLayout::PLANE_U]);
1529 uint8_t *vPlane = const_cast<uint8_t *>(input->data()[C2PlanarLayout::PLANE_V]);
1530 int32_t yStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
1531 int32_t uStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc;
1532 int32_t vStride = layout.planes[C2PlanarLayout::PLANE_V].rowInc;
1533
1534 uint32_t width = mSize->width;
1535 uint32_t height = mSize->height;
1536 // width and height are always even (as block size is 16x16)
1537 CHECK_EQ((width & 1u), 0u);
1538 CHECK_EQ((height & 1u), 0u);
1539 size_t yPlaneSize = width * height;
1540
1541 switch (layout.type) {
1542 case C2PlanarLayout::TYPE_RGB:
1543 [[fallthrough]];
1544 case C2PlanarLayout::TYPE_RGBA: {
1545 ALOGV("yPlaneSize = %zu", yPlaneSize);
1546 MemoryBlock conversionBuffer = mConversionBuffers.fetch(yPlaneSize * 3 / 2);
1547 mConversionBuffersInUse.emplace(conversionBuffer.data(), conversionBuffer);
1548 yPlane = conversionBuffer.data();
1549 uPlane = yPlane + yPlaneSize;
1550 vPlane = uPlane + yPlaneSize / 4;
1551 yStride = width;
1552 uStride = vStride = yStride / 2;
1553 ConvertRGBToPlanarYUV(yPlane, yStride, height, conversionBuffer.size(), *input,
1554 mColorAspects->matrix, mColorAspects->range);
1555 break;
1556 }
1557 case C2PlanarLayout::TYPE_YUV: {
1558 if (!IsYUV420(*input)) {
1559 ALOGE("input is not YUV420");
1560 return C2_BAD_VALUE;
1561 }
1562
1563 if (layout.planes[layout.PLANE_Y].colInc == 1
1564 && layout.planes[layout.PLANE_U].colInc == 1
1565 && layout.planes[layout.PLANE_V].colInc == 1
1566 && uStride == vStride
1567 && yStride == 2 * vStride) {
1568 // I420 compatible - already set up above
1569 break;
1570 }
1571
1572 // copy to I420
1573 yStride = width;
1574 uStride = vStride = yStride / 2;
1575 MemoryBlock conversionBuffer = mConversionBuffers.fetch(yPlaneSize * 3 / 2);
1576 mConversionBuffersInUse.emplace(conversionBuffer.data(), conversionBuffer);
1577 MediaImage2 img = CreateYUV420PlanarMediaImage2(width, height, yStride, height);
1578 status_t err = ImageCopy(conversionBuffer.data(), &img, *input);
1579 if (err != OK) {
1580 ALOGE("Buffer conversion failed: %d", err);
1581 return C2_BAD_VALUE;
1582 }
1583 yPlane = conversionBuffer.data();
1584 uPlane = yPlane + yPlaneSize;
1585 vPlane = uPlane + yPlaneSize / 4;
1586 break;
1587
1588 }
1589
1590 case C2PlanarLayout::TYPE_YUVA:
1591 ALOGE("YUVA plane type is not supported");
1592 return C2_BAD_VALUE;
1593
1594 default:
1595 ALOGE("Unrecognized plane type: %d", layout.type);
1596 return C2_BAD_VALUE;
1597 }
1598
1599 switch (mIvVideoColorFormat) {
1600 case IV_YUV_420P:
1601 {
1602 // input buffer is supposed to be const but Ittiam API wants bare pointer.
1603 ps_inp_raw_buf->apv_bufs[0] = yPlane;
1604 ps_inp_raw_buf->apv_bufs[1] = uPlane;
1605 ps_inp_raw_buf->apv_bufs[2] = vPlane;
1606
1607 ps_inp_raw_buf->au4_wd[0] = mSize->width;
1608 ps_inp_raw_buf->au4_wd[1] = mSize->width / 2;
1609 ps_inp_raw_buf->au4_wd[2] = mSize->width / 2;
1610
1611 ps_inp_raw_buf->au4_ht[0] = mSize->height;
1612 ps_inp_raw_buf->au4_ht[1] = mSize->height / 2;
1613 ps_inp_raw_buf->au4_ht[2] = mSize->height / 2;
1614
1615 ps_inp_raw_buf->au4_strd[0] = yStride;
1616 ps_inp_raw_buf->au4_strd[1] = uStride;
1617 ps_inp_raw_buf->au4_strd[2] = vStride;
1618 break;
1619 }
1620
1621 case IV_YUV_422ILE:
1622 {
1623 // TODO
1624 // ps_inp_raw_buf->apv_bufs[0] = pu1_buf;
1625 // ps_inp_raw_buf->au4_wd[0] = mWidth * 2;
1626 // ps_inp_raw_buf->au4_ht[0] = mHeight;
1627 // ps_inp_raw_buf->au4_strd[0] = mStride * 2;
1628 break;
1629 }
1630
1631 case IV_YUV_420SP_UV:
1632 case IV_YUV_420SP_VU:
1633 default:
1634 {
1635 ps_inp_raw_buf->apv_bufs[0] = yPlane;
1636 ps_inp_raw_buf->apv_bufs[1] = uPlane;
1637
1638 ps_inp_raw_buf->au4_wd[0] = mSize->width;
1639 ps_inp_raw_buf->au4_wd[1] = mSize->width;
1640
1641 ps_inp_raw_buf->au4_ht[0] = mSize->height;
1642 ps_inp_raw_buf->au4_ht[1] = mSize->height / 2;
1643
1644 ps_inp_raw_buf->au4_strd[0] = yStride;
1645 ps_inp_raw_buf->au4_strd[1] = uStride;
1646 break;
1647 }
1648 }
1649 return C2_OK;
1650 }
1651
finishWork(uint64_t workIndex,const std::unique_ptr<C2Work> & work,ive_video_encode_op_t * ps_encode_op)1652 void C2SoftAvcEnc::finishWork(uint64_t workIndex, const std::unique_ptr<C2Work> &work,
1653 ive_video_encode_op_t *ps_encode_op) {
1654 std::shared_ptr<C2Buffer> buffer =
1655 createLinearBuffer(mOutBlock, 0, ps_encode_op->s_out_buf.u4_bytes);
1656 if (IV_IDR_FRAME == ps_encode_op->u4_encoded_frame_type) {
1657 ALOGV("IDR frame produced");
1658 buffer->setInfo(std::make_shared<C2StreamPictureTypeMaskInfo::output>(
1659 0u /* stream id */, C2Config::SYNC_FRAME));
1660 }
1661 mOutBlock = nullptr;
1662
1663 auto fillWork = [buffer](const std::unique_ptr<C2Work> &work) {
1664 work->worklets.front()->output.flags = (C2FrameData::flags_t)0;
1665 work->worklets.front()->output.buffers.clear();
1666 work->worklets.front()->output.buffers.push_back(buffer);
1667 work->worklets.front()->output.ordinal = work->input.ordinal;
1668 work->workletsProcessed = 1u;
1669 };
1670 if (work && c2_cntr64_t(workIndex) == work->input.ordinal.frameIndex) {
1671 fillWork(work);
1672 if (mSawInputEOS) {
1673 work->worklets.front()->output.flags = C2FrameData::FLAG_END_OF_STREAM;
1674 }
1675 } else {
1676 finish(workIndex, fillWork);
1677 }
1678 }
1679
process(const std::unique_ptr<C2Work> & work,const std::shared_ptr<C2BlockPool> & pool)1680 void C2SoftAvcEnc::process(
1681 const std::unique_ptr<C2Work> &work,
1682 const std::shared_ptr<C2BlockPool> &pool) {
1683 // Initialize output work
1684 work->result = C2_OK;
1685 work->workletsProcessed = 0u;
1686 work->worklets.front()->output.flags = work->input.flags;
1687
1688 IV_STATUS_T status;
1689 nsecs_t timeDelay = 0;
1690 uint64_t workIndex = work->input.ordinal.frameIndex.peekull();
1691
1692 // Initialize encoder if not already initialized
1693 if (mCodecCtx == nullptr) {
1694 if (C2_OK != initEncoder()) {
1695 ALOGE("Failed to initialize encoder");
1696 mSignalledError = true;
1697 work->result = C2_CORRUPTED;
1698 work->workletsProcessed = 1u;
1699 return;
1700 }
1701 }
1702 if (mSignalledError) {
1703 return;
1704 }
1705 // while (!mSawOutputEOS && !outQueue.empty()) {
1706 c2_status_t error;
1707 ih264e_video_encode_ip_t s_video_encode_ip = {};
1708 ih264e_video_encode_op_t s_video_encode_op = {};
1709 ive_video_encode_ip_t *ps_encode_ip = &s_video_encode_ip.s_ive_ip;
1710 ive_video_encode_op_t *ps_encode_op = &s_video_encode_op.s_ive_op;
1711 memset(ps_encode_op, 0, sizeof(*ps_encode_op));
1712
1713 if (!mSpsPpsHeaderReceived) {
1714 constexpr uint32_t kHeaderLength = MIN_STREAM_SIZE;
1715 uint8_t header[kHeaderLength];
1716 error = setEncodeArgs(
1717 ps_encode_ip, ps_encode_op, nullptr, header, kHeaderLength, workIndex);
1718 if (error != C2_OK) {
1719 ALOGE("setEncodeArgs failed: %d", error);
1720 mSignalledError = true;
1721 work->result = C2_CORRUPTED;
1722 work->workletsProcessed = 1u;
1723 return;
1724 }
1725 status = ive_api_function(mCodecCtx, ps_encode_ip, ps_encode_op);
1726
1727 if (IV_SUCCESS != status) {
1728 ALOGE("Encode header failed = 0x%x\n",
1729 ps_encode_op->u4_error_code);
1730 work->workletsProcessed = 1u;
1731 return;
1732 } else {
1733 ALOGV("Bytes Generated in header %d\n",
1734 ps_encode_op->s_out_buf.u4_bytes);
1735 }
1736
1737 mSpsPpsHeaderReceived = true;
1738
1739 std::unique_ptr<C2StreamInitDataInfo::output> csd =
1740 C2StreamInitDataInfo::output::AllocUnique(ps_encode_op->s_out_buf.u4_bytes, 0u);
1741 if (!csd) {
1742 ALOGE("CSD allocation failed");
1743 mSignalledError = true;
1744 work->result = C2_NO_MEMORY;
1745 work->workletsProcessed = 1u;
1746 return;
1747 }
1748 memcpy(csd->m.value, header, ps_encode_op->s_out_buf.u4_bytes);
1749 work->worklets.front()->output.configUpdate.push_back(std::move(csd));
1750
1751 DUMP_TO_FILE(
1752 mOutFile, csd->m.value, csd->flexCount());
1753 if (work->input.buffers.empty()) {
1754 work->workletsProcessed = 1u;
1755 return;
1756 }
1757 }
1758
1759 // handle dynamic config parameters
1760 {
1761 IntfImpl::Lock lock = mIntf->lock();
1762 std::shared_ptr<C2StreamIntraRefreshTuning::output> intraRefresh = mIntf->getIntraRefresh_l();
1763 std::shared_ptr<C2StreamBitrateInfo::output> bitrate = mIntf->getBitrate_l();
1764 std::shared_ptr<C2StreamRequestSyncFrameTuning::output> requestSync = mIntf->getRequestSync_l();
1765 lock.unlock();
1766
1767 if (bitrate != mBitrate) {
1768 mBitrate = bitrate;
1769 setBitRate();
1770 }
1771
1772 if (intraRefresh != mIntraRefresh) {
1773 mIntraRefresh = intraRefresh;
1774 setAirParams();
1775 }
1776
1777 if (requestSync != mRequestSync) {
1778 // we can handle IDR immediately
1779 if (requestSync->value) {
1780 // unset request
1781 C2StreamRequestSyncFrameTuning::output clearSync(0u, C2_FALSE);
1782 std::vector<std::unique_ptr<C2SettingResult>> failures;
1783 mIntf->config({ &clearSync }, C2_MAY_BLOCK, &failures);
1784 ALOGV("Got sync request");
1785 setFrameType(IV_IDR_FRAME);
1786 }
1787 mRequestSync = requestSync;
1788 }
1789 }
1790
1791 if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
1792 mSawInputEOS = true;
1793 }
1794
1795 /* In normal mode, store inputBufferInfo and this will be returned
1796 when encoder consumes this input */
1797 // if (!mInputDataIsMeta && (inputBufferInfo != NULL)) {
1798 // for (size_t i = 0; i < MAX_INPUT_BUFFER_HEADERS; i++) {
1799 // if (NULL == mInputBufferInfo[i]) {
1800 // mInputBufferInfo[i] = inputBufferInfo;
1801 // break;
1802 // }
1803 // }
1804 // }
1805 std::shared_ptr<C2GraphicView> view;
1806 std::shared_ptr<C2Buffer> inputBuffer;
1807 if (!work->input.buffers.empty()) {
1808 inputBuffer = work->input.buffers[0];
1809 view = std::make_shared<C2GraphicView>(
1810 inputBuffer->data().graphicBlocks().front().map().get());
1811 if (view->error() != C2_OK) {
1812 ALOGE("graphic view map err = %d", view->error());
1813 work->workletsProcessed = 1u;
1814 return;
1815 }
1816 //(b/232396154)
1817 //workaround for incorrect crop size in view when using surface mode
1818 view->setCrop_be(C2Rect(mSize->width, mSize->height));
1819 }
1820
1821 do {
1822 if (mSawInputEOS && work->input.buffers.empty()) break;
1823 if (!mOutBlock) {
1824 C2MemoryUsage usage = {C2MemoryUsage::CPU_READ,
1825 C2MemoryUsage::CPU_WRITE};
1826 // TODO: error handling, proper usage, etc.
1827 c2_status_t err =
1828 pool->fetchLinearBlock(mOutBufferSize, usage, &mOutBlock);
1829 if (err != C2_OK) {
1830 ALOGE("fetch linear block err = %d", err);
1831 work->result = err;
1832 work->workletsProcessed = 1u;
1833 return;
1834 }
1835 }
1836 C2WriteView wView = mOutBlock->map().get();
1837 if (wView.error() != C2_OK) {
1838 ALOGE("write view map err = %d", wView.error());
1839 work->result = wView.error();
1840 work->workletsProcessed = 1u;
1841 return;
1842 }
1843
1844 error = setEncodeArgs(
1845 ps_encode_ip, ps_encode_op, view.get(), wView.base(), wView.capacity(), workIndex);
1846 if (error != C2_OK) {
1847 ALOGE("setEncodeArgs failed : %d", error);
1848 mSignalledError = true;
1849 work->result = error;
1850 work->workletsProcessed = 1u;
1851 return;
1852 }
1853
1854 // DUMP_TO_FILE(
1855 // mInFile, s_encode_ip.s_inp_buf.apv_bufs[0],
1856 // (mHeight * mStride * 3 / 2));
1857
1858 /* Compute time elapsed between end of previous decode()
1859 * to start of current decode() */
1860 mTimeStart = systemTime();
1861 timeDelay = mTimeStart - mTimeEnd;
1862 status = ive_api_function(mCodecCtx, &s_video_encode_ip, &s_video_encode_op);
1863
1864 if (IV_SUCCESS != status) {
1865 if ((ps_encode_op->u4_error_code & 0xFF) == IH264E_BITSTREAM_BUFFER_OVERFLOW) {
1866 // TODO: use IVE_CMD_CTL_GETBUFINFO for proper max input size?
1867 mOutBufferSize *= 2;
1868 mOutBlock.reset();
1869 continue;
1870 }
1871 ALOGE("Encode Frame failed = 0x%x\n",
1872 ps_encode_op->u4_error_code);
1873 mSignalledError = true;
1874 work->result = C2_CORRUPTED;
1875 work->workletsProcessed = 1u;
1876 return;
1877 }
1878 } while (IV_SUCCESS != status);
1879
1880 // Hold input buffer reference
1881 if (inputBuffer) {
1882 mBuffers[ps_encode_ip->s_inp_buf.apv_bufs[0]] = inputBuffer;
1883 }
1884
1885 /* Compute time taken for decode() */
1886 mTimeEnd = systemTime();
1887 nsecs_t timeTaken = mTimeEnd - mTimeStart;
1888
1889 ALOGV("timeTaken=%" PRId64 "d delay=%" PRId64 " numBytes=%6d", timeTaken, timeDelay,
1890 ps_encode_op->s_out_buf.u4_bytes);
1891
1892 void *freed = ps_encode_op->s_inp_buf.apv_bufs[0];
1893 /* If encoder frees up an input buffer, mark it as free */
1894 if (freed != nullptr) {
1895 if (mBuffers.count(freed) == 0u) {
1896 ALOGD("buffer not tracked");
1897 } else {
1898 // Release input buffer reference
1899 mBuffers.erase(freed);
1900 mConversionBuffersInUse.erase(freed);
1901 }
1902 }
1903
1904 if (ps_encode_op->output_present) {
1905 if (!ps_encode_op->s_out_buf.u4_bytes) {
1906 ALOGE("Error: Output present but bytes generated is zero");
1907 mSignalledError = true;
1908 work->result = C2_CORRUPTED;
1909 work->workletsProcessed = 1u;
1910 return;
1911 }
1912 uint64_t workId = ((uint64_t)ps_encode_op->u4_timestamp_high << 32) |
1913 ps_encode_op->u4_timestamp_low;
1914 finishWork(workId, work, ps_encode_op);
1915 }
1916 if (mSawInputEOS) {
1917 drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
1918 }
1919 }
1920
drainInternal(uint32_t drainMode,const std::shared_ptr<C2BlockPool> & pool,const std::unique_ptr<C2Work> & work)1921 c2_status_t C2SoftAvcEnc::drainInternal(
1922 uint32_t drainMode,
1923 const std::shared_ptr<C2BlockPool> &pool,
1924 const std::unique_ptr<C2Work> &work) {
1925
1926 if (drainMode == NO_DRAIN) {
1927 ALOGW("drain with NO_DRAIN: no-op");
1928 return C2_OK;
1929 }
1930 if (drainMode == DRAIN_CHAIN) {
1931 ALOGW("DRAIN_CHAIN not supported");
1932 return C2_OMITTED;
1933 }
1934
1935 while (true) {
1936 if (!mOutBlock) {
1937 C2MemoryUsage usage = {C2MemoryUsage::CPU_READ,
1938 C2MemoryUsage::CPU_WRITE};
1939 // TODO: error handling, proper usage, etc.
1940 c2_status_t err =
1941 pool->fetchLinearBlock(mOutBufferSize, usage, &mOutBlock);
1942 if (err != C2_OK) {
1943 ALOGE("fetch linear block err = %d", err);
1944 work->result = err;
1945 work->workletsProcessed = 1u;
1946 return err;
1947 }
1948 }
1949 C2WriteView wView = mOutBlock->map().get();
1950 if (wView.error()) {
1951 ALOGE("graphic view map failed %d", wView.error());
1952 return C2_CORRUPTED;
1953 }
1954 ih264e_video_encode_ip_t s_video_encode_ip = {};
1955 ih264e_video_encode_op_t s_video_encode_op = {};
1956 ive_video_encode_ip_t *ps_encode_ip = &s_video_encode_ip.s_ive_ip;
1957 ive_video_encode_op_t *ps_encode_op = &s_video_encode_op.s_ive_op;
1958 if (C2_OK != setEncodeArgs(ps_encode_ip, ps_encode_op, nullptr,
1959 wView.base(), wView.capacity(), 0)) {
1960 ALOGE("setEncodeArgs failed for drainInternal");
1961 mSignalledError = true;
1962 work->result = C2_CORRUPTED;
1963 work->workletsProcessed = 1u;
1964 return C2_CORRUPTED;
1965 }
1966 (void)ive_api_function(mCodecCtx, &s_video_encode_ip, &s_video_encode_op);
1967
1968 void *freed = ps_encode_op->s_inp_buf.apv_bufs[0];
1969 /* If encoder frees up an input buffer, mark it as free */
1970 if (freed != nullptr) {
1971 if (mBuffers.count(freed) == 0u) {
1972 ALOGD("buffer not tracked");
1973 } else {
1974 // Release input buffer reference
1975 mBuffers.erase(freed);
1976 mConversionBuffersInUse.erase(freed);
1977 }
1978 }
1979
1980 if (ps_encode_op->output_present) {
1981 uint64_t workId = ((uint64_t)ps_encode_op->u4_timestamp_high << 32) |
1982 ps_encode_op->u4_timestamp_low;
1983 finishWork(workId, work, ps_encode_op);
1984 } else {
1985 if (work->workletsProcessed != 1u) {
1986 work->worklets.front()->output.flags = work->input.flags;
1987 work->worklets.front()->output.ordinal = work->input.ordinal;
1988 work->worklets.front()->output.buffers.clear();
1989 work->workletsProcessed = 1u;
1990 }
1991 break;
1992 }
1993 }
1994
1995 return C2_OK;
1996 }
1997
drain(uint32_t drainMode,const std::shared_ptr<C2BlockPool> & pool)1998 c2_status_t C2SoftAvcEnc::drain(
1999 uint32_t drainMode,
2000 const std::shared_ptr<C2BlockPool> &pool) {
2001 return drainInternal(drainMode, pool, nullptr);
2002 }
2003
2004 class C2SoftAvcEncFactory : public C2ComponentFactory {
2005 public:
C2SoftAvcEncFactory()2006 C2SoftAvcEncFactory() : mHelper(std::static_pointer_cast<C2ReflectorHelper>(
2007 GetCodec2PlatformComponentStore()->getParamReflector())) {
2008 }
2009
createComponent(c2_node_id_t id,std::shared_ptr<C2Component> * const component,std::function<void (C2Component *)> deleter)2010 virtual c2_status_t createComponent(
2011 c2_node_id_t id,
2012 std::shared_ptr<C2Component>* const component,
2013 std::function<void(C2Component*)> deleter) override {
2014 *component = std::shared_ptr<C2Component>(
2015 new C2SoftAvcEnc(COMPONENT_NAME,
2016 id,
2017 std::make_shared<C2SoftAvcEnc::IntfImpl>(mHelper)),
2018 deleter);
2019 return C2_OK;
2020 }
2021
createInterface(c2_node_id_t id,std::shared_ptr<C2ComponentInterface> * const interface,std::function<void (C2ComponentInterface *)> deleter)2022 virtual c2_status_t createInterface(
2023 c2_node_id_t id,
2024 std::shared_ptr<C2ComponentInterface>* const interface,
2025 std::function<void(C2ComponentInterface*)> deleter) override {
2026 *interface = std::shared_ptr<C2ComponentInterface>(
2027 new SimpleInterface<C2SoftAvcEnc::IntfImpl>(
2028 COMPONENT_NAME, id, std::make_shared<C2SoftAvcEnc::IntfImpl>(mHelper)),
2029 deleter);
2030 return C2_OK;
2031 }
2032
2033 virtual ~C2SoftAvcEncFactory() override = default;
2034
2035 private:
2036 std::shared_ptr<C2ReflectorHelper> mHelper;
2037 };
2038
2039 } // namespace android
2040
2041 __attribute__((cfi_canonical_jump_table))
CreateCodec2Factory()2042 extern "C" ::C2ComponentFactory* CreateCodec2Factory() {
2043 ALOGV("in %s", __func__);
2044 return new ::android::C2SoftAvcEncFactory();
2045 }
2046
2047 __attribute__((cfi_canonical_jump_table))
DestroyCodec2Factory(::C2ComponentFactory * factory)2048 extern "C" void DestroyCodec2Factory(::C2ComponentFactory* factory) {
2049 ALOGV("in %s", __func__);
2050 delete factory;
2051 }
2052