FFmpeg
sbcenc.c
Go to the documentation of this file.
1 /*
2  * Bluetooth low-complexity, subband codec (SBC)
3  *
4  * Copyright (C) 2017 Aurelien Jacobs <aurel@gnuage.org>
5  * Copyright (C) 2012-2013 Intel Corporation
6  * Copyright (C) 2008-2010 Nokia Corporation
7  * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
8  * Copyright (C) 2004-2005 Henryk Ploetz <henryk@ploetzli.ch>
9  * Copyright (C) 2005-2008 Brad Midgley <bmidgley@xmission.com>
10  *
11  * This file is part of FFmpeg.
12  *
13  * FFmpeg is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Lesser General Public
15  * License as published by the Free Software Foundation; either
16  * version 2.1 of the License, or (at your option) any later version.
17  *
18  * FFmpeg is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21  * Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with FFmpeg; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27 
28 /**
29  * @file
30  * SBC encoder implementation
31  */
32 
33 #include "libavutil/opt.h"
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "profiles.h"
37 #include "put_bits.h"
38 #include "sbc.h"
39 #include "sbcdsp.h"
40 
41 typedef struct SBCEncContext {
42  AVClass *class;
43  int64_t max_delay;
44  int msbc;
46  DECLARE_ALIGNED(SBC_ALIGN, SBCDSPContext, dsp);
48 
49 static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)
50 {
51  int ch, blk;
52  int16_t *x;
53 
54  switch (frame->subbands) {
55  case 4:
56  for (ch = 0; ch < frame->channels; ch++) {
57  x = &s->X[ch][s->position - 4 *
58  s->increment + frame->blocks * 4];
59  for (blk = 0; blk < frame->blocks;
60  blk += s->increment) {
61  s->sbc_analyze_4s(
62  s, x,
63  frame->sb_sample_f[blk][ch],
64  frame->sb_sample_f[blk + 1][ch] -
65  frame->sb_sample_f[blk][ch]);
66  x -= 4 * s->increment;
67  }
68  }
69  return frame->blocks * 4;
70 
71  case 8:
72  for (ch = 0; ch < frame->channels; ch++) {
73  x = &s->X[ch][s->position - 8 *
74  s->increment + frame->blocks * 8];
75  for (blk = 0; blk < frame->blocks;
76  blk += s->increment) {
77  s->sbc_analyze_8s(
78  s, x,
79  frame->sb_sample_f[blk][ch],
80  frame->sb_sample_f[blk + 1][ch] -
81  frame->sb_sample_f[blk][ch]);
82  x -= 8 * s->increment;
83  }
84  }
85  return frame->blocks * 8;
86 
87  default:
88  return AVERROR(EIO);
89  }
90 }
91 
92 /*
93  * Packs the SBC frame from frame into the memory in avpkt.
94  * Returns the length of the packed frame.
95  */
96 static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame,
97  int joint, int msbc)
98 {
99  PutBitContext pb;
100 
101  /* Will copy the header parts for CRC-8 calculation here */
102  uint8_t crc_header[11] = { 0 };
103  int crc_pos;
104 
105  uint32_t audio_sample;
106 
107  int ch, sb, blk; /* channel, subband, block and bit counters */
108  int bits[2][8]; /* bits distribution */
109  uint32_t levels[2][8]; /* levels are derived from that */
110  uint32_t sb_sample_delta[2][8];
111 
112  if (msbc) {
113  avpkt->data[0] = MSBC_SYNCWORD;
114  avpkt->data[1] = 0;
115  avpkt->data[2] = 0;
116  } else {
117  avpkt->data[0] = SBC_SYNCWORD;
118 
119  avpkt->data[1] = (frame->frequency & 0x03) << 6;
120  avpkt->data[1] |= (((frame->blocks >> 2) - 1) & 0x03) << 4;
121  avpkt->data[1] |= (frame->mode & 0x03) << 2;
122  avpkt->data[1] |= (frame->allocation & 0x01) << 1;
123  avpkt->data[1] |= ((frame->subbands == 8) & 0x01) << 0;
124 
125  avpkt->data[2] = frame->bitpool;
126 
127  if (frame->bitpool > frame->subbands << (4 + (frame->mode == STEREO
128  || frame->mode == JOINT_STEREO)))
129  return -5;
130  }
131 
132  /* Can't fill in crc yet */
133  crc_header[0] = avpkt->data[1];
134  crc_header[1] = avpkt->data[2];
135  crc_pos = 16;
136 
137  init_put_bits(&pb, avpkt->data + 4, avpkt->size);
138 
139  if (frame->mode == JOINT_STEREO) {
140  put_bits(&pb, frame->subbands, joint);
141  crc_header[crc_pos >> 3] = joint;
142  crc_pos += frame->subbands;
143  }
144 
145  for (ch = 0; ch < frame->channels; ch++) {
146  for (sb = 0; sb < frame->subbands; sb++) {
147  put_bits(&pb, 4, frame->scale_factor[ch][sb] & 0x0F);
148  crc_header[crc_pos >> 3] <<= 4;
149  crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] & 0x0F;
150  crc_pos += 4;
151  }
152  }
153 
154  /* align the last crc byte */
155  if (crc_pos % 8)
156  crc_header[crc_pos >> 3] <<= 8 - (crc_pos % 8);
157 
158  avpkt->data[3] = ff_sbc_crc8(frame->crc_ctx, crc_header, crc_pos);
159 
161 
162  for (ch = 0; ch < frame->channels; ch++) {
163  for (sb = 0; sb < frame->subbands; sb++) {
164  levels[ch][sb] = ((1 << bits[ch][sb]) - 1) <<
165  (32 - (frame->scale_factor[ch][sb] +
166  SCALE_OUT_BITS + 2));
167  sb_sample_delta[ch][sb] = (uint32_t) 1 <<
168  (frame->scale_factor[ch][sb] +
169  SCALE_OUT_BITS + 1);
170  }
171  }
172 
173  for (blk = 0; blk < frame->blocks; blk++) {
174  for (ch = 0; ch < frame->channels; ch++) {
175  for (sb = 0; sb < frame->subbands; sb++) {
176 
177  if (bits[ch][sb] == 0)
178  continue;
179 
180  audio_sample = ((uint64_t) levels[ch][sb] *
181  (sb_sample_delta[ch][sb] +
182  frame->sb_sample_f[blk][ch][sb])) >> 32;
183 
184  put_bits(&pb, bits[ch][sb], audio_sample);
185  }
186  }
187  }
188 
189  flush_put_bits(&pb);
190 
191  return put_bytes_output(&pb);
192 }
193 
194 static int sbc_encode_init(AVCodecContext *avctx)
195 {
196  SBCEncContext *sbc = avctx->priv_data;
197  struct sbc_frame *frame = &sbc->frame;
198 
199  if (avctx->profile == FF_PROFILE_SBC_MSBC)
200  sbc->msbc = 1;
201 
202  if (sbc->msbc) {
203  if (avctx->channels != 1) {
204  av_log(avctx, AV_LOG_ERROR, "mSBC require mono channel.\n");
205  return AVERROR(EINVAL);
206  }
207 
208  if (avctx->sample_rate != 16000) {
209  av_log(avctx, AV_LOG_ERROR, "mSBC require 16 kHz samplerate.\n");
210  return AVERROR(EINVAL);
211  }
212 
213  frame->mode = SBC_MODE_MONO;
214  frame->subbands = 8;
215  frame->blocks = MSBC_BLOCKS;
216  frame->allocation = SBC_AM_LOUDNESS;
217  frame->bitpool = 26;
218 
219  avctx->frame_size = 8 * MSBC_BLOCKS;
220  } else {
221  int d;
222 
223  if (avctx->global_quality > 255*FF_QP2LAMBDA) {
224  av_log(avctx, AV_LOG_ERROR, "bitpool > 255 is not allowed.\n");
225  return AVERROR(EINVAL);
226  }
227 
228  if (avctx->channels == 1) {
229  frame->mode = SBC_MODE_MONO;
230  if (sbc->max_delay <= 3000 || avctx->bit_rate > 270000)
231  frame->subbands = 4;
232  else
233  frame->subbands = 8;
234  } else {
235  if (avctx->bit_rate < 180000 || avctx->bit_rate > 420000)
237  else
238  frame->mode = SBC_MODE_STEREO;
239  if (sbc->max_delay <= 4000 || avctx->bit_rate > 420000)
240  frame->subbands = 4;
241  else
242  frame->subbands = 8;
243  }
244  /* sbc algorithmic delay is ((blocks + 10) * subbands - 2) / sample_rate */
245  frame->blocks = av_clip(((sbc->max_delay * avctx->sample_rate + 2)
246  / (1000000 * frame->subbands)) - 10, 4, 16) & ~3;
247 
248  frame->allocation = SBC_AM_LOUDNESS;
249 
250  d = frame->blocks * ((frame->mode == SBC_MODE_DUAL_CHANNEL) + 1);
251  frame->bitpool = (((avctx->bit_rate * frame->subbands * frame->blocks) / avctx->sample_rate)
252  - 4 * frame->subbands * avctx->channels
253  - (frame->mode == SBC_MODE_JOINT_STEREO)*frame->subbands - 32 + d/2) / d;
254  if (avctx->global_quality > 0)
255  frame->bitpool = avctx->global_quality / FF_QP2LAMBDA;
256 
257  avctx->frame_size = 4*((frame->subbands >> 3) + 1) * 4*(frame->blocks >> 2);
258  }
259 
260  for (int i = 0; avctx->codec->supported_samplerates[i]; i++)
261  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
262  frame->frequency = i;
263 
264  frame->channels = avctx->channels;
265  frame->codesize = frame->subbands * frame->blocks * avctx->channels * 2;
266  frame->crc_ctx = av_crc_get_table(AV_CRC_8_EBU);
267 
268  memset(&sbc->dsp.X, 0, sizeof(sbc->dsp.X));
269  sbc->dsp.position = (SBC_X_BUFFER_SIZE - frame->subbands * 9) & ~7;
270  sbc->dsp.increment = sbc->msbc ? 1 : 4;
271  ff_sbcdsp_init(&sbc->dsp);
272 
273  return 0;
274 }
275 
276 static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
277  const AVFrame *av_frame, int *got_packet_ptr)
278 {
279  SBCEncContext *sbc = avctx->priv_data;
280  struct sbc_frame *frame = &sbc->frame;
282  uint8_t dual = frame->mode == SBC_MODE_DUAL_CHANNEL;
283  int ret, j = 0;
284 
285  int frame_length = 4 + (4 * frame->subbands * frame->channels) / 8
286  + ((frame->blocks * frame->bitpool * (1 + dual)
287  + joint * frame->subbands) + 7) / 8;
288 
289  /* input must be large enough to encode a complete frame */
290  if (av_frame->nb_samples * frame->channels * 2 < frame->codesize)
291  return 0;
292 
293  if ((ret = ff_alloc_packet2(avctx, avpkt, frame_length, 0)) < 0)
294  return ret;
295 
296  /* Select the needed input data processing function and call it */
297  if (frame->subbands == 8)
298  sbc->dsp.position = sbc->dsp.sbc_enc_process_input_8s(
299  sbc->dsp.position, av_frame->data[0], sbc->dsp.X,
300  frame->subbands * frame->blocks, frame->channels);
301  else
302  sbc->dsp.position = sbc->dsp.sbc_enc_process_input_4s(
303  sbc->dsp.position, av_frame->data[0], sbc->dsp.X,
304  frame->subbands * frame->blocks, frame->channels);
305 
306  sbc_analyze_audio(&sbc->dsp, &sbc->frame);
307 
308  if (frame->mode == JOINT_STEREO)
309  j = sbc->dsp.sbc_calc_scalefactors_j(frame->sb_sample_f,
310  frame->scale_factor,
311  frame->blocks,
312  frame->subbands);
313  else
314  sbc->dsp.sbc_calc_scalefactors(frame->sb_sample_f,
315  frame->scale_factor,
316  frame->blocks,
317  frame->channels,
318  frame->subbands);
319  emms_c();
320  sbc_pack_frame(avpkt, frame, j, sbc->msbc);
321 
322  *got_packet_ptr = 1;
323  return 0;
324 }
325 
326 #define OFFSET(x) offsetof(SBCEncContext, x)
327 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
328 static const AVOption options[] = {
329  { "sbc_delay", "set maximum algorithmic latency",
330  OFFSET(max_delay), AV_OPT_TYPE_DURATION, {.i64 = 13000}, 1000,13000, AE },
331  { "msbc", "use mSBC mode (wideband speech mono SBC)",
332  OFFSET(msbc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AE },
334  { NULL },
335 };
336 
337 static const AVClass sbc_class = {
338  .class_name = "sbc encoder",
339  .item_name = av_default_item_name,
340  .option = options,
341  .version = LIBAVUTIL_VERSION_INT,
342 };
343 
345  .name = "sbc",
346  .long_name = NULL_IF_CONFIG_SMALL("SBC (low-complexity subband codec)"),
347  .type = AVMEDIA_TYPE_AUDIO,
348  .id = AV_CODEC_ID_SBC,
349  .priv_data_size = sizeof(SBCEncContext),
351  .encode2 = sbc_encode_frame,
352  .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
353  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
354  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
356  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
358  .supported_samplerates = (const int[]) { 16000, 32000, 44100, 48000, 0 },
359  .priv_class = &sbc_class,
361 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
AVCodec
AVCodec.
Definition: codec.h:197
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: internal.h:41
av_clip
#define av_clip
Definition: common.h:122
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
opt.h
AV_CRC_8_EBU
@ AV_CRC_8_EBU
Definition: crc.h:57
MSBC_SYNCWORD
#define MSBC_SYNCWORD
Definition: sbc.h:70
JOINT_STEREO
#define JOINT_STEREO
Definition: atrac3.c:58
OFFSET
#define OFFSET(x)
Definition: sbcenc.c:326
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:93
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:66
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
AVOption
AVOption.
Definition: opt.h:248
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:239
STEREO
#define STEREO
Definition: cook.c:62
sbc_analyze_audio
static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)
Definition: sbcenc.c:49
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
MSBC_BLOCKS
#define MSBC_BLOCKS
Definition: sbc.h:40
SBCEncContext::dsp
SBCDSPContext dsp
Definition: sbcenc.c:46
options
static const AVOption options[]
Definition: sbcenc.c:328
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:545
sbcdsp.h
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
SBCEncContext::msbc
int msbc
Definition: sbcenc.c:44
AV_CODEC_ID_SBC
@ AV_CODEC_ID_SBC
Definition: codec_id.h:512
AVCodec::supported_samplerates
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0
Definition: codec.h:219
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:602
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
FF_AVCTX_PROFILE_OPTION
#define FF_AVCTX_PROFILE_OPTION(name, description, type, value)
Definition: profiles.h:25
AE
#define AE
Definition: sbcenc.c:327
bits
uint8_t bits
Definition: vp3data.h:141
ff_sbcdsp_init
av_cold void ff_sbcdsp_init(SBCDSPContext *s)
Definition: sbcdsp.c:364
SBCEncContext::max_delay
int64_t max_delay
Definition: sbcenc.c:43
SBC_SYNCWORD
#define SBC_SYNCWORD
Definition: sbc.h:69
blk
#define blk(i)
Definition: sha.c:185
PutBitContext
Definition: put_bits.h:51
SBCEncContext
Definition: sbcenc.c:41
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
ff_sbc_encoder
AVCodec ff_sbc_encoder
Definition: sbcenc.c:344
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
SBC_MODE_STEREO
#define SBC_MODE_STEREO
Definition: sbc.h:57
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
profiles.h
SBC_AM_LOUDNESS
#define SBC_AM_LOUDNESS
Definition: sbc.h:61
SBC_ALIGN
#define SBC_ALIGN
Definition: sbc.h:79
AVPacket::size
int size
Definition: packet.h:370
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
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sbc_encode_frame
static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *av_frame, int *got_packet_ptr)
Definition: sbcenc.c:276
SBC_MODE_MONO
#define SBC_MODE_MONO
Definition: sbc.h:55
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
sbc_encode_init
static int sbc_encode_init(AVCodecContext *avctx)
Definition: sbcenc.c:194
sbc.h
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:117
SBC_X_BUFFER_SIZE
#define SBC_X_BUFFER_SIZE
Definition: sbcdsp.h:41
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:390
i
int i
Definition: input.c:407
sbc_frame
Definition: sbc.h:83
sbc_frame::joint
uint8_t joint
Definition: sbc.h:102
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
ff_sbc_profiles
const AVProfile ff_sbc_profiles[]
Definition: profiles.c:154
ff_sbc_crc8
uint8_t ff_sbc_crc8(const AVCRC *ctx, const uint8_t *data, size_t len)
Definition: sbc.c:55
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
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
SBCEncContext::frame
struct sbc_frame frame
Definition: sbcenc.c:45
sbc_class
static const AVClass sbc_class
Definition: sbcenc.c:337
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1858
SCALE_OUT_BITS
#define SCALE_OUT_BITS
Definition: sbcdsp.h:40
FF_PROFILE_SBC_MSBC
#define FF_PROFILE_SBC_MSBC
Definition: avcodec.h:1964
ff_sbc_calculate_bits
void ff_sbc_calculate_bits(const struct sbc_frame *frame, int(*bits)[8])
Definition: sbc.c:79
SBC_MODE_DUAL_CHANNEL
#define SBC_MODE_DUAL_CHANNEL
Definition: sbc.h:56
sbc_pack_frame
static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame, int joint, int msbc)
Definition: sbcenc.c:96
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:147
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
d
d
Definition: ffmpeg_filter.c:158
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
SBC_MODE_JOINT_STEREO
#define SBC_MODE_JOINT_STEREO
Definition: sbc.h:58
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
put_bits.h