Merge commit 'bfcd4b6a1691d20aebc6d2308424c2a88334a9f0'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 2 Oct 2012 14:25:58 +0000 (16:25 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 2 Oct 2012 15:27:52 +0000 (17:27 +0200)
* commit 'bfcd4b6a1691d20aebc6d2308424c2a88334a9f0':
  adpcmdec: set AVCodec.sample_fmts
  twinvq: use planar sample format
  ralf: use planar sample format
  mpc7/8: use planar sample format
  iac/imc: use planar sample format
  dcadec: use float planar sample format
  cook: use planar sample format
  atrac3: use float planar sample format
  apedec: output in planar sample format
  8svx: use planar sample format

Conflicts:
libavcodec/8svx.c
libavcodec/dcadec.c
libavcodec/mpc7.c
libavcodec/mpc8.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
12 files changed:
1  2 
libavcodec/8svx.c
libavcodec/adpcm.c
libavcodec/apedec.c
libavcodec/atrac3.c
libavcodec/cook.c
libavcodec/dcadec.c
libavcodec/imc.c
libavcodec/mpc.c
libavcodec/mpc.h
libavcodec/mpc7.c
libavcodec/mpc8.c
libavcodec/twinvq.c

  /** decoder context */
  typedef struct EightSvxContext {
      AVFrame frame;
 -    uint8_t fib_acc[2];
      const int8_t *table;
  
 -    /* buffer used to store the whole first packet.
 -       data is only sent as one large packet */
 -    uint8_t *data[2];
 -    int data_size;
 -    int data_idx;
 +    /* buffer used to store the whole audio decoded/interleaved chunk,
 +     * which is sent with the first packet */
 +    uint8_t *samples;
 +    int64_t samples_size;
 +    int samples_idx;
  } EightSvxContext;
  
 -static const int8_t fibonacci[16]   = { -34, -21, -13,  -8, -5, -3, -2, -1,
 -                                          0,   1,   2,   3,  5,  8, 13, 21 };
 -static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1,
 -                                           0,   1,   2,   4,  8, 16, 32, 64 };
 +static const int8_t fibonacci[16]   = { -34,  -21, -13,  -8, -5, -3, -2, -1, 0, 1, 2, 3, 5, 8,  13, 21 };
 +static const int8_t exponential[16] = { -128, -64, -32, -16, -8, -4, -2, -1, 0, 1, 2, 4, 8, 16, 32, 64 };
  
 -#define MAX_FRAME_SIZE 32768
 +#define MAX_FRAME_SIZE 2048
  
  /**
-  * Interleave samples in buffer containing all left channel samples
-  * at the beginning, and right channel samples at the end.
-  * Each sample is assumed to be in signed 8-bit format.
-  *
-  * @param size the size in bytes of the dst and src buffer
-  */
- static void interleave_stereo(uint8_t *dst, const uint8_t *src, int size)
- {
-     uint8_t *dst_end = dst + size;
-     size = size>>1;
-     while (dst < dst_end) {
-         *dst++ = *src;
-         *dst++ = *(src+size);
-         src++;
-     }
- }
- /**
   * Delta decode the compressed values in src, and put the resulting
 - * decoded samples in dst.
 + * decoded samples in dst.
   *
 - * @param[in,out] state starting value. it is saved for use in the next call.
 + * @param val starting value assumed by the delta sequence
 + * @param table delta sequence table
 + * @return size in bytes of the decoded data, must be src_size*2
   */
 -static void delta_decode(uint8_t *dst, const uint8_t *src, int src_size,
 -                         uint8_t *state, const int8_t *table)
 +static int delta_decode(int8_t *dst, const uint8_t *src, int src_size,
 +                        int8_t val, const int8_t *table)
  {
 -    uint8_t val = *state;
 +    int n = src_size;
 +    int8_t *dst0 = dst;
  
 -    while (src_size--) {
 +    while (n--) {
          uint8_t d = *src++;
 -        val = av_clip_uint8(val + table[d & 0xF]);
 +        val = av_clip(val + table[d & 0x0f], -127, 128);
          *dst++ = val;
 -        val = av_clip_uint8(val + table[d >> 4]);
 +        val = av_clip(val + table[d >> 4]  , -127, 128);
          *dst++ = val;
      }
  
@@@ -107,56 -84,54 +88,54 @@@ static int eightsvx_decode_frame(AVCode
                                   int *got_frame_ptr, AVPacket *avpkt)
  {
      EightSvxContext *esc = avctx->priv_data;
-     int n, out_data_size, ret;
 -    int buf_size;
++    int n, out_data_size;
+     int ch, ret;
 -    int is_compr = (avctx->codec_id != AV_CODEC_ID_PCM_S8_PLANAR);
 -
 -    /* for the first packet, copy data to buffer */
 -    if (avpkt->data) {
 -        int hdr_size  = is_compr ? 2 : 0;
 -        int chan_size = (avpkt->size - hdr_size * avctx->channels) / avctx->channels;
 -
 -        if (avpkt->size < hdr_size * avctx->channels) {
 -            av_log(avctx, AV_LOG_ERROR, "packet size is too small\n");
 -            return AVERROR(EINVAL);
 -        }
 -        if (esc->data[0]) {
 -            av_log(avctx, AV_LOG_ERROR, "unexpected data after first packet\n");
 -            return AVERROR(EINVAL);
 +    uint8_t *src, *dst;
 +
 +    /* decode and interleave the first packet */
 +    if (!esc->samples && avpkt) {
 +        uint8_t *deinterleaved_samples, *p = NULL;
 +        int packet_size = avpkt->size;
 +
 +        if (packet_size % avctx->channels) {
 +            av_log(avctx, AV_LOG_WARNING, "Packet with odd size, ignoring last byte\n");
 +            if (packet_size < avctx->channels)
 +                return packet_size;
 +            packet_size -= packet_size % avctx->channels;
          }
 +        esc->samples_size = !esc->table ?
 +            packet_size : avctx->channels + (packet_size-avctx->channels) * 2;
 +        if (!(esc->samples = av_malloc(esc->samples_size)))
 +            return AVERROR(ENOMEM);
  
 -        if (is_compr) {
 -        esc->fib_acc[0] = avpkt->data[1] + 128;
 -        if (avctx->channels == 2)
 -            esc->fib_acc[1] = avpkt->data[2+chan_size+1] + 128;
 -        }
 +        /* decompress */
 +        if (esc->table) {
 +            const uint8_t *buf = avpkt->data;
 +            uint8_t *dst;
 +            int buf_size = avpkt->size;
 +            int i, n = esc->samples_size;
  
 -        esc->data_idx  = 0;
 -        esc->data_size = chan_size;
 -        if (!(esc->data[0] = av_malloc(chan_size)))
 -            return AVERROR(ENOMEM);
 -        if (avctx->channels == 2) {
 -            if (!(esc->data[1] = av_malloc(chan_size))) {
 -                av_freep(&esc->data[0]);
 +            if (buf_size < 2) {
 +                av_log(avctx, AV_LOG_ERROR, "packet size is too small\n");
 +                return AVERROR(EINVAL);
 +            }
 +            if (!(deinterleaved_samples = av_mallocz(n)))
                  return AVERROR(ENOMEM);
 +            dst = p = deinterleaved_samples;
 +
 +            /* the uncompressed starting value is contained in the first byte */
 +            dst = deinterleaved_samples;
 +            for (i = 0; i < avctx->channels; i++) {
 +                delta_decode(dst, buf + 1, buf_size / avctx->channels - 1, buf[0], esc->table);
 +                buf += buf_size / avctx->channels;
 +                dst += n / avctx->channels - 1;
              }
 +        } else {
 +            deinterleaved_samples = avpkt->data;
          }
 -        memcpy(esc->data[0], &avpkt->data[hdr_size], chan_size);
 -        if (avctx->channels == 2)
 -            memcpy(esc->data[1], &avpkt->data[2*hdr_size+chan_size], chan_size);
 -    }
 -    if (!esc->data[0]) {
 -        av_log(avctx, AV_LOG_ERROR, "unexpected empty packet\n");
 -        return AVERROR(EINVAL);
 -    }
  
-         if (avctx->channels == 2)
-             interleave_stereo(esc->samples, deinterleaved_samples, esc->samples_size);
-         else
-             memcpy(esc->samples, deinterleaved_samples, esc->samples_size);
 -    /* decode next piece of data from the buffer */
 -    buf_size = FFMIN(MAX_FRAME_SIZE, esc->data_size - esc->data_idx);
 -    if (buf_size <= 0) {
 -        *got_frame_ptr = 0;
 -        return avpkt->size;
++        memcpy(esc->samples, deinterleaved_samples, esc->samples_size);
 +        av_freep(&p);
      }
  
      /* get output buffer */
      *got_frame_ptr   = 1;
      *(AVFrame *)data = esc->frame;
  
-     dst = esc->frame.data[0];
-     src = esc->samples + esc->samples_idx;
-     out_data_size = esc->frame.nb_samples * avctx->channels;
-     for (n = out_data_size; n > 0; n--)
-         *dst++ = *src++ + 128;
 -    return avpkt->size;
++    out_data_size = esc->frame.nb_samples;
++    for (ch = 0; ch<avctx->channels; ch++) {
++        dst = esc->frame.data[ch];
++        src = esc->samples + esc->samples_idx / avctx->channels + ch * esc->samples_size / avctx->channels;
++        for (n = out_data_size; n > 0; n--)
++            *dst++ = *src++ + 128;
++    }
++    out_data_size *= avctx->channels;
 +    esc->samples_idx += out_data_size;
 +
 +    return esc->table ?
 +        (avctx->frame_number == 0)*2 + out_data_size / 2 :
 +        out_data_size;
  }
  
 -/** initialize 8svx decoder */
  static av_cold int eightsvx_decode_init(AVCodecContext *avctx)
  {
      EightSvxContext *esc = avctx->priv_data;
  
      if (avctx->channels < 1 || avctx->channels > 2) {
          av_log(avctx, AV_LOG_ERROR, "8SVX does not support more than 2 channels\n");
 -        return AVERROR(EINVAL);
 +        return AVERROR_INVALIDDATA;
      }
  
 -    switch(avctx->codec->id) {
 -        case AV_CODEC_ID_8SVX_FIB:
 -          esc->table = fibonacci;
 -          break;
 -        case AV_CODEC_ID_8SVX_EXP:
 -          esc->table = exponential;
 -          break;
 -        case AV_CODEC_ID_PCM_S8_PLANAR:
 -            break;
 -        default:
 -          return -1;
 +    switch (avctx->codec->id) {
 +    case AV_CODEC_ID_8SVX_FIB: esc->table = fibonacci;    break;
 +    case AV_CODEC_ID_8SVX_EXP: esc->table = exponential;  break;
 +    case AV_CODEC_ID_PCM_S8_PLANAR:
 +    case AV_CODEC_ID_8SVX_RAW: esc->table = NULL;         break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Invalid codec id %d.\n", avctx->codec->id);
 +        return AVERROR_INVALIDDATA;
      }
-     avctx->sample_fmt = AV_SAMPLE_FMT_U8;
+     avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
  
      avcodec_get_frame_defaults(&esc->frame);
      avctx->coded_frame = &esc->frame;
@@@ -226,26 -205,28 +208,30 @@@ AVCodec ff_eightsvx_fib_decoder = 
    .id             = AV_CODEC_ID_8SVX_FIB,
    .priv_data_size = sizeof (EightSvxContext),
    .init           = eightsvx_decode_init,
 -  .close          = eightsvx_decode_close,
    .decode         = eightsvx_decode_frame,
 -  .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
 +  .close          = eightsvx_decode_close,
 +  .capabilities   = CODEC_CAP_DR1,
    .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
+   .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+                                                     AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_EIGHTSVX_EXP_DECODER
  AVCodec ff_eightsvx_exp_decoder = {
    .name           = "8svx_exp",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_8SVX_EXP,
    .priv_data_size = sizeof (EightSvxContext),
    .init           = eightsvx_decode_init,
 -  .close          = eightsvx_decode_close,
    .decode         = eightsvx_decode_frame,
 -  .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
 +  .close          = eightsvx_decode_close,
 +  .capabilities   = CODEC_CAP_DR1,
    .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),
+   .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+                                                     AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_PCM_S8_PLANAR_DECODER
  AVCodec ff_pcm_s8_planar_decoder = {
      .name           = "pcm_s8_planar",
      .type           = AVMEDIA_TYPE_AUDIO,
      .init           = eightsvx_decode_init,
      .close          = eightsvx_decode_close,
      .decode         = eightsvx_decode_frame,
 -    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
 +    .capabilities   = CODEC_CAP_DR1,
      .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 8-bit planar"),
+     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
+                                                       AV_SAMPLE_FMT_NONE },
  };
 +#endif
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1454,8 -1290,8 +1452,8 @@@ static int dca_filter_channels(DCAConte
      if (s->output & DCA_LFE) {
          lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
                                s->lfe_data + 2 * s->lfe * (block_index + 4),
-                               &s->samples[256 * s->lfe_index],
-                               (1.0 / 256.0) * s->scale_bias);
 -                              s->samples_chanptr[dca_lfe_index[s->amode]],
++                              s->samples_chanptr[s->lfe_index],
+                               1.0 / (256.0 * 32768.0));
          /* Outputs 20bits pcm samples */
      }
  
@@@ -2067,22 -1654,11 +2065,20 @@@ static int dca_decode_frame(AVCodecCont
      int lfe_samples;
      int num_core_channels = 0;
      int i, ret;
-     float *samples_flt;
 -    float  **samples_flt;
++    float **samples_flt;
 +    float *src_chan;
 +    float *dst_chan;
-     int16_t *samples_s16;
      DCAContext *s = avctx->priv_data;
 -    int channels;
      int core_ss_end;
 -
 +    int channels;
 +    float scale;
 +    int achan;
 +    int chset;
 +    int mask;
 +    int lavc;
 +    int posn;
 +    int j, k;
-     int ch;
 +    int endch;
  
      s->xch_present = 0;
  
              s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
              s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
          }
-                         src_chan = s->samples + s->channel_order_tab[j] * 256;
 +
 +        /* If stream contains XXCH, we might need to undo an embedded downmix */
 +        if (s->xxch_dmix_embedded) {
 +            /* Loop over channel sets in turn */
 +            ch = num_core_channels;
 +            for (chset = 0; chset < s->xxch_chset; chset++) {
 +                endch = ch + s->xxch_chset_nch[chset];
 +                mask = s->xxch_dmix_embedded;
 +
 +                /* undo downmix */
 +                for (j = ch; j < endch; j++) {
 +                    if (mask & (1 << j)) { /* this channel has been mixed-out */
-                                 dst_chan = s->samples + achan * 256;
++                        src_chan = s->samples_chanptr[s->channel_order_tab[j]];
 +                        for (k = 0; k < endch; k++) {
 +                            achan = s->channel_order_tab[k];
 +                            scale = s->xxch_dmix_coeff[j][k];
 +                            if (scale != 0.0) {
-                         src_chan = s->samples + s->channel_order_tab[j] * 256;
++                                dst_chan = s->samples_chanptr[achan];
 +                                s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
 +                                                           -scale, 256);
 +                            }
 +                        }
 +                    }
 +                }
 +
 +                /* if a downmix has been embedded then undo the pre-scaling */
 +                if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
 +                    scale = s->xxch_dmix_sf[chset];
 +
 +                    for (j = 0; j < ch; j++) {
-                         src_chan = s->samples + s->lfe_index * 256;
++                        src_chan = s->samples_chanptr[s->channel_order_tab[j]];
 +                        for (k = 0; k < 256; k++)
 +                            src_chan[k] *= scale;
 +                    }
 +
 +                    /* LFE channel is always part of core, scale if it exists */
 +                    if (s->lfe) {
-         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
-             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
-                                          channels);
-             samples_flt += 256 * channels;
-         } else {
-             s->fmt_conv.float_to_int16_interleave(samples_s16,
-                                                   s->samples_chanptr, 256,
-                                                   channels);
-             samples_s16 += 256 * channels;
-         }
++                        src_chan = s->samples_chanptr[s->lfe_index];
 +                        for (k = 0; k < 256; k++)
 +                            src_chan[k] *= scale;
 +                    }
 +                }
 +
 +                ch = endch;
 +            }
 +
 +        }
      }
  
      /* update lfe history */
@@@ -996,9 -987,10 +988,11 @@@ AVCodec ff_imc_decoder = 
      .decode         = imc_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
      .long_name      = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
+     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+                                                       AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_IAC_DECODER
  AVCodec ff_iac_decoder = {
      .name           = "iac",
      .type           = AVMEDIA_TYPE_AUDIO,
      .decode         = imc_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
      .long_name      = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
+     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+                                                       AV_SAMPLE_FMT_NONE },
  };
 +#endif
