sample.cpp

Go to the documentation of this file.

/* $Id: sample.cpp 191 2005-08-05 00:55:59Z tapted $ $URL: svn+ssh://pc-g33-9.it.usyd.edu.au/var/svn/pub/taptaudio/trunk/src/sample.cpp $ */
#include "sample.h"

/**\file sample.cpp
 * Implementation of the ASSample classes
 * \author Trent Apted <tapted@it.usyd.edu.au>
 * $Revision: 191 $
 * $Date: 2005-08-05 10:55:59 +1000 (Fri, 05 Aug 2005) $
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>

#include "sndfile.h"

template <>
    sf_count_t lsf_read(SNDFILE *sndfile, short* data, sf_count_t items) {
        return sf_read_short(sndfile, data, items);
    }
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, int* data, sf_count_t items) {
        return sf_read_int(sndfile, data, items);
    }
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, float* data, sf_count_t items) {
        return sf_read_float(sndfile, data, items);
    }
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, double* data, sf_count_t items) {
        return sf_read_double(sndfile, data, items);
    }

Recording::Recording(unsigned long initial_size,
                     unsigned chans,
                     AUDIO_FORMAT format,
                     double samplerate)
    :
    reserved(initial_size)
{
    data = new Uint8[reserved];
    channels = chans;
    bytes_size = 0;
    rate = samplerate;
    fmt = format;
}
Recording::~Recording() {
    delete[] static_cast<Uint8*>(data);
    data = 0;
}

void Recording::fill(const void *more, unsigned long sz) {
    if (bytes_size + sz > reserved) {
        memcpy(static_cast<Uint8*>(data) + bytes_size, more, reserved-bytes_size);
        bytes_size = reserved;
    } else {
        memcpy(static_cast<Uint8*>(data) + bytes_size, more, sz);
        bytes_size += sz;
    }
}

void Recording::skipfill(const void *more, unsigned long sz, unsigned block) {
    sz /= 2;
    unsigned long szavail = bytes_size + sz > reserved ? reserved - bytes_size : sz;
    unsigned long nblocks = szavail / block;
    DODEBUG(INTERRUPT, ("[At] At skipfill(more = %p, sz = %lu, block = %u), szavail = %lu, nblocks = %lu",
                        more, sz, block, szavail, nblocks));
    Uint8 *to = static_cast<Uint8*>(data) + bytes_size;
    const Uint8 *from = static_cast<const Uint8*>(more);
    for (unsigned b = 0; b < nblocks; ++b) {
        memcpy(to, from, block);
        to += block;
        from += 2*block;
    }
    bytes_size += szavail;
}

void Recording::trim() {
    if (reserved > bytes_size) {
        void* new_buf = new Uint8[bytes_size];
        memcpy(new_buf, data, bytes_size);
        delete[] static_cast<Uint8*>(data);
        data = new_buf;
    }
}

void Recording::fillSilence(unsigned long sz) {
    if (bytes_size + sz > reserved) {
        memset(static_cast<Uint8*>(data) + bytes_size, 0, reserved-bytes_size);
        bytes_size = reserved;
    } else {
        memset(static_cast<Uint8*>(data) + bytes_size, 0, sz);
        bytes_size += sz;
    }
}

void Recording::append(void *more, unsigned long sz) {
    if (bytes_size + sz > reserved) {
        do {
            reserved <<= 1;
        } while (bytes_size + sz > reserved);
        void* new_buf = new Uint8[reserved];
        memcpy(new_buf, data, bytes_size);
        delete[] static_cast<Uint8*>(data);
        data = new_buf;
    }
    memcpy(static_cast<Uint8*>(data) + bytes_size, more, sz);
    bytes_size += sz;
}

void PCMSample::mono2stereo(void *newdata,
                            const void *olddata,
                            unsigned long olddata_bytes,
                            unsigned oldframesize) {
    for (unsigned long i = 0; i < olddata_bytes; i += oldframesize) {
        memcpy(static_cast<Uint8*>(newdata) + 2*i,
               static_cast<const Uint8*>(olddata) + i, oldframesize);
        memcpy(static_cast<Uint8*>(newdata) + 2*i + oldframesize,
               static_cast<const Uint8*>(olddata) + i, oldframesize);
    }
//        for (unsigned b = 0; b < oldframesize; ++b)
//            newdata[2*i + b + oldframesize] = newdata[2*i + b] = olddata[i + b];
}

    /* hmmmm this is very dodgy... we don't use this at the moment */
void PCMSample::stereo2mono(Uint8 *newdata,
                            const Uint8 *olddata,
                            unsigned long olddata_bytes,
                            unsigned framesize) {
    for (unsigned long i = 0; i < olddata_bytes/2; i += framesize) {
        unsigned long accum[2] = {0, 0}; //unsigned long long??
        for (unsigned b = 0; b < framesize; ++b) {
            accum[0] = (accum[0] << 8) + olddata[2*i + b];
            accum[1] = (accum[1] << 8) + olddata[2*i + b + framesize];
        }
        accum[0] =  static_cast<unsigned long>((0.5 + accum[0] + accum[1]) / 2.0);
        for (unsigned b = 0; b < framesize; ++b) {
            newdata[i + framesize - b] = accum[0] & 0xff;
            accum[0] = accum[0] >> 8 & 0x00ffffff;
        }
    }
}

