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


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