f36a0b26e5b7b15f3bdb2b932d9ba24afa301782
[glsdk/gst-plugins-ugly0-10.git] / ext / lame / gstlame.c
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
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)
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;
177 #define GST_TYPE_LAME_QUALITY (gst_lame_quality_get_type())
178 static GType
179 gst_lame_quality_get_type (void)
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;
202 #define GST_TYPE_LAME_PADDING (gst_lame_padding_get_type())
203 static GType
204 gst_lame_padding_get_type (void)
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;
220 #define GST_TYPE_LAME_VBRMODE (gst_lame_vbrmode_get_type())
221 static GType
222 gst_lame_vbrmode_get_type (void)
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;
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)
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;
262 #endif
264 /********** Standard stuff for signals and arguments **********/
266 enum
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)
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);
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)
338   if (lame->lgf) {
339     lame_close (lame->lgf);
340     lame->lgf = NULL;
341   }
344 static void
345 gst_lame_finalize (GObject * obj)
347   gst_lame_release_memory (GST_LAME (obj));
349   G_OBJECT_CLASS (parent_class)->finalize (obj);
352 static void
353 gst_lame_base_init (gpointer g_class)
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>");
367 static void
368 gst_lame_class_init (GstLameClass * klass)
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
546 static gboolean
547 gst_lame_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
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   }
620 static void
621 gst_lame_init (GstLame * lame, GstLameClass * klass)
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");
661 static gboolean
662 gst_lame_start (GstAudioEncoder * enc)
664   GstLame *lame = GST_LAME (enc);
666   GST_DEBUG_OBJECT (lame, "start");
667   return TRUE;
670 static gboolean
671 gst_lame_stop (GstAudioEncoder * enc)
673   GstLame *lame = GST_LAME (enc);
675   GST_DEBUG_OBJECT (lame, "stop");
677   gst_lame_release_memory (lame);
678   return TRUE;
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)
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   }
834 static void
835 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
836     GParamSpec * pspec)
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   }
947 static GstFlowReturn
948 gst_lame_flush_full (GstLame * lame, gboolean push)
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;
972 static void
973 gst_lame_flush (GstAudioEncoder * enc)
975   gst_lame_flush_full (GST_LAME (enc), FALSE);
978 static GstFlowReturn
979 gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
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;
1039 /* set up the encoder state */
1040 static gboolean
1041 gst_lame_setup (GstLame * lame)
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
1163 static gboolean
1164 gst_lame_get_default_settings (void)
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;
1220 gboolean
1221 gst_lame_register (GstPlugin * plugin)
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;