Merge commit '5a4e9fe855282a99586050a507d0a486ad39df5b'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 6 Mar 2013 22:56:07 +0000 (23:56 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 6 Mar 2013 23:01:32 +0000 (00:01 +0100)
* commit '5a4e9fe855282a99586050a507d0a486ad39df5b':
  avcodec/internal: Fix #if DECODE_AUDIO / ENCODE_AUDIO name mismatch
  shorten: use the unsigned type where needed

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/internal.h
libavcodec/shorten.c

diff --combined libavcodec/internal.h
index 14f7918dbda6785e7cfcf6275bb58dbd9feca19c,05efbfc15a4b6aca606e2d669eba3d31a382547f..af9e58eead317030ad021b34cb62bbfd53684626
@@@ -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
   */
  
@@@ -62,7 -62,7 +62,7 @@@ typedef struct AVCodecInternal 
       */
      int is_copy;
  
- #if FF_API_OLD_DECODE_AUDIO
+ #if FF_API_OLD_ENCODE_AUDIO
      /**
       * Internal sample count used by avcodec_encode_audio() to fabricate pts.
       * Can be removed along with avcodec_encode_audio().
       * Stored here so we can free it.
       */
      uint8_t *audio_data;
 +
 +    /**
 +     * temporary buffer used for encoders to store their bitstream
 +     */
 +    uint8_t *byte_buffer;
 +    unsigned int byte_buffer_size;
 +
 +    void *frame_thread_encoder;
 +
 +    /**
 +     * Number of audio samples to skip at the start of the next decoded frame
 +     */
 +    int skip_samples;
  } AVCodecInternal;
  
  struct AVCodecDefault {
@@@ -119,23 -106,6 +119,23 @@@ int ff_match_2uint16(const uint16_t (*t
  
  unsigned int avpriv_toupper4(unsigned int x);
  
 +/**
 + * does needed setup of pkt_pts/pos and such for (re)get_buffer();
 + */
 +void ff_init_buffer_info(AVCodecContext *s, AVFrame *frame);
 +
 +
 +void avpriv_color_frame(AVFrame *frame, const int color[4]);
 +
 +/**
 + * Remove and free all side data from packet.
 + */
 +void ff_packet_free_side_data(AVPacket *pkt);
 +
 +extern volatile int ff_avcodec_locked;
 +int ff_lock_avcodec(AVCodecContext *log_ctx);
 +int ff_unlock_avcodec(void);
 +
  int avpriv_lock_avformat(void);
  int avpriv_unlock_avformat(void);
  
   * ensure the output packet data is large enough, whether provided by the user
   * or allocated in this function.
   *
 + * @param avctx   the AVCodecContext of the encoder
   * @param avpkt   the AVPacket
   *                If avpkt->data is already set, avpkt->size is checked
   *                to ensure it is large enough.
   * @param size    the minimum required packet size
   * @return        0 on success, negative error code on failure
   */
 +int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size);
 +
  int ff_alloc_packet(AVPacket *avpkt, int size);
  
  /**
  static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx,
                                                          int64_t samples)
  {
 +    if(samples == AV_NOPTS_VALUE)
 +        return AV_NOPTS_VALUE;
      return av_rescale_q(samples, (AVRational){ 1, avctx->sample_rate },
                          avctx->time_base);
  }
   */
  int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame);
  
 +int ff_thread_can_start_frame(AVCodecContext *avctx);
 +
 +int ff_get_logical_cpus(AVCodecContext *avctx);
 +
 +int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx);
 +
 +void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
 +                         uint8_t *visualization_buffer[3], int *low_delay,
 +                         int mb_width, int mb_height, int mb_stride, int quarter_sample);
 +
 +/**
 + * Call avcodec_open2 recursively by decrementing counter, unlocking mutex,
 + * calling the function and then restoring again. Assumes the mutex is
 + * already locked
 + */
 +int ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
 +
 +/**
 + * Call avcodec_close recursively, counterpart to avcodec_open2_recursive.
 + */
 +int ff_codec_close_recursive(AVCodecContext *avctx);
 +
 +/**
 + * Finalize buf into extradata and set its size appropriately.
 + */
 +int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf);
 +
 +AVDictionary **ff_frame_get_metadatap(AVFrame *frame);
 +
  #endif /* AVCODEC_INTERNAL_H */
