seal 0.1.0

data/src/seal/mpg.h

@@ -0,0 +1,24 @@
+/*
+ * mpg.h is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ *
+ * mpg.h provides subroutines to decode MPEG 1.0, 2.0 and 2.5 audio for layers
+ * 1, 2 and 3.
+ */
+
+#ifndef _SEAL_MPG_H_
+#define _SEAL_MPG_H_
+
+#include <stddef.h>
+#include <seal/raw.h>
+#include <seal/stream.h>
+#include <seal/err.h>
+
+seal_err_t _seal_load_mpg(seal_raw_t*, const char* /*filename*/);
+seal_err_t _seal_init_mpg_stream(seal_stream_t*, const char* /*filename*/);
+seal_err_t _seal_stream_mpg(seal_stream_t*, seal_raw_t*, size_t* /*psize*/);
+seal_err_t _seal_rewind_mpg_stream(seal_stream_t*);
+seal_err_t _seal_close_mpg_stream(seal_stream_t*);
+
+#endif /* _SEAL_MPG_H_ */

data/src/seal/ov.c

@@ -0,0 +1,180 @@
+/*
+ * ov.c is part of the Scorched End Audio Library (SEAL) and is
+ * licensed under the terms of the GNU Lesser General Public License. See
+ * COPYING attached with the library.
+ */
+
+#include <stdlib.h>
+#include <vorbis/codec.h>
+#define OV_EXCLUDE_STATIC_CALLBACKS
+#include <vorbis/vorbisfile.h>
+#include <seal/raw.h>
+#include <seal/stream.h>
+#include <seal/err.h>
+#include "ov.h"
+#include "reader.h"
+
+/* Initial buffer size for loading. */
+static const int INITIAL_BUF_SIZE = 4096;
+
+static
+seal_err_t
+setup(seal_raw_attr_t* attr, OggVorbis_File* ovf, const char* filename)
+{
+    vorbis_info* vi;
+    FILE* ov;
+
+    ov = _seal_fopen(filename);
+    if (ov == 0)
+        return SEAL_CANNOT_OPEN_FILE;
+    if (ov_open(ov, ovf, 0, 0) < 0) {
+        _seal_fclose(ov);
+        return SEAL_CANNOT_OPEN_OV;
+    }
+    vi = ov_info(ovf, -1);
+    attr->bit_depth = 16;
+    attr->nchannels = vi->channels;
+    attr->freq = vi->rate;
+
+    return SEAL_OK;
+}
+
+/* Caller passes `nbytes_loaded' to be able to accumulate the value. */
+static
+long
+read(seal_raw_t* raw, unsigned long* nbytes_loaded, OggVorbis_File* ovf)
+{
+    long nbytes_read;
+    int bitstream;
+
+    nbytes_read = ov_read(ovf, (char*) raw->data + *nbytes_loaded,
+                          raw->size - *nbytes_loaded, 0, 2, 1, &bitstream);
+    *nbytes_loaded += nbytes_read;
+
+    return nbytes_read;
+}
+
+static
+seal_err_t
+load(seal_raw_t* raw, OggVorbis_File* ovf)
+{
+    long nbytes_read;
+    unsigned long nbytes_loaded = 0;
+    seal_err_t err;
+
+    if ((err = seal_alloc_raw_data(raw, INITIAL_BUF_SIZE)) != SEAL_OK)
+        return err;
+
+    do {
+        if ((err = seal_ensure_raw_data_size(raw, nbytes_loaded)) != SEAL_OK)
+            goto cleanup;
+        nbytes_read = read(raw, &nbytes_loaded, ovf);
+    } while (nbytes_read > 0);
+
+    /* If `nbytes_read' < 0 then an error occurred. */
+    if (nbytes_read < 0) {
+        err = SEAL_CANNOT_READ_OV;
+        goto cleanup;
+    }
+
+    raw->size = nbytes_loaded;
+
+    return SEAL_OK;
+
+cleanup:
+    seal_free_raw_data(raw);
+
+    return err;
+}
+
+seal_err_t
+_seal_load_ov(seal_raw_t* raw, const char* filename)
+{
+    seal_raw_t tmp_raw;
+    OggVorbis_File ovf;
+    seal_err_t err;
+
+    if ((err = setup(&tmp_raw.attr, &ovf, filename)) != SEAL_OK)
+        return err;
+
+    if ((err = load(&tmp_raw, &ovf)) == SEAL_OK)
+        *raw = tmp_raw;
+
+    /* This closes the opened file handle too. */
+    ov_clear(&ovf);
+
+    return err;
+}
+
+seal_err_t
+_seal_init_ov_stream(seal_stream_t* stream, const char* filename)
+{
+    seal_raw_attr_t attr;
+    OggVorbis_File* povf;
+    seal_err_t err;
+
+    povf = malloc(sizeof (OggVorbis_File));
+    if (povf == 0)
+        return SEAL_CANNOT_ALLOC_MEM;
+
+    if ((err = setup(&attr, povf, filename)) != SEAL_OK) {
+        free(povf);
+        return err;
+    }
+
+    stream->id = povf;
+    stream->fmt = SEAL_OV_FMT;
+    stream->attr = attr;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_stream_ov(seal_stream_t* stream, seal_raw_t* raw, size_t* psize)
+{
+    long nbytes_read;
+    unsigned long nbytes_streamed = 0;
+    seal_raw_t tmp_raw;
+    seal_err_t err;
+
+    if ((err = seal_alloc_raw_data(&tmp_raw, raw->size)) != SEAL_OK)
+        return err;
+
+    do nbytes_read = read(&tmp_raw, &nbytes_streamed, stream->id);
+    while (nbytes_streamed < tmp_raw.size && nbytes_read > 0);
+
+    if (nbytes_read < 0) {
+        err = SEAL_CANNOT_READ_OV;
+        seal_free_raw_data(&tmp_raw);
+        return err;
+    }
+
+    if (nbytes_streamed != 0) {
+        raw->data = tmp_raw.data;
+        raw->size = nbytes_streamed;
+        raw->attr = stream->attr;
+    } else {
+        seal_free_raw_data(&tmp_raw);
+    }
+    *psize = nbytes_streamed;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_rewind_ov_stream(seal_stream_t* stream)
+{
+    if (ov_time_seek(stream->id, 0) != 0)
+        return SEAL_CANNOT_REWIND_OV;
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_close_ov_stream(seal_stream_t* stream)
+{
+    if (ov_clear(stream->id) != 0)
+        return SEAL_CANNOT_CLOSE_OV;
+
+    free(stream->id);
+    return SEAL_OK;
+}

data/src/seal/ov.h

@@ -0,0 +1,22 @@
+/*
+ * ov.h is part of the Scorched End Audio Library (SEAL) and is licensed under
+ * the terms of the GNU Lesser General Public License. See COPYING attached
+ * with the library.
+ *
+ * ov.h provides subroutines to decode ogg vorbis files.
+ */
+
+#ifndef _SEAL_OV_H_
+#define _SEAL_OV_H_
+
+#include <stddef.h>
+#include <seal/raw.h>
+#include <seal/stream.h>
+
+seal_err_t _seal_load_ov(seal_raw_t*, const char* /*filename*/);
+seal_err_t _seal_init_ov_stream(seal_stream_t*, const char* /*filename*/);
+seal_err_t _seal_stream_ov(seal_stream_t*, seal_raw_t*, size_t* /*psize*/);
+seal_err_t _seal_rewind_ov_stream(seal_stream_t*);
+seal_err_t _seal_close_ov_stream(seal_stream_t*);
+
+#endif /* _SEAL_OV_H_ */

data/src/seal/raw.c

@@ -0,0 +1,59 @@
+/*
+ * raw.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <seal/raw.h>
+#include <seal/err.h>
+
+/* Reallocates `raw->data' to size `size'. */
+static
+seal_err_t
+realloc_raw_data(seal_raw_t* raw, size_t size)
+{
+    void* buf;
+
+    buf = realloc(raw->data, size);
+    if (buf == 0)
+        return SEAL_CANNOT_ALLOC_MEM;
+    raw->data = buf;
+    raw->size = size;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_alloc_raw_data(seal_raw_t* raw, size_t size)
+{
+    raw->size = size;
+    raw->data = malloc(size);
+    if (raw->data == 0)
+        return SEAL_CANNOT_ALLOC_MEM;
+
+    return SEAL_OK;
+}
+
+void
+seal_free_raw_data(seal_raw_t* raw)
+{
+    free(raw->data);
+}
+
+seal_err_t
+seal_extend_raw_data(seal_raw_t* raw)
+{
+    return realloc_raw_data(raw, raw->size * 2);
+}
+
+seal_err_t
+seal_ensure_raw_data_size(seal_raw_t* raw, size_t size)
+{
+    /* If the buffer is not large enough... */
+    if (size >= raw->size)
+        return seal_extend_raw_data(raw);
+
+    return SEAL_OK;
+}

data/src/seal/reader.c

@@ -0,0 +1,102 @@
+/*
+ * reader.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#ifdef _WIN32
+# include <Windows.h>
+#endif
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <seal/err.h>
+#include "reader.h"
+
+enum
+{
+    JUNK_BUF_SIZE = 512
+};
+
+/* Helpers that convert raw bytes to little-endian 16- and 32-bit integers. */
+static
+uint16_t
+raw2le16(uint8_t* bytes)
+{
+    return bytes[1] << 8 | bytes[0];
+}
+
+static
+uint32_t
+raw2le32(uint8_t* bytes)
+{
+    return bytes[3] << 24 | bytes[2] << 16 | raw2le16(bytes);
+}
+
+FILE*
+_seal_fopen(const char* filename)
+{
+    FILE* file;
+
+#ifdef _WIN32
+    wchar_t wfilename[260];
+    MultiByteToWideChar(CP_UTF8, 0, filename, -1, wfilename, 260);
+    file = _wfopen(wfilename, L"rb");
+#else
+    file = fopen(filename, "rb");
+#endif
+
+    return file;
+}
+
+void
+_seal_fclose(FILE* file)
+{
+    fclose(file);
+}
+
+/*
+ * A template for the following two functions. All arguments except `FILE'
+ * will have multiple evaluations in one call.
+ */
+#define READ_UINT_LE(nbits, buf, size, file) do                             \
+{                                                                           \
+    size_t _i_, count;                                                      \
+                                                                            \
+    count = fread((buf), sizeof (uint##nbits##_t), (size), (file));         \
+    for (_i_ = 0; _i_ < (size); ++_i_) {                                    \
+        *(buf) = raw2le##nbits((uint8_t*) (buf));                           \
+        ++(buf);                                                            \
+    }                                                                       \
+} while (0)
+
+void
+_seal_read_uint16le(uint16_t* buf, size_t size, void* file)
+{
+    READ_UINT_LE(16, buf, size, file);
+}
+
+void
+_seal_read_uint32le(uint32_t* buf, size_t size, void* file)
+{
+    READ_UINT_LE(32, buf, size, file);
+}
+
+/*
+ * Use of static variable avoids the overhead brought by dynamic memory
+ * allocations and deallocations. Microsoft's implementation of fseek flushes
+ * the buffer, which is evil and why fread is used here.
+ */
+void
+_seal_skip(uint32_t nbytes, void* file)
+{
+    size_t count;
+    uint32_t i;
+    static uint8_t junk[JUNK_BUF_SIZE];
+
+    for (i = JUNK_BUF_SIZE; i <= nbytes; i += JUNK_BUF_SIZE)
+        count = fread(junk, 1, JUNK_BUF_SIZE, file);
+    nbytes %= JUNK_BUF_SIZE;
+    if (nbytes > 0)
+        count = fread(junk, 1, nbytes, file);
+}

data/src/seal/reader.h

@@ -0,0 +1,59 @@
+/*
+ * reader.h is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ *
+ * reader.h provides utilities related to file input.
+ */
+
+#ifndef _SEAL_READER_H_
+#define _SEAL_READER_H_
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+
+/* Makes a 32-bit tag in little-endian. No multiple evaluations. */
+#define SEAL_MKTAG(a, b, c, d) ((a) | (b) << 8 | (c) << 16 | (d) << 24)
+
+/*
+ * Processes filename encoding and then open the file. Does not return
+ * `seal_err_t', so caller should be checking if the returned pointer is 0.
+ *
+ * @param filename  the filename to open
+ * @return          the opened file pointer
+ */
+FILE* _seal_fopen(const char* /*filename*/);
+
+/*
+ * @param file      the file pointer to close
+ */
+void _seal_fclose(FILE*);
+
+/*
+ * Reads unsigned 16-bit integers in little-endian.
+ *
+ * @param buf       the array of integers to receive the data
+ * @param size      the size of the array
+ * @param file      the file input stream
+ */
+void _seal_read_uint16le(uint16_t* /*buf*/, size_t, void* /*file*/);
+
+/*
+ * Reads unsigned 32-bit integers in little-endian.
+ *
+ * @param buf       the array of integers to receive the data
+ * @param size      the size of the array
+ * @param file      the file input stream
+ */
+void _seal_read_uint32le(uint32_t* /*buf*/, size_t, void* /*file*/);
+
+/*
+ * Skips `nbytes' bytes (seek forward).
+ *
+ * @param nbytes    the number of bytes to skip
+ * @param file      the file input stream
+ */
+void _seal_skip(uint32_t /*nbytes*/, void* /*file*/);
+
+#endif /* _SEAL_READER_H_ */