src/test_libFLAC/decoders.c

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