← Back to branch summary

~ubuntu-branches/ubuntu/natty/flac/natty

« back to all changes in this revision

Viewing changes to src/test_libFLAC++/encoders.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Joshua Kwan
  • Date: 2007-05-29 22:56:36 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070529225636-ljeff8xxip09qaap
Tags: 1.1.4-1
http://bugs.debian.org/405167
http://bugs.debian.org/411311
* New upstream release. closes: #405167, #411311
  - libOggFLAC and libOggFLAC++ have been merged into libFLAC, so
    remove their corresponding packages.
  - Because of the API changes required to effect the above, there has
    been yet another soname bump. libflac7 -> libflac8 and
    libflac++5 -> libflac++6. Emails have been dispatched to the
    maintainers of dependent packages.
* Some notes on patches that were removed:
  - 02_stdin_stdout, 06_manpage_mention_utf8_convert: merged upstream
  - 08_manpage_warnings: Upstream has changed the manpage so it defintely
    can't fit in in 80 cols, so just forget about it. We'll live.
  - 05_eof_warnings_are_errors: Upstream decided to add a -w option to
    flac to treat all warnings as errors. I am going to defer to that
    for now, but if people think it's stupid let me know and I'll port
    the patch forward.
  - 04_stack_smasher: was a backport from 1.1.3, so it's obsolete.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test_libFLAC++/encoders.cpp
1
1
/* test_libFLAC++ - Unit tester for libFLAC++
2
 
 * Copyright (C) 2002,2003,2004,2005  Josh Coalson
 
2
 * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or
5
5
 * modify it under the terms of the GNU General Public License
17
17
 */
18
18
 
19
19
#include "encoders.h"
20
 
extern "C" {
21
 
#include "file_utils.h"
22
 
#include "metadata_utils.h"
23
 
}
24
20
#include "FLAC/assert.h"
25
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>
26
28
#include <stdio.h>
27
29
#include <stdlib.h>
28
30
#include <string.h>
29
31
 
30
 
static ::FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, unknown_;
31
 
static ::FLAC__StreamMetadata *metadata_sequence_[] = { &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_ };
 
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_ };
32
48
static const unsigned num_metadata_ = sizeof(metadata_sequence_) / sizeof(metadata_sequence_[0]);
33
 
static const char *flacfilename_ = "metadata.flac";
 
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
}
34
78
 
35
79
static void init_metadata_blocks_()
36
80
{
37
 
        mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 
81
        mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
38
82
}
39
83
 
40
84
static void free_metadata_blocks_()
41
85
{
42
 
        mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
 
86
        mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
43
87
}
44
88
 
45
89
class StreamEncoder : public FLAC::Encoder::Stream {
46
90
public:
47
 
        StreamEncoder(): FLAC::Encoder::Stream() { }
 
91
        Layer layer_;
 
92
        FILE *file_;
 
93
 
 
94
        StreamEncoder(Layer layer): FLAC::Encoder::Stream(), layer_(layer), file_(0) { }
48
95
        ~StreamEncoder() { }
49
96
 
50
97
        // from FLAC::Encoder::Stream
51
 
        ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame);
 
98
        ::FLAC__StreamEncoderReadStatus read_callback(FLAC__byte buffer[], size_t *bytes);
 
99
        ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame);
 
100
        ::FLAC__StreamEncoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset);
 
101
        ::FLAC__StreamEncoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset);
52
102
        void metadata_callback(const ::FLAC__StreamMetadata *metadata);
53
 
 
54
 
        bool die(const char *msg = 0) const;
55
103
};
56
104
 
57
 
::FLAC__StreamEncoderWriteStatus StreamEncoder::write_callback(const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame)
58
 
{
59
 
        (void)buffer, (void)bytes, (void)samples, (void)current_frame;
60
 
 
61
 
        return ::FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 
105
::FLAC__StreamEncoderReadStatus StreamEncoder::read_callback(FLAC__byte buffer[], size_t *bytes)
 
106
{
 
107
        if(*bytes > 0) {
 
108
                *bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file_);
 
109
                if(ferror(file_))
 
110
                        return ::FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
 
111
                else if(*bytes == 0)
 
112
                        return ::FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM;
 
113
                else
 
114
                        return ::FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
 
115
        }
 
116
        else
 
117
                return ::FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
 
118
}
 
119
 
 
120
::FLAC__StreamEncoderWriteStatus StreamEncoder::write_callback(const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame)
 
121
{
 
122
        (void)samples, (void)current_frame;
 
123
 
 
124
        if(fwrite(buffer, 1, bytes, file_) != bytes)
 
125
                return ::FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
 
126
        else
 
127
                return ::FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
 
128
}
 
129
 
 
130
::FLAC__StreamEncoderSeekStatus StreamEncoder::seek_callback(FLAC__uint64 absolute_byte_offset)
 
131
{
 
132
        if(layer_==LAYER_STREAM)
 
133
                return ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
 
134
        else if(fseek(file_, (long)absolute_byte_offset, SEEK_SET) < 0)
 
135
                return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
 
136
        else
 
137
                return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
 
138
}
 
139
 
 
140
::FLAC__StreamEncoderTellStatus StreamEncoder::tell_callback(FLAC__uint64 *absolute_byte_offset)
 
141
{
 
142
        long pos;
 
143
        if(layer_==LAYER_STREAM)
 
144
                return ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED;
 
145
        else if((pos = ftell(file_)) < 0)
 
146
                return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
 
147
        else {
 
148
                *absolute_byte_offset = (FLAC__uint64)pos;
 
149
                return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
 
150
        }
62
151
}
63
152
 
64
153
void StreamEncoder::metadata_callback(const ::FLAC__StreamMetadata *metadata)
66
155
        (void)metadata;
67
156
}
68
157
 
69
 
bool StreamEncoder::die(const char *msg) const
70
 
