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