src/test_libFLAC/encoders.c

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