FLAC Encoder Interface Reference

Overview

The IFLACEncodeSettings interface provides complete control over FLAC (Free Lossless Audio Codec) audio encoding parameters in DirectShow filter graphs. FLAC is a lossless audio compression format that reduces file size without any loss in audio quality, making it ideal for archival, professional audio production, and high-fidelity music distribution.

This interface allows developers to configure encoding quality levels, Linear Predictive Coding (LPC) parameters, block sizes, mid-side stereo coding, and Rice partition orders to achieve optimal compression efficiency for different types of audio content.

Interface GUID: {A6096781-2A65-4540-A536-011235D0A5FE}

Inherits From: IUnknown

Interface Definitions

C# Definition

using System;
using System.Runtime.InteropServices;

namespace VisioForge.DirectShowAPI
{
    /// <summary>
    /// FLAC (Free Lossless Audio Codec) encoder configuration interface.
    /// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
    /// </summary>
    [ComImport]
    [Guid("A6096781-2A65-4540-A536-011235D0A5FE")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    public interface IFLACEncodeSettings
    {
        /// <summary>
        /// Checks if encoding settings can be modified at the current time.
        /// </summary>
        /// <returns>True if settings can be modified, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool canModifySettings();

        /// <summary>
        /// Sets the FLAC encoding level (compression quality).
        /// </summary>
        /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setEncodingLevel(uint inLevel);

        /// <summary>
        /// Sets the Linear Predictive Coding (LPC) order.
        /// Higher values provide better compression but slower encoding.
        /// </summary>
        /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setLPCOrder(uint inLPCOrder);

        /// <summary>
        /// Sets the audio block size for encoding.
        /// Larger blocks can provide better compression but increase latency.
        /// </summary>
        /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setBlockSize(uint inBlockSize);

        /// <summary>
        /// Enables or disables mid-side stereo coding for 2-channel audio.
        /// Can improve compression for stereo audio with correlated channels.
        /// </summary>
        /// <param name="inUseMidSideCoding">True to enable mid-side coding, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useMidSideCoding([In, MarshalAs(UnmanagedType.Bool)] bool inUseMidSideCoding);

        /// <summary>
        /// Enables or disables adaptive mid-side stereo coding.
        /// Automatically decides whether to use mid-side coding on a per-block basis.
        /// Overrides useMidSideCoding and is generally faster.
        /// </summary>
        /// <param name="inUseAdaptiveMidSideCoding">True to enable adaptive mid-side coding, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useAdaptiveMidSideCoding([In, MarshalAs(UnmanagedType.Bool)] bool inUseAdaptiveMidSideCoding);

        /// <summary>
        /// Enables or disables exhaustive model search for best compression.
        /// Significantly slower but can provide better compression ratios.
        /// </summary>
        /// <param name="inUseExhaustiveModelSearch">True to enable exhaustive search, false to disable</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool useExhaustiveModelSearch([In, MarshalAs(UnmanagedType.Bool)] bool inUseExhaustiveModelSearch);

        /// <summary>
        /// Sets the Rice partition order range for entropy coding.
        /// Controls the trade-off between compression efficiency and encoding speed.
        /// </summary>
        /// <param name="inMin">Minimum Rice partition order</param>
        /// <param name="inMax">Maximum Rice partition order</param>
        /// <returns>True if successful, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool setRicePartitionOrder(uint inMin, uint inMax);

        /// <summary>
        /// Gets the current encoding level setting.
        /// </summary>
        /// <returns>Current encoding level (0-8)</returns>
        [PreserveSig]
        int encoderLevel();

        /// <summary>
        /// Gets the current Linear Predictive Coding (LPC) order.
        /// </summary>
        /// <returns>Current LPC order</returns>
        [PreserveSig]
        uint LPCOrder();

        /// <summary>
        /// Gets the current block size setting.
        /// </summary>
        /// <returns>Current block size in samples</returns>
        [PreserveSig]
        uint blockSize();

        /// <summary>
        /// Gets the minimum Rice partition order.
        /// </summary>
        /// <returns>Minimum Rice partition order</returns>
        [PreserveSig]
        uint riceMin();

        /// <summary>
        /// Gets the maximum Rice partition order.
        /// </summary>
        /// <returns>Maximum Rice partition order</returns>
        [PreserveSig]
        uint riceMax();

        /// <summary>
        /// Checks if mid-side stereo coding is enabled.
        /// </summary>
        /// <returns>True if mid-side coding is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingMidSideCoding();

        /// <summary>
        /// Checks if adaptive mid-side stereo coding is enabled.
        /// </summary>
        /// <returns>True if adaptive mid-side coding is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingAdaptiveMidSideCoding();

        /// <summary>
        /// Checks if exhaustive model search is enabled.
        /// </summary>
        /// <returns>True if exhaustive model search is enabled, false otherwise</returns>
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Bool)]
        bool isUsingExhaustiveModel();
    }
}

