// Copyright (c) 2008-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 <bitdev.h> 

#include <fbs.h> 

#include <gdi.h> 

#include <utf.h> 

#include "subtitlesource.h"

#include "srtdecoder.h"

#include "srtframe.h"

// Define the separators for each subtitle frame in SRT file

_LIT8(KSrtFrameSeparator1, "\r\n\r\n" );

_LIT8(KSrtFrameSeparator2, "\n\n" );

// The length of the separators

const TInt KSrtFrameSeparator1Len = 4;

const TInt KSrtFrameSeparator2Len = 2;

// The margin size

const TInt KSrtBmpMarginWidth = 6;

const TInt KSrtBmpMarginHeight = 6;

// The width of subtitle region is the same as the width of the video region, while the height is 33 

// percent of the height of the video region. 

const TInt KSrtSubtitleRegionYFactor = 33;

// Define panic category

_LIT(KSrtSubtitleDecoderPanicCategory, "SrtSubDec");

// TSrtSubtitleDecoderPanics is an enumeration with the following entries:

// EBadCall indicates a bad call

enum TSrtSubtitleDecoderPanics

    {

    ESrtBadCall = 1,

    ESrtUnexpected,

    ESrtNotStarted,

    ESrtAlreadyStarted

    };

/** Constructor with a reference to the subtitle source 

@param aSubtitleSource a reference to the subtitle source

*/ 

CSrtSubtitleDecoder::CSrtSubtitleDecoder(MSubtitleSource& aSubtitleSource) : 

    iSource(aSubtitleSource)

    {

    }

EXPORT_C CSrtSubtitleDecoder::~CSrtSubtitleDecoder()

    {

    delete iFrameParser;

    iDecodeBuffer.Close();

    }

/** Allocates and constructs a srt subtitle decoder 

@param aSubtitleSource a reference to the subtitle source

@return A pointer to the new object. 

@leave If an error occurs, the method will leave with a system-wide error code. 

*/    

