src/test_libFLAC/decoders.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2002-2009  Josh Coalson
   3  * Copyright (C) 2011-2013  Xiph.Org Foundation
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 #  include <config.h>
  22 #endif
  23
  24 #include <errno.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "decoders.h"
  29 #include "FLAC/assert.h"
  30 #include "FLAC/stream_decoder.h"
  31 #include "share/grabbag.h"
  32 #include "share/compat.h"
  33 #include "share/safe_str.h"
  34 #include "test_libs_common/file_utils_flac.h"
  35 #include "test_libs_common/metadata_utils.h"
  36
  37 typedef enum {
  38         LAYER_STREAM = 0, /* FLAC__stream_decoder_init_[ogg_]stream() without seeking */
  39         LAYER_SEEKABLE_STREAM, /* FLAC__stream_decoder_init_[ogg_]stream() with seeking */
  40         LAYER_FILE, /* FLAC__stream_decoder_init_[ogg_]FILE() */
  41         LAYER_FILENAME /* FLAC__stream_decoder_init_[ogg_]file() */
  42 } Layer;
  43
  44 static const char * const LayerString[] = {
  45         "Stream",
  46         "Seekable Stream",
  47         "FILE*",
  48         "Filename"
  49 };
  50
  51 typedef struct {
  52         Layer layer;
  53         FILE *file;
  54         char filename[512];
  55         unsigned current_metadata_number;
  56         FLAC__bool ignore_errors;
  57         FLAC__bool error_occurred;
  58 } StreamDecoderClientData;
  59
  60 static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, picture_, unknown_;
  61 static FLAC__StreamMetadata *expected_metadata_sequence_[9];
  62 static unsigned num_expected_;
  63 static FLAC__off_t flacfilesize_;
  64
  65 static const char *flacfilename(FLAC__bool is_ogg)
  66 {
  67         return is_ogg? "metadata.oga" : "metadata.flac";
  68 }
  69
  70 static FLAC__bool die_(const char *msg)
  71 {
  72         printf("ERROR: %s\n", msg);
  73         return false;
  74 }
  75
  76 static FLAC__bool die_s_(const char *msg, const FLAC__StreamDecoder *decoder)
  77 {
  78         FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
  79
  80         if(msg)
  81                 printf("FAILED, %s", msg);
  82         else
  83                 printf("FAILED");
  84
  85         printf(", state = %u (%s)\n", (unsigned)state, FLAC__StreamDecoderStateString[state]);
  86
  87         return false;
  88 }
  89
  90 static void open_test_file(StreamDecoderClientData * pdcd, int is_ogg, const char * mode)
  91 {
  92         pdcd->file = flac_fopen(flacfilename(is_ogg), mode);
  93         safe_strncpy(pdcd->filename, flacfilename(is_ogg), sizeof (pdcd->filename));
  94 }
  95
  96 static void init_metadata_blocks_(void)
  97 {
  98         mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
  99 }
 100
 101 static void free_metadata_blocks_(void)
 102 {
 103         mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
 104 }
 105
 106 static FLAC__bool generate_file_(FLAC__bool is_ogg)
 107 {
 108         printf("\n\ngenerating %sFLAC file for decoder tests...\n", is_ogg? "Ogg ":"");
 109
 110         num_expected_ = 0;
 111         expected_metadata_sequence_[num_expected_++] = &padding_;
 112         expected_metadata_sequence_[num_expected_++] = &seektable_;
 113         expected_metadata_sequence_[num_expected_++] = &application1_;
 114         expected_metadata_sequence_[num_expected_++] = &application2_;
 115         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 116         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 117         expected_metadata_sequence_[num_expected_++] = &picture_;
 118         expected_metadata_sequence_[num_expected_++] = &unknown_;
 119         /* WATCHOUT: for Ogg FLAC the encoder should move the VORBIS_COMMENT block to the front, right after STREAMINFO */
 120
 121         if(!file_utils__generate_flacfile(is_ogg, flacfilename(is_ogg), &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
 122                 return die_("creating the encoded file");
 123
 124         return true;
 125 }
 126
 127 static FLAC__StreamDecoderReadStatus stream_decoder_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
 128 {
 129         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 130         const size_t requested_bytes = *bytes;
 131
 132         (void)decoder;
 133
 134         if(0 == dcd) {
 135                 printf("ERROR: client_data in read callback is NULL\n");
 136                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 137         }
 138
 139         if(dcd->error_occurred)
 140                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 141
 142         if(feof(dcd->file)) {
 143                 *bytes = 0;
 144                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 145         }
 146         else if(requested_bytes > 0) {
 147                 *bytes = fread(buffer, 1, requested_bytes, dcd->file);
 148                 if(*bytes == 0) {
 149                         if(feof(dcd->file))
 150                                 return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
 151                         else
 152                                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 153                 }
 154                 else {
 155                         return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 156                 }
 157         }
 158         else
 159                 return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
 160 }
 161
 162 static FLAC__StreamDecoderSeekStatus stream_decoder_seek_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 163 {
 164         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 165
 166         (void)decoder;
 167
 168         if(0 == dcd) {
 169                 printf("ERROR: client_data in seek callback is NULL\n");
 170                 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 171         }
 172
 173         if(dcd->error_occurred)
 174                 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 175
 176         if(fseeko(dcd->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0) {
 177                 dcd->error_occurred = true;
 178                 return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 179         }
 180
 181         return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 182 }
 183
 184 static FLAC__StreamDecoderTellStatus stream_decoder_tell_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 185 {
 186         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 187         FLAC__off_t offset;
 188
 189         (void)decoder;
 190
 191         if(0 == dcd) {
 192                 printf("ERROR: client_data in tell callback is NULL\n");
 193                 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 194         }
 195
 196         if(dcd->error_occurred)
 197                 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 198
 199         offset = ftello(dcd->file);
 200         *absolute_byte_offset = (FLAC__uint64)offset;
 201
 202         if(offset < 0) {
 203                 dcd->error_occurred = true;
 204                 return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 205         }
 206
 207         return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 208 }
 209
 210 static FLAC__StreamDecoderLengthStatus stream_decoder_length_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 211 {
 212         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 213
 214         (void)decoder;
 215
 216         if(0 == dcd) {
 217                 printf("ERROR: client_data in length callback is NULL\n");
 218                 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 219         }
 220
 221         if(dcd->error_occurred)
 222                 return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 223
 224         *stream_length = (FLAC__uint64)flacfilesize_;
 225         return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 226 }
 227
 228 static FLAC__bool stream_decoder_eof_callback_(const FLAC__StreamDecoder *decoder, void *client_data)
 229 {
 230         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 231
 232         (void)decoder;
 233
 234         if(0 == dcd) {
 235                 printf("ERROR: client_data in eof callback is NULL\n");
 236                 return true;
 237         }
 238
 239         if(dcd->error_occurred)
 240                 return true;
 241
 242         return feof(dcd->file);
 243 }
 244
 245 static FLAC__StreamDecoderWriteStatus stream_decoder_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 246 {
 247         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 248
 249         (void)decoder, (void)buffer;
 250
 251         if(0 == dcd) {
 252                 printf("ERROR: client_data in write callback is NULL\n");
 253                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 254         }
 255
 256         if(dcd->error_occurred)
 257                 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 258
 259         if(
 260                 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
 261                 (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
 262         ) {
 263                 printf("content... ");
 264                 fflush(stdout);
 265         }
 266
 267         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 268 }
 269
 270 static void stream_decoder_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
 271 {
 272         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 273
 274         (void)decoder;
 275
 276         if(0 == dcd) {
 277                 printf("ERROR: client_data in metadata callback is NULL\n");
 278                 return;
 279         }
 280
 281         if(dcd->error_occurred)
 282                 return;
 283
 284         printf("%d... ", dcd->current_metadata_number);
 285         fflush(stdout);
 286
 287         if(dcd->current_metadata_number >= num_expected_) {
 288                 (void)die_("got more metadata blocks than expected");
 289                 dcd->error_occurred = true;
 290         }
 291         else {
 292                 if(!mutils__compare_block(expected_metadata_sequence_[dcd->current_metadata_number], metadata)) {
 293                         (void)die_("metadata block mismatch");
 294                         dcd->error_occurred = true;
 295                 }
 296         }
 297         dcd->current_metadata_number++;
 298 }
 299
 300 static void stream_decoder_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 301 {
 302         StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 303
 304         (void)decoder;
 305
 306         if(0 == dcd) {
 307                 printf("ERROR: client_data in error callback is NULL\n");
 308                 return;
 309         }
 310
 311         if(!dcd->ignore_errors) {
 312                 printf("ERROR: got error callback: err = %u (%s)\n", (unsigned)status, FLAC__StreamDecoderErrorStatusString[status]);
 313                 dcd->error_occurred = true;
 314         }
 315 }
 316
 317 static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, StreamDecoderClientData *dcd, FLAC__bool is_ogg)
 318 {
 319         FLAC__StreamDecoderInitStatus init_status;
 320
 321         if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
 322                 return die_s_("at FLAC__stream_decoder_set_md5_checking(), returned false", decoder);
 323
 324         /* for FLAC__stream_encoder_init_FILE(), the FLAC__stream_encoder_finish() closes the file so we have to keep re-opening: */
 325         if(dcd->layer == LAYER_FILE) {
 326                 printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
 327                 open_test_file(dcd, is_ogg, "rb");
 328                 if(0 == dcd->file) {
 329                         printf("ERROR (%s)\n", strerror(errno));
 330                         return false;
 331                 }
 332                 printf("OK\n");
 333         }
 334
 335         switch(dcd->layer) {
 336                 case LAYER_STREAM:
 337                         printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 338                         init_status = is_ogg?
 339                                 FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 340                                 FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd)
 341                         ;
 342                         break;
 343                 case LAYER_SEEKABLE_STREAM:
 344                         printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 345                         init_status = is_ogg?
 346                                 FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 347                                 FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 348                         break;
 349                 case LAYER_FILE:
 350                         printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 351                         init_status = is_ogg?
 352                                 FLAC__stream_decoder_init_ogg_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 353                                 FLAC__stream_decoder_init_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 354                         break;
 355                 case LAYER_FILENAME:
 356                         printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 357                         init_status = is_ogg?
 358                                 FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 359                                 FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 360                         break;
 361                 default:
 362                         die_("internal error 000");
 363                         return false;
 364         }
 365         if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
 366                 return die_s_(0, decoder);
 367         printf("OK\n");
 368
 369         dcd->current_metadata_number = 0;
 370
 371         if(dcd->layer < LAYER_FILE && fseeko(dcd->file, 0, SEEK_SET) < 0) {
 372                 printf("FAILED rewinding input, errno = %d\n", errno);
 373                 return false;
 374         }
 375
 376         printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 377         if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 378                 return die_s_("returned false", decoder);
 379         printf("OK\n");
 380
 381         printf("testing FLAC__stream_decoder_finish()... ");
 382         if(!FLAC__stream_decoder_finish(decoder))
 383                 return die_s_("returned false", decoder);
 384         printf("OK\n");
 385
 386         return true;
 387 }
 388
 389 static FLAC__bool test_stream_decoder(Layer layer, FLAC__bool is_ogg)
 390 {
 391         FLAC__StreamDecoder *decoder;
 392         FLAC__StreamDecoderInitStatus init_status;
 393         FLAC__StreamDecoderState state;
 394         StreamDecoderClientData decoder_client_data;
 395         FLAC__bool expect;
 396
 397         decoder_client_data.layer = layer;
 398
 399         printf("\n+++ libFLAC unit test: FLAC__StreamDecoder (layer: %s, format: %s)\n\n", LayerString[layer], is_ogg? "Ogg FLAC" : "FLAC");
 400
 401         printf("testing FLAC__stream_decoder_new()... ");
 402         decoder = FLAC__stream_decoder_new();
 403         if(0 == decoder) {
 404                 printf("FAILED, returned NULL\n");
 405                 return false;
 406         }
 407         printf("OK\n");
 408
 409         printf("testing FLAC__stream_decoder_delete()... ");
 410         FLAC__stream_decoder_delete(decoder);
 411         printf("OK\n");
 412
 413         printf("testing FLAC__stream_decoder_new()... ");
 414         decoder = FLAC__stream_decoder_new();
 415         if(0 == decoder) {
 416                 printf("FAILED, returned NULL\n");
 417                 return false;
 418         }
 419         printf("OK\n");
 420
 421         switch(layer) {
 422                 case LAYER_STREAM:
 423                 case LAYER_SEEKABLE_STREAM:
 424                         printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 425                         init_status = is_ogg?
 426                                 FLAC__stream_decoder_init_ogg_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0) :
 427                                 FLAC__stream_decoder_init_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 428                         break;
 429                 case LAYER_FILE:
 430                         printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 431                         init_status = is_ogg?
 432                                 FLAC__stream_decoder_init_ogg_FILE(decoder, stdin, 0, 0, 0, 0) :
 433                                 FLAC__stream_decoder_init_FILE(decoder, stdin, 0, 0, 0, 0);
 434                         break;
 435                 case LAYER_FILENAME:
 436                         printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 437                         init_status = is_ogg?
 438                                 FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0) :
 439                                 FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0);
 440                         break;
 441                 default:
 442                         die_("internal error 003");
 443                         return false;
 444         }
 445         if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS)
 446                 return die_s_(0, decoder);
 447         printf("OK\n");
 448
 449         printf("testing FLAC__stream_decoder_delete()... ");
 450         FLAC__stream_decoder_delete(decoder);
 451         printf("OK\n");
 452
 453         num_expected_ = 0;
 454         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 455
 456         printf("testing FLAC__stream_decoder_new()... ");
 457         decoder = FLAC__stream_decoder_new();
 458         if(0 == decoder) {
 459                 printf("FAILED, returned NULL\n");
 460                 return false;
 461         }
 462         printf("OK\n");
 463
 464         if(is_ogg) {
 465                 printf("testing FLAC__stream_decoder_set_ogg_serial_number()... ");
 466                 if(!FLAC__stream_decoder_set_ogg_serial_number(decoder, file_utils__ogg_serial_number))
 467                         return die_s_("returned false", decoder);
 468                 printf("OK\n");
 469         }
 470
 471         printf("testing FLAC__stream_decoder_set_md5_checking()... ");
 472         if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
 473                 return die_s_("returned false", decoder);
 474         printf("OK\n");
 475
 476         if(layer < LAYER_FILENAME) {
 477                 printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
 478                 open_test_file(&decoder_client_data, is_ogg, "rb");
 479                 if(0 == decoder_client_data.file) {
 480                         printf("ERROR (%s)\n", strerror(errno));
 481                         return false;
 482                 }
 483                 printf("OK\n");
 484         }
 485
 486         switch(layer) {
 487                 case LAYER_STREAM:
 488                         printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 489                         init_status = is_ogg?
 490                                 FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 491                                 FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 492                         break;
 493                 case LAYER_SEEKABLE_STREAM:
 494                         printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 495                         init_status = is_ogg?
 496                                 FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 497                                 FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 498                         break;
 499                 case LAYER_FILE:
 500                         printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 501                         init_status = is_ogg?
 502                                 FLAC__stream_decoder_init_ogg_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 503                                 FLAC__stream_decoder_init_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 504                         break;
 505                 case LAYER_FILENAME:
 506                         printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 507                         init_status = is_ogg?
 508                                 FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 509                                 FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 510                         break;
 511                 default:
 512                         die_("internal error 009");
 513                         return false;
 514         }
 515         if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
 516                 return die_s_(0, decoder);
 517         printf("OK\n");
 518
 519         printf("testing FLAC__stream_decoder_get_state()... ");
 520         state = FLAC__stream_decoder_get_state(decoder);
 521         printf("returned state = %u (%s)... OK\n", state, FLAC__StreamDecoderStateString[state]);
 522
 523         decoder_client_data.current_metadata_number = 0;
 524         decoder_client_data.ignore_errors = false;
 525         decoder_client_data.error_occurred = false;
 526
 527         printf("testing FLAC__stream_decoder_get_md5_checking()... ");
 528         if(!FLAC__stream_decoder_get_md5_checking(decoder)) {
 529                 printf("FAILED, returned false, expected true\n");
 530                 return false;
 531         }
 532         printf("OK\n");
 533
 534         printf("testing FLAC__stream_decoder_process_until_end_of_metadata()... ");
 535         if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
 536                 return die_s_("returned false", decoder);
 537         printf("OK\n");
 538
 539         printf("testing FLAC__stream_decoder_process_single()... ");
 540         if(!FLAC__stream_decoder_process_single(decoder))
 541                 return die_s_("returned false", decoder);
 542         printf("OK\n");
 543
 544         printf("testing FLAC__stream_decoder_skip_single_frame()... ");
 545         if(!FLAC__stream_decoder_skip_single_frame(decoder))
 546                 return die_s_("returned false", decoder);
 547         printf("OK\n");
 548
 549         if(layer < LAYER_FILE) {
 550                 printf("testing FLAC__stream_decoder_flush()... ");
 551                 if(!FLAC__stream_decoder_flush(decoder))
 552                         return die_s_("returned false", decoder);
 553                 printf("OK\n");
 554
 555                 decoder_client_data.ignore_errors = true;
 556                 printf("testing FLAC__stream_decoder_process_single()... ");
 557                 if(!FLAC__stream_decoder_process_single(decoder))
 558                         return die_s_("returned false", decoder);
 559                 printf("OK\n");
 560                 decoder_client_data.ignore_errors = false;
 561         }
 562
 563         expect = (layer != LAYER_STREAM);
 564         printf("testing FLAC__stream_decoder_seek_absolute()... ");
 565         if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
 566                 return die_s_(expect? "returned false" : "returned true", decoder);
 567         printf("OK\n");
 568
 569         printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 570         if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 571                 return die_s_("returned false", decoder);
 572         printf("OK\n");
 573
 574         expect = (layer != LAYER_STREAM);
 575         printf("testing FLAC__stream_decoder_seek_absolute()... ");
 576         if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
 577                 return die_s_(expect? "returned false" : "returned true", decoder);
 578         printf("OK\n");
 579
 580         printf("testing FLAC__stream_decoder_get_channels()... ");
 581         {
 582                 unsigned channels = FLAC__stream_decoder_get_channels(decoder);
 583                 if(channels != streaminfo_.data.stream_info.channels) {
 584                         printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
 585                         return false;
 586                 }
 587         }
 588         printf("OK\n");
 589
 590         printf("testing FLAC__stream_decoder_get_bits_per_sample()... ");
 591         {
 592                 unsigned bits_per_sample = FLAC__stream_decoder_get_bits_per_sample(decoder);
 593                 if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
 594                         printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
 595                         return false;
 596                 }
 597         }
 598         printf("OK\n");
 599
 600         printf("testing FLAC__stream_decoder_get_sample_rate()... ");
 601         {
 602                 unsigned sample_rate = FLAC__stream_decoder_get_sample_rate(decoder);
 603                 if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
 604                         printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
 605                         return false;
 606                 }
 607         }
 608         printf("OK\n");
 609
 610         printf("testing FLAC__stream_decoder_get_blocksize()... ");
 611         {
 612                 unsigned blocksize = FLAC__stream_decoder_get_blocksize(decoder);
 613                 /* value could be anything since we're at the last block, so accept any reasonable answer */
 614                 printf("returned %u... %s\n", blocksize, blocksize>0? "OK" : "FAILED");
 615                 if(blocksize == 0)
 616                         return false;
 617         }
 618
 619         printf("testing FLAC__stream_decoder_get_channel_assignment()... ");
 620         {
 621                 FLAC__ChannelAssignment ca = FLAC__stream_decoder_get_channel_assignment(decoder);
 622                 printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
 623         }
 624
 625         if(layer < LAYER_FILE) {
 626                 printf("testing FLAC__stream_decoder_reset()... ");
 627                 if(!FLAC__stream_decoder_reset(decoder)) {
 628                         state = FLAC__stream_decoder_get_state(decoder);
 629                         printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]);
 630                         return false;
 631                 }
 632                 printf("OK\n");
 633
 634                 if(layer == LAYER_STREAM) {
 635                         /* after a reset() we have to rewind the input ourselves */
 636                         printf("rewinding input... ");
 637                         if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) {
 638                                 printf("FAILED, errno = %d\n", errno);
 639                                 return false;
 640                         }
 641                         printf("OK\n");
 642                 }
 643
 644                 decoder_client_data.current_metadata_number = 0;
 645
 646                 printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 647                 if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 648                         return die_s_("returned false", decoder);
 649                 printf("OK\n");
 650         }
 651
 652         printf("testing FLAC__stream_decoder_finish()... ");
 653         if(!FLAC__stream_decoder_finish(decoder))
 654                 return die_s_("returned false", decoder);
 655         printf("OK\n");
 656
 657         /*
 658          * respond all
 659          */
 660
 661         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 662         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 663                 return die_s_("returned false", decoder);
 664         printf("OK\n");
 665
 666         num_expected_ = 0;
 667         if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 668                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 669                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 670                 expected_metadata_sequence_[num_expected_++] = &padding_;
 671                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 672                 expected_metadata_sequence_[num_expected_++] = &application1_;
 673                 expected_metadata_sequence_[num_expected_++] = &application2_;
 674                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 675                 expected_metadata_sequence_[num_expected_++] = &picture_;
 676                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 677         }
 678         else {
 679                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 680                 expected_metadata_sequence_[num_expected_++] = &padding_;
 681                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 682                 expected_metadata_sequence_[num_expected_++] = &application1_;
 683                 expected_metadata_sequence_[num_expected_++] = &application2_;
 684                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 685                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 686                 expected_metadata_sequence_[num_expected_++] = &picture_;
 687                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 688         }
 689
 690         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 691                 return false;
 692
 693         /*
 694          * ignore all
 695          */
 696
 697         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 698         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 699                 return die_s_("returned false", decoder);
 700         printf("OK\n");
 701
 702         num_expected_ = 0;
 703
 704         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 705                 return false;
 706
 707         /*
 708          * respond all, ignore VORBIS_COMMENT
 709          */
 710
 711         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 712         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 713                 return die_s_("returned false", decoder);
 714         printf("OK\n");
 715
 716         printf("testing FLAC__stream_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
 717         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
 718                 return die_s_("returned false", decoder);
 719         printf("OK\n");
 720
 721         num_expected_ = 0;
 722         expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 723         expected_metadata_sequence_[num_expected_++] = &padding_;
 724         expected_metadata_sequence_[num_expected_++] = &seektable_;
 725         expected_metadata_sequence_[num_expected_++] = &application1_;
 726         expected_metadata_sequence_[num_expected_++] = &application2_;
 727         expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 728         expected_metadata_sequence_[num_expected_++] = &picture_;
 729         expected_metadata_sequence_[num_expected_++] = &unknown_;
 730
 731         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 732                 return false;
 733
 734         /*
 735          * respond all, ignore APPLICATION
 736          */
 737
 738         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 739         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 740                 return die_s_("returned false", decoder);
 741         printf("OK\n");
 742
 743         printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
 744         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
 745                 return die_s_("returned false", decoder);
 746         printf("OK\n");
 747
 748         num_expected_ = 0;
 749         if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 750                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 751                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 752                 expected_metadata_sequence_[num_expected_++] = &padding_;
 753                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 754                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 755                 expected_metadata_sequence_[num_expected_++] = &picture_;
 756                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 757         }
 758         else {
 759                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 760                 expected_metadata_sequence_[num_expected_++] = &padding_;
 761                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 762                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 763                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 764                 expected_metadata_sequence_[num_expected_++] = &picture_;
 765                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 766         }
 767
 768         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 769                 return false;
 770
 771         /*
 772          * respond all, ignore APPLICATION id of app#1
 773          */
 774
 775         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 776         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 777                 return die_s_("returned false", decoder);
 778         printf("OK\n");
 779
 780         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 781         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 782                 return die_s_("returned false", decoder);
 783         printf("OK\n");
 784
 785         num_expected_ = 0;
 786         if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 787                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 788                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 789                 expected_metadata_sequence_[num_expected_++] = &padding_;
 790                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 791                 expected_metadata_sequence_[num_expected_++] = &application2_;
 792                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 793                 expected_metadata_sequence_[num_expected_++] = &picture_;
 794                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 795         }
 796         else {
 797                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 798                 expected_metadata_sequence_[num_expected_++] = &padding_;
 799                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 800                 expected_metadata_sequence_[num_expected_++] = &application2_;
 801                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 802                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 803                 expected_metadata_sequence_[num_expected_++] = &picture_;
 804                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 805         }
 806
 807         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 808                 return false;
 809
 810         /*
 811          * respond all, ignore APPLICATION id of app#1 & app#2
 812          */
 813
 814         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 815         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 816                 return die_s_("returned false", decoder);
 817         printf("OK\n");
 818
 819         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 820         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 821                 return die_s_("returned false", decoder);
 822         printf("OK\n");
 823
 824         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #2)... ");
 825         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
 826                 return die_s_("returned false", decoder);
 827         printf("OK\n");
 828
 829         num_expected_ = 0;
 830         if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 831                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 832                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 833                 expected_metadata_sequence_[num_expected_++] = &padding_;
 834                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 835                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 836                 expected_metadata_sequence_[num_expected_++] = &picture_;
 837                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 838         }
 839         else {
 840                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 841                 expected_metadata_sequence_[num_expected_++] = &padding_;
 842                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 843                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 844                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 845                 expected_metadata_sequence_[num_expected_++] = &picture_;
 846                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 847         }
 848
 849         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 850                 return false;
 851
 852         /*
 853          * ignore all, respond VORBIS_COMMENT
 854          */
 855
 856         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 857         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 858                 return die_s_("returned false", decoder);
 859         printf("OK\n");
 860
 861         printf("testing FLAC__stream_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
 862         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
 863                 return die_s_("returned false", decoder);
 864         printf("OK\n");
 865
 866         num_expected_ = 0;
 867         expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 868
 869         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 870                 return false;
 871
 872         /*
 873          * ignore all, respond APPLICATION
 874          */
 875
 876         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 877         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 878                 return die_s_("returned false", decoder);
 879         printf("OK\n");
 880
 881         printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
 882         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
 883                 return die_s_("returned false", decoder);
 884         printf("OK\n");
 885
 886         num_expected_ = 0;
 887         expected_metadata_sequence_[num_expected_++] = &application1_;
 888         expected_metadata_sequence_[num_expected_++] = &application2_;
 889
 890         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 891                 return false;
 892
 893         /*
 894          * ignore all, respond APPLICATION id of app#1
 895          */
 896
 897         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 898         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 899                 return die_s_("returned false", decoder);
 900         printf("OK\n");
 901
 902         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 903         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 904                 return die_s_("returned false", decoder);
 905         printf("OK\n");
 906
 907         num_expected_ = 0;
 908         expected_metadata_sequence_[num_expected_++] = &application1_;
 909
 910         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 911                 return false;
 912
 913         /*
 914          * ignore all, respond APPLICATION id of app#1 & app#2
 915          */
 916
 917         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 918         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 919                 return die_s_("returned false", decoder);
 920         printf("OK\n");
 921
 922         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 923         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 924                 return die_s_("returned false", decoder);
 925         printf("OK\n");
 926
 927         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #2)... ");
 928         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
 929                 return die_s_("returned false", decoder);
 930         printf("OK\n");
 931
 932         num_expected_ = 0;
 933         expected_metadata_sequence_[num_expected_++] = &application1_;
 934         expected_metadata_sequence_[num_expected_++] = &application2_;
 935
 936         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 937                 return false;
 938
 939         /*
 940          * respond all, ignore APPLICATION, respond APPLICATION id of app#1
 941          */
 942
 943         printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
 944         if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
 945                 return die_s_("returned false", decoder);
 946         printf("OK\n");
 947
 948         printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
 949         if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
 950                 return die_s_("returned false", decoder);
 951         printf("OK\n");
 952
 953         printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
 954         if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
 955                 return die_s_("returned false", decoder);
 956         printf("OK\n");
 957
 958         num_expected_ = 0;
 959         if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 960                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 961                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 962                 expected_metadata_sequence_[num_expected_++] = &padding_;
 963                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 964                 expected_metadata_sequence_[num_expected_++] = &application1_;
 965                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 966                 expected_metadata_sequence_[num_expected_++] = &picture_;
 967                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 968         }
 969         else {
 970                 expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 971                 expected_metadata_sequence_[num_expected_++] = &padding_;
 972                 expected_metadata_sequence_[num_expected_++] = &seektable_;
 973                 expected_metadata_sequence_[num_expected_++] = &application1_;
 974                 expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 975                 expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 976                 expected_metadata_sequence_[num_expected_++] = &picture_;
 977                 expected_metadata_sequence_[num_expected_++] = &unknown_;
 978         }
 979
 980         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
 981                 return false;
 982
 983         /*
 984          * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
 985          */
 986
 987         printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
 988         if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
 989                 return die_s_("returned false", decoder);
 990         printf("OK\n");
 991
 992         printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
 993         if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
 994                 return die_s_("returned false", decoder);
 995         printf("OK\n");
 996
 997         printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
 998         if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
 999                 return die_s_("returned false", decoder);
