FLAC 1.5.0 Free Lossless Audio Codec

Classes | Macros | Typedefs | Enumerations | Enumerator | Functions | Variables
FLAC/stream_encoder.h: stream encoder interface
FLAC C API » FLAC/ *_encoder.h: encoder interfaces

## Classes

struct | FLAC__StreamEncoder

## Macros

#define | FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK 0
#define | FLAC__STREAM_ENCODER_SET_NUM_THREADS_NOT_COMPILED_WITH_MULTITHREADING_ENABLED 1
#define | FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED 2
#define | FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS 3

## Typedefs

typedef FLAC__StreamEncoderReadStatus(* | FLAC__StreamEncoderReadCallback) (const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
typedef FLAC__StreamEncoderWriteStatus(* | FLAC__StreamEncoderWriteCallback) (const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data)
typedef FLAC__StreamEncoderSeekStatus(* | FLAC__StreamEncoderSeekCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
typedef FLAC__StreamEncoderTellStatus(* | FLAC__StreamEncoderTellCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
typedef void(* | FLAC__StreamEncoderMetadataCallback) (const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
typedef void(* | FLAC__StreamEncoderProgressCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void *client_data)

## Enumerations

enum | FLAC__StreamEncoderState { FLAC__STREAM_ENCODER_OK = 0 , FLAC__STREAM_ENCODER_UNINITIALIZED , FLAC__STREAM_ENCODER_OGG_ERROR , FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR , FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA , FLAC__STREAM_ENCODER_CLIENT_ERROR , FLAC__STREAM_ENCODER_IO_ERROR , FLAC__STREAM_ENCODER_FRAMING_ERROR ,
FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
}
enum | FLAC__StreamEncoderInitStatus { FLAC__STREAM_ENCODER_INIT_STATUS_OK = 0 , FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR , FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE ,
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER , FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION , FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER , FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE ,
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA , FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED
}
enum | FLAC__StreamEncoderReadStatus { FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE , FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM , FLAC__STREAM_ENCODER_READ_STATUS_ABORT , FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED }
enum | FLAC__StreamEncoderWriteStatus { FLAC__STREAM_ENCODER_WRITE_STATUS_OK = 0 , FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR }
enum | FLAC__StreamEncoderSeekStatus { FLAC__STREAM_ENCODER_SEEK_STATUS_OK , FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR , FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED }
enum | FLAC__StreamEncoderTellStatus { FLAC__STREAM_ENCODER_TELL_STATUS_OK , FLAC__STREAM_ENCODER_TELL_STATUS_ERROR , FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED }

## Functions

FLAC__StreamEncoder * | FLAC__stream_encoder_new (void)
void | FLAC__stream_encoder_delete (FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_set_ogg_serial_number (FLAC__StreamEncoder *encoder, long serial_number)
FLAC__bool | FLAC__stream_encoder_set_verify (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_streamable_subset (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_channels (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_bits_per_sample (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_sample_rate (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_compression_level (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_blocksize (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_do_mid_side_stereo (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_loose_mid_side_stereo (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_apodization (FLAC__StreamEncoder *encoder, const char *specification)
FLAC__bool | FLAC__stream_encoder_set_max_lpc_order (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_qlp_coeff_precision (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_do_qlp_coeff_prec_search (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_do_escape_coding (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_do_exhaustive_model_search (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__bool | FLAC__stream_encoder_set_min_residual_partition_order (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_max_residual_partition_order (FLAC__StreamEncoder *encoder, uint32_t value)
uint32_t | FLAC__stream_encoder_set_num_threads (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_rice_parameter_search_dist (FLAC__StreamEncoder *encoder, uint32_t value)
FLAC__bool | FLAC__stream_encoder_set_total_samples_estimate (FLAC__StreamEncoder *encoder, FLAC__uint64 value)
FLAC__bool | FLAC__stream_encoder_set_metadata (FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, uint32_t num_blocks)
FLAC__bool | FLAC__stream_encoder_set_limit_min_bitrate (FLAC__StreamEncoder *encoder, FLAC__bool value)
FLAC__StreamEncoderState | FLAC__stream_encoder_get_state (const FLAC__StreamEncoder *encoder)
FLAC__StreamDecoderState | FLAC__stream_encoder_get_verify_decoder_state (const FLAC__StreamEncoder *encoder)
const char * | FLAC__stream_encoder_get_resolved_state_string (const FLAC__StreamEncoder *encoder)
void | FLAC__stream_encoder_get_verify_decoder_error_stats (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, uint32_t *frame_number, uint32_t *channel, uint32_t *sample, FLAC__int32 *expected, FLAC__int32 *got)
FLAC__bool | FLAC__stream_encoder_get_verify (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_streamable_subset (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_channels (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_bits_per_sample (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_sample_rate (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_blocksize (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_do_mid_side_stereo (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_loose_mid_side_stereo (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_max_lpc_order (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_qlp_coeff_precision (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_do_qlp_coeff_prec_search (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_do_escape_coding (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_do_exhaustive_model_search (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_min_residual_partition_order (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_max_residual_partition_order (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_num_threads (const FLAC__StreamEncoder *encoder)
uint32_t | FLAC__stream_encoder_get_rice_parameter_search_dist (const FLAC__StreamEncoder *encoder)
FLAC__uint64 | FLAC__stream_encoder_get_total_samples_estimate (const FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_get_limit_min_bitrate (const FLAC__StreamEncoder *encoder)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_stream (FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteCallback write_callback, FLAC__StreamEncoderSeekCallback seek_callback, FLAC__StreamEncoderTellCallback tell_callback, FLAC__StreamEncoderMetadataCallback metadata_callback, void *client_data)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_ogg_stream (FLAC__StreamEncoder *encoder, FLAC__StreamEncoderReadCallback read_callback, FLAC__StreamEncoderWriteCallback write_callback, FLAC__StreamEncoderSeekCallback seek_callback, FLAC__StreamEncoderTellCallback tell_callback, FLAC__StreamEncoderMetadataCallback metadata_callback, void *client_data)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_FILE (FLAC__StreamEncoder *encoder, FILE *file, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_ogg_FILE (FLAC__StreamEncoder *encoder, FILE *file, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_file (FLAC__StreamEncoder *encoder, const char *filename, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
FLAC__StreamEncoderInitStatus | FLAC__stream_encoder_init_ogg_file (FLAC__StreamEncoder *encoder, const char *filename, FLAC__StreamEncoderProgressCallback progress_callback, void *client_data)
FLAC__bool | FLAC__stream_encoder_finish (FLAC__StreamEncoder *encoder)
FLAC__bool | FLAC__stream_encoder_process (FLAC__StreamEncoder *encoder, const FLAC__int32 *const buffer[], uint32_t samples)
FLAC__bool | FLAC__stream_encoder_process_interleaved (FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], uint32_t samples)

## Variables

const char *const | FLAC__StreamEncoderStateString []
const char *const | FLAC__StreamEncoderInitStatusString []
const char *const | FLAC__StreamEncoderReadStatusString []
const char *const | FLAC__StreamEncoderWriteStatusString []
const char *const | FLAC__StreamEncoderSeekStatusString []
const char *const | FLAC__StreamEncoderTellStatusString []
struct FLAC__StreamEncoderProtected * | FLAC__StreamEncoder::protected_
struct FLAC__StreamEncoderPrivate * | FLAC__StreamEncoder::private_

## Detailed Description

This module contains the functions which implement the stream encoder.

The stream encoder can encode to native FLAC, and optionally Ogg FLAC (check FLAC_API_SUPPORTS_OGG_FLAC) streams and files.

The basic usage of this encoder is as follows:

- The program creates an instance of an encoder using FLAC__stream_encoder_new().
- The program overrides the default settings using FLAC__stream_encoder_set_*() functions. At a minimum, the following functions should be called:
  - FLAC__stream_encoder_set_channels()
  - FLAC__stream_encoder_set_bits_per_sample()
  - FLAC__stream_encoder_set_sample_rate()
  - FLAC__stream_encoder_set_ogg_serial_number() (if encoding to Ogg FLAC)
  - FLAC__stream_encoder_set_total_samples_estimate() (if known)
- If the application wants to control the compression level or set its own metadata, then the following should also be called:
  - FLAC__stream_encoder_set_compression_level()
  - FLAC__stream_encoder_set_verify()
  - FLAC__stream_encoder_set_metadata()
- The rest of the set functions should only be called if the client needs exact control over how the audio is compressed; thorough understanding of the FLAC format is necessary to achieve good results.
- The program initializes the instance to validate the settings and prepare for encoding using
  - FLAC__stream_encoder_init_stream() or FLAC__stream_encoder_init_FILE() or FLAC__stream_encoder_init_file() for native FLAC
  - FLAC__stream_encoder_init_ogg_stream() or FLAC__stream_encoder_init_ogg_FILE() or FLAC__stream_encoder_init_ogg_file() for Ogg FLAC
- The program calls FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved() to encode data, which subsequently calls the callbacks when there is encoder data ready to be written.
- The program finishes the encoding with FLAC__stream_encoder_finish(), which causes the encoder to encode any data still in its input pipe, update the metadata with the final encoding statistics if output seeking is possible, and finally reset the encoder to the uninitialized state.
- The instance may be used again or deleted with FLAC__stream_encoder_delete().

In more detail, the stream encoder functions similarly to the stream decoder , but has fewer callbacks and more options. Typically the client will create a new instance by calling FLAC__stream_encoder_new(), then set the necessary parameters with FLAC__stream_encoder_set_*(), and initialize it by calling one of the FLAC__stream_encoder_init_*() functions.

Unlike the decoders, the stream encoder has many options that can affect the speed and compression ratio. When setting these parameters you should have some basic knowledge of the format (see the user-level documentation or the formal description). The FLAC__stream_encoder_set_*() functions themselves do not validate the values as many are interdependent. The FLAC__stream_encoder_init_*() functions will do this, so make sure to pay attention to the state returned by FLAC__stream_encoder_init_*() to make sure that it is FLAC__STREAM_ENCODER_INIT_STATUS_OK. Any parameters that are not set before FLAC__stream_encoder_init_*() will take on the defaults from the constructor.

There are three initialization functions for native FLAC, one for setting up the encoder to encode FLAC data to the client via callbacks, and two for encoding directly to a file.

For encoding via callbacks, use FLAC__stream_encoder_init_stream(). You must also supply a write callback which will be called anytime there is raw encoded data to write. If the client can seek the output it is best to also supply seek and tell callbacks, as this allows the encoder to go back after encoding is finished to write back information that was collected while encoding, like seek point offsets, frame sizes, etc.

For encoding directly to a file, use FLAC__stream_encoder_init_FILE() or FLAC__stream_encoder_init_file(). Then you must only supply a filename or open `FILE*`; the encoder will handle all the callbacks internally. You may also supply a progress callback for periodic notification of the encoding progress.

There are three similarly-named init functions for encoding to Ogg FLAC streams. Check `FLAC_API_SUPPORTS_OGG_FLAC` to find out if the library has been built with Ogg support.

The call to FLAC__stream_encoder_init_*() currently will also immediately call the write callback several times, once with the `fLaC` signature, and once for each encoded metadata block. Note that for Ogg FLAC encoding you will usually get at least twice the number of callbacks than with native FLAC, one for the Ogg page header and one for the page body.

After initializing the instance, the client may feed audio data to the encoder in one of two ways:

- Channel separate, through FLAC__stream_encoder_process() - The client will pass an array of pointers to buffers, one for each channel, to the encoder, each of the same length. The samples need not be block-aligned, but each channel should have the same number of samples.
- Channel interleaved, through FLAC__stream_encoder_process_interleaved() - The client will pass a single pointer to data that is channel-interleaved (i.e. channel0_sample0, channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). Again, the samples need not be block-aligned but they must be sample-aligned, i.e. the first value should be channel0_sample0 and the last value channelN_sampleM.

Note that for either process call, each sample in the buffers should be a signed integer, right-justified to the resolution set by FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution is 16 bits per sample, the samples should all be in the range [-32768,32767].

When the client is finished encoding data, it calls FLAC__stream_encoder_finish(), which causes the encoder to encode any data still in its input pipe, and call the metadata callback with the final encoding statistics. Then the instance may be deleted with FLAC__stream_encoder_delete() or initialized again to encode another stream.

For programs that write their own metadata, but that do not know the actual metadata until after encoding, it is advantageous to instruct the encoder to write a PADDING block of the correct size, so that instead of rewriting the whole stream after encoding, the program can just overwrite the PADDING block. If only the maximum size of the metadata is known, the program can write a slightly larger padding block, then split it after encoding.

Make sure you understand how lengths are calculated. All FLAC metadata blocks have a 4 byte header which contains the type and length. This length does not include the 4 bytes of the header. See the format page for the specification of metadata blocks and their lengths.

Note
  If you are writing the FLAC data to a file via callbacks, make sure it is open for update (e.g. mode "w+" for stdio streams). This is because after the first encoding pass, the encoder will try to seek back to the beginning of the stream, to the STREAMINFO block, to write some data there. (If using FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE(), the file is managed internally.)
  The "set" functions may only be called when the encoder is in the state FLAC__STREAM_ENCODER_UNINITIALIZED, i.e. after FLAC__stream_encoder_new() or FLAC__stream_encoder_finish(), but before FLAC__stream_encoder_init_*(). If this is the case they will return `true`, otherwise `false`.
  FLAC__stream_encoder_finish() resets all settings to the constructor defaults.

## Typedef Documentation

## ◆ FLAC__StreamEncoderReadCallback

typedef FLAC__StreamEncoderReadStatus(* FLAC__StreamEncoderReadCallback) (const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)

Signature for the read callback.

A function pointer matching this signature must be passed to FLAC__stream_encoder_init_ogg_stream() if seeking is supported. The supplied function will be called when the encoder needs to read back encoded data. This happens during the metadata callback, when the encoder has to read, modify, and rewrite the metadata (e.g. seekpoints) gathered while encoding. The address of the buffer to be filled is supplied, along with the number of bytes the buffer can hold. The callback may choose to supply less data and modify the byte count but must be careful not to overflow the buffer. The callback then returns a status code chosen from FLAC__StreamEncoderReadStatus.

Here is an example of a read callback for stdio streams:

FLAC__StreamEncoderReadStatus read_cb(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
{
FILE *file = ((MyClientData*)client_data)->file;
if(*bytes > 0) {
*bytes = fread(buffer, sizeof(FLAC__byte), *bytes, file);
if(ferror(file))
return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
else if(*bytes == 0)
return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM;
else
return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
}
else
return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
}
FLAC__StreamEncoderReadStatus
FLAC__StreamEncoderReadStatus
Definition: stream_encoder.h:367
FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE
@ FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE
Definition: stream_encoder.h:369
FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM
@ FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM
Definition: stream_encoder.h:372
FLAC__STREAM_ENCODER_READ_STATUS_ABORT
@ FLAC__STREAM_ENCODER_READ_STATUS_ABORT
Definition: stream_encoder.h:375
FLAC__StreamEncoder
Definition: stream_encoder.h:469

Note
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  buffer | A pointer to a location for the callee to store data to be encoded.
  bytes | A pointer to the size of the buffer. On entry to the callback, it contains the maximum number of bytes that may be stored in buffer. The callee must set it to the actual number of bytes stored (0 in case of error or end-of-stream) before returning.
  client_data | The callee's client data set through FLAC__stream_encoder_set_client_data().

Return values

  FLAC__StreamEncoderReadStatus | The callee's return status.

## ◆ FLAC__StreamEncoderWriteCallback

typedef FLAC__StreamEncoderWriteStatus(* FLAC__StreamEncoderWriteCallback) (const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data)

Signature for the write callback.

A function pointer matching this signature must be passed to FLAC__stream_encoder_init*_stream(). The supplied function will be called by the encoder anytime there is raw encoded data ready to write. It may include metadata mixed with encoded audio frames and the data is not guaranteed to be aligned on frame or metadata block boundaries.

The only duty of the callback is to write out the bytes worth of data in buffer to the current position in the output stream. The arguments samples and current_frame are purely informational. If samples is greater than `0`, then current_frame will hold the current frame number that is being written; otherwise it indicates that the write callback is being called to write metadata.

Note
  Unlike when writing to native FLAC, when writing to Ogg FLAC the write callback will be called at least twice when writing each audio frame; once for the page header and once for the page body, possibly repeating this pair of calls several times in a batch with the same value of current_frame. When writing the page header, as well as in all but the first page body write of the batch, the samples argument to the write callback will be `0`. For the write callback call containing the first page body, the samples argument is the number of samples contained in all newly added complete packets (not pages). This means that in case a packet is split over two pages, they are counted in the samples argument of the page on which the packet is completed.
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  buffer | An array of encoded data of length bytes.
  bytes | The byte length of buffer.
  samples | The number of samples encoded by buffer. `0` has a special meaning; see above.
  current_frame | The number of the current frame being encoded.
  client_data | The callee's client data set through FLAC__stream_encoder_init_*().

Return values

  FLAC__StreamEncoderWriteStatus | The callee's return status.

## ◆ FLAC__StreamEncoderSeekCallback

typedef FLAC__StreamEncoderSeekStatus(* FLAC__StreamEncoderSeekCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)

Signature for the seek callback.

A function pointer matching this signature may be passed to FLAC__stream_encoder_init*_stream(). The supplied function will be called when the encoder needs to seek the output stream. The encoder will pass the absolute byte offset to seek to, 0 meaning the beginning of the stream.

Here is an example of a seek callback for stdio streams:

FLAC__StreamEncoderSeekStatus seek_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
{
FILE *file = ((MyClientData*)client_data)->file;
if(file == stdin)
return FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
else if(fseeko(file, (off_t)absolute_byte_offset, SEEK_SET) < 0)
return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
else
return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
}
FLAC__StreamEncoderSeekStatus
FLAC__StreamEncoderSeekStatus
Definition: stream_encoder.h:413
FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED
@ FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED
Definition: stream_encoder.h:421
FLAC__STREAM_ENCODER_SEEK_STATUS_OK
@ FLAC__STREAM_ENCODER_SEEK_STATUS_OK
Definition: stream_encoder.h:415
FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
@ FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
Definition: stream_encoder.h:418

Note
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  absolute_byte_offset | The offset from the beginning of the stream to seek to.
  client_data | The callee's client data set through FLAC__stream_encoder_init_*().

Return values

  FLAC__StreamEncoderSeekStatus | The callee's return status.

## ◆ FLAC__StreamEncoderTellCallback

typedef FLAC__StreamEncoderTellStatus(* FLAC__StreamEncoderTellCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)

Signature for the tell callback.

A function pointer matching this signature may be passed to FLAC__stream_encoder_init*_stream(). The supplied function will be called when the encoder needs to know the current position of the output stream.

Warning
  The callback must return the true current byte offset of the output to which the encoder is writing. If you are buffering the output, make sure and take this into account. If you are writing directly to a FILE* from your write callback, ftell() is sufficient. If you are writing directly to a file descriptor from your write callback, you can use lseek(fd, SEEK_CUR, 0). The encoder may later seek back to these points to rewrite metadata after encoding.

Here is an example of a tell callback for stdio streams:

FLAC__StreamEncoderTellStatus tell_cb(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
{
FILE *file = ((MyClientData*)client_data)->file;
off_t pos;
if(file == stdin)
return FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED;
else if((pos = ftello(file)) < 0)
return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
else {
*absolute_byte_offset = (FLAC__uint64)pos;
return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
}
}
FLAC__StreamEncoderTellStatus
FLAC__StreamEncoderTellStatus
Definition: stream_encoder.h:436
FLAC__STREAM_ENCODER_TELL_STATUS_OK
@ FLAC__STREAM_ENCODER_TELL_STATUS_OK
Definition: stream_encoder.h:438
FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED
@ FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED
Definition: stream_encoder.h:444
FLAC__STREAM_ENCODER_TELL_STATUS_ERROR
@ FLAC__STREAM_ENCODER_TELL_STATUS_ERROR
Definition: stream_encoder.h:441

Note
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  absolute_byte_offset | The address at which to store the current position of the output.
  client_data | The callee's client data set through FLAC__stream_encoder_init_*().

Return values

  FLAC__StreamEncoderTellStatus | The callee's return status.

## ◆ FLAC__StreamEncoderMetadataCallback

typedef void(* FLAC__StreamEncoderMetadataCallback) (const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)

Signature for the metadata callback.

A function pointer matching this signature may be passed to FLAC__stream_encoder_init*_stream(). The supplied function will be called once at the end of encoding with the populated STREAMINFO structure. This is so the client can seek back to the beginning of the file and write the STREAMINFO block with the correct statistics after encoding (like minimum/maximum frame size and total samples).

Note
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  metadata | The final populated STREAMINFO block.
  client_data | The callee's client data set through FLAC__stream_encoder_init_*().

## ◆ FLAC__StreamEncoderProgressCallback

typedef void(* FLAC__StreamEncoderProgressCallback) (const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void *client_data)

Signature for the progress callback.

A function pointer matching this signature may be passed to FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE(). The supplied function will be called when the encoder has finished writing a frame. The `total_frames_estimate` argument to the callback will be based on the value from FLAC__stream_encoder_set_total_samples_estimate().

Note
  In general, FLAC__StreamEncoder functions which change the state should not be called on the encoder while in the callback.

Parameters

  encoder | The encoder instance calling the callback.
  bytes_written | Bytes written so far.
  samples_written | Samples written so far.
  frames_written | Frames written so far.
  total_frames_estimate | The estimate of the total number of frames to be written.
  client_data | The callee's client data set through FLAC__stream_encoder_init_*().

## Enumeration Type Documentation

## ◆ FLAC__StreamEncoderState

enum FLAC__StreamEncoderState

State values for a FLAC__StreamEncoder.

The encoder's state can be obtained by calling FLAC__stream_encoder_get_state().

If the encoder gets into any other state besides `FLAC__STREAM_ENCODER_OK` or `FLAC__STREAM_ENCODER_UNINITIALIZED`, it becomes invalid for encoding and must be deleted with FLAC__stream_encoder_delete().

Enumerator
FLAC__STREAM_ENCODER_OK | The encoder is in the normal OK state and samples can be processed.
FLAC__STREAM_ENCODER_UNINITIALIZED | The encoder is in the uninitialized state; one of the FLAC__stream_encoder_init_*() functions must be called before samples can be processed.
FLAC__STREAM_ENCODER_OGG_ERROR | An error occurred in the underlying Ogg layer.
FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR | An error occurred in the underlying verify stream decoder; check FLAC__stream_encoder_get_verify_decoder_state().
FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA | The verify decoder detected a mismatch between the original audio signal and the decoded audio signal.
FLAC__STREAM_ENCODER_CLIENT_ERROR | One of the callbacks returned a fatal error.
FLAC__STREAM_ENCODER_IO_ERROR | An I/O error occurred while opening/reading/writing a file. Check `errno`.
FLAC__STREAM_ENCODER_FRAMING_ERROR | An error occurred while writing the stream; usually, the write_callback returned an error.
FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR | Memory allocation failed.

## ◆ FLAC__StreamEncoderInitStatus

enum FLAC__StreamEncoderInitStatus

Possible return values for the FLAC__stream_encoder_init_*() functions.

Enumerator
FLAC__STREAM_ENCODER_INIT_STATUS_OK | Initialization was successful.
FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR | General failure to set up encoder; call FLAC__stream_encoder_get_state() for cause.
FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER | The library was not compiled with support for the given container format.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS | A required callback was not supplied.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS | The encoder has an invalid setting for number of channels.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE | The encoder has an invalid setting for bits-per-sample. FLAC supports 4-32 bps.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE | The encoder has an invalid setting for the input sample rate.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE | The encoder has an invalid setting for the block size.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER | The encoder has an invalid setting for the maximum LPC order.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION | The encoder has an invalid setting for the precision of the quantized linear predictor coefficients.
FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER | The specified block size is less than the maximum LPC order.
FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE | The encoder is bound to the Subset but other settings violate it.
FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA | The metadata input to the encoder is invalid, in one of the following ways:

- FLAC__stream_encoder_set_metadata() was called with a null pointer but a block count > 0
- One of the metadata blocks contains an undefined type
- It contains an illegal CUESHEET as checked by FLAC__format_cuesheet_is_legal()
- It contains an illegal SEEKTABLE as checked by FLAC__format_seektable_is_legal()
- It contains more than one SEEKTABLE block or more than one VORBIS_COMMENT block

FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED | FLAC__stream_encoder_init_*() was called when the encoder was already initialized, usually because FLAC__stream_encoder_finish() was not called.

## ◆ FLAC__StreamEncoderReadStatus

enum FLAC__StreamEncoderReadStatus

Return values for the FLAC__StreamEncoder read callback.

Enumerator
FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE | The read was OK and decoding can continue.
FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM | The read was attempted at the end of the stream.
FLAC__STREAM_ENCODER_READ_STATUS_ABORT | An unrecoverable error occurred.
FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED | Client does not support reading back from the output.

## ◆ FLAC__StreamEncoderWriteStatus

enum FLAC__StreamEncoderWriteStatus

Return values for the FLAC__StreamEncoder write callback.

Enumerator
FLAC__STREAM_ENCODER_WRITE_STATUS_OK | The write was OK and encoding can continue.
FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR | An unrecoverable error occurred. The encoder will return from the process call.

## ◆ FLAC__StreamEncoderSeekStatus

enum FLAC__StreamEncoderSeekStatus

Return values for the FLAC__StreamEncoder seek callback.

Enumerator
FLAC__STREAM_ENCODER_SEEK_STATUS_OK | The seek was OK and encoding can continue.
FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR | An unrecoverable error occurred.
FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED | Client does not support seeking.

## ◆ FLAC__StreamEncoderTellStatus

enum FLAC__StreamEncoderTellStatus

Return values for the FLAC__StreamEncoder tell callback.

Enumerator
FLAC__STREAM_ENCODER_TELL_STATUS_OK | The tell was OK and encoding can continue.
FLAC__STREAM_ENCODER_TELL_STATUS_ERROR | An unrecoverable error occurred.
FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED | Client does not support seeking.

## Function Documentation

## ◆ FLAC__stream_encoder_new()

FLAC__StreamEncoder * FLAC__stream_encoder_new | ( | void |  | ) |

Create a new stream encoder instance. The instance is created with default settings; see the individual FLAC__stream_encoder_set_*() functions for each setting's default.

Return values

  FLAC__StreamEncoder* | `NULL` if there was an error allocating memory, else the new instance.

## ◆ FLAC__stream_encoder_delete()

void FLAC__stream_encoder_delete | ( | FLAC__StreamEncoder * | encoder | ) |

Free an encoder instance. Deletes the object pointed to by encoder.

Parameters

  encoder | A pointer to an existing encoder.

Assertions:
  encoder != NULL

## ◆ FLAC__stream_encoder_set_ogg_serial_number()

FLAC__bool FLAC__stream_encoder_set_ogg_serial_number | ( | FLAC__StreamEncoder * | encoder,
|  | long | serial_number
| ) |  |

Set the serial number for the FLAC stream to use in the Ogg container.

Note
  This does not need to be set for native FLAC encoding.
  It is recommended to set a serial number explicitly as the default of '0' may collide with other streams.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  serial_number | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_verify()

FLAC__bool FLAC__stream_encoder_set_verify | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set the "verify" flag. If `true`, the encoder will verify it's own encoded output by feeding it through an internal decoder and comparing the original signal against the decoded signal. If a mismatch occurs, the process call will return `false`. Note that this will slow the encoding process by the extra time required for decoding and comparison.

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | Flag value (see above).

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_streamable_subset()

FLAC__bool FLAC__stream_encoder_set_streamable_subset | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set the Subset flag. If `true`, the encoder will comply with the Subset and will check the settings during FLAC__stream_encoder_init_*() to see if all settings comply. If `false`, the settings may take advantage of the full range that the format allows.

Make sure you know what it entails before setting this to `false`.

Default Value: `true`

Parameters

  encoder | An encoder instance to set.
  value | Flag value (see above).

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_channels()

FLAC__bool FLAC__stream_encoder_set_channels | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the number of channels to be encoded.

Default Value: `2`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_bits_per_sample()

FLAC__bool FLAC__stream_encoder_set_bits_per_sample | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the sample resolution of the input to be encoded.

Warning
  Do not feed the encoder data that is wider than the value you set here or you will generate an invalid stream.

Default Value: `16`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_sample_rate()

FLAC__bool FLAC__stream_encoder_set_sample_rate | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the sample rate (in Hz) of the input to be encoded.

Default Value: `44100`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_compression_level()

FLAC__bool FLAC__stream_encoder_set_compression_level | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the compression level

The compression level is roughly proportional to the amount of effort the encoder expends to compress the file. A higher level usually means more computation but higher compression. The default level is suitable for most applications.

Currently the levels range from `0` (fastest, least compression) to `8` (slowest, most compression). A value larger than `8` will be treated as `8`.

This function automatically calls the following other `_set_` functions with appropriate values, so the client does not need to unless it specifically wants to override them:

- FLAC__stream_encoder_set_do_mid_side_stereo()
- FLAC__stream_encoder_set_loose_mid_side_stereo()
- FLAC__stream_encoder_set_apodization()
- FLAC__stream_encoder_set_max_lpc_order()
- FLAC__stream_encoder_set_qlp_coeff_precision()
- FLAC__stream_encoder_set_do_qlp_coeff_prec_search()
- FLAC__stream_encoder_set_do_escape_coding()
- FLAC__stream_encoder_set_do_exhaustive_model_search()
- FLAC__stream_encoder_set_min_residual_partition_order()
- FLAC__stream_encoder_set_max_residual_partition_order()
- FLAC__stream_encoder_set_rice_parameter_search_dist()

The actual values set for each level are:

level | do mid-side stereo | loose mid-side stereo | apodization | max lpc order | qlp coeff precision | qlp coeff prec search | escape coding | exhaustive model search | min residual partition order | max residual partition order | rice parameter search dist
0 | false | false | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0
1 | true | true | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0
2 | true | false | tukey(0.5) | 0 | 0 | false | false | false | 0 | 3 | 0
3 | false | false | tukey(0.5) | 6 | 0 | false | false | false | 0 | 4 | 0
4 | true | true | tukey(0.5) | 8 | 0 | false | false | false | 0 | 4 | 0
5 | true | false | tukey(0.5) | 8 | 0 | false | false | false | 0 | 5 | 0
6 | true | false | subdivide_tukey(2) | 8 | 0 | false | false | false | 0 | 6 | 0
7 | true | false | subdivide_tukey(2) | 12 | 0 | false | false | false | 0 | 6 | 0
8 | true | false | subdivide_tukey(3) | 12 | 0 | false | false | false | 0 | 6 | 0

Default Value: `5`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_blocksize()

FLAC__bool FLAC__stream_encoder_set_blocksize | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the blocksize to use while encoding.

The number of samples to use per frame. Use `0` to let the encoder estimate a blocksize; this is usually best.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_do_mid_side_stereo()

FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set to `true` to enable mid-side encoding on stereo input. The number of channels must be 2 for this to have any effect. Set to `false` to use only independent channel coding.

Default Value: `true`

Parameters

  encoder | An encoder instance to set.
  value | Flag value (see above).

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_loose_mid_side_stereo()

FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set to `true` to enable adaptive switching between mid-side and left-right encoding on stereo input. Set to `false` to use exhaustive searching. Setting this to `true` requires FLAC__stream_encoder_set_do_mid_side_stereo() to also be set to `true` in order to have any effect.

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | Flag value (see above).

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_apodization()

FLAC__bool FLAC__stream_encoder_set_apodization | ( | FLAC__StreamEncoder * | encoder,
|  | const char * | specification
| ) |  |

Sets the apodization function(s) the encoder will use when windowing audio data for LPC analysis.

The specification is a plain ASCII string which specifies exactly which functions to use. There may be more than one (up to 32), separated by `'`;' characters. Some functions take one or more comma-separated arguments in parentheses.

The available functions are `bartlett`, `bartlett_hann`, `blackman`, `blackman_harris_4term_92db`, `connes`, `flattop`, `gauss(STDDEV)`, `hamming`, `hann`, `kaiser_bessel`, `nuttall`, `rectangle`, `triangle`, `tukey(P)`, `partial_tukey`(n[/ov[/P]]), `punchout_tukey`(n[/ov[/P]]), `subdivide_tukey`(n[/P]), `welch`.

For `gauss(STDDEV)`, STDDEV specifies the standard deviation (0<STDDEV<=0.5).

For `tukey(P)`, P specifies the fraction of the window that is tapered (0<=P<=1). P=0 corresponds to `rectangle` and P=1 corresponds to `hann`.

Specifying `partial_tukey` or `punchout_tukey` works a little different. These do not specify a single apodization function, but a series of them with some overlap. partial_tukey specifies a series of small windows (all treated separately) while punchout_tukey specifies a series of windows that have a hole in them. In this way, the predictor is constructed with only a part of the block, which helps in case a block consists of dissimilar parts.

The three parameters that can be specified for the functions are n, ov and P. n is the number of functions to add, ov is the overlap of the windows in case of partial_tukey and the overlap in the gaps in case of punchout_tukey. P is the fraction of the window that is tapered, like with a regular tukey window. The function can be specified with only a number, a number and an overlap, or a number an overlap and a P, for example, partial_tukey(3), partial_tukey(3/0.3) and partial_tukey(3/0.3/0.5) are all valid. ov should be smaller than 1 and can be negative.

subdivide_tukey(n) is a more efficient reimplementation of partial_tukey and punchout_tukey taken together, recycling as much data as possible. It combines all possible non-redundant partial_tukey(n) and punchout_tukey(n) up to the n specified. Specifying subdivide_tukey(3) is equivalent to specifying tukey, partial_tukey(2), partial_tukey(3) and punchout_tukey(3), specifying subdivide_tukey(5) equivalently adds partial_tukey(4), punchout_tukey(4), partial_tukey(5) and punchout_tukey(5). To be able to reuse data as much as possible, the tukey taper is taken equal for all windows, and the P specified is applied for the smallest used window. In other words, subdivide_tukey(2/0.5) results in a taper equal to that of tukey(0.25) and subdivide_tukey(5) in a taper equal to that of tukey(0.1). The default P for subdivide_tukey when none is specified is 0.5.

Example specifications are `"blackman"` or `"hann;triangle;tukey(0.5);tukey(0.25);tukey(0.125)"`

Any function that is specified erroneously is silently dropped. Up to 32 functions are kept, the rest are dropped. If the specification is empty the encoder defaults to `"tukey(0.5)"`.

When more than one function is specified, then for every subframe the encoder will try each of them separately and choose the window that results in the smallest compressed subframe.

Note that each function specified causes the encoder to occupy a floating point array in which to store the window. Also note that the values of P, STDDEV and ov are locale-specific, so if the comma separator specified by the locale is a comma, a comma should be used. A locale-independent way is to specify using scientific notation, e.g. 5e-1 instad of 0.5 or 0,5.

Default Value: `"tukey(0.5)"`

Parameters

  encoder | An encoder instance to set.
  specification | See above.

Assertions:
  encoder != NULL
  specification != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_max_lpc_order()

FLAC__bool FLAC__stream_encoder_set_max_lpc_order | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the maximum LPC order, or `0` to use only the fixed predictors.

Default Value: `8`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_qlp_coeff_precision()

FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the precision, in bits, of the quantized linear predictor coefficients, or `0` to let the encoder select it based on the blocksize.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_do_qlp_coeff_prec_search()

FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set to `false` to use only the specified quantized linear predictor coefficient precision, or `true` to search neighboring precision values and use the best one.

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_do_escape_coding()

FLAC__bool FLAC__stream_encoder_set_do_escape_coding | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Deprecated. Setting this value has no effect.

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_do_exhaustive_model_search()

FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set to `false` to let the encoder estimate the best model order based on the residual signal energy, or `true` to force the encoder to evaluate all order models and select the best.

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_min_residual_partition_order()

FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the minimum partition order to search when coding the residual. This is used in tandem with FLAC__stream_encoder_set_max_residual_partition_order().

The partition order determines the context size in the residual. The context size will be approximately `blocksize / (2 ^ order)`.

Set both min and max values to `0` to force a single context, whose Rice parameter is based on the residual signal variance. Otherwise, set a min and max order, and the encoder will search all orders, using the mean of each context for its Rice parameter, and use the best.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_max_residual_partition_order()

FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the maximum partition order to search when coding the residual. This is used in tandem with FLAC__stream_encoder_set_min_residual_partition_order().

The partition order determines the context size in the residual. The context size will be approximately `blocksize / (2 ^ order)`.

Set both min and max values to `0` to force a single context, whose Rice parameter is based on the residual signal variance. Otherwise, set a min and max order, and the encoder will search all orders, using the mean of each context for its Rice parameter, and use the best.

Default Value: `5`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_num_threads()

uint32_t FLAC__stream_encoder_set_num_threads | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Set the maximum number of threads to use during encoding. Set to a value different than 1 to enable multithreaded encoding.

Note that enabling multithreading encoding (i.e., setting a value different than 1) results in the behaviour of FLAC__stream_encoder_finish(), FLAC__stream_encoder_process(), FLAC__stream_encoder_process_interleaved() subtly changing. For example, calling one of the process functions with enough samples to fill a block might not always result in a call to the write callback with a frame coding these samples. Instead, blocks with samples are distributed among worker threads, meaning that the first few calls to those functions will return very quickly, while later calls might block if all threads are occupied. Also, certain calls to the process functions will results in several calls to the write callback, while subsequent calls might again return very quickly with no calls to the write callback.

Also, a call to FLAC__stream_encoder_finish() blocks while waiting for all threads to finish, and therefore might take much longer than when not multithreading and result in multiple calls to the write callback.

Calls to the write callback are guaranteed to be in the correct order.

Currently, passing a value of 0 is synonymous with a value of 1, but this might change in the future.

Default Value: `1`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  uint32_t |
  - `FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK` if the number of threads was set correctly,
  - `FLAC__STREAM_ENCODER_SET_NUM_THREADS_NOT_COMPILED_WITH_MULTITHREADING_ENABLED` when multithreading was not enabled at compilation,
  - `FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED` when the encoder was already initialized,
  - `FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS` when the number of threads was larger than the maximum allowed number of threads (currently 128).

## ◆ FLAC__stream_encoder_set_rice_parameter_search_dist()

FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist | ( | FLAC__StreamEncoder * | encoder,
|  | uint32_t | value
| ) |  |

Deprecated. Setting this value has no effect.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_total_samples_estimate()

FLAC__bool FLAC__stream_encoder_set_total_samples_estimate | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__uint64 | value
| ) |  |

Set an estimate of the total samples that will be encoded. This is merely an estimate and may be set to `0` if unknown. This value will be written to the STREAMINFO block before encoding, and can remove the need for the caller to rewrite the value later if the value is known before encoding.

Default Value: `0`

Parameters

  encoder | An encoder instance to set.
  value | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_set_metadata()

FLAC__bool FLAC__stream_encoder_set_metadata | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__StreamMetadata ** | metadata,
|  | uint32_t | num_blocks
| ) |  |

Set the metadata blocks to be emitted to the stream before encoding. A value of `NULL`, `0` implies no metadata; otherwise, supply an array of pointers to metadata blocks. The array is non-const since the encoder may need to change the is_last flag inside them, and in some cases update seek point offsets. Otherwise, the encoder will not modify or free the blocks. It is up to the caller to free the metadata blocks after encoding finishes.

Note
  The encoder stores only copies of the pointers in the metadata array; the metadata blocks themselves must survive at least until after FLAC__stream_encoder_finish() returns. Do not free the blocks until then.
  The STREAMINFO block is always written and no STREAMINFO block may occur in the supplied array.
  By default the encoder does not create a SEEKTABLE. If one is supplied in the metadata array, but the client has specified that it does not support seeking, then the SEEKTABLE will be written verbatim. However by itself this is not very useful as the client will not know the stream offsets for the seekpoints ahead of time. In order to get a proper seektable the client must support seeking. See next note.
  SEEKTABLE blocks are handled specially. Since you will not know the values for the seek point stream offsets, you should pass in a SEEKTABLE 'template', that is, a SEEKTABLE object with the required sample numbers (or placeholder points), with `0` for the frame_samples and stream_offset fields for each point. If the client has specified that it supports seeking by providing a seek callback to FLAC__stream_encoder_init_stream() or both seek AND read callback to FLAC__stream_encoder_init_ogg_stream() (or by using FLAC__stream_encoder_init*_file() or FLAC__stream_encoder_init*_FILE()), then while it is encoding the encoder will fill the stream offsets in for you and when encoding is finished, it will seek back and write the real values into the SEEKTABLE block in the stream. There are helper routines for manipulating seektable template blocks; see metadata.h: FLAC__metadata_object_seektable_template_*(). If the client does not support seeking, the SEEKTABLE will have inaccurate offsets which will slow down or remove the ability to seek in the FLAC stream.
  The encoder instance will modify the first `SEEKTABLE` block as it transforms the template to a valid seektable while encoding, but it is still up to the caller to free all metadata blocks after encoding.
  A VORBIS_COMMENT block may be supplied. The vendor string in it will be ignored. libFLAC will use it's own vendor string. libFLAC will not modify the passed-in VORBIS_COMMENT's vendor string, it will simply write it's own into the stream. If no VORBIS_COMMENT block is present in the metadata array, libFLAC will write an empty one, containing only the vendor string.
  The Ogg FLAC mapping requires that the VORBIS_COMMENT block be the second metadata block of the stream. The encoder already supplies the STREAMINFO block automatically. If metadata does not contain a VORBIS_COMMENT block, the encoder will supply that too. Otherwise, if metadata does contain a VORBIS_COMMENT block and it is not the first, the init function will reorder metadata by moving the VORBIS_COMMENT block to the front; the relative ordering of the other blocks will remain as they were.
  The Ogg FLAC mapping limits the number of metadata blocks per stream to `65535`. If num_blocks exceeds this the function will return `false`.

Default Value: `NULL`, 0

Parameters

  encoder | An encoder instance to set.
  metadata | See above.
  num_blocks | See above.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`. `false` if the encoder is already initialized, or if num_blocks > 65535 if encoding to Ogg FLAC, else `true`.

## ◆ FLAC__stream_encoder_set_limit_min_bitrate()

FLAC__bool FLAC__stream_encoder_set_limit_min_bitrate | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__bool | value
| ) |  |

Set to `true` to make the encoder not output frames which contain only constant subframes. This is beneficial for streaming applications: very small frames can cause problems with buffering as bitrates can drop as low 1kbit/s for CDDA audio encoded within subset. The minimum bitrate for a FLAC file encoded with this function used is raised to 1bit/sample (i.e. 48kbit/s for 48kHz material).

Default Value: `false`

Parameters

  encoder | An encoder instance to set.
  value | Flag value (see above).

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if the encoder is already initialized, else `true`.

## ◆ FLAC__stream_encoder_get_state()

FLAC__StreamEncoderState FLAC__stream_encoder_get_state | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the current encoder state.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamEncoderState | The current encoder state.

## ◆ FLAC__stream_encoder_get_verify_decoder_state()

FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the state of the verify stream decoder. Useful when the stream encoder state is `FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR`.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamDecoderState | The verify stream decoder state.

## ◆ FLAC__stream_encoder_get_resolved_state_string()

const char * FLAC__stream_encoder_get_resolved_state_string | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the current encoder state as a C string. This version automatically resolves `FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR` by getting the verify decoder's state.

Parameters

  encoder | A encoder instance to query.

Assertions:
  encoder != NULL

Return values

  const | char * The encoder state as a C string. Do not modify the contents.

## ◆ FLAC__stream_encoder_get_verify_decoder_error_stats()

void FLAC__stream_encoder_get_verify_decoder_error_stats | ( | const FLAC__StreamEncoder * | encoder,
|  | FLAC__uint64 * | absolute_sample,
|  | uint32_t * | frame_number,
|  | uint32_t * | channel,
|  | uint32_t * | sample,
|  | FLAC__int32 * | expected,
|  | FLAC__int32 * | got
| ) |  |

Get relevant values about the nature of a verify decoder error. Useful when the stream encoder state is `FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR`. The arguments should be addresses in which the stats will be returned, or NULL if value is not desired.

Parameters

  encoder | An encoder instance to query.
  absolute_sample | The absolute sample number of the mismatch.
  frame_number | The number of the frame in which the mismatch occurred.
  channel | The channel in which the mismatch occurred.
  sample | The number of the sample (relative to the frame) in which the mismatch occurred.
  expected | The expected value for the sample in question.
  got | The actual value returned by the decoder.

Assertions:
  encoder != NULL

## ◆ FLAC__stream_encoder_get_verify()

FLAC__bool FLAC__stream_encoder_get_verify | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the "verify" flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_verify().

## ◆ FLAC__stream_encoder_get_streamable_subset()

FLAC__bool FLAC__stream_encoder_get_streamable_subset | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the Subset flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_streamable_subset().

## ◆ FLAC__stream_encoder_get_channels()

uint32_t FLAC__stream_encoder_get_channels | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the number of input channels being processed.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_channels().

## ◆ FLAC__stream_encoder_get_bits_per_sample()

uint32_t FLAC__stream_encoder_get_bits_per_sample | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the input sample resolution setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_bits_per_sample().

## ◆ FLAC__stream_encoder_get_sample_rate()

uint32_t FLAC__stream_encoder_get_sample_rate | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the input sample rate setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_sample_rate().

## ◆ FLAC__stream_encoder_get_blocksize()

uint32_t FLAC__stream_encoder_get_blocksize | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the blocksize setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_blocksize().

## ◆ FLAC__stream_encoder_get_do_mid_side_stereo()

FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the "mid/side stereo coding" flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_get_do_mid_side_stereo().

## ◆ FLAC__stream_encoder_get_loose_mid_side_stereo()

FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the "adaptive mid/side switching" flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_loose_mid_side_stereo().

## ◆ FLAC__stream_encoder_get_max_lpc_order()

uint32_t FLAC__stream_encoder_get_max_lpc_order | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the maximum LPC order setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_max_lpc_order().

## ◆ FLAC__stream_encoder_get_qlp_coeff_precision()

uint32_t FLAC__stream_encoder_get_qlp_coeff_precision | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the quantized linear predictor coefficient precision setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_qlp_coeff_precision().

## ◆ FLAC__stream_encoder_get_do_qlp_coeff_prec_search()

FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the qlp coefficient precision search flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_do_qlp_coeff_prec_search().

## ◆ FLAC__stream_encoder_get_do_escape_coding()

FLAC__bool FLAC__stream_encoder_get_do_escape_coding | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the "escape coding" flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_do_escape_coding().

## ◆ FLAC__stream_encoder_get_do_exhaustive_model_search()

FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the exhaustive model search flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_do_exhaustive_model_search().

## ◆ FLAC__stream_encoder_get_min_residual_partition_order()

uint32_t FLAC__stream_encoder_get_min_residual_partition_order | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the minimum residual partition order setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_min_residual_partition_order().

## ◆ FLAC__stream_encoder_get_max_residual_partition_order()

uint32_t FLAC__stream_encoder_get_max_residual_partition_order | ( | const FLAC__StreamEncoder * | encoder | ) |

Get maximum residual partition order setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_max_residual_partition_order().

## ◆ FLAC__stream_encoder_get_num_threads()

uint32_t FLAC__stream_encoder_get_num_threads | ( | const FLAC__StreamEncoder * | encoder | ) |

Get maximum number of threads setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_num_threads().

## ◆ FLAC__stream_encoder_get_rice_parameter_search_dist()

uint32_t FLAC__stream_encoder_get_rice_parameter_search_dist | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the Rice parameter search distance setting.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  uint32_t | See FLAC__stream_encoder_set_rice_parameter_search_dist().

## ◆ FLAC__stream_encoder_get_total_samples_estimate()

FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the previously set estimate of the total samples to be encoded. The encoder merely mimics back the value given to FLAC__stream_encoder_set_total_samples_estimate() since it has no other way of knowing how many samples the client will encode.

Parameters

  encoder | An encoder instance to set.

Assertions:
  encoder != NULL

Return values

  FLAC__uint64 | See FLAC__stream_encoder_get_total_samples_estimate().

## ◆ FLAC__stream_encoder_get_limit_min_bitrate()

FLAC__bool FLAC__stream_encoder_get_limit_min_bitrate | ( | const FLAC__StreamEncoder * | encoder | ) |

Get the "limit_min_bitrate" flag.

Parameters

  encoder | An encoder instance to query.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | See FLAC__stream_encoder_set_limit_min_bitrate().

## ◆ FLAC__stream_encoder_init_stream()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__StreamEncoderWriteCallback | write_callback,
|  | FLAC__StreamEncoderSeekCallback | seek_callback,
|  | FLAC__StreamEncoderTellCallback | tell_callback,
|  | FLAC__StreamEncoderMetadataCallback | metadata_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode native FLAC streams.

This flavor of initialization sets up the encoder to encode to a native FLAC stream. I/O is performed via callbacks to the client. For encoding to a plain file via filename or open `FILE*`, FLAC__stream_encoder_init_file() and FLAC__stream_encoder_init_FILE() provide a simpler interface.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

The call to FLAC__stream_encoder_init_stream() currently will also immediately call the write callback several times, once with the `fLaC` signature, and once for each encoded metadata block.

Parameters

  encoder | An uninitialized encoder instance.
  write_callback | See FLAC__StreamEncoderWriteCallback. This pointer must not be `NULL`.
  seek_callback | See FLAC__StreamEncoderSeekCallback. This pointer may be `NULL` if seeking is not supported. The encoder uses seeking to go back and write some some stream statistics to the STREAMINFO block; this is recommended but not necessary to create a valid FLAC stream. If seek_callback is not `NULL` then a tell_callback must also be supplied. Alternatively, a dummy seek callback that just returns `FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED` may also be supplied, all though this is slightly less efficient for the encoder.
  tell_callback | See FLAC__StreamEncoderTellCallback. This pointer may be `NULL` if seeking is not supported. If seek_callback is `NULL` then this argument will be ignored. If seek_callback is not `NULL` then a tell_callback must also be supplied. Alternatively, a dummy tell callback that just returns `FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED` may also be supplied, all though this is slightly less efficient for the encoder.
  metadata_callback | See FLAC__StreamEncoderMetadataCallback. This pointer may be `NULL` if the callback is not desired. If the client provides a seek callback, this function is not necessary as the encoder will automatically seek back and update the STREAMINFO block. It may also be `NULL` if the client does not support seeking, since it will have no way of going back to update the STREAMINFO. However the client can still supply a callback if it would like to know the details from the STREAMINFO.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_init_ogg_stream()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_stream | ( | FLAC__StreamEncoder * | encoder,
|  | FLAC__StreamEncoderReadCallback | read_callback,
|  | FLAC__StreamEncoderWriteCallback | write_callback,
|  | FLAC__StreamEncoderSeekCallback | seek_callback,
|  | FLAC__StreamEncoderTellCallback | tell_callback,
|  | FLAC__StreamEncoderMetadataCallback | metadata_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode Ogg FLAC streams.

This flavor of initialization sets up the encoder to encode to a FLAC stream in an Ogg container. I/O is performed via callbacks to the client. For encoding to a plain file via filename or open `FILE*`, FLAC__stream_encoder_init_ogg_file() and FLAC__stream_encoder_init_ogg_FILE() provide a simpler interface.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

The call to FLAC__stream_encoder_init_ogg_stream() currently will also immediately call the write callback several times to write the metadata packets.

Parameters

  encoder | An uninitialized encoder instance.
  read_callback | See FLAC__StreamEncoderReadCallback. This pointer must not be `NULL` if seek_callback is non-NULL since they are both needed to be able to write data back to the Ogg FLAC stream in the post-encode phase.
  write_callback | See FLAC__StreamEncoderWriteCallback. This pointer must not be `NULL`.
  seek_callback | See FLAC__StreamEncoderSeekCallback. This pointer may be `NULL` if seeking is not supported. The encoder uses seeking to go back and write some some stream statistics to the STREAMINFO block; this is recommended but not necessary to create a valid FLAC stream. If seek_callback is not `NULL` then a tell_callback must also be supplied. Alternatively, a dummy seek callback that just returns `FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED` may also be supplied, all though this is slightly less efficient for the encoder.
  tell_callback | See FLAC__StreamEncoderTellCallback. This pointer may be `NULL` if seeking is not supported. If seek_callback is `NULL` then this argument will be ignored. If seek_callback is not `NULL` then a tell_callback must also be supplied. Alternatively, a dummy tell callback that just returns `FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED` may also be supplied, all though this is slightly less efficient for the encoder.
  metadata_callback | See FLAC__StreamEncoderMetadataCallback. This pointer may be `NULL` if the callback is not desired. If the client provides a seek callback, this function is not necessary as the encoder will automatically seek back and update the STREAMINFO block. It may also be `NULL` if the client does not support seeking, since it will have no way of going back to update the STREAMINFO. However the client can still supply a callback if it would like to know the details from the STREAMINFO.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_init_FILE()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE | ( | FLAC__StreamEncoder * | encoder,
|  | FILE * | file,
|  | FLAC__StreamEncoderProgressCallback | progress_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode native FLAC files.

This flavor of initialization sets up the encoder to encode to a plain native FLAC file. For non-stdio streams, you must use FLAC__stream_encoder_init_stream() and provide callbacks for the I/O.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

Parameters

  encoder | An uninitialized encoder instance.
  file | An open file. The file should have been opened with mode `"w+b"` and rewound. The file becomes owned by the encoder and should not be manipulated by the client while encoding. Unless file is `stdout`, it will be closed when FLAC__stream_encoder_finish() is called. Note however that a proper SEEKTABLE cannot be created when encoding to `stdout` since it is not seekable.
  progress_callback | See FLAC__StreamEncoderProgressCallback. This pointer may be `NULL` if the callback is not desired.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL
  file != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_init_ogg_FILE()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE | ( | FLAC__StreamEncoder * | encoder,
|  | FILE * | file,
|  | FLAC__StreamEncoderProgressCallback | progress_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode Ogg FLAC files.

This flavor of initialization sets up the encoder to encode to a plain Ogg FLAC file. For non-stdio streams, you must use FLAC__stream_encoder_init_ogg_stream() and provide callbacks for the I/O.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

Parameters

  encoder | An uninitialized encoder instance.
  file | An open file. The file should have been opened with mode `"w+b"` and rewound. The file becomes owned by the encoder and should not be manipulated by the client while encoding. Unless file is `stdout`, it will be closed when FLAC__stream_encoder_finish() is called. Note however that a proper SEEKTABLE cannot be created when encoding to `stdout` since it is not seekable.
  progress_callback | See FLAC__StreamEncoderProgressCallback. This pointer may be `NULL` if the callback is not desired.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL
  file != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_init_file()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file | ( | FLAC__StreamEncoder * | encoder,
|  | const char * | filename,
|  | FLAC__StreamEncoderProgressCallback | progress_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode native FLAC files.

This flavor of initialization sets up the encoder to encode to a plain FLAC file. If POSIX fopen() semantics are not sufficient you must use FLAC__stream_encoder_init_FILE(), or FLAC__stream_encoder_init_stream() and provide callbacks for the I/O.

On Windows, filename must be a UTF-8 encoded filename, which libFLAC internally translates to an appropriate representation to use with _wfopen. On all other systems, filename is passed to fopen without any translation.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

Parameters

  encoder | An uninitialized encoder instance.
  filename | The name of the file to encode to. The file will be opened with fopen(). Use `NULL` to encode to `stdout`. Note however that a proper SEEKTABLE cannot be created when encoding to `stdout` since it is not seekable.
  progress_callback | See FLAC__StreamEncoderProgressCallback. This pointer may be `NULL` if the callback is not desired.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_init_ogg_file()

FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_file | ( | FLAC__StreamEncoder * | encoder,
|  | const char * | filename,
|  | FLAC__StreamEncoderProgressCallback | progress_callback,
|  | void * | client_data
| ) |  |

Initialize the encoder instance to encode Ogg FLAC files.

This flavor of initialization sets up the encoder to encode to a plain Ogg FLAC file. If POSIX fopen() semantics are not sufficient, you must use FLAC__stream_encoder_init_ogg_FILE(), or FLAC__stream_encoder_init_ogg_stream() and provide callbacks for the I/O.

On Windows, filename must be a UTF-8 encoded filename, which libFLAC internally translates to an appropriate representation to use with _wfopen. On all other systems, filename is passed to fopen without any translation.

This function should be called after FLAC__stream_encoder_new() and FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process() or FLAC__stream_encoder_process_interleaved(). initialization succeeded.

Parameters

  encoder | An uninitialized encoder instance.
  filename | The name of the file to encode to. The file will be opened with fopen(). Use `NULL` to encode to `stdout`. Note however that a proper SEEKTABLE cannot be created when encoding to `stdout` since it is not seekable.
  progress_callback | See FLAC__StreamEncoderProgressCallback. This pointer may be `NULL` if the callback is not desired.
  client_data | This value will be supplied to callbacks in their client_data argument.

Assertions:
  encoder != NULL

Return values

  FLAC__StreamEncoderInitStatus | `FLAC__STREAM_ENCODER_INIT_STATUS_OK` if initialization was successful; see FLAC__StreamEncoderInitStatus for the meanings of other return values.

## ◆ FLAC__stream_encoder_finish()

FLAC__bool FLAC__stream_encoder_finish | ( | FLAC__StreamEncoder * | encoder | ) |

Finish the encoding process. Flushes the encoding buffer, releases resources, resets the encoder settings to their defaults, and returns the encoder state to FLAC__STREAM_ENCODER_UNINITIALIZED. Note that this can generate one or more write callbacks before returning, and will generate a metadata callback.

Note that in the course of processing the last frame, errors can occur, so the caller should be sure to check the return value to ensure the file was encoded properly.

In the event of a prematurely-terminated encode, it is not strictly necessary to call this immediately before FLAC__stream_encoder_delete() but it is good practice to match every FLAC__stream_encoder_init_*() with a FLAC__stream_encoder_finish().

Parameters

  encoder | An uninitialized encoder instance.

Assertions:
  encoder != NULL

Return values

  FLAC__bool | `false` if an error occurred processing the last frame; or if verify mode is set (see FLAC__stream_encoder_set_verify()), there was a verify mismatch; else `true`. If `false`, caller should check the state with FLAC__stream_encoder_get_state() for more information about the error.

## ◆ FLAC__stream_encoder_process()

FLAC__bool FLAC__stream_encoder_process | ( | FLAC__StreamEncoder * | encoder,
|  | const FLAC__int32 *const | buffer[],
|  | uint32_t | samples
| ) |  |

Submit data for encoding. This version allows you to supply the input data via an array of pointers, each pointer pointing to an array of samples samples representing one channel. The samples need not be block-aligned, but each channel should have the same number of samples. Each sample should be a signed integer, right-justified to the resolution set by FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution is 16 bits per sample, the samples should all be in the range [-32768,32767].

For applications where channel order is important, channels must follow the order as described in the frame header.

Parameters

  encoder | An initialized encoder instance in the OK state.
  buffer | An array of pointers to each channel's signal.
  samples | The number of samples in one channel.

Assertions:
  encoder != NULL
  FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK
  FLAC__stream_encoder_get_state
  FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
  FLAC__STREAM_ENCODER_OK
  @ FLAC__STREAM_ENCODER_OK
  Definition: stream_encoder.h:243

Return values

  FLAC__bool | `true` if successful, else `false`; in this case, check the encoder state with FLAC__stream_encoder_get_state() to see what went wrong.

## ◆ FLAC__stream_encoder_process_interleaved()

FLAC__bool FLAC__stream_encoder_process_interleaved | ( | FLAC__StreamEncoder * | encoder,
|  | const FLAC__int32 | buffer[],
|  | uint32_t | samples
| ) |  |

Submit data for encoding. This version allows you to supply the input data where the channels are interleaved into a single array (i.e. channel0_sample0, channel1_sample0, ... , channelN_sample0, channel0_sample1, ...). The samples need not be block-aligned but they must be sample-aligned, i.e. the first value should be channel0_sample0 and the last value channelN_sampleM. Each sample should be a signed integer, right-justified to the resolution set by FLAC__stream_encoder_set_bits_per_sample(). For example, if the resolution is 16 bits per sample, the samples should all be in the range [-32768,32767].

For applications where channel order is important, channels must follow the order as described in the frame header.

Parameters

  encoder | An initialized encoder instance in the OK state.
  buffer | An array of channel-interleaved data (see above).
  samples | The number of samples in one channel, the same as for FLAC__stream_encoder_process(). For example, if encoding two channels, `1000` samples corresponds to a buffer of 2000 values.

Assertions:
  encoder != NULL
  FLAC__stream_encoder_get_state(encoder) == FLAC__STREAM_ENCODER_OK

Return values

  FLAC__bool | `true` if successful, else `false`; in this case, check the encoder state with FLAC__stream_encoder_get_state() to see what went wrong.

## Variable Documentation

## ◆ FLAC__StreamEncoderStateString

const char* const FLAC__StreamEncoderStateString[]

extern

Maps a FLAC__StreamEncoderState to a C string.

Using a FLAC__StreamEncoderState as the index to this array will give the string equivalent. The contents should not be modified.

## ◆ FLAC__StreamEncoderInitStatusString

const char* const FLAC__StreamEncoderInitStatusString[]

extern

Maps a FLAC__StreamEncoderInitStatus to a C string.

Using a FLAC__StreamEncoderInitStatus as the index to this array will give the string equivalent. The contents should not be modified.

## ◆ FLAC__StreamEncoderReadStatusString

const char* const FLAC__StreamEncoderReadStatusString[]

extern

Maps a FLAC__StreamEncoderReadStatus to a C string.

Using a FLAC__StreamEncoderReadStatus as the index to this array will give the string equivalent. The contents should not be modified.

## ◆ FLAC__StreamEncoderWriteStatusString

const char* const FLAC__StreamEncoderWriteStatusString[]

extern

Maps a FLAC__StreamEncoderWriteStatus to a C string.

Using a FLAC__StreamEncoderWriteStatus as the index to this array will give the string equivalent. The contents should not be modified.

## ◆ FLAC__StreamEncoderSeekStatusString

const char* const FLAC__StreamEncoderSeekStatusString[]

extern

Maps a FLAC__StreamEncoderSeekStatus to a C string.

Using a FLAC__StreamEncoderSeekStatus as the index to this array will give the string equivalent. The contents should not be modified.

## ◆ FLAC__StreamEncoderTellStatusString

const char* const FLAC__StreamEncoderTellStatusString[]

extern

Maps a FLAC__StreamEncoderTellStatus to a C string.

Using a FLAC__StreamEncoderTellStatus as the index to this array will give the string equivalent. The contents should not be modified.

Copyright (c) 2000-2009 Josh Coalson Copyright (c) 2011-2025 Xiph.Org Foundation