FFmpeg: libavcodec/sbcenc.c Source File

FFmpeg

[フレーム]

libavcodec

sbcenc.c

Go to the documentation of this file.

1 /*

2 * Bluetooth low-complexity, subband codec (SBC)

3 *

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 */

28 /**

29 * @file

30 * SBC encoder implementation

31 */

33 #include "libavutil/channel_layout.h"

34 #include "libavutil/emms.h"

35 #include "libavutil/opt.h"

36 #include "avcodec.h"

37 #include "codec_internal.h"

38 #include "encode.h"

39 #include "profiles.h"

40 #include "put_bits.h"

41 #include "sbc.h"

42 #include "sbcdsp.h"

44 typedef struct SBCEncContext {

45 AVClass *class;

46 int64_t max_delay;

47 int msbc;

48 DECLARE_ALIGNED(SBC_ALIGN, struct sbc_frame, frame);

49 DECLARE_ALIGNED(SBC_ALIGN, SBCDSPContext, dsp);

50 } SBCEncContext;

52 static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)

53 {

54 int ch, blk;

55 int16_t *x;

57 switch (frame->subbands) {

58 case 4:

59 for (ch = 0; ch < frame->channels; ch++) {

60 x = &s->X[ch][s->position - 4 *

61 s->increment + frame->blocks * 4];

62 for (blk = 0; blk < frame->blocks;

63 blk += s->increment) {

64 s->sbc_analyze_4s(

65 s, x,

66 frame->sb_sample_f[blk][ch],

67 frame->sb_sample_f[blk + 1][ch] -

68 frame->sb_sample_f[blk][ch]);

69 x -= 4 * s->increment;

70 }

71 }

72 return frame->blocks * 4;

74 case 8:

75 for (ch = 0; ch < frame->channels; ch++) {

76 x = &s->X[ch][s->position - 8 *

77 s->increment + frame->blocks * 8];

78 for (blk = 0; blk < frame->blocks;

79 blk += s->increment) {

80 s->sbc_analyze_8s(

81 s, x,

82 frame->sb_sample_f[blk][ch],

83 frame->sb_sample_f[blk + 1][ch] -

84 frame->sb_sample_f[blk][ch]);

85 x -= 8 * s->increment;

86 }

87 }

88 return frame->blocks * 8;

90 default:

91 return AVERROR(EIO);

92 }

93 }

95 /*

96 * Packs the SBC frame from frame into the memory in avpkt.

97 * Returns the length of the packed frame.

98 */

99 static size_t sbc_pack_frame(AVPacket *avpkt, struct sbc_frame *frame,

100 int joint, int msbc)

