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