Merge commit '284ea790d89441fa1e6b2d72d3c1ed6d61972f0b'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Nov 2012 12:39:52 +0000 (13:39 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Nov 2012 12:39:52 +0000 (13:39 +0100)
* commit '284ea790d89441fa1e6b2d72d3c1ed6d61972f0b':
  dsputil: move vector_fmul_scalar() to AVFloatDSPContext in libavutil
  aacenc: use the correct output buffer
  aacdec: fix signed overflows in lcg_random()
  base64: fix signed overflow in shift

Conflicts:
libavcodec/dsputil.c
libavutil/base64.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/aacdec.c
libavcodec/arm/dsputil_init_neon.c
libavcodec/arm/dsputil_neon.S
libavcodec/dsputil.c
libavcodec/dsputil.h
libavcodec/libmp3lame.c
libavcodec/wmaenc.c
libavcodec/wmaprodec.c
libavutil/float_dsp.c
libavutil/float_dsp.h

diff --combined libavcodec/aacdec.c
@@@ -7,20 -7,20 +7,20 @@@
   * Copyright (c) 2008-2010 Paul Kendall <paul@kcbbs.gen.nz>
   * Copyright (c) 2010      Janne Grunau <janne-libav@jannau.net>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  static VLC vlc_scalefactors;
  static VLC vlc_spectral[11];
  
 -static const char overread_err[] = "Input buffer exhausted before END element found\n";
 +#define overread_err "Input buffer exhausted before END element found\n"
  
  static int count_channels(uint8_t (*layout)[3], int tags)
  {
  /**
   * Check for the channel element in the current channel position configuration.
   * If it exists, make sure the appropriate element is allocated and map the
 - * channel order to match the internal Libav channel layout.
 + * channel order to match the internal FFmpeg channel layout.
   *
   * @param   che_pos current channel position configuration
   * @param   type channel element type
@@@ -149,10 -149,6 +149,10 @@@ static av_cold int che_configure(AACCon
              ff_aac_sbr_ctx_init(ac, &ac->che[type][id]->sbr);
          }
          if (type != TYPE_CCE) {
 +            if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
 +                av_log(ac->avctx, AV_LOG_ERROR, "Too many channels\n");
 +                return AVERROR_INVALIDDATA;
 +            }
              ac->output_element[(*channels)++] = &ac->che[type][id]->ch[0];
              if (type == TYPE_CPE ||
                  (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1)) {
@@@ -449,8 -445,7 +449,8 @@@ static int output_configure(AACContext 
      }
  
      memcpy(ac->tag_che_map, ac->che, 4 * MAX_ELEM_ID * sizeof(ac->che[0][0]));
 -    avctx->channel_layout = ac->oc[1].channel_layout = layout;
 +    if (layout) avctx->channel_layout = layout;
 +    ac->oc[1].channel_layout = layout;
      avctx->channels = ac->oc[1].channels = channels;
      ac->oc[1].status = oc_type;
  
      return 0;
  }
  
 +static void flush(AVCodecContext *avctx)
 +{
 +    AACContext *ac= avctx->priv_data;
 +    int type, i, j;
 +
 +    for (type = 3; type >= 0; type--) {
 +        for (i = 0; i < MAX_ELEM_ID; i++) {
 +            ChannelElement *che = ac->che[type][i];
 +            if (che) {
 +                for (j = 0; j <= 1; j++) {
 +                    memset(che->ch[j].saved, 0, sizeof(che->ch[j].saved));
 +                }
 +            }
 +        }
 +    }
 +}
 +
  /**
   * Set up channel positions based on a default channel configuration
   * as specified in table 1.17.
@@@ -512,8 -490,6 +512,8 @@@ static ChannelElement *get_che(AACConte
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "mono with CPE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         2) < 0)
              return NULL;
          int layout_map_tags;
          push_output_configuration(ac);
  
 +        av_log(ac->avctx, AV_LOG_DEBUG, "stereo with SCE\n");
 +
          if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,
                                         1) < 0)
              return NULL;
@@@ -610,8 -584,6 +610,8 @@@ static void decode_channel_map(uint8_t 
          case AAC_CHANNEL_LFE:
              syn_ele = TYPE_LFE;
              break;
 +        default:
 +            av_assert0(0);
          }
          layout_map[0][0] = syn_ele;
          layout_map[0][1] = get_bits(gb, 4);
@@@ -654,10 -626,6 +654,10 @@@ static int decode_pce(AVCodecContext *a
      if (get_bits1(gb))
          skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
  
 +    if (get_bits_left(gb) < 4 * (num_front + num_side + num_back + num_lfe + num_assoc_data + num_cc)) {
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
 +        return -1;
 +    }
      decode_channel_map(layout_map       , AAC_CHANNEL_FRONT, gb, num_front);
      tags = num_front;
      decode_channel_map(layout_map + tags, AAC_CHANNEL_SIDE,  gb, num_side);
      /* comment field, first byte is length */
      comment_len = get_bits(gb, 8) * 8;
      if (get_bits_left(gb) < comment_len) {
 -        av_log(avctx, AV_LOG_ERROR, overread_err);
 +        av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
          return -1;
      }
      skip_bits_long(gb, comment_len);
@@@ -774,9 -742,9 +774,9 @@@ static int decode_audio_specific_config
      GetBitContext gb;
      int i;
  
 -    av_dlog(avctx, "extradata size %d\n", avctx->extradata_size);
 -    for (i = 0; i < avctx->extradata_size; i++)
 -         av_dlog(avctx, "%02x ", avctx->extradata[i]);
 +    av_dlog(avctx, "audio specific config size %d\n", bit_size >> 3);
 +    for (i = 0; i < bit_size >> 3; i++)
 +         av_dlog(avctx, "%02x ", data[i]);
      av_dlog(avctx, "\n");
  
      init_get_bits(&gb, data, bit_size);
   *
   * @return  Returns a 32-bit pseudorandom integer
   */
 -static av_always_inline int lcg_random(int previous_val)
 +static av_always_inline int lcg_random(unsigned previous_val)
  {
-     return previous_val * 1664525 + 1013904223;
+     union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
+     return v.s;
  }
  
  static av_always_inline void reset_predict_state(PredictorState *ps)
@@@ -969,7 -938,7 +970,7 @@@ static int skip_data_stream_element(AAC
          align_get_bits(gb);
  
      if (get_bits_left(gb) < 8 * count) {
 -        av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +        av_log(ac->avctx, AV_LOG_ERROR, "skip_data_stream_element: "overread_err);
          return -1;
      }
      skip_bits_long(gb, 8 * count);
@@@ -1050,11 -1019,11 +1051,11 @@@ static int decode_ics_info(AACContext *
          if (ics->predictor_present) {
              if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN) {
                  if (decode_prediction(ac, ics, gb)) {
 -                    return AVERROR_INVALIDDATA;
 +                    goto fail;
                  }
              } else if (ac->oc[1].m4ac.object_type == AOT_AAC_LC) {
                  av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
 -                return AVERROR_INVALIDDATA;
 +                goto fail;
              } else {
                  if ((ics->ltp.present = get_bits(gb, 1)))
                      decode_ltp(&ics->ltp, gb, ics->max_sfb);
          av_log(ac->avctx, AV_LOG_ERROR,
                 "Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
                 ics->max_sfb, ics->num_swb);
 -        return AVERROR_INVALIDDATA;
 +        goto fail;
      }
  
      return 0;
 +fail:
 +    ics->max_sfb = 0;
 +    return AVERROR_INVALIDDATA;
  }
  
  /**
@@@ -1103,7 -1069,7 +1104,7 @@@ static int decode_band_types(AACContex
                  sect_len_incr = get_bits(gb, bits);
                  sect_end += sect_len_incr;
                  if (get_bits_left(gb) < 0) {
 -                    av_log(ac->avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(ac->avctx, AV_LOG_ERROR, "decode_band_types: "overread_err);
                      return -1;
                  }
                  if (sect_end > ics->max_sfb) {
@@@ -1271,7 -1237,7 +1272,7 @@@ static void decode_mid_side_stereo(Chan
          for (idx = 0; idx < cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb; idx++)
              cpe->ms_mask[idx] = get_bits1(gb);
      } else if (ms_present == 2) {
 -        memset(cpe->ms_mask, 1, cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb * sizeof(cpe->ms_mask[0]));
 +        memset(cpe->ms_mask, 1,  sizeof(cpe->ms_mask[0]) * cpe->ch[0].ics.num_window_groups * cpe->ch[0].ics.max_sfb);
      }
  }
  
@@@ -1394,7 -1360,7 +1395,7 @@@ static int decode_spectrum_and_dequant(
  
                      band_energy = ac->dsp.scalarproduct_float(cfo, cfo, off_len);
                      scale = sf[idx] / sqrtf(band_energy);
-                     ac->dsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
+                     ac->fdsp.vector_fmul_scalar(cfo, cfo, scale, off_len);
                  }
              } else {
                  const float *vq = ff_aac_codebook_vector_vals[cbt_m1];
                              }
                          } while (len -= 2);
  
-                         ac->dsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
+                         ac->fdsp.vector_fmul_scalar(cfo, cfo, sf[idx], off_len);
                      }
                  }
  
@@@ -1764,10 -1730,10 +1765,10 @@@ static void apply_intensity_stereo(AACC
                          c *= 1 - 2 * cpe->ms_mask[idx];
                      scale = c * sce1->sf[idx];
                      for (group = 0; group < ics->group_len[g]; group++)
-                         ac->dsp.vector_fmul_scalar(coef1 + group * 128 + offsets[i],
-                                                    coef0 + group * 128 + offsets[i],
-                                                    scale,
-                                                    offsets[i + 1] - offsets[i]);
+                         ac->fdsp.vector_fmul_scalar(coef1 + group * 128 + offsets[i],
+                                                     coef0 + group * 128 + offsets[i],
+                                                     scale,
+                                                     offsets[i + 1] - offsets[i]);
                  }
              } else {
                  int bt_run_end = sce1->band_type_run_end[idx];
@@@ -1974,32 -1940,6 +1975,32 @@@ static int decode_dynamic_range(Dynamic
      return n;
  }
  
 +static int decode_fill(AACContext *ac, GetBitContext *gb, int len) {
 +    uint8_t buf[256];
 +    int i, major, minor;
 +
 +    if (len < 13+7*8)
 +        goto unknown;
 +
 +    get_bits(gb, 13); len -= 13;
 +
 +    for(i=0; i+1<sizeof(buf) && len>=8; i++, len-=8)
 +        buf[i] = get_bits(gb, 8);
 +
 +    buf[i] = 0;
 +    if (ac->avctx->debug & FF_DEBUG_PICT_INFO)
 +        av_log(ac->avctx, AV_LOG_DEBUG, "FILL:%s\n", buf);
 +
 +    if (sscanf(buf, "libfaac %d.%d", &major, &minor) == 2){
 +        ac->avctx->internal->skip_samples = 1024;
 +    }
 +
 +unknown:
 +    skip_bits_long(gb, len);
 +
 +    return 0;
 +}
 +
  /**
   * Decode extension data (incomplete); reference: table 4.51.
   *
@@@ -2041,8 -1981,6 +2042,8 @@@ static int decode_extension_payload(AAC
          res = decode_dynamic_range(&ac->che_drc, gb);
          break;
      case EXT_FILL:
 +        decode_fill(ac, gb, 8 * cnt - 4);
 +        break;
      case EXT_FILL_DATA:
      case EXT_DATA_ELEMENT:
      default:
@@@ -2065,7 -2003,7 +2066,7 @@@ static void apply_tns(float coef[1024]
      int w, filt, m, i;
      int bottom, top, order, start, end, size, inc;
      float lpc[TNS_MAX_ORDER];
 -    float tmp[TNS_MAX_ORDER];
 +    float tmp[TNS_MAX_ORDER+1];
  
      for (w = 0; w < ics->num_windows; w++) {
          bottom = ics->num_swb;
@@@ -2412,11 -2350,9 +2413,11 @@@ static int parse_adts_frame_header(AACC
  
      size = avpriv_aac_parse_header(gb, &hdr_info);
      if (size > 0) {
 -        if (hdr_info.num_aac_frames != 1) {
 +        if (!ac->warned_num_aac_frames && hdr_info.num_aac_frames != 1) {
 +            // This is 2 for "VLB " audio in NSV files.
 +            // See samples/nsv/vlb_audio.
              av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame", 0);
 -            return AVERROR_PATCHWELCOME;
 +            ac->warned_num_aac_frames = 1;
          }
          push_output_configuration(ac);
          if (hdr_info.chan_config) {
                  return -7;
          } else {
              ac->oc[1].m4ac.chan_config = 0;
 +            /**
 +             * dual mono frames in Japanese DTV can have chan_config 0
 +             * WITHOUT specifying PCE.
 +             *  thus, set dual mono as default.
 +             */
 +#if 0
 +            if (ac->enable_jp_dmono && ac->oc[0].status == OC_NONE) {
 +                layout_map_tags = 2;
 +                layout_map[0][0] = layout_map[1][0] = TYPE_SCE;
 +                layout_map[0][2] = layout_map[1][2] = AAC_CHANNEL_FRONT;
 +                layout_map[0][1] = 0;
 +                layout_map[1][1] = 1;
 +                if (output_configure(ac, layout_map, layout_map_tags,
 +                                     OC_TRIAL_FRAME))
 +                    return -7;
 +            }
 +#endif
          }
          ac->oc[1].m4ac.sample_rate     = hdr_info.sample_rate;
          ac->oc[1].m4ac.sampling_index  = hdr_info.sampling_index;
  }
  
  static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
 -                                int *got_frame_ptr, GetBitContext *gb)
 +                                int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt)
  {
      AACContext *ac = avctx->priv_data;
      ChannelElement *che = NULL, *che_prev = NULL;
      enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
      int err, elem_id;
      int samples = 0, multiplier, audio_found = 0, pce_found = 0;
 +    int is_dmono, sce_count = 0;
 +    float *tmp = NULL;
  
      if (show_bits(gb, 12) == 0xfff) {
          if (parse_adts_frame_header(ac, gb) < 0) {
          case TYPE_SCE:
              err = decode_ics(ac, &che->ch[0], gb, 0, 0);
              audio_found = 1;
 +            sce_count++;
              break;
  
          case TYPE_CPE:
                  pop_output_configuration(ac);
              } else {
                  err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
 +                if (!err)
 +                    ac->oc[1].m4ac.chan_config = 0;
                  pce_found = 1;
              }
              break;
              if (elem_id == 15)
                  elem_id += get_bits(gb, 8) - 1;
              if (get_bits_left(gb) < 8 * elem_id) {
 -                    av_log(avctx, AV_LOG_ERROR, overread_err);
 +                    av_log(avctx, AV_LOG_ERROR, "TYPE_FIL: "overread_err);
                      err = -1;
                      goto fail;
              }
  
      multiplier = (ac->oc[1].m4ac.sbr == 1) ? ac->oc[1].m4ac.ext_sample_rate > ac->oc[1].m4ac.sample_rate : 0;
      samples <<= multiplier;
 -
 +#if 0
 +    /* for dual-mono audio (SCE + SCE) */
 +    is_dmono = ac->enable_jp_dmono && sce_count == 2 &&
 +               ac->oc[1].channel_layout == (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT);
 +
 +    if (is_dmono) {
 +        if (ac->dmono_mode == 0) {
 +            tmp = ac->output_data[1];
 +            ac->output_data[1] = ac->output_data[0];
 +        } else if (ac->dmono_mode == 1) {
 +            tmp = ac->output_data[0];
 +            ac->output_data[0] = ac->output_data[1];
 +        }
 +    }
 +#endif
      if (samples) {
          ac->frame.nb_samples = samples;
          *(AVFrame *)data = ac->frame;
      }
      *got_frame_ptr = !!samples;
 -
 +#if 0
 +    if (is_dmono) {
 +        if (ac->dmono_mode == 0)
 +            ac->output_data[1] = tmp;
 +        else if (ac->dmono_mode == 1)
 +            ac->output_data[0] = tmp;
 +    }
 +#endif
      if (ac->oc[1].status && audio_found) {
          avctx->sample_rate = ac->oc[1].m4ac.sample_rate << multiplier;
          avctx->frame_size = samples;
          ac->oc[1].status = OC_LOCKED;
      }
  
 +    if (multiplier) {
 +        int side_size;
 +        uint32_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
 +        if (side && side_size>=4)
 +            AV_WL32(side, 2*AV_RL32(side));
 +    }
      return 0;
  fail:
      pop_output_configuration(ac);
@@@ -2649,12 -2536,8 +2650,12 @@@ static int aac_decode_frame(AVCodecCont
      const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
                                         AV_PKT_DATA_NEW_EXTRADATA,
                                         &new_extradata_size);
 +    int jp_dualmono_size;
 +    const uint8_t *jp_dualmono   = av_packet_get_side_data(avpkt,
 +                                       AV_PKT_DATA_JP_DUALMONO,
 +                                       &jp_dualmono_size);
  
 -    if (new_extradata) {
 +    if (new_extradata && 0) {
          av_free(avctx->extradata);
          avctx->extradata = av_mallocz(new_extradata_size +
                                        FF_INPUT_BUFFER_PADDING_SIZE);
          }
      }
  
 +    ac->enable_jp_dmono = !!jp_dualmono;
 +    ac->dmono_mode = 0;
 +    if (jp_dualmono && jp_dualmono_size > 0)
 +        ac->dmono_mode = *jp_dualmono;
 +
      init_get_bits(&gb, buf, buf_size * 8);
  
 -    if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb)) < 0)
 +    if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt)) < 0)
          return err;
  
      buf_consumed = (get_bits_count(&gb) + 7) >> 3;
