FFmpeg
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 "encode.h"
46 #include "fft.h"
47 #include "internal.h"
48 #include "nellymoser.h"
49 #include "sinewin.h"
50 
51 #define BITSTREAM_WRITER_LE
52 #include "put_bits.h"
53 
54 #define POW_TABLE_SIZE (1<<11)
55 #define POW_TABLE_OFFSET 3
56 #define OPT_SIZE ((1<<15) + 3000)
57 
58 typedef struct NellyMoserEncodeContext {
66  DECLARE_ALIGNED(32, float, buf)[3 * NELLY_BUF_LEN]; ///< sample buffer
67  float (*opt )[OPT_SIZE];
68  uint8_t (*path)[OPT_SIZE];
70 
71 static float pow_table[POW_TABLE_SIZE]; ///< pow(2, -i / 2048.0 - 3.0);
72 
73 static const uint8_t sf_lut[96] = {
74  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
75  5, 5, 5, 6, 7, 7, 8, 8, 9, 10, 11, 11, 12, 13, 13, 14,
76  15, 15, 16, 17, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24, 25, 26,
77  27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40,
78  41, 41, 42, 43, 44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 52, 53,
79  54, 55, 55, 56, 57, 57, 58, 59, 59, 60, 60, 60, 61, 61, 61, 62,
80 };
81 
82 static const uint8_t sf_delta_lut[78] = {
83  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
84  4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 10, 11, 11, 12,
85  13, 13, 14, 15, 16, 17, 17, 18, 19, 19, 20, 21, 21, 22, 22, 23,
86  23, 24, 24, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28,
87  28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30,
88 };
89 
90 static const uint8_t quant_lut[230] = {
91  0,
92 
93  0, 1, 2,
94 
95  0, 1, 2, 3, 4, 5, 6,
96 
97  0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11,
98  12, 13, 13, 13, 14,
99 
100  0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8,
101  8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
102  22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 29,
103  30,
104 
105  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3,
106  4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,
107  10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
108  15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20,
109  21, 21, 22, 22, 23, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32,
110  33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 42, 43, 44, 44, 45, 45,
111  46, 47, 47, 48, 48, 49, 49, 50, 50, 50, 51, 51, 51, 52, 52, 52,
112  53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56, 56, 57, 57, 57, 57,
113  58, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 61,
114  61, 61, 61, 61, 62,
115 };
116 
117 static const float quant_lut_mul[7] = { 0.0, 0.0, 2.0, 2.0, 5.0, 12.0, 36.6 };
118 static const float quant_lut_add[7] = { 0.0, 0.0, 2.0, 7.0, 21.0, 56.0, 157.0 };
119 static const uint8_t quant_lut_offset[8] = { 0, 0, 1, 4, 11, 32, 81, 230 };
120 
122 {
123  float *in0 = s->buf;
124  float *in1 = s->buf + NELLY_BUF_LEN;
125  float *in2 = s->buf + 2 * NELLY_BUF_LEN;
126 
127  s->fdsp->vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN);
128  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN);
129  s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out, s->in_buff);
130 
131  s->fdsp->vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN);
132  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN);
133  s->mdct_ctx.mdct_calc(&s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->in_buff);
134 }
135 
137 {
139 
140  ff_mdct_end(&s->mdct_ctx);
141 
142  av_freep(&s->opt);
143  av_freep(&s->path);
144  ff_af_queue_close(&s->afq);
145  av_freep(&s->fdsp);
146 
147  return 0;
148 }
149 
151 {
152  /* faster way of doing
153  for (int i = 0; i < POW_TABLE_SIZE; i++)
154  pow_table[i] = 2^(-i / 2048.0 - 3.0 + POW_TABLE_OFFSET); */
155  pow_table[0] = 1;
156  pow_table[1024] = M_SQRT1_2;
157  for (int i = 1; i < 513; i++) {
158  double tmp = exp2(-i / 2048.0);
159  pow_table[i] = tmp;
160  pow_table[1024-i] = M_SQRT1_2 / tmp;
161  pow_table[1024+i] = tmp * M_SQRT1_2;
162  pow_table[2048-i] = 0.5 / tmp;
163  }
164  /* Generate overlap window */
166 }
167 
169 {
170  static AVOnce init_static_once = AV_ONCE_INIT;
172  int ret;
173 
174  if (avctx->channels != 1) {
175  av_log(avctx, AV_LOG_ERROR, "Nellymoser supports only 1 channel\n");
176  return AVERROR(EINVAL);
177  }
178 
179  if (avctx->sample_rate != 8000 && avctx->sample_rate != 16000 &&
180  avctx->sample_rate != 11025 &&
181  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
183  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
184  return AVERROR(EINVAL);
185  }
186 
187  avctx->frame_size = NELLY_SAMPLES;
189  ff_af_queue_init(avctx, &s->afq);
190  s->avctx = avctx;
191  if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
192  return ret;
194  if (!s->fdsp)
195  return AVERROR(ENOMEM);
196 
197  if (s->avctx->trellis) {
198  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
199  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
200  if (!s->opt || !s->path)
201  return AVERROR(ENOMEM);
202  }
203 
204  ff_thread_once(&init_static_once, nellymoser_init_static);
205 
206  return 0;
207 }
208 
209 #define find_best(val, table, LUT, LUT_add, LUT_size) \
210  best_idx = \
211  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
212  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
213  best_idx++;
214 
215 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
216 {
217  int band, best_idx, power_idx = 0;
218  float power_candidate;
219 
220  //base exponent
221  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
222  idx_table[0] = best_idx;
223  power_idx = ff_nelly_init_table[best_idx];
224 
225  for (band = 1; band < NELLY_BANDS; band++) {
226  power_candidate = cand[band] - power_idx;
227  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
228  idx_table[band] = best_idx;
229  power_idx += ff_nelly_delta_table[best_idx];
230  }
231 }
232 
233 static inline float distance(float x, float y, int band)
234 {
235  //return pow(fabs(x-y), 2.0);
236  float tmp = x - y;
237  return tmp * tmp;
238 }
239 
240 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
241 {
242  int i, j, band, best_idx;
243  float power_candidate, best_val;
244 
245  float (*opt )[OPT_SIZE] = s->opt ;
246  uint8_t(*path)[OPT_SIZE] = s->path;
247 
248  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
249  opt[0][i] = INFINITY;
250  }
251 
252  for (i = 0; i < 64; i++) {
253  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
254  path[0][ff_nelly_init_table[i]] = i;
255  }
256 
257  for (band = 1; band < NELLY_BANDS; band++) {
258  int q, c = 0;
259  float tmp;
260  int idx_min, idx_max, idx;
261  power_candidate = cand[band];
262  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
263  idx_min = FFMAX(0, cand[band] - q);
264  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
265  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
266  if ( isinf(opt[band - 1][i]) )
267  continue;
268  for (j = 0; j < 32; j++) {
269  idx = i + ff_nelly_delta_table[j];
270  if (idx > idx_max)
271  break;
272  if (idx >= idx_min) {
273  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
274  if (opt[band][idx] > tmp) {
275  opt[band][idx] = tmp;
276  path[band][idx] = j;
277  c = 1;
278  }
279  }
280  }
281  }
282  }
283  av_assert1(c); //FIXME
284  }
285 
286  best_val = INFINITY;
287  best_idx = -1;
288  band = NELLY_BANDS - 1;
289  for (i = 0; i < OPT_SIZE; i++) {
290  if (best_val > opt[band][i]) {
291  best_val = opt[band][i];
292  best_idx = i;
293  }
294  }
295  for (band = NELLY_BANDS - 1; band >= 0; band--) {
296  idx_table[band] = path[band][best_idx];
297  if (band) {
298  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
299  }
300  }
301 }
302 
303 /**
304  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
305  * @param s encoder context
306  * @param output output buffer
307  * @param output_size size of output buffer
308  */
309 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
310 {
311  PutBitContext pb;
312  int i, j, band, block, best_idx, power_idx = 0;
313  float power_val, coeff, coeff_sum;
314  float pows[NELLY_FILL_LEN];
315  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
316  float cand[NELLY_BANDS];
317 
318  apply_mdct(s);
319 
320  init_put_bits(&pb, output, output_size);
321 
322  i = 0;
323  for (band = 0; band < NELLY_BANDS; band++) {
324  coeff_sum = 0;
325  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
326  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
327  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
328  }
329  cand[band] =
330  log2(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0;
331  }
332 
333  if (s->avctx->trellis) {
334  get_exponent_dynamic(s, cand, idx_table);
335  } else {
336  get_exponent_greedy(s, cand, idx_table);
337  }
338 
339  i = 0;
340  for (band = 0; band < NELLY_BANDS; band++) {
341  if (band) {
342  power_idx += ff_nelly_delta_table[idx_table[band]];
343  put_bits(&pb, 5, idx_table[band]);
344  } else {
345  power_idx = ff_nelly_init_table[idx_table[0]];
346  put_bits(&pb, 6, idx_table[0]);
347  }
348  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
349  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
350  s->mdct_out[i] *= power_val;
351  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
352  pows[i] = power_idx;
353  }
354  }
355 
357 
358  for (block = 0; block < 2; block++) {
359  for (i = 0; i < NELLY_FILL_LEN; i++) {
360  if (bits[i] > 0) {
361  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
362  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
363  best_idx =
367  quant_lut_offset[bits[i]+1] - 1
368  )];
369  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
370  best_idx++;
371 
372  put_bits(&pb, bits[i], best_idx);
373  }
374  }
375  if (!block)
377  }
378 
379  flush_put_bits(&pb);
380  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
381 }
382 
383 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
384  const AVFrame *frame, int *got_packet_ptr)
385 {
387  int ret;
388 
389  if (s->last_frame)
390  return 0;
391 
392  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
393  if (frame) {
394  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
395  frame->nb_samples * sizeof(*s->buf));
396  if (frame->nb_samples < NELLY_SAMPLES) {
397  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
398  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
399  if (frame->nb_samples >= NELLY_BUF_LEN)
400  s->last_frame = 1;
401  }
402  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
403  return ret;
404  } else {
405  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
406  s->last_frame = 1;
407  }
408 
409  if ((ret = ff_get_encode_buffer(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
410  return ret;
411  encode_block(s, avpkt->data, avpkt->size);
412 
413  /* Get the next frame pts/duration */
414  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
415  &avpkt->duration);
416 
417  *got_packet_ptr = 1;
418  return 0;
419 }
420 
422  .name = "nellymoser",
423  .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
424  .type = AVMEDIA_TYPE_AUDIO,
426  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
428  .priv_data_size = sizeof(NellyMoserEncodeContext),
429  .init = encode_init,
430  .encode2 = encode_frame,
431  .close = encode_end,
432  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
435 };
NellyMoserEncodeContext::fdsp
AVFloatDSPContext * fdsp
Definition: nellymoserenc.c:61
quant_lut_mul
static const float quant_lut_mul[7]
Definition: nellymoserenc.c:117
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1012
AVCodec
AVCodec.
Definition: codec.h:202
NELLY_HEADER_BITS
#define NELLY_HEADER_BITS
Definition: nellymoser.h:41
FF_CODEC_CAP_INIT_THREADSAFE
#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:42
av_clip
#define av_clip
Definition: common.h:96
INFINITY
#define INFINITY
Definition: mathematics.h:67
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
quant_lut_add
static const float quant_lut_add[7]
Definition: nellymoserenc.c:118
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
pow_table
static float pow_table[POW_TABLE_SIZE]
pow(2, -i / 2048.0 - 3.0);
Definition: nellymoserenc.c:71
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: nellymoserenc.c:168
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
nellymoser_init_static
static av_cold void nellymoser_init_static(void)
Definition: nellymoserenc.c:150
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
nellymoser.h
thread.h
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
get_exponent_greedy
static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
Definition: nellymoserenc.c:215
NELLY_FILL_LEN
#define NELLY_FILL_LEN
Definition: nellymoser.h:44
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
encode.h
NellyMoserEncodeContext::opt
float(* opt)[OPT_SIZE]
Definition: nellymoserenc.c:67
table
static const uint16_t table[]
Definition: prosumer.c:206
NELLY_BLOCK_LEN
#define NELLY_BLOCK_LEN
Definition: nellymoser.h:40
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
NellyMoserEncodeContext::in_buff
float in_buff[NELLY_SAMPLES]
Definition: nellymoserenc.c:65
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
mathematics.h
NellyMoserEncodeContext::path
uint8_t(* path)[OPT_SIZE]
Definition: nellymoserenc.c:68
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
ff_nelly_band_sizes_table
const uint8_t ff_nelly_band_sizes_table[NELLY_BANDS]
Definition: nellymoser.c:68
audio_frame_queue.h
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1701
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
ff_nelly_dequantization_table
const float ff_nelly_dequantization_table[127]
Definition: nellymoser.c:41
NellyMoserEncodeContext
Definition: nellymoserenc.c:58
POW_TABLE_SIZE
#define POW_TABLE_SIZE
Definition: nellymoserenc.c:54
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
NellyMoserEncodeContext::buf
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:66
s
#define s(width, name)
Definition: cbs_vp9.c:257
POW_TABLE_OFFSET
#define POW_TABLE_OFFSET
Definition: nellymoserenc.c:55
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
NELLY_BANDS
#define NELLY_BANDS
Definition: nellymoser.h:39
bits
uint8_t bits
Definition: vp3data.h:141
encode_block
static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
Encode NELLY_SAMPLES samples.
Definition: nellymoserenc.c:309
AudioFrameQueue
Definition: audio_frame_queue.h:32
sf_lut
static const uint8_t sf_lut[96]
Definition: nellymoserenc.c:73
ff_nelly_init_table
const uint16_t ff_nelly_init_table[64]
Definition: nellymoser.c:72
PutBitContext
Definition: put_bits.h:49
ff_nelly_delta_table
const int16_t ff_nelly_delta_table[32]
Definition: nellymoser.c:81
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NELLY_DETAIL_BITS
#define NELLY_DETAIL_BITS
Definition: nellymoser.h:42
quant_lut_offset
static const uint8_t quant_lut_offset[8]
Definition: nellymoserenc.c:119
isinf
#define isinf(x)
Definition: libm.h:317
NellyMoserEncodeContext::mdct_ctx
FFTContext mdct_ctx
Definition: nellymoserenc.c:62
AVOnce
#define AVOnce
Definition: thread.h:172
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
float_dsp.h
sf_delta_lut
static const uint8_t sf_delta_lut[78]
Definition: nellymoserenc.c:82
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:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
find_best
#define find_best(val, table, LUT, LUT_add, LUT_size)
Definition: nellymoserenc.c:209
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:154
NELLY_BUF_LEN
#define NELLY_BUF_LEN
Definition: nellymoser.h:43
AVFloatDSPContext
Definition: float_dsp.h:24
sinewin.h
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1283
NELLY_SAMPLES
#define NELLY_SAMPLES
Definition: nellymoser.h:48
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
NellyMoserEncodeContext::avctx
AVCodecContext * avctx
Definition: nellymoserenc.c:59
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
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: internal.h:50
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
exp2
#define exp2(x)
Definition: libm.h:288
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
ret
ret
Definition: filter_design.txt:187
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
NellyMoserEncodeContext::afq
AudioFrameQueue afq
Definition: nellymoserenc.c:63
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1280
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:383
put_bits_ptr
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:369
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
NellyMoserEncodeContext::mdct_out
float mdct_out[NELLY_SAMPLES]
Definition: nellymoserenc.c:64
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
OPT_SIZE
#define OPT_SIZE
Definition: nellymoserenc.c:56
AV_CODEC_CAP_DELAY
#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:82
ff_nellymoser_encoder
const AVCodec ff_nellymoser_encoder
Definition: nellymoserenc.c:421
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: nellymoserenc.c:136
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: nellymoserenc.c:383
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
quant_lut
static const uint8_t quant_lut[230]
Definition: nellymoserenc.c:90
get_exponent_dynamic
static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
Definition: nellymoserenc.c:240
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
apply_mdct
static void apply_mdct(NellyMoserEncodeContext *s)
Definition: nellymoserenc.c:121
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:233
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:87
put_bits.h
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
NellyMoserEncodeContext::last_frame
int last_frame
Definition: nellymoserenc.c:60
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:455
ff_nelly_get_sample_bits
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:118