FFmpeg  4.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  av_freep(&s->opt);
142  av_freep(&s->path);
143  ff_af_queue_close(&s->afq);
144  av_freep(&s->fdsp);
145 
146  return 0;
147 }
148 
150 {
151  /* faster way of doing
152  for (int i = 0; i < POW_TABLE_SIZE; i++)
153  pow_table[i] = 2^(-i / 2048.0 - 3.0 + POW_TABLE_OFFSET); */
154  pow_table[0] = 1;
155  pow_table[1024] = M_SQRT1_2;
156  for (int i = 1; i < 513; i++) {
157  double tmp = exp2(-i / 2048.0);
158  pow_table[i] = tmp;
159  pow_table[1024-i] = M_SQRT1_2 / tmp;
160  pow_table[1024+i] = tmp * M_SQRT1_2;
161  pow_table[2048-i] = 0.5 / tmp;
162  }
163  /* Generate overlap window */
165 }
166 
168 {
169  static AVOnce init_static_once = AV_ONCE_INIT;
171  int ret;
172 
173  if (avctx->channels != 1) {
174  av_log(avctx, AV_LOG_ERROR, "Nellymoser supports only 1 channel\n");
175  return AVERROR(EINVAL);
176  }
177 
178  if (avctx->sample_rate != 8000 && avctx->sample_rate != 16000 &&
179  avctx->sample_rate != 11025 &&
180  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
182  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
183  return AVERROR(EINVAL);
184  }
185 
186  avctx->frame_size = NELLY_SAMPLES;
188  ff_af_queue_init(avctx, &s->afq);
189  s->avctx = avctx;
190  if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
191  return ret;
193  if (!s->fdsp)
194  return AVERROR(ENOMEM);
195 
196  if (s->avctx->trellis) {
197  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
198  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
199  if (!s->opt || !s->path)
200  return AVERROR(ENOMEM);
201  }
202 
203  ff_thread_once(&init_static_once, nellymoser_init_static);
204 
205  return 0;
206 }
207 
208 #define find_best(val, table, LUT, LUT_add, LUT_size) \
209  best_idx = \
210  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
211  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
212  best_idx++;
213 
214 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
215 {
216  int band, best_idx, power_idx = 0;
217  float power_candidate;
218 
219  //base exponent
220  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
221  idx_table[0] = best_idx;
222  power_idx = ff_nelly_init_table[best_idx];
223 
224  for (band = 1; band < NELLY_BANDS; band++) {
225  power_candidate = cand[band] - power_idx;
226  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
227  idx_table[band] = best_idx;
228  power_idx += ff_nelly_delta_table[best_idx];
229  }
230 }
231 
232 static inline float distance(float x, float y, int band)
233 {
234  //return pow(fabs(x-y), 2.0);
235  float tmp = x - y;
236  return tmp * tmp;
237 }
238 
239 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
240 {
241  int i, j, band, best_idx;
242  float power_candidate, best_val;
243 
244  float (*opt )[OPT_SIZE] = s->opt ;
245  uint8_t(*path)[OPT_SIZE] = s->path;
246 
247  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
248  opt[0][i] = INFINITY;
249  }
250 
251  for (i = 0; i < 64; i++) {
252  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
253  path[0][ff_nelly_init_table[i]] = i;
254  }
255 
256  for (band = 1; band < NELLY_BANDS; band++) {
257  int q, c = 0;
258  float tmp;
259  int idx_min, idx_max, idx;
260  power_candidate = cand[band];
261  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
262  idx_min = FFMAX(0, cand[band] - q);
263  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
264  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
265  if ( isinf(opt[band - 1][i]) )
266  continue;
267  for (j = 0; j < 32; j++) {
268  idx = i + ff_nelly_delta_table[j];
269  if (idx > idx_max)
270  break;
271  if (idx >= idx_min) {
272  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
273  if (opt[band][idx] > tmp) {
274  opt[band][idx] = tmp;
275  path[band][idx] = j;
276  c = 1;
277  }
278  }
279  }
280  }
281  }
282  av_assert1(c); //FIXME
283  }
284 
285  best_val = INFINITY;
286  best_idx = -1;
287  band = NELLY_BANDS - 1;
288  for (i = 0; i < OPT_SIZE; i++) {
289  if (best_val > opt[band][i]) {
290  best_val = opt[band][i];
291  best_idx = i;
292  }
293  }
294  for (band = NELLY_BANDS - 1; band >= 0; band--) {
295  idx_table[band] = path[band][best_idx];
296  if (band) {
297  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
298  }
299  }
300 }
301 
302 /**
303  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
304  * @param s encoder context
305  * @param output output buffer
306  * @param output_size size of output buffer
307  */
308 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
309 {
310  PutBitContext pb;
311  int i, j, band, block, best_idx, power_idx = 0;
312  float power_val, coeff, coeff_sum;
313  float pows[NELLY_FILL_LEN];
314  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
315  float cand[NELLY_BANDS];
316 
317  apply_mdct(s);
318 
319  init_put_bits(&pb, output, output_size);
320 
321  i = 0;
322  for (band = 0; band < NELLY_BANDS; band++) {
323  coeff_sum = 0;
324  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
325  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
326  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
327  }
328  cand[band] =
329  log2(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0;
330  }
331 
332  if (s->avctx->trellis) {
333  get_exponent_dynamic(s, cand, idx_table);
334  } else {
335  get_exponent_greedy(s, cand, idx_table);
336  }
337 
338  i = 0;
339  for (band = 0; band < NELLY_BANDS; band++) {
340  if (band) {
341  power_idx += ff_nelly_delta_table[idx_table[band]];
342  put_bits(&pb, 5, idx_table[band]);
343  } else {
344  power_idx = ff_nelly_init_table[idx_table[0]];
345  put_bits(&pb, 6, idx_table[0]);
346  }
347  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
348  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
349  s->mdct_out[i] *= power_val;
350  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
351  pows[i] = power_idx;
352  }
353  }
354 
356 
357  for (block = 0; block < 2; block++) {
358  for (i = 0; i < NELLY_FILL_LEN; i++) {
359  if (bits[i] > 0) {
360  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
361  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
362  best_idx =
366  quant_lut_offset[bits[i]+1] - 1
367  )];
368  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
369  best_idx++;
370 
371  put_bits(&pb, bits[i], best_idx);
372  }
373  }
374  if (!block)
376  }
377 
378  flush_put_bits(&pb);
379  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
380 }
381 
382 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
383  const AVFrame *frame, int *got_packet_ptr)
384 {
386  int ret;
387 
388  if (s->last_frame)
389  return 0;
390 
391  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
392  if (frame) {
393  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
394  frame->nb_samples * sizeof(*s->buf));
395  if (frame->nb_samples < NELLY_SAMPLES) {
396  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
397  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
399  s->last_frame = 1;
400  }
401  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
402  return ret;
403  } else {
404  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
405  s->last_frame = 1;
406  }
407 
408  if ((ret = ff_alloc_packet2(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
409  return ret;
410  encode_block(s, avpkt->data, avpkt->size);
411 
412  /* Get the next frame pts/duration */
413  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
414  &avpkt->duration);
415 
416  *got_packet_ptr = 1;
417  return 0;
418 }
419 
421  .name = "nellymoser",
422  .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
423  .type = AVMEDIA_TYPE_AUDIO,
425  .priv_data_size = sizeof(NellyMoserEncodeContext),
426  .init = encode_init,
427  .encode2 = encode_frame,
428  .close = encode_end,
430  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
433 };
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]