src/test_libFLAC/encoders.c

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