vorbis-tools/oggenc/easyflac.c

   1 /* EasyFLAC - A thin decoding wrapper around libFLAC and libOggFLAC to
   2  * make your code less ugly.  See easyflac.h for explanation.
   3  *
   4  * Copyright 2003 - Stan Seibert <volsung@xiph.org>
   5  * This code is licensed under a BSD style license:
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  * - Redistributions of source code must retain the above copyright
  12  * notice, this list of conditions and the following disclaimer.
  13  *
  14  * - Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  *
  18  * - Neither the name of the Xiph.org Foundation nor the names of its
  19  * contributors may be used to endorse or promote products derived from
  20  * this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include <config.h>
  38 #endif
  39
  40 #include <FLAC/export.h>
  41 #if !defined(FLAC_API_VERSION_CURRENT) || (FLAC_API_VERSION_CURRENT < 8)
  42
  43 #include <stdlib.h>
  44 #include "easyflac.h"
  45
  46
  47 FLAC__bool EasyFLAC__is_oggflac(EasyFLAC__StreamDecoder *decoder)
  48 {
  49     return decoder->is_oggflac;
  50 }
  51
  52
  53 EasyFLAC__StreamDecoder *EasyFLAC__stream_decoder_new(FLAC__bool is_oggflac)
  54 {
  55     EasyFLAC__StreamDecoder *decoder = malloc(sizeof(EasyFLAC__StreamDecoder));
  56
  57     if (decoder != NULL)
  58     {
  59         decoder->is_oggflac = is_oggflac;
  60
  61         if (decoder->is_oggflac)
  62             decoder->oggflac = OggFLAC__stream_decoder_new();
  63         else
  64             decoder->flac = FLAC__stream_decoder_new();
  65
  66         if (  (decoder->is_oggflac && decoder->oggflac == NULL)
  67             ||(!decoder->is_oggflac && decoder->flac == NULL)  )
  68         {
  69             free(decoder);
  70             decoder = NULL;
  71         }
  72     }
  73
  74     return decoder;
  75 }
  76
  77
  78 void EasyFLAC__stream_decoder_delete(EasyFLAC__StreamDecoder *decoder)
  79 {
  80     if (decoder->is_oggflac)
  81         OggFLAC__stream_decoder_delete(decoder->oggflac);
  82     else
  83         FLAC__stream_decoder_delete(decoder->flac);
  84
  85     free(decoder);
  86 }
  87
  88
  89 /* Wrappers around the callbacks for OggFLAC */
  90
  91 FLAC__StreamDecoderReadStatus oggflac_read_callback(const OggFLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
  92 {
  93     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
  94
  95     return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
  96 }
  97
  98
  99 FLAC__StreamDecoderWriteStatus oggflac_write_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 100 {
 101     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 102
 103     return (*(e_decoder->callbacks.write))(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
 104 }
 105
 106
 107 void oggflac_metadata_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 108 {
 109     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 110
 111     (*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
 112 }
 113
 114
 115 void oggflac_error_callback(const OggFLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 116 {
 117     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 118
 119     (*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
 120 }
 121
 122
 123 /* Wrappers around the callbacks for FLAC */
 124
 125 FLAC__StreamDecoderReadStatus flac_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 126 {
 127     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 128
 129     return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
 130 }
 131
 132
 133 FLAC__StreamDecoderWriteStatus flac_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 134 {
 135     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 136
 137     return (*e_decoder->callbacks.write)(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
 138 }
 139
 140
 141 void flac_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 142 {
 143     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 144
 145     (*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
 146 }
 147
 148
 149 void flac_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 150 {
 151     EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 152
 153     (*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
 154 }
 155
 156
 157 FLAC__bool EasyFLAC__set_read_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderReadCallback value)
 158 {
 159     decoder->callbacks.read = value;
 160
 161     if (decoder->is_oggflac)
 162         return OggFLAC__stream_decoder_set_read_callback(decoder->oggflac, &oggflac_read_callback);
 163     else
 164         return FLAC__stream_decoder_set_read_callback(decoder->flac, &flac_read_callback);
 165 }
 166
 167
 168 FLAC__bool EasyFLAC__set_write_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderWriteCallback value)
 169 {
 170     decoder->callbacks.write = value;
 171
 172     if (decoder->is_oggflac)
 173         return OggFLAC__stream_decoder_set_write_callback(decoder->oggflac, &oggflac_write_callback);
 174     else
 175         return FLAC__stream_decoder_set_write_callback(decoder->flac, &flac_write_callback);
 176 }
 177
 178
 179 FLAC__bool EasyFLAC__set_metadata_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderMetadataCallback value)
 180 {
 181     decoder->callbacks.metadata = value;
 182
 183     if (decoder->is_oggflac)
 184         return OggFLAC__stream_decoder_set_metadata_callback(decoder->oggflac, &oggflac_metadata_callback);
 185     else
 186         return FLAC__stream_decoder_set_metadata_callback(decoder->flac, &flac_metadata_callback);
 187 }
 188
 189
 190 FLAC__bool EasyFLAC__set_error_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderErrorCallback value)
 191 {
 192     decoder->callbacks.error = value;
 193
 194     if (decoder->is_oggflac)
 195         return OggFLAC__stream_decoder_set_error_callback(decoder->oggflac, &oggflac_error_callback);
 196     else
 197         return FLAC__stream_decoder_set_error_callback(decoder->flac, &flac_error_callback);
 198 }
 199
 200
 201 FLAC__bool EasyFLAC__set_client_data(EasyFLAC__StreamDecoder *decoder, void *value)
 202 {
 203     decoder->callbacks.client_data = value;
 204
 205     if (decoder->is_oggflac)
 206         return OggFLAC__stream_decoder_set_client_data(decoder->oggflac, decoder);
 207     else
 208         return FLAC__stream_decoder_set_client_data(decoder->flac, decoder);
 209 }
 210
 211
 212 FLAC__bool EasyFLAC__set_metadata_respond(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 213 {
 214     if (decoder->is_oggflac)
 215         return OggFLAC__stream_decoder_set_metadata_respond(decoder->oggflac, type);
 216     else
 217         return FLAC__stream_decoder_set_metadata_respond(decoder->flac, type);
 218 }
 219
 220
 221 FLAC__bool EasyFLAC__set_metadata_respond_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 222 {
 223     if (decoder->is_oggflac)
 224         return OggFLAC__stream_decoder_set_metadata_respond_application(decoder->oggflac, id);
 225     else
 226         return FLAC__stream_decoder_set_metadata_respond_application(decoder->flac, id);
 227 }
 228
 229
 230 FLAC__bool EasyFLAC__set_metadata_respond_all(EasyFLAC__StreamDecoder *decoder)
 231 {
 232     if (decoder->is_oggflac)
 233         return OggFLAC__stream_decoder_set_metadata_respond_all(decoder->oggflac);
 234     else
 235         return FLAC__stream_decoder_set_metadata_respond_all(decoder->flac);
 236 }
 237
 238
 239 FLAC__bool EasyFLAC__set_metadata_ignore(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 240 {
 241     if (decoder->is_oggflac)
 242         return OggFLAC__stream_decoder_set_metadata_ignore(decoder->oggflac, type);
 243     else
 244         return FLAC__stream_decoder_set_metadata_ignore(decoder->flac, type);
 245 }
 246
 247
 248 FLAC__bool EasyFLAC__set_metadata_ignore_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 249 {
 250     if (decoder->is_oggflac)
 251         return OggFLAC__stream_decoder_set_metadata_ignore_application(decoder->oggflac, id);
 252     else
 253         return FLAC__stream_decoder_set_metadata_ignore_application(decoder->flac, id);
 254 }
 255
 256 FLAC__bool EasyFLAC__set_metadata_ignore_all(EasyFLAC__StreamDecoder *decoder)
 257 {
 258     if (decoder->is_oggflac)
 259         return OggFLAC__stream_decoder_set_metadata_ignore_all(decoder->oggflac);
 260     else
 261         return FLAC__stream_decoder_set_metadata_ignore_all(decoder->flac);
 262 }
 263
 264
 265 FLAC__StreamDecoderState EasyFLAC__get_state(const EasyFLAC__StreamDecoder *decoder)
 266 {
 267     if (decoder->is_oggflac)
 268         return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
 269     else
 270         return FLAC__stream_decoder_get_state(decoder->flac);
 271 }
 272
 273
 274 unsigned EasyFLAC__get_channels(const EasyFLAC__StreamDecoder *decoder)
 275 {
 276     if (decoder->is_oggflac)
 277         return OggFLAC__stream_decoder_get_channels(decoder->oggflac);
 278     else
 279         return FLAC__stream_decoder_get_channels(decoder->flac);
 280 }
 281
 282
 283 FLAC__ChannelAssignment EasyFLAC__get_channel_assignment(const EasyFLAC__StreamDecoder *decoder)
 284 {
 285     if (decoder->is_oggflac)
 286         return OggFLAC__stream_decoder_get_channel_assignment(decoder->oggflac);
 287     else
 288         return FLAC__stream_decoder_get_channel_assignment(decoder->flac);
 289 }
 290
 291
 292 unsigned EasyFLAC__get_bits_per_sample(const EasyFLAC__StreamDecoder *decoder)
 293 {
 294     if (decoder->is_oggflac)
 295         return OggFLAC__stream_decoder_get_bits_per_sample(decoder->oggflac);
 296     else
 297         return FLAC__stream_decoder_get_bits_per_sample(decoder->flac);
 298 }
 299
 300
 301 unsigned EasyFLAC__get_sample_rate(const EasyFLAC__StreamDecoder *decoder)
 302 {
 303     if (decoder->is_oggflac)
 304         return OggFLAC__stream_decoder_get_sample_rate(decoder->oggflac);
 305     else
 306         return FLAC__stream_decoder_get_sample_rate(decoder->flac);
 307 }
 308
 309
 310 unsigned EasyFLAC__get_blocksize(const EasyFLAC__StreamDecoder *decoder)
 311 {
 312     if (decoder->is_oggflac)
 313         return OggFLAC__stream_decoder_get_blocksize(decoder->oggflac);
 314     else
 315         return FLAC__stream_decoder_get_blocksize(decoder->flac);
 316 }
 317
 318
 319 FLAC__StreamDecoderState EasyFLAC__init(EasyFLAC__StreamDecoder *decoder)
 320 {
 321     if (decoder->is_oggflac)
 322     {
 323         OggFLAC__stream_decoder_init(decoder->oggflac);
 324         return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
 325     }
 326     else
 327         return FLAC__stream_decoder_init(decoder->flac);
 328 }
 329
 330
 331 void EasyFLAC__finish(EasyFLAC__StreamDecoder *decoder)
 332 {
 333     if (decoder->is_oggflac)
 334         OggFLAC__stream_decoder_finish(decoder->oggflac);
 335     else
 336         FLAC__stream_decoder_finish(decoder->flac);
 337 }
 338
 339
 340 FLAC__bool EasyFLAC__flush(EasyFLAC__StreamDecoder *decoder)
 341 {
 342     if (decoder->is_oggflac)
 343         return OggFLAC__stream_decoder_flush(decoder->oggflac);
 344     else
 345         return FLAC__stream_decoder_flush(decoder->flac);
 346 }
 347
 348
 349 FLAC__bool EasyFLAC__reset(EasyFLAC__StreamDecoder *decoder)
 350 {
 351     if (decoder->is_oggflac)
 352         return OggFLAC__stream_decoder_reset(decoder->oggflac);
 353     else
 354         return FLAC__stream_decoder_reset(decoder->flac);
 355 }
 356
 357
 358 FLAC__bool EasyFLAC__process_single(EasyFLAC__StreamDecoder *decoder)
 359 {
 360     if (decoder->is_oggflac)
 361         return OggFLAC__stream_decoder_process_single(decoder->oggflac);
 362     else
 363         return FLAC__stream_decoder_process_single(decoder->flac);
 364 }
 365
 366
 367 FLAC__bool EasyFLAC__process_until_end_of_metadata(EasyFLAC__StreamDecoder *decoder)
 368 {
 369     if (decoder->is_oggflac)
 370         return OggFLAC__stream_decoder_process_until_end_of_metadata(decoder->oggflac);
 371     else
 372         return FLAC__stream_decoder_process_until_end_of_metadata(decoder->flac);
 373 }
 374
 375
 376 FLAC__bool EasyFLAC__process_until_end_of_stream(EasyFLAC__StreamDecoder *decoder)
 377 {
 378     if (decoder->is_oggflac)
 379         return OggFLAC__stream_decoder_process_until_end_of_stream(decoder->oggflac);
 380     else
 381         return FLAC__stream_decoder_process_until_end_of_stream(decoder->flac);
 382 }
 383
 384 #endif