Simple merge
Simple merge
@@@ -90,12 -94,9 +90,12 @@@ static av_cold int mpc7_decode_init(AVC
              c->IS, c->MSS, c->gapless, c->lastframelen, c->maxbands);
      c->frames_to_skip = 0;
  
-     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+     avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
      avctx->channel_layout = AV_CH_LAYOUT_STEREO;
  
 +    avcodec_get_frame_defaults(&c->frame);
 +    avctx->coded_frame = &c->frame;
 +
      if(vlc_initialized) return 0;
      av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
      scfi_vlc.table = scfi_table;
@@@ -293,9 -293,7 +293,9 @@@ static int mpc7_decode_frame(AVCodecCon
          for(ch = 0; ch < 2; ch++)
              idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off);
  
-     ff_mpc_dequantize_and_synth(c, mb, c->frame.data[0], 2);
+     ff_mpc_dequantize_and_synth(c, mb, (int16_t **)c->frame.extended_data, 2);
 +    if(last_frame)
 +        c->frame.nb_samples = c->lastframelen;
  
      bits_used = get_bits_count(&gb);
      bits_avail = buf_size * 8;
@@@ -139,12 -135,8 +139,12 @@@ static av_cold int mpc8_decode_init(AVC
      c->MSS = get_bits1(&gb);
      c->frames = 1 << (get_bits(&gb, 3) * 2);
  
-     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+     avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
 -    avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 +    avctx->channel_layout = (channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
 +    avctx->channels = channels;
 +
 +    avcodec_get_frame_defaults(&c->frame);
 +    avctx->coded_frame = &c->frame;
  
      if(vlc_initialized) return 0;
      av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
Simple merge