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