@@@ -2713,7 -2591,7 +2714,7 @@@ static av_cold int aac_decode_close(AVC
  
  struct LATMContext {
      AACContext      aac_ctx;             ///< containing AACContext
 -    int             initialized;         ///< initilized after a valid extradata was seen
 +    int             initialized;         ///< initialized after a valid extradata was seen
  
      // parser data
      int             audio_mux_version_A; ///< LATM syntax version
@@@ -2758,15 -2636,10 +2759,15 @@@ static int latm_decode_audio_specific_c
      if (bits_consumed < 0)
          return AVERROR_INVALIDDATA;
  
 -    if (ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
 +    if (!latmctx->initialized ||
 +        ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
          ac->oc[1].m4ac.chan_config != m4ac.chan_config) {
  
 -        av_log(avctx, AV_LOG_INFO, "audio config changed\n");
 +        if(latmctx->initialized) {
 +            av_log(avctx, AV_LOG_INFO, "audio config changed\n");
 +        } else {
 +            av_log(avctx, AV_LOG_INFO, "initializing latmctx\n");
 +        }
          latmctx->initialized = 0;
  
          esize = (bits_consumed+7) / 8;
@@@ -2810,9 -2683,9 +2811,9 @@@ static int read_stream_mux_config(struc
              return AVERROR_PATCHWELCOME;
          }
  
 -        // for each program (which there is only on in DVB)
 +        // for each program (which there is only one in DVB)
  
 -        // for each layer (which there is only on in DVB)
 +        // for each layer (which there is only one in DVB)
          if (get_bits(gb, 3)) {                   // numLayer
              av_log_missing_feature(latmctx->aac_ctx.avctx,
                                     "Multiple layers", 1);
@@@ -2933,7 -2806,7 +2934,7 @@@ static int latm_decode_frame(AVCodecCon
          return AVERROR_INVALIDDATA;
  
      muxlength = get_bits(&gb, 13) + 3;
 -    // not enough data, the parser should have sorted this
 +    // not enough data, the parser should have sorted this out
      if (muxlength > avpkt->size)
          return AVERROR_INVALIDDATA;
  
          return AVERROR_INVALIDDATA;
      }
  
 -    if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb)) < 0)
 +    if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb, avpkt)) < 0)
          return err;
  
      return muxlength;
