src/libFLAC/metadata_iterators.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2001,2002,2003,2004,2005,2006  Josh Coalson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * - Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * - Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * - Neither the name of the Xiph.org Foundation nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #if HAVE_CONFIG_H
  33 #  include <config.h>
  34 #endif
  35
  36 #include <errno.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #if defined _MSC_VER || defined __MINGW32__
  42 #include <sys/utime.h> /* for utime() */
  43 #include <io.h> /* for chmod() */
  44 #include <sys/types.h> /* for off_t */
  45 //@@@ [2G limit] hacks for MSVC6
  46 #define fseeko fseek
  47 #define ftello ftell
  48 #else
  49 #include <sys/types.h> /* some flavors of BSD (like OS X) require this to get time_t */
  50 #include <utime.h> /* for utime() */
  51 #include <unistd.h> /* for chown(), unlink() */
  52 #endif
  53 #include <sys/stat.h> /* for stat(), maybe chmod() */
  54
  55 #include "private/metadata.h"
  56
  57 #include "FLAC/assert.h"
  58 #include "FLAC/stream_decoder.h"
  59
  60 #ifdef max
  61 #undef max
  62 #endif
  63 #define max(a,b) ((a)>(b)?(a):(b))
  64 #ifdef min
  65 #undef min
  66 #endif
  67 #define min(a,b) ((a)<(b)?(a):(b))
  68
  69
  70 /****************************************************************************
  71  *
  72  * Local function declarations
  73  *
  74  ***************************************************************************/
  75
  76 static void pack_uint32_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes);
  77 static void pack_uint32_little_endian_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes);
  78 static void pack_uint64_(FLAC__uint64 val, FLAC__byte *b, unsigned bytes);
  79 static FLAC__uint32 unpack_uint32_(FLAC__byte *b, unsigned bytes);
  80 static FLAC__uint32 unpack_uint32_little_endian_(FLAC__byte *b, unsigned bytes);
  81 static FLAC__uint64 unpack_uint64_(FLAC__byte *b, unsigned bytes);
  82
  83 static FLAC__bool read_metadata_block_header_(FLAC__Metadata_SimpleIterator *iterator);
  84 static FLAC__bool read_metadata_block_data_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block);
  85 static FLAC__bool read_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__bool *is_last, FLAC__MetadataType *type, unsigned *length);
  86 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata *block);
  87 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_StreamInfo *block);
  88 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata_Padding *block, unsigned block_length);
  89 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Application *block, unsigned block_length);
  90 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_SeekTable *block, unsigned block_length);
  91 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_entry_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment_Entry *entry);
  92 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment *block);
  93 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_track_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet_Track *track);
  94 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet *block);
  95 static FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Unknown *block, unsigned block_length);
  96
  97 static FLAC__bool write_metadata_block_header_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block);
  98 static FLAC__bool write_metadata_block_data_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block);
  99 static FLAC__bool write_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block);
 100 static FLAC__bool write_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block);
 101 static FLAC__bool write_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_StreamInfo *block);
 102 static FLAC__bool write_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Padding *block, unsigned block_length);
 103 static FLAC__bool write_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Application *block, unsigned block_length);
 104 static FLAC__bool write_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_SeekTable *block);
 105 static FLAC__bool write_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_VorbisComment *block);
 106 static FLAC__bool write_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_CueSheet *block);
 107 static FLAC__bool write_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Unknown *block, unsigned block_length);
 108
 109 static FLAC__bool write_metadata_block_stationary_(FLAC__Metadata_SimpleIterator *iterator, const FLAC__StreamMetadata *block);
 110 static FLAC__bool write_metadata_block_stationary_with_padding_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, unsigned padding_length, FLAC__bool padding_is_last);
 111 static FLAC__bool rewrite_whole_file_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool append);
 112
 113 static void simple_iterator_push_(FLAC__Metadata_SimpleIterator *iterator);
 114 static FLAC__bool simple_iterator_pop_(FLAC__Metadata_SimpleIterator *iterator);
 115
 116 static unsigned seek_to_first_metadata_block_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb);
 117 static unsigned seek_to_first_metadata_block_(FILE *f);
 118
 119 static FLAC__bool simple_iterator_copy_file_prefix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, FLAC__bool append);
 120 static FLAC__bool simple_iterator_copy_file_postfix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, int fixup_is_last_code, off_t fixup_is_last_flag_offset, FLAC__bool backup);
 121
 122 static FLAC__bool copy_n_bytes_from_file_(FILE *file, FILE *tempfile, off_t bytes, FLAC__Metadata_SimpleIteratorStatus *status);
 123 static FLAC__bool copy_n_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, off_t bytes, FLAC__Metadata_SimpleIteratorStatus *status);
 124 static FLAC__bool copy_remaining_bytes_from_file_(FILE *file, FILE *tempfile, FLAC__Metadata_SimpleIteratorStatus *status);
 125 static FLAC__bool copy_remaining_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, FLAC__Metadata_SimpleIteratorStatus *status);
 126
 127 static FLAC__bool open_tempfile_(const char *filename, const char *tempfile_path_prefix, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status);
 128 static FLAC__bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status);
 129 static void cleanup_tempfile_(FILE **tempfile, char **tempfilename);
 130
 131 static FLAC__bool get_file_stats_(const char *filename, struct stat *stats);
 132 static void set_file_stats_(const char *filename, struct stat *stats);
 133
 134 static int fseek_wrapper_(FLAC__IOHandle handle, FLAC__int64 offset, int whence);
 135 static FLAC__int64 ftell_wrapper_(FLAC__IOHandle handle);
 136
 137 static FLAC__Metadata_ChainStatus get_equivalent_status_(FLAC__Metadata_SimpleIteratorStatus status);
 138
 139
 140 #ifdef FLAC__VALGRIND_TESTING
 141 static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
 142 {
 143         size_t ret = fwrite(ptr, size, nmemb, stream);
 144         if(!ferror(stream))
 145                 fflush(stream);
 146         return ret;
 147 }
 148 #else
 149 #define local__fwrite fwrite
 150 #endif
 151
 152 /****************************************************************************
 153  *
 154  * Level 0 implementation
 155  *
 156  ***************************************************************************/
 157
 158 static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
 159 static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
 160 static void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
 161
 162 typedef struct {
 163         FLAC__bool got_error;
 164         FLAC__StreamMetadata *object;
 165 } level0_client_data;
 166
 167 static FLAC__StreamMetadata *get_one_metadata_block_(const char *filename, FLAC__MetadataType type)
 168 {
 169         level0_client_data cd;
 170         FLAC__StreamDecoder *decoder;
 171
 172         FLAC__ASSERT(0 != filename);
 173
 174         cd.got_error = false;
 175         cd.object = 0;
 176
 177         decoder = FLAC__stream_decoder_new();
 178
 179         if(0 == decoder)
 180                 return 0;
 181
 182         FLAC__stream_decoder_set_md5_checking(decoder, false);
 183         FLAC__stream_decoder_set_metadata_ignore_all(decoder);
 184         FLAC__stream_decoder_set_metadata_respond(decoder, type);
 185
 186         if(FLAC__stream_decoder_init_file(decoder, filename, write_callback_, metadata_callback_, error_callback_, &cd) != FLAC__STREAM_DECODER_INIT_STATUS_OK || cd.got_error) {
 187                 FLAC__stream_decoder_finish(decoder);
 188                 FLAC__stream_decoder_delete(decoder);
 189                 return 0;
 190         }
 191
 192         if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder) || cd.got_error) {
 193                 FLAC__stream_decoder_finish(decoder);
 194                 FLAC__stream_decoder_delete(decoder);
 195                 if(0 != cd.object)
 196                         FLAC__metadata_object_delete(cd.object);
 197                 return 0;
 198         }
 199
 200         FLAC__stream_decoder_finish(decoder);
 201         FLAC__stream_decoder_delete(decoder);
 202
 203         return cd.object;
 204 }
 205
 206 FLAC_API FLAC__bool FLAC__metadata_get_streaminfo(const char *filename, FLAC__StreamMetadata *streaminfo)
 207 {
 208         FLAC__StreamMetadata *object;
 209
 210         FLAC__ASSERT(0 != filename);
 211         FLAC__ASSERT(0 != streaminfo);
 212
 213         object = get_one_metadata_block_(filename, FLAC__METADATA_TYPE_STREAMINFO);
 214
 215         if (object) {
 216                 /* can just copy the contents since STREAMINFO has no internal structure */
 217                 *streaminfo = *object;
 218                 FLAC__metadata_object_delete(object);
 219                 return true;
 220         }
 221         else {
 222                 return false;
 223         }
 224 }
 225
 226 FLAC_API FLAC__bool FLAC__metadata_get_tags(const char *filename, FLAC__StreamMetadata **tags)
 227 {
 228         FLAC__ASSERT(0 != filename);
 229         FLAC__ASSERT(0 != tags);
 230
 231         *tags = get_one_metadata_block_(filename, FLAC__METADATA_TYPE_VORBIS_COMMENT);
 232
 233         return 0 != *tags;
 234 }
 235
 236 FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__StreamMetadata **cuesheet)
 237 {
 238         FLAC__ASSERT(0 != filename);
 239         FLAC__ASSERT(0 != cuesheet);
 240
 241         *cuesheet = get_one_metadata_block_(filename, FLAC__METADATA_TYPE_CUESHEET);
 242
 243         return 0 != *cuesheet;
 244 }
 245
 246 FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 247 {
 248         (void)decoder, (void)frame, (void)buffer, (void)client_data;
 249
 250         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 251 }
 252
 253 void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 254 {
 255         level0_client_data *cd = (level0_client_data *)client_data;
 256         (void)decoder;
 257
 258         /*
 259          * we assume we only get here when the one metadata block we were
 260          * looking for was passed to us
 261          */
 262         if(!cd->got_error && 0 == cd->object) {
 263                 if(0 == (cd->object = FLAC__metadata_object_clone(metadata)))
 264                         cd->got_error = true;
 265         }
 266 }
 267
 268 void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 269 {
 270         level0_client_data *cd = (level0_client_data *)client_data;
 271         (void)decoder;
 272
 273         if(status != FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC)
 274                 cd->got_error = true;
 275 }
 276
 277
 278 /****************************************************************************
 279  *
 280  * Level 1 implementation
 281  *
 282  ***************************************************************************/
 283
 284 #define SIMPLE_ITERATOR_MAX_PUSH_DEPTH (1+4)
 285 /* 1 for initial offset, +4 for our own personal use */
 286
 287 struct FLAC__Metadata_SimpleIterator {
 288         FILE *file;
 289         char *filename, *tempfile_path_prefix;
 290         struct stat stats;
 291         FLAC__bool has_stats;
 292         FLAC__bool is_writable;
 293         FLAC__Metadata_SimpleIteratorStatus status;
 294         off_t offset[SIMPLE_ITERATOR_MAX_PUSH_DEPTH];
 295         off_t first_offset; /* this is the offset to the STREAMINFO block */
 296         unsigned depth;
 297         /* this is the metadata block header of the current block we are pointing to: */
 298         FLAC__bool is_last;
 299         FLAC__MetadataType type;
 300         unsigned length;
 301 };
 302
 303 FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[] = {
 304         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK",
 305         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT",
 306         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE",
 307         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE",
 308         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE",
 309         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA",
 310         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR",
 311         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR",
 312         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR",
 313         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR",
 314         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR",
 315         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR",
 316         "FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR"
 317 };
 318
 319
 320 FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new()
 321 {
 322         FLAC__Metadata_SimpleIterator *iterator = (FLAC__Metadata_SimpleIterator*)calloc(1, sizeof(FLAC__Metadata_SimpleIterator));
 323
 324         if(0 != iterator) {
 325                 iterator->file = 0;
 326                 iterator->filename = 0;
 327                 iterator->tempfile_path_prefix = 0;
 328                 iterator->has_stats = false;
 329                 iterator->is_writable = false;
 330                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
 331                 iterator->first_offset = iterator->offset[0] = -1;
 332                 iterator->depth = 0;
 333         }
 334
 335         return iterator;
 336 }
 337
 338 static void simple_iterator_free_guts_(FLAC__Metadata_SimpleIterator *iterator)
 339 {
 340         FLAC__ASSERT(0 != iterator);
 341
 342         if(0 != iterator->file) {
 343                 fclose(iterator->file);
 344                 iterator->file = 0;
 345                 if(iterator->has_stats)
 346                         set_file_stats_(iterator->filename, &iterator->stats);
 347         }
 348         if(0 != iterator->filename) {
 349                 free(iterator->filename);
 350                 iterator->filename = 0;
 351         }
 352         if(0 != iterator->tempfile_path_prefix) {
 353                 free(iterator->tempfile_path_prefix);
 354                 iterator->tempfile_path_prefix = 0;
 355         }
 356 }
 357
 358 FLAC_API void FLAC__metadata_simple_iterator_delete(FLAC__Metadata_SimpleIterator *iterator)
 359 {
 360         FLAC__ASSERT(0 != iterator);
 361
 362         simple_iterator_free_guts_(iterator);
 363         free(iterator);
 364 }
 365
 366 FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_status(FLAC__Metadata_SimpleIterator *iterator)
 367 {
 368         FLAC__Metadata_SimpleIteratorStatus status;
 369
 370         FLAC__ASSERT(0 != iterator);
 371
 372         status = iterator->status;
 373         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
 374         return status;
 375 }
 376
 377 static FLAC__bool simple_iterator_prime_input_(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool read_only)
 378 {
 379         unsigned ret;
 380
 381         FLAC__ASSERT(0 != iterator);
 382
 383         if(read_only || 0 == (iterator->file = fopen(iterator->filename, "r+b"))) {
 384                 iterator->is_writable = false;
 385                 if(read_only || errno == EACCES) {
 386                         if(0 == (iterator->file = fopen(iterator->filename, "rb"))) {
 387                                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
 388                                 return false;
 389                         }
 390                 }
 391                 else {
 392                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
 393                         return false;
 394                 }
 395         }
 396         else {
 397                 iterator->is_writable = true;
 398         }
 399
 400         ret = seek_to_first_metadata_block_(iterator->file);
 401         switch(ret) {
 402                 case 0:
 403                         iterator->depth = 0;
 404                         iterator->first_offset = iterator->offset[iterator->depth] = ftello(iterator->file);
 405                         return read_metadata_block_header_(iterator);
 406                 case 1:
 407                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
 408                         return false;
 409                 case 2:
 410                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
 411                         return false;
 412                 case 3:
 413                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE;
 414                         return false;
 415                 default:
 416                         FLAC__ASSERT(0);
 417                         return false;
 418         }
 419 }
 420
 421 #if 0
 422 @@@ If we decide to finish implementing this, put this comment back in metadata.h
 423 /*
 424  * The 'tempfile_path_prefix' allows you to specify a directory where
 425  * tempfiles should go.  Remember that if your metadata edits cause the
 426  * FLAC file to grow, the entire file will have to be rewritten.  If
 427  * 'tempfile_path_prefix' is NULL, the temp file will be written in the
 428  * same directory as the original FLAC file.  This makes replacing the
 429  * original with the tempfile fast but requires extra space in the same
 430  * partition for the tempfile.  If space is a problem, you can pass a
 431  * directory name belonging to a different partition in
 432  * 'tempfile_path_prefix'.  Note that you should use the forward slash
 433  * '/' as the directory separator.  A trailing slash is not needed; it
 434  * will be added automatically.
 435  */
 436 FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool preserve_file_stats, const char *tempfile_path_prefix);
 437 #endif
 438
 439 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_init(FLAC__Metadata_SimpleIterator *iterator, const char *filename, FLAC__bool read_only, FLAC__bool preserve_file_stats)
 440 {
 441         const char *tempfile_path_prefix = 0; /*@@@ search for comments near 'rename(...)' for what it will take to finish implementing this */
 442
 443         FLAC__ASSERT(0 != iterator);
 444         FLAC__ASSERT(0 != filename);
 445
 446         simple_iterator_free_guts_(iterator);
 447
 448         if(!read_only && preserve_file_stats)
 449                 iterator->has_stats = get_file_stats_(filename, &iterator->stats);
 450
 451         if(0 == (iterator->filename = strdup(filename))) {
 452                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
 453                 return false;
 454         }
 455         if(0 != tempfile_path_prefix && 0 == (iterator->tempfile_path_prefix = strdup(tempfile_path_prefix))) {
 456                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
 457                 return false;
 458         }
 459
 460         return simple_iterator_prime_input_(iterator, read_only);
 461 }
 462
 463 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_is_writable(const FLAC__Metadata_SimpleIterator *iterator)
 464 {
 465         FLAC__ASSERT(0 != iterator);
 466         FLAC__ASSERT(0 != iterator->file);
 467
 468         return iterator->is_writable;
 469 }
 470
 471 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_next(FLAC__Metadata_SimpleIterator *iterator)
 472 {
 473         FLAC__ASSERT(0 != iterator);
 474         FLAC__ASSERT(0 != iterator->file);
 475
 476         if(iterator->is_last)
 477                 return false;
 478
 479         if(0 != fseeko(iterator->file, iterator->length, SEEK_CUR)) {
 480                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
 481                 return false;
 482         }
 483
 484         iterator->offset[iterator->depth] = ftello(iterator->file);
 485
 486         return read_metadata_block_header_(iterator);
 487 }
 488
 489 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_prev(FLAC__Metadata_SimpleIterator *iterator)
 490 {
 491         off_t this_offset;
 492
 493         FLAC__ASSERT(0 != iterator);
 494         FLAC__ASSERT(0 != iterator->file);
 495
 496         if(iterator->offset[iterator->depth] == iterator->first_offset)
 497                 return false;
 498
 499         if(0 != fseeko(iterator->file, iterator->first_offset, SEEK_SET)) {
 500                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
 501                 return false;
 502         }
 503         this_offset = iterator->first_offset;
 504         if(!read_metadata_block_header_(iterator))
 505                 return false;
 506
 507         /* we ignore any error from ftello() and catch it in fseeko() */
 508         while(ftello(iterator->file) + (off_t)iterator->length < iterator->offset[iterator->depth]) {
 509                 if(0 != fseeko(iterator->file, iterator->length, SEEK_CUR)) {
 510                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
 511                         return false;
 512                 }
 513                 this_offset = ftello(iterator->file);
 514                 if(!read_metadata_block_header_(iterator))
 515                         return false;
 516         }
 517
 518         iterator->offset[iterator->depth] = this_offset;
 519
 520         return true;
 521 }
 522
 523 FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const FLAC__Metadata_SimpleIterator *iterator)
 524 {
 525         FLAC__ASSERT(0 != iterator);
 526         FLAC__ASSERT(0 != iterator->file);
 527
 528         return iterator->type;
 529 }
 530
 531 FLAC_API FLAC__StreamMetadata *FLAC__metadata_simple_iterator_get_block(FLAC__Metadata_SimpleIterator *iterator)
 532 {
 533         FLAC__StreamMetadata *block = FLAC__metadata_object_new(iterator->type);
 534
 535         FLAC__ASSERT(0 != iterator);
 536         FLAC__ASSERT(0 != iterator->file);
 537
 538         if(0 != block) {
 539                 block->is_last = iterator->is_last;
 540                 block->length = iterator->length;
 541
 542                 if(!read_metadata_block_data_(iterator, block)) {
 543                         FLAC__metadata_object_delete(block);
 544                         return 0;
 545                 }
 546
 547                 /* back up to the beginning of the block data to stay consistent */
 548                 if(0 != fseeko(iterator->file, iterator->offset[iterator->depth] + FLAC__STREAM_METADATA_HEADER_LENGTH, SEEK_SET)) {
 549                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
 550                         FLAC__metadata_object_delete(block);
 551                         return 0;
 552                 }
 553         }
 554         else
 555                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
 556
 557         return block;
 558 }
 559
 560 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_set_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding)
 561 {
 562         FLAC__ASSERT_DECLARATION(off_t debug_target_offset = iterator->offset[iterator->depth];)
 563         FLAC__bool ret;
 564
 565         FLAC__ASSERT(0 != iterator);
 566         FLAC__ASSERT(0 != iterator->file);
 567         FLAC__ASSERT(0 != block);
 568
 569         if(!iterator->is_writable) {
 570                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE;
 571                 return false;
 572         }
 573
 574         if(iterator->type == FLAC__METADATA_TYPE_STREAMINFO || block->type == FLAC__METADATA_TYPE_STREAMINFO) {
 575                 if(iterator->type != block->type) {
 576                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
 577                         return false;
 578                 }
 579         }
 580
 581         block->is_last = iterator->is_last;
 582
 583         if(iterator->length == block->length)
 584                 return write_metadata_block_stationary_(iterator, block);
 585         else if(iterator->length > block->length) {
 586                 if(use_padding && iterator->length >= FLAC__STREAM_METADATA_HEADER_LENGTH + block->length) {
 587                         ret = write_metadata_block_stationary_with_padding_(iterator, block, iterator->length - FLAC__STREAM_METADATA_HEADER_LENGTH - block->length, block->is_last);
 588                         FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
 589                         FLAC__ASSERT(!ret || ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 590                         return ret;
 591                 }
 592                 else {
 593                         ret = rewrite_whole_file_(iterator, block, /*append=*/false);
 594                         FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
 595                         FLAC__ASSERT(!ret || ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 596                         return ret;
 597                 }
 598         }
 599         else /* iterator->length < block->length */ {
 600                 unsigned padding_leftover = 0;
 601                 FLAC__bool padding_is_last = false;
 602                 if(use_padding) {
 603                         /* first see if we can even use padding */
 604                         if(iterator->is_last) {
 605                                 use_padding = false;
 606                         }
 607                         else {
 608                                 const unsigned extra_padding_bytes_required = block->length - iterator->length;
 609                                 simple_iterator_push_(iterator);
 610                                 if(!FLAC__metadata_simple_iterator_next(iterator)) {
 611                                         (void)simple_iterator_pop_(iterator);
 612                                         return false;
 613                                 }
 614                                 if(iterator->type != FLAC__METADATA_TYPE_PADDING) {
 615                                         use_padding = false;
 616                                 }
 617                                 else {
 618                                         if(FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length == extra_padding_bytes_required) {
 619                                                 padding_leftover = 0;
 620                                                 block->is_last = iterator->is_last;
 621                                         }
 622                                         else if(iterator->length < extra_padding_bytes_required)
 623                                                 use_padding = false;
 624                                         else {
 625                                                 padding_leftover = FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length - extra_padding_bytes_required;
 626                                                 padding_is_last = iterator->is_last;
 627                                                 block->is_last = false;
 628                                         }
 629                                 }
 630                                 if(!simple_iterator_pop_(iterator))
 631                                         return false;
 632                         }
 633                 }
 634                 if(use_padding) {
 635                         if(padding_leftover == 0) {
 636                                 ret = write_metadata_block_stationary_(iterator, block);
 637                                 FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
 638                                 FLAC__ASSERT(!ret || ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 639                                 return ret;
 640                         }
 641                         else {
 642                                 FLAC__ASSERT(padding_leftover >= FLAC__STREAM_METADATA_HEADER_LENGTH);
 643                                 ret = write_metadata_block_stationary_with_padding_(iterator, block, padding_leftover - FLAC__STREAM_METADATA_HEADER_LENGTH, padding_is_last);
 644                                 FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
 645                                 FLAC__ASSERT(!ret || ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 646                                 return ret;
 647                         }
 648                 }
 649                 else {
 650                         ret = rewrite_whole_file_(iterator, block, /*append=*/false);
 651                         FLAC__ASSERT(!ret || iterator->offset[iterator->depth] == debug_target_offset);
 652                         FLAC__ASSERT(!ret || ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 653                         return ret;
 654                 }
 655         }
 656 }
 657
 658 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_insert_block_after(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool use_padding)
 659 {
 660         unsigned padding_leftover = 0;
 661         FLAC__bool padding_is_last = false;
 662
 663         FLAC__ASSERT_DECLARATION(off_t debug_target_offset = iterator->offset[iterator->depth] + FLAC__STREAM_METADATA_HEADER_LENGTH + iterator->length;)
 664         FLAC__bool ret;
 665
 666         FLAC__ASSERT(0 != iterator);
 667         FLAC__ASSERT(0 != iterator->file);
 668         FLAC__ASSERT(0 != block);
 669
 670         if(!iterator->is_writable)
 671                 return false;
 672
 673         if(block->type == FLAC__METADATA_TYPE_STREAMINFO) {
 674                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
 675                 return false;
 676         }
 677
 678         block->is_last = iterator->is_last;
 679
 680         if(use_padding) {
 681                 /* first see if we can even use padding */
 682                 if(iterator->is_last) {
 683                         use_padding = false;
 684                 }
 685                 else {
 686                         simple_iterator_push_(iterator);
 687                         if(!FLAC__metadata_simple_iterator_next(iterator)) {
 688                                 (void)simple_iterator_pop_(iterator);
 689                                 return false;
 690                         }
 691                         if(iterator->type != FLAC__METADATA_TYPE_PADDING) {
 692                                 use_padding = false;
 693                         }
 694                         else {
 695                                 if(iterator->length == block->length) {
 696                                         padding_leftover = 0;
 697                                         block->is_last = iterator->is_last;
 698                                 }
 699                                 else if(iterator->length < FLAC__STREAM_METADATA_HEADER_LENGTH + block->length)
 700                                         use_padding = false;
 701                                 else {
 702                                         padding_leftover = iterator->length - block->length;
 703                                         padding_is_last = iterator->is_last;
 704                                         block->is_last = false;
 705                                 }
 706                         }
 707                         if(!simple_iterator_pop_(iterator))
 708                                 return false;
 709                 }
 710         }
 711         if(use_padding) {
 712                 /* move to the next block, which is suitable padding */
 713                 if(!FLAC__metadata_simple_iterator_next(iterator))
 714                         return false;
 715                 if(padding_leftover == 0) {
 716                         ret = write_metadata_block_stationary_(iterator, block);
 717                         FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
 718                         FLAC__ASSERT(ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 719                         return ret;
 720                 }
 721                 else {
 722                         FLAC__ASSERT(padding_leftover >= FLAC__STREAM_METADATA_HEADER_LENGTH);
 723                         ret = write_metadata_block_stationary_with_padding_(iterator, block, padding_leftover - FLAC__STREAM_METADATA_HEADER_LENGTH, padding_is_last);
 724                         FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
 725                         FLAC__ASSERT(ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 726                         return ret;
 727                 }
 728         }
 729         else {
 730                 ret = rewrite_whole_file_(iterator, block, /*append=*/true);
 731                 FLAC__ASSERT(iterator->offset[iterator->depth] == debug_target_offset);
 732                 FLAC__ASSERT(ftello(iterator->file) == debug_target_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH);
 733                 return ret;
 734         }
 735 }
 736
 737 FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_SimpleIterator *iterator, FLAC__bool use_padding)
 738 {
 739         FLAC__ASSERT_DECLARATION(off_t debug_target_offset = iterator->offset[iterator->depth];)
 740         FLAC__bool ret;
 741
 742         if(iterator->type == FLAC__METADATA_TYPE_STREAMINFO) {
 743                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT;
 744                 return false;
 745         }
 746
 747         if(use_padding) {
 748                 FLAC__StreamMetadata *padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
 749                 if(0 == padding) {
 750                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
 751                         return false;
 752                 }
 753                 padding->length = iterator->length;
 754                 if(!FLAC__metadata_simple_iterator_set_block(iterator, padding, false)) {
 755                         FLAC__metadata_object_delete(padding);
 756                         return false;
 757                 }
 758                 FLAC__metadata_object_delete(padding);
 759                 if(!FLAC__metadata_simple_iterator_prev(iterator))
 760                         return false;
 761                 FLAC__ASSERT(iterator->offset[iterator->depth] + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH + (off_t)iterator->length == debug_target_offset);
 762                 FLAC__ASSERT(ftello(iterator->file) + (off_t)iterator->length == debug_target_offset);
 763                 return true;
 764         }
 765         else {
 766                 ret = rewrite_whole_file_(iterator, 0, /*append=*/false);
 767                 FLAC__ASSERT(iterator->offset[iterator->depth] + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH + (off_t)iterator->length == debug_target_offset);
 768                 FLAC__ASSERT(ftello(iterator->file) + (off_t)iterator->length == debug_target_offset);
 769                 return ret;
 770         }
 771 }
 772
 773
 774
 775 /****************************************************************************
 776  *
 777  * Level 2 implementation
 778  *
 779  ***************************************************************************/
 780
 781
 782 typedef struct FLAC__Metadata_Node {
 783         FLAC__StreamMetadata *data;
 784         struct FLAC__Metadata_Node *prev, *next;
 785 } FLAC__Metadata_Node;
 786
 787 struct FLAC__Metadata_Chain {
 788         char *filename; /* will be NULL if using callbacks */
 789         FLAC__Metadata_Node *head;
 790         FLAC__Metadata_Node *tail;
 791         unsigned nodes;
 792         FLAC__Metadata_ChainStatus status;
 793         off_t first_offset, last_offset;
 794         /*
 795          * This is the length of the chain initially read from the FLAC file.
 796          * it is used to compare against the current length to decide whether
 797          * or not the whole file has to be rewritten.
 798          */
 799         off_t initial_length;
 800 };
 801
 802 struct FLAC__Metadata_Iterator {
 803         FLAC__Metadata_Chain *chain;
 804         FLAC__Metadata_Node *current;
 805 };
 806
 807 FLAC_API const char * const FLAC__Metadata_ChainStatusString[] = {
 808         "FLAC__METADATA_CHAIN_STATUS_OK",
 809         "FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT",
 810         "FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE",
 811         "FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE",
 812         "FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE",
 813         "FLAC__METADATA_CHAIN_STATUS_BAD_METADATA",
 814         "FLAC__METADATA_CHAIN_STATUS_READ_ERROR",
 815         "FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR",
 816         "FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR",
 817         "FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR",
 818         "FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR",
 819         "FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR",
 820         "FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR",
 821         "FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS",
 822         "FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH",
 823         "FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL"
 824 };
 825
 826
 827 static FLAC__Metadata_Node *node_new_()
 828 {
 829         return (FLAC__Metadata_Node*)calloc(1, sizeof(FLAC__Metadata_Node));
 830 }
 831
 832 static void node_delete_(FLAC__Metadata_Node *node)
 833 {
 834         FLAC__ASSERT(0 != node);
 835         if(0 != node->data)
 836                 FLAC__metadata_object_delete(node->data);
 837         free(node);
 838 }
 839
 840 static void chain_init_(FLAC__Metadata_Chain *chain)
 841 {
 842         FLAC__ASSERT(0 != chain);
 843
 844         chain->filename = 0;
 845         chain->head = chain->tail = 0;
 846         chain->nodes = 0;
 847         chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
 848         chain->initial_length = 0;
 849 }
 850
 851 static void chain_clear_(FLAC__Metadata_Chain *chain)
 852 {
 853         FLAC__Metadata_Node *node, *next;
 854
 855         FLAC__ASSERT(0 != chain);
 856
 857         for(node = chain->head; node; ) {
 858                 next = node->next;
 859                 node_delete_(node);
 860                 node = next;
 861         }
 862
 863         if(0 != chain->filename)
 864                 free(chain->filename);
 865
 866         chain_init_(chain);
 867 }
 868
 869 static void chain_append_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
 870 {
 871         FLAC__ASSERT(0 != chain);
 872         FLAC__ASSERT(0 != node);
 873         FLAC__ASSERT(0 != node->data);
 874
 875         node->next = node->prev = 0;
 876         node->data->is_last = true;
 877         if(0 != chain->tail)
 878                 chain->tail->data->is_last = false;
 879
 880         if(0 == chain->head)
 881                 chain->head = node;
 882         else {
 883                 FLAC__ASSERT(0 != chain->tail);
 884                 chain->tail->next = node;
 885                 node->prev = chain->tail;
 886         }
 887         chain->tail = node;
 888         chain->nodes++;
 889 }
 890
 891 static void chain_remove_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
 892 {
 893         FLAC__ASSERT(0 != chain);
 894         FLAC__ASSERT(0 != node);
 895
 896         if(node == chain->head)
 897                 chain->head = node->next;
 898         else
 899                 node->prev->next = node->next;
 900
 901         if(node == chain->tail)
 902                 chain->tail = node->prev;
 903         else
 904                 node->next->prev = node->prev;
 905
 906         if(0 != chain->tail)
 907                 chain->tail->data->is_last = true;
 908
 909         chain->nodes--;
 910 }
 911
 912 static void chain_delete_node_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
 913 {
 914         chain_remove_node_(chain, node);
 915         node_delete_(node);
 916 }
 917
 918 static off_t chain_calculate_length_(FLAC__Metadata_Chain *chain)
 919 {
 920         const FLAC__Metadata_Node *node;
 921         off_t length = 0;
 922         for(node = chain->head; node; node = node->next)
 923                 length += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
 924         return length;
 925 }
 926
 927 static void iterator_insert_node_(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Node *node)
 928 {
 929         FLAC__ASSERT(0 != node);
 930         FLAC__ASSERT(0 != node->data);
 931         FLAC__ASSERT(0 != iterator);
 932         FLAC__ASSERT(0 != iterator->current);
 933         FLAC__ASSERT(0 != iterator->chain);
 934         FLAC__ASSERT(0 != iterator->chain->head);
 935         FLAC__ASSERT(0 != iterator->chain->tail);
 936
 937         node->data->is_last = false;
 938
 939         node->prev = iterator->current->prev;
 940         node->next = iterator->current;
 941
 942         if(0 == node->prev)
 943                 iterator->chain->head = node;
 944         else
 945                 node->prev->next = node;
 946
 947         iterator->current->prev = node;
 948
 949         iterator->chain->nodes++;
 950 }
 951
 952 static void iterator_insert_node_after_(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Node *node)
 953 {
 954         FLAC__ASSERT(0 != node);
 955         FLAC__ASSERT(0 != node->data);
 956         FLAC__ASSERT(0 != iterator);
 957         FLAC__ASSERT(0 != iterator->current);
 958         FLAC__ASSERT(0 != iterator->chain);
 959         FLAC__ASSERT(0 != iterator->chain->head);
 960         FLAC__ASSERT(0 != iterator->chain->tail);
 961
 962         iterator->current->data->is_last = false;
 963
 964         node->prev = iterator->current;
 965         node->next = iterator->current->next;
 966
 967         if(0 == node->next)
 968                 iterator->chain->tail = node;
 969         else
 970                 node->next->prev = node;
 971
 972         node->prev->next = node;
 973
 974         iterator->chain->tail->data->is_last = true;
 975
 976         iterator->chain->nodes++;
 977 }
 978
 979 /* return true iff node and node->next are both padding */
 980 static FLAC__bool chain_merge_adjacent_padding_(FLAC__Metadata_Chain *chain, FLAC__Metadata_Node *node)
 981 {
 982         if(node->data->type == FLAC__METADATA_TYPE_PADDING && 0 != node->next && node->next->data->type == FLAC__METADATA_TYPE_PADDING) {
 983                 const unsigned growth = FLAC__STREAM_METADATA_HEADER_LENGTH + node->next->data->length;
 984                 node->data->length += growth;
 985
 986                 chain_delete_node_(chain, node->next);
 987                 return true;
 988         }
 989         else
 990                 return false;
 991 }
 992
 993 /* Returns the new length of the chain, or 0 if there was an error. */
 994 /* WATCHOUT: This can get called multiple times before a write, so
 995  * it should still work when this happens.
 996  */
 997 /* WATCHOUT: Make sure to also update the logic in
 998  * FLAC__metadata_chain_check_if_tempfile_needed() if the logic here changes.
 999  */
1000 static off_t chain_prepare_for_write_(FLAC__Metadata_Chain *chain, FLAC__bool use_padding)
1001 {
1002         off_t current_length = chain_calculate_length_(chain);
1003
1004         if(use_padding) {
1005                 /* if the metadata shrank and the last block is padding, we just extend the last padding block */
1006                 if(current_length < chain->initial_length && chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
1007                         const off_t delta = chain->initial_length - current_length;
1008                         chain->tail->data->length += delta;
1009                         current_length += delta;
1010                         FLAC__ASSERT(current_length == chain->initial_length);
1011                 }
1012                 /* if the metadata shrank more than 4 bytes then there's room to add another padding block */
1013                 else if(current_length + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH <= chain->initial_length) {
1014                         FLAC__StreamMetadata *padding;
1015                         FLAC__Metadata_Node *node;
1016                         if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING))) {
1017                                 chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
1018                                 return 0;
1019                         }
1020                         padding->length = chain->initial_length - (FLAC__STREAM_METADATA_HEADER_LENGTH + current_length);
1021                         if(0 == (node = node_new_())) {
1022                                 FLAC__metadata_object_delete(padding);
1023                                 chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
1024                                 return 0;
1025                         }
1026                         node->data = padding;
1027                         chain_append_node_(chain, node);
1028                         current_length = chain_calculate_length_(chain);
1029                         FLAC__ASSERT(current_length == chain->initial_length);
1030                 }
1031                 /* if the metadata grew but the last block is padding, try cutting the padding to restore the original length so we don't have to rewrite the whole file */
1032                 else if(current_length > chain->initial_length) {
1033                         const off_t delta = current_length - chain->initial_length;
1034                         if(chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
1035                                 /* if the delta is exactly the size of the last padding block, remove the padding block */
1036                                 if((off_t)chain->tail->data->length + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH == delta) {
1037                                         chain_delete_node_(chain, chain->tail);
1038                                         current_length = chain_calculate_length_(chain);
1039                                         FLAC__ASSERT(current_length == chain->initial_length);
1040                                 }
1041                                 /* if there is at least 'delta' bytes of padding, trim the padding down */
1042                                 else if((off_t)chain->tail->data->length >= delta) {
1043                                         chain->tail->data->length -= delta;
1044                                         current_length -= delta;
1045                                         FLAC__ASSERT(current_length == chain->initial_length);
1046                                 }
1047                         }
1048                 }
1049         }
1050
1051         return current_length;
1052 }
1053
1054 static FLAC__bool chain_read_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__IOCallback_Tell tell_cb)
1055 {
1056         FLAC__Metadata_Node *node;
1057
1058         FLAC__ASSERT(0 != chain);
1059
1060         /* we assume we're already at the beginning of the file */
1061
1062         switch(seek_to_first_metadata_block_cb_(handle, read_cb, seek_cb)) {
1063                 case 0:
1064                         break;
1065                 case 1:
1066                         chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
1067                         return false;
1068                 case 2:
1069                         chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1070                         return false;
1071                 case 3:
1072                         chain->status = FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE;
1073                         return false;
1074                 default:
1075                         FLAC__ASSERT(0);
1076                         return false;
1077         }
1078
1079         {
1080                 FLAC__int64 pos = tell_cb(handle);
1081                 if(pos < 0) {
1082                         chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
1083                         return false;
1084                 }
1085                 chain->first_offset = (off_t)pos;
1086         }
1087
1088         {
1089                 FLAC__bool is_last;
1090                 FLAC__MetadataType type;
1091                 unsigned length;
1092
1093                 do {
1094                         node = node_new_();
1095                         if(0 == node) {
1096                                 chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
1097                                 return false;
1098                         }
1099
1100                         if(!read_metadata_block_header_cb_(handle, read_cb, &is_last, &type, &length)) {
1101                                 chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
1102                                 return false;
1103                         }
1104
1105                         node->data = FLAC__metadata_object_new(type);
1106                         if(0 == node->data) {
1107                                 node_delete_(node);
1108                                 chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
1109                                 return false;
1110                         }
1111
1112                         node->data->is_last = is_last;
1113                         node->data->length = length;
1114
1115                         chain->status = get_equivalent_status_(read_metadata_block_data_cb_(handle, read_cb, seek_cb, node->data));
1116                         if(chain->status != FLAC__METADATA_CHAIN_STATUS_OK) {
1117                                 node_delete_(node);
1118                                 return false;
1119                         }
1120                         chain_append_node_(chain, node);
1121                 } while(!is_last);
1122         }
1123
1124         {
1125                 FLAC__int64 pos = tell_cb(handle);
1126                 if(pos < 0) {
1127                         chain->status = FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
1128                         return false;
1129                 }
1130                 chain->last_offset = (off_t)pos;
1131         }
1132
1133         chain->initial_length = chain_calculate_length_(chain);
1134
1135         return true;
1136 }
1137
1138 static FLAC__bool chain_rewrite_metadata_in_place_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, FLAC__IOCallback_Seek seek_cb)
1139 {
1140         FLAC__Metadata_Node *node;
1141
1142         FLAC__ASSERT(0 != chain);
1143         FLAC__ASSERT(0 != chain->head);
1144
1145         if(0 != seek_cb(handle, chain->first_offset, SEEK_SET)) {
1146                 chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1147                 return false;
1148         }
1149
1150         for(node = chain->head; node; node = node->next) {
1151                 if(!write_metadata_block_header_cb_(handle, write_cb, node->data)) {
1152                         chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
1153                         return false;
1154                 }
1155                 if(!write_metadata_block_data_cb_(handle, write_cb, node->data)) {
1156                         chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
1157                         return false;
1158                 }
1159         }
1160
1161         /*FLAC__ASSERT(fflush(), ftello() == chain->last_offset);*/
1162
1163         chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
1164         return true;
1165 }
1166
1167 static FLAC__bool chain_rewrite_metadata_in_place_(FLAC__Metadata_Chain *chain)
1168 {
1169         FILE *file;
1170         FLAC__bool ret;
1171
1172         FLAC__ASSERT(0 != chain->filename);
1173
1174         if(0 == (file = fopen(chain->filename, "r+b"))) {
1175                 chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
1176                 return false;
1177         }
1178
1179         /* chain_rewrite_metadata_in_place_cb_() sets chain->status for us */
1180         ret = chain_rewrite_metadata_in_place_cb_(chain, (FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, fseek_wrapper_);
1181
1182         fclose(file);
1183
1184         return ret;
1185 }
1186
1187 static FLAC__bool chain_rewrite_file_(FLAC__Metadata_Chain *chain, const char *tempfile_path_prefix)
1188 {
1189         FILE *f, *tempfile;
1190         char *tempfilename;
1191         FLAC__Metadata_SimpleIteratorStatus status;
1192         const FLAC__Metadata_Node *node;
1193
1194         FLAC__ASSERT(0 != chain);
1195         FLAC__ASSERT(0 != chain->filename);
1196         FLAC__ASSERT(0 != chain->head);
1197
1198         /* copy the file prefix (data up to first metadata block */
1199         if(0 == (f = fopen(chain->filename, "rb"))) {
1200                 chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
1201                 return false;
1202         }
1203         if(!open_tempfile_(chain->filename, tempfile_path_prefix, &tempfile, &tempfilename, &status)) {
1204                 chain->status = get_equivalent_status_(status);
1205                 cleanup_tempfile_(&tempfile, &tempfilename);
1206                 return false;
1207         }
1208         if(!copy_n_bytes_from_file_(f, tempfile, chain->first_offset, &status)) {
1209                 chain->status = get_equivalent_status_(status);
1210                 cleanup_tempfile_(&tempfile, &tempfilename);
1211                 return false;
1212         }
1213
1214         /* write the metadata */
1215         for(node = chain->head; node; node = node->next) {
1216                 if(!write_metadata_block_header_(tempfile, &status, node->data)) {
1217                         chain->status = get_equivalent_status_(status);
1218                         return false;
1219                 }
1220                 if(!write_metadata_block_data_(tempfile, &status, node->data)) {
1221                         chain->status = get_equivalent_status_(status);
1222                         return false;
1223                 }
1224         }
1225         /*FLAC__ASSERT(fflush(), ftello() == chain->last_offset);*/
1226
1227         /* copy the file postfix (everything after the metadata) */
1228         if(0 != fseeko(f, chain->last_offset, SEEK_SET)) {
1229                 cleanup_tempfile_(&tempfile, &tempfilename);
1230                 chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1231                 return false;
1232         }
1233         if(!copy_remaining_bytes_from_file_(f, tempfile, &status)) {
1234                 cleanup_tempfile_(&tempfile, &tempfilename);
1235                 chain->status = get_equivalent_status_(status);
1236                 return false;
1237         }
1238
1239         /* move the tempfile on top of the original */
1240         (void)fclose(f);
1241         if(!transport_tempfile_(chain->filename, &tempfile, &tempfilename, &status))
1242                 return false;
1243
1244         return true;
1245 }
1246
1247 /* assumes 'handle' is already at beginning of file */
1248 static FLAC__bool chain_rewrite_file_cb_(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb)
1249 {
1250         FLAC__Metadata_SimpleIteratorStatus status;
1251         const FLAC__Metadata_Node *node;
1252
1253         FLAC__ASSERT(0 != chain);
1254         FLAC__ASSERT(0 == chain->filename);
1255         FLAC__ASSERT(0 != chain->head);
1256
1257         /* copy the file prefix (data up to first metadata block */
1258         if(!copy_n_bytes_from_file_cb_(handle, read_cb, temp_handle, temp_write_cb, chain->first_offset, &status)) {
1259                 chain->status = get_equivalent_status_(status);
1260                 return false;
1261         }
1262
1263         /* write the metadata */
1264         for(node = chain->head; node; node = node->next) {
1265                 if(!write_metadata_block_header_cb_(temp_handle, temp_write_cb, node->data)) {
1266                         chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
1267                         return false;
1268                 }
1269                 if(!write_metadata_block_data_cb_(temp_handle, temp_write_cb, node->data)) {
1270                         chain->status = FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
1271                         return false;
1272                 }
1273         }
1274         /*FLAC__ASSERT(fflush(), ftello() == chain->last_offset);*/
1275
1276         /* copy the file postfix (everything after the metadata) */
1277         if(0 != seek_cb(handle, chain->last_offset, SEEK_SET)) {
1278                 chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1279                 return false;
1280         }
1281         if(!copy_remaining_bytes_from_file_cb_(handle, read_cb, eof_cb, temp_handle, temp_write_cb, &status)) {
1282                 chain->status = get_equivalent_status_(status);
1283                 return false;
1284         }
1285
1286         return true;
1287 }
1288
1289 FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new()
1290 {
1291         FLAC__Metadata_Chain *chain = (FLAC__Metadata_Chain*)calloc(1, sizeof(FLAC__Metadata_Chain));
1292
1293         if(0 != chain)
1294                 chain_init_(chain);
1295
1296         return chain;
1297 }
1298
1299 FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain)
1300 {
1301         FLAC__ASSERT(0 != chain);
1302
1303         chain_clear_(chain);
1304
1305         free(chain);
1306 }
1307
1308 FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain)
1309 {
1310         FLAC__Metadata_ChainStatus status;
1311
1312         FLAC__ASSERT(0 != chain);
1313
1314         status = chain->status;
1315         chain->status = FLAC__METADATA_CHAIN_STATUS_OK;
1316         return status;
1317 }
1318
1319 FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename)
1320 {
1321         FILE *file;
1322         FLAC__bool ret;
1323
1324         FLAC__ASSERT(0 != chain);
1325         FLAC__ASSERT(0 != filename);
1326
1327         chain_clear_(chain);
1328
1329         if(0 == (chain->filename = strdup(filename))) {
1330                 chain->status = FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
1331                 return false;
1332         }
1333
1334         if(0 == (file = fopen(filename, "rb"))) {
1335                 chain->status = FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
1336                 return false;
1337         }
1338
1339         /* chain_read_cb_() sets chain->status for us */
1340         ret = chain_read_cb_(chain, file, (FLAC__IOCallback_Read)fread, fseek_wrapper_, ftell_wrapper_);
1341
1342         fclose(file);
1343
1344         return ret;
1345 }
1346
1347 FLAC_API FLAC__bool FLAC__metadata_chain_read_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks)
1348 {
1349         FLAC__ASSERT(0 != chain);
1350
1351         chain_clear_(chain);
1352
1353         if (0 == callbacks.read || 0 == callbacks.seek || 0 == callbacks.tell) {
1354                 chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
1355                 return false;
1356         }
1357
1358         /* rewind */
1359         if(0 != callbacks.seek(handle, 0, SEEK_SET)) {
1360                 chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1361                 return false;
1362         }
1363
1364         if(!chain_read_cb_(chain, handle, callbacks.read, callbacks.seek, callbacks.tell))
1365                 return false; /* chain->status is already set by chain_read_cb_ */
1366
1367         return true;
1368 }
1369
1370 FLAC_API FLAC__bool FLAC__metadata_chain_check_if_tempfile_needed(FLAC__Metadata_Chain *chain, FLAC__bool use_padding)
1371 {
1372         /* This does all the same checks that are in chain_prepare_for_write_()
1373          * but doesn't actually alter the chain.  Make sure to update the logic
1374          * here if chain_prepare_for_write_() changes.
1375          */
1376         const off_t current_length = chain_calculate_length_(chain);
1377
1378         FLAC__ASSERT(0 != chain);
1379
1380         if(use_padding) {
1381                 /* if the metadata shrank and the last block is padding, we just extend the last padding block */
1382                 if(current_length < chain->initial_length && chain->tail->data->type == FLAC__METADATA_TYPE_PADDING)
1383                         return false;
1384                 /* if the metadata shrank more than 4 bytes then there's room to add another padding block */
1385                 else if(current_length + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH <= chain->initial_length)
1386                         return false;
1387                 /* if the metadata grew but the last block is padding, try cutting the padding to restore the original length so we don't have to rewrite the whole file */
1388                 else if(current_length > chain->initial_length) {
1389                         const off_t delta = current_length - chain->initial_length;
1390                         if(chain->tail->data->type == FLAC__METADATA_TYPE_PADDING) {
1391                                 /* if the delta is exactly the size of the last padding block, remove the padding block */
1392                                 if((off_t)chain->tail->data->length + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH == delta)
1393                                         return false;
1394                                 /* if there is at least 'delta' bytes of padding, trim the padding down */
1395                                 else if((off_t)chain->tail->data->length >= delta)
1396                                         return false;
1397                         }
1398                 }
1399         }
1400
1401         return (current_length != chain->initial_length);
1402 }
1403
1404 FLAC_API FLAC__bool FLAC__metadata_chain_write(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats)
1405 {
1406         struct stat stats;
1407         const char *tempfile_path_prefix = 0;
1408         off_t current_length;
1409
1410         FLAC__ASSERT(0 != chain);
1411
1412         if (0 == chain->filename) {
1413                 chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
1414                 return false;
1415         }
1416
1417         current_length = chain_prepare_for_write_(chain, use_padding);
1418
1419         /* a return value of 0 means there was an error; chain->status is already set */
1420         if (0 == current_length)
1421                 return false;
1422
1423         if(preserve_file_stats)
1424                 get_file_stats_(chain->filename, &stats);
1425
1426         if(current_length == chain->initial_length) {
1427                 if(!chain_rewrite_metadata_in_place_(chain))
1428                         return false;
1429         }
1430         else {
1431                 if(!chain_rewrite_file_(chain, tempfile_path_prefix))
1432                         return false;
1433
1434                 /* recompute lengths and offsets */
1435                 {
1436                         const FLAC__Metadata_Node *node;
1437                         chain->initial_length = current_length;
1438                         chain->last_offset = chain->first_offset;
1439                         for(node = chain->head; node; node = node->next)
1440                                 chain->last_offset += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
1441                 }
1442         }
1443
1444         if(preserve_file_stats)
1445                 set_file_stats_(chain->filename, &stats);
1446
1447         return true;
1448 }
1449
1450 FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks)
1451 {
1452         off_t current_length;
1453
1454         FLAC__ASSERT(0 != chain);
1455
1456         if (0 != chain->filename) {
1457                 chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
1458                 return false;
1459         }
1460
1461         if (0 == callbacks.write || 0 == callbacks.seek) {
1462                 chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
1463                 return false;
1464         }
1465
1466         if (FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding)) {
1467                 chain->status = FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL;
1468                 return false;
1469         }
1470
1471         current_length = chain_prepare_for_write_(chain, use_padding);
1472
1473         /* a return value of 0 means there was an error; chain->status is already set */
1474         if (0 == current_length)
1475                 return false;
1476
1477         FLAC__ASSERT(current_length == chain->initial_length);
1478
1479         return chain_rewrite_metadata_in_place_cb_(chain, handle, callbacks.write, callbacks.seek);
1480 }
1481
1482 FLAC_API FLAC__bool FLAC__metadata_chain_write_with_callbacks_and_tempfile(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__IOHandle handle, FLAC__IOCallbacks callbacks, FLAC__IOHandle temp_handle, FLAC__IOCallbacks temp_callbacks)
1483 {
1484         off_t current_length;
1485
1486         FLAC__ASSERT(0 != chain);
1487
1488         if (0 != chain->filename) {
1489                 chain->status = FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH;
1490                 return false;
1491         }
1492
1493         if (0 == callbacks.read || 0 == callbacks.seek || 0 == callbacks.eof) {
1494                 chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
1495                 return false;
1496         }
1497         if (0 == temp_callbacks.write) {
1498                 chain->status = FLAC__METADATA_CHAIN_STATUS_INVALID_CALLBACKS;
1499                 return false;
1500         }
1501
1502         if (!FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding)) {
1503                 chain->status = FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL;
1504                 return false;
1505         }
1506
1507         current_length = chain_prepare_for_write_(chain, use_padding);
1508
1509         /* a return value of 0 means there was an error; chain->status is already set */
1510         if (0 == current_length)
1511                 return false;
1512
1513         FLAC__ASSERT(current_length != chain->initial_length);
1514
1515         /* rewind */
1516         if(0 != callbacks.seek(handle, 0, SEEK_SET)) {
1517                 chain->status = FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
1518                 return false;
1519         }
1520
1521         if(!chain_rewrite_file_cb_(chain, handle, callbacks.read, callbacks.seek, callbacks.eof, temp_handle, temp_callbacks.write))
1522                 return false;
1523
1524         /* recompute lengths and offsets */
1525         {
1526                 const FLAC__Metadata_Node *node;
1527                 chain->initial_length = current_length;
1528                 chain->last_offset = chain->first_offset;
1529                 for(node = chain->head; node; node = node->next)
1530                         chain->last_offset += (FLAC__STREAM_METADATA_HEADER_LENGTH + node->data->length);
1531         }
1532
1533         return true;
1534 }
1535
1536 FLAC_API void FLAC__metadata_chain_merge_padding(FLAC__Metadata_Chain *chain)
1537 {
1538         FLAC__Metadata_Node *node;
1539
1540         FLAC__ASSERT(0 != chain);
1541
1542         for(node = chain->head; node; ) {
1543                 if(!chain_merge_adjacent_padding_(chain, node))
1544                         node = node->next;
1545         }
1546 }
1547
1548 FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain)
1549 {
1550         FLAC__Metadata_Node *node, *save;
1551         unsigned i;
1552
1553         FLAC__ASSERT(0 != chain);
1554
1555         /*
1556          * Don't try and be too smart... this simple algo is good enough for
1557          * the small number of nodes that we deal with.
1558          */
1559         for(i = 0, node = chain->head; i < chain->nodes; i++) {
1560                 if(node->data->type == FLAC__METADATA_TYPE_PADDING) {
1561                         save = node->next;
1562                         chain_remove_node_(chain, node);
1563                         chain_append_node_(chain, node);
1564                         node = save;
1565                 }
1566                 else {
1567                         node = node->next;
1568                 }
1569         }
1570
1571         FLAC__metadata_chain_merge_padding(chain);
1572 }
1573
1574
1575 FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new()
1576 {
1577         FLAC__Metadata_Iterator *iterator = (FLAC__Metadata_Iterator*)calloc(1, sizeof(FLAC__Metadata_Iterator));
1578
1579         /* calloc() implies:
1580                 iterator->current = 0;
1581                 iterator->chain = 0;
1582         */
1583
1584         return iterator;
1585 }
1586
1587 FLAC_API void FLAC__metadata_iterator_delete(FLAC__Metadata_Iterator *iterator)
1588 {
1589         FLAC__ASSERT(0 != iterator);
1590
1591         free(iterator);
1592 }
1593
1594 FLAC_API void FLAC__metadata_iterator_init(FLAC__Metadata_Iterator *iterator, FLAC__Metadata_Chain *chain)
1595 {
1596         FLAC__ASSERT(0 != iterator);
1597         FLAC__ASSERT(0 != chain);
1598         FLAC__ASSERT(0 != chain->head);
1599
1600         iterator->chain = chain;
1601         iterator->current = chain->head;
1602 }
1603
1604 FLAC_API FLAC__bool FLAC__metadata_iterator_next(FLAC__Metadata_Iterator *iterator)
1605 {
1606         FLAC__ASSERT(0 != iterator);
1607
1608         if(0 == iterator->current || 0 == iterator->current->next)
1609                 return false;
1610
1611         iterator->current = iterator->current->next;
1612         return true;
1613 }
1614
1615 FLAC_API FLAC__bool FLAC__metadata_iterator_prev(FLAC__Metadata_Iterator *iterator)
1616 {
1617         FLAC__ASSERT(0 != iterator);
1618
1619         if(0 == iterator->current || 0 == iterator->current->prev)
1620                 return false;
1621
1622         iterator->current = iterator->current->prev;
1623         return true;
1624 }
1625
1626 FLAC_API FLAC__MetadataType FLAC__metadata_iterator_get_block_type(const FLAC__Metadata_Iterator *iterator)
1627 {
1628         FLAC__ASSERT(0 != iterator);
1629         FLAC__ASSERT(0 != iterator->current);
1630         FLAC__ASSERT(0 != iterator->current->data);
1631
1632         return iterator->current->data->type;
1633 }
1634
1635 FLAC_API FLAC__StreamMetadata *FLAC__metadata_iterator_get_block(FLAC__Metadata_Iterator *iterator)
1636 {
1637         FLAC__ASSERT(0 != iterator);
1638         FLAC__ASSERT(0 != iterator->current);
1639
1640         return iterator->current->data;
1641 }
1642
1643 FLAC_API FLAC__bool FLAC__metadata_iterator_set_block(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
1644 {
1645         FLAC__ASSERT(0 != iterator);
1646         FLAC__ASSERT(0 != block);
1647         return FLAC__metadata_iterator_delete_block(iterator, false) && FLAC__metadata_iterator_insert_block_after(iterator, block);
1648 }
1649
1650 FLAC_API FLAC__bool FLAC__metadata_iterator_delete_block(FLAC__Metadata_Iterator *iterator, FLAC__bool replace_with_padding)
1651 {
1652         FLAC__Metadata_Node *save;
1653
1654         FLAC__ASSERT(0 != iterator);
1655         FLAC__ASSERT(0 != iterator->current);
1656
1657         if(0 == iterator->current->prev) {
1658                 FLAC__ASSERT(iterator->current->data->type == FLAC__METADATA_TYPE_STREAMINFO);
1659                 return false;
1660         }
1661
1662         save = iterator->current->prev;
1663
1664         if(replace_with_padding) {
1665                 FLAC__metadata_object_delete_data(iterator->current->data);
1666                 iterator->current->data->type = FLAC__METADATA_TYPE_PADDING;
1667         }
1668         else {
1669                 chain_delete_node_(iterator->chain, iterator->current);
1670         }
1671
1672         iterator->current = save;
1673         return true;
1674 }
1675
1676 FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_before(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
1677 {
1678         FLAC__Metadata_Node *node;
1679
1680         FLAC__ASSERT(0 != iterator);
1681         FLAC__ASSERT(0 != iterator->current);
1682         FLAC__ASSERT(0 != block);
1683
1684         if(block->type == FLAC__METADATA_TYPE_STREAMINFO)
1685                 return false;
1686
1687         if(0 == iterator->current->prev) {
1688                 FLAC__ASSERT(iterator->current->data->type == FLAC__METADATA_TYPE_STREAMINFO);
1689                 return false;
1690         }
1691
1692         if(0 == (node = node_new_()))
1693                 return false;
1694
1695         node->data = block;
1696         iterator_insert_node_(iterator, node);
1697         iterator->current = node;
1698         return true;
1699 }
1700
1701 FLAC_API FLAC__bool FLAC__metadata_iterator_insert_block_after(FLAC__Metadata_Iterator *iterator, FLAC__StreamMetadata *block)
1702 {
1703         FLAC__Metadata_Node *node;
1704
1705         FLAC__ASSERT(0 != iterator);
1706         FLAC__ASSERT(0 != iterator->current);
1707         FLAC__ASSERT(0 != block);
1708
1709         if(block->type == FLAC__METADATA_TYPE_STREAMINFO)
1710                 return false;
1711
1712         if(0 == (node = node_new_()))
1713                 return false;
1714
1715         node->data = block;
1716         iterator_insert_node_after_(iterator, node);
1717         iterator->current = node;
1718         return true;
1719 }
1720
1721
1722 /****************************************************************************
1723  *
1724  * Local function definitions
1725  *
1726  ***************************************************************************/
1727
1728 void pack_uint32_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes)
1729 {
1730         unsigned i;
1731
1732         b += bytes;
1733
1734         for(i = 0; i < bytes; i++) {
1735                 *(--b) = (FLAC__byte)(val & 0xff);
1736                 val >>= 8;
1737         }
1738 }
1739
1740 void pack_uint32_little_endian_(FLAC__uint32 val, FLAC__byte *b, unsigned bytes)
1741 {
1742         unsigned i;
1743
1744         for(i = 0; i < bytes; i++) {
1745                 *(b++) = (FLAC__byte)(val & 0xff);
1746                 val >>= 8;
1747         }
1748 }
1749
1750 void pack_uint64_(FLAC__uint64 val, FLAC__byte *b, unsigned bytes)
1751 {
1752         unsigned i;
1753
1754         b += bytes;
1755
1756         for(i = 0; i < bytes; i++) {
1757                 *(--b) = (FLAC__byte)(val & 0xff);
1758                 val >>= 8;
1759         }
1760 }
1761
1762 FLAC__uint32 unpack_uint32_(FLAC__byte *b, unsigned bytes)
1763 {
1764         FLAC__uint32 ret = 0;
1765         unsigned i;
1766
1767         for(i = 0; i < bytes; i++)
1768                 ret = (ret << 8) | (FLAC__uint32)(*b++);
1769
1770         return ret;
1771 }
1772
1773 FLAC__uint32 unpack_uint32_little_endian_(FLAC__byte *b, unsigned bytes)
1774 {
1775         FLAC__uint32 ret = 0;
1776         unsigned i;
1777
1778         b += bytes;
1779
1780         for(i = 0; i < bytes; i++)
1781                 ret = (ret << 8) | (FLAC__uint32)(*--b);
1782
1783         return ret;
1784 }
1785
1786 FLAC__uint64 unpack_uint64_(FLAC__byte *b, unsigned bytes)
1787 {
1788         FLAC__uint64 ret = 0;
1789         unsigned i;
1790
1791         for(i = 0; i < bytes; i++)
1792                 ret = (ret << 8) | (FLAC__uint64)(*b++);
1793
1794         return ret;
1795 }
1796
1797 FLAC__bool read_metadata_block_header_(FLAC__Metadata_SimpleIterator *iterator)
1798 {
1799         FLAC__ASSERT(0 != iterator);
1800         FLAC__ASSERT(0 != iterator->file);
1801
1802         if(!read_metadata_block_header_cb_((FLAC__IOHandle)iterator->file, (FLAC__IOCallback_Read)fread, &iterator->is_last, &iterator->type, &iterator->length)) {
1803                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1804                 return false;
1805         }
1806
1807         return true;
1808 }
1809
1810 FLAC__bool read_metadata_block_data_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block)
1811 {
1812         FLAC__ASSERT(0 != iterator);
1813         FLAC__ASSERT(0 != iterator->file);
1814
1815         iterator->status = read_metadata_block_data_cb_((FLAC__IOHandle)iterator->file, (FLAC__IOCallback_Read)fread, fseek_wrapper_, block);
1816
1817         return (iterator->status == FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK);
1818 }
1819
1820 FLAC__bool read_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__bool *is_last, FLAC__MetadataType *type, unsigned *length)
1821 {
1822         FLAC__byte raw_header[FLAC__STREAM_METADATA_HEADER_LENGTH];
1823
1824         if(read_cb(raw_header, 1, FLAC__STREAM_METADATA_HEADER_LENGTH, handle) != FLAC__STREAM_METADATA_HEADER_LENGTH)
1825                 return false;
1826
1827         *is_last = raw_header[0] & 0x80? true : false;
1828         *type = (FLAC__MetadataType)(raw_header[0] & 0x7f);
1829         *length = unpack_uint32_(raw_header + 1, 3);
1830
1831         /* Note that we don't check:
1832          *    if(iterator->type >= FLAC__METADATA_TYPE_UNDEFINED)
1833          * we just will read in an opaque block
1834          */
1835
1836         return true;
1837 }
1838
1839 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata *block)
1840 {
1841         switch(block->type) {
1842                 case FLAC__METADATA_TYPE_STREAMINFO:
1843                         return read_metadata_block_data_streaminfo_cb_(handle, read_cb, &block->data.stream_info);
1844                 case FLAC__METADATA_TYPE_PADDING:
1845                         return read_metadata_block_data_padding_cb_(handle, seek_cb, &block->data.padding, block->length);
1846                 case FLAC__METADATA_TYPE_APPLICATION:
1847                         return read_metadata_block_data_application_cb_(handle, read_cb, &block->data.application, block->length);
1848                 case FLAC__METADATA_TYPE_SEEKTABLE:
1849                         return read_metadata_block_data_seektable_cb_(handle, read_cb, &block->data.seek_table, block->length);
1850                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
1851                         return read_metadata_block_data_vorbis_comment_cb_(handle, read_cb, &block->data.vorbis_comment);
1852                 case FLAC__METADATA_TYPE_CUESHEET:
1853                         return read_metadata_block_data_cuesheet_cb_(handle, read_cb, &block->data.cue_sheet);
1854                 default:
1855                         return read_metadata_block_data_unknown_cb_(handle, read_cb, &block->data.unknown, block->length);
1856         }
1857 }
1858
1859 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_StreamInfo *block)
1860 {
1861         FLAC__byte buffer[FLAC__STREAM_METADATA_STREAMINFO_LENGTH], *b;
1862
1863         if(read_cb(buffer, 1, FLAC__STREAM_METADATA_STREAMINFO_LENGTH, handle) != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
1864                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1865
1866         b = buffer;
1867
1868         /* we are using hardcoded numbers for simplicity but we should
1869          * probably eventually write a bit-level unpacker and use the
1870          * _STREAMINFO_ constants.
1871          */
1872         block->min_blocksize = unpack_uint32_(b, 2); b += 2;
1873         block->max_blocksize = unpack_uint32_(b, 2); b += 2;
1874         block->min_framesize = unpack_uint32_(b, 3); b += 3;
1875         block->max_framesize = unpack_uint32_(b, 3); b += 3;
1876         block->sample_rate = (unpack_uint32_(b, 2) << 4) | ((unsigned)(b[2] & 0xf0) >> 4);
1877         block->channels = (unsigned)((b[2] & 0x0e) >> 1) + 1;
1878         block->bits_per_sample = ((((unsigned)(b[2] & 0x01)) << 4) | (((unsigned)(b[3] & 0xf0)) >> 4)) + 1;
1879         block->total_samples = (((FLAC__uint64)(b[3] & 0x0f)) << 32) | unpack_uint64_(b+4, 4);
1880         memcpy(block->md5sum, b+8, 16);
1881
1882         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
1883 }
1884
1885
1886 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Seek seek_cb, FLAC__StreamMetadata_Padding *block, unsigned block_length)
1887 {
1888         (void)block; /* nothing to do; we don't care about reading the padding bytes */
1889
1890         if(0 != seek_cb(handle, block_length, SEEK_CUR))
1891                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
1892
1893         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
1894 }
1895
1896 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Application *block, unsigned block_length)
1897 {
1898         const unsigned id_bytes = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
1899
1900         if(read_cb(block->id, 1, id_bytes, handle) != id_bytes)
1901                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1902
1903         block_length -= id_bytes;
1904
1905         if(block_length == 0) {
1906                 block->data = 0;
1907         }
1908         else {
1909                 if(0 == (block->data = (FLAC__byte*)malloc(block_length)))
1910                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
1911
1912                 if(read_cb(block->data, 1, block_length, handle) != block_length)
1913                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1914         }
1915
1916         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
1917 }
1918
1919 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_SeekTable *block, unsigned block_length)
1920 {
1921         unsigned i;
1922         FLAC__byte buffer[FLAC__STREAM_METADATA_SEEKPOINT_LENGTH];
1923
1924         FLAC__ASSERT(block_length % FLAC__STREAM_METADATA_SEEKPOINT_LENGTH == 0);
1925
1926         block->num_points = block_length / FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
1927
1928         if(block->num_points == 0)
1929                 block->points = 0;
1930         else if(0 == (block->points = (FLAC__StreamMetadata_SeekPoint*)malloc(block->num_points * sizeof(FLAC__StreamMetadata_SeekPoint))))
1931                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
1932
1933         for(i = 0; i < block->num_points; i++) {
1934                 if(read_cb(buffer, 1, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH, handle) != FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)
1935                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1936                 /* some MAGIC NUMBERs here */
1937                 block->points[i].sample_number = unpack_uint64_(buffer, 8);
1938                 block->points[i].stream_offset = unpack_uint64_(buffer+8, 8);
1939                 block->points[i].frame_samples = unpack_uint32_(buffer+16, 2);
1940         }
1941
1942         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
1943 }
1944
1945 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_entry_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment_Entry *entry)
1946 {
1947         const unsigned entry_length_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
1948         FLAC__byte buffer[4]; /* magic number is asserted below */
1949
1950         FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8 == 4);
1951
1952         if(read_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
1953                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1954         entry->length = unpack_uint32_little_endian_(buffer, entry_length_len);
1955
1956         if(0 != entry->entry)
1957                 free(entry->entry);
1958
1959         if(entry->length == 0) {
1960                 entry->entry = 0;
1961         }
1962         else {
1963                 if(0 == (entry->entry = (FLAC__byte*)malloc(entry->length+1)))
1964                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
1965
1966                 if(read_cb(entry->entry, 1, entry->length, handle) != entry->length)
1967                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1968
1969                 entry->entry[entry->length] = '\0';
1970         }
1971
1972         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
1973 }
1974
1975 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_VorbisComment *block)
1976 {
1977         unsigned i;
1978         FLAC__Metadata_SimpleIteratorStatus status;
1979         const unsigned num_comments_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
1980         FLAC__byte buffer[4]; /* magic number is asserted below */
1981
1982         FLAC__ASSERT(FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8 == 4);
1983
1984         if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_vorbis_comment_entry_cb_(handle, read_cb, &(block->vendor_string))))
1985                 return status;
1986
1987         if(read_cb(buffer, 1, num_comments_len, handle) != num_comments_len)
1988                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
1989         block->num_comments = unpack_uint32_little_endian_(buffer, num_comments_len);
1990
1991         if(block->num_comments == 0) {
1992                 block->comments = 0;
1993         }
1994         else if(0 == (block->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)calloc(block->num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry))))
1995                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
1996
1997         for(i = 0; i < block->num_comments; i++) {
1998                 if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_vorbis_comment_entry_cb_(handle, read_cb, block->comments + i)))
1999                         return status;
2000         }
2001
2002         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
2003 }
2004
2005 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_track_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet_Track *track)
2006 {
2007         unsigned i, len;
2008         FLAC__byte buffer[32]; /* asserted below that this is big enough */
2009
2010         FLAC__ASSERT(sizeof(buffer) >= sizeof(FLAC__uint64));
2011         FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN/8);
2012         FLAC__ASSERT(sizeof(buffer) >= (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8);
2013
2014         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN % 8 == 0);
2015         len = FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN / 8;
2016         if(read_cb(buffer, 1, len, handle) != len)
2017                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2018         track->offset = unpack_uint64_(buffer, len);
2019
2020         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN % 8 == 0);
2021         len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN / 8;
2022         if(read_cb(buffer, 1, len, handle) != len)
2023                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2024         track->number = (FLAC__byte)unpack_uint32_(buffer, len);
2025
2026         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
2027         len = FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN / 8;
2028         if(read_cb(track->isrc, 1, len, handle) != len)
2029                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2030
2031         FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) % 8 == 0);
2032         len = (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8;
2033         if(read_cb(buffer, 1, len, handle) != len)
2034                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2035         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN == 1);
2036         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN == 1);
2037         track->type = buffer[0] >> 7;
2038         track->pre_emphasis = (buffer[0] >> 6) & 1;
2039
2040         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN % 8 == 0);
2041         len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN / 8;
2042         if(read_cb(buffer, 1, len, handle) != len)
2043                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2044         track->num_indices = (FLAC__byte)unpack_uint32_(buffer, len);
2045
2046         if(track->num_indices == 0) {
2047                 track->indices = 0;
2048         }
2049         else if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*)calloc(track->num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index))))
2050                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2051
2052         for(i = 0; i < track->num_indices; i++) {
2053                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN % 8 == 0);
2054                 len = FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN / 8;
2055                 if(read_cb(buffer, 1, len, handle) != len)
2056                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2057                 track->indices[i].offset = unpack_uint64_(buffer, len);
2058
2059                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN % 8 == 0);
2060                 len = FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN / 8;
2061                 if(read_cb(buffer, 1, len, handle) != len)
2062                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2063                 track->indices[i].number = (FLAC__byte)unpack_uint32_(buffer, len);
2064
2065                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN % 8 == 0);
2066                 len = FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN / 8;
2067                 if(read_cb(buffer, 1, len, handle) != len)
2068                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2069         }
2070
2071         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
2072 }
2073
2074 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_CueSheet *block)
2075 {
2076         unsigned i, len;
2077         FLAC__Metadata_SimpleIteratorStatus status;
2078         FLAC__byte buffer[1024]; /* MSVC needs a constant expression so we put a magic number and assert */
2079
2080         FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN)/8 <= sizeof(buffer));
2081         FLAC__ASSERT(sizeof(FLAC__uint64) <= sizeof(buffer));
2082
2083         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
2084         len = FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN / 8;
2085         if(read_cb(block->media_catalog_number, 1, len, handle) != len)
2086                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2087
2088         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN % 8 == 0);
2089         len = FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN / 8;
2090         if(read_cb(buffer, 1, len, handle) != len)
2091                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2092         block->lead_in = unpack_uint64_(buffer, len);
2093
2094         FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) % 8 == 0);
2095         len = (FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) / 8;
2096         if(read_cb(buffer, 1, len, handle) != len)
2097                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2098         block->is_cd = buffer[0]&0x80? true : false;
2099
2100         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN % 8 == 0);
2101         len = FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN / 8;
2102         if(read_cb(buffer, 1, len, handle) != len)
2103                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2104         block->num_tracks = unpack_uint32_(buffer, len);
2105
2106         if(block->num_tracks == 0) {
2107                 block->tracks = 0;
2108         }
2109         else if(0 == (block->tracks = (FLAC__StreamMetadata_CueSheet_Track*)calloc(block->num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track))))
2110                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2111
2112         for(i = 0; i < block->num_tracks; i++) {
2113                 if(FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK != (status = read_metadata_block_data_cuesheet_track_cb_(handle, read_cb, block->tracks + i)))
2114                         return status;
2115         }
2116
2117         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
2118 }
2119
2120 FLAC__Metadata_SimpleIteratorStatus read_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__StreamMetadata_Unknown *block, unsigned block_length)
2121 {
2122         if(block_length == 0) {
2123                 block->data = 0;
2124         }
2125         else {
2126                 if(0 == (block->data = (FLAC__byte*)malloc(block_length)))
2127                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2128
2129                 if(read_cb(block->data, 1, block_length, handle) != block_length)
2130                         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2131         }
2132
2133         return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
2134 }
2135
2136 FLAC__bool write_metadata_block_header_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block)
2137 {
2138         FLAC__ASSERT(0 != file);
2139         FLAC__ASSERT(0 != status);
2140
2141         if(!write_metadata_block_header_cb_((FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, block)) {
2142                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2143                 return false;
2144         }
2145
2146         return true;
2147 }
2148
2149 FLAC__bool write_metadata_block_data_(FILE *file, FLAC__Metadata_SimpleIteratorStatus *status, const FLAC__StreamMetadata *block)
2150 {
2151         FLAC__ASSERT(0 != file);
2152         FLAC__ASSERT(0 != status);
2153
2154         if (write_metadata_block_data_cb_((FLAC__IOHandle)file, (FLAC__IOCallback_Write)fwrite, block)) {
2155                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK;
2156                 return true;
2157         }
2158         else {
2159                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2160                 return false;
2161         }
2162 }
2163
2164 FLAC__bool write_metadata_block_header_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block)
2165 {
2166         FLAC__byte buffer[FLAC__STREAM_METADATA_HEADER_LENGTH];
2167
2168         FLAC__ASSERT(block->length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
2169
2170         buffer[0] = (block->is_last? 0x80 : 0) | (FLAC__byte)block->type;
2171         pack_uint32_(block->length, buffer + 1, 3);
2172
2173         if(write_cb(buffer, 1, FLAC__STREAM_METADATA_HEADER_LENGTH, handle) != FLAC__STREAM_METADATA_HEADER_LENGTH)
2174                 return false;
2175
2176         return true;
2177 }
2178
2179 FLAC__bool write_metadata_block_data_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata *block)
2180 {
2181         FLAC__ASSERT(0 != block);
2182
2183         switch(block->type) {
2184                 case FLAC__METADATA_TYPE_STREAMINFO:
2185                         return write_metadata_block_data_streaminfo_cb_(handle, write_cb, &block->data.stream_info);
2186                 case FLAC__METADATA_TYPE_PADDING:
2187                         return write_metadata_block_data_padding_cb_(handle, write_cb, &block->data.padding, block->length);
2188                 case FLAC__METADATA_TYPE_APPLICATION:
2189                         return write_metadata_block_data_application_cb_(handle, write_cb, &block->data.application, block->length);
2190                 case FLAC__METADATA_TYPE_SEEKTABLE:
2191                         return write_metadata_block_data_seektable_cb_(handle, write_cb, &block->data.seek_table);
2192                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
2193                         return write_metadata_block_data_vorbis_comment_cb_(handle, write_cb, &block->data.vorbis_comment);
2194                 case FLAC__METADATA_TYPE_CUESHEET:
2195                         return write_metadata_block_data_cuesheet_cb_(handle, write_cb, &block->data.cue_sheet);
2196                 default:
2197                         return write_metadata_block_data_unknown_cb_(handle, write_cb, &block->data.unknown, block->length);
2198         }
2199 }
2200
2201 FLAC__bool write_metadata_block_data_streaminfo_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_StreamInfo *block)
2202 {
2203         FLAC__byte buffer[FLAC__STREAM_METADATA_STREAMINFO_LENGTH];
2204         const unsigned channels1 = block->channels - 1;
2205         const unsigned bps1 = block->bits_per_sample - 1;
2206
2207         /* we are using hardcoded numbers for simplicity but we should
2208          * probably eventually write a bit-level packer and use the
2209          * _STREAMINFO_ constants.
2210          */
2211         pack_uint32_(block->min_blocksize, buffer, 2);
2212         pack_uint32_(block->max_blocksize, buffer+2, 2);
2213         pack_uint32_(block->min_framesize, buffer+4, 3);
2214         pack_uint32_(block->max_framesize, buffer+7, 3);
2215         buffer[10] = (block->sample_rate >> 12) & 0xff;
2216         buffer[11] = (block->sample_rate >> 4) & 0xff;
2217         buffer[12] = ((block->sample_rate & 0x0f) << 4) | (channels1 << 1) | (bps1 >> 4);
2218         buffer[13] = (FLAC__byte)(((bps1 & 0x0f) << 4) | ((block->total_samples >> 32) & 0x0f));
2219         pack_uint32_((FLAC__uint32)block->total_samples, buffer+14, 4);
2220         memcpy(buffer+18, block->md5sum, 16);
2221
2222         if(write_cb(buffer, 1, FLAC__STREAM_METADATA_STREAMINFO_LENGTH, handle) != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
2223                 return false;
2224
2225         return true;
2226 }
2227
2228 FLAC__bool write_metadata_block_data_padding_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Padding *block, unsigned block_length)
2229 {
2230         unsigned i, n = block_length;
2231         FLAC__byte buffer[1024];
2232
2233         (void)block;
2234
2235         memset(buffer, 0, 1024);
2236
2237         for(i = 0; i < n/1024; i++)
2238                 if(write_cb(buffer, 1, 1024, handle) != 1024)
2239                         return false;
2240
2241         n %= 1024;
2242
2243         if(write_cb(buffer, 1, n, handle) != n)
2244                 return false;
2245
2246         return true;
2247 }
2248
2249 FLAC__bool write_metadata_block_data_application_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Application *block, unsigned block_length)
2250 {
2251         const unsigned id_bytes = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
2252
2253         if(write_cb(block->id, 1, id_bytes, handle) != id_bytes)
2254                 return false;
2255
2256         block_length -= id_bytes;
2257
2258         if(write_cb(block->data, 1, block_length, handle) != block_length)
2259                 return false;
2260
2261         return true;
2262 }
2263
2264 FLAC__bool write_metadata_block_data_seektable_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_SeekTable *block)
2265 {
2266         unsigned i;
2267         FLAC__byte buffer[FLAC__STREAM_METADATA_SEEKPOINT_LENGTH];
2268
2269         for(i = 0; i < block->num_points; i++) {
2270                 /* some MAGIC NUMBERs here */
2271                 pack_uint64_(block->points[i].sample_number, buffer, 8);
2272                 pack_uint64_(block->points[i].stream_offset, buffer+8, 8);
2273                 pack_uint32_(block->points[i].frame_samples, buffer+16, 2);
2274                 if(write_cb(buffer, 1, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH, handle) != FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)
2275                         return false;
2276         }
2277
2278         return true;
2279 }
2280
2281 FLAC__bool write_metadata_block_data_vorbis_comment_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_VorbisComment *block)
2282 {
2283         unsigned i;
2284         const unsigned entry_length_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
2285         const unsigned num_comments_len = FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
2286         FLAC__byte buffer[4]; /* magic number is asserted below */
2287
2288         FLAC__ASSERT(max(FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN, FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8 == 4);
2289
2290         pack_uint32_little_endian_(block->vendor_string.length, buffer, entry_length_len);
2291         if(write_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
2292                 return false;
2293         if(write_cb(block->vendor_string.entry, 1, block->vendor_string.length, handle) != block->vendor_string.length)
2294                 return false;
2295
2296         pack_uint32_little_endian_(block->num_comments, buffer, num_comments_len);
2297         if(write_cb(buffer, 1, num_comments_len, handle) != num_comments_len)
2298                 return false;
2299
2300         for(i = 0; i < block->num_comments; i++) {
2301                 pack_uint32_little_endian_(block->comments[i].length, buffer, entry_length_len);
2302                 if(write_cb(buffer, 1, entry_length_len, handle) != entry_length_len)
2303                         return false;
2304                 if(write_cb(block->comments[i].entry, 1, block->comments[i].length, handle) != block->comments[i].length)
2305                         return false;
2306         }
2307
2308         return true;
2309 }
2310
2311 FLAC__bool write_metadata_block_data_cuesheet_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_CueSheet *block)
2312 {
2313         unsigned i, j, len;
2314         FLAC__byte buffer[1024]; /* asserted below that this is big enough */
2315
2316         FLAC__ASSERT(sizeof(buffer) >= sizeof(FLAC__uint64));
2317         FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN/8);
2318         FLAC__ASSERT(sizeof(buffer) >= (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN)/8);
2319         FLAC__ASSERT(sizeof(buffer) >= FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN/8);
2320
2321         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
2322         len = FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN / 8;
2323         if(write_cb(block->media_catalog_number, 1, len, handle) != len)
2324                 return false;
2325
2326         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN % 8 == 0);
2327         len = FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN / 8;
2328         pack_uint64_(block->lead_in, buffer, len);
2329         if(write_cb(buffer, 1, len, handle) != len)
2330                 return false;
2331
2332         FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) % 8 == 0);
2333         len = (FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN) / 8;
2334         memset(buffer, 0, len);
2335         if(block->is_cd)
2336                 buffer[0] |= 0x80;
2337         if(write_cb(buffer, 1, len, handle) != len)
2338                 return false;
2339
2340         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN % 8 == 0);
2341         len = FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN / 8;
2342         pack_uint32_(block->num_tracks, buffer, len);
2343         if(write_cb(buffer, 1, len, handle) != len)
2344                 return false;
2345
2346         for(i = 0; i < block->num_tracks; i++) {
2347                 FLAC__StreamMetadata_CueSheet_Track *track = block->tracks + i;
2348
2349                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN % 8 == 0);
2350                 len = FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN / 8;
2351                 pack_uint64_(track->offset, buffer, len);
2352                 if(write_cb(buffer, 1, len, handle) != len)
2353                         return false;
2354
2355                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN % 8 == 0);
2356                 len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN / 8;
2357                 pack_uint32_(track->number, buffer, len);
2358                 if(write_cb(buffer, 1, len, handle) != len)
2359                         return false;
2360
2361                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
2362                 len = FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN / 8;
2363                 if(write_cb(track->isrc, 1, len, handle) != len)
2364                         return false;
2365
2366                 FLAC__ASSERT((FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) % 8 == 0);
2367                 len = (FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN) / 8;
2368                 memset(buffer, 0, len);
2369                 buffer[0] = (track->type << 7) | (track->pre_emphasis << 6);
2370                 if(write_cb(buffer, 1, len, handle) != len)
2371                         return false;
2372
2373                 FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN % 8 == 0);
2374                 len = FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN / 8;
2375                 pack_uint32_(track->num_indices, buffer, len);
2376                 if(write_cb(buffer, 1, len, handle) != len)
2377                         return false;
2378
2379                 for(j = 0; j < track->num_indices; j++) {
2380                         FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j;
2381
2382                         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN % 8 == 0);
2383                         len = FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN / 8;
2384                         pack_uint64_(index->offset, buffer, len);
2385                         if(write_cb(buffer, 1, len, handle) != len)
2386                                 return false;
2387
2388                         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN % 8 == 0);
2389                         len = FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN / 8;
2390                         pack_uint32_(index->number, buffer, len);
2391                         if(write_cb(buffer, 1, len, handle) != len)
2392                                 return false;
2393
2394                         FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN % 8 == 0);
2395                         len = FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN / 8;
2396                         memset(buffer, 0, len);
2397                         if(write_cb(buffer, 1, len, handle) != len)
2398                                 return false;
2399                 }
2400         }
2401
2402         return true;
2403 }
2404
2405 FLAC__bool write_metadata_block_data_unknown_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Write write_cb, const FLAC__StreamMetadata_Unknown *block, unsigned block_length)
2406 {
2407         if(write_cb(block->data, 1, block_length, handle) != block_length)
2408                 return false;
2409
2410         return true;
2411 }
2412
2413 FLAC__bool write_metadata_block_stationary_(FLAC__Metadata_SimpleIterator *iterator, const FLAC__StreamMetadata *block)
2414 {
2415         if(0 != fseeko(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
2416                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2417                 return false;
2418         }
2419
2420         if(!write_metadata_block_header_(iterator->file, &iterator->status, block))
2421                 return false;
2422
2423         if(!write_metadata_block_data_(iterator->file, &iterator->status, block))
2424                 return false;
2425
2426         if(0 != fseeko(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
2427                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2428                 return false;
2429         }
2430
2431         return read_metadata_block_header_(iterator);
2432 }
2433
2434 FLAC__bool write_metadata_block_stationary_with_padding_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, unsigned padding_length, FLAC__bool padding_is_last)
2435 {
2436         FLAC__StreamMetadata *padding;
2437
2438         if(0 != fseeko(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
2439                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2440                 return false;
2441         }
2442
2443         block->is_last = false;
2444
2445         if(!write_metadata_block_header_(iterator->file, &iterator->status, block))
2446                 return false;
2447
2448         if(!write_metadata_block_data_(iterator->file, &iterator->status, block))
2449                 return false;
2450
2451         if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
2452                 return FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2453
2454         padding->is_last = padding_is_last;
2455         padding->length = padding_length;
2456
2457         if(!write_metadata_block_header_(iterator->file, &iterator->status, padding)) {
2458                 FLAC__metadata_object_delete(padding);
2459                 return false;
2460         }
2461
2462         if(!write_metadata_block_data_(iterator->file, &iterator->status, padding)) {
2463                 FLAC__metadata_object_delete(padding);
2464                 return false;
2465         }
2466
2467         FLAC__metadata_object_delete(padding);
2468
2469         if(0 != fseeko(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
2470                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2471                 return false;
2472         }
2473
2474         return read_metadata_block_header_(iterator);
2475 }
2476
2477 FLAC__bool rewrite_whole_file_(FLAC__Metadata_SimpleIterator *iterator, FLAC__StreamMetadata *block, FLAC__bool append)
2478 {
2479         FILE *tempfile;
2480         char *tempfilename;
2481         int fixup_is_last_code = 0; /* 0 => no need to change any is_last flags */
2482         off_t fixup_is_last_flag_offset = -1;
2483
2484         FLAC__ASSERT(0 != block || append == false);
2485
2486         if(iterator->is_last) {
2487                 if(append) {
2488                         fixup_is_last_code = 1; /* 1 => clear the is_last flag at the following offset */
2489                         fixup_is_last_flag_offset = iterator->offset[iterator->depth];
2490                 }
2491                 else if(0 == block) {
2492                         simple_iterator_push_(iterator);
2493                         if(!FLAC__metadata_simple_iterator_prev(iterator)) {
2494                                 (void)simple_iterator_pop_(iterator);
2495                                 return false;
2496                         }
2497                         fixup_is_last_code = -1; /* -1 => set the is_last the flag at the following offset */
2498                         fixup_is_last_flag_offset = iterator->offset[iterator->depth];
2499                         if(!simple_iterator_pop_(iterator))
2500                                 return false;
2501                 }
2502         }
2503
2504         if(!simple_iterator_copy_file_prefix_(iterator, &tempfile, &tempfilename, append))
2505                 return false;
2506
2507         if(0 != block) {
2508                 if(!write_metadata_block_header_(tempfile, &iterator->status, block)) {
2509                         cleanup_tempfile_(&tempfile, &tempfilename);
2510                         return false;
2511                 }
2512
2513                 if(!write_metadata_block_data_(tempfile, &iterator->status, block)) {
2514                         cleanup_tempfile_(&tempfile, &tempfilename);
2515                         return false;
2516                 }
2517         }
2518
2519         if(!simple_iterator_copy_file_postfix_(iterator, &tempfile, &tempfilename, fixup_is_last_code, fixup_is_last_flag_offset, block==0))
2520                 return false;
2521
2522         if(append)
2523                 return FLAC__metadata_simple_iterator_next(iterator);
2524
2525         return true;
2526 }
2527
2528 void simple_iterator_push_(FLAC__Metadata_SimpleIterator *iterator)
2529 {
2530         FLAC__ASSERT(iterator->depth+1 < SIMPLE_ITERATOR_MAX_PUSH_DEPTH);
2531         iterator->offset[iterator->depth+1] = iterator->offset[iterator->depth];
2532         iterator->depth++;
2533 }
2534
2535 FLAC__bool simple_iterator_pop_(FLAC__Metadata_SimpleIterator *iterator)
2536 {
2537         FLAC__ASSERT(iterator->depth > 0);
2538         iterator->depth--;
2539         if(0 != fseeko(iterator->file, iterator->offset[iterator->depth], SEEK_SET)) {
2540                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2541                 return false;
2542         }
2543
2544         return read_metadata_block_header_(iterator);
2545 }
2546
2547 /* return meanings:
2548  * 0: ok
2549  * 1: read error
2550  * 2: seek error
2551  * 3: not a FLAC file
2552  */
2553 unsigned seek_to_first_metadata_block_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Seek seek_cb)
2554 {
2555         FLAC__byte buffer[4];
2556         size_t n;
2557         unsigned i;
2558
2559         FLAC__ASSERT(FLAC__STREAM_SYNC_LENGTH == 4);
2560
2561         /* skip any id3v2 tag */
2562         errno = 0;
2563         n = read_cb(buffer, 1, 4, handle);
2564         if(errno)
2565                 return 1;
2566         else if(n != 4)
2567                 return 3;
2568         else if(0 == memcmp(buffer, "ID3", 3)) {
2569                 unsigned tag_length = 0;
2570
2571                 /* skip to the tag length */
2572                 if(seek_cb(handle, 2, SEEK_CUR) < 0)
2573                         return 2;
2574
2575                 /* read the length */
2576                 for(i = 0; i < 4; i++) {
2577                         if(read_cb(buffer, 1, 1, handle) < 1 || buffer[0] & 0x80)
2578                                 return 1;
2579                         tag_length <<= 7;
2580                         tag_length |= (buffer[0] & 0x7f);
2581                 }
2582
2583                 /* skip the rest of the tag */
2584                 if(seek_cb(handle, tag_length, SEEK_CUR) < 0)
2585                         return 2;
2586
2587                 /* read the stream sync code */
2588                 errno = 0;
2589                 n = read_cb(buffer, 1, 4, handle);
2590                 if(errno)
2591                         return 1;
2592                 else if(n != 4)
2593                         return 3;
2594         }
2595
2596         /* check for the fLaC signature */
2597         if(0 == memcmp(FLAC__STREAM_SYNC_STRING, buffer, FLAC__STREAM_SYNC_LENGTH))
2598                 return 0;
2599         else
2600                 return 3;
2601 }
2602
2603 unsigned seek_to_first_metadata_block_(FILE *f)
2604 {
2605         return seek_to_first_metadata_block_cb_((FLAC__IOHandle)f, (FLAC__IOCallback_Read)fread, fseek_wrapper_);
2606 }
2607
2608 FLAC__bool simple_iterator_copy_file_prefix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, FLAC__bool append)
2609 {
2610         const off_t offset_end = append? iterator->offset[iterator->depth] + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH + (off_t)iterator->length : iterator->offset[iterator->depth];
2611
2612         if(0 != fseeko(iterator->file, 0, SEEK_SET)) {
2613                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2614                 return false;
2615         }
2616         if(!open_tempfile_(iterator->filename, iterator->tempfile_path_prefix, tempfile, tempfilename, &iterator->status)) {
2617                 cleanup_tempfile_(tempfile, tempfilename);
2618                 return false;
2619         }
2620         if(!copy_n_bytes_from_file_(iterator->file, *tempfile, offset_end, &iterator->status)) {
2621                 cleanup_tempfile_(tempfile, tempfilename);
2622                 return false;
2623         }
2624
2625         return true;
2626 }
2627
2628 FLAC__bool simple_iterator_copy_file_postfix_(FLAC__Metadata_SimpleIterator *iterator, FILE **tempfile, char **tempfilename, int fixup_is_last_code, off_t fixup_is_last_flag_offset, FLAC__bool backup)
2629 {
2630         off_t save_offset = iterator->offset[iterator->depth];
2631         FLAC__ASSERT(0 != *tempfile);
2632
2633         if(0 != fseeko(iterator->file, save_offset + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH + (off_t)iterator->length, SEEK_SET)) {
2634                 cleanup_tempfile_(tempfile, tempfilename);
2635                 iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2636                 return false;
2637         }
2638         if(!copy_remaining_bytes_from_file_(iterator->file, *tempfile, &iterator->status)) {
2639                 cleanup_tempfile_(tempfile, tempfilename);
2640                 return false;
2641         }
2642
2643         if(fixup_is_last_code != 0) {
2644                 /*
2645                  * if code == 1, it means a block was appended to the end so
2646                  *   we have to clear the is_last flag of the previous block
2647                  * if code == -1, it means the last block was deleted so
2648                  *   we have to set the is_last flag of the previous block
2649                  */
2650                 /* MAGIC NUMBERs here; we know the is_last flag is the high bit of the byte at this location */
2651                 FLAC__byte x;
2652                 if(0 != fseeko(*tempfile, fixup_is_last_flag_offset, SEEK_SET)) {
2653                         cleanup_tempfile_(tempfile, tempfilename);
2654                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2655                         return false;
2656                 }
2657                 if(fread(&x, 1, 1, *tempfile) != 1) {
2658                         cleanup_tempfile_(tempfile, tempfilename);
2659                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2660                         return false;
2661                 }
2662                 if(fixup_is_last_code > 0) {
2663                         FLAC__ASSERT(x & 0x80);
2664                         x &= 0x7f;
2665                 }
2666                 else {
2667                         FLAC__ASSERT(!(x & 0x80));
2668                         x |= 0x80;
2669                 }
2670                 if(0 != fseeko(*tempfile, fixup_is_last_flag_offset, SEEK_SET)) {
2671                         cleanup_tempfile_(tempfile, tempfilename);
2672                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR;
2673                         return false;
2674                 }
2675                 if(local__fwrite(&x, 1, 1, *tempfile) != 1) {
2676                         cleanup_tempfile_(tempfile, tempfilename);
2677                         iterator->status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2678                         return false;
2679                 }
2680         }
2681
2682         (void)fclose(iterator->file);
2683
2684         if(!transport_tempfile_(iterator->filename, tempfile, tempfilename, &iterator->status))
2685                 return false;
2686
2687         if(iterator->has_stats)
2688                 set_file_stats_(iterator->filename, &iterator->stats);
2689
2690         if(!simple_iterator_prime_input_(iterator, !iterator->is_writable))
2691                 return false;
2692         if(backup) {
2693                 while(iterator->offset[iterator->depth] + (off_t)FLAC__STREAM_METADATA_HEADER_LENGTH + (off_t)iterator->length < save_offset)
2694                         if(!FLAC__metadata_simple_iterator_next(iterator))
2695                                 return false;
2696                 return true;
2697         }
2698         else {
2699                 /* move the iterator to it's original block faster by faking a push, then doing a pop_ */
2700                 FLAC__ASSERT(iterator->depth == 0);
2701                 iterator->offset[0] = save_offset;
2702                 iterator->depth++;
2703                 return simple_iterator_pop_(iterator);
2704         }
2705 }
2706
2707 FLAC__bool copy_n_bytes_from_file_(FILE *file, FILE *tempfile, off_t bytes, FLAC__Metadata_SimpleIteratorStatus *status)
2708 {
2709         FLAC__byte buffer[8192];
2710         size_t n;
2711
2712         while(bytes > 0) {
2713                 n = min(sizeof(buffer), bytes);
2714                 if(fread(buffer, 1, n, file) != n) {
2715                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2716                         return false;
2717                 }
2718                 if(local__fwrite(buffer, 1, n, tempfile) != n) {
2719                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2720                         return false;
2721                 }
2722                 bytes -= n;
2723         }
2724
2725         return true;
2726 }
2727
2728 FLAC__bool copy_n_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, off_t bytes, FLAC__Metadata_SimpleIteratorStatus *status)
2729 {
2730         FLAC__byte buffer[8192];
2731         size_t n;
2732
2733         while(bytes > 0) {
2734                 n = min(sizeof(buffer), bytes);
2735                 if(read_cb(buffer, 1, n, handle) != n) {
2736                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2737                         return false;
2738                 }
2739                 if(temp_write_cb(buffer, 1, n, temp_handle) != n) {
2740                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2741                         return false;
2742                 }
2743                 bytes -= n;
2744         }
2745
2746         return true;
2747 }
2748
2749 FLAC__bool copy_remaining_bytes_from_file_(FILE *file, FILE *tempfile, FLAC__Metadata_SimpleIteratorStatus *status)
2750 {
2751         FLAC__byte buffer[8192];
2752         size_t n;
2753
2754         while(!feof(file)) {
2755                 n = fread(buffer, 1, sizeof(buffer), file);
2756                 if(n == 0 && !feof(file)) {
2757                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2758                         return false;
2759                 }
2760                 if(n > 0 && local__fwrite(buffer, 1, n, tempfile) != n) {
2761                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2762                         return false;
2763                 }
2764         }
2765
2766         return true;
2767 }
2768
2769 FLAC__bool copy_remaining_bytes_from_file_cb_(FLAC__IOHandle handle, FLAC__IOCallback_Read read_cb, FLAC__IOCallback_Eof eof_cb, FLAC__IOHandle temp_handle, FLAC__IOCallback_Write temp_write_cb, FLAC__Metadata_SimpleIteratorStatus *status)
2770 {
2771         FLAC__byte buffer[8192];
2772         size_t n;
2773
2774         while(!eof_cb(handle)) {
2775                 n = read_cb(buffer, 1, sizeof(buffer), handle);
2776                 if(n == 0 && !eof_cb(handle)) {
2777                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR;
2778                         return false;
2779                 }
2780                 if(n > 0 && temp_write_cb(buffer, 1, n, temp_handle) != n) {
2781                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR;
2782                         return false;
2783                 }
2784         }
2785
2786         return true;
2787 }
2788
2789 FLAC__bool open_tempfile_(const char *filename, const char *tempfile_path_prefix, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status)
2790 {
2791         static const char *tempfile_suffix = ".metadata_edit";
2792         if(0 == tempfile_path_prefix) {
2793                 if(0 == (*tempfilename = (char*)malloc(strlen(filename) + strlen(tempfile_suffix) + 1))) {
2794                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2795                         return false;
2796                 }
2797                 strcpy(*tempfilename, filename);
2798                 strcat(*tempfilename, tempfile_suffix);
2799         }
2800         else {
2801                 const char *p = strrchr(filename, '/');
2802                 if(0 == p)
2803                         p = filename;
2804                 else
2805                         p++;
2806
2807                 if(0 == (*tempfilename = (char*)malloc(strlen(tempfile_path_prefix) + 1 + strlen(p) + strlen(tempfile_suffix) + 1))) {
2808                         *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR;
2809                         return false;
2810                 }
2811                 strcpy(*tempfilename, tempfile_path_prefix);
2812                 strcat(*tempfilename, "/");
2813                 strcat(*tempfilename, p);
2814                 strcat(*tempfilename, tempfile_suffix);
2815         }
2816
2817         if(0 == (*tempfile = fopen(*tempfilename, "w+b"))) {
2818                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE;
2819                 return false;
2820         }
2821
2822         return true;
2823 }
2824
2825 FLAC__bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename, FLAC__Metadata_SimpleIteratorStatus *status)
2826 {
2827         FLAC__ASSERT(0 != filename);
2828         FLAC__ASSERT(0 != tempfile);
2829         FLAC__ASSERT(0 != *tempfile);
2830         FLAC__ASSERT(0 != tempfilename);
2831         FLAC__ASSERT(0 != *tempfilename);
2832         FLAC__ASSERT(0 != status);
2833
2834         (void)fclose(*tempfile);
2835         *tempfile = 0;
2836
2837 #if defined _MSC_VER || defined __MINGW32__ || defined __EMX__
2838         /* on some flavors of windows, rename() will fail if the destination already exists */
2839         if(unlink(filename) < 0) {
2840                 cleanup_tempfile_(tempfile, tempfilename);
2841                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR;
2842                 return false;
2843         }
2844 #endif
2845
2846         /*@@@ to fully support the tempfile_path_prefix we need to update this piece to actually copy across filesystems instead of just rename(): */
2847         if(0 != rename(*tempfilename, filename)) {
2848                 cleanup_tempfile_(tempfile, tempfilename);
2849                 *status = FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR;
2850                 return false;
2851         }
2852
2853         cleanup_tempfile_(tempfile, tempfilename);
2854
2855         return true;
2856 }
2857
2858 void cleanup_tempfile_(FILE **tempfile, char **tempfilename)
2859 {
2860         if(0 != *tempfile) {
2861                 (void)fclose(*tempfile);
2862                 *tempfile = 0;
2863         }
2864
2865         if(0 != *tempfilename) {
2866                 (void)unlink(*tempfilename);
2867                 free(*tempfilename);
2868                 *tempfilename = 0;
2869         }
2870 }
2871
2872 FLAC__bool get_file_stats_(const char *filename, struct stat *stats)
2873 {
2874         FLAC__ASSERT(0 != filename);
2875         FLAC__ASSERT(0 != stats);
2876         return (0 == stat(filename, stats));
2877 }
2878
2879 void set_file_stats_(const char *filename, struct stat *stats)
2880 {
2881         struct utimbuf srctime;
2882
2883         FLAC__ASSERT(0 != filename);
2884         FLAC__ASSERT(0 != stats);
2885
2886         srctime.actime = stats->st_atime;
2887         srctime.modtime = stats->st_mtime;
2888         (void)chmod(filename, stats->st_mode);
2889         (void)utime(filename, &srctime);
2890 #if !defined _MSC_VER && !defined __MINGW32__ && !defined __EMX__
2891         (void)chown(filename, stats->st_uid, -1);
2892         (void)chown(filename, -1, stats->st_gid);
2893 #endif
2894 }
2895
2896 int fseek_wrapper_(FLAC__IOHandle handle, FLAC__int64 offset, int whence)
2897 {
2898         return fseeko((FILE*)handle, (off_t)offset, whence);
2899 }
2900
2901 FLAC__int64 ftell_wrapper_(FLAC__IOHandle handle)
2902 {
2903         return ftello((FILE*)handle);
2904 }
2905
2906 FLAC__Metadata_ChainStatus get_equivalent_status_(FLAC__Metadata_SimpleIteratorStatus status)
2907 {
2908         switch(status) {
2909                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK:
2910                         return FLAC__METADATA_CHAIN_STATUS_OK;
2911                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ILLEGAL_INPUT:
2912                         return FLAC__METADATA_CHAIN_STATUS_ILLEGAL_INPUT;
2913                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_ERROR_OPENING_FILE:
2914                         return FLAC__METADATA_CHAIN_STATUS_ERROR_OPENING_FILE;
2915                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_A_FLAC_FILE:
2916                         return FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE;
2917                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_NOT_WRITABLE:
2918                         return FLAC__METADATA_CHAIN_STATUS_NOT_WRITABLE;
2919                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_BAD_METADATA:
2920                         return FLAC__METADATA_CHAIN_STATUS_BAD_METADATA;
2921                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_READ_ERROR:
2922                         return FLAC__METADATA_CHAIN_STATUS_READ_ERROR;
2923                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_SEEK_ERROR:
2924                         return FLAC__METADATA_CHAIN_STATUS_SEEK_ERROR;
2925                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_WRITE_ERROR:
2926                         return FLAC__METADATA_CHAIN_STATUS_WRITE_ERROR;
2927                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_RENAME_ERROR:
2928                         return FLAC__METADATA_CHAIN_STATUS_RENAME_ERROR;
2929                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_UNLINK_ERROR:
2930                         return FLAC__METADATA_CHAIN_STATUS_UNLINK_ERROR;
2931                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR:
2932                         return FLAC__METADATA_CHAIN_STATUS_MEMORY_ALLOCATION_ERROR;
2933                 case FLAC__METADATA_SIMPLE_ITERATOR_STATUS_INTERNAL_ERROR:
2934                 default:
2935                         return FLAC__METADATA_CHAIN_STATUS_INTERNAL_ERROR;
2936         }
2937 }