← Back to branch summary

~ubuntu-branches/ubuntu/raring/flac/raring

« back to all changes in this revision

Viewing changes to src/libFLAC/seekable_stream_encoder.c

  • Committer: Bazaar Package Importer
  • Author(s): Joshua Kwan
  • Date: 2007-05-29 22:56:36 UTC
  • mto: (8.1.1 lenny)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20070529225636-p8lkii0r0kp50pns
Tags: upstream-1.1.4
Import upstream version 1.1.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libFLAC/seekable_stream_encoder.c
1
 
/* libFLAC - Free Lossless Audio Codec library
2
 
 * Copyright (C) 2002,2003,2004,2005  Josh Coalson
3
 
 *
4
 
 * Redistribution and use in source and binary forms, with or without
5
 
 * modification, are permitted provided that the following conditions
6
 
 * are met:
7
 
 *
8
 
 * - Redistributions of source code must retain the above copyright
9
 
 * notice, this list of conditions and the following disclaimer.
10
 
 *
11
 
 * - Redistributions in binary form must reproduce the above copyright
12
 
 * notice, this list of conditions and the following disclaimer in the
13
 
 * documentation and/or other materials provided with the distribution.
14
 
 *
15
 
 * - Neither the name of the Xiph.org Foundation nor the names of its
16
 
 * contributors may be used to endorse or promote products derived from
17
 
 * this software without specific prior written permission.
18
 
 *
19
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20
 
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21
 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22
 
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23
 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24
 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25
 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26
 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27
 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28
 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29
 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
 
 */
31
 
 
32
 
#include <stdio.h>
33
 
#include <stdlib.h> /* for calloc() */
34
 
#include <string.h> /* for memcpy() */
35
 
#include "FLAC/assert.h"
36
 
#include "protected/seekable_stream_encoder.h"
37
 
 
38
 
#ifdef max
39
 
#undef max
40
 
#endif
41
 
#define max(a,b) ((a)>(b)?(a):(b))
42
 
 
43
 
/***********************************************************************
44
 
 *
45
 
 * Private class method prototypes
46
 
 *
47
 
 ***********************************************************************/
48
 
 
49
 
/* unpublished debug routines */
50
 
extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
51
 
extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
52
 
extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
53
 
 
54
 
static void set_defaults_(FLAC__SeekableStreamEncoder *encoder);
55
 
static FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
56
 
static void metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data);
57
 
 
58
 
/***********************************************************************
59
 
 *
60
 
 * Private class data
61
 
 *
62
 
 ***********************************************************************/
63
 
 
64
 
typedef struct FLAC__SeekableStreamEncoderPrivate {
65
 
        FLAC__SeekableStreamEncoderSeekCallback seek_callback;
66
 
        FLAC__SeekableStreamEncoderTellCallback tell_callback;
67
 
        FLAC__SeekableStreamEncoderWriteCallback write_callback;
68
 
        void *client_data;
69
 
        FLAC__StreamEncoder *stream_encoder;
70
 
        FLAC__StreamMetadata_SeekTable *seek_table;
71
 
        /* internal vars (all the above are class settings) */
72
 
        unsigned first_seekpoint_to_check;
73
 
        FLAC__uint64 samples_written;
74
 
} FLAC__SeekableStreamEncoderPrivate;
75
 
 
76
 
/***********************************************************************
77
 
 *
78
 
 * Public static class data
79
 
 *
80
 
 ***********************************************************************/
81
 
 
82
 
FLAC_API const char * const FLAC__SeekableStreamEncoderStateString[] = {
83
 
        "FLAC__SEEKABLE_STREAM_ENCODER_OK",
84
 
        "FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR",
85
 
        "FLAC__SEEKABLE_STREAM_ENCODER_MEMORY_ALLOCATION_ERROR",
86
 
        "FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR",
87
 
        "FLAC__SEEKABLE_STREAM_ENCODER_READ_ERROR",
88
 
        "FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR",
89
 
        "FLAC__SEEKABLE_STREAM_ENCODER_TELL_ERROR",
90
 
        "FLAC__SEEKABLE_STREAM_ENCODER_ALREADY_INITIALIZED",
91
 
        "FLAC__SEEKABLE_STREAM_ENCODER_INVALID_CALLBACK",
92
 
        "FLAC__SEEKABLE_STREAM_ENCODER_INVALID_SEEKTABLE",
93
 
        "FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED"
94
 
};
95
 
 
96
 
FLAC_API const char * const FLAC__SeekableStreamEncoderSeekStatusString[] = {
97
 
        "FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK",
98
 
        "FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR"
99
 
};
100
 
 
101
 
FLAC_API const char * const FLAC__SeekableStreamEncoderTellStatusString[] = {
102
 
        "FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK",
103
 
        "FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_ERROR"
104
 
};
105
 
 
106
 
 
107
 
/***********************************************************************
108
 
 *
109
 
 * Class constructor/destructor
110
 
 *
111
 
 ***********************************************************************/
112
 
 
113
 
FLAC_API FLAC__SeekableStreamEncoder *FLAC__seekable_stream_encoder_new()
114
 
