componentbase.cpp revision 9b88640fe94198cf3f03151136840b04014a0a7d 
1/*
2 * Copyright (C) 2009 Wind River Systems.
3 */
4
5#include <stdlib.h>
6#include <string.h>
7
8#include <OMX_Core.h>
9#include <OMX_Component.h>
10
11#include <componentbase.h>
12
13/*
14 * ComponentBase
15 */
16/*
17 * constructor & destructor
18 */
19void ComponentBase::__ComponentBase(void)
20{
21    memset(name, 0, OMX_MAX_STRINGNAME_SIZE);
22    cmodule = NULL;
23    handle = NULL;
24
25    roles = NULL;
26    nr_roles = 0;
27}
28
29ComponentBase::ComponentBase()
30{
31    __ComponentBase();
32}
33
34ComponentBase::ComponentBase(const OMX_STRING name)
35{
36    __ComponentBase();
37    SetName(name);
38}
39
40ComponentBase::~ComponentBase()
41{
42    if (roles) {
43        OMX_U32 i;
44
45        for (i = 0; i < nr_roles; i++)
46            free(roles[i]);
47
48        free(roles);
49    }
50}
51
52/* end of constructor & destructor */
53
54/*
55 * accessor
56 */
57/* name */
58void ComponentBase::SetName(const OMX_STRING name)
59{
60    strncpy(this->name, name, OMX_MAX_STRINGNAME_SIZE);
61    this->name[OMX_MAX_STRINGNAME_SIZE-1] = '\0';
62}
63
64const OMX_STRING ComponentBase::GetName(void)
65{
66    return name;
67}
68
69/* component module */
70void ComponentBase::SetCModule(CModule *cmodule)
71{
72    this->cmodule = cmodule;
73}
74
75CModule *ComponentBase::GetCModule(void)
76{
77    return cmodule;
78}
79
80/* end of accessor */
81
82/*
83 * core methods & helpers
84 */
85/* roles */
86OMX_ERRORTYPE ComponentBase::SetRolesOfComponent(OMX_U32 nr_roles,
87                                                 const OMX_U8 **roles)
88{
89    OMX_U32 i;
90
91    this->roles = (OMX_U8 **)malloc(sizeof(OMX_STRING) * nr_roles);
92    if (!this->roles)
93        return OMX_ErrorInsufficientResources;
94
95    for (i = 0; i < nr_roles; i++) {
96        this->roles[i] = (OMX_U8 *)malloc(OMX_MAX_STRINGNAME_SIZE);
97        if (!this->roles[i]) {
98            int j;
99
100            for (j = (int )i-1; j >= 0; j--)
101                free(this->roles[j]);
102            free(this->roles);
103
104            return OMX_ErrorInsufficientResources;
105        }
106
107        strncpy((OMX_STRING)&this->roles[i][0],
108                (const OMX_STRING)&roles[i][0],
109                OMX_MAX_STRINGNAME_SIZE);
110    }
111
112    this->nr_roles = nr_roles;
113    return OMX_ErrorNone;
114}
115
116OMX_ERRORTYPE ComponentBase::GetRolesOfComponent(OMX_U32 *nr_roles,
117                                                 OMX_U8 **roles)
118{
119    OMX_U32 i;
120    OMX_U32 this_nr_roles = this->nr_roles;
121
122    if (!roles) {
123        *nr_roles = this_nr_roles;
124        return OMX_ErrorNone;
125    }
126
127    if (!nr_roles || (*nr_roles != this_nr_roles))
128        return OMX_ErrorBadParameter;
129
130    for (i = 0; i < this_nr_roles; i++) {
131        if (!roles[i])
132            break;
133
134        if (roles && roles[i])
135            strncpy((OMX_STRING)&roles[i][0],
136                    (const OMX_STRING)&this->roles[i][0],
137                    OMX_MAX_STRINGNAME_SIZE);
138    }
139
140    if (i != this_nr_roles)
141        return OMX_ErrorBadParameter;
142
143    *nr_roles = this_nr_roles;
144    return OMX_ErrorNone;
145}
146
147bool ComponentBase::QueryHavingThisRole(const OMX_STRING role)
148{
149    OMX_U32 i;
150
151    if (!roles || !role)
152        return false;
153
154    for (i = 0; i < nr_roles; i++) {
155        if (!strcmp((OMX_STRING)&roles[i][0], role))
156            return true;
157    }
158
159    return false;
160}
161
162/* end of core methods & helpers */
163
164/*
165 * component methods & helpers
166 */
167OMX_ERRORTYPE ComponentBase::GetComponentVersion(
168    OMX_IN  OMX_HANDLETYPE hComponent,
169    OMX_OUT OMX_STRING pComponentName,
170    OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
171    OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
172    OMX_OUT OMX_UUIDTYPE* pComponentUUID)
173{
174    ComponentBase *cbase;
175
176    if (!hComponent)
177        return OMX_ErrorBadParameter;
178
179    cbase = static_cast<ComponentBase *>
180        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
181    if (!cbase)
182        return OMX_ErrorBadParameter;
183
184    return cbase->CBaseGetComponentVersion(hComponent,
185                                           pComponentName,
186                                           pComponentVersion,
187                                           pSpecVersion,
188                                           pComponentUUID);
189}
190
191OMX_ERRORTYPE ComponentBase::CBaseGetComponentVersion(
192    OMX_IN  OMX_HANDLETYPE hComponent,
193    OMX_OUT OMX_STRING pComponentName,
194    OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
195    OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
196    OMX_OUT OMX_UUIDTYPE* pComponentUUID)
197{
198    /*
199     * Todo
200     */
201
202    return OMX_ErrorNotImplemented;
203}
204
205OMX_ERRORTYPE ComponentBase::SendCommand(
206    OMX_IN  OMX_HANDLETYPE hComponent,
207    OMX_IN  OMX_COMMANDTYPE Cmd,
208    OMX_IN  OMX_U32 nParam1,
209    OMX_IN  OMX_PTR pCmdData)
210{
211    ComponentBase *cbase;
212
213    if (!hComponent)
214        return OMX_ErrorBadParameter;
215
216    cbase = static_cast<ComponentBase *>
217        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
218    if (!cbase)
219        return OMX_ErrorBadParameter;
220
221    return cbase->CBaseSendCommand(hComponent, Cmd, nParam1, pCmdData);
222}
223
224OMX_ERRORTYPE ComponentBase::CBaseSendCommand(
225    OMX_IN  OMX_HANDLETYPE hComponent,
226    OMX_IN  OMX_COMMANDTYPE Cmd,
227    OMX_IN  OMX_U32 nParam1,
228    OMX_IN  OMX_PTR pCmdData)
229{
230    /*
231     * Todo
232     */
233
234    return OMX_ErrorNotImplemented;
235}
236
237OMX_ERRORTYPE ComponentBase::GetParameter(
238    OMX_IN  OMX_HANDLETYPE hComponent,
239    OMX_IN  OMX_INDEXTYPE nParamIndex,
240    OMX_INOUT OMX_PTR pComponentParameterStructure)
241{
242    ComponentBase *cbase;
243
244    if (!hComponent)
245        return OMX_ErrorBadParameter;
246
247    cbase = static_cast<ComponentBase *>
248        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
249    if (!cbase)
250        return OMX_ErrorBadParameter;
251
252    return cbase->CBaseGetParameter(hComponent, nParamIndex,
253                                    pComponentParameterStructure);
254}
255
256OMX_ERRORTYPE ComponentBase::CBaseGetParameter(
257    OMX_IN  OMX_HANDLETYPE hComponent,
258    OMX_IN  OMX_INDEXTYPE nParamIndex,
259    OMX_INOUT OMX_PTR pComponentParameterStructure)
260{
261    /*
262     * Todo
263     */
264
265    return OMX_ErrorNotImplemented;
266}
267
268OMX_ERRORTYPE ComponentBase::SetParameter(
269    OMX_IN  OMX_HANDLETYPE hComponent,
270    OMX_IN  OMX_INDEXTYPE nIndex,
271    OMX_IN  OMX_PTR pComponentParameterStructure)
272{
273    ComponentBase *cbase;
274
275    if (!hComponent)
276        return OMX_ErrorBadParameter;
277
278    cbase = static_cast<ComponentBase *>
279        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
280    if (!cbase)
281        return OMX_ErrorBadParameter;
282
283    return cbase->CBaseSetParameter(hComponent, nIndex,
284                                    pComponentParameterStructure);
285}
286
287OMX_ERRORTYPE ComponentBase::CBaseSetParameter(
288    OMX_IN  OMX_HANDLETYPE hComponent,
289    OMX_IN  OMX_INDEXTYPE nIndex,
290    OMX_IN  OMX_PTR pComponentParameterStructure)
291{
292    /*
293     * Todo
294     */
295
296    return OMX_ErrorNotImplemented;
297}
298
299OMX_ERRORTYPE ComponentBase::GetConfig(
300    OMX_IN  OMX_HANDLETYPE hComponent,
301    OMX_IN  OMX_INDEXTYPE nIndex,
302    OMX_INOUT OMX_PTR pComponentConfigStructure)
303{
304    ComponentBase *cbase;
305
306    if (!hComponent)
307        return OMX_ErrorBadParameter;
308
309    cbase = static_cast<ComponentBase *>
310        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
311    if (!cbase)
312        return OMX_ErrorBadParameter;
313
314    return cbase->CBaseGetConfig(hComponent, nIndex,
315                                 pComponentConfigStructure);
316}
317
318OMX_ERRORTYPE ComponentBase::CBaseGetConfig(
319    OMX_IN  OMX_HANDLETYPE hComponent,
320    OMX_IN  OMX_INDEXTYPE nIndex,
321    OMX_INOUT OMX_PTR pComponentConfigStructure)
322{
323    /*
324     * Todo
325     */
326
327    return OMX_ErrorNotImplemented;
328}
329
330OMX_ERRORTYPE ComponentBase::SetConfig(
331    OMX_IN  OMX_HANDLETYPE hComponent,
332    OMX_IN  OMX_INDEXTYPE nIndex,
333    OMX_IN  OMX_PTR pComponentConfigStructure)
334{
335    ComponentBase *cbase;
336
337    if (!hComponent)
338        return OMX_ErrorBadParameter;
339
340    cbase = static_cast<ComponentBase *>
341        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
342    if (!cbase)
343        return OMX_ErrorBadParameter;
344
345    return cbase->CBaseSetConfig(hComponent, nIndex,
346                                 pComponentConfigStructure);
347}
348
349OMX_ERRORTYPE ComponentBase::CBaseSetConfig(
350    OMX_IN  OMX_HANDLETYPE hComponent,
351    OMX_IN  OMX_INDEXTYPE nIndex,
352    OMX_IN  OMX_PTR pComponentConfigStructure)
353{
354    /*
355     * Todo
356     */
357
358    return OMX_ErrorNotImplemented;
359}
360
361OMX_ERRORTYPE ComponentBase::GetExtensionIndex(
362    OMX_IN  OMX_HANDLETYPE hComponent,
363    OMX_IN  OMX_STRING cParameterName,
364    OMX_OUT OMX_INDEXTYPE* pIndexType)
365{
366    ComponentBase *cbase;
367
368    if (!hComponent)
369        return OMX_ErrorBadParameter;
370
371    cbase = static_cast<ComponentBase *>
372        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
373    if (!cbase)
374        return OMX_ErrorBadParameter;
375
376    return cbase->CBaseGetExtensionIndex(hComponent, cParameterName,
377                                         pIndexType);
378}
379
380OMX_ERRORTYPE ComponentBase::CBaseGetExtensionIndex(
381    OMX_IN  OMX_HANDLETYPE hComponent,
382    OMX_IN  OMX_STRING cParameterName,
383    OMX_OUT OMX_INDEXTYPE* pIndexType)
384{
385    /*
386     * Todo
387     */
388
389    return OMX_ErrorNotImplemented;
390}
391
392OMX_ERRORTYPE ComponentBase::GetState(
393    OMX_IN  OMX_HANDLETYPE hComponent,
394    OMX_OUT OMX_STATETYPE* pState)
395{
396    ComponentBase *cbase;
397
398    if (!hComponent)
399        return OMX_ErrorBadParameter;
400
401    cbase = static_cast<ComponentBase *>
402        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
403    if (!cbase)
404        return OMX_ErrorBadParameter;
405
406    return cbase->CBaseGetState(hComponent, pState);
407}
408
409OMX_ERRORTYPE ComponentBase::CBaseGetState(
410    OMX_IN  OMX_HANDLETYPE hComponent,
411    OMX_OUT OMX_STATETYPE* pState)
412{
413    /*
414     * Todo
415     */
416
417    return OMX_ErrorNotImplemented;
418}
419
420OMX_ERRORTYPE ComponentBase::ComponentTunnelRequest(
421    OMX_IN  OMX_HANDLETYPE hComponent,
422    OMX_IN  OMX_U32 nPort,
423    OMX_IN  OMX_HANDLETYPE hTunneledComponent,
424    OMX_IN  OMX_U32 nTunneledPort,
425    OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup)
426{
427    ComponentBase *cbase;
428
429    if (!hComponent)
430        return OMX_ErrorBadParameter;
431
432    cbase = static_cast<ComponentBase *>
433        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
434    if (!cbase)
435        return OMX_ErrorBadParameter;
436
437    return cbase->CBaseComponentTunnelRequest(hComponent, nPort,
438                                              hTunneledComponent,
439                                              nTunneledPort, pTunnelSetup);
440}
441
442OMX_ERRORTYPE ComponentBase::CBaseComponentTunnelRequest(
443    OMX_IN  OMX_HANDLETYPE hComp,
444    OMX_IN  OMX_U32 nPort,
445    OMX_IN  OMX_HANDLETYPE hTunneledComp,
446    OMX_IN  OMX_U32 nTunneledPort,
447    OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup)
448{
449    /*
450     * Todo
451     */
452
453    return OMX_ErrorNotImplemented;
454}
455
456OMX_ERRORTYPE ComponentBase::UseBuffer(
457    OMX_IN OMX_HANDLETYPE hComponent,
458    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
459    OMX_IN OMX_U32 nPortIndex,
460    OMX_IN OMX_PTR pAppPrivate,
461    OMX_IN OMX_U32 nSizeBytes,
462    OMX_IN OMX_U8* pBuffer)
463{
464    ComponentBase *cbase;
465
466    if (!hComponent)
467        return OMX_ErrorBadParameter;
468
469    cbase = static_cast<ComponentBase *>
470        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
471    if (!cbase)
472        return OMX_ErrorBadParameter;
473
474    return cbase->CBaseUseBuffer(hComponent, ppBufferHdr, nPortIndex,
475                                 pAppPrivate, nSizeBytes, pBuffer);
476}
477
478OMX_ERRORTYPE ComponentBase::CBaseUseBuffer(
479    OMX_IN OMX_HANDLETYPE hComponent,
480    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
481    OMX_IN OMX_U32 nPortIndex,
482    OMX_IN OMX_PTR pAppPrivate,
483    OMX_IN OMX_U32 nSizeBytes,
484    OMX_IN OMX_U8* pBuffer)
485{
486    /*
487     * Todo
488     */
489
490    return OMX_ErrorNotImplemented;
491}
492
493OMX_ERRORTYPE ComponentBase::AllocateBuffer(
494    OMX_IN OMX_HANDLETYPE hComponent,
495    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
496    OMX_IN OMX_U32 nPortIndex,
497    OMX_IN OMX_PTR pAppPrivate,
498    OMX_IN OMX_U32 nSizeBytes)
499{
500    ComponentBase *cbase;
501
502    if (!hComponent)
503        return OMX_ErrorBadParameter;
504
505    cbase = static_cast<ComponentBase *>
506        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
507    if (!cbase)
508        return OMX_ErrorBadParameter;
509
510    return cbase->CBaseAllocateBuffer(hComponent, ppBuffer, nPortIndex,
511                                      pAppPrivate, nSizeBytes);
512}
513
514OMX_ERRORTYPE ComponentBase::CBaseAllocateBuffer(
515    OMX_IN OMX_HANDLETYPE hComponent,
516    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
517    OMX_IN OMX_U32 nPortIndex,
518    OMX_IN OMX_PTR pAppPrivate,
519    OMX_IN OMX_U32 nSizeBytes)
520{
521    /*
522     * Todo
523     */
524
525    return OMX_ErrorNotImplemented;
526}
527
528OMX_ERRORTYPE ComponentBase::FreeBuffer(
529    OMX_IN  OMX_HANDLETYPE hComponent,
530    OMX_IN  OMX_U32 nPortIndex,
531    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
532{
533    ComponentBase *cbase;
534
535    if (!hComponent)
536        return OMX_ErrorBadParameter;
537
538    cbase = static_cast<ComponentBase *>
539        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
540    if (!cbase)
541        return OMX_ErrorBadParameter;
542
543    return cbase->CBaseFreeBuffer(hComponent, nPortIndex, pBuffer);
544}
545
546OMX_ERRORTYPE ComponentBase::CBaseFreeBuffer(
547    OMX_IN  OMX_HANDLETYPE hComponent,
548    OMX_IN  OMX_U32 nPortIndex,
549    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
550{
551    /*
552     * Todo
553     */
554
555    return OMX_ErrorNotImplemented;
556}
557
558OMX_ERRORTYPE ComponentBase::EmptyThisBuffer(
559    OMX_IN  OMX_HANDLETYPE hComponent,
560    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
561{
562    ComponentBase *cbase;
563
564    if (!hComponent)
565        return OMX_ErrorBadParameter;
566
567    cbase = static_cast<ComponentBase *>
568        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
569    if (!cbase)
570        return OMX_ErrorBadParameter;
571
572    return cbase->CBaseEmptyThisBuffer(hComponent, pBuffer);
573}
574
575OMX_ERRORTYPE ComponentBase::CBaseEmptyThisBuffer(
576    OMX_IN  OMX_HANDLETYPE hComponent,
577    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
578{
579    /*
580     * Todo
581     */
582
583    return OMX_ErrorNotImplemented;
584}
585
586OMX_ERRORTYPE ComponentBase::FillThisBuffer(
587    OMX_IN  OMX_HANDLETYPE hComponent,
588    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
589{
590    ComponentBase *cbase;
591
592    if (!hComponent)
593        return OMX_ErrorBadParameter;
594
595    cbase = static_cast<ComponentBase *>
596        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
597    if (!cbase)
598        return OMX_ErrorBadParameter;
599
600    return cbase->CBaseFillThisBuffer(hComponent, pBuffer);
601}
602
603OMX_ERRORTYPE ComponentBase::CBaseFillThisBuffer(
604    OMX_IN  OMX_HANDLETYPE hComponent,
605    OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer)
606{
607    /*
608     * Todo
609     */
610
611    return OMX_ErrorNotImplemented;
612}
613
614OMX_ERRORTYPE ComponentBase::SetCallbacks(
615    OMX_IN  OMX_HANDLETYPE hComponent,
616    OMX_IN  OMX_CALLBACKTYPE* pCallbacks,
617    OMX_IN  OMX_PTR pAppData)
618{
619    ComponentBase *cbase;
620
621    if (!hComponent)
622        return OMX_ErrorBadParameter;
623
624    cbase = static_cast<ComponentBase *>
625        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
626    if (!cbase)
627        return OMX_ErrorBadParameter;
628
629    return cbase->CBaseSetCallbacks(hComponent, pCallbacks, pAppData);
630}
631
632OMX_ERRORTYPE ComponentBase::CBaseSetCallbacks(
633    OMX_IN  OMX_HANDLETYPE hComponent,
634    OMX_IN  OMX_CALLBACKTYPE* pCallbacks,
635    OMX_IN  OMX_PTR pAppData)
636{
637    /*
638     * Todo
639     */
640
641    return OMX_ErrorNotImplemented;
642}
643
644OMX_ERRORTYPE ComponentBase::ComponentDeInit(
645    OMX_IN  OMX_HANDLETYPE hComponent)
646{
647    ComponentBase *cbase;
648
649    if (!hComponent)
650        return OMX_ErrorBadParameter;
651
652    cbase = static_cast<ComponentBase *>
653        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
654    if (!cbase)
655        return OMX_ErrorBadParameter;
656
657    return cbase->CBaseComponentDeInit(hComponent);
658}
659
660OMX_ERRORTYPE ComponentBase::CBaseComponentDeInit(
661    OMX_IN  OMX_HANDLETYPE hComponent)
662{
663    /*
664     * Todo
665     */
666
667    return OMX_ErrorNotImplemented;
668}
669
670OMX_ERRORTYPE ComponentBase::UseEGLImage(
671    OMX_IN OMX_HANDLETYPE hComponent,
672    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
673    OMX_IN OMX_U32 nPortIndex,
674    OMX_IN OMX_PTR pAppPrivate,
675    OMX_IN void* eglImage)
676{
677    ComponentBase *cbase;
678
679    if (!hComponent)
680        return OMX_ErrorBadParameter;
681
682    cbase = static_cast<ComponentBase *>
683        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
684    if (!cbase)
685        return OMX_ErrorBadParameter;
686
687    return cbase->CBaseUseEGLImage(hComponent, ppBufferHdr, nPortIndex,
688                                   pAppPrivate, eglImage);
689}
690
691OMX_ERRORTYPE ComponentBase::CBaseUseEGLImage(
692    OMX_IN OMX_HANDLETYPE hComponent,
693    OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
694    OMX_IN OMX_U32 nPortIndex,
695    OMX_IN OMX_PTR pAppPrivate,
696    OMX_IN void* eglImage)
697{
698    /*
699     * Todo
700     */
701
702    return OMX_ErrorNotImplemented;
703}
704
705OMX_ERRORTYPE ComponentBase::ComponentRoleEnum(
706    OMX_IN OMX_HANDLETYPE hComponent,
707    OMX_OUT OMX_U8 *cRole,
708    OMX_IN OMX_U32 nIndex)
709{
710    ComponentBase *cbase;
711
712    if (!hComponent)
713        return OMX_ErrorBadParameter;
714
715    cbase = static_cast<ComponentBase *>
716        (((OMX_COMPONENTTYPE *)hComponent)->pComponentPrivate);
717    if (!cbase)
718        return OMX_ErrorBadParameter;
719
720    return cbase->CBaseComponentRoleEnum(hComponent, cRole, nIndex);
721}
722
723OMX_ERRORTYPE ComponentBase::CBaseComponentRoleEnum(
724    OMX_IN OMX_HANDLETYPE hComponent,
725    OMX_OUT OMX_U8 *cRole,
726    OMX_IN OMX_U32 nIndex)
727{
728    if (hComponent != (OMX_HANDLETYPE *)this->handle)
729        return OMX_ErrorBadParameter;
730
731    if (nIndex > nr_roles)
732        return OMX_ErrorBadParameter;
733
734    strncpy((char *)cRole, (const char *)roles[nIndex],
735            OMX_MAX_STRINGNAME_SIZE);
736    return OMX_ErrorNone;
737}
738
739/* end of component methods & helpers */
740
741/*
742 * omx header manipuation
743 */
744void ComponentBase::SetTypeHeader(OMX_PTR type, OMX_U32 size)
745{
746    OMX_U32 *nsize;
747    OMX_VERSIONTYPE *nversion;
748
749    if (!type)
750        return;
751
752    nsize = (OMX_U32 *)type;
753    nversion = (OMX_VERSIONTYPE *)((OMX_U8 *)type + sizeof(OMX_U32));
754
755    *nsize = sizeof(size);
756    nversion->nVersion = OMX_SPEC_VERSION;
757}
758
759OMX_BOOL ComponentBase::CheckTypeHeader(OMX_PTR type, OMX_U32 size)
760{
761    OMX_U32 *nsize;
762    OMX_VERSIONTYPE *nversion;
763    OMX_U8 mismatch = 0;
764
765    if (!type)
766        return OMX_FALSE;
767
768    nsize = (OMX_U32 *)type;
769    nversion = (OMX_VERSIONTYPE *)((OMX_U8 *)type + sizeof(OMX_U32));
770
771    mismatch = (*nsize != sizeof(size)) ? 1 : 0;
772    mismatch |= (nversion->nVersion != OMX_SPEC_VERSION) ? 1 : 0;
773
774    if (mismatch)
775        return OMX_TRUE;
776    else
777        return OMX_FALSE;
778}
779