revert r1783

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@1785 10f7b99b-c216-0410-bff0-8a66a9350fd8

1 files changed, 186 insertions, 260 deletions

diff --git a/src/filters/transform/MPCVideoDec/ffmpeg/libavcodec/mlpdec.c b/src/filters/transform/MPCVideoDec/ffmpeg/libavcodec/mlpdec.c
index ac41e5441..a5ba3d0b6 100644
--- a/src/filters/transform/MPCVideoDec/ffmpeg/libavcodec/mlpdec.c
+++ b/src/filters/transform/MPCVideoDec/ffmpeg/libavcodec/mlpdec.c
@@ -44,8 +44,7 @@ static const char* sample_message =
     "http://ffmpeg.org/bugreports.html and include "
     "a sample of this file.";
 
-typedef struct SubStream
-{
+typedef struct SubStream {
     //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
     uint8_t     restart_seen;
 
@@ -116,8 +115,7 @@ typedef struct SubStream
 
 } SubStream;
 
-typedef struct MLPDecodeContext
-{
+typedef struct MLPDecodeContext {
     AVCodecContext *avctx;
 
     //! Current access unit being read has a major sync.
@@ -157,24 +155,23 @@ static VLC huff_vlc[3];
 
 static av_cold void init_static(void)
 {
-    if(!huff_vlc[0].bits)
-    {
+    if (!huff_vlc[0].bits) {
         INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
-                        &ff_mlp_huffman_tables[0][0][1], 2, 1,
-                        &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
+                    &ff_mlp_huffman_tables[0][0][1], 2, 1,
+                    &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
         INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
-                        &ff_mlp_huffman_tables[1][0][1], 2, 1,
-                        &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
+                    &ff_mlp_huffman_tables[1][0][1], 2, 1,
+                    &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
         INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
-                        &ff_mlp_huffman_tables[2][0][1], 2, 1,
-                        &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
+                    &ff_mlp_huffman_tables[2][0][1], 2, 1,
+                    &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
     }
 
     ff_mlp_init_crc();
 }
 
 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
-        unsigned int substr, unsigned int ch)
+                                          unsigned int substr, unsigned int ch)
 {
     ChannelParams *cp = &m->channel_params[ch];
     SubStream *s = &m->substream[substr];
@@ -182,10 +179,10 @@ static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
     int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
     int32_t sign_huff_offset = cp->huff_offset;
 
-    if(cp->codebook > 0)
+    if (cp->codebook > 0)
         sign_huff_offset -= 7 << lsb_bits;
 
-    if(sign_shift >= 0)
+    if (sign_shift >= 0)
         sign_huff_offset -= 1 << sign_shift;
 
     return sign_huff_offset;
@@ -200,26 +197,25 @@ static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
     SubStream *s = &m->substream[substr];
     unsigned int mat, channel;
 
-    for(mat = 0; mat < s->num_primitive_matrices; mat++)
-        if(s->lsb_bypass[mat])
+    for (mat = 0; mat < s->num_primitive_matrices; mat++)
+        if (s->lsb_bypass[mat])
             m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
 
-    for(channel = s->min_channel; channel <= s->max_channel; channel++)
-    {
+    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
         ChannelParams *cp = &m->channel_params[channel];
         int codebook = cp->codebook;
         int quant_step_size = s->quant_step_size[channel];
         int lsb_bits = cp->huff_lsbs - quant_step_size;
         int result = 0;
 
-        if(codebook > 0)
+        if (codebook > 0)
             result = get_vlc2(gbp, huff_vlc[codebook-1].table,
-                              VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
+                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
 
-        if(result < 0)
+        if (result < 0)
             return -1;
 
-        if(lsb_bits > 0)
+        if (lsb_bits > 0)
             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
 
         result  += cp->sign_huff_offset;
@@ -238,7 +234,7 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx)
 
     init_static();
     m->avctx = avctx;
-    for(substr = 0; substr < MAX_SUBSTREAMS; substr++)
+    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
         m->substream[substr].lossless_check_data = 0xffffffff;
     dsputil_init(&m->dsp, avctx);
 
@@ -255,64 +251,55 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
     MLPHeaderInfo mh;
     int substr;
 
-    if(ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
+    if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
         return -1;
 
-    if(mh.group1_bits == 0)
-    {
+    if (mh.group1_bits == 0) {
         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
         return -1;
     }
-    if(mh.group2_bits > mh.group1_bits)
-    {
+    if (mh.group2_bits > mh.group1_bits) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Channel group 2 cannot have more bits per sample than group 1.\n");
         return -1;
     }
 
-    if(mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate)
-    {
+    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Channel groups with differing sample rates are not currently supported.\n");
         return -1;
     }
 
-    if(mh.group1_samplerate == 0)
-    {
+    if (mh.group1_samplerate == 0) {
         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
         return -1;
     }
-    if(mh.group1_samplerate > MAX_SAMPLERATE)
-    {
+    if (mh.group1_samplerate > MAX_SAMPLERATE) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Sampling rate %d is greater than the supported maximum (%d).\n",
                mh.group1_samplerate, MAX_SAMPLERATE);
         return -1;
     }
-    if(mh.access_unit_size > MAX_BLOCKSIZE)
-    {
+    if (mh.access_unit_size > MAX_BLOCKSIZE) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Block size %d is greater than the supported maximum (%d).\n",
                mh.access_unit_size, MAX_BLOCKSIZE);
         return -1;
     }
-    if(mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2)
-    {
+    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Block size pow2 %d is greater than the supported maximum (%d).\n",
                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
         return -1;
     }
 
-    if(mh.num_substreams == 0)
+    if (mh.num_substreams == 0)
         return -1;
-    if(m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2)
-    {
+    if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
         return -1;
     }
-    if(mh.num_substreams > MAX_SUBSTREAMS)
-    {
+    if (mh.num_substreams > MAX_SUBSTREAMS) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of substreams %d is larger than the maximum supported "
                "by the decoder. %s\n", mh.num_substreams, sample_message);
@@ -329,13 +316,13 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
     m->avctx->frame_size     = mh.access_unit_size;
 
     m->avctx->bits_per_raw_sample = mh.group1_bits;
-    if(mh.group1_bits > 16)
+    if (mh.group1_bits > 16)
         m->avctx->sample_fmt = SAMPLE_FMT_S32;
     else
         m->avctx->sample_fmt = SAMPLE_FMT_S16;
 
     m->params_valid = 1;
-    for(substr = 0; substr < MAX_SUBSTREAMS; substr++)
+    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
         m->substream[substr].restart_seen = 0;
 
     return 0;
@@ -355,13 +342,12 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     uint8_t lossless_check;
     int start_count = get_bits_count(gbp);
     const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
-                                   ? MAX_MATRIX_CHANNEL_MLP
-                                   : MAX_MATRIX_CHANNEL_TRUEHD;
+                                 ? MAX_MATRIX_CHANNEL_MLP
+                                 : MAX_MATRIX_CHANNEL_TRUEHD;
 
     sync_word = get_bits(gbp, 13);
 
-    if(sync_word != 0x31ea >> 1)
-    {
+    if (sync_word != 0x31ea >> 1) {
         av_log(m->avctx, AV_LOG_ERROR,
                "restart header sync incorrect (got 0x%04x)\n", sync_word);
         return -1;
@@ -369,8 +355,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 
     s->noise_type = get_bits1(gbp);
 
-    if(m->avctx->codec_id == CODEC_ID_MLP && s->noise_type)
-    {
+    if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
         return -1;
     }
@@ -381,16 +366,14 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     s->max_channel        = get_bits(gbp, 4);
     s->max_matrix_channel = get_bits(gbp, 4);
 
-    if(s->max_matrix_channel > max_matrix_channel)
-    {
+    if (s->max_matrix_channel > max_matrix_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Max matrix channel cannot be greater than %d.\n",
                max_matrix_channel);
         return -1;
     }
 
-    if(s->max_channel != s->max_matrix_channel)
-    {
+    if (s->max_channel != s->max_matrix_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Max channel must be equal max matrix channel.\n");
         return -1;
@@ -398,25 +381,22 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 
     /* This should happen for TrueHD streams with >6 channels and MLP's noise
      * type. It is not yet known if this is allowed. */
-    if(s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type)
-    {
+    if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of channels %d is larger than the maximum supported "
-               "by the decoder. %s\n", s->max_channel + 2, sample_message);
+               "by the decoder. %s\n", s->max_channel+2, sample_message);
         return -1;
     }
 
-    if(s->min_channel > s->max_channel)
-    {
+    if (s->min_channel > s->max_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Substream min channel cannot be greater than max channel.\n");
         return -1;
     }
 
-    if(m->avctx->request_channels > 0
-       && s->max_channel + 1 >= m->avctx->request_channels
-       && substr < m->max_decoded_substream)
-    {
+    if (m->avctx->request_channels > 0
+        && s->max_channel + 1 >= m->avctx->request_channels
+        && substr < m->max_decoded_substream) {
         av_log(m->avctx, AV_LOG_INFO,
                "Extracting %d channel downmix from substream %d. "
                "Further substreams will be skipped.\n",
@@ -431,11 +411,10 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 
     s->data_check_present = get_bits1(gbp);
     lossless_check = get_bits(gbp, 8);
-    if(substr == m->max_decoded_substream
-       && s->lossless_check_data != 0xffffffff)
-    {
+    if (substr == m->max_decoded_substream
+        && s->lossless_check_data != 0xffffffff) {
         tmp = xor_32_to_8(s->lossless_check_data);
-        if(tmp != lossless_check)
+        if (tmp != lossless_check)
             av_log(m->avctx, AV_LOG_WARNING,
                    "Lossless check failed - expected %02x, calculated %02x.\n",
                    lossless_check, tmp);
@@ -445,11 +424,9 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 
     memset(s->ch_assign, 0, sizeof(s->ch_assign));
 
-    for(ch = 0; ch <= s->max_matrix_channel; ch++)
-    {
+    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
         int ch_assign = get_bits(gbp, 6);
-        if(ch_assign > s->max_matrix_channel)
-        {
+        if (ch_assign > s->max_matrix_channel) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "Assignment of matrix channel %d to invalid output channel %d. %s\n",
                    ch, ch_assign, sample_message);
@@ -460,7 +437,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 
     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 
-    if(checksum != get_bits(gbp, 8))
+    if (checksum != get_bits(gbp, 8))
         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 
     /* Set default decoding parameters. */
@@ -469,11 +446,10 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     s->blocksize              = 8;
     s->lossless_check_data    = 0;
 
-    memset(s->output_shift   , 0, sizeof(s->output_shift));
+    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
 
-    for(ch = s->min_channel; ch <= s->max_channel; ch++)
-    {
+    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
         ChannelParams *cp = &m->channel_params[ch];
         cp->filter_params[FIR].order = 0;
         cp->filter_params[IIR].order = 0;
@@ -487,7 +463,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
         cp->huff_lsbs        = 24;
     }
 
-    if(substr == m->max_decoded_substream)
+    if (substr == m->max_decoded_substream)
         m->avctx->channels = s->max_matrix_channel + 1;
 
     return 0;
@@ -506,15 +482,13 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
     // Filter is 0 for FIR, 1 for IIR.
     assert(filter < 2);
 
-    if(m->filter_changed[channel][filter]++ > 1)
-    {
+    if (m->filter_changed[channel][filter]++ > 1) {
         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
         return -1;
     }
 
     order = get_bits(gbp, 4);
-    if(order > max_order)
-    {
+    if (order > max_order) {
         av_log(m->avctx, AV_LOG_ERROR,
                "%cIR filter order %d is greater than maximum %d.\n",
                fchar, order, max_order);
@@ -522,8 +496,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
     }
     fp->order = order;
 
-    if(order > 0)
-    {
+    if (order > 0) {
         int32_t *fcoeff = m->channel_params[channel].coeff[filter];
         int coeff_bits, coeff_shift;
 
@@ -531,30 +504,26 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 
         coeff_bits  = get_bits(gbp, 5);
         coeff_shift = get_bits(gbp, 3);
-        if(coeff_bits < 1 || coeff_bits > 16)
-        {
+        if (coeff_bits < 1 || coeff_bits > 16) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "%cIR filter coeff_bits must be between 1 and 16.\n",
                    fchar);
             return -1;
         }
-        if(coeff_bits + coeff_shift > 16)
-        {
+        if (coeff_bits + coeff_shift > 16) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
                    fchar);
             return -1;
         }
 
-        for(i = 0; i < order; i++)
+        for (i = 0; i < order; i++)
             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
 
-        if(get_bits1(gbp))
-        {
+        if (get_bits1(gbp)) {
             int state_bits, state_shift;
 
-            if(filter == FIR)
-            {
+            if (filter == FIR) {
                 av_log(m->avctx, AV_LOG_ERROR,
                        "FIR filter has state data specified.\n");
                 return -1;
@@ -565,7 +534,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 
             /* TODO: Check validity of state data. */
 
-            for(i = 0; i < order; i++)
+            for (i = 0; i < order; i++)
                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
         }
     }
@@ -580,60 +549,54 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
     SubStream *s = &m->substream[substr];
     unsigned int mat, ch;
     const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
-                                       ? MAX_MATRICES_MLP
-                                       : MAX_MATRICES_TRUEHD;
+                                     ? MAX_MATRICES_MLP
+                                     : MAX_MATRICES_TRUEHD;
 
-    if(m->matrix_changed++ > 1)
-    {
+    if (m->matrix_changed++ > 1) {
         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
         return -1;
     }
 
     s->num_primitive_matrices = get_bits(gbp, 4);
 
-    if(s->num_primitive_matrices > max_primitive_matrices)
-    {
+    if (s->num_primitive_matrices > max_primitive_matrices) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of primitive matrices cannot be greater than %d.\n",
                max_primitive_matrices);
         return -1;
     }
 
-    for(mat = 0; mat < s->num_primitive_matrices; mat++)
-    {
+    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
         int frac_bits, max_chan;
         s->matrix_out_ch[mat] = get_bits(gbp, 4);
         frac_bits             = get_bits(gbp, 4);
         s->lsb_bypass   [mat] = get_bits1(gbp);
 
-        if(s->matrix_out_ch[mat] > s->max_matrix_channel)
-        {
+        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
             av_log(m->avctx, AV_LOG_ERROR,
-                   "Invalid channel %d specified as output from matrix.\n",
-                   s->matrix_out_ch[mat]);
+                    "Invalid channel %d specified as output from matrix.\n",
+                    s->matrix_out_ch[mat]);
             return -1;
         }
-        if(frac_bits > 14)
-        {
+        if (frac_bits > 14) {
             av_log(m->avctx, AV_LOG_ERROR,
-                   "Too many fractional bits specified.\n");
+                    "Too many fractional bits specified.\n");
             return -1;
         }
 
         max_chan = s->max_matrix_channel;
-        if(!s->noise_type)
-            max_chan += 2;
+        if (!s->noise_type)
+            max_chan+=2;
 
-        for(ch = 0; ch <= max_chan; ch++)
-        {
+        for (ch = 0; ch <= max_chan; ch++) {
             int coeff_val = 0;
-            if(get_bits1(gbp))
+            if (get_bits1(gbp))
                 coeff_val = get_sbits(gbp, frac_bits + 2);
 
             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
         }
 
-        if(s->noise_type)
+        if (s->noise_type)
             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
         else
             s->matrix_noise_shift[mat] = 0;
@@ -652,27 +615,25 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
     FilterParams *iir = &cp->filter_params[IIR];
     SubStream *s = &m->substream[substr];
 
-    if(s->param_presence_flags & PARAM_FIR)
-        if(get_bits1(gbp))
-            if(read_filter_params(m, gbp, ch, FIR) < 0)
+    if (s->param_presence_flags & PARAM_FIR)
+        if (get_bits1(gbp))
+            if (read_filter_params(m, gbp, ch, FIR) < 0)
                 return -1;
 
-    if(s->param_presence_flags & PARAM_IIR)
-        if(get_bits1(gbp))
-            if(read_filter_params(m, gbp, ch, IIR) < 0)
+    if (s->param_presence_flags & PARAM_IIR)
+        if (get_bits1(gbp))
+            if (read_filter_params(m, gbp, ch, IIR) < 0)
                 return -1;
 
-    if(fir->order + iir->order > 8)
-    {
+    if (fir->order + iir->order > 8) {
         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
         return -1;
     }
 
-    if(fir->order && iir->order &&
-       fir->shift != iir->shift)
-    {
+    if (fir->order && iir->order &&
+        fir->shift != iir->shift) {
         av_log(m->avctx, AV_LOG_ERROR,
-               "FIR and IIR filters must use the same precision.\n");
+                "FIR and IIR filters must use the same precision.\n");
         return -1;
     }
     /* The FIR and IIR filters must have the same precision.
@@ -680,18 +641,17 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
      * FIR filter is considered. If only the IIR filter is employed,
      * the FIR filter precision is set to that of the IIR filter, so
      * that the filtering code can use it. */
-    if(!fir->order && iir->order)
+    if (!fir->order && iir->order)
         fir->shift = iir->shift;
 
-    if(s->param_presence_flags & PARAM_HUFFOFFSET)
-        if(get_bits1(gbp))
+    if (s->param_presence_flags & PARAM_HUFFOFFSET)
+        if (get_bits1(gbp))
             cp->huff_offset = get_sbits(gbp, 15);
 
     cp->codebook  = get_bits(gbp, 2);
     cp->huff_lsbs = get_bits(gbp, 5);
 
-    if(cp->huff_lsbs > 24)
-    {
+    if (cp->huff_lsbs > 24) {
         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
         return -1;
     }
@@ -710,36 +670,33 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
     SubStream *s = &m->substream[substr];
     unsigned int ch;
 
-    if(s->param_presence_flags & PARAM_PRESENCE)
-        if(get_bits1(gbp))
+    if (s->param_presence_flags & PARAM_PRESENCE)
+        if (get_bits1(gbp))
             s->param_presence_flags = get_bits(gbp, 8);
 
-    if(s->param_presence_flags & PARAM_BLOCKSIZE)
-        if(get_bits1(gbp))
-        {
+    if (s->param_presence_flags & PARAM_BLOCKSIZE)
+        if (get_bits1(gbp)) {
             s->blocksize = get_bits(gbp, 9);
-            if(s->blocksize < 8 || s->blocksize > m->access_unit_size)
-            {
+            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
                 s->blocksize = 0;
                 return -1;
             }
         }
 
-    if(s->param_presence_flags & PARAM_MATRIX)
-        if(get_bits1(gbp))
-            if(read_matrix_params(m, substr, gbp) < 0)
+    if (s->param_presence_flags & PARAM_MATRIX)
+        if (get_bits1(gbp))
+            if (read_matrix_params(m, substr, gbp) < 0)
                 return -1;
 
-    if(s->param_presence_flags & PARAM_OUTSHIFT)
-        if(get_bits1(gbp))
-            for(ch = 0; ch <= s->max_matrix_channel; ch++)
+    if (s->param_presence_flags & PARAM_OUTSHIFT)
+        if (get_bits1(gbp))
+            for (ch = 0; ch <= s->max_matrix_channel; ch++)
                 s->output_shift[ch] = get_sbits(gbp, 4);
 
-    if(s->param_presence_flags & PARAM_QUANTSTEP)
-        if(get_bits1(gbp))
-            for(ch = 0; ch <= s->max_channel; ch++)
-            {
+    if (s->param_presence_flags & PARAM_QUANTSTEP)
+        if (get_bits1(gbp))
+            for (ch = 0; ch <= s->max_channel; ch++) {
                 ChannelParams *cp = &m->channel_params[ch];
 
                 s->quant_step_size[ch] = get_bits(gbp, 4);
@@ -747,9 +704,9 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
             }
 
-    for(ch = s->min_channel; ch <= s->max_channel; ch++)
-        if(get_bits1(gbp))
-            if(read_channel_params(m, substr, gbp, ch) < 0)
+    for (ch = s->min_channel; ch <= s->max_channel; ch++)
+        if (get_bits1(gbp))
+            if (read_channel_params(m, substr, gbp, ch) < 0)
                 return -1;
 
     return 0;
@@ -793,16 +750,14 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
     SubStream *s = &m->substream[substr];
     unsigned int i, ch, expected_stream_pos = 0;
 
-    if(s->data_check_present)
-    {
+    if (s->data_check_present) {
         expected_stream_pos  = get_bits_count(gbp);
         expected_stream_pos += get_bits(gbp, 16);
         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
                "we have not tested yet. %s\n", sample_message);
     }
 
-    if(s->blockpos + s->blocksize > m->access_unit_size)
-    {
+    if (s->blockpos + s->blocksize > m->access_unit_size) {
         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
         return -1;
     }
@@ -810,18 +765,17 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 
-    for(i = 0; i < s->blocksize; i++)
-        if(read_huff_channels(m, gbp, substr, i) < 0)
+    for (i = 0; i < s->blocksize; i++)
+        if (read_huff_channels(m, gbp, substr, i) < 0)
             return -1;
 
-    for(ch = s->min_channel; ch <= s->max_channel; ch++)
+    for (ch = s->min_channel; ch <= s->max_channel; ch++)
         filter_channel(m, substr, ch);
 
     s->blockpos += s->blocksize;
 
-    if(s->data_check_present)
-    {
-        if(get_bits_count(gbp) != expected_stream_pos)
+    if (s->data_check_present) {
+        if (get_bits_count(gbp) != expected_stream_pos)
             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
         skip_bits(gbp, 8);
     }
@@ -831,23 +785,22 @@ static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 
 /** Data table used for TrueHD noise generation function. */
 
-static const int8_t noise_table[256] =
-{
-    30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
-    52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
-    10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
-    51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
-    38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
-    61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
-    67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
-    48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
-    0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
-    16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
-    13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
-    89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
-    36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
-    39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
-    45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
+static const int8_t noise_table[256] = {
+     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
+     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
+     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
+     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
+     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
+     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
+     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
+     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
+      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
+     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
+     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
+     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
+     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
+     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
+     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 };
 
@@ -868,13 +821,12 @@ static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
     uint32_t seed = s->noisegen_seed;
     unsigned int maxchan = s->max_matrix_channel;
 
-    for(i = 0; i < s->blockpos; i++)
-    {
+    for (i = 0; i < s->blockpos; i++) {
         uint16_t seed_shr7 = seed >> 7;
         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 
-        seed = (seed << 16) ^ seed_shr7 ^(seed_shr7 << 5);
+        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
     }
 
     s->noisegen_seed = seed;
@@ -888,11 +840,10 @@ static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
     unsigned int i;
     uint32_t seed = s->noisegen_seed;
 
-    for(i = 0; i < m->access_unit_size_pow2; i++)
-    {
+    for (i = 0; i < m->access_unit_size_pow2; i++) {
         uint8_t seed_shr15 = seed >> 15;
         m->noise_buffer[i] = noise_table[seed_shr15];
-        seed = (seed << 8) ^ seed_shr15 ^(seed_shr15 << 5);
+        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
     }
 
     s->noisegen_seed = seed;
@@ -909,18 +860,14 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
     unsigned int maxchan;
 
     maxchan = s->max_matrix_channel;
-    if(!s->noise_type)
-    {
+    if (!s->noise_type) {
         generate_2_noise_channels(m, substr);
         maxchan += 2;
-    }
-    else
-    {
+    } else {
         fill_noise_buffer(m, substr);
     }
 
-    for(mat = 0; mat < s->num_primitive_matrices; mat++)
-    {
+    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
         int matrix_noise_shift = s->matrix_noise_shift[mat];
         unsigned int dest_ch = s->matrix_out_ch[mat];
         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
@@ -930,17 +877,15 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 
         /* TODO: DSPContext? */
 
-        for(i = 0; i < s->blockpos; i++)
-        {
+        for (i = 0; i < s->blockpos; i++) {
             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
             int32_t *samples = m->sample_buffer[i];
             int64_t accum = 0;
 
-            for(src_ch = 0; src_ch <= maxchan; src_ch++)
+            for (src_ch = 0; src_ch <= maxchan; src_ch++)
                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
 
-            if(matrix_noise_shift)
-            {
+            if (matrix_noise_shift) {
                 index &= m->access_unit_size_pow2 - 1;
                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
                 index += index2;
@@ -961,18 +906,16 @@ static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
     int32_t *data_32 = (int32_t*) data;
     int16_t *data_16 = (int16_t*) data;
 
-    if(*data_size < (s->max_channel + 1) * s->blockpos *(is32 ? 4 : 2))
+    if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
         return -1;
 
-    for(i = 0; i < s->blockpos; i++)
-    {
-        for(out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++)
-        {
+    for (i = 0; i < s->blockpos; i++) {
+        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
             int mat_ch = s->ch_assign[out_ch];
             int32_t sample = m->sample_buffer[i][mat_ch]
-                             << s->output_shift[mat_ch];
+                          << s->output_shift[mat_ch];
             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
-            if(is32) *data_32++ = sample << 8;
+            if (is32) *data_32++ = sample << 8;
             else      *data_16++ = sample >> 8;
         }
     }
@@ -985,7 +928,7 @@ static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
 static int output_data(MLPDecodeContext *m, unsigned int substr,
                        uint8_t *data, unsigned int *data_size)
 {
-    if(m->avctx->sample_fmt == SAMPLE_FMT_S32)
+    if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
         return output_data_internal(m, substr, data, data_size, 1);
     else
         return output_data_internal(m, substr, data, data_size, 0);
@@ -1009,27 +952,25 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
     uint16_t substream_data_len[MAX_SUBSTREAMS];
     uint8_t parity_bits;
 
-    if(buf_size < 4)
+    if (buf_size < 4)
         return 0;
 
     length = (AV_RB16(buf) & 0xfff) * 2;
 
-    if(length < 4 || length > buf_size)
+    if (length < 4 || length > buf_size)
         return -1;
 
     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
 
     m->is_major_sync_unit = 0;
-    if(show_bits_long(&gb, 31) == (0xf8726fba >> 1))
-    {
-        if(read_major_sync(m, &gb) < 0)
+    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
+        if (read_major_sync(m, &gb) < 0)
             goto error;
         m->is_major_sync_unit = 1;
         header_size += 28;
     }
 
-    if(!m->params_valid)
-    {
+    if (!m->params_valid) {
         av_log(m->avctx, AV_LOG_WARNING,
                "Stream parameters not seen; skipping frame.\n");
         *data_size = 0;
@@ -1038,8 +979,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
 
     substream_start = 0;
 
-    for(substr = 0; substr < m->num_substreams; substr++)
-    {
+    for (substr = 0; substr < m->num_substreams; substr++) {
         int extraword_present, checkdata_present, end, nonrestart_substr;
 
         extraword_present = get_bits1(&gb);
@@ -1051,10 +991,8 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
 
         substr_header_size += 2;
 
-        if(extraword_present)
-        {
-            if(m->avctx->codec_id == CODEC_ID_MLP)
-            {
+        if (extraword_present) {
+            if (m->avctx->codec_id == CODEC_ID_MLP) {
                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
                 goto error;
             }
@@ -1062,22 +1000,19 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
             substr_header_size += 2;
         }
 
-        if(!(nonrestart_substr ^ m->is_major_sync_unit))
-        {
+        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
             goto error;
         }
 
-        if(end + header_size + substr_header_size > length)
-        {
+        if (end + header_size + substr_header_size > length) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "Indicated length of substream %d data goes off end of "
                    "packet.\n", substr);
             end = length - header_size - substr_header_size;
         }
 
-        if(end < substream_start)
-        {
+        if (end < substream_start) {
             av_log(avctx, AV_LOG_ERROR,
                    "Indicated end offset of substream %d data "
                    "is smaller than calculated start offset.\n",
@@ -1085,7 +1020,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
             goto error;
         }
 
-        if(substr > m->max_decoded_substream)
+        if (substr > m->max_decoded_substream)
             continue;
 
         substream_parity_present[substr] = checkdata_present;
@@ -1105,8 +1040,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
 
     buf += header_size + substr_header_size;
 
-    for(substr = 0; substr <= m->max_decoded_substream; substr++)
-    {
+    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
         SubStream *s = &m->substream[substr];
         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
 
@@ -1114,76 +1048,70 @@ static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
         memset(m->filter_changed, 0, sizeof(m->filter_changed));
 
         s->blockpos = 0;
-        do
-        {
-            if(get_bits1(&gb))
-            {
-                if(get_bits1(&gb))
-                {
+        do {
+            if (get_bits1(&gb)) {
+                if (get_bits1(&gb)) {
                     /* A restart header should be present. */
-                    if(read_restart_header(m, &gb, buf, substr) < 0)
+                    if (read_restart_header(m, &gb, buf, substr) < 0)
                         goto next_substr;
                     s->restart_seen = 1;
                 }
 
-                if(!s->restart_seen)
+                if (!s->restart_seen)
                     goto next_substr;
-                if(read_decoding_params(m, &gb, substr) < 0)
+                if (read_decoding_params(m, &gb, substr) < 0)
                     goto next_substr;
             }
 
-            if(!s->restart_seen)
+            if (!s->restart_seen)
                 goto next_substr;
 
-            if(read_block_data(m, &gb, substr) < 0)
+            if (read_block_data(m, &gb, substr) < 0)
                 return -1;
 
-            if(get_bits_count(&gb) >= substream_data_len[substr] * 8)
+            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
                 goto substream_length_mismatch;
 
-        }
-        while(!get_bits1(&gb));
+        } while (!get_bits1(&gb));
 
         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
 
-        if(substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32)
-        {
+        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
             int shorten_by;
 
-            if(get_bits(&gb, 16) != 0xD234)
+            if (get_bits(&gb, 16) != 0xD234)
                 return -1;
 
             shorten_by = get_bits(&gb, 16);
-            if(m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
+            if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
-            else if(m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
+            else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
                 return -1;
 
-            if(substr == m->max_decoded_substream)
+            if (substr == m->max_decoded_substream)
                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
         }
 
-        if(substream_parity_present[substr])
-        {
+        if (substream_parity_present[substr]) {
             uint8_t parity, checksum;
 
-            if(substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
+            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
                 goto substream_length_mismatch;
 
             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
-            checksum = ff_mlp_checksum8(buf, substream_data_len[substr] - 2);
+            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
 
-            if((get_bits(&gb, 8) ^ parity) != 0xa9)
+            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
-            if(get_bits(&gb, 8)           != checksum)
+            if ( get_bits(&gb, 8)           != checksum)
                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
         }
 
-        if(substream_data_len[substr] * 8 != get_bits_count(&gb))
+        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
             goto substream_length_mismatch;
 
 next_substr:
-        if(!s->restart_seen)
+        if (!s->restart_seen)
             av_log(m->avctx, AV_LOG_ERROR,
                    "No restart header present in substream %d.\n", substr);
 
@@ -1192,7 +1120,7 @@ next_substr:
 
     rematrix_channels(m, m->max_decoded_substream);
 
-    if(output_data(m, m->max_decoded_substream, data, data_size) < 0)
+    if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
         return -1;
 
     return length;
@@ -1206,8 +1134,7 @@ error:
     return -1;
 }
 
-AVCodec mlp_decoder =
-{
+AVCodec mlp_decoder = {
     "mlp",
     CODEC_TYPE_AUDIO,
     CODEC_ID_MLP,
@@ -1225,8 +1152,7 @@ AVCodec mlp_decoder =
 };
 
 #if CONFIG_TRUEHD_DECODER
-AVCodec truehd_decoder =
-{
+AVCodec truehd_decoder = {
     "truehd",
     CODEC_TYPE_AUDIO,
     CODEC_ID_TRUEHD,