src/test_libFLAC/decoders.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2002,2003,2004,2005,2006  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 #if HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <errno.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #if defined _MSC_VER || defined __MINGW32__
  28 //@@@ [2G limit] hacks for MSVC6
  29 #define fseeko fseek
  30 #define ftello ftell
  31 #endif
  32 #include "decoders.h"
  33 #include "file_utils.h"
  34 #include "metadata_utils.h"
  35 #include "FLAC/assert.h"
  36 #include "FLAC/file_decoder.h"
  37 #include "FLAC/seekable_stream_decoder.h"
  38 #include "FLAC/stream_decoder.h"
  39 #include "share/grabbag.h"
  40
  41 typedef struct {
  42         FILE *file;
  43         unsigned current_metadata_number;
  44         FLAC__bool ignore_errors;
  45         FLAC__bool error_occurred;
  46 } stream_decoder_client_data_struct;
  47
  48 typedef stream_decoder_client_data_struct seekable_stream_decoder_client_data_struct;
  49 typedef stream_decoder_client_data_struct file_decoder_client_data_struct;
  50
  51 static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, unknown_;
  52 static FLAC__StreamMetadata *expected_metadata_sequence_[8];
  53 static unsigned num_expected_;
  54 static const char *flacfilename_ = "metadata.flac";
  55 static off_t flacfilesize_;
  56
  57 static FLAC__bool die_(const char *msg)
  58 {
  59         printf("ERROR: %s\n", msg);
  60         return false;
  61 }
  62
  63 static FLAC__bool die_s_(const char *msg, const FLAC__StreamDecoder *decoder)
  64 {
  65         FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
  66
  67         if(msg)
  68                 printf("FAILED, %s", msg);
  69         else
  70                 printf("FAILED");
  71
  72         printf(", state = %u (%s)\n", (unsigned)state, FLAC__StreamDecoderStateString[state]);
  73
  74         return false;
  75 }
  76
  77 static FLAC__bool die_ss_(const char *msg, const FLAC__SeekableStreamDecoder *decoder)
  78 {
  79         FLAC__SeekableStreamDecoderState state = FLAC__seekable_stream_decoder_get_state(decoder);
  80
  81         if(msg)
  82                 printf("FAILED, %s", msg);
  83         else
  84                 printf("FAILED");
  85
  86         printf(", state = %u (%s)\n", (unsigned)state, FLAC__SeekableStreamDecoderStateString[state]);
  87         if(state == FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
  88                 FLAC__StreamDecoderState state_ = FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder);
  89                 printf("      stream decoder state = %u (%s)\n", (unsigned)state_, FLAC__StreamDecoderStateString[state_]);
  90         }
  91
  92         return false;
  93 }
  94
  95 static FLAC__bool die_f_(const char *msg, const FLAC__FileDecoder *decoder)
  96 {
  97         FLAC__FileDecoderState state = FLAC__file_decoder_get_state(decoder);
  98
  99         if(msg)
 100                 printf("FAILED, %s", msg);
 101         else
 102                 printf("FAILED");
 103
 104         printf(", state = %u (%s)\n", (unsigned)state, FLAC__FileDecoderStateString[state]);
 105         if(state == FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR) {
 106                 FLAC__SeekableStreamDecoderState state_ = FLAC__file_decoder_get_seekable_stream_decoder_state(decoder);
 107                 printf("      seekable stream decoder state = %u (%s)\n", (unsigned)state, FLAC__SeekableStreamDecoderStateString[state_]);
 108                 if(state_ == FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
 109                         FLAC__StreamDecoderState state__ = FLAC__file_decoder_get_stream_decoder_state(decoder);
 110                         printf("      stream decoder state = %u (%s)\n", (unsigned)state__, FLAC__StreamDecoderStateString[state__]);
 111                 }
 112         }
 113
 114         return false;
 115 }
 116
 117 static void init_metadata_blocks_()
 118 {
 119         mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 120 }
 121
 122 static void free_metadata_blocks_()
 123 {
 124         mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 125 }
 126
 127 static FLAC__bool generate_file_()
 128 {
 129         printf("\n\ngenerating FLAC file for decoder tests...\n");
 130
 131         num_expected_ = 0;
 132         expected_metadata_sequence_[num_expected_++] = &padding_;
 133         expected_metadata_sequence_[num_expected_++] = &seektable_;
 134         expected_metadata_sequence_[num_expected_++] = &application1_;
 135         expected_metadata_sequence_[num_expected_++] = &application2_;
 136         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 137         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 138         expected_metadata_sequence_[num_expected_++] = &unknown_;
 139
 140         if(!file_utils__generate_flacfile(flacfilename_, &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
 141                 return die_("creating the encoded file");
 142
 143         return true;
 144 }
 145
 146 static FLAC__StreamDecoderReadStatus stream_decoder_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 147 {
 148         stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 149         const unsigned requested_bytes = *bytes;
 150
 151         (void)decoder;
 152
 153         if(0 == dcd) {
 154                 printf("ERROR: client_data in read callback is NULL\n");
 155                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 156         }
 157
 158         if(dcd->error_occurred)
 159                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 160
 161         if(feof(dcd->file)) {
 162                 *bytes = 0;
 163                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 164         }
 165         else if(requested_bytes > 0) {
 166                 *bytes = fread(buffer, 1, requested_bytes, dcd->file);
 167                 if(*bytes == 0) {
 168                         if(feof(dcd->file))
 169                                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 170                         else
 171                                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 172                 }
 173                 else {
 174                         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 175                 }
 176         }
 177         else
 178                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
 179 }
 180
 181 static FLAC__StreamDecoderWriteStatus stream_decoder_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 182 {
 183         stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 184
 185         (void)decoder, (void)buffer;
 186
 187         if(0 == dcd) {
 188                 printf("ERROR: client_data in write callback is NULL\n");
 189                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 190         }
 191
 192         if(dcd->error_occurred)
 193                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 194
 195         if(
 196                 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
 197                 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
 198         ) {
 199                 printf("content... ");
 200                 fflush(stdout);
 201         }
 202
 203         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 204 }
 205
 206 static void stream_decoder_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 207 {
 208         stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 209
 210         (void)decoder;
 211
 212         if(0 == dcd) {
 213                 printf("ERROR: client_data in metadata callback is NULL\n");
 214                 return;
 215         }
 216
 217         if(dcd->error_occurred)
 218                 return;
 219
 220         printf("%d... ", dcd->current_metadata_number);
 221         fflush(stdout);
 222
 223         if(dcd->current_metadata_number >= num_expected_) {
 224                 (void)die_("got more metadata blocks than expected");
 225                 dcd->error_occurred = true;
 226         }
 227         else {
 228                 if(!mutils__compare_block(expected_metadata_sequence_[dcd->current_metadata_number], metadata)) {
 229                         (void)die_("metadata block mismatch");
 230                         dcd->error_occurred = true;
 231                 }
 232         }
 233         dcd->current_metadata_number++;
 234 }
 235
 236 static void stream_decoder_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 237 {
 238         stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 239
 240         (void)decoder;
 241
 242         if(0 == dcd) {
 243                 printf("ERROR: client_data in error callback is NULL\n");
 244                 return;
 245         }
 246
 247         if(!dcd->ignore_errors) {
 248                 printf("ERROR: got error callback: err = %u (%s)\n", (unsigned)status, FLAC__StreamDecoderErrorStatusString[status]);
 249                 dcd->error_occurred = true;
 250         }
 251 }
 252
 253 static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, stream_decoder_client_data_struct *dcd)
 254 {
 255         if(!FLAC__stream_decoder_set_read_callback(decoder, stream_decoder_read_callback_))
 256                 return die_s_("at FLAC__stream_decoder_set_read_callback(), returned false", decoder);
 257
 258         if(!FLAC__stream_decoder_set_write_callback(decoder, stream_decoder_write_callback_))
 259                 return die_s_("at FLAC__stream_decoder_set_write_callback(), returned false", decoder);
 260
 261         if(!FLAC__stream_decoder_set_metadata_callback(decoder, stream_decoder_metadata_callback_))
 262                 return die_s_("at FLAC__stream_decoder_set_metadata_callback(), returned false", decoder);
 263
 264         if(!FLAC__stream_decoder_set_error_callback(decoder, stream_decoder_error_callback_))
 265                 return die_s_("at FLAC__stream_decoder_set_error_callback(), returned false", decoder);
 266
 267         if(!FLAC__stream_decoder_set_client_data(decoder, dcd))
 268                 return die_s_("at FLAC__stream_decoder_set_client_data(), returned false", decoder);
 269
 270         printf("testing FLAC__stream_decoder_init()... ");
 271         if(FLAC__stream_decoder_init(decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 272                 return die_s_(0, decoder);
 273         printf("OK\n");
 274
 275         dcd->current_metadata_number = 0;
 276
 277         if(fseeko(dcd->file, 0, SEEK_SET) < 0) {
 278                 printf("FAILED rewinding input, errno = %d\n", errno);
 279                 return false;
 280         }
 281
 282         printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 283         if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 284                 return die_s_("returned false", decoder);
 285         printf("OK\n");
 286
 287         printf("testing FLAC__stream_decoder_finish()... ");
 288         FLAC__stream_decoder_finish(decoder);
 289         printf("OK\n");
 290
 291         return true;
 292 }
 293
 294 static FLAC__bool test_stream_decoder()
 295 {
 296         FLAC__StreamDecoder *decoder;
 297         FLAC__StreamDecoderState state;
 298         stream_decoder_client_data_struct decoder_client_data;
 299
 300         printf("\n+++ libFLAC unit test: FLAC__StreamDecoder\n\n");
 301
 302         printf("testing FLAC__stream_decoder_new()... ");
 303         decoder = FLAC__stream_decoder_new();
 304         if(0 == decoder) {
 305                 printf("FAILED, returned NULL\n");
 306                 return false;
 307         }
 308         printf("OK\n");
 309
 310         printf("testing FLAC__stream_decoder_delete()... ");
 311         FLAC__stream_decoder_delete(decoder);
 312         printf("OK\n");
 313
 314         printf("testing FLAC__stream_decoder_new()... ");
 315         decoder = FLAC__stream_decoder_new();
 316         if(0 == decoder) {
 317                 printf("FAILED, returned NULL\n");
 318                 return false;
 319         }
 320         printf("OK\n");
 321
 322         printf("testing FLAC__stream_decoder_init()... ");
 323         if(FLAC__stream_decoder_init(decoder) == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 324                 return die_s_(0, decoder);
 325         printf("OK\n");
 326
 327         printf("testing FLAC__stream_decoder_delete()... ");
 328         FLAC__stream_decoder_delete(decoder);
 329         printf("OK\n");
 330
 331         num_expected_ = 0;
 332         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 333
 334         printf("testing FLAC__stream_decoder_new()... ");
 335         decoder = FLAC__stream_decoder_new();
 336         if(0 == decoder) {
 337                 printf("FAILED, returned NULL\n");
 338                 return false;
 339         }
 340         printf("OK\n");
 341
 342         printf("testing FLAC__stream_decoder_set_read_callback()... ");
 343         if(!FLAC__stream_decoder_set_read_callback(decoder, stream_decoder_read_callback_))
 344                 return die_s_("returned false", decoder);
 345         printf("OK\n");
 346
 347         printf("testing FLAC__stream_decoder_set_write_callback()... ");
 348         if(!FLAC__stream_decoder_set_write_callback(decoder, stream_decoder_write_callback_))
 349                 return die_s_("returned false", decoder);
 350         printf("OK\n");
 351
 352         printf("testing FLAC__stream_decoder_set_metadata_callback()... ");
 353         if(!FLAC__stream_decoder_set_metadata_callback(decoder, stream_decoder_metadata_callback_))
 354                 return die_s_("returned false", decoder);
 355         printf("OK\n");
 356
 357         printf("testing FLAC__stream_decoder_set_error_callback()... ");
 358         if(!FLAC__stream_decoder_set_error_callback(decoder, stream_decoder_error_callback_))
 359                 return die_s_("returned false", decoder);
 360         printf("OK\n");
 361
 362         printf("testing FLAC__stream_decoder_set_client_data()... ");
 363         if(!FLAC__stream_decoder_set_client_data(decoder, &decoder_client_data))
 364                 return die_s_("returned false", decoder);
 365         printf("OK\n");
 366
 367         printf("testing FLAC__stream_decoder_init()... ");
 368         if(FLAC__stream_decoder_init(decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 369                 return die_s_(0, decoder);
 370         printf("OK\n");
 371
 372         printf("testing FLAC__stream_decoder_get_state()... ");
 373         state = FLAC__stream_decoder_get_state(decoder);
 374         printf("returned state = %u (%s)... OK\n", state, FLAC__StreamDecoderStateString[state]);
 375
 376         decoder_client_data.current_metadata_number = 0;
 377         decoder_client_data.ignore_errors = false;
 378         decoder_client_data.error_occurred = false;
 379
 380         printf("opening FLAC file... ");
 381         decoder_client_data.file = fopen(flacfilename_, "rb");
 382         if(0 == decoder_client_data.file) {
 383                 printf("ERROR (%s)\n", strerror(errno));
 384                 return false;
 385         }
 386         printf("OK\n");
 387
 388         printf("testing FLAC__stream_decoder_process_until_end_of_metadata()... ");
 389         if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
 390                 return die_s_("returned false", decoder);
 391         printf("OK\n");
 392
 393         printf("testing FLAC__stream_decoder_process_single()... ");
 394         if(!FLAC__stream_decoder_process_single(decoder))
 395                 return die_s_("returned false", decoder);
 396         printf("OK\n");
 397
 398         printf("testing FLAC__stream_decoder_skip_single_frame()... ");
 399         if(!FLAC__stream_decoder_skip_single_frame(decoder))
 400                 return die_s_("returned false", decoder);
 401         printf("OK\n");
 402
 403         printf("testing FLAC__stream_decoder_flush()... ");
 404         if(!FLAC__stream_decoder_flush(decoder))
 405                 return die_s_("returned false", decoder);
 406         printf("OK\n");
 407
 408         decoder_client_data.ignore_errors = true;
 409         printf("testing FLAC__stream_decoder_process_single()... ");
 410         if(!FLAC__stream_decoder_process_single(decoder))
 411                 return die_s_("returned false", decoder);
 412         printf("OK\n");
 413         decoder_client_data.ignore_errors = false;
 414
 415         printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 416         if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 417                 return die_s_("returned false", decoder);
 418         printf("OK\n");
 419
 420         printf("testing FLAC__stream_decoder_get_channels()... ");
 421         {
 422                 unsigned channels = FLAC__stream_decoder_get_channels(decoder);
 423                 if(channels != streaminfo_.data.stream_info.channels) {
 424                         printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
 425                         return false;
 426                 }
 427         }
 428         printf("OK\n");
 429
 430         printf("testing FLAC__stream_decoder_get_bits_per_sample()... ");
 431         {
 432                 unsigned bits_per_sample = FLAC__stream_decoder_get_bits_per_sample(decoder);
 433                 if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
 434                         printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
 435                         return false;
 436                 }
 437         }
 438         printf("OK\n");
 439
 440         printf("testing FLAC__stream_decoder_get_sample_rate()... ");
 441         {
 442                 unsigned sample_rate = FLAC__stream_decoder_get_sample_rate(decoder);
 443                 if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
 444                         printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
 445                         return false;
 446                 }
 447         }
 448         printf("OK\n");
 449
 450         printf("testing FLAC__stream_decoder_get_blocksize()... ");
 451         {
 452                 unsigned blocksize = FLAC__stream_decoder_get_blocksize(decoder);
 453                 /* value could be anything since we're at the last block, so accept any answer */
 454                 printf("returned %u... OK\n", blocksize);
 455         }
 456
 457         printf("testing FLAC__stream_decoder_get_channel_assignment()... ");
 458         {
 459                 FLAC__ChannelAssignment ca = FLAC__stream_decoder_get_channel_assignment(decoder);
 460                 printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
 461         }
 462
 463         printf("testing FLAC__stream_decoder_reset()... ");
 464         if(!FLAC__stream_decoder_reset(decoder)) {
 465                 state = FLAC__stream_decoder_get_state(decoder);
 466                 printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]);
 467                 return false;
 468         }
 469         printf("OK\n");
 470
 471         decoder_client_data.current_metadata_number = 0;
 472
 473         printf("rewinding input... ");
 474         if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) {
 475                 printf("FAILED, errno = %d\n", errno);
 476                 return false;
 477         }
 478         printf("OK\n");
 479
 480         printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 481         if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 482                 return die_s_("returned false", decoder);
 483         printf("OK\n");
 484
 485         printf("testing FLAC__stream_decoder_finish()... ");
 486         FLAC__stream_decoder_finish(decoder);
 487         printf("OK\n");
 488
 489         /*
 490          * respond all
 491          */
 492
 493         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 494         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 495                 return die_s_("returned false", decoder);
 496         printf("OK\n");
 497
 498         num_expected_ = 0;
 499         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 500         expected_metadata_sequence_[num_expected_++] = &padding_;
 501         expected_metadata_sequence_[num_expected_++] = &seektable_;
 502         expected_metadata_sequence_[num_expected_++] = &application1_;
 503         expected_metadata_sequence_[num_expected_++] = &application2_;
 504         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 505         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 506         expected_metadata_sequence_[num_expected_++] = &unknown_;
 507
 508         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 509                 return false;
 510
 511         /*
 512          * ignore all
 513          */
 514
 515         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 516         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 517                 return die_s_("returned false", decoder);
 518         printf("OK\n");
 519
 520         num_expected_ = 0;
 521
 522         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 523                 return false;
 524
 525         /*
 526          * respond all, ignore VORBIS_COMMENT
 527          */
 528
 529         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 530         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 531                 return die_s_("returned false", decoder);
 532         printf("OK\n");
 533
 534         printf("testing FLAC__stream_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
 535         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
 536                 return die_s_("returned false", decoder);
 537         printf("OK\n");
 538
 539         num_expected_ = 0;
 540         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 541         expected_metadata_sequence_[num_expected_++] = &padding_;
 542         expected_metadata_sequence_[num_expected_++] = &seektable_;
 543         expected_metadata_sequence_[num_expected_++] = &application1_;
 544         expected_metadata_sequence_[num_expected_++] = &application2_;
 545         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 546         expected_metadata_sequence_[num_expected_++] = &unknown_;
 547
 548         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 549                 return false;
 550
 551         /*
 552          * respond all, ignore APPLICATION
 553          */
 554
 555         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 556         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 557                 return die_s_("returned false", decoder);
 558         printf("OK\n");
 559
 560         printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
 561         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
 562                 return die_s_("returned false", decoder);
 563         printf("OK\n");
 564
 565         num_expected_ = 0;
 566         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 567         expected_metadata_sequence_[num_expected_++] = &padding_;
 568         expected_metadata_sequence_[num_expected_++] = &seektable_;
 569         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 570         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 571         expected_metadata_sequence_[num_expected_++] = &unknown_;
 572
 573         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 574                 return false;
 575
 576         /*
 577          * respond all, ignore APPLICATION id of app#1
 578          */
 579
 580         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 581         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 582                 return die_s_("returned false", decoder);
 583         printf("OK\n");
 584
 585         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 586         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 587                 return die_s_("returned false", decoder);
 588         printf("OK\n");
 589
 590         num_expected_ = 0;
 591         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 592         expected_metadata_sequence_[num_expected_++] = &padding_;
 593         expected_metadata_sequence_[num_expected_++] = &seektable_;
 594         expected_metadata_sequence_[num_expected_++] = &application2_;
 595         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 596         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 597         expected_metadata_sequence_[num_expected_++] = &unknown_;
 598
 599         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 600                 return false;
 601
 602         /*
 603          * respond all, ignore APPLICATION id of app#1 & app#2
 604          */
 605
 606         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 607         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 608                 return die_s_("returned false", decoder);
 609         printf("OK\n");
 610
 611         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 612         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 613                 return die_s_("returned false", decoder);
 614         printf("OK\n");
 615
 616         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #2)... ");
 617         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
 618                 return die_s_("returned false", decoder);
 619         printf("OK\n");
 620
 621         num_expected_ = 0;
 622         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 623         expected_metadata_sequence_[num_expected_++] = &padding_;
 624         expected_metadata_sequence_[num_expected_++] = &seektable_;
 625         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 626         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 627         expected_metadata_sequence_[num_expected_++] = &unknown_;
 628
 629         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 630                 return false;
 631
 632         /*
 633          * ignore all, respond VORBIS_COMMENT
 634          */
 635
 636         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 637         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 638                 return die_s_("returned false", decoder);
 639         printf("OK\n");
 640
 641         printf("testing FLAC__stream_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
 642         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
 643                 return die_s_("returned false", decoder);
 644         printf("OK\n");
 645
 646         num_expected_ = 0;
 647         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 648
 649         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 650                 return false;
 651
 652         /*
 653          * ignore all, respond APPLICATION
 654          */
 655
 656         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 657         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 658                 return die_s_("returned false", decoder);
 659         printf("OK\n");
 660
 661         printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
 662         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
 663                 return die_s_("returned false", decoder);
 664         printf("OK\n");
 665
 666         num_expected_ = 0;
 667         expected_metadata_sequence_[num_expected_++] = &application1_;
 668         expected_metadata_sequence_[num_expected_++] = &application2_;
 669
 670         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 671                 return false;
 672
 673         /*
 674          * ignore all, respond APPLICATION id of app#1
 675          */
 676
 677         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 678         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 679                 return die_s_("returned false", decoder);
 680         printf("OK\n");
 681
 682         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 683         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 684                 return die_s_("returned false", decoder);
 685         printf("OK\n");
 686
 687         num_expected_ = 0;
 688         expected_metadata_sequence_[num_expected_++] = &application1_;
 689
 690         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 691                 return false;
 692
 693         /*
 694          * ignore all, respond APPLICATION id of app#1 & app#2
 695          */
 696
 697         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 698         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 699                 return die_s_("returned false", decoder);
 700         printf("OK\n");
 701
 702         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 703         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 704                 return die_s_("returned false", decoder);
 705         printf("OK\n");
 706
 707         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #2)... ");
 708         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
 709                 return die_s_("returned false", decoder);
 710         printf("OK\n");
 711
 712         num_expected_ = 0;
 713         expected_metadata_sequence_[num_expected_++] = &application1_;
 714         expected_metadata_sequence_[num_expected_++] = &application2_;
 715
 716         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 717                 return false;
 718
 719         /*
 720          * respond all, ignore APPLICATION, respond APPLICATION id of app#1
 721          */
 722
 723         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 724         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 725                 return die_s_("returned false", decoder);
 726         printf("OK\n");
 727
 728         printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
 729         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
 730                 return die_s_("returned false", decoder);
 731         printf("OK\n");
 732
 733         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 734         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 735                 return die_s_("returned false", decoder);
 736         printf("OK\n");
 737
 738         num_expected_ = 0;
 739         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 740         expected_metadata_sequence_[num_expected_++] = &padding_;
 741         expected_metadata_sequence_[num_expected_++] = &seektable_;
 742         expected_metadata_sequence_[num_expected_++] = &application1_;
 743         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 744         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 745         expected_metadata_sequence_[num_expected_++] = &unknown_;
 746
 747         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 748                 return false;
 749
 750         /*
 751          * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
 752          */
 753
 754         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 755         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 756                 return die_s_("returned false", decoder);
 757         printf("OK\n");
 758
 759         printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
 760         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
 761                 return die_s_("returned false", decoder);
 762         printf("OK\n");
 763
 764         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 765         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 766                 return die_s_("returned false", decoder);
 767         printf("OK\n");
 768
 769         num_expected_ = 0;
 770         expected_metadata_sequence_[num_expected_++] = &application2_;
 771
 772         if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 773                 return false;
 774
 775         /* done, now leave the sequence the way we found it... */
 776         num_expected_ = 0;
 777         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 778         expected_metadata_sequence_[num_expected_++] = &padding_;
 779         expected_metadata_sequence_[num_expected_++] = &seektable_;
 780         expected_metadata_sequence_[num_expected_++] = &application1_;
 781         expected_metadata_sequence_[num_expected_++] = &application2_;
 782         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 783         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 784         expected_metadata_sequence_[num_expected_++] = &unknown_;
 785
 786         printf("testing FLAC__stream_decoder_delete()... ");
 787         FLAC__stream_decoder_delete(decoder);
 788         printf("OK\n");
 789
 790         fclose(decoder_client_data.file);
 791
 792         printf("\nPASSED!\n");
 793
 794         return true;
 795 }
 796
 797 static FLAC__SeekableStreamDecoderReadStatus seekable_stream_decoder_read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 798 {
 799         (void)decoder;
 800         switch(stream_decoder_read_callback_(0, buffer, bytes, client_data)) {
 801                 case FLAC__STREAM_DECODER_READ_STATUS_CONTINUE:
 802                         return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
 803                 case FLAC__STREAM_DECODER_READ_STATUS_ABORT:
 804                 case FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM:
 805                         return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
 806                 default:
 807                         FLAC__ASSERT(0);
 808                         return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
 809         }
 810 }
 811
 812 static FLAC__SeekableStreamDecoderSeekStatus seekable_stream_decoder_seek_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 813 {
 814         seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
 815
 816         (void)decoder;
 817
 818         if(0 == dcd) {
 819                 printf("ERROR: client_data in seek callback is NULL\n");
 820                 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
 821         }
 822
 823         if(dcd->error_occurred)
 824                 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
 825
 826         if(fseeko(dcd->file, (off_t)absolute_byte_offset, SEEK_SET) < 0) {
 827                 dcd->error_occurred = true;
 828                 return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
 829         }
 830
 831         return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
 832 }
 833
 834 static FLAC__SeekableStreamDecoderTellStatus seekable_stream_decoder_tell_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 835 {
 836         seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
 837         off_t offset;
 838
 839         (void)decoder;
 840
 841         if(0 == dcd) {
 842                 printf("ERROR: client_data in tell callback is NULL\n");
 843                 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
 844         }
 845
 846         if(dcd->error_occurred)
 847                 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
 848
 849         offset = ftello(dcd->file);
 850         *absolute_byte_offset = (FLAC__uint64)offset;
 851
 852         if(offset < 0) {
 853                 dcd->error_occurred = true;
 854                 return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
 855         }
 856
 857         return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
 858 }
 859
 860 static FLAC__SeekableStreamDecoderLengthStatus seekable_stream_decoder_length_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 861 {
 862         seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
 863
 864         (void)decoder;
 865
 866         if(0 == dcd) {
 867                 printf("ERROR: client_data in length callback is NULL\n");
 868                 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
 869         }
 870
 871         if(dcd->error_occurred)
 872                 return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
 873
 874         *stream_length = (FLAC__uint64)flacfilesize_;
 875         return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
 876 }
 877
 878 static FLAC__bool seekable_stream_decoder_eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *client_data)
 879 {
 880         seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
 881
 882         (void)decoder;
 883
 884         if(0 == dcd) {
 885                 printf("ERROR: client_data in eof callback is NULL\n");
 886                 return true;
 887         }
 888
 889         if(dcd->error_occurred)
 890                 return true;
 891
 892         return feof(dcd->file);
 893 }
 894
 895 static FLAC__StreamDecoderWriteStatus seekable_stream_decoder_write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 896 {
 897         (void)decoder;
 898         return stream_decoder_write_callback_(0, frame, buffer, client_data);
 899 }
 900
 901 static void seekable_stream_decoder_metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 902 {
 903         (void)decoder;
 904         stream_decoder_metadata_callback_(0, metadata, client_data);
 905 }
 906
 907 static void seekable_stream_decoder_error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 908 {
 909         (void)decoder;
 910         stream_decoder_error_callback_(0, status, client_data);
 911 }
 912
 913 static FLAC__bool seekable_stream_decoder_test_respond_(FLAC__SeekableStreamDecoder *decoder, seekable_stream_decoder_client_data_struct *dcd)
 914 {
 915         if(!FLAC__seekable_stream_decoder_set_read_callback(decoder, seekable_stream_decoder_read_callback_))
 916                 return die_ss_("at FLAC__seekable_stream_decoder_set_read_callback(), returned false", decoder);
 917
 918         if(!FLAC__seekable_stream_decoder_set_seek_callback(decoder, seekable_stream_decoder_seek_callback_))
 919                 return die_ss_("at FLAC__seekable_stream_decoder_set_seek_callback(), returned false", decoder);
 920
 921         if(!FLAC__seekable_stream_decoder_set_tell_callback(decoder, seekable_stream_decoder_tell_callback_))
 922                 return die_ss_("at FLAC__seekable_stream_decoder_set_tell_callback(), returned false", decoder);
 923
 924         if(!FLAC__seekable_stream_decoder_set_length_callback(decoder, seekable_stream_decoder_length_callback_))
 925                 return die_ss_("at FLAC__seekable_stream_decoder_set_length_callback(), returned false", decoder);
 926
 927         if(!FLAC__seekable_stream_decoder_set_eof_callback(decoder, seekable_stream_decoder_eof_callback_))
 928                 return die_ss_("at FLAC__seekable_stream_decoder_set_eof_callback(), returned false", decoder);
 929
 930         if(!FLAC__seekable_stream_decoder_set_write_callback(decoder, seekable_stream_decoder_write_callback_))
 931                 return die_ss_("at FLAC__seekable_stream_decoder_set_write_callback(), returned false", decoder);
 932
 933         if(!FLAC__seekable_stream_decoder_set_metadata_callback(decoder, seekable_stream_decoder_metadata_callback_))
 934                 return die_ss_("at FLAC__seekable_stream_decoder_set_metadata_callback(), returned false", decoder);
 935
 936         if(!FLAC__seekable_stream_decoder_set_error_callback(decoder, seekable_stream_decoder_error_callback_))
 937                 return die_ss_("at FLAC__seekable_stream_decoder_set_error_callback(), returned false", decoder);
 938
 939         if(!FLAC__seekable_stream_decoder_set_client_data(decoder, dcd))
 940                 return die_ss_("at FLAC__seekable_stream_decoder_set_client_data(), returned false", decoder);
 941
 942         if(!FLAC__seekable_stream_decoder_set_md5_checking(decoder, true))
 943                 return die_ss_("at FLAC__seekable_stream_decoder_set_md5_checking(), returned false", decoder);
 944
 945         printf("testing FLAC__seekable_stream_decoder_init()... ");
 946         if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
 947                 return die_ss_(0, decoder);
 948         printf("OK\n");
 949
 950         dcd->current_metadata_number = 0;
 951
 952         if(fseeko(dcd->file, 0, SEEK_SET) < 0) {
 953                 printf("FAILED rewinding input, errno = %d\n", errno);
 954                 return false;
 955         }
 956
 957         printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
 958         if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
 959                 return die_ss_("returned false", decoder);
 960         printf("OK\n");
 961
 962         printf("testing FLAC__seekable_stream_decoder_finish()... ");
 963         (void) FLAC__seekable_stream_decoder_finish(decoder);
 964         printf("OK\n");
 965
 966         return true;
 967 }
 968
 969 static FLAC__bool test_seekable_stream_decoder()
 970 {
 971         FLAC__SeekableStreamDecoder *decoder;
 972         FLAC__SeekableStreamDecoderState state;
 973         FLAC__StreamDecoderState sstate;
 974         seekable_stream_decoder_client_data_struct decoder_client_data;
 975
 976         printf("\n+++ libFLAC unit test: FLAC__SeekableStreamDecoder\n\n");
 977
 978         printf("testing FLAC__seekable_stream_decoder_new()... ");
 979         decoder = FLAC__seekable_stream_decoder_new();
 980         if(0 == decoder) {
 981                 printf("FAILED, returned NULL\n");
 982                 return false;
 983         }
 984         printf("OK\n");
 985
 986         printf("testing FLAC__seekable_stream_decoder_delete()... ");
 987         FLAC__seekable_stream_decoder_delete(decoder);
 988         printf("OK\n");
 989
 990         printf("testing FLAC__seekable_stream_decoder_new()... ");
 991         decoder = FLAC__seekable_stream_decoder_new();
 992         if(0 == decoder) {
 993                 printf("FAILED, returned NULL\n");
 994                 return false;
 995         }
 996         printf("OK\n");
 997
 998         printf("testing FLAC__seekable_stream_decoder_init()... ");
 999         if(FLAC__seekable_stream_decoder_init(decoder) == FLAC__SEEKABLE_STREAM_DECODER_OK)
1000                 return die_ss_(0, decoder);
1001         printf("OK\n");
1002
1003         printf("testing FLAC__seekable_stream_decoder_delete()... ");
1004         FLAC__seekable_stream_decoder_delete(decoder);
1005         printf("OK\n");
1006
1007         num_expected_ = 0;
1008         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1009
1010         printf("testing FLAC__seekable_stream_decoder_new()... ");
1011         decoder = FLAC__seekable_stream_decoder_new();
1012         if(0 == decoder) {
1013                 printf("FAILED, returned NULL\n");
1014                 return false;
1015         }
1016         printf("OK\n");
1017
1018         printf("testing FLAC__seekable_stream_decoder_set_read_callback()... ");
1019         if(!FLAC__seekable_stream_decoder_set_read_callback(decoder, seekable_stream_decoder_read_callback_))
1020                 return die_ss_("returned false", decoder);
1021         printf("OK\n");
1022
1023         printf("testing FLAC__seekable_stream_decoder_set_seek_callback()... ");
1024         if(!FLAC__seekable_stream_decoder_set_seek_callback(decoder, seekable_stream_decoder_seek_callback_))
1025                 return die_ss_("returned false", decoder);
1026         printf("OK\n");
1027
1028         printf("testing FLAC__seekable_stream_decoder_set_tell_callback()... ");
1029         if(!FLAC__seekable_stream_decoder_set_tell_callback(decoder, seekable_stream_decoder_tell_callback_))
1030                 return die_ss_("returned false", decoder);
1031         printf("OK\n");
1032
1033         printf("testing FLAC__seekable_stream_decoder_set_length_callback()... ");
1034         if(!FLAC__seekable_stream_decoder_set_length_callback(decoder, seekable_stream_decoder_length_callback_))
1035                 return die_ss_("returned false", decoder);
1036         printf("OK\n");
1037
1038         printf("testing FLAC__seekable_stream_decoder_set_eof_callback()... ");
1039         if(!FLAC__seekable_stream_decoder_set_eof_callback(decoder, seekable_stream_decoder_eof_callback_))
1040                 return die_ss_("returned false", decoder);
1041         printf("OK\n");
1042
1043         printf("testing FLAC__seekable_stream_decoder_set_write_callback()... ");
1044         if(!FLAC__seekable_stream_decoder_set_write_callback(decoder, seekable_stream_decoder_write_callback_))
1045                 return die_ss_("returned false", decoder);
1046         printf("OK\n");
1047
1048         printf("testing FLAC__seekable_stream_decoder_set_metadata_callback()... ");
1049         if(!FLAC__seekable_stream_decoder_set_metadata_callback(decoder, seekable_stream_decoder_metadata_callback_))
1050                 return die_ss_("returned false", decoder);
1051         printf("OK\n");
1052
1053         printf("testing FLAC__seekable_stream_decoder_set_error_callback()... ");
1054         if(!FLAC__seekable_stream_decoder_set_error_callback(decoder, seekable_stream_decoder_error_callback_))
1055                 return die_ss_("returned false", decoder);
1056         printf("OK\n");
1057
1058         printf("testing FLAC__seekable_stream_decoder_set_client_data()... ");
1059         if(!FLAC__seekable_stream_decoder_set_client_data(decoder, &decoder_client_data))
1060                 return die_ss_("returned false", decoder);
1061         printf("OK\n");
1062
1063         printf("testing FLAC__seekable_stream_decoder_set_md5_checking()... ");
1064         if(!FLAC__seekable_stream_decoder_set_md5_checking(decoder, true))
1065                 return die_ss_("returned false", decoder);
1066         printf("OK\n");
1067
1068         printf("testing FLAC__seekable_stream_decoder_init()... ");
1069         if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
1070                 return die_ss_(0, decoder);
1071         printf("OK\n");
1072
1073         printf("testing FLAC__seekable_stream_decoder_get_state()... ");
1074         state = FLAC__seekable_stream_decoder_get_state(decoder);
1075         printf("returned state = %u (%s)... OK\n", state, FLAC__SeekableStreamDecoderStateString[state]);
1076
1077         printf("testing FLAC__seekable_stream_decoder_get_stream_decoder_state()... ");
1078         sstate = FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder);
1079         printf("returned state = %u (%s)... OK\n", sstate, FLAC__StreamDecoderStateString[sstate]);
1080
1081         decoder_client_data.current_metadata_number = 0;
1082         decoder_client_data.ignore_errors = false;
1083         decoder_client_data.error_occurred = false;
1084
1085         printf("opening FLAC file... ");
1086         decoder_client_data.file = fopen(flacfilename_, "rb");
1087         if(0 == decoder_client_data.file) {
1088                 printf("ERROR (%s)\n", strerror(errno));
1089                 return false;
1090         }
1091         printf("OK\n");
1092
1093         printf("testing FLAC__seekable_stream_decoder_get_md5_checking()... ");
1094         if(!FLAC__seekable_stream_decoder_get_md5_checking(decoder)) {
1095                 printf("FAILED, returned false, expected true\n");
1096                 return false;
1097         }
1098         printf("OK\n");
1099
1100         printf("testing FLAC__seekable_stream_decoder_process_until_end_of_metadata()... ");
1101         if(!FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder))
1102                 return die_ss_("returned false", decoder);
1103         printf("OK\n");
1104
1105         printf("testing FLAC__seekable_stream_decoder_process_single()... ");
1106         if(!FLAC__seekable_stream_decoder_process_single(decoder))
1107                 return die_ss_("returned false", decoder);
1108         printf("OK\n");
1109
1110         printf("testing FLAC__seekable_stream_decoder_skip_single_frame()... ");
1111         if(!FLAC__seekable_stream_decoder_skip_single_frame(decoder))
1112                 return die_ss_("returned false", decoder);
1113         printf("OK\n");
1114
1115         printf("testing FLAC__seekable_stream_decoder_flush()... ");
1116         if(!FLAC__seekable_stream_decoder_flush(decoder))
1117                 return die_ss_("returned false", decoder);
1118         printf("OK\n");
1119
1120         decoder_client_data.ignore_errors = true;
1121         printf("testing FLAC__seekable_stream_decoder_process_single()... ");
1122         if(!FLAC__seekable_stream_decoder_process_single(decoder))
1123                 return die_ss_("returned false", decoder);
1124         printf("OK\n");
1125         decoder_client_data.ignore_errors = false;
1126
1127         printf("testing FLAC__seekable_stream_decoder_seek_absolute()... ");
1128         if(!FLAC__seekable_stream_decoder_seek_absolute(decoder, 0))
1129                 return die_ss_("returned false", decoder);
1130         printf("OK\n");
1131
1132         printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
1133         if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
1134                 return die_ss_("returned false", decoder);
1135         printf("OK\n");
1136
1137         printf("testing FLAC__seekable_stream_decoder_get_channels()... ");
1138         {
1139                 unsigned channels = FLAC__seekable_stream_decoder_get_channels(decoder);
1140                 if(channels != streaminfo_.data.stream_info.channels) {
1141                         printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
1142                         return false;
1143                 }
1144         }
1145         printf("OK\n");
1146
1147         printf("testing FLAC__seekable_stream_decoder_get_bits_per_sample()... ");
1148         {
1149                 unsigned bits_per_sample = FLAC__seekable_stream_decoder_get_bits_per_sample(decoder);
1150                 if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
1151                         printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
1152                         return false;
1153                 }
1154         }
1155         printf("OK\n");
1156
1157         printf("testing FLAC__seekable_stream_decoder_get_sample_rate()... ");
1158         {
1159                 unsigned sample_rate = FLAC__seekable_stream_decoder_get_sample_rate(decoder);
1160                 if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
1161                         printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
1162                         return false;
1163                 }
1164         }
1165         printf("OK\n");
1166
1167         printf("testing FLAC__seekable_stream_decoder_get_blocksize()... ");
1168         {
1169                 unsigned blocksize = FLAC__seekable_stream_decoder_get_blocksize(decoder);
1170                 /* value could be anything since we're at the last block, so accept any answer */
1171                 printf("returned %u... OK\n", blocksize);
1172         }
1173
1174         printf("testing FLAC__seekable_stream_decoder_get_channel_assignment()... ");
1175         {
1176                 FLAC__ChannelAssignment ca = FLAC__seekable_stream_decoder_get_channel_assignment(decoder);
1177                 printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
1178         }
1179
1180         printf("testing FLAC__seekable_stream_decoder_reset()... ");
1181         if(!FLAC__seekable_stream_decoder_reset(decoder))
1182                 return die_ss_("returned false", decoder);
1183         printf("OK\n");
1184
1185         decoder_client_data.current_metadata_number = 0;
1186
1187         printf("rewinding input... ");
1188         if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) {
1189                 printf("FAILED, errno = %d\n", errno);
1190                 return false;
1191         }
1192         printf("OK\n");
1193
1194         printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
1195         if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
1196                 return die_ss_("returned false", decoder);
1197         printf("OK\n");
1198
1199         printf("testing FLAC__seekable_stream_decoder_finish()... ");
1200         (void) FLAC__seekable_stream_decoder_finish(decoder);
1201         printf("OK\n");
1202
1203         /*
1204          * respond all
1205          */
1206
1207         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1208         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1209                 return die_ss_("returned false", decoder);
1210         printf("OK\n");
1211
1212         num_expected_ = 0;
1213         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1214         expected_metadata_sequence_[num_expected_++] = &padding_;
1215         expected_metadata_sequence_[num_expected_++] = &seektable_;
1216         expected_metadata_sequence_[num_expected_++] = &application1_;
1217         expected_metadata_sequence_[num_expected_++] = &application2_;
1218         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1219         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1220         expected_metadata_sequence_[num_expected_++] = &unknown_;
1221
1222         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1223                 return false;
1224
1225         /*
1226          * ignore all
1227          */
1228
1229         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1230         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1231                 return die_ss_("returned false", decoder);
1232         printf("OK\n");
1233
1234         num_expected_ = 0;
1235
1236         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1237                 return false;
1238
1239         /*
1240          * respond all, ignore VORBIS_COMMENT
1241          */
1242
1243         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1244         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1245                 return die_ss_("returned false", decoder);
1246         printf("OK\n");
1247
1248         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
1249         if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1250                 return die_ss_("returned false", decoder);
1251         printf("OK\n");
1252
1253         num_expected_ = 0;
1254         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1255         expected_metadata_sequence_[num_expected_++] = &padding_;
1256         expected_metadata_sequence_[num_expected_++] = &seektable_;
1257         expected_metadata_sequence_[num_expected_++] = &application1_;
1258         expected_metadata_sequence_[num_expected_++] = &application2_;
1259         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1260         expected_metadata_sequence_[num_expected_++] = &unknown_;
1261
1262         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1263                 return false;
1264
1265         /*
1266          * respond all, ignore APPLICATION
1267          */
1268
1269         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1270         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1271                 return die_ss_("returned false", decoder);
1272         printf("OK\n");
1273
1274         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(APPLICATION)... ");
1275         if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1276                 return die_ss_("returned false", decoder);
1277         printf("OK\n");
1278
1279         num_expected_ = 0;
1280         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1281         expected_metadata_sequence_[num_expected_++] = &padding_;
1282         expected_metadata_sequence_[num_expected_++] = &seektable_;
1283         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1284         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1285         expected_metadata_sequence_[num_expected_++] = &unknown_;
1286
1287         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1288                 return false;
1289
1290         /*
1291          * respond all, ignore APPLICATION id of app#1
1292          */
1293
1294         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1295         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1296                 return die_ss_("returned false", decoder);
1297         printf("OK\n");
1298
1299         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1300         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1301                 return die_ss_("returned false", decoder);
1302         printf("OK\n");
1303
1304         num_expected_ = 0;
1305         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1306         expected_metadata_sequence_[num_expected_++] = &padding_;
1307         expected_metadata_sequence_[num_expected_++] = &seektable_;
1308         expected_metadata_sequence_[num_expected_++] = &application2_;
1309         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1310         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1311         expected_metadata_sequence_[num_expected_++] = &unknown_;
1312
1313         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1314                 return false;
1315
1316         /*
1317          * respond all, ignore APPLICATION id of app#1 & app#2
1318          */
1319
1320         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1321         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1322                 return die_ss_("returned false", decoder);
1323         printf("OK\n");
1324
1325         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1326         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1327                 return die_ss_("returned false", decoder);
1328         printf("OK\n");
1329
1330         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #2)... ");
1331         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
1332                 return die_ss_("returned false", decoder);
1333         printf("OK\n");
1334
1335         num_expected_ = 0;
1336         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1337         expected_metadata_sequence_[num_expected_++] = &padding_;
1338         expected_metadata_sequence_[num_expected_++] = &seektable_;
1339         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1340         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1341         expected_metadata_sequence_[num_expected_++] = &unknown_;
1342
1343         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1344                 return false;
1345
1346         /*
1347          * ignore all, respond VORBIS_COMMENT
1348          */
1349
1350         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1351         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1352                 return die_ss_("returned false", decoder);
1353         printf("OK\n");
1354
1355         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
1356         if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1357                 return die_ss_("returned false", decoder);
1358         printf("OK\n");
1359
1360         num_expected_ = 0;
1361         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1362
1363         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1364                 return false;
1365
1366         /*
1367          * ignore all, respond APPLICATION
1368          */
1369
1370         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1371         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1372                 return die_ss_("returned false", decoder);
1373         printf("OK\n");
1374
1375         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(APPLICATION)... ");
1376         if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1377                 return die_ss_("returned false", decoder);
1378         printf("OK\n");
1379
1380         num_expected_ = 0;
1381         expected_metadata_sequence_[num_expected_++] = &application1_;
1382         expected_metadata_sequence_[num_expected_++] = &application2_;
1383
1384         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1385                 return false;
1386
1387         /*
1388          * ignore all, respond APPLICATION id of app#1
1389          */
1390
1391         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1392         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1393                 return die_ss_("returned false", decoder);
1394         printf("OK\n");
1395
1396         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1397         if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1398                 return die_ss_("returned false", decoder);
1399         printf("OK\n");
1400
1401         num_expected_ = 0;
1402         expected_metadata_sequence_[num_expected_++] = &application1_;
1403
1404         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1405                 return false;
1406
1407         /*
1408          * ignore all, respond APPLICATION id of app#1 & app#2
1409          */
1410
1411         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1412         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1413                 return die_ss_("returned false", decoder);
1414         printf("OK\n");
1415
1416         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1417         if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1418                 return die_ss_("returned false", decoder);
1419         printf("OK\n");
1420
1421         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #2)... ");
1422         if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
1423                 return die_ss_("returned false", decoder);
1424         printf("OK\n");
1425
1426         num_expected_ = 0;
1427         expected_metadata_sequence_[num_expected_++] = &application1_;
1428         expected_metadata_sequence_[num_expected_++] = &application2_;
1429
1430         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1431                 return false;
1432
1433         /*
1434          * respond all, ignore APPLICATION, respond APPLICATION id of app#1
1435          */
1436
1437         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1438         if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1439                 return die_ss_("returned false", decoder);
1440         printf("OK\n");
1441
1442         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(APPLICATION)... ");
1443         if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1444                 return die_ss_("returned false", decoder);
1445         printf("OK\n");
1446
1447         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1448         if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1449                 return die_ss_("returned false", decoder);
1450         printf("OK\n");
1451
1452         num_expected_ = 0;
1453         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1454         expected_metadata_sequence_[num_expected_++] = &padding_;
1455         expected_metadata_sequence_[num_expected_++] = &seektable_;
1456         expected_metadata_sequence_[num_expected_++] = &application1_;
1457         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1458         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1459         expected_metadata_sequence_[num_expected_++] = &unknown_;
1460
1461         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1462                 return false;
1463
1464         /*
1465          * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
1466          */
1467
1468         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1469         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1470                 return die_ss_("returned false", decoder);
1471         printf("OK\n");
1472
1473         printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(APPLICATION)... ");
1474         if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1475                 return die_ss_("returned false", decoder);
1476         printf("OK\n");
1477
1478         printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1479         if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1480                 return die_ss_("returned false", decoder);
1481         printf("OK\n");
1482
1483         num_expected_ = 0;
1484         expected_metadata_sequence_[num_expected_++] = &application2_;
1485
1486         if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1487                 return false;
1488
1489         /* done, now leave the sequence the way we found it... */
1490         num_expected_ = 0;
1491         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1492         expected_metadata_sequence_[num_expected_++] = &padding_;
1493         expected_metadata_sequence_[num_expected_++] = &seektable_;
1494         expected_metadata_sequence_[num_expected_++] = &application1_;
1495         expected_metadata_sequence_[num_expected_++] = &application2_;
1496         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1497         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1498         expected_metadata_sequence_[num_expected_++] = &unknown_;
1499
1500         printf("testing FLAC__seekable_stream_decoder_delete()... ");
1501         FLAC__seekable_stream_decoder_delete(decoder);
1502         printf("OK\n");
1503
1504         fclose(decoder_client_data.file);
1505
1506         printf("\nPASSED!\n");
1507
1508         return true;
1509 }
1510
1511 static FLAC__StreamDecoderWriteStatus file_decoder_write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
1512 {
1513         (void)decoder;
1514         return stream_decoder_write_callback_(0, frame, buffer, client_data);
1515 }
1516
1517 static void file_decoder_metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
1518 {
1519         (void)decoder;
1520         stream_decoder_metadata_callback_(0, metadata, client_data);
1521 }
1522
1523 static void file_decoder_error_callback_(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
1524 {
1525         (void)decoder;
1526         stream_decoder_error_callback_(0, status, client_data);
1527 }
1528
1529 static FLAC__bool file_decoder_test_respond_(FLAC__FileDecoder *decoder, file_decoder_client_data_struct *dcd)
1530 {
1531         if(!FLAC__file_decoder_set_write_callback(decoder, file_decoder_write_callback_))
1532                 return die_f_("at FLAC__file_decoder_set_write_callback(), returned false", decoder);
1533
1534         if(!FLAC__file_decoder_set_metadata_callback(decoder, file_decoder_metadata_callback_))
1535                 return die_f_("at FLAC__file_decoder_set_metadata_callback(), returned false", decoder);
1536
1537         if(!FLAC__file_decoder_set_error_callback(decoder, file_decoder_error_callback_))
1538                 return die_f_("at FLAC__file_decoder_set_error_callback(), returned false", decoder);
1539
1540         if(!FLAC__file_decoder_set_client_data(decoder, dcd))
1541                 return die_f_("at FLAC__file_decoder_set_client_data(), returned false", decoder);
1542
1543         if(!FLAC__file_decoder_set_filename(decoder, flacfilename_))
1544                 return die_f_("at FLAC__file_decoder_set_filename(), returned false", decoder);
1545
1546         if(!FLAC__file_decoder_set_md5_checking(decoder, true))
1547                 return die_f_("at FLAC__file_decoder_set_md5_checking(), returned false", decoder);
1548
1549         printf("testing FLAC__file_decoder_init()... ");
1550         if(FLAC__file_decoder_init(decoder) != FLAC__FILE_DECODER_OK)
1551                 return die_f_(0, decoder);
1552         printf("OK\n");
1553
1554         dcd->current_metadata_number = 0;
1555
1556         printf("testing FLAC__file_decoder_process_until_end_of_file()... ");
1557         if(!FLAC__file_decoder_process_until_end_of_file(decoder))
1558                 return die_f_("returned false", decoder);
1559         printf("OK\n");
1560
1561         printf("testing FLAC__file_decoder_finish()... ");
1562         (void) FLAC__file_decoder_finish(decoder);
1563         printf("OK\n");
1564
1565         return true;
1566 }
1567
1568 static FLAC__bool test_file_decoder()
1569 {
1570         FLAC__FileDecoder *decoder;
1571         FLAC__FileDecoderState state;
1572         FLAC__SeekableStreamDecoderState ssstate;
1573         FLAC__StreamDecoderState sstate;
1574         seekable_stream_decoder_client_data_struct decoder_client_data;
1575
1576         printf("\n+++ libFLAC unit test: FLAC__FileDecoder\n\n");
1577
1578         printf("testing FLAC__file_decoder_new()... ");
1579         decoder = FLAC__file_decoder_new();
1580         if(0 == decoder) {
1581                 printf("FAILED, returned NULL\n");
1582                 return false;
1583         }
1584         printf("OK\n");
1585
1586         printf("testing FLAC__file_decoder_delete()... ");
1587         FLAC__file_decoder_delete(decoder);
1588         printf("OK\n");
1589
1590         printf("testing FLAC__file_decoder_new()... ");
1591         decoder = FLAC__file_decoder_new();
1592         if(0 == decoder) {
1593                 printf("FAILED, returned NULL\n");
1594                 return false;
1595         }
1596         printf("OK\n");
1597
1598         printf("testing FLAC__file_decoder_init()... ");
1599         if(FLAC__file_decoder_init(decoder) == FLAC__FILE_DECODER_OK)
1600                 return die_f_(0, decoder);
1601         printf("OK\n");
1602
1603         printf("testing FLAC__file_decoder_delete()... ");
1604         FLAC__file_decoder_delete(decoder);
1605         printf("OK\n");
1606
1607         num_expected_ = 0;
1608         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1609
1610         printf("testing FLAC__file_decoder_new()... ");
1611         decoder = FLAC__file_decoder_new();
1612         if(0 == decoder) {
1613                 printf("FAILED, returned NULL\n");
1614                 return false;
1615         }
1616         printf("OK\n");
1617
1618         printf("testing FLAC__file_decoder_set_write_callback()... ");
1619         if(!FLAC__file_decoder_set_write_callback(decoder, file_decoder_write_callback_))
1620                 return die_f_("returned false", decoder);
1621         printf("OK\n");
1622
1623         printf("testing FLAC__file_decoder_set_metadata_callback()... ");
1624         if(!FLAC__file_decoder_set_metadata_callback(decoder, file_decoder_metadata_callback_))
1625                 return die_f_("returned false", decoder);
1626         printf("OK\n");
1627
1628         printf("testing FLAC__file_decoder_set_error_callback()... ");
1629         if(!FLAC__file_decoder_set_error_callback(decoder, file_decoder_error_callback_))
1630                 return die_f_("returned false", decoder);
1631         printf("OK\n");
1632
1633         printf("testing FLAC__file_decoder_set_client_data()... ");
1634         if(!FLAC__file_decoder_set_client_data(decoder, &decoder_client_data))
1635                 return die_f_("returned false", decoder);
1636         printf("OK\n");
1637
1638         printf("testing FLAC__file_decoder_set_filename()... ");
1639         if(!FLAC__file_decoder_set_filename(decoder, flacfilename_))
1640                 return die_f_("returned false", decoder);
1641         printf("OK\n");
1642
1643         printf("testing FLAC__file_decoder_set_md5_checking()... ");
1644         if(!FLAC__file_decoder_set_md5_checking(decoder, true))
1645                 return die_f_("returned false", decoder);
1646         printf("OK\n");
1647
1648         printf("testing FLAC__file_decoder_init()... ");
1649         if(FLAC__file_decoder_init(decoder) != FLAC__FILE_DECODER_OK)
1650                 return die_f_(0, decoder);
1651         printf("OK\n");
1652
1653         printf("testing FLAC__file_decoder_get_state()... ");
1654         state = FLAC__file_decoder_get_state(decoder);
1655         printf("returned state = %u (%s)... OK\n", state, FLAC__FileDecoderStateString[state]);
1656
1657         printf("testing FLAC__file_decoder_get_seekable_stream_decoder_state()... ");
1658         ssstate = FLAC__file_decoder_get_seekable_stream_decoder_state(decoder);
1659         printf("returned state = %u (%s)... OK\n", ssstate, FLAC__SeekableStreamDecoderStateString[ssstate]);
1660
1661         printf("testing FLAC__file_decoder_get_stream_decoder_state()... ");
1662         sstate = FLAC__file_decoder_get_stream_decoder_state(decoder);
1663         printf("returned state = %u (%s)... OK\n", sstate, FLAC__StreamDecoderStateString[sstate]);
1664
1665         decoder_client_data.current_metadata_number = 0;
1666         decoder_client_data.ignore_errors = false;
1667         decoder_client_data.error_occurred = false;
1668
1669         printf("testing FLAC__file_decoder_get_md5_checking()... ");
1670         if(!FLAC__file_decoder_get_md5_checking(decoder)) {
1671                 printf("FAILED, returned false, expected true\n");
1672                 return false;
1673         }
1674         printf("OK\n");
1675
1676         printf("testing FLAC__file_decoder_process_until_end_of_metadata()... ");
1677         if(!FLAC__file_decoder_process_until_end_of_metadata(decoder))
1678                 return die_f_("returned false", decoder);
1679         printf("OK\n");
1680
1681         printf("testing FLAC__file_decoder_process_single()... ");
1682         if(!FLAC__file_decoder_process_single(decoder))
1683                 return die_f_("returned false", decoder);
1684         printf("OK\n");
1685
1686         printf("testing FLAC__file_decoder_skip_single_frame()... ");
1687         if(!FLAC__file_decoder_skip_single_frame(decoder))
1688                 return die_f_("returned false", decoder);
1689         printf("OK\n");
1690
1691         printf("testing FLAC__file_decoder_seek_absolute()... ");
1692         if(!FLAC__file_decoder_seek_absolute(decoder, 0))
1693                 return die_f_("returned false", decoder);
1694         printf("OK\n");
1695
1696         printf("testing FLAC__file_decoder_process_until_end_of_file()... ");
1697         if(!FLAC__file_decoder_process_until_end_of_file(decoder))
1698                 return die_f_("returned false", decoder);
1699         printf("OK\n");
1700
1701         printf("testing FLAC__file_decoder_get_channels()... ");
1702         {
1703                 unsigned channels = FLAC__file_decoder_get_channels(decoder);
1704                 if(channels != streaminfo_.data.stream_info.channels) {
1705                         printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
1706                         return false;
1707                 }
1708         }
1709         printf("OK\n");
1710
1711         printf("testing FLAC__file_decoder_get_bits_per_sample()... ");
1712         {
1713                 unsigned bits_per_sample = FLAC__file_decoder_get_bits_per_sample(decoder);
1714                 if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
1715                         printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
1716                         return false;
1717                 }
1718         }
1719         printf("OK\n");
1720
1721         printf("testing FLAC__file_decoder_get_sample_rate()... ");
1722         {
1723                 unsigned sample_rate = FLAC__file_decoder_get_sample_rate(decoder);
1724                 if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
1725                         printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
1726                         return false;
1727                 }
1728         }
1729         printf("OK\n");
1730
1731         printf("testing FLAC__file_decoder_get_blocksize()... ");
1732         {
1733                 unsigned blocksize = FLAC__file_decoder_get_blocksize(decoder);
1734                 /* value could be anything since we're at the last block, so accept any answer */
1735                 printf("returned %u... OK\n", blocksize);
1736         }
1737
1738         printf("testing FLAC__file_decoder_get_channel_assignment()... ");
1739         {
1740                 FLAC__ChannelAssignment ca = FLAC__file_decoder_get_channel_assignment(decoder);
1741                 printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
1742         }
1743
1744         printf("testing FLAC__file_decoder_finish()... ");
1745         (void) FLAC__file_decoder_finish(decoder);
1746         printf("OK\n");
1747
1748         /*
1749          * respond all
1750          */
1751
1752         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1753         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1754                 return die_f_("returned false", decoder);
1755         printf("OK\n");
1756
1757         num_expected_ = 0;
1758         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1759         expected_metadata_sequence_[num_expected_++] = &padding_;
1760         expected_metadata_sequence_[num_expected_++] = &seektable_;
1761         expected_metadata_sequence_[num_expected_++] = &application1_;
1762         expected_metadata_sequence_[num_expected_++] = &application2_;
1763         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1764         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1765         expected_metadata_sequence_[num_expected_++] = &unknown_;
1766
1767         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1768                 return false;
1769
1770         /*
1771          * ignore all
1772          */
1773
1774         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1775         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1776                 return die_f_("returned false", decoder);
1777         printf("OK\n");
1778
1779         num_expected_ = 0;
1780
1781         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1782                 return false;
1783
1784         /*
1785          * respond all, ignore VORBIS_COMMENT
1786          */
1787
1788         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1789         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1790                 return die_f_("returned false", decoder);
1791         printf("OK\n");
1792
1793         printf("testing FLAC__file_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
1794         if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1795                 return die_f_("returned false", decoder);
1796         printf("OK\n");
1797
1798         num_expected_ = 0;
1799         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1800         expected_metadata_sequence_[num_expected_++] = &padding_;
1801         expected_metadata_sequence_[num_expected_++] = &seektable_;
1802         expected_metadata_sequence_[num_expected_++] = &application1_;
1803         expected_metadata_sequence_[num_expected_++] = &application2_;
1804         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1805         expected_metadata_sequence_[num_expected_++] = &unknown_;
1806
1807         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1808                 return false;
1809
1810         /*
1811          * respond all, ignore APPLICATION
1812          */
1813
1814         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1815         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1816                 return die_f_("returned false", decoder);
1817         printf("OK\n");
1818
1819         printf("testing FLAC__file_decoder_set_metadata_ignore(APPLICATION)... ");
1820         if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1821                 return die_f_("returned false", decoder);
1822         printf("OK\n");
1823
1824         num_expected_ = 0;
1825         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1826         expected_metadata_sequence_[num_expected_++] = &padding_;
1827         expected_metadata_sequence_[num_expected_++] = &seektable_;
1828         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1829         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1830         expected_metadata_sequence_[num_expected_++] = &unknown_;
1831
1832         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1833                 return false;
1834
1835         /*
1836          * respond all, ignore APPLICATION id of app#1
1837          */
1838
1839         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1840         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1841                 return die_f_("returned false", decoder);
1842         printf("OK\n");
1843
1844         printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
1845         if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1846                 return die_f_("returned false", decoder);
1847         printf("OK\n");
1848
1849         num_expected_ = 0;
1850         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1851         expected_metadata_sequence_[num_expected_++] = &padding_;
1852         expected_metadata_sequence_[num_expected_++] = &seektable_;
1853         expected_metadata_sequence_[num_expected_++] = &application2_;
1854         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1855         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1856         expected_metadata_sequence_[num_expected_++] = &unknown_;
1857
1858         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1859                 return false;
1860
1861         /*
1862          * respond all, ignore APPLICATION id of app#1 & app#2
1863          */
1864
1865         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1866         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1867                 return die_f_("returned false", decoder);
1868         printf("OK\n");
1869
1870         printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
1871         if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1872                 return die_f_("returned false", decoder);
1873         printf("OK\n");
1874
1875         printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #2)... ");
1876         if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
1877                 return die_f_("returned false", decoder);
1878         printf("OK\n");
1879
1880         num_expected_ = 0;
1881         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1882         expected_metadata_sequence_[num_expected_++] = &padding_;
1883         expected_metadata_sequence_[num_expected_++] = &seektable_;
1884         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1885         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1886         expected_metadata_sequence_[num_expected_++] = &unknown_;
1887
1888         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1889                 return false;
1890
1891         /*
1892          * ignore all, respond VORBIS_COMMENT
1893          */
1894
1895         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1896         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1897                 return die_f_("returned false", decoder);
1898         printf("OK\n");
1899
1900         printf("testing FLAC__file_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
1901         if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1902                 return die_f_("returned false", decoder);
1903         printf("OK\n");
1904
1905         num_expected_ = 0;
1906         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1907
1908         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1909                 return false;
1910
1911         /*
1912          * ignore all, respond APPLICATION
1913          */
1914
1915         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1916         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1917                 return die_f_("returned false", decoder);
1918         printf("OK\n");
1919
1920         printf("testing FLAC__file_decoder_set_metadata_respond(APPLICATION)... ");
1921         if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1922                 return die_f_("returned false", decoder);
1923         printf("OK\n");
1924
1925         num_expected_ = 0;
1926         expected_metadata_sequence_[num_expected_++] = &application1_;
1927         expected_metadata_sequence_[num_expected_++] = &application2_;
1928
1929         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1930                 return false;
1931
1932         /*
1933          * ignore all, respond APPLICATION id of app#1
1934          */
1935
1936         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1937         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1938                 return die_f_("returned false", decoder);
1939         printf("OK\n");
1940
1941         printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1942         if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1943                 return die_f_("returned false", decoder);
1944         printf("OK\n");
1945
1946         num_expected_ = 0;
1947         expected_metadata_sequence_[num_expected_++] = &application1_;
1948
1949         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1950                 return false;
1951
1952         /*
1953          * ignore all, respond APPLICATION id of app#1 & app#2
1954          */
1955
1956         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1957         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1958                 return die_f_("returned false", decoder);
1959         printf("OK\n");
1960
1961         printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1962         if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1963                 return die_f_("returned false", decoder);
1964         printf("OK\n");
1965
1966         printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #2)... ");
1967         if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
1968                 return die_f_("returned false", decoder);
1969         printf("OK\n");
1970
1971         num_expected_ = 0;
1972         expected_metadata_sequence_[num_expected_++] = &application1_;
1973         expected_metadata_sequence_[num_expected_++] = &application2_;
1974
1975         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1976                 return false;
1977
1978         /*
1979          * respond all, ignore APPLICATION, respond APPLICATION id of app#1
1980          */
1981
1982         printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1983         if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1984                 return die_f_("returned false", decoder);
1985         printf("OK\n");
1986
1987         printf("testing FLAC__file_decoder_set_metadata_ignore(APPLICATION)... ");
1988         if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1989                 return die_f_("returned false", decoder);
1990         printf("OK\n");
1991
1992         printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1993         if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1994                 return die_f_("returned false", decoder);
1995         printf("OK\n");
1996
1997         num_expected_ = 0;
1998         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1999         expected_metadata_sequence_[num_expected_++] = &padding_;
2000         expected_metadata_sequence_[num_expected_++] = &seektable_;
2001         expected_metadata_sequence_[num_expected_++] = &application1_;
2002         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
2003         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
2004         expected_metadata_sequence_[num_expected_++] = &unknown_;
2005
2006         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
2007                 return false;
2008
2009         /*
2010          * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
2011          */
2012
2013         printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
2014         if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
2015                 return die_f_("returned false", decoder);
2016         printf("OK\n");
2017
2018         printf("testing FLAC__file_decoder_set_metadata_respond(APPLICATION)... ");
2019         if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
2020                 return die_f_("returned false", decoder);
2021         printf("OK\n");
2022
2023         printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
2024         if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
2025                 return die_f_("returned false", decoder);
2026         printf("OK\n");
2027
2028         num_expected_ = 0;
2029         expected_metadata_sequence_[num_expected_++] = &application2_;
2030
2031         if(!file_decoder_test_respond_(decoder, &decoder_client_data))
2032                 return false;
2033
2034         /* done, now leave the sequence the way we found it... */
2035         num_expected_ = 0;
2036         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
2037         expected_metadata_sequence_[num_expected_++] = &padding_;
2038         expected_metadata_sequence_[num_expected_++] = &seektable_;
2039         expected_metadata_sequence_[num_expected_++] = &application1_;
2040         expected_metadata_sequence_[num_expected_++] = &application2_;
2041         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
2042         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
2043         expected_metadata_sequence_[num_expected_++] = &unknown_;
2044
2045         printf("testing FLAC__file_decoder_delete()... ");
2046         FLAC__file_decoder_delete(decoder);
2047         printf("OK\n");
2048
2049         printf("\nPASSED!\n");
2050
2051         return true;
2052 }
2053
2054 FLAC__bool test_decoders()
2055 {
2056         init_metadata_blocks_();
2057         if(!generate_file_())
2058                 return false;
2059
2060         if(!test_stream_decoder())
2061                 return false;
2062
2063         if(!test_seekable_stream_decoder())
2064                 return false;
2065
2066         if(!test_file_decoder())
2067                 return false;
2068
2069         (void) grabbag__file_remove_file(flacfilename_);
2070         free_metadata_blocks_();
2071
2072         return true;
2073 }