{
71
 
        State state = get_state();
72
 
 
73
 
        if(msg)
74
 
                printf("FAILED, %s", msg);
75
 
        else
76
 
                printf("FAILED");
77
 
 
78
 
        printf(", state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
79
 
        if(state == ::FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
80
 
                FLAC::Decoder::Stream::State dstate = get_verify_decoder_state();
81
 
                printf("      verify decoder state = %u (%s)\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
82
 
        }
83
 
 
84
 
        return false;
85
 
}
86
 
 
87
 
static bool test_stream_encoder()
88
 
{
89
 
        StreamEncoder *encoder;
90
 
        FLAC__int32 samples[1024];
91
 
        FLAC__int32 *samples_array[1] = { samples };
92
 
        unsigned i;
93
 
 
94
 
        printf("\n+++ libFLAC++ unit test: FLAC::Encoder::Stream\n\n");
95
 
 
96
 
        printf("allocating encoder instance... ");
97
 
        encoder = new StreamEncoder();
98
 
        if(0 == encoder) {
99
 
                printf("FAILED, new returned NULL\n");
100
 
                return false;
101
 
        }
102
 
        printf("OK\n");
103
 
 
104
 
        printf("testing is_valid()... ");
105
 
        if(!encoder->is_valid()) {
106
 
                printf("FAILED, returned false\n");
107
 
                return false;
108
 
        }
109
 
        printf("OK\n");
110
 
 
111
 
        printf("testing set_verify()... ");
112
 
        if(!encoder->set_verify(true))
113
 
                return encoder->die("returned false");
114
 
        printf("OK\n");
115
 
 
116
 
        printf("testing set_streamable_subset()... ");
117
 
        if(!encoder->set_streamable_subset(true))
118
 
                return encoder->die("returned false");
119
 
        printf("OK\n");
120
 
 
121
 
        printf("testing set_do_mid_side_stereo()... ");
122
 
        if(!encoder->set_do_mid_side_stereo(false))
123
 
                return encoder->die("returned false");
124
 
        printf("OK\n");
125
 
 
126
 
        printf("testing set_loose_mid_side_stereo()... ");
127
 
        if(!encoder->set_loose_mid_side_stereo(false))
128
 
                return encoder->die("returned false");
129
 
        printf("OK\n");
130
 
 
131
 
        printf("testing set_channels()... ");
132
 
        if(!encoder->set_channels(streaminfo_.data.stream_info.channels))
133
 
                return encoder->die("returned false");
134
 
        printf("OK\n");
135
 
 
136
 
        printf("testing set_bits_per_sample()... ");
137
 
        if(!encoder->set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample))
138
 
                return encoder->die("returned false");
139
 
        printf("OK\n");
140
 
 
141
 
        printf("testing set_sample_rate()... ");
142
 
        if(!encoder->set_sample_rate(streaminfo_.data.stream_info.sample_rate))
143
 
                return encoder->die("returned false");
144
 
        printf("OK\n");
145
 
 
146
 
        printf("testing set_blocksize()... ");
147
 
        if(!encoder->set_blocksize(streaminfo_.data.stream_info.min_blocksize))
148
 
                return encoder->die("returned false");
149
 
        printf("OK\n");
150
 
 
151
 
        printf("testing set_max_lpc_order()... ");
152
 
        if(!encoder->set_max_lpc_order(0))
153
 
                return encoder->die("returned false");
154
 
        printf("OK\n");
155
 
 
156
 
        printf("testing set_qlp_coeff_precision()... ");
157
 
        if(!encoder->set_qlp_coeff_precision(0))
158
 
                return encoder->die("returned false");
159
 
        printf("OK\n");
160
 
 
161
 
        printf("testing set_do_qlp_coeff_prec_search()... ");
162
 
        if(!encoder->set_do_qlp_coeff_prec_search(false))
163
 
                return encoder->die("returned false");
164
 
        printf("OK\n");
165
 
 
166
 
        printf("testing set_do_escape_coding()... ");
167
 
        if(!encoder->set_do_escape_coding(false))
168
 
                return encoder->die("returned false");
169
 
        printf("OK\n");
170
 
 
171
 
        printf("testing set_do_exhaustive_model_search()... ");
172
 
        if(!encoder->set_do_exhaustive_model_search(false))
173
 
                return encoder->die("returned false");
174
 
        printf("OK\n");
175
 
 
176
 
        printf("testing set_min_residual_partition_order()... ");
177
 
        if(!encoder->set_min_residual_partition_order(0))
178
 
                return encoder->die("returned false");
179
 
        printf("OK\n");
180
 
 
181
 
        printf("testing set_max_residual_partition_order()... ");
182
 
        if(!encoder->set_max_residual_partition_order(0))
183
 
                return encoder->die("returned false");
184
 
        printf("OK\n");
185
 
 
186
 
        printf("testing set_rice_parameter_search_dist()... ");
187
 
        if(!encoder->set_rice_parameter_search_dist(0))
188
 
                return encoder->die("returned false");
189
 
        printf("OK\n");
190
 
 
191
 
        printf("testing set_total_samples_estimate()... ");
192
 
        if(!encoder->set_total_samples_estimate(streaminfo_.data.stream_info.total_samples))
193
 
                return encoder->die("returned false");
194
 
        printf("OK\n");
195
 
 
196
 
        printf("testing set_metadata()... ");
197
 
        if(!encoder->set_metadata(metadata_sequence_, num_metadata_))
198
 
                return encoder->die("returned false");
199
 
        printf("OK\n");
200
 
 
201
 
        printf("testing init()... ");
202
 
        if(encoder->init() != ::FLAC__STREAM_ENCODER_OK)
203
 
                return encoder->die();
204
 
        printf("OK\n");
205
 
 
206
 
        printf("testing get_state()... ");
207
 
        FLAC::Encoder::Stream::State state = encoder->get_state();
208
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
209
 
 
210
 
        printf("testing get_verify_decoder_state()... ");
211
 
        FLAC::Decoder::Stream::State dstate = encoder->get_verify_decoder_state();
212
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
213
 
 
214
 
        {
215
 
                FLAC__uint64 absolute_sample;
216
 
                unsigned frame_number;
217
 
                unsigned channel;
218
 
                unsigned sample;
219
 
                FLAC__int32 expected;
220
 
                FLAC__int32 got;
221
 
 
222
 
                printf("testing get_verify_decoder_error_stats()... ");
223
 
                encoder->get_verify_decoder_error_stats(&absolute_sample, &frame_number, &channel, &sample, &expected, &got);
224
 
                printf("OK\n");
225
 
        }
226
 
 
227
 
        printf("testing get_verify()... ");
228
 
        if(encoder->get_verify() != true) {
229
 
                printf("FAILED, expected true, got false\n");
230
 
                return false;
231
 
        }
232
 
        printf("OK\n");
233
 
 
234
 
        printf("testing get_streamable_subset()... ");
235
 
        if(encoder->get_streamable_subset() != true) {
236
 
                printf("FAILED, expected true, got false\n");
237
 
                return false;
238
 
        }
239
 
        printf("OK\n");
240
 
 
241
 
        printf("testing get_do_mid_side_stereo()... ");
242
 
        if(encoder->get_do_mid_side_stereo() != false) {
243
 
                printf("FAILED, expected false, got true\n");
244
 
                return false;
245
 
        }
246
 
        printf("OK\n");
247
 
 
248
 
        printf("testing get_loose_mid_side_stereo()... ");
249
 
        if(encoder->get_loose_mid_side_stereo() != false) {
250
 
                printf("FAILED, expected false, got true\n");
251
 
                return false;
252
 
        }
253
 
        printf("OK\n");
254
 
 
255
 
        printf("testing get_channels()... ");
256
 
        if(encoder->get_channels() != streaminfo_.data.stream_info.channels) {
257
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, encoder->get_channels());
258
 
                return false;
259
 
        }
260
 
        printf("OK\n");
261
 
 
262
 
        printf("testing get_bits_per_sample()... ");
263
 
        if(encoder->get_bits_per_sample() != streaminfo_.data.stream_info.bits_per_sample) {
264
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, encoder->get_bits_per_sample());
265
 
                return false;
266
 
        }
