/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/**
 * This PVA_FF_AtomUtils Class contains sime useful methods for operating on Atoms
 */


#define IMPLEMENT_AtomUtils

#include "atomutils.h"
#include "a_atomdefs.h"
#include <time.h>

// **** FILE STREAM RENDERING METHODS ****

// Render the 64 bits byte by byte and take most significant byte first
bool
PVA_FF_AtomUtils::render64(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint64 data)
{
    if (fp != NULL)
    {
        for (int32 i = 0; i < 64; i += 8)
        {

            uint8 byte = (uint8)((data >> (56 - i)) & 0x000000ff);
            if (fp->_filePtr->Write(&byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the 32 bits byte by byte and take most significant byte first
bool
PVA_FF_AtomUtils::render32(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 data)
{
    if (fp != NULL)
    {
        for (int32 i = 0; i < 32; i += 8)
        {
            uint8 byte = (uint8)((data >> (24 - i)) & 0x000000ff);
            if (fp->_filePtr->Write(&byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the 24 bits byte by byte and take most significant byte first
bool
PVA_FF_AtomUtils::render24(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 data)
{
    if (fp != NULL)
    {
        for (int32 i = 0; i < 24; i += 8)
        {
            uint8 byte = (uint8)((data >> (16 - i)) & 0x0000ff);
            if (fp->_filePtr->Write(&byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the 16 bits byte by byte and take most significant byte first
bool
PVA_FF_AtomUtils::render16(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint16 data)
{
    if (fp != NULL)
    {
        for (int32 i = 0; i < 16; i += 8)
        {
            uint8 byte = (uint8)((data >> (8 - i)) & 0x00ff);
            if (fp->_filePtr->Write(&byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the 8 bits as a single byte
bool
PVA_FF_AtomUtils::render8(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint8 data)
{
    if (fp != NULL)
    {
        if (fp->_filePtr->Write(&data, 1, 1) != 1)
        {
            return false;
        }
        return true;
    }
    return false;
}

// Render the a string byte by byte
bool
PVA_FF_AtomUtils::renderString(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, PVA_FF_UTF8_STRING_PARAM data)
{
    if (fp != NULL)
    {
        uint8 byte = 0;
        for (uint32 i = 0; i < data.get_size(); i++)
        {
            byte = data[i];
            if (fp->_filePtr->Write(&byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the a string byte by byte
bool
PVA_FF_AtomUtils::renderUnicodeString(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, PVA_FF_UNICODE_STRING_PARAM data)
{
    if (fp != NULL)
    {
        OSCL_TCHAR *stringptr = (OSCL_TCHAR *)data.get_cstr();

        uint16 temp = 0;
        uint8 lower_byte = 0;
        uint8 upper_byte = 0;
        for (uint32 i = 0; i < data.get_size(); i++)
        {
            // Watch byte ordering in the stored format
            temp = (uint16)(stringptr[i] & 0xFF00);
            temp = (uint8)((temp >> 8) & 0xFF);
            lower_byte = (uint8)(temp);

            if (fp->_filePtr->Write(&lower_byte, 1, 1) != 1)
            {
                return false;
            }

            upper_byte = (uint8)(stringptr[i] & 0x00FF);
            if (fp->_filePtr->Write(&upper_byte, 1, 1) != 1)
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

// Render the a string byte by byte PLUS render the trailing \0
bool
PVA_FF_AtomUtils::renderNullTerminatedString(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, PVA_FF_UTF8_STRING_PARAM data)
{
    if (fp != NULL)
    {
        PVA_FF_AtomUtils::renderString(fp, data);
        // put the trailing 0
        uint8 byte = 0;
        if (fp->_filePtr->Write(&byte, 1, 1) != 1)
        {
            return false;
        }
        return true;
    }
    return false;
}

// Render the a string byte by byte PLUS render the trailing \0
bool
PVA_FF_AtomUtils::renderNullTerminatedUnicodeString(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, PVA_FF_UNICODE_STRING_PARAM data)
{
    if (fp != NULL)
    {
        PVA_FF_AtomUtils::renderUnicodeString(fp, data);
        // Need two bytes of zeros for UNICODE null termination
        uint16 data = 0;
        if (fp->_filePtr->Write(&data, 2, 1) != 1)
        {
            return false;
        }
        return true;
    }
    return false;
}

// Render a chunk of uint8 data
bool
PVA_FF_AtomUtils::renderByteData(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 length, uint8 *data)
{
    bool retVal = true;

    if (fp != NULL)
    {
        if (fp->_filePtr->Write(data, 1, length) != length)
        {
            retVal = false;
        }
    }
    else
    {
        retVal = false;
    }

    return (retVal);
}

// Setting the current time value - seconds since 1/1/1904
void
PVA_FF_AtomUtils::setTime(uint32 &ulTime)
{
    // 2082844800 is number of seconds from Jan 1, 1904 to Jan 1, 1970.
    // time() returns the seconds since Jan 1, 1970.
    ulTime = uint32(time(NULL) + 2082844800 );
}


uint32
PVA_FF_AtomUtils::getNumberOfBytesUsedToStoreContent(uint32 sizeOfClass)
{
    // The content in a descriptor class fp stored immediately after the descriptor tag
    if (sizeOfClass <= 0x7f) return sizeOfClass - 2; // _sizeOfClass field fp 1 byte (7 LS bits)
    else if (sizeOfClass <= 0x3fff) return sizeOfClass - 3; // _sizeOfClass fp 2 bytes (7 LS bits each)
    else if (sizeOfClass <= 0x1fffff) return sizeOfClass - 4; // _sizeOfClass fp 3 bytes (7 LS bits each)
    else if (sizeOfClass <= 0x0fffffff) return sizeOfClass - 5; // _sizeOfClass fp 4 bytes (7 LS bits each)
    else return 0; // ERROR condition
}

uint32
PVA_FF_AtomUtils::getNumberOfBytesUsedToStoreSizeOfClass(uint32 contentSize)
{
    // The actual _sizeOfClass value includes the size of the class's contents PLUS
    // the number of bytes needed to store the _sizeOfClass field. The parameter
    // contentSize represents the number of bytes needed to store ONLY the members
    // of the class NOT including the _sizeOfClass field.
    if (contentSize <= 0x7e) return 1; // _sizeOfClass field can be rendered in 1 byte (7 LS bits)
    else if (contentSize <= 0x3ffd) return 2; // _sizeOfClass field can be rendered in 2 bytes (7 LS bits each)
    else if (contentSize <= 0x1ffffc) return 3; // _sizeOfClass field can be rendered in 3 bytes (7 LS bits each)
    else if (contentSize <= 0xfffffffb) return 4; // _sizeOfClass field can be rendered in 4 bytes (7 LS bits each)
    else return 0; // ERROR condition
}

void PVA_FF_AtomUtils::seekFromCurrPos(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 n)
{
    fp->_filePtr->Seek(n, Oscl_File::SEEKCUR);
}

void PVA_FF_AtomUtils::seekFromStart(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 n)
{
    fp->_filePtr->Seek(n, Oscl_File::SEEKSET);
}

void PVA_FF_AtomUtils::seekToEnd(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
    fp->_filePtr->Seek(0, Oscl_File::SEEKEND);
}

void PVA_FF_AtomUtils::rewindFilePointerByN(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 n)
{
    fp->_filePtr->Seek((-1 *(int32) n), Oscl_File::SEEKCUR);
}

int32 PVA_FF_AtomUtils::getCurrentFilePosition(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
    return (fp->_filePtr->Tell());
}

bool
PVA_FF_AtomUtils::openFile(MP4_AUTHOR_FF_FILE_IO_WRAP *fp,
                           PVA_FF_UNICODE_STRING_PARAM fileName,
                           int32 mode, uint32 aCacheSize)
{
    if (!fp->_filePtr)
    {
        // Only need to create new file object if it's not passed in from createMp4File
        //fp->_filePtr = OSCL_NEW(Oscl_File, ());
        PV_MP4_FF_NEW(fp->auditCB, Oscl_File, (), fp->_filePtr);
    }

    if (fp->_osclFileServerSession->Connect() != 0)
        return false;

    fp->_filePtr->SetPVCacheSize(aCacheSize);
    return (fp->_filePtr->Open(fileName.get_cstr(), mode, *(fp->_osclFileServerSession)) == 0);
}

void
PVA_FF_AtomUtils::closeFile(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
    fp->_filePtr->Close();
    //OSCL_DELETE(fp->_filePtr);
    PV_MP4_FF_DELETE(NULL, Oscl_File, fp->_filePtr);

    fp->_filePtr = NULL;
}

void PVA_FF_AtomUtils::closeFileSession(Oscl_FileServer* fs)
{
    if (fs)
        fs->Close();
}

bool
PVA_FF_AtomUtils::readByteData(MP4_AUTHOR_FF_FILE_IO_WRAP *fp, uint32 length, uint8 *data)
{
    uint32 bytesRead;
    bytesRead = fp->_filePtr->Read(data, 1, length);

    if (bytesRead < (uint32)length) // read byte data failed
        return false;
    return true;
}