sndfile2k.h

Go to the documentation of this file.

/*
** Copyright (C) 1999-2016 Erik de Castro Lopo <erikd@mega-nerd.com>
** Copyright (C) 2017 evpobr <evpobr@gmail.com>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU Lesser General Public License as published by
** the Free Software Foundation; either version 2.1 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#pragma once

#ifndef SNDFILE2K_H
#define SNDFILE2K_H

/* This is the version 1.0.X header file. */
#define SNDFILE_1

#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef enum SF_FORMAT
{
    // Major formats.

    SF_FORMAT_WAV = 0x010000,
    SF_FORMAT_AIFF = 0x020000,
    SF_FORMAT_AU = 0x030000,
    SF_FORMAT_RAW = 0x040000,
    SF_FORMAT_PAF = 0x050000,
    SF_FORMAT_SVX = 0x060000,
    SF_FORMAT_NIST = 0x070000,
    SF_FORMAT_VOC = 0x080000,
    SF_FORMAT_IRCAM = 0x0A0000,
    SF_FORMAT_W64 = 0x0B0000,
    SF_FORMAT_MAT4 = 0x0C0000,
    SF_FORMAT_MAT5 = 0x0D0000,
    SF_FORMAT_PVF = 0x0E0000,
    SF_FORMAT_XI = 0x0F0000,
    SF_FORMAT_HTK = 0x100000,
    SF_FORMAT_SDS = 0x110000,
    SF_FORMAT_AVR = 0x120000,
    SF_FORMAT_WAVEX = 0x130000,
    SF_FORMAT_SD2 = 0x160000,
    SF_FORMAT_FLAC = 0x170000,
    SF_FORMAT_CAF = 0x180000,
    SF_FORMAT_WVE = 0x190000,
    SF_FORMAT_OGG = 0x200000,
    SF_FORMAT_MPC2K = 0x210000,
    SF_FORMAT_RF64 = 0x220000,

    // Subtypes from here on

    SF_FORMAT_PCM_S8 = 0x0001,
    SF_FORMAT_PCM_16 = 0x0002,
    SF_FORMAT_PCM_24 = 0x0003,
    SF_FORMAT_PCM_32 = 0x0004,
    SF_FORMAT_PCM_U8 = 0x0005,
    SF_FORMAT_FLOAT = 0x0006,
    SF_FORMAT_DOUBLE = 0x0007,
    SF_FORMAT_ULAW = 0x0010,
    SF_FORMAT_ALAW = 0x0011,
    SF_FORMAT_IMA_ADPCM = 0x0012,
    SF_FORMAT_MS_ADPCM = 0x0013,
    SF_FORMAT_GSM610 = 0x0020,
    SF_FORMAT_VOX_ADPCM = 0x0021,
    SF_FORMAT_NMS_ADPCM_16 = 0x0022,
    SF_FORMAT_NMS_ADPCM_24 = 0x0023,
    SF_FORMAT_NMS_ADPCM_32 = 0x0024,
    SF_FORMAT_G721_32 = 0x0030,
    SF_FORMAT_G723_24 = 0x0031,
    SF_FORMAT_G723_40 = 0x0032,
    SF_FORMAT_DWVW_12 = 0x0040,
    SF_FORMAT_DWVW_16 = 0x0041,
    SF_FORMAT_DWVW_24 = 0x0042,
    SF_FORMAT_DWVW_N = 0x0043,
    SF_FORMAT_DPCM_8 = 0x0050,
    SF_FORMAT_DPCM_16 = 0x0051,
    SF_FORMAT_VORBIS = 0x0060,
    SF_FORMAT_ALAC_16 = 0x0070,
    SF_FORMAT_ALAC_20 = 0x0071,
    SF_FORMAT_ALAC_24 = 0x0072,
    SF_FORMAT_ALAC_32 = 0x0073,

    // Endian-ness options

    SF_ENDIAN_FILE = 0x00000000,
    SF_ENDIAN_LITTLE = 0x10000000,
    SF_ENDIAN_BIG = 0x20000000,
    SF_ENDIAN_CPU = 0x30000000,
    SF_FORMAT_SUBMASK = 0x0000FFFF,
    SF_FORMAT_TYPEMASK = 0x0FFF0000,
    SF_FORMAT_ENDMASK = 0xF0000000
} SF_FORMAT;