267
 
        printf("OK\n");
268
 
 
269
 
        printf("testing get_sample_rate()... ");
270
 
        if(encoder->get_sample_rate() != streaminfo_.data.stream_info.sample_rate) {
271
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, encoder->get_sample_rate());
272
 
                return false;
273
 
        }
274
 
        printf("OK\n");
275
 
 
276
 
        printf("testing get_blocksize()... ");
277
 
        if(encoder->get_blocksize() != streaminfo_.data.stream_info.min_blocksize) {
278
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, encoder->get_blocksize());
279
 
                return false;
280
 
        }
281
 
        printf("OK\n");
282
 
 
283
 
        printf("testing get_max_lpc_order()... ");
284
 
        if(encoder->get_max_lpc_order() != 0) {
285
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_lpc_order());
286
 
                return false;
287
 
        }
288
 
        printf("OK\n");
289
 
 
290
 
        printf("testing get_qlp_coeff_precision()... ");
291
 
        (void)encoder->get_qlp_coeff_precision();
292
 
        /* we asked the encoder to auto select this so we accept anything */
293
 
        printf("OK\n");
294
 
 
295
 
        printf("testing get_do_qlp_coeff_prec_search()... ");
296
 
        if(encoder->get_do_qlp_coeff_prec_search() != false) {
297
 
                printf("FAILED, expected false, got true\n");
298
 
                return false;
299
 
        }
300
 
        printf("OK\n");
301
 
 
302
 
        printf("testing get_do_escape_coding()... ");
303
 
        if(encoder->get_do_escape_coding() != false) {
304
 
                printf("FAILED, expected false, got true\n");
305
 
                return false;
306
 
        }
307
 
        printf("OK\n");
308
 
 
309
 
        printf("testing get_do_exhaustive_model_search()... ");
310
 
        if(encoder->get_do_exhaustive_model_search() != false) {
311
 
                printf("FAILED, expected false, got true\n");
312
 
                return false;
313
 
        }
314
 
        printf("OK\n");
315
 
 
316
 
        printf("testing get_min_residual_partition_order()... ");
317
 
        if(encoder->get_min_residual_partition_order() != 0) {
318
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_min_residual_partition_order());
319
 
                return false;
320
 
        }
321
 
        printf("OK\n");
322
 
 
323
 
        printf("testing get_max_residual_partition_order()... ");
324
 
        if(encoder->get_max_residual_partition_order() != 0) {
325
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_residual_partition_order());
326
 
                return false;
327
 
        }
328
 
        printf("OK\n");
329
 
 
330
 
        printf("testing get_rice_parameter_search_dist()... ");
331
 
        if(encoder->get_rice_parameter_search_dist() != 0) {
332
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_rice_parameter_search_dist());
333
 
                return false;
334
 
        }
335
 
        printf("OK\n");
336
 
 
337
 
        printf("testing get_total_samples_estimate()... ");
338
 
        if(encoder->get_total_samples_estimate() != streaminfo_.data.stream_info.total_samples) {
339
 
                printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, encoder->get_total_samples_estimate());
340
 
                return false;
341
 
        }
342
 
        printf("OK\n");
343
 
 
344
 
        /* init the dummy sample buffer */
345
 
        for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
346
 
                samples[i] = i & 7;
347
 
 
348
 
        printf("testing process()... ");
349
 
        if(!encoder->process(samples_array, sizeof(samples) / sizeof(FLAC__int32)))
350
 
                return encoder->die("returned false");
351
 
        printf("OK\n");
352
 
 
353
 
        printf("testing process_interleaved()... ");
354
 
        if(!encoder->process_interleaved(samples, sizeof(samples) / sizeof(FLAC__int32)))
355
 
                return encoder->die("returned false");
356
 
        printf("OK\n");
357
 
 
358
 
        printf("testing finish()... ");
359
 
        encoder->finish();
360
 
        printf("OK\n");
361
 
 
362
 
        printf("freeing encoder instance... ");
363
 
        delete encoder;
364
 
        printf("OK\n");
365
 
 
366
 
        printf("\nPASSED!\n");
367
 
 
368
 
        return true;
369
 
}
370
 
 
371
 
class SeekableStreamEncoder : public FLAC::Encoder::SeekableStream {
372
 
public:
373
 
        SeekableStreamEncoder(): FLAC::Encoder::SeekableStream() { }
374
 
        ~SeekableStreamEncoder() { }
375
 
 
376
 
        // from FLAC::Encoder::SeekableStream
377
 
