lame: ensure parsed output
[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   }
576   lame->out_samplerate = out_samplerate;
578   version = lame_get_version (lame->lgf);
579   if (version == 0)
580     version = 2;
581   else if (version == 1)
582     version = 1;
583   else if (version == 2)
584     version = 3;
586   othercaps =
587       gst_caps_new_simple ("audio/mpeg",
588       "mpegversion", G_TYPE_INT, 1,
589       "mpegaudioversion", G_TYPE_INT, version,
590       "layer", G_TYPE_INT, 3,
591       "channels", G_TYPE_INT, lame->mode == MONO ? 1 : lame->num_channels,
592       "rate", G_TYPE_INT, out_samplerate, NULL);
594   /* and use these caps */
595   gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (lame), othercaps);
596   gst_caps_unref (othercaps);
598   /* base class feedback:
599    * - we will handle buffers, just hand us all available
600    * - report latency */
601   latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
602       GST_SECOND, lame->samplerate);
603   gst_audio_encoder_set_latency (enc, latency, latency);
605   return TRUE;
607 zero_output_rate:
608   {
609     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
610         ("LAME decided on a zero sample rate"));
611     return FALSE;
612   }
613 setup_failed:
614   {
615     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS,
616         (_("Failed to configure LAME encoder. Check your encoding parameters.")), (NULL));
617     return FALSE;
618   }
621 static void
622 gst_lame_init (GstLame * lame, GstLameClass * klass)
624   GST_DEBUG_OBJECT (lame, "starting initialization");
626   /* Set default settings */
627   lame->bitrate = gst_lame_default_settings.bitrate;
628   lame->compression_ratio = gst_lame_default_settings.compression_ratio;
629   lame->quality = gst_lame_default_settings.quality;
630   lame->mode = gst_lame_default_settings.mode;
631   lame->requested_mode = lame->mode;
632   lame->force_ms = gst_lame_default_settings.force_ms;
633   lame->free_format = gst_lame_default_settings.free_format;
634   lame->copyright = gst_lame_default_settings.copyright;
635   lame->original = gst_lame_default_settings.original;
636   lame->error_protection = gst_lame_default_settings.error_protection;
637   lame->extension = gst_lame_default_settings.extension;
638   lame->strict_iso = gst_lame_default_settings.strict_iso;
639   lame->disable_reservoir = gst_lame_default_settings.disable_reservoir;
640   lame->vbr = gst_lame_default_settings.vbr;
641   lame->vbr_quality = gst_lame_default_settings.vbr_quality;
642   lame->vbr_mean_bitrate = gst_lame_default_settings.vbr_mean_bitrate;
643   lame->vbr_min_bitrate = gst_lame_default_settings.vbr_min_bitrate;
644   lame->vbr_max_bitrate = gst_lame_default_settings.vbr_max_bitrate;
645   lame->vbr_hard_min = gst_lame_default_settings.vbr_hard_min;
646   lame->lowpass_freq = gst_lame_default_settings.lowpass_freq;
647   lame->lowpass_width = gst_lame_default_settings.lowpass_width;
648   lame->highpass_freq = gst_lame_default_settings.highpass_freq;
649   lame->highpass_width = gst_lame_default_settings.highpass_width;
650   lame->ath_only = gst_lame_default_settings.ath_only;
651   lame->ath_short = gst_lame_default_settings.ath_short;
652   lame->no_ath = gst_lame_default_settings.no_ath;
653   lame->ath_lower = gst_lame_default_settings.ath_lower;
654   lame->allow_diff_short = gst_lame_default_settings.allow_diff_short;
655   lame->no_short_blocks = gst_lame_default_settings.no_short_blocks;
656   lame->emphasis = gst_lame_default_settings.emphasis;
657   lame->preset = gst_lame_default_settings.preset;
659   GST_DEBUG_OBJECT (lame, "done initializing");
662 static gboolean
663 gst_lame_start (GstAudioEncoder * enc)
665   GstLame *lame = GST_LAME (enc);
667   if (!lame->adapter)
668     lame->adapter = gst_adapter_new ();
669   gst_adapter_clear (lame->adapter);
671   GST_DEBUG_OBJECT (lame, "start");
672   return TRUE;
675 static gboolean
676 gst_lame_stop (GstAudioEncoder * enc)
678   GstLame *lame = GST_LAME (enc);
680   GST_DEBUG_OBJECT (lame, "stop");
682   if (lame->adapter) {
683     g_object_unref (lame->adapter);
684     lame->adapter = NULL;
685   }
687   gst_lame_release_memory (lame);
688   return TRUE;
692 /* <php-emulation-mode>three underscores for ___rate is really really really
693  * private as opposed to one underscore<php-emulation-mode> */
694 /* call this MACRO outside of the NULL state so that we have a higher chance
695  * of actually having a pipeline and bus to get the message through */
697 #define CHECK_AND_FIXUP_BITRATE(obj,param,rate,free_format)               \
698 G_STMT_START {                                                            \
699   gint ___rate = rate;                                                    \
700   gint maxrate = 320;                                                     \
701   gint multiplier = 64;                                                   \
702   if (!free_format) {                                                     \
703     if (rate == 0) {                                                      \
704       ___rate = rate;                                                     \
705     } else if (rate <= 64) {                                              \
706       maxrate = 64; multiplier = 8;                                       \
707       if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate);               \
708     } else if (rate <= 128) {                                             \
709       maxrate = 128; multiplier = 16;                                     \
710       if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate);             \
711     } else if (rate <= 256) {                                             \
712       maxrate = 256; multiplier = 32;                                     \
713       if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate);             \
714     } else if (rate <= 320) {                                             \
715       maxrate = 320; multiplier = 64;                                     \
716       if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate);             \
717     }                                                                     \
718     if (___rate != rate) {                                                \
719       GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS,                        \
720           (_("The requested bitrate %d kbit/s for property '%s' "         \
721              "is not allowed. "                                           \
722             "The bitrate was changed to %d kbit/s."), rate,               \
723             param,  ___rate),                                             \
724           ("A bitrate below %d should be a multiple of %d.",              \
725               maxrate, multiplier));                                      \
726       rate = ___rate;                                                     \
727     }                                                                     \
728   }                                                                       \
729 } G_STMT_END
731 static void
732 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
733     GParamSpec * pspec)
735   GstLame *lame;
737   lame = GST_LAME (object);
739   switch (prop_id) {
740     case ARG_BITRATE:
741       lame->bitrate = g_value_get_int (value);
742       break;
743     case ARG_COMPRESSION_RATIO:
744       lame->compression_ratio = g_value_get_float (value);
745       break;
746     case ARG_QUALITY:
747       lame->quality = g_value_get_enum (value);
748       break;
749     case ARG_MODE:
750       lame->requested_mode = g_value_get_enum (value);
751       break;
752     case ARG_FORCE_MS:
753       lame->force_ms = g_value_get_boolean (value);
754       break;
755     case ARG_FREE_FORMAT:
756       lame->free_format = g_value_get_boolean (value);
757       break;
758     case ARG_COPYRIGHT:
759       lame->copyright = g_value_get_boolean (value);
760       break;
761     case ARG_ORIGINAL:
762       lame->original = g_value_get_boolean (value);
763       break;
764     case ARG_ERROR_PROTECTION:
765       lame->error_protection = g_value_get_boolean (value);
766       break;
767     case ARG_PADDING_TYPE:
768       break;
769     case ARG_EXTENSION:
770       lame->extension = g_value_get_boolean (value);
771       break;
772     case ARG_STRICT_ISO:
773       lame->strict_iso = g_value_get_boolean (value);
774       break;
775     case ARG_DISABLE_RESERVOIR:
776       lame->disable_reservoir = g_value_get_boolean (value);
777       break;
778     case ARG_VBR:
779       lame->vbr = g_value_get_enum (value);
780       break;
781     case ARG_VBR_QUALITY:
782       lame->vbr_quality = g_value_get_enum (value);
783       break;
784     case ARG_VBR_MEAN_BITRATE:
785       lame->vbr_mean_bitrate = g_value_get_int (value);
786       break;
787     case ARG_VBR_MIN_BITRATE:
788       lame->vbr_min_bitrate = g_value_get_int (value);
789       break;
790     case ARG_VBR_MAX_BITRATE:
791       lame->vbr_max_bitrate = g_value_get_int (value);
792       break;
793     case ARG_VBR_HARD_MIN:
794       lame->vbr_hard_min = g_value_get_int (value);
795       break;
796     case ARG_LOWPASS_FREQ:
797       lame->lowpass_freq = g_value_get_int (value);
798       break;
799     case ARG_LOWPASS_WIDTH:
800       lame->lowpass_width = g_value_get_int (value);
801       break;
802     case ARG_HIGHPASS_FREQ:
803       lame->highpass_freq = g_value_get_int (value);
804       break;
805     case ARG_HIGHPASS_WIDTH:
806       lame->highpass_width = g_value_get_int (value);
807       break;
808     case ARG_ATH_ONLY:
809       lame->ath_only = g_value_get_boolean (value);
810       break;
811     case ARG_ATH_SHORT:
812       lame->ath_short = g_value_get_boolean (value);
813       break;
814     case ARG_NO_ATH:
815       lame->no_ath = g_value_get_boolean (value);
816       break;
817     case ARG_ATH_LOWER:
818       lame->ath_lower = g_value_get_int (value);
819       break;
820     case ARG_CWLIMIT:
821       break;
822     case ARG_ALLOW_DIFF_SHORT:
823       lame->allow_diff_short = g_value_get_boolean (value);
824       break;
825     case ARG_NO_SHORT_BLOCKS:
826       lame->no_short_blocks = g_value_get_boolean (value);
827       break;
828     case ARG_EMPHASIS:
829       lame->emphasis = g_value_get_boolean (value);
830       break;
831     case ARG_XINGHEADER:
832       break;
833 #ifdef GSTLAME_PRESET
834     case ARG_PRESET:
835       lame->preset = g_value_get_enum (value);
836       break;
837 #endif
838     default:
839       break;
840   }
844 static void
845 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
846     GParamSpec * pspec)
848   GstLame *lame;
850   lame = GST_LAME (object);
852   switch (prop_id) {
853     case ARG_BITRATE:
854       g_value_set_int (value, lame->bitrate);
855       break;
856     case ARG_COMPRESSION_RATIO:
857       g_value_set_float (value, lame->compression_ratio);
858       break;
859     case ARG_QUALITY:
860       g_value_set_enum (value, lame->quality);
861       break;
862     case ARG_MODE:
863       g_value_set_enum (value, lame->requested_mode);
864       break;
865     case ARG_FORCE_MS:
866       g_value_set_boolean (value, lame->force_ms);
867       break;
868     case ARG_FREE_FORMAT:
869       g_value_set_boolean (value, lame->free_format);
870       break;
871     case ARG_COPYRIGHT:
872       g_value_set_boolean (value, lame->copyright);
873       break;
874     case ARG_ORIGINAL:
875       g_value_set_boolean (value, lame->original);
876       break;
877     case ARG_ERROR_PROTECTION:
878       g_value_set_boolean (value, lame->error_protection);
879       break;
880     case ARG_PADDING_TYPE:
881       break;
882     case ARG_EXTENSION:
883       g_value_set_boolean (value, lame->extension);
884       break;
885     case ARG_STRICT_ISO:
886       g_value_set_boolean (value, lame->strict_iso);
887       break;
888     case ARG_DISABLE_RESERVOIR:
889       g_value_set_boolean (value, lame->disable_reservoir);
890       break;
891     case ARG_VBR:
892       g_value_set_enum (value, lame->vbr);
893       break;
894     case ARG_VBR_QUALITY:
895       g_value_set_enum (value, lame->vbr_quality);
896       break;
897     case ARG_VBR_MEAN_BITRATE:
898       g_value_set_int (value, lame->vbr_mean_bitrate);
899       break;
900     case ARG_VBR_MIN_BITRATE:
901       g_value_set_int (value, lame->vbr_min_bitrate);
902       break;
903     case ARG_VBR_MAX_BITRATE:
904       g_value_set_int (value, lame->vbr_max_bitrate);
905       break;
906     case ARG_VBR_HARD_MIN:
907       g_value_set_int (value, lame->vbr_hard_min);
908       break;
909     case ARG_LOWPASS_FREQ:
910       g_value_set_int (value, lame->lowpass_freq);
911       break;
912     case ARG_LOWPASS_WIDTH:
913       g_value_set_int (value, lame->lowpass_width);
914       break;
915     case ARG_HIGHPASS_FREQ:
916       g_value_set_int (value, lame->highpass_freq);
917       break;
918     case ARG_HIGHPASS_WIDTH:
919       g_value_set_int (value, lame->highpass_width);
920       break;
921     case ARG_ATH_ONLY:
922       g_value_set_boolean (value, lame->ath_only);
923       break;
924     case ARG_ATH_SHORT:
925       g_value_set_boolean (value, lame->ath_short);
926       break;
927     case ARG_NO_ATH:
928       g_value_set_boolean (value, lame->no_ath);
929       break;
930     case ARG_ATH_LOWER:
931       g_value_set_int (value, lame->ath_lower);
932       break;
933     case ARG_CWLIMIT:
934       break;
935     case ARG_ALLOW_DIFF_SHORT:
936       g_value_set_boolean (value, lame->allow_diff_short);
937       break;
938     case ARG_NO_SHORT_BLOCKS:
939       g_value_set_boolean (value, lame->no_short_blocks);
940       break;
941     case ARG_EMPHASIS:
942       g_value_set_boolean (value, lame->emphasis);
943       break;
944     case ARG_XINGHEADER:
945       break;
946 #ifdef GSTLAME_PRESET
947     case ARG_PRESET:
948       g_value_set_enum (value, lame->preset);
949       break;
950 #endif
951     default:
952       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
953       break;
954   }
957 /* **** credits go to mpegaudioparse **** */
959 static const guint mp3types_bitrates[2][3][16] = {
960   {
961         {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
962         {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
963         {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
964       },
965   {
966         {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
967         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
968         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
969       },
970 };
972 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
973 {22050, 24000, 16000},
974 {11025, 12000, 8000}
975 };
977 static inline guint
978 mp3_type_frame_length_from_header (GstLame * lame, guint32 header,
979     guint * put_version, guint * put_layer, guint * put_channels,
980     guint * put_bitrate, guint * put_samplerate, guint * put_mode,
981     guint * put_crc)
983   guint length;
984   gulong mode, samplerate, bitrate, layer, channels, padding, crc;
985   gulong version;
986   gint lsf, mpg25;
988   if (header & (1 << 20)) {
989     lsf = (header & (1 << 19)) ? 0 : 1;
990     mpg25 = 0;
991   } else {
992     lsf = 1;
993     mpg25 = 1;
994   }
996   version = 1 + lsf + mpg25;
998   layer = 4 - ((header >> 17) & 0x3);
1000   crc = (header >> 16) & 0x1;
1002   bitrate = (header >> 12) & 0xF;
1003   bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
1004   /* The caller has ensured we have a valid header, so bitrate can't be
1005      zero here. */
1006   g_assert (bitrate != 0);
1008   samplerate = (header >> 10) & 0x3;
1009   samplerate = mp3types_freqs[lsf + mpg25][samplerate];
1011   padding = (header >> 9) & 0x1;
1013   mode = (header >> 6) & 0x3;
1014   channels = (mode == 3) ? 1 : 2;
1016   switch (layer) {
1017     case 1:
1018       length = 4 * ((bitrate * 12) / samplerate + padding);
1019       break;
1020     case 2:
1021       length = (bitrate * 144) / samplerate + padding;
1022       break;
1023     default:
1024     case 3:
1025       length = (bitrate * 144) / (samplerate << lsf) + padding;
1026       break;
1027   }
1029   GST_DEBUG_OBJECT (lame, "Calculated mp3 frame length of %u bytes", length);
1030   GST_DEBUG_OBJECT (lame, "samplerate = %lu, bitrate = %lu, version = %lu, "
1031       "layer = %lu, channels = %lu", samplerate, bitrate, version,
1032       layer, channels);
1034   if (put_version)
1035     *put_version = version;
1036   if (put_layer)
1037     *put_layer = layer;
1038   if (put_channels)
1039     *put_channels = channels;
1040   if (put_bitrate)
1041     *put_bitrate = bitrate;
1042   if (put_samplerate)
1043     *put_samplerate = samplerate;
1044   if (put_mode)
1045     *put_mode = mode;
1046   if (put_crc)
1047     *put_crc = crc;
1049   return length;
1052 static gboolean
1053 mp3_sync_check (GstLame * lame, unsigned long head)
1055   GST_DEBUG_OBJECT (lame, "checking mp3 header 0x%08lx", head);
1056   /* if it's not a valid sync */
1057   if ((head & 0xffe00000) != 0xffe00000) {
1058     GST_WARNING_OBJECT (lame, "invalid sync");
1059     return FALSE;
1060   }
1061   /* if it's an invalid MPEG version */
1062   if (((head >> 19) & 3) == 0x1) {
1063     GST_WARNING_OBJECT (lame, "invalid MPEG version: 0x%lx", (head >> 19) & 3);
1064     return FALSE;
1065   }
1066   /* if it's an invalid layer */
1067   if (!((head >> 17) & 3)) {
1068     GST_WARNING_OBJECT (lame, "invalid layer: 0x%lx", (head >> 17) & 3);
1069     return FALSE;
1070   }
1071   /* if it's an invalid bitrate */
1072   if (((head >> 12) & 0xf) == 0x0) {
1073     GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx."
1074         "Free format files are not supported yet", (head >> 12) & 0xf);
1075     return FALSE;
1076   }
1077   if (((head >> 12) & 0xf) == 0xf) {
1078     GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx", (head >> 12) & 0xf);
1079     return FALSE;
1080   }
1081   /* if it's an invalid samplerate */
1082   if (((head >> 10) & 0x3) == 0x3) {
1083     GST_WARNING_OBJECT (lame, "invalid samplerate: 0x%lx", (head >> 10) & 0x3);
1084     return FALSE;
1085   }
1087   if ((head & 0x3) == 0x2) {
1088     /* Ignore this as there are some files with emphasis 0x2 that can
1089      * be played fine. See BGO #537235 */
1090     GST_WARNING_OBJECT (lame, "invalid emphasis: 0x%lx", head & 0x3);
1091   }
1093   return TRUE;
1096 /* **** end mpegaudioparse **** */
1098 static GstFlowReturn
1099 gst_lame_finish_frames (GstLame * lame)
1101   gint av;
1102   guint header;
1103   GstFlowReturn result = GST_FLOW_OK;
1105   /* limited parsing, we don't expect to lose sync here */
1106   while ((result == GST_FLOW_OK) &&
1107       ((av = gst_adapter_available (lame->adapter)) > 4)) {
1108     guint rate, version, layer, size;
1109     GstBuffer *mp3_buf;
1110     const guint8 *data;
1112     data = gst_adapter_peek (lame->adapter, 4);
1113     header = GST_READ_UINT32_BE (data);
1114     if (!mp3_sync_check (lame, header))
1115       goto invalid_header;
1117     size = mp3_type_frame_length_from_header (lame, header, &version, &layer,
1118         NULL, NULL, &rate, NULL, NULL);
1120     if (G_UNLIKELY (layer != 3 || rate != lame->out_samplerate)) {
1121       GST_DEBUG_OBJECT (lame,
1122           "unexpected mp3 header with (rate, layer): (%u, %u)",
1123           rate, version, layer);
1124       goto invalid_header;
1125     }
1127     if (size > av) {
1128       /* pretty likely to occur when lame is holding back on us */
1129       GST_LOG_OBJECT (lame, "frame size %u (> %d)", size, av);
1130       break;
1131     }
1133     /* should be ok now */
1134     mp3_buf = gst_adapter_take_buffer (lame->adapter, size);
1135     /* number of samples for MPEG-1, layer 3 */
1136     result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame),
1137         mp3_buf, version == 1 ? 1152 : 576);
1138   }
1140 exit:
1141   return result;
1143   /* ERRORS */
1144 invalid_header:
1145   {
1146     GST_ELEMENT_ERROR (lame, STREAM, ENCODE,
1147         ("invalid lame mp3 sync header %08X", header), (NULL));
1148     result = GST_FLOW_ERROR;
1149     goto exit;
1150   }
1153 static GstFlowReturn
1154 gst_lame_flush_full (GstLame * lame, gboolean push)
1156   GstBuffer *buf;
1157   gint size;
1158   GstFlowReturn result = GST_FLOW_OK;
1159   gint av;
1161   if (!lame->lgf)
1162     return GST_FLOW_OK;
1164   buf = gst_buffer_new_and_alloc (7200);
1165   size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
1167   if (size > 0) {
1168     GST_BUFFER_SIZE (buf) = size;
1169     GST_DEBUG_OBJECT (lame, "collecting final %d bytes", size);
1170     gst_adapter_push (lame->adapter, buf);
1171   } else {
1172     GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
1173     gst_buffer_unref (buf);
1174     result = GST_FLOW_OK;
1175   }
1177   if (push) {
1178     result = gst_lame_finish_frames (lame);
1179   } else {
1180     /* never mind */
1181     gst_adapter_clear (lame->adapter);
1182   }
1184   /* either way, we expect nothing left */
1185   if ((av = gst_adapter_available (lame->adapter))) {
1186     /* should this be more fatal ?? */
1187     GST_WARNING_OBJECT (lame, "unparsed %d bytes left after flushing", av);
1188     /* clean up anyway */
1189     gst_adapter_clear (lame->adapter);
1190   }
1192   return result;
1195 static void
1196 gst_lame_flush (GstAudioEncoder * enc)
1198   gst_lame_flush_full (GST_LAME (enc), FALSE);
1201 static GstFlowReturn
1202 gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
1204   GstLame *lame;
1205   guchar *mp3_data;
1206   GstBuffer *mp3_buf;
1207   gint mp3_buffer_size, mp3_size;
1208   GstFlowReturn result;
1209   gint num_samples;
1210   guint8 *data;
1211   guint size;
1213   lame = GST_LAME (enc);
1215   /* squeeze remaining and push */
1216   if (G_UNLIKELY (buf == NULL))
1217     return gst_lame_flush_full (lame, TRUE);
1219   data = GST_BUFFER_DATA (buf);
1220   size = GST_BUFFER_SIZE (buf);
1222   num_samples = size / 2;
1224   /* allocate space for output */
1225   mp3_buffer_size = 1.25 * num_samples + 7200;
1226   mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
1227   mp3_data = GST_BUFFER_DATA (mp3_buf);
1229   /* lame seems to be too stupid to get mono interleaved going */
1230   if (lame->num_channels == 1) {
1231     mp3_size = lame_encode_buffer (lame->lgf,
1232         (short int *) data,
1233         (short int *) data, num_samples, mp3_data, mp3_buffer_size);
1234   } else {
1235     mp3_size = lame_encode_buffer_interleaved (lame->lgf,
1236         (short int *) data,
1237         num_samples / lame->num_channels, mp3_data, mp3_buffer_size);
1238   }
1240   GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
1241       size, mp3_size);
1243   if (mp3_size < 0) {
1244     g_warning ("error %d", mp3_size);
1245   }
1247   if (G_LIKELY (mp3_size > 0)) {
1248     GST_BUFFER_SIZE (mp3_buf) = mp3_size;
1249     /* unfortunately lame does not provide frame delineated output,
1250      * so collect output and parse into frames ... */
1251     gst_adapter_push (lame->adapter, mp3_buf);
1252     result = gst_lame_finish_frames (lame);
1253   } else {
1254     if (mp3_size < 0) {
1255       /* eat error ? */
1256       g_warning ("error %d", mp3_size);
1257     }
1258     result = GST_FLOW_OK;
1259     gst_buffer_unref (mp3_buf);
1260   }
1262   return result;
1265 /* set up the encoder state */
1266 static gboolean
1267 gst_lame_setup (GstLame * lame)
1270 #define CHECK_ERROR(command) G_STMT_START {\
1271   if ((command) < 0) { \
1272     GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1273     return FALSE; \
1274   } \
1275 }G_STMT_END
1277   int retval;
1278   GstCaps *allowed_caps;
1280   GST_DEBUG_OBJECT (lame, "starting setup");
1282   /* check if we're already setup; if we are, we might want to check
1283    * if this initialization is compatible with the previous one */
1284   /* FIXME: do this */
1285   if (lame->setup) {
1286     GST_WARNING_OBJECT (lame, "already setup");
1287     lame->setup = FALSE;
1288   }
1290   lame->lgf = lame_init ();
1292   if (lame->lgf == NULL)
1293     return FALSE;
1295   /* copy the parameters over */
1296   lame_set_in_samplerate (lame->lgf, lame->samplerate);
1298   /* let lame choose default samplerate unless outgoing sample rate is fixed */
1299   allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
1301   if (allowed_caps != NULL) {
1302     GstStructure *structure;
1303     gint samplerate;
1305     structure = gst_caps_get_structure (allowed_caps, 0);
1307     if (gst_structure_get_int (structure, "rate", &samplerate)) {
1308       GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps",
1309           samplerate);
1310       lame_set_out_samplerate (lame->lgf, samplerate);
1311     } else {
1312       GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate");
1313       lame_set_out_samplerate (lame->lgf, 0);
1314     }
1315     gst_caps_unref (allowed_caps);
1316     allowed_caps = NULL;
1317   } else {
1318     GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate");
1319     lame_set_out_samplerate (lame->lgf, 0);
1320   }
1322   /* force mono encoding if we only have one channel */
1323   if (lame->num_channels == 1)
1324     lame->mode = 3;
1325   else
1326     lame->mode = lame->requested_mode;
1328   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1329   CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate, lame->free_format);
1330   CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1331   CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1332   CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1333   CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1334   CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1335   CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1336   CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1337   CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1338   CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1339   CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1340   CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1341   CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1342   CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1343   CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1344   CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1345           lame->vbr_mean_bitrate));
1346   CHECK_AND_FIXUP_BITRATE (lame, "vbr-min-bitrate", lame->vbr_min_bitrate,
1347       lame->free_format);
1348   CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1349           lame->vbr_min_bitrate));
1350   CHECK_AND_FIXUP_BITRATE (lame, "vbr-max-bitrate", lame->vbr_max_bitrate,
1351       lame->free_format);
1352   CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1353           lame->vbr_max_bitrate));
1354   CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1355   CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1356   CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1357   CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1358   CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1359   CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1360   CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1361   CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1362   CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1363   CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1364   CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1365   CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1366   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
1367 #ifdef GSTLAME_PRESET
1368   if (lame->preset > 0) {
1369     CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1370   }
1371 #endif
1373   /* initialize the lame encoder */
1374   if ((retval = lame_init_params (lame->lgf)) >= 0) {
1375     lame->setup = TRUE;
1376     /* FIXME: it would be nice to print out the mode here */
1377     GST_INFO ("lame encoder setup (%d kbit/s, %d Hz, %d channels)",
1378         lame->bitrate, lame->samplerate, lame->num_channels);
1379   } else {
1380     GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1381   }
1383   GST_DEBUG_OBJECT (lame, "done with setup");
1385   return lame->setup;
1386 #undef CHECK_ERROR
1389 static gboolean
1390 gst_lame_get_default_settings (void)
1392   lame_global_flags *lgf = NULL;
1394   lgf = lame_init ();
1395   if (lgf == NULL) {
1396     GST_ERROR ("Error initializing LAME");
1397     return FALSE;
1398   }
1400   if (lame_init_params (lgf) < 0) {
1401     GST_ERROR ("Error getting default settings");
1402     return FALSE;
1403   }
1405   gst_lame_default_settings.bitrate = lame_get_brate (lgf);
1406   gst_lame_default_settings.compression_ratio = 0.0;    /* lame_get_compression_ratio (lgf); */
1407   gst_lame_default_settings.quality = lame_get_quality (lgf);
1408   gst_lame_default_settings.mode = lame_get_mode (lgf);
1409   gst_lame_default_settings.force_ms = lame_get_force_ms (lgf);
1410   gst_lame_default_settings.free_format = lame_get_free_format (lgf);
1411   gst_lame_default_settings.copyright = lame_get_copyright (lgf);
1412   gst_lame_default_settings.original = lame_get_original (lgf);
1413   gst_lame_default_settings.error_protection = lame_get_error_protection (lgf);
1414   gst_lame_default_settings.extension = lame_get_extension (lgf);
1415   gst_lame_default_settings.strict_iso = lame_get_strict_ISO (lgf);
1416   gst_lame_default_settings.disable_reservoir =
1417       lame_get_disable_reservoir (lgf);
1418   gst_lame_default_settings.vbr = lame_get_VBR (lgf);
1419   gst_lame_default_settings.vbr_quality = lame_get_VBR_q (lgf);
1420   gst_lame_default_settings.vbr_mean_bitrate =
1421       lame_get_VBR_mean_bitrate_kbps (lgf);
1422   gst_lame_default_settings.vbr_min_bitrate =
1423       lame_get_VBR_min_bitrate_kbps (lgf);
1424   gst_lame_default_settings.vbr_max_bitrate =
1425       lame_get_VBR_max_bitrate_kbps (lgf);
1426   gst_lame_default_settings.vbr_hard_min = lame_get_VBR_hard_min (lgf);
1427   gst_lame_default_settings.lowpass_freq = lame_get_lowpassfreq (lgf);
1428   gst_lame_default_settings.lowpass_width = lame_get_lowpasswidth (lgf);
1429   gst_lame_default_settings.highpass_freq = lame_get_highpassfreq (lgf);
1430   gst_lame_default_settings.highpass_width = lame_get_highpasswidth (lgf);
1431   gst_lame_default_settings.ath_only = lame_get_ATHonly (lgf);
1432   gst_lame_default_settings.ath_short = lame_get_ATHshort (lgf);
1433   gst_lame_default_settings.no_ath = lame_get_noATH (lgf);
1434   gst_lame_default_settings.ath_type = lame_get_ATHtype (lgf);
1435   gst_lame_default_settings.ath_lower = lame_get_ATHlower (lgf);
1436   gst_lame_default_settings.allow_diff_short = lame_get_allow_diff_short (lgf);
1437   gst_lame_default_settings.no_short_blocks = lame_get_no_short_blocks (lgf);
1438   gst_lame_default_settings.emphasis = lame_get_emphasis (lgf);
1439   gst_lame_default_settings.preset = 0;
1441   lame_close (lgf);
1443   return TRUE;
1446 gboolean
1447 gst_lame_register (GstPlugin * plugin)
1449   GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1451   if (!gst_lame_get_default_settings ())
1452     return FALSE;
1454   if (!gst_element_register (plugin, "lame", GST_RANK_MARGINAL, GST_TYPE_LAME))
1455     return FALSE;
1457   return TRUE;