1 /* test_libFLAC - Unit tester for libFLAC
2 * Copyright (C) 2002,2003 Josh Coalson
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 * These are not tests, just utility functions used by the metadata tests
23 #include "metadata_utils.h"
24 #include "FLAC/metadata.h"
26 #include <stdlib.h> /* for malloc() */
27 #include <string.h> /* for memcmp() */
29 FLAC__bool mutils__compare_block_data_streaminfo(const FLAC__StreamMetadata_StreamInfo *block, const FLAC__StreamMetadata_StreamInfo *blockcopy)
31 if(blockcopy->min_blocksize != block->min_blocksize) {
32 printf("FAILED, min_blocksize mismatch, expected %u, got %u\n", block->min_blocksize, blockcopy->min_blocksize);
35 if(blockcopy->max_blocksize != block->max_blocksize) {
36 printf("FAILED, max_blocksize mismatch, expected %u, got %u\n", block->max_blocksize, blockcopy->max_blocksize);
39 if(blockcopy->min_framesize != block->min_framesize) {
40 printf("FAILED, min_framesize mismatch, expected %u, got %u\n", block->min_framesize, blockcopy->min_framesize);
43 if(blockcopy->max_framesize != block->max_framesize) {
44 printf("FAILED, max_framesize mismatch, expected %u, got %u\n", block->max_framesize, blockcopy->max_framesize);
47 if(blockcopy->sample_rate != block->sample_rate) {
48 printf("FAILED, sample_rate mismatch, expected %u, got %u\n", block->sample_rate, blockcopy->sample_rate);
51 if(blockcopy->channels != block->channels) {
52 printf("FAILED, channels mismatch, expected %u, got %u\n", block->channels, blockcopy->channels);
55 if(blockcopy->bits_per_sample != block->bits_per_sample) {
56 printf("FAILED, bits_per_sample mismatch, expected %u, got %u\n", block->bits_per_sample, blockcopy->bits_per_sample);
59 if(blockcopy->total_samples != block->total_samples) {
60 printf("FAILED, total_samples mismatch, expected %llu, got %llu\n", block->total_samples, blockcopy->total_samples);
63 if(0 != memcmp(blockcopy->md5sum, block->md5sum, sizeof(block->md5sum))) {
64 printf("FAILED, md5sum mismatch, expected %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X, got %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
65 (unsigned)block->md5sum[0],
66 (unsigned)block->md5sum[1],
67 (unsigned)block->md5sum[2],
68 (unsigned)block->md5sum[3],
69 (unsigned)block->md5sum[4],
70 (unsigned)block->md5sum[5],
71 (unsigned)block->md5sum[6],
72 (unsigned)block->md5sum[7],
73 (unsigned)block->md5sum[8],
74 (unsigned)block->md5sum[9],
75 (unsigned)block->md5sum[10],
76 (unsigned)block->md5sum[11],
77 (unsigned)block->md5sum[12],
78 (unsigned)block->md5sum[13],
79 (unsigned)block->md5sum[14],
80 (unsigned)block->md5sum[15],
81 (unsigned)blockcopy->md5sum[0],
82 (unsigned)blockcopy->md5sum[1],
83 (unsigned)blockcopy->md5sum[2],
84 (unsigned)blockcopy->md5sum[3],
85 (unsigned)blockcopy->md5sum[4],
86 (unsigned)blockcopy->md5sum[5],
87 (unsigned)blockcopy->md5sum[6],
88 (unsigned)blockcopy->md5sum[7],
89 (unsigned)blockcopy->md5sum[8],
90 (unsigned)blockcopy->md5sum[9],
91 (unsigned)blockcopy->md5sum[10],
92 (unsigned)blockcopy->md5sum[11],
93 (unsigned)blockcopy->md5sum[12],
94 (unsigned)blockcopy->md5sum[13],
95 (unsigned)blockcopy->md5sum[14],
96 (unsigned)blockcopy->md5sum[15]
103 FLAC__bool mutils__compare_block_data_padding(const FLAC__StreamMetadata_Padding *block, const FLAC__StreamMetadata_Padding *blockcopy, unsigned block_length)
105 /* we don't compare the padding guts */
106 (void)block, (void)blockcopy, (void)block_length;
110 FLAC__bool mutils__compare_block_data_application(const FLAC__StreamMetadata_Application *block, const FLAC__StreamMetadata_Application *blockcopy, unsigned block_length)
112 if(block_length < sizeof(block->id)) {
113 printf("FAILED, bad block length = %u\n", block_length);
116 if(0 != memcmp(blockcopy->id, block->id, sizeof(block->id))) {
117 printf("FAILED, id mismatch, expected %02X%02X%02X%02X, got %02X%02X%02X%02X\n",
118 (unsigned)block->id[0],
119 (unsigned)block->id[1],
120 (unsigned)block->id[2],
121 (unsigned)block->id[3],
122 (unsigned)blockcopy->id[0],
123 (unsigned)blockcopy->id[1],
124 (unsigned)blockcopy->id[2],
125 (unsigned)blockcopy->id[3]
129 if(0 == block->data || 0 == blockcopy->data) {
130 if(block->data != blockcopy->data) {
131 printf("FAILED, data mismatch (%s's data pointer is null)\n", 0==block->data?"original":"copy");
134 else if(block_length - sizeof(block->id) > 0) {
135 printf("FAILED, data pointer is null but block length is not 0\n");
140 if(block_length - sizeof(block->id) == 0) {
141 printf("FAILED, data pointer is not null but block length is 0\n");
144 else if(0 != memcmp(blockcopy->data, block->data, block_length - sizeof(block->id))) {
145 printf("FAILED, data mismatch\n");
152 FLAC__bool mutils__compare_block_data_seektable(const FLAC__StreamMetadata_SeekTable *block, const FLAC__StreamMetadata_SeekTable *blockcopy)
155 if(blockcopy->num_points != block->num_points) {
156 printf("FAILED, num_points mismatch, expected %u, got %u\n", block->num_points, blockcopy->num_points);
159 for(i = 0; i < block->num_points; i++) {
160 if(blockcopy->points[i].sample_number != block->points[i].sample_number) {
161 printf("FAILED, points[%u].sample_number mismatch, expected %llu, got %llu\n", i, block->points[i].sample_number, blockcopy->points[i].sample_number);
164 if(blockcopy->points[i].stream_offset != block->points[i].stream_offset) {
165 printf("FAILED, points[%u].stream_offset mismatch, expected %llu, got %llu\n", i, block->points[i].stream_offset, blockcopy->points[i].stream_offset);
168 if(blockcopy->points[i].frame_samples != block->points[i].frame_samples) {
169 printf("FAILED, points[%u].frame_samples mismatch, expected %u, got %u\n", i, block->points[i].frame_samples, blockcopy->points[i].frame_samples);
176 FLAC__bool mutils__compare_block_data_vorbiscomment(const FLAC__StreamMetadata_VorbisComment *block, const FLAC__StreamMetadata_VorbisComment *blockcopy)
179 if(blockcopy->vendor_string.length != block->vendor_string.length) {
180 printf("FAILED, vendor_string.length mismatch, expected %u, got %u\n", block->vendor_string.length, blockcopy->vendor_string.length);
183 if(0 == block->vendor_string.entry || 0 == blockcopy->vendor_string.entry) {
184 if(block->vendor_string.entry != blockcopy->vendor_string.entry) {
185 printf("FAILED, vendor_string.entry mismatch\n");
189 else if(0 != memcmp(blockcopy->vendor_string.entry, block->vendor_string.entry, block->vendor_string.length)) {
190 printf("FAILED, vendor_string.entry mismatch\n");
193 if(blockcopy->num_comments != block->num_comments) {
194 printf("FAILED, num_comments mismatch, expected %u, got %u\n", block->num_comments, blockcopy->num_comments);
197 for(i = 0; i < block->num_comments; i++) {
198 if(blockcopy->comments[i].length != block->comments[i].length) {
199 printf("FAILED, comments[%u].length mismatch, expected %u, got %u\n", i, block->comments[i].length, blockcopy->comments[i].length);
202 if(0 == block->comments[i].entry || 0 == blockcopy->comments[i].entry) {
203 if(block->comments[i].entry != blockcopy->comments[i].entry) {
204 printf("FAILED, comments[%u].entry mismatch\n", i);
209 if(0 != memcmp(blockcopy->comments[i].entry, block->comments[i].entry, block->comments[i].length)) {
210 printf("FAILED, comments[%u].entry mismatch\n", i);
218 FLAC__bool mutils__compare_block_data_cuesheet(const FLAC__StreamMetadata_CueSheet *block, const FLAC__StreamMetadata_CueSheet *blockcopy)
222 if(0 != strcmp(blockcopy->media_catalog_number, block->media_catalog_number)) {
223 printf("FAILED, media_catalog_number mismatch, expected %s, got %s\n", block->media_catalog_number, blockcopy->media_catalog_number);
226 if(blockcopy->lead_in != block->lead_in) {
227 printf("FAILED, lead_in mismatch, expected %llu, got %llu\n", block->lead_in, blockcopy->lead_in);
230 if(blockcopy->is_cd != block->is_cd) {
231 printf("FAILED, is_cd mismatch, expected %u, got %u\n", (unsigned)block->is_cd, (unsigned)blockcopy->is_cd);
234 if(blockcopy->num_tracks != block->num_tracks) {
235 printf("FAILED, num_tracks mismatch, expected %u, got %u\n", block->num_tracks, blockcopy->num_tracks);
238 for(i = 0; i < block->num_tracks; i++) {
239 if(blockcopy->tracks[i].offset != block->tracks[i].offset) {
240 printf("FAILED, tracks[%u].offset mismatch, expected %llu, got %llu\n", i, block->tracks[i].offset, blockcopy->tracks[i].offset);
243 if(blockcopy->tracks[i].number != block->tracks[i].number) {
244 printf("FAILED, tracks[%u].number mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].number, (unsigned)blockcopy->tracks[i].number);
247 if(blockcopy->tracks[i].num_indices != block->tracks[i].num_indices) {
248 printf("FAILED, tracks[%u].num_indices mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].num_indices, (unsigned)blockcopy->tracks[i].num_indices);
251 /* num_indices == 0 means lead-out track so only the track offset and number are valid */
252 if(block->tracks[i].num_indices > 0) {
253 if(0 != strcmp(blockcopy->tracks[i].isrc, block->tracks[i].isrc)) {
254 printf("FAILED, tracks[%u].isrc mismatch, expected %s, got %s\n", i, block->tracks[i].isrc, blockcopy->tracks[i].isrc);
257 if(blockcopy->tracks[i].type != block->tracks[i].type) {
258 printf("FAILED, tracks[%u].type mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].type, (unsigned)blockcopy->tracks[i].type);
261 if(blockcopy->tracks[i].pre_emphasis != block->tracks[i].pre_emphasis) {
262 printf("FAILED, tracks[%u].pre_emphasis mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].pre_emphasis, (unsigned)blockcopy->tracks[i].pre_emphasis);
265 if(0 == block->tracks[i].indices || 0 == blockcopy->tracks[i].indices) {
266 if(block->tracks[i].indices != blockcopy->tracks[i].indices) {
267 printf("FAILED, tracks[%u].indices mismatch\n", i);
272 for(j = 0; j < block->tracks[i].num_indices; j++) {
273 if(blockcopy->tracks[i].indices[j].offset != block->tracks[i].indices[j].offset) {
274 printf("FAILED, tracks[%u].indices[%u].offset mismatch, expected %llu, got %llu\n", i, j, block->tracks[i].indices[j].offset, blockcopy->tracks[i].indices[j].offset);
277 if(blockcopy->tracks[i].indices[j].number != block->tracks[i].indices[j].number) {
278 printf("FAILED, tracks[%u].indices[%u].number mismatch, expected %u, got %u\n", i, j, (unsigned)block->tracks[i].indices[j].number, (unsigned)blockcopy->tracks[i].indices[j].number);
288 FLAC__bool mutils__compare_block_data_unknown(const FLAC__StreamMetadata_Unknown *block, const FLAC__StreamMetadata_Unknown *blockcopy, unsigned block_length)
290 if(0 == block->data || 0 == blockcopy->data) {
291 if(block->data != blockcopy->data) {
292 printf("FAILED, data mismatch (%s's data pointer is null)\n", 0==block->data?"original":"copy");
295 else if(block_length > 0) {
296 printf("FAILED, data pointer is null but block length is not 0\n");
301 if(block_length == 0) {
302 printf("FAILED, data pointer is not null but block length is 0\n");
305 else if(0 != memcmp(blockcopy->data, block->data, block_length)) {
306 printf("FAILED, data mismatch\n");
313 FLAC__bool mutils__compare_block(const FLAC__StreamMetadata *block, const FLAC__StreamMetadata *blockcopy)
315 if(blockcopy->type != block->type) {
316 printf("FAILED, type mismatch, expected %s, got %s\n", FLAC__MetadataTypeString[block->type], FLAC__MetadataTypeString[blockcopy->type]);
319 if(blockcopy->is_last != block->is_last) {
320 printf("FAILED, is_last mismatch, expected %u, got %u\n", (unsigned)block->is_last, (unsigned)blockcopy->is_last);
323 if(blockcopy->length != block->length) {
324 printf("FAILED, length mismatch, expected %u, got %u\n", block->length, blockcopy->length);
327 switch(block->type) {
328 case FLAC__METADATA_TYPE_STREAMINFO:
329 return mutils__compare_block_data_streaminfo(&block->data.stream_info, &blockcopy->data.stream_info);
330 case FLAC__METADATA_TYPE_PADDING:
331 return mutils__compare_block_data_padding(&block->data.padding, &blockcopy->data.padding, block->length);
332 case FLAC__METADATA_TYPE_APPLICATION:
333 return mutils__compare_block_data_application(&block->data.application, &blockcopy->data.application, block->length);
334 case FLAC__METADATA_TYPE_SEEKTABLE:
335 return mutils__compare_block_data_seektable(&block->data.seek_table, &blockcopy->data.seek_table);
336 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
337 return mutils__compare_block_data_vorbiscomment(&block->data.vorbis_comment, &blockcopy->data.vorbis_comment);
338 case FLAC__METADATA_TYPE_CUESHEET:
339 return mutils__compare_block_data_cuesheet(&block->data.cue_sheet, &blockcopy->data.cue_sheet);
341 return mutils__compare_block_data_unknown(&block->data.unknown, &blockcopy->data.unknown, block->length);
344 static void *malloc_or_die_(size_t size)
346 void *x = malloc(size);
348 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
354 static void *calloc_or_die_(size_t n, size_t size)
356 void *x = calloc(n, size);
358 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)n * (unsigned)size);
364 void mutils__init_metadata_blocks(
365 FLAC__StreamMetadata *streaminfo,
366 FLAC__StreamMetadata *padding,
367 FLAC__StreamMetadata *seektable,
368 FLAC__StreamMetadata *application1,
369 FLAC__StreamMetadata *application2,
370 FLAC__StreamMetadata *vorbiscomment,
371 FLAC__StreamMetadata *cuesheet
375 most of the actual numbers and data in the blocks don't matter,
376 we just want to make sure the decoder parses them correctly
378 remember, the metadata interface gets tested after the decoders,
379 so we do all the metadata manipulation here without it.
382 /* min/max_framesize and md5sum don't get written at first, so we have to leave them 0 */
383 streaminfo->is_last = false;
384 streaminfo->type = FLAC__METADATA_TYPE_STREAMINFO;
385 streaminfo->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
386 streaminfo->data.stream_info.min_blocksize = 576;
387 streaminfo->data.stream_info.max_blocksize = 576;
388 streaminfo->data.stream_info.min_framesize = 0;
389 streaminfo->data.stream_info.max_framesize = 0;
390 streaminfo->data.stream_info.sample_rate = 44100;
391 streaminfo->data.stream_info.channels = 1;
392 streaminfo->data.stream_info.bits_per_sample = 8;
393 streaminfo->data.stream_info.total_samples = 0;
394 memset(streaminfo->data.stream_info.md5sum, 0, 16);
396 padding->is_last = false;
397 padding->type = FLAC__METADATA_TYPE_PADDING;
398 padding->length = 1234;
400 seektable->is_last = false;
401 seektable->type = FLAC__METADATA_TYPE_SEEKTABLE;
402 seektable->data.seek_table.num_points = 2;
403 seektable->length = seektable->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
404 seektable->data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*)malloc_or_die_(seektable->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint));
405 seektable->data.seek_table.points[0].sample_number = 0;
406 seektable->data.seek_table.points[0].stream_offset = 0;
407 seektable->data.seek_table.points[0].frame_samples = streaminfo->data.stream_info.min_blocksize;
408 seektable->data.seek_table.points[1].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
409 seektable->data.seek_table.points[1].stream_offset = 1000;
410 seektable->data.seek_table.points[1].frame_samples = streaminfo->data.stream_info.min_blocksize;
412 application1->is_last = false;
413 application1->type = FLAC__METADATA_TYPE_APPLICATION;
414 application1->length = 8;
415 memcpy(application1->data.application.id, "\xfe\xdc\xba\x98", 4);
416 application1->data.application.data = (FLAC__byte*)malloc_or_die_(4);
417 memcpy(application1->data.application.data, "\xf0\xe1\xd2\xc3", 4);
419 application2->is_last = false;
420 application2->type = FLAC__METADATA_TYPE_APPLICATION;
421 application2->length = 4;
422 memcpy(application2->data.application.id, "\x76\x54\x32\x10", 4);
423 application2->data.application.data = 0;
426 const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
427 vorbiscomment->is_last = false;
428 vorbiscomment->type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
429 vorbiscomment->length = (4 + vendor_string_length) + 4 + (4 + 5) + (4 + 0);
430 vorbiscomment->data.vorbis_comment.vendor_string.length = vendor_string_length;
431 vorbiscomment->data.vorbis_comment.vendor_string.entry = (FLAC__byte*)malloc_or_die_(vendor_string_length);
432 memcpy(vorbiscomment->data.vorbis_comment.vendor_string.entry, FLAC__VENDOR_STRING, vendor_string_length);
433 vorbiscomment->data.vorbis_comment.num_comments = 2;
434 vorbiscomment->data.vorbis_comment.comments = (FLAC__StreamMetadata_VorbisComment_Entry*)malloc_or_die_(vorbiscomment->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
435 vorbiscomment->data.vorbis_comment.comments[0].length = 5;
436 vorbiscomment->data.vorbis_comment.comments[0].entry = (FLAC__byte*)malloc_or_die_(5);
437 memcpy(vorbiscomment->data.vorbis_comment.comments[0].entry, "ab=cd", 5);
438 vorbiscomment->data.vorbis_comment.comments[1].length = 0;
439 vorbiscomment->data.vorbis_comment.comments[1].entry = 0;
442 cuesheet->is_last = true;
443 cuesheet->type = FLAC__METADATA_TYPE_CUESHEET;
447 FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
448 FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
449 FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
450 FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
451 FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
455 FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
456 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
457 FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
458 FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
459 FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
460 FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
461 FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
465 FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
466 FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
467 FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
470 memset(cuesheet->data.cue_sheet.media_catalog_number, 0, sizeof(cuesheet->data.cue_sheet.media_catalog_number));
471 cuesheet->data.cue_sheet.media_catalog_number[0] = 'j';
472 cuesheet->data.cue_sheet.media_catalog_number[1] = 'C';
473 cuesheet->data.cue_sheet.lead_in = 2 * 44100;
474 cuesheet->data.cue_sheet.is_cd = true;
475 cuesheet->data.cue_sheet.num_tracks = 3;
476 cuesheet->data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)calloc_or_die_(cuesheet->data.cue_sheet.num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track));
477 cuesheet->data.cue_sheet.tracks[0].offset = 0;
478 cuesheet->data.cue_sheet.tracks[0].number = 1;
479 memcpy(cuesheet->data.cue_sheet.tracks[0].isrc, "ACBDE1234567", sizeof(cuesheet->data.cue_sheet.tracks[0].isrc));
480 cuesheet->data.cue_sheet.tracks[0].type = 0;
481 cuesheet->data.cue_sheet.tracks[0].pre_emphasis = 1;
482 cuesheet->data.cue_sheet.tracks[0].num_indices = 2;
483 cuesheet->data.cue_sheet.tracks[0].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet->data.cue_sheet.tracks[0].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
484 cuesheet->data.cue_sheet.tracks[0].indices[0].offset = 0;
485 cuesheet->data.cue_sheet.tracks[0].indices[0].number = 0;
486 cuesheet->data.cue_sheet.tracks[0].indices[1].offset = 123 * 588;
487 cuesheet->data.cue_sheet.tracks[0].indices[1].number = 1;
488 cuesheet->data.cue_sheet.tracks[1].offset = 1234 * 588;
489 cuesheet->data.cue_sheet.tracks[1].number = 2;
490 memcpy(cuesheet->data.cue_sheet.tracks[1].isrc, "ACBDE7654321", sizeof(cuesheet->data.cue_sheet.tracks[1].isrc));
491 cuesheet->data.cue_sheet.tracks[1].type = 1;
492 cuesheet->data.cue_sheet.tracks[1].pre_emphasis = 0;
493 cuesheet->data.cue_sheet.tracks[1].num_indices = 1;
494 cuesheet->data.cue_sheet.tracks[1].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet->data.cue_sheet.tracks[1].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
495 cuesheet->data.cue_sheet.tracks[1].indices[0].offset = 0;
496 cuesheet->data.cue_sheet.tracks[1].indices[0].number = 1;
497 cuesheet->data.cue_sheet.tracks[2].offset = 12345 * 588;
498 cuesheet->data.cue_sheet.tracks[2].number = 170;
499 cuesheet->data.cue_sheet.tracks[2].num_indices = 0;
502 void mutils__free_metadata_blocks(
503 FLAC__StreamMetadata *streaminfo,
504 FLAC__StreamMetadata *padding,
505 FLAC__StreamMetadata *seektable,
506 FLAC__StreamMetadata *application1,
507 FLAC__StreamMetadata *application2,
508 FLAC__StreamMetadata *vorbiscomment,
509 FLAC__StreamMetadata *cuesheet
512 (void)streaminfo, (void)padding, (void)application2;
513 free(seektable->data.seek_table.points);
514 free(application1->data.application.data);
515 free(vorbiscomment->data.vorbis_comment.vendor_string.entry);
516 free(vorbiscomment->data.vorbis_comment.comments[0].entry);
517 free(vorbiscomment->data.vorbis_comment.comments);
518 free(cuesheet->data.cue_sheet.tracks[0].indices);
519 free(cuesheet->data.cue_sheet.tracks[1].indices);
520 free(cuesheet->data.cue_sheet.tracks);