void FileSample::load_sndfile(SNDFILE* sf, SF_INFO &sfinfo, bool forcestereo) {
    unsigned  sz = 0;
    switch (sfinfo.format & SF_FORMAT_SUBMASK) {
        //case SF_FORMAT_DOUBLE: sz = 4;
    case SF_FORMAT_FLOAT:
    case SF_FORMAT_PCM_32: sz++;
    /*case SF_FORMAT_PCM_24:*/ sz++;
    case SF_FORMAT_PCM_16: sz++;
    case SF_FORMAT_PCM_S8:
        /*case SF_FORMAT_PCM_U8:*/ sz++;
    }
    if (sz == 0) {
        throw "Unsupported";
    }

    unsigned frame_sz = sz * sfinfo.channels;
    channels = sfinfo.channels;
    bytes_size = frame_sz * sfinfo.frames;
    rate = sfinfo.samplerate;
    data = new Uint8[bytes_size];

    sf_count_t numread = 0;

    switch (sfinfo.format & SF_FORMAT_SUBMASK) {
    case SF_FORMAT_FLOAT:
        numread = sf_readf_float(sf, static_cast<float*>(data), sfinfo.frames);
        fmt = AF_Float32;
        break;
    case SF_FORMAT_PCM_32:
        numread = sf_readf_int(sf, static_cast<int*>(data), sfinfo.frames);
        fmt = AF_Int32;
        break;
    case SF_FORMAT_PCM_16:
        numread = sf_readf_short(sf, static_cast<short*>(data), sfinfo.frames);
        fmt = AF_Int16;
        break;
    case SF_FORMAT_PCM_S8:
        numread = sf_read_raw(sf, data, bytes_size);
        fmt = AF_Int8;
    }

    if (channels == 1 && forcestereo) {
        Uint8 *newdata = new Uint8[bytes_size * 2];
        mono2stereo(newdata, data, bytes_size, sz);
        delete[] static_cast<Uint8*>(data);
        data = newdata;
        bytes_size *= 2;
        channels = 2;
    }
}

FileSample::FileSample(const std::string &path, bool forcestereo) {
    SF_INFO sfinfo;
    SNDFILE* sf = sf_open(path.c_str(), SFM_READ, &sfinfo);
    if (sf) {
        try {
            load_sndfile(sf, sfinfo, forcestereo);
        } catch (...) {
            DODEBUG(ERROR, ("[Ae] Unsupported file format in %s\n",
                            path.c_str()));
            sf_close(sf);
            throw;
        }
        sf_close(sf);
    } else {
        DODEBUG(ERROR, ("[Ae] Unable to open %s: %s\n",
                        path.c_str(), sf_strerror(sf)));
        throw "Unable to open file";
    }
}

FileSample::~FileSample() {
    delete[] static_cast<Uint8*>(data);
    data = 0;
}

bool Recording::save(const std::string &path) {
    SNDFILE *sf = 0;
    SF_INFO sfinfo = {0, static_cast<int>(rate), channels, SF_FORMAT_WAV | SF_ENDIAN_FILE, 1, 0};
    sf_count_t numwritten = 0;
    switch (fmt) {
    case AF_Float32:
        sfinfo.frames = bytes_size / (4 * channels);
        sfinfo.format |= SF_FORMAT_FLOAT;
        if ((sf = sf_open(path.c_str(), SFM_WRITE, &sfinfo)))
            numwritten = sf_writef_float(sf, static_cast<float*>(data), bytes_size / (4*channels));
        break;
    case AF_Int32:
        sfinfo.frames = bytes_size / (4 * channels);
        sfinfo.format |= SF_FORMAT_PCM_32;
        if ((sf = sf_open(path.c_str(), SFM_WRITE, &sfinfo)))
            numwritten = sf_writef_int(sf, static_cast<int*>(data), bytes_size / (4*channels));
        break;
    case AF_Int16:
        sfinfo.frames = bytes_size / (2 * channels);
        sfinfo.format |= SF_FORMAT_PCM_16;
        if ((sf = sf_open(path.c_str(), SFM_WRITE, &sfinfo)))
            numwritten = sf_writef_short(sf, static_cast<short*>(data), bytes_size / (2 * channels));
        break;
    case AF_Int8:
        sfinfo.frames = bytes_size / 1;
        sfinfo.format |= SF_FORMAT_PCM_S8;
        if ((sf = sf_open(path.c_str(), SFM_WRITE, &sfinfo)))
            numwritten = sf_write_raw(sf, data, bytes_size);
        break;
    default:
        break;
    }
    if (numwritten == 0)
        sf_perror(sf);

    if (sf)
        sf_close(sf);

    return numwritten > 0;
}

---