@@ -365,4 +365,47 @@ is highly recommended that it be left as enabled except for testing purposes.

 @end table

+@subheading Floating-Point-Only AC-3 Encoding Options

+

+These options are only valid for the floating-point encoder and do not exist

+for the fixed-point encoder due to the corresponding features not being

+implemented in fixed-point.

+

+@table @option

+

+@item -channel_coupling @var{boolean}

+Enables/Disables use of channel coupling, which is an optional AC-3 feature

+that increases quality by combining high frequency information from multiple

+channels into a single channel. The per-channel high frequency information is

+sent with less accuracy in both the frequency and time domains. This allows

+more bits to be used for lower frequencies while preserving enough information

+to reconstruct the high frequencies. This option is enabled by default for the

+floating-point encoder and should generally be left as enabled except for

+testing purposes or to increase encoding speed.

+@table @option

+@item -1

+@itemx auto

+Selected by Encoder (default)

+@item 0

+@itemx off

+Disable Channel Coupling

+@item 1

+@itemx on

+Enable Channel Coupling

+@end table

+

+@item -cpl_start_band @var{number}

+Coupling Start Band. Sets the channel coupling start band, from 1 to 15. If a

+value higher than the bandwidth is used, it will be reduced to 1 less than the

+coupling end band. If @var{auto} is used, the start band will be determined by

+the encoder based on the bit rate, sample rate, and channel layout. This option

+has no effect if channel coupling is disabled.

+@table @option

+@item -1

+@itemx auto

+Selected by Encoder (default)

+@end table

+

+@end table

+

 @c man end ENCODERS

@@ -28,7 +28,8 @@

 #define AVCODEC_AC3_H

 #define AC3_MAX_CODED_FRAME_SIZE 3840 /* in bytes */

-#define AC3_MAX_CHANNELS 6 /* including LFE channel */

+#define AC3_MAX_CHANNELS 7            /**< maximum number of channels, including coupling channel */

+#define CPL_CH 0                      /**< coupling channel index */

 #define AC3_MAX_COEFS   256

 #define AC3_BLOCK_SIZE  256

@@ -58,11 +58,6 @@

 #include "fft.h"

 #include "fmtconvert.h"

-/* override ac3.h to include coupling channel */

-#undef AC3_MAX_CHANNELS

-#define AC3_MAX_CHANNELS 7

-#define CPL_CH 0

-

 #define AC3_OUTPUT_LFEON  8

 #define SPX_MAX_BANDS    17

@@ -54,12 +54,6 @@ const uint8_t ff_eac3_hebap_tab[64] = {

 };

 /**

- * Table E2.16 Default Coupling Banding Structure

- */

-const uint8_t ff_eac3_default_cpl_band_struct[18] =

-{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1 };

-

-/**

  * Table E2.15 Default Spectral Extension Banding Structure

  */

 const uint8_t ff_eac3_default_spx_band_struct[17] =

@@ -27,7 +27,6 @@

 extern const uint8_t ff_ac3_ungroup_3_in_5_bits_tab[32][3];

 extern const uint8_t ff_eac3_hebap_tab[64];

-extern const uint8_t ff_eac3_default_cpl_band_struct[18];

 extern const uint8_t ff_eac3_default_spx_band_struct[17];

 #endif /* AVCODEC_AC3DEC_DATA_H */