@@@ -2995,7 -2868,6 +2996,7 @@@ AVCodec ff_aac_decoder = 
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
  
  /*
@@@ -3017,5 -2889,4 +3018,5 @@@ AVCodec ff_aac_latm_decoder = 
      },
      .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
      .channel_layouts = aac_channel_layout,
 +    .flush = flush,
  };
@@@ -2,20 -2,20 +2,20 @@@
   * ARM NEON optimised DSP functions
   * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -144,8 -144,6 +144,6 @@@ void ff_avg_h264_chroma_mc2_neon(uint8_
  
  void ff_vector_fmul_window_neon(float *dst, const float *src0,
                                  const float *src1, const float *win, int len);
- void ff_vector_fmul_scalar_neon(float *dst, const float *src, float mul,
-                                 int len);
  void ff_butterflies_float_neon(float *v1, float *v2, int len);
  float ff_scalarproduct_float_neon(const float *v1, const float *v2, int len);
  void ff_vector_fmul_reverse_neon(float *dst, const float *src0,
@@@ -171,7 -169,7 +169,7 @@@ void ff_dsputil_init_neon(DSPContext *c
  {
      const int high_bit_depth = avctx->bits_per_raw_sample > 8;
  
 -    if (avctx->bits_per_raw_sample <= 8) {
 +    if (!avctx->lowres && avctx->bits_per_raw_sample <= 8) {
          if (avctx->idct_algo == FF_IDCT_AUTO ||
              avctx->idct_algo == FF_IDCT_SIMPLENEON) {
              c->idct_put              = ff_simple_idct_put_neon;
      }
  
      c->vector_fmul_window         = ff_vector_fmul_window_neon;
-     c->vector_fmul_scalar         = ff_vector_fmul_scalar_neon;
      c->butterflies_float          = ff_butterflies_float_neon;
      c->scalarproduct_float        = ff_scalarproduct_float_neon;
      c->vector_fmul_reverse        = ff_vector_fmul_reverse_neon;
@@@ -2,20 -2,20 +2,20 @@@
   * ARM NEON optimised DSP functions
   * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -642,44 -642,6 +642,6 @@@ function ff_vorbis_inverse_coupling_neo
  endfunc
  #endif
  
- function ff_vector_fmul_scalar_neon, export=1
- VFP     len .req r2
- NOVFP   len .req r3
- VFP     vdup.32         q8,  d0[0]
- NOVFP   vdup.32         q8,  r2
-         bics            r12, len, #15
-         beq             3f
-         vld1.32         {q0},[r1,:128]!
-         vld1.32         {q1},[r1,:128]!
- 1:      vmul.f32        q0,  q0,  q8
-         vld1.32         {q2},[r1,:128]!
-         vmul.f32        q1,  q1,  q8
-         vld1.32         {q3},[r1,:128]!
-         vmul.f32        q2,  q2,  q8
-         vst1.32         {q0},[r0,:128]!
-         vmul.f32        q3,  q3,  q8
-         vst1.32         {q1},[r0,:128]!
-         subs            r12, r12, #16
-         beq             2f
-         vld1.32         {q0},[r1,:128]!
-         vst1.32         {q2},[r0,:128]!
-         vld1.32         {q1},[r1,:128]!
-         vst1.32         {q3},[r0,:128]!
-         b               1b
- 2:      vst1.32         {q2},[r0,:128]!
-         vst1.32         {q3},[r0,:128]!
-         ands            len, len, #15
-         it              eq
-         bxeq            lr
- 3:      vld1.32         {q0},[r1,:128]!
-         vmul.f32        q0,  q0,  q8
-         vst1.32         {q0},[r0,:128]!
-         subs            len, len, #4
-         bgt             3b
-         bx              lr
-         .unreq          len
- endfunc
  function ff_butterflies_float_neon, export=1
  1:      vld1.32         {q0},[r0,:128]
          vld1.32         {q1},[r1,:128]
diff --combined libavcodec/dsputil.c
@@@ -5,20 -5,20 +5,20 @@@
   *
   * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "mpegvideo.h"
  #include "config.h"
  #include "vorbis.h"
 +#include "diracdsp.h"
  
  uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
  uint32_t ff_squareTbl[512] = {0, };
  
 +#define pixeltmp int16_t
  #define BIT_DEPTH 9
  #include "dsputil_template.c"
  #undef BIT_DEPTH
  #include "dsputil_template.c"
  #undef BIT_DEPTH
  
 +#undef pixeltmp
 +#define pixeltmp int32_t
 +#define BIT_DEPTH 12
 +#include "dsputil_template.c"
 +#undef BIT_DEPTH
 +
 +#define BIT_DEPTH 14
 +#include "dsputil_template.c"
 +#undef BIT_DEPTH
 +
 +#undef pixeltmp
 +#define pixeltmp int16_t
  #define BIT_DEPTH 8
  #include "dsputil_template.c"
 +#undef pixeltmp
  
  // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
  #define pb_7f (~0UL/255 * 0x7f)
@@@ -352,7 -337,7 +352,7 @@@ static int sse16_c(void *v, uint8_t *pi
      return s;
  }
  
 -static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
 +static void diff_pixels_c(DCTELEM *av_restrict block, const uint8_t *s1,
                            const uint8_t *s2, int stride){
      int i;
  
  }
  
  
 -static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
 +static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *av_restrict pixels,
                                   int line_size)
  {
      int i;
      }
  }
  
 +static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *av_restrict pixels,
 +                                 int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<4;i++) {
 +        pixels[0] = av_clip_uint8(block[0]);
 +        pixels[1] = av_clip_uint8(block[1]);
 +        pixels[2] = av_clip_uint8(block[2]);
 +        pixels[3] = av_clip_uint8(block[3]);
 +
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
 +static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *av_restrict pixels,
 +                                 int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<2;i++) {
 +        pixels[0] = av_clip_uint8(block[0]);
 +        pixels[1] = av_clip_uint8(block[1]);
 +
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
  static void put_signed_pixels_clamped_c(const DCTELEM *block,
 -                                        uint8_t *restrict pixels,
 +                                        uint8_t *av_restrict pixels,
                                          int line_size)
  {
      int i, j;
      }
  }
  
 -static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
 +static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *av_restrict pixels,
                                   int line_size)
  {
      int i;
      }
  }
  
 +static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *av_restrict pixels,
 +                          int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<4;i++) {
 +        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
 +        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
 +        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
 +        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
 +static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *av_restrict pixels,
 +                          int line_size)
 +{
 +    int i;
 +
 +    /* read the pixels */
 +    for(i=0;i<2;i++) {
 +        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
 +        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
 +        pixels += line_size;
 +        block += 8;
 +    }
 +}
 +
  static int sum_abs_dctelem_c(DCTELEM *block)
  {
      int sum=0, i;
@@@ -1333,51 -1256,6 +1333,51 @@@ void ff_avg_rv40_qpel8_mc33_c(uint8_t *
  }
  #endif /* CONFIG_RV40_DECODER */
  
 +#if CONFIG_DIRAC_DECODER
 +#define DIRAC_MC(OPNAME)\
 +void ff_ ## OPNAME ## _dirac_pixels8_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +     OPNAME ## _pixels8_8_c(dst, src[0], stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels16_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_8_c(dst, src[0], stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels32_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_8_c(dst   , src[0]   , stride, h);\
 +    OPNAME ## _pixels16_8_c(dst+16, src[0]+16, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels8_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels8_l2_8(dst, src[0], src[1], stride, stride, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels16_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_l2_8(dst, src[0], src[1], stride, stride, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels32_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_l2_8(dst   , src[0]   , src[1]   , stride, stride, stride, h);\
 +    OPNAME ## _pixels16_l2_8(dst+16, src[0]+16, src[1]+16, stride, stride, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels8_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels8_l4_8(dst, src[0], src[1], src[2], src[3], stride, stride, stride, stride, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels16_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_l4_8(dst, src[0], src[1], src[2], src[3], stride, stride, stride, stride, stride, h);\
 +}\
 +void ff_ ## OPNAME ## _dirac_pixels32_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    OPNAME ## _pixels16_l4_8(dst   , src[0]   , src[1]   , src[2]   , src[3]   , stride, stride, stride, stride, stride, h);\
 +    OPNAME ## _pixels16_l4_8(dst+16, src[0]+16, src[1]+16, src[2]+16, src[3]+16, stride, stride, stride, stride, stride, h);\
 +}
 +DIRAC_MC(put)
 +DIRAC_MC(avg)
 +#endif
 +
  static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
      uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
      int i;
