// 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;

	}