diff --combined libavcodec/shorten.c
index 82cc06cf1c068884719c9bf65f99137948ba5572,d6c9386c8aae882497c7c399a5a924abd14d0e44..3a6d6340122a7313d365cc2dfe73f3710e4b8868
@@@ -2,20 -2,20 +2,20 @@@
   * Shorten decoder
   * Copyright (c) 2005 Jeff Muizelaar
   *
 - * 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
   */
  
  #define ENERGYSIZE 3
  #define BITSHIFTSIZE 2
  
 +#define TYPE_S8    1
 +#define TYPE_U8    2
  #define TYPE_S16HL 3
 +#define TYPE_U16HL 4
  #define TYPE_S16LH 5
 +#define TYPE_U16LH 6
  
  #define NWRAP 3
  #define NSKIPSIZE 1
@@@ -87,7 -83,7 +87,7 @@@ typedef struct ShortenContext 
      GetBitContext gb;
  
      int min_framesize, max_framesize;
-     int channels;
+     unsigned channels;
  
      int32_t *decoded[MAX_CHANNELS];
      int32_t *decoded_base[MAX_CHANNELS];
@@@ -116,6 -112,7 +116,6 @@@ static av_cold int shorten_decode_init(
  {
      ShortenContext *s = avctx->priv_data;
      s->avctx          = avctx;
 -    avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  
      return 0;
  }
@@@ -185,17 -182,13 +185,17 @@@ static int init_offset(ShortenContext *
      int nblock = FFMAX(1, s->nmean);
      /* initialise offset */
      switch (s->internal_ftype) {
 +    case TYPE_U8:
 +        s->avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
 +        mean = 0x80;
 +        break;
      case TYPE_S16HL:
      case TYPE_S16LH:
 -        mean = 0;
 +        s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
          break;
      default:
 -        av_log(s->avctx, AV_LOG_ERROR, "unknown audio type");
 -        return AVERROR_INVALIDDATA;
 +        av_log(s->avctx, AV_LOG_ERROR, "unknown audio type\n");
 +        return AVERROR_PATCHWELCOME;
      }
  
      for (chan = 0; chan < s->channels; chan++)
  static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
                                int header_size)
  {
 -    int len;
 +    int len, bps;
      short wave_format;
 +    const uint8_t *end= header + header_size;
  
      if (bytestream_get_le32(&header) != MKTAG('R', 'I', 'F', 'F')) {
          av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
  
      while (bytestream_get_le32(&header) != MKTAG('f', 'm', 't', ' ')) {
          len     = bytestream_get_le32(&header);
 +        if (len<0 || end - header - 8 < len)
 +            return AVERROR_INVALIDDATA;
          header += len;
      }
      len = bytestream_get_le32(&header);
      avctx->sample_rate = bytestream_get_le32(&header);
      header += 4;        // skip bit rate    (represents original uncompressed bit rate)
      header += 2;        // skip block align (not needed)
 -    avctx->bits_per_coded_sample = bytestream_get_le16(&header);
 +    bps     = bytestream_get_le16(&header);
 +    avctx->bits_per_coded_sample = bps;
  
 -    if (avctx->bits_per_coded_sample != 16) {
 -        av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample\n");
 +    if (bps != 16 && bps != 8) {
 +        av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps);
          return AVERROR(ENOSYS);
      }
  
      return 0;
  }
  
 -static void output_buffer(int16_t **samples, int nchan, int blocksize,
 -                          int32_t **buffer)
 -{
 -    int i, ch;
 -    for (ch = 0; ch < nchan; ch++) {
 -        int32_t *in  = buffer[ch];
 -        int16_t *out = samples[ch];
 -        for (i = 0; i < blocksize; i++)
 -            out[i] = av_clip_int16(in[i]);
 -    }
 -}
 -
  static const int fixed_coeffs[3][3] = {
      { 1,  0,  0 },
      { 2, -1,  0 },
@@@ -338,7 -339,11 +338,11 @@@ static int read_header(ShortenContext *
      s->internal_ftype = get_uint(s, TYPESIZE);
  
      s->channels = get_uint(s, CHANSIZE);
-     if (s->channels <= 0 || s->channels > MAX_CHANNELS) {
+     if (!s->channels) {
+         av_log(s->avctx, AV_LOG_ERROR, "No channels reported\n");
+         return AVERROR_INVALIDDATA;
+     }
+     if (s->channels > MAX_CHANNELS) {
          av_log(s->avctx, AV_LOG_ERROR, "too many channels: %d\n", s->channels);
          s->channels = 0;
          return AVERROR_INVALIDDATA;
  
      /* get blocksize if version > 0 */
      if (s->version > 0) {
-         int skip_bytes, blocksize;
+         int skip_bytes;
+         unsigned blocksize;
  
          blocksize = get_uint(s, av_log2(DEFAULT_BLOCK_SIZE));
-         if (!blocksize || blocksize > (unsigned)MAX_BLOCKSIZE) {
+         if (!blocksize || blocksize > MAX_BLOCKSIZE) {
              av_log(s->avctx, AV_LOG_ERROR,
                     "invalid or unsupported block size: %d\n",
                     blocksize);
@@@ -417,7 -423,7 +422,7 @@@ static int shorten_decode_frame(AVCodec
      /* allocate internal bitstream buffer */
      if (s->max_framesize == 0) {
          void *tmp_ptr;
 -        s->max_framesize = 1024; // should hopefully be enough for the first header
 +        s->max_framesize = 8192; // should hopefully be enough for the first header
          tmp_ptr = av_fast_realloc(s->bitstream, &s->allocated_bitstream_size,
                                    s->max_framesize);
          if (!tmp_ptr) {
                  s->bitshift = get_ur_golomb_shorten(&s->gb, BITSHIFTSIZE);
                  break;
              case FN_BLOCKSIZE: {
-                 int blocksize = get_uint(s, av_log2(s->blocksize));
+                 unsigned blocksize = get_uint(s, av_log2(s->blocksize));
                  if (blocksize > s->blocksize) {
                      av_log(avctx, AV_LOG_ERROR,
                             "Increasing block size is not supported\n");
                      return AVERROR_PATCHWELCOME;
                  }
-                 if (!blocksize || blocksize > (unsigned)MAX_BLOCKSIZE) {
+                 if (!blocksize || blocksize > MAX_BLOCKSIZE) {
                      av_log(avctx, AV_LOG_ERROR, "invalid or unsupported "
                                                  "block size: %d\n", blocksize);
                      return AVERROR(EINVAL);
                      sum += s->offset[channel][i];
                  coffset = sum / s->nmean;
                  if (s->version >= 2)
 -                    coffset >>= FFMIN(1, s->bitshift);
 +                    coffset = s->bitshift == 0 ? coffset : coffset >> s->bitshift - 1 >> 1;
              }
  
              /* decode samples for this channel */
              /* if this is the last channel in the block, output the samples */
              s->cur_chan++;
              if (s->cur_chan == s->channels) {
 +                uint8_t *samples_u8;
 +                int16_t *samples_s16;
 +                int chan;
 +
                  /* get output buffer */
                  frame->nb_samples = s->blocksize;
                  if ((ret = ff_get_buffer(avctx, frame)) < 0) {
                      av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
                      return ret;
                  }
 -                /* interleave output */
 -                output_buffer((int16_t **)frame->extended_data, s->channels,
 -                              s->blocksize, s->decoded);
 +
 +                for (chan = 0; chan < s->channels; chan++) {
 +                    samples_u8  = ((uint8_t **)frame->extended_data)[chan];
 +                    samples_s16 = ((int16_t **)frame->extended_data)[chan];
 +                    for (i = 0; i < s->blocksize; i++) {
 +                        switch (s->internal_ftype) {
 +                        case TYPE_U8:
 +                            *samples_u8++ = av_clip_uint8(s->decoded[chan][i]);
 +                            break;
 +                        case TYPE_S16HL:
 +                        case TYPE_S16LH:
 +                            *samples_s16++ = av_clip_int16(s->decoded[chan][i]);
 +                            break;
 +                        }
 +                    }
 +                }
  
                  *got_frame_ptr = 1;
              }
@@@ -663,6 -652,5 +668,6 @@@ AVCodec ff_shorten_decoder = 
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
      .long_name      = NULL_IF_CONFIG_SMALL("Shorten"),
      .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
 +                                                      AV_SAMPLE_FMT_U8P,
                                                        AV_SAMPLE_FMT_NONE },
  };