/*

* Copyright (c) 2002-2007 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:  This class is used for storing and parsing properties

*

*/

//  INCLUDE FILES

#include <logger.h>

#include <mmfformatimplementationuids.hrh>

#include <mmfcontrollerimplementationuids.hrh>

#include "cmmaplayerproperties.h"

#include <mmfcontrollerpluginresolver.h>

#include "tmmaparametervalidator.h"

// CONSTANTS

// AUDIO PARAMETERS

_LIT(KPropertyEncoding,     "encoding");

_LIT(KPropertyEncodingPcm,  "pcm");     // Wav

_LIT(KPropertyEncodingAmr,  "amr");     // Amr

_LIT(KPropertyEncodingGsm,  "gsm");

_LIT(KPropertyEncodingUlaw, "ulaw");    // Au

_LIT(KPropertyEncodingAlaw, "alaw");

_LIT(KPropertyEncodingRaw,  "raw");     // Raw pcm

_LIT(KPropertyEncodingNone,  "");       // empty string

_LIT(KContentTypeWav, "audio/wav");

_LIT(KContentTypeAu,  "audio/au");

_LIT(KContentTypeAmr, "audio/amr");

_LIT(KContentTypeRaw, "audio/raw");

// Format used if not specified in locator

_LIT(KDefaultAudioRecordContentType, "audio/wav");

_LIT(KPropertyRate,         "rate");

_LIT(KPropertyBits,         "bits");

_LIT(KPropertyChannels,     "channels");

_LIT(KPropertyEndian,       "endian");

MMA_PARAMETER_STR(KPropertyEndianLittle, "little");

MMA_PARAMETER_STR(KPropertyEndianBig,    "big");

MMA_PARAMETER_ARRAY(KValidEndianValues)

{

    {

        &KPropertyEndianLittle

    }, {&KPropertyEndianBig}

};

_LIT(KPropertySigned,       "signed");

MMA_PARAMETER_STR(KPropertySignedSigned, "signed");

MMA_PARAMETER_STR(KPropertySignedUnsigned, "unsigned");

MMA_PARAMETER_ARRAY(KValidSignedValues)

{

    {

        &KPropertySignedSigned

    }, {&KPropertySignedUnsigned}

};

// VIDEO PARAMETERS

_LIT(KPropertyFps,         "fps");

_LIT(KPropertyWidth,       "width");

_LIT(KPropertyHeight,      "height");

const TInt KSizeNotSet = -1;

// Format used if not specified in locator

_LIT(KDefaultVideoRecordContentType, "video/3gpp");

//IMAGE PARAMETERS

_LIT(KPropertyType,             "type");

MMA_PARAMETER_STR(KPropertyJfif,  "jfif");

MMA_PARAMETER_STR(KPropertyExif,  "exif");

MMA_PARAMETER_ARRAY(KValidTypes)

{

    {

        &KPropertyJfif

    }, {&KPropertyExif}

};

_LIT(KFormatPng, "png");

_LIT(KFormatJpg, "jpeg");   // not "jpg"

_LIT(KFormatGif, "gif");

_LIT(KFormatBmp, "bmp");

_LIT(KContentTypePng, "image/png");

_LIT(KContentTypeJpg, "image/jpeg");

_LIT(KContentTypeJpg2,"image/jpg");

_LIT(KContentTypeGif, "image/gif");

_LIT(KContentTypeBmp, "image/bmp");

_LIT(KPropertyColor, "colors");

MMA_PARAMETER_STR(KPropertyRGB888,  "rgb888");

MMA_PARAMETER_STR(KPropertyRGB444,  "rgb444");

MMA_PARAMETER_STR(KPropertyGray16,  "gray16");

MMA_PARAMETER_STR(KPropertyGray8,   "gray8");

_LIT(KPropertyQuality, "quality");

const TInt KDefaultQuality = 75; // digged out from ICL source

const TInt KDefaultBpp = 24;

const TInt KDefaultBpp444 = 12;

const TInt KDefaultBppGray16 = 16;

const TInt KDefaultBppGray8 = 8;

const TInt KNoUserDefinedQuality = -1;

const TReal32 KNoUserDefinedFps = -1;

// CMMAImageSettings container destructor

CMMAImageSettings::~CMMAImageSettings()

{

    delete iMimeType;

    delete iType;

    delete iImageData;

}

CMMAAudioSettings::~CMMAAudioSettings()

{

    delete iContentType;

}

