summaryrefslogtreecommitdiffstats
path: root/plugins/encoder/lame/k3blameencoder.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/encoder/lame/k3blameencoder.cpp')
-rw-r--r--plugins/encoder/lame/k3blameencoder.cpp627
1 files changed, 627 insertions, 0 deletions
diff --git a/plugins/encoder/lame/k3blameencoder.cpp b/plugins/encoder/lame/k3blameencoder.cpp
new file mode 100644
index 0000000..089c7d0
--- /dev/null
+++ b/plugins/encoder/lame/k3blameencoder.cpp
@@ -0,0 +1,627 @@
+/*
+ *
+ * $Id: k3blameencoder.cpp 653779 2007-04-14 07:58:51Z trueg $
+ * Copyright (C) 2003 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This file is part of the K3b project.
+ * Copyright (C) 1998-2007 Sebastian Trueg <trueg@k3b.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * See the file "COPYING" for the exact licensing terms.
+ */
+
+#include <config.h>
+
+#include "k3blameencoder.h"
+
+#include <k3bcore.h>
+#include <k3bpluginfactory.h>
+
+#include <klocale.h>
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kinstance.h>
+#include <knuminput.h>
+#include <kcombobox.h>
+#include <kdialogbase.h>
+
+#include <qlayout.h>
+#include <qcstring.h>
+#include <qradiobutton.h>
+#include <qcheckbox.h>
+#include <qspinbox.h>
+#include <qgroupbox.h>
+#include <qbuttongroup.h>
+#include <qtextcodec.h>
+#include <qfile.h>
+#include <qslider.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
+
+#include <stdio.h>
+#include <lame/lame.h>
+
+
+K_EXPORT_COMPONENT_FACTORY( libk3blameencoder, K3bPluginFactory<K3bLameEncoder>( "libk3blameencoder" ) )
+
+
+static const int s_lame_bitrates[] = {
+ 32,
+ 40,
+ 48,
+ 56,
+ 64,
+ 80,
+ 96,
+ 112,
+ 128,
+ 160,
+ 192,
+ 224,
+ 256,
+ 320,
+ 0 // just used for the loops below
+};
+
+
+static const int s_lame_presets[] = {
+ 56, // ABR for Voice, Radio, Mono, etc.
+ 90, //
+
+ V6, // ~115 kbps
+ V5, // ~130 kbps | Portable - small size
+ V4, // ~160 kbps
+
+ V3, // ~175 kbps
+ V2, // ~190 kbps | HiFi - for home or quite listening
+ V1, // ~210 kbps |
+ V0, // ~230 kbps
+
+ 320 // ABR 320 neary lossless for archiving (not recommended, use flac instead)
+};
+
+
+static const int s_lame_preset_approx_bitrates[] = {
+ 56,
+ 90,
+ 115,
+ 130,
+ 160,
+ 175,
+ 190,
+ 210,
+ 230,
+ 320
+};
+
+
+static const char* s_lame_preset_strings[] = {
+ I18N_NOOP("Low quality (56 kbps)"),
+ I18N_NOOP("Low quality (90 kbps)"),
+
+ I18N_NOOP("Portable (average 115 kbps)"),
+ I18N_NOOP("Portable (average 130 kbps)"),
+ I18N_NOOP("Portable (average 160 kbps)"),
+
+ I18N_NOOP("HiFi (average 175 kbps)"),
+ I18N_NOOP("HiFi (average 190 kbps)"),
+ I18N_NOOP("HiFi (average 210 kbps)"),
+ I18N_NOOP("HiFi (average 230 kbps)"),
+
+ I18N_NOOP("Archiving (320 kbps)"),
+};
+
+
+static const char* s_lame_mode_strings[] = {
+ I18N_NOOP("Stereo"),
+ I18N_NOOP("Joint Stereo"),
+ I18N_NOOP("Mono")
+};
+
+
+
+class K3bLameEncoder::Private
+{
+public:
+ Private()
+ : flags(0),
+ fid(0) {
+ }
+
+ lame_global_flags* flags;
+
+ char buffer[8000];
+
+ QString filename;
+ FILE* fid;
+};
+
+
+
+
+K3bLameEncoder::K3bLameEncoder( QObject* parent, const char* name )
+ : K3bAudioEncoder( parent, name )
+{
+ d = new Private();
+}
+
+
+K3bLameEncoder::~K3bLameEncoder()
+{
+ closeFile();
+
+ delete d;
+}
+
+
+bool K3bLameEncoder::openFile( const QString& extension, const QString& filename, const K3b::Msf& length )
+{
+ closeFile();
+
+ d->filename = filename;
+ d->fid = ::fopen( QFile::encodeName( filename ), "w+" );
+ if( d->fid )
+ return initEncoder( extension, length );
+ else
+ return false;
+}
+
+
+bool K3bLameEncoder::isOpen() const
+{
+ return ( d->fid != 0 );
+}
+
+
+void K3bLameEncoder::closeFile()
+{
+ if( isOpen() ) {
+ finishEncoder();
+ ::fclose( d->fid );
+ d->fid = 0;
+ d->filename.truncate(0);
+ }
+}
+
+
+const QString& K3bLameEncoder::filename() const
+{
+ return d->filename;
+}
+
+
+bool K3bLameEncoder::initEncoderInternal( const QString&, const K3b::Msf& length )
+{
+ KConfig* c = k3bcore->config();
+ c->setGroup( "K3bLameEncoderPlugin" );
+
+ d->flags = lame_init();
+
+ if( d->flags == 0 ) {
+ kdDebug() << "(K3bLameEncoder) lame_init failed." << endl;
+ return false;
+ }
+
+ //
+ // set the format of the input data
+ //
+ lame_set_num_samples( d->flags, length.lba()*588 );
+ lame_set_in_samplerate( d->flags, 44100 );
+ lame_set_num_channels( d->flags, 2 );
+
+ //
+ // Lame by default determines the samplerate based on the bitrate
+ // since we have no option for the user to influence this yet
+ // we just keep to the good old 44.1 khz
+ //
+ lame_set_out_samplerate( d->flags, 44100 );
+
+ //
+ // Choose the quality level
+ //
+ if( c->readBoolEntry( "Manual Bitrate Settings", false ) ) {
+ //
+ // Mode
+ //
+ QString mode = c->readEntry( "Mode", "stereo" );
+ if( mode == "stereo" )
+ lame_set_mode( d->flags, STEREO );
+ else if( mode == "joint" )
+ lame_set_mode( d->flags, JOINT_STEREO );
+ else // mono
+ lame_set_mode( d->flags, MONO );
+
+ //
+ // Variable Bitrate
+ //
+ if( c->readBoolEntry( "VBR", false ) ) {
+ // we use the default algorithm here
+ lame_set_VBR( d->flags, vbr_default );
+
+ if( c->readBoolEntry( "Use Maximum Bitrate", false ) ) {
+ lame_set_VBR_max_bitrate_kbps( d->flags, c->readNumEntry( "Maximum Bitrate", 224 ) );
+ }
+ if( c->readBoolEntry( "Use Minimum Bitrate", false ) ) {
+ lame_set_VBR_min_bitrate_kbps( d->flags, c->readNumEntry( "Minimum Bitrate", 32 ) );
+
+ // TODO: lame_set_hard_min
+ }
+ if( c->readBoolEntry( "Use Average Bitrate", true ) ) {
+ lame_set_VBR( d->flags, vbr_abr );
+ lame_set_VBR_mean_bitrate_kbps( d->flags, c->readNumEntry( "Average Bitrate", 128 ) );
+ }
+ }
+
+ //
+ // Constant Bitrate
+ //
+ else {
+ lame_set_VBR( d->flags, vbr_off );
+ lame_set_brate( d->flags, c->readNumEntry( "Constant Bitrate", 128 ) );
+ }
+ }
+
+ else {
+ //
+ // In lame 0 is the highest quality. Since that is just confusing for the user
+ // if we call the setting "Quality" we simply invert the value.
+ //
+ int q = c->readNumEntry( "Quality Level", 5 );
+ if( q < 0 ) q = 0;
+ if( q > 9 ) q = 9;
+
+ kdDebug() << "(K3bLameEncoder) setting preset encoding value to " << q << endl;
+
+ if ( q < 2 || q > 8 ) {
+ lame_set_VBR( d->flags, vbr_abr );
+ }
+ else {
+ lame_set_VBR( d->flags, vbr_default );
+ }
+ lame_set_preset( d->flags, s_lame_presets[q] );
+
+ if( q < 2 )
+ lame_set_mode( d->flags, MONO );
+ }
+
+
+ //
+ // file options
+ //
+ lame_set_copyright( d->flags, c->readBoolEntry( "Copyright", false ) );
+ lame_set_original( d->flags, c->readBoolEntry( "Original", true ) );
+ lame_set_strict_ISO( d->flags, c->readBoolEntry( "ISO compliance", false ) );
+ lame_set_error_protection( d->flags, c->readBoolEntry( "Error Protection", false ) );
+
+
+ //
+ // Used Algorithm
+ //
+ // default to 2 which is the same as the -h lame option
+ // THIS HAS NO INFLUENCE ON THE SIZE OF THE FILE!
+ //
+ //
+ // In lame 0 is the highest quality. Since that is just confusing for the user
+ // if we call the setting "Quality" we simply invert the value.
+ //
+ int q = c->readNumEntry( "Encoder Quality", 7 );
+ if( q < 0 ) q = 0;
+ if( q > 9 ) q = 9;
+ lame_set_quality( d->flags, 9-q );
+
+ //
+ // ID3 settings
+ //
+ // for now we default to both v1 and v2 tags
+ id3tag_add_v2( d->flags );
+ id3tag_pad_v2( d->flags );
+
+ return( lame_init_params( d->flags ) != -1 );
+}
+
+
+long K3bLameEncoder::encodeInternal( const char* data, Q_ULONG len )
+{
+ // FIXME: we may have to swap data here
+ int size = lame_encode_buffer_interleaved( d->flags,
+ (short int*)data,
+ len/4,
+ (unsigned char*)d->buffer,
+ 8000 );
+ if( size < 0 ) {
+ kdDebug() << "(K3bLameEncoder) lame_encode_buffer_interleaved failed." << endl;
+ return -1;
+ }
+
+ return ::fwrite( d->buffer, 1, size, d->fid );
+}
+
+
+void K3bLameEncoder::finishEncoderInternal()
+{
+ int size = lame_encode_flush( d->flags,
+ (unsigned char*)d->buffer,
+ 8000 );
+ if( size > 0 )
+ ::fwrite( d->buffer, 1, size, d->fid );
+
+ lame_mp3_tags_fid( d->flags, d->fid );
+
+ lame_close( d->flags );
+ d->flags = 0;
+}
+
+
+void K3bLameEncoder::setMetaDataInternal( K3bAudioEncoder::MetaDataField f, const QString& value )
+{
+ // let's not use UTF-8 here since I don't know how to tell lame...
+ // FIXME: when we use the codec we only get garbage. Why?
+ QTextCodec* codec = 0;//QTextCodec::codecForName( "ISO8859-1" );
+// if( !codec )
+// kdDebug() << "(K3bLameEncoder) could not find codec ISO8859-1." << endl;
+
+ switch( f ) {
+ case META_TRACK_TITLE:
+ id3tag_set_title( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_TRACK_ARTIST:
+ id3tag_set_artist( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_ALBUM_TITLE:
+ id3tag_set_album( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_ALBUM_COMMENT:
+ id3tag_set_comment( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_YEAR:
+ id3tag_set_year( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_TRACK_NUMBER:
+ id3tag_set_track( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() );
+ break;
+ case META_GENRE:
+ if( id3tag_set_genre( d->flags, codec ? codec->fromUnicode(value).data() : value.latin1() ) )
+ kdDebug() << "(K3bLameEncoder) unable to set genre." << endl;
+ break;
+ default:
+ return;
+ }
+
+ if( lame_init_params( d->flags ) < 0 )
+ kdDebug() << "(K3bLameEncoder) lame_init_params failed." << endl;
+}
+
+
+
+
+
+K3bLameEncoderSettingsWidget::K3bLameEncoderSettingsWidget( QWidget* parent, const char* name )
+ : K3bPluginConfigWidget( parent, name )
+{
+ m_w = new base_K3bLameEncoderSettingsWidget( this );
+ m_w->m_sliderQuality->setRange( 0, 9 );
+ m_w->m_spinEncoderQuality->setRange( 0, 9, true );
+
+ m_manualSettingsDlg = new KDialogBase( this, 0, true,
+ i18n("(Lame) Manual Quality Settings") );
+ m_brW = new base_K3bManualBitrateSettingsWidget( m_manualSettingsDlg );
+ m_manualSettingsDlg->setMainWidget( m_brW );
+
+ for( int i = 0; s_lame_bitrates[i]; ++i )
+ m_brW->m_comboMaximumBitrate->insertItem( i18n("%1 kbps" ).arg(s_lame_bitrates[i]) );
+
+ for( int i = 0; s_lame_bitrates[i]; ++i )
+ m_brW->m_comboMinimumBitrate->insertItem( i18n("%1 kbps" ).arg(s_lame_bitrates[i]) );
+
+ for( int i = 0; s_lame_bitrates[i]; ++i )
+ m_brW->m_comboConstantBitrate->insertItem( i18n("%1 kbps" ).arg(s_lame_bitrates[i]) );
+
+
+ QHBoxLayout* lay = new QHBoxLayout( this );
+ lay->setMargin( 0 );
+ lay->addWidget( m_w );
+
+ // TODO: add whatsthis help for the quality level.
+ // QString qualityLevelWhatsThis = i18n("<p>");
+
+ connect( m_w->m_buttonManualSettings, SIGNAL(clicked()),
+ this, SLOT(slotShowManualSettings()) );
+ connect( m_w->m_sliderQuality, SIGNAL(valueChanged(int)),
+ this, SLOT(slotQualityLevelChanged(int)) );
+
+ updateManualSettingsLabel();
+ slotQualityLevelChanged( 5 );
+}
+
+
+K3bLameEncoderSettingsWidget::~K3bLameEncoderSettingsWidget()
+{
+}
+
+
+void K3bLameEncoderSettingsWidget::slotShowManualSettings()
+{
+ // save current settings for proper cancellation
+ bool constant = m_brW->m_radioConstantBitrate->isChecked();
+ int constBitrate = m_brW->m_comboConstantBitrate->currentItem();
+ int max = m_brW->m_comboMaximumBitrate->currentItem();
+ int min = m_brW->m_comboMinimumBitrate->currentItem();
+ int av = m_brW->m_spinAverageBitrate->value();
+ int mode = m_brW->m_comboMode->currentItem();
+
+ if( m_manualSettingsDlg->exec() == QDialog::Rejected ) {
+ m_brW->m_radioConstantBitrate->setChecked( constant );
+ m_brW->m_comboConstantBitrate->setCurrentItem( constBitrate );
+ m_brW->m_comboMaximumBitrate->setCurrentItem( max );
+ m_brW->m_comboMinimumBitrate->setCurrentItem( min );
+ m_brW->m_spinAverageBitrate->setValue( av );
+ m_brW->m_comboMode->setCurrentItem( mode );
+ }
+ else
+ updateManualSettingsLabel();
+}
+
+
+void K3bLameEncoderSettingsWidget::updateManualSettingsLabel()
+{
+ if( m_brW->m_radioConstantBitrate->isChecked() )
+ m_w->m_labelManualSettings->setText( i18n("Constant Bitrate: %1 kbps (%2)")
+ .arg(s_lame_bitrates[m_brW->m_comboConstantBitrate->currentItem()])
+ .arg(i18n(s_lame_mode_strings[m_brW->m_comboMode->currentItem()])) );
+ else
+ m_w->m_labelManualSettings->setText( i18n("Variable Bitrate (%1)")
+ .arg(i18n(s_lame_mode_strings[m_brW->m_comboMode->currentItem()])) );
+}
+
+
+void K3bLameEncoderSettingsWidget::slotQualityLevelChanged( int val )
+{
+ m_w->m_labelQualityLevel->setText( i18n(s_lame_preset_strings[val]) );
+}
+
+
+void K3bLameEncoderSettingsWidget::loadConfig()
+{
+ KConfig* c = k3bcore->config();
+ c->setGroup( "K3bLameEncoderPlugin" );
+
+ QString mode = c->readEntry( "Mode", "stereo" );
+ if( mode == "stereo" )
+ m_brW->m_comboMode->setCurrentItem( 0 );
+ else if( mode == "joint" )
+ m_brW->m_comboMode->setCurrentItem( 1 );
+ else // mono
+ m_brW->m_comboMode->setCurrentItem( 2 );
+
+ bool manual = c->readBoolEntry( "Manual Bitrate Settings", false );
+ if( manual )
+ m_w->m_radioManual->setChecked(true);
+ else
+ m_w->m_radioQualityLevel->setChecked(true);
+
+ if( c->readBoolEntry( "VBR", false ) )
+ m_brW->m_radioVariableBitrate->setChecked( true );
+ else
+ m_brW->m_radioConstantBitrate->setChecked( true );
+
+ m_brW->m_comboConstantBitrate->setCurrentItem( i18n("%1 kbps").arg(c->readNumEntry( "Constant Bitrate", 128 )) );
+ m_brW->m_comboMaximumBitrate->setCurrentItem( i18n("%1 kbps").arg(c->readNumEntry( "Maximum Bitrate", 224 )) );
+ m_brW->m_comboMinimumBitrate->setCurrentItem( i18n("%1 kbps").arg(c->readNumEntry( "Minimum Bitrate", 32 )) );
+ m_brW->m_spinAverageBitrate->setValue( c->readNumEntry( "Average Bitrate", 128) );
+
+ m_brW->m_checkBitrateMaximum->setChecked( c->readBoolEntry( "Use Maximum Bitrate", false ) );
+ m_brW->m_checkBitrateMinimum->setChecked( c->readBoolEntry( "Use Minimum Bitrate", false ) );
+ m_brW->m_checkBitrateAverage->setChecked( c->readBoolEntry( "Use Average Bitrate", true ) );
+
+ m_w->m_sliderQuality->setValue( c->readNumEntry( "Quality Level", 5 ) );
+
+ m_w->m_checkCopyright->setChecked( c->readBoolEntry( "Copyright", false ) );
+ m_w->m_checkOriginal->setChecked( c->readBoolEntry( "Original", true ) );
+ m_w->m_checkISO->setChecked( c->readBoolEntry( "ISO compliance", false ) );
+ m_w->m_checkError->setChecked( c->readBoolEntry( "Error Protection", false ) );
+
+ // default to 2 which is the same as the -h lame option
+ m_w->m_spinEncoderQuality->setValue( c->readNumEntry( "Encoder Quality", 7 ) );
+
+ updateManualSettingsLabel();
+}
+
+
+void K3bLameEncoderSettingsWidget::saveConfig()
+{
+ KConfig* c = k3bcore->config();
+ c->setGroup( "K3bLameEncoderPlugin" );
+
+ QString mode;
+ switch( m_brW->m_comboMode->currentItem() ) {
+ case 0:
+ mode = "stereo";
+ break;
+ case 1:
+ mode = "joint";
+ break;
+ case 2:
+ mode = "mono";
+ break;
+ }
+ c->writeEntry( "Mode", mode );
+
+ c->writeEntry( "Manual Bitrate Settings", m_w->m_radioManual->isChecked() );
+
+ c->writeEntry( "VBR", !m_brW->m_radioConstantBitrate->isChecked() );
+ c->writeEntry( "Constant Bitrate", m_brW->m_comboConstantBitrate->currentText().left(3).toInt() );
+ c->writeEntry( "Maximum Bitrate", m_brW->m_comboMaximumBitrate->currentText().left(3).toInt() );
+ c->writeEntry( "Minimum Bitrate", m_brW->m_comboMinimumBitrate->currentText().left(3).toInt() );
+ c->writeEntry( "Average Bitrate", m_brW->m_spinAverageBitrate->value() );
+
+ c->writeEntry( "Use Maximum Bitrate", m_brW->m_checkBitrateMaximum->isChecked() );
+ c->writeEntry( "Use Minimum Bitrate", m_brW->m_checkBitrateMinimum->isChecked() );
+ c->writeEntry( "Use Average Bitrate", m_brW->m_checkBitrateAverage->isChecked() );
+
+ c->writeEntry( "Quality Level", m_w->m_sliderQuality->value() );
+
+ c->writeEntry( "Copyright", m_w->m_checkCopyright->isChecked() );
+ c->writeEntry( "Original", m_w->m_checkOriginal->isChecked() );
+ c->writeEntry( "ISO compliance", m_w->m_checkISO->isChecked() );
+ c->writeEntry( "Error Protection", m_w->m_checkError->isChecked() );
+
+ // default to 2 which is the same as the -h lame option
+ c->writeEntry( "Encoder Quality", m_w->m_spinEncoderQuality->value() );
+}
+
+
+
+QStringList K3bLameEncoder::extensions() const
+{
+ return QStringList( "mp3" );
+}
+
+
+QString K3bLameEncoder::fileTypeComment( const QString& ) const
+{
+ return "MPEG1 Layer III (mp3)";
+}
+
+
+long long K3bLameEncoder::fileSize( const QString&, const K3b::Msf& msf ) const
+{
+ KConfig* c = k3bcore->config();
+ c->setGroup( "K3bLameEncoderPlugin" );
+ int bitrate = 0;
+ if( c->readBoolEntry( "Manual Bitrate Settings", false ) ) {
+ if( c->readBoolEntry( "VBR", false ) ) {
+ if( c->readBoolEntry( "Use Maximum Bitrate", false ) )
+ bitrate = c->readNumEntry( "Maximum Bitrate", 224 );
+ if( c->readBoolEntry( "Use Minimum Bitrate", false ) )
+ bitrate = ( bitrate > 0
+ ? (bitrate - c->readNumEntry( "Minimum Bitrate", 32 )) / 2
+ : c->readNumEntry( "Minimum Bitrate", 32 ) );
+ if( c->readBoolEntry( "Use Average Bitrate", true ) )
+ bitrate = c->readNumEntry( "Average Bitrate", 128 );
+ }
+ else {
+ bitrate = c->readNumEntry( "Constant Bitrate", 128 );
+ }
+ }
+ else {
+ int q = c->readNumEntry( "Quality Level", 5 );
+ if( q < 0 ) q = 0;
+ if( q > 9 ) q = 9;
+ bitrate = s_lame_preset_approx_bitrates[q];
+ }
+
+ return (msf.totalFrames()/75 * bitrate * 1000)/8;
+}
+
+
+K3bPluginConfigWidget* K3bLameEncoder::createConfigWidget( QWidget* parent,
+ const char* name ) const
+{
+ return new K3bLameEncoderSettingsWidget( parent, name );
+}
+
+
+#include "k3blameencoder.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-24 20:48:11 +0000