src/test_libFLAC/encoders.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2002,2003  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 "encoders.h"
  20 #include "file_utils.h"
  21 #include "metadata_utils.h"
  22 #include "FLAC/assert.h"
  23 #include "FLAC/file_encoder.h"
  24 #include "FLAC/seekable_stream_encoder.h"
  25 #include "FLAC/stream_encoder.h"
  26 #include "share/grabbag.h"
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, unknown_;
  32 static FLAC__StreamMetadata *metadata_sequence_[] = { &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_ };
  33 static const unsigned num_metadata_ = sizeof(metadata_sequence_) / sizeof(metadata_sequence_[0]);
  34 static const char *flacfilename_ = "metadata.flac";
  35
  36 static FLAC__bool die_s_(const char *msg, const FLAC__StreamEncoder *encoder)
  37 {
  38         FLAC__StreamEncoderState state = FLAC__stream_encoder_get_state(encoder);
  39
  40         if(msg)
  41                 printf("FAILED, %s", msg);
  42         else
  43                 printf("FAILED");
  44
  45         printf(", state = %u (%s)\n", (unsigned)state, FLAC__StreamEncoderStateString[state]);
  46         if(state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
  47                 FLAC__StreamDecoderState dstate = FLAC__stream_encoder_get_verify_decoder_state(encoder);
  48                 printf("      verify decoder state = %u (%s)\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
  49         }
  50
  51         return false;
  52 }
  53
  54 static FLAC__bool die_ss_(const char *msg, const FLAC__SeekableStreamEncoder *encoder)
  55 {
  56         FLAC__SeekableStreamEncoderState state = FLAC__seekable_stream_encoder_get_state(encoder);
  57
  58         if(msg)
  59                 printf("FAILED, %s", msg);
  60         else
  61                 printf("FAILED");
  62
  63         printf(", state = %u (%s)\n", (unsigned)state, FLAC__SeekableStreamEncoderStateString[state]);
  64         if(state == FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR) {
  65                 FLAC__StreamEncoderState state_ = FLAC__seekable_stream_encoder_get_stream_encoder_state(encoder);
  66                 printf("      stream encoder state = %u (%s)\n", (unsigned)state_, FLAC__StreamEncoderStateString[state_]);
  67                 if(state_ == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
  68                         FLAC__StreamDecoderState dstate = FLAC__seekable_stream_encoder_get_verify_decoder_state(encoder);
  69                         printf("      verify decoder state = %u (%s)\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
  70                 }
  71         }
  72
  73         return false;
  74 }
  75
  76 static FLAC__bool die_f_(const char *msg, const FLAC__FileEncoder *encoder)
  77 {
  78         FLAC__FileEncoderState state = FLAC__file_encoder_get_state(encoder);
  79
  80         if(msg)
  81                 printf("FAILED, %s", msg);
  82         else
  83                 printf("FAILED");
  84
  85         printf(", state = %u (%s)\n", (unsigned)state, FLAC__FileEncoderStateString[state]);
  86         if(state == FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR) {
  87                 FLAC__SeekableStreamEncoderState state_ = FLAC__file_encoder_get_seekable_stream_encoder_state(encoder);
  88                 printf("      seekable stream encoder state = %u (%s)\n", (unsigned)state_, FLAC__SeekableStreamEncoderStateString[state_]);
  89                 if(state_ == FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR) {
  90                         FLAC__StreamEncoderState state__ = FLAC__file_encoder_get_stream_encoder_state(encoder);
  91                         printf("      stream encoder state = %u (%s)\n", (unsigned)state__, FLAC__StreamEncoderStateString[state__]);
  92                         if(state__ == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
  93                                 FLAC__StreamDecoderState dstate = FLAC__file_encoder_get_verify_decoder_state(encoder);
  94                                 printf("      verify decoder state = %u (%s)\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
  95                         }
  96                 }
  97         }
  98
  99         return false;
 100 }
 101
 102 static void init_metadata_blocks_()
 103 {
 104         mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 105 }
 106
 107 static void free_metadata_blocks_()
 108 {
 109         mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 110 }
 111
 112 static FLAC__StreamEncoderWriteStatus stream_encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
 113 {
 114         (void)encoder, (void)buffer, (void)bytes, (void)samples, (void)current_frame, (void)client_data;
 115         return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 116 }
 117
 118 static void stream_encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
 119 {
 120         (void)encoder, (void)metadata, (void)client_data;
 121 }
 122
 123 static FLAC__bool test_stream_encoder()
 124 {
 125         FLAC__StreamEncoder *encoder;
 126         FLAC__StreamEncoderState state;
 127         FLAC__StreamDecoderState dstate;
 128         FLAC__int32 samples[1024];
 129         FLAC__int32 *samples_array[1];
 130         unsigned i;
 131
 132         samples_array[0] = samples;
 133
 134         printf("\n+++ libFLAC unit test: FLAC__StreamEncoder\n\n");
 135
 136         printf("testing FLAC__stream_encoder_new()... ");
 137         encoder = FLAC__stream_encoder_new();
 138         if(0 == encoder) {
 139                 printf("FAILED, returned NULL\n");
 140                 return false;
 141         }
 142         printf("OK\n");
 143
 144         printf("testing FLAC__stream_encoder_set_verify()... ");
 145         if(!FLAC__stream_encoder_set_verify(encoder, true))
 146                 return die_s_("returned false", encoder);
 147         printf("OK\n");
 148
 149         printf("testing FLAC__stream_encoder_set_streamable_subset()... ");
 150         if(!FLAC__stream_encoder_set_streamable_subset(encoder, true))
 151                 return die_s_("returned false", encoder);
 152         printf("OK\n");
 153
 154         printf("testing FLAC__stream_encoder_set_do_mid_side_stereo()... ");
 155         if(!FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false))
 156                 return die_s_("returned false", encoder);
 157         printf("OK\n");
 158
 159         printf("testing FLAC__stream_encoder_set_loose_mid_side_stereo()... ");
 160         if(!FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false))
 161                 return die_s_("returned false", encoder);
 162         printf("OK\n");
 163
 164         printf("testing FLAC__stream_encoder_set_channels()... ");
 165         if(!FLAC__stream_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 166                 return die_s_("returned false", encoder);
 167         printf("OK\n");
 168
 169         printf("testing FLAC__stream_encoder_set_bits_per_sample()... ");
 170         if(!FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
 171                 return die_s_("returned false", encoder);
 172         printf("OK\n");
 173
 174         printf("testing FLAC__stream_encoder_set_sample_rate()... ");
 175         if(!FLAC__stream_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
 176                 return die_s_("returned false", encoder);
 177         printf("OK\n");
 178
 179         printf("testing FLAC__stream_encoder_set_blocksize()... ");
 180         if(!FLAC__stream_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 181                 return die_s_("returned false", encoder);
 182         printf("OK\n");
 183
 184         printf("testing FLAC__stream_encoder_set_max_lpc_order()... ");
 185         if(!FLAC__stream_encoder_set_max_lpc_order(encoder, 0))
 186                 return die_s_("returned false", encoder);
 187         printf("OK\n");
 188
 189         printf("testing FLAC__stream_encoder_set_qlp_coeff_precision()... ");
 190         if(!FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0))
 191                 return die_s_("returned false", encoder);
 192         printf("OK\n");
 193
 194         printf("testing FLAC__stream_encoder_set_do_qlp_coeff_prec_search()... ");
 195         if(!FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false))
 196                 return die_s_("returned false", encoder);
 197         printf("OK\n");
 198
 199         printf("testing FLAC__stream_encoder_set_do_escape_coding()... ");
 200         if(!FLAC__stream_encoder_set_do_escape_coding(encoder, false))
 201                 return die_s_("returned false", encoder);
 202         printf("OK\n");
 203
 204         printf("testing FLAC__stream_encoder_set_do_exhaustive_model_search()... ");
 205         if(!FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false))
 206                 return die_s_("returned false", encoder);
 207         printf("OK\n");
 208
 209         printf("testing FLAC__stream_encoder_set_min_residual_partition_order()... ");
 210         if(!FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0))
 211                 return die_s_("returned false", encoder);
 212         printf("OK\n");
 213
 214         printf("testing FLAC__stream_encoder_set_max_residual_partition_order()... ");
 215         if(!FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0))
 216                 return die_s_("returned false", encoder);
 217         printf("OK\n");
 218
 219         printf("testing FLAC__stream_encoder_set_rice_parameter_search_dist()... ");
 220         if(!FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0))
 221                 return die_s_("returned false", encoder);
 222         printf("OK\n");
 223
 224         printf("testing FLAC__stream_encoder_set_total_samples_estimate()... ");
 225         if(!FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
 226                 return die_s_("returned false", encoder);
 227         printf("OK\n");
 228
 229         printf("testing FLAC__stream_encoder_set_metadata()... ");
 230         if(!FLAC__stream_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
 231                 return die_s_("returned false", encoder);
 232         printf("OK\n");
 233
 234         printf("testing FLAC__stream_encoder_set_write_callback()... ");
 235         if(!FLAC__stream_encoder_set_write_callback(encoder, stream_encoder_write_callback_))
 236                 return die_s_("returned false", encoder);
 237         printf("OK\n");
 238
 239         printf("testing FLAC__stream_encoder_set_metadata_callback()... ");
 240         if(!FLAC__stream_encoder_set_metadata_callback(encoder, stream_encoder_metadata_callback_))
 241                 return die_s_("returned false", encoder);
 242         printf("OK\n");
 243
 244         printf("testing FLAC__stream_encoder_set_client_data()... ");
 245         if(!FLAC__stream_encoder_set_client_data(encoder, 0))
 246                 return die_s_("returned false", encoder);
 247         printf("OK\n");
 248
 249         printf("testing FLAC__stream_encoder_init()... ");
 250         if(FLAC__stream_encoder_init(encoder) != FLAC__STREAM_ENCODER_OK)
 251                 return die_s_(0, encoder);
 252         printf("OK\n");
 253
 254         printf("testing FLAC__stream_encoder_get_state()... ");
 255         state = FLAC__stream_encoder_get_state(encoder);
 256         printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__StreamEncoderStateString[state]);
 257
 258         printf("testing FLAC__stream_encoder_get_verify_decoder_state()... ");
 259         dstate = FLAC__stream_encoder_get_verify_decoder_state(encoder);
 260         printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
 261
 262         {
 263                 FLAC__uint64 absolute_sample;
 264                 unsigned frame_number;
 265                 unsigned channel;
 266                 unsigned sample;
 267                 FLAC__int32 expected;
 268                 FLAC__int32 got;
 269
 270                 printf("testing FLAC__stream_encoder_get_verify_decoder_error_stats()... ");
 271                 FLAC__stream_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 272                 printf("OK\n");
 273         }
 274
 275         printf("testing FLAC__stream_encoder_get_verify()... ");
 276         if(FLAC__stream_encoder_get_verify(encoder) != true) {
 277                 printf("FAILED, expected true, got false\n");
 278                 return false;
 279         }
 280         printf("OK\n");
 281
 282         printf("testing FLAC__stream_encoder_get_streamable_subset()... ");
 283         if(FLAC__stream_encoder_get_streamable_subset(encoder) != true) {
 284                 printf("FAILED, expected true, got false\n");
 285                 return false;
 286         }
 287         printf("OK\n");
 288
 289         printf("testing FLAC__stream_encoder_get_do_mid_side_stereo()... ");
 290         if(FLAC__stream_encoder_get_do_mid_side_stereo(encoder) != false) {
 291                 printf("FAILED, expected false, got true\n");
 292                 return false;
 293         }
 294         printf("OK\n");
 295
 296         printf("testing FLAC__stream_encoder_get_loose_mid_side_stereo()... ");
 297         if(FLAC__stream_encoder_get_loose_mid_side_stereo(encoder) != false) {
 298                 printf("FAILED, expected false, got true\n");
 299                 return false;
 300         }
 301         printf("OK\n");
 302
 303         printf("testing FLAC__stream_encoder_get_channels()... ");
 304         if(FLAC__stream_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
 305                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__stream_encoder_get_channels(encoder));
 306                 return false;
 307         }
 308         printf("OK\n");
 309
 310         printf("testing FLAC__stream_encoder_get_bits_per_sample()... ");
 311         if(FLAC__stream_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
 312                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__stream_encoder_get_bits_per_sample(encoder));
 313                 return false;
 314         }
 315         printf("OK\n");
 316
 317         printf("testing FLAC__stream_encoder_get_sample_rate()... ");
 318         if(FLAC__stream_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
 319                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__stream_encoder_get_sample_rate(encoder));
 320                 return false;
 321         }
 322         printf("OK\n");
 323
 324         printf("testing FLAC__stream_encoder_get_blocksize()... ");
 325         if(FLAC__stream_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
 326                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__stream_encoder_get_blocksize(encoder));
 327                 return false;
 328         }
 329         printf("OK\n");
 330
 331         printf("testing FLAC__stream_encoder_get_max_lpc_order()... ");
 332         if(FLAC__stream_encoder_get_max_lpc_order(encoder) != 0) {
 333                 printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_max_lpc_order(encoder));
 334                 return false;
 335         }
 336         printf("OK\n");
 337
 338         printf("testing FLAC__stream_encoder_get_qlp_coeff_precision()... ");
 339         (void)FLAC__stream_encoder_get_qlp_coeff_precision(encoder);
 340         /* we asked the encoder to auto select this so we accept anything */
 341         printf("OK\n");
 342
 343         printf("testing FLAC__stream_encoder_get_do_qlp_coeff_prec_search()... ");
 344         if(FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
 345                 printf("FAILED, expected false, got true\n");
 346                 return false;
 347         }
 348         printf("OK\n");
 349
 350         printf("testing FLAC__stream_encoder_get_do_escape_coding()... ");
 351         if(FLAC__stream_encoder_get_do_escape_coding(encoder) != false) {
 352                 printf("FAILED, expected false, got true\n");
 353                 return false;
 354         }
 355         printf("OK\n");
 356
 357         printf("testing FLAC__stream_encoder_get_do_exhaustive_model_search()... ");
 358         if(FLAC__stream_encoder_get_do_exhaustive_model_search(encoder) != false) {
 359                 printf("FAILED, expected false, got true\n");
 360                 return false;
 361         }
 362         printf("OK\n");
 363
 364         printf("testing FLAC__stream_encoder_get_min_residual_partition_order()... ");
 365         if(FLAC__stream_encoder_get_min_residual_partition_order(encoder) != 0) {
 366                 printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_min_residual_partition_order(encoder));
 367                 return false;
 368         }
 369         printf("OK\n");
 370
 371         printf("testing FLAC__stream_encoder_get_max_residual_partition_order()... ");
 372         if(FLAC__stream_encoder_get_max_residual_partition_order(encoder) != 0) {
 373                 printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_max_residual_partition_order(encoder));
 374                 return false;
 375         }
 376         printf("OK\n");
 377
 378         printf("testing FLAC__stream_encoder_get_rice_parameter_search_dist()... ");
 379         if(FLAC__stream_encoder_get_rice_parameter_search_dist(encoder) != 0) {
 380                 printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_rice_parameter_search_dist(encoder));
 381                 return false;
 382         }
 383         printf("OK\n");
 384
 385         printf("testing FLAC__stream_encoder_get_total_samples_estimate()... ");
 386         if(FLAC__stream_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
 387                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, FLAC__stream_encoder_get_total_samples_estimate(encoder));
 388                 return false;
 389         }
 390         printf("OK\n");
 391
 392         /* init the dummy sample buffer */
 393         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
 394                 samples[i] = i & 7;
 395
 396         printf("testing FLAC__stream_encoder_process()... ");
 397         if(!FLAC__stream_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
 398                 return die_s_("returned false", encoder);
 399         printf("OK\n");
 400
 401         printf("testing FLAC__stream_encoder_process_interleaved()... ");
 402         if(!FLAC__stream_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
 403                 return die_s_("returned false", encoder);
 404         printf("OK\n");
 405
 406         printf("testing FLAC__stream_encoder_finish()... ");
 407         FLAC__stream_encoder_finish(encoder);
 408         printf("OK\n");
 409
 410         printf("testing FLAC__stream_encoder_delete()... ");
 411         FLAC__stream_encoder_delete(encoder);
 412         printf("OK\n");
 413
 414         printf("\nPASSED!\n");
 415
 416         return true;
 417 }
 418
 419 FLAC__SeekableStreamEncoderSeekStatus seekable_stream_encoder_seek_callback_(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 420 {
 421         (void)encoder, (void)absolute_byte_offset, (void)client_data;
 422         return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK;
 423 }
 424
 425 FLAC__StreamEncoderWriteStatus seekable_stream_encoder_write_callback_(const FLAC__SeekableStreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
 426 {
 427         (void)encoder, (void)buffer, (void)bytes, (void)samples, (void)current_frame, (void)client_data;
 428         return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 429 }
 430
 431 static FLAC__bool test_seekable_stream_encoder()
 432 {
 433         FLAC__SeekableStreamEncoder *encoder;
 434         FLAC__SeekableStreamEncoderState state;
 435         FLAC__StreamEncoderState state_;
 436         FLAC__StreamDecoderState dstate;
 437         FLAC__int32 samples[1024];
 438         FLAC__int32 *samples_array[1];
 439         unsigned i;
 440
 441         samples_array[0] = samples;
 442
 443         printf("\n+++ libFLAC unit test: FLAC__SeekableStreamEncoder\n\n");
 444
 445         printf("testing FLAC__seekable_stream_encoder_new()... ");
 446         encoder = FLAC__seekable_stream_encoder_new();
 447         if(0 == encoder) {
 448                 printf("FAILED, returned NULL\n");
 449                 return false;
 450         }
 451         printf("OK\n");
 452
 453         printf("testing FLAC__seekable_stream_encoder_set_verify()... ");
 454         if(!FLAC__seekable_stream_encoder_set_verify(encoder, true))
 455                 return die_ss_("returned false", encoder);
 456         printf("OK\n");
 457
 458         printf("testing FLAC__seekable_stream_encoder_set_streamable_subset()... ");
 459         if(!FLAC__seekable_stream_encoder_set_streamable_subset(encoder, true))
 460                 return die_ss_("returned false", encoder);
 461         printf("OK\n");
 462
 463         printf("testing FLAC__seekable_stream_encoder_set_do_mid_side_stereo()... ");
 464         if(!FLAC__seekable_stream_encoder_set_do_mid_side_stereo(encoder, false))
 465                 return die_ss_("returned false", encoder);
 466         printf("OK\n");
 467
 468         printf("testing FLAC__seekable_stream_encoder_set_loose_mid_side_stereo()... ");
 469         if(!FLAC__seekable_stream_encoder_set_loose_mid_side_stereo(encoder, false))
 470                 return die_ss_("returned false", encoder);
 471         printf("OK\n");
 472
 473         printf("testing FLAC__seekable_stream_encoder_set_channels()... ");
 474         if(!FLAC__seekable_stream_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 475                 return die_ss_("returned false", encoder);
 476         printf("OK\n");
 477
 478         printf("testing FLAC__seekable_stream_encoder_set_bits_per_sample()... ");
 479         if(!FLAC__seekable_stream_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
 480                 return die_ss_("returned false", encoder);
 481         printf("OK\n");
 482
 483         printf("testing FLAC__seekable_stream_encoder_set_sample_rate()... ");
 484         if(!FLAC__seekable_stream_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
 485                 return die_ss_("returned false", encoder);
 486         printf("OK\n");
 487
 488         printf("testing FLAC__seekable_stream_encoder_set_blocksize()... ");
 489         if(!FLAC__seekable_stream_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 490                 return die_ss_("returned false", encoder);
 491         printf("OK\n");
 492
 493         printf("testing FLAC__seekable_stream_encoder_set_max_lpc_order()... ");
 494         if(!FLAC__seekable_stream_encoder_set_max_lpc_order(encoder, 0))
 495                 return die_ss_("returned false", encoder);
 496         printf("OK\n");
 497
 498         printf("testing FLAC__seekable_stream_encoder_set_qlp_coeff_precision()... ");
 499         if(!FLAC__seekable_stream_encoder_set_qlp_coeff_precision(encoder, 0))
 500                 return die_ss_("returned false", encoder);
 501         printf("OK\n");
 502
 503         printf("testing FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search()... ");
 504         if(!FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search(encoder, false))
 505                 return die_ss_("returned false", encoder);
 506         printf("OK\n");
 507
 508         printf("testing FLAC__seekable_stream_encoder_set_do_escape_coding()... ");
 509         if(!FLAC__seekable_stream_encoder_set_do_escape_coding(encoder, false))
 510                 return die_ss_("returned false", encoder);
 511         printf("OK\n");
 512
 513         printf("testing FLAC__seekable_stream_encoder_set_do_exhaustive_model_search()... ");
 514         if(!FLAC__seekable_stream_encoder_set_do_exhaustive_model_search(encoder, false))
 515                 return die_ss_("returned false", encoder);
 516         printf("OK\n");
 517
 518         printf("testing FLAC__seekable_stream_encoder_set_min_residual_partition_order()... ");
 519         if(!FLAC__seekable_stream_encoder_set_min_residual_partition_order(encoder, 0))
 520                 return die_ss_("returned false", encoder);
 521         printf("OK\n");
 522
 523         printf("testing FLAC__seekable_stream_encoder_set_max_residual_partition_order()... ");
 524         if(!FLAC__seekable_stream_encoder_set_max_residual_partition_order(encoder, 0))
 525                 return die_ss_("returned false", encoder);
 526         printf("OK\n");
 527
 528         printf("testing FLAC__seekable_stream_encoder_set_rice_parameter_search_dist()... ");
 529         if(!FLAC__seekable_stream_encoder_set_rice_parameter_search_dist(encoder, 0))
 530                 return die_ss_("returned false", encoder);
 531         printf("OK\n");
 532
 533         printf("testing FLAC__seekable_stream_encoder_set_total_samples_estimate()... ");
 534         if(!FLAC__seekable_stream_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
 535                 return die_ss_("returned false", encoder);
 536         printf("OK\n");
 537
 538         printf("testing FLAC__seekable_stream_encoder_set_metadata()... ");
 539         if(!FLAC__seekable_stream_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
 540                 return die_ss_("returned false", encoder);
 541         printf("OK\n");
 542
 543         printf("testing FLAC__seekable_stream_encoder_set_seek_callback()... ");
 544         if(!FLAC__seekable_stream_encoder_set_seek_callback(encoder, seekable_stream_encoder_seek_callback_))
 545                 return die_ss_("returned false", encoder);
 546         printf("OK\n");
 547
 548         printf("testing FLAC__seekable_stream_encoder_set_write_callback()... ");
 549         if(!FLAC__seekable_stream_encoder_set_write_callback(encoder, seekable_stream_encoder_write_callback_))
 550                 return die_ss_("returned false", encoder);
 551         printf("OK\n");
 552
 553         printf("testing FLAC__seekable_stream_encoder_set_client_data()... ");
 554         if(!FLAC__seekable_stream_encoder_set_client_data(encoder, 0))
 555                 return die_ss_("returned false", encoder);
 556         printf("OK\n");
 557
 558         printf("testing FLAC__seekable_stream_encoder_init()... ");
 559         if(FLAC__seekable_stream_encoder_init(encoder) != FLAC__SEEKABLE_STREAM_ENCODER_OK)
 560                 return die_ss_(0, encoder);
 561         printf("OK\n");
 562
 563         printf("testing FLAC__seekable_stream_encoder_get_state()... ");
 564         state = FLAC__seekable_stream_encoder_get_state(encoder);
 565         printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__SeekableStreamEncoderStateString[state]);
 566
 567         printf("testing FLAC__seekable_stream_encoder_get_stream_encoder_state()... ");
 568         state_ = FLAC__seekable_stream_encoder_get_stream_encoder_state(encoder);
 569         printf("returned state = %u (%s)... OK\n", (unsigned)state_, FLAC__StreamEncoderStateString[state_]);
 570
 571         printf("testing FLAC__seekable_stream_encoder_get_verify_decoder_state()... ");
 572         dstate = FLAC__seekable_stream_encoder_get_verify_decoder_state(encoder);
 573         printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
 574
 575         {
 576                 FLAC__uint64 absolute_sample;
 577                 unsigned frame_number;
 578                 unsigned channel;
 579                 unsigned sample;
 580                 FLAC__int32 expected;
 581                 FLAC__int32 got;
 582
 583                 printf("testing FLAC__seekable_stream_encoder_get_verify_decoder_error_stats()... ");
 584                 FLAC__seekable_stream_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 585                 printf("OK\n");
 586         }
 587
 588         printf("testing FLAC__seekable_stream_encoder_get_verify()... ");
 589         if(FLAC__seekable_stream_encoder_get_verify(encoder) != true) {
 590                 printf("FAILED, expected true, got false\n");
 591                 return false;
 592         }
 593         printf("OK\n");
 594
 595         printf("testing FLAC__seekable_stream_encoder_get_streamable_subset()... ");
 596         if(FLAC__seekable_stream_encoder_get_streamable_subset(encoder) != true) {
 597                 printf("FAILED, expected true, got false\n");
 598                 return false;
 599         }
 600         printf("OK\n");
 601
 602         printf("testing FLAC__seekable_stream_encoder_get_do_mid_side_stereo()... ");
 603         if(FLAC__seekable_stream_encoder_get_do_mid_side_stereo(encoder) != false) {
 604                 printf("FAILED, expected false, got true\n");
 605                 return false;
 606         }
 607         printf("OK\n");
 608
 609         printf("testing FLAC__seekable_stream_encoder_get_loose_mid_side_stereo()... ");
 610         if(FLAC__seekable_stream_encoder_get_loose_mid_side_stereo(encoder) != false) {
 611                 printf("FAILED, expected false, got true\n");
 612                 return false;
 613         }
 614         printf("OK\n");
 615
 616         printf("testing FLAC__seekable_stream_encoder_get_channels()... ");
 617         if(FLAC__seekable_stream_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
 618                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__seekable_stream_encoder_get_channels(encoder));
 619                 return false;
 620         }
 621         printf("OK\n");
 622
 623         printf("testing FLAC__seekable_stream_encoder_get_bits_per_sample()... ");
 624         if(FLAC__seekable_stream_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
 625                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__seekable_stream_encoder_get_bits_per_sample(encoder));
 626                 return false;
 627         }
 628         printf("OK\n");
 629
 630         printf("testing FLAC__seekable_stream_encoder_get_sample_rate()... ");
 631         if(FLAC__seekable_stream_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
 632                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__seekable_stream_encoder_get_sample_rate(encoder));
 633                 return false;
 634         }
 635         printf("OK\n");
 636
 637         printf("testing FLAC__seekable_stream_encoder_get_blocksize()... ");
 638         if(FLAC__seekable_stream_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
 639                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__seekable_stream_encoder_get_blocksize(encoder));
 640                 return false;
 641         }
 642         printf("OK\n");
 643
 644         printf("testing FLAC__seekable_stream_encoder_get_max_lpc_order()... ");
 645         if(FLAC__seekable_stream_encoder_get_max_lpc_order(encoder) != 0) {
 646                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_max_lpc_order(encoder));
 647                 return false;
 648         }
 649         printf("OK\n");
 650
 651         printf("testing FLAC__seekable_stream_encoder_get_qlp_coeff_precision()... ");
 652         (void)FLAC__seekable_stream_encoder_get_qlp_coeff_precision(encoder);
 653         /* we asked the encoder to auto select this so we accept anything */
 654         printf("OK\n");
 655
 656         printf("testing FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search()... ");
 657         if(FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
 658                 printf("FAILED, expected false, got true\n");
 659                 return false;
 660         }
 661         printf("OK\n");
 662
 663         printf("testing FLAC__seekable_stream_encoder_get_do_escape_coding()... ");
 664         if(FLAC__seekable_stream_encoder_get_do_escape_coding(encoder) != false) {
 665                 printf("FAILED, expected false, got true\n");
 666                 return false;
 667         }
 668         printf("OK\n");
 669
 670         printf("testing FLAC__seekable_stream_encoder_get_do_exhaustive_model_search()... ");
 671         if(FLAC__seekable_stream_encoder_get_do_exhaustive_model_search(encoder) != false) {
 672                 printf("FAILED, expected false, got true\n");
 673                 return false;
 674         }
 675         printf("OK\n");
 676
 677         printf("testing FLAC__seekable_stream_encoder_get_min_residual_partition_order()... ");
 678         if(FLAC__seekable_stream_encoder_get_min_residual_partition_order(encoder) != 0) {
 679                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_min_residual_partition_order(encoder));
 680                 return false;
 681         }
 682         printf("OK\n");
 683
 684         printf("testing FLAC__seekable_stream_encoder_get_max_residual_partition_order()... ");
 685         if(FLAC__seekable_stream_encoder_get_max_residual_partition_order(encoder) != 0) {
 686                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_max_residual_partition_order(encoder));
 687                 return false;
 688         }
 689         printf("OK\n");
 690
 691         printf("testing FLAC__seekable_stream_encoder_get_rice_parameter_search_dist()... ");
 692         if(FLAC__seekable_stream_encoder_get_rice_parameter_search_dist(encoder) != 0) {
 693                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_rice_parameter_search_dist(encoder));
 694                 return false;
 695         }
 696         printf("OK\n");
 697
 698         printf("testing FLAC__seekable_stream_encoder_get_total_samples_estimate()... ");
 699         if(FLAC__seekable_stream_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
 700                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, FLAC__seekable_stream_encoder_get_total_samples_estimate(encoder));
 701                 return false;
 702         }
 703         printf("OK\n");
 704
 705         /* init the dummy sample buffer */
 706         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
 707                 samples[i] = i & 7;
 708
 709         printf("testing FLAC__seekable_stream_encoder_process()... ");
 710         if(!FLAC__seekable_stream_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
 711                 return die_ss_("returned false", encoder);
 712         printf("OK\n");
 713
 714         printf("testing FLAC__seekable_stream_encoder_process_interleaved()... ");
 715         if(!FLAC__seekable_stream_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
 716                 return die_ss_("returned false", encoder);
 717         printf("OK\n");
 718
 719         printf("testing FLAC__seekable_stream_encoder_finish()... ");
 720         FLAC__seekable_stream_encoder_finish(encoder);
 721         printf("OK\n");
 722
 723         printf("testing FLAC__seekable_stream_encoder_delete()... ");
 724         FLAC__seekable_stream_encoder_delete(encoder);
 725         printf("OK\n");
 726
 727         printf("\nPASSED!\n");
 728
 729         return true;
 730 }
 731
 732 static void file_encoder_progress_callback_(const FLAC__FileEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data)
 733 {
 734         (void)encoder, (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate, (void)client_data;
 735 }
 736
 737 static FLAC__bool test_file_encoder()
 738 {
 739         FLAC__FileEncoder *encoder;
 740         FLAC__FileEncoderState state;
 741         FLAC__SeekableStreamEncoderState state_;
 742         FLAC__StreamEncoderState state__;
 743         FLAC__StreamDecoderState dstate;
 744         FLAC__int32 samples[1024];
 745         FLAC__int32 *samples_array[1];
 746         unsigned i;
 747
 748         samples_array[0] = samples;
 749
 750         printf("\n+++ libFLAC unit test: FLAC__FileEncoder\n\n");
 751
 752         printf("testing FLAC__file_encoder_new()... ");
 753         encoder = FLAC__file_encoder_new();
 754         if(0 == encoder) {
 755                 printf("FAILED, returned NULL\n");
 756                 return false;
 757         }
 758         printf("OK\n");
 759
 760         printf("testing FLAC__file_encoder_set_verify()... ");
 761         if(!FLAC__file_encoder_set_verify(encoder, true))
 762                 return die_f_("returned false", encoder);
 763         printf("OK\n");
 764
 765         printf("testing FLAC__file_encoder_set_streamable_subset()... ");
 766         if(!FLAC__file_encoder_set_streamable_subset(encoder, true))
 767                 return die_f_("returned false", encoder);
 768         printf("OK\n");
 769
 770         printf("testing FLAC__file_encoder_set_do_mid_side_stereo()... ");
 771         if(!FLAC__file_encoder_set_do_mid_side_stereo(encoder, false))
 772                 return die_f_("returned false", encoder);
 773         printf("OK\n");
 774
 775         printf("testing FLAC__file_encoder_set_loose_mid_side_stereo()... ");
 776         if(!FLAC__file_encoder_set_loose_mid_side_stereo(encoder, false))
 777                 return die_f_("returned false", encoder);
 778         printf("OK\n");
 779
 780         printf("testing FLAC__file_encoder_set_channels()... ");
 781         if(!FLAC__file_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 782                 return die_f_("returned false", encoder);
 783         printf("OK\n");
 784
 785         printf("testing FLAC__file_encoder_set_bits_per_sample()... ");
 786         if(!FLAC__file_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
 787                 return die_f_("returned false", encoder);
 788         printf("OK\n");
 789
 790         printf("testing FLAC__file_encoder_set_sample_rate()... ");
 791         if(!FLAC__file_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
 792                 return die_f_("returned false", encoder);
 793         printf("OK\n");
 794
 795         printf("testing FLAC__file_encoder_set_blocksize()... ");
 796         if(!FLAC__file_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 797                 return die_f_("returned false", encoder);
 798         printf("OK\n");
 799
 800         printf("testing FLAC__file_encoder_set_max_lpc_order()... ");
 801         if(!FLAC__file_encoder_set_max_lpc_order(encoder, 0))
 802                 return die_f_("returned false", encoder);
 803         printf("OK\n");
 804
 805         printf("testing FLAC__file_encoder_set_qlp_coeff_precision()... ");
 806         if(!FLAC__file_encoder_set_qlp_coeff_precision(encoder, 0))
 807                 return die_f_("returned false", encoder);
 808         printf("OK\n");
 809
 810         printf("testing FLAC__file_encoder_set_do_qlp_coeff_prec_search()... ");
 811         if(!FLAC__file_encoder_set_do_qlp_coeff_prec_search(encoder, false))
 812                 return die_f_("returned false", encoder);
 813         printf("OK\n");
 814
 815         printf("testing FLAC__file_encoder_set_do_escape_coding()... ");
 816         if(!FLAC__file_encoder_set_do_escape_coding(encoder, false))
 817                 return die_f_("returned false", encoder);
 818         printf("OK\n");
 819
 820         printf("testing FLAC__file_encoder_set_do_exhaustive_model_search()... ");
 821         if(!FLAC__file_encoder_set_do_exhaustive_model_search(encoder, false))
 822                 return die_f_("returned false", encoder);
 823         printf("OK\n");
 824
 825         printf("testing FLAC__file_encoder_set_min_residual_partition_order()... ");
 826         if(!FLAC__file_encoder_set_min_residual_partition_order(encoder, 0))
 827                 return die_f_("returned false", encoder);
 828         printf("OK\n");
 829
 830         printf("testing FLAC__file_encoder_set_max_residual_partition_order()... ");
 831         if(!FLAC__file_encoder_set_max_residual_partition_order(encoder, 0))
 832                 return die_f_("returned false", encoder);
 833         printf("OK\n");
 834
 835         printf("testing FLAC__file_encoder_set_rice_parameter_search_dist()... ");
 836         if(!FLAC__file_encoder_set_rice_parameter_search_dist(encoder, 0))
 837                 return die_f_("returned false", encoder);
 838         printf("OK\n");
 839
 840         printf("testing FLAC__file_encoder_set_total_samples_estimate()... ");
 841         if(!FLAC__file_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
 842                 return die_f_("returned false", encoder);
 843         printf("OK\n");
 844
 845         printf("testing FLAC__file_encoder_set_metadata()... ");
 846         if(!FLAC__file_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
 847                 return die_f_("returned false", encoder);
 848         printf("OK\n");
 849
 850         printf("testing FLAC__file_encoder_set_filename()... ");
 851         if(!FLAC__file_encoder_set_filename(encoder, flacfilename_))
 852                 return die_f_("returned false", encoder);
 853         printf("OK\n");
 854
 855         printf("testing FLAC__file_encoder_set_progress_callback()... ");
 856         if(!FLAC__file_encoder_set_progress_callback(encoder, file_encoder_progress_callback_))
 857                 return die_f_("returned false", encoder);
 858         printf("OK\n");
 859
 860         printf("testing FLAC__file_encoder_set_client_data()... ");
 861         if(!FLAC__file_encoder_set_client_data(encoder, 0))
 862                 return die_f_("returned false", encoder);
 863         printf("OK\n");
 864
 865         printf("testing FLAC__file_encoder_init()... ");
 866         if(FLAC__file_encoder_init(encoder) != FLAC__FILE_ENCODER_OK)
 867                 return die_f_(0, encoder);
 868         printf("OK\n");
 869
 870         printf("testing FLAC__file_encoder_get_state()... ");
 871         state = FLAC__file_encoder_get_state(encoder);
 872         printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__FileEncoderStateString[state]);
 873
 874         printf("testing FLAC__file_encoder_get_seekable_stream_encoder_state()... ");
 875         state_ = FLAC__file_encoder_get_seekable_stream_encoder_state(encoder);
 876         printf("returned state = %u (%s)... OK\n", (unsigned)state_, FLAC__SeekableStreamEncoderStateString[state_]);
 877
 878         printf("testing FLAC__file_encoder_get_stream_encoder_state()... ");
 879         state__ = FLAC__file_encoder_get_stream_encoder_state(encoder);
 880         printf("returned state = %u (%s)... OK\n", (unsigned)state__, FLAC__StreamEncoderStateString[state__]);
 881
 882         printf("testing FLAC__file_encoder_get_verify_decoder_state()... ");
 883         dstate = FLAC__file_encoder_get_verify_decoder_state(encoder);
 884         printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
 885
 886         {
 887                 FLAC__uint64 absolute_sample;
 888                 unsigned frame_number;
 889                 unsigned channel;
 890                 unsigned sample;
 891                 FLAC__int32 expected;
 892                 FLAC__int32 got;
 893
 894                 printf("testing FLAC__file_encoder_get_verify_decoder_error_stats()... ");
 895                 FLAC__file_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 896                 printf("OK\n");
 897         }
 898
 899         printf("testing FLAC__file_encoder_get_verify()... ");
 900         if(FLAC__file_encoder_get_verify(encoder) != true) {
 901                 printf("FAILED, expected true, got false\n");
 902                 return false;
 903         }
 904         printf("OK\n");
 905
 906         printf("testing FLAC__file_encoder_get_streamable_subset()... ");
 907         if(FLAC__file_encoder_get_streamable_subset(encoder) != true) {
 908                 printf("FAILED, expected true, got false\n");
 909                 return false;
 910         }
 911         printf("OK\n");
 912
 913         printf("testing FLAC__file_encoder_get_do_mid_side_stereo()... ");
 914         if(FLAC__file_encoder_get_do_mid_side_stereo(encoder) != false) {
 915                 printf("FAILED, expected false, got true\n");
 916                 return false;
 917         }
 918         printf("OK\n");
 919
 920         printf("testing FLAC__file_encoder_get_loose_mid_side_stereo()... ");
 921         if(FLAC__file_encoder_get_loose_mid_side_stereo(encoder) != false) {
 922                 printf("FAILED, expected false, got true\n");
 923                 return false;
 924         }
 925         printf("OK\n");
 926
 927         printf("testing FLAC__file_encoder_get_channels()... ");
 928         if(FLAC__file_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
 929                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__file_encoder_get_channels(encoder));
 930                 return false;
 931         }
 932         printf("OK\n");
 933
 934         printf("testing FLAC__file_encoder_get_bits_per_sample()... ");
 935         if(FLAC__file_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
 936                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__file_encoder_get_bits_per_sample(encoder));
 937                 return false;
 938         }
 939         printf("OK\n");
 940
 941         printf("testing FLAC__file_encoder_get_sample_rate()... ");
 942         if(FLAC__file_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
 943                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__file_encoder_get_sample_rate(encoder));
 944                 return false;
 945         }
 946         printf("OK\n");
 947
 948         printf("testing FLAC__file_encoder_get_blocksize()... ");
 949         if(FLAC__file_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
 950                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__file_encoder_get_blocksize(encoder));
 951                 return false;
 952         }
 953         printf("OK\n");
 954
 955         printf("testing FLAC__file_encoder_get_max_lpc_order()... ");
 956         if(FLAC__file_encoder_get_max_lpc_order(encoder) != 0) {
 957                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_max_lpc_order(encoder));
 958                 return false;
 959         }
 960         printf("OK\n");
 961
 962         printf("testing FLAC__file_encoder_get_qlp_coeff_precision()... ");
 963         (void)FLAC__file_encoder_get_qlp_coeff_precision(encoder);
 964         /* we asked the encoder to auto select this so we accept anything */
 965         printf("OK\n");
 966
 967         printf("testing FLAC__file_encoder_get_do_qlp_coeff_prec_search()... ");
 968         if(FLAC__file_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
 969                 printf("FAILED, expected false, got true\n");
 970                 return false;
 971         }
 972         printf("OK\n");
 973
 974         printf("testing FLAC__file_encoder_get_do_escape_coding()... ");
 975         if(FLAC__file_encoder_get_do_escape_coding(encoder) != false) {
 976                 printf("FAILED, expected false, got true\n");
 977                 return false;
 978         }
 979         printf("OK\n");
 980
 981         printf("testing FLAC__file_encoder_get_do_exhaustive_model_search()... ");
 982         if(FLAC__file_encoder_get_do_exhaustive_model_search(encoder) != false) {
 983                 printf("FAILED, expected false, got true\n");
 984                 return false;
 985         }
 986         printf("OK\n");
 987
 988         printf("testing FLAC__file_encoder_get_min_residual_partition_order()... ");
 989         if(FLAC__file_encoder_get_min_residual_partition_order(encoder) != 0) {
 990                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_min_residual_partition_order(encoder));
 991                 return false;
 992         }
 993         printf("OK\n");
 994
 995         printf("testing FLAC__file_encoder_get_max_residual_partition_order()... ");
 996         if(FLAC__file_encoder_get_max_residual_partition_order(encoder) != 0) {
 997                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_max_residual_partition_order(encoder));
 998                 return false;
 999         }
1000         printf("OK\n");
1001
1002         printf("testing FLAC__file_encoder_get_rice_parameter_search_dist()... ");
1003         if(FLAC__file_encoder_get_rice_parameter_search_dist(encoder) != 0) {
1004                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_rice_parameter_search_dist(encoder));
1005                 return false;
1006         }
1007         printf("OK\n");
1008
1009         printf("testing FLAC__file_encoder_get_total_samples_estimate()... ");
1010         if(FLAC__file_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
1011                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, FLAC__file_encoder_get_total_samples_estimate(encoder));
1012                 return false;
1013         }
1014         printf("OK\n");
1015
1016         /* init the dummy sample buffer */
1017         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
1018                 samples[i] = i & 7;
1019
1020         printf("testing FLAC__file_encoder_process()... ");
1021         if(!FLAC__file_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
1022                 return die_f_("returned false", encoder);
1023         printf("OK\n");
1024
1025         printf("testing FLAC__file_encoder_process_interleaved()... ");
1026         if(!FLAC__file_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
1027                 return die_f_("returned false", encoder);
1028         printf("OK\n");
1029
1030         printf("testing FLAC__file_encoder_finish()... ");
1031         FLAC__file_encoder_finish(encoder);
1032         printf("OK\n");
1033
1034         printf("testing FLAC__file_encoder_delete()... ");
1035         FLAC__file_encoder_delete(encoder);
1036         printf("OK\n");
1037
1038         printf("\nPASSED!\n");
1039
1040         return true;
1041 }
1042
1043 FLAC__bool test_encoders()
1044 {
1045         init_metadata_blocks_();
1046
1047         if(!test_stream_encoder())
1048                 return false;
1049
1050         if(!test_seekable_stream_encoder())
1051                 return false;
1052
1053         if(!test_file_encoder())
1054                 return false;
1055
1056         (void) grabbag__file_remove_file(flacfilename_);
1057         free_metadata_blocks_();
1058
1059         return true;
1060 }