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