101 {

102 PutBitContext pb;

103

104 /* Will copy the header parts for CRC-8 calculation here */

105 uint8_t crc_header[11] = { 0 };

106 int crc_pos;

107

108 uint32_t audio_sample;

109

110 int ch, sb, blk; /* channel, subband, block and bit counters */

111 int bits[2][8]; /* bits distribution */

112 uint32_t levels[2][8]; /* levels are derived from that */

113 uint32_t sb_sample_delta[2][8];

114

115 if (msbc) {

116 avpkt->data[0] = MSBC_SYNCWORD;

117 avpkt->data[1] = 0;

118 avpkt->data[2] = 0;

119 } else {

120 avpkt->data[0] = SBC_SYNCWORD;

121

122 avpkt->data[1] = (frame->frequency & 0x03) << 6;

123 avpkt->data[1] |= (((frame->blocks >> 2) - 1) & 0x03) << 4;

124 avpkt->data[1] |= (frame->mode & 0x03) << 2;

125 avpkt->data[1] |= (frame->allocation & 0x01) << 1;

126 avpkt->data[1] |= ((frame->subbands == 8) & 0x01) << 0;

127

128 avpkt->data[2] = frame->bitpool;

129

130 if (frame->bitpool > frame->subbands << (4 + (frame->mode == STEREO

131 || frame->mode == JOINT_STEREO)))

132 return -5;

133 }

134

135 /* Can't fill in crc yet */

136 crc_header[0] = avpkt->data[1];

137 crc_header[1] = avpkt->data[2];

138 crc_pos = 16;

139

140 init_put_bits(&pb, avpkt->data + 4, avpkt->size);

141

142 if (frame->mode == JOINT_STEREO) {

143 put_bits(&pb, frame->subbands, joint);

144 crc_header[crc_pos >> 3] = joint;

145 crc_pos += frame->subbands;

146 }

147

148 for (ch = 0; ch < frame->channels; ch++) {

149 for (sb = 0; sb < frame->subbands; sb++) {

150 put_bits(&pb, 4, frame->scale_factor[ch][sb] & 0x0F);

151 crc_header[crc_pos >> 3] <<= 4;

152 crc_header[crc_pos >> 3] |= frame->scale_factor[ch][sb] & 0x0F;

153 crc_pos += 4;

154 }

155 }

156

157 /* align the last crc byte */

158 if (crc_pos % 8)

159 crc_header[crc_pos >> 3] <<= 8 - (crc_pos % 8);

160

161 avpkt->data[3] = ff_sbc_crc8(frame->crc_ctx, crc_header, crc_pos);

162

163 ff_sbc_calculate_bits(frame, bits);

164

165 for (ch = 0; ch < frame->channels; ch++) {

166 for (sb = 0; sb < frame->subbands; sb++) {

167 levels[ch][sb] = ((1 << bits[ch][sb]) - 1) <<

168 (32 - (frame->scale_factor[ch][sb] +

169 SCALE_OUT_BITS + 2));

170 sb_sample_delta[ch][sb] = (uint32_t) 1 <<

171 (frame->scale_factor[ch][sb] +

172 SCALE_OUT_BITS + 1);

173 }

174 }

175

176 for (blk = 0; blk < frame->blocks; blk++) {

177 for (ch = 0; ch < frame->channels; ch++) {

178 for (sb = 0; sb < frame->subbands; sb++) {

179

180 if (bits[ch][sb] == 0)

181 continue;

182

183 audio_sample = ((uint64_t) levels[ch][sb] *

184 (sb_sample_delta[ch][sb] +

185 frame->sb_sample_f[blk][ch][sb])) >> 32;

186

187 put_bits(&pb, bits[ch][sb], audio_sample);

188 }

189 }

190 }

191

192 flush_put_bits(&pb);

193

194 return put_bytes_output(&pb);

195 }

196

197 static int sbc_encode_init(AVCodecContext *avctx)

198 {

199 SBCEncContext *sbc = avctx->priv_data;

200 struct sbc_frame *frame = &sbc->frame;

201

202 if (avctx->profile == AV_PROFILE_SBC_MSBC)

203 sbc->msbc = 1;

204

205 if (sbc->msbc) {

206 if (avctx->ch_layout.nb_channels != 1) {

207 av_log(avctx, AV_LOG_ERROR, "mSBC require mono channel.\n");

208 return AVERROR(EINVAL);

209 }

210

211 if (avctx->sample_rate != 16000) {

212 av_log(avctx, AV_LOG_ERROR, "mSBC require 16 kHz samplerate.\n");

213 return AVERROR(EINVAL);

214 }

215

216 frame->mode = SBC_MODE_MONO;

217 frame->subbands = 8;

218 frame->blocks = MSBC_BLOCKS;

219 frame->allocation = SBC_AM_LOUDNESS;

220 frame->bitpool = 26;

221

222 avctx->frame_size = 8 * MSBC_BLOCKS;

223 } else {

224 int d;

225

226 if (avctx->global_quality > 255*FF_QP2LAMBDA) {

227 av_log(avctx, AV_LOG_ERROR, "bitpool > 255 is not allowed.\n");

228 return AVERROR(EINVAL);

229 }

230

231 if (avctx->ch_layout.nb_channels == 1) {

232 frame->mode = SBC_MODE_MONO;

233 if (sbc->max_delay <= 3000 || avctx->bit_rate > 270000)

234 frame->subbands = 4;

235 else

236 frame->subbands = 8;

237 } else {

238 if (avctx->bit_rate < 180000 || avctx->bit_rate > 420000)

239 frame->mode = SBC_MODE_JOINT_STEREO;

240 else

241 frame->mode = SBC_MODE_STEREO;

242 if (sbc->max_delay <= 4000 || avctx->bit_rate > 420000)

243 frame->subbands = 4;

244 else

245 frame->subbands = 8;

246 }

247 /* sbc algorithmic delay is ((blocks + 10) * subbands - 2) / sample_rate */

248 frame->blocks = av_clip(((sbc->max_delay * avctx->sample_rate + 2)

249 / (1000000 * frame->subbands)) - 10, 4, 16) & ~3;

250

251 frame->allocation = SBC_AM_LOUDNESS;

252

253 d = frame->blocks * ((frame->mode == SBC_MODE_DUAL_CHANNEL) + 1);

254 frame->bitpool = (((avctx->bit_rate * frame->subbands * frame->blocks) / avctx->sample_rate)

255 - 4 * frame->subbands * avctx->ch_layout.nb_channels

256 - (frame->mode == SBC_MODE_JOINT_STEREO)*frame->subbands - 32 + d/2) / d;

257 if (avctx->global_quality > 0)

258 frame->bitpool = avctx->global_quality / FF_QP2LAMBDA;

259

260 avctx->frame_size = 4*((frame->subbands >> 3) + 1) * 4*(frame->blocks >> 2);

261 }

262

263 for (int i = 0; avctx->codec->supported_samplerates[i]; i++)

264 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])

