projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blob
? search:


c282f24916030eb4e0b319d12e5805155139c2fb
[GitHub/LineageOS/android_hardware_samsung_slsi_openmax.git] / component / video / enc / mpeg4 / Exynos_OMX_Mpeg4enc.c
1 /*
2 *
3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 /*
19 * @file Exynos_OMX_Mpeg4enc.c
20 * @brief
21 * @author Yunji Kim (yunji.kim@samsung.com)
22 * @version 2.0.0
23 * @history
24 * 2012.02.20 : Create
25 */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "Exynos_OMX_Macros.h"
32 #include "Exynos_OMX_Basecomponent.h"
33 #include "Exynos_OMX_Baseport.h"
34 #include "Exynos_OMX_Venc.h"
35 #include "Exynos_OMX_VencControl.h"
36 #include "Exynos_OSAL_ETC.h"
37 #include "Exynos_OSAL_Semaphore.h"
38 #include "Exynos_OSAL_Thread.h"
39 #include "Exynos_OSAL_Android.h"
40 #include "library_register.h"
41 #include "Exynos_OMX_Mpeg4enc.h"
42 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Event.h"
44
45 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
46 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
47 #include "csc.h"
48
49 #undef EXYNOS_LOG_TAG
50 #define EXYNOS_LOG_TAG "EXYNOS_MPEG4_ENC"
51 #define EXYNOS_LOG_OFF
52 //#define EXYNOS_TRACE_ON
53 #include "Exynos_OSAL_Log.h"
54
55 /* MPEG4 Encoder Supported Levels & profiles */
56 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
57 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
58 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
59 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
60 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
61 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
62 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
63 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
64 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
65 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
66 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
67 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
68 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
69 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
70 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
71 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
72 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
73
74 /* H.263 Encoder Supported Levels & profiles */
75 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
76 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
77 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
78 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
79 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
80 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
81 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
82 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
83 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70}};
84
85 static OMX_U32 OMXMpeg4ProfileToMFCProfile(OMX_VIDEO_MPEG4PROFILETYPE profile)
86 {
87 OMX_U32 ret;
88
89 switch (profile) {
90 case OMX_VIDEO_MPEG4ProfileSimple:
91 ret = 0;
92 break;
93 case OMX_VIDEO_MPEG4ProfileAdvancedSimple:
94 ret = 1;
95 break;
96 default:
97 ret = 0;
98 };
99
100 return ret;
101 }
102
103 static OMX_U32 OMXMpeg4LevelToMFCLevel(OMX_VIDEO_MPEG4LEVELTYPE level)
104 {
105 OMX_U32 ret;
106
107 switch (level) {
108 case OMX_VIDEO_MPEG4Level0:
109 ret = 0;
110 break;
111 case OMX_VIDEO_MPEG4Level0b:
112 ret = 1;
113 break;
114 case OMX_VIDEO_MPEG4Level1:
115 ret = 2;
116 break;
117 case OMX_VIDEO_MPEG4Level2:
118 ret = 3;
119 break;
120 case OMX_VIDEO_MPEG4Level3:
121 ret = 4;
122 break;
123 case OMX_VIDEO_MPEG4Level4:
124 case OMX_VIDEO_MPEG4Level4a:
125 ret = 6;
126 break;
127 case OMX_VIDEO_MPEG4Level5:
128 ret = 7;
129 break;
130 default:
131 ret = 0;
132 };
133
134 return ret;
135 }
136
137 static void Print_Mpeg4Enc_Param(ExynosVideoEncParam *pEncParam)
138 {
139 ExynosVideoEncCommonParam *pCommonParam = &pEncParam->commonParam;
140 ExynosVideoEncMpeg4Param *pMpeg4Param = &pEncParam->codecParam.mpeg4;
141
142 /* common parameters */
143 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceWidth : %d", pCommonParam->SourceWidth);
144 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceHeight : %d", pCommonParam->SourceHeight);
145 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "IDRPeriod : %d", pCommonParam->IDRPeriod);
146 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceMode : %d", pCommonParam->SliceMode);
147 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh : %d", pCommonParam->RandomIntraMBRefresh);
148 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Bitrate : %d", pCommonParam->Bitrate);
149 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp : %d", pCommonParam->FrameQp);
150 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_P : %d", pCommonParam->FrameQp_P);
151 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMax : %d", pCommonParam->QSCodeMax);
152 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMin : %d", pCommonParam->QSCodeMin);
153 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PadControlOn : %d", pCommonParam->PadControlOn);
154 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LumaPadVal : %d", pCommonParam->LumaPadVal);
155 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CbPadVal : %d", pCommonParam->CbPadVal);
156 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CrPadVal : %d", pCommonParam->CrPadVal);
157 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameMap : %d", pCommonParam->FrameMap);
158
159 /* Mpeg4 specific parameters */
160 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "ProfileIDC : %d", pMpeg4Param->ProfileIDC);
161 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LevelIDC : %d", pMpeg4Param->LevelIDC);
162 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_B : %d", pMpeg4Param->FrameQp_B);
163 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "TimeIncreamentRes : %d", pMpeg4Param->TimeIncreamentRes);
164 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VopTimeIncreament : %d", pMpeg4Param->VopTimeIncreament);
165 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceArgument : %d", pMpeg4Param->SliceArgument);
166 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NumberBFrames : %d", pMpeg4Param->NumberBFrames);
167 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "DisableQpelME : %d", pMpeg4Param->DisableQpelME);
168
169 /* rate control related parameters */
170 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableFRMRateControl : %d", pCommonParam->EnableFRMRateControl);
171 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableMBRateControl : %d", pCommonParam->EnableMBRateControl);
172 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CBRPeriodRf : %d", pCommonParam->CBRPeriodRf);
173 }
174
175 static void Print_H263Enc_Param(ExynosVideoEncParam *pEncParam)
176 {
177 ExynosVideoEncCommonParam *pCommonParam = &pEncParam->commonParam;
178 ExynosVideoEncH263Param *pH263Param = &pEncParam->codecParam.h263;
179
180 /* common parameters */
181 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceWidth : %d", pCommonParam->SourceWidth);
182 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceHeight : %d", pCommonParam->SourceHeight);
183 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "IDRPeriod : %d", pCommonParam->IDRPeriod);
184 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceMode : %d", pCommonParam->SliceMode);
185 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh : %d", pCommonParam->RandomIntraMBRefresh);
186 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Bitrate : %d", pCommonParam->Bitrate);
187 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp : %d", pCommonParam->FrameQp);
188 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_P : %d", pCommonParam->FrameQp_P);
189 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMax : %d", pCommonParam->QSCodeMax);
190 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMin : %d", pCommonParam->QSCodeMin);
191 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PadControlOn : %d", pCommonParam->PadControlOn);
192 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LumaPadVal : %d", pCommonParam->LumaPadVal);
193 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CbPadVal : %d", pCommonParam->CbPadVal);
194 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CrPadVal : %d", pCommonParam->CrPadVal);
195 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameMap : %d", pCommonParam->FrameMap);
196
197 /* H263 specific parameters */
198 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameRate : %d", pH263Param->FrameRate);
199
200 /* rate control related parameters */
201 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableFRMRateControl : %d", pCommonParam->EnableFRMRateControl);
202 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableMBRateControl : %d", pCommonParam->EnableMBRateControl);
203 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CBRPeriodRf : %d", pCommonParam->CBRPeriodRf);
204 }
205
206 static void Set_Mpeg4Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
207 {
208 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
209 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
210 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
211 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
212 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = NULL;
213 ENCODE_CODEC_EXTRA_BUFFERINFO *pExtBufferInfo = NULL;
214
215 ExynosVideoEncParam *pEncParam = NULL;
216 ExynosVideoEncCommonParam *pCommonParam = NULL;
217 ExynosVideoEncMpeg4Param *pMpeg4Param = NULL;
218
219 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
220 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
221 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
222 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
223 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
224 pExtBufferInfo = (ENCODE_CODEC_EXTRA_BUFFERINFO *)pExynosInputPort->processData.extInfo;
225
226 pEncParam = &pMFCMpeg4Handle->encParam;
227 pCommonParam = &pEncParam->commonParam;
228 pMpeg4Param = &pEncParam->codecParam.mpeg4;
229 pEncParam->eCompressionFormat = VIDEO_CODING_MPEG4;
230 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "eCompressionFormat: %d", pEncParam->eCompressionFormat);
231
232 /* common parameters */
233 pCommonParam->SourceWidth = pExynosOutputPort->portDefinition.format.video.nFrameWidth;
234 pCommonParam->SourceHeight = pExynosOutputPort->portDefinition.format.video.nFrameHeight;
235 pCommonParam->IDRPeriod = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
236 pCommonParam->SliceMode = 0;
237 pCommonParam->Bitrate = pExynosOutputPort->portDefinition.format.video.nBitrate;
238 pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
239 pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
240 pCommonParam->QSCodeMax = 30;
241 pCommonParam->QSCodeMin = 10;
242 pCommonParam->PadControlOn = 0; /* 0: Use boundary pixel, 1: Use the below setting value */
243 pCommonParam->LumaPadVal = 0;
244 pCommonParam->CbPadVal = 0;
245 pCommonParam->CrPadVal = 0;
246
247 if (pVideoEnc->intraRefresh.eRefreshMode == OMX_VIDEO_IntraRefreshCyclic) {
248 /* Cyclic Mode */
249 pCommonParam->RandomIntraMBRefresh = pVideoEnc->intraRefresh.nCirMBs;
250 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh: %d", pCommonParam->RandomIntraMBRefresh);
251 } else {
252 /* Don't support "Adaptive" and "Cyclic + Adaptive" */
253 pCommonParam->RandomIntraMBRefresh = 0;
254 }
255
256 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "extInfo color = %x", pExtBufferInfo->eColorFormat);
257
258 switch (pExtBufferInfo->eColorFormat) {
259 case OMX_COLOR_FormatYUV420SemiPlanar:
260 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12;
261 break;
262 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV21Linear:
263 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV21;
264 break;
265 #ifdef USE_ENCODER_RGBINPUT_SUPPORT
266 case OMX_COLOR_FormatYUV420Planar:
267 pCommonParam->FrameMap = VIDEO_COLORFORMAT_I420;
268 break;
269 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatYVU420Planar:
270 pCommonParam->FrameMap = VIDEO_COLORFORMAT_YV12;
271 break;
272 case OMX_COLOR_Format32bitBGRA8888:
273 pCommonParam->FrameMap = VIDEO_COLORFORMAT_ARGB8888;
274 break;
275 #endif
276 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV12Tiled:
277 default:
278 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
279 break;
280 }
281
282 /* Mpeg4 specific parameters */
283 pMpeg4Param->ProfileIDC = OMXMpeg4ProfileToMFCProfile(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eProfile);
284 pMpeg4Param->LevelIDC = OMXMpeg4LevelToMFCLevel(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eLevel);
285 pMpeg4Param->FrameQp_B = pVideoEnc->quantization.nQpB;
286 pMpeg4Param->TimeIncreamentRes = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
287 pMpeg4Param->VopTimeIncreament = 1;
288 pMpeg4Param->SliceArgument = 0; /* MB number or byte number */
289 pMpeg4Param->NumberBFrames = 0; /* 0(not used) ~ 2 */
290 pMpeg4Param->DisableQpelME = 1;
291
292 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
293 /* rate control related parameters */
294 switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
295 case OMX_Video_ControlRateDisable:
296 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode DBR");
297 pCommonParam->EnableFRMRateControl = 0; /* 0: Disable, 1: Frame level RC */
298 pCommonParam->EnableMBRateControl = 0; /* 0: Disable, 1:MB level RC */
299 pCommonParam->CBRPeriodRf = 100;
300 break;
301 case OMX_Video_ControlRateConstant:
302 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode CBR");
303 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
304 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
305 pCommonParam->CBRPeriodRf = 9;
306 break;
307 case OMX_Video_ControlRateVariable:
308 default: /*Android default */
309 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
310 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
311 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
312 pCommonParam->CBRPeriodRf = 100;
313 break;
314 }
315
316 Print_Mpeg4Enc_Param(pEncParam);
317 }
318
319 static void Set_H263Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
320 {
321 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
322 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
323 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
324 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
325 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = NULL;
326 ENCODE_CODEC_EXTRA_BUFFERINFO *pExtBufferInfo = NULL;
327
328 ExynosVideoEncParam *pEncParam = NULL;
329 ExynosVideoEncCommonParam *pCommonParam = NULL;
330 ExynosVideoEncH263Param *pH263Param = NULL;
331
332 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
333 pMpeg4Enc = pVideoEnc->hCodecHandle;
334 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
335 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
336 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
337 pExtBufferInfo = (ENCODE_CODEC_EXTRA_BUFFERINFO *)pExynosInputPort->processData.extInfo;
338
339 pEncParam = &pMFCMpeg4Handle->encParam;
340 pCommonParam = &pEncParam->commonParam;
341 pH263Param = &pEncParam->codecParam.h263;
342 pEncParam->eCompressionFormat = VIDEO_CODING_H263;
343 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "eCompressionFormat: %d", pEncParam->eCompressionFormat);
344
345 /* common parameters */
346 pCommonParam->SourceWidth = pExynosOutputPort->portDefinition.format.video.nFrameWidth;
347 pCommonParam->SourceHeight = pExynosOutputPort->portDefinition.format.video.nFrameHeight;
348 pCommonParam->IDRPeriod = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
349 pCommonParam->SliceMode = 0;
350 pCommonParam->Bitrate = pExynosOutputPort->portDefinition.format.video.nBitrate;
351 pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
352 pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
353 pCommonParam->QSCodeMax = 30;
354 pCommonParam->QSCodeMin = 10;
355 pCommonParam->PadControlOn = 0; /* 0: Use boundary pixel, 1: Use the below setting value */
356 pCommonParam->LumaPadVal = 0;
357 pCommonParam->CbPadVal = 0;
358 pCommonParam->CrPadVal = 0;
359
360 if (pVideoEnc->intraRefresh.eRefreshMode == OMX_VIDEO_IntraRefreshCyclic) {
361 /* Cyclic Mode */
362 pCommonParam->RandomIntraMBRefresh = pVideoEnc->intraRefresh.nCirMBs;
363 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh: %d", pCommonParam->RandomIntraMBRefresh);
364 } else {
365 /* Don't support "Adaptive" and "Cyclic + Adaptive" */
366 pCommonParam->RandomIntraMBRefresh = 0;
367 }
368
369 switch (pExtBufferInfo->eColorFormat) {
370 case OMX_COLOR_FormatYUV420SemiPlanar:
371 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12;
372 break;
373 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV21Linear:
374 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV21;
375 break;
376 #ifdef USE_ENCODER_RGBINPUT_SUPPORT
377 case OMX_COLOR_FormatYUV420Planar:
378 pCommonParam->FrameMap = VIDEO_COLORFORMAT_I420;
379 break;
380 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatYVU420Planar:
381 pCommonParam->FrameMap = VIDEO_COLORFORMAT_YV12;
382 break;
383 case OMX_COLOR_Format32bitBGRA8888:
384 pCommonParam->FrameMap = VIDEO_COLORFORMAT_ARGB8888;
385 break;
386 #endif
387 case (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV12Tiled:
388 default:
389 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
390 break;
391 }
392
393 /* H263 specific parameters */
394 pH263Param->FrameRate = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
395
396 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
397 /* rate control related parameters */
398 switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
399 case OMX_Video_ControlRateDisable:
400 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode DBR");
401 pCommonParam->EnableFRMRateControl = 0; /* 0: Disable, 1: Frame level RC */
402 pCommonParam->EnableMBRateControl = 0; /* 0: Disable, 1:MB level RC */
403 pCommonParam->CBRPeriodRf = 100;
404 break;
405 case OMX_Video_ControlRateConstant:
406 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode CBR");
407 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
408 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
409 pCommonParam->CBRPeriodRf = 9;
410 break;
411 case OMX_Video_ControlRateVariable:
412 default: /*Android default */
413 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
414 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
415 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
416 pCommonParam->CBRPeriodRf = 100;
417 break;
418 }
419
420 Print_H263Enc_Param(pEncParam);
421 }
422
423 static void Change_Mpeg4Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
424 {
425 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
426 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
427 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
428 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
429 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
430
431 ExynosVideoEncOps *pEncOps = NULL;
432 ExynosVideoEncParam *pEncParam = NULL;
433 ExynosVideoEncCommonParam *pCommonParam = NULL;
434 ExynosVideoEncMpeg4Param *pMpeg4Param = NULL;
435
436 int setParam = 0;
437
438 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
439 pMpeg4Enc = pVideoEnc->hCodecHandle;
440 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
441 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
442 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
443 pEncOps = pMFCMpeg4Handle->pEncOps;
444
445 pEncParam = &pMFCMpeg4Handle->encParam;
446 pCommonParam = &pEncParam->commonParam;
447 pMpeg4Param = &pEncParam->codecParam.mpeg4;
448
449 if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
450 setParam = VIDEO_FRAME_I;
451 pEncOps->Set_FrameType(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
452 pVideoEnc->IntraRefreshVOP = OMX_FALSE;
453 }
454 if (pCommonParam->IDRPeriod != (int)pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
455 setParam = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
456 pEncOps->Set_IDRPeriod(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
457 }
458 if (pCommonParam->Bitrate != (int)pExynosOutputPort->portDefinition.format.video.nBitrate) {
459 setParam = pExynosOutputPort->portDefinition.format.video.nBitrate;
460 pEncOps->Set_BitRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
461 }
462 if (pMpeg4Param->TimeIncreamentRes != (int)((pExynosInputPort->portDefinition.format.video.xFramerate) >> 16)) {
463 setParam = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
464 pEncOps->Set_FrameRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
465 }
466
467 Set_Mpeg4Enc_Param(pExynosComponent);
468 }
469
470 static void Change_H263Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
471 {
472 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
473 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
474 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
475 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
476 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
477
478 ExynosVideoEncOps *pEncOps = NULL;
479 ExynosVideoEncParam *pEncParam = NULL;
480 ExynosVideoEncCommonParam *pCommonParam = NULL;
481 ExynosVideoEncH263Param *pH263Param = NULL;
482
483 int setParam = 0;
484
485 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
486 pMpeg4Enc = pVideoEnc->hCodecHandle;
487 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
488 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
489 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
490 pEncOps = pMFCMpeg4Handle->pEncOps;
491
492 pEncParam = &pMFCMpeg4Handle->encParam;
493 pCommonParam = &pEncParam->commonParam;
494 pH263Param = &pEncParam->codecParam.h263;
495
496 if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
497 setParam = VIDEO_FRAME_I;
498 pEncOps->Set_FrameType(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
499 pVideoEnc->IntraRefreshVOP = OMX_FALSE;
500 }
501 if (pCommonParam->IDRPeriod != (int)pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
502 setParam = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
503 pEncOps->Set_IDRPeriod(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
504 }
505 if (pCommonParam->Bitrate != (int)pExynosOutputPort->portDefinition.format.video.nBitrate) {
506 setParam = pExynosOutputPort->portDefinition.format.video.nBitrate;
507 pEncOps->Set_BitRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
508 }
509 if (pH263Param->FrameRate != (int)((pExynosInputPort->portDefinition.format.video.xFramerate) >> 16)) {
510 setParam = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
511 pEncOps->Set_FrameRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
512 }
513
514 Set_H263Enc_Param(pExynosComponent);
515 }
516
517 OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
518 {
519 OMX_ERRORTYPE ret = OMX_ErrorNone;
520
521 EXIT:
522 return ret;
523 }
524
525 OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR *pVirtAddr, OMX_U32 *dataSize)
526 {
527 OMX_ERRORTYPE ret = OMX_ErrorNone;
528 ExynosVideoBuffer *pCodecBuffer;
529
530 if (codecBuffer == NULL) {
531 ret = OMX_ErrorBadParameter;
532 goto EXIT;
533 }
534
535 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
536
537 if (pVirtAddr != NULL)
538 *pVirtAddr = pCodecBuffer->planes[0].addr;
539
540 if (dataSize != NULL)
541 *dataSize = pCodecBuffer->planes[0].allocSize;
542
543 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
544
545 EXIT:
546 return ret;
547 }
548
549 OMX_ERRORTYPE Mpeg4CodecOpen(EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc)
550 {
551 OMX_ERRORTYPE ret = OMX_ErrorNone;
552
553 ExynosVideoEncOps *pEncOps = NULL;
554 ExynosVideoEncBufferOps *pInbufOps = NULL;
555 ExynosVideoEncBufferOps *pOutbufOps = NULL;
556
557 FunctionIn();
558
559 if (pMpeg4Enc == NULL) {
560 ret = OMX_ErrorBadParameter;
561 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
562 goto EXIT;
563 }
564
565 /* alloc ops structure */
566 pEncOps = (ExynosVideoEncOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncOps));
567 pInbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
568 pOutbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
569
570 if ((pEncOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
571 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate encoder ops buffer");
572 ret = OMX_ErrorInsufficientResources;
573 goto EXIT;
574 }
575
576 pMpeg4Enc->hMFCMpeg4Handle.pEncOps = pEncOps;
577 pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = pInbufOps;
578 pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = pOutbufOps;
579
580 /* function pointer mapping */
581 pEncOps->nSize = sizeof(ExynosVideoEncOps);
582 pInbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
583 pOutbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
584
585 Exynos_Video_Register_Encoder(pEncOps, pInbufOps, pOutbufOps);
586
587 /* check mandatory functions for encoder ops */
588 if ((pEncOps->Init == NULL) || (pEncOps->Finalize == NULL) ||
589 (pEncOps->Set_FrameTag == NULL) || (pEncOps->Get_FrameTag == NULL)) {
590 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
591 ret = OMX_ErrorInsufficientResources;
592 goto EXIT;
593 }
594
595 /* check mandatory functions for buffer ops */
596 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
597 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
598 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
599 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
600 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
601 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
602 ret = OMX_ErrorInsufficientResources;
603 goto EXIT;
604 }
605
606 /* alloc context, open, querycap */
607 #ifdef USE_DMA_BUF
608 pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.pEncOps->Init(V4L2_MEMORY_DMABUF);
609 #else
610 pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.pEncOps->Init(V4L2_MEMORY_USERPTR);
611 #endif
612 if (pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle == NULL) {
613 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
614 ret = OMX_ErrorInsufficientResources;
615 goto EXIT;
616 }
617
618 ret = OMX_ErrorNone;
619
620 EXIT:
621 if (ret != OMX_ErrorNone) {
622 if (pEncOps != NULL) {
623 Exynos_OSAL_Free(pEncOps);
624 pMpeg4Enc->hMFCMpeg4Handle.pEncOps = NULL;
625 }
626 if (pInbufOps != NULL) {
627 Exynos_OSAL_Free(pInbufOps);
628 pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = NULL;
629 }
630 if (pOutbufOps != NULL) {
631 Exynos_OSAL_Free(pOutbufOps);
632 pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = NULL;
633 }
634 }
635
636 FunctionOut();
637
638 return ret;
639 }
640
641 OMX_ERRORTYPE Mpeg4CodecClose(EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc)
642 {
643 OMX_ERRORTYPE ret = OMX_ErrorNone;
644 void *hMFCHandle = NULL;
645 ExynosVideoEncOps *pEncOps = NULL;
646 ExynosVideoEncBufferOps *pInbufOps = NULL;
647 ExynosVideoEncBufferOps *pOutbufOps = NULL;
648
649 FunctionIn();
650
651 if (pMpeg4Enc == NULL) {
652 ret = OMX_ErrorBadParameter;
653 goto EXIT;
654 }
655
656 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
657 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
658 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
659 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
660
661 if (hMFCHandle != NULL) {
662 pEncOps->Finalize(hMFCHandle);
663 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = NULL;
664 }
665 if (pOutbufOps != NULL) {
666 Exynos_OSAL_Free(pOutbufOps);
667 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = NULL;
668 }
669 if (pInbufOps != NULL) {
670 Exynos_OSAL_Free(pInbufOps);
671 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = NULL;
672 }
673 if (pEncOps != NULL) {
674 Exynos_OSAL_Free(pEncOps);
675 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps = NULL;
676 }
677
678 ret = OMX_ErrorNone;
679
680 EXIT:
681 FunctionOut();
682
683 return ret;
684 }
685
686 OMX_ERRORTYPE Mpeg4CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
687 {
688 OMX_ERRORTYPE ret = OMX_ErrorNone;
689 void *hMFCHandle = NULL;
690 ExynosVideoEncOps *pEncOps = NULL;
691 ExynosVideoEncBufferOps *pInbufOps = NULL;
692 ExynosVideoEncBufferOps *pOutbufOps = NULL;
693 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
694 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
695
696 FunctionIn();
697
698 if (pOMXComponent == NULL) {
699 ret = OMX_ErrorBadParameter;
700 goto EXIT;
701 }
702
703 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
704 if (pVideoEnc == NULL) {
705 ret = OMX_ErrorBadParameter;
706 goto EXIT;
707 }
708
709 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
710 if (pMpeg4Enc == NULL) {
711 ret = OMX_ErrorBadParameter;
712 goto EXIT;
713 }
714
715 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
716 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
717 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
718 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
719
720 if (nPortIndex == INPUT_PORT_INDEX)
721 pInbufOps->Run(hMFCHandle);
722 else if (nPortIndex == OUTPUT_PORT_INDEX)
723 pOutbufOps->Run(hMFCHandle);
724
725 ret = OMX_ErrorNone;
726
727 EXIT:
728 FunctionOut();
729
730 return ret;
731 }
732
733 OMX_ERRORTYPE Mpeg4CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
734 {
735 OMX_ERRORTYPE ret = OMX_ErrorNone;
736 void *hMFCHandle = NULL;
737 ExynosVideoEncOps *pEncOps = NULL;
738 ExynosVideoEncBufferOps *pInbufOps = NULL;
739 ExynosVideoEncBufferOps *pOutbufOps = NULL;
740 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
741 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
742
743 FunctionIn();
744
745 if (pOMXComponent == NULL) {
746 ret = OMX_ErrorBadParameter;
747 goto EXIT;
748 }
749
750 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
751 if (pVideoEnc == NULL) {
752 ret = OMX_ErrorBadParameter;
753 goto EXIT;
754 }
755 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
756 if (pMpeg4Enc == NULL) {
757 ret = OMX_ErrorBadParameter;
758 goto EXIT;
759 }
760
761 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
762 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
763 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
764 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
765
766 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
767 pInbufOps->Stop(hMFCHandle);
768 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
769 pOutbufOps->Stop(hMFCHandle);
770
771 ret = OMX_ErrorNone;
772
773 EXIT:
774 FunctionOut();
775
776 return ret;
777 }
778
779 OMX_ERRORTYPE Mpeg4CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
780 {
781 OMX_ERRORTYPE ret = OMX_ErrorNone;
782 void *hMFCHandle = NULL;
783 ExynosVideoEncOps *pEncOps = NULL;
784 ExynosVideoEncBufferOps *pInbufOps = NULL;
785 ExynosVideoEncBufferOps *pOutbufOps = NULL;
786 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
787 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
788
789 FunctionIn();
790
791 if (pOMXComponent == NULL) {
792 ret = OMX_ErrorBadParameter;
793 goto EXIT;
794 }
795
796 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
797 if (pVideoEnc == NULL) {
798 ret = OMX_ErrorBadParameter;
799 goto EXIT;
800 }
801 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
802 if (pMpeg4Enc == NULL) {
803 ret = OMX_ErrorBadParameter;
804 goto EXIT;
805 }
806
807 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
808 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
809 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
810 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
811
812 if (nPortIndex == INPUT_PORT_INDEX) {
813 if (pMpeg4Enc->bSourceStart == OMX_FALSE) {
814 Exynos_OSAL_SignalSet(pMpeg4Enc->hSourceStartEvent);
815 Exynos_OSAL_SleepMillisec(0);
816 }
817 }
818
819 if (nPortIndex == OUTPUT_PORT_INDEX) {
820 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
821 Exynos_OSAL_SignalSet(pMpeg4Enc->hDestinationStartEvent);
822 Exynos_OSAL_SleepMillisec(0);
823 }
824 }
825
826 ret = OMX_ErrorNone;
827
828 EXIT:
829 FunctionOut();
830
831 return ret;
832 }
833
834 OMX_ERRORTYPE Mpeg4CodecRegistCodecBuffers(
835 OMX_COMPONENTTYPE *pOMXComponent,
836 OMX_U32 nPortIndex,
837 OMX_U32 nBufferCnt)
838 {
839 OMX_ERRORTYPE ret = OMX_ErrorNone;
840 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
841 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
842 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
843 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
844 CODEC_ENC_BUFFER **ppCodecBuffer = NULL;
845 ExynosVideoEncBufferOps *pBufOps = NULL;
846 ExynosVideoPlane *pPlanes = NULL;
847
848 OMX_U32 nPlaneCnt = 0;
849 int i, j;
850
851 FunctionIn();
852
853 if (nPortIndex == INPUT_PORT_INDEX) {
854 ppCodecBuffer = &(pVideoEnc->pMFCEncInputBuffer[0]);
855 pBufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
856 } else {
857 ppCodecBuffer = &(pVideoEnc->pMFCEncOutputBuffer[0]);
858 pBufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
859 }
860 nPlaneCnt = pExynosComponent->pExynosPort[nPortIndex].nPlaneCnt;
861
862 pPlanes = (ExynosVideoPlane *)Exynos_OSAL_Malloc(sizeof(ExynosVideoPlane) * nPlaneCnt);
863 if (pPlanes == NULL) {
864 ret = OMX_ErrorInsufficientResources;
865 goto EXIT;
866 }
867
868 /* Register buffer */
869 for (i = 0; i < nBufferCnt; i++) {
870 for (j = 0; j < nPlaneCnt; j++) {
871 pPlanes[j].addr = ppCodecBuffer[i]->pVirAddr[j];
872 pPlanes[j].fd = ppCodecBuffer[i]->fd[j];
873 pPlanes[j].allocSize = ppCodecBuffer[i]->bufferSize[j];
874 }
875
876 if (pBufOps->Register(hMFCHandle, pPlanes, nPlaneCnt) != VIDEO_ERROR_NONE) {
877 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "PORT[%d]: Failed to Register buffer", nPortIndex);
878 ret = OMX_ErrorInsufficientResources;
879 Exynos_OSAL_Free(pPlanes);
880 goto EXIT;
881 }
882 }
883
884 Exynos_OSAL_Free(pPlanes);
885
886 ret = OMX_ErrorNone;
887
888 EXIT:
889 FunctionOut();
890
891 return ret;
892 }
893
894 OMX_ERRORTYPE Mpeg4CodecEnqueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
895 {
896 OMX_ERRORTYPE ret = OMX_ErrorNone;
897 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
898 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
899 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
900 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
901 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
902 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
903 int i, nOutbufs;
904
905 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
906 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
907 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
908
909 FunctionIn();
910
911 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
912 ret = OMX_ErrorBadPortIndex;
913 goto EXIT;
914 }
915
916 if ((nPortIndex == INPUT_PORT_INDEX) &&
917 (pMpeg4Enc->bSourceStart == OMX_TRUE)) {
918 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
919
920 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
921 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
922 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
923 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
924
925 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
926 }
927
928 pInbufOps->Clear_Queue(hMFCHandle);
929 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
930 (pMpeg4Enc->bDestinationStart == OMX_TRUE)) {
931 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
932
933 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
934 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncOutputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncOutputBuffer[i]);
935 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
936
937 Exynos_CodecBufferEnqueue(pExynosComponent, OUTPUT_PORT_INDEX, pVideoEnc->pMFCEncOutputBuffer[i]);
938 }
939
940 pOutbufOps->Clear_Queue(hMFCHandle);
941 }
942
943 EXIT:
944 FunctionOut();
945
946 return ret;
947 }
948
949 OMX_ERRORTYPE Mpeg4CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
950 {
951 OMX_ERRORTYPE ret = OMX_ErrorNone;
952 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
953 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
954 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
955 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
956 void *hMFCHandle = pMFCMpeg4Handle->hMFCHandle;
957 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
958 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
959 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
960
961 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
962 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
963 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
964 ExynosVideoEncParam *pEncParam = NULL;
965
966 ExynosVideoGeometry bufferConf;
967 OMX_U32 inputBufferNumber = 0;
968 int i, nOutbufs;
969
970 FunctionIn();
971
972 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
973 BYPASS_BUFFER_INFO *pBufferInfo = (BYPASS_BUFFER_INFO *)Exynos_OSAL_Malloc(sizeof(BYPASS_BUFFER_INFO));
974 if (pBufferInfo == NULL) {
975 ret = OMX_ErrorInsufficientResources;
976 goto EXIT;
977 }
978
979 pBufferInfo->nFlags = pSrcInputData->nFlags;
980 pBufferInfo->timeStamp = pSrcInputData->timeStamp;
981 ret = Exynos_OSAL_Queue(&pMpeg4Enc->bypassBufferInfoQ, (void *)pBufferInfo);
982 Exynos_OSAL_SignalSet(pMpeg4Enc->hDestinationStartEvent);
983
984 ret = OMX_ErrorNone;
985 goto EXIT;
986 }
987
988 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
989 Set_Mpeg4Enc_Param(pExynosComponent);
990 else
991 Set_H263Enc_Param(pExynosComponent);
992
993 pEncParam = &pMFCMpeg4Handle->encParam;
994 if (pEncOps->Set_EncParam) {
995 if(pEncOps->Set_EncParam(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, pEncParam) != VIDEO_ERROR_NONE) {
996 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
997 ret = OMX_ErrorInsufficientResources;
998 goto EXIT;
999 }
1000 }
1001
1002 /* input buffer info: only 3 config values needed */
1003 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1004 bufferConf.eColorFormat = pEncParam->commonParam.FrameMap;
1005 bufferConf.nFrameWidth = pExynosInputPort->portDefinition.format.video.nFrameWidth;
1006 bufferConf.nFrameHeight = pExynosInputPort->portDefinition.format.video.nFrameHeight;
1007 bufferConf.nPlaneCnt = pExynosInputPort->nPlaneCnt;
1008 pInbufOps->Set_Shareable(hMFCHandle);
1009 inputBufferNumber = MAX_INPUTBUFFER_NUM_DYNAMIC;
1010
1011 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1012 /* should be done before prepare input buffer */
1013 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1014 ret = OMX_ErrorInsufficientResources;
1015 goto EXIT;
1016 }
1017 }
1018
1019 /* set input buffer geometry */
1020 if (pInbufOps->Set_Geometry) {
1021 if (pInbufOps->Set_Geometry(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1022 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
1023 ret = OMX_ErrorInsufficientResources;
1024 goto EXIT;
1025 }
1026 }
1027
1028 /* setup input buffer */
1029 if (pInbufOps->Setup(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
1030 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
1031 ret = OMX_ErrorInsufficientResources;
1032 goto EXIT;
1033 }
1034
1035 if ((pExynosInputPort->bufferProcessType & BUFFER_SHARE) &&
1036 (pExynosInputPort->bStoreMetaData != OMX_TRUE)) {
1037 ret = OMX_ErrorNotImplemented;
1038 goto EXIT;
1039 }
1040
1041 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
1042 ret = OMX_ErrorNone;
1043
1044 EXIT:
1045 FunctionOut();
1046
1047 return ret;
1048 }
1049
1050 OMX_ERRORTYPE Mpeg4CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1051 {
1052 OMX_ERRORTYPE ret = OMX_ErrorNone;
1053 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1054 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1055 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1056 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
1057 void *hMFCHandle = pMFCMpeg4Handle->hMFCHandle;
1058 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1059 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1060
1061 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1062 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1063 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1064 ExynosVideoGeometry bufferConf;
1065 int i, nOutbufs;
1066
1067 FunctionIn();
1068
1069 int OutBufferSize = pExynosOutputPort->portDefinition.nBufferSize;
1070
1071 /* set geometry for output (dst) */
1072 if (pOutbufOps->Set_Geometry) {
1073 /* only 2 config values needed */
1074 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1075 bufferConf.eCompressionFormat = VIDEO_CODING_MPEG4;
1076 else
1077 bufferConf.eCompressionFormat = VIDEO_CODING_H263;
1078 bufferConf.nSizeImage = OutBufferSize;
1079 bufferConf.nPlaneCnt = pExynosOutputPort->nPlaneCnt;
1080
1081 if (pOutbufOps->Set_Geometry(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1082 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1083 ret = OMX_ErrorInsufficientResources;
1084 goto EXIT;
1085 }
1086 }
1087
1088 /* should be done before prepare output buffer */
1089 if (pOutbufOps->Enable_Cacheable) {
1090 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1091 ret = OMX_ErrorInsufficientResources;
1092 goto EXIT;
1093 }
1094 }
1095
1096 if (pOutbufOps->Set_Shareable) {
1097 pOutbufOps->Set_Shareable(hMFCHandle);
1098 }
1099 int SetupBufferNumber = 0;
1100 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY)
1101 SetupBufferNumber = MFC_OUTPUT_BUFFER_NUM_MAX;
1102 else
1103 SetupBufferNumber = pExynosOutputPort->portDefinition.nBufferCountActual;
1104 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SetupBufferNumber:%d", SetupBufferNumber);
1105
1106 if (pOutbufOps->Setup(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, SetupBufferNumber) != VIDEO_ERROR_NONE) {
1107 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1108 ret = OMX_ErrorInsufficientResources;
1109 goto EXIT;
1110 }
1111
1112 OMX_U32 dataLen[VIDEO_BUFFER_MAX_PLANES] = {0, 0, 0};
1113 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1114 OMX_U32 nPlaneSize[VIDEO_BUFFER_MAX_PLANES] = {0, 0, 0};
1115 nPlaneSize[0] = OutBufferSize;
1116 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX, MFC_OUTPUT_BUFFER_NUM_MAX, nPlaneSize);
1117 if (ret != OMX_ErrorNone)
1118 goto EXIT;
1119
1120 /* Enqueue output buffer */
1121 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1122 pOutbufOps->ExtensionEnqueue(hMFCHandle,
1123 (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr,
1124 (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->fd,
1125 (unsigned int *)pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize,
1126 (unsigned int *)dataLen, pExynosOutputPort->nPlaneCnt, NULL);
1127 }
1128
1129 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1130 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1131 ret = OMX_ErrorInsufficientResources;
1132 goto EXIT;
1133 }
1134 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1135 /* Register output buffer */
1136 /*************/
1137 /* TBD */
1138 /*************/
1139 }
1140 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1141
1142 ret = OMX_ErrorNone;
1143
1144 EXIT:
1145 FunctionOut();
1146
1147 return ret;
1148 }
1149
1150 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetParameter(
1151 OMX_IN OMX_HANDLETYPE hComponent,
1152 OMX_IN OMX_INDEXTYPE nParamIndex,
1153 OMX_INOUT OMX_PTR pComponentParameterStructure)
1154 {
1155 OMX_ERRORTYPE ret = OMX_ErrorNone;
1156 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1157 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1158
1159 FunctionIn();
1160
1161 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1162 ret = OMX_ErrorBadParameter;
1163 goto EXIT;
1164 }
1165 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1166 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1167 if (ret != OMX_ErrorNone) {
1168 goto EXIT;
1169 }
1170 if (pOMXComponent->pComponentPrivate == NULL) {
1171 ret = OMX_ErrorBadParameter;
1172 goto EXIT;
1173 }
1174
1175 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1176 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1177 ret = OMX_ErrorInvalidState;
1178 goto EXIT;
1179 }
1180
1181 switch (nParamIndex) {
1182 case OMX_IndexParamVideoMpeg4:
1183 {
1184 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1185 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = NULL;
1186 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1187
1188 ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1189 if (ret != OMX_ErrorNone) {
1190 goto EXIT;
1191 }
1192
1193 if (pDstMpeg4Component->nPortIndex >= ALL_PORT_NUM) {
1194 ret = OMX_ErrorBadPortIndex;
1195 goto EXIT;
1196 }
1197
1198 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1199 pSrcMpeg4Component = &pMpeg4Enc->mpeg4Component[pDstMpeg4Component->nPortIndex];
1200
1201 Exynos_OSAL_Memcpy(pDstMpeg4Component, pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1202 }
1203 break;
1204 case OMX_IndexParamVideoH263:
1205 {
1206 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1207 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = NULL;
1208 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1209
1210 ret = Exynos_OMX_Check_SizeVersion(pDstH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1211 if (ret != OMX_ErrorNone) {
1212 goto EXIT;
1213 }
1214
1215 if (pDstH263Component->nPortIndex >= ALL_PORT_NUM) {
1216 ret = OMX_ErrorBadPortIndex;
1217 goto EXIT;
1218 }
1219
1220 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1221 pSrcH263Component = &pMpeg4Enc->h263Component[pDstH263Component->nPortIndex];
1222
1223 Exynos_OSAL_Memcpy(pDstH263Component, pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1224 }
1225 break;
1226 case OMX_IndexParamStandardComponentRole:
1227 {
1228 OMX_S32 codecType;
1229 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1230 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1231 if (ret != OMX_ErrorNone) {
1232 goto EXIT;
1233 }
1234
1235 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1236 if (codecType == CODEC_TYPE_MPEG4)
1237 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE);
1238 else
1239 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE);
1240 }
1241 break;
1242 case OMX_IndexParamVideoProfileLevelQuerySupported:
1243 {
1244 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1245 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1246 OMX_U32 maxProfileLevelNum = 0;
1247 OMX_S32 codecType;
1248
1249 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1250 if (ret != OMX_ErrorNone) {
1251 goto EXIT;
1252 }
1253
1254 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1255 ret = OMX_ErrorBadPortIndex;
1256 goto EXIT;
1257 }
1258
1259 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1260 if (codecType == CODEC_TYPE_MPEG4) {
1261 pProfileLevel = supportedMPEG4ProfileLevels;
1262 maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1263 } else {
1264 pProfileLevel = supportedH263ProfileLevels;
1265 maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1266 }
1267
1268 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1269 ret = OMX_ErrorNoMore;
1270 goto EXIT;
1271 }
1272
1273 pProfileLevel += pDstProfileLevel->nProfileIndex;
1274 pDstProfileLevel->eProfile = pProfileLevel->profile;
1275 pDstProfileLevel->eLevel = pProfileLevel->level;
1276 }
1277 break;
1278 case OMX_IndexParamVideoProfileLevelCurrent:
1279 {
1280 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1281 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = NULL;
1282 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = NULL;
1283 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1284 OMX_S32 codecType;
1285
1286 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1287 if (ret != OMX_ErrorNone) {
1288 goto EXIT;
1289 }
1290
1291 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1292 ret = OMX_ErrorBadPortIndex;
1293 goto EXIT;
1294 }
1295
1296 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1297 codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
1298 if (codecType == CODEC_TYPE_MPEG4) {
1299 pSrcMpeg4Component = &pMpeg4Enc->mpeg4Component[pDstProfileLevel->nPortIndex];
1300 pDstProfileLevel->eProfile = pSrcMpeg4Component->eProfile;
1301 pDstProfileLevel->eLevel = pSrcMpeg4Component->eLevel;
1302 } else {
1303 pSrcH263Component = &pMpeg4Enc->h263Component[pDstProfileLevel->nPortIndex];
1304 pDstProfileLevel->eProfile = pSrcH263Component->eProfile;
1305 pDstProfileLevel->eLevel = pSrcH263Component->eLevel;
1306 }
1307 }
1308 break;
1309 case OMX_IndexParamVideoErrorCorrection:
1310 {
1311 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1312 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1313 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1314
1315 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1316 if (ret != OMX_ErrorNone) {
1317 goto EXIT;
1318 }
1319
1320 if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1321 ret = OMX_ErrorBadPortIndex;
1322 goto EXIT;
1323 }
1324
1325 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1326 pSrcErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1327
1328 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1329 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1330 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1331 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1332 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1333 }
1334 break;
1335 default:
1336 ret = Exynos_OMX_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1337 break;
1338 }
1339 EXIT:
1340 FunctionOut();
1341
1342 return ret;
1343 }
1344
1345 OMX_ERRORTYPE Exynos_Mpeg4Enc_SetParameter(
1346 OMX_IN OMX_HANDLETYPE hComponent,
1347 OMX_IN OMX_INDEXTYPE nIndex,
1348 OMX_IN OMX_PTR pComponentParameterStructure)
1349 {
1350 OMX_ERRORTYPE ret = OMX_ErrorNone;
1351 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1352 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1353
1354 FunctionIn();
1355
1356 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1357 ret = OMX_ErrorBadParameter;
1358 goto EXIT;
1359 }
1360 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1361 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1362 if (ret != OMX_ErrorNone) {
1363 goto EXIT;
1364 }
1365 if (pOMXComponent->pComponentPrivate == NULL) {
1366 ret = OMX_ErrorBadParameter;
1367 goto EXIT;
1368 }
1369
1370 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1371 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1372 ret = OMX_ErrorInvalidState;
1373 goto EXIT;
1374 }
1375
1376 switch (nIndex) {
1377 case OMX_IndexParamVideoMpeg4:
1378 {
1379 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = NULL;
1380 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1381 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1382
1383 ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1384 if (ret != OMX_ErrorNone) {
1385 goto EXIT;
1386 }
1387
1388 if (pSrcMpeg4Component->nPortIndex >= ALL_PORT_NUM) {
1389 ret = OMX_ErrorBadPortIndex;
1390 goto EXIT;
1391 }
1392
1393 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1394 pDstMpeg4Component = &pMpeg4Enc->mpeg4Component[pSrcMpeg4Component->nPortIndex];
1395
1396 Exynos_OSAL_Memcpy(pDstMpeg4Component, pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1397 }
1398 break;
1399 case OMX_IndexParamVideoH263:
1400 {
1401 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = NULL;
1402 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1403 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1404
1405 ret = Exynos_OMX_Check_SizeVersion(pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1406 if (ret != OMX_ErrorNone) {
1407 goto EXIT;
1408 }
1409
1410 if (pSrcH263Component->nPortIndex >= ALL_PORT_NUM) {
1411 ret = OMX_ErrorBadPortIndex;
1412 goto EXIT;
1413 }
1414
1415 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1416 pDstH263Component = &pMpeg4Enc->h263Component[pSrcH263Component->nPortIndex];
1417
1418 Exynos_OSAL_Memcpy(pDstH263Component, pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1419 }
1420 break;
1421 case OMX_IndexParamStandardComponentRole:
1422 {
1423 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1424
1425 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1426 if (ret != OMX_ErrorNone) {
1427 goto EXIT;
1428 }
1429
1430 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1431 ret = OMX_ErrorIncorrectStateOperation;
1432 goto EXIT;
1433 }
1434
1435 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE)) {
1436 pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1437 //((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_MPEG4;
1438 } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE)) {
1439 pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1440 //((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_H263;
1441 } else {
1442 ret = OMX_ErrorBadParameter;
1443 goto EXIT;
1444 }
1445 }
1446 break;
1447 case OMX_IndexParamVideoProfileLevelCurrent:
1448 {
1449 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1450 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = NULL;
1451 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = NULL;
1452 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1453 OMX_S32 codecType;
1454
1455 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1456 if (ret != OMX_ErrorNone)
1457 goto EXIT;
1458
1459 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1460 ret = OMX_ErrorBadPortIndex;
1461 goto EXIT;
1462 }
1463
1464 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1465 codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
1466 if (codecType == CODEC_TYPE_MPEG4) {
1467 /*
1468 * To do: Check validity of profile & level parameters
1469 */
1470
1471 pDstMpeg4Component = &pMpeg4Enc->mpeg4Component[pSrcProfileLevel->nPortIndex];
1472 pDstMpeg4Component->eProfile = pSrcProfileLevel->eProfile;
1473 pDstMpeg4Component->eLevel = pSrcProfileLevel->eLevel;
1474 } else {
1475 /*
1476 * To do: Check validity of profile & level parameters
1477 */
1478
1479 pDstH263Component = &pMpeg4Enc->h263Component[pSrcProfileLevel->nPortIndex];
1480 pDstH263Component->eProfile = pSrcProfileLevel->eProfile;
1481 pDstH263Component->eLevel = pSrcProfileLevel->eLevel;
1482 }
1483 }
1484 break;
1485 case OMX_IndexParamVideoErrorCorrection:
1486 {
1487 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1488 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1489 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1490
1491 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1492 if (ret != OMX_ErrorNone) {
1493 goto EXIT;
1494 }
1495
1496 if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1497 ret = OMX_ErrorBadPortIndex;
1498 goto EXIT;
1499 }
1500
1501 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1502 pDstErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1503
1504 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1505 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1506 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1507 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1508 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1509 }
1510 break;
1511 default:
1512 ret = Exynos_OMX_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1513 break;
1514 }
1515 EXIT:
1516 FunctionOut();
1517
1518 return ret;
1519 }
1520
1521 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetConfig(
1522 OMX_IN OMX_HANDLETYPE hComponent,
1523 OMX_IN OMX_INDEXTYPE nIndex,
1524 OMX_IN OMX_PTR pComponentConfigStructure)
1525 {
1526 OMX_ERRORTYPE ret = OMX_ErrorNone;
1527 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1528 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1529
1530 FunctionIn();
1531
1532 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1533 ret = OMX_ErrorBadParameter;
1534 goto EXIT;
1535 }
1536 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1537 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1538 if (ret != OMX_ErrorNone) {
1539 goto EXIT;
1540 }
1541 if (pOMXComponent->pComponentPrivate == NULL) {
1542 ret = OMX_ErrorBadParameter;
1543 goto EXIT;
1544 }
1545 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1546 if (pExynosComponent->currentState == OMX_StateInvalid) {
1547 ret = OMX_ErrorInvalidState;
1548 goto EXIT;
1549 }
1550
1551 switch (nIndex) {
1552 default:
1553 ret = Exynos_OMX_VideoEncodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1554 break;
1555 }
1556
1557 EXIT:
1558 FunctionOut();
1559
1560 return ret;
1561 }
1562
1563 OMX_ERRORTYPE Exynos_Mpeg4Enc_SetConfig(
1564 OMX_IN OMX_HANDLETYPE hComponent,
1565 OMX_IN OMX_INDEXTYPE nIndex,
1566 OMX_IN OMX_PTR pComponentConfigStructure)
1567 {
1568 OMX_ERRORTYPE ret = OMX_ErrorNone;
1569 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1570 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1571 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1572 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1573
1574 FunctionIn();
1575
1576 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1577 ret = OMX_ErrorBadParameter;
1578 goto EXIT;
1579 }
1580 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1581 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1582 if (ret != OMX_ErrorNone) {
1583 goto EXIT;
1584 }
1585 if (pOMXComponent->pComponentPrivate == NULL) {
1586 ret = OMX_ErrorBadParameter;
1587 goto EXIT;
1588 }
1589 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1590 if (pExynosComponent->currentState == OMX_StateInvalid) {
1591 ret = OMX_ErrorInvalidState;
1592 goto EXIT;
1593 }
1594
1595 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1596 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
1597
1598 switch (nIndex) {
1599 case OMX_IndexConfigVideoIntraPeriod:
1600 {
1601 OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
1602
1603 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1604 pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1605 else
1606 pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1607
1608 ret = OMX_ErrorNone;
1609 }
1610 break;
1611 default:
1612 ret = Exynos_OMX_VideoEncodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1613 break;
1614 }
1615
1616 EXIT:
1617 if (ret == OMX_ErrorNone)
1618 pVideoEnc->configChange = OMX_TRUE;
1619
1620 FunctionOut();
1621
1622 return ret;
1623 }
1624
1625 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetExtensionIndex(
1626 OMX_IN OMX_HANDLETYPE hComponent,
1627 OMX_IN OMX_STRING cParameterName,
1628 OMX_OUT OMX_INDEXTYPE *pIndexType)
1629 {
1630 OMX_ERRORTYPE ret = OMX_ErrorNone;
1631 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1632 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1633
1634 FunctionIn();
1635
1636 if (hComponent == NULL) {
1637 ret = OMX_ErrorBadParameter;
1638 goto EXIT;
1639 }
1640 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1641 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1642 if (ret != OMX_ErrorNone) {
1643 goto EXIT;
1644 }
1645 if (pOMXComponent->pComponentPrivate == NULL) {
1646 ret = OMX_ErrorBadParameter;
1647 goto EXIT;
1648 }
1649 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1650 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1651 ret = OMX_ErrorBadParameter;
1652 goto EXIT;
1653 }
1654 if (pExynosComponent->currentState == OMX_StateInvalid) {
1655 ret = OMX_ErrorInvalidState;
1656 goto EXIT;
1657 }
1658 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
1659 *pIndexType = OMX_IndexConfigVideoIntraPeriod;
1660 ret = OMX_ErrorNone;
1661 } else {
1662 ret = Exynos_OMX_VideoEncodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1663 }
1664
1665 EXIT:
1666 FunctionOut();
1667
1668 return ret;
1669 }
1670
1671 OMX_ERRORTYPE Exynos_Mpeg4Enc_ComponentRoleEnum(
1672 OMX_IN OMX_HANDLETYPE hComponent,
1673 OMX_OUT OMX_U8 *cRole,
1674 OMX_IN OMX_U32 nIndex)
1675 {
1676 OMX_ERRORTYPE ret = OMX_ErrorNone;
1677 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1678 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1679 OMX_S32 codecType;
1680
1681 FunctionIn();
1682
1683 if ((hComponent == NULL) || (cRole == NULL)) {
1684 ret = OMX_ErrorBadParameter;
1685 goto EXIT;
1686 }
1687 if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) { /* supports only one role */
1688 ret = OMX_ErrorNoMore;
1689 goto EXIT;
1690 }
1691 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1692 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1693 if (ret != OMX_ErrorNone) {
1694 goto EXIT;
1695 }
1696 if (pOMXComponent->pComponentPrivate == NULL) {
1697 ret = OMX_ErrorBadParameter;
1698 goto EXIT;
1699 }
1700
1701 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1702 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1703 ret = OMX_ErrorInvalidState;
1704 goto EXIT;
1705 }
1706
1707 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1708 if (codecType == CODEC_TYPE_MPEG4)
1709 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE);
1710 else
1711 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE);
1712
1713 EXIT:
1714 FunctionOut();
1715
1716 return ret;
1717 }
1718
1719 /* MFC Init */
1720 OMX_ERRORTYPE Exynos_Mpeg4Enc_Init(OMX_COMPONENTTYPE *pOMXComponent)
1721 {
1722 OMX_ERRORTYPE ret = OMX_ErrorNone;
1723 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1724 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1725 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1726 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1727 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;;
1728 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
1729 ENCODE_CODEC_EXTRA_BUFFERINFO *pExtBufferInfo = pExynosInputPort->processData.extInfo;
1730 OMX_PTR hMFCHandle = NULL;
1731 OMX_COLOR_FORMATTYPE eColorFormat;
1732
1733 ExynosVideoEncOps *pEncOps = NULL;
1734 ExynosVideoEncBufferOps *pInbufOps = NULL;
1735 ExynosVideoEncBufferOps *pOutbufOps = NULL;
1736
1737 CSC_METHOD csc_method = CSC_METHOD_SW;
1738 int i = 0;
1739
1740 FunctionIn();
1741
1742 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
1743 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
1744 pVideoEnc->bFirstOutput = OMX_FALSE;
1745 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1746 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1747 pExynosComponent->bBehaviorEOS = OMX_FALSE;
1748
1749 eColorFormat = pExynosInputPort->portDefinition.format.video.eColorFormat;
1750 if (pExynosInputPort->bStoreMetaData == OMX_TRUE) {
1751 if (eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
1752 pExynosInputPort->bufferProcessType = BUFFER_COPY;
1753 } else {
1754 pExynosInputPort->bufferProcessType = BUFFER_SHARE;
1755 }
1756 } else {
1757 pExynosInputPort->bufferProcessType = BUFFER_COPY;
1758 }
1759
1760 /* Mpeg4/H.263 Codec Open */
1761 ret = Mpeg4CodecOpen(pMpeg4Enc);
1762 if (ret != OMX_ErrorNone) {
1763 goto EXIT;
1764 }
1765
1766 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1767 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1768 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1769 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
1770
1771 #ifdef USE_ENCODER_RGBINPUT_SUPPORT
1772 if (pEncOps->Check_RGBSupport(hMFCHandle) != VIDEO_ERROR_NOSUPPORT)
1773 pVideoEnc->bRGBSupport = OMX_TRUE;
1774 #endif
1775
1776 pVideoEnc->nInbufSpareSize = pInbufOps->Get_SpareSize(hMFCHandle);
1777
1778 pExynosInputPort->nPlaneCnt = MFC_DEFAULT_INPUT_BUFFER_PLANE;
1779 if ((pExynosInputPort->bStoreMetaData != OMX_TRUE) &&
1780 (eColorFormat != OMX_COLOR_FormatAndroidOpaque)) {
1781 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1782 OMX_U32 nPlaneSize[MAX_BUFFER_PLANE] = {0, 0, 0};
1783
1784 if (pVideoEnc->bRGBSupport == OMX_TRUE) {
1785 pExynosInputPort->nPlaneCnt = Exynos_OSAL_GetPlaneCount(eColorFormat);
1786 Exynos_OSAL_GetPlaneSize(eColorFormat, ALIGN_TO_16B(1920), ALIGN_TO_16B(1080), nPlaneSize);
1787 } else {
1788 pExtBufferInfo->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1789 pExynosInputPort->nPlaneCnt = Exynos_OSAL_GetPlaneCount(OMX_COLOR_FormatYUV420SemiPlanar);
1790 Exynos_OSAL_GetPlaneSize(OMX_COLOR_FormatYUV420SemiPlanar, ALIGN_TO_16B(1920), ALIGN_TO_16B(1080), nPlaneSize);
1791 }
1792
1793 if (pVideoEnc->nInbufSpareSize > 0) {
1794 for (i = 0; i < pExynosInputPort->nPlaneCnt; i++)
1795 nPlaneSize[i] += pVideoEnc->nInbufSpareSize;
1796 }
1797
1798 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1799 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1800
1801 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX, nPlaneSize);
1802 if (ret != OMX_ErrorNone)
1803 goto EXIT;
1804
1805 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++)
1806 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
1807 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1808 /*************/
1809 /* TBD */
1810 /*************/
1811 /* Does not require any actions. */
1812 }
1813 }
1814
1815 pExynosOutputPort->nPlaneCnt = MFC_DEFAULT_OUTPUT_BUFFER_PLANE;
1816 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1817 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1818 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1819 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1820 /*************/
1821 /* TBD */
1822 /*************/
1823 /* Does not require any actions. */
1824 }
1825
1826 pMpeg4Enc->bSourceStart = OMX_FALSE;
1827 Exynos_OSAL_SignalCreate(&pMpeg4Enc->hSourceStartEvent);
1828 pMpeg4Enc->bDestinationStart = OMX_FALSE;
1829 Exynos_OSAL_SignalCreate(&pMpeg4Enc->hDestinationStartEvent);
1830
1831 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1832 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1833 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp = 0;
1834 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp = 0;
1835
1836 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1837
1838 Exynos_OSAL_QueueCreate(&pMpeg4Enc->bypassBufferInfoQ, QUEUE_ELEMENTS);
1839
1840 #ifdef USE_CSC_HW
1841 csc_method = CSC_METHOD_HW;
1842 #endif
1843 pVideoEnc->csc_handle = csc_init(csc_method);
1844 if (pVideoEnc->csc_handle == NULL) {
1845 ret = OMX_ErrorInsufficientResources;
1846 goto EXIT;
1847 }
1848 pVideoEnc->csc_set_format = OMX_FALSE;
1849
1850 EXIT:
1851 FunctionOut();
1852
1853 return ret;
1854 }
1855
1856 /* MFC Terminate */
1857 OMX_ERRORTYPE Exynos_Mpeg4Enc_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1858 {
1859 OMX_ERRORTYPE ret = OMX_ErrorNone;
1860 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1861 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle);
1862 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1863 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1864 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1865 OMX_PTR hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
1866
1867 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1868 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1869 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1870
1871 int i = 0, plane = 0;
1872
1873 FunctionIn();
1874
1875 if (pVideoEnc->csc_handle != NULL) {
1876 csc_deinit(pVideoEnc->csc_handle);
1877 pVideoEnc->csc_handle = NULL;
1878 }
1879
1880 Exynos_OSAL_QueueTerminate(&pMpeg4Enc->bypassBufferInfoQ);
1881
1882 Exynos_OSAL_SignalTerminate(pMpeg4Enc->hDestinationStartEvent);
1883 pMpeg4Enc->hDestinationStartEvent = NULL;
1884 pMpeg4Enc->bDestinationStart = OMX_FALSE;
1885 Exynos_OSAL_SignalTerminate(pMpeg4Enc->hSourceStartEvent);
1886 pMpeg4Enc->hSourceStartEvent = NULL;
1887 pMpeg4Enc->bSourceStart = OMX_FALSE;
1888
1889 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1890 Exynos_Free_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX);
1891 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
1892 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
1893 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1894 /*************/
1895 /* TBD */
1896 /*************/
1897 /* Does not require any actions. */
1898 }
1899
1900 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1901 Exynos_Free_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX);
1902 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
1903 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
1904 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1905 /*************/
1906 /* TBD */
1907 /*************/
1908 /* Does not require any actions. */
1909 }
1910 Mpeg4CodecClose(pMpeg4Enc);
1911
1912 EXIT:
1913 FunctionOut();
1914
1915 return ret;
1916 }
1917
1918 OMX_ERRORTYPE Exynos_Mpeg4Enc_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1919 {
1920 OMX_ERRORTYPE ret = OMX_ErrorNone;
1921 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1922 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1923 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
1924 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
1925 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1926 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1927 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1928 ENCODE_CODEC_EXTRA_BUFFERINFO *pExtBufferInfo = pSrcInputData->extInfo;
1929
1930 OMX_BUFFERHEADERTYPE tempBufferHeader;
1931 void *pPrivate = NULL;
1932
1933 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1934 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1935 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1936 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1937
1938 int i;
1939
1940 FunctionIn();
1941
1942 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
1943 ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
1944 if ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)
1945 goto EXIT;
1946 }
1947 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
1948 ret = Mpeg4CodecDstSetup(pOMXComponent);
1949 }
1950
1951 if (pVideoEnc->configChange == OMX_TRUE) {
1952 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1953 Change_Mpeg4Enc_Param(pExynosComponent);
1954 else
1955 Change_H263Enc_Param(pExynosComponent);
1956
1957 pVideoEnc->configChange = OMX_FALSE;
1958 }
1959
1960 if ((pSrcInputData->dataLen > 0) ||
1961 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
1962 OMX_U32 nAllocLen[MAX_BUFFER_PLANE] = {0, 0, 0};
1963 OMX_U32 nMFCYUVDataSize[MAX_BUFFER_PLANE] = {0, 0, 0};
1964
1965 pExynosComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
1966 pExynosComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
1967 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp, pSrcInputData->nFlags);
1968 pEncOps->Set_FrameTag(hMFCHandle, pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp);
1969 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
1970 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
1971 #ifdef USE_QOS_CTRL
1972 if ((pVideoEnc->bQosChanged == OMX_TRUE) &&
1973 (pEncOps->Set_QosRatio != NULL)) {
1974 pEncOps->Set_QosRatio(hMFCHandle, pVideoEnc->nQosRatio);
1975 pVideoEnc->bQosChanged = OMX_FALSE;
1976 }
1977 #endif
1978 /* queue work for input buffer */
1979 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Exynos_Mpeg4Enc_SrcIn(): oneFrameSize: %d, bufferHeader: 0x%x", oneFrameSize, pSrcInputData->bufferHeader);
1980
1981 if (pExynosInputPort->bufferProcessType == BUFFER_COPY) {
1982 Exynos_OSAL_GetPlaneSize(pExtBufferInfo->eColorFormat, ALIGN_TO_16B(1920), ALIGN_TO_16B(1080), nMFCYUVDataSize);
1983 tempBufferHeader.nFlags = pSrcInputData->nFlags;
1984 tempBufferHeader.nTimeStamp = pSrcInputData->timeStamp;
1985 pPrivate = (void *)&tempBufferHeader;
1986 } else {
1987 Exynos_OSAL_GetPlaneSize(pExtBufferInfo->eColorFormat,
1988 pExynosInputPort->portDefinition.format.video.nFrameWidth,
1989 pExynosInputPort->portDefinition.format.video.nFrameHeight,
1990 nMFCYUVDataSize);
1991 pPrivate = (void *)pSrcInputData->bufferHeader;
1992 }
1993
1994 if (pVideoEnc->nInbufSpareSize> 0) {
1995 for (i = 0; i < pExynosInputPort->nPlaneCnt; i++)
1996 nAllocLen[i] = nMFCYUVDataSize[i] + pVideoEnc->nInbufSpareSize;
1997 }
1998
1999 codecReturn = pInbufOps->ExtensionEnqueue(hMFCHandle,
2000 (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.dataBuffer,
2001 (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.fd,
2002 (unsigned int *)nAllocLen, (unsigned int *)nMFCYUVDataSize,
2003 pExynosInputPort->nPlaneCnt, pPrivate);
2004 if (codecReturn != VIDEO_ERROR_NONE) {
2005 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pInbufOps->Enqueue", __FUNCTION__, __LINE__);
2006 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2007 goto EXIT;
2008 }
2009 Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2010 if (pMpeg4Enc->bSourceStart == OMX_FALSE) {
2011 pMpeg4Enc->bSourceStart = OMX_TRUE;
2012 Exynos_OSAL_SignalSet(pMpeg4Enc->hSourceStartEvent);
2013 Exynos_OSAL_SleepMillisec(0);
2014 }
2015 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
2016 pMpeg4Enc->bDestinationStart = OMX_TRUE;
2017 Exynos_OSAL_SignalSet(pMpeg4Enc->hDestinationStartEvent);
2018 Exynos_OSAL_SleepMillisec(0);
2019 }
2020 }
2021
2022 ret = OMX_ErrorNone;
2023
2024 EXIT:
2025 FunctionOut();
2026
2027 return ret;
2028 }
2029
2030 OMX_ERRORTYPE Exynos_Mpeg4Enc_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2031 {
2032 OMX_ERRORTYPE ret = OMX_ErrorNone;
2033 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2034 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2035 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
2036 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2037 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2038
2039 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2040 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
2041 ExynosVideoBuffer *pVideoBuffer = NULL;
2042 ExynosVideoBuffer videoBuffer;
2043
2044 FunctionIn();
2045
2046 if (pInbufOps->ExtensionDequeue(hMFCHandle, &videoBuffer) == VIDEO_ERROR_NONE)
2047 pVideoBuffer = &videoBuffer;
2048 else
2049 pVideoBuffer = NULL;
2050
2051 pSrcOutputData->dataLen = 0;
2052 pSrcOutputData->usedDataLen = 0;
2053 pSrcOutputData->remainDataLen = 0;
2054 pSrcOutputData->nFlags = 0;
2055 pSrcOutputData->timeStamp = 0;
2056 pSrcOutputData->allocSize = 0;
2057 pSrcOutputData->bufferHeader = NULL;
2058
2059 if (pVideoBuffer == NULL) {
2060 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2061 pSrcOutputData->pPrivate = NULL;
2062 } else {
2063 int plane = 0;
2064 for (plane = 0; plane < pExynosInputPort->nPlaneCnt; plane++) {
2065 pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2066 pSrcOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2067
2068 pSrcOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2069 }
2070
2071 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2072 int i;
2073 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2074 if (pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[0] ==
2075 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]) {
2076 pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
2077 pSrcOutputData->pPrivate = pVideoEnc->pMFCEncInputBuffer[i];
2078 break;
2079 }
2080 }
2081
2082 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2083 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - Lost buffer", __FUNCTION__, __LINE__);
2084 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2085 goto EXIT;
2086 }
2087 }
2088
2089 /* For Share Buffer */
2090 if (pExynosInputPort->bufferProcessType == BUFFER_SHARE)
2091 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2092 }
2093
2094 ret = OMX_ErrorNone;
2095
2096 EXIT:
2097 FunctionOut();
2098
2099 return ret;
2100 }
2101
2102 OMX_ERRORTYPE Exynos_Mpeg4Enc_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2103 {
2104 OMX_ERRORTYPE ret = OMX_ErrorNone;
2105 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2106 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2107 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2108 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2109 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2110 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2111 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
2112 OMX_U32 dataLen = 0;
2113 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2114
2115 FunctionIn();
2116
2117 if (pDstInputData->buffer.singlePlaneBuffer.dataBuffer == NULL) {
2118 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2119 ret = OMX_ErrorBadParameter;
2120 goto EXIT;
2121 }
2122
2123 OMX_U32 nAllocLen[VIDEO_BUFFER_MAX_PLANES] = {0, 0, 0};
2124 nAllocLen[0] = pExynosOutputPort->portDefinition.format.video.nFrameWidth * pExynosOutputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
2125
2126 codecReturn = pOutbufOps->ExtensionEnqueue(hMFCHandle,
2127 (unsigned char **)&pDstInputData->buffer.singlePlaneBuffer.dataBuffer,
2128 (unsigned char **)&pDstInputData->buffer.singlePlaneBuffer.fd,
2129 (unsigned int *)nAllocLen, (unsigned int *)&dataLen,
2130 pExynosOutputPort->nPlaneCnt, pDstInputData->bufferHeader);
2131 if (codecReturn != VIDEO_ERROR_NONE) {
2132 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pOutbufOps->Enqueue", __FUNCTION__, __LINE__);
2133 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2134 goto EXIT;
2135 }
2136 Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2137
2138 ret = OMX_ErrorNone;
2139
2140 EXIT:
2141 FunctionOut();
2142
2143 return ret;
2144 }
2145
2146 OMX_ERRORTYPE Exynos_Mpeg4Enc_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2147 {
2148 OMX_ERRORTYPE ret = OMX_ErrorNone;
2149 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2150 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2151 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2152 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2153 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2154 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2155 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
2156 ExynosVideoBuffer *pVideoBuffer;
2157 ExynosVideoBuffer videoBuffer;
2158 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2159 ExynosVideoGeometry bufferGeometry;
2160 OMX_S32 indexTimestamp = 0;
2161
2162 FunctionIn();
2163
2164 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
2165 ret = OMX_ErrorNone;
2166 goto EXIT;
2167 }
2168
2169 if (pOutbufOps->ExtensionDequeue(hMFCHandle, &videoBuffer) == VIDEO_ERROR_NONE) {
2170 pVideoBuffer = &videoBuffer;
2171 } else {
2172 pVideoBuffer = NULL;
2173 ret = OMX_ErrorNone;
2174 goto EXIT;
2175 }
2176
2177 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp++;
2178 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2179
2180 pDstOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2181 pDstOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2182 pDstOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2183 pDstOutputData->dataLen = pVideoBuffer->planes[0].dataSize;
2184 pDstOutputData->remainDataLen = pVideoBuffer->planes[0].dataSize;
2185 pDstOutputData->usedDataLen = 0;
2186 pDstOutputData->pPrivate = pVideoBuffer;
2187 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2188 int i = 0;
2189 pDstOutputData->pPrivate = NULL;
2190 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
2191 if (pDstOutputData->buffer.singlePlaneBuffer.dataBuffer ==
2192 pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0]) {
2193 pDstOutputData->pPrivate = pVideoEnc->pMFCEncOutputBuffer[i];
2194 break;
2195 }
2196 }
2197
2198 if (pDstOutputData->pPrivate == NULL) {
2199 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2200 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2201 goto EXIT;
2202 }
2203 }
2204
2205 /* For Share Buffer */
2206 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2207
2208 if (pVideoEnc->bFirstOutput == OMX_FALSE) {
2209 OMX_U8 *p = NULL;
2210
2211 /* start header return */
2212 pDstOutputData->timeStamp = 0;
2213 pDstOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
2214 pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2215 pVideoEnc->bFirstOutput = OMX_TRUE;
2216 } else {
2217 indexTimestamp = pEncOps->Get_FrameTag(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle);
2218 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2219 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp];
2220 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp];
2221 } else {
2222 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2223 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2224 }
2225
2226 pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2227 if (pVideoBuffer->frameType == VIDEO_FRAME_I)
2228 pDstOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
2229 }
2230
2231 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2232 (((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
2233 (pExynosComponent->bBehaviorEOS == OMX_FALSE))) {
2234 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%x displayStatus:%d, nFlags0x%x", pExynosComponent, displayStatus, pDstOutputData->nFlags);
2235 pDstOutputData->remainDataLen = 0;
2236 }
2237
2238 if (((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) &&
2239 (pExynosComponent->bBehaviorEOS == OMX_TRUE))
2240 pExynosComponent->bBehaviorEOS = OMX_FALSE;
2241
2242 ret = OMX_ErrorNone;
2243
2244 EXIT:
2245 FunctionOut();
2246
2247 return ret;
2248 }
2249
2250 OMX_ERRORTYPE Exynos_Mpeg4Enc_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2251 {
2252 OMX_ERRORTYPE ret = OMX_ErrorNone;
2253 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2254 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2255 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2256
2257 FunctionIn();
2258
2259 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2260 ret = OMX_ErrorNone;
2261 goto EXIT;
2262 }
2263 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2264 ret = OMX_ErrorNone;
2265 goto EXIT;
2266 }
2267
2268 ret = Exynos_Mpeg4Enc_SrcIn(pOMXComponent, pSrcInputData);
2269 if (ret != OMX_ErrorNone) {
2270 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcIn -> event is thrown to client", __FUNCTION__, __LINE__);
2271 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2272 pExynosComponent->callbackData,
2273 OMX_EventError, ret, 0, NULL);
2274 }
2275
2276 EXIT:
2277 FunctionOut();
2278
2279 return ret;
2280 }
2281
2282 OMX_ERRORTYPE Exynos_Mpeg4Enc_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2283 {
2284 OMX_ERRORTYPE ret = OMX_ErrorNone;
2285 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2286 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2287 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2288
2289 FunctionIn();
2290
2291 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2292 ret = OMX_ErrorNone;
2293 goto EXIT;
2294 }
2295
2296 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2297 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2298 ret = OMX_ErrorNone;
2299 goto EXIT;
2300 }
2301 }
2302 if ((pMpeg4Enc->bSourceStart == OMX_FALSE) &&
2303 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2304 Exynos_OSAL_SignalWait(pMpeg4Enc->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2305 Exynos_OSAL_SignalReset(pMpeg4Enc->hSourceStartEvent);
2306 }
2307
2308 ret = Exynos_Mpeg4Enc_SrcOut(pOMXComponent, pSrcOutputData);
2309 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2310 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcOut -> event is thrown to client", __FUNCTION__, __LINE__);
2311 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2312 pExynosComponent->callbackData,
2313 OMX_EventError, ret, 0, NULL);
2314 }
2315
2316 EXIT:
2317 FunctionOut();
2318
2319 return ret;
2320 }
2321
2322 OMX_ERRORTYPE Exynos_Mpeg4Enc_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2323 {
2324 OMX_ERRORTYPE ret = OMX_ErrorNone;
2325 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2326 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2327 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2328
2329 FunctionIn();
2330
2331 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2332 ret = OMX_ErrorNone;
2333 goto EXIT;
2334 }
2335 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2336 ret = OMX_ErrorNone;
2337 goto EXIT;
2338 }
2339 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2340 if ((pMpeg4Enc->bDestinationStart == OMX_FALSE) &&
2341 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2342 Exynos_OSAL_SignalWait(pMpeg4Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2343 Exynos_OSAL_SignalReset(pMpeg4Enc->hDestinationStartEvent);
2344 }
2345
2346 if (Exynos_OSAL_GetElemNum(&pMpeg4Enc->bypassBufferInfoQ) > 0) {
2347 BYPASS_BUFFER_INFO *pBufferInfo = (BYPASS_BUFFER_INFO *)Exynos_OSAL_Dequeue(&pMpeg4Enc->bypassBufferInfoQ);
2348 if (pBufferInfo == NULL) {
2349 ret = OMX_ErrorUndefined;
2350 goto EXIT;
2351 }
2352
2353 pDstInputData->bufferHeader->nFlags = pBufferInfo->nFlags;
2354 pDstInputData->bufferHeader->nTimeStamp = pBufferInfo->timeStamp;
2355 Exynos_OMX_OutputBufferReturn(pOMXComponent, pDstInputData->bufferHeader);
2356 Exynos_OSAL_Free(pBufferInfo);
2357
2358 ret = OMX_ErrorNone;
2359 goto EXIT;
2360 }
2361 }
2362 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2363 ret = Exynos_Mpeg4Enc_DstIn(pOMXComponent, pDstInputData);
2364 if (ret != OMX_ErrorNone) {
2365 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstIn -> event is thrown to client", __FUNCTION__, __LINE__);
2366 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2367 pExynosComponent->callbackData,
2368 OMX_EventError, ret, 0, NULL);
2369 }
2370 }
2371
2372 EXIT:
2373 FunctionOut();
2374
2375 return ret;
2376 }
2377
2378 OMX_ERRORTYPE Exynos_Mpeg4Enc_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2379 {
2380 OMX_ERRORTYPE ret = OMX_ErrorNone;
2381 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2382 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2383 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2384
2385 FunctionIn();
2386
2387 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2388 ret = OMX_ErrorNone;
2389 goto EXIT;
2390 }
2391 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2392 ret = OMX_ErrorNone;
2393 goto EXIT;
2394 }
2395
2396 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2397 if ((pMpeg4Enc->bDestinationStart == OMX_FALSE) &&
2398 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2399 Exynos_OSAL_SignalWait(pMpeg4Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2400 Exynos_OSAL_SignalReset(pMpeg4Enc->hDestinationStartEvent);
2401 }
2402
2403 if (Exynos_OSAL_GetElemNum(&pMpeg4Enc->bypassBufferInfoQ) > 0) {
2404 EXYNOS_OMX_DATABUFFER *dstOutputUseBuffer = &pExynosOutputPort->way.port2WayDataBuffer.outputDataBuffer;
2405 OMX_BUFFERHEADERTYPE *pOMXBuffer = NULL;
2406 BYPASS_BUFFER_INFO *pBufferInfo = NULL;
2407
2408 if (dstOutputUseBuffer->dataValid == OMX_FALSE) {
2409 pOMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
2410 if (pOMXBuffer == NULL) {
2411 ret = OMX_ErrorUndefined;
2412 goto EXIT;
2413 }
2414 } else {
2415 pOMXBuffer = dstOutputUseBuffer->bufferHeader;
2416 }
2417
2418 pBufferInfo = Exynos_OSAL_Dequeue(&pMpeg4Enc->bypassBufferInfoQ);
2419 if (pBufferInfo == NULL) {
2420 ret = OMX_ErrorUndefined;
2421 goto EXIT;
2422 }
2423
2424 pOMXBuffer->nFlags = pBufferInfo->nFlags;
2425 pOMXBuffer->nTimeStamp = pBufferInfo->timeStamp;
2426 Exynos_OMX_OutputBufferReturn(pOMXComponent, pOMXBuffer);
2427 Exynos_OSAL_Free(pBufferInfo);
2428
2429 dstOutputUseBuffer->dataValid = OMX_FALSE;
2430
2431 ret = OMX_ErrorNone;
2432 goto EXIT;
2433 }
2434 }
2435 ret = Exynos_Mpeg4Enc_DstOut(pOMXComponent, pDstOutputData);
2436 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2437 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstOut -> event is thrown to client", __FUNCTION__, __LINE__);
2438 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2439 pExynosComponent->callbackData,
2440 OMX_EventError, ret, 0, NULL);
2441 }
2442
2443 EXIT:
2444 FunctionOut();
2445
2446 return ret;
2447 }
2448
2449 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2450 OMX_HANDLETYPE hComponent,
2451 OMX_STRING componentName)
2452 {
2453 OMX_ERRORTYPE ret = OMX_ErrorNone;
2454 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2455 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2456 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2457 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
2458 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
2459 OMX_S32 codecType = -1;
2460 int i = 0;
2461
2462 FunctionIn();
2463
2464 if ((hComponent == NULL) || (componentName == NULL)) {
2465 ret = OMX_ErrorBadParameter;
2466 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
2467 goto EXIT;
2468 }
2469 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_ENC, componentName) == 0) {
2470 codecType = CODEC_TYPE_MPEG4;
2471 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_ENC, componentName) == 0) {
2472 codecType = CODEC_TYPE_H263;
2473 } else {
2474 ret = OMX_ErrorBadParameter;
2475 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, componentName, ret);
2476 goto EXIT;
2477 }
2478
2479 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2480 ret = Exynos_OMX_VideoEncodeComponentInit(pOMXComponent);
2481 if (ret != OMX_ErrorNone) {
2482 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Exynos_OMX_VideoDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
2483 goto EXIT;
2484 }
2485 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2486 pExynosComponent->codecType = HW_VIDEO_ENC_CODEC;
2487
2488 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2489 if (pExynosComponent->componentName == NULL) {
2490 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2491 ret = OMX_ErrorInsufficientResources;
2492 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
2493 goto EXIT;
2494 }
2495 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2496
2497 pMpeg4Enc = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4ENC_HANDLE));
2498 if (pMpeg4Enc == NULL) {
2499 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2500 ret = OMX_ErrorInsufficientResources;
2501 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: EXYNOS_MPEG4ENC_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
2502 goto EXIT;
2503 }
2504 Exynos_OSAL_Memset(pMpeg4Enc, 0, sizeof(EXYNOS_MPEG4ENC_HANDLE));
2505 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2506 pVideoEnc->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Enc;
2507 pMpeg4Enc->hMFCMpeg4Handle.codecType = codecType;
2508
2509 if (codecType == CODEC_TYPE_MPEG4)
2510 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_ENC);
2511 else
2512 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_ENC);
2513
2514 /* Set componentVersion */
2515 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2516 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2517 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2518 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2519 /* Set specVersion */
2520 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2521 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2522 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2523 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2524
2525 /* Input port */
2526 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2527 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2528 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2529 pExynosPort->portDefinition.format.video.nBitrate = 64000;
2530 pExynosPort->portDefinition.format.video.xFramerate= (15 << 16);
2531 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2532 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2533 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2534 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2535 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2536 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2537 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2538 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2539 pExynosPort->bufferProcessType = BUFFER_COPY;
2540 pExynosPort->portWayType = WAY2_PORT;
2541
2542 /* Output port */
2543 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2544 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2545 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2546 pExynosPort->portDefinition.format.video.nBitrate = 64000;
2547 pExynosPort->portDefinition.format.video.xFramerate= (15 << 16);
2548 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2549 if (codecType == CODEC_TYPE_MPEG4) {
2550 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2551 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2552 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2553 } else {
2554 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2555 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2556 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2557 }
2558 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2559 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2560 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2561 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2562 pExynosPort->bufferProcessType = BUFFER_SHARE;
2563 pExynosPort->portWayType = WAY2_PORT;
2564
2565 if (codecType == CODEC_TYPE_MPEG4) {
2566 for(i = 0; i < ALL_PORT_NUM; i++) {
2567 INIT_SET_SIZE_VERSION(&pMpeg4Enc->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2568 pMpeg4Enc->mpeg4Component[i].nPortIndex = i;
2569 pMpeg4Enc->mpeg4Component[i].eProfile = OMX_VIDEO_MPEG4ProfileSimple;
2570 pMpeg4Enc->mpeg4Component[i].eLevel = OMX_VIDEO_MPEG4Level4;
2571
2572 pMpeg4Enc->mpeg4Component[i].nPFrames = 10;
2573 pMpeg4Enc->mpeg4Component[i].nBFrames = 0; /* No support for B frames */
2574 pMpeg4Enc->mpeg4Component[i].nMaxPacketSize = 256; /* Default value */
2575 pMpeg4Enc->mpeg4Component[i].nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
2576 pMpeg4Enc->mpeg4Component[i].bGov = OMX_FALSE;
2577
2578 }
2579 } else {
2580 for(i = 0; i < ALL_PORT_NUM; i++) {
2581 INIT_SET_SIZE_VERSION(&pMpeg4Enc->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2582 pMpeg4Enc->h263Component[i].nPortIndex = i;
2583 pMpeg4Enc->h263Component[i].eProfile = OMX_VIDEO_H263ProfileBaseline;
2584 pMpeg4Enc->h263Component[i].eLevel = OMX_VIDEO_H263Level45;
2585
2586 pMpeg4Enc->h263Component[i].nPFrames = 20;
2587 pMpeg4Enc->h263Component[i].nBFrames = 0; /* No support for B frames */
2588 pMpeg4Enc->h263Component[i].bPLUSPTYPEAllowed = OMX_FALSE;
2589 pMpeg4Enc->h263Component[i].nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
2590 pMpeg4Enc->h263Component[i].bForceRoundingTypeToZero = OMX_TRUE;
2591 pMpeg4Enc->h263Component[i].nPictureHeaderRepetition = 0;
2592 pMpeg4Enc->h263Component[i].nGOBHeaderInterval = 0;
2593 }
2594 }
2595
2596 pOMXComponent->GetParameter = &Exynos_Mpeg4Enc_GetParameter;
2597 pOMXComponent->SetParameter = &Exynos_Mpeg4Enc_SetParameter;
2598 pOMXComponent->GetConfig = &Exynos_Mpeg4Enc_GetConfig;
2599 pOMXComponent->SetConfig = &Exynos_Mpeg4Enc_SetConfig;
2600 pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Enc_GetExtensionIndex;
2601 pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Enc_ComponentRoleEnum;
2602 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2603
2604 pExynosComponent->exynos_codec_componentInit = &Exynos_Mpeg4Enc_Init;
2605 pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Enc_Terminate;
2606
2607 pVideoEnc->exynos_codec_srcInputProcess = &Exynos_Mpeg4Enc_srcInputBufferProcess;
2608 pVideoEnc->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Enc_srcOutputBufferProcess;
2609 pVideoEnc->exynos_codec_dstInputProcess = &Exynos_Mpeg4Enc_dstInputBufferProcess;
2610 pVideoEnc->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Enc_dstOutputBufferProcess;
2611
2612 pVideoEnc->exynos_codec_start = &Mpeg4CodecStart;
2613 pVideoEnc->exynos_codec_stop = &Mpeg4CodecStop;
2614 pVideoEnc->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2615 pVideoEnc->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnqueueAllBuffer;
2616
2617 pVideoEnc->exynos_checkInputFrame = NULL;
2618 pVideoEnc->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2619 pVideoEnc->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2620
2621 pVideoEnc->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2622 if (pVideoEnc->hSharedMemory == NULL) {
2623 Exynos_OSAL_Free(pMpeg4Enc);
2624 pMpeg4Enc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2625 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2626 ret = OMX_ErrorInsufficientResources;
2627 goto EXIT;
2628 }
2629
2630 pExynosComponent->currentState = OMX_StateLoaded;
2631
2632 ret = OMX_ErrorNone;
2633
2634 EXIT:
2635 FunctionOut();
2636
2637 return ret;
2638 }
2639
2640 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2641 {
2642 OMX_ERRORTYPE ret = OMX_ErrorNone;
2643 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2644 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2645 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
2646 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
2647
2648 FunctionIn();
2649
2650 if (hComponent == NULL) {
2651 ret = OMX_ErrorBadParameter;
2652 goto EXIT;
2653 }
2654 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2655 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2656 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2657
2658 Exynos_OSAL_SharedMemory_Close(pVideoEnc->hSharedMemory);
2659
2660 Exynos_OSAL_Free(pExynosComponent->componentName);
2661 pExynosComponent->componentName = NULL;
2662
2663 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2664 if (pMpeg4Enc != NULL) {
2665 Exynos_OSAL_Free(pMpeg4Enc);
2666 pMpeg4Enc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2667 }
2668
2669 ret = Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2670 if (ret != OMX_ErrorNone) {
2671 goto EXIT;
2672 }
2673
2674 ret = OMX_ErrorNone;
2675
2676 EXIT:
2677 FunctionOut();
2678
2679 return ret;
2680 }