src/test_libOggFLAC/decoders.c

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