@@@ -1812,7 -1690,7 +1812,7 @@@ static int try_8x8basis_c(int16_t rem[6
          int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
          int w= weight[i];
          b>>= RECON_SHIFT;
 -        assert(-512<b && b<512);
 +        av_assert2(-512<b && b<512);
  
          sum += (w*b)*(w*b)>>4;
      }
@@@ -1931,7 -1809,7 +1931,7 @@@ static void add_bytes_c(uint8_t *dst, u
          dst[i+0] += src[i+0];
  }
  
 -static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
 +static void diff_bytes_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w){
      long i;
  #if !HAVE_FAST_UNALIGNED
      if((long)src2 & (sizeof(long)-1)){
@@@ -2071,7 -1949,7 +2071,7 @@@ static int hadamard8_diff8x8_c(/*MpegEn
      int temp[64];
      int sum=0;
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      for(i=0; i<8; i++){
          //FIXME try pointer walks
@@@ -2116,7 -1994,7 +2116,7 @@@ static int hadamard8_intra8x8_c(/*MpegE
      int temp[64];
      int sum=0;
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      for(i=0; i<8; i++){
          //FIXME try pointer walks
@@@ -2163,7 -2041,7 +2163,7 @@@ static int dct_sad8x8_c(/*MpegEncContex
      MpegEncContext * const s= (MpegEncContext *)c;
      LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      s->dsp.diff_pixels(temp, src1, src2, stride);
      s->dsp.fdct(temp);
@@@ -2228,7 -2106,7 +2228,7 @@@ static int dct_max8x8_c(/*MpegEncContex
      LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
      int sum=0, i;
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      s->dsp.diff_pixels(temp, src1, src2, stride);
      s->dsp.fdct(temp);
@@@ -2245,7 -2123,7 +2245,7 @@@ static int quant_psnr8x8_c(/*MpegEncCon
      DCTELEM * const bak = temp+64;
      int sum=0, i;
  
 -    assert(h==8);
 +    av_assert2(h==8);
      s->mb_intra=0;
  
      s->dsp.diff_pixels(temp, src1, src2, stride);
@@@ -2273,7 -2151,7 +2273,7 @@@ static int rd8x8_c(/*MpegEncContext*/ v
      uint8_t * length;
      uint8_t * last_length;
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      copy_block8(lsrc1, src1, 8, stride, 8);
      copy_block8(lsrc2, src2, 8, stride, 8);
  
          level= temp[i] + 64;
  
 -        assert(level - 64);
 +        av_assert2(level - 64);
  
          if((level&(~127)) == 0){
              bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
@@@ -2347,7 -2225,7 +2347,7 @@@ static int bit8x8_c(/*MpegEncContext*/ 
      uint8_t * length;
      uint8_t * last_length;
  
 -    assert(h==8);
 +    av_assert2(h==8);
  
      s->dsp.diff_pixels(temp, src1, src2, stride);
  
  
          level= temp[i] + 64;
  
 -        assert(level - 64);
 +        av_assert2(level - 64);
  
          if((level&(~127)) == 0){
              bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
@@@ -2514,15 -2392,7 +2514,7 @@@ static void vector_fmul_window_c(float 
      }
  }
  
- static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
-                                  int len)
- {
-     int i;
-     for (i = 0; i < len; i++)
-         dst[i] = src[i] * mul;
- }
 -static void butterflies_float_c(float *restrict v1, float *restrict v2,
 +static void butterflies_float_c(float *av_restrict v1, float *av_restrict v2,
                                  int len)
  {
      int i;
@@@ -2745,37 -2615,6 +2737,37 @@@ static void ff_jref_idct_add(uint8_t *d
      add_pixels_clamped_c(block, dest, line_size);
  }
  
 +static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    ff_j_rev_dct4 (block);
 +    put_pixels_clamped4_c(block, dest, line_size);
 +}
 +static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    ff_j_rev_dct4 (block);
 +    add_pixels_clamped4_c(block, dest, line_size);
 +}
 +
 +static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    ff_j_rev_dct2 (block);
 +    put_pixels_clamped2_c(block, dest, line_size);
 +}
 +static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    ff_j_rev_dct2 (block);
 +    add_pixels_clamped2_c(block, dest, line_size);
 +}
 +
 +static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    dest[0] = av_clip_uint8((block[0] + 4)>>3);
 +}
 +static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
 +{
 +    dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
 +}
 +
  static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
  
  /* init static data */
@@@ -2807,7 -2646,7 +2799,7 @@@ int ff_check_alignment(void)
                  "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
                  "and may be very slow or crash. This is not a bug in libavcodec,\n"
                  "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
 -                "Do not report crashes to Libav developers.\n");
 +                "Do not report crashes to FFmpeg developers.\n");
  #endif
              did_fail=1;
          }