CMMAAudioSettings *TMMAParameterValidator::ValidateAudioPropertiesL(const TDesC& aProperties)

{

    CMMAAudioSettings* settings = new(ELeave) CMMAAudioSettings;

    CleanupStack::PushL(settings);

    CMMAParameterRuleSet* rules = CMMAParameterRuleSet::NewLC();

    // "bits" must be between 0 - 24

    TMMAParameterRuleInt bitsRule(KPropertyBits, 0, 24);

    rules->AppendRuleL(&bitsRule);

    // "rate" must be positive

    TMMAParameterRuleInt rateRule(KPropertyRate, 1);

    rules->AppendRuleL(&rateRule);

    // "channels" must be 1 or 2

    TMMAParameterRuleInt channelsRule(KPropertyChannels, 1, 2);

    rules->AppendRuleL(&channelsRule);

    // "signed" must be "signed" or "unsigned"

    TMMAParameterRuleDes signedRule(KPropertySigned, KValidSignedValues,

                                    MMA_PARAMETER_ARRAY_SIZE(KValidSignedValues));

    rules->AppendRuleL(&signedRule);

    // "endian" must be "little" or "big"

    TMMAParameterRuleDes endianRule(KPropertyEndian, KValidEndianValues,

                                    MMA_PARAMETER_ARRAY_SIZE(KValidEndianValues));

    rules->AppendRuleL(&endianRule);

    // "encoding" must be one of valid values

    TMMAParameterRuleDes encodingRule(KPropertyEncoding);

    rules->AppendRuleL(&encodingRule);

    CMMAPlayerProperties* properties = CMMAPlayerProperties::NewL(aProperties, *rules);

    CleanupStack::PushL(properties);

    // validating properties

    properties->ValidateL();

    TInt bits = KDefaultBits;

    properties->GetProperty(KPropertyBits, bits);

    settings->iRate = KDefaultRate;

    properties->GetProperty(KPropertyRate, settings->iRate);

    settings->iChannels = KDefaultChannels;

    properties->GetProperty(KPropertyChannels, settings->iChannels);

    // Normally encoders are not streamable

    settings->iStreamableFormat = EFalse;

    // signed=signed/unsigned (default is unsigned for 8bit, signed for 16bit)

    TBool dataSigned = EFalse;

    if (properties->Compare(KPropertyBits, 16))

    {

        dataSigned = ETrue;

    }

    if (properties->Compare(KPropertySigned, KPropertySignedSigned()))

    {

        dataSigned = ETrue;

    }

    else if (properties->Compare(KPropertySigned, KPropertySignedUnsigned()))

    {

        dataSigned = EFalse;

    }

    // little by default

    TBool endianLittle = ETrue;

    if (properties->Compare(KPropertyEndian, KPropertyEndianBig()))

    {

        endianLittle = EFalse;

    }

    settings->iDataType = KMMFFourCCCodeNULL;

    // encoding specific

    TPtrC encoding(NULL, 0);

    properties->GetProperty(KPropertyEncoding, encoding);

    if ((encoding == KPropertyEncodingAmr()) ||

            (encoding == KPropertyEncodingGsm()))

    {

        // AMR format

        encoding.Set(KContentTypeAmr());

    }

    else if (encoding == KPropertyEncodingUlaw())

    {

        // AU format, ulaw codec

        encoding.Set(KContentTypeAu());

        settings->iDataType = KMMFFourCCCodeMuLAW;

    }

    else if (encoding == KPropertyEncodingAlaw())

    {

        // AU format, alaw codec

        encoding.Set(KContentTypeAu());

        settings->iDataType = KMMFFourCCCodeALAW;

    }

    else if (encoding == KPropertyEncodingPcm())

    {

        // wav format

        encoding.Set(KContentTypeWav());

    }

    else if (encoding == KPropertyEncodingRaw())

    {

        // raw format, default codec

        encoding.Set(KContentTypeRaw());

    }

    else if ((encoding == KPropertyEncodingNone()))     // this is the default case

    {

        encoding.Set(KDefaultAudioRecordContentType());

    }

    settings->iContentType = encoding.AllocL();

    // wav specific

    if (*settings->iContentType == KContentTypeWav())

    {

        if (bits == 8)

        {

            settings->iDataType = KMMFFourCCCodePCMU8;

        }

        else if (bits == 16)

        {

            settings->iDataType = KMMFFourCCCodePCM16;

        }

        else if (bits != KDefaultBits)

        {

            User::Leave(KErrNotSupported);

        }

    }

    // raw specific

    if (*settings->iContentType == KContentTypeRaw())

    {

        if (bits == 8)

        {

            if (dataSigned)

            {

                settings->iDataType = KMMFFourCCCodePCM8;

            }

            else

            {

                settings->iDataType = KMMFFourCCCodePCMU8;

            }

        }

        else if (bits == 16)

        {

            if (endianLittle)

            {

                if (dataSigned)

                {

                    settings->iDataType = KMMFFourCCCodePCM16;

                }

                else

                {

                    settings->iDataType = KMMFFourCCCodePCMU16;

                }

            }

            else // Big endian

            {

                if (dataSigned)

                {

                    settings->iDataType = KMMFFourCCCodePCM16B;

                }

                else

                {

                    settings->iDataType = KMMFFourCCCodePCMU16B;

                }

            }

        }

        else if (bits != KDefaultBits) // bits not 8 or 16

        {

            User::Leave(KErrNotSupported);

        }

        settings->iEncoding = TUid::Uid(KMmfUidFormatRAWWrite);

        settings->iController = TUid::Uid(KMmfUidControllerAudio);

    }

    CleanupStack::PopAndDestroy(2);   // rules, properties

    CleanupStack::Pop(settings);

    return settings;

}