        ::FLAC__SeekableStreamEncoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset);
378
 
        ::FLAC__SeekableStreamEncoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset);
379
 
        ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame);
380
 
 
381
 
        bool die(const char *msg = 0) const;
382
 
};
383
 
 
384
 
::FLAC__SeekableStreamEncoderSeekStatus SeekableStreamEncoder::seek_callback(FLAC__uint64 absolute_byte_offset)
385
 
{
386
 
        (void)absolute_byte_offset;
387
 
 
388
 
        return ::FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK;
389
 
}
390
 
 
391
 
::FLAC__SeekableStreamEncoderTellStatus SeekableStreamEncoder::tell_callback(FLAC__uint64 *absolute_byte_offset)
392
 
{
393
 
        *absolute_byte_offset = 0;
394
 
 
395
 
        return ::FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK;
396
 
}
397
 
 
398
 
::FLAC__StreamEncoderWriteStatus SeekableStreamEncoder::write_callback(const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame)
399
 
{
400
 
        (void)buffer, (void)bytes, (void)samples, (void)current_frame;
401
 
 
402
 
        return ::FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
403
 
}
404
 
 
405
 
bool SeekableStreamEncoder::die(const char *msg) const
406
 
{
407
 
        State state = get_state();
408
 
 
409
 
        if(msg)
410
 
                printf("FAILED, %s", msg);
411
 
        else
412
 
                printf("FAILED");
413
 
 
414
 
        printf(", state = %u (%s)\n", (unsigned)((::FLAC__SeekableStreamEncoderState)state), state.as_cstring());
415
 
        if(state == ::FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR) {
416
 
                FLAC::Encoder::Stream::State state_ = get_stream_encoder_state();
417
 
                printf("      stream encoder state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state_), state_.as_cstring());
418
 
                if(state_ == ::FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
419
 
                        FLAC::Decoder::Stream::State dstate = get_verify_decoder_state();
420
 
                        printf("      verify decoder state = %u (%s)\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
421
 
                }
422
 
        }
423
 
 
424
 
        return false;
425
 
}
426
 
 
427
 
static bool test_seekable_stream_encoder()
428
 
{
429
 
        SeekableStreamEncoder *encoder;
430
 
        FLAC__int32 samples[1024];
431
 
        FLAC__int32 *samples_array[1] = { samples };
432
 
        unsigned i;
433
 
 
434
 
        printf("\n+++ libFLAC++ unit test: FLAC::Encoder::SeekableStream\n\n");
435
 
 
436
 
        printf("allocating encoder instance... ");
437
 
        encoder = new SeekableStreamEncoder();
438
 
        if(0 == encoder) {
439
 
                printf("FAILED, new returned NULL\n");
440
 
                return false;
441
 
        }
442
 
        printf("OK\n");
443
 
 
444
 
        printf("testing is_valid()... ");
445
 
        if(!encoder->is_valid()) {
446
 
                printf("FAILED, returned false\n");
447
 
                return false;
448
 
        }
449
 
        printf("OK\n");
450
 
 
451
 
        printf("testing set_verify()... ");
452
 
        if(!encoder->set_verify(true))
453
 
                return encoder->die("returned false");
454
 
        printf("OK\n");
455
 
 
456
 
        printf("testing set_streamable_subset()... ");
457
 
        if(!encoder->set_streamable_subset(true))
458
 
                return encoder->die("returned false");
459
 
        printf("OK\n");
460
 
 
461
 
        printf("testing set_do_mid_side_stereo()... ");
462
 
        if(!encoder->set_do_mid_side_stereo(false))
463
 
                return encoder->die("returned false");
464
 
        printf("OK\n");
465
 
 
466
 
        printf("testing set_loose_mid_side_stereo()... ");
467
 
        if(!encoder->set_loose_mid_side_stereo(false))
468
 
                return encoder->die("returned false");
469
 
        printf("OK\n");
470
 
 
471
 
        printf("testing set_channels()... ");
472
 
        if(!encoder->set_channels(streaminfo_.data.stream_info.channels))
473
 
                return encoder->die("returned false");
474
 
        printf("OK\n");
475
 
 
476
 
        printf("testing set_bits_per_sample()... ");
477
 
        if(!encoder->set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample))
478
 
                return encoder->die("returned false");
479
 
        printf("OK\n");
480
 
 
481
 
        printf("testing set_sample_rate()... ");
482
 
        if(!encoder->set_sample_rate(streaminfo_.data.stream_info.sample_rate))
483
 
                return encoder->die("returned false");
484
 
        printf("OK\n");
485
 
 
486
 
        printf("testing set_blocksize()... ");
487
 
        if(!encoder->set_blocksize(streaminfo_.data.stream_info.min_blocksize))
488
 
                return encoder->die("returned false");
489
 
        printf("OK\n");
490
 
 
491
 
        printf("testing set_max_lpc_order()... ");
492
 
        if(!encoder->set_max_lpc_order(0))
493
 
                return encoder->die("returned false");
494
 
        printf("OK\n");
495
 
 
496
 
        printf("testing set_qlp_coeff_precision()... ");
497
 
        if(!encoder->set_qlp_coeff_precision(0))
498
 
                return encoder->die("returned false");
499
 
        printf("OK\n");
500
 
 
501
 
        printf("testing set_do_qlp_coeff_prec_search()... ");
502
 
        if(!encoder->set_do_qlp_coeff_prec_search(false))
503
 
                return encoder->die("returned false");
504
 
        printf("OK\n");
505
 
 
506
 
        printf("testing set_do_escape_coding()... ");
507
 
        if(!encoder->set_do_escape_coding(false))
508
 
                return encoder->die("returned false");
509
 
        printf("OK\n");
510
 
 
511
 
        printf("testing set_do_exhaustive_model_search()... ");
512
 
        if(!encoder->set_do_exhaustive_model_search(false))
513
 
                return encoder->die("returned false");
514
 
        printf("OK\n");
515
 
 
516
 
        printf("testing set_min_residual_partition_order()... ");
517
 
        if(!encoder->set_min_residual_partition_order(0))
518
 
                return encoder->die("returned false");
519
 
        printf("OK\n");
520
 
 
521
 
        printf("testing set_max_residual_partition_order()... ");
522
 
        if(!encoder->set_max_residual_partition_order(0))
523
 
                return encoder->die("returned false");
524
 
        printf("OK\n");
525
 
 
526
 
        printf("testing set_rice_parameter_search_dist()... ");
527
 
        if(!encoder->set_rice_parameter_search_dist(0))
528
 
                return encoder->die("returned false");
529
 
        printf("OK\n");
530
 
 
531
 
        printf("testing set_total_samples_estimate()... ");
532
 
        if(!encoder->set_total_samples_estimate(streaminfo_.data.stream_info.total_samples))
533
 
                return encoder->die("returned false");
534
 
        printf("OK\n");
535
 
 
536
 
        printf("testing set_metadata()... ");
537
 
        if(!encoder->set_metadata(metadata_sequence_, num_metadata_))
538
 
                return encoder->die("returned false");
539
 
        printf("OK\n");
540
 
 
541
 
        printf("testing init()... ");
542
 
        if(encoder->init() != ::FLAC__SEEKABLE_STREAM_ENCODER_OK)
543
 
                return encoder->die();
544
 
        printf("OK\n");
545
 
 
546
 
        printf("testing get_state()... ");
547
 
        FLAC::Encoder::SeekableStream::State state = encoder->get_state();
548
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__SeekableStreamEncoderState)state), state.as_cstring());
549
 
 
550
 
        printf("testing get_stream_encoder_state()... ");
