src/libFLAC/metadata_iterators.c

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