C++ Definition

#include <unknwn.h>

// {A6096781-2A65-4540-A536-011235D0A5FE}
DEFINE_GUID(IID_IFLACEncodeSettings,
    0xa6096781, 0x2a65, 0x4540, 0xa5, 0x36, 0x01, 0x12, 0x35, 0xd0, 0xa5, 0xfe);

/// <summary>
/// FLAC (Free Lossless Audio Codec) encoder configuration interface.
/// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
/// </summary>
DECLARE_INTERFACE_(IFLACEncodeSettings, IUnknown)
{
    /// <summary>
    /// Checks if encoding settings can be modified at the current time.
    /// </summary>
    /// <returns>TRUE if settings can be modified, FALSE otherwise</returns>
    STDMETHOD_(BOOL, canModifySettings)(THIS) PURE;

    /// <summary>
    /// Sets the FLAC encoding level (compression quality).
    /// </summary>
    /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setEncodingLevel)(THIS_
        unsigned long inLevel
        ) PURE;

    /// <summary>
    /// Sets the Linear Predictive Coding (LPC) order.
    /// Higher values provide better compression but slower encoding.
    /// </summary>
    /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setLPCOrder)(THIS_
        unsigned long inLPCOrder
        ) PURE;

    /// <summary>
    /// Sets the audio block size for encoding.
    /// Larger blocks can provide better compression but increase latency.
    /// </summary>
    /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setBlockSize)(THIS_
        unsigned long inBlockSize
        ) PURE;

    /// <summary>
    /// Enables or disables mid-side stereo coding for 2-channel audio.
    /// Can improve compression for stereo audio with correlated channels.
    /// </summary>
    /// <param name="inUseMidSideCoding">TRUE to enable mid-side coding, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
    STDMETHOD_(BOOL, useMidSideCoding)(THIS_
        BOOL inUseMidSideCoding
        ) PURE;

    /// <summary>
    /// Enables or disables adaptive mid-side stereo coding.
    /// Automatically decides whether to use mid-side coding on a per-block basis.
    /// Overrides useMidSideCoding and is generally faster.
    /// </summary>
    /// <param name="inUseAdaptiveMidSideCoding">TRUE to enable adaptive mid-side coding, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
    STDMETHOD_(BOOL, useAdaptiveMidSideCoding)(THIS_
        BOOL inUseAdaptiveMidSideCoding
        ) PURE;

    /// <summary>
    /// Enables or disables exhaustive model search for best compression.
    /// Significantly slower but can provide better compression ratios.
    /// </summary>
    /// <param name="inUseExhaustiveModelSearch">TRUE to enable exhaustive search, FALSE to disable</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, useExhaustiveModelSearch)(THIS_
        BOOL inUseExhaustiveModelSearch
        ) PURE;

    /// <summary>
    /// Sets the Rice partition order range for entropy coding.
    /// Controls the trade-off between compression efficiency and encoding speed.
    /// </summary>
    /// <param name="inMin">Minimum Rice partition order</param>
    /// <param name="inMax">Maximum Rice partition order</param>
    /// <returns>TRUE if successful, FALSE otherwise</returns>
    STDMETHOD_(BOOL, setRicePartitionOrder)(THIS_
        unsigned long inMin,
        unsigned long inMax
        ) PURE;

    /// <summary>
    /// Gets the current encoding level setting.
    /// </summary>
    /// <returns>Current encoding level (0-8)</returns>
    STDMETHOD_(int, encoderLevel)(THIS) PURE;

    /// <summary>
    /// Gets the current Linear Predictive Coding (LPC) order.
    /// </summary>
    /// <returns>Current LPC order</returns>
    STDMETHOD_(unsigned long, LPCOrder)(THIS) PURE;

    /// <summary>
    /// Gets the current block size setting.
    /// </summary>
    /// <returns>Current block size in samples</returns>
    STDMETHOD_(unsigned long, blockSize)(THIS) PURE;

    /// <summary>
    /// Gets the minimum Rice partition order.
    /// </summary>
    /// <returns>Minimum Rice partition order</returns>
    STDMETHOD_(unsigned long, riceMin)(THIS) PURE;

    /// <summary>
    /// Gets the maximum Rice partition order.
    /// </summary>
    /// <returns>Maximum Rice partition order</returns>
    STDMETHOD_(unsigned long, riceMax)(THIS) PURE;

    /// <summary>
    /// Checks if mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>TRUE if mid-side coding is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingMidSideCoding)(THIS) PURE;

    /// <summary>
    /// Checks if adaptive mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>TRUE if adaptive mid-side coding is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingAdaptiveMidSideCoding)(THIS) PURE;

    /// <summary>
    /// Checks if exhaustive model search is enabled.
    /// </summary>
    /// <returns>TRUE if exhaustive model search is enabled, FALSE otherwise</returns>
    STDMETHOD_(BOOL, isUsingExhaustiveModel)(THIS) PURE;
};