@@ -99,6 +99,8 @@ typedef struct AC3EncOptions {

     /* other encoding options */

     int allow_per_frame_metadata;

     int stereo_rematrixing;

+    int channel_coupling;

+    int cpl_start;

 } AC3EncOptions;

 /**

@@ -114,10 +116,22 @@ typedef struct AC3Block {

     int16_t  **band_psd;                        ///< psd per critical band

     int16_t  **mask;                            ///< masking curve

     uint16_t **qmant;                           ///< quantized mantissas

+    uint8_t  **cpl_coord_exp;                   ///< coupling coord exponents           (cplcoexp)

+    uint8_t  **cpl_coord_mant;                  ///< coupling coord mantissas           (cplcomant)

     uint8_t  coeff_shift[AC3_MAX_CHANNELS];     ///< fixed-point coefficient shift values

     uint8_t  new_rematrixing_strategy;          ///< send new rematrixing flags in this block

+    int      num_rematrixing_bands;             ///< number of rematrixing bands

     uint8_t  rematrixing_flags[4];              ///< rematrixing flags

     struct AC3Block *exp_ref_block[AC3_MAX_CHANNELS]; ///< reference blocks for EXP_REUSE

+    int      new_cpl_strategy;                  ///< send new coupling strategy

+    int      cpl_in_use;                        ///< coupling in use for this block     (cplinu)

+    uint8_t  channel_in_cpl[AC3_MAX_CHANNELS];  ///< channel in coupling                (chincpl)

+    int      num_cpl_channels;                  ///< number of channels in coupling

+    uint8_t  new_cpl_coords;                    ///< send new coupling coordinates      (cplcoe)

+    uint8_t  cpl_master_exp[AC3_MAX_CHANNELS];  ///< coupling coord master exponents    (mstrcplco)

+    int      new_snr_offsets;                   ///< send new SNR offsets

+    int      new_cpl_leak;                      ///< send new coupling leak info

+    int      end_freq[AC3_MAX_CHANNELS];        ///< end frequency bin                  (endmant)

 } AC3Block;

 /**

@@ -164,10 +178,16 @@ typedef struct AC3EncodeContext {

     int cutoff;                             ///< user-specified cutoff frequency, in Hz

     int bandwidth_code;                     ///< bandwidth code (0 to 60)               (chbwcod)

-    int nb_coefs[AC3_MAX_CHANNELS];

+    int start_freq[AC3_MAX_CHANNELS];       ///< start frequency bin                    (strtmant)

+    int cpl_end_freq;                       ///< coupling channel end frequency bin

+

+    int cpl_on;                             ///< coupling turned on for this frame

+    int cpl_enabled;                        ///< coupling enabled for all frames

+    int num_cpl_subbands;                   ///< number of coupling subbands            (ncplsubnd)

+    int num_cpl_bands;                      ///< number of coupling bands               (ncplbnd)

+    uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS];  ///< number of coeffs in each coupling band

     int rematrixing_enabled;                ///< stereo rematrixing enabled

-    int num_rematrixing_bands;              ///< number of rematrixing bands

     /* bitrate allocation control */

     int slow_gain_code;                     ///< slow gain code                         (sgaincod)

@@ -194,6 +214,8 @@ typedef struct AC3EncodeContext {

     int16_t *band_psd_buffer;

     int16_t *mask_buffer;

     uint16_t *qmant_buffer;

+    uint8_t *cpl_coord_exp_buffer;

+    uint8_t *cpl_coord_mant_buffer;

     uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies

@@ -267,6 +289,12 @@ static const AVOption options[] = {

     {"hdcd",     "HDCD",               0, FF_OPT_TYPE_CONST, {.dbl = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},

 /* Other Encoding Options */

 {"stereo_rematrixing", "Stereo Rematrixing", OFFSET(stereo_rematrixing), FF_OPT_TYPE_INT, {.dbl = 1 }, 0, 1, AC3ENC_PARAM},

+#if CONFIG_AC3ENC_FLOAT

+{"channel_coupling",   "Channel Coupling",   OFFSET(channel_coupling),   FF_OPT_TYPE_INT, {.dbl = 1 }, 0, 1, AC3ENC_PARAM, "channel_coupling"},

+    {"auto", "Selected by the Encoder", 0, FF_OPT_TYPE_CONST, {.dbl = -1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "channel_coupling"},

+{"cpl_start_band", "Coupling Start Band", OFFSET(cpl_start), FF_OPT_TYPE_INT, {.dbl = -1 }, -1, 15, AC3ENC_PARAM, "cpl_start_band"},

+    {"auto", "Selected by the Encoder", 0, FF_OPT_TYPE_CONST, {.dbl = -1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "cpl_start_band"},

+#endif

 {NULL}

 };

@@ -296,9 +324,9 @@ static void scale_coefficients(AC3EncodeContext *s);

 /**

  * LUT for number of exponent groups.

- * exponent_group_tab[exponent strategy-1][number of coefficients]

+ * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]

  */

-static uint8_t exponent_group_tab[3][256];

+static uint8_t exponent_group_tab[2][3][256];

 /**

@@ -358,6 +386,49 @@ static const uint8_t ac3_bandwidth_tab[5][3][19] = {

 /**

+ * LUT to select the coupling start band based on the bit rate, sample rate, and

+ * number of full-bandwidth channels. -1 = coupling off

+ * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]

+ *

+ * TODO: more testing for optimal parameters.

+ *       multi-channel tests at 44.1kHz and 32kHz.

+ */

+static const int8_t ac3_coupling_start_tab[6][3][19] = {

+//      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640

+

+    // 2/0

+    { {  0,  0,  0,  0,  0,  0,  0,  1,  1,  7,  8, 11, 12, -1, -1, -1, -1, -1, -1 },

+      {  0,  0,  0,  0,  0,  0,  1,  3,  5,  7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },

+      {  0,  0,  0,  0,  1,  2,  2,  9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+

+    // 3/0

+    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },

+      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },

+      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+

+    // 2/1 - untested

+    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },

+      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },

+      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+

+    // 3/1

+    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },

+      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },

+      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+

+    // 2/2 - untested

+    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },

