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 "codec_internal.h"
46 #include "encode.h"
47 #include "fft.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
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->sample_rate != 8000 && avctx->sample_rate != 16000 &&
175  avctx->sample_rate != 11025 &&
176  avctx->sample_rate != 22050 && avctx->sample_rate != 44100 &&
178  av_log(avctx, AV_LOG_ERROR, "Nellymoser works only with 8000, 16000, 11025, 22050 and 44100 sample rate\n");
179  return AVERROR(EINVAL);
180  }
181 
182  avctx->frame_size = NELLY_SAMPLES;
184  ff_af_queue_init(avctx, &s->afq);
185  s->avctx = avctx;
186  if ((ret = ff_mdct_init(&s->mdct_ctx, 8, 0, 32768.0)) < 0)
187  return ret;
189  if (!s->fdsp)
190  return AVERROR(ENOMEM);
191 
192  if (s->avctx->trellis) {
193  s->opt = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(float ));
194  s->path = av_malloc(NELLY_BANDS * OPT_SIZE * sizeof(uint8_t));
195  if (!s->opt || !s->path)
196  return AVERROR(ENOMEM);
197  }
198 
199  ff_thread_once(&init_static_once, nellymoser_init_static);
200 
201  return 0;
202 }
203 
204 #define find_best(val, table, LUT, LUT_add, LUT_size) \
205  best_idx = \
206  LUT[av_clip ((lrintf(val) >> 8) + LUT_add, 0, LUT_size - 1)]; \
207  if (fabs(val - table[best_idx]) > fabs(val - table[best_idx + 1])) \
208  best_idx++;
209 
210 static void get_exponent_greedy(NellyMoserEncodeContext *s, float *cand, int *idx_table)
211 {
212  int band, best_idx, power_idx = 0;
213  float power_candidate;
214 
215  //base exponent
216  find_best(cand[0], ff_nelly_init_table, sf_lut, -20, 96);
217  idx_table[0] = best_idx;
218  power_idx = ff_nelly_init_table[best_idx];
219 
220  for (band = 1; band < NELLY_BANDS; band++) {
221  power_candidate = cand[band] - power_idx;
222  find_best(power_candidate, ff_nelly_delta_table, sf_delta_lut, 37, 78);
223  idx_table[band] = best_idx;
224  power_idx += ff_nelly_delta_table[best_idx];
225  }
226 }
227 
228 static inline float distance(float x, float y, int band)
229 {
230  //return pow(fabs(x-y), 2.0);
231  float tmp = x - y;
232  return tmp * tmp;
233 }
234 
235 static void get_exponent_dynamic(NellyMoserEncodeContext *s, float *cand, int *idx_table)
236 {
237  int i, j, band, best_idx;
238  float power_candidate, best_val;
239 
240  float (*opt )[OPT_SIZE] = s->opt ;
241  uint8_t(*path)[OPT_SIZE] = s->path;
242 
243  for (i = 0; i < NELLY_BANDS * OPT_SIZE; i++) {
244  opt[0][i] = INFINITY;
245  }
246 
247  for (i = 0; i < 64; i++) {
248  opt[0][ff_nelly_init_table[i]] = distance(cand[0], ff_nelly_init_table[i], 0);
249  path[0][ff_nelly_init_table[i]] = i;
250  }
251 
252  for (band = 1; band < NELLY_BANDS; band++) {
253  int q, c = 0;
254  float tmp;
255  int idx_min, idx_max, idx;
256  power_candidate = cand[band];
257  for (q = 1000; !c && q < OPT_SIZE; q <<= 2) {
258  idx_min = FFMAX(0, cand[band] - q);
259  idx_max = FFMIN(OPT_SIZE, cand[band - 1] + q);
260  for (i = FFMAX(0, cand[band - 1] - q); i < FFMIN(OPT_SIZE, cand[band - 1] + q); i++) {
261  if ( isinf(opt[band - 1][i]) )
262  continue;
263  for (j = 0; j < 32; j++) {
264  idx = i + ff_nelly_delta_table[j];
265  if (idx > idx_max)
266  break;
267  if (idx >= idx_min) {
268  tmp = opt[band - 1][i] + distance(idx, power_candidate, band);
269  if (opt[band][idx] > tmp) {
270  opt[band][idx] = tmp;
271  path[band][idx] = j;
272  c = 1;
273  }
274  }
275  }
276  }
277  }
278  av_assert1(c); //FIXME
279  }
280 
281  best_val = INFINITY;
282  best_idx = -1;
283  band = NELLY_BANDS - 1;
284  for (i = 0; i < OPT_SIZE; i++) {
285  if (best_val > opt[band][i]) {
286  best_val = opt[band][i];
287  best_idx = i;
288  }
289  }
290  for (band = NELLY_BANDS - 1; band >= 0; band--) {
291  idx_table[band] = path[band][best_idx];
292  if (band) {
293  best_idx -= ff_nelly_delta_table[path[band][best_idx]];
294  }
295  }
296 }
297 
298 /**
299  * Encode NELLY_SAMPLES samples. It assumes, that samples contains 3 * NELLY_BUF_LEN values
300  * @param s encoder context
301  * @param output output buffer
302  * @param output_size size of output buffer
303  */
304 static void encode_block(NellyMoserEncodeContext *s, unsigned char *output, int output_size)
305 {
306  PutBitContext pb;
307  int i, j, band, block, best_idx, power_idx = 0;
308  float power_val, coeff, coeff_sum;
309  float pows[NELLY_FILL_LEN];
310  int bits[NELLY_BUF_LEN], idx_table[NELLY_BANDS];
311  float cand[NELLY_BANDS];
312 
313  apply_mdct(s);
314 
315  init_put_bits(&pb, output, output_size);
316 
317  i = 0;
318  for (band = 0; band < NELLY_BANDS; band++) {
319  coeff_sum = 0;
320  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
321  coeff_sum += s->mdct_out[i ] * s->mdct_out[i ]
322  + s->mdct_out[i + NELLY_BUF_LEN] * s->mdct_out[i + NELLY_BUF_LEN];
323  }
324  cand[band] =
325  log2(FFMAX(1.0, coeff_sum / (ff_nelly_band_sizes_table[band] << 7))) * 1024.0;
326  }
327 
328  if (s->avctx->trellis) {
329  get_exponent_dynamic(s, cand, idx_table);
330  } else {
331  get_exponent_greedy(s, cand, idx_table);
332  }
333 
334  i = 0;
335  for (band = 0; band < NELLY_BANDS; band++) {
336  if (band) {
337  power_idx += ff_nelly_delta_table[idx_table[band]];
338  put_bits(&pb, 5, idx_table[band]);
339  } else {
340  power_idx = ff_nelly_init_table[idx_table[0]];
341  put_bits(&pb, 6, idx_table[0]);
342  }
343  power_val = pow_table[power_idx & 0x7FF] / (1 << ((power_idx >> 11) + POW_TABLE_OFFSET));
344  for (j = 0; j < ff_nelly_band_sizes_table[band]; i++, j++) {
345  s->mdct_out[i] *= power_val;
346  s->mdct_out[i + NELLY_BUF_LEN] *= power_val;
347  pows[i] = power_idx;
348  }
349  }
350 
352 
353  for (block = 0; block < 2; block++) {
354  for (i = 0; i < NELLY_FILL_LEN; i++) {
355  if (bits[i] > 0) {
356  const float *table = ff_nelly_dequantization_table + (1 << bits[i]) - 1;
357  coeff = s->mdct_out[block * NELLY_BUF_LEN + i];
358  best_idx =
362  quant_lut_offset[bits[i]+1] - 1
363  )];
364  if (fabs(coeff - table[best_idx]) > fabs(coeff - table[best_idx + 1]))
365  best_idx++;
366 
367  put_bits(&pb, bits[i], best_idx);
368  }
369  }
370  if (!block)
372  }
373 
374  flush_put_bits(&pb);
375  memset(put_bits_ptr(&pb), 0, output + output_size - put_bits_ptr(&pb));
376 }
377 
378 static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
379  const AVFrame *frame, int *got_packet_ptr)
380 {
382  int ret;
383 
384  if (s->last_frame)
385  return 0;
386 
387  memcpy(s->buf, s->buf + NELLY_SAMPLES, NELLY_BUF_LEN * sizeof(*s->buf));
388  if (frame) {
389  memcpy(s->buf + NELLY_BUF_LEN, frame->data[0],
390  frame->nb_samples * sizeof(*s->buf));
391  if (frame->nb_samples < NELLY_SAMPLES) {
392  memset(s->buf + NELLY_BUF_LEN + frame->nb_samples, 0,
393  (NELLY_SAMPLES - frame->nb_samples) * sizeof(*s->buf));
394  if (frame->nb_samples >= NELLY_BUF_LEN)
395  s->last_frame = 1;
396  }
397  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
398  return ret;
399  } else {
400  memset(s->buf + NELLY_BUF_LEN, 0, NELLY_SAMPLES * sizeof(*s->buf));
401  s->last_frame = 1;
402  }
403 
404  if ((ret = ff_get_encode_buffer(avctx, avpkt, NELLY_BLOCK_LEN, 0)) < 0)
405  return ret;
406  encode_block(s, avpkt->data, avpkt->size);
407 
408  /* Get the next frame pts/duration */
409  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
410  &avpkt->duration);
411 
412  *got_packet_ptr = 1;
413  return 0;
414 }
415 
417  .p.name = "nellymoser",
418  .p.long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
419  .p.type = AVMEDIA_TYPE_AUDIO,
420  .p.id = AV_CODEC_ID_NELLYMOSER,
421  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
423  .priv_data_size = sizeof(NellyMoserEncodeContext),
424  .init = encode_init,
426  .close = encode_end,
427  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
429  .p.ch_layouts = (const AVChannelLayout[]){ AV_CHANNEL_LAYOUT_MONO, { 0 } },
430  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
431 };
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: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:41
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:1007
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
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: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:210
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: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
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:118
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:392
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:30
init
static int init
Definition: av_tx.c:47
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
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:1732
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
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:179
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
float
float
Definition: af_crystalizer.c:122
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
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:304
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:50
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:177
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
ff_nellymoser_encoder
const FFCodec ff_nellymoser_encoder
Definition: nellymoserenc.c:416
NellyMoserEncodeContext::mdct_ctx
FFTContext mdct_ctx
Definition: nellymoserenc.c:62
AVOnce
#define AVOnce
Definition: thread.h:176
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:375
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:204
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
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:1312
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
FFTContext
Definition: fft.h:75
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:63
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1309
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
fft.h
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: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
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:288
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: nellymoserenc.c:378
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
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:235
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:121
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:228
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:462
ff_nelly_get_sample_bits
void ff_nelly_get_sample_bits(const float *buf, int *bits)
Definition: nellymoser.c:118