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 #include "libavutil/tx.h"
43 
44 #include "audio_frame_queue.h"
45 #include "avcodec.h"
46 #include "codec_internal.h"
47 #include "encode.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 {
67  DECLARE_ALIGNED(32, float, buf)[3 * NELLY_BUF_LEN]; ///< sample buffer
69  uint8_t (*path)[OPT_SIZE];
71 
72 static float pow_table[POW_TABLE_SIZE]; ///< pow(2, -i / 2048.0 - 3.0);
73 
74 static const uint8_t sf_lut[96] = {
75  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
76  5, 5, 5, 6, 7, 7, 8, 8, 9, 10, 11, 11, 12, 13, 13, 14,
77  15, 15, 16, 17, 17, 18, 19, 19, 20, 21, 22, 22, 23, 24, 25, 26,
78  27, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40,
79  41, 41, 42, 43, 44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 52, 53,
80  54, 55, 55, 56, 57, 57, 58, 59, 59, 60, 60, 60, 61, 61, 61, 62,
81 };
82 
83 static const uint8_t sf_delta_lut[78] = {
84  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4,
85  4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 10, 11, 11, 12,
86  13, 13, 14, 15, 16, 17, 17, 18, 19, 19, 20, 21, 21, 22, 22, 23,
87  23, 24, 24, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28,
88  28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 30,
89 };
90 
91 static const uint8_t quant_lut[230] = {
92  0,
93 
94  0, 1, 2,
95 
96  0, 1, 2, 3, 4, 5, 6,
97 
98  0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11,
99  12, 13, 13, 13, 14,
100 
101  0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8,
102  8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
103  22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 29,
104  30,
105 
106  0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3,
107  4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9,
108  10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
109  15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 20, 20, 20,
110  21, 21, 22, 22, 23, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32,
111  33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 42, 43, 44, 44, 45, 45,
112  46, 47, 47, 48, 48, 49, 49, 50, 50, 50, 51, 51, 51, 52, 52, 52,
113  53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56, 56, 57, 57, 57, 57,
114  58, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 61,
115  61, 61, 61, 61, 62,
116 };
117 
118 static const float quant_lut_mul[7] = { 0.0, 0.0, 2.0, 2.0, 5.0, 12.0, 36.6 };
119 static const float quant_lut_add[7] = { 0.0, 0.0, 2.0, 7.0, 21.0, 56.0, 157.0 };
120 static const uint8_t quant_lut_offset[8] = { 0, 0, 1, 4, 11, 32, 81, 230 };
121 
123 {
124  float *in0 = s->buf;
125  float *in1 = s->buf + NELLY_BUF_LEN;
126  float *in2 = s->buf + 2 * NELLY_BUF_LEN;
127 
128  s->fdsp->vector_fmul (s->in_buff, in0, ff_sine_128, NELLY_BUF_LEN);
129  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in1, ff_sine_128, NELLY_BUF_LEN);
130  s->mdct_fn(s->mdct_ctx, s->mdct_out, s->in_buff, sizeof(float));
131 
132  s->fdsp->vector_fmul (s->in_buff, in1, ff_sine_128, NELLY_BUF_LEN);
133  s->fdsp->vector_fmul_reverse(s->in_buff + NELLY_BUF_LEN, in2, ff_sine_128, NELLY_BUF_LEN);
134  s->mdct_fn(s->mdct_ctx, s->mdct_out + NELLY_BUF_LEN, s->in_buff, sizeof(float));
135 }
136 
138 {
140 
141  av_tx_uninit(&s->mdct_ctx);
142 
143  av_freep(&s->opt);
144  av_freep(&s->path);
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  float scale = 32768.0;
174  int ret;
175 
176  if (avctx->sample_rate != 8000 && avctx->sample_rate != 16000 &&
177  avctx->sample_rate != 11025 &&
178  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
180  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
181  return AVERROR(EINVAL);
182  }
183 
184  avctx->frame_size = NELLY_SAMPLES;
186  ff_af_queue_init(avctx, &s->afq);
187  s->avctx = avctx;
188  if ((ret = av_tx_init(&s->mdct_ctx, &s->mdct_fn, AV_TX_FLOAT_MDCT, 0, 128, &scale, 0)) < 0)
189  return ret;
191  if (!s->fdsp)
192  return AVERROR(ENOMEM);
193 
194  if (s->avctx->trellis) {
195  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
196  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
197  if (!s->opt || !s->path)
198  return AVERROR(ENOMEM);
199  }
200 
201  ff_thread_once(&init_static_once, nellymoser_init_static);
202 
203  return 0;
204 }
205 
206 #define find_best(val, table, LUT, LUT_add, LUT_size) \
207  best_idx = \
208  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
209  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
210  best_idx++;
211 
212 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
213 {
214  int band, best_idx, power_idx = 0;
215  float power_candidate;
216 
217  //base exponent
218  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
219  idx_table[0] = best_idx;
220  power_idx = ff_nelly_init_table[best_idx];
221 
222  for (band = 1; band < NELLY_BANDS; band++) {
223  power_candidate = cand[band] - power_idx;
224  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
225  idx_table[band] = best_idx;
226  power_idx += ff_nelly_delta_table[best_idx];
227  }
228 }
229 
230 static inline float distance(float x, float y, int band)
231 {
232  //return pow(fabs(x-y), 2.0);
233  float tmp = x - y;
234  return tmp * tmp;
235 }
236 
237 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
238 {
239  int i, j, band, best_idx;
240  float power_candidate, best_val;
241 
242  float (*opt )[OPT_SIZE] = s->opt ;
243  uint8_t(*path)[OPT_SIZE] = s->path;
244 
245  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
246  opt[0][i] = INFINITY;
247  }
248 
249  for (i = 0; i < 64; i++) {
250  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
251  path[0][ff_nelly_init_table[i]] = i;
252  }
253 
254  for (band = 1; band < NELLY_BANDS; band++) {
255  int q, c = 0;
256  float tmp;
257  int idx_min, idx_max, idx;
258  power_candidate = cand[band];
259  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
260  idx_min = FFMAX(0, cand[band] - q);
261  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
262  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
263  if ( isinf(opt[band - 1][i]) )
264  continue;
265  for (j = 0; j < 32; j++) {
266  idx = i + ff_nelly_delta_table[j];
267  if (idx > idx_max)
268  break;
269  if (idx >= idx_min) {
270  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
271  if (opt[band][idx] > tmp) {
272  opt[band][idx] = tmp;
273  path[band][idx] = j;
274  c = 1;
275  }
276  }
277  }
278  }
279  }
280  av_assert1(c); //FIXME
281  }
282 
283  best_val = INFINITY;
284  best_idx = -1;
285  band = NELLY_BANDS - 1;
286  for (i = 0; i < OPT_SIZE; i++) {
287  if (best_val > opt[band][i]) {
288  best_val = opt[band][i];
289  best_idx = i;
290  }
291  }
292  for (band = NELLY_BANDS - 1; band >= 0; band--) {
293  idx_table[band] = path[band][best_idx];
294  if (band) {
295  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
296  }
297  }
298 }
299 
300 /**
301  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
302  * @param s encoder context
303  * @param output output buffer
304  * @param output_size size of output buffer
305  */
306 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
307 {
308  PutBitContext pb;
309  int i, j, band, block, best_idx, power_idx = 0;
310  float power_val, coeff, coeff_sum;
311  float pows[NELLY_FILL_LEN];
312  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
313  float cand[NELLY_BANDS];
314 
315  apply_mdct(s);
316 
317  init_put_bits(&pb, output, output_size);
318 
319  i = 0;
320  for (band = 0; band < NELLY_BANDS; band++) {
321  coeff_sum = 0;
322  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
323  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
324  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
325  }
326  cand[band] =
327  log2(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0;
328  }
329 
330  if (s->avctx->trellis) {
331  get_exponent_dynamic(s, cand, idx_table);
332  } else {
333  get_exponent_greedy(s, cand, idx_table);
334  }
335 
336  i = 0;
337  for (band = 0; band < NELLY_BANDS; band++) {
338  if (band) {
339  power_idx += ff_nelly_delta_table[idx_table[band]];
340  put_bits(&pb, 5, idx_table[band]);
341  } else {
342  power_idx = ff_nelly_init_table[idx_table[0]];
343  put_bits(&pb, 6, idx_table[0]);
344  }
345  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
346  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
347  s->mdct_out[i] *= power_val;
348  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
349  pows[i] = power_idx;
350  }
351  }
352 
354 
355  for (block = 0; block < 2; block++) {
356  for (i = 0; i < NELLY_FILL_LEN; i++) {
357  if (bits[i] > 0) {
358  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
359  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
360  best_idx =
364  quant_lut_offset[bits[i]+1] - 1
365  )];
366  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
367  best_idx++;
368 
369  put_bits(&pb, bits[i], best_idx);
370  }
371  }
372  if (!block)
374  }
375 
376  flush_put_bits(&pb);
377  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
378 }
379 
380 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
381  const AVFrame *frame, int *got_packet_ptr)
382 {
384  int ret;
385 
386  if (s->last_frame)
387  return 0;
388 
389  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
390  if (frame) {
391  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
392  frame->nb_samples * sizeof(*s->buf));
393  if (frame->nb_samples < NELLY_SAMPLES) {
394  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
395  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
396  if (frame->nb_samples >= NELLY_BUF_LEN)
397  s->last_frame = 1;
398  }
399  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
400  return ret;
401  } else {
402  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
403  s->last_frame = 1;
404  }
405 
406  if ((ret = ff_get_encode_buffer(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
407  return ret;
408  encode_block(s, avpkt->data, avpkt->size);
409 
410  /* Get the next frame pts/duration */
411  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
412  &avpkt->duration);
413 
414  *got_packet_ptr = 1;
415  return 0;
416 }
417 
419  .p.name = "nellymoser",
420  CODEC_LONG_NAME("Nellymoser Asao"),
421  .p.type = AVMEDIA_TYPE_AUDIO,
422  .p.id = AV_CODEC_ID_NELLYMOSER,
423  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
425  .priv_data_size = sizeof(NellyMoserEncodeContext),
426  .init = encode_init,
428  .close = encode_end,
429  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
431  .p.ch_layouts = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
432  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
433 };
NellyMoserEncodeContext::fdsp
AVFloatDSPContext * fdsp
Definition: nellymoserenc.c:61
quant_lut_mul
static const float quant_lut_mul[7]
Definition: nellymoserenc.c:118
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1035
NELLY_HEADER_BITS
#define NELLY_HEADER_BITS
Definition: nellymoser.h:41
av_clip
#define av_clip
Definition: common.h:95
INFINITY
#define INFINITY
Definition: mathematics.h:67
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: codec_internal.h:42
quant_lut_add
static const float quant_lut_add[7]
Definition: nellymoserenc.c:119
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:72
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:169
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
nellymoser_init_static
static av_cold void nellymoser_init_static(void)
Definition: nellymoserenc.c:151
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
nellymoser.h
thread.h
AVTXContext
Definition: tx_priv.h:228
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:62
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:212
NELLY_FILL_LEN
#define NELLY_FILL_LEN
Definition: nellymoser.h:44
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:374
encode.h
NellyMoserEncodeContext::opt
float(* opt)[OPT_SIZE]
Definition: nellymoserenc.c:68
table
static const uint16_t table[]
Definition: prosumer.c:205
NELLY_BLOCK_LEN
#define NELLY_BLOCK_LEN
Definition: nellymoser.h:40
FFCodec
Definition: codec_internal.h:119
NellyMoserEncodeContext::in_buff
float in_buff[NELLY_SAMPLES]
Definition: nellymoserenc.c:66
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
mathematics.h
NellyMoserEncodeContext::path
uint8_t(* path)[OPT_SIZE]
Definition: nellymoserenc.c:69
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:883
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
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:1726
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:307
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:184
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
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:127
NellyMoserEncodeContext::buf
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:67
float
float
Definition: af_crystalizer.c:122
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
s
#define s(width, name)
Definition: cbs_vp9.c:256
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
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
bits
uint8_t bits
Definition: vp3data.h:128
encode_block
static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
Encode NELLY_SAMPLES samples.
Definition: nellymoserenc.c:306
AudioFrameQueue
Definition: audio_frame_queue.h:32
sf_lut
static const uint8_t sf_lut[96]
Definition: nellymoserenc.c:74
ff_nelly_init_table
const uint16_t ff_nelly_init_table[64]
Definition: nellymoser.c:72
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:182
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:120
isinf
#define isinf(x)
Definition: libm.h:317
ff_nellymoser_encoder
const FFCodec ff_nellymoser_encoder
Definition: nellymoserenc.c:418
AVOnce
#define AVOnce
Definition: thread.h:181
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:83
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:375
find_best
#define find_best(val, table, LUT, LUT_add, LUT_size)
Definition: nellymoserenc.c:206
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:301
codec_internal.h
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
NELLY_BUF_LEN
#define NELLY_BUF_LEN
Definition: nellymoser.h:43
AVFloatDSPContext
Definition: float_dsp.h:24
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
sinewin.h
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
NellyMoserEncodeContext::mdct_fn
av_tx_fn mdct_fn
Definition: nellymoserenc.c:63
NELLY_SAMPLES
#define NELLY_SAMPLES
Definition: nellymoser.h:48
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
NellyMoserEncodeContext::avctx
AVCodecContext * avctx
Definition: nellymoserenc.c:59
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
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:55
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:211
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:64
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1310
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
AVCodecContext
main external API structure.
Definition: avcodec.h:398
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:370
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:79
NellyMoserEncodeContext::mdct_out
float mdct_out[NELLY_SAMPLES]
Definition: nellymoserenc.c:65
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
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: nellymoserenc.c:137
NellyMoserEncodeContext::mdct_ctx
AVTXContext * mdct_ctx
Definition: nellymoserenc.c:62
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: nellymoserenc.c:380
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:368
quant_lut
static const uint8_t quant_lut[230]
Definition: nellymoserenc.c:91
get_exponent_dynamic
static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
Definition: nellymoserenc.c:237
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:122
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:230
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
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:27
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:60
NellyMoserEncodeContext::last_frame
int last_frame
Definition: nellymoserenc.c:60
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:468
tx.h
ff_nelly_get_sample_bits
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:118