FFmpeg: libavcodec/mpc7.c Source File

FFmpeg

[フレーム]

libavcodec

mpc7.c

Go to the documentation of this file.

1 /*

2 * Musepack SV7 decoder

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 */

22 /**

23 * @file

24 * MPEG Audio Layer 1/2 -like codec with frames of 1152 samples

25 * divided into 32 subbands.

26 */

28 #include "libavutil/channel_layout.h"

29 #include "libavutil/internal.h"

30 #include "libavutil/lfg.h"

31 #include "libavutil/mem_internal.h"

32 #include "libavutil/thread.h"

34 #include "avcodec.h"

35 #include "codec_internal.h"

36 #include "get_bits.h"

37 #include "internal.h"

38 #include "mpegaudiodsp.h"

40 #include "mpc.h"

41 #include "mpc7data.h"

43 static VLC scfi_vlc, dscf_vlc, hdr_vlc, quant_vlc[MPC7_QUANT_VLC_TABLES][2];

45 static av_cold void mpc7_init_static(void)

46 {

47 static VLCElem quant_tables[7224];

48 const uint8_t *raw_quant_table = mpc7_quant_vlcs;

50 INIT_VLC_STATIC_FROM_LENGTHS(&scfi_vlc, MPC7_SCFI_BITS, MPC7_SCFI_SIZE,

51 &mpc7_scfi[1], 2,

52 &mpc7_scfi[0], 2, 1, 0, 0, 1 << MPC7_SCFI_BITS);

53 INIT_VLC_STATIC_FROM_LENGTHS(&dscf_vlc, MPC7_DSCF_BITS, MPC7_DSCF_SIZE,

54 &mpc7_dscf[1], 2,

55 &mpc7_dscf[0], 2, 1, -7, 0, 1 << MPC7_DSCF_BITS);

56 INIT_VLC_STATIC_FROM_LENGTHS(&hdr_vlc, MPC7_HDR_BITS, MPC7_HDR_SIZE,

57 &mpc7_hdr[1], 2,

58 &mpc7_hdr[0], 2, 1, -5, 0, 1 << MPC7_HDR_BITS);

59 for (unsigned i = 0, offset = 0; i < MPC7_QUANT_VLC_TABLES; i++){

60 for (int j = 0; j < 2; j++) {

61 quant_vlc[i][j].table = &quant_tables[offset];

62 quant_vlc[i][j].table_allocated = FF_ARRAY_ELEMS(quant_tables) - offset;

63 ff_init_vlc_from_lengths(&quant_vlc[i][j], 9, mpc7_quant_vlc_sizes[i],

64 &raw_quant_table[1], 2,

65 &raw_quant_table[0], 2, 1,

66 mpc7_quant_vlc_off[i],

67 INIT_VLC_STATIC_OVERLONG, NULL);

68 raw_quant_table += 2 * mpc7_quant_vlc_sizes[i];

69 offset += quant_vlc[i][j].table_size;

70 }

71 }

72 ff_mpa_synth_init_fixed();

73 }

75 static av_cold int mpc7_decode_init(AVCodecContext * avctx)

76 {

77 static AVOnce init_static_once = AV_ONCE_INIT;

78 MPCContext *c = avctx->priv_data;

79 GetBitContext gb;

80 LOCAL_ALIGNED_16(uint8_t, buf, [16]);

82 /* Musepack SV7 is always stereo */

83 if (avctx->ch_layout.nb_channels != 2) {

84 avpriv_request_sample(avctx, "%d channels", avctx->ch_layout.nb_channels);

85 return AVERROR_PATCHWELCOME;

86 }

88 if(avctx->extradata_size < 16){

89 av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);

90 return AVERROR_INVALIDDATA;

91 }

92 memset(c->oldDSCF, 0, sizeof(c->oldDSCF));

93 av_lfg_init(&c->rnd, 0xDEADBEEF);

94 ff_bswapdsp_init(&c->bdsp);

95 ff_mpadsp_init(&c->mpadsp);

96 c->bdsp.bswap_buf((uint32_t *) buf, (const uint32_t *) avctx->extradata, 4);

97 init_get_bits(&gb, buf, 128);

99 c->IS = get_bits1(&gb);

100 c->MSS = get_bits1(&gb);

101 c->maxbands = get_bits(&gb, 6);

102 if(c->maxbands >= BANDS){

103 av_log(avctx, AV_LOG_ERROR, "Too many bands: %i\n", c->maxbands);

104 return AVERROR_INVALIDDATA;

105 }

106 skip_bits_long(&gb, 88);

107 c->gapless = get_bits1(&gb);

108 c->lastframelen = get_bits(&gb, 11);