+      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },

+      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+

+    // 3/2

+    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },

+      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },

+      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

+};

+

+

+/**

  * Adjust the frame size to make the average bit rate match the target bit rate.

  * This is only needed for 11025, 22050, and 44100 sample rates.

  */

@@ -419,15 +490,297 @@ static void apply_mdct(AC3EncodeContext *s)

             apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE);

-            block->coeff_shift[ch] = normalize_samples(s);

+            block->coeff_shift[ch+1] = normalize_samples(s);

-            s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch],

+            s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch+1],

                                    s->windowed_samples);

         }

     }

 }

+static void compute_coupling_strategy(AC3EncodeContext *s)

+{

+    int blk, ch;

+    int got_cpl_snr;

+

+    /* set coupling use flags for each block/channel */

+    /* TODO: turn coupling on/off and adjust start band based on bit usage */

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+        for (ch = 1; ch <= s->fbw_channels; ch++)

+            block->channel_in_cpl[ch] = s->cpl_on;

+    }

+

+    /* enable coupling for each block if at least 2 channels have coupling

+       enabled for that block */

+    got_cpl_snr = 0;

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+        block->num_cpl_channels = 0;

+        for (ch = 1; ch <= s->fbw_channels; ch++)

+            block->num_cpl_channels += block->channel_in_cpl[ch];

+        block->cpl_in_use = block->num_cpl_channels > 1;

+        if (!block->cpl_in_use) {

+            block->num_cpl_channels = 0;

+            for (ch = 1; ch <= s->fbw_channels; ch++)

+                block->channel_in_cpl[ch] = 0;

+        }

+

+        block->new_cpl_strategy = !blk;

+        if (blk) {

+            for (ch = 1; ch <= s->fbw_channels; ch++) {

+                if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {

+                    block->new_cpl_strategy = 1;

+                    break;

+                }

+            }

+        }

+        block->new_cpl_leak = block->new_cpl_strategy;

+

+        if (!blk || (block->cpl_in_use && !got_cpl_snr)) {

+            block->new_snr_offsets = 1;

+            if (block->cpl_in_use)

+                got_cpl_snr = 1;

+        } else {

+            block->new_snr_offsets = 0;

+        }

+    }

+

+    /* set bandwidth for each channel */

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+        for (ch = 1; ch <= s->fbw_channels; ch++) {

+            if (block->channel_in_cpl[ch])

+                block->end_freq[ch] = s->start_freq[CPL_CH];

+            else

+                block->end_freq[ch] = s->bandwidth_code * 3 + 73;

+        }

+    }

+}

+

+

+/**

+ * Calculate a single coupling coordinate.

+ */

+static inline float calc_cpl_coord(float energy_ch, float energy_cpl)

+{

+    float coord = 0.125;

+    if (energy_cpl > 0)

+        coord *= sqrtf(energy_ch / energy_cpl);

+    return coord;

+}

+

+

+/**

+ * Calculate coupling channel and coupling coordinates.

+ * TODO: Currently this is only used for the floating-point encoder. I was

+ *       able to make it work for the fixed-point encoder, but quality was

+ *       generally lower in most cases than not using coupling. If a more

+ *       adaptive coupling strategy were to be implemented it might be useful

+ *       at that time to use coupling for the fixed-point encoder as well.

+ */

