ce188d4d |
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 | */ |
65 | static 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 */ |
83 | static 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 */ |
99 | static 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 | */ |
115 | static 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 | |
128 | static 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 | |
147 | static 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 | |
164 | static 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 | |
172 | static 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 | |
192 | static 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 | |
207 | static 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 | |
214 | static 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 | |
226 | static 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 | |
249 | static 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 | |
294 | static 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 | |
310 | static 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 | |
343 | static 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 | |
350 | static 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 | |
357 | static 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 | |
373 | static 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 | |
396 | static 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 | |
430 | FLAC_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 | |
520 | FLAC_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 | |
626 | void 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 | |
689 | FLAC_API void FLAC__metadata_object_delete(FLAC__StreamMetadata *object) |
690 | { |
691 | FLAC__metadata_object_delete_data(object); |
692 | free(object); |
693 | } |
694 | |
695 | static 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 | |
718 | static 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 | |
732 | static 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 | |
757 | static 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 | |
785 | static 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 | |
834 | static 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 | |
857 | static 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 | |
868 | FLAC_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 | |
902 | FLAC_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 | |
927 | FLAC_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 | |
973 | FLAC_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 | |
982 | FLAC_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 | |
1002 | FLAC_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 | |
1017 | FLAC_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 | |
1025 | FLAC_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 | |
1037 | FLAC_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 | |
1056 | FLAC_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 | |
1081 | FLAC_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 | |
1106 | FLAC_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 | |
1146 | FLAC_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 | |
1158 | FLAC_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 | |
1165 | FLAC_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 | |
1219 | FLAC_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 | |
1229 | FLAC_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 | |
1253 | FLAC_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 | |
1260 | FLAC_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 | |
1303 | FLAC_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 | |
1324 | 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) |
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 | |
1350 | 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) |
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 | |
1381 | FLAC_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 | |
1390 | FLAC_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 | |
1397 | FLAC_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 | |
1417 | FLAC_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 | |
1438 | FLAC_API FLAC__StreamMetadata_CueSheet_Track *FLAC__metadata_object_cuesheet_track_new(void) |
1439 | { |
1440 | return calloc(1, sizeof(FLAC__StreamMetadata_CueSheet_Track)); |
1441 | } |
1442 | |
1443 | FLAC_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 | |
1459 | void 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 | |
1469 | FLAC_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 | |
1475 | FLAC_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 | |
1519 | FLAC_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 | |
1541 | FLAC_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 | |
1548 | FLAC_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 | |
1567 | FLAC_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 | |
1614 | FLAC_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 | |
1622 | FLAC_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 | |
1643 | FLAC_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 | |
1650 | FLAC_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 | |
1671 | FLAC_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 | |
1679 | static 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 | |
1693 | static 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*/ |
1704 | FLAC_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 | |
1726 | FLAC_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 | |
1757 | FLAC_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 | |
1788 | FLAC_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 | |
1815 | FLAC_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 | } |