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