src/test_libFLAC/encoders.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2002,2003,2004  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #include "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__SeekableStreamEncoderTellStatus seekable_stream_encoder_tell_callback_(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 426 {
 427         (void)encoder, (void)absolute_byte_offset, (void)client_data;
 428         return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK;
 429 }
 430
 431 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)
 432 {
 433         (void)encoder, (void)buffer, (void)bytes, (void)samples, (void)current_frame, (void)client_data;
 434         return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 435 }
 436
 437 static FLAC__bool test_seekable_stream_encoder()
 438 {
 439         FLAC__SeekableStreamEncoder *encoder;
 440         FLAC__SeekableStreamEncoderState state;
 441         FLAC__StreamEncoderState state_;
 442         FLAC__StreamDecoderState dstate;
 443         FLAC__int32 samples[1024];
 444         FLAC__int32 *samples_array[1];
 445         unsigned i;
 446
 447         samples_array[0] = samples;
 448
 449         printf("\n+++ libFLAC unit test: FLAC__SeekableStreamEncoder\n\n");
 450
 451         printf("testing FLAC__seekable_stream_encoder_new()... ");
 452         encoder = FLAC__seekable_stream_encoder_new();
 453         if(0 == encoder) {
 454                 printf("FAILED, returned NULL\n");
 455                 return false;
 456         }
 457         printf("OK\n");
 458
 459         printf("testing FLAC__seekable_stream_encoder_set_verify()... ");
 460         if(!FLAC__seekable_stream_encoder_set_verify(encoder, true))
 461                 return die_ss_("returned false", encoder);
 462         printf("OK\n");
 463
 464         printf("testing FLAC__seekable_stream_encoder_set_streamable_subset()... ");
 465         if(!FLAC__seekable_stream_encoder_set_streamable_subset(encoder, true))
 466                 return die_ss_("returned false", encoder);
 467         printf("OK\n");
 468
 469         printf("testing FLAC__seekable_stream_encoder_set_do_mid_side_stereo()... ");
 470         if(!FLAC__seekable_stream_encoder_set_do_mid_side_stereo(encoder, false))
 471                 return die_ss_("returned false", encoder);
 472         printf("OK\n");
 473
 474         printf("testing FLAC__seekable_stream_encoder_set_loose_mid_side_stereo()... ");
 475         if(!FLAC__seekable_stream_encoder_set_loose_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_channels()... ");
 480         if(!FLAC__seekable_stream_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 481                 return die_ss_("returned false", encoder);
 482         printf("OK\n");
 483
 484         printf("testing FLAC__seekable_stream_encoder_set_bits_per_sample()... ");
 485         if(!FLAC__seekable_stream_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
 486                 return die_ss_("returned false", encoder);
 487         printf("OK\n");
 488
 489         printf("testing FLAC__seekable_stream_encoder_set_sample_rate()... ");
 490         if(!FLAC__seekable_stream_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
 491                 return die_ss_("returned false", encoder);
 492         printf("OK\n");
 493
 494         printf("testing FLAC__seekable_stream_encoder_set_blocksize()... ");
 495         if(!FLAC__seekable_stream_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 496                 return die_ss_("returned false", encoder);
 497         printf("OK\n");
 498
 499         printf("testing FLAC__seekable_stream_encoder_set_max_lpc_order()... ");
 500         if(!FLAC__seekable_stream_encoder_set_max_lpc_order(encoder, 0))
 501                 return die_ss_("returned false", encoder);
 502         printf("OK\n");
 503
 504         printf("testing FLAC__seekable_stream_encoder_set_qlp_coeff_precision()... ");
 505         if(!FLAC__seekable_stream_encoder_set_qlp_coeff_precision(encoder, 0))
 506                 return die_ss_("returned false", encoder);
 507         printf("OK\n");
 508
 509         printf("testing FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search()... ");
 510         if(!FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search(encoder, false))
 511                 return die_ss_("returned false", encoder);
 512         printf("OK\n");
 513
 514         printf("testing FLAC__seekable_stream_encoder_set_do_escape_coding()... ");
 515         if(!FLAC__seekable_stream_encoder_set_do_escape_coding(encoder, false))
 516                 return die_ss_("returned false", encoder);
 517         printf("OK\n");
 518
 519         printf("testing FLAC__seekable_stream_encoder_set_do_exhaustive_model_search()... ");
 520         if(!FLAC__seekable_stream_encoder_set_do_exhaustive_model_search(encoder, false))
 521                 return die_ss_("returned false", encoder);
 522         printf("OK\n");
 523
 524         printf("testing FLAC__seekable_stream_encoder_set_min_residual_partition_order()... ");
 525         if(!FLAC__seekable_stream_encoder_set_min_residual_partition_order(encoder, 0))
 526                 return die_ss_("returned false", encoder);
 527         printf("OK\n");
 528
 529         printf("testing FLAC__seekable_stream_encoder_set_max_residual_partition_order()... ");
 530         if(!FLAC__seekable_stream_encoder_set_max_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_rice_parameter_search_dist()... ");
 535         if(!FLAC__seekable_stream_encoder_set_rice_parameter_search_dist(encoder, 0))
 536                 return die_ss_("returned false", encoder);
 537         printf("OK\n");
 538
 539         printf("testing FLAC__seekable_stream_encoder_set_total_samples_estimate()... ");
 540         if(!FLAC__seekable_stream_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
 541                 return die_ss_("returned false", encoder);
 542         printf("OK\n");
 543
 544         printf("testing FLAC__seekable_stream_encoder_set_metadata()... ");
 545         if(!FLAC__seekable_stream_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
 546                 return die_ss_("returned false", encoder);
 547         printf("OK\n");
 548
 549         printf("testing FLAC__seekable_stream_encoder_set_seek_callback()... ");
 550         if(!FLAC__seekable_stream_encoder_set_seek_callback(encoder, seekable_stream_encoder_seek_callback_))
 551                 return die_ss_("returned false", encoder);
 552         printf("OK\n");
 553
 554         printf("testing FLAC__seekable_stream_encoder_set_tell_callback()... ");
 555         if(!FLAC__seekable_stream_encoder_set_tell_callback(encoder, seekable_stream_encoder_tell_callback_))
 556                 return die_ss_("returned false", encoder);
 557         printf("OK\n");
 558
 559         printf("testing FLAC__seekable_stream_encoder_set_write_callback()... ");
 560         if(!FLAC__seekable_stream_encoder_set_write_callback(encoder, seekable_stream_encoder_write_callback_))
 561                 return die_ss_("returned false", encoder);
 562         printf("OK\n");
 563
 564         printf("testing FLAC__seekable_stream_encoder_set_client_data()... ");
 565         if(!FLAC__seekable_stream_encoder_set_client_data(encoder, 0))
 566                 return die_ss_("returned false", encoder);
 567         printf("OK\n");
 568
 569         printf("testing FLAC__seekable_stream_encoder_init()... ");
 570         if(FLAC__seekable_stream_encoder_init(encoder) != FLAC__SEEKABLE_STREAM_ENCODER_OK)
 571                 return die_ss_(0, encoder);
 572         printf("OK\n");
 573
 574         printf("testing FLAC__seekable_stream_encoder_get_state()... ");
 575         state = FLAC__seekable_stream_encoder_get_state(encoder);
 576         printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__SeekableStreamEncoderStateString[state]);
 577
 578         printf("testing FLAC__seekable_stream_encoder_get_stream_encoder_state()... ");
 579         state_ = FLAC__seekable_stream_encoder_get_stream_encoder_state(encoder);
 580         printf("returned state = %u (%s)... OK\n", (unsigned)state_, FLAC__StreamEncoderStateString[state_]);
 581
 582         printf("testing FLAC__seekable_stream_encoder_get_verify_decoder_state()... ");
 583         dstate = FLAC__seekable_stream_encoder_get_verify_decoder_state(encoder);
 584         printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
 585
 586         {
 587                 FLAC__uint64 absolute_sample;
 588                 unsigned frame_number;
 589                 unsigned channel;
 590                 unsigned sample;
 591                 FLAC__int32 expected;
 592                 FLAC__int32 got;
 593
 594                 printf("testing FLAC__seekable_stream_encoder_get_verify_decoder_error_stats()... ");
 595                 FLAC__seekable_stream_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 596                 printf("OK\n");
 597         }
 598
 599         printf("testing FLAC__seekable_stream_encoder_get_verify()... ");
 600         if(FLAC__seekable_stream_encoder_get_verify(encoder) != true) {
 601                 printf("FAILED, expected true, got false\n");
 602                 return false;
 603         }
 604         printf("OK\n");
 605
 606         printf("testing FLAC__seekable_stream_encoder_get_streamable_subset()... ");
 607         if(FLAC__seekable_stream_encoder_get_streamable_subset(encoder) != true) {
 608                 printf("FAILED, expected true, got false\n");
 609                 return false;
 610         }
 611         printf("OK\n");
 612
 613         printf("testing FLAC__seekable_stream_encoder_get_do_mid_side_stereo()... ");
 614         if(FLAC__seekable_stream_encoder_get_do_mid_side_stereo(encoder) != false) {
 615                 printf("FAILED, expected false, got true\n");
 616                 return false;
 617         }
 618         printf("OK\n");
 619
 620         printf("testing FLAC__seekable_stream_encoder_get_loose_mid_side_stereo()... ");
 621         if(FLAC__seekable_stream_encoder_get_loose_mid_side_stereo(encoder) != false) {
 622                 printf("FAILED, expected false, got true\n");
 623                 return false;
 624         }
 625         printf("OK\n");
 626
 627         printf("testing FLAC__seekable_stream_encoder_get_channels()... ");
 628         if(FLAC__seekable_stream_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
 629                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__seekable_stream_encoder_get_channels(encoder));
 630                 return false;
 631         }
 632         printf("OK\n");
 633
 634         printf("testing FLAC__seekable_stream_encoder_get_bits_per_sample()... ");
 635         if(FLAC__seekable_stream_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
 636                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__seekable_stream_encoder_get_bits_per_sample(encoder));
 637                 return false;
 638         }
 639         printf("OK\n");
 640
 641         printf("testing FLAC__seekable_stream_encoder_get_sample_rate()... ");
 642         if(FLAC__seekable_stream_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
 643                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__seekable_stream_encoder_get_sample_rate(encoder));
 644                 return false;
 645         }
 646         printf("OK\n");
 647
 648         printf("testing FLAC__seekable_stream_encoder_get_blocksize()... ");
 649         if(FLAC__seekable_stream_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
 650                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__seekable_stream_encoder_get_blocksize(encoder));
 651                 return false;
 652         }
 653         printf("OK\n");
 654
 655         printf("testing FLAC__seekable_stream_encoder_get_max_lpc_order()... ");
 656         if(FLAC__seekable_stream_encoder_get_max_lpc_order(encoder) != 0) {
 657                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_max_lpc_order(encoder));
 658                 return false;
 659         }
 660         printf("OK\n");
 661
 662         printf("testing FLAC__seekable_stream_encoder_get_qlp_coeff_precision()... ");
 663         (void)FLAC__seekable_stream_encoder_get_qlp_coeff_precision(encoder);
 664         /* we asked the encoder to auto select this so we accept anything */
 665         printf("OK\n");
 666
 667         printf("testing FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search()... ");
 668         if(FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
 669                 printf("FAILED, expected false, got true\n");
 670                 return false;
 671         }
 672         printf("OK\n");
 673
 674         printf("testing FLAC__seekable_stream_encoder_get_do_escape_coding()... ");
 675         if(FLAC__seekable_stream_encoder_get_do_escape_coding(encoder) != false) {
 676                 printf("FAILED, expected false, got true\n");
 677                 return false;
 678         }
 679         printf("OK\n");
 680
 681         printf("testing FLAC__seekable_stream_encoder_get_do_exhaustive_model_search()... ");
 682         if(FLAC__seekable_stream_encoder_get_do_exhaustive_model_search(encoder) != false) {
 683                 printf("FAILED, expected false, got true\n");
 684                 return false;
 685         }
 686         printf("OK\n");
 687
 688         printf("testing FLAC__seekable_stream_encoder_get_min_residual_partition_order()... ");
 689         if(FLAC__seekable_stream_encoder_get_min_residual_partition_order(encoder) != 0) {
 690                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_min_residual_partition_order(encoder));
 691                 return false;
 692         }
 693         printf("OK\n");
 694
 695         printf("testing FLAC__seekable_stream_encoder_get_max_residual_partition_order()... ");
 696         if(FLAC__seekable_stream_encoder_get_max_residual_partition_order(encoder) != 0) {
 697                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_max_residual_partition_order(encoder));
 698                 return false;
 699         }
 700         printf("OK\n");
 701
 702         printf("testing FLAC__seekable_stream_encoder_get_rice_parameter_search_dist()... ");
 703         if(FLAC__seekable_stream_encoder_get_rice_parameter_search_dist(encoder) != 0) {
 704                 printf("FAILED, expected %u, got %u\n", 0, FLAC__seekable_stream_encoder_get_rice_parameter_search_dist(encoder));
 705                 return false;
 706         }
 707         printf("OK\n");
 708
 709         printf("testing FLAC__seekable_stream_encoder_get_total_samples_estimate()... ");
 710         if(FLAC__seekable_stream_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
 711                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, FLAC__seekable_stream_encoder_get_total_samples_estimate(encoder));
 712                 return false;
 713         }
 714         printf("OK\n");
 715
 716         /* init the dummy sample buffer */
 717         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
 718                 samples[i] = i & 7;
 719
 720         printf("testing FLAC__seekable_stream_encoder_process()... ");
 721         if(!FLAC__seekable_stream_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
 722                 return die_ss_("returned false", encoder);
 723         printf("OK\n");
 724
 725         printf("testing FLAC__seekable_stream_encoder_process_interleaved()... ");
 726         if(!FLAC__seekable_stream_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
 727                 return die_ss_("returned false", encoder);
 728         printf("OK\n");
 729
 730         printf("testing FLAC__seekable_stream_encoder_finish()... ");
 731         FLAC__seekable_stream_encoder_finish(encoder);
 732         printf("OK\n");
 733
 734         printf("testing FLAC__seekable_stream_encoder_delete()... ");
 735         FLAC__seekable_stream_encoder_delete(encoder);
 736         printf("OK\n");
 737
 738         printf("\nPASSED!\n");
 739
 740         return true;
 741 }
 742
 743 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)
 744 {
 745         (void)encoder, (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate, (void)client_data;
 746 }
 747
 748 static FLAC__bool test_file_encoder()
 749 {
 750         FLAC__FileEncoder *encoder;
 751         FLAC__FileEncoderState state;
 752         FLAC__SeekableStreamEncoderState state_;
 753         FLAC__StreamEncoderState state__;
 754         FLAC__StreamDecoderState dstate;
 755         FLAC__int32 samples[1024];
 756         FLAC__int32 *samples_array[1];
 757         unsigned i;
 758
 759         samples_array[0] = samples;
 760
 761         printf("\n+++ libFLAC unit test: FLAC__FileEncoder\n\n");
 762
 763         printf("testing FLAC__file_encoder_new()... ");
 764         encoder = FLAC__file_encoder_new();
 765         if(0 == encoder) {
 766                 printf("FAILED, returned NULL\n");
 767                 return false;
 768         }
 769         printf("OK\n");
 770
 771         printf("testing FLAC__file_encoder_set_verify()... ");
 772         if(!FLAC__file_encoder_set_verify(encoder, true))
 773                 return die_f_("returned false", encoder);
 774         printf("OK\n");
 775
 776         printf("testing FLAC__file_encoder_set_streamable_subset()... ");
 777         if(!FLAC__file_encoder_set_streamable_subset(encoder, true))
 778                 return die_f_("returned false", encoder);
 779         printf("OK\n");
 780
 781         printf("testing FLAC__file_encoder_set_do_mid_side_stereo()... ");
 782         if(!FLAC__file_encoder_set_do_mid_side_stereo(encoder, false))
 783                 return die_f_("returned false", encoder);
 784         printf("OK\n");
 785
 786         printf("testing FLAC__file_encoder_set_loose_mid_side_stereo()... ");
 787         if(!FLAC__file_encoder_set_loose_mid_side_stereo(encoder, false))
 788                 return die_f_("returned false", encoder);
 789         printf("OK\n");
 790
 791         printf("testing FLAC__file_encoder_set_channels()... ");
 792         if(!FLAC__file_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
 793                 return die_f_("returned false", encoder);
 794         printf("OK\n");
 795
 796         printf("testing FLAC__file_encoder_set_bits_per_sample()... ");
 797         if(!FLAC__file_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
 798                 return die_f_("returned false", encoder);
 799         printf("OK\n");
 800
 801         printf("testing FLAC__file_encoder_set_sample_rate()... ");
 802         if(!FLAC__file_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
 803                 return die_f_("returned false", encoder);
 804         printf("OK\n");
 805
 806         printf("testing FLAC__file_encoder_set_blocksize()... ");
 807         if(!FLAC__file_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
 808                 return die_f_("returned false", encoder);
 809         printf("OK\n");
 810
 811         printf("testing FLAC__file_encoder_set_max_lpc_order()... ");
 812         if(!FLAC__file_encoder_set_max_lpc_order(encoder, 0))
 813                 return die_f_("returned false", encoder);
 814         printf("OK\n");
 815
 816         printf("testing FLAC__file_encoder_set_qlp_coeff_precision()... ");
 817         if(!FLAC__file_encoder_set_qlp_coeff_precision(encoder, 0))
 818                 return die_f_("returned false", encoder);
 819         printf("OK\n");
 820
 821         printf("testing FLAC__file_encoder_set_do_qlp_coeff_prec_search()... ");
 822         if(!FLAC__file_encoder_set_do_qlp_coeff_prec_search(encoder, false))
 823                 return die_f_("returned false", encoder);
 824         printf("OK\n");
 825
 826         printf("testing FLAC__file_encoder_set_do_escape_coding()... ");
 827         if(!FLAC__file_encoder_set_do_escape_coding(encoder, false))
 828                 return die_f_("returned false", encoder);
 829         printf("OK\n");
 830
 831         printf("testing FLAC__file_encoder_set_do_exhaustive_model_search()... ");
 832         if(!FLAC__file_encoder_set_do_exhaustive_model_search(encoder, false))
 833                 return die_f_("returned false", encoder);
 834         printf("OK\n");
 835
 836         printf("testing FLAC__file_encoder_set_min_residual_partition_order()... ");
 837         if(!FLAC__file_encoder_set_min_residual_partition_order(encoder, 0))
 838                 return die_f_("returned false", encoder);
 839         printf("OK\n");
 840
 841         printf("testing FLAC__file_encoder_set_max_residual_partition_order()... ");
 842         if(!FLAC__file_encoder_set_max_residual_partition_order(encoder, 0))
 843                 return die_f_("returned false", encoder);
 844         printf("OK\n");
 845
 846         printf("testing FLAC__file_encoder_set_rice_parameter_search_dist()... ");
 847         if(!FLAC__file_encoder_set_rice_parameter_search_dist(encoder, 0))
 848                 return die_f_("returned false", encoder);
 849         printf("OK\n");
 850
 851         printf("testing FLAC__file_encoder_set_total_samples_estimate()... ");
 852         if(!FLAC__file_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
 853                 return die_f_("returned false", encoder);
 854         printf("OK\n");
 855
 856         printf("testing FLAC__file_encoder_set_metadata()... ");
 857         if(!FLAC__file_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
 858                 return die_f_("returned false", encoder);
 859         printf("OK\n");
 860
 861         printf("testing FLAC__file_encoder_set_filename()... ");
 862         if(!FLAC__file_encoder_set_filename(encoder, flacfilename_))
 863                 return die_f_("returned false", encoder);
 864         printf("OK\n");
 865
 866         printf("testing FLAC__file_encoder_set_progress_callback()... ");
 867         if(!FLAC__file_encoder_set_progress_callback(encoder, file_encoder_progress_callback_))
 868                 return die_f_("returned false", encoder);
 869         printf("OK\n");
 870
 871         printf("testing FLAC__file_encoder_set_client_data()... ");
 872         if(!FLAC__file_encoder_set_client_data(encoder, 0))
 873                 return die_f_("returned false", encoder);
 874         printf("OK\n");
 875
 876         printf("testing FLAC__file_encoder_init()... ");
 877         if(FLAC__file_encoder_init(encoder) != FLAC__FILE_ENCODER_OK)
 878                 return die_f_(0, encoder);
 879         printf("OK\n");
 880
 881         printf("testing FLAC__file_encoder_get_state()... ");
 882         state = FLAC__file_encoder_get_state(encoder);
 883         printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__FileEncoderStateString[state]);
 884
 885         printf("testing FLAC__file_encoder_get_seekable_stream_encoder_state()... ");
 886         state_ = FLAC__file_encoder_get_seekable_stream_encoder_state(encoder);
 887         printf("returned state = %u (%s)... OK\n", (unsigned)state_, FLAC__SeekableStreamEncoderStateString[state_]);
 888
 889         printf("testing FLAC__file_encoder_get_stream_encoder_state()... ");
 890         state__ = FLAC__file_encoder_get_stream_encoder_state(encoder);
 891         printf("returned state = %u (%s)... OK\n", (unsigned)state__, FLAC__StreamEncoderStateString[state__]);
 892
 893         printf("testing FLAC__file_encoder_get_verify_decoder_state()... ");
 894         dstate = FLAC__file_encoder_get_verify_decoder_state(encoder);
 895         printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
 896
 897         {
 898                 FLAC__uint64 absolute_sample;
 899                 unsigned frame_number;
 900                 unsigned channel;
 901                 unsigned sample;
 902                 FLAC__int32 expected;
 903                 FLAC__int32 got;
 904
 905                 printf("testing FLAC__file_encoder_get_verify_decoder_error_stats()... ");
 906                 FLAC__file_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 907                 printf("OK\n");
 908         }
 909
 910         printf("testing FLAC__file_encoder_get_verify()... ");
 911         if(FLAC__file_encoder_get_verify(encoder) != true) {
 912                 printf("FAILED, expected true, got false\n");
 913                 return false;
 914         }
 915         printf("OK\n");
 916
 917         printf("testing FLAC__file_encoder_get_streamable_subset()... ");
 918         if(FLAC__file_encoder_get_streamable_subset(encoder) != true) {
 919                 printf("FAILED, expected true, got false\n");
 920                 return false;
 921         }
 922         printf("OK\n");
 923
 924         printf("testing FLAC__file_encoder_get_do_mid_side_stereo()... ");
 925         if(FLAC__file_encoder_get_do_mid_side_stereo(encoder) != false) {
 926                 printf("FAILED, expected false, got true\n");
 927                 return false;
 928         }
 929         printf("OK\n");
 930
 931         printf("testing FLAC__file_encoder_get_loose_mid_side_stereo()... ");
 932         if(FLAC__file_encoder_get_loose_mid_side_stereo(encoder) != false) {
 933                 printf("FAILED, expected false, got true\n");
 934                 return false;
 935         }
 936         printf("OK\n");
 937
 938         printf("testing FLAC__file_encoder_get_channels()... ");
 939         if(FLAC__file_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
 940                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__file_encoder_get_channels(encoder));
 941                 return false;
 942         }
 943         printf("OK\n");
 944
 945         printf("testing FLAC__file_encoder_get_bits_per_sample()... ");
 946         if(FLAC__file_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
 947                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__file_encoder_get_bits_per_sample(encoder));
 948                 return false;
 949         }
 950         printf("OK\n");
 951
 952         printf("testing FLAC__file_encoder_get_sample_rate()... ");
 953         if(FLAC__file_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
 954                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__file_encoder_get_sample_rate(encoder));
 955                 return false;
 956         }
 957         printf("OK\n");
 958
 959         printf("testing FLAC__file_encoder_get_blocksize()... ");
 960         if(FLAC__file_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
 961                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__file_encoder_get_blocksize(encoder));
 962                 return false;
 963         }
 964         printf("OK\n");
 965
 966         printf("testing FLAC__file_encoder_get_max_lpc_order()... ");
 967         if(FLAC__file_encoder_get_max_lpc_order(encoder) != 0) {
 968                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_max_lpc_order(encoder));
 969                 return false;
 970         }
 971         printf("OK\n");
 972
 973         printf("testing FLAC__file_encoder_get_qlp_coeff_precision()... ");
 974         (void)FLAC__file_encoder_get_qlp_coeff_precision(encoder);
 975         /* we asked the encoder to auto select this so we accept anything */
 976         printf("OK\n");
 977
 978         printf("testing FLAC__file_encoder_get_do_qlp_coeff_prec_search()... ");
 979         if(FLAC__file_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
 980                 printf("FAILED, expected false, got true\n");
 981                 return false;
 982         }
 983         printf("OK\n");
 984
 985         printf("testing FLAC__file_encoder_get_do_escape_coding()... ");
 986         if(FLAC__file_encoder_get_do_escape_coding(encoder) != false) {
 987                 printf("FAILED, expected false, got true\n");
 988                 return false;
 989         }
 990         printf("OK\n");
 991
 992         printf("testing FLAC__file_encoder_get_do_exhaustive_model_search()... ");
 993         if(FLAC__file_encoder_get_do_exhaustive_model_search(encoder) != false) {
 994                 printf("FAILED, expected false, got true\n");
 995                 return false;
 996         }
 997         printf("OK\n");
 998
 999         printf("testing FLAC__file_encoder_get_min_residual_partition_order()... ");
1000         if(FLAC__file_encoder_get_min_residual_partition_order(encoder) != 0) {
1001                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_min_residual_partition_order(encoder));
1002                 return false;
1003         }
1004         printf("OK\n");
1005
1006         printf("testing FLAC__file_encoder_get_max_residual_partition_order()... ");
1007         if(FLAC__file_encoder_get_max_residual_partition_order(encoder) != 0) {
1008                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_max_residual_partition_order(encoder));
1009                 return false;
1010         }
1011         printf("OK\n");
1012
1013         printf("testing FLAC__file_encoder_get_rice_parameter_search_dist()... ");
1014         if(FLAC__file_encoder_get_rice_parameter_search_dist(encoder) != 0) {
1015                 printf("FAILED, expected %u, got %u\n", 0, FLAC__file_encoder_get_rice_parameter_search_dist(encoder));
1016                 return false;
1017         }
1018         printf("OK\n");
1019
1020         printf("testing FLAC__file_encoder_get_total_samples_estimate()... ");
1021         if(FLAC__file_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
1022                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, FLAC__file_encoder_get_total_samples_estimate(encoder));
1023                 return false;
1024         }
1025         printf("OK\n");
1026
1027         /* init the dummy sample buffer */
1028         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
1029                 samples[i] = i & 7;
1030
1031         printf("testing FLAC__file_encoder_process()... ");
1032         if(!FLAC__file_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
1033                 return die_f_("returned false", encoder);
1034         printf("OK\n");
1035
1036         printf("testing FLAC__file_encoder_process_interleaved()... ");
1037         if(!FLAC__file_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
1038                 return die_f_("returned false", encoder);
1039         printf("OK\n");
1040
1041         printf("testing FLAC__file_encoder_finish()... ");
1042         FLAC__file_encoder_finish(encoder);
1043         printf("OK\n");
1044
1045         printf("testing FLAC__file_encoder_delete()... ");
1046         FLAC__file_encoder_delete(encoder);
1047         printf("OK\n");
1048
1049         printf("\nPASSED!\n");
1050
1051         return true;
1052 }
1053
1054 FLAC__bool test_encoders()
1055 {
1056         init_metadata_blocks_();
1057
1058         if(!test_stream_encoder())
1059                 return false;
1060
1061         if(!test_seekable_stream_encoder())
1062                 return false;
1063
1064         if(!test_file_encoder())
1065                 return false;
1066
1067         (void) grabbag__file_remove_file(flacfilename_);
1068         free_metadata_blocks_();
1069
1070         return true;
1071 }