FFmpeg: libavcodec/binkaudio.c Source File

FFmpeg

libavcodec

binkaudio.c

Go to the documentation of this file.

1 /*

2 * Bink Audio decoder

3 * Copyright (c) 2007-2011 Peter Ross (pross@xvid.org)

4 * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

22

23 /**

24 * @file

25 * Bink Audio decoder

26 *

27 * Technical details here:

28 * http://wiki.multimedia.cx/index.php?title=Bink_Audio

29 */

30

31 #include "config_components.h"

32

33 #include "libavutil/channel_layout.h"

34 #include "libavutil/intfloat.h"

35 #include "libavutil/mem_internal.h"

36

37 #define BITSTREAM_READER_LE

38 #include "avcodec.h"

39 #include "dct.h"

40 #include "decode.h"

41 #include "get_bits.h"

42 #include "codec_internal.h"

43 #include "internal.h"

44 #include "rdft.h"

45 #include "wma_freqs.h"

46

47 #define MAX_DCT_CHANNELS 6

48 #define MAX_CHANNELS 2

49 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)

50

51 typedef struct BinkAudioContext {

52 GetBitContext gb;

53 int version_b; ///< Bink version 'b'

54 int first;

55 int channels;

56 int ch_offset;

57 int frame_len; ///< transform size (samples)

58 int overlap_len; ///< overlap size (samples)

59 int block_size;

60 int num_bands;

61 float root;

62 unsigned int bands[26];

63 float previous[MAX_DCT_CHANNELS][BINK_BLOCK_MAX_SIZE / 16]; ///< coeffs from previous audio block

64 float quant_table[96];

65 AVPacket *pkt;

66 union {

67 RDFTContext rdft;

68 DCTContext dct;

69 } trans;

70 } BinkAudioContext;

71

72

73 static av_cold int decode_init(AVCodecContext *avctx)

74 {

75 BinkAudioContext *s = avctx->priv_data;

76 int sample_rate = avctx->sample_rate;

77 int sample_rate_half;

78 int i, ret;

79 int frame_len_bits;

80 int max_channels = avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT ? MAX_CHANNELS : MAX_DCT_CHANNELS;

81 int channels = avctx->ch_layout.nb_channels;

82

83 /* determine frame length */

84 if (avctx->sample_rate < 22050) {

85 frame_len_bits = 9;

86 } else if (avctx->sample_rate < 44100) {

87 frame_len_bits = 10;

88 } else {

89 frame_len_bits = 11;

90 }

91

92 if (channels < 1 || channels > max_channels) {

93 av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", channels);

94 return AVERROR_INVALIDDATA;

95 }

96 av_channel_layout_uninit(&avctx->ch_layout);

97 av_channel_layout_default(&avctx->ch_layout, channels);

98

99 s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';

100

101 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {

102 // audio is already interleaved for the RDFT format variant

103 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

104 if (sample_rate > INT_MAX / channels)

105 return AVERROR_INVALIDDATA;

106 sample_rate *= channels;

107 s->channels = 1;

108 if (!s->version_b)

109 frame_len_bits += av_log2(channels);

110 } else {

111 s->channels = channels;

112 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

113 }

114

115 s->frame_len = 1 << frame_len_bits;

116 s->overlap_len = s->frame_len / 16;

117 s->block_size = (s->frame_len - s->overlap_len) * FFMIN(MAX_CHANNELS, s->channels);

118 sample_rate_half = (sample_rate + 1LL) / 2;

119 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

120 s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);

121 else

122 s->root = s->frame_len / (sqrt(s->frame_len) * 32768.0);

123 for (i = 0; i < 96; i++) {

124 /* constant is result of 0.066399999/log10(M_E) */

125 s->quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;

126 }

127

128 /* calculate number of bands */

129 for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)

130 if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])

131 break;

132

133 /* populate bands data */

134 s->bands[0] = 2;

135 for (i = 1; i < s->num_bands; i++)

136 s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;

137 s->bands[s->num_bands] = s->frame_len;

138

139 s->first = 1;

140

141 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

142 ret = ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);

143 else if (CONFIG_BINKAUDIO_DCT_DECODER)

144 ret = ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);

145 else

146 av_assert0(0);

147 if (ret < 0)

148 return ret;

149

150 s->pkt = avctx->internal->in_pkt;

151

152 return 0;

153 }

154

155 static float get_float(GetBitContext *gb)

156 {

157 int power = get_bits(gb, 5);

158 float f = ldexpf(get_bits(gb, 23), power - 23);

159 if (get_bits1(gb))

160 f = -f;

161 return f;

162 }

163

164 static const uint8_t rle_length_tab[16] = {

165 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64

166 };

