---
updatedAt: 2025-06-18T15:10:08.000Z
agentTools:
  projectIndex: https://api.encoding.com/llms.txt
---

# Audio Multitrack Settings

<a name="audiomultitrack"></a>Encoding.com supports the use of multiple audio tracks mapped to outputs. You can change audio track settings in the <audio_stream> section.

```xml
<?xml version="1.0"?>
<query>
    <userid>[UserID]</userid> <!-- required-->
    <userkey>[UserKey]</userkey> <!-- required-->
    <action>[Action]</action> <!-- required-->
    <source>[SourceFile]</source> <!-- required -->
    <format>
        <output>[OutputFormat]</output> <!-- required -->
        <audio_stream>
            <use_stream_id>[SourceMediaAudioStreamID]</use_stream_id>
            <natural_order>[yes|no]</natural_order>
            <language>[ISO639-2 language identifier]</language>
            <!-- Common audio settings -->
            <channel>
                <id>[OutputChannelID]</id>
                <in>
                    <id>[SourceTrackID:SourceChannelID]</id>
                    <gain>[ChannelGainLevel]</gain>
                    <program_id>[ProgramID]</program_id>
                </in>
                <in>
                    <!-- input channel params -->
                </in>
                <split_layout>[SplitLayout]</split_layout>
            </channel>
            <channel>
                <!-- audio channel params -->
            </channel>
            <normalize>[yes|no]</normalize>
            <layout>[AudioLayoutName]</layout>
            <audio_channels_number>[ChannelsNumber]</audio_channels_number>
            <automix_channels>[yes|no]</automix_channels>
            <lfe_low>[LfeLow]</lfe_low>
            <lfe_high>[LfeHigh]</lfe_high>
            <split_channels>[yes|no]</split_channels>
            <validate>
                <on_error>[pass|fail|report]</on_error>
                <repair>[yes|no]</repair>
                <loudness_diff>[LoudnessDiff]<loudness_diff>
                <stereo_diff>[StereoDiff]</stereo_diff>
                <side_diff>[SideDiff]</side_diff>
            </validate>
            <metadata_channel_layout>[LayoutMetaData]</metadata_channel_layout>
            <upmix_channel_gain>
                <fl>[FLGain]</fl>
                <fr>[FRGain]</fr>
                <fc>[FCGain]</fc>
                <lfe>[LFGain]</lfe>
                <sl>[SLGain]</sl>
                <sr>[SRGain]</sr>
                <bl>[BLGain]</bl>
                <br/>[BRGain]</br>
                <bc>[BCGain]</bc>
            </upmix_channel_gain>
            <disposition>[visual_impaired|hearing_impaired]</disposition>
            <program_id>[ProgramID]</program_id>
            <audio_tune>
                <low_pass_filter>[FilterFrequency]</low_pass_filter>
                <high_pass_filter>[FilterFrequency]</high_pass_filter>
                <compand_points>[CompandFilter]</compand_points>
                <channel>
                    <id>[ChannelID]</id>
                    <low_pass_filter>[FilterFrequency]</low_pass_filter>
                    <high_pass_filter>[FilterFrequency]</high_pass_filter>
                    <compand_points>[CompandFilter]</compand_points>
                    <gain>[ChannelGainLevel]</gain>
                    <max_peak>[MaxPeakLevel]</max_peak>
                </channel>
                <channel>
                    <!-- audio tune channel params -->
                </channel>
            </audio_tune>
            <adjust_lra>[LRALevel]</adjust_lra>
            <accepted_loudness_interval>[LoudnessInterval]</accepted_loudness_interval>
            <frame_wrapping>[FrameWrapping]</frame_wrapping>
        </audio_stream>
        <!-- multiple audio_streams -->
        <audio_stream>
            <!-- audio_stream params -->
        </audio_stream>
        <!-- format params -->
    </format>
</query>
```
```json
{
    "query": {
        "userid": "[UserID]", // required
        "userkey": "[UserKey]", // required
        "action": "[Action]", // required
        "source": "[SourceFile]", // required
        "format": {
            "output": "[OutputFormat]", // required
            "audio_stream": [
                {
                    "use_stream_id": "[SourceMediaAudioStreamID]",
                    "natural_order": "[yes|no]",
                    "language": "[ISO639-2 language identifier]",
                    "channel": [
                        {
                            "id": "[OutputChannelID]",
                            "in": [
                                {
                                    "id": "[SourceTrackID:SourceChannelID]",
                                    "gain": "[ChannelGainLevel]",
                                    "program_id": "[ProgramID]"
                                },
                                {
                                    // input channel params
                                }
                            ],
                            "split_layout": "[SplitLayout]"
                        },
                        {
                            // audio channel params
                        }
                    ],
                    "normalize": "[yes|no]",
                    "layout": "[AudioLayoutName]",
                    "audio_channels_number": "[ChannelsNumber]",
                    "automix_channels": "[yes|no]",
                    "lfe_low": "[LfeLow]",
                    "lfe_high": "[LfeHigh]",
                    "split_channels": "[yes|no]",
                    "validate": {
                        "on_error": "[pass|fail|report]",
                        "repair": "[yes|no]",
                        "loudness_diff": "[LoudnessDiff]",
                        "stereo_diff": "[StereoDiff]",
                        "side_diff": "[SideDiff]"
                    },
                    "metadata_channel_layout": "[LayoutMetaData]",
                    "upmix_channel_gain": {
                        "fl": "[FLGain]",
                        "fr": "[FRGain]",
                        "fc": "[FCGain]",
                        "lfe": "[LFGain]",
                        "sl": "[SLGain]",
                        "sr": "[SRGain]",
                        "bl": "[BLGain]",
                        "br": "[BRGain]",
                        "bc": "[BCGain]"
                    },
                    "disposition": "[visual_impaired|hearing_impaired]",
                    "program_id": "[ProgramID]",
                    "audio_tune": {
                        "low_pass_filter": "[FilterFrequency]",
                        "high_pass_filter": "[FilterFrequency]",
                        "compand_points": "[CompandFilter]",
                        "channel": [
                            {
                                "id": "[ChannelID]",
                                "low_pass_filter": "[FilterFrequency]",
                                "high_pass_filter": "[FilterFrequency]",
                                "compand_points": "[CompandFilter]",
                                "gain": "[ChannelGainLevel]",
                                "max_peak": "[MaxPeakLevel]"
                            },
                            {
                                // audio tune channel params
                            }
                        ]
                    },
                    "adjust_lra": "[LRALevel]",
                    "accepted_loudness_interval": "[LoudnessInterval]",
                    "frame_wrapping": "[FrameWrapping]"
                },
                {
                    // audio_stream params
                }
            ]
            // format params
        }
    }
}
```