typedef enum SF_COMMAND
{
    SFC_GET_LIB_VERSION = 0x1000,

    SFC_GET_LOG_INFO = 0x1001,

    SFC_GET_CURRENT_SF_INFO = 0x1002,

    SFC_GET_NORM_DOUBLE = 0x1010,

    SFC_GET_NORM_FLOAT = 0x1011,

    SFC_SET_NORM_DOUBLE = 0x1012,

    SFC_SET_NORM_FLOAT = 0x1013,

    SFC_SET_SCALE_FLOAT_INT_READ = 0x1014,

    SFC_SET_SCALE_INT_FLOAT_WRITE = 0x1015,

    SFC_GET_SIMPLE_FORMAT_COUNT = 0x1020,

    SFC_GET_SIMPLE_FORMAT = 0x1021,

    SFC_GET_FORMAT_INFO = 0x1028,

    SFC_GET_FORMAT_MAJOR_COUNT = 0x1030,

    SFC_GET_FORMAT_MAJOR = 0x1031,

    SFC_GET_FORMAT_SUBTYPE_COUNT = 0x1032,

    SFC_GET_FORMAT_SUBTYPE = 0x1033,

    SFC_CALC_SIGNAL_MAX = 0x1040,

    SFC_CALC_NORM_SIGNAL_MAX = 0x1041,

    SFC_CALC_MAX_ALL_CHANNELS = 0x1042,

    SFC_CALC_NORM_MAX_ALL_CHANNELS = 0x1043,

    SFC_GET_SIGNAL_MAX = 0x1044,

    SFC_GET_MAX_ALL_CHANNELS = 0x1045,

    SFC_SET_ADD_PEAK_CHUNK = 0x1050,

    SFC_SET_ADD_HEADER_PAD_CHUNK = 0x1051,

    SFC_UPDATE_HEADER_NOW = 0x1060,

    SFC_SET_UPDATE_HEADER_AUTO = 0x1061,

    SFC_FILE_TRUNCATE = 0x1080,

    SFC_SET_RAW_START_OFFSET = 0x1090,

    SFC_SET_DITHER_ON_WRITE = 0x10A0,

    SFC_SET_DITHER_ON_READ = 0x10A1,

    SFC_GET_DITHER_INFO_COUNT = 0x10A2,

    SFC_GET_DITHER_INFO = 0x10A3,

    SFC_GET_EMBED_FILE_INFO = 0x10B0,

    SFC_SET_CLIPPING = 0x10C0,

    SFC_GET_CLIPPING = 0x10C1,

    SFC_GET_CUE_COUNT = 0x10CD,

    SFC_GET_CUE = 0x10CE,
    SFC_SET_CUE = 0x10CF,

    SFC_GET_INSTRUMENT = 0x10D0,
    SFC_SET_INSTRUMENT = 0x10D1,

    SFC_GET_LOOP_INFO = 0x10E0,

    SFC_GET_BROADCAST_INFO = 0x10F0,
    SFC_SET_BROADCAST_INFO = 0x10F1,

    SFC_GET_CHANNEL_MAP_INFO = 0x1100,
    SFC_SET_CHANNEL_MAP_INFO = 0x1101,

    SFC_RAW_DATA_NEEDS_ENDSWAP = 0x1110,

    // Support for Wavex Ambisonics Format

    SFC_WAVEX_SET_AMBISONIC = 0x1200,
    SFC_WAVEX_GET_AMBISONIC = 0x1201,

    SFC_RF64_AUTO_DOWNGRADE = 0x1210,

    SFC_SET_VBR_ENCODING_QUALITY = 0x1300,
    SFC_SET_COMPRESSION_LEVEL = 0x1301,

    SFC_SET_CART_INFO = 0x1400,
    SFC_GET_CART_INFO = 0x1401,

    SFC_TEST_IEEE_FLOAT_REPLACE = 0x6001,

    SFC_SET_ADD_DITHER_ON_WRITE = 0x1070,
    SFC_SET_ADD_DITHER_ON_READ = 0x1071
} SF_COMMAND;

