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