551
 
        FLAC::Encoder::Stream::State state_ = encoder->get_stream_encoder_state();
552
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamEncoderState)state_), state_.as_cstring());
553
 
 
554
 
        printf("testing get_verify_decoder_state()... ");
555
 
        FLAC::Decoder::Stream::State dstate = encoder->get_verify_decoder_state();
556
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
557
 
 
558
 
        {
559
 
                FLAC__uint64 absolute_sample;
560
 
                unsigned frame_number;
561
 
                unsigned channel;
562
 
                unsigned sample;
563
 
                FLAC__int32 expected;
564
 
                FLAC__int32 got;
565
 
 
566
 
                printf("testing get_verify_decoder_error_stats()... ");
567
 
                encoder->get_verify_decoder_error_stats(&absolute_sample, &frame_number, &channel, &sample, &expected, &got);
568
 
                printf("OK\n");
569
 
        }
570
 
 
571
 
        printf("testing get_verify()... ");
572
 
        if(encoder->get_verify() != true) {
573
 
                printf("FAILED, expected true, got false\n");
574
 
                return false;
575
 
        }
576
 
        printf("OK\n");
577
 
 
578
 
        printf("testing get_streamable_subset()... ");
579
 
        if(encoder->get_streamable_subset() != true) {
580
 
                printf("FAILED, expected true, got false\n");
581
 
                return false;
582
 
        }
583
 
        printf("OK\n");
584
 
 
585
 
        printf("testing get_do_mid_side_stereo()... ");
586
 
        if(encoder->get_do_mid_side_stereo() != false) {
587
 
                printf("FAILED, expected false, got true\n");
588
 
                return false;
589
 
        }
590
 
        printf("OK\n");
591
 
 
592
 
        printf("testing get_loose_mid_side_stereo()... ");
593
 
        if(encoder->get_loose_mid_side_stereo() != false) {
594
 
                printf("FAILED, expected false, got true\n");
595
 
                return false;
596
 
        }
597
 
        printf("OK\n");
598
 
 
599
 
        printf("testing get_channels()... ");
600
 
        if(encoder->get_channels() != streaminfo_.data.stream_info.channels) {
601
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, encoder->get_channels());
602
 
                return false;
603
 
        }
604
 
        printf("OK\n");
605
 
 
606
 
        printf("testing get_bits_per_sample()... ");
607
 
        if(encoder->get_bits_per_sample() != streaminfo_.data.stream_info.bits_per_sample) {
608
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, encoder->get_bits_per_sample());
609
 
                return false;
610
 
        }
611
 
        printf("OK\n");
612
 
 
613
 
        printf("testing get_sample_rate()... ");
614
 
        if(encoder->get_sample_rate() != streaminfo_.data.stream_info.sample_rate) {
615
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, encoder->get_sample_rate());
616
 
                return false;
617
 
        }
618
 
        printf("OK\n");
619
 
 
620
 
        printf("testing get_blocksize()... ");
621
 
        if(encoder->get_blocksize() != streaminfo_.data.stream_info.min_blocksize) {
622
 
                printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, encoder->get_blocksize());
623
 
                return false;
624
 
        }
625
 
        printf("OK\n");
626
 
 
627
 
        printf("testing get_max_lpc_order()... ");
628
 
        if(encoder->get_max_lpc_order() != 0) {
629
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_lpc_order());
630
 
                return false;
631
 
        }
632
 
        printf("OK\n");
633
 
 
634
 
        printf("testing get_qlp_coeff_precision()... ");
635
 
        (void)encoder->get_qlp_coeff_precision();
636
 
        /* we asked the encoder to auto select this so we accept anything */
637
 
        printf("OK\n");
638
 
 
639
 
        printf("testing get_do_qlp_coeff_prec_search()... ");
640
 
        if(encoder->get_do_qlp_coeff_prec_search() != false) {
641
 
                printf("FAILED, expected false, got true\n");
642
 
                return false;
643
 
        }
644
 
        printf("OK\n");
645
 
 
646
 
        printf("testing get_do_escape_coding()... ");
647
 
        if(encoder->get_do_escape_coding() != false) {
648
 
                printf("FAILED, expected false, got true\n");
649
 
                return false;
650
 
        }
651
 
        printf("OK\n");
652
 
 
653
 
        printf("testing get_do_exhaustive_model_search()... ");
654
 
        if(encoder->get_do_exhaustive_model_search() != false) {
655
 
                printf("FAILED, expected false, got true\n");
656
 
                return false;
657
 
        }
658
 
        printf("OK\n");
659
 
 
660
 
        printf("testing get_min_residual_partition_order()... ");
661
 
        if(encoder->get_min_residual_partition_order() != 0) {
662
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_min_residual_partition_order());
663
 
                return false;
