← Back to branch summary

~ubuntu-branches/ubuntu/trusty/flac/trusty-updates

« back to all changes in this revision

Viewing changes to src/test_libFLAC/decoders.c

  • Committer: Bazaar Package Importer
  • Author(s): Marc 'HE' Brockschmidt
  • Date: 2008-03-16 18:02:56 UTC
  • mfrom: (1.1.5 upstream) (8.1.2 gutsy)
  • Revision ID: james.westby@ubuntu.com-20080316180256-qhf3wk704rp165pm
Tags: 1.2.1-1.2
http://bugs.debian.org/455304
* Non-maintainer upload.
* Fix gcc-4.3 FTBFS, patch by KiBi (Closes: #455304)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test_libFLAC/decoders.c
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
16
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17
17
 */
18
18
 
 
19
#if HAVE_CONFIG_H
 
20
#  include <config.h>
 
21
#endif
 
22
 
 
23
#include <errno.h>
 
24
#include <stdio.h>
 
25
#include <stdlib.h>
 
26
#include <string.h>
 
27
#if defined _MSC_VER || defined __MINGW32__
 
28
#if _MSC_VER <= 1600 /* @@@ [2G limit] */
 
29
#define fseeko fseek
 
30
#define ftello ftell
 
31
#endif
 
32
#endif
19
33
#include "decoders.h"
20
 
#include "file_utils.h"
21
 
#include "metadata_utils.h"
22
34
#include "FLAC/assert.h"
23
 
#include "FLAC/file_decoder.h"
24
 
#include "FLAC/seekable_stream_decoder.h"
25
35
#include "FLAC/stream_decoder.h"
26
36
#include "share/grabbag.h"
27
 
#include <errno.h>
28
 
#include <stdio.h>
29
 
#include <stdlib.h>
30
 
#include <string.h>
 
37
#include "test_libs_common/file_utils_flac.h"
 
38
#include "test_libs_common/metadata_utils.h"
 
39
 
 
40
typedef enum {
 
41
        LAYER_STREAM = 0, /* FLAC__stream_decoder_init_[ogg_]stream() without seeking */
 
42
        LAYER_SEEKABLE_STREAM, /* FLAC__stream_decoder_init_[ogg_]stream() with seeking */
 
43
        LAYER_FILE, /* FLAC__stream_decoder_init_[ogg_]FILE() */
 
44
        LAYER_FILENAME /* FLAC__stream_decoder_init_[ogg_]file() */
 
45
} Layer;
 
46
 
 
47
static const char * const LayerString[] = {
 
48
        "Stream",
 
49
        "Seekable Stream",
 
50
        "FILE*",
 
51
        "Filename"
 
52
};
31
53
 
32
54
typedef struct {
 
55
        Layer layer;
33
56
        FILE *file;
34
57
        unsigned current_metadata_number;
35
58
        FLAC__bool ignore_errors;
36
59
        FLAC__bool error_occurred;
37
 
} stream_decoder_client_data_struct;
38
 
 
39
 
typedef stream_decoder_client_data_struct seekable_stream_decoder_client_data_struct;
40
 
typedef stream_decoder_client_data_struct file_decoder_client_data_struct;
41
 
 
42
 
static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, unknown_;
43
 
static FLAC__StreamMetadata *expected_metadata_sequence_[8];
 
60
} StreamDecoderClientData;
 
61
 
 
62
static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, picture_, unknown_;
 
63
static FLAC__StreamMetadata *expected_metadata_sequence_[9];
44
64
static unsigned num_expected_;
45
 
static const char *flacfilename_ = "metadata.flac";
46
 
static unsigned flacfilesize_;
 
65
static off_t flacfilesize_;
 
66
 
 
67
static const char *flacfilename(FLAC__bool is_ogg)
 
68
{
 
69
        return is_ogg? "metadata.oga" : "metadata.flac";
 
70
}
47
71
 
48
72
static FLAC__bool die_(const char *msg)
49
73
{
65
89
        return false;
66
90
}
67
91
 
68
 
static FLAC__bool die_ss_(const char *msg, const FLAC__SeekableStreamDecoder *decoder)
69
 
{
70
 
        FLAC__SeekableStreamDecoderState state = FLAC__seekable_stream_decoder_get_state(decoder);
71
 
 
72
 
        if(msg)
73
 
                printf("FAILED, %s", msg);
74
 
        else
75
 
                printf("FAILED");
76
 
 
77
 
        printf(", state = %u (%s)\n", (unsigned)state, FLAC__SeekableStreamDecoderStateString[state]);
78
 
        if(state == FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
79
 
                FLAC__StreamDecoderState state_ = FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder);
80
 
                printf("      stream decoder state = %u (%s)\n", (unsigned)state_, FLAC__StreamDecoderStateString[state_]);
81
 
        }
82
 
 
83
 
        return false;
84
 
}
85
 
 
86
 
static FLAC__bool die_f_(const char *msg, const FLAC__FileDecoder *decoder)
87
 
{
88
 
        FLAC__FileDecoderState state = FLAC__file_decoder_get_state(decoder);
89
 
 
90
 
        if(msg)
91
 
                printf("FAILED, %s", msg);
92
 
        else
93
 
                printf("FAILED");
94
 
 
95
 
        printf(", state = %u (%s)\n", (unsigned)state, FLAC__FileDecoderStateString[state]);
96
 
        if(state == FLAC__FILE_DECODER_SEEKABLE_STREAM_DECODER_ERROR) {
97
 
                FLAC__SeekableStreamDecoderState state_ = FLAC__file_decoder_get_seekable_stream_decoder_state(decoder);
98
 
                printf("      seekable stream decoder state = %u (%s)\n", (unsigned)state, FLAC__SeekableStreamDecoderStateString[state_]);
99
 
                if(state_ == FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR) {
100
 
                        FLAC__StreamDecoderState state__ = FLAC__file_decoder_get_stream_decoder_state(decoder);
101
 
                        printf("      stream decoder state = %u (%s)\n", (unsigned)state__, FLAC__StreamDecoderStateString[state__]);
102
 
                }
103
 
        }
104
 
 
105
 
        return false;
106
 
}
107
 
 
108
 
static void init_metadata_blocks_()
109
 
{
110
 
        mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
111
 
}
112
 
 
113
 
static void free_metadata_blocks_()
114
 
{
115
 
        mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &unknown_);
116
 
}
117
 
 
118
 
static FLAC__bool generate_file_()
119
 
