Wavefile.cc File Reference

#include <Nsound/Nsound.h>
#include <Nsound/AudioStream.h>
#include <Nsound/Buffer.h>
#include <Nsound/Wavefile.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <fstream>
#include <iostream>
#include <sstream>

Include dependency graph for Wavefile.cc:

Go to the source code of this file.

Classes
struct	RawTag

Macros
#define	LM_UNUSED   __attribute__((unused))
#define	NOT_FOUND   -1
#define	IO_ERROR   -2
#define	MIN(a, b)   ((a < b) ? a : b)

Typedefs
typedef struct RawTag	RawTag

Functions
static int64	swapBytesInt64 (const uint64 &i)
	Endian Conversion. More...
static int64	swapBytesInt48 (const uint64 &i)
static int32	swapBytesInt32 (const uint32 i)
static int32	swapBytesInt24 (const uint32 i)
static int32	swapBytesInt16 (const uint32 i)
static int64	readInt (FILE *fd, uint32 n_bytes)
static float32	readFloat32 (FILE *fd)
static float64	readFloat64 (FILE *fd)
static void	writeInt (FILE *output, uint32 n_bytes, int64 value)
static void	writeFloat32 (FILE *output, float32 value)
static void	writeFloat64 (FILE *output, float64 value)
int64	findID3v1Tag (FILE *fin)

Macro Definition Documentation

#define LM_UNUSED   __attribute__((unused))

Definition at line 238 of file Wavefile.cc.

Referenced by readFloat32(), readFloat64(), and readInt().

#define NOT_FOUND   -1

Definition at line 1550 of file Wavefile.cc.

Referenced by findID3v1Tag(), Nsound::ID3v1Tag::read(), and Nsound::ID3v1Tag::write().

#define IO_ERROR   -2

Definition at line 1551 of file Wavefile.cc.

Referenced by findID3v1Tag(), Nsound::ID3v1Tag::read(), and Nsound::ID3v1Tag::write().

#define MIN	(		a,
			b
	)		((a < b) ? a : b)

Referenced by Nsound::ID3v1Tag::write().

Typedef Documentation

typedef struct RawTag RawTag

Function Documentation

static int64 swapBytesInt64 ( const uint64 &  i )

inlinestatic

Endian Conversion.

little endian: intel big endian: power pc, sparc

4 bytes little endian byte order: 1234 big endian byte order: 4321

3 bytes little endian byte order: 123 big endian byte order: 321

2 bytes little endian byte order: 12 big endian byte order: 21

The method below takes an int and swaps the bytes. Note that on either endian system the method will do the correct converstion. That is, a big endian value will become a little (4321 –> 1234), and a little endian becomes big (1234 –> 4321).

Definition at line 157 of file Wavefile.cc.

Referenced by readFloat64(), readInt(), writeFloat64(), and writeInt().

{
    int64 k = i;
    uint8 * c = reinterpret_cast<uint8 *>(&k);

    //    0 1 2 3 4 5 6 7
    // 0x1234567890abcdef
    uint8 t = c[0];
    c[0] = c[7];
    c[7] = t;
    t = c[1];
    c[1] = c[6];
    c[6] = t;
    t = c[2];
    c[2] = c[5];
    c[5] = t;
    t = c[3];
    c[3] = c[4];
    c[4] = t;

    return k;
};

static int64 swapBytesInt48 ( const uint64 &  i )

inlinestatic

Definition at line 182 of file Wavefile.cc.

{
    int64 k = i;
    uint8 * c = reinterpret_cast<uint8 *>(&k);

    //    0 1 2 3 4 5 6 7
    // 0x1234567890abcdef

    uint8 t = c[2];
    c[2] = c[7];
    c[7] = t;
    t = c[3];
    c[3] = c[6];
    c[6] = t;
    t = c[4];
    c[4] = c[5];
    c[5] = t;

    return k;
};

static int32 swapBytesInt32 ( const uint32  i )

inlinestatic

Definition at line 206 of file Wavefile.cc.

Referenced by readFloat32(), readFloat64(), writeFloat32(), and writeFloat64().

{
    return static_cast<int32>(((i & 0xff000000) >> 24 |
                              ((i & 0x00ff0000) >>  8 |
                              ((i & 0x0000ff00) <<  8 |
                              ((i & 0x000000ff) << 24)))));
};