664
 
        }
665
 
        printf("OK\n");
666
 
 
667
 
        printf("testing get_max_residual_partition_order()... ");
668
 
        if(encoder->get_max_residual_partition_order() != 0) {
669
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_max_residual_partition_order());
670
 
                return false;
671
 
        }
672
 
        printf("OK\n");
673
 
 
674
 
        printf("testing get_rice_parameter_search_dist()... ");
675
 
        if(encoder->get_rice_parameter_search_dist() != 0) {
676
 
                printf("FAILED, expected %u, got %u\n", 0, encoder->get_rice_parameter_search_dist());
677
 
                return false;
678
 
        }
679
 
        printf("OK\n");
680
 
 
681
 
        printf("testing get_total_samples_estimate()... ");
682
 
        if(encoder->get_total_samples_estimate() != streaminfo_.data.stream_info.total_samples) {
683
 
                printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, encoder->get_total_samples_estimate());
684
 
                return false;
685
 
        }
686
 
        printf("OK\n");
687
 
 
688
 
        /* init the dummy sample buffer */
689
 
        for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
690
 
                samples[i] = i & 7;
691
 
 
692
 
        printf("testing process()... ");
693
 
        if(!encoder->process(samples_array, sizeof(samples) / sizeof(FLAC__int32)))
694
 
                return encoder->die("returned false");
695
 
        printf("OK\n");
696
 
 
697
 
        printf("testing process_interleaved()... ");
698
 
        if(!encoder->process_interleaved(samples, sizeof(samples) / sizeof(FLAC__int32)))
699
 
                return encoder->die("returned false");
700
 
        printf("OK\n");
701
 
 
702
 
        printf("testing finish()... ");
703
 
        encoder->finish();
704
 
        printf("OK\n");
705
 
 
706
 
        printf("freeing encoder instance... ");
707
 
        delete encoder;
708
 
        printf("OK\n");
709
 
 
710
 
        printf("\nPASSED!\n");
711
 
 
712
 
        return true;
713
 
}
714
 
 
715
158
class FileEncoder : public FLAC::Encoder::File {
716
159
public:
717
 
        FileEncoder(): FLAC::Encoder::File() { }
 
160
        Layer layer_;
 
161
 
 
162
        FileEncoder(Layer layer): FLAC::Encoder::File(), layer_(layer) { }
718
163
        ~FileEncoder() { }
719
164
 
720
165
        // from FLAC::Encoder::File
721
166
        void progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate);
722
 
 
723
 
        bool die(const char *msg = 0) const;
724
167
};
725
168
 
726
 
void FileEncoder::progress_callback(FLAC__uint64, FLAC__uint64, unsigned, unsigned)
 