typedef enum SF_STR_FIELD
{
    SF_STR_TITLE = 0x01,
    SF_STR_COPYRIGHT = 0x02,
    SF_STR_SOFTWARE = 0x03,
    SF_STR_ARTIST = 0x04,
    SF_STR_COMMENT = 0x05,
    SF_STR_DATE = 0x06,
    SF_STR_ALBUM = 0x07,
    SF_STR_LICENSE = 0x08,
    SF_STR_TRACKNUMBER = 0x09,
    SF_STR_GENRE = 0x10
} SF_STR_FIELD;

#define SF_STR_FIRST SF_STR_TITLE

#define SF_STR_LAST SF_STR_GENRE

typedef enum SF_BOOL
{
    SF_FALSE = 0,
    SF_TRUE = 1,
} SF_BOOL;

typedef enum SF_FILEMODE
{
    SFM_READ = 0x10,
    SFM_WRITE = 0x20,
    SFM_RDWR = 0x30,
} SF_FILEMODE;

typedef enum SF_AMBISONIC_MODE
{
    SF_AMBISONIC_NONE = 0x40,
    SF_AMBISONIC_B_FORMAT = 0x41
} SF_AMBISONIC_MODE;

typedef enum SF_ERR
{
    SF_ERR_NO_ERROR = 0,
    SF_ERR_UNRECOGNISED_FORMAT = 1,
    SF_ERR_SYSTEM = 2,
    SF_ERR_MALFORMED_FILE = 3,
    SF_ERR_UNSUPPORTED_ENCODING = 4
} SF_ERR;

typedef enum SF_CHANNEL_MAP
{
    SF_CHANNEL_MAP_INVALID = 0,
    SF_CHANNEL_MAP_MONO = 1,
    SF_CHANNEL_MAP_LEFT,
    SF_CHANNEL_MAP_RIGHT,
    SF_CHANNEL_MAP_CENTER,
    SF_CHANNEL_MAP_FRONT_LEFT,
    SF_CHANNEL_MAP_FRONT_RIGHT,
    SF_CHANNEL_MAP_FRONT_CENTER,
    SF_CHANNEL_MAP_REAR_CENTER,
    SF_CHANNEL_MAP_REAR_LEFT,
    SF_CHANNEL_MAP_REAR_RIGHT,
    SF_CHANNEL_MAP_LFE,
    SF_CHANNEL_MAP_FRONT_LEFT_OF_CENTER,
    SF_CHANNEL_MAP_FRONT_RIGHT_OF_CENTER,
    SF_CHANNEL_MAP_SIDE_LEFT,
    SF_CHANNEL_MAP_SIDE_RIGHT,
    SF_CHANNEL_MAP_TOP_CENTER,
    SF_CHANNEL_MAP_TOP_FRONT_LEFT,
    SF_CHANNEL_MAP_TOP_FRONT_RIGHT,
    SF_CHANNEL_MAP_TOP_FRONT_CENTER,
    SF_CHANNEL_MAP_TOP_REAR_LEFT,
    SF_CHANNEL_MAP_TOP_REAR_RIGHT,
    SF_CHANNEL_MAP_TOP_REAR_CENTER,

    SF_CHANNEL_MAP_AMBISONIC_B_W,
    SF_CHANNEL_MAP_AMBISONIC_B_X,
    SF_CHANNEL_MAP_AMBISONIC_B_Y,
    SF_CHANNEL_MAP_AMBISONIC_B_Z,

    SF_CHANNEL_MAP_MAX
} SF_CHANNEL_MAP;

typedef struct sf_private_tag SNDFILE;

typedef int64_t sf_count_t;

#define SF_COUNT_MAX INT64_MAX

