src/libFLAC/file_decoder.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2000,2001,2002  Josh Coalson
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h> /* for malloc() */
  22 #include <string.h> /* for strcmp() */
  23 #include <sys/stat.h> /* for stat() */
  24 #include "FLAC/assert.h"
  25 #include "protected/file_decoder.h"
  26 #include "protected/seekable_stream_decoder.h"
  27 #include "private/md5.h"
  28
  29 /***********************************************************************
  30  *
  31  * Private class method prototypes
  32  *
  33  ***********************************************************************/
  34
  35 static FLAC__SeekableStreamDecoderReadStatus read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  36 static FLAC__SeekableStreamDecoderSeekStatus seek_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
  37 static FLAC__SeekableStreamDecoderTellStatus tell_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
  38 static FLAC__SeekableStreamDecoderLengthStatus length_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
  39 static FLAC__bool eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *client_data);
  40 static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
  41 static void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
  42 static void error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  43
  44 /***********************************************************************
  45  *
  46  * Private class data
  47  *
  48  ***********************************************************************/
  49
  50 typedef struct FLAC__FileDecoderPrivate {
  51         FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
  52         void (*metadata_callback)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
  53         void (*error_callback)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  54         void *client_data;
  55         FILE *file;
  56         char *filename; /* == NULL if stdin */
  57         FLAC__SeekableStreamDecoder *seekable_stream_decoder;
  58         struct {
  59                 FLAC__bool md5_checking;
  60         } init_values_for_superclass;
  61 } FLAC__FileDecoderPrivate;
  62
  63 /***********************************************************************
  64  *
  65  * Public static class data
  66  *
  67  ***********************************************************************/
  68
  69 const char *FLAC__FileDecoderStateString[] = {
  70         "FLAC__FILE_DECODER_OK",
  71         "FLAC__FILE_DECODER_SEEKING",
  72         "FLAC__FILE_DECODER_END_OF_FILE",
  73         "FLAC__FILE_DECODER_ERROR_OPENING_FILE",
  74         "FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR",
  75         "FLAC__FILE_DECODER_SEEK_ERROR",
  76         "FLAC__FILE_DECODER_STREAM_ERROR",
  77         "FLAC__FILE_DECODER_STREAM_DECODER_ERROR",
  78         "FLAC__FILE_DECODER_ALREADY_INITIALIZED",
  79         "FLAC__FILE_DECODER_INVALID_CALLBACK",
  80         "FLAC__FILE_DECODER_UNINITIALIZED"
  81 };
  82
  83 /***********************************************************************
  84  *
  85  * Class constructor/destructor
  86  *
  87  ***********************************************************************/
  88
  89 FLAC__FileDecoder *FLAC__file_decoder_new()
  90 {
  91         FLAC__FileDecoder *decoder;
  92
  93         FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
  94
  95         decoder = (FLAC__FileDecoder*)malloc(sizeof(FLAC__FileDecoder));
  96         if(decoder == 0) {
  97                 return 0;
  98         }
  99         decoder->protected_ = (FLAC__FileDecoderProtected*)malloc(sizeof(FLAC__FileDecoderProtected));
 100         if(decoder->protected_ == 0) {
 101                 free(decoder);
 102                 return 0;
 103         }
 104         decoder->private_ = (FLAC__FileDecoderPrivate*)malloc(sizeof(FLAC__FileDecoderPrivate));
 105         if(decoder->private_ == 0) {
 106                 free(decoder->protected_);
 107                 free(decoder);
 108                 return 0;
 109         }
 110
 111         decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
 112
 113         decoder->private_->filename = 0;
 114         decoder->private_->write_callback = 0;
 115         decoder->private_->metadata_callback = 0;
 116         decoder->private_->error_callback = 0;
 117         decoder->private_->client_data = 0;
 118         decoder->private_->init_values_for_superclass.md5_checking = false;
 119
 120         return decoder;
 121 }
 122
 123 void FLAC__file_decoder_delete(FLAC__FileDecoder *decoder)
 124 {
 125         FLAC__ASSERT(decoder != 0);
 126         FLAC__ASSERT(decoder->protected_ != 0);
 127         FLAC__ASSERT(decoder->private_ != 0);
 128
 129         free(decoder->private_);
 130         free(decoder->protected_);
 131         free(decoder);
 132 }
 133
 134 /***********************************************************************
 135  *
 136  * Public class methods
 137  *
 138  ***********************************************************************/
 139
 140 FLAC__FileDecoderState FLAC__file_decoder_init(FLAC__FileDecoder *decoder)
 141 {
 142         FLAC__ASSERT(decoder != 0);
 143
 144         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 145                 return decoder->protected_->state = FLAC__FILE_DECODER_ALREADY_INITIALIZED;
 146
 147         decoder->protected_->state = FLAC__FILE_DECODER_OK;
 148
 149         if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
 150                 return decoder->protected_->state = FLAC__FILE_DECODER_INVALID_CALLBACK;
 151
 152         decoder->private_->file = 0;
 153         decoder->private_->seekable_stream_decoder = 0;
 154
 155         if(0 == decoder->private_->filename)
 156                 decoder->private_->file = stdin;
 157         else
 158                 decoder->private_->file = fopen(decoder->private_->filename, "rb");
 159
 160         if(decoder->private_->file == 0)
 161                 return decoder->protected_->state = FLAC__FILE_DECODER_ERROR_OPENING_FILE;
 162
 163         decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
 164
 165         if(0 == decoder->private_->seekable_stream_decoder)
 166                 return decoder->protected_->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
 167
 168         FLAC__seekable_stream_decoder_set_read_callback(decoder->private_->seekable_stream_decoder, read_callback_);
 169         FLAC__seekable_stream_decoder_set_seek_callback(decoder->private_->seekable_stream_decoder, seek_callback_);
 170         FLAC__seekable_stream_decoder_set_tell_callback(decoder->private_->seekable_stream_decoder, tell_callback_);
 171         FLAC__seekable_stream_decoder_set_length_callback(decoder->private_->seekable_stream_decoder, length_callback_);
 172         FLAC__seekable_stream_decoder_set_eof_callback(decoder->private_->seekable_stream_decoder, eof_callback_);
 173         FLAC__seekable_stream_decoder_set_write_callback(decoder->private_->seekable_stream_decoder, write_callback_);
 174         FLAC__seekable_stream_decoder_set_metadata_callback(decoder->private_->seekable_stream_decoder, metadata_callback_);
 175         FLAC__seekable_stream_decoder_set_error_callback(decoder->private_->seekable_stream_decoder, error_callback_);
 176         FLAC__seekable_stream_decoder_set_client_data(decoder->private_->seekable_stream_decoder, decoder);
 177
 178         /*
 179          * Unfortunately, because of the "_new() ... _set_() ... _init()" order of
 180          * decoder initialization, settings that are 'inherited' from the superclass
 181          * have to be passed up this way, because the superclass has not even been
 182          * created yet when the value is set in the subclass.
 183          */
 184         (void)FLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, decoder->private_->init_values_for_superclass.md5_checking);
 185
 186         if(FLAC__seekable_stream_decoder_init(decoder->private_->seekable_stream_decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
 187                 return decoder->protected_->state = FLAC__FILE_DECODER_STREAM_DECODER_ERROR; /*@@@ change this to FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR in next minor-revision */
 188
 189         return decoder->protected_->state;
 190 }
 191
 192 FLAC__bool FLAC__file_decoder_finish(FLAC__FileDecoder *decoder)
 193 {
 194         FLAC__bool ok = true;
 195
 196         FLAC__ASSERT(decoder != 0);
 197         if(decoder->protected_->state == FLAC__FILE_DECODER_UNINITIALIZED)
 198                 return true;
 199         if(decoder->private_->file != 0 && decoder->private_->file != stdin)
 200                 fclose(decoder->private_->file);
 201         if(0 != decoder->private_->filename) {
 202                 free(decoder->private_->filename);
 203                 decoder->private_->filename = 0;
 204         }
 205         if(decoder->private_->seekable_stream_decoder != 0) {
 206                 ok = FLAC__seekable_stream_decoder_finish(decoder->private_->seekable_stream_decoder);
 207                 FLAC__seekable_stream_decoder_delete(decoder->private_->seekable_stream_decoder);
 208         }
 209         decoder->protected_->state = FLAC__FILE_DECODER_UNINITIALIZED;
 210         return ok;
 211 }
 212
 213 FLAC__bool FLAC__file_decoder_set_md5_checking(const FLAC__FileDecoder *decoder, FLAC__bool value)
 214 {
 215         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 216                 return false;
 217         decoder->private_->init_values_for_superclass.md5_checking = value;
 218         return true;
 219 }
 220
 221 FLAC__bool FLAC__file_decoder_set_filename(const FLAC__FileDecoder *decoder, const char *value)
 222 {
 223         FLAC__ASSERT(value != 0);
 224         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 225                 return false;
 226         if(0 != decoder->private_->filename) {
 227                 free(decoder->private_->filename);
 228                 decoder->private_->filename = 0;
 229         }
 230         if(0 != strcmp(value, "-")) {
 231                 if(0 == (decoder->private_->filename = (char*)malloc(strlen(value)+1))) {
 232                         decoder->protected_->state = FLAC__FILE_DECODER_MEMORY_ALLOCATION_ERROR;
 233                         return false;
 234                 }
 235                 strcpy(decoder->private_->filename, value);
 236         }
 237         return true;
 238 }
 239
 240 FLAC__bool FLAC__file_decoder_set_write_callback(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data))
 241 {
 242         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 243                 return false;
 244         decoder->private_->write_callback = value;
 245         return true;
 246 }
 247
 248 FLAC__bool FLAC__file_decoder_set_metadata_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
 249 {
 250         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 251                 return false;
 252         decoder->private_->metadata_callback = value;
 253         return true;
 254 }
 255
 256 FLAC__bool FLAC__file_decoder_set_error_callback(const FLAC__FileDecoder *decoder, void (*value)(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
 257 {
 258         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 259                 return false;
 260         decoder->private_->error_callback = value;
 261         return true;
 262 }
 263
 264 FLAC__bool FLAC__file_decoder_set_client_data(const FLAC__FileDecoder *decoder, void *value)
 265 {
 266         if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
 267                 return false;
 268         decoder->private_->client_data = value;
 269         return true;
 270 }
 271
 272 FLAC__FileDecoderState FLAC__file_decoder_get_state(const FLAC__FileDecoder *decoder)
 273 {
 274         return decoder->protected_->state;
 275 }
 276
 277 FLAC__bool FLAC__file_decoder_get_md5_checking(const FLAC__FileDecoder *decoder)
 278 {
 279         return FLAC__seekable_stream_decoder_get_md5_checking(decoder->private_->seekable_stream_decoder);
 280 }
 281
 282 FLAC__bool FLAC__file_decoder_process_whole_file(FLAC__FileDecoder *decoder)
 283 {
 284         FLAC__bool ret;
 285         FLAC__ASSERT(decoder != 0);
 286
 287         if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 288                 decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
 289
 290         if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
 291                 return true;
 292
 293         FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 294
 295         ret = FLAC__seekable_stream_decoder_process_whole_stream(decoder->private_->seekable_stream_decoder);
 296         if(!ret)
 297                 decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
 298
 299         return ret;
 300 }
 301
 302 FLAC__bool FLAC__file_decoder_process_metadata(FLAC__FileDecoder *decoder)
 303 {
 304         FLAC__bool ret;
 305         FLAC__ASSERT(decoder != 0);
 306
 307         if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 308                 decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
 309
 310         if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
 311                 return true;
 312
 313         FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 314
 315         ret = FLAC__seekable_stream_decoder_process_metadata(decoder->private_->seekable_stream_decoder);
 316         if(!ret)
 317                 decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
 318
 319         return ret;
 320 }
 321
 322 FLAC__bool FLAC__file_decoder_process_one_frame(FLAC__FileDecoder *decoder)
 323 {
 324         FLAC__bool ret;
 325         FLAC__ASSERT(decoder != 0);
 326
 327         if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 328                 decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
 329
 330         if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
 331                 return true;
 332
 333         FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 334
 335         ret = FLAC__seekable_stream_decoder_process_one_frame(decoder->private_->seekable_stream_decoder);
 336         if(!ret)
 337                 decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
 338
 339         return ret;
 340 }
 341
 342 FLAC__bool FLAC__file_decoder_process_remaining_frames(FLAC__FileDecoder *decoder)
 343 {
 344         FLAC__bool ret;
 345         FLAC__ASSERT(decoder != 0);
 346
 347         if(decoder->private_->seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 348                 decoder->protected_->state = FLAC__FILE_DECODER_END_OF_FILE;
 349
 350         if(decoder->protected_->state == FLAC__FILE_DECODER_END_OF_FILE)
 351                 return true;
 352
 353         FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 354
 355         ret = FLAC__seekable_stream_decoder_process_remaining_frames(decoder->private_->seekable_stream_decoder);
 356         if(!ret)
 357                 decoder->protected_->state = FLAC__FILE_DECODER_SEEKABLE_STREAM_ERROR;
 358
 359         return ret;
 360 }
 361
 362 /***********************************************************************
 363  *
 364  * Private class methods
 365  *
 366  ***********************************************************************/
 367
 368 FLAC__bool FLAC__file_decoder_seek_absolute(FLAC__FileDecoder *decoder, FLAC__uint64 sample)
 369 {
 370         FLAC__ASSERT(decoder != 0);
 371         FLAC__ASSERT(decoder->protected_->state == FLAC__FILE_DECODER_OK);
 372
 373         if(decoder->private_->filename == 0) { /* means the file is stdin... */
 374                 decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
 375                 return false;
 376         }
 377
 378         if(!FLAC__seekable_stream_decoder_seek_absolute(decoder->private_->seekable_stream_decoder, sample)) {
 379                 decoder->protected_->state = FLAC__FILE_DECODER_SEEK_ERROR;
 380                 return false;
 381         }
 382         else
 383                 return true;
 384 }
 385
 386 FLAC__SeekableStreamDecoderReadStatus read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 387 {
 388         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 389         (void)decoder;
 390
 391         if(*bytes > 0) {
 392                 size_t bytes_read = fread(buffer, sizeof(FLAC__byte), *bytes, file_decoder->private_->file);
 393                 if(bytes_read == 0 && !feof(file_decoder->private_->file)) {
 394                         return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
 395                 }
 396                 else {
 397                         *bytes = (unsigned)bytes_read;
 398                         return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
 399                 }
 400         }
 401         else
 402                 return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR; /* abort to avoid a deadlock */
 403 }
 404
 405 FLAC__SeekableStreamDecoderSeekStatus seek_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 406 {
 407         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 408         (void)decoder;
 409
 410         if(fseek(file_decoder->private_->file, (long)absolute_byte_offset, SEEK_SET) < 0)
 411                 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
 412         else
 413                 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
 414 }
 415
 416 FLAC__SeekableStreamDecoderTellStatus tell_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 417 {
 418         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 419         long pos;
 420         (void)decoder;
 421
 422         if((pos = ftell(file_decoder->private_->file)) < 0)
 423                 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
 424         else {
 425                 *absolute_byte_offset = (FLAC__uint64)pos;
 426                 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
 427         }
 428 }
 429
 430 FLAC__SeekableStreamDecoderLengthStatus length_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 431 {
 432         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 433         struct stat filestats;
 434         (void)decoder;
 435
 436         if(0 == file_decoder->private_->filename || stat(file_decoder->private_->filename, &filestats) != 0)
 437                 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
 438         else {
 439                 *stream_length = (FLAC__uint64)filestats.st_size;
 440                 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
 441         }
 442 }
 443
 444 FLAC__bool eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *client_data)
 445 {
 446         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 447         (void)decoder;
 448
 449         return feof(file_decoder->private_->file);
 450 }
 451
 452 FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
 453 {
 454         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 455         (void)decoder;
 456
 457         return file_decoder->private_->write_callback(file_decoder, frame, buffer, file_decoder->private_->client_data);
 458 }
 459
 460 void metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
 461 {
 462         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 463         (void)decoder;
 464
 465         file_decoder->private_->metadata_callback(file_decoder, metadata, file_decoder->private_->client_data);
 466 }
 467
 468 void error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 469 {
 470         FLAC__FileDecoder *file_decoder = (FLAC__FileDecoder *)client_data;
 471         (void)decoder;
 472
 473         file_decoder->private_->error_callback(file_decoder, status, file_decoder->private_->client_data);
 474 }