+static void apply_channel_coupling(AC3EncodeContext *s)

+{

+#if CONFIG_AC3ENC_FLOAT

+    DECLARE_ALIGNED(16, float,   cpl_coords)      [AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16];

+    DECLARE_ALIGNED(16, int32_t, fixed_cpl_coords)[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16];

+    int blk, ch, bnd, i, j;

+    CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};

+    int num_cpl_coefs = s->num_cpl_subbands * 12;

+

+    /* calculate coupling channel from fbw channels */

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+        CoefType *cpl_coef = &block->mdct_coef[CPL_CH][s->start_freq[CPL_CH]];

+        if (!block->cpl_in_use)

+            continue;

+        memset(cpl_coef-1, 0, (num_cpl_coefs+4) * sizeof(*cpl_coef));

+        for (ch = 1; ch <= s->fbw_channels; ch++) {

+            CoefType *ch_coef = &block->mdct_coef[ch][s->start_freq[CPL_CH]];

+            if (!block->channel_in_cpl[ch])

+                continue;

+            for (i = 0; i < num_cpl_coefs; i++)

+                cpl_coef[i] += ch_coef[i];

+        }

+        /* note: coupling start bin % 4 will always be 1 and num_cpl_coefs

+                 will always be a multiple of 12, so we need to subtract 1 from

+                 the start and add 4 to the length when using optimized

+                 functions which require 16-byte alignment. */

+

+        /* coefficients must be clipped to +/- 1.0 in order to be encoded */

+        s->dsp.vector_clipf(cpl_coef-1, cpl_coef-1, -1.0f, 1.0f, num_cpl_coefs+4);

+

+        /* scale coupling coefficients from float to 24-bit fixed-point */

+        s->ac3dsp.float_to_fixed24(&block->fixed_coef[CPL_CH][s->start_freq[CPL_CH]-1],

+                                   cpl_coef-1, num_cpl_coefs+4);

+    }

+

+    /* calculate energy in each band in coupling channel and each fbw channel */

+    /* TODO: possibly use SIMD to speed up energy calculation */

+    bnd = 0;

+    i = s->start_freq[CPL_CH];

+    while (i < s->cpl_end_freq) {

+        int band_size = s->cpl_band_sizes[bnd];

+        for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {

+            for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+                AC3Block *block = &s->blocks[blk];

+                if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))

+                    continue;

+                for (j = 0; j < band_size; j++) {

+                    CoefType v = block->mdct_coef[ch][i+j];

+                    MAC_COEF(energy[blk][ch][bnd], v, v);

+                }

+            }

+        }

+        i += band_size;

+        bnd++;

+    }

+

+    /* determine which blocks to send new coupling coordinates for */

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block  = &s->blocks[blk];

+        AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;

+        int new_coords = 0;

+        CoefSumType coord_diff[AC3_MAX_CHANNELS] = {0,};

+

+        if (block->cpl_in_use) {

+            /* calculate coupling coordinates for all blocks and calculate the

+               average difference between coordinates in successive blocks */

+            for (ch = 1; ch <= s->fbw_channels; ch++) {

+                if (!block->channel_in_cpl[ch])

+                    continue;

+

+                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

+                    cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],

+                                                              energy[blk][CPL_CH][bnd]);

+                    if (blk > 0 && block0->cpl_in_use &&

+                        block0->channel_in_cpl[ch]) {

+                        coord_diff[ch] += fabs(cpl_coords[blk-1][ch][bnd] -

+                                               cpl_coords[blk  ][ch][bnd]);

+                    }

+                }

+                coord_diff[ch] /= s->num_cpl_bands;

+            }

+

+            /* send new coordinates if this is the first block, if previous

+             * block did not use coupling but this block does, the channels

+             * using coupling has changed from the previous block, or the

+             * coordinate difference from the last block for any channel is

+             * greater than a threshold value. */

