• 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 = reinterpret_cast<void *>(&(param->nBufferSize));
389     paramOut[index].size = sizeof(param->nBufferSize);
390     index++;
391     paramOut[index].key = KEY_MIMETYPE;
392     param->format.video.eCompressionFormat =
393         static_cast<OMX_VIDEO_CODINGTYPE>(ConvertVideoCodingTypeToMimeType(param->format.video.eCompressionFormat));
394     paramOut[index].val = reinterpret_cast<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 = reinterpret_cast<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 = reinterpret_cast<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 = reinterpret_cast<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 = reinterpret_cast<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 = reinterpret_cast<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 = reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 = static_cast<OMX_AUDIO_CODINGTYPE>(ConvertAudioCodingTypeToMimeType(param->eEncoding));
470     paramOut[index].val = setMark ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 = static_cast<OMX_AUDIO_AACPROFILETYPE>(ConvertAacProfileToProfile(param->eAACProfile));
515     paramOut[index].val = setMark ? reinterpret_cast<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 = static_cast<OMX_AUDIO_CHANNELMODETYPE>(ConvertChannelModeToSoundMode(param->eChannelMode));
520     paramOut[index].val = setMark ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 = static_cast<OMX_AUDIO_CHANNELMODETYPE>(ConvertChannelModeToSoundMode(param->eChannelMode));
545     paramOut[index].val = setMark ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 ? reinterpret_cast<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 =
601         static_cast<OMX_VIDEO_CODINGTYPE>(ConvertVideoCodingTypeToMimeType(param->eCompressionFormat));
602     paramOut[index].val = setMark ? reinterpret_cast<void *>(&(param->eCompressionFormat)) : nullptr;
603     paramOut[index].size = setMark ? sizeof(param->eCompressionFormat) : 0;
604     index++;
605     paramOut[index].key = KEY_VIDEO_FRAME_RATE;
606     paramOut[index].val = setMark ? reinterpret_cast<void *>(&(param->xFramerate)) : nullptr;
607     paramOut[index].size = setMark ? sizeof(param->xFramerate) : 0;
608     index++;
609     param->eColorFormat = static_cast<OMX_COLOR_FORMATTYPE>(ConvertColorFormatToPixelFormat(param->eColorFormat));
610     if (static_cast<PixelFormat>(param->eColorFormat) != PIXEL_FMT_BUTT || !setMark) {
611         paramOut[index].key = KEY_PIXEL_FORMAT;
612         paramOut[index].val = setMark ? reinterpret_cast<void *>(&(param->eColorFormat)) : nullptr;
613         paramOut[index].size = setMark ? sizeof(param->eColorFormat) : 0;
614         index++;
615     }
616 
617     paramCnt = index;
618 }
619 
SplitParamVideoAvc(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)620 static void SplitParamVideoAvc(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
621 {
622     OMX_VIDEO_PARAM_AVCTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_AVCTYPE *>(paramIn);
623     int32_t index = 0;
624     paramOut[index].key = KEY_VIDEO_PROFILE;
625     param->eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(ConvertAvcProfileToProfile(param->eProfile));
626     paramOut[index].val = setMark ? reinterpret_cast<void *>(&(param->eProfile)) : nullptr;
627     paramOut[index].size = setMark ? sizeof(param->eProfile) : 0;
628     index++;
629 
630     paramCnt = index;
631 }
632 
SplitParamVideoBitrate(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)633 static void SplitParamVideoBitrate(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
634 {
635     OMX_VIDEO_PARAM_BITRATETYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_BITRATETYPE *>(paramIn);
636     int32_t index = 0;
637     paramOut[index].key = KEY_VIDEO_RC_MODE;
638     param->eControlRate = static_cast<OMX_VIDEO_CONTROLRATETYPE>(ConvertRateTypeToRcMode(param->eControlRate));
639     paramOut[index].val = setMark ? reinterpret_cast<void *>(&(param->eControlRate)) : nullptr;
640     paramOut[index].size = setMark ? sizeof(param->eControlRate) : 0;
641     index++;
642 
643     paramCnt = index;
644 }
645 
SplitParamPassthrough(int8_t * paramIn,Param * paramOut,int32_t & paramCnt,bool setMark)646 static void SplitParamPassthrough(int8_t *paramIn, Param *paramOut, int32_t &paramCnt, bool setMark)
647 {
648     PassthroughParam *param = reinterpret_cast<PassthroughParam *>(paramIn);
649     int32_t index = 0;
650     paramOut[index].key = static_cast<ParamKey>(param->key);
651     paramOut[index].val = param->val;
652     paramOut[index].size = param->size;
653     index++;
654 
655     paramCnt = index;
656 }
657 
SplitParam(int32_t paramIndex,int8_t * paramIn,Param * paramOut,int32_t & paramCnt,CodecType type)658 int32_t SplitParam(int32_t paramIndex, int8_t *paramIn, Param *paramOut, int32_t &paramCnt, CodecType type)
659 {
660     if (paramIn == nullptr || paramOut == nullptr) {
661         HDF_LOGE("%{public}s error, paramIn or paramOut is null", __func__);
662         return HDF_FAILURE;
663     }
664     bool setMark = (paramCnt == 1);
665     switch (paramIndex) {
666         case OMX_IndexParamPortDefinition:
667             SplitParamPortDefinition(paramIn, paramOut, paramCnt, setMark, type);
668             break;
669         case OMX_IndexParamAudioPortFormat:
670             SplitParamAudioPortFormat(paramIn, paramOut, paramCnt, setMark);
671             break;
672         case OMX_IndexParamAudioPcm:
673             SplitParamAudioPcm(paramIn, paramOut, paramCnt, setMark);
674             break;
675         case OMX_IndexParamAudioAac:
676             SplitParamAudioAac(paramIn, paramOut, paramCnt, setMark);
677             break;
678         case OMX_IndexParamAudioMp3:
679             SplitParamAudioMp3(paramIn, paramOut, paramCnt, setMark);
680             break;
681         case OMX_IndexParamAudioG726:
682             SplitParamAudioG726(paramIn, paramOut, paramCnt, setMark);
683             break;
684         case OMX_IndexParamImagePortFormat:
685             SplitParamImagePortFormat(paramIn, paramOut, paramCnt, setMark);
686             break;
687         case OMX_IndexParamQFactor:
688             SplitParamQfactor(paramIn, paramOut, paramCnt, setMark);
689             break;
690         case OMX_IndexParamVideoPortFormat:
691             SplitParamVideoPortFormat(paramIn, paramOut, paramCnt, setMark);
692             break;
693         case OMX_IndexParamVideoAvc:
694             SplitParamVideoAvc(paramIn, paramOut, paramCnt, setMark);
695             break;
696         case OMX_IndexParamVideoBitrate:
697             SplitParamVideoBitrate(paramIn, paramOut, paramCnt, setMark);
698             break;
699         case OMX_IndexParamPassthrough:
700             SplitParamPassthrough(paramIn, paramOut, paramCnt, setMark);
701             break;
702         default:
703             HDF_LOGE("%{public}s error, paramIndex[%{public}d] is not support!", __func__, paramIndex);
704             return HDF_ERR_NOT_SUPPORT;
705     }
706     return HDF_SUCCESS;
707 }
708 
ParseParamPortDefinitionVideo(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)709 static int32_t ParseParamPortDefinitionVideo(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
710 {
711     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramOut);
712     int32_t validCount = 0;
713     for (int32_t i = 0; i < paramCnt; i++) {
714         if (paramIn[i].val == nullptr) {
715             continue;
716         }
717         validCount++;
718         switch (paramIn[i].key) {
719             case KEY_INPUT_BUFFER_COUNT:
720             case KEY_OUTPUT_BUFFER_COUNT:
721                 param->nBufferCountActual = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
722                 break;
723             case KEY_BUFFERSIZE:
724                 param->nBufferSize = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
725                 param->bEnabled = OMX_TRUE;
726                 break;
727             case KEY_MIMETYPE: {
728                 int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
729                 param->format.video.eCompressionFormat = static_cast<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             default:
752                 validCount--;
753                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
754                 break;
755         }
756     }
757     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
758 }
759 
ParseParamPortDefinitionAudio(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)760 static int32_t ParseParamPortDefinitionAudio(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
761 {
762     OMX_PARAM_PORTDEFINITIONTYPE *param = reinterpret_cast<OMX_PARAM_PORTDEFINITIONTYPE *>(paramOut);
763     int32_t validCount = 0;
764     for (int32_t i = 0; i < paramCnt; i++) {
765         if (paramIn[i].val == nullptr) {
766             continue;
767         }
768         validCount++;
769         switch (paramIn[i].key) {
770             case KEY_BUFFERSIZE: {
771                 param->nBufferSize =
772                          param->nPortIndex == static_cast<OMX_U32>(INPUT_PORTINDEX) ?
773                          static_cast<OMX_U32>(info.inputBufferSize) : static_cast<OMX_U32>(info.outputBufferSize);
774                 param->nBufferCountActual =
775                          param->nPortIndex == static_cast<OMX_U32>(INPUT_PORTINDEX) ?
776                          static_cast<OMX_U32>(info.inputBufferCount) : static_cast<OMX_U32>(info.outputBufferCount);
777                 param->bEnabled = OMX_TRUE;
778                 break;
779             }
780             case KEY_MIMETYPE: {
781                 int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
782                 param->format.audio.eEncoding = static_cast<OMX_AUDIO_CODINGTYPE>(codingType);
783                 break;
784             }
785 
786             default: {
787                 validCount--;
788                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
789                 break;
790             }
791         }
792     }
793     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
794 }
795 
ParseParamPortDefinition(Param * paramIn,int8_t * paramOut,int32_t paramCnt,CodecExInfo info)796 static int32_t ParseParamPortDefinition(Param *paramIn, int8_t *paramOut, int32_t paramCnt, CodecExInfo info)
797 {
798     int32_t ret = HDF_FAILURE;
799     if (info.type == VIDEO_DECODER || info.type == VIDEO_ENCODER) {
800         ret = ParseParamPortDefinitionVideo(paramIn, paramOut, paramCnt, info);
801     } else if (info.type == AUDIO_DECODER || info.type == AUDIO_ENCODER) {
802         ret = ParseParamPortDefinitionAudio(paramIn, paramOut, paramCnt, info);
803     }
804     return ret;
805 }
806 
ParseParamAudioPortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)807 static int32_t ParseParamAudioPortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
808 {
809     OMX_AUDIO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PORTFORMATTYPE *>(paramOut);
810     int32_t validCount = 0;
811     for (int32_t i = 0; i < paramCnt; i++) {
812         if (paramIn[i].val == nullptr) {
813             continue;
814         }
815         validCount++;
816         if (paramIn[i].key == KEY_MIMETYPE) {
817             int32_t codingType = ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val)));
818             param->eEncoding = (OMX_AUDIO_CODINGTYPE)codingType;
819         } else {
820             validCount--;
821             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
822         }
823     }
824     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
825 }
826 
ParseParamAudioPcm(Param * paramIn,int8_t * paramOut,int32_t paramCnt)827 static int32_t ParseParamAudioPcm(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
828 {
829     OMX_AUDIO_PARAM_PCMMODETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_PCMMODETYPE *>(paramOut);
830     int32_t validCount = 0;
831     for (int32_t i = 0; i < paramCnt; i++) {
832         if (paramIn[i].val == nullptr) {
833             continue;
834         }
835         validCount++;
836         switch (paramIn[i].key) {
837             case KEY_AUDIO_CHANNEL_COUNT:
838                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
839                 break;
840             case KEY_AUDIO_POINTS_PER_FRAME:
841                 param->nBitPerSample = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
842                 break;
843             case KEY_AUDIO_SAMPLE_RATE:
844                 param->nSamplingRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
845                 break;
846 
847             default: {
848                 validCount--;
849                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
850                 break;
851             }
852         }
853     }
854     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
855 }
856 
ParseParamAudioAac(Param * paramIn,int8_t * paramOut,int32_t paramCnt)857 static int32_t ParseParamAudioAac(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
858 {
859     OMX_AUDIO_PARAM_AACPROFILETYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_AACPROFILETYPE *>(paramOut);
860     int32_t validCount = 0;
861     for (int32_t i = 0; i < paramCnt; i++) {
862         if (paramIn[i].val == nullptr) {
863             continue;
864         }
865         validCount++;
866         switch (paramIn[i].key) {
867             case KEY_AUDIO_CHANNEL_COUNT:
868                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
869                 break;
870             case KEY_AUDIO_SAMPLE_RATE:
871                 param->nSampleRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
872                 break;
873             case KEY_BITRATE:
874                 param->nBitRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
875                 break;
876             case KEY_AUDIO_PROFILE:
877                 param->eAACProfile = static_cast<OMX_AUDIO_AACPROFILETYPE>(
878                     ConvertProfileToOmxProfile(*(reinterpret_cast<Profile *>(paramIn[i].val))));
879                 break;
880             case KEY_AUDIO_SOUND_MODE:
881                 param->eChannelMode =
882                     ConvertSoundModeToChannelMode(*(reinterpret_cast<AudioSoundMode *>(paramIn[i].val)));
883                 break;
884 
885             default: {
886                 validCount--;
887                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
888                 break;
889             }
890         }
891     }
892     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
893 }
894 
ParseParamAudioMp3(Param * paramIn,int8_t * paramOut,int32_t paramCnt)895 static int32_t ParseParamAudioMp3(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
896 {
897     OMX_AUDIO_PARAM_MP3TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_MP3TYPE *>(paramOut);
898     int32_t validCount = 0;
899     for (int32_t i = 0; i < paramCnt; i++) {
900         if (paramIn[i].val == nullptr) {
901             continue;
902         }
903         validCount++;
904         switch (paramIn[i].key) {
905             case KEY_AUDIO_CHANNEL_COUNT:
906                 param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
907                 break;
908             case KEY_AUDIO_SAMPLE_RATE:
909                 param->nSampleRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
910                 break;
911             case KEY_BITRATE:
912                 param->nBitRate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
913                 break;
914             case KEY_AUDIO_SOUND_MODE:
915                 param->eChannelMode =
916                     ConvertSoundModeToChannelMode(*(reinterpret_cast<AudioSoundMode *>(paramIn[i].val)));
917                 break;
918 
919             default: {
920                 validCount--;
921                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
922                 break;
923             }
924         }
925     }
926     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
927 }
928 
ParseParamAudioG726(Param * paramIn,int8_t * paramOut,int32_t paramCnt)929 static int32_t ParseParamAudioG726(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
930 {
931     OMX_AUDIO_PARAM_G726TYPE *param = reinterpret_cast<OMX_AUDIO_PARAM_G726TYPE *>(paramOut);
932     int32_t validCount = 0;
933     for (int32_t i = 0; i < paramCnt; i++) {
934         if (paramIn[i].val == nullptr) {
935             continue;
936         }
937         validCount++;
938         if (paramIn[i].key == KEY_AUDIO_CHANNEL_COUNT) {
939             param->nChannels = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
940         } else {
941             validCount--;
942             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
943         }
944     }
945     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
946 }
947 
ParseParamImagePortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)948 static int32_t ParseParamImagePortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
949 {
950     OMX_IMAGE_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_PORTFORMATTYPE *>(paramOut);
951     int32_t validCount = 0;
952     for (int32_t i = 0; i < paramCnt; i++) {
953         if (paramIn[i].val == nullptr) {
954             continue;
955         }
956         validCount++;
957         switch (paramIn[i].key) {
958             case KEY_MIMETYPE:
959                 param->eCompressionFormat = static_cast<OMX_IMAGE_CODINGTYPE>(
960                     ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val))));
961                 break;
962             case KEY_PIXEL_FORMAT:
963                 param->eColorFormat =
964                     ConvertPixelFormatToColorFormat(*(reinterpret_cast<PixelFormat *>(paramIn[i].val)));
965                 break;
966 
967             default: {
968                 validCount--;
969                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
970                 break;
971             }
972         }
973     }
974     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
975 }
976 
ParseParamQfactor(Param * paramIn,int8_t * paramOut,int32_t paramCnt)977 static int32_t ParseParamQfactor(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
978 {
979     OMX_IMAGE_PARAM_QFACTORTYPE *param = reinterpret_cast<OMX_IMAGE_PARAM_QFACTORTYPE *>(paramOut);
980     int32_t validCount = 0;
981     for (int32_t i = 0; i < paramCnt; i++) {
982         if (paramIn[i].val == nullptr) {
983             continue;
984         }
985         validCount++;
986         if (paramIn[i].key == KEY_IMAGE_Q_FACTOR) {
987             param->nQFactor = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
988         } else {
989             validCount--;
990             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
991         }
992     }
993     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
994 }
995 
ParseParamVideoPortFormat(Param * paramIn,int8_t * paramOut,int32_t paramCnt)996 static int32_t ParseParamVideoPortFormat(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
997 {
998     OMX_VIDEO_PARAM_PORTFORMATTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_PORTFORMATTYPE *>(paramOut);
999     int32_t validCount = 0;
1000     for (int32_t i = 0; i < paramCnt; i++) {
1001         if (paramIn[i].val == nullptr) {
1002             continue;
1003         }
1004         validCount++;
1005         switch (paramIn[i].key) {
1006             case KEY_MIMETYPE:
1007                 param->eCompressionFormat = static_cast<OMX_VIDEO_CODINGTYPE>(
1008                     ConvertMimeTypeToCodingType(*(reinterpret_cast<AvCodecMime *>(paramIn[i].val))));
1009                 break;
1010             case KEY_PIXEL_FORMAT:
1011                 param->eColorFormat =
1012                     ConvertPixelFormatToColorFormat(*(reinterpret_cast<PixelFormat *>(paramIn[i].val)));
1013                 break;
1014             case KEY_VIDEO_FRAME_RATE:
1015                 param->xFramerate = *(reinterpret_cast<OMX_U32 *>(paramIn[i].val));
1016                 break;
1017 
1018             default: {
1019                 validCount--;
1020                 HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1021                 break;
1022             }
1023         }
1024     }
1025     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1026 }
1027 
ParseParamVideoAvc(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1028 static int32_t ParseParamVideoAvc(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1029 {
1030     OMX_VIDEO_PARAM_AVCTYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_AVCTYPE *>(paramOut);
1031     int32_t validCount = 0;
1032     for (int32_t i = 0; i < paramCnt; i++) {
1033         if (paramIn[i].val == nullptr) {
1034             continue;
1035         }
1036         validCount++;
1037         if (paramIn[i].key == KEY_VIDEO_PROFILE) {
1038             param->eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>
1039                 (ConvertProfileToOmxProfile(*(reinterpret_cast<Profile *>(paramIn[i].val))));
1040         } else {
1041             validCount--;
1042             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1043         }
1044     }
1045     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1046 }
1047 
ParseParamVideoBitrate(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1048 static int32_t ParseParamVideoBitrate(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1049 {
1050     OMX_VIDEO_PARAM_BITRATETYPE *param = reinterpret_cast<OMX_VIDEO_PARAM_BITRATETYPE *>(paramOut);
1051     int32_t validCount = 0;
1052     for (int32_t i = 0; i < paramCnt; i++) {
1053         if (paramIn[i].val == nullptr) {
1054             continue;
1055         }
1056         validCount++;
1057         if (paramIn[i].key == KEY_VIDEO_RC_MODE) {
1058             param->eControlRate = ConvertRcModeToRateType(*(reinterpret_cast<VideoCodecRcMode *>(paramIn[i].val)));
1059         } else {
1060             validCount--;
1061             HDF_LOGW("%{public}s warn, unsupport key[%{public}d]", __func__, paramIn[i].key);
1062         }
1063     }
1064     return (validCount > 0) ? HDF_SUCCESS : HDF_FAILURE;
1065 }
1066 
ParseParamPassthrough(Param * paramIn,int8_t * paramOut,int32_t paramCnt)1067 static int32_t ParseParamPassthrough(Param *paramIn, int8_t *paramOut, int32_t paramCnt)
1068 {
1069     PassthroughParam *param = reinterpret_cast<PassthroughParam *>(paramOut);
1070 
1071     int32_t index = 0;
1072     if (paramIn[index].val == nullptr) {
1073         return HDF_FAILURE;
1074     }
1075     param->key = paramIn[index].key;
1076     param->val = paramIn[index].val;
1077     param->size = paramIn[index].size;
1078     return HDF_SUCCESS;
1079 }
1080 
ParseParam(int32_t paramIndex,Param * paramIn,int32_t paramCnt,int8_t * paramOut,CodecExInfo info)1081 int32_t ParseParam(int32_t paramIndex, Param *paramIn, int32_t paramCnt, int8_t *paramOut, CodecExInfo info)
1082 {
1083     if (paramIn == nullptr || paramOut == nullptr) {
1084         HDF_LOGE("%{public}s error, paramIn or paramOut is null", __func__);
1085         return HDF_FAILURE;
1086     }
1087     int32_t ret = HDF_SUCCESS;
1088     switch (paramIndex) {
1089         case OMX_IndexParamPortDefinition:
1090             ret = ParseParamPortDefinition(paramIn, paramOut, paramCnt, info);
1091             break;
1092         case OMX_IndexParamAudioPortFormat:
1093             ret = ParseParamAudioPortFormat(paramIn, paramOut, paramCnt);
1094             break;
1095         case OMX_IndexParamAudioPcm:
1096             ret = ParseParamAudioPcm(paramIn, paramOut, paramCnt);
1097             break;
1098         case OMX_IndexParamAudioAac:
1099             ret = ParseParamAudioAac(paramIn, paramOut, paramCnt);
1100             break;
1101         case OMX_IndexParamAudioMp3:
1102             ret = ParseParamAudioMp3(paramIn, paramOut, paramCnt);
1103             break;
1104         case OMX_IndexParamAudioG726:
1105             ret = ParseParamAudioG726(paramIn, paramOut, paramCnt);
1106             break;
1107         case OMX_IndexParamImagePortFormat:
1108             ret = ParseParamImagePortFormat(paramIn, paramOut, paramCnt);
1109             break;
1110         case OMX_IndexParamQFactor:
1111             ret = ParseParamQfactor(paramIn, paramOut, paramCnt);
1112             break;
1113         case OMX_IndexParamVideoPortFormat:
1114             ret = ParseParamVideoPortFormat(paramIn, paramOut, paramCnt);
1115             break;
1116         case OMX_IndexParamVideoAvc:
1117             ret = ParseParamVideoAvc(paramIn, paramOut, paramCnt);
1118             break;
1119         case OMX_IndexParamVideoBitrate:
1120             ret = ParseParamVideoBitrate(paramIn, paramOut, paramCnt);
1121             break;
1122         case OMX_IndexParamPassthrough:
1123             ret = ParseParamPassthrough(paramIn, paramOut, paramCnt);
1124             break;
1125 
1126         default:
1127             HDF_LOGE("%{public}s error, unsupport paramIndex[%{public}d]", __func__, paramIndex);
1128             ret = HDF_ERR_NOT_SUPPORT;
1129             break;
1130     }
1131     return ret;
1132 }
1133 
ConvertBufferTypeToOmxBufferType(BufferType type)1134 static int32_t ConvertBufferTypeToOmxBufferType(BufferType type)
1135 {
1136     CodecBufferType bufferType;
1137     switch (type) {
1138         case BUFFER_TYPE_VIRTUAL:
1139             bufferType = CODEC_BUFFER_TYPE_VIRTUAL_ADDR;
1140             break;
1141         case BUFFER_TYPE_FD:
1142             bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1143             break;
1144         case BUFFER_TYPE_HANDLE:
1145             bufferType = CODEC_BUFFER_TYPE_HANDLE;
1146             break;
1147 
1148         default: {
1149             HDF_LOGW("%{public}s warn, unsupport bufferType[%{public}d]", __func__, type);
1150             bufferType = CODEC_BUFFER_TYPE_INVALID;
1151             break;
1152         }
1153     }
1154     return bufferType;
1155 }
1156 
ConvertOmxBufferTypeToBufferType(int32_t type,BufferType & bufferType)1157 int32_t ConvertOmxBufferTypeToBufferType(int32_t type, BufferType &bufferType)
1158 {
1159     int32_t ret = HDF_SUCCESS;
1160     switch (type) {
1161         case CODEC_BUFFER_TYPE_VIRTUAL_ADDR:
1162             bufferType = BUFFER_TYPE_VIRTUAL;
1163             break;
1164         case CODEC_BUFFER_TYPE_AVSHARE_MEM_FD:
1165             bufferType = BUFFER_TYPE_FD;
1166             break;
1167         case CODEC_BUFFER_TYPE_HANDLE:
1168             bufferType = BUFFER_TYPE_HANDLE;
1169             break;
1170 
1171         default: {
1172             HDF_LOGE("%{public}s warn, unsupport bufferType[%{public}d]", __func__, type);
1173             bufferType = BUFFER_TYPE_VIRTUAL;
1174             ret = HDF_FAILURE;
1175             break;
1176         }
1177     }
1178     return ret;
1179 }
1180 
ConvertOmxCodecBufferToCodecBuffer(const OmxCodecBuffer & omxBuffer,CodecBuffer & codecBuffer)1181 void ConvertOmxCodecBufferToCodecBuffer(const OmxCodecBuffer &omxBuffer, CodecBuffer &codecBuffer)
1182 {
1183     codecBuffer.bufferId = omxBuffer.bufferId;
1184     codecBuffer.timeStamp = omxBuffer.pts;
1185     if (omxBuffer.flag & OMX_BUFFERFLAG_EOS) {
1186         codecBuffer.flag = STREAM_FLAG_EOS;
1187     } else {
1188         codecBuffer.flag = STREAM_FLAG_CODEC_SPECIFIC_INF;
1189     }
1190     codecBuffer.bufferCnt = 1;
1191     ConvertOmxBufferTypeToBufferType(omxBuffer.bufferType, codecBuffer.buffer[0].type);
1192     codecBuffer.buffer[0].buf = (intptr_t)omxBuffer.buffer;
1193     codecBuffer.buffer[0].offset = omxBuffer.offset;
1194     codecBuffer.buffer[0].length = omxBuffer.filledLen;
1195     codecBuffer.buffer[0].capacity = omxBuffer.allocLen;
1196 }
1197 
ConvertCodecBufferToOmxCodecBuffer(OmxCodecBuffer & omxBuffer,CodecBuffer & codecBuffer)1198 void ConvertCodecBufferToOmxCodecBuffer(OmxCodecBuffer &omxBuffer, CodecBuffer &codecBuffer)
1199 {
1200     omxBuffer.bufferId = codecBuffer.bufferId;
1201     omxBuffer.pts = codecBuffer.timeStamp;
1202     if (codecBuffer.flag & STREAM_FLAG_EOS) {
1203         omxBuffer.flag = OMX_BUFFERFLAG_EOS;
1204     }
1205     omxBuffer.bufferType = static_cast<CodecBufferType>(ConvertBufferTypeToOmxBufferType(codecBuffer.buffer[0].type));
1206     omxBuffer.buffer = reinterpret_cast<uint8_t *>(codecBuffer.buffer[0].buf);
1207     omxBuffer.offset = codecBuffer.buffer[0].offset;
1208     omxBuffer.filledLen = codecBuffer.buffer[0].length;
1209     omxBuffer.allocLen = codecBuffer.buffer[0].capacity;
1210     omxBuffer.bufferLen = codecBuffer.buffer[0].capacity;
1211 }
1212 }  // namespace Common
1213 }  // namespace Codec
1214 }  // namespace OHOS