167

168 /**

169 * Decode Bink Audio block

170 * @param[out] out Output buffer (must contain s->block_size elements)

171 * @return 0 on success, negative error code on failure

172 */

173 static int decode_block(BinkAudioContext *s, float **out, int use_dct,

174 int channels, int ch_offset)

175 {

176 int ch, i, j, k;

177 float q, quant[25];

178 int width, coeff;

179 GetBitContext *gb = &s->gb;

180

181 if (use_dct)

182 skip_bits(gb, 2);

183

184 for (ch = 0; ch < channels; ch++) {

185 FFTSample *coeffs = out[ch + ch_offset];

186

187 if (s->version_b) {

188 if (get_bits_left(gb) < 64)

189 return AVERROR_INVALIDDATA;

190 coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;

191 coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;

192 } else {

193 if (get_bits_left(gb) < 58)

194 return AVERROR_INVALIDDATA;

195 coeffs[0] = get_float(gb) * s->root;

196 coeffs[1] = get_float(gb) * s->root;

197 }

198

199 if (get_bits_left(gb) < s->num_bands * 8)

200 return AVERROR_INVALIDDATA;

201 for (i = 0; i < s->num_bands; i++) {

202 int value = get_bits(gb, 8);

203 quant[i] = s->quant_table[FFMIN(value, 95)];

204 }

205

206 k = 0;

207 q = quant[0];

208

209 // parse coefficients

210 i = 2;

211 while (i < s->frame_len) {

212 if (s->version_b) {

213 j = i + 16;

214 } else {

215 int v = get_bits1(gb);

216 if (v) {

217 v = get_bits(gb, 4);

218 j = i + rle_length_tab[v] * 8;

219 } else {

220 j = i + 8;

221 }

222 }

223

224 j = FFMIN(j, s->frame_len);

225

226 width = get_bits(gb, 4);

227 if (width == 0) {

228 memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));

229 i = j;

230 while (s->bands[k] < i)

231 q = quant[k++];

232 } else {

233 while (i < j) {

234 if (s->bands[k] == i)

235 q = quant[k++];

236 coeff = get_bits(gb, width);

237 if (coeff) {

238 int v;

239 v = get_bits1(gb);

240 if (v)

241 coeffs[i] = -q * coeff;

242 else

243 coeffs[i] = q * coeff;

244 } else {

245 coeffs[i] = 0.0f;

246 }

247 i++;

248 }

249 }

250 }

251

252 if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {

253 coeffs[0] /= 0.5;

254 s->trans.dct.dct_calc(&s->trans.dct, coeffs);

255 }

256 else if (CONFIG_BINKAUDIO_RDFT_DECODER)

257 s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);

258 }

259

260 for (ch = 0; ch < channels; ch++) {

261 int j;

262 int count = s->overlap_len * channels;

263 if (!s->first) {

264 j = ch;

265 for (i = 0; i < s->overlap_len; i++, j += channels)

266 out[ch + ch_offset][i] = (s->previous[ch + ch_offset][i] * (count - j) +

267 out[ch + ch_offset][i] * j) / count;

268 }

269 memcpy(s->previous[ch + ch_offset], &out[ch + ch_offset][s->frame_len - s->overlap_len],

270 s->overlap_len * sizeof(*s->previous[ch + ch_offset]));

271 }

272

273 s->first = 0;

274

275 return 0;

276 }

277

278 static av_cold int decode_end(AVCodecContext *avctx)

279 {

280 BinkAudioContext * s = avctx->priv_data;

281 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

282 ff_rdft_end(&s->trans.rdft);

283 else if (CONFIG_BINKAUDIO_DCT_DECODER)

284 ff_dct_end(&s->trans.dct);

285

286 return 0;

287 }

288

289 static void get_bits_align32(GetBitContext *s)

290 {

291 int n = (-get_bits_count(s)) & 31;

292 if (n) skip_bits(s, n);

293 }

294

295 static int binkaudio_receive_frame(AVCodecContext *avctx, AVFrame *frame)

