src/libFLAC/metadata_object.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2001,2002,2003,2004  Josh Coalson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * - Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * - Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * - Neither the name of the Xiph.org Foundation nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "private/metadata.h"
  36
  37 #include "FLAC/assert.h"
  38
  39
  40 /****************************************************************************
  41  *
  42  * Local routines
  43  *
  44  ***************************************************************************/
  45
  46 static FLAC__bool copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes)
  47 {
  48         if(bytes > 0 && 0 != from) {
  49                 FLAC__byte *x;
  50                 if(0 == (x = (FLAC__byte*)malloc(bytes)))
  51                         return false;
  52                 memcpy(x, from, bytes);
  53                 *to = x;
  54         }
  55         else {
  56                 FLAC__ASSERT(0 == from);
  57                 FLAC__ASSERT(bytes == 0);
  58                 *to = 0;
  59         }
  60         return true;
  61 }
  62
  63 static FLAC__bool copy_vcentry_(FLAC__StreamMetadata_VorbisComment_Entry *to, const FLAC__StreamMetadata_VorbisComment_Entry *from)
  64 {
  65         to->length = from->length;
  66         if(0 == from->entry) {
  67                 FLAC__ASSERT(from->length == 0);
  68                 to->entry = 0;
  69         }
  70         else {
  71                 FLAC__byte *x;
  72                 FLAC__ASSERT(from->length > 0);
  73                 if(0 == (x = (FLAC__byte*)malloc(from->length)))
  74                         return false;
  75                 memcpy(x, from->entry, from->length);
  76                 to->entry = x;
  77         }
  78         return true;
  79 }
  80
  81 static FLAC__bool copy_track_(FLAC__StreamMetadata_CueSheet_Track *to, const FLAC__StreamMetadata_CueSheet_Track *from)
  82 {
  83         memcpy(to, from, sizeof(FLAC__StreamMetadata_CueSheet_Track));
  84         if(0 == from->indices) {
  85                 FLAC__ASSERT(from->num_indices == 0);
  86         }
  87         else {
  88                 FLAC__StreamMetadata_CueSheet_Index *x;
  89                 FLAC__ASSERT(from->num_indices > 0);
  90                 if(0 == (x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index))))
  91                         return false;
  92                 memcpy(x, from->indices, from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
  93                 to->indices = x;
  94         }
  95         return true;
  96 }
  97
  98 static void seektable_calculate_length_(FLAC__StreamMetadata *object)
  99 {
 100         FLAC__ASSERT(0 != object);
 101         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 102
 103         object->length = object->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
 104 }
 105
 106 static FLAC__StreamMetadata_SeekPoint *seekpoint_array_new_(unsigned num_points)
 107 {
 108         FLAC__StreamMetadata_SeekPoint *object_array;
 109
 110         FLAC__ASSERT(num_points > 0);
 111
 112         object_array = (FLAC__StreamMetadata_SeekPoint*)malloc(num_points * sizeof(FLAC__StreamMetadata_SeekPoint));
 113
 114         if(0 != object_array) {
 115                 unsigned i;
 116                 for(i = 0; i < num_points; i++) {
 117                         object_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 118                         object_array[i].stream_offset = 0;
 119                         object_array[i].frame_samples = 0;
 120                 }
 121         }
 122
 123         return object_array;
 124 }
 125
 126 static void vorbiscomment_calculate_length_(FLAC__StreamMetadata *object)
 127 {
 128         unsigned i;
 129
 130         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
 131
 132         object->length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN) / 8;
 133         object->length += object->data.vorbis_comment.vendor_string.length;
 134         object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8;
 135         for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
 136                 object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8);
 137                 object->length += object->data.vorbis_comment.comments[i].length;
 138         }
 139 }
 140
 141 static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_new_(unsigned num_comments)
 142 {
 143         FLAC__ASSERT(num_comments > 0);
 144
 145         return (FLAC__StreamMetadata_VorbisComment_Entry*)calloc(num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
 146 }
 147
 148 static void vorbiscomment_entry_array_delete_(FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
 149 {
 150         unsigned i;
 151
 152         FLAC__ASSERT(0 != object_array && num_comments > 0);
 153
 154         for(i = 0; i < num_comments; i++)
 155                 if(0 != object_array[i].entry)
 156                         free(object_array[i].entry);
 157
 158         if(0 != object_array)
 159                 free(object_array);
 160 }
 161
 162 static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_copy_(const FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
 163 {
 164         FLAC__StreamMetadata_VorbisComment_Entry *return_array;
 165
 166         FLAC__ASSERT(0 != object_array);
 167         FLAC__ASSERT(num_comments > 0);
 168
 169         return_array = vorbiscomment_entry_array_new_(num_comments);
 170
 171         if(0 != return_array) {
 172                 unsigned i;
 173
 174                 for(i = 0; i < num_comments; i++) {
 175                         if(!copy_vcentry_(return_array+i, object_array+i)) {
 176                                 vorbiscomment_entry_array_delete_(return_array, num_comments);
 177                                 return 0;
 178                         }
 179                 }
 180         }
 181
 182         return return_array;
 183 }
 184
 185 static FLAC__bool vorbiscomment_set_entry_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry *dest, const FLAC__StreamMetadata_VorbisComment_Entry *src, FLAC__bool copy)
 186 {
 187         FLAC__byte *save;
 188
 189         FLAC__ASSERT(0 != object);
 190         FLAC__ASSERT(0 != dest);
 191         FLAC__ASSERT(0 != src);
 192         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
 193         FLAC__ASSERT((0 != src->entry && src->length > 0) || (0 == src->entry && src->length == 0 && copy == false));
 194
 195         save = dest->entry;
 196
 197         /* do the copy first so that if we fail we leave the object untouched */
 198         if(copy) {
 199                 if(!copy_vcentry_(dest, src))
 200                         return false;
 201         }
 202         else {
 203                 *dest = *src;
 204         }
 205
 206         if(0 != save)
 207                 free(save);
 208
 209         vorbiscomment_calculate_length_(object);
 210         return true;
 211 }
 212
 213 static void cuesheet_calculate_length_(FLAC__StreamMetadata *object)
 214 {
 215         unsigned i;
 216
 217         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
 218
 219         object->length = (
 220                 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
 221                 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
 222                 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
 223                 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
 224                 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
 225         ) / 8;
 226
 227         object->length += object->data.cue_sheet.num_tracks * (
 228                 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
 229                 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
 230                 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
 231                 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
 232                 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
 233                 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
 234                 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
 235         ) / 8;
 236
 237         for(i = 0; i < object->data.cue_sheet.num_tracks; i++) {
 238                 object->length += object->data.cue_sheet.tracks[i].num_indices * (
 239                         FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
 240                         FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
 241                         FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
 242                 ) / 8;
 243         }
 244 }
 245
 246 static FLAC__StreamMetadata_CueSheet_Index *cuesheet_track_index_array_new_(unsigned num_indices)
 247 {
 248         FLAC__ASSERT(num_indices > 0);
 249
 250         return (FLAC__StreamMetadata_CueSheet_Index*)calloc(num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index));
 251 }
 252
 253 static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_new_(unsigned num_tracks)
 254 {
 255         FLAC__ASSERT(num_tracks > 0);
 256
 257         return (FLAC__StreamMetadata_CueSheet_Track*)calloc(num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track));
 258 }
 259
 260 static void cuesheet_track_array_delete_(FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
 261 {
 262         unsigned i;
 263
 264         FLAC__ASSERT(0 != object_array && num_tracks > 0);
 265
 266         for(i = 0; i < num_tracks; i++) {
 267                 if(0 != object_array[i].indices) {
 268                         FLAC__ASSERT(object_array[i].num_indices > 0);
 269                         free(object_array[i].indices);
 270                 }
 271         }
 272
 273         if(0 != object_array)
 274                 free(object_array);
 275 }
 276
 277 static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_copy_(const FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
 278 {
 279         FLAC__StreamMetadata_CueSheet_Track *return_array;
 280
 281         FLAC__ASSERT(0 != object_array);
 282         FLAC__ASSERT(num_tracks > 0);
 283
 284         return_array = cuesheet_track_array_new_(num_tracks);
 285
 286         if(0 != return_array) {
 287                 unsigned i;
 288
 289                 for(i = 0; i < num_tracks; i++) {
 290                         if(!copy_track_(return_array+i, object_array+i)) {
 291                                 cuesheet_track_array_delete_(return_array, num_tracks);
 292                                 return 0;
 293                         }
 294                 }
 295         }
 296
 297         return return_array;
 298 }
 299
 300 static FLAC__bool cuesheet_set_track_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_CueSheet_Track *dest, const FLAC__StreamMetadata_CueSheet_Track *src, FLAC__bool copy)
 301 {
 302         FLAC__StreamMetadata_CueSheet_Index *save;
 303
 304         FLAC__ASSERT(0 != object);
 305         FLAC__ASSERT(0 != dest);
 306         FLAC__ASSERT(0 != src);
 307         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
 308         FLAC__ASSERT((0 != src->indices && src->num_indices > 0) || (0 == src->indices && src->num_indices == 0));
 309
 310         save = dest->indices;
 311
 312         /* do the copy first so that if we fail we leave the object untouched */
 313         if(copy) {
 314                 if(!copy_track_(dest, src))
 315                         return false;
 316         }
 317         else {
 318                 *dest = *src;
 319         }
 320
 321         if(0 != save)
 322                 free(save);
 323
 324         cuesheet_calculate_length_(object);
 325         return true;
 326 }
 327
 328
 329 /****************************************************************************
 330  *
 331  * Metadata object routines
 332  *
 333  ***************************************************************************/
 334
 335 FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type)
 336 {
 337         FLAC__StreamMetadata *object = (FLAC__StreamMetadata*)calloc(1, sizeof(FLAC__StreamMetadata));
 338         if(0 != object) {
 339                 object->is_last = false;
 340                 object->type = type;
 341                 switch(type) {
 342                         case FLAC__METADATA_TYPE_STREAMINFO:
 343                                 object->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
 344                                 break;
 345                         case FLAC__METADATA_TYPE_PADDING:
 346                                 /* calloc() took care of this for us:
 347                                 object->length = 0;
 348                                 */
 349                                 break;
 350                         case FLAC__METADATA_TYPE_APPLICATION:
 351                                 object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
 352                                 /* calloc() took care of this for us:
 353                                 object->data.application.data = 0;
 354                                 */
 355                                 break;
 356                         case FLAC__METADATA_TYPE_SEEKTABLE:
 357                                 /* calloc() took care of this for us:
 358                                 object->length = 0;
 359                                 object->data.seek_table.num_points = 0;
 360                                 object->data.seek_table.points = 0;
 361                                 */
 362                                 break;
 363                         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 364                                 {
 365                                         object->data.vorbis_comment.vendor_string.length = (unsigned)strlen(FLAC__VENDOR_STRING);
 366                                         if(!copy_bytes_(&object->data.vorbis_comment.vendor_string.entry, (const FLAC__byte*)FLAC__VENDOR_STRING, object->data.vorbis_comment.vendor_string.length)) {
 367                                                 free(object);
 368                                                 return 0;
 369                                         }
 370                                         vorbiscomment_calculate_length_(object);
 371                                 }
 372                                 break;
 373                         case FLAC__METADATA_TYPE_CUESHEET:
 374                                 cuesheet_calculate_length_(object);
 375                                 break;
 376                         default:
 377                                 /* calloc() took care of this for us:
 378                                 object->length = 0;
 379                                 object->data.unknown.data = 0;
 380                                 */
 381                                 break;
 382                 }
 383         }
 384
 385         return object;
 386 }
 387
 388 FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object)
 389 {
 390         FLAC__StreamMetadata *to;
 391
 392         FLAC__ASSERT(0 != object);
 393
 394         if(0 != (to = FLAC__metadata_object_new(object->type))) {
 395                 to->is_last = object->is_last;
 396                 to->type = object->type;
 397                 to->length = object->length;
 398                 switch(to->type) {
 399                         case FLAC__METADATA_TYPE_STREAMINFO:
 400                                 memcpy(&to->data.stream_info, &object->data.stream_info, sizeof(FLAC__StreamMetadata_StreamInfo));
 401                                 break;
 402                         case FLAC__METADATA_TYPE_PADDING:
 403                                 break;
 404                         case FLAC__METADATA_TYPE_APPLICATION:
 405                                 memcpy(&to->data.application.id, &object->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8);
 406                                 if(!copy_bytes_(&to->data.application.data, object->data.application.data, object->length - FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) {
 407                                         FLAC__metadata_object_delete(to);
 408                                         return 0;
 409                                 }
 410                                 break;
 411                         case FLAC__METADATA_TYPE_SEEKTABLE:
 412                                 to->data.seek_table.num_points = object->data.seek_table.num_points;
 413                                 if(!copy_bytes_((FLAC__byte**)&to->data.seek_table.points, (FLAC__byte*)object->data.seek_table.points, object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint))) {
 414                                         FLAC__metadata_object_delete(to);
 415                                         return 0;
 416                                 }
 417                                 break;
 418                         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 419                                 if(0 != to->data.vorbis_comment.vendor_string.entry) {
 420                                         free(to->data.vorbis_comment.vendor_string.entry);
 421                                         to->data.vorbis_comment.vendor_string.entry = 0;
 422                                 }
 423                                 if(!copy_vcentry_(&to->data.vorbis_comment.vendor_string, &object->data.vorbis_comment.vendor_string)) {
 424                                         FLAC__metadata_object_delete(to);
 425                                         return 0;
 426                                 }
 427                                 if(object->data.vorbis_comment.num_comments == 0) {
 428                                         FLAC__ASSERT(0 == object->data.vorbis_comment.comments);
 429                                         to->data.vorbis_comment.comments = 0;
 430                                 }
 431                                 else {
 432                                         FLAC__ASSERT(0 != object->data.vorbis_comment.comments);
 433                                         to->data.vorbis_comment.comments = vorbiscomment_entry_array_copy_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
 434                                         if(0 == to->data.vorbis_comment.comments) {
 435                                                 FLAC__metadata_object_delete(to);
 436                                                 return 0;
 437                                         }
 438                                 }
 439                                 to->data.vorbis_comment.num_comments = object->data.vorbis_comment.num_comments;
 440                                 break;
 441                         case FLAC__METADATA_TYPE_CUESHEET:
 442                                 memcpy(&to->data.cue_sheet, &object->data.cue_sheet, sizeof(FLAC__StreamMetadata_CueSheet));
 443                                 if(object->data.cue_sheet.num_tracks == 0) {
 444                                         FLAC__ASSERT(0 == object->data.cue_sheet.tracks);
 445                                 }
 446                                 else {
 447                                         FLAC__ASSERT(0 != object->data.cue_sheet.tracks);
 448                                         to->data.cue_sheet.tracks = cuesheet_track_array_copy_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
 449                                         if(0 == to->data.cue_sheet.tracks) {
 450                                                 FLAC__metadata_object_delete(to);
 451                                                 return 0;
 452                                         }
 453                                 }
 454                                 break;
 455                         default:
 456                                 if(!copy_bytes_(&to->data.unknown.data, object->data.unknown.data, object->length)) {
 457                                         FLAC__metadata_object_delete(to);
 458                                         return 0;
 459                                 }
 460                                 break;
 461                 }
 462         }
 463
 464         return to;
 465 }
 466
 467 void FLAC__metadata_object_delete_data(FLAC__StreamMetadata *object)
 468 {
 469         FLAC__ASSERT(0 != object);
 470
 471         switch(object->type) {
 472                 case FLAC__METADATA_TYPE_STREAMINFO:
 473                 case FLAC__METADATA_TYPE_PADDING:
 474                         break;
 475                 case FLAC__METADATA_TYPE_APPLICATION:
 476                         if(0 != object->data.application.data) {
 477                                 free(object->data.application.data);
 478                                 object->data.application.data = 0;
 479                         }
 480                         break;
 481                 case FLAC__METADATA_TYPE_SEEKTABLE:
 482                         if(0 != object->data.seek_table.points) {
 483                                 free(object->data.seek_table.points);
 484                                 object->data.seek_table.points = 0;
 485                         }
 486                         break;
 487                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 488                         if(0 != object->data.vorbis_comment.vendor_string.entry) {
 489                                 free(object->data.vorbis_comment.vendor_string.entry);
 490                                 object->data.vorbis_comment.vendor_string.entry = 0;
 491                         }
 492                         if(0 != object->data.vorbis_comment.comments) {
 493                                 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
 494                                 vorbiscomment_entry_array_delete_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
 495                         }
 496                         break;
 497                 case FLAC__METADATA_TYPE_CUESHEET:
 498                         if(0 != object->data.cue_sheet.tracks) {
 499                                 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
 500                                 cuesheet_track_array_delete_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
 501                         }
 502                         break;
 503                 default:
 504                         if(0 != object->data.unknown.data) {
 505                                 free(object->data.unknown.data);
 506                                 object->data.unknown.data = 0;
 507                         }
 508                         break;
 509         }
 510 }
 511
 512 FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object)
 513 {
 514         FLAC__metadata_object_delete_data(object);
 515         free(object);
 516 }
 517
 518 static FLAC__bool compare_block_data_streaminfo_(const FLAC__StreamMetadata_StreamInfo *block1, const FLAC__StreamMetadata_StreamInfo *block2)
 519 {
 520         if(block1->min_blocksize != block2->min_blocksize)
 521                 return false;
 522         if(block1->max_blocksize != block2->max_blocksize)
 523                 return false;
 524         if(block1->min_framesize != block2->min_framesize)
 525                 return false;
 526         if(block1->max_framesize != block2->max_framesize)
 527                 return false;
 528         if(block1->sample_rate != block2->sample_rate)
 529                 return false;
 530         if(block1->channels != block2->channels)
 531                 return false;
 532         if(block1->bits_per_sample != block2->bits_per_sample)
 533                 return false;
 534         if(block1->total_samples != block2->total_samples)
 535                 return false;
 536         if(0 != memcmp(block1->md5sum, block2->md5sum, 16))
 537                 return false;
 538         return true;
 539 }
 540
 541 static FLAC__bool compare_block_data_application_(const FLAC__StreamMetadata_Application *block1, const FLAC__StreamMetadata_Application *block2, unsigned block_length)
 542 {
 543         FLAC__ASSERT(0 != block1);
 544         FLAC__ASSERT(0 != block2);
 545         FLAC__ASSERT(block_length >= sizeof(block1->id));
 546
 547         if(0 != memcmp(block1->id, block2->id, sizeof(block1->id)))
 548                 return false;
 549         if(0 != block1->data && 0 != block2->data)
 550                 return 0 == memcmp(block1->data, block2->data, block_length - sizeof(block1->id));
 551         else
 552                 return block1->data == block2->data;
 553 }
 554
 555 static FLAC__bool compare_block_data_seektable_(const FLAC__StreamMetadata_SeekTable *block1, const FLAC__StreamMetadata_SeekTable *block2)
 556 {
 557         unsigned i;
 558
 559         FLAC__ASSERT(0 != block1);
 560         FLAC__ASSERT(0 != block2);
 561
 562         if(block1->num_points != block2->num_points)
 563                 return false;
 564
 565         if(0 != block1->points && 0 != block2->points) {
 566                 for(i = 0; i < block1->num_points; i++) {
 567                         if(block1->points[i].sample_number != block2->points[i].sample_number)
 568                                 return false;
 569                         if(block1->points[i].stream_offset != block2->points[i].stream_offset)
 570                                 return false;
 571                         if(block1->points[i].frame_samples != block2->points[i].frame_samples)
 572                                 return false;
 573                 }
 574                 return true;
 575         }
 576         else
 577                 return block1->points == block2->points;
 578 }
 579
 580 static FLAC__bool compare_block_data_vorbiscomment_(const FLAC__StreamMetadata_VorbisComment *block1, const FLAC__StreamMetadata_VorbisComment *block2)
 581 {
 582         unsigned i;
 583
 584         if(block1->vendor_string.length != block2->vendor_string.length)
 585                 return false;
 586
 587         if(0 != block1->vendor_string.entry && 0 != block2->vendor_string.entry) {
 588                 if(0 != memcmp(block1->vendor_string.entry, block2->vendor_string.entry, block1->vendor_string.length))
 589                         return false;
 590         }
 591         else if(block1->vendor_string.entry != block2->vendor_string.entry)
 592                 return false;
 593
 594         if(block1->num_comments != block2->num_comments)
 595                 return false;
 596
 597         for(i = 0; i < block1->num_comments; i++) {
 598                 if(0 != block1->comments[i].entry && 0 != block2->comments[i].entry) {
 599                         if(0 != memcmp(block1->comments[i].entry, block2->comments[i].entry, block1->comments[i].length))
 600                                 return false;
 601                 }
 602                 else if(block1->comments[i].entry != block2->comments[i].entry)
 603                         return false;
 604         }
 605         return true;
 606 }
 607
 608 static FLAC__bool compare_block_data_cuesheet_(const FLAC__StreamMetadata_CueSheet *block1, const FLAC__StreamMetadata_CueSheet *block2)
 609 {
 610         unsigned i, j;
 611
 612         if(0 != strcmp(block1->media_catalog_number, block2->media_catalog_number))
 613                 return false;
 614
 615         if(block1->lead_in != block2->lead_in)
 616                 return false;
 617
 618         if(block1->is_cd != block2->is_cd)
 619                 return false;
 620
 621         if(block1->num_tracks != block2->num_tracks)
 622                 return false;
 623
 624         if(0 != block1->tracks && 0 != block2->tracks) {
 625                 FLAC__ASSERT(block1->num_tracks > 0);
 626                 for(i = 0; i < block1->num_tracks; i++) {
 627                         if(block1->tracks[i].offset != block2->tracks[i].offset)
 628                                 return false;
 629                         if(block1->tracks[i].number != block2->tracks[i].number)
 630                                 return false;
 631                         if(0 != memcmp(block1->tracks[i].isrc, block2->tracks[i].isrc, sizeof(block1->tracks[i].isrc)))
 632                                 return false;
 633                         if(block1->tracks[i].type != block2->tracks[i].type)
 634                                 return false;
 635                         if(block1->tracks[i].pre_emphasis != block2->tracks[i].pre_emphasis)
 636                                 return false;
 637                         if(block1->tracks[i].num_indices != block2->tracks[i].num_indices)
 638                                 return false;
 639                         if(0 != block1->tracks[i].indices && 0 != block2->tracks[i].indices) {
 640                                 FLAC__ASSERT(block1->tracks[i].num_indices > 0);
 641                                 for(j = 0; j < block1->tracks[i].num_indices; j++) {
 642                                         if(block1->tracks[i].indices[j].offset != block2->tracks[i].indices[j].offset)
 643                                                 return false;
 644                                         if(block1->tracks[i].indices[j].number != block2->tracks[i].indices[j].number)
 645                                                 return false;
 646                                 }
 647                         }
 648                         else if(block1->tracks[i].indices != block2->tracks[i].indices)
 649                                 return false;
 650                 }
 651         }
 652         else if(block1->tracks != block2->tracks)
 653                 return false;
 654         return true;
 655 }
 656
 657 static FLAC__bool compare_block_data_unknown_(const FLAC__StreamMetadata_Unknown *block1, const FLAC__StreamMetadata_Unknown *block2, unsigned block_length)
 658 {
 659         FLAC__ASSERT(0 != block1);
 660         FLAC__ASSERT(0 != block2);
 661
 662         if(0 != block1->data && 0 != block2->data)
 663                 return 0 == memcmp(block1->data, block2->data, block_length);
 664         else
 665                 return block1->data == block2->data;
 666 }
 667
 668 FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2)
 669 {
 670         FLAC__ASSERT(0 != block1);
 671         FLAC__ASSERT(0 != block2);
 672
 673         if(block1->type != block2->type) {
 674                 return false;
 675         }
 676         if(block1->is_last != block2->is_last) {
 677                 return false;
 678         }
 679         if(block1->length != block2->length) {
 680                 return false;
 681         }
 682         switch(block1->type) {
 683                 case FLAC__METADATA_TYPE_STREAMINFO:
 684                         return compare_block_data_streaminfo_(&block1->data.stream_info, &block2->data.stream_info);
 685                 case FLAC__METADATA_TYPE_PADDING:
 686                         return true; /* we don't compare the padding guts */
 687                 case FLAC__METADATA_TYPE_APPLICATION:
 688                         return compare_block_data_application_(&block1->data.application, &block2->data.application, block1->length);
 689                 case FLAC__METADATA_TYPE_SEEKTABLE:
 690                         return compare_block_data_seektable_(&block1->data.seek_table, &block2->data.seek_table);
 691                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 692                         return compare_block_data_vorbiscomment_(&block1->data.vorbis_comment, &block2->data.vorbis_comment);
 693                 case FLAC__METADATA_TYPE_CUESHEET:
 694                         return compare_block_data_cuesheet_(&block1->data.cue_sheet, &block2->data.cue_sheet);
 695                 default:
 696                         return compare_block_data_unknown_(&block1->data.unknown, &block2->data.unknown, block1->length);
 697         }
 698 }
 699
 700 FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy)
 701 {
 702         FLAC__byte *save;
 703
 704         FLAC__ASSERT(0 != object);
 705         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_APPLICATION);
 706         FLAC__ASSERT((0 != data && length > 0) || (0 == data && length == 0 && copy == false));
 707
 708         save = object->data.application.data;
 709
 710         /* do the copy first so that if we fail we leave the object untouched */
 711         if(copy) {
 712                 if(!copy_bytes_(&object->data.application.data, data, length))
 713                         return false;
 714         }
 715         else {
 716                 object->data.application.data = data;
 717         }
 718
 719         if(0 != save)
 720                 free(save);
 721
 722         object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8 + length;
 723         return true;
 724 }
 725
 726 FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points)
 727 {
 728         FLAC__ASSERT(0 != object);
 729         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 730
 731         if(0 == object->data.seek_table.points) {
 732                 FLAC__ASSERT(object->data.seek_table.num_points == 0);
 733                 if(0 == new_num_points)
 734                         return true;
 735                 else if(0 == (object->data.seek_table.points = seekpoint_array_new_(new_num_points)))
 736                         return false;
 737         }
 738         else {
 739                 const unsigned old_size = object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
 740                 const unsigned new_size = new_num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
 741
 742                 FLAC__ASSERT(object->data.seek_table.num_points > 0);
 743
 744                 if(new_size == 0) {
 745                         free(object->data.seek_table.points);
 746                         object->data.seek_table.points = 0;
 747                 }
 748                 else if(0 == (object->data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*)realloc(object->data.seek_table.points, new_size)))
 749                         return false;
 750
 751                 /* if growing, set new elements to placeholders */
 752                 if(new_size > old_size) {
 753                         unsigned i;
 754                         for(i = object->data.seek_table.num_points; i < new_num_points; i++) {
 755                                 object->data.seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 756                                 object->data.seek_table.points[i].stream_offset = 0;
 757                                 object->data.seek_table.points[i].frame_samples = 0;
 758                         }
 759                 }
 760         }
 761
 762         object->data.seek_table.num_points = new_num_points;
 763
 764         seektable_calculate_length_(object);
 765         return true;
 766 }
 767
 768 FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
 769 {
 770         FLAC__ASSERT(0 != object);
 771         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 772         FLAC__ASSERT(point_num < object->data.seek_table.num_points);
 773
 774         object->data.seek_table.points[point_num] = point;
 775 }
 776
 777 FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
 778 {
 779         int i;
 780
 781         FLAC__ASSERT(0 != object);
 782         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 783         FLAC__ASSERT(point_num <= object->data.seek_table.num_points);
 784
 785         if(!FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points+1))
 786                 return false;
 787
 788         /* move all points >= point_num forward one space */
 789         for(i = (int)object->data.seek_table.num_points-1; i > (int)point_num; i--)
 790                 object->data.seek_table.points[i] = object->data.seek_table.points[i-1];
 791
 792         FLAC__metadata_object_seektable_set_point(object, point_num, point);
 793         seektable_calculate_length_(object);
 794         return true;
 795 }
 796
 797 FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num)
 798 {
 799         unsigned i;
 800
 801         FLAC__ASSERT(0 != object);
 802         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 803         FLAC__ASSERT(point_num < object->data.seek_table.num_points);
 804
 805         /* move all points > point_num backward one space */
 806         for(i = point_num; i < object->data.seek_table.num_points-1; i++)
 807                 object->data.seek_table.points[i] = object->data.seek_table.points[i+1];
 808
 809         return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points-1);
 810 }
 811
 812 FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object)
 813 {
 814         FLAC__ASSERT(0 != object);
 815         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 816
 817         return FLAC__format_seektable_is_legal(&object->data.seek_table);
 818 }
 819
 820 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num)
 821 {
 822         FLAC__ASSERT(0 != object);
 823         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 824
 825         if(num > 0)
 826                 /* WATCHOUT: we rely on the fact that growing the array adds PLACEHOLDERS at the end */
 827                 return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points + num);
 828         else
 829                 return true;
 830 }
 831
 832 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number)
 833 {
 834         FLAC__StreamMetadata_SeekTable *seek_table;
 835
 836         FLAC__ASSERT(0 != object);
 837         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 838
 839         seek_table = &object->data.seek_table;
 840
 841         if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + 1))
 842                 return false;
 843
 844         seek_table->points[seek_table->num_points - 1].sample_number = sample_number;
 845         seek_table->points[seek_table->num_points - 1].stream_offset = 0;
 846         seek_table->points[seek_table->num_points - 1].frame_samples = 0;
 847
 848         return true;
 849 }
 850
 851 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num)
 852 {
 853         FLAC__ASSERT(0 != object);
 854         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 855         FLAC__ASSERT(0 != sample_numbers || num == 0);
 856
 857         if(num > 0) {
 858                 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
 859                 unsigned i, j;
 860
 861                 i = seek_table->num_points;
 862
 863                 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
 864                         return false;
 865
 866                 for(j = 0; j < num; i++, j++) {
 867                         seek_table->points[i].sample_number = sample_numbers[j];
 868                         seek_table->points[i].stream_offset = 0;
 869                         seek_table->points[i].frame_samples = 0;
 870                 }
 871         }
 872
 873         return true;
 874 }
 875
 876 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples)
 877 {
 878         FLAC__ASSERT(0 != object);
 879         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 880         FLAC__ASSERT(total_samples > 0);
 881
 882         if(num > 0) {
 883                 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
 884                 unsigned i, j;
 885
 886                 i = seek_table->num_points;
 887
 888                 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
 889                         return false;
 890
 891                 for(j = 0; j < num; i++, j++) {
 892                         seek_table->points[i].sample_number = total_samples * (FLAC__uint64)j / (FLAC__uint64)num;
 893                         seek_table->points[i].stream_offset = 0;
 894                         seek_table->points[i].frame_samples = 0;
 895                 }
 896         }
 897
 898         return true;
 899 }
 900
 901 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact)
 902 {
 903         unsigned unique;
 904
 905         FLAC__ASSERT(0 != object);
 906         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
 907
 908         unique = FLAC__format_seektable_sort(&object->data.seek_table);
 909
 910         return !compact || FLAC__metadata_object_seektable_resize_points(object, unique);
 911 }
 912
 913 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
 914 {
 915         return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.vendor_string, &entry, copy);
 916 }
 917
 918 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments)
 919 {
 920         FLAC__ASSERT(0 != object);
 921         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
 922
 923         if(0 == object->data.vorbis_comment.comments) {
 924                 FLAC__ASSERT(object->data.vorbis_comment.num_comments == 0);
 925                 if(0 == new_num_comments)
 926                         return true;
 927                 else if(0 == (object->data.vorbis_comment.comments = vorbiscomment_entry_array_new_(new_num_comments)))
 928                         return false;
 929         }
 930         else {
 931                 const unsigned old_size = object->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
 932                 const unsigned new_size = new_num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
 933
 934                 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
 935
 936                 /* if shrinking, free the truncated entries */
 937                 if(new_num_comments < object->data.vorbis_comment.num_comments) {
 938                         unsigned i;
 939                         for(i = new_num_comments; i < object->data.vorbis_comment.num_comments; i++)
 940                                 if(0 != object->data.vorbis_comment.comments[i].entry)
 941                                         free(object->data.vorbis_comment.comments[i].entry);
 942                 }
 943
 944                 if(new_size == 0) {
 945                         free(object->data.vorbis_comment.comments);
 946                         object->data.vorbis_comment.comments = 0;
 947                 }
 948                 else if(0 == (object->data.vorbis_comment.comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(object->data.vorbis_comment.comments, new_size)))
 949                         return false;
 950
 951                 /* if growing, zero all the length/pointers of new elements */
 952                 if(new_size > old_size)
 953                         memset(object->data.vorbis_comment.comments + object->data.vorbis_comment.num_comments, 0, new_size - old_size);
 954         }
 955
 956         object->data.vorbis_comment.num_comments = new_num_comments;
 957
 958         vorbiscomment_calculate_length_(object);
 959         return true;
 960 }
 961
 962 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
 963 {
 964         FLAC__ASSERT(0 != object);
 965         FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
 966
 967         return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.comments[comment_num], &entry, copy);
 968 }
 969
 970 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
 971 {
 972         FLAC__StreamMetadata_VorbisComment *vc;
 973
 974         FLAC__ASSERT(0 != object);
 975         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
 976         FLAC__ASSERT(comment_num <= object->data.vorbis_comment.num_comments);
 977
 978         vc = &object->data.vorbis_comment;
 979
 980         if(!FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments+1))
 981                 return false;
 982
 983         /* move all comments >= comment_num forward one space */
 984         memmove(&vc->comments[comment_num+1], &vc->comments[comment_num], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-1-comment_num));
 985         vc->comments[comment_num].length = 0;
 986         vc->comments[comment_num].entry = 0;
 987
 988         return FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy);
 989 }
 990
 991 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num)
 992 {
 993         FLAC__StreamMetadata_VorbisComment *vc;
 994
 995         FLAC__ASSERT(0 != object);
 996         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
 997         FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
 998
 999         vc = &object->data.vorbis_comment;
1000
1001         /* free the comment at comment_num */
1002         if(0 != vc->comments[comment_num].entry)
1003                 free(vc->comments[comment_num].entry);
1004
1005         /* move all comments > comment_num backward one space */
1006         memmove(&vc->comments[comment_num], &vc->comments[comment_num+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-comment_num-1));
1007         vc->comments[vc->num_comments-1].length = 0;
1008         vc->comments[vc->num_comments-1].entry = 0;
1009
1010         return FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments-1);
1011 }
1012
1013 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, unsigned field_name_length)
1014 {
1015         const FLAC__byte *eq = (FLAC__byte*)memchr(entry->entry, '=', entry->length);
1016 #if defined _MSC_VER || defined __MINGW32__
1017 #define FLAC__STRNCASECMP strnicmp
1018 #else
1019 #define FLAC__STRNCASECMP strncasecmp
1020 #endif
1021         return (0 != eq && (unsigned)(eq-entry->entry) == field_name_length && 0 == FLAC__STRNCASECMP(field_name, (const char *)entry->entry, field_name_length));
1022 #undef FLAC__STRNCASECMP
1023 }
1024
1025 FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name)
1026 {
1027         const unsigned field_name_length = strlen(field_name);
1028         unsigned i;
1029
1030         FLAC__ASSERT(0 != object);
1031         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1032
1033         for(i = offset; i < object->data.vorbis_comment.num_comments; i++) {
1034                 if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments + i, field_name, field_name_length))
1035                         return (int)i;
1036         }
1037
1038         return -1;
1039 }
1040
1041 FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name)
1042 {
1043         const unsigned field_name_length = strlen(field_name);
1044         unsigned i;
1045
1046         FLAC__ASSERT(0 != object);
1047         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1048
1049         for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
1050                 if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments + i, field_name, field_name_length)) {
1051                         if(!FLAC__metadata_object_vorbiscomment_delete_comment(object, i))
1052                                 return -1;
1053                         else
1054                                 return 1;
1055                 }
1056         }
1057
1058         return 0;
1059 }
1060
1061 FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name)
1062 {
1063         FLAC__bool ok = true;
1064         unsigned matching = 0;
1065         const unsigned field_name_length = strlen(field_name);
1066         int i;
1067
1068         FLAC__ASSERT(0 != object);
1069         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1070
1071         /* must delete from end to start otherwise it will interfere with our iteration */
1072         for(i = (int)object->data.vorbis_comment.num_comments - 1; ok && i >= 0; i--) {
1073                 if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments + i, field_name, field_name_length)) {
1074                         matching++;
1075                         ok &= FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i);
1076                 }
1077         }
1078
1079         return ok? (int)matching : -1;
1080 }
1081
1082 FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new()
1083 {
1084         return (FLAC__StreamMetadata_CueSheet_Track*)calloc(1, sizeof(FLAC__StreamMetadata_CueSheet_Track));
1085 }
1086
1087 FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object)
1088 {
1089         FLAC__StreamMetadata_CueSheet_Track *to;
1090
1091         FLAC__ASSERT(0 != object);
1092
1093         if(0 != (to = FLAC__metadata_object_cuesheet_track_new())) {
1094                 if(!copy_track_(to, object)) {
1095                         FLAC__metadata_object_cuesheet_track_delete(to);
1096                         return 0;
1097                 }
1098         }
1099
1100         return to;
1101 }
1102
1103 void FLAC__metadata_object_cuesheet_track_delete_data(FLAC__StreamMetadata_CueSheet_Track *object)
1104 {
1105         FLAC__ASSERT(0 != object);
1106
1107         if(0 != object->indices) {
1108                 FLAC__ASSERT(object->num_indices > 0);
1109                 free(object->indices);
1110         }
1111 }
1112
1113 FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object)
1114 {
1115         FLAC__metadata_object_cuesheet_track_delete_data(object);
1116         free(object);
1117 }
1118
1119 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices)
1120 {
1121         FLAC__StreamMetadata_CueSheet_Track *track;
1122         FLAC__ASSERT(0 != object);
1123         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1124         FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1125
1126         track = &object->data.cue_sheet.tracks[track_num];
1127
1128         if(0 == track->indices) {
1129                 FLAC__ASSERT(track->num_indices == 0);
1130                 if(0 == new_num_indices)
1131                         return true;
1132                 else if(0 == (track->indices = cuesheet_track_index_array_new_(new_num_indices)))
1133                         return false;
1134         }
1135         else {
1136                 const unsigned old_size = track->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
1137                 const unsigned new_size = new_num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
1138
1139                 FLAC__ASSERT(track->num_indices > 0);
1140
1141                 if(new_size == 0) {
1142                         free(track->indices);
1143                         track->indices = 0;
1144                 }
1145                 else if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(track->indices, new_size)))
1146                         return false;
1147
1148                 /* if growing, zero all the lengths/pointers of new elements */
1149                 if(new_size > old_size)
1150                         memset(track->indices + track->num_indices, 0, new_size - old_size);
1151         }
1152
1153         track->num_indices = new_num_indices;
1154
1155         cuesheet_calculate_length_(object);
1156         return true;
1157 }
1158
1159 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index index)
1160 {
1161         FLAC__StreamMetadata_CueSheet_Track *track;
1162
1163         FLAC__ASSERT(0 != object);
1164         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1165         FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1166         FLAC__ASSERT(index_num <= object->data.cue_sheet.tracks[track_num].num_indices);
1167
1168         track = &object->data.cue_sheet.tracks[track_num];
1169
1170         if(!FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices+1))
1171                 return false;
1172
1173         /* move all indices >= index_num forward one space */
1174         memmove(&track->indices[index_num+1], &track->indices[index_num], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-1-index_num));
1175
1176         track->indices[index_num] = index;
1177         cuesheet_calculate_length_(object);
1178         return true;
1179 }
1180
1181 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
1182 {
1183         FLAC__StreamMetadata_CueSheet_Index index;
1184         memset(&index, 0, sizeof(index));
1185         return FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, index);
1186 }
1187
1188 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
1189 {
1190         FLAC__StreamMetadata_CueSheet_Track *track;
1191
1192         FLAC__ASSERT(0 != object);
1193         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1194         FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1195         FLAC__ASSERT(index_num < object->data.cue_sheet.tracks[track_num].num_indices);
1196
1197         track = &object->data.cue_sheet.tracks[track_num];
1198
1199         /* move all indices > index_num backward one space */
1200         memmove(&track->indices[index_num], &track->indices[index_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-index_num-1));
1201
1202         FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices-1);
1203         cuesheet_calculate_length_(object);
1204         return true;
1205 }
1206
1207 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks)
1208 {
1209         FLAC__ASSERT(0 != object);
1210         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1211
1212         if(0 == object->data.cue_sheet.tracks) {
1213                 FLAC__ASSERT(object->data.cue_sheet.num_tracks == 0);
1214                 if(0 == new_num_tracks)
1215                         return true;
1216                 else if(0 == (object->data.cue_sheet.tracks = cuesheet_track_array_new_(new_num_tracks)))
1217                         return false;
1218         }
1219         else {
1220                 const unsigned old_size = object->data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
1221                 const unsigned new_size = new_num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
1222
1223                 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
1224
1225                 /* if shrinking, free the truncated entries */
1226                 if(new_num_tracks < object->data.cue_sheet.num_tracks) {
1227                         unsigned i;
1228                         for(i = new_num_tracks; i < object->data.cue_sheet.num_tracks; i++)
1229                                 if(0 != object->data.cue_sheet.tracks[i].indices)
1230                                         free(object->data.cue_sheet.tracks[i].indices);
1231                 }
1232
1233                 if(new_size == 0) {
1234                         free(object->data.cue_sheet.tracks);
1235                         object->data.cue_sheet.tracks = 0;
1236                 }
1237                 else if(0 == (object->data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(object->data.cue_sheet.tracks, new_size)))
1238                         return false;
1239
1240                 /* if growing, zero all the lengths/pointers of new elements */
1241                 if(new_size > old_size)
1242                         memset(object->data.cue_sheet.tracks + object->data.cue_sheet.num_tracks, 0, new_size - old_size);
1243         }
1244
1245         object->data.cue_sheet.num_tracks = new_num_tracks;
1246
1247         cuesheet_calculate_length_(object);
1248         return true;
1249 }
1250
1251 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
1252 {
1253         FLAC__ASSERT(0 != object);
1254         FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1255
1256         return cuesheet_set_track_(object, object->data.cue_sheet.tracks + track_num, track, copy);
1257 }
1258
1259 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
1260 {
1261         FLAC__StreamMetadata_CueSheet *cs;
1262
1263         FLAC__ASSERT(0 != object);
1264         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1265         FLAC__ASSERT(track_num <= object->data.cue_sheet.num_tracks);
1266
1267         cs = &object->data.cue_sheet;
1268
1269         if(!FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks+1))
1270                 return false;
1271
1272         /* move all tracks >= track_num forward one space */
1273         memmove(&cs->tracks[track_num+1], &cs->tracks[track_num], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-1-track_num));
1274         cs->tracks[track_num].num_indices = 0;
1275         cs->tracks[track_num].indices = 0;
1276
1277         return FLAC__metadata_object_cuesheet_set_track(object, track_num, track, copy);
1278 }
1279
1280 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num)
1281 {
1282         FLAC__StreamMetadata_CueSheet_Track track;
1283         memset(&track, 0, sizeof(track));
1284         return FLAC__metadata_object_cuesheet_insert_track(object, track_num, &track, /*copy=*/false);
1285 }
1286
1287 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num)
1288 {
1289         FLAC__StreamMetadata_CueSheet *cs;
1290
1291         FLAC__ASSERT(0 != object);
1292         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1293         FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1294
1295         cs = &object->data.cue_sheet;
1296
1297         /* free the track at track_num */
1298         if(0 != cs->tracks[track_num].indices)
1299                 free(cs->tracks[track_num].indices);
1300
1301         /* move all tracks > track_num backward one space */
1302         memmove(&cs->tracks[track_num], &cs->tracks[track_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-track_num-1));
1303         cs->tracks[cs->num_tracks-1].num_indices = 0;
1304         cs->tracks[cs->num_tracks-1].indices = 0;
1305
1306         return FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks-1);
1307 }
1308
1309 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation)
1310 {
1311         FLAC__ASSERT(0 != object);
1312         FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1313
1314         return FLAC__format_cuesheet_is_legal(&object->data.cue_sheet, check_cd_da_subset, violation);
1315 }