vorbis-tools-1.2.0/ogg123/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 FLAC__bool EasyFLAC__is_oggflac(EasyFLAC__StreamDecoder *decoder)
  47 {
  48         return decoder->is_oggflac;
  49 }
  50
  51
  52 EasyFLAC__StreamDecoder *EasyFLAC__stream_decoder_new(FLAC__bool is_oggflac)
  53 {
  54         EasyFLAC__StreamDecoder *decoder = malloc(sizeof(EasyFLAC__StreamDecoder));
  55
  56         if (decoder != NULL)
  57         {
  58                 decoder->is_oggflac = is_oggflac;
  59
  60                 if (decoder->is_oggflac)
  61                         decoder->oggflac = OggFLAC__stream_decoder_new();
  62                 else
  63                         decoder->flac = FLAC__stream_decoder_new();
  64
  65                 if (  (decoder->is_oggflac && decoder->oggflac == NULL)
  66                     ||(!decoder->is_oggflac && decoder->flac == NULL)  )
  67                 {
  68                         free(decoder);
  69                         decoder = NULL;
  70                 }
  71         }
  72
  73         return decoder;
  74 }
  75
  76
  77 void EasyFLAC__stream_decoder_delete(EasyFLAC__StreamDecoder *decoder)
  78 {
  79         if (decoder->is_oggflac)
  80                 OggFLAC__stream_decoder_delete(decoder->oggflac);
  81         else
  82                 FLAC__stream_decoder_delete(decoder->flac);
  83
  84         free(decoder);
  85 }
  86
  87
  88 /* Wrappers around the callbacks for OggFLAC */
  89
  90 FLAC__StreamDecoderReadStatus oggflac_read_callback(const OggFLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
  91 {
  92         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
  93
  94         return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
  95 }
  96
  97
  98 FLAC__StreamDecoderWriteStatus oggflac_write_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
  99 {
 100         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 101
 102         return (*(e_decoder->callbacks.write))(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
 103 }
 104
 105
 106 void oggflac_metadata_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 107 {
 108         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 109
 110         (*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
 111 }
 112
 113
 114 void oggflac_error_callback(const OggFLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 115 {
 116         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 117
 118         (*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
 119 }
 120
 121
 122 /* Wrappers around the callbacks for FLAC */
 123
 124 FLAC__StreamDecoderReadStatus flac_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 125 {
 126         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 127
 128         return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
 129 }
 130
 131
 132 FLAC__StreamDecoderWriteStatus flac_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 133 {
 134         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 135
 136         return (*e_decoder->callbacks.write)(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
 137 }
 138
 139
 140 void flac_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 141 {
 142         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 143
 144         (*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
 145 }
 146
 147
 148 void flac_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 149 {
 150         EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
 151
 152         (*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
 153 }
 154
 155
 156 FLAC__bool EasyFLAC__set_read_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderReadCallback value)
 157 {
 158         decoder->callbacks.read = value;
 159
 160         if (decoder->is_oggflac)
 161                 return OggFLAC__stream_decoder_set_read_callback(decoder->oggflac, &oggflac_read_callback);
 162         else
 163                 return FLAC__stream_decoder_set_read_callback(decoder->flac, &flac_read_callback);
 164 }
 165
 166
 167 FLAC__bool EasyFLAC__set_write_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderWriteCallback value)
 168 {
 169         decoder->callbacks.write = value;
 170
 171         if (decoder->is_oggflac)
 172                 return OggFLAC__stream_decoder_set_write_callback(decoder->oggflac, &oggflac_write_callback);
 173         else
 174                 return FLAC__stream_decoder_set_write_callback(decoder->flac, &flac_write_callback);
 175 }
 176
 177
 178 FLAC__bool EasyFLAC__set_metadata_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderMetadataCallback value)
 179 {
 180         decoder->callbacks.metadata = value;
 181
 182         if (decoder->is_oggflac)
 183                 return OggFLAC__stream_decoder_set_metadata_callback(decoder->oggflac, &oggflac_metadata_callback);
 184         else
 185                 return FLAC__stream_decoder_set_metadata_callback(decoder->flac, &flac_metadata_callback);
 186 }
 187
 188
 189 FLAC__bool EasyFLAC__set_error_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderErrorCallback value)
 190 {
 191         decoder->callbacks.error = value;
 192
 193         if (decoder->is_oggflac)
 194                 return OggFLAC__stream_decoder_set_error_callback(decoder->oggflac, &oggflac_error_callback);
 195         else
 196                 return FLAC__stream_decoder_set_error_callback(decoder->flac, &flac_error_callback);
 197 }
 198
 199
 200 FLAC__bool EasyFLAC__set_client_data(EasyFLAC__StreamDecoder *decoder, void *value)
 201 {
 202         decoder->callbacks.client_data = value;
 203
 204         if (decoder->is_oggflac)
 205                 return OggFLAC__stream_decoder_set_client_data(decoder->oggflac, decoder);
 206         else
 207                 return FLAC__stream_decoder_set_client_data(decoder->flac, decoder);
 208 }
 209
 210
 211 FLAC__bool EasyFLAC__set_metadata_respond(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 212 {
 213         if (decoder->is_oggflac)
 214                 return OggFLAC__stream_decoder_set_metadata_respond(decoder->oggflac, type);
 215         else
 216                 return FLAC__stream_decoder_set_metadata_respond(decoder->flac, type);
 217 }
 218
 219
 220 FLAC__bool EasyFLAC__set_metadata_respond_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 221 {
 222         if (decoder->is_oggflac)
 223                 return OggFLAC__stream_decoder_set_metadata_respond_application(decoder->oggflac, id);
 224         else
 225                 return FLAC__stream_decoder_set_metadata_respond_application(decoder->flac, id);
 226 }
 227
 228
 229 FLAC__bool EasyFLAC__set_metadata_respond_all(EasyFLAC__StreamDecoder *decoder)
 230 {
 231         if (decoder->is_oggflac)
 232                 return OggFLAC__stream_decoder_set_metadata_respond_all(decoder->oggflac);
 233         else
 234                 return FLAC__stream_decoder_set_metadata_respond_all(decoder->flac);
 235 }
 236
 237
 238 FLAC__bool EasyFLAC__set_metadata_ignore(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
 239 {
 240         if (decoder->is_oggflac)
 241                 return OggFLAC__stream_decoder_set_metadata_ignore(decoder->oggflac, type);
 242         else
 243                 return FLAC__stream_decoder_set_metadata_ignore(decoder->flac, type);
 244 }
 245
 246
 247 FLAC__bool EasyFLAC__set_metadata_ignore_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
 248 {
 249         if (decoder->is_oggflac)
 250                 return OggFLAC__stream_decoder_set_metadata_ignore_application(decoder->oggflac, id);
 251         else
 252                 return FLAC__stream_decoder_set_metadata_ignore_application(decoder->flac, id);
 253 }
 254
 255 FLAC__bool EasyFLAC__set_metadata_ignore_all(EasyFLAC__StreamDecoder *decoder)
 256 {
 257         if (decoder->is_oggflac)
 258                 return OggFLAC__stream_decoder_set_metadata_ignore_all(decoder->oggflac);
 259         else
 260                 return FLAC__stream_decoder_set_metadata_ignore_all(decoder->flac);
 261 }
 262
 263
 264 FLAC__StreamDecoderState EasyFLAC__get_state(const EasyFLAC__StreamDecoder *decoder)
 265 {
 266         if (decoder->is_oggflac)
 267                 return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
 268         else
 269                 return FLAC__stream_decoder_get_state(decoder->flac);
 270 }
 271
 272
 273 unsigned EasyFLAC__get_channels(const EasyFLAC__StreamDecoder *decoder)
 274 {
 275         if (decoder->is_oggflac)
 276                 return OggFLAC__stream_decoder_get_channels(decoder->oggflac);
 277         else
 278                 return FLAC__stream_decoder_get_channels(decoder->flac);
 279 }
 280
 281
 282 FLAC__ChannelAssignment EasyFLAC__get_channel_assignment(const EasyFLAC__StreamDecoder *decoder)
 283 {
 284         if (decoder->is_oggflac)
 285                 return OggFLAC__stream_decoder_get_channel_assignment(decoder->oggflac);
 286         else
 287                 return FLAC__stream_decoder_get_channel_assignment(decoder->flac);
 288 }
 289
 290
 291 unsigned EasyFLAC__get_bits_per_sample(const EasyFLAC__StreamDecoder *decoder)
 292 {
 293         if (decoder->is_oggflac)
 294                 return OggFLAC__stream_decoder_get_bits_per_sample(decoder->oggflac);
 295         else
 296                 return FLAC__stream_decoder_get_bits_per_sample(decoder->flac);
 297 }
 298
 299
 300 unsigned EasyFLAC__get_sample_rate(const EasyFLAC__StreamDecoder *decoder)
 301 {
 302         if (decoder->is_oggflac)
 303                 return OggFLAC__stream_decoder_get_sample_rate(decoder->oggflac);
 304         else
 305                 return FLAC__stream_decoder_get_sample_rate(decoder->flac);
 306 }
 307
 308
 309 unsigned EasyFLAC__get_blocksize(const EasyFLAC__StreamDecoder *decoder)
 310 {
 311         if (decoder->is_oggflac)
 312                 return OggFLAC__stream_decoder_get_blocksize(decoder->oggflac);
 313         else
 314                 return FLAC__stream_decoder_get_blocksize(decoder->flac);
 315 }
 316
 317
 318 FLAC__StreamDecoderState EasyFLAC__init(EasyFLAC__StreamDecoder *decoder)
 319 {
 320         if (decoder->is_oggflac)
 321         {
 322                 OggFLAC__stream_decoder_init(decoder->oggflac);
 323                 return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
 324         }
 325         else
 326                 return FLAC__stream_decoder_init(decoder->flac);
 327 }
 328
 329
 330 void EasyFLAC__finish(EasyFLAC__StreamDecoder *decoder)
 331 {
 332         if (decoder->is_oggflac)
 333                 OggFLAC__stream_decoder_finish(decoder->oggflac);
 334         else
 335                 FLAC__stream_decoder_finish(decoder->flac);
 336 }
 337
 338
 339 FLAC__bool EasyFLAC__flush(EasyFLAC__StreamDecoder *decoder)
 340 {
 341         if (decoder->is_oggflac)
 342                 return OggFLAC__stream_decoder_flush(decoder->oggflac);
 343         else
 344                 return FLAC__stream_decoder_flush(decoder->flac);
 345 }
 346
 347
 348 FLAC__bool EasyFLAC__reset(EasyFLAC__StreamDecoder *decoder)
 349 {
 350         if (decoder->is_oggflac)
 351                 return OggFLAC__stream_decoder_reset(decoder->oggflac);
 352         else
 353                 return FLAC__stream_decoder_reset(decoder->flac);
 354 }
 355
 356
 357 FLAC__bool EasyFLAC__process_single(EasyFLAC__StreamDecoder *decoder)
 358 {
 359         if (decoder->is_oggflac)
 360                 return OggFLAC__stream_decoder_process_single(decoder->oggflac);
 361         else
 362                 return FLAC__stream_decoder_process_single(decoder->flac);
 363 }
 364
 365
 366 FLAC__bool EasyFLAC__process_until_end_of_metadata(EasyFLAC__StreamDecoder *decoder)
 367 {
 368         if (decoder->is_oggflac)
 369                 return OggFLAC__stream_decoder_process_until_end_of_metadata(decoder->oggflac);
 370         else
 371                 return FLAC__stream_decoder_process_until_end_of_metadata(decoder->flac);
 372 }
 373
 374
 375 FLAC__bool EasyFLAC__process_until_end_of_stream(EasyFLAC__StreamDecoder *decoder)
 376 {
 377         if (decoder->is_oggflac)
 378                 return OggFLAC__stream_decoder_process_until_end_of_stream(decoder->oggflac);
 379         else
 380                 return FLAC__stream_decoder_process_until_end_of_stream(decoder->flac);
 381 }
 382
 383 #endif