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