← Back to branch summary

~ubuntu-branches/ubuntu/precise/flac/precise-updates

« back to all changes in this revision

Viewing changes to src/test_libOggFLAC/decoders.c

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

Show diffs side-by-side

added added

removed removed

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