296 {

297 BinkAudioContext *s = avctx->priv_data;

298 GetBitContext *gb = &s->gb;

299 int ret;

300

301 again:

302 if (!s->pkt->data) {

303 ret = ff_decode_get_packet(avctx, s->pkt);

304 if (ret < 0) {

305 s->ch_offset = 0;

306 return ret;

307 }

308

309 if (s->pkt->size < 4) {

310 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

311 ret = AVERROR_INVALIDDATA;

312 goto fail;

313 }

314

315 ret = init_get_bits8(gb, s->pkt->data, s->pkt->size);

316 if (ret < 0)

317 goto fail;

318

319 /* skip reported size */

320 skip_bits_long(gb, 32);

321 }

322

323 /* get output buffer */

324 if (s->ch_offset == 0) {

325 frame->nb_samples = s->frame_len;

326 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

327 return ret;

328 }

329

330 if (decode_block(s, (float **)frame->extended_data,

331 avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT,

332 FFMIN(MAX_CHANNELS, s->channels - s->ch_offset), s->ch_offset)) {

333 av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");

334 s->ch_offset = 0;

335 return AVERROR_INVALIDDATA;

336 }

337 s->ch_offset += MAX_CHANNELS;

338 get_bits_align32(gb);

339 if (!get_bits_left(gb)) {

340 memset(gb, 0, sizeof(*gb));

341 av_packet_unref(s->pkt);

342 }

343 if (s->ch_offset >= s->channels) {

344 s->ch_offset = 0;

345 } else {

346 goto again;

347 }

348

349 frame->nb_samples = s->block_size / FFMIN(avctx->ch_layout.nb_channels, MAX_CHANNELS);

350

351 return 0;

352 fail:

353 s->ch_offset = 0;

354 av_packet_unref(s->pkt);

355 return ret;

356 }

357

358 static void decode_flush(AVCodecContext *avctx)

359 {

360 BinkAudioContext *const s = avctx->priv_data;

361

362 /* s->pkt coincides with avctx->internal->in_pkt

363 * and is unreferenced generically when flushing. */

364 s->first = 1;

365 s->ch_offset = 0;

366 }

367

368 const FFCodec ff_binkaudio_rdft_decoder = {

369 .p.name = "binkaudio_rdft",

370 .p.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)"),

371 .p.type = AVMEDIA_TYPE_AUDIO,

372 .p.id = AV_CODEC_ID_BINKAUDIO_RDFT,

373 .priv_data_size = sizeof(BinkAudioContext),

374 .init = decode_init,

375 .flush = decode_flush,

376 .close = decode_end,

377 FF_CODEC_RECEIVE_FRAME_CB(binkaudio_receive_frame),

378 .p.capabilities = AV_CODEC_CAP_DR1,

379 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

380 };

381

382 const FFCodec ff_binkaudio_dct_decoder = {

383 .p.name = "binkaudio_dct",

384 .p.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)"),

385 .p.type = AVMEDIA_TYPE_AUDIO,

386 .p.id = AV_CODEC_ID_BINKAUDIO_DCT,

387 .priv_data_size = sizeof(BinkAudioContext),

388 .init = decode_init,

389 .flush = decode_flush,

390 .close = decode_end,

391 FF_CODEC_RECEIVE_FRAME_CB(binkaudio_receive_frame),

392 .p.capabilities = AV_CODEC_CAP_DR1,

393 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

394 };

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:422

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:291

ff_decode_get_packet

int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)

Called by decoders to get the next packet for decoding.

Definition: decode.c:205

BinkAudioContext::first

int first

Definition: binkaudio.c:54

BinkAudioContext::version_b

int version_b

Bink version 'b'.

Definition: binkaudio.c:53

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:39

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:839

FILE * out

Definition: movenc.c:54

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:998

BinkAudioContext::channels

int channels

Definition: binkaudio.c:55

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:546

static float get_float(GetBitContext *gb)

Definition: binkaudio.c:155

BINK_BLOCK_MAX_SIZE

#define BINK_BLOCK_MAX_SIZE

Definition: binkaudio.c:49

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:219

@ DFT_C2R

Definition: avfft.h:75

This structure describes decoded (raw) audio or video data.

Definition: frame.h:325

#define expf(x)

Definition: libm.h:283

Definition: codec_internal.h:112

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:300

sample_rate

Definition: ffmpeg_filter.c:153

BinkAudioContext::gb

GetBitContext gb

Definition: binkaudio.c:52

static int init

Definition: av_tx.c:47

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:467

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:379

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

@ DCT_III

Definition: avfft.h:95

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:398

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2056

#define fail()

Definition: checkasm.h:131

static av_always_inline float av_int2float(uint32_t i)

Reinterpret a 32-bit integer as a float.

Definition: intfloat.h:40

Definition: get_bits.h:61

av_cold void ff_rdft_end(RDFTContext *s)

Definition: rdft.c:117

static int quant(float coef, const float Q, const float rounding)

Quantize one coefficient.

Definition: aacenc_utils.h:59

BinkAudioContext

Definition: binkaudio.c:51

BinkAudioContext::quant_table

float quant_table[96]

Definition: binkaudio.c:64

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

#define av_cold

Definition: attributes.h:90

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:667

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:491

#define width

s

#define s(width, name)

Definition: cbs_vp9.c:256

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