static int32 swapBytesInt24 ( const uint32  i )

inlinestatic

Definition at line 216 of file Wavefile.cc.

{
    return static_cast<int32>(((i & 0x00ff0000) >> 16 |
                              ((i & 0x0000ff00)       |
                              ((i & 0x000000ff) << 16))));
};

static int32 swapBytesInt16 ( const uint32  i )

inlinestatic

Definition at line 225 of file Wavefile.cc.

{
    return static_cast<int32>(((i & 0x0000ff00) >> 8 |
                              ((i & 0x000000ff) << 8)));
};

static int64 readInt ( FILE *  fd, uint32  n_bytes  )

inlinestatic

This method reads data from the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 246 of file Wavefile.cc.

References LM_UNUSED, and swapBytesInt64().

Referenced by findID3v1Tag().

{
    int64 temp64 = 0;

    size_t _ LM_UNUSED = fread(reinterpret_cast<char*>(&temp64), n_bytes, 1, fd);

    // Swap the bytes if we are on a big endian platform.
    #ifdef NSOUND_BIG_ENDIAN
        temp64 = swapBytesInt64(temp64);
    #endif

    // Sign extend temp64.
    switch(n_bytes)
    {
        // 48-bit
        case 6:
            if(temp64   & 0x0000800000000000ULL)
            {
                temp64 |= 0xffff000000000000ULL;
            }
            break;

        // 32-bit
        case 4:
            if(temp64   & 0x0000000080000000ULL)
            {
                temp64 |= 0xffffffff00000000ULL;
            }
            break;

        // 24-bit
        case 3:
            if(temp64   & 0x0000000000800000ULL)
            {
                temp64 |= 0xffffffffff000000ULL;
            }
            break;

        // 16-bit
        case 2:
            if(temp64   & 0x0000000000008000ULL)
            {
                temp64 |= 0xffffffffffff0000ULL;
            }
            break;

        // 8 bit wavefiles are stored unsigned (silly that it's different)
        case 1:
            break;
    }

    return temp64;
}

static float32 readFloat32 ( FILE *  fd )

inlinestatic

This method reads data from the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 305 of file Wavefile.cc.

References LM_UNUSED, and swapBytesInt32().

{
    int32 temp32 = 0;
    float32 * f32 = reinterpret_cast<float32 *>(&temp32);

    size_t _ LM_UNUSED = fread(reinterpret_cast<char*>(&temp32), sizeof(float32), 1, fd);

    // Swap the bytes if we are on a big endian platform.
    #ifdef NSOUND_BIG_ENDIAN
        temp32 = swapBytesInt32(temp32);
    #endif

    return *f32;
}

static float64 readFloat64 ( FILE *  fd )

inlinestatic

This method reads data from the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 325 of file Wavefile.cc.

References LM_UNUSED, swapBytesInt32(), and swapBytesInt64().

{
    int64 temp64 = 0;
    float64 * f64 = reinterpret_cast<float64 *>(&temp64);

    size_t _ LM_UNUSED = fread(reinterpret_cast<char*>(&temp64), sizeof(float64), 1, fd);

    // Swap the bytes if we are on a big endian platform.
    #ifdef NSOUND_BIG_ENDIAN
        if(sizeof(float64) == 8) temp64 = swapBytesInt64(temp64);
        else if(sizeof(float64) == 4) temp64 = swapBytesInt32(temp64);
    #endif

    return *f64;
}

static void writeInt ( FILE *  output, uint32  n_bytes, int64  value  )

inlinestatic

This method writes data to the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 346 of file Wavefile.cc.

References swapBytesInt64().

Referenced by Nsound::Wavefile::write().

{
    // Swap the bytes if we are on a big endian platform
    #ifdef NSOUND_BIG_ENDIAN
        value = swapBytesInt64(value);
    #endif

    fwrite(reinterpret_cast<char*>(&value), n_bytes, 1, output);
}

static void writeFloat32 ( FILE *  output, float32  value  )

inlinestatic

This method writes data to the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 364 of file Wavefile.cc.

References swapBytesInt32().

Referenced by Nsound::Wavefile::write().