+            if (blk == 0) {

+                new_coords = 1;

+            } else if (!block0->cpl_in_use) {

+                new_coords = 1;

+            } else {

+                for (ch = 1; ch <= s->fbw_channels; ch++) {

+                    if (block->channel_in_cpl[ch] && !block0->channel_in_cpl[ch]) {

+                        new_coords = 1;

+                        break;

+                    }

+                }

+                if (!new_coords) {

+                    for (ch = 1; ch <= s->fbw_channels; ch++) {

+                        if (block->channel_in_cpl[ch] && coord_diff[ch] > 0.04) {

+                            new_coords = 1;

+                            break;

+                        }

+                    }

+                }

+            }

+        }

+        block->new_cpl_coords = new_coords;

+    }

+

+    /* calculate final coupling coordinates, taking into account reusing of

+       coordinates in successive blocks */

+    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

+        blk = 0;

+        while (blk < AC3_MAX_BLOCKS) {

+            int blk1;

+            CoefSumType energy_cpl;

+            AC3Block *block  = &s->blocks[blk];

+

+            if (!block->cpl_in_use) {

+                blk++;

+                continue;

+            }

+

+            energy_cpl = energy[blk][CPL_CH][bnd];

+            blk1 = blk+1;

+            while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) {

+                if (s->blocks[blk1].cpl_in_use)

+                    energy_cpl += energy[blk1][CPL_CH][bnd];

+                blk1++;

+            }

+

+            for (ch = 1; ch <= s->fbw_channels; ch++) {

+                CoefType energy_ch;

+                if (!block->channel_in_cpl[ch])

+                    continue;

+                energy_ch = energy[blk][ch][bnd];

+                blk1 = blk+1;

+                while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) {

+                    if (s->blocks[blk1].cpl_in_use)

+                        energy_ch += energy[blk1][ch][bnd];

+                    blk1++;

+                }

+                cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);

+            }

+            blk = blk1;

+        }

+    }

+

+    /* calculate exponents/mantissas for coupling coordinates */

+    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+        if (!block->cpl_in_use || !block->new_cpl_coords)

+            continue;

+

+        s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],

+                                   cpl_coords[blk][1],

+                                   s->fbw_channels * 16);

+        s->ac3dsp.extract_exponents(block->cpl_coord_exp[1],

+                                    fixed_cpl_coords[blk][1],

+                                    s->fbw_channels * 16);

+

+        for (ch = 1; ch <= s->fbw_channels; ch++) {

+            int bnd, min_exp, max_exp, master_exp;

+

+            /* determine master exponent */

+            min_exp = max_exp = block->cpl_coord_exp[ch][0];

+            for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {

+                int exp = block->cpl_coord_exp[ch][bnd];

+                min_exp = FFMIN(exp, min_exp);

+                max_exp = FFMAX(exp, max_exp);

+            }

+            master_exp = ((max_exp - 15) + 2) / 3;

+            master_exp = FFMAX(master_exp, 0);

+            while (min_exp < master_exp * 3)

+                master_exp--;

+            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

+                block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -

+                                                        master_exp * 3, 0, 15);

+            }

+            block->cpl_master_exp[ch] = master_exp;

+

+            /* quantize mantissas */

+            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

+                int cpl_exp  = block->cpl_coord_exp[ch][bnd];

+                int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;

+                if (cpl_exp == 15)

+                    cpl_mant >>= 1;

+                else

+                    cpl_mant -= 16;

+

+                block->cpl_coord_mant[ch][bnd] = cpl_mant;

+            }

+        }

+    }

+#endif /* CONFIG_AC3ENC_FLOAT */

+}

+

+

 /**

  * Determine rematrixing flags for each block and band.

  */

@@ -440,23 +793,32 @@ static void compute_rematrixing_strategy(AC3EncodeContext *s)

     if (s->channel_mode != AC3_CHMODE_STEREO)

         return;

-    s->num_rematrixing_bands = 4;

-

-    nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);

-

     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

         block = &s->blocks[blk];

         block->new_rematrixing_strategy = !blk;

-        if (!s->rematrixing_enabled)

+

+        if (!s->rematrixing_enabled) {

+            block0 = block;

             continue;

-        for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {

+        }

+

+        block->num_rematrixing_bands = 4;

+        if (block->cpl_in_use) {

+            block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);

+            block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);

+            if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)

