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 #include "libavutil/mem.h"
26 #include "libavutil/mem_internal.h"
27 
28 #define BITSTREAM_READER_LE
29 #include "avcodec.h"
30 #include "celp_filters.h"
31 #include "codec_internal.h"
32 #include "decode.h"
33 #include "get_bits.h"
34 #include "lpc_functions.h"
35 #include "ra288.h"
36 
37 #define MAX_BACKWARD_FILTER_ORDER 36
38 #define MAX_BACKWARD_FILTER_LEN 40
39 #define MAX_BACKWARD_FILTER_NONREC 35
40 
41 #define RA288_BLOCK_SIZE 5
42 #define RA288_BLOCKS_PER_FRAME 32
43 
44 typedef struct RA288Context {
45  void (*vector_fmul)(float *dst, const float *src0, const float *src1,
46  int len);
47  DECLARE_ALIGNED(32, float, sp_lpc)[FFALIGN(36, 16)]; ///< LPC coefficients for speech data (spec: A)
48  DECLARE_ALIGNED(32, float, gain_lpc)[FFALIGN(10, 16)]; ///< LPC coefficients for gain (spec: GB)
49 
50  /** speech data history (spec: SB).
51  * Its first 70 coefficients are updated only at backward filtering.
52  */
53  float sp_hist[111];
54 
55  /// speech part of the gain autocorrelation (spec: REXP)
56  float sp_rec[37];
57 
58  /** log-gain history (spec: SBLG).
59  * Its first 28 coefficients are updated only at backward filtering.
60  */
61  float gain_hist[38];
62 
63  /// recursive part of the gain autocorrelation (spec: REXPLG)
64  float gain_rec[11];
65 } RA288Context;
66 
68 {
69  RA288Context *ractx = avctx->priv_data;
70  AVFloatDSPContext *fdsp;
71 
75 
76  if (avctx->block_align != 38) {
77  av_log(avctx, AV_LOG_ERROR, "unsupported block align\n");
78  return AVERROR_PATCHWELCOME;
79  }
80 
82  if (!fdsp)
83  return AVERROR(ENOMEM);
84  ractx->vector_fmul = fdsp->vector_fmul;
85  av_free(fdsp);
86 
87  return 0;
88 }
89 
90 static void convolve(float *tgt, const float *src, int len, int n)
91 {
92  for (; n >= 0; n--)
93  tgt[n] = avpriv_scalarproduct_float_c(src, src - n, len);
94 
95 }
96 
97 static void decode(RA288Context *ractx, float gain, int cb_coef)
98 {
99  int i;
100  double sumsum;
101  float sum, buffer[5];
102  float *block = ractx->sp_hist + 70 + 36; // current block
103  float *gain_block = ractx->gain_hist + 28;
104 
105  memmove(ractx->sp_hist + 70, ractx->sp_hist + 75, 36*sizeof(*block));
106 
107  /* block 46 of G.728 spec */
108  sum = 32.0;
109  for (i=0; i < 10; i++)
110  sum -= gain_block[9-i] * ractx->gain_lpc[i];
111 
112  /* block 47 of G.728 spec */
113  sum = av_clipf(sum, 0, 60);
114 
115  /* block 48 of G.728 spec */
116  /* exp(sum * 0.1151292546497) == pow(10.0,sum/20) */
117  sumsum = exp(sum * 0.1151292546497) * gain * (1.0/(1<<23));
118 
119  for (i=0; i < 5; i++)
120  buffer[i] = codetable[cb_coef][i] * sumsum;
121 
123 
124  sum = FFMAX(sum, 5.0 / (1<<24));
125 
126  /* shift and store */
127  memmove(gain_block, gain_block + 1, 9 * sizeof(*gain_block));
128 
129  gain_block[9] = 10 * log10(sum) + (10*log10(((1<<24)/5.)) - 32);
130 
132 }
133 
134 /**
135  * Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
136  *
137  * @param order filter order
138  * @param n input length
139  * @param non_rec number of non-recursive samples
140  * @param out filter output
141  * @param hist pointer to the input history of the filter
142  * @param out pointer to the non-recursive part of the output
143  * @param out2 pointer to the recursive part of the output
144  * @param window pointer to the windowing function table
145  */
146 static void do_hybrid_window(RA288Context *ractx,
147  int order, int n, int non_rec, float *out,
148  float *hist, float *out2, const float *window)
149 {
150  int i;
151  float buffer1[MAX_BACKWARD_FILTER_ORDER + 1];
152  float buffer2[MAX_BACKWARD_FILTER_ORDER + 1];
156 
157  av_assert2(order>=0);
158 
159  ractx->vector_fmul(work, window, hist, FFALIGN(order + n + non_rec, 16));
160 
161  convolve(buffer1, work + order , n , order);
162  convolve(buffer2, work + order + n, non_rec, order);
163 
164  for (i=0; i <= order; i++) {
165  out2[i] = out2[i] * 0.5625 + buffer1[i];
166  out [i] = out2[i] + buffer2[i];
167  }
168 
169  /* Multiply by the white noise correcting factor (WNCF). */
170  *out *= 257.0 / 256.0;
171 }
172 
173 /**
174  * Backward synthesis filter, find the LPC coefficients from past speech data.
175  */
176 static void backward_filter(RA288Context *ractx,
177  float *hist, float *rec, const float *window,
178  float *lpc, const float *tab,
179  int order, int n, int non_rec, int move_size)
180 {
182 
183  do_hybrid_window(ractx, order, n, non_rec, temp, hist, rec, window);
184 
185  if (!compute_lpc_coefs(temp, order, lpc, 0, 1, 1))
186  ractx->vector_fmul(lpc, lpc, tab, FFALIGN(order, 16));
187 
188  memmove(hist, hist + n, move_size*sizeof(*hist));
189 }
190 
192  int *got_frame_ptr, AVPacket *avpkt)
193 {
194  const uint8_t *buf = avpkt->data;
195  int buf_size = avpkt->size;
196  float *out;
197  int i, ret;
198  RA288Context *ractx = avctx->priv_data;
199  GetBitContext gb;
200 
201  if (buf_size < avctx->block_align) {
202  av_log(avctx, AV_LOG_ERROR,
203  "Error! Input buffer is too small [%d<%d]\n",
204  buf_size, avctx->block_align);
205  return AVERROR_INVALIDDATA;
206  }
207 
208  ret = init_get_bits8(&gb, buf, avctx->block_align);
209  if (ret < 0)
210  return ret;
211 
212  /* get output buffer */
214  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
215  return ret;
216  out = (float *)frame->data[0];
217 
218  for (i=0; i < RA288_BLOCKS_PER_FRAME; i++) {
219  float gain = amptable[get_bits(&gb, 3)];
220  int cb_coef = get_bits(&gb, 6 + (i&1));
221 
222  decode(ractx, gain, cb_coef);
223 
224  memcpy(out, &ractx->sp_hist[70 + 36], RA288_BLOCK_SIZE * sizeof(*out));
226 
227  if ((i & 7) == 3) {
228  backward_filter(ractx, ractx->sp_hist, ractx->sp_rec, syn_window,
229  ractx->sp_lpc, syn_bw_tab, 36, 40, 35, 70);
230 
231  backward_filter(ractx, ractx->gain_hist, ractx->gain_rec, gain_window,
232  ractx->gain_lpc, gain_bw_tab, 10, 8, 20, 28);
233  }
234  }
235 
236  *got_frame_ptr = 1;
237 
238  return avctx->block_align;
239 }
240 
242  .p.name = "real_288",
243  CODEC_LONG_NAME("RealAudio 2.0 (28.8K)"),
244  .p.type = AVMEDIA_TYPE_AUDIO,
245  .p.id = AV_CODEC_ID_RA_288,
246  .priv_data_size = sizeof(RA288Context),
249  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
250 };
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
mem_internal.h
out
FILE * out
Definition: movenc.c:55
codetable
static const int16_t codetable[128][5]
Definition: ra288.h:34
src1
const pixel * src1
Definition: h264pred_template.c:421
ff_ra_288_decoder
const FFCodec ff_ra_288_decoder
Definition: ra288.c:241
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:524
MAX_BACKWARD_FILTER_NONREC
#define MAX_BACKWARD_FILTER_NONREC
Definition: ra288.c:39
FFCodec
Definition: codec_internal.h:126
backward_filter
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:176
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_celp_lp_synthesis_filterf
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:85
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
window
static SDL_Window * window
Definition: ffplay.c:361
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
decode
static void decode(RA288Context *ractx, float gain, int cb_coef)
Definition: ra288.c:97
GetBitContext
Definition: get_bits.h:108
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
MAX_BACKWARD_FILTER_ORDER
#define MAX_BACKWARD_FILTER_ORDER
Definition: ra288.c:37
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
gain_window
static const float gain_window[FFALIGN(38, 16)]
Definition: ra288.h:123
syn_bw_tab
static const float syn_bw_tab[FFALIGN(36, 16)]
synthesis bandwidth broadening table
Definition: ra288.h:134
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
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
LOCAL_ALIGNED
#define LOCAL_ALIGNED(a, t, v,...)
Definition: mem_internal.h:133
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
do_hybrid_window
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:146
decode.h
get_bits.h
gain_bw_tab
static const float gain_bw_tab[FFALIGN(10, 16)]
gain bandwidth broadening table
Definition: ra288.h:144
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
compute_lpc_coefs
static int 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_functions.h:54
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
work
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:66
RA288_BLOCKS_PER_FRAME
#define RA288_BLOCKS_PER_FRAME
Definition: ra288.c:42
RA288Context::sp_lpc
float sp_lpc[FFALIGN(36, 16)]
LPC coefficients for speech data (spec: A)
Definition: ra288.c:47
celp_filters.h
av_clipf
av_clipf
Definition: af_crystalizer.c:121
exp
int8_t exp
Definition: eval.c:73
ra288_decode_init
static av_cold int ra288_decode_init(AVCodecContext *avctx)
Definition: ra288.c:67
float_dsp.h
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
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
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
AVFloatDSPContext::vector_fmul
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:36
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
AVFloatDSPContext
Definition: float_dsp.h:22
convolve
static void convolve(float *tgt, const float *src, int len, int n)
Definition: ra288.c:90
RA288Context
Definition: ra288.c:44
RA288_BLOCK_SIZE
#define RA288_BLOCK_SIZE
Definition: ra288.c:41
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:426
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
internal.h
ra288_decode_frame
static int ra288_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: ra288.c:191
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
RA288Context::gain_lpc
float gain_lpc[FFALIGN(10, 16)]
LPC coefficients for gain (spec: GB)
Definition: ra288.c:48
len
int len
Definition: vorbis_enc_data.h:426
syn_window
static const float syn_window[FFALIGN(111, 16)]
Definition: ra288.h:101
RA288Context::gain_hist
float gain_hist[38]
log-gain history (spec: SBLG).
Definition: ra288.c:61
avcodec.h
RA288Context::vector_fmul
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Definition: ra288.c:45
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1083
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
RA288Context::sp_rec
float sp_rec[37]
speech part of the gain autocorrelation (spec: REXP)
Definition: ra288.c:56
RA288Context::gain_rec
float gain_rec[11]
recursive part of the gain autocorrelation (spec: REXPLG)
Definition: ra288.c:64
AVCodecContext
main external API structure.
Definition: avcodec.h:445
channel_layout.h
lpc_functions.h
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
temp
else temp
Definition: vf_mcdeint.c:263
avpriv_scalarproduct_float_c
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
src0
const pixel *const src0
Definition: h264pred_template.c:420
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:378
amptable
static const float amptable[8]
Definition: ra288.h:29
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
RA288Context::sp_hist
float sp_hist[111]
speech data history (spec: SB).
Definition: ra288.c:53
MAX_BACKWARD_FILTER_LEN
#define MAX_BACKWARD_FILTER_LEN
Definition: ra288.c:38
ra288.h
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60