/*

* Copyright (c) 2004 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:  Recognizer for 3GP files.

*

*/

// INCLUDES

#include    <f32file.h>

#include    <barsread.h>

#include    <mp4lib.h>

#include    <implementationproxy.h>

#include    "3GPAudioPlayControllerRecognizer.h"

#include    "DebugMacros.h"

// LOCAL CONSTANTS AND MACROS

const TUid KUidMime3gpRecognizer = {0x101FAFAD};

const TInt KExtLength = 4;

_LIT(KDot, ".");

_LIT(KDot3gp, ".3gp");

_LIT(KDot3ga, ".3ga");

_LIT8(K3gpAudioMimeType, "audio/3gpp");

_LIT8(K3gpVideoMimeType, "video/3gpp");

_LIT(KDotMp4, ".mp4");

_LIT(KDotM4a, ".m4a");

_LIT8(KMp4AudioMimeType, "audio/mp4");

_LIT8(KMp4VideoMimeType, "video/mp4");

_LIT(KDot3g2, ".3g2");

_LIT8(K3g2AudioMimeType, "audio/3gpp2");

_LIT8(K3g2VideoMimeType, "video/3gpp2");

// Needed for looking at headers for 3gp files w/ no extensions

const TInt KPreHeaderLength = 4;

const TInt KHeaderLen = 8;

_LIT8(K3gpHeader ,"ftyp3gp");

_LIT8(KMp4Header ,"ftypmp4");

_LIT8(KMmp4Header ,"ftypmmp4");

_LIT8(KM4aHeader, "ftypM4A");

_LIT8(K3g2Header, "ftyp3g2");

_LIT8(K3gp6Header, "ftyp3gp6"); // 3GPP Release 6 basic Profile

_LIT8(K3gr6Header, "ftyp3gr6"); // 3GPP Rel6 Progressive Download ProfileHeader

_LIT8(K3gs6Header, "ftyp3gs6"); // 3GPP Release 6 streaming-server Profile

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::C3GPAudioPlayControllerRecognizer()

// Call base constructor with the recognizer's UID and confidence level

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

C3GPAudioPlayControllerRecognizer::C3GPAudioPlayControllerRecognizer()

    :CApaDataRecognizerType(KUidMime3gpRecognizer, CApaDataRecognizerType::EHigh)

    {

    // Set the number of data (MIME) types supported by this recognizer.

    iCountDataTypes = 6;

    }

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void C3GPAudioPlayControllerRecognizer::ConstructL()

    {

    }

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