169
void FileEncoder::progress_callback(FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate)
727
170
{
 
171
        (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate;
728
172
}
729
173
 
730
 
bool FileEncoder::die(const char *msg) const
 
174
static FLAC::Encoder::Stream *new_by_layer(Layer layer)
731
175
{
732
 
        State state = get_state();
733
 
 
734
 
        if(msg)
735
 
                printf("FAILED, %s", msg);
 
176
        if(layer < LAYER_FILE)
 
177
                return new StreamEncoder(layer);
736
178
        else
737
 
                printf("FAILED");
738
 
 
739
 
        printf(", state = %u (%s)\n", (unsigned)((::FLAC__FileEncoderState)state), state.as_cstring());
740
 
        if(state == ::FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR) {
741
 
                FLAC::Encoder::SeekableStream::State state_ = get_seekable_stream_encoder_state();
742
 
                printf("      seekable stream encoder state = %u (%s)\n", (unsigned)((::FLAC__SeekableStreamEncoderState)state_), state_.as_cstring());
743
 
                if(state_ == ::FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR) {
744
 
                        FLAC::Encoder::Stream::State state__ = get_stream_encoder_state();
745
 
                        printf("      stream encoder state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state__), state__.as_cstring());
746
 
                        if(state__ == ::FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
747
 
                                FLAC::Decoder::Stream::State dstate = get_verify_decoder_state();
748
 
                                printf("      verify decoder state = %u (%s)\n", (unsigned)((::FLAC__StreamDecoderState)dstate), dstate.as_cstring());
749
 
                        }
750
 
                }
751
 
        }
752
 
 
753
 
        return false;
 
179
                return new FileEncoder(layer);
754
180
}
755
181
 
756
 
static bool test_file_encoder()
 
182
static bool test_stream_encoder(Layer layer, bool is_ogg)
757
183
{
758
 
        FileEncoder *encoder;
 
184
        FLAC::Encoder::Stream *encoder;
 
185
        ::FLAC__StreamEncoderInitStatus init_status;
 
186
        FILE *file = 0;
759
187
        FLAC__int32 samples[1024];
760
188
        FLAC__int32 *samples_array[1] = { samples };
761
189
        unsigned i;
762
190
 
763
 
        printf("\n+++ libFLAC++ unit test: FLAC::Encoder::File\n\n");
 
191
        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");
764
192
 
765
193
        printf("allocating encoder instance... ");
766
 
        encoder = new FileEncoder();
 
194
        encoder = new_by_layer(layer);
767
195
        if(0 == encoder) {
768
196
                printf("FAILED, new returned NULL\n");
769
197
                return false;
777
205
        }
778
206
        printf("OK\n");
779
207
 
 
208
        if(is_ogg) {
 
209
                printf("testing set_ogg_serial_number()... ");
 
210
                if(!encoder->set_ogg_serial_number(file_utils__ogg_serial_number))
 
211
                        return die_s_("returned false", encoder);
 
212
                printf("OK\n");
 
213
        }
 
214
 
780
215
        printf("testing set_verify()... ");
781
216
        if(!encoder->set_verify(true))
782
 
                return encoder->die("returned false");
 
217
                return die_s_("returned false", encoder);
783
218
        printf("OK\n");
784
219
 
785
220
        printf("testing set_streamable_subset()... ");
786
221
        if(!encoder->set_streamable_subset(true))
787
 
                return encoder->die("returned false");
788
 
        printf("OK\n");
789
 
 
790
 
        printf("testing set_do_mid_side_stereo()... ");
791
 
        if(!encoder->set_do_mid_side_stereo(false))
792
 
                return encoder->die("returned false");
793
 
        printf("OK\n");
794
 
 
795
 
        printf("testing set_loose_mid_side_stereo()... ");
796
 
        if(!encoder->set_loose_mid_side_stereo(false))
797
 
                return encoder->die("returned false");
 
222
                return die_s_("returned false", encoder);
798
223
        printf("OK\n");
799
224
 
800
225
        printf("testing set_channels()... ");
801
226
        if(!encoder->set_channels(streaminfo_.data.stream_info.channels))
802
 
                return encoder->die("returned false");
 
227
                return die_s_("returned false", encoder);
803
228
        printf("OK\n");
804
229
 
805
230
        printf("testing set_bits_per_sample()... ");
806
231
        if(!encoder->set_bits_per_sample(streaminfo_.data.stream_info.bits_per_sample))
807
 
                return encoder->die("returned false");
 
232
                return die_s_("returned false", encoder);
808
233
        printf("OK\n");
809
234
 
810
235
        printf("testing set_sample_rate()... ");
811
236
        if(!encoder->set_sample_rate(streaminfo_.data.stream_info.sample_rate))
812
 
                return encoder->die("returned false");
 
237
                return die_s_("returned false", encoder);
 
238
        printf("OK\n");
 
239
 
 
240
        printf("testing set_compression_level()... ");
 
241
        if(!encoder->set_compression_level((unsigned)(-1)))
 
242
                return die_s_("returned false", encoder);
813
243
        printf("OK\n");
814
244
 
815
245
        printf("testing set_blocksize()... ");
816
246
        if(!encoder->set_blocksize(streaminfo_.data.stream_info.min_blocksize))
817
 
                return encoder->die("returned false");
 
247
                return die_s_("returned false", encoder);
 
248
        printf("OK\n");
 
249
 
 
250
        printf("testing set_do_mid_side_stereo()... ");
 
251
        if(!encoder->set_do_mid_side_stereo(false))
 
252
                return die_s_("returned false", encoder);
 
253
        printf("OK\n");
 
254
 
 
255
        printf("testing set_loose_mid_side_stereo()... ");
 
256
        if(!encoder->set_loose_mid_side_stereo(false))
 
257
                return die_s_("returned false", encoder);
818
258
        printf("OK\n");
819
259
 
820
260
        printf("testing set_max_lpc_order()... ");
821
261
        if(!encoder->set_max_lpc_order(0))
822
 
                return encoder->die("returned false");
 
262
                return die_s_("returned false", encoder);
823
263
        printf("OK\n");
824
264
 
825
265
        printf("testing set_qlp_coeff_precision()... ");
826
266
        if(!encoder->set_qlp_coeff_precision(0))
827
 
                return encoder->die("returned false");
 
267
                return die_s_("returned false", encoder);
828
268
        printf("OK\n");
829
269
 
830
270
        printf("testing set_do_qlp_coeff_prec_search()... ");
831
271
        if(!encoder->set_do_qlp_coeff_prec_search(false))
832
 
                return encoder->die("returned false");
 
272
                return die_s_("returned false", encoder);
833
273
        printf("OK\n");
834
274
 
835
275
        printf("testing set_do_escape_coding()... ");
836
276
        if(!encoder->set_do_escape_coding(false))
837
 
                return encoder->die("returned false");
 
277
                return die_s_("returned false", encoder);
838
278
        printf("OK\n");
839
279
 
840
280
        printf("testing set_do_exhaustive_model_search()... ");
841
281
        if(!encoder->set_do_exhaustive_model_search(false))
842
 
                return encoder->die("returned false");
 
282
                return die_s_("returned false", encoder);
843
283
        printf("OK\n");
844
284
 
845
285
        printf("testing set_min_residual_partition_order()... ");
846
286
        if(!encoder->set_min_residual_partition_order(0))
847
 
                return encoder->die("returned false");
 
287
                return die_s_("returned false", encoder);
848
288
        printf("OK\n");
849
289
 
850
290
        printf("testing set_max_residual_partition_order()... ");
851
291
        if(!encoder->set_max_residual_partition_order(0))
852
 
                return encoder->die("returned false");
 
292
                return die_s_("returned false", encoder);
853
293
        printf("OK\n");
854
294
 
855
295
        printf("testing set_rice_parameter_search_dist()... ");
856
296
        if(!encoder->set_rice_parameter_search_dist(0))
857
 
                return encoder->die("returned false");
 
297
                return die_s_("returned false", encoder);
858
298
        printf("OK\n");
859
299
 
860
300
        printf("testing set_total_samples_estimate()... ");
861
301
        if(!encoder->set_total_samples_estimate(streaminfo_.data.stream_info.total_samples))
862
 
                return encoder->die("returned false");
 
302
                return die_s_("returned false", encoder);
863
303
        printf("OK\n");
864
304
 
865
305
        printf("testing set_metadata()... ");
866
306
        if(!encoder->set_metadata(metadata_sequence_, num_metadata_))
867
 
                return encoder->die("returned false");
868
 
        printf("OK\n");
869
 
 
870
 
        printf("testing set_filename()... ");
871
 
        if(!encoder->set_filename(flacfilename_))
872
 
                return encoder->die("returned false");
873
 
        printf("OK\n");
874
 
 
875
 
        printf("testing init()... ");
876
 
        if(encoder->init() != ::FLAC__FILE_ENCODER_OK)
877
 
                return encoder->die();
 
307
                return die_s_("returned false", encoder);
 
308
        printf("OK\n");
 
309
 
 
310
        if(layer < LAYER_FILENAME) {
 
311
                printf("opening file for FLAC output... ");
 
312
                file = ::fopen(flacfilename(is_ogg), "w+b");
 
313
                if(0 == file) {
 
314
                        printf("ERROR (%s)\n", strerror(errno));
 
315
                        return false;
 
316
                }
 
317
                printf("OK\n");
 
318
                if(layer < LAYER_FILE)
 
319
                        dynamic_cast<StreamEncoder*>(encoder)->file_ = file;
 
320
        }
 
321
 
 
322
        switch(layer) {
 
323
                case LAYER_STREAM:
 
324
                case LAYER_SEEKABLE_STREAM:
 
325
                        printf("testing init%s()... ", is_ogg? "_ogg":"");
 
326
                        init_status = is_ogg? encoder->init_ogg() : encoder->init();
 
327
                        break;
 
328
                case LAYER_FILE:
 
329
                        printf("testing init%s()... ", is_ogg? "_ogg":"");
 
330
                        init_status = is_ogg?
 
331
                                dynamic_cast<FLAC::Encoder::File*>(encoder)->init_ogg(file) :
 
332
                                dynamic_cast<FLAC::Encoder::File*>(encoder)->init(file);
 
333
                        break;
 
334
                case LAYER_FILENAME:
 
335
                        printf("testing init%s()... ", is_ogg? "_ogg":"");
 
336
                        init_status = is_ogg?
 
337
                                dynamic_cast<FLAC::Encoder::File*>(encoder)->init_ogg(flacfilename(is_ogg)) :
 
338
                                dynamic_cast<FLAC::Encoder::File*>(encoder)->init(flacfilename(is_ogg));
 
339
                        break;
 
340
                default:
 
341
                        die_("internal error 001");
 
342
                        return false;
 
343
        }
 
344
        if(init_status != ::FLAC__STREAM_ENCODER_INIT_STATUS_OK)
 
345
                return die_s_(0, encoder);
878
346
        printf("OK\n");
879
347
 
880
348
        printf("testing get_state()... ");
881
 
        FLAC::Encoder::File::State state = encoder->get_state();
882
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__FileEncoderState)state), state.as_cstring());
883
 
 
884
 
        printf("testing get_seekable_stream_encoder_state()... ");