@@@ -2842,28 -2681,12 +2834,28 @@@ av_cold void ff_dsputil_init(DSPContext
      }
  #endif //CONFIG_ENCODERS
  
 -    if (avctx->bits_per_raw_sample == 10) {
 -        c->idct_put              = ff_simple_idct_put_10;
 -        c->idct_add              = ff_simple_idct_add_10;
 -        c->idct                  = ff_simple_idct_10;
 -        c->idct_permutation_type = FF_NO_IDCT_PERM;
 -    } else {
 +    if(avctx->lowres==1){
 +        c->idct_put= ff_jref_idct4_put;
 +        c->idct_add= ff_jref_idct4_add;
 +        c->idct    = ff_j_rev_dct4;
 +        c->idct_permutation_type= FF_NO_IDCT_PERM;
 +    }else if(avctx->lowres==2){
 +        c->idct_put= ff_jref_idct2_put;
 +        c->idct_add= ff_jref_idct2_add;
 +        c->idct    = ff_j_rev_dct2;
 +        c->idct_permutation_type= FF_NO_IDCT_PERM;
 +    }else if(avctx->lowres==3){
 +        c->idct_put= ff_jref_idct1_put;
 +        c->idct_add= ff_jref_idct1_add;
 +        c->idct    = ff_j_rev_dct1;
 +        c->idct_permutation_type= FF_NO_IDCT_PERM;
 +    }else{
 +        if (avctx->bits_per_raw_sample == 10) {
 +            c->idct_put              = ff_simple_idct_put_10;
 +            c->idct_add              = ff_simple_idct_add_10;
 +            c->idct                  = ff_simple_idct_10;
 +            c->idct_permutation_type = FF_NO_IDCT_PERM;
 +        } else {
          if(avctx->idct_algo==FF_IDCT_INT){
              c->idct_put= ff_jref_idct_put;
              c->idct_add= ff_jref_idct_add;
              c->idct     = ff_simple_idct_8;
              c->idct_permutation_type= FF_NO_IDCT_PERM;
          }
 +        }
      }
  
      c->diff_pixels = diff_pixels_c;
      c->scalarproduct_float = ff_scalarproduct_float_c;
      c->butterflies_float = butterflies_float_c;
      c->butterflies_float_interleave = butterflies_float_interleave_c;
-     c->vector_fmul_scalar = vector_fmul_scalar_c;
  
      c->shrink[0]= av_image_copy_plane;
      c->shrink[1]= ff_shrink22;
              BIT_DEPTH_FUNCS(10, _16);
          }
          break;
 +    case 12:
 +        if (c->dct_bits == 32) {
 +            BIT_DEPTH_FUNCS(12, _32);
 +        } else {
 +            BIT_DEPTH_FUNCS(12, _16);
 +        }
 +        break;
 +    case 14:
 +        if (c->dct_bits == 32) {
 +            BIT_DEPTH_FUNCS(14, _32);
 +        } else {
 +            BIT_DEPTH_FUNCS(14, _16);
 +        }
 +        break;
      default:
 -        BIT_DEPTH_FUNCS(8, _16);
 +        if(avctx->bits_per_raw_sample<=8 || avctx->codec_type != AVMEDIA_TYPE_VIDEO) {
 +            BIT_DEPTH_FUNCS(8, _16);
 +        }
          break;
      }
  
      if (ARCH_PPC)        ff_dsputil_init_ppc   (c, avctx);
      if (ARCH_SH4)        ff_dsputil_init_sh4   (c, avctx);
      if (ARCH_BFIN)       ff_dsputil_init_bfin  (c, avctx);
 +    if (HAVE_MIPSFPU)    ff_dsputil_init_mips  (c, avctx);
  
      for (i = 0; i < 4; i++) {
          for (j = 0; j < 16; j++) {
      ff_init_scantable_permutation(c->idct_permutation,
                                    c->idct_permutation_type);
  }
 +
 +av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
 +{
 +    ff_dsputil_init(c, avctx);
 +}
diff --combined libavcodec/dsputil.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -46,9 -46,6 +46,9 @@@ void ff_fdct248_islow_8(DCTELEM *data)
  void ff_fdct248_islow_10(DCTELEM *data);
  
  void ff_j_rev_dct (DCTELEM *data);
 +void ff_j_rev_dct4 (DCTELEM *data);
 +void ff_j_rev_dct2 (DCTELEM *data);
 +void ff_j_rev_dct1 (DCTELEM *data);
  void ff_wmv2_idct_c(DCTELEM *data);
  
  void ff_fdct_mmx(DCTELEM *block);
@@@ -72,8 -69,6 +72,8 @@@ void ff_h264_chroma_dc_dequant_idct_ #
  H264_IDCT( 8)
  H264_IDCT( 9)
  H264_IDCT(10)
 +H264_IDCT(12)
 +H264_IDCT(14)
  
  void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp);
  void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
