/*
 * Copyright (c) 2010 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:
 * Source file for the main class of the Thumbnail Tester test app.
 * 
 */

#include "thumbnailtester.h"
#include "yuv2rgb24.h"

#include <e32base.h>
#include <e32debug.h>
#include <f32file.h>

const TInt KFontSize = 15;

// Thumbnail tester implementation

void CThumbnailTester::ExecuteL()
    {
    CThumbnailTester* self = new(ELeave) CThumbnailTester;
    CleanupStack::PushL( self );
    self->InitL();
    self->Main();
    CleanupStack::PopAndDestroy( self );    
    }
    
CThumbnailTester::CThumbnailTester() : 
    CTestAppBase( KFontSize )
    {    
    }
    
CThumbnailTester::~CThumbnailTester()
    {
    Cancel();
    
    if( iGc && iFullScreenWindow )
	      {
        iGc->Activate(*iFullScreenWindow);
        
        iFullScreenWindow->Invalidate();
        iFullScreenWindow->BeginRedraw();
        
        iGc->Reset();
        
        iGc->UseFont(iFont);                
        iGc->SetBrushColor(KRgbDarkBlue);
        
        iGc->Clear();

        if( iFinalResult == KErrNone )
            {
            // KRgbWhite seems to be having problems (0xffffff) in some emulators,
            // but 0xfefefe is working, so use that instead of white.        
            iGc->SetPenColor(0xfefefe);                 
            }
        else
            {
            iGc->SetPenColor(KRgbRed);
            }
    
        iBuffer.Format( _L("THUMBNAILTESTER EXIT, result = %i"), iFinalResult );
        iGc->DrawText( iBuffer, TPoint(5, 20) );
       
        iFullScreenWindow->EndRedraw();
        
        iGc->Deactivate();
        
        iFullScreenWindow->SetVisible( ETrue );
        
        WaitForAnyKey();
        }    
    
    }
    
void CThumbnailTester::InitL()
    {
    BaseConstructL( NULL, 0 );  // this app doesn't use the option pages concept
    
    iFullScreenWindow = new(ELeave) RWindow( iWs );
    User::LeaveIfError( iFullScreenWindow->Construct( *iWindowGroup, KNullWsHandle ) );
    iFullScreenWindow->SetExtent( TPoint(0,0), iDisplaySize );
    iFullScreenWindow->SetNonTransparent();
    iFullScreenWindow->SetBackgroundColor(KRgbBlack);
    iFullScreenWindow->SetVisible(false);
    iFullScreenWindow->Activate();
        
    iGc->Activate(*iFullScreenWindow);

    iFullScreenWindow->BeginRedraw();
    
    iGc->Reset();    
    iGc->UseFont(iFont);                
    iGc->SetBrushStyle(CWindowGc::ESolidBrush);
    iGc->SetBrushColor(KRgbBlack);    
    iGc->Clear();
    
    iFullScreenWindow->EndRedraw();
    
    iGc->Deactivate();    
    }

void CThumbnailTester::Main()
    {    
    TRAPD( err, MainL() ); 
    
    RDebug::Printf( "THUMBNAILTESTER Completed, err=%i", err );    
    }

void CThumbnailTester::MainL()        
    {
    TFileName filename;
    
    SelectFileWithHistoryL( TPoint(0,0), iDisplaySize, filename, KHistoryFilename, KMaxHistoryEntries );
    
    GenerateThumbnailL( filename );
    }
  