Delphi Definition

uses
  ActiveX, ComObj;

const
  IID_IFLACEncodeSettings: TGUID = '{A6096781-2A65-4540-A536-011235D0A5FE}';

type
  /// <summary>
  /// FLAC (Free Lossless Audio Codec) encoder configuration interface.
  /// Provides comprehensive control over FLAC encoding parameters for lossless audio compression.
  /// </summary>
  IFLACEncodeSettings = interface(IUnknown)
    ['{A6096781-2A65-4540-A536-011235D0A5FE}']

    /// <summary>
    /// Checks if encoding settings can be modified at the current time.
    /// </summary>
    /// <returns>True if settings can be modified, false otherwise</returns>
    function canModifySettings: BOOL; stdcall;

    /// <summary>
    /// Sets the FLAC encoding level (compression quality).
    /// </summary>
    /// <param name="inLevel">Encoding level (0-8, where 8 is highest compression, slowest)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setEncodingLevel(inLevel: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Sets the Linear Predictive Coding (LPC) order.
    /// Higher values provide better compression but slower encoding.
    /// </summary>
    /// <param name="inLPCOrder">LPC order (typically 0-32)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setLPCOrder(inLPCOrder: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Sets the audio block size for encoding.
    /// Larger blocks can provide better compression but increase latency.
    /// </summary>
    /// <param name="inBlockSize">Block size in samples (typically 192-4608)</param>
    /// <returns>True if successful, false otherwise</returns>
    function setBlockSize(inBlockSize: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Enables or disables mid-side stereo coding for 2-channel audio.
    /// Can improve compression for stereo audio with correlated channels.
    /// </summary>
    /// <param name="inUseMidSideCoding">True to enable mid-side coding, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    /// <remarks>Only applicable for 2-channel (stereo) audio</remarks>
    function useMidSideCoding(inUseMidSideCoding: BOOL): BOOL; stdcall;

    /// <summary>
    /// Enables or disables adaptive mid-side stereo coding.
    /// Automatically decides whether to use mid-side coding on a per-block basis.
    /// Overrides useMidSideCoding and is generally faster.
    /// </summary>
    /// <param name="inUseAdaptiveMidSideCoding">True to enable adaptive mid-side coding, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    /// <remarks>Only for 2-channel audio. Overrides useMidSideCoding setting. Generally provides better performance.</remarks>
    function useAdaptiveMidSideCoding(inUseAdaptiveMidSideCoding: BOOL): BOOL; stdcall;

    /// <summary>
    /// Enables or disables exhaustive model search for best compression.
    /// Significantly slower but can provide better compression ratios.
    /// </summary>
    /// <param name="inUseExhaustiveModelSearch">True to enable exhaustive search, false to disable</param>
    /// <returns>True if successful, false otherwise</returns>
    function useExhaustiveModelSearch(inUseExhaustiveModelSearch: BOOL): BOOL; stdcall;

    /// <summary>
    /// Sets the Rice partition order range for entropy coding.
    /// Controls the trade-off between compression efficiency and encoding speed.
    /// </summary>
    /// <param name="inMin">Minimum Rice partition order</param>
    /// <param name="inMax">Maximum Rice partition order</param>
    /// <returns>True if successful, false otherwise</returns>
    function setRicePartitionOrder(inMin: Cardinal; inMax: Cardinal): BOOL; stdcall;

    /// <summary>
    /// Gets the current encoding level setting.
    /// </summary>
    /// <returns>Current encoding level (0-8)</returns>
    function encoderLevel: Integer; stdcall;

    /// <summary>
    /// Gets the current Linear Predictive Coding (LPC) order.
    /// </summary>
    /// <returns>Current LPC order</returns>
    function LPCOrder: Cardinal; stdcall;

    /// <summary>
    /// Gets the current block size setting.
    /// </summary>
    /// <returns>Current block size in samples</returns>
    function blockSize: Cardinal; stdcall;

    /// <summary>
    /// Gets the minimum Rice partition order.
    /// </summary>
    /// <returns>Minimum Rice partition order</returns>
    function riceMin: Cardinal; stdcall;

    /// <summary>
    /// Gets the maximum Rice partition order.
    /// </summary>
    /// <returns>Maximum Rice partition order</returns>
    function riceMax: Cardinal; stdcall;

    /// <summary>
    /// Checks if mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>True if mid-side coding is enabled, false otherwise</returns>
    function isUsingMidSideCoding: BOOL; stdcall;

    /// <summary>
    /// Checks if adaptive mid-side stereo coding is enabled.
    /// </summary>
    /// <returns>True if adaptive mid-side coding is enabled, false otherwise</returns>
    function isUsingAdaptiveMidSideCoding: BOOL; stdcall;

    /// <summary>
    /// Checks if exhaustive model search is enabled.
    /// </summary>
    /// <returns>True if exhaustive model search is enabled, false otherwise</returns>
    function isUsingExhaustiveModel: BOOL; stdcall;
  end;

Method Reference

Configuration Check

canModifySettings

Checks if encoding settings can be modified at the current time. This is useful to verify the encoder is in a state where configuration changes are allowed (typically before the filter graph starts running).

Returns: true if settings can be modified, false otherwise

Example Usage:

if (flacEncoder.canModifySettings())
{
    // Safe to modify encoder settings
    flacEncoder.setEncodingLevel(5);
}

Encoding Configuration Methods

setEncodingLevel

Sets the FLAC encoding level, which controls the compression quality and encoding speed trade-off.

Parameters: - inLevel - Encoding level (0-8): - 0 = Fastest encoding, lowest compression - 5 = Balanced (recommended for most uses) - 8 = Slowest encoding, highest compression

Returns: true if successful, false otherwise

Recommended Values: - Fast archival: Level 3-5 - High-quality archival: Level 6-8 - Real-time encoding: Level 0-2

setLPCOrder

Sets the Linear Predictive Coding (LPC) order, which affects compression efficiency and encoding speed.

Parameters: - inLPCOrder - LPC order value (typically 0-32) - 0 = No LPC (fastest) - 12 = Default for most audio - 32 = Maximum compression (slowest)

Returns: true if successful, false otherwise

Note: Higher LPC orders provide better compression but significantly increase encoding time.

setBlockSize

Sets the audio block size for encoding. The block size affects both compression efficiency and latency.

Parameters: - inBlockSize - Block size in samples - Common values: 192, 576, 1152, 2304, 4608 - Default is typically 4096 for 44.1kHz audio

Returns: true if successful, false otherwise

Recommendations: - Low latency: 192-1152 samples - Standard archival: 4096 samples - Maximum compression: 4608 samples

useMidSideCoding

Enables or disables mid-side stereo coding for 2-channel audio. Mid-side coding can improve compression for stereo audio where the left and right channels are highly correlated.

Parameters: - inUseMidSideCoding - true to enable, false to disable

Returns: true if successful, false otherwise

Note: Only applicable for 2-channel (stereo) audio. Most music benefits from mid-side coding.

useAdaptiveMidSideCoding

Enables or disables adaptive mid-side stereo coding. This mode automatically decides whether to use mid-side coding on a per-block basis, providing better compression than fixed mid-side coding.

Parameters: - inUseAdaptiveMidSideCoding - true to enable, false to disable

Returns: true if successful, false otherwise

Note: - Only for 2-channel audio - Overrides useMidSideCoding setting - Generally provides better performance than fixed mid-side coding - Recommended for most stereo encoding scenarios

useExhaustiveModelSearch

Enables or disables exhaustive model search for finding the best compression predictor.

Parameters: - inUseExhaustiveModelSearch - true to enable, false to disable

Returns: true if successful, false otherwise

Warning: Exhaustive search significantly slows down encoding (often 2-4x slower) but can provide marginally better compression (typically 1-3% file size reduction).

Recommended: Only enable for archival of critical audio where encoding time is not a concern.

setRicePartitionOrder

Sets the Rice partition order range for entropy coding. Rice coding is the final compression stage in FLAC.

Parameters: - inMin - Minimum Rice partition order (typically 0-2) - inMax - Maximum Rice partition order (typically 3-8)

Returns: true if successful, false otherwise

Typical Values: - Fast encoding: min=0, max=3 - Standard encoding: min=0, max=6 - Maximum compression: min=0, max=8

Status Query Methods

encoderLevel

Gets the current encoding level setting.

Returns: Current encoding level (0-8)

LPCOrder

Gets the current Linear Predictive Coding (LPC) order.

Returns: Current LPC order value

blockSize

Gets the current block size setting.

Returns: Current block size in samples

riceMin

Gets the minimum Rice partition order.

Returns: Minimum Rice partition order

riceMax

Gets the maximum Rice partition order.

Returns: Maximum Rice partition order

isUsingMidSideCoding

Checks if fixed mid-side stereo coding is enabled.

Returns: true if mid-side coding is enabled, false otherwise

isUsingAdaptiveMidSideCoding

Checks if adaptive mid-side stereo coding is enabled.

Returns: true if adaptive mid-side coding is enabled, false otherwise

isUsingExhaustiveModel

Checks if exhaustive model search is enabled.

Returns: true if exhaustive model search is enabled, false otherwise

Usage Examples

C# Example - High Quality Archival

using System;
using DirectShowLib;
using VisioForge.DirectShowAPI;

public class FLACArchivalEncoder
{
    public void ConfigureHighQualityArchival(IBaseFilter audioEncoder)
    {
        // Query the FLAC encoder interface
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null)
        {
            Console.WriteLine("Error: Filter does not support IFLACEncodeSettings");
            return;
        }

        // Check if we can modify settings
        if (!flacEncoder.canModifySettings())
        {
            Console.WriteLine("Warning: Cannot modify encoder settings at this time");
            return;
        }

        // High quality archival settings
        flacEncoder.setEncodingLevel(8);              // Maximum compression
        flacEncoder.setLPCOrder(12);                  // Good LPC order for music
        flacEncoder.setBlockSize(4096);               // Standard block size for 44.1kHz
        flacEncoder.useAdaptiveMidSideCoding(true);   // Adaptive mid-side for stereo
        flacEncoder.useExhaustiveModelSearch(true);   // Best possible compression
        flacEncoder.setRicePartitionOrder(0, 8);      // Maximum Rice partition range

        Console.WriteLine("FLAC encoder configured for high-quality archival:");
        Console.WriteLine($"  Encoding Level: {flacEncoder.encoderLevel()}");
        Console.WriteLine($"  LPC Order: {flacEncoder.LPCOrder()}");
        Console.WriteLine($"  Block Size: {flacEncoder.blockSize()}");
        Console.WriteLine($"  Adaptive Mid-Side: {flacEncoder.isUsingAdaptiveMidSideCoding()}");
        Console.WriteLine($"  Exhaustive Search: {flacEncoder.isUsingExhaustiveModel()}");
        Console.WriteLine($"  Rice Partition: {flacEncoder.riceMin()}-{flacEncoder.riceMax()}");
    }
}