109 av_log(avctx, AV_LOG_DEBUG, "IS: %d, MSS: %d, TG: %d, LFL: %d, bands: %d\n",

110 c->IS, c->MSS, c->gapless, c->lastframelen, c->maxbands);

111 c->frames_to_skip = 0;

112

113 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

114 av_channel_layout_uninit(&avctx->ch_layout);

115 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

116

117 ff_thread_once(&init_static_once, mpc7_init_static);

118

119 return 0;

120 }

121

122 /**

123 * Fill samples for given subband

124 */

125 static inline void idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int *dst)

126 {

127 int i, i1, t;

128 switch(idx){

129 case -1:

130 for(i = 0; i < SAMPLES_PER_BAND; i++){

131 *dst++ = (av_lfg_get(&c->rnd) & 0x3FC) - 510;

132 }

133 break;

134 case 1:

135 i1 = get_bits1(gb);

136 for(i = 0; i < SAMPLES_PER_BAND/3; i++){

137 t = get_vlc2(gb, quant_vlc[0][i1].table, 9, 2);

138 *dst++ = mpc7_idx30[t];

139 *dst++ = mpc7_idx31[t];

140 *dst++ = mpc7_idx32[t];

141 }

142 break;

143 case 2:

144 i1 = get_bits1(gb);

145 for(i = 0; i < SAMPLES_PER_BAND/2; i++){

146 t = get_vlc2(gb, quant_vlc[1][i1].table, 9, 2);

147 *dst++ = mpc7_idx50[t];

148 *dst++ = mpc7_idx51[t];

149 }

150 break;

151 case 3: case 4: case 5: case 6: case 7:

152 i1 = get_bits1(gb);

153 for(i = 0; i < SAMPLES_PER_BAND; i++)

154 *dst++ = get_vlc2(gb, quant_vlc[idx-1][i1].table, 9, 2);

155 break;

156 case 8: case 9: case 10: case 11: case 12:

157 case 13: case 14: case 15: case 16: case 17:

158 t = (1 << (idx - 2)) - 1;

159 for(i = 0; i < SAMPLES_PER_BAND; i++)

160 *dst++ = get_bits(gb, idx - 1) - t;

161 break;

162 default: // case 0 and -2..-17

163 return;

164 }

165 }

166

167 static int get_scale_idx(GetBitContext *gb, int ref)

168 {

169 int t = get_vlc2(gb, dscf_vlc.table, MPC7_DSCF_BITS, 1);

170 if (t == 8)

171 return get_bits(gb, 6);

172 return ref + t;

173 }

174

175 static int mpc7_decode_frame(AVCodecContext *avctx, AVFrame *frame,

176 int *got_frame_ptr, AVPacket *avpkt)

177 {

178 const uint8_t *buf = avpkt->data;

179 int buf_size;

180 MPCContext *c = avctx->priv_data;

181 GetBitContext gb;

182 int i, ch;

183 int mb = -1;

184 Band *bands = c->bands;

185 int off, ret, last_frame, skip;

186 int bits_used, bits_avail;

187

188 memset(bands, 0, sizeof(*bands) * (c->maxbands + 1));

189

190 buf_size = avpkt->size & ~3;

191 if (buf_size <= 0) {

192 av_log(avctx, AV_LOG_ERROR, "packet size is too small (%i bytes)\n",

193 avpkt->size);

194 return AVERROR_INVALIDDATA;

195 }

196 if (buf_size != avpkt->size) {

197 av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "

198 "extra bytes at the end will be skipped.\n");

199 }

200

201 skip = buf[0];

202 last_frame = buf[1];

203 buf += 4;

204 buf_size -= 4;

205

206 /* get output buffer */

207 frame->nb_samples = MPC_FRAME_SIZE;

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

209 return ret;

210

211 av_fast_padded_malloc(&c->bits, &c->buf_size, buf_size);

212 if (!c->bits)

213 return AVERROR(ENOMEM);

214 c->bdsp.bswap_buf((uint32_t *) c->bits, (const uint32_t *) buf,

215 buf_size >> 2);

216 if ((ret = init_get_bits8(&gb, c->bits, buf_size)) < 0)

217 return ret;

218 skip_bits_long(&gb, skip);

219

220 /* read subband indexes */

221 for(i = 0; i <= c->maxbands; i++){

222 for(ch = 0; ch < 2; ch++){

223 int t = i ? get_vlc2(&gb, hdr_vlc.table, MPC7_HDR_BITS, 1) : 4;

224 if(t == 4) bands[i].res[ch] = get_bits(&gb, 4);

225 else bands[i].res[ch] = bands[i-1].res[ch] + t;

226 if (bands[i].res[ch] < -1 || bands[i].res[ch] > 17) {

227 av_log(avctx, AV_LOG_ERROR, "subband index invalid\n");

228 return AVERROR_INVALIDDATA;

229 }

230 }

231

232 if(bands[i].res[0] || bands[i].res[1]){

233 mb = i;

234 if(c->MSS) bands[i].msf = get_bits1(&gb);

235 }

236 }

