FFmpeg  4.4.6
libtwolame.c
Go to the documentation of this file.
1 /*
2  * Interface to libtwolame for mp2 encoding
3  * Copyright (c) 2012 Paul B Mahol
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  * Interface to libtwolame for mp2 encoding.
25  */
26 
27 #include <twolame.h>
28 
29 #include "libavutil/common.h"
30 #include "libavutil/opt.h"
31 
32 #include "avcodec.h"
33 #include "internal.h"
34 #include "mpegaudio.h"
35 
36 typedef struct TWOLAMEContext {
37  AVClass *class;
38  int mode;
39  int psymodel;
40  int energy;
42  int copyright;
43  int original;
44  int verbosity;
45 
46  twolame_options *glopts;
49 
51 {
52  TWOLAMEContext *s = avctx->priv_data;
53  twolame_close(&s->glopts);
54  return 0;
55 }
56 
58 {
59  TWOLAMEContext *s = avctx->priv_data;
60  int ret;
61 
62  avctx->frame_size = TWOLAME_SAMPLES_PER_FRAME;
63  avctx->initial_padding = 512 - 32 + 1;
64 
65  s->glopts = twolame_init();
66  if (!s->glopts)
67  return AVERROR(ENOMEM);
68 
69  twolame_set_verbosity(s->glopts, s->verbosity);
70  twolame_set_mode(s->glopts, s->mode);
71  twolame_set_psymodel(s->glopts, s->psymodel);
72  twolame_set_energy_levels(s->glopts, s->energy);
73  twolame_set_error_protection(s->glopts, s->error_protection);
74  twolame_set_copyright(s->glopts, s->copyright);
75  twolame_set_original(s->glopts, s->original);
76 
77  twolame_set_num_channels(s->glopts, avctx->channels);
78  twolame_set_in_samplerate(s->glopts, avctx->sample_rate);
79  twolame_set_out_samplerate(s->glopts, avctx->sample_rate);
80 
81  if (!avctx->bit_rate) {
82  if ((s->mode == TWOLAME_AUTO_MODE && avctx->channels == 1) || s->mode == TWOLAME_MONO)
83  avctx->bit_rate = avctx->sample_rate < 28000 ? 80000 : 192000;
84  else
85  avctx->bit_rate = avctx->sample_rate < 28000 ? 160000 : 384000;
86  }
87 
88  if (avctx->flags & AV_CODEC_FLAG_QSCALE || !avctx->bit_rate) {
89  twolame_set_VBR(s->glopts, TRUE);
90  twolame_set_VBR_level(s->glopts,
91  avctx->global_quality / (float) FF_QP2LAMBDA);
92  av_log(avctx, AV_LOG_WARNING,
93  "VBR in MP2 is a hack, use another codec that supports it.\n");
94  } else {
95  twolame_set_bitrate(s->glopts, avctx->bit_rate / 1000);
96  }
97 
98  ret = twolame_init_params(s->glopts);
99  if (ret) {
100  twolame_encode_close(avctx);
101  return AVERROR_UNKNOWN;
102  }
103 
104  return 0;
105 }
106 
107 static int twolame_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
108  const AVFrame *frame, int *got_packet_ptr)
109 {
110  TWOLAMEContext *s = avctx->priv_data;
111  int ret;
112 
113  if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE, 0)) < 0)
114  return ret;
115 
116  if (frame) {
117  switch (avctx->sample_fmt) {
118  case AV_SAMPLE_FMT_FLT:
119  ret = twolame_encode_buffer_float32_interleaved(s->glopts,
120  (const float *)frame->data[0],
121  frame->nb_samples,
122  avpkt->data,
123  avpkt->size);
124  break;
125  case AV_SAMPLE_FMT_FLTP:
126  ret = twolame_encode_buffer_float32(s->glopts,
127  (const float *)frame->data[0],
128  (const float *)frame->data[1],
129  frame->nb_samples,
130  avpkt->data, avpkt->size);
131  break;
132  case AV_SAMPLE_FMT_S16:
133  ret = twolame_encode_buffer_interleaved(s->glopts,
134  (const short int *)frame->data[0],
135  frame->nb_samples,
136  avpkt->data, avpkt->size);
137  break;
138  case AV_SAMPLE_FMT_S16P:
139  ret = twolame_encode_buffer(s->glopts,
140  (const short int *)frame->data[0],
141  (const short int *)frame->data[1],
142  frame->nb_samples,
143  avpkt->data, avpkt->size);
144  break;
145  default:
146  av_log(avctx, AV_LOG_ERROR,
147  "Unsupported sample format %d.\n", avctx->sample_fmt);
148  return AVERROR_BUG;
149  }
150  } else {
151  ret = twolame_encode_flush(s->glopts, avpkt->data, avpkt->size);
152  }
153 
154  if (!ret) // no bytes written
155  return 0;
156  if (ret < 0) // twolame error
157  return AVERROR_UNKNOWN;
158 
159  if (frame) {
161  if (frame->pts != AV_NOPTS_VALUE)
162  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
163  } else {
164  avpkt->pts = s->next_pts;
165  }
166  // this is for setting pts for flushed packet(s).
167  if (avpkt->pts != AV_NOPTS_VALUE)
168  s->next_pts = avpkt->pts + avpkt->duration;
169 
170  av_shrink_packet(avpkt, ret);
171  *got_packet_ptr = 1;
172  return 0;
173 }
174 
175 #define OFFSET(x) offsetof(TWOLAMEContext, x)
176 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
177 static const AVOption options[] = {
178  { "mode", "Mpeg Mode", OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = TWOLAME_AUTO_MODE }, TWOLAME_AUTO_MODE, TWOLAME_MONO, AE, "mode"},
179  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_AUTO_MODE }, 0, 0, AE, "mode" },
180  { "stereo", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_STEREO }, 0, 0, AE, "mode" },
181  { "joint_stereo", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_JOINT_STEREO }, 0, 0, AE, "mode" },
182  { "dual_channel", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_DUAL_CHANNEL }, 0, 0, AE, "mode" },
183  { "mono", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_MONO }, 0, 0, AE, "mode" },
184  { "psymodel", "Psychoacoustic Model", OFFSET(psymodel), AV_OPT_TYPE_INT, { .i64 = 3 }, -1, 4, AE},
185  { "energy_levels","enable energy levels", OFFSET(energy), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AE},
186  { "error_protection","enable CRC error protection", OFFSET(error_protection), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AE},
187  { "copyright", "set MPEG Audio Copyright flag", OFFSET(copyright), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AE},
188  { "original", "set MPEG Audio Original flag", OFFSET(original), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AE},
189  { "verbosity", "set library optput level (0-10)", OFFSET(verbosity), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 10, AE},
190  { NULL },
191 };
192 
193 static const AVClass twolame_class = {
194  .class_name = "libtwolame encoder",
195  .item_name = av_default_item_name,
196  .option = options,
197  .version = LIBAVUTIL_VERSION_INT,
198 };
199 
201  { "b", "0" },
202  { NULL },
203 };
204 
205 static const int twolame_samplerates[] = {
206  16000, 22050, 24000, 32000, 44100, 48000, 0
207 };
208 
210  .name = "libtwolame",
211  .long_name = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),
212  .type = AVMEDIA_TYPE_AUDIO,
213  .id = AV_CODEC_ID_MP2,
214  .priv_data_size = sizeof(TWOLAMEContext),
216  .encode2 = twolame_encode_frame,
217  .close = twolame_encode_close,
218  .capabilities = AV_CODEC_CAP_DELAY,
220  .priv_class = &twolame_class,
221  .sample_fmts = (const enum AVSampleFormat[]) {
227  },
228  .channel_layouts = (const uint64_t[]) {
231  0 },
232  .supported_samplerates = twolame_samplerates,
233  .wrapper_name = "libtwolame",
234 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
#define av_cold
Definition: attributes.h:88
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
common internal and external API header
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
static AVFrame * frame
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
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
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
#define AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_STEREO
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
@ AV_CODEC_ID_MP2
Definition: codec_id.h:424
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:277
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AE
Definition: libtwolame.c:176
static int twolame_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libtwolame.c:107
static const AVOption options[]
Definition: libtwolame.c:177
static av_cold int twolame_encode_init(AVCodecContext *avctx)
Definition: libtwolame.c:57
AVCodec ff_libtwolame_encoder
Definition: libtwolame.c:209
static av_cold int twolame_encode_close(AVCodecContext *avctx)
Definition: libtwolame.c:50
#define OFFSET(x)
Definition: libtwolame.c:175
static const int twolame_samplerates[]
Definition: libtwolame.c:205
static const AVClass twolame_class
Definition: libtwolame.c:193
static const AVCodecDefault twolame_defaults[]
Definition: libtwolame.c:200
mpeg audio declarations for both encoder and decoder.
#define MPA_MAX_CODED_FRAME_SIZE
Definition: mpegaudio.h:40
AVOptions.
Describe the class of an AVClass context structure.
Definition: log.h:67
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
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:602
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
int initial_padding
Audio only.
Definition: avcodec.h:2066
int sample_rate
samples per second
Definition: avcodec.h:1196
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
int channels
number of audio channels
Definition: avcodec.h:1197
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
twolame_options * glopts
Definition: libtwolame.c:46
int64_t next_pts
Definition: libtwolame.c:47
int error_protection
Definition: libtwolame.c:41
#define av_log(a,...)