← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/libOggFLAC/stream_encoder.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/libOggFLAC/stream_encoder.c
1
 
/* libOggFLAC - Free Lossless Audio Codec + Ogg 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 "FLAC/assert.h"
35
 
#include "OggFLAC/stream_encoder.h"
36
 
#include "protected/stream_encoder.h"
37
 
 
38
 
/***********************************************************************
39
 
 *
40
 
 * Private class method prototypes
41
 
 *
42
 
 ***********************************************************************/
43
 
 
44
 
/* unpublished debug routines */
45
 
extern FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
46
 
extern FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
47
 
extern FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value);
48
 
 
49
 
static void set_defaults_(OggFLAC__StreamEncoder *encoder);
50
 
static FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
51
 
static void metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data);
52
 
 
53
 
 
54
 
/***********************************************************************
55
 
 *
56
 
 * Private class data
57
 
 *
58
 
 ***********************************************************************/
59
 
 
60
 
typedef struct OggFLAC__StreamEncoderPrivate {
61
 
        OggFLAC__StreamEncoderWriteCallback write_callback;
62
 
        OggFLAC__StreamEncoderMetadataCallback metadata_callback;
63
 
        void *client_data;
64
 
        FLAC__StreamEncoder *FLAC_stream_encoder;
65
 
} OggFLAC__StreamEncoderPrivate;
66
 
 
67
 
 
68
 
/***********************************************************************
69
 
 *
70
 
 * Public static class data
71
 
 *
72
 
 ***********************************************************************/
73
 
 
74
 
OggFLAC_API const char * const OggFLAC__StreamEncoderStateString[] = {
75
 
        "OggFLAC__STREAM_ENCODER_OK",
76
 
        "OggFLAC__STREAM_ENCODER_OGG_ERROR",
77
 
        "OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR",
78
 
        "OggFLAC__STREAM_ENCODER_INVALID_CALLBACK",
79
 
        "OggFLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR",
80
 
        "OggFLAC__STREAM_ENCODER_ALREADY_INITIALIZED",
81
 
        "OggFLAC__STREAM_ENCODER_UNINITIALIZED"
82
 
};
83
 
 
84
 
 
85
 
/***********************************************************************
86
 
 *
87
 
 * Class constructor/destructor
88
 
 *
89
 
 */
90
 
OggFLAC_API OggFLAC__StreamEncoder *OggFLAC__stream_encoder_new()
91
 
{
92
 
        OggFLAC__StreamEncoder *encoder;
93
 
 
94
 
        encoder = (OggFLAC__StreamEncoder*)calloc(1, sizeof(OggFLAC__StreamEncoder));
95
 
        if(encoder == 0) {
96
 
                return 0;
97
 
        }
98
 
 
99
 
        encoder->protected_ = (OggFLAC__StreamEncoderProtected*)calloc(1, sizeof(OggFLAC__StreamEncoderProtected));
100
 
        if(encoder->protected_ == 0) {
101
 
                free(encoder);
102
 
                return 0;
103
 
        }
104
 
 
105
 
        encoder->private_ = (OggFLAC__StreamEncoderPrivate*)calloc(1, sizeof(OggFLAC__StreamEncoderPrivate));
106
 
        if(encoder->private_ == 0) {
107
 
                free(encoder->protected_);
108
 
                free(encoder);
109
 
                return 0;
110
 
        }
111
 
 
112
 
        encoder->private_->FLAC_stream_encoder = FLAC__stream_encoder_new();
113
 
        if(0 == encoder->private_->FLAC_stream_encoder) {
114
 
                free(encoder->private_);
115
 
                free(encoder->protected_);
116
 
                free(encoder);
117
 
                return 0;
118
 
        }
119
 
 
120
 
        set_defaults_(encoder);
121
 
 
122
 
        encoder->protected_->state = OggFLAC__STREAM_ENCODER_UNINITIALIZED;
123
 
 
124
 
        return encoder;
125
 
}
126
 
 
127
 
OggFLAC_API void OggFLAC__stream_encoder_delete(OggFLAC__StreamEncoder *encoder)
128
 
