1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:  HDMI sink object

    15  *

    16  */

    17 

    18 #include <accpolhdmispeakerallocation.h>

    19 #include <accpolobjecttypes.h>

    20 

    21 #include "acc_debug.h"

    22 

    23 // -----------------------------------------------------------------------------

    24 // CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation()

    25 // C++ default constructor can NOT contain any code, that

    26 // might leave.

    27 // -----------------------------------------------------------------------------

    28 //

    29 CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation( CAccPolObjectCon* aObject ) :

    30     CAccPolObjectBase( EAccPolHdmiSpeakerAllocationObject, aObject )

    31     {

    32     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Enter" );

    33     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Return" );

    34     }

    35 

    36 // -----------------------------------------------------------------------------

    37 // CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation()

    38 // C++ default constructor can NOT contain any code, that

    39 // might leave.

    40 // -----------------------------------------------------------------------------

    41 //

    42 CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation( const TBool aFrontSpeakers,

    43     const TBool aRearSpeakers,

    44     const TBool aLowFrequencyEffect,

    45     const TBool aFrontCenter,

    46     const TBool aFrontCenterHigh,

    47     const TBool aTopCenter,

    48     const TBool aRearCenter,

    49     const TBool aFrontLeftRightCenter,

    50     const TBool aRearLeftRightCenter,

    51     const TBool aFrontWideSpeakers,

    52     const TBool aFrontHighSpeakers ) :

    53     CAccPolObjectBase( EAccPolHdmiSpeakerAllocationObject ),

    54         iSpeakerAllocation( EHdmiSpeakerUnknown )

    55     {

    56     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Enter" );

    57 

    58     if( aFrontSpeakers )

    59         {

    60         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRight;

    61         iSpeakerCount += 2;

    62         }

    63     if( aRearSpeakers )

    64         {

    65         iSpeakerAllocation |= EHdmiSpeakerRearLeftRight;

    66         iSpeakerCount += 2;

    67         }

    68     if( aLowFrequencyEffect )

    69         {

    70         iSpeakerAllocation |= EHdmiSpeakerLowFrequencyEffect;

    71         ++iSpeakerCount;

    72         }

    73     if( aFrontCenter )

    74         {

    75         iSpeakerAllocation |= EHdmiSpeakerFrontCenter;

    76         ++iSpeakerCount;

    77         }

    78     if( aFrontCenterHigh )

    79         {

    80         iSpeakerAllocation |= EHdmiSpeakerFrontCenterHigh;

    81         ++iSpeakerCount;

    82         }

    83     if( aTopCenter )

    84         {

    85         iSpeakerAllocation |= EHdmiSpeakerTopCenter;

    86         ++iSpeakerCount;

    87         }

    88     if( aRearCenter )

    89         {

    90         iSpeakerAllocation |= EHdmiSpeakerRearCenter;

    91         ++iSpeakerCount;

    92         }

    93     if( aFrontLeftRightCenter )

    94         {

    95         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightCenter;

    96         iSpeakerCount += 2;

    97         }

    98     if( aRearLeftRightCenter )

    99         {

   100         iSpeakerAllocation |= EHdmiSpeakerRearLeftRightCenter;

   101         iSpeakerCount += 2;

   102         }

   103     if( aFrontWideSpeakers )

   104         {

   105         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightWide;

   106         iSpeakerCount += 2;

   107         }

   108     if( aFrontHighSpeakers )

   109         {

   110         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightHigh;

   111         iSpeakerCount += 2;

   112         }

   113 

   114     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Return" );

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation()

   119 // C++ default constructor can NOT contain any code, that

   120 // might leave.

   121 // -----------------------------------------------------------------------------

   122 //

   123 CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation( const TUint32 aSpeakerAllocation ) :

   124     CAccPolObjectBase( EAccPolHdmiSpeakerAllocationObject ),

   125         iSpeakerAllocation( aSpeakerAllocation ), iSpeakerCount( 0 )

   126     {

   127     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Enter" );

   128 

   129     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRight )

   130         {

   131         iSpeakerCount += 2;

   132         }

   133     if( aSpeakerAllocation & EHdmiSpeakerRearLeftRight )

   134         {

   135         iSpeakerCount += 2;

   136         }

   137     if( aSpeakerAllocation & EHdmiSpeakerLowFrequencyEffect )

   138         {

   139         ++iSpeakerCount;

   140         }

   141     if( aSpeakerAllocation & EHdmiSpeakerFrontCenter )

   142         {

   143         ++iSpeakerCount;

   144         }

   145     if( aSpeakerAllocation & EHdmiSpeakerFrontCenterHigh )

   146         {

   147         ++iSpeakerCount;

   148         }

   149     if( aSpeakerAllocation & EHdmiSpeakerTopCenter )

   150         {

   151         ++iSpeakerCount;

   152         }

   153     if( aSpeakerAllocation & EHdmiSpeakerRearCenter )

   154         {

   155         ++iSpeakerCount;

   156         }

   157     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightCenter )

   158         {

   159         iSpeakerCount += 2;

   160         }

   161     if( aSpeakerAllocation & EHdmiSpeakerRearLeftRightCenter )

   162         {

   163         iSpeakerCount += 2;

   164         }

   165     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightWide )

   166         {

   167         iSpeakerCount += 2;

   168         }

   169     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightHigh )

   170         {

   171         iSpeakerCount += 2;

   172         }

   173 

   174     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::CAccPolHdmiSpeakerAllocation() - Return" );

   175     }

   176 

   177 // ---------------------------------------------------------------------------

   178 // CAccPolHdmiSpeakerAllocation::NewL()

   179 // ---------------------------------------------------------------------------

   180 //

   181 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewL( CAccPolObjectCon* aObject )

   182     {

   183     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL() - Enter" );

   184     CAccPolHdmiSpeakerAllocation* self =

   185         CAccPolHdmiSpeakerAllocation::NewLC( aObject );

   186     CleanupStack::Pop( self );

   187     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL() - Return" );

   188     return self;

   189     }

   190 

   191 // ---------------------------------------------------------------------------

   192 // CAccPolHdmiSpeakerAllocation::NewLC()

   193 // ---------------------------------------------------------------------------

   194 //

   195 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewLC( CAccPolObjectCon* aObject )

   196     {

   197     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Enter" );

   198     CAccPolHdmiSpeakerAllocation* self =

   199         new ( ELeave ) CAccPolHdmiSpeakerAllocation( aObject );

   200     CleanupStack::PushL( self );

   201     self->ConstructL();

   202     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Return" );

   203     return self;

   204     }

   205 

   206 // ---------------------------------------------------------------------------

   207 // CAccPolHdmiSpeakerAllocation::NewL()

   208 // ---------------------------------------------------------------------------

   209 //

   210 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewL( const TUint32 aSpeakerAllocation )

   211     {

   212     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL() - Enter" );

   213     CAccPolHdmiSpeakerAllocation* self =

   214         CAccPolHdmiSpeakerAllocation::NewLC( aSpeakerAllocation );

   215     CleanupStack::Pop( self );

   216     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL() - Return" );

   217     return self;

   218     }

   219 

   220 // ---------------------------------------------------------------------------

   221 // CAccPolHdmiSpeakerAllocation::NewLC()

   222 // ---------------------------------------------------------------------------

   223 //

   224 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewLC( const TUint32 aSpeakerAllocation )

   225     {

   226     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Enter" );

   227     CAccPolHdmiSpeakerAllocation* self =

   228         new ( ELeave ) CAccPolHdmiSpeakerAllocation( aSpeakerAllocation );

   229     CleanupStack::PushL( self );

   230     self->ConstructL();

   231     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Return" );

   232     return self;

   233     }

   234 

   235 // ---------------------------------------------------------------------------

   236 // CAccPolHdmiSpeakerAllocation::NewL()

   237 // ---------------------------------------------------------------------------

   238 //

   239 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewL( const TBool aFrontSpeakers,

   240     const TBool aRearSpeakers,

   241     const TBool aLowFrequencyEffect,

   242     const TBool aFrontCenter,

   243     const TBool aFrontCenterHigh,

   244     const TBool aTopCenter,

   245     const TBool aRearCenter,

   246     const TBool aFrontLeftRightCenter,

   247     const TBool aRearLeftRightCenter,

   248     const TBool aFrontWideSpeakers,

   249     const TBool aFrontHighSpeakers )

   250     {

   251     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL() - Enter" );

   252     CAccPolHdmiSpeakerAllocation* self =

   253         CAccPolHdmiSpeakerAllocation::NewLC( aFrontSpeakers,

   254             aRearSpeakers,

   255             aLowFrequencyEffect,

   256             aFrontCenter,

   257             aFrontCenterHigh,

   258             aTopCenter,

   259             aRearCenter,

   260             aFrontLeftRightCenter,

   261             aRearLeftRightCenter,

   262             aFrontWideSpeakers,

   263             aFrontHighSpeakers );

   264 

   265     CleanupStack::Pop( self );

   266     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewL()- Return" );

   267     return self;

   268     }

   269 

   270 // ---------------------------------------------------------------------------

   271 // CAccPolHdmiSpeakerAllocation::NewLC()

   272 // ---------------------------------------------------------------------------

   273 //

   274 EXPORT_C CAccPolHdmiSpeakerAllocation* CAccPolHdmiSpeakerAllocation::NewLC( const TBool aFrontSpeakers,

   275     const TBool aRearSpeakers,

   276     const TBool aLowFrequencyEffect,

   277     const TBool aFrontCenter,

   278     const TBool aFrontCenterHigh,

   279     const TBool aTopCenter,

   280     const TBool aRearCenter,

   281     const TBool aFrontLeftRightCenter,

   282     const TBool aRearLeftRightCenter,

   283     const TBool aFrontWideSpeakers,

   284     const TBool aFrontHighSpeakers )

   285     {

   286     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Enter" );

   287     CAccPolHdmiSpeakerAllocation* self =

   288         new ( ELeave ) CAccPolHdmiSpeakerAllocation( aFrontSpeakers,

   289             aRearSpeakers,

   290             aLowFrequencyEffect,

   291             aFrontCenter,

   292             aFrontCenterHigh,

   293             aTopCenter,

   294             aRearCenter,

   295             aFrontLeftRightCenter,

   296             aRearLeftRightCenter,

   297             aFrontWideSpeakers,

   298             aFrontHighSpeakers );

   299     CleanupStack::PushL( self );

   300     self->ConstructL();

   301     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::NewLC() - Return" );

   302     return self;

   303     }

   304 

   305 // ---------------------------------------------------------------------------

   306 // CAccPolHdmiSpeakerAllocation::ConstructL()

   307 // ---------------------------------------------------------------------------

   308 //

   309 void CAccPolHdmiSpeakerAllocation::ConstructL()

   310     {

   311     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ConstructL() - Enter" );

   312     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ConstructL() - Return" );

   313     }

   314 

   315 // Destructor

   316 CAccPolHdmiSpeakerAllocation::~CAccPolHdmiSpeakerAllocation()

   317     {

   318     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::~CAccPolHdmiSpeakerAllocation() - Enter" );

   319     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::~CAccPolHdmiSpeakerAllocation() - Return" );

   320     }

   321 

   322 // ---------------------------------------------------------------------------

   323 // CAccPolHdmiSpeakerAllocation::operator()

   324 // ---------------------------------------------------------------------------

   325 //

   326 EXPORT_C CAccPolHdmiSpeakerAllocation& CAccPolHdmiSpeakerAllocation::operator=( const CAccPolHdmiSpeakerAllocation& aOutputTerminalObject )

   327     {

   328     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::operator() - Enter" );

   329     CAccPolObjectBase::operator=( ( CAccPolObjectBase& )aOutputTerminalObject );

   330 

   331     iSpeakerAllocation = aOutputTerminalObject.SpeakerAllocation();

   332     iSpeakerCount = aOutputTerminalObject.SpeakerCount();

   333 

   334     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::operator() - Return" );

   335     return ( *this );

   336     }

   337 

   338 // ---------------------------------------------------------------------------

   339 // CAccPolHdmiSpeakerAllocation::ExternalizeL()

   340 // ---------------------------------------------------------------------------

   341 //

   342 void CAccPolHdmiSpeakerAllocation::ExternalizeL( RWriteStream& aStream ) const

   343     {

   344     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ExternalizeL() - Enter" );

   345 

   346     // Add object type at the beginning

   347     aStream.WriteUint8L( ObjectType() );

   348 

   349     // Object data

   350     aStream.WriteUint32L( SpeakerAllocation() );

   351     aStream.WriteUint32L( SpeakerCount() );

   352 

   353     API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ExternalizeL - Speaker Allocation  = %d", iSpeakerAllocation );

   354     API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ExternalizeL - Speaker Count  = %d", iSpeakerCount );

   355     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::ExternalizeL - Return" );

   356     }

   357 

   358 // ---------------------------------------------------------------------------

   359 // CAccPolHdmiSpeakerAllocation::InternalizeL()

   360 // ---------------------------------------------------------------------------

   361 //

   362 void CAccPolHdmiSpeakerAllocation::InternalizeL( RReadStream& aStream )

   363     {

   364     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::InternalizeL() - Enter" );

   365 

   366     // Object data

   367     iSpeakerAllocation = aStream.ReadUint32L();

   368     iSpeakerCount = aStream.ReadUint32L();

   369 

   370     API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::InternalizeL - Speaker Allocation  = %d", iSpeakerAllocation );

   371     API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::InternalizeL - Speaker Count  = %d", iSpeakerCount );

   372     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::InternalizeL - Return" );

   373     }

   374 

   375 // ---------------------------------------------------------------------------

   376 // CAccPolHdmiSpeakerAllocation::DuplicateL()

   377 // ---------------------------------------------------------------------------

   378 //

   379 CAccPolObjectBase* CAccPolHdmiSpeakerAllocation::DuplicateLC( CAccPolObjectCon* aObject )

   380     {

   381     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::DuplicateLC() - Enter" );

   382     CAccPolHdmiSpeakerAllocation* aOutput =

   383         CAccPolHdmiSpeakerAllocation::NewLC( aObject );

   384     *aOutput = ( CAccPolHdmiSpeakerAllocation& )*this;

   385     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::DuplicateLC() - Return" );

   386     return aOutput;

   387     }

   388 

   389 // ---------------------------------------------------------------------------

   390 // CAccPolHdmiSpeakerAllocation::SetSpeakerAllocation()

   391 // ---------------------------------------------------------------------------

   392 //

   393 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetSpeakerAllocation( const TUint32 aSpeakerAllocation )

   394     {

   395     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerAllocation() - Enter" );

   396 

   397     iSpeakerAllocation = aSpeakerAllocation;

   398     iSpeakerCount = 0;

   399     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRight )

   400         {

   401         iSpeakerCount += 2;

   402         }

   403     if( aSpeakerAllocation & EHdmiSpeakerRearLeftRight )

   404         {

   405         iSpeakerCount += 2;

   406         }

   407     if( aSpeakerAllocation & EHdmiSpeakerLowFrequencyEffect )

   408         {

   409         ++iSpeakerCount;

   410         }

   411     if( aSpeakerAllocation & EHdmiSpeakerFrontCenter )

   412         {

   413         ++iSpeakerCount;

   414         }

   415     if( aSpeakerAllocation & EHdmiSpeakerFrontCenterHigh )

   416         {

   417         ++iSpeakerCount;

   418         }

   419     if( aSpeakerAllocation & EHdmiSpeakerTopCenter )

   420         {

   421         ++iSpeakerCount;

   422         }

   423     if( aSpeakerAllocation & EHdmiSpeakerRearCenter )

   424         {

   425         ++iSpeakerCount;

   426         }

   427     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightCenter )

   428         {

   429         iSpeakerCount += 2;

   430         }

   431     if( aSpeakerAllocation & EHdmiSpeakerRearLeftRightCenter )

   432         {

   433         iSpeakerCount += 2;

   434         }

   435     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightWide )

   436         {

   437         iSpeakerCount += 2;

   438         }

   439     if( aSpeakerAllocation & EHdmiSpeakerFrontLeftRightHigh )

   440         {

   441         iSpeakerCount += 2;

   442         }

   443 

   444     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerAllocation() - Return" );

   445     }

   446 

   447 // ---------------------------------------------------------------------------

   448 // CAccPolHdmiSpeakerAllocation::SetFrontSpeakers()

   449 // ---------------------------------------------------------------------------

   450 //

   451 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontSpeakers( const TBool aValue )

   452     {

   453     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontSpeakers() - Enter" );

   454     if( !( iSpeakerAllocation & EHdmiSpeakerFrontLeftRight ) && aValue )

   455         {

   456         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRight;

   457         iSpeakerCount += 2;

   458         }

   459     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRight ) && !aValue )

   460         {

   461         iSpeakerAllocation &= ~EHdmiSpeakerFrontLeftRight;

   462         iSpeakerCount -= 2;

   463         }

   464     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontSpeakers() - Return" );

   465     }

   466 

   467 // ---------------------------------------------------------------------------

   468 // CAccPolHdmiSpeakerAllocation::SetRearSpeakers()

   469 // ---------------------------------------------------------------------------

   470 //

   471 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetRearSpeakers( const TBool aValue )

   472     {

   473     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearSpeakers() - Enter" );

   474     if( !( iSpeakerAllocation & EHdmiSpeakerRearLeftRight ) && aValue )

   475         {

   476         iSpeakerAllocation |= EHdmiSpeakerRearLeftRight;

   477         iSpeakerCount += 2;

   478         }

   479     else if( ( iSpeakerAllocation & EHdmiSpeakerRearLeftRight ) && !aValue )

   480         {

   481         iSpeakerAllocation &= ~EHdmiSpeakerRearLeftRight;

   482         iSpeakerCount -= 2;

   483         }

   484     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearSpeakers() - Return" );

   485     }

   486 

   487 // ---------------------------------------------------------------------------

   488 // CAccPolHdmiSpeakerAllocation::SetLowFrequencyEffect()

   489 // ---------------------------------------------------------------------------

   490 //

   491 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetLowFrequencyEffect( const TBool aValue )

   492     {

   493     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetLowFrequencyEffect() - Enter" );

   494     if( !( iSpeakerAllocation & EHdmiSpeakerLowFrequencyEffect ) && aValue )

   495         {

   496         iSpeakerAllocation |= EHdmiSpeakerLowFrequencyEffect;

   497         ++iSpeakerCount;

   498         }

   499     else if( ( iSpeakerAllocation & EHdmiSpeakerLowFrequencyEffect ) && !aValue )

   500         {

   501         iSpeakerAllocation &= ~EHdmiSpeakerLowFrequencyEffect;

   502         --iSpeakerCount;

   503         }

   504     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetLowFrequencyEffect() - Return" );

   505     }

   506 

   507 // ---------------------------------------------------------------------------

   508 // CAccPolHdmiSpeakerAllocation::SetFrontCenter()

   509 // ---------------------------------------------------------------------------

   510 //

   511 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontCenter( const TBool aValue )

   512     {

   513     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontCenter() - Enter" );

   514     if( !( iSpeakerAllocation & EHdmiSpeakerFrontCenter ) && aValue )

   515         {

   516         iSpeakerAllocation |= EHdmiSpeakerFrontCenter;

   517         ++iSpeakerCount;

   518         }

   519     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontCenter ) && !aValue )

   520         {

   521         iSpeakerAllocation &= ~EHdmiSpeakerFrontCenter;

   522         --iSpeakerCount;

   523         }

   524     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontCenter() - Return" );

   525     }

   526 

   527 // ---------------------------------------------------------------------------

   528 // CAccPolHdmiSpeakerAllocation::SetFrontCenterHigh()

   529 // ---------------------------------------------------------------------------

   530 //

   531 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontCenterHigh( const TBool aValue )

   532     {

   533     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontCenterHigh() - Enter" );

   534     if( !( iSpeakerAllocation & EHdmiSpeakerFrontCenterHigh ) && aValue )

   535         {

   536         iSpeakerAllocation |= EHdmiSpeakerFrontCenterHigh;

   537         ++iSpeakerCount;

   538         }

   539     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontCenterHigh ) && !aValue )

   540         {

   541         iSpeakerAllocation &= ~EHdmiSpeakerFrontCenterHigh;

   542         --iSpeakerCount;

   543         }

   544     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontCenterHigh() - Return" );

   545     }

   546 

   547 // ---------------------------------------------------------------------------

   548 // CAccPolHdmiSpeakerAllocation::SetTopCenter()

   549 // ---------------------------------------------------------------------------

   550 //

   551 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetTopCenter( const TBool aValue )

   552     {

   553     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetTopCenter() - Enter" );

   554     if( !( iSpeakerAllocation & EHdmiSpeakerTopCenter ) && aValue )

   555         {

   556         iSpeakerAllocation |= EHdmiSpeakerTopCenter;

   557         ++iSpeakerCount;

   558         }

   559     else if( ( iSpeakerAllocation & EHdmiSpeakerTopCenter ) && !aValue )

   560         {

   561         iSpeakerAllocation &= ~EHdmiSpeakerTopCenter;

   562         --iSpeakerCount;

   563         }

   564     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetTopCenter() - Return" );

   565     }

   566 

   567 // ---------------------------------------------------------------------------

   568 // CAccPolHdmiSpeakerAllocation::SetRearCenter()

   569 // ---------------------------------------------------------------------------

   570 //

   571 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetRearCenter( const TBool aValue )

   572     {

   573     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearCenter() - Enter" );

   574     if( !( iSpeakerAllocation & EHdmiSpeakerRearCenter ) && aValue )

   575         {

   576         iSpeakerAllocation |= EHdmiSpeakerRearCenter;

   577         ++iSpeakerCount;

   578         }

   579     else if( ( iSpeakerAllocation & EHdmiSpeakerRearCenter ) && !aValue )

   580         {

   581         iSpeakerAllocation &= ~EHdmiSpeakerRearCenter;

   582         --iSpeakerCount;

   583         }

   584     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearCenter() - Return" );

   585     }

   586 

   587 // ---------------------------------------------------------------------------

   588 // CAccPolHdmiSpeakerAllocation::SetFrontLeftRightCenter()

   589 // ---------------------------------------------------------------------------

   590 //

   591 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontLeftRightCenter( const TBool aValue )

   592     {

   593     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontLeftRightCenter() - Enter" );

   594     if( !( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightCenter ) && aValue )

   595         {

   596         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightCenter;

   597         iSpeakerCount += 2;

   598         }

   599     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightCenter )

   600         && !aValue )

   601         {

   602         iSpeakerAllocation &= ~EHdmiSpeakerFrontLeftRightCenter;

   603         iSpeakerCount -= 2;

   604         }

   605     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontLeftRightCenter() - Return" );

   606     }

   607 

   608 // ---------------------------------------------------------------------------

   609 // CAccPolHdmiSpeakerAllocation::SetRearLeftRightCenter()

   610 // ---------------------------------------------------------------------------

   611 //

   612 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetRearLeftRightCenter( const TBool aValue )

   613     {

   614     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearLeftRightCenter() - Enter" );

   615     if( !( iSpeakerAllocation & EHdmiSpeakerRearLeftRightCenter ) && aValue )

   616         {

   617         iSpeakerAllocation |= EHdmiSpeakerRearLeftRightCenter;

   618         iSpeakerCount += 2;

   619         }

   620     else if( ( iSpeakerAllocation & EHdmiSpeakerRearLeftRightCenter )

   621         && !aValue )

   622         {

   623         iSpeakerAllocation &= ~EHdmiSpeakerRearLeftRightCenter;

   624         iSpeakerCount -= 2;

   625         }

   626     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetRearLeftRightCenter() - Return" );

   627     }

   628 

   629 // ---------------------------------------------------------------------------

   630 // CAccPolHdmiSpeakerAllocation::SetFrontWideSpeakers()

   631 // ---------------------------------------------------------------------------

   632 //

   633 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontWideSpeakers( const TBool aValue )

   634     {

   635     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontWideSpeakers() - Enter" );

   636     if( !( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightWide ) && aValue )

   637         {

   638         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightWide;

   639         iSpeakerCount += 2;

   640         }

   641     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightWide ) && !aValue )

   642         {

   643         iSpeakerAllocation &= ~EHdmiSpeakerFrontLeftRightWide;

   644         iSpeakerCount -= 2;

   645         }

   646     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontWideSpeakers() - Return" );

   647     }

   648 

   649 // ---------------------------------------------------------------------------

   650 // CAccPolHdmiSpeakerAllocation::SetFrontHighSpeakers()

   651 // ---------------------------------------------------------------------------

   652 //

   653 EXPORT_C void CAccPolHdmiSpeakerAllocation::SetFrontHighSpeakers( const TBool aValue )

   654     {

   655     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontHighSpeakers() - Enter" );

   656     if( !( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightHigh ) && aValue )

   657         {

   658         iSpeakerAllocation |= EHdmiSpeakerFrontLeftRightHigh;

   659         iSpeakerCount += 2;

   660         }

   661     else if( ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightHigh ) && !aValue )

   662         {

   663         iSpeakerAllocation &= ~EHdmiSpeakerFrontLeftRightHigh;

   664         iSpeakerCount -= 2;

   665         }

   666     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SetFrontHighSpeakers() - Return" );

   667     }

   668 

   669 // ---------------------------------------------------------------------------

   670 // CAccPolHdmiSpeakerAllocation::SpeakerCount()

   671 // ---------------------------------------------------------------------------

   672 //

   673 EXPORT_C TUint32 CAccPolHdmiSpeakerAllocation::SpeakerCount() const

   674     {

   675     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerCount() - Enter" );

   676     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerCount() - Return" );

   677     return iSpeakerCount;

   678     }

   679 

   680 // ---------------------------------------------------------------------------

   681 // CAccPolHdmiSpeakerAllocation::SpeakerAllocation()

   682 // ---------------------------------------------------------------------------

   683 //

   684 EXPORT_C TUint32 CAccPolHdmiSpeakerAllocation::SpeakerAllocation() const

   685     {

   686     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerAllocation() - Enter" );

   687     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::SpeakerAllocation() - Return" );

   688     return iSpeakerAllocation;

   689     }

   690 

   691 // ---------------------------------------------------------------------------

   692 // CAccPolHdmiSpeakerAllocation::FrontSpeakers()

   693 // ---------------------------------------------------------------------------

   694 //

   695 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontSpeakers() const

   696     {

   697     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontSpeakers() - Enter" );

   698     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontSpeakers() - Return" );

   699     return ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRight );

   700     }

   701 

   702 // ---------------------------------------------------------------------------

   703 // CAccPolHdmiSpeakerAllocation::RearSpeakers()

   704 // ---------------------------------------------------------------------------

   705 //

   706 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::RearSpeakers() const

   707     {

   708     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearSpeakers() - Enter" );

   709     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearSpeakers() - Return" );

   710     return ( iSpeakerAllocation & EHdmiSpeakerRearLeftRight );

   711     }

   712 

   713 // ---------------------------------------------------------------------------

   714 // CAccPolHdmiSpeakerAllocation::LowFrequencyEffect()

   715 // ---------------------------------------------------------------------------

   716 //

   717 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::LowFrequencyEffect() const

   718     {

   719     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::LowFrequencyEffect() - Enter" );

   720     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::LowFrequencyEffect() - Return" );

   721     return ( iSpeakerAllocation & EHdmiSpeakerLowFrequencyEffect );

   722     }

   723 

   724 // ---------------------------------------------------------------------------

   725 // CAccPolHdmiSpeakerAllocation::FrontCenter()

   726 // ---------------------------------------------------------------------------

   727 //

   728 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontCenter() const

   729     {

   730     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontCenter() - Enter" );

   731     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontCenter() - Return" );

   732     return ( iSpeakerAllocation & EHdmiSpeakerFrontCenter );

   733     }

   734 

   735 // ---------------------------------------------------------------------------

   736 // CAccPolHdmiSpeakerAllocation::FrontCenterHigh()

   737 // ---------------------------------------------------------------------------

   738 //

   739 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontCenterHigh() const

   740     {

   741     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontCenterHigh() - Enter" );

   742     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontCenterHigh() - Return" );

   743     return ( iSpeakerAllocation & EHdmiSpeakerFrontCenterHigh );

   744     }

   745 

   746 // ---------------------------------------------------------------------------

   747 // CAccPolHdmiSpeakerAllocation::TopCenter()

   748 // ---------------------------------------------------------------------------

   749 //

   750 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::TopCenter() const

   751     {

   752     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::TopCenter() - Enter" );

   753     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::TopCenter() - Return" );

   754     return ( iSpeakerAllocation & EHdmiSpeakerTopCenter );

   755     }

   756 

   757 // ---------------------------------------------------------------------------

   758 // CAccPolHdmiSpeakerAllocation::RearCenter()

   759 // ---------------------------------------------------------------------------

   760 //

   761 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::RearCenter() const

   762     {

   763     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearCenter() - Enter" );

   764     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearCenter() - Return" );

   765     return ( iSpeakerAllocation & EHdmiSpeakerRearCenter );

   766     }

   767 

   768 // ---------------------------------------------------------------------------

   769 // CAccPolHdmiSpeakerAllocation::FrontLeftRightCenter()

   770 // ---------------------------------------------------------------------------

   771 //

   772 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontLeftRightCenter() const

   773     {

   774     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontLeftRightCenter() - Enter" );

   775     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontLeftRightCenter() - Return" );

   776     return ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightCenter );

   777     }

   778 

   779 // ---------------------------------------------------------------------------

   780 // CAccPolHdmiSpeakerAllocation::RearLeftRightCenter()

   781 // ---------------------------------------------------------------------------

   782 //

   783 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::RearLeftRightCenter() const

   784     {

   785     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearLeftRightCenter() - Enter" );

   786     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::RearLeftRightCenter() - Return" );

   787     return ( iSpeakerAllocation & EHdmiSpeakerRearLeftRightCenter );

   788     }

   789 

   790 // ---------------------------------------------------------------------------

   791 // CAccPolHdmiSpeakerAllocation::FrontWideSpeakers()

   792 // ---------------------------------------------------------------------------

   793 //

   794 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontWideSpeakers() const

   795     {

   796     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontWideSpeakers() - Enter" );

   797     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontWideSpeakers() - Return" );

   798     return ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightWide );

   799     }

   800 

   801 // ---------------------------------------------------------------------------

   802 // CAccPolHdmiSpeakerAllocation::FrontHighSpeakers()

   803 // ---------------------------------------------------------------------------

   804 //

   805 EXPORT_C TBool CAccPolHdmiSpeakerAllocation::FrontHighSpeakers() const

   806     {

   807     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontHighSpeakers() - Enter" );

   808     API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolHdmiSpeakerAllocation::FrontHighSpeakers() - Return" );

   809     return ( iSpeakerAllocation & EHdmiSpeakerFrontLeftRightHigh );

   810     }