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


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