Merge commit 'd2a4e4b9cc9a0c2661e1c1d6f6b51babac2cec1b'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 20:03:21 +0000 (22:03 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 20:10:21 +0000 (22:10 +0200)
* commit 'd2a4e4b9cc9a0c2661e1c1d6f6b51babac2cec1b':
  wma: K&R formatting cosmetics

Conflicts:
libavcodec/wma.c
libavcodec/wmadec.c
libavcodec/wmaenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/wma.c
libavcodec/wma.h
libavcodec/wma_common.c
libavcodec/wmadata.h
libavcodec/wmadec.c
libavcodec/wmaenc.c

@@@ -45,20 -46,20 +46,20 @@@ static av_cold void init_coef_vlc(VLC *
  
      init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
  
-     run_table   = av_malloc_array(n, sizeof(uint16_t));
-     level_table = av_malloc_array(n, sizeof(uint16_t));
-     flevel_table= av_malloc_array(n, sizeof(*flevel_table));
-     int_table   = av_malloc_array(n, sizeof(uint16_t));
-     i = 2;
-     level = 1;
-     k = 0;
 -    run_table    = av_malloc(n * sizeof(uint16_t));
 -    level_table  = av_malloc(n * sizeof(uint16_t));
 -    flevel_table = av_malloc(n * sizeof(*flevel_table));
 -    int_table    = av_malloc(n * sizeof(uint16_t));
++    run_table    = av_malloc_array(n, sizeof(uint16_t));
++    level_table  = av_malloc_array(n, sizeof(uint16_t));
++    flevel_table = av_malloc_array(n, sizeof(*flevel_table));
++    int_table    = av_malloc_array(n, sizeof(uint16_t));
+     i            = 2;
+     level        = 1;
+     k            = 0;
      while (i < n) {
          int_table[k] = i;
-         l = levels_table[k++];
+         l            = levels_table[k++];
          for (j = 0; j < l; j++) {
-             run_table[i]   = j;
-             level_table[i] = level;
-             flevel_table[i]= level;
+             run_table[i]    = j;
+             level_table[i]  = level;
+             flevel_table[i] = level;
              i++;
          }
          level++;
@@@ -120,28 -119,24 +119,28 @@@ av_cold int ff_wma_init(AVCodecContext 
      /* if version 2, then the rates are normalized */
      sample_rate1 = avctx->sample_rate;
      if (s->version == 2) {
-         if (sample_rate1 >= 44100) {
+         if (sample_rate1 >= 44100)
              sample_rate1 = 44100;
-         } else if (sample_rate1 >= 22050) {
+         else if (sample_rate1 >= 22050)
              sample_rate1 = 22050;
-         } else if (sample_rate1 >= 16000) {
+         else if (sample_rate1 >= 16000)
              sample_rate1 = 16000;
-         } else if (sample_rate1 >= 11025) {
+         else if (sample_rate1 >= 11025)
              sample_rate1 = 11025;
-         } else if (sample_rate1 >= 8000) {
+         else if (sample_rate1 >= 8000)
              sample_rate1 = 8000;
-         }
      }
  
-     bps = (float)avctx->bit_rate / (float)(avctx->channels * avctx->sample_rate);
-     s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
+     bps                 = (float) avctx->bit_rate /
+                           (float) (avctx->channels * avctx->sample_rate);
+     s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
 +    if (s->byte_offset_bits + 3 > MIN_CACHE_BITS) {
 +        av_log(avctx, AV_LOG_ERROR, "byte_offset_bits %d is too large\n", s->byte_offset_bits);
 +        return AVERROR_PATCHWELCOME;
 +    }
  
      /* compute high frequency value and choose if noise coding should
-        be activated */
+      * be activated */
      bps1 = bps;
      if (avctx->channels == 2)
          bps1 = bps * 1.6;
@@@ -378,17 -368,15 +372,15 @@@ int ff_wma_end(AVCodecContext *avctx
      for (i = 0; i < s->nb_block_sizes; i++)
          ff_mdct_end(&s->mdct_ctx[i]);
  
-     if (s->use_exp_vlc) {
+     if (s->use_exp_vlc)
          ff_free_vlc(&s->exp_vlc);
-     }
-     if (s->use_noise_coding) {
+     if (s->use_noise_coding)
          ff_free_vlc(&s->hgain_vlc);
-     }
      for (i = 0; i < 2; i++) {
          ff_free_vlc(&s->coef_vlc[i]);
 -        av_free(s->run_table[i]);
 -        av_free(s->level_table[i]);
 -        av_free(s->int_table[i]);
 +        av_freep(&s->run_table[i]);
 +        av_freep(&s->level_table[i]);
 +        av_freep(&s->int_table[i]);
      }
  
      return 0;
Simple merge
Simple merge
Simple merge
@@@ -81,29 -83,18 +83,28 @@@ static av_cold int wma_decode_init(AVCo
      s->avctx = avctx;
  
      /* extract flag infos */
-     flags2 = 0;
+     flags2    = 0;
      extradata = avctx->extradata;
-     if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4) {
-         flags2 = AV_RL16(extradata+2);
-     } else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6) {
-         flags2 = AV_RL16(extradata+4);
-     }
+     if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)
+         flags2 = AV_RL16(extradata + 2);
+     else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)
+         flags2 = AV_RL16(extradata + 4);
  
-     s->use_exp_vlc = flags2 & 0x0001;
-     s->use_bit_reservoir = flags2 & 0x0002;
+     s->use_exp_vlc            = flags2 & 0x0001;
+     s->use_bit_reservoir      = flags2 & 0x0002;
      s->use_variable_block_len = flags2 & 0x0004;
  
-     if(avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){
-         if(AV_RL16(extradata+4)==0xd && s->use_variable_block_len){
++    if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){
++        if (AV_RL16(extradata+4)==0xd && s->use_variable_block_len){
 +            av_log(avctx, AV_LOG_WARNING, "Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");
 +            s->use_variable_block_len= 0; // this fixes issue1503
 +        }
 +    }
 +
 +    for (i=0; i<MAX_CHANNELS; i++)
 +        s->max_exponent[i] = 1.0;
 +
-     if(ff_wma_init(avctx, flags2)<0)
+     if (ff_wma_init(avctx, flags2) < 0)
          return -1;
  
      /* init MDCT */
@@@ -479,17 -472,12 +482,17 @@@ static int wma_decode_block(WMACodecCon
          /* fixed block len */
          s->next_block_len_bits = s->frame_len_bits;
          s->prev_block_len_bits = s->frame_len_bits;
-         s->block_len_bits = s->frame_len_bits;
+         s->block_len_bits      = s->frame_len_bits;
      }
  
 +    if (s->frame_len_bits - s->block_len_bits >= s->nb_block_sizes){
 +        av_log(s->avctx, AV_LOG_ERROR, "block_len_bits not initialized to a valid value\n");
 +        return -1;
 +    }
 +
      /* now check if the block length is coherent with the frame length */
      s->block_len = 1 << s->block_len_bits;
-     if ((s->block_pos + s->block_len) > s->frame_len){
+     if ((s->block_pos + s->block_len) > s->frame_len) {
          av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");
          return -1;
      }
          goto next;
  
      /* read total gain and extract corresponding number of bits for
-        coef escape coding */
+      * coef escape coding */
      total_gain = 1;
-     for(;;) {
+     for (;;) {
 +        if (get_bits_left(&s->gb) < 7) {
 +            av_log(s->avctx, AV_LOG_ERROR, "total_gain overread\n");
 +            return AVERROR_INVALIDDATA;
 +        }
-         a = get_bits(&s->gb, 7);
+         a           = get_bits(&s->gb, 7);
          total_gain += a;
          if (a != 127)
              break;
@@@ -831,28 -811,24 +830,27 @@@ static int wma_decode_superframe(AVCode
                 buf_size, avctx->block_align);
          return AVERROR_INVALIDDATA;
      }
-     if(avctx->block_align)
 -    buf_size = avctx->block_align;
++    if (avctx->block_align)
 +        buf_size = avctx->block_align;
  
-     init_get_bits(&s->gb, buf, buf_size*8);
+     init_get_bits(&s->gb, buf, buf_size * 8);
  
      if (s->use_bit_reservoir) {
          /* read super frame header */
          skip_bits(&s->gb, 4); /* super frame index */
          nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
-     } else {
 +        if (nb_frames <= 0) {
 +            av_log(avctx, AV_LOG_ERROR, "nb_frames is %d\n", nb_frames);
 +            return AVERROR_INVALIDDATA;
 +        }
+     } else
          nb_frames = 1;
-     }
  
      /* get output buffer */
      frame->nb_samples = nb_frames * s->frame_len;
 -    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
          return ret;
-     samples = (float **)frame->extended_data;
 -    }
+     samples        = (float **) frame->extended_data;
      samples_offset = 0;
  
      if (s->use_bit_reservoir) {
          samples_offset += s->frame_len;
      }
  
 -    av_dlog(s->avctx, "%d %d %d %d outbytes:%td eaten:%d\n",
 +    av_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
              s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
-             (int8_t *)samples - (int8_t *)data, avctx->block_align);
+             (int8_t *) samples - (int8_t *) data, avctx->block_align);
  
      *got_frame_ptr = 1;
  
 -    return avctx->block_align;
 +    return buf_size;
-  fail:
+ fail:
      /* when error, we reset the bit reservoir */
      s->last_superframe_len = 0;
      return -1;
@@@ -944,11 -922,10 +944,11 @@@ static av_cold void flush(AVCodecContex
  {
      WMACodecContext *s = avctx->priv_data;
  
-     s->last_bitoffset=
-     s->last_superframe_len= 0;
+     s->last_bitoffset      =
+     s->last_superframe_len = 0;
  }
  
 +#if CONFIG_WMAV1_DECODER
  AVCodec ff_wmav1_decoder = {
      .name           = "wmav1",
      .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
@@@ -34,8 -37,9 +35,9 @@@ static av_cold int encode_init(AVCodecC
  
      s->avctx = avctx;
  
-     if(avctx->channels > MAX_CHANNELS) {
-         av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer\n",
+     if (avctx->channels > MAX_CHANNELS) {
+         av_log(avctx, AV_LOG_ERROR,
 -               "too many channels: got %i, need %i or fewer",
++               "too many channels: got %i, need %i or fewer\n",
                 avctx->channels, MAX_CHANNELS);
          return AVERROR(EINVAL);
      }
      flags1 = 0;
      flags2 = 1;
      if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
-         extradata= av_malloc(4);
-         avctx->extradata_size= 4;
+         extradata             = av_malloc(4);
+         avctx->extradata_size = 4;
          AV_WL16(extradata, flags1);
-         AV_WL16(extradata+2, flags2);
+         AV_WL16(extradata + 2, flags2);
      } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
-         extradata= av_mallocz(10);
-         avctx->extradata_size= 10;
+         extradata             = av_mallocz(10);
+         avctx->extradata_size = 10;
          AV_WL32(extradata, flags1);
-         AV_WL16(extradata+4, flags2);
-     }else
+         AV_WL16(extradata + 4, flags2);
+     } else {
 -        assert(0);
 +        av_assert0(0);
-     avctx->extradata= extradata;
-     s->use_exp_vlc = flags2 & 0x0001;
-     s->use_bit_reservoir = flags2 & 0x0002;
+     }
+     avctx->extradata          = extradata;
+     s->use_exp_vlc            = flags2 & 0x0001;
+     s->use_bit_reservoir      = flags2 & 0x0002;
      s->use_variable_block_len = flags2 & 0x0004;
      if (avctx->channels == 2)
          s->ms_stereo = 1;
                           (avctx->sample_rate * 8);
      block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
      avctx->block_align = block_align;
 -    avctx->bit_rate    = avctx->block_align * 8LL * avctx->sample_rate /
 -                         s->frame_len;
 +
-     avctx->frame_size = avctx->delay = s->frame_len;
+     avctx->frame_size  =
+     avctx->delay       = s->frame_len;
  
      return 0;
  }
@@@ -139,24 -149,25 +146,25 @@@ static void encode_exp_vlc(WMACodecCont
      const uint16_t *ptr;
      float *q, *q_end;
  
-     ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
-     q = s->exponents[ch];
+     ptr   = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
+     q     = s->exponents[ch];
      q_end = q + s->block_len;
      if (s->version == 1) {
-         last_exp= *exp_param++;
-         av_assert0(last_exp-10 >= 0 && last_exp-10 < 32);
+         last_exp = *exp_param++;
 -        assert(last_exp - 10 >= 0 && last_exp - 10 < 32);
++        av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
          put_bits(&s->pb, 5, last_exp - 10);
-         q+= *ptr++;
-     }else
+         q += *ptr++;
+     } else
          last_exp = 36;
      while (q < q_end) {
-         int exp = *exp_param++;
+         int exp  = *exp_param++;
          int code = exp - last_exp + 60;
 -        assert(code >= 0 && code < 120);
 +        av_assert1(code >= 0 && code < 120);
-         put_bits(&s->pb, ff_aac_scalefactor_bits[code], ff_aac_scalefactor_code[code]);
+         put_bits(&s->pb, ff_aac_scalefactor_bits[code],
+                  ff_aac_scalefactor_code[code]);
          /* XXX: use a table */
-         q+= *ptr++;
-         last_exp= exp;
+         q       += *ptr++;
+         last_exp = exp;
      }
  }
  
@@@ -164,12 -177,18 +174,18 @@@ static int encode_block(WMACodecContex
      int v, bsize, ch, coef_nb_bits, parse_exponents;
      float mdct_norm;
      int nb_coefs[MAX_CHANNELS];
-     static const int fixed_exp[25]={20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20};
-     //FIXME remove duplication relative to decoder
+     static const int fixed_exp[25] = {
+         20, 20, 20, 20, 20,
+         20, 20, 20, 20, 20,
+         20, 20, 20, 20, 20,
+         20, 20, 20, 20, 20,
+         20, 20, 20, 20, 20
+     };
+     // FIXME remove duplication relative to decoder
      if (s->use_variable_block_len) {
-         av_assert0(0); //FIXME not implemented
-     }else{
 -        assert(0); // FIXME not implemented
++        av_assert0(0); // FIXME not implemented
+     } else {
          /* fixed block len */
          s->next_block_len_bits = s->frame_len_bits;
          s->prev_block_len_bits = s->frame_len_bits;
      }
  
      s->block_len = 1 << s->block_len_bits;
 -//     assert((s->block_pos + s->block_len) <= s->frame_len);
 +//     av_assert0((s->block_pos + s->block_len) <= s->frame_len);
      bsize = s->frame_len_bits - s->block_len_bits;
  
-     //FIXME factor
+     // FIXME factor
      v = s->coefs_end[bsize] - s->coefs_start;
      for (ch = 0; ch < s->avctx->channels; ch++)
          nb_coefs[ch] = v;
              float *coefs, *exponents, mult;
              int i, n;
  
-             coefs1 = s->coefs1[ch];
+             coefs1    = s->coefs1[ch];
              exponents = s->exponents[ch];
-             mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
-             mult *= mdct_norm;
-             coefs = src_coefs[ch];
+             mult      = pow(10, total_gain * 0.05) / s->max_exponent[ch];
+             mult     *= mdct_norm;
+             coefs     = src_coefs[ch];
              if (s->use_noise_coding && 0) {
-                 av_assert0(0); //FIXME not implemented
 -                assert(0); // FIXME not implemented
++                av_assert0(0); // FIXME not implemented
              } else {
                  coefs += s->coefs_start;
-                 n = nb_coefs[ch];
-                 for(i = 0;i < n; i++){
-                     double t= *coefs++ / (exponents[i] * mult);
-                     if(t<-32768 || t>32767)
+                 n      = nb_coefs[ch];
+                 for (i = 0; i < n; i++) {
+                     double t = *coefs++ / (exponents[i] * mult);
+                     if (t < -32768 || t > 32767)
                          return -1;
  
                      coefs1[i] = lrint(t);
                  if (s->use_exp_vlc) {
                      encode_exp_vlc(s, ch, fixed_exp);
                  } else {
-                     av_assert0(0); //FIXME not implemented
 -                    assert(0); // FIXME not implemented
++                    av_assert0(0); // FIXME not implemented
  //                    encode_exp_lsp(s, ch);
                  }
              }
          }
-     } else {
-         av_assert0(0); //FIXME not implemented
-     }
+     } else
 -        assert(0); // FIXME not implemented
++        av_assert0(0); // FIXME not implemented
  
      for (ch = 0; ch < s->avctx->channels; ch++) {
          if (s->channel_coded[ch]) {
              int run, tindex;
              WMACoef *ptr, *eptr;
              tindex = (ch == 1 && s->ms_stereo);
-             ptr = &s->coefs1[ch][0];
-             eptr = ptr + nb_coefs[ch];
-             run=0;
-             for(;ptr < eptr; ptr++){
-                 if(*ptr){
-                     int level= *ptr;
-                     int abs_level= FFABS(level);
-                     int code= 0;
-                     if(abs_level <= s->coef_vlcs[tindex]->max_level){
-                         if(run < s->coef_vlcs[tindex]->levels[abs_level-1])
-                             code= run + s->int_table[tindex][abs_level-1];
-                     }
+             ptr    = &s->coefs1[ch][0];
+             eptr   = ptr + nb_coefs[ch];
+             run = 0;
+             for (; ptr < eptr; ptr++) {
+                 if (*ptr) {
+                     int level     = *ptr;
+                     int abs_level = FFABS(level);
+                     int code      = 0;
+                     if (abs_level <= s->coef_vlcs[tindex]->max_level)
+                         if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
+                             code = run + s->int_table[tindex][abs_level - 1];
  
 -                    assert(code < s->coef_vlcs[tindex]->n);
 +                    av_assert2(code < s->coef_vlcs[tindex]->n);
-                     put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]);
+                     put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
+                              s->coef_vlcs[tindex]->huffcodes[code]);
  
-                     if(code == 0){
-                         if(1<<coef_nb_bits <= abs_level)
+                     if (code == 0) {
+                         if (1 << coef_nb_bits <= abs_level)
                              return -1;
  
                          put_bits(&s->pb, coef_nb_bits, abs_level);
      return 0;
  }
  
- static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){
+ static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
+                         uint8_t *buf, int buf_size, int total_gain)
+ {
      init_put_bits(&s->pb, buf, buf_size);
  
-     if (s->use_bit_reservoir) {
-         av_assert0(0);//FIXME not implemented
-     }else{
-         if(encode_block(s, src_coefs, total_gain) < 0)
-             return INT_MAX;
-     }
+     if (s->use_bit_reservoir)
 -        assert(0); // FIXME not implemented
++        av_assert0(0); // FIXME not implemented
+     else if (encode_block(s, src_coefs, total_gain) < 0)
+         return INT_MAX;
  
      avpriv_align_put_bits(&s->pb);
  
@@@ -344,10 -359,10 +356,10 @@@ static int encode_superframe(AVCodecCon
                               const AVFrame *frame, int *got_packet_ptr)
  {
      WMACodecContext *s = avctx->priv_data;
 -    int i, total_gain, ret;
 +    int i, total_gain, ret, error;
  
-     s->block_len_bits= s->frame_len_bits; //required by non variable block len
-     s->block_len = 1 << s->block_len_bits;
+     s->block_len_bits = s->frame_len_bits; // required by non variable block len
+     s->block_len      = 1 << s->block_len_bits;
  
      apply_window_and_mdct(avctx, frame);
  
          }
      }
  
 -    if ((ret = ff_alloc_packet(avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE))) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)) < 0)
          return ret;
 -    }
  