void CThumbnailTester::GenerateThumbnailL( TDes& aFileName )
    {
    SelectIntegerL( TPoint(0,0), iDisplaySize, _L("Select starting position(seconds):"), 0, 9999, iStartPositionInMs );
    
    // Convert from seconds to ms.
    iStartPositionInMs *= 1000;
        
    _LIT( KFull,   "Full speed" );
    _LIT( KMedium, "100 millisecond delay" );
    _LIT( KSlow,   "1 second delay" );

    RPointerArray<TDesC> speed;
    speed.Append( &KFull );
    speed.Append( &KMedium );
    speed.Append( &KSlow );
    
    TInt index = SelectFromListL( TPoint(0,0), iDisplaySize, _L("Select speed:"), speed );
    
    speed.Reset();
    
    switch( index )
        {
        case 0:
            iDelayBetweenFrames = 0;
            break;
        case 1:
            iDelayBetweenFrames = 100000;  // 1/10 second
            break;
        case 2:
            iDelayBetweenFrames = 1000000;  // 1 second
            break;
        }

    RFile file;    
    User::LeaveIfError( file.Open( iFs, aFileName, EFileShareReadersOnly | EFileStream | EFileRead ) );
    
    iThumbnailUtility = CHXThumbnailUtility::NewL(*this);

    bool done = false;

    iStopThumbnailGeneration = false;
    
    StartMonitoringWindowEvents();
    
    TInt originalStartPositionInMs = iStartPositionInMs;
    
    while( !done )
        {
        iThumbnailUtility->OpenFileL( file, iStartPositionInMs );

        // OpenFileL will block until all bitmaps have been passed to PacketReady.
        
        // This isn't necessarily exact, but advance the start position by the time represented
        // by the number of renderered frames.
        iStartPositionInMs = originalStartPositionInMs + (iTotalFramesRendered * 1000) / iFrameRateInSec;
                
        done = ((iFramesRendered < 5) || iStopThumbnailGeneration);
        
        iFramesRendered = 0;
        }
    
    Cancel();
 
    WaitForAnyKey();
    
    delete iThumbnailUtility;
    iThumbnailUtility = NULL;
    
    file.Close();    
    }
           
bool CThumbnailTester::ConsumeKeyEvent( TInt /*aKeyCode*/ )
    {
    // Stop thumbnail generation when a key is pressed.
    iStopThumbnailGeneration = true;
    iThumbnailUtility->CancelThumb();
    return true;
    }

void CThumbnailTester::ExecuteOperation( TInt aOperation, const TDesC& aOperationText )
    {    
    }

