FFmpeg
ra288.c
Go to the documentation of this file.
1 /*
2  * RealAudio 2.0 (28.8K)
3  * Copyright (c) 2003 The FFmpeg project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
23 #include "libavutil/float_dsp.h"
24 #include "libavutil/internal.h"
25 
26 #define BITSTREAM_READER_LE
27 #include "avcodec.h"
28 #include "celp_filters.h"
29 #include "get_bits.h"
30 #include "internal.h"
31 #include "lpc.h"
32 #include "ra288.h"
33 
34 #define MAX_BACKWARD_FILTER_ORDER 36
35 #define MAX_BACKWARD_FILTER_LEN 40
36 #define MAX_BACKWARD_FILTER_NONREC 35
37 
38 #define RA288_BLOCK_SIZE 5
39 #define RA288_BLOCKS_PER_FRAME 32
40 
41 typedef struct RA288Context {
43  DECLARE_ALIGNED(32, float, sp_lpc)[FFALIGN(36, 16)]; ///< LPC coefficients for speech data (spec: A)
44  DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)]; ///< LPC coefficients for gain (spec: GB)
45 
46  /** speech data history (spec: SB).
47  * Its first 70 coefficients are updated only at backward filtering.
48  */
49  float sp_hist[111];
50 
51  /// speech part of the gain autocorrelation (spec: REXP)
52  float sp_rec[37];
53 
54  /** log-gain history (spec: SBLG).
55  * Its first 28 coefficients are updated only at backward filtering.
56  */
57  float gain_hist[38];
58 
59  /// recursive part of the gain autocorrelation (spec: REXPLG)
60  float gain_rec[11];
61 } RA288Context;
62 
64 {
65  RA288Context *ractx = avctx->priv_data;
66 
67  av_freep(&ractx->fdsp);
68 
69  return 0;
70 }
71 
73 {
74  RA288Context *ractx = avctx->priv_data;
75 
76  avctx->channels = 1;
79 
80  if (avctx->block_align <= 0) {
81  av_log(avctx, AV_LOG_ERROR, "unsupported block align\n");
82  return AVERROR_PATCHWELCOME;
83  }
84 
86  if (!ractx->fdsp)
87  return AVERROR(ENOMEM);
88 
89  return 0;
90 }
91 
92 static void convolve(float *tgt, const float *src, int len, int n)
93 {
94  for (; n >= 0; n--)
95  tgt[n] = avpriv_scalarproduct_float_c(src, src - n, len);
96 
97 }
98 
99 static void decode(RA288Context *ractx, float gain, int cb_coef)
100 {
101  int i;
102  double sumsum;
103  float sum, buffer[5];
104  float *block = ractx->sp_hist + 70 + 36; // current block
105  float *gain_block = ractx->gain_hist + 28;
106 
107  memmove(ractx->sp_hist + 70, ractx->sp_hist + 75, 36*sizeof(*block));
108 
109  /* block 46 of G.728 spec */
110  sum = 32.0;
111  for (i=0; i < 10; i++)
112  sum -= gain_block[9-i] * ractx->gain_lpc[i];
113 
114  /* block 47 of G.728 spec */
115  sum = av_clipf(sum, 0, 60);
116 
117  /* block 48 of G.728 spec */
118  /* exp(sum * 0.1151292546497) == pow(10.0,sum/20) */
119  sumsum = exp(sum * 0.1151292546497) * gain * (1.0/(1<<23));
120 
121  for (i=0; i < 5; i++)
122  buffer[i] = codetable[cb_coef][i] * sumsum;
123 
124  sum = avpriv_scalarproduct_float_c(buffer, buffer, 5);
125 
126  sum = FFMAX(sum, 5.0 / (1<<24));
127 
128  /* shift and store */
129  memmove(gain_block, gain_block + 1, 9 * sizeof(*gain_block));
130 
131  gain_block[9] = 10 * log10(sum) + (10*log10(((1<<24)/5.)) - 32);
132 
133  ff_celp_lp_synthesis_filterf(block, ractx->sp_lpc, buffer, 5, 36);
134 }
135 
136 /**
137  * Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
138  *
139  * @param order filter order
140  * @param n input length
141  * @param non_rec number of non-recursive samples
142  * @param out filter output
143  * @param hist pointer to the input history of the filter
144  * @param out pointer to the non-recursive part of the output
145  * @param out2 pointer to the recursive part of the output
146  * @param window pointer to the windowing function table
147  */
148 static void do_hybrid_window(RA288Context *ractx,
149  int order, int n, int non_rec, float *out,
150  float *hist, float *out2, const float *window)
151 {
152  int i;
153  float buffer1[MAX_BACKWARD_FILTER_ORDER + 1];
154  float buffer2[MAX_BACKWARD_FILTER_ORDER + 1];
158 
159  av_assert2(order>=0);
160 
161  ractx->fdsp->vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16));
162 
163  convolve(buffer1, work + order , n , order);
164  convolve(buffer2, work + order + n, non_rec, order);
165 
166  for (i=0; i <= order; i++) {
167  out2[i] = out2[i] * 0.5625 + buffer1[i];
168  out [i] = out2[i] + buffer2[i];
169  }
170 
171  /* Multiply by the white noise correcting factor (WNCF). */
172  *out *= 257.0 / 256.0;
173 }
174 
175 /**
176  * Backward synthesis filter, find the LPC coefficients from past speech data.
177  */
178 static void backward_filter(RA288Context *ractx,
179  float *hist, float *rec, const float *window,
180  float *lpc, const float *tab,
181  int order, int n, int non_rec, int move_size)
182 {
184 
185  do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window);
186 
187  if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1))
188  ractx->fdsp->vector_fmul(lpc, lpc, tab, FFALIGN(order, 16));
189 
190  memmove(hist, hist + n, move_size*sizeof(*hist));
191 }
192 
193 static int ra288_decode_frame(AVCodecContext * avctx, void *data,
194  int *got_frame_ptr, AVPacket *avpkt)
195 {
196  AVFrame *frame = data;
197  const uint8_t *buf = avpkt->data;
198  int buf_size = avpkt->size;
199  float *out;
200  int i, ret;
201  RA288Context *ractx = avctx->priv_data;
202  GetBitContext gb;
203 
204  if (buf_size < avctx->block_align) {
205  av_log(avctx, AV_LOG_ERROR,
206  "Error! Input buffer is too small [%d<%d]\n",
207  buf_size, avctx->block_align);
208  return AVERROR_INVALIDDATA;
209  }
210 
211  ret = init_get_bits8(&gb, buf, avctx->block_align);
212  if (ret < 0)
213  return ret;
214 
215  /* get output buffer */
217  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
218  return ret;
219  out = (float *)frame->data[0];
220 
221  for (i=0; i < RA288_BLOCKS_PER_FRAME; i++) {
222  float gain = amptable[get_bits(&gb, 3)];
223  int cb_coef = get_bits(&gb, 6 + (i&1));
224 
225  decode(ractx, gain, cb_coef);
226 
227  memcpy(out, &ractx->sp_hist[70 + 36], RA288_BLOCK_SIZE * sizeof(*out));
228  out += RA288_BLOCK_SIZE;
229 
230  if ((i & 7) == 3) {
231  backward_filter(ractx, ractx->sp_hist, ractx->sp_rec, syn_window,
232  ractx->sp_lpc, syn_bw_tab, 36, 40, 35, 70);
233 
234  backward_filter(ractx, ractx->gain_hist, ractx->gain_rec, gain_window,
235  ractx->gain_lpc, gain_bw_tab, 10, 8, 20, 28);
236  }
237  }
238 
239  *got_frame_ptr = 1;
240 
241  return avctx->block_align;
242 }
243 
245  .name = "real_288",
246  .long_name = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
247  .type = AVMEDIA_TYPE_AUDIO,
248  .id = AV_CODEC_ID_RA_288,
249  .priv_data_size = sizeof(RA288Context),
252  .close = ra288_decode_close,
253  .capabilities = AV_CODEC_CAP_DR1,
254 };
float sp_lpc[FFALIGN(36, 16)]
LPC coefficients for speech data (spec: A)
Definition: ra288.c:43
static av_cold int ra288_decode_close(AVCodecContext *avctx)
Definition: ra288.c:63
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
Definition: celp_filters.c:84
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
float gain_lpc[FFALIGN(10, 16)]
LPC coefficients for gain (spec: GB)
Definition: ra288.c:44
static void backward_filter(RA288Context *ractx, float *hist, float *rec, const float *window, float *lpc, const float *tab, int order, int n, int non_rec, int move_size)
Backward synthesis filter, find the LPC coefficients from past speech data.
Definition: ra288.c:178
must be printed separately If there s no standard function for printing the type you the WRITE_1D_FUNC_ARGV macro is a very quick way to create one See libavcodec dv_tablegen c for an example The h file This file should the initialization functions should not do and instead of the variable declarations the generated *_tables h file should be included Since that will be generated in the build the path must be i e not Makefile changes To make the automatic table creation work
Definition: tablegen.txt:45
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
else temp
Definition: vf_mcdeint.c:256
#define MAX_BACKWARD_FILTER_ORDER
Definition: ra288.c:34
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1481
static void decode(RA288Context *ractx, float gain, int cb_coef)
Definition: ra288.c:99
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3492
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2265
static const float amptable[8]
Definition: ra288.h:28
float sp_hist[111]
speech data history (spec: SB).
Definition: ra288.c:49
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
#define MAX_BACKWARD_FILTER_NONREC
Definition: ra288.c:36
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
float gain_hist[38]
log-gain history (spec: SBLG).
Definition: ra288.c:57
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1480
bitstream reader API header.
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define MAX_BACKWARD_FILTER_LEN
Definition: ra288.c:35
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static void convolve(float *tgt, const float *src, int len, int n)
Definition: ra288.c:92
#define FFMAX(a, b)
Definition: common.h:94
int8_t exp
Definition: eval.c:72
static const float syn_window[FFALIGN(111, 16)]
Definition: ra288.h:100
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
AVCodec ff_ra_288_decoder
Definition: ra288.c:244
common internal API header
static SDL_Window * window
Definition: ffplay.c:367
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:911
#define RA288_BLOCKS_PER_FRAME
Definition: ra288.c:39
static const float gain_window[FFALIGN(38, 16)]
Definition: ra288.h:122
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
int n
Definition: avisynth_c.h:760
static int AAC_RENAME() compute_lpc_coefs(const LPC_TYPE *autoc, int max_order, LPC_TYPE *lpc, int lpc_stride, int fail, int normalize)
Levinson-Durbin recursion.
Definition: lpc.h:166
static const float syn_bw_tab[FFALIGN(36, 16)]
synthesis bandwidth broadening table
Definition: ra288.h:133
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVFloatDSPContext * fdsp
Definition: ra288.c:42
static const int16_t codetable[128][5]
Definition: ra288.h:33
Libavcodec external API header.
float sp_rec[37]
speech part of the gain autocorrelation (spec: REXP)
Definition: ra288.c:52
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1568
static void do_hybrid_window(RA288Context *ractx, int order, int n, int non_rec, float *out, float *hist, float *out2, const float *window)
Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
Definition: ra288.c:148
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
void * buf
Definition: avisynth_c.h:766
static const float gain_bw_tab[FFALIGN(10, 16)]
gain bandwidth broadening table
Definition: ra288.h:143
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
Definition: float_dsp.c:124
#define RA288_BLOCK_SIZE
Definition: ra288.c:38
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static av_cold int ra288_decode_init(AVCodecContext *avctx)
Definition: ra288.c:72
static int ra288_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: ra288.c:193
common internal api header.
#define LOCAL_ALIGNED(a, t, v,...)
Definition: internal.h:114
float gain_rec[11]
recursive part of the gain autocorrelation (spec: REXPLG)
Definition: ra288.c:60
void * priv_data
Definition: avcodec.h:1595
int len
int channels
number of audio channels
Definition: avcodec.h:2229
static const struct twinvq_data tab
FILE * out
Definition: movenc.c:54
#define av_freep(p)
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
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
for(j=16;j >0;--j)
GLuint buffer
Definition: opengl_enc.c:101