+                block->new_rematrixing_strategy = 1;

+        }

+        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);

+

+        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {

             /* calculate calculate sum of squared coeffs for one band in one block */

             int start = ff_ac3_rematrix_band_tab[bnd];

             int end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);

             CoefSumType sum[4] = {0,};

             for (i = start; i < end; i++) {

-                CoefType lt = block->mdct_coef[0][i];

-                CoefType rt = block->mdct_coef[1][i];

+                CoefType lt = block->mdct_coef[1][i];

+                CoefType rt = block->mdct_coef[2][i];

                 CoefType md = lt + rt;

                 CoefType sd = lt - rt;

                 MAC_COEF(sum[0], lt, lt);

@@ -495,21 +857,20 @@ static void apply_rematrixing(AC3EncodeContext *s)

     if (!s->rematrixing_enabled)

         return;

-    nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);

-

     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

         AC3Block *block = &s->blocks[blk];

         if (block->new_rematrixing_strategy)

             flags = block->rematrixing_flags;

-        for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {

+        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);

+        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {

             if (flags[bnd]) {

                 start = ff_ac3_rematrix_band_tab[bnd];

                 end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);

                 for (i = start; i < end; i++) {

-                    int32_t lt = block->fixed_coef[0][i];

-                    int32_t rt = block->fixed_coef[1][i];

-                    block->fixed_coef[0][i] = (lt + rt) >> 1;

-                    block->fixed_coef[1][i] = (lt - rt) >> 1;

+                    int32_t lt = block->fixed_coef[1][i];

+                    int32_t rt = block->fixed_coef[2][i];

+                    block->fixed_coef[1][i] = (lt + rt) >> 1;

+                    block->fixed_coef[2][i] = (lt - rt) >> 1;

                 }

             }

         }

@@ -526,12 +887,13 @@ static av_cold void exponent_init(AC3EncodeContext *s)

     for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {

         grpsize = 3 << expstr;

-        for (i = 73; i < 256; i++) {

-            exponent_group_tab[expstr][i] = (i + grpsize - 4) / grpsize;

+        for (i = 12; i < 256; i++) {

+            exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;

+            exponent_group_tab[1][expstr][i] = (i              ) / grpsize;

         }

     }

     /* LFE */

-    exponent_group_tab[0][7] = 2;

+    exponent_group_tab[0][0][7] = 2;

 }

@@ -544,7 +906,7 @@ static void extract_exponents(AC3EncodeContext *s)

 {

     int blk, ch;

-    for (ch = 0; ch < s->channels; ch++) {

+    for (ch = !s->cpl_on; ch <= s->channels; ch++) {

         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

             AC3Block *block = &s->blocks[blk];

             s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch],

@@ -569,7 +931,7 @@ static void compute_exp_strategy(AC3EncodeContext *s)

 {

     int ch, blk, blk1;

-    for (ch = 0; ch < s->fbw_channels; ch++) {

+    for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {

         uint8_t *exp_strategy = s->exp_strategy[ch];

         uint8_t *exp          = s->blocks[0].exp[ch];

         int exp_diff;

@@ -578,13 +940,18 @@ static void compute_exp_strategy(AC3EncodeContext *s)

            reused in the next frame */

         exp_strategy[0] = EXP_NEW;

         exp += AC3_MAX_COEFS;

-        for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {

+        for (blk = 1; blk < AC3_MAX_BLOCKS; blk++, exp += AC3_MAX_COEFS) {

+            if ((ch == CPL_CH && (!s->blocks[blk].cpl_in_use || !s->blocks[blk-1].cpl_in_use)) ||

+                (ch  > CPL_CH && (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]))) {

+                exp_strategy[blk] = EXP_NEW;

+                continue;

+            }

             exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);

-            if (exp_diff > EXP_DIFF_THRESHOLD)

+            exp_strategy[blk] = EXP_REUSE;

+            if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))

+                exp_strategy[blk] = EXP_NEW;

+            else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)

                 exp_strategy[blk] = EXP_NEW;

-            else

-                exp_strategy[blk] = EXP_REUSE;

-            exp += AC3_MAX_COEFS;

         }

         /* now select the encoding strategy type : if exponents are often

@@ -615,25 +982,26 @@ static void compute_exp_strategy(AC3EncodeContext *s)

 /**

  * Update the exponents so that they are the ones the decoder will decode.

  */

-static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy)