1000         printf("OK\n");
1001
1002         num_expected_ = 0;
1003         expected_metadata_sequence_[num_expected_++] = &application2_;
1004
1005         if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
1006                 return false;
1007
1008         if(layer < LAYER_FILE) /* for LAYER_FILE, FLAC__stream_decoder_finish() closes the file */
1009                 fclose(decoder_client_data.file);
1010
1011         printf("testing FLAC__stream_decoder_delete()... ");
1012         FLAC__stream_decoder_delete(decoder);
1013         printf("OK\n");
1014
1015         printf("\nPASSED!\n");
1016
1017         return true;
1018 }
1019
1020 FLAC__bool test_decoders(void)
1021 {
1022         FLAC__bool is_ogg = false;
1023
1024         while(1) {
1025                 init_metadata_blocks_();
1026
1027                 if(!generate_file_(is_ogg))
1028                         return false;
1029
1030                 if(!test_stream_decoder(LAYER_STREAM, is_ogg))
1031                         return false;
1032
1033                 if(!test_stream_decoder(LAYER_SEEKABLE_STREAM, is_ogg))
1034                         return false;
1035
1036                 if(!test_stream_decoder(LAYER_FILE, is_ogg))
1037                         return false;
1038
1039                 if(!test_stream_decoder(LAYER_FILENAME, is_ogg))
1040                         return false;
1041
1042                 (void) grabbag__file_remove_file(flacfilename(is_ogg));
1043
1044                 free_metadata_blocks_();
1045
1046                 if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
1047                         break;
1048                 is_ogg = true;
1049         }
1050
1051         return true;
1052 }