1 /* GStreamer
2 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3 * Copyright (C) <2004> Wim Taymans <wim@fluendo.com>
4 * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
20 */
22 /**
23 * SECTION:element-lame
24 * @see_also: lame, mad, vorbisenc
25 *
26 * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream.
27 * Note that <ulink url="http://en.wikipedia.org/wiki/MP3">MP3</ulink> is not
28 * a free format, there are licensing and patent issues to take into
29 * consideration. See <ulink url="http://www.vorbis.com/">Ogg/Vorbis</ulink>
30 * for a royalty free (and often higher quality) alternative.
31 *
32 * <refsect2>
33 * <title>Note</title>
34 * This element is deprecated, use the lame element instead
35 * which provides a much simpler interface and results in better MP3 files.
36 * </refsect2>
37 *
38 * <refsect2>
39 * <title>Output sample rate</title>
40 * If no fixed output sample rate is negotiated on the element's src pad,
41 * the element will choose an optimal sample rate to resample to internally.
42 * For example, a 16-bit 44.1 KHz mono audio stream encoded at 48 kbit will
43 * get resampled to 32 KHz. Use filter caps on the src pad to force a
44 * particular sample rate.
45 * </refsect2>
46 * <refsect2>
47 * <title>Writing metadata (tags)</title>
48 * Whilst the lame encoder element does claim to implement the GstTagSetter
49 * interface, it does so only for backwards compatibility reasons. Tag writing
50 * has been removed from lame. Use external elements like id3v2mux or apev2mux
51 * to add tags to your MP3 streams. The same goes for XING headers: use the
52 * xingmux element to add XING headers to your VBR mp3 file.
53 * </refsect2>
54 * <refsect2>
55 * <title>Example pipelines</title>
56 * |[
57 * gst-launch -v audiotestsrc wave=sine num-buffers=100 ! audioconvert ! lame ! filesink location=sine.mp3
58 * ]| Encode a test sine signal to MP3.
59 * |[
60 * gst-launch -v alsasrc ! audioconvert ! lame bitrate=192 ! filesink location=alsasrc.mp3
61 * ]| Record from a sound card using ALSA and encode to MP3
62 * |[
63 * gst-launch -v filesrc location=music.wav ! decodebin ! audioconvert ! audioresample ! lame bitrate=192 ! id3v2mux ! filesink location=music.mp3
64 * ]| Transcode from a .wav file to MP3 (the id3v2mux element is optional)
65 * |[
66 * gst-launch -v cdda://5 ! audioconvert ! lame bitrate=192 ! filesink location=track5.mp3
67 * ]| Encode Audio CD track 5 to MP3
68 * |[
69 * gst-launch -v audiotestsrc num-buffers=10 ! audio/x-raw-int,rate=44100,channels=1 ! lame bitrate=48 mode=3 ! filesink location=test.mp3
70 * ]| Encode to a fixed sample rate
71 * </refsect2>
72 *
73 * Last reviewed on 2007-07-24 (0.10.7)
74 */
76 /* FIXME 0.11: Remove all properties except the useful ones. Nobody knows what most
77 * properties are doing and they're intended for LAME developers only.
78 */
80 #ifdef HAVE_CONFIG_H
81 #include "config.h"
82 #endif
84 #include "string.h"
85 #include "gstlame.h"
86 #include "gst/gst-i18n-plugin.h"
88 #ifdef lame_set_preset
89 #define GST_LAME_PRESET
90 #endif
92 GST_DEBUG_CATEGORY_STATIC (debug);
93 #define GST_CAT_DEFAULT debug
95 /* LAME can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible
96 * sample rates it supports */
97 static GstStaticPadTemplate gst_lame_sink_template =
98 GST_STATIC_PAD_TEMPLATE ("sink",
99 GST_PAD_SINK,
100 GST_PAD_ALWAYS,
101 GST_STATIC_CAPS ("audio/x-raw-int, "
102 "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", "
103 "signed = (boolean) true, "
104 "width = (int) 16, "
105 "depth = (int) 16, "
106 "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
107 "channels = (int) [ 1, 2 ]")
108 );
110 static GstStaticPadTemplate gst_lame_src_template =
111 GST_STATIC_PAD_TEMPLATE ("src",
112 GST_PAD_SRC,
113 GST_PAD_ALWAYS,
114 GST_STATIC_CAPS ("audio/mpeg, "
115 "mpegversion = (int) 1, "
116 "layer = (int) 3, "
117 "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
118 "channels = (int) [ 1, 2 ]")
119 );
121 static struct
122 {
123 gint bitrate;
124 gfloat compression_ratio;
125 gint quality;
126 gint mode;
127 gboolean force_ms;
128 gboolean free_format;
129 gboolean copyright;
130 gboolean original;
131 gboolean error_protection;
132 gboolean extension;
133 gboolean strict_iso;
134 gboolean disable_reservoir;
135 gint vbr;
136 gint vbr_quality;
137 gint vbr_mean_bitrate;
138 gint vbr_min_bitrate;
139 gint vbr_max_bitrate;
140 gint vbr_hard_min;
141 gint lowpass_freq;
142 gint lowpass_width;
143 gint highpass_freq;
144 gint highpass_width;
145 gboolean ath_only;
146 gboolean ath_short;
147 gboolean no_ath;
148 gint ath_type;
149 gint ath_lower;
150 gboolean allow_diff_short;
151 gboolean no_short_blocks;
152 gboolean emphasis;
153 gint preset;
154 } gst_lame_default_settings;
156 /********** Define useful types for non-programmatic interfaces **********/
157 #define GST_TYPE_LAME_MODE (gst_lame_mode_get_type())
158 static GType
159 gst_lame_mode_get_type (void)
160 {
161 static GType lame_mode_type = 0;
162 static GEnumValue lame_modes[] = {
163 {0, "Stereo", "stereo"},
164 {1, "Joint Stereo", "joint"},
165 {2, "Dual Channel", "dual"},
166 {3, "Mono", "mono"},
167 {4, "Auto", "auto"},
168 {0, NULL, NULL}
169 };
171 if (!lame_mode_type) {
172 lame_mode_type = g_enum_register_static ("GstLameMode", lame_modes);
173 }
174 return lame_mode_type;
175 }
177 #define GST_TYPE_LAME_QUALITY (gst_lame_quality_get_type())
178 static GType
179 gst_lame_quality_get_type (void)
180 {
181 static GType lame_quality_type = 0;
182 static GEnumValue lame_quality[] = {
183 {0, "0 - Best", "0"},
184 {1, "1", "1"},
185 {2, "2", "2"},
186 {3, "3", "3"},
187 {4, "4", "4"},
188 {5, "5 - Default", "5"},
189 {6, "6", "6"},
190 {7, "7", "7"},
191 {8, "8", "8"},
192 {9, "9 - Worst", "9"},
193 {0, NULL, NULL}
194 };
196 if (!lame_quality_type) {
197 lame_quality_type = g_enum_register_static ("GstLameQuality", lame_quality);
198 }
199 return lame_quality_type;
200 }
202 #define GST_TYPE_LAME_PADDING (gst_lame_padding_get_type())
203 static GType
204 gst_lame_padding_get_type (void)
205 {
206 static GType lame_padding_type = 0;
207 static GEnumValue lame_padding[] = {
208 {0, "No Padding", "never"},
209 {1, "Always Pad", "always"},
210 {2, "Adjust Padding", "adjust"},
211 {0, NULL, NULL}
212 };
214 if (!lame_padding_type) {
215 lame_padding_type = g_enum_register_static ("GstLamePadding", lame_padding);
216 }
217 return lame_padding_type;
218 }
220 #define GST_TYPE_LAME_VBRMODE (gst_lame_vbrmode_get_type())
221 static GType
222 gst_lame_vbrmode_get_type (void)
223 {
224 static GType lame_vbrmode_type = 0;
225 static GEnumValue lame_vbrmode[] = {
226 {vbr_off, "No VBR (Constant Bitrate)", "none"},
227 {vbr_rh, "Lame's old VBR algorithm", "old"},
228 {vbr_abr, "VBR Average Bitrate", "abr"},
229 {vbr_mtrh, "Lame's new VBR algorithm", "new"},
230 {0, NULL, NULL}
231 };
233 if (!lame_vbrmode_type) {
234 lame_vbrmode_type = g_enum_register_static ("GstLameVbrmode", lame_vbrmode);
235 }
237 return lame_vbrmode_type;
238 }
240 #ifdef GSTLAME_PRESET
241 #define GST_TYPE_LAME_PRESET (gst_lame_preset_get_type())
242 static GType
243 gst_lame_preset_get_type (void)
244 {
245 static GType gst_lame_preset = 0;
246 static GEnumValue gst_lame_presets[] = {
247 {0, "None", "none"},
248 {MEDIUM, "Medium", "medium"},
249 {STANDARD, "Standard", "standard"},
250 {EXTREME, "Extreme", "extreme"},
251 {INSANE, "Insane", "insane"},
252 {0, NULL, NULL}
253 };
255 if (!gst_lame_preset) {
256 gst_lame_preset =
257 g_enum_register_static ("GstLamePreset", gst_lame_presets);
258 }
260 return gst_lame_preset;
261 }
262 #endif
264 /********** Standard stuff for signals and arguments **********/
266 enum
267 {
268 ARG_0,
269 ARG_BITRATE,
270 ARG_COMPRESSION_RATIO,
271 ARG_QUALITY,
272 ARG_MODE,
273 ARG_FORCE_MS,
274 ARG_FREE_FORMAT,
275 ARG_COPYRIGHT,
276 ARG_ORIGINAL,
277 ARG_ERROR_PROTECTION,
278 ARG_PADDING_TYPE, /* FIXME: remove in 0.11 */
279 ARG_EXTENSION,
280 ARG_STRICT_ISO,
281 ARG_DISABLE_RESERVOIR,
282 ARG_VBR,
283 ARG_VBR_MEAN_BITRATE,
284 ARG_VBR_MIN_BITRATE,
285 ARG_VBR_MAX_BITRATE,
286 ARG_VBR_HARD_MIN,
287 ARG_LOWPASS_FREQ,
288 ARG_LOWPASS_WIDTH,
289 ARG_HIGHPASS_FREQ,
290 ARG_HIGHPASS_WIDTH,
291 ARG_ATH_ONLY,
292 ARG_ATH_SHORT,
293 ARG_NO_ATH,
294 ARG_ATH_LOWER,
295 ARG_CWLIMIT, /* FIXME: remove in 0.11 */
296 ARG_ALLOW_DIFF_SHORT,
297 ARG_NO_SHORT_BLOCKS,
298 ARG_EMPHASIS,
299 ARG_VBR_QUALITY,
300 #ifdef GSTLAME_PRESET
301 ARG_XINGHEADER, /* FIXME: remove in 0.11 */
302 ARG_PRESET
303 #else
304 ARG_XINGHEADER /* FIXME: remove in 0.11 */
305 #endif
306 };
308 static gboolean gst_lame_start (GstAudioEncoder * enc);
309 static gboolean gst_lame_stop (GstAudioEncoder * enc);
310 static gboolean gst_lame_set_format (GstAudioEncoder * enc,
311 GstAudioInfo * info);
312 static GstFlowReturn gst_lame_handle_frame (GstAudioEncoder * enc,
313 GstBuffer * in_buf);
314 static void gst_lame_flush (GstAudioEncoder * enc);
316 static void gst_lame_set_property (GObject * object, guint prop_id,
317 const GValue * value, GParamSpec * pspec);
318 static void gst_lame_get_property (GObject * object, guint prop_id,
319 GValue * value, GParamSpec * pspec);
320 static gboolean gst_lame_setup (GstLame * lame);
322 static void
323 gst_lame_add_interfaces (GType lame_type)
324 {
325 static const GInterfaceInfo tag_setter_info = { NULL, NULL, NULL };
327 /* FIXME: remove support for the GstTagSetter interface in 0.11 */
328 g_type_add_interface_static (lame_type, GST_TYPE_TAG_SETTER,
329 &tag_setter_info);
330 }
332 GST_BOILERPLATE_FULL (GstLame, gst_lame, GstAudioEncoder,
333 GST_TYPE_AUDIO_ENCODER, gst_lame_add_interfaces);
335 static void
336 gst_lame_release_memory (GstLame * lame)
337 {
338 if (lame->lgf) {
339 lame_close (lame->lgf);
340 lame->lgf = NULL;
341 }
342 }
344 static void
345 gst_lame_finalize (GObject * obj)
346 {
347 gst_lame_release_memory (GST_LAME (obj));
349 G_OBJECT_CLASS (parent_class)->finalize (obj);
350 }
352 static void
353 gst_lame_base_init (gpointer g_class)
354 {
355 GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
357 gst_element_class_add_static_pad_template (element_class,
358 &gst_lame_src_template);
359 gst_element_class_add_static_pad_template (element_class,
360 &gst_lame_sink_template);
361 gst_element_class_set_details_simple (element_class, "L.A.M.E. mp3 encoder",
362 "Codec/Encoder/Audio",
363 "High-quality free MP3 encoder (deprecated)",
364 "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>");
365 }
367 static void
368 gst_lame_class_init (GstLameClass * klass)
369 {
370 GObjectClass *gobject_class;
371 GstAudioEncoderClass *base_class;
373 gobject_class = (GObjectClass *) klass;
374 base_class = (GstAudioEncoderClass *) klass;
376 gobject_class->set_property = gst_lame_set_property;
377 gobject_class->get_property = gst_lame_get_property;
378 gobject_class->finalize = gst_lame_finalize;
380 base_class->start = GST_DEBUG_FUNCPTR (gst_lame_start);
381 base_class->stop = GST_DEBUG_FUNCPTR (gst_lame_stop);
382 base_class->set_format = GST_DEBUG_FUNCPTR (gst_lame_set_format);
383 base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_lame_handle_frame);
384 base_class->flush = GST_DEBUG_FUNCPTR (gst_lame_flush);
386 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BITRATE,
387 g_param_spec_int ("bitrate", "Bitrate (kb/s)",
388 "Bitrate in kbit/sec (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
389 "112, 128, 160, 192, 224, 256 or 320)",
390 0, 320, gst_lame_default_settings.bitrate,
391 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
392 /* compression ratio set to 0.0 by default otherwise it overrides the bitrate setting */
393 g_object_class_install_property (G_OBJECT_CLASS (klass),
394 ARG_COMPRESSION_RATIO, g_param_spec_float ("compression-ratio",
395 "Compression Ratio",
396 "let lame choose bitrate to achieve selected compression ratio", 0.0,
397 200.0, gst_lame_default_settings.compression_ratio,
398 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
399 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
400 g_param_spec_enum ("quality", "Quality",
401 "Quality of algorithm used for encoding", GST_TYPE_LAME_QUALITY,
402 gst_lame_default_settings.quality,
403 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
404 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,
405 g_param_spec_enum ("mode", "Mode", "Encoding mode", GST_TYPE_LAME_MODE,
406 gst_lame_default_settings.mode,
407 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
408 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FORCE_MS,
409 g_param_spec_boolean ("force-ms", "Force ms",
410 "Force ms_stereo on all frames", gst_lame_default_settings.force_ms,
411 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
412 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FREE_FORMAT,
413 g_param_spec_boolean ("free-format", "Free format",
414 "Produce a free format bitstream",
415 gst_lame_default_settings.free_format,
416 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
417 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COPYRIGHT,
418 g_param_spec_boolean ("copyright", "Copyright", "Mark as copyright",
419 gst_lame_default_settings.copyright,
420 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
421 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ORIGINAL,
422 g_param_spec_boolean ("original", "Original", "Mark as original",
423 gst_lame_default_settings.original,
424 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
425 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_PROTECTION,
426 g_param_spec_boolean ("error-protection", "Error protection",
427 "Adds 16 bit checksum to every frame",
428 gst_lame_default_settings.error_protection,
429 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
430 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PADDING_TYPE,
431 g_param_spec_enum ("padding-type", "Padding type",
432 "Padding type " "(DEPRECATED: this setting has no effect)",
433 GST_TYPE_LAME_PADDING, FALSE,
434 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
435 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EXTENSION,
436 g_param_spec_boolean ("extension", "Extension", "Extension",
437 gst_lame_default_settings.extension,
438 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
439 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STRICT_ISO,
440 g_param_spec_boolean ("strict-iso", "Strict ISO",
441 "Comply as much as possible to ISO MPEG spec", TRUE,
442 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
443 g_object_class_install_property (G_OBJECT_CLASS (klass),
444 ARG_DISABLE_RESERVOIR, g_param_spec_boolean ("disable-reservoir",
445 "Disable reservoir", "Disable the bit reservoir", TRUE,
446 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
447 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR,
448 g_param_spec_enum ("vbr", "VBR", "Specify bitrate mode",
449 GST_TYPE_LAME_VBRMODE, gst_lame_default_settings.vbr,
450 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
451 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_QUALITY,
452 g_param_spec_enum ("vbr-quality", "VBR Quality", "VBR Quality",
453 GST_TYPE_LAME_QUALITY, gst_lame_default_settings.vbr_quality,
454 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
455 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MEAN_BITRATE,
456 g_param_spec_int ("vbr-mean-bitrate", "VBR mean bitrate",
457 "Specify mean VBR bitrate", 0, 320,
458 gst_lame_default_settings.vbr_mean_bitrate,
459 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
460 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MIN_BITRATE,
461 g_param_spec_int ("vbr-min-bitrate", "VBR min bitrate",
462 "Specify minimum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
463 "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
464 gst_lame_default_settings.vbr_min_bitrate,
465 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
466 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MAX_BITRATE,
467 g_param_spec_int ("vbr-max-bitrate", "VBR max bitrate",
468 "Specify maximum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
469 "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
470 gst_lame_default_settings.vbr_max_bitrate,
471 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
472 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_HARD_MIN,
473 g_param_spec_int ("vbr-hard-min", "VBR hard min",
474 "Specify whether min VBR bitrate is a hard limit. Normally, "
475 "it can be violated for silence", 0, 1,
476 gst_lame_default_settings.vbr_hard_min,
477 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
478 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_FREQ,
479 g_param_spec_int ("lowpass-freq", "Lowpass freq",
480 "frequency(kHz), lowpass filter cutoff above freq", 0, 50000,
481 gst_lame_default_settings.lowpass_freq,
482 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
483 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_WIDTH,
484 g_param_spec_int ("lowpass-width", "Lowpass width",
485 "frequency(kHz) - default 15% of lowpass freq", -1, G_MAXINT,
486 gst_lame_default_settings.lowpass_width,
487 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
488 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_FREQ,
489 g_param_spec_int ("highpass-freq", "Highpass freq",
490 "frequency(kHz), highpass filter cutoff below freq", 0, 50000,
491 gst_lame_default_settings.highpass_freq,
492 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
493 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_WIDTH,
494 g_param_spec_int ("highpass-width", "Highpass width",
495 "frequency(kHz) - default 15% of highpass freq", -1, G_MAXINT,
496 gst_lame_default_settings.highpass_width,
497 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
498 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_ONLY,
499 g_param_spec_boolean ("ath-only", "ATH only",
500 "Ignore GPSYCHO completely, use ATH only",
501 gst_lame_default_settings.ath_only,
502 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
503 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_SHORT,
504 g_param_spec_boolean ("ath-short", "ATH short",
505 "Ignore GPSYCHO for short blocks, use ATH only",
506 gst_lame_default_settings.ath_short,
507 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
508 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_ATH,
509 g_param_spec_boolean ("no-ath", "No ath",
510 "turns ATH down to a flat noise floor",
511 gst_lame_default_settings.no_ath,
512 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
513 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_LOWER,
514 g_param_spec_int ("ath-lower", "ATH lower", "lowers ATH by x dB",
515 G_MININT, G_MAXINT, gst_lame_default_settings.ath_lower,
516 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
517 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CWLIMIT,
518 g_param_spec_int ("cwlimit", "Cwlimit",
519 "Compute tonality up to freq (in kHz) default 8.8717 "
520 "(DEPRECATED: this setting has no effect)", 0, 50000, 0,
521 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
522 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ALLOW_DIFF_SHORT,
523 g_param_spec_boolean ("allow-diff-short", "Allow diff short",
524 "Allow diff short", gst_lame_default_settings.allow_diff_short,
525 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
526 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_SHORT_BLOCKS,
527 g_param_spec_boolean ("no-short-blocks", "No short blocks",
528 "Do not use short blocks", gst_lame_default_settings.no_short_blocks,
529 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
530 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EMPHASIS,
531 g_param_spec_boolean ("emphasis", "Emphasis", "Emphasis",
532 gst_lame_default_settings.emphasis,
533 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
534 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_XINGHEADER,
535 g_param_spec_boolean ("xingheader", "Output Xing Header",
536 "Output Xing Header (BROKEN, use xingmux instead)", FALSE,
537 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
538 #ifdef GSTLAME_PRESET
539 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PRESET,
540 g_param_spec_enum ("preset", "Lame Preset", "Lame Preset",
541 GST_TYPE_LAME_PRESET, gst_lame_default_settings.preset,
542 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
543 #endif
544 }
546 static gboolean
547 gst_lame_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
548 {
549 GstLame *lame;
550 gint out_samplerate;
551 gint version;
552 GstCaps *othercaps;
553 GstClockTime latency;
555 lame = GST_LAME (enc);
557 /* parameters already parsed for us */
558 lame->samplerate = GST_AUDIO_INFO_RATE (info);
559 lame->num_channels = GST_AUDIO_INFO_CHANNELS (info);
561 /* but we might be asked to reconfigure, so reset */
562 gst_lame_release_memory (lame);
564 GST_DEBUG_OBJECT (lame, "setting up lame");
565 if (!gst_lame_setup (lame))
566 goto setup_failed;
568 out_samplerate = lame_get_out_samplerate (lame->lgf);
569 if (out_samplerate == 0)
570 goto zero_output_rate;
571 if (out_samplerate != lame->samplerate) {
572 GST_WARNING_OBJECT (lame,
573 "output samplerate %d is different from incoming samplerate %d",
574 out_samplerate, lame->samplerate);
575 }
576 lame->out_samplerate = out_samplerate;
578 version = lame_get_version (lame->lgf);
579 if (version == 0)
580 version = 2;
581 else if (version == 1)
582 version = 1;
583 else if (version == 2)
584 version = 3;
586 othercaps =
587 gst_caps_new_simple ("audio/mpeg",
588 "mpegversion", G_TYPE_INT, 1,
589 "mpegaudioversion", G_TYPE_INT, version,
590 "layer", G_TYPE_INT, 3,
591 "channels", G_TYPE_INT, lame->mode == MONO ? 1 : lame->num_channels,
592 "rate", G_TYPE_INT, out_samplerate, NULL);
594 /* and use these caps */
595 gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (lame), othercaps);
596 gst_caps_unref (othercaps);
598 /* base class feedback:
599 * - we will handle buffers, just hand us all available
600 * - report latency */
601 latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
602 GST_SECOND, lame->samplerate);
603 gst_audio_encoder_set_latency (enc, latency, latency);
605 return TRUE;
607 zero_output_rate:
608 {
609 GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
610 ("LAME decided on a zero sample rate"));
611 return FALSE;
612 }
613 setup_failed:
614 {
615 GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS,
616 (_("Failed to configure LAME encoder. Check your encoding parameters.")), (NULL));
617 return FALSE;
618 }
619 }
621 static void
622 gst_lame_init (GstLame * lame, GstLameClass * klass)
623 {
624 GST_DEBUG_OBJECT (lame, "starting initialization");
626 /* Set default settings */
627 lame->bitrate = gst_lame_default_settings.bitrate;
628 lame->compression_ratio = gst_lame_default_settings.compression_ratio;
629 lame->quality = gst_lame_default_settings.quality;
630 lame->mode = gst_lame_default_settings.mode;
631 lame->requested_mode = lame->mode;
632 lame->force_ms = gst_lame_default_settings.force_ms;
633 lame->free_format = gst_lame_default_settings.free_format;
634 lame->copyright = gst_lame_default_settings.copyright;
635 lame->original = gst_lame_default_settings.original;
636 lame->error_protection = gst_lame_default_settings.error_protection;
637 lame->extension = gst_lame_default_settings.extension;
638 lame->strict_iso = gst_lame_default_settings.strict_iso;
639 lame->disable_reservoir = gst_lame_default_settings.disable_reservoir;
640 lame->vbr = gst_lame_default_settings.vbr;
641 lame->vbr_quality = gst_lame_default_settings.vbr_quality;
642 lame->vbr_mean_bitrate = gst_lame_default_settings.vbr_mean_bitrate;
643 lame->vbr_min_bitrate = gst_lame_default_settings.vbr_min_bitrate;
644 lame->vbr_max_bitrate = gst_lame_default_settings.vbr_max_bitrate;
645 lame->vbr_hard_min = gst_lame_default_settings.vbr_hard_min;
646 lame->lowpass_freq = gst_lame_default_settings.lowpass_freq;
647 lame->lowpass_width = gst_lame_default_settings.lowpass_width;
648 lame->highpass_freq = gst_lame_default_settings.highpass_freq;
649 lame->highpass_width = gst_lame_default_settings.highpass_width;
650 lame->ath_only = gst_lame_default_settings.ath_only;
651 lame->ath_short = gst_lame_default_settings.ath_short;
652 lame->no_ath = gst_lame_default_settings.no_ath;
653 lame->ath_lower = gst_lame_default_settings.ath_lower;
654 lame->allow_diff_short = gst_lame_default_settings.allow_diff_short;
655 lame->no_short_blocks = gst_lame_default_settings.no_short_blocks;
656 lame->emphasis = gst_lame_default_settings.emphasis;
657 lame->preset = gst_lame_default_settings.preset;
659 GST_DEBUG_OBJECT (lame, "done initializing");
660 }
662 static gboolean
663 gst_lame_start (GstAudioEncoder * enc)
664 {
665 GstLame *lame = GST_LAME (enc);
667 if (!lame->adapter)
668 lame->adapter = gst_adapter_new ();
669 gst_adapter_clear (lame->adapter);
671 GST_DEBUG_OBJECT (lame, "start");
672 return TRUE;
673 }
675 static gboolean
676 gst_lame_stop (GstAudioEncoder * enc)
677 {
678 GstLame *lame = GST_LAME (enc);
680 GST_DEBUG_OBJECT (lame, "stop");
682 if (lame->adapter) {
683 g_object_unref (lame->adapter);
684 lame->adapter = NULL;
685 }
687 gst_lame_release_memory (lame);
688 return TRUE;
689 }
692 /* <php-emulation-mode>three underscores for ___rate is really really really
693 * private as opposed to one underscore<php-emulation-mode> */
694 /* call this MACRO outside of the NULL state so that we have a higher chance
695 * of actually having a pipeline and bus to get the message through */
697 #define CHECK_AND_FIXUP_BITRATE(obj,param,rate,free_format) \
698 G_STMT_START { \
699 gint ___rate = rate; \
700 gint maxrate = 320; \
701 gint multiplier = 64; \
702 if (!free_format) { \
703 if (rate == 0) { \
704 ___rate = rate; \
705 } else if (rate <= 64) { \
706 maxrate = 64; multiplier = 8; \
707 if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate); \
708 } else if (rate <= 128) { \
709 maxrate = 128; multiplier = 16; \
710 if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate); \
711 } else if (rate <= 256) { \
712 maxrate = 256; multiplier = 32; \
713 if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate); \
714 } else if (rate <= 320) { \
715 maxrate = 320; multiplier = 64; \
716 if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate); \
717 } \
718 if (___rate != rate) { \
719 GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS, \
720 (_("The requested bitrate %d kbit/s for property '%s' " \
721 "is not allowed. " \
722 "The bitrate was changed to %d kbit/s."), rate, \
723 param, ___rate), \
724 ("A bitrate below %d should be a multiple of %d.", \
725 maxrate, multiplier)); \
726 rate = ___rate; \
727 } \
728 } \
729 } G_STMT_END
731 static void
732 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
733 GParamSpec * pspec)
734 {
735 GstLame *lame;
737 lame = GST_LAME (object);
739 switch (prop_id) {
740 case ARG_BITRATE:
741 lame->bitrate = g_value_get_int (value);
742 break;
743 case ARG_COMPRESSION_RATIO:
744 lame->compression_ratio = g_value_get_float (value);
745 break;
746 case ARG_QUALITY:
747 lame->quality = g_value_get_enum (value);
748 break;
749 case ARG_MODE:
750 lame->requested_mode = g_value_get_enum (value);
751 break;
752 case ARG_FORCE_MS:
753 lame->force_ms = g_value_get_boolean (value);
754 break;
755 case ARG_FREE_FORMAT:
756 lame->free_format = g_value_get_boolean (value);
757 break;
758 case ARG_COPYRIGHT:
759 lame->copyright = g_value_get_boolean (value);
760 break;
761 case ARG_ORIGINAL:
762 lame->original = g_value_get_boolean (value);
763 break;
764 case ARG_ERROR_PROTECTION:
765 lame->error_protection = g_value_get_boolean (value);
766 break;
767 case ARG_PADDING_TYPE:
768 break;
769 case ARG_EXTENSION:
770 lame->extension = g_value_get_boolean (value);
771 break;
772 case ARG_STRICT_ISO:
773 lame->strict_iso = g_value_get_boolean (value);
774 break;
775 case ARG_DISABLE_RESERVOIR:
776 lame->disable_reservoir = g_value_get_boolean (value);
777 break;
778 case ARG_VBR:
779 lame->vbr = g_value_get_enum (value);
780 break;
781 case ARG_VBR_QUALITY:
782 lame->vbr_quality = g_value_get_enum (value);
783 break;
784 case ARG_VBR_MEAN_BITRATE:
785 lame->vbr_mean_bitrate = g_value_get_int (value);
786 break;
787 case ARG_VBR_MIN_BITRATE:
788 lame->vbr_min_bitrate = g_value_get_int (value);
789 break;
790 case ARG_VBR_MAX_BITRATE:
791 lame->vbr_max_bitrate = g_value_get_int (value);
792 break;
793 case ARG_VBR_HARD_MIN:
794 lame->vbr_hard_min = g_value_get_int (value);
795 break;
796 case ARG_LOWPASS_FREQ:
797 lame->lowpass_freq = g_value_get_int (value);
798 break;
799 case ARG_LOWPASS_WIDTH:
800 lame->lowpass_width = g_value_get_int (value);
801 break;
802 case ARG_HIGHPASS_FREQ:
803 lame->highpass_freq = g_value_get_int (value);
804 break;
805 case ARG_HIGHPASS_WIDTH:
806 lame->highpass_width = g_value_get_int (value);
807 break;
808 case ARG_ATH_ONLY:
809 lame->ath_only = g_value_get_boolean (value);
810 break;
811 case ARG_ATH_SHORT:
812 lame->ath_short = g_value_get_boolean (value);
813 break;
814 case ARG_NO_ATH:
815 lame->no_ath = g_value_get_boolean (value);
816 break;
817 case ARG_ATH_LOWER:
818 lame->ath_lower = g_value_get_int (value);
819 break;
820 case ARG_CWLIMIT:
821 break;
822 case ARG_ALLOW_DIFF_SHORT:
823 lame->allow_diff_short = g_value_get_boolean (value);
824 break;
825 case ARG_NO_SHORT_BLOCKS:
826 lame->no_short_blocks = g_value_get_boolean (value);
827 break;
828 case ARG_EMPHASIS:
829 lame->emphasis = g_value_get_boolean (value);
830 break;
831 case ARG_XINGHEADER:
832 break;
833 #ifdef GSTLAME_PRESET
834 case ARG_PRESET:
835 lame->preset = g_value_get_enum (value);
836 break;
837 #endif
838 default:
839 break;
840 }
842 }
844 static void
845 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
846 GParamSpec * pspec)
847 {
848 GstLame *lame;
850 lame = GST_LAME (object);
852 switch (prop_id) {
853 case ARG_BITRATE:
854 g_value_set_int (value, lame->bitrate);
855 break;
856 case ARG_COMPRESSION_RATIO:
857 g_value_set_float (value, lame->compression_ratio);
858 break;
859 case ARG_QUALITY:
860 g_value_set_enum (value, lame->quality);
861 break;
862 case ARG_MODE:
863 g_value_set_enum (value, lame->requested_mode);
864 break;
865 case ARG_FORCE_MS:
866 g_value_set_boolean (value, lame->force_ms);
867 break;
868 case ARG_FREE_FORMAT:
869 g_value_set_boolean (value, lame->free_format);
870 break;
871 case ARG_COPYRIGHT:
872 g_value_set_boolean (value, lame->copyright);
873 break;
874 case ARG_ORIGINAL:
875 g_value_set_boolean (value, lame->original);
876 break;
877 case ARG_ERROR_PROTECTION:
878 g_value_set_boolean (value, lame->error_protection);
879 break;
880 case ARG_PADDING_TYPE:
881 break;
882 case ARG_EXTENSION:
883 g_value_set_boolean (value, lame->extension);
884 break;
885 case ARG_STRICT_ISO:
886 g_value_set_boolean (value, lame->strict_iso);
887 break;
888 case ARG_DISABLE_RESERVOIR:
889 g_value_set_boolean (value, lame->disable_reservoir);
890 break;
891 case ARG_VBR:
892 g_value_set_enum (value, lame->vbr);
893 break;
894 case ARG_VBR_QUALITY:
895 g_value_set_enum (value, lame->vbr_quality);
896 break;
897 case ARG_VBR_MEAN_BITRATE:
898 g_value_set_int (value, lame->vbr_mean_bitrate);
899 break;
900 case ARG_VBR_MIN_BITRATE:
901 g_value_set_int (value, lame->vbr_min_bitrate);
902 break;
903 case ARG_VBR_MAX_BITRATE:
904 g_value_set_int (value, lame->vbr_max_bitrate);
905 break;
906 case ARG_VBR_HARD_MIN:
907 g_value_set_int (value, lame->vbr_hard_min);
908 break;
909 case ARG_LOWPASS_FREQ:
910 g_value_set_int (value, lame->lowpass_freq);
911 break;
912 case ARG_LOWPASS_WIDTH:
913 g_value_set_int (value, lame->lowpass_width);
914 break;
915 case ARG_HIGHPASS_FREQ:
916 g_value_set_int (value, lame->highpass_freq);
917 break;
918 case ARG_HIGHPASS_WIDTH:
919 g_value_set_int (value, lame->highpass_width);
920 break;
921 case ARG_ATH_ONLY:
922 g_value_set_boolean (value, lame->ath_only);
923 break;
924 case ARG_ATH_SHORT:
925 g_value_set_boolean (value, lame->ath_short);
926 break;
927 case ARG_NO_ATH:
928 g_value_set_boolean (value, lame->no_ath);
929 break;
930 case ARG_ATH_LOWER:
931 g_value_set_int (value, lame->ath_lower);
932 break;
933 case ARG_CWLIMIT:
934 break;
935 case ARG_ALLOW_DIFF_SHORT:
936 g_value_set_boolean (value, lame->allow_diff_short);
937 break;
938 case ARG_NO_SHORT_BLOCKS:
939 g_value_set_boolean (value, lame->no_short_blocks);
940 break;
941 case ARG_EMPHASIS:
942 g_value_set_boolean (value, lame->emphasis);
943 break;
944 case ARG_XINGHEADER:
945 break;
946 #ifdef GSTLAME_PRESET
947 case ARG_PRESET:
948 g_value_set_enum (value, lame->preset);
949 break;
950 #endif
951 default:
952 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
953 break;
954 }
955 }
957 /* **** credits go to mpegaudioparse **** */
959 static const guint mp3types_bitrates[2][3][16] = {
960 {
961 {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
962 {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
963 {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
964 },
965 {
966 {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
967 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
968 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
969 },
970 };
972 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
973 {22050, 24000, 16000},
974 {11025, 12000, 8000}
975 };
977 static inline guint
978 mp3_type_frame_length_from_header (GstLame * lame, guint32 header,
979 guint * put_version, guint * put_layer, guint * put_channels,
980 guint * put_bitrate, guint * put_samplerate, guint * put_mode,
981 guint * put_crc)
982 {
983 guint length;
984 gulong mode, samplerate, bitrate, layer, channels, padding, crc;
985 gulong version;
986 gint lsf, mpg25;
988 if (header & (1 << 20)) {
989 lsf = (header & (1 << 19)) ? 0 : 1;
990 mpg25 = 0;
991 } else {
992 lsf = 1;
993 mpg25 = 1;
994 }
996 version = 1 + lsf + mpg25;
998 layer = 4 - ((header >> 17) & 0x3);
1000 crc = (header >> 16) & 0x1;
1002 bitrate = (header >> 12) & 0xF;
1003 bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
1004 /* The caller has ensured we have a valid header, so bitrate can't be
1005 zero here. */
1006 g_assert (bitrate != 0);
1008 samplerate = (header >> 10) & 0x3;
1009 samplerate = mp3types_freqs[lsf + mpg25][samplerate];
1011 padding = (header >> 9) & 0x1;
1013 mode = (header >> 6) & 0x3;
1014 channels = (mode == 3) ? 1 : 2;
1016 switch (layer) {
1017 case 1:
1018 length = 4 * ((bitrate * 12) / samplerate + padding);
1019 break;
1020 case 2:
1021 length = (bitrate * 144) / samplerate + padding;
1022 break;
1023 default:
1024 case 3:
1025 length = (bitrate * 144) / (samplerate << lsf) + padding;
1026 break;
1027 }
1029 GST_DEBUG_OBJECT (lame, "Calculated mp3 frame length of %u bytes", length);
1030 GST_DEBUG_OBJECT (lame, "samplerate = %lu, bitrate = %lu, version = %lu, "
1031 "layer = %lu, channels = %lu", samplerate, bitrate, version,
1032 layer, channels);
1034 if (put_version)
1035 *put_version = version;
1036 if (put_layer)
1037 *put_layer = layer;
1038 if (put_channels)
1039 *put_channels = channels;
1040 if (put_bitrate)
1041 *put_bitrate = bitrate;
1042 if (put_samplerate)
1043 *put_samplerate = samplerate;
1044 if (put_mode)
1045 *put_mode = mode;
1046 if (put_crc)
1047 *put_crc = crc;
1049 return length;
1050 }
1052 static gboolean
1053 mp3_sync_check (GstLame * lame, unsigned long head)
1054 {
1055 GST_DEBUG_OBJECT (lame, "checking mp3 header 0x%08lx", head);
1056 /* if it's not a valid sync */
1057 if ((head & 0xffe00000) != 0xffe00000) {
1058 GST_WARNING_OBJECT (lame, "invalid sync");
1059 return FALSE;
1060 }
1061 /* if it's an invalid MPEG version */
1062 if (((head >> 19) & 3) == 0x1) {
1063 GST_WARNING_OBJECT (lame, "invalid MPEG version: 0x%lx", (head >> 19) & 3);
1064 return FALSE;
1065 }
1066 /* if it's an invalid layer */
1067 if (!((head >> 17) & 3)) {
1068 GST_WARNING_OBJECT (lame, "invalid layer: 0x%lx", (head >> 17) & 3);
1069 return FALSE;
1070 }
1071 /* if it's an invalid bitrate */
1072 if (((head >> 12) & 0xf) == 0x0) {
1073 GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx."
1074 "Free format files are not supported yet", (head >> 12) & 0xf);
1075 return FALSE;
1076 }
1077 if (((head >> 12) & 0xf) == 0xf) {
1078 GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx", (head >> 12) & 0xf);
1079 return FALSE;
1080 }
1081 /* if it's an invalid samplerate */
1082 if (((head >> 10) & 0x3) == 0x3) {
1083 GST_WARNING_OBJECT (lame, "invalid samplerate: 0x%lx", (head >> 10) & 0x3);
1084 return FALSE;
1085 }
1087 if ((head & 0x3) == 0x2) {
1088 /* Ignore this as there are some files with emphasis 0x2 that can
1089 * be played fine. See BGO #537235 */
1090 GST_WARNING_OBJECT (lame, "invalid emphasis: 0x%lx", head & 0x3);
1091 }
1093 return TRUE;
1094 }
1096 /* **** end mpegaudioparse **** */
1098 static GstFlowReturn
1099 gst_lame_finish_frames (GstLame * lame)
1100 {
1101 gint av;
1102 guint header;
1103 GstFlowReturn result = GST_FLOW_OK;
1105 /* limited parsing, we don't expect to lose sync here */
1106 while ((result == GST_FLOW_OK) &&
1107 ((av = gst_adapter_available (lame->adapter)) > 4)) {
1108 guint rate, version, layer, size;
1109 GstBuffer *mp3_buf;
1110 const guint8 *data;
1112 data = gst_adapter_peek (lame->adapter, 4);
1113 header = GST_READ_UINT32_BE (data);
1114 if (!mp3_sync_check (lame, header))
1115 goto invalid_header;
1117 size = mp3_type_frame_length_from_header (lame, header, &version, &layer,
1118 NULL, NULL, &rate, NULL, NULL);
1120 if (G_UNLIKELY (layer != 3 || rate != lame->out_samplerate)) {
1121 GST_DEBUG_OBJECT (lame,
1122 "unexpected mp3 header with (rate, layer): (%u, %u)",
1123 rate, version, layer);
1124 goto invalid_header;
1125 }
1127 if (size > av) {
1128 /* pretty likely to occur when lame is holding back on us */
1129 GST_LOG_OBJECT (lame, "frame size %u (> %d)", size, av);
1130 break;
1131 }
1133 /* should be ok now */
1134 mp3_buf = gst_adapter_take_buffer (lame->adapter, size);
1135 /* number of samples for MPEG-1, layer 3 */
1136 result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame),
1137 mp3_buf, version == 1 ? 1152 : 576);
1138 }
1140 exit:
1141 return result;
1143 /* ERRORS */
1144 invalid_header:
1145 {
1146 GST_ELEMENT_ERROR (lame, STREAM, ENCODE,
1147 ("invalid lame mp3 sync header %08X", header), (NULL));
1148 result = GST_FLOW_ERROR;
1149 goto exit;
1150 }
1151 }
1153 static GstFlowReturn
1154 gst_lame_flush_full (GstLame * lame, gboolean push)
1155 {
1156 GstBuffer *buf;
1157 gint size;
1158 GstFlowReturn result = GST_FLOW_OK;
1159 gint av;
1161 if (!lame->lgf)
1162 return GST_FLOW_OK;
1164 buf = gst_buffer_new_and_alloc (7200);
1165 size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
1167 if (size > 0) {
1168 GST_BUFFER_SIZE (buf) = size;
1169 GST_DEBUG_OBJECT (lame, "collecting final %d bytes", size);
1170 gst_adapter_push (lame->adapter, buf);
1171 } else {
1172 GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
1173 gst_buffer_unref (buf);
1174 result = GST_FLOW_OK;
1175 }
1177 if (push) {
1178 result = gst_lame_finish_frames (lame);
1179 } else {
1180 /* never mind */
1181 gst_adapter_clear (lame->adapter);
1182 }
1184 /* either way, we expect nothing left */
1185 if ((av = gst_adapter_available (lame->adapter))) {
1186 /* should this be more fatal ?? */
1187 GST_WARNING_OBJECT (lame, "unparsed %d bytes left after flushing", av);
1188 /* clean up anyway */
1189 gst_adapter_clear (lame->adapter);
1190 }
1192 return result;
1193 }
1195 static void
1196 gst_lame_flush (GstAudioEncoder * enc)
1197 {
1198 gst_lame_flush_full (GST_LAME (enc), FALSE);
1199 }
1201 static GstFlowReturn
1202 gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
1203 {
1204 GstLame *lame;
1205 guchar *mp3_data;
1206 GstBuffer *mp3_buf;
1207 gint mp3_buffer_size, mp3_size;
1208 GstFlowReturn result;
1209 gint num_samples;
1210 guint8 *data;
1211 guint size;
1213 lame = GST_LAME (enc);
1215 /* squeeze remaining and push */
1216 if (G_UNLIKELY (buf == NULL))
1217 return gst_lame_flush_full (lame, TRUE);
1219 data = GST_BUFFER_DATA (buf);
1220 size = GST_BUFFER_SIZE (buf);
1222 num_samples = size / 2;
1224 /* allocate space for output */
1225 mp3_buffer_size = 1.25 * num_samples + 7200;
1226 mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
1227 mp3_data = GST_BUFFER_DATA (mp3_buf);
1229 /* lame seems to be too stupid to get mono interleaved going */
1230 if (lame->num_channels == 1) {
1231 mp3_size = lame_encode_buffer (lame->lgf,
1232 (short int *) data,
1233 (short int *) data, num_samples, mp3_data, mp3_buffer_size);
1234 } else {
1235 mp3_size = lame_encode_buffer_interleaved (lame->lgf,
1236 (short int *) data,
1237 num_samples / lame->num_channels, mp3_data, mp3_buffer_size);
1238 }
1240 GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
1241 size, mp3_size);
1243 if (mp3_size < 0) {
1244 g_warning ("error %d", mp3_size);
1245 }
1247 if (G_LIKELY (mp3_size > 0)) {
1248 GST_BUFFER_SIZE (mp3_buf) = mp3_size;
1249 /* unfortunately lame does not provide frame delineated output,
1250 * so collect output and parse into frames ... */
1251 gst_adapter_push (lame->adapter, mp3_buf);
1252 result = gst_lame_finish_frames (lame);
1253 } else {
1254 if (mp3_size < 0) {
1255 /* eat error ? */
1256 g_warning ("error %d", mp3_size);
1257 }
1258 result = GST_FLOW_OK;
1259 gst_buffer_unref (mp3_buf);
1260 }
1262 return result;
1263 }
1265 /* set up the encoder state */
1266 static gboolean
1267 gst_lame_setup (GstLame * lame)
1268 {
1270 #define CHECK_ERROR(command) G_STMT_START {\
1271 if ((command) < 0) { \
1272 GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1273 return FALSE; \
1274 } \
1275 }G_STMT_END
1277 int retval;
1278 GstCaps *allowed_caps;
1280 GST_DEBUG_OBJECT (lame, "starting setup");
1282 /* check if we're already setup; if we are, we might want to check
1283 * if this initialization is compatible with the previous one */
1284 /* FIXME: do this */
1285 if (lame->setup) {
1286 GST_WARNING_OBJECT (lame, "already setup");
1287 lame->setup = FALSE;
1288 }
1290 lame->lgf = lame_init ();
1292 if (lame->lgf == NULL)
1293 return FALSE;
1295 /* copy the parameters over */
1296 lame_set_in_samplerate (lame->lgf, lame->samplerate);
1298 /* let lame choose default samplerate unless outgoing sample rate is fixed */
1299 allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
1301 if (allowed_caps != NULL) {
1302 GstStructure *structure;
1303 gint samplerate;
1305 structure = gst_caps_get_structure (allowed_caps, 0);
1307 if (gst_structure_get_int (structure, "rate", &samplerate)) {
1308 GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps",
1309 samplerate);
1310 lame_set_out_samplerate (lame->lgf, samplerate);
1311 } else {
1312 GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate");
1313 lame_set_out_samplerate (lame->lgf, 0);
1314 }
1315 gst_caps_unref (allowed_caps);
1316 allowed_caps = NULL;
1317 } else {
1318 GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate");
1319 lame_set_out_samplerate (lame->lgf, 0);
1320 }
1322 /* force mono encoding if we only have one channel */
1323 if (lame->num_channels == 1)
1324 lame->mode = 3;
1325 else
1326 lame->mode = lame->requested_mode;
1328 CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1329 CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate, lame->free_format);
1330 CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1331 CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1332 CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1333 CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1334 CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1335 CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1336 CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1337 CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1338 CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1339 CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1340 CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1341 CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1342 CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1343 CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1344 CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1345 lame->vbr_mean_bitrate));
1346 CHECK_AND_FIXUP_BITRATE (lame, "vbr-min-bitrate", lame->vbr_min_bitrate,
1347 lame->free_format);
1348 CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1349 lame->vbr_min_bitrate));
1350 CHECK_AND_FIXUP_BITRATE (lame, "vbr-max-bitrate", lame->vbr_max_bitrate,
1351 lame->free_format);
1352 CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1353 lame->vbr_max_bitrate));
1354 CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1355 CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1356 CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1357 CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1358 CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1359 CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1360 CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1361 CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1362 CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1363 CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1364 CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1365 CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1366 CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
1367 #ifdef GSTLAME_PRESET
1368 if (lame->preset > 0) {
1369 CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1370 }
1371 #endif
1373 /* initialize the lame encoder */
1374 if ((retval = lame_init_params (lame->lgf)) >= 0) {
1375 lame->setup = TRUE;
1376 /* FIXME: it would be nice to print out the mode here */
1377 GST_INFO ("lame encoder setup (%d kbit/s, %d Hz, %d channels)",
1378 lame->bitrate, lame->samplerate, lame->num_channels);
1379 } else {
1380 GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1381 }
1383 GST_DEBUG_OBJECT (lame, "done with setup");
1385 return lame->setup;
1386 #undef CHECK_ERROR
1387 }
1389 static gboolean
1390 gst_lame_get_default_settings (void)
1391 {
1392 lame_global_flags *lgf = NULL;
1394 lgf = lame_init ();
1395 if (lgf == NULL) {
1396 GST_ERROR ("Error initializing LAME");
1397 return FALSE;
1398 }
1400 if (lame_init_params (lgf) < 0) {
1401 GST_ERROR ("Error getting default settings");
1402 return FALSE;
1403 }
1405 gst_lame_default_settings.bitrate = lame_get_brate (lgf);
1406 gst_lame_default_settings.compression_ratio = 0.0; /* lame_get_compression_ratio (lgf); */
1407 gst_lame_default_settings.quality = lame_get_quality (lgf);
1408 gst_lame_default_settings.mode = lame_get_mode (lgf);
1409 gst_lame_default_settings.force_ms = lame_get_force_ms (lgf);
1410 gst_lame_default_settings.free_format = lame_get_free_format (lgf);
1411 gst_lame_default_settings.copyright = lame_get_copyright (lgf);
1412 gst_lame_default_settings.original = lame_get_original (lgf);
1413 gst_lame_default_settings.error_protection = lame_get_error_protection (lgf);
1414 gst_lame_default_settings.extension = lame_get_extension (lgf);
1415 gst_lame_default_settings.strict_iso = lame_get_strict_ISO (lgf);
1416 gst_lame_default_settings.disable_reservoir =
1417 lame_get_disable_reservoir (lgf);
1418 gst_lame_default_settings.vbr = lame_get_VBR (lgf);
1419 gst_lame_default_settings.vbr_quality = lame_get_VBR_q (lgf);
1420 gst_lame_default_settings.vbr_mean_bitrate =
1421 lame_get_VBR_mean_bitrate_kbps (lgf);
1422 gst_lame_default_settings.vbr_min_bitrate =
1423 lame_get_VBR_min_bitrate_kbps (lgf);
1424 gst_lame_default_settings.vbr_max_bitrate =
1425 lame_get_VBR_max_bitrate_kbps (lgf);
1426 gst_lame_default_settings.vbr_hard_min = lame_get_VBR_hard_min (lgf);
1427 gst_lame_default_settings.lowpass_freq = lame_get_lowpassfreq (lgf);
1428 gst_lame_default_settings.lowpass_width = lame_get_lowpasswidth (lgf);
1429 gst_lame_default_settings.highpass_freq = lame_get_highpassfreq (lgf);
1430 gst_lame_default_settings.highpass_width = lame_get_highpasswidth (lgf);
1431 gst_lame_default_settings.ath_only = lame_get_ATHonly (lgf);
1432 gst_lame_default_settings.ath_short = lame_get_ATHshort (lgf);
1433 gst_lame_default_settings.no_ath = lame_get_noATH (lgf);
1434 gst_lame_default_settings.ath_type = lame_get_ATHtype (lgf);
1435 gst_lame_default_settings.ath_lower = lame_get_ATHlower (lgf);
1436 gst_lame_default_settings.allow_diff_short = lame_get_allow_diff_short (lgf);
1437 gst_lame_default_settings.no_short_blocks = lame_get_no_short_blocks (lgf);
1438 gst_lame_default_settings.emphasis = lame_get_emphasis (lgf);
1439 gst_lame_default_settings.preset = 0;
1441 lame_close (lgf);
1443 return TRUE;
1444 }
1446 gboolean
1447 gst_lame_register (GstPlugin * plugin)
1448 {
1449 GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1451 if (!gst_lame_get_default_settings ())
1452 return FALSE;
1454 if (!gst_element_register (plugin, "lame", GST_RANK_MARGINAL, GST_TYPE_LAME))
1455 return FALSE;
1457 return TRUE;
1458 }