static av_cold int decode_end(AVCodecContext *avctx)

Definition: binkaudio.c:278

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

binkaudio_receive_frame

static int binkaudio_receive_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: binkaudio.c:295

AV_CODEC_ID_BINKAUDIO_DCT

@ AV_CODEC_ID_BINKAUDIO_DCT

Definition: codec_id.h:475

channels

Definition: aptx.h:32

ff_wma_critical_freqs

const uint16_t ff_wma_critical_freqs[25]

Definition: wma_freqs.c:23

BinkAudioContext::trans

union BinkAudioContext::@24 trans

BinkAudioContext::ch_offset

int ch_offset

Definition: binkaudio.c:56

#define ldexpf(x, exp)

Definition: libm.h:389

static void flush(AVCodecContext *avctx)

Definition: aacdec_template.c:606

BinkAudioContext::overlap_len

int overlap_len

overlap size (samples)

Definition: binkaudio.c:58

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:424

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

MAX_DCT_CHANNELS

#define MAX_DCT_CHANNELS

Definition: binkaudio.c:47

av_channel_layout_default

void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)

Get the default channel layout for a given number of channels.

Definition: channel_layout.c:960

float FFTSample

Definition: avfft.h:35

static int decode_block(BinkAudioContext *s, float **out, int use_dct, int channels, int ch_offset)

Decode Bink Audio block.

Definition: binkaudio.c:173

BinkAudioContext::pkt

AVPacket * pkt

Definition: binkaudio.c:65

ff_binkaudio_dct_decoder

const FFCodec ff_binkaudio_dct_decoder

Definition: binkaudio.c:382

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:630

f

f

Definition: af_crystalizer.c:122

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1403

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

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

BinkAudioContext::previous

float previous[MAX_DCT_CHANNELS][BINK_BLOCK_MAX_SIZE/16]

coeffs from previous audio block

Definition: binkaudio.c:63

codec_internal.h

BinkAudioContext::root

float root

Definition: binkaudio.c:61

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1014

ff_binkaudio_rdft_decoder

const FFCodec ff_binkaudio_rdft_decoder

Definition: binkaudio.c:368

static const uint8_t rle_length_tab[16]

Definition: binkaudio.c:164

BinkAudioContext::frame_len

int frame_len

transform size (samples)

Definition: binkaudio.c:57

av_cold void ff_dct_end(DCTContext *s)

Definition: dct.c:224

static av_cold int decode_init(AVCodecContext *avctx)

Definition: binkaudio.c:73

enum AVCodecID id

Definition: codec.h:210

av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)

Set up a real FFT.

Definition: rdft.c:89

BinkAudioContext::rdft

RDFTContext rdft

Definition: binkaudio.c:67

av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)

Set up DCT.

Definition: dct.c:179

i

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:490

get_bits_align32

static void get_bits_align32(GetBitContext *s)

Definition: binkaudio.c:289

Definition: rdft.h:28

AVCodecInternal::in_pkt

AVPacket * in_pkt

This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...

Definition: internal.h:73

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

#define FFMIN(a, b)

Definition: macros.h:49

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

Definition: dct.h:32

const char * name

Name of the codec implementation.

Definition: codec.h:203

ret

Definition: filter_design.txt:187

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

BinkAudioContext::dct

DCTContext dct

Definition: binkaudio.c:68

main external API structure.

Definition: avcodec.h:389

static float power(float r, float g, float b, float max)

Definition: preserve_color.h:45

channel_layout.h

FF_CODEC_RECEIVE_FRAME_CB

#define FF_CODEC_RECEIVE_FRAME_CB(func)

Definition: codec_internal.h:260

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 again

Definition: filter_design.txt:25

BinkAudioContext::num_bands

int num_bands

Definition: binkaudio.c:60

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:416

This structure stores compressed data.

Definition: packet.h:351

BinkAudioContext::block_size

int block_size

Definition: binkaudio.c:59

static const double coeff[2][5]

Definition: vf_owdenoise.c:78

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

static void decode_flush(AVCodecContext *avctx)

Definition: binkaudio.c:358

AV_CODEC_ID_BINKAUDIO_RDFT

@ AV_CODEC_ID_BINKAUDIO_RDFT

Definition: codec_id.h:474

#define MAX_CHANNELS

Definition: binkaudio.c:48

int av_log2(unsigned v)

Definition: intmath.c:26

AV_SAMPLE_FMT_FLT

@ AV_SAMPLE_FMT_FLT

float

Definition: samplefmt.h:60

BinkAudioContext::bands

unsigned int bands[26]

Definition: binkaudio.c:62

Generated on Wed Aug 24 2022 21:41:19 for FFmpeg by doxygen 1.8.17