237 /* get scale indexes coding method */

238 for(i = 0; i <= mb; i++)

239 for(ch = 0; ch < 2; ch++)

240 if(bands[i].res[ch]) bands[i].scfi[ch] = get_vlc2(&gb, scfi_vlc.table, MPC7_SCFI_BITS, 1);

241 /* get scale indexes */

242 for(i = 0; i <= mb; i++){

243 for(ch = 0; ch < 2; ch++){

244 if(bands[i].res[ch]){

245 bands[i].scf_idx[ch][2] = c->oldDSCF[ch][i];

246 bands[i].scf_idx[ch][0] = get_scale_idx(&gb, bands[i].scf_idx[ch][2]);

247 switch(bands[i].scfi[ch]){

248 case 0:

249 bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]);

250 bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]);

251 break;

252 case 1:

253 bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]);

254 bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1];

255 break;

256 case 2:

257 bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];

258 bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]);

259 break;

260 case 3:

261 bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];

262 break;

263 }

264 c->oldDSCF[ch][i] = bands[i].scf_idx[ch][2];

265 }

266 }

267 }

268 /* get quantizers */

269 memset(c->Q, 0, sizeof(c->Q));

270 off = 0;

271 for(i = 0; i < BANDS; i++, off += SAMPLES_PER_BAND)

272 for(ch = 0; ch < 2; ch++)

273 idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off);

274

275 ff_mpc_dequantize_and_synth(c, mb, (int16_t **)frame->extended_data, 2);

276 if(last_frame)

277 frame->nb_samples = c->lastframelen;

278

279 bits_used = get_bits_count(&gb);

280 bits_avail = buf_size * 8;

281 if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) {

282 av_log(avctx, AV_LOG_ERROR, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail);

283 return AVERROR_INVALIDDATA;

284 }

285 if(c->frames_to_skip){

286 c->frames_to_skip--;

287 *got_frame_ptr = 0;

288 return avpkt->size;

289 }

290

291 *got_frame_ptr = 1;

292

293 return avpkt->size;

294 }

295

296 static void mpc7_decode_flush(AVCodecContext *avctx)

297 {

298 MPCContext *c = avctx->priv_data;

299

300 memset(c->oldDSCF, 0, sizeof(c->oldDSCF));

301 c->frames_to_skip = 32;

302 }

303

304 static av_cold int mpc7_decode_close(AVCodecContext *avctx)

305 {

306 MPCContext *c = avctx->priv_data;

307 av_freep(&c->bits);

308 c->buf_size = 0;

309 return 0;

310 }

311

312 const FFCodec ff_mpc7_decoder = {

313 .p.name = "mpc7",

314 .p.long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"),

315 .p.type = AVMEDIA_TYPE_AUDIO,

316 .p.id = AV_CODEC_ID_MUSEPACK7,

317 .priv_data_size = sizeof(MPCContext),

318 .init = mpc7_decode_init,

319 .close = mpc7_decode_close,

320 FF_CODEC_DECODE_CB(mpc7_decode_frame),

321 .flush = mpc7_decode_flush,

322 .p.capabilities = AV_CODEC_CAP_DR1,

323 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,

324 AV_SAMPLE_FMT_NONE },

325 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

326 };

MPC7_SCFI_BITS

#define MPC7_SCFI_BITS

Definition: mpc7data.h:34

dscf_vlc

static VLC dscf_vlc

Definition: mpc7.c:43

mpc7_scfi

static const uint8_t mpc7_scfi[MPC7_SCFI_SIZE *2]

Definition: mpc7data.h:35

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:291

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

mpc7_decode_frame

static int mpc7_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: mpc7.c:175

scfi_vlc

static VLC scfi_vlc

Definition: mpc7.c:43

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

ff_mpc7_decoder

const FFCodec ff_mpc7_decoder

Definition: mpc7.c:312

hdr_vlc

static VLC hdr_vlc

Definition: mpc7.c:43

mem_internal.h

av_lfg_init

av_cold void av_lfg_init(AVLFG *c, unsigned int seed)

Definition: lfg.c:32

thread.h

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:219

ff_mpadsp_init

av_cold void ff_mpadsp_init(MPADSPContext *s)

Definition: mpegaudiodsp.c:82

AVFrame

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

