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