src/libFLAC/seekable_stream_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 memcpy()/memcmp() */
  23 #include "FLAC/assert.h"
  24 #include "protected/seekable_stream_decoder.h"
  25 #include "protected/stream_decoder.h"
  26 #include "private/md5.h"
  27
  28 /***********************************************************************
  29  *
  30  * Private class method prototypes
  31  *
  32  ***********************************************************************/
  33
  34 static void seekable_stream_decoder_set_defaults_(FLAC__SeekableStreamDecoder *decoder);
  35 static FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  36 static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
  37 static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
  38 static void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  39 static FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample);
  40
  41 /***********************************************************************
  42  *
  43  * Private class data
  44  *
  45  ***********************************************************************/
  46
  47 typedef struct FLAC__SeekableStreamDecoderPrivate {
  48         FLAC__SeekableStreamDecoderReadStatus (*read_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
  49         FLAC__SeekableStreamDecoderSeekStatus (*seek_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
  50         FLAC__SeekableStreamDecoderTellStatus (*tell_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
  51         FLAC__SeekableStreamDecoderLengthStatus (*length_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
  52         FLAC__bool (*eof_callback)(const FLAC__SeekableStreamDecoder *decoder, void *client_data);
  53         FLAC__StreamDecoderWriteStatus (*write_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
  54         void (*metadata_callback)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
  55         void (*error_callback)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
  56         void *client_data;
  57         FLAC__StreamDecoder *stream_decoder;
  58         FLAC__bool do_md5_checking; /* initially gets protected_->md5_checking but is turned off after a seek */
  59         struct MD5Context md5context;
  60         FLAC__byte stored_md5sum[16]; /* this is what is stored in the metadata */
  61         FLAC__byte computed_md5sum[16]; /* this is the sum we computed from the decoded data */
  62         /* the rest of these are only used for seeking: */
  63         FLAC__StreamMetadata_StreamInfo stream_info; /* we keep this around so we can figure out how to seek quickly */
  64         const FLAC__StreamMetadata_SeekTable *seek_table; /* we hold a pointer to the stream decoder's seek table for the same reason */
  65         /* Since we always want to see the STREAMINFO and SEEK_TABLE blocks at this level, we need some extra flags to keep track of whether they should be passed on up through the metadata_callback */
  66         FLAC__bool ignore_stream_info_block;
  67         FLAC__bool ignore_seek_table_block;
  68         FLAC__Frame last_frame; /* holds the info of the last frame we seeked to */
  69         FLAC__uint64 target_sample;
  70 } FLAC__SeekableStreamDecoderPrivate;
  71
  72 /***********************************************************************
  73  *
  74  * Public static class data
  75  *
  76  ***********************************************************************/
  77
  78 const char * const FLAC__SeekableStreamDecoderStateString[] = {
  79         "FLAC__SEEKABLE_STREAM_DECODER_OK",
  80         "FLAC__SEEKABLE_STREAM_DECODER_SEEKING",
  81         "FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM",
  82         "FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR",
  83         "FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR",
  84         "FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR",
  85         "FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR",
  86     "FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED",
  87     "FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK",
  88     "FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED"
  89 };
  90
  91 const char * const FLAC__SeekableStreamDecoderReadStatusString[] = {
  92         "FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK",
  93         "FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR"
  94 };
  95
  96 const char * const FLAC__SeekableStreamDecoderSeekStatusString[] = {
  97         "FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK",
  98         "FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR"
  99 };
 100
 101 const char * const FLAC__SeekableStreamDecoderTellStatusString[] = {
 102         "FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK",
 103         "FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR"
 104 };
 105
 106 const char * const FLAC__SeekableStreamDecoderLengthStatusString[] = {
 107         "FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK",
 108         "FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR"
 109 };
 110
 111 /***********************************************************************
 112  *
 113  * Class constructor/destructor
 114  *
 115  ***********************************************************************/
 116
 117 FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
 118 {
 119         FLAC__SeekableStreamDecoder *decoder;
 120
 121         FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 122
 123         decoder = (FLAC__SeekableStreamDecoder*)malloc(sizeof(FLAC__SeekableStreamDecoder));
 124         if(decoder == 0) {
 125                 return 0;
 126         }
 127         decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
 128         if(decoder->protected_ == 0) {
 129                 free(decoder);
 130                 return 0;
 131         }
 132         decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
 133         if(decoder->private_ == 0) {
 134                 free(decoder->protected_);
 135                 free(decoder);
 136                 return 0;
 137         }
 138
 139         decoder->private_->stream_decoder = FLAC__stream_decoder_new();
 140
 141         if(0 == decoder->private_->stream_decoder) {
 142                 free(decoder->private_);
 143                 free(decoder->protected_);
 144                 free(decoder);
 145                 return 0;
 146         }
 147
 148         seekable_stream_decoder_set_defaults_(decoder);
 149
 150         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 151
 152         return decoder;
 153 }
 154
 155 void FLAC__seekable_stream_decoder_delete(FLAC__SeekableStreamDecoder *decoder)
 156 {
 157         FLAC__ASSERT(decoder != 0);
 158         FLAC__ASSERT(decoder->protected_ != 0);
 159         FLAC__ASSERT(decoder->private_ != 0);
 160         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 161
 162         (void)FLAC__seekable_stream_decoder_finish(decoder);
 163
 164         FLAC__stream_decoder_delete(decoder->private_->stream_decoder);
 165
 166         free(decoder->private_);
 167         free(decoder->protected_);
 168         free(decoder);
 169 }
 170
 171 /***********************************************************************
 172  *
 173  * Public class methods
 174  *
 175  ***********************************************************************/
 176
 177 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_init(FLAC__SeekableStreamDecoder *decoder)
 178 {
 179         FLAC__ASSERT(decoder != 0);
 180
 181         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 182                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED;
 183
 184         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)
 185                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK;
 186
 187         if(0 == decoder->private_->write_callback || 0 == decoder->private_->metadata_callback || 0 == decoder->private_->error_callback)
 188                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK;
 189
 190         decoder->private_->seek_table = 0;
 191
 192         decoder->private_->do_md5_checking = decoder->protected_->md5_checking;
 193
 194         /* We initialize the MD5Context even though we may never use it.  This is
 195          * because md5 checking may be turned on to start and then turned off if a
 196          * seek occurs.  So we always init the context here and finalize it in
 197          * FLAC__seekable_stream_decoder_finish() to make sure things are always
 198          * cleaned up properly.
 199          */
 200         MD5Init(&decoder->private_->md5context);
 201
 202         FLAC__stream_decoder_set_read_callback(decoder->private_->stream_decoder, read_callback_);
 203         FLAC__stream_decoder_set_write_callback(decoder->private_->stream_decoder, write_callback_);
 204         FLAC__stream_decoder_set_metadata_callback(decoder->private_->stream_decoder, metadata_callback_);
 205         FLAC__stream_decoder_set_error_callback(decoder->private_->stream_decoder, error_callback_);
 206         FLAC__stream_decoder_set_client_data(decoder->private_->stream_decoder, decoder);
 207
 208         /* We always want to see these blocks.  Whether or not we pass them up
 209          * through the metadata callback will be determined by flags set in our
 210          * implementation of ..._set_metadata_respond/ignore...()
 211          */
 212         FLAC__stream_decoder_set_metadata_respond(decoder->private_->stream_decoder, FLAC__METADATA_TYPE_STREAMINFO);
 213         FLAC__stream_decoder_set_metadata_respond(decoder->private_->stream_decoder, FLAC__METADATA_TYPE_SEEKTABLE);
 214
 215         if(FLAC__stream_decoder_init(decoder->private_->stream_decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 216                 return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 217
 218         return decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
 219 }
 220
 221 FLAC__bool FLAC__seekable_stream_decoder_finish(FLAC__SeekableStreamDecoder *decoder)
 222 {
 223         FLAC__bool md5_failed = false;
 224
 225         FLAC__ASSERT(decoder != 0);
 226         FLAC__ASSERT(decoder->private_ != 0);
 227         FLAC__ASSERT(decoder->protected_ != 0);
 228
 229         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 230                 return true;
 231
 232         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 233
 234         /* see the comment in FLAC__seekable_stream_decoder_init() as to why we
 235          * always call MD5Final()
 236          */
 237         MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context);
 238
 239         FLAC__stream_decoder_finish(decoder->private_->stream_decoder);
 240
 241         if(decoder->private_->do_md5_checking) {
 242                 if(memcmp(decoder->private_->stored_md5sum, decoder->private_->computed_md5sum, 16))
 243                         md5_failed = true;
 244         }
 245
 246         seekable_stream_decoder_set_defaults_(decoder);
 247
 248         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
 249
 250         return !md5_failed;
 251 }
 252
 253 FLAC__bool FLAC__seekable_stream_decoder_set_md5_checking(FLAC__SeekableStreamDecoder *decoder, FLAC__bool value)
 254 {
 255         FLAC__ASSERT(decoder != 0);
 256         FLAC__ASSERT(decoder->protected_ != 0);
 257         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 258                 return false;
 259         decoder->protected_->md5_checking = value;
 260         return true;
 261 }
 262
 263 FLAC__bool FLAC__seekable_stream_decoder_set_read_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderReadStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data))
 264 {
 265         FLAC__ASSERT(decoder != 0);
 266         FLAC__ASSERT(decoder->private_ != 0);
 267         FLAC__ASSERT(decoder->protected_ != 0);
 268         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 269                 return false;
 270         decoder->private_->read_callback = value;
 271         return true;
 272 }
 273
 274 FLAC__bool FLAC__seekable_stream_decoder_set_seek_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderSeekStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data))
 275 {
 276         FLAC__ASSERT(decoder != 0);
 277         FLAC__ASSERT(decoder->private_ != 0);
 278         FLAC__ASSERT(decoder->protected_ != 0);
 279         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 280                 return false;
 281         decoder->private_->seek_callback = value;
 282         return true;
 283 }
 284
 285 FLAC__bool FLAC__seekable_stream_decoder_set_tell_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderTellStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data))
 286 {
 287         FLAC__ASSERT(decoder != 0);
 288         FLAC__ASSERT(decoder->private_ != 0);
 289         FLAC__ASSERT(decoder->protected_ != 0);
 290         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 291                 return false;
 292         decoder->private_->tell_callback = value;
 293         return true;
 294 }
 295
 296 FLAC__bool FLAC__seekable_stream_decoder_set_length_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__SeekableStreamDecoderLengthStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data))
 297 {
 298         FLAC__ASSERT(decoder != 0);
 299         FLAC__ASSERT(decoder->private_ != 0);
 300         FLAC__ASSERT(decoder->protected_ != 0);
 301         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 302                 return false;
 303         decoder->private_->length_callback = value;
 304         return true;
 305 }
 306
 307 FLAC__bool FLAC__seekable_stream_decoder_set_eof_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__bool (*value)(const FLAC__SeekableStreamDecoder *decoder, void *client_data))
 308 {
 309         FLAC__ASSERT(decoder != 0);
 310         FLAC__ASSERT(decoder->private_ != 0);
 311         FLAC__ASSERT(decoder->protected_ != 0);
 312         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 313                 return false;
 314         decoder->private_->eof_callback = value;
 315         return true;
 316 }
 317
 318 FLAC__bool FLAC__seekable_stream_decoder_set_write_callback(FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderWriteStatus (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data))
 319 {
 320         FLAC__ASSERT(decoder != 0);
 321         FLAC__ASSERT(decoder->private_ != 0);
 322         FLAC__ASSERT(decoder->protected_ != 0);
 323         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 324                 return false;
 325         decoder->private_->write_callback = value;
 326         return true;
 327 }
 328
 329 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_callback(FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data))
 330 {
 331         FLAC__ASSERT(decoder != 0);
 332         FLAC__ASSERT(decoder->private_ != 0);
 333         FLAC__ASSERT(decoder->protected_ != 0);
 334         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 335                 return false;
 336         decoder->private_->metadata_callback = value;
 337         return true;
 338 }
 339
 340 FLAC__bool FLAC__seekable_stream_decoder_set_error_callback(FLAC__SeekableStreamDecoder *decoder, void (*value)(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data))
 341 {
 342         FLAC__ASSERT(decoder != 0);
 343         FLAC__ASSERT(decoder->private_ != 0);
 344         FLAC__ASSERT(decoder->protected_ != 0);
 345         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 346                 return false;
 347         decoder->private_->error_callback = value;
 348         return true;
 349 }
 350
 351 FLAC__bool FLAC__seekable_stream_decoder_set_client_data(FLAC__SeekableStreamDecoder *decoder, void *value)
 352 {
 353         FLAC__ASSERT(decoder != 0);
 354         FLAC__ASSERT(decoder->private_ != 0);
 355         FLAC__ASSERT(decoder->protected_ != 0);
 356         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 357                 return false;
 358         decoder->private_->client_data = value;
 359         return true;
 360 }
 361
 362 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond(FLAC__SeekableStreamDecoder *decoder, FLAC__MetadataType type)
 363 {
 364         FLAC__ASSERT(decoder != 0);
 365         FLAC__ASSERT(decoder->private_ != 0);
 366         FLAC__ASSERT(decoder->protected_ != 0);
 367         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 368         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 369                 return false;
 370         if(type == FLAC__METADATA_TYPE_STREAMINFO)
 371                 decoder->private_->ignore_stream_info_block = false;
 372         else if(type == FLAC__METADATA_TYPE_SEEKTABLE)
 373                 decoder->private_->ignore_seek_table_block = false;
 374         return FLAC__stream_decoder_set_metadata_respond(decoder->private_->stream_decoder, type);
 375 }
 376
 377 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_application(FLAC__SeekableStreamDecoder *decoder, const FLAC__byte id[4])
 378 {
 379         FLAC__ASSERT(decoder != 0);
 380         FLAC__ASSERT(decoder->private_ != 0);
 381         FLAC__ASSERT(decoder->protected_ != 0);
 382         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 383         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 384                 return false;
 385         return FLAC__stream_decoder_set_metadata_respond_application(decoder->private_->stream_decoder, id);
 386 }
 387
 388 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_respond_all(FLAC__SeekableStreamDecoder *decoder)
 389 {
 390         FLAC__ASSERT(decoder != 0);
 391         FLAC__ASSERT(decoder->private_ != 0);
 392         FLAC__ASSERT(decoder->protected_ != 0);
 393         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 394         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 395                 return false;
 396         decoder->private_->ignore_stream_info_block = false;
 397         decoder->private_->ignore_seek_table_block = false;
 398         return FLAC__stream_decoder_set_metadata_respond_all(decoder->private_->stream_decoder);
 399 }
 400
 401 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore(FLAC__SeekableStreamDecoder *decoder, FLAC__MetadataType type)
 402 {
 403         FLAC__ASSERT(decoder != 0);
 404         FLAC__ASSERT(decoder->private_ != 0);
 405         FLAC__ASSERT(decoder->protected_ != 0);
 406         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 407         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 408                 return false;
 409         if(type == FLAC__METADATA_TYPE_STREAMINFO)
 410                 decoder->private_->ignore_stream_info_block = true;
 411         else if(type == FLAC__METADATA_TYPE_SEEKTABLE)
 412                 decoder->private_->ignore_seek_table_block = true;
 413         return FLAC__stream_decoder_set_metadata_ignore(decoder->private_->stream_decoder, type);
 414 }
 415
 416 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_application(FLAC__SeekableStreamDecoder *decoder, const FLAC__byte id[4])
 417 {
 418         FLAC__ASSERT(decoder != 0);
 419         FLAC__ASSERT(decoder->private_ != 0);
 420         FLAC__ASSERT(decoder->protected_ != 0);
 421         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 422         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 423                 return false;
 424         return FLAC__stream_decoder_set_metadata_ignore_application(decoder->private_->stream_decoder, id);
 425 }
 426
 427 FLAC__bool FLAC__seekable_stream_decoder_set_metadata_ignore_all(FLAC__SeekableStreamDecoder *decoder)
 428 {
 429         FLAC__ASSERT(decoder != 0);
 430         FLAC__ASSERT(decoder->private_ != 0);
 431         FLAC__ASSERT(decoder->protected_ != 0);
 432         FLAC__ASSERT(decoder->private_->stream_decoder != 0);
 433         if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED)
 434                 return false;
 435         decoder->private_->ignore_stream_info_block = true;
 436         decoder->private_->ignore_seek_table_block = true;
 437         return FLAC__stream_decoder_set_metadata_ignore_all(decoder->private_->stream_decoder);
 438 }
 439
 440 FLAC__SeekableStreamDecoderState FLAC__seekable_stream_decoder_get_state(const FLAC__SeekableStreamDecoder *decoder)
 441 {
 442         FLAC__ASSERT(decoder != 0);
 443         FLAC__ASSERT(decoder->protected_ != 0);
 444         return decoder->protected_->state;
 445 }
 446
 447 FLAC__bool FLAC__seekable_stream_decoder_get_md5_checking(const FLAC__SeekableStreamDecoder *decoder)
 448 {
 449         FLAC__ASSERT(decoder != 0);
 450         FLAC__ASSERT(decoder->protected_ != 0);
 451         return decoder->protected_->md5_checking;
 452 }
 453
 454 unsigned FLAC__seekable_stream_decoder_get_channels(const FLAC__SeekableStreamDecoder *decoder)
 455 {
 456     FLAC__ASSERT(decoder != 0);
 457     FLAC__ASSERT(decoder->private_ != 0);
 458     return FLAC__stream_decoder_get_channels(decoder->private_->stream_decoder);
 459 }
 460
 461 FLAC__ChannelAssignment FLAC__seekable_stream_decoder_get_channel_assignment(const FLAC__SeekableStreamDecoder *decoder)
 462 {
 463     FLAC__ASSERT(decoder != 0);
 464     FLAC__ASSERT(decoder->private_ != 0);
 465     return FLAC__stream_decoder_get_channel_assignment(decoder->private_->stream_decoder);
 466 }
 467
 468 unsigned FLAC__seekable_stream_decoder_get_bits_per_sample(const FLAC__SeekableStreamDecoder *decoder)
 469 {
 470     FLAC__ASSERT(decoder != 0);
 471     FLAC__ASSERT(decoder->private_ != 0);
 472     return FLAC__stream_decoder_get_bits_per_sample(decoder->private_->stream_decoder);
 473 }
 474
 475 unsigned FLAC__seekable_stream_decoder_get_sample_rate(const FLAC__SeekableStreamDecoder *decoder)
 476 {
 477     FLAC__ASSERT(decoder != 0);
 478     FLAC__ASSERT(decoder->private_ != 0);
 479     return FLAC__stream_decoder_get_sample_rate(decoder->private_->stream_decoder);
 480 }
 481
 482 unsigned FLAC__seekable_stream_decoder_get_blocksize(const FLAC__SeekableStreamDecoder *decoder)
 483 {
 484     FLAC__ASSERT(decoder != 0);
 485     FLAC__ASSERT(decoder->private_ != 0);
 486     return FLAC__stream_decoder_get_blocksize(decoder->private_->stream_decoder);
 487 }
 488
 489 FLAC__bool FLAC__seekable_stream_decoder_flush(FLAC__SeekableStreamDecoder *decoder)
 490 {
 491         FLAC__ASSERT(decoder != 0);
 492         FLAC__ASSERT(decoder->private_ != 0);
 493         FLAC__ASSERT(decoder->protected_ != 0);
 494
 495         decoder->private_->do_md5_checking = false;
 496
 497         if(!FLAC__stream_decoder_flush(decoder->private_->stream_decoder)) {
 498                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 499                 return false;
 500         }
 501
 502         return true;
 503 }
 504
 505 FLAC__bool FLAC__seekable_stream_decoder_reset(FLAC__SeekableStreamDecoder *decoder)
 506 {
 507         FLAC__ASSERT(decoder != 0);
 508         FLAC__ASSERT(decoder->private_ != 0);
 509         FLAC__ASSERT(decoder->protected_ != 0);
 510
 511         if(!FLAC__seekable_stream_decoder_flush(decoder)) {
 512                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 513                 return false;
 514         }
 515
 516         if(!FLAC__stream_decoder_reset(decoder->private_->stream_decoder)) {
 517                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 518                 return false;
 519         }
 520
 521         decoder->private_->seek_table = 0;
 522
 523         decoder->private_->do_md5_checking = decoder->protected_->md5_checking;
 524
 525         /* We initialize the MD5Context even though we may never use it.  This is
 526          * because md5 checking may be turned on to start and then turned off if a
 527          * seek occurs.  So we always init the context here and finalize it in
 528          * FLAC__seekable_stream_decoder_finish() to make sure things are always
 529          * cleaned up properly.
 530          */
 531         MD5Init(&decoder->private_->md5context);
 532
 533         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
 534
 535         return true;
 536 }
 537
 538 FLAC__bool FLAC__seekable_stream_decoder_process_whole_stream(FLAC__SeekableStreamDecoder *decoder)
 539 {
 540         FLAC__bool ret;
 541         FLAC__ASSERT(decoder != 0);
 542
 543         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 544                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 545
 546         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 547                 return true;
 548
 549         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 550
 551         ret = FLAC__stream_decoder_process_whole_stream(decoder->private_->stream_decoder);
 552         if(!ret)
 553                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 554
 555         return ret;
 556 }
 557
 558 FLAC__bool FLAC__seekable_stream_decoder_process_metadata(FLAC__SeekableStreamDecoder *decoder)
 559 {
 560         FLAC__bool ret;
 561         FLAC__ASSERT(decoder != 0);
 562
 563         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 564                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 565
 566         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 567                 return true;
 568
 569         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 570
 571         ret = FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder);
 572         if(!ret)
 573                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 574
 575         return ret;
 576 }
 577
 578 FLAC__bool FLAC__seekable_stream_decoder_process_one_frame(FLAC__SeekableStreamDecoder *decoder)
 579 {
 580         FLAC__bool ret;
 581         FLAC__ASSERT(decoder != 0);
 582
 583         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 584                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 585
 586         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 587                 return true;
 588
 589         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 590
 591         ret = FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder);
 592         if(!ret)
 593                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 594
 595         return ret;
 596 }
 597
 598 FLAC__bool FLAC__seekable_stream_decoder_process_remaining_frames(FLAC__SeekableStreamDecoder *decoder)
 599 {
 600         FLAC__bool ret;
 601         FLAC__ASSERT(decoder != 0);
 602
 603         if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM)
 604                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 605
 606         if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM)
 607                 return true;
 608
 609         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK);
 610
 611         ret = FLAC__stream_decoder_process_remaining_frames(decoder->private_->stream_decoder);
 612         if(!ret)
 613                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 614
 615         return ret;
 616 }
 617
 618 FLAC__bool FLAC__seekable_stream_decoder_seek_absolute(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 sample)
 619 {
 620         FLAC__uint64 length;
 621
 622         FLAC__ASSERT(decoder != 0);
 623         FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK || decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM);
 624
 625         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEKING;
 626
 627         /* turn off md5 checking if a seek is attempted */
 628         decoder->private_->do_md5_checking = false;
 629
 630         if(!FLAC__stream_decoder_reset(decoder->private_->stream_decoder)) {
 631                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 632                 return false;
 633         }
 634         /* get the file length */
 635         if(decoder->private_->length_callback(decoder, &length, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK) {
 636                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 637                 return false;
 638         }
 639         /* rewind */
 640         if(decoder->private_->seek_callback(decoder, 0, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK) {
 641                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 642                 return false;
 643         }
 644         if(!FLAC__stream_decoder_process_metadata(decoder->private_->stream_decoder)) {
 645                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 646                 return false;
 647         }
 648         if(decoder->private_->stream_info.total_samples > 0 && sample > decoder->private_->stream_info.total_samples) {
 649                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 650                 return false;
 651         }
 652
 653         return seek_to_absolute_sample_(decoder, length, sample);
 654 }
 655
 656 /***********************************************************************
 657  *
 658  * Private class methods
 659  *
 660  ***********************************************************************/
 661
 662 void seekable_stream_decoder_set_defaults_(FLAC__SeekableStreamDecoder *decoder)
 663 {
 664         decoder->private_->read_callback = 0;
 665         decoder->private_->seek_callback = 0;
 666         decoder->private_->tell_callback = 0;
 667         decoder->private_->length_callback = 0;
 668         decoder->private_->eof_callback = 0;
 669         decoder->private_->write_callback = 0;
 670         decoder->private_->metadata_callback = 0;
 671         decoder->private_->error_callback = 0;
 672         decoder->private_->client_data = 0;
 673         /* WATCHOUT: these should match the default behavior of FLAC__StreamDecoder */
 674         decoder->private_->ignore_stream_info_block = false;
 675         decoder->private_->ignore_seek_table_block = true;
 676
 677         decoder->protected_->md5_checking = false;
 678 }
 679
 680 FLAC__StreamDecoderReadStatus read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 681 {
 682         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 683         (void)decoder;
 684         if(seekable_stream_decoder->private_->eof_callback(seekable_stream_decoder, seekable_stream_decoder->private_->client_data)) {
 685                 seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 686                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 687         }
 688         else if(*bytes > 0) {
 689                 unsigned bytes_read = *bytes;
 690                 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) {
 691                         seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR;
 692                         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 693                 }
 694                 if(bytes_read == 0) {
 695                         if(seekable_stream_decoder->private_->eof_callback(seekable_stream_decoder, seekable_stream_decoder->private_->client_data)) {
 696                                 seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM;
 697                                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 698                         }
 699                         else
 700                                 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 701                 }
 702                 else {
 703                         *bytes = bytes_read;
 704                         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 705                 }
 706         }
 707         else
 708                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
 709 }
 710
 711 FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 712 {
 713         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 714         (void)decoder;
 715
 716         if(seekable_stream_decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
 717                 FLAC__uint64 this_frame_sample = frame->header.number.sample_number;
 718                 FLAC__uint64 next_frame_sample = this_frame_sample + (FLAC__uint64)frame->header.blocksize;
 719                 FLAC__uint64 target_sample = seekable_stream_decoder->private_->target_sample;
 720
 721                 FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
 722
 723                 seekable_stream_decoder->private_->last_frame = *frame; /* save the frame */
 724                 if(this_frame_sample <= target_sample && target_sample < next_frame_sample) { /* we hit our target frame */
 725                         unsigned delta = (unsigned)(target_sample - this_frame_sample);
 726                         /* kick out of seek mode */
 727                         seekable_stream_decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_OK;
 728                         /* shift out the samples before target_sample */
 729                         if(delta > 0) {
 730                                 unsigned channel;
 731                                 const FLAC__int32 *newbuffer[FLAC__MAX_CHANNELS];
 732                                 for(channel = 0; channel < frame->header.channels; channel++)
 733                                         newbuffer[channel] = buffer[channel] + delta;
 734                                 seekable_stream_decoder->private_->last_frame.header.blocksize -= delta;
 735                                 seekable_stream_decoder->private_->last_frame.header.number.sample_number += (FLAC__uint64)delta;
 736                                 /* write the relevant samples */
 737                                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, &seekable_stream_decoder->private_->last_frame, newbuffer, seekable_stream_decoder->private_->client_data);
 738                         }
 739                         else {
 740                                 /* write the relevant samples */
 741                                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, frame, buffer, seekable_stream_decoder->private_->client_data);
 742                         }
 743                 }
 744                 else {
 745                         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 746                 }
 747         }
 748         else {
 749                 if(seekable_stream_decoder->private_->do_md5_checking) {
 750                         if(!FLAC__MD5Accumulate(&seekable_stream_decoder->private_->md5context, buffer, frame->header.channels, frame->header.blocksize, (frame->header.bits_per_sample+7) / 8))
 751                                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 752                 }
 753                 return seekable_stream_decoder->private_->write_callback(seekable_stream_decoder, frame, buffer, seekable_stream_decoder->private_->client_data);
 754         }
 755 }
 756
 757 void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 758 {
 759         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 760         (void)decoder;
 761
 762         if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
 763                 seekable_stream_decoder->private_->stream_info = metadata->data.stream_info;
 764                 /* save the MD5 signature for comparison later */
 765                 memcpy(seekable_stream_decoder->private_->stored_md5sum, metadata->data.stream_info.md5sum, 16);
 766                 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))
 767                         seekable_stream_decoder->private_->do_md5_checking = false;
 768         }
 769         else if(metadata->type == FLAC__METADATA_TYPE_SEEKTABLE) {
 770                 seekable_stream_decoder->private_->seek_table = &metadata->data.seek_table;
 771         }
 772
 773         if(seekable_stream_decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
 774                 FLAC__bool ignore_block = false;
 775                 if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO && seekable_stream_decoder->private_->ignore_stream_info_block)
 776                         ignore_block = true;
 777                 else if(metadata->type == FLAC__METADATA_TYPE_SEEKTABLE && seekable_stream_decoder->private_->ignore_seek_table_block)
 778                         ignore_block = true;
 779                 if(!ignore_block)
 780                         seekable_stream_decoder->private_->metadata_callback(seekable_stream_decoder, metadata, seekable_stream_decoder->private_->client_data);
 781         }
 782 }
 783
 784 void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 785 {
 786         FLAC__SeekableStreamDecoder *seekable_stream_decoder = (FLAC__SeekableStreamDecoder *)client_data;
 787         (void)decoder;
 788
 789         if(seekable_stream_decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING)
 790                 seekable_stream_decoder->private_->error_callback(seekable_stream_decoder, status, seekable_stream_decoder->private_->client_data);
 791 }
 792
 793 FLAC__bool seek_to_absolute_sample_(FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 stream_length, FLAC__uint64 target_sample)
 794 {
 795         FLAC__uint64 first_frame_offset, lower_bound, upper_bound;
 796         FLAC__int64 pos = -1, last_pos = -1;
 797         int i, lower_seek_point = -1, upper_seek_point = -1;
 798         unsigned approx_bytes_per_frame;
 799         FLAC__uint64 last_frame_sample = 0xffffffffffffffff;
 800         FLAC__bool needs_seek;
 801         const FLAC__uint64 total_samples = decoder->private_->stream_info.total_samples;
 802         const unsigned min_blocksize = decoder->private_->stream_info.min_blocksize;
 803         const unsigned max_blocksize = decoder->private_->stream_info.max_blocksize;
 804         const unsigned max_framesize = decoder->private_->stream_info.max_framesize;
 805         const unsigned channels = FLAC__seekable_stream_decoder_get_channels(decoder);
 806         const unsigned bps = FLAC__seekable_stream_decoder_get_bits_per_sample(decoder);
 807
 808         /* we are just guessing here, but we want to guess high, not low */
 809         if(max_framesize > 0) {
 810                 approx_bytes_per_frame = max_framesize;
 811         }
 812         /*
 813          * Check if it's a known fixed-blocksize stream.  Note that though
 814          * the spec doesn't allow zeroes in the STREAMINFO block, we may
 815          * never get a STREAMINFO block when decoding so the value of
 816          * min_blocksize might be zero.
 817          */
 818         else if(min_blocksize == max_blocksize && min_blocksize > 0) {
 819                 /* note there are no () around 'bps/8' to keep precision up since it's an integer calulation */
 820                 approx_bytes_per_frame = min_blocksize * channels * bps/8 + 64;
 821         }
 822         else
 823                 approx_bytes_per_frame = 4608 * channels * bps/8 + 64;
 824
 825         /*
 826          * The stream position is currently at the first frame plus any read
 827          * ahead data, so first we get the stream position, then subtract
 828          * uncomsumed bytes to get the position of the first frame in the
 829          * stream.
 830          */
 831         if(decoder->private_->tell_callback(decoder, &first_frame_offset, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
 832                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 833                 return false;
 834         }
 835         FLAC__ASSERT(first_frame_offset >= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder));
 836         first_frame_offset -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder);
 837
 838         /*
 839          * First, we set an upper and lower bound on where in the
 840          * stream we will search.  For now we assume the worst case
 841          * scenario, which is our best guess at the beginning of
 842          * the first and last frames.
 843          */
 844         lower_bound = first_frame_offset;
 845
 846         /* calc the upper_bound, beyond which we never want to seek */
 847         if(max_framesize > 0)
 848                 upper_bound = stream_length - (max_framesize + 128 + 2); /* 128 for a possible ID3V1 tag, 2 for indexing differences */
 849         else
 850                 upper_bound = stream_length - ((channels * bps * FLAC__MAX_BLOCK_SIZE) / 8 + 128 + 2);
 851
 852         /*
 853          * Now we refine the bounds if we have a seektable with
 854          * suitable points.  Note that according to the spec they
 855          * must be ordered by ascending sample number.
 856          */
 857         if(0 != decoder->private_->seek_table) {
 858                 /* find the closest seek point <= target_sample, if it exists */
 859                 for(i = (int)decoder->private_->seek_table->num_points - 1; i >= 0; i--) {
 860                         if(decoder->private_->seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER && decoder->private_->seek_table->points[i].sample_number <= target_sample)
 861                                 break;
 862                 }
 863                 if(i >= 0) { /* i.e. we found a suitable seek point... */
 864                         lower_bound = first_frame_offset + decoder->private_->seek_table->points[i].stream_offset;
 865                         lower_seek_point = i;
 866                 }
 867
 868                 /* find the closest seek point > target_sample, if it exists */
 869                 for(i = 0; i < (int)decoder->private_->seek_table->num_points; i++) {
 870                         if(decoder->private_->seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER && decoder->private_->seek_table->points[i].sample_number > target_sample)
 871                                 break;
 872                 }
 873                 if(i < (int)decoder->private_->seek_table->num_points) { /* i.e. we found a suitable seek point... */
 874                         upper_bound = first_frame_offset + decoder->private_->seek_table->points[i].stream_offset;
 875                         upper_seek_point = i;
 876                 }
 877         }
 878
 879         /*
 880          * Now guess at where within those bounds our target
 881          * sample will be.
 882          */
 883         if(lower_seek_point >= 0) {
 884                 /* first see if our sample is within a few frames of the lower seekpoint */
 885                 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)) {
 886                         pos = (FLAC__int64)lower_bound;
 887                 }
 888                 else if(upper_seek_point >= 0) {
 889                         const FLAC__uint64 target_offset = target_sample - decoder->private_->seek_table->points[lower_seek_point].sample_number;
 890                         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;
 891                         const FLAC__uint64 range_bytes = upper_bound - lower_bound;
 892 #if defined _MSC_VER || defined __MINGW32__
 893                         /* with VC++ you have to spoon feed it the casting */
 894                         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;
 895 #else
 896                         pos = (FLAC__int64)lower_bound + (FLAC__int64)((double)target_offset / (double)range_samples * (double)(range_bytes-1)) - approx_bytes_per_frame;
 897 #endif
 898                 }
 899         }
 900
 901         /*
 902          * If there's no seek table, we need to use the metadata (if we
 903          * have it) and the filelength to estimate the position of the
 904          * frame with the correct sample.
 905          */
 906         if(pos < 0 && total_samples > 0) {
 907 #if defined _MSC_VER || defined __MINGW32__
 908                 /* with VC++ you have to spoon feed it the casting */
 909                 pos = (FLAC__int64)first_frame_offset + (FLAC__int64)((double)(FLAC__int64)target_sample / (double)(FLAC__int64)total_samples * (double)(FLAC__int64)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
 910 #else
 911                 pos = (FLAC__int64)first_frame_offset + (FLAC__int64)((double)target_sample / (double)total_samples * (double)(stream_length-first_frame_offset-1)) - approx_bytes_per_frame;
 912 #endif
 913         }
 914
 915         /*
 916          * If there's no seek table and total_samples is unknown, we
 917          * don't even bother trying to figure out a target, we just use
 918          * our current position.
 919          */
 920         if(pos < 0) {
 921                 FLAC__uint64 upos;
 922                 if(decoder->private_->tell_callback(decoder, &upos, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
 923                         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 924                         return false;
 925                 }
 926                 pos = (FLAC__int32)upos;
 927                 needs_seek = false;
 928         }
 929         else
 930                 needs_seek = true;
 931
 932         /* clip the position to the bounds, lower bound takes precedence */
 933         if(pos >= (FLAC__int64)upper_bound) {
 934                 pos = (FLAC__int64)upper_bound-1;
 935                 needs_seek = true;
 936         }
 937         if(pos < (FLAC__int64)lower_bound) {
 938                 pos = (FLAC__int64)lower_bound;
 939                 needs_seek = true;
 940         }
 941
 942         decoder->private_->target_sample = target_sample;
 943         while(1) {
 944                 if(needs_seek) {
 945                         if(decoder->private_->seek_callback(decoder, (FLAC__uint64)pos, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK) {
 946                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 947                                 return false;
 948                         }
 949                         if(!FLAC__stream_decoder_flush(decoder->private_->stream_decoder)) {
 950                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR;
 951                                 return false;
 952                         }
 953                 }
 954                 if(!FLAC__stream_decoder_process_one_frame(decoder->private_->stream_decoder)) {
 955                         decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 956                         return false;
 957                 }
 958                 /* our write callback will change the state when it gets to the target frame */
 959                 if(decoder->protected_->state != FLAC__SEEKABLE_STREAM_DECODER_SEEKING) {
 960                         break;
 961                 }
 962                 else { /* we need to narrow the search */
 963                         FLAC__uint64 this_frame_sample = decoder->private_->last_frame.header.number.sample_number;
 964                         FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER);
 965                         if(this_frame_sample == last_frame_sample) {
 966                                 /* our last move backwards wasn't big enough */
 967                                 pos -= (last_pos - pos);
 968                                 needs_seek = true;
 969                         }
 970                         else {
 971                                 if(target_sample < this_frame_sample) {
 972                                         last_pos = pos;
 973                                         approx_bytes_per_frame = decoder->private_->last_frame.header.blocksize * channels * bps/8 + 64;
 974                                         pos -= approx_bytes_per_frame;
 975                                         needs_seek = true;
 976                                 }
 977                                 else { /* target_sample >= this_frame_sample + this frame's blocksize */
 978                                         FLAC__uint64 upos;
 979                                         if(decoder->private_->tell_callback(decoder, &upos, decoder->private_->client_data) != FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK) {
 980                                                 decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR;
 981                                                 return false;
 982                                         }
 983                                         last_pos = pos;
 984                                         pos = (FLAC__int32)upos;
 985                                         pos -= FLAC__stream_decoder_get_input_bytes_unconsumed(decoder->private_->stream_decoder);
 986                                         needs_seek = false;
 987                                 }
 988                         }
 989                         if(pos < (FLAC__int64)lower_bound)
 990                                 pos = (FLAC__int64)lower_bound;
 991                         last_frame_sample = this_frame_sample;
 992                 }
 993         }
 994
 995         return true;
 996 }