{
129
 
        FLAC__ASSERT(0 != encoder);
130
 
        FLAC__ASSERT(0 != encoder->protected_);
131
 
        FLAC__ASSERT(0 != encoder->private_);
132
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
133
 
 
134
 
        (void)OggFLAC__stream_encoder_finish(encoder);
135
 
 
136
 
        FLAC__stream_encoder_delete(encoder->private_->FLAC_stream_encoder);
137
 
 
138
 
        free(encoder->private_);
139
 
        free(encoder->protected_);
140
 
        free(encoder);
141
 
}
142
 
 
143
 
 
144
 
/***********************************************************************
145
 
 *
146
 
 * Public class methods
147
 
 *
148
 
 ***********************************************************************/
149
 
 
150
 
OggFLAC_API OggFLAC__StreamEncoderState OggFLAC__stream_encoder_init(OggFLAC__StreamEncoder *encoder)
151
 
{
152
 
        FLAC__ASSERT(0 != encoder);
153
 
 
154
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
155
 
                return encoder->protected_->state = OggFLAC__STREAM_ENCODER_ALREADY_INITIALIZED;
156
 
 
157
 
        if(0 == encoder->private_->write_callback || 0 == encoder->private_->metadata_callback)
158
 
                return encoder->protected_->state = OggFLAC__STREAM_ENCODER_INVALID_CALLBACK;
159
 
 
160
 
        if(!OggFLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect))
161
 
                        return encoder->protected_->state = OggFLAC__STREAM_ENCODER_OGG_ERROR;
162
 
 
163
 
        FLAC__stream_encoder_set_write_callback(encoder->private_->FLAC_stream_encoder, write_callback_);
164
 
        FLAC__stream_encoder_set_metadata_callback(encoder->private_->FLAC_stream_encoder, metadata_callback_);
165
 
        FLAC__stream_encoder_set_client_data(encoder->private_->FLAC_stream_encoder, encoder);
166
 
 
167
 
        if(FLAC__stream_encoder_init(encoder->private_->FLAC_stream_encoder) != FLAC__STREAM_ENCODER_OK)
168
 
                return encoder->protected_->state = OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR;
169
 
 
170
 
        return encoder->protected_->state = OggFLAC__STREAM_ENCODER_OK;
171
 
}
172
 
 
173
 
OggFLAC_API void OggFLAC__stream_encoder_finish(OggFLAC__StreamEncoder *encoder)
174
 
{
175
 
        FLAC__ASSERT(0 != encoder);
176
 
        FLAC__ASSERT(0 != encoder->private_);
177
 
        FLAC__ASSERT(0 != encoder->protected_);
178
 
 
179
 
        if(encoder->protected_->state == OggFLAC__STREAM_ENCODER_UNINITIALIZED)
180
 
                return;
181
 
 
182
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
183
 
 
184
 
        FLAC__stream_encoder_finish(encoder->private_->FLAC_stream_encoder);
185
 
 
186
 
        OggFLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
187
 
 
188
 
        set_defaults_(encoder);
189
 
 
190
 
        encoder->protected_->state = OggFLAC__STREAM_ENCODER_UNINITIALIZED;
191
 
}
192
 
 
193
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_serial_number(OggFLAC__StreamEncoder *encoder, long value)
194
 
{
195
 
        FLAC__ASSERT(0 != encoder);
196
 
        FLAC__ASSERT(0 != encoder->private_);
197
 
        FLAC__ASSERT(0 != encoder->protected_);
198
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
199
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
200
 
                return false;
201
 
        OggFLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value);
202
 
        return true;
