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));
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:1077
NELLY_HEADER_BITS
#define NELLY_HEADER_BITS
Definition: nellymoser.h:41
av_clip
#define av_clip
Definition: common.h:98
INFINITY
#define INFINITY
Definition: mathematics.h:118
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:1050
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:235
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:344
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:522
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:127
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:540
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:902
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:365
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:1122
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
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:205
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:151
NellyMoserEncodeContext::buf
float buf[3 *NELLY_BUF_LEN]
sample buffer
Definition: nellymoserenc.c:67
float
float
Definition: af_crystalizer.c:121
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:198
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: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:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
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:203
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:202
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
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
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:303
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
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:22
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
NellyMoserEncodeContext::avctx
AVCodecContext * avctx
Definition: nellymoserenc.c:59
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:424
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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:56
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:194
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
ret
ret
Definition: filter_design.txt:187
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:1379
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:103
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:377
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:105
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:76
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:342
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:378
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:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
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:79
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:81
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:473
tx.h
ff_nelly_get_sample_bits
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:118