1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
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
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #include "pv_omxcomponent.h"
19 #include "pv_omxdefs.h"
20 #include "oscl_types.h"
21
22 #if PROXY_INTERFACE
23 #include "omx_proxy_interface.h"
24 #endif
25
26
OmxComponentBase()27 OmxComponentBase::OmxComponentBase() :
28 OsclActiveObject(OsclActiveObject::EPriorityNominal, "OMXComponent")
29 {
30 //Flag to call BufferMgmtFunction in the Run() when the component state is executing
31 iBufferExecuteFlag = OMX_FALSE;
32 ipAppPriv = NULL;
33
34 iLogger = PVLogger::GetLoggerObject("OmxComponentBase");
35 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : constructed"));
36
37 ipCallbacks = NULL;
38 iCallbackData = NULL;
39 iState = OMX_StateLoaded;
40
41 ipCoreDescriptor = NULL;
42 iNumInputBuffer = 0;
43
44 ipFrameDecodeBuffer = NULL;
45 iPartialFrameAssembly = OMX_FALSE;
46 iIsInputBufferEnded = OMX_TRUE;
47 iEndofStream = OMX_FALSE;
48 ipTempInputBuffer = NULL;
49 iTempInputBufferLength = 0;
50
51 ipTargetComponent = NULL;
52 iTargetMarkData = NULL;
53 ipTempTargetComponent = NULL;
54 iTempTargetMarkData = NULL;
55
56 iNewInBufferRequired = OMX_TRUE;
57 iNewOutBufRequired = OMX_TRUE;
58
59 iTempConsumedLength = 0;
60 iOutBufferCount = 0;
61 iCodecReady = OMX_FALSE;
62 ipInputCurrBuffer = NULL;
63 iInputCurrBufferSize = 0;
64 iInputCurrLength = 0;
65 iFrameCount = 0;
66 iStateTransitionFlag = OMX_FALSE;
67 iEndOfFrameFlag = OMX_FALSE;
68 ipInputBuffer = NULL;
69 ipOutputBuffer = NULL;
70
71 iOutputFrameLength = 0;
72 iNumPorts = 0;
73 iCompressedFormatPortNum = OMX_PORT_INPUTPORT_INDEX;
74 ipComponentProxy = NULL;
75
76 ipPorts = NULL;
77
78 //Indicate whether component has been already initialized */
79 iIsInit = OMX_FALSE;
80
81 iGroupPriority = 0;
82 iGroupID = 0;
83
84 iComponentRoleFlag = OMX_FALSE;
85 ipMark = NULL;
86
87 iEosProcessing = OMX_FALSE;
88 iFirstFragment = OMX_FALSE;
89 iFrameTimestamp = 0;
90 iSamplesPerFrame = 0;
91 iSilenceInsertionInProgress = OMX_FALSE;
92 iSilenceFramesNeeded = 0;
93 iIsFirstOutputFrame = OMX_TRUE;
94 iInputBufferRemainingBytes = 0;
95 iResizePending = OMX_FALSE;
96
97 ipTempOutBufferForPortReconfig = NULL;
98 iSizeOutBufferForPortReconfig = 0;
99 iSendOutBufferAfterPortReconfigFlag = OMX_FALSE;
100 iTimestampOutBufferForPortReconfig = (OMX_TICKS)0;
101 iOutputMicroSecPerFrame = (OMX_TICKS)0;
102 }
103
104
ConstructBaseComponent(OMX_PTR pAppData)105 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::ConstructBaseComponent(OMX_PTR pAppData)
106 {
107 OSCL_UNUSED_ARG(pAppData);
108 OMX_U32 ii, jj;
109
110 if (iNumPorts)
111 {
112 if (ipPorts)
113 {
114 oscl_free(ipPorts);
115 ipPorts = NULL;
116 }
117
118 ipPorts = (ComponentPortType**) oscl_calloc(iNumPorts, sizeof(ComponentPortType*));
119 if (!ipPorts)
120 {
121 return OMX_ErrorInsufficientResources;
122 }
123
124 for (ii = 0; ii < iNumPorts; ii++)
125 {
126 ipPorts[ii] = (ComponentPortType*) oscl_calloc(1, sizeof(ComponentPortType));
127 if (!ipPorts[ii])
128 {
129 return OMX_ErrorInsufficientResources;
130 }
131
132 ipPorts[ii]->TransientState = OMX_StateMax;
133 SetHeader(&ipPorts[ii]->PortParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
134 ipPorts[ii]->PortParam.nPortIndex = ii;
135
136 /** Allocate and initialize buffer Queue */
137 ipPorts[ii]->pBufferQueue = (QueueType*) oscl_malloc(sizeof(QueueType));
138
139 if (NULL == ipPorts[ii]->pBufferQueue)
140 {
141 return OMX_ErrorInsufficientResources;
142 }
143
144 if (OMX_ErrorNone != QueueInit(ipPorts[ii]->pBufferQueue))
145 {
146 return OMX_ErrorInsufficientResources;
147 }
148
149 for (jj = 0; jj < OMX_PORT_NUMBER_FORMATS_SUPPORTED; jj++)
150 {
151 oscl_memset(&ipPorts[ii]->VideoParam[jj], 0, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
152 }
153 }
154
155 SetPortFlushFlag(iNumPorts, -1, OMX_FALSE);
156 SetNumBufferFlush(iNumPorts, -1, OMX_FALSE);
157 }
158
159
160 iCodecReady = OMX_FALSE;
161 ipCallbacks = NULL;
162 iCallbackData = NULL;
163 iState = OMX_StateLoaded;
164 ipTempInputBuffer = NULL;
165 iTempInputBufferLength = 0;
166 iNumInputBuffer = 0;
167 iPartialFrameAssembly = OMX_FALSE;
168 iEndofStream = OMX_FALSE;
169 iIsInputBufferEnded = OMX_TRUE;
170 iNewOutBufRequired = OMX_TRUE;
171 iEosProcessing = OMX_FALSE;
172 iRepositionFlag = OMX_FALSE;
173 iIsFirstOutputFrame = OMX_TRUE;
174 iMarkPropagate = OMX_FALSE;
175 ipTempOutBufferForPortReconfig = NULL;
176 iSendOutBufferAfterPortReconfigFlag = OMX_FALSE;
177 iSizeOutBufferForPortReconfig = 0;
178 iComponentRoleFlag = OMX_FALSE;
179
180
181 /* Initialize the asynchronous command Queue */
182 if (ipCoreDescriptor)
183 {
184 oscl_free(ipCoreDescriptor);
185 ipCoreDescriptor = NULL;
186 }
187
188 ipCoreDescriptor = (CoreDescriptorType*) oscl_malloc(sizeof(CoreDescriptorType));
189 if (NULL == ipCoreDescriptor)
190 {
191 return OMX_ErrorInsufficientResources;
192 }
193
194 ipCoreDescriptor->pMessageQueue = NULL;
195 ipCoreDescriptor->pMessageQueue = (QueueType*) oscl_malloc(sizeof(QueueType));
196 if (NULL == ipCoreDescriptor->pMessageQueue)
197 {
198 return OMX_ErrorInsufficientResources;
199 }
200
201 if (OMX_ErrorNone != QueueInit(ipCoreDescriptor->pMessageQueue))
202 {
203 return OMX_ErrorInsufficientResources;
204 }
205
206 /** Default parameters setting */
207 iIsInit = OMX_FALSE;
208 iGroupPriority = 0;
209 iGroupID = 0;
210 ipMark = NULL;
211
212 SetHeader(&iPortTypesParam, sizeof(OMX_PORT_PARAM_TYPE));
213
214 iOutBufferCount = 0;
215 iStateTransitionFlag = OMX_FALSE;
216 iEndOfFrameFlag = OMX_FALSE;
217 iFirstFragment = OMX_FALSE;
218
219 //Will be used in case of partial frame assembly
220 ipInputCurrBuffer = NULL;
221 iInputCurrBufferSize = 0;
222 ipAppPriv->CompHandle = &iOmxComponent;
223
224 return OMX_ErrorNone;
225 }
226
227
DestroyBaseComponent()228 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::DestroyBaseComponent()
229 {
230 OMX_U32 ii;
231
232 /*Deinitialize and free ports semaphores and Queue*/
233 for (ii = 0; ii < iNumPorts; ii++)
234 {
235 if (NULL != ipPorts[ii]->pBufferQueue)
236 {
237 QueueDeinit(ipPorts[ii]->pBufferQueue);
238 oscl_free(ipPorts[ii]->pBufferQueue);
239 ipPorts[ii]->pBufferQueue = NULL;
240 }
241 /*Free port*/
242 if (NULL != ipPorts[ii])
243 {
244 oscl_free(ipPorts[ii]);
245 ipPorts[ii] = NULL;
246 }
247 }
248
249 if (ipPorts)
250 {
251 oscl_free(ipPorts);
252 ipPorts = NULL;
253 }
254
255 iState = OMX_StateLoaded;
256
257 //Free the temp output buffer
258 if (ipTempOutBufferForPortReconfig)
259 {
260 oscl_free(ipTempOutBufferForPortReconfig);
261 ipTempOutBufferForPortReconfig = NULL;
262 iSizeOutBufferForPortReconfig = 0;
263 }
264
265 if (ipInputCurrBuffer)
266 {
267 oscl_free(ipInputCurrBuffer);
268 ipInputCurrBuffer = NULL;
269 iInputCurrBufferSize = 0;
270 }
271
272 if (ipTempInputBuffer)
273 {
274 oscl_free(ipTempInputBuffer);
275 ipTempInputBuffer = NULL;
276 }
277
278 if (NULL != ipCoreDescriptor)
279 {
280
281 if (NULL != ipCoreDescriptor->pMessageQueue)
282 {
283 /* De-initialize the asynchronous command queue */
284 QueueDeinit(ipCoreDescriptor->pMessageQueue);
285 oscl_free(ipCoreDescriptor->pMessageQueue);
286 ipCoreDescriptor->pMessageQueue = NULL;
287 }
288
289 oscl_free(ipCoreDescriptor);
290 ipCoreDescriptor = NULL;
291 }
292
293 return OMX_ErrorNone;
294 }
295
296
297 /*********************
298 *
299 * Component verfication routines
300 *
301 **********************/
302
SetHeader(OMX_PTR aHeader,OMX_U32 aSize)303 OSCL_EXPORT_REF void OmxComponentBase::SetHeader(OMX_PTR aHeader, OMX_U32 aSize)
304 {
305 OMX_VERSIONTYPE* pVersion = (OMX_VERSIONTYPE*)((OMX_STRING) aHeader + sizeof(OMX_U32));
306 *((OMX_U32*) aHeader) = aSize;
307
308 pVersion->s.nVersionMajor = SPECVERSIONMAJOR;
309 pVersion->s.nVersionMinor = SPECVERSIONMINOR;
310 pVersion->s.nRevision = SPECREVISION;
311 pVersion->s.nStep = SPECSTEP;
312 }
313
314
CheckHeader(OMX_PTR aHeader,OMX_U32 aSize)315 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::CheckHeader(OMX_PTR aHeader, OMX_U32 aSize)
316 {
317 OMX_VERSIONTYPE* pVersion = (OMX_VERSIONTYPE*)((OMX_STRING) aHeader + sizeof(OMX_U32));
318
319 if (NULL == aHeader)
320 {
321 return OMX_ErrorBadParameter;
322 }
323
324 if (*((OMX_U32*) aHeader) != aSize)
325 {
326 return OMX_ErrorBadParameter;
327 }
328
329 if (pVersion->s.nVersionMajor != SPECVERSIONMAJOR ||
330 pVersion->s.nVersionMinor != SPECVERSIONMINOR ||
331 pVersion->s.nRevision != SPECREVISION ||
332 pVersion->s.nStep != SPECSTEP)
333 {
334 return OMX_ErrorVersionMismatch;
335 }
336
337 return OMX_ErrorNone;
338 }
339
340
341 /**
342 * This function verify component state and structure header
343 */
ParameterSanityCheck(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pStructure,OMX_IN size_t size)344 OMX_ERRORTYPE OmxComponentBase::ParameterSanityCheck(
345 OMX_IN OMX_HANDLETYPE hComponent,
346 OMX_IN OMX_U32 nPortIndex,
347 OMX_IN OMX_PTR pStructure,
348 OMX_IN size_t size)
349 {
350 OSCL_UNUSED_ARG(hComponent);
351 if (iState != OMX_StateLoaded &&
352 iState != OMX_StateWaitForResources)
353 {
354 return OMX_ErrorIncorrectStateOperation;
355 }
356
357 if (nPortIndex >= iNumPorts)
358 {
359 return OMX_ErrorBadPortIndex;
360 }
361
362 return CheckHeader(pStructure, size);
363 }
364
365 /**
366 * Set/Reset Port Flush Flag
367 */
SetPortFlushFlag(OMX_S32 NumPorts,OMX_S32 index,OMX_BOOL value)368 void OmxComponentBase::SetPortFlushFlag(OMX_S32 NumPorts, OMX_S32 index, OMX_BOOL value)
369 {
370 OMX_S32 ii;
371
372 if (-1 == index)
373 {
374 for (ii = 0; ii < NumPorts; ii++)
375 {
376 ipPorts[ii]->IsPortFlushed = value;
377 }
378 }
379 else
380 {
381 ipPorts[index]->IsPortFlushed = value;
382 }
383
384 }
385
386 /**
387 * Set Number of Buffer Flushed with the value Specified
388 */
SetNumBufferFlush(OMX_S32 NumPorts,OMX_S32 index,OMX_S32 value)389 void OmxComponentBase::SetNumBufferFlush(OMX_S32 NumPorts, OMX_S32 index, OMX_S32 value)
390 {
391 OMX_S32 ii;
392
393 if (-1 == index)
394 {
395 // For all ComponentPort
396 for (ii = 0; ii < NumPorts; ii++)
397 {
398 ipPorts[ii]->NumBufferFlushed = value;
399 }
400 }
401 else
402 {
403 ipPorts[index]->NumBufferFlushed = value;
404 }
405 }
406
407
ParseFullAVCFramesIntoNALs(OMX_BUFFERHEADERTYPE * aInputBuffer)408 OSCL_EXPORT_REF OMX_BOOL OmxComponentBase::ParseFullAVCFramesIntoNALs(OMX_BUFFERHEADERTYPE* aInputBuffer)
409 {
410 OSCL_UNUSED_ARG(aInputBuffer);
411
412 // we should never arrive here if this is not an AVC component, since iOMXComponentUsesFullAVCFrames (which is tested before calling this function)
413 // should only be set for an AVC component
414
415 OSCL_ASSERT(OMX_FALSE);
416
417 return OMX_FALSE;
418 }
419
420 /** This function assembles multiple input buffers into
421 * one frame with the marker flag OMX_BUFFERFLAG_ENDOFFRAME set
422 */
AssemblePartialFrames(OMX_BUFFERHEADERTYPE * aInputBuffer)423 OMX_BOOL OmxComponentBase::AssemblePartialFrames(OMX_BUFFERHEADERTYPE* aInputBuffer)
424 {
425 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames IN"));
426
427 QueueType* pInputQueue = ipPorts[OMX_PORT_INPUTPORT_INDEX]->pBufferQueue;
428
429 ComponentPortType* pInPort = ipPorts[OMX_PORT_INPUTPORT_INDEX];
430 OMX_U32 BytesToCopy = 0;
431
432 ipInputBuffer = aInputBuffer;
433
434 if (!iPartialFrameAssembly)
435 {
436 if (iNumInputBuffer > 0)
437 {
438 if (ipInputBuffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME)
439 {
440 iInputCurrLength = ipInputBuffer->nFilledLen;
441
442 //Only applicable for H.264 component
443 #ifdef INSERT_NAL_START_CODE
444 // this is the case of 1 full NAL in 1 buffer
445 // if start codes are inserted, skip the start code
446 iInputCurrLength = ipInputBuffer->nFilledLen - 4;
447 ipInputBuffer->nOffset += 4;
448 #endif
449 ipFrameDecodeBuffer = ipInputBuffer->pBuffer + ipInputBuffer->nOffset;
450 //capture the timestamp to be send to the corresponding output buffer
451 iFrameTimestamp = ipInputBuffer->nTimeStamp;
452 }
453 else
454 {
455 iInputCurrLength = 0;
456 iPartialFrameAssembly = OMX_TRUE;
457 iFirstFragment = OMX_TRUE;
458 iFrameTimestamp = ipInputBuffer->nTimeStamp;
459 ipFrameDecodeBuffer = ipInputCurrBuffer;
460 }
461
462 }
463 else
464 {
465 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames ERROR"));
466 return OMX_FALSE;
467 }
468
469 }
470
471 //Assembling of partial frame will be done based on OMX_BUFFERFLAG_ENDOFFRAME flag marked
472 if (iPartialFrameAssembly)
473 {
474 while (iNumInputBuffer > 0)
475 {
476 if (OMX_FALSE == iFirstFragment)
477 {
478 /* If the timestamp of curr fragment doesn't match with previous,
479 * discard the previous fragments & start reconstructing from new
480 */
481 if (iFrameTimestamp != ipInputBuffer->nTimeStamp)
482 {
483 iInputCurrLength = 0;
484 iPartialFrameAssembly = OMX_TRUE;
485 iFirstFragment = OMX_TRUE;
486 iFrameTimestamp = ipInputBuffer->nTimeStamp;
487 ipFrameDecodeBuffer = ipInputCurrBuffer;
488
489 //Send a stream corrupt callback
490 OMX_COMPONENTTYPE *pHandle = &iOmxComponent;
491 (*(ipCallbacks->EventHandler))
492 (pHandle,
493 iCallbackData,
494 OMX_EventError,
495 OMX_ErrorStreamCorrupt,
496 0,
497 NULL);
498 }
499 }
500
501 #ifdef INSERT_NAL_START_CODE
502 else
503 {
504 // this is the case of a partial NAL in 1 buffer
505 // this is the first fragment of a nal
506
507 // if start codes are inserted, skip the start code
508 ipInputBuffer->nFilledLen -= 4;
509 ipInputBuffer->nOffset += 4;
510 }
511 #endif
512
513 if ((ipInputBuffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) != 0)
514 {
515 break;
516 }
517
518 // check if the buffer size can take the new piece, or it needs to expand
519 BytesToCopy = ipInputBuffer->nFilledLen;
520
521 if (iInputCurrBufferSize < (iInputCurrLength + BytesToCopy))
522 {
523 // allocate new partial frame buffer
524 OMX_U8* pTempNewBuffer = NULL;
525 pTempNewBuffer = (OMX_U8*) oscl_malloc(sizeof(OMX_U8) * (iInputCurrLength + BytesToCopy));
526
527 // in the event that new buffer cannot be allocated
528 if (NULL == pTempNewBuffer)
529 {
530 // copy into what space is available, and let the decoder complain
531 BytesToCopy = iInputCurrLength - iInputCurrBufferSize;
532 }
533 else
534 {
535
536 // copy contents of the old buffer into the new one
537 oscl_memcpy(pTempNewBuffer, ipInputCurrBuffer, iInputCurrBufferSize);
538 // free the old buffer
539 if (ipInputCurrBuffer)
540 {
541 oscl_free(ipInputCurrBuffer);
542 }
543 // assign new one
544 ipInputCurrBuffer = pTempNewBuffer;
545 iInputCurrBufferSize = (iInputCurrLength + BytesToCopy);
546 ipFrameDecodeBuffer = ipInputCurrBuffer + iInputCurrLength;
547 }
548 }
549
550 iInputCurrLength += BytesToCopy;
551 oscl_memcpy(ipFrameDecodeBuffer, (ipInputBuffer->pBuffer + ipInputBuffer->nOffset), BytesToCopy); // copy buffer data
552 ipFrameDecodeBuffer += BytesToCopy; // move the ptr
553
554 ipInputBuffer->nFilledLen = 0;
555
556 ReturnInputBuffer(ipInputBuffer, pInPort);
557 ipInputBuffer = NULL;
558
559 iFirstFragment = OMX_FALSE;
560
561 if (iNumInputBuffer > 0)
562 {
563 ipInputBuffer = (OMX_BUFFERHEADERTYPE*) DeQueue(pInputQueue);
564 if (NULL == ipInputBuffer)
565 {
566 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames ERROR DeQueue() returned NULL"));
567 return OMX_FALSE;
568 }
569
570 if (ipInputBuffer->nFlags & OMX_BUFFERFLAG_EOS)
571 {
572 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames EndOfStream arrived"));
573 iEndofStream = OMX_TRUE;
574 }
575 }
576 }
577
578 // if we broke out of the while loop because of lack of buffers, then return and wait for more input buffers
579 if (0 == iNumInputBuffer)
580 {
581 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames OUT"));
582 return OMX_FALSE;
583 }
584 else
585 {
586 // we have found the buffer that is the last piece of the frame.
587 // Copy the buffer, but do not release it yet (this will be done after decoding for consistency)
588
589 BytesToCopy = ipInputBuffer->nFilledLen;
590 // check if the buffer size can take the new piece, or it needs to expand
591 if (iInputCurrBufferSize < (iInputCurrLength + BytesToCopy))
592 {
593 // allocate new partial frame buffer
594 OMX_U8* pTempNewBuffer = NULL;
595 pTempNewBuffer = (OMX_U8*) oscl_malloc(sizeof(OMX_U8) * (iInputCurrLength + BytesToCopy));
596
597 // if you cannot allocate new buffer, just copy what data you can
598 if (NULL == pTempNewBuffer)
599 {
600 BytesToCopy = iInputCurrBufferSize - iInputCurrLength;
601 }
602 else
603 {
604
605 // copy contents of the old one into new one
606 oscl_memcpy(pTempNewBuffer, ipInputCurrBuffer, iInputCurrBufferSize);
607 // free the old buffer
608 if (ipInputCurrBuffer)
609 {
610 oscl_free(ipInputCurrBuffer);
611 }
612 // assign new one
613 ipInputCurrBuffer = pTempNewBuffer;
614 iInputCurrBufferSize = (iInputCurrLength + BytesToCopy);
615 ipFrameDecodeBuffer = ipInputCurrBuffer + iInputCurrLength;
616 }
617 }
618
619 iInputCurrLength += BytesToCopy;
620 oscl_memcpy(ipFrameDecodeBuffer, (ipInputBuffer->pBuffer + ipInputBuffer->nOffset), BytesToCopy); // copy buffer data
621 ipFrameDecodeBuffer += BytesToCopy; // move the ptr
622
623 ipFrameDecodeBuffer = ipInputCurrBuffer; // reset the pointer back to beginning of assembly buffer
624 iPartialFrameAssembly = OMX_FALSE; // we have finished with assembling the frame, so this is not needed any more
625 }
626 }
627
628 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AssemblePartialFrames OUT"));
629 return OMX_TRUE;
630 }
631
632
ReturnInputBuffer(OMX_BUFFERHEADERTYPE * pInputBuffer,ComponentPortType * pPort)633 OSCL_EXPORT_REF void OmxComponentBase::ReturnInputBuffer(OMX_BUFFERHEADERTYPE* pInputBuffer, ComponentPortType* pPort)
634 {
635 OSCL_UNUSED_ARG(pPort);
636 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
637
638 if (iNumInputBuffer)
639 {
640 iNumInputBuffer--;
641 }
642
643 //Callback for releasing the input buffer
644 (*(ipCallbacks->EmptyBufferDone))
645 (pHandle, iCallbackData, pInputBuffer);
646
647 }
648
649 /**
650 * Returns Output Buffer back to the IL client
651 */
ReturnOutputBuffer(OMX_BUFFERHEADERTYPE * pOutputBuffer,ComponentPortType * pPort)652 OSCL_EXPORT_REF void OmxComponentBase::ReturnOutputBuffer(OMX_BUFFERHEADERTYPE* pOutputBuffer,
653 ComponentPortType *pPort)
654 {
655 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
656
657 //Callback for sending back the output buffer
658 (*(ipCallbacks->FillBufferDone))
659 (pHandle, iCallbackData, pOutputBuffer);
660
661 if (iOutBufferCount)
662 {
663 iOutBufferCount--;
664 }
665
666 pPort->NumBufferFlushed++;
667 iNewOutBufRequired = OMX_TRUE;
668 }
669
670
671 /** Flushes all the buffers under processing by the given port.
672 * This function is called due to a state change of the component, typically
673 * @param PortIndex the ID of the port to be flushed
674 */
675
FlushPort(OMX_S32 PortIndex)676 OMX_ERRORTYPE OmxComponentBase::FlushPort(OMX_S32 PortIndex)
677 {
678 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FlushPort IN"));
679
680 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
681
682
683 QueueType* pInputQueue = ipPorts[OMX_PORT_INPUTPORT_INDEX]->pBufferQueue;
684 QueueType* pOutputQueue = ipPorts[OMX_PORT_OUTPUTPORT_INDEX]->pBufferQueue;
685
686 OMX_BUFFERHEADERTYPE* pOutputBuff;
687 OMX_BUFFERHEADERTYPE* pInputBuff;
688
689 if (OMX_PORT_INPUTPORT_INDEX == PortIndex || OMX_PORT_ALLPORT_INDEX == PortIndex)
690 {
691 iPartialFrameAssembly = OMX_FALSE;
692
693 //Release all the input buffers in queue
694 while ((GetQueueNumElem(pInputQueue) > 0))
695 {
696 pInputBuff = (OMX_BUFFERHEADERTYPE*) DeQueue(pInputQueue);
697 if (NULL == pInputBuff)
698 {
699 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FlushPort ERROR DeQueue() returned NULL"));
700 return OMX_ErrorUndefined;
701 }
702 (*(ipCallbacks->EmptyBufferDone))
703 (pHandle, iCallbackData, pInputBuff);
704 iNumInputBuffer--;
705 }
706
707 //Release the current buffer that is being processed by the component.
708 if (iNumInputBuffer > 0 && ipInputBuffer && (OMX_FALSE == iIsInputBufferEnded))
709 {
710 (*(ipCallbacks->EmptyBufferDone))
711 (pHandle, iCallbackData, ipInputBuffer);
712 iNumInputBuffer--;
713
714 iIsInputBufferEnded = OMX_TRUE;
715 iInputCurrLength = 0;
716 }
717 }
718
719 if (OMX_PORT_OUTPUTPORT_INDEX == PortIndex || OMX_PORT_ALLPORT_INDEX == PortIndex)
720 {
721 //Release the current output buffer if present that is being processed by the component.
722 if ((OMX_FALSE == iNewOutBufRequired) && (iOutBufferCount > 0))
723 {
724 if (ipOutputBuffer)
725 {
726 (*(ipCallbacks->FillBufferDone))
727 (pHandle, iCallbackData, ipOutputBuffer);
728 iOutBufferCount--;
729 iNewOutBufRequired = OMX_TRUE;
730 }
731 }
732
733 //Release all other output buffers in queue
734 while ((GetQueueNumElem(pOutputQueue) > 0))
735 {
736 pOutputBuff = (OMX_BUFFERHEADERTYPE*) DeQueue(pOutputQueue);
737 if (NULL == pOutputBuff)
738 {
739 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FlushPort ERROR DeQueue() returned NULL"));
740 return OMX_ErrorUndefined;
741 }
742
743 pOutputBuff->nFilledLen = 0;
744 (*(ipCallbacks->FillBufferDone))
745 (pHandle, iCallbackData, pOutputBuff);
746 iOutBufferCount--;
747 }
748
749 }
750
751 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FlushPort OUT"));
752 return OMX_ErrorNone;
753 }
754
755 /**
756 * Disable Single Port
757 */
DisableSinglePort(OMX_U32 PortIndex)758 void OmxComponentBase::DisableSinglePort(OMX_U32 PortIndex)
759 {
760 ipPorts[PortIndex]->PortParam.bEnabled = OMX_FALSE;
761
762 if (PORT_IS_POPULATED(ipPorts[PortIndex]) && OMX_TRUE == iIsInit)
763 {
764 iStateTransitionFlag = OMX_TRUE;
765 return;
766 }
767
768 ipPorts[PortIndex]->NumBufferFlushed = 0;
769 }
770
771
772 /** Disables the specified port. This function is called due to a request by the IL client
773 * @param PortIndex the ID of the port to be disabled
774 */
DisablePort(OMX_S32 PortIndex)775 OMX_ERRORTYPE OmxComponentBase::DisablePort(OMX_S32 PortIndex)
776 {
777
778 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DisablePort IN"));
779 OMX_U32 ii;
780
781 if (-1 == PortIndex)
782 {
783 for (ii = 0; ii < iNumPorts; ii++)
784 {
785 ipPorts[ii]->IsPortFlushed = OMX_TRUE;
786 }
787
788 /*Flush all ports*/
789 FlushPort(PortIndex);
790
791 for (ii = 0; ii < iNumPorts; ii++)
792 {
793 ipPorts[ii]->IsPortFlushed = OMX_FALSE;
794 }
795 }
796 else
797 {
798 /*Flush the port specified*/
799 ipPorts[PortIndex]->IsPortFlushed = OMX_TRUE;
800 FlushPort(PortIndex);
801 ipPorts[PortIndex]->IsPortFlushed = OMX_FALSE;
802 }
803
804 /*Disable ports*/
805 if (PortIndex != -1)
806 {
807 DisableSinglePort(PortIndex);
808 }
809 else
810 {
811 for (ii = 0; ii < iNumPorts; ii++)
812 {
813 DisableSinglePort(ii);
814 }
815 }
816
817 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DisablePort OUT"));
818
819 return OMX_ErrorNone;
820 }
821
822 /**
823 * Enable Single Port
824 */
EnableSinglePort(OMX_U32 PortIndex)825 void OmxComponentBase::EnableSinglePort(OMX_U32 PortIndex)
826 {
827 ipPorts[PortIndex]->PortParam.bEnabled = OMX_TRUE;
828
829 if (!PORT_IS_POPULATED(ipPorts[PortIndex]) && OMX_TRUE == iIsInit)
830 {
831 iStateTransitionFlag = OMX_TRUE;
832 return;
833 }
834 }
835
836 /** Enables the specified port. This function is called due to a request by the IL client
837 * @param PortIndex the ID of the port to be enabled
838 */
EnablePort(OMX_S32 PortIndex)839 OMX_ERRORTYPE OmxComponentBase::EnablePort(OMX_S32 PortIndex)
840 {
841 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EnablePort IN"));
842
843 OMX_U32 ii;
844
845 /*Enable port/s*/
846 if (PortIndex != -1)
847 {
848 EnableSinglePort(PortIndex);
849 }
850 else
851 {
852 for (ii = 0; ii < iNumPorts; ii++)
853 {
854 EnableSinglePort(ii);
855 }
856 }
857
858 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EnablePort OUT"));
859 return OMX_ErrorNone;
860 }
861
862 //Not implemented & supported in case of base profile components
863
TunnelRequest(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_U32 nPort,OMX_IN OMX_HANDLETYPE hTunneledComp,OMX_IN OMX_U32 nTunneledPort,OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup)864 OMX_ERRORTYPE OmxComponentBase::TunnelRequest(
865 OMX_IN OMX_HANDLETYPE hComp,
866 OMX_IN OMX_U32 nPort,
867 OMX_IN OMX_HANDLETYPE hTunneledComp,
868 OMX_IN OMX_U32 nTunneledPort,
869 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup)
870 {
871 OSCL_UNUSED_ARG(hComp);
872 OSCL_UNUSED_ARG(nPort);
873 OSCL_UNUSED_ARG(hTunneledComp);
874 OSCL_UNUSED_ARG(nTunneledPort);
875 OSCL_UNUSED_ARG(pTunnelSetup);
876
877 return OMX_ErrorNotImplemented;
878 }
879
880
BaseComponentGetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_INOUT OMX_PTR pComponentConfigStructure)881 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentGetConfig(
882 OMX_IN OMX_HANDLETYPE hComponent,
883 OMX_IN OMX_INDEXTYPE nIndex,
884 OMX_INOUT OMX_PTR pComponentConfigStructure)
885 {
886
887 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
888 OMX_ERRORTYPE Status;
889
890 if (NULL == pOpenmaxAOType)
891 {
892 return OMX_ErrorBadParameter;
893 }
894
895 Status = pOpenmaxAOType->GetConfig(hComponent, nIndex, pComponentConfigStructure);
896 return Status;
897 }
898
899
900
GetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_INOUT OMX_PTR pComponentConfigStructure)901 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::GetConfig(
902 OMX_IN OMX_HANDLETYPE hComponent,
903 OMX_IN OMX_INDEXTYPE nIndex,
904 OMX_INOUT OMX_PTR pComponentConfigStructure)
905 {
906 OSCL_UNUSED_ARG(hComponent);
907 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig IN"));
908
909 OMX_U32 PortIndex;
910 OMX_CONFIG_INTRAREFRESHVOPTYPE* pVideoIFrame;
911 OMX_CONFIG_FRAMERATETYPE* pFrameRateType;
912 OMX_VIDEO_CONFIG_BITRATETYPE* pConfigBitRateType;
913
914 if (NULL == pComponentConfigStructure)
915 {
916 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig error bad parameter"));
917 return OMX_ErrorBadParameter;
918 }
919
920 switch (nIndex)
921 {
922 case OMX_IndexConfigVideoIntraVOPRefresh:
923 {
924 pVideoIFrame = (OMX_CONFIG_INTRAREFRESHVOPTYPE*) pComponentConfigStructure;
925 if (pVideoIFrame->nPortIndex != iCompressedFormatPortNum)
926 {
927 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig error bad port index for OMX_IndexConfigVideoIntraVOPRefresh"));
928 return OMX_ErrorBadPortIndex;
929 }
930 PortIndex = pVideoIFrame->nPortIndex;
931 oscl_memcpy(pVideoIFrame, &ipPorts[PortIndex]->VideoIFrame, sizeof(OMX_CONFIG_INTRAREFRESHVOPTYPE));
932 SetHeader(pVideoIFrame, sizeof(OMX_CONFIG_INTRAREFRESHVOPTYPE));
933 }
934 break;
935
936 case OMX_IndexConfigVideoFramerate:
937 {
938 pFrameRateType = (OMX_CONFIG_FRAMERATETYPE*) pComponentConfigStructure;
939 if (pFrameRateType->nPortIndex != iCompressedFormatPortNum)
940 {
941 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig error bad port index for OMX_IndexConfigVideoFramerate"));
942 return OMX_ErrorBadPortIndex;
943 }
944 PortIndex = pFrameRateType->nPortIndex;
945 oscl_memcpy(pFrameRateType, &ipPorts[PortIndex]->VideoConfigFrameRateType, sizeof(OMX_CONFIG_FRAMERATETYPE));
946 SetHeader(pFrameRateType, sizeof(OMX_CONFIG_FRAMERATETYPE));
947 }
948 break;
949
950 case OMX_IndexConfigVideoBitrate:
951 {
952 pConfigBitRateType = (OMX_VIDEO_CONFIG_BITRATETYPE*) pComponentConfigStructure;
953 if (pConfigBitRateType->nPortIndex != iCompressedFormatPortNum)
954 {
955 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig error bad port index for OMX_IndexConfigVideoBitrate"));
956 return OMX_ErrorBadPortIndex;
957 }
958 PortIndex = pConfigBitRateType->nPortIndex;
959 oscl_memcpy(pConfigBitRateType, &ipPorts[PortIndex]->VideoConfigBitRateType, sizeof(OMX_VIDEO_CONFIG_BITRATETYPE));
960 SetHeader(pConfigBitRateType, sizeof(OMX_VIDEO_CONFIG_BITRATETYPE));
961 }
962 break;
963 default:
964 {
965 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetParameter error Unsupported Index"));
966 return OMX_ErrorUnsupportedIndex;
967 }
968
969 }
970
971 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : GetConfig OUT"));
972
973 return OMX_ErrorNone;
974 }
975
976
BaseComponentSetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_IN OMX_PTR pComponentConfigStructure)977 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentSetConfig(
978 OMX_IN OMX_HANDLETYPE hComponent,
979 OMX_IN OMX_INDEXTYPE nIndex,
980 OMX_IN OMX_PTR pComponentConfigStructure)
981 {
982 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
983 OMX_ERRORTYPE Status;
984
985 if (NULL == pOpenmaxAOType)
986 {
987 return OMX_ErrorBadParameter;
988 }
989
990 Status = pOpenmaxAOType->SetConfig(hComponent, nIndex, pComponentConfigStructure);
991 return Status;
992 }
993
994
SetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_IN OMX_PTR pComponentConfigStructure)995 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::SetConfig(
996 OMX_IN OMX_HANDLETYPE hComponent,
997 OMX_IN OMX_INDEXTYPE nIndex,
998 OMX_IN OMX_PTR pComponentConfigStructure)
999 {
1000 OSCL_UNUSED_ARG(hComponent);
1001 OSCL_UNUSED_ARG(nIndex);
1002 OSCL_UNUSED_ARG(pComponentConfigStructure);
1003
1004 return OMX_ErrorNotImplemented;
1005 }
1006
1007
BaseComponentGetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)1008 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentGetExtensionIndex(
1009 OMX_IN OMX_HANDLETYPE hComponent,
1010 OMX_IN OMX_STRING cParameterName,
1011 OMX_OUT OMX_INDEXTYPE* pIndexType)
1012 {
1013 OSCL_UNUSED_ARG(hComponent);
1014 OSCL_UNUSED_ARG(cParameterName);
1015 OSCL_UNUSED_ARG(pIndexType);
1016
1017 return OMX_ErrorNotImplemented;
1018 }
1019
1020
BaseComponentGetState(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_STATETYPE * pState)1021 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentGetState(
1022 OMX_IN OMX_HANDLETYPE hComponent,
1023 OMX_OUT OMX_STATETYPE* pState)
1024 {
1025 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1026
1027 pOpenmaxAOType->GetState(pState);
1028
1029 return OMX_ErrorNone;
1030 }
1031
1032
GetState(OMX_OUT OMX_STATETYPE * pState)1033 void OmxComponentBase::GetState(OMX_OUT OMX_STATETYPE* pState)
1034 {
1035 *pState = iState;
1036 }
1037
1038
BaseComponentGetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)1039 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentGetParameter(
1040 OMX_IN OMX_HANDLETYPE hComponent,
1041 OMX_IN OMX_INDEXTYPE nParamIndex,
1042 OMX_INOUT OMX_PTR ComponentParameterStructure)
1043 {
1044
1045 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1046 OMX_ERRORTYPE Status;
1047
1048 if (NULL == pOpenmaxAOType)
1049 {
1050 return OMX_ErrorBadParameter;
1051 }
1052
1053 Status = pOpenmaxAOType->GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1054 return Status;
1055
1056 }
1057
BaseComponentSetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_IN OMX_PTR ComponentParameterStructure)1058 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentSetParameter(
1059 OMX_IN OMX_HANDLETYPE hComponent,
1060 OMX_IN OMX_INDEXTYPE nParamIndex,
1061 OMX_IN OMX_PTR ComponentParameterStructure)
1062 {
1063
1064 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1065 OMX_ERRORTYPE Status;
1066
1067 if (NULL == pOpenmaxAOType)
1068 {
1069 return OMX_ErrorBadParameter;
1070 }
1071
1072 Status = pOpenmaxAOType->SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1073
1074 return Status;
1075 }
1076
1077
BaseComponentUseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)1078 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentUseBuffer(
1079 OMX_IN OMX_HANDLETYPE hComponent,
1080 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
1081 OMX_IN OMX_U32 nPortIndex,
1082 OMX_IN OMX_PTR pAppPrivate,
1083 OMX_IN OMX_U32 nSizeBytes,
1084 OMX_IN OMX_U8* pBuffer)
1085 {
1086 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1087 OMX_ERRORTYPE Status;
1088
1089 if (NULL == pOpenmaxAOType)
1090 {
1091 return OMX_ErrorBadParameter;
1092 }
1093
1094 Status = pOpenmaxAOType->UseBuffer(hComponent, ppBufferHdr, nPortIndex, pAppPrivate, nSizeBytes, pBuffer);
1095
1096 return Status;
1097 }
1098
1099
UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)1100 OMX_ERRORTYPE OmxComponentBase::UseBuffer(
1101 OMX_IN OMX_HANDLETYPE hComponent,
1102 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
1103 OMX_IN OMX_U32 nPortIndex,
1104 OMX_IN OMX_PTR pAppPrivate,
1105 OMX_IN OMX_U32 nSizeBytes,
1106 OMX_IN OMX_U8* pBuffer)
1107 {
1108 OSCL_UNUSED_ARG(hComponent);
1109
1110 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer IN"));
1111 ComponentPortType* pBaseComponentPort;
1112 OMX_U32 ii;
1113
1114 if (nPortIndex >= iNumPorts)
1115 {
1116 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer error bad port index"));
1117 return OMX_ErrorBadPortIndex;
1118 }
1119
1120 pBaseComponentPort = ipPorts[nPortIndex];
1121
1122 if (pBaseComponentPort->TransientState != OMX_StateIdle)
1123 {
1124 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer error incorrect state"));
1125 return OMX_ErrorIncorrectStateTransition;
1126 }
1127
1128 if (NULL == pBaseComponentPort->pBuffer)
1129 {
1130 pBaseComponentPort->pBuffer = (OMX_BUFFERHEADERTYPE**) oscl_calloc(pBaseComponentPort->PortParam.nBufferCountActual, sizeof(OMX_BUFFERHEADERTYPE*));
1131 if (NULL == pBaseComponentPort->pBuffer)
1132 {
1133 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer error insufficient resources"));
1134 return OMX_ErrorInsufficientResources;
1135 }
1136
1137 pBaseComponentPort->BufferState = (OMX_U32*) oscl_calloc(pBaseComponentPort->PortParam.nBufferCountActual, sizeof(OMX_U32));
1138 if (NULL == pBaseComponentPort->BufferState)
1139 {
1140 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer error insufficient resources"));
1141 return OMX_ErrorInsufficientResources;
1142 }
1143 }
1144
1145 for (ii = 0; ii < pBaseComponentPort->PortParam.nBufferCountActual; ii++)
1146 {
1147 if (!(pBaseComponentPort->BufferState[ii] & BUFFER_ALLOCATED) &&
1148 !(pBaseComponentPort->BufferState[ii] & BUFFER_ASSIGNED))
1149 {
1150 pBaseComponentPort->pBuffer[ii] = (OMX_BUFFERHEADERTYPE*) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE));
1151 if (NULL == pBaseComponentPort->pBuffer[ii])
1152 {
1153 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer error insufficient resources"));
1154 return OMX_ErrorInsufficientResources;
1155 }
1156 SetHeader(pBaseComponentPort->pBuffer[ii], sizeof(OMX_BUFFERHEADERTYPE));
1157 pBaseComponentPort->pBuffer[ii]->pBuffer = pBuffer;
1158 pBaseComponentPort->pBuffer[ii]->nAllocLen = nSizeBytes;
1159 pBaseComponentPort->pBuffer[ii]->nFilledLen = 0;
1160 pBaseComponentPort->pBuffer[ii]->nOffset = 0;
1161 pBaseComponentPort->pBuffer[ii]->nFlags = 0;
1162 pBaseComponentPort->pBuffer[ii]->pPlatformPrivate = pBaseComponentPort;
1163 pBaseComponentPort->pBuffer[ii]->pAppPrivate = pAppPrivate;
1164 pBaseComponentPort->pBuffer[ii]->nTickCount = 0;
1165 pBaseComponentPort->pBuffer[ii]->nTimeStamp = 0;
1166 pBaseComponentPort->pBuffer[ii]->hMarkTargetComponent = NULL;
1167 *ppBufferHdr = pBaseComponentPort->pBuffer[ii];
1168 if (OMX_DirInput == pBaseComponentPort->PortParam.eDir)
1169 {
1170 pBaseComponentPort->pBuffer[ii]->nInputPortIndex = nPortIndex;
1171 pBaseComponentPort->pBuffer[ii]->nOutputPortIndex = iNumPorts; // here is assigned a non-valid port index
1172 }
1173 else
1174 {
1175 pBaseComponentPort->pBuffer[ii]->nOutputPortIndex = nPortIndex;
1176 pBaseComponentPort->pBuffer[ii]->nInputPortIndex = iNumPorts; // here is assigned a non-valid port index
1177 }
1178 pBaseComponentPort->BufferState[ii] |= BUFFER_ASSIGNED;
1179 pBaseComponentPort->BufferState[ii] |= HEADER_ALLOCATED;
1180 pBaseComponentPort->NumAssignedBuffers++;
1181 if (pBaseComponentPort->PortParam.nBufferCountActual == pBaseComponentPort->NumAssignedBuffers)
1182 {
1183 pBaseComponentPort->PortParam.bPopulated = OMX_TRUE;
1184
1185 if (OMX_TRUE == iStateTransitionFlag)
1186 {
1187 //Reschedule the AO for a state change (Loaded->Idle) if its pending on buffer allocation
1188 RunIfNotReady();
1189 iStateTransitionFlag = OMX_FALSE;
1190 }
1191 }
1192 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer OUT"));
1193 return OMX_ErrorNone;
1194 }
1195 }
1196
1197 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : UseBuffer OUT"));
1198 return OMX_ErrorNone;
1199 }
1200
1201
BaseComponentAllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** pBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)1202 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentAllocateBuffer(
1203 OMX_IN OMX_HANDLETYPE hComponent,
1204 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
1205 OMX_IN OMX_U32 nPortIndex,
1206 OMX_IN OMX_PTR pAppPrivate,
1207 OMX_IN OMX_U32 nSizeBytes)
1208 {
1209 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1210 OMX_ERRORTYPE Status;
1211
1212 if (NULL == pOpenmaxAOType)
1213 {
1214 return OMX_ErrorBadParameter;
1215 }
1216
1217 Status = pOpenmaxAOType->AllocateBuffer(hComponent, pBuffer, nPortIndex, pAppPrivate, nSizeBytes);
1218
1219 return Status;
1220 }
1221
1222
AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** pBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)1223 OMX_ERRORTYPE OmxComponentBase::AllocateBuffer(
1224 OMX_IN OMX_HANDLETYPE hComponent,
1225 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
1226 OMX_IN OMX_U32 nPortIndex,
1227 OMX_IN OMX_PTR pAppPrivate,
1228 OMX_IN OMX_U32 nSizeBytes)
1229 {
1230 OSCL_UNUSED_ARG(hComponent);
1231
1232 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer IN"));
1233
1234 ComponentPortType* pBaseComponentPort;
1235 OMX_U32 ii;
1236
1237 if (nPortIndex >= iNumPorts)
1238 {
1239 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error bad port index"));
1240 return OMX_ErrorBadPortIndex;
1241 }
1242
1243 pBaseComponentPort = ipPorts[nPortIndex];
1244
1245 if (pBaseComponentPort->TransientState != OMX_StateIdle)
1246 {
1247 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error incorrect state"));
1248 return OMX_ErrorIncorrectStateTransition;
1249 }
1250
1251 if (NULL == pBaseComponentPort->pBuffer)
1252 {
1253 pBaseComponentPort->pBuffer = (OMX_BUFFERHEADERTYPE**) oscl_calloc(pBaseComponentPort->PortParam.nBufferCountActual, sizeof(OMX_BUFFERHEADERTYPE*));
1254 if (NULL == pBaseComponentPort->pBuffer)
1255 {
1256 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error insufficient resources"));
1257 return OMX_ErrorInsufficientResources;
1258 }
1259
1260 pBaseComponentPort->BufferState = (OMX_U32*) oscl_calloc(pBaseComponentPort->PortParam.nBufferCountActual, sizeof(OMX_U32));
1261 if (NULL == pBaseComponentPort->BufferState)
1262 {
1263 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error insufficient resources"));
1264 return OMX_ErrorInsufficientResources;
1265 }
1266 }
1267
1268 for (ii = 0; ii < pBaseComponentPort->PortParam.nBufferCountActual; ii++)
1269 {
1270 if (!(pBaseComponentPort->BufferState[ii] & BUFFER_ALLOCATED) &&
1271 !(pBaseComponentPort->BufferState[ii] & BUFFER_ASSIGNED))
1272 {
1273 pBaseComponentPort->pBuffer[ii] = (OMX_BUFFERHEADERTYPE*) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE));
1274 if (NULL == pBaseComponentPort->pBuffer[ii])
1275 {
1276 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error insufficient resources"));
1277 return OMX_ErrorInsufficientResources;
1278 }
1279 SetHeader(pBaseComponentPort->pBuffer[ii], sizeof(OMX_BUFFERHEADERTYPE));
1280 /* allocate the buffer */
1281 pBaseComponentPort->pBuffer[ii]->pBuffer = (OMX_BYTE) oscl_malloc(nSizeBytes);
1282 if (NULL == pBaseComponentPort->pBuffer[ii]->pBuffer)
1283 {
1284 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer error insufficient resources"));
1285 return OMX_ErrorInsufficientResources;
1286 }
1287 pBaseComponentPort->pBuffer[ii]->nAllocLen = nSizeBytes;
1288 pBaseComponentPort->pBuffer[ii]->nFlags = 0;
1289 pBaseComponentPort->pBuffer[ii]->pPlatformPrivate = pBaseComponentPort;
1290 pBaseComponentPort->pBuffer[ii]->pAppPrivate = pAppPrivate;
1291 *pBuffer = pBaseComponentPort->pBuffer[ii];
1292 pBaseComponentPort->BufferState[ii] |= BUFFER_ALLOCATED;
1293 pBaseComponentPort->BufferState[ii] |= HEADER_ALLOCATED;
1294
1295 if (OMX_DirInput == pBaseComponentPort->PortParam.eDir)
1296 {
1297 pBaseComponentPort->pBuffer[ii]->nInputPortIndex = nPortIndex;
1298 // here is assigned a non-valid port index
1299 pBaseComponentPort->pBuffer[ii]->nOutputPortIndex = iNumPorts;
1300 }
1301 else
1302 {
1303 // here is assigned a non-valid port index
1304 pBaseComponentPort->pBuffer[ii]->nInputPortIndex = iNumPorts;
1305 pBaseComponentPort->pBuffer[ii]->nOutputPortIndex = nPortIndex;
1306 }
1307
1308 pBaseComponentPort->NumAssignedBuffers++;
1309
1310 if (pBaseComponentPort->PortParam.nBufferCountActual == pBaseComponentPort->NumAssignedBuffers)
1311 {
1312 pBaseComponentPort->PortParam.bPopulated = OMX_TRUE;
1313
1314 if (OMX_TRUE == iStateTransitionFlag)
1315 {
1316 //Reschedule the AO for a state change (Loaded->Idle) if its pending on buffer allocation
1317 RunIfNotReady();
1318 iStateTransitionFlag = OMX_FALSE;
1319 }
1320 }
1321
1322 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer OUT"));
1323 return OMX_ErrorNone;
1324 }
1325 }
1326
1327 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : AllocateBuffer OUT"));
1328 return OMX_ErrorInsufficientResources;
1329 }
1330
BaseComponentFreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)1331 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentFreeBuffer(
1332 OMX_IN OMX_HANDLETYPE hComponent,
1333 OMX_IN OMX_U32 nPortIndex,
1334 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
1335 {
1336 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1337 OMX_ERRORTYPE Status;
1338
1339 if (NULL == pOpenmaxAOType)
1340 {
1341 return OMX_ErrorBadParameter;
1342 }
1343
1344 Status = pOpenmaxAOType->FreeBuffer(hComponent, nPortIndex, pBuffer);
1345
1346 return Status;
1347 }
1348
1349
FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)1350 OMX_ERRORTYPE OmxComponentBase::FreeBuffer(
1351 OMX_IN OMX_HANDLETYPE hComponent,
1352 OMX_IN OMX_U32 nPortIndex,
1353 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
1354 {
1355 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FreeBuffer IN"));
1356
1357 ComponentPortType* pBaseComponentPort;
1358
1359 OMX_U32 ii;
1360 OMX_BOOL FoundBuffer;
1361
1362 if (nPortIndex >= iNumPorts)
1363 {
1364 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FreeBuffer error bad port index"));
1365 return OMX_ErrorBadPortIndex;
1366 }
1367
1368 pBaseComponentPort = ipPorts[nPortIndex];
1369
1370 if (pBaseComponentPort->TransientState != OMX_StateLoaded
1371 && pBaseComponentPort->TransientState != OMX_StateInvalid)
1372 {
1373
1374 (*(ipCallbacks->EventHandler))
1375 (hComponent,
1376 iCallbackData,
1377 OMX_EventError, /* The command was completed */
1378 OMX_ErrorPortUnpopulated, /* The commands was a OMX_CommandStateSet */
1379 nPortIndex, /* The State has been changed in message->MessageParam2 */
1380 NULL);
1381 }
1382
1383 for (ii = 0; ii < pBaseComponentPort->PortParam.nBufferCountActual; ii++)
1384 {
1385 if ((pBaseComponentPort->BufferState[ii] & BUFFER_ALLOCATED) &&
1386 (pBaseComponentPort->pBuffer[ii]->pBuffer == pBuffer->pBuffer))
1387 {
1388
1389 pBaseComponentPort->NumAssignedBuffers--;
1390 oscl_free(pBuffer->pBuffer);
1391 pBuffer->pBuffer = NULL;
1392
1393 if (pBaseComponentPort->BufferState[ii] & HEADER_ALLOCATED)
1394 {
1395 oscl_free(pBuffer);
1396 pBuffer = NULL;
1397 }
1398 pBaseComponentPort->BufferState[ii] = BUFFER_FREE;
1399 break;
1400 }
1401 else if ((pBaseComponentPort->BufferState[ii] & BUFFER_ASSIGNED) &&
1402 (pBaseComponentPort->pBuffer[ii] == pBuffer))
1403 {
1404
1405 pBaseComponentPort->NumAssignedBuffers--;
1406
1407 if (pBaseComponentPort->BufferState[ii] & HEADER_ALLOCATED)
1408 {
1409 oscl_free(pBuffer);
1410 pBuffer = NULL;
1411 }
1412
1413 pBaseComponentPort->BufferState[ii] = BUFFER_FREE;
1414 break;
1415 }
1416 }
1417
1418 FoundBuffer = OMX_FALSE;
1419
1420 for (ii = 0; ii < pBaseComponentPort->PortParam.nBufferCountActual; ii++)
1421 {
1422 if (pBaseComponentPort->BufferState[ii] != BUFFER_FREE)
1423 {
1424 FoundBuffer = OMX_TRUE;
1425 break;
1426 }
1427 }
1428 if (!FoundBuffer)
1429 {
1430 pBaseComponentPort->PortParam.bPopulated = OMX_FALSE;
1431
1432 if (OMX_TRUE == iStateTransitionFlag)
1433 {
1434 //Reschedule the AO for a state change (Idle->Loaded) if its pending on buffer de-allocation
1435 RunIfNotReady();
1436 iStateTransitionFlag = OMX_FALSE;
1437
1438 //Reset the decoding flags while freeing buffers
1439 if (OMX_PORT_INPUTPORT_INDEX == nPortIndex)
1440 {
1441 iIsInputBufferEnded = OMX_TRUE;
1442 iTempInputBufferLength = 0;
1443 iTempConsumedLength = 0;
1444 iNewInBufferRequired = OMX_TRUE;
1445 }
1446 else if (OMX_PORT_OUTPUTPORT_INDEX == nPortIndex)
1447 {
1448 iNewOutBufRequired = OMX_TRUE;
1449 }
1450 }
1451
1452 if (NULL != pBaseComponentPort->pBuffer)
1453 {
1454 oscl_free(pBaseComponentPort->pBuffer);
1455 pBaseComponentPort->pBuffer = NULL;
1456 oscl_free(pBaseComponentPort->BufferState);
1457 pBaseComponentPort->BufferState = NULL;
1458 }
1459 }
1460
1461 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FreeBuffer OUT"));
1462 return OMX_ErrorNone;
1463 }
1464
1465
1466 /** Set Callbacks. It stores in the component private structure the pointers to the user application callbacs
1467 * @param hComponent the handle of the component
1468 * @param ipCallbacks the OpenMAX standard structure that holds the callback pointers
1469 * @param pAppData a pointer to a private structure, not covered by OpenMAX standard, in needed
1470 */
1471
BaseComponentSetCallbacks(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_CALLBACKTYPE * pCallbacks,OMX_IN OMX_PTR pAppData)1472 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentSetCallbacks(
1473 OMX_IN OMX_HANDLETYPE hComponent,
1474 OMX_IN OMX_CALLBACKTYPE* pCallbacks,
1475 OMX_IN OMX_PTR pAppData)
1476 {
1477 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1478 OMX_ERRORTYPE Status;
1479
1480 if (NULL == pOpenmaxAOType)
1481 {
1482 return OMX_ErrorBadParameter;
1483 }
1484
1485 Status = pOpenmaxAOType->SetCallbacks(hComponent, pCallbacks, pAppData);
1486
1487 return Status;
1488 }
1489
1490
SetCallbacks(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_CALLBACKTYPE * pCallbacks,OMX_IN OMX_PTR pAppData)1491 OMX_ERRORTYPE OmxComponentBase::SetCallbacks(
1492 OMX_IN OMX_HANDLETYPE hComponent,
1493 OMX_IN OMX_CALLBACKTYPE* pCallbacks,
1494 OMX_IN OMX_PTR pAppData)
1495 {
1496 OSCL_UNUSED_ARG(hComponent);
1497
1498 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SetCallbacks"));
1499 ipCallbacks = pCallbacks;
1500 iCallbackData = pAppData;
1501
1502 return OMX_ErrorNone;
1503 }
1504
1505
BaseComponentSendCommand(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_COMMANDTYPE Cmd,OMX_IN OMX_U32 nParam,OMX_IN OMX_PTR pCmdData)1506 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentSendCommand(
1507 OMX_IN OMX_HANDLETYPE hComponent,
1508 OMX_IN OMX_COMMANDTYPE Cmd,
1509 OMX_IN OMX_U32 nParam,
1510 OMX_IN OMX_PTR pCmdData)
1511 {
1512
1513 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1514 OMX_ERRORTYPE Status;
1515
1516 if (NULL == pOpenmaxAOType)
1517 {
1518 return OMX_ErrorBadParameter;
1519 }
1520
1521 Status = pOpenmaxAOType->SendCommand(hComponent, Cmd, nParam, pCmdData);
1522
1523 return Status;
1524 }
1525
SendCommand(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_COMMANDTYPE Cmd,OMX_IN OMX_S32 nParam,OMX_IN OMX_PTR pCmdData)1526 OMX_ERRORTYPE OmxComponentBase::SendCommand(
1527 OMX_IN OMX_HANDLETYPE hComponent,
1528 OMX_IN OMX_COMMANDTYPE Cmd,
1529 OMX_IN OMX_S32 nParam,
1530 OMX_IN OMX_PTR pCmdData)
1531 {
1532
1533 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand IN"));
1534
1535 OMX_U32 ii;
1536 OMX_ERRORTYPE ErrMsgHandler = OMX_ErrorNone;
1537 QueueType* pMessageQueue;
1538 CoreMessage* Message = NULL;
1539 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
1540
1541 pMessageQueue = ipCoreDescriptor->pMessageQueue;
1542
1543 if (OMX_StateInvalid == iState)
1544 {
1545 ErrMsgHandler = OMX_ErrorInvalidState;
1546 }
1547
1548 switch (Cmd)
1549 {
1550 case OMX_CommandStateSet:
1551 {
1552 Message = (CoreMessage*) oscl_malloc(sizeof(CoreMessage));
1553
1554 if (NULL == Message)
1555 {
1556 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error insufficient resources"));
1557 return OMX_ErrorInsufficientResources;
1558 }
1559
1560 Message->pComponent = (OMX_COMPONENTTYPE *) hComponent;
1561 Message->MessageType = SENDCOMMAND_MSG_TYPE;
1562 Message->MessageParam1 = OMX_CommandStateSet;
1563 Message->MessageParam2 = nParam;
1564 Message->pCmdData = pCmdData;
1565
1566 if ((OMX_StateIdle == nParam) && (OMX_StateLoaded == iState))
1567 {
1568 ErrMsgHandler = pOpenmaxAOType->ComponentInit();
1569
1570 if (OMX_ErrorNone != ErrMsgHandler)
1571 {
1572 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error component init"));
1573 return OMX_ErrorInsufficientResources;
1574 }
1575 for (ii = 0; ii < iNumPorts; ii++)
1576 {
1577 ipPorts[ii]->TransientState = OMX_StateIdle;
1578 }
1579 }
1580 else if ((OMX_StateLoaded == nParam) && (OMX_StateIdle == iState))
1581 {
1582 for (ii = 0; ii < iNumPorts; ii++)
1583 {
1584 if (PORT_IS_ENABLED(ipPorts[ii]))
1585 {
1586 ipPorts[ii]->TransientState = OMX_StateLoaded;
1587 }
1588 }
1589 }
1590 else if (OMX_StateInvalid == nParam)
1591 {
1592 for (ii = 0; ii < iNumPorts; ii++)
1593 {
1594 if (PORT_IS_ENABLED(ipPorts[ii]))
1595 {
1596 ipPorts[ii]->TransientState = OMX_StateInvalid;
1597 }
1598 }
1599 }
1600 else if (((OMX_StateIdle == nParam) || (OMX_StatePause == nParam))
1601 && (OMX_StateExecuting == iState))
1602 {
1603 iBufferExecuteFlag = OMX_FALSE;
1604 }
1605
1606 }
1607 break;
1608
1609 case OMX_CommandFlush:
1610 {
1611 Message = (CoreMessage*) oscl_malloc(sizeof(CoreMessage));
1612
1613 if (NULL == Message)
1614 {
1615 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error insufficient resources"));
1616 return OMX_ErrorInsufficientResources;
1617 }
1618
1619 Message->pComponent = (OMX_COMPONENTTYPE *) hComponent;
1620 Message->MessageType = SENDCOMMAND_MSG_TYPE;
1621 Message->MessageParam1 = OMX_CommandFlush;
1622 Message->MessageParam2 = nParam;
1623 Message->pCmdData = pCmdData;
1624
1625 if ((nParam != -1) && ((OMX_U32) nParam >= iNumPorts))
1626 {
1627 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error bad port index"));
1628 return OMX_ErrorBadPortIndex;
1629 }
1630
1631 //If component is in Idle state, just queue the command and don't do anything else
1632 if (iState == OMX_StateIdle)
1633 {
1634 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand Flush command in Idle state"));
1635 break;
1636 }
1637
1638 if ((iState != OMX_StateExecuting) && (iState != OMX_StatePause))
1639 {
1640 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1641 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1642 break;
1643
1644 }
1645
1646 SetPortFlushFlag(iNumPorts, nParam, OMX_TRUE);
1647 SetNumBufferFlush(iNumPorts, -1, 0);
1648 }
1649 break;
1650
1651 case OMX_CommandPortDisable:
1652 {
1653 if ((nParam != -1) && ((OMX_U32) nParam >= iNumPorts))
1654 {
1655 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error bad port index"));
1656 return OMX_ErrorBadPortIndex;
1657 }
1658
1659 iResizePending = OMX_FALSE; // reset the flag to enable processing
1660 iSendOutBufferAfterPortReconfigFlag = OMX_TRUE;
1661
1662
1663 if (-1 == nParam)
1664 {
1665 for (ii = 0; ii < iNumPorts; ii++)
1666 {
1667 if (!PORT_IS_ENABLED(ipPorts[ii]))
1668 {
1669 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1670 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1671 break;
1672 }
1673 else
1674 {
1675 ipPorts[ii]->TransientState = OMX_StateLoaded;
1676 }
1677 }
1678 }
1679 else
1680 {
1681 if (!PORT_IS_ENABLED(ipPorts[nParam]))
1682 {
1683 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1684 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1685 break;
1686 }
1687 else
1688 {
1689 ipPorts[nParam]->TransientState = OMX_StateLoaded;
1690 }
1691 }
1692
1693 Message = (CoreMessage*) oscl_malloc(sizeof(CoreMessage));
1694 if (NULL == Message)
1695 {
1696 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error insufficient resources"));
1697 return OMX_ErrorInsufficientResources;
1698 }
1699
1700 Message->pComponent = (OMX_COMPONENTTYPE *) hComponent;
1701 if (OMX_ErrorNone == ErrMsgHandler)
1702 {
1703 Message->MessageType = SENDCOMMAND_MSG_TYPE;
1704 Message->MessageParam2 = nParam;
1705 }
1706 else
1707 {
1708 Message->MessageType = ERROR_MSG_TYPE;
1709 Message->MessageParam2 = ErrMsgHandler;
1710 }
1711 Message->MessageParam1 = OMX_CommandPortDisable;
1712 Message->pCmdData = pCmdData;
1713 }
1714 break;
1715
1716
1717 case OMX_CommandPortEnable:
1718 {
1719 if ((nParam != -1) && ((OMX_U32) nParam >= iNumPorts))
1720 {
1721 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error bad port index"));
1722 return OMX_ErrorBadPortIndex;
1723 }
1724
1725 if (-1 == nParam)
1726 {
1727 for (ii = 0; ii < iNumPorts; ii++)
1728 {
1729 if (PORT_IS_ENABLED(ipPorts[ii]))
1730 {
1731 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1732 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1733 break;
1734 }
1735 else
1736 {
1737 ipPorts[ii]->TransientState = OMX_StateIdle;
1738 }
1739 }
1740 }
1741 else
1742 {
1743 if (PORT_IS_ENABLED(ipPorts[nParam]))
1744 {
1745 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1746 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1747 break;
1748 }
1749 else
1750 {
1751 ipPorts[nParam]->TransientState = OMX_StateIdle;
1752 }
1753 }
1754
1755 Message = (CoreMessage*) oscl_malloc(sizeof(CoreMessage));
1756 if (NULL == Message)
1757 {
1758 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error insufficient resources"));
1759 return OMX_ErrorInsufficientResources;
1760 }
1761
1762 Message->pComponent = (OMX_COMPONENTTYPE *) hComponent;
1763 if (OMX_ErrorNone == ErrMsgHandler)
1764 {
1765 Message->MessageType = SENDCOMMAND_MSG_TYPE;
1766 }
1767 else
1768 {
1769 Message->MessageType = ERROR_MSG_TYPE;
1770 }
1771
1772 Message->MessageParam1 = OMX_CommandPortEnable;
1773 Message->MessageParam2 = nParam;
1774 Message->pCmdData = pCmdData;
1775 }
1776 break;
1777
1778
1779 case OMX_CommandMarkBuffer:
1780 {
1781 if ((iState != OMX_StateExecuting) && (iState != OMX_StatePause))
1782 {
1783 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error incorrect state"));
1784 ErrMsgHandler = OMX_ErrorIncorrectStateOperation;
1785 break;
1786 }
1787
1788 if ((nParam != -1) && ((OMX_U32) nParam >= iNumPorts))
1789 {
1790 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error bad port index"));
1791 return OMX_ErrorBadPortIndex;
1792 }
1793
1794 Message = (CoreMessage*) oscl_malloc(sizeof(CoreMessage));
1795 if (NULL == Message)
1796 {
1797 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error insufficient resources"));
1798 return OMX_ErrorInsufficientResources;
1799 }
1800 Message->pComponent = (OMX_COMPONENTTYPE *) hComponent;
1801 Message->MessageType = SENDCOMMAND_MSG_TYPE;
1802 Message->MessageParam1 = OMX_CommandMarkBuffer;
1803 Message->MessageParam2 = nParam;
1804 Message->pCmdData = pCmdData;
1805 }
1806 break;
1807
1808
1809 default:
1810 {
1811 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error unsupported index"));
1812 ErrMsgHandler = OMX_ErrorUnsupportedIndex;
1813 }
1814 break;
1815 }
1816
1817 if (OMX_ErrorNone != Queue(pMessageQueue, Message))
1818 {
1819 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand error, Queuing command failed"));
1820 return OMX_ErrorInsufficientResources;
1821 }
1822
1823 RunIfNotReady();
1824
1825 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : SendCommand OUT"));
1826 return ErrMsgHandler;
1827 }
1828
1829
1830
1831 /* This routine will reset all the buffers and flag associated with decoding
1832 * when receiving a flush command on the respective port*/
ResetAfterFlush(OMX_S32 PortIndex)1833 void OmxComponentBase::ResetAfterFlush(OMX_S32 PortIndex)
1834 {
1835
1836 if (OMX_PORT_INPUTPORT_INDEX == PortIndex || OMX_PORT_ALLPORT_INDEX == PortIndex)
1837 {
1838 iIsInputBufferEnded = OMX_TRUE;
1839 iEndofStream = OMX_FALSE;
1840 iNewInBufferRequired = OMX_TRUE;
1841 iPartialFrameAssembly = OMX_FALSE;
1842 iTempInputBufferLength = 0;
1843 iTempConsumedLength = 0;
1844 iInputBufferRemainingBytes = 0;
1845 iInputCurrLength = 0;
1846
1847 //Assume for this state transition that reposition command has come
1848 iRepositionFlag = OMX_TRUE;
1849 //Reset the silence insertion logic also
1850 iSilenceInsertionInProgress = OMX_FALSE;
1851 }
1852
1853 if (OMX_PORT_OUTPUTPORT_INDEX == PortIndex || OMX_PORT_ALLPORT_INDEX == PortIndex)
1854 {
1855 iNewOutBufRequired = OMX_TRUE;
1856 }
1857
1858 return;
1859 }
1860
1861
1862 /** This is called by the OMX core in its message processing
1863 * thread context upon a component request. A request is made
1864 * by the component when some asynchronous services are needed:
1865 * 1) A SendCommand() is to be processed
1866 * 2) An error needs to be notified
1867 * \param Message, the message that has been passed to core
1868 */
1869
MessageHandler(CoreMessage * Message)1870 OMX_ERRORTYPE OmxComponentBase::MessageHandler(CoreMessage* Message)
1871 {
1872
1873 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
1874 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*) iOmxComponent.pComponentPrivate;
1875 OMX_U32 ii;
1876 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
1877
1878
1879 /** Dealing with a SendCommand call.
1880 * -MessageParam1 contains the command to execute
1881 * -MessageParam2 contains the parameter of the command
1882 * (destination state in case of a state change command).
1883 */
1884
1885 OMX_STATETYPE orig_state = iState;
1886 if (SENDCOMMAND_MSG_TYPE == Message->MessageType)
1887 {
1888 switch (Message->MessageParam1)
1889 {
1890 case OMX_CommandStateSet:
1891 {
1892 /* Do the actual state change */
1893 ErrorType = DoStateSet(Message->MessageParam2);
1894
1895 if (OMX_TRUE == iStateTransitionFlag)
1896 {
1897 return OMX_ErrorNone;
1898 }
1899
1900 //Do not send the callback now till the State gets changed
1901 if (ErrorType != OMX_ErrorNone)
1902 {
1903 (*(ipCallbacks->EventHandler))
1904 (pHandle,
1905 iCallbackData,
1906 OMX_EventError, /* The command was completed */
1907 ErrorType, /* The commands was a OMX_CommandStateSet */
1908 0, /* The iState has been changed in Message->MessageParam2 */
1909 NULL);
1910 }
1911 else
1912 {
1913 /* And run the callback */
1914 (*(ipCallbacks->EventHandler))
1915 (pHandle,
1916 iCallbackData,
1917 OMX_EventCmdComplete, /* The command was completed */
1918 OMX_CommandStateSet, /* The commands was a OMX_CommandStateSet */
1919 Message->MessageParam2, /* The iState has been changed in Message->MessageParam2 */
1920 NULL);
1921 }
1922 }
1923 break;
1924
1925 case OMX_CommandFlush:
1926 {
1927 //If the component is in Idle state, send the command complete callback
1928 //without any processing as the ports are empty of buffers anyway
1929 if (OMX_StateIdle == iState)
1930 {
1931 if (-1 == Message->MessageParam2)
1932 {
1933 /*Flush all port*/
1934 for (ii = 0; ii < iNumPorts; ii++)
1935 {
1936 (*(ipCallbacks->EventHandler))
1937 (pHandle,
1938 iCallbackData,
1939 OMX_EventCmdComplete, /* The command was completed */
1940 OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
1941 ii, /* The iState has been changed in Message->MessageParam2 */
1942 NULL);
1943 }
1944 }
1945 else
1946 {
1947 /*Flush input/output port*/
1948 (*(ipCallbacks->EventHandler))
1949 (pHandle,
1950 iCallbackData,
1951 OMX_EventCmdComplete, /* The command was completed */
1952 OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
1953 Message->MessageParam2, /* The iState has been changed in Message->MessageParam2 */
1954 NULL);
1955 }
1956
1957 // Break from here as we don't want to do any further processing
1958 // for this command
1959 break;
1960 }
1961
1962
1963 /*Flush ports*/
1964 ErrorType = FlushPort(Message->MessageParam2);
1965
1966 SetNumBufferFlush(iNumPorts, -1, 0);
1967
1968 ResetAfterFlush(Message->MessageParam2);
1969
1970 //If Flush Command has come at the input port, reset the individual component as well
1971 if (OMX_PORT_INPUTPORT_INDEX == Message->MessageParam2
1972 || OMX_PORT_ALLPORT_INDEX == Message->MessageParam2)
1973 {
1974 /* Component specific flush routine for input buffer where individual components
1975 * may set/reset some flags/buffer lengths if required.*/
1976
1977 pOpenmaxAOType->ResetComponent();
1978 }
1979
1980 if (ErrorType != OMX_ErrorNone)
1981 {
1982 (*(ipCallbacks->EventHandler))
1983 (pHandle,
1984 iCallbackData,
1985 OMX_EventError, /* The command was completed */
1986 ErrorType, /* The commands was a OMX_CommandStateSet */
1987 0, /* The iState has been changed in Message->MessageParam2 */
1988 NULL);
1989 }
1990 else
1991 {
1992 if (-1 == Message->MessageParam2)
1993 {
1994 /*Flush all port*/
1995 for (ii = 0; ii < iNumPorts; ii++)
1996 {
1997 (*(ipCallbacks->EventHandler))
1998 (pHandle,
1999 iCallbackData,
2000 OMX_EventCmdComplete, /* The command was completed */
2001 OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
2002 ii, /* The iState has been changed in Message->MessageParam2 */
2003 NULL);
2004 }
2005 }
2006 else
2007 {
2008 /*Flush input/output port*/
2009 (*(ipCallbacks->EventHandler))
2010 (pHandle,
2011 iCallbackData,
2012 OMX_EventCmdComplete, /* The command was completed */
2013 OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
2014 Message->MessageParam2, /* The iState has been changed in Message->MessageParam2 */
2015 NULL);
2016 }
2017 }
2018 SetPortFlushFlag(iNumPorts, -1, OMX_FALSE);
2019 }
2020 break;
2021
2022 case OMX_CommandPortDisable:
2023 {
2024 /** This condition is added to pass the tests, it is not significant for the environment */
2025 ErrorType = DisablePort(Message->MessageParam2);
2026 if (OMX_TRUE == iStateTransitionFlag)
2027 {
2028 return OMX_ErrorNone;
2029 }
2030
2031 if (ErrorType != OMX_ErrorNone)
2032 {
2033 (*(ipCallbacks->EventHandler))
2034 (pHandle,
2035 iCallbackData,
2036 OMX_EventError, /* The command was completed */
2037 ErrorType, /* The commands was a OMX_CommandStateSet */
2038 0, /* The iState has been changed in Message->MessageParam2 */
2039 NULL);
2040 }
2041 else
2042 {
2043 if (-1 == Message->MessageParam2)
2044 {
2045 /*Disable all ports*/
2046 for (ii = 0; ii < iNumPorts; ii++)
2047 {
2048 (*(ipCallbacks->EventHandler))
2049 (pHandle,
2050 iCallbackData,
2051 OMX_EventCmdComplete, /* The command was completed */
2052 OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
2053 ii, /* The iState has been changed in Message->MessageParam2 */
2054 NULL);
2055 }
2056 }
2057 else
2058 {
2059 (*(ipCallbacks->EventHandler))
2060 (pHandle,
2061 iCallbackData,
2062 OMX_EventCmdComplete, /* The command was completed */
2063 OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
2064 Message->MessageParam2, /* The iState has been changed in Message->MessageParam2 */
2065 NULL);
2066 }
2067 }
2068 }
2069 break;
2070
2071 case OMX_CommandPortEnable:
2072 {
2073 ErrorType = EnablePort(Message->MessageParam2);
2074 if (OMX_TRUE == iStateTransitionFlag)
2075 {
2076 return OMX_ErrorNone;
2077 }
2078
2079 if (ErrorType != OMX_ErrorNone)
2080 {
2081 (*(ipCallbacks->EventHandler))
2082 (pHandle,
2083 iCallbackData,
2084 OMX_EventError, /* The command was completed */
2085 ErrorType, /* The commands was a OMX_CommandStateSet */
2086 0, /* The State has been changed in Message->MessageParam2 */
2087 NULL);
2088 }
2089 else
2090 {
2091 if (Message->MessageParam2 != -1)
2092 {
2093 (*(ipCallbacks->EventHandler))
2094 (pHandle,
2095 iCallbackData,
2096 OMX_EventCmdComplete, /* The command was completed */
2097 OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
2098 Message->MessageParam2, /* The State has been changed in Message->MessageParam2 */
2099 NULL);
2100 }
2101 else
2102 {
2103 for (ii = 0; ii < iNumPorts; ii++)
2104 {
2105 (*(ipCallbacks->EventHandler))
2106 (pHandle,
2107 iCallbackData,
2108 OMX_EventCmdComplete, /* The command was completed */
2109 OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
2110 ii, /* The State has been changed in Message->MessageParam2 */
2111 NULL);
2112 }
2113 }
2114 }
2115 }
2116 break;
2117
2118 case OMX_CommandMarkBuffer:
2119 {
2120 ipMark = (OMX_MARKTYPE *)Message->pCmdData;
2121 }
2122 break;
2123
2124 default:
2125 {
2126
2127 }
2128 break;
2129 }
2130 /* Dealing with an asynchronous error condition
2131 */
2132 }
2133
2134 if (orig_state != OMX_StateInvalid)
2135 {
2136 ErrorType = OMX_ErrorNone;
2137 }
2138
2139 return ErrorType;
2140 }
2141
2142 /** Changes the state of a component taking proper actions depending on
2143 * the transiotion requested
2144 * \param aDestinationState the requested target state.
2145 */
2146
DoStateSet(OMX_U32 aDestinationState)2147 OMX_ERRORTYPE OmxComponentBase::DoStateSet(OMX_U32 aDestinationState)
2148 {
2149 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE,
2150 (0, "OmxComponentBase : DoStateSet IN : iState (%i) aDestinationState (%i)", iState, aDestinationState));
2151
2152 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
2153 OMX_U32 ii;
2154
2155 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*) iOmxComponent.pComponentPrivate;
2156
2157 if (OMX_StateLoaded == aDestinationState)
2158 {
2159 switch (iState)
2160 {
2161 case OMX_StateInvalid:
2162 {
2163 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2164 return OMX_ErrorInvalidState;
2165 }
2166
2167 case OMX_StateWaitForResources:
2168 {
2169 iState = OMX_StateLoaded;
2170 }
2171 break;
2172
2173 case OMX_StateLoaded:
2174 {
2175 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error same state"));
2176 return OMX_ErrorSameState;
2177 }
2178
2179 case OMX_StateIdle:
2180 {
2181 for (ii = 0; ii < iNumPorts; ii++)
2182 {
2183 if (PORT_IS_ENABLED(ipPorts[ii]) && PORT_IS_POPULATED(ipPorts[ii]))
2184 {
2185 iStateTransitionFlag = OMX_TRUE;
2186 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet Waiting port to be de-populated"));
2187 return OMX_ErrorNone;
2188 }
2189 }
2190
2191 iState = OMX_StateLoaded;
2192
2193 iNumInputBuffer = 0;
2194 iOutBufferCount = 0;
2195 iPartialFrameAssembly = OMX_FALSE;
2196 iEndofStream = OMX_FALSE;
2197 iIsInputBufferEnded = OMX_TRUE;
2198 iNewOutBufRequired = OMX_TRUE;
2199 iNewInBufferRequired = OMX_TRUE;
2200 iFirstFragment = OMX_FALSE;
2201
2202 pOpenmaxAOType->ComponentDeInit();
2203 }
2204 break;
2205
2206 default:
2207 {
2208 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error incorrect state"));
2209 return OMX_ErrorIncorrectStateTransition;
2210 }
2211 }
2212 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2213 return OMX_ErrorNone;
2214 }
2215
2216 if (OMX_StateWaitForResources == aDestinationState)
2217 {
2218 switch (iState)
2219 {
2220 case OMX_StateInvalid:
2221 {
2222 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2223 return OMX_ErrorInvalidState;
2224 }
2225
2226 case OMX_StateLoaded:
2227 {
2228 iState = OMX_StateWaitForResources;
2229 }
2230 break;
2231
2232 case OMX_StateWaitForResources:
2233 {
2234 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error same state"));
2235 return OMX_ErrorSameState;
2236 }
2237
2238 default:
2239 {
2240 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error incorrect state"));
2241 return OMX_ErrorIncorrectStateTransition;
2242 }
2243 }
2244 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2245 return OMX_ErrorNone;
2246 }
2247
2248 if (OMX_StateIdle == aDestinationState)
2249 {
2250 switch (iState)
2251 {
2252 case OMX_StateInvalid:
2253 {
2254 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2255 return OMX_ErrorInvalidState;
2256 }
2257
2258 case OMX_StateWaitForResources:
2259 {
2260 iState = OMX_StateIdle;
2261 }
2262 break;
2263
2264 case OMX_StateLoaded:
2265 {
2266 for (ii = 0; ii < iNumPorts; ii++)
2267 {
2268 if (PORT_IS_ENABLED(ipPorts[ii]) && !PORT_IS_POPULATED(ipPorts[ii]))
2269 {
2270 iStateTransitionFlag = OMX_TRUE;
2271 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet Waiting port to be populated"));
2272 return OMX_ErrorNone;
2273 }
2274 }
2275
2276 iState = OMX_StateIdle;
2277
2278 //Used in case of partial frame assembly
2279 if (!ipInputCurrBuffer)
2280 {
2281 //Keep the size of temp buffer double to be on safer side
2282 iInputCurrBufferSize = 2 * sizeof(uint8) * (ipPorts[OMX_PORT_INPUTPORT_INDEX]->PortParam.nBufferSize);
2283
2284 ipInputCurrBuffer = (OMX_U8*) oscl_malloc(iInputCurrBufferSize);
2285 if (NULL == ipInputCurrBuffer)
2286 {
2287 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error insufficient resources"));
2288 return OMX_ErrorInsufficientResources;
2289 }
2290
2291 }
2292
2293 //Used when the buffers are not marked with EndOfFrame flag
2294 if (!ipTempInputBuffer)
2295 {
2296 ipTempInputBuffer = (OMX_U8*) oscl_malloc(iInputCurrBufferSize);
2297 if (NULL == ipTempInputBuffer)
2298 {
2299 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error insufficient resources"));
2300 return OMX_ErrorInsufficientResources;
2301 }
2302 }
2303
2304 iTempInputBufferLength = 0;
2305 iTempConsumedLength = 0;
2306 iInputBufferRemainingBytes = 0;
2307 }
2308 break;
2309
2310 case OMX_StateIdle:
2311 {
2312 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error same state"));
2313 return OMX_ErrorSameState;
2314 }
2315
2316 //Both the below cases have same body
2317 case OMX_StateExecuting:
2318 case OMX_StatePause:
2319 {
2320 SetNumBufferFlush(iNumPorts, -1, 0);
2321 SetPortFlushFlag(iNumPorts, -1, OMX_TRUE);
2322
2323 ComponentPortType* pInPort = (ComponentPortType*) ipPorts[OMX_PORT_INPUTPORT_INDEX];
2324
2325 //Return all the buffers if still occupied
2326 QueueType* pInputQueue = ipPorts[OMX_PORT_INPUTPORT_INDEX]->pBufferQueue;
2327
2328 while ((iNumInputBuffer > 0) && (GetQueueNumElem(pInputQueue) > 0))
2329 {
2330 FlushPort(OMX_PORT_INPUTPORT_INDEX);
2331 }
2332
2333 // if a buffer was previously dequeued, it wasnt freed in above loop. return it now
2334 if (iNumInputBuffer > 0)
2335 {
2336 ipInputBuffer->nFilledLen = 0;
2337 ReturnInputBuffer(ipInputBuffer, pInPort);
2338 iNewInBufferRequired = OMX_TRUE;
2339 iIsInputBufferEnded = OMX_TRUE;
2340 iInputCurrLength = 0;
2341 ipInputBuffer = NULL;
2342 }
2343
2344 //Return all the buffers if still occupied
2345 while ((iNumInputBuffer > 0))
2346 {
2347 FlushPort(OMX_PORT_INPUTPORT_INDEX);
2348 }
2349
2350 //Return all the output buffers if still occupied
2351 while (iOutBufferCount > 0)
2352 {
2353 FlushPort(OMX_PORT_OUTPUTPORT_INDEX);
2354 }
2355
2356 //Call the reset funstion here to reset the flags and buffer length variables
2357 ResetAfterFlush(OMX_PORT_ALLPORT_INDEX);
2358
2359
2360 SetPortFlushFlag(iNumPorts, -1, OMX_FALSE);
2361 SetNumBufferFlush(iNumPorts, -1, 0);
2362
2363 pOpenmaxAOType->ResetComponent();
2364
2365 iState = OMX_StateIdle;
2366 }
2367 break;
2368
2369 default:
2370 {
2371 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error incorrect state"));
2372 return OMX_ErrorIncorrectStateTransition;
2373 }
2374 }
2375
2376 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2377 return ErrorType;
2378 }
2379
2380 if (OMX_StatePause == aDestinationState)
2381 {
2382 switch (iState)
2383 {
2384 case OMX_StateInvalid:
2385 {
2386 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2387 return OMX_ErrorInvalidState;
2388 }
2389
2390 case OMX_StatePause:
2391 {
2392 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error same state"));
2393 return OMX_ErrorSameState;
2394 }
2395
2396 //Falling through to the next case
2397 case OMX_StateExecuting:
2398 case OMX_StateIdle:
2399 {
2400 iState = OMX_StatePause;
2401 }
2402 break;
2403
2404 default:
2405 {
2406 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error incorrect state"));
2407 return OMX_ErrorIncorrectStateTransition;
2408 }
2409 }
2410
2411 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2412 return OMX_ErrorNone;
2413 }
2414
2415 if (OMX_StateExecuting == aDestinationState)
2416 {
2417 switch (iState)
2418 {
2419 case OMX_StateInvalid:
2420 {
2421 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2422 return OMX_ErrorInvalidState;
2423 }
2424
2425 case OMX_StateIdle:
2426 {
2427 iState = OMX_StateExecuting;
2428 }
2429 break;
2430
2431 case OMX_StatePause:
2432 {
2433 iState = OMX_StateExecuting;
2434 /* A trigger to start the processing of buffers when component
2435 * transitions to executing from pause, as it is already
2436 * holding the required buffers
2437 */
2438 RunIfNotReady();
2439 }
2440 break;
2441
2442 case OMX_StateExecuting:
2443 {
2444 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error same state"));
2445 return OMX_ErrorSameState;
2446 }
2447
2448 default:
2449 {
2450 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error incorrect state"));
2451 return OMX_ErrorIncorrectStateTransition;
2452 }
2453 }
2454
2455 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2456 return OMX_ErrorNone;
2457 }
2458
2459 if (OMX_StateInvalid == aDestinationState)
2460 {
2461 switch (iState)
2462 {
2463 case OMX_StateInvalid:
2464 {
2465 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2466 return OMX_ErrorInvalidState;
2467 }
2468
2469 default:
2470 {
2471 iState = OMX_StateInvalid;
2472 if (iIsInit != OMX_FALSE)
2473 {
2474 pOpenmaxAOType->ComponentDeInit();
2475 }
2476 }
2477 break;
2478 }
2479
2480 if (iIsInit != OMX_FALSE)
2481 {
2482 pOpenmaxAOType->ComponentDeInit();
2483 }
2484
2485 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet error invalid state"));
2486 return OMX_ErrorInvalidState;
2487 }
2488
2489 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : DoStateSet OUT"));
2490 return OMX_ErrorNone;
2491 }
2492
2493
2494
BaseComponentEmptyThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)2495 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentEmptyThisBuffer(
2496 OMX_IN OMX_HANDLETYPE hComponent,
2497 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
2498 {
2499
2500 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate;
2501 OMX_ERRORTYPE Status;
2502
2503 if (NULL == pOpenmaxAOType)
2504 {
2505 return OMX_ErrorBadParameter;
2506 }
2507
2508 Status = pOpenmaxAOType->EmptyThisBuffer(hComponent, pBuffer);
2509
2510 return Status;
2511
2512 }
2513
2514
EmptyThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)2515 OMX_ERRORTYPE OmxComponentBase::EmptyThisBuffer(
2516 OMX_IN OMX_HANDLETYPE hComponent,
2517 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
2518
2519 {
2520 OSCL_UNUSED_ARG(hComponent);
2521 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer IN"));
2522 //Do not queue buffers if component is in invalid state
2523 if (OMX_StateInvalid == iState)
2524 {
2525 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error invalid state"));
2526 return OMX_ErrorInvalidState;
2527 }
2528
2529 if ((OMX_StateIdle == iState) || (OMX_StatePause == iState) || (OMX_StateExecuting == iState))
2530 {
2531 OMX_U32 PortIndex;
2532 QueueType* pInputQueue;
2533 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
2534
2535 PortIndex = pBuffer->nInputPortIndex;
2536
2537 //Validate the port index & Queue the buffers available only at the input port
2538 if (PortIndex >= iNumPorts ||
2539 ipPorts[PortIndex]->PortParam.eDir != OMX_DirInput)
2540 {
2541 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error bad port index"));
2542 return OMX_ErrorBadPortIndex;
2543 }
2544
2545 //Port should be in enabled state before accepting buffers
2546 if (!PORT_IS_ENABLED(ipPorts[PortIndex]))
2547 {
2548 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error incorrect state"));
2549 return OMX_ErrorIncorrectStateOperation;
2550 }
2551
2552 /* The number of buffers the component can queue at a time
2553 * depends upon the number of buffers allocated/assigned on the input port
2554 */
2555 if (iNumInputBuffer == (ipPorts[PortIndex]->NumAssignedBuffers))
2556 {
2557 RunIfNotReady();
2558 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error incorrect state"));
2559 return OMX_ErrorIncorrectStateOperation;
2560 }
2561
2562 //Finally after passing all the conditions, queue the buffer in Input queue
2563 pInputQueue = ipPorts[PortIndex]->pBufferQueue;
2564
2565 if ((ErrorType = CheckHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone)
2566 {
2567 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error check header failed"));
2568 return ErrorType;
2569 }
2570
2571 if (OMX_ErrorNone != Queue(pInputQueue, pBuffer))
2572 {
2573 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error, Queuing buffer failed"));
2574 return OMX_ErrorInsufficientResources;
2575 }
2576 iNumInputBuffer++;
2577
2578 //Signal the AO about the incoming buffer
2579 RunIfNotReady();
2580 }
2581 else
2582 {
2583 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer error incorrect state"));
2584 //This macro is not accepted in any other state except the three mentioned above
2585 return OMX_ErrorIncorrectStateOperation;
2586 }
2587
2588 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : EmptyThisBuffer OUT"));
2589
2590 return OMX_ErrorNone;
2591 }
2592
2593
BaseComponentFillThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)2594 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentFillThisBuffer(
2595 OMX_IN OMX_HANDLETYPE hComponent,
2596 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
2597 {
2598
2599 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
2600 OMX_ERRORTYPE Status;
2601
2602 if (NULL == pOpenmaxAOType)
2603 {
2604 return OMX_ErrorBadParameter;
2605 }
2606
2607 Status = pOpenmaxAOType->FillThisBuffer(hComponent, pBuffer);
2608
2609 return Status;
2610 }
2611
FillThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)2612 OMX_ERRORTYPE OmxComponentBase::FillThisBuffer(
2613 OMX_IN OMX_HANDLETYPE hComponent,
2614 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
2615
2616 {
2617 OSCL_UNUSED_ARG(hComponent);
2618 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer IN"));
2619
2620 OMX_U32 PortIndex;
2621
2622 QueueType* pOutputQueue;
2623 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
2624
2625 PortIndex = pBuffer->nOutputPortIndex;
2626 //Validate the port index & Queue the buffers available only at the output port
2627 if (PortIndex >= iNumPorts ||
2628 ipPorts[PortIndex]->PortParam.eDir != OMX_DirOutput)
2629 {
2630 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer error bad port index"));
2631 return OMX_ErrorBadPortIndex;
2632 }
2633
2634 pOutputQueue = ipPorts[PortIndex]->pBufferQueue;
2635 if (iState != OMX_StateExecuting &&
2636 iState != OMX_StatePause &&
2637 iState != OMX_StateIdle)
2638 {
2639 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer error invalid state"));
2640 return OMX_ErrorInvalidState;
2641 }
2642
2643 //Port should be in enabled state before accepting buffers
2644 if (!PORT_IS_ENABLED(ipPorts[PortIndex]))
2645 {
2646 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer error incorrect state"));
2647 return OMX_ErrorIncorrectStateOperation;
2648 }
2649
2650 if ((ErrorType = CheckHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone)
2651 {
2652 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer error check header failed"));
2653 return ErrorType;
2654 }
2655
2656 //Queue the buffer in output queue
2657 if (OMX_ErrorNone != Queue(pOutputQueue, pBuffer))
2658 {
2659 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer error, queuing buffer failed"));
2660 return OMX_ErrorInsufficientResources;
2661 }
2662
2663 iOutBufferCount++;
2664
2665 //Signal the AO about the incoming buffer
2666 RunIfNotReady();
2667
2668 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : FillThisBuffer OUT"));
2669
2670 return OMX_ErrorNone;
2671 }
2672
2673
2674 /** This is the central function for buffers processing and decoding.
2675 * It is called through the Run() of active object when the component is in executing state
2676 * and is signalled each time a new buffer is available on the given ports
2677 * This function will process the input buffers & return output buffers
2678 */
2679
BufferMgmtFunction()2680 OSCL_EXPORT_REF void OmxComponentBase::BufferMgmtFunction()
2681 {
2682 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction IN"));
2683
2684 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
2685 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*) iOmxComponent.pComponentPrivate;
2686
2687 QueueType* pInputQueue = ipPorts[OMX_PORT_INPUTPORT_INDEX]->pBufferQueue;
2688 QueueType* pOutputQueue = ipPorts[OMX_PORT_OUTPUTPORT_INDEX]->pBufferQueue;
2689 ComponentPortType* pInPort = (ComponentPortType*) ipPorts[OMX_PORT_INPUTPORT_INDEX];
2690
2691 OMX_BOOL PartialFrameReturn, Status;
2692
2693 /* Don't dequeue any further buffer after endofstream buffer has been dequeued
2694 * till we send the callback and reset the flag back to false
2695 */
2696 if (OMX_FALSE == iEndofStream)
2697 {
2698 //More than one frame can't be dequeued in case of outbut blocked
2699 if ((OMX_TRUE == iIsInputBufferEnded) && (GetQueueNumElem(pInputQueue) > 0))
2700 {
2701 ipInputBuffer = (OMX_BUFFERHEADERTYPE*) DeQueue(pInputQueue);
2702 if (NULL == ipInputBuffer)
2703 {
2704 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction ERROR DeQueue() returned NULL"));
2705 return;
2706 }
2707
2708 if (ipInputBuffer->nFlags & OMX_BUFFERFLAG_EOS)
2709 {
2710 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction EndOfStream arrived"));
2711 iEndofStream = OMX_TRUE;
2712 }
2713
2714 // To do: test this second condition newly added
2715 if ((ipInputBuffer->nFilledLen != 0) ||
2716 ((OMX_TRUE == iEndofStream) && (OMX_TRUE == iPartialFrameAssembly)))
2717 {
2718 // if we already started assembling frames, it means
2719 // we didn't get marker bit yet, but may be getting it
2720 // when the first frame assembly is over
2721 // If so, we'll set iEndOfFrameFlag to TRUE in BufferMgmtWithoutMarker assembly
2722 if (0 == iFrameCount && iPartialFrameAssembly == OMX_FALSE)
2723 {
2724 //Set the marker flag (iEndOfFrameFlag) if first frame has the EndOfFrame flag marked.
2725 if ((ipInputBuffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) != 0)
2726 {
2727 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction EndOfFrame flag present"));
2728 iEndOfFrameFlag = OMX_TRUE;
2729 }
2730
2731 /* This routine will allocate the internal input buffers that are required to
2732 * assemble partial frames in both with and without marker mode for H.263 decoder component.
2733 * The size of partial frame assembly buffer will be in proportion to the W & H of the clip.
2734 * We require maximum of first 12 bytes of data (this will be checked */
2735
2736
2737 if (OMX_ErrorNone != pOpenmaxAOType->ReAllocatePartialAssemblyBuffers(ipInputBuffer))
2738 {
2739 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction Error Memory Re-allocation of partial frame assembly buffer failed, OUT"));
2740 return;
2741 }
2742
2743 }
2744
2745 /* This condition will be true if OMX_BUFFERFLAG_ENDOFFRAME flag is
2746 * not marked in all the input buffers
2747 */
2748 if (!iEndOfFrameFlag)
2749 {
2750 Status = pOpenmaxAOType->BufferMgmtWithoutMarker();
2751 if (OMX_FALSE == Status)
2752 {
2753 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction OUT"));
2754 return;
2755 }
2756
2757 }
2758 //If OMX_BUFFERFLAG_ENDOFFRAME flag is marked, come here
2759 else
2760 {
2761 if (iPVCapabilityFlags.iOMXComponentUsesFullAVCFrames && (OMX_PORT_INPUTPORT_INDEX == iCompressedFormatPortNum))
2762 {
2763 // since full frames are sent, there will never be partial frame assembly,
2764 // but we do need to parse the frames into NALs to send to the decoder
2765 PartialFrameReturn = ParseFullAVCFramesIntoNALs(ipInputBuffer);
2766 }
2767 else
2768 {
2769 PartialFrameReturn = AssemblePartialFrames(ipInputBuffer);
2770 }
2771 if (OMX_FALSE == PartialFrameReturn)
2772 {
2773 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction OUT"));
2774 return;
2775 }
2776 iIsInputBufferEnded = OMX_FALSE;
2777
2778 ipTargetComponent = (OMX_COMPONENTTYPE*) ipInputBuffer->hMarkTargetComponent;
2779
2780 iTargetMarkData = ipInputBuffer->pMarkData;
2781 if (ipTargetComponent == (OMX_COMPONENTTYPE*) pHandle)
2782 {
2783 (*(ipCallbacks->EventHandler))
2784 (pHandle,
2785 iCallbackData,
2786 OMX_EventMark,
2787 1,
2788 0,
2789 ipInputBuffer->pMarkData);
2790 }
2791 }
2792
2793 /* This routine will take care of any audio component specific tasks like
2794 -> Reading the input buffer timestamp
2795 -> Checking for Silence insertion
2796 -> Repostioning implementation etc
2797 */
2798 if (OMX_TRUE == iIsAudioComponent)
2799 {
2800 pOpenmaxAOType->SyncWithInputTimestamp();
2801 }
2802
2803
2804 } //end braces for if (ipInputBuffer->nFilledLen != 0)
2805 else
2806 {
2807 //Reschedule the AO if there are more buffers in queue
2808 if ((GetQueueNumElem(pInputQueue) > 0) &&
2809 ((GetQueueNumElem(pOutputQueue) > 0) || (OMX_FALSE == iNewOutBufRequired)))
2810 {
2811 RunIfNotReady();
2812 }
2813
2814 ReturnInputBuffer(ipInputBuffer, pInPort);
2815 ipInputBuffer = NULL;
2816 }
2817
2818 } //end braces for if ((OMX_TRUE == iIsInputBufferEnded) && (GetQueueNumElem(pInputQueue) > 0))
2819 } //if (OMX_FALSE == iEndofStream)
2820
2821
2822 //Component specific Encode/Decode routine
2823 pOpenmaxAOType->ProcessData();
2824
2825 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtFunction OUT"));
2826 return;
2827 }
2828
2829
BufferMgmtWithoutMarker()2830 OSCL_EXPORT_REF OMX_BOOL OmxComponentBase::BufferMgmtWithoutMarker()
2831 {
2832 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker IN"));
2833
2834 ComponentPortType* pInPort = (ComponentPortType*) ipPorts[OMX_PORT_INPUTPORT_INDEX];
2835 QueueType* pInputQueue = ipPorts[OMX_PORT_INPUTPORT_INDEX]->pBufferQueue;
2836 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*) iOmxComponent.pComponentPrivate;
2837
2838
2839 /* If the buffer has enough data or EndofStream is true, and
2840 * partial frame assembly is not turned on, process the buffer independently */
2841
2842 if (((ipInputBuffer->nFilledLen >= (iInputCurrBufferSize >> 1)) || (iEndofStream == OMX_TRUE))
2843 && (OMX_FALSE == iPartialFrameAssembly))
2844 {
2845 //This is a new piece of buffer, process it independently
2846 if (iNumInputBuffer > 0)
2847 {
2848 iInputCurrLength = ipInputBuffer->nFilledLen;
2849 ipFrameDecodeBuffer = ipInputBuffer->pBuffer + ipInputBuffer->nOffset;
2850 iFrameTimestamp = ipInputBuffer->nTimeStamp;
2851
2852 /* Components not implementing ComponentBufferMgmtWithoutMarker(), will reset
2853 * iIsInputBufferEnded flag in the below routine */
2854 pOpenmaxAOType->ProcessInBufferFlag();
2855 }
2856 else
2857 {
2858 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker OUT"));
2859 return OMX_FALSE; // nothing to decode
2860 }
2861 }
2862 else
2863 {
2864 if (!iPartialFrameAssembly)
2865 {
2866 iInputCurrLength = 0;
2867 ipFrameDecodeBuffer = ipInputCurrBuffer;
2868 }
2869
2870 while (iNumInputBuffer > 0)
2871 {
2872 int32 BytesToCopy = ipInputBuffer->nFilledLen;
2873
2874 if ((iInputCurrLength + BytesToCopy) > iInputCurrBufferSize)
2875 {
2876 // allocate new partial frame buffers
2877 OMX_U8* pTempNewBuffer = NULL;
2878 pTempNewBuffer = (OMX_U8*) oscl_malloc(sizeof(OMX_U8) * (iInputCurrLength + BytesToCopy));
2879
2880 if (NULL != pTempNewBuffer)
2881 {
2882 // copy contents of the old buffer into the new one
2883 oscl_memcpy(pTempNewBuffer, ipTempInputBuffer, iTempInputBufferLength);
2884 // free the old buffer
2885 if (ipTempInputBuffer)
2886 {
2887 oscl_free(ipTempInputBuffer);
2888 }
2889 // assign new one
2890 ipTempInputBuffer = pTempNewBuffer;
2891
2892 pTempNewBuffer = NULL;
2893 pTempNewBuffer = (OMX_U8*) oscl_malloc(sizeof(OMX_U8) * (iInputCurrLength + BytesToCopy));
2894
2895 // in the event that new buffer cannot be allocated
2896 if (NULL == pTempNewBuffer)
2897 {
2898 // copy into what space is available, and let the decoder complain
2899 BytesToCopy = iInputCurrLength - iInputCurrBufferSize;
2900 }
2901 else
2902 {
2903 // copy contents of the old buffer into the new one
2904 oscl_memcpy(pTempNewBuffer, ipInputCurrBuffer, iInputCurrBufferSize);
2905 // free the old buffer
2906 if (ipInputCurrBuffer)
2907 {
2908 oscl_free(ipInputCurrBuffer);
2909 }
2910 // assign new memory location
2911 ipInputCurrBuffer = pTempNewBuffer;
2912 iInputCurrBufferSize = (iInputCurrLength + BytesToCopy);
2913 ipFrameDecodeBuffer = ipInputCurrBuffer + iInputCurrLength;
2914 }
2915 }
2916 //No memory to allocate ipTempInputBuffer
2917 else
2918 {
2919 // copy into what space is available, and let the decoder complain
2920 BytesToCopy = iInputCurrLength - iInputCurrBufferSize;
2921 }
2922 }
2923
2924 oscl_memcpy(ipFrameDecodeBuffer, (ipInputBuffer->pBuffer + ipInputBuffer->nOffset), BytesToCopy);
2925 ipFrameDecodeBuffer += ipInputBuffer->nFilledLen; // move the ptr
2926 iInputCurrLength += BytesToCopy;
2927
2928 iFrameTimestamp = ipInputBuffer->nTimeStamp;
2929
2930 // check if we've encountered end of frame flag while trying to assemble the very first frame
2931 if ((0 == iFrameCount) && ((ipInputBuffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) != 0))
2932 {
2933 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker EndOfFrameFlag finally arrived"));
2934 iEndOfFrameFlag = OMX_TRUE;
2935 }
2936
2937 if ((iInputCurrLength >= (iInputCurrBufferSize >> 1))
2938 || (OMX_TRUE == iEndofStream) || (OMX_TRUE == iEndOfFrameFlag))
2939 {
2940 break;
2941 }
2942
2943 //Set the filled len to zero to indicate buffer is fully consumed
2944 ipInputBuffer->nFilledLen = 0;
2945 ReturnInputBuffer(ipInputBuffer, pInPort);
2946 ipInputBuffer = NULL;
2947
2948 if (iNumInputBuffer > 0)
2949 {
2950 ipInputBuffer = (OMX_BUFFERHEADERTYPE*) DeQueue(pInputQueue);
2951 if (NULL == ipInputBuffer)
2952 {
2953 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker Error, Input buffer Dequeue returned NULL"));
2954 return OMX_FALSE;
2955 }
2956
2957 if (ipInputBuffer->nFlags & OMX_BUFFERFLAG_EOS)
2958 {
2959 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker EndOfStream arrived"));
2960 iEndofStream = OMX_TRUE;
2961 }
2962 }
2963 }
2964
2965 if (iEndOfFrameFlag)
2966 {
2967 // if we have encountered end of frame, 1st frame has been assembled
2968 // and we can switch to "end of frame flag" mode
2969 iIsInputBufferEnded = OMX_FALSE;
2970 iNewInBufferRequired = OMX_FALSE;
2971 ipFrameDecodeBuffer = ipInputCurrBuffer; // rewind buffer ptr to beginning of inputcurrbuffer
2972 iPartialFrameAssembly = OMX_FALSE;
2973 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker Found end of frame flag - OUT"));
2974 return OMX_TRUE;
2975
2976 }
2977
2978 if ((((iInputCurrLength + iTempInputBufferLength) < (iInputCurrBufferSize >> 1)))
2979 && (OMX_TRUE != iEndofStream))
2980 {
2981 iPartialFrameAssembly = OMX_TRUE;
2982 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker OUT"));
2983 return OMX_FALSE;
2984 }
2985 else
2986 {
2987 ipFrameDecodeBuffer = ipInputCurrBuffer;
2988 iPartialFrameAssembly = OMX_FALSE;
2989
2990 /* Components not implementing ComponentBufferMgmtWithoutMarker(), will reset
2991 * iIsInputBufferEnded flag in the below routine */
2992 pOpenmaxAOType->ProcessInBufferFlag();
2993 }
2994
2995 }
2996
2997
2998 //Different components may choose to do some extra processing here.
2999 //e.g. video components and also amr component copies the collected data into temp input buffers here.
3000 pOpenmaxAOType->ComponentBufferMgmtWithoutMarker();
3001
3002 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : BufferMgmtWithoutMarker OUT"));
3003 return OMX_TRUE;
3004
3005 }
3006
3007
3008
3009 //Propagate here the buffer mark through output port in case of BufferMgmtWithoutMarker
ComponentBufferMgmtWithoutMarker()3010 OSCL_EXPORT_REF void OmxComponentBase::ComponentBufferMgmtWithoutMarker()
3011 {
3012 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
3013
3014 ipTargetComponent = (OMX_COMPONENTTYPE*) ipInputBuffer->hMarkTargetComponent;
3015
3016 iTargetMarkData = ipInputBuffer->pMarkData;
3017 if (ipTargetComponent == (OMX_COMPONENTTYPE*) pHandle)
3018 {
3019 (*(ipCallbacks->EventHandler))
3020 (pHandle,
3021 iCallbackData,
3022 OMX_EventMark,
3023 1,
3024 0,
3025 ipInputBuffer->pMarkData);
3026 }
3027 }
3028
3029
3030 /* A part of buffer management without marker routine, this function will
3031 * copy the current input buffer into a big temporary buffer, so that
3032 * an incomplete/partial frame is never passed to the decoder library for decode
3033 */
TempInputBufferMgmtWithoutMarker()3034 OSCL_EXPORT_REF void OmxComponentBase::TempInputBufferMgmtWithoutMarker()
3035 {
3036 OMX_COMPONENTTYPE* pHandle = &iOmxComponent;
3037 ComponentPortType* pInPort = (ComponentPortType*) ipPorts[OMX_PORT_INPUTPORT_INDEX];
3038 OMX_U32 TempInputBufferSize = iInputCurrBufferSize;
3039
3040 if (iTempInputBufferLength < (TempInputBufferSize >> 1))
3041 {
3042 oscl_memmove(ipTempInputBuffer, &ipTempInputBuffer[iTempConsumedLength], iTempInputBufferLength);
3043 iIsInputBufferEnded = OMX_TRUE;
3044 iTempConsumedLength = 0;
3045 }
3046
3047 if ((iTempInputBufferLength + iTempConsumedLength + iInputCurrLength)
3048 <= TempInputBufferSize)
3049 {
3050 oscl_memcpy(&ipTempInputBuffer[iTempInputBufferLength + iTempConsumedLength], ipFrameDecodeBuffer, iInputCurrLength);
3051 iTempInputBufferLength += iInputCurrLength;
3052
3053 if (iTempInputBufferLength + (TempInputBufferSize >> 1) <= TempInputBufferSize)
3054 {
3055 iNewInBufferRequired = OMX_TRUE;
3056 }
3057 else
3058 {
3059 iNewInBufferRequired = OMX_FALSE;
3060 }
3061
3062 ipTargetComponent = (OMX_COMPONENTTYPE*) ipInputBuffer->hMarkTargetComponent;
3063
3064 iTargetMarkData = ipInputBuffer->pMarkData;
3065 if (ipTargetComponent == (OMX_COMPONENTTYPE*) pHandle)
3066 {
3067 (*(ipCallbacks->EventHandler))
3068 (pHandle,
3069 iCallbackData,
3070 OMX_EventMark,
3071 1,
3072 0,
3073 ipInputBuffer->pMarkData);
3074 }
3075 ipInputBuffer->nFilledLen = 0;
3076 ReturnInputBuffer(ipInputBuffer, pInPort);
3077 ipInputBuffer = NULL;
3078
3079 }
3080
3081 if (iTempInputBufferLength >= (TempInputBufferSize >> 1))
3082 {
3083 iIsInputBufferEnded = OMX_FALSE;
3084 }
3085 }
3086
3087
3088
Run()3089 OSCL_EXPORT_REF void OmxComponentBase::Run()
3090 {
3091 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : Run IN"));
3092
3093 CoreMessage* pCoreMessage;
3094 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*) iOmxComponent.pComponentPrivate;
3095
3096 //Execute the commands from the message handler queue
3097 if ((GetQueueNumElem(ipCoreDescriptor->pMessageQueue) > 0))
3098 {
3099 pCoreMessage = (CoreMessage*) DeQueue(ipCoreDescriptor->pMessageQueue);
3100
3101 if (OMX_CommandStateSet == pCoreMessage->MessageParam1)
3102 {
3103 if (OMX_StateExecuting == pCoreMessage->MessageParam2)
3104 {
3105 iBufferExecuteFlag = OMX_TRUE;
3106 }
3107 else
3108 {
3109 iBufferExecuteFlag = OMX_FALSE;
3110 }
3111 }
3112
3113 MessageHandler(pCoreMessage);
3114
3115 /* If some allocations/deallocations are required before the state transition
3116 * then queue the command again to be executed later on
3117 */
3118 if (OMX_TRUE == iStateTransitionFlag)
3119 {
3120 if (OMX_ErrorNone != Queue(ipCoreDescriptor->pMessageQueue, pCoreMessage))
3121 {
3122 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : Error, Queue command failed, Run OUT"));
3123 return;
3124 }
3125
3126 // Don't reschedule. Wait for arriving buffers to do it
3127 //RunIfNotReady();
3128 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : Run OUT"));
3129 return;
3130 }
3131
3132 else
3133 {
3134 oscl_free(pCoreMessage);
3135 pCoreMessage = NULL;
3136 }
3137 }
3138
3139 /* If the component is in executing state, call the Buffer management function.
3140 * Stop calling this function as soon as state transition request is received.
3141 */
3142 if ((OMX_TRUE == iBufferExecuteFlag) && (OMX_TRUE != iResizePending))
3143 {
3144 pOpenmaxAOType->BufferMgmtFunction();
3145 }
3146
3147 //Check for any more commands in the message handler queue & schedule them for later
3148 if ((GetQueueNumElem(ipCoreDescriptor->pMessageQueue) > 0))
3149 {
3150 RunIfNotReady();
3151 }
3152
3153
3154 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentBase : Run OUT"));
3155
3156 return;
3157 }
3158
3159
3160 /**************************
3161 AUDIO BASE CLASS ROUTINES
3162 **************************/
OmxComponentAudio()3163 OSCL_EXPORT_REF OmxComponentAudio::OmxComponentAudio()
3164 {
3165 iIsAudioComponent = OMX_TRUE;
3166
3167 }
3168
3169
GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)3170 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentAudio::GetParameter(
3171 OMX_IN OMX_HANDLETYPE hComponent,
3172 OMX_IN OMX_INDEXTYPE nParamIndex,
3173 OMX_INOUT OMX_PTR ComponentParameterStructure)
3174 {
3175 OSCL_UNUSED_ARG(hComponent);
3176
3177 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter IN"));
3178
3179 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
3180 OMX_PARAM_BUFFERSUPPLIERTYPE* pBufSupply;
3181 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef;
3182 OMX_PORT_PARAM_TYPE* pPortDomains;
3183 OMX_U32 PortIndex;
3184 OMX_PARAM_COMPONENTROLETYPE* pCompRole;
3185
3186 OMX_AUDIO_PARAM_PORTFORMATTYPE* pAudioPortFormat;
3187 OMX_AUDIO_PARAM_PCMMODETYPE* pAudioPcmMode;
3188 OMX_AUDIO_PARAM_WMATYPE* pAudioWma;
3189 OMX_AUDIO_PARAM_MP3TYPE* pAudioMp3;
3190 OMX_AUDIO_CONFIG_EQUALIZERTYPE* pAudioEqualizer;
3191 OMX_AUDIO_PARAM_AACPROFILETYPE* pAudioAac;
3192 OMX_AUDIO_PARAM_AMRTYPE* pAudioAmr;
3193
3194 ComponentPortType* pComponentPort;
3195
3196 if (NULL == ComponentParameterStructure)
3197 {
3198 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad parameter"));
3199 return OMX_ErrorBadParameter;
3200 }
3201
3202 switch (nParamIndex)
3203 {
3204 case OMX_IndexParamPriorityMgmt:
3205 {
3206 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*) ComponentParameterStructure;
3207 SetHeader(pPrioMgmt, sizeof(OMX_PRIORITYMGMTTYPE));
3208 pPrioMgmt->nGroupPriority = iGroupPriority;
3209 pPrioMgmt->nGroupID = iGroupID;
3210 }
3211 break;
3212
3213 case OMX_IndexParamAudioInit:
3214 {
3215 SetHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
3216 oscl_memcpy(ComponentParameterStructure, &iPortTypesParam, sizeof(OMX_PORT_PARAM_TYPE));
3217 }
3218 break;
3219
3220
3221 //Following 3 cases have a single common piece of code to be executed
3222 case OMX_IndexParamVideoInit:
3223 case OMX_IndexParamImageInit:
3224 case OMX_IndexParamOtherInit:
3225 {
3226 pPortDomains = (OMX_PORT_PARAM_TYPE*) ComponentParameterStructure;
3227 SetHeader(pPortDomains, sizeof(OMX_PORT_PARAM_TYPE));
3228 pPortDomains->nPorts = 0;
3229 pPortDomains->nStartPortNumber = 0;
3230 }
3231 break;
3232
3233 case OMX_IndexParamAudioPortFormat:
3234 {
3235 pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*) ComponentParameterStructure;
3236 //Added to pass parameter test
3237 if (pAudioPortFormat->nIndex > ipPorts[pAudioPortFormat->nPortIndex]->AudioParam.nIndex)
3238 {
3239 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error index out of range"));
3240 return OMX_ErrorNoMore;
3241 }
3242 SetHeader(pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
3243 if (pAudioPortFormat->nPortIndex <= 1)
3244 {
3245 pComponentPort = (ComponentPortType*) ipPorts[pAudioPortFormat->nPortIndex];
3246 oscl_memcpy(pAudioPortFormat, &pComponentPort->AudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
3247 }
3248 else
3249 {
3250 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3251 return OMX_ErrorBadPortIndex;
3252 }
3253 }
3254 break;
3255
3256 case OMX_IndexParamAudioPcm:
3257 {
3258 pAudioPcmMode = (OMX_AUDIO_PARAM_PCMMODETYPE*) ComponentParameterStructure;
3259 if (pAudioPcmMode->nPortIndex > 1)
3260 {
3261 return OMX_ErrorBadPortIndex;
3262 }
3263 PortIndex = pAudioPcmMode->nPortIndex;
3264 oscl_memcpy(pAudioPcmMode, &ipPorts[PortIndex]->AudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
3265 SetHeader(pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
3266 }
3267 break;
3268
3269 case OMX_IndexParamAudioMp3:
3270 {
3271 pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*) ComponentParameterStructure;
3272 if (pAudioMp3->nPortIndex != iCompressedFormatPortNum)
3273 {
3274 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3275 return OMX_ErrorBadPortIndex;
3276 }
3277 PortIndex = pAudioMp3->nPortIndex;
3278 oscl_memcpy(pAudioMp3, &ipPorts[PortIndex]->AudioMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
3279 SetHeader(pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
3280 }
3281 break;
3282
3283 case OMX_IndexParamAudioWma:
3284 {
3285 pAudioWma = (OMX_AUDIO_PARAM_WMATYPE*) ComponentParameterStructure;
3286 if (pAudioWma->nPortIndex != iCompressedFormatPortNum)
3287 {
3288 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3289 return OMX_ErrorBadPortIndex;
3290 }
3291 PortIndex = pAudioWma->nPortIndex;
3292 oscl_memcpy(pAudioWma, &ipPorts[PortIndex]->AudioWmaParam, sizeof(OMX_AUDIO_PARAM_WMATYPE));
3293 SetHeader(pAudioWma, sizeof(OMX_AUDIO_PARAM_WMATYPE));
3294 }
3295 break;
3296
3297 case OMX_IndexConfigAudioEqualizer:
3298 {
3299 pAudioEqualizer = (OMX_AUDIO_CONFIG_EQUALIZERTYPE*) ComponentParameterStructure;
3300 if (pAudioEqualizer->nPortIndex != iCompressedFormatPortNum)
3301 {
3302 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3303 return OMX_ErrorBadPortIndex;
3304 }
3305 PortIndex = pAudioEqualizer->nPortIndex;
3306 oscl_memcpy(pAudioEqualizer, &ipPorts[PortIndex]->AudioEqualizerType, sizeof(OMX_AUDIO_CONFIG_EQUALIZERTYPE));
3307 SetHeader(pAudioEqualizer, sizeof(OMX_AUDIO_CONFIG_EQUALIZERTYPE));
3308 }
3309 break;
3310
3311 case OMX_IndexParamAudioAac:
3312 {
3313 pAudioAac = (OMX_AUDIO_PARAM_AACPROFILETYPE*) ComponentParameterStructure;
3314 if (pAudioAac->nPortIndex != iCompressedFormatPortNum)
3315 {
3316 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3317 return OMX_ErrorBadPortIndex;
3318 }
3319 PortIndex = pAudioAac->nPortIndex;
3320 oscl_memcpy(pAudioAac, &ipPorts[PortIndex]->AudioAacParam, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
3321 SetHeader(pAudioAac, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
3322 }
3323 break;
3324
3325 case OMX_IndexParamAudioAmr:
3326 {
3327 pAudioAmr = (OMX_AUDIO_PARAM_AMRTYPE*) ComponentParameterStructure;
3328 if (pAudioAmr->nPortIndex != iCompressedFormatPortNum)
3329 {
3330 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3331 return OMX_ErrorBadPortIndex;
3332 }
3333 PortIndex = pAudioAmr->nPortIndex;
3334 oscl_memcpy(pAudioAmr, &ipPorts[PortIndex]->AudioAmrParam, sizeof(OMX_AUDIO_PARAM_AMRTYPE));
3335 SetHeader(pAudioAmr, sizeof(OMX_AUDIO_PARAM_AMRTYPE));
3336 }
3337 break;
3338
3339 case OMX_IndexParamPortDefinition:
3340 {
3341 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
3342 PortIndex = pPortDef->nPortIndex;
3343 if (PortIndex >= iNumPorts)
3344 {
3345 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3346 return OMX_ErrorBadPortIndex;
3347 }
3348 oscl_memcpy(pPortDef, &ipPorts[PortIndex]->PortParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
3349 }
3350 break;
3351
3352 case OMX_IndexParamCompBufferSupplier:
3353 {
3354 pBufSupply = (OMX_PARAM_BUFFERSUPPLIERTYPE*) ComponentParameterStructure;
3355 PortIndex = pBufSupply->nPortIndex;
3356 if (PortIndex >= iNumPorts)
3357 {
3358 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error bad port index"));
3359 return OMX_ErrorBadPortIndex;
3360 }
3361 SetHeader(pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
3362
3363 if (OMX_DirInput == ipPorts[PortIndex]->PortParam.eDir)
3364 {
3365 pBufSupply->eBufferSupplier = OMX_BufferSupplyUnspecified;
3366 }
3367 else
3368 {
3369 SetHeader(pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
3370 pBufSupply->eBufferSupplier = OMX_BufferSupplyUnspecified;
3371 }
3372 }
3373 break;
3374
3375 case(OMX_INDEXTYPE) PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
3376 {
3377 PV_OMXComponentCapabilityFlagsType *pCap_flags = (PV_OMXComponentCapabilityFlagsType *) ComponentParameterStructure;
3378 if (NULL == pCap_flags)
3379 {
3380 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error pCap_flags NULL"));
3381 return OMX_ErrorBadParameter;
3382 }
3383 oscl_memcpy(pCap_flags, &iPVCapabilityFlags, sizeof(iPVCapabilityFlags));
3384
3385 }
3386 break;
3387 case OMX_IndexParamStandardComponentRole:
3388 {
3389 pCompRole = (OMX_PARAM_COMPONENTROLETYPE*) ComponentParameterStructure;
3390 SetHeader(pCompRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
3391 oscl_strncpy((OMX_STRING)pCompRole->cRole, (OMX_STRING)iComponentRole, OMX_MAX_STRINGNAME_SIZE);
3392 }
3393 break;
3394
3395 default:
3396 {
3397 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter error Unsupported Index"));
3398 return OMX_ErrorUnsupportedIndex;
3399 }
3400 }
3401
3402 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : GetParameter OUT"));
3403
3404 return OMX_ErrorNone;
3405
3406 }
3407
3408
SetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_IN OMX_PTR ComponentParameterStructure)3409 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentAudio::SetParameter(
3410 OMX_IN OMX_HANDLETYPE hComponent,
3411 OMX_IN OMX_INDEXTYPE nParamIndex,
3412 OMX_IN OMX_PTR ComponentParameterStructure)
3413 {
3414 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter IN"));
3415
3416 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
3417 OMX_AUDIO_PARAM_PORTFORMATTYPE* pAudioPortFormat;
3418 OMX_AUDIO_PARAM_PCMMODETYPE* pAudioPcmMode;
3419 OMX_PARAM_BUFFERSUPPLIERTYPE* pBufSupply;
3420 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef ;
3421 OMX_PARAM_COMPONENTROLETYPE* pCompRole;
3422 ComponentPortType* pComponentPort;
3423
3424 OMX_AUDIO_PARAM_WMATYPE* pAudioWma;
3425 OMX_AUDIO_PARAM_MP3TYPE* pAudioMp3;
3426 OMX_AUDIO_CONFIG_EQUALIZERTYPE* pAudioEqualizer;
3427 OMX_AUDIO_PARAM_AACPROFILETYPE* pAudioAac;
3428 OMX_AUDIO_PARAM_AMRTYPE* pAudioAmr;
3429
3430 OMX_U32 PortIndex;
3431 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
3432 OmxComponentAudio* pOpenmaxAOType = (OmxComponentAudio*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
3433
3434
3435 if (NULL == ComponentParameterStructure)
3436 {
3437 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error bad parameter"));
3438 return OMX_ErrorBadParameter;
3439 }
3440
3441 switch (nParamIndex)
3442 {
3443 case OMX_IndexParamAudioInit:
3444 {
3445 /*Check Structure Header*/
3446 CheckHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
3447 if (ErrorType != OMX_ErrorNone)
3448 {
3449 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error audio init failed"));
3450 return ErrorType;
3451 }
3452 oscl_memcpy(&iPortTypesParam, ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
3453 }
3454 break;
3455
3456 case OMX_IndexParamAudioPortFormat:
3457 {
3458 pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*) ComponentParameterStructure;
3459 PortIndex = pAudioPortFormat->nPortIndex;
3460 /*Check Structure Header and verify component state*/
3461 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
3462 if (ErrorType != OMX_ErrorNone)
3463 {
3464 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3465 return ErrorType;
3466 }
3467 if (PortIndex <= 1)
3468 {
3469 pComponentPort = (ComponentPortType*) ipPorts[PortIndex];
3470 oscl_memcpy(&pComponentPort->AudioParam, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
3471 }
3472 else
3473 {
3474 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error bad port index"));
3475 return OMX_ErrorBadPortIndex;
3476 }
3477 }
3478 break;
3479
3480 case OMX_IndexParamAudioPcm:
3481 {
3482 pAudioPcmMode = (OMX_AUDIO_PARAM_PCMMODETYPE*) ComponentParameterStructure;
3483 PortIndex = pAudioPcmMode->nPortIndex;
3484 /*Check Structure Header and verify component State*/
3485 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
3486 oscl_memcpy(&ipPorts[PortIndex]->AudioPcmMode, pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
3487 }
3488 break;
3489
3490 case OMX_IndexParamAudioMp3:
3491 {
3492 pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*) ComponentParameterStructure;
3493 PortIndex = pAudioMp3->nPortIndex;
3494 /*Check Structure Header and verify component state*/
3495 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
3496 if (ErrorType != OMX_ErrorNone)
3497 {
3498 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3499 return ErrorType;
3500 }
3501 oscl_memcpy(&ipPorts[PortIndex]->AudioMp3Param, pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
3502 }
3503 break;
3504
3505 case OMX_IndexParamAudioWma:
3506 {
3507
3508
3509 pAudioWma = (OMX_AUDIO_PARAM_WMATYPE*) ComponentParameterStructure;
3510 PortIndex = pAudioWma->nPortIndex;
3511 /*Check Structure Header and verify component state*/
3512 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioWma, sizeof(OMX_AUDIO_PARAM_WMATYPE));
3513 if (ErrorType != OMX_ErrorNone)
3514 {
3515 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3516 return ErrorType;
3517 }
3518 oscl_memcpy(&ipPorts[PortIndex]->AudioWmaParam, pAudioWma, sizeof(OMX_AUDIO_PARAM_WMATYPE));
3519 }
3520 break;
3521
3522 case OMX_IndexConfigAudioEqualizer:
3523 {
3524 pAudioEqualizer = (OMX_AUDIO_CONFIG_EQUALIZERTYPE*) ComponentParameterStructure;
3525 PortIndex = pAudioEqualizer->nPortIndex;
3526 /*Check Structure Header and verify component state*/
3527 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioEqualizer, sizeof(OMX_AUDIO_CONFIG_EQUALIZERTYPE));
3528 if (ErrorType != OMX_ErrorNone)
3529 {
3530 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3531 return ErrorType;
3532 }
3533 oscl_memcpy(&ipPorts[PortIndex]->AudioEqualizerType, pAudioEqualizer, sizeof(OMX_AUDIO_CONFIG_EQUALIZERTYPE));
3534 }
3535 break;
3536
3537 case OMX_IndexParamAudioAac:
3538 {
3539 OMX_BOOL AacPlusFlag = OMX_TRUE;
3540
3541 pAudioAac = (OMX_AUDIO_PARAM_AACPROFILETYPE*) ComponentParameterStructure;
3542 PortIndex = pAudioAac->nPortIndex;
3543 /*Check Structure Header and verify component state*/
3544 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioAac, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
3545 if (ErrorType != OMX_ErrorNone)
3546 {
3547 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3548 return ErrorType;
3549 }
3550 oscl_memcpy(&ipPorts[PortIndex]->AudioAacParam, pAudioAac, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
3551
3552 if ((ipPorts[PortIndex]->AudioAacParam.eAACProfile == OMX_AUDIO_AACObjectHE)
3553 || (ipPorts[PortIndex]->AudioAacParam.eAACProfile == OMX_AUDIO_AACObjectHE_PS))
3554 {
3555 AacPlusFlag = OMX_TRUE;
3556 }
3557 else
3558 {
3559 AacPlusFlag = OMX_FALSE;
3560 }
3561
3562 pOpenmaxAOType->UpdateAACPlusFlag(AacPlusFlag);
3563 }
3564 break;
3565
3566 case OMX_IndexParamAudioAmr:
3567 {
3568 pAudioAmr = (OMX_AUDIO_PARAM_AMRTYPE*) ComponentParameterStructure;
3569 PortIndex = pAudioAmr->nPortIndex;
3570 /*Check Structure Header and verify component state*/
3571 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pAudioAmr, sizeof(OMX_AUDIO_PARAM_AMRTYPE));
3572 if (ErrorType != OMX_ErrorNone)
3573 {
3574 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3575 return ErrorType;
3576 }
3577 oscl_memcpy(&ipPorts[PortIndex]->AudioAmrParam, pAudioAmr, sizeof(OMX_AUDIO_PARAM_AMRTYPE));
3578
3579 //If the band mode turns out to be WB, set the sampling freq to 16KHz
3580 if ((pAudioAmr->eAMRBandMode >= OMX_AUDIO_AMRBandModeWB0) &&
3581 (pAudioAmr->eAMRBandMode <= OMX_AUDIO_AMRBandModeWB8))
3582 {
3583 ipPorts[OMX_PORT_OUTPUTPORT_INDEX]->AudioPcmMode.nSamplingRate = 16000;
3584 }
3585 }
3586 break;
3587
3588 case OMX_IndexParamPriorityMgmt:
3589 {
3590 if (iState != OMX_StateLoaded && iState != OMX_StateWaitForResources)
3591 {
3592 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error incorrect state error"));
3593 return OMX_ErrorIncorrectStateOperation;
3594 }
3595 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*) ComponentParameterStructure;
3596 if ((ErrorType = CheckHeader(pPrioMgmt, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone)
3597 {
3598 break;
3599 }
3600 iGroupPriority = pPrioMgmt->nGroupPriority;
3601 iGroupID = pPrioMgmt->nGroupID;
3602 }
3603 break;
3604
3605 case OMX_IndexParamPortDefinition:
3606 {
3607 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
3608 PortIndex = pPortDef->nPortIndex;
3609
3610 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
3611 if (ErrorType != OMX_ErrorNone)
3612 {
3613 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3614 return ErrorType;
3615 }
3616
3617 ipPorts[PortIndex]->PortParam.nBufferCountActual = pPortDef->nBufferCountActual;
3618 ipPorts[PortIndex]->PortParam.nBufferSize = pPortDef->nBufferSize;
3619
3620 oscl_memcpy(&ipPorts[PortIndex]->PortParam.format.audio, &pPortDef->format.audio, sizeof(OMX_AUDIO_PORTDEFINITIONTYPE));
3621 }
3622 break;
3623
3624 case OMX_IndexParamCompBufferSupplier:
3625 {
3626 pBufSupply = (OMX_PARAM_BUFFERSUPPLIERTYPE*) ComponentParameterStructure;
3627 PortIndex = pBufSupply->nPortIndex;
3628
3629 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
3630 if (OMX_ErrorIncorrectStateOperation == ErrorType)
3631 {
3632 if (PORT_IS_ENABLED(ipPorts[pBufSupply->nPortIndex]))
3633 {
3634 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error incorrect state error"));
3635 return OMX_ErrorIncorrectStateOperation;
3636 }
3637 }
3638 else if (ErrorType != OMX_ErrorNone)
3639 {
3640 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error parameter sanity check error"));
3641 return ErrorType;
3642 }
3643
3644 if (pBufSupply->eBufferSupplier == OMX_BufferSupplyUnspecified)
3645 {
3646 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter OUT"));
3647 return OMX_ErrorNone;
3648 }
3649
3650 ErrorType = OMX_ErrorNone;
3651 }
3652 break;
3653
3654 case OMX_IndexParamStandardComponentRole:
3655 {
3656 pCompRole = (OMX_PARAM_COMPONENTROLETYPE*) ComponentParameterStructure;
3657 if ((ErrorType = CheckHeader(pCompRole, sizeof(OMX_PARAM_COMPONENTROLETYPE))) != OMX_ErrorNone)
3658 {
3659 break;
3660 }
3661 oscl_strncpy((OMX_STRING)iComponentRole, (OMX_STRING)pCompRole->cRole, OMX_MAX_STRINGNAME_SIZE);
3662 iComponentRoleFlag = OMX_TRUE;
3663 }
3664 break;
3665
3666
3667 default:
3668 {
3669 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter error Unsupported index"));
3670 return OMX_ErrorUnsupportedIndex;
3671 }
3672 }
3673
3674 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentAudio : SetParameter OUT"));
3675 return ErrorType;
3676
3677 }
3678
3679
3680 /*************************
3681 VIDEO BASE CLASS ROUTINES
3682 *************************/
OmxComponentVideo()3683 OSCL_EXPORT_REF OmxComponentVideo::OmxComponentVideo()
3684 {
3685 iIsAudioComponent = OMX_FALSE;
3686
3687 }
3688
3689
GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)3690 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentVideo::GetParameter(
3691 OMX_IN OMX_HANDLETYPE hComponent,
3692 OMX_IN OMX_INDEXTYPE nParamIndex,
3693 OMX_INOUT OMX_PTR ComponentParameterStructure)
3694 {
3695 OSCL_UNUSED_ARG(hComponent);
3696
3697 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter IN"));
3698
3699 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
3700 OMX_PARAM_BUFFERSUPPLIERTYPE* pBufSupply;
3701 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef;
3702 OMX_PORT_PARAM_TYPE* pPortDomains;
3703 OMX_U32 PortIndex;
3704 OMX_PARAM_COMPONENTROLETYPE* pCompRole;
3705
3706
3707 OMX_VIDEO_PARAM_PORTFORMATTYPE* pVideoPortFormat;
3708 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pProfileLevel;
3709
3710 OMX_VIDEO_PARAM_MPEG4TYPE* pVideoMpeg4;
3711 OMX_VIDEO_PARAM_H263TYPE* pVideoH263;
3712 OMX_VIDEO_PARAM_AVCTYPE* pVideoAvc;
3713 OMX_VIDEO_PARAM_WMVTYPE* pVideoWmv;
3714
3715 //Video encoder configuration parameters
3716 OMX_CONFIG_ROTATIONTYPE* pVideoRotation;
3717 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pVideoErrCorr;
3718 OMX_VIDEO_PARAM_BITRATETYPE* pVideoRateControl;
3719 OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pVideoQuant;
3720 OMX_VIDEO_PARAM_VBSMCTYPE* pVideoBlock;
3721 OMX_VIDEO_PARAM_MOTIONVECTORTYPE* pVideoMotionVector;
3722 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pVideoIntraRefresh;
3723
3724 if (NULL == ComponentParameterStructure)
3725 {
3726 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad parameter"));
3727 return OMX_ErrorBadParameter;
3728 }
3729
3730 switch (nParamIndex)
3731 {
3732 case OMX_IndexParamPriorityMgmt:
3733 {
3734 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*) ComponentParameterStructure;
3735 SetHeader(pPrioMgmt, sizeof(OMX_PRIORITYMGMTTYPE));
3736 pPrioMgmt->nGroupPriority = iGroupPriority;
3737 pPrioMgmt->nGroupID = iGroupID;
3738 }
3739 break;
3740
3741 case OMX_IndexParamVideoInit:
3742 {
3743 SetHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
3744 oscl_memcpy(ComponentParameterStructure, &iPortTypesParam, sizeof(OMX_PORT_PARAM_TYPE));
3745 }
3746 break;
3747
3748
3749 //Following 3 cases have a single common piece of code to be executed
3750 case OMX_IndexParamAudioInit:
3751 case OMX_IndexParamImageInit:
3752 case OMX_IndexParamOtherInit:
3753 {
3754 pPortDomains = (OMX_PORT_PARAM_TYPE*) ComponentParameterStructure;
3755 SetHeader(pPortDomains, sizeof(OMX_PORT_PARAM_TYPE));
3756 pPortDomains->nPorts = 0;
3757 pPortDomains->nStartPortNumber = 0;
3758 }
3759 break;
3760
3761 case OMX_IndexParamVideoPortFormat:
3762 {
3763 pVideoPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*) ComponentParameterStructure;
3764
3765 //Check for valid port index
3766 PortIndex = pVideoPortFormat->nPortIndex;
3767 if (PortIndex >= iNumPorts)
3768 {
3769 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3770 return OMX_ErrorBadPortIndex;
3771 }
3772
3773 OMX_U32 QueriedIndex = pVideoPortFormat->nIndex;
3774 if (QueriedIndex >= ipPorts[PortIndex]->ActualNumPortFormatsSupported)
3775 {
3776 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error index out of range"));
3777 return OMX_ErrorNoMore;
3778 }
3779 else
3780 {
3781 SetHeader(pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
3782 oscl_memcpy(pVideoPortFormat, &ipPorts[PortIndex]->VideoParam[QueriedIndex], sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
3783 }
3784 }
3785
3786 break;
3787
3788 case OMX_IndexParamVideoMpeg4:
3789 {
3790 pVideoMpeg4 = (OMX_VIDEO_PARAM_MPEG4TYPE*) ComponentParameterStructure;
3791 if (pVideoMpeg4->nPortIndex != iCompressedFormatPortNum)
3792 {
3793 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3794 return OMX_ErrorBadPortIndex;
3795 }
3796 PortIndex = pVideoMpeg4->nPortIndex;
3797 oscl_memcpy(pVideoMpeg4, &ipPorts[PortIndex]->VideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
3798 SetHeader(pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
3799 }
3800 break;
3801
3802 case OMX_IndexParamVideoH263:
3803 {
3804 pVideoH263 = (OMX_VIDEO_PARAM_H263TYPE*) ComponentParameterStructure;
3805 if (pVideoH263->nPortIndex != iCompressedFormatPortNum)
3806 {
3807 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3808 return OMX_ErrorBadPortIndex;
3809 }
3810 PortIndex = pVideoH263->nPortIndex;
3811 oscl_memcpy(pVideoH263, &ipPorts[PortIndex]->VideoH263, sizeof(OMX_VIDEO_PARAM_H263TYPE));
3812 SetHeader(pVideoH263, sizeof(OMX_VIDEO_PARAM_H263TYPE));
3813 }
3814 break;
3815
3816 case OMX_IndexParamVideoAvc:
3817 {
3818 pVideoAvc = (OMX_VIDEO_PARAM_AVCTYPE*) ComponentParameterStructure;
3819 if (pVideoAvc->nPortIndex != iCompressedFormatPortNum)
3820 {
3821 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3822 return OMX_ErrorBadPortIndex;
3823 }
3824 PortIndex = pVideoAvc->nPortIndex;
3825 oscl_memcpy(pVideoAvc, &ipPorts[PortIndex]->VideoAvc, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
3826 SetHeader(pVideoAvc, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
3827 }
3828 break;
3829
3830 case OMX_IndexParamVideoWmv:
3831 {
3832 pVideoWmv = (OMX_VIDEO_PARAM_WMVTYPE*)ComponentParameterStructure;
3833 if (pVideoWmv->nPortIndex != iCompressedFormatPortNum)
3834 {
3835 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3836 return OMX_ErrorBadPortIndex;
3837 }
3838 PortIndex = pVideoWmv->nPortIndex;
3839 oscl_memcpy(pVideoWmv, &ipPorts[PortIndex]->VideoWmv, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
3840 SetHeader(pVideoWmv, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
3841 }
3842 break;
3843
3844 case OMX_IndexParamVideoProfileLevelQuerySupported:
3845 {
3846 pProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*) ComponentParameterStructure;
3847
3848 PortIndex = pProfileLevel->nPortIndex;
3849 if (pProfileLevel->nProfileIndex > ipPorts[PortIndex]->ProfileLevel.nProfileIndex)
3850 {
3851 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error profile not supported"));
3852 return OMX_ErrorNoMore;
3853 }
3854
3855 oscl_memcpy(pProfileLevel, &ipPorts[PortIndex]->ProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
3856 SetHeader(pProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
3857 }
3858 break;
3859
3860 case OMX_IndexParamVideoProfileLevelCurrent:
3861 {
3862 pProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*) ComponentParameterStructure;
3863
3864 PortIndex = pProfileLevel->nPortIndex;
3865
3866 oscl_memcpy(pProfileLevel, &ipPorts[PortIndex]->ProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
3867 SetHeader(pProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
3868 }
3869 break;
3870
3871 case OMX_IndexParamPortDefinition:
3872 {
3873 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
3874 PortIndex = pPortDef->nPortIndex;
3875 if (PortIndex >= iNumPorts)
3876 {
3877 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3878 return OMX_ErrorBadPortIndex;
3879 }
3880 oscl_memcpy(pPortDef, &ipPorts[PortIndex]->PortParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
3881 }
3882 break;
3883
3884 case OMX_IndexParamCompBufferSupplier:
3885 {
3886 pBufSupply = (OMX_PARAM_BUFFERSUPPLIERTYPE*) ComponentParameterStructure;
3887 PortIndex = pBufSupply->nPortIndex;
3888 if (PortIndex >= iNumPorts)
3889 {
3890 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3891 return OMX_ErrorBadPortIndex;
3892 }
3893 SetHeader(pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
3894
3895 if (OMX_DirInput == ipPorts[PortIndex]->PortParam.eDir)
3896 {
3897 pBufSupply->eBufferSupplier = OMX_BufferSupplyUnspecified;
3898 }
3899 else
3900 {
3901 SetHeader(pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
3902 pBufSupply->eBufferSupplier = OMX_BufferSupplyUnspecified;
3903 }
3904 }
3905 break;
3906
3907 case(OMX_INDEXTYPE) PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
3908 {
3909 PV_OMXComponentCapabilityFlagsType *pCap_flags = (PV_OMXComponentCapabilityFlagsType *) ComponentParameterStructure;
3910 if (NULL == pCap_flags)
3911 {
3912 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error pCap_flags NULL"));
3913 return OMX_ErrorBadParameter;
3914 }
3915 oscl_memcpy(pCap_flags, &iPVCapabilityFlags, sizeof(iPVCapabilityFlags));
3916
3917 }
3918 break;
3919
3920 case OMX_IndexConfigCommonRotate:
3921 {
3922 pVideoRotation = (OMX_CONFIG_ROTATIONTYPE*) ComponentParameterStructure;
3923 if (pVideoRotation->nPortIndex >= iNumPorts)
3924 {
3925 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3926 return OMX_ErrorBadPortIndex;
3927 }
3928 PortIndex = pVideoRotation->nPortIndex;
3929 oscl_memcpy(pVideoRotation, &ipPorts[PortIndex]->VideoOrientationType, sizeof(OMX_CONFIG_ROTATIONTYPE));
3930 SetHeader(pVideoRotation, sizeof(OMX_CONFIG_ROTATIONTYPE));
3931 }
3932 break;
3933
3934 case OMX_IndexParamVideoErrorCorrection:
3935 {
3936 pVideoErrCorr = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*) ComponentParameterStructure;
3937 if (pVideoErrCorr->nPortIndex != iCompressedFormatPortNum)
3938 {
3939 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3940 return OMX_ErrorBadPortIndex;
3941 }
3942 PortIndex = pVideoErrCorr->nPortIndex;
3943 oscl_memcpy(pVideoErrCorr, &ipPorts[PortIndex]->VideoErrorCorrection, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
3944 SetHeader(pVideoErrCorr, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
3945 }
3946 break;
3947
3948 case OMX_IndexParamVideoBitrate:
3949 {
3950 pVideoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE*) ComponentParameterStructure;
3951 if (pVideoRateControl->nPortIndex != iCompressedFormatPortNum)
3952 {
3953 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3954 return OMX_ErrorBadPortIndex;
3955 }
3956 PortIndex = pVideoRateControl->nPortIndex;
3957 oscl_memcpy(pVideoRateControl, &ipPorts[PortIndex]->VideoRateType, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
3958 SetHeader(pVideoRateControl, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
3959 }
3960 break;
3961
3962 case OMX_IndexParamVideoQuantization:
3963 {
3964 pVideoQuant = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) ComponentParameterStructure;
3965 if (pVideoQuant->nPortIndex != iCompressedFormatPortNum)
3966 {
3967 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3968 return OMX_ErrorBadPortIndex;
3969 }
3970 PortIndex = pVideoQuant->nPortIndex;
3971 oscl_memcpy(pVideoQuant, &ipPorts[PortIndex]->VideoQuantType, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
3972 SetHeader(pVideoQuant, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
3973 }
3974 break;
3975
3976 case OMX_IndexParamVideoVBSMC:
3977 {
3978 pVideoBlock = (OMX_VIDEO_PARAM_VBSMCTYPE*) ComponentParameterStructure;
3979 if (pVideoBlock->nPortIndex != iCompressedFormatPortNum)
3980 {
3981 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3982 return OMX_ErrorBadPortIndex;
3983 }
3984 PortIndex = pVideoBlock->nPortIndex;
3985 oscl_memcpy(pVideoBlock, &ipPorts[PortIndex]->VideoBlockMotionSize, sizeof(OMX_VIDEO_PARAM_VBSMCTYPE));
3986 SetHeader(pVideoBlock, sizeof(OMX_VIDEO_PARAM_VBSMCTYPE));
3987 }
3988 break;
3989
3990 case OMX_IndexParamVideoMotionVector:
3991 {
3992 pVideoMotionVector = (OMX_VIDEO_PARAM_MOTIONVECTORTYPE*) ComponentParameterStructure;
3993 if (pVideoMotionVector->nPortIndex != iCompressedFormatPortNum)
3994 {
3995 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
3996 return OMX_ErrorBadPortIndex;
3997 }
3998 PortIndex = pVideoMotionVector->nPortIndex;
3999 oscl_memcpy(pVideoMotionVector, &ipPorts[PortIndex]->VideoMotionVector, sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
4000 SetHeader(pVideoMotionVector, sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
4001 }
4002 break;
4003
4004 case OMX_IndexParamVideoIntraRefresh:
4005 {
4006 pVideoIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*) ComponentParameterStructure;
4007 if (pVideoIntraRefresh->nPortIndex != iCompressedFormatPortNum)
4008 {
4009 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error bad port index"));
4010 return OMX_ErrorBadPortIndex;
4011 }
4012 PortIndex = pVideoIntraRefresh->nPortIndex;
4013 oscl_memcpy(pVideoIntraRefresh, &ipPorts[PortIndex]->VideoIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
4014 SetHeader(pVideoIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
4015 }
4016 break;
4017 case OMX_IndexParamStandardComponentRole:
4018 {
4019 pCompRole = (OMX_PARAM_COMPONENTROLETYPE*) ComponentParameterStructure;
4020 SetHeader(pCompRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
4021 oscl_strncpy((OMX_STRING)pCompRole->cRole, (OMX_STRING)iComponentRole, OMX_MAX_STRINGNAME_SIZE);
4022 }
4023 break;
4024 default:
4025 {
4026 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter error Unsupported Index"));
4027 return OMX_ErrorUnsupportedIndex;
4028 }
4029 // break; This break statement was removed to avoid compiler warning for Unreachable Code
4030 }
4031
4032 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : GetParameter OUT"));
4033
4034 return OMX_ErrorNone;
4035
4036 }
4037
4038
SetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_IN OMX_PTR ComponentParameterStructure)4039 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentVideo::SetParameter(
4040 OMX_IN OMX_HANDLETYPE hComponent,
4041 OMX_IN OMX_INDEXTYPE nParamIndex,
4042 OMX_IN OMX_PTR ComponentParameterStructure)
4043 {
4044 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter IN"));
4045
4046 OMX_ERRORTYPE ErrorType = OMX_ErrorNone;
4047 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
4048 OMX_VIDEO_PARAM_PORTFORMATTYPE* pVideoPortFormat;
4049 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pProfileLevel;
4050 OMX_PARAM_BUFFERSUPPLIERTYPE* pBufSupply;
4051 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef ;
4052 OMX_U32 PortIndex;
4053
4054 OMX_PARAM_COMPONENTROLETYPE* pCompRole;
4055 OMX_VIDEO_PARAM_MPEG4TYPE* pVideoMpeg4;
4056 OMX_VIDEO_PARAM_H263TYPE* pVideoH263;
4057 OMX_VIDEO_PARAM_WMVTYPE* pVideoWmv;
4058 OMX_VIDEO_PARAM_AVCTYPE* pVideoAvc;
4059
4060 //Video encoder configuration parameters
4061 OMX_CONFIG_ROTATIONTYPE* pVideoRotation;
4062 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pVideoErrCorr;
4063 OMX_VIDEO_PARAM_BITRATETYPE* pVideoRateControl;
4064 OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pVideoQuant;
4065 OMX_VIDEO_PARAM_VBSMCTYPE* pVideoBlock;
4066 OMX_VIDEO_PARAM_MOTIONVECTORTYPE* pVideoMotionVector;
4067 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pVideoIntraRefresh;
4068
4069
4070 ComponentPortType* pComponentPort;
4071
4072 if (NULL == ComponentParameterStructure)
4073 {
4074 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error bad parameter"));
4075 return OMX_ErrorBadParameter;
4076 }
4077
4078 switch (nParamIndex)
4079 {
4080 case OMX_IndexParamVideoInit:
4081 {
4082 /*Check Structure Header*/
4083 CheckHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
4084 if (ErrorType != OMX_ErrorNone)
4085 {
4086 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error video init check header failed"));
4087 return ErrorType;
4088 }
4089 oscl_memcpy(&iPortTypesParam, ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE));
4090 }
4091 break;
4092
4093 case OMX_IndexParamVideoPortFormat:
4094 {
4095 pVideoPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*) ComponentParameterStructure;
4096 PortIndex = pVideoPortFormat->nPortIndex;
4097 /*Check Structure Header and verify component state*/
4098 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
4099 if (ErrorType != OMX_ErrorNone)
4100 {
4101 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error parameter sanity check error"));
4102 return ErrorType;
4103 }
4104 if (PortIndex <= 1)
4105 {
4106 pComponentPort = (ComponentPortType*) ipPorts[PortIndex];
4107 oscl_memcpy(&pComponentPort->VideoParam, pVideoPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
4108 }
4109 else
4110 {
4111 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error bad port index"));
4112 return OMX_ErrorBadPortIndex;
4113 }
4114 }
4115 break;
4116
4117 case OMX_IndexParamVideoMpeg4:
4118 {
4119 pVideoMpeg4 = (OMX_VIDEO_PARAM_MPEG4TYPE*) ComponentParameterStructure;
4120 PortIndex = pVideoMpeg4->nPortIndex;
4121 /*Check Structure Header and verify component state*/
4122 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
4123 if (ErrorType != OMX_ErrorNone)
4124 {
4125 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4126 return ErrorType;
4127 }
4128 oscl_memcpy(&ipPorts[PortIndex]->VideoMpeg4, pVideoMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
4129 }
4130 break;
4131
4132 case OMX_IndexParamVideoH263:
4133 {
4134 pVideoH263 = (OMX_VIDEO_PARAM_H263TYPE*) ComponentParameterStructure;
4135 PortIndex = pVideoH263->nPortIndex;
4136 /*Check Structure Header and verify component state*/
4137 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoH263, sizeof(OMX_VIDEO_PARAM_H263TYPE));
4138 if (ErrorType != OMX_ErrorNone)
4139 {
4140 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4141 return ErrorType;
4142 }
4143 oscl_memcpy(&ipPorts[PortIndex]->VideoH263, pVideoH263, sizeof(OMX_VIDEO_PARAM_H263TYPE));
4144 }
4145 break;
4146
4147 case OMX_IndexParamVideoAvc:
4148 {
4149 pVideoAvc = (OMX_VIDEO_PARAM_AVCTYPE*) ComponentParameterStructure;
4150 PortIndex = pVideoAvc->nPortIndex;
4151 /*Check Structure Header and verify component state*/
4152 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoAvc, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
4153 if (ErrorType != OMX_ErrorNone)
4154 {
4155 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error parameter sanity check error"));
4156 return ErrorType;
4157 }
4158 oscl_memcpy(&ipPorts[PortIndex]->VideoAvc, pVideoAvc, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
4159 }
4160 break;
4161
4162 case OMX_IndexParamVideoWmv:
4163 {
4164 pVideoWmv = (OMX_VIDEO_PARAM_WMVTYPE*)ComponentParameterStructure;
4165 PortIndex = pVideoWmv->nPortIndex;
4166 /*Check Structure Header and verify component state*/
4167 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoWmv, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
4168 if (ErrorType != OMX_ErrorNone)
4169 {
4170 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4171 return ErrorType;
4172 }
4173 oscl_memcpy(&ipPorts[PortIndex]->VideoWmv, pVideoWmv, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
4174 }
4175 break;
4176
4177
4178 case OMX_IndexParamVideoProfileLevelCurrent:
4179 {
4180 pProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*) ComponentParameterStructure;
4181 PortIndex = pProfileLevel->nPortIndex;
4182 /*Check Structure Header and verify component state*/
4183 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
4184 if (OMX_ErrorNone != ErrorType)
4185 {
4186 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error parameter sanity check error"));
4187 return ErrorType;
4188 }
4189 oscl_memcpy(&ipPorts[PortIndex]->ProfileLevel, pProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
4190 }
4191 break;
4192
4193 case OMX_IndexParamPriorityMgmt:
4194 {
4195 if (iState != OMX_StateLoaded && iState != OMX_StateWaitForResources)
4196 {
4197 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error incorrect state error"));
4198 return OMX_ErrorIncorrectStateOperation;
4199 }
4200 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*) ComponentParameterStructure;
4201 if ((ErrorType = CheckHeader(pPrioMgmt, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone)
4202 {
4203 break;
4204 }
4205 iGroupPriority = pPrioMgmt->nGroupPriority;
4206 iGroupID = pPrioMgmt->nGroupID;
4207 }
4208 break;
4209
4210 case OMX_IndexParamPortDefinition:
4211 {
4212 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
4213 PortIndex = pPortDef->nPortIndex;
4214
4215 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
4216 if (ErrorType != OMX_ErrorNone)
4217 {
4218 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error parameter sanity check error"));
4219 return ErrorType;
4220 }
4221
4222 ipPorts[PortIndex]->PortParam.nBufferCountActual = pPortDef->nBufferCountActual;
4223 ipPorts[PortIndex]->PortParam.nBufferSize = pPortDef->nBufferSize;
4224
4225 oscl_memcpy(&ipPorts[PortIndex]->PortParam.format.video, &pPortDef->format.video, sizeof(OMX_VIDEO_PORTDEFINITIONTYPE));
4226
4227 // adjust the minimum buffer size of the uncompressed format based on width and height that may have been set
4228 // In case of decoder - output port contains uncompressed data - so outpu buffer size needs to be adjusted
4229 // In case of encoder - input port contains uncompressed data - so input buffer size needs to be adjusted
4230 // In both cases (encoder&decoder) - eCompressionFormat parameter on the appropriate port is set to OMX_VIDEO_CodingUnused
4231
4232 OMX_VIDEO_PORTDEFINITIONTYPE *videoformat = &(ipPorts[PortIndex]->PortParam.format.video);
4233 if (videoformat->eCompressionFormat == OMX_VIDEO_CodingUnused)
4234 {
4235 // check if stride needs to be adjusted - stride should be at least the 16 byte aligned width
4236 // WMV is special case that requires 4 bytes alignment
4237
4238 OMX_U32 min_stride = ((videoformat->nFrameWidth + 15) & (~15));
4239 OMX_U32 min_sliceheight = ((videoformat->nFrameHeight + 15) & (~15));
4240
4241 if (oscl_strcmp("video/wmv", videoformat->cMIMEType) == 0)
4242 {
4243 min_stride = ((videoformat->nFrameWidth + 3) & (~3));
4244 min_sliceheight = ((videoformat->nFrameHeight + 1) & (~1));
4245 }
4246
4247
4248 videoformat->nStride = min_stride;
4249 videoformat->nSliceHeight = min_sliceheight;
4250
4251
4252 // finally, compute the new minimum buffer size.
4253
4254 // Encoder components can have different formats - (rely on the client to provide the correct size)
4255 if (OMX_PORT_OUTPUTPORT_INDEX == PortIndex)
4256 {
4257 // Decoder components always output YUV420 format
4258 ipPorts[PortIndex]->PortParam.nBufferSize = (videoformat->nSliceHeight * videoformat->nStride * 3) >> 1;
4259
4260 }
4261
4262 if (OMX_PORT_INPUTPORT_INDEX == PortIndex)
4263 {
4264 // Encoder components may have different formats
4265 if (videoformat->eColorFormat == OMX_COLOR_Format24bitRGB888)
4266 {
4267 ipPorts[PortIndex]->PortParam.nBufferSize = videoformat->nSliceHeight * videoformat->nStride * 3;
4268 }
4269 else if (videoformat->eColorFormat == OMX_COLOR_Format12bitRGB444)
4270 {
4271 ipPorts[PortIndex]->PortParam.nBufferSize = videoformat->nSliceHeight * videoformat->nStride * 2;
4272
4273 }
4274 else if (videoformat->eColorFormat == OMX_COLOR_FormatYUV420Planar)
4275 {
4276 ipPorts[PortIndex]->PortParam.nBufferSize = (videoformat->nSliceHeight * videoformat->nStride * 3) >> 1;
4277
4278 }
4279
4280 }
4281
4282 }
4283
4284 }
4285 break;
4286
4287 case OMX_IndexParamCompBufferSupplier:
4288 {
4289 pBufSupply = (OMX_PARAM_BUFFERSUPPLIERTYPE*) ComponentParameterStructure;
4290 PortIndex = pBufSupply->nPortIndex;
4291
4292 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pBufSupply, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
4293 if (OMX_ErrorIncorrectStateOperation == ErrorType)
4294 {
4295 if (PORT_IS_ENABLED(ipPorts[pBufSupply->nPortIndex]))
4296 {
4297 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error incorrect state error"));
4298 return OMX_ErrorIncorrectStateOperation;
4299 }
4300 }
4301 else if (ErrorType != OMX_ErrorNone)
4302 {
4303 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error parameter sanity check error"));
4304 return ErrorType;
4305 }
4306
4307 if (pBufSupply->eBufferSupplier == OMX_BufferSupplyUnspecified)
4308 {
4309 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter OUT"));
4310 return OMX_ErrorNone;
4311 }
4312
4313 ErrorType = OMX_ErrorNone;
4314 }
4315 break;
4316
4317 case OMX_IndexParamStandardComponentRole:
4318 {
4319 pCompRole = (OMX_PARAM_COMPONENTROLETYPE*) ComponentParameterStructure;
4320 if ((ErrorType = CheckHeader(pCompRole, sizeof(OMX_PARAM_COMPONENTROLETYPE))) != OMX_ErrorNone)
4321 {
4322 break;
4323 }
4324 oscl_strncpy((OMX_STRING)iComponentRole, (OMX_STRING)pCompRole->cRole, OMX_MAX_STRINGNAME_SIZE);
4325 iComponentRoleFlag = OMX_TRUE;
4326 }
4327 break;
4328
4329
4330 case OMX_IndexConfigCommonRotate:
4331 {
4332 pVideoRotation = (OMX_CONFIG_ROTATIONTYPE*) ComponentParameterStructure;
4333 PortIndex = pVideoRotation->nPortIndex;
4334 /*Check Structure Header and verify component state*/
4335 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoRotation, sizeof(OMX_CONFIG_ROTATIONTYPE));
4336 if (ErrorType != OMX_ErrorNone)
4337 {
4338 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4339 return ErrorType;
4340 }
4341 oscl_memcpy(&ipPorts[PortIndex]->VideoOrientationType, pVideoRotation, sizeof(OMX_CONFIG_ROTATIONTYPE));
4342 }
4343 break;
4344
4345 case OMX_IndexParamVideoErrorCorrection:
4346 {
4347 pVideoErrCorr = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*) ComponentParameterStructure;
4348 PortIndex = pVideoErrCorr->nPortIndex;
4349 /*Check Structure Header and verify component state*/
4350 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoErrCorr, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
4351 if (ErrorType != OMX_ErrorNone)
4352 {
4353 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4354 return ErrorType;
4355 }
4356 oscl_memcpy(&ipPorts[PortIndex]->VideoErrorCorrection, pVideoErrCorr, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
4357 }
4358 break;
4359
4360 case OMX_IndexParamVideoBitrate:
4361 {
4362 pVideoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE*) ComponentParameterStructure;
4363 PortIndex = pVideoRateControl->nPortIndex;
4364 /*Check Structure Header and verify component state*/
4365 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoRateControl, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
4366 if (ErrorType != OMX_ErrorNone)
4367 {
4368 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4369 return ErrorType;
4370 }
4371 oscl_memcpy(&ipPorts[PortIndex]->VideoRateType, pVideoRateControl, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
4372 }
4373 break;
4374
4375 case OMX_IndexParamVideoQuantization:
4376 {
4377 pVideoQuant = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) ComponentParameterStructure;
4378 PortIndex = pVideoQuant->nPortIndex;
4379 /*Check Structure Header and verify component state*/
4380 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoQuant, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
4381 if (ErrorType != OMX_ErrorNone)
4382 {
4383 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4384 return ErrorType;
4385 }
4386 oscl_memcpy(&ipPorts[PortIndex]->VideoQuantType, pVideoQuant, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
4387 }
4388 break;
4389
4390 case OMX_IndexParamVideoVBSMC:
4391 {
4392 pVideoBlock = (OMX_VIDEO_PARAM_VBSMCTYPE*) ComponentParameterStructure;
4393 PortIndex = pVideoBlock->nPortIndex;
4394 /*Check Structure Header and verify component state*/
4395 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoBlock, sizeof(OMX_VIDEO_PARAM_VBSMCTYPE));
4396 if (ErrorType != OMX_ErrorNone)
4397 {
4398 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4399 return ErrorType;
4400 }
4401 oscl_memcpy(&ipPorts[PortIndex]->VideoBlockMotionSize, pVideoBlock, sizeof(OMX_VIDEO_PARAM_VBSMCTYPE));
4402 }
4403 break;
4404
4405 case OMX_IndexParamVideoMotionVector:
4406 {
4407 pVideoMotionVector = (OMX_VIDEO_PARAM_MOTIONVECTORTYPE*) ComponentParameterStructure;
4408 PortIndex = pVideoMotionVector->nPortIndex;
4409 /*Check Structure Header and verify component state*/
4410 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoMotionVector, sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
4411 if (ErrorType != OMX_ErrorNone)
4412 {
4413 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4414 return ErrorType;
4415 }
4416 oscl_memcpy(&ipPorts[PortIndex]->VideoMotionVector, pVideoMotionVector, sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
4417 }
4418 break;
4419
4420 case OMX_IndexParamVideoIntraRefresh:
4421 {
4422 pVideoIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*) ComponentParameterStructure;
4423 PortIndex = pVideoIntraRefresh->nPortIndex;
4424 /*Check Structure Header and verify component state*/
4425 ErrorType = ParameterSanityCheck(hComponent, PortIndex, pVideoIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
4426 if (ErrorType != OMX_ErrorNone)
4427 {
4428 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error param check failed"));
4429 return ErrorType;
4430 }
4431 oscl_memcpy(&ipPorts[PortIndex]->VideoIntraRefresh, pVideoIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
4432 }
4433 break;
4434
4435
4436 default:
4437 {
4438 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter error Unsupported index"));
4439 return OMX_ErrorUnsupportedIndex;
4440 }
4441 // break; This break statement was removed to avoid compiler warning for Unreachable Code
4442 }
4443
4444 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "OmxComponentVideo : SetParameter OUT"));
4445 return ErrorType;
4446
4447 }
4448 #if PROXY_INTERFACE
4449
4450 /** Component entry points declarations with proxy interface*/
BaseComponentProxyGetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_INOUT OMX_PTR pComponentConfigStructure)4451 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyGetConfig(
4452 OMX_IN OMX_HANDLETYPE hComponent,
4453 OMX_IN OMX_INDEXTYPE nIndex,
4454 OMX_INOUT OMX_PTR pComponentConfigStructure)
4455 {
4456 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4457 if (NULL == pOpenmaxAOType)
4458 {
4459 return OMX_ErrorBadParameter;
4460 }
4461
4462 OMX_ERRORTYPE ReturnValue;
4463
4464 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyGetConfig(hComponent, nIndex, pComponentConfigStructure);
4465 return ReturnValue;
4466 }
4467
BaseComponentProxySetConfig(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_IN OMX_PTR pComponentConfigStructure)4468 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxySetConfig(
4469 OMX_IN OMX_HANDLETYPE hComponent,
4470 OMX_IN OMX_INDEXTYPE nIndex,
4471 OMX_IN OMX_PTR pComponentConfigStructure)
4472 {
4473 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4474 if (NULL == pOpenmaxAOType)
4475 {
4476 return OMX_ErrorBadParameter;
4477 }
4478
4479 OMX_ERRORTYPE ReturnValue;
4480
4481 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxySetConfig(hComponent, nIndex, pComponentConfigStructure);
4482 return ReturnValue;
4483 }
4484
BaseComponentProxyGetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)4485 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyGetExtensionIndex(
4486 OMX_IN OMX_HANDLETYPE hComponent,
4487 OMX_IN OMX_STRING cParameterName,
4488 OMX_OUT OMX_INDEXTYPE* pIndexType)
4489 {
4490 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4491 if (NULL == pOpenmaxAOType)
4492 {
4493 return OMX_ErrorBadParameter;
4494 }
4495
4496 OMX_ERRORTYPE ReturnValue;
4497
4498 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyGetExtensionIndex(hComponent, cParameterName, pIndexType);
4499 return ReturnValue;
4500 }
4501
BaseComponentProxyGetState(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_STATETYPE * pState)4502 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyGetState(
4503 OMX_IN OMX_HANDLETYPE hComponent,
4504 OMX_OUT OMX_STATETYPE* pState)
4505 {
4506 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4507 if (NULL == pOpenmaxAOType)
4508 {
4509 return OMX_ErrorBadParameter;
4510 }
4511
4512 OMX_ERRORTYPE ReturnValue;
4513
4514 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyGetState(hComponent, pState);
4515 return ReturnValue;
4516 }
4517
4518
BaseComponentProxyGetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)4519 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyGetParameter(
4520 OMX_IN OMX_HANDLETYPE hComponent,
4521 OMX_IN OMX_INDEXTYPE nParamIndex,
4522 OMX_INOUT OMX_PTR ComponentParameterStructure)
4523 {
4524 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4525 if (NULL == pOpenmaxAOType)
4526 {
4527 return OMX_ErrorBadParameter;
4528 }
4529
4530 OMX_ERRORTYPE ReturnValue = OMX_ErrorNone;
4531
4532 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyGetParameter(hComponent, nParamIndex, ComponentParameterStructure);
4533 return ReturnValue;
4534 }
4535
4536
BaseComponentProxySetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_IN OMX_PTR ComponentParameterStructure)4537 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxySetParameter(
4538 OMX_IN OMX_HANDLETYPE hComponent,
4539 OMX_IN OMX_INDEXTYPE nParamIndex,
4540 OMX_IN OMX_PTR ComponentParameterStructure)
4541 {
4542 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4543 if (NULL == pOpenmaxAOType)
4544 {
4545 return OMX_ErrorBadParameter;
4546 }
4547
4548 OMX_ERRORTYPE ReturnValue;
4549
4550 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxySetParameter(hComponent, nParamIndex, ComponentParameterStructure);
4551 return ReturnValue;
4552 }
4553
4554
BaseComponentProxyUseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)4555 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyUseBuffer(
4556 OMX_IN OMX_HANDLETYPE hComponent,
4557 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
4558 OMX_IN OMX_U32 nPortIndex,
4559 OMX_IN OMX_PTR pAppPrivate,
4560 OMX_IN OMX_U32 nSizeBytes,
4561 OMX_IN OMX_U8* pBuffer)
4562 {
4563 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4564 if (NULL == pOpenmaxAOType)
4565 {
4566 return OMX_ErrorBadParameter;
4567 }
4568
4569 OMX_ERRORTYPE ReturnValue;
4570
4571 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyUseBuffer(hComponent, ppBufferHdr, nPortIndex, pAppPrivate, nSizeBytes, pBuffer);
4572 return ReturnValue;
4573 }
4574
BaseComponentProxyAllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** pBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)4575 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyAllocateBuffer(
4576 OMX_IN OMX_HANDLETYPE hComponent,
4577 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
4578 OMX_IN OMX_U32 nPortIndex,
4579 OMX_IN OMX_PTR pAppPrivate,
4580 OMX_IN OMX_U32 nSizeBytes)
4581 {
4582 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4583 if (NULL == pOpenmaxAOType)
4584 {
4585 return OMX_ErrorBadParameter;
4586 }
4587
4588 OMX_ERRORTYPE ReturnValue;
4589
4590 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyAllocateBuffer(hComponent, pBuffer, nPortIndex, pAppPrivate, nSizeBytes);
4591 return ReturnValue;
4592 }
4593
BaseComponentProxyFreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)4594 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyFreeBuffer(
4595 OMX_IN OMX_HANDLETYPE hComponent,
4596 OMX_IN OMX_U32 nPortIndex,
4597 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
4598 {
4599 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4600 if (NULL == pOpenmaxAOType)
4601 {
4602 return OMX_ErrorBadParameter;
4603 }
4604
4605 OMX_ERRORTYPE ReturnValue;
4606
4607 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyFreeBuffer(hComponent, nPortIndex, pBuffer);
4608 return ReturnValue;
4609 }
4610
BaseComponentProxySetCallbacks(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_CALLBACKTYPE * pCallbacks,OMX_IN OMX_PTR pAppData)4611 OMX_ERRORTYPE OmxComponentBase::BaseComponentProxySetCallbacks(
4612 OMX_IN OMX_HANDLETYPE hComponent,
4613 OMX_IN OMX_CALLBACKTYPE* pCallbacks,
4614 OMX_IN OMX_PTR pAppData)
4615 {
4616 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4617 if (NULL == pOpenmaxAOType)
4618 {
4619 return OMX_ErrorBadParameter;
4620 }
4621
4622 OMX_ERRORTYPE ReturnValue;
4623
4624 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxySetCallbacks(hComponent, pCallbacks, pAppData);
4625 return ReturnValue;
4626 }
4627
BaseComponentProxySendCommand(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_COMMANDTYPE Cmd,OMX_IN OMX_U32 nParam,OMX_IN OMX_PTR pCmdData)4628 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxySendCommand(
4629 OMX_IN OMX_HANDLETYPE hComponent,
4630 OMX_IN OMX_COMMANDTYPE Cmd,
4631 OMX_IN OMX_U32 nParam,
4632 OMX_IN OMX_PTR pCmdData)
4633 {
4634 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4635 if (NULL == pOpenmaxAOType)
4636 {
4637 return OMX_ErrorBadParameter;
4638 }
4639
4640 OMX_ERRORTYPE ReturnValue;
4641
4642 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxySendCommand(hComponent, Cmd, nParam, pCmdData);
4643 return ReturnValue;
4644 }
4645
BaseComponentProxyEmptyThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)4646 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyEmptyThisBuffer(
4647 OMX_IN OMX_HANDLETYPE hComponent,
4648 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
4649 {
4650 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4651 if (NULL == pOpenmaxAOType)
4652 {
4653 return OMX_ErrorBadParameter;
4654 }
4655
4656 OMX_ERRORTYPE ReturnValue;
4657
4658 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyEmptyThisBuffer(hComponent, pBuffer);
4659 return ReturnValue;
4660 }
4661
4662
BaseComponentProxyFillThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)4663 OSCL_EXPORT_REF OMX_ERRORTYPE OmxComponentBase::BaseComponentProxyFillThisBuffer(
4664 OMX_IN OMX_HANDLETYPE hComponent,
4665 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
4666 {
4667 OmxComponentBase* pOpenmaxAOType = (OmxComponentBase*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
4668 if (NULL == pOpenmaxAOType)
4669 {
4670 return OMX_ErrorBadParameter;
4671 }
4672
4673 OMX_ERRORTYPE ReturnValue;
4674
4675 ReturnValue = ((ProxyApplication_OMX*)(pOpenmaxAOType->ipComponentProxy))->ProxyFillThisBuffer(hComponent, pBuffer);
4676 return ReturnValue;
4677 }
4678
4679 #endif // PROXY_INTERFACE
4680