@@@ -100,8 -95,6 +100,8 @@@ void ff_avg_pixels16x16_ ## depth ## _c
  PUTAVG_PIXELS( 8)
  PUTAVG_PIXELS( 9)
  PUTAVG_PIXELS(10)
 +PUTAVG_PIXELS(12)
 +PUTAVG_PIXELS(14)
  
  #define ff_put_pixels8x8_c ff_put_pixels8x8_8_c
  #define ff_avg_pixels8x8_c ff_avg_pixels8x8_8_c
@@@ -125,7 -118,7 +125,7 @@@ void ff_gmc_c(uint8_t *dst, uint8_t *sr
  /* minimum alignment rules ;)
  If you notice errors in the align stuff, need more alignment for some ASM code
  for some CPU or need to use a function with less aligned data then send a mail
 -to the libav-devel mailing list, ...
 +to the ffmpeg-devel mailing list, ...
  
  !warning These alignments might not match reality, (missing attribute((align))
  stuff somewhere possible).
@@@ -203,8 -196,6 +203,8 @@@ void ff_emulated_edge_mc_ ## depth (uin
  EMULATED_EDGE(8)
  EMULATED_EDGE(9)
  EMULATED_EDGE(10)
 +EMULATED_EDGE(12)
 +EMULATED_EDGE(14)
  
  /**
   * DSPContext.
@@@ -364,7 -355,7 +364,7 @@@ typedef struct DSPContext 
  
      /* huffyuv specific */
      void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);
 -    void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w);
 +    void (*diff_bytes)(uint8_t *dst/*align 16*/, const uint8_t *src1/*align 16*/, const uint8_t *src2/*align 1*/,int w);
      /**
       * subtract huffyuv's variant of median prediction
       * note, this might read from src1[-1], src2[-1]
      void (*add_hfyu_median_prediction)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top);
      int  (*add_hfyu_left_prediction)(uint8_t *dst, const uint8_t *src, int w, int left);
      void (*add_hfyu_left_prediction_bgr32)(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha);
 +    /* this might write to dst[w] */
      void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w);
      void (*bswap16_buf)(uint16_t *dst, const uint16_t *src, int len);
  
      /* assume len is a multiple of 8, and arrays are 16-byte aligned */
      void (*vector_clipf)(float *dst /* align 16 */, const float *src /* align 16 */, float min, float max, int len /* align 16 */);
      /**
-      * Multiply a vector of floats by a scalar float.  Source and
-      * destination vectors must overlap exactly or not at all.
-      * @param dst result vector, 16-byte aligned
-      * @param src input vector, 16-byte aligned
-      * @param mul scalar value
-      * @param len length of vector, multiple of 4
-      */
-     void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
-                                int len);
-     /**
       * Calculate the scalar product of two vectors of floats.
       * @param v1  first vector, 16-byte aligned
       * @param v2  second vector, 16-byte aligned
       * @param v2  second input vector, difference output, 16-byte aligned
       * @param len length of vectors, multiple of 4
       */
 -    void (*butterflies_float)(float *restrict v1, float *restrict v2, int len);
 +    void (*butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len);
  
      /**
       * Calculate the sum and difference of two vectors of floats and interleave
  
  void ff_dsputil_static_init(void);
  void ff_dsputil_init(DSPContext* p, AVCodecContext *avctx);
 +attribute_deprecated void dsputil_init(DSPContext* c, AVCodecContext *avctx);
  
  int ff_check_alignment(void);
  
@@@ -614,7 -593,6 +604,7 @@@ void ff_dsputil_init_mmx(DSPContext* c
  void ff_dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);
  void ff_dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx);
  void ff_dsputil_init_vis(DSPContext* c, AVCodecContext *avctx);
 +void ff_dsputil_init_mips(DSPContext* c, AVCodecContext *avctx);
  
  void ff_dsputil_init_dwt(DSPContext *c);
  
diff --combined libavcodec/libmp3lame.c
@@@ -2,20 -2,20 +2,20 @@@
   * Interface to libmp3lame for mp3 encoding
   * Copyright (c) 2002 Lennert Buytenhek <buytenh@gnu.org>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  
  #include "libavutil/channel_layout.h"
  #include "libavutil/common.h"
+ #include "libavutil/float_dsp.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "avcodec.h"
  #include "audio_frame_queue.h"
- #include "dsputil.h"
  #include "internal.h"
  #include "mpegaudio.h"
  #include "mpegaudiodecheader.h"
  
 -#define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4)
 +#define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4+1000) // FIXME: Buffer size to small? Adding 1000 to make up for it.
  
  typedef struct LAMEContext {
      AVClass *class;
@@@ -50,7 -50,7 +50,7 @@@
      int reservoir;
      float *samples_flt[2];
      AudioFrameQueue afq;
-     DSPContext dsp;
+     AVFloatDSPContext fdsp;
  } LAMEContext;
  
  
@@@ -102,7 -102,6 +102,7 @@@ static av_cold int mp3lame_encode_init(
      if ((s->gfp = lame_init()) == NULL)
          return AVERROR(ENOMEM);
  
 +
      lame_set_num_channels(s->gfp, avctx->channels);
      lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);
  
      if (ret < 0)
          goto error;
  
-     ff_dsputil_init(&s->dsp, avctx);
+     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
  
      return 0;
  error:
@@@ -206,10 -205,10 +206,10 @@@ static int mp3lame_encode_frame(AVCodec
                  return AVERROR(EINVAL);
              }
              for (ch = 0; ch < avctx->channels; ch++) {
-                 s->dsp.vector_fmul_scalar(s->samples_flt[ch],
-                                           (const float *)frame->data[ch],
-                                           32768.0f,
-                                           FFALIGN(frame->nb_samples, 8));
+                 s->fdsp.vector_fmul_scalar(s->samples_flt[ch],
+                                            (const float *)frame->data[ch],
+                                            32768.0f,
+                                            FFALIGN(frame->nb_samples, 8));
              }
              ENCODE_BUFFER(lame_encode_buffer_float, float, s->samples_flt);
              break;
      av_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,
              s->buffer_index);
      if (len <= s->buffer_index) {
 -        if ((ret = ff_alloc_packet(avpkt, len))) {
 -            av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 +        if ((ret = ff_alloc_packet2(avctx, avpkt, len)))
              return ret;
 -        }
          memcpy(avpkt->data, s->buffer, len);
          s->buffer_index -= len;
          memmove(s->buffer, s->buffer + len, s->buffer_index);
diff --combined libavcodec/wmaenc.c
@@@ -2,27 -2,29 +2,27 @@@
   * WMA compatible encoder
   * Copyright (c) 2007 Michael Niedermayer
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "avcodec.h"
  #include "internal.h"
  #include "wma.h"
 -
 -#undef NDEBUG
 -#include <assert.h>
 +#include "libavutil/avassert.h"
  
  
  static int encode_init(AVCodecContext * avctx){
@@@ -64,7 -66,7 +64,7 @@@
          AV_WL32(extradata, flags1);
          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;
@@@ -82,7 -84,8 +82,7 @@@
                           (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;
  
  #if FF_API_OLD_ENCODE_AUDIO
@@@ -108,7 -111,7 +108,7 @@@ static void apply_window_and_mdct(AVCod
  
      for (ch = 0; ch < avctx->channels; ch++) {
          memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
-         s->dsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
+         s->fdsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
          s->dsp.vector_fmul_reverse(&s->output[window_len], s->frame_out[ch], win, len);
          s->fdsp.vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
          mdct->mdct_calc(mdct, s->coefs[ch], s->output);
@@@ -147,7 -150,7 +147,7 @@@ static void encode_exp_vlc(WMACodecCont
      q_end = q + s->block_len;
      if (s->version == 1) {
          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
      while (q < q_end) {
          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]);
          /* XXX: use a table */
          q+= *ptr++;
