/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Video Source subsystem.
*
*/
// INCLUDE FILES
#include <badesca.h>
#include <e32svr.h>
#include <featmgr.h>
#include "CApiVideoSource.h"
#include "CVSCameraDataProvider.h"
#include "CVSStillImageDataProvider.h"
#include "CVSOnboardCameraDataProvider.h"
// EXTERNAL FUNCTION PROTOTYPES
// MACROS
#ifdef _DEBUG
# define __IF_DEBUG(t) {RDebug::t;}
#else
# define __IF_DEBUG(t)
#endif
// LOCAL CONSTANTS AND MACROS
class TSizeCount
{
public:
TInt iCount;
TSize iSize;
};
class TRateCount
{
public:
TInt iCount;
TReal32 iRate;
};
// LOCAL FUNCTION PROTOTYPES
static TInt TSizeCountTLinearOrderFunc(
const TSizeCount& aSizeCount1, const TSizeCount& aSizeCount2 );
static TBool TSizeCountTIdentityRelationFunc(
const TSizeCount& aSizeCount1, const TSizeCount& aSizeCount2 );
static TInt TRateCountTLinearOrderFunc(
const TRateCount& aRateCount1, const TRateCount& aRateCount2 );
static TBool TRateCountTIdentityRelationFunc(
const TRateCount& aRateCount1, const TRateCount& aRateCount2 );
// FORWARD DECLARATIONS
// ============================= LOCAL FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// TSizeCountTLinearOrderFunc: Used in RArray<TSizeCount)::InsertInOrder
// -----------------------------------------------------------------------------
//
static TInt TSizeCountTLinearOrderFunc(
const TSizeCount& aSizeCount1,
const TSizeCount& aSizeCount2 )
{
if ( aSizeCount1.iSize == aSizeCount2.iSize )
{
return 0;
}
else
{
// It is assumed that width and height fit in 16-bit, if they don't,
// use TInt64
TInt32 s1 =
( aSizeCount1.iSize.iWidth & 0xffff ) << 16 |
( aSizeCount1.iSize.iHeight & 0xffff );
TInt32 s2 =
( aSizeCount2.iSize.iWidth & 0xffff ) << 16 |
( aSizeCount2.iSize.iHeight & 0xffff );
return s1 - s2;
}
}
// -----------------------------------------------------------------------------
// TSizeCountTIdentityRelationFunc: Used in RArray<TSizeCount)::Find
// -----------------------------------------------------------------------------
//
static TBool TSizeCountTIdentityRelationFunc(
const TSizeCount& aSizeCount1,
const TSizeCount& aSizeCount2 )
{
if ( aSizeCount1.iSize == aSizeCount2.iSize )
{
return ETrue;
}
else
{
return EFalse;
}
}
// -----------------------------------------------------------------------------
// TRateCountTLinearOrderFunc: Used in RArray<TRateCount)::InsertInOrder
// -----------------------------------------------------------------------------
//
static TInt TRateCountTLinearOrderFunc(
const TRateCount& aRateCount1,
const TRateCount& aRateCount2 )
{
if ( aRateCount1.iRate > aRateCount2.iRate )
{
return 1;
}
if ( aRateCount1.iRate < aRateCount2.iRate )
{
return -1;
}
return 0;
}
// -----------------------------------------------------------------------------
// TRateCountTIdentityRelationFunc: Used in RArray<TRateCount)::Find
// -----------------------------------------------------------------------------
//
static TBool TRateCountTIdentityRelationFunc(
const TRateCount& aRateCount1,
const TRateCount& aRateCount2 )
{
if ( aRateCount1.iRate == aRateCount2.iRate )
{
return ETrue;
}
else
{
return EFalse;
}
}
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CVSDataProvider::NewL
// -----------------------------------------------------------------------------
//
CVSDataProvider* CVSDataProvider::NewL(
TInt aProviderIndex,
MVSDataProviderObserver* aObserver,
MVSBufferPool* aPool )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::NewL() [aProviderIndex = %d] >>"), RThread().Id().operator TUint(), aProviderIndex));
CVSDataProvider* self = NULL;
// Is it ecam
TInt count = CamerasAvailable();
// < 0 == error
if( count < 0 )
{
User::Leave( count );
}
if ( aProviderIndex < count )
{
self = CVSCameraDataProvider::NewL( aObserver, aProviderIndex, aPool );
}
else
{
// Is it still image
count += 1;
if ( aProviderIndex == ( count - 1) )
{
self = CVSStillImageDataProvider::NewL( aObserver, aPool );
}
else
{
User::Leave( KErrNotSupported );
}
}
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::NewL() <<"), RThread().Id().operator TUint()));
return self;
}
// -----------------------------------------------------------------------------
// CVSDataProvider::~CVSDataProvider
// -----------------------------------------------------------------------------
//
CVSDataProvider::~CVSDataProvider()
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::~CVSDataProvider() >>"), RThread().Id().operator TUint()));
delete iErrorNotifier;
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::~CVSDataProvider() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::ProvidersAvailable
// -----------------------------------------------------------------------------
//
TInt CVSDataProvider::ProvidersAvailable()
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ProvidersAvailable() >>"), RThread().Id().operator TUint()));
// Count ecams
TInt numProviders = CamerasAvailable();
// < 0 == error
if ( numProviders < 0 )
{
numProviders = 1; // only still image provider
}
else
{
numProviders += 1; // add still
}
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ProvidersAvailable() [numProviders = %d] <<"), RThread().Id().operator TUint(), numProviders));
return numProviders;
}
// -----------------------------------------------------------------------------
// CVSDataProvider::ProviderInfoL
// -----------------------------------------------------------------------------
//
void CVSDataProvider::ProviderInfoL(
TInt aProviderIndex,
TVSDataProviderInfo& aInfo )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ProviderInfoL() >>"), RThread().Id().operator TUint()));
CVSDataProvider* provider = NewL( aProviderIndex, NULL, NULL);
provider->ProviderInfo( aInfo );
delete provider;
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ProviderInfoL() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::SetFillBufferParams
// -----------------------------------------------------------------------------
//
void CVSDataProvider::SetFillBufferParams(
MVTVideoSink* aConsumer,
TMediaId aMediaId )
{
iConsumer = aConsumer;
iMediaId = aMediaId;
}
// -----------------------------------------------------------------------------
// CVSDataProvider::NotifyError
// -----------------------------------------------------------------------------
//
void CVSDataProvider::NotifyError( TInt aError )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::NotifyError() >>"), RThread().Id().operator TUint()));
iErrorNotifier->NotifyError( &Observer(), aError );
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::NotifyError() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::CVSDataProvider
// -----------------------------------------------------------------------------
//
CVSDataProvider::CVSDataProvider(
MVSDataProviderObserver* aObserver,
MVSBufferPool* aPool ) :
iObserver( aObserver ),
iPool ( aPool )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::CVSDataProvider() >>"), RThread().Id().operator TUint()));
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::CVSDataProvider() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::ConstructL
// -----------------------------------------------------------------------------
//
void CVSDataProvider::ConstructL()
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ConstructL() >>"), RThread().Id().operator TUint()));
iErrorNotifier = CProviderErrorNotifierAO::NewL();
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ConstructL() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::TimeToPlay
// -----------------------------------------------------------------------------
//
const TTimeIntervalMicroSeconds& CVSDataProvider::TimeToPlay()
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::TimeToPlay() >>"), RThread().Id().operator TUint()));
TTime now;
now.HomeTime();
TTimeIntervalMicroSeconds timeToPlay( now.MicroSecondsFrom( iStartTime ) );
if( timeToPlay <= iPreviousTimeToPlay )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::TimeToPlay(): *WARNING* Time warp backwards! Correcting.."), RThread().Id().operator TUint()));
iPreviousTimeToPlay =
TTimeIntervalMicroSeconds( iPreviousTimeToPlay.Int64() + 1 );
}
else
{
iPreviousTimeToPlay = timeToPlay;
}
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::TimeToPlay() <<"), RThread().Id().operator TUint()));
return iPreviousTimeToPlay;
}
// -----------------------------------------------------------------------------
// CVSDataProvider::ResetStartTime
// -----------------------------------------------------------------------------
//
void CVSDataProvider::ResetStartTime()
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ResetStartTime() >>"), RThread().Id().operator TUint()));
iStartTime.HomeTime();
iPreviousTimeToPlay = iStartTime.MicroSecondsFrom( iStartTime );
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::ResetStartTime() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::CamerasAvailable()
// -----------------------------------------------------------------------------
//
TInt CVSDataProvider::CamerasAvailable()
{
TRAPD( result, FeatureManager::InitializeLibL() );
if( result != KErrNone )
{
return result;
}
TInt count( 0 );
if( FeatureManager::FeatureSupported( KFeatureIdCamera ) )
{
count = CCamera::CamerasAvailable();
}
FeatureManager::UnInitializeLib();
return count;
}
// -----------------------------------------------------------------------------
// CVSDataProvider::SwitchFrom
// -----------------------------------------------------------------------------
//
void CVSDataProvider::SwitchFrom( const CVSDataProvider& anOldProvider )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::SwitchFrom() >>"), RThread().Id().operator TUint()));
iStartTime = anOldProvider.iStartTime;
iPreviousTimeToPlay = anOldProvider.iPreviousTimeToPlay;
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::SwitchFrom() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::EnumerateVideoFrameFormatsL
// -----------------------------------------------------------------------------
//
void CVSDataProvider::EnumerateVideoFrameFormatsL(
CDesC8Array* aSupportedFormats )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameFormats() >>"), RThread().Id().operator TUint()));
TInt providerCount = ProvidersAvailable();
TInt countOfProvidersThatSupportYUV420Planar = 0;
for ( TInt i = 0; i < providerCount; i++ )
{
TVSDataProviderInfo info;
ProviderInfoL( i, info );
if ( info.iVideoFrameFormatsSupported & CCamera::EFormatYUV420Planar )
{
countOfProvidersThatSupportYUV420Planar++;
}
}
if( providerCount > 0 &&
providerCount <= countOfProvidersThatSupportYUV420Planar )
{
aSupportedFormats->AppendL( KVtVideoMIMETypeYUV420 );
}
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameFormats() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::EnumerateVideoFrameSizesL
// -----------------------------------------------------------------------------
//
void CVSDataProvider::EnumerateVideoFrameSizesL(
RArray<TSize>& aSupportedSizes,
const TDesC8& aFormat )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameSizes() >>"), RThread().Id().operator TUint()));
CleanupClosePushL( aSupportedSizes );
RArray<TSizeCount> sizeCountArray;
CleanupClosePushL( sizeCountArray );
TInt providerCount = ProvidersAvailable();
for ( TInt i = 0; i < providerCount; i++ )
{
CVSDataProvider* p = CVSDataProvider::NewL( i, NULL, NULL );
CleanupStack::PushL( p );
TVSDataProviderInfo info;
ProviderInfoL( i, info );
for ( TInt j = 0; j < info.iNumVideoFrameSizesSupported; j++ )
{
TSize size;
p->GetVideoFrameSize( size, j, aFormat );
if ( size != TSize(0,0) )
{
TSizeCount sizeCount;
sizeCount.iCount = 1;
sizeCount.iSize = size;
TInt err = sizeCountArray.InsertInOrder(
sizeCount,
TLinearOrder<TSizeCount>( TSizeCountTLinearOrderFunc ) );
if ( err == KErrAlreadyExists )
{
TInt idx = sizeCountArray.Find(
sizeCount,
TIdentityRelation<TSizeCount>(
TSizeCountTIdentityRelationFunc ) );
if ( idx == KErrNotFound )
{
User::Leave( KErrUnknown );
}
else
{
// Increment count of providers that supports the size
sizeCountArray[idx].iCount++;
}
}
else
{
User::LeaveIfError( err );
}
}
}
CleanupStack::PopAndDestroy(); // p
}
aSupportedSizes.Reset();
for ( TInt k = 0; k < sizeCountArray.Count(); k++ )
{
// Do all providers support the size
if ( providerCount > 0 && providerCount <= sizeCountArray[k].iCount )
{
User::LeaveIfError(
aSupportedSizes.Append( sizeCountArray[k].iSize ) );
}
}
CleanupStack::PopAndDestroy(); // sizeCountArray
CleanupStack::Pop(); // aSupportedSizes
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameSizes() <<"), RThread().Id().operator TUint()));
}
// -----------------------------------------------------------------------------
// CVSDataProvider::EnumerateVideoFrameRatesL
// -----------------------------------------------------------------------------
//
void CVSDataProvider::EnumerateVideoFrameRatesL(
RArray<TReal32>& aSupportedRates,
const TDesC8& aFormat,
const TSize& aSize )
{
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameRates() >>"), RThread().Id().operator TUint()));
CleanupClosePushL( aSupportedRates );
RArray<TRateCount> rateCountArray;
CleanupClosePushL( rateCountArray );
TInt providerCount = ProvidersAvailable();
__IF_DEBUG(Print(_L(" LOOKING FOR COMMON SUPPORTED RATES, PROVIDER COUNT: %d"), providerCount));
for ( TInt i = 0; i < providerCount; i++ )
{
__IF_DEBUG(Print(_L(" PROVIDER %d"), i));
CVSDataProvider* p = CVSDataProvider::NewL( i, NULL, NULL );
CleanupStack::PushL( p );
TVSDataProviderInfo info;
ProviderInfoL( i, info );
__IF_DEBUG(Print(_L(" info.iNumVideoFrameRatesSupported: %d"), info.iNumVideoFrameRatesSupported));
for ( TInt j = 0; j < info.iNumVideoFrameRatesSupported; j++ )
{
TReal32 rate = 0.0;
p->GetVideoFrameRate( rate, j, aFormat, aSize );
__IF_DEBUG(Print(_L(" RATE FOR RATE INDEX %d IS %f"), j, rate));
if ( rate != 0.0 )
{
TRateCount rateCount;
rateCount.iCount = 1;
rateCount.iRate = rate;
TInt err = rateCountArray.InsertInOrder(
rateCount,
TLinearOrder<TRateCount>( TRateCountTLinearOrderFunc ) );
if ( err == KErrAlreadyExists )
{
TInt idx = rateCountArray.Find(
rateCount,
TIdentityRelation<TRateCount>(
TRateCountTIdentityRelationFunc ) );
if ( idx == KErrNotFound )
{
User::Leave( KErrUnknown );
}
else
{
// Increment count of providers that supports the rate
rateCountArray[idx].iCount++;
}
}
else
{
User::LeaveIfError( err );
}
}
}
CleanupStack::PopAndDestroy(); // p
}
aSupportedRates.Reset();
for ( TInt k = 0; k < rateCountArray.Count(); k++ )
{
// Do all providers support the rate
if ( providerCount > 0 && providerCount <= rateCountArray[k].iCount )
{
User::LeaveIfError(
aSupportedRates.Append( rateCountArray[k].iRate ) );
}
}
CleanupStack::PopAndDestroy( ); // rateCountArray
CleanupStack::Pop(); // aSupportedRates
__IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataProvider::EnumerateVideoFrameRates() <<"), RThread().Id().operator TUint()));
}
// End of File