| Parameter                           | Description                                                                                                                                          | Allowed Values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Default Values                                             |
| :---------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------- |
| **Audio Stresm Parameters**         |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **use\_stream\_id**                 | Specify the source media stream ID.                                                                                                                  | Non negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | By default # of \*\*\<audio\_stream /> param will be used. |
| **natural\_order**                  | If set to *yes* then value of **\<use\_stream\_id />** will mean number of source's **audio** stream, not number of stream in all type streams list. | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | no                                                         |
| **language**                        | Specify the track language.                                                                                                                          | A language code in 3 lowercase letters according to [ISO639-2](https://www.loc.gov/standards/iso639-2/php/code_list.php).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | *none*                                                     |
| **normalize**                       | Enable the renormalization output track to avoid clipping noise.                                                                                     | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | *none*                                                     |
| **layout**                          | Specify the output channels layout.                                                                                                                  | One of these channel layouts:  <br/>mono — FC  <br/>stereo — FL+FR  <br/>2.1 — FL+FR+LFE  <br/>3.0 — FL+FR+FC  <br/>3.0-back — FL+FR+BC  <br/>4.0 — FL+FR+FC+BC  <br/>quad — FL+FR+BL+BR  <br/>quad-side — FL+FR+SL+SR  <br/>3.1 — FL+FR+FC+LFE  <br/>5.0 — FL+FR+FC+BL+BR  <br/>5.0-side — FL+FR+FC+SL+SR  <br/>4.1 — FL+FR+FC+LFE+BC  <br/>5.1 — FL+FR+FC+LFE+BL+BR  <br/>5.1-side — FL+FR+FC+LFE+SL+SR  <br/>6.0 — FL+FR+FC+BC+SL+SR  <br/>6.0-front — FL+FR+FLC+FRC+SL+SR  <br/>hexagonal — FL+FR+FC+BL+BR+BC  <br/>6.1 — FL+FR+FC+LFE+BC+SL+SR  <br/>6.1 — FL+FR+FC+LFE+BL+BR+BC  <br/>6.1-front — FL+FR+LFE+FLC+FRC+SL+SR  <br/>7.0 — FL+FR+FC+BL+BR+SL+SR  <br/>7.0-front — FL+FR+FC+FLC+FRC+SL+SR  <br/>7.1 — FL+FR+FC+LFE+BL+BR+SL+SR  <br/>7.1-wide — FL+FR+FC+LFE+BL+BR+FLC+FRC  <br/>7.1-wide-side — FL+FR+FC+LFE+FLC+FRC+SL+SR  <br/>octagonal — FL+FR+FC+BL+BR+BC+SL+SR  <br/>downmix — DL+DR                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **automix\_channels**               | Automatically upmix or downmix audio stream to the specified number of channels in **\<audio\_channels\_number />**                                  | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | no                                                         |
| **lfe\_low**                        | LFE low cut off frequency                                                                                                                            | Integer number between 3 and 255                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 20                                                         |
| **lfe\_high**                       | LFE high cut off frequency                                                                                                                           | Integer number between 3 and 512                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 120                                                        |
| **split\_channels**                 | Mux PCM audio stream channels into output as individual tracks.                                                                                      | yes, no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | no                                                         |
| **program\_id**                     | Output stream program id                                                                                                                             | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **adjust\_lra**                     | LRA value audio normalization that would be applied for large audio streams                                                                          | Positive float number between 1 and 20 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | *none*                                                     |
| **accepted\_loudness\_interval**    | Loudness interval of iterative loudness normalization for large audio streams                                                                        | Positive float number between 0.1 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 1                                                          |
| **Output Audio Channel Parameters** |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **id**                              | Specify the output channel ID.                                                                                                                       | Channel number or one of these channel names:  <br/>FL — front left  <br/>FR — front right  <br/>FC — front center  <br/>LFE — low frequency  <br/>BL — back left  <br/>BR — back right  <br/>FLC — front left-of-center  <br/>FRC — front right-of-center  <br/>BC — back center  <br/>SL — side left  <br/>SR — side right  <br/>TC — top center  <br/>TFL — top front left  <br/>TFC — top front center  <br/>TFR — top front right  <br/>TBL — top back left  <br/>TBC — top back center  <br/>TBR — top back right  <br/>DL — downmix left  <br/>DR — downmix right  <br/>WL — wide left  <br/>WR — wide right  <br/>SDL — surround direct left  <br/>SDR — surround direct right  <br/>LFE2 — low frequency 2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | *none*                                                     |
| **split\_layout**                   | Set stream layout name for if \*\*\<split\_channels />\*\*set to *yes*                                                                               | fl, fr, fc, lfe, bl, br, flc, frc, bc, sl, sr, tc, tfl, tfc, tfr, tbl, tbc, tbr, dl, dr, wl, wr, sdl, sdr, rsl, rsr, lw, rw, lfe2, lt, rt, -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | *none*                                                     |
| **Input Audio Channel Parameters**  |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **id**                              | Specify input audio channel ID.                                                                                                                      | Input channel ID in format \[track\_id]:\[channel\_id]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **gain**                            | Sepcify the input audio channel gain level.                                                                                                          | Float positive number from 0 to 1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | *none*                                                     |
| **program\_id**                     | Input channel program id                                                                                                                             | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **Validate Parameters**             | [See dedicated article](https://api.encoding.com/reference/features-audio-validation)                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **metadata\_channel\_layout**       | Force channel layout value in the stream metadata                                                                                                    | For **mov** and **dnxhd** output format:  <br/>**c** – C,  <br/>**l\_r** – L R,  <br/>**l\_r\_head** – L R Head,  <br/>**lt\_rt** – Lt Rt,  <br/>**m\_s** – M S,  <br/>**x\_y** – X Y,  <br/>**w\_x\_y\_z** – W X Y Z,  <br/>**l\_r\_ls\_rs** – L R Ls Rs,  <br/>**l\_r\_lrs\_rrs\_c** – L R Lrs Rrs C,  <br/>**l\_r\_lrs\_rrs\_c\_cs** – L R Lrs Rrs C Cs,  <br/>**l\_r\_lrs\_rrs\_c\_crs\_ls\_rs** – L R Lrs Rrs C Crs Ls Rs,  <br/>**l\_r\_lrs\_rrs\_vhl\_vhr\_vhlrs\_vhrrs** – L R Lrs Rrs Vhl Vhr Vhlrs Vhrrs,  <br/>**l\_r\_c** – L R C,  <br/>**c\_l\_r** – C L R,  <br/>**l\_r\_c\_cs** – L R C Cs,  <br/>**c\_l\_r\_cs** – C L R Cs,  <br/>**l\_r\_c\_ls\_rs** – L R C Ls Rs,  <br/>**l\_r\_ls\_rs\_c** – L R Ls Rs C,  <br/>**l\_c\_r\_ls\_rs** – L C R Ls Rs,  <br/>**c\_l\_r\_ls\_rs** – C L R Ls Rs,  <br/>**l\_r\_c\_lfe\_ls\_rs** – L R C LFE Ls Rs,  <br/>**l\_r\_ls\_rs\_c\_lfe** – L R Ls Rs C LFE,  <br/>**l\_c\_r\_ls\_rs\_lfe** – L C R Ls Rs LFE,  <br/>**c\_l\_r\_ls\_rs\_lfe** – C L R Ls Rs LFE,  <br/>**l\_r\_c\_lfe\_ls\_rs\_cs** – L R C LFE Ls Rs Cs,  <br/>**l\_r\_c\_lfe\_ls\_rs\_lc\_rc** – L R C LFE Ls Rs Lc Rc,  <br/>**c\_lc\_rc\_l\_r\_ls\_rs\_lfe** – C Lc Rc L R Ls Rs LFE,  <br/>**l\_r\_c\_lfe\_ls\_r\_rls\_rrs** – L R C LFE Ls R Rls Rrs,  <br/>**l\_r\_ls\_rs\_c\_lfe\_lc\_rc** – L R Ls Rs C LFE Lc Rc,  <br/>**l\_r\_c\_lfe\_ls\_rs\_lt\_rt** – L R C LFE Ls Rs Lt Rt,  <br/>**l\_r\_cs** – L R Cs,  <br/>**l\_r\_lfe** – L R LFE,  <br/>**l\_r\_lfe\_cs** – L R LFE Cs,  <br/>**l\_r\_lfe\_ls\_rs** – L R LFE Ls Rs,  <br/>**l\_r\_c\_lfe** – L R C LFE,  <br/>**l\_r\_c\_lfe\_cs** – L R C LFE Cs,  <br/>**l\_r\_ls\_rs\_lfe** – L R Ls Rs LFE,  <br/>**l\_r\_ls\_rs\_c\_cs** – L R Ls Rs C Cs,  <br/>**l\_r\_ls\_rs\_c\_rls\_rrs** – L R Ls Rs C Rls Rrs,  <br/>**c\_l\_r\_ls\_rs\_cs** – C L R Ls Rs Cs,  <br/>**c\_l\_r\_ls\_rs\_cs\_lfe** – C L R Ls Rs Cs LFE,  <br/>**c\_l\_r\_ls\_rs\_rls\_rrs** – C L R Ls Rs Rls Rrs,  <br/>**c\_l\_r\_ls\_rs\_rls\_rrs\_cs** – C L R Ls Rs Rls Rrs Cs,  <br/>**l\_r\_c\_vhc\_lsd\_rsd\_ls\_rs\_vhl\_vhr\_lw\_rw\_csd\_cs\_lfe1\_lfe2** – L R C Vhc Lsd Rsd Ls Rs Vhl Vhr Lw Rw Csd Cs LFE1 LFE2,  <br/>**l\_r\_c\_vhc\_lsd\_rsd\_ls\_rs\_vhl\_vhr\_lw\_rw\_csd\_cs\_lfe1\_lfe2\_lc\_rc\_hi\_vi\_haptic** – L R C Vhc Lsd Rsd Ls Rs Vhl Vhr Lw Rw Csd Cs LFE1 LFE2 Lc Rc HI VI Haptic  <br/>  <br/>For **mxf\_op1a** output format:  <br/>**L**, **FL**,  <br/>**R**, **FR**,  <br/>**C**, **FC**,  <br/>**LFE**,  <br/>**Ls**, **BL**,  <br/>**Rs**, **BR**,  <br/>**Lc**, **FLC**,  <br/>**RC**, **FRC**,  <br/>**Cs**, **BC**,  <br/>**Lsd**, **SL**,  <br/>**Rsd**, **SR**,  <br/>**Ts**, **TC**,  <br/>**Ltf**, **TFL**,  <br/>**Ctf**, **TFC**,  <br/>**Rtf**, **TFR**,  <br/>**Ltr**, **Trl**, **TBL**,  <br/>**Ctr**, **Trc**, **TBC**,  <br/>**Rtr**, **Trr**, **TBR**,  <br/>**Lts**, **TSL**,  <br/>**Lw**,  <br/>**Rw**,  <br/>**LFE2**,  <br/>**Lrs**,  <br/>**Rrs**,  <br/>**Lt**,  <br/>**Rt**,  <br/>**M** | *none*                                                     |
| **disposition**                     | Audio stream disposition type                                                                                                                        | visual\_impaired, hearing\_impaired                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | *none*                                                     |
| **frame\_wrapping**                 | Set audio frame wrapping mode. Affects only the mxf\_op1a output                                                                                     | aes3, bwf                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | *none*                                                     |
| **Upmix Channel Gain Parameters**   |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **fl**                              | Left channel gain                                                                                                                                    | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **fr**                              | Right channel gain                                                                                                                                   | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **fc**                              | Center channel gain                                                                                                                                  | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **lfe**                             | LFE channel gain                                                                                                                                     | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **sl**                              | Side left channel gain                                                                                                                               | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **sr**                              | Side right channel gain                                                                                                                              | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **bl**                              | Back left channel gain                                                                                                                               | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **br**                              | Back right channel gain                                                                                                                              | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **bc**                              | Back center channel gain                                                                                                                             | Float number between 0 and 1 inclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | *none*                                                     |
| **Audio Tune Parameters**           |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **low\_pass\_filter**               | Low Pass filter frequency                                                                                                                            | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **high\_pass\_filter**              | High Pass filter frequency                                                                                                                           | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **compand\_points**                 | Compand filter points separated by pipe symbol                                                                                                       | Valid compand filter string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **Audio Tune Channel Parameters**   |                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |                                                            |
| **id**                              | Channel ID starting from 0                                                                                                                           | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **low\_pass\_filter**               | Low Pass filter frequency                                                                                                                            | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **high\_pass\_filter**              | High Pass filter frequency                                                                                                                           | Non-negative integer number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **compand\_points**                 | Compand filter points separated by pipe symbol                                                                                                       | Valid compand filter string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **gain**                            | Channel gain level                                                                                                                                   | Float number between -100 and 100 exclusive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | *none*                                                     |
| **max\_peak**                       | Maximum true peak level. Channel volume will be decreased to hit the specified value if the channel peak value overshoot the limit                   | Negative float number greater than -100                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | *none*                                                     |

> 🚧 For lfe\_low and lfe\_hight
>
> **\<lfe\_low />** and **\<lfe\_hight />** parameters will be allied only in case of channel upmixing.

> 🚧 For split\_channels
>
> The **\<split\_channels />** parameter available only for PCM audio codecs.

> 🚧 For metadata\_channel\_layout
>
> The **\<metadata\_channel\_layout />** parameter available only for  **mov**, **dnxhd** and **mxf\_op1a** output formats.

> 🚧 For adjust\_lra and accepted\_loudness\_interval
>
> The **\<adjust\_lra />** and **\<accepted\_loudness\_interval />** parameters only applied for DEE processing for large audio streams with size over 4GB

> 🚧 For accepted\_loudness\_interval
>
> We discovered, that sometimes loudness normalization performed by our default audio encoder doesn't work well, especially on complex audio with a high loudness range. Therefore an iterative loudness correction procedure may be applied. The accepted\_loudness\_interval parameter tunes the exit criteria for this procedure by setting an acceptable loudness interval. Corresponding to the EBU recommendation we use default value equals to 1.