FFmpeg
mpc8.c
Go to the documentation of this file.
1 /*
2  * Musepack SV8 decoder
3  * Copyright (c) 2007 Konstantin Shishkov
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 
22 /**
23  * @file
24  * MPEG Audio Layer 1/2 -like codec with frames of 1152 samples
25  * divided into 32 subbands.
26  */
27 
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/lfg.h"
30 #include "avcodec.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "mpegaudiodsp.h"
34 
35 #include "mpc.h"
36 #include "mpc8data.h"
37 #include "mpc8huff.h"
38 
39 static VLC band_vlc, scfi_vlc[2], dscf_vlc[2], res_vlc[2];
40 static VLC q1_vlc, q2_vlc[2], q3_vlc[2], quant_vlc[4][2], q9up_vlc;
41 
42 static const int q3_offsets[2] = { MPC8_Q3_OFFSET, MPC8_Q4_OFFSET };
43 static const int quant_offsets[6] = { MPC8_Q5_OFFSET, MPC8_Q6_OFFSET, MPC8_Q7_OFFSET, MPC8_Q8_OFFSET };
44 
45 static inline int mpc8_dec_base(GetBitContext *gb, int k, int n)
46 {
47  int len = mpc8_cnk_len[k-1][n-1] - 1;
48  int code = len ? get_bits_long(gb, len) : 0;
49 
50  if (code >= mpc8_cnk_lost[k-1][n-1])
51  code = ((code << 1) | get_bits1(gb)) - mpc8_cnk_lost[k-1][n-1];
52 
53  return code;
54 }
55 
56 static inline int mpc8_dec_enum(GetBitContext *gb, int k, int n)
57 {
58  int bits = 0;
59  const uint32_t * C = mpc8_cnk[k-1];
60  int code = mpc8_dec_base(gb, k, n);
61 
62  do {
63  n--;
64  if (code >= C[n]) {
65  bits |= 1U << n;
66  code -= C[n];
67  C -= 32;
68  k--;
69  }
70  } while(k > 0);
71 
72  return bits;
73 }
74 
75 static inline int mpc8_get_mod_golomb(GetBitContext *gb, int m)
76 {
77  if(mpc8_cnk_len[0][m] < 1) return 0;
78  return mpc8_dec_base(gb, 1, m+1);
79 }
80 
81 static int mpc8_get_mask(GetBitContext *gb, int size, int t)
82 {
83  int mask = 0;
84 
85  if(t && t != size)
86  mask = mpc8_dec_enum(gb, FFMIN(t, size - t), size);
87  if((t << 1) > size) mask = ~mask;
88 
89  return mask;
90 }
91 
92 static const uint16_t vlc_offsets[13] = {
93  0, 640, 1184, 1748, 2298, 2426, 2554, 3066, 3578, 4106, 4618, 5196, 5708
94 };
95 
96 static av_cold int mpc8_decode_init(AVCodecContext * avctx)
97 {
98  int i;
99  MPCContext *c = avctx->priv_data;
100  GetBitContext gb;
101  static int vlc_initialized = 0;
102  int channels;
103 
104  static VLC_TYPE band_table[542][2];
105  static VLC_TYPE q1_table[520][2];
106  static VLC_TYPE q9up_table[524][2];
107  static VLC_TYPE scfi0_table[1 << MPC8_SCFI0_BITS][2];
108  static VLC_TYPE scfi1_table[1 << MPC8_SCFI1_BITS][2];
109  static VLC_TYPE dscf0_table[560][2];
110  static VLC_TYPE dscf1_table[598][2];
111  static VLC_TYPE q3_0_table[512][2];
112  static VLC_TYPE q3_1_table[516][2];
113  static VLC_TYPE codes_table[5708][2];
114 
115  if(avctx->extradata_size < 2){
116  av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
117  return -1;
118  }
119  memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
120  av_lfg_init(&c->rnd, 0xDEADBEEF);
121  ff_mpadsp_init(&c->mpadsp);
122 
123  ff_mpc_init();
124 
125  init_get_bits(&gb, avctx->extradata, 16);
126 
127  skip_bits(&gb, 3);//sample rate
128  c->maxbands = get_bits(&gb, 5) + 1;
129  if (c->maxbands >= BANDS) {
130  av_log(avctx,AV_LOG_ERROR, "maxbands %d too high\n", c->maxbands);
131  return AVERROR_INVALIDDATA;
132  }
133  channels = get_bits(&gb, 4) + 1;
134  if (channels > 2) {
135  avpriv_request_sample(avctx, "Multichannel MPC SV8");
136  return AVERROR_PATCHWELCOME;
137  }
138  c->MSS = get_bits1(&gb);
139  c->frames = 1 << (get_bits(&gb, 3) * 2);
140 
141  avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
142  avctx->channel_layout = (channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
143  avctx->channels = channels;
144 
145  if(vlc_initialized) return 0;
146  av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
147 
148  band_vlc.table = band_table;
149  band_vlc.table_allocated = 542;
150  init_vlc(&band_vlc, MPC8_BANDS_BITS, MPC8_BANDS_SIZE,
151  mpc8_bands_bits, 1, 1,
152  mpc8_bands_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
153 
154  q1_vlc.table = q1_table;
155  q1_vlc.table_allocated = 520;
156  init_vlc(&q1_vlc, MPC8_Q1_BITS, MPC8_Q1_SIZE,
157  mpc8_q1_bits, 1, 1,
158  mpc8_q1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
159  q9up_vlc.table = q9up_table;
160  q9up_vlc.table_allocated = 524;
161  init_vlc(&q9up_vlc, MPC8_Q9UP_BITS, MPC8_Q9UP_SIZE,
162  mpc8_q9up_bits, 1, 1,
163  mpc8_q9up_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
164 
165  scfi_vlc[0].table = scfi0_table;
166  scfi_vlc[0].table_allocated = 1 << MPC8_SCFI0_BITS;
167  init_vlc(&scfi_vlc[0], MPC8_SCFI0_BITS, MPC8_SCFI0_SIZE,
168  mpc8_scfi0_bits, 1, 1,
169  mpc8_scfi0_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
170  scfi_vlc[1].table = scfi1_table;
171  scfi_vlc[1].table_allocated = 1 << MPC8_SCFI1_BITS;
172  init_vlc(&scfi_vlc[1], MPC8_SCFI1_BITS, MPC8_SCFI1_SIZE,
173  mpc8_scfi1_bits, 1, 1,
174  mpc8_scfi1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
175 
176  dscf_vlc[0].table = dscf0_table;
177  dscf_vlc[0].table_allocated = 560;
178  init_vlc(&dscf_vlc[0], MPC8_DSCF0_BITS, MPC8_DSCF0_SIZE,
179  mpc8_dscf0_bits, 1, 1,
180  mpc8_dscf0_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
181  dscf_vlc[1].table = dscf1_table;
182  dscf_vlc[1].table_allocated = 598;
183  init_vlc(&dscf_vlc[1], MPC8_DSCF1_BITS, MPC8_DSCF1_SIZE,
184  mpc8_dscf1_bits, 1, 1,
185  mpc8_dscf1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
186 
187  q3_vlc[0].table = q3_0_table;
188  q3_vlc[0].table_allocated = 512;
189  ff_init_vlc_sparse(&q3_vlc[0], MPC8_Q3_BITS, MPC8_Q3_SIZE,
190  mpc8_q3_bits, 1, 1,
191  mpc8_q3_codes, 1, 1,
192  mpc8_q3_syms, 1, 1, INIT_VLC_USE_NEW_STATIC);
193  q3_vlc[1].table = q3_1_table;
194  q3_vlc[1].table_allocated = 516;
195  ff_init_vlc_sparse(&q3_vlc[1], MPC8_Q4_BITS, MPC8_Q4_SIZE,
196  mpc8_q4_bits, 1, 1,
197  mpc8_q4_codes, 1, 1,
198  mpc8_q4_syms, 1, 1, INIT_VLC_USE_NEW_STATIC);
199 
200  for(i = 0; i < 2; i++){
201  res_vlc[i].table = &codes_table[vlc_offsets[0+i]];
202  res_vlc[i].table_allocated = vlc_offsets[1+i] - vlc_offsets[0+i];
203  init_vlc(&res_vlc[i], MPC8_RES_BITS, MPC8_RES_SIZE,
204  &mpc8_res_bits[i], 1, 1,
205  &mpc8_res_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
206 
207  q2_vlc[i].table = &codes_table[vlc_offsets[2+i]];
208  q2_vlc[i].table_allocated = vlc_offsets[3+i] - vlc_offsets[2+i];
209  init_vlc(&q2_vlc[i], MPC8_Q2_BITS, MPC8_Q2_SIZE,
210  &mpc8_q2_bits[i], 1, 1,
211  &mpc8_q2_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
212 
213  quant_vlc[0][i].table = &codes_table[vlc_offsets[4+i]];
214  quant_vlc[0][i].table_allocated = vlc_offsets[5+i] - vlc_offsets[4+i];
215  init_vlc(&quant_vlc[0][i], MPC8_Q5_BITS, MPC8_Q5_SIZE,
216  &mpc8_q5_bits[i], 1, 1,
217  &mpc8_q5_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
218  quant_vlc[1][i].table = &codes_table[vlc_offsets[6+i]];
219  quant_vlc[1][i].table_allocated = vlc_offsets[7+i] - vlc_offsets[6+i];
220  init_vlc(&quant_vlc[1][i], MPC8_Q6_BITS, MPC8_Q6_SIZE,
221  &mpc8_q6_bits[i], 1, 1,
222  &mpc8_q6_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
223  quant_vlc[2][i].table = &codes_table[vlc_offsets[8+i]];
224  quant_vlc[2][i].table_allocated = vlc_offsets[9+i] - vlc_offsets[8+i];
225  init_vlc(&quant_vlc[2][i], MPC8_Q7_BITS, MPC8_Q7_SIZE,
226  &mpc8_q7_bits[i], 1, 1,
227  &mpc8_q7_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
228  quant_vlc[3][i].table = &codes_table[vlc_offsets[10+i]];
229  quant_vlc[3][i].table_allocated = vlc_offsets[11+i] - vlc_offsets[10+i];
230  init_vlc(&quant_vlc[3][i], MPC8_Q8_BITS, MPC8_Q8_SIZE,
231  &mpc8_q8_bits[i], 1, 1,
232  &mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
233  }
234  vlc_initialized = 1;
235 
236  return 0;
237 }
238 
239 static int mpc8_decode_frame(AVCodecContext * avctx, void *data,
240  int *got_frame_ptr, AVPacket *avpkt)
241 {
242  AVFrame *frame = data;
243  const uint8_t *buf = avpkt->data;
244  int buf_size = avpkt->size;
245  MPCContext *c = avctx->priv_data;
246  GetBitContext gb2, *gb = &gb2;
247  int i, j, k, ch, cnt, res, t;
248  Band *bands = c->bands;
249  int off;
250  int maxband, keyframe;
251  int last[2];
252 
253  keyframe = c->cur_frame == 0;
254 
255  if(keyframe){
256  memset(c->Q, 0, sizeof(c->Q));
257  c->last_bits_used = 0;
258  }
259  if ((res = init_get_bits8(gb, buf, buf_size)) < 0)
260  return res;
261 
262  skip_bits(gb, c->last_bits_used & 7);
263 
264  if(keyframe)
265  maxband = mpc8_get_mod_golomb(gb, c->maxbands + 1);
266  else{
267  maxband = c->last_max_band + get_vlc2(gb, band_vlc.table, MPC8_BANDS_BITS, 2);
268  if(maxband > 32) maxband -= 33;
269  }
270 
271  if (get_bits_left(gb) < 0) {
272  *got_frame_ptr = 0;
273  return buf_size;
274  }
275 
276  if(maxband > c->maxbands + 1) {
277  av_log(avctx, AV_LOG_ERROR, "maxband %d too large\n",maxband);
278  return AVERROR_INVALIDDATA;
279  }
280  c->last_max_band = maxband;
281 
282  /* read subband indexes */
283  if(maxband){
284  last[0] = last[1] = 0;
285  for(i = maxband - 1; i >= 0; i--){
286  for(ch = 0; ch < 2; ch++){
287  last[ch] = get_vlc2(gb, res_vlc[last[ch] > 2].table, MPC8_RES_BITS, 2) + last[ch];
288  if(last[ch] > 15) last[ch] -= 17;
289  bands[i].res[ch] = last[ch];
290  }
291  }
292  if(c->MSS){
293  int mask;
294 
295  cnt = 0;
296  for(i = 0; i < maxband; i++)
297  if(bands[i].res[0] || bands[i].res[1])
298  cnt++;
299  t = mpc8_get_mod_golomb(gb, cnt);
300  mask = mpc8_get_mask(gb, cnt, t);
301  for(i = maxband - 1; i >= 0; i--)
302  if(bands[i].res[0] || bands[i].res[1]){
303  bands[i].msf = mask & 1;
304  mask >>= 1;
305  }
306  }
307  }
308  for(i = maxband; i < c->maxbands; i++)
309  bands[i].res[0] = bands[i].res[1] = 0;
310 
311  if(keyframe){
312  for(i = 0; i < 32; i++)
313  c->oldDSCF[0][i] = c->oldDSCF[1][i] = 1;
314  }
315 
316  for(i = 0; i < maxband; i++){
317  if(bands[i].res[0] || bands[i].res[1]){
318  cnt = !!bands[i].res[0] + !!bands[i].res[1] - 1;
319  if(cnt >= 0){
320  t = get_vlc2(gb, scfi_vlc[cnt].table, scfi_vlc[cnt].bits, 1);
321  if(bands[i].res[0]) bands[i].scfi[0] = t >> (2 * cnt);
322  if(bands[i].res[1]) bands[i].scfi[1] = t & 3;
323  }
324  }
325  }
326 
327  for(i = 0; i < maxband; i++){
328  for(ch = 0; ch < 2; ch++){
329  if(!bands[i].res[ch]) continue;
330 
331  if(c->oldDSCF[ch][i]){
332  bands[i].scf_idx[ch][0] = get_bits(gb, 7) - 6;
333  c->oldDSCF[ch][i] = 0;
334  }else{
335  t = get_vlc2(gb, dscf_vlc[1].table, MPC8_DSCF1_BITS, 2);
336  if(t == 64)
337  t += get_bits(gb, 6);
338  bands[i].scf_idx[ch][0] = ((bands[i].scf_idx[ch][2] + t - 25) & 0x7F) - 6;
339  }
340  for(j = 0; j < 2; j++){
341  if((bands[i].scfi[ch] << j) & 2)
342  bands[i].scf_idx[ch][j + 1] = bands[i].scf_idx[ch][j];
343  else{
344  t = get_vlc2(gb, dscf_vlc[0].table, MPC8_DSCF0_BITS, 2);
345  if(t == 31)
346  t = 64 + get_bits(gb, 6);
347  bands[i].scf_idx[ch][j + 1] = ((bands[i].scf_idx[ch][j] + t - 25) & 0x7F) - 6;
348  }
349  }
350  }
351  }
352 
353  for(i = 0, off = 0; i < maxband; i++, off += SAMPLES_PER_BAND){
354  for(ch = 0; ch < 2; ch++){
355  res = bands[i].res[ch];
356  switch(res){
357  case -1:
358  for(j = 0; j < SAMPLES_PER_BAND; j++)
359  c->Q[ch][off + j] = (av_lfg_get(&c->rnd) & 0x3FC) - 510;
360  break;
361  case 0:
362  break;
363  case 1:
364  for(j = 0; j < SAMPLES_PER_BAND; j += SAMPLES_PER_BAND / 2){
365  cnt = get_vlc2(gb, q1_vlc.table, MPC8_Q1_BITS, 2);
366  t = mpc8_get_mask(gb, 18, cnt);
367  for(k = 0; k < SAMPLES_PER_BAND / 2; k++)
368  c->Q[ch][off + j + k] = t & (1 << (SAMPLES_PER_BAND / 2 - k - 1))
369  ? (get_bits1(gb) << 1) - 1 : 0;
370  }
371  break;
372  case 2:
373  cnt = 6;//2*mpc8_thres[res]
374  for(j = 0; j < SAMPLES_PER_BAND; j += 3){
375  t = get_vlc2(gb, q2_vlc[cnt > 3].table, MPC8_Q2_BITS, 2);
376  c->Q[ch][off + j + 0] = mpc8_idx50[t];
377  c->Q[ch][off + j + 1] = mpc8_idx51[t];
378  c->Q[ch][off + j + 2] = mpc8_idx52[t];
379  cnt = (cnt >> 1) + mpc8_huffq2[t];
380  }
381  break;
382  case 3:
383  case 4:
384  for(j = 0; j < SAMPLES_PER_BAND; j += 2){
385  t = get_vlc2(gb, q3_vlc[res - 3].table, MPC8_Q3_BITS, 2) + q3_offsets[res - 3];
386  c->Q[ch][off + j + 1] = t >> 4;
387  c->Q[ch][off + j + 0] = (t & 8) ? (t & 0xF) - 16 : (t & 0xF);
388  }
389  break;
390  case 5:
391  case 6:
392  case 7:
393  case 8:
394  cnt = 2 * mpc8_thres[res];
395  for(j = 0; j < SAMPLES_PER_BAND; j++){
396  t = get_vlc2(gb, quant_vlc[res - 5][cnt > mpc8_thres[res]].table, quant_vlc[res - 5][cnt > mpc8_thres[res]].bits, 2) + quant_offsets[res - 5];
397  c->Q[ch][off + j] = t;
398  cnt = (cnt >> 1) + FFABS(c->Q[ch][off + j]);
399  }
400  break;
401  default:
402  for(j = 0; j < SAMPLES_PER_BAND; j++){
403  c->Q[ch][off + j] = get_vlc2(gb, q9up_vlc.table, MPC8_Q9UP_BITS, 2);
404  if(res != 9){
405  c->Q[ch][off + j] <<= res - 9;
406  c->Q[ch][off + j] |= get_bits(gb, res - 9);
407  }
408  c->Q[ch][off + j] -= (1 << (res - 2)) - 1;
409  }
410  }
411  }
412  }
413 
414  frame->nb_samples = MPC_FRAME_SIZE;
415  if ((res = ff_get_buffer(avctx, frame, 0)) < 0)
416  return res;
417 
418  ff_mpc_dequantize_and_synth(c, maxband - 1,
419  (int16_t **)frame->extended_data,
420  avctx->channels);
421 
422  c->cur_frame++;
423 
424  c->last_bits_used = get_bits_count(gb);
425  if(c->cur_frame >= c->frames)
426  c->cur_frame = 0;
427  if (get_bits_left(gb) < 0) {
428  av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -get_bits_left(gb));
429  c->last_bits_used = buf_size << 3;
430  } else if (c->cur_frame == 0 && get_bits_left(gb) < 8) {// we have only padding left
431  c->last_bits_used = buf_size << 3;
432  }
433 
434  *got_frame_ptr = 1;
435 
436  return c->cur_frame ? c->last_bits_used >> 3 : buf_size;
437 }
438 
439 static av_cold void mpc8_decode_flush(AVCodecContext *avctx)
440 {
441  MPCContext *c = avctx->priv_data;
442  c->cur_frame = 0;
443 }
444 
445 AVCodec ff_mpc8_decoder = {
446  .name = "mpc8",
447  .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
448  .type = AVMEDIA_TYPE_AUDIO,
449  .id = AV_CODEC_ID_MUSEPACK8,
450  .priv_data_size = sizeof(MPCContext),
451  .init = mpc8_decode_init,
452  .decode = mpc8_decode_frame,
453  .flush = mpc8_decode_flush,
454  .capabilities = AV_CODEC_CAP_DR1,
455  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
456  AV_SAMPLE_FMT_NONE },
457 };
q1_vlc
static VLC q1_vlc
Definition: mpc8.c:40
MPC8_Q9UP_BITS
#define MPC8_Q9UP_BITS
Definition: mpc8huff.h:163
AVCodec
AVCodec.
Definition: avcodec.h:3481
mpc8_q6_codes
static const uint8_t mpc8_q6_codes[2][MPC8_Q6_SIZE]
Definition: mpc8huff.h:419
MPC8_Q3_OFFSET
#define MPC8_Q3_OFFSET
Definition: mpc8huff.h:316
MPC8_DSCF0_SIZE
#define MPC8_DSCF0_SIZE
Definition: mpc8huff.h:69
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
mpc8data.h
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
MPC8_Q8_BITS
#define MPC8_Q8_BITS
Definition: mpc8huff.h:498
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
n
int n
Definition: avisynth_c.h:760
MPC8_Q7_BITS
#define MPC8_Q7_BITS
Definition: mpc8huff.h:449
mpc8_res_bits
static const int8_t mpc8_res_bits[2][MPC8_RES_SIZE]
Definition: mpc8huff.h:135
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
mpc8_q9up_bits
static const int8_t mpc8_q9up_bits[MPC8_Q9UP_SIZE]
Definition: mpc8huff.h:199
mpc8_decode_flush
static av_cold void mpc8_decode_flush(AVCodecContext *avctx)
Definition: mpc8.c:439
quant_offsets
static const int quant_offsets[6]
Definition: mpc8.c:43
MPC8_RES_SIZE
#define MPC8_RES_SIZE
Definition: mpc8huff.h:120
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
MPC8_Q9UP_SIZE
#define MPC8_Q9UP_SIZE
Definition: mpc8huff.h:162
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:31
mpc8_dec_base
static int mpc8_dec_base(GetBitContext *gb, int k, int n)
Definition: mpc8.c:45
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
internal.h
MPC8_Q6_BITS
#define MPC8_Q6_BITS
Definition: mpc8huff.h:416
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:91
mpc8_q8_bits
static const int8_t mpc8_q8_bits[2][MPC8_Q8_SIZE]
Definition: mpc8huff.h:539
MPCContext
Definition: mpc.h:52
scfi_vlc
static VLC scfi_vlc[2]
Definition: mpc8.c:39
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
channels
channels
Definition: aptx.c:30
MPC8_Q8_OFFSET
#define MPC8_Q8_OFFSET
Definition: mpc8huff.h:499
MPC8_Q6_SIZE
#define MPC8_Q6_SIZE
Definition: mpc8huff.h:415
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
mpc8_q4_bits
static const int8_t mpc8_q4_bits[MPC8_Q4_SIZE]
Definition: mpc8huff.h:363
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
mpc8huff.h
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
mpc8_q4_syms
static const int8_t mpc8_q4_syms[MPC8_Q4_SIZE]
Definition: mpc8huff.h:376
mpc8_scfi1_bits
static const int8_t mpc8_scfi1_bits[MPC8_SCFI1_SIZE]
Definition: mpc8huff.h:63
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
mpc8_bands_bits
static const int8_t mpc8_bands_bits[MPC8_BANDS_SIZE]
Definition: mpc8huff.h:37
U
#define U(x)
Definition: vp56_arith.h:37
MPC8_RES_BITS
#define MPC8_RES_BITS
Definition: mpc8huff.h:121
mpc8_get_mod_golomb
static int mpc8_get_mod_golomb(GetBitContext *gb, int m)
Definition: mpc8.c:75
GetBitContext
Definition: get_bits.h:61
mpc8_get_mask
static int mpc8_get_mask(GetBitContext *gb, int size, int t)
Definition: mpc8.c:81
ff_mpc_dequantize_and_synth
void ff_mpc_dequantize_and_synth(MPCContext *c, int maxband, int16_t **out, int channels)
Definition: mpc.c:61
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
mpc8_cnk_lost
static const uint32_t mpc8_cnk_lost[16][33]
Definition: mpc8data.h:101
mpc8_cnk_len
static const uint8_t mpc8_cnk_len[16][33]
Definition: mpc8data.h:80
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
MPC8_SCFI1_SIZE
#define MPC8_SCFI1_SIZE
Definition: mpc8huff.h:55
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
mask
static const uint16_t mask[17]
Definition: lzw.c:38
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1667
MPC8_Q5_OFFSET
#define MPC8_Q5_OFFSET
Definition: mpc8huff.h:392
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
vlc_offsets
static const uint16_t vlc_offsets[13]
Definition: mpc8.c:92
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
lfg.h
bits
uint8_t bits
Definition: vp3data.h:202
MPC8_DSCF1_SIZE
#define MPC8_DSCF1_SIZE
Definition: mpc8huff.h:94
mpc8_idx52
static const int8_t mpc8_idx52[125]
Definition: mpc8data.h:41
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
mpc8_dscf0_codes
static const uint8_t mpc8_dscf0_codes[MPC8_DSCF0_SIZE]
Definition: mpc8huff.h:72
ff_mpc_init
av_cold void ff_mpc_init(void)
Definition: mpc.c:37
get_bits.h
mpc8_q8_codes
static const uint8_t mpc8_q8_codes[2][MPC8_Q8_SIZE]
Definition: mpc8huff.h:501
mpc8_decode_frame
static int mpc8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: mpc8.c:239
bands
static const float bands[]
Definition: af_superequalizer.c:56
mpc8_q2_codes
static const uint8_t mpc8_q2_codes[2][MPC8_Q2_SIZE]
Definition: mpc8huff.h:237
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
MPC8_Q1_BITS
#define MPC8_Q1_BITS
Definition: mpc8huff.h:149
mpc.h
mpc8_q1_bits
static const int8_t mpc8_q1_bits[MPC8_Q1_SIZE]
Definition: mpc8huff.h:156
MPC8_Q3_SIZE
#define MPC8_Q3_SIZE
Definition: mpc8huff.h:314
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
MPC_FRAME_SIZE
#define MPC_FRAME_SIZE
Definition: mpc.h:41
mpc8_q1_codes
static const uint8_t mpc8_q1_codes[MPC8_Q1_SIZE]
Definition: mpc8huff.h:151
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
mpc8_q5_bits
static const int8_t mpc8_q5_bits[2][MPC8_Q5_SIZE]
Definition: mpc8huff.h:404
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:273
mpc8_huffq2
static const int8_t mpc8_huffq2[5 *5 *5]
Definition: mpc8data.h:50
quant_vlc
static VLC quant_vlc[4][2]
Definition: mpc8.c:40
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
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
mpc8_scfi0_codes
static const uint8_t mpc8_scfi0_codes[MPC8_SCFI0_SIZE]
Definition: mpc8huff.h:48
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
MPC8_Q3_BITS
#define MPC8_Q3_BITS
Definition: mpc8huff.h:315
AVPacket::size
int size
Definition: avcodec.h:1478
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:188
mpc8_thres
static const unsigned int mpc8_thres[]
Definition: mpc8data.h:49
band_vlc
static VLC band_vlc
Definition: mpc8.c:39
SAMPLES_PER_BAND
#define SAMPLES_PER_BAND
Definition: mpc.h:40
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
MPC8_Q4_OFFSET
#define MPC8_Q4_OFFSET
Definition: mpc8huff.h:348
size
int size
Definition: twinvq_data.h:11134
MPC8_Q2_BITS
#define MPC8_Q2_BITS
Definition: mpc8huff.h:235
MPC8_Q7_OFFSET
#define MPC8_Q7_OFFSET
Definition: mpc8huff.h:450
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
MPC8_SCFI1_BITS
#define MPC8_SCFI1_BITS
Definition: mpc8huff.h:56
mpc8_q9up_codes
static const uint8_t mpc8_q9up_codes[MPC8_Q9UP_SIZE]
Definition: mpc8huff.h:165
MPC8_Q6_OFFSET
#define MPC8_Q6_OFFSET
Definition: mpc8huff.h:417
MPC8_Q5_SIZE
#define MPC8_Q5_SIZE
Definition: mpc8huff.h:390
mpc8_cnk
static const uint32_t mpc8_cnk[16][32]
Definition: mpc8data.h:60
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
mpc8_scfi1_codes
static const uint8_t mpc8_scfi1_codes[MPC8_SCFI1_SIZE]
Definition: mpc8huff.h:58
MPC8_Q7_SIZE
#define MPC8_Q7_SIZE
Definition: mpc8huff.h:448
MPC8_Q8_SIZE
#define MPC8_Q8_SIZE
Definition: mpc8huff.h:497
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2226
q9up_vlc
static VLC q9up_vlc
Definition: mpc8.c:40
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
mpc8_q3_bits
static const int8_t mpc8_q3_bits[MPC8_Q3_SIZE]
Definition: mpc8huff.h:327
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
BANDS
#define BANDS
Definition: imc.c:52
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
MPC8_Q4_BITS
#define MPC8_Q4_BITS
Definition: mpc8huff.h:347
mpc8_dec_enum
static int mpc8_dec_enum(GetBitContext *gb, int k, int n)
Definition: mpc8.c:56
mpc8_q7_codes
static const uint8_t mpc8_q7_codes[2][MPC8_Q7_SIZE]
Definition: mpc8huff.h:452
uint8_t
uint8_t
Definition: audio_convert.c:194
MPC8_DSCF1_BITS
#define MPC8_DSCF1_BITS
Definition: mpc8huff.h:95
MPC8_Q5_BITS
#define MPC8_Q5_BITS
Definition: mpc8huff.h:391
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
len
int len
Definition: vorbis_enc_data.h:452
MPC8_SCFI0_SIZE
#define MPC8_SCFI0_SIZE
Definition: mpc8huff.h:45
mpc8_q2_bits
static const int8_t mpc8_q2_bits[2][MPC8_Q2_SIZE]
Definition: mpc8huff.h:275
mpc8_bands_codes
static const uint8_t mpc8_bands_codes[MPC8_BANDS_SIZE]
Definition: mpc8huff.h:30
res_vlc
static VLC res_vlc[2]
Definition: mpc8.c:39
avcodec.h
q3_vlc
static VLC q3_vlc[2]
Definition: mpc8.c:40
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
q3_offsets
static const int q3_offsets[2]
Definition: mpc8.c:42
mpc8_q3_syms
static const int8_t mpc8_q3_syms[MPC8_Q3_SIZE]
Definition: mpc8huff.h:336
AV_CODEC_ID_MUSEPACK8
@ AV_CODEC_ID_MUSEPACK8
Definition: avcodec.h:598
ff_mpc8_decoder
AVCodec ff_mpc8_decoder
Definition: mpc8.c:445
dscf_vlc
static VLC dscf_vlc[2]
Definition: mpc8.c:39
mpc8_decode_init
static av_cold int mpc8_decode_init(AVCodecContext *avctx)
Definition: mpc8.c:96
mpc8_q4_codes
static const uint8_t mpc8_q4_codes[MPC8_Q4_SIZE]
Definition: mpc8huff.h:350
MPC8_Q4_SIZE
#define MPC8_Q4_SIZE
Definition: mpc8huff.h:346
mpc8_dscf1_codes
static const uint8_t mpc8_dscf1_codes[MPC8_DSCF1_SIZE]
Definition: mpc8huff.h:97
mpc8_dscf1_bits
static const int8_t mpc8_dscf1_bits[MPC8_DSCF1_SIZE]
Definition: mpc8huff.h:108
mpc8_q3_codes
static const uint8_t mpc8_q3_codes[MPC8_Q3_SIZE]
Definition: mpc8huff.h:318
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
channel_layout.h
Band
Subband structure - hold all variables for each subband.
Definition: mpc.h:44
mpc8_idx50
static const int8_t mpc8_idx50[125]
Definition: mpc8data.h:27
MPC8_DSCF0_BITS
#define MPC8_DSCF0_BITS
Definition: mpc8huff.h:70
VLC
Definition: vlc.h:26
MPC8_BANDS_BITS
#define MPC8_BANDS_BITS
Definition: mpc8huff.h:28
MPC8_SCFI0_BITS
#define MPC8_SCFI0_BITS
Definition: mpc8huff.h:46
mpc8_q5_codes
static const uint8_t mpc8_q5_codes[2][MPC8_Q5_SIZE]
Definition: mpc8huff.h:394
mpc8_dscf0_bits
static const int8_t mpc8_dscf0_bits[MPC8_DSCF0_SIZE]
Definition: mpc8huff.h:82
MPC8_BANDS_SIZE
#define MPC8_BANDS_SIZE
Definition: mpc8huff.h:27
MPC8_Q1_SIZE
#define MPC8_Q1_SIZE
Definition: mpc8huff.h:148
mpegaudiodsp.h
mpc8_res_codes
static const uint8_t mpc8_res_codes[2][MPC8_RES_SIZE]
Definition: mpc8huff.h:123
mpc8_q7_bits
static const int8_t mpc8_q7_bits[2][MPC8_Q7_SIZE]
Definition: mpc8huff.h:474
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
mpc8_scfi0_bits
static const int8_t mpc8_scfi0_bits[MPC8_SCFI0_SIZE]
Definition: mpc8huff.h:51
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
mpc8_idx51
static const int8_t mpc8_idx51[125]
Definition: mpc8data.h:34
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
mpc8_q6_bits
static const int8_t mpc8_q6_bits[2][MPC8_Q6_SIZE]
Definition: mpc8huff.h:433
q2_vlc
static VLC q2_vlc[2]
Definition: mpc8.c:40
MPC8_Q2_SIZE
#define MPC8_Q2_SIZE
Definition: mpc8huff.h:234
Generated on Wed Aug 24 2022 21:26:51 for FFmpeg by   doxygen 1.8.17