| 1 |
/* |
| 2 |
** Copyright (C) 1999-2016 Erik de Castro Lopo <[email protected]> |
| 3 |
** |
| 4 |
** This program is free software; you can redistribute it and/or modify |
| 5 |
** it under the terms of the GNU Lesser General Public License as published by |
| 6 |
** the Free Software Foundation; either version 2.1 of the License, or |
| 7 |
** (at your option) any later version. |
| 8 |
** |
| 9 |
** This program is distributed in the hope that it will be useful, |
| 10 |
** but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 |
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 |
** GNU Lesser General Public License for more details. |
| 13 |
** |
| 14 |
** You should have received a copy of the GNU Lesser General Public License |
| 15 |
** along with this program; if not, write to the Free Software |
| 16 |
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 17 |
*/ |
| 18 |
|
| 19 |
/* |
| 20 |
** sndfile.h -- system-wide definitions |
| 21 |
** |
| 22 |
** API documentation is in the doc/ directory of the source code tarball |
| 23 |
** and at http://libsndfile.github.io/libsndfile/api.html. |
| 24 |
*/ |
| 25 |
|
| 26 |
#ifndef SNDFILE_H |
| 27 |
#define SNDFILE_H |
| 28 |
|
| 29 |
/* This is the version 1.0.X header file. */ |
| 30 |
#define SNDFILE_1 |
| 31 |
|
| 32 |
#include <stdio.h> |
| 33 |
#include <stdint.h> |
| 34 |
#include <sys/types.h> |
| 35 |
|
| 36 |
#ifdef __cplusplus |
| 37 |
extern "C" { |
| 38 |
#endif /* __cplusplus */ |
| 39 |
|
| 40 |
/* The following file types can be read and written. |
| 41 |
** A file type would consist of a major type (ie SF_FORMAT_WAV) bitwise |
| 42 |
** ORed with a minor type (ie SF_FORMAT_PCM). SF_FORMAT_TYPEMASK and |
| 43 |
** SF_FORMAT_SUBMASK can be used to separate the major and minor file |
| 44 |
** types. |
| 45 |
*/ |
| 46 |
|
| 47 |
enum |
| 48 |
{ /* Major formats. */ |
| 49 |
SF_FORMAT_WAV = 0x010000, /* Microsoft WAV format (little endian default). */ |
| 50 |
SF_FORMAT_AIFF = 0x020000, /* Apple/SGI AIFF format (big endian). */ |
| 51 |
SF_FORMAT_AU = 0x030000, /* Sun/NeXT AU format (big endian). */ |
| 52 |
SF_FORMAT_RAW = 0x040000, /* RAW PCM data. */ |
| 53 |
SF_FORMAT_PAF = 0x050000, /* Ensoniq PARIS file format. */ |
| 54 |
SF_FORMAT_SVX = 0x060000, /* Amiga IFF / SVX8 / SV16 format. */ |
| 55 |
SF_FORMAT_NIST = 0x070000, /* Sphere NIST format. */ |
| 56 |
SF_FORMAT_VOC = 0x080000, /* VOC files. */ |
| 57 |
SF_FORMAT_IRCAM = 0x0A0000, /* Berkeley/IRCAM/CARL */ |
| 58 |
SF_FORMAT_W64 = 0x0B0000, /* Sonic Foundry's 64 bit RIFF/WAV */ |
| 59 |
SF_FORMAT_MAT4 = 0x0C0000, /* Matlab (tm) V4.2 / GNU Octave 2.0 */ |
| 60 |
SF_FORMAT_MAT5 = 0x0D0000, /* Matlab (tm) V5.0 / GNU Octave 2.1 */ |
| 61 |
SF_FORMAT_PVF = 0x0E0000, /* Portable Voice Format */ |
| 62 |
SF_FORMAT_XI = 0x0F0000, /* Fasttracker 2 Extended Instrument */ |
| 63 |
SF_FORMAT_HTK = 0x100000, /* HMM Tool Kit format */ |
| 64 |
SF_FORMAT_SDS = 0x110000, /* Midi Sample Dump Standard */ |
| 65 |
SF_FORMAT_AVR = 0x120000, /* Audio Visual Research */ |
| 66 |
SF_FORMAT_WAVEX = 0x130000, /* MS WAVE with WAVEFORMATEX */ |
| 67 |
SF_FORMAT_SD2 = 0x160000, /* Sound Designer 2 */ |
| 68 |
SF_FORMAT_FLAC = 0x170000, /* FLAC lossless file format */ |
| 69 |
SF_FORMAT_CAF = 0x180000, /* Core Audio File format */ |
| 70 |
SF_FORMAT_WVE = 0x190000, /* Psion WVE format */ |
| 71 |
SF_FORMAT_OGG = 0x200000, /* Xiph OGG container */ |
| 72 |
SF_FORMAT_MPC2K = 0x210000, /* Akai MPC 2000 sampler */ |
| 73 |
SF_FORMAT_RF64 = 0x220000, /* RF64 WAV file */ |
| 74 |
SF_FORMAT_MPEG = 0x230000, /* MPEG-1/2 audio stream */ |
| 75 |
|
| 76 |
/* Subtypes from here on. */ |
| 77 |
|
| 78 |
SF_FORMAT_PCM_S8 = 0x0001, /* Signed 8 bit data */ |
| 79 |
SF_FORMAT_PCM_16 = 0x0002, /* Signed 16 bit data */ |
| 80 |
SF_FORMAT_PCM_24 = 0x0003, /* Signed 24 bit data */ |
| 81 |
SF_FORMAT_PCM_32 = 0x0004, /* Signed 32 bit data */ |
| 82 |
|
| 83 |
SF_FORMAT_PCM_U8 = 0x0005, /* Unsigned 8 bit data (WAV and RAW only) */ |
| 84 |
|
| 85 |
SF_FORMAT_FLOAT = 0x0006, /* 32 bit float data */ |
| 86 |
SF_FORMAT_DOUBLE = 0x0007, /* 64 bit float data */ |
| 87 |
|
| 88 |
SF_FORMAT_ULAW = 0x0010, /* U-Law encoded. */ |
| 89 |
SF_FORMAT_ALAW = 0x0011, /* A-Law encoded. */ |
| 90 |
SF_FORMAT_IMA_ADPCM = 0x0012, /* IMA ADPCM. */ |
| 91 |
SF_FORMAT_MS_ADPCM = 0x0013, /* Microsoft ADPCM. */ |
| 92 |
|
| 93 |
SF_FORMAT_GSM610 = 0x0020, /* GSM 6.10 encoding. */ |
| 94 |
SF_FORMAT_VOX_ADPCM = 0x0021, /* OKI / Dialogix ADPCM */ |
| 95 |
|
| 96 |
SF_FORMAT_NMS_ADPCM_16 = 0x0022, /* 16kbs NMS G721-variant encoding. */ |
| 97 |
SF_FORMAT_NMS_ADPCM_24 = 0x0023, /* 24kbs NMS G721-variant encoding. */ |
| 98 |
SF_FORMAT_NMS_ADPCM_32 = 0x0024, /* 32kbs NMS G721-variant encoding. */ |
| 99 |
|
| 100 |
SF_FORMAT_G721_32 = 0x0030, /* 32kbs G721 ADPCM encoding. */ |
| 101 |
SF_FORMAT_G723_24 = 0x0031, /* 24kbs G723 ADPCM encoding. */ |
| 102 |
SF_FORMAT_G723_40 = 0x0032, /* 40kbs G723 ADPCM encoding. */ |
| 103 |
|
| 104 |
SF_FORMAT_DWVW_12 = 0x0040, /* 12 bit Delta Width Variable Word encoding. */ |
| 105 |
SF_FORMAT_DWVW_16 = 0x0041, /* 16 bit Delta Width Variable Word encoding. */ |
| 106 |
SF_FORMAT_DWVW_24 = 0x0042, /* 24 bit Delta Width Variable Word encoding. */ |
| 107 |
SF_FORMAT_DWVW_N = 0x0043, /* N bit Delta Width Variable Word encoding. */ |
| 108 |
|
| 109 |
SF_FORMAT_DPCM_8 = 0x0050, /* 8 bit differential PCM (XI only) */ |
| 110 |
SF_FORMAT_DPCM_16 = 0x0051, /* 16 bit differential PCM (XI only) */ |
| 111 |
|
| 112 |
SF_FORMAT_VORBIS = 0x0060, /* Xiph Vorbis encoding. */ |
| 113 |
SF_FORMAT_OPUS = 0x0064, /* Xiph/Skype Opus encoding. */ |
| 114 |
|
| 115 |
SF_FORMAT_ALAC_16 = 0x0070, /* Apple Lossless Audio Codec (16 bit). */ |
| 116 |
SF_FORMAT_ALAC_20 = 0x0071, /* Apple Lossless Audio Codec (20 bit). */ |
| 117 |
SF_FORMAT_ALAC_24 = 0x0072, /* Apple Lossless Audio Codec (24 bit). */ |
| 118 |
SF_FORMAT_ALAC_32 = 0x0073, /* Apple Lossless Audio Codec (32 bit). */ |
| 119 |
|
| 120 |
SF_FORMAT_MPEG_LAYER_I = 0x0080, /* MPEG-1 Audio Layer I */ |
| 121 |
SF_FORMAT_MPEG_LAYER_II = 0x0081, /* MPEG-1 Audio Layer II */ |
| 122 |
SF_FORMAT_MPEG_LAYER_III = 0x0082, /* MPEG-2 Audio Layer III */ |
| 123 |
|
| 124 |
/* Endian-ness options. */ |
| 125 |
|
| 126 |
SF_ENDIAN_FILE = 0x00000000, /* Default file endian-ness. */ |
| 127 |
SF_ENDIAN_LITTLE = 0x10000000, /* Force little endian-ness. */ |
| 128 |
SF_ENDIAN_BIG = 0x20000000, /* Force big endian-ness. */ |
| 129 |
SF_ENDIAN_CPU = 0x30000000, /* Force CPU endian-ness. */ |
| 130 |
|
| 131 |
SF_FORMAT_SUBMASK = 0x0000FFFF, |
| 132 |
SF_FORMAT_TYPEMASK = 0x0FFF0000, |
| 133 |
SF_FORMAT_ENDMASK = 0x30000000 |
| 134 |
} ; |
| 135 |
|
| 136 |
/* |
| 137 |
** The following are the valid command numbers for the sf_command() |
| 138 |
** interface. The use of these commands is documented in the file |
| 139 |
** command.html in the doc directory of the source code distribution. |
| 140 |
*/ |
| 141 |
|
| 142 |
enum |
| 143 |
{ SFC_GET_LIB_VERSION = 0x1000, |
| 144 |
SFC_GET_LOG_INFO = 0x1001, |
| 145 |
SFC_GET_CURRENT_SF_INFO = 0x1002, |
| 146 |
|
| 147 |
|
| 148 |
SFC_GET_NORM_DOUBLE = 0x1010, |
| 149 |
SFC_GET_NORM_FLOAT = 0x1011, |
| 150 |
SFC_SET_NORM_DOUBLE = 0x1012, |
| 151 |
SFC_SET_NORM_FLOAT = 0x1013, |
| 152 |
SFC_SET_SCALE_FLOAT_INT_READ = 0x1014, |
| 153 |
SFC_SET_SCALE_INT_FLOAT_WRITE = 0x1015, |
| 154 |
|
| 155 |
SFC_GET_SIMPLE_FORMAT_COUNT = 0x1020, |
| 156 |
SFC_GET_SIMPLE_FORMAT = 0x1021, |
| 157 |
|
| 158 |
SFC_GET_FORMAT_INFO = 0x1028, |
| 159 |
|
| 160 |
SFC_GET_FORMAT_MAJOR_COUNT = 0x1030, |
| 161 |
SFC_GET_FORMAT_MAJOR = 0x1031, |
| 162 |
SFC_GET_FORMAT_SUBTYPE_COUNT = 0x1032, |
| 163 |
SFC_GET_FORMAT_SUBTYPE = 0x1033, |
| 164 |
|
| 165 |
SFC_CALC_SIGNAL_MAX = 0x1040, |
| 166 |
SFC_CALC_NORM_SIGNAL_MAX = 0x1041, |
| 167 |
SFC_CALC_MAX_ALL_CHANNELS = 0x1042, |
| 168 |
SFC_CALC_NORM_MAX_ALL_CHANNELS = 0x1043, |
| 169 |
SFC_GET_SIGNAL_MAX = 0x1044, |
| 170 |
SFC_GET_MAX_ALL_CHANNELS = 0x1045, |
| 171 |
|
| 172 |
SFC_SET_ADD_PEAK_CHUNK = 0x1050, |
| 173 |
|
| 174 |
SFC_UPDATE_HEADER_NOW = 0x1060, |
| 175 |
SFC_SET_UPDATE_HEADER_AUTO = 0x1061, |
| 176 |
|
| 177 |
SFC_FILE_TRUNCATE = 0x1080, |
| 178 |
|
| 179 |
SFC_SET_RAW_START_OFFSET = 0x1090, |
| 180 |
|
| 181 |
/* Commands reserved for dithering, which is not implemented. */ |
| 182 |
SFC_SET_DITHER_ON_WRITE = 0x10A0, |
| 183 |
SFC_SET_DITHER_ON_READ = 0x10A1, |
| 184 |
|
| 185 |
SFC_GET_DITHER_INFO_COUNT = 0x10A2, |
| 186 |
SFC_GET_DITHER_INFO = 0x10A3, |
| 187 |
|
| 188 |
SFC_GET_EMBED_FILE_INFO = 0x10B0, |
| 189 |
|
| 190 |
SFC_SET_CLIPPING = 0x10C0, |
| 191 |
SFC_GET_CLIPPING = 0x10C1, |
| 192 |
|
| 193 |
SFC_GET_CUE_COUNT = 0x10CD, |
| 194 |
SFC_GET_CUE = 0x10CE, |
| 195 |
SFC_SET_CUE = 0x10CF, |
| 196 |
|
| 197 |
SFC_GET_INSTRUMENT = 0x10D0, |
| 198 |
SFC_SET_INSTRUMENT = 0x10D1, |
| 199 |
|
| 200 |
SFC_GET_LOOP_INFO = 0x10E0, |
| 201 |
|
| 202 |
SFC_GET_BROADCAST_INFO = 0x10F0, |
| 203 |
SFC_SET_BROADCAST_INFO = 0x10F1, |
| 204 |
|
| 205 |
SFC_GET_CHANNEL_MAP_INFO = 0x1100, |
| 206 |
SFC_SET_CHANNEL_MAP_INFO = 0x1101, |
| 207 |
|
| 208 |
SFC_RAW_DATA_NEEDS_ENDSWAP = 0x1110, |
| 209 |
|
| 210 |
/* Support for Wavex Ambisonics Format */ |
| 211 |
SFC_WAVEX_SET_AMBISONIC = 0x1200, |
| 212 |
SFC_WAVEX_GET_AMBISONIC = 0x1201, |
| 213 |
|
| 214 |
/* |
| 215 |
** RF64 files can be set so that on-close, writable files that have less |
| 216 |
** than 4GB of data in them are converted to RIFF/WAV, as per EBU |
| 217 |
** recommendations. |
| 218 |
*/ |
| 219 |
SFC_RF64_AUTO_DOWNGRADE = 0x1210, |
| 220 |
|
| 221 |
SFC_SET_VBR_ENCODING_QUALITY = 0x1300, |
| 222 |
SFC_SET_COMPRESSION_LEVEL = 0x1301, |
| 223 |
|
| 224 |
/* Ogg format commands */ |
| 225 |
SFC_SET_OGG_PAGE_LATENCY_MS = 0x1302, |
| 226 |
SFC_SET_OGG_PAGE_LATENCY = 0x1303, |
| 227 |
SFC_GET_OGG_STREAM_SERIALNO = 0x1306, |
| 228 |
|
| 229 |
SFC_GET_BITRATE_MODE = 0x1304, |
| 230 |
SFC_SET_BITRATE_MODE = 0x1305, |
| 231 |
|
| 232 |
/* Cart Chunk support */ |
| 233 |
SFC_SET_CART_INFO = 0x1400, |
| 234 |
SFC_GET_CART_INFO = 0x1401, |
| 235 |
|
| 236 |
/* Opus files original samplerate metadata */ |
| 237 |
SFC_SET_ORIGINAL_SAMPLERATE = 0x1500, |
| 238 |
SFC_GET_ORIGINAL_SAMPLERATE = 0x1501, |
| 239 |
|
| 240 |
/* Following commands for testing only. */ |
| 241 |
SFC_TEST_IEEE_FLOAT_REPLACE = 0x6001, |
| 242 |
|
| 243 |
/* |
| 244 |
** These SFC_SET_ADD_* values are deprecated and will disappear at some |
| 245 |
** time in the future. They are guaranteed to be here up to and |
| 246 |
** including version 1.0.8 to avoid breakage of existing software. |
| 247 |
** They currently do nothing and will continue to do nothing. |
| 248 |
*/ |
| 249 |
SFC_SET_ADD_HEADER_PAD_CHUNK = 0x1051, |
| 250 |
|
| 251 |
SFC_SET_ADD_DITHER_ON_WRITE = 0x1070, |
| 252 |
SFC_SET_ADD_DITHER_ON_READ = 0x1071 |
| 253 |
} ; |
| 254 |
|
| 255 |
|
| 256 |
/* |
| 257 |
** String types that can be set and read from files. Not all file types |
| 258 |
** support this and even the file types which support one, may not support |
| 259 |
** all string types. |
| 260 |
*/ |
| 261 |
|
| 262 |
enum |
| 263 |
{ SF_STR_TITLE = 0x01, |
| 264 |
SF_STR_COPYRIGHT = 0x02, |
| 265 |
SF_STR_SOFTWARE = 0x03, |
| 266 |
SF_STR_ARTIST = 0x04, |
| 267 |
SF_STR_COMMENT = 0x05, |
| 268 |
SF_STR_DATE = 0x06, |
| 269 |
SF_STR_ALBUM = 0x07, |
| 270 |
SF_STR_LICENSE = 0x08, |
| 271 |
SF_STR_TRACKNUMBER = 0x09, |
| 272 |
SF_STR_GENRE = 0x10 |
| 273 |
} ; |
| 274 |
|
| 275 |
/* |
| 276 |
** Use the following as the start and end index when doing metadata |
| 277 |
** transcoding. |
| 278 |
*/ |
| 279 |
|
| 280 |
#define SF_STR_FIRST SF_STR_TITLE |
| 281 |
#define SF_STR_LAST SF_STR_GENRE |
| 282 |
|
| 283 |
enum |
| 284 |
{ /* True and false */ |
| 285 |
SF_FALSE = 0, |
| 286 |
SF_TRUE = 1, |
| 287 |
|
| 288 |
/* Modes for opening files. */ |
| 289 |
SFM_READ = 0x10, |
| 290 |
SFM_WRITE = 0x20, |
| 291 |
SFM_RDWR = 0x30, |
| 292 |
|
| 293 |
SF_AMBISONIC_NONE = 0x40, |
| 294 |
SF_AMBISONIC_B_FORMAT = 0x41 |
| 295 |
} ; |
| 296 |
|
| 297 |
/* Public error values. These are guaranteed to remain unchanged for the duration |
| 298 |
** of the library major version number. |
| 299 |
** There are also a large number of private error numbers which are internal to |
| 300 |
** the library which can change at any time. |
| 301 |
*/ |
| 302 |
|
| 303 |
enum |
| 304 |
{ SF_ERR_NO_ERROR = 0, |
| 305 |
SF_ERR_UNRECOGNISED_FORMAT = 1, |
| 306 |
SF_ERR_SYSTEM = 2, |
| 307 |
SF_ERR_MALFORMED_FILE = 3, |
| 308 |
SF_ERR_UNSUPPORTED_ENCODING = 4 |
| 309 |
} ; |
| 310 |
|
| 311 |
|
| 312 |
/* Channel map values (used with SFC_SET/GET_CHANNEL_MAP). |
| 313 |
*/ |
| 314 |
|
| 315 |
enum |
| 316 |
{ SF_CHANNEL_MAP_INVALID = 0, |
| 317 |
SF_CHANNEL_MAP_MONO = 1, |
| 318 |
SF_CHANNEL_MAP_LEFT, /* Apple calls this 'Left' */ |
| 319 |
SF_CHANNEL_MAP_RIGHT, /* Apple calls this 'Right' */ |
| 320 |
SF_CHANNEL_MAP_CENTER, /* Apple calls this 'Center' */ |
| 321 |
SF_CHANNEL_MAP_FRONT_LEFT, |
| 322 |
SF_CHANNEL_MAP_FRONT_RIGHT, |
| 323 |
SF_CHANNEL_MAP_FRONT_CENTER, |
| 324 |
SF_CHANNEL_MAP_REAR_CENTER, /* Apple calls this 'Center Surround', Msft calls this 'Back Center' */ |
| 325 |
SF_CHANNEL_MAP_REAR_LEFT, /* Apple calls this 'Left Surround', Msft calls this 'Back Left' */ |
| 326 |
SF_CHANNEL_MAP_REAR_RIGHT, /* Apple calls this 'Right Surround', Msft calls this 'Back Right' */ |
| 327 |
SF_CHANNEL_MAP_LFE, /* Apple calls this 'LFEScreen', Msft calls this 'Low Frequency' */ |
| 328 |
SF_CHANNEL_MAP_FRONT_LEFT_OF_CENTER, /* Apple calls this 'Left Center' */ |
| 329 |
SF_CHANNEL_MAP_FRONT_RIGHT_OF_CENTER, /* Apple calls this 'Right Center */ |
| 330 |
SF_CHANNEL_MAP_SIDE_LEFT, /* Apple calls this 'Left Surround Direct' */ |
| 331 |
SF_CHANNEL_MAP_SIDE_RIGHT, /* Apple calls this 'Right Surround Direct' */ |
| 332 |
SF_CHANNEL_MAP_TOP_CENTER, /* Apple calls this 'Top Center Surround' */ |
| 333 |
SF_CHANNEL_MAP_TOP_FRONT_LEFT, /* Apple calls this 'Vertical Height Left' */ |
| 334 |
SF_CHANNEL_MAP_TOP_FRONT_RIGHT, /* Apple calls this 'Vertical Height Right' */ |
| 335 |
SF_CHANNEL_MAP_TOP_FRONT_CENTER, /* Apple calls this 'Vertical Height Center' */ |
| 336 |
SF_CHANNEL_MAP_TOP_REAR_LEFT, /* Apple and MS call this 'Top Back Left' */ |
| 337 |
SF_CHANNEL_MAP_TOP_REAR_RIGHT, /* Apple and MS call this 'Top Back Right' */ |
| 338 |
SF_CHANNEL_MAP_TOP_REAR_CENTER, /* Apple and MS call this 'Top Back Center' */ |
| 339 |
|
| 340 |
SF_CHANNEL_MAP_AMBISONIC_B_W, |
| 341 |
SF_CHANNEL_MAP_AMBISONIC_B_X, |
| 342 |
SF_CHANNEL_MAP_AMBISONIC_B_Y, |
| 343 |
SF_CHANNEL_MAP_AMBISONIC_B_Z, |
| 344 |
|
| 345 |
SF_CHANNEL_MAP_MAX |
| 346 |
} ; |
| 347 |
|
| 348 |
/* Bitrate mode values (for use with SFC_GET/SET_BITRATE_MODE) |
| 349 |
*/ |
| 350 |
enum |
| 351 |
{ SF_BITRATE_MODE_CONSTANT = 0, |
| 352 |
SF_BITRATE_MODE_AVERAGE, |
| 353 |
SF_BITRATE_MODE_VARIABLE |
| 354 |
} ; |
| 355 |
|
| 356 |
|
| 357 |
/* A SNDFILE* pointer can be passed around much like stdio.h's FILE* pointer. */ |
| 358 |
|
| 359 |
typedef struct sf_private_tag SNDFILE ; |
| 360 |
|
| 361 |
/* The following typedef is system specific and is defined when libsndfile is |
| 362 |
** compiled. sf_count_t will be a 64 bit value when the underlying OS allows |
| 363 |
** 64 bit file offsets. |
| 364 |
** On windows, we need to allow the same header file to be compiler by both GCC |
| 365 |
** and the Microsoft compiler. |
| 366 |
*/ |
| 367 |
|
| 368 |
typedef int64_t sf_count_t ; |
| 369 |
#ifndef SF_COUNT_MAX |
| 370 |
#define SF_COUNT_MAX INT64_MAX |
| 371 |
#endif |
| 372 |
|
| 373 |
|
| 374 |
/* A pointer to a SF_INFO structure is passed to sf_open () and filled in. |
| 375 |
** On write, the SF_INFO structure is filled in by the user and passed into |
| 376 |
** sf_open (). |
| 377 |
*/ |
| 378 |
|
| 379 |
struct SF_INFO |
| 380 |
{ sf_count_t frames ; /* Used to be called samples. Changed to avoid confusion. */ |
| 381 |
int samplerate ; |
| 382 |
int channels ; |
| 383 |
int format ; |
| 384 |
int sections ; |
| 385 |
int seekable ; |
| 386 |
} ; |
| 387 |
|
| 388 |
typedef struct SF_INFO SF_INFO ; |
| 389 |
|
| 390 |
/* The SF_FORMAT_INFO struct is used to retrieve information about the sound |
| 391 |
** file formats libsndfile supports using the sf_command () interface. |
| 392 |
** |
| 393 |
** Using this interface will allow applications to support new file formats |
| 394 |
** and encoding types when libsndfile is upgraded, without requiring |
| 395 |
** re-compilation of the application. |
| 396 |
** |
| 397 |
** Please consult the libsndfile documentation (particularly the information |
| 398 |
** on the sf_command () interface) for examples of its use. |
| 399 |
*/ |
| 400 |
|
| 401 |
typedef struct |
| 402 |
{ int format ; |
| 403 |
const char *name ; |
| 404 |
const char *extension ; |
| 405 |
} SF_FORMAT_INFO ; |
| 406 |
|
| 407 |
/* |
| 408 |
** Enums and typedefs for adding dither on read and write. |
| 409 |
** Reserved for future implementation. |
| 410 |
*/ |
| 411 |
|
| 412 |
enum |
| 413 |
{ SFD_DEFAULT_LEVEL = 0, |
| 414 |
SFD_CUSTOM_LEVEL = 0x40000000, |
| 415 |
|
| 416 |
SFD_NO_DITHER = 500, |
| 417 |
SFD_WHITE = 501, |
| 418 |
SFD_TRIANGULAR_PDF = 502 |
| 419 |
} ; |
| 420 |
|
| 421 |
typedef struct |
| 422 |
{ int type ; |
| 423 |
double level ; |
| 424 |
const char *name ; |
| 425 |
} SF_DITHER_INFO ; |
| 426 |
|
| 427 |
/* Struct used to retrieve information about a file embedded within a |
| 428 |
** larger file. See SFC_GET_EMBED_FILE_INFO. |
| 429 |
*/ |
| 430 |
|
| 431 |
typedef struct |
| 432 |
{ sf_count_t offset ; |
| 433 |
sf_count_t length ; |
| 434 |
} SF_EMBED_FILE_INFO ; |
| 435 |
|
| 436 |
/* |
| 437 |
** Struct used to retrieve cue marker information from a file |
| 438 |
*/ |
| 439 |
|
| 440 |
typedef struct |
| 441 |
{ int32_t indx ; |
| 442 |
uint32_t position ; |
| 443 |
int32_t fcc_chunk ; |
| 444 |
int32_t chunk_start ; |
| 445 |
int32_t block_start ; |
| 446 |
uint32_t sample_offset ; |
| 447 |
char name [256] ; |
| 448 |
} SF_CUE_POINT ; |
| 449 |
|
| 450 |
#define SF_CUES_VAR(count) \ |
| 451 |
struct \ |
| 452 |
{ uint32_t cue_count ; \ |
| 453 |
SF_CUE_POINT cue_points [count] ; \ |
| 454 |
} |
| 455 |
|
| 456 |
typedef SF_CUES_VAR (100) SF_CUES ; |
| 457 |
|
| 458 |
/* |
| 459 |
** Structs used to retrieve music sample information from a file. |
| 460 |
*/ |
| 461 |
|
| 462 |
enum |
| 463 |
{ /* |
| 464 |
** The loop mode field in SF_INSTRUMENT will be one of the following. |
| 465 |
*/ |
| 466 |
SF_LOOP_NONE = 800, |
| 467 |
SF_LOOP_FORWARD, |
| 468 |
SF_LOOP_BACKWARD, |
| 469 |
SF_LOOP_ALTERNATING |
| 470 |
} ; |
| 471 |
|
| 472 |
typedef struct |
| 473 |
{ int gain ; |
| 474 |
char basenote, detune ; |
| 475 |
char velocity_lo, velocity_hi ; |
| 476 |
char key_lo, key_hi ; |
| 477 |
int loop_count ; |
| 478 |
|
| 479 |
struct |
| 480 |
{ int mode ; |
| 481 |
uint32_t start ; |
| 482 |
uint32_t end ; |
| 483 |
uint32_t count ; |
| 484 |
} loops [16] ; /* make variable in a sensible way */ |
| 485 |
} SF_INSTRUMENT ; |
| 486 |
|
| 487 |
|
| 488 |
|
| 489 |
/* Struct used to retrieve loop information from a file.*/ |
| 490 |
typedef struct |
| 491 |
{ |
| 492 |
short time_sig_num ; /* any positive integer > 0 */ |
| 493 |
short time_sig_den ; /* any positive power of 2 > 0 */ |
| 494 |
int loop_mode ; /* see SF_LOOP enum */ |
| 495 |
|
| 496 |
int num_beats ; /* this is NOT the amount of quarter notes !!!*/ |
| 497 |
/* a full bar of 4/4 is 4 beats */ |
| 498 |
/* a full bar of 7/8 is 7 beats */ |
| 499 |
|
| 500 |
float bpm ; /* suggestion, as it can be calculated using other fields:*/ |
| 501 |
/* file's length, file's sampleRate and our time_sig_den*/ |
| 502 |
/* -> bpms are always the amount of _quarter notes_ per minute */ |
| 503 |
|
| 504 |
int root_key ; /* MIDI note, or -1 for None */ |
| 505 |
int future [6] ; |
| 506 |
} SF_LOOP_INFO ; |
| 507 |
|
| 508 |
|
| 509 |
/* Struct used to retrieve broadcast (EBU) information from a file. |
| 510 |
** Strongly (!) based on EBU "bext" chunk format used in Broadcast WAVE. |
| 511 |
*/ |
| 512 |
#define SF_BROADCAST_INFO_VAR(coding_hist_size) \ |
| 513 |
struct \ |
| 514 |
{ char description [256] ; \ |
| 515 |
char originator [32] ; \ |
| 516 |
char originator_reference [32] ; \ |
| 517 |
char origination_date [10] ; \ |
| 518 |
char origination_time [8] ; \ |
| 519 |
uint32_t time_reference_low ; \ |
| 520 |
uint32_t time_reference_high ; \ |
| 521 |
short version ; \ |
| 522 |
char umid [64] ; \ |
| 523 |
int16_t loudness_value ; \ |
| 524 |
int16_t loudness_range ; \ |
| 525 |
int16_t max_true_peak_level ; \ |
| 526 |
int16_t max_momentary_loudness ; \ |
| 527 |
int16_t max_shortterm_loudness ; \ |
| 528 |
char reserved [180] ; \ |
| 529 |
uint32_t coding_history_size ; \ |
| 530 |
char coding_history [coding_hist_size] ; \ |
| 531 |
} |
| 532 |
|
| 533 |
/* SF_BROADCAST_INFO is the above struct with coding_history field of 256 bytes. */ |
| 534 |
typedef SF_BROADCAST_INFO_VAR (256) SF_BROADCAST_INFO ; |
| 535 |
|
| 536 |
struct SF_CART_TIMER |
| 537 |
{ char usage [4] ; |
| 538 |
int32_t value ; |
| 539 |
} ; |
| 540 |
|
| 541 |
typedef struct SF_CART_TIMER SF_CART_TIMER ; |
| 542 |
|
| 543 |
#define SF_CART_INFO_VAR(p_tag_text_size) \ |
| 544 |
struct \ |
| 545 |
{ char version [4] ; \ |
| 546 |
char title [64] ; \ |
| 547 |
char artist [64] ; \ |
| 548 |
char cut_id [64] ; \ |
| 549 |
char client_id [64] ; \ |
| 550 |
char category [64] ; \ |
| 551 |
char classification [64] ; \ |
| 552 |
char out_cue [64] ; \ |
| 553 |
char start_date [10] ; \ |
| 554 |
char start_time [8] ; \ |
| 555 |
char end_date [10] ; \ |
| 556 |
char end_time [8] ; \ |
| 557 |
char producer_app_id [64] ; \ |
| 558 |
char producer_app_version [64] ; \ |
| 559 |
char user_def [64] ; \ |
| 560 |
int32_t level_reference ; \ |
| 561 |
SF_CART_TIMER post_timers [8] ; \ |
| 562 |
char reserved [276] ; \ |
| 563 |
char url [1024] ; \ |
| 564 |
uint32_t tag_text_size ; \ |
| 565 |
char tag_text [p_tag_text_size] ; \ |
| 566 |
} |
| 567 |
|
| 568 |
typedef SF_CART_INFO_VAR (256) SF_CART_INFO ; |
| 569 |
|
| 570 |
/* Virtual I/O functionality. */ |
| 571 |
|
| 572 |
typedef sf_count_t (*sf_vio_get_filelen) (void *user_data) ; |
| 573 |
typedef sf_count_t (*sf_vio_seek) (sf_count_t offset, int whence, void *user_data) ; |
| 574 |
typedef sf_count_t (*sf_vio_read) (void *ptr, sf_count_t count, void *user_data) ; |
| 575 |
typedef sf_count_t (*sf_vio_write) (const void *ptr, sf_count_t count, void *user_data) ; |
| 576 |
typedef sf_count_t (*sf_vio_tell) (void *user_data) ; |
| 577 |
|
| 578 |
struct SF_VIRTUAL_IO |
| 579 |
{ sf_vio_get_filelen get_filelen ; |
| 580 |
sf_vio_seek seek ; |
| 581 |
sf_vio_read read ; |
| 582 |
sf_vio_write write ; |
| 583 |
sf_vio_tell tell ; |
| 584 |
} ; |
| 585 |
|
| 586 |
typedef struct SF_VIRTUAL_IO SF_VIRTUAL_IO ; |
| 587 |
|
| 588 |
|
| 589 |
/* Open the specified file for read, write or both. On error, this will |
| 590 |
** return a NULL pointer. To find the error number, pass a NULL SNDFILE |
| 591 |
** to sf_strerror (). |
| 592 |
** All calls to sf_open() should be matched with a call to sf_close(). |
| 593 |
*/ |
| 594 |
|
| 595 |
SNDFILE* sf_open (const char *path, int mode, SF_INFO *sfinfo) ; |
| 596 |
|
| 597 |
|
| 598 |
/* Use the existing file descriptor to create a SNDFILE object. If close_desc |
| 599 |
** is TRUE, the file descriptor will be closed when sf_close() is called. If |
| 600 |
** it is FALSE, the descriptor will not be closed. |
| 601 |
** When passed a descriptor like this, the library will assume that the start |
| 602 |
** of file header is at the current file offset. This allows sound files within |
| 603 |
** larger container files to be read and/or written. |
| 604 |
** On error, this will return a NULL pointer. To find the error number, pass a |
| 605 |
** NULL SNDFILE to sf_strerror (). |
| 606 |
** All calls to sf_open_fd() should be matched with a call to sf_close(). |
| 607 |
|
| 608 |
*/ |
| 609 |
|
| 610 |
SNDFILE* sf_open_fd (int fd, int mode, SF_INFO *sfinfo, int close_desc) ; |
| 611 |
|
| 612 |
SNDFILE* sf_open_virtual (SF_VIRTUAL_IO *sfvirtual, int mode, SF_INFO *sfinfo, void *user_data) ; |
| 613 |
|
| 614 |
|
| 615 |
/* sf_error () returns a error number which can be translated to a text |
| 616 |
** string using sf_error_number(). |
| 617 |
*/ |
| 618 |
|
| 619 |
int sf_error (SNDFILE *sndfile) ; |
| 620 |
|
| 621 |
|
| 622 |
/* sf_strerror () returns to the caller a pointer to the current error message for |
| 623 |
** the given SNDFILE. |
| 624 |
*/ |
| 625 |
|
| 626 |
const char* sf_strerror (SNDFILE *sndfile) ; |
| 627 |
|
| 628 |
|
| 629 |
/* sf_error_number () allows the retrieval of the error string for each internal |
| 630 |
** error number. |
| 631 |
** |
| 632 |
*/ |
| 633 |
|
| 634 |
const char* sf_error_number (int errnum) ; |
| 635 |
|
| 636 |
|
| 637 |
/* The following two error functions are deprecated but they will remain in the |
| 638 |
** library for the foreseeable future. The function sf_strerror() should be used |
| 639 |
** in their place. |
| 640 |
*/ |
| 641 |
|
| 642 |
int sf_perror (SNDFILE *sndfile) ; |
| 643 |
int sf_error_str (SNDFILE *sndfile, char* str, size_t len) ; |
| 644 |
|
| 645 |
|
| 646 |
/* Allow the caller to retrieve information from or change aspects of the |
| 647 |
** library behaviour. |
| 648 |
*/ |
| 649 |
|
| 650 |
int sf_command (SNDFILE *sndfile, int command, void *data, int datasize) ; |
| 651 |
|
| 652 |
|
| 653 |
/* Return TRUE if fields of the SF_INFO struct are a valid combination of values. */ |
| 654 |
|
| 655 |
int sf_format_check (const SF_INFO *info) ; |
| 656 |
|
| 657 |
|
| 658 |
/* Seek within the waveform data chunk of the SNDFILE. sf_seek () uses |
| 659 |
** the same values for whence (SEEK_SET, SEEK_CUR and SEEK_END) as |
| 660 |
** stdio.h function fseek (). |
| 661 |
** An offset of zero with whence set to SEEK_SET will position the |
| 662 |
** read / write pointer to the first data sample. |
| 663 |
** On success sf_seek returns the current position in (multi-channel) |
| 664 |
** samples from the start of the file. |
| 665 |
** Please see the libsndfile documentation for moving the read pointer |
| 666 |
** separately from the write pointer on files open in mode SFM_RDWR. |
| 667 |
** On error all of these functions return -1. |
| 668 |
*/ |
| 669 |
|
| 670 |
enum |
| 671 |
{ SF_SEEK_SET = SEEK_SET, |
| 672 |
SF_SEEK_CUR = SEEK_CUR, |
| 673 |
SF_SEEK_END = SEEK_END |
| 674 |
} ; |
| 675 |
|
| 676 |
sf_count_t sf_seek (SNDFILE *sndfile, sf_count_t frames, int whence) ; |
| 677 |
|
| 678 |
|
| 679 |
/* Functions for retrieving and setting string data within sound files. |
| 680 |
** Not all file types support this features; AIFF and WAV do. For both |
| 681 |
** functions, the str_type parameter must be one of the SF_STR_* values |
| 682 |
** defined above. |
| 683 |
** On error, sf_set_string() returns non-zero while sf_get_string() |
| 684 |
** returns NULL. |
| 685 |
*/ |
| 686 |
|
| 687 |
int sf_set_string (SNDFILE *sndfile, int str_type, const char* str) ; |
| 688 |
|
| 689 |
const char* sf_get_string (SNDFILE *sndfile, int str_type) ; |
| 690 |
|
| 691 |
|
| 692 |
/* Return the library version string. */ |
| 693 |
|
| 694 |
const char * sf_version_string (void) ; |
| 695 |
|
| 696 |
/* Return the current byterate at this point in the file. The byte rate in this |
| 697 |
** case is the number of bytes per second of audio data. For instance, for a |
| 698 |
** stereo, 18 bit PCM encoded file with an 16kHz sample rate, the byte rate |
| 699 |
** would be 2 (stereo) * 2 (two bytes per sample) * 16000 => 64000 bytes/sec. |
| 700 |
** For some file formats the returned value will be accurate and exact, for some |
| 701 |
** it will be a close approximation, for some it will be the average bitrate for |
| 702 |
** the whole file and for some it will be a time varying value that was accurate |
| 703 |
** when the file was most recently read or written. |
| 704 |
** To get the bitrate, multiple this value by 8. |
| 705 |
** Returns -1 for unknown. |
| 706 |
*/ |
| 707 |
int sf_current_byterate (SNDFILE *sndfile) ; |
| 708 |
|
| 709 |
/* Functions for reading/writing the waveform data of a sound file. |
| 710 |
*/ |
| 711 |
|
| 712 |
sf_count_t sf_read_raw (SNDFILE *sndfile, void *ptr, sf_count_t bytes) ; |
| 713 |
sf_count_t sf_write_raw (SNDFILE *sndfile, const void *ptr, sf_count_t bytes) ; |
| 714 |
|
| 715 |
|
| 716 |
/* Functions for reading and writing the data chunk in terms of frames. |
| 717 |
** The number of items actually read/written = frames * number of channels. |
| 718 |
** sf_xxxx_raw read/writes the raw data bytes from/to the file |
| 719 |
** sf_xxxx_short passes data in the native short format |
| 720 |
** sf_xxxx_int passes data in the native int format |
| 721 |
** sf_xxxx_float passes data in the native float format |
| 722 |
** sf_xxxx_double passes data in the native double format |
| 723 |
** All of these read/write function return number of frames read/written. |
| 724 |
*/ |
| 725 |
|
| 726 |
sf_count_t sf_readf_short (SNDFILE *sndfile, short *ptr, sf_count_t frames) ; |
| 727 |
sf_count_t sf_writef_short (SNDFILE *sndfile, const short *ptr, sf_count_t frames) ; |
| 728 |
|
| 729 |
sf_count_t sf_readf_int (SNDFILE *sndfile, int *ptr, sf_count_t frames) ; |
| 730 |
sf_count_t sf_writef_int (SNDFILE *sndfile, const int *ptr, sf_count_t frames) ; |
| 731 |
|
| 732 |
sf_count_t sf_readf_float (SNDFILE *sndfile, float *ptr, sf_count_t frames) ; |
| 733 |
sf_count_t sf_writef_float (SNDFILE *sndfile, const float *ptr, sf_count_t frames) ; |
| 734 |
|
| 735 |
sf_count_t sf_readf_double (SNDFILE *sndfile, double *ptr, sf_count_t frames) ; |
| 736 |
sf_count_t sf_writef_double (SNDFILE *sndfile, const double *ptr, sf_count_t frames) ; |
| 737 |
|
| 738 |
|
| 739 |
/* Functions for reading and writing the data chunk in terms of items. |
| 740 |
** Otherwise similar to above. |
| 741 |
** All of these read/write function return number of items read/written. |
| 742 |
*/ |
| 743 |
|
| 744 |
sf_count_t sf_read_short (SNDFILE *sndfile, short *ptr, sf_count_t items) ; |
| 745 |
sf_count_t sf_write_short (SNDFILE *sndfile, const short *ptr, sf_count_t items) ; |
| 746 |
|
| 747 |
sf_count_t sf_read_int (SNDFILE *sndfile, int *ptr, sf_count_t items) ; |
| 748 |
sf_count_t sf_write_int (SNDFILE *sndfile, const int *ptr, sf_count_t items) ; |
| 749 |
|
| 750 |
sf_count_t sf_read_float (SNDFILE *sndfile, float *ptr, sf_count_t items) ; |
| 751 |
sf_count_t sf_write_float (SNDFILE *sndfile, const float *ptr, sf_count_t items) ; |
| 752 |
|
| 753 |
sf_count_t sf_read_double (SNDFILE *sndfile, double *ptr, sf_count_t items) ; |
| 754 |
sf_count_t sf_write_double (SNDFILE *sndfile, const double *ptr, sf_count_t items) ; |
| 755 |
|
| 756 |
|
| 757 |
/* Close the SNDFILE and clean up all memory allocations associated with this |
| 758 |
** file. |
| 759 |
** Returns 0 on success, or an error number. |
| 760 |
*/ |
| 761 |
|
| 762 |
int sf_close (SNDFILE *sndfile) ; |
| 763 |
|
| 764 |
|
| 765 |
/* If the file is opened SFM_WRITE or SFM_RDWR, call fsync() on the file |
| 766 |
** to force the writing of data to disk. If the file is opened SFM_READ |
| 767 |
** no action is taken. |
| 768 |
*/ |
| 769 |
|
| 770 |
void sf_write_sync (SNDFILE *sndfile) ; |
| 771 |
|
| 772 |
|
| 773 |
|
| 774 |
/* The function sf_wchar_open() is Windows Only! |
| 775 |
** Open a file passing in a Windows Unicode filename. Otherwise, this is |
| 776 |
** the same as sf_open(). |
| 777 |
*/ |
| 778 |
|
| 779 |
#ifdef _WIN32 |
| 780 |
SNDFILE* sf_wchar_open (const wchar_t *wpath, int mode, SF_INFO *sfinfo) ; |
| 781 |
#endif |
| 782 |
|
| 783 |
|
| 784 |
|
| 785 |
|
| 786 |
/* Getting and setting of chunks from within a sound file. |
| 787 |
** |
| 788 |
** These functions allow the getting and setting of chunks within a sound file |
| 789 |
** (for those formats which allow it). |
| 790 |
** |
| 791 |
** These functions fail safely. Specifically, they will not allow you to overwrite |
| 792 |
** existing chunks or add extra versions of format specific reserved chunks but |
| 793 |
** should allow you to retrieve any and all chunks (may not be implemented for |
| 794 |
** all chunks or all file formats). |
| 795 |
*/ |
| 796 |
|
| 797 |
struct SF_CHUNK_INFO |
| 798 |
{ char id [64] ; /* The chunk identifier. */ |
| 799 |
unsigned id_size ; /* The size of the chunk identifier. */ |
| 800 |
unsigned datalen ; /* The size of that data. */ |
| 801 |
void *data ; /* Pointer to the data. */ |
| 802 |
} ; |
| 803 |
|
| 804 |
typedef struct SF_CHUNK_INFO SF_CHUNK_INFO ; |
| 805 |
|
| 806 |
/* Set the specified chunk info (must be done before any audio data is written |
| 807 |
** to the file). This will fail for format specific reserved chunks. |
| 808 |
** The chunk_info->data pointer must be valid until the file is closed. |
| 809 |
** Returns SF_ERR_NO_ERROR on success or non-zero on failure. |
| 810 |
*/ |
| 811 |
int sf_set_chunk (SNDFILE * sndfile, const SF_CHUNK_INFO * chunk_info) ; |
| 812 |
|
| 813 |
/* |
| 814 |
** An opaque structure to an iterator over the all chunks of a given id |
| 815 |
*/ |
| 816 |
typedef struct SF_CHUNK_ITERATOR SF_CHUNK_ITERATOR ; |
| 817 |
|
| 818 |
/* Get an iterator for all chunks matching chunk_info. |
| 819 |
** The iterator will point to the first chunk matching chunk_info. |
| 820 |
** Chunks are matching, if (chunk_info->id) matches the first |
| 821 |
** (chunk_info->id_size) bytes of a chunk found in the SNDFILE* handle. |
| 822 |
** If chunk_info is NULL, an iterator to all chunks in the SNDFILE* handle |
| 823 |
** is returned. |
| 824 |
** The values of chunk_info->datalen and chunk_info->data are ignored. |
| 825 |
** If no matching chunks are found in the sndfile, NULL is returned. |
| 826 |
** The returned iterator will stay valid until one of the following occurs: |
| 827 |
** a) The sndfile is closed. |
| 828 |
** b) A new chunk is added using sf_set_chunk(). |
| 829 |
** c) Another chunk iterator function is called on the same SNDFILE* handle |
| 830 |
** that causes the iterator to be modified. |
| 831 |
** The memory for the iterator belongs to the SNDFILE* handle and is freed when |
| 832 |
** sf_close() is called. |
| 833 |
*/ |
| 834 |
SF_CHUNK_ITERATOR * |
| 835 |
sf_get_chunk_iterator (SNDFILE * sndfile, const SF_CHUNK_INFO * chunk_info) ; |
| 836 |
|
| 837 |
/* Iterate through chunks by incrementing the iterator. |
| 838 |
** Increments the iterator and returns a handle to the new one. |
| 839 |
** After this call, iterator will no longer be valid, and you must use the |
| 840 |
** newly returned handle from now on. |
| 841 |
** The returned handle can be used to access the next chunk matching |
| 842 |
** the criteria as defined in sf_get_chunk_iterator(). |
| 843 |
** If iterator points to the last chunk, this will free all resources |
| 844 |
** associated with iterator and return NULL. |
| 845 |
** The returned iterator will stay valid until sf_get_chunk_iterator_next |
| 846 |
** is called again, the sndfile is closed or a new chunk us added. |
| 847 |
*/ |
| 848 |
SF_CHUNK_ITERATOR * |
| 849 |
sf_next_chunk_iterator (SF_CHUNK_ITERATOR * iterator) ; |
| 850 |
|
| 851 |
|
| 852 |
/* Get the size of the specified chunk. |
| 853 |
** If the specified chunk exists, the size will be returned in the |
| 854 |
** datalen field of the SF_CHUNK_INFO struct. |
| 855 |
** Additionally, the id of the chunk will be copied to the id |
| 856 |
** field of the SF_CHUNK_INFO struct and it's id_size field will |
| 857 |
** be updated accordingly. |
| 858 |
** If the chunk doesn't exist chunk_info->datalen will be zero, and the |
| 859 |
** id and id_size fields will be undefined. |
| 860 |
** The function will return SF_ERR_NO_ERROR on success or non-zero on |
| 861 |
** failure. |
| 862 |
*/ |
| 863 |
int |
| 864 |
sf_get_chunk_size (const SF_CHUNK_ITERATOR * it, SF_CHUNK_INFO * chunk_info) ; |
| 865 |
|
| 866 |
/* Get the specified chunk data. |
| 867 |
** If the specified chunk exists, up to chunk_info->datalen bytes of |
| 868 |
** the chunk data will be copied into the chunk_info->data buffer |
| 869 |
** (allocated by the caller) and the chunk_info->datalen field |
| 870 |
** updated to reflect the size of the data. The id and id_size |
| 871 |
** field will be updated according to the retrieved chunk |
| 872 |
** If the chunk doesn't exist chunk_info->datalen will be zero, and the |
| 873 |
** id and id_size fields will be undefined. |
| 874 |
** The function will return SF_ERR_NO_ERROR on success or non-zero on |
| 875 |
** failure. |
| 876 |
*/ |
| 877 |
int |
| 878 |
sf_get_chunk_data (const SF_CHUNK_ITERATOR * it, SF_CHUNK_INFO * chunk_info) ; |
| 879 |
|
| 880 |
|
| 881 |
#ifdef __cplusplus |
| 882 |
} /* extern "C" */ |
| 883 |
#endif /* __cplusplus */ |
| 884 |
|
| 885 |
#endif /* SNDFILE_H */ |