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