src/test_libOggFLAC/decoders.c

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