move in some common metadata setting stuff here
[flac.git] / src / test_libOggFLAC / metadata_utils.c
1 /* test_libFLAC - Unit tester for libFLAC
2  * Copyright (C) 2002,2003  Josh Coalson
3  *
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.
8  *
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.
13  *
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.
17  */
18
19 /*
20  * These are not tests, just utility functions used by the metadata tests
21  */
22
23 #include "metadata_utils.h"
24 #include "FLAC/metadata.h"
25 #include <stdio.h>
26 #include <stdlib.h> /* for malloc() */
27 #include <string.h> /* for memcmp() */
28
29 FLAC__bool mutils__compare_block_data_streaminfo(const FLAC__StreamMetadata_StreamInfo *block, const FLAC__StreamMetadata_StreamInfo *blockcopy)
30 {
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);
33                 return false;
34         }
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);
37                 return false;
38         }
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);
41                 return false;
42         }
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);
45                 return false;
46         }
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);
49                 return false;
50         }
51         if(blockcopy->channels != block->channels) {
52                 printf("FAILED, channels mismatch, expected %u, got %u\n", block->channels, blockcopy->channels);
53                 return false;
54         }
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);
57                 return false;
58         }
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);
61                 return false;
62         }
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]
97                 );
98                 return false;
99         }
100         return true;
101 }
102
103 FLAC__bool mutils__compare_block_data_padding(const FLAC__StreamMetadata_Padding *block, const FLAC__StreamMetadata_Padding *blockcopy, unsigned block_length)
104 {
105         /* we don't compare the padding guts */
106         (void)block, (void)blockcopy, (void)block_length;
107         return true;
108 }
109
110 FLAC__bool mutils__compare_block_data_application(const FLAC__StreamMetadata_Application *block, const FLAC__StreamMetadata_Application *blockcopy, unsigned block_length)
111 {
112         if(block_length < sizeof(block->id)) {
113                 printf("FAILED, bad block length = %u\n", block_length);
114                 return false;
115         }
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]
126                 );
127                 return false;
128         }
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");
132                         return false;
133                 }
134                 else if(block_length - sizeof(block->id) > 0) {
135                         printf("FAILED, data pointer is null but block length is not 0\n");
136                         return false;
137                 }
138         }
139         else {
140                 if(block_length - sizeof(block->id) == 0) {
141                         printf("FAILED, data pointer is not null but block length is 0\n");
142                         return false;
143                 }
144                 else if(0 != memcmp(blockcopy->data, block->data, block_length - sizeof(block->id))) {
145                         printf("FAILED, data mismatch\n");
146                         return false;
147                 }
148         }
149         return true;
150 }
151
152 FLAC__bool mutils__compare_block_data_seektable(const FLAC__StreamMetadata_SeekTable *block, const FLAC__StreamMetadata_SeekTable *blockcopy)
153 {
154         unsigned i;
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);
157                 return false;
158         }
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);
162                         return false;
163                 }
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);
166                         return false;
167                 }
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);
170                         return false;
171                 }
172         }
173         return true;
174 }
175
176 FLAC__bool mutils__compare_block_data_vorbiscomment(const FLAC__StreamMetadata_VorbisComment *block, const FLAC__StreamMetadata_VorbisComment *blockcopy)
177 {
178         unsigned i;
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);
181                 return false;
182         }
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");
186                         return false;
187                 }
188         }
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");
191                 return false;
192         }
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);
195                 return false;
196         }
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);
200                         return false;
201                 }
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);
205                                 return false;
206                         }
207                 }
208                 else {
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);
211                                 return false;
212                         }
213                 }
214         }
215         return true;
216 }
217
218 FLAC__bool mutils__compare_block_data_cuesheet(const FLAC__StreamMetadata_CueSheet *block, const FLAC__StreamMetadata_CueSheet *blockcopy)
219 {
220         unsigned i, j;
221
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);
224                 return false;
225         }
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);
228                 return false;
229         }
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);
232                 return false;
233         }
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);
236                 return false;
237         }
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);
241                         return false;
242                 }
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);
245                         return false;
246                 }
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);
249                         return false;
250                 }
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);
255                                 return false;
256                         }
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);
259                                 return false;
260                         }
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);
263                                 return false;
264                         }
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);
268                                         return false;
269                                 }
270                         }
271                         else {
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);
275                                                 return false;
276                                         }
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);
279                                                 return false;
280                                         }
281                                 }
282                         }
283                 }
284         }
285         return true;
286 }
287
288 FLAC__bool mutils__compare_block_data_unknown(const FLAC__StreamMetadata_Unknown *block, const FLAC__StreamMetadata_Unknown *blockcopy, unsigned block_length)
289 {
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");
293                         return false;
294                 }
295                 else if(block_length > 0) {
296                         printf("FAILED, data pointer is null but block length is not 0\n");
297                         return false;
298                 }
299         }
300         else {
301                 if(block_length == 0) {
302                         printf("FAILED, data pointer is not null but block length is 0\n");
303                         return false;
304                 }
305                 else if(0 != memcmp(blockcopy->data, block->data, block_length)) {
306                         printf("FAILED, data mismatch\n");
307                         return false;
308                 }
309         }
310         return true;
311 }
312
313 FLAC__bool mutils__compare_block(const FLAC__StreamMetadata *block, const FLAC__StreamMetadata *blockcopy)
314 {
315         if(blockcopy->type != block->type) {
316                 printf("FAILED, type mismatch, expected %s, got %s\n", FLAC__MetadataTypeString[block->type], FLAC__MetadataTypeString[blockcopy->type]);
317                 return false;
318         }
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);
321                 return false;
322         }
323         if(blockcopy->length != block->length) {
324                 printf("FAILED, length mismatch, expected %u, got %u\n", block->length, blockcopy->length);
325                 return false;
326         }
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);
340                 default:
341                         return mutils__compare_block_data_unknown(&block->data.unknown, &blockcopy->data.unknown, block->length);
342         }
343 }
344 static void *malloc_or_die_(size_t size)
345 {
346         void *x = malloc(size);
347         if(0 == x) {
348                 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
349                 exit(1);
350         }
351         return x;
352 }
353
354 static void *calloc_or_die_(size_t n, size_t size)
355 {
356         void *x = calloc(n, size);
357         if(0 == x) {
358                 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)n * (unsigned)size);
359                 exit(1);
360         }
361         return x;
362 }
363
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
372 )
373 {
374         /*
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
377
378                 remember, the metadata interface gets tested after the decoders,
379                 so we do all the metadata manipulation here without it.
380         */
381
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);
395
396         padding->is_last = false;
397         padding->type = FLAC__METADATA_TYPE_PADDING;
398         padding->length = 1234;
399
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;
411
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);
418
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;
424
425         {
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;
440         }
441
442         cuesheet->is_last = true;
443         cuesheet->type = FLAC__METADATA_TYPE_CUESHEET;
444         cuesheet->length =
445                 /* cuesheet guts */
446                 (
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
452                 ) / 8 +
453                 /* 2 tracks */
454                 3 * (
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
462                 ) / 8 +
463                 /* 3 index points */
464                 3 * (
465                         FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
466                         FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
467                         FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
468                 ) / 8
469         ;
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;
500 }
501
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
510 )
511 {
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);
521 }