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 
34 #include "libavutil/opt.h"
35 #include "avcodec.h"
36 #include "encode.h"
37 #include "internal.h"
38 #include "profiles.h"
39 #include "put_bits.h"
40 #include "sbc.h"
41 #include "sbcdsp.h"
42 
43 typedef struct SBCEncContext {
44  AVClass *class;
45  int64_t max_delay;
46  int msbc;
48  DECLARE_ALIGNED(SBC_ALIGN, SBCDSPContext, dsp);
50 
51 static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)
52 {
53  int ch, blk;
54  int16_t *x;
55 
56  switch (frame->subbands) {
57  case 4:
58  for (ch = 0; ch < frame->channels; ch++) {
59  x = &s->X[ch][s->position - 4 *
60  s->increment + frame->blocks * 4];
61  for (blk = 0; blk < frame->blocks;
62  blk += s->increment) {
63  s->sbc_analyze_4s(
64  s, x,
65  frame->sb_sample_f[blk][ch],
66  frame->sb_sample_f[blk + 1][ch] -
67  frame->sb_sample_f[blk][ch]);
68  x -= 4 * s->increment;
69  }
70  }
71  return frame->blocks * 4;
72 
73  case 8:
74  for (ch = 0; ch < frame->channels; ch++) {
75  x = &s->X[ch][s->position - 8 *
76  s->increment + frame->blocks * 8];
77  for (blk = 0; blk < frame->blocks;
78  blk += s->increment) {
79  s->sbc_analyze_8s(
80  s, x,
81  frame->sb_sample_f[blk][ch],
82  frame->sb_sample_f[blk + 1][ch] -
83  frame->sb_sample_f[blk][ch]);
84  x -= 8 * s->increment;
85  }
86  }
87  return frame->blocks * 8;
88 
89  default:
90  return AVERROR(EIO);
91  }
92 }
93 
94 /*
95  * Packs the SBC frame from frame into the memory in avpkt.
96  * Returns the length of the packed frame.
97  */
98 static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame,
99  int joint, int msbc)
100 {
101  PutBitContext pb;
102 
103  /* Will copy the header parts for CRC-8 calculation here */
104  uint8_t crc_header[11] = { 0 };
105  int crc_pos;
106 
107  uint32_t audio_sample;
108 
109  int ch, sb, blk; /* channel, subband, block and bit counters */
110  int bits[2][8]; /* bits distribution */
111  uint32_t levels[2][8]; /* levels are derived from that */
112  uint32_t sb_sample_delta[2][8];
113 
114  if (msbc) {
115  avpkt->data[0] = MSBC_SYNCWORD;
116  avpkt->data[1] = 0;
117  avpkt->data[2] = 0;
118  } else {
119  avpkt->data[0] = SBC_SYNCWORD;
120 
121  avpkt->data[1] = (frame->frequency & 0x03) << 6;
122  avpkt->data[1] |= (((frame->blocks >> 2) - 1) & 0x03) << 4;
123  avpkt->data[1] |= (frame->mode & 0x03) << 2;
124  avpkt->data[1] |= (frame->allocation & 0x01) << 1;
125  avpkt->data[1] |= ((frame->subbands == 8) & 0x01) << 0;
126 
127  avpkt->data[2] = frame->bitpool;
128 
129  if (frame->bitpool > frame->subbands << (4 + (frame->mode == STEREO
130  || frame->mode == JOINT_STEREO)))
131  return -5;
132  }
133 
134  /* Can't fill in crc yet */
135  crc_header[0] = avpkt->data[1];
136  crc_header[1] = avpkt->data[2];
137  crc_pos = 16;
138 
139  init_put_bits(&pb, avpkt->data + 4, avpkt->size);
140 
141  if (frame->mode == JOINT_STEREO) {
142  put_bits(&pb, frame->subbands, joint);
143  crc_header[crc_pos >> 3] = joint;
144  crc_pos += frame->subbands;
145  }
146 
147  for (ch = 0; ch < frame->channels; ch++) {
148  for (sb = 0; sb < frame->subbands; sb++) {
149  put_bits(&pb, 4, frame->scale_factor[ch][sb] & 0x0F);
150  crc_header[crc_pos >> 3] <<= 4;
151  crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] & 0x0F;
152  crc_pos += 4;
153  }
154  }
155 
156  /* align the last crc byte */
157  if (crc_pos % 8)
158  crc_header[crc_pos >> 3] <<= 8 - (crc_pos % 8);
159 
160  avpkt->data[3] = ff_sbc_crc8(frame->crc_ctx, crc_header, crc_pos);
161 
163 
164  for (ch = 0; ch < frame->channels; ch++) {
165  for (sb = 0; sb < frame->subbands; sb++) {
166  levels[ch][sb] = ((1 << bits[ch][sb]) - 1) <<
167  (32 - (frame->scale_factor[ch][sb] +
168  SCALE_OUT_BITS + 2));
169  sb_sample_delta[ch][sb] = (uint32_t) 1 <<
170  (frame->scale_factor[ch][sb] +
171  SCALE_OUT_BITS + 1);
172  }
173  }
174 
175  for (blk = 0; blk < frame->blocks; blk++) {
176  for (ch = 0; ch < frame->channels; ch++) {
177  for (sb = 0; sb < frame->subbands; sb++) {
178 
179  if (bits[ch][sb] == 0)
180  continue;
181 
182  audio_sample = ((uint64_t) levels[ch][sb] *
183  (sb_sample_delta[ch][sb] +
184  frame->sb_sample_f[blk][ch][sb])) >> 32;
185 
186  put_bits(&pb, bits[ch][sb], audio_sample);
187  }
188  }
189  }
190 
191  flush_put_bits(&pb);
192 
193  return put_bytes_output(&pb);
194 }
195 
196 static int sbc_encode_init(AVCodecContext *avctx)
197 {
198  SBCEncContext *sbc = avctx->priv_data;
199  struct sbc_frame *frame = &sbc->frame;
200 
201  if (avctx->profile == FF_PROFILE_SBC_MSBC)
202  sbc->msbc = 1;
203 
204  if (sbc->msbc) {
205  if (avctx->channels != 1) {
206  av_log(avctx, AV_LOG_ERROR, "mSBC require mono channel.\n");
207  return AVERROR(EINVAL);
208  }
209 
210  if (avctx->sample_rate != 16000) {
211  av_log(avctx, AV_LOG_ERROR, "mSBC require 16 kHz samplerate.\n");
212  return AVERROR(EINVAL);
213  }
214 
215  frame->mode = SBC_MODE_MONO;
216  frame->subbands = 8;
217  frame->blocks = MSBC_BLOCKS;
218  frame->allocation = SBC_AM_LOUDNESS;
219  frame->bitpool = 26;
220 
221  avctx->frame_size = 8 * MSBC_BLOCKS;
222  } else {
223  int d;
224 
225  if (avctx->global_quality > 255*FF_QP2LAMBDA) {
226  av_log(avctx, AV_LOG_ERROR, "bitpool > 255 is not allowed.\n");
227  return AVERROR(EINVAL);
228  }
229 
230  if (avctx->channels == 1) {
231  frame->mode = SBC_MODE_MONO;
232  if (sbc->max_delay <= 3000 || avctx->bit_rate > 270000)
233  frame->subbands = 4;
234  else
235  frame->subbands = 8;
236  } else {
237  if (avctx->bit_rate < 180000 || avctx->bit_rate > 420000)
239  else
240  frame->mode = SBC_MODE_STEREO;
241  if (sbc->max_delay <= 4000 || avctx->bit_rate > 420000)
242  frame->subbands = 4;
243  else
244  frame->subbands = 8;
245  }
246  /* sbc algorithmic delay is ((blocks + 10) * subbands - 2) / sample_rate */
247  frame->blocks = av_clip(((sbc->max_delay * avctx->sample_rate + 2)
248  / (1000000 * frame->subbands)) - 10, 4, 16) & ~3;
249 
250  frame->allocation = SBC_AM_LOUDNESS;
251 
252  d = frame->blocks * ((frame->mode == SBC_MODE_DUAL_CHANNEL) + 1);
253  frame->bitpool = (((avctx->bit_rate * frame->subbands * frame->blocks) / avctx->sample_rate)
254  - 4 * frame->subbands * avctx->channels
255  - (frame->mode == SBC_MODE_JOINT_STEREO)*frame->subbands - 32 + d/2) / d;
256  if (avctx->global_quality > 0)
257  frame->bitpool = avctx->global_quality / FF_QP2LAMBDA;
258 
259  avctx->frame_size = 4*((frame->subbands >> 3) + 1) * 4*(frame->blocks >> 2);
260  }
261 
262  for (int i = 0; avctx->codec->supported_samplerates[i]; i++)
263  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
264  frame->frequency = i;
265 
266  frame->channels = avctx->channels;
267  frame->codesize = frame->subbands * frame->blocks * avctx->channels * 2;
268  frame->crc_ctx = av_crc_get_table(AV_CRC_8_EBU);
269 
270  memset(&sbc->dsp.X, 0, sizeof(sbc->dsp.X));
271  sbc->dsp.position = (SBC_X_BUFFER_SIZE - frame->subbands * 9) & ~7;
272  sbc->dsp.increment = sbc->msbc ? 1 : 4;
273  ff_sbcdsp_init(&sbc->dsp);
274 
275  return 0;
276 }
277 
278 static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
279  const AVFrame *av_frame, int *got_packet_ptr)
280 {
281  SBCEncContext *sbc = avctx->priv_data;
282  struct sbc_frame *frame = &sbc->frame;
283  uint8_t joint = frame->mode == SBC_MODE_JOINT_STEREO;
284  uint8_t dual = frame->mode == SBC_MODE_DUAL_CHANNEL;
285  int ret, j = 0;
286 
287  int frame_length = 4 + (4 * frame->subbands * frame->channels) / 8
288  + ((frame->blocks * frame->bitpool * (1 + dual)
289  + joint * frame->subbands) + 7) / 8;
290 
291  /* input must be large enough to encode a complete frame */
292  if (av_frame->nb_samples * frame->channels * 2 < frame->codesize)
293  return 0;
294 
295  if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_length, 0)) < 0)
296  return ret;
297 
298  /* Select the needed input data processing function and call it */
299  if (frame->subbands == 8)
300  sbc->dsp.position = sbc->dsp.sbc_enc_process_input_8s(
301  sbc->dsp.position, av_frame->data[0], sbc->dsp.X,
302  frame->subbands * frame->blocks, frame->channels);
303  else
304  sbc->dsp.position = sbc->dsp.sbc_enc_process_input_4s(
305  sbc->dsp.position, av_frame->data[0], sbc->dsp.X,
306  frame->subbands * frame->blocks, frame->channels);
307 
308  sbc_analyze_audio(&sbc->dsp, &sbc->frame);
309 
310  if (frame->mode == JOINT_STEREO)
311  j = sbc->dsp.sbc_calc_scalefactors_j(frame->sb_sample_f,
312  frame->scale_factor,
313  frame->blocks,
314  frame->subbands);
315  else
316  sbc->dsp.sbc_calc_scalefactors(frame->sb_sample_f,
317  frame->scale_factor,
318  frame->blocks,
319  frame->channels,
320  frame->subbands);
321  emms_c();
322  sbc_pack_frame(avpkt, frame, j, sbc->msbc);
323 
324  *got_packet_ptr = 1;
325  return 0;
326 }
327 
328 #define OFFSET(x) offsetof(SBCEncContext, x)
329 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
330 static const AVOption options[] = {
331  { "sbc_delay", "set maximum algorithmic latency",
332  OFFSET(max_delay), AV_OPT_TYPE_DURATION, {.i64 = 13000}, 1000,13000, AE },
333  { "msbc", "use mSBC mode (wideband speech mono SBC)",
334  OFFSET(msbc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AE },
336  { NULL },
337 };
338 
339 static const AVClass sbc_class = {
340  .class_name = "sbc encoder",
341  .item_name = av_default_item_name,
342  .option = options,
343  .version = LIBAVUTIL_VERSION_INT,
344 };
345 
347  .name = "sbc",
348  .long_name = NULL_IF_CONFIG_SMALL("SBC (low-complexity subband codec)"),
349  .type = AVMEDIA_TYPE_AUDIO,
350  .id = AV_CODEC_ID_SBC,
352  .priv_data_size = sizeof(SBCEncContext),
354  .encode2 = sbc_encode_frame,
355  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
356  .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
358  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
360  .supported_samplerates = (const int[]) { 16000, 32000, 44100, 48000, 0 },
361  .priv_class = &sbc_class,
363 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1008
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:42
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:56
MSBC_SYNCWORD
#define MSBC_SYNCWORD
Definition: sbc.h:71
JOINT_STEREO
#define JOINT_STEREO
Definition: atrac3.c:58
OFFSET
#define OFFSET(x)
Definition: sbcenc.c:328
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:988
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:61
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
encode.h
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:238
STEREO
#define STEREO
Definition: cook.c:63
sbc_analyze_audio
static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)
Definition: sbcenc.c:51
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
MSBC_BLOCKS
#define MSBC_BLOCKS
Definition: sbc.h:41
SBCEncContext::dsp
SBCDSPContext dsp
Definition: sbcenc.c:48
options
static const AVOption options[]
Definition: sbcenc.c:330
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:388
sbcdsp.h
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
SBCEncContext::msbc
int msbc
Definition: sbcenc.c:46
AV_CODEC_ID_SBC
@ AV_CODEC_ID_SBC
Definition: codec_id.h:509
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:180
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:445
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:329
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:45
SBC_SYNCWORD
#define SBC_SYNCWORD
Definition: sbc.h:70
blk
#define blk(i)
Definition: sha.c:185
PutBitContext
Definition: put_bits.h:49
SBCEncContext
Definition: sbcenc.c:43
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:429
SBC_MODE_STEREO
#define SBC_MODE_STEREO
Definition: sbc.h:58
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:62
SBC_ALIGN
#define SBC_ALIGN
Definition: sbc.h:80
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
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:116
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:278
SBC_MODE_MONO
#define SBC_MODE_MONO
Definition: sbc.h:56
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:196
sbc.h
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:989
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
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:369
i
int i
Definition: input.c:406
sbc_frame
Definition: sbc.h:84
sbc_frame::joint
uint8_t joint
Definition: sbc.h:103
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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:54
avcodec.h
ret
ret
Definition: filter_design.txt:187
ff_sbc_encoder
const AVCodec ff_sbc_encoder
Definition: sbcenc.c:346
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:71
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:47
sbc_class
static const AVClass sbc_class
Definition: sbcenc.c:339
AVCodecContext
main external API structure.
Definition: avcodec.h:379
channel_layout.h
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1521
SCALE_OUT_BITS
#define SCALE_OUT_BITS
Definition: sbcdsp.h:40
FF_PROFILE_SBC_MSBC
#define FF_PROFILE_SBC_MSBC
Definition: avcodec.h:1627
ff_sbc_calculate_bits
void ff_sbc_calculate_bits(const struct sbc_frame *frame, int(*bits)[8])
Definition: sbc.c:78
SBC_MODE_DUAL_CHANNEL
#define SBC_MODE_DUAL_CHANNEL
Definition: sbc.h:57
sbc_pack_frame
static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame, int joint, int msbc)
Definition: sbcenc.c:98
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
d
d
Definition: ffmpeg_filter.c:156
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:59
put_bits.h