3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 * @file Exynos_OMX_Mpeg4enc.c
21 * @author Yunji Kim (yunji.kim@samsung.com)
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_OSAL_ETC.h"
36 #include "Exynos_OSAL_Semaphore.h"
37 #include "Exynos_OSAL_Thread.h"
38 #include "library_register.h"
39 #include "Exynos_OMX_Mpeg4enc.h"
40 //#include "ExynosVideoApi.h"
41 #include "Exynos_OSAL_SharedMemory.h"
42 #include "Exynos_OSAL_Event.h"
44 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
45 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
49 #define EXYNOS_LOG_TAG "EXYNOS_MPEG4_ENC"
50 #define EXYNOS_LOG_OFF
51 //#define EXYNOS_TRACE_ON
52 #include "Exynos_OSAL_Log.h"
54 /* MPEG4 Encoder Supported Levels & profiles */
55 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
56 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
57 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
58 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
59 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
60 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
61 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
62 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
63 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
64 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
65 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
66 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
67 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
68 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
69 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
70 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
71 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
73 /* H.263 Encoder Supported Levels & profiles */
74 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
75 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
76 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
77 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
78 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
79 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
80 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
81 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
82 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70}};
84 static OMX_U32 OMXMpeg4ProfileToMFCProfile(OMX_VIDEO_MPEG4PROFILETYPE profile)
89 case OMX_VIDEO_MPEG4ProfileSimple:
92 case OMX_VIDEO_MPEG4ProfileAdvancedSimple:
102 static OMX_U32 OMXMpeg4LevelToMFCLevel(OMX_VIDEO_MPEG4LEVELTYPE level)
107 case OMX_VIDEO_MPEG4Level0:
110 case OMX_VIDEO_MPEG4Level0b:
113 case OMX_VIDEO_MPEG4Level1:
116 case OMX_VIDEO_MPEG4Level2:
119 case OMX_VIDEO_MPEG4Level3:
122 case OMX_VIDEO_MPEG4Level4:
123 case OMX_VIDEO_MPEG4Level4a:
126 case OMX_VIDEO_MPEG4Level5:
136 static void Print_Mpeg4Enc_Param(ExynosVideoEncParam *pEncParam)
138 ExynosVideoEncCommonParam *pCommonParam = &pEncParam->commonParam;
139 ExynosVideoEncMpeg4Param *pMpeg4Param = &pEncParam->codecParam.mpeg4;
141 /* common parameters */
142 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceWidth : %d", pCommonParam->SourceWidth);
143 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceHeight : %d", pCommonParam->SourceHeight);
144 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "IDRPeriod : %d", pCommonParam->IDRPeriod);
145 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceMode : %d", pCommonParam->SliceMode);
146 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh : %d", pCommonParam->RandomIntraMBRefresh);
147 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Bitrate : %d", pCommonParam->Bitrate);
148 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp : %d", pCommonParam->FrameQp);
149 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_P : %d", pCommonParam->FrameQp_P);
150 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMax : %d", pCommonParam->QSCodeMax);
151 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMin : %d", pCommonParam->QSCodeMin);
152 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PadControlOn : %d", pCommonParam->PadControlOn);
153 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LumaPadVal : %d", pCommonParam->LumaPadVal);
154 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CbPadVal : %d", pCommonParam->CbPadVal);
155 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CrPadVal : %d", pCommonParam->CrPadVal);
156 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameMap : %d", pCommonParam->FrameMap);
158 /* Mpeg4 specific parameters */
159 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "ProfileIDC : %d", pMpeg4Param->ProfileIDC);
160 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LevelIDC : %d", pMpeg4Param->LevelIDC);
161 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_B : %d", pMpeg4Param->FrameQp_B);
162 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "TimeIncreamentRes : %d", pMpeg4Param->TimeIncreamentRes);
163 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VopTimeIncreament : %d", pMpeg4Param->VopTimeIncreament);
164 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceArgument : %d", pMpeg4Param->SliceArgument);
165 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NumberBFrames : %d", pMpeg4Param->NumberBFrames);
166 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "DisableQpelME : %d", pMpeg4Param->DisableQpelME);
168 /* rate control related parameters */
169 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableFRMRateControl : %d", pCommonParam->EnableFRMRateControl);
170 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableMBRateControl : %d", pCommonParam->EnableMBRateControl);
171 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CBRPeriodRf : %d", pCommonParam->CBRPeriodRf);
174 static void Print_H263Enc_Param(ExynosVideoEncParam *pEncParam)
176 ExynosVideoEncCommonParam *pCommonParam = &pEncParam->commonParam;
177 ExynosVideoEncH263Param *pH263Param = &pEncParam->codecParam.h263;
179 /* common parameters */
180 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceWidth : %d", pCommonParam->SourceWidth);
181 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceHeight : %d", pCommonParam->SourceHeight);
182 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "IDRPeriod : %d", pCommonParam->IDRPeriod);
183 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceMode : %d", pCommonParam->SliceMode);
184 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh : %d", pCommonParam->RandomIntraMBRefresh);
185 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Bitrate : %d", pCommonParam->Bitrate);
186 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp : %d", pCommonParam->FrameQp);
187 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_P : %d", pCommonParam->FrameQp_P);
188 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMax : %d", pCommonParam->QSCodeMax);
189 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMin : %d", pCommonParam->QSCodeMin);
190 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PadControlOn : %d", pCommonParam->PadControlOn);
191 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LumaPadVal : %d", pCommonParam->LumaPadVal);
192 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CbPadVal : %d", pCommonParam->CbPadVal);
193 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CrPadVal : %d", pCommonParam->CrPadVal);
194 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameMap : %d", pCommonParam->FrameMap);
196 /* H263 specific parameters */
197 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameRate : %d", pH263Param->FrameRate);
199 /* rate control related parameters */
200 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableFRMRateControl : %d", pCommonParam->EnableFRMRateControl);
201 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableMBRateControl : %d", pCommonParam->EnableMBRateControl);
202 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CBRPeriodRf : %d", pCommonParam->CBRPeriodRf);
205 static void Set_Mpeg4Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
207 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
208 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
209 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
210 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
211 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
213 ExynosVideoEncParam *pEncParam = NULL;
214 ExynosVideoEncCommonParam *pCommonParam = NULL;
215 ExynosVideoEncMpeg4Param *pMpeg4Param = NULL;
217 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
218 pMpeg4Enc = pVideoEnc->hCodecHandle;
219 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
220 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
221 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
223 pEncParam = &pMFCMpeg4Handle->encParam;
224 pCommonParam = &pEncParam->commonParam;
225 pMpeg4Param = &pEncParam->codecParam.mpeg4;
226 pEncParam->eCompressionFormat = VIDEO_CODING_MPEG4;
227 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "eCompressionFormat: %d", pEncParam->eCompressionFormat);
229 /* common parameters */
230 pCommonParam->SourceWidth = pExynosOutputPort->portDefinition.format.video.nFrameWidth;
231 pCommonParam->SourceHeight = pExynosOutputPort->portDefinition.format.video.nFrameHeight;
232 pCommonParam->IDRPeriod = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
233 pCommonParam->SliceMode = 0;
234 pCommonParam->RandomIntraMBRefresh = 0;
235 pCommonParam->Bitrate = pExynosOutputPort->portDefinition.format.video.nBitrate;
236 pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
237 pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
238 pCommonParam->QSCodeMax = 30;
239 pCommonParam->QSCodeMin = 10;
240 pCommonParam->PadControlOn = 0; /* 0: Use boundary pixel, 1: Use the below setting value */
241 pCommonParam->LumaPadVal = 0;
242 pCommonParam->CbPadVal = 0;
243 pCommonParam->CrPadVal = 0;
245 switch ((EXYNOS_OMX_COLOR_FORMATTYPE)pExynosInputPort->portDefinition.format.video.eColorFormat) {
246 case OMX_COLOR_FormatYUV420SemiPlanar:
247 case OMX_COLOR_FormatYUV420Planar: /* Converted to NV12 in Exynos_Preprocessor_InputData */
248 #ifdef TIZEN_FEATURE_E3250
249 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
251 #ifdef USE_METADATABUFFERTYPE
252 case OMX_COLOR_FormatAndroidOpaque:
254 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12;
256 case OMX_SEC_COLOR_FormatNV12Tiled:
257 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
258 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
260 case OMX_SEC_COLOR_FormatNV21Linear:
261 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV21;
264 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
268 /* Mpeg4 specific parameters */
269 pMpeg4Param->ProfileIDC = OMXMpeg4ProfileToMFCProfile(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eProfile);
270 pMpeg4Param->LevelIDC = OMXMpeg4LevelToMFCLevel(pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].eLevel);
271 pMpeg4Param->FrameQp_B = pVideoEnc->quantization.nQpB;
272 pMpeg4Param->TimeIncreamentRes = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
273 pMpeg4Param->VopTimeIncreament = 1;
274 pMpeg4Param->SliceArgument = 0; /* MB number or byte number */
275 pMpeg4Param->NumberBFrames = 0; /* 0(not used) ~ 2 */
276 pMpeg4Param->DisableQpelME = 1;
278 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
279 /* rate control related parameters */
280 switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
281 case OMX_Video_ControlRateDisable:
282 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode DBR");
283 pCommonParam->EnableFRMRateControl = 0; /* 0: Disable, 1: Frame level RC */
284 pCommonParam->EnableMBRateControl = 0; /* 0: Disable, 1:MB level RC */
285 pCommonParam->CBRPeriodRf = 100;
287 case OMX_Video_ControlRateConstant:
288 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode CBR");
289 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
290 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
291 pCommonParam->CBRPeriodRf = 9;
293 case OMX_Video_ControlRateVariable:
294 default: /*Android default */
295 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
296 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
297 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
298 pCommonParam->CBRPeriodRf = 100;
302 Print_Mpeg4Enc_Param(pEncParam);
305 static void Set_H263Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
307 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
308 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
309 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
310 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
311 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
313 ExynosVideoEncParam *pEncParam = NULL;
314 ExynosVideoEncCommonParam *pCommonParam = NULL;
315 ExynosVideoEncH263Param *pH263Param = NULL;
317 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
318 pMpeg4Enc = pVideoEnc->hCodecHandle;
319 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
320 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
321 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
323 pEncParam = &pMFCMpeg4Handle->encParam;
324 pCommonParam = &pEncParam->commonParam;
325 pH263Param = &pEncParam->codecParam.h263;
326 pEncParam->eCompressionFormat = VIDEO_CODING_H263;
327 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "eCompressionFormat: %d", pEncParam->eCompressionFormat);
329 /* common parameters */
330 pCommonParam->SourceWidth = pExynosOutputPort->portDefinition.format.video.nFrameWidth;
331 pCommonParam->SourceHeight = pExynosOutputPort->portDefinition.format.video.nFrameHeight;
332 pCommonParam->IDRPeriod = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
333 pCommonParam->SliceMode = 0;
334 pCommonParam->RandomIntraMBRefresh = 0;
335 pCommonParam->Bitrate = pExynosOutputPort->portDefinition.format.video.nBitrate;
336 pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
337 pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
338 pCommonParam->QSCodeMax = 30;
339 pCommonParam->QSCodeMin = 10;
340 pCommonParam->PadControlOn = 0; /* 0: Use boundary pixel, 1: Use the below setting value */
341 pCommonParam->LumaPadVal = 0;
342 pCommonParam->CbPadVal = 0;
343 pCommonParam->CrPadVal = 0;
345 switch ((EXYNOS_OMX_COLOR_FORMATTYPE)pExynosInputPort->portDefinition.format.video.eColorFormat) {
346 case OMX_COLOR_FormatYUV420SemiPlanar:
347 case OMX_COLOR_FormatYUV420Planar: /* Converted to NV12 in Exynos_Preprocessor_InputData */
348 #ifdef TIZEN_FEATURE_E3250
349 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
351 #ifdef USE_METADATABUFFERTYPE
352 case OMX_COLOR_FormatAndroidOpaque:
354 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12;
356 case OMX_SEC_COLOR_FormatNV12Tiled:
357 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
358 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
360 case OMX_SEC_COLOR_FormatNV21Linear:
361 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV21;
364 pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
368 /* H263 specific parameters */
369 pH263Param->FrameRate = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
371 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
372 /* rate control related parameters */
373 switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
374 case OMX_Video_ControlRateVariable:
375 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
376 pCommonParam->EnableFRMRateControl = 0; /* 0: Disable, 1: Frame level RC */
377 pCommonParam->EnableMBRateControl = 0; /* 0: Disable, 1:MB level RC */
378 pCommonParam->CBRPeriodRf = 100;
380 case OMX_Video_ControlRateConstant:
381 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode CBR");
382 pCommonParam->EnableFRMRateControl = 1; /* 0: Disable, 1: Frame level RC */
383 pCommonParam->EnableMBRateControl = 1; /* 0: Disable, 1:MB level RC */
384 pCommonParam->CBRPeriodRf = 10;
386 case OMX_Video_ControlRateDisable:
387 default: /*Android default */
388 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
389 pCommonParam->EnableFRMRateControl = 0;
390 pCommonParam->EnableMBRateControl = 0;
391 pCommonParam->CBRPeriodRf = 100;
395 Print_H263Enc_Param(pEncParam);
398 static void Change_Mpeg4Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
400 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
401 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
402 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
403 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
404 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
406 ExynosVideoEncOps *pEncOps = NULL;
407 ExynosVideoEncParam *pEncParam = NULL;
408 ExynosVideoEncCommonParam *pCommonParam = NULL;
409 ExynosVideoEncMpeg4Param *pMpeg4Param = NULL;
413 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
414 pMpeg4Enc = pVideoEnc->hCodecHandle;
415 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
416 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
417 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
418 pEncOps = pMFCMpeg4Handle->pEncOps;
420 pEncParam = &pMFCMpeg4Handle->encParam;
421 pCommonParam = &pEncParam->commonParam;
422 pMpeg4Param = &pEncParam->codecParam.mpeg4;
424 if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
425 setParam = VIDEO_FRAME_I;
426 pEncOps->Set_FrameType(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
427 pVideoEnc->IntraRefreshVOP = OMX_FALSE;
429 if (pCommonParam->IDRPeriod != (int)pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
430 setParam = pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames + 1;
431 pEncOps->Set_IDRPeriod(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
433 if (pCommonParam->Bitrate != (int)pExynosOutputPort->portDefinition.format.video.nBitrate) {
434 setParam = pExynosOutputPort->portDefinition.format.video.nBitrate;
435 pEncOps->Set_BitRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
437 if (pMpeg4Param->TimeIncreamentRes != (int)((pExynosInputPort->portDefinition.format.video.xFramerate) >> 16)) {
438 setParam = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
439 pEncOps->Set_FrameRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
442 Set_Mpeg4Enc_Param(pExynosComponent);
445 static void Change_H263Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
447 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
448 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
449 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
450 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
451 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle;
453 ExynosVideoEncOps *pEncOps = NULL;
454 ExynosVideoEncParam *pEncParam = NULL;
455 ExynosVideoEncCommonParam *pCommonParam = NULL;
456 ExynosVideoEncH263Param *pH263Param = NULL;
460 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
461 pMpeg4Enc = pVideoEnc->hCodecHandle;
462 pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
463 pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
464 pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
465 pEncOps = pMFCMpeg4Handle->pEncOps;
467 pEncParam = &pMFCMpeg4Handle->encParam;
468 pCommonParam = &pEncParam->commonParam;
469 pH263Param = &pEncParam->codecParam.h263;
471 if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
472 setParam = VIDEO_FRAME_I;
473 pEncOps->Set_FrameType(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
474 pVideoEnc->IntraRefreshVOP = OMX_FALSE;
476 if (pCommonParam->IDRPeriod != (int)pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1) {
477 setParam = pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames + 1;
478 pEncOps->Set_IDRPeriod(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
480 if (pCommonParam->Bitrate != (int)pExynosOutputPort->portDefinition.format.video.nBitrate) {
481 setParam = pExynosOutputPort->portDefinition.format.video.nBitrate;
482 pEncOps->Set_BitRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
484 if (pH263Param->FrameRate != (int)((pExynosInputPort->portDefinition.format.video.xFramerate) >> 16)) {
485 setParam = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
486 pEncOps->Set_FrameRate(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, setParam);
489 Set_H263Enc_Param(pExynosComponent);
492 OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
494 OMX_ERRORTYPE ret = OMX_ErrorNone;
500 OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR *pVirtAddr, OMX_U32 *dataSize)
502 OMX_ERRORTYPE ret = OMX_ErrorNone;
503 ExynosVideoBuffer *pCodecBuffer;
505 if (codecBuffer == NULL) {
506 ret = OMX_ErrorBadParameter;
510 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
512 if (pVirtAddr != NULL)
513 *pVirtAddr = pCodecBuffer->planes[0].addr;
515 if (dataSize != NULL)
516 *dataSize = pCodecBuffer->planes[0].allocSize;
518 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
524 OMX_ERRORTYPE Mpeg4CodecOpen(EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc)
526 OMX_ERRORTYPE ret = OMX_ErrorNone;
528 ExynosVideoEncOps *pEncOps = NULL;
529 ExynosVideoEncBufferOps *pInbufOps = NULL;
530 ExynosVideoEncBufferOps *pOutbufOps = NULL;
531 enum v4l2_memory v4l2MemoryType = V4L2_MEMORY_USERPTR;
535 if (pMpeg4Enc == NULL) {
536 ret = OMX_ErrorBadParameter;
537 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
541 /* alloc ops structure */
542 pEncOps = (ExynosVideoEncOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncOps));
543 pInbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
544 pOutbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
546 if ((pEncOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
547 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate encoder ops buffer");
548 ret = OMX_ErrorInsufficientResources;
552 pMpeg4Enc->hMFCMpeg4Handle.pEncOps = pEncOps;
553 pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = pInbufOps;
554 pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = pOutbufOps;
556 /* function pointer mapping */
557 pEncOps->nSize = sizeof(ExynosVideoEncOps);
558 pInbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
559 pOutbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
561 Exynos_Video_Register_Encoder(pEncOps, pInbufOps, pOutbufOps);
563 /* check mandatory functions for encoder ops */
564 if ((pEncOps->Init == NULL) || (pEncOps->Finalize == NULL) ||
565 (pEncOps->Set_FrameTag == NULL) || (pEncOps->Get_FrameTag == NULL)) {
566 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
567 ret = OMX_ErrorInsufficientResources;
571 /* check mandatory functions for buffer ops */
572 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
573 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
574 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
575 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
576 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
577 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
578 ret = OMX_ErrorInsufficientResources;
582 if (pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
584 v4l2MemoryType = V4L2_MEMORY_DMABUF;
585 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "using Enc V4L2_MEMORY_DMABUF");
587 v4l2MemoryType = V4L2_MEMORY_USERPTR;
588 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "using Enc V4L2_MEMORY_USEPTR");
591 //v4l2MemoryType = V4L2_MEMORY_MMAP;
592 v4l2MemoryType = V4L2_MEMORY_DMABUF; //if input port is using Buffer-share mode
593 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "using Enc V4L2_MEMORY - DMABUF & MMAP");
596 /* alloc context, open, querycap */
597 pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.pEncOps->Init(v4l2MemoryType);
598 if (pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle == NULL) {
599 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
600 ret = OMX_ErrorInsufficientResources;
607 if (ret != OMX_ErrorNone) {
608 if (pEncOps != NULL) {
609 Exynos_OSAL_Free(pEncOps);
610 pMpeg4Enc->hMFCMpeg4Handle.pEncOps = NULL;
612 if (pInbufOps != NULL) {
613 Exynos_OSAL_Free(pInbufOps);
614 pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = NULL;
616 if (pOutbufOps != NULL) {
617 Exynos_OSAL_Free(pOutbufOps);
618 pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = NULL;
627 OMX_ERRORTYPE Mpeg4CodecClose(EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc)
629 OMX_ERRORTYPE ret = OMX_ErrorNone;
630 void *hMFCHandle = NULL;
631 ExynosVideoEncOps *pEncOps = NULL;
632 ExynosVideoEncBufferOps *pInbufOps = NULL;
633 ExynosVideoEncBufferOps *pOutbufOps = NULL;
637 if (pMpeg4Enc == NULL) {
638 ret = OMX_ErrorBadParameter;
642 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
643 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
644 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
645 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
647 if (hMFCHandle != NULL) {
648 pEncOps->Finalize(hMFCHandle);
649 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = NULL;
651 if (pOutbufOps != NULL) {
652 Exynos_OSAL_Free(pOutbufOps);
653 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps = NULL;
655 if (pInbufOps != NULL) {
656 Exynos_OSAL_Free(pInbufOps);
657 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps = NULL;
659 if (pEncOps != NULL) {
660 Exynos_OSAL_Free(pEncOps);
661 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps = NULL;
672 OMX_ERRORTYPE Mpeg4CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
674 OMX_ERRORTYPE ret = OMX_ErrorNone;
675 void *hMFCHandle = NULL;
676 ExynosVideoEncOps *pEncOps = NULL;
677 ExynosVideoEncBufferOps *pInbufOps = NULL;
678 ExynosVideoEncBufferOps *pOutbufOps = NULL;
679 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
680 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
684 if (pOMXComponent == NULL) {
685 ret = OMX_ErrorBadParameter;
689 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
690 if (pVideoEnc == NULL) {
691 ret = OMX_ErrorBadParameter;
695 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
696 if (pMpeg4Enc == NULL) {
697 ret = OMX_ErrorBadParameter;
701 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
702 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
703 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
704 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
706 if (nPortIndex == INPUT_PORT_INDEX)
707 pInbufOps->Run(hMFCHandle);
708 else if (nPortIndex == OUTPUT_PORT_INDEX)
709 pOutbufOps->Run(hMFCHandle);
719 OMX_ERRORTYPE Mpeg4CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
721 OMX_ERRORTYPE ret = OMX_ErrorNone;
722 void *hMFCHandle = NULL;
723 ExynosVideoEncOps *pEncOps = NULL;
724 ExynosVideoEncBufferOps *pInbufOps = NULL;
725 ExynosVideoEncBufferOps *pOutbufOps = NULL;
726 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
727 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
731 if (pOMXComponent == NULL) {
732 ret = OMX_ErrorBadParameter;
736 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
737 if (pVideoEnc == NULL) {
738 ret = OMX_ErrorBadParameter;
741 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
742 if (pMpeg4Enc == NULL) {
743 ret = OMX_ErrorBadParameter;
747 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
748 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
749 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
750 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
752 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
753 pInbufOps->Stop(hMFCHandle);
754 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
755 pOutbufOps->Stop(hMFCHandle);
765 OMX_ERRORTYPE Mpeg4CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
767 OMX_ERRORTYPE ret = OMX_ErrorNone;
768 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
769 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
770 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
771 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
772 void *hMFCHandle = pMFCMpeg4Handle->hMFCHandle;
773 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
774 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
776 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
777 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
778 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
779 ExynosVideoEncParam *pEncParam = NULL;
781 ExynosVideoGeometry bufferConf;
782 OMX_U32 inputBufferNumber = 0;
787 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
788 Set_Mpeg4Enc_Param(pExynosComponent);
790 Set_H263Enc_Param(pExynosComponent);
792 pEncParam = &pMFCMpeg4Handle->encParam;
793 if (pEncOps->Set_EncParam) {
794 if(pEncOps->Set_EncParam(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, pEncParam) != VIDEO_ERROR_NONE) {
795 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
796 ret = OMX_ErrorInsufficientResources;
801 /* input buffer info: only 3 config values needed */
802 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
803 bufferConf.eColorFormat = pEncParam->commonParam.FrameMap;;
804 bufferConf.nFrameWidth = pExynosInputPort->portDefinition.format.video.nFrameWidth;
805 bufferConf.nFrameHeight = pExynosInputPort->portDefinition.format.video.nFrameHeight;
807 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "bufferConf, eColorFormat=%d, w=%d, h=%d", bufferConf.eColorFormat, bufferConf.nFrameWidth, bufferConf.nFrameHeight);
809 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
810 ||pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
811 pInbufOps->Set_Shareable(hMFCHandle);
813 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
814 inputBufferNumber = MAX_CAMERA_INPUTBUFFER_NUM; /* Need change to number of camera buffer */
815 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
816 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
819 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
820 /* should be done before prepare input buffer */
821 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
822 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set Enable_Cacheable for input buffer");
823 ret = OMX_ErrorInsufficientResources;
828 /* set input buffer geometry */
829 if (pInbufOps->Set_Geometry) {
831 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
832 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
833 ret = OMX_ErrorInsufficientResources;
838 /* setup input buffer */
839 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
840 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
841 ret = OMX_ErrorInsufficientResources;
845 ExynosVideoPlane planes[MFC_INPUT_BUFFER_PLANE];
848 if (pExynosInputPort->bufferProcessType & BUFFER_COPY &&
849 pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
850 /* Register input buffer */
851 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
852 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
853 planes[plane].addr = pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane];
854 planes[plane].allocSize = pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[plane];
855 planes[plane].fd = pVideoEnc->pMFCEncInputBuffer[i]->fd[plane];
857 if (pInbufOps->Register(hMFCHandle, planes, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
858 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
859 ret = OMX_ErrorInsufficientResources;
863 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
864 pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
865 ExynosVideoBuffer *pBuffer = NULL;
867 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
868 pVideoEnc->pMFCEncInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
869 /* get input buffer info */
870 if (pInbufOps->Get_Buffer) {
871 if (pInbufOps->Get_Buffer(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
872 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
873 ret = OMX_ErrorInsufficientResources;
878 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
879 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
880 pVideoEnc->pMFCEncInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
881 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
882 pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
883 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane]);
886 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
888 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
889 if (pExynosInputPort->bStoreMetaData == OMX_TRUE) {
893 /* Does not require any actions. */
895 #ifndef TIZEN_FEATURE_E3250 /* slp platform can go into here */
896 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
897 ret = OMX_ErrorNotImplemented;
909 OMX_ERRORTYPE Mpeg4CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
911 OMX_ERRORTYPE ret = OMX_ErrorNone;
912 void *hMFCHandle = NULL;
913 ExynosVideoEncOps *pEncOps = NULL;
914 ExynosVideoEncBufferOps *pInbufOps = NULL;
915 ExynosVideoEncBufferOps *pOutbufOps = NULL;
916 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
917 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
921 if (pOMXComponent == NULL) {
922 ret = OMX_ErrorBadParameter;
926 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
927 if (pVideoEnc == NULL) {
928 ret = OMX_ErrorBadParameter;
931 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
932 if (pMpeg4Enc == NULL) {
933 ret = OMX_ErrorBadParameter;
937 hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
938 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
939 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
940 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
942 if (nPortIndex == INPUT_PORT_INDEX) {
943 if (pMpeg4Enc->bSourceStart == OMX_FALSE) {
944 Exynos_OSAL_SignalSet(pMpeg4Enc->hSourceStartEvent);
945 Exynos_OSAL_SleepMillisec(0);
949 if (nPortIndex == OUTPUT_PORT_INDEX) {
950 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
951 Exynos_OSAL_SignalSet(pMpeg4Enc->hDestinationStartEvent);
952 Exynos_OSAL_SleepMillisec(0);
964 OMX_ERRORTYPE Mpeg4CodecEnqueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
966 OMX_ERRORTYPE ret = OMX_ErrorNone;
967 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
968 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
969 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
970 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
971 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
972 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
975 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
976 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
977 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
981 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
982 ret = OMX_ErrorBadPortIndex;
986 if ((nPortIndex == INPUT_PORT_INDEX) &&
987 (pMpeg4Enc->bSourceStart == OMX_TRUE)) {
988 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
990 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
991 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
992 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
993 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
995 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
998 pInbufOps->Clear_Queue(hMFCHandle);
999 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1000 (pMpeg4Enc->bDestinationStart == OMX_TRUE)) {
1001 OMX_U32 dataLen[2] = {0, 0};
1002 ExynosVideoBuffer *pBuffer = NULL;
1004 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1006 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1007 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
1008 Exynos_CodecBufferEnqueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
1009 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncOutputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncOutputBuffer[i]);
1010 // Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
1011 // Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
1013 pOutbufOps->Clear_Queue(hMFCHandle);
1022 OMX_ERRORTYPE Mpeg4CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1024 OMX_ERRORTYPE ret = OMX_ErrorNone;
1025 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1026 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1027 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1028 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
1029 void *hMFCHandle = pMFCMpeg4Handle->hMFCHandle;
1030 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1031 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1032 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1034 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1035 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1036 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1037 ExynosVideoEncParam *pEncParam = NULL;
1039 ExynosVideoGeometry bufferConf;
1040 OMX_U32 inputBufferNumber = 0;
1045 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1046 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1047 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1048 if (OMXBuffer == NULL) {
1049 ret = OMX_ErrorUndefined;
1053 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1054 OMXBuffer->nFlags = pSrcInputData->nFlags;
1055 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1057 ret = OMX_ErrorNone;
1061 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1062 Set_Mpeg4Enc_Param(pExynosComponent);
1064 Set_H263Enc_Param(pExynosComponent);
1066 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1067 pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE)) {
1068 ret = Mpeg4CodecSrcInit(pOMXComponent);
1069 if (ret != OMX_ErrorNone)
1073 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
1074 ret = OMX_ErrorNone;
1082 OMX_ERRORTYPE Mpeg4CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1084 OMX_ERRORTYPE ret = OMX_ErrorNone;
1085 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1086 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1087 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1088 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
1089 void *hMFCHandle = pMFCMpeg4Handle->hMFCHandle;
1090 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1091 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1093 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1094 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1095 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1096 ExynosVideoGeometry bufferConf;
1097 int i, nOutbufs, nPlanes, OutBufferSize;
1101 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1102 /*For memory Optimization */
1103 OutBufferSize = 1024*1024*2;//pExynosOutputPort->portDefinition.format.video.nFrameWidth * pExynosOutputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
1105 OutBufferSize = pExynosOutputPort->extendBufferHeader[0].OMXBufferHeader->nAllocLen;
1108 /* set geometry for output (dst) */
1109 if (pOutbufOps->Set_Geometry) {
1110 /* only 2 config values needed */
1111 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1112 bufferConf.eCompressionFormat = VIDEO_CODING_MPEG4;
1114 bufferConf.eCompressionFormat = VIDEO_CODING_H263;
1115 bufferConf.nSizeImage = OutBufferSize;
1117 if (pOutbufOps->Set_Geometry(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1118 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1119 ret = OMX_ErrorInsufficientResources;
1124 /* should be done before prepare output buffer */
1125 if (pOutbufOps->Enable_Cacheable) {
1126 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1127 ret = OMX_ErrorInsufficientResources;
1132 if (pOutbufOps->Set_Shareable) {
1133 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1134 ||pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
1135 pOutbufOps->Set_Shareable(hMFCHandle);
1137 int SetupBufferNumber = 0;
1138 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY)
1139 SetupBufferNumber = MFC_OUTPUT_BUFFER_NUM_MAX;
1141 SetupBufferNumber = pExynosOutputPort->portDefinition.nBufferCountActual;
1142 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SetupBufferNumber:%d", SetupBufferNumber);
1144 if (pOutbufOps->Setup(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, SetupBufferNumber) != VIDEO_ERROR_NONE) {
1145 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1146 ret = OMX_ErrorInsufficientResources;
1150 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0};
1151 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1152 if (pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
1153 /* Register input buffer */
1154 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1155 ExynosVideoPlane plane;
1156 pVideoEnc->pMFCEncOutputBuffer[i] = (CODEC_ENC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
1157 pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0] =
1158 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, OutBufferSize, NORMAL_MEMORY);
1159 if (pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0] == NULL) {
1160 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
1161 ret = OMX_ErrorInsufficientResources;
1164 pVideoEnc->pMFCEncOutputBuffer[i]->fd[0] =
1165 Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0]);
1166 pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[0] = OutBufferSize;
1168 plane.addr = pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0];
1169 plane.fd = pVideoEnc->pMFCEncOutputBuffer[i]->fd[0];
1170 plane.allocSize = pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[0];
1172 if (pOutbufOps->Register(hMFCHandle, &plane, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1173 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1174 ret = OMX_ErrorInsufficientResources;
1177 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr,
1178 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1180 }else if (pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
1181 /* Register input buffer */
1182 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1183 ExynosVideoBuffer *pBuffer = NULL;
1185 pVideoEnc->pMFCEncOutputBuffer[i] = (CODEC_ENC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
1187 if (pOutbufOps->Get_Buffer) {
1188 if (pOutbufOps->Get_Buffer(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1189 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1190 ret = OMX_ErrorInsufficientResources;
1195 for (nPlanes = 0; nPlanes < MFC_OUTPUT_BUFFER_PLANE; nPlanes++) {
1196 pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[nPlanes] = (void *)pBuffer->planes[nPlanes].addr;
1197 pVideoEnc->pMFCEncOutputBuffer[i]->fd[nPlanes] = pBuffer->planes[nPlanes].fd;
1198 pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[nPlanes] = pBuffer->planes[nPlanes].allocSize;
1199 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncOutputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[nPlanes]);
1202 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr,
1203 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1207 /* start header encoding */
1208 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1209 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1210 ret = OMX_ErrorInsufficientResources;
1213 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1214 /* Register input buffer */
1218 ExynosVideoPlane plane;
1219 for (i = 0; i < pExynosOutputPort->portDefinition.nBufferCountActual; i++) {
1220 plane.addr = pExynosOutputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
1221 plane.fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[0];
1222 plane.allocSize = pExynosOutputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
1223 if (pOutbufOps->Register(hMFCHandle, &plane, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1224 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
1225 ret = OMX_ErrorInsufficientResources;
1231 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1233 ret = OMX_ErrorNone;
1241 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetParameter(
1242 OMX_IN OMX_HANDLETYPE hComponent,
1243 OMX_IN OMX_INDEXTYPE nParamIndex,
1244 OMX_INOUT OMX_PTR pComponentParameterStructure)
1246 OMX_ERRORTYPE ret = OMX_ErrorNone;
1247 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1248 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1252 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1253 ret = OMX_ErrorBadParameter;
1256 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1257 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1258 if (ret != OMX_ErrorNone) {
1261 if (pOMXComponent->pComponentPrivate == NULL) {
1262 ret = OMX_ErrorBadParameter;
1266 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1267 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1268 ret = OMX_ErrorInvalidState;
1272 switch (nParamIndex) {
1273 case OMX_IndexParamVideoMpeg4:
1275 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1276 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = NULL;
1277 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1279 ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1280 if (ret != OMX_ErrorNone) {
1284 if (pDstMpeg4Component->nPortIndex >= ALL_PORT_NUM) {
1285 ret = OMX_ErrorBadPortIndex;
1289 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1290 pSrcMpeg4Component = &pMpeg4Enc->mpeg4Component[pDstMpeg4Component->nPortIndex];
1292 Exynos_OSAL_Memcpy(pDstMpeg4Component, pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1295 case OMX_IndexParamVideoH263:
1297 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1298 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = NULL;
1299 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1301 ret = Exynos_OMX_Check_SizeVersion(pDstH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1302 if (ret != OMX_ErrorNone) {
1306 if (pDstH263Component->nPortIndex >= ALL_PORT_NUM) {
1307 ret = OMX_ErrorBadPortIndex;
1311 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1312 pSrcH263Component = &pMpeg4Enc->h263Component[pDstH263Component->nPortIndex];
1314 Exynos_OSAL_Memcpy(pDstH263Component, pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1317 case OMX_IndexParamStandardComponentRole:
1320 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1321 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1322 if (ret != OMX_ErrorNone) {
1326 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1327 if (codecType == CODEC_TYPE_MPEG4)
1328 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE);
1330 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE);
1333 case OMX_IndexParamVideoProfileLevelQuerySupported:
1335 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1336 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1337 OMX_U32 maxProfileLevelNum = 0;
1340 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1341 if (ret != OMX_ErrorNone) {
1345 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1346 ret = OMX_ErrorBadPortIndex;
1350 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1351 if (codecType == CODEC_TYPE_MPEG4) {
1352 pProfileLevel = supportedMPEG4ProfileLevels;
1353 maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1355 pProfileLevel = supportedH263ProfileLevels;
1356 maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1359 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1360 ret = OMX_ErrorNoMore;
1364 pProfileLevel += pDstProfileLevel->nProfileIndex;
1365 pDstProfileLevel->eProfile = pProfileLevel->profile;
1366 pDstProfileLevel->eLevel = pProfileLevel->level;
1369 case OMX_IndexParamVideoProfileLevelCurrent:
1371 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1372 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = NULL;
1373 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = NULL;
1374 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1377 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1378 if (ret != OMX_ErrorNone) {
1382 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1383 ret = OMX_ErrorBadPortIndex;
1387 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1388 codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
1389 if (codecType == CODEC_TYPE_MPEG4) {
1390 pSrcMpeg4Component = &pMpeg4Enc->mpeg4Component[pDstProfileLevel->nPortIndex];
1391 pDstProfileLevel->eProfile = pSrcMpeg4Component->eProfile;
1392 pDstProfileLevel->eLevel = pSrcMpeg4Component->eLevel;
1394 pSrcH263Component = &pMpeg4Enc->h263Component[pDstProfileLevel->nPortIndex];
1395 pDstProfileLevel->eProfile = pSrcH263Component->eProfile;
1396 pDstProfileLevel->eLevel = pSrcH263Component->eLevel;
1400 case OMX_IndexParamVideoErrorCorrection:
1402 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1403 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1404 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1406 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1407 if (ret != OMX_ErrorNone) {
1411 if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1412 ret = OMX_ErrorBadPortIndex;
1416 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1417 pSrcErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1419 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1420 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1421 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1422 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1423 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1427 ret = Exynos_OMX_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1436 OMX_ERRORTYPE Exynos_Mpeg4Enc_SetParameter(
1437 OMX_IN OMX_HANDLETYPE hComponent,
1438 OMX_IN OMX_INDEXTYPE nIndex,
1439 OMX_IN OMX_PTR pComponentParameterStructure)
1441 OMX_ERRORTYPE ret = OMX_ErrorNone;
1442 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1443 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1447 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1448 ret = OMX_ErrorBadParameter;
1451 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1452 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1453 if (ret != OMX_ErrorNone) {
1456 if (pOMXComponent->pComponentPrivate == NULL) {
1457 ret = OMX_ErrorBadParameter;
1461 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1462 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1463 ret = OMX_ErrorInvalidState;
1468 case OMX_IndexParamVideoMpeg4:
1470 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = NULL;
1471 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Component = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1472 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1474 ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1475 if (ret != OMX_ErrorNone) {
1479 if (pSrcMpeg4Component->nPortIndex >= ALL_PORT_NUM) {
1480 ret = OMX_ErrorBadPortIndex;
1484 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1485 pDstMpeg4Component = &pMpeg4Enc->mpeg4Component[pSrcMpeg4Component->nPortIndex];
1487 Exynos_OSAL_Memcpy(pDstMpeg4Component, pSrcMpeg4Component, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1490 case OMX_IndexParamVideoH263:
1492 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = NULL;
1493 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Component = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1494 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1496 ret = Exynos_OMX_Check_SizeVersion(pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1497 if (ret != OMX_ErrorNone) {
1501 if (pSrcH263Component->nPortIndex >= ALL_PORT_NUM) {
1502 ret = OMX_ErrorBadPortIndex;
1506 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1507 pDstH263Component = &pMpeg4Enc->h263Component[pSrcH263Component->nPortIndex];
1509 Exynos_OSAL_Memcpy(pDstH263Component, pSrcH263Component, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1512 case OMX_IndexParamStandardComponentRole:
1514 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1516 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1517 if (ret != OMX_ErrorNone) {
1521 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1522 ret = OMX_ErrorIncorrectStateOperation;
1526 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE)) {
1527 pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1528 //((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_MPEG4;
1529 } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE)) {
1530 pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1531 //((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_H263;
1533 ret = OMX_ErrorBadParameter;
1538 case OMX_IndexParamVideoProfileLevelCurrent:
1540 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1541 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Component = NULL;
1542 OMX_VIDEO_PARAM_H263TYPE *pDstH263Component = NULL;
1543 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1546 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1547 if (ret != OMX_ErrorNone)
1550 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1551 ret = OMX_ErrorBadPortIndex;
1555 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1556 codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
1557 if (codecType == CODEC_TYPE_MPEG4) {
1559 * To do: Check validity of profile & level parameters
1562 pDstMpeg4Component = &pMpeg4Enc->mpeg4Component[pSrcProfileLevel->nPortIndex];
1563 pDstMpeg4Component->eProfile = pSrcProfileLevel->eProfile;
1564 pDstMpeg4Component->eLevel = pSrcProfileLevel->eLevel;
1567 * To do: Check validity of profile & level parameters
1570 pDstH263Component = &pMpeg4Enc->h263Component[pSrcProfileLevel->nPortIndex];
1571 pDstH263Component->eProfile = pSrcProfileLevel->eProfile;
1572 pDstH263Component->eLevel = pSrcProfileLevel->eLevel;
1576 case OMX_IndexParamVideoErrorCorrection:
1578 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1579 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1580 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1582 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1583 if (ret != OMX_ErrorNone) {
1587 if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1588 ret = OMX_ErrorBadPortIndex;
1592 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1593 pDstErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1595 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1596 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1597 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1598 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1599 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1603 ret = Exynos_OMX_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1612 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetConfig(
1613 OMX_IN OMX_HANDLETYPE hComponent,
1614 OMX_IN OMX_INDEXTYPE nIndex,
1615 OMX_IN OMX_PTR pComponentConfigStructure)
1617 OMX_ERRORTYPE ret = OMX_ErrorNone;
1618 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1619 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1623 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1624 ret = OMX_ErrorBadParameter;
1627 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1628 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1629 if (ret != OMX_ErrorNone) {
1632 if (pOMXComponent->pComponentPrivate == NULL) {
1633 ret = OMX_ErrorBadParameter;
1636 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1637 if (pExynosComponent->currentState == OMX_StateInvalid) {
1638 ret = OMX_ErrorInvalidState;
1644 ret = Exynos_OMX_VideoEncodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1654 OMX_ERRORTYPE Exynos_Mpeg4Enc_SetConfig(
1655 OMX_IN OMX_HANDLETYPE hComponent,
1656 OMX_IN OMX_INDEXTYPE nIndex,
1657 OMX_IN OMX_PTR pComponentConfigStructure)
1659 OMX_ERRORTYPE ret = OMX_ErrorNone;
1660 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1661 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1662 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1663 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
1667 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1668 ret = OMX_ErrorBadParameter;
1671 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1672 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1673 if (ret != OMX_ErrorNone) {
1676 if (pOMXComponent->pComponentPrivate == NULL) {
1677 ret = OMX_ErrorBadParameter;
1680 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1681 if (pExynosComponent->currentState == OMX_StateInvalid) {
1682 ret = OMX_ErrorInvalidState;
1686 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1687 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)pVideoEnc->hCodecHandle;
1690 case OMX_IndexConfigVideoIntraPeriod:
1692 OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
1694 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
1695 pMpeg4Enc->mpeg4Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1697 pMpeg4Enc->h263Component[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1699 ret = OMX_ErrorNone;
1703 ret = Exynos_OMX_VideoEncodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1708 if (ret == OMX_ErrorNone)
1709 pVideoEnc->configChange = OMX_TRUE;
1716 OMX_ERRORTYPE Exynos_Mpeg4Enc_GetExtensionIndex(
1717 OMX_IN OMX_HANDLETYPE hComponent,
1718 OMX_IN OMX_STRING cParameterName,
1719 OMX_OUT OMX_INDEXTYPE *pIndexType)
1721 OMX_ERRORTYPE ret = OMX_ErrorNone;
1722 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1723 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1727 if (hComponent == NULL) {
1728 ret = OMX_ErrorBadParameter;
1731 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1732 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1733 if (ret != OMX_ErrorNone) {
1736 if (pOMXComponent->pComponentPrivate == NULL) {
1737 ret = OMX_ErrorBadParameter;
1740 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1741 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1742 ret = OMX_ErrorBadParameter;
1745 if (pExynosComponent->currentState == OMX_StateInvalid) {
1746 ret = OMX_ErrorInvalidState;
1749 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
1750 *pIndexType = OMX_IndexConfigVideoIntraPeriod;
1751 ret = OMX_ErrorNone;
1753 ret = Exynos_OMX_VideoEncodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1762 OMX_ERRORTYPE Exynos_Mpeg4Enc_ComponentRoleEnum(
1763 OMX_IN OMX_HANDLETYPE hComponent,
1764 OMX_OUT OMX_U8 *cRole,
1765 OMX_IN OMX_U32 nIndex)
1767 OMX_ERRORTYPE ret = OMX_ErrorNone;
1768 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1769 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1774 if ((hComponent == NULL) || (cRole == NULL)) {
1775 ret = OMX_ErrorBadParameter;
1778 if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) { /* supports only one role */
1779 ret = OMX_ErrorNoMore;
1782 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1783 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1784 if (ret != OMX_ErrorNone) {
1787 if (pOMXComponent->pComponentPrivate == NULL) {
1788 ret = OMX_ErrorBadParameter;
1792 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1793 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1794 ret = OMX_ErrorInvalidState;
1798 codecType = ((EXYNOS_MPEG4ENC_HANDLE *)(((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1799 if (codecType == CODEC_TYPE_MPEG4)
1800 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_ENC_ROLE);
1802 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_ENC_ROLE);
1811 OMX_ERRORTYPE Exynos_Mpeg4Enc_Init(OMX_COMPONENTTYPE *pOMXComponent)
1813 OMX_ERRORTYPE ret = OMX_ErrorNone;
1814 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1815 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1816 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1817 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1818 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;;
1819 EXYNOS_MFC_MPEG4ENC_HANDLE *pMFCMpeg4Handle = &pMpeg4Enc->hMFCMpeg4Handle;
1820 OMX_PTR hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
1821 OMX_COLOR_FORMATTYPE eColorFormat;
1823 ExynosVideoEncOps *pEncOps = NULL;
1824 ExynosVideoEncBufferOps *pInbufOps = NULL;
1825 ExynosVideoEncBufferOps *pOutbufOps = NULL;
1827 CSC_METHOD csc_method = CSC_METHOD_SW;
1832 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
1833 pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
1834 pVideoEnc->bFirstOutput = OMX_FALSE;
1835 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1836 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1838 eColorFormat = pExynosInputPort->portDefinition.format.video.eColorFormat;
1839 if (pExynosInputPort->bStoreMetaData == OMX_TRUE) {
1840 #ifndef TIZEN_FEATURE_E3250 /* we do not use OMX_COLOR_FormatAndroidOpaque */
1841 if (eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
1842 pExynosInputPort->bufferProcessType = BUFFER_COPY;
1844 pExynosInputPort->bufferProcessType = BUFFER_SHARE;
1848 if (eColorFormat == OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd ||
1849 eColorFormat == OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd) {
1850 pExynosInputPort->bufferProcessType = BUFFER_SHARE;
1852 pExynosInputPort->bufferProcessType = BUFFER_COPY;
1856 /* Mpeg4/H.263 Codec Open */
1857 ret = Mpeg4CodecOpen(pMpeg4Enc);
1858 if (ret != OMX_ErrorNone) {
1862 pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1863 pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1864 pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1866 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1867 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1868 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1870 if (pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
1871 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1872 pVideoEnc->pMFCEncInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
1873 /* Use ION Allocator */
1875 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_YBUFFER_SIZE, NORMAL_MEMORY);
1876 pVideoEnc->pMFCEncInputBuffer[i]->fd[0] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
1877 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[0] = DEFAULT_MFC_INPUT_YBUFFER_SIZE;
1879 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_CBUFFER_SIZE, NORMAL_MEMORY);
1880 pVideoEnc->pMFCEncInputBuffer[i]->fd[1] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
1881 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[1] = DEFAULT_MFC_INPUT_CBUFFER_SIZE;
1883 pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
1885 if ((pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] == NULL) ||
1886 (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] == NULL)) {
1887 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1888 ret = OMX_ErrorInsufficientResources;
1892 /* MFC input buffers are 1 plane. */
1893 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[2] = NULL;
1894 pVideoEnc->pMFCEncInputBuffer[i]->fd[2] = -1;
1895 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[2] = 0;
1897 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
1898 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
1899 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
1901 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
1904 ret = Mpeg4CodecSrcInit(pOMXComponent);
1905 if (ret != OMX_ErrorNone)
1908 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1912 /* Does not require any actions. */
1915 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1916 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1917 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1918 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1922 /* Does not require any actions. */
1925 pMpeg4Enc->bSourceStart = OMX_FALSE;
1926 Exynos_OSAL_SignalCreate(&pMpeg4Enc->hSourceStartEvent);
1927 pMpeg4Enc->bDestinationStart = OMX_FALSE;
1928 Exynos_OSAL_SignalCreate(&pMpeg4Enc->hDestinationStartEvent);
1930 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1931 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1932 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp = 0;
1933 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp = 0;
1935 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1937 #if 0//defined(USE_CSC_GSCALER)
1938 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
1940 pVideoEnc->csc_handle = csc_init(csc_method);
1941 if (pVideoEnc->csc_handle == NULL) {
1942 ret = OMX_ErrorInsufficientResources;
1945 pVideoEnc->csc_set_format = OMX_FALSE;
1954 OMX_ERRORTYPE Exynos_Mpeg4Enc_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1956 OMX_ERRORTYPE ret = OMX_ErrorNone;
1957 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1958 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle);
1959 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1960 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1961 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1962 OMX_PTR hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
1964 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
1965 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
1966 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
1968 int i = 0, plane = 0;
1972 if (pVideoEnc->csc_handle != NULL) {
1973 csc_deinit(pVideoEnc->csc_handle);
1974 pVideoEnc->csc_handle = NULL;
1977 Exynos_OSAL_SignalTerminate(pMpeg4Enc->hDestinationStartEvent);
1978 pMpeg4Enc->hDestinationStartEvent = NULL;
1979 pMpeg4Enc->bDestinationStart = OMX_FALSE;
1980 Exynos_OSAL_SignalTerminate(pMpeg4Enc->hSourceStartEvent);
1981 pMpeg4Enc->hSourceStartEvent = NULL;
1982 pMpeg4Enc->bSourceStart = OMX_FALSE;
1984 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1985 if (pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
1986 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1987 if (pVideoEnc->pMFCEncInputBuffer[i] != NULL) {
1988 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
1989 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1990 if (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane] != NULL)
1991 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane]);
1994 Exynos_OSAL_Free(pVideoEnc->pMFCEncInputBuffer[i]);
1995 pVideoEnc->pMFCEncInputBuffer[i] = NULL;
2000 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2001 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2002 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2006 /* Does not require any actions. */
2009 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2010 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2011 if (pVideoEnc->pMFCEncInputBuffer[i] != NULL) {
2012 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2013 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2014 if (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane] != NULL)
2015 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane]);
2018 Exynos_OSAL_Free(pVideoEnc->pMFCEncInputBuffer[i]);
2019 pVideoEnc->pMFCEncInputBuffer[i] = NULL;
2023 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2024 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2025 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2029 /* Does not require any actions. */
2031 Mpeg4CodecClose(pMpeg4Enc);
2039 OMX_ERRORTYPE Exynos_Mpeg4Enc_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2041 OMX_ERRORTYPE ret = OMX_ErrorNone;
2042 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2043 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2044 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2045 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2046 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2047 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2048 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2049 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2050 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
2051 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
2052 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2057 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
2058 ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
2059 // if ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)
2060 if (ret != OMX_ErrorNone)
2063 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
2064 ret = Mpeg4CodecDstSetup(pOMXComponent);
2067 if (pVideoEnc->configChange == OMX_TRUE) {
2068 if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
2069 Change_Mpeg4Enc_Param(pExynosComponent);
2071 Change_H263Enc_Param(pExynosComponent);
2073 pVideoEnc->configChange = OMX_FALSE;
2077 if ((pSrcInputData->dataLen >= 0) ||
2078 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2079 OMX_U32 pMFCYUVDataSize[MFC_INPUT_BUFFER_PLANE] = {NULL, NULL};
2080 ExynosVideoPlane planes[MFC_INPUT_BUFFER_PLANE];
2083 pExynosComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
2084 pExynosComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
2085 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);
2086 pEncOps->Set_FrameTag(hMFCHandle, pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp);
2087 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp++;
2088 pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
2090 /* queue work for input buffer */
2091 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Exynos_Mpeg4Enc_SrcIn(): oneFrameSize: %d, bufferHeader: 0x%x", oneFrameSize, pSrcInputData->bufferHeader);
2092 pMFCYUVDataSize[0] = pExynosInputPort->portDefinition.format.video.nFrameWidth * pExynosInputPort->portDefinition.format.video.nFrameHeight;
2093 pMFCYUVDataSize[1] = pMFCYUVDataSize[0]/2;
2095 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.dataBuffer,
2096 (unsigned int *)pMFCYUVDataSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2097 //#ifdef USE_METADATABUFFERTYPE
2098 if ((codecReturn == VIDEO_ERROR_NOBUFFERS) &&
2099 /*(pExynosInputPort->bStoreMetaData == OMX_TRUE) &&*/
2100 (pExynosInputPort->bufferProcessType & BUFFER_SHARE)) {
2101 OMX_U32 nAllocLen[MFC_INPUT_BUFFER_PLANE] = {0, 0};
2102 nAllocLen[0] = ALIGN_TO_16B(pExynosInputPort->portDefinition.format.video.nFrameWidth) *
2103 ALIGN_TO_16B(pExynosInputPort->portDefinition.format.video.nFrameHeight);
2104 nAllocLen[1] = ALIGN(nAllocLen[0]/2,256);
2105 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2106 planes[plane].addr = pSrcInputData->buffer.multiPlaneBuffer.dataBuffer[plane];
2107 planes[plane].allocSize = nAllocLen[plane];
2108 planes[plane].fd = pSrcInputData->buffer.multiPlaneBuffer.fd[plane];
2111 /* Register input buffer */
2112 if (pInbufOps->Register(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle,
2113 planes, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
2114 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
2115 ret = OMX_ErrorInsufficientResources;
2118 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.dataBuffer,
2119 (unsigned int *)pMFCYUVDataSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2123 if (codecReturn != VIDEO_ERROR_NONE) {
2124 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pInbufOps->Enqueue", __FUNCTION__, __LINE__);
2125 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2128 Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2129 if (pMpeg4Enc->bSourceStart == OMX_FALSE) {
2130 pMpeg4Enc->bSourceStart = OMX_TRUE;
2131 Exynos_OSAL_SignalSet(pMpeg4Enc->hSourceStartEvent);
2132 Exynos_OSAL_SleepMillisec(0);
2134 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
2135 pMpeg4Enc->bDestinationStart = OMX_TRUE;
2136 Exynos_OSAL_SignalSet(pMpeg4Enc->hDestinationStartEvent);
2137 Exynos_OSAL_SleepMillisec(0);
2141 ret = OMX_ErrorNone;
2149 OMX_ERRORTYPE Exynos_Mpeg4Enc_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2151 OMX_ERRORTYPE ret = OMX_ErrorNone;
2152 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2153 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2154 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2155 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2156 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2157 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2158 ExynosVideoEncBufferOps *pInbufOps = pMpeg4Enc->hMFCMpeg4Handle.pInbufOps;
2159 ExynosVideoBuffer *pVideoBuffer;
2163 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2165 pSrcOutputData->dataLen = 0;
2166 pSrcOutputData->usedDataLen = 0;
2167 pSrcOutputData->remainDataLen = 0;
2168 pSrcOutputData->nFlags = 0;
2169 pSrcOutputData->timeStamp = 0;
2171 if (pVideoBuffer == NULL) {
2172 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2173 pSrcOutputData->allocSize = 0;
2174 pSrcOutputData->pPrivate = NULL;
2175 pSrcOutputData->bufferHeader = NULL;
2178 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2179 pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2180 pSrcOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2182 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize +
2183 pVideoBuffer->planes[1].allocSize +
2184 pVideoBuffer->planes[2].allocSize;
2186 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2188 while (pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[0] != pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]) {
2190 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2191 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - Lost buffer", __FUNCTION__, __LINE__);
2192 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2196 pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
2197 pSrcOutputData->pPrivate = pVideoEnc->pMFCEncInputBuffer[i];
2200 /* For Share Buffer */
2201 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2204 ret = OMX_ErrorNone;
2212 OMX_ERRORTYPE Exynos_Mpeg4Enc_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2214 OMX_ERRORTYPE ret = OMX_ErrorNone;
2215 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2216 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2217 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2218 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2219 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2220 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
2221 OMX_U32 dataLen = 0;
2222 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2226 if (pDstInputData->buffer.singlePlaneBuffer.dataBuffer == NULL) {
2227 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2228 ret = OMX_ErrorBadParameter;
2232 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)&pDstInputData->buffer.singlePlaneBuffer.dataBuffer,
2233 (unsigned int *)&dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2235 if (codecReturn != VIDEO_ERROR_NONE) {
2236 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pOutbufOps->Enqueue", __FUNCTION__, __LINE__);
2237 ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2240 Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2242 ret = OMX_ErrorNone;
2250 OMX_ERRORTYPE Exynos_Mpeg4Enc_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2252 OMX_ERRORTYPE ret = OMX_ErrorNone;
2253 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2254 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2255 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2256 void *hMFCHandle = pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle;
2257 ExynosVideoEncOps *pEncOps = pMpeg4Enc->hMFCMpeg4Handle.pEncOps;
2258 ExynosVideoEncBufferOps *pOutbufOps = pMpeg4Enc->hMFCMpeg4Handle.pOutbufOps;
2259 ExynosVideoBuffer *pVideoBuffer;
2260 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2261 ExynosVideoGeometry bufferGeometry;
2262 OMX_S32 indexTimestamp = 0;
2266 if (pMpeg4Enc->bDestinationStart == OMX_FALSE) {
2267 ret = OMX_ErrorNone;
2271 if ((pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle)) == NULL) {
2272 ret = OMX_ErrorNone;
2276 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp++;
2277 pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2279 pDstOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2280 pDstOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2281 pDstOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2282 pDstOutputData->dataLen = pVideoBuffer->planes[0].dataSize;
2283 pDstOutputData->remainDataLen = pVideoBuffer->planes[0].dataSize;
2284 pDstOutputData->usedDataLen = 0;
2285 pDstOutputData->pPrivate = pVideoBuffer;
2286 /* For Share Buffer */
2287 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2289 if (pVideoEnc->bFirstOutput == OMX_FALSE) {
2292 pDstOutputData->timeStamp = 0;
2293 pDstOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
2294 pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2295 pVideoEnc->bFirstOutput = OMX_TRUE;
2297 indexTimestamp = pEncOps->Get_FrameTag(pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle);
2298 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2299 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp];
2300 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Enc->hMFCMpeg4Handle.outputIndexTimestamp];
2302 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2303 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2306 pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2307 if (pVideoBuffer->frameType == VIDEO_FRAME_I)
2308 pDstOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
2311 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2312 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2313 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%x displayStatus:%d, nFlags0x%x", pExynosComponent, displayStatus, pDstOutputData->nFlags);
2314 pDstOutputData->remainDataLen = 0;
2317 ret = OMX_ErrorNone;
2325 OMX_ERRORTYPE Exynos_Mpeg4Enc_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2327 OMX_ERRORTYPE ret = OMX_ErrorNone;
2328 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2329 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2330 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2334 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2335 ret = OMX_ErrorNone;
2338 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2339 ret = OMX_ErrorNone;
2343 ret = Exynos_Mpeg4Enc_SrcIn(pOMXComponent, pSrcInputData);
2344 if (ret != OMX_ErrorNone) {
2345 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcIn -> event is thrown to client", __FUNCTION__, __LINE__);
2346 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2347 pExynosComponent->callbackData,
2348 OMX_EventError, ret, 0, NULL);
2357 OMX_ERRORTYPE Exynos_Mpeg4Enc_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2359 OMX_ERRORTYPE ret = OMX_ErrorNone;
2360 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2361 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2362 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2366 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2367 ret = OMX_ErrorNone;
2371 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2372 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2373 ret = OMX_ErrorNone;
2377 if ((pMpeg4Enc->bSourceStart == OMX_FALSE) &&
2378 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2379 Exynos_OSAL_SignalWait(pMpeg4Enc->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2380 Exynos_OSAL_SignalReset(pMpeg4Enc->hSourceStartEvent);
2383 ret = Exynos_Mpeg4Enc_SrcOut(pOMXComponent, pSrcOutputData);
2384 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2385 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcOut -> event is thrown to client", __FUNCTION__, __LINE__);
2386 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2387 pExynosComponent->callbackData,
2388 OMX_EventError, ret, 0, NULL);
2397 OMX_ERRORTYPE Exynos_Mpeg4Enc_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2399 OMX_ERRORTYPE ret = OMX_ErrorNone;
2400 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2401 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2402 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2406 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2407 ret = OMX_ErrorNone;
2410 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2411 ret = OMX_ErrorNone;
2414 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2415 if ((pMpeg4Enc->bDestinationStart == OMX_FALSE) &&
2416 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2417 Exynos_OSAL_SignalWait(pMpeg4Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2418 Exynos_OSAL_SignalReset(pMpeg4Enc->hDestinationStartEvent);
2421 if (pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2422 ret = Exynos_Mpeg4Enc_DstIn(pOMXComponent, pDstInputData);
2423 if (ret != OMX_ErrorNone) {
2424 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstIn -> event is thrown to client", __FUNCTION__, __LINE__);
2425 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2426 pExynosComponent->callbackData,
2427 OMX_EventError, ret, 0, NULL);
2437 OMX_ERRORTYPE Exynos_Mpeg4Enc_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2439 OMX_ERRORTYPE ret = OMX_ErrorNone;
2440 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2441 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2442 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2446 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2447 ret = OMX_ErrorNone;
2450 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2451 ret = OMX_ErrorNone;
2455 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2456 if ((pMpeg4Enc->bDestinationStart == OMX_FALSE) &&
2457 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2458 Exynos_OSAL_SignalWait(pMpeg4Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2459 Exynos_OSAL_SignalReset(pMpeg4Enc->hDestinationStartEvent);
2462 ret = Exynos_Mpeg4Enc_DstOut(pOMXComponent, pDstOutputData);
2463 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2464 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstOut -> event is thrown to client", __FUNCTION__, __LINE__);
2465 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2466 pExynosComponent->callbackData,
2467 OMX_EventError, ret, 0, NULL);
2476 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2477 OMX_HANDLETYPE hComponent,
2478 OMX_STRING componentName)
2480 OMX_ERRORTYPE ret = OMX_ErrorNone;
2481 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2482 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2483 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2484 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
2485 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
2486 OMX_S32 codecType = -1;
2491 if ((hComponent == NULL) || (componentName == NULL)) {
2492 ret = OMX_ErrorBadParameter;
2493 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
2496 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_ENC, componentName) == 0) {
2497 codecType = CODEC_TYPE_MPEG4;
2498 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_ENC, componentName) == 0) {
2499 codecType = CODEC_TYPE_H263;
2501 ret = OMX_ErrorBadParameter;
2502 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, componentName, ret);
2506 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2507 ret = Exynos_OMX_VideoEncodeComponentInit(pOMXComponent);
2508 if (ret != OMX_ErrorNone) {
2509 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Exynos_OMX_VideoDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
2512 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2513 pExynosComponent->codecType = HW_VIDEO_ENC_CODEC;
2515 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2516 if (pExynosComponent->componentName == NULL) {
2517 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2518 ret = OMX_ErrorInsufficientResources;
2519 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
2522 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2524 pMpeg4Enc = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4ENC_HANDLE));
2525 if (pMpeg4Enc == NULL) {
2526 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2527 ret = OMX_ErrorInsufficientResources;
2528 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: EXYNOS_MPEG4ENC_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
2531 Exynos_OSAL_Memset(pMpeg4Enc, 0, sizeof(EXYNOS_MPEG4ENC_HANDLE));
2532 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2533 pVideoEnc->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Enc;
2534 pMpeg4Enc->hMFCMpeg4Handle.codecType = codecType;
2536 if (codecType == CODEC_TYPE_MPEG4)
2537 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_ENC);
2539 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_ENC);
2542 /* In case of BUFFER_COPY mode
2543 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2544 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2545 In case of BUFFER_SHARE
2546 bShareableBuf should be TRUE, FALSE is ignored
2548 pMpeg4Enc->hMFCMpeg4Handle.bShareableBuf = OMX_FALSE; //Check bStoreMetaData in Init function
2550 /* Set componentVersion */
2551 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2552 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2553 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2554 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2555 /* Set specVersion */
2556 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2557 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2558 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2559 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2562 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2563 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2564 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2565 pExynosPort->portDefinition.format.video.nBitrate = 64000;
2566 pExynosPort->portDefinition.format.video.xFramerate= (15 << 16);
2567 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2568 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2569 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2570 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2571 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2572 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2573 #ifdef TIZEN_FEATURE_E3250
2574 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2576 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2578 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2579 pExynosPort->bufferProcessType = BUFFER_COPY;
2580 pExynosPort->portWayType = WAY2_PORT;
2583 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2584 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2585 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2586 pExynosPort->portDefinition.format.video.nBitrate = 64000;
2587 pExynosPort->portDefinition.format.video.xFramerate= (15 << 16);
2588 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2589 if (codecType == CODEC_TYPE_MPEG4) {
2590 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2591 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2592 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2594 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2595 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2596 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2598 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2599 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2600 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2601 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2602 pExynosPort->bufferProcessType = BUFFER_COPY;
2603 pExynosPort->portWayType = WAY2_PORT;
2605 if (codecType == CODEC_TYPE_MPEG4) {
2606 for(i = 0; i < ALL_PORT_NUM; i++) {
2607 INIT_SET_SIZE_VERSION(&pMpeg4Enc->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2608 pMpeg4Enc->mpeg4Component[i].nPortIndex = i;
2609 pMpeg4Enc->mpeg4Component[i].eProfile = OMX_VIDEO_MPEG4ProfileSimple;
2610 pMpeg4Enc->mpeg4Component[i].eLevel = OMX_VIDEO_MPEG4Level4;
2612 pMpeg4Enc->mpeg4Component[i].nPFrames = 10;
2613 pMpeg4Enc->mpeg4Component[i].nBFrames = 0; /* No support for B frames */
2614 pMpeg4Enc->mpeg4Component[i].nMaxPacketSize = 256; /* Default value */
2615 pMpeg4Enc->mpeg4Component[i].nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
2616 pMpeg4Enc->mpeg4Component[i].bGov = OMX_FALSE;
2620 for(i = 0; i < ALL_PORT_NUM; i++) {
2621 INIT_SET_SIZE_VERSION(&pMpeg4Enc->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2622 pMpeg4Enc->h263Component[i].nPortIndex = i;
2623 pMpeg4Enc->h263Component[i].eProfile = OMX_VIDEO_H263ProfileBaseline;
2624 pMpeg4Enc->h263Component[i].eLevel = OMX_VIDEO_H263Level45;
2626 pMpeg4Enc->h263Component[i].nPFrames = 20;
2627 pMpeg4Enc->h263Component[i].nBFrames = 0; /* No support for B frames */
2628 pMpeg4Enc->h263Component[i].bPLUSPTYPEAllowed = OMX_FALSE;
2629 pMpeg4Enc->h263Component[i].nAllowedPictureTypes = OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
2630 pMpeg4Enc->h263Component[i].bForceRoundingTypeToZero = OMX_TRUE;
2631 pMpeg4Enc->h263Component[i].nPictureHeaderRepetition = 0;
2632 pMpeg4Enc->h263Component[i].nGOBHeaderInterval = 0;
2636 pOMXComponent->GetParameter = &Exynos_Mpeg4Enc_GetParameter;
2637 pOMXComponent->SetParameter = &Exynos_Mpeg4Enc_SetParameter;
2638 pOMXComponent->GetConfig = &Exynos_Mpeg4Enc_GetConfig;
2639 pOMXComponent->SetConfig = &Exynos_Mpeg4Enc_SetConfig;
2640 pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Enc_GetExtensionIndex;
2641 pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Enc_ComponentRoleEnum;
2642 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2644 pExynosComponent->exynos_codec_componentInit = &Exynos_Mpeg4Enc_Init;
2645 pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Enc_Terminate;
2647 pVideoEnc->exynos_codec_srcInputProcess = &Exynos_Mpeg4Enc_srcInputBufferProcess;
2648 pVideoEnc->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Enc_srcOutputBufferProcess;
2649 pVideoEnc->exynos_codec_dstInputProcess = &Exynos_Mpeg4Enc_dstInputBufferProcess;
2650 pVideoEnc->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Enc_dstOutputBufferProcess;
2652 pVideoEnc->exynos_codec_start = &Mpeg4CodecStart;
2653 pVideoEnc->exynos_codec_stop = &Mpeg4CodecStop;
2654 pVideoEnc->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2655 pVideoEnc->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnqueueAllBuffer;
2657 pVideoEnc->exynos_checkInputFrame = NULL;
2658 pVideoEnc->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2659 pVideoEnc->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2661 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2662 pVideoEnc->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2663 if (pVideoEnc->hSharedMemory == NULL) {
2664 Exynos_OSAL_Free(pMpeg4Enc);
2665 pMpeg4Enc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2666 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2667 ret = OMX_ErrorInsufficientResources;
2671 pExynosComponent->currentState = OMX_StateLoaded;
2673 ret = OMX_ErrorNone;
2681 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2683 OMX_ERRORTYPE ret = OMX_ErrorNone;
2684 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2685 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2686 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
2687 EXYNOS_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
2691 if (hComponent == NULL) {
2692 ret = OMX_ErrorBadParameter;
2695 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2696 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2697 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2698 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2699 Exynos_OSAL_SharedMemory_Close(pVideoEnc->hSharedMemory);
2701 Exynos_OSAL_Free(pExynosComponent->componentName);
2702 pExynosComponent->componentName = NULL;
2704 pMpeg4Enc = (EXYNOS_MPEG4ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2705 if (pMpeg4Enc != NULL) {
2706 Exynos_OSAL_Free(pMpeg4Enc);
2707 pMpeg4Enc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2710 ret = Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2711 if (ret != OMX_ErrorNone) {
2715 ret = OMX_ErrorNone;