C# Example - Fast Real-Time Encoding

public class FLACRealTimeEncoder
{
    public void ConfigureFastEncoding(IBaseFilter audioEncoder)
    {
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null || !flacEncoder.canModifySettings())
            return;

        // Fast encoding settings for real-time use
        flacEncoder.setEncodingLevel(2);              // Fast encoding
        flacEncoder.setLPCOrder(8);                   // Lower LPC for speed
        flacEncoder.setBlockSize(1152);               // Smaller blocks for lower latency
        flacEncoder.useAdaptiveMidSideCoding(true);   // Still good compression
        flacEncoder.useExhaustiveModelSearch(false);  // Disable for speed
        flacEncoder.setRicePartitionOrder(0, 4);      // Reduced Rice partition range

        Console.WriteLine("FLAC encoder configured for fast real-time encoding");
        Console.WriteLine($"  Encoding Level: {flacEncoder.encoderLevel()}");
        Console.WriteLine($"  LPC Order: {flacEncoder.LPCOrder()}");
        Console.WriteLine($"  Block Size: {flacEncoder.blockSize()} (lower latency)");
    }
}

C# Example - Balanced Music Encoding

public class FLACMusicEncoder
{
    public void ConfigureBalancedMusic(IBaseFilter audioEncoder)
    {
        var flacEncoder = audioEncoder as IFLACEncodeSettings;
        if (flacEncoder == null || !flacEncoder.canModifySettings())
            return;

        // Balanced settings for music encoding (good compression, reasonable speed)
        flacEncoder.setEncodingLevel(5);              // Balanced compression
        flacEncoder.setLPCOrder(12);                  // Standard LPC for music
        flacEncoder.setBlockSize(4096);               // Optimal for 44.1kHz
        flacEncoder.useAdaptiveMidSideCoding(true);   // Adaptive mid-side
        flacEncoder.useExhaustiveModelSearch(false);  // Not needed for music
        flacEncoder.setRicePartitionOrder(0, 6);      // Good Rice partition range

        Console.WriteLine("FLAC encoder configured for balanced music encoding");
    }
}

