1/* libFLAC - Free Lossless Audio Codec library 2 * Copyright (C) 2001-2009 Josh Coalson 3 * Copyright (C) 2011-2016 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#ifdef HAVE_CONFIG_H 34# include <config.h> 35#endif 36 37#include <stdlib.h> 38#include <string.h> 39 40#include "private/metadata.h" 41#include "private/memory.h" 42 43#include "FLAC/assert.h" 44#include "share/alloc.h" 45#include "share/compat.h" 46 47/* Alias the first (in share/alloc.h) to the second (in src/libFLAC/memory.c). */ 48#define safe_malloc_mul_2op_ safe_malloc_mul_2op_p 49 50 51/**************************************************************************** 52 * 53 * Local routines 54 * 55 ***************************************************************************/ 56 57/* copy bytes: 58 * from = NULL && bytes = 0 59 * to <- NULL 60 * from != NULL && bytes > 0 61 * to <- copy of from 62 * else ASSERT 63 * malloc error leaves 'to' unchanged 64 */ 65static FLAC__bool copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes) 66{ 67 FLAC__ASSERT(to != NULL); 68 if (bytes > 0 && from != NULL) { 69 FLAC__byte *x; 70 if ((x = safe_malloc_(bytes)) == NULL) 71 return false; 72 memcpy(x, from, bytes); 73 *to = x; 74 } 75 else { 76 *to = 0; 77 } 78 return true; 79} 80 81#if 0 /* UNUSED */ 82/* like copy_bytes_(), but free()s the original '*to' if the copy succeeds and the original '*to' is non-NULL */ 83static FLAC__bool free_copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes) 84{ 85 FLAC__byte *copy; 86 FLAC__ASSERT(to != NULL); 87 if (copy_bytes_(©, from, bytes)) { 88 free(*to); 89 *to = copy; 90 return true; 91 } 92 else 93 return false; 94} 95#endif 96 97/* reallocate entry to 1 byte larger and add a terminating NUL */ 98/* realloc() failure leaves entry unchanged */ 99static FLAC__bool ensure_null_terminated_(FLAC__byte **entry, unsigned length) 100{ 101 FLAC__byte *x = safe_realloc_add_2op_(*entry, length, /*+*/1); 102 if (x != NULL) { 103 x[length] = '\0'; 104 *entry = x; 105 return true; 106 } 107 else 108 return false; 109} 110 111/* copies the NUL-terminated C-string 'from' to '*to', leaving '*to' 112 * unchanged if malloc fails, free()ing the original '*to' if it 113 * succeeds and the original '*to' was not NULL 114 */ 115static FLAC__bool copy_cstring_(char **to, const char *from) 116{ 117 char *copy = strdup(from); 118 FLAC__ASSERT(to != NULL); 119 if (copy) { 120 free(*to); 121 *to = copy; 122 return true; 123 } 124 else 125 return false; 126} 127 128static FLAC__bool copy_vcentry_(FLAC__StreamMetadata_VorbisComment_Entry *to, const FLAC__StreamMetadata_VorbisComment_Entry *from) 129{ 130 to->length = from->length; 131 if (from->entry == 0) { 132 FLAC__ASSERT(from->length == 0); 133 to->entry = 0; 134 } 135 else { 136 FLAC__byte *x; 137 FLAC__ASSERT(from->length > 0); 138 if ((x = safe_malloc_add_2op_(from->length, /*+*/1)) == NULL) 139 return false; 140 memcpy(x, from->entry, from->length); 141 x[from->length] = '\0'; 142 to->entry = x; 143 } 144 return true; 145} 146 147static FLAC__bool copy_track_(FLAC__StreamMetadata_CueSheet_Track *to, const FLAC__StreamMetadata_CueSheet_Track *from) 148{ 149 memcpy(to, from, sizeof(FLAC__StreamMetadata_CueSheet_Track)); 150 if (from->indices == 0) { 151 FLAC__ASSERT(from->num_indices == 0); 152 } 153 else { 154 FLAC__StreamMetadata_CueSheet_Index *x; 155 FLAC__ASSERT(from->num_indices > 0); 156 if ((x = safe_malloc_mul_2op_p(from->num_indices, /*times*/sizeof(FLAC__StreamMetadata_CueSheet_Index))) == NULL) 157 return false; 158 memcpy(x, from->indices, from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index)); 159 to->indices = x; 160 } 161 return true; 162} 163 164static void seektable_calculate_length_(FLAC__StreamMetadata *object) 165{ 166 FLAC__ASSERT(object != NULL); 167 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 168 169 object->length = object->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH; 170} 171 172static FLAC__StreamMetadata_SeekPoint *seekpoint_array_new_(unsigned num_points) 173{ 174 FLAC__StreamMetadata_SeekPoint *object_array; 175 176 FLAC__ASSERT(num_points > 0); 177 178 object_array = safe_malloc_mul_2op_p(num_points, /*times*/sizeof(FLAC__StreamMetadata_SeekPoint)); 179 180 if (object_array != NULL) { 181 unsigned i; 182 for (i = 0; i < num_points; i++) { 183 object_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 184 object_array[i].stream_offset = 0; 185 object_array[i].frame_samples = 0; 186 } 187 } 188 189 return object_array; 190} 191 192static void vorbiscomment_calculate_length_(FLAC__StreamMetadata *object) 193{ 194 unsigned i; 195 196 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 197 198 object->length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN) / 8; 199 object->length += object->data.vorbis_comment.vendor_string.length; 200 object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8; 201 for (i = 0; i < object->data.vorbis_comment.num_comments; i++) { 202 object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8); 203 object->length += object->data.vorbis_comment.comments[i].length; 204 } 205} 206 207static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_new_(unsigned num_comments) 208{ 209 FLAC__ASSERT(num_comments > 0); 210 211 return safe_calloc_(num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)); 212} 213 214static void vorbiscomment_entry_array_delete_(FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments) 215{ 216 unsigned i; 217 218 FLAC__ASSERT(object_array != NULL && num_comments > 0); 219 220 for (i = 0; i < num_comments; i++) 221 free(object_array[i].entry); 222 223 free(object_array); 224} 225 226static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_copy_(const FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments) 227{ 228 FLAC__StreamMetadata_VorbisComment_Entry *return_array; 229 230 FLAC__ASSERT(object_array != NULL); 231 FLAC__ASSERT(num_comments > 0); 232 233 return_array = vorbiscomment_entry_array_new_(num_comments); 234 235 if (return_array != NULL) { 236 unsigned i; 237 238 for (i = 0; i < num_comments; i++) { 239 if (!copy_vcentry_(return_array+i, object_array+i)) { 240 vorbiscomment_entry_array_delete_(return_array, num_comments); 241 return 0; 242 } 243 } 244 } 245 246 return return_array; 247} 248 249static FLAC__bool vorbiscomment_set_entry_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry *dest, const FLAC__StreamMetadata_VorbisComment_Entry *src, FLAC__bool copy) 250{ 251 FLAC__byte *save; 252 253 FLAC__ASSERT(object != NULL); 254 FLAC__ASSERT(dest != NULL); 255 FLAC__ASSERT(src != NULL); 256 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 257 FLAC__ASSERT((src->entry != NULL && src->length > 0) || (src->entry == NULL && src->length == 0)); 258 259 save = dest->entry; 260 261 if (src->entry != NULL) { 262 if (copy) { 263 /* do the copy first so that if we fail we leave the dest object untouched */ 264 if (!copy_vcentry_(dest, src)) 265 return false; 266 } 267 else { 268 /* we have to make sure that the string we're taking over is null-terminated */ 269 270 /* 271 * Stripping the const from src->entry is OK since we're taking 272 * ownership of the pointer. This is a hack around a deficiency 273 * in the API where the same function is used for 'copy' and 274 * 'own', but the source entry is a const pointer. If we were 275 * precise, the 'own' flavor would be a separate function with a 276 * non-const source pointer. But it's not, so we hack away. 277 */ 278 if (!ensure_null_terminated_((FLAC__byte**)(&src->entry), src->length)) 279 return false; 280 *dest = *src; 281 } 282 } 283 else { 284 /* the src is null */ 285 *dest = *src; 286 } 287 288 free(save); 289 290 vorbiscomment_calculate_length_(object); 291 return true; 292} 293 294static int vorbiscomment_find_entry_from_(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name, unsigned field_name_length) 295{ 296 unsigned i; 297 298 FLAC__ASSERT(object != NULL); 299 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 300 FLAC__ASSERT(field_name != NULL); 301 302 for (i = offset; i < object->data.vorbis_comment.num_comments; i++) { 303 if (FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) 304 return (int)i; 305 } 306 307 return -1; 308} 309 310static void cuesheet_calculate_length_(FLAC__StreamMetadata *object) 311{ 312 unsigned i; 313 314 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 315 316 object->length = ( 317 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN + 318 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN + 319 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN + 320 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN + 321 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN 322 ) / 8; 323 324 object->length += object->data.cue_sheet.num_tracks * ( 325 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN + 326 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN + 327 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN + 328 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN + 329 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN + 330 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN + 331 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN 332 ) / 8; 333 334 for (i = 0; i < object->data.cue_sheet.num_tracks; i++) { 335 object->length += object->data.cue_sheet.tracks[i].num_indices * ( 336 FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN + 337 FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN + 338 FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN 339 ) / 8; 340 } 341} 342 343static FLAC__StreamMetadata_CueSheet_Index *cuesheet_track_index_array_new_(unsigned num_indices) 344{ 345 FLAC__ASSERT(num_indices > 0); 346 347 return safe_calloc_(num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)); 348} 349 350static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_new_(unsigned num_tracks) 351{ 352 FLAC__ASSERT(num_tracks > 0); 353 354 return safe_calloc_(num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)); 355} 356 357static void cuesheet_track_array_delete_(FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks) 358{ 359 unsigned i; 360 361 FLAC__ASSERT(object_array != NULL && num_tracks > 0); 362 363 for (i = 0; i < num_tracks; i++) { 364 if (object_array[i].indices != 0) { 365 FLAC__ASSERT(object_array[i].num_indices > 0); 366 free(object_array[i].indices); 367 } 368 } 369 370 free(object_array); 371} 372 373static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_copy_(const FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks) 374{ 375 FLAC__StreamMetadata_CueSheet_Track *return_array; 376 377 FLAC__ASSERT(object_array != NULL); 378 FLAC__ASSERT(num_tracks > 0); 379 380 return_array = cuesheet_track_array_new_(num_tracks); 381 382 if (return_array != NULL) { 383 unsigned i; 384 385 for (i = 0; i < num_tracks; i++) { 386 if (!copy_track_(return_array+i, object_array+i)) { 387 cuesheet_track_array_delete_(return_array, num_tracks); 388 return 0; 389 } 390 } 391 } 392 393 return return_array; 394} 395 396static FLAC__bool cuesheet_set_track_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_CueSheet_Track *dest, const FLAC__StreamMetadata_CueSheet_Track *src, FLAC__bool copy) 397{ 398 FLAC__StreamMetadata_CueSheet_Index *save; 399 400 FLAC__ASSERT(object != NULL); 401 FLAC__ASSERT(dest != NULL); 402 FLAC__ASSERT(src != NULL); 403 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 404 FLAC__ASSERT((src->indices != NULL && src->num_indices > 0) || (src->indices == NULL && src->num_indices == 0)); 405 406 save = dest->indices; 407 408 /* do the copy first so that if we fail we leave the object untouched */ 409 if (copy) { 410 if (!copy_track_(dest, src)) 411 return false; 412 } 413 else { 414 *dest = *src; 415 } 416 417 free(save); 418 419 cuesheet_calculate_length_(object); 420 return true; 421} 422 423 424/**************************************************************************** 425 * 426 * Metadata object routines 427 * 428 ***************************************************************************/ 429 430FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type) 431{ 432 FLAC__StreamMetadata *object; 433 434 if (type > FLAC__MAX_METADATA_TYPE) 435 return 0; 436 437 object = calloc(1, sizeof(FLAC__StreamMetadata)); 438 if (object != NULL) { 439 object->is_last = false; 440 object->type = type; 441 switch(type) { 442 case FLAC__METADATA_TYPE_STREAMINFO: 443 object->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; 444 break; 445 case FLAC__METADATA_TYPE_PADDING: 446 /* calloc() took care of this for us: 447 object->length = 0; 448 */ 449 break; 450 case FLAC__METADATA_TYPE_APPLICATION: 451 object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8; 452 /* calloc() took care of this for us: 453 object->data.application.data = 0; 454 */ 455 break; 456 case FLAC__METADATA_TYPE_SEEKTABLE: 457 /* calloc() took care of this for us: 458 object->length = 0; 459 object->data.seek_table.num_points = 0; 460 object->data.seek_table.points = 0; 461 */ 462 break; 463 case FLAC__METADATA_TYPE_VORBIS_COMMENT: 464 object->data.vorbis_comment.vendor_string.length = (unsigned)strlen(FLAC__VENDOR_STRING); 465 if (!copy_bytes_(&object->data.vorbis_comment.vendor_string.entry, (const FLAC__byte*)FLAC__VENDOR_STRING, object->data.vorbis_comment.vendor_string.length+1)) { 466 free(object); 467 return 0; 468 } 469 vorbiscomment_calculate_length_(object); 470 break; 471 case FLAC__METADATA_TYPE_CUESHEET: 472 cuesheet_calculate_length_(object); 473 break; 474 case FLAC__METADATA_TYPE_PICTURE: 475 object->length = ( 476 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN + 477 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* empty mime_type string */ 478 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* empty description string */ 479 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN + 480 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN + 481 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN + 482 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN + 483 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN + 484 0 /* no data */ 485 ) / 8; 486 object->data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER; 487 object->data.picture.mime_type = 0; 488 object->data.picture.description = 0; 489 /* calloc() took care of this for us: 490 object->data.picture.width = 0; 491 object->data.picture.height = 0; 492 object->data.picture.depth = 0; 493 object->data.picture.colors = 0; 494 object->data.picture.data_length = 0; 495 object->data.picture.data = 0; 496 */ 497 /* now initialize mime_type and description with empty strings to make things easier on the client */ 498 if (!copy_cstring_(&object->data.picture.mime_type, "")) { 499 free(object); 500 return 0; 501 } 502 if (!copy_cstring_((char**)(&object->data.picture.description), "")) { 503 free(object->data.picture.mime_type); 504 free(object); 505 return 0; 506 } 507 break; 508 default: 509 /* calloc() took care of this for us: 510 object->length = 0; 511 object->data.unknown.data = 0; 512 */ 513 break; 514 } 515 } 516 517 return object; 518} 519 520FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object) 521{ 522 FLAC__StreamMetadata *to; 523 524 FLAC__ASSERT(object != NULL); 525 526 if ((to = FLAC__metadata_object_new(object->type)) != NULL) { 527 to->is_last = object->is_last; 528 to->type = object->type; 529 to->length = object->length; 530 switch(to->type) { 531 case FLAC__METADATA_TYPE_STREAMINFO: 532 memcpy(&to->data.stream_info, &object->data.stream_info, sizeof(FLAC__StreamMetadata_StreamInfo)); 533 break; 534 case FLAC__METADATA_TYPE_PADDING: 535 break; 536 case FLAC__METADATA_TYPE_APPLICATION: 537 if (to->length < FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) { /* underflow check */ 538 FLAC__metadata_object_delete(to); 539 return 0; 540 } 541 memcpy(&to->data.application.id, &object->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8); 542 if (!copy_bytes_(&to->data.application.data, object->data.application.data, object->length - FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) { 543 FLAC__metadata_object_delete(to); 544 return 0; 545 } 546 break; 547 case FLAC__METADATA_TYPE_SEEKTABLE: 548 to->data.seek_table.num_points = object->data.seek_table.num_points; 549 if (to->data.seek_table.num_points > UINT32_MAX / sizeof(FLAC__StreamMetadata_SeekPoint)) { /* overflow check */ 550 FLAC__metadata_object_delete(to); 551 return 0; 552 } 553 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))) { 554 FLAC__metadata_object_delete(to); 555 return 0; 556 } 557 break; 558 case FLAC__METADATA_TYPE_VORBIS_COMMENT: 559 if (to->data.vorbis_comment.vendor_string.entry != NULL) { 560 free(to->data.vorbis_comment.vendor_string.entry); 561 to->data.vorbis_comment.vendor_string.entry = 0; 562 } 563 if (!copy_vcentry_(&to->data.vorbis_comment.vendor_string, &object->data.vorbis_comment.vendor_string)) { 564 FLAC__metadata_object_delete(to); 565 return 0; 566 } 567 if (object->data.vorbis_comment.num_comments == 0) { 568 to->data.vorbis_comment.comments = 0; 569 } 570 else { 571 to->data.vorbis_comment.comments = vorbiscomment_entry_array_copy_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments); 572 if (to->data.vorbis_comment.comments == NULL) { 573 to->data.vorbis_comment.num_comments = 0; 574 FLAC__metadata_object_delete(to); 575 return 0; 576 } 577 } 578 to->data.vorbis_comment.num_comments = object->data.vorbis_comment.num_comments; 579 break; 580 case FLAC__METADATA_TYPE_CUESHEET: 581 memcpy(&to->data.cue_sheet, &object->data.cue_sheet, sizeof(FLAC__StreamMetadata_CueSheet)); 582 if (object->data.cue_sheet.num_tracks == 0) { 583 FLAC__ASSERT(object->data.cue_sheet.tracks == NULL); 584 } 585 else { 586 FLAC__ASSERT(object->data.cue_sheet.tracks != 0); 587 to->data.cue_sheet.tracks = cuesheet_track_array_copy_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks); 588 if (to->data.cue_sheet.tracks == NULL) { 589 FLAC__metadata_object_delete(to); 590 return 0; 591 } 592 } 593 break; 594 case FLAC__METADATA_TYPE_PICTURE: 595 to->data.picture.type = object->data.picture.type; 596 if (!copy_cstring_(&to->data.picture.mime_type, object->data.picture.mime_type)) { 597 FLAC__metadata_object_delete(to); 598 return 0; 599 } 600 if (!copy_cstring_((char**)(&to->data.picture.description), (const char*)object->data.picture.description)) { 601 FLAC__metadata_object_delete(to); 602 return 0; 603 } 604 to->data.picture.width = object->data.picture.width; 605 to->data.picture.height = object->data.picture.height; 606 to->data.picture.depth = object->data.picture.depth; 607 to->data.picture.colors = object->data.picture.colors; 608 to->data.picture.data_length = object->data.picture.data_length; 609 if (!copy_bytes_((&to->data.picture.data), object->data.picture.data, object->data.picture.data_length)) { 610 FLAC__metadata_object_delete(to); 611 return 0; 612 } 613 break; 614 default: 615 if (!copy_bytes_(&to->data.unknown.data, object->data.unknown.data, object->length)) { 616 FLAC__metadata_object_delete(to); 617 return 0; 618 } 619 break; 620 } 621 } 622 623 return to; 624} 625 626void FLAC__metadata_object_delete_data(FLAC__StreamMetadata *object) 627{ 628 FLAC__ASSERT(object != NULL); 629 630 switch(object->type) { 631 case FLAC__METADATA_TYPE_STREAMINFO: 632 case FLAC__METADATA_TYPE_PADDING: 633 break; 634 case FLAC__METADATA_TYPE_APPLICATION: 635 if (object->data.application.data != NULL) { 636 free(object->data.application.data); 637 object->data.application.data = NULL; 638 } 639 break; 640 case FLAC__METADATA_TYPE_SEEKTABLE: 641 if (object->data.seek_table.points != NULL) { 642 free(object->data.seek_table.points); 643 object->data.seek_table.points = NULL; 644 } 645 break; 646 case FLAC__METADATA_TYPE_VORBIS_COMMENT: 647 if (object->data.vorbis_comment.vendor_string.entry != NULL) { 648 free(object->data.vorbis_comment.vendor_string.entry); 649 object->data.vorbis_comment.vendor_string.entry = 0; 650 } 651 if (object->data.vorbis_comment.comments != NULL) { 652 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0); 653 vorbiscomment_entry_array_delete_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments); 654 object->data.vorbis_comment.comments = NULL; 655 object->data.vorbis_comment.num_comments = 0; 656 } 657 break; 658 case FLAC__METADATA_TYPE_CUESHEET: 659 if (object->data.cue_sheet.tracks != NULL) { 660 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0); 661 cuesheet_track_array_delete_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks); 662 object->data.cue_sheet.tracks = NULL; 663 object->data.cue_sheet.num_tracks = 0; 664 } 665 break; 666 case FLAC__METADATA_TYPE_PICTURE: 667 if (object->data.picture.mime_type != NULL) { 668 free(object->data.picture.mime_type); 669 object->data.picture.mime_type = NULL; 670 } 671 if (object->data.picture.description != NULL) { 672 free(object->data.picture.description); 673 object->data.picture.description = NULL; 674 } 675 if (object->data.picture.data != NULL) { 676 free(object->data.picture.data); 677 object->data.picture.data = NULL; 678 } 679 break; 680 default: 681 if (object->data.unknown.data != NULL) { 682 free(object->data.unknown.data); 683 object->data.unknown.data = NULL; 684 } 685 break; 686 } 687} 688 689FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object) 690{ 691 FLAC__metadata_object_delete_data(object); 692 free(object); 693} 694 695static FLAC__bool compare_block_data_streaminfo_(const FLAC__StreamMetadata_StreamInfo *block1, const FLAC__StreamMetadata_StreamInfo *block2) 696{ 697 if (block1->min_blocksize != block2->min_blocksize) 698 return false; 699 if (block1->max_blocksize != block2->max_blocksize) 700 return false; 701 if (block1->min_framesize != block2->min_framesize) 702 return false; 703 if (block1->max_framesize != block2->max_framesize) 704 return false; 705 if (block1->sample_rate != block2->sample_rate) 706 return false; 707 if (block1->channels != block2->channels) 708 return false; 709 if (block1->bits_per_sample != block2->bits_per_sample) 710 return false; 711 if (block1->total_samples != block2->total_samples) 712 return false; 713 if (memcmp(block1->md5sum, block2->md5sum, 16) != 0) 714 return false; 715 return true; 716} 717 718static FLAC__bool compare_block_data_application_(const FLAC__StreamMetadata_Application *block1, const FLAC__StreamMetadata_Application *block2, unsigned block_length) 719{ 720 FLAC__ASSERT(block1 != NULL); 721 FLAC__ASSERT(block2 != NULL); 722 FLAC__ASSERT(block_length >= sizeof(block1->id)); 723 724 if (memcmp(block1->id, block2->id, sizeof(block1->id)) != 0) 725 return false; 726 if (block1->data != NULL && block2->data != NULL) 727 return memcmp(block1->data, block2->data, block_length - sizeof(block1->id)) == 0; 728 else 729 return block1->data == block2->data; 730} 731 732static FLAC__bool compare_block_data_seektable_(const FLAC__StreamMetadata_SeekTable *block1, const FLAC__StreamMetadata_SeekTable *block2) 733{ 734 unsigned i; 735 736 FLAC__ASSERT(block1 != NULL); 737 FLAC__ASSERT(block2 != NULL); 738 739 if (block1->num_points != block2->num_points) 740 return false; 741 742 if (block1->points != NULL && block2->points != NULL) { 743 for (i = 0; i < block1->num_points; i++) { 744 if (block1->points[i].sample_number != block2->points[i].sample_number) 745 return false; 746 if (block1->points[i].stream_offset != block2->points[i].stream_offset) 747 return false; 748 if (block1->points[i].frame_samples != block2->points[i].frame_samples) 749 return false; 750 } 751 return true; 752 } 753 else 754 return block1->points == block2->points; 755} 756 757static FLAC__bool compare_block_data_vorbiscomment_(const FLAC__StreamMetadata_VorbisComment *block1, const FLAC__StreamMetadata_VorbisComment *block2) 758{ 759 unsigned i; 760 761 if (block1->vendor_string.length != block2->vendor_string.length) 762 return false; 763 764 if (block1->vendor_string.entry != NULL && block2->vendor_string.entry != NULL) { 765 if (memcmp(block1->vendor_string.entry, block2->vendor_string.entry, block1->vendor_string.length) != 0) 766 return false; 767 } 768 else if (block1->vendor_string.entry != block2->vendor_string.entry) 769 return false; 770 771 if (block1->num_comments != block2->num_comments) 772 return false; 773 774 for (i = 0; i < block1->num_comments; i++) { 775 if (block1->comments[i].entry != NULL && block2->comments[i].entry != NULL) { 776 if (memcmp(block1->comments[i].entry, block2->comments[i].entry, block1->comments[i].length) != 0) 777 return false; 778 } 779 else if (block1->comments[i].entry != block2->comments[i].entry) 780 return false; 781 } 782 return true; 783} 784 785static FLAC__bool compare_block_data_cuesheet_(const FLAC__StreamMetadata_CueSheet *block1, const FLAC__StreamMetadata_CueSheet *block2) 786{ 787 unsigned i, j; 788 789 if (strcmp(block1->media_catalog_number, block2->media_catalog_number) != 0) 790 return false; 791 792 if (block1->lead_in != block2->lead_in) 793 return false; 794 795 if (block1->is_cd != block2->is_cd) 796 return false; 797 798 if (block1->num_tracks != block2->num_tracks) 799 return false; 800 801 if (block1->tracks != NULL && block2->tracks != NULL) { 802 FLAC__ASSERT(block1->num_tracks > 0); 803 for (i = 0; i < block1->num_tracks; i++) { 804 if (block1->tracks[i].offset != block2->tracks[i].offset) 805 return false; 806 if (block1->tracks[i].number != block2->tracks[i].number) 807 return false; 808 if (memcmp(block1->tracks[i].isrc, block2->tracks[i].isrc, sizeof(block1->tracks[i].isrc)) != 0) 809 return false; 810 if (block1->tracks[i].type != block2->tracks[i].type) 811 return false; 812 if (block1->tracks[i].pre_emphasis != block2->tracks[i].pre_emphasis) 813 return false; 814 if (block1->tracks[i].num_indices != block2->tracks[i].num_indices) 815 return false; 816 if (block1->tracks[i].indices != NULL && block2->tracks[i].indices != NULL) { 817 FLAC__ASSERT(block1->tracks[i].num_indices > 0); 818 for (j = 0; j < block1->tracks[i].num_indices; j++) { 819 if (block1->tracks[i].indices[j].offset != block2->tracks[i].indices[j].offset) 820 return false; 821 if (block1->tracks[i].indices[j].number != block2->tracks[i].indices[j].number) 822 return false; 823 } 824 } 825 else if (block1->tracks[i].indices != block2->tracks[i].indices) 826 return false; 827 } 828 } 829 else if (block1->tracks != block2->tracks) 830 return false; 831 return true; 832} 833 834static FLAC__bool compare_block_data_picture_(const FLAC__StreamMetadata_Picture *block1, const FLAC__StreamMetadata_Picture *block2) 835{ 836 if (block1->type != block2->type) 837 return false; 838 if (block1->mime_type != block2->mime_type && (block1->mime_type == 0 || block2->mime_type == 0 || strcmp(block1->mime_type, block2->mime_type))) 839 return false; 840 if (block1->description != block2->description && (block1->description == 0 || block2->description == 0 || strcmp((const char *)block1->description, (const char *)block2->description))) 841 return false; 842 if (block1->width != block2->width) 843 return false; 844 if (block1->height != block2->height) 845 return false; 846 if (block1->depth != block2->depth) 847 return false; 848 if (block1->colors != block2->colors) 849 return false; 850 if (block1->data_length != block2->data_length) 851 return false; 852 if (block1->data != block2->data && (block1->data == NULL || block2->data == NULL || memcmp(block1->data, block2->data, block1->data_length))) 853 return false; 854 return true; 855} 856 857static FLAC__bool compare_block_data_unknown_(const FLAC__StreamMetadata_Unknown *block1, const FLAC__StreamMetadata_Unknown *block2, unsigned block_length) 858{ 859 FLAC__ASSERT(block1 != NULL); 860 FLAC__ASSERT(block2 != NULL); 861 862 if (block1->data != NULL && block2->data != NULL) 863 return memcmp(block1->data, block2->data, block_length) == 0; 864 else 865 return block1->data == block2->data; 866} 867 868FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2) 869{ 870 FLAC__ASSERT(block1 != NULL); 871 FLAC__ASSERT(block2 != NULL); 872 873 if (block1->type != block2->type) { 874 return false; 875 } 876 if (block1->is_last != block2->is_last) { 877 return false; 878 } 879 if (block1->length != block2->length) { 880 return false; 881 } 882 switch(block1->type) { 883 case FLAC__METADATA_TYPE_STREAMINFO: 884 return compare_block_data_streaminfo_(&block1->data.stream_info, &block2->data.stream_info); 885 case FLAC__METADATA_TYPE_PADDING: 886 return true; /* we don't compare the padding guts */ 887 case FLAC__METADATA_TYPE_APPLICATION: 888 return compare_block_data_application_(&block1->data.application, &block2->data.application, block1->length); 889 case FLAC__METADATA_TYPE_SEEKTABLE: 890 return compare_block_data_seektable_(&block1->data.seek_table, &block2->data.seek_table); 891 case FLAC__METADATA_TYPE_VORBIS_COMMENT: 892 return compare_block_data_vorbiscomment_(&block1->data.vorbis_comment, &block2->data.vorbis_comment); 893 case FLAC__METADATA_TYPE_CUESHEET: 894 return compare_block_data_cuesheet_(&block1->data.cue_sheet, &block2->data.cue_sheet); 895 case FLAC__METADATA_TYPE_PICTURE: 896 return compare_block_data_picture_(&block1->data.picture, &block2->data.picture); 897 default: 898 return compare_block_data_unknown_(&block1->data.unknown, &block2->data.unknown, block1->length); 899 } 900} 901 902FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy) 903{ 904 FLAC__byte *save; 905 906 FLAC__ASSERT(object != NULL); 907 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_APPLICATION); 908 FLAC__ASSERT((data != NULL && length > 0) || (data == NULL && length == 0 && copy == false)); 909 910 save = object->data.application.data; 911 912 /* do the copy first so that if we fail we leave the object untouched */ 913 if (copy) { 914 if (!copy_bytes_(&object->data.application.data, data, length)) 915 return false; 916 } 917 else { 918 object->data.application.data = data; 919 } 920 921 free(save); 922 923 object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8 + length; 924 return true; 925} 926 927FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points) 928{ 929 FLAC__ASSERT(object != NULL); 930 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 931 932 if (object->data.seek_table.points == 0) { 933 FLAC__ASSERT(object->data.seek_table.num_points == 0); 934 if (new_num_points == 0) 935 return true; 936 else if ((object->data.seek_table.points = seekpoint_array_new_(new_num_points)) == 0) 937 return false; 938 } 939 else { 940 const size_t old_size = object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint); 941 const size_t new_size = new_num_points * sizeof(FLAC__StreamMetadata_SeekPoint); 942 943 /* overflow check */ 944 if (new_num_points > UINT32_MAX / sizeof(FLAC__StreamMetadata_SeekPoint)) 945 return false; 946 947 FLAC__ASSERT(object->data.seek_table.num_points > 0); 948 949 if (new_size == 0) { 950 free(object->data.seek_table.points); 951 object->data.seek_table.points = 0; 952 } 953 else if ((object->data.seek_table.points = safe_realloc_(object->data.seek_table.points, new_size)) == NULL) 954 return false; 955 956 /* if growing, set new elements to placeholders */ 957 if (new_size > old_size) { 958 unsigned i; 959 for (i = object->data.seek_table.num_points; i < new_num_points; i++) { 960 object->data.seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 961 object->data.seek_table.points[i].stream_offset = 0; 962 object->data.seek_table.points[i].frame_samples = 0; 963 } 964 } 965 } 966 967 object->data.seek_table.num_points = new_num_points; 968 969 seektable_calculate_length_(object); 970 return true; 971} 972 973FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point) 974{ 975 FLAC__ASSERT(object != NULL); 976 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 977 FLAC__ASSERT(point_num < object->data.seek_table.num_points); 978 979 object->data.seek_table.points[point_num] = point; 980} 981 982FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point) 983{ 984 int i; 985 986 FLAC__ASSERT(object != NULL); 987 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 988 FLAC__ASSERT(point_num <= object->data.seek_table.num_points); 989 990 if (!FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points+1)) 991 return false; 992 993 /* move all points >= point_num forward one space */ 994 for (i = (int)object->data.seek_table.num_points-1; i > (int)point_num; i--) 995 object->data.seek_table.points[i] = object->data.seek_table.points[i-1]; 996 997 FLAC__metadata_object_seektable_set_point(object, point_num, point); 998 seektable_calculate_length_(object); 999 return true; 1000} 1001 1002FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num) 1003{ 1004 unsigned i; 1005 1006 FLAC__ASSERT(object != NULL); 1007 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1008 FLAC__ASSERT(point_num < object->data.seek_table.num_points); 1009 1010 /* move all points > point_num backward one space */ 1011 for (i = point_num; i < object->data.seek_table.num_points-1; i++) 1012 object->data.seek_table.points[i] = object->data.seek_table.points[i+1]; 1013 1014 return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points-1); 1015} 1016 1017FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object) 1018{ 1019 FLAC__ASSERT(object != NULL); 1020 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1021 1022 return FLAC__format_seektable_is_legal(&object->data.seek_table); 1023} 1024 1025FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num) 1026{ 1027 FLAC__ASSERT(object != NULL); 1028 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1029 1030 if (num > 0) 1031 /* WATCHOUT: we rely on the fact that growing the array adds PLACEHOLDERS at the end */ 1032 return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points + num); 1033 else 1034 return true; 1035} 1036 1037FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number) 1038{ 1039 FLAC__StreamMetadata_SeekTable *seek_table; 1040 1041 FLAC__ASSERT(object != NULL); 1042 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1043 1044 seek_table = &object->data.seek_table; 1045 1046 if (!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + 1)) 1047 return false; 1048 1049 seek_table->points[seek_table->num_points - 1].sample_number = sample_number; 1050 seek_table->points[seek_table->num_points - 1].stream_offset = 0; 1051 seek_table->points[seek_table->num_points - 1].frame_samples = 0; 1052 1053 return true; 1054} 1055 1056FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num) 1057{ 1058 FLAC__ASSERT(object != NULL); 1059 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1060 FLAC__ASSERT(sample_numbers != 0 || num == 0); 1061 1062 if (num > 0) { 1063 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table; 1064 unsigned i, j; 1065 1066 i = seek_table->num_points; 1067 1068 if (!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num)) 1069 return false; 1070 1071 for (j = 0; j < num; i++, j++) { 1072 seek_table->points[i].sample_number = sample_numbers[j]; 1073 seek_table->points[i].stream_offset = 0; 1074 seek_table->points[i].frame_samples = 0; 1075 } 1076 } 1077 1078 return true; 1079} 1080 1081FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples) 1082{ 1083 FLAC__ASSERT(object != NULL); 1084 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1085 FLAC__ASSERT(total_samples > 0); 1086 1087 if (num > 0 && total_samples > 0) { 1088 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table; 1089 unsigned i, j; 1090 1091 i = seek_table->num_points; 1092 1093 if (!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num)) 1094 return false; 1095 1096 for (j = 0; j < num; i++, j++) { 1097 seek_table->points[i].sample_number = total_samples * (FLAC__uint64)j / (FLAC__uint64)num; 1098 seek_table->points[i].stream_offset = 0; 1099 seek_table->points[i].frame_samples = 0; 1100 } 1101 } 1102 1103 return true; 1104} 1105 1106FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, unsigned samples, FLAC__uint64 total_samples) 1107{ 1108 FLAC__ASSERT(object != NULL); 1109 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1110 FLAC__ASSERT(samples > 0); 1111 FLAC__ASSERT(total_samples > 0); 1112 1113 if (samples > 0 && total_samples > 0) { 1114 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table; 1115 unsigned i, j; 1116 FLAC__uint64 num, sample; 1117 1118 num = 1 + total_samples / samples; /* 1+ for the first sample at 0 */ 1119 /* now account for the fact that we don't place a seekpoint at "total_samples" since samples are number from 0: */ 1120 if (total_samples % samples == 0) 1121 num--; 1122 1123 /* Put a strict upper bound on the number of allowed seek points. */ 1124 if (num > 32768) { 1125 /* Set the bound and recalculate samples accordingly. */ 1126 num = 32768; 1127 samples = total_samples / num; 1128 } 1129 1130 i = seek_table->num_points; 1131 1132 if (!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + (unsigned)num)) 1133 return false; 1134 1135 sample = 0; 1136 for (j = 0; j < num; i++, j++, sample += samples) { 1137 seek_table->points[i].sample_number = sample; 1138 seek_table->points[i].stream_offset = 0; 1139 seek_table->points[i].frame_samples = 0; 1140 } 1141 } 1142 1143 return true; 1144} 1145 1146FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact) 1147{ 1148 unsigned unique; 1149 1150 FLAC__ASSERT(object != NULL); 1151 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE); 1152 1153 unique = FLAC__format_seektable_sort(&object->data.seek_table); 1154 1155 return !compact || FLAC__metadata_object_seektable_resize_points(object, unique); 1156} 1157 1158FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy) 1159{ 1160 if (!FLAC__format_vorbiscomment_entry_value_is_legal(entry.entry, entry.length)) 1161 return false; 1162 return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.vendor_string, &entry, copy); 1163} 1164 1165FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments) 1166{ 1167 FLAC__ASSERT(object != NULL); 1168 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1169 1170 if (object->data.vorbis_comment.comments == NULL) { 1171 FLAC__ASSERT(object->data.vorbis_comment.num_comments == 0); 1172 if (new_num_comments == 0) 1173 return true; 1174 else if ((object->data.vorbis_comment.comments = vorbiscomment_entry_array_new_(new_num_comments)) == NULL) 1175 return false; 1176 } 1177 else { 1178 const size_t old_size = object->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry); 1179 const size_t new_size = new_num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry); 1180 1181 /* overflow check */ 1182 if (new_num_comments > UINT32_MAX / sizeof(FLAC__StreamMetadata_VorbisComment_Entry)) 1183 return false; 1184 1185 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0); 1186 1187 /* if shrinking, free the truncated entries */ 1188 if (new_num_comments < object->data.vorbis_comment.num_comments) { 1189 unsigned i; 1190 for (i = new_num_comments; i < object->data.vorbis_comment.num_comments; i++) 1191 if (object->data.vorbis_comment.comments[i].entry != NULL) 1192 free(object->data.vorbis_comment.comments[i].entry); 1193 } 1194 1195 if (new_size == 0) { 1196 free(object->data.vorbis_comment.comments); 1197 object->data.vorbis_comment.comments = 0; 1198 } 1199 else { 1200 FLAC__StreamMetadata_VorbisComment_Entry *oldptr = object->data.vorbis_comment.comments; 1201 if ((object->data.vorbis_comment.comments = realloc(object->data.vorbis_comment.comments, new_size)) == NULL) { 1202 vorbiscomment_entry_array_delete_(oldptr, object->data.vorbis_comment.num_comments); 1203 object->data.vorbis_comment.num_comments = 0; 1204 return false; 1205 } 1206 } 1207 1208 /* if growing, zero all the length/pointers of new elements */ 1209 if (new_size > old_size) 1210 memset(object->data.vorbis_comment.comments + object->data.vorbis_comment.num_comments, 0, new_size - old_size); 1211 } 1212 1213 object->data.vorbis_comment.num_comments = new_num_comments; 1214 1215 vorbiscomment_calculate_length_(object); 1216 return true; 1217} 1218 1219FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy) 1220{ 1221 FLAC__ASSERT(object != NULL); 1222 FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments); 1223 1224 if (!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length)) 1225 return false; 1226 return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.comments[comment_num], &entry, copy); 1227} 1228 1229FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy) 1230{ 1231 FLAC__StreamMetadata_VorbisComment *vc; 1232 1233 FLAC__ASSERT(object != NULL); 1234 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1235 FLAC__ASSERT(comment_num <= object->data.vorbis_comment.num_comments); 1236 1237 if (!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length)) 1238 return false; 1239 1240 vc = &object->data.vorbis_comment; 1241 1242 if (!FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments+1)) 1243 return false; 1244 1245 /* move all comments >= comment_num forward one space */ 1246 memmove(&vc->comments[comment_num+1], &vc->comments[comment_num], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-1-comment_num)); 1247 vc->comments[comment_num].length = 0; 1248 vc->comments[comment_num].entry = 0; 1249 1250 return FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy); 1251} 1252 1253FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy) 1254{ 1255 FLAC__ASSERT(object != NULL); 1256 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1257 return FLAC__metadata_object_vorbiscomment_insert_comment(object, object->data.vorbis_comment.num_comments, entry, copy); 1258} 1259 1260FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy) 1261{ 1262 FLAC__ASSERT(entry.entry != NULL && entry.length > 0); 1263 1264 if (!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length)) 1265 return false; 1266 1267 { 1268 int i; 1269 size_t field_name_length; 1270 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length); 1271 1272 if (eq == NULL) 1273 return false; /* double protection */ 1274 1275 field_name_length = eq-entry.entry; 1276 1277 i = vorbiscomment_find_entry_from_(object, 0, (const char *)entry.entry, field_name_length); 1278 if (i >= 0) { 1279 unsigned indx = (unsigned)i; 1280 if (!FLAC__metadata_object_vorbiscomment_set_comment(object, indx, entry, copy)) 1281 return false; 1282 entry = object->data.vorbis_comment.comments[indx]; 1283 indx++; /* skip over replaced comment */ 1284 if (all && indx < object->data.vorbis_comment.num_comments) { 1285 i = vorbiscomment_find_entry_from_(object, indx, (const char *)entry.entry, field_name_length); 1286 while (i >= 0) { 1287 indx = (unsigned)i; 1288 if (!FLAC__metadata_object_vorbiscomment_delete_comment(object, indx)) 1289 return false; 1290 if (indx < object->data.vorbis_comment.num_comments) 1291 i = vorbiscomment_find_entry_from_(object, indx, (const char *)entry.entry, field_name_length); 1292 else 1293 i = -1; 1294 } 1295 } 1296 return true; 1297 } 1298 else 1299 return FLAC__metadata_object_vorbiscomment_append_comment(object, entry, copy); 1300 } 1301} 1302 1303FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num) 1304{ 1305 FLAC__StreamMetadata_VorbisComment *vc; 1306 1307 FLAC__ASSERT(object != NULL); 1308 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1309 FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments); 1310 1311 vc = &object->data.vorbis_comment; 1312 1313 /* free the comment at comment_num */ 1314 free(vc->comments[comment_num].entry); 1315 1316 /* move all comments > comment_num backward one space */ 1317 memmove(&vc->comments[comment_num], &vc->comments[comment_num+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-comment_num-1)); 1318 vc->comments[vc->num_comments-1].length = 0; 1319 vc->comments[vc->num_comments-1].entry = 0; 1320 1321 return FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments-1); 1322} 1323 1324FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field_name, const char *field_value) 1325{ 1326 FLAC__ASSERT(entry != NULL); 1327 FLAC__ASSERT(field_name != NULL); 1328 FLAC__ASSERT(field_value != NULL); 1329 1330 if (!FLAC__format_vorbiscomment_entry_name_is_legal(field_name)) 1331 return false; 1332 if (!FLAC__format_vorbiscomment_entry_value_is_legal((const FLAC__byte *)field_value, (unsigned)(-1))) 1333 return false; 1334 1335 { 1336 const size_t nn = strlen(field_name); 1337 const size_t nv = strlen(field_value); 1338 entry->length = nn + 1 /*=*/ + nv; 1339 if ((entry->entry = safe_malloc_add_4op_(nn, /*+*/1, /*+*/nv, /*+*/1)) == NULL) 1340 return false; 1341 memcpy(entry->entry, field_name, nn); 1342 entry->entry[nn] = '='; 1343 memcpy(entry->entry+nn+1, field_value, nv); 1344 entry->entry[entry->length] = '\0'; 1345 } 1346 1347 return true; 1348} 1349 1350FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value) 1351{ 1352 FLAC__ASSERT(entry.entry != NULL && entry.length > 0); 1353 FLAC__ASSERT(field_name != NULL); 1354 FLAC__ASSERT(field_value != NULL); 1355 1356 if (!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length)) 1357 return false; 1358 1359 { 1360 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length); 1361 const size_t nn = eq-entry.entry; 1362 const size_t nv = entry.length-nn-1; /* -1 for the '=' */ 1363 1364 if (eq == NULL) 1365 return false; /* double protection */ 1366 if ((*field_name = safe_malloc_add_2op_(nn, /*+*/1)) == NULL) 1367 return false; 1368 if ((*field_value = safe_malloc_add_2op_(nv, /*+*/1)) == NULL) { 1369 free(*field_name); 1370 return false; 1371 } 1372 memcpy(*field_name, entry.entry, nn); 1373 memcpy(*field_value, entry.entry+nn+1, nv); 1374 (*field_name)[nn] = '\0'; 1375 (*field_value)[nv] = '\0'; 1376 } 1377 1378 return true; 1379} 1380 1381FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length) 1382{ 1383 FLAC__ASSERT(entry.entry != NULL && entry.length > 0); 1384 { 1385 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length); 1386 return (eq != NULL && (unsigned)(eq-entry.entry) == field_name_length && FLAC__STRNCASECMP(field_name, (const char *)entry.entry, field_name_length) == 0); 1387 } 1388} 1389 1390FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name) 1391{ 1392 FLAC__ASSERT(field_name != NULL); 1393 1394 return vorbiscomment_find_entry_from_(object, offset, field_name, strlen(field_name)); 1395} 1396 1397FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name) 1398{ 1399 const unsigned field_name_length = strlen(field_name); 1400 unsigned i; 1401 1402 FLAC__ASSERT(object != NULL); 1403 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1404 1405 for (i = 0; i < object->data.vorbis_comment.num_comments; i++) { 1406 if (FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) { 1407 if (!FLAC__metadata_object_vorbiscomment_delete_comment(object, i)) 1408 return -1; 1409 else 1410 return 1; 1411 } 1412 } 1413 1414 return 0; 1415} 1416 1417FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name) 1418{ 1419 FLAC__bool ok = true; 1420 unsigned matching = 0; 1421 const unsigned field_name_length = strlen(field_name); 1422 int i; 1423 1424 FLAC__ASSERT(object != NULL); 1425 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT); 1426 1427 /* must delete from end to start otherwise it will interfere with our iteration */ 1428 for (i = (int)object->data.vorbis_comment.num_comments - 1; ok && i >= 0; i--) { 1429 if (FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) { 1430 matching++; 1431 ok &= FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i); 1432 } 1433 } 1434 1435 return ok? (int)matching : -1; 1436} 1437 1438FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void) 1439{ 1440 return calloc(1, sizeof(FLAC__StreamMetadata_CueSheet_Track)); 1441} 1442 1443FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object) 1444{ 1445 FLAC__StreamMetadata_CueSheet_Track *to; 1446 1447 FLAC__ASSERT(object != NULL); 1448 1449 if ((to = FLAC__metadata_object_cuesheet_track_new()) != NULL) { 1450 if (!copy_track_(to, object)) { 1451 FLAC__metadata_object_cuesheet_track_delete(to); 1452 return 0; 1453 } 1454 } 1455 1456 return to; 1457} 1458 1459void FLAC__metadata_object_cuesheet_track_delete_data(FLAC__StreamMetadata_CueSheet_Track *object) 1460{ 1461 FLAC__ASSERT(object != NULL); 1462 1463 if (object->indices != NULL) { 1464 FLAC__ASSERT(object->num_indices > 0); 1465 free(object->indices); 1466 } 1467} 1468 1469FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object) 1470{ 1471 FLAC__metadata_object_cuesheet_track_delete_data(object); 1472 free(object); 1473} 1474 1475FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices) 1476{ 1477 FLAC__StreamMetadata_CueSheet_Track *track; 1478 FLAC__ASSERT(object != NULL); 1479 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1480 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks); 1481 1482 track = &object->data.cue_sheet.tracks[track_num]; 1483 1484 if (track->indices == NULL) { 1485 FLAC__ASSERT(track->num_indices == 0); 1486 if (new_num_indices == 0) 1487 return true; 1488 else if ((track->indices = cuesheet_track_index_array_new_(new_num_indices)) == NULL) 1489 return false; 1490 } 1491 else { 1492 const size_t old_size = track->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index); 1493 const size_t new_size = new_num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index); 1494 1495 /* overflow check */ 1496 if (new_num_indices > UINT32_MAX / sizeof(FLAC__StreamMetadata_CueSheet_Index)) 1497 return false; 1498 1499 FLAC__ASSERT(track->num_indices > 0); 1500 1501 if (new_size == 0) { 1502 free(track->indices); 1503 track->indices = 0; 1504 } 1505 else if ((track->indices = safe_realloc_(track->indices, new_size)) == NULL) 1506 return false; 1507 1508 /* if growing, zero all the lengths/pointers of new elements */ 1509 if (new_size > old_size) 1510 memset(track->indices + track->num_indices, 0, new_size - old_size); 1511 } 1512 1513 track->num_indices = new_num_indices; 1514 1515 cuesheet_calculate_length_(object); 1516 return true; 1517} 1518 1519FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index indx) 1520{ 1521 FLAC__StreamMetadata_CueSheet_Track *track; 1522 1523 FLAC__ASSERT(object != NULL); 1524 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1525 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks); 1526 FLAC__ASSERT(index_num <= object->data.cue_sheet.tracks[track_num].num_indices); 1527 1528 track = &object->data.cue_sheet.tracks[track_num]; 1529 1530 if (!FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices+1)) 1531 return false; 1532 1533 /* move all indices >= index_num forward one space */ 1534 memmove(&track->indices[index_num+1], &track->indices[index_num], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-1-index_num)); 1535 1536 track->indices[index_num] = indx; 1537 cuesheet_calculate_length_(object); 1538 return true; 1539} 1540 1541FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num) 1542{ 1543 FLAC__StreamMetadata_CueSheet_Index indx; 1544 memset(&indx, 0, sizeof(indx)); 1545 return FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, indx); 1546} 1547 1548FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num) 1549{ 1550 FLAC__StreamMetadata_CueSheet_Track *track; 1551 1552 FLAC__ASSERT(object != NULL); 1553 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1554 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks); 1555 FLAC__ASSERT(index_num < object->data.cue_sheet.tracks[track_num].num_indices); 1556 1557 track = &object->data.cue_sheet.tracks[track_num]; 1558 1559 /* move all indices > index_num backward one space */ 1560 memmove(&track->indices[index_num], &track->indices[index_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-index_num-1)); 1561 1562 FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices-1); 1563 cuesheet_calculate_length_(object); 1564 return true; 1565} 1566 1567FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks) 1568{ 1569 FLAC__ASSERT(object != NULL); 1570 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1571 1572 if (object->data.cue_sheet.tracks == NULL) { 1573 FLAC__ASSERT(object->data.cue_sheet.num_tracks == 0); 1574 if (new_num_tracks == 0) 1575 return true; 1576 else if ((object->data.cue_sheet.tracks = cuesheet_track_array_new_(new_num_tracks)) == NULL) 1577 return false; 1578 } 1579 else { 1580 const size_t old_size = object->data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track); 1581 const size_t new_size = new_num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track); 1582 1583 /* overflow check */ 1584 if (new_num_tracks > UINT32_MAX / sizeof(FLAC__StreamMetadata_CueSheet_Track)) 1585 return false; 1586 1587 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0); 1588 1589 /* if shrinking, free the truncated entries */ 1590 if (new_num_tracks < object->data.cue_sheet.num_tracks) { 1591 unsigned i; 1592 for (i = new_num_tracks; i < object->data.cue_sheet.num_tracks; i++) 1593 free(object->data.cue_sheet.tracks[i].indices); 1594 } 1595 1596 if (new_size == 0) { 1597 free(object->data.cue_sheet.tracks); 1598 object->data.cue_sheet.tracks = 0; 1599 } 1600 else if ((object->data.cue_sheet.tracks = safe_realloc_(object->data.cue_sheet.tracks, new_size)) == NULL) 1601 return false; 1602 1603 /* if growing, zero all the lengths/pointers of new elements */ 1604 if (new_size > old_size) 1605 memset(object->data.cue_sheet.tracks + object->data.cue_sheet.num_tracks, 0, new_size - old_size); 1606 } 1607 1608 object->data.cue_sheet.num_tracks = new_num_tracks; 1609 1610 cuesheet_calculate_length_(object); 1611 return true; 1612} 1613 1614FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy) 1615{ 1616 FLAC__ASSERT(object != NULL); 1617 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks); 1618 1619 return cuesheet_set_track_(object, object->data.cue_sheet.tracks + track_num, track, copy); 1620} 1621 1622FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy) 1623{ 1624 FLAC__StreamMetadata_CueSheet *cs; 1625 1626 FLAC__ASSERT(object != NULL); 1627 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1628 FLAC__ASSERT(track_num <= object->data.cue_sheet.num_tracks); 1629 1630 cs = &object->data.cue_sheet; 1631 1632 if (!FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks+1)) 1633 return false; 1634 1635 /* move all tracks >= track_num forward one space */ 1636 memmove(&cs->tracks[track_num+1], &cs->tracks[track_num], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-1-track_num)); 1637 cs->tracks[track_num].num_indices = 0; 1638 cs->tracks[track_num].indices = 0; 1639 1640 return FLAC__metadata_object_cuesheet_set_track(object, track_num, track, copy); 1641} 1642 1643FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num) 1644{ 1645 FLAC__StreamMetadata_CueSheet_Track track; 1646 memset(&track, 0, sizeof(track)); 1647 return FLAC__metadata_object_cuesheet_insert_track(object, track_num, &track, /*copy=*/false); 1648} 1649 1650FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num) 1651{ 1652 FLAC__StreamMetadata_CueSheet *cs; 1653 1654 FLAC__ASSERT(object != NULL); 1655 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1656 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks); 1657 1658 cs = &object->data.cue_sheet; 1659 1660 /* free the track at track_num */ 1661 free(cs->tracks[track_num].indices); 1662 1663 /* move all tracks > track_num backward one space */ 1664 memmove(&cs->tracks[track_num], &cs->tracks[track_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-track_num-1)); 1665 cs->tracks[cs->num_tracks-1].num_indices = 0; 1666 cs->tracks[cs->num_tracks-1].indices = 0; 1667 1668 return FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks-1); 1669} 1670 1671FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation) 1672{ 1673 FLAC__ASSERT(object != NULL); 1674 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1675 1676 return FLAC__format_cuesheet_is_legal(&object->data.cue_sheet, check_cd_da_subset, violation); 1677} 1678 1679static FLAC__uint64 get_index_01_offset_(const FLAC__StreamMetadata_CueSheet *cs, unsigned track) 1680{ 1681 if (track >= (cs->num_tracks-1) || cs->tracks[track].num_indices < 1) 1682 return 0; 1683 else if (cs->tracks[track].indices[0].number == 1) 1684 return cs->tracks[track].indices[0].offset + cs->tracks[track].offset + cs->lead_in; 1685 else if (cs->tracks[track].num_indices < 2) 1686 return 0; 1687 else if (cs->tracks[track].indices[1].number == 1) 1688 return cs->tracks[track].indices[1].offset + cs->tracks[track].offset + cs->lead_in; 1689 else 1690 return 0; 1691} 1692 1693static FLAC__uint32 cddb_add_digits_(FLAC__uint32 x) 1694{ 1695 FLAC__uint32 n = 0; 1696 while (x) { 1697 n += (x%10); 1698 x /= 10; 1699 } 1700 return n; 1701} 1702 1703/*@@@@add to tests*/ 1704FLAC_API FLAC__uint32 FLAC__metadata_object_cuesheet_calculate_cddb_id(const FLAC__StreamMetadata *object) 1705{ 1706 const FLAC__StreamMetadata_CueSheet *cs; 1707 1708 FLAC__ASSERT(object != NULL); 1709 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET); 1710 1711 cs = &object->data.cue_sheet; 1712 1713 if (cs->num_tracks < 2) /* need at least one real track and the lead-out track */ 1714 return 0; 1715 1716 { 1717 FLAC__uint32 i, length, sum = 0; 1718 for (i = 0; i < (cs->num_tracks-1); i++) /* -1 to avoid counting the lead-out */ 1719 sum += cddb_add_digits_((FLAC__uint32)(get_index_01_offset_(cs, i) / 44100)); 1720 length = (FLAC__uint32)((cs->tracks[cs->num_tracks-1].offset+cs->lead_in) / 44100) - (FLAC__uint32)(get_index_01_offset_(cs, 0) / 44100); 1721 1722 return (sum % 0xFF) << 24 | length << 8 | (FLAC__uint32)(cs->num_tracks-1); 1723 } 1724} 1725 1726FLAC_API FLAC__bool FLAC__metadata_object_picture_set_mime_type(FLAC__StreamMetadata *object, char *mime_type, FLAC__bool copy) 1727{ 1728 char *old; 1729 size_t old_length, new_length; 1730 1731 FLAC__ASSERT(object != NULL); 1732 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE); 1733 FLAC__ASSERT(mime_type != NULL); 1734 1735 old = object->data.picture.mime_type; 1736 old_length = old? strlen(old) : 0; 1737 new_length = strlen(mime_type); 1738 1739 /* do the copy first so that if we fail we leave the object untouched */ 1740 if (copy) { 1741 if (new_length >= SIZE_MAX) /* overflow check */ 1742 return false; 1743 if (!copy_bytes_((FLAC__byte**)(&object->data.picture.mime_type), (FLAC__byte*)mime_type, new_length+1)) 1744 return false; 1745 } 1746 else { 1747 object->data.picture.mime_type = mime_type; 1748 } 1749 1750 free(old); 1751 1752 object->length -= old_length; 1753 object->length += new_length; 1754 return true; 1755} 1756 1757FLAC_API FLAC__bool FLAC__metadata_object_picture_set_description(FLAC__StreamMetadata *object, FLAC__byte *description, FLAC__bool copy) 1758{ 1759 FLAC__byte *old; 1760 size_t old_length, new_length; 1761 1762 FLAC__ASSERT(object != NULL); 1763 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE); 1764 FLAC__ASSERT(description != NULL); 1765 1766 old = object->data.picture.description; 1767 old_length = old? strlen((const char *)old) : 0; 1768 new_length = strlen((const char *)description); 1769 1770 /* do the copy first so that if we fail we leave the object untouched */ 1771 if (copy) { 1772 if (new_length >= SIZE_MAX) /* overflow check */ 1773 return false; 1774 if (!copy_bytes_(&object->data.picture.description, description, new_length+1)) 1775 return false; 1776 } 1777 else { 1778 object->data.picture.description = description; 1779 } 1780 1781 free(old); 1782 1783 object->length -= old_length; 1784 object->length += new_length; 1785 return true; 1786} 1787 1788FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, FLAC__uint32 length, FLAC__bool copy) 1789{ 1790 FLAC__byte *old; 1791 1792 FLAC__ASSERT(object != NULL); 1793 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE); 1794 FLAC__ASSERT((data != NULL && length > 0) || (data == NULL && length == 0 && copy == false)); 1795 1796 old = object->data.picture.data; 1797 1798 /* do the copy first so that if we fail we leave the object untouched */ 1799 if (copy) { 1800 if (!copy_bytes_(&object->data.picture.data, data, length)) 1801 return false; 1802 } 1803 else { 1804 object->data.picture.data = data; 1805 } 1806 1807 free(old); 1808 1809 object->length -= object->data.picture.data_length; 1810 object->data.picture.data_length = length; 1811 object->length += length; 1812 return true; 1813} 1814 1815FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation) 1816{ 1817 FLAC__ASSERT(object != NULL); 1818 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE); 1819 1820 return FLAC__format_picture_is_legal(&object->data.picture, violation); 1821} 1822