fileformats/mp3/parser/src/mp3fileio.cpp

/* ------------------------------------------------------------------
 * 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.
 * -------------------------------------------------------------------
 */
// -*- c++ -*-
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//                           M P 3   F I L E   I O

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


/**
 *  @file mp3fileio.cpp
 *  @brief This include file contains the implementation of the MP3 file
 *  IO utility functions.
 */

//----------------------------------------------------------------------
// Defines
//----------------------------------------------------------------------
#define IMPLEMENT_MP3FileIO

//----------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------
#include "mp3fileio.h"
#include "oscl_utf8conv.h"


//----------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Global Constant Definitions
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Global Data Definitions
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Static Variable Definitions
//----------------------------------------------------------------------

/*======================================================================
FUNCTION:     **** FILE POINTER READING METHODS

DESCRIPTION:

INPUT/OUTPUT PARAMETERS:

RETURN VALUE:

SIDE EFFECTS:

======================================================================*/

// Read in the 64 bits byte by byte and take most significant byte first
bool MP3FileIO::read64(PVFile *fp, uint64 &data)
{
    const int32 N = 8;
    uint8 bytes[N];
    data = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    for (int32 i = 0; i < N; i++)
    {
        // data = (data<<8) | bytes[i];
    }

    return true;
}

// Read in the 32 bits byte by byte and take most significant byte first
bool MP3FileIO::read32(PVFile *fp, uint32 &data)
{
    const int32 N = 4;
    uint8 bytes[N];
    data = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    for (int32 i = 0; i < N; i++)
        data = (data << 8) | bytes[i];

    return true;
}

// Read in the 32 bits byte by byte and take most significant byte first.
// This is equivalent to two read32 calls.
bool MP3FileIO::read32read32(PVFile *fp, uint32 &data1, uint32 &data2)
{
    const int32 N = 8;
    uint8 bytes[N];
    data1 = 0;
    data2 = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    int32 i;
    for (i = 0; i < 4; i++)
        data1 = (data1 << 8) | bytes[i];

    for (i = 4; i < 8; i++)
        data2 = (data2 << 8) | bytes[i];

    return true;
}

// Read in the 24 bits byte by byte and take most significant byte first
bool MP3FileIO::read24(PVFile *fp, uint32 &data)
{
    const int32 N = 3;
    uint8 bytes[N];
    data = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    for (int32 i = 0; i < N; i++)
        data = (data << 8) | bytes[i];

    return true;
}

// Read in the 16 bits byte by byte and take most significant byte first
bool MP3FileIO::read16(PVFile *fp, uint16 &data)
{
    const int32 N = 2;
    uint8 bytes[N];
    data = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    for (int32 i = 0; i < N; i++)
        data = (uint16)((data << 8) | (uint16)bytes[i]);

    return true;
}

// Read in the 16 bits byte by byte and take most significant byte first
// This is equivalent to two read16 calls
bool MP3FileIO::read16read16(PVFile *fp, uint16 &data1, uint16 &data2)
{
    const int32 N = 4;
    uint8 bytes[N];
    data1 = 0;
    data2 = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    int32 i;
    for (i = 0; i < 2; i++)
        data1 = (uint16)((data1 << 8) | (uint16) bytes[i]);

    for (i = 2; i < 4; i++)
        data2 = (uint16)((data2 << 8) | (uint16) bytes[i]);

    return true;
}

// Read in the 8 bit byte
bool MP3FileIO::read8(PVFile *fp, uint8 &data)
{
    data = 0;

    int32 retVal = (int32)(fp->Read((void*) & data, 1, 1));

    if (retVal < 1)
        return false;

    /*
    int8 byte;
    is.get(byte);
    data = (uint8)byte;
    */
    return true;
}

// Read in the 8 bit byte
// This is equivalent to two read8 calls
bool MP3FileIO::read8read8(PVFile *fp, uint8 &data1, uint8 &data2)
{
    const int32 N = 2;
    uint8 bytes[N];
    data1 = 0;
    data2 = 0;

    int32 retVal = (int32)(fp->Read((void*)bytes, 1, N));

    if (retVal < N)
        return false;

    data1 = bytes[0];
    data2 = bytes[1];

    return true;
}

// Read in byte data and take most significant byte first
bool MP3FileIO::readByteData(PVFile *fp, uint32 length, uint8 *data, uint32 *numbytes)
{
    uint32 bytesRead;
    bytesRead = fp->Read(data, 1, length);

    if (numbytes)
        *numbytes = bytesRead;

    if (bytesRead < (uint32)length) // read byte data failed
    {
        int32 seekback = 0;
        // bytes to seek backwards
        seekback -= (int32) bytesRead;
        fp->Seek(seekback, Oscl_File::SEEKCUR);
        return false;
    }

    return true;
}

// Peeks and returns the next Nth tag (32 bits) from the file
uint32 MP3FileIO::peekNextNthBytes(PVFile *fp, int32 n)
{
    uint32 tag = 0;
    for (int32 i = 0; i < n; i++)
    {
        MP3FileIO::read32(fp, tag);
    }
    fp->Seek(-4*n, Oscl_File::SEEKCUR);
    return tag;
}

// Peeks and returns the next Nth bytes (8 bits) from the file
uint8 MP3FileIO::peekNextByte(PVFile *fp)
{
    uint8 tag = 0;
    MP3FileIO::read8(fp, tag);

    fp->Seek(-1, Oscl_File::SEEKCUR);

    return tag;
}

// Returns the content length if known
// return 0 if unknown
uint32 MP3FileIO::getContentLength(PVFile *fp)
{
    return fp->GetContentLength();
}