{
120
 
        printf("\n\ngenerating FLAC file for decoder tests...\n");
 
92
static void init_metadata_blocks_(void)
 
93
{
 
94
        mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
 
95
}
 
96
 
 
97
static void free_metadata_blocks_(void)
 
98
{
 
99
        mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
 
100
}
 
101
 
 
102
static FLAC__bool generate_file_(FLAC__bool is_ogg)
 
103
{
 
104
        printf("\n\ngenerating %sFLAC file for decoder tests...\n", is_ogg? "Ogg ":"");
121
105
 
122
106
        num_expected_ = 0;
123
107
        expected_metadata_sequence_[num_expected_++] = &padding_;
126
110
        expected_metadata_sequence_[num_expected_++] = &application2_;
127
111
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
128
112
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
113
        expected_metadata_sequence_[num_expected_++] = &picture_;
129
114
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
115
        /* WATCHOUT: for Ogg FLAC the encoder should move the VORBIS_COMMENT block to the front, right after STREAMINFO */
130
116
 
131
 
        if(!file_utils__generate_flacfile(flacfilename_, &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
 
117
        if(!file_utils__generate_flacfile(is_ogg, flacfilename(is_ogg), &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
132
118
                return die_("creating the encoded file");
133
119
 
134
120
        return true;
135
121
}
136
122
 
137
 
static FLAC__StreamDecoderReadStatus stream_decoder_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 
123
static FLAC__StreamDecoderReadStatus stream_decoder_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
138
124
{
139
 
        stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
140
 
        const unsigned requested_bytes = *bytes;
 
125
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 
126
        const size_t requested_bytes = *bytes;
141
127
 
142
128
        (void)decoder;
143
129
 
169
155
                return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
170
156
}
171
157
 
 
158
static FLAC__StreamDecoderSeekStatus stream_decoder_seek_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 
159
{
 
160
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 
161
 
 
162
        (void)decoder;
 
163
 
 
164
        if(0 == dcd) {
 
165
                printf("ERROR: client_data in seek callback is NULL\n");
 
166
                return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 
167
        }
 
168
 
 
169
        if(dcd->error_occurred)
 
170
                return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 
171
 
 
172
        if(fseeko(dcd->file, (off_t)absolute_byte_offset, SEEK_SET) < 0) {
 
173
                dcd->error_occurred = true;
 
174
                return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
 
175
        }
 
176
 
 
177
        return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
 
178
}
 
179
 
 
180
static FLAC__StreamDecoderTellStatus stream_decoder_tell_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 
181
{
 
182
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 
183
        off_t offset;
 
184
 
 
185
        (void)decoder;
 
186
 
 
187
        if(0 == dcd) {
 
188
                printf("ERROR: client_data in tell callback is NULL\n");
 
189
                return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 
190
        }
 
191
 
 
192
        if(dcd->error_occurred)
 
193
                return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 
194
 
 
195
        offset = ftello(dcd->file);
 
196
        *absolute_byte_offset = (FLAC__uint64)offset;
 
197
 
 
198
        if(offset < 0) {
 
199
                dcd->error_occurred = true;
 
200
                return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
 
201
        }
 
202
 
 
203
        return FLAC__STREAM_DECODER_TELL_STATUS_OK;
 
204
}
 
205
 
 
206
static FLAC__StreamDecoderLengthStatus stream_decoder_length_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 
207
{
 
208
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 
209
 
 
210
        (void)decoder;
 
211
 
 
212
        if(0 == dcd) {
 
213
                printf("ERROR: client_data in length callback is NULL\n");
 
214
                return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 
215
        }
 
216
 
 
217
        if(dcd->error_occurred)
 
218
                return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
 
219
 
 
220
        *stream_length = (FLAC__uint64)flacfilesize_;
 
221
        return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
 
222
}
 
223
 
 
224
static FLAC__bool stream_decoder_eof_callback_(const FLAC__StreamDecoder *decoder, void *client_data)
 
225
{
 
226
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
 
227
 
 
228
        (void)decoder;
 
229
 
 
230
        if(0 == dcd) {
 
231
                printf("ERROR: client_data in eof callback is NULL\n");
 
232
                return true;
 
233
        }
 
234
 
 
235
        if(dcd->error_occurred)
 
236
                return true;
 
237
 
 
238
        return feof(dcd->file);
 
239
}
 
240
 
172
241
static FLAC__StreamDecoderWriteStatus stream_decoder_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
173
242
{
174
 
        stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 
243
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
175
244
 
176
245
        (void)decoder, (void)buffer;
177
246
 
196
265
 
197
266
static void stream_decoder_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
198
267
{
199
 
        stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 
268
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
200
269
 
201
270
        (void)decoder;
202
271
 
226
295
 
227
296
static void stream_decoder_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
228
297
{
229
 
        stream_decoder_client_data_struct *dcd = (stream_decoder_client_data_struct*)client_data;
 
298
        StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
230
299
 
231
300
        (void)decoder;
232
301
 
241
310
        }
242
311
}
243
312
 
244
 
static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, stream_decoder_client_data_struct *dcd)
 
313
static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, StreamDecoderClientData *dcd, FLAC__bool is_ogg)
245
314
{
246
 
        if(!FLAC__stream_decoder_set_read_callback(decoder, stream_decoder_read_callback_))
247
 
                return die_s_("at FLAC__stream_decoder_set_read_callback(), returned false", decoder);
248
 
 
249
 
        if(!FLAC__stream_decoder_set_write_callback(decoder, stream_decoder_write_callback_))
250
 
                return die_s_("at FLAC__stream_decoder_set_write_callback(), returned false", decoder);
251
 
 
252
 
        if(!FLAC__stream_decoder_set_metadata_callback(decoder, stream_decoder_metadata_callback_))
253
 
                return die_s_("at FLAC__stream_decoder_set_metadata_callback(), returned false", decoder);
254
 
 
255
 
        if(!FLAC__stream_decoder_set_error_callback(decoder, stream_decoder_error_callback_))
256
 
                return die_s_("at FLAC__stream_decoder_set_error_callback(), returned false", decoder);
257
 
 
258
 
        if(!FLAC__stream_decoder_set_client_data(decoder, dcd))
259
 
                return die_s_("at FLAC__stream_decoder_set_client_data(), returned false", decoder);
260
 
 
261
 
        printf("testing FLAC__stream_decoder_init()... ");
262
 
        if(FLAC__stream_decoder_init(decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 
315
        FLAC__StreamDecoderInitStatus init_status;
 
316
 
 
317
        if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
 
318
                return die_s_("at FLAC__stream_decoder_set_md5_checking(), returned false", decoder);
 
319
 
 
320
        /* for FLAC__stream_encoder_init_FILE(), the FLAC__stream_encoder_finish() closes the file so we have to keep re-opening: */
 
321
        if(dcd->layer == LAYER_FILE) {
 
322
                printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
 
323
                dcd->file = fopen(flacfilename(is_ogg), "rb");
 
324
                if(0 == dcd->file) {
 
325
                        printf("ERROR (%s)\n", strerror(errno));
 
326
                        return false;
 
327
                }
 
328
                printf("OK\n");
 
329
        }
 
330
 
 
331
        switch(dcd->layer) {
 
332
                case LAYER_STREAM:
 
333
                        printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 
334
                        init_status = is_ogg?
 
335
                                FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 
336
                                FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd)
 
337
                        ;
 
338
                        break;
 
339
                case LAYER_SEEKABLE_STREAM:
 
340
                        printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 
341
                        init_status = is_ogg?
 
342
                                FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 
343
                                FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 
344
                        break;
 
345
                case LAYER_FILE:
 
346
                        printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 
347
                        init_status = is_ogg?
 
348
                                FLAC__stream_decoder_init_ogg_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 
349
                                FLAC__stream_decoder_init_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 
350
                        break;
 
351
                case LAYER_FILENAME:
 
352
                        printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 
353
                        init_status = is_ogg?
 
354
                                FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
 
355
                                FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
 
356
                        break;
 
357
                default:
 
358
                        die_("internal error 000");
 
359
                        return false;
 
360
        }
 
361
        if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
263
362
                return die_s_(0, decoder);
264
363
        printf("OK\n");
265
364
 
266
365
        dcd->current_metadata_number = 0;
267
366
 
268
 
        if(fseek(dcd->file, 0, SEEK_SET) < 0) {
 
367
        if(dcd->layer < LAYER_FILE && fseeko(dcd->file, 0, SEEK_SET) < 0) {
269
368
                printf("FAILED rewinding input, errno = %d\n", errno);
270
369
                return false;
271
370
        }
276
375
        printf("OK\n");
277
376
 
278
377
        printf("testing FLAC__stream_decoder_finish()... ");
279
 
        FLAC__stream_decoder_finish(decoder);
 
378
        if(!FLAC__stream_decoder_finish(decoder))
 
379
                return die_s_("returned false", decoder);
280
380
        printf("OK\n");
281
381
 
282
382
        return true;
283
383
}
284
384
 
285
 
static FLAC__bool test_stream_decoder()
 
385
static FLAC__bool test_stream_decoder(Layer layer, FLAC__bool is_ogg)
286
386
{
287
387
        FLAC__StreamDecoder *decoder;
 
388
        FLAC__StreamDecoderInitStatus init_status;
288
389
        FLAC__StreamDecoderState state;
289
 
        stream_decoder_client_data_struct decoder_client_data;
290
 
 
291
 
        printf("\n+++ libFLAC unit test: FLAC__StreamDecoder\n\n");
 
390
        StreamDecoderClientData decoder_client_data;
 
391
        FLAC__bool expect;
 
392
 
 
393
        decoder_client_data.layer = layer;
 
394
 
 
395
        printf("\n+++ libFLAC unit test: FLAC__StreamDecoder (layer: %s, format: %s)\n\n", LayerString[layer], is_ogg? "Ogg FLAC" : "FLAC");
292
396
 
293
397
        printf("testing FLAC__stream_decoder_new()... ");
294
398
        decoder = FLAC__stream_decoder_new();
310
414
        }
311
415
        printf("OK\n");
312
416
 
313
 
        printf("testing FLAC__stream_decoder_init()... ");
314
 
        if(FLAC__stream_decoder_init(decoder) == FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 
417
        switch(layer) {
 
418
                case LAYER_STREAM:
 
419
                case LAYER_SEEKABLE_STREAM:
 
420
                        printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 
421
                        init_status = is_ogg?
 
422
                                FLAC__stream_decoder_init_ogg_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0) :
 
423
                                FLAC__stream_decoder_init_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 
424
                        break;
 
425
                case LAYER_FILE:
 
426
                        printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 
427
                        init_status = is_ogg?
 
428
                                FLAC__stream_decoder_init_ogg_FILE(decoder, stdin, 0, 0, 0, 0) :
 
429
                                FLAC__stream_decoder_init_FILE(decoder, stdin, 0, 0, 0, 0);
 
430
                        break;
 
431
                case LAYER_FILENAME:
 
432
                        printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 
433
                        init_status = is_ogg?
 
434
                                FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0) :
 
435
                                FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0);
 
436
                        break;
 
437
                default:
 
438
                        die_("internal error 003");
 
439
                        return false;
 
440
        }
 
441
        if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS)
315
442
                return die_s_(0, decoder);
316
443
        printf("OK\n");
317
444
 
330
457
        }
331
458
        printf("OK\n");
332
459
 
333
 
        printf("testing FLAC__stream_decoder_set_read_callback()... ");
334
 
        if(!FLAC__stream_decoder_set_read_callback(decoder, stream_decoder_read_callback_))
335
 
                return die_s_("returned false", decoder);
336
 
        printf("OK\n");
337
 
 
338
 
        printf("testing FLAC__stream_decoder_set_write_callback()... ");
339
 
        if(!FLAC__stream_decoder_set_write_callback(decoder, stream_decoder_write_callback_))
340
 
                return die_s_("returned false", decoder);
341
 
        printf("OK\n");
342
 
 
343
 
        printf("testing FLAC__stream_decoder_set_metadata_callback()... ");
344
 
        if(!FLAC__stream_decoder_set_metadata_callback(decoder, stream_decoder_metadata_callback_))
345
 
                return die_s_("returned false", decoder);
346
 
        printf("OK\n");
347
 
 
348
 
        printf("testing FLAC__stream_decoder_set_error_callback()... ");
349
 
        if(!FLAC__stream_decoder_set_error_callback(decoder, stream_decoder_error_callback_))
350
 
                return die_s_("returned false", decoder);
351
 
        printf("OK\n");
352
 
 
353
 
        printf("testing FLAC__stream_decoder_set_client_data()... ");
354
 
        if(!FLAC__stream_decoder_set_client_data(decoder, &decoder_client_data))
355
 
                return die_s_("returned false", decoder);
356
 
        printf("OK\n");
357
 
 
358
 
        printf("testing FLAC__stream_decoder_init()... ");
359
 
        if(FLAC__stream_decoder_init(decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
 
460
        if(is_ogg) {
 
461
                printf("testing FLAC__stream_decoder_set_ogg_serial_number()... ");
 
462
                if(!FLAC__stream_decoder_set_ogg_serial_number(decoder, file_utils__ogg_serial_number))
 
463
                        return die_s_("returned false", decoder);
 
464
                printf("OK\n");
 
465
        }
 
466
 
 
467
        printf("testing FLAC__stream_decoder_set_md5_checking()... ");
 
468
        if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
 
469
                return die_s_("returned false", decoder);
 
470
        printf("OK\n");
 
471
 
 
472
        if(layer < LAYER_FILENAME) {
 
473
                printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
 
474
                decoder_client_data.file = fopen(flacfilename(is_ogg), "rb");
 
475
                if(0 == decoder_client_data.file) {
 
476
                        printf("ERROR (%s)\n", strerror(errno));
 
477
                        return false;
 
478
                }
 
479
                printf("OK\n");
 
480
        }
 
481
 
 
482
        switch(layer) {
 
483
                case LAYER_STREAM:
 
484
                        printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 
485
                        init_status = is_ogg?
 
486
                                FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 
487
                                FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 
488
                        break;
 
489
                case LAYER_SEEKABLE_STREAM:
 
490
                        printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
 
491
                        init_status = is_ogg?
 
492
                                FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 
493
                                FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 
494
                        break;
 
495
                case LAYER_FILE:
 
496
                        printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
 
497
                        init_status = is_ogg?
 
498
                                FLAC__stream_decoder_init_ogg_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 
499
                                FLAC__stream_decoder_init_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 
500
                        break;
 
501
                case LAYER_FILENAME:
 
502
                        printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
 
503
                        init_status = is_ogg?
 
504
                                FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
 
505
                                FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
 
506
                        break;
 
507
                default:
 
508
                        die_("internal error 009");
 
509
                        return false;
 
510
        }
 
511
        if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
360
512
                return die_s_(0, decoder);
361
513
        printf("OK\n");
362
514
 
368
520
        decoder_client_data.ignore_errors = false;
369
521
        decoder_client_data.error_occurred = false;
370
522
 
371
 
        printf("opening FLAC file... ");
372
 
        decoder_client_data.file = fopen(flacfilename_, "rb");
373
 
        if(0 == decoder_client_data.file) {
374
 
                printf("ERROR\n");
 
523
        printf("testing FLAC__stream_decoder_get_md5_checking()... ");
 
524
        if(!FLAC__stream_decoder_get_md5_checking(decoder)) {
 
525
                printf("FAILED, returned false, expected true\n");
375
526
                return false;
376
527
        }
377
528
        printf("OK\n");
391
542
                return die_s_("returned false", decoder);
392
543
        printf("OK\n");
393
544
 
394
 
        printf("testing FLAC__stream_decoder_flush()... ");
395
 
        if(!FLAC__stream_decoder_flush(decoder))
396
 
                return die_s_("returned false", decoder);
397
 
        printf("OK\n");
398
 
 
399
 
        decoder_client_data.ignore_errors = true;
400
 
        printf("testing FLAC__stream_decoder_process_single()... ");
401
 
        if(!FLAC__stream_decoder_process_single(decoder))
402
 
                return die_s_("returned false", decoder);
403
 
        printf("OK\n");
404
 
        decoder_client_data.ignore_errors = false;
 
545
        if(layer < LAYER_FILE) {
 
546
                printf("testing FLAC__stream_decoder_flush()... ");
 
547
                if(!FLAC__stream_decoder_flush(decoder))
 
548
                        return die_s_("returned false", decoder);
 
549
                printf("OK\n");
 
550
 
 
551
                decoder_client_data.ignore_errors = true;
 
552
                printf("testing FLAC__stream_decoder_process_single()... ");
 
553
                if(!FLAC__stream_decoder_process_single(decoder))
 
554
                        return die_s_("returned false", decoder);
 
555
                printf("OK\n");
 
556
                decoder_client_data.ignore_errors = false;
 
557
        }
 
558
 
 
559
        expect = (layer != LAYER_STREAM);
 
560
        printf("testing FLAC__stream_decoder_seek_absolute()... ");
 
561
        if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
 
562
                return die_s_(expect? "returned false" : "returned true", decoder);
 
563
        printf("OK\n");
405
564
 
406
565
        printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
407
566
        if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
408
567
                return die_s_("returned false", decoder);
409
568
        printf("OK\n");
410
569
 
 
570
        expect = (layer != LAYER_STREAM);
 
571
        printf("testing FLAC__stream_decoder_seek_absolute()... ");
 
572
        if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
 
573
                return die_s_(expect? "returned false" : "returned true", decoder);
 
574
        printf("OK\n");
 
575
 
411
576
        printf("testing FLAC__stream_decoder_get_channels()... ");
412
577
        {
413
578
                unsigned channels = FLAC__stream_decoder_get_channels(decoder);
441
606
        printf("testing FLAC__stream_decoder_get_blocksize()... ");
442
607
        {
443
608
                unsigned blocksize = FLAC__stream_decoder_get_blocksize(decoder);
444
 
                /* value could be anything since we're at the last block, so accept any answer */
445
 
                printf("returned %u... OK\n", blocksize);
 
609
                /* value could be anything since we're at the last block, so accept any reasonable answer */
 
610
                printf("returned %u... %s\n", blocksize, blocksize>0? "OK" : "FAILED");
 
611
                if(blocksize == 0)
 
612
                        return false;
446
613
        }
447
614
 
448
615
        printf("testing FLAC__stream_decoder_get_channel_assignment()... ");
451
618
                printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
452
619
        }
453
620
 
454
 
        printf("testing FLAC__stream_decoder_reset()... ");
455
 
        if(!FLAC__stream_decoder_reset(decoder)) {
456
 
                state = FLAC__stream_decoder_get_state(decoder);
457
 
                printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]);
458
 
                return false;
459
 
        }
460
 
        printf("OK\n");
461
 
 
462
 
        decoder_client_data.current_metadata_number = 0;
463
 
 
464
 
        printf("rewinding input... ");
465
 
        if(fseek(decoder_client_data.file, 0, SEEK_SET) < 0) {
466
 
                printf("FAILED, errno = %d\n", errno);
467
 
                return false;
468
 
        }
469
 
        printf("OK\n");
470
 
 
471
 
        printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
472
 
        if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
473
 
                return die_s_("returned false", decoder);
474
 
        printf("OK\n");
 
621
        if(layer < LAYER_FILE) {
 
622
                printf("testing FLAC__stream_decoder_reset()... ");
 
623
                if(!FLAC__stream_decoder_reset(decoder)) {
 
624
                        state = FLAC__stream_decoder_get_state(decoder);
 
625
                        printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]);
 
626
                        return false;
 
627
                }
 
628
                printf("OK\n");
 
629
 
 
630
                if(layer == LAYER_STREAM) {
 
631
                        /* after a reset() we have to rewind the input ourselves */
 
632
                        printf("rewinding input... ");
 
633
                        if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) {
 
634
                                printf("FAILED, errno = %d\n", errno);
 
635
                                return false;
 
636
                        }
 
637
                        printf("OK\n");
 
638
                }
 
639
 
 
640
                decoder_client_data.current_metadata_number = 0;
 
641
 
 
642
                printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
 
643
                if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
 
644
                        return die_s_("returned false", decoder);
 
645
                printf("OK\n");
 
646
        }