{
    // Swap the bytes if we are on a big endian platform
    #ifdef NSOUND_BIG_ENDIAN
        uint32 * v = reinterpret_cast<uint32 *>(&value);
        *v = swapBytesInt32(*v);
    #endif

    fwrite(reinterpret_cast<char*>(&value), 1, sizeof(float32), output);
}

static void writeFloat64 ( FILE *  output, float64  value  )

inlinestatic

This method writes data to the file and does the proper byte conversion based on the endianess of the platform.

Definition at line 382 of file Wavefile.cc.

References swapBytesInt32(), and swapBytesInt64().

Referenced by Nsound::Wavefile::write().

{
    // Swap the bytes if we are on a big endian platform
    #ifdef NSOUND_BIG_ENDIAN
        uint64 * v = reinterpret_cast<uint64 *>(&value);

        if(sizeof(float64) == 8) *v = swapBytesInt64(*v);
        else if(sizeof(float64) == 4) *v = swapBytesInt32(*v);
    #endif

    fwrite(reinterpret_cast<char*>(&value), sizeof(float64), 1, output);
}

int64 findID3v1Tag

(

FILE *

fin

)

Definition at line 1554 of file Wavefile.cc.

References Nsound::Wavefile::DATA_, IO_ERROR, M_CHECK_PTR, M_THROW, NOT_FOUND, readInt(), Nsound::Wavefile::RIFF_, and Nsound::Wavefile::WAVE_.

Referenced by Nsound::ID3v1Tag::read(), and Nsound::ID3v1Tag::write().

{
    uint32 chunk_id = 0;
    uint32 header_limit = 72 ;  // The 'data' should be near the begging
                                // of the file if it is a WAVE file.

    size_t data_length = 0;

    uint32 count = 0;

    M_CHECK_PTR(fin);
    if(fin == NULL) return IO_ERROR;

    fseek(fin, 0, SEEK_SET);

    // Verify first tag is RIFF
    chunk_id = static_cast<uint32>(readInt(fin, 4));
    count += 4;

    if(chunk_id != Wavefile::RIFF_)
    {
        M_THROW("ID3v1Tag::find(): could not read 'RIFF' from file");
        return IO_ERROR;
    }

    // Read RIFF chunk length
    chunk_id = static_cast<uint32>(readInt(fin, 4));
    count += 4;

    // Read in 'WAVE'
    chunk_id = static_cast<uint32>(readInt(fin, 4));
    count += 4;

    if(chunk_id != Wavefile::WAVE_)
    {
        M_THROW("ID3v1Tag::find(): could not read 'WAVE' from file");
        return IO_ERROR;
    }

    // Okay, we now know we are reading a RIFF WAVE file.

    // Search for the 'data' tag.
    while(count < header_limit)
    {
        chunk_id = static_cast<uint32>(readInt(fin, 4));

        count += 4;

        if(chunk_id == Wavefile::DATA_)
        {
            data_length = static_cast<uint32>(readInt(fin,4));
            break;
        }
    }

    if(count >= header_limit)
    {
        cerr << "*** Error --> ID3v1Tag::find(): did not find the 'data'"
             << endl;
        return IO_ERROR;
    }

    size_t cur_pos = ftell(fin);
    fseek(fin, 0, SEEK_END);
    size_t end_pos = ftell(fin);

    // Seek to the end of the data
    #ifdef NSOUND_PLATFORM_OS_WINDOWS
        fseek(fin, static_cast<long>(cur_pos), SEEK_SET);
        fseek(fin, static_cast<long>(data_length), SEEK_CUR);
    #else
        fseek(fin, cur_pos, SEEK_SET);
        fseek(fin, data_length, SEEK_CUR);
    #endif

    // Start scanning for 'TAG'
    cur_pos = ftell(fin);
    while(cur_pos < end_pos-2)
    {
        char t[3];

        if(3 != fread(t, 1, 3, fin))
        {
            M_THROW("ID3v1Tag::find(): IO error reading file");
            return IO_ERROR;
        }

        if(t[0] == 'T' && t[1] == 'A' && t[2] == 'G')
        {
            break;
        }

        cur_pos = ftell(fin);
    }

    // No tag.
    if(cur_pos >= end_pos)
    {
        return NOT_FOUND;
    }

    // We have the tag, back up three bytes and return position.
    fseek(fin, -3, SEEK_CUR);

    return ftell(fin);
}