TMMAVideoSettings TMMAParameterValidator::ValidateVideoPropertiesL(const TDesC& aProperties)

{

    CheckEncodingL(aProperties);

    TMMAVideoSettings settings;

    CMMAParameterRuleSet* rules = CMMAParameterRuleSet::NewLC();

    // "fps" is real, taking it as string and validating later

    TMMAParameterRuleDes fpsRule(KPropertyFps);

    rules->AppendRuleL(&fpsRule);

    // "width" must be positive

    TMMAParameterRuleInt widthRule(KPropertyWidth, 1);

    rules->AppendRuleL(&widthRule);

    // "height" must be positive

    TMMAParameterRuleInt heightRule(KPropertyHeight, 1);

    rules->AppendRuleL(&heightRule);

    // "encoding" can be anything in this point (actual validation will be done by MMF)

    TMMAParameterRuleDes encodingRule(KPropertyEncoding);

    rules->AppendRuleL(&encodingRule);

    CMMAPlayerProperties* properties = CMMAPlayerProperties::NewL(aProperties, *rules);

    CleanupStack::PushL(properties);

    // validating properties

    properties->ValidateL();

    properties->GetProperty(KPropertyWidth, settings.iWidth = KSizeNotSet);

    properties->GetProperty(KPropertyHeight, settings.iHeight = KSizeNotSet);

    TPtrC fps;

    settings.iFps = KNoUserDefinedFps;

    if (properties->GetProperty(KPropertyFps, fps))

    {

        TLex lex(fps);

        TReal32 fpsReal;

        // try to get fps value from string

        TInt err = lex.Val(fpsReal);

        if (err == KErrNone)

        {

            // Check if there other characters after

            // number ( 34xxx )

            if (!lex.Eos() ||

                    (fpsReal <= 0))

            {

                User::Leave(KErrArgument);

            }

            else

            {

                settings.iFps = fpsReal;

            }

        }

        else if (err == KErrNoMemory)

        {

            User::Leave(KErrNoMemory);

        }

        else

        {

            // value is not available

            User::Leave(KErrArgument);

        }

    }

    settings.iEncoding.Set(KDefaultVideoRecordContentType());

    properties->GetProperty(KPropertyEncoding, settings.iEncoding);

    CleanupStack::PopAndDestroy(2);   // rules, properties

    return settings;

}

CMMAImageSettings* TMMAParameterValidator::ValidateImagePropertiesL(const TDesC& aProperties)