475
647
 
476
648
        printf("testing FLAC__stream_decoder_finish()... ");
477
 
        FLAC__stream_decoder_finish(decoder);
 
649
        if(!FLAC__stream_decoder_finish(decoder))
 
650
                return die_s_("returned false", decoder);
478
651
        printf("OK\n");
479
652
 
480
653
        /*
487
660
        printf("OK\n");
488
661
 
489
662
        num_expected_ = 0;
490
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
491
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
492
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
493
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
494
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
495
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
496
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
497
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
663
        if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 
664
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
665
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
666
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
667
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
668
                expected_metadata_sequence_[num_expected_++] = &application1_;
 
669
                expected_metadata_sequence_[num_expected_++] = &application2_;
 
670
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
671
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
672
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
673
        }
 
674
        else {
 
675
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
676
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
677
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
678
                expected_metadata_sequence_[num_expected_++] = &application1_;
 
679
                expected_metadata_sequence_[num_expected_++] = &application2_;
 
680
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
681
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
682
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
683
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
684
        }
498
685
 
499
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
686
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
500
687
                return false;
501
688
 
502
689
        /*
510
697
 
511
698
        num_expected_ = 0;
512
699
 
513
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
700
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
514
701
                return false;
515
702
 
516
703
        /*
534
721
        expected_metadata_sequence_[num_expected_++] = &application1_;
535
722
        expected_metadata_sequence_[num_expected_++] = &application2_;
536
723
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
724
        expected_metadata_sequence_[num_expected_++] = &picture_;
537
725
        expected_metadata_sequence_[num_expected_++] = &unknown_;
538
726
 
539
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
727
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
540
728
                return false;
541
729
 
542
730
        /*
554
742
        printf("OK\n");
555
743
 
556
744
        num_expected_ = 0;
557
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
558
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
559
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
560
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
561
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
562
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
745
        if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 
746
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
747
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
748
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
749
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
750
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
751
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
752
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
753
        }
 
754
        else {
 
755
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
756
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
757
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
758
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
759
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
760
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
761
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
762
        }
563
763
 
564
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
764
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
565
765
                return false;
566
766
 
567
767
        /*
579
779
        printf("OK\n");
580
780
 
581
781
        num_expected_ = 0;
582
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
583
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
584
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
585
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
586
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
587
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
588
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
782
        if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 
783
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
784
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
785
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
786
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
787
                expected_metadata_sequence_[num_expected_++] = &application2_;
 
788
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
789
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
790
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
791
        }
 
792
        else {
 
793
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
794
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
795
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
796
                expected_metadata_sequence_[num_expected_++] = &application2_;
 
797
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
798
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
799
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
800
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
801
        }
589
802
 
590
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
803
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
591
804
                return false;
592
805
 
593
806
        /*
610
823
        printf("OK\n");
611
824
 
612
825
        num_expected_ = 0;
613
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
614
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
615
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
616
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
617
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
618
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
826
        if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 
827
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
828
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
829
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
830
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
831
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
832
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
833
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
834
        }
 
835
        else {
 
836
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
837
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
838
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
839
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
840
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
841
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
842
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
843
        }
619
844
 
620
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
845
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
621
846
                return false;
622
847
 
623
848
        /*
637
862
        num_expected_ = 0;
638
863
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
639
864
 
640
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
865
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
641
866
                return false;
642
867
 
643
868
        /*
658
883
        expected_metadata_sequence_[num_expected_++] = &application1_;
659
884
        expected_metadata_sequence_[num_expected_++] = &application2_;
660
885
 
661
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
886
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
662
887
                return false;
663
888
 
664
889
        /*
678
903
        num_expected_ = 0;
679
904
        expected_metadata_sequence_[num_expected_++] = &application1_;
680
905
 
681
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
906
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
682
907
                return false;
683
908
 
684
909
        /*
704
929
        expected_metadata_sequence_[num_expected_++] = &application1_;
705
930
        expected_metadata_sequence_[num_expected_++] = &application2_;
706
931
 
707
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
932
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
708
933
                return false;
709
934
 
710
935
        /*
727
952
        printf("OK\n");
728
953
 
729
954
        num_expected_ = 0;
730
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
731
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
732
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
733
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
734
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
735
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
736
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
955
        if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
 
956
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
957
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
958
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
959
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
960
                expected_metadata_sequence_[num_expected_++] = &application1_;
 
961
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
962
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
963
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
964
        }
 
965
        else {
 
966
                expected_metadata_sequence_[num_expected_++] = &streaminfo_;
 
967
                expected_metadata_sequence_[num_expected_++] = &padding_;
 
968
                expected_metadata_sequence_[num_expected_++] = &seektable_;
 
969
                expected_metadata_sequence_[num_expected_++] = &application1_;
 
970
                expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
 
971
                expected_metadata_sequence_[num_expected_++] = &cuesheet_;
 
972
                expected_metadata_sequence_[num_expected_++] = &picture_;
 
973
                expected_metadata_sequence_[num_expected_++] = &unknown_;
 
974
        }
737
975
 
738
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
976
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
739
977
                return false;
740
978
 
741
979
        /*
760
998
        num_expected_ = 0;
761
999
        expected_metadata_sequence_[num_expected_++] = &application2_;
762
1000
 
763
 
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data))
 
1001
        if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
764
1002
                return false;
765
1003
 
766
 
        /* done, now leave the sequence the way we found it... */
