FFmpeg: libavcodec/flacdec.c Source File

FFmpeg
flacdec.c
Go to the documentation of this file.
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
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  * FLAC (Free Lossless Audio Codec) decoder
25  * @author Alex Beregszaszi
26  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33 
34 #include <limits.h>
35 
36 #include "libavutil/avassert.h"
37 #include "libavutil/crc.h"
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "get_bits.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46 #include "flacdsp.h"
47 #include "thread.h"
48 #include "unary.h"
49 
50 
51  typedef struct FLACContext {
52   AVClass *class;
53   struct FLACStreaminfo flac_stream_info;
54 
55   AVCodecContext *avctx; ///< parent AVCodecContext
56   GetBitContext gb; ///< GetBitContext initialized to start at the current frame
57 
58   int blocksize; ///< number of samples in the current frame
59   int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
60   int ch_mode; ///< channel decorrelation type in the current frame
61   int got_streaminfo; ///< indicates if the STREAMINFO has been read
62 
63   int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
64   uint8_t *decoded_buffer;
65   unsigned int decoded_buffer_size;
66   int buggy_lpc; ///< use workaround for old lavc encoded files
67 
68   FLACDSPContext dsp;
69 } FLACContext;
70 
71 static int allocate_buffers(FLACContext *s);
72 
73  static void flac_set_bps(FLACContext *s)
74 {
75  enum AVSampleFormat req = s->avctx->request_sample_fmt;
76  int need32 = s->flac_stream_info.bps > 16;
77  int want32 = av_get_bytes_per_sample(req) > 2;
78  int planar = av_sample_fmt_is_planar(req);
79 
80  if (need32 || want32) {
81  if (planar)
82  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
83  else
84  s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
85  s->sample_shift = 32 - s->flac_stream_info.bps;
86  } else {
87  if (planar)
88  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
89  else
90  s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
91  s->sample_shift = 16 - s->flac_stream_info.bps;
92  }
93 }
94 
95  static av_cold int flac_decode_init(AVCodecContext *avctx)
96 {
97  enum FLACExtradataFormat format;
98  uint8_t *streaminfo;
99  int ret;
100  FLACContext *s = avctx->priv_data;
101  s->avctx = avctx;
102 
103  /* for now, the raw FLAC header is allowed to be passed to the decoder as
104  frame data instead of extradata. */
105  if (!avctx->extradata)
106  return 0;
107 
108  if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
109  return AVERROR_INVALIDDATA;
110 
111  /* initialize based on the demuxer-supplied streamdata header */
112  ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113  if (ret < 0)
114  return ret;
115  ret = allocate_buffers(s);
116  if (ret < 0)
117  return ret;
118  flac_set_bps(s);
119  ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
120  s->flac_stream_info.channels, s->flac_stream_info.bps);
121  s->got_streaminfo = 1;
122 
123  return 0;
124 }
125 
126  static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
127 {
128  av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129  av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130  av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131  av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132  av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 }
134 
135  static int allocate_buffers(FLACContext *s)
136 {
137  int buf_size;
138  int ret;
139 
140  av_assert0(s->flac_stream_info.max_blocksize);
141 
142  buf_size = av_samples_get_buffer_size(NULL, s->flac_stream_info.channels,
143  s->flac_stream_info.max_blocksize,
144  AV_SAMPLE_FMT_S32P, 0);
145  if (buf_size < 0)
146  return buf_size;
147 
148  av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
149  if (!s->decoded_buffer)
150  return AVERROR(ENOMEM);
151 
152  ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
153  s->decoded_buffer,
154  s->flac_stream_info.channels,
155  s->flac_stream_info.max_blocksize,
156  AV_SAMPLE_FMT_S32P, 0);
157  return ret < 0 ? ret : 0;
158 }
159 
160 /**
161  * Parse the STREAMINFO from an inline header.
162  * @param s the flac decoding context
163  * @param buf input buffer, starting with the "fLaC" marker
164  * @param buf_size buffer size
165  * @return non-zero if metadata is invalid
166  */
167  static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
168 {
169  int metadata_type, metadata_size, ret;
170 
171  if (buf_size < FLAC_STREAMINFO_SIZE+8) {
172  /* need more data */
173  return 0;
174  }
175  flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
176  if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
177  metadata_size != FLAC_STREAMINFO_SIZE) {
178  return AVERROR_INVALIDDATA;
179  }
180  ret = ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
181  if (ret < 0)
182  return ret;
183  ret = allocate_buffers(s);
184  if (ret < 0)
185  return ret;
186  flac_set_bps(s);
187  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
188  s->flac_stream_info.channels, s->flac_stream_info.bps);
189  s->got_streaminfo = 1;
190 
191  return 0;
192 }
193 
194 /**
195  * Determine the size of an inline header.
196  * @param buf input buffer, starting with the "fLaC" marker
197  * @param buf_size buffer size
198  * @return number of bytes in the header, or 0 if more data is needed
199  */
200  static int get_metadata_size(const uint8_t *buf, int buf_size)
201 {
202  int metadata_last, metadata_size;
203  const uint8_t *buf_end = buf + buf_size;
204 
205  buf += 4;
206  do {
207  if (buf_end - buf < 4)
208  return AVERROR_INVALIDDATA;
209  flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
210  buf += 4;
211  if (buf_end - buf < metadata_size) {
212  /* need more data in order to read the complete header */
213  return AVERROR_INVALIDDATA;
214  }
215  buf += metadata_size;
216  } while (!metadata_last);
217 
218  return buf_size - (buf_end - buf);
219 }
220 
221  static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
222 {
223  GetBitContext gb = s->gb;
224  int i, tmp, partition, method_type, rice_order;
225  int rice_bits, rice_esc;
226  int samples;
227 
228  method_type = get_bits(&gb, 2);
229  rice_order = get_bits(&gb, 4);
230 
231  samples = s->blocksize >> rice_order;
232  rice_bits = 4 + method_type;
233  rice_esc = (1 << rice_bits) - 1;
234 
235  decoded += pred_order;
236  i = pred_order;
237 
238  if (method_type > 1) {
239  av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
240  method_type);
241  return AVERROR_INVALIDDATA;
242  }
243 
244  if (samples << rice_order != s->blocksize) {
245  av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
246  rice_order, s->blocksize);
247  return AVERROR_INVALIDDATA;
248  }
249 
250  if (pred_order > samples) {
251  av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
252  pred_order, samples);
253  return AVERROR_INVALIDDATA;
254  }
255 
256  for (partition = 0; partition < (1 << rice_order); partition++) {
257  tmp = get_bits(&gb, rice_bits);
258  if (tmp == rice_esc) {
259  tmp = get_bits(&gb, 5);
260  for (; i < samples; i++)
261  *decoded++ = get_sbits_long(&gb, tmp);
262  } else {
263  int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
264  for (; i < samples; i++) {
265  int v = get_sr_golomb_flac(&gb, tmp, real_limit, 0);
266  if (v == 0x80000000){
267  av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
268  return AVERROR_INVALIDDATA;
269  }
270 
271  *decoded++ = v;
272  }
273  }
274  i= 0;
275  }
276 
277  s->gb = gb;
278 
279  return 0;
280 }
281 
282  static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
283  int pred_order, int bps)
284 {
285  const int blocksize = s->blocksize;
286  unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
287  int i;
288  int ret;
289 
290  /* warm up samples */
291  for (i = 0; i < pred_order; i++) {
292  decoded[i] = get_sbits_long(&s->gb, bps);
293  }
294 
295  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
296  return ret;
297 
298  if (pred_order > 0)
299  a = decoded[pred_order-1];
300  if (pred_order > 1)
301  b = a - decoded[pred_order-2];
302  if (pred_order > 2)
303  c = b - decoded[pred_order-2] + decoded[pred_order-3];
304  if (pred_order > 3)
305  d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
306 
307  switch (pred_order) {
308  case 0:
309  break;
310  case 1:
311  for (i = pred_order; i < blocksize; i++)
312  decoded[i] = a += decoded[i];
313  break;
314  case 2:
315  for (i = pred_order; i < blocksize; i++)
316  decoded[i] = a += b += decoded[i];
317  break;
318  case 3:
319  for (i = pred_order; i < blocksize; i++)
320  decoded[i] = a += b += c += decoded[i];
321  break;
322  case 4:
323  for (i = pred_order; i < blocksize; i++)
324  decoded[i] = a += b += c += d += decoded[i];
325  break;
326  default:
327  av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
328  return AVERROR_INVALIDDATA;
329  }
330 
331  return 0;
332 }
333 
334  static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
335  int order, int qlevel, int len, int bps)
336 {
337  int i, j;
338  int ebps = 1 << (bps-1);
339  unsigned sigma = 0;
340 
341  for (i = order; i < len; i++)
342  sigma |= decoded[i] + ebps;
343 
344  if (sigma < 2*ebps)
345  return;
346 
347  for (i = len - 1; i >= order; i--) {
348  int64_t p = 0;
349  for (j = 0; j < order; j++)
350  p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
351  decoded[i] -= p >> qlevel;
352  }
353  for (i = order; i < len; i++, decoded++) {
354  int32_t p = 0;
355  for (j = 0; j < order; j++)
356  p += coeffs[j] * (uint32_t)decoded[j];
357  decoded[j] += p >> qlevel;
358  }
359 }
360 
361  static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
362  int bps)
363 {
364  int i, ret;
365  int coeff_prec, qlevel;
366  int coeffs[32];
367 
368  /* warm up samples */
369  for (i = 0; i < pred_order; i++) {
370  decoded[i] = get_sbits_long(&s->gb, bps);
371  }
372 
373  coeff_prec = get_bits(&s->gb, 4) + 1;
374  if (coeff_prec == 16) {
375  av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
376  return AVERROR_INVALIDDATA;
377  }
378  qlevel = get_sbits(&s->gb, 5);
379  if (qlevel < 0) {
380  av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
381  qlevel);
382  return AVERROR_INVALIDDATA;
383  }
384 
385  for (i = 0; i < pred_order; i++) {
386  coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
387  }
388 
389  if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
390  return ret;
391 
392  if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
393  || ( !s->buggy_lpc && bps <= 16
394  && bps + coeff_prec + av_log2(pred_order) <= 32)) {
395  s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
396  } else {
397  s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
398  if (s->flac_stream_info.bps <= 16)
399  lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
400  }
401 
402  return 0;
403 }
404 
405  static inline int decode_subframe(FLACContext *s, int channel)
406 {
407  int32_t *decoded = s->decoded[channel];
408  int type, wasted = 0;
409  int bps = s->flac_stream_info.bps;
410  int i, tmp, ret;
411 
412  if (channel == 0) {
413  if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414  bps++;
415  } else {
416  if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
417  bps++;
418  }
419 
420  if (get_bits1(&s->gb)) {
421  av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422  return AVERROR_INVALIDDATA;
423  }
424  type = get_bits(&s->gb, 6);
425 
426  if (get_bits1(&s->gb)) {
427  int left = get_bits_left(&s->gb);
428  if ( left <= 0 ||
429  (left < bps && !show_bits_long(&s->gb, left)) ||
430  !show_bits_long(&s->gb, bps)) {
431  av_log(s->avctx, AV_LOG_ERROR,
432  "Invalid number of wasted bits > available bits (%d) - left=%d\n",
433  bps, left);
434  return AVERROR_INVALIDDATA;
435  }
436  wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
437  bps -= wasted;
438  }
439  if (bps > 32) {
440  avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
441  return AVERROR_PATCHWELCOME;
442  }
443 
444 //FIXME use av_log2 for types
445  if (type == 0) {
446  tmp = get_sbits_long(&s->gb, bps);
447  for (i = 0; i < s->blocksize; i++)
448  decoded[i] = tmp;
449  } else if (type == 1) {
450  for (i = 0; i < s->blocksize; i++)
451  decoded[i] = get_sbits_long(&s->gb, bps);
452  } else if ((type >= 8) && (type <= 12)) {
453  if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
454  return ret;
455  } else if (type >= 32) {
456  if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
457  return ret;
458  } else {
459  av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460  return AVERROR_INVALIDDATA;
461  }
462 
463  if (wasted && wasted < 32) {
464  int i;
465  for (i = 0; i < s->blocksize; i++)
466  decoded[i] = (unsigned)decoded[i] << wasted;
467  }
468 
469  return 0;
470 }
471 
472  static int decode_frame(FLACContext *s)
473 {
474  int i, ret;
475  GetBitContext *gb = &s->gb;
476  FLACFrameInfo fi;
477 
478  if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
479  av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480  return ret;
481  }
482 
483  if ( s->flac_stream_info.channels
484  && fi.channels != s->flac_stream_info.channels
485  && s->got_streaminfo) {
486  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
487  ff_flac_set_channel_layout(s->avctx);
488  ret = allocate_buffers(s);
489  if (ret < 0)
490  return ret;
491  }
492  s->flac_stream_info.channels = s->avctx->channels = fi.channels;
493  if (!s->avctx->channel_layout)
494  ff_flac_set_channel_layout(s->avctx);
495  s->ch_mode = fi.ch_mode;
496 
497  if (!s->flac_stream_info.bps && !fi.bps) {
498  av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
499  return AVERROR_INVALIDDATA;
500  }
501  if (!fi.bps) {
502  fi.bps = s->flac_stream_info.bps;
503  } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
504  av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
505  "supported\n");
506  return AVERROR_INVALIDDATA;
507  }
508 
509  if (!s->flac_stream_info.bps) {
510  s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
511  flac_set_bps(s);
512  }
513 
514  if (!s->flac_stream_info.max_blocksize)
515  s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
516  if (fi.blocksize > s->flac_stream_info.max_blocksize) {
517  av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518  s->flac_stream_info.max_blocksize);
519  return AVERROR_INVALIDDATA;
520  }
521  s->blocksize = fi.blocksize;
522 
523  if (!s->flac_stream_info.samplerate && !fi.samplerate) {
524  av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525  " or frame header\n");
526  return AVERROR_INVALIDDATA;
527  }
528  if (fi.samplerate == 0)
529  fi.samplerate = s->flac_stream_info.samplerate;
530  s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
531 
532  if (!s->got_streaminfo) {
533  ret = allocate_buffers(s);
534  if (ret < 0)
535  return ret;
536  s->got_streaminfo = 1;
537  dump_headers(s->avctx, &s->flac_stream_info);
538  }
539  ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
540  s->flac_stream_info.channels, s->flac_stream_info.bps);
541 
542 // dump_headers(s->avctx, &s->flac_stream_info);
543 
544  /* subframes */
545  for (i = 0; i < s->flac_stream_info.channels; i++) {
546  if ((ret = decode_subframe(s, i)) < 0)
547  return ret;
548  }
549 
550  align_get_bits(gb);
551 
552  /* frame footer */
553  skip_bits(gb, 16); /* data crc */
554 
555  return 0;
556 }
557 
558  static int flac_decode_frame(AVCodecContext *avctx, void *data,
559  int *got_frame_ptr, AVPacket *avpkt)
560 {
561  AVFrame *frame = data;
562  ThreadFrame tframe = { .f = data };
563  const uint8_t *buf = avpkt->data;
564  int buf_size = avpkt->size;
565  FLACContext *s = avctx->priv_data;
566  int bytes_read = 0;
567  int ret;
568 
569  *got_frame_ptr = 0;
570 
571  if (s->flac_stream_info.max_framesize == 0) {
572  s->flac_stream_info.max_framesize =
573  ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
574  FLAC_MAX_CHANNELS, 32);
575  }
576 
577  if (buf_size > 5 && !memcmp(buf, "177円FLAC", 5)) {
578  av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
579  return buf_size;
580  }
581 
582  if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
583  av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
584  return buf_size;
585  }
586 
587  /* check that there is at least the smallest decodable amount of data.
588  this amount corresponds to the smallest valid FLAC frame possible.
589  FF F8 69 02 00 00 9A 00 00 34 46 */
590  if (buf_size < FLAC_MIN_FRAME_SIZE)
591  return buf_size;
592 
593  /* check for inline header */
594  if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
595  if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
596  av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
597  return ret;
598  }
599  return get_metadata_size(buf, buf_size);
600  }
601 
602  /* decode frame */
603  if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
604  return ret;
605  if ((ret = decode_frame(s)) < 0) {
606  av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
607  return ret;
608  }
609  bytes_read = get_bits_count(&s->gb)/8;
610 
611  if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
612  av_crc(av_crc_get_table(AV_CRC_16_ANSI),
613  0, buf, bytes_read)) {
614  av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
615  if (s->avctx->err_recognition & AV_EF_EXPLODE)
616  return AVERROR_INVALIDDATA;
617  }
618 
619  /* get output buffer */
620  frame->nb_samples = s->blocksize;
621  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
622  return ret;
623 
624  s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
625  s->flac_stream_info.channels,
626  s->blocksize, s->sample_shift);
627 
628  if (bytes_read > buf_size) {
629  av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
630  return AVERROR_INVALIDDATA;
631  }
632  if (bytes_read < buf_size) {
633  av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
634  buf_size - bytes_read, buf_size);
635  }
636 
637  *got_frame_ptr = 1;
638 
639  return bytes_read;
640 }
641 
642 #if HAVE_THREADS
643 static int init_thread_copy(AVCodecContext *avctx)
644 {
645  FLACContext *s = avctx->priv_data;
646  s->decoded_buffer = NULL;
647  s->decoded_buffer_size = 0;
648  s->avctx = avctx;
649  if (s->flac_stream_info.max_blocksize)
650  return allocate_buffers(s);
651  return 0;
652 }
653 #endif
654 
655  static av_cold int flac_decode_close(AVCodecContext *avctx)
656 {
657  FLACContext *s = avctx->priv_data;
658 
659  av_freep(&s->decoded_buffer);
660 
661  return 0;
662 }
663 
664  static const AVOption options[] = {
665 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
666 { NULL },
667 };
668 
669  static const AVClass flac_decoder_class = {
670  "FLAC decoder",
671  av_default_item_name,
672  options,
673  LIBAVUTIL_VERSION_INT,
674 };
675 
676  AVCodec ff_flac_decoder = {
677  .name = "flac",
678  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
679  .type = AVMEDIA_TYPE_AUDIO,
680  .id = AV_CODEC_ID_FLAC,
681  .priv_data_size = sizeof(FLACContext),
682  .init = flac_decode_init,
683  .close = flac_decode_close,
684  .decode = flac_decode_frame,
685  .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
686  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
687  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
688  AV_SAMPLE_FMT_S16P,
689  AV_SAMPLE_FMT_S32,
690  AV_SAMPLE_FMT_S32P,
691  AV_SAMPLE_FMT_NONE },
692  .priv_class = &flac_decoder_class,
693 };
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:405
get_sr_golomb_flac
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:382
NULL
#define NULL
Definition: coverity.c:32
s
const char * s
Definition: avisynth_c.h:768
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
format
static const char * format[]
Definition: af_aiir.c:311
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
AVOption
AVOption.
Definition: opt.h:246
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
init_thread_copy
static int init_thread_copy(AVCodecContext *avctx)
Definition: tta.c:392
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_flacdsp_init
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:88
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
allocate_buffers
static int allocate_buffers(FLACContext *s)
Definition: flacdec.c:135
ff_flac_get_max_frame_size
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
Definition: flac.c:148
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
AVPacket::size
int size
Definition: avcodec.h:1431
b
const char * b
Definition: vf_curves.c:113
AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2657
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FLACContext::avctx
AVCodecContext * avctx
parent AVCodecContext
Definition: flacdec.c:55
AV_CODEC_ID_FLAC
Definition: avcodec.h:563
FLAC_MAX_BLOCKSIZE
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2741
decode_residuals
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
Definition: flacdec.c:221
AVCodec
AVCodec.
Definition: avcodec.h:3408
FLACFrameInfo::blocksize
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:254
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
ff_flac_is_extradata_valid
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:393
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FLACDSPContext::lpc32
void(* lpc32)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:31
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2181
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
FLACContext::dsp
FLACDSPContext dsp
Definition: flacdec.c:68
flac_decoder_class
static const AVClass flac_decoder_class
Definition: flacdec.c:669
opt.h
AVOptions.
thread.h
Multithreading support functions.
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1618
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
frame
static AVFrame * frame
Definition: demuxing_decoding.c:53
flac_set_bps
static void flac_set_bps(FLACContext *s)
Definition: flacdec.c:73
crc.h
Public header for CRC hash function implementation.
FLACContext::decoded_buffer
uint8_t * decoded_buffer
Definition: flacdec.c:64
AVPacket::data
uint8_t * data
Definition: avcodec.h:1430
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:200
get_bits.h
bitstream reader API header.
FLACContext::decoded_buffer_size
unsigned int decoded_buffer_size
Definition: flacdec.c:65
AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
U
#define U(x)
Definition: vp56_arith.h:37
FLACExtradataFormat
FLACExtradataFormat
Definition: flac.h:58
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:596
fi
AVS_FilterInfo ** fi
Definition: avisynth_c.h:731
FLACContext::decoded
int32_t * decoded[FLAC_MAX_CHANNELS]
decoded samples
Definition: flacdec.c:63
FLACFrameInfo::ch_mode
int ch_mode
channel decorrelation mode
Definition: flac.h:87
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
flac.h
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
AVERROR
#define AVERROR(e)
Definition: error.h:43
AVCodecContext::request_sample_fmt
enum AVSampleFormat request_sample_fmt
desired sample format
Definition: avcodec.h:2246
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:186
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
decode_subframe_lpc
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:361
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
get_metadata_size
static int get_metadata_size(const uint8_t *buf, int buf_size)
Determine the size of an inline header.
Definition: flacdec.c:200
FLACContext::gb
GetBitContext gb
GetBitContext initialized to start at the current frame.
Definition: flacdec.c:56
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
dump_headers
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
Definition: flacdec.c:126
ff_flac_decode_frame_header
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:50
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1015
decode_subframe_fixed
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, int pred_order, int bps)
Definition: flacdec.c:282
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2224
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:488
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2642
AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
FLACContext::buggy_lpc
int buggy_lpc
use workaround for old lavc encoded files
Definition: flacdec.c:66
FLACContext::got_streaminfo
int got_streaminfo
indicates if the STREAMINFO has been read
Definition: flacdec.c:61
SUINT32
#define SUINT32
Definition: dct32_template.c:31
ff_flac_parse_streaminfo
int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
int32_t
int32_t
Definition: audio_convert.c:194
AV_OPT_TYPE_BOOL
Definition: opt.h:240
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2653
FLACContext::sample_shift
int sample_shift
shift required to make output samples 16-bit or 32-bit
Definition: flacdec.c:59
ff_flac_decoder
AVCodec ff_flac_decoder
Definition: flacdec.c:676
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
avcodec.h
Libavcodec external API header.
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2173
options
static const AVOption options[]
Definition: flacdec.c:664
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:464
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:965
decode_frame
static int decode_frame(FLACContext *s)
Definition: flacdec.c:472
AVCodecContext
main external API structure.
Definition: avcodec.h:1518
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8: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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch const uint8_t **in ch off *out planar
Definition: audioconvert.c:56
buf
void * buf
Definition: avisynth_c.h:690
type
GLint GLenum type
Definition: opengl_enc.c:105
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:314
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:119
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
flac_parse_block_header
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:145
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2650
lpc_analyze_remodulate
static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32], int order, int qlevel, int len, int bps)
Definition: flacdec.c:334
parse_streaminfo
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
Parse the STREAMINFO from an inline header.
Definition: flacdec.c:167
FLACContext::flac_stream_info
struct FLACStreaminfo flac_stream_info
Definition: flacdec.c:53
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
FLACContext::blocksize
int blocksize
number of samples in the current frame
Definition: flacdec.c:58
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
decode_subframe
static int decode_subframe(FLACContext *s, int channel)
Definition: flacdec.c:405
FLACDSPContext::lpc16
void(* lpc16)(int32_t *samples, const int coeffs[32], int order, int qlevel, int len)
Definition: flacdsp.h:29
internal.h
common internal api header.
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
channel
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
FLAC_MIN_FRAME_SIZE
#define FLAC_MIN_FRAME_SIZE
Definition: flac.h:38
bps
unsigned bps
Definition: movenc.c:1456
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:367
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1545
av_samples_fill_arrays
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:151
coeffs
static const int16_t coeffs[]
Definition: simple_idct_mmi.c:40
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2174
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:472
av_uninit
#define av_uninit(x)
Definition: attributes.h:148
flac_decode_init
static av_cold int flac_decode_init(AVCodecContext *avctx)
Definition: flacdec.c:95
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
AV_CRC_16_ANSI
Definition: crc.h:51
golomb.h
exp golomb vlc stuff
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1407
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:284
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1423
FLACDSPContext::decorrelate
void(* decorrelate[4])(uint8_t **out, int32_t **in, int channels, int len, int shift)
Definition: flacdsp.h:27
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
flac_decode_close
static av_cold int flac_decode_close(AVCodecContext *avctx)
Definition: flacdec.c:655
FLACContext::ch_mode
int ch_mode
channel decorrelation type in the current frame
Definition: flacdec.c:60
a
a
Definition: h264pred_template.c:468
flac_decode_frame
static int flac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: flacdec.c:558
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
Generated on Sun May 13 2018 02:03:46 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /