1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2001,2002,2003,2004,2005,2006,2007 Josh Coalson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
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.
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.
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.
39 #include "private/metadata.h"
41 #include "FLAC/assert.h"
44 /****************************************************************************
48 ***************************************************************************/
51 * from = NULL && bytes = 0
53 * from != NULL && bytes > 0
56 * malloc error leaved 'to' unchanged
58 static FLAC__bool copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes)
60 FLAC__ASSERT(0 != to);
61 if(bytes > 0 && 0 != from) {
63 if(0 == (x = (FLAC__byte*)malloc(bytes)))
65 memcpy(x, from, bytes);
69 FLAC__ASSERT(0 == from);
70 FLAC__ASSERT(bytes == 0);
77 /* like copy_bytes_(), but free()s the original '*to' if the copy succeeds and the original '*to' is non-NULL */
78 static FLAC__bool free_copy_bytes_(FLAC__byte **to, const FLAC__byte *from, unsigned bytes)
81 FLAC__ASSERT(0 != to);
82 if(copy_bytes_(©, from, bytes)) {
93 /* reallocate entry to 1 byte larger and add a terminating NUL */
94 /* realloc() failure leaves entry unchanged */
95 static FLAC__bool ensure_null_terminated_(FLAC__byte **entry, unsigned length)
97 FLAC__byte *x = (FLAC__byte*)realloc(*entry, length+1);
107 /* copies the NUL-terminated C-string 'from' to '*to', leaving '*to'
108 * unchanged if malloc fails, free()ing the original '*to' if it
109 * succeeds and the original '*to' was not NULL
111 static FLAC__bool copy_cstring_(char **to, const char *from)
113 char *copy = strdup(from);
125 static FLAC__bool copy_vcentry_(FLAC__StreamMetadata_VorbisComment_Entry *to, const FLAC__StreamMetadata_VorbisComment_Entry *from)
127 to->length = from->length;
128 if(0 == from->entry) {
129 FLAC__ASSERT(from->length == 0);
134 FLAC__ASSERT(from->length > 0);
135 if(0 == (x = (FLAC__byte*)malloc(from->length+1)))
137 memcpy(x, from->entry, from->length);
138 x[from->length] = '\0';
144 static FLAC__bool copy_track_(FLAC__StreamMetadata_CueSheet_Track *to, const FLAC__StreamMetadata_CueSheet_Track *from)
146 memcpy(to, from, sizeof(FLAC__StreamMetadata_CueSheet_Track));
147 if(0 == from->indices) {
148 FLAC__ASSERT(from->num_indices == 0);
151 FLAC__StreamMetadata_CueSheet_Index *x;
152 FLAC__ASSERT(from->num_indices > 0);
153 if(0 == (x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index))))
155 memcpy(x, from->indices, from->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
161 static void seektable_calculate_length_(FLAC__StreamMetadata *object)
163 FLAC__ASSERT(0 != object);
164 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
166 object->length = object->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
169 static FLAC__StreamMetadata_SeekPoint *seekpoint_array_new_(unsigned num_points)
171 FLAC__StreamMetadata_SeekPoint *object_array;
173 FLAC__ASSERT(num_points > 0);
175 object_array = (FLAC__StreamMetadata_SeekPoint*)malloc(num_points * sizeof(FLAC__StreamMetadata_SeekPoint));
177 if(0 != object_array) {
179 for(i = 0; i < num_points; i++) {
180 object_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
181 object_array[i].stream_offset = 0;
182 object_array[i].frame_samples = 0;
189 static void vorbiscomment_calculate_length_(FLAC__StreamMetadata *object)
193 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
195 object->length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN) / 8;
196 object->length += object->data.vorbis_comment.vendor_string.length;
197 object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN) / 8;
198 for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
199 object->length += (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8);
200 object->length += object->data.vorbis_comment.comments[i].length;
204 static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_new_(unsigned num_comments)
206 FLAC__ASSERT(num_comments > 0);
208 return (FLAC__StreamMetadata_VorbisComment_Entry*)calloc(num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
211 static void vorbiscomment_entry_array_delete_(FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
215 FLAC__ASSERT(0 != object_array && num_comments > 0);
217 for(i = 0; i < num_comments; i++)
218 if(0 != object_array[i].entry)
219 free(object_array[i].entry);
221 if(0 != object_array)
225 static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_copy_(const FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
227 FLAC__StreamMetadata_VorbisComment_Entry *return_array;
229 FLAC__ASSERT(0 != object_array);
230 FLAC__ASSERT(num_comments > 0);
232 return_array = vorbiscomment_entry_array_new_(num_comments);
234 if(0 != return_array) {
237 for(i = 0; i < num_comments; i++) {
238 if(!copy_vcentry_(return_array+i, object_array+i)) {
239 vorbiscomment_entry_array_delete_(return_array, num_comments);
248 static FLAC__bool vorbiscomment_set_entry_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry *dest, const FLAC__StreamMetadata_VorbisComment_Entry *src, FLAC__bool copy)
252 FLAC__ASSERT(0 != object);
253 FLAC__ASSERT(0 != dest);
254 FLAC__ASSERT(0 != src);
255 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
256 FLAC__ASSERT((0 != src->entry && src->length > 0) || (0 == src->entry && src->length == 0));
260 if(0 != src->entry && src->length > 0) {
262 /* do the copy first so that if we fail we leave the dest object untouched */
263 if(!copy_vcentry_(dest, src))
267 /* we have to make sure that the string we're taking over is null-terminated */
270 * Stripping the const from src->entry is OK since we're taking
271 * ownership of the pointer. This is a hack around a deficiency
272 * in the API where the same function is used for 'copy' and
273 * 'own', but the source entry is a const pointer. If we were
274 * precise, the 'own' flavor would be a separate function with a
275 * non-const source pointer. But it's not, so we hack away.
277 if(!ensure_null_terminated_((FLAC__byte**)(&src->entry), src->length))
283 /* the src is null */
290 vorbiscomment_calculate_length_(object);
294 static int vorbiscomment_find_entry_from_(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name, unsigned field_name_length)
298 FLAC__ASSERT(0 != object);
299 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
300 FLAC__ASSERT(0 != field_name);
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))
310 static void cuesheet_calculate_length_(FLAC__StreamMetadata *object)
314 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
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
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
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
343 static FLAC__StreamMetadata_CueSheet_Index *cuesheet_track_index_array_new_(unsigned num_indices)
345 FLAC__ASSERT(num_indices > 0);
347 return (FLAC__StreamMetadata_CueSheet_Index*)calloc(num_indices, sizeof(FLAC__StreamMetadata_CueSheet_Index));
350 static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_new_(unsigned num_tracks)
352 FLAC__ASSERT(num_tracks > 0);
354 return (FLAC__StreamMetadata_CueSheet_Track*)calloc(num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track));
357 static void cuesheet_track_array_delete_(FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
361 FLAC__ASSERT(0 != object_array && num_tracks > 0);
363 for(i = 0; i < num_tracks; i++) {
364 if(0 != object_array[i].indices) {
365 FLAC__ASSERT(object_array[i].num_indices > 0);
366 free(object_array[i].indices);
370 if(0 != object_array)
374 static FLAC__StreamMetadata_CueSheet_Track *cuesheet_track_array_copy_(const FLAC__StreamMetadata_CueSheet_Track *object_array, unsigned num_tracks)
376 FLAC__StreamMetadata_CueSheet_Track *return_array;
378 FLAC__ASSERT(0 != object_array);
379 FLAC__ASSERT(num_tracks > 0);
381 return_array = cuesheet_track_array_new_(num_tracks);
383 if(0 != return_array) {
386 for(i = 0; i < num_tracks; i++) {
387 if(!copy_track_(return_array+i, object_array+i)) {
388 cuesheet_track_array_delete_(return_array, num_tracks);
397 static FLAC__bool cuesheet_set_track_(FLAC__StreamMetadata *object, FLAC__StreamMetadata_CueSheet_Track *dest, const FLAC__StreamMetadata_CueSheet_Track *src, FLAC__bool copy)
399 FLAC__StreamMetadata_CueSheet_Index *save;
401 FLAC__ASSERT(0 != object);
402 FLAC__ASSERT(0 != dest);
403 FLAC__ASSERT(0 != src);
404 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
405 FLAC__ASSERT((0 != src->indices && src->num_indices > 0) || (0 == src->indices && src->num_indices == 0));
407 save = dest->indices;
409 /* do the copy first so that if we fail we leave the object untouched */
411 if(!copy_track_(dest, src))
421 cuesheet_calculate_length_(object);
426 /****************************************************************************
428 * Metadata object routines
430 ***************************************************************************/
432 FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type)
434 FLAC__StreamMetadata *object;
436 if(type > FLAC__MAX_METADATA_TYPE_CODE)
439 object = (FLAC__StreamMetadata*)calloc(1, sizeof(FLAC__StreamMetadata));
441 object->is_last = false;
444 case FLAC__METADATA_TYPE_STREAMINFO:
445 object->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
447 case FLAC__METADATA_TYPE_PADDING:
448 /* calloc() took care of this for us:
452 case FLAC__METADATA_TYPE_APPLICATION:
453 object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
454 /* calloc() took care of this for us:
455 object->data.application.data = 0;
458 case FLAC__METADATA_TYPE_SEEKTABLE:
459 /* calloc() took care of this for us:
461 object->data.seek_table.num_points = 0;
462 object->data.seek_table.points = 0;
465 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
466 object->data.vorbis_comment.vendor_string.length = (unsigned)strlen(FLAC__VENDOR_STRING);
467 if(!copy_bytes_(&object->data.vorbis_comment.vendor_string.entry, (const FLAC__byte*)FLAC__VENDOR_STRING, object->data.vorbis_comment.vendor_string.length+1)) {
471 vorbiscomment_calculate_length_(object);
473 case FLAC__METADATA_TYPE_CUESHEET:
474 cuesheet_calculate_length_(object);
476 case FLAC__METADATA_TYPE_PICTURE:
478 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
479 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* empty mime_type string */
480 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* empty description string */
481 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
482 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
483 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
484 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
485 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN +
488 object->data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER;
489 object->data.picture.mime_type = 0;
490 object->data.picture.description = 0;
491 /* calloc() took care of this for us:
492 object->data.picture.width = 0;
493 object->data.picture.height = 0;
494 object->data.picture.depth = 0;
495 object->data.picture.colors = 0;
496 object->data.picture.data_length = 0;
497 object->data.picture.data = 0;
499 /* now initialize mime_type and description with empty strings to make things easier on the client */
500 if(!copy_cstring_(&object->data.picture.mime_type, "")) {
504 if(!copy_cstring_((char**)(&object->data.picture.description), "")) {
505 if(object->data.picture.mime_type)
506 free(object->data.picture.mime_type);
512 /* calloc() took care of this for us:
514 object->data.unknown.data = 0;
523 FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_clone(const FLAC__StreamMetadata *object)
525 FLAC__StreamMetadata *to;
527 FLAC__ASSERT(0 != object);
529 if(0 != (to = FLAC__metadata_object_new(object->type))) {
530 to->is_last = object->is_last;
531 to->type = object->type;
532 to->length = object->length;
534 case FLAC__METADATA_TYPE_STREAMINFO:
535 memcpy(&to->data.stream_info, &object->data.stream_info, sizeof(FLAC__StreamMetadata_StreamInfo));
537 case FLAC__METADATA_TYPE_PADDING:
539 case FLAC__METADATA_TYPE_APPLICATION:
540 memcpy(&to->data.application.id, &object->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8);
541 if(!copy_bytes_(&to->data.application.data, object->data.application.data, object->length - FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) {
542 FLAC__metadata_object_delete(to);
546 case FLAC__METADATA_TYPE_SEEKTABLE:
547 to->data.seek_table.num_points = object->data.seek_table.num_points;
548 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))) {
549 FLAC__metadata_object_delete(to);
553 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
554 if(0 != to->data.vorbis_comment.vendor_string.entry) {
555 free(to->data.vorbis_comment.vendor_string.entry);
556 to->data.vorbis_comment.vendor_string.entry = 0;
558 if(!copy_vcentry_(&to->data.vorbis_comment.vendor_string, &object->data.vorbis_comment.vendor_string)) {
559 FLAC__metadata_object_delete(to);
562 if(object->data.vorbis_comment.num_comments == 0) {
563 FLAC__ASSERT(0 == object->data.vorbis_comment.comments);
564 to->data.vorbis_comment.comments = 0;
567 FLAC__ASSERT(0 != object->data.vorbis_comment.comments);
568 to->data.vorbis_comment.comments = vorbiscomment_entry_array_copy_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
569 if(0 == to->data.vorbis_comment.comments) {
570 FLAC__metadata_object_delete(to);
574 to->data.vorbis_comment.num_comments = object->data.vorbis_comment.num_comments;
576 case FLAC__METADATA_TYPE_CUESHEET:
577 memcpy(&to->data.cue_sheet, &object->data.cue_sheet, sizeof(FLAC__StreamMetadata_CueSheet));
578 if(object->data.cue_sheet.num_tracks == 0) {
579 FLAC__ASSERT(0 == object->data.cue_sheet.tracks);
582 FLAC__ASSERT(0 != object->data.cue_sheet.tracks);
583 to->data.cue_sheet.tracks = cuesheet_track_array_copy_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
584 if(0 == to->data.cue_sheet.tracks) {
585 FLAC__metadata_object_delete(to);
590 case FLAC__METADATA_TYPE_PICTURE:
591 to->data.picture.type = object->data.picture.type;
592 if(!copy_cstring_(&to->data.picture.mime_type, object->data.picture.mime_type)) {
593 FLAC__metadata_object_delete(to);
596 if(!copy_cstring_((char**)(&to->data.picture.description), (const char*)object->data.picture.description)) {
597 FLAC__metadata_object_delete(to);
600 to->data.picture.width = object->data.picture.width;
601 to->data.picture.height = object->data.picture.height;
602 to->data.picture.depth = object->data.picture.depth;
603 to->data.picture.colors = object->data.picture.colors;
604 to->data.picture.data_length = object->data.picture.data_length;
605 if(!copy_bytes_((&to->data.picture.data), object->data.picture.data, object->data.picture.data_length)) {
606 FLAC__metadata_object_delete(to);
611 if(!copy_bytes_(&to->data.unknown.data, object->data.unknown.data, object->length)) {
612 FLAC__metadata_object_delete(to);
622 void FLAC__metadata_object_delete_data(FLAC__StreamMetadata *object)
624 FLAC__ASSERT(0 != object);
626 switch(object->type) {
627 case FLAC__METADATA_TYPE_STREAMINFO:
628 case FLAC__METADATA_TYPE_PADDING:
630 case FLAC__METADATA_TYPE_APPLICATION:
631 if(0 != object->data.application.data) {
632 free(object->data.application.data);
633 object->data.application.data = 0;
636 case FLAC__METADATA_TYPE_SEEKTABLE:
637 if(0 != object->data.seek_table.points) {
638 free(object->data.seek_table.points);
639 object->data.seek_table.points = 0;
642 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
643 if(0 != object->data.vorbis_comment.vendor_string.entry) {
644 free(object->data.vorbis_comment.vendor_string.entry);
645 object->data.vorbis_comment.vendor_string.entry = 0;
647 if(0 != object->data.vorbis_comment.comments) {
648 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
649 vorbiscomment_entry_array_delete_(object->data.vorbis_comment.comments, object->data.vorbis_comment.num_comments);
652 case FLAC__METADATA_TYPE_CUESHEET:
653 if(0 != object->data.cue_sheet.tracks) {
654 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
655 cuesheet_track_array_delete_(object->data.cue_sheet.tracks, object->data.cue_sheet.num_tracks);
658 case FLAC__METADATA_TYPE_PICTURE:
659 if(0 != object->data.picture.mime_type) {
660 free(object->data.picture.mime_type);
661 object->data.picture.mime_type = 0;
663 if(0 != object->data.picture.description) {
664 free(object->data.picture.description);
665 object->data.picture.description = 0;
667 if(0 != object->data.picture.data) {
668 free(object->data.picture.data);
669 object->data.picture.data = 0;
673 if(0 != object->data.unknown.data) {
674 free(object->data.unknown.data);
675 object->data.unknown.data = 0;
681 FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object)
683 FLAC__metadata_object_delete_data(object);
687 static FLAC__bool compare_block_data_streaminfo_(const FLAC__StreamMetadata_StreamInfo *block1, const FLAC__StreamMetadata_StreamInfo *block2)
689 if(block1->min_blocksize != block2->min_blocksize)
691 if(block1->max_blocksize != block2->max_blocksize)
693 if(block1->min_framesize != block2->min_framesize)
695 if(block1->max_framesize != block2->max_framesize)
697 if(block1->sample_rate != block2->sample_rate)
699 if(block1->channels != block2->channels)
701 if(block1->bits_per_sample != block2->bits_per_sample)
703 if(block1->total_samples != block2->total_samples)
705 if(0 != memcmp(block1->md5sum, block2->md5sum, 16))
710 static FLAC__bool compare_block_data_application_(const FLAC__StreamMetadata_Application *block1, const FLAC__StreamMetadata_Application *block2, unsigned block_length)
712 FLAC__ASSERT(0 != block1);
713 FLAC__ASSERT(0 != block2);
714 FLAC__ASSERT(block_length >= sizeof(block1->id));
716 if(0 != memcmp(block1->id, block2->id, sizeof(block1->id)))
718 if(0 != block1->data && 0 != block2->data)
719 return 0 == memcmp(block1->data, block2->data, block_length - sizeof(block1->id));
721 return block1->data == block2->data;
724 static FLAC__bool compare_block_data_seektable_(const FLAC__StreamMetadata_SeekTable *block1, const FLAC__StreamMetadata_SeekTable *block2)
728 FLAC__ASSERT(0 != block1);
729 FLAC__ASSERT(0 != block2);
731 if(block1->num_points != block2->num_points)
734 if(0 != block1->points && 0 != block2->points) {
735 for(i = 0; i < block1->num_points; i++) {
736 if(block1->points[i].sample_number != block2->points[i].sample_number)
738 if(block1->points[i].stream_offset != block2->points[i].stream_offset)
740 if(block1->points[i].frame_samples != block2->points[i].frame_samples)
746 return block1->points == block2->points;
749 static FLAC__bool compare_block_data_vorbiscomment_(const FLAC__StreamMetadata_VorbisComment *block1, const FLAC__StreamMetadata_VorbisComment *block2)
753 if(block1->vendor_string.length != block2->vendor_string.length)
756 if(0 != block1->vendor_string.entry && 0 != block2->vendor_string.entry) {
757 if(0 != memcmp(block1->vendor_string.entry, block2->vendor_string.entry, block1->vendor_string.length))
760 else if(block1->vendor_string.entry != block2->vendor_string.entry)
763 if(block1->num_comments != block2->num_comments)
766 for(i = 0; i < block1->num_comments; i++) {
767 if(0 != block1->comments[i].entry && 0 != block2->comments[i].entry) {
768 if(0 != memcmp(block1->comments[i].entry, block2->comments[i].entry, block1->comments[i].length))
771 else if(block1->comments[i].entry != block2->comments[i].entry)
777 static FLAC__bool compare_block_data_cuesheet_(const FLAC__StreamMetadata_CueSheet *block1, const FLAC__StreamMetadata_CueSheet *block2)
781 if(0 != strcmp(block1->media_catalog_number, block2->media_catalog_number))
784 if(block1->lead_in != block2->lead_in)
787 if(block1->is_cd != block2->is_cd)
790 if(block1->num_tracks != block2->num_tracks)
793 if(0 != block1->tracks && 0 != block2->tracks) {
794 FLAC__ASSERT(block1->num_tracks > 0);
795 for(i = 0; i < block1->num_tracks; i++) {
796 if(block1->tracks[i].offset != block2->tracks[i].offset)
798 if(block1->tracks[i].number != block2->tracks[i].number)
800 if(0 != memcmp(block1->tracks[i].isrc, block2->tracks[i].isrc, sizeof(block1->tracks[i].isrc)))
802 if(block1->tracks[i].type != block2->tracks[i].type)
804 if(block1->tracks[i].pre_emphasis != block2->tracks[i].pre_emphasis)
806 if(block1->tracks[i].num_indices != block2->tracks[i].num_indices)
808 if(0 != block1->tracks[i].indices && 0 != block2->tracks[i].indices) {
809 FLAC__ASSERT(block1->tracks[i].num_indices > 0);
810 for(j = 0; j < block1->tracks[i].num_indices; j++) {
811 if(block1->tracks[i].indices[j].offset != block2->tracks[i].indices[j].offset)
813 if(block1->tracks[i].indices[j].number != block2->tracks[i].indices[j].number)
817 else if(block1->tracks[i].indices != block2->tracks[i].indices)
821 else if(block1->tracks != block2->tracks)
826 static FLAC__bool compare_block_data_picture_(const FLAC__StreamMetadata_Picture *block1, const FLAC__StreamMetadata_Picture *block2)
828 if(block1->type != block2->type)
830 if(block1->mime_type != block2->mime_type && (0 == block1->mime_type || 0 == block2->mime_type || strcmp(block1->mime_type, block2->mime_type)))
832 if(block1->description != block2->description && (0 == block1->description || 0 == block2->description || strcmp((const char *)block1->description, (const char *)block2->description)))
834 if(block1->width != block2->width)
836 if(block1->height != block2->height)
838 if(block1->depth != block2->depth)
840 if(block1->colors != block2->colors)
842 if(block1->data_length != block2->data_length)
844 if(block1->data != block2->data && (0 == block1->data || 0 == block2->data || memcmp(block1->data, block2->data, block1->data_length)))
849 static FLAC__bool compare_block_data_unknown_(const FLAC__StreamMetadata_Unknown *block1, const FLAC__StreamMetadata_Unknown *block2, unsigned block_length)
851 FLAC__ASSERT(0 != block1);
852 FLAC__ASSERT(0 != block2);
854 if(0 != block1->data && 0 != block2->data)
855 return 0 == memcmp(block1->data, block2->data, block_length);
857 return block1->data == block2->data;
860 FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *block1, const FLAC__StreamMetadata *block2)
862 FLAC__ASSERT(0 != block1);
863 FLAC__ASSERT(0 != block2);
865 if(block1->type != block2->type) {
868 if(block1->is_last != block2->is_last) {
871 if(block1->length != block2->length) {
874 switch(block1->type) {
875 case FLAC__METADATA_TYPE_STREAMINFO:
876 return compare_block_data_streaminfo_(&block1->data.stream_info, &block2->data.stream_info);
877 case FLAC__METADATA_TYPE_PADDING:
878 return true; /* we don't compare the padding guts */
879 case FLAC__METADATA_TYPE_APPLICATION:
880 return compare_block_data_application_(&block1->data.application, &block2->data.application, block1->length);
881 case FLAC__METADATA_TYPE_SEEKTABLE:
882 return compare_block_data_seektable_(&block1->data.seek_table, &block2->data.seek_table);
883 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
884 return compare_block_data_vorbiscomment_(&block1->data.vorbis_comment, &block2->data.vorbis_comment);
885 case FLAC__METADATA_TYPE_CUESHEET:
886 return compare_block_data_cuesheet_(&block1->data.cue_sheet, &block2->data.cue_sheet);
887 case FLAC__METADATA_TYPE_PICTURE:
888 return compare_block_data_picture_(&block1->data.picture, &block2->data.picture);
890 return compare_block_data_unknown_(&block1->data.unknown, &block2->data.unknown, block1->length);
894 FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy)
898 FLAC__ASSERT(0 != object);
899 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_APPLICATION);
900 FLAC__ASSERT((0 != data && length > 0) || (0 == data && length == 0 && copy == false));
902 save = object->data.application.data;
904 /* do the copy first so that if we fail we leave the object untouched */
906 if(!copy_bytes_(&object->data.application.data, data, length))
910 object->data.application.data = data;
916 object->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8 + length;
920 FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points)
922 FLAC__ASSERT(0 != object);
923 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
925 if(0 == object->data.seek_table.points) {
926 FLAC__ASSERT(object->data.seek_table.num_points == 0);
927 if(0 == new_num_points)
929 else if(0 == (object->data.seek_table.points = seekpoint_array_new_(new_num_points)))
933 const unsigned old_size = object->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
934 const unsigned new_size = new_num_points * sizeof(FLAC__StreamMetadata_SeekPoint);
936 FLAC__ASSERT(object->data.seek_table.num_points > 0);
939 free(object->data.seek_table.points);
940 object->data.seek_table.points = 0;
942 else if(0 == (object->data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*)realloc(object->data.seek_table.points, new_size)))
945 /* if growing, set new elements to placeholders */
946 if(new_size > old_size) {
948 for(i = object->data.seek_table.num_points; i < new_num_points; i++) {
949 object->data.seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
950 object->data.seek_table.points[i].stream_offset = 0;
951 object->data.seek_table.points[i].frame_samples = 0;
956 object->data.seek_table.num_points = new_num_points;
958 seektable_calculate_length_(object);
962 FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
964 FLAC__ASSERT(0 != object);
965 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
966 FLAC__ASSERT(point_num < object->data.seek_table.num_points);
968 object->data.seek_table.points[point_num] = point;
971 FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point)
975 FLAC__ASSERT(0 != object);
976 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
977 FLAC__ASSERT(point_num <= object->data.seek_table.num_points);
979 if(!FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points+1))
982 /* move all points >= point_num forward one space */
983 for(i = (int)object->data.seek_table.num_points-1; i > (int)point_num; i--)
984 object->data.seek_table.points[i] = object->data.seek_table.points[i-1];
986 FLAC__metadata_object_seektable_set_point(object, point_num, point);
987 seektable_calculate_length_(object);
991 FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num)
995 FLAC__ASSERT(0 != object);
996 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
997 FLAC__ASSERT(point_num < object->data.seek_table.num_points);
999 /* move all points > point_num backward one space */
1000 for(i = point_num; i < object->data.seek_table.num_points-1; i++)
1001 object->data.seek_table.points[i] = object->data.seek_table.points[i+1];
1003 return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points-1);
1006 FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamMetadata *object)
1008 FLAC__ASSERT(0 != object);
1009 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1011 return FLAC__format_seektable_is_legal(&object->data.seek_table);
1014 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num)
1016 FLAC__ASSERT(0 != object);
1017 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1020 /* WATCHOUT: we rely on the fact that growing the array adds PLACEHOLDERS at the end */
1021 return FLAC__metadata_object_seektable_resize_points(object, object->data.seek_table.num_points + num);
1026 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__StreamMetadata *object, FLAC__uint64 sample_number)
1028 FLAC__StreamMetadata_SeekTable *seek_table;
1030 FLAC__ASSERT(0 != object);
1031 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1033 seek_table = &object->data.seek_table;
1035 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + 1))
1038 seek_table->points[seek_table->num_points - 1].sample_number = sample_number;
1039 seek_table->points[seek_table->num_points - 1].stream_offset = 0;
1040 seek_table->points[seek_table->num_points - 1].frame_samples = 0;
1045 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num)
1047 FLAC__ASSERT(0 != object);
1048 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1049 FLAC__ASSERT(0 != sample_numbers || num == 0);
1052 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
1055 i = seek_table->num_points;
1057 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
1060 for(j = 0; j < num; i++, j++) {
1061 seek_table->points[i].sample_number = sample_numbers[j];
1062 seek_table->points[i].stream_offset = 0;
1063 seek_table->points[i].frame_samples = 0;
1070 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples)
1072 FLAC__ASSERT(0 != object);
1073 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1074 FLAC__ASSERT(total_samples > 0);
1076 if(num > 0 && total_samples > 0) {
1077 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
1080 i = seek_table->num_points;
1082 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + num))
1085 for(j = 0; j < num; i++, j++) {
1086 seek_table->points[i].sample_number = total_samples * (FLAC__uint64)j / (FLAC__uint64)num;
1087 seek_table->points[i].stream_offset = 0;
1088 seek_table->points[i].frame_samples = 0;
1095 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, unsigned samples, FLAC__uint64 total_samples)
1097 FLAC__ASSERT(0 != object);
1098 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1099 FLAC__ASSERT(samples > 0);
1100 FLAC__ASSERT(total_samples > 0);
1102 if(samples > 0 && total_samples > 0) {
1103 FLAC__StreamMetadata_SeekTable *seek_table = &object->data.seek_table;
1105 FLAC__uint64 num, sample;
1107 num = 1 + total_samples / samples; /* 1+ for the first sample at 0 */
1108 /* now account for the fact that we don't place a seekpoint at "total_samples" since samples are number from 0: */
1109 if(total_samples % samples == 0)
1112 i = seek_table->num_points;
1114 if(!FLAC__metadata_object_seektable_resize_points(object, seek_table->num_points + (unsigned)num))
1118 for(j = 0; j < num; i++, j++, sample += samples) {
1119 seek_table->points[i].sample_number = sample;
1120 seek_table->points[i].stream_offset = 0;
1121 seek_table->points[i].frame_samples = 0;
1128 FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata *object, FLAC__bool compact)
1132 FLAC__ASSERT(0 != object);
1133 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_SEEKTABLE);
1135 unique = FLAC__format_seektable_sort(&object->data.seek_table);
1137 return !compact || FLAC__metadata_object_seektable_resize_points(object, unique);
1140 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
1142 if(!FLAC__format_vorbiscomment_entry_value_is_legal(entry.entry, entry.length))
1144 return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.vendor_string, &entry, copy);
1147 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments)
1149 FLAC__ASSERT(0 != object);
1150 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1152 if(0 == object->data.vorbis_comment.comments) {
1153 FLAC__ASSERT(object->data.vorbis_comment.num_comments == 0);
1154 if(0 == new_num_comments)
1156 else if(0 == (object->data.vorbis_comment.comments = vorbiscomment_entry_array_new_(new_num_comments)))
1160 const unsigned old_size = object->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
1161 const unsigned new_size = new_num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry);
1163 FLAC__ASSERT(object->data.vorbis_comment.num_comments > 0);
1165 /* if shrinking, free the truncated entries */
1166 if(new_num_comments < object->data.vorbis_comment.num_comments) {
1168 for(i = new_num_comments; i < object->data.vorbis_comment.num_comments; i++)
1169 if(0 != object->data.vorbis_comment.comments[i].entry)
1170 free(object->data.vorbis_comment.comments[i].entry);
1174 free(object->data.vorbis_comment.comments);
1175 object->data.vorbis_comment.comments = 0;
1177 else if(0 == (object->data.vorbis_comment.comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(object->data.vorbis_comment.comments, new_size)))
1180 /* if growing, zero all the length/pointers of new elements */
1181 if(new_size > old_size)
1182 memset(object->data.vorbis_comment.comments + object->data.vorbis_comment.num_comments, 0, new_size - old_size);
1185 object->data.vorbis_comment.num_comments = new_num_comments;
1187 vorbiscomment_calculate_length_(object);
1191 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
1193 FLAC__ASSERT(0 != object);
1194 FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
1196 if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
1198 return vorbiscomment_set_entry_(object, &object->data.vorbis_comment.comments[comment_num], &entry, copy);
1201 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
1203 FLAC__StreamMetadata_VorbisComment *vc;
1205 FLAC__ASSERT(0 != object);
1206 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1207 FLAC__ASSERT(comment_num <= object->data.vorbis_comment.num_comments);
1209 if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
1212 vc = &object->data.vorbis_comment;
1214 if(!FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments+1))
1217 /* move all comments >= comment_num forward one space */
1218 memmove(&vc->comments[comment_num+1], &vc->comments[comment_num], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-1-comment_num));
1219 vc->comments[comment_num].length = 0;
1220 vc->comments[comment_num].entry = 0;
1222 return FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy);
1225 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy)
1227 FLAC__ASSERT(0 != object);
1228 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1229 return FLAC__metadata_object_vorbiscomment_insert_comment(object, object->data.vorbis_comment.num_comments, entry, copy);
1232 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__StreamMetadata *object, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool all, FLAC__bool copy)
1234 FLAC__ASSERT(0 != entry.entry && entry.length > 0);
1236 if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
1241 unsigned field_name_length;
1242 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
1244 FLAC__ASSERT(0 != eq);
1247 return false; /* double protection */
1249 field_name_length = eq-entry.entry;
1251 if((i = vorbiscomment_find_entry_from_(object, 0, (const char *)entry.entry, field_name_length)) >= 0) {
1252 unsigned index = (unsigned)i;
1253 if(!FLAC__metadata_object_vorbiscomment_set_comment(object, index, entry, copy))
1255 if(all && (index+1 < object->data.vorbis_comment.num_comments)) {
1256 for(i = vorbiscomment_find_entry_from_(object, index+1, (const char *)entry.entry, field_name_length); i >= 0; ) {
1257 if(!FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i))
1259 if((unsigned)i < object->data.vorbis_comment.num_comments)
1260 i = vorbiscomment_find_entry_from_(object, (unsigned)i, (const char *)entry.entry, field_name_length);
1268 return FLAC__metadata_object_vorbiscomment_append_comment(object, entry, copy);
1272 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num)
1274 FLAC__StreamMetadata_VorbisComment *vc;
1276 FLAC__ASSERT(0 != object);
1277 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1278 FLAC__ASSERT(comment_num < object->data.vorbis_comment.num_comments);
1280 vc = &object->data.vorbis_comment;
1282 /* free the comment at comment_num */
1283 if(0 != vc->comments[comment_num].entry)
1284 free(vc->comments[comment_num].entry);
1286 /* move all comments > comment_num backward one space */
1287 memmove(&vc->comments[comment_num], &vc->comments[comment_num+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(vc->num_comments-comment_num-1));
1288 vc->comments[vc->num_comments-1].length = 0;
1289 vc->comments[vc->num_comments-1].entry = 0;
1291 return FLAC__metadata_object_vorbiscomment_resize_comments(object, vc->num_comments-1);
1294 FLAC_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)
1296 FLAC__ASSERT(0 != entry);
1297 FLAC__ASSERT(0 != field_name);
1298 FLAC__ASSERT(0 != field_value);
1300 if(!FLAC__format_vorbiscomment_entry_name_is_legal(field_name))
1302 if(!FLAC__format_vorbiscomment_entry_value_is_legal((const FLAC__byte *)field_value, (unsigned)(-1)))
1306 const size_t nn = strlen(field_name);
1307 const size_t nv = strlen(field_value);
1308 entry->length = nn + 1 /*=*/ + nv;
1309 if(0 == (entry->entry = (FLAC__byte*)malloc(entry->length+1)))
1311 memcpy(entry->entry, field_name, nn);
1312 entry->entry[nn] = '=';
1313 memcpy(entry->entry+nn+1, field_value, nv);
1314 entry->entry[entry->length] = '\0';
1320 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(const FLAC__StreamMetadata_VorbisComment_Entry entry, char **field_name, char **field_value)
1322 FLAC__ASSERT(0 != entry.entry && entry.length > 0);
1323 FLAC__ASSERT(0 != field_name);
1324 FLAC__ASSERT(0 != field_value);
1326 if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length))
1330 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
1331 const size_t nn = eq-entry.entry;
1332 const size_t nv = entry.length-nn-1; /* -1 for the '=' */
1333 FLAC__ASSERT(0 != eq);
1335 return false; /* double protection */
1336 if(0 == (*field_name = (char*)malloc(nn+1)))
1338 if(0 == (*field_value = (char*)malloc(nv+1))) {
1342 memcpy(*field_name, entry.entry, nn);
1343 memcpy(*field_value, entry.entry+nn+1, nv);
1344 (*field_name)[nn] = '\0';
1345 (*field_value)[nv] = '\0';
1351 FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length)
1353 FLAC__ASSERT(0 != entry.entry && entry.length > 0);
1355 const FLAC__byte *eq = (FLAC__byte*)memchr(entry.entry, '=', entry.length);
1356 #if defined _MSC_VER || defined __BORLANDC__ || defined __MINGW32__ || defined __EMX__
1357 #define FLAC__STRNCASECMP strnicmp
1359 #define FLAC__STRNCASECMP strncasecmp
1361 return (0 != eq && (unsigned)(eq-entry.entry) == field_name_length && 0 == FLAC__STRNCASECMP(field_name, (const char *)entry.entry, field_name_length));
1362 #undef FLAC__STRNCASECMP
1366 FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name)
1368 FLAC__ASSERT(0 != field_name);
1370 return vorbiscomment_find_entry_from_(object, offset, field_name, strlen(field_name));
1373 FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entry_matching(FLAC__StreamMetadata *object, const char *field_name)
1375 const unsigned field_name_length = strlen(field_name);
1378 FLAC__ASSERT(0 != object);
1379 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1381 for(i = 0; i < object->data.vorbis_comment.num_comments; i++) {
1382 if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) {
1383 if(!FLAC__metadata_object_vorbiscomment_delete_comment(object, i))
1393 FLAC_API int FLAC__metadata_object_vorbiscomment_remove_entries_matching(FLAC__StreamMetadata *object, const char *field_name)
1395 FLAC__bool ok = true;
1396 unsigned matching = 0;
1397 const unsigned field_name_length = strlen(field_name);
1400 FLAC__ASSERT(0 != object);
1401 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
1403 /* must delete from end to start otherwise it will interfere with our iteration */
1404 for(i = (int)object->data.vorbis_comment.num_comments - 1; ok && i >= 0; i--) {
1405 if(FLAC__metadata_object_vorbiscomment_entry_matches(object->data.vorbis_comment.comments[i], field_name, field_name_length)) {
1407 ok &= FLAC__metadata_object_vorbiscomment_delete_comment(object, (unsigned)i);
1411 return ok? (int)matching : -1;
1414 FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void)
1416 return (FLAC__StreamMetadata_CueSheet_Track*)calloc(1, sizeof(FLAC__StreamMetadata_CueSheet_Track));
1419 FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_clone(const FLAC__StreamMetadata_CueSheet_Track *object)
1421 FLAC__StreamMetadata_CueSheet_Track *to;
1423 FLAC__ASSERT(0 != object);
1425 if(0 != (to = FLAC__metadata_object_cuesheet_track_new())) {
1426 if(!copy_track_(to, object)) {
1427 FLAC__metadata_object_cuesheet_track_delete(to);
1435 void FLAC__metadata_object_cuesheet_track_delete_data(FLAC__StreamMetadata_CueSheet_Track *object)
1437 FLAC__ASSERT(0 != object);
1439 if(0 != object->indices) {
1440 FLAC__ASSERT(object->num_indices > 0);
1441 free(object->indices);
1445 FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_CueSheet_Track *object)
1447 FLAC__metadata_object_cuesheet_track_delete_data(object);
1451 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices)
1453 FLAC__StreamMetadata_CueSheet_Track *track;
1454 FLAC__ASSERT(0 != object);
1455 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1456 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1458 track = &object->data.cue_sheet.tracks[track_num];
1460 if(0 == track->indices) {
1461 FLAC__ASSERT(track->num_indices == 0);
1462 if(0 == new_num_indices)
1464 else if(0 == (track->indices = cuesheet_track_index_array_new_(new_num_indices)))
1468 const unsigned old_size = track->num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
1469 const unsigned new_size = new_num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index);
1471 FLAC__ASSERT(track->num_indices > 0);
1474 free(track->indices);
1477 else if(0 == (track->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(track->indices, new_size)))
1480 /* if growing, zero all the lengths/pointers of new elements */
1481 if(new_size > old_size)
1482 memset(track->indices + track->num_indices, 0, new_size - old_size);
1485 track->num_indices = new_num_indices;
1487 cuesheet_calculate_length_(object);
1491 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)
1493 FLAC__StreamMetadata_CueSheet_Track *track;
1495 FLAC__ASSERT(0 != object);
1496 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1497 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1498 FLAC__ASSERT(index_num <= object->data.cue_sheet.tracks[track_num].num_indices);
1500 track = &object->data.cue_sheet.tracks[track_num];
1502 if(!FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices+1))
1505 /* move all indices >= index_num forward one space */
1506 memmove(&track->indices[index_num+1], &track->indices[index_num], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-1-index_num));
1508 track->indices[index_num] = index;
1509 cuesheet_calculate_length_(object);
1513 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
1515 FLAC__StreamMetadata_CueSheet_Index index;
1516 memset(&index, 0, sizeof(index));
1517 return FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, index);
1520 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num)
1522 FLAC__StreamMetadata_CueSheet_Track *track;
1524 FLAC__ASSERT(0 != object);
1525 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1526 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1527 FLAC__ASSERT(index_num < object->data.cue_sheet.tracks[track_num].num_indices);
1529 track = &object->data.cue_sheet.tracks[track_num];
1531 /* move all indices > index_num backward one space */
1532 memmove(&track->indices[index_num], &track->indices[index_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(track->num_indices-index_num-1));
1534 FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, track->num_indices-1);
1535 cuesheet_calculate_length_(object);
1539 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks)
1541 FLAC__ASSERT(0 != object);
1542 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1544 if(0 == object->data.cue_sheet.tracks) {
1545 FLAC__ASSERT(object->data.cue_sheet.num_tracks == 0);
1546 if(0 == new_num_tracks)
1548 else if(0 == (object->data.cue_sheet.tracks = cuesheet_track_array_new_(new_num_tracks)))
1552 const unsigned old_size = object->data.cue_sheet.num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
1553 const unsigned new_size = new_num_tracks * sizeof(FLAC__StreamMetadata_CueSheet_Track);
1555 FLAC__ASSERT(object->data.cue_sheet.num_tracks > 0);
1557 /* if shrinking, free the truncated entries */
1558 if(new_num_tracks < object->data.cue_sheet.num_tracks) {
1560 for(i = new_num_tracks; i < object->data.cue_sheet.num_tracks; i++)
1561 if(0 != object->data.cue_sheet.tracks[i].indices)
1562 free(object->data.cue_sheet.tracks[i].indices);
1566 free(object->data.cue_sheet.tracks);
1567 object->data.cue_sheet.tracks = 0;
1569 else if(0 == (object->data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(object->data.cue_sheet.tracks, new_size)))
1572 /* if growing, zero all the lengths/pointers of new elements */
1573 if(new_size > old_size)
1574 memset(object->data.cue_sheet.tracks + object->data.cue_sheet.num_tracks, 0, new_size - old_size);
1577 object->data.cue_sheet.num_tracks = new_num_tracks;
1579 cuesheet_calculate_length_(object);
1583 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
1585 FLAC__ASSERT(0 != object);
1586 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1588 return cuesheet_set_track_(object, object->data.cue_sheet.tracks + track_num, track, copy);
1591 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy)
1593 FLAC__StreamMetadata_CueSheet *cs;
1595 FLAC__ASSERT(0 != object);
1596 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1597 FLAC__ASSERT(track_num <= object->data.cue_sheet.num_tracks);
1599 cs = &object->data.cue_sheet;
1601 if(!FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks+1))
1604 /* move all tracks >= track_num forward one space */
1605 memmove(&cs->tracks[track_num+1], &cs->tracks[track_num], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-1-track_num));
1606 cs->tracks[track_num].num_indices = 0;
1607 cs->tracks[track_num].indices = 0;
1609 return FLAC__metadata_object_cuesheet_set_track(object, track_num, track, copy);
1612 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num)
1614 FLAC__StreamMetadata_CueSheet_Track track;
1615 memset(&track, 0, sizeof(track));
1616 return FLAC__metadata_object_cuesheet_insert_track(object, track_num, &track, /*copy=*/false);
1619 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num)
1621 FLAC__StreamMetadata_CueSheet *cs;
1623 FLAC__ASSERT(0 != object);
1624 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1625 FLAC__ASSERT(track_num < object->data.cue_sheet.num_tracks);
1627 cs = &object->data.cue_sheet;
1629 /* free the track at track_num */
1630 if(0 != cs->tracks[track_num].indices)
1631 free(cs->tracks[track_num].indices);
1633 /* move all tracks > track_num backward one space */
1634 memmove(&cs->tracks[track_num], &cs->tracks[track_num+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(cs->num_tracks-track_num-1));
1635 cs->tracks[cs->num_tracks-1].num_indices = 0;
1636 cs->tracks[cs->num_tracks-1].indices = 0;
1638 return FLAC__metadata_object_cuesheet_resize_tracks(object, cs->num_tracks-1);
1641 FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_is_legal(const FLAC__StreamMetadata *object, FLAC__bool check_cd_da_subset, const char **violation)
1643 FLAC__ASSERT(0 != object);
1644 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1646 return FLAC__format_cuesheet_is_legal(&object->data.cue_sheet, check_cd_da_subset, violation);
1649 static FLAC__uint64 get_index_01_offset_(const FLAC__StreamMetadata_CueSheet *cs, unsigned track)
1651 if (track >= (cs->num_tracks-1) || cs->tracks[track].num_indices < 1)
1653 else if (cs->tracks[track].indices[0].number == 1)
1654 return cs->tracks[track].indices[0].offset + cs->tracks[track].offset + cs->lead_in;
1655 else if (cs->tracks[track].num_indices < 2)
1657 else if (cs->tracks[track].indices[1].number == 1)
1658 return cs->tracks[track].indices[1].offset + cs->tracks[track].offset + cs->lead_in;
1663 static FLAC__uint32 cddb_add_digits_(FLAC__uint32 x)
1673 FLAC_API FLAC__uint32 FLAC__metadata_object_cuesheet_calculate_cddb_id(const FLAC__StreamMetadata *object)
1675 const FLAC__StreamMetadata_CueSheet *cs;
1677 FLAC__ASSERT(0 != object);
1678 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_CUESHEET);
1680 cs = &object->data.cue_sheet;
1682 if (cs->num_tracks < 2) /* need at least one real track and the lead-out track */
1686 FLAC__uint32 i, length, sum = 0;
1687 for (i = 0; i < (cs->num_tracks-1); i++) /* -1 to avoid counting the lead-out */
1688 sum += cddb_add_digits_((FLAC__uint32)(get_index_01_offset_(cs, i) / 44100));
1689 length = (FLAC__uint32)((cs->tracks[cs->num_tracks-1].offset+cs->lead_in) / 44100) - (FLAC__uint32)(get_index_01_offset_(cs, 0) / 44100);
1691 return (sum % 0xFF) << 24 | length << 8 | (FLAC__uint32)(cs->num_tracks-1);
1695 FLAC_API FLAC__bool FLAC__metadata_object_picture_set_mime_type(FLAC__StreamMetadata *object, char *mime_type, FLAC__bool copy)
1698 size_t old_length, new_length;
1700 FLAC__ASSERT(0 != object);
1701 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE);
1702 FLAC__ASSERT(0 != mime_type);
1704 old = object->data.picture.mime_type;
1705 old_length = old? strlen(old) : 0;
1706 new_length = strlen(mime_type);
1708 /* do the copy first so that if we fail we leave the object untouched */
1710 if(!copy_bytes_((FLAC__byte**)(&object->data.picture.mime_type), (FLAC__byte*)mime_type, new_length+1))
1714 object->data.picture.mime_type = mime_type;
1720 object->length -= old_length;
1721 object->length += new_length;
1725 FLAC_API FLAC__bool FLAC__metadata_object_picture_set_description(FLAC__StreamMetadata *object, FLAC__byte *description, FLAC__bool copy)
1728 size_t old_length, new_length;
1730 FLAC__ASSERT(0 != object);
1731 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE);
1732 FLAC__ASSERT(0 != description);
1734 old = object->data.picture.description;
1735 old_length = old? strlen((const char *)old) : 0;
1736 new_length = strlen((const char *)description);
1738 /* do the copy first so that if we fail we leave the object untouched */
1740 if(!copy_bytes_(&object->data.picture.description, description, new_length+1))
1744 object->data.picture.description = description;
1750 object->length -= old_length;
1751 object->length += new_length;
1755 FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, FLAC__uint32 length, FLAC__bool copy)
1759 FLAC__ASSERT(0 != object);
1760 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE);
1761 FLAC__ASSERT((0 != data && length > 0) || (0 == data && length == 0 && copy == false));
1763 old = object->data.picture.data;
1765 /* do the copy first so that if we fail we leave the object untouched */
1767 if(!copy_bytes_(&object->data.picture.data, data, length))
1771 object->data.picture.data = data;
1777 object->length -= object->data.picture.data_length;
1778 object->data.picture.data_length = length;
1779 object->length += length;
1783 FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation)
1785 FLAC__ASSERT(0 != object);
1786 FLAC__ASSERT(object->type == FLAC__METADATA_TYPE_PICTURE);
1788 return FLAC__format_picture_is_legal(&object->data.picture, violation);