projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
vp9: fix redefinition error
[GitHub/LineageOS/android_hardware_samsung_slsi_openmax.git] / osal / Exynos_OSAL_SkypeHD.c
CommitLineData
a9bdc01e
T		 1/*
2 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * @file Exynos_OSAL_SkypeHD.cpp
19 * @brief
20 * @author Seungbeom Kim (sbcrux.kim@samsung.com)
21 * @version 2.0.0
22 * @history
23 * 2015.04.27 : Create
24 */
25
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29
30#include "Exynos_OSAL_Mutex.h"
31#include "Exynos_OSAL_Semaphore.h"
32#include "Exynos_OMX_Baseport.h"
33#include "Exynos_OMX_Basecomponent.h"
34#include "Exynos_OMX_Macros.h"
35#include "Exynos_OSAL_SkypeHD.h"
36#include "Exynos_OSAL_ETC.h"
37#include "Exynos_OMX_Def.h"
38#include "exynos_format.h"
39
40#include "ExynosVideoApi.h"
41
42#include "OMX_Video_Extensions.h"
43
44#undef EXYNOS_LOG_TAG
45#define EXYNOS_LOG_TAG "Exynos_OSAL_SkypeHD"
46//#define EXYNOS_LOG_OFF
47#include "Exynos_OSAL_Log.h"
48
49#include "Exynos_OSAL_SkypeHD.h"
50
51/* ENCODE_ONLY */
52#ifdef BUILD_ENC
53#include "Exynos_OMX_Venc.h"
54#include "Exynos_OMX_H264enc.h"
55#endif
56
57/* DECODE_ONLY */
58#ifdef BUILD_DEC
59#include "Exynos_OMX_Vdec.h"
60#include "Exynos_OMX_H264dec.h"
61#endif
62
63#ifdef __cplusplus
64extern "C" {
65#endif
66
67/* Change CHECK_SIZE_VERSION Macro for SkypeHD */
68OMX_ERRORTYPE Exynos_OMX_Check_SizeVersion_SkypeHD(OMX_PTR header, OMX_U32 size)
69{
70 OMX_ERRORTYPE ret = OMX_ErrorNone;
71 OMX_VERSIONTYPE *version = NULL;
72
73 if (header == NULL) {
74 ret = OMX_ErrorBadParameter;
75 goto EXIT;
76 }
77
78 version = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
79 if (*((OMX_U32*)header) != size) {
80 ret = OMX_ErrorBadParameter;
81 goto EXIT;
82 }
83
84 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "nVersionMajor:%d, nVersionMinor:%d", version->s.nVersionMajor, version->s.nVersionMinor);
85 if (version->s.nVersionMajor != OMX_VIDEO_MajorVersion ||
86 version->s.nVersionMinor > OMX_VIDEO_MinorVersion) {
87 ret = OMX_ErrorVersionMismatch;
88 goto EXIT;
89 }
90
91 ret = OMX_ErrorNone;
92
93EXIT:
94 return ret;
95}
96
97
98
99/* ENCODE_ONLY */
100#ifdef BUILD_ENC
101/* video enc */
102OMX_ERRORTYPE Exynos_H264Enc_GetExtensionIndex_SkypeHD(
103 OMX_IN OMX_HANDLETYPE hComponent,
104 OMX_IN OMX_STRING cParameterName,
105 OMX_OUT OMX_INDEXTYPE *pIndexType)
106{
107 OMX_ERRORTYPE ret = OMX_ErrorNone;
108 OMX_COMPONENTTYPE *pOMXComponent = NULL;
109 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
110
111 FunctionIn();
112
113 if (hComponent == NULL) {
114 ret = OMX_ErrorBadParameter;
115 goto EXIT;
116 }
117 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
118 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
119 if (ret != OMX_ErrorNone) {
120 goto EXIT;
121 }
122 if (pOMXComponent->pComponentPrivate == NULL) {
123 ret = OMX_ErrorBadParameter;
124 goto EXIT;
125 }
126 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
127 if ((cParameterName == NULL) || (pIndexType == NULL)) {
128 ret = OMX_ErrorBadParameter;
129 goto EXIT;
130 }
131
132 if (pExynosComponent->currentState == OMX_StateInvalid) {
133 ret = OMX_ErrorInvalidState;
134 goto EXIT;
135 }
136
137 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_DRIVERVER) == 0) {
138 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamDriverVersion;
139 ret = OMX_ErrorNone;
140 goto EXIT;
141 }
142
143 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_ENCODERSETTING) == 0) {
144 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamEncoderSetting;
145 ret = OMX_ErrorNone;
146 goto EXIT;
147 }
148
149 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_ENCODERCAP) == 0) {
150 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamEncoderCapability;
151 ret = OMX_ErrorNone;
152 goto EXIT;
153 }
154
155 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_CONFIG_MARKLTRFRAME) == 0) {
156 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeConfigMarkLTRFrame;
157 ret = OMX_ErrorNone;
158 goto EXIT;
159 }
160
161 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_CONFIG_USELTRFRAME) == 0) {
162 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeConfigUseLTRFrame;
163 ret = OMX_ErrorNone;
164 goto EXIT;
165 }
166
167 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_CONFIG_QP) == 0) {
168 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeConfigQP;
169 ret = OMX_ErrorNone;
170 goto EXIT;
171 }
172
173 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_CONFIG_TEMPORALLAYERCOUNT) == 0) {
174 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeConfigTemporalLayerCount;
175 ret = OMX_ErrorNone;
176 goto EXIT;
177 }
178
179 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_CONFIG_BASELAYERPID) == 0) {
180 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeConfigBasePid;
181 ret = OMX_ErrorNone;
182 goto EXIT;
183 }
184
185 ret = OMX_ErrorUnsupportedIndex;
186
187EXIT:
188 FunctionOut();
189
190 return ret;
191}
192
193OMX_ERRORTYPE Exynos_H264Enc_GetParameter_SkypeHD(
194 OMX_IN OMX_HANDLETYPE hComponent,
195 OMX_IN OMX_INDEXTYPE nParamIndex,
196 OMX_INOUT OMX_PTR pComponentParameterStructure)
197{
198
199 OMX_ERRORTYPE ret = OMX_ErrorNone;
200 OMX_COMPONENTTYPE *pOMXComponent = NULL;
201 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
202 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
203 EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
204
205 FunctionIn();
206
207 if ((hComponent == NULL) || (pComponentParameterStructure == NULL)) {
208 ret = OMX_ErrorBadParameter;
209 goto EXIT;
210 }
211 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
212 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
213 if (ret != OMX_ErrorNone) {
214 goto EXIT;
215 }
216 if (pOMXComponent->pComponentPrivate == NULL) {
217 ret = OMX_ErrorBadParameter;
218 goto EXIT;
219 }
220
221 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
222 if (pExynosComponent->currentState == OMX_StateInvalid) {
223 ret = OMX_ErrorInvalidState;
224 goto EXIT;
225 }
226
227 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
228 pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
229
230 switch ((int)nParamIndex) {
231 case OMX_IndexSkypeParamDriverVersion:
232 {
233 OMX_VIDEO_PARAM_DRIVERVER *pDriverVer = (OMX_VIDEO_PARAM_DRIVERVER *)pComponentParameterStructure;
234
235 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pDriverVer, sizeof(OMX_VIDEO_PARAM_DRIVERVER));
236 if (ret != OMX_ErrorNone)
237 goto EXIT;
238
239 if (pDriverVer->nPortIndex > OUTPUT_PORT_INDEX) {
240 ret = OMX_ErrorBadPortIndex;
241 goto EXIT;
242 }
243
244 pDriverVer->nDriverVersion = (OMX_U64)(pH264Enc->hMFCH264Handle.videoInstInfo.SwVersion);
245 }
246 break;
247 case OMX_IndexSkypeParamEncoderCapability:
248 {
249 OMX_VIDEO_PARAM_ENCODERCAP *pEncoderCap = (OMX_VIDEO_PARAM_ENCODERCAP *)pComponentParameterStructure;
250 OMX_VIDEO_ENCODERCAP *pstEncCap = NULL;
251
252 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pEncoderCap, sizeof(OMX_VIDEO_PARAM_ENCODERCAP));
253 if (ret != OMX_ErrorNone)
254 goto EXIT;
255
256 if (pEncoderCap->nPortIndex > OUTPUT_PORT_INDEX) {
257 ret = OMX_ErrorBadPortIndex;
258 goto EXIT;
259 }
260
261 pstEncCap = &(pEncoderCap->stEncCap);
262
263 pstEncCap->bLowLatency = OMX_TRUE;
264 pstEncCap->nMaxFrameWidth = MAX_FRAME_WIDTH;
265 pstEncCap->nMaxFrameHeight = MAX_FRAME_HEIGHT;
266 pstEncCap->nMaxInstances = RESOURCE_VIDEO_ENC;
267 pstEncCap->nMaxTemporaLayerCount = OMX_VIDEO_MAX_TEMPORAL_LAYERS;
268 pstEncCap->nMaxRefFrames = ((OMX_VIDEO_MAX_TEMPORAL_LAYERS_WITH_LTR + 1) / 2) + OMX_VIDEO_MAX_LTR_FRAMES;
269 pstEncCap->nMaxLTRFrames = OMX_VIDEO_MAX_LTR_FRAMES;
270 pstEncCap->nMaxLevel = OMX_VIDEO_AVCLevel42;
271 pstEncCap->nSliceControlModesBM = (1 << (OMX_VIDEO_SliceControlModeMB - 1)) | (1 << (OMX_VIDEO_SliceControlModeByte - 1));
272 pstEncCap->nMaxMacroblockProcessingRate = ENC_BLOCKS_PER_SECOND;
273 pstEncCap->nResize = 0;
274 pstEncCap->xMinScaleFactor = 0;
275 }
276 break;
277 case OMX_IndexSkypeParamEncoderSetting:
278 {
279 OMX_VIDEO_PARAM_ENCODERSETTING *pEncoderSetting = (OMX_VIDEO_PARAM_ENCODERSETTING *)pComponentParameterStructure;
280
281 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pEncoderSetting, sizeof(OMX_VIDEO_PARAM_ENCODERSETTING));
282 if (ret != OMX_ErrorNone)
283 goto EXIT;
284
285 if (pEncoderSetting->nPortIndex > OUTPUT_PORT_INDEX) {
286 ret = OMX_ErrorBadPortIndex;
287 goto EXIT;
288 }
289
290 Exynos_OSAL_Memcpy(&(pEncoderSetting->stEncParam), &(pH264Enc->stEncParam), sizeof(OMX_VIDEO_ENCODERPARAMS));
291 }
292 break;
293 default:
294 ret = OMX_ErrorUnsupportedIndex;
295 break;
296 }
297
298EXIT:
299
300 FunctionOut();
301
302 return ret;
303}
304
305OMX_ERRORTYPE Exynos_H264Enc_SetParameter_SkypeHD(
306 OMX_IN OMX_HANDLETYPE hComponent,
307 OMX_IN OMX_INDEXTYPE nIndex,
308 OMX_IN OMX_PTR pComponentParameterStructure)
309{
310 OMX_ERRORTYPE ret = OMX_ErrorNone;
311 OMX_COMPONENTTYPE *pOMXComponent = NULL;
312 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
313 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
314 EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
315
316 FunctionIn();
317
318 if ((hComponent == NULL) || (pComponentParameterStructure == NULL)) {
319 ret = OMX_ErrorBadParameter;
320 goto EXIT;
321 }
322 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
323 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
324 if (ret != OMX_ErrorNone) {
325 goto EXIT;
326 }
327 if (pOMXComponent->pComponentPrivate == NULL) {
328 ret = OMX_ErrorBadParameter;
329 goto EXIT;
330 }
331
332 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
333 if (pExynosComponent->currentState == OMX_StateInvalid) {
334 ret = OMX_ErrorInvalidState;
335 goto EXIT;
336 }
337
338 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
339 pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
340
341 switch ((int)nIndex) {
342 case OMX_IndexSkypeParamEncoderSetting:
343 {
344 OMX_VIDEO_PARAM_ENCODERSETTING *pEncoderSetting = (OMX_VIDEO_PARAM_ENCODERSETTING *)pComponentParameterStructure;
345 OMX_VIDEO_ENCODERPARAMS *pstEncParam = NULL;
346
347 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pEncoderSetting, sizeof(OMX_VIDEO_PARAM_ENCODERSETTING));
348 if (ret != OMX_ErrorNone)
349 goto EXIT;
350
351 if (pEncoderSetting->nPortIndex > OUTPUT_PORT_INDEX) {
352 ret = OMX_ErrorBadPortIndex;
353 goto EXIT;
354 }
355
356 pstEncParam = &(pEncoderSetting->stEncParam);
357
358 pH264Enc->bLowLatency = pstEncParam->bLowLatency;
359
360 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pstEncParam->bLowLatency: %s", (pstEncParam->bLowLatency == OMX_TRUE) ? "OMX_TRUE" : "OMX_FALSE");
361
362 /* SetPrependSPSPPSToIDR */
363 pH264Enc->hMFCH264Handle.bPrependSpsPpsToIdr = pstEncParam->bSequenceHeaderWithIDR;
364
365 if (pstEncParam->bUseExtendedProfile == OMX_TRUE) {
366 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pstEncParam->eProfile: 0x%x", pstEncParam->eProfile);
367 switch (pstEncParam->eProfile) {
368 case OMX_VIDEO_EXT_AVCProfileConstrainedBaseline:
369 pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eProfile = OMX_VIDEO_AVCProfileConstrainedBaseline;
370 break;
371 case OMX_VIDEO_EXT_AVCProfileConstrainedHigh:
372 pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eProfile = OMX_VIDEO_AVCProfileConstrainedHigh;
373 break;
374 default:
375 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "default eProfile: 0x%x", pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eProfile);
376 break;
377 }
378 }
379
380 switch (pstEncParam->eHierarType) {
381 case OMX_VIDEO_HierarType_P:
382 pH264Enc->eHierarchicalType = EXYNOS_OMX_Hierarchical_P;
383 break;
384 case OMX_VIDEO_HierarType_B:
385 pH264Enc->eHierarchicalType = EXYNOS_OMX_Hierarchical_B;
386 break;
387 default:
388 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "default eHierarType: 0x%x", pH264Enc->eHierarchicalType);
389 break;
390 }
391
392 if (pstEncParam->nMaxTemporalLayerCount > OMX_VIDEO_ANDROID_MAXAVCTEMPORALLAYERS) {
393 ret = OMX_ErrorBadParameter;
394 goto EXIT;
395 } else {
396 if (pstEncParam->nMaxTemporalLayerCount > 0) {
397 pH264Enc->hMFCH264Handle.bTemporalSVC = OMX_TRUE;
398 pH264Enc->TemporalSVC.nTemporalLayerCount = pstEncParam->nMaxTemporalLayerCount | GENERAL_TSVC_ENABLE;
399 } else {
400 pH264Enc->hMFCH264Handle.bTemporalSVC = OMX_FALSE;
401 }
402 }
403
404 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pstEncParam->nLTRFrames: %d", pstEncParam->nLTRFrames);
405 if (((int)(pstEncParam->nLTRFrames) > ((int)OMX_VIDEO_MAX_LTR_FRAMES)) ||
406 (((int)pstEncParam->nLTRFrames) < 0)) {
407 ret = OMX_ErrorBadParameter;
408 goto EXIT;
409 } else {
410 if (pstEncParam->nLTRFrames > 0)
411 pH264Enc->hMFCH264Handle.bLTREnable = OMX_TRUE;
412 else
413 pH264Enc->hMFCH264Handle.bLTREnable = OMX_FALSE;
414 }
415
416 switch (pstEncParam->eSliceControlMode) {
417 case OMX_VIDEO_SliceControlModeMB:
418 pH264Enc->AVCSliceFmo.eSliceMode = OMX_VIDEO_SLICEMODE_AVCMBSlice;
419 break;
420 case OMX_VIDEO_SliceControlModeByte:
421 pH264Enc->AVCSliceFmo.eSliceMode = OMX_VIDEO_SLICEMODE_AVCByteSlice;
422 break;
423 case OMX_VIDEO_SliceControlModeNone:
424 case OMX_VIDEO_SliceControlModMBRow:
425 default:
426 pH264Enc->AVCSliceFmo.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault;
427 break;
428 }
429
430 if (pstEncParam->nSarIndex > 0)
431 pH264Enc->stSarParam.SarEnable = OMX_TRUE;
432
433 pH264Enc->stSarParam.SarIndex = pstEncParam->nSarIndex;
434 pH264Enc->stSarParam.SarWidth = pstEncParam->nSarWidth;
435 pH264Enc->stSarParam.SarHeight = pstEncParam->nSarHeight;
436
437 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SarIndex:%d, SarWidth:%d, SarHeight:%d",
438 pstEncParam->nSarIndex, pstEncParam->nSarWidth, pstEncParam->nSarHeight);
439
440 Exynos_OSAL_Memcpy(&(pH264Enc->stEncParam), &(pEncoderSetting->stEncParam), sizeof(OMX_VIDEO_ENCODERPARAMS));
441 }
442 break;
443 default:
444 ret = OMX_ErrorUnsupportedIndex;
445 break;
446 }
447
448EXIT:
449
450 FunctionOut();
451
452 return ret;
453}
454
455OMX_ERRORTYPE Exynos_H264Enc_GetConfig_SkypeHD(
456 OMX_HANDLETYPE hComponent,
457 OMX_INDEXTYPE nIndex,
458 OMX_PTR pComponentConfigStructure)
459{
460 OMX_ERRORTYPE ret = OMX_ErrorNone;
461 OMX_COMPONENTTYPE *pOMXComponent = NULL;
462 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
463 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
464 EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
465
466 FunctionIn();
467
468 if ((hComponent == NULL) || (pComponentConfigStructure == NULL)) {
469 ret = OMX_ErrorBadParameter;
470 goto EXIT;
471 }
472 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
473 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
474 if (ret != OMX_ErrorNone) {
475 goto EXIT;
476 }
477 if (pOMXComponent->pComponentPrivate == NULL) {
478 ret = OMX_ErrorBadParameter;
479 goto EXIT;
480 }
481 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
482 if (pExynosComponent->currentState == OMX_StateInvalid) {
483 ret = OMX_ErrorInvalidState;
484 goto EXIT;
485 }
486
487 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
488 pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
489
490 switch ((int)nIndex) {
491 case OMX_IndexSkypeConfigTemporalLayerCount:
492 {
493 OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *pTemporalLayerCount = (OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *)pComponentConfigStructure;
494
495 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pTemporalLayerCount, sizeof(OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT));
496 if (ret != OMX_ErrorNone)
497 goto EXIT;
498
499 if (pTemporalLayerCount->nPortIndex > OUTPUT_PORT_INDEX) {
500 ret = OMX_ErrorBadPortIndex;
501 goto EXIT;
502 }
503
504 pTemporalLayerCount->nTemporalLayerCount = pH264Enc->TemporalSVC.nTemporalLayerCount & (~GENERAL_TSVC_ENABLE);
505 }
506 break;
507 case OMX_IndexSkypeConfigBasePid:
508 {
509 OMX_VIDEO_CONFIG_BASELAYERPID *pBaseLayerPid = (OMX_VIDEO_CONFIG_BASELAYERPID *)pComponentConfigStructure;
510
511 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pBaseLayerPid, sizeof(OMX_VIDEO_CONFIG_BASELAYERPID));
512 if (ret != OMX_ErrorNone)
513 goto EXIT;
514
515 if (pBaseLayerPid->nPortIndex > OUTPUT_PORT_INDEX) {
516 ret = OMX_ErrorBadPortIndex;
517 goto EXIT;
518 }
519
520 pBaseLayerPid->nPID = pH264Enc->nBaseLayerPid;
521 }
522 break;
523 default:
524 ret = OMX_ErrorUnsupportedIndex;
525 break;
526 }
527
528EXIT:
529 FunctionOut();
530
531 return ret;
532}
533
534OMX_ERRORTYPE Exynos_H264Enc_SetConfig_SkypeHD(
535 OMX_HANDLETYPE hComponent,
536 OMX_INDEXTYPE nIndex,
537 OMX_PTR pComponentConfigStructure)
538{
539 OMX_ERRORTYPE ret = OMX_ErrorNone;
540 OMX_COMPONENTTYPE *pOMXComponent = NULL;
541 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
542 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
543 EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
544
545 FunctionIn();
546
547 if ((hComponent == NULL) || (pComponentConfigStructure == NULL)) {
548 ret = OMX_ErrorBadParameter;
549 goto EXIT;
550 }
551 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
552 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
553 if (ret != OMX_ErrorNone) {
554 goto EXIT;
555 }
556 if (pOMXComponent->pComponentPrivate == NULL) {
557 ret = OMX_ErrorBadParameter;
558 goto EXIT;
559 }
560 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
561 if (pExynosComponent->currentState == OMX_StateInvalid) {
562 ret = OMX_ErrorInvalidState;
563 goto EXIT;
564 }
565
566 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
567 pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
568
569 switch ((int)nIndex) {
570 case OMX_IndexSkypeConfigMarkLTRFrame:
571 {
572 OMX_VIDEO_CONFIG_MARKLTRFRAME *pMarkLTRFrame = (OMX_VIDEO_CONFIG_MARKLTRFRAME *)pComponentConfigStructure;
573 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
574 ExynosVideoEncParam *pEncParam = NULL;
575 ExynosVideoEncCommonParam *pCommonParam = NULL;
576 ExynosVideoEncH264Param *pH264Param = NULL;
577 ExynosVideoEncOps *pEncOps = NULL;
578
579 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pMarkLTRFrame, sizeof(OMX_VIDEO_CONFIG_MARKLTRFRAME));
580 if (ret != OMX_ErrorNone)
581 goto EXIT;
582
583 if (pMarkLTRFrame->nPortIndex != OUTPUT_PORT_INDEX) {
584 ret = OMX_ErrorBadPortIndex;
585 goto EXIT;
586 }
587
588 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
589 pEncParam = &pMFCH264Handle->encParam;
590 pCommonParam = &pEncParam->commonParam;
591 pH264Param = &pEncParam->codecParam.h264;
592 pEncOps = pMFCH264Handle->pEncOps;
593
594 /* TBD */
595 }
596 break;
597 case OMX_IndexSkypeConfigUseLTRFrame:
598 {
599 OMX_VIDEO_CONFIG_USELTRFRAME *pUseLTRFrame = (OMX_VIDEO_CONFIG_USELTRFRAME *)pComponentConfigStructure;
600 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
601 ExynosVideoEncParam *pEncParam = NULL;
602 ExynosVideoEncCommonParam *pCommonParam = NULL;
603 ExynosVideoEncH264Param *pH264Param = NULL;
604 ExynosVideoEncOps *pEncOps = NULL;
605
606 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pUseLTRFrame, sizeof(OMX_VIDEO_CONFIG_USELTRFRAME));
607 if (ret != OMX_ErrorNone)
608 goto EXIT;
609
610 if (pUseLTRFrame->nPortIndex != OUTPUT_PORT_INDEX) {
611 ret = OMX_ErrorBadPortIndex;
612 goto EXIT;
613 }
614
615 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
616 pEncParam = &pMFCH264Handle->encParam;
617 pCommonParam = &pEncParam->commonParam;
618 pH264Param = &pEncParam->codecParam.h264;
619 pEncOps = pMFCH264Handle->pEncOps;
620
621 /* TBD */
622 }
623 break;
624 case OMX_IndexSkypeConfigQP:
625 {
626 OMX_VIDEO_CONFIG_QP *pConfigQp = (OMX_VIDEO_CONFIG_QP *)pComponentConfigStructure;
627 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
628 ExynosVideoEncParam *pEncParam = NULL;
629 ExynosVideoEncCommonParam *pCommonParam = NULL;
630 ExynosVideoEncH264Param *pH264Param = NULL;
631 ExynosVideoEncOps *pEncOps = NULL;
632
633 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pConfigQp, sizeof(OMX_VIDEO_CONFIG_QP));
634 if (ret != OMX_ErrorNone)
635 goto EXIT;
636
637 if (pConfigQp->nPortIndex != OUTPUT_PORT_INDEX) {
638 ret = OMX_ErrorBadPortIndex;
639 goto EXIT;
640 }
641
642 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
643 pEncParam = &pMFCH264Handle->encParam;
644 pCommonParam = &pEncParam->commonParam;
645 pH264Param = &pEncParam->codecParam.h264;
646 pEncOps = pMFCH264Handle->pEncOps;
647
648 /* will remove */
649 pVideoEnc->quantization.nQpI = pConfigQp->nQP;
650 pVideoEnc->quantization.nQpP = pConfigQp->nQP;
651 pVideoEnc->quantization.nQpB = pConfigQp->nQP;
652// pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
653// pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
654// pH264Param->FrameQp_B = pVideoEnc->quantization.nQpB;
655
656 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : pConfigQp->nQP:%d", __FUNCTION__, pConfigQp->nQP);
657
658 /* TBD */
659 }
660 break;
661 case OMX_IndexSkypeConfigTemporalLayerCount:
662 {
663 OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *pTemporalLayerCount = (OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *)pComponentConfigStructure;
664 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
665 ExynosVideoEncOps *pEncOps = NULL;
666
667 int i = 0;
668 TemporalLayerShareBuffer TemporalSVC;
669
670 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pTemporalLayerCount, sizeof(OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT));
671 if (ret != OMX_ErrorNone)
672 goto EXIT;
673
674 if (pTemporalLayerCount->nPortIndex > OUTPUT_PORT_INDEX) {
675 ret = OMX_ErrorBadPortIndex;
676 goto EXIT;
677 }
678
679 if ((pH264Enc->hMFCH264Handle.bTemporalSVC == OMX_FALSE) ||
680 (pTemporalLayerCount->nTemporalLayerCount > OMX_VIDEO_ANDROID_MAXAVCTEMPORALLAYERS)) {
681 ret = OMX_ErrorBadParameter;
682 goto EXIT;
683 }
684
685 /* Temporal SVC */
686 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
687 pEncOps = pMFCH264Handle->pEncOps;
688
689 pH264Enc->TemporalSVC.nTemporalLayerCount = pTemporalLayerCount->nTemporalLayerCount | GENERAL_TSVC_ENABLE;
690 }
691 break;
692 case OMX_IndexSkypeConfigBasePid:
693 {
694 OMX_VIDEO_CONFIG_BASELAYERPID *pBaseLayerPid = (OMX_VIDEO_CONFIG_BASELAYERPID *)pComponentConfigStructure;
695 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
696 ExynosVideoEncParam *pEncParam = NULL;
697 ExynosVideoEncCommonParam *pCommonParam = NULL;
698 ExynosVideoEncH264Param *pH264Param = NULL;
699 ExynosVideoEncOps *pEncOps = NULL;
700
701 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pBaseLayerPid, sizeof(OMX_VIDEO_CONFIG_BASELAYERPID));
702 if (ret != OMX_ErrorNone)
703 goto EXIT;
704
705 if (pBaseLayerPid->nPortIndex > OUTPUT_PORT_INDEX) {
706 ret = OMX_ErrorBadPortIndex;
707 goto EXIT;
708 }
709
710 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
711 pEncParam = &pMFCH264Handle->encParam;
712 pCommonParam = &pEncParam->commonParam;
713 pH264Param = &pEncParam->codecParam.h264;
714 pEncOps = pMFCH264Handle->pEncOps;
715
716 pH264Enc->nBaseLayerPid = pBaseLayerPid->nPID;
717 }
718 break;
719 default:
720 ret = OMX_ErrorUnsupportedIndex;
721 break;
722 }
723
724EXIT:
725
726 FunctionOut();
727
728 return ret;
729}
730
731void Change_H264Enc_SkypeHDParam(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_PTR pDynamicConfigCMD)
732{
733 OMX_ERRORTYPE ret = OMX_ErrorNone;
734 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
735 EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
736 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
737 OMX_PTR pConfigData = NULL;
738 OMX_S32 nCmdIndex = 0;
739 ExynosVideoEncOps *pEncOps = NULL;
740 int nValue = 0;
741
742 int i;
743
744 FunctionIn();
745
746 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
747 pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
748 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
749 pEncOps = pMFCH264Handle->pEncOps;
750
751 if (pDynamicConfigCMD == NULL)
752 goto EXIT;
753
754 nCmdIndex = *(OMX_S32 *)pDynamicConfigCMD;
755 pConfigData = (OMX_PTR)((OMX_U8 *)pDynamicConfigCMD + sizeof(OMX_S32));
756
757 switch ((int)nCmdIndex) {
758 case OMX_IndexSkypeConfigMarkLTRFrame:
759 {
760 OMX_VIDEO_CONFIG_MARKLTRFRAME *pMarkLTRFrame = (OMX_VIDEO_CONFIG_MARKLTRFRAME *)pConfigData;
761 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
762 ExynosVideoEncParam *pEncParam = NULL;
763 ExynosVideoEncCommonParam *pCommonParam = NULL;
764 ExynosVideoEncH264Param *pH264Param = NULL;
765 ExynosVideoEncOps *pEncOps = NULL;
766
767 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pMarkLTRFrame, sizeof(OMX_VIDEO_CONFIG_MARKLTRFRAME));
768 if (ret != OMX_ErrorNone)
769 goto EXIT;
770
771 if (pMarkLTRFrame->nPortIndex != OUTPUT_PORT_INDEX) {
772 ret = OMX_ErrorBadPortIndex;
773 goto EXIT;
774 }
775
776 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
777 pEncParam = &pMFCH264Handle->encParam;
778 pCommonParam = &pEncParam->commonParam;
779 pH264Param = &pEncParam->codecParam.h264;
780 pEncOps = pMFCH264Handle->pEncOps;
781
782 /* TBD */
783 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pMarkLTRFrame->nLongTermFrmIdx: %d", pMarkLTRFrame->nLongTermFrmIdx + 1);
784 pEncOps->Set_MarkLTRFrame(pMFCH264Handle->hMFCHandle, pMarkLTRFrame->nLongTermFrmIdx + 1);
785 }
786 break;
787 case OMX_IndexSkypeConfigUseLTRFrame:
788 {
789 OMX_VIDEO_CONFIG_USELTRFRAME *pUseLTRFrame = (OMX_VIDEO_CONFIG_USELTRFRAME *)pConfigData;
790 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
791 ExynosVideoEncParam *pEncParam = NULL;
792 ExynosVideoEncCommonParam *pCommonParam = NULL;
793 ExynosVideoEncH264Param *pH264Param = NULL;
794 ExynosVideoEncOps *pEncOps = NULL;
795
796 OMX_S32 nUsedLTRFrameNum = 0;
797
798 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pUseLTRFrame, sizeof(OMX_VIDEO_CONFIG_USELTRFRAME));
799 if (ret != OMX_ErrorNone)
800 goto EXIT;
801
802 if (pUseLTRFrame->nPortIndex != OUTPUT_PORT_INDEX) {
803 ret = OMX_ErrorBadPortIndex;
804 goto EXIT;
805 }
806
807 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
808 pEncParam = &pMFCH264Handle->encParam;
809 pCommonParam = &pEncParam->commonParam;
810 pH264Param = &pEncParam->codecParam.h264;
811 pEncOps = pMFCH264Handle->pEncOps;
812
813 nUsedLTRFrameNum = pUseLTRFrame->nUsedLTRFrameBM;
814 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pUseLTRFrame->nUsedLTRFrameBM: %d, nUsedLTRFrameNum = %d", pUseLTRFrame->nUsedLTRFrameBM, nUsedLTRFrameNum);
815 if (nUsedLTRFrameNum < 0) {
816 ret = OMX_ErrorBadParameter;
817 goto EXIT;
818 }
819
820 pEncOps->Set_UsedLTRFrame(pMFCH264Handle->hMFCHandle, nUsedLTRFrameNum);
821 }
822 break;
823 case OMX_IndexSkypeConfigQP:
824 {
825 OMX_VIDEO_CONFIG_QP *pConfigQp = (OMX_VIDEO_CONFIG_QP *)pConfigData;
826 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
827 ExynosVideoEncParam *pEncParam = NULL;
828 ExynosVideoEncCommonParam *pCommonParam = NULL;
829 ExynosVideoEncH264Param *pH264Param = NULL;
830 ExynosVideoEncOps *pEncOps = NULL;
831
832 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pConfigQp, sizeof(OMX_VIDEO_CONFIG_QP));
833 if (ret != OMX_ErrorNone)
834 goto EXIT;
835
836 if (pConfigQp->nPortIndex != OUTPUT_PORT_INDEX) {
837 ret = OMX_ErrorBadPortIndex;
838 goto EXIT;
839 }
840
841 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
842 pEncParam = &pMFCH264Handle->encParam;
843 pCommonParam = &pEncParam->commonParam;
844 pH264Param = &pEncParam->codecParam.h264;
845 pEncOps = pMFCH264Handle->pEncOps;
846
847 /* will remove */
848 pVideoEnc->quantization.nQpI = pConfigQp->nQP;
849 pVideoEnc->quantization.nQpP = pConfigQp->nQP;
850 pVideoEnc->quantization.nQpB = pConfigQp->nQP;
851// pCommonParam->FrameQp = pVideoEnc->quantization.nQpI;
852// pCommonParam->FrameQp_P = pVideoEnc->quantization.nQpP;
853// pH264Param->FrameQp_B = pVideoEnc->quantization.nQpB;
854
855 /* TBD */
856 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pConfigQp->nQP: %d", pConfigQp->nQP);
857 pEncOps->Set_DynamicQpControl(pMFCH264Handle->hMFCHandle, pConfigQp->nQP);
858 }
859 break;
860 case OMX_IndexSkypeConfigTemporalLayerCount:
861 {
862 OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *pTemporalLayerCount = (OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT *)pConfigData;
863 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
864 ExynosVideoEncOps *pEncOps = NULL;
865
866 int i = 0;
867 TemporalLayerShareBuffer TemporalSVC;
868
869 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pTemporalLayerCount, sizeof(OMX_VIDEO_CONFIG_TEMPORALLAYERCOUNT));
870 if (ret != OMX_ErrorNone)
871 goto EXIT;
872
873 if (pTemporalLayerCount->nPortIndex != OUTPUT_PORT_INDEX) {
874 ret = OMX_ErrorBadPortIndex;
875 goto EXIT;
876 }
877
878 if ((pH264Enc->hMFCH264Handle.bTemporalSVC == OMX_FALSE) ||
879 (pTemporalLayerCount->nTemporalLayerCount > OMX_VIDEO_ANDROID_MAXAVCTEMPORALLAYERS)) {
880 ret = OMX_ErrorBadParameter;
881 goto EXIT;
882 }
883
884 /* Temporal SVC */
885 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
886 pEncOps = pMFCH264Handle->pEncOps;
887
888 Exynos_OSAL_Memset(&TemporalSVC, 0, sizeof(TemporalLayerShareBuffer));
889 TemporalSVC.nTemporalLayerCount = (unsigned int)pTemporalLayerCount->nTemporalLayerCount | GENERAL_TSVC_ENABLE;
890 for (i = 0; i < OMX_VIDEO_ANDROID_MAXAVCTEMPORALLAYERS; i++)
891 TemporalSVC.nTemporalLayerBitrateRatio[i] = 0;
892
893 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "TemporalSVC.nTemporalLayerCount: %d", TemporalSVC.nTemporalLayerCount & (~GENERAL_TSVC_ENABLE));
894 pEncOps->Set_LayerChange(pMFCH264Handle->hMFCHandle, TemporalSVC);
895 }
896 break;
897 case OMX_IndexSkypeConfigBasePid:
898 {
899 OMX_VIDEO_CONFIG_BASELAYERPID *pBaseLayerPid = (OMX_VIDEO_CONFIG_BASELAYERPID *)pConfigData;
900 EXYNOS_MFC_H264ENC_HANDLE *pMFCH264Handle = NULL;
901 ExynosVideoEncParam *pEncParam = NULL;
902 ExynosVideoEncCommonParam *pCommonParam = NULL;
903 ExynosVideoEncH264Param *pH264Param = NULL;
904 ExynosVideoEncOps *pEncOps = NULL;
905
906 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pBaseLayerPid, sizeof(OMX_VIDEO_CONFIG_BASELAYERPID));
907 if (ret != OMX_ErrorNone)
908 goto EXIT;
909
910 if (pBaseLayerPid->nPortIndex != OUTPUT_PORT_INDEX) {
911 ret = OMX_ErrorBadPortIndex;
912 goto EXIT;
913 }
914
915 pMFCH264Handle = &pH264Enc->hMFCH264Handle;
916 pEncParam = &pMFCH264Handle->encParam;
917 pCommonParam = &pEncParam->commonParam;
918 pH264Param = &pEncParam->codecParam.h264;
919 pEncOps = pMFCH264Handle->pEncOps;
920
921 /* TBD */
922 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pBaseLayerPid->nPID: %d", pBaseLayerPid->nPID);
923 pEncOps->Set_BasePID(pMFCH264Handle->hMFCHandle, pBaseLayerPid->nPID);
924 }
925 break;
926 default:
927 break;
928 }
929
930EXIT:
931
932 FunctionOut();
933
934 return;
935}
936#endif
937
938
939/* DECODE_ONLY */
940#ifdef BUILD_DEC
941/* video dec */
942OMX_ERRORTYPE Exynos_H264Dec_GetExtensionIndex_SkypeHD(
943 OMX_IN OMX_HANDLETYPE hComponent,
944 OMX_IN OMX_STRING cParameterName,
945 OMX_OUT OMX_INDEXTYPE *pIndexType)
946{
947 OMX_ERRORTYPE ret = OMX_ErrorNone;
948 OMX_COMPONENTTYPE *pOMXComponent = NULL;
949 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
950
951 FunctionIn();
952
953 if (hComponent == NULL) {
954 ret = OMX_ErrorBadParameter;
955 goto EXIT;
956 }
957 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
958 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
959 if (ret != OMX_ErrorNone) {
960 goto EXIT;
961 }
962 if (pOMXComponent->pComponentPrivate == NULL) {
963 ret = OMX_ErrorBadParameter;
964 goto EXIT;
965 }
966 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
967 if ((cParameterName == NULL) || (pIndexType == NULL)) {
968 ret = OMX_ErrorBadParameter;
969 goto EXIT;
970 }
971 if (pExynosComponent->currentState == OMX_StateInvalid) {
972 ret = OMX_ErrorInvalidState;
973 goto EXIT;
974 }
975
976 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_DRIVERVER) == 0) {
977 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamDriverVersion;
978 ret = OMX_ErrorNone;
979 goto EXIT;
980 }
981
982 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_DECODERSETTING) == 0) {
983 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamDecoderSetting;
984 ret = OMX_ErrorNone;
985 goto EXIT;
986 }
987
988 if (Exynos_OSAL_Strcmp(cParameterName, OMX_MS_SKYPE_PARAM_DECODERCAP) == 0) {
989 *pIndexType = (OMX_INDEXTYPE) OMX_IndexSkypeParamDecoderCapability;
990 ret = OMX_ErrorNone;
991 goto EXIT;
992 }
993
994 ret = OMX_ErrorUnsupportedIndex;
995
996EXIT:
997 FunctionOut();
998
999 return ret;
1000}
1001
1002OMX_ERRORTYPE Exynos_H264Dec_GetParameter_SkypeHD(
1003 OMX_IN OMX_HANDLETYPE hComponent,
1004 OMX_IN OMX_INDEXTYPE nParamIndex,
1005 OMX_INOUT OMX_PTR pComponentParameterStructure)
1006{
1007 OMX_ERRORTYPE ret = OMX_ErrorNone;
1008 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1009 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1010 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
1011 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1012
1013 FunctionIn();
1014
1015 if ((hComponent == NULL) || (pComponentParameterStructure == NULL)) {
1016 ret = OMX_ErrorBadParameter;
1017 goto EXIT;
1018 }
1019 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1020 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1021 if (ret != OMX_ErrorNone) {
1022 goto EXIT;
1023 }
1024 if (pOMXComponent->pComponentPrivate == NULL) {
1025 ret = OMX_ErrorBadParameter;
1026 goto EXIT;
1027 }
1028
1029 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1030 if (pExynosComponent->currentState == OMX_StateInvalid) {
1031 ret = OMX_ErrorInvalidState;
1032 goto EXIT;
1033 }
1034
1035 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1036 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1037
1038 switch ((int)nParamIndex) {
1039 case OMX_IndexSkypeParamDriverVersion:
1040 {
1041 OMX_VIDEO_PARAM_DRIVERVER *pDriverVer = (OMX_VIDEO_PARAM_DRIVERVER *)pComponentParameterStructure;
1042
1043 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pDriverVer, sizeof(OMX_VIDEO_PARAM_DRIVERVER));
1044 if (ret != OMX_ErrorNone)
1045 goto EXIT;
1046
1047 if (pDriverVer->nPortIndex > OUTPUT_PORT_INDEX) {
1048 ret = OMX_ErrorBadPortIndex;
1049 goto EXIT;
1050 }
1051
1052 pDriverVer->nDriverVersion = (OMX_U64)(pH264Dec->hMFCH264Handle.videoInstInfo.SwVersion);
1053 }
1054 break;
1055 case OMX_IndexSkypeParamDecoderCapability:
1056 {
1057 OMX_VIDEO_PARAM_DECODERCAP *pDecoderCap = (OMX_VIDEO_PARAM_DECODERCAP *)pComponentParameterStructure;
1058 OMX_VIDEO_DECODERCAP *pstDecCap = NULL;
1059
1060 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pDecoderCap, sizeof(OMX_VIDEO_PARAM_DECODERCAP));
1061 if (ret != OMX_ErrorNone)
1062 goto EXIT;
1063
1064 if (pDecoderCap->nPortIndex > OUTPUT_PORT_INDEX) {
1065 ret = OMX_ErrorBadPortIndex;
1066 goto EXIT;
1067 }
1068
1069 pstDecCap = &(pDecoderCap->stDecoderCap);
1070
1071 /* TBD */
1072 pstDecCap->bLowLatency = OMX_TRUE;
1073 pstDecCap->nMaxFrameWidth = MAX_FRAME_WIDTH;
1074 pstDecCap->nMaxFrameHeight = MAX_FRAME_HEIGHT;
1075 pstDecCap->nMaxInstances = RESOURCE_VIDEO_DEC;
1076 pstDecCap->nMaxLevel = OMX_VIDEO_AVCLevel42;
1077 pstDecCap->nMaxMacroblockProcessingRate = DEC_BLOCKS_PER_SECOND;
1078 }
1079 break;
1080 case OMX_IndexSkypeParamDecoderSetting:
1081 {
1082 OMX_VIDEO_PARAM_DECODERSETTING *pDecoderSetting = (OMX_VIDEO_PARAM_DECODERSETTING *)pComponentParameterStructure;
1083 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1084 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1085 OMX_VIDEO_DECODERPARAMS *pstDecParam = NULL;
1086
1087 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pDecoderSetting, sizeof(OMX_VIDEO_PARAM_DECODERSETTING));
1088 if (ret != OMX_ErrorNone)
1089 goto EXIT;
1090
1091 if (pDecoderSetting->nPortIndex > OUTPUT_PORT_INDEX) {
1092 ret = OMX_ErrorBadPortIndex;
1093 goto EXIT;
1094 }
1095
1096 pstDecParam = &(pDecoderSetting->stDecParam);
1097 pstDecParam->bLowLatency = pH264Dec->bLowLatency;
1098 }
1099 break;
1100 default:
1101 ret = OMX_ErrorUnsupportedIndex;
1102 break;
1103 }
1104
1105EXIT:
1106
1107 FunctionOut();
1108
1109 return ret;
1110}
1111
1112OMX_ERRORTYPE Exynos_H264Dec_SetParameter_SkypeHD(
1113 OMX_IN OMX_HANDLETYPE hComponent,
1114 OMX_IN OMX_INDEXTYPE nIndex,
1115 OMX_IN OMX_PTR pComponentParameterStructure)
1116{
1117 OMX_ERRORTYPE ret = OMX_ErrorNone;
1118 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1119 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1120 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
1121 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1122
1123 FunctionIn();
1124
1125 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1126 ret = OMX_ErrorBadParameter;
1127 goto EXIT;
1128 }
1129 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1130 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1131 if (ret != OMX_ErrorNone) {
1132 goto EXIT;
1133 }
1134 if (pOMXComponent->pComponentPrivate == NULL) {
1135 ret = OMX_ErrorBadParameter;
1136 goto EXIT;
1137 }
1138
1139 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1140 if (pExynosComponent->currentState == OMX_StateInvalid) {
1141 ret = OMX_ErrorInvalidState;
1142 goto EXIT;
1143 }
1144
1145 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1146 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1147
1148 switch ((int)nIndex) {
1149 case OMX_IndexSkypeParamDecoderSetting:
1150 {
1151 OMX_VIDEO_PARAM_DECODERSETTING *pDecoderSetting = (OMX_VIDEO_PARAM_DECODERSETTING *)pComponentParameterStructure;
1152 OMX_VIDEO_DECODERPARAMS *pstDecParam = NULL;
1153
1154 ret = Exynos_OMX_Check_SizeVersion_SkypeHD(pDecoderSetting, sizeof(OMX_VIDEO_PARAM_DECODERSETTING));
1155 if (ret != OMX_ErrorNone)
1156 goto EXIT;
1157
1158 if (pDecoderSetting->nPortIndex > OUTPUT_PORT_INDEX) {
1159 ret = OMX_ErrorBadPortIndex;
1160 goto EXIT;
1161 }
1162
1163 pstDecParam = &(pDecoderSetting->stDecParam);
1164 pH264Dec->bLowLatency = pstDecParam->bLowLatency;
1165 }
1166 break;
1167 default:
1168 ret = OMX_ErrorUnsupportedIndex;
1169 break;
1170
1171 }
1172
1173EXIT:
1174
1175 FunctionOut();
1176
1177 return ret;
1178}
1179#endif
1180
1181#ifdef __cplusplus
1182}
1183#endif