typedef struct SF_INFO
{
    sf_count_t frames;
    int samplerate;
    int channels;
    int format;
    int sections;
    int seekable;
} SF_INFO;

typedef struct SF_FORMAT_INFO
{
    int format;
    const char *name;
    const char *extension;
} SF_FORMAT_INFO;

typedef enum SF_DITHER_TYPE
{
    SFD_DEFAULT_LEVEL = 0,
    SFD_CUSTOM_LEVEL = 0x40000000,

    SFD_NO_DITHER = 500,
    SFD_WHITE = 501,
    SFD_TRIANGULAR_PDF = 502
} SF_DITHER_TYPE;

typedef struct SF_DITHER_INFO
{
    int type;
    double level;
    const char *name;
} SF_DITHER_INFO;

typedef struct SF_EMBED_FILE_INFO
{
    sf_count_t offset;
    sf_count_t length;
} SF_EMBED_FILE_INFO;

typedef struct SF_CUE_POINT
{
    int32_t indx;
    uint32_t position;
    int32_t fcc_chunk;
    int32_t chunk_start;
    int32_t block_start;
    uint32_t sample_offset;
    char name[256];
} SF_CUE_POINT;

#define SF_CUES_VAR(count)              \
    struct                              \
    {                                   \
        uint32_t cue_count;             \
        SF_CUE_POINT cue_points[count]; \
    }

typedef SF_CUES_VAR(100) SF_CUES;

typedef enum SF_LOOP_MODE
{
    SF_LOOP_NONE = 800,
    SF_LOOP_FORWARD,
    SF_LOOP_BACKWARD,
    SF_LOOP_ALTERNATING
} SF_LOOP_MODE;

typedef struct SF_INSTRUMENT
{
    int gain;
    char basenote, detune;
    char velocity_lo, velocity_hi;
    char key_lo, key_hi;
    int loop_count;

    struct
    {
        int mode;
        uint32_t start;
        uint32_t end;
        uint32_t count;
    } loops[16]; // make variable in a sensible way
} SF_INSTRUMENT;

typedef struct SF_LOOP_INFO
{
    short time_sig_num; // any positive integer    > 0
    short time_sig_den; // any positive power of 2 > 0
    int loop_mode; // see SF_LOOP enum

    /* 
     * this is NOT the amount of quarter notes !!!
     * a full bar of 4/4 is 4 beats
     * a full bar of 7/8 is 7 beats
     */
    int num_beats;

    /*
     * suggestion, as it can be calculated using other fields:
     * file's length, file's sampleRate and our time_sig_den
     * -> bpms are always the amount of _quarter notes_ per minute
     */
    float bpm;

    int root_key; // MIDI note, or -1 for None
    int future[6];
} SF_LOOP_INFO;

/* Struct used to retrieve broadcast (EBU) information from a file.
 *
 * Strongly (!) based on EBU "bext" chunk format used in Broadcast WAVE.
 *
 * @deprecated This feature and will be removed in next major release.
 *
 */
#define SF_BROADCAST_INFO_VAR(coding_hist_size) \
    struct                                      \
    {                                           \
        char description[256];                  \
        char originator[32];                    \
        char originator_reference[32];          \
        char origination_date[10];              \
        char origination_time[8];               \
        uint32_t time_reference_low;            \
        uint32_t time_reference_high;           \
        short version;                          \
        char umid[64];                          \
        char reserved[190];                     \
        uint32_t coding_history_size;           \
        char coding_history[coding_hist_size];  \
    }

typedef SF_BROADCAST_INFO_VAR(256) SF_BROADCAST_INFO;

typedef struct SF_CART_TIMER
{
    char usage[4];
    int32_t value;
} SF_CART_TIMER;

