/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

* MPEG-4 VOL header parsing.

*

*/

// INCLUDE FILES

#include "mpegcons.h"

#include "VedVolReader.h"

// MACROS

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

// CONSTANTS

const TUint8 CVedVolReader::KMsbMask[] = {1, 3, 7, 15, 31, 63, 127, 255};

const TUint8 CVedVolReader::KLsbMask[] = {255, 254, 252, 248, 240, 224, 192, 128, 0};

const TInt CVedVolReader::KMaxUserDataLength = 512;

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

// Two-phased constructor

EXPORT_C CVedVolReader* CVedVolReader::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// C++ default constructor

CVedVolReader::CVedVolReader() : iBitstreamMode(EVedVideoBitstreamModeUnknown)

    {

    // Reset the header data to zeroes

    Mem::FillZ(&iHeader, sizeof(TVolHeader));

    }

// Symbian OS default constructor can leave

void CVedVolReader::ConstructL()

    {

    }

// Destructor

CVedVolReader::~CVedVolReader()

    {

    if (iHeader.iUserData != 0)

        {

        delete iHeader.iUserData;

        }

    }

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

// CVedVolReader::ParseVolHeaderL

// Parses given Video Object Layer header

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

//

EXPORT_C TInt CVedVolReader::ParseVolHeaderL(TDesC8& aData)

    {

    TInt useDefaultVBVParams = 0;

    TInt numBits;

    TUint32 bits;

    // Reset the header data

    if (iHeader.iUserData != 0)

        {

        delete iHeader.iUserData;

        iHeader.iUserData = 0;

        }

    Mem::FillZ(&iHeader, sizeof(TVolHeader));

    iBitstreamMode = EVedVideoBitstreamModeUnknown;

    iHeaderSize = 0;

    // Check that we have something to parse

    if (aData.Length() == 0)

        {

        User::Leave(KErrNotFound);

        }

    TSeqHeaderBuffer buffer(aData, 0, 7);   // Bit 7 is the first bit in a byte   

    // if H.263 PSC is present

    bits = ReadSeqHeaderBits(buffer, 22, EFalse);

    if (bits == 32)

        {

        // This is H.263 so there are no VOL headers

        iBitstreamMode = EVedVideoBitstreamModeH263;

        return KErrNone;

        }

    // if Visual Object Sequence Start Code is present 

    bits = ReadSeqHeaderBits(buffer, MP4_VOS_START_CODE_LENGTH, EFalse);

    if (bits == MP4_VOS_START_CODE)

        {

        // vos_start_code

        ReadSeqHeaderBits(buffer, MP4_VOS_START_CODE_LENGTH, ETrue);

        // profile_and_level_indication (8 bits) 

        bits = ReadSeqHeaderBits(buffer, 8, ETrue);      

        //   8: Simple Profile Level 0 (from ISO/IEC 14496-2:1999/FPDAM4 [N3670] October 2000)

        //   9: Simple Profile Level 0b

        //   1: Simple Profile Level 1

        //   2: Simple Profile Level 2

        //   3: Simple Profile Level 3

        //   4: Simple Profile Level 4a

        if (bits != 1 && bits != 2 && bits != 3 && bits != 4 && bits != 8 && bits != 9)

            {

            // Profile level id was not recognized so take a guess

            // This is changed later if resolution does not match

            bits = 9;

            }

        iHeader.iProfileLevelId = (TInt) bits;

        ReadUserDataL(buffer);

        }

    // if Visual Object Start Code is present 

    bits = ReadSeqHeaderBits(buffer, MP4_VO_START_CODE_LENGTH, EFalse);

    if (bits == MP4_VO_START_CODE)

        {

        // visual_object_start_code

        ReadSeqHeaderBits(buffer, MP4_VO_START_CODE_LENGTH, ETrue);

        // is_visual_object_identifier (1 bit)

        bits = ReadSeqHeaderBits(buffer, 1, ETrue);

        if (bits)

            {

            // visual_object_ver_id (4 bits)

            bits = ReadSeqHeaderBits(buffer, 4, ETrue);

            if (bits != 1 && bits != 2)

                {

                // this is not an MPEG-4 version 1 or 2 stream

                PRINT((_L("CVedVolReader: ERROR - This is not an MPEG-4 version 1 or 2 stream")))

                User::Leave(KErrNotSupported);

                }

            // visual_object_priority (3 bits) 

            bits = ReadSeqHeaderBits(buffer, 3, ETrue);

            iHeader.iVoPriority = (TInt) bits;

            } 

        else

            {

            iHeader.iVoPriority = 0;

            }

        // visual_object_type (4 bits)

        bits = ReadSeqHeaderBits(buffer, 4, ETrue);

        if (bits != 1)

            {

            // this is not a video object

            PRINT((_L("CVedVolReader: ERROR - This is not a video object")))

            User::Leave(KErrNotSupported);

            }

        // is_video_signal_type (1 bit)

        bits = ReadSeqHeaderBits(buffer, 1, ETrue);

        if (bits)

            {

            /* Note: The following fields in the bitstream give information about the 

               video signal type before encoding. These parameters don't influence the 

               decoding algorithm, but the composition at the output of the video decoder.

               Until a way to utilize them is found, these fields are just dummyly read,

               but not interpreted.

               For interpretation see the MPEG-4 Visual standard page 66-70. */

            // video_format (3 bits)

            bits = ReadSeqHeaderBits(buffer, 3, ETrue);

            iHeader.iVideoFormat = (TInt) bits;

            // video_range (1 bit)

            bits = ReadSeqHeaderBits(buffer, 1, ETrue);

            iHeader.iVideoRange = (TInt) bits;

            // colour_description (1 bit)

            bits = ReadSeqHeaderBits(buffer, 1, ETrue);

            if (bits)

                {          

                // colour_primaries (8 bits)

                bits = ReadSeqHeaderBits(buffer, 8, ETrue);

                iHeader.iColourPrimaries = (TInt) bits;

                // transfer_characteristics (8 bits)

                bits = ReadSeqHeaderBits(buffer, 8, ETrue);

                iHeader.iTransferCharacteristics = (TInt) bits;

                // matrix_coefficients (8 bits)

                bits = ReadSeqHeaderBits(buffer, 8, ETrue);

                iHeader.iMatrixCoefficients = (TInt) bits;

                }

            else

                {

                iHeader.iColourPrimaries = 1;         // default: ITU-R BT.709 

                iHeader.iTransferCharacteristics = 1; // default: ITU-R BT.709 

                iHeader.iMatrixCoefficients = 1;      // default: ITU-R BT.709 

                }

            } 

        else

            {

            // default values

            iHeader.iVideoFormat = 5;             // Unspecified video format 

            iHeader.iVideoRange = 0;              // Y range 16-235 pixel values 

            iHeader.iColourPrimaries = 1;         // ITU-R BT.709 

            iHeader.iTransferCharacteristics = 1; // ITU-R BT.709 

            iHeader.iMatrixCoefficients = 1;      // ITU-R BT.709 

            }

        // check the next start code

        ReadSeqHeaderBits(buffer, 1, ETrue);

        if (buffer.iBitInOctet != 7)

            {

            numBits = buffer.iBitInOctet + 1;

            bits = ReadSeqHeaderBits(buffer, numBits, ETrue);

            if (bits != (TUint32) ((1 << numBits)-1))

                {

                // stuffing error in VO

                PRINT((_L("CVedVolReader: ERROR - Stuffing error")))

                User::Leave(KErrNotSupported);

                }

            }

        ReadUserDataL(buffer);

        }

    // if Video Object Start Code is present

    bits = ReadSeqHeaderBits(buffer, MP4_VID_START_CODE_LENGTH, EFalse);

    if (bits == MP4_VID_START_CODE)

        {

        // video_object_start_code 

        ReadSeqHeaderBits(buffer, MP4_VID_START_CODE_LENGTH, ETrue);

        // video_object_id

        bits = ReadSeqHeaderBits(buffer, MP4_VID_ID_CODE_LENGTH, ETrue);

        iHeader.iVoId = (TInt) bits;

        }

    // Check if H.263 PSC follows the VO header, in which case this is MPEG-4 with short header

    bits = ReadSeqHeaderBits(buffer, 22, EFalse);

    if (bits == 32 || buffer.iData.Length() <= buffer.iGetIndex)

        {

        iBitstreamMode = EVedVideoBitstreamModeMPEG4ShortHeader;

        // Calculate the header size in bytes

        if (buffer.iBitInOctet == 7)

            {

            // The size is a multiple of 8 bits so the size is the number of bytes we've read so far

            iHeaderSize = buffer.iGetIndex;

            }

        else

            {

            // Round up to the next full byte

            iHeaderSize = buffer.iGetIndex + 1;

            }

        // We no longer support short header clips    

        User::Leave(KErrNotSupported);

        }

    // vol_start_code 

    bits = ReadSeqHeaderBits(buffer, MP4_VOL_START_CODE_LENGTH, ETrue);

    if(bits != MP4_VOL_START_CODE)

    {

        PRINT((_L("CVedVolReader: ERROR - Bitstream does not start with MP4_VOL_START_CODE")))

        User::Leave(KErrCorrupt);

    }

    // vol_id

    bits = ReadSeqHeaderBits(buffer, MP4_VOL_ID_CODE_LENGTH, ETrue);

    iHeader.iVolId = (TInt) bits;

    // random_accessible_vol (1 bit)

    bits = ReadSeqHeaderBits(buffer, 1, ETrue);

    iHeader.iRandomAccessibleVol = (TUint8) bits;

    // video_object_type_indication (8 bits)

    bits = ReadSeqHeaderBits(buffer, 8, ETrue);

    if (bits != 1)

        {

        // this is not a simple video object stream 

        PRINT((_L("CVedVolReader: ERROR - This is not a simple video object stream")))

        User::Leave(KErrNotSupported);

        }

    // is_object_layer_identifier (1 bit)

    bits = ReadSeqHeaderBits(buffer, 1, ETrue);

    if (bits)

        {

        // visual_object_ver_id (4 bits)

        bits = ReadSeqHeaderBits(buffer, 4, ETrue);

        if (bits != 1 && bits != 2)

            {

            // this is not an MPEG-4 version 1 or 2 stream

            PRINT((_L("CVedVolReader: ERROR - This is not an MPEG-4 version 1 or 2 stream")))

            User::Leave(KErrNotSupported);

            }

        // video_object_layer_priority (3 bits)

        bits = ReadSeqHeaderBits(buffer, 3, ETrue);

        iHeader.iVoPriority = (TInt) bits;

        } 

    // aspect_ratio_info: `0010`- 12:11 (625-type for 4:3 picture)

    bits = ReadSeqHeaderBits(buffer, 4, ETrue);

    iHeader.iPixelAspectRatio = (TInt) bits;

    // extended par 

    if (bits == 15)

        { 

        // par_width 

        bits = ReadSeqHeaderBits(buffer, 8, ETrue);

        // par_height 

        bits = ReadSeqHeaderBits(buffer, 8, ETrue);

        }

    // vol_control_parameters flag 

    bits = ReadSeqHeaderBits(buffer, 1, ETrue);

    if (bits)

        {

        // chroma_format (2 bits)

        bits = ReadSeqHeaderBits(buffer, 2, ETrue);

        if (bits != 1)

            {

            PRINT((_L("CVedVolReader: ERROR - Not supported chroma format")))

            User::Leave(KErrNotSupported);

            }

        // low_delay (1 bits)

        bits = ReadSeqHeaderBits(buffer, 1, ETrue);

        // vbv_parameters (1 bits)

        bits = ReadSeqHeaderBits(buffer, 1, ETrue);

        if (bits)

            {

            // first_half_bitrate (15 bits) 

            bits = ReadSeqHeaderBits(buffer, 15, ETrue);

            iHeader.iBitRate = (bits << 15);

            // marker_bit

            if (!ReadSeqHeaderBits(buffer, 1, ETrue))

                {

                User::Leave(KErrCorrupt);

                }

            // latter_half_bitrate (15 bits)

            bits = ReadSeqHeaderBits(buffer, 15, ETrue);

            iHeader.iBitRate += bits;

            iHeader.iBitRate *= 400;

            // marker_bit

            if (!ReadSeqHeaderBits(buffer, 1, ETrue))

                {

                User::Leave(KErrCorrupt);

                }

            // first_half_vbv_buffer_size (15 bits)

            bits = ReadSeqHeaderBits(buffer, 15, ETrue);

            iHeader.iVbvBufferSize = (bits << 3);

            // marker_bit

            if (!ReadSeqHeaderBits(buffer, 1, ETrue))

                {

                User::Leave(KErrCorrupt);

                }

            // latter_half_vbv_buffer_size (3 bits)

            bits = ReadSeqHeaderBits(buffer, 3, ETrue);

            iHeader.iVbvBufferSize += bits;

            iHeader.iVbvBufferSize *= 16384;

            // first_half_vbv_occupancy (11 bits)

            bits = ReadSeqHeaderBits(buffer, 11, ETrue);

            iHeader.iVbvOccupancy = (bits << 15);

            // marker_bit

            if (!ReadSeqHeaderBits(buffer, 1, ETrue))

                {

                User::Leave(KErrCorrupt);

                }

            // latter_half_vbv_occupancy (15 bits) 

            bits = ReadSeqHeaderBits(buffer, 15, ETrue);

            iHeader.iVbvOccupancy += bits;

            iHeader.iVbvOccupancy *= 64;

            // marker_bit

            if (!ReadSeqHeaderBits(buffer, 1, ETrue))

                {

                User::Leave(KErrCorrupt);

                }

            }

        else

            {

            useDefaultVBVParams = 1;

            }

        }     

    else

        {

        useDefaultVBVParams = 1;

        }

    // vol_shape (2 bits) 

    bits = ReadSeqHeaderBits(buffer, 2, ETrue);

    // rectangular_shape = '00'

    if (bits != 0)

        {

        PRINT((_L("CVedVolReader: ERROR - Not rectangular shape is not supported")))

        User::Leave(KErrNotSupported);

        }

    // marker_bit

    if (!ReadSeqHeaderBits(buffer, 1, ETrue))

        {

        User::Leave(KErrCorrupt);

        }

    // time_increment_resolution 

    bits = ReadSeqHeaderBits(buffer, 16, ETrue);

    iHeader.iTimeIncrementResolution = (TInt) bits;

    // marker_bit

    if (!ReadSeqHeaderBits(buffer, 1, ETrue))

        {

        User::Leave(KErrCorrupt);

        }

    // fixed_vop_rate 

    bits = ReadSeqHeaderBits(buffer, 1, ETrue);

    // fixed_vop_time_increment (1-15 bits)

    if (bits)

        {

        for (numBits = 1; ((iHeader.iTimeIncrementResolution-1) >> numBits) != 0; numBits++) 

            {

            }

        bits = ReadSeqHeaderBits(buffer, numBits, ETrue);

        }

    // marker_bit

    if (!ReadSeqHeaderBits(buffer, 1, ETrue))

        {

        User::Leave(KErrCorrupt);

        }

    // vol_width (13 bits) 

    bits = ReadSeqHeaderBits(buffer, 13, ETrue);

    iHeader.iLumWidth = (TInt) bits;

    // marker_bit

    if (!ReadSeqHeaderBits(buffer, 1, ETrue))

        {

        User::Leave(KErrCorrupt);

        }

    // vol_height (13 bits) 

    bits = ReadSeqHeaderBits(buffer, 13, ETrue);

    iHeader.iLumHeight = (TInt) bits;

    // Accept only resolutions that are divisible by 16

    if ( ((iHeader.iLumWidth & 0x0000000f) != 0) ||

        ((iHeader.iLumHeight & 0x0000000f) != 0) )

        {

        PRINT((_L("CVedVolReader: ERROR - Unsupported resolution")))

        User::Leave(KErrNotSupported);

        }

    TInt macroBlocks = iHeader.iLumWidth * iHeader.iLumHeight / (16 * 16);

    // Check that we don't have too many macro blocks (ie resolution is not too big)

    if( macroBlocks > 1200 )

        {

        PRINT((_L("CVedVolReader: ERROR - Unsupported resolution")))

        User::Leave(KErrNotSupported);

        }

    // Check that profile level id matches with the number of macro blocks

    if( macroBlocks > 396 )

        {

        // Resolution is higher than CIF => level must be 4a

        if( iHeader.iProfileLevelId != 4 )

            {

            iHeader.iProfileLevelId = 4;

            useDefaultVBVParams = 1;

            }

        }

    else if( macroBlocks > 99 )

        {

        // Resolution is higher than QCIF => level must be atleast 2

        if( iHeader.iProfileLevelId < 2 || iHeader.iProfileLevelId > 4 )

            {

            iHeader.iProfileLevelId = 3;    // QVGA/CIF @ 30fps

            useDefaultVBVParams = 1;

            }

        }

    // Set default VBV params if not set already  

    if (useDefaultVBVParams)

        {

        switch (iHeader.iProfileLevelId)

            {

            case 1:

                iHeader.iVbvBufferSize = 10;