885
 
        FLAC::Encoder::SeekableStream::State state_ = encoder->get_seekable_stream_encoder_state();
886
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__SeekableStreamEncoderState)state_), state_.as_cstring());
887
 
 
888
 
        printf("testing get_stream_encoder_state()... ");
889
 
        FLAC::Encoder::Stream::State state__ = encoder->get_stream_encoder_state();
890
 
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamEncoderState)state__), state__.as_cstring());
 
349
        FLAC::Encoder::Stream::State state = encoder->get_state();
 
350
        printf("returned state = %u (%s)... OK\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
891
351
 
892
352
        printf("testing get_verify_decoder_state()... ");
893
353
        FLAC::Decoder::Stream::State dstate = encoder->get_verify_decoder_state();
1018
478
 
1019
479
        printf("testing get_total_samples_estimate()... ");
1020
480
        if(encoder->get_total_samples_estimate() != streaminfo_.data.stream_info.total_samples) {
1021
 
                printf("FAILED, expected %llu, got %llu\n", streaminfo_.data.stream_info.total_samples, encoder->get_total_samples_estimate());
 
481
#ifdef _MSC_VER
 
482
                printf("FAILED, expected %I64u, got %I64u\n", streaminfo_.data.stream_info.total_samples, encoder->get_total_samples_estimate());
 
483
#else
 
484
                printf("FAILED, expected %llu, got %llu\n", (unsigned long long)streaminfo_.data.stream_info.total_samples, (unsigned long long)encoder->get_total_samples_estimate());
 
485
#endif
1022
486
                return false;
1023
487
        }
1024
488
        printf("OK\n");
1029
493
 
1030
494
        printf("testing process()... ");
1031
495
        if(!encoder->process(samples_array, sizeof(samples) / sizeof(FLAC__int32)))
1032
 
                return encoder->die("returned false");
 
496
                return die_s_("returned false", encoder);
1033
497
        printf("OK\n");
1034
498
 
1035
499
        printf("testing process_interleaved()... ");
1036
500
        if(!encoder->process_interleaved(samples, sizeof(samples) / sizeof(FLAC__int32)))
1037
 
                return encoder->die("returned false");
 
501
                return die_s_("returned false", encoder);
1038
502
        printf("OK\n");
1039
503
 
1040
504
        printf("testing finish()... ");
1041
 
        encoder->finish();
 
505
        if(!encoder->finish()) {
 
506
                FLAC::Encoder::Stream::State state = encoder->get_state();
 
507
                printf("FAILED, returned false, state = %u (%s)\n", (unsigned)((::FLAC__StreamEncoderState)state), state.as_cstring());
 
508
                return false;
 
509
        }
1042
510
        printf("OK\n");
1043
511
 
 
512
        if(layer < LAYER_FILE)
 
513
                ::fclose(dynamic_cast<StreamEncoder*>(encoder)->file_);
 
514
 
1044
515
        printf("freeing encoder instance... ");
1045
516
        delete encoder;
1046
517
        printf("OK\n");
1052
523
 
1053
524
bool test_encoders()
1054
525
{
1055
 
        init_metadata_blocks_();
1056
 
 
1057
 
        if(!test_stream_encoder())
1058
 
                return false;
1059
 
 
1060
 
        if(!test_seekable_stream_encoder())
1061
 
                return false;
1062
 
 
1063
 
        if(!test_file_encoder())
1064
 
                return false;
1065
 
 
1066
 
        free_metadata_blocks_();
 
526
        FLAC__bool is_ogg = false;
 
527
 
 
528
        while(1) {
 
529
                init_metadata_blocks_();
 
530
 
 
531
                if(!test_stream_encoder(LAYER_STREAM, is_ogg))
 
532
                        return false;
 
533
 
 
534
                if(!test_stream_encoder(LAYER_SEEKABLE_STREAM, is_ogg))
 
535
                        return false;
 
536
 
 
537
                if(!test_stream_encoder(LAYER_FILE, is_ogg))
 
538
                        return false;
 
539
 
 
540
                if(!test_stream_encoder(LAYER_FILENAME, is_ogg))
 
541
                        return false;
 
542
 
 
543
                (void) grabbag__file_remove_file(flacfilename(is_ogg));
 
544
 
 
545
                free_metadata_blocks_();
 
546
 
 
547
                if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
 
548
                        break;
 
549
                is_ogg = true;
 
550
        }
1067
551
 
1068
552
        return true;
1069
553
}