void CThumbnailTester::MetaDataReady(TInt aError)
    {
    RDebug::Printf( "THUMBNAILTESTER MetadataReady(%i)", aError );
    
    // Get basic meta data.
    
    TUint lCount = 0;
    TUint i=0;
    
    iThumbnailUtility->GetMetaDataCount(lCount);

    RDebug::Printf( "THUMBNAILTESTER metadata count=%i", lCount );
    
    for (i=0; i<lCount; i++)
        {
        HBufC *pDes = NULL;           
        HXMetaDataKeys::EHXMetaDataId id;        
        iThumbnailUtility->GetMetaDataAt(i, id, pDes);

        const char* key = "";
        
        for( TInt j = 0; j < sizeof(HXMetaDataKeyTab)/sizeof(HXMetaDataKeys); j++ )
            {
            if( id == HXMetaDataKeyTab[j].m_id )
                {
                key = HXMetaDataKeyTab[j].m_pHXKey;
                }
            }
        
        for( TInt j = 0; j < sizeof(HXStreamMetaDataKeyTab)/sizeof(HXMetaDataKeys); j++ )
            {
            if( id == HXStreamMetaDataKeyTab[j].m_id )
                {
                key = HXStreamMetaDataKeyTab[j].m_pHXKey;
                }
            }
        
        RDebug::Printf( "THUMBNAILTESTER metadata[%i] id=%i key=%s", i, id, key );        
        
        TInt current = 0;
        TBuf8<400> outputLine;
        while( current < pDes->Length() )
            {
            char c = pDes->Des()[current];                
            char c2 = c;
            if( c2 < ' ' || c2 > '~' )
                {
                c2 = ' ';
                }
            
            outputLine.AppendFormat(_L8("%02x/%c "), c, c2 ); 
            
            current++;
            
            if( (current % 20 == 0) || current == pDes->Length()  )
                {
                outputLine.Append( '\0' );
                RDebug::Printf( (char*)outputLine.Ptr() );
                outputLine.SetLength(0);
                }            
            }        
        
        if (id == HXMetaDataKeys::EHXFrameSize && pDes)
            {
            TPtr pFrameSizePtr = pDes->Des();
            _LIT(KChar_x, "x");
            TInt xLoc = pFrameSizePtr.Find(KChar_x);
            if (xLoc != KErrNotFound)
                {                           
                TLex lexWidth(pFrameSizePtr.Mid(0, xLoc));
                TLex lexHeight(pFrameSizePtr.Mid(xLoc+1));
                lexWidth.Val(iWidth);  // Storing into local iWidth variable
                lexHeight.Val(iHeight);  // Storing into local iHeight variable  
                }
            }
        else if (id == HXMetaDataKeys::EHXDuration && pDes)
            {
            TLex lexDuration(pDes->Des());
            lexDuration.Val(iDuration);
            }        
        else if (id == HXMetaDataKeys::EHXFramesPerSecond && pDes)
            {
            TLex lexFramesPerSecond(pDes->Des());           
            lexFramesPerSecond.Val(iFrameRateInSec);            
            }
        else if (id == HXMetaDataKeys::EHXClipBitRate && pDes)
            {
            TLex lexBitRate(pDes->Des());           
            lexBitRate.Val(iClipBitRate);            
            }
        else if (id == HXMetaDataKeys::EHXVideoBitRate && pDes)
            {
            TLex lexBitRate(pDes->Des());           
            lexBitRate.Val(iVideoBitRate);            
            }
        else if (id == HXMetaDataKeys::EHXAudioBitRate && pDes)
            {
            TLex lexBitRate(pDes->Des());           
            lexBitRate.Val(iAudioBitRate);            
            }
        
        } // end for
    
    iTotalFrameCount = ( (iDuration+500)/1000 ) * iFrameRateInSec;
    
    RDebug::Printf( "THUMBNAILTESTER width=%i", iWidth );
    RDebug::Printf( "THUMBNAILTESTER height=%i", iHeight );
    RDebug::Printf( "THUMBNAILTESTER frame rate=%i", iFrameRateInSec );
    RDebug::Printf( "THUMBNAILTESTER duration=%i", iDuration );
    RDebug::Printf( "THUMBNAILTESTER frame count=%i", iTotalFrameCount );
    RDebug::Printf( "THUMBNAILTESTER clip bit rate=%i", iClipBitRate );
    RDebug::Printf( "THUMBNAILTESTER video bit rate=%i", iVideoBitRate );
    RDebug::Printf( "THUMBNAILTESTER audio bit rate=%i", iAudioBitRate );
    }

