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