libavcodec/ffwavesynth.c

   1 /*
   2  * Wavesynth pseudo-codec
   3  * Copyright (c) 2011 Nicolas George
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/intreadwrite.h"
  23 #include "libavutil/log.h"
  24 #include "libavutil/mem.h"
  25 #include "avcodec.h"
  26 #include "codec_internal.h"
  27 #include "decode.h"
  28
  29
  30 #define SIN_BITS 14
  31 #define WS_MAX_CHANNELS 32
  32 #define INF_TS 0x7FFFFFFFFFFFFFFF
  33
  34 #define PINK_UNIT 128
  35
  36 /*
  37    Format of the extradata and packets
  38
  39    THIS INFORMATION IS NOT PART OF THE PUBLIC API OR ABI.
  40    IT CAN CHANGE WITHOUT NOTIFICATION.
  41
  42    All numbers are in little endian.
  43
  44    The codec extradata define a set of intervals with uniform content.
  45    Overlapping intervals are added together.
  46
  47    extradata:
  48        uint32      number of intervals
  49        ...         intervals
  50
  51    interval:
  52        int64       start timestamp; time_base must be 1/sample_rate;
  53                    start timestamps must be in ascending order
  54        int64       end timestamp
  55        uint32      type
  56        uint32      channels mask
  57        ...         additional information, depends on type
  58
  59    sine interval (type fourcc "SINE"):
  60        int32       start frequency, in 1/(1<<16) Hz
  61        int32       end frequency
  62        int32       start amplitude, 1<<16 is the full amplitude
  63        int32       end amplitude
  64        uint32      start phase, 0 is sin(0), 0x20000000 is sin(pi/2), etc.;
  65                    n | (1<<31) means to match the phase of previous channel #n
  66
  67    pink noise interval (type fourcc "NOIS"):
  68        int32       start amplitude
  69        int32       end amplitude
  70
  71    The input packets encode the time and duration of the requested segment.
  72
  73    packet:
  74        int64       start timestamp
  75        int32       duration
  76
  77 */
  78
  79 enum ws_interval_type {
  80     WS_SINE  = MKTAG('S','I','N','E'),
  81     WS_NOISE = MKTAG('N','O','I','S'),
  82 };
  83
  84 struct ws_interval {
  85     int64_t ts_start, ts_end;
  86     uint64_t phi0, dphi0, ddphi;
  87     uint64_t amp0, damp;
  88     uint64_t phi, dphi, amp;
  89     uint32_t channels;
  90     enum ws_interval_type type;
  91     int next;
  92 };
  93
  94 struct wavesynth_context {
  95     int64_t cur_ts;
  96     int64_t next_ts;
  97     int32_t *sin;
  98     struct ws_interval *inter;
  99     uint32_t dither_state;
 100     uint32_t pink_state;
 101     int32_t pink_pool[PINK_UNIT];
 102     unsigned pink_need, pink_pos;
 103     int nb_inter;
 104     int cur_inter;
 105     int next_inter;
 106 };
 107
 108 #define LCG_A 1284865837
 109 #define LCG_C 4150755663
 110 #define LCG_AI 849225893 /* A*AI = 1 [mod 1<<32] */
 111
 112 static uint32_t lcg_next(uint32_t *s)
 113 {
 114     *s = *s * LCG_A + LCG_C;
 115     return *s;
 116 }
 117
 118 static void lcg_seek(uint32_t *s, uint32_t dt)
 119 {
 120     uint32_t a, c, t = *s;
 121
 122     a = LCG_A;
 123     c = LCG_C;
 124     while (dt) {
 125         if (dt & 1)
 126             t = a * t + c;
 127         c *= a + 1; /* coefficients for a double step */
 128         a *= a;
 129         dt >>= 1;
 130     }
 131     *s = t;
 132 }
 133
 134 /* Emulate pink noise by summing white noise at the sampling frequency,
 135  * white noise at half the sampling frequency (each value taken twice),
 136  * etc., with a total of 8 octaves.
 137  * This is known as the Voss-McCartney algorithm. */
 138
 139 static void pink_fill(struct wavesynth_context *ws)
 140 {
 141     int32_t vt[7] = { 0 }, v = 0;
 142     int i, j;
 143
 144     ws->pink_pos = 0;
 145     if (!ws->pink_need)
 146         return;
 147     for (i = 0; i < PINK_UNIT; i++) {
 148         for (j = 0; j < 7; j++) {
 149             if ((i >> j) & 1)
 150                 break;
 151             v -= vt[j];
 152             vt[j] = (int32_t)lcg_next(&ws->pink_state) >> 3;
 153             v += vt[j];
 154         }
 155         ws->pink_pool[i] = v + ((int32_t)lcg_next(&ws->pink_state) >> 3);
 156     }
 157     lcg_next(&ws->pink_state); /* so we use exactly 256 steps */
 158 }
 159
 160 /**
 161  * @return  (1<<64) * a / b, without overflow, if a < b
 162  */
 163 static uint64_t frac64(uint64_t a, uint64_t b)
 164 {
 165     uint64_t r = 0;
 166     int i;
 167
 168     if (b < (uint64_t)1 << 32) { /* b small, use two 32-bits steps */
 169         a <<= 32;
 170         return ((a / b) << 32) | ((a % b) << 32) / b;
 171     }
 172     if (b < (uint64_t)1 << 48) { /* b medium, use four 16-bits steps */
 173         for (i = 0; i < 4; i++) {
 174             a <<= 16;
 175             r = (r << 16) | (a / b);
 176             a %= b;
 177         }
 178         return r;
 179     }
 180     for (i = 63; i >= 0; i--) {
 181         if (a >= (uint64_t)1 << 63 || a << 1 >= b) {
 182             r |= (uint64_t)1 << i;
 183             a = (a << 1) - b;
 184         } else {
 185             a <<= 1;
 186         }
 187     }
 188     return r;
 189 }
 190
 191 static uint64_t phi_at(struct ws_interval *in, int64_t ts)
 192 {
 193     uint64_t dt = ts - (uint64_t)in->ts_start;
 194     uint64_t dt2 = dt & 1 ? /* dt * (dt - 1) / 2 without overflow */
 195                    dt * ((dt - 1) >> 1) : (dt >> 1) * (dt - 1);
 196     return in->phi0 + dt * in->dphi0 + dt2 * in->ddphi;
 197 }
 198
 199 static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
 200 {
 201     int *last, i;
 202     struct ws_interval *in;
 203
 204     last = &ws->cur_inter;
 205     for (i = 0; i < ws->nb_inter; i++) {
 206         in = &ws->inter[i];
 207         if (ts < in->ts_start)
 208             break;
 209         if (ts >= in->ts_end)
 210             continue;
 211         *last = i;
 212         last = &in->next;
 213         in->phi  = phi_at(in, ts);
 214         in->dphi = in->dphi0 + (ts - in->ts_start) * in->ddphi;
 215         in->amp  = in->amp0  + (ts - in->ts_start) * in->damp;
 216     }
 217     ws->next_inter = i;
 218     ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
 219     *last = -1;
 220     lcg_seek(&ws->dither_state, (uint32_t)ts - (uint32_t)ws->cur_ts);
 221     if (ws->pink_need) {
 222         uint64_t pink_ts_cur  = (ws->cur_ts + (uint64_t)PINK_UNIT - 1) & ~(PINK_UNIT - 1);
 223         uint64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
 224         int pos = ts & (PINK_UNIT - 1);
 225         lcg_seek(&ws->pink_state, (uint32_t)(pink_ts_next - pink_ts_cur) * 2);
 226         if (pos) {
 227             pink_fill(ws);
 228             ws->pink_pos = pos;
 229         } else {
 230             ws->pink_pos = PINK_UNIT;
 231         }
 232     }
 233     ws->cur_ts = ts;
 234 }
 235
 236 static int wavesynth_parse_extradata(AVCodecContext *avc)
 237 {
 238     struct wavesynth_context *ws = avc->priv_data;
 239     struct ws_interval *in;
 240     uint8_t *edata, *edata_end;
 241     int32_t f1, f2, a1, a2;
 242     uint32_t phi;
 243     int64_t dphi1, dphi2, dt, cur_ts = -0x8000000000000000;
 244     int i;
 245
 246     if (avc->extradata_size < 4)
 247         return AVERROR(EINVAL);
 248     edata = avc->extradata;
 249     edata_end = edata + avc->extradata_size;
 250     ws->nb_inter = AV_RL32(edata);
 251     edata += 4;
 252     if (ws->nb_inter < 0 || (edata_end - edata) / 24 < ws->nb_inter)
 253         return AVERROR(EINVAL);
 254     ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
 255     if (!ws->inter)
 256         return AVERROR(ENOMEM);
 257     for (i = 0; i < ws->nb_inter; i++) {
 258         in = &ws->inter[i];
 259         if (edata_end - edata < 24)
 260             return AVERROR(EINVAL);
 261         in->ts_start = AV_RL64(edata +  0);
 262         in->ts_end   = AV_RL64(edata +  8);
 263         in->type     = AV_RL32(edata + 16);
 264         in->channels = AV_RL32(edata + 20);
 265         edata += 24;
 266         if (in->ts_start < cur_ts ||
 267             in->ts_end <= in->ts_start ||
 268             (uint64_t)in->ts_end - in->ts_start > INT64_MAX
 269         )
 270             return AVERROR(EINVAL);
 271         cur_ts = in->ts_start;
 272         dt = in->ts_end - in->ts_start;
 273         switch (in->type) {
 274             case WS_SINE:
 275                 if (edata_end - edata < 20 || avc->sample_rate <= 0)
 276                     return AVERROR(EINVAL);
 277                 f1  = AV_RL32(edata +  0);
 278                 f2  = AV_RL32(edata +  4);
 279                 a1  = AV_RL32(edata +  8);
 280                 a2  = AV_RL32(edata + 12);
 281                 phi = AV_RL32(edata + 16);
 282                 edata += 20;
 283                 dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
 284                 dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
 285                 in->dphi0 = dphi1;
 286                 in->ddphi = (int64_t)(dphi2 - (uint64_t)dphi1) / dt;
 287                 if (phi & 0x80000000) {
 288                     phi &= ~0x80000000;
 289                     if (phi >= i)
 290                         return AVERROR(EINVAL);
 291                     in->phi0 = phi_at(&ws->inter[phi], in->ts_start);
 292                 } else {
 293                     in->phi0 = (uint64_t)phi << 33;
 294                 }
 295                 break;
 296             case WS_NOISE:
 297                 if (edata_end - edata < 8)
 298                     return AVERROR(EINVAL);
 299                 a1  = AV_RL32(edata +  0);
 300                 a2  = AV_RL32(edata +  4);
 301                 edata += 8;
 302                 break;
 303             default:
 304                 return AVERROR(EINVAL);
 305         }
 306         in->amp0 = (uint64_t)a1 << 32;
 307         in->damp = (int64_t)(((uint64_t)a2 << 32) - ((uint64_t)a1 << 32)) / dt;
 308     }
 309     if (edata != edata_end)
 310         return AVERROR(EINVAL);
 311     return 0;
 312 }
 313
 314 static av_cold int wavesynth_init(AVCodecContext *avc)
 315 {
 316     struct wavesynth_context *ws = avc->priv_data;
 317     int i, r;
 318
 319     if (avc->ch_layout.nb_channels > WS_MAX_CHANNELS) {
 320         av_log(avc, AV_LOG_ERROR,
 321                "This implementation is limited to %d channels.\n",
 322                WS_MAX_CHANNELS);
 323         return AVERROR(EINVAL);
 324     }
 325     r = wavesynth_parse_extradata(avc);
 326     if (r < 0) {
 327         av_log(avc, AV_LOG_ERROR, "Invalid intervals definitions.\n");
 328         return r;
 329     }
 330     ws->sin = av_malloc(sizeof(*ws->sin) << SIN_BITS);
 331     if (!ws->sin)
 332         return AVERROR(ENOMEM);
 333     for (i = 0; i < 1 << SIN_BITS; i++)
 334         ws->sin[i] = floor(32767 * sin(2 * M_PI * i / (1 << SIN_BITS)));
 335     ws->dither_state = MKTAG('D','I','T','H');
 336     for (i = 0; i < ws->nb_inter; i++)
 337         ws->pink_need += ws->inter[i].type == WS_NOISE;
 338     ws->pink_state = MKTAG('P','I','N','K');
 339     ws->pink_pos = PINK_UNIT;
 340     wavesynth_seek(ws, 0);
 341     avc->sample_fmt = AV_SAMPLE_FMT_S16;
 342     return 0;
 343 }
 344
 345 static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
 346                                    int32_t *channels)
 347 {
 348     int32_t amp, *cv;
 349     unsigned val;
 350     struct ws_interval *in;
 351     int i, *last, pink;
 352     uint32_t c, all_ch = 0;
 353
 354     i = ws->cur_inter;
 355     last = &ws->cur_inter;
 356     if (ws->pink_pos == PINK_UNIT)
 357         pink_fill(ws);
 358     pink = ws->pink_pool[ws->pink_pos++] >> 16;
 359     while (i >= 0) {
 360         in = &ws->inter[i];
 361         i = in->next;
 362         if (ts >= in->ts_end) {
 363             *last = i;
 364             continue;
 365         }
 366         last = &in->next;
 367         amp = in->amp >> 32;
 368         in->amp  += in->damp;
 369         switch (in->type) {
 370             case WS_SINE:
 371                 val = amp * (unsigned)ws->sin[in->phi >> (64 - SIN_BITS)];
 372                 in->phi  += in->dphi;
 373                 in->dphi += in->ddphi;
 374                 break;
 375             case WS_NOISE:
 376                 val = amp * (unsigned)pink;
 377                 break;
 378             default:
 379                 val = 0;
 380         }
 381         all_ch |= in->channels;
 382         for (c = in->channels, cv = channels; c; c >>= 1, cv++)
 383             if (c & 1)
 384                 *cv += (unsigned)val;
 385     }
 386     val = (int32_t)lcg_next(&ws->dither_state) >> 16;
 387     for (c = all_ch, cv = channels; c; c >>= 1, cv++)
 388         if (c & 1)
 389             *cv += val;
 390 }
 391
 392 static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
 393 {
 394     int *last, i;
 395     struct ws_interval *in;
 396
 397     last = &ws->cur_inter;
 398     for (i = ws->cur_inter; i >= 0; i = ws->inter[i].next)
 399         last = &ws->inter[i].next;
 400     for (i = ws->next_inter; i < ws->nb_inter; i++) {
 401         in = &ws->inter[i];
 402         if (ts < in->ts_start)
 403             break;
 404         if (ts >= in->ts_end)
 405             continue;
 406         *last = i;
 407         last = &in->next;
 408         in->phi = in->phi0;
 409         in->dphi = in->dphi0;
 410         in->amp = in->amp0;
 411     }
 412     ws->next_inter = i;
 413     ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
 414     *last = -1;
 415 }
 416
 417 static int wavesynth_decode(AVCodecContext *avc, AVFrame *frame,
 418                             int *rgot_frame, AVPacket *packet)
 419 {
 420     struct wavesynth_context *ws = avc->priv_data;
 421     int64_t ts;
 422     int duration;
 423     int s, c, r;
 424     int16_t *pcm;
 425     int32_t channels[WS_MAX_CHANNELS];
 426
 427     *rgot_frame = 0;
 428     if (packet->size != 12)
 429         return AVERROR_INVALIDDATA;
 430     ts = AV_RL64(packet->data);
 431     if (ts != ws->cur_ts)
 432         wavesynth_seek(ws, ts);
 433     duration = AV_RL32(packet->data + 8);
 434     if (duration <= 0)
 435         return AVERROR(EINVAL);
 436     frame->nb_samples = duration;
 437     r = ff_get_buffer(avc, frame, 0);
 438     if (r < 0)
 439         return r;
 440     pcm = (int16_t *)frame->data[0];
 441     for (s = 0; s < duration; s++, ts+=(uint64_t)1) {
 442         memset(channels, 0, avc->ch_layout.nb_channels * sizeof(*channels));
 443         if (ts >= ws->next_ts)
 444             wavesynth_enter_intervals(ws, ts);
 445         wavesynth_synth_sample(ws, ts, channels);
 446         for (c = 0; c < avc->ch_layout.nb_channels; c++)
 447             *(pcm++) = channels[c] >> 16;
 448     }
 449     ws->cur_ts += (uint64_t)duration;
 450     *rgot_frame = 1;
 451     return packet->size;
 452 }
 453
 454 static av_cold int wavesynth_close(AVCodecContext *avc)
 455 {
 456     struct wavesynth_context *ws = avc->priv_data;
 457
 458     av_freep(&ws->sin);
 459     av_freep(&ws->inter);
 460     return 0;
 461 }
 462
 463 const FFCodec ff_ffwavesynth_decoder = {
 464     .p.name         = "wavesynth",
 465     CODEC_LONG_NAME("Wave synthesis pseudo-codec"),
 466     .p.type         = AVMEDIA_TYPE_AUDIO,
 467     .p.id           = AV_CODEC_ID_FFWAVESYNTH,
 468     .priv_data_size = sizeof(struct wavesynth_context),
 469     .init           = wavesynth_init,
 470     .close          = wavesynth_close,
 471     FF_CODEC_DECODE_CB(wavesynth_decode),
 472     .p.capabilities = AV_CODEC_CAP_DR1,
 473     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 474 };