?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix a couple of Windows 2Gig file size issues.
[flac.git] / src / test_libFLAC++ / metadata_manip.cpp
blobff024162c6bd75d0a9b3ab296984acf4664f877d
1 /* test_libFLAC++ - Unit tester for libFLAC++
2 * Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009 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 along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #if HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <stdio.h>
24 #include <stdlib.h> /* for malloc() */
25 #include <string.h> /* for memcpy()/memset() */
26 #include <sys/types.h> /* some flavors of BSD (like OS X) require this to get time_t */
27 #ifdef _MSC_VER
28 #include <sys/utime.h>
29 #else
30 #include <utime.h> /* for utime() */
31 #endif
32 #if !defined _MSC_VER && !defined __MINGW32__ && !defined __EMX__
33 #include <unistd.h> /* for chown(), unlink() */
34 #endif
35 #include <sys/stat.h> /* for stat(), maybe chmod() */
36 #include "FLAC/assert.h"
37 #include "FLAC++/decoder.h"
38 #include "FLAC++/metadata.h"
39 #include "share/grabbag.h"
40 #include "share/compat.h"
41 #include "share/macros.h"
42 extern "C" {
43 #include "test_libs_common/file_utils_flac.h"
44 }
45
46 /******************************************************************************
47 The general strategy of these tests (for interface levels 1 and 2) is
48 to create a dummy FLAC file with a known set of initial metadata
49 blocks, then keep a mirror locally of what we expect the metadata to be
50 after each operation. Then testing becomes a simple matter of running
51 a FLAC::Decoder::File over the dummy file after each operation, comparing
52 the decoded metadata to what's in our local copy. If there are any
53 differences in the metadata, or the actual audio data is corrupted, we
54 will catch it while decoding.
55 ******************************************************************************/
56
57 class OurFileDecoder: public FLAC::Decoder::File {
58 public:
59 inline OurFileDecoder(bool ignore_metadata): ignore_metadata_(ignore_metadata), error_occurred_(false) { }
60
61 bool ignore_metadata_;
62 bool error_occurred_;
63 protected:
64 ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
65 void metadata_callback(const ::FLAC__StreamMetadata *metadata);
66 void error_callback(::FLAC__StreamDecoderErrorStatus status);
67 };
68
69 struct OurMetadata {
70 FLAC::Metadata::Prototype *blocks[64];
71 unsigned num_blocks;
72 };
73
74 /* our copy of the metadata in flacfilename() */
75 static OurMetadata our_metadata_;
76
77 /* the current block number that corresponds to the position of the iterator we are testing */
78 static unsigned mc_our_block_number_ = 0;
79
80 static const char *flacfilename(bool is_ogg)
81 {
82 return is_ogg? "metadata.oga" : "metadata.flac";
83 }
84
85 static bool die_(const char *msg)
86 {
87 printf("ERROR: %s\n", msg);
88 return false;
89 }
90
91 static bool die_c_(const char *msg, FLAC::Metadata::Chain::Status status)
92 {
93 printf("ERROR: %s\n", msg);
94 printf(" status=%u (%s)\n", (unsigned)((::FLAC__Metadata_ChainStatus)status), status.as_cstring());
95 return false;
96 }
97
98 static bool die_ss_(const char *msg, FLAC::Metadata::SimpleIterator &iterator)
99 {
100 const FLAC::Metadata::SimpleIterator::Status status = iterator.status();
101 printf("ERROR: %s\n", msg);
102 printf(" status=%u (%s)\n", (unsigned)((::FLAC__Metadata_SimpleIteratorStatus)status), status.as_cstring());
103 return false;
104 }
105
106 static void *malloc_or_die_(size_t size)
107 {
108 void *x = malloc(size);
109 if(0 == x) {
110 fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
111 exit(1);
112 }
113 return x;
114 }
115
116 static char *strdup_or_die_(const char *s)
117 {
118 char *x = strdup(s);
119 if(0 == x) {
120 fprintf(stderr, "ERROR: out of memory copying string \"%s\"\n", s);
121 exit(1);
122 }
123 return x;
124 }
125
126 /* functions for working with our metadata copy */
127
128 static bool replace_in_our_metadata_(FLAC::Metadata::Prototype *block, unsigned position, bool copy)
129 {
130 unsigned i;
131 FLAC::Metadata::Prototype *obj = block;
132 FLAC__ASSERT(position < our_metadata_.num_blocks);
133 if(copy) {
134 if(0 == (obj = FLAC::Metadata::clone(block)))
135 return die_("during FLAC::Metadata::clone()");
136 }
137 delete our_metadata_.blocks[position];
138 our_metadata_.blocks[position] = obj;
139
140 /* set the is_last flags */
141 for(i = 0; i < our_metadata_.num_blocks - 1; i++)
142 our_metadata_.blocks[i]->set_is_last(false);
143 our_metadata_.blocks[i]->set_is_last(true);
144
145 return true;
146 }
147
148 static bool insert_to_our_metadata_(FLAC::Metadata::Prototype *block, unsigned position, bool copy)
149 {
150 unsigned i;
151 FLAC::Metadata::Prototype *obj = block;
152 if(copy) {
153 if(0 == (obj = FLAC::Metadata::clone(block)))
154 return die_("during FLAC::Metadata::clone()");
155 }
156 if(position > our_metadata_.num_blocks) {
157 position = our_metadata_.num_blocks;
158 }
159 else {
160 for(i = our_metadata_.num_blocks; i > position; i--)
161 our_metadata_.blocks[i] = our_metadata_.blocks[i-1];
162 }
163 our_metadata_.blocks[position] = obj;
164 our_metadata_.num_blocks++;
165
166 /* set the is_last flags */
167 for(i = 0; i < our_metadata_.num_blocks - 1; i++)
168 our_metadata_.blocks[i]->set_is_last(false);
169 our_metadata_.blocks[i]->set_is_last(true);
170
171 return true;
172 }
173
174 static void delete_from_our_metadata_(unsigned position)
175 {
176 unsigned i;
177 FLAC__ASSERT(position < our_metadata_.num_blocks);
178 delete our_metadata_.blocks[position];
179 for(i = position; i < our_metadata_.num_blocks - 1; i++)
180 our_metadata_.blocks[i] = our_metadata_.blocks[i+1];
181 our_metadata_.num_blocks--;
182
183 /* set the is_last flags */
184 if(our_metadata_.num_blocks > 0) {
185 for(i = 0; i < our_metadata_.num_blocks - 1; i++)
186 our_metadata_.blocks[i]->set_is_last(false);
187 our_metadata_.blocks[i]->set_is_last(true);
188 }
189 }
190
191 void add_to_padding_length_(unsigned index, int delta)
192 {
193 FLAC::Metadata::Padding *padding = dynamic_cast<FLAC::Metadata::Padding *>(our_metadata_.blocks[index]);
194 FLAC__ASSERT(0 != padding);
195 padding->set_length((unsigned)((int)padding->get_length() + delta));
196 }
197
198 /*
199 * This wad of functions supports filename- and callback-based chain reading/writing.
200 * Everything up to set_file_stats_() is copied from libFLAC/metadata_iterators.c
201 */
202 bool open_tempfile_(const char *filename, FILE **tempfile, char **tempfilename)
203 {
204 static const char *tempfile_suffix = ".metadata_edit";
205
206 if(0 == (*tempfilename = (char*)malloc(strlen(filename) + strlen(tempfile_suffix) + 1)))
207 return false;
208 strcpy(*tempfilename, filename);
209 strcat(*tempfilename, tempfile_suffix);
210
211 if(0 == (*tempfile = fopen(*tempfilename, "wb")))
212 return false;
213
214 return true;
215 }
216
217 void cleanup_tempfile_(FILE **tempfile, char **tempfilename)
218 {
219 if(0 != *tempfile) {
220 (void)fclose(*tempfile);
221 *tempfile = 0;
222 }
223
224 if(0 != *tempfilename) {
225 (void)unlink(*tempfilename);
226 free(*tempfilename);
227 *tempfilename = 0;
228 }
229 }
230
231 bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename)
232 {
233 FLAC__ASSERT(0 != filename);
234 FLAC__ASSERT(0 != tempfile);
235 FLAC__ASSERT(0 != tempfilename);
236 FLAC__ASSERT(0 != *tempfilename);
237
238 if(0 != *tempfile) {
239 (void)fclose(*tempfile);
240 *tempfile = 0;
241 }
242
243 #if defined _MSC_VER || defined __MINGW32__ || defined __EMX__
244 /* on some flavors of windows, rename() will fail if the destination already exists */
245 if(unlink(filename) < 0) {
246 cleanup_tempfile_(tempfile, tempfilename);
247 return false;
248 }
249 #endif
250
251 if(0 != rename(*tempfilename, filename)) {
252 cleanup_tempfile_(tempfile, tempfilename);
253 return false;
254 }
255
256 cleanup_tempfile_(tempfile, tempfilename);
257
258 return true;
259 }
260
261 bool get_file_stats_(const char *filename, struct stat *stats)
262 {
263 FLAC__ASSERT(0 != filename);
264 FLAC__ASSERT(0 != stats);
265 return (0 == stat(filename, stats));
266 }
267
268 void set_file_stats_(const char *filename, struct stat *stats)
269 {
270 struct utimbuf srctime;
271
272 FLAC__ASSERT(0 != filename);
273 FLAC__ASSERT(0 != stats);
274
275 srctime.actime = stats->st_atime;
276 srctime.modtime = stats->st_mtime;
277 (void)chmod(filename, stats->st_mode);
278 (void)utime(filename, &srctime);
279 #if !defined _MSC_VER && !defined __MINGW32__ && !defined __EMX__
280 FLAC_CHECK_RETURN(chown(filename, stats->st_uid, (gid_t)(-1)));
281 FLAC_CHECK_RETURN(chown(filename, (uid_t)(-1), stats->st_gid));
282 #endif
283 }
284
285 #ifdef FLAC__VALGRIND_TESTING
286 static size_t chain_write_cb_(const void *ptr, size_t size, size_t nmemb, ::FLAC__IOHandle handle)
287 {
288 FILE *stream = (FILE*)handle;
289 size_t ret = fwrite(ptr, size, nmemb, stream);
290 if(!ferror(stream))
291 fflush(stream);
292 return ret;
293 }
294 #endif
295
296 static int chain_seek_cb_(::FLAC__IOHandle handle, FLAC__int64 offset, int whence)
297 {
298 FLAC__off_t o = (FLAC__off_t)offset;
299 FLAC__ASSERT(offset == o);
300 return fseeko((FILE*)handle, o, whence);
301 }
302
303 static FLAC__int64 chain_tell_cb_(::FLAC__IOHandle handle)
304 {
305 return ftello((FILE*)handle);
306 }
307
308 static int chain_eof_cb_(::FLAC__IOHandle handle)
309 {
310 return feof((FILE*)handle);
311 }
312
313 static bool write_chain_(FLAC::Metadata::Chain &chain, bool use_padding, bool preserve_file_stats, bool filename_based, const char *filename)
314 {
315 if(filename_based)
316 return chain.write(use_padding, preserve_file_stats);
317 else {
318 ::FLAC__IOCallbacks callbacks;
319
320 memset(&callbacks, 0, sizeof(callbacks));
321 callbacks.read = (::FLAC__IOCallback_Read)fread;
322 #ifdef FLAC__VALGRIND_TESTING
323 callbacks.write = chain_write_cb_;
324 #else
325 callbacks.write = (::FLAC__IOCallback_Write)fwrite;
326 #endif
327 callbacks.seek = chain_seek_cb_;
328 callbacks.eof = chain_eof_cb_;
329
330 if(chain.check_if_tempfile_needed(use_padding)) {
331 struct stat stats;
332 FILE *file, *tempfile;
333 char *tempfilename;
334 if(preserve_file_stats) {
335 if(!get_file_stats_(filename, &stats))
336 return false;
337 }
338 if(0 == (file = fopen(filename, "rb")))
339 return false; /*@@@@ chain status still says OK though */
340 if(!open_tempfile_(filename, &tempfile, &tempfilename)) {
341 fclose(file);
342 cleanup_tempfile_(&tempfile, &tempfilename);
343 return false; /*@@@@ chain status still says OK though */
344 }
345 if(!chain.write(use_padding, (::FLAC__IOHandle)file, callbacks, (::FLAC__IOHandle)tempfile, callbacks)) {
346 fclose(file);
347 fclose(tempfile);
348 return false;
349 }
350 fclose(file);
351 fclose(tempfile);
352 file = tempfile = 0;
353 if(!transport_tempfile_(filename, &tempfile, &tempfilename))
354 return false;
355 if(preserve_file_stats)
356 set_file_stats_(filename, &stats);
357 }
358 else {
359 FILE *file = fopen(filename, "r+b");
360 if(0 == file)
361 return false; /*@@@@ chain status still says OK though */
362 if(!chain.write(use_padding, (::FLAC__IOHandle)file, callbacks)) {
363 fclose(file);
364 return false;
365 }
366 fclose(file);
367 }
368 }
369
370 return true;
371 }
372
373 static bool read_chain_(FLAC::Metadata::Chain &chain, const char *filename, bool filename_based, bool is_ogg)
374 {
375 if(filename_based)
376 return chain.read(filename, is_ogg);
377 else {
378 ::FLAC__IOCallbacks callbacks;
379
380 memset(&callbacks, 0, sizeof(callbacks));
381 callbacks.read = (::FLAC__IOCallback_Read)fread;
382 callbacks.seek = chain_seek_cb_;
383 callbacks.tell = chain_tell_cb_;
384
385 {
386 bool ret;
387 FILE *file = fopen(filename, "rb");
388 if(0 == file)
389 return false; /*@@@@ chain status still says OK though */
390 ret = chain.read((::FLAC__IOHandle)file, callbacks, is_ogg);
391 fclose(file);
392 return ret;
393 }
394 }
395 }
396
397 /* function for comparing our metadata to a FLAC::Metadata::Chain */
398
399 static bool compare_chain_(FLAC::Metadata::Chain &chain, unsigned current_position, FLAC::Metadata::Prototype *current_block)
400 {
401 unsigned i;
402 FLAC::Metadata::Iterator iterator;
403 bool next_ok = true;
404
405 printf("\tcomparing chain... ");
406 fflush(stdout);
407
408 if(!iterator.is_valid())
409 return die_("allocating memory for iterator");
410
411 iterator.init(chain);
412
413 i = 0;
414 do {
415 FLAC::Metadata::Prototype *block;
416
417 printf("%u... ", i);
418 fflush(stdout);
419
420 if(0 == (block = iterator.get_block()))
421 return die_("getting block from iterator");
422
423 if(*block != *our_metadata_.blocks[i])
424 return die_("metadata block mismatch");
425
426 delete block;
427 i++;
428 next_ok = iterator.next();
429 } while(i < our_metadata_.num_blocks && next_ok);
430
431 if(next_ok)
432 return die_("chain has more blocks than expected");
433
434 if(i < our_metadata_.num_blocks)
435 return die_("short block count in chain");
436
437 if(0 != current_block) {
438 printf("CURRENT_POSITION... ");
439 fflush(stdout);
440
441 if(*current_block != *our_metadata_.blocks[current_position])
442 return die_("metadata block mismatch");
443 }
444
445 printf("PASSED\n");
446
447 return true;
448 }
449
450 ::FLAC__StreamDecoderWriteStatus OurFileDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[])
451 {
452 (void)buffer;
453
454 if(
455 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
456 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
457 ) {
458 printf("content... ");
459 fflush(stdout);
460 }
461
462 return ::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
463 }
464
465 void OurFileDecoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
466 {
467 /* don't bother checking if we've already hit an error */
468 if(error_occurred_)
469 return;
470
471 printf("%d... ", mc_our_block_number_);
472 fflush(stdout);
473
474 if(!ignore_metadata_) {
475 if(mc_our_block_number_ >= our_metadata_.num_blocks) {
476 (void)die_("got more metadata blocks than expected");
477 error_occurred_ = true;
478 }
479 else {
480 if(*our_metadata_.blocks[mc_our_block_number_] != metadata) {
481 (void)die_("metadata block mismatch");
482 error_occurred_ = true;
483 }
484 }
485 }
486
487 mc_our_block_number_++;
488 }
489
490 void OurFileDecoder::error_callback(::FLAC__StreamDecoderErrorStatus status)
491 {
492 error_occurred_ = true;
493 printf("ERROR: got error callback, status = %s (%u)\n", FLAC__StreamDecoderErrorStatusString[status], (unsigned)status);
494 }
495
496 static bool generate_file_(bool include_extras, bool is_ogg)
497 {
498 ::FLAC__StreamMetadata streaminfo, vorbiscomment, *cuesheet, picture, padding;
499 ::FLAC__StreamMetadata *metadata[4];
500 unsigned i = 0, n = 0;
501
502 printf("generating %sFLAC file for test\n", is_ogg? "Ogg " : "");
503
504 while(our_metadata_.num_blocks > 0)
505 delete_from_our_metadata_(0);
506
507 streaminfo.is_last = false;
508 streaminfo.type = ::FLAC__METADATA_TYPE_STREAMINFO;
509 streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
510 streaminfo.data.stream_info.min_blocksize = 576;
511 streaminfo.data.stream_info.max_blocksize = 576;
512 streaminfo.data.stream_info.min_framesize = 0;
513 streaminfo.data.stream_info.max_framesize = 0;
514 streaminfo.data.stream_info.sample_rate = 44100;
515 streaminfo.data.stream_info.channels = 1;
516 streaminfo.data.stream_info.bits_per_sample = 8;
517 streaminfo.data.stream_info.total_samples = 0;
518 memset(streaminfo.data.stream_info.md5sum, 0, 16);
519
520 {
521 const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
522 vorbiscomment.is_last = false;
523 vorbiscomment.type = ::FLAC__METADATA_TYPE_VORBIS_COMMENT;
524 vorbiscomment.length = (4 + vendor_string_length) + 4;
525 vorbiscomment.data.vorbis_comment.vendor_string.length = vendor_string_length;
526 vorbiscomment.data.vorbis_comment.vendor_string.entry = (FLAC__byte*)malloc_or_die_(vendor_string_length+1);
527 memcpy(vorbiscomment.data.vorbis_comment.vendor_string.entry, FLAC__VENDOR_STRING, vendor_string_length+1);
528 vorbiscomment.data.vorbis_comment.num_comments = 0;
529 vorbiscomment.data.vorbis_comment.comments = 0;
530 }
531
532 {
533 if (0 == (cuesheet = ::FLAC__metadata_object_new(::FLAC__METADATA_TYPE_CUESHEET)))
534 return die_("priming our metadata");
535 cuesheet->is_last = false;
536 strcpy(cuesheet->data.cue_sheet.media_catalog_number, "bogo-MCN");
537 cuesheet->data.cue_sheet.lead_in = 123;
538 cuesheet->data.cue_sheet.is_cd = false;
539 if (!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, 0))
540 return die_("priming our metadata");
541 cuesheet->data.cue_sheet.tracks[0].number = 1;
542 if (!FLAC__metadata_object_cuesheet_track_insert_blank_index(cuesheet, 0, 0))
543 return die_("priming our metadata");
544 }
545
546 {
547 picture.is_last = false;
548 picture.type = ::FLAC__METADATA_TYPE_PICTURE;
549 picture.length =
550 (
551 FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
552 FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* will add the length for the string later */
553 FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* will add the length for the string later */
554 FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
555 FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
556 FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
557 FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
558 FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN /* will add the length for the data later */
559 ) / 8
560 ;
561 picture.data.picture.type = ::FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER;
562 picture.data.picture.mime_type = strdup_or_die_("image/jpeg");
563 picture.length += strlen(picture.data.picture.mime_type);
564 picture.data.picture.description = (FLAC__byte*)strdup_or_die_("desc");
565 picture.length += strlen((const char *)picture.data.picture.description);
566 picture.data.picture.width = 300;
567 picture.data.picture.height = 300;
568 picture.data.picture.depth = 24;
569 picture.data.picture.colors = 0;
570 picture.data.picture.data = (FLAC__byte*)strdup_or_die_("SOMEJPEGDATA");
571 picture.data.picture.data_length = strlen((const char *)picture.data.picture.data);
572 picture.length += picture.data.picture.data_length;
573 }
574
575 padding.is_last = true;
576 padding.type = ::FLAC__METADATA_TYPE_PADDING;
577 padding.length = 1234;
578
579 metadata[n++] = &vorbiscomment;
580 if(include_extras) {
581 metadata[n++] = cuesheet;
582 metadata[n++] = &picture;
583 }
584 metadata[n++] = &padding;
585
586 FLAC::Metadata::StreamInfo s(&streaminfo);
587 FLAC::Metadata::VorbisComment v(&vorbiscomment);
588 FLAC::Metadata::CueSheet c(cuesheet, /*copy=*/false);
589 FLAC::Metadata::Picture pi(&picture);
590 FLAC::Metadata::Padding p(&padding);
591 if(
592 !insert_to_our_metadata_(&s, i++, /*copy=*/true) ||
593 !insert_to_our_metadata_(&v, i++, /*copy=*/true) ||
594 (include_extras && !insert_to_our_metadata_(&c, i++, /*copy=*/true)) ||
595 (include_extras && !insert_to_our_metadata_(&pi, i++, /*copy=*/true)) ||
596 !insert_to_our_metadata_(&p, i++, /*copy=*/true)
597 )
598 return die_("priming our metadata");
599
600 if(!file_utils__generate_flacfile(is_ogg, flacfilename(is_ogg), 0, 512 * 1024, &streaminfo, metadata, n))
601 return die_("creating the encoded file");
602
603 free(vorbiscomment.data.vorbis_comment.vendor_string.entry);
604 free(picture.data.picture.mime_type);
605 free(picture.data.picture.description);
606 free(picture.data.picture.data);
607
608 return true;
609 }
610
611 static bool test_file_(bool is_ogg, bool ignore_metadata)
612 {
613 const char *filename = flacfilename(is_ogg);
614 OurFileDecoder decoder(ignore_metadata);
615
616 mc_our_block_number_ = 0;
617 decoder.error_occurred_ = false;
618
619 printf("\ttesting '%s'... ", filename);
620 fflush(stdout);
621
622 if(!decoder.is_valid())
623 return die_("couldn't allocate decoder instance");
624
625 decoder.set_md5_checking(true);
626 decoder.set_metadata_respond_all();
627 if((is_ogg? decoder.init_ogg(filename) : decoder.init(filename)) != ::FLAC__STREAM_DECODER_INIT_STATUS_OK) {
628 (void)decoder.finish();
629 return die_("initializing decoder\n");
630 }
631 if(!decoder.process_until_end_of_stream()) {
632 (void)decoder.finish();
633 return die_("decoding file\n");
634 }
635
636 (void)decoder.finish();
637
638 if(decoder.error_occurred_)
639 return false;
640
641 if(mc_our_block_number_ != our_metadata_.num_blocks)
642 return die_("short metadata block count");
643
644 printf("PASSED\n");
645 return true;
646 }
647
648 static bool change_stats_(const char *filename, bool read_only)
649 {
650 if(!grabbag__file_change_stats(filename, read_only))
651 return die_("during grabbag__file_change_stats()");
652
653 return true;
654 }
655
656 static bool remove_file_(const char *filename)
657 {
658 while(our_metadata_.num_blocks > 0)
659 delete_from_our_metadata_(0);
660
661 if(!grabbag__file_remove_file(filename))
662 return die_("removing file");
663
664 return true;
665 }
666
667 static bool test_level_0_()
668 {
669 FLAC::Metadata::StreamInfo streaminfo;
670
671 printf("\n\n++++++ testing level 0 interface\n");
672
673 if(!generate_file_(/*include_extras=*/true, /*is_ogg=*/false))
674 return false;
675
676 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/true))
677 return false;
678
679 printf("testing FLAC::Metadata::get_streaminfo()... ");
680
681 if(!FLAC::Metadata::get_streaminfo(flacfilename(/*is_ogg=*/false), streaminfo))
682 return die_("during FLAC::Metadata::get_streaminfo()");
683
684 /* check to see if some basic data matches (c.f. generate_file_()) */
685 if(streaminfo.get_channels() != 1)
686 return die_("mismatch in streaminfo.get_channels()");
687 if(streaminfo.get_bits_per_sample() != 8)
688 return die_("mismatch in streaminfo.get_bits_per_sample()");
689 if(streaminfo.get_sample_rate() != 44100)
690 return die_("mismatch in streaminfo.get_sample_rate()");
691 if(streaminfo.get_min_blocksize() != 576)
692 return die_("mismatch in streaminfo.get_min_blocksize()");
693 if(streaminfo.get_max_blocksize() != 576)
694 return die_("mismatch in streaminfo.get_max_blocksize()");
695
696 printf("OK\n");
697
698 {
699 printf("testing FLAC::Metadata::get_tags(VorbisComment *&)... ");
700
701 FLAC::Metadata::VorbisComment *tags = 0;
702
703 if(!FLAC::Metadata::get_tags(flacfilename(/*is_ogg=*/false), tags))
704 return die_("during FLAC::Metadata::get_tags()");
705
706 /* check to see if some basic data matches (c.f. generate_file_()) */
707 if(tags->get_num_comments() != 0)
708 return die_("mismatch in tags->get_num_comments()");
709
710 printf("OK\n");
711
712 delete tags;
713 }
714
715 {
716 printf("testing FLAC::Metadata::get_tags(VorbisComment &)... ");
717
718 FLAC::Metadata::VorbisComment tags;
719
720 if(!FLAC::Metadata::get_tags(flacfilename(/*is_ogg=*/false), tags))
721 return die_("during FLAC::Metadata::get_tags()");
722
723 /* check to see if some basic data matches (c.f. generate_file_()) */
724 if(tags.get_num_comments() != 0)
725 return die_("mismatch in tags.get_num_comments()");
726
727 printf("OK\n");
728 }
729
730 {
731 printf("testing FLAC::Metadata::get_cuesheet(CueSheet *&)... ");
732
733 FLAC::Metadata::CueSheet *cuesheet = 0;
734
735 if(!FLAC::Metadata::get_cuesheet(flacfilename(/*is_ogg=*/false), cuesheet))
736 return die_("during FLAC::Metadata::get_cuesheet()");
737
738 /* check to see if some basic data matches (c.f. generate_file_()) */
739 if(cuesheet->get_lead_in() != 123)
740 return die_("mismatch in cuesheet->get_lead_in()");
741
742 printf("OK\n");
743
744 delete cuesheet;
745 }
746
747 {
748 printf("testing FLAC::Metadata::get_cuesheet(CueSheet &)... ");
749
750 FLAC::Metadata::CueSheet cuesheet;
751
752 if(!FLAC::Metadata::get_cuesheet(flacfilename(/*is_ogg=*/false), cuesheet))
753 return die_("during FLAC::Metadata::get_cuesheet()");
754
755 /* check to see if some basic data matches (c.f. generate_file_()) */
756 if(cuesheet.get_lead_in() != 123)
757 return die_("mismatch in cuesheet.get_lead_in()");
758
759 printf("OK\n");
760 }
761
762 {
763 printf("testing FLAC::Metadata::get_picture(Picture *&)... ");
764
765 FLAC::Metadata::Picture *picture = 0;
766
767 if(!FLAC::Metadata::get_picture(flacfilename(/*is_ogg=*/false), picture, /*type=*/(::FLAC__StreamMetadata_Picture_Type)(-1), /*mime_type=*/0, /*description=*/0, /*max_width=*/(unsigned)(-1), /*max_height=*/(unsigned)(-1), /*max_depth=*/(unsigned)(-1), /*max_colors=*/(unsigned)(-1)))
768 return die_("during FLAC::Metadata::get_picture()");
769
770 /* check to see if some basic data matches (c.f. generate_file_()) */
771 if(picture->get_type () != ::FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER)
772 return die_("mismatch in picture->get_type ()");
773
774 printf("OK\n");
775
776 delete picture;
777 }
778
779 {
780 printf("testing FLAC::Metadata::get_picture(Picture &)... ");
781
782 FLAC::Metadata::Picture picture;
783
784 if(!FLAC::Metadata::get_picture(flacfilename(/*is_ogg=*/false), picture, /*type=*/(::FLAC__StreamMetadata_Picture_Type)(-1), /*mime_type=*/0, /*description=*/0, /*max_width=*/(unsigned)(-1), /*max_height=*/(unsigned)(-1), /*max_depth=*/(unsigned)(-1), /*max_colors=*/(unsigned)(-1)))
785 return die_("during FLAC::Metadata::get_picture()");
786
787 /* check to see if some basic data matches (c.f. generate_file_()) */
788 if(picture.get_type () != ::FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER)
789 return die_("mismatch in picture->get_type ()");
790
791 printf("OK\n");
792 }
793
794 if(!remove_file_(flacfilename(/*is_ogg=*/false)))
795 return false;
796
797 return true;
798 }
799
800 static bool test_level_1_()
801 {
802 FLAC::Metadata::Prototype *block;
803 FLAC::Metadata::StreamInfo *streaminfo;
804 FLAC::Metadata::Padding *padding;
805 FLAC::Metadata::Application *app;
806 FLAC__byte data[1000];
807 unsigned our_current_position = 0;
808
809 // initialize 'data' to avoid Valgrind errors
810 memset(data, 0, sizeof(data));
811
812 printf("\n\n++++++ testing level 1 interface\n");
813
814 /************************************************************/
815 {
816 printf("simple iterator on read-only file\n");
817
818 if(!generate_file_(/*include_extras=*/false, /*is_ogg=*/false))
819 return false;
820
821 if(!change_stats_(flacfilename(/*is_ogg=*/false), /*read_only=*/true))
822 return false;
823
824 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/true))
825 return false;
826
827 FLAC::Metadata::SimpleIterator iterator;
828
829 if(!iterator.is_valid())
830 return die_("iterator.is_valid() returned false");
831
832 if(!iterator.init(flacfilename(/*is_ogg=*/false), /*read_only=*/false, /*preserve_file_stats=*/false))
833 return die_("iterator.init() returned false");
834
835 printf("is writable = %u\n", (unsigned)iterator.is_writable());
836 if(iterator.is_writable())
837 return die_("iterator claims file is writable when tester thinks it should not be; are you running as root?\n");
838
839 printf("iterate forwards\n");
840
841 if(iterator.get_block_type() != ::FLAC__METADATA_TYPE_STREAMINFO)
842 return die_("expected STREAMINFO type from iterator.get_block_type()");
843 if(0 == (block = iterator.get_block()))
844 return die_("getting block 0");
845 if(block->get_type() != ::FLAC__METADATA_TYPE_STREAMINFO)
846 return die_("expected STREAMINFO type");
847 if(block->get_is_last())
848 return die_("expected is_last to be false");
849 if(block->get_length() != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
850 return die_("bad STREAMINFO length");
851 /* check to see if some basic data matches (c.f. generate_file_()) */
852 streaminfo = dynamic_cast<FLAC::Metadata::StreamInfo *>(block);
853 FLAC__ASSERT(0 != streaminfo);
854 if(streaminfo->get_channels() != 1)
855 return die_("mismatch in channels");
856 if(streaminfo->get_bits_per_sample() != 8)
857 return die_("mismatch in bits_per_sample");
858 if(streaminfo->get_sample_rate() != 44100)
859 return die_("mismatch in sample_rate");
860 if(streaminfo->get_min_blocksize() != 576)
861 return die_("mismatch in min_blocksize");
862 if(streaminfo->get_max_blocksize() != 576)
863 return die_("mismatch in max_blocksize");
864 // we will delete streaminfo a little later when we're really done with it...
865
866 if(!iterator.next())
867 return die_("forward iterator ended early");
868 our_current_position++;
869
870 if(!iterator.next())
871 return die_("forward iterator ended early");
872 our_current_position++;
873
874 if(iterator.get_block_type() != ::FLAC__METADATA_TYPE_PADDING)
875 return die_("expected PADDING type from iterator.get_block_type()");
876 if(0 == (block = iterator.get_block()))
877 return die_("getting block 1");
878 if(block->get_type() != ::FLAC__METADATA_TYPE_PADDING)
879 return die_("expected PADDING type");
880 if(!block->get_is_last())
881 return die_("expected is_last to be true");
882 /* check to see if some basic data matches (c.f. generate_file_()) */
883 if(block->get_length() != 1234)
884 return die_("bad PADDING length");
885 delete block;
886
887 if(iterator.next())
888 return die_("forward iterator returned true but should have returned false");
889
890 printf("iterate backwards\n");
891 if(!iterator.prev())
892 return die_("reverse iterator ended early");
893 if(!iterator.prev())
894 return die_("reverse iterator ended early");
895 if(iterator.prev())
896 return die_("reverse iterator returned true but should have returned false");
897
898 printf("testing iterator.set_block() on read-only file...\n");
899
900 if(!iterator.set_block(streaminfo, false))
901 printf("PASSED. iterator.set_block() returned false like it should\n");
902 else
903 return die_("iterator.set_block() returned true but shouldn't have");
904 delete streaminfo;
905 }
906
907 /************************************************************/
908 {
909 printf("simple iterator on writable file\n");
910
911 if(!change_stats_(flacfilename(/*is_ogg=*/false), /*read-only=*/false))
912 return false;
913
914 printf("creating APPLICATION block\n");
915
916 if(0 == (app = new FLAC::Metadata::Application()))
917 return die_("new FLAC::Metadata::Application()");
918 app->set_id((const unsigned char *)"duh");
919
920 printf("creating PADDING block\n");
921
922 if(0 == (padding = new FLAC::Metadata::Padding()))
923 return die_("new FLAC::Metadata::Padding()");
924 padding->set_length(20);
925
926 FLAC::Metadata::SimpleIterator iterator;
927
928 if(!iterator.is_valid())
929 return die_("iterator.is_valid() returned false");
930
931 if(!iterator.init(flacfilename(/*is_ogg=*/false), /*read_only=*/false, /*preserve_file_stats=*/false))
932 return die_("iterator.init() returned false");
933 our_current_position = 0;
934
935 printf("is writable = %u\n", (unsigned)iterator.is_writable());
936
937 printf("[S]VP\ttry to write over STREAMINFO block...\n");
938 if(!iterator.set_block(app, false))
939 printf("\titerator.set_block() returned false like it should\n");
940 else
941 return die_("iterator.set_block() returned true but shouldn't have");
942
943 printf("[S]VP\tnext\n");
944 if(!iterator.next())
945 return die_("iterator ended early\n");
946 our_current_position++;
947
948 printf("S[V]P\tnext\n");
949 if(!iterator.next())
950 return die_("iterator ended early\n");
951 our_current_position++;
952
953 printf("SV[P]\tinsert PADDING after, don't expand into padding\n");
954 padding->set_length(25);
955 if(!iterator.insert_block_after(padding, false))
956 return die_ss_("iterator.insert_block_after(padding, false)", iterator);
957 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
958 return false;
959
960 printf("SVP[P]\tprev\n");
961 if(!iterator.prev())
962 return die_("iterator ended early\n");
963 our_current_position--;
964
965 printf("SV[P]P\tprev\n");
966 if(!iterator.prev())
967 return die_("iterator ended early\n");
968 our_current_position--;
969
970 printf("S[V]PP\tinsert PADDING after, don't expand into padding\n");
971 padding->set_length(30);
972 if(!iterator.insert_block_after(padding, false))
973 return die_ss_("iterator.insert_block_after(padding, false)", iterator);
974 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
975 return false;
976
977 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
978 return false;
979
980 printf("SV[P]PP\tprev\n");
981 if(!iterator.prev())
982 return die_("iterator ended early\n");
983 our_current_position--;
984
985 printf("S[V]PPP\tprev\n");
986 if(!iterator.prev())
987 return die_("iterator ended early\n");
988 our_current_position--;
989
990 printf("[S]VPPP\tdelete (STREAMINFO block), must fail\n");
991 if(iterator.delete_block(false))
992 return die_ss_("iterator.delete_block(false) should have returned false", iterator);
993
994 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
995 return false;
996
997 printf("[S]VPPP\tnext\n");
998 if(!iterator.next())
999 return die_("iterator ended early\n");
1000 our_current_position++;
1001
1002 printf("S[V]PPP\tnext\n");
1003 if(!iterator.next())
1004 return die_("iterator ended early\n");
1005 our_current_position++;
1006
1007 printf("SV[P]PP\tdelete (middle block), replace with padding\n");
1008 if(!iterator.delete_block(true))
1009 return die_ss_("iterator.delete_block(true)", iterator);
1010 our_current_position--;
1011
1012 printf("S[V]PPP\tnext\n");
1013 if(!iterator.next())
1014 return die_("iterator ended early\n");
1015 our_current_position++;
1016
1017 printf("SV[P]PP\tdelete (middle block), don't replace with padding\n");
1018 if(!iterator.delete_block(false))
1019 return die_ss_("iterator.delete_block(false)", iterator);
1020 delete_from_our_metadata_(our_current_position--);
1021
1022 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1023 return false;
1024
1025 printf("S[V]PP\tnext\n");
1026 if(!iterator.next())
1027 return die_("iterator ended early\n");
1028 our_current_position++;
1029
1030 printf("SV[P]P\tnext\n");
1031 if(!iterator.next())
1032 return die_("iterator ended early\n");
1033 our_current_position++;
1034
1035 printf("SVP[P]\tdelete (last block), replace with padding\n");
1036 if(!iterator.delete_block(true))
1037 return die_ss_("iterator.delete_block(false)", iterator);
1038 our_current_position--;
1039
1040 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1041 return false;
1042
1043 printf("SV[P]P\tnext\n");
1044 if(!iterator.next())
1045 return die_("iterator ended early\n");
1046 our_current_position++;
1047
1048 printf("SVP[P]\tdelete (last block), don't replace with padding\n");
1049 if(!iterator.delete_block(false))
1050 return die_ss_("iterator.delete_block(false)", iterator);
1051 delete_from_our_metadata_(our_current_position--);
1052
1053 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1054 return false;
1055
1056 printf("SV[P]\tprev\n");
1057 if(!iterator.prev())
1058 return die_("iterator ended early\n");
1059 our_current_position--;
1060
1061 printf("S[V]P\tprev\n");
1062 if(!iterator.prev())
1063 return die_("iterator ended early\n");
1064 our_current_position--;
1065
1066 printf("[S]VP\tset STREAMINFO (change sample rate)\n");
1067 FLAC__ASSERT(our_current_position == 0);
1068 block = iterator.get_block();
1069 streaminfo = dynamic_cast<FLAC::Metadata::StreamInfo *>(block);
1070 FLAC__ASSERT(0 != streaminfo);
1071 streaminfo->set_sample_rate(32000);
1072 if(!replace_in_our_metadata_(block, our_current_position, /*copy=*/true))
1073 return die_("copying object");
1074 if(!iterator.set_block(block, false))
1075 return die_ss_("iterator.set_block(block, false)", iterator);
1076 delete block;
1077
1078 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1079 return false;
1080
1081 printf("[S]VP\tnext\n");
1082 if(!iterator.next())
1083 return die_("iterator ended early\n");
1084 our_current_position++;
1085
1086 printf("S[V]P\tinsert APPLICATION after, expand into padding of exceeding size\n");
1087 app->set_id((const unsigned char *)"euh"); /* twiddle the id so that our comparison doesn't miss transposition */
1088 if(!iterator.insert_block_after(app, true))
1089 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1090 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1091 return false;
1092 add_to_padding_length_(our_current_position+1, -((int)(FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) + (int)app->get_length()));
1093
1094 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1095 return false;
1096
1097 printf("SV[A]P\tnext\n");
1098 if(!iterator.next())
1099 return die_("iterator ended early\n");
1100 our_current_position++;
1101
1102 printf("SVA[P]\tset APPLICATION, expand into padding of exceeding size\n");
1103 app->set_id((const unsigned char *)"fuh"); /* twiddle the id */
1104 if(!iterator.set_block(app, true))
1105 return die_ss_("iterator.set_block(app, true)", iterator);
1106 if(!insert_to_our_metadata_(app, our_current_position, /*copy=*/true))
1107 return false;
1108 add_to_padding_length_(our_current_position+1, -((int)(FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) + (int)app->get_length()));
1109
1110 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1111 return false;
1112
1113 printf("SVA[A]P\tset APPLICATION (grow), don't expand into padding\n");
1114 app->set_id((const unsigned char *)"guh"); /* twiddle the id */
1115 if(!app->set_data(data, sizeof(data), true))
1116 return die_("setting APPLICATION data");
1117 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1118 return die_("copying object");
1119 if(!iterator.set_block(app, false))
1120 return die_ss_("iterator.set_block(app, false)", iterator);
1121
1122 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1123 return false;
1124
1125 printf("SVA[A]P\tset APPLICATION (shrink), don't fill in with padding\n");
1126 app->set_id((const unsigned char *)"huh"); /* twiddle the id */
1127 if(!app->set_data(data, 12, true))
1128 return die_("setting APPLICATION data");
1129 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1130 return die_("copying object");
1131 if(!iterator.set_block(app, false))
1132 return die_ss_("iterator.set_block(app, false)", iterator);
1133
1134 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1135 return false;
1136
1137 printf("SVA[A]P\tset APPLICATION (grow), expand into padding of exceeding size\n");
1138 app->set_id((const unsigned char *)"iuh"); /* twiddle the id */
1139 if(!app->set_data(data, sizeof(data), true))
1140 return die_("setting APPLICATION data");
1141 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1142 return die_("copying object");
1143 add_to_padding_length_(our_current_position+1, -((int)sizeof(data) - 12));
1144 if(!iterator.set_block(app, true))
1145 return die_ss_("iterator.set_block(app, true)", iterator);
1146
1147 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1148 return false;
1149
1150 printf("SVA[A]P\tset APPLICATION (shrink), fill in with padding\n");
1151 app->set_id((const unsigned char *)"juh"); /* twiddle the id */
1152 if(!app->set_data(data, 23, true))
1153 return die_("setting APPLICATION data");
1154 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1155 return die_("copying object");
1156 if(!insert_to_our_metadata_(padding, our_current_position+1, /*copy=*/true))
1157 return die_("copying object");
1158 dynamic_cast<FLAC::Metadata::Padding *>(our_metadata_.blocks[our_current_position+1])->set_length(sizeof(data) - 23 - FLAC__STREAM_METADATA_HEADER_LENGTH);
1159 if(!iterator.set_block(app, true))
1160 return die_ss_("iterator.set_block(app, true)", iterator);
1161
1162 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1163 return false;
1164
1165 printf("SVA[A]PP\tnext\n");
1166 if(!iterator.next())
1167 return die_("iterator ended early\n");
1168 our_current_position++;
1169
1170 printf("SVAA[P]P\tnext\n");
1171 if(!iterator.next())
1172 return die_("iterator ended early\n");
1173 our_current_position++;
1174
1175 printf("SVAAP[P]\tset PADDING (shrink), don't fill in with padding\n");
1176 padding->set_length(5);
1177 if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
1178 return die_("copying object");
1179 if(!iterator.set_block(padding, false))
1180 return die_ss_("iterator.set_block(padding, false)", iterator);
1181
1182 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1183 return false;
1184
1185 printf("SVAAP[P]\tset APPLICATION (grow)\n");
1186 app->set_id((const unsigned char *)"kuh"); /* twiddle the id */
1187 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1188 return die_("copying object");
1189 if(!iterator.set_block(app, false))
1190 return die_ss_("iterator.set_block(app, false)", iterator);
1191
1192 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1193 return false;
1194
1195 printf("SVAAP[A]\tset PADDING (equal)\n");
1196 padding->set_length(27);
1197 if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
1198 return die_("copying object");
1199 if(!iterator.set_block(padding, false))
1200 return die_ss_("iterator.set_block(padding, false)", iterator);
1201
1202 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1203 return false;
1204
1205 printf("SVAAP[P]\tprev\n");
1206 if(!iterator.prev())
1207 return die_("iterator ended early\n");
1208 our_current_position--;
1209
1210 printf("SVAA[P]P\tdelete (middle block), don't replace with padding\n");
1211 if(!iterator.delete_block(false))
1212 return die_ss_("iterator.delete_block(false)", iterator);
1213 delete_from_our_metadata_(our_current_position--);
1214
1215 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1216 return false;
1217
1218 printf("SVA[A]P\tdelete (middle block), don't replace with padding\n");
1219 if(!iterator.delete_block(false))
1220 return die_ss_("iterator.delete_block(false)", iterator);
1221 delete_from_our_metadata_(our_current_position--);
1222
1223 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1224 return false;
1225
1226 printf("SV[A]P\tnext\n");
1227 if(!iterator.next())
1228 return die_("iterator ended early\n");
1229 our_current_position++;
1230
1231 printf("SVA[P]\tinsert PADDING after\n");
1232 padding->set_length(5);
1233 if(!iterator.insert_block_after(padding, false))
1234 return die_ss_("iterator.insert_block_after(padding, false)", iterator);
1235 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
1236 return false;
1237
1238 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1239 return false;
1240
1241 printf("SVAP[P]\tprev\n");
1242 if(!iterator.prev())
1243 return die_("iterator ended early\n");
1244 our_current_position--;
1245
1246 printf("SVA[P]P\tprev\n");
1247 if(!iterator.prev())
1248 return die_("iterator ended early\n");
1249 our_current_position--;
1250
1251 printf("SV[A]PP\tset APPLICATION (grow), try to expand into padding which is too small\n");
1252 if(!app->set_data(data, 32, true))
1253 return die_("setting APPLICATION data");
1254 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1255 return die_("copying object");
1256 if(!iterator.set_block(app, true))
1257 return die_ss_("iterator.set_block(app, true)", iterator);
1258
1259 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1260 return false;
1261
1262 printf("SV[A]PP\tset APPLICATION (grow), try to expand into padding which is 'close' but still too small\n");
1263 if(!app->set_data(data, 60, true))
1264 return die_("setting APPLICATION data");
1265 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1266 return die_("copying object");
1267 if(!iterator.set_block(app, true))
1268 return die_ss_("iterator.set_block(app, true)", iterator);
1269
1270 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1271 return false;
1272
1273 printf("SV[A]PP\tset APPLICATION (grow), expand into padding which will leave 0-length pad\n");
1274 if(!app->set_data(data, 87, true))
1275 return die_("setting APPLICATION data");
1276 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1277 return die_("copying object");
1278 dynamic_cast<FLAC::Metadata::Padding *>(our_metadata_.blocks[our_current_position+1])->set_length(0);
1279 if(!iterator.set_block(app, true))
1280 return die_ss_("iterator.set_block(app, true)", iterator);
1281
1282 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1283 return false;
1284
1285 printf("SV[A]PP\tset APPLICATION (grow), expand into padding which is exactly consumed\n");
1286 if(!app->set_data(data, 91, true))
1287 return die_("setting APPLICATION data");
1288 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1289 return die_("copying object");
1290 delete_from_our_metadata_(our_current_position+1);
1291 if(!iterator.set_block(app, true))
1292 return die_ss_("iterator.set_block(app, true)", iterator);
1293
1294 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1295 return false;
1296
1297 printf("SV[A]P\tset APPLICATION (grow), expand into padding which is exactly consumed\n");
1298 if(!app->set_data(data, 100, true))
1299 return die_("setting APPLICATION data");
1300 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1301 return die_("copying object");
1302 delete_from_our_metadata_(our_current_position+1);
1303 our_metadata_.blocks[our_current_position]->set_is_last(true);
1304 if(!iterator.set_block(app, true))
1305 return die_ss_("iterator.set_block(app, true)", iterator);
1306
1307 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1308 return false;
1309
1310 printf("SV[A]\tset PADDING (equal size)\n");
1311 padding->set_length(app->get_length());
1312 if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
1313 return die_("copying object");
1314 if(!iterator.set_block(padding, true))
1315 return die_ss_("iterator.set_block(padding, true)", iterator);
1316
1317 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1318 return false;
1319
1320 printf("SV[P]\tinsert PADDING after\n");
1321 if(!iterator.insert_block_after(padding, false))
1322 return die_ss_("iterator.insert_block_after(padding, false)", iterator);
1323 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
1324 return false;
1325
1326 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1327 return false;
1328
1329 printf("SVP[P]\tinsert PADDING after\n");
1330 padding->set_length(5);
1331 if(!iterator.insert_block_after(padding, false))
1332 return die_ss_("iterator.insert_block_after(padding, false)", iterator);
1333 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
1334 return false;
1335
1336 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1337 return false;
1338
1339 printf("SVPP[P]\tprev\n");
1340 if(!iterator.prev())
1341 return die_("iterator ended early\n");
1342 our_current_position--;
1343
1344 printf("SVP[P]P\tprev\n");
1345 if(!iterator.prev())
1346 return die_("iterator ended early\n");
1347 our_current_position--;
1348
1349 printf("SV[P]PP\tprev\n");
1350 if(!iterator.prev())
1351 return die_("iterator ended early\n");
1352 our_current_position--;
1353
1354 printf("S[V]PPP\tinsert APPLICATION after, try to expand into padding which is too small\n");
1355 if(!app->set_data(data, 101, true))
1356 return die_("setting APPLICATION data");
1357 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1358 return die_("copying object");
1359 if(!iterator.insert_block_after(app, true))
1360 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1361
1362 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1363 return false;
1364
1365 printf("SV[A]PPP\tdelete (middle block), don't replace with padding\n");
1366 if(!iterator.delete_block(false))
1367 return die_ss_("iterator.delete_block(false)", iterator);
1368 delete_from_our_metadata_(our_current_position--);
1369
1370 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1371 return false;
1372
1373 printf("S[V]PPP\tinsert APPLICATION after, try to expand into padding which is 'close' but still too small\n");
1374 if(!app->set_data(data, 97, true))
1375 return die_("setting APPLICATION data");
1376 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1377 return die_("copying object");
1378 if(!iterator.insert_block_after(app, true))
1379 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1380
1381 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1382 return false;
1383
1384 printf("SV[A]PPP\tdelete (middle block), don't replace with padding\n");
1385 if(!iterator.delete_block(false))
1386 return die_ss_("iterator.delete_block(false)", iterator);
1387 delete_from_our_metadata_(our_current_position--);
1388
1389 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1390 return false;
1391
1392 printf("S[V]PPP\tinsert APPLICATION after, expand into padding which is exactly consumed\n");
1393 if(!app->set_data(data, 100, true))
1394 return die_("setting APPLICATION data");
1395 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1396 return die_("copying object");
1397 delete_from_our_metadata_(our_current_position+1);
1398 if(!iterator.insert_block_after(app, true))
1399 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1400
1401 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1402 return false;
1403
1404 printf("SV[A]PP\tdelete (middle block), don't replace with padding\n");
1405 if(!iterator.delete_block(false))
1406 return die_ss_("iterator.delete_block(false)", iterator);
1407 delete_from_our_metadata_(our_current_position--);
1408
1409 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1410 return false;
1411
1412 printf("S[V]PP\tinsert APPLICATION after, expand into padding which will leave 0-length pad\n");
1413 if(!app->set_data(data, 96, true))
1414 return die_("setting APPLICATION data");
1415 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1416 return die_("copying object");
1417 dynamic_cast<FLAC::Metadata::Padding *>(our_metadata_.blocks[our_current_position+1])->set_length(0);
1418 if(!iterator.insert_block_after(app, true))
1419 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1420
1421 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1422 return false;
1423
1424 printf("SV[A]PP\tdelete (middle block), don't replace with padding\n");
1425 if(!iterator.delete_block(false))
1426 return die_ss_("iterator.delete_block(false)", iterator);
1427 delete_from_our_metadata_(our_current_position--);
1428
1429 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1430 return false;
1431
1432 printf("S[V]PP\tnext\n");
1433 if(!iterator.next())
1434 return die_("iterator ended early\n");
1435 our_current_position++;
1436
1437 printf("SV[P]P\tdelete (middle block), don't replace with padding\n");
1438 if(!iterator.delete_block(false))
1439 return die_ss_("iterator.delete_block(false)", iterator);
1440 delete_from_our_metadata_(our_current_position--);
1441
1442 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1443 return false;
1444
1445 printf("S[V]P\tinsert APPLICATION after, expand into padding which is exactly consumed\n");
1446 if(!app->set_data(data, 1, true))
1447 return die_("setting APPLICATION data");
1448 if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
1449 return die_("copying object");
1450 delete_from_our_metadata_(our_current_position+1);
1451 if(!iterator.insert_block_after(app, true))
1452 return die_ss_("iterator.insert_block_after(app, true)", iterator);
1453
1454 if(!test_file_(/*is_ogg=*/false, /*ignore_metadata=*/false))
1455 return false;
1456 }
1457
1458 delete app;
1459 delete padding;
1460
1461 if(!remove_file_(flacfilename(/*is_ogg=*/false)))
1462 return false;
1463
1464 return true;
1465 }
1466
1467 static bool test_level_2_(bool filename_based, bool is_ogg)
1468 {
1469 FLAC::Metadata::Prototype *block;
1470 FLAC::Metadata::StreamInfo *streaminfo;
1471 FLAC::Metadata::Application *app;
1472 FLAC::Metadata::Padding *padding;
1473 FLAC__byte data[2000];
1474 unsigned our_current_position;
1475
1476 // initialize 'data' to avoid Valgrind errors
1477 memset(data, 0, sizeof(data));
1478
1479 printf("\n\n++++++ testing level 2 interface (%s-based, %s FLAC)\n", filename_based? "filename":"callback", is_ogg? "Ogg":"native");
1480
1481 printf("generate read-only file\n");
1482
1483 if(!generate_file_(/*include_extras=*/false, is_ogg))
1484 return false;
1485
1486 if(!change_stats_(flacfilename(is_ogg), /*read_only=*/true))
1487 return false;
1488
1489 printf("create chain\n");
1490 FLAC::Metadata::Chain chain;
1491 if(!chain.is_valid())
1492 return die_("allocating memory for chain");
1493
1494 printf("read chain\n");
1495
1496 if(!read_chain_(chain, flacfilename(is_ogg), filename_based, is_ogg))
1497 return die_c_("reading chain", chain.status());
1498
1499 printf("[S]VP\ttest initial metadata\n");
1500
1501 if(!compare_chain_(chain, 0, 0))
1502 return false;
1503 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1504 return false;
1505
1506 if(is_ogg)
1507 goto end;
1508
1509 printf("switch file to read-write\n");
1510
1511 if(!change_stats_(flacfilename(is_ogg), /*read-only=*/false))
1512 return false;
1513
1514 printf("create iterator\n");
1515 {
1516 FLAC::Metadata::Iterator iterator;
1517 if(!iterator.is_valid())
1518 return die_("allocating memory for iterator");
1519
1520 our_current_position = 0;
1521
1522 iterator.init(chain);
1523
1524 if(0 == (block = iterator.get_block()))
1525 return die_("getting block from iterator");
1526
1527 FLAC__ASSERT(block->get_type() == FLAC__METADATA_TYPE_STREAMINFO);
1528
1529 printf("[S]VP\tmodify STREAMINFO, write\n");
1530
1531 streaminfo = dynamic_cast<FLAC::Metadata::StreamInfo *>(block);
1532 FLAC__ASSERT(0 != streaminfo);
1533 streaminfo->set_sample_rate(32000);
1534 if(!replace_in_our_metadata_(block, our_current_position, /*copy=*/true))
1535 return die_("copying object");
1536 delete block;
1537
1538 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/true, filename_based, flacfilename(is_ogg)))
1539 return die_c_("during chain.write(false, true)", chain.status());
1540 block = iterator.get_block();
1541 if(!compare_chain_(chain, our_current_position, block))
1542 return false;
1543 delete block;
1544 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1545 return false;
1546
1547 printf("[S]VP\tnext\n");
1548 if(!iterator.next())
1549 return die_("iterator ended early\n");
1550 our_current_position++;
1551
1552 printf("S[V]P\tnext\n");
1553 if(!iterator.next())
1554 return die_("iterator ended early\n");
1555 our_current_position++;
1556
1557 printf("SV[P]\treplace PADDING with identical-size APPLICATION\n");
1558 if(0 == (block = iterator.get_block()))
1559 return die_("getting block from iterator");
1560 if(0 == (app = new FLAC::Metadata::Application()))
1561 return die_("new FLAC::Metadata::Application()");
1562 app->set_id((const unsigned char *)"duh");
1563 if(!app->set_data(data, block->get_length()-(FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8), true))
1564 return die_("setting APPLICATION data");
1565 delete block;
1566 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1567 return die_("copying object");
1568 if(!iterator.set_block(app))
1569 return die_c_("iterator.set_block(app)", chain.status());
1570
1571 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1572 return die_c_("during chain.write(false, false)", chain.status());
1573 block = iterator.get_block();
1574 if(!compare_chain_(chain, our_current_position, block))
1575 return false;
1576 delete block;
1577 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1578 return false;
1579
1580 printf("SV[A]\tshrink APPLICATION, don't use padding\n");
1581 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1582 return die_("copying object");
1583 if(!app->set_data(data, 26, true))
1584 return die_("setting APPLICATION data");
1585 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1586 return die_("copying object");
1587 if(!iterator.set_block(app))
1588 return die_c_("iterator.set_block(app)", chain.status());
1589
1590 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1591 return die_c_("during chain.write(false, false)", chain.status());
1592 block = iterator.get_block();
1593 if(!compare_chain_(chain, our_current_position, block))
1594 return false;
1595 delete block;
1596 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1597 return false;
1598
1599 printf("SV[A]\tgrow APPLICATION, don't use padding\n");
1600 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1601 return die_("copying object");
1602 if(!app->set_data(data, 28, true))
1603 return die_("setting APPLICATION data");
1604 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1605 return die_("copying object");
1606 if(!iterator.set_block(app))
1607 return die_c_("iterator.set_block(app)", chain.status());
1608
1609 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1610 return die_c_("during chain.write(false, false)", chain.status());
1611 block = iterator.get_block();
1612 if(!compare_chain_(chain, our_current_position, block))
1613 return false;
1614 delete block;
1615 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1616 return false;
1617
1618 printf("SV[A]\tgrow APPLICATION, use padding, but last block is not padding\n");
1619 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1620 return die_("copying object");
1621 if(!app->set_data(data, 36, true))
1622 return die_("setting APPLICATION data");
1623 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1624 return die_("copying object");
1625 if(!iterator.set_block(app))
1626 return die_c_("iterator.set_block(app)", chain.status());
1627
1628 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1629 return die_c_("during chain.write(false, false)", chain.status());
1630 block = iterator.get_block();
1631 if(!compare_chain_(chain, our_current_position, block))
1632 return false;
1633 delete block;
1634 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1635 return false;
1636
1637 printf("SV[A]\tshrink APPLICATION, use padding, last block is not padding, but delta is too small for new PADDING block\n");
1638 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1639 return die_("copying object");
1640 if(!app->set_data(data, 33, true))
1641 return die_("setting APPLICATION data");
1642 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1643 return die_("copying object");
1644 if(!iterator.set_block(app))
1645 return die_c_("iterator.set_block(app)", chain.status());
1646
1647 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1648 return die_c_("during chain.write(true, false)", chain.status());
1649 block = iterator.get_block();
1650 if(!compare_chain_(chain, our_current_position, block))
1651 return false;
1652 delete block;
1653 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1654 return false;
1655
1656 printf("SV[A]\tshrink APPLICATION, use padding, last block is not padding, delta is enough for new PADDING block\n");
1657 if(0 == (padding = new FLAC::Metadata::Padding()))
1658 return die_("creating PADDING block");
1659 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1660 return die_("copying object");
1661 if(!app->set_data(data, 29, true))
1662 return die_("setting APPLICATION data");
1663 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1664 return die_("copying object");
1665 padding->set_length(0);
1666 if(!insert_to_our_metadata_(padding, our_current_position+1, /*copy=*/false))
1667 return die_("internal error");
1668 if(!iterator.set_block(app))
1669 return die_c_("iterator.set_block(app)", chain.status());
1670
1671 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1672 return die_c_("during chain.write(true, false)", chain.status());
1673 block = iterator.get_block();
1674 if(!compare_chain_(chain, our_current_position, block))
1675 return false;
1676 delete block;
1677 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1678 return false;
1679
1680 printf("SV[A]P\tshrink APPLICATION, use padding, last block is padding\n");
1681 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1682 return die_("copying object");
1683 if(!app->set_data(data, 16, true))
1684 return die_("setting APPLICATION data");
1685 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1686 return die_("copying object");
1687 dynamic_cast<FLAC::Metadata::Padding *>(our_metadata_.blocks[our_current_position+1])->set_length(13);
1688 if(!iterator.set_block(app))
1689 return die_c_("iterator.set_block(app)", chain.status());
1690
1691 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1692 return die_c_("during chain.write(true, false)", chain.status());
1693 block = iterator.get_block();
1694 if(!compare_chain_(chain, our_current_position, block))
1695 return false;
1696 delete block;
1697 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1698 return false;
1699
1700 printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding, but delta is too small\n");
1701 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1702 return die_("copying object");
1703 if(!app->set_data(data, 50, true))
1704 return die_("setting APPLICATION data");
1705 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1706 return die_("copying object");
1707 if(!iterator.set_block(app))
1708 return die_c_("iterator.set_block(app)", chain.status());
1709
1710 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1711 return die_c_("during chain.write(true, false)", chain.status());
1712 block = iterator.get_block();
1713 if(!compare_chain_(chain, our_current_position, block))
1714 return false;
1715 delete block;
1716 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1717 return false;
1718
1719 printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding of exceeding size\n");
1720 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1721 return die_("copying object");
1722 if(!app->set_data(data, 56, true))
1723 return die_("setting APPLICATION data");
1724 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1725 return die_("copying object");
1726 add_to_padding_length_(our_current_position+1, -(56 - 50));
1727 if(!iterator.set_block(app))
1728 return die_c_("iterator.set_block(app)", chain.status());
1729
1730 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1731 return die_c_("during chain.write(true, false)", chain.status());
1732 block = iterator.get_block();
1733 if(!compare_chain_(chain, our_current_position, block))
1734 return false;
1735 delete block;
1736 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1737 return false;
1738
1739 printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding of exact size\n");
1740 if(0 == (app = dynamic_cast<FLAC::Metadata::Application *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1741 return die_("copying object");
1742 if(!app->set_data(data, 67, true))
1743 return die_("setting APPLICATION data");
1744 if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
1745 return die_("copying object");
1746 delete_from_our_metadata_(our_current_position+1);
1747 if(!iterator.set_block(app))
1748 return die_c_("iterator.set_block(app)", chain.status());
1749
1750 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1751 return die_c_("during chain.write(true, false)", chain.status());
1752 block = iterator.get_block();
1753 if(!compare_chain_(chain, our_current_position, block))
1754 return false;
1755 delete block;
1756 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1757 return false;
1758
1759 printf("SV[A]\tprev\n");
1760 if(!iterator.prev())
1761 return die_("iterator ended early\n");
1762 our_current_position--;
1763
1764 printf("S[V]A\tprev\n");
1765 if(!iterator.prev())
1766 return die_("iterator ended early\n");
1767 our_current_position--;
1768
1769 printf("[S]VA\tinsert PADDING before STREAMINFO (should fail)\n");
1770 if(0 == (padding = new FLAC::Metadata::Padding()))
1771 return die_("creating PADDING block");
1772 padding->set_length(30);
1773 if(!iterator.insert_block_before(padding))
1774 printf("\titerator.insert_block_before() returned false like it should\n");
1775 else
1776 return die_("iterator.insert_block_before() should have returned false");
1777
1778 printf("[S]VA\tnext\n");
1779 if(!iterator.next())
1780 return die_("iterator ended early\n");
1781 our_current_position++;
1782
1783 printf("S[V]A\tinsert PADDING after\n");
1784 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
1785 return die_("copying metadata");
1786 if(!iterator.insert_block_after(padding))
1787 return die_("iterator.insert_block_after(padding)");
1788
1789 block = iterator.get_block();
1790 if(!compare_chain_(chain, our_current_position, block))
1791 return false;
1792 delete block;
1793
1794 printf("SV[P]A\tinsert PADDING before\n");
1795 if(0 == (padding = dynamic_cast<FLAC::Metadata::Padding *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1796 return die_("creating PADDING block");
1797 padding->set_length(17);
1798 if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
1799 return die_("copying metadata");
1800 if(!iterator.insert_block_before(padding))
1801 return die_("iterator.insert_block_before(padding)");
1802
1803 block = iterator.get_block();
1804 if(!compare_chain_(chain, our_current_position, block))
1805 return false;
1806 delete block;
1807
1808 printf("SV[P]PA\tinsert PADDING before\n");
1809 if(0 == (padding = dynamic_cast<FLAC::Metadata::Padding *>(FLAC::Metadata::clone(our_metadata_.blocks[our_current_position]))))
1810 return die_("creating PADDING block");
1811 padding->set_length(0);
1812 if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
1813 return die_("copying metadata");
1814 if(!iterator.insert_block_before(padding))
1815 return die_("iterator.insert_block_before(padding)");
1816
1817 block = iterator.get_block();
1818 if(!compare_chain_(chain, our_current_position, block))
1819 return false;
1820 delete block;
1821
1822 printf("SV[P]PPA\tnext\n");
1823 if(!iterator.next())
1824 return die_("iterator ended early\n");
1825 our_current_position++;
1826
1827 printf("SVP[P]PA\tnext\n");
1828 if(!iterator.next())
1829 return die_("iterator ended early\n");
1830 our_current_position++;
1831
1832 printf("SVPP[P]A\tnext\n");
1833 if(!iterator.next())
1834 return die_("iterator ended early\n");
1835 our_current_position++;
1836
1837 printf("SVPPP[A]\tinsert PADDING after\n");
1838 if(0 == (padding = dynamic_cast<FLAC::Metadata::Padding *>(FLAC::Metadata::clone(our_metadata_.blocks[2]))))
1839 return die_("creating PADDING block");
1840 padding->set_length(57);
1841 if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
1842 return die_("copying metadata");
1843 if(!iterator.insert_block_after(padding))
1844 return die_("iterator.insert_block_after(padding)");
1845
1846 block = iterator.get_block();
1847 if(!compare_chain_(chain, our_current_position, block))
1848 return false;
1849 delete block;
1850
1851 printf("SVPPPA[P]\tinsert PADDING before\n");
1852 if(0 == (padding = dynamic_cast<FLAC::Metadata::Padding *>(FLAC::Metadata::clone(our_metadata_.blocks[2]))))
1853 return die_("creating PADDING block");
1854 padding->set_length(99);
1855 if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
1856 return die_("copying metadata");
1857 if(!iterator.insert_block_before(padding))
1858 return die_("iterator.insert_block_before(padding)");
1859
1860 block = iterator.get_block();
1861 if(!compare_chain_(chain, our_current_position, block))
1862 return false;
1863 delete block;
1864
1865 }
1866 our_current_position = 0;
1867
1868 printf("SVPPPAPP\tmerge padding\n");
1869 chain.merge_padding();
1870 add_to_padding_length_(2, FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[3]->get_length());
1871 add_to_padding_length_(2, FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[4]->get_length());
1872 add_to_padding_length_(6, FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[7]->get_length());
1873 delete_from_our_metadata_(7);
1874 delete_from_our_metadata_(4);
1875 delete_from_our_metadata_(3);
1876
1877 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1878 return die_c_("during chain.write(true, false)", chain.status());
1879 if(!compare_chain_(chain, 0, 0))
1880 return false;
1881 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1882 return false;
1883
1884 printf("SVPAP\tsort padding\n");
1885 chain.sort_padding();
1886 add_to_padding_length_(4, FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[2]->get_length());
1887 delete_from_our_metadata_(2);
1888
1889 if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
1890 return die_c_("during chain.write(true, false)", chain.status());
1891 if(!compare_chain_(chain, 0, 0))
1892 return false;
1893 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
1894 return false;
1895
1896 printf("create iterator\n");
1897 {
1898 FLAC::Metadata::Iterator iterator;
1899 if(!iterator.is_valid())
1900 return die_("allocating memory for iterator");
1901
1902 our_current_position = 0;
1903
1904 iterator.init(chain);
1905
1906 printf("[S]VAP\tnext\n");
1907 if(!iterator.next())
1908 return die_("iterator ended early\n");
1909 our_current_position++;
1910
1911 printf("S[V]AP\tnext\n");
1912 if(!iterator.next())
1913 return die_("iterator ended early\n");
1914 our_current_position++;
1915
1916 printf("SV[A]P\tdelete middle block, replace with padding\n");
1917 if(0 == (padding = new FLAC::Metadata::Padding()))
1918 return die_("creating PADDING block");
1919 padding->set_length(71);
1920 if(!replace_in_our_metadata_(padding, our_current_position--, /*copy=*/false))
1921 return die_("copying object");
1922 if(!iterator.delete_block(/*replace_with_padding=*/true))
1923 return die_c_("iterator.delete_block(true)", chain.status());
1924
1925 block = iterator.get_block();
1926 if(!compare_chain_(chain, our_current_position, block))
1927 return false;
1928 delete block;
1929
1930 printf("S[V]PP\tnext\n");
1931 if(!iterator.next())
1932 return die_("iterator ended early\n");
1933 our_current_position++;
1934
1935 printf("SV[P]P\tdelete middle block, don't replace with padding\n");
1936 delete_from_our_metadata_(our_current_position--);
1937 if(!iterator.delete_block(/*replace_with_padding=*/false))
1938 return die_c_("iterator.delete_block(false)", chain.status());
1939
1940 block = iterator.get_block();
1941 if(!compare_chain_(chain, our_current_position, block))
1942 return false;
1943 delete block;
1944
1945 printf("S[V]P\tnext\n");
1946 if(!iterator.next())
1947 return die_("iterator ended early\n");
1948 our_current_position++;
1949
1950 printf("SV[P]\tdelete last block, replace with padding\n");
1951 if(0 == (padding = new FLAC::Metadata::Padding()))
1952 return die_("creating PADDING block");
1953 padding->set_length(219);
1954 if(!replace_in_our_metadata_(padding, our_current_position--, /*copy=*/false))
1955 return die_("copying object");
1956 if(!iterator.delete_block(/*replace_with_padding=*/true))
1957 return die_c_("iterator.delete_block(true)", chain.status());
1958
1959 block = iterator.get_block();
1960 if(!compare_chain_(chain, our_current_position, block))
1961 return false;
1962 delete block;
1963
1964 printf("S[V]P\tnext\n");
1965 if(!iterator.next())
1966 return die_("iterator ended early\n");
1967 our_current_position++;
1968
1969 printf("SV[P]\tdelete last block, don't replace with padding\n");
1970 delete_from_our_metadata_(our_current_position--);
1971 if(!iterator.delete_block(/*replace_with_padding=*/false))
1972 return die_c_("iterator.delete_block(false)", chain.status());
1973
1974 block = iterator.get_block();
1975 if(!compare_chain_(chain, our_current_position, block))
1976 return false;
1977 delete block;
1978
1979 printf("S[V]\tprev\n");
1980 if(!iterator.prev())
1981 return die_("iterator ended early\n");
1982 our_current_position--;
1983
1984 printf("[S]V\tdelete STREAMINFO block, should fail\n");
1985 if(iterator.delete_block(/*replace_with_padding=*/false))
1986 return die_("iterator.delete_block() on STREAMINFO should have failed but didn't");
1987
1988 block = iterator.get_block();
1989 if(!compare_chain_(chain, our_current_position, block))
1990 return false;
1991 delete block;
1992
1993 } // delete iterator
1994 our_current_position = 0;
1995
1996 printf("SV\tmerge padding\n");
1997 chain.merge_padding();
1998
1999 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
2000 return die_c_("during chain.write(false, false)", chain.status());
2001 if(!compare_chain_(chain, 0, 0))
2002 return false;
2003 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
2004 return false;
2005
2006 printf("SV\tsort padding\n");
2007 chain.sort_padding();
2008
2009 if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
2010 return die_c_("during chain.write(false, false)", chain.status());
2011 if(!compare_chain_(chain, 0, 0))
2012 return false;
2013 if(!test_file_(is_ogg, /*ignore_metadata=*/false))
2014 return false;
2015
2016 end:
2017 if(!remove_file_(flacfilename(is_ogg)))
2018 return false;
2019
2020 return true;
2021 }
2022
2023 static bool test_level_2_misc_(bool is_ogg)
2024 {
2025 ::FLAC__IOCallbacks callbacks;
2026
2027 memset(&callbacks, 0, sizeof(callbacks));
2028 callbacks.read = (::FLAC__IOCallback_Read)fread;
2029 #ifdef FLAC__VALGRIND_TESTING
2030 callbacks.write = chain_write_cb_;
2031 #else
2032 callbacks.write = (::FLAC__IOCallback_Write)fwrite;
2033 #endif
2034 callbacks.seek = chain_seek_cb_;
2035 callbacks.tell = chain_tell_cb_;
2036 callbacks.eof = chain_eof_cb_;
2037
2038 printf("\n\n++++++ testing level 2 interface (mismatched read/write protections)\n");
2039
2040 printf("generate file\n");
2041
2042 if(!generate_file_(/*include_extras=*/false, is_ogg))
2043 return false;
2044
2045 printf("create chain\n");
2046 FLAC::Metadata::Chain chain;
2047 if(!chain.is_valid())
2048 return die_("allocating chain");
2049
2050 printf("read chain (filename-based)\n");
2051
2052 if(!chain.read(flacfilename(is_ogg)))
2053 return die_c_("reading chain", chain.status());
2054
2055 printf("write chain with wrong method Chain::write(with callbacks)\n");
2056 {
2057 if(chain.write(/*use_padding=*/false, 0, callbacks))
2058 return die_c_("mismatched write should have failed", chain.status());
2059 if(chain.status() != ::FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
2060 return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", chain.status());
2061 printf(" OK: Chain::write(with callbacks) returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
2062 }
2063
2064 printf("read chain (filename-based)\n");
2065
2066 if(!chain.read(flacfilename(is_ogg)))
2067 return die_c_("reading chain", chain.status());
2068
2069 printf("write chain with wrong method Chain::write(with callbacks and tempfile)\n");
2070 {
2071 if(chain.write(/*use_padding=*/false, 0, callbacks, 0, callbacks))
2072 return die_c_("mismatched write should have failed", chain.status());
2073 if(chain.status() != ::FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
2074 return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", chain.status());
2075 printf(" OK: Chain::write(with callbacks and tempfile) returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
2076 }
2077
2078 printf("read chain (callback-based)\n");
2079 {
2080 FILE *file = fopen(flacfilename(is_ogg), "rb");
2081 if(0 == file)
2082 return die_("opening file");
2083 if(!chain.read((::FLAC__IOHandle)file, callbacks)) {
2084 fclose(file);
2085 return die_c_("reading chain", chain.status());
2086 }
2087 fclose(file);
2088 }
2089
2090 printf("write chain with wrong method write()\n");
2091 {
2092 if(chain.write(/*use_padding=*/false, /*preserve_file_stats=*/false))
2093 return die_c_("mismatched write should have failed", chain.status());
2094 if(chain.status() != ::FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
2095 return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", chain.status());
2096 printf(" OK: write() returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
2097 }
2098
2099 printf("read chain (callback-based)\n");
2100 {
2101 FILE *file = fopen(flacfilename(is_ogg), "rb");
2102 if(0 == file)
2103 return die_("opening file");
2104 if(!chain.read((::FLAC__IOHandle)file, callbacks)) {
2105 fclose(file);
2106 return die_c_("reading chain", chain.status());
2107 }
2108 fclose(file);
2109 }
2110
2111 printf("testing Chain::check_if_tempfile_needed()... ");
2112
2113 if(!chain.check_if_tempfile_needed(/*use_padding=*/false))
2114 printf("OK: Chain::check_if_tempfile_needed() returned false like it should\n");
2115 else
2116 return die_("Chain::check_if_tempfile_needed() returned true but shouldn't have");
2117
2118 printf("write chain with wrong method Chain::write(with callbacks and tempfile)\n");
2119 {
2120 if(chain.write(/*use_padding=*/false, 0, callbacks, 0, callbacks))
2121 return die_c_("mismatched write should have failed", chain.status());
2122 if(chain.status() != ::FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL)
2123 return die_c_("expected FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL", chain.status());
2124 printf(" OK: Chain::write(with callbacks and tempfile) returned false,FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL like it should\n");
2125 }
2126
2127 printf("read chain (callback-based)\n");
2128 {
2129 FILE *file = fopen(flacfilename(is_ogg), "rb");
2130 if(0 == file)
2131 return die_("opening file");
2132 if(!chain.read((::FLAC__IOHandle)file, callbacks)) {
2133 fclose(file);
2134 return die_c_("reading chain", chain.status());
2135 }
2136 fclose(file);
2137 }
2138
2139 printf("create iterator\n");
2140 {
2141 FLAC::Metadata::Iterator iterator;
2142 if(!iterator.is_valid())
2143 return die_("allocating memory for iterator");
2144
2145 iterator.init(chain);
2146
2147 printf("[S]VP\tnext\n");
2148 if(!iterator.next())
2149 return die_("iterator ended early\n");
2150
2151 printf("S[V]P\tdelete VORBIS_COMMENT, write\n");
2152 if(!iterator.delete_block(/*replace_with_padding=*/false))
2153 return die_c_("block delete failed\n", chain.status());
2154
2155 printf("testing Chain::check_if_tempfile_needed()... ");
2156
2157 if(chain.check_if_tempfile_needed(/*use_padding=*/false))
2158 printf("OK: Chain::check_if_tempfile_needed() returned true like it should\n");
2159 else
2160 return die_("Chain::check_if_tempfile_needed() returned false but shouldn't have");
2161
2162 printf("write chain with wrong method Chain::write(with callbacks)\n");
2163 {
2164 if(chain.write(/*use_padding=*/false, 0, callbacks))
2165 return die_c_("mismatched write should have failed", chain.status());
2166 if(chain.status() != ::FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL)
2167 return die_c_("expected FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL", chain.status());
2168 printf(" OK: Chain::write(with callbacks) returned false,FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL like it should\n");
2169 }
2170
2171 } // delete iterator
2172
2173 if(!remove_file_(flacfilename(is_ogg)))
2174 return false;
2175
2176 return true;
2177 }
2178
2179 bool test_metadata_file_manipulation()
2180 {
2181 printf("\n+++ libFLAC++ unit test: metadata manipulation\n\n");
2182
2183 our_metadata_.num_blocks = 0;
2184
2185 if(!test_level_0_())
2186 return false;
2187
2188 if(!test_level_1_())
2189 return false;
2190
2191 if(!test_level_2_(/*filename_based=*/true, /*is_ogg=*/false)) /* filename-based */
2192 return false;
2193 if(!test_level_2_(/*filename_based=*/false, /*is_ogg=*/false)) /* callback-based */
2194 return false;
2195 if(!test_level_2_misc_(/*is_ogg=*/false))
2196 return false;
2197
2198 if(FLAC_API_SUPPORTS_OGG_FLAC) {
2199 if(!test_level_2_(/*filename_based=*/true, /*is_ogg=*/true)) /* filename-based */
2200 return false;
2201 if(!test_level_2_(/*filename_based=*/false, /*is_ogg=*/true)) /* callback-based */
2202 return false;
2203 #if 0
2204 /* when ogg flac write is supported, will have to add this: */
2205 if(!test_level_2_misc_(/*is_ogg=*/true))
2206 return false;
2207 #endif
2208 }
2209
2210 return true;
2211 }