{
115
 
        FLAC__SeekableStreamEncoder *encoder;
116
 
 
117
 
        FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
118
 
 
119
 
        encoder = (FLAC__SeekableStreamEncoder*)calloc(1, sizeof(FLAC__SeekableStreamEncoder));
120
 
        if(encoder == 0) {
121
 
                return 0;
122
 
        }
123
 
 
124
 
        encoder->protected_ = (FLAC__SeekableStreamEncoderProtected*)calloc(1, sizeof(FLAC__SeekableStreamEncoderProtected));
125
 
        if(encoder->protected_ == 0) {
126
 
                free(encoder);
127
 
                return 0;
128
 
        }
129
 
 
130
 
        encoder->private_ = (FLAC__SeekableStreamEncoderPrivate*)calloc(1, sizeof(FLAC__SeekableStreamEncoderPrivate));
131
 
        if(encoder->private_ == 0) {
132
 
                free(encoder->protected_);
133
 
                free(encoder);
134
 
                return 0;
135
 
        }
136
 
 
137
 
        encoder->private_->stream_encoder = FLAC__stream_encoder_new();
138
 
        if(0 == encoder->private_->stream_encoder) {
139
 
                free(encoder->private_);
140
 
                free(encoder->protected_);
141
 
                free(encoder);
142
 
                return 0;
143
 
        }
144
 
 
145
 
        set_defaults_(encoder);
146
 
 
147
 
        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED;
148
 
 
149
 
        return encoder;
150
 
}
151
 
 
152
 
FLAC_API void FLAC__seekable_stream_encoder_delete(FLAC__SeekableStreamEncoder *encoder)
153
 
{
154
 
        FLAC__ASSERT(0 != encoder);
155
 
        FLAC__ASSERT(0 != encoder->protected_);
156
 
        FLAC__ASSERT(0 != encoder->private_);
157
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
158
 
 
159
 
        (void)FLAC__seekable_stream_encoder_finish(encoder);
160
 
 
161
 
        FLAC__stream_encoder_delete(encoder->private_->stream_encoder);
162
 
 
163
 
        free(encoder->private_);
164
 
        free(encoder->protected_);
165
 
        free(encoder);
166
 
}
167
 
 
168
 
 
169
 
/***********************************************************************
170
 
 *
171
 
 * Public class methods
172
 
 *
173
 
 ***********************************************************************/
174
 
 
175
 
FLAC_API FLAC__SeekableStreamEncoderState FLAC__seekable_stream_encoder_init(FLAC__SeekableStreamEncoder *encoder)
176
 