265 frame->frequency = i;

266

267 frame->channels = avctx->ch_layout.nb_channels;

268 frame->codesize = frame->subbands * frame->blocks * avctx->ch_layout.nb_channels * 2;

269 frame->crc_ctx = av_crc_get_table(AV_CRC_8_EBU);

270

271 memset(&sbc->dsp.X, 0, sizeof(sbc->dsp.X));

272 sbc->dsp.position = (SBC_X_BUFFER_SIZE - frame->subbands * 9) & ~7;

273 sbc->dsp.increment = sbc->msbc ? 1 : 4;

274 ff_sbcdsp_init(&sbc->dsp);

275

276 return 0;

277 }

278

279 static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

280 const AVFrame *av_frame, int *got_packet_ptr)

281 {

282 SBCEncContext *sbc = avctx->priv_data;

283 struct sbc_frame *frame = &sbc->frame;

284 uint8_t joint = frame->mode == SBC_MODE_JOINT_STEREO;

285 uint8_t dual = frame->mode == SBC_MODE_DUAL_CHANNEL;

286 int ret, j = 0;

287

288 int frame_length = 4 + (4 * frame->subbands * frame->channels) / 8

289 + ((frame->blocks * frame->bitpool * (1 + dual)

290 + joint * frame->subbands) + 7) / 8;

291

292 /* input must be large enough to encode a complete frame */

293 if (av_frame->nb_samples * frame->channels * 2 < frame->codesize)

294 return 0;

295

296 if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_length, 0)) < 0)

297 return ret;

298

299 /* Select the needed input data processing function and call it */

300 if (frame->subbands == 8)

301 sbc->dsp.position = sbc->dsp.sbc_enc_process_input_8s(

302 sbc->dsp.position, av_frame->data[0], sbc->dsp.X,

303 frame->subbands * frame->blocks, frame->channels);

304 else

305 sbc->dsp.position = sbc->dsp.sbc_enc_process_input_4s(

306 sbc->dsp.position, av_frame->data[0], sbc->dsp.X,

307 frame->subbands * frame->blocks, frame->channels);

308

309 sbc_analyze_audio(&sbc->dsp, &sbc->frame);

310

311 if (frame->mode == JOINT_STEREO)

312 j = sbc->dsp.sbc_calc_scalefactors_j(frame->sb_sample_f,

313 frame->scale_factor,

314 frame->blocks,

315 frame->subbands);

316 else

317 sbc->dsp.sbc_calc_scalefactors(frame->sb_sample_f,

318 frame->scale_factor,

319 frame->blocks,

320 frame->channels,

321 frame->subbands);

322 emms_c();

323 sbc_pack_frame(avpkt, frame, j, sbc->msbc);

324

325 *got_packet_ptr = 1;

326 return 0;

327 }

328

329 #define OFFSET(x) offsetof(SBCEncContext, x)

330 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

