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  /* faster way of doing
183  for (i = 0; i < POW_TABLE_SIZE; i++)
184  pow_table[i] = 2^(-i / 2048.0 - 3.0 + POW_TABLE_OFFSET); */
185  pow_table[0] = 1;
186  pow_table[1024] = M_SQRT1_2;
187  for (i = 1; i < 513; i++) {
188  double tmp = exp2(-i / 2048.0);
189  pow_table[i] = tmp;
190  pow_table[1024-i] = M_SQRT1_2 / tmp;
191  pow_table[1024+i] = tmp * M_SQRT1_2;
192  pow_table[2048-i] = 0.5 / tmp;
193  }
194 
195  if (s->avctx->trellis) {
196  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
197  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
198  if (!s->opt || !s->path) {
199  ret = AVERROR(ENOMEM);
200  goto error;
201  }
202  }
203 
204  return 0;
205 error:
206  encode_end(avctx);
207  return ret;
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 
357  ff_nelly_get_sample_bits(pows, bits);
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 =
365  quant_lut[av_clip (
366  coeff * quant_lut_mul[bits[i]] + quant_lut_add[bits[i]],
367  quant_lut_offset[bits[i]],
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));
400  if (frame->nb_samples >= NELLY_BUF_LEN)
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,
434 };
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
const char * s
Definition: avisynth_c.h:768
#define isinf(x)
Definition: libm.h:317
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
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:206
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]
#define M_SQRT1_2
Definition: mathematics.h:58
float mdct_out[NELLY_SAMPLES]
Definition: nellymoserenc.c:62
int size
Definition: avcodec.h:1591
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:39
AVCodec.
Definition: avcodec.h:3573
#define log2(x)
Definition: libm.h:404
#define NELLY_DETAIL_BITS
Definition: nellymoser.h:42
static int16_t block[64]
Definition: dct.c:113
#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:983
const uint16_t ff_nelly_init_table[64]
Definition: nellymoser.c:70
uint8_t bits
Definition: crc.c:296
uint8_t
#define av_cold
Definition: attributes.h:82
#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.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1608
static AVFrame * frame
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
uint8_t * data
Definition: avcodec.h:1590
#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:227
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:176
int initial_padding
Audio only.
Definition: avcodec.h:3349
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1754
static av_cold int encode_init(AVCodecContext *avctx)
const char * name
Name of the codec implementation.
Definition: avcodec.h:3580
#define ff_mdct_init
Definition: fft.h:169
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FFMAX(a, b)
Definition: common.h:94
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:885
#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:988
const uint8_t ff_nelly_band_sizes_table[NELLY_BANDS]
Definition: nellymoser.c:66
#define FFMIN(a, b)
Definition: common.h:96
#define POW_TABLE_OFFSET
Definition: nellymoserenc.c:53
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:2441
static const uint8_t quant_lut[230]
Definition: nellymoserenc.c:88
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2421
static const uint8_t sf_lut[96]
Definition: nellymoserenc.c:71
main external API structure.
Definition: avcodec.h:1659
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:64
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2880
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:119
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:1689
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
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 exp2(x)
Definition: libm.h:288
#define ff_mdct_end
Definition: fft.h:170
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:2758
void * priv_data
Definition: avcodec.h:1701
int channels
number of audio channels
Definition: avcodec.h:2422
static uint8_t tmp[8]
Definition: des.c:38
const int16_t ff_nelly_delta_table[32]
Definition: nellymoser.c:79
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
#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:116
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:1567
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:241
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2877
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1583
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