C++ Example - High Quality Archival

#include <dshow.h>
#include <iostream>
#include "IFLACEncodeSettings.h"

void ConfigureHighQualityFLAC(IBaseFilter* pAudioEncoder)
{
    IFLACEncodeSettings* pFLACEncoder = NULL;
    HRESULT hr = S_OK;

    // Query the FLAC encoder interface
    hr = pAudioEncoder->QueryInterface(IID_IFLACEncodeSettings,
                                       (void**)&pFLACEncoder);
    if (FAILED(hr) || !pFLACEncoder)
    {
        std::cout << "Error: Filter does not support IFLACEncodeSettings" << std::endl;
        return;
    }

    // Check if we can modify settings
    if (!pFLACEncoder->canModifySettings())
    {
        std::cout << "Warning: Cannot modify encoder settings" << std::endl;
        pFLACEncoder->Release();
        return;
    }

    // Configure high quality archival settings
    pFLACEncoder->setEncodingLevel(8);              // Maximum compression
    pFLACEncoder->setLPCOrder(12);                  // Good LPC order
    pFLACEncoder->setBlockSize(4096);               // Standard block size
    pFLACEncoder->useAdaptiveMidSideCoding(TRUE);   // Adaptive mid-side
    pFLACEncoder->useExhaustiveModelSearch(TRUE);   // Best compression
    pFLACEncoder->setRicePartitionOrder(0, 8);      // Maximum range

    // Display configuration
    std::cout << "FLAC encoder configured for high-quality archival:" << std::endl;
    std::cout << "  Encoding Level: " << pFLACEncoder->encoderLevel() << std::endl;
    std::cout << "  LPC Order: " << pFLACEncoder->LPCOrder() << std::endl;
    std::cout << "  Block Size: " << pFLACEncoder->blockSize() << std::endl;
    std::cout << "  Adaptive Mid-Side: "
              << (pFLACEncoder->isUsingAdaptiveMidSideCoding() ? "Yes" : "No") << std::endl;
    std::cout << "  Exhaustive Search: "
              << (pFLACEncoder->isUsingExhaustiveModel() ? "Yes" : "No") << std::endl;

    pFLACEncoder->Release();
}