void CThumbnailTester::PacketReady(TInt /*aError*/, void *pYuvBuffer, TUint32 /*aYuvBufferSize*/)
    {
    // TODO: HANDLE aError
    
    iFramesRendered++;
    iTotalFramesRendered++;
    
    // Convert from YUV420 to RGB24.
    
    const TInt KBytesPerPixel = 3; // 24-bit rgb takes 3 bytes
    
    TUint32 rgbBufferSize = iWidth * iHeight * KBytesPerPixel;
    TUint8 *pRgbBuffer =(TUint8*) User::AllocL(rgbBufferSize);
        
    CYuv2Rgb24* yuvConverter = NULL; 
    TRAPD(err, yuvConverter = new(ELeave) CYuv2Rgb24);
    
    // TODO: CHECK ERROR

    TRAP(err, yuvConverter->ConstructL(iWidth, iHeight, iWidth, iHeight))

    // TODO: CHECK ERROR

    TInt scanLineLength = iWidth * KBytesPerPixel;
    
    TUint8* yBuf = (TUint8*)pYuvBuffer;
    TUint8* uBuf = yBuf + iWidth*iHeight;
    TUint8* vBuf = uBuf + (iWidth*iHeight)/4;    
    
    yuvConverter->Convert(yBuf, uBuf, vBuf, iWidth, iHeight, pRgbBuffer, scanLineLength);
    
    delete yuvConverter;        

    // Use RGB24 buffer to create CFbsBitmap.
    
    CFbsBitmap* pBitmap = NULL;
    
    TRAP(err, pBitmap = new (ELeave) CFbsBitmap);
    if( err == KErrNone )
        {
        err = pBitmap->Create(TSize(iWidth, iHeight), EColor16M); 
    
        if( err == KErrNone )
            {
            // fill image from rgb buffer to input bitmap buffer 
            TPtr8 linePtr(0,0); 
            TInt lineLength = pBitmap->ScanLineLength(iWidth, EColor16M); 
            for(int j=0, i=0; j<iHeight; j++, i+=lineLength)
                {
                linePtr.Set(pRgbBuffer+i, lineLength, lineLength);
                pBitmap->SetScanLine((TDes8&)linePtr,j); 
                }
                
            iGc->Activate(*iSelectionWindow);
            
            iSelectionWindow->Invalidate();
            iSelectionWindow->BeginRedraw();
            
            iGc->Reset();
            
            iGc->UseFont(iFont);                
            iGc->SetBrushColor(KRgbDarkBlue);
            
            iGc->Clear();
            
            // KRgbWhite seems to be having problems (0xffffff) in some emulators,
            // but 0xfefefe is working, so use that instead of white.        
            iGc->SetPenColor(0xfefefe);

            TPoint topLeft( iDisplaySize.iWidth/2 - iWidth/2, 
                            iDisplaySize.iHeight/2 - iHeight/2 ); 
            iGc->BitBlt( topLeft, pBitmap );
            
            const TInt KColumn = 3;
            const TInt KRowIncrement = KFontSize + 1;
            TInt row = KRowIncrement;

            iBuffer.Format( _L("Frame # %i"), iFramesRendered );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;

            iBuffer.Format( _L("Total frames rendered: %i"), iTotalFramesRendered );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;

            iBuffer.Format( _L("Start time(ms): %i"), iStartPositionInMs );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;

            iBuffer.Format( _L("Display size: %ix%i"), iDisplaySize.iWidth, iDisplaySize.iHeight );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;
            
            iBuffer.Format( _L("Video size: %ix%i"), iWidth, iHeight );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Total frame count: %i"), iTotalFrameCount );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Duration: %i"), iDuration );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Frame rate: %i"), iFrameRateInSec );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Clip bit rate: %i"), iClipBitRate );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Video bit rate: %i"), iVideoBitRate );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            
            
            iBuffer.Format( _L("Audio bit rate: %i"), iAudioBitRate );
            iGc->DrawText( iBuffer, TPoint(KColumn, row) );
            row += KRowIncrement;            

            iGc->DrawText( _L("<Press key to stop then another to exit>"), TPoint(KColumn, iDisplaySize.iHeight-10) );
            
            iSelectionWindow->EndRedraw();
            
            iGc->Deactivate();
            
            iSelectionWindow->SetVisible( ETrue );            
            }
        
        delete pBitmap;
        }
    
    delete pRgbBuffer;    

    User::After( iDelayBetweenFrames );    
    }

void CThumbnailTester::EndOfPackets()
    {
    RDebug::Printf( "THUMBNAILTESTER end of packets" );
    }

GLDEF_C TInt E32Main()
    {
    __UHEAP_MARK;
    
    CActiveScheduler* scheduler = new CActiveScheduler;
    CTrapCleanup* cleanup = CTrapCleanup::New();
    if( scheduler != NULL && cleanup != NULL )
    {
        CActiveScheduler::Install( scheduler );
        TRAP_IGNORE( CThumbnailTester::ExecuteL() );
    }
    delete cleanup;
    delete scheduler;
    REComSession::FinalClose();
    __UHEAP_MARKEND;
    return 0;
    }