src/libFLAC/seekable_stream_decoder.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2000,2001  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 "FLAC/assert.h"
  23 #include "protected/seekable_stream_decoder.h"
  24 #include "protected/stream_decoder.h"
  25 #include "private/md5.h"
  26
  27 /***********************************************************************
  28  *
  29  * Private class method prototypes
  30  *
  31  ***********************************************************************/
  32
  33 static FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  34 static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
  35 static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
  36 static void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  37 static FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample);
  38
  39 /***********************************************************************
  40  *
  41  * Private class data
  42  *
  43  ***********************************************************************/
  44
  45 typedef struct FLAC__SeekableStreamDecoderPrivate {
  46         FLAC__SeekableStreamDecoderReadStatus (*read_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  47         FLAC__SeekableStreamDecoderSeekStatus (*seek_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
  48         FLAC__SeekableStreamDecoderTellStatus (*tell_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
  49         FLAC__SeekableStreamDecoderLengthStatus (*length_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
  50         FLAC__bool (*eof_callback)(const FLAC__SeekableStreamDecoder *decoder, void *client_data);
  51         FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data);
  52         void (*metadata_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data);
  53         void (*error_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  54         void *client_data;
  55         FLAC__StreamDecoder *stream_decoder;
  56         struct MD5Context md5context;
  57         FLAC__byte stored_md5sum[16]; /* this is what is stored in the metadata */
  58         FLAC__byte computed_md5sum[16]; /* this is the sum we computed from the decoded data */
  59         /* the rest of these are only used for seeking: */
  60         FLAC__StreamMetaData_StreamInfo stream_info; /* we keep this around so we can figure out how to seek quickly */
  61         const FLAC__StreamMetaData_SeekTable *seek_table; /* we hold a pointer to the stream decoder's seek table for the same reason */
  62         FLAC__Frame last_frame; /* holds the info of the last frame we seeked to */
  63         FLAC__uint64 target_sample;
  64 } FLAC__SeekableStreamDecoderPrivate;
  65
  66 /***********************************************************************
  67  *
  68  * Public static class data
  69  *
  70  ***********************************************************************/
  71
  72 const char *FLAC__SeekableStreamDecoderStateString[] = {
  73         "FLAC__SEEKABLE_STREAM_DECODER_OK",
  74         "FLAC__SEEKABLE_STREAM_DECODER_SEEKING",
  75         "FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM",
  76         "FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR",
  77         "FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR",
  78         "FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR",
  79         "FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR",
  80     "FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED",
  81     "FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK",
  82     "FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED"
  83 };
  84
  85 const char *FLAC__SeekableStreamDecoderReadStatusString[] = {
  86         "FLAC__STREAM_DECODER_READ_STATUS_OK",
  87         "FLAC__STREAM_DECODER_READ_STATUS_ERROR"
  88 };
  89
  90 const char *FLAC__SeekableStreamDecoderSeekStatusString[] = {
  91         "FLAC__STREAM_DECODER_SEEK_STATUS_OK",
  92         "FLAC__STREAM_DECODER_SEEK_STATUS_ERROR"
  93 };
  94
  95 const char *FLAC__SeekableStreamDecoderTellStatusString[] = {
  96         "FLAC__STREAM_DECODER_TELL_STATUS_OK",
  97         "FLAC__STREAM_DECODER_TELL_STATUS_ERROR"
  98 };
  99
 100 const char *FLAC__SeekableStreamDecoderLengthStatusString[] = {
 101         "FLAC__STREAM_DECODER_LENGTH_STATUS_OK",
 102         "FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR"
 103 };
 104
 105 /***********************************************************************
 106  *
 107  * Class constructor/destructor
 108  *
 109  ***********************************************************************/
 110
 111 FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
 112 {
 113         FLAC__SeekableStreamDecoder *decoder;
 114
 115         FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 116
 117         decoder = (FLAC__SeekableStreamDecoder*)malloc(sizeof(FLAC__SeekableStreamDecoder));
 118         if(decoder == 0) {
 119                 return 0;
 120         }
 121         decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
 122         if(decoder->protected_ == 0) {
 123                 free(decoder);
 124                 return 0;
 125         }
 126         decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
 127         if(decoder->private_ == 0) {
 128                 free(decoder->protected_);
 129                 free(decoder);
 130                 return 0;
 131         }
 132
 133         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 134
 135         decoder->private_->read_callback = 0;
 136         decoder->private_->seek_callback = 0;
 137         decoder->private_->tell_callback = 0;
 138         decoder->private_->length_callback = 0;
 139         decoder->private_->eof_callback = 0;
 140         decoder->private_->write_callback = 0;
 141         decoder->private_->metadata_callback = 0;
 142         decoder->private_->error_callback = 0;
 143         decoder->private_->client_data = 0;
 144
 145         return decoder;
 146 }
 147
 148 void FLAC__seekable_stream_decoder_delete(FLAC__SeekableStreamDecoder *decoder)
 149 {
 150         FLAC__ASSERT(decoder != 0);
 151         FLAC__ASSERT(decoder->protected_ != 0);
 152         FLAC__ASSERT(decoder->private_ != 0);
 153
 154         free(decoder->private_);
 155         free(decoder->protected_);
 156         free(decoder);
 157 }
 158
 159 /***********************************************************************
 160  *
 161  * Public class methods
 162  *
 163  ***********************************************************************/
 164
 165 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_init(FLAC__SeekableStreamDecoder *decoder)
 166 {
 167         FLAC__ASSERT(decoder != 0);
 168
 169         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 170                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED;
 171
 172         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
 173
 174         if(0 == decoder->private_->read_callback || 0 == decoder->private_->seek_callback || 0 == decoder->private_->tell_callback || 0 == decoder->private_->length_callback || 0 == decoder->private_->eof_callback)
 175                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK;
 176
 177         if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
 178                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK;
 179
 180         decoder->private_->stream_decoder = 0;
 181         decoder->private_->seek_table = 0;
 182
 183         /* We initialize the MD5Context even though we may never use it.  This is
 184          * because md5_checking may be turned on to start and then turned off if a
 185          * seek occurs.  So we always init the context here and finalize it in
 186          * FLAC__seekable_stream_decoder_finish() to make sure things are always
 187          * cleaned up properly.
 188          */
 189         MD5Init(&decoder->private_->md5context);
 190
 191         decoder->private_->stream_decoder = FLAC__stream_decoder_new();
 192
 193         if(0 == decoder->private_->stream_decoder)
 194                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR;
 195
 196         FLAC__stream_decoder_set_read_callback(decoder->private_->stream_decoder, read_callback_);
 197         FLAC__stream_decoder_set_write_callback(decoder->private_->stream_decoder, write_callback_);
 198         FLAC__stream_decoder_set_metadata_callback(decoder->private_->stream_decoder, metadata_callback_);
 199         FLAC__stream_decoder_set_error_callback(decoder->private_->stream_decoder, error_callback_);
 200         FLAC__stream_decoder_set_client_data(decoder->private_->stream_decoder, decoder);
 201
 202         if(FLAC__stream_decoder_init(decoder->private_->stream_decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 203                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 204
 205         return decoder->protected_->state;
 206 }
 207
 208 FLAC__bool FLAC__seekable_stream_decoder_finish(FLAC__SeekableStreamDecoder *decoder)
 209 {
 210         FLAC__bool md5_failed = false;
 211
 212         FLAC__ASSERT(decoder != 0);
 213         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 214                 return true;
 215         /* see the comment in FLAC__seekable_stream_decoder_init() as to why we
 216          * always call MD5Final()
 217          */
 218         MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context);
 219         if(decoder->private_->stream_decoder != 0) {
 220                 FLAC__stream_decoder_finish(decoder->private_->stream_decoder);
 221                 FLAC__stream_decoder_delete(decoder->private_->stream_decoder);
 222         }
 223         if(decoder->protected_->md5_checking) {
 224                 if(memcmp(decoder->private_->stored_md5sum, decoder->private_->computed_md5sum, 16))
 225                         md5_failed = true;
 226         }
 227         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 228         return !md5_failed;
 229 }
 230
 231 FLAC__bool FLAC__seekable_stream_decoder_set_md5_checking(const FLAC__SeekableStreamDecoder *decoder, FLAC__bool value)
 232 {
 233         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 234                 return false;
 235         decoder->protected_->md5_checking = value;
 236         return true;
 237 }
 238
 239 FLAC__bool FLAC__seekable_stream_decoder_set_read_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderReadStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data))
 240 {
 241         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 242                 return false;
 243         decoder->private_->read_callback = value;
 244         return true;
 245 }
 246
 247 FLAC__bool FLAC__seekable_stream_decoder_set_seek_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderSeekStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data))
 248 {
 249         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 250                 return false;
 251         decoder->private_->seek_callback = value;
 252         return true;
 253 }
 254
 255 FLAC__bool FLAC__seekable_stream_decoder_set_tell_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderTellStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data))
 256 {
 257         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 258                 return false;
 259         decoder->private_->tell_callback = value;
 260         return true;
 261 }
 262
 263 FLAC__bool FLAC__seekable_stream_decoder_set_length_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderLengthStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data))
 264 {
 265         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 266                 return false;
 267         decoder->private_->length_callback = value;
 268         return true;
 269 }
 270
 271 FLAC__bool FLAC__seekable_stream_decoder_set_eof_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__bool (*value)(const FLAC__SeekableStreamDecoder *decoder, void *client_data))
 272 {
 273         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 274                 return false;
 275         decoder->private_->eof_callback = value;
 276         return true;
 277 }
 278
 279 FLAC__bool FLAC__seekable_stream_decoder_set_write_callback(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data))
 280 {
 281         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 282                 return false;
 283         decoder->private_->write_callback = value;
 284         return true;
 285 }
 286
 287 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_callback(const FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data))
 288 {
 289         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 290                 return false;
 291         decoder->private_->metadata_callback = value;
 292         return true;
 293 }
 294
 295 FLAC__bool FLAC__seekable_stream_decoder_set_error_callback(const FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
 296 {
 297         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 298                 return false;
 299         decoder->private_->error_callback = value;
 300         return true;
 301 }
 302
 303 FLAC__bool FLAC__seekable_stream_decoder_set_client_data(const FLAC__SeekableStreamDecoder *decoder, void *value)
 304 {
 305         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 306                 return false;
 307         decoder->private_->client_data = value;
 308         return true;
 309 }
 310
 311 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_get_state(const FLAC__SeekableStreamDecoder *decoder)
 312 {
 313         return decoder->protected_->state;
 314 }
 315
 316 FLAC__bool FLAC__seekable_stream_decoder_get_md5_checking(const FLAC__SeekableStreamDecoder *decoder)
 317 {
 318         return decoder->protected_->md5_checking;
 319 }
 320
 321 FLAC__bool FLAC__seekable_stream_decoder_process_whole_stream(FLAC__SeekableStreamDecoder *decoder)
 322 {
 323         FLAC__bool ret;
 324         FLAC__ASSERT(decoder != 0);
 325
 326         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 327                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 328
 329         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 330                 return true;
 331
 332         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 333
 334         ret = FLAC__stream_decoder_process_whole_stream(decoder->private_->stream_decoder);
 335         if(!ret)
 336                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 337
 338         return ret;
 339 }
 340
 341 FLAC__bool FLAC__seekable_stream_decoder_process_metadata(FLAC__SeekableStreamDecoder *decoder)
 342 {
 343         FLAC__bool ret;
 344         FLAC__ASSERT(decoder != 0);
 345
 346         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 347                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 348
 349         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 350                 return true;
 351
 352         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 353
 354         ret = FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder);
 355         if(!ret)
 356                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 357
 358         return ret;
 359 }
 360
 361 FLAC__bool FLAC__seekable_stream_decoder_process_one_frame(FLAC__SeekableStreamDecoder *decoder)
 362 {
 363         FLAC__bool ret;
 364         FLAC__ASSERT(decoder != 0);
 365
 366         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 367                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 368
 369         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 370                 return true;
 371
 372         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 373
 374         ret = FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder);
 375         if(!ret)
 376                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 377
 378         return ret;
 379 }
 380
 381 FLAC__bool FLAC__seekable_stream_decoder_process_remaining_frames(FLAC__SeekableStreamDecoder *decoder)
 382 {
 383         FLAC__bool ret;
 384         FLAC__ASSERT(decoder != 0);
 385
 386         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 387                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 388
 389         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 390                 return true;
 391
 392         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 393
 394         ret = FLAC__stream_decoder_process_remaining_frames(decoder->private_->stream_decoder);
 395         if(!ret)
 396                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 397
 398         return ret;
 399 }
 400
 401 FLAC__bool FLAC__seekable_stream_decoder_seek_absolute(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 sample)
 402 {
 403         FLAC__uint64 length;
 404
 405         FLAC__ASSERT(decoder != 0);
 406         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 407
 408         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEKING;
 409
 410         /* turn off md5 checking if a seek is attempted */
 411         decoder->protected_->md5_checking = false;
 412
 413         if(!FLAC__stream_decoder_reset(decoder->private_->stream_decoder)) {
 414                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 415                 return false;
 416         }
 417         /* get the file length */
 418         if(decoder->private_->length_callback(decoder, &length, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK) {
 419                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 420                 return false;
 421         }
 422         /* rewind */
 423         if(decoder->private_->seek_callback(decoder, 0, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK) {
 424                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 425                 return false;
 426         }
 427         if(!FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder)) {
 428                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 429                 return false;
 430         }
 431         if(sample > decoder->private_->stream_info.total_samples) {
 432                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 433                 return false;
 434         }
 435
 436         return seek_to_absolute_sample_(decoder, length, sample);
 437 }
 438
 439 /***********************************************************************
 440  *
 441  * Private class methods
 442  *
 443  ***********************************************************************/
 444
 445 FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 446 {
 447         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 448         (void)decoder;
 449         if(seekable_stream_decoder->private_->eof_callback(seekable_stream_decoder, seekable_stream_decoder->private_->client_data)) {
 450                 seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 451                 return FLAC__STREAM_DECODER_READ_END_OF_STREAM;
 452         }
 453         else if(*bytes > 0) {
 454                 unsigned bytes_read = *bytes;
 455                 if(seekable_stream_decoder->private_->read_callback(seekable_stream_decoder, buffer, &bytes_read, seekable_stream_decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK) {
 456                         seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR;
 457                         return FLAC__STREAM_DECODER_READ_ABORT;
 458                 }
 459                 if(bytes_read == 0) {
 460                         if(seekable_stream_decoder->private_->eof_callback(seekable_stream_decoder, seekable_stream_decoder->private_->client_data)) {
 461                                 seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 462                                 return FLAC__STREAM_DECODER_READ_END_OF_STREAM;
 463                         }
 464                         else
 465                                 return FLAC__STREAM_DECODER_READ_CONTINUE;
 466                 }
 467                 else {
 468                         *bytes = bytes_read;
 469                         return FLAC__STREAM_DECODER_READ_CONTINUE;
 470                 }
 471         }
 472         else
 473                 return FLAC__STREAM_DECODER_READ_ABORT; /* abort to avoid a deadlock */
 474 }
 475
 476 FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *buffer[], void *client_data)
 477 {
 478         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 479         (void)decoder;
 480
 481         if(seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
 482                 FLAC__uint64 this_frame_sample = frame->header.number.sample_number;
 483                 FLAC__uint64 next_frame_sample = this_frame_sample + (FLAC__uint64)frame->header.blocksize;
 484                 FLAC__uint64 target_sample = seekable_stream_decoder->private_->target_sample;
 485
 486                 FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
 487
 488                 seekable_stream_decoder->private_->last_frame = *frame; /* save the frame */
 489                 if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */
 490                         unsigned delta = (unsigned)(target_sample - this_frame_sample);
 491                         /* kick out of seek mode */
 492                         seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
 493                         /* shift out the samples before target_sample */
 494                         if(delta > 0) {
 495                                 unsigned channel;
 496                                 const FLAC__int32 *newbuffer[FLAC__MAX_CHANNELS];
 497                                 for(channel = 0; channel < frame->header.channels; channel++)
 498                                         newbuffer[channel] = buffer[channel] + delta;
 499                                 seekable_stream_decoder->private_->last_frame.header.blocksize -= delta;
 500                                 seekable_stream_decoder->private_->last_frame.header.number.sample_number += (FLAC__uint64)delta;
 501                                 /* write the relevant samples */
 502                                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, &seekable_stream_decoder->private_->last_frame, newbuffer, seekable_stream_decoder->private_->client_data);
 503                         }
 504                         else {
 505                                 /* write the relevant samples */
 506                                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, frame, buffer, seekable_stream_decoder->private_->client_data);
 507                         }
 508                 }
 509                 else {
 510                         return FLAC__STREAM_DECODER_WRITE_CONTINUE;
 511                 }
 512         }
 513         else {
 514                 if(seekable_stream_decoder->protected_->md5_checking) {
 515                         if(!FLAC__MD5Accumulate(&seekable_stream_decoder->private_->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8))
 516                                 return FLAC__STREAM_DECODER_WRITE_ABORT;
 517                 }
 518                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, frame, buffer, seekable_stream_decoder->private_->client_data);
 519         }
 520 }
 521
 522 void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetaData *metadata, void *client_data)
 523 {
 524         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 525         (void)decoder;
 526
 527         if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
 528                 seekable_stream_decoder->private_->stream_info = metadata->data.stream_info;
 529                 /* save the MD5 signature for comparison later */
 530                 memcpy(seekable_stream_decoder->private_->stored_md5sum, metadata->data.stream_info.md5sum, 16);
 531                 if(0 == memcmp(seekable_stream_decoder->private_->stored_md5sum, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16))
 532                         seekable_stream_decoder->protected_->md5_checking = false;
 533         }
 534         else if(metadata->type == FLAC__METADATA_TYPE_SEEKTABLE) {
 535                 seekable_stream_decoder->private_->seek_table = &metadata->data.seek_table;
 536         }
 537
 538         if(seekable_stream_decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING)
 539                 seekable_stream_decoder->private_->metadata_callback(seekable_stream_decoder, metadata, seekable_stream_decoder->private_->client_data);
 540 }
 541
 542 void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 543 {
 544         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 545         (void)decoder;
 546
 547         if(seekable_stream_decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING)
 548                 seekable_stream_decoder->private_->error_callback(seekable_stream_decoder, status, seekable_stream_decoder->private_->client_data);
 549 }
 550
 551 FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample)
 552 {
 553         FLAC__uint64 first_frame_offset, lower_bound, upper_bound;
 554         FLAC__int64 pos = -1, last_pos = -1;
 555         int i, lower_seek_point = -1, upper_seek_point = -1;
 556         unsigned approx_bytes_per_frame;
 557         FLAC__uint64 last_frame_sample = 0xffffffffffffffff;
 558         FLAC__bool needs_seek;
 559         const FLAC__bool is_variable_blocksize_stream = (decoder->private_->stream_info.min_blocksize != decoder->private_->stream_info.max_blocksize);
 560
 561         /* we are just guessing here, but we want to guess high, not low */
 562         if(decoder->private_->stream_info.max_framesize > 0) {
 563                 approx_bytes_per_frame = decoder->private_->stream_info.max_framesize;
 564         }
 565         else if(!is_variable_blocksize_stream) {
 566                 /* note there are no () around 'decoder->private_->stream_info.bits_per_sample/8' to keep precision up since it's an integer calulation */
 567                 approx_bytes_per_frame = decoder->private_->stream_info.min_blocksize * decoder->private_->stream_info.channels * decoder->private_->stream_info.bits_per_sample/8 + 64;
 568         }
 569         else
 570                 approx_bytes_per_frame = 1152 * decoder->private_->stream_info.channels * decoder->private_->stream_info.bits_per_sample/8 + 64;
 571
 572         /*
 573          * The stream position is currently at the first frame plus any read
 574          * ahead data, so first we get the stream position, then subtract
 575          * uncomsumed bytes to get the position of the first frame in the
 576          * stream.
 577          */
 578         if(decoder->private_->tell_callback(decoder, &first_frame_offset, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
 579                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 580                 return false;
 581         }
 582         FLAC__ASSERT(first_frame_offset >= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder));
 583         first_frame_offset -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder);
 584
 585         /*
 586          * First, we set an upper and lower bound on where in the
 587          * stream we will search.  For now we assume the worst case
 588          * scenario, which is our best guess at the beginning of
 589          * the first and last frames.
 590          */
 591         lower_bound = first_frame_offset;
 592
 593         /* calc the upper_bound, beyond which we never want to seek */
 594         if(decoder->private_->stream_info.max_framesize > 0)
 595                 upper_bound = stream_length - (decoder->private_->stream_info.max_framesize + 128 + 2); /* 128 for a possible ID3V1 tag, 2 for indexing differences */
 596         else
 597                 upper_bound = stream_length - ((decoder->private_->stream_info.channels * decoder->private_->stream_info.bits_per_sample * FLAC__MAX_BLOCK_SIZE) / 8 + 128 + 2);
 598
 599         /*
 600          * Now we refine the bounds if we have a seektable with
 601          * suitable points.  Note that according to the spec they
 602          * must be ordered by ascending sample number.
 603          */
 604         if(0 != decoder->private_->seek_table) {
 605                 /* find the closest seek point <= target_sample, if it exists */
 606                 for(i = (int)decoder->private_->seek_table->num_points - 1; i >= 0; i--) {
 607                         if(decoder->private_->seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER && decoder->private_->seek_table->points[i].sample_number <= target_sample)
 608                                 break;
 609                 }
 610                 if(i >= 0) { /* i.e. we found a suitable seek point... */
 611                         lower_bound = first_frame_offset + decoder->private_->seek_table->points[i].stream_offset;
 612                         lower_seek_point = i;
 613                 }
 614
 615                 /* find the closest seek point > target_sample, if it exists */
 616                 for(i = 0; i < (int)decoder->private_->seek_table->num_points; i++) {
 617                         if(decoder->private_->seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER && decoder->private_->seek_table->points[i].sample_number > target_sample)
 618                                 break;
 619                 }
 620                 if(i < (int)decoder->private_->seek_table->num_points) { /* i.e. we found a suitable seek point... */
 621                         upper_bound = first_frame_offset + decoder->private_->seek_table->points[i].stream_offset;
 622                         upper_seek_point = i;
 623                 }
 624         }
 625
 626         /*
 627          * Now guess at where within those bounds our target
 628          * sample will be.
 629          */
 630         if(lower_seek_point >= 0) {
 631                 /* first see if our sample is within a few frames of the lower seekpoint */
 632                 if(decoder->private_->seek_table->points[lower_seek_point].sample_number <= target_sample && target_sample < decoder->private_->seek_table->points[lower_seek_point].sample_number + (decoder->private_->seek_table->points[lower_seek_point].frame_samples * 4)) {
 633                         pos = (FLAC__int64)lower_bound;
 634                 }
 635                 else if(upper_seek_point >= 0) {
 636                         const FLAC__uint64 target_offset = target_sample - decoder->private_->seek_table->points[lower_seek_point].sample_number;
 637                         const FLAC__uint64 range_samples = decoder->private_->seek_table->points[upper_seek_point].sample_number - decoder->private_->seek_table->points[lower_seek_point].sample_number;
 638                         const FLAC__uint64 range_bytes = upper_bound - lower_bound;
 639 #if defined _MSC_VER || defined __MINGW32__
 640                         /* with VC++ you have to spoon feed it the casting */
 641                         pos = (FLAC__int64)lower_bound + (FLAC__int64)((double)(FLAC__int64)target_offset / (double)(FLAC__int64)range_samples * (double)(FLAC__int64)(range_bytes-1)) - approx_bytes_per_frame;
 642 #else
 643                         pos = (FLAC__int64)lower_bound + (FLAC__int64)((double)target_offset / (double)range_samples * (double)(range_bytes-1)) - approx_bytes_per_frame;
 644 #endif
 645                 }
 646         }
 647         if(pos < 0) {
 648                 /* We need to use the metadata and the filelength to estimate the position of the frame with the correct sample */
 649 #if defined _MSC_VER || defined __MINGW32__
 650                 /* with VC++ you have to spoon feed it the casting */
 651                 pos = (FLAC__int64)first_frame_offset + (FLAC__int64)((double)(FLAC__int64)target_sample / (double)(FLAC__int64)decoder->private_->stream_info.total_samples * (double)(FLAC__int64)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
 652 #else
 653                 pos = (FLAC__int64)first_frame_offset + (FLAC__int64)((double)target_sample / (double)decoder->private_->stream_info.total_samples * (double)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
 654 #endif
 655         }
 656
 657         /* clip the position to the bounds, lower bound takes precedence */
 658         if(pos >= (FLAC__int64)upper_bound)
 659                 pos = (FLAC__int64)upper_bound-1;
 660         if(pos < (FLAC__int64)lower_bound)
 661                 pos = (FLAC__int64)lower_bound;
 662         needs_seek = true;
 663
 664         decoder->private_->target_sample = target_sample;
 665         while(1) {
 666                 if(needs_seek) {
 667                         if(decoder->private_->seek_callback(decoder, (FLAC__uint64)pos, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK) {
 668                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 669                                 return false;
 670                         }
 671                         if(!FLAC__stream_decoder_flush(decoder->private_->stream_decoder)) {
 672                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_ERROR;
 673                                 return false;
 674                         }
 675                 }
 676                 if(!FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder)) {
 677                         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 678                         return false;
 679                 }
 680                 /* our write callback will change the state when it gets to the target frame */
 681                 if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
 682                         break;
 683                 }
 684                 else { /* we need to narrow the search */
 685                         FLAC__uint64 this_frame_sample = decoder->private_->last_frame.header.number.sample_number;
 686                         FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
 687                         if(this_frame_sample == last_frame_sample) {
 688                                 /* our last move backwards wasn't big enough */
 689                                 pos -= (last_pos - pos);
 690                                 needs_seek = true;
 691                         }
 692                         else {
 693                                 if(target_sample < this_frame_sample) {
 694                                         last_pos = pos;
 695                                         approx_bytes_per_frame = decoder->private_->last_frame.header.blocksize * decoder->private_->last_frame.header.channels * decoder->private_->last_frame.header.bits_per_sample/8 + 64;
 696                                         pos -= approx_bytes_per_frame;
 697                                         needs_seek = true;
 698                                 }
 699                                 else { /* target_sample >= this_frame_sample + this frame's blocksize */
 700                                         last_pos = pos;
 701                                         if(decoder->private_->tell_callback(decoder, (FLAC__uint64*)(&pos), decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
 702                                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 703                                                 return false;
 704                                         }
 705                                         pos -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder);
 706                                         needs_seek = false;
 707                                 }
 708                         }
 709                         if(pos < (FLAC__int64)lower_bound)
 710                                 pos = (FLAC__int64)lower_bound;
 711                         last_frame_sample = this_frame_sample;
 712                 }
 713         }
 714
 715         return true;
 716 }