767
 
        num_expected_ = 0;
768
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
769
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
770
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
771
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
772
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
773
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
774
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
775
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
 
1004
        if(layer < LAYER_FILE) /* for LAYER_FILE, FLAC__stream_decoder_finish() closes the file */
 
1005
                fclose(decoder_client_data.file);
776
1006
 
777
1007
        printf("testing FLAC__stream_decoder_delete()... ");
778
1008
        FLAC__stream_decoder_delete(decoder);
779
1009
        printf("OK\n");
780
1010
 
781
 
        fclose(decoder_client_data.file);
782
 
 
783
 
        printf("\nPASSED!\n");
784
 
 
785
 
        return true;
786
 
}
787
 
 
788
 
static FLAC__SeekableStreamDecoderReadStatus seekable_stream_decoder_read_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
789
 
{
790
 
        (void)decoder;
791
 
        switch(stream_decoder_read_callback_(0, buffer, bytes, client_data)) {
792
 
                case FLAC__STREAM_DECODER_READ_STATUS_CONTINUE:
793
 
                        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
794
 
                case FLAC__STREAM_DECODER_READ_STATUS_ABORT:
795
 
                case FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM:
796
 
                        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
797
 
                default:
798
 
                        FLAC__ASSERT(0);
799
 
                        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
800
 
        }
801
 
}
802
 
 
803
 
static FLAC__SeekableStreamDecoderSeekStatus seekable_stream_decoder_seek_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
804
 
{
805
 
        seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
806
 
 
807
 
        (void)decoder;
808
 
 
809
 
        if(0 == dcd) {
810
 
                printf("ERROR: client_data in seek callback is NULL\n");
811
 
                return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
812
 
        }
813
 
 
814
 
        if(dcd->error_occurred)
815
 
                return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
816
 
 
817
 
        if(fseek(dcd->file, (long)absolute_byte_offset, SEEK_SET) < 0) {
818
 
                dcd->error_occurred = true;
819
 
                return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
820
 
        }
821
 
 
822
 
        return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
823
 
}
824
 
 
825
 
static FLAC__SeekableStreamDecoderTellStatus seekable_stream_decoder_tell_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
826
 
{
827
 
        seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
828
 
        long offset;
829
 
 
830
 
        (void)decoder;
831
 
 
832
 
        if(0 == dcd) {
833
 
                printf("ERROR: client_data in tell callback is NULL\n");
834
 
                return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
835
 
        }
836
 
 
837
 
        if(dcd->error_occurred)
838
 
                return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
839
 
 
840
 
        offset = ftell(dcd->file);
841
 
        *absolute_byte_offset = (FLAC__uint64)offset;
842
 
 
843
 
        if(offset < 0) {
844
 
                dcd->error_occurred = true;
845
 
                return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
846
 
        }
847
 
 
848
 
        return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
849
 
}
850
 
 
851
 
static FLAC__SeekableStreamDecoderLengthStatus seekable_stream_decoder_length_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
852
 
{
853
 
        seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
854
 
 
855
 
        (void)decoder;
856
 
 
857
 
        if(0 == dcd) {
858
 
                printf("ERROR: client_data in length callback is NULL\n");
859
 
                return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
860
 
        }
861
 
 
862
 
        if(dcd->error_occurred)
863
 
                return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
864
 
 
865
 
        *stream_length = (FLAC__uint64)flacfilesize_;
866
 
        return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
867
 
}
868
 
 
869
 
static FLAC__bool seekable_stream_decoder_eof_callback_(const FLAC__SeekableStreamDecoder *decoder, void *client_data)
870
 
{
871
 
        seekable_stream_decoder_client_data_struct *dcd = (seekable_stream_decoder_client_data_struct*)client_data;
872
 
 
873
 
        (void)decoder;
874
 
 
875
 
        if(0 == dcd) {
876
 
                printf("ERROR: client_data in eof callback is NULL\n");
877
 
                return true;
878
 
        }
879
 
 
880
 
        if(dcd->error_occurred)
881
 
                return true;
882
 
 
883
 
        return feof(dcd->file);
884
 
}
885
 
 
886
 
static FLAC__StreamDecoderWriteStatus seekable_stream_decoder_write_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
887
 
{
888
 
        (void)decoder;
889
 
        return stream_decoder_write_callback_(0, frame, buffer, client_data);
890
 
}
891
 
 
892
 
