yading@10: /*
yading@10:  * Wavesynth pseudo-codec
yading@10:  * Copyright (c) 2011 Nicolas George
yading@10:  *
yading@10:  * This file is part of FFmpeg.
yading@10:  *
yading@10:  * FFmpeg is free software; you can redistribute it and/or
yading@10:  * modify it under the terms of the GNU Lesser General Public
yading@10:  * License as published by the Free Software Foundation; either
yading@10:  * version 2.1 of the License, or (at your option) any later version.
yading@10:  *
yading@10:  * FFmpeg is distributed in the hope that it will be useful,
yading@10:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
yading@10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
yading@10:  * Lesser General Public License for more details.
yading@10:  *
yading@10:  * You should have received a copy of the GNU Lesser General Public
yading@10:  * License along with FFmpeg; if not, write to the Free Software
yading@10:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
yading@10:  */
yading@10: 
yading@10: #include "libavutil/intreadwrite.h"
yading@10: #include "libavutil/log.h"
yading@10: #include "avcodec.h"
yading@10: #include "internal.h"
yading@10: 
yading@10: 
yading@10: #define SIN_BITS 14
yading@10: #define WS_MAX_CHANNELS 32
yading@10: #define INF_TS 0x7FFFFFFFFFFFFFFF
yading@10: 
yading@10: #define PINK_UNIT 128
yading@10: 
yading@10: /*
yading@10:    Format of the extradata and packets
yading@10: 
yading@10:    THIS INFORMATION IS NOT PART OF THE PUBLIC API OR ABI.
yading@10:    IT CAN CHANGE WITHOUT NOTIFICATION.
yading@10: 
yading@10:    All numbers are in little endian.
yading@10: 
yading@10:    The codec extradata define a set of intervals with uniform content.
yading@10:    Overlapping intervals are added together.
yading@10: 
yading@10:    extradata:
yading@10:        uint32      number of intervals
yading@10:        ...         intervals
yading@10: 
yading@10:    interval:
yading@10:        int64       start timestamp; time_base must be 1/sample_rate;
yading@10:                    start timestamps must be in ascending order
yading@10:        int64       end timestamp
yading@10:        uint32      type
yading@10:        uint32      channels mask
yading@10:        ...         additional information, depends on type
yading@10: 
yading@10:    sine interval (type fourcc "SINE"):
yading@10:        int32       start frequency, in 1/(1<<16) Hz
yading@10:        int32       end frequency
yading@10:        int32       start amplitude, 1<<16 is the full amplitude
yading@10:        int32       end amplitude
yading@10:        uint32      start phase, 0 is sin(0), 0x20000000 is sin(pi/2), etc.;
yading@10:                    n | (1<<31) means to match the phase of previous channel #n
yading@10: 
yading@10:    pink noise interval (type fourcc "NOIS"):
yading@10:        int32       start amplitude
yading@10:        int32       end amplitude
yading@10: 
yading@10:    The input packets encode the time and duration of the requested segment.
yading@10: 
yading@10:    packet:
yading@10:        int64       start timestamp
yading@10:        int32       duration
yading@10: 
yading@10: */
yading@10: 
yading@10: enum ws_interval_type {
yading@10:     WS_SINE  = MKTAG('S','I','N','E'),
yading@10:     WS_NOISE = MKTAG('N','O','I','S'),
yading@10: };
yading@10: 
yading@10: struct ws_interval {
yading@10:     int64_t ts_start, ts_end;
yading@10:     uint64_t phi0, dphi0, ddphi;
yading@10:     uint64_t amp0, damp;
yading@10:     uint64_t phi, dphi, amp;
yading@10:     uint32_t channels;
yading@10:     enum ws_interval_type type;
yading@10:     int next;
yading@10: };
yading@10: 
yading@10: struct wavesynth_context {
yading@10:     int64_t cur_ts;
yading@10:     int64_t next_ts;
yading@10:     int32_t *sin;
yading@10:     AVFrame frame;
yading@10:     struct ws_interval *inter;
yading@10:     uint32_t dither_state;
yading@10:     uint32_t pink_state;
yading@10:     int32_t pink_pool[PINK_UNIT];
yading@10:     unsigned pink_need, pink_pos;
yading@10:     int nb_inter;
yading@10:     int cur_inter;
yading@10:     int next_inter;
yading@10: };
yading@10: 
yading@10: #define LCG_A 1284865837
yading@10: #define LCG_C 4150755663
yading@10: #define LCG_AI 849225893 /* A*AI = 1 [mod 1<<32] */
yading@10: 
yading@10: static uint32_t lcg_next(uint32_t *s)
yading@10: {
yading@10:     *s = *s * LCG_A + LCG_C;
yading@10:     return *s;
yading@10: }
yading@10: 
yading@10: static void lcg_seek(uint32_t *s, int64_t dt)
yading@10: {
yading@10:     uint32_t a, c, t = *s;
yading@10: 
yading@10:     if (dt >= 0) {
yading@10:         a = LCG_A;
yading@10:         c = LCG_C;
yading@10:     } else { /* coefficients for a step backward */
yading@10:         a = LCG_AI;
yading@10:         c = (uint32_t)(LCG_AI * LCG_C);
yading@10:         dt = -dt;
yading@10:     }
yading@10:     while (dt) {
yading@10:         if (dt & 1)
yading@10:             t = a * t + c;
yading@10:         c *= a + 1; /* coefficients for a double step */
yading@10:         a *= a;
yading@10:         dt >>= 1;
yading@10:     }
yading@10:     *s = t;
yading@10: }
yading@10: 
yading@10: /* Emulate pink noise by summing white noise at the sampling frequency,
yading@10:  * white noise at half the sampling frequency (each value taken twice),
yading@10:  * etc., with a total of 8 octaves.
yading@10:  * This is known as the Voss-McCartney algorithm. */
yading@10: 
yading@10: static void pink_fill(struct wavesynth_context *ws)
yading@10: {
yading@10:     int32_t vt[7] = { 0 }, v = 0;
yading@10:     int i, j;
yading@10: 
yading@10:     ws->pink_pos = 0;
yading@10:     if (!ws->pink_need)
yading@10:         return;
yading@10:     for (i = 0; i < PINK_UNIT; i++) {
yading@10:         for (j = 0; j < 7; j++) {
yading@10:             if ((i >> j) & 1)
yading@10:                 break;
yading@10:             v -= vt[j];
yading@10:             vt[j] = (int32_t)lcg_next(&ws->pink_state) >> 3;
yading@10:             v += vt[j];
yading@10:         }
yading@10:         ws->pink_pool[i] = v + ((int32_t)lcg_next(&ws->pink_state) >> 3);
yading@10:     }
yading@10:     lcg_next(&ws->pink_state); /* so we use exactly 256 steps */
yading@10: }
yading@10: 
yading@10: /**
yading@10:  * @return  (1<<64) * a / b, without overflow, if a < b
yading@10:  */
yading@10: static uint64_t frac64(uint64_t a, uint64_t b)
yading@10: {
yading@10:     uint64_t r = 0;
yading@10:     int i;
yading@10: 
yading@10:     if (b < (uint64_t)1 << 32) { /* b small, use two 32-bits steps */
yading@10:         a <<= 32;
yading@10:         return ((a / b) << 32) | ((a % b) << 32) / b;
yading@10:     }
yading@10:     if (b < (uint64_t)1 << 48) { /* b medium, use four 16-bits steps */
yading@10:         for (i = 0; i < 4; i++) {
yading@10:             a <<= 16;
yading@10:             r = (r << 16) | (a / b);
yading@10:             a %= b;
yading@10:         }
yading@10:         return r;
yading@10:     }
yading@10:     for (i = 63; i >= 0; i--) {
yading@10:         if (a >= (uint64_t)1 << 63 || a << 1 >= b) {
yading@10:             r |= (uint64_t)1 << i;
yading@10:             a = (a << 1) - b;
yading@10:         } else {
yading@10:             a <<= 1;
yading@10:         }
yading@10:     }
yading@10:     return r;
yading@10: }
yading@10: 
yading@10: static uint64_t phi_at(struct ws_interval *in, int64_t ts)
yading@10: {
yading@10:     uint64_t dt = ts - in->ts_start;
yading@10:     uint64_t dt2 = dt & 1 ? /* dt * (dt - 1) / 2 without overflow */
yading@10:                    dt * ((dt - 1) >> 1) : (dt >> 1) * (dt - 1);
yading@10:     return in->phi0 + dt * in->dphi0 + dt2 * in->ddphi;
yading@10: }
yading@10: 
yading@10: static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
yading@10: {
yading@10:     int *last, i;
yading@10:     struct ws_interval *in;
yading@10: 
yading@10:     last = &ws->cur_inter;
yading@10:     for (i = 0; i < ws->nb_inter; i++) {
yading@10:         in = &ws->inter[i];
yading@10:         if (ts < in->ts_start)
yading@10:             break;
yading@10:         if (ts >= in->ts_end)
yading@10:             continue;
yading@10:         *last = i;
yading@10:         last = &in->next;
yading@10:         in->phi  = phi_at(in, ts);
yading@10:         in->dphi = in->dphi0 + (ts - in->ts_start) * in->ddphi;
yading@10:         in->amp  = in->amp0  + (ts - in->ts_start) * in->damp;
yading@10:     }
yading@10:     ws->next_inter = i;
yading@10:     ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
yading@10:     *last = -1;
yading@10:     lcg_seek(&ws->dither_state, ts - ws->cur_ts);
yading@10:     if (ws->pink_need) {
yading@10:         int64_t pink_ts_cur  = (ws->cur_ts + PINK_UNIT - 1) & ~(PINK_UNIT - 1);
yading@10:         int64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
yading@10:         int pos = ts & (PINK_UNIT - 1);
yading@10:         lcg_seek(&ws->pink_state, (pink_ts_next - pink_ts_cur) << 1);
yading@10:         if (pos) {
yading@10:             pink_fill(ws);
yading@10:             ws->pink_pos = pos;
yading@10:         } else {
yading@10:             ws->pink_pos = PINK_UNIT;
yading@10:         }
yading@10:     }
yading@10:     ws->cur_ts = ts;
yading@10: }
yading@10: 
yading@10: static int wavesynth_parse_extradata(AVCodecContext *avc)
yading@10: {
yading@10:     struct wavesynth_context *ws = avc->priv_data;
yading@10:     struct ws_interval *in;
yading@10:     uint8_t *edata, *edata_end;
yading@10:     int32_t f1, f2, a1, a2;
yading@10:     uint32_t phi;
yading@10:     int64_t dphi1, dphi2, dt, cur_ts = -0x8000000000000000;
yading@10:     int i;
yading@10: 
yading@10:     if (avc->extradata_size < 4)
yading@10:         return AVERROR(EINVAL);
yading@10:     edata = avc->extradata;
yading@10:     edata_end = edata + avc->extradata_size;
yading@10:     ws->nb_inter = AV_RL32(edata);
yading@10:     edata += 4;
yading@10:     if (ws->nb_inter < 0)
yading@10:         return AVERROR(EINVAL);
yading@10:     ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
yading@10:     if (!ws->inter)
yading@10:         return AVERROR(ENOMEM);
yading@10:     for (i = 0; i < ws->nb_inter; i++) {
yading@10:         in = &ws->inter[i];
yading@10:         if (edata_end - edata < 24)
yading@10:             return AVERROR(EINVAL);
yading@10:         in->ts_start = AV_RL64(edata +  0);
yading@10:         in->ts_end   = AV_RL64(edata +  8);
yading@10:         in->type     = AV_RL32(edata + 16);
yading@10:         in->channels = AV_RL32(edata + 20);
yading@10:         edata += 24;
yading@10:         if (in->ts_start < cur_ts || in->ts_end <= in->ts_start)
yading@10:             return AVERROR(EINVAL);
yading@10:         cur_ts = in->ts_start;
yading@10:         dt = in->ts_end - in->ts_start;
yading@10:         switch (in->type) {
yading@10:             case WS_SINE:
yading@10:                 if (edata_end - edata < 20)
yading@10:                     return AVERROR(EINVAL);
yading@10:                 f1  = AV_RL32(edata +  0);
yading@10:                 f2  = AV_RL32(edata +  4);
yading@10:                 a1  = AV_RL32(edata +  8);
yading@10:                 a2  = AV_RL32(edata + 12);
yading@10:                 phi = AV_RL32(edata + 16);
yading@10:                 edata += 20;
yading@10:                 dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
yading@10:                 dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
yading@10:                 in->dphi0 = dphi1;
yading@10:                 in->ddphi = (dphi2 - dphi1) / dt;
yading@10:                 if (phi & 0x80000000) {
yading@10:                     phi &= ~0x80000000;
yading@10:                     if (phi >= i)
yading@10:                         return AVERROR(EINVAL);
yading@10:                     in->phi0 = phi_at(&ws->inter[phi], in->ts_start);
yading@10:                 } else {
yading@10:                     in->phi0 = (uint64_t)phi << 33;
yading@10:                 }
yading@10:                 break;
yading@10:             case WS_NOISE:
yading@10:                 if (edata_end - edata < 8)
yading@10:                     return AVERROR(EINVAL);
yading@10:                 a1  = AV_RL32(edata +  0);
yading@10:                 a2  = AV_RL32(edata +  4);
yading@10:                 edata += 8;
yading@10:                 break;
yading@10:             default:
yading@10:                 return AVERROR(EINVAL);
yading@10:         }
yading@10:         in->amp0 = (int64_t)a1 << 32;
yading@10:         in->damp = (((int64_t)a2 << 32) - ((int64_t)a1 << 32)) / dt;
yading@10:     }
yading@10:     if (edata != edata_end)
yading@10:         return AVERROR(EINVAL);
yading@10:     return 0;
yading@10: }
yading@10: 
yading@10: static av_cold int wavesynth_init(AVCodecContext *avc)
yading@10: {
yading@10:     struct wavesynth_context *ws = avc->priv_data;
yading@10:     int i, r;
yading@10: 
yading@10:     if (avc->channels > WS_MAX_CHANNELS) {
yading@10:         av_log(avc, AV_LOG_ERROR,
yading@10:                "This implementation is limited to %d channels.\n",
yading@10:                WS_MAX_CHANNELS);
yading@10:         return AVERROR(EINVAL);
yading@10:     }
yading@10:     r = wavesynth_parse_extradata(avc);
yading@10:     if (r < 0) {
yading@10:         av_log(avc, AV_LOG_ERROR, "Invalid intervals definitions.\n");
yading@10:         goto fail;
yading@10:     }
yading@10:     ws->sin = av_malloc(sizeof(*ws->sin) << SIN_BITS);
yading@10:     if (!ws->sin) {
yading@10:         r = AVERROR(ENOMEM);
yading@10:         goto fail;
yading@10:     }
yading@10:     for (i = 0; i < 1 << SIN_BITS; i++)
yading@10:         ws->sin[i] = floor(32767 * sin(2 * M_PI * i / (1 << SIN_BITS)));
yading@10:     ws->dither_state = MKTAG('D','I','T','H');
yading@10:     for (i = 0; i < ws->nb_inter; i++)
yading@10:         ws->pink_need += ws->inter[i].type == WS_NOISE;
yading@10:     ws->pink_state = MKTAG('P','I','N','K');
yading@10:     ws->pink_pos = PINK_UNIT;
yading@10:     avcodec_get_frame_defaults(&ws->frame);
yading@10:     avc->coded_frame = &ws->frame;
yading@10:     wavesynth_seek(ws, 0);
yading@10:     avc->sample_fmt = AV_SAMPLE_FMT_S16;
yading@10:     return 0;
yading@10: 
yading@10: fail:
yading@10:     av_free(ws->inter);
yading@10:     av_free(ws->sin);
yading@10:     return r;
yading@10: }
yading@10: 
yading@10: static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
yading@10:                                    int32_t *channels)
yading@10: {
yading@10:     int32_t amp, val, *cv;
yading@10:     struct ws_interval *in;
yading@10:     int i, *last, pink;
yading@10:     uint32_t c, all_ch = 0;
yading@10: 
yading@10:     i = ws->cur_inter;
yading@10:     last = &ws->cur_inter;
yading@10:     if (ws->pink_pos == PINK_UNIT)
yading@10:         pink_fill(ws);
yading@10:     pink = ws->pink_pool[ws->pink_pos++] >> 16;
yading@10:     while (i >= 0) {
yading@10:         in = &ws->inter[i];
yading@10:         i = in->next;
yading@10:         if (ts >= in->ts_end) {
yading@10:             *last = i;
yading@10:             continue;
yading@10:         }
yading@10:         last = &in->next;
yading@10:         amp = in->amp >> 32;
yading@10:         in->amp  += in->damp;
yading@10:         switch (in->type) {
yading@10:             case WS_SINE:
yading@10:                 val = amp * ws->sin[in->phi >> (64 - SIN_BITS)];
yading@10:                 in->phi  += in->dphi;
yading@10:                 in->dphi += in->ddphi;
yading@10:                 break;
yading@10:             case WS_NOISE:
yading@10:                 val = amp * pink;
yading@10:                 break;
yading@10:             default:
yading@10:                 val = 0;
yading@10:         }
yading@10:         all_ch |= in->channels;
yading@10:         for (c = in->channels, cv = channels; c; c >>= 1, cv++)
yading@10:             if (c & 1)
yading@10:                 *cv += val;
yading@10:     }
yading@10:     val = (int32_t)lcg_next(&ws->dither_state) >> 16;
yading@10:     for (c = all_ch, cv = channels; c; c >>= 1, cv++)
yading@10:         if (c & 1)
yading@10:             *cv += val;
yading@10: }
yading@10: 
yading@10: static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
yading@10: {
yading@10:     int *last, i;
yading@10:     struct ws_interval *in;
yading@10: 
yading@10:     last = &ws->cur_inter;
yading@10:     for (i = ws->cur_inter; i >= 0; i = ws->inter[i].next)
yading@10:         last = &ws->inter[i].next;
yading@10:     for (i = ws->next_inter; i < ws->nb_inter; i++) {
yading@10:         in = &ws->inter[i];
yading@10:         if (ts < in->ts_start)
yading@10:             break;
yading@10:         if (ts >= in->ts_end)
yading@10:             continue;
yading@10:         *last = i;
yading@10:         last = &in->next;
yading@10:         in->phi = in->phi0;
yading@10:         in->dphi = in->dphi0;
yading@10:         in->amp = in->amp0;
yading@10:     }
yading@10:     ws->next_inter = i;
yading@10:     ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
yading@10:     *last = -1;
yading@10: }
yading@10: 
yading@10: static int wavesynth_decode(AVCodecContext *avc, void *rframe, int *rgot_frame,
yading@10:                             AVPacket *packet)
yading@10: {
yading@10:     struct wavesynth_context *ws = avc->priv_data;
yading@10:     int64_t ts;
yading@10:     int duration;
yading@10:     int s, c, r;
yading@10:     int16_t *pcm;
yading@10:     int32_t channels[WS_MAX_CHANNELS];
yading@10: 
yading@10:     *rgot_frame = 0;
yading@10:     if (packet->size != 12)
yading@10:         return AVERROR_INVALIDDATA;
yading@10:     ts = AV_RL64(packet->data);
yading@10:     if (ts != ws->cur_ts)
yading@10:         wavesynth_seek(ws, ts);
yading@10:     duration = AV_RL32(packet->data + 8);
yading@10:     if (duration <= 0)
yading@10:         return AVERROR(EINVAL);
yading@10:     ws->frame.nb_samples = duration;
yading@10:     r = ff_get_buffer(avc, &ws->frame, 0);
yading@10:     if (r < 0)
yading@10:         return r;
yading@10:     pcm = (int16_t *)ws->frame.data[0];
yading@10:     for (s = 0; s < duration; s++, ts++) {
yading@10:         memset(channels, 0, avc->channels * sizeof(*channels));
yading@10:         if (ts >= ws->next_ts)
yading@10:             wavesynth_enter_intervals(ws, ts);
yading@10:         wavesynth_synth_sample(ws, ts, channels);
yading@10:         for (c = 0; c < avc->channels; c++)
yading@10:             *(pcm++) = channels[c] >> 16;
yading@10:     }
yading@10:     ws->cur_ts += duration;
yading@10:     *rgot_frame = 1;
yading@10:     *(AVFrame *)rframe = ws->frame;
yading@10:     return packet->size;
yading@10: }
yading@10: 
yading@10: static av_cold int wavesynth_close(AVCodecContext *avc)
yading@10: {
yading@10:     struct wavesynth_context *ws = avc->priv_data;
yading@10: 
yading@10:     av_free(ws->sin);
yading@10:     av_free(ws->inter);
yading@10:     return 0;
yading@10: }
yading@10: 
yading@10: AVCodec ff_ffwavesynth_decoder = {
yading@10:     .name           = "wavesynth",
yading@10:     .type           = AVMEDIA_TYPE_AUDIO,
yading@10:     .id             = AV_CODEC_ID_FFWAVESYNTH,
yading@10:     .priv_data_size = sizeof(struct wavesynth_context),
yading@10:     .init           = wavesynth_init,
yading@10:     .close          = wavesynth_close,
yading@10:     .decode         = wavesynth_decode,
yading@10:     .capabilities   = CODEC_CAP_DR1,
yading@10:     .long_name      = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
yading@10: };