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 
160  ff_sbc_calculate_bits(frame, bits);
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_bits_count(&pb) + 7) / 8;
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)
236  frame->mode = SBC_MODE_JOINT_STEREO;
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;
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 };
enum sbc_frame::@135 mode
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:535
#define SBC_X_BUFFER_SIZE
Definition: sbcdsp.h:39
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int msbc
Definition: sbcenc.c:44
AVOption.
Definition: opt.h:248
uint16_t codesize
Definition: sbc.h:98
#define JOINT_STEREO
Definition: atrac3.c:55
static const AVOption options[]
Definition: sbcenc.c:328
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int32_t sb_sample_f[16][2][8]
Definition: sbc.h:107
#define SBC_AM_LOUDNESS
Definition: sbc.h:60
#define AV_CH_LAYOUT_STEREO
#define blk(i)
Definition: sha.c:185
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
SBC basic "building bricks".
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
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
#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:40
#define MSBC_BLOCKS
Definition: sbc.h:39
uint8_t
AVOptions.
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
AVCodec ff_sbc_encoder
Definition: sbcenc.c:344
uint8_t * data
Definition: packet.h:363
#define av_log(a,...)
#define SBC_MODE_MONO
Definition: sbc.h:54
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
SBCDSPContext dsp
Definition: sbcenc.c:46
uint32_t scale_factor[2][8]
Definition: sbc.h:104
uint8_t bitpool
Definition: sbc.h:97
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame, int joint, int msbc)
Definition: sbcenc.c:96
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:81
av_cold void ff_sbcdsp_init(SBCDSPContext *s)
Definition: sbcdsp.c:364
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:80
uint8_t channels
Definition: sbc.h:91
static const AVClass sbc_class
Definition: sbcenc.c:337
#define s(width, name)
Definition: cbs_vp9.c:257
#define SBC_MODE_JOINT_STEREO
Definition: sbc.h:57
uint8_t ff_sbc_crc8(const AVCRC *ctx, const uint8_t *data, size_t len)
Definition: sbc.c:55
#define OFFSET(x)
Definition: sbcenc.c:326
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
#define MSBC_SYNCWORD
Definition: sbc.h:69
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)
Definition: sbcenc.c:49
int sample_rate
samples per second
Definition: avcodec.h:1186
#define SBC_MODE_DUAL_CHANNEL
Definition: sbc.h:55
main external API structure.
Definition: avcodec.h:526
#define FF_PROFILE_SBC_MSBC
Definition: avcodec.h:1962
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
Describe the class of an AVClass context structure.
Definition: log.h:67
int64_t max_delay
Definition: sbcenc.c:43
uint8_t frequency
Definition: sbc.h:83
enum sbc_frame::@136 allocation
#define AE
Definition: sbcenc.c:327
#define SBC_ALIGN
Definition: sbc.h:78
uint8_t joint
Definition: sbc.h:101
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/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_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 *(UINT64_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 *(UINT64_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
const AVProfile ff_sbc_profiles[]
Definition: profiles.c:148
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
common internal api header.
#define STEREO
Definition: cook.c:61
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
signed 16 bits
Definition: samplefmt.h:61
const AVCRC * crc_ctx
Definition: sbc.h:112
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
#define FF_AVCTX_PROFILE_OPTION(name, description, type, value)
Definition: profiles.h:25
SBC common definitions for the encoder and decoder.
#define SBC_MODE_STEREO
Definition: sbc.h:56
void * priv_data
Definition: avcodec.h:553
static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *av_frame, int *got_packet_ptr)
Definition: sbcenc.c:276
int channels
number of audio channels
Definition: avcodec.h:1187
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: codec.h:212
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
void ff_sbc_calculate_bits(const struct sbc_frame *frame, int(*bits)[8])
Definition: sbc.c:79
Definition: sbc.h:82
struct sbc_frame frame
Definition: sbcenc.c:45
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
#define AV_CH_LAYOUT_MONO
#define SCALE_OUT_BITS
Definition: sbcdsp.h:38
This structure stores compressed data.
Definition: packet.h:340
uint8_t subbands
Definition: sbc.h:96
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:374
#define SBC_SYNCWORD
Definition: sbc.h:68
int i
Definition: input.c:407
static int sbc_encode_init(AVCodecContext *avctx)
Definition: sbcenc.c:194
uint8_t blocks
Definition: sbc.h:84
bitstream writer API