{

    CMMAImageSettings* settings = new(ELeave)CMMAImageSettings;

    CleanupStack::PushL(settings);

    CMMAParameterRuleSet* rules = CMMAParameterRuleSet::NewLC();

    // "width" must be positive

    TMMAParameterRuleInt widthRule(KPropertyWidth, 1);

    rules->AppendRuleL(&widthRule);

    // "height" must be positive

    TMMAParameterRuleInt heightRule(KPropertyHeight, 1);

    rules->AppendRuleL(&heightRule);

    // "encoding" final validation is done with image encoder

    TMMAParameterRuleDes encodingRule(KPropertyEncoding);

    rules->AppendRuleL(&encodingRule);

    // "color" can be anything in this point, it will be validated later

    TMMAParameterRuleDes colorRule(KPropertyColor);

    rules->AppendRuleL(&colorRule);

    // "type" must be "jfif" or "exif"

    TMMAParameterRuleDes typeRule(KPropertyType, KValidTypes,

                                  MMA_PARAMETER_ARRAY_SIZE(KValidTypes));

    rules->AppendRuleL(&typeRule);

    // "quality" must be between 0 and 100

    TMMAParameterRuleInt qualityRule(KPropertyQuality, 0, 100);

    rules->AppendRuleL(&qualityRule);

    CMMAPlayerProperties* properties = CMMAPlayerProperties::NewL(aProperties, *rules);

    CleanupStack::PushL(properties);

    // validating properties

    properties->ValidateL();

    properties->GetProperty(KPropertyWidth, settings->iWidth = KSizeNotSet);

    properties->GetProperty(KPropertyHeight, settings->iHeight = KSizeNotSet);

    // do not set quality if user has not defined it

    TInt quality = KNoUserDefinedQuality;

    properties->GetProperty(KPropertyQuality, quality);

    TPtrC encoding;

    if (properties->Compare(KPropertyEncoding, KFormatPng) ||

            properties->Compare(KPropertyEncoding, KContentTypePng))

        settings->iMimeType = CreateHBufC8FromUnicodeL(KContentTypePng);

        TPngEncodeData* imageData = new(ELeave)TPngEncodeData();

        imageData->iBitsPerPixel = KDefaultBpp;

        imageData->iColor = ETrue;

        imageData->iPaletted = EFalse;

        imageData->iLevel = TPngEncodeData::EDefaultCompression;

        CleanupStack::PushL(imageData);

        TPtrC color;

        if (properties->Compare(KPropertyColor, KPropertyRGB888()))

        {

            // default

        }

        else if (properties->Compare(KPropertyColor, KPropertyRGB444()))

        {

            imageData->iBitsPerPixel = KDefaultBpp444;

        }

        else if (properties->Compare(KPropertyColor, KPropertyGray16()))

        {

            imageData->iBitsPerPixel = KDefaultBppGray16;

            imageData->iColor = EFalse;

        }

        else if (properties->Compare(KPropertyColor, KPropertyGray8()))

        {

            imageData->iBitsPerPixel = KDefaultBppGray8;

            imageData->iColor = EFalse;

        }

        else if (properties->GetProperty(KPropertyColor, color))

        {

            // not valid color parameter

            User::Leave(KErrArgument);

        }

        settings->iImageData = CFrameImageData::NewL();

        User::LeaveIfError(settings->iImageData->AppendFrameData(imageData));

        // CFrameImageData took ownership of imageData

        CleanupStack::Pop(imageData);

        // png quality setting not supported, "type" is only for jpeg.

        TPtrC tmp;

        if (quality != KNoUserDefinedQuality ||

                properties->GetProperty(KPropertyType, tmp)

           )

        {

            User::Leave(KErrArgument);

        }

    }

    else if (properties->Compare(KPropertyEncoding, KFormatJpg) ||

             properties->Compare(KPropertyEncoding, KContentTypeJpg) ||

             properties->Compare(KPropertyEncoding, KContentTypeJpg2))

        settings->iMimeType = CreateHBufC8FromUnicodeL(KContentTypeJpg);

        if (properties->Compare(KPropertyType, KPropertyJfif()))

        {

            settings->iType = CreateHBufC8FromUnicodeL(KPropertyJfif());

        }

        else if (properties->Compare(KPropertyType, KPropertyExif()))

        {

            settings->iType = CreateHBufC8FromUnicodeL(KPropertyExif());

        }

        else

        {

            settings->iType = CreateHBufC8FromUnicodeL(KPropertyExif());

        }

        TJpegImageData* imageData = new(ELeave)TJpegImageData();

        CleanupStack::PushL(imageData);

        imageData->iQualityFactor = KDefaultQuality;

        imageData->iSampleScheme = TJpegImageData::EColor444;

        if (quality != KNoUserDefinedQuality)

        {

            imageData->iQualityFactor = quality;

        }

        settings->iImageData = CFrameImageData::NewL();

        User::LeaveIfError(settings->iImageData->AppendImageData(imageData));

        // CFrameImageData took ownership of imageData

        CleanupStack::Pop(imageData);