C++ Example - Fast Real-Time Encoding

void ConfigureFastFLAC(IBaseFilter* pAudioEncoder)
{
    IFLACEncodeSettings* pFLACEncoder = NULL;
    HRESULT hr = pAudioEncoder->QueryInterface(IID_IFLACEncodeSettings,
                                               (void**)&pFLACEncoder);
    if (SUCCEEDED(hr) && pFLACEncoder)
    {
        if (pFLACEncoder->canModifySettings())
        {
            // Fast encoding configuration
            pFLACEncoder->setEncodingLevel(2);              // Fast
            pFLACEncoder->setLPCOrder(8);                   // Lower LPC
            pFLACEncoder->setBlockSize(1152);               // Smaller blocks
            pFLACEncoder->useAdaptiveMidSideCoding(TRUE);   // Still good
            pFLACEncoder->useExhaustiveModelSearch(FALSE);  // Disabled for speed
            pFLACEncoder->setRicePartitionOrder(0, 4);      // Reduced range

            std::cout << "FLAC encoder configured for fast real-time encoding" << std::endl;
        }
        pFLACEncoder->Release();
    }
}

Delphi Example - High Quality Archival

uses
  DirectShow9, ActiveX;

procedure ConfigureHighQualityFLAC(AudioEncoder: IBaseFilter);
var
  FLACEncoder: IFLACEncodeSettings;
  hr: HRESULT;