203
 
}
204
 
 
205
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_verify(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
206
 
{
207
 
        FLAC__ASSERT(0 != encoder);
208
 
        FLAC__ASSERT(0 != encoder->private_);
209
 
        FLAC__ASSERT(0 != encoder->protected_);
210
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
211
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
212
 
                return false;
213
 
        return FLAC__stream_encoder_set_verify(encoder->private_->FLAC_stream_encoder, value);
214
 
}
215
 
 
216
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_streamable_subset(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
217
 
{
218
 
        FLAC__ASSERT(0 != encoder);
219
 
        FLAC__ASSERT(0 != encoder->private_);
220
 
        FLAC__ASSERT(0 != encoder->protected_);
221
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
222
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
223
 
                return false;
224
 
        return FLAC__stream_encoder_set_streamable_subset(encoder->private_->FLAC_stream_encoder, value);
225
 
}
226
 
 
227
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_mid_side_stereo(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
228
 
{
229
 
        FLAC__ASSERT(0 != encoder);
230
 
        FLAC__ASSERT(0 != encoder->private_);
231
 
        FLAC__ASSERT(0 != encoder->protected_);
232
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
233
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
234
 
                return false;
235
 
        return FLAC__stream_encoder_set_do_mid_side_stereo(encoder->private_->FLAC_stream_encoder, value);
236
 
}
237
 
 
238
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_loose_mid_side_stereo(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
239
 
{
240
 
        FLAC__ASSERT(0 != encoder);
241
 
        FLAC__ASSERT(0 != encoder->private_);
242
 
        FLAC__ASSERT(0 != encoder->protected_);
243
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
244
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
245
 
                return false;
246
 
        return FLAC__stream_encoder_set_loose_mid_side_stereo(encoder->private_->FLAC_stream_encoder, value);
247
 
}
248
 
 
249
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_channels(OggFLAC__StreamEncoder *encoder, unsigned value)
250
 
{
251
 
        FLAC__ASSERT(0 != encoder);
252
 
        FLAC__ASSERT(0 != encoder->private_);
253
 
        FLAC__ASSERT(0 != encoder->protected_);
254
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
255
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
256
 
                return false;
257
 
        return FLAC__stream_encoder_set_channels(encoder->private_->FLAC_stream_encoder, value);
258
 
}
259
 
 
260
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_bits_per_sample(OggFLAC__StreamEncoder *encoder, unsigned value)
261
 
{
262
 
        FLAC__ASSERT(0 != encoder);
263
 
        FLAC__ASSERT(0 != encoder->private_);
264
 
        FLAC__ASSERT(0 != encoder->protected_);
265
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
266
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
267
 
                return false;
268
 
        return FLAC__stream_encoder_set_bits_per_sample(encoder->private_->FLAC_stream_encoder, value);
269
 
}
270
 
 
271
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_sample_rate(OggFLAC__StreamEncoder *encoder, unsigned value)
272
 
{
273
 
        FLAC__ASSERT(0 != encoder);
274
 
        FLAC__ASSERT(0 != encoder->private_);
275
 
        FLAC__ASSERT(0 != encoder->protected_);
276
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
277
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
278
 
                return false;
279
 
        return FLAC__stream_encoder_set_sample_rate(encoder->private_->FLAC_stream_encoder, value);
280
 
}
281
 
 
282
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_blocksize(OggFLAC__StreamEncoder *encoder, unsigned value)
283
 
{
284
 
        FLAC__ASSERT(0 != encoder);
285
 
        FLAC__ASSERT(0 != encoder->private_);
286
 
        FLAC__ASSERT(0 != encoder->protected_);
287
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
288
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
289
 
                return false;
290
 
        return FLAC__stream_encoder_set_blocksize(encoder->private_->FLAC_stream_encoder, value);
291
 
}
292
 
 
293
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_max_lpc_order(OggFLAC__StreamEncoder *encoder, unsigned value)
294
 
{
295
 
        FLAC__ASSERT(0 != encoder);
296
 
        FLAC__ASSERT(0 != encoder->private_);
297
 
        FLAC__ASSERT(0 != encoder->protected_);
298
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
299
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
300
 
                return false;
301
 
        return FLAC__stream_encoder_set_max_lpc_order(encoder->private_->FLAC_stream_encoder, value);
302
 
}
303
 
 
304
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_qlp_coeff_precision(OggFLAC__StreamEncoder *encoder, unsigned value)
305
 
{
306
 
        FLAC__ASSERT(0 != encoder);
307
 
        FLAC__ASSERT(0 != encoder->private_);
308
 
        FLAC__ASSERT(0 != encoder->protected_);
309
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
310
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
311
 
                return false;
312
 
        return FLAC__stream_encoder_set_qlp_coeff_precision(encoder->private_->FLAC_stream_encoder, value);
313
 
}
314
 
 
315
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
316
 
{
317
 
        FLAC__ASSERT(0 != encoder);
318
 
        FLAC__ASSERT(0 != encoder->private_);
319
 
        FLAC__ASSERT(0 != encoder->protected_);
320
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
321
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
322
 
                return false;
323
 
        return FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder->private_->FLAC_stream_encoder, value);
324
 
}
325
 
 
326
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_escape_coding(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
327
 
{
328
 
        FLAC__ASSERT(0 != encoder);
329
 
        FLAC__ASSERT(0 != encoder->private_);
330
 
        FLAC__ASSERT(0 != encoder->protected_);
331
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
332
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
333
 
                return false;
334
 
        return FLAC__stream_encoder_set_do_escape_coding(encoder->private_->FLAC_stream_encoder, value);
335
 
}
336
 
 
337
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_do_exhaustive_model_search(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
338
 
{
339
 
        FLAC__ASSERT(0 != encoder);
340
 
        FLAC__ASSERT(0 != encoder->private_);
341
 
        FLAC__ASSERT(0 != encoder->protected_);
342
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
343
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
344
 
                return false;
345
 
        return FLAC__stream_encoder_set_do_exhaustive_model_search(encoder->private_->FLAC_stream_encoder, value);
346
 
}
347
 
 
348
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_min_residual_partition_order(OggFLAC__StreamEncoder *encoder, unsigned value)
349
 
{
350
 
        FLAC__ASSERT(0 != encoder);
351
 
        FLAC__ASSERT(0 != encoder->private_);
352
 
        FLAC__ASSERT(0 != encoder->protected_);
353
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
354
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
355
 
                return false;
356
 
        return FLAC__stream_encoder_set_min_residual_partition_order(encoder->private_->FLAC_stream_encoder, value);
357
 
}
358
 
 
359
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_max_residual_partition_order(OggFLAC__StreamEncoder *encoder, unsigned value)
360
 
{
361
 
        FLAC__ASSERT(0 != encoder);
362
 
        FLAC__ASSERT(0 != encoder->private_);
363
 
        FLAC__ASSERT(0 != encoder->protected_);
364
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
365
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
366
 
                return false;
367
 
        return FLAC__stream_encoder_set_max_residual_partition_order(encoder->private_->FLAC_stream_encoder, value);
368
 
}
369
 
 
370
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_rice_parameter_search_dist(OggFLAC__StreamEncoder *encoder, unsigned value)
371
 
{
372
 
        FLAC__ASSERT(0 != encoder);
373
 
        FLAC__ASSERT(0 != encoder->private_);
374
 
        FLAC__ASSERT(0 != encoder->protected_);
375
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
376
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
377
 
                return false;
378
 
        return FLAC__stream_encoder_set_rice_parameter_search_dist(encoder->private_->FLAC_stream_encoder, value);
379
 
}
380
 
 
381
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_total_samples_estimate(OggFLAC__StreamEncoder *encoder, FLAC__uint64 value)
382
 
{
383
 
        FLAC__ASSERT(0 != encoder);
384
 
        FLAC__ASSERT(0 != encoder->private_);
385
 
        FLAC__ASSERT(0 != encoder->protected_);
386
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
387
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
388
 
                return false;
389
 
        return FLAC__stream_encoder_set_total_samples_estimate(encoder->private_->FLAC_stream_encoder, value);
390
 
}
391
 
 
392
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_metadata(OggFLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
393
 
{
394
 
        FLAC__ASSERT(0 != encoder);
395
 
        FLAC__ASSERT(0 != encoder->private_);
396
 
        FLAC__ASSERT(0 != encoder->protected_);
397
 
        FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder);
398
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
399
 
                return false;
400
 
        /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
401
 
        if(0 != metadata && num_blocks > 1) {
402
 
                unsigned i;
403
 
                for(i = 1; i < num_blocks; i++) {
404
 
                        if(0 != metadata[i] && metadata[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
405
 
                                FLAC__StreamMetadata *vc = metadata[i];
406
 
                                for( ; i > 0; i--)
407
 
                                        metadata[i] = metadata[i-1];
408
 
                                metadata[0] = vc;
409
 
                                break;
410
 
                        }
411
 
                }
412
 
        }
413
 
        if(!OggFLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
414
 
                return false;
415
 
        return FLAC__stream_encoder_set_metadata(encoder->private_->FLAC_stream_encoder, metadata, num_blocks);
416
 
}
417
 
 
418
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_write_callback(OggFLAC__StreamEncoder *encoder, OggFLAC__StreamEncoderWriteCallback value)
419
 
{
420
 
        FLAC__ASSERT(0 != encoder);
421
 
        FLAC__ASSERT(0 != encoder->private_);
422
 
        FLAC__ASSERT(0 != encoder->protected_);
423
 
        FLAC__ASSERT(0 != value);
424
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
425
 
                return false;
426
 
        encoder->private_->write_callback = value;
427
 
        return true;
428
 
}
429
 
 
430
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_metadata_callback(OggFLAC__StreamEncoder *encoder, OggFLAC__StreamEncoderMetadataCallback value)
431
 
{
432
 
        FLAC__ASSERT(0 != encoder);
433
 
        FLAC__ASSERT(0 != encoder->private_);
434
 
        FLAC__ASSERT(0 != encoder->protected_);
435
 
        FLAC__ASSERT(0 != value);
436
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
437
 
                return false;
438
 
        encoder->private_->metadata_callback = value;
439
 
        return true;
440
 
}
441
 
 
442
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_set_client_data(OggFLAC__StreamEncoder *encoder, void *value)
443
 
{
444
 
        FLAC__ASSERT(0 != encoder);
445
 
        FLAC__ASSERT(0 != encoder->private_);
446
 
        FLAC__ASSERT(0 != encoder->protected_);
447
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
448
 
                return false;
449
 
        encoder->private_->client_data = value;
450
 
        return true;
451
 
}
452
 
 
453
 
/*
454
 
 * These three functions are not static, but not publically exposed in
455
 
 * include/FLAC/ either.  They are used by the test suite.
456
 
 */
457
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_constant_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
458
 
{
459
 
        FLAC__ASSERT(0 != encoder);
460
 
        FLAC__ASSERT(0 != encoder->private_);
461
 
        FLAC__ASSERT(0 != encoder->protected_);
462
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
463
 
                return false;
464
 
        return FLAC__stream_encoder_disable_constant_subframes(encoder->private_->FLAC_stream_encoder, value);
465
 
}
466
 
 
467
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_fixed_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
468
 
{
469
 
        FLAC__ASSERT(0 != encoder);
470
 
        FLAC__ASSERT(0 != encoder->private_);
471
 
        FLAC__ASSERT(0 != encoder->protected_);
472
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
473
 
                return false;
474
 
        return FLAC__stream_encoder_disable_fixed_subframes(encoder->private_->FLAC_stream_encoder, value);
475
 
}
476
 
 
477
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_disable_verbatim_subframes(OggFLAC__StreamEncoder *encoder, FLAC__bool value)
478
 
{
479
 
        FLAC__ASSERT(0 != encoder);
480
 
        FLAC__ASSERT(0 != encoder->private_);
481
 
        FLAC__ASSERT(0 != encoder->protected_);
482
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_UNINITIALIZED)
483
 
                return false;
484
 
        return FLAC__stream_encoder_disable_verbatim_subframes(encoder->private_->FLAC_stream_encoder, value);
485
 
}
486
 
 
487
 
OggFLAC_API OggFLAC__StreamEncoderState OggFLAC__stream_encoder_get_state(const OggFLAC__StreamEncoder *encoder)
488
 
{
489
 
        FLAC__ASSERT(0 != encoder);
490
 
        FLAC__ASSERT(0 != encoder->private_);
491
 
        FLAC__ASSERT(0 != encoder->protected_);
492
 
        return encoder->protected_->state;
493
 
}
494
 
 
495
 
OggFLAC_API FLAC__StreamEncoderState OggFLAC__stream_encoder_get_FLAC_stream_encoder_state(const OggFLAC__StreamEncoder *encoder)
496
 
{
497
 
        FLAC__ASSERT(0 != encoder);
498
 
        FLAC__ASSERT(0 != encoder->private_);
499
 
        FLAC__ASSERT(0 != encoder->protected_);
500
 
        return FLAC__stream_encoder_get_state(encoder->private_->FLAC_stream_encoder);
501
 
}
502
 
 
503
 
OggFLAC_API FLAC__StreamDecoderState OggFLAC__stream_encoder_get_verify_decoder_state(const OggFLAC__StreamEncoder *encoder)
504
 
{
505
 
        FLAC__ASSERT(0 != encoder);
506
 
        FLAC__ASSERT(0 != encoder->private_);
507
 
        FLAC__ASSERT(0 != encoder->protected_);
508
 
        return FLAC__stream_encoder_get_verify_decoder_state(encoder->private_->FLAC_stream_encoder);
509
 
}
510
 
 
511
 
OggFLAC_API const char *OggFLAC__stream_encoder_get_resolved_state_string(const OggFLAC__StreamEncoder *encoder)
512
 
{
513
 
        if(encoder->protected_->state != OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR)
514
 
                return OggFLAC__StreamEncoderStateString[encoder->protected_->state];
515
 
        else
516
 
                return FLAC__stream_encoder_get_resolved_state_string(encoder->private_->FLAC_stream_encoder);
517
 
}
518
 
 
519
 
OggFLAC_API void OggFLAC__stream_encoder_get_verify_decoder_error_stats(const OggFLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
520
 
{
521
 
        FLAC__ASSERT(0 != encoder);
522
 
        FLAC__ASSERT(0 != encoder->private_);
523
 
        FLAC__stream_encoder_get_verify_decoder_error_stats(encoder->private_->FLAC_stream_encoder, absolute_sample, frame_number, channel, sample, expected, got);
524
 
}
525
 
 
526
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_verify(const OggFLAC__StreamEncoder *encoder)
527
 
{
528
 
        FLAC__ASSERT(0 != encoder);
529
 
        FLAC__ASSERT(0 != encoder->private_);
530
 
        FLAC__ASSERT(0 != encoder->protected_);
531
 
        return FLAC__stream_encoder_get_verify(encoder->private_->FLAC_stream_encoder);
532
 
}
533
 
 
534
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_streamable_subset(const OggFLAC__StreamEncoder *encoder)
535
 
{
536
 
        FLAC__ASSERT(0 != encoder);
537
 
        FLAC__ASSERT(0 != encoder->private_);
538
 
        FLAC__ASSERT(0 != encoder->protected_);
539
 
        return FLAC__stream_encoder_get_streamable_subset(encoder->private_->FLAC_stream_encoder);
540
 
}
541
 
 
542
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_mid_side_stereo(const OggFLAC__StreamEncoder *encoder)
543
 
{
544
 
        FLAC__ASSERT(0 != encoder);
545
 
        FLAC__ASSERT(0 != encoder->private_);
546
 
        FLAC__ASSERT(0 != encoder->protected_);
547
 
        return FLAC__stream_encoder_get_do_mid_side_stereo(encoder->private_->FLAC_stream_encoder);
548
 
}
549
 
 
550
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_loose_mid_side_stereo(const OggFLAC__StreamEncoder *encoder)
551
 
{
552
 
        FLAC__ASSERT(0 != encoder);
553
 
        FLAC__ASSERT(0 != encoder->private_);
554
 
        FLAC__ASSERT(0 != encoder->protected_);
555
 
        return FLAC__stream_encoder_get_loose_mid_side_stereo(encoder->private_->FLAC_stream_encoder);
556
 
}
557
 
 
558
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_channels(const OggFLAC__StreamEncoder *encoder)
559
 
{
560
 
        FLAC__ASSERT(0 != encoder);
561
 
        FLAC__ASSERT(0 != encoder->private_);
562
 
        FLAC__ASSERT(0 != encoder->protected_);
563
 
        return FLAC__stream_encoder_get_channels(encoder->private_->FLAC_stream_encoder);
564
 
}
565
 
 
566
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_bits_per_sample(const OggFLAC__StreamEncoder *encoder)
567
 
{
568
 
        FLAC__ASSERT(0 != encoder);
569
 
        FLAC__ASSERT(0 != encoder->private_);
570
 
        FLAC__ASSERT(0 != encoder->protected_);
571
 
        return FLAC__stream_encoder_get_bits_per_sample(encoder->private_->FLAC_stream_encoder);
572
 
}
573
 
 
574
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_sample_rate(const OggFLAC__StreamEncoder *encoder)
575
 
{
576
 
        FLAC__ASSERT(0 != encoder);
577
 
        FLAC__ASSERT(0 != encoder->private_);
578
 
        FLAC__ASSERT(0 != encoder->protected_);
579
 
        return FLAC__stream_encoder_get_sample_rate(encoder->private_->FLAC_stream_encoder);
580
 
}
581
 
 
582
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_blocksize(const OggFLAC__StreamEncoder *encoder)
583
 
{
584
 
        FLAC__ASSERT(0 != encoder);
585
 
        FLAC__ASSERT(0 != encoder->private_);
586
 
        FLAC__ASSERT(0 != encoder->protected_);
587
 
        return FLAC__stream_encoder_get_blocksize(encoder->private_->FLAC_stream_encoder);
588
 
}
589
 
 
590
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_max_lpc_order(const OggFLAC__StreamEncoder *encoder)
591
 
{
592
 
        FLAC__ASSERT(0 != encoder);
593
 
        FLAC__ASSERT(0 != encoder->private_);
594
 
        FLAC__ASSERT(0 != encoder->protected_);
595
 
        return FLAC__stream_encoder_get_max_lpc_order(encoder->private_->FLAC_stream_encoder);
596
 
}
597
 
 
598
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_qlp_coeff_precision(const OggFLAC__StreamEncoder *encoder)
599
 
{
600
 
        FLAC__ASSERT(0 != encoder);
601
 
        FLAC__ASSERT(0 != encoder->private_);
602
 
        FLAC__ASSERT(0 != encoder->protected_);
603
 
        return FLAC__stream_encoder_get_qlp_coeff_precision(encoder->private_->FLAC_stream_encoder);
604
 
}
605
 
 
606
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_qlp_coeff_prec_search(const OggFLAC__StreamEncoder *encoder)
607
 
{
608
 
        FLAC__ASSERT(0 != encoder);
609
 
        FLAC__ASSERT(0 != encoder->private_);
610
 
        FLAC__ASSERT(0 != encoder->protected_);
611
 
        return FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder->private_->FLAC_stream_encoder);
612
 
}
613
 
 
614
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_escape_coding(const OggFLAC__StreamEncoder *encoder)
615
 
{
616
 
        FLAC__ASSERT(0 != encoder);
617
 
        FLAC__ASSERT(0 != encoder->private_);
618
 
        FLAC__ASSERT(0 != encoder->protected_);
619
 
        return FLAC__stream_encoder_get_do_escape_coding(encoder->private_->FLAC_stream_encoder);
620
 
}
621
 
 
622
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_get_do_exhaustive_model_search(const OggFLAC__StreamEncoder *encoder)
623
 
{
624
 
        FLAC__ASSERT(0 != encoder);
625
 
        FLAC__ASSERT(0 != encoder->private_);
626
 
        FLAC__ASSERT(0 != encoder->protected_);
627
 
        return FLAC__stream_encoder_get_do_exhaustive_model_search(encoder->private_->FLAC_stream_encoder);
628
 
}
629
 
 
630
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_min_residual_partition_order(const OggFLAC__StreamEncoder *encoder)
631
 
{
632
 
        FLAC__ASSERT(0 != encoder);
633
 
        FLAC__ASSERT(0 != encoder->private_);
634
 
        FLAC__ASSERT(0 != encoder->protected_);
635
 
        return FLAC__stream_encoder_get_min_residual_partition_order(encoder->private_->FLAC_stream_encoder);
636
 
}
637
 
 
638
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_max_residual_partition_order(const OggFLAC__StreamEncoder *encoder)
639
 
{
640
 
        FLAC__ASSERT(0 != encoder);
641
 
        FLAC__ASSERT(0 != encoder->private_);
642
 
        FLAC__ASSERT(0 != encoder->protected_);
643
 
        return FLAC__stream_encoder_get_max_residual_partition_order(encoder->private_->FLAC_stream_encoder);
644
 
}
645
 
 
646
 
OggFLAC_API unsigned OggFLAC__stream_encoder_get_rice_parameter_search_dist(const OggFLAC__StreamEncoder *encoder)
647
 
{
648
 
        FLAC__ASSERT(0 != encoder);
649
 
        FLAC__ASSERT(0 != encoder->private_);
650
 
        FLAC__ASSERT(0 != encoder->protected_);
651
 
        return FLAC__stream_encoder_get_rice_parameter_search_dist(encoder->private_->FLAC_stream_encoder);
652
 
}
653
 
 
654
 
OggFLAC_API FLAC__uint64 OggFLAC__stream_encoder_get_total_samples_estimate(const OggFLAC__StreamEncoder *encoder)
655
 
{
656
 
        FLAC__ASSERT(0 != encoder);
657
 
        FLAC__ASSERT(0 != encoder->private_);
658
 
        FLAC__ASSERT(0 != encoder->protected_);
659
 
        return FLAC__stream_encoder_get_total_samples_estimate(encoder->private_->FLAC_stream_encoder);
660
 
}
661
 
 
662
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_process(OggFLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
663
 
{
664
 
        FLAC__ASSERT(0 != encoder);
665
 
        FLAC__ASSERT(0 != encoder->private_);
666
 
        FLAC__ASSERT(0 != encoder->protected_);
667
 
        return FLAC__stream_encoder_process(encoder->private_->FLAC_stream_encoder, buffer, samples);
668
 
}
669
 
 
670
 
OggFLAC_API FLAC__bool OggFLAC__stream_encoder_process_interleaved(OggFLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
671
 
{
672
 
        FLAC__ASSERT(0 != encoder);
673
 
        FLAC__ASSERT(0 != encoder->private_);
674
 
        FLAC__ASSERT(0 != encoder->protected_);
675
 
        return FLAC__stream_encoder_process_interleaved(encoder->private_->FLAC_stream_encoder, buffer, samples);
676
 
}
677
 
 
678
 
/***********************************************************************
679
 
 *
680
 
 * Private class methods
681
 
 *
682
 
 ***********************************************************************/
683
 
 
684
 
void set_defaults_(OggFLAC__StreamEncoder *encoder)
685
 
{
686
 
        FLAC__ASSERT(0 != encoder);
687
 
 
688
 
        encoder->private_->write_callback = 0;
689
 
        encoder->private_->metadata_callback = 0;
690
 
        encoder->private_->client_data = 0;
691
 
        OggFLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
692
 
}
693
 
 
694
 
FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__StreamEncoder *unused, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
695
 
{
696
 
        OggFLAC__StreamEncoder *encoder = (OggFLAC__StreamEncoder*)client_data;
697
 
        const FLAC__uint64 total_samples_estimate = FLAC__stream_encoder_get_total_samples_estimate(encoder->private_->FLAC_stream_encoder);
698
 
 
699
 
        (void)unused;
700
 
        FLAC__ASSERT(encoder->private_->FLAC_stream_encoder == unused);
701
 
 
702
 
        return OggFLAC__ogg_encoder_aspect_write_callback_wrapper(&encoder->protected_->ogg_encoder_aspect, total_samples_estimate, buffer, bytes, samples, current_frame, (OggFLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback, encoder, encoder->private_->client_data);
703
 
}
704
 
 
705
 
void metadata_callback_(const FLAC__StreamEncoder *unused, const FLAC__StreamMetadata *metadata, void *client_data)
706
 
{
707
 
        OggFLAC__StreamEncoder *encoder = (OggFLAC__StreamEncoder*)client_data;
708
 
 
709
 
        (void)unused;
710
 
        FLAC__ASSERT(encoder->private_->FLAC_stream_encoder == unused);
711
 
 
712
 
        encoder->private_->metadata_callback(encoder, metadata, encoder->private_->client_data);
713
 
}