{
177
 
        FLAC__ASSERT(0 != encoder);
178
 
 
179
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
180
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_ALREADY_INITIALIZED;
181
 
 
182
 
        if(0 == encoder->private_->seek_callback || 0 == encoder->private_->tell_callback || 0 == encoder->private_->write_callback)
183
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_INVALID_CALLBACK;
184
 
 
185
 
        if(0 != encoder->private_->seek_table && !FLAC__format_seektable_is_legal(encoder->private_->seek_table))
186
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_INVALID_SEEKTABLE;
187
 
 
188
 
        /*
189
 
         * These must be done before we init the stream encoder because that
190
 
         * calls the write_callback, which uses these values.
191
 
         */
192
 
        encoder->private_->first_seekpoint_to_check = 0;
193
 
        encoder->private_->samples_written = 0;
194
 
        encoder->protected_->streaminfo_offset = 0;
195
 
        encoder->protected_->seektable_offset = 0;
196
 
        encoder->protected_->audio_offset = 0;
197
 
 
198
 
        FLAC__stream_encoder_set_write_callback(encoder->private_->stream_encoder, write_callback_);
199
 
        FLAC__stream_encoder_set_metadata_callback(encoder->private_->stream_encoder, metadata_callback_);
200
 
        FLAC__stream_encoder_set_client_data(encoder->private_->stream_encoder, encoder);
201
 
 
202
 
        if(FLAC__stream_encoder_init(encoder->private_->stream_encoder) != FLAC__STREAM_ENCODER_OK)
203
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR;
204
 
 
205
 
        /*
206
 
         * Initializing the stream encoder writes all the metadata, so we
207
 
         * save the stream offset now.
208
 
         */
209
 
        if(encoder->private_->tell_callback(encoder, &encoder->protected_->audio_offset, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK)
210
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_TELL_ERROR;
211
 
 
212
 
        return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_OK;
213
 
}
214
 
 
215
 
FLAC_API void FLAC__seekable_stream_encoder_finish(FLAC__SeekableStreamEncoder *encoder)
216
 
{
217
 
        FLAC__ASSERT(0 != encoder);
218
 
        FLAC__ASSERT(0 != encoder->private_);
219
 
        FLAC__ASSERT(0 != encoder->protected_);
220
 
 
221
 
        if(encoder->protected_->state == FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
222
 
                return;
223
 
 
224
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
225
 
 
226
 
        FLAC__stream_encoder_finish(encoder->private_->stream_encoder);
227
 
 
228
 
        set_defaults_(encoder);
229
 
 
230
 
        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED;
231
 
}
232
 
 
233
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_verify(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
234
 
{
235
 
        FLAC__ASSERT(0 != encoder);
236
 
        FLAC__ASSERT(0 != encoder->private_);
237
 
        FLAC__ASSERT(0 != encoder->protected_);
238
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
239
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
240
 
                return false;
241
 
        return FLAC__stream_encoder_set_verify(encoder->private_->stream_encoder, value);
242
 
}
243
 
 
244
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_streamable_subset(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
245
 
{
246
 
        FLAC__ASSERT(0 != encoder);
247
 
        FLAC__ASSERT(0 != encoder->private_);
248
 
        FLAC__ASSERT(0 != encoder->protected_);
249
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
250
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
251
 
                return false;
252
 
        return FLAC__stream_encoder_set_streamable_subset(encoder->private_->stream_encoder, value);
253
 
}
254
 
 
255
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_do_mid_side_stereo(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
256
 
{
257
 
        FLAC__ASSERT(0 != encoder);
258
 
        FLAC__ASSERT(0 != encoder->private_);
259
 
        FLAC__ASSERT(0 != encoder->protected_);
260
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
261
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
262
 
                return false;
263
 
        return FLAC__stream_encoder_set_do_mid_side_stereo(encoder->private_->stream_encoder, value);
264
 
}
265
 
 
266
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_loose_mid_side_stereo(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
267
 
{
268
 
        FLAC__ASSERT(0 != encoder);
269
 
        FLAC__ASSERT(0 != encoder->private_);
270
 
        FLAC__ASSERT(0 != encoder->protected_);
271
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
272
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
273
 
                return false;
274
 
        return FLAC__stream_encoder_set_loose_mid_side_stereo(encoder->private_->stream_encoder, value);
275
 
}
276
 
 
277
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_channels(FLAC__SeekableStreamEncoder *encoder, unsigned value)
278
 
{
279
 
        FLAC__ASSERT(0 != encoder);
280
 
        FLAC__ASSERT(0 != encoder->private_);
281
 
        FLAC__ASSERT(0 != encoder->protected_);
282
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
283
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
284
 
                return false;
285
 
        return FLAC__stream_encoder_set_channels(encoder->private_->stream_encoder, value);
286
 
}
287
 
 
288
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_bits_per_sample(FLAC__SeekableStreamEncoder *encoder, unsigned value)
289
 
{
290
 
        FLAC__ASSERT(0 != encoder);
291
 
        FLAC__ASSERT(0 != encoder->private_);
292
 
        FLAC__ASSERT(0 != encoder->protected_);
293
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
294
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
295
 
                return false;
296
 
        return FLAC__stream_encoder_set_bits_per_sample(encoder->private_->stream_encoder, value);
297
 
}
298
 
 
299
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_sample_rate(FLAC__SeekableStreamEncoder *encoder, unsigned value)
300
 
{
301
 
        FLAC__ASSERT(0 != encoder);
302
 
        FLAC__ASSERT(0 != encoder->private_);
303
 
        FLAC__ASSERT(0 != encoder->protected_);
304
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
305
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
306
 
                return false;
307
 
        return FLAC__stream_encoder_set_sample_rate(encoder->private_->stream_encoder, value);
308
 
}
309
 
 
310
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_blocksize(FLAC__SeekableStreamEncoder *encoder, unsigned value)
311
 
{
312
 
        FLAC__ASSERT(0 != encoder);
313
 
        FLAC__ASSERT(0 != encoder->private_);
314
 
        FLAC__ASSERT(0 != encoder->protected_);
315
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
316
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
317
 
                return false;
318
 
        return FLAC__stream_encoder_set_blocksize(encoder->private_->stream_encoder, value);
319
 
}
320
 
 
321
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_max_lpc_order(FLAC__SeekableStreamEncoder *encoder, unsigned value)
322
 
{
323
 
        FLAC__ASSERT(0 != encoder);
324
 
        FLAC__ASSERT(0 != encoder->private_);
325
 
        FLAC__ASSERT(0 != encoder->protected_);
326
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
327
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
328
 
                return false;
329
 
        return FLAC__stream_encoder_set_max_lpc_order(encoder->private_->stream_encoder, value);
330
 
}
331
 
 
332
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_qlp_coeff_precision(FLAC__SeekableStreamEncoder *encoder, unsigned value)
333
 
{
334
 
        FLAC__ASSERT(0 != encoder);
335
 
        FLAC__ASSERT(0 != encoder->private_);
336
 
        FLAC__ASSERT(0 != encoder->protected_);
337
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
338
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
339
 
                return false;
340
 
        return FLAC__stream_encoder_set_qlp_coeff_precision(encoder->private_->stream_encoder, value);
341
 
}
342
 
 
343
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
344
 
{
345
 
        FLAC__ASSERT(0 != encoder);
346
 
        FLAC__ASSERT(0 != encoder->private_);
347
 
        FLAC__ASSERT(0 != encoder->protected_);
348
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
349
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
350
 
                return false;
351
 
        return FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder->private_->stream_encoder, value);
352
 
}
353
 
 
354
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_do_escape_coding(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
355
 
{
356
 
        FLAC__ASSERT(0 != encoder);
357
 
        FLAC__ASSERT(0 != encoder->private_);
358
 
        FLAC__ASSERT(0 != encoder->protected_);
359
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
360
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
361
 
                return false;
362
 
        return FLAC__stream_encoder_set_do_escape_coding(encoder->private_->stream_encoder, value);
363
 
}
364
 
 
365
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_do_exhaustive_model_search(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
366
 
{
367
 
        FLAC__ASSERT(0 != encoder);
368
 
        FLAC__ASSERT(0 != encoder->private_);
369
 
        FLAC__ASSERT(0 != encoder->protected_);
370
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
371
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
372
 
                return false;
373
 
        return FLAC__stream_encoder_set_do_exhaustive_model_search(encoder->private_->stream_encoder, value);
374
 
}
375
 
 
376
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_min_residual_partition_order(FLAC__SeekableStreamEncoder *encoder, unsigned value)
377
 
{
378
 
        FLAC__ASSERT(0 != encoder);
379
 
        FLAC__ASSERT(0 != encoder->private_);
380
 
        FLAC__ASSERT(0 != encoder->protected_);
381
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
382
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
383
 
                return false;
384
 
        return FLAC__stream_encoder_set_min_residual_partition_order(encoder->private_->stream_encoder, value);
385
 
}
386
 
 
387
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_max_residual_partition_order(FLAC__SeekableStreamEncoder *encoder, unsigned value)
388
 
{
389
 
        FLAC__ASSERT(0 != encoder);
390
 
        FLAC__ASSERT(0 != encoder->private_);
391
 
        FLAC__ASSERT(0 != encoder->protected_);
392
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
393
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
394
 
                return false;
395
 
        return FLAC__stream_encoder_set_max_residual_partition_order(encoder->private_->stream_encoder, value);
396
 
}
397
 
 
398
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_rice_parameter_search_dist(FLAC__SeekableStreamEncoder *encoder, unsigned value)
399
 
{
400
 
        FLAC__ASSERT(0 != encoder);
401
 
        FLAC__ASSERT(0 != encoder->private_);
402
 
        FLAC__ASSERT(0 != encoder->protected_);
403
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
404
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
405
 
                return false;
406
 
        return FLAC__stream_encoder_set_rice_parameter_search_dist(encoder->private_->stream_encoder, value);
407
 
}
408
 
 
409
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_total_samples_estimate(FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 value)
410
 
{
411
 
        FLAC__ASSERT(0 != encoder);
412
 
        FLAC__ASSERT(0 != encoder->private_);
413
 
        FLAC__ASSERT(0 != encoder->protected_);
414
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
415
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
416
 
                return false;
417
 
        return FLAC__stream_encoder_set_total_samples_estimate(encoder->private_->stream_encoder, value);
418
 
}
419
 
 
420
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_metadata(FLAC__SeekableStreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
421
 
{
422
 
        FLAC__ASSERT(0 != encoder);
423
 
        FLAC__ASSERT(0 != encoder->private_);
424
 
        FLAC__ASSERT(0 != encoder->protected_);
425
 
        FLAC__ASSERT(0 != encoder->private_->stream_encoder);
426
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
427
 
                return false;
428
 
        if(0 != metadata && num_blocks > 0) {
429
 
                unsigned i;
430
 
                for(i = 0; i < num_blocks; i++) {
431
 
                        if(0 != metadata[i] && metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
432
 
                                encoder->private_->seek_table = &metadata[i]->data.seek_table;
433
 
                                break; /* take only the first one */
434
 
                        }
435
 
                }
436
 
        }
437
 
        return FLAC__stream_encoder_set_metadata(encoder->private_->stream_encoder, metadata, num_blocks);
438
 
}
439
 
 
440
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_seek_callback(FLAC__SeekableStreamEncoder *encoder, FLAC__SeekableStreamEncoderSeekCallback value)
441
 
{
442
 
        FLAC__ASSERT(0 != encoder);
443
 
        FLAC__ASSERT(0 != encoder->private_);
444
 
        FLAC__ASSERT(0 != encoder->protected_);
445
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
446
 
                return false;
447
 
        encoder->private_->seek_callback = value;
448
 
        return true;
449
 
}
450
 
 
451
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_tell_callback(FLAC__SeekableStreamEncoder *encoder, FLAC__SeekableStreamEncoderTellCallback value)
452
 
{
453
 
        FLAC__ASSERT(0 != encoder);
454
 
        FLAC__ASSERT(0 != encoder->private_);
455
 
        FLAC__ASSERT(0 != encoder->protected_);
456
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
457
 
                return false;
458
 
        encoder->private_->tell_callback = value;
459
 
        return true;
460
 
}
461
 
 
462
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_write_callback(FLAC__SeekableStreamEncoder *encoder, FLAC__SeekableStreamEncoderWriteCallback value)
463
 
{
464
 
        FLAC__ASSERT(0 != encoder);
465
 
        FLAC__ASSERT(0 != encoder->private_);
466
 
        FLAC__ASSERT(0 != encoder->protected_);
467
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
468
 
                return false;
469
 
        encoder->private_->write_callback = value;
470
 
        return true;
471
 
}
472
 
 
473
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_set_client_data(FLAC__SeekableStreamEncoder *encoder, void *value)
474
 
{
475
 
        FLAC__ASSERT(0 != encoder);
476
 
        FLAC__ASSERT(0 != encoder->private_);
477
 
        FLAC__ASSERT(0 != encoder->protected_);
478
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
479
 
                return false;
480
 
        encoder->private_->client_data = value;
481
 
        return true;
482
 
}
483
 
 
484
 
/*
485
 
 * These three functions are not static, but not publically exposed in
486
 
 * include/FLAC/ either.  They are used by the test suite.
487
 
 */
488
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_disable_constant_subframes(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
489
 
{
490
 
        FLAC__ASSERT(0 != encoder);
491
 
        FLAC__ASSERT(0 != encoder->private_);
492
 
        FLAC__ASSERT(0 != encoder->protected_);
493
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
494
 
                return false;
495
 
        return FLAC__stream_encoder_disable_constant_subframes(encoder->private_->stream_encoder, value);
496
 
}
497
 
 
498
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_disable_fixed_subframes(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
499
 
{
500
 
        FLAC__ASSERT(0 != encoder);
501
 
        FLAC__ASSERT(0 != encoder->private_);
502
 
        FLAC__ASSERT(0 != encoder->protected_);
503
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
504
 
                return false;
505
 
        return FLAC__stream_encoder_disable_fixed_subframes(encoder->private_->stream_encoder, value);
506
 
}
507
 
 
508
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_disable_verbatim_subframes(FLAC__SeekableStreamEncoder *encoder, FLAC__bool value)
509
 
{
510
 
        FLAC__ASSERT(0 != encoder);
511
 
        FLAC__ASSERT(0 != encoder->private_);
512
 
        FLAC__ASSERT(0 != encoder->protected_);
513
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED)
514
 
                return false;
515
 
        return FLAC__stream_encoder_disable_verbatim_subframes(encoder->private_->stream_encoder, value);
516
 
}
517
 
 
518
 
FLAC_API FLAC__SeekableStreamEncoderState FLAC__seekable_stream_encoder_get_state(const FLAC__SeekableStreamEncoder *encoder)
519
 
{
520
 
        FLAC__ASSERT(0 != encoder);
521
 
        FLAC__ASSERT(0 != encoder->protected_);
522
 
        return encoder->protected_->state;
523
 
}
524
 
 
525
 
FLAC_API FLAC__StreamEncoderState FLAC__seekable_stream_encoder_get_stream_encoder_state(const FLAC__SeekableStreamEncoder *encoder)
526
 
{
527
 
        FLAC__ASSERT(0 != encoder);
528
 
        FLAC__ASSERT(0 != encoder->private_);
529
 
        return FLAC__stream_encoder_get_state(encoder->private_->stream_encoder);
530
 
}
531
 
 
532
 
FLAC_API FLAC__StreamDecoderState FLAC__seekable_stream_encoder_get_verify_decoder_state(const FLAC__SeekableStreamEncoder *encoder)
533
 
{
534
 
        FLAC__ASSERT(0 != encoder);
535
 
        FLAC__ASSERT(0 != encoder->private_);
536
 
        return FLAC__stream_encoder_get_verify_decoder_state(encoder->private_->stream_encoder);
537
 
}
538
 
 
539
 
FLAC_API const char *FLAC__seekable_stream_encoder_get_resolved_state_string(const FLAC__SeekableStreamEncoder *encoder)
540
 
{
541
 
        if(encoder->protected_->state != FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR)
542
 
                return FLAC__SeekableStreamEncoderStateString[encoder->protected_->state];
543
 
        else
544
 
                return FLAC__stream_encoder_get_resolved_state_string(encoder->private_->stream_encoder);
545
 
}
546
 
 
547
 
FLAC_API void FLAC__seekable_stream_encoder_get_verify_decoder_error_stats(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
548
 
{
549
 
        FLAC__ASSERT(0 != encoder);
550
 
        FLAC__ASSERT(0 != encoder->private_);
551
 
        FLAC__stream_encoder_get_verify_decoder_error_stats(encoder->private_->stream_encoder, absolute_sample, frame_number, channel, sample, expected, got);
552
 
}
553
 
 
554
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_verify(const FLAC__SeekableStreamEncoder *encoder)
555
 
{
556
 
        FLAC__ASSERT(0 != encoder);
557
 
        FLAC__ASSERT(0 != encoder->private_);
558
 
        return FLAC__stream_encoder_get_verify(encoder->private_->stream_encoder);
559
 
}
560
 
 
561
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_streamable_subset(const FLAC__SeekableStreamEncoder *encoder)
562
 
{
563
 
        FLAC__ASSERT(0 != encoder);
564
 
        FLAC__ASSERT(0 != encoder->private_);
565
 
        return FLAC__stream_encoder_get_streamable_subset(encoder->private_->stream_encoder);
566
 
}
567
 
 
568
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_do_mid_side_stereo(const FLAC__SeekableStreamEncoder *encoder)
569
 
{
570
 
        FLAC__ASSERT(0 != encoder);
571
 
        FLAC__ASSERT(0 != encoder->private_);
572
 
        return FLAC__stream_encoder_get_do_mid_side_stereo(encoder->private_->stream_encoder);
573
 
}
574
 
 
575
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_loose_mid_side_stereo(const FLAC__SeekableStreamEncoder *encoder)
576
 
{
577
 
        FLAC__ASSERT(0 != encoder);
578
 
        FLAC__ASSERT(0 != encoder->private_);
579
 
        return FLAC__stream_encoder_get_loose_mid_side_stereo(encoder->private_->stream_encoder);
580
 
}
581
 
 
582
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_channels(const FLAC__SeekableStreamEncoder *encoder)
583
 
{
584
 
        FLAC__ASSERT(0 != encoder);
585
 
        FLAC__ASSERT(0 != encoder->private_);
586
 
        return FLAC__stream_encoder_get_channels(encoder->private_->stream_encoder);
587
 
}
588
 
 
589
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_bits_per_sample(const FLAC__SeekableStreamEncoder *encoder)
590
 
{
591
 
        FLAC__ASSERT(0 != encoder);
592
 
        FLAC__ASSERT(0 != encoder->private_);
593
 
        return FLAC__stream_encoder_get_bits_per_sample(encoder->private_->stream_encoder);
594
 
}
595
 
 
596
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_sample_rate(const FLAC__SeekableStreamEncoder *encoder)
597
 
{
598
 
        FLAC__ASSERT(0 != encoder);
599
 
        FLAC__ASSERT(0 != encoder->private_);
600
 
        return FLAC__stream_encoder_get_sample_rate(encoder->private_->stream_encoder);
601
 
}
602
 
 
603
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_blocksize(const FLAC__SeekableStreamEncoder *encoder)
604
 
{
605
 
        FLAC__ASSERT(0 != encoder);
606
 
        FLAC__ASSERT(0 != encoder->private_);
607
 
        return FLAC__stream_encoder_get_blocksize(encoder->private_->stream_encoder);
608
 
}
609
 
 
610
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_max_lpc_order(const FLAC__SeekableStreamEncoder *encoder)
611
 
{
612
 
        FLAC__ASSERT(0 != encoder);
613
 
        FLAC__ASSERT(0 != encoder->private_);
614
 
        return FLAC__stream_encoder_get_max_lpc_order(encoder->private_->stream_encoder);
615
 
}
616
 
 
617
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_qlp_coeff_precision(const FLAC__SeekableStreamEncoder *encoder)
618
 
{
619
 
        FLAC__ASSERT(0 != encoder);
620
 
        FLAC__ASSERT(0 != encoder->private_);
621
 
        return FLAC__stream_encoder_get_qlp_coeff_precision(encoder->private_->stream_encoder);
622
 
}
623
 
 
624
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__SeekableStreamEncoder *encoder)
625
 
{
626
 
        FLAC__ASSERT(0 != encoder);
627
 
        FLAC__ASSERT(0 != encoder->private_);
628
 
        return FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder->private_->stream_encoder);
629
 
}
630
 
 
631
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_do_escape_coding(const FLAC__SeekableStreamEncoder *encoder)
632
 
{
633
 
        FLAC__ASSERT(0 != encoder);
634
 
        FLAC__ASSERT(0 != encoder->private_);
635
 
        return FLAC__stream_encoder_get_do_escape_coding(encoder->private_->stream_encoder);
636
 
}
637
 
 
638
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_get_do_exhaustive_model_search(const FLAC__SeekableStreamEncoder *encoder)
639
 
{
640
 
        FLAC__ASSERT(0 != encoder);
641
 
        FLAC__ASSERT(0 != encoder->private_);
642
 
        return FLAC__stream_encoder_get_do_exhaustive_model_search(encoder->private_->stream_encoder);
643
 
}
644
 
 
645
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_min_residual_partition_order(const FLAC__SeekableStreamEncoder *encoder)
646
 
{
647
 
        FLAC__ASSERT(0 != encoder);
648
 
        FLAC__ASSERT(0 != encoder->private_);
649
 
        return FLAC__stream_encoder_get_min_residual_partition_order(encoder->private_->stream_encoder);
650
 
}
651
 
 
652
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_max_residual_partition_order(const FLAC__SeekableStreamEncoder *encoder)
653
 
{
654
 
        FLAC__ASSERT(0 != encoder);
655
 
        FLAC__ASSERT(0 != encoder->private_);
656
 
        return FLAC__stream_encoder_get_max_residual_partition_order(encoder->private_->stream_encoder);
657
 
}
658
 
 
659
 
FLAC_API unsigned FLAC__seekable_stream_encoder_get_rice_parameter_search_dist(const FLAC__SeekableStreamEncoder *encoder)
660
 
{
661
 
        FLAC__ASSERT(0 != encoder);
662
 
        FLAC__ASSERT(0 != encoder->private_);
663
 
        return FLAC__stream_encoder_get_rice_parameter_search_dist(encoder->private_->stream_encoder);
664
 
}
665
 
 
666
 
FLAC_API FLAC__uint64 FLAC__seekable_stream_encoder_get_total_samples_estimate(const FLAC__SeekableStreamEncoder *encoder)
667
 
{
668
 
        FLAC__ASSERT(0 != encoder);
669
 
        FLAC__ASSERT(0 != encoder->private_);
670
 
        return FLAC__stream_encoder_get_total_samples_estimate(encoder->private_->stream_encoder);
671
 
}
672
 
 
673
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_process(FLAC__SeekableStreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
674
 
{
675
 
        FLAC__ASSERT(0 != encoder);
676
 
        FLAC__ASSERT(0 != encoder->private_);
677
 
        if(!FLAC__stream_encoder_process(encoder->private_->stream_encoder, buffer, samples)) {
678
 
                encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR;
679
 
                return false;
680
 
        }
681
 
        else
682
 
                return true;
683
 
}
684
 
 
685
 
/* 'samples' is channel-wide samples, e.g. for 1 second at 44100Hz, 'samples' = 44100 regardless of the number of channels */
686
 
FLAC_API FLAC__bool FLAC__seekable_stream_encoder_process_interleaved(FLAC__SeekableStreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
687
 
{
688
 
        FLAC__ASSERT(0 != encoder);
689
 
        FLAC__ASSERT(0 != encoder->private_);
690
 
        if(!FLAC__stream_encoder_process_interleaved(encoder->private_->stream_encoder, buffer, samples)) {
691
 
                encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR;
692
 
                return false;
693
 
        }
694
 
        else
695
 
                return true;
696
 
}
697
 
 
698
 
/***********************************************************************
699
 
 *
700
 
 * Private class methods
701
 
 *
702
 
 ***********************************************************************/
703
 
 
704
 
void set_defaults_(FLAC__SeekableStreamEncoder *encoder)
705
 
{
706
 
        FLAC__ASSERT(0 != encoder);
707
 
        FLAC__ASSERT(0 != encoder->private_);
708
 
        FLAC__ASSERT(0 != encoder->protected_);
709
 
 
710
 
        encoder->private_->seek_callback = 0;
711
 
        encoder->private_->tell_callback = 0;
712
 
        encoder->private_->write_callback = 0;
713
 
        encoder->private_->client_data = 0;
714
 
 
715
 
        encoder->private_->seek_table = 0;
716
 
}
717
 
 
718
 
FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *unused, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
719
 
{
720
 
        FLAC__SeekableStreamEncoder *encoder = (FLAC__SeekableStreamEncoder*)client_data;
721
 
        FLAC__StreamEncoderWriteStatus status;
722
 
        FLAC__uint64 output_position;
723
 
 
724
 
        (void)unused; /* silence compiler warning about unused parameter */
725
 
        FLAC__ASSERT(encoder->private_->stream_encoder == unused);
726
 
 
727
 
        if(encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK)
728
 
                return encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_TELL_ERROR;
729
 
 
730
 
        /*
731
 
         * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets.
732
 
         */
733
 
        if(samples == 0) {
734
 
                FLAC__MetadataType type = (buffer[0] & 0x7f);
735
 
                if(type == FLAC__METADATA_TYPE_STREAMINFO)
736
 
                        encoder->protected_->streaminfo_offset = output_position;
737
 
                else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0)
738
 
                        encoder->protected_->seektable_offset = output_position;
739
 
        }
740
 
 
741
 
        /*
742
 
         * Mark the current seek point if hit (if audio_offset == 0 that
743
 
         * means we're still writing metadata and haven't hit the first
744
 
         * frame yet)
745
 
         */
746
 
        if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) {
747
 
                const unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder->private_->stream_encoder);
748
 
                const FLAC__uint64 frame_first_sample = encoder->private_->samples_written;
749
 
                const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1;
750
 
                FLAC__uint64 test_sample;
751
 
                unsigned i;
752
 
                for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) {
753
 
                        test_sample = encoder->private_->seek_table->points[i].sample_number;
754
 
                        if(test_sample > frame_last_sample) {
755
 
                                break;
756
 
                        }
757
 
                        else if(test_sample >= frame_first_sample) {
758
 
                                encoder->private_->seek_table->points[i].sample_number = frame_first_sample;
759
 
                                encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset;
760
 
                                encoder->private_->seek_table->points[i].frame_samples = blocksize;
761
 
                                encoder->private_->first_seekpoint_to_check++;
762
 
                                /* DO NOT: "break;" and here's why:
763
 
                                 * The seektable template may contain more than one target
764
 
                                 * sample for any given frame; we will keep looping, generating
765
 
                                 * duplicate seekpoints for them, and we'll clean it up later,
766
 
                                 * just before writing the seektable back to the metadata.
767
 
                                 */
768
 
                        }
769
 
                        else {
770
 
                                encoder->private_->first_seekpoint_to_check++;
771
 
                        }
772
 
                }
773
 
        }
774
 
 
775
 
        status = encoder->private_->write_callback(encoder, buffer, bytes, samples, current_frame, encoder->private_->client_data);
776
 
 
777
 
        if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
778
 
                encoder->private_->samples_written += samples;
779
 
        }
780
 
        else
781
 
                encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR;
782
 
 
783
 
        return status;
784
 
}
785
 
 
786
 
void metadata_callback_(const FLAC__StreamEncoder *unused, const FLAC__StreamMetadata *metadata, void *client_data)
787
 
{
788
 
        FLAC__SeekableStreamEncoder *encoder = (FLAC__SeekableStreamEncoder*)client_data;
789
 
        FLAC__byte b[max(6, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)];
790
 
        const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
791
 
        const unsigned min_framesize = metadata->data.stream_info.min_framesize;
792
 
        const unsigned max_framesize = metadata->data.stream_info.max_framesize;
793
 
        const unsigned bps = metadata->data.stream_info.bits_per_sample;
794
 
 
795
 
        FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO);
796
 
 
797
 
        /* We get called by the stream encoder when the encoding process
798
 
         * has finished so that we can update the STREAMINFO and SEEKTABLE
799
 
         * blocks.
800
 
         */
801
 
 
802
 
        (void)unused; /* silence compiler warning about unused parameter */
803
 
        FLAC__ASSERT(encoder->private_->stream_encoder == unused);
804
 
 
805
 
        /*@@@ reopen callback here?  The docs currently require user to open files in update mode from the start */
806
 
 
807
 
        /* All this is based on intimate knowledge of the stream header
808
 
         * layout, but a change to the header format that would break this
809
 
         * would also break all streams encoded in the previous format.
810
 
         */
811
 
 
812
 
        /*
813
 
         * Write MD5 signature
814
 
         */
815
 
        {
816
 
                const unsigned md5_offset =
817
 
                FLAC__STREAM_METADATA_HEADER_LENGTH +
818
 
                (
819
 
                        FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
820
 
                        FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
821
 
                        FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
822
 
                        FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
823
 
                        FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
824
 
                        FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
825
 
                        FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN +
826
 
                        FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
827
 
                ) / 8;
828
 
 
829
 
                if(encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK) {
830
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR;
831
 
                        return;
832
 
                }
833
 
                if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
834
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR;
835
 
                        return;
836
 
                }
837
 
        }
838
 
 
839
 
        /*
840
 
         * Write total samples
841
 
         */
842
 
        {
843
 
                const unsigned total_samples_byte_offset =
844
 
                FLAC__STREAM_METADATA_HEADER_LENGTH +
845
 
                (
846
 
                        FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
847
 
                        FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN +
848
 
                        FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN +
849
 
                        FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN +
850
 
                        FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN +
851
 
                        FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN +
852
 
                        FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
853
 
                        - 4
854
 
                ) / 8;
855
 
 
856
 
                b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples >> 32) & 0x0F);
857
 
                b[1] = (FLAC__byte)((samples >> 24) & 0xFF);
858
 
                b[2] = (FLAC__byte)((samples >> 16) & 0xFF);
859
 
                b[3] = (FLAC__byte)((samples >> 8) & 0xFF);
860
 
                b[4] = (FLAC__byte)(samples & 0xFF);
861
 
                if(encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + total_samples_byte_offset, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK) {
862
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR;
863
 
                        return;
864
 
                }
865
 
                if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
866
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR;
867
 
                        return;
868
 
                }
869
 
        }
870
 
 
871
 
        /*
872
 
         * Write min/max framesize
873
 
         */
874
 
        {
875
 
                const unsigned min_framesize_offset =
876
 
                FLAC__STREAM_METADATA_HEADER_LENGTH +
877
 
                (
878
 
                        FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN +
879
 
                        FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
880
 
                ) / 8;
881
 
 
882
 
                b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF);
883
 
                b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF);