@@@ -171,7 -174,7 +171,7 @@@ static int encode_block(WMACodecContex
  
      //FIXME remove duplication relative to decoder
      if (s->use_variable_block_len) {
 -        assert(0); //FIXME not implemented
 +        av_assert0(0); //FIXME not implemented
      }else{
          /* fixed block len */
          s->next_block_len_bits = s->frame_len_bits;
              mult *= mdct_norm;
              coefs = src_coefs[ch];
              if (s->use_noise_coding && 0) {
 -                assert(0); //FIXME not implemented
 +                av_assert0(0); //FIXME not implemented
              } else {
                  coefs += s->coefs_start;
                  n = nb_coefs[ch];
                  if (s->use_exp_vlc) {
                      encode_exp_vlc(s, ch, fixed_exp);
                  } else {
 -                    assert(0); //FIXME not implemented
 +                    av_assert0(0); //FIXME not implemented
  //                    encode_exp_lsp(s, ch);
                  }
              }
          }
      } else {
 -        assert(0); //FIXME not implemented
 +        av_assert0(0); //FIXME not implemented
      }
  
      for (ch = 0; ch < s->avctx->channels; ch++) {
                              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]);
  
                      if(code == 0){
@@@ -332,7 -335,7 +332,7 @@@ static int encode_frame(WMACodecContex
      init_put_bits(&s->pb, buf, buf_size);
  
      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;
@@@ -347,7 -350,7 +347,7 @@@ 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;
          }
      }
  
 -    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)))
          return ret;
 -    }
  
 -#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)
 +        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
  
 -    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");
 -        return AVERROR(EINVAL);
 -    }
 -    assert((put_bits_count(&s->pb) & 7) == 0);
 -    while (i++)
 +    while(total_gain <= 128 && error > 0)
 +        error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
 +    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);
 +    av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
  
      if (frame->pts != AV_NOPTS_VALUE)
          avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
      return 0;
  }
  
 +#if CONFIG_WMAV1_ENCODER
  AVCodec ff_wmav1_encoder = {
      .name           = "wmav1",
      .type           = AVMEDIA_TYPE_AUDIO,
                                                       AV_SAMPLE_FMT_NONE },
      .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
  };
 -
 +#endif
 +#if CONFIG_WMAV2_ENCODER
  AVCodec ff_wmav2_encoder = {
      .name           = "wmav2",
      .type           = AVMEDIA_TYPE_AUDIO,
                                                       AV_SAMPLE_FMT_NONE },
      .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
  };
 +#endif
diff --combined libavcodec/wmaprodec.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
   * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -86,6 -86,7 +86,7 @@@
   * subframe in order to reconstruct the output samples.
   */
  
+ #include "libavutil/float_dsp.h"
  #include "libavutil/intfloat.h"
  #include "libavutil/intreadwrite.h"
  #include "avcodec.h"
