FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
42 #include "audio_frame_queue.h"
43 #include "avcodec.h"
44 #include "fft.h"
45 #include "internal.h"
46 #include "nellymoser.h"
47 #include "sinewin.h"
48 
49 #define BITSTREAM_WRITER_LE
50 #include "put_bits.h"
51 
52 #define POW_TABLE_SIZE (1<<11)
53 #define POW_TABLE_OFFSET 3
54 #define OPT_SIZE ((1<<15) + 3000)
55 
56 typedef struct NellyMoserEncodeContext {
64  DECLARE_ALIGNED(32, float, buf)[3 * NELLY_BUF_LEN]; ///< sample buffer
65  float (*opt )[OPT_SIZE];
68 
69 static float pow_table[POW_TABLE_SIZE]; ///< pow(2, -i / 2048.0 - 3.0);
70 
71 static const uint8_t sf_lut[96] = {
72  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
73  5, 5, 5, 6, 7, 7, 8, 8, 9, 10, 11, 11, 12, 13, 13, 14,
74  15, 15, 16, 17, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24, 25, 26,
75  27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40,
76  41, 41, 42, 43, 44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 52, 53,
77  54, 55, 55, 56, 57, 57, 58, 59, 59, 60, 60, 60, 61, 61, 61, 62,
78 };
79 
80 static const uint8_t sf_delta_lut[78] = {
81  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
82  4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 10, 11, 11, 12,
83  13, 13, 14, 15, 16, 17, 17, 18, 19, 19, 20, 21, 21, 22, 22, 23,
84  23, 24, 24, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28,
85  28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30,
86 };
87 
88 static const uint8_t quant_lut[230] = {
89  0,
90 
91  0, 1, 2,
92 
93  0, 1, 2, 3, 4, 5, 6,
94 
95  0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11,
96  12, 13, 13, 13, 14,
97 
98  0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8,
99  8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
100  22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 29,
101  30,
102 
103  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3,
104  4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,
105  10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
106  15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20,
107  21, 21, 22, 22, 23, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32,
108  33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 42, 43, 44, 44, 45, 45,
109  46, 47, 47, 48, 48, 49, 49, 50, 50, 50, 51, 51, 51, 52, 52, 52,
110  53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56, 56, 57, 57, 57, 57,
111  58, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 61,
112  61, 61, 61, 61, 62,
113 };
114 
115 static const float quant_lut_mul[7] = { 0.0, 0.0, 2.0, 2.0, 5.0, 12.0, 36.6 };
116 static const float quant_lut_add[7] = { 0.0, 0.0, 2.0, 7.0, 21.0, 56.0, 157.0 };
117 static const uint8_t quant_lut_offset[8] = { 0, 0, 1, 4, 11, 32, 81, 230 };
118 
120 {
121  float *in0 = s->buf;
122  float *in1 = s->buf + NELLY_BUF_LEN;
123  float *in2 = s->buf + 2 * NELLY_BUF_LEN;
124 
125  s->fdsp->vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN);
126  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN);
127  s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);
128 
129  s->fdsp->vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN);
130  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN);
132 }
133 
135 {
137 
138  ff_mdct_end(&s->mdct_ctx);
139 
140  if (s->avctx->trellis) {
141  av_freep(&s->opt);
142  av_freep(&s->path);
143  }
144  ff_af_queue_close(&s->afq);
145  av_freep(&s->fdsp);
146 
147  return 0;
148 }
149 
151 {
153  int i, ret;
154 
155  if (avctx->channels != 1) {
156  av_log(avctx, AV_LOG_ERROR, "Nellymoser supports only 1 channel\n");
157  return AVERROR(EINVAL);
158  }
159 
160  if (avctx->sample_rate != 8000 && avctx->sample_rate != 16000 &&
161  avctx->sample_rate != 11025 &&
162  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
164  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
165  return AVERROR(EINVAL);
166  }
167 
168  avctx->frame_size = NELLY_SAMPLES;
170  ff_af_queue_init(avctx, &s->afq);
171  s->avctx = avctx;
172  if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
173  goto error;
175  if (!s->fdsp) {
176  ret = AVERROR(ENOMEM);
177  goto error;
178  }
179 
180  /* Generate overlap window */
182  for (i = 0; i < POW_TABLE_SIZE; i++)
183  pow_table[i] = pow(2, -i / 2048.0 - 3.0 + POW_TABLE_OFFSET);
184 
185  if (s->avctx->trellis) {
186  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
187  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
188  if (!s->opt || !s->path) {
189  ret = AVERROR(ENOMEM);
190  goto error;
191  }
192  }
193 
194  return 0;
195 error:
196  encode_end(avctx);
197  return ret;
198 }
199 
200 #define find_best(val, table, LUT, LUT_add, LUT_size) \
201  best_idx = \
202  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
203  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
204  best_idx++;
205 
206 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
207 {
208  int band, best_idx, power_idx = 0;
209  float power_candidate;
210 
211  //base exponent
212  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
213  idx_table[0] = best_idx;
214  power_idx = ff_nelly_init_table[best_idx];
215 
216  for (band = 1; band < NELLY_BANDS; band++) {
217  power_candidate = cand[band] - power_idx;
218  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
219  idx_table[band] = best_idx;
220  power_idx += ff_nelly_delta_table[best_idx];
221  }
222 }
223 
224 static inline float distance(float x, float y, int band)
225 {
226  //return pow(fabs(x-y), 2.0);
227  float tmp = x - y;
228  return tmp * tmp;
229 }
230 
231 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
232 {
233  int i, j, band, best_idx;
234  float power_candidate, best_val;
235 
236  float (*opt )[OPT_SIZE] = s->opt ;
237  uint8_t(*path)[OPT_SIZE] = s->path;
238 
239  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
240  opt[0][i] = INFINITY;
241  }
242 
243  for (i = 0; i < 64; i++) {
244  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
245  path[0][ff_nelly_init_table[i]] = i;
246  }
247 
248  for (band = 1; band < NELLY_BANDS; band++) {
249  int q, c = 0;
250  float tmp;
251  int idx_min, idx_max, idx;
252  power_candidate = cand[band];
253  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
254  idx_min = FFMAX(0, cand[band] - q);
255  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
256  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
257  if ( isinf(opt[band - 1][i]) )
258  continue;
259  for (j = 0; j < 32; j++) {
260  idx = i + ff_nelly_delta_table[j];
261  if (idx > idx_max)
262  break;
263  if (idx >= idx_min) {
264  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
265  if (opt[band][idx] > tmp) {
266  opt[band][idx] = tmp;
267  path[band][idx] = j;
268  c = 1;
269  }
270  }
271  }
272  }
273  }
274  av_assert1(c); //FIXME
275  }
276 
277  best_val = INFINITY;
278  best_idx = -1;
279  band = NELLY_BANDS - 1;
280  for (i = 0; i < OPT_SIZE; i++) {
281  if (best_val > opt[band][i]) {
282  best_val = opt[band][i];
283  best_idx = i;
284  }
285  }
286  for (band = NELLY_BANDS - 1; band >= 0; band--) {
287  idx_table[band] = path[band][best_idx];
288  if (band) {
289  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
290  }
291  }
292 }
293 
294 /**
295  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
296  * @param s encoder context
297  * @param output output buffer
298  * @param output_size size of output buffer
299  */
300 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
301 {
302  PutBitContext pb;
303  int i, j, band, block, best_idx, power_idx = 0;
304  float power_val, coeff, coeff_sum;
305  float pows[NELLY_FILL_LEN];
306  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
307  float cand[NELLY_BANDS];
308 
309  apply_mdct(s);
310 
311  init_put_bits(&pb, output, output_size);
312 
313  i = 0;
314  for (band = 0; band < NELLY_BANDS; band++) {
315  coeff_sum = 0;
316  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
317  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
318  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
319  }
320  cand[band] =
321  log(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0 / M_LN2;
322  }
323 
324  if (s->avctx->trellis) {
325  get_exponent_dynamic(s, cand, idx_table);
326  } else {
327  get_exponent_greedy(s, cand, idx_table);
328  }
329 
330  i = 0;
331  for (band = 0; band < NELLY_BANDS; band++) {
332  if (band) {
333  power_idx += ff_nelly_delta_table[idx_table[band]];
334  put_bits(&pb, 5, idx_table[band]);
335  } else {
336  power_idx = ff_nelly_init_table[idx_table[0]];
337  put_bits(&pb, 6, idx_table[0]);
338  }
339  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
340  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
341  s->mdct_out[i] *= power_val;
342  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
343  pows[i] = power_idx;
344  }
345  }
346 
347  ff_nelly_get_sample_bits(pows, bits);
348 
349  for (block = 0; block < 2; block++) {
350  for (i = 0; i < NELLY_FILL_LEN; i++) {
351  if (bits[i] > 0) {
352  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
353  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
354  best_idx =
355  quant_lut[av_clip (
356  coeff * quant_lut_mul[bits[i]] + quant_lut_add[bits[i]],
357  quant_lut_offset[bits[i]],
358  quant_lut_offset[bits[i]+1] - 1
359  )];
360  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
361  best_idx++;
362 
363  put_bits(&pb, bits[i], best_idx);
364  }
365  }
366  if (!block)
368  }
369 
370  flush_put_bits(&pb);
371  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
372 }
373 
374 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
375  const AVFrame *frame, int *got_packet_ptr)
376 {
378  int ret;
379 
380  if (s->last_frame)
381  return 0;
382 
383  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
384  if (frame) {
385  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
386  frame->nb_samples * sizeof(*s->buf));
387  if (frame->nb_samples < NELLY_SAMPLES) {
388  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
389  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
390  if (frame->nb_samples >= NELLY_BUF_LEN)
391  s->last_frame = 1;
392  }
393  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
394  return ret;
395  } else {
396  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
397  s->last_frame = 1;
398  }
399 
400  if ((ret = ff_alloc_packet2(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
401  return ret;
402  encode_block(s, avpkt->data, avpkt->size);
403 
404  /* Get the next frame pts/duration */
405  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
406  &avpkt->duration);
407 
408  *got_packet_ptr = 1;
409  return 0;
410 }
411 
413  .name = "nellymoser",
414  .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
415  .type = AVMEDIA_TYPE_AUDIO,
417  .priv_data_size = sizeof(NellyMoserEncodeContext),
418  .init = encode_init,
419  .encode2 = encode_frame,
420  .close = encode_end,
422  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
424 };
const char * s
Definition: avisynth_c.h:631
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:109
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:167
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_cold int encode_end(AVCodecContext *avctx)
static const float quant_lut_add[7]
float mdct_out[NELLY_SAMPLES]
Definition: nellymoserenc.c:62
int size
Definition: avcodec.h:1423
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
static void apply_mdct(NellyMoserEncodeContext *s)
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:138
const float ff_nelly_dequantization_table[127]
Definition: nellymoser.c:40
AVCodec.
Definition: avcodec.h:3473
#define NELLY_DETAIL_BITS
Definition: nellymoser.h:42
#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: avcodec.h:881
const uint16_t ff_nelly_init_table[64]
Definition: nellymoser.c:71
uint8_t bits
Definition: crc.c:295
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1422
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1440
#define av_log(a,...)
AVFloatDSPContext * fdsp
Definition: nellymoserenc.c:59
static float pow_table[POW_TABLE_SIZE]
pow(2, -i / 2048.0 - 3.0);
Definition: nellymoserenc.c:69
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:219
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
#define AVERROR(e)
Definition: error.h:43
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
int initial_padding
Audio only.
Definition: avcodec.h:3295
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2822
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1596
static av_cold int encode_init(AVCodecContext *avctx)
const char * name
Name of the codec implementation.
Definition: avcodec.h:3480
#define ff_mdct_init
Definition: fft.h:167
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FFMAX(a, b)
Definition: common.h:64
Libavcodec external API header.
AudioFrameQueue afq
Definition: nellymoserenc.c:61
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
static float distance(float x, float y, int band)
float in_buff[NELLY_SAMPLES]
Definition: nellymoserenc.c:63
Definition: fft.h:88
uint8_t(* path)[OPT_SIZE]
Definition: nellymoserenc.c:66
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:787
#define M_LN2
Definition: mathematics.h:34
#define NELLY_BLOCK_LEN
Definition: nellymoser.h:40
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:886
const uint8_t ff_nelly_band_sizes_table[NELLY_BANDS]
Definition: nellymoser.c:67
#define FFMIN(a, b)
Definition: common.h:66
float y
#define POW_TABLE_OFFSET
Definition: nellymoserenc.c:53
ret
Definition: avfilter.c:974
AVCodecContext * avctx
Definition: nellymoserenc.c:57
#define NELLY_HEADER_BITS
Definition: nellymoser.h:41
AVCodec ff_nellymoser_encoder
float(* opt)[OPT_SIZE]
Definition: nellymoserenc.c:65
#define INFINITY
Definition: math.h:27
#define OPT_SIZE
Definition: nellymoserenc.c:54
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2281
static const uint8_t quant_lut[230]
Definition: nellymoserenc.c:88
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
int sample_rate
samples per second
Definition: avcodec.h:2261
static const uint8_t sf_lut[96]
Definition: nellymoserenc.c:71
main external API structure.
Definition: avcodec.h:1501
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:64
static const uint8_t quant_lut_offset[8]
#define find_best(val, table, LUT, LUT_add, LUT_size)
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:143
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1780
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
common internal and external API header
#define ff_mdct_end
Definition: fft.h:168
static double c[64]
#define NELLY_BUF_LEN
Definition: nellymoser.h:43
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
Encode NELLY_SAMPLES samples.
int trellis
trellis RD quantization
Definition: avcodec.h:2712
void * priv_data
Definition: avcodec.h:1543
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int *duration)
Remove frame(s) from the queue.
int channels
number of audio channels
Definition: avcodec.h:2262
const int16_t ff_nelly_delta_table[32]
Definition: nellymoser.c:80
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
static av_always_inline av_const int isinf(float x)
Definition: libm.h:86
#define NELLY_BANDS
Definition: nellymoser.h:39
#define av_freep(p)
#define POW_TABLE_SIZE
Definition: nellymoserenc.c:52
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:117
The 3 alphanumeric copyright notices are md5summed they are from the original implementors.
#define NELLY_SAMPLES
Definition: nellymoser.h:48
This structure stores compressed data.
Definition: avcodec.h:1399
static const float quant_lut_mul[7]
#define NELLY_FILL_LEN
Definition: nellymoser.h:44
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:225
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2819
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1415
void AAC_RENAME() ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
static const uint8_t sf_delta_lut[78]
Definition: nellymoserenc.c:80
bitstream writer API
static int16_t block[64]
Definition: dct-test.c:110