EXPORT_C CSrtSubtitleDecoder* CSrtSubtitleDecoder::NewL(MSubtitleSource& aSubtitleSource)

    {

    CSrtSubtitleDecoder* self = new(ELeave) CSrtSubtitleDecoder(aSubtitleSource);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/** Initialises the decoder

@leave If an error occurs, the method will leave with a system-wide error code.

*/

void CSrtSubtitleDecoder::ConstructL()

    {

    iFrameParser = CSrtFrame::NewL();

    }

EXPORT_C TInt CSrtSubtitleDecoder::CalculateSubtitleRegion(const TRect& aScreenSize, TRect& aSubtitleRegion)

    {

    // TRect::IsEmpty is not used because the following test tests the minus values.

    if ((aScreenSize.iBr.iX < 0) || (aScreenSize.iBr.iY < 0) || 

        (aScreenSize.iTl.iX < 0) || (aScreenSize.iTl.iY < 0))

        {

        return KErrArgument;  

        }

    if ((aScreenSize.iBr.iX <= aScreenSize.iTl.iX) || (aScreenSize.iBr.iY <= aScreenSize.iTl.iY))

        {

        return KErrArgument; 

        }

    TPoint topleft;

    topleft.iX = aScreenSize.iTl.iX;

    topleft.iY = aScreenSize.iTl.iY + aScreenSize.Height() * (100 - KSrtSubtitleRegionYFactor) / 100; 

    aSubtitleRegion.SetRect(topleft, aScreenSize.iBr);

    return KErrNone;

    }

/** Calculate the number of the characters in the first line. The full words are supposed to be displayed 

unless the length of a word is bigger than one line space. 

@param aFont The font in current use.

@param aText The descriptor

@param aWidthInPixels The available width for character display.

@param aNumOfCharsToSkip The number of characters to skip, it can be 0, 1 (\n) or 2 (\r\n) 

@return The number of characters which will be able to be displayed without exceeding the specified width. 

The count starts from the beginning of the descriptor. 

*/   

TInt CSrtSubtitleDecoder::CalculateCharsInNextLine(const CFont &aFont, const TDesC &aText, TInt aWidthInPixels, TInt& aNumOfCharsToSkip)

    {

    const TChar KMMFSubtitleCharSpace(' ');

    const TChar KMMFSubtitleCharCR('\r');

    const TChar KMMFSubtitleCharLF('\n');

    TInt charsInLine = aFont.TextCount(aText, aWidthInPixels);

    aNumOfCharsToSkip = 0;

    if (charsInLine < aText.Length())

        {

        // For finding the last space of a descriptor which is not very big, using a simple loop 

        // shall be more efficient than using TLex

        for (TInt i = charsInLine; i > 0; i--)

            {

            if (KMMFSubtitleCharSpace == aText[i - 1])

                {

                charsInLine = i;

                break;

                }

            }

        }

    // Check \r\n or \n, the following loop is more efficient than TDesC::Find() in most cases 

    // because both \r\n and \n are handled in one loop. 

    for (TInt j = 0; j < charsInLine; j++)

        {

        if (KMMFSubtitleCharLF == aText[j])

            {

            if (j > 0)

                {

                // ignore \r if there is a \n

                if (KMMFSubtitleCharCR == aText[j - 1])

                    {

                    charsInLine = j;

                    aNumOfCharsToSkip = 2;

                    }

                else

                    {

                    charsInLine = j + 1;

                    aNumOfCharsToSkip = 1;

                    }

                }

            else

                {

                charsInLine = j + 1;

                aNumOfCharsToSkip = 1;

                }

            break;

            }

        }

    return charsInLine;

    }

/** Based on a descriptor containing a SRT subtitle frame, the function generates a single frame of 

subtitle animation for the current time and outputs the region of the subtitle frame that has been 

updated.

@param aContent The subtitle frame as a descriptor

@param aSubtitleFrame Reference to the current subtitle frame

@param aDirtyRegion The decoder outputs the region of the subtitle frame that has been updated. 

    i.e. the region that now contains new subtitle content.

@leave If an error occurs, the method will leave with a system-wide error code. 

*/

void CSrtSubtitleDecoder::DecodeSubtitleContentL(const TDesC8& aContent, CFbsBitmap& aSubtitleFrame, TRect& aDirtyRegion)

    {

    TSize bmpSize = aSubtitleFrame.SizeInPixels(); 

    TSize modifiedBmpSize;

    // the following value of "2" means two side of margin. 

    modifiedBmpSize.iHeight = bmpSize.iHeight - KSrtBmpMarginHeight * 2;

    modifiedBmpSize.iWidth = bmpSize.iWidth - KSrtBmpMarginWidth * 2;

    // test if the size of the bitmap is valid after taking margin into account   

    if ((modifiedBmpSize.iHeight > 0) && (modifiedBmpSize.iWidth > 0))

        {

        // prepare and populate the bitmap

        CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(&aSubtitleFrame);

        CleanupStack::PushL(bmpDevice);

        CFbsBitGc* bitmapContext = CFbsBitGc::NewL(); //Create a GC to draw to the bitmap

        bitmapContext->Activate(bmpDevice);

        CleanupStack::PushL(bitmapContext);

        bitmapContext->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

        // Use a white color (R=255, G=255, B=255) with alpha value of 0. 

        TRgb transparentWhite(255, 255, 255, 0);

        bitmapContext->SetBrushColor(transparentWhite);

        bitmapContext->Clear(); 

        bitmapContext->SetDrawMode(CGraphicsContext::EDrawModePEN);

        bitmapContext->SetPenStyle(CGraphicsContext::ESolidPen);

        bitmapContext->SetPenColor(KRgbBlack);

        HBufC* content = CnvUtfConverter::ConvertToUnicodeFromUtf8L(aContent);

        CleanupStack::PushL(content);

        // try to set up font

        CFont *font = NULL;

        TFontSpec fontSpec(KSrtTargetTypefaceName, KSrtTargetTypefaceHeightInTwips);

        User::LeaveIfError(bmpDevice->GetNearestFontToDesignHeightInTwips(font, fontSpec));

        bitmapContext->UseFont(font);

        TInt maxCharWidthInPixels = font->MaxCharWidthInPixels();

        TInt heightInPixels = font->HeightInPixels();

        TInt maxLines = modifiedBmpSize.iHeight / heightInPixels;    

        TInt maxCharsPerLine = modifiedBmpSize.iWidth / maxCharWidthInPixels; 

        TInt charsInLine = 0;

        TInt currentRow = 0;

        TPoint drawPosition;

        drawPosition.iX = KSrtBmpMarginWidth;

        drawPosition.iY = KSrtBmpMarginHeight + heightInPixels;

        TInt unvisitedChars = content->Length();

        TInt lineStartPos = 0;

        TInt numOfCharsToSkip = 0;

        if ((maxLines > 0) && (maxCharsPerLine > 0))

            {

            do

                {

                TPtrC ptrUnvisitedDesc = content->Right(unvisitedChars);                

                charsInLine = CalculateCharsInNextLine(*font, ptrUnvisitedDesc, modifiedBmpSize.iWidth, numOfCharsToSkip); 

                if (charsInLine > 0)

                    {

                    if (charsInLine > numOfCharsToSkip)

                        {

                        TPtrC ptrLine = content->Mid(lineStartPos, charsInLine - numOfCharsToSkip);

                        // try to draw text line by line

                        // Note that aPosition in DrawText indicates the bottom left of the first character. 

                        bitmapContext->DrawText(ptrLine, drawPosition);

                        drawPosition.iY += heightInPixels; 

                        currentRow++;

                        }

                    lineStartPos += charsInLine;

                    unvisitedChars -= charsInLine;

                    }

                }

            while(charsInLine > 0 && currentRow < maxLines);

            // update the dirty region

            aDirtyRegion.iTl.SetXY(KSrtBmpMarginWidth, KSrtBmpMarginHeight);

            TInt actualMaxCharsPerLine = 0;

            actualMaxCharsPerLine = Min(content->Length(), maxCharsPerLine);

            aDirtyRegion.iBr.SetXY(

                KSrtBmpMarginWidth + actualMaxCharsPerLine * maxCharWidthInPixels,

                KSrtBmpMarginHeight + currentRow * heightInPixels + font->FontMaxDescent());

            }

        else

            {

            // bitmap too small for the font

            User::Leave(KErrArgument);

            }

        bmpDevice->ReleaseFont(font);

        bitmapContext->DiscardFont();

        CleanupStack::PopAndDestroy(3, bmpDevice); // content, bitmapContext, bmpDevice

        }

    else

        {

        // bitmap too small or the length of content is 0

        User::Leave(KErrArgument);

        }

    }

/** Try to get the next valid frame 

@param aSearchByVideoPosition Indicate if search for the next valid frame matching aVideoPosition

@param aVideoPosition The video position in microsecond

@leave If an error occurs, the method will leave with a system-wide error code. 

*/

void CSrtSubtitleDecoder::GetNextValidFrameL(TBool aSearchByVideoPosition, TInt64 aVideoPosition)

    {

    TInt decoderBufferMaxLen = iDecodeBuffer.MaxLength();

    TInt errorFrame = KErrNone;

    TInt error = KErrNone;

    TInt sepLen = 0;

    TInt i = 0;

    TChar currentChar = 0;

    TBool frameFound = EFalse;

    if (iLastFrame)

    	{

    	User::Leave(KErrEof);

    	}

    while (!frameFound)

        {

        // if a frame is not available in iDecodeBuffer, fill iBuffer until CRLFCRLF is available in iBuffer

        TPtrC8 restOfData = iDecodeBuffer.Right(iDecodeBuffer.Length() - iDecodeBufferPosition);

        TInt sepPosition = 0;

        // try to extract a frame from iDecodeBuffer

        errorFrame = GetFrameSeparatorInfo(restOfData, sepLen, sepPosition);

        if (KErrNotFound != errorFrame)

            {

            User::LeaveIfError(errorFrame);

            }

        // if no frame can be extracted, read source until a frame is available or get an EOF error.

        while (KErrNotFound == errorFrame)

            {

            // move the unvisited data in decode buffer to the head before read from the source

            if (iDecodeBufferPosition != 0)

                {

                // move the unvisited data in decode buffer to the head

                if (iDecodeBufferPosition <= iDecodeBuffer.Length() - 1)

                    {

                    TPtrC8 newSubtitleFrame = iDecodeBuffer.Right(iDecodeBuffer.Length() - (iDecodeBufferPosition));

                    // use iBuffer to hold the preserved data when rotating data in iDecodeBuffer

                    if (iBuffer.MaxLength() < newSubtitleFrame.Length())

                        {

                        // Some data in iBuffer make iDecodeBuffer hold at least one frame, and so

                        // iBuffer should always be larger than the preserved data in iDecodeBuffer

                        User::Panic(KSrtSubtitleDecoderPanicCategory, ESrtUnexpected);

                        }

                    iBuffer.Copy(newSubtitleFrame);

                    iDecodeBuffer.Copy(iBuffer);

                    }

                iDecodeBufferPosition = 0;

                }

            error = iSource.GetBuffer(iBuffer);

            if ((KErrNone != error) && (KErrEof != error))

                {

                User::Leave(error);

                }

            if (iBuffer.Length() > 0)

                {

                TInt bufLen = iDecodeBuffer.Length();

                TInt newBufLen = iBuffer.Length();

                if (decoderBufferMaxLen < newBufLen + bufLen)

                    {

                    iDecodeBuffer.ReAllocL(newBufLen + bufLen);

                    decoderBufferMaxLen = iDecodeBuffer.MaxLength();

                    }

                iDecodeBuffer.Append(iBuffer);

                }

            if (KErrEof == error)

                {

                // reach the end of the subtitle source but cannot find new line separators.  Frame 

                // ends at EOF marker then.  No more frames can be read after this one.

                sepLen = 0;

                sepPosition = iDecodeBuffer.Length();

                errorFrame = KErrNone;

                if (iLastFrame)

                	{

                	User::Leave(KErrEof);

                	}

                iLastFrame = ETrue;

                }

            else

            	{

            	errorFrame = GetFrameSeparatorInfo(iDecodeBuffer, sepLen, sepPosition);

            	}

            if (KErrNotFound != errorFrame)

                {

                User::LeaveIfError(errorFrame);

                }

            }

        // extract a possible frame

        TPtrC8 subtitleFrameDescriptor = iDecodeBuffer.Mid(iDecodeBufferPosition, sepPosition);

        // Find the start of the next frame, and update the current position of the decode buffer by 

        // the following method: from the start of iDecodeBuffer, find the position of the first digit 

        // character after the first frame separator. 

        // Not the current position of the decode buffer is updated before parsing the frame, so the 

        // potential invalid frame will be skipped.  

        iDecodeBufferPosition += sepPosition + sepLen;

        TInt firstDigitPosFromCurrentPos = KErrNotFound;

        for (i = iDecodeBufferPosition; i < iDecodeBuffer.Length(); i++)

            {

            currentChar = iDecodeBuffer[i];

            if (currentChar.IsDigit())

                {

                firstDigitPosFromCurrentPos = i;

                break;

                }

            }

        if (KErrNotFound == firstDigitPosFromCurrentPos) 

            {

            iDecodeBufferPosition = iDecodeBuffer.Length() - 1;

            }

        else

            {

            iDecodeBufferPosition = firstDigitPosFromCurrentPos;

            }

        // parse the frame 

        TRAPD(parseError, iFrameParser->ParseL(subtitleFrameDescriptor, aSearchByVideoPosition, aVideoPosition));

        if (KErrNone == parseError)

            {

            frameFound = ETrue;

            if (!aSearchByVideoPosition)

                {

                // skip the past frames, such as 

                // 2\r\n00:00:02,000 --> 00:00:04,000\r\nhome\r\n\r\n

                // 1\r\n00:00:00,000 --> 00:00:02,000\r\nwelcome\r\n\r\n

                // 3\r\n00:00:04,000 --> 00:00:06,000\r\nagain

                if (iFrameParser->EndTime() < iEndTimeOfLastValidFrame)

                    {

                    frameFound = EFalse;

                    }  

                else

                    {

                    iEndTimeOfLastValidFrame = iFrameParser->EndTime();

                    }  

                }      

            else

                {

                iEndTimeOfLastValidFrame = iFrameParser->EndTime();

                }    

            }

        else

            {

            if (KErrArgument != parseError)

                {

                User::Leave(parseError);

                }

            }

        }

    }

/** The decoder generates a single frame of subtitle animation for the current time.   

The decoder maintains track of the video position. The video position can be updated 

via a call to MSubtitleDecoder::SetVideoPosition(). 

@param aSubtitleFrame Reference to the current subtitle frame

@param aDirtyRegion The decoder outputs the region of the subtitle frame that has been updated. 

    i.e. the region that now contains new subtitle content.

@param aDisplayTime The time in microseconds from the current stream position that the subtitle is due. 

    DevSubtitle will draw aSubtitleFrame after aDisplayTime has elapsed.

@param aDisplayDuration The time in microseconds that this frame should be displayed for. The CRP will clear 

    this frame after aDisplayFor microseconds

@leave If an error occurs, the method will leave with a system-wide error code.

*/   

EXPORT_C void CSrtSubtitleDecoder::GetNextFrameL(CFbsBitmap& aSubtitleFrame, TRect& aDirtyRegion, TTimeIntervalMicroSeconds& aDisplayTime, TTimeIntervalMicroSeconds& aDisplayDuration)

    {

    if (!iStarted)

        {

        User::Panic(KSrtSubtitleDecoderPanicCategory, ESrtNotStarted);

        }

    TTime currentTime;

    currentTime.UniversalTime();

    TTimeIntervalMicroSeconds elapsedTime = currentTime.MicroSecondsFrom(iStartSystemTime);

    TInt64 currentVideoPositionValue = elapsedTime.Int64() + iStartVideoPosition;

    if (iFirstSearch)

        {

        // skip the past frame

        GetNextValidFrameL(ETrue, currentVideoPositionValue);

        iFirstSearch = EFalse;

        }

    else

        {

        // get the next frame

        GetNextValidFrameL(EFalse, 0);

        }

    TInt64 elapsedDuration = 0;

    // if start time <= current video time, this frame needs to be started immediately.    

    if (iFrameParser->StartTime() <= currentVideoPositionValue)

        {

        aDisplayTime = 0;

        elapsedDuration = currentVideoPositionValue - iFrameParser->StartTime();

        }

    else

        {

        aDisplayTime = iFrameParser->StartTime() - currentVideoPositionValue;

        }

    // if end time < current video time, this duration becomes 0.

    if (iFrameParser->EndTime() <= currentVideoPositionValue)

        {

        aDisplayDuration = 0;

        }

    else

        {

        aDisplayDuration = iFrameParser->Duration() - elapsedDuration;

        }