Definition: frame.h:325

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

quant_vlc

static VLC quant_vlc[MPC7_QUANT_VLC_TABLES][2]

Definition: mpc7.c:43

table

static const uint16_t table[]

Definition: prosumer.c:206

MPCContext

Definition: mpc.h:54

FFCodec

Definition: codec_internal.h:112

mpc7_decode_close

static av_cold int mpc7_decode_close(AVCodecContext *avctx)

Definition: mpc7.c:304

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:354

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:300

MPC7_HDR_BITS

#define MPC7_HDR_BITS

Definition: mpc7data.h:47

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:649

init

static int init

Definition: av_tx.c:47

mpc7_hdr

static const uint8_t mpc7_hdr[MPC7_HDR_SIZE *2]

Definition: mpc7data.h:48

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:379

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:2056

GetBitContext

Definition: get_bits.h:61

ff_mpc_dequantize_and_synth

void ff_mpc_dequantize_and_synth(MPCContext *c, int maxband, int16_t **out, int channels)

Definition: mpc.c:55

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

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

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

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:491

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

av_lfg_get

static unsigned int av_lfg_get(AVLFG *c)

Get the next random unsigned 32-bit number using an ALFG.

Definition: lfg.h:53

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

mpc7_idx32

static const int8_t mpc7_idx32[]

Definition: mpc7data.h:29

lfg.h

LOCAL_ALIGNED_16

#define LOCAL_ALIGNED_16(t, v,...)

Definition: mem_internal.h:130

mpc7_decode_flush

static void mpc7_decode_flush(AVCodecContext *avctx)

Definition: mpc7.c:296

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

get_bits.h

bands

static const float bands[]

Definition: af_superequalizer.c:56

mpc.h

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:177

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

ff_mpa_synth_init_fixed

void ff_mpa_synth_init_fixed(void)

mpc7_idx51

static const int8_t mpc7_idx51[]

Definition: mpc7data.h:31

mpc7_quant_vlcs

static const uint8_t mpc7_quant_vlcs[177 *2 *2]

Definition: mpc7data.h:62

MPC_FRAME_SIZE

#define MPC_FRAME_SIZE

Definition: mpc.h:43

INIT_VLC_STATIC_FROM_LENGTHS

#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)

Definition: vlc.h:131

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

ff_init_vlc_from_lengths

int ff_init_vlc_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: vlc.c:328

MPC7_HDR_SIZE

#define MPC7_HDR_SIZE

Definition: mpc7data.h:46

mpc7_init_static

static av_cold void mpc7_init_static(void)

Definition: mpc7.c:45

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:787

AVOnce

#define AVOnce

Definition: thread.h:176

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

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

MPC7_QUANT_VLC_TABLES

#define MPC7_QUANT_VLC_TABLES

Definition: mpc7data.h:53

VLC::table_allocated

int table_allocated

Definition: vlc.h:34

ff_get_buffer

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

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

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:290

codec_internal.h

SAMPLES_PER_BAND

#define SAMPLES_PER_BAND

Definition: mpc.h:42

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1014

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

VLCElem

Definition: vlc.h:27

MPC7_SCFI_SIZE

#define MPC7_SCFI_SIZE

Definition: mpc7data.h:33

mpc7_quant_vlc_sizes

static const uint8_t mpc7_quant_vlc_sizes[MPC7_QUANT_VLC_TABLES]

Definition: mpc7data.h:54

offset

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 offset

Definition: writing_filters.txt:86

#define mb

Definition: vf_colormatrix.c:101

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:64

get_scale_idx

static int get_scale_idx(GetBitContext *gb, int ref)

Definition: mpc7.c:167

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

Definition: cbs_h2645.c:269

mpc7_idx31

static const int8_t mpc7_idx31[]

Definition: mpc7data.h:28

mpc7data.h

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:490

internal.h

BANDS

#define BANDS

Definition: imc.c:57

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:48

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

mpc7_decode_init

static av_cold int mpc7_decode_init(AVCodecContext *avctx)

Definition: mpc7.c:75

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

avcodec.h

mpc7_idx30

static const int8_t mpc7_idx30[]

Definition: mpc7data.h:27

ret

Definition: filter_design.txt:187

INIT_VLC_STATIC_OVERLONG

#define INIT_VLC_STATIC_OVERLONG

Definition: vlc.h:101

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

mpc7_dscf

static const uint8_t mpc7_dscf[MPC7_DSCF_SIZE *2]

Definition: mpc7data.h:41

AVCodecContext

main external API structure.

Definition: avcodec.h:389

mpc7_idx50

static const int8_t mpc7_idx50[]

Definition: mpc7data.h:30

channel_layout.h

Band