-     total_gain= 128;
-     for(i=64; i; i>>=1){
 -#if 1
+     total_gain = 128;
+     for (i = 64; i; i >>= 1) {
 -        int error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
 +        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
                                   total_gain - i);
-         if(error<=0)
-             total_gain-= i;
 -        if (error < 0)
++        if (error <= 0)
+             total_gain -= i;
      }
 -#else
 -    total_gain = 90;
 -    best = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain);
 -    for (i = 32; i; i >>= 1) {
 -        int scoreL = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain - i);
 -        int scoreR = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain + i);
 -        av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain);
 -        if (scoreL < FFMIN(best, scoreR)) {
 -            best        = scoreL;
 -            total_gain -= i;
 -        } else if (scoreR < best) {
 -            best        = scoreR;
 -            total_gain += i;
 -        }
 -    }
 -#endif /* 1 */
  
 -    if ((i = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain)) >= 0) {
 -        av_log(avctx, AV_LOG_ERROR, "required frame size too large. please "
 -                                    "use a higher bit rate.\n");
 +    while(total_gain <= 128 && error > 0)
 +        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
 +    if (error > 0) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
 +        avpkt->size = 0;
          return AVERROR(EINVAL);
      }
 -    assert((put_bits_count(&s->pb) & 7) == 0);
 -    while (i++)
 +    av_assert0((put_bits_count(&s->pb) & 7) == 0);
 +    i= avctx->block_align - (put_bits_count(&s->pb)+7)/8;
 +    av_assert0(i>=0);
 +    while(i--)
          put_bits(&s->pb, 8, 'N');
  
      flush_put_bits(&s->pb);
@@@ -408,11 -436,10 +420,11 @@@ AVCodec ff_wmav1_encoder = 
      .init           = encode_init,
      .encode2        = encode_superframe,
      .close          = ff_wma_end,
-     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
-                                                      AV_SAMPLE_FMT_NONE },
+     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+                                                       AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_WMAV2_ENCODER
  AVCodec ff_wmav2_encoder = {
      .name           = "wmav2",
      .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
      .init           = encode_init,
      .encode2        = encode_superframe,
      .close          = ff_wma_end,
-     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
-                                                      AV_SAMPLE_FMT_NONE },
+     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+                                                       AV_SAMPLE_FMT_NONE },
  };
 +#endif