#define SF_CART_INFO_VAR(p_tag_text_size) \
    struct                                \
    {                                     \
        char version[4];                  \
        char title[64];                   \
        char artist[64];                  \
        char cut_id[64];                  \
        char client_id[64];               \
        char category[64];                \
        char classification[64];          \
        char out_cue[64];                 \
        char start_date[10];              \
        char start_time[8];               \
        char end_date[10];                \
        char end_time[8];                 \
        char producer_app_id[64];         \
        char producer_app_version[64];    \
        char user_def[64];                \
        int32_t level_reference;          \
        SF_CART_TIMER post_timers[8];     \
        char reserved[276];               \
        char url[1024];                   \
        uint32_t tag_text_size;           \
        char tag_text[p_tag_text_size];   \
    }

typedef SF_CART_INFO_VAR(256) SF_CART_INFO;

typedef unsigned long (*sf_ref_callback)(void *user_data);
typedef void (*sf_unref_callback)(void *user_data);

typedef sf_count_t (*sf_vio_get_filelen)(void *user_data);

typedef sf_count_t (*sf_vio_seek)(sf_count_t offset, int whence, void *user_data);
typedef sf_count_t (*sf_vio_read)(void *ptr, sf_count_t count, void *user_data);

typedef sf_count_t (*sf_vio_write)(const void *ptr, sf_count_t count, void *user_data);
typedef sf_count_t (*sf_vio_tell)(void *user_data);
typedef void (*sf_vio_flush)(void *user_data);
typedef int (*sf_vio_set_filelen)(void *user_data, sf_count_t len);

typedef SF_BOOL (*sf_vio_is_pipe)(void *user_data);

typedef struct SF_VIRTUAL_IO
{
    sf_vio_get_filelen get_filelen;
    sf_vio_seek seek;
    sf_vio_read read;
    sf_vio_write write;
    sf_vio_tell tell;
    sf_vio_flush flush;
    sf_vio_set_filelen set_filelen;
    sf_vio_is_pipe is_pipe;
    sf_ref_callback ref;
    sf_unref_callback unref;
} SF_VIRTUAL_IO;

#include "sndfile2k_export.h"

SNDFILE2K_EXPORT SNDFILE *sf_open(const char *path, int mode, SF_INFO *sfinfo);

SNDFILE2K_EXPORT SNDFILE *sf_open_fd(int fd, int mode, SF_INFO *sfinfo, int close_desc);

SNDFILE2K_EXPORT SNDFILE *sf_open_virtual(SF_VIRTUAL_IO *sfvirtual, int mode, SF_INFO *sfinfo,
                                          void *user_data);

SNDFILE2K_EXPORT SNDFILE *sf_open_virtual_ex(SF_VIRTUAL_IO *sfvirtual, int mode, SF_INFO *sfinfo, void *user_data);

SNDFILE2K_EXPORT int sf_error(SNDFILE *sndfile);

SNDFILE2K_EXPORT const char *sf_strerror(SNDFILE *sndfile);

SNDFILE2K_EXPORT const char *sf_error_number(int errnum);

SNDFILE2K_EXPORT int sf_perror(SNDFILE *sndfile);

SNDFILE2K_EXPORT int sf_error_str(SNDFILE *sndfile, char *str, size_t len);

SNDFILE2K_EXPORT int sf_command(SNDFILE *sndfile, int command, void *data, int datasize);

SNDFILE2K_EXPORT int sf_format_check(const SF_INFO *info);

typedef enum SF_SEEK_MODE
{
    SF_SEEK_SET = SEEK_SET,
    SF_SEEK_CUR = SEEK_CUR,
    SF_SEEK_END = SEEK_END
} SF_SEEK_MODE;

SNDFILE2K_EXPORT sf_count_t sf_seek(SNDFILE *sndfile, sf_count_t frames, int whence);

SNDFILE2K_EXPORT int sf_set_string(SNDFILE *sndfile, int str_type, const char *str);

SNDFILE2K_EXPORT const char *sf_get_string(SNDFILE *sndfile, int str_type);

SNDFILE2K_EXPORT const char *sf_version_string(void);

SNDFILE2K_EXPORT int sf_current_byterate(SNDFILE *sndfile);

SNDFILE2K_EXPORT sf_count_t sf_read_raw(SNDFILE *sndfile, void *ptr, sf_count_t bytes);

