amrwbdec: set channels, channel_layout, and sample_rate

[ffmpeg] / libavcodec / adxenc.c

diff --git a/libavcodec/adxenc.c b/libavcodec/adxenc.c
index 12690d2ed081e10e1ae78998edf0ad4ba09a7a97..8a5053962694979ee51520530e967ff181ed4704 100644 (file)
--- a/libavcodec/adxenc.c
+++ b/libavcodec/adxenc.c
@@ -19,9 +19,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libavutil/intreadwrite.h"
 #include "avcodec.h"
 #include "adx.h"
+#include "bytestream.h"
+#include "internal.h"
 #include "put_bits.h"
 
 /**
@@ -42,7 +43,7 @@ static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
     int s0, s1, s2, d;
     int max = 0;
     int min = 0;
-    int data[32];
+    int data[BLOCK_SAMPLES];
 
     s1 = prev->s1;
     s2 = prev->s2;
@@ -61,7 +62,7 @@ static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
     prev->s2 = s2;
 
     if (max == 0 && min == 0) {
-        memset(adx, 0, 18);
+        memset(adx, 0, BLOCK_SIZE);
         return;
     }
 
@@ -76,25 +77,34 @@ static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav,
     AV_WB16(adx, scale);
 
     init_put_bits(&pb, adx + 2, 16);
-    for (i = 0; i < 32; i++)
+    for (i = 0; i < BLOCK_SAMPLES; i++)
         put_sbits(&pb, 4, av_clip(data[i] / scale, -8, 7));
     flush_put_bits(&pb);
 }
 
+#define HEADER_SIZE 36
+
 static int adx_encode_header(AVCodecContext *avctx, uint8_t *buf, int bufsize)
 {
     ADXContext *c = avctx->priv_data;
 
-    AV_WB32(buf + 0x00, 0x80000000 | 0x20);
-    AV_WB32(buf + 0x04, 0x03120400 | avctx->channels);
-    AV_WB32(buf + 0x08, avctx->sample_rate);
-    AV_WB32(buf + 0x0c, 0);
-    AV_WB16(buf + 0x10, c->cutoff);
-    AV_WB32(buf + 0x12, 0x03000000);
-    AV_WB32(buf + 0x16, 0x00000000);
-    AV_WB32(buf + 0x1a, 0x00000000);
-    memcpy (buf + 0x1e, "(c)CRI", 6);
-    return 0x20 + 4;
+    bytestream_put_be16(&buf, 0x8000);              /* header signature */
+    bytestream_put_be16(&buf, HEADER_SIZE - 4);     /* copyright offset */
+    bytestream_put_byte(&buf, 3);                   /* encoding */
+    bytestream_put_byte(&buf, BLOCK_SIZE);          /* block size */
+    bytestream_put_byte(&buf, 4);                   /* sample size */
+    bytestream_put_byte(&buf, avctx->channels);     /* channels */
+    bytestream_put_be32(&buf, avctx->sample_rate);  /* sample rate */
+    bytestream_put_be32(&buf, 0);                   /* total sample count */
+    bytestream_put_be16(&buf, c->cutoff);           /* cutoff frequency */
+    bytestream_put_byte(&buf, 3);                   /* version */
+    bytestream_put_byte(&buf, 0);                   /* flags */
+    bytestream_put_be32(&buf, 0);                   /* unknown */
+    bytestream_put_be32(&buf, 0);                   /* loop enabled */
+    bytestream_put_be16(&buf, 0);                   /* padding */
+    bytestream_put_buffer(&buf, "(c)CRI", 6);       /* copyright signature */
+
+    return HEADER_SIZE;
 }
 
 static av_cold int adx_encode_init(AVCodecContext *avctx)
@@ -105,9 +115,12 @@ static av_cold int adx_encode_init(AVCodecContext *avctx)
         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
         return AVERROR(EINVAL);
     }
-    avctx->frame_size = 32;
+    avctx->frame_size = BLOCK_SAMPLES;
 
-    avctx->coded_frame = avcodec_alloc_frame();
+#if FF_API_OLD_ENCODE_AUDIO
+    avcodec_get_frame_defaults(&c->frame);
+    avctx->coded_frame = &c->frame;
+#endif
 
     /* the cutoff can be adjusted, but this seems to work pretty well */
     c->cutoff = 500;
@@ -116,44 +129,47 @@ static av_cold int adx_encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static av_cold int adx_encode_close(AVCodecContext *avctx)
-{
-    av_freep(&avctx->coded_frame);
-    return 0;
-}
-
-static int adx_encode_frame(AVCodecContext *avctx, uint8_t *frame,
-                            int buf_size, void *data)
+static int adx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
+                            const AVFrame *frame, int *got_packet_ptr)
 {
     ADXContext *c          = avctx->priv_data;
-    const int16_t *samples = data;
-    uint8_t *dst           = frame;
+    const int16_t *samples = (const int16_t *)frame->data[0];
+    uint8_t *dst;
+    int ch, out_size, ret;
+
+    out_size = BLOCK_SIZE * avctx->channels + !c->header_parsed * HEADER_SIZE;
+    if ((ret = ff_alloc_packet(avpkt, out_size)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
+        return ret;
+    }
+    dst = avpkt->data;
 
     if (!c->header_parsed) {
-        int hdrsize = adx_encode_header(avctx, dst, buf_size);
-        dst += hdrsize;
+        int hdrsize;
+        if ((hdrsize = adx_encode_header(avctx, dst, avpkt->size)) < 0) {
+            av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
+            return AVERROR(EINVAL);
+        }
+        dst      += hdrsize;
         c->header_parsed = 1;
     }
 
-    if (avctx->channels == 1) {
-            adx_encode(c, dst, samples, c->prev, avctx->channels);
-            dst     += 18;
-    } else {
-            adx_encode(c, dst,      samples,     c->prev,     avctx->channels);
-            adx_encode(c, dst + 18, samples + 1, c->prev + 1, avctx->channels);
-            dst     += 18*2;
+    for (ch = 0; ch < avctx->channels; ch++) {
+        adx_encode(c, dst, samples + ch, &c->prev[ch], avctx->channels);
+        dst += BLOCK_SIZE;
     }
-    return dst - frame;
+
+    *got_packet_ptr = 1;
+    return 0;
 }
 
 AVCodec ff_adpcm_adx_encoder = {
     .name           = "adpcm_adx",
     .type           = AVMEDIA_TYPE_AUDIO,
-    .id             = CODEC_ID_ADPCM_ADX,
+    .id             = AV_CODEC_ID_ADPCM_ADX,
     .priv_data_size = sizeof(ADXContext),
     .init           = adx_encode_init,
-    .encode         = adx_encode_frame,
-    .close          = adx_encode_close,
+    .encode2        = adx_encode_frame,
     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
     .long_name      = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),