C3GPAudioPlayControllerRecognizer* C3GPAudioPlayControllerRecognizer::NewL()

    {

    C3GPAudioPlayControllerRecognizer* self = new(ELeave) C3GPAudioPlayControllerRecognizer();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

C3GPAudioPlayControllerRecognizer::~C3GPAudioPlayControllerRecognizer()

    {

    }

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::SupportedDataTypeL

// Return the supposed datatype depending on the

// MimeType of the file

// -----------------------------------------------------------------------------

//

TDataType C3GPAudioPlayControllerRecognizer::SupportedDataTypeL(

        TInt aIndex) const

    {

    DP1(_L("C3GPAudioPlayControllerRecognizer::SupportedDataTypeL [%d]"), 

            aIndex);

    TDataType dataType;

    switch(aIndex)

        {

        case 0:

            dataType = TDataType(K3gpAudioMimeType);

            break;

        case 1:

            dataType = TDataType(K3gpVideoMimeType);

            break;

        case 2:

            dataType = TDataType(KMp4AudioMimeType);

            break;

        case 3:

            dataType = TDataType(KMp4VideoMimeType);

            break;

        case 4:

            dataType = TDataType(K3g2AudioMimeType);

            break;

        case 5:

            dataType = TDataType(K3g2VideoMimeType);

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }

    return dataType;

    }

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::PreferredBufSize()

// Return the supposed minimum buffer size we need to

// successfully recognize the data

// -----------------------------------------------------------------------------

//

TUint C3GPAudioPlayControllerRecognizer::PreferredBufSize()

    {

    return 0;

    }

// -----------------------------------------------------------------------------

// C3GPAudioPlayControllerRecognizer::DoRecognizeL

// Attempt to recognize the data

// this recognizer only attempts to match the data and/or file suffix

//

// NB if the file is not recognized, this function should NOT leave :

// it should instead set iConfidence = ENotRecognized and return

// the function should only leave if there is an out-of-memory condition

// -----------------------------------------------------------------------------

//

void C3GPAudioPlayControllerRecognizer::DoRecognizeL(

        const TDesC& aName,

        const TDesC8& aBuffer)

    {

    DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL"));

#ifdef _DEBUG

    RDebug::RawPrint(aName);

#endif

    DP0(_L(" "));

    TPtrC8 header;

    TInt headerMatch = 0;

    // assume Match will fail :

    iConfidence = CApaDataRecognizerType::ENotRecognized;

    if (aName.Find(KDot) == KErrNotFound) // No extension

        {

        DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL - Ext not present"));

        if (aBuffer.Length() < (KPreHeaderLength+KHeaderLen))

            {

            return;

            }

        else

            {

            // Check headers for 3gp (allowed to play w/out ext):

            header.Set(aBuffer.Mid(KPreHeaderLength, KHeaderLen));

            headerMatch = ( (header.FindF(K3gpHeader)  == 0) ||

                            (header.FindF(KMp4Header)  == 0) ||

                            (header.FindF(KMmp4Header) == 0) ||

                            (header.FindF(KM4aHeader)  == 0) ||

                            (header.FindF(K3g2Header)  == 0) ||

                            (header.FindF(K3gp6Header) == 0) ||

                            (header.FindF(K3gr6Header) == 0) ||

                            (header.FindF(K3gs6Header) == 0) );

            DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL: headerMatch = %d"), headerMatch);

            if (!headerMatch)

                {

                return;

                }

            }

        }

    TPtrC ext(aName.Right(KExtLength));

    DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL: Extension:"));

#ifdef _DEBUG

    RDebug::RawPrint(ext);

#endif

    DP0(_L(" "));

    if ( (ext.CompareF(KDot3gp) == 0) || (ext.CompareF(KDotMp4) == 0) ||

         (ext.CompareF(KDotM4a) == 0) || (ext.CompareF(KDot3g2) == 0) || 

         (ext.CompareF(KDot3ga) == 0) || headerMatch)

        {

        RFile* fileHandle= NULL;

        TRAPD(handleErr, fileHandle = FilePassedByHandleL());

        if (handleErr != KErrNone)

            {

            DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL - Can't get FH [%d]"), handleErr);

            return;

            }

        MP4Handle mp4Handle;    // 3GP library handle

        MP4Err err;

        // Check if file handle exists first. If not, try to open with file name.

        if (fileHandle)

            {

            err = MP4ParseOpenFileHandle(&mp4Handle, fileHandle);

            DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL FileHandle, err[%d]"), err);

            }

        else

            { // file handle not present

            RBuf buf;

            TUint nameSize = aName.Length() + 1; // Add 1 extra for "zero" termination

            buf.CreateL(nameSize); // Create the RBuf 

            buf = aName; // Copy "aName" using the assignment operation

            err = MP4ParseOpen(&mp4Handle, (MP4FileName) buf.PtrZ());  

            buf.Close(); // Close Buf to free the memory

            DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL FileName, err[%d]"), err);

            if (err != MP4_OK)

                { // cannot find the file by name but the header content or extension was ok

                err = MP4ParseOpen(&mp4Handle, NULL);

                DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL databuf, err[%d]"), err);

                if (err == MP4_OK)

                    {

                    TUint8* p = (TUint8*)(aBuffer.Ptr());

                    TInt l = aBuffer.Length();

                    DP2(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL databuf *p[0x%x] l[%d]"), p[0], l);

                    err = MP4ParseWriteData(mp4Handle, p, l);

                    DP1(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL databuf write, err[%d]"), err);

                    }

                }

            }

        if (err == MP4_OK)

            {

            mp4_u32 videoLength, videoType, videoWidth, videoHeight, timeScale;

            mp4_double frameRate;

            err = MP4ParseRequestVideoDescription(mp4Handle, &videoLength, &frameRate,

                    &videoType, &videoWidth, &videoHeight, &timeScale);

            if (err == MP4_NO_VIDEO)

                {

                mp4_u32 audioLength, audioType, timeScale, averateBitRate;

                mp4_u8 framesPerSample;

                err = MP4ParseRequestAudioDescription(mp4Handle, &audioLength, &audioType,

                        &framesPerSample, &timeScale, &averateBitRate);

                if (err == MP4_OK)

                    {

                    if ( (header.FindF(K3gpHeader)  == 0) ||

                         (header.FindF(K3gp6Header) == 0) ||

                         (header.FindF(K3gr6Header) == 0) ||

                         (header.FindF(K3gs6Header) == 0) ||

                         (header.FindF(KMmp4Header) == 0) ||

                         (ext.CompareF(KDot3gp)     == 0) ||

                         (ext.CompareF(KDot3ga)     == 0) )

                        {

                        iDataType = TDataType(K3gpAudioMimeType);

                        iConfidence = ECertain;

                        DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [3gp audio]"));

                        }

                    else if ( (header.FindF(KM4aHeader) == 0) ||

                              (ext.CompareF(KDotM4a)    == 0) ||

                              (header.FindF(KMp4Header) == 0) ||

                              (ext.CompareF(KDotMp4)    == 0) )

                        {

                        iDataType = TDataType(KMp4AudioMimeType);

                        iConfidence = ECertain;

                        DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [Mp4 audio]"));

                        }

                    else if ( (header.FindF(K3g2Header) == 0) ||

                              (ext.CompareF(KDot3g2)    == 0) )

                        {

                        iDataType = TDataType(K3g2AudioMimeType);

                        iConfidence = ECertain;

                        DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [3g2 audio]"));

                        }

                    } // End if (err == MP4_OK)

                } // End If (err == MP4_NO_VIDEO) i.e. Audio

            else if (err == MP4_OK)

                {

                if ( (header.FindF(K3gpHeader)  == 0) ||

                     (header.FindF(K3gp6Header) == 0) ||

                     (header.FindF(K3gr6Header) == 0) ||

                     (header.FindF(K3gs6Header) == 0) ||

                     (header.FindF(KMmp4Header) == 0) ||

                     (ext.CompareF(KDot3gp)     == 0) )

                    {

                    iDataType = TDataType(K3gpVideoMimeType);

                    iConfidence = ECertain;

                    DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [3gp video]"));

                    }

                else if ( (header.FindF(KMp4Header) == 0) ||

                          (ext.CompareF(KDotMp4)    == 0) )

                    {

                    iDataType = TDataType(KMp4VideoMimeType);

                    iConfidence = ECertain;

                    DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [Mp4 video]"));

                    }

                else if ( (header.FindF(K3g2Header) == 0) ||

                          (ext.CompareF(KDot3g2)    == 0) )

                    {

                    iDataType = TDataType(K3g2VideoMimeType);

                    iConfidence = ECertain;

                    DP0(_L("C3GPAudioPlayControllerRecognizer::DoRecognizeL [3g2 video]"));

                    }

                }// end of else if (err == MP4_OK)

            }// End FileHandle or FileName Open OK

        if (mp4Handle)

            {

            MP4ParseClose(mp4Handle);

            }

        } // End of Extension Comparision If statement

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------

// CApaDataRecognizerType* CreateRecognizerL()

// Used to create an instance of a CApaDataRecognizerType-derived class

// -----------------------------------------------------------------------------

//

CApaDataRecognizerType* C3GPAudioPlayControllerRecognizer::CreateRecognizerL()

    {

	return new(ELeave) C3GPAudioPlayControllerRecognizer();

	}

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(0x101FAFD6, C3GPAudioPlayControllerRecognizer::CreateRecognizerL)

    };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

// End of file