src/test_libFLAC++/encoders.cpp

   1 /* test_libFLAC++ - Unit tester for libFLAC++
   2  * Copyright (C) 2002,2003,2004,2005,2006  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #include "encoders.h"
  20 #include "FLAC/assert.h"
  21 #include "FLAC++/encoder.h"
  22 #include "share/grabbag.h"
  23 extern "C" {
  24 #include "test_libs_common/file_utils_flac.h"
  25 #include "test_libs_common/metadata_utils.h"
  26 }
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 typedef enum {
  33         LAYER_STREAM = 0, /* FLAC__stream_encoder_init_stream() without seeking */
  34         LAYER_SEEKABLE_STREAM, /* FLAC__stream_encoder_init_stream() with seeking */
  35         LAYER_FILE, /* FLAC__stream_encoder_init_FILE() */
  36         LAYER_FILENAME /* FLAC__stream_encoder_init_file() */
  37 } Layer;
  38
  39 static const char * const LayerString[] = {
  40         "Stream",
  41         "Seekable Stream",
  42         "FILE*",
  43         "Filename"
  44 };
  45
  46 static ::FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, picture_, unknown_;
  47 static ::FLAC__StreamMetadata *metadata_sequence_[] = { &vorbiscomment_, &padding_, &seektable_, &application1_, &application2_, &cuesheet_, &picture_, &unknown_ };
  48 static const unsigned num_metadata_ = sizeof(metadata_sequence_) / sizeof(metadata_sequence_[0]);
  49
  50 static const char *flacfilename(bool is_ogg)
  51 {
  52         return is_ogg? "metadata.ogg" : "metadata.flac";
  53 }
  54
  55 static bool die_(const char *msg)
  56 {
  57         printf("ERROR: %s\n", msg);
  58         return false;
  59 }
  60
  61 static bool die_s_(const char *msg, const FLAC::Encoder::Stream *encoder)
  62 {
  63         FLAC::Encoder::Stream::State state = encoder->get_state();
  64
  65         if(msg)
  66                 printf("FAILED, %s", msg);
  67         else
  68                 printf("FAILED");
  69
  70         printf(", state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
  71         if(state == ::FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
  72                 FLAC::Decoder::Stream::State dstate = encoder->get_verify_decoder_state();
  73                 printf("      verify decoder state = %u (%s)\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
  74         }
  75
  76         return false;
  77 }
  78
  79 static void init_metadata_blocks_()
  80 {
  81         mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
  82 }
  83
  84 static void free_metadata_blocks_()
  85 {
  86         mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
  87 }
  88
  89 class StreamEncoder : public FLAC::Encoder::Stream {
  90 public:
  91         Layer layer_;
  92
  93         StreamEncoder(Layer layer): FLAC::Encoder::Stream(), layer_(layer) { }
  94         ~StreamEncoder() { }
  95
  96         // from FLAC::Encoder::Stream
  97         ::FLAC__StreamEncoderReadStatus read_callback(FLAC__byte buffer[], size_t *bytes);
  98         ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame);
  99         ::FLAC__StreamEncoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset);
 100         ::FLAC__StreamEncoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset);
 101         void metadata_callback(const ::FLAC__StreamMetadata *metadata);
 102 };
 103
 104 ::FLAC__StreamEncoderReadStatus StreamEncoder::read_callback(FLAC__byte buffer[], size_t *bytes)
 105 {
 106         (void)buffer, (void)bytes;
 107
 108         return ::FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
 109 }
 110
 111 ::FLAC__StreamEncoderWriteStatus StreamEncoder::write_callback(const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame)
 112 {
 113         (void)buffer, (void)bytes, (void)samples, (void)current_frame;
 114
 115         return ::FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 116 }
 117
 118 ::FLAC__StreamEncoderSeekStatus StreamEncoder::seek_callback(FLAC__uint64 absolute_byte_offset)
 119 {
 120         (void)absolute_byte_offset;
 121
 122         return layer_==LAYER_STREAM? ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED : ::FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 123 }
 124
 125 ::FLAC__StreamEncoderTellStatus StreamEncoder::tell_callback(FLAC__uint64 *absolute_byte_offset)
 126 {
 127         *absolute_byte_offset = 0;
 128
 129         return layer_==LAYER_STREAM? ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED : ::FLAC__STREAM_ENCODER_TELL_STATUS_OK;
 130 }
 131
 132 void StreamEncoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
 133 {
 134         (void)metadata;
 135 }
 136
 137 class FileEncoder : public FLAC::Encoder::File {
 138 public:
 139         Layer layer_;
 140
 141         FileEncoder(Layer layer): FLAC::Encoder::File(), layer_(layer) { }
 142         ~FileEncoder() { }
 143
 144         // from FLAC::Encoder::File
 145         void progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate);
 146 };
 147
 148 void FileEncoder::progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate)
 149 {
 150         (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate;
 151 }
 152
 153 static FLAC::Encoder::Stream *new_by_layer(Layer layer)
 154 {
 155         if(layer < LAYER_FILE)
 156                 return new StreamEncoder(layer);
 157         else
 158                 return new FileEncoder(layer);
 159 }
 160
 161 static bool test_stream_encoder(Layer layer, bool is_ogg)
 162 {
 163         FLAC::Encoder::Stream *encoder;
 164         ::FLAC__StreamEncoderInitStatus init_status;
 165         FILE *file = 0;
 166         FLAC__int32 samples[1024];
 167         FLAC__int32 *samples_array[1] = { samples };
 168         unsigned i;
 169
 170         printf("\n+++ libFLAC++ unit test: FLAC::Encoder::%s (layer: %s, format: %s)\n\n", layer<LAYER_FILE? "Stream":"File", LayerString[layer], is_ogg? "Ogg FLAC":"FLAC");
 171
 172         printf("allocating encoder instance... ");
 173         encoder = new_by_layer(layer);
 174         if(0 == encoder) {
 175                 printf("FAILED, new returned NULL\n");
 176                 return false;
 177         }
 178         printf("OK\n");
 179
 180         printf("testing is_valid()... ");
 181         if(!encoder->is_valid()) {
 182                 printf("FAILED, returned false\n");
 183                 return false;
 184         }
 185         printf("OK\n");
 186
 187         if(is_ogg) {
 188                 printf("testing set_ogg_serial_number()... ");
 189                 if(!encoder->set_ogg_serial_number(file_utils__ogg_serial_number))
 190                         return die_s_("returned false", encoder);
 191                 printf("OK\n");
 192         }
 193
 194         printf("testing set_verify()... ");
 195         if(!encoder->set_verify(true))
 196                 return die_s_("returned false", encoder);
 197         printf("OK\n");
 198
 199         printf("testing set_streamable_subset()... ");
 200         if(!encoder->set_streamable_subset(true))
 201                 return die_s_("returned false", encoder);
 202         printf("OK\n");
 203
 204         printf("testing set_do_mid_side_stereo()... ");
 205         if(!encoder->set_do_mid_side_stereo(false))
 206                 return die_s_("returned false", encoder);
 207         printf("OK\n");
 208
 209         printf("testing set_loose_mid_side_stereo()... ");
 210         if(!encoder->set_loose_mid_side_stereo(false))
 211                 return die_s_("returned false", encoder);
 212         printf("OK\n");
 213
 214         printf("testing set_channels()... ");
 215         if(!encoder->set_channels(streaminfo_.data.stream_info.channels))
 216                 return die_s_("returned false", encoder);
 217         printf("OK\n");
 218
 219         printf("testing set_bits_per_sample()... ");
 220         if(!encoder->set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample))
 221                 return die_s_("returned false", encoder);
 222         printf("OK\n");
 223
 224         printf("testing set_sample_rate()... ");
 225         if(!encoder->set_sample_rate(streaminfo_.data.stream_info.sample_rate))
 226                 return die_s_("returned false", encoder);
 227         printf("OK\n");
 228
 229         printf("testing set_blocksize()... ");
 230         if(!encoder->set_blocksize(streaminfo_.data.stream_info.min_blocksize))
 231                 return die_s_("returned false", encoder);
 232         printf("OK\n");
 233
 234         printf("testing set_max_lpc_order()... ");
 235         if(!encoder->set_max_lpc_order(0))
 236                 return die_s_("returned false", encoder);
 237         printf("OK\n");
 238
 239         printf("testing set_qlp_coeff_precision()... ");
 240         if(!encoder->set_qlp_coeff_precision(0))
 241                 return die_s_("returned false", encoder);
 242         printf("OK\n");
 243
 244         printf("testing set_do_qlp_coeff_prec_search()... ");
 245         if(!encoder->set_do_qlp_coeff_prec_search(false))
 246                 return die_s_("returned false", encoder);
 247         printf("OK\n");
 248
 249         printf("testing set_do_escape_coding()... ");
 250         if(!encoder->set_do_escape_coding(false))
 251                 return die_s_("returned false", encoder);
 252         printf("OK\n");
 253
 254         printf("testing set_do_exhaustive_model_search()... ");
 255         if(!encoder->set_do_exhaustive_model_search(false))
 256                 return die_s_("returned false", encoder);
 257         printf("OK\n");
 258
 259         printf("testing set_min_residual_partition_order()... ");
 260         if(!encoder->set_min_residual_partition_order(0))
 261                 return die_s_("returned false", encoder);
 262         printf("OK\n");
 263
 264         printf("testing set_max_residual_partition_order()... ");
 265         if(!encoder->set_max_residual_partition_order(0))
 266                 return die_s_("returned false", encoder);
 267         printf("OK\n");
 268
 269         printf("testing set_rice_parameter_search_dist()... ");
 270         if(!encoder->set_rice_parameter_search_dist(0))
 271                 return die_s_("returned false", encoder);
 272         printf("OK\n");
 273
 274         printf("testing set_total_samples_estimate()... ");
 275         if(!encoder->set_total_samples_estimate(streaminfo_.data.stream_info.total_samples))
 276                 return die_s_("returned false", encoder);
 277         printf("OK\n");
 278
 279         printf("testing set_metadata()... ");
 280         if(!encoder->set_metadata(metadata_sequence_, num_metadata_))
 281                 return die_s_("returned false", encoder);
 282         printf("OK\n");
 283
 284         switch(layer) {
 285                 case LAYER_STREAM:
 286                 case LAYER_SEEKABLE_STREAM:
 287                         printf("testing init%s()... ", is_ogg? "_ogg":"");
 288                         init_status = is_ogg? encoder->init_ogg() : encoder->init();
 289                         break;
 290                 case LAYER_FILE:
 291                         printf("opening file for FLAC output... ");
 292                         file = ::fopen(flacfilename(is_ogg), "w+b");
 293                         if(0 == file) {
 294                                 printf("ERROR (%s)\n", strerror(errno));
 295                                 return false;
 296                         }
 297                         printf("OK\n");
 298
 299                         printf("testing init%s()... ", is_ogg? "_ogg":"");
 300                         init_status = is_ogg?
 301                                 dynamic_cast<FLAC::Encoder::File*>(encoder)->init_ogg(file) :
 302                                 dynamic_cast<FLAC::Encoder::File*>(encoder)->init(file);
 303                         break;
 304                 case LAYER_FILENAME:
 305                         printf("testing init%s()... ", is_ogg? "_ogg":"");
 306                         init_status = is_ogg?
 307                                 dynamic_cast<FLAC::Encoder::File*>(encoder)->init_ogg(flacfilename(is_ogg)) :
 308                                 dynamic_cast<FLAC::Encoder::File*>(encoder)->init(flacfilename(is_ogg));
 309                         break;
 310                 default:
 311                         die_("internal error 001");
 312                         return false;
 313         }
 314         if(init_status != ::FLAC__STREAM_ENCODER_INIT_STATUS_OK)
 315                 return die_s_(0, encoder);
 316         printf("OK\n");
 317
 318         printf("testing get_state()... ");
 319         FLAC::Encoder::Stream::State state = encoder->get_state();
 320         printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
 321
 322         printf("testing get_verify_decoder_state()... ");
 323         FLAC::Decoder::Stream::State dstate = encoder->get_verify_decoder_state();
 324         printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
 325
 326         {
 327                 FLAC__uint64 absolute_sample;
 328                 unsigned frame_number;
 329                 unsigned channel;
 330                 unsigned sample;
 331                 FLAC__int32 expected;
 332                 FLAC__int32 got;
 333
 334                 printf("testing get_verify_decoder_error_stats()... ");
 335                 encoder->get_verify_decoder_error_stats(&absolute_sample, &frame_number, &channel, &sample, &expected, &got);
 336                 printf("OK\n");
 337         }
 338
 339         printf("testing get_verify()... ");
 340         if(encoder->get_verify() != true) {
 341                 printf("FAILED, expected true, got false\n");
 342                 return false;
 343         }
 344         printf("OK\n");
 345
 346         printf("testing get_streamable_subset()... ");
 347         if(encoder->get_streamable_subset() != true) {
 348                 printf("FAILED, expected true, got false\n");
 349                 return false;
 350         }
 351         printf("OK\n");
 352
 353         printf("testing get_do_mid_side_stereo()... ");
 354         if(encoder->get_do_mid_side_stereo() != false) {
 355                 printf("FAILED, expected false, got true\n");
 356                 return false;
 357         }
 358         printf("OK\n");
 359
 360         printf("testing get_loose_mid_side_stereo()... ");
 361         if(encoder->get_loose_mid_side_stereo() != false) {
 362                 printf("FAILED, expected false, got true\n");
 363                 return false;
 364         }
 365         printf("OK\n");
 366
 367         printf("testing get_channels()... ");
 368         if(encoder->get_channels() != streaminfo_.data.stream_info.channels) {
 369                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, encoder->get_channels());
 370                 return false;
 371         }
 372         printf("OK\n");
 373
 374         printf("testing get_bits_per_sample()... ");
 375         if(encoder->get_bits_per_sample() != streaminfo_.data.stream_info.bits_per_sample) {
 376                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, encoder->get_bits_per_sample());
 377                 return false;
 378         }
 379         printf("OK\n");
 380
 381         printf("testing get_sample_rate()... ");
 382         if(encoder->get_sample_rate() != streaminfo_.data.stream_info.sample_rate) {
 383                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, encoder->get_sample_rate());
 384                 return false;
 385         }
 386         printf("OK\n");
 387
 388         printf("testing get_blocksize()... ");
 389         if(encoder->get_blocksize() != streaminfo_.data.stream_info.min_blocksize) {
 390                 printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, encoder->get_blocksize());
 391                 return false;
 392         }
 393         printf("OK\n");
 394
 395         printf("testing get_max_lpc_order()... ");
 396         if(encoder->get_max_lpc_order() != 0) {
 397                 printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_lpc_order());
 398                 return false;
 399         }
 400         printf("OK\n");
 401
 402         printf("testing get_qlp_coeff_precision()... ");
 403         (void)encoder->get_qlp_coeff_precision();
 404         /* we asked the encoder to auto select this so we accept anything */
 405         printf("OK\n");
 406
 407         printf("testing get_do_qlp_coeff_prec_search()... ");
 408         if(encoder->get_do_qlp_coeff_prec_search() != false) {
 409                 printf("FAILED, expected false, got true\n");
 410                 return false;
 411         }
 412         printf("OK\n");
 413
 414         printf("testing get_do_escape_coding()... ");
 415         if(encoder->get_do_escape_coding() != false) {
 416                 printf("FAILED, expected false, got true\n");
 417                 return false;
 418         }
 419         printf("OK\n");
 420
 421         printf("testing get_do_exhaustive_model_search()... ");
 422         if(encoder->get_do_exhaustive_model_search() != false) {
 423                 printf("FAILED, expected false, got true\n");
 424                 return false;
 425         }
 426         printf("OK\n");
 427
 428         printf("testing get_min_residual_partition_order()... ");
 429         if(encoder->get_min_residual_partition_order() != 0) {
 430                 printf("FAILED, expected %u, got %u\n", 0, encoder->get_min_residual_partition_order());
 431                 return false;
 432         }
 433         printf("OK\n");
 434
 435         printf("testing get_max_residual_partition_order()... ");
 436         if(encoder->get_max_residual_partition_order() != 0) {
 437                 printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_residual_partition_order());
 438                 return false;
 439         }
 440         printf("OK\n");
 441
 442         printf("testing get_rice_parameter_search_dist()... ");
 443         if(encoder->get_rice_parameter_search_dist() != 0) {
 444                 printf("FAILED, expected %u, got %u\n", 0, encoder->get_rice_parameter_search_dist());
 445                 return false;
 446         }
 447         printf("OK\n");
 448
 449         printf("testing get_total_samples_estimate()... ");
 450         if(encoder->get_total_samples_estimate() != streaminfo_.data.stream_info.total_samples) {
 451                 printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, encoder->get_total_samples_estimate());
 452                 return false;
 453         }
 454         printf("OK\n");
 455
 456         /* init the dummy sample buffer */
 457         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
 458                 samples[i] = i & 7;
 459
 460         printf("testing process()... ");
 461         if(!encoder->process(samples_array, sizeof(samples) / sizeof(FLAC__int32)))
 462                 return die_s_("returned false", encoder);
 463         printf("OK\n");
 464
 465         printf("testing process_interleaved()... ");
 466         if(!encoder->process_interleaved(samples, sizeof(samples) / sizeof(FLAC__int32)))
 467                 return die_s_("returned false", encoder);
 468         printf("OK\n");
 469
 470         printf("testing finish()... ");
 471         encoder->finish();
 472         printf("OK\n");
 473
 474         printf("freeing encoder instance... ");
 475         delete encoder;
 476         printf("OK\n");
 477
 478         printf("\nPASSED!\n");
 479
 480         return true;
 481 }
 482
 483 bool test_encoders()
 484 {
 485         FLAC__bool is_ogg = false;
 486
 487         while(1) {
 488                 init_metadata_blocks_();
 489
 490                 if(!test_stream_encoder(LAYER_STREAM, is_ogg))
 491                         return false;
 492
 493                 if(!test_stream_encoder(LAYER_SEEKABLE_STREAM, is_ogg))
 494                         return false;
 495
 496                 if(!test_stream_encoder(LAYER_FILE, is_ogg))
 497                         return false;
 498
 499                 if(!test_stream_encoder(LAYER_FILENAME, is_ogg))
 500                         return false;
 501
 502                 (void) grabbag__file_remove_file(flacfilename(is_ogg));
 503
 504                 free_metadata_blocks_();
 505
 506                 if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
 507                         break;
 508                 is_ogg = true;
 509         }
 510
 511         return true;
 512 }