FFmpeg  4.4
nellymoserenc.c
Go to the documentation of this file.
1 /*
2  * Nellymoser encoder
3  * This code is developed as part of Google Summer of Code 2008 Program.
4  *
5  * Copyright (c) 2008 Bartlomiej Wolowiec
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * Nellymoser encoder
27  * by Bartlomiej Wolowiec
28  *
29  * Generic codec information: libavcodec/nellymoserdec.c
30  *
31  * Some information also from: http://samples.mplayerhq.hu/A-codecs/Nelly_Moser/ASAO/ASAO.zip
32  * (Copyright Joseph Artsimovich and UAB "DKD")
33  *
34  * for more information about nellymoser format, visit:
35  * http://wiki.multimedia.cx/index.php?title=Nellymoser
36  */
37 
38 #include "libavutil/common.h"
39 #include "libavutil/float_dsp.h"
40 #include "libavutil/mathematics.h"
41 #include "libavutil/thread.h"
42 
43 #include "audio_frame_queue.h"
44 #include "avcodec.h"
45 #include "fft.h"
46 #include "internal.h"
47 #include "nellymoser.h"
48 #include "sinewin.h"
49 
50 #define BITSTREAM_WRITER_LE
51 #include "put_bits.h"
52 
53 #define POW_TABLE_SIZE (1<<11)
54 #define POW_TABLE_OFFSET 3
55 #define OPT_SIZE ((1<<15) + 3000)
56 
57 typedef struct NellyMoserEncodeContext {
65  DECLARE_ALIGNED(32, float, buf)[3 * NELLY_BUF_LEN]; ///< sample buffer
66  float (*opt )[OPT_SIZE];
69 
70 static float pow_table[POW_TABLE_SIZE]; ///< pow(2, -i / 2048.0 - 3.0);
71 
72 static const uint8_t sf_lut[96] = {
73  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
74  5, 5, 5, 6, 7, 7, 8, 8, 9, 10, 11, 11, 12, 13, 13, 14,
75  15, 15, 16, 17, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24, 25, 26,
76  27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40,
77  41, 41, 42, 43, 44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 52, 53,
78  54, 55, 55, 56, 57, 57, 58, 59, 59, 60, 60, 60, 61, 61, 61, 62,
79 };
80 
81 static const uint8_t sf_delta_lut[78] = {
82  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
83  4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 10, 11, 11, 12,
84  13, 13, 14, 15, 16, 17, 17, 18, 19, 19, 20, 21, 21, 22, 22, 23,
85  23, 24, 24, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28,
86  28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30,
87 };
88 
89 static const uint8_t quant_lut[230] = {
90  0,
91 
92  0, 1, 2,
93 
94  0, 1, 2, 3, 4, 5, 6,
95 
96  0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11,
97  12, 13, 13, 13, 14,
98 
99  0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8,
100  8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
101  22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 29,
102  30,
103 
104  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3,
105  4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,
106  10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
107  15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20,
108  21, 21, 22, 22, 23, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32,
109  33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 42, 43, 44, 44, 45, 45,
110  46, 47, 47, 48, 48, 49, 49, 50, 50, 50, 51, 51, 51, 52, 52, 52,
111  53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56, 56, 57, 57, 57, 57,
112  58, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 61,
113  61, 61, 61, 61, 62,
114 };
115 
116 static const float quant_lut_mul[7] = { 0.0, 0.0, 2.0, 2.0, 5.0, 12.0, 36.6 };
117 static const float quant_lut_add[7] = { 0.0, 0.0, 2.0, 7.0, 21.0, 56.0, 157.0 };
118 static const uint8_t quant_lut_offset[8] = { 0, 0, 1, 4, 11, 32, 81, 230 };
119 
121 {
122  float *in0 = s->buf;
123  float *in1 = s->buf + NELLY_BUF_LEN;
124  float *in2 = s->buf + 2 * NELLY_BUF_LEN;
125 
126  s->fdsp->vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN);
127  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN);
128  s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);
129 
130  s->fdsp->vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN);
131  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN);
132  s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->in_buff);
133 }
134 
136 {
138 
139  ff_mdct_end(&s->mdct_ctx);
140 
141  if (s->avctx->trellis) {
142  av_freep(&s->opt);
143  av_freep(&s->path);
144  }
145  ff_af_queue_close(&s->afq);
146  av_freep(&s->fdsp);
147 
148  return 0;
149 }
150 
152 {
153  /* faster way of doing
154  for (int i = 0; i < POW_TABLE_SIZE; i++)
155  pow_table[i] = 2^(-i / 2048.0 - 3.0 + POW_TABLE_OFFSET); */
156  pow_table[0] = 1;
157  pow_table[1024] = M_SQRT1_2;
158  for (int i = 1; i < 513; i++) {
159  double tmp = exp2(-i / 2048.0);
160  pow_table[i] = tmp;
161  pow_table[1024-i] = M_SQRT1_2 / tmp;
162  pow_table[1024+i] = tmp * M_SQRT1_2;
163  pow_table[2048-i] = 0.5 / tmp;
164  }
165  /* Generate overlap window */
167 }
168 
170 {
171  static AVOnce init_static_once = AV_ONCE_INIT;
173  int ret;
174 
175  if (avctx->channels != 1) {
176  av_log(avctx, AV_LOG_ERROR, "Nellymoser supports only 1 channel\n");
177  return AVERROR(EINVAL);
178  }
179 
180  if (avctx->sample_rate != 8000 && avctx->sample_rate != 16000 &&
181  avctx->sample_rate != 11025 &&
182  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
184  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
185  return AVERROR(EINVAL);
186  }
187 
188  avctx->frame_size = NELLY_SAMPLES;
190  ff_af_queue_init(avctx, &s->afq);
191  s->avctx = avctx;
192  if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
193  return ret;
195  if (!s->fdsp)
196  return AVERROR(ENOMEM);
197 
198  if (s->avctx->trellis) {
199  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
200  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
201  if (!s->opt || !s->path)
202  return AVERROR(ENOMEM);
203  }
204 
205  ff_thread_once(&init_static_once, nellymoser_init_static);
206 
207  return 0;
208 }
209 
210 #define find_best(val, table, LUT, LUT_add, LUT_size) \
211  best_idx = \
212  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
213  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
214  best_idx++;
215 
216 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
217 {
218  int band, best_idx, power_idx = 0;
219  float power_candidate;
220 
221  //base exponent
222  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
223  idx_table[0] = best_idx;
224  power_idx = ff_nelly_init_table[best_idx];
225 
226  for (band = 1; band < NELLY_BANDS; band++) {
227  power_candidate = cand[band] - power_idx;
228  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
229  idx_table[band] = best_idx;
230  power_idx += ff_nelly_delta_table[best_idx];
231  }
232 }
233 
234 static inline float distance(float x, float y, int band)
235 {
236  //return pow(fabs(x-y), 2.0);
237  float tmp = x - y;
238  return tmp * tmp;
239 }
240 
241 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
242 {
243  int i, j, band, best_idx;
244  float power_candidate, best_val;
245 
246  float (*opt )[OPT_SIZE] = s->opt ;
247  uint8_t(*path)[OPT_SIZE] = s->path;
248 
249  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
250  opt[0][i] = INFINITY;
251  }
252 
253  for (i = 0; i < 64; i++) {
254  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
255  path[0][ff_nelly_init_table[i]] = i;
256  }
257 
258  for (band = 1; band < NELLY_BANDS; band++) {
259  int q, c = 0;
260  float tmp;
261  int idx_min, idx_max, idx;
262  power_candidate = cand[band];
263  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
264  idx_min = FFMAX(0, cand[band] - q);
265  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
266  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
267  if ( isinf(opt[band - 1][i]) )
268  continue;
269  for (j = 0; j < 32; j++) {
270  idx = i + ff_nelly_delta_table[j];
271  if (idx > idx_max)
272  break;
273  if (idx >= idx_min) {
274  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
275  if (opt[band][idx] > tmp) {
276  opt[band][idx] = tmp;
277  path[band][idx] = j;
278  c = 1;
279  }
280  }
281  }
282  }
283  }
284  av_assert1(c); //FIXME
285  }
286 
287  best_val = INFINITY;
288  best_idx = -1;
289  band = NELLY_BANDS - 1;
290  for (i = 0; i < OPT_SIZE; i++) {
291  if (best_val > opt[band][i]) {
292  best_val = opt[band][i];
293  best_idx = i;
294  }
295  }
296  for (band = NELLY_BANDS - 1; band >= 0; band--) {
297  idx_table[band] = path[band][best_idx];
298  if (band) {
299  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
300  }
301  }
302 }
303 
304 /**
305  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
306  * @param s encoder context
307  * @param output output buffer
308  * @param output_size size of output buffer
309  */
310 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
311 {
312  PutBitContext pb;
313  int i, j, band, block, best_idx, power_idx = 0;
314  float power_val, coeff, coeff_sum;
315  float pows[NELLY_FILL_LEN];
316  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
317  float cand[NELLY_BANDS];
318 
319  apply_mdct(s);
320 
321  init_put_bits(&pb, output, output_size);
322 
323  i = 0;
324  for (band = 0; band < NELLY_BANDS; band++) {
325  coeff_sum = 0;
326  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
327  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
328  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
329  }
330  cand[band] =
331  log2(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0;
332  }
333 
334  if (s->avctx->trellis) {
335  get_exponent_dynamic(s, cand, idx_table);
336  } else {
337  get_exponent_greedy(s, cand, idx_table);
338  }
339 
340  i = 0;
341  for (band = 0; band < NELLY_BANDS; band++) {
342  if (band) {
343  power_idx += ff_nelly_delta_table[idx_table[band]];
344  put_bits(&pb, 5, idx_table[band]);
345  } else {
346  power_idx = ff_nelly_init_table[idx_table[0]];
347  put_bits(&pb, 6, idx_table[0]);
348  }
349  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
350  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
351  s->mdct_out[i] *= power_val;
352  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
353  pows[i] = power_idx;
354  }
355  }
356 
358 
359  for (block = 0; block < 2; block++) {
360  for (i = 0; i < NELLY_FILL_LEN; i++) {
361  if (bits[i] > 0) {
362  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
363  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
364  best_idx =
368  quant_lut_offset[bits[i]+1] - 1
369  )];
370  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
371  best_idx++;
372 
373  put_bits(&pb, bits[i], best_idx);
374  }
375  }
376  if (!block)
378  }
379 
380  flush_put_bits(&pb);
381  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
382 }
383 
384 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
385  const AVFrame *frame, int *got_packet_ptr)
386 {
388  int ret;
389 
390  if (s->last_frame)
391  return 0;
392 
393  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
394  if (frame) {
395  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
396  frame->nb_samples * sizeof(*s->buf));
397  if (frame->nb_samples < NELLY_SAMPLES) {
398  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
399  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
401  s->last_frame = 1;
402  }
403  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
404  return ret;
405  } else {
406  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
407  s->last_frame = 1;
408  }
409 
410  if ((ret = ff_alloc_packet2(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
411  return ret;
412  encode_block(s, avpkt->data, avpkt->size);
413 
414  /* Get the next frame pts/duration */
415  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
416  &avpkt->duration);
417 
418  *got_packet_ptr = 1;
419  return 0;
420 }
421 
423  .name = "nellymoser",
424  .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
425  .type = AVMEDIA_TYPE_AUDIO,
427  .priv_data_size = sizeof(NellyMoserEncodeContext),
428  .init = encode_init,
429  .encode2 = encode_frame,
430  .close = encode_end,
432  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
435 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
#define av_cold
Definition: attributes.h:88
uint8_t
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
Libavcodec external API header.
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1604
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
common internal and external API header
#define FFMIN(a, b)
Definition: common.h:105
#define av_clip
Definition: common.h:122
#define FFMAX(a, b)
Definition: common.h:103
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
static AVFrame * frame
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
#define ff_mdct_init
Definition: fft.h:161
#define ff_mdct_end
Definition: fft.h:162
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:457
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
int i
Definition: input.c:407
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
#define log2(x)
Definition: libm.h:404
#define isinf(x)
Definition: libm.h:317
#define exp2(x)
Definition: libm.h:288
#define INFINITY
Definition: mathematics.h:67
#define M_SQRT1_2
Definition: mathematics.h:58
const uint16_t ff_nelly_init_table[64]
Definition: nellymoser.c:70
const uint8_t ff_nelly_band_sizes_table[NELLY_BANDS]
Definition: nellymoser.c:66
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:116
const int16_t ff_nelly_delta_table[32]
Definition: nellymoser.c:79
const float ff_nelly_dequantization_table[127]
Definition: nellymoser.c:39
The 3 alphanumeric copyright notices are md5summed they are from the original implementors.
#define NELLY_BANDS
Definition: nellymoser.h:39
#define NELLY_BUF_LEN
Definition: nellymoser.h:43
#define NELLY_DETAIL_BITS
Definition: nellymoser.h:42
#define NELLY_SAMPLES
Definition: nellymoser.h:48
#define NELLY_HEADER_BITS
Definition: nellymoser.h:41
#define NELLY_FILL_LEN
Definition: nellymoser.h:44
#define NELLY_BLOCK_LEN
Definition: nellymoser.h:40
static float distance(float x, float y, int band)
#define find_best(val, table, LUT, LUT_add, LUT_size)
#define OPT_SIZE
Definition: nellymoserenc.c:55
static av_cold void nellymoser_init_static(void)
static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
Encode NELLY_SAMPLES samples.
#define POW_TABLE_SIZE
Definition: nellymoserenc.c:53
static const uint8_t quant_lut_offset[8]
AVCodec ff_nellymoser_encoder
#define POW_TABLE_OFFSET
Definition: nellymoserenc.c:54
static av_cold int encode_init(AVCodecContext *avctx)
static float pow_table[POW_TABLE_SIZE]
pow(2, -i / 2048.0 - 3.0);
Definition: nellymoserenc.c:70
static const float quant_lut_mul[7]
static const float quant_lut_add[7]
static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
static av_cold int encode_end(AVCodecContext *avctx)
static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
static void apply_mdct(NellyMoserEncodeContext *s)
static const uint8_t sf_lut[96]
Definition: nellymoserenc.c:72
static const uint8_t sf_delta_lut[78]
Definition: nellymoserenc.c:81
static const uint8_t quant_lut[230]
Definition: nellymoserenc.c:89
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
static const uint16_t table[]
Definition: prosumer.c:206
bitstream writer API
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:57
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:342
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:76
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:110
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
main external API structure.
Definition: avcodec.h:536
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
int initial_padding
Audio only.
Definition: avcodec.h:2062
int sample_rate
samples per second
Definition: avcodec.h:1196
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
int channels
number of audio channels
Definition: avcodec.h:1197
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
Definition: fft.h:83
AVCodecContext * avctx
Definition: nellymoserenc.c:58
float in_buff[NELLY_SAMPLES]
Definition: nellymoserenc.c:64
float(* opt)[OPT_SIZE]
Definition: nellymoserenc.c:66
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:65
AudioFrameQueue afq
Definition: nellymoserenc.c:62
AVFloatDSPContext * fdsp
Definition: nellymoserenc.c:60
uint8_t(* path)[OPT_SIZE]
Definition: nellymoserenc.c:67
float mdct_out[NELLY_SAMPLES]
Definition: nellymoserenc.c:63
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
static int16_t block[64]
Definition: dct.c:116
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
uint8_t bits
Definition: vp3data.h:141
static double c[64]