+static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,

+                                    int cpl)

 {

     int nb_groups, i, k;

-    nb_groups = exponent_group_tab[exp_strategy-1][nb_exps] * 3;

+    nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;

     /* for each group, compute the minimum exponent */

     switch(exp_strategy) {

     case EXP_D25:

-        for (i = 1, k = 1; i <= nb_groups; i++) {

+        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {

             uint8_t exp_min = exp[k];

             if (exp[k+1] < exp_min)

                 exp_min = exp[k+1];

-            exp[i] = exp_min;

+            exp[i-cpl] = exp_min;

             k += 2;

         }

         break;

     case EXP_D45:

-        for (i = 1, k = 1; i <= nb_groups; i++) {

+        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {

             uint8_t exp_min = exp[k];

             if (exp[k+1] < exp_min)

                 exp_min = exp[k+1];

@@ -641,14 +1009,14 @@ static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy)

                 exp_min = exp[k+2];

             if (exp[k+3] < exp_min)

                 exp_min = exp[k+3];

-            exp[i] = exp_min;

+            exp[i-cpl] = exp_min;

             k += 4;

         }

         break;

     }

     /* constraint for DC exponent */

-    if (exp[0] > 15)

+    if (!cpl && exp[0] > 15)

         exp[0] = 15;

     /* decrease the delta between each groups to within 2 so that they can be

@@ -659,18 +1027,21 @@ static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy)

     while (--i >= 0)

         exp[i] = FFMIN(exp[i], exp[i+1] + 2);

+    if (cpl)

+        exp[-1] = exp[0] & ~1;

+

     /* now we have the exponent values the decoder will see */

     switch (exp_strategy) {

     case EXP_D25:

-        for (i = nb_groups, k = nb_groups * 2; i > 0; i--) {

-            uint8_t exp1 = exp[i];

+        for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {

+            uint8_t exp1 = exp[i-cpl];

             exp[k--] = exp1;

             exp[k--] = exp1;

         }

         break;

     case EXP_D45:

-        for (i = nb_groups, k = nb_groups * 4; i > 0; i--) {

-            exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i];

+        for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {

+            exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];

             k -= 4;

         }

         break;

@@ -686,32 +1057,40 @@ static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy)

  */

 static void encode_exponents(AC3EncodeContext *s)

 {

-    int blk, blk1, ch;

+    int blk, blk1, ch, cpl;

     uint8_t *exp, *exp_strategy;

     int nb_coefs, num_reuse_blocks;

-    for (ch = 0; ch < s->channels; ch++) {

-        exp          = s->blocks[0].exp[ch];

+    for (ch = !s->cpl_on; ch <= s->channels; ch++) {

+        exp          = s->blocks[0].exp[ch] + s->start_freq[ch];

         exp_strategy = s->exp_strategy[ch];

-        nb_coefs     = s->nb_coefs[ch];

+        cpl = (ch == CPL_CH);

         blk = 0;

         while (blk < AC3_MAX_BLOCKS) {

+            AC3Block *block = &s->blocks[blk];

+            if (cpl && !block->cpl_in_use) {

+                exp += AC3_MAX_COEFS;

+                blk++;

+                continue;

+            }

+            nb_coefs = block->end_freq[ch] - s->start_freq[ch];

             blk1 = blk + 1;

             /* count the number of EXP_REUSE blocks after the current block

                and set exponent reference block pointers */

-            s->blocks[blk].exp_ref_block[ch] = &s->blocks[blk];

+            block->exp_ref_block[ch] = block;

             while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE) {

-                s->blocks[blk1].exp_ref_block[ch] = &s->blocks[blk];

+                s->blocks[blk1].exp_ref_block[ch] = block;

                 blk1++;

             }

             num_reuse_blocks = blk1 - blk - 1;

             /* for the EXP_REUSE case we select the min of the exponents */

-            s->ac3dsp.ac3_exponent_min(exp, num_reuse_blocks, nb_coefs);

+            s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,

+                                       AC3_MAX_COEFS);

-            encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk]);

+            encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);

             exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);

             blk = blk1;