331 static const AVOption options[] = {

332 { "sbc_delay", "set maximum algorithmic latency",

333 OFFSET(max_delay), AV_OPT_TYPE_DURATION, {.i64 = 13000}, 1000,13000, AE },

334 { "msbc", "use mSBC mode (wideband speech mono SBC)",

335 OFFSET(msbc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AE },

336 FF_AVCTX_PROFILE_OPTION("msbc", NULL, AUDIO, AV_PROFILE_SBC_MSBC)

337 { NULL },

338 };

339

340 static const AVClass sbc_class = {

341 .class_name = "sbc encoder",

342 .item_name = av_default_item_name,

343 .option = options,

344 .version = LIBAVUTIL_VERSION_INT,

345 };

346

347 const FFCodec ff_sbc_encoder = {

348 .p.name = "sbc",

349 CODEC_LONG_NAME("SBC (low-complexity subband codec)"),

350 .p.type = AVMEDIA_TYPE_AUDIO,

351 .p.id = AV_CODEC_ID_SBC,

352 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME |

353 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

354 .priv_data_size = sizeof(SBCEncContext),

355 .init = sbc_encode_init,

356 FF_CODEC_ENCODE_CB(sbc_encode_frame),

357 .p.ch_layouts = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,

358 AV_CHANNEL_LAYOUT_STEREO,

359 { 0 } },

360 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,

361 AV_SAMPLE_FMT_NONE },

362 .p.supported_samplerates = (const int[]) { 16000, 32000, 44100, 48000, 0 },

363 .p.priv_class = &sbc_class,

364 .p.profiles = NULL_IF_CONFIG_SMALL(ff_sbc_profiles),

365 };

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1083

av_clip

#define av_clip

Definition: common.h:100

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:59

OFFSET

#define OFFSET(x)

Definition: sbcenc.c:329

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:387

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:89

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

int64_t

long long int64_t

Definition: coverity.c:34

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:223

AVPacket::data

uint8_t * data

Definition: packet.h:539

AVOption

AVOption.

Definition: opt.h:429

encode.h

AV_OPT_TYPE_DURATION

@ AV_OPT_TYPE_DURATION

Underlying C type is int64_t.

Definition: opt.h:319

FFCodec

Definition: codec_internal.h:127

STEREO

#define STEREO

Definition: cook.c:65

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

sbc_analyze_audio

static int sbc_analyze_audio(SBCDSPContext *s, struct sbc_frame *frame)

Definition: sbcenc.c:52

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:410

MSBC_BLOCKS

#define MSBC_BLOCKS

Definition: sbc.h:41

SBCEncContext::dsp

SBCDSPContext dsp

Definition: sbcenc.c:49

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

options

static const AVOption options[]

Definition: sbcenc.c:331

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:460

AVCodec::supported_samplerates

const attribute_deprecated int * supported_samplerates

Definition: codec.h:217

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

sbcdsp.h

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:320

SBCEncContext::msbc

int msbc

Definition: sbcenc.c:47

AV_CODEC_ID_SBC

@ AV_CODEC_ID_SBC

Definition: codec_id.h:527

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

emms_c

#define emms_c()

Definition: emms.h:63

#define s(width, name)

Definition: cbs_vp9.c:198

AVCodecContext::global_quality

int global_quality

Global quality for codecs which cannot change it per frame.

Definition: avcodec.h:1249

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:26

#define AE

Definition: sbcenc.c:330

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:159

bits

uint8_t bits

Definition: vp3data.h:128

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:46

SBC_SYNCWORD

#define SBC_SYNCWORD

Definition: sbc.h:70

blk

#define blk(i)

Definition: sha.c:186

PutBitContext

Definition: put_bits.h:50

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

SBCEncContext

Definition: sbcenc.c:44

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:501

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:237

profiles.h

SBC_AM_LOUDNESS

#define SBC_AM_LOUDNESS

Definition: sbc.h:62

SBC_ALIGN

#define SBC_ALIGN

Definition: sbc.h:80

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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:540

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:94

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:311

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

sbc_encode_frame

static int sbc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *av_frame, int *got_packet_ptr)

Definition: sbcenc.c:279

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:197

sbc.h

emms.h

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:469

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

sbc_frame

Definition: sbc.h:84

sbc_frame::joint

uint8_t joint

Definition: sbc.h:103

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

ff_sbc_encoder

const FFCodec ff_sbc_encoder

Definition: sbcenc.c:347

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

ff_sbc_profiles

const AVProfile ff_sbc_profiles[]

Definition: profiles.c:170

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

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: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:48

sbc_class

static const AVClass sbc_class

Definition: sbcenc.c:340

AVCodecContext

main external API structure.

Definition: avcodec.h:451

channel_layout.h

AV_PROFILE_SBC_MSBC