f36a0b26e5b7b15f3bdb2b932d9ba24afa301782
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 }
577 version = lame_get_version (lame->lgf);
578 if (version == 0)
579 version = 2;
580 else if (version == 1)
581 version = 1;
582 else if (version == 2)
583 version = 3;
585 othercaps =
586 gst_caps_new_simple ("audio/mpeg",
587 "mpegversion", G_TYPE_INT, 1,
588 "mpegaudioversion", G_TYPE_INT, version,
589 "layer", G_TYPE_INT, 3,
590 "channels", G_TYPE_INT, lame->mode == MONO ? 1 : lame->num_channels,
591 "rate", G_TYPE_INT, out_samplerate, NULL);
593 /* and use these caps */
594 gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (lame), othercaps);
595 gst_caps_unref (othercaps);
597 /* base class feedback:
598 * - we will handle buffers, just hand us all available
599 * - report latency */
600 latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
601 GST_SECOND, lame->samplerate);
602 gst_audio_encoder_set_latency (enc, latency, latency);
604 return TRUE;
606 zero_output_rate:
607 {
608 GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
609 ("LAME decided on a zero sample rate"));
610 return FALSE;
611 }
612 setup_failed:
613 {
614 GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS,
615 (_("Failed to configure LAME encoder. Check your encoding parameters.")), (NULL));
616 return FALSE;
617 }
618 }
620 static void
621 gst_lame_init (GstLame * lame, GstLameClass * klass)
622 {
623 GST_DEBUG_OBJECT (lame, "starting initialization");
625 /* Set default settings */
626 lame->bitrate = gst_lame_default_settings.bitrate;
627 lame->compression_ratio = gst_lame_default_settings.compression_ratio;
628 lame->quality = gst_lame_default_settings.quality;
629 lame->mode = gst_lame_default_settings.mode;
630 lame->requested_mode = lame->mode;
631 lame->force_ms = gst_lame_default_settings.force_ms;
632 lame->free_format = gst_lame_default_settings.free_format;
633 lame->copyright = gst_lame_default_settings.copyright;
634 lame->original = gst_lame_default_settings.original;
635 lame->error_protection = gst_lame_default_settings.error_protection;
636 lame->extension = gst_lame_default_settings.extension;
637 lame->strict_iso = gst_lame_default_settings.strict_iso;
638 lame->disable_reservoir = gst_lame_default_settings.disable_reservoir;
639 lame->vbr = gst_lame_default_settings.vbr;
640 lame->vbr_quality = gst_lame_default_settings.vbr_quality;
641 lame->vbr_mean_bitrate = gst_lame_default_settings.vbr_mean_bitrate;
642 lame->vbr_min_bitrate = gst_lame_default_settings.vbr_min_bitrate;
643 lame->vbr_max_bitrate = gst_lame_default_settings.vbr_max_bitrate;
644 lame->vbr_hard_min = gst_lame_default_settings.vbr_hard_min;
645 lame->lowpass_freq = gst_lame_default_settings.lowpass_freq;
646 lame->lowpass_width = gst_lame_default_settings.lowpass_width;
647 lame->highpass_freq = gst_lame_default_settings.highpass_freq;
648 lame->highpass_width = gst_lame_default_settings.highpass_width;
649 lame->ath_only = gst_lame_default_settings.ath_only;
650 lame->ath_short = gst_lame_default_settings.ath_short;
651 lame->no_ath = gst_lame_default_settings.no_ath;
652 lame->ath_lower = gst_lame_default_settings.ath_lower;
653 lame->allow_diff_short = gst_lame_default_settings.allow_diff_short;
654 lame->no_short_blocks = gst_lame_default_settings.no_short_blocks;
655 lame->emphasis = gst_lame_default_settings.emphasis;
656 lame->preset = gst_lame_default_settings.preset;
658 GST_DEBUG_OBJECT (lame, "done initializing");
659 }
661 static gboolean
662 gst_lame_start (GstAudioEncoder * enc)
663 {
664 GstLame *lame = GST_LAME (enc);
666 GST_DEBUG_OBJECT (lame, "start");
667 return TRUE;
668 }
670 static gboolean
671 gst_lame_stop (GstAudioEncoder * enc)
672 {
673 GstLame *lame = GST_LAME (enc);
675 GST_DEBUG_OBJECT (lame, "stop");
677 gst_lame_release_memory (lame);
678 return TRUE;
679 }
682 /* <php-emulation-mode>three underscores for ___rate is really really really
683 * private as opposed to one underscore<php-emulation-mode> */
684 /* call this MACRO outside of the NULL state so that we have a higher chance
685 * of actually having a pipeline and bus to get the message through */
687 #define CHECK_AND_FIXUP_BITRATE(obj,param,rate,free_format) \
688 G_STMT_START { \
689 gint ___rate = rate; \
690 gint maxrate = 320; \
691 gint multiplier = 64; \
692 if (!free_format) { \
693 if (rate == 0) { \
694 ___rate = rate; \
695 } else if (rate <= 64) { \
696 maxrate = 64; multiplier = 8; \
697 if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate); \
698 } else if (rate <= 128) { \
699 maxrate = 128; multiplier = 16; \
700 if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate); \
701 } else if (rate <= 256) { \
702 maxrate = 256; multiplier = 32; \
703 if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate); \
704 } else if (rate <= 320) { \
705 maxrate = 320; multiplier = 64; \
706 if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate); \
707 } \
708 if (___rate != rate) { \
709 GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS, \
710 (_("The requested bitrate %d kbit/s for property '%s' " \
711 "is not allowed. " \
712 "The bitrate was changed to %d kbit/s."), rate, \
713 param, ___rate), \
714 ("A bitrate below %d should be a multiple of %d.", \
715 maxrate, multiplier)); \
716 rate = ___rate; \
717 } \
718 } \
719 } G_STMT_END
721 static void
722 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
723 GParamSpec * pspec)
724 {
725 GstLame *lame;
727 lame = GST_LAME (object);
729 switch (prop_id) {
730 case ARG_BITRATE:
731 lame->bitrate = g_value_get_int (value);
732 break;
733 case ARG_COMPRESSION_RATIO:
734 lame->compression_ratio = g_value_get_float (value);
735 break;
736 case ARG_QUALITY:
737 lame->quality = g_value_get_enum (value);
738 break;
739 case ARG_MODE:
740 lame->requested_mode = g_value_get_enum (value);
741 break;
742 case ARG_FORCE_MS:
743 lame->force_ms = g_value_get_boolean (value);
744 break;
745 case ARG_FREE_FORMAT:
746 lame->free_format = g_value_get_boolean (value);
747 break;
748 case ARG_COPYRIGHT:
749 lame->copyright = g_value_get_boolean (value);
750 break;
751 case ARG_ORIGINAL:
752 lame->original = g_value_get_boolean (value);
753 break;
754 case ARG_ERROR_PROTECTION:
755 lame->error_protection = g_value_get_boolean (value);
756 break;
757 case ARG_PADDING_TYPE:
758 break;
759 case ARG_EXTENSION:
760 lame->extension = g_value_get_boolean (value);
761 break;
762 case ARG_STRICT_ISO:
763 lame->strict_iso = g_value_get_boolean (value);
764 break;
765 case ARG_DISABLE_RESERVOIR:
766 lame->disable_reservoir = g_value_get_boolean (value);
767 break;
768 case ARG_VBR:
769 lame->vbr = g_value_get_enum (value);
770 break;
771 case ARG_VBR_QUALITY:
772 lame->vbr_quality = g_value_get_enum (value);
773 break;
774 case ARG_VBR_MEAN_BITRATE:
775 lame->vbr_mean_bitrate = g_value_get_int (value);
776 break;
777 case ARG_VBR_MIN_BITRATE:
778 lame->vbr_min_bitrate = g_value_get_int (value);
779 break;
780 case ARG_VBR_MAX_BITRATE:
781 lame->vbr_max_bitrate = g_value_get_int (value);
782 break;
783 case ARG_VBR_HARD_MIN:
784 lame->vbr_hard_min = g_value_get_int (value);
785 break;
786 case ARG_LOWPASS_FREQ:
787 lame->lowpass_freq = g_value_get_int (value);
788 break;
789 case ARG_LOWPASS_WIDTH:
790 lame->lowpass_width = g_value_get_int (value);
791 break;
792 case ARG_HIGHPASS_FREQ:
793 lame->highpass_freq = g_value_get_int (value);
794 break;
795 case ARG_HIGHPASS_WIDTH:
796 lame->highpass_width = g_value_get_int (value);
797 break;
798 case ARG_ATH_ONLY:
799 lame->ath_only = g_value_get_boolean (value);
800 break;
801 case ARG_ATH_SHORT:
802 lame->ath_short = g_value_get_boolean (value);
803 break;
804 case ARG_NO_ATH:
805 lame->no_ath = g_value_get_boolean (value);
806 break;
807 case ARG_ATH_LOWER:
808 lame->ath_lower = g_value_get_int (value);
809 break;
810 case ARG_CWLIMIT:
811 break;
812 case ARG_ALLOW_DIFF_SHORT:
813 lame->allow_diff_short = g_value_get_boolean (value);
814 break;
815 case ARG_NO_SHORT_BLOCKS:
816 lame->no_short_blocks = g_value_get_boolean (value);
817 break;
818 case ARG_EMPHASIS:
819 lame->emphasis = g_value_get_boolean (value);
820 break;
821 case ARG_XINGHEADER:
822 break;
823 #ifdef GSTLAME_PRESET
824 case ARG_PRESET:
825 lame->preset = g_value_get_enum (value);
826 break;
827 #endif
828 default:
829 break;
830 }
832 }
834 static void
835 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
836 GParamSpec * pspec)
837 {
838 GstLame *lame;
840 lame = GST_LAME (object);
842 switch (prop_id) {
843 case ARG_BITRATE:
844 g_value_set_int (value, lame->bitrate);
845 break;
846 case ARG_COMPRESSION_RATIO:
847 g_value_set_float (value, lame->compression_ratio);
848 break;
849 case ARG_QUALITY:
850 g_value_set_enum (value, lame->quality);
851 break;
852 case ARG_MODE:
853 g_value_set_enum (value, lame->requested_mode);
854 break;
855 case ARG_FORCE_MS:
856 g_value_set_boolean (value, lame->force_ms);
857 break;
858 case ARG_FREE_FORMAT:
859 g_value_set_boolean (value, lame->free_format);
860 break;
861 case ARG_COPYRIGHT:
862 g_value_set_boolean (value, lame->copyright);
863 break;
864 case ARG_ORIGINAL:
865 g_value_set_boolean (value, lame->original);
866 break;
867 case ARG_ERROR_PROTECTION:
868 g_value_set_boolean (value, lame->error_protection);
869 break;
870 case ARG_PADDING_TYPE:
871 break;
872 case ARG_EXTENSION:
873 g_value_set_boolean (value, lame->extension);
874 break;
875 case ARG_STRICT_ISO:
876 g_value_set_boolean (value, lame->strict_iso);
877 break;
878 case ARG_DISABLE_RESERVOIR:
879 g_value_set_boolean (value, lame->disable_reservoir);
880 break;
881 case ARG_VBR:
882 g_value_set_enum (value, lame->vbr);
883 break;
884 case ARG_VBR_QUALITY:
885 g_value_set_enum (value, lame->vbr_quality);
886 break;
887 case ARG_VBR_MEAN_BITRATE:
888 g_value_set_int (value, lame->vbr_mean_bitrate);
889 break;
890 case ARG_VBR_MIN_BITRATE:
891 g_value_set_int (value, lame->vbr_min_bitrate);
892 break;
893 case ARG_VBR_MAX_BITRATE:
894 g_value_set_int (value, lame->vbr_max_bitrate);
895 break;
896 case ARG_VBR_HARD_MIN:
897 g_value_set_int (value, lame->vbr_hard_min);
898 break;
899 case ARG_LOWPASS_FREQ:
900 g_value_set_int (value, lame->lowpass_freq);
901 break;
902 case ARG_LOWPASS_WIDTH:
903 g_value_set_int (value, lame->lowpass_width);
904 break;
905 case ARG_HIGHPASS_FREQ:
906 g_value_set_int (value, lame->highpass_freq);
907 break;
908 case ARG_HIGHPASS_WIDTH:
909 g_value_set_int (value, lame->highpass_width);
910 break;
911 case ARG_ATH_ONLY:
912 g_value_set_boolean (value, lame->ath_only);
913 break;
914 case ARG_ATH_SHORT:
915 g_value_set_boolean (value, lame->ath_short);
916 break;
917 case ARG_NO_ATH:
918 g_value_set_boolean (value, lame->no_ath);
919 break;
920 case ARG_ATH_LOWER:
921 g_value_set_int (value, lame->ath_lower);
922 break;
923 case ARG_CWLIMIT:
924 break;
925 case ARG_ALLOW_DIFF_SHORT:
926 g_value_set_boolean (value, lame->allow_diff_short);
927 break;
928 case ARG_NO_SHORT_BLOCKS:
929 g_value_set_boolean (value, lame->no_short_blocks);
930 break;
931 case ARG_EMPHASIS:
932 g_value_set_boolean (value, lame->emphasis);
933 break;
934 case ARG_XINGHEADER:
935 break;
936 #ifdef GSTLAME_PRESET
937 case ARG_PRESET:
938 g_value_set_enum (value, lame->preset);
939 break;
940 #endif
941 default:
942 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
943 break;
944 }
945 }
947 static GstFlowReturn
948 gst_lame_flush_full (GstLame * lame, gboolean push)
949 {
950 GstBuffer *buf;
951 gint size;
952 GstFlowReturn result = GST_FLOW_OK;
954 if (!lame->lgf)
955 return GST_FLOW_OK;
957 buf = gst_buffer_new_and_alloc (7200);
958 size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
960 if (size > 0 && push) {
961 GST_BUFFER_SIZE (buf) = size;
962 GST_DEBUG_OBJECT (lame, "pushing final packet of %u bytes", size);
963 result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame), buf, -1);
964 } else {
965 GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
966 gst_buffer_unref (buf);
967 result = GST_FLOW_OK;
968 }
969 return result;
970 }
972 static void
973 gst_lame_flush (GstAudioEncoder * enc)
974 {
975 gst_lame_flush_full (GST_LAME (enc), FALSE);
976 }
978 static GstFlowReturn
979 gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
980 {
981 GstLame *lame;
982 guchar *mp3_data;
983 GstBuffer *mp3_buf;
984 gint mp3_buffer_size, mp3_size;
985 GstFlowReturn result;
986 gint num_samples;
987 guint8 *data;
988 guint size;
990 lame = GST_LAME (enc);
992 /* squeeze remaining and push */
993 if (G_UNLIKELY (buf == NULL))
994 return gst_lame_flush_full (lame, TRUE);
996 data = GST_BUFFER_DATA (buf);
997 size = GST_BUFFER_SIZE (buf);
999 num_samples = size / 2;
1001 /* allocate space for output */
1002 mp3_buffer_size = 1.25 * num_samples + 7200;
1003 mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
1004 mp3_data = GST_BUFFER_DATA (mp3_buf);
1006 /* lame seems to be too stupid to get mono interleaved going */
1007 if (lame->num_channels == 1) {
1008 mp3_size = lame_encode_buffer (lame->lgf,
1009 (short int *) data,
1010 (short int *) data, num_samples, mp3_data, mp3_buffer_size);
1011 } else {
1012 mp3_size = lame_encode_buffer_interleaved (lame->lgf,
1013 (short int *) data,
1014 num_samples / lame->num_channels, mp3_data, mp3_buffer_size);
1015 }
1017 GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
1018 size, mp3_size);
1020 if (mp3_size < 0) {
1021 g_warning ("error %d", mp3_size);
1022 }
1024 if (G_LIKELY (mp3_size > 0)) {
1025 GST_BUFFER_SIZE (mp3_buf) = mp3_size;
1026 result = gst_audio_encoder_finish_frame (enc, mp3_buf, -1);
1027 } else {
1028 if (mp3_size < 0) {
1029 /* eat error ? */
1030 g_warning ("error %d", mp3_size);
1031 }
1032 result = GST_FLOW_OK;
1033 gst_buffer_unref (mp3_buf);
1034 }
1036 return result;
1037 }
1039 /* set up the encoder state */
1040 static gboolean
1041 gst_lame_setup (GstLame * lame)
1042 {
1044 #define CHECK_ERROR(command) G_STMT_START {\
1045 if ((command) < 0) { \
1046 GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1047 return FALSE; \
1048 } \
1049 }G_STMT_END
1051 int retval;
1052 GstCaps *allowed_caps;
1054 GST_DEBUG_OBJECT (lame, "starting setup");
1056 /* check if we're already setup; if we are, we might want to check
1057 * if this initialization is compatible with the previous one */
1058 /* FIXME: do this */
1059 if (lame->setup) {
1060 GST_WARNING_OBJECT (lame, "already setup");
1061 lame->setup = FALSE;
1062 }
1064 lame->lgf = lame_init ();
1066 if (lame->lgf == NULL)
1067 return FALSE;
1069 /* copy the parameters over */
1070 lame_set_in_samplerate (lame->lgf, lame->samplerate);
1072 /* let lame choose default samplerate unless outgoing sample rate is fixed */
1073 allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
1075 if (allowed_caps != NULL) {
1076 GstStructure *structure;
1077 gint samplerate;
1079 structure = gst_caps_get_structure (allowed_caps, 0);
1081 if (gst_structure_get_int (structure, "rate", &samplerate)) {
1082 GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps",
1083 samplerate);
1084 lame_set_out_samplerate (lame->lgf, samplerate);
1085 } else {
1086 GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate");
1087 lame_set_out_samplerate (lame->lgf, 0);
1088 }
1089 gst_caps_unref (allowed_caps);
1090 allowed_caps = NULL;
1091 } else {
1092 GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate");
1093 lame_set_out_samplerate (lame->lgf, 0);
1094 }
1096 /* force mono encoding if we only have one channel */
1097 if (lame->num_channels == 1)
1098 lame->mode = 3;
1099 else
1100 lame->mode = lame->requested_mode;
1102 CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1103 CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate, lame->free_format);
1104 CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1105 CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1106 CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1107 CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1108 CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1109 CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1110 CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1111 CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1112 CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1113 CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1114 CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1115 CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1116 CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1117 CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1118 CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1119 lame->vbr_mean_bitrate));
1120 CHECK_AND_FIXUP_BITRATE (lame, "vbr-min-bitrate", lame->vbr_min_bitrate,
1121 lame->free_format);
1122 CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1123 lame->vbr_min_bitrate));
1124 CHECK_AND_FIXUP_BITRATE (lame, "vbr-max-bitrate", lame->vbr_max_bitrate,
1125 lame->free_format);
1126 CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1127 lame->vbr_max_bitrate));
1128 CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1129 CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1130 CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1131 CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1132 CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1133 CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1134 CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1135 CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1136 CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1137 CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1138 CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1139 CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1140 CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
1141 #ifdef GSTLAME_PRESET
1142 if (lame->preset > 0) {
1143 CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1144 }
1145 #endif
1147 /* initialize the lame encoder */
1148 if ((retval = lame_init_params (lame->lgf)) >= 0) {
1149 lame->setup = TRUE;
1150 /* FIXME: it would be nice to print out the mode here */
1151 GST_INFO ("lame encoder setup (%d kbit/s, %d Hz, %d channels)",
1152 lame->bitrate, lame->samplerate, lame->num_channels);
1153 } else {
1154 GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1155 }
1157 GST_DEBUG_OBJECT (lame, "done with setup");
1159 return lame->setup;
1160 #undef CHECK_ERROR
1161 }
1163 static gboolean
1164 gst_lame_get_default_settings (void)
1165 {
1166 lame_global_flags *lgf = NULL;
1168 lgf = lame_init ();
1169 if (lgf == NULL) {
1170 GST_ERROR ("Error initializing LAME");
1171 return FALSE;
1172 }
1174 if (lame_init_params (lgf) < 0) {
1175 GST_ERROR ("Error getting default settings");
1176 return FALSE;
1177 }
1179 gst_lame_default_settings.bitrate = lame_get_brate (lgf);
1180 gst_lame_default_settings.compression_ratio = 0.0; /* lame_get_compression_ratio (lgf); */
1181 gst_lame_default_settings.quality = lame_get_quality (lgf);
1182 gst_lame_default_settings.mode = lame_get_mode (lgf);
1183 gst_lame_default_settings.force_ms = lame_get_force_ms (lgf);
1184 gst_lame_default_settings.free_format = lame_get_free_format (lgf);
1185 gst_lame_default_settings.copyright = lame_get_copyright (lgf);
1186 gst_lame_default_settings.original = lame_get_original (lgf);
1187 gst_lame_default_settings.error_protection = lame_get_error_protection (lgf);
1188 gst_lame_default_settings.extension = lame_get_extension (lgf);
1189 gst_lame_default_settings.strict_iso = lame_get_strict_ISO (lgf);
1190 gst_lame_default_settings.disable_reservoir =
1191 lame_get_disable_reservoir (lgf);
1192 gst_lame_default_settings.vbr = lame_get_VBR (lgf);
1193 gst_lame_default_settings.vbr_quality = lame_get_VBR_q (lgf);
1194 gst_lame_default_settings.vbr_mean_bitrate =
1195 lame_get_VBR_mean_bitrate_kbps (lgf);
1196 gst_lame_default_settings.vbr_min_bitrate =
1197 lame_get_VBR_min_bitrate_kbps (lgf);
1198 gst_lame_default_settings.vbr_max_bitrate =
1199 lame_get_VBR_max_bitrate_kbps (lgf);
1200 gst_lame_default_settings.vbr_hard_min = lame_get_VBR_hard_min (lgf);
1201 gst_lame_default_settings.lowpass_freq = lame_get_lowpassfreq (lgf);
1202 gst_lame_default_settings.lowpass_width = lame_get_lowpasswidth (lgf);
1203 gst_lame_default_settings.highpass_freq = lame_get_highpassfreq (lgf);
1204 gst_lame_default_settings.highpass_width = lame_get_highpasswidth (lgf);
1205 gst_lame_default_settings.ath_only = lame_get_ATHonly (lgf);
1206 gst_lame_default_settings.ath_short = lame_get_ATHshort (lgf);
1207 gst_lame_default_settings.no_ath = lame_get_noATH (lgf);
1208 gst_lame_default_settings.ath_type = lame_get_ATHtype (lgf);
1209 gst_lame_default_settings.ath_lower = lame_get_ATHlower (lgf);
1210 gst_lame_default_settings.allow_diff_short = lame_get_allow_diff_short (lgf);
1211 gst_lame_default_settings.no_short_blocks = lame_get_no_short_blocks (lgf);
1212 gst_lame_default_settings.emphasis = lame_get_emphasis (lgf);
1213 gst_lame_default_settings.preset = 0;
1215 lame_close (lgf);
1217 return TRUE;
1218 }
1220 gboolean
1221 gst_lame_register (GstPlugin * plugin)
1222 {
1223 GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1225 if (!gst_lame_get_default_settings ())
1226 return FALSE;
1228 if (!gst_element_register (plugin, "lame", GST_RANK_MARGINAL, GST_TYPE_LAME))
1229 return FALSE;
1231 return TRUE;
1232 }