src/libFLAC/metadata_iterators.c

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