884
 
                b[2] = (FLAC__byte)(min_framesize & 0xFF);
885
 
                b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF);
886
 
                b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF);
887
 
                b[5] = (FLAC__byte)(max_framesize & 0xFF);
888
 
                if(encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + min_framesize_offset, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK) {
889
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR;
890
 
                        return;
891
 
                }
892
 
                if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
893
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR;
894
 
                        return;
895
 
                }
896
 
        }
897
 
 
898
 
        /*
899
 
         * Write seektable
900
 
         */
901
 
        if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
902
 
                unsigned i;
903
 
 
904
 
                FLAC__format_seektable_sort(encoder->private_->seek_table);
905
 
 
906
 
                FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
907
 
 
908
 
                if(encoder->private_->seek_callback(encoder, encoder->protected_->seektable_offset + FLAC__STREAM_METADATA_HEADER_LENGTH, encoder->private_->client_data) != FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK) {
909
 
                        encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR;
910
 
                        return;
911
 
                }
912
 
 
913
 
                for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
914
 
                        FLAC__uint64 xx;
915
 
                        unsigned x;
916
 
                        xx = encoder->private_->seek_table->points[i].sample_number;
917
 
                        b[7] = (FLAC__byte)xx; xx >>= 8;
918
 
                        b[6] = (FLAC__byte)xx; xx >>= 8;
