// Copyright (c) 2006-2009 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:

 //

 #include "constants.h"

 #include "parsers.h"

 // The length of the frame in written directly into the header.

 // It is 13 bits in length and spans 3 bytes.

 #define AAC_SYNC1_MASK				0xff	// 11111111

 #define AAC_SYNC2_MASK				0xf0	// 11110000

 #define AAC_FRAME_LENGTH_MASK1		0x03	// 00000011

 #define AAC_FRAME_LENGTH_MASK2		0xff	// 11111111

 #define AAC_FRAME_LENGTH_MASK3		0xe0	// 11100000

 #define AAC_LAYER_MASK				0x06	// 00000110

 #define AAC_GET_SYNC1(d)	(d)

 #define AAC_GET_SYNC2(d)	((d & AAC_SYNC2_MASK) >> 4)

 #define AAC_GET_LAYER(d)	(((d) & AAC_LAYER_MASK) >> 1)

 #define AAC_GET_FRAME_LENGTH(a, b, c) \

 							(((a) & AAC_FRAME_LENGTH_MASK1) << 11) | \

 							(((b) & AAC_FRAME_LENGTH_MASK2) << 03) | \

 							(((c) & AAC_FRAME_LENGTH_MASK3) >> 05)

 #define AAC_IS_BAD_SYNC1(s)			((s) != 0xff)

 #define AAC_IS_BAD_SYNC2(s)			((s) != 0x0f)

 #define AAC_IS_BAD_LAYER(l)			((l) != 0x00)

 #define AAC_IS_BAD_FRAME_LENGTH(l)	((l) < KAACFrameHeaderSize)

 //

 // The various states the recognition process goes through.

 //

 typedef enum

 	{

 	ESearchFrame1,

 	ESearchFrame2

 	}

 TAACState;

 //

 // This truth table maps the following flags to a confidence level.

 //

 // A: Extension identified.

 // B: Frame1 found.

 // C: Frame2 found.

 //

 // C B A -> Confidence

 // ===================

 // 0 0 0 -> ENotRecognised

 // 0 0 1 -> EPossible

 // 0 1 0 -> EProbable

 // 0 1 1 -> ECertain

 // 1 0 0 -> ENotRecognised (Can't have f2 without f1)

 // 1 0 1 -> ENotRecognised (Can't have f2 without f1)

 // 1 1 0 -> EProbable

 // 1 1 1 -> ECertain

 //

 static const TInt KAACFlagsToConfidence[8] =

 	{

 	KConfNotRecognised,

 	KConfPossible,

 	KConfProbable,

 	KConfCertain,

 	KConfNotRecognised,

 	KConfNotRecognised,

 	KConfProbable,

 	KConfCertain

 	};

 #define KAACConfidenceMask	0x07	// [0000 0111]

 #define KAACFrame1Bit		KBit1

 #define KAACFrame2Bit		KBit2

 //

 // Constructs a TAACParser on the stack.

 //

 TAACParser::TAACParser(CReader& aReader, TFlags& aFlags)

  :	iReader(aReader),

  	iFlags(aFlags)

 	{

 	}

 //

 //

 //

 void TAACParser::DoRecognise(const TDesC& aFileExt, CReader& aReader, TMatch& aMatch)

 	{

 	TFlags flags;

 	TBool extMatch;

 	// See if the extension is recognised.

 	extMatch = (aFileExt.MatchF(TPtrC(KExtAAC)) != KErrNotFound);

 	// Try to match a known header.

 	if (aReader.Match(TPtrC8(_S8("ADIF*"))))

 		{

 		aMatch.iConfidence = (extMatch ? KConfCertain : KConfProbable);

 		aMatch.iMime = KMimeAAC;

 		return;

 		}

 	// No known header so try to parse it.

 	// Parsing uses flags to track what has been identified.

 	if (extMatch)

 		{

 		flags.SetExtensionFlag();

 		}

 	TAACParser parser(aReader, flags);

 	TRAP_IGNORE(parser.ParseL());

 	TInt confIndex = flags.GetBitField(KAACConfidenceMask);

 	aMatch.iConfidence = KAACFlagsToConfidence[confIndex];

 	if (aMatch.iConfidence != KConfNotRecognised)

 		{

 		aMatch.iMime = KMimeAAC;

 		}

 	}

 //

 // Looks for valid AAC frame headers; at the current position

 // and immediately after (if one found).

 //

 void TAACParser::ParseL()

 	{

 	TInt frameLength;

 	TAACState state = ESearchFrame1;

 	// Check if it's an ADTS (raw) format AAC file.

 	// There's no known metadata tag for AAC so the

 	// first frame header should be at the start of the buffer.

 	FOREVER

 		{

 		TID3Parser::ReadAndSkipID3L(iReader);

 		TInt err = CheckForFrameHeaderL(frameLength);

 		if (err == KErrNotFound)

 			{

 			return;

 			}

 		switch (state)

 			{

 			case ESearchFrame1:

 				iFlags.SetBit(KAACFrame1Bit);

 				state = ESearchFrame2;

 				break;

 			case ESearchFrame2:

 				iFlags.SetBit(KAACFrame2Bit);

 				return;

 			}

 		// Skip over the audio frame.

 		// This should be done after flags have been set.

 		iReader.SeekL(frameLength - KAACFrameHeaderSize);

 		};

 	}

 //

 // Looks for valid AAC frame header bit patterns.

 // If one is not found KErrNotFound is returned and aFrameLength

 // remains unchanged. If one is found KErrNone is retured and

 // aFrameLength is set to the length of the frame.

 //

 TInt TAACParser::CheckForFrameHeaderL(TInt& aFrameLength)

 	{

 	TBuf8<KAACFrameHeaderSize> header;

 	header.SetLength(KAACFrameHeaderSize);

 	iReader.ReadBytesL(header);

 	do

 		{

 		if (AAC_IS_BAD_SYNC1(AAC_GET_SYNC1(header[0])))

 			{

 			break;

 			}

 		if (AAC_IS_BAD_SYNC2(AAC_GET_SYNC2(header[1])))

 			{

 			break;

 			}

 		if (AAC_IS_BAD_LAYER(AAC_GET_LAYER(header[1])))

 			{

 			break;

 			}

 		TInt frameLength = AAC_GET_FRAME_LENGTH(header[3], header[4], header[5]);

 		if (AAC_IS_BAD_FRAME_LENGTH(frameLength))

 			{

 			break;

 			}

 		// All is ok.

 		aFrameLength = frameLength;

 		return KErrNone;

 		}

 	while (EFalse);

 	// No frame header was found.

 	aFrameLength = 0;

 	iReader.SeekL(-KAACFrameHeaderSize);

 	return KErrNotFound;

 	}