FFmpeg
ffwavesynth.c
Go to the documentation of this file.
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 
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;
91  int next;
92 };
93 
95  int64_t cur_ts;
96  int64_t next_ts;
98  struct ws_interval *inter;
99  uint32_t dither_state;
100  uint32_t pink_state;
102  unsigned pink_need, pink_pos;
103  int nb_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 
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 
315 {
316  struct wavesynth_context *ws = avc->priv_data;
317  int i, r;
318 
320  av_log(avc, AV_LOG_ERROR,
321  "This implementation is limited to %d channels.\n",
323  return AVERROR(EINVAL);
324  }
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);
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 
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;
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)
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 
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 
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,
472  .p.capabilities = AV_CODEC_CAP_DR1,
473  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
474 };
ws_interval::phi
uint64_t phi
Definition: ffwavesynth.c:88
ff_ffwavesynth_decoder
const FFCodec ff_ffwavesynth_decoder
Definition: ffwavesynth.c:463
ws_interval::type
enum ws_interval_type type
Definition: ffwavesynth.c:90
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
wavesynth_context::pink_state
uint32_t pink_state
Definition: ffwavesynth.c:100
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
wavesynth_context::next_inter
int next_inter
Definition: ffwavesynth.c:105
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
ws_interval::amp0
uint64_t amp0
Definition: ffwavesynth.c:87
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:520
wavesynth_context::pink_need
unsigned pink_need
Definition: ffwavesynth.c:102
b
#define b
Definition: input.c:41
wavesynth_context::inter
struct ws_interval * inter
Definition: ffwavesynth.c:98
FFCodec
Definition: codec_internal.h:126
wavesynth_context::nb_inter
int nb_inter
Definition: ffwavesynth.c:103
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
wavesynth_synth_sample
static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts, int32_t *channels)
Definition: ffwavesynth.c:345
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
wavesynth_context::cur_ts
int64_t cur_ts
Definition: ffwavesynth.c:95
ws_interval::ts_start
int64_t ts_start
Definition: ffwavesynth.c:85
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
ws_interval::dphi
uint64_t dphi
Definition: ffwavesynth.c:88
val
static double val(void *priv, double ch)
Definition: aeval.c:78
wavesynth_context::cur_inter
int cur_inter
Definition: ffwavesynth.c:104
a2
static double a2(void *priv, double x, double y)
Definition: vf_xfade.c:2031
AV_CODEC_ID_FFWAVESYNTH
@ AV_CODEC_ID_FFWAVESYNTH
Definition: codec_id.h:508
LCG_A
#define LCG_A
Definition: ffwavesynth.c:108
phi_at
static uint64_t phi_at(struct ws_interval *in, int64_t ts)
Definition: ffwavesynth.c:191
wavesynth_parse_extradata
static int wavesynth_parse_extradata(AVCodecContext *avc)
Definition: ffwavesynth.c:236
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ws_interval::next
int next
Definition: ffwavesynth.c:91
av_cold
#define av_cold
Definition: attributes.h:90
ws_interval::ddphi
uint64_t ddphi
Definition: ffwavesynth.c:86
duration
int64_t duration
Definition: movenc.c:65
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ws_interval::f2
int32_t f2
Definition: sbgdec.c:151
wavesynth_decode
static int wavesynth_decode(AVCodecContext *avc, AVFrame *frame, int *rgot_frame, AVPacket *packet)
Definition: ffwavesynth.c:417
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
frac64
static uint64_t frac64(uint64_t a, uint64_t b)
Definition: ffwavesynth.c:163
ws_interval::phi0
uint64_t phi0
Definition: ffwavesynth.c:86
WS_SINE
@ WS_SINE
Definition: ffwavesynth.c:80
wavesynth_context::sin
int32_t * sin
Definition: ffwavesynth.c:97
channels
channels
Definition: aptx.h:31
decode.h
wavesynth_context
Definition: ffwavesynth.c:94
wavesynth_enter_intervals
static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
Definition: ffwavesynth.c:392
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
SIN_BITS
#define SIN_BITS
Definition: ffwavesynth.c:30
LCG_C
#define LCG_C
Definition: ffwavesynth.c:109
ws_interval::dphi0
uint64_t dphi0
Definition: ffwavesynth.c:86
ws_interval::amp
uint64_t amp
Definition: ffwavesynth.c:88
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
PINK_UNIT
#define PINK_UNIT
Definition: ffwavesynth.c:34
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:521
codec_internal.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
ws_interval::channels
uint32_t channels
Definition: ffwavesynth.c:89
INF_TS
#define INF_TS
Definition: ffwavesynth.c:32
wavesynth_seek
static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
Definition: ffwavesynth.c:199
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
M_PI
#define M_PI
Definition: mathematics.h:67
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
wavesynth_init
static av_cold int wavesynth_init(AVCodecContext *avc)
Definition: ffwavesynth.c:314
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
WS_MAX_CHANNELS
#define WS_MAX_CHANNELS
Definition: ffwavesynth.c:31
wavesynth_context::next_ts
int64_t next_ts
Definition: ffwavesynth.c:96
wavesynth_context::pink_pool
int32_t pink_pool[PINK_UNIT]
Definition: ffwavesynth.c:101
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
wavesynth_context::dither_state
uint32_t dither_state
Definition: ffwavesynth.c:99
ws_interval
Definition: ffwavesynth.c:84
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
ws_interval::ts_end
int64_t ts_end
Definition: ffwavesynth.c:85
ws_interval::f1
int32_t f1
Definition: sbgdec.c:151
avcodec.h
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
pos
unsigned int pos
Definition: spdifenc.c:414
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVCodecContext
main external API structure.
Definition: avcodec.h:445
wavesynth_close
static av_cold int wavesynth_close(AVCodecContext *avc)
Definition: ffwavesynth.c:454
lcg_next
static uint32_t lcg_next(uint32_t *s)
Definition: ffwavesynth.c:112
lcg_seek
static void lcg_seek(uint32_t *s, uint32_t dt)
Definition: ffwavesynth.c:118
mem.h
WS_NOISE
@ WS_NOISE
Definition: ffwavesynth.c:81
pink_fill
static void pink_fill(struct wavesynth_context *ws)
Definition: ffwavesynth.c:139
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
wavesynth_context::pink_pos
unsigned pink_pos
Definition: ffwavesynth.c:102
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
a1
static double a1(void *priv, double x, double y)
Definition: vf_xfade.c:2030
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ws_interval::damp
uint64_t damp
Definition: ffwavesynth.c:87
ws_interval_type
ws_interval_type
Definition: ffwavesynth.c:79