919
 
                        b[5] = (FLAC__byte)xx; xx >>= 8;
920
 
                        b[4] = (FLAC__byte)xx; xx >>= 8;
921
 
                        b[3] = (FLAC__byte)xx; xx >>= 8;
922
 
                        b[2] = (FLAC__byte)xx; xx >>= 8;
923
 
                        b[1] = (FLAC__byte)xx; xx >>= 8;
924
 
                        b[0] = (FLAC__byte)xx; xx >>= 8;
925
 
                        xx = encoder->private_->seek_table->points[i].stream_offset;
926
 
                        b[15] = (FLAC__byte)xx; xx >>= 8;
927
 
                        b[14] = (FLAC__byte)xx; xx >>= 8;
928
 
                        b[13] = (FLAC__byte)xx; xx >>= 8;
929
 
                        b[12] = (FLAC__byte)xx; xx >>= 8;
930
 
                        b[11] = (FLAC__byte)xx; xx >>= 8;
931
 
                        b[10] = (FLAC__byte)xx; xx >>= 8;
932
 
                        b[9] = (FLAC__byte)xx; xx >>= 8;
933
 
                        b[8] = (FLAC__byte)xx; xx >>= 8;
934
 
                        x = encoder->private_->seek_table->points[i].frame_samples;
935
 
                        b[17] = (FLAC__byte)x; x >>= 8;
936
 
                        b[16] = (FLAC__byte)x; x >>= 8;
937
 
                        if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
938
 
                                encoder->protected_->state = FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR;
939
 
                                return;
940
 
                        }
941
 
                }
942
 
        }
943
 
}