1 /*
2 * Copyright 2017 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 "C2SoftAvcDec"
19 #ifndef KEEP_THREADS_ACTIVE
20 #define KEEP_THREADS_ACTIVE 0
21 #endif
22 #include <log/log.h>
23
24 #include <media/stagefright/foundation/MediaDefs.h>
25
26 #include <C2Debug.h>
27 #include <C2PlatformSupport.h>
28 #include <Codec2Mapper.h>
29 #include <SimpleC2Interface.h>
30
31 #include "C2SoftAvcDec.h"
32
33 namespace android {
34
35 namespace {
36 constexpr size_t kMinInputBufferSize = 2 * 1024 * 1024;
37 constexpr char COMPONENT_NAME[] = "c2.android.avc.decoder";
38 constexpr uint32_t kDefaultOutputDelay = 8;
39 /* avc specification allows for a maximum delay of 16 frames.
40 As soft avc decoder supports interlaced, this delay would be 32 fields.
41 And avc decoder implementation has an additional delay of 2 decode calls.
42 So total maximum output delay is 34 */
43 constexpr uint32_t kMaxOutputDelay = 34;
44 constexpr uint32_t kMinInputBytes = 4;
45 } // namespace
46
47 class C2SoftAvcDec::IntfImpl : public SimpleInterface<void>::BaseParams {
48 public:
IntfImpl(const std::shared_ptr<C2ReflectorHelper> & helper)49 explicit IntfImpl(const std::shared_ptr<C2ReflectorHelper> &helper)
50 : SimpleInterface<void>::BaseParams(
51 helper,
52 COMPONENT_NAME,
53 C2Component::KIND_DECODER,
54 C2Component::DOMAIN_VIDEO,
55 MEDIA_MIMETYPE_VIDEO_AVC) {
56 noPrivateBuffers(); // TODO: account for our buffers here
57 noInputReferences();
58 noOutputReferences();
59 noInputLatency();
60 noTimeStretch();
61
62 // TODO: Proper support for reorder depth.
63 addParameter(
64 DefineParam(mActualOutputDelay, C2_PARAMKEY_OUTPUT_DELAY)
65 .withDefault(new C2PortActualDelayTuning::output(kDefaultOutputDelay))
66 .withFields({C2F(mActualOutputDelay, value).inRange(0, kMaxOutputDelay)})
67 .withSetter(Setter<decltype(*mActualOutputDelay)>::StrictValueWithNoDeps)
68 .build());
69
70 // TODO: output latency and reordering
71
72 addParameter(
73 DefineParam(mAttrib, C2_PARAMKEY_COMPONENT_ATTRIBUTES)
74 .withConstValue(new C2ComponentAttributesSetting(C2Component::ATTRIB_IS_TEMPORAL))
75 .build());
76
77 // coded and output picture size is the same for this codec
78 addParameter(
79 DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE)
80 .withDefault(new C2StreamPictureSizeInfo::output(0u, 320, 240))
81 .withFields({
82 C2F(mSize, width).inRange(2, 4080, 2),
83 C2F(mSize, height).inRange(2, 4080, 2),
84 })
85 .withSetter(SizeSetter)
86 .build());
87
88 addParameter(
89 DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE)
90 .withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240))
91 .withFields({
92 C2F(mSize, width).inRange(2, 4080, 2),
93 C2F(mSize, height).inRange(2, 4080, 2),
94 })
95 .withSetter(MaxPictureSizeSetter, mSize)
96 .build());
97
98 addParameter(
99 DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
100 .withDefault(new C2StreamProfileLevelInfo::input(0u,
101 C2Config::PROFILE_AVC_CONSTRAINED_BASELINE, C2Config::LEVEL_AVC_5_2))
102 .withFields({
103 C2F(mProfileLevel, profile).oneOf({
104 C2Config::PROFILE_AVC_CONSTRAINED_BASELINE,
105 C2Config::PROFILE_AVC_BASELINE,
106 C2Config::PROFILE_AVC_MAIN,
107 C2Config::PROFILE_AVC_CONSTRAINED_HIGH,
108 C2Config::PROFILE_AVC_PROGRESSIVE_HIGH,
109 C2Config::PROFILE_AVC_HIGH}),
110 C2F(mProfileLevel, level).oneOf({
111 C2Config::LEVEL_AVC_1, C2Config::LEVEL_AVC_1B, C2Config::LEVEL_AVC_1_1,
112 C2Config::LEVEL_AVC_1_2, C2Config::LEVEL_AVC_1_3,
113 C2Config::LEVEL_AVC_2, C2Config::LEVEL_AVC_2_1, C2Config::LEVEL_AVC_2_2,
114 C2Config::LEVEL_AVC_3, C2Config::LEVEL_AVC_3_1, C2Config::LEVEL_AVC_3_2,
115 C2Config::LEVEL_AVC_4, C2Config::LEVEL_AVC_4_1, C2Config::LEVEL_AVC_4_2,
116 C2Config::LEVEL_AVC_5, C2Config::LEVEL_AVC_5_1, C2Config::LEVEL_AVC_5_2
117 })
118 })
119 .withSetter(ProfileLevelSetter, mSize)
120 .build());
121
122 addParameter(
123 DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
124 .withDefault(new C2StreamMaxBufferSizeInfo::input(0u, kMinInputBufferSize))
125 .withFields({
126 C2F(mMaxInputSize, value).any(),
127 })
128 .calculatedAs(MaxInputSizeSetter, mMaxSize)
129 .build());
130
131 C2ChromaOffsetStruct locations[1] = { C2ChromaOffsetStruct::ITU_YUV_420_0() };
132 std::shared_ptr<C2StreamColorInfo::output> defaultColorInfo =
133 C2StreamColorInfo::output::AllocShared(
134 1u, 0u, 8u /* bitDepth */, C2Color::YUV_420);
135 memcpy(defaultColorInfo->m.locations, locations, sizeof(locations));
136
137 defaultColorInfo =
138 C2StreamColorInfo::output::AllocShared(
139 { C2ChromaOffsetStruct::ITU_YUV_420_0() },
140 0u, 8u /* bitDepth */, C2Color::YUV_420);
141 helper->addStructDescriptors<C2ChromaOffsetStruct>();
142
143 addParameter(
144 DefineParam(mColorInfo, C2_PARAMKEY_CODED_COLOR_INFO)
145 .withConstValue(defaultColorInfo)
146 .build());
147
148 addParameter(
149 DefineParam(mDefaultColorAspects, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS)
150 .withDefault(new C2StreamColorAspectsTuning::output(
151 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
152 C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
153 .withFields({
154 C2F(mDefaultColorAspects, range).inRange(
155 C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
156 C2F(mDefaultColorAspects, primaries).inRange(
157 C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
158 C2F(mDefaultColorAspects, transfer).inRange(
159 C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
160 C2F(mDefaultColorAspects, matrix).inRange(
161 C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
162 })
163 .withSetter(DefaultColorAspectsSetter)
164 .build());
165
166 addParameter(
167 DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
168 .withDefault(new C2StreamColorAspectsInfo::input(
169 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
170 C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
171 .withFields({
172 C2F(mCodedColorAspects, range).inRange(
173 C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
174 C2F(mCodedColorAspects, primaries).inRange(
175 C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
176 C2F(mCodedColorAspects, transfer).inRange(
177 C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
178 C2F(mCodedColorAspects, matrix).inRange(
179 C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
180 })
181 .withSetter(CodedColorAspectsSetter)
182 .build());
183
184 addParameter(
185 DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
186 .withDefault(new C2StreamColorAspectsInfo::output(
187 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
188 C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
189 .withFields({
190 C2F(mColorAspects, range).inRange(
191 C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
192 C2F(mColorAspects, primaries).inRange(
193 C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
194 C2F(mColorAspects, transfer).inRange(
195 C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
196 C2F(mColorAspects, matrix).inRange(
197 C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
198 })
199 .withSetter(ColorAspectsSetter, mDefaultColorAspects, mCodedColorAspects)
200 .build());
201
202 // TODO: support more formats?
203 addParameter(
204 DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT)
205 .withConstValue(new C2StreamPixelFormatInfo::output(
206 0u, HAL_PIXEL_FORMAT_YCBCR_420_888))
207 .build());
208 }
SizeSetter(bool mayBlock,const C2P<C2StreamPictureSizeInfo::output> & oldMe,C2P<C2StreamPictureSizeInfo::output> & me)209 static C2R SizeSetter(bool mayBlock, const C2P<C2StreamPictureSizeInfo::output> &oldMe,
210 C2P<C2StreamPictureSizeInfo::output> &me) {
211 (void)mayBlock;
212 C2R res = C2R::Ok();
213 if (!me.F(me.v.width).supportsAtAll(me.v.width)) {
214 res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.width)));
215 me.set().width = oldMe.v.width;
216 }
217 if (!me.F(me.v.height).supportsAtAll(me.v.height)) {
218 res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.height)));
219 me.set().height = oldMe.v.height;
220 }
221 return res;
222 }
223
MaxPictureSizeSetter(bool mayBlock,C2P<C2StreamMaxPictureSizeTuning::output> & me,const C2P<C2StreamPictureSizeInfo::output> & size)224 static C2R MaxPictureSizeSetter(bool mayBlock, C2P<C2StreamMaxPictureSizeTuning::output> &me,
225 const C2P<C2StreamPictureSizeInfo::output> &size) {
226 (void)mayBlock;
227 // TODO: get max width/height from the size's field helpers vs. hardcoding
228 me.set().width = c2_min(c2_max(me.v.width, size.v.width), 4080u);
229 me.set().height = c2_min(c2_max(me.v.height, size.v.height), 4080u);
230 return C2R::Ok();
231 }
232
MaxInputSizeSetter(bool mayBlock,C2P<C2StreamMaxBufferSizeInfo::input> & me,const C2P<C2StreamMaxPictureSizeTuning::output> & maxSize)233 static C2R MaxInputSizeSetter(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input> &me,
234 const C2P<C2StreamMaxPictureSizeTuning::output> &maxSize) {
235 (void)mayBlock;
236 // assume compression ratio of 2
237 me.set().value = c2_max((((maxSize.v.width + 15) / 16)
238 * ((maxSize.v.height + 15) / 16) * 192), kMinInputBufferSize);
239 return C2R::Ok();
240 }
241
ProfileLevelSetter(bool mayBlock,C2P<C2StreamProfileLevelInfo::input> & me,const C2P<C2StreamPictureSizeInfo::output> & size)242 static C2R ProfileLevelSetter(bool mayBlock, C2P<C2StreamProfileLevelInfo::input> &me,
243 const C2P<C2StreamPictureSizeInfo::output> &size) {
244 (void)mayBlock;
245 (void)size;
246 (void)me; // TODO: validate
247 return C2R::Ok();
248 }
249
DefaultColorAspectsSetter(bool mayBlock,C2P<C2StreamColorAspectsTuning::output> & me)250 static C2R DefaultColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsTuning::output> &me) {
251 (void)mayBlock;
252 if (me.v.range > C2Color::RANGE_OTHER) {
253 me.set().range = C2Color::RANGE_OTHER;
254 }
255 if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
256 me.set().primaries = C2Color::PRIMARIES_OTHER;
257 }
258 if (me.v.transfer > C2Color::TRANSFER_OTHER) {
259 me.set().transfer = C2Color::TRANSFER_OTHER;
260 }
261 if (me.v.matrix > C2Color::MATRIX_OTHER) {
262 me.set().matrix = C2Color::MATRIX_OTHER;
263 }
264 return C2R::Ok();
265 }
266
CodedColorAspectsSetter(bool mayBlock,C2P<C2StreamColorAspectsInfo::input> & me)267 static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input> &me) {
268 (void)mayBlock;
269 if (me.v.range > C2Color::RANGE_OTHER) {
270 me.set().range = C2Color::RANGE_OTHER;
271 }
272 if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
273 me.set().primaries = C2Color::PRIMARIES_OTHER;
274 }
275 if (me.v.transfer > C2Color::TRANSFER_OTHER) {
276 me.set().transfer = C2Color::TRANSFER_OTHER;
277 }
278 if (me.v.matrix > C2Color::MATRIX_OTHER) {
279 me.set().matrix = C2Color::MATRIX_OTHER;
280 }
281 return C2R::Ok();
282 }
283
ColorAspectsSetter(bool mayBlock,C2P<C2StreamColorAspectsInfo::output> & me,const C2P<C2StreamColorAspectsTuning::output> & def,const C2P<C2StreamColorAspectsInfo::input> & coded)284 static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output> &me,
285 const C2P<C2StreamColorAspectsTuning::output> &def,
286 const C2P<C2StreamColorAspectsInfo::input> &coded) {
287 (void)mayBlock;
288 // take default values for all unspecified fields, and coded values for specified ones
289 me.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range;
290 me.set().primaries = coded.v.primaries == PRIMARIES_UNSPECIFIED
291 ? def.v.primaries : coded.v.primaries;
292 me.set().transfer = coded.v.transfer == TRANSFER_UNSPECIFIED
293 ? def.v.transfer : coded.v.transfer;
294 me.set().matrix = coded.v.matrix == MATRIX_UNSPECIFIED ? def.v.matrix : coded.v.matrix;
295 return C2R::Ok();
296 }
297
getColorAspects_l()298 std::shared_ptr<C2StreamColorAspectsInfo::output> getColorAspects_l() {
299 return mColorAspects;
300 }
301
302 private:
303 std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel;
304 std::shared_ptr<C2StreamPictureSizeInfo::output> mSize;
305 std::shared_ptr<C2StreamMaxPictureSizeTuning::output> mMaxSize;
306 std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mMaxInputSize;
307 std::shared_ptr<C2StreamColorInfo::output> mColorInfo;
308 std::shared_ptr<C2StreamColorAspectsInfo::input> mCodedColorAspects;
309 std::shared_ptr<C2StreamColorAspectsTuning::output> mDefaultColorAspects;
310 std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;
311 std::shared_ptr<C2StreamPixelFormatInfo::output> mPixelFormat;
312 };
313
getCpuCoreCount()314 static size_t getCpuCoreCount() {
315 long cpuCoreCount = 1;
316 #if defined(_SC_NPROCESSORS_ONLN)
317 cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN);
318 #else
319 // _SC_NPROC_ONLN must be defined...
320 cpuCoreCount = sysconf(_SC_NPROC_ONLN);
321 #endif
322 CHECK(cpuCoreCount >= 1);
323 ALOGV("Number of CPU cores: %ld", cpuCoreCount);
324 return (size_t)cpuCoreCount;
325 }
326
ivd_aligned_malloc(void * ctxt,WORD32 alignment,WORD32 size)327 static void *ivd_aligned_malloc(void *ctxt, WORD32 alignment, WORD32 size) {
328 (void) ctxt;
329 return memalign(alignment, size);
330 }
331
ivd_aligned_free(void * ctxt,void * mem)332 static void ivd_aligned_free(void *ctxt, void *mem) {
333 (void) ctxt;
334 free(mem);
335 }
336
C2SoftAvcDec(const char * name,c2_node_id_t id,const std::shared_ptr<IntfImpl> & intfImpl)337 C2SoftAvcDec::C2SoftAvcDec(
338 const char *name,
339 c2_node_id_t id,
340 const std::shared_ptr<IntfImpl> &intfImpl)
341 : SimpleC2Component(std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)),
342 mIntf(intfImpl),
343 mDecHandle(nullptr),
344 mOutBufferFlush(nullptr),
345 mIvColorFormat(IV_YUV_420P),
346 mOutputDelay(kDefaultOutputDelay),
347 mWidth(320),
348 mHeight(240),
349 mHeaderDecoded(false),
350 mOutIndex(0u) {
351 GENERATE_FILE_NAMES();
352 CREATE_DUMP_FILE(mInFile);
353 }
C2SoftAvcDec(const char * name,c2_node_id_t id,const std::shared_ptr<C2ReflectorHelper> & helper)354 C2SoftAvcDec::C2SoftAvcDec(
355 const char *name,
356 c2_node_id_t id,
357 const std::shared_ptr<C2ReflectorHelper> &helper)
358 : C2SoftAvcDec(name, id, std::make_shared<IntfImpl>(helper)) {
359 }
360
~C2SoftAvcDec()361 C2SoftAvcDec::~C2SoftAvcDec() {
362 onRelease();
363 }
364
onInit()365 c2_status_t C2SoftAvcDec::onInit() {
366 status_t err = initDecoder();
367 return err == OK ? C2_OK : C2_CORRUPTED;
368 }
369
onStop()370 c2_status_t C2SoftAvcDec::onStop() {
371 if (OK != resetDecoder()) return C2_CORRUPTED;
372 resetPlugin();
373 return C2_OK;
374 }
375
onReset()376 void C2SoftAvcDec::onReset() {
377 (void) onStop();
378 }
379
onRelease()380 void C2SoftAvcDec::onRelease() {
381 (void) deleteDecoder();
382 if (mOutBufferFlush) {
383 ivd_aligned_free(nullptr, mOutBufferFlush);
384 mOutBufferFlush = nullptr;
385 }
386 if (mOutBlock) {
387 mOutBlock.reset();
388 }
389 }
390
onFlush_sm()391 c2_status_t C2SoftAvcDec::onFlush_sm() {
392 if (OK != setFlushMode()) return C2_CORRUPTED;
393
394 uint32_t bufferSize = mStride * mHeight * 3 / 2;
395 mOutBufferFlush = (uint8_t *)ivd_aligned_malloc(nullptr, 128, bufferSize);
396 if (!mOutBufferFlush) {
397 ALOGE("could not allocate tmp output buffer (for flush) of size %u ", bufferSize);
398 return C2_NO_MEMORY;
399 }
400
401 while (true) {
402 ih264d_video_decode_ip_t s_h264d_decode_ip = {};
403 ih264d_video_decode_op_t s_h264d_decode_op = {};
404 ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
405 ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;
406
407 setDecodeArgs(ps_decode_ip, ps_decode_op, nullptr, nullptr, 0, 0, 0);
408 (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);
409 if (0 == ps_decode_op->u4_output_present) {
410 resetPlugin();
411 break;
412 }
413 }
414
415 if (mOutBufferFlush) {
416 ivd_aligned_free(nullptr, mOutBufferFlush);
417 mOutBufferFlush = nullptr;
418 }
419
420 return C2_OK;
421 }
422
createDecoder()423 status_t C2SoftAvcDec::createDecoder() {
424 ivdext_create_ip_t s_create_ip = {};
425 ivdext_create_op_t s_create_op = {};
426
427 s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ivdext_create_ip_t);
428 s_create_ip.u4_keep_threads_active = KEEP_THREADS_ACTIVE;
429 s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
430 s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
431 s_create_ip.s_ivd_create_ip_t.e_output_format = mIvColorFormat;
432 s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
433 s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
434 s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = nullptr;
435 s_create_op.s_ivd_create_op_t.u4_size = sizeof(ivdext_create_op_t);
436 IV_API_CALL_STATUS_T status = ivdec_api_function(nullptr,
437 &s_create_ip,
438 &s_create_op);
439 if (status != IV_SUCCESS) {
440 ALOGE("error in %s: 0x%x", __func__,
441 s_create_op.s_ivd_create_op_t.u4_error_code);
442 return UNKNOWN_ERROR;
443 }
444 mDecHandle = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
445 mDecHandle->pv_fxns = (void *)ivdec_api_function;
446 mDecHandle->u4_size = sizeof(iv_obj_t);
447
448 return OK;
449 }
450
setNumCores()451 status_t C2SoftAvcDec::setNumCores() {
452 ivdext_ctl_set_num_cores_ip_t s_set_num_cores_ip = {};
453 ivdext_ctl_set_num_cores_op_t s_set_num_cores_op = {};
454
455 s_set_num_cores_ip.u4_size = sizeof(ivdext_ctl_set_num_cores_ip_t);
456 s_set_num_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
457 s_set_num_cores_ip.e_sub_cmd = IVDEXT_CMD_CTL_SET_NUM_CORES;
458 s_set_num_cores_ip.u4_num_cores = mNumCores;
459 s_set_num_cores_op.u4_size = sizeof(ivdext_ctl_set_num_cores_op_t);
460 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
461 &s_set_num_cores_ip,
462 &s_set_num_cores_op);
463 if (IV_SUCCESS != status) {
464 ALOGD("error in %s: 0x%x", __func__, s_set_num_cores_op.u4_error_code);
465 return UNKNOWN_ERROR;
466 }
467
468 return OK;
469 }
470
setParams(size_t stride,IVD_VIDEO_DECODE_MODE_T dec_mode)471 status_t C2SoftAvcDec::setParams(size_t stride, IVD_VIDEO_DECODE_MODE_T dec_mode) {
472 ih264d_ctl_set_config_ip_t s_h264d_set_dyn_params_ip = {};
473 ih264d_ctl_set_config_op_t s_h264d_set_dyn_params_op = {};
474 ivd_ctl_set_config_ip_t *ps_set_dyn_params_ip =
475 &s_h264d_set_dyn_params_ip.s_ivd_ctl_set_config_ip_t;
476 ivd_ctl_set_config_op_t *ps_set_dyn_params_op =
477 &s_h264d_set_dyn_params_op.s_ivd_ctl_set_config_op_t;
478
479 ps_set_dyn_params_ip->u4_size = sizeof(ih264d_ctl_set_config_ip_t);
480 ps_set_dyn_params_ip->e_cmd = IVD_CMD_VIDEO_CTL;
481 ps_set_dyn_params_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
482 ps_set_dyn_params_ip->u4_disp_wd = (UWORD32) stride;
483 ps_set_dyn_params_ip->e_frm_skip_mode = IVD_SKIP_NONE;
484 ps_set_dyn_params_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
485 ps_set_dyn_params_ip->e_vid_dec_mode = dec_mode;
486 ps_set_dyn_params_op->u4_size = sizeof(ih264d_ctl_set_config_op_t);
487 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
488 &s_h264d_set_dyn_params_ip,
489 &s_h264d_set_dyn_params_op);
490 if (status != IV_SUCCESS) {
491 ALOGE("error in %s: 0x%x", __func__, ps_set_dyn_params_op->u4_error_code);
492 return UNKNOWN_ERROR;
493 }
494
495 return OK;
496 }
497
getVersion()498 void C2SoftAvcDec::getVersion() {
499 ivd_ctl_getversioninfo_ip_t s_get_versioninfo_ip = {};
500 ivd_ctl_getversioninfo_op_t s_get_versioninfo_op = {};
501 UWORD8 au1_buf[512];
502
503 s_get_versioninfo_ip.u4_size = sizeof(ivd_ctl_getversioninfo_ip_t);
504 s_get_versioninfo_ip.e_cmd = IVD_CMD_VIDEO_CTL;
505 s_get_versioninfo_ip.e_sub_cmd = IVD_CMD_CTL_GETVERSION;
506 s_get_versioninfo_ip.pv_version_buffer = au1_buf;
507 s_get_versioninfo_ip.u4_version_buffer_size = sizeof(au1_buf);
508 s_get_versioninfo_op.u4_size = sizeof(ivd_ctl_getversioninfo_op_t);
509 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
510 &s_get_versioninfo_ip,
511 &s_get_versioninfo_op);
512 if (status != IV_SUCCESS) {
513 ALOGD("error in %s: 0x%x", __func__,
514 s_get_versioninfo_op.u4_error_code);
515 } else {
516 ALOGV("ittiam decoder version number: %s",
517 (char *) s_get_versioninfo_ip.pv_version_buffer);
518 }
519 }
520
initDecoder()521 status_t C2SoftAvcDec::initDecoder() {
522 if (OK != createDecoder()) return UNKNOWN_ERROR;
523 mNumCores = MIN(getCpuCoreCount(), MAX_NUM_CORES);
524 mStride = ALIGN128(mWidth);
525 mSignalledError = false;
526 resetPlugin();
527 (void) setNumCores();
528 if (OK != setParams(mStride, IVD_DECODE_FRAME)) return UNKNOWN_ERROR;
529 (void) getVersion();
530
531 return OK;
532 }
533
setDecodeArgs(ivd_video_decode_ip_t * ps_decode_ip,ivd_video_decode_op_t * ps_decode_op,C2ReadView * inBuffer,C2GraphicView * outBuffer,size_t inOffset,size_t inSize,uint32_t tsMarker)534 bool C2SoftAvcDec::setDecodeArgs(ivd_video_decode_ip_t *ps_decode_ip,
535 ivd_video_decode_op_t *ps_decode_op,
536 C2ReadView *inBuffer,
537 C2GraphicView *outBuffer,
538 size_t inOffset,
539 size_t inSize,
540 uint32_t tsMarker) {
541 uint32_t displayStride = mStride;
542 if (outBuffer) {
543 C2PlanarLayout layout;
544 layout = outBuffer->layout();
545 displayStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
546 }
547 uint32_t displayHeight = mHeight;
548 size_t lumaSize = displayStride * displayHeight;
549 size_t chromaSize = lumaSize >> 2;
550
551 if (mStride != displayStride) {
552 mStride = displayStride;
553 if (OK != setParams(mStride, IVD_DECODE_FRAME)) return false;
554 }
555
556 ps_decode_ip->u4_size = sizeof(ih264d_video_decode_ip_t);
557 ps_decode_ip->e_cmd = IVD_CMD_VIDEO_DECODE;
558 if (inBuffer) {
559 ps_decode_ip->u4_ts = tsMarker;
560 ps_decode_ip->pv_stream_buffer = const_cast<uint8_t *>(inBuffer->data() + inOffset);
561 ps_decode_ip->u4_num_Bytes = inSize;
562 } else {
563 ps_decode_ip->u4_ts = 0;
564 ps_decode_ip->pv_stream_buffer = nullptr;
565 ps_decode_ip->u4_num_Bytes = 0;
566 }
567 ps_decode_ip->s_out_buffer.u4_min_out_buf_size[0] = lumaSize;
568 ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize;
569 ps_decode_ip->s_out_buffer.u4_min_out_buf_size[2] = chromaSize;
570 if (outBuffer) {
571 if (outBuffer->height() < displayHeight) {
572 ALOGE("Output buffer too small: provided (%dx%d) required (%ux%u)",
573 outBuffer->width(), outBuffer->height(), displayStride, displayHeight);
574 return false;
575 }
576 ps_decode_ip->s_out_buffer.pu1_bufs[0] = outBuffer->data()[C2PlanarLayout::PLANE_Y];
577 ps_decode_ip->s_out_buffer.pu1_bufs[1] = outBuffer->data()[C2PlanarLayout::PLANE_U];
578 ps_decode_ip->s_out_buffer.pu1_bufs[2] = outBuffer->data()[C2PlanarLayout::PLANE_V];
579 } else {
580 ps_decode_ip->s_out_buffer.pu1_bufs[0] = mOutBufferFlush;
581 ps_decode_ip->s_out_buffer.pu1_bufs[1] = mOutBufferFlush + lumaSize;
582 ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferFlush + lumaSize + chromaSize;
583 }
584 ps_decode_ip->s_out_buffer.u4_num_bufs = 3;
585 ps_decode_op->u4_size = sizeof(ih264d_video_decode_op_t);
586
587 return true;
588 }
589
getVuiParams()590 bool C2SoftAvcDec::getVuiParams() {
591 ivdext_ctl_get_vui_params_ip_t s_get_vui_params_ip = {};
592 ivdext_ctl_get_vui_params_op_t s_get_vui_params_op = {};
593
594 s_get_vui_params_ip.u4_size = sizeof(ivdext_ctl_get_vui_params_ip_t);
595 s_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
596 s_get_vui_params_ip.e_sub_cmd =
597 (IVD_CONTROL_API_COMMAND_TYPE_T) IH264D_CMD_CTL_GET_VUI_PARAMS;
598 s_get_vui_params_op.u4_size = sizeof(ivdext_ctl_get_vui_params_op_t);
599 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
600 &s_get_vui_params_ip,
601 &s_get_vui_params_op);
602 if (status != IV_SUCCESS) {
603 ALOGD("error in %s: 0x%x", __func__, s_get_vui_params_op.u4_error_code);
604 return false;
605 }
606
607 VuiColorAspects vuiColorAspects;
608 vuiColorAspects.primaries = s_get_vui_params_op.u1_colour_primaries;
609 vuiColorAspects.transfer = s_get_vui_params_op.u1_tfr_chars;
610 vuiColorAspects.coeffs = s_get_vui_params_op.u1_matrix_coeffs;
611 vuiColorAspects.fullRange = s_get_vui_params_op.u1_video_full_range_flag;
612
613 // convert vui aspects to C2 values if changed
614 if (!(vuiColorAspects == mBitstreamColorAspects)) {
615 mBitstreamColorAspects = vuiColorAspects;
616 ColorAspects sfAspects;
617 C2StreamColorAspectsInfo::input codedAspects = { 0u };
618 ColorUtils::convertIsoColorAspectsToCodecAspects(
619 vuiColorAspects.primaries, vuiColorAspects.transfer, vuiColorAspects.coeffs,
620 vuiColorAspects.fullRange, sfAspects);
621 if (!C2Mapper::map(sfAspects.mPrimaries, &codedAspects.primaries)) {
622 codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED;
623 }
624 if (!C2Mapper::map(sfAspects.mRange, &codedAspects.range)) {
625 codedAspects.range = C2Color::RANGE_UNSPECIFIED;
626 }
627 if (!C2Mapper::map(sfAspects.mMatrixCoeffs, &codedAspects.matrix)) {
628 codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED;
629 }
630 if (!C2Mapper::map(sfAspects.mTransfer, &codedAspects.transfer)) {
631 codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED;
632 }
633 std::vector<std::unique_ptr<C2SettingResult>> failures;
634 (void)mIntf->config({&codedAspects}, C2_MAY_BLOCK, &failures);
635 }
636 return true;
637 }
638
setFlushMode()639 status_t C2SoftAvcDec::setFlushMode() {
640 ivd_ctl_flush_ip_t s_set_flush_ip = {};
641 ivd_ctl_flush_op_t s_set_flush_op = {};
642
643 s_set_flush_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
644 s_set_flush_ip.e_cmd = IVD_CMD_VIDEO_CTL;
645 s_set_flush_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
646 s_set_flush_op.u4_size = sizeof(ivd_ctl_flush_op_t);
647 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
648 &s_set_flush_ip,
649 &s_set_flush_op);
650 if (status != IV_SUCCESS) {
651 ALOGE("error in %s: 0x%x", __func__, s_set_flush_op.u4_error_code);
652 return UNKNOWN_ERROR;
653 }
654
655 return OK;
656 }
657
resetDecoder()658 status_t C2SoftAvcDec::resetDecoder() {
659 ivd_ctl_reset_ip_t s_reset_ip = {};
660 ivd_ctl_reset_op_t s_reset_op = {};
661
662 s_reset_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);
663 s_reset_ip.e_cmd = IVD_CMD_VIDEO_CTL;
664 s_reset_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
665 s_reset_op.u4_size = sizeof(ivd_ctl_reset_op_t);
666 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
667 &s_reset_ip,
668 &s_reset_op);
669 if (IV_SUCCESS != status) {
670 ALOGE("error in %s: 0x%x", __func__, s_reset_op.u4_error_code);
671 return UNKNOWN_ERROR;
672 }
673 mStride = 0;
674 (void) setNumCores();
675 mSignalledError = false;
676 mHeaderDecoded = false;
677
678 return OK;
679 }
680
resetPlugin()681 void C2SoftAvcDec::resetPlugin() {
682 mSignalledOutputEos = false;
683 mTimeStart = mTimeEnd = systemTime();
684 if (mOutBlock) {
685 mOutBlock.reset();
686 }
687 }
688
deleteDecoder()689 status_t C2SoftAvcDec::deleteDecoder() {
690 if (mDecHandle) {
691 ivdext_delete_ip_t s_delete_ip = {};
692 ivdext_delete_op_t s_delete_op = {};
693
694 s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ivdext_delete_ip_t);
695 s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
696 s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ivdext_delete_op_t);
697 IV_API_CALL_STATUS_T status = ivdec_api_function(mDecHandle,
698 &s_delete_ip,
699 &s_delete_op);
700 if (status != IV_SUCCESS) {
701 ALOGE("error in %s: 0x%x", __func__,
702 s_delete_op.s_ivd_delete_op_t.u4_error_code);
703 return UNKNOWN_ERROR;
704 }
705 mDecHandle = nullptr;
706 }
707
708 return OK;
709 }
710
fillEmptyWork(const std::unique_ptr<C2Work> & work)711 static void fillEmptyWork(const std::unique_ptr<C2Work> &work) {
712 uint32_t flags = 0;
713 if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
714 flags |= C2FrameData::FLAG_END_OF_STREAM;
715 ALOGV("signalling eos");
716 }
717 work->worklets.front()->output.flags = (C2FrameData::flags_t)flags;
718 work->worklets.front()->output.buffers.clear();
719 work->worklets.front()->output.ordinal = work->input.ordinal;
720 work->workletsProcessed = 1u;
721 }
722
finishWork(uint64_t index,const std::unique_ptr<C2Work> & work)723 void C2SoftAvcDec::finishWork(uint64_t index, const std::unique_ptr<C2Work> &work) {
724 std::shared_ptr<C2Buffer> buffer = createGraphicBuffer(std::move(mOutBlock),
725 C2Rect(mWidth, mHeight));
726 mOutBlock = nullptr;
727 {
728 IntfImpl::Lock lock = mIntf->lock();
729 buffer->setInfo(mIntf->getColorAspects_l());
730 }
731
732 class FillWork {
733 public:
734 FillWork(uint32_t flags, C2WorkOrdinalStruct ordinal,
735 const std::shared_ptr<C2Buffer>& buffer)
736 : mFlags(flags), mOrdinal(ordinal), mBuffer(buffer) {}
737 ~FillWork() = default;
738
739 void operator()(const std::unique_ptr<C2Work>& work) {
740 work->worklets.front()->output.flags = (C2FrameData::flags_t)mFlags;
741 work->worklets.front()->output.buffers.clear();
742 work->worklets.front()->output.ordinal = mOrdinal;
743 work->workletsProcessed = 1u;
744 work->result = C2_OK;
745 if (mBuffer) {
746 work->worklets.front()->output.buffers.push_back(mBuffer);
747 }
748 ALOGV("timestamp = %lld, index = %lld, w/%s buffer",
749 mOrdinal.timestamp.peekll(), mOrdinal.frameIndex.peekll(),
750 mBuffer ? "" : "o");
751 }
752
753 private:
754 const uint32_t mFlags;
755 const C2WorkOrdinalStruct mOrdinal;
756 const std::shared_ptr<C2Buffer> mBuffer;
757 };
758
759 auto fillWork = [buffer](const std::unique_ptr<C2Work> &work) {
760 work->worklets.front()->output.flags = (C2FrameData::flags_t)0;
761 work->worklets.front()->output.buffers.clear();
762 work->worklets.front()->output.buffers.push_back(buffer);
763 work->worklets.front()->output.ordinal = work->input.ordinal;
764 work->workletsProcessed = 1u;
765 };
766 if (work && c2_cntr64_t(index) == work->input.ordinal.frameIndex) {
767 bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);
768 // TODO: Check if cloneAndSend can be avoided by tracking number of frames remaining
769 if (eos) {
770 if (buffer) {
771 mOutIndex = index;
772 C2WorkOrdinalStruct outOrdinal = work->input.ordinal;
773 cloneAndSend(
774 mOutIndex, work,
775 FillWork(C2FrameData::FLAG_INCOMPLETE, outOrdinal, buffer));
776 buffer.reset();
777 }
778 } else {
779 fillWork(work);
780 }
781 } else {
782 finish(index, fillWork);
783 }
784 }
785
ensureDecoderState(const std::shared_ptr<C2BlockPool> & pool)786 c2_status_t C2SoftAvcDec::ensureDecoderState(const std::shared_ptr<C2BlockPool> &pool) {
787 if (!mDecHandle) {
788 ALOGE("not supposed to be here, invalid decoder context");
789 return C2_CORRUPTED;
790 }
791 if (mOutBlock &&
792 (mOutBlock->width() != ALIGN128(mWidth) || mOutBlock->height() != mHeight)) {
793 mOutBlock.reset();
794 }
795 if (!mOutBlock) {
796 uint32_t format = HAL_PIXEL_FORMAT_YV12;
797 C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
798 c2_status_t err =
799 pool->fetchGraphicBlock(ALIGN128(mWidth), mHeight, format, usage, &mOutBlock);
800 if (err != C2_OK) {
801 ALOGE("fetchGraphicBlock for Output failed with status %d", err);
802 return err;
803 }
804 ALOGV("provided (%dx%d) required (%dx%d)",
805 mOutBlock->width(), mOutBlock->height(), ALIGN128(mWidth), mHeight);
806 }
807
808 return C2_OK;
809 }
810
811 // TODO: can overall error checking be improved?
812 // TODO: allow configuration of color format and usage for graphic buffers instead
813 // of hard coding them to HAL_PIXEL_FORMAT_YV12
814 // TODO: pass coloraspects information to surface
815 // TODO: test support for dynamic change in resolution
816 // TODO: verify if the decoder sent back all frames
process(const std::unique_ptr<C2Work> & work,const std::shared_ptr<C2BlockPool> & pool)817 void C2SoftAvcDec::process(
818 const std::unique_ptr<C2Work> &work,
819 const std::shared_ptr<C2BlockPool> &pool) {
820 // Initialize output work
821 work->result = C2_OK;
822 work->workletsProcessed = 0u;
823 work->worklets.front()->output.flags = work->input.flags;
824 if (mSignalledError || mSignalledOutputEos) {
825 work->result = C2_BAD_VALUE;
826 return;
827 }
828
829 size_t inOffset = 0u;
830 size_t inSize = 0u;
831 uint32_t workIndex = work->input.ordinal.frameIndex.peeku() & 0xFFFFFFFF;
832 C2ReadView rView = mDummyReadView;
833 if (!work->input.buffers.empty()) {
834 rView = work->input.buffers[0]->data().linearBlocks().front().map().get();
835 inSize = rView.capacity();
836 if (inSize && rView.error()) {
837 ALOGE("read view map failed %d", rView.error());
838 work->result = rView.error();
839 return;
840 }
841 }
842 bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);
843 bool hasPicture = false;
844
845 ALOGV("in buffer attr. size %zu timestamp %d frameindex %d, flags %x",
846 inSize, (int)work->input.ordinal.timestamp.peeku(),
847 (int)work->input.ordinal.frameIndex.peeku(), work->input.flags);
848 size_t inPos = 0;
849 while (inPos < inSize && inSize - inPos >= kMinInputBytes) {
850 if (C2_OK != ensureDecoderState(pool)) {
851 mSignalledError = true;
852 work->workletsProcessed = 1u;
853 work->result = C2_CORRUPTED;
854 return;
855 }
856
857 ih264d_video_decode_ip_t s_h264d_decode_ip = {};
858 ih264d_video_decode_op_t s_h264d_decode_op = {};
859 ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
860 ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;
861 {
862 C2GraphicView wView = mOutBlock->map().get();
863 if (wView.error()) {
864 ALOGE("graphic view map failed %d", wView.error());
865 work->result = wView.error();
866 return;
867 }
868 if (!setDecodeArgs(ps_decode_ip, ps_decode_op, &rView, &wView,
869 inOffset + inPos, inSize - inPos, workIndex)) {
870 mSignalledError = true;
871 work->workletsProcessed = 1u;
872 work->result = C2_CORRUPTED;
873 return;
874 }
875
876 if (false == mHeaderDecoded) {
877 /* Decode header and get dimensions */
878 setParams(mStride, IVD_DECODE_HEADER);
879 }
880
881 mTimeStart = systemTime();
882 nsecs_t delay = mTimeStart - mTimeEnd;
883 (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);
884
885 mTimeEnd = systemTime();
886 nsecs_t decodeTime = mTimeEnd - mTimeStart;
887 ALOGV("decodeTime=%" PRId64 " delay=%" PRId64 " numBytes=%6d", decodeTime, delay,
888 ps_decode_op->u4_num_bytes_consumed);
889 }
890 if (IVD_MEM_ALLOC_FAILED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
891 ALOGE("allocation failure in decoder");
892 mSignalledError = true;
893 work->workletsProcessed = 1u;
894 work->result = C2_CORRUPTED;
895 return;
896 } else if (IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED ==
897 (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
898 ALOGE("unsupported resolution : %dx%d", mWidth, mHeight);
899 mSignalledError = true;
900 work->workletsProcessed = 1u;
901 work->result = C2_CORRUPTED;
902 return;
903 } else if (IVD_RES_CHANGED == (ps_decode_op->u4_error_code & IVD_ERROR_MASK)) {
904 ALOGV("resolution changed");
905 drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work);
906 resetDecoder();
907 resetPlugin();
908 work->workletsProcessed = 0u;
909
910 /* Decode header and get new dimensions */
911 setParams(mStride, IVD_DECODE_HEADER);
912 (void) ivdec_api_function(mDecHandle, ps_decode_ip, ps_decode_op);
913 } else if (IS_IVD_FATAL_ERROR(ps_decode_op->u4_error_code)) {
914 ALOGE("Fatal error in decoder 0x%x", ps_decode_op->u4_error_code);
915 mSignalledError = true;
916 work->workletsProcessed = 1u;
917 work->result = C2_CORRUPTED;
918 return;
919 }
920 if (ps_decode_op->i4_reorder_depth >= 0 && mOutputDelay != ps_decode_op->i4_reorder_depth) {
921 mOutputDelay = ps_decode_op->i4_reorder_depth;
922 ALOGV("New Output delay %d ", mOutputDelay);
923
924 C2PortActualDelayTuning::output outputDelay(mOutputDelay);
925 std::vector<std::unique_ptr<C2SettingResult>> failures;
926 c2_status_t err =
927 mIntf->config({&outputDelay}, C2_MAY_BLOCK, &failures);
928 if (err == OK) {
929 work->worklets.front()->output.configUpdate.push_back(
930 C2Param::Copy(outputDelay));
931 } else {
932 ALOGE("Cannot set output delay");
933 mSignalledError = true;
934 work->workletsProcessed = 1u;
935 work->result = C2_CORRUPTED;
936 return;
937 }
938 }
939 if (0 < ps_decode_op->u4_pic_wd && 0 < ps_decode_op->u4_pic_ht) {
940 if (mHeaderDecoded == false) {
941 mHeaderDecoded = true;
942 mStride = ALIGN128(ps_decode_op->u4_pic_wd);
943 setParams(mStride, IVD_DECODE_FRAME);
944 }
945 if (ps_decode_op->u4_pic_wd != mWidth || ps_decode_op->u4_pic_ht != mHeight) {
946 mWidth = ps_decode_op->u4_pic_wd;
947 mHeight = ps_decode_op->u4_pic_ht;
948 CHECK_EQ(0u, ps_decode_op->u4_output_present);
949
950 C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight);
951 std::vector<std::unique_ptr<C2SettingResult>> failures;
952 c2_status_t err = mIntf->config({&size}, C2_MAY_BLOCK, &failures);
953 if (err == OK) {
954 work->worklets.front()->output.configUpdate.push_back(
955 C2Param::Copy(size));
956 } else {
957 ALOGE("Cannot set width and height");
958 mSignalledError = true;
959 work->workletsProcessed = 1u;
960 work->result = C2_CORRUPTED;
961 return;
962 }
963 continue;
964 }
965 }
966 (void)getVuiParams();
967 hasPicture |= (1 == ps_decode_op->u4_frame_decoded_flag);
968 if (ps_decode_op->u4_output_present) {
969 finishWork(ps_decode_op->u4_ts, work);
970 }
971 inPos += ps_decode_op->u4_num_bytes_consumed;
972 }
973 if (eos) {
974 drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
975 mSignalledOutputEos = true;
976 } else if (!hasPicture) {
977 fillEmptyWork(work);
978 }
979
980 work->input.buffers.clear();
981 }
982
drainInternal(uint32_t drainMode,const std::shared_ptr<C2BlockPool> & pool,const std::unique_ptr<C2Work> & work)983 c2_status_t C2SoftAvcDec::drainInternal(
984 uint32_t drainMode,
985 const std::shared_ptr<C2BlockPool> &pool,
986 const std::unique_ptr<C2Work> &work) {
987 if (drainMode == NO_DRAIN) {
988 ALOGW("drain with NO_DRAIN: no-op");
989 return C2_OK;
990 }
991 if (drainMode == DRAIN_CHAIN) {
992 ALOGW("DRAIN_CHAIN not supported");
993 return C2_OMITTED;
994 }
995
996 if (OK != setFlushMode()) return C2_CORRUPTED;
997 while (true) {
998 if (C2_OK != ensureDecoderState(pool)) {
999 mSignalledError = true;
1000 work->workletsProcessed = 1u;
1001 work->result = C2_CORRUPTED;
1002 return C2_CORRUPTED;
1003 }
1004 C2GraphicView wView = mOutBlock->map().get();
1005 if (wView.error()) {
1006 ALOGE("graphic view map failed %d", wView.error());
1007 return C2_CORRUPTED;
1008 }
1009 ih264d_video_decode_ip_t s_h264d_decode_ip = {};
1010 ih264d_video_decode_op_t s_h264d_decode_op = {};
1011 ivd_video_decode_ip_t *ps_decode_ip = &s_h264d_decode_ip.s_ivd_video_decode_ip_t;
1012 ivd_video_decode_op_t *ps_decode_op = &s_h264d_decode_op.s_ivd_video_decode_op_t;
1013 if (!setDecodeArgs(ps_decode_ip, ps_decode_op, nullptr, &wView, 0, 0, 0)) {
1014 mSignalledError = true;
1015 work->workletsProcessed = 1u;
1016 return C2_CORRUPTED;
1017 }
1018 (void) ivdec_api_function(mDecHandle, &s_h264d_decode_ip, &s_h264d_decode_op);
1019 if (ps_decode_op->u4_output_present) {
1020 finishWork(ps_decode_op->u4_ts, work);
1021 } else {
1022 fillEmptyWork(work);
1023 break;
1024 }
1025 }
1026
1027 return C2_OK;
1028 }
1029
drain(uint32_t drainMode,const std::shared_ptr<C2BlockPool> & pool)1030 c2_status_t C2SoftAvcDec::drain(
1031 uint32_t drainMode,
1032 const std::shared_ptr<C2BlockPool> &pool) {
1033 return drainInternal(drainMode, pool, nullptr);
1034 }
1035
1036 class C2SoftAvcDecFactory : public C2ComponentFactory {
1037 public:
C2SoftAvcDecFactory()1038 C2SoftAvcDecFactory() : mHelper(std::static_pointer_cast<C2ReflectorHelper>(
1039 GetCodec2PlatformComponentStore()->getParamReflector())) {
1040 }
1041
createComponent(c2_node_id_t id,std::shared_ptr<C2Component> * const component,std::function<void (C2Component *)> deleter)1042 virtual c2_status_t createComponent(
1043 c2_node_id_t id,
1044 std::shared_ptr<C2Component>* const component,
1045 std::function<void(C2Component*)> deleter) override {
1046 *component = std::shared_ptr<C2Component>(
1047 new C2SoftAvcDec(COMPONENT_NAME,
1048 id,
1049 std::make_shared<C2SoftAvcDec::IntfImpl>(mHelper)),
1050 deleter);
1051 return C2_OK;
1052 }
1053
createInterface(c2_node_id_t id,std::shared_ptr<C2ComponentInterface> * const interface,std::function<void (C2ComponentInterface *)> deleter)1054 virtual c2_status_t createInterface(
1055 c2_node_id_t id,
1056 std::shared_ptr<C2ComponentInterface>* const interface,
1057 std::function<void(C2ComponentInterface*)> deleter) override {
1058 *interface = std::shared_ptr<C2ComponentInterface>(
1059 new SimpleInterface<C2SoftAvcDec::IntfImpl>(
1060 COMPONENT_NAME, id, std::make_shared<C2SoftAvcDec::IntfImpl>(mHelper)),
1061 deleter);
1062 return C2_OK;
1063 }
1064
1065 virtual ~C2SoftAvcDecFactory() override = default;
1066
1067 private:
1068 std::shared_ptr<C2ReflectorHelper> mHelper;
1069 };
1070
1071 } // namespace android
1072
1073 __attribute__((cfi_canonical_jump_table))
CreateCodec2Factory()1074 extern "C" ::C2ComponentFactory* CreateCodec2Factory() {
1075 ALOGV("in %s", __func__);
1076 return new ::android::C2SoftAvcDecFactory();
1077 }
1078
1079 __attribute__((cfi_canonical_jump_table))
DestroyCodec2Factory(::C2ComponentFactory * factory)1080 extern "C" void DestroyCodec2Factory(::C2ComponentFactory* factory) {
1081 ALOGV("in %s", __func__);
1082 delete factory;
1083 }
1084