begin
  // Query the FLAC encoder interface
  hr := AudioEncoder.QueryInterface(IID_IFLACEncodeSettings, FLACEncoder);
  if Failed(hr) or (FLACEncoder = nil) then
  begin
    WriteLn('Error: Filter does not support IFLACEncodeSettings');
    Exit;
  end;

  try
    // Check if we can modify settings
    if not FLACEncoder.canModifySettings then
    begin
      WriteLn('Warning: Cannot modify encoder settings');
      Exit;
    end;

    // Configure high quality archival settings
    FLACEncoder.setEncodingLevel(8);              // Maximum compression
    FLACEncoder.setLPCOrder(12);                  // Good LPC order
    FLACEncoder.setBlockSize(4096);               // Standard block size
    FLACEncoder.useAdaptiveMidSideCoding(True);   // Adaptive mid-side
    FLACEncoder.useExhaustiveModelSearch(True);   // Best compression
    FLACEncoder.setRicePartitionOrder(0, 8);      // Maximum range

    // Display configuration
    WriteLn('FLAC encoder configured for high-quality archival:');
    WriteLn('  Encoding Level: ', FLACEncoder.encoderLevel);
    WriteLn('  LPC Order: ', FLACEncoder.LPCOrder);
    WriteLn('  Block Size: ', FLACEncoder.blockSize);
    WriteLn('  Adaptive Mid-Side: ', FLACEncoder.isUsingAdaptiveMidSideCoding);
    WriteLn('  Exhaustive Search: ', FLACEncoder.isUsingExhaustiveModel);

  finally
    FLACEncoder := nil;
  end;
end;

Delphi Example - Balanced Music Encoding

procedure ConfigureBalancedMusicFLAC(AudioEncoder: IBaseFilter);
var
  FLACEncoder: IFLACEncodeSettings;
begin
  if Succeeded(AudioEncoder.QueryInterface(IID_IFLACEncodeSettings, FLACEncoder)) then
  begin
    try
      if FLACEncoder.canModifySettings then
      begin
        // Balanced settings for music
        FLACEncoder.setEncodingLevel(5);              // Balanced
        FLACEncoder.setLPCOrder(12);                  // Standard for music
        FLACEncoder.setBlockSize(4096);               // Optimal
        FLACEncoder.useAdaptiveMidSideCoding(True);   // Adaptive
        FLACEncoder.useExhaustiveModelSearch(False);  // Not needed
        FLACEncoder.setRicePartitionOrder(0, 6);      // Good range

        WriteLn('FLAC encoder configured for balanced music encoding');
      end;
    finally
      FLACEncoder := nil;
    end;
  end;
end;

Best Practices

Encoding Level Selection

Level 0-2: Fast encoding, suitable for real-time applications - Use when encoding speed is critical - Typical compression: 50-55% of original size

Level 3-5: Balanced encoding (recommended for most uses) - Good balance between speed and compression - Typical compression: 45-50% of original size - Level 5 is recommended for general-purpose archival

Level 6-8: Maximum compression, slower encoding - Use for long-term archival where storage space is critical - Typical compression: 40-45% of original size - Encoding can be 2-5x slower than level 5