@@@ -170,6 -171,7 +171,7 @@@ typedef struct WMAProDecodeCtx 
      AVCodecContext*  avctx;                         ///< codec context for av_log
      AVFrame          frame;                         ///< AVFrame for decoded output
      DSPContext       dsp;                           ///< accelerated DSP functions
+     AVFloatDSPContext fdsp;
      uint8_t          frame_data[MAX_FRAMESIZE +
                        FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
      PutBitContext    pb;                            ///< context for filling the frame_data buffer
@@@ -280,6 -282,8 +282,8 @@@ static av_cold int decode_init(AVCodecC
  
      s->avctx = avctx;
      ff_dsputil_init(&s->dsp, avctx);
+     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
      init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
  
      avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
          return AVERROR_INVALIDDATA;
      }
  
 +    if (s->min_samples_per_subframe < (1<<WMAPRO_BLOCK_MIN_BITS)) {
 +        av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n",
 +               s->min_samples_per_subframe);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
      if (s->avctx->sample_rate <= 0) {
          av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
          return AVERROR_INVALIDDATA;
          }
          s->sfb_offsets[i][band - 1] = subframe_len;
          s->num_sfb[i]               = band - 1;
 +        if (s->num_sfb[i] <= 0) {
 +            av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n");
 +            return AVERROR_INVALIDDATA;
 +        }
      }
  
  
@@@ -539,7 -533,7 +543,7 @@@ static int decode_tilehdr(WMAProDecodeC
      int c;
  
      /* Should never consume more than 3073 bits (256 iterations for the
 -     * while loop when always the minimum amount of 128 samples is substracted
 +     * while loop when always the minimum amount of 128 samples is subtracted
       * from missing samples in the 8 channel case).
       * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
       */
@@@ -1018,12 -1012,12 +1022,12 @@@ static void inverse_channel_transform(W
                      }
                  } else if (s->avctx->channels == 2) {
                      int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
-                     s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
-                                               ch_data[0] + sfb[0],
-                                               181.0 / 128, len);
-                     s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
-                                               ch_data[1] + sfb[0],
-                                               181.0 / 128, len);
+                     s->fdsp.vector_fmul_scalar(ch_data[0] + sfb[0],
+                                                ch_data[0] + sfb[0],
+                                                181.0 / 128, len);
+                     s->fdsp.vector_fmul_scalar(ch_data[1] + sfb[0],
+                                                ch_data[1] + sfb[0],
+                                                181.0 / 128, len);
                  }
              }
          }
@@@ -1140,7 -1134,7 +1144,7 @@@ static int decode_subframe(WMAProDecode
          int num_fill_bits;
          if (!(num_fill_bits = get_bits(&s->gb, 2))) {
              int len = get_bits(&s->gb, 4);
 -            num_fill_bits = get_bits(&s->gb, len) + 1;
 +            num_fill_bits = (len ? get_bits(&s->gb, len) : 0) + 1;
          }
  
          if (num_fill_bits >= 0) {
              transmit_coeffs = 1;
      }
  
 +    av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE);
      if (transmit_coeffs) {
          int step;
          int quant_step = 90 * s->bits_per_sample >> 4;
              for (i = 0; i < s->channels_for_cur_subframe; i++) {
                  int c = s->channel_indexes_for_cur_subframe[i];
                  int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
 -                if (num_vec_coeffs > WMAPRO_BLOCK_MAX_SIZE) {
 +                if (num_vec_coeffs > s->subframe_len) {
                      av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
                      return AVERROR_INVALIDDATA;
                  }
                              s->channel[c].scale_factor_step;
                  const float quant = pow(10.0, exp / 20.0);
                  int start = s->cur_sfb_offsets[b];
-                 s->dsp.vector_fmul_scalar(s->tmp + start,
-                                           s->channel[c].coeffs + start,
-                                           quant, end - start);
+                 s->fdsp.vector_fmul_scalar(s->tmp + start,
+                                            s->channel[c].coeffs + start,
+                                            quant, end - start);
              }
  
              /** apply imdct (imdct_half == DCTIV with reverse) */
@@@ -1449,7 -1442,7 +1453,7 @@@ static void save_bits(WMAProDecodeCtx *
      int buflen;
  
      /** when the frame data does not need to be concatenated, the input buffer
 -        is resetted and additional bits from the previous frame are copyed
 +        is reset and additional bits from the previous frame are copied
          and skipped later so that a fast byte copy is possible */
  
      if (!append) {
          init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
      }
  
 -    buflen = (s->num_saved_bits + len + 8) >> 3;
 +    buflen = (put_bits_count(&s->pb) + len + 8) >> 3;
  
      if (len <= 0 || buflen > MAX_FRAMESIZE) {
          av_log_ask_for_sample(s->avctx, "input buffer too small\n");
diff --combined libavutil/float_dsp.c
@@@ -1,21 -1,18 +1,21 @@@
  /*
 - * This file is part of Libav.
 + * Copyright 2005 Balatoni Denes
 + * Copyright 2006 Loren Merritt
   *
 - * Libav is free software; you can redistribute it and/or
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -39,10 -36,19 +39,19 @@@ static void vector_fmac_scalar_c(float 
          dst[i] += src[i] * mul;
  }
  
+ static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
+                                  int len)
+ {
+     int i;
+     for (i = 0; i < len; i++)
+         dst[i] = src[i] * mul;
+ }
  void avpriv_float_dsp_init(AVFloatDSPContext *fdsp, int bit_exact)
  {
      fdsp->vector_fmul = vector_fmul_c;
      fdsp->vector_fmac_scalar = vector_fmac_scalar_c;
+     fdsp->vector_fmul_scalar = vector_fmul_scalar_c;
  
  #if ARCH_ARM
      ff_float_dsp_init_arm(fdsp);
@@@ -50,7 -56,5 +59,7 @@@
      ff_float_dsp_init_ppc(fdsp, bit_exact);
  #elif ARCH_X86
      ff_float_dsp_init_x86(fdsp);
 +#elif ARCH_MIPS
 +    ff_float_dsp_init_mips(fdsp);
  #endif
  }
diff --combined libavutil/float_dsp.h
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -51,6 -51,21 +51,21 @@@ typedef struct AVFloatDSPContext 
       */
      void (*vector_fmac_scalar)(float *dst, const float *src, float mul,
                                 int len);
+     /**
+      * Multiply a vector of floats by a scalar float.  Source and
+      * destination vectors must overlap exactly or not at all.
+      *
+      * @param dst result vector
+      *            constraints: 16-byte aligned
+      * @param src input vector
+      *            constraints: 16-byte aligned
+      * @param mul scalar value
+      * @param len length of vector
+      *            constraints: multiple of 4
+      */
+     void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
+                                int len);
  } AVFloatDSPContext;
  
  /**
@@@ -65,6 -80,5 +80,6 @@@ void avpriv_float_dsp_init(AVFloatDSPCo
  void ff_float_dsp_init_arm(AVFloatDSPContext *fdsp);
  void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int strict);
  void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp);
 +void ff_float_dsp_init_mips(AVFloatDSPContext *fdsp);
  
  #endif /* AVUTIL_FLOAT_DSP_H */