3e73421b87a22b6f9a29d5fe71f6991008f4a9a3
[flac.git] / include / FLAC / stream_encoder.h
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000,2001,2002  Josh Coalson
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library 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 GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA  02111-1307, USA.
18  */
19
20 #ifndef FLAC__STREAM_ENCODER_H
21 #define FLAC__STREAM_ENCODER_H
22
23 #include "format.h"
24
25 #ifdef __cplusplus
26 extern "C" {
27 #endif
28
29
30 /** \file include/FLAC/stream_encoder.h
31  *
32  *  \brief
33  *  This module contains the functions which implement the stream
34  *  encoder.
35  *
36  *  See the detailed documentation in the
37  *  \link flac_stream_encoder stream encoder \endlink module.
38  */
39
40 /** \defgroup flac_stream_encoder FLAC/stream_encoder.h: stream encoder interface
41  *  \ingroup flac
42  *
43  *  \brief
44  *  This module contains the functions which implement the stream
45  *  encoder.
46  *
47  * The basic usage of a libFLAC encoder is as follows: 
48  * - The program creates an instance of an encoder using
49  *   FLAC__stream_encoder_new().
50  * - The program overrides the default settings and sets callbacks for
51  *   reading, writing, error reporting, and metadata reporting using
52  *   FLAC__stream_encoder_set_*() functions.
53  * - The program initializes the instance to validate the settings and
54  *   prepare for encoding using FLAC__stream_encoder_init(). 
55  * - The program calls FLAC__stream_encoder_process() or
56  *   FLAC__stream_encoder_process_interleaved() to encode data, which
57  *   subsequently calls the callbacks. 
58  * - The program finishes the instance with FLAC__stream_encoder_finish(),
59  *   which flushes the input and output and resets the encoder to the
60  *   unitialized state. 
61  * - The instance may be used again or deleted with
62  *   FLAC__stream_encoder_delete(). 
63  *
64  * \note
65  * The "set" functions may only be called when the encoder is in the
66  * state FLAC__STREAM_ENCODER_UNINITIALIZED, i.e. after
67  * FLAC__stream_encoder_new() or FLAC__stream_encoder_finish(), but
68  * before FLAC__stream_encoder_init().  If this is the case they will
69  * return true, otherwise false.
70  *
71  * \note
72  * The "set" functions do not validate the values as many are
73  * interdependent.  The FLAC__stream_encoder_init() function will do
74  * this, so make sure to pay attention to the state returned by
75  * FLAC__stream_encoder_init() to make sure that it is
76  * FLAC__STREAM_ENCODER_OK.
77  *
78  * \note
79  * Unlike the decoders, the stream encoder has many options that can
80  * affect the speed and compression ratio.  When setting these parameters
81  * you should have some basic knowledge of the format (see the
82  * <A HREF="../documentation.html#format">user-level documentation</A>
83  * or the <A HREF="../format.html">formal description</A>).
84  *
85  * \note
86  * Any parameters that are not set before FLAC__stream_encoder_init()
87  * will take on the defaults from the constructor.
88  *
89  * \note
90  * FLAC__stream_encoder_finish() resets all settings to the constructor
91  * defaults, including the callbacks.
92  * 
93  * \{
94  */
95
96
97 /** State values for a FLAC__StreamEncoder
98  *
99  *  The encoder's state can be obtained by calling FLAC__stream_encoder_get_state().
100  */
101 typedef enum {
102
103         FLAC__STREAM_ENCODER_OK = 0,
104         /**< The encoder is in the normal OK state. */
105
106         FLAC__STREAM_ENCODER_INVALID_CALLBACK,
107         /**< The encoder was initialized before setting all the required callbacks. */
108
109         FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS,
110         /**< The encoder has an invalid setting for number of channels. */
111
112         FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE,
113         /**< The encoder has an invalid setting for bits-per-sample.
114          * FLAC supports 4-32 bps but the reference encoder currently supports
115          * only up to 24 bps.
116          */
117
118         FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE,
119         /**< The encoder has an invalid setting for the input sample rate. */
120
121         FLAC__STREAM_ENCODER_INVALID_BLOCK_SIZE,
122         /**< The encoder has an invalid setting for the block size. */
123
124         FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION,
125         /**< The encoder has an invalid setting for the precision of the quantized linear predictor coefficients. */
126
127         FLAC__STREAM_ENCODER_MID_SIDE_CHANNELS_MISMATCH,
128         /**< Mid/side coding was specified but the number of channels is not equal to 2. */
129
130         FLAC__STREAM_ENCODER_MID_SIDE_SAMPLE_SIZE_MISMATCH,
131         /**< Deprecated. */
132
133         FLAC__STREAM_ENCODER_ILLEGAL_MID_SIDE_FORCE,
134         /**< Loose mid/side coding was specified but mid/side coding was not. */
135
136         FLAC__STREAM_ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER,
137         /**< The specified block size is less than the maximum LPC order. */
138
139         FLAC__STREAM_ENCODER_NOT_STREAMABLE,
140         /**< The encoder is bound to the "streamable subset" but other settings violate it. */
141
142         FLAC__STREAM_ENCODER_FRAMING_ERROR,
143         /**< An error occurred while writing the stream; usually, the write_callback returned an error. */
144
145         FLAC__STREAM_ENCODER_INVALID_METADATA,
146         /**< The metadata input to the encoder is invalid. */
147
148         FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING,
149         /**< An error occurred while writing the stream; usually, the write_callback returned an error. */
150
151         FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_WRITING,
152         /**< The write_callback returned an error. */
153
154         FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR,
155         /**< Memory allocation failed. */
156
157         FLAC__STREAM_ENCODER_ALREADY_INITIALIZED,
158         /**< FLAC__stream_encoder_init() was called when the encoder was
159          * already initialized, usually because
160          * FLAC__stream_encoder_finish() was not called.
161          */
162
163         FLAC__STREAM_ENCODER_UNINITIALIZED
164         /**< The encoder is in the uninitialized state. */
165
166 } FLAC__StreamEncoderState;
167
168 /** Maps a FLAC__StreamEncoderState to a C string.
169  *
170  *  Using a FLAC__StreamEncoderState as the index to this array
171  *  will give the string equivalent.  The contents should not be modified.
172  */
173 extern const char * const FLAC__StreamEncoderStateString[];
174
175 /** Return values for the FLAC__StreamEncoder write callback.
176  */
177 typedef enum {
178
179         FLAC__STREAM_ENCODER_WRITE_OK = 0,
180         /**< The write was OK and encoding can continue. */
181
182         FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR
183         /**< An unrecoverable error occurred.  The encoder will return from the process call. */
184
185 } FLAC__StreamEncoderWriteStatus;
186
187 /** Maps a FLAC__StreamEncoderWriteStatus to a C string.
188  *
189  *  Using a FLAC__StreamEncoderWriteStatus as the index to this array
190  *  will give the string equivalent.  The contents should not be modified.
191  */
192 extern const char * const FLAC__StreamEncoderWriteStatusString[];
193
194
195 /***********************************************************************
196  *
197  * class FLAC__StreamEncoder
198  *
199  ***********************************************************************/
200
201 struct FLAC__StreamEncoderProtected;
202 struct FLAC__StreamEncoderPrivate;
203 /** The opaque structure definition for the stream encoder type.
204  */
205 typedef struct {
206         struct FLAC__StreamEncoderProtected *protected_; /* avoid the C++ keyword 'protected' */
207         struct FLAC__StreamEncoderPrivate *private_; /* avoid the C++ keyword 'private' */
208 } FLAC__StreamEncoder;
209
210
211 /***********************************************************************
212  *
213  * Class constructor/destructor
214  *
215  ***********************************************************************/
216
217 /** Create a new stream encoder instance.  The instance is created with
218  *  default settings; see the individual FLAC__stream_encoder_set_*()
219  *  functions for each setting's default.
220  *
221  * \retval FLAC__StreamEncoder*
222  *    \c NULL if there was an error allocating memory, else the new instance.
223  */
224 FLAC__StreamEncoder *FLAC__stream_encoder_new();
225
226 /** Free an encoder instance.  Deletes the object pointed to by \a encoder.
227  *
228  * \param encoder  A pointer to an existing encoder.
229  * \assert
230  *    \code encoder != NULL \endcode
231  */
232 void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder);
233
234 /***********************************************************************
235  *
236  * Public class method prototypes
237  *
238  ***********************************************************************/
239
240 /*
241  * FLAC__bool   do_qlp_coeff_prec_search      (DEFAULT: false ) false => use qlp_coeff_precision, true => search around qlp_coeff_precision, take best
242  * FLAC__bool   do_escape_coding              (DEFAULT: false ) true => search for escape codes in the entropy coding stage for slightly better compression
243  * FLAC__bool   do_exhaustive_model_search    (DEFAULT: false ) false => use estimated bits per residual for scoring, true => generate all, take shortest
244  * unsigned     min_residual_partition_order  (DEFAULT: 0     ) 0 => estimate Rice parameter based on residual variance; >0 => partition residual, use parameter
245  * unsigned     max_residual_partition_order  (DEFAULT: 0     )      for each based on mean; min_ and max_ specify the min and max Rice partition order
246  * unsigned     rice_parameter_search_dist    (DEFAULT: 0     ) 0 => try only calc'd parameter k; else try all [k-dist..k+dist] parameters, use best
247  * FLAC__uint64 total_samples_estimate        (DEFAULT: 0     ) may be 0 if unknown.  acts as a placeholder in the STREAMINFO until the actual total is calculated
248  * FLAC__StreamMetadata **metadata            (DEFAULT: NULL,0) optional metadata blocks to prepend.  STREAMINFO is not allowed since it is done internally.
249  * + unsigned num_blocks
250  * void*        client_data                   (DEFAULT: NULL  ) passed back through the callbacks
251  */
252
253 /** Set the "streamable subset" flag.  If \c true, the encoder will comply
254  *  with the subset (see the format specification) and will check the
255  *  settings during FLAC__stream_encoder_init() to see if all settings
256  *  comply.  If \c false, the settings may take advantage of the full
257  *  range that the format allows.
258  *
259  *  Make sure you know what it entails before setting this to \c false.
260  *
261  * \default \c true
262  * \param  encoder  An encoder instance to set.
263  * \param  value    Flag value (see above).
264  * \assert
265  *    \code encoder != NULL \endcode
266  * \retval FLAC__bool
267  *    \c false if the encoder is already initialized, else \c true.
268  */
269 FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value);
270
271 /** Set to \c true to enable mid-side encoding on stereo input.  The
272  *  number of channels must be 2.  Set to \c false to use only
273  *  independent channel coding.
274  *
275  * \default \c false
276  * \param  encoder  An encoder instance to set.
277  * \param  value    Flag value (see above).
278  * \assert
279  *    \code encoder != NULL \endcode
280  * \retval FLAC__bool
281  *    \c false if the encoder is already initialized, else \c true.
282  */
283 FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value);
284
285 /** Set to \c true to enable adaptive switching between mid-side and
286  *  left-right encoding on stereo input.  The number of channels must
287  *  be 2.  Set to \c false to use exhaustive searching.  In either
288  *  case, the mid/side stereo setting must be \c true.
289  *
290  * \default \c false
291  * \param  encoder  An encoder instance to set.
292  * \param  value    Flag value (see above).
293  * \assert
294  *    \code encoder != NULL \endcode
295  * \retval FLAC__bool
296  *    \c false if the encoder is already initialized, else \c true.
297  */
298 FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value);
299
300 /** Set the number of channels to be encoded.
301  *
302  * \default \c 2
303  * \param  encoder  An encoder instance to set.
304  * \param  value    See above.
305  * \assert
306  *    \code encoder != NULL \endcode
307  * \retval FLAC__bool
308  *    \c false if the encoder is already initialized, else \c true.
309  */
310 FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value);
311
312 /** Set the sample resolution of the input to be encoded.
313  *
314  * \warning
315  * Do not feed the encoder data that is wider than the value you
316  * set here or you will generate an invalid stream.
317  *
318  * \default \c 16
319  * \param  encoder  An encoder instance to set.
320  * \param  value    See above.
321  * \assert
322  *    \code encoder != NULL \endcode
323  * \retval FLAC__bool
324  *    \c false if the encoder is already initialized, else \c true.
325  */
326 FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value);
327
328 /** Set the sample rate (in Hz) of the input to be encoded.
329  *
330  * \default \c 44100
331  * \param  encoder  An encoder instance to set.
332  * \param  value    See above.
333  * \assert
334  *    \code encoder != NULL \endcode
335  * \retval FLAC__bool
336  *    \c false if the encoder is already initialized, else \c true.
337  */
338 FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value);
339
340 /** Set the blocksize to use while encoding.
341  *
342  * \default \c 1152
343  * \param  encoder  An encoder instance to set.
344  * \param  value    See above.
345  * \assert
346  *    \code encoder != NULL \endcode
347  * \retval FLAC__bool
348  *    \c false if the encoder is already initialized, else \c true.
349  */
350 FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value);
351
352 /** Set the maximum LPC order, or \c 0 to use only the fixed predictors.
353  *
354  * \default \c 0
355  * \param  encoder  An encoder instance to set.
356  * \param  value    See above.
357  * \assert
358  *    \code encoder != NULL \endcode
359  * \retval FLAC__bool
360  *    \c false if the encoder is already initialized, else \c true.
361  */
362 FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value);
363
364 /** Set the precision, in bits, of the quantized linear predictor
365  *  coefficients, or \c 0 to let the encoder select it based on the
366  *  blocksize.
367  *
368  * \note
369  * In the current implementation, qlp_coeff_precision + bits_per_sample must
370  * be less than 32.
371  *
372  * \default \c 0
373  * \param  encoder  An encoder instance to set.
374  * \param  value    See above.
375  * \assert
376  *    \code encoder != NULL \endcode
377  * \retval FLAC__bool
378  *    \c false if the encoder is already initialized, else \c true.
379  */
380 FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value);
381
382 /** Set the number of channels to be encoded.
383  *
384  * \default \c false
385  * \param  encoder  An encoder instance to set.
386  * \param  value    See above.
387  * \assert
388  *    \code encoder != NULL \endcode
389  * \retval FLAC__bool
390  *    \c false if the encoder is already initialized, else \c true.
391  */
392 FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value);
393
394 /** Set the number of channels to be encoded.
395  *
396  * \default \c false
397  * \param  encoder  An encoder instance to set.
398  * \param  value    See above.
399  * \assert
400  *    \code encoder != NULL \endcode
401  * \retval FLAC__bool
402  *    \c false if the encoder is already initialized, else \c true.
403  */
404 FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value);
405
406 /** Set the number of channels to be encoded.
407  *
408  * \default \c false
409  * \param  encoder  An encoder instance to set.
410  * \param  value    See above.
411  * \assert
412  *    \code encoder != NULL \endcode
413  * \retval FLAC__bool
414  *    \c false if the encoder is already initialized, else \c true.
415  */
416 FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value);
417
418 /** Set the number of channels to be encoded.
419  *
420  * \default \c 0
421  * \param  encoder  An encoder instance to set.
422  * \param  value    See above.
423  * \assert
424  *    \code encoder != NULL \endcode
425  * \retval FLAC__bool
426  *    \c false if the encoder is already initialized, else \c true.
427  */
428 FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value);
429
430 /** Set the number of channels to be encoded.
431  *
432  * \default \c 0
433  * \param  encoder  An encoder instance to set.
434  * \param  value    See above.
435  * \assert
436  *    \code encoder != NULL \endcode
437  * \retval FLAC__bool
438  *    \c false if the encoder is already initialized, else \c true.
439  */
440 FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value);
441
442 /** Set the number of channels to be encoded.
443  *
444  * \default \c 0
445  * \param  encoder  An encoder instance to set.
446  * \param  value    See above.
447  * \assert
448  *    \code encoder != NULL \endcode
449  * \retval FLAC__bool
450  *    \c false if the encoder is already initialized, else \c true.
451  */
452 FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value);
453
454 /** Set the number of channels to be encoded.
455  *
456  * \default \c 0
457  * \param  encoder  An encoder instance to set.
458  * \param  value    See above.
459  * \assert
460  *    \code encoder != NULL \endcode
461  * \retval FLAC__bool
462  *    \c false if the encoder is already initialized, else \c true.
463  */
464 FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value);
465
466 /** Set the number of channels to be encoded.
467  *
468  * \default \c NULL, 0
469  * \param  encoder  An encoder instance to set.
470  * \param  value    See above.
471  * \assert
472  *    \code encoder != NULL \endcode
473  * \retval FLAC__bool
474  *    \c false if the encoder is already initialized, else \c true.
475  */
476 FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks);
477
478 /** Set the number of channels to be encoded.
479  *
480  * \default \c NULL; the callback is mandatory and must be set before initialization
481  * \param  encoder  An encoder instance to set.
482  * \param  value    See above.
483  * \assert
484  *    \code encoder != NULL \endcode
485  *    \code value != NULL \endcode
486  * \retval FLAC__bool
487  *    \c false if the encoder is already initialized, else \c true.
488  */
489 FLAC__bool FLAC__stream_encoder_set_write_callback(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteStatus (*value)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data));
490
491 /** Set the number of channels to be encoded.
492  *
493  * \default \c NULL; the callback is mandatory and must be set before initialization
494  * \param  encoder  An encoder instance to set.
495  * \param  value    See above.
496  * \assert
497  *    \code encoder != NULL \endcode
498  *    \code value != NULL \endcode
499  * \retval FLAC__bool
500  *    \c false if the encoder is already initialized, else \c true.
501  */
502 FLAC__bool FLAC__stream_encoder_set_metadata_callback(FLAC__StreamEncoder *encoder, void (*value)(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data));
503
504 /** Set the number of channels to be encoded.
505  *
506  * \default \c NULL
507  * \param  encoder  An encoder instance to set.
508  * \param  value    See above.
509  * \assert
510  *    \code encoder != NULL \endcode
511  * \retval FLAC__bool
512  *    \c false if the encoder is already initialized, else \c true.
513  */
514 FLAC__bool FLAC__stream_encoder_set_client_data(FLAC__StreamEncoder *encoder, void *value);
515
516 /*
517  * Various "get" methods
518  */
519 FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder);
520 FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder);
521 FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder);
522 FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder);
523 unsigned   FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
524 unsigned   FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
525 unsigned   FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
526 unsigned   FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
527 unsigned   FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
528 unsigned   FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
529 FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder);
530 FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder);
531 FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder);
532 unsigned   FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
533 unsigned   FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
534 unsigned   FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
535
536 /*
537  * Initialize the instance; should be called after construction and
538  * 'set' calls but before any of the 'process' calls.  Will set and
539  * return the encoder state, which will be FLAC__STREAM_ENCODER_OK
540  * if initialization succeeded.
541  */
542 FLAC__StreamEncoderState FLAC__stream_encoder_init(FLAC__StreamEncoder *encoder);
543
544 /*
545  * Flush the encoding buffer, release resources, and return the encoder
546  * state to FLAC__STREAM_ENCODER_UNINITIALIZED.  Note that this can
547  * generate one or more write_callback()s before returning.
548  */
549 void FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder);
550
551 /*
552  * Methods for encoding the data
553  */
554 FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples);
555 FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples);
556
557 /* \} */
558
559 #ifdef __cplusplus
560 }
561 #endif
562
563 #endif