Mid-Side Stereo Coding

• Always enable useAdaptiveMidSideCoding for stereo audio
• Adaptive mode automatically determines when mid-side coding helps
• Provides better compression than fixed mid-side mode
• No significant performance penalty

LPC Order Recommendations

Music and General Audio: - Use LPC order 12 for most music encoding - Higher orders (16-32) provide minimal benefit for music - Lower orders (8) are suitable for speech

Classical and High-Dynamic Range: - Consider LPC order 16-32 for orchestral recordings - Provides better prediction for complex harmonic content

Block Size Selection

Sample Rate Considerations: - 44.1kHz: 4096 samples (default, ~93ms) - 48kHz: 4608 samples (~96ms) - 96kHz: 4608-8192 samples

Latency Requirements: - Real-time: 192-1152 samples - Standard archival: 4096 samples - Maximum compression: 4608 samples

Exhaustive Model Search

When to Enable: - Critical archival projects where every byte counts - Unlimited encoding time available - File size reduction is paramount

When to Disable (recommended for most users): - Real-time or near-real-time encoding - Large batch encoding projects - Compression improvement is typically <3% - Encoding time increases 2-4x

Rice Partition Order

Fast Encoding: setRicePartitionOrder(0, 3) Standard Encoding: setRicePartitionOrder(0, 6) (recommended) Maximum Compression: setRicePartitionOrder(0, 8)

Troubleshooting

Settings Cannot Be Modified

Symptom: canModifySettings() returns false

Causes: 1. Filter graph is already running 2. Encoder is actively processing audio 3. Filter is in an incorrect state

Solutions: - Stop the filter graph before modifying settings - Configure encoder before connecting filter pins - Query settings before starting playback/capture

Poor Compression Ratio

Symptom: FLAC files are larger than expected

Possible Causes: 1. Low encoding level (0-2) 2. Source audio is already compressed (MP3, AAC) 3. Source audio has high noise floor 4. Inappropriate block size for sample rate

Solutions: - Increase encoding level to 5-8 - Never re-encode already compressed audio - FLAC cannot improve quality - Use noise reduction on source audio before encoding - Adjust block size to match sample rate (see recommendations above)

Encoding Too Slow

Symptom: Real-time encoding cannot keep up with audio stream

Solutions: 1. Reduce encoding level to 0-3 2. Disable exhaustive model search 3. Reduce LPC order to 8 4. Reduce Rice partition max to 4 5. Use smaller block sizes (1152 or less)

Audio Pops or Clicks in Encoded Output

Symptom: Audible artifacts in encoded FLAC files

Possible Causes: 1. Encoder cannot process fast enough (buffer underruns) 2. Incompatible block size with sample rate 3. Hardware performance issues

Solutions: - Reduce encoding complexity (lower level, disable exhaustive search) - Use standard block sizes for the sample rate - Increase DirectShow buffer sizes - Reduce system load during encoding

Stereo Encoding Issues

Symptom: Stereo audio sounds incorrect or mono

Check: - Verify input is actually stereo (2 channels) - Mid-side coding only works with stereo input - Check if adaptive mid-side is enabled for best results - Verify filter graph audio format (use GraphEdit to inspect)

Technical Notes

FLAC Encoding Process

FLAC encoding involves several stages: 1. Blocking: Audio divided into blocks 2. Prediction: LPC analysis predicts sample values 3. Mid-Side Coding: Optional stereo decorrelation (for 2-channel audio) 4. Residual Encoding: Rice coding compresses prediction errors 5. Frame Assembly: Blocks assembled into FLAC frames

Performance Characteristics

CPU Usage by Setting: - Encoding Level: ~10% increase per level - LPC Order: ~5% increase per 4 orders - Exhaustive Search: 200-400% increase - Mid-Side Coding: ~2-5% increase

Memory Requirements: - Minimal: ~512KB working memory - Larger blocks require more memory - No significant dependency on audio duration

Compatibility

FLAC files encoded with any settings combination are compatible with all FLAC decoders. Higher compression settings only affect encoding time and file size, not decoder compatibility or playback quality.

---

See Also

• LAME MP3 Encoder Interface
• Audio Codecs Reference
• Encoding Filters Pack Overview