SNDFILE2K_EXPORT sf_count_t sf_write_raw(SNDFILE *sndfile, const void *ptr, sf_count_t bytes);

SNDFILE2K_EXPORT sf_count_t sf_readf_short(SNDFILE *sndfile, short *ptr, sf_count_t frames);
SNDFILE2K_EXPORT sf_count_t sf_writef_short(SNDFILE *sndfile, const short *ptr, sf_count_t frames);

SNDFILE2K_EXPORT sf_count_t sf_readf_int(SNDFILE *sndfile, int *ptr, sf_count_t frames);
SNDFILE2K_EXPORT sf_count_t sf_writef_int(SNDFILE *sndfile, const int *ptr, sf_count_t frames);

SNDFILE2K_EXPORT sf_count_t sf_readf_float(SNDFILE *sndfile, float *ptr, sf_count_t frames);
SNDFILE2K_EXPORT sf_count_t sf_writef_float(SNDFILE *sndfile, const float *ptr, sf_count_t frames);

SNDFILE2K_EXPORT sf_count_t sf_readf_double(SNDFILE *sndfile, double *ptr, sf_count_t frames);
SNDFILE2K_EXPORT sf_count_t sf_writef_double(SNDFILE *sndfile, const double *ptr,
                                             sf_count_t frames);

SNDFILE2K_EXPORT sf_count_t sf_read_short(SNDFILE *sndfile, short *ptr, sf_count_t items);
SNDFILE2K_EXPORT sf_count_t sf_write_short(SNDFILE *sndfile, const short *ptr, sf_count_t items);

SNDFILE2K_EXPORT sf_count_t sf_read_int(SNDFILE *sndfile, int *ptr, sf_count_t items);
SNDFILE2K_EXPORT sf_count_t sf_write_int(SNDFILE *sndfile, const int *ptr, sf_count_t items);

SNDFILE2K_EXPORT sf_count_t sf_read_float(SNDFILE *sndfile, float *ptr, sf_count_t items);
SNDFILE2K_EXPORT sf_count_t sf_write_float(SNDFILE *sndfile, const float *ptr, sf_count_t items);

SNDFILE2K_EXPORT sf_count_t sf_read_double(SNDFILE *sndfile, double *ptr, sf_count_t items);
SNDFILE2K_EXPORT sf_count_t sf_write_double(SNDFILE *sndfile, const double *ptr, sf_count_t items);
SNDFILE2K_EXPORT int sf_close(SNDFILE *sndfile);

SNDFILE2K_EXPORT void sf_write_sync(SNDFILE *sndfile);

#if (defined(_WIN32) || defined(__CYGWIN__))

SNDFILE2K_EXPORT SNDFILE *sf_wchar_open(const wchar_t *wpath, int mode, SF_INFO *sfinfo);
#endif

struct SF_CHUNK_INFO
{
    char id[64]; 
    unsigned id_size; 
    unsigned datalen; 
    void *data; 
};

typedef struct SF_CHUNK_INFO SF_CHUNK_INFO;

SNDFILE2K_EXPORT int sf_set_chunk(SNDFILE *sndfile, const SF_CHUNK_INFO *chunk_info);

typedef struct SF_CHUNK_ITERATOR SF_CHUNK_ITERATOR;

SNDFILE2K_EXPORT SF_CHUNK_ITERATOR *sf_get_chunk_iterator(SNDFILE *sndfile,
                                                          const SF_CHUNK_INFO *chunk_info);

SNDFILE2K_EXPORT SF_CHUNK_ITERATOR *sf_next_chunk_iterator(SF_CHUNK_ITERATOR *iterator);

SNDFILE2K_EXPORT int sf_get_chunk_size(const SF_CHUNK_ITERATOR *it, SF_CHUNK_INFO *chunk_info);

SNDFILE2K_EXPORT int sf_get_chunk_data(const SF_CHUNK_ITERATOR *it, SF_CHUNK_INFO *chunk_info);

#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */

#endif /* SNDFILE2K_H */