static void seekable_stream_decoder_metadata_callback_(const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
893
 
{
894
 
        (void)decoder;
895
 
        stream_decoder_metadata_callback_(0, metadata, client_data);
896
 
}
897
 
 
898
 
static void seekable_stream_decoder_error_callback_(const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
899
 
{
900
 
        (void)decoder;
901
 
        stream_decoder_error_callback_(0, status, client_data);
902
 
}
903
 
 
904
 
static FLAC__bool seekable_stream_decoder_test_respond_(FLAC__SeekableStreamDecoder *decoder, seekable_stream_decoder_client_data_struct *dcd)
905
 
{
906
 
        if(!FLAC__seekable_stream_decoder_set_read_callback(decoder, seekable_stream_decoder_read_callback_))
907
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_read_callback(), returned false", decoder);
908
 
 
909
 
        if(!FLAC__seekable_stream_decoder_set_seek_callback(decoder, seekable_stream_decoder_seek_callback_))
910
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_seek_callback(), returned false", decoder);
911
 
 
912
 
        if(!FLAC__seekable_stream_decoder_set_tell_callback(decoder, seekable_stream_decoder_tell_callback_))
913
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_tell_callback(), returned false", decoder);
914
 
 
915
 
        if(!FLAC__seekable_stream_decoder_set_length_callback(decoder, seekable_stream_decoder_length_callback_))
916
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_length_callback(), returned false", decoder);
917
 
 
918
 
        if(!FLAC__seekable_stream_decoder_set_eof_callback(decoder, seekable_stream_decoder_eof_callback_))
919
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_eof_callback(), returned false", decoder);
920
 
 
921
 
        if(!FLAC__seekable_stream_decoder_set_write_callback(decoder, seekable_stream_decoder_write_callback_))
922
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_write_callback(), returned false", decoder);
923
 
 
924
 
        if(!FLAC__seekable_stream_decoder_set_metadata_callback(decoder, seekable_stream_decoder_metadata_callback_))
925
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_metadata_callback(), returned false", decoder);
926
 
 
927
 
        if(!FLAC__seekable_stream_decoder_set_error_callback(decoder, seekable_stream_decoder_error_callback_))
928
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_error_callback(), returned false", decoder);
929
 
 
930
 
        if(!FLAC__seekable_stream_decoder_set_client_data(decoder, dcd))
931
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_client_data(), returned false", decoder);
932
 
 
933
 
        if(!FLAC__seekable_stream_decoder_set_md5_checking(decoder, true))
934
 
                return die_ss_("at FLAC__seekable_stream_decoder_set_md5_checking(), returned false", decoder);
935
 
 
936
 
        printf("testing FLAC__seekable_stream_decoder_init()... ");
937
 
        if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
938
 
                return die_ss_(0, decoder);
939
 
        printf("OK\n");
940
 
 
941
 
        dcd->current_metadata_number = 0;
942
 
 
943
 
        if(fseek(dcd->file, 0, SEEK_SET) < 0) {
944
 
                printf("FAILED rewinding input, errno = %d\n", errno);
945
 
                return false;
946
 
        }
947
 
 
948
 
        printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
949
 
        if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
950
 
                return die_ss_("returned false", decoder);
951
 
        printf("OK\n");
952
 
 
953
 
        printf("testing FLAC__seekable_stream_decoder_finish()... ");
954
 
        (void) FLAC__seekable_stream_decoder_finish(decoder);
955
 
        printf("OK\n");
956
 
 
957
 
        return true;
958
 
}
959
 
 
960
 
static FLAC__bool test_seekable_stream_decoder()
961
 
{
962
 
        FLAC__SeekableStreamDecoder *decoder;
963
 
        FLAC__SeekableStreamDecoderState state;
964
 
        FLAC__StreamDecoderState sstate;
965
 
        seekable_stream_decoder_client_data_struct decoder_client_data;
966
 
 
967
 
        printf("\n+++ libFLAC unit test: FLAC__SeekableStreamDecoder\n\n");
968
 
 
969
 
        printf("testing FLAC__seekable_stream_decoder_new()... ");
970
 
        decoder = FLAC__seekable_stream_decoder_new();
971
 
        if(0 == decoder) {
972
 
                printf("FAILED, returned NULL\n");
973
 
                return false;
974
 
        }
975
 
        printf("OK\n");
976
 
 
977
 
        printf("testing FLAC__seekable_stream_decoder_delete()... ");
978
 
        FLAC__seekable_stream_decoder_delete(decoder);
979
 
        printf("OK\n");
980
 
 
981
 
        printf("testing FLAC__seekable_stream_decoder_new()... ");
982
 
        decoder = FLAC__seekable_stream_decoder_new();
983
 
        if(0 == decoder) {
984
 
                printf("FAILED, returned NULL\n");
985
 
                return false;
986
 
        }
987
 
        printf("OK\n");
988
 
 
989
 
        printf("testing FLAC__seekable_stream_decoder_init()... ");
990
 
        if(FLAC__seekable_stream_decoder_init(decoder) == FLAC__SEEKABLE_STREAM_DECODER_OK)
991
 
                return die_ss_(0, decoder);
992
 
        printf("OK\n");
993
 
 
994
 
        printf("testing FLAC__seekable_stream_decoder_delete()... ");
995
 
        FLAC__seekable_stream_decoder_delete(decoder);
996
 
        printf("OK\n");
997
 
 
998
 
        num_expected_ = 0;
999
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1000
 
 
1001
 
        printf("testing FLAC__seekable_stream_decoder_new()... ");
1002
 
        decoder = FLAC__seekable_stream_decoder_new();
1003
 
        if(0 == decoder) {
1004
 
                printf("FAILED, returned NULL\n");
1005
 
                return false;
1006
 
        }
1007
 
        printf("OK\n");
1008
 
 
1009
 
        printf("testing FLAC__seekable_stream_decoder_set_read_callback()... ");
1010
 
        if(!FLAC__seekable_stream_decoder_set_read_callback(decoder, seekable_stream_decoder_read_callback_))
1011
 
                return die_ss_("returned false", decoder);
1012
 
        printf("OK\n");
1013
 
 
1014
 
        printf("testing FLAC__seekable_stream_decoder_set_seek_callback()... ");
1015
 
        if(!FLAC__seekable_stream_decoder_set_seek_callback(decoder, seekable_stream_decoder_seek_callback_))
1016
 
                return die_ss_("returned false", decoder);
1017
 
        printf("OK\n");
1018
 
 
1019
 
        printf("testing FLAC__seekable_stream_decoder_set_tell_callback()... ");
1020
 
        if(!FLAC__seekable_stream_decoder_set_tell_callback(decoder, seekable_stream_decoder_tell_callback_))
1021
 
                return die_ss_("returned false", decoder);
1022
 
        printf("OK\n");
1023
 
 
1024
 
        printf("testing FLAC__seekable_stream_decoder_set_length_callback()... ");
1025
 
        if(!FLAC__seekable_stream_decoder_set_length_callback(decoder, seekable_stream_decoder_length_callback_))
1026
 
                return die_ss_("returned false", decoder);
1027
 
        printf("OK\n");
1028
 
 
1029
 
        printf("testing FLAC__seekable_stream_decoder_set_eof_callback()... ");
1030
 
        if(!FLAC__seekable_stream_decoder_set_eof_callback(decoder, seekable_stream_decoder_eof_callback_))
1031
 
                return die_ss_("returned false", decoder);
1032
 
        printf("OK\n");
1033
 
 
1034
 
        printf("testing FLAC__seekable_stream_decoder_set_write_callback()... ");
1035
 
        if(!FLAC__seekable_stream_decoder_set_write_callback(decoder, seekable_stream_decoder_write_callback_))
1036
 
                return die_ss_("returned false", decoder);
1037
 
        printf("OK\n");
1038
 
 
1039
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_callback()... ");
1040
 
        if(!FLAC__seekable_stream_decoder_set_metadata_callback(decoder, seekable_stream_decoder_metadata_callback_))
1041
 
                return die_ss_("returned false", decoder);
1042
 
        printf("OK\n");
1043
 
 
1044
 
        printf("testing FLAC__seekable_stream_decoder_set_error_callback()... ");
1045
 
        if(!FLAC__seekable_stream_decoder_set_error_callback(decoder, seekable_stream_decoder_error_callback_))
1046
 
                return die_ss_("returned false", decoder);
1047
 
        printf("OK\n");
1048
 
 
1049
 
        printf("testing FLAC__seekable_stream_decoder_set_client_data()... ");
1050
 
        if(!FLAC__seekable_stream_decoder_set_client_data(decoder, &decoder_client_data))
1051
 
                return die_ss_("returned false", decoder);
1052
 
        printf("OK\n");
1053
 
 
1054
 
        printf("testing FLAC__seekable_stream_decoder_set_md5_checking()... ");
1055
 
        if(!FLAC__seekable_stream_decoder_set_md5_checking(decoder, true))
1056
 
                return die_ss_("returned false", decoder);
1057
 
        printf("OK\n");
1058
 
 
1059
 
        printf("testing FLAC__seekable_stream_decoder_init()... ");
1060
 
        if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK)
1061
 
                return die_ss_(0, decoder);
1062
 
        printf("OK\n");
1063
 
 
1064
 
        printf("testing FLAC__seekable_stream_decoder_get_state()... ");
1065
 
        state = FLAC__seekable_stream_decoder_get_state(decoder);
1066
 
        printf("returned state = %u (%s)... OK\n", state, FLAC__SeekableStreamDecoderStateString[state]);
1067
 
 
1068
 
        printf("testing FLAC__seekable_stream_decoder_get_stream_decoder_state()... ");
1069
 
        sstate = FLAC__seekable_stream_decoder_get_stream_decoder_state(decoder);
1070
 
        printf("returned state = %u (%s)... OK\n", sstate, FLAC__StreamDecoderStateString[sstate]);
1071
 
 
1072
 
        decoder_client_data.current_metadata_number = 0;
1073
 
        decoder_client_data.ignore_errors = false;
1074
 
        decoder_client_data.error_occurred = false;
1075
 
 
1076
 
        printf("opening FLAC file... ");
1077
 
        decoder_client_data.file = fopen(flacfilename_, "rb");
1078
 
        if(0 == decoder_client_data.file) {
1079
 
                printf("ERROR\n");
1080
 
                return false;
1081
 
        }
1082
 
        printf("OK\n");
1083
 
 
1084
 
        printf("testing FLAC__seekable_stream_decoder_get_md5_checking()... ");
1085
 
        if(!FLAC__seekable_stream_decoder_get_md5_checking(decoder)) {
1086
 
                printf("FAILED, returned false, expected true\n");
1087
 
                return false;
1088
 
        }
1089
 
        printf("OK\n");
1090
 
 
1091
 
        printf("testing FLAC__seekable_stream_decoder_process_until_end_of_metadata()... ");
1092
 
        if(!FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder))
1093
 
                return die_ss_("returned false", decoder);
1094
 
        printf("OK\n");
1095
 
 
1096
 
        printf("testing FLAC__seekable_stream_decoder_process_single()... ");
1097
 
        if(!FLAC__seekable_stream_decoder_process_single(decoder))
1098
 
                return die_ss_("returned false", decoder);
1099
 
        printf("OK\n");
1100
 
 
1101
 
        printf("testing FLAC__seekable_stream_decoder_skip_single_frame()... ");
1102
 
        if(!FLAC__seekable_stream_decoder_skip_single_frame(decoder))
1103
 
                return die_ss_("returned false", decoder);
1104
 
        printf("OK\n");
1105
 
 
1106
 
        printf("testing FLAC__seekable_stream_decoder_flush()... ");
1107
 
        if(!FLAC__seekable_stream_decoder_flush(decoder))
1108
 
                return die_ss_("returned false", decoder);
1109
 
        printf("OK\n");
1110
 
 
1111
 
        decoder_client_data.ignore_errors = true;
1112
 
        printf("testing FLAC__seekable_stream_decoder_process_single()... ");
1113
 
        if(!FLAC__seekable_stream_decoder_process_single(decoder))
1114
 
                return die_ss_("returned false", decoder);
1115
 
        printf("OK\n");
1116
 
        decoder_client_data.ignore_errors = false;
1117
 
 
1118
 
        printf("testing FLAC__seekable_stream_decoder_seek_absolute()... ");
1119
 
        if(!FLAC__seekable_stream_decoder_seek_absolute(decoder, 0))
1120
 
                return die_ss_("returned false", decoder);
1121
 
        printf("OK\n");
1122
 
 
1123
 
        printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
1124
 
        if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
1125
 
                return die_ss_("returned false", decoder);
1126
 
        printf("OK\n");
1127
 
 
1128
 
        printf("testing FLAC__seekable_stream_decoder_get_channels()... ");
1129
 
        {
1130
 
                unsigned channels = FLAC__seekable_stream_decoder_get_channels(decoder);
1131
 
                if(channels != streaminfo_.data.stream_info.channels) {
1132
 
                        printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
1133
 
                        return false;
1134
 
                }
1135
 
        }
1136
 
        printf("OK\n");
1137
 
 
1138
 
        printf("testing FLAC__seekable_stream_decoder_get_bits_per_sample()... ");
1139
 
        {
1140
 
                unsigned bits_per_sample = FLAC__seekable_stream_decoder_get_bits_per_sample(decoder);
1141
 
                if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
1142
 
                        printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
1143
 
                        return false;
1144
 
                }
1145
 
        }
1146
 
        printf("OK\n");
1147
 
 
1148
 
        printf("testing FLAC__seekable_stream_decoder_get_sample_rate()... ");
1149
 
        {
1150
 
                unsigned sample_rate = FLAC__seekable_stream_decoder_get_sample_rate(decoder);
1151
 
                if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
1152
 
                        printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
1153
 
                        return false;
1154
 
                }
1155
 
        }
1156
 
        printf("OK\n");
1157
 
 
1158
 
        printf("testing FLAC__seekable_stream_decoder_get_blocksize()... ");
1159
 
        {
1160
 
                unsigned blocksize = FLAC__seekable_stream_decoder_get_blocksize(decoder);
1161
 
                /* value could be anything since we're at the last block, so accept any answer */
1162
 
                printf("returned %u... OK\n", blocksize);
1163
 
        }
1164
 
 
1165
 
        printf("testing FLAC__seekable_stream_decoder_get_channel_assignment()... ");
1166
 
        {
1167
 
                FLAC__ChannelAssignment ca = FLAC__seekable_stream_decoder_get_channel_assignment(decoder);
1168
 
                printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
1169
 
        }
1170
 
 
1171
 
        printf("testing FLAC__seekable_stream_decoder_reset()... ");
1172
 
        if(!FLAC__seekable_stream_decoder_reset(decoder))
1173
 
                return die_ss_("returned false", decoder);
1174
 
        printf("OK\n");
1175
 
 
1176
 
        decoder_client_data.current_metadata_number = 0;
1177
 
 
1178
 
        printf("rewinding input... ");
1179
 
        if(fseek(decoder_client_data.file, 0, SEEK_SET) < 0) {
1180
 
                printf("FAILED, errno = %d\n", errno);
1181
 
                return false;
1182
 
        }
1183
 
        printf("OK\n");
1184
 
 
1185
 
        printf("testing FLAC__seekable_stream_decoder_process_until_end_of_stream()... ");
