• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "component_common.h"
17 #include <hdf_log.h>
18 #include <hdf_base.h>
19 #include "codec_omx_ext.h"
20 
21 namespace OHOS {
22 namespace Codec {
23 namespace Common {
ConvertAudioCodingTypeToMimeType(OMX_AUDIO_CODINGTYPE codingType)24 static AvCodecMime ConvertAudioCodingTypeToMimeType(OMX_AUDIO_CODINGTYPE codingType)
25 {
26     AvCodecMime codecMime = MEDIA_MIMETYPE_INVALID;
27     switch (codingType) {
28         case OMX_AUDIO_CodingPCM:
29             codecMime = MEDIA_MIMETYPE_AUDIO_PCM;
30             break;
31         case OMX_AUDIO_CodingG711:
32             codecMime = MEDIA_MIMETYPE_AUDIO_G711A;
33             break;
34         case OMX_AUDIO_CodingG726:
35             codecMime = MEDIA_MIMETYPE_AUDIO_G726;
36             break;
37         case OMX_AUDIO_CodingAAC:
38             codecMime = MEDIA_MIMETYPE_AUDIO_AAC;
39             break;
40         case OMX_AUDIO_CodingMP3:
41             codecMime = MEDIA_MIMETYPE_AUDIO_MP3;
42             break;
43 
44         default:
45             HDF_LOGW("%{public}s warn, unsupport codingType[%{public}d]", __func__, codingType);
46             break;
47     }
48 
49     return codecMime;
50 }
51 
ConvertVideoCodingTypeToMimeType(int32_t codingType)52 static AvCodecMime ConvertVideoCodingTypeToMimeType(int32_t codingType)
53 {
54     AvCodecMime codecMime = MEDIA_MIMETYPE_INVALID;
55     switch (codingType) {
56         case OMX_VIDEO_CodingAVC:
57             codecMime = MEDIA_MIMETYPE_VIDEO_AVC;
58             break;
59         case CODEC_OMX_VIDEO_CodingHEVC:
60             codecMime = MEDIA_MIMETYPE_VIDEO_HEVC;
61             break;
62         case OMX_VIDEO_CodingMPEG4:
63             codecMime = MEDIA_MIMETYPE_VIDEO_MPEG4;
64             break;
65         default:
66             HDF_LOGW("%{public}s warn, unsupport codingType[%{public}d]", __func__, codingType);
67             break;
68     }
69 
70     return codecMime;
71 }
72 
ConvertImageCodingTypeToMimeType(OMX_IMAGE_CODINGTYPE codingType)73 static AvCodecMime ConvertImageCodingTypeToMimeType(OMX_IMAGE_CODINGTYPE codingType)
74 {
75     AvCodecMime codecMime = MEDIA_MIMETYPE_INVALID;
76     if (codingType == OMX_IMAGE_CodingJPEG) {
77         codecMime = MEDIA_MIMETYPE_IMAGE_JPEG;
78     } else {
79         HDF_LOGW("%{public}s warn, unsupport codingType[%{public}d]", __func__, codingType);
80     }
81     return codecMime;
82 }
83 
ConvertMimeTypeToCodingType(AvCodecMime mimeType)84 static int32_t ConvertMimeTypeToCodingType(AvCodecMime mimeType)
85 {
86     int32_t codingType = 0;
87     switch (mimeType) {
88         case MEDIA_MIMETYPE_IMAGE_JPEG:
89             codingType = OMX_IMAGE_CodingJPEG;
90             break;
91         case MEDIA_MIMETYPE_VIDEO_AVC:
92             codingType = OMX_VIDEO_CodingAVC;
93             break;
94         case MEDIA_MIMETYPE_VIDEO_HEVC:
95             codingType = CODEC_OMX_VIDEO_CodingHEVC;
96             break;
97         case MEDIA_MIMETYPE_VIDEO_MPEG4:
98             codingType = OMX_VIDEO_CodingMPEG4;
99             break;
100         case MEDIA_MIMETYPE_AUDIO_PCM:
101             codingType = OMX_AUDIO_CodingPCM;
102             break;
103         case MEDIA_MIMETYPE_AUDIO_G711A:
104         case MEDIA_MIMETYPE_AUDIO_G711U:
105             codingType = OMX_AUDIO_CodingG711;
106             break;
107         case MEDIA_MIMETYPE_AUDIO_G726:
108             codingType = MEDIA_MIMETYPE_AUDIO_G726;
109             break;
110         case MEDIA_MIMETYPE_AUDIO_AAC:
111             codingType = MEDIA_MIMETYPE_AUDIO_AAC;
112             break;
113         case MEDIA_MIMETYPE_AUDIO_MP3:
114             codingType = MEDIA_MIMETYPE_AUDIO_MP3;
115             break;
116 
117         default:
118             HDF_LOGW("%{public}s warn, unsupport codingType[%{public}d]", __func__, mimeType);
119             break;
120     }
121     return codingType;
122 }
123 
ConvertColorFormatToPixelFormat(OMX_COLOR_FORMATTYPE formatType)124 static PixelFormat ConvertColorFormatToPixelFormat(OMX_COLOR_FORMATTYPE formatType)
125 {
126     PixelFormat pixelFormat = PIXEL_FMT_BUTT;
127     switch (formatType) {
128         case OMX_COLOR_FormatYUV422SemiPlanar:
129             pixelFormat = PIXEL_FMT_YCBCR_422_SP;
130             break;
131         case OMX_COLOR_FormatYUV420SemiPlanar:
132             pixelFormat = PIXEL_FMT_YCBCR_420_SP;
133             break;
134         case OMX_COLOR_FormatYUV422Planar:
135             pixelFormat = PIXEL_FMT_YCBCR_422_P;
136             break;
137         case OMX_COLOR_FormatYUV420Planar:
138             pixelFormat = PIXEL_FMT_YCBCR_420_P;
139             break;
140         case OMX_COLOR_FormatYCbYCr:
141             pixelFormat = PIXEL_FMT_YUYV_422_PKG;
142             break;
143         case OMX_COLOR_FormatCbYCrY:
144             pixelFormat = PIXEL_FMT_UYVY_422_PKG;
145             break;
146         case OMX_COLOR_FormatYCrYCb:
147             pixelFormat = PIXEL_FMT_YVYU_422_PKG;
148             break;
149         case OMX_COLOR_FormatCrYCbY:
150             pixelFormat = PIXEL_FMT_VYUY_422_PKG;
151             break;
152 
153         default:
154             HDF_LOGW("%{public}s: unspupport format[%{public}d]", __func__, formatType);
155             break;
156     }
157 
158     return pixelFormat;
159 }
160 
ConvertPixelFormatToColorFormat(PixelFormat pixelFormat)161 static OMX_COLOR_FORMATTYPE ConvertPixelFormatToColorFormat(PixelFormat pixelFormat)
162 {
163     OMX_COLOR_FORMATTYPE formatType = OMX_COLOR_FormatUnused;
164     switch (pixelFormat) {
165         case PIXEL_FMT_YCBCR_422_SP:
166             formatType = OMX_COLOR_FormatYUV422SemiPlanar;
167             break;
168         case PIXEL_FMT_YCBCR_420_SP:
169             formatType = OMX_COLOR_FormatYUV420SemiPlanar;
170             break;
171         case PIXEL_FMT_YCBCR_422_P:
172             formatType = OMX_COLOR_FormatYUV422Planar;
173             break;
174         case PIXEL_FMT_YCBCR_420_P:
175             formatType = OMX_COLOR_FormatYUV420Planar;
176             break;
177         case PIXEL_FMT_YUYV_422_PKG:
178             formatType = OMX_COLOR_FormatYCbYCr;
179             break;
180         case PIXEL_FMT_UYVY_422_PKG:
181             formatType = OMX_COLOR_FormatCbYCrY;
182             break;
183         case PIXEL_FMT_YVYU_422_PKG:
184             formatType = OMX_COLOR_FormatYCrYCb;
185             break;
186         case PIXEL_FMT_VYUY_422_PKG:
187             formatType = OMX_COLOR_FormatCrYCbY;
188             break;
189 
190         default:
191             HDF_LOGW("%{public}s warn, unsupport pixelFormat[%{public}d]", __func__, pixelFormat);
192             break;
193     }
194     return formatType;
195 }
196 
ConvertChannelModeToSoundMode(OMX_AUDIO_CHANNELMODETYPE modeType)197 static AudioSoundMode ConvertChannelModeToSoundMode(OMX_AUDIO_CHANNELMODETYPE modeType)
198 {
199     AudioSoundMode soundMode = AUD_SOUND_MODE_INVALID;
200     switch (modeType) {
201         case OMX_AUDIO_ChannelModeStereo:
202             soundMode = AUD_SOUND_MODE_STEREO;
203             break;
204         case OMX_AUDIO_ChannelModeMono:
205             soundMode = AUD_SOUND_MODE_MONO;
206             break;
207 
208         default:
209             HDF_LOGW("%{public}s warn, unsupport modeType[%{public}d]", __func__, modeType);
210             break;
211     }
212 
213     return soundMode;
214 }
215 
ConvertSoundModeToChannelMode(AudioSoundMode soundMode)216 static OMX_AUDIO_CHANNELMODETYPE ConvertSoundModeToChannelMode(AudioSoundMode soundMode)
217 {
218     OMX_AUDIO_CHANNELMODETYPE modeType = OMX_AUDIO_ChannelModeMax;
219     switch (soundMode) {
220         case AUD_SOUND_MODE_STEREO:
221             modeType = OMX_AUDIO_ChannelModeStereo;
222             break;
223         case AUD_SOUND_MODE_MONO:
224             modeType = OMX_AUDIO_ChannelModeMono;
225             break;
226 
227         default:
228             HDF_LOGW("%{public}s warn, unsupport soundMode[%{public}d]", __func__, soundMode);
229             break;
230     }
231     return modeType;
232 }
233 
ConvertAacProfileToProfile(OMX_AUDIO_AACPROFILETYPE profileType)234 static Profile ConvertAacProfileToProfile(OMX_AUDIO_AACPROFILETYPE profileType)
235 {
236     Profile profile = INVALID_PROFILE;
237     switch (profileType) {
238         case OMX_AUDIO_AACObjectLC:
239             profile = AAC_LC_PROFILE;
240             break;
241         case OMX_AUDIO_AACObjectMain:
242             profile = AAC_MAIN_PROFILE;
243             break;
244         case OMX_AUDIO_AACObjectHE:
245             profile = AAC_HE_V1_PROFILE;
246             break;
247         case OMX_AUDIO_AACObjectHE_PS:
248             profile = AAC_HE_V2_PROFILE;
249             break;
250         case OMX_AUDIO_AACObjectLD:
251             profile = AAC_LD_PROFILE;
252             break;
253 
254         default:
255             HDF_LOGW("%{public}s warn, unsupport profileType[%{public}d]", __func__, profileType);
256             break;
257     }
258 
259     return profile;
260 }
261 
ConvertAvcProfileToProfile(OMX_VIDEO_AVCPROFILETYPE profileType)262 static Profile ConvertAvcProfileToProfile(OMX_VIDEO_AVCPROFILETYPE profileType)
263 {
264     Profile profile = INVALID_PROFILE;
265     switch (profileType) {
266         case OMX_VIDEO_AVCProfileBaseline:
267             profile = AVC_BASELINE_PROFILE;
268             break;
269         case OMX_VIDEO_AVCProfileMain:
270             profile = AVC_MAIN_PROFILE;
271             break;
272         case OMX_VIDEO_AVCProfileHigh:
273             profile = AVC_HIGH_PROFILE;
274             break;
275 
276         default:
277             HDF_LOGW("%{public}s warn, unsupport profileType[%{public}d]", __func__, profileType);
278             break;
279     }
280 
281     return profile;
282 }
283 
ConvertProfileToOmxProfile(Profile profile)284 static int32_t ConvertProfileToOmxProfile(Profile profile)
285 {
286     int32_t profileType = 0;
287     switch (profile) {
288         case AVC_BASELINE_PROFILE:
289             profileType = OMX_VIDEO_AVCProfileBaseline;
290             break;
291         case AVC_MAIN_PROFILE:
292             profileType = OMX_VIDEO_AVCProfileMain;
293             break;
294         case AVC_HIGH_PROFILE:
295             profileType = OMX_VIDEO_AVCProfileHigh;
296             break;
297         case AAC_LC_PROFILE:
298             profileType = OMX_AUDIO_AACObjectLC;
299             break;
300         case AAC_MAIN_PROFILE:
301             profileType = OMX_AUDIO_AACObjectMain;
302             break;
303         case AAC_HE_V1_PROFILE:
304             profileType = OMX_AUDIO_AACObjectHE;
305             break;
306         case AAC_HE_V2_PROFILE:
307             profileType = OMX_AUDIO_AACObjectHE_PS;
308             break;
309         case AAC_LD_PROFILE:
310             profileType = OMX_AUDIO_AACObjectLD;
311             break;
312 
313         default:
314             HDF_LOGW("%{public}s warn, unsupport profileType[%{public}d]", __func__, profile);
315             break;
316     }
317     return profileType;
318 }
319 
ConvertRateTypeToRcMode(OMX_VIDEO_CONTROLRATETYPE rateType)320 static VideoCodecRcMode ConvertRateTypeToRcMode(OMX_VIDEO_CONTROLRATETYPE rateType)
321 {
322     VideoCodecRcMode rcMode = VID_CODEC_RC_CBR;
323     switch (rateType) {
324         case OMX_Video_ControlRateVariable:
325             rcMode = VID_CODEC_RC_VBR;
326             break;
327         case OMX_Video_ControlRateConstant:
328             rcMode = VID_CODEC_RC_CBR;
329             break;
330 
331         default:
332             HDF_LOGW("%{public}s warn, unsupport rateType[%{public}d]", __func__, rateType);
333             break;
334     }
335 
336     return rcMode;
337 }
338 
ConvertRcModeToRateType(VideoCodecRcMode rcMode)339 static OMX_VIDEO_CONTROLRATETYPE ConvertRcModeToRateType(VideoCodecRcMode rcMode)
340 {
341     OMX_VIDEO_CONTROLRATETYPE rateType = OMX_Video_ControlRateMax;
342     switch (rcMode) {
343         case VID_CODEC_RC_VBR:
344             rateType = OMX_Video_ControlRateVariable;
345             break;
346         case VID_CODEC_RC_CBR:
347             rateType = OMX_Video_ControlRateConstant;
348             break;
349 
350         default:
351             HDF_LOGW("%{public}s warn, unsupport rcMode[%{public}d]", __func__, rcMode);
352             break;
353     }
354     return rateType;
355 }
356 
SplitParamGettingPortDefinitionVideo(int8_t * paramIn,Param * paramOut,int32_t & paramCnt)357 static void SplitParamGettingPortDefinitionVideo(int8_t *paramIn, Param *paramOut, int32_t &paramCnt)
358 {
359     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramIn);
360     int32_t index = 0;
361 
362     if (param->nPortIndex == INPUT_PORTINDEX) {
363         paramOut[index++].key = KEY_INPUT_BUFFER_COUNT;
364     } else if (param->nPortIndex == OUTPUT_PORTINDEX) {
365         paramOut[index++].key = KEY_OUTPUT_BUFFER_COUNT;
366     }
367     paramOut[index++].key = KEY_BUFFERSIZE;
368     paramOut[index++].key = KEY_MIMETYPE;
369     paramOut[index++].key = KEY_VIDEO_WIDTH;
370     paramOut[index++].key = KEY_VIDEO_HEIGHT;
371     paramOut[index++].key = KEY_VIDEO_STRIDE;
372     paramOut[index++].key = KEY_BITRATE;
373     paramOut[index++].key = KEY_VIDEO_FRAME_RATE;
374     paramOut[index++].key = KEY_PIXEL_FORMAT;
375     paramCnt = index;
376     for (index = 0; index < paramCnt; index++) {
377         paramOut[index].val = nullptr;
378         paramOut[index].size = 0;
379     }
380 }
381 
SplitParamSettingPortDefinitionVideo(int8_t * paramIn,Param * paramOut,int32_t & paramCnt)382 static void SplitParamSettingPortDefinitionVideo(int8_t *paramIn, Param *paramOut, int32_t &paramCnt)
383 {
384     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramIn);
385     int32_t index = 0;
386 
387     paramOut[index].key = KEY_BUFFERSIZE;
388     paramOut[index].val = (void *)&(param->nBufferSize);
389     paramOut[index].size = sizeof(param->nBufferSize);
390     index++;
391     paramOut[index].key = KEY_MIMETYPE;
392     param->format.video.eCompressionFormat =
393                 (OMX_VIDEO_CODINGTYPE)ConvertVideoCodingTypeToMimeType(param->format.video.eCompressionFormat);
394     paramOut[index].val = (void *)&(param->format.video.eCompressionFormat);
395     paramOut[index].size = sizeof(param->format.video.eCompressionFormat);
396     index++;
397     paramOut[index].key = KEY_VIDEO_WIDTH;
398     paramOut[index].val = (void *)&(param->format.video.nFrameWidth);
399     paramOut[index].size = sizeof(param->format.video.nFrameWidth);
400     index++;
401     paramOut[index].key = KEY_VIDEO_HEIGHT;
402     paramOut[index].val = (void *)&(param->format.video.nFrameHeight);
403     paramOut[index].size = sizeof(param->format.video.nFrameHeight);
404     index++;
405     paramOut[index].key = KEY_VIDEO_STRIDE;
406     paramOut[index].val = (void *)&(param->format.video.nStride);
407     paramOut[index].size = sizeof(param->format.video.nStride);
408     index++;
409     paramOut[index].key = KEY_BITRATE;
410     paramOut[index].val = (void *)&(param->format.video.nBitrate);
411     paramOut[index].size = sizeof(param->format.video.nBitrate);
412     index++;
413     paramOut[index].key = KEY_VIDEO_FRAME_RATE;
414     paramOut[index].val = (void *)&(param->format.video.xFramerate);
415     paramOut[index].size = sizeof(param->format.video.xFramerate);
416     index++;
417     param->format.video.eColorFormat =
418         static_cast<OMX_COLOR_FORMATTYPE>(ConvertColorFormatToPixelFormat(param->format.video.eColorFormat));
419     if (static_cast<PixelFormat>(param->format.video.eColorFormat) != PIXEL_FMT_BUTT) {
420         paramOut[index].key = KEY_PIXEL_FORMAT;
421         paramOut[index].val = (void *)&(param->format.video.eColorFormat);
422         paramOut[index].size = sizeof(param->format.video.eColorFormat);
423         index++;
424     }
425 
426     paramCnt = index;
427 }
428 
SplitParamPortDefinitionVideo(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)429 static void SplitParamPortDefinitionVideo(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
430 {
431     if (!setMark) {
432         SplitParamGettingPortDefinitionVideo(paramIn, paramOut, paramCnt);
433     } else {
434         SplitParamSettingPortDefinitionVideo(paramIn, paramOut, paramCnt);
435     }
436 }
437 
SplitParamPortDefinitionAudio(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)438 static void SplitParamPortDefinitionAudio(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
439 {
440     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramIn);
441     int32_t index = 0;
442     paramOut[index].key = KEY_BUFFERSIZE;
443     paramOut[index].val = setMark ? (void *)&(param->nBufferSize) : nullptr;
444     paramOut[index].size = setMark ? sizeof(param->nBufferSize) : 0;
445     index++;
446     paramOut[index].key = KEY_MIMETYPE;
447     param->format.audio.eEncoding =
448         static_cast<OMX_AUDIO_CODINGTYPE>(ConvertAudioCodingTypeToMimeType(param->format.audio.eEncoding));
449     paramOut[index].val = setMark ? (void *)&(param->format.audio.eEncoding) : nullptr;
450     paramOut[index].size = setMark ? sizeof(param->format.audio.eEncoding) : 0;
451     index++;
452     paramCnt = index;
453 }
454 
SplitParamPortDefinition(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark,CodecType type)455 static void SplitParamPortDefinition(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark, CodecType type)
456 {
457     if (type == VIDEO_DECODER || type == VIDEO_ENCODER) {
458         SplitParamPortDefinitionVideo(paramIn, paramOut, paramCnt, setMark);
459     } else if (type == AUDIO_DECODER || type == AUDIO_ENCODER) {
460         SplitParamPortDefinitionAudio(paramIn, paramOut, paramCnt, setMark);
461     }
462 }
463 
SplitParamAudioPortFormat(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)464 static void SplitParamAudioPortFormat(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
465 {
466     OMX_AUDIO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PORTFORMATTYPE *>(paramIn);
467     int32_t index = 0;
468     paramOut[index].key = KEY_MIMETYPE;
469     param->eEncoding = (OMX_AUDIO_CODINGTYPE)ConvertAudioCodingTypeToMimeType(param->eEncoding);
470     paramOut[index].val = setMark ? (void *)&(param->eEncoding) : nullptr;
471     paramOut[index].size = setMark ? sizeof(param->eEncoding) : 0;
472     index++;
473 
474     paramCnt = index;
475 }
476 
SplitParamAudioPcm(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)477 static void SplitParamAudioPcm(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
478 {
479     OMX_AUDIO_PARAM_PCMMODETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PCMMODETYPE *>(paramIn);
480     int32_t index = 0;
481     paramOut[index].key = KEY_AUDIO_CHANNEL_COUNT;
482     paramOut[index].val = setMark ? (void *)&(param->nChannels) : nullptr;
483     paramOut[index].size = setMark ? sizeof(param->nChannels) : 0;
484     index++;
485     paramOut[index].key = KEY_AUDIO_POINTS_PER_FRAME;
486     paramOut[index].val = setMark ? (void *)&(param->nBitPerSample) : nullptr;
487     paramOut[index].size = setMark ? sizeof(param->nBitPerSample) : 0;
488     index++;
489     paramOut[index].key = KEY_AUDIO_SAMPLE_RATE;
490     paramOut[index].val = setMark ? (void *)&(param->nSamplingRate) : nullptr;
491     paramOut[index].size = setMark ? sizeof(param->nSamplingRate) : 0;
492     index++;
493 
494     paramCnt = index;
495 }
496 
SplitParamAudioAac(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)497 static void SplitParamAudioAac(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
498 {
499     OMX_AUDIO_PARAM_AACPROFILETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_AACPROFILETYPE *>(paramIn);
500     int32_t index = 0;
501     paramOut[index].key = KEY_AUDIO_CHANNEL_COUNT;
502     paramOut[index].val = setMark ? (void *)&(param->nChannels) : nullptr;
503     paramOut[index].size = setMark ? sizeof(param->nChannels) : 0;
504     index++;
505     paramOut[index].key = KEY_AUDIO_SAMPLE_RATE;
506     paramOut[index].val = setMark ? (void *)&(param->nSampleRate) : nullptr;
507     paramOut[index].size = setMark ? sizeof(param->nSampleRate) : 0;
508     index++;
509     paramOut[index].key = KEY_BITRATE;
510     paramOut[index].val = setMark ? (void *)&(param->nBitRate) : nullptr;
511     paramOut[index].size = setMark ? sizeof(param->nBitRate) : 0;
512     index++;
513     paramOut[index].key = KEY_AUDIO_PROFILE;
514     param->eAACProfile = (OMX_AUDIO_AACPROFILETYPE)ConvertAacProfileToProfile(param->eAACProfile);
515     paramOut[index].val = setMark ? (void *)&(param->eAACProfile) : nullptr;
516     paramOut[index].size = setMark ? sizeof(param->eAACProfile) : 0;
517     index++;
518     paramOut[index].key = KEY_AUDIO_SOUND_MODE;
519     param->eChannelMode = (OMX_AUDIO_CHANNELMODETYPE)ConvertChannelModeToSoundMode(param->eChannelMode);
520     paramOut[index].val = setMark ? (void *)&(param->eChannelMode) : nullptr;
521     paramOut[index].size = setMark ? sizeof(param->eChannelMode) : 0;
522     index++;
523 
524     paramCnt = index;
525 }
526 
SplitParamAudioMp3(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)527 static void SplitParamAudioMp3(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
528 {
529     OMX_AUDIO_PARAM_MP3TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_MP3TYPE *>(paramIn);
530     int32_t index = 0;
531     paramOut[index].key = KEY_AUDIO_CHANNEL_COUNT;
532     paramOut[index].val = setMark ? (void *)&(param->nChannels) : nullptr;
533     paramOut[index].size = setMark ? sizeof(param->nChannels) : 0;
534     index++;
535     paramOut[index].key = KEY_AUDIO_SAMPLE_RATE;
536     paramOut[index].val = setMark ? (void *)&(param->nSampleRate) : nullptr;
537     paramOut[index].size = setMark ? sizeof(param->nSampleRate) : 0;
538     index++;
539     paramOut[index].key = KEY_BITRATE;
540     paramOut[index].val = setMark ? (void *)&(param->nBitRate) : nullptr;
541     paramOut[index].size = setMark ? sizeof(param->nBitRate) : 0;
542     index++;
543     paramOut[index].key = KEY_AUDIO_SOUND_MODE;
544     param->eChannelMode = (OMX_AUDIO_CHANNELMODETYPE)ConvertChannelModeToSoundMode(param->eChannelMode);
545     paramOut[index].val = setMark ? (void *)&(param->eChannelMode) : nullptr;
546     paramOut[index].size = setMark ? sizeof(param->eChannelMode) : 0;
547     index++;
548 
549     paramCnt = index;
550 }
551 
SplitParamAudioG726(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)552 static void SplitParamAudioG726(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
553 {
554     OMX_AUDIO_PARAM_G726TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_G726TYPE *>(paramIn);
555     int32_t index = 0;
556     paramOut[index].key = KEY_AUDIO_CHANNEL_COUNT;
557     paramOut[index].val = setMark ? (void *)&(param->nChannels) : nullptr;
558     paramOut[index].size = setMark ? sizeof(param->nChannels) : 0;
559     index++;
560 
561     paramCnt = index;
562 }
563 
SplitParamImagePortFormat(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)564 static void SplitParamImagePortFormat(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
565 {
566     OMX_IMAGE_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_PORTFORMATTYPE *>(paramIn);
567     int32_t index = 0;
568     paramOut[index].key = KEY_MIMETYPE;
569     param->eCompressionFormat = (OMX_IMAGE_CODINGTYPE)ConvertImageCodingTypeToMimeType(param->eCompressionFormat);
570     paramOut[index].val = setMark ? (void *)&(param->eCompressionFormat) : nullptr;
571     paramOut[index].size = setMark ? sizeof(param->eCompressionFormat) : 0;
572     index++;
573     param->eColorFormat = static_cast<OMX_COLOR_FORMATTYPE>(ConvertColorFormatToPixelFormat(param->eColorFormat));
574     if (static_cast<PixelFormat>(param->eColorFormat) != PIXEL_FMT_BUTT || !setMark) {
575         paramOut[index].key = KEY_PIXEL_FORMAT;
576         paramOut[index].val = setMark ? (void *)&(param->eColorFormat) : nullptr;
577         paramOut[index].size = setMark ? sizeof(param->eColorFormat) : 0;
578         index++;
579     }
580     paramCnt = index;
581 }
582 
SplitParamQfactor(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)583 static void SplitParamQfactor(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
584 {
585     OMX_IMAGE_PARAM_QFACTORTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_QFACTORTYPE *>(paramIn);
586     int32_t index = 0;
587     paramOut[index].key = KEY_IMAGE_Q_FACTOR;
588     paramOut[index].val = setMark ? (void *)&(param->nQFactor) : nullptr;
589     paramOut[index].size = setMark ? sizeof(param->nQFactor) : 0;
590     index++;
591 
592     paramCnt = index;
593 }
594 
SplitParamVideoPortFormat(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)595 static void SplitParamVideoPortFormat(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
596 {
597     OMX_VIDEO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_PORTFORMATTYPE *>(paramIn);
598     int32_t index = 0;
599     paramOut[index].key = KEY_MIMETYPE;
600     param->eCompressionFormat = (OMX_VIDEO_CODINGTYPE)ConvertVideoCodingTypeToMimeType(param->eCompressionFormat);
601     paramOut[index].val = setMark ? (void *)&(param->eCompressionFormat) : nullptr;
602     paramOut[index].size = setMark ? sizeof(param->eCompressionFormat) : 0;
603     index++;
604     paramOut[index].key = KEY_VIDEO_FRAME_RATE;
605     paramOut[index].val = setMark ? (void *)&(param->xFramerate) : nullptr;
606     paramOut[index].size = setMark ? sizeof(param->xFramerate) : 0;
607     index++;
608     param->eColorFormat = static_cast<OMX_COLOR_FORMATTYPE>(ConvertColorFormatToPixelFormat(param->eColorFormat));
609     if (static_cast<PixelFormat>(param->eColorFormat) != PIXEL_FMT_BUTT || !setMark) {
610         paramOut[index].key = KEY_PIXEL_FORMAT;
611         paramOut[index].val = setMark ? (void *)&(param->eColorFormat) : nullptr;
612         paramOut[index].size = setMark ? sizeof(param->eColorFormat) : 0;
613         index++;
614     }
615 
616     paramCnt = index;
617 }
618 
SplitParamVideoAvc(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)619 static void SplitParamVideoAvc(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
620 {
621     OMX_VIDEO_PARAM_AVCTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_AVCTYPE *>(paramIn);
622     int32_t index = 0;
623     paramOut[index].key = KEY_VIDEO_PROFILE;
624     param->eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(ConvertAvcProfileToProfile(param->eProfile));
625     paramOut[index].val = setMark ? (void *)&(param->eProfile) : nullptr;
626     paramOut[index].size = setMark ? sizeof(param->eProfile) : 0;
627     index++;
628 
629     paramCnt = index;
630 }
631 
SplitParamVideoBitrate(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)632 static void SplitParamVideoBitrate(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
633 {
634     OMX_VIDEO_PARAM_BITRATETYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_BITRATETYPE *>(paramIn);
635     int32_t index = 0;
636     paramOut[index].key = KEY_VIDEO_RC_MODE;
637     param->eControlRate = (OMX_VIDEO_CONTROLRATETYPE)ConvertRateTypeToRcMode(param->eControlRate);
638     paramOut[index].val = setMark ? (void *)&(param->eControlRate) : nullptr;
639     paramOut[index].size = setMark ? sizeof(param->eControlRate) : 0;
640     index++;
641 
642     paramCnt = index;
643 }
644 
SplitParamPassthrough(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)645 static void SplitParamPassthrough(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
646 {
647     PassthroughParam *param = reinterpret_cast<PassthroughParam *>(paramIn);
648     int32_t index = 0;
649     paramOut[index].key = (ParamKey)param->key;
650     paramOut[index].val = param->val;
651     paramOut[index].size = param->size;
652     index++;
653 
654     paramCnt = index;
655 }
656 
SplitParam(int32_t paramIndex,int8_t * paramIn,Param * paramOut,int32_t & paramCnt,CodecType type)657 int32_t SplitParam(int32_t paramIndex, int8_t *paramIn, Param *paramOut, int32_t &paramCnt, CodecType type)
658 {
659     if (paramIn == nullptr || paramOut == nullptr) {
660         HDF_LOGE("%{public}s error, paramIn or paramOut is null", __func__);
661         return HDF_FAILURE;
662     }
663     bool setMark = (paramCnt == 1);
664     switch (paramIndex) {
665         case OMX_IndexParamPortDefinition:
666             SplitParamPortDefinition(paramIn, paramOut, paramCnt, setMark, type);
667             break;
668         case OMX_IndexParamAudioPortFormat:
669             SplitParamAudioPortFormat(paramIn, paramOut, paramCnt, setMark);
670             break;
671         case OMX_IndexParamAudioPcm:
672             SplitParamAudioPcm(paramIn, paramOut, paramCnt, setMark);
673             break;
674         case OMX_IndexParamAudioAac:
675             SplitParamAudioAac(paramIn, paramOut, paramCnt, setMark);
676             break;
677         case OMX_IndexParamAudioMp3:
678             SplitParamAudioMp3(paramIn, paramOut, paramCnt, setMark);
679             break;
680         case OMX_IndexParamAudioG726:
681             SplitParamAudioG726(paramIn, paramOut, paramCnt, setMark);
682             break;
683         case OMX_IndexParamImagePortFormat:
684             SplitParamImagePortFormat(paramIn, paramOut, paramCnt, setMark);
685             break;
686         case OMX_IndexParamQFactor:
687             SplitParamQfactor(paramIn, paramOut, paramCnt, setMark);
688             break;
689         case OMX_IndexParamVideoPortFormat:
690             SplitParamVideoPortFormat(paramIn, paramOut, paramCnt, setMark);
691             break;
692         case OMX_IndexParamVideoAvc:
693             SplitParamVideoAvc(paramIn, paramOut, paramCnt, setMark);
694             break;
695         case OMX_IndexParamVideoBitrate:
696             SplitParamVideoBitrate(paramIn, paramOut, paramCnt, setMark);
697             break;
698         case OMX_IndexParamPassthrough:
699             SplitParamPassthrough(paramIn, paramOut, paramCnt, setMark);
700             break;
701         default:
702             HDF_LOGE("%{public}s error, paramIndex[%{public}d] is not support!", __func__, paramIndex);
703             return HDF_ERR_NOT_SUPPORT;
704     }
705     return HDF_SUCCESS;
706 }
707 
ParseParamPortDefinitionVideo(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)708 static int32_t ParseParamPortDefinitionVideo(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
709 {
710     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramOut);
711     int32_t validCount = 0;
712     for (int32_t i = 0; i < paramCnt; i++) {
713         if (paramIn[i].val == nullptr) {
714             continue;
715         }
716         validCount++;
717         switch (paramIn[i].key) {
718             case KEY_INPUT_BUFFER_COUNT:
719             case KEY_OUTPUT_BUFFER_COUNT:
720                 param->nBufferCountActual = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
721                 break;
722             case KEY_BUFFERSIZE: {
723                 param->nBufferSize = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
724                 param->bEnabled = OMX_TRUE;
725                 break;
726             }
727             case KEY_MIMETYPE: {
728                 int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
729                 param->format.video.eCompressionFormat = (OMX_VIDEO_CODINGTYPE)codingType;
730                 break;
731             }
732             case KEY_VIDEO_WIDTH:
733                 param->format.video.nFrameWidth = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
734                 break;
735             case KEY_VIDEO_HEIGHT:
736                 param->format.video.nFrameHeight = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
737                 break;
738             case KEY_VIDEO_STRIDE:
739                 param->format.video.nStride = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
740                 break;
741             case KEY_BITRATE:
742                 param->format.video.nBitrate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
743                 break;
744             case KEY_VIDEO_FRAME_RATE:
745                 param->format.video.xFramerate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
746                 break;
747             case KEY_PIXEL_FORMAT:
748                 param->format.video.eColorFormat =
749                     ConvertPixelFormatToColorFormat(*(reinterpret_cast<PixelFormat *>(paramIn[i].val)));
750                 break;
751 
752             default: {
753                 validCount--;
754                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
755                 break;
756             }
757         }
758     }
759     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
760 }
761 
ParseParamPortDefinitionAudio(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)762 static int32_t ParseParamPortDefinitionAudio(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
763 {
764     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramOut);
765     int32_t validCount = 0;
766     for (int32_t i = 0; i < paramCnt; i++) {
767         if (paramIn[i].val == nullptr) {
768             continue;
769         }
770         validCount++;
771         switch (paramIn[i].key) {
772             case KEY_BUFFERSIZE: {
773                 param->nBufferSize =
774                          param->nPortIndex == static_cast<OMX_U32>(INPUT_PORTINDEX) ?
775                          static_cast<OMX_U32>(info.inputBufferSize) : static_cast<OMX_U32>(info.outputBufferSize);
776                 param->nBufferCountActual =
777                          param->nPortIndex == static_cast<OMX_U32>(INPUT_PORTINDEX) ?
778                          static_cast<OMX_U32>(info.inputBufferCount) : static_cast<OMX_U32>(info.outputBufferCount);
779                 param->bEnabled = OMX_TRUE;
780                 break;
781             }
782             case KEY_MIMETYPE: {
783                 int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
784                 param->format.audio.eEncoding = static_cast<OMX_AUDIO_CODINGTYPE>(codingType);
785                 break;
786             }
787 
788             default: {
789                 validCount--;
790                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
791                 break;
792             }
793         }
794     }
795     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
796 }
797 
ParseParamPortDefinition(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)798 static int32_t ParseParamPortDefinition(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
799 {
800     int32_t ret = HDF_FAILURE;
801     if (info.type == VIDEO_DECODER || info.type == VIDEO_ENCODER) {
802         ret = ParseParamPortDefinitionVideo(paramIn, paramOut, paramCnt, info);
803     } else if (info.type == AUDIO_DECODER || info.type == AUDIO_ENCODER) {
804         ret = ParseParamPortDefinitionAudio(paramIn, paramOut, paramCnt, info);
805     }
806     return ret;
807 }
808 
ParseParamAudioPortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)809 static int32_t ParseParamAudioPortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
810 {
811     OMX_AUDIO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PORTFORMATTYPE *>(paramOut);
812     int32_t validCount = 0;
813     for (int32_t i = 0; i < paramCnt; i++) {
814         if (paramIn[i].val == nullptr) {
815             continue;
816         }
817         validCount++;
818         if (paramIn[i].key == KEY_MIMETYPE) {
819             int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
820             param->eEncoding = (OMX_AUDIO_CODINGTYPE)codingType;
821         } else {
822             validCount--;
823             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
824         }
825     }
826     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
827 }
828 
ParseParamAudioPcm(Param * paramIn,int8_t * paramOut,int32_t paramCnt)829 static int32_t ParseParamAudioPcm(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
830 {
831     OMX_AUDIO_PARAM_PCMMODETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PCMMODETYPE *>(paramOut);
832     int32_t validCount = 0;
833     for (int32_t i = 0; i < paramCnt; i++) {
834         if (paramIn[i].val == nullptr) {
835             continue;
836         }
837         validCount++;
838         switch (paramIn[i].key) {
839             case KEY_AUDIO_CHANNEL_COUNT:
840                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
841                 break;
842             case KEY_AUDIO_POINTS_PER_FRAME:
843                 param->nBitPerSample = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
844                 break;
845             case KEY_AUDIO_SAMPLE_RATE:
846                 param->nSamplingRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
847                 break;
848 
849             default: {
850                 validCount--;
851                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
852                 break;
853             }
854         }
855     }
856     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
857 }
858 
ParseParamAudioAac(Param * paramIn,int8_t * paramOut,int32_t paramCnt)859 static int32_t ParseParamAudioAac(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
860 {
861     OMX_AUDIO_PARAM_AACPROFILETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_AACPROFILETYPE *>(paramOut);
862     int32_t validCount = 0;
863     for (int32_t i = 0; i < paramCnt; i++) {
864         if (paramIn[i].val == nullptr) {
865             continue;
866         }
867         validCount++;
868         switch (paramIn[i].key) {
869             case KEY_AUDIO_CHANNEL_COUNT:
870                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
871                 break;
872             case KEY_AUDIO_SAMPLE_RATE:
873                 param->nSampleRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
874                 break;
875             case KEY_BITRATE:
876                 param->nBitRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
877                 break;
878             case KEY_AUDIO_PROFILE:
879                 param->eAACProfile = (OMX_AUDIO_AACPROFILETYPE)
880                     ConvertProfileToOmxProfile(*(reinterpret_cast<Profile *>(paramIn[i].val)));
881                 break;
882             case KEY_AUDIO_SOUND_MODE:
883                 param->eChannelMode =
884                     ConvertSoundModeToChannelMode(*(reinterpret_cast<AudioSoundMode *>(paramIn[i].val)));
885                 break;
886 
887             default: {
888                 validCount--;
889                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
890                 break;
891             }
892         }
893     }
894     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
895 }
896 
ParseParamAudioMp3(Param * paramIn,int8_t * paramOut,int32_t paramCnt)897 static int32_t ParseParamAudioMp3(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
898 {
899     OMX_AUDIO_PARAM_MP3TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_MP3TYPE *>(paramOut);
900     int32_t validCount = 0;
901     for (int32_t i = 0; i < paramCnt; i++) {
902         if (paramIn[i].val == nullptr) {
903             continue;
904         }
905         validCount++;
906         switch (paramIn[i].key) {
907             case KEY_AUDIO_CHANNEL_COUNT:
908                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
909                 break;
910             case KEY_AUDIO_SAMPLE_RATE:
911                 param->nSampleRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
912                 break;
913             case KEY_BITRATE:
914                 param->nBitRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
915                 break;
916             case KEY_AUDIO_SOUND_MODE:
917                 param->eChannelMode =
918                     ConvertSoundModeToChannelMode(*(reinterpret_cast<AudioSoundMode *>(paramIn[i].val)));
919                 break;
920 
921             default: {
922                 validCount--;
923                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
924                 break;
925             }
926         }
927     }
928     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
929 }
930 
ParseParamAudioG726(Param * paramIn,int8_t * paramOut,int32_t paramCnt)931 static int32_t ParseParamAudioG726(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
932 {
933     OMX_AUDIO_PARAM_G726TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_G726TYPE *>(paramOut);
934     int32_t validCount = 0;
935     for (int32_t i = 0; i < paramCnt; i++) {
936         if (paramIn[i].val == nullptr) {
937             continue;
938         }
939         validCount++;
940         if (paramIn[i].key == KEY_AUDIO_CHANNEL_COUNT) {
941             param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
942         } else {
943             validCount--;
944             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
945         }
946     }
947     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
948 }
949 
ParseParamImagePortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)950 static int32_t ParseParamImagePortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
951 {
952     OMX_IMAGE_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_PORTFORMATTYPE *>(paramOut);
953     int32_t validCount = 0;
954     for (int32_t i = 0; i < paramCnt; i++) {
955         if (paramIn[i].val == nullptr) {
956             continue;
957         }
958         validCount++;
959         switch (paramIn[i].key) {
960             case KEY_MIMETYPE:
961                 param->eCompressionFormat = (OMX_IMAGE_CODINGTYPE)
962                     ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
963                 break;
964             case KEY_PIXEL_FORMAT:
965                 param->eColorFormat =
966                     ConvertPixelFormatToColorFormat(*(reinterpret_cast<PixelFormat *>(paramIn[i].val)));
967                 break;
968 
969             default: {
970                 validCount--;
971                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
972                 break;
973             }
974         }
975     }
976     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
977 }
978 
ParseParamQfactor(Param * paramIn,int8_t * paramOut,int32_t paramCnt)979 static int32_t ParseParamQfactor(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
980 {
981     OMX_IMAGE_PARAM_QFACTORTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_QFACTORTYPE *>(paramOut);
982     int32_t validCount = 0;
983     for (int32_t i = 0; i < paramCnt; i++) {
984         if (paramIn[i].val == nullptr) {
985             continue;
986         }
987         validCount++;
988         if (paramIn[i].key == KEY_IMAGE_Q_FACTOR) {
989             param->nQFactor = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
990         } else {
991             validCount--;
992             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
993         }
994     }
995     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
996 }
997 
ParseParamVideoPortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)998 static int32_t ParseParamVideoPortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
999 {
1000     OMX_VIDEO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_PORTFORMATTYPE *>(paramOut);
1001     int32_t validCount = 0;
1002     for (int32_t i = 0; i < paramCnt; i++) {
1003         if (paramIn[i].val == nullptr) {
1004             continue;
1005         }
1006         validCount++;
1007         switch (paramIn[i].key) {
1008             case KEY_MIMETYPE:
1009                 param->eCompressionFormat = (OMX_VIDEO_CODINGTYPE)
1010                     ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
1011                 break;
1012             case KEY_PIXEL_FORMAT:
1013                 param->eColorFormat =
1014                     ConvertPixelFormatToColorFormat(*(reinterpret_cast<PixelFormat *>(paramIn[i].val)));
1015                 break;
1016             case KEY_VIDEO_FRAME_RATE:
1017                 param->xFramerate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
1018                 break;
1019 
1020             default: {
1021                 validCount--;
1022                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1023                 break;
1024             }
1025         }
1026     }
1027     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1028 }
1029 
ParseParamVideoAvc(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1030 static int32_t ParseParamVideoAvc(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1031 {
1032     OMX_VIDEO_PARAM_AVCTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_AVCTYPE *>(paramOut);
1033     int32_t validCount = 0;
1034     for (int32_t i = 0; i < paramCnt; i++) {
1035         if (paramIn[i].val == nullptr) {
1036             continue;
1037         }
1038         validCount++;
1039         if (paramIn[i].key == KEY_VIDEO_PROFILE) {
1040             param->eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>
1041                 (ConvertProfileToOmxProfile(*(reinterpret_cast<Profile *>(paramIn[i].val))));
1042         } else {
1043             validCount--;
1044             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1045         }
1046     }
1047     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1048 }
1049 
ParseParamVideoBitrate(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1050 static int32_t ParseParamVideoBitrate(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1051 {
1052     OMX_VIDEO_PARAM_BITRATETYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_BITRATETYPE *>(paramOut);
1053     int32_t validCount = 0;
1054     for (int32_t i = 0; i < paramCnt; i++) {
1055         if (paramIn[i].val == nullptr) {
1056             continue;
1057         }
1058         validCount++;
1059         if (paramIn[i].key == KEY_VIDEO_RC_MODE) {
1060             param->eControlRate = ConvertRcModeToRateType(*(reinterpret_cast<VideoCodecRcMode *>(paramIn[i].val)));
1061         } else {
1062             validCount--;
1063             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1064         }
1065     }
1066     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1067 }
1068 
ParseParamPassthrough(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1069 static int32_t ParseParamPassthrough(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1070 {
1071     PassthroughParam *param = reinterpret_cast<PassthroughParam *>(paramOut);
1072 
1073     int32_t index = 0;
1074     if (paramIn[index].val == nullptr) {
1075         return HDF_FAILURE;
1076     }
1077     param->key = paramIn[index].key;
1078     param->val = paramIn[index].val;
1079     param->size = paramIn[index].size;
1080     return HDF_SUCCESS;
1081 }
1082 
ParseParam(int32_t paramIndex,Param * paramIn,int32_t paramCnt,int8_t * paramOut,CodecExInfo info)1083 int32_t ParseParam(int32_t paramIndex, Param *paramIn, int32_t paramCnt, int8_t *paramOut, CodecExInfo info)
1084 {
1085     if (paramIn == nullptr || paramOut == nullptr) {
1086         HDF_LOGE("%{public}s error, paramIn or paramOut is null", __func__);
1087         return HDF_FAILURE;
1088     }
1089     int32_t ret = HDF_SUCCESS;
1090     switch (paramIndex) {
1091         case OMX_IndexParamPortDefinition:
1092             ret = ParseParamPortDefinition(paramIn, paramOut, paramCnt, info);
1093             break;
1094         case OMX_IndexParamAudioPortFormat:
1095             ret = ParseParamAudioPortFormat(paramIn, paramOut, paramCnt);
1096             break;
1097         case OMX_IndexParamAudioPcm:
1098             ret = ParseParamAudioPcm(paramIn, paramOut, paramCnt);
1099             break;
1100         case OMX_IndexParamAudioAac:
1101             ret = ParseParamAudioAac(paramIn, paramOut, paramCnt);
1102             break;
1103         case OMX_IndexParamAudioMp3:
1104             ret = ParseParamAudioMp3(paramIn, paramOut, paramCnt);
1105             break;
1106         case OMX_IndexParamAudioG726:
1107             ret = ParseParamAudioG726(paramIn, paramOut, paramCnt);
1108             break;
1109         case OMX_IndexParamImagePortFormat:
1110             ret = ParseParamImagePortFormat(paramIn, paramOut, paramCnt);
1111             break;
1112         case OMX_IndexParamQFactor:
1113             ret = ParseParamQfactor(paramIn, paramOut, paramCnt);
1114             break;
1115         case OMX_IndexParamVideoPortFormat:
1116             ret = ParseParamVideoPortFormat(paramIn, paramOut, paramCnt);
1117             break;
1118         case OMX_IndexParamVideoAvc:
1119             ret = ParseParamVideoAvc(paramIn, paramOut, paramCnt);
1120             break;
1121         case OMX_IndexParamVideoBitrate:
1122             ret = ParseParamVideoBitrate(paramIn, paramOut, paramCnt);
1123             break;
1124         case OMX_IndexParamPassthrough:
1125             ret = ParseParamPassthrough(paramIn, paramOut, paramCnt);
1126             break;
1127 
1128         default:
1129             HDF_LOGE("%{public}s error, unsupport paramIndex[%{public}d]", __func__, paramIndex);
1130             ret = HDF_ERR_NOT_SUPPORT;
1131             break;
1132     }
1133     return ret;
1134 }
1135 
ConvertBufferTypeToOmxBufferType(BufferType type)1136 static int32_t ConvertBufferTypeToOmxBufferType(BufferType type)
1137 {
1138     CodecBufferType bufferType;
1139     switch (type) {
1140         case BUFFER_TYPE_VIRTUAL:
1141             bufferType = CODEC_BUFFER_TYPE_VIRTUAL_ADDR;
1142             break;
1143         case BUFFER_TYPE_FD:
1144             bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1145             break;
1146         case BUFFER_TYPE_HANDLE:
1147             bufferType = CODEC_BUFFER_TYPE_HANDLE;
1148             break;
1149 
1150         default: {
1151             HDF_LOGW("%{public}s warn, unsupport bufferType[%{public}d]", __func__, type);
1152             bufferType = CODEC_BUFFER_TYPE_INVALID;
1153             break;
1154         }
1155     }
1156     return bufferType;
1157 }
1158 
ConvertOmxBufferTypeToBufferType(int32_t type,BufferType & bufferType)1159 int32_t ConvertOmxBufferTypeToBufferType(int32_t type, BufferType &bufferType)
1160 {
1161     int32_t ret = HDF_SUCCESS;
1162     switch (type) {
1163         case CODEC_BUFFER_TYPE_VIRTUAL_ADDR:
1164             bufferType = BUFFER_TYPE_VIRTUAL;
1165             break;
1166         case CODEC_BUFFER_TYPE_AVSHARE_MEM_FD:
1167             bufferType = BUFFER_TYPE_FD;
1168             break;
1169         case CODEC_BUFFER_TYPE_HANDLE:
1170             bufferType = BUFFER_TYPE_HANDLE;
1171             break;
1172 
1173         default: {
1174             HDF_LOGE("%{public}s warn, unsupport bufferType[%{public}d]", __func__, type);
1175             bufferType = BUFFER_TYPE_VIRTUAL;
1176             ret = HDF_FAILURE;
1177             break;
1178         }
1179     }
1180     return ret;
1181 }
1182 
ConvertOmxCodecBufferToCodecBuffer(const OmxCodecBuffer & omxBuffer,CodecBuffer & codecBuffer)1183 void ConvertOmxCodecBufferToCodecBuffer(const OmxCodecBuffer &omxBuffer, CodecBuffer &codecBuffer)
1184 {
1185     codecBuffer.bufferId = omxBuffer.bufferId;
1186     codecBuffer.timeStamp = omxBuffer.pts;
1187     if (omxBuffer.flag & OMX_BUFFERFLAG_EOS) {
1188         codecBuffer.flag = STREAM_FLAG_EOS;
1189     } else {
1190         codecBuffer.flag = STREAM_FLAG_CODEC_SPECIFIC_INF;
1191     }
1192     codecBuffer.bufferCnt = 1;
1193     ConvertOmxBufferTypeToBufferType(omxBuffer.bufferType, codecBuffer.buffer[0].type);
1194     codecBuffer.buffer[0].buf = (intptr_t)omxBuffer.buffer;
1195     codecBuffer.buffer[0].offset = omxBuffer.offset;
1196     codecBuffer.buffer[0].length = omxBuffer.filledLen;
1197     codecBuffer.buffer[0].capacity = omxBuffer.allocLen;
1198 }
1199 
ConvertCodecBufferToOmxCodecBuffer(OmxCodecBuffer & omxBuffer,CodecBuffer & codecBuffer)1200 void ConvertCodecBufferToOmxCodecBuffer(OmxCodecBuffer &omxBuffer, CodecBuffer &codecBuffer)
1201 {
1202     omxBuffer.bufferId = codecBuffer.bufferId;
1203     omxBuffer.pts = codecBuffer.timeStamp;
1204     if (codecBuffer.flag & STREAM_FLAG_EOS) {
1205         omxBuffer.flag = OMX_BUFFERFLAG_EOS;
1206     }
1207     omxBuffer.bufferType = (CodecBufferType)ConvertBufferTypeToOmxBufferType(codecBuffer.buffer[0].type);
1208     omxBuffer.buffer = (uint8_t *)codecBuffer.buffer[0].buf;
1209     omxBuffer.offset = codecBuffer.buffer[0].offset;
1210     omxBuffer.filledLen = codecBuffer.buffer[0].length;
1211     omxBuffer.allocLen = codecBuffer.buffer[0].capacity;
1212     omxBuffer.bufferLen = codecBuffer.buffer[0].capacity;
1213 }
1214 }  // namespace Common
1215 }  // namespace Codec
1216 }  // namespace OHOS