00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "libavutil/intreadwrite.h"
00023 #include "libavutil/log.h"
00024 #include "avcodec.h"
00025 #include "internal.h"
00026
00027
00028 #define SIN_BITS 14
00029 #define WS_MAX_CHANNELS 32
00030 #define INF_TS 0x7FFFFFFFFFFFFFFF
00031
00032 #define PINK_UNIT 128
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077 enum ws_interval_type {
00078 WS_SINE = MKTAG('S','I','N','E'),
00079 WS_NOISE = MKTAG('N','O','I','S'),
00080 };
00081
00082 struct ws_interval {
00083 int64_t ts_start, ts_end;
00084 uint64_t phi0, dphi0, ddphi;
00085 uint64_t amp0, damp;
00086 uint64_t phi, dphi, amp;
00087 uint32_t channels;
00088 enum ws_interval_type type;
00089 int next;
00090 };
00091
00092 struct wavesynth_context {
00093 int64_t cur_ts;
00094 int64_t next_ts;
00095 int32_t *sin;
00096 AVFrame frame;
00097 struct ws_interval *inter;
00098 uint32_t dither_state;
00099 uint32_t pink_state;
00100 int32_t pink_pool[PINK_UNIT];
00101 unsigned pink_need, pink_pos;
00102 int nb_inter;
00103 int cur_inter;
00104 int next_inter;
00105 };
00106
00107 #define LCG_A 1284865837
00108 #define LCG_C 4150755663
00109 #define LCG_AI 849225893
00110
00111 static uint32_t lcg_next(uint32_t *s)
00112 {
00113 *s = *s * LCG_A + LCG_C;
00114 return *s;
00115 }
00116
00117 static void lcg_seek(uint32_t *s, int64_t dt)
00118 {
00119 uint32_t a, c, t = *s;
00120
00121 if (dt >= 0) {
00122 a = LCG_A;
00123 c = LCG_C;
00124 } else {
00125 a = LCG_AI;
00126 c = (uint32_t)(LCG_AI * LCG_C);
00127 dt = -dt;
00128 }
00129 while (dt) {
00130 if (dt & 1)
00131 t = a * t + c;
00132 c *= a + 1;
00133 a *= a;
00134 dt >>= 1;
00135 }
00136 *s = t;
00137 }
00138
00139
00140
00141
00142
00143
00144 static void pink_fill(struct wavesynth_context *ws)
00145 {
00146 int32_t vt[7] = { 0 }, v = 0;
00147 int i, j;
00148
00149 ws->pink_pos = 0;
00150 if (!ws->pink_need)
00151 return;
00152 for (i = 0; i < PINK_UNIT; i++) {
00153 for (j = 0; j < 7; j++) {
00154 if ((i >> j) & 1)
00155 break;
00156 v -= vt[j];
00157 vt[j] = (int32_t)lcg_next(&ws->pink_state) >> 3;
00158 v += vt[j];
00159 }
00160 ws->pink_pool[i] = v + ((int32_t)lcg_next(&ws->pink_state) >> 3);
00161 }
00162 lcg_next(&ws->pink_state);
00163 }
00164
00168 static uint64_t frac64(uint64_t a, uint64_t b)
00169 {
00170 uint64_t r = 0;
00171 int i;
00172
00173 if (b < (uint64_t)1 << 32) {
00174 a <<= 32;
00175 return ((a / b) << 32) | ((a % b) << 32) / b;
00176 }
00177 if (b < (uint64_t)1 << 48) {
00178 for (i = 0; i < 4; i++) {
00179 a <<= 16;
00180 r = (r << 16) | (a / b);
00181 a %= b;
00182 }
00183 return r;
00184 }
00185 for (i = 63; i >= 0; i--) {
00186 if (a >= (uint64_t)1 << 63 || a << 1 >= b) {
00187 r |= (uint64_t)1 << i;
00188 a = (a << 1) - b;
00189 } else {
00190 a <<= 1;
00191 }
00192 }
00193 return r;
00194 }
00195
00196 static uint64_t phi_at(struct ws_interval *in, int64_t ts)
00197 {
00198 uint64_t dt = ts - in->ts_start;
00199 uint64_t dt2 = dt & 1 ?
00200 dt * ((dt - 1) >> 1) : (dt >> 1) * (dt - 1);
00201 return in->phi0 + dt * in->dphi0 + dt2 * in->ddphi;
00202 }
00203
00204 static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
00205 {
00206 int *last, i;
00207 struct ws_interval *in;
00208
00209 last = &ws->cur_inter;
00210 for (i = 0; i < ws->nb_inter; i++) {
00211 in = &ws->inter[i];
00212 if (ts < in->ts_start)
00213 break;
00214 if (ts >= in->ts_end)
00215 continue;
00216 *last = i;
00217 last = &in->next;
00218 in->phi = phi_at(in, ts);
00219 in->dphi = in->dphi0 + (ts - in->ts_start) * in->ddphi;
00220 in->amp = in->amp0 + (ts - in->ts_start) * in->damp;
00221 }
00222 ws->next_inter = i;
00223 ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
00224 *last = -1;
00225 lcg_seek(&ws->dither_state, ts - ws->cur_ts);
00226 if (ws->pink_need) {
00227 int64_t pink_ts_cur = (ws->cur_ts + PINK_UNIT - 1) & ~(PINK_UNIT - 1);
00228 int64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
00229 int pos = ts & (PINK_UNIT - 1);
00230 lcg_seek(&ws->pink_state, (pink_ts_next - pink_ts_cur) << 1);
00231 if (pos) {
00232 pink_fill(ws);
00233 ws->pink_pos = pos;
00234 } else {
00235 ws->pink_pos = PINK_UNIT;
00236 }
00237 }
00238 ws->cur_ts = ts;
00239 }
00240
00241 static int wavesynth_parse_extradata(AVCodecContext *avc)
00242 {
00243 struct wavesynth_context *ws = avc->priv_data;
00244 struct ws_interval *in;
00245 uint8_t *edata, *edata_end;
00246 int32_t f1, f2, a1, a2;
00247 uint32_t phi;
00248 int64_t dphi1, dphi2, dt, cur_ts = -0x8000000000000000;
00249 int i;
00250
00251 if (avc->extradata_size < 4)
00252 return AVERROR(EINVAL);
00253 edata = avc->extradata;
00254 edata_end = edata + avc->extradata_size;
00255 ws->nb_inter = AV_RL32(edata);
00256 edata += 4;
00257 if (ws->nb_inter < 0)
00258 return AVERROR(EINVAL);
00259 ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
00260 if (!ws->inter)
00261 return AVERROR(ENOMEM);
00262 for (i = 0; i < ws->nb_inter; i++) {
00263 in = &ws->inter[i];
00264 if (edata_end - edata < 24)
00265 return AVERROR(EINVAL);
00266 in->ts_start = AV_RL64(edata + 0);
00267 in->ts_end = AV_RL64(edata + 8);
00268 in->type = AV_RL32(edata + 16);
00269 in->channels = AV_RL32(edata + 20);
00270 edata += 24;
00271 if (in->ts_start < cur_ts || in->ts_end <= in->ts_start)
00272 return AVERROR(EINVAL);
00273 cur_ts = in->ts_start;
00274 dt = in->ts_end - in->ts_start;
00275 switch (in->type) {
00276 case WS_SINE:
00277 if (edata_end - edata < 20)
00278 return AVERROR(EINVAL);
00279 f1 = AV_RL32(edata + 0);
00280 f2 = AV_RL32(edata + 4);
00281 a1 = AV_RL32(edata + 8);
00282 a2 = AV_RL32(edata + 12);
00283 phi = AV_RL32(edata + 16);
00284 edata += 20;
00285 dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
00286 dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
00287 in->dphi0 = dphi1;
00288 in->ddphi = (dphi2 - dphi1) / dt;
00289 if (phi & 0x80000000) {
00290 phi &= ~0x80000000;
00291 if (phi >= i)
00292 return AVERROR(EINVAL);
00293 in->phi0 = phi_at(&ws->inter[phi], in->ts_start);
00294 } else {
00295 in->phi0 = (uint64_t)phi << 33;
00296 }
00297 break;
00298 case WS_NOISE:
00299 if (edata_end - edata < 8)
00300 return AVERROR(EINVAL);
00301 a1 = AV_RL32(edata + 0);
00302 a2 = AV_RL32(edata + 4);
00303 edata += 8;
00304 break;
00305 default:
00306 return AVERROR(EINVAL);
00307 }
00308 in->amp0 = (int64_t)a1 << 32;
00309 in->damp = (((int64_t)a2 << 32) - ((int64_t)a1 << 32)) / dt;
00310 }
00311 if (edata != edata_end)
00312 return AVERROR(EINVAL);
00313 return 0;
00314 }
00315
00316 static av_cold int wavesynth_init(AVCodecContext *avc)
00317 {
00318 struct wavesynth_context *ws = avc->priv_data;
00319 int i, r;
00320
00321 if (avc->channels > WS_MAX_CHANNELS) {
00322 av_log(avc, AV_LOG_ERROR,
00323 "This implementation is limited to %d channels.\n",
00324 WS_MAX_CHANNELS);
00325 return AVERROR(EINVAL);
00326 }
00327 r = wavesynth_parse_extradata(avc);
00328 if (r < 0) {
00329 av_log(avc, AV_LOG_ERROR, "Invalid intervals definitions.\n");
00330 goto fail;
00331 }
00332 ws->sin = av_malloc(sizeof(*ws->sin) << SIN_BITS);
00333 if (!ws->sin) {
00334 r = AVERROR(ENOMEM);
00335 goto fail;
00336 }
00337 for (i = 0; i < 1 << SIN_BITS; i++)
00338 ws->sin[i] = floor(32767 * sin(2 * M_PI * i / (1 << SIN_BITS)));
00339 ws->dither_state = MKTAG('D','I','T','H');
00340 for (i = 0; i < ws->nb_inter; i++)
00341 ws->pink_need += ws->inter[i].type == WS_NOISE;
00342 ws->pink_state = MKTAG('P','I','N','K');
00343 ws->pink_pos = PINK_UNIT;
00344 avcodec_get_frame_defaults(&ws->frame);
00345 avc->coded_frame = &ws->frame;
00346 wavesynth_seek(ws, 0);
00347 avc->sample_fmt = AV_SAMPLE_FMT_S16;
00348 return 0;
00349
00350 fail:
00351 av_free(ws->inter);
00352 av_free(ws->sin);
00353 return r;
00354 }
00355
00356 static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
00357 int32_t *channels)
00358 {
00359 int32_t amp, val, *cv;
00360 struct ws_interval *in;
00361 int i, *last, pink;
00362 uint32_t c, all_ch = 0;
00363
00364 i = ws->cur_inter;
00365 last = &ws->cur_inter;
00366 if (ws->pink_pos == PINK_UNIT)
00367 pink_fill(ws);
00368 pink = ws->pink_pool[ws->pink_pos++] >> 16;
00369 while (i >= 0) {
00370 in = &ws->inter[i];
00371 i = in->next;
00372 if (ts >= in->ts_end) {
00373 *last = i;
00374 continue;
00375 }
00376 last = &in->next;
00377 amp = in->amp >> 32;
00378 in->amp += in->damp;
00379 switch (in->type) {
00380 case WS_SINE:
00381 val = amp * ws->sin[in->phi >> (64 - SIN_BITS)];
00382 in->phi += in->dphi;
00383 in->dphi += in->ddphi;
00384 break;
00385 case WS_NOISE:
00386 val = amp * pink;
00387 break;
00388 default:
00389 val = 0;
00390 }
00391 all_ch |= in->channels;
00392 for (c = in->channels, cv = channels; c; c >>= 1, cv++)
00393 if (c & 1)
00394 *cv += val;
00395 }
00396 val = (int32_t)lcg_next(&ws->dither_state) >> 16;
00397 for (c = all_ch, cv = channels; c; c >>= 1, cv++)
00398 if (c & 1)
00399 *cv += val;
00400 }
00401
00402 static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
00403 {
00404 int *last, i;
00405 struct ws_interval *in;
00406
00407 last = &ws->cur_inter;
00408 for (i = ws->cur_inter; i >= 0; i = ws->inter[i].next)
00409 last = &ws->inter[i].next;
00410 for (i = ws->next_inter; i < ws->nb_inter; i++) {
00411 in = &ws->inter[i];
00412 if (ts < in->ts_start)
00413 break;
00414 if (ts >= in->ts_end)
00415 continue;
00416 *last = i;
00417 last = &in->next;
00418 in->phi = in->phi0;
00419 in->dphi = in->dphi0;
00420 in->amp = in->amp0;
00421 }
00422 ws->next_inter = i;
00423 ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
00424 *last = -1;
00425 }
00426
00427 static int wavesynth_decode(AVCodecContext *avc, void *rframe, int *rgot_frame,
00428 AVPacket *packet)
00429 {
00430 struct wavesynth_context *ws = avc->priv_data;
00431 int64_t ts;
00432 int duration;
00433 int s, c, r;
00434 int16_t *pcm;
00435 int32_t channels[WS_MAX_CHANNELS];
00436
00437 *rgot_frame = 0;
00438 if (packet->size != 12)
00439 return AVERROR_INVALIDDATA;
00440 ts = AV_RL64(packet->data);
00441 if (ts != ws->cur_ts)
00442 wavesynth_seek(ws, ts);
00443 duration = AV_RL32(packet->data + 8);
00444 if (duration <= 0)
00445 return AVERROR(EINVAL);
00446 ws->frame.nb_samples = duration;
00447 r = ff_get_buffer(avc, &ws->frame);
00448 if (r < 0)
00449 return r;
00450 pcm = (int16_t *)ws->frame.data[0];
00451 for (s = 0; s < duration; s++, ts++) {
00452 memset(channels, 0, avc->channels * sizeof(*channels));
00453 if (ts >= ws->next_ts)
00454 wavesynth_enter_intervals(ws, ts);
00455 wavesynth_synth_sample(ws, ts, channels);
00456 for (c = 0; c < avc->channels; c++)
00457 *(pcm++) = channels[c] >> 16;
00458 }
00459 ws->cur_ts += duration;
00460 *rgot_frame = 1;
00461 *(AVFrame *)rframe = ws->frame;
00462 return packet->size;
00463 }
00464
00465 static av_cold int wavesynth_close(AVCodecContext *avc)
00466 {
00467 struct wavesynth_context *ws = avc->priv_data;
00468
00469 av_free(ws->sin);
00470 av_free(ws->inter);
00471 return 0;
00472 }
00473
00474 AVCodec ff_ffwavesynth_decoder = {
00475 .name = "wavesynth",
00476 .type = AVMEDIA_TYPE_AUDIO,
00477 .id = AV_CODEC_ID_FFWAVESYNTH,
00478 .priv_data_size = sizeof(struct wavesynth_context),
00479 .init = wavesynth_init,
00480 .close = wavesynth_close,
00481 .decode = wavesynth_decode,
00482 .capabilities = CODEC_CAP_DR1,
00483 .long_name = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
00484 };