@@ -727,7 +1106,7 @@ static void encode_exponents(AC3EncodeContext *s)

  */

 static void group_exponents(AC3EncodeContext *s)

 {

-    int blk, ch, i;

+    int blk, ch, i, cpl;

     int group_size, nb_groups, bit_count;

     uint8_t *p;

     int delta0, delta1, delta2;

@@ -736,14 +1115,15 @@ static void group_exponents(AC3EncodeContext *s)

     bit_count = 0;

     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

         AC3Block *block = &s->blocks[blk];

-        for (ch = 0; ch < s->channels; ch++) {

+        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {

             int exp_strategy = s->exp_strategy[ch][blk];

             if (exp_strategy == EXP_REUSE)

                 continue;

+            cpl = (ch == CPL_CH);

             group_size = exp_strategy + (exp_strategy == EXP_D45);

-            nb_groups = exponent_group_tab[exp_strategy-1][s->nb_coefs[ch]];

+            nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];

             bit_count += 4 + (nb_groups * 7);

-            p = block->exp[ch];

+            p = block->exp[ch] + s->start_freq[ch] - cpl;

             /* DC exponent */

             exp1 = *p++;

@@ -810,9 +1190,7 @@ static void count_frame_bits_fixed(AC3EncodeContext *s)

     /* assumptions:

      *   no dynamic range codes

-     *   no channel coupling

      *   bit allocation parameters do not change between blocks

-     *   SNR offsets do not change between blocks

      *   no delta bit allocation

      *   no skipped data

      *   no auxilliary data

@@ -833,11 +1211,6 @@ static void count_frame_bits_fixed(AC3EncodeContext *s)

         /* dynamic range */

         frame_bits++;

-        /* coupling strategy */

-        frame_bits++;

-        if (!blk)

-            frame_bits++;

-

         /* exponent strategy */

         frame_bits += 2 * s->fbw_channels;

         if (s->lfe_on)

@@ -848,11 +1221,6 @@ static void count_frame_bits_fixed(AC3EncodeContext *s)

         if (!blk)

             frame_bits += 2 + 2 + 2 + 2 + 3;

-        /* snr offsets and fast gain codes */

-        frame_bits++;

-        if (!blk)

-            frame_bits += 6 + s->channels * (4 + 3);

-

         /* delta bit allocation */

         frame_bits++;

@@ -884,7 +1252,7 @@ static void bit_alloc_init(AC3EncodeContext *s)

     s->slow_gain_code  = 1;

     s->db_per_bit_code = 3;

     s->floor_code      = 7;

-    for (ch = 0; ch < s->channels; ch++)

+    for (ch = 0; ch <= s->channels; ch++)

         s->fast_gain_code[ch] = 4;

     /* initial snr offset */

@@ -898,6 +1266,8 @@ static void bit_alloc_init(AC3EncodeContext *s)

     s->bit_alloc.slow_gain  = ff_ac3_slow_gain_tab[s->slow_gain_code];

     s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];

     s->bit_alloc.floor      = ff_ac3_floor_tab[s->floor_code];

+    s->bit_alloc.cpl_fast_leak = 0;

+    s->bit_alloc.cpl_slow_leak = 0;

     count_frame_bits_fixed(s);

 }

@@ -926,17 +1296,64 @@ static void count_frame_bits(AC3EncodeContext *s)

     /* audio blocks */

     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {

+        AC3Block *block = &s->blocks[blk];

+

+        /* coupling strategy */

+        frame_bits++;

+        if (block->new_cpl_strategy) {

+            frame_bits++;

+            if (block->cpl_in_use) {

+                frame_bits += s->fbw_channels;

+                if (s->channel_mode == AC3_CHMODE_STEREO)

+                    frame_bits++;

+                frame_bits += 4 + 4;

+                frame_bits += s->num_cpl_subbands - 1;

+            }

+        }

+

+        /* coupling coordinates */

+        if (block->cpl_in_use) {

+            for (ch = 1; ch <= s->fbw_channels; ch++) {

+                if (block->channel_in_cpl[ch]) {

+                    frame_bits++;

+                    if (block->new_cpl_coords) {

+                        frame_bits += 2;