--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/mmapi_akn/baseline/src/tmmaparametervalidator.cpp Wed Sep 01 12:33:18 2010 +0100
@@ -0,0 +1,628 @@
+/*
+* 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 <jdebug.h>
+#include <mmf/plugin/mmfformatimplementationuids.hrh>
+#include <mmf/plugin/mmfcontrollerimplementationuids.hrh>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include "cmmaplayerproperties.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))
+ { //PNG
+ 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))
+ { // JPG
+ 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);
+
+ TPtrC tmp;
+ // jpg encoders colors cannot be configured,
+ // notice that if there was "type" defined it must be "jfif"
+ // and encoder will check that anyway.
+ if (properties->GetProperty(KPropertyColor, tmp))
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+ else if (properties->Compare(KPropertyEncoding, KFormatGif) ||
+ properties->Compare(KPropertyEncoding, KContentTypeGif))
+ {//GIF
+ settings->iMimeType = CreateHBufC8FromUnicodeL(KContentTypeGif);
+ TPtrC tmp;
+ // gif encoder is not configurable
+ if (properties->GetProperty(KPropertyColor, tmp) ||
+ properties->GetProperty(KPropertyType, tmp) ||
+ quality != KNoUserDefinedQuality)
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+ else if (properties->Compare(KPropertyEncoding, KFormatBmp) ||
+ properties->Compare(KPropertyEncoding, KContentTypeBmp))
+ {//BMP
+ settings->iMimeType = CreateHBufC8FromUnicodeL(KContentTypeBmp);
+ TBmpImageData* imageData = new(ELeave)TBmpImageData();
+ CleanupStack::PushL(imageData);
+ imageData->iBitsPerPixel = KDefaultBpp;
+ TPtrC color;
+ if (properties->Compare(KPropertyColor, KPropertyRGB888()))
+ {
+ // default
+ }
+ else if (properties->Compare(KPropertyColor, KPropertyRGB444()))
+ {
+ imageData->iBitsPerPixel = KDefaultBpp444;
+ }
+ else if (properties->GetProperty(KPropertyColor, color))
+ {
+ // not valid color parameter
+ User::Leave(KErrArgument);
+ }
+
+ settings->iImageData = CFrameImageData::NewL();
+ User::LeaveIfError(settings->iImageData->AppendImageData(imageData));
+ // CFrameImageData took ownership of imageData
+ CleanupStack::Pop(imageData);
+
+ // quality not supported, "type" is only for jpg
+ TPtrC tmp;
+ if (quality != KNoUserDefinedQuality ||
+ properties->GetProperty(KPropertyType, tmp))
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+ else if (properties->GetProperty(KPropertyEncoding, encoding))
+ { // OTHER POSSIBLE TYPE
+ // trying to create encoder with only content/mime-type
+ settings->iMimeType = CreateHBufC8FromUnicodeL(encoding);
+
+ // No extra parameters, only content-type
+ TPtrC tmp;
+ if (properties->GetProperty(KPropertyColor, tmp) ||
+ properties->GetProperty(KPropertyType, tmp) ||
+ quality != KNoUserDefinedQuality)
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+ else // default: we had empty properties string
+ {
+ settings->iMimeType = CreateHBufC8FromUnicodeL(KContentTypePng);
+ }
+ CleanupStack::PopAndDestroy(properties);
+ CleanupStack::PopAndDestroy(rules);
+ CleanupStack::Pop(settings);
+ return settings;
+}
+
+void TMMAParameterValidator::CheckEncodingL(const TDesC& aProperties)
+{
+ TInt encodingPos = aProperties.Find(KPropertyEncoding);
+ // empty properties is valid and
+ // encoding must be first parameter and must exist every time
+ if ((aProperties.Length() > 0) &&
+ ((encodingPos == KErrNotFound) ||
+ (encodingPos != 0)))
+ {
+ User::Leave(KErrArgument);
+ }
+}
+
+HBufC8* TMMAParameterValidator::CreateHBufC8FromUnicodeL(const TDesC& aDes)
+{
+ HBufC8* tmp = HBufC8::NewL(aDes.Length());
+ tmp->Des().Copy(aDes);
+ return tmp;
+}
+
+// END OF FILE