3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 * @file Exynos_OMX_H264enc.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
31 #include "Exynos_OMX_Macros.h"
32 #include "Exynos_OMX_Basecomponent.h"
33 #include "Exynos_OMX_Baseport.h"
34 #include "Exynos_OMX_Venc.h"
35 #include "Exynos_OSAL_ETC.h"
36 #include "Exynos_OSAL_Semaphore.h"
37 #include "Exynos_OSAL_Thread.h"
38 #include "Exynos_OSAL_Android.h"
39 #include "library_register.h"
40 #include "Exynos_OMX_H264enc.h"
41 #include "ExynosVideoApi.h"
42 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Event.h"
45 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
46 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
50 #define EXYNOS_LOG_TAG "EXYNOS_H264_ENC"
51 #define EXYNOS_LOG_OFF
52 //#define EXYNOS_TRACE_ON
53 #include "Exynos_OSAL_Log.h"
55 /* H.264 Encoder Supported Levels & profiles */
56 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels
[] ={
57 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel1
},
58 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel1b
},
59 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel11
},
60 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel12
},
61 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel13
},
62 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel2
},
63 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel21
},
64 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel22
},
65 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel3
},
66 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel31
},
67 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel32
},
68 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel4
},
69 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel41
},
70 {OMX_VIDEO_AVCProfileBaseline
, OMX_VIDEO_AVCLevel42
},
72 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel1
},
73 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel1b
},
74 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel11
},
75 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel12
},
76 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel13
},
77 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel2
},
78 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel21
},
79 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel22
},
80 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel3
},
81 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel31
},
82 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel32
},
83 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel4
},
84 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel41
},
85 {OMX_VIDEO_AVCProfileMain
, OMX_VIDEO_AVCLevel42
},
87 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel1
},
88 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel1b
},
89 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel11
},
90 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel12
},
91 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel13
},
92 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel2
},
93 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel21
},
94 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel22
},
95 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel3
},
96 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel31
},
97 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel32
},
98 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel4
},
99 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel41
},
100 {OMX_VIDEO_AVCProfileHigh
, OMX_VIDEO_AVCLevel42
}};
102 static OMX_U32
OMXAVCProfileToProfileIDC(OMX_VIDEO_AVCPROFILETYPE profile
)
106 if (profile
== OMX_VIDEO_AVCProfileBaseline
)
108 else if (profile
== OMX_VIDEO_AVCProfileMain
)
110 else if (profile
== OMX_VIDEO_AVCProfileHigh
)
116 static OMX_U32
OMXAVCLevelToLevelIDC(OMX_VIDEO_AVCLEVELTYPE level
)
118 OMX_U32 ret
= 11; //default OMX_VIDEO_AVCLevel4
120 if (level
== OMX_VIDEO_AVCLevel1
)
122 else if (level
== OMX_VIDEO_AVCLevel1b
)
124 else if (level
== OMX_VIDEO_AVCLevel11
)
126 else if (level
== OMX_VIDEO_AVCLevel12
)
128 else if (level
== OMX_VIDEO_AVCLevel13
)
130 else if (level
== OMX_VIDEO_AVCLevel2
)
132 else if (level
== OMX_VIDEO_AVCLevel21
)
134 else if (level
== OMX_VIDEO_AVCLevel22
)
136 else if (level
== OMX_VIDEO_AVCLevel3
)
138 else if (level
== OMX_VIDEO_AVCLevel31
)
140 else if (level
== OMX_VIDEO_AVCLevel32
)
142 else if (level
== OMX_VIDEO_AVCLevel4
)
144 else if (level
== OMX_VIDEO_AVCLevel41
)
146 else if (level
== OMX_VIDEO_AVCLevel42
)
152 static OMX_U8
*FindDelimiter(OMX_U8
*pBuffer
, OMX_U32 size
)
156 for (i
= 0; i
< size
- 3; i
++) {
157 if ((pBuffer
[i
] == 0x00) &&
158 (pBuffer
[i
+ 1] == 0x00) &&
159 (pBuffer
[i
+ 2] == 0x00) &&
160 (pBuffer
[i
+ 3] == 0x01))
161 return (pBuffer
+ i
);
167 static void Print_H264Enc_Param(ExynosVideoEncParam
*pEncParam
)
169 ExynosVideoEncCommonParam
*pCommonParam
= &pEncParam
->commonParam
;
170 ExynosVideoEncH264Param
*pH264Param
= &pEncParam
->codecParam
.h264
;
172 /* common parameters */
173 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SourceWidth : %d", pCommonParam
->SourceWidth
);
174 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SourceHeight : %d", pCommonParam
->SourceHeight
);
175 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "IDRPeriod : %d", pCommonParam
->IDRPeriod
);
176 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SliceMode : %d", pCommonParam
->SliceMode
);
177 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "RandomIntraMBRefresh : %d", pCommonParam
->RandomIntraMBRefresh
);
178 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Bitrate : %d", pCommonParam
->Bitrate
);
179 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "FrameQp : %d", pCommonParam
->FrameQp
);
180 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "FrameQp_P : %d", pCommonParam
->FrameQp_P
);
181 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "QSCodeMax : %d", pCommonParam
->QSCodeMax
);
182 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "QSCodeMin : %d", pCommonParam
->QSCodeMin
);
183 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "PadControlOn : %d", pCommonParam
->PadControlOn
);
184 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "LumaPadVal : %d", pCommonParam
->LumaPadVal
);
185 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "CbPadVal : %d", pCommonParam
->CbPadVal
);
186 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "CrPadVal : %d", pCommonParam
->CrPadVal
);
187 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "FrameMap : %d", pCommonParam
->FrameMap
);
189 /* H.264 specific parameters */
190 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "ProfileIDC : %d", pH264Param
->ProfileIDC
);
191 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "LevelIDC : %d", pH264Param
->LevelIDC
);
192 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "FrameQp_B : %d", pH264Param
->FrameQp_B
);
193 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "FrameRate : %d", pH264Param
->FrameRate
);
194 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SliceArgument : %d", pH264Param
->SliceArgument
);
195 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "NumberBFrames : %d", pH264Param
->NumberBFrames
);
196 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "NumberReferenceFrames : %d", pH264Param
->NumberReferenceFrames
);
197 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "NumberRefForPframes : %d", pH264Param
->NumberRefForPframes
);
198 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "LoopFilterDisable : %d", pH264Param
->LoopFilterDisable
);
199 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "LoopFilterAlphaC0Offset : %d", pH264Param
->LoopFilterAlphaC0Offset
);
200 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "LoopFilterBetaOffset : %d", pH264Param
->LoopFilterBetaOffset
);
201 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SymbolMode : %d", pH264Param
->SymbolMode
);
202 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "PictureInterlace : %d", pH264Param
->PictureInterlace
);
203 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Transform8x8Mode : %d", pH264Param
->Transform8x8Mode
);
204 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "DarkDisable : %d", pH264Param
->DarkDisable
);
205 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SmoothDisable : %d", pH264Param
->SmoothDisable
);
206 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "StaticDisable : %d", pH264Param
->StaticDisable
);
207 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "ActivityDisable : %d", pH264Param
->ActivityDisable
);
209 /* rate control related parameters */
210 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "EnableFRMRateControl : %d", pCommonParam
->EnableFRMRateControl
);
211 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "EnableMBRateControl : %d", pCommonParam
->EnableMBRateControl
);
212 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "CBRPeriodRf : %d", pCommonParam
->CBRPeriodRf
);
215 static void Set_H264Enc_Param(EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
)
217 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= NULL
;
218 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= NULL
;
219 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
220 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
221 EXYNOS_MFC_H264ENC_HANDLE
*pMFCH264Handle
= NULL
;
223 ExynosVideoEncParam
*pEncParam
= NULL
;
224 ExynosVideoEncCommonParam
*pCommonParam
= NULL
;
225 ExynosVideoEncH264Param
*pH264Param
= NULL
;
227 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
228 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
229 pMFCH264Handle
= &pH264Enc
->hMFCH264Handle
;
230 pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
231 pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
233 pEncParam
= &pMFCH264Handle
->encParam
;
234 pCommonParam
= &pEncParam
->commonParam
;
235 pH264Param
= &pEncParam
->codecParam
.h264
;
236 pEncParam
->eCompressionFormat
= VIDEO_CODING_AVC
;
237 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "eCompressionFormat: %d", pEncParam
->eCompressionFormat
);
239 /* common parameters */
240 pCommonParam
->SourceWidth
= pExynosOutputPort
->portDefinition
.format
.video
.nFrameWidth
;
241 pCommonParam
->SourceHeight
= pExynosOutputPort
->portDefinition
.format
.video
.nFrameHeight
;
242 pCommonParam
->IDRPeriod
= pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
+ 1;
243 pCommonParam
->SliceMode
= 0;
244 pCommonParam
->Bitrate
= pExynosOutputPort
->portDefinition
.format
.video
.nBitrate
;
245 pCommonParam
->FrameQp
= pVideoEnc
->quantization
.nQpI
;
246 pCommonParam
->FrameQp_P
= pVideoEnc
->quantization
.nQpP
;
247 pCommonParam
->QSCodeMax
= 51;
248 pCommonParam
->QSCodeMin
= 10;
249 pCommonParam
->PadControlOn
= 0; /* 0: disable, 1: enable */
250 pCommonParam
->LumaPadVal
= 0;
251 pCommonParam
->CbPadVal
= 0;
252 pCommonParam
->CrPadVal
= 0;
254 if (pVideoEnc
->intraRefresh
.eRefreshMode
== OMX_VIDEO_IntraRefreshCyclic
) {
256 pCommonParam
->RandomIntraMBRefresh
= pVideoEnc
->intraRefresh
.nCirMBs
;
257 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "RandomIntraMBRefresh: %d", pCommonParam
->RandomIntraMBRefresh
);
259 /* Don't support "Adaptive" and "Cyclic + Adaptive" */
260 pCommonParam
->RandomIntraMBRefresh
= 0;
263 if (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
) {
264 if (pVideoEnc
->ANBColorFormat
== OMX_COLOR_FormatYUV420SemiPlanar
)
265 pCommonParam
->FrameMap
= VIDEO_COLORFORMAT_NV12
;
266 if (pVideoEnc
->ANBColorFormat
== OMX_SEC_COLOR_FormatNV12Tiled
)
267 pCommonParam
->FrameMap
= VIDEO_COLORFORMAT_NV12_TILED
;
269 switch ((EXYNOS_OMX_COLOR_FORMATTYPE
)pExynosInputPort
->portDefinition
.format
.video
.eColorFormat
) {
270 case OMX_COLOR_FormatYUV420SemiPlanar
:
271 case OMX_COLOR_FormatYUV420Planar
: /* Converted to NV12 in Exynos_CSC_InputData */
272 #ifdef USE_METADATABUFFERTYPE
273 case OMX_COLOR_FormatAndroidOpaque
:
275 pCommonParam
->FrameMap
= VIDEO_COLORFORMAT_NV12
;
277 case OMX_SEC_COLOR_FormatNV21Linear
:
278 pCommonParam
->FrameMap
= VIDEO_COLORFORMAT_NV21
;
280 case OMX_SEC_COLOR_FormatNV12Tiled
:
282 pCommonParam
->FrameMap
= VIDEO_COLORFORMAT_NV12_TILED
;
287 /* H.264 specific parameters */
288 pH264Param
->ProfileIDC
= OMXAVCProfileToProfileIDC(pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].eProfile
); /*0: OMX_VIDEO_AVCProfileMain */
289 pH264Param
->LevelIDC
= OMXAVCLevelToLevelIDC(pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].eLevel
); /*40: OMX_VIDEO_AVCLevel4 */
290 pH264Param
->FrameQp_B
= pVideoEnc
->quantization
.nQpB
;
291 pH264Param
->FrameRate
= (pExynosInputPort
->portDefinition
.format
.video
.xFramerate
) >> 16;
292 pH264Param
->SliceArgument
= 0; /* Slice mb/byte size number */
293 pH264Param
->NumberBFrames
= 0; /* 0 ~ 2 */
294 pH264Param
->NumberReferenceFrames
= 1;
295 pH264Param
->NumberRefForPframes
= 1;
296 pH264Param
->LoopFilterDisable
= 1; /* 1: Loop Filter Disable, 0: Filter Enable */
297 pH264Param
->LoopFilterAlphaC0Offset
= 0;
298 pH264Param
->LoopFilterBetaOffset
= 0;
299 pH264Param
->SymbolMode
= 0; /* 0: CAVLC, 1: CABAC */
300 pH264Param
->PictureInterlace
= 0;
301 pH264Param
->Transform8x8Mode
= 0; /* 0: 4x4, 1: allow 8x8 */
302 pH264Param
->DarkDisable
= 1;
303 pH264Param
->SmoothDisable
= 1;
304 pH264Param
->StaticDisable
= 1;
305 pH264Param
->ActivityDisable
= 1;
307 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc
->eControlRate
[OUTPUT_PORT_INDEX
]);
308 /* rate control related parameters */
309 switch (pVideoEnc
->eControlRate
[OUTPUT_PORT_INDEX
]) {
310 case OMX_Video_ControlRateDisable
:
311 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Video Encode DBR");
312 pCommonParam
->EnableFRMRateControl
= 0; /* 0: Disable, 1: Frame level RC */
313 pCommonParam
->EnableMBRateControl
= 0; /* 0: Disable, 1:MB level RC */
314 pCommonParam
->CBRPeriodRf
= 100;
316 case OMX_Video_ControlRateConstant
:
317 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Video Encode CBR");
318 pCommonParam
->EnableFRMRateControl
= 1; /* 0: Disable, 1: Frame level RC */
319 pCommonParam
->EnableMBRateControl
= 1; /* 0: Disable, 1:MB level RC */
320 pCommonParam
->CBRPeriodRf
= 9;
322 case OMX_Video_ControlRateVariable
:
323 default: /*Android default */
324 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Video Encode VBR");
325 pCommonParam
->EnableFRMRateControl
= 1; /* 0: Disable, 1: Frame level RC */
326 pCommonParam
->EnableMBRateControl
= 1; /* 0: Disable, 1:MB level RC */
327 pCommonParam
->CBRPeriodRf
= 100;
331 Print_H264Enc_Param(pEncParam
);
334 static void Change_H264Enc_Param(EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
)
336 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= NULL
;
337 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= NULL
;
338 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
339 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
340 EXYNOS_MFC_H264ENC_HANDLE
*pMFCH264Handle
= NULL
;
342 ExynosVideoEncOps
*pEncOps
= NULL
;
343 ExynosVideoEncParam
*pEncParam
= NULL
;
344 ExynosVideoEncCommonParam
*pCommonParam
= NULL
;
345 ExynosVideoEncH264Param
*pH264Param
= NULL
;
349 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
350 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
351 pMFCH264Handle
= &pH264Enc
->hMFCH264Handle
;
352 pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
353 pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
354 pEncOps
= pMFCH264Handle
->pEncOps
;
356 pEncParam
= &pMFCH264Handle
->encParam
;
357 pCommonParam
= &pEncParam
->commonParam
;
358 pH264Param
= &pEncParam
->codecParam
.h264
;
360 if (pVideoEnc
->IntraRefreshVOP
== OMX_TRUE
) {
361 setParam
= VIDEO_FRAME_I
;
362 pEncOps
->Set_FrameType(pH264Enc
->hMFCH264Handle
.hMFCHandle
, setParam
);
363 pVideoEnc
->IntraRefreshVOP
= OMX_FALSE
;
365 if (pCommonParam
->IDRPeriod
!= (int)pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
+ 1) {
366 setParam
= pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
+ 1;
367 pEncOps
->Set_IDRPeriod(pH264Enc
->hMFCH264Handle
.hMFCHandle
, setParam
);
369 if (pCommonParam
->Bitrate
!= (int)pExynosOutputPort
->portDefinition
.format
.video
.nBitrate
) {
370 setParam
= pExynosOutputPort
->portDefinition
.format
.video
.nBitrate
;
371 pEncOps
->Set_BitRate(pH264Enc
->hMFCH264Handle
.hMFCHandle
, setParam
);
373 if (pH264Param
->FrameRate
!= (int)((pExynosInputPort
->portDefinition
.format
.video
.xFramerate
) >> 16)) {
374 setParam
= (pExynosInputPort
->portDefinition
.format
.video
.xFramerate
) >> 16;
375 pEncOps
->Set_FrameRate(pH264Enc
->hMFCH264Handle
.hMFCHandle
, setParam
);
378 Set_H264Enc_Param(pExynosComponent
);
381 OMX_ERRORTYPE
GetCodecInputPrivateData(OMX_PTR codecBuffer
, OMX_PTR addr
[], OMX_U32 size
[])
383 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
389 OMX_ERRORTYPE
GetCodecOutputPrivateData(OMX_PTR codecBuffer
, OMX_PTR
*pVirtAddr
, OMX_U32
*dataSize
)
391 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
392 ExynosVideoBuffer
*pCodecBuffer
;
394 if (codecBuffer
== NULL
) {
395 ret
= OMX_ErrorBadParameter
;
399 pCodecBuffer
= (ExynosVideoBuffer
*)codecBuffer
;
401 if (pVirtAddr
!= NULL
)
402 *pVirtAddr
= pCodecBuffer
->planes
[0].addr
;
404 if (dataSize
!= NULL
)
405 *dataSize
= pCodecBuffer
->planes
[0].allocSize
;
407 pCodecBuffer
= (ExynosVideoBuffer
*)codecBuffer
;
413 OMX_ERRORTYPE
H264CodecOpen(EXYNOS_H264ENC_HANDLE
*pH264Enc
)
415 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
417 ExynosVideoEncOps
*pEncOps
= NULL
;
418 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
419 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
423 if (pH264Enc
== NULL
) {
424 ret
= OMX_ErrorBadParameter
;
425 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, Line:%d", __LINE__
);
429 /* alloc ops structure */
430 pEncOps
= (ExynosVideoEncOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncOps
));
431 pInbufOps
= (ExynosVideoEncBufferOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps
));
432 pOutbufOps
= (ExynosVideoEncBufferOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps
));
434 if ((pEncOps
== NULL
) || (pInbufOps
== NULL
) || (pOutbufOps
== NULL
)) {
435 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to allocate encoder ops buffer");
436 ret
= OMX_ErrorInsufficientResources
;
440 pH264Enc
->hMFCH264Handle
.pEncOps
= pEncOps
;
441 pH264Enc
->hMFCH264Handle
.pInbufOps
= pInbufOps
;
442 pH264Enc
->hMFCH264Handle
.pOutbufOps
= pOutbufOps
;
444 /* function pointer mapping */
445 pEncOps
->nSize
= sizeof(ExynosVideoEncOps
);
446 pInbufOps
->nSize
= sizeof(ExynosVideoEncBufferOps
);
447 pOutbufOps
->nSize
= sizeof(ExynosVideoEncBufferOps
);
449 Exynos_Video_Register_Encoder(pEncOps
, pInbufOps
, pOutbufOps
);
451 /* check mandatory functions for encoder ops */
452 if ((pEncOps
->Init
== NULL
) || (pEncOps
->Finalize
== NULL
) ||
453 (pEncOps
->Set_FrameTag
== NULL
) || (pEncOps
->Get_FrameTag
== NULL
)) {
454 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Mandatory functions must be supplied");
455 ret
= OMX_ErrorInsufficientResources
;
459 /* check mandatory functions for buffer ops */
460 if ((pInbufOps
->Setup
== NULL
) || (pOutbufOps
->Setup
== NULL
) ||
461 (pInbufOps
->Run
== NULL
) || (pOutbufOps
->Run
== NULL
) ||
462 (pInbufOps
->Stop
== NULL
) || (pOutbufOps
->Stop
== NULL
) ||
463 (pInbufOps
->Enqueue
== NULL
) || (pOutbufOps
->Enqueue
== NULL
) ||
464 (pInbufOps
->Dequeue
== NULL
) || (pOutbufOps
->Dequeue
== NULL
)) {
465 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Mandatory functions must be supplied");
466 ret
= OMX_ErrorInsufficientResources
;
470 /* alloc context, open, querycap */
471 pH264Enc
->hMFCH264Handle
.hMFCHandle
= pH264Enc
->hMFCH264Handle
.pEncOps
->Init(V4L2_MEMORY_DMABUF
);
472 if (pH264Enc
->hMFCH264Handle
.hMFCHandle
== NULL
) {
473 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to allocate context buffer");
474 ret
= OMX_ErrorInsufficientResources
;
481 if (ret
!= OMX_ErrorNone
) {
482 if (pEncOps
!= NULL
) {
483 Exynos_OSAL_Free(pEncOps
);
484 pH264Enc
->hMFCH264Handle
.pEncOps
= NULL
;
486 if (pInbufOps
!= NULL
) {
487 Exynos_OSAL_Free(pInbufOps
);
488 pH264Enc
->hMFCH264Handle
.pInbufOps
= NULL
;
490 if (pOutbufOps
!= NULL
) {
491 Exynos_OSAL_Free(pOutbufOps
);
492 pH264Enc
->hMFCH264Handle
.pOutbufOps
= NULL
;
501 OMX_ERRORTYPE
H264CodecClose(EXYNOS_H264ENC_HANDLE
*pH264Enc
)
503 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
504 void *hMFCHandle
= NULL
;
505 ExynosVideoEncOps
*pEncOps
= NULL
;
506 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
507 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
511 if (pH264Enc
== NULL
) {
512 ret
= OMX_ErrorBadParameter
;
516 hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
517 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
518 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
519 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
521 if (hMFCHandle
!= NULL
) {
522 pEncOps
->Finalize(hMFCHandle
);
523 hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
= NULL
;
525 if (pOutbufOps
!= NULL
) {
526 Exynos_OSAL_Free(pOutbufOps
);
527 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
= NULL
;
529 if (pInbufOps
!= NULL
) {
530 Exynos_OSAL_Free(pInbufOps
);
531 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
= NULL
;
533 if (pEncOps
!= NULL
) {
534 Exynos_OSAL_Free(pEncOps
);
535 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
= NULL
;
546 OMX_ERRORTYPE
H264CodecStart(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
548 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
549 void *hMFCHandle
= NULL
;
550 ExynosVideoEncOps
*pEncOps
= NULL
;
551 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
552 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
553 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
554 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
558 if (pOMXComponent
== NULL
) {
559 ret
= OMX_ErrorBadParameter
;
563 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
564 if (pVideoEnc
== NULL
) {
565 ret
= OMX_ErrorBadParameter
;
569 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)pVideoEnc
->hCodecHandle
;
570 if (pH264Enc
== NULL
) {
571 ret
= OMX_ErrorBadParameter
;
575 hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
576 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
577 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
578 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
580 if (nPortIndex
== INPUT_PORT_INDEX
)
581 pInbufOps
->Run(hMFCHandle
);
582 else if (nPortIndex
== OUTPUT_PORT_INDEX
)
583 pOutbufOps
->Run(hMFCHandle
);
593 OMX_ERRORTYPE
H264CodecStop(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
595 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
596 void *hMFCHandle
= NULL
;
597 ExynosVideoEncOps
*pEncOps
= NULL
;
598 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
599 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
600 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
601 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
605 if (pOMXComponent
== NULL
) {
606 ret
= OMX_ErrorBadParameter
;
610 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
611 if (pVideoEnc
== NULL
) {
612 ret
= OMX_ErrorBadParameter
;
615 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)pVideoEnc
->hCodecHandle
;
616 if (pH264Enc
== NULL
) {
617 ret
= OMX_ErrorBadParameter
;
621 hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
622 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
623 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
624 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
626 if ((nPortIndex
== INPUT_PORT_INDEX
) && (pInbufOps
!= NULL
))
627 pInbufOps
->Stop(hMFCHandle
);
628 else if ((nPortIndex
== OUTPUT_PORT_INDEX
) && (pOutbufOps
!= NULL
))
629 pOutbufOps
->Stop(hMFCHandle
);
639 OMX_ERRORTYPE
H264CodecOutputBufferProcessRun(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
641 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
642 void *hMFCHandle
= NULL
;
643 ExynosVideoEncOps
*pEncOps
= NULL
;
644 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
645 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
646 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
647 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
651 if (pOMXComponent
== NULL
) {
652 ret
= OMX_ErrorBadParameter
;
656 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
657 if (pVideoEnc
== NULL
) {
658 ret
= OMX_ErrorBadParameter
;
661 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)pVideoEnc
->hCodecHandle
;
662 if (pH264Enc
== NULL
) {
663 ret
= OMX_ErrorBadParameter
;
667 hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
668 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
669 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
670 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
672 if (nPortIndex
== INPUT_PORT_INDEX
) {
673 if (pH264Enc
->bSourceStart
== OMX_FALSE
) {
674 Exynos_OSAL_SignalSet(pH264Enc
->hSourceStartEvent
);
675 Exynos_OSAL_SleepMillisec(0);
679 if (nPortIndex
== OUTPUT_PORT_INDEX
) {
680 if (pH264Enc
->bDestinationStart
== OMX_FALSE
) {
681 Exynos_OSAL_SignalSet(pH264Enc
->hDestinationStartEvent
);
682 Exynos_OSAL_SleepMillisec(0);
694 OMX_ERRORTYPE
H264CodecEnQueueAllBuffer(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
696 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
697 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
698 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
699 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
700 void *hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
701 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
702 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
705 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
706 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
707 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
711 if ((nPortIndex
== INPUT_PORT_INDEX
) &&
712 (pH264Enc
->bSourceStart
== OMX_TRUE
)) {
713 Exynos_CodecBufferReset(pExynosComponent
, INPUT_PORT_INDEX
);
715 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
716 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]);
717 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0]);
718 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1]);
720 Exynos_CodecBufferEnQueue(pExynosComponent
, INPUT_PORT_INDEX
, pVideoEnc
->pMFCEncInputBuffer
[i
]);
723 pInbufOps
->Clear_Queue(hMFCHandle
);
724 } else if ((nPortIndex
== OUTPUT_PORT_INDEX
) &&
725 (pH264Enc
->bDestinationStart
== OMX_TRUE
)) {
726 OMX_U32 dataLen
[2] = {0, 0};
727 ExynosVideoBuffer
*pBuffer
= NULL
;
729 Exynos_CodecBufferReset(pExynosComponent
, OUTPUT_PORT_INDEX
);
731 for (i
= 0; i
< MFC_OUTPUT_BUFFER_NUM_MAX
; i
++) {
732 pOutbufOps
->Get_Buffer(hMFCHandle
, i
, &pBuffer
);
733 Exynos_CodecBufferEnQueue(pExynosComponent
, OUTPUT_PORT_INDEX
, (OMX_PTR
)pBuffer
);
734 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncOutputBuffer[%d]: 0x%x", i
, pVideoEnc
->pMFCEncOutputBuffer
[i
]);
735 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0]);
736 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1]);
738 pOutbufOps
->Clear_Queue(hMFCHandle
);
740 ret
= OMX_ErrorBadParameter
;
750 OMX_ERRORTYPE
H264CodecSrcSetup(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
752 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
753 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
754 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
755 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
756 EXYNOS_MFC_H264ENC_HANDLE
*pMFCH264Handle
= &pH264Enc
->hMFCH264Handle
;
757 void *hMFCHandle
= pMFCH264Handle
->hMFCHandle
;
758 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
759 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
760 OMX_U32 oneFrameSize
= pSrcInputData
->dataLen
;
762 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
763 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
764 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
765 ExynosVideoEncParam
*pEncParam
= NULL
;
767 ExynosVideoGeometry bufferConf
;
768 OMX_U32 inputBufferNumber
= 0;
773 if ((oneFrameSize
<= 0) && (pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
)) {
774 OMX_BUFFERHEADERTYPE
*OMXBuffer
= NULL
;
775 OMXBuffer
= Exynos_OutputBufferGetQueue_Direct(pExynosComponent
);
776 if (OMXBuffer
== NULL
) {
777 ret
= OMX_ErrorUndefined
;
781 OMXBuffer
->nTimeStamp
= pSrcInputData
->timeStamp
;
782 OMXBuffer
->nFlags
= pSrcInputData
->nFlags
;
783 Exynos_OMX_OutputBufferReturn(pOMXComponent
, OMXBuffer
);
789 Set_H264Enc_Param(pExynosComponent
);
790 pEncParam
= &pMFCH264Handle
->encParam
;
791 if (pEncOps
->Set_EncParam
) {
792 if(pEncOps
->Set_EncParam(pH264Enc
->hMFCH264Handle
.hMFCHandle
, pEncParam
) != VIDEO_ERROR_NONE
) {
793 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to set geometry for input buffer");
794 ret
= OMX_ErrorInsufficientResources
;
799 /* input buffer info: only 3 config values needed */
800 Exynos_OSAL_Memset(&bufferConf
, 0, sizeof(bufferConf
));
801 bufferConf
.eColorFormat
= pEncParam
->commonParam
.FrameMap
;//VIDEO_COLORFORMAT_NV12;
802 bufferConf
.nFrameWidth
= pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
;
803 bufferConf
.nFrameHeight
= pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
;
804 pInbufOps
->Set_Shareable(hMFCHandle
);
805 if (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
) {
806 inputBufferNumber
= MAX_INPUTBUFFER_NUM_DYNAMIC
;
807 } else if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
808 inputBufferNumber
= MFC_INPUT_BUFFER_NUM_MAX
;
811 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
812 /* should be done before prepare input buffer */
813 if (pInbufOps
->Enable_Cacheable(hMFCHandle
) != VIDEO_ERROR_NONE
) {
814 ret
= OMX_ErrorInsufficientResources
;
819 /* set input buffer geometry */
820 if (pInbufOps
->Set_Geometry
) {
821 if (pInbufOps
->Set_Geometry(hMFCHandle
, &bufferConf
) != VIDEO_ERROR_NONE
) {
822 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to set geometry for input buffer");
823 ret
= OMX_ErrorInsufficientResources
;
828 /* setup input buffer */
829 if (pInbufOps
->Setup(hMFCHandle
, inputBufferNumber
) != VIDEO_ERROR_NONE
) {
830 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to setup input buffer");
831 ret
= OMX_ErrorInsufficientResources
;
835 ExynosVideoPlane planes
[MFC_INPUT_BUFFER_PLANE
];
838 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
839 /* Register input buffer */
840 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
841 for (plane
= 0; plane
< MFC_INPUT_BUFFER_PLANE
; plane
++) {
842 planes
[plane
].addr
= pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[plane
];
843 planes
[plane
].allocSize
= pVideoEnc
->pMFCEncInputBuffer
[i
]->bufferSize
[plane
];
844 planes
[plane
].fd
= pVideoEnc
->pMFCEncInputBuffer
[i
]->fd
[plane
];
846 if (pInbufOps
->Register(hMFCHandle
, planes
, MFC_INPUT_BUFFER_PLANE
) != VIDEO_ERROR_NONE
) {
847 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Register input buffer");
848 ret
= OMX_ErrorInsufficientResources
;
852 } else if (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
) {
853 if (pExynosInputPort
->bStoreMetaData
== OMX_TRUE
) {
857 /* Does not require any actions. */
859 ret
= OMX_ErrorNotImplemented
;
864 pH264Enc
->hMFCH264Handle
.bConfiguredMFCSrc
= OMX_TRUE
;
873 OMX_ERRORTYPE
H264CodecDstSetup(OMX_COMPONENTTYPE
*pOMXComponent
)
875 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
876 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
877 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
878 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
879 EXYNOS_MFC_H264ENC_HANDLE
*pMFCH264Handle
= &pH264Enc
->hMFCH264Handle
;
880 void *hMFCHandle
= pMFCH264Handle
->hMFCHandle
;
881 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
882 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
884 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
885 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
886 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
887 ExynosVideoGeometry bufferConf
;
892 int OutBufferSize
= pExynosOutputPort
->portDefinition
.format
.video
.nFrameWidth
* pExynosOutputPort
->portDefinition
.format
.video
.nFrameHeight
* 3 / 2;
893 /* set geometry for output (dst) */
894 if (pOutbufOps
->Set_Geometry
) {
895 /* output buffer info: only 2 config values needed */
896 bufferConf
.eCompressionFormat
= VIDEO_CODING_AVC
;
897 bufferConf
.nSizeImage
= OutBufferSize
;
899 if (pOutbufOps
->Set_Geometry(pH264Enc
->hMFCH264Handle
.hMFCHandle
, &bufferConf
) != VIDEO_ERROR_NONE
) {
900 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to set geometry for output buffer");
901 ret
= OMX_ErrorInsufficientResources
;
906 /* should be done before prepare output buffer */
907 if (pOutbufOps
->Enable_Cacheable(hMFCHandle
) != VIDEO_ERROR_NONE
) {
908 ret
= OMX_ErrorInsufficientResources
;
912 pOutbufOps
->Set_Shareable(hMFCHandle
);
913 int SetupBufferNumber
= 0;
914 if ((pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
)
915 SetupBufferNumber
= MFC_OUTPUT_BUFFER_NUM_MAX
;
917 SetupBufferNumber
= pExynosOutputPort
->portDefinition
.nBufferCountActual
;
918 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "SetupBufferNumber:%d", SetupBufferNumber
);
920 if (pOutbufOps
->Setup(pH264Enc
->hMFCH264Handle
.hMFCHandle
, SetupBufferNumber
) != VIDEO_ERROR_NONE
) {
921 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to setup output buffer");
922 ret
= OMX_ErrorInsufficientResources
;
926 OMX_U32 dataLen
[MFC_OUTPUT_BUFFER_PLANE
] = {0};
927 if ((pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
928 /* Register input buffer */
929 for (i
= 0; i
< MFC_OUTPUT_BUFFER_NUM_MAX
; i
++) {
930 ExynosVideoPlane plane
;
931 pVideoEnc
->pMFCEncOutputBuffer
[i
] = (CODEC_ENC_BUFFER
*)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER
));
932 pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0] =
933 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc
->hSharedMemory
, OutBufferSize
, NORMAL_MEMORY
);
934 if (pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0] == NULL
) {
935 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Alloc output buffer");
936 ret
= OMX_ErrorInsufficientResources
;
939 pVideoEnc
->pMFCEncOutputBuffer
[i
]->fd
[0] =
940 Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc
->hSharedMemory
, pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0]);
941 pVideoEnc
->pMFCEncOutputBuffer
[i
]->bufferSize
[0] = OutBufferSize
;
943 plane
.addr
= pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0];
944 plane
.fd
= pVideoEnc
->pMFCEncOutputBuffer
[i
]->fd
[0];
945 plane
.allocSize
= pVideoEnc
->pMFCEncOutputBuffer
[i
]->bufferSize
[0];
947 if (pOutbufOps
->Register(hMFCHandle
, &plane
, MFC_OUTPUT_BUFFER_PLANE
) != VIDEO_ERROR_NONE
) {
948 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Register output buffer");
949 ret
= OMX_ErrorInsufficientResources
;
952 pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
,
953 (unsigned int *)dataLen
, MFC_OUTPUT_BUFFER_PLANE
, NULL
);
955 } else if ((pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) == BUFFER_SHARE
) {
956 /* Register input buffer */
960 ExynosVideoPlane plane
;
961 for (i
= 0; i
< pExynosOutputPort
->portDefinition
.nBufferCountActual
; i
++) {
962 plane
.addr
= pExynosOutputPort
->extendBufferHeader
[i
].OMXBufferHeader
->pBuffer
;
963 plane
.fd
= pExynosOutputPort
->extendBufferHeader
[i
].buf_fd
[0];
964 plane
.allocSize
= OutBufferSize
;
965 if (pOutbufOps
->Register(hMFCHandle
, &plane
, MFC_OUTPUT_BUFFER_PLANE
) != VIDEO_ERROR_NONE
) {
966 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Register input buffer");
967 ret
= OMX_ErrorInsufficientResources
;
970 pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)&pExynosOutputPort
->extendBufferHeader
[i
].OMXBufferHeader
->pBuffer
,
971 (unsigned int *)dataLen
, MFC_OUTPUT_BUFFER_PLANE
, NULL
);
975 /* start header encoding */
976 if (pOutbufOps
->Run(hMFCHandle
) != VIDEO_ERROR_NONE
) {
977 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to run output buffer");
978 ret
= OMX_ErrorInsufficientResources
;
982 if (pExynosOutputPort
->bufferProcessType
== BUFFER_SHARE
) {
983 OMX_BUFFERHEADERTYPE
*OMXBuffer
= NULL
;
984 ExynosVideoBuffer
*pVideoBuffer
= NULL
;
986 OMXBuffer
= Exynos_OutputBufferGetQueue_Direct(pExynosComponent
);
987 if (OMXBuffer
== OMX_ErrorNone
) {
988 ret
= OMX_ErrorUndefined
;
992 if ((pVideoBuffer
= pOutbufOps
->Dequeue(hMFCHandle
)) == NULL
) {
993 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - pOutbufOps->Dequeue", __FUNCTION__
, __LINE__
);
994 ret
= OMX_ErrorUndefined
;
998 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "dst:0x%x, src:0x%x, dataSize:%d",
1000 pVideoBuffer
->planes
[0].addr
,
1001 pVideoBuffer
->planes
[0].dataSize
);
1002 Exynos_OSAL_Memcpy(OMXBuffer
->pBuffer
, pVideoBuffer
->planes
[0].addr
, pVideoBuffer
->planes
[0].dataSize
);
1003 OMXBuffer
->nFilledLen
= pVideoBuffer
->planes
[0].dataSize
;
1004 OMXBuffer
->nOffset
= 0;
1005 OMXBuffer
->nTimeStamp
= 0;
1006 OMXBuffer
->nFlags
|= OMX_BUFFERFLAG_CODECCONFIG
;
1007 OMXBuffer
->nFlags
|= OMX_BUFFERFLAG_ENDOFFRAME
;
1008 Exynos_OMX_OutputBufferReturn(pOMXComponent
, OMXBuffer
);
1010 pVideoEnc
->bFirstOutput
= OMX_TRUE
;
1011 ret
= OMX_ErrorNone
;
1013 H264CodecStop(pOMXComponent
, OUTPUT_PORT_INDEX
);
1015 pH264Enc
->hMFCH264Handle
.bConfiguredMFCDst
= OMX_TRUE
;
1017 ret
= OMX_ErrorNone
;
1025 OMX_ERRORTYPE
Exynos_H264Enc_GetParameter(
1026 OMX_IN OMX_HANDLETYPE hComponent
,
1027 OMX_IN OMX_INDEXTYPE nParamIndex
,
1028 OMX_INOUT OMX_PTR pComponentParameterStructure
)
1030 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1031 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1032 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1036 if (hComponent
== NULL
|| pComponentParameterStructure
== NULL
) {
1037 ret
= OMX_ErrorBadParameter
;
1040 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1041 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1042 if (ret
!= OMX_ErrorNone
) {
1045 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1046 ret
= OMX_ErrorBadParameter
;
1050 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1051 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1052 ret
= OMX_ErrorInvalidState
;
1056 switch (nParamIndex
) {
1057 case OMX_IndexParamVideoAvc
:
1059 OMX_VIDEO_PARAM_AVCTYPE
*pDstAVCComponent
= (OMX_VIDEO_PARAM_AVCTYPE
*)pComponentParameterStructure
;
1060 OMX_VIDEO_PARAM_AVCTYPE
*pSrcAVCComponent
= NULL
;
1061 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1063 ret
= Exynos_OMX_Check_SizeVersion(pDstAVCComponent
, sizeof(OMX_VIDEO_PARAM_AVCTYPE
));
1064 if (ret
!= OMX_ErrorNone
) {
1068 if (pDstAVCComponent
->nPortIndex
>= ALL_PORT_NUM
) {
1069 ret
= OMX_ErrorBadPortIndex
;
1073 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1074 pSrcAVCComponent
= &pH264Enc
->AVCComponent
[pDstAVCComponent
->nPortIndex
];
1076 Exynos_OSAL_Memcpy(pDstAVCComponent
, pSrcAVCComponent
, sizeof(OMX_VIDEO_PARAM_AVCTYPE
));
1079 case OMX_IndexParamStandardComponentRole
:
1081 OMX_PARAM_COMPONENTROLETYPE
*pComponentRole
= (OMX_PARAM_COMPONENTROLETYPE
*)pComponentParameterStructure
;
1082 ret
= Exynos_OMX_Check_SizeVersion(pComponentRole
, sizeof(OMX_PARAM_COMPONENTROLETYPE
));
1083 if (ret
!= OMX_ErrorNone
) {
1087 Exynos_OSAL_Strcpy((char *)pComponentRole
->cRole
, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE
);
1090 case OMX_IndexParamVideoProfileLevelQuerySupported
:
1092 OMX_VIDEO_PARAM_PROFILELEVELTYPE
*pDstProfileLevel
= (OMX_VIDEO_PARAM_PROFILELEVELTYPE
*)pComponentParameterStructure
;
1093 EXYNOS_OMX_VIDEO_PROFILELEVEL
*pProfileLevel
= NULL
;
1094 OMX_U32 maxProfileLevelNum
= 0;
1096 ret
= Exynos_OMX_Check_SizeVersion(pDstProfileLevel
, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE
));
1097 if (ret
!= OMX_ErrorNone
) {
1101 if (pDstProfileLevel
->nPortIndex
>= ALL_PORT_NUM
) {
1102 ret
= OMX_ErrorBadPortIndex
;
1106 pProfileLevel
= supportedAVCProfileLevels
;
1107 maxProfileLevelNum
= sizeof(supportedAVCProfileLevels
) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL
);
1109 if (pDstProfileLevel
->nProfileIndex
>= maxProfileLevelNum
) {
1110 ret
= OMX_ErrorNoMore
;
1114 pProfileLevel
+= pDstProfileLevel
->nProfileIndex
;
1115 pDstProfileLevel
->eProfile
= pProfileLevel
->profile
;
1116 pDstProfileLevel
->eLevel
= pProfileLevel
->level
;
1119 case OMX_IndexParamVideoProfileLevelCurrent
:
1121 OMX_VIDEO_PARAM_PROFILELEVELTYPE
*pDstProfileLevel
= (OMX_VIDEO_PARAM_PROFILELEVELTYPE
*)pComponentParameterStructure
;
1122 OMX_VIDEO_PARAM_AVCTYPE
*pSrcAVCComponent
= NULL
;
1123 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1125 ret
= Exynos_OMX_Check_SizeVersion(pDstProfileLevel
, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE
));
1126 if (ret
!= OMX_ErrorNone
) {
1130 if (pDstProfileLevel
->nPortIndex
>= ALL_PORT_NUM
) {
1131 ret
= OMX_ErrorBadPortIndex
;
1135 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1136 pSrcAVCComponent
= &pH264Enc
->AVCComponent
[pDstProfileLevel
->nPortIndex
];
1138 pDstProfileLevel
->eProfile
= pSrcAVCComponent
->eProfile
;
1139 pDstProfileLevel
->eLevel
= pSrcAVCComponent
->eLevel
;
1142 case OMX_IndexParamVideoErrorCorrection
:
1144 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pDstErrorCorrectionType
= (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*)pComponentParameterStructure
;
1145 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pSrcErrorCorrectionType
= NULL
;
1146 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1148 ret
= Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType
, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
));
1149 if (ret
!= OMX_ErrorNone
) {
1153 if (pDstErrorCorrectionType
->nPortIndex
!= OUTPUT_PORT_INDEX
) {
1154 ret
= OMX_ErrorBadPortIndex
;
1158 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1159 pSrcErrorCorrectionType
= &pH264Enc
->errorCorrectionType
[OUTPUT_PORT_INDEX
];
1161 pDstErrorCorrectionType
->bEnableHEC
= pSrcErrorCorrectionType
->bEnableHEC
;
1162 pDstErrorCorrectionType
->bEnableResync
= pSrcErrorCorrectionType
->bEnableResync
;
1163 pDstErrorCorrectionType
->nResynchMarkerSpacing
= pSrcErrorCorrectionType
->nResynchMarkerSpacing
;
1164 pDstErrorCorrectionType
->bEnableDataPartitioning
= pSrcErrorCorrectionType
->bEnableDataPartitioning
;
1165 pDstErrorCorrectionType
->bEnableRVLC
= pSrcErrorCorrectionType
->bEnableRVLC
;
1169 ret
= Exynos_OMX_VideoEncodeGetParameter(hComponent
, nParamIndex
, pComponentParameterStructure
);
1178 OMX_ERRORTYPE
Exynos_H264Enc_SetParameter(
1179 OMX_IN OMX_HANDLETYPE hComponent
,
1180 OMX_IN OMX_INDEXTYPE nIndex
,
1181 OMX_IN OMX_PTR pComponentParameterStructure
)
1183 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1184 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1185 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1189 if (hComponent
== NULL
|| pComponentParameterStructure
== NULL
) {
1190 ret
= OMX_ErrorBadParameter
;
1193 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1194 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1195 if (ret
!= OMX_ErrorNone
) {
1198 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1199 ret
= OMX_ErrorBadParameter
;
1203 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1204 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1205 ret
= OMX_ErrorInvalidState
;
1210 case OMX_IndexParamVideoAvc
:
1212 OMX_VIDEO_PARAM_AVCTYPE
*pDstAVCComponent
= NULL
;
1213 OMX_VIDEO_PARAM_AVCTYPE
*pSrcAVCComponent
= (OMX_VIDEO_PARAM_AVCTYPE
*)pComponentParameterStructure
;
1214 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1216 ret
= Exynos_OMX_Check_SizeVersion(pSrcAVCComponent
, sizeof(OMX_VIDEO_PARAM_AVCTYPE
));
1217 if (ret
!= OMX_ErrorNone
) {
1221 if (pSrcAVCComponent
->nPortIndex
>= ALL_PORT_NUM
) {
1222 ret
= OMX_ErrorBadPortIndex
;
1226 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1227 pDstAVCComponent
= &pH264Enc
->AVCComponent
[pSrcAVCComponent
->nPortIndex
];
1229 Exynos_OSAL_Memcpy(pDstAVCComponent
, pSrcAVCComponent
, sizeof(OMX_VIDEO_PARAM_AVCTYPE
));
1232 case OMX_IndexParamStandardComponentRole
:
1234 OMX_PARAM_COMPONENTROLETYPE
*pComponentRole
= (OMX_PARAM_COMPONENTROLETYPE
*)pComponentParameterStructure
;
1236 ret
= Exynos_OMX_Check_SizeVersion(pComponentRole
, sizeof(OMX_PARAM_COMPONENTROLETYPE
));
1237 if (ret
!= OMX_ErrorNone
) {
1241 if ((pExynosComponent
->currentState
!= OMX_StateLoaded
) && (pExynosComponent
->currentState
!= OMX_StateWaitForResources
)) {
1242 ret
= OMX_ErrorIncorrectStateOperation
;
1246 if (!Exynos_OSAL_Strcmp((char*)pComponentRole
->cRole
, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE
)) {
1247 pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
].portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingAVC
;
1249 ret
= OMX_ErrorBadParameter
;
1254 case OMX_IndexParamVideoProfileLevelCurrent
:
1256 OMX_VIDEO_PARAM_PROFILELEVELTYPE
*pSrcProfileLevel
= (OMX_VIDEO_PARAM_PROFILELEVELTYPE
*)pComponentParameterStructure
;
1257 OMX_VIDEO_PARAM_AVCTYPE
*pDstAVCComponent
= NULL
;
1258 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1260 ret
= Exynos_OMX_Check_SizeVersion(pSrcProfileLevel
, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE
));
1261 if (ret
!= OMX_ErrorNone
)
1264 if (pSrcProfileLevel
->nPortIndex
>= ALL_PORT_NUM
) {
1265 ret
= OMX_ErrorBadPortIndex
;
1269 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1271 pDstAVCComponent
= &pH264Enc
->AVCComponent
[pSrcProfileLevel
->nPortIndex
];
1272 pDstAVCComponent
->eProfile
= pSrcProfileLevel
->eProfile
;
1273 pDstAVCComponent
->eLevel
= pSrcProfileLevel
->eLevel
;
1276 case OMX_IndexParamVideoErrorCorrection
:
1278 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pSrcErrorCorrectionType
= (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*)pComponentParameterStructure
;
1279 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pDstErrorCorrectionType
= NULL
;
1280 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1282 ret
= Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType
, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
));
1283 if (ret
!= OMX_ErrorNone
) {
1287 if (pSrcErrorCorrectionType
->nPortIndex
!= OUTPUT_PORT_INDEX
) {
1288 ret
= OMX_ErrorBadPortIndex
;
1292 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1293 pDstErrorCorrectionType
= &pH264Enc
->errorCorrectionType
[OUTPUT_PORT_INDEX
];
1295 pDstErrorCorrectionType
->bEnableHEC
= pSrcErrorCorrectionType
->bEnableHEC
;
1296 pDstErrorCorrectionType
->bEnableResync
= pSrcErrorCorrectionType
->bEnableResync
;
1297 pDstErrorCorrectionType
->nResynchMarkerSpacing
= pSrcErrorCorrectionType
->nResynchMarkerSpacing
;
1298 pDstErrorCorrectionType
->bEnableDataPartitioning
= pSrcErrorCorrectionType
->bEnableDataPartitioning
;
1299 pDstErrorCorrectionType
->bEnableRVLC
= pSrcErrorCorrectionType
->bEnableRVLC
;
1303 ret
= Exynos_OMX_VideoEncodeSetParameter(hComponent
, nIndex
, pComponentParameterStructure
);
1312 OMX_ERRORTYPE
Exynos_H264Enc_GetConfig(
1313 OMX_HANDLETYPE hComponent
,
1314 OMX_INDEXTYPE nIndex
,
1315 OMX_PTR pComponentConfigStructure
)
1317 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1318 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1319 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1320 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1324 if (hComponent
== NULL
|| pComponentConfigStructure
== NULL
) {
1325 ret
= OMX_ErrorBadParameter
;
1328 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1329 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1330 if (ret
!= OMX_ErrorNone
) {
1333 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1334 ret
= OMX_ErrorBadParameter
;
1337 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1338 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1339 ret
= OMX_ErrorInvalidState
;
1342 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1345 case OMX_IndexConfigVideoAVCIntraPeriod
:
1347 OMX_VIDEO_CONFIG_AVCINTRAPERIOD
*pAVCIntraPeriod
= (OMX_VIDEO_CONFIG_AVCINTRAPERIOD
*)pComponentConfigStructure
;
1348 OMX_U32 portIndex
= pAVCIntraPeriod
->nPortIndex
;
1350 if ((portIndex
!= OUTPUT_PORT_INDEX
)) {
1351 ret
= OMX_ErrorBadPortIndex
;
1354 pAVCIntraPeriod
->nIDRPeriod
= pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
+ 1;
1355 pAVCIntraPeriod
->nPFrames
= pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
;
1360 ret
= Exynos_OMX_VideoEncodeGetConfig(hComponent
, nIndex
, pComponentConfigStructure
);
1370 OMX_ERRORTYPE
Exynos_H264Enc_SetConfig(
1371 OMX_HANDLETYPE hComponent
,
1372 OMX_INDEXTYPE nIndex
,
1373 OMX_PTR pComponentConfigStructure
)
1375 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1376 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1377 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1378 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
1379 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
1383 if (hComponent
== NULL
|| pComponentConfigStructure
== NULL
) {
1384 ret
= OMX_ErrorBadParameter
;
1387 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1388 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1389 if (ret
!= OMX_ErrorNone
) {
1392 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1393 ret
= OMX_ErrorBadParameter
;
1396 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1397 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1398 ret
= OMX_ErrorInvalidState
;
1402 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1403 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1406 case OMX_IndexConfigVideoIntraPeriod
:
1408 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVEncBase
= ((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
);
1409 OMX_U32 nPFrames
= (*((OMX_U32
*)pComponentConfigStructure
)) - 1;
1411 pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
= nPFrames
;
1413 ret
= OMX_ErrorNone
;
1416 case OMX_IndexConfigVideoAVCIntraPeriod
:
1418 OMX_VIDEO_CONFIG_AVCINTRAPERIOD
*pAVCIntraPeriod
= (OMX_VIDEO_CONFIG_AVCINTRAPERIOD
*)pComponentConfigStructure
;
1419 OMX_U32 portIndex
= pAVCIntraPeriod
->nPortIndex
;
1421 if ((portIndex
!= OUTPUT_PORT_INDEX
)) {
1422 ret
= OMX_ErrorBadPortIndex
;
1425 if (pAVCIntraPeriod
->nIDRPeriod
== (pAVCIntraPeriod
->nPFrames
+ 1))
1426 pH264Enc
->AVCComponent
[OUTPUT_PORT_INDEX
].nPFrames
= pAVCIntraPeriod
->nPFrames
;
1428 ret
= OMX_ErrorBadParameter
;
1435 ret
= Exynos_OMX_VideoEncodeSetConfig(hComponent
, nIndex
, pComponentConfigStructure
);
1440 if (ret
== OMX_ErrorNone
)
1441 pVideoEnc
->configChange
= OMX_TRUE
;
1448 OMX_ERRORTYPE
Exynos_H264Enc_GetExtensionIndex(
1449 OMX_IN OMX_HANDLETYPE hComponent
,
1450 OMX_IN OMX_STRING cParameterName
,
1451 OMX_OUT OMX_INDEXTYPE
*pIndexType
)
1453 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1454 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1455 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1459 if (hComponent
== NULL
) {
1460 ret
= OMX_ErrorBadParameter
;
1463 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1464 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1465 if (ret
!= OMX_ErrorNone
) {
1468 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1469 ret
= OMX_ErrorBadParameter
;
1472 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1473 if ((cParameterName
== NULL
) || (pIndexType
== NULL
)) {
1474 ret
= OMX_ErrorBadParameter
;
1477 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1478 ret
= OMX_ErrorInvalidState
;
1481 if (Exynos_OSAL_Strcmp(cParameterName
, EXYNOS_INDEX_CONFIG_VIDEO_INTRAPERIOD
) == 0) {
1482 *pIndexType
= OMX_IndexConfigVideoIntraPeriod
;
1483 ret
= OMX_ErrorNone
;
1485 ret
= Exynos_OMX_VideoEncodeGetExtensionIndex(hComponent
, cParameterName
, pIndexType
);
1494 OMX_ERRORTYPE
Exynos_H264Enc_ComponentRoleEnum(OMX_HANDLETYPE hComponent
, OMX_U8
*cRole
, OMX_U32 nIndex
)
1496 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1497 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1498 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1502 if ((hComponent
== NULL
) || (cRole
== NULL
)) {
1503 ret
= OMX_ErrorBadParameter
;
1506 if (nIndex
== (MAX_COMPONENT_ROLE_NUM
-1)) {
1507 Exynos_OSAL_Strcpy((char *)cRole
, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE
);
1508 ret
= OMX_ErrorNone
;
1510 ret
= OMX_ErrorNoMore
;
1520 OMX_ERRORTYPE
Exynos_H264Enc_Init(OMX_COMPONENTTYPE
*pOMXComponent
)
1522 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1523 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1524 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1525 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1526 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1527 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;;
1528 EXYNOS_MFC_H264ENC_HANDLE
*pMFCH264Handle
= &pH264Enc
->hMFCH264Handle
;
1529 OMX_PTR hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1530 OMX_COLOR_FORMATTYPE eColorFormat
;
1532 ExynosVideoEncOps
*pEncOps
= NULL
;
1533 ExynosVideoEncBufferOps
*pInbufOps
= NULL
;
1534 ExynosVideoEncBufferOps
*pOutbufOps
= NULL
;
1540 pH264Enc
->hMFCH264Handle
.bConfiguredMFCSrc
= OMX_FALSE
;
1541 pH264Enc
->hMFCH264Handle
.bConfiguredMFCDst
= OMX_FALSE
;
1542 pExynosComponent
->bUseFlagEOF
= OMX_TRUE
;
1543 pExynosComponent
->bSaveFlagEOS
= OMX_FALSE
;
1544 pExynosComponent
->bBehaviorEOS
= OMX_FALSE
;
1546 eColorFormat
= pExynosInputPort
->portDefinition
.format
.video
.eColorFormat
;
1547 if (pExynosInputPort
->bStoreMetaData
== OMX_TRUE
) {
1548 if (eColorFormat
== OMX_COLOR_FormatAndroidOpaque
) {
1549 pExynosInputPort
->bufferProcessType
= BUFFER_COPY
;
1551 pExynosInputPort
->bufferProcessType
= BUFFER_SHARE
;
1554 pExynosInputPort
->bufferProcessType
= BUFFER_COPY
;
1557 /* H.264 Codec Open */
1558 ret
= H264CodecOpen(pH264Enc
);
1559 if (ret
!= OMX_ErrorNone
) {
1563 pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1564 pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
1565 pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
1567 if ((pExynosInputPort
->bStoreMetaData
!= OMX_TRUE
) &&
1568 (eColorFormat
!= OMX_COLOR_FormatAndroidOpaque
)) {
1569 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
1570 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort
->codecSemID
);
1571 Exynos_OSAL_QueueCreate(&pExynosInputPort
->codecBufferQ
, MAX_QUEUE_ELEMENTS
);
1573 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
1574 pVideoEnc
->pMFCEncInputBuffer
[i
] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER
));
1575 /* Use ION Allocator */
1577 pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc
->hSharedMemory
, DEFAULT_MFC_INPUT_YBUFFER_SIZE
, NORMAL_MEMORY
);
1578 pVideoEnc
->pMFCEncInputBuffer
[i
]->fd
[0] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc
->hSharedMemory
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0]);
1579 pVideoEnc
->pMFCEncInputBuffer
[i
]->bufferSize
[0] = DEFAULT_MFC_INPUT_YBUFFER_SIZE
;
1581 pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc
->hSharedMemory
, DEFAULT_MFC_INPUT_CBUFFER_SIZE
, NORMAL_MEMORY
);
1582 pVideoEnc
->pMFCEncInputBuffer
[i
]->fd
[1] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc
->hSharedMemory
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1]);
1583 pVideoEnc
->pMFCEncInputBuffer
[i
]->bufferSize
[1] = DEFAULT_MFC_INPUT_CBUFFER_SIZE
;
1585 pVideoEnc
->pMFCEncInputBuffer
[i
]->dataSize
= 0;
1587 if ((pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0] == NULL
) ||
1588 (pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1] == NULL
)) {
1589 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Fail input buffer");
1590 ret
= OMX_ErrorInsufficientResources
;
1594 /* MFC input buffers are 1 plane. */
1595 pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[2] = NULL
;
1596 pVideoEnc
->pMFCEncInputBuffer
[i
]->fd
[2] = -1;
1597 pVideoEnc
->pMFCEncInputBuffer
[i
]->bufferSize
[2] = 0;
1599 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]);
1600 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0]);
1601 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[1]);
1603 Exynos_CodecBufferEnQueue(pExynosComponent
, INPUT_PORT_INDEX
, pVideoEnc
->pMFCEncInputBuffer
[i
]);
1605 } else if (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
) {
1609 /* Does not require any actions. */
1613 if ((pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
1614 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort
->codecSemID
);
1615 Exynos_OSAL_QueueCreate(&pExynosOutputPort
->codecBufferQ
, MAX_QUEUE_ELEMENTS
);
1616 } else if (pExynosOutputPort
->bufferProcessType
== BUFFER_SHARE
) {
1620 /* Does not require any actions. */
1623 pH264Enc
->bSourceStart
= OMX_FALSE
;
1624 Exynos_OSAL_SignalCreate(&pH264Enc
->hSourceStartEvent
);
1625 pH264Enc
->bDestinationStart
= OMX_FALSE
;
1626 Exynos_OSAL_SignalCreate(&pH264Enc
->hDestinationStartEvent
);
1628 Exynos_OSAL_Memset(pExynosComponent
->timeStamp
, -19771003, sizeof(OMX_TICKS
) * MAX_TIMESTAMP
);
1629 Exynos_OSAL_Memset(pExynosComponent
->nFlags
, 0, sizeof(OMX_U32
) * MAX_FLAGS
);
1630 pH264Enc
->hMFCH264Handle
.indexTimestamp
= 0;
1631 pH264Enc
->hMFCH264Handle
.outputIndexTimestamp
= 0;
1633 pExynosComponent
->getAllDelayBuffer
= OMX_FALSE
;
1642 OMX_ERRORTYPE
Exynos_H264Enc_Terminate(OMX_COMPONENTTYPE
*pOMXComponent
)
1644 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1645 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1646 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= ((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
);
1647 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1648 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1649 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1650 OMX_PTR hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1652 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1653 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
1654 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
1656 int i
= 0, plane
= 0;
1660 Exynos_OSAL_SignalTerminate(pH264Enc
->hDestinationStartEvent
);
1661 pH264Enc
->hDestinationStartEvent
= NULL
;
1662 pH264Enc
->bDestinationStart
= OMX_FALSE
;
1663 Exynos_OSAL_SignalTerminate(pH264Enc
->hSourceStartEvent
);
1664 pH264Enc
->hSourceStartEvent
= NULL
;
1665 pH264Enc
->bSourceStart
= OMX_FALSE
;
1667 if ((pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
1668 for (i
= 0; i
< MFC_OUTPUT_BUFFER_NUM_MAX
; i
++) {
1669 if (pVideoEnc
->pMFCEncOutputBuffer
[i
] != NULL
) {
1670 if (pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0] != NULL
)
1671 Exynos_OSAL_SharedMemory_Free(pVideoEnc
->hSharedMemory
, pVideoEnc
->pMFCEncOutputBuffer
[i
]->pVirAddr
[0]);
1672 Exynos_OSAL_Free(pVideoEnc
->pMFCEncOutputBuffer
[i
]);
1673 pVideoEnc
->pMFCEncOutputBuffer
[i
] = NULL
;
1677 Exynos_OSAL_QueueTerminate(&pExynosOutputPort
->codecBufferQ
);
1678 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort
->codecSemID
);
1679 } else if (pExynosOutputPort
->bufferProcessType
== BUFFER_SHARE
) {
1683 /* Does not require any actions. */
1686 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
1687 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
1688 if (pVideoEnc
->pMFCEncInputBuffer
[i
] != NULL
) {
1689 for (plane
= 0; plane
< MFC_INPUT_BUFFER_PLANE
; plane
++) {
1690 if (pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[plane
] != NULL
)
1691 Exynos_OSAL_SharedMemory_Free(pVideoEnc
->hSharedMemory
, pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[plane
]);
1693 Exynos_OSAL_Free(pVideoEnc
->pMFCEncInputBuffer
[i
]);
1694 pVideoEnc
->pMFCEncInputBuffer
[i
] = NULL
;
1698 Exynos_OSAL_QueueTerminate(&pExynosInputPort
->codecBufferQ
);
1699 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort
->codecSemID
);
1700 } else if (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
) {
1704 /* Does not require any actions. */
1706 H264CodecClose(pH264Enc
);
1714 OMX_ERRORTYPE
Exynos_H264Enc_SrcIn(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
1716 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1717 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1718 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1719 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1720 void *hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1721 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1722 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1723 OMX_U32 oneFrameSize
= pSrcInputData
->dataLen
;
1724 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1725 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
1726 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
1727 ExynosVideoErrorType codecReturn
= VIDEO_ERROR_NONE
;
1732 if (pH264Enc
->hMFCH264Handle
.bConfiguredMFCSrc
== OMX_FALSE
) {
1733 ret
= H264CodecSrcSetup(pOMXComponent
, pSrcInputData
);
1734 if ((pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
)
1737 if (pH264Enc
->hMFCH264Handle
.bConfiguredMFCDst
== OMX_FALSE
) {
1738 ret
= H264CodecDstSetup(pOMXComponent
);
1741 if (pVideoEnc
->configChange
== OMX_TRUE
) {
1742 Change_H264Enc_Param(pExynosComponent
);
1743 pVideoEnc
->configChange
= OMX_FALSE
;
1745 if ((pSrcInputData
->dataLen
>= 0) ||
1746 ((pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
)) {
1747 OMX_U32 nAllocLen
[MFC_INPUT_BUFFER_PLANE
] = {0, 0};
1748 OMX_U32 pMFCYUVDataSize
[MFC_INPUT_BUFFER_PLANE
] = {NULL
, NULL
};
1749 ExynosVideoPlane planes
[MFC_INPUT_BUFFER_PLANE
];
1752 pExynosComponent
->timeStamp
[pH264Enc
->hMFCH264Handle
.indexTimestamp
] = pSrcInputData
->timeStamp
;
1753 pExynosComponent
->nFlags
[pH264Enc
->hMFCH264Handle
.indexTimestamp
] = pSrcInputData
->nFlags
;
1754 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData
->timeStamp
, pSrcInputData
->timeStamp
/ 1E6
, pH264Enc
->hMFCH264Handle
.indexTimestamp
, pSrcInputData
->nFlags
);
1755 pEncOps
->Set_FrameTag(hMFCHandle
, pH264Enc
->hMFCH264Handle
.indexTimestamp
);
1756 pH264Enc
->hMFCH264Handle
.indexTimestamp
++;
1757 pH264Enc
->hMFCH264Handle
.indexTimestamp
%= MAX_TIMESTAMP
;
1759 /* queue work for input buffer */
1760 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "Exynos_H264Enc_SrcIn(): oneFrameSize: %d, bufferHeader: 0x%x", oneFrameSize
, pSrcInputData
->bufferHeader
);
1761 pMFCYUVDataSize
[0] = pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
* pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
;
1762 pMFCYUVDataSize
[1] = pMFCYUVDataSize
[0] / 2;
1764 #ifdef USE_METADATABUFFERTYPE
1765 nAllocLen
[0] = ALIGN_TO_16B(pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
) *
1766 ALIGN_TO_16B(pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
);
1767 nAllocLen
[1] = ALIGN(nAllocLen
[0]/2,256);
1769 if ((pExynosInputPort
->bStoreMetaData
== OMX_TRUE
) &&
1770 (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
)) {
1771 codecReturn
= pInbufOps
->ExtensionEnqueue(hMFCHandle
,
1772 (unsigned char **)pSrcInputData
->buffer
.multiPlaneBuffer
.dataBuffer
,
1773 (unsigned char **)pSrcInputData
->buffer
.multiPlaneBuffer
.fd
,
1774 (unsigned int *)nAllocLen
, (unsigned int *)pMFCYUVDataSize
,
1775 MFC_INPUT_BUFFER_PLANE
, pSrcInputData
->bufferHeader
);
1777 codecReturn
= pInbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pSrcInputData
->buffer
.multiPlaneBuffer
.dataBuffer
,
1778 (unsigned int *)pMFCYUVDataSize
, MFC_INPUT_BUFFER_PLANE
, pSrcInputData
->bufferHeader
);
1781 codecReturn
= pInbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pSrcInputData
->buffer
.multiPlaneBuffer
.dataBuffer
,
1782 (unsigned int *)pMFCYUVDataSize
, MFC_INPUT_BUFFER_PLANE
, pSrcInputData
->bufferHeader
);
1784 if (codecReturn
!= VIDEO_ERROR_NONE
) {
1785 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - pInbufOps->Enqueue", __FUNCTION__
, __LINE__
);
1786 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecEncode
;
1789 H264CodecStart(pOMXComponent
, INPUT_PORT_INDEX
);
1790 if (pH264Enc
->bSourceStart
== OMX_FALSE
) {
1791 pH264Enc
->bSourceStart
= OMX_TRUE
;
1792 Exynos_OSAL_SignalSet(pH264Enc
->hSourceStartEvent
);
1793 Exynos_OSAL_SleepMillisec(0);
1795 if (pH264Enc
->bDestinationStart
== OMX_FALSE
) {
1796 pH264Enc
->bDestinationStart
= OMX_TRUE
;
1797 Exynos_OSAL_SignalSet(pH264Enc
->hDestinationStartEvent
);
1798 Exynos_OSAL_SleepMillisec(0);
1802 ret
= OMX_ErrorNone
;
1810 OMX_ERRORTYPE
Exynos_H264Enc_SrcOut(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcOutputData
)
1812 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1813 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1814 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1815 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1816 void *hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1817 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1818 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1819 ExynosVideoEncBufferOps
*pInbufOps
= pH264Enc
->hMFCH264Handle
.pInbufOps
;
1820 ExynosVideoBuffer
*pVideoBuffer
;
1821 ExynosVideoBuffer videoBuffer
;
1825 if ((pExynosInputPort
->bStoreMetaData
== OMX_TRUE
) &&
1826 (pExynosInputPort
->bufferProcessType
== BUFFER_SHARE
)) {
1827 if (pInbufOps
->ExtensionDequeue(hMFCHandle
, &videoBuffer
) == VIDEO_ERROR_NONE
)
1828 pVideoBuffer
= &videoBuffer
;
1830 pVideoBuffer
= NULL
;
1832 pVideoBuffer
= pInbufOps
->Dequeue(hMFCHandle
);
1835 pSrcOutputData
->dataLen
= 0;
1836 pSrcOutputData
->usedDataLen
= 0;
1837 pSrcOutputData
->remainDataLen
= 0;
1838 pSrcOutputData
->nFlags
= 0;
1839 pSrcOutputData
->timeStamp
= 0;
1841 if (pVideoBuffer
== NULL
) {
1842 pSrcOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
= NULL
;
1843 pSrcOutputData
->allocSize
= 0;
1844 pSrcOutputData
->pPrivate
= NULL
;
1845 pSrcOutputData
->bufferHeader
= NULL
;
1848 for (plane
= 0; plane
< MFC_INPUT_BUFFER_PLANE
; plane
++) {
1849 pSrcOutputData
->buffer
.multiPlaneBuffer
.dataBuffer
[plane
] = pVideoBuffer
->planes
[plane
].addr
;
1850 pSrcOutputData
->buffer
.multiPlaneBuffer
.fd
[plane
] = pVideoBuffer
->planes
[plane
].fd
;
1852 pSrcOutputData
->allocSize
= pVideoBuffer
->planes
[0].allocSize
+
1853 pVideoBuffer
->planes
[1].allocSize
+
1854 pVideoBuffer
->planes
[2].allocSize
;
1856 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
1858 while (pSrcOutputData
->buffer
.multiPlaneBuffer
.dataBuffer
[0] != pVideoEnc
->pMFCEncInputBuffer
[i
]->pVirAddr
[0]) {
1859 if (i
>= MFC_INPUT_BUFFER_NUM_MAX
) {
1860 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - Lost buffer", __FUNCTION__
, __LINE__
);
1861 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecEncode
;
1866 pVideoEnc
->pMFCEncInputBuffer
[i
]->dataSize
= 0;
1867 pSrcOutputData
->pPrivate
= pVideoEnc
->pMFCEncInputBuffer
[i
];
1870 /* For Share Buffer */
1871 pSrcOutputData
->bufferHeader
= (OMX_BUFFERHEADERTYPE
*)pVideoBuffer
->pPrivate
;
1874 ret
= OMX_ErrorNone
;
1882 OMX_ERRORTYPE
Exynos_H264Enc_DstIn(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstInputData
)
1884 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1885 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1886 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1887 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1888 void *hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1889 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1890 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
1891 OMX_U32 dataLen
= 0;
1892 ExynosVideoErrorType codecReturn
= VIDEO_ERROR_NONE
;
1896 if (pDstInputData
->buffer
.singlePlaneBuffer
.dataBuffer
== NULL
) {
1897 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to find input buffer");
1898 ret
= OMX_ErrorBadParameter
;
1902 codecReturn
= pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)&pDstInputData
->buffer
.singlePlaneBuffer
.dataBuffer
,
1903 (unsigned int *)&dataLen
, MFC_OUTPUT_BUFFER_PLANE
, pDstInputData
->bufferHeader
);
1905 if (codecReturn
!= VIDEO_ERROR_NONE
) {
1906 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - pOutbufOps->Enqueue", __FUNCTION__
, __LINE__
);
1907 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecEncode
;
1910 H264CodecStart(pOMXComponent
, OUTPUT_PORT_INDEX
);
1912 ret
= OMX_ErrorNone
;
1920 OMX_ERRORTYPE
Exynos_H264Enc_DstOut(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstOutputData
)
1922 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1923 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1924 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1925 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1926 void *hMFCHandle
= pH264Enc
->hMFCH264Handle
.hMFCHandle
;
1927 ExynosVideoEncOps
*pEncOps
= pH264Enc
->hMFCH264Handle
.pEncOps
;
1928 ExynosVideoEncBufferOps
*pOutbufOps
= pH264Enc
->hMFCH264Handle
.pOutbufOps
;
1929 ExynosVideoBuffer
*pVideoBuffer
;
1930 ExynosVideoFrameStatusType displayStatus
= VIDEO_FRAME_STATUS_UNKNOWN
;
1931 ExynosVideoGeometry bufferGeometry
;
1932 OMX_S32 indexTimestamp
= 0;
1936 if (pH264Enc
->bDestinationStart
== OMX_FALSE
) {
1937 ret
= OMX_ErrorNone
;
1941 if ((pVideoBuffer
= pOutbufOps
->Dequeue(hMFCHandle
)) == NULL
) {
1942 ret
= OMX_ErrorNone
;
1946 pH264Enc
->hMFCH264Handle
.outputIndexTimestamp
++;
1947 pH264Enc
->hMFCH264Handle
.outputIndexTimestamp
%= MAX_TIMESTAMP
;
1949 pDstOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
= pVideoBuffer
->planes
[0].addr
;
1950 pDstOutputData
->buffer
.singlePlaneBuffer
.fd
= pVideoBuffer
->planes
[0].fd
;
1951 pDstOutputData
->allocSize
= pVideoBuffer
->planes
[0].allocSize
;
1952 pDstOutputData
->dataLen
= pVideoBuffer
->planes
[0].dataSize
;
1953 pDstOutputData
->remainDataLen
= pVideoBuffer
->planes
[0].dataSize
;
1954 pDstOutputData
->usedDataLen
= 0;
1955 pDstOutputData
->pPrivate
= pVideoBuffer
;
1956 /* For Share Buffer */
1957 pDstOutputData
->bufferHeader
= (OMX_BUFFERHEADERTYPE
*)pVideoBuffer
->pPrivate
;
1959 if (pVideoEnc
->bFirstOutput
== OMX_FALSE
) {
1964 /* Calculate sps/pps size if needed */
1965 p
= FindDelimiter((OMX_U8
*)(pDstOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
+ 4),
1966 pDstOutputData
->dataLen
- 4);
1968 iSpsSize
= (unsigned int)p
- (unsigned int)pDstOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
;
1969 pH264Enc
->hMFCH264Handle
.headerData
.pHeaderSPS
=
1970 (OMX_PTR
)pDstOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
;
1971 pH264Enc
->hMFCH264Handle
.headerData
.SPSLen
= iSpsSize
;
1973 iPpsSize
= pDstOutputData
->dataLen
- iSpsSize
;
1974 pH264Enc
->hMFCH264Handle
.headerData
.pHeaderPPS
=
1975 (OMX_U8
*)pDstOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
+ iSpsSize
;
1976 pH264Enc
->hMFCH264Handle
.headerData
.PPSLen
= iPpsSize
;
1978 pDstOutputData
->timeStamp
= 0;
1979 pDstOutputData
->nFlags
|= OMX_BUFFERFLAG_CODECCONFIG
;
1980 pDstOutputData
->nFlags
|= OMX_BUFFERFLAG_ENDOFFRAME
;
1981 pVideoEnc
->bFirstOutput
= OMX_TRUE
;
1983 indexTimestamp
= pEncOps
->Get_FrameTag(pH264Enc
->hMFCH264Handle
.hMFCHandle
);
1984 if ((indexTimestamp
< 0) || (indexTimestamp
>= MAX_TIMESTAMP
)) {
1985 pDstOutputData
->timeStamp
= pExynosComponent
->timeStamp
[pH264Enc
->hMFCH264Handle
.outputIndexTimestamp
];
1986 pDstOutputData
->nFlags
= pExynosComponent
->nFlags
[pH264Enc
->hMFCH264Handle
.outputIndexTimestamp
];
1988 pDstOutputData
->timeStamp
= pExynosComponent
->timeStamp
[indexTimestamp
];
1989 pDstOutputData
->nFlags
= pExynosComponent
->nFlags
[indexTimestamp
];
1992 pDstOutputData
->nFlags
|= OMX_BUFFERFLAG_ENDOFFRAME
;
1993 if (pVideoBuffer
->frameType
== VIDEO_FRAME_I
)
1994 pDstOutputData
->nFlags
|= OMX_BUFFERFLAG_SYNCFRAME
;
1997 if ((displayStatus
== VIDEO_FRAME_STATUS_CHANGE_RESOL
) ||
1998 (((pDstOutputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
) &&
1999 (pExynosComponent
->bBehaviorEOS
== OMX_FALSE
))) {
2000 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "%x displayStatus:%d, nFlags0x%x", pExynosComponent
, displayStatus
, pDstOutputData
->nFlags
);
2001 pDstOutputData
->remainDataLen
= 0;
2003 if (((pDstOutputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
) &&
2004 (pExynosComponent
->bBehaviorEOS
== OMX_TRUE
))
2005 pExynosComponent
->bBehaviorEOS
= OMX_FALSE
;
2007 ret
= OMX_ErrorNone
;
2015 OMX_ERRORTYPE
Exynos_H264Enc_srcInputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
2017 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2018 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2019 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2020 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
2024 if ((!CHECK_PORT_ENABLED(pExynosInputPort
)) || (!CHECK_PORT_POPULATED(pExynosInputPort
))) {
2025 ret
= OMX_ErrorNone
;
2028 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, INPUT_PORT_INDEX
)) {
2029 ret
= OMX_ErrorNone
;
2033 ret
= Exynos_H264Enc_SrcIn(pOMXComponent
, pSrcInputData
);
2034 if (ret
!= OMX_ErrorNone
) {
2035 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - SrcIn -> event is thrown to client", __FUNCTION__
, __LINE__
);
2036 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2037 pExynosComponent
->callbackData
,
2038 OMX_EventError
, ret
, 0, NULL
);
2047 OMX_ERRORTYPE
Exynos_H264Enc_srcOutputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcOutputData
)
2049 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2050 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2051 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2052 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
2056 if ((!CHECK_PORT_ENABLED(pExynosInputPort
)) || (!CHECK_PORT_POPULATED(pExynosInputPort
))) {
2057 ret
= OMX_ErrorNone
;
2061 if ((pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
2062 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, INPUT_PORT_INDEX
)) {
2063 ret
= OMX_ErrorNone
;
2067 if ((pH264Enc
->bSourceStart
== OMX_FALSE
) &&
2068 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort
))) {
2069 Exynos_OSAL_SignalWait(pH264Enc
->hSourceStartEvent
, DEF_MAX_WAIT_TIME
);
2070 Exynos_OSAL_SignalReset(pH264Enc
->hSourceStartEvent
);
2073 ret
= Exynos_H264Enc_SrcOut(pOMXComponent
, pSrcOutputData
);
2074 if ((ret
!= OMX_ErrorNone
) && (pExynosComponent
->currentState
== OMX_StateExecuting
)) {
2075 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - SrcOut -> event is thrown to client", __FUNCTION__
, __LINE__
);
2076 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2077 pExynosComponent
->callbackData
,
2078 OMX_EventError
, ret
, 0, NULL
);
2087 OMX_ERRORTYPE
Exynos_H264Enc_dstInputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstInputData
)
2089 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2090 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2091 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2092 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2096 if ((!CHECK_PORT_ENABLED(pExynosOutputPort
)) || (!CHECK_PORT_POPULATED(pExynosOutputPort
))) {
2097 ret
= OMX_ErrorNone
;
2100 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, OUTPUT_PORT_INDEX
)) {
2101 ret
= OMX_ErrorNone
;
2104 if (pExynosOutputPort
->bufferProcessType
== BUFFER_SHARE
) {
2105 if ((pH264Enc
->bDestinationStart
== OMX_FALSE
) &&
2106 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort
))) {
2107 Exynos_OSAL_SignalWait(pH264Enc
->hDestinationStartEvent
, DEF_MAX_WAIT_TIME
);
2108 Exynos_OSAL_SignalReset(pH264Enc
->hDestinationStartEvent
);
2111 if (pH264Enc
->hMFCH264Handle
.bConfiguredMFCDst
== OMX_TRUE
) {
2112 ret
= Exynos_H264Enc_DstIn(pOMXComponent
, pDstInputData
);
2113 if (ret
!= OMX_ErrorNone
) {
2114 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - DstIn -> event is thrown to client", __FUNCTION__
, __LINE__
);
2115 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2116 pExynosComponent
->callbackData
,
2117 OMX_EventError
, ret
, 0, NULL
);
2127 OMX_ERRORTYPE
Exynos_H264Enc_dstOutputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstOutputData
)
2129 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2130 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2131 EXYNOS_H264ENC_HANDLE
*pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2132 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2136 if ((!CHECK_PORT_ENABLED(pExynosOutputPort
)) || (!CHECK_PORT_POPULATED(pExynosOutputPort
))) {
2137 ret
= OMX_ErrorNone
;
2140 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, OUTPUT_PORT_INDEX
)) {
2141 ret
= OMX_ErrorNone
;
2145 if ((pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) == BUFFER_COPY
) {
2146 if ((pH264Enc
->bDestinationStart
== OMX_FALSE
) &&
2147 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort
))) {
2148 Exynos_OSAL_SignalWait(pH264Enc
->hDestinationStartEvent
, DEF_MAX_WAIT_TIME
);
2149 Exynos_OSAL_SignalReset(pH264Enc
->hDestinationStartEvent
);
2152 ret
= Exynos_H264Enc_DstOut(pOMXComponent
, pDstOutputData
);
2153 if ((ret
!= OMX_ErrorNone
) && (pExynosComponent
->currentState
== OMX_StateExecuting
)) {
2154 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: %d: Failed - DstOut -> event is thrown to client", __FUNCTION__
, __LINE__
);
2155 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2156 pExynosComponent
->callbackData
,
2157 OMX_EventError
, ret
, 0, NULL
);
2166 OSCL_EXPORT_REF OMX_ERRORTYPE
Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent
, OMX_STRING componentName
)
2168 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2169 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
2170 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
2171 EXYNOS_OMX_BASEPORT
*pExynosPort
= NULL
;
2172 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
2173 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
2178 if ((hComponent
== NULL
) || (componentName
== NULL
)) {
2179 ret
= OMX_ErrorBadParameter
;
2180 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, Line:%d", __LINE__
);
2183 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_ENC
, componentName
) != 0) {
2184 ret
= OMX_ErrorBadParameter
;
2185 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName
, __LINE__
);
2189 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
2190 ret
= Exynos_OMX_VideoEncodeComponentInit(pOMXComponent
);
2191 if (ret
!= OMX_ErrorNone
) {
2192 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_Error, Line:%d", __LINE__
);
2195 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2196 pExynosComponent
->codecType
= HW_VIDEO_ENC_CODEC
;
2198 pExynosComponent
->componentName
= (OMX_STRING
)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE
);
2199 if (pExynosComponent
->componentName
== NULL
) {
2200 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent
);
2201 ret
= OMX_ErrorInsufficientResources
;
2202 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorInsufficientResources, Line:%d", __LINE__
);
2205 Exynos_OSAL_Memset(pExynosComponent
->componentName
, 0, MAX_OMX_COMPONENT_NAME_SIZE
);
2207 pH264Enc
= Exynos_OSAL_Malloc(sizeof(EXYNOS_H264ENC_HANDLE
));
2208 if (pH264Enc
== NULL
) {
2209 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent
);
2210 ret
= OMX_ErrorInsufficientResources
;
2211 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorInsufficientResources, Line:%d", __LINE__
);
2214 Exynos_OSAL_Memset(pH264Enc
, 0, sizeof(EXYNOS_H264ENC_HANDLE
));
2215 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
2216 pVideoEnc
->hCodecHandle
= (OMX_HANDLETYPE
)pH264Enc
;
2217 pVideoEnc
->quantization
.nQpI
= 20;
2218 pVideoEnc
->quantization
.nQpP
= 20;
2219 pVideoEnc
->quantization
.nQpB
= 20;
2221 Exynos_OSAL_Strcpy(pExynosComponent
->componentName
, EXYNOS_OMX_COMPONENT_H264_ENC
);
2222 /* Set componentVersion */
2223 pExynosComponent
->componentVersion
.s
.nVersionMajor
= VERSIONMAJOR_NUMBER
;
2224 pExynosComponent
->componentVersion
.s
.nVersionMinor
= VERSIONMINOR_NUMBER
;
2225 pExynosComponent
->componentVersion
.s
.nRevision
= REVISION_NUMBER
;
2226 pExynosComponent
->componentVersion
.s
.nStep
= STEP_NUMBER
;
2227 /* Set specVersion */
2228 pExynosComponent
->specVersion
.s
.nVersionMajor
= VERSIONMAJOR_NUMBER
;
2229 pExynosComponent
->specVersion
.s
.nVersionMinor
= VERSIONMINOR_NUMBER
;
2230 pExynosComponent
->specVersion
.s
.nRevision
= REVISION_NUMBER
;
2231 pExynosComponent
->specVersion
.s
.nStep
= STEP_NUMBER
;
2234 pExynosPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
2235 pExynosPort
->portDefinition
.format
.video
.nFrameWidth
= DEFAULT_FRAME_WIDTH
;
2236 pExynosPort
->portDefinition
.format
.video
.nFrameHeight
= DEFAULT_FRAME_HEIGHT
;
2237 pExynosPort
->portDefinition
.format
.video
.nStride
= 0; /*DEFAULT_FRAME_WIDTH;*/
2238 pExynosPort
->portDefinition
.nBufferSize
= DEFAULT_VIDEO_INPUT_BUFFER_SIZE
;
2239 pExynosPort
->portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingUnused
;
2240 Exynos_OSAL_Memset(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, 0, MAX_OMX_MIMETYPE_SIZE
);
2241 Exynos_OSAL_Strcpy(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, "raw/video");
2242 pExynosPort
->portDefinition
.format
.video
.eColorFormat
= OMX_COLOR_FormatYUV420SemiPlanar
;
2243 pExynosPort
->portDefinition
.bEnabled
= OMX_TRUE
;
2244 pExynosPort
->bufferProcessType
= BUFFER_COPY
;
2245 pExynosPort
->portWayType
= WAY2_PORT
;
2248 pExynosPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2249 pExynosPort
->portDefinition
.format
.video
.nFrameWidth
= DEFAULT_FRAME_WIDTH
;
2250 pExynosPort
->portDefinition
.format
.video
.nFrameHeight
= DEFAULT_FRAME_HEIGHT
;
2251 pExynosPort
->portDefinition
.format
.video
.nStride
= 0; /*DEFAULT_FRAME_WIDTH;*/
2252 pExynosPort
->portDefinition
.nBufferSize
= DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE
;
2253 pExynosPort
->portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingAVC
;
2254 Exynos_OSAL_Memset(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, 0, MAX_OMX_MIMETYPE_SIZE
);
2255 Exynos_OSAL_Strcpy(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, "video/avc");
2256 pExynosPort
->portDefinition
.format
.video
.eColorFormat
= OMX_COLOR_FormatUnused
;
2257 pExynosPort
->portDefinition
.bEnabled
= OMX_TRUE
;
2258 pExynosPort
->bufferProcessType
= BUFFER_SHARE
;
2259 pExynosPort
->portWayType
= WAY2_PORT
;
2261 for(i
= 0; i
< ALL_PORT_NUM
; i
++) {
2262 INIT_SET_SIZE_VERSION(&pH264Enc
->AVCComponent
[i
], OMX_VIDEO_PARAM_AVCTYPE
);
2263 pH264Enc
->AVCComponent
[i
].nPortIndex
= i
;
2264 pH264Enc
->AVCComponent
[i
].eProfile
= OMX_VIDEO_AVCProfileBaseline
;
2265 pH264Enc
->AVCComponent
[i
].eLevel
= OMX_VIDEO_AVCLevel31
;
2267 pH264Enc
->AVCComponent
[i
].nPFrames
= 20;
2270 pOMXComponent
->GetParameter
= &Exynos_H264Enc_GetParameter
;
2271 pOMXComponent
->SetParameter
= &Exynos_H264Enc_SetParameter
;
2272 pOMXComponent
->GetConfig
= &Exynos_H264Enc_GetConfig
;
2273 pOMXComponent
->SetConfig
= &Exynos_H264Enc_SetConfig
;
2274 pOMXComponent
->GetExtensionIndex
= &Exynos_H264Enc_GetExtensionIndex
;
2275 pOMXComponent
->ComponentRoleEnum
= &Exynos_H264Enc_ComponentRoleEnum
;
2276 pOMXComponent
->ComponentDeInit
= &Exynos_OMX_ComponentDeinit
;
2278 pExynosComponent
->exynos_codec_componentInit
= &Exynos_H264Enc_Init
;
2279 pExynosComponent
->exynos_codec_componentTerminate
= &Exynos_H264Enc_Terminate
;
2281 pVideoEnc
->exynos_codec_srcInputProcess
= &Exynos_H264Enc_srcInputBufferProcess
;
2282 pVideoEnc
->exynos_codec_srcOutputProcess
= &Exynos_H264Enc_srcOutputBufferProcess
;
2283 pVideoEnc
->exynos_codec_dstInputProcess
= &Exynos_H264Enc_dstInputBufferProcess
;
2284 pVideoEnc
->exynos_codec_dstOutputProcess
= &Exynos_H264Enc_dstOutputBufferProcess
;
2286 pVideoEnc
->exynos_codec_start
= &H264CodecStart
;
2287 pVideoEnc
->exynos_codec_stop
= &H264CodecStop
;
2288 pVideoEnc
->exynos_codec_bufferProcessRun
= &H264CodecOutputBufferProcessRun
;
2289 pVideoEnc
->exynos_codec_enqueueAllBuffer
= &H264CodecEnQueueAllBuffer
;
2291 pVideoEnc
->exynos_checkInputFrame
= NULL
;
2292 pVideoEnc
->exynos_codec_getCodecInputPrivateData
= &GetCodecInputPrivateData
;
2293 pVideoEnc
->exynos_codec_getCodecOutputPrivateData
= &GetCodecOutputPrivateData
;
2295 pVideoEnc
->hSharedMemory
= Exynos_OSAL_SharedMemory_Open();
2296 if (pVideoEnc
->hSharedMemory
== NULL
) {
2297 Exynos_OSAL_Free(pH264Enc
);
2298 pH264Enc
= ((EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
= NULL
;
2299 Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent
);
2300 ret
= OMX_ErrorInsufficientResources
;
2304 pExynosComponent
->currentState
= OMX_StateLoaded
;
2306 ret
= OMX_ErrorNone
;
2314 OMX_ERRORTYPE
Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent
)
2316 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2317 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
2318 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
2319 EXYNOS_OMX_VIDEOENC_COMPONENT
*pVideoEnc
= NULL
;
2320 EXYNOS_H264ENC_HANDLE
*pH264Enc
= NULL
;
2324 if (hComponent
== NULL
) {
2325 ret
= OMX_ErrorBadParameter
;
2328 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
2329 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2330 pVideoEnc
= (EXYNOS_OMX_VIDEOENC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
2332 Exynos_OSAL_SharedMemory_Close(pVideoEnc
->hSharedMemory
);
2334 Exynos_OSAL_Free(pExynosComponent
->componentName
);
2335 pExynosComponent
->componentName
= NULL
;
2337 pH264Enc
= (EXYNOS_H264ENC_HANDLE
*)pVideoEnc
->hCodecHandle
;
2338 if (pH264Enc
!= NULL
) {
2339 Exynos_OSAL_Free(pH264Enc
);
2340 pH264Enc
= pVideoEnc
->hCodecHandle
= NULL
;
2343 ret
= Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent
);
2344 if (ret
!= OMX_ErrorNone
) {
2348 ret
= OMX_ErrorNone
;