src/libFLAC/seekable_stream_decoder.c

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