1186
 
        if(!FLAC__seekable_stream_decoder_process_until_end_of_stream(decoder))
1187
 
                return die_ss_("returned false", decoder);
1188
 
        printf("OK\n");
1189
 
 
1190
 
        printf("testing FLAC__seekable_stream_decoder_finish()... ");
1191
 
        (void) FLAC__seekable_stream_decoder_finish(decoder);
1192
 
        printf("OK\n");
1193
 
 
1194
 
        /*
1195
 
         * respond all
1196
 
         */
1197
 
 
1198
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1199
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1200
 
                return die_ss_("returned false", decoder);
1201
 
        printf("OK\n");
1202
 
 
1203
 
        num_expected_ = 0;
1204
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1205
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1206
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1207
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1208
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1209
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1210
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1211
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1212
 
 
1213
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1214
 
                return false;
1215
 
 
1216
 
        /*
1217
 
         * ignore all
1218
 
         */
1219
 
 
1220
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1221
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1222
 
                return die_ss_("returned false", decoder);
1223
 
        printf("OK\n");
1224
 
 
1225
 
        num_expected_ = 0;
1226
 
 
1227
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1228
 
                return false;
1229
 
 
1230
 
        /*
1231
 
         * respond all, ignore VORBIS_COMMENT
1232
 
         */
1233
 
 
1234
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1235
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1236
 
                return die_ss_("returned false", decoder);
1237
 
        printf("OK\n");
1238
 
 
1239
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
1240
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1241
 
                return die_ss_("returned false", decoder);
1242
 
        printf("OK\n");
1243
 
 
1244
 
        num_expected_ = 0;
1245
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1246
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1247
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1248
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1249
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1250
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1251
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1252
 
 
1253
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1254
 
                return false;
1255
 
 
1256
 
        /*
1257
 
         * respond all, ignore APPLICATION
1258
 
         */
1259
 
 
1260
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1261
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1262
 
                return die_ss_("returned false", decoder);
1263
 
        printf("OK\n");
1264
 
 
1265
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(APPLICATION)... ");
1266
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1267
 
                return die_ss_("returned false", decoder);
1268
 
        printf("OK\n");
1269
 
 
1270
 
        num_expected_ = 0;
1271
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1272
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1273
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1274
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1275
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1276
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1277
 
 
1278
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1279
 
                return false;
1280
 
 
1281
 
        /*
1282
 
         * respond all, ignore APPLICATION id of app#1
1283
 
         */
1284
 
 
1285
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1286
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1287
 
                return die_ss_("returned false", decoder);
1288
 
        printf("OK\n");
1289
 
 
1290
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1291
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1292
 
                return die_ss_("returned false", decoder);
1293
 
        printf("OK\n");
1294
 
 
1295
 
        num_expected_ = 0;
1296
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1297
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1298
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1299
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1300
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1301
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1302
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1303
 
 
1304
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1305
 
                return false;
1306
 
 
1307
 
        /*
1308
 
         * respond all, ignore APPLICATION id of app#1 & app#2
1309
 
         */
1310
 
 
1311
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1312
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1313
 
                return die_ss_("returned false", decoder);
1314
 
        printf("OK\n");
1315
 
 
1316
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1317
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1318
 
                return die_ss_("returned false", decoder);
1319
 
        printf("OK\n");
1320
 
 
1321
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #2)... ");
1322
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
1323
 
                return die_ss_("returned false", decoder);
1324
 
        printf("OK\n");
1325
 
 
1326
 
        num_expected_ = 0;
1327
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1328
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1329
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1330
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1331
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1332
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1333
 
 
1334
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1335
 
                return false;
1336
 
 
1337
 
        /*
1338
 
         * ignore all, respond VORBIS_COMMENT
1339
 
         */
1340
 
 
1341
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1342
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1343
 
                return die_ss_("returned false", decoder);
1344
 
        printf("OK\n");
1345
 
 
1346
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
1347
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1348
 
                return die_ss_("returned false", decoder);
1349
 
        printf("OK\n");
1350
 
 
1351
 
        num_expected_ = 0;
1352
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1353
 
 
1354
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1355
 
                return false;
1356
 
 
1357
 
        /*
1358
 
         * ignore all, respond APPLICATION
1359
 
         */
1360
 
 
1361
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1362
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1363
 
                return die_ss_("returned false", decoder);
1364
 
        printf("OK\n");
1365
 
 
1366
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(APPLICATION)... ");
1367
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1368
 
                return die_ss_("returned false", decoder);
1369
 
        printf("OK\n");
1370
 
 
1371
 
        num_expected_ = 0;
1372
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1373
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1374
 
 
1375
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1376
 
                return false;
1377
 
 
1378
 
        /*
1379
 
         * ignore all, respond APPLICATION id of app#1
1380
 
         */
1381
 
 
1382
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1383
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1384
 
                return die_ss_("returned false", decoder);
1385
 
        printf("OK\n");
1386
 
 
1387
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1388
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1389
 
                return die_ss_("returned false", decoder);
1390
 
        printf("OK\n");
1391
 
 
1392
 
        num_expected_ = 0;
1393
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1394
 
 
1395
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1396
 
                return false;
1397
 
 
1398
 
        /*
1399
 
         * ignore all, respond APPLICATION id of app#1 & app#2
1400
 
         */
1401
 
 
1402
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1403
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1404
 
                return die_ss_("returned false", decoder);
1405
 
        printf("OK\n");
1406
 
 
1407
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1408
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1409
 
                return die_ss_("returned false", decoder);
1410
 
        printf("OK\n");
1411
 
 
1412
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #2)... ");
1413
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
1414
 
                return die_ss_("returned false", decoder);
1415
 
        printf("OK\n");
1416
 
 
1417
 
        num_expected_ = 0;
1418
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1419
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1420
 
 
1421
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1422
 
                return false;
1423
 
 
1424
 
        /*
1425
 
         * respond all, ignore APPLICATION, respond APPLICATION id of app#1
1426
 
         */
1427
 
 
1428
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_all()... ");
1429
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_all(decoder))
1430
 
                return die_ss_("returned false", decoder);
1431
 
        printf("OK\n");
1432
 
 
1433
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore(APPLICATION)... ");
1434
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1435
 
                return die_ss_("returned false", decoder);
1436
 
        printf("OK\n");
1437
 
 
1438
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond_application(of app block #1)... ");
1439
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1440
 
                return die_ss_("returned false", decoder);
1441
 
        printf("OK\n");
1442
 
 
1443
 
        num_expected_ = 0;
1444
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1445
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1446
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1447
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1448
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1449
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1450
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1451
 
 
1452
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1453
 
                return false;
1454
 
 
1455
 
        /*
1456
 
         * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
1457
 
         */
1458
 
 
1459
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_all()... ");
1460
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_all(decoder))
1461
 
                return die_ss_("returned false", decoder);
1462
 
        printf("OK\n");
1463
 
 
1464
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_respond(APPLICATION)... ");
1465
 
        if(!FLAC__seekable_stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1466
 
                return die_ss_("returned false", decoder);
1467
 
        printf("OK\n");
1468
 
 
1469
 
        printf("testing FLAC__seekable_stream_decoder_set_metadata_ignore_application(of app block #1)... ");
1470
 
        if(!FLAC__seekable_stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1471
 
                return die_ss_("returned false", decoder);
1472
 
        printf("OK\n");
1473
 
 
1474
 
        num_expected_ = 0;
1475
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1476
 
 
1477
 
        if(!seekable_stream_decoder_test_respond_(decoder, &decoder_client_data))
1478
 
                return false;
1479
 
 
1480
 
        /* done, now leave the sequence the way we found it... */
1481
 
        num_expected_ = 0;
1482
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1483
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1484
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1485
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1486
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1487
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1488
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1489
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1490
 
 
1491
 
        printf("testing FLAC__seekable_stream_decoder_delete()... ");
1492
 
        FLAC__seekable_stream_decoder_delete(decoder);
1493
 
        printf("OK\n");
1494
 
 
1495
 
        fclose(decoder_client_data.file);
1496
 
 
1497
 
        printf("\nPASSED!\n");
1498
 
 
1499
 
        return true;
1500
 
}
1501
 
 
1502
 
static FLAC__StreamDecoderWriteStatus file_decoder_write_callback_(const FLAC__FileDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
1503
 
{
1504
 
        (void)decoder;
1505
 
        return stream_decoder_write_callback_(0, frame, buffer, client_data);
1506
 
}
1507
 
 
1508
 
static void file_decoder_metadata_callback_(const FLAC__FileDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
1509
 
{
1510
 
        (void)decoder;
1511
 
        stream_decoder_metadata_callback_(0, metadata, client_data);
1512
 
}
1513
 
 
1514
 
static void file_decoder_error_callback_(const FLAC__FileDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
1515
 
{
1516
 
        (void)decoder;
1517
 
        stream_decoder_error_callback_(0, status, client_data);
1518
 
}
1519
 
 
1520
 
static FLAC__bool file_decoder_test_respond_(FLAC__FileDecoder *decoder, file_decoder_client_data_struct *dcd)
1521
 
{
1522
 
        if(!FLAC__file_decoder_set_write_callback(decoder, file_decoder_write_callback_))
1523
 
                return die_f_("at FLAC__file_decoder_set_write_callback(), returned false", decoder);
1524
 
 
1525
 
        if(!FLAC__file_decoder_set_metadata_callback(decoder, file_decoder_metadata_callback_))
1526
 
                return die_f_("at FLAC__file_decoder_set_metadata_callback(), returned false", decoder);
1527
 
 
1528
 
        if(!FLAC__file_decoder_set_error_callback(decoder, file_decoder_error_callback_))
1529
 
                return die_f_("at FLAC__file_decoder_set_error_callback(), returned false", decoder);
1530
 
 
1531
 
        if(!FLAC__file_decoder_set_client_data(decoder, dcd))
1532
 
                return die_f_("at FLAC__file_decoder_set_client_data(), returned false", decoder);
1533
 
 
1534
 
        if(!FLAC__file_decoder_set_filename(decoder, flacfilename_))
1535
 
                return die_f_("at FLAC__file_decoder_set_filename(), returned false", decoder);
1536
 
 
1537
 
        if(!FLAC__file_decoder_set_md5_checking(decoder, true))
1538
 
                return die_f_("at FLAC__file_decoder_set_md5_checking(), returned false", decoder);
1539
 
 
1540
 
        printf("testing FLAC__file_decoder_init()... ");
1541
 
        if(FLAC__file_decoder_init(decoder) != FLAC__FILE_DECODER_OK)
1542
 
                return die_f_(0, decoder);
1543
 
        printf("OK\n");
1544
 
 
1545
 
        dcd->current_metadata_number = 0;
1546
 
 
1547
 
        printf("testing FLAC__file_decoder_process_until_end_of_file()... ");
1548
 
        if(!FLAC__file_decoder_process_until_end_of_file(decoder))
1549
 
                return die_f_("returned false", decoder);
1550
 
        printf("OK\n");
1551
 
 
1552
 
        printf("testing FLAC__file_decoder_finish()... ");
1553
 
        (void) FLAC__file_decoder_finish(decoder);
1554
 
        printf("OK\n");
1555
 
 
1556
 
        return true;
1557
 
}
1558
 
 
1559
 
static FLAC__bool test_file_decoder()
1560
 
{
1561
 
        FLAC__FileDecoder *decoder;
1562
 
        FLAC__FileDecoderState state;
1563
 
        FLAC__SeekableStreamDecoderState ssstate;
1564
 
        FLAC__StreamDecoderState sstate;
1565
 
        seekable_stream_decoder_client_data_struct decoder_client_data;
1566
 
 
1567
 
        printf("\n+++ libFLAC unit test: FLAC__FileDecoder\n\n");
1568
 
 
1569
 
        printf("testing FLAC__file_decoder_new()... ");
1570
 
        decoder = FLAC__file_decoder_new();
1571
 
        if(0 == decoder) {
1572
 
                printf("FAILED, returned NULL\n");
1573
 
                return false;
1574
 
        }
1575
 
        printf("OK\n");
1576
 
 
1577
 
        printf("testing FLAC__file_decoder_delete()... ");
1578
 
        FLAC__file_decoder_delete(decoder);
1579
 
        printf("OK\n");
1580
 
 
1581
 
        printf("testing FLAC__file_decoder_new()... ");
1582
 
        decoder = FLAC__file_decoder_new();
1583
 
        if(0 == decoder) {
1584
 
                printf("FAILED, returned NULL\n");
1585
 
                return false;
1586
 
        }
1587
 
        printf("OK\n");
1588
 
 
1589
 
        printf("testing FLAC__file_decoder_init()... ");
1590
 
        if(FLAC__file_decoder_init(decoder) == FLAC__FILE_DECODER_OK)
1591
 
                return die_f_(0, decoder);
1592
 
        printf("OK\n");
1593
 
 
1594
 
        printf("testing FLAC__file_decoder_delete()... ");
1595
 
        FLAC__file_decoder_delete(decoder);
1596
 
        printf("OK\n");
1597
 
 
1598
 
        num_expected_ = 0;
1599
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1600
 
 
1601
 
        printf("testing FLAC__file_decoder_new()... ");
1602
 
        decoder = FLAC__file_decoder_new();
1603
 
        if(0 == decoder) {
1604
 
                printf("FAILED, returned NULL\n");
1605
 
                return false;
1606
 
        }
1607
 
        printf("OK\n");
1608
 
 
1609
 
        printf("testing FLAC__file_decoder_set_write_callback()... ");
1610
 
        if(!FLAC__file_decoder_set_write_callback(decoder, file_decoder_write_callback_))
1611
 
                return die_f_("returned false", decoder);
1612
 
        printf("OK\n");
1613
 
 
1614
 
        printf("testing FLAC__file_decoder_set_metadata_callback()... ");
1615
 
        if(!FLAC__file_decoder_set_metadata_callback(decoder, file_decoder_metadata_callback_))
1616
 
                return die_f_("returned false", decoder);
1617
 
        printf("OK\n");
1618
 
 
1619
 
        printf("testing FLAC__file_decoder_set_error_callback()... ");
1620
 
        if(!FLAC__file_decoder_set_error_callback(decoder, file_decoder_error_callback_))
1621
 
                return die_f_("returned false", decoder);
1622
 
        printf("OK\n");
1623
 
 
1624
 
        printf("testing FLAC__file_decoder_set_client_data()... ");
1625
 
        if(!FLAC__file_decoder_set_client_data(decoder, &decoder_client_data))
1626
 
                return die_f_("returned false", decoder);
1627
 
        printf("OK\n");
1628
 
 
1629
 
        printf("testing FLAC__file_decoder_set_filename()... ");
1630
 
        if(!FLAC__file_decoder_set_filename(decoder, flacfilename_))
1631
 
                return die_f_("returned false", decoder);
1632
 
        printf("OK\n");
1633
 
 
1634
 
        printf("testing FLAC__file_decoder_set_md5_checking()... ");
1635
 
        if(!FLAC__file_decoder_set_md5_checking(decoder, true))
1636
 
                return die_f_("returned false", decoder);
1637
 
        printf("OK\n");
1638
 
 
1639
 
        printf("testing FLAC__file_decoder_init()... ");
1640
 
        if(FLAC__file_decoder_init(decoder) != FLAC__FILE_DECODER_OK)
1641
 
                return die_f_(0, decoder);
1642
 
        printf("OK\n");
1643
 
 
1644
 
        printf("testing FLAC__file_decoder_get_state()... ");
1645
 
        state = FLAC__file_decoder_get_state(decoder);
1646
 
        printf("returned state = %u (%s)... OK\n", state, FLAC__FileDecoderStateString[state]);
1647
 
 
1648
 
        printf("testing FLAC__file_decoder_get_seekable_stream_decoder_state()... ");
1649
 
        ssstate = FLAC__file_decoder_get_seekable_stream_decoder_state(decoder);
1650
 
        printf("returned state = %u (%s)... OK\n", ssstate, FLAC__SeekableStreamDecoderStateString[ssstate]);
1651
 
 
1652
 
        printf("testing FLAC__file_decoder_get_stream_decoder_state()... ");
1653
 
        sstate = FLAC__file_decoder_get_stream_decoder_state(decoder);
1654
 
        printf("returned state = %u (%s)... OK\n", sstate, FLAC__StreamDecoderStateString[sstate]);
1655
 
 
1656
 
        decoder_client_data.current_metadata_number = 0;
1657
 
        decoder_client_data.ignore_errors = false;
1658
 
        decoder_client_data.error_occurred = false;
1659
 
 
1660
 
        printf("testing FLAC__file_decoder_get_md5_checking()... ");
1661
 
        if(!FLAC__file_decoder_get_md5_checking(decoder)) {
1662
 
                printf("FAILED, returned false, expected true\n");
1663
 
                return false;
1664
 
        }
1665
 
        printf("OK\n");
1666
 
 
1667
 
        printf("testing FLAC__file_decoder_process_until_end_of_metadata()... ");
1668
 
        if(!FLAC__file_decoder_process_until_end_of_metadata(decoder))
1669
 
                return die_f_("returned false", decoder);
1670
 
        printf("OK\n");
1671
 
 
1672
 
        printf("testing FLAC__file_decoder_process_single()... ");
1673
 
        if(!FLAC__file_decoder_process_single(decoder))
1674
 
                return die_f_("returned false", decoder);
1675
 
        printf("OK\n");
1676
 
 
1677
 
        printf("testing FLAC__file_decoder_skip_single_frame()... ");
1678
 
        if(!FLAC__file_decoder_skip_single_frame(decoder))
1679
 
                return die_f_("returned false", decoder);
1680
 
        printf("OK\n");
1681
 
 
1682
 
        printf("testing FLAC__file_decoder_seek_absolute()... ");
1683
 
        if(!FLAC__file_decoder_seek_absolute(decoder, 0))
1684
 
                return die_f_("returned false", decoder);
1685
 
        printf("OK\n");
1686
 
 
1687
 
        printf("testing FLAC__file_decoder_process_until_end_of_file()... ");
1688
 
        if(!FLAC__file_decoder_process_until_end_of_file(decoder))
1689
 
                return die_f_("returned false", decoder);
1690
 
        printf("OK\n");
1691
 
 
1692
 
        printf("testing FLAC__file_decoder_get_channels()... ");
1693
 
        {
1694
 
                unsigned channels = FLAC__file_decoder_get_channels(decoder);
1695
 
                if(channels != streaminfo_.data.stream_info.channels) {
1696
 
                        printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
1697
 
                        return false;
1698
 
                }
1699
 
        }
1700
 
        printf("OK\n");
1701
 
 
1702
 
        printf("testing FLAC__file_decoder_get_bits_per_sample()... ");
1703
 
        {
1704
 
                unsigned bits_per_sample = FLAC__file_decoder_get_bits_per_sample(decoder);
1705
 
                if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
1706
 
                        printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
1707
 
                        return false;
1708
 
                }
1709
 
        }
1710
 
        printf("OK\n");
1711
 
 
1712
 
        printf("testing FLAC__file_decoder_get_sample_rate()... ");
1713
 
        {
1714
 
                unsigned sample_rate = FLAC__file_decoder_get_sample_rate(decoder);
1715
 
                if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
1716
 
                        printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
1717
 
                        return false;
1718
 
                }
1719
 
        }
1720
 
        printf("OK\n");
1721
 
 
1722
 
        printf("testing FLAC__file_decoder_get_blocksize()... ");
1723
 
        {
1724
 
                unsigned blocksize = FLAC__file_decoder_get_blocksize(decoder);
1725
 
                /* value could be anything since we're at the last block, so accept any answer */
1726
 
                printf("returned %u... OK\n", blocksize);
1727
 
        }
1728
 
 
1729
 
        printf("testing FLAC__file_decoder_get_channel_assignment()... ");
1730
 
        {
1731
 
                FLAC__ChannelAssignment ca = FLAC__file_decoder_get_channel_assignment(decoder);
1732
 
                printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
1733
 
        }
1734
 
 
1735
 
        printf("testing FLAC__file_decoder_finish()... ");
1736
 
        (void) FLAC__file_decoder_finish(decoder);
1737
 
        printf("OK\n");
1738
 
 
1739
 
        /*
1740
 
         * respond all
1741
 
         */
1742
 
 
1743
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1744
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1745
 
                return die_f_("returned false", decoder);
1746
 
        printf("OK\n");
1747
 
 
1748
 
        num_expected_ = 0;
1749
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1750
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1751
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1752
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1753
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1754
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1755
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1756
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1757
 
 
1758
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1759
 
                return false;
1760
 
 
1761
 
        /*
1762
 
         * ignore all
1763
 
         */
1764
 
 
1765
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1766
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1767
 
                return die_f_("returned false", decoder);
1768
 
        printf("OK\n");
1769
 
 
1770
 
        num_expected_ = 0;
1771
 
 
1772
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1773
 
                return false;
1774
 
 
1775
 
        /*
1776
 
         * respond all, ignore VORBIS_COMMENT
1777
 
         */
1778
 
 
1779
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1780
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1781
 
                return die_f_("returned false", decoder);
1782
 
        printf("OK\n");
1783
 
 
1784
 
        printf("testing FLAC__file_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
1785
 
        if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1786
 
                return die_f_("returned false", decoder);
1787
 
        printf("OK\n");
1788
 
 
1789
 
        num_expected_ = 0;
1790
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1791
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1792
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1793
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1794
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1795
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1796
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1797
 
 
1798
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1799
 
                return false;
1800
 
 
1801
 
        /*
1802
 
         * respond all, ignore APPLICATION
1803
 
         */
1804
 
 
1805
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1806
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1807
 
                return die_f_("returned false", decoder);
1808
 
        printf("OK\n");
1809
 
 
1810
 
        printf("testing FLAC__file_decoder_set_metadata_ignore(APPLICATION)... ");
1811
 
        if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1812
 
                return die_f_("returned false", decoder);
1813
 
        printf("OK\n");
1814
 
 
1815
 
        num_expected_ = 0;
1816
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1817
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1818
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1819
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1820
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1821
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1822
 
 
1823
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1824
 
                return false;
1825
 
 
1826
 
        /*
1827
 
         * respond all, ignore APPLICATION id of app#1
1828
 
         */
1829
 
 
1830
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1831
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1832
 
                return die_f_("returned false", decoder);
1833
 
        printf("OK\n");
1834
 
 
1835
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
1836
 
        if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1837
 
                return die_f_("returned false", decoder);
1838
 
        printf("OK\n");
1839
 
 
1840
 
        num_expected_ = 0;
1841
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1842
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1843
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1844
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1845
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1846
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1847
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1848
 
 
1849
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1850
 
                return false;
1851
 
 
1852
 
        /*
1853
 
         * respond all, ignore APPLICATION id of app#1 & app#2
1854
 
         */
1855
 
 
1856
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1857
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1858
 
                return die_f_("returned false", decoder);
1859
 
        printf("OK\n");
1860
 
 
1861
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
1862
 
        if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
1863
 
                return die_f_("returned false", decoder);
1864
 
        printf("OK\n");
1865
 
 
1866
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #2)... ");
1867
 
        if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
1868
 
                return die_f_("returned false", decoder);
1869
 
        printf("OK\n");
1870
 
 
1871
 
        num_expected_ = 0;
1872
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1873
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1874
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1875
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1876
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1877
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1878
 
 
1879
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1880
 
                return false;
1881
 
 
1882
 
        /*
1883
 
         * ignore all, respond VORBIS_COMMENT
1884
 
         */
1885
 
 
1886
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1887
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1888
 
                return die_f_("returned false", decoder);
1889
 
        printf("OK\n");
1890
 
 
1891
 
        printf("testing FLAC__file_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
1892
 
        if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
1893
 
                return die_f_("returned false", decoder);
1894
 
        printf("OK\n");
1895
 
 
1896
 
        num_expected_ = 0;
1897
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1898
 
 
1899
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1900
 
                return false;
1901
 
 
1902
 
        /*
1903
 
         * ignore all, respond APPLICATION
1904
 
         */
1905
 
 
1906
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1907
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1908
 
                return die_f_("returned false", decoder);
1909
 
        printf("OK\n");
1910
 
 
1911
 
        printf("testing FLAC__file_decoder_set_metadata_respond(APPLICATION)... ");
1912
 
        if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
1913
 
                return die_f_("returned false", decoder);
1914
 
        printf("OK\n");
1915
 
 
1916
 
        num_expected_ = 0;
1917
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1918
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1919
 
 
1920
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1921
 
                return false;
1922
 
 
1923
 
        /*
1924
 
         * ignore all, respond APPLICATION id of app#1
1925
 
         */
1926
 
 
1927
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1928
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1929
 
                return die_f_("returned false", decoder);
1930
 
        printf("OK\n");
1931
 
 
1932
 
        printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1933
 
        if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1934
 
                return die_f_("returned false", decoder);
1935
 
        printf("OK\n");
1936
 
 
1937
 
        num_expected_ = 0;
1938
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1939
 
 
1940
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1941
 
                return false;
1942
 
 
1943
 
        /*
1944
 
         * ignore all, respond APPLICATION id of app#1 & app#2
1945
 
         */
1946
 
 
1947
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
1948
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
1949
 
                return die_f_("returned false", decoder);
1950
 
        printf("OK\n");
1951
 
 
1952
 
        printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1953
 
        if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1954
 
                return die_f_("returned false", decoder);
1955
 
        printf("OK\n");
1956
 
 
1957
 
        printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #2)... ");
1958
 
        if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
1959
 
                return die_f_("returned false", decoder);
1960
 
        printf("OK\n");
1961
 
 
1962
 
        num_expected_ = 0;
1963
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1964
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
1965
 
 
1966
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1967
 
                return false;
1968
 
 
1969
 
        /*
1970
 
         * respond all, ignore APPLICATION, respond APPLICATION id of app#1
1971
 
         */
1972
 
 
1973
 
        printf("testing FLAC__file_decoder_set_metadata_respond_all()... ");
1974
 
        if(!FLAC__file_decoder_set_metadata_respond_all(decoder))
1975
 
                return die_f_("returned false", decoder);
1976
 
        printf("OK\n");
1977
 
 
1978
 
        printf("testing FLAC__file_decoder_set_metadata_ignore(APPLICATION)... ");
1979
 
        if(!FLAC__file_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
1980
 
                return die_f_("returned false", decoder);
1981
 
        printf("OK\n");
1982
 
 
1983
 
        printf("testing FLAC__file_decoder_set_metadata_respond_application(of app block #1)... ");
1984
 
        if(!FLAC__file_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
1985
 
                return die_f_("returned false", decoder);
1986
 
        printf("OK\n");
1987
 
 
1988
 
        num_expected_ = 0;
1989
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
1990
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
1991
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
1992
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
1993
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
1994
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
1995
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
1996
 
 
1997
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
1998
 
                return false;
1999
 
 
2000
 
        /*
2001
 
         * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
2002
 
         */
2003
 
 
2004
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_all()... ");
2005
 
        if(!FLAC__file_decoder_set_metadata_ignore_all(decoder))
2006
 
                return die_f_("returned false", decoder);
2007
 
        printf("OK\n");
2008
 
 
2009
 
        printf("testing FLAC__file_decoder_set_metadata_respond(APPLICATION)... ");
2010
 
        if(!FLAC__file_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
2011
 
                return die_f_("returned false", decoder);
2012
 
        printf("OK\n");
2013
 
 
2014
 
        printf("testing FLAC__file_decoder_set_metadata_ignore_application(of app block #1)... ");
2015
 
        if(!FLAC__file_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
2016
 
                return die_f_("returned false", decoder);
2017
 
        printf("OK\n");
2018
 
 
2019
 
        num_expected_ = 0;
2020
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
2021
 
 
2022
 
        if(!file_decoder_test_respond_(decoder, &decoder_client_data))
2023
 
                return false;
2024
 
 
2025
 
        /* done, now leave the sequence the way we found it... */
2026
 
        num_expected_ = 0;
2027
 
        expected_metadata_sequence_[num_expected_++] = &streaminfo_;
2028
 
        expected_metadata_sequence_[num_expected_++] = &padding_;
2029
 
        expected_metadata_sequence_[num_expected_++] = &seektable_;
2030
 
        expected_metadata_sequence_[num_expected_++] = &application1_;
2031
 
        expected_metadata_sequence_[num_expected_++] = &application2_;
2032
 
        expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
2033
 
        expected_metadata_sequence_[num_expected_++] = &cuesheet_;
2034
 
        expected_metadata_sequence_[num_expected_++] = &unknown_;
2035
 
 
2036
 
        printf("testing FLAC__file_decoder_delete()... ");
2037
 
        FLAC__file_decoder_delete(decoder);
2038
 
        printf("OK\n");
2039
 
 
2040
 
        printf("\nPASSED!\n");
2041
 
 
2042
 
        return true;
2043
 
}
2044
 
 
2045
 
FLAC__bool test_decoders()
2046
 
{
2047
 
        init_metadata_blocks_();
2048
 
        if(!generate_file_())
2049
 
                return false;
2050
 
 
2051
 
        if(!test_stream_decoder())
2052
 
                return false;
2053
 
 
2054
 
        if(!test_seekable_stream_decoder())
2055
 
                return false;
2056
 
 
2057
 
        if(!test_file_decoder())
2058
 
                return false;
2059
 
 
2060
 
        (void) grabbag__file_remove_file(flacfilename_);
2061
 
        free_metadata_blocks_();
 
1011
        printf("\nPASSED!\n");
 
1012
 
 
1013
        return true;
 
1014
}
 
1015
 
 
1016
FLAC__bool test_decoders(void)
 
1017
{
 
1018
        FLAC__bool is_ogg = false;
 
1019
 
 
1020
        while(1) {
 
1021
                init_metadata_blocks_();
 
1022
 
 
1023
                if(!generate_file_(is_ogg))
 
1024
                        return false;
 
1025
 
 
1026
                if(!test_stream_decoder(LAYER_STREAM, is_ogg))
 
1027
                        return false;
 
1028
 
 
1029
                if(!test_stream_decoder(LAYER_SEEKABLE_STREAM, is_ogg))
 
1030
                        return false;
 
1031
 
 
1032
                if(!test_stream_decoder(LAYER_FILE, is_ogg))
 
1033
                        return false;
 
1034
 
 
1035
                if(!test_stream_decoder(LAYER_FILENAME, is_ogg))
 
1036
                        return false;
 
1037
 
 
1038
                (void) grabbag__file_remove_file(flacfilename(is_ogg));
 
1039
 
 
1040
                free_metadata_blocks_();
 
1041
 
 
1042
                if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
 
1043
                        break;
 
1044
                is_ogg = true;
 
1045
        }
2062
1046
 
2063
1047
        return true;
2064
1048
}