Of course I immediately ran

sudo aptitude install digikam

and installed diigkam 2.6.0 along with its necessary dependencies.

The Problem

Then I just ran

digikam

and I started, asked me some useful questions and then greeted me with:

QSqlDatabasePrivate::removeDatabase: connection 'ConnectionTest' is still in use, all queries will cease to work.
[0x2f86b90] main services discovery error: no suitable services discovery module
digikam: symbol lookup error: /usr/lib/qt4/plugins/phonon_backend/phonon_vlc.so: undefined symbol: libvlc_audio_filter_list_get

Normally I don’t pay attention to the messages in the terminal after starting a program (Hello, Iceweasel), but digikam was nice enough to crash, so that I would not distract me from the error message. How kind.

The Solution

When looking at the error message, you can see that the file “/usr/lib/qt4/plugins/phonon_backend/phonon_vlc.so” plays some role here. And playing around with aptitude you can find a package named “phonon-backend-vlc”. The package name matches the file having the problem quite nicely. I am convinced now, that the solution is to remove the package (be sure you do not need it):

sudo aptitude remove phonon-backend-vlc

Aptitude might then suggest to remove a bunch of other stuff as well (digikam among them), which I find counter-productive. So I just enter “n” the first few times until I am satisfied with the solution aptitude offers me:

The following actions will resolve these dependencies:

     Install the following packages:                   
1)     phonon-backend-gstreamer [4:4.6.0.0-2 (testing)]

That does not sound too bad, so I accept it.

When aptitude is done removing the phonon-backend-vlc package, I try it again:

digikam

And now it works.

Chances are you have seen the following error message (or else you would probably not have found this post):

Error: PHP Startup: Unable to load dynamic library '/usr/lib/php5/20100525/suhosin.so' -
/usr/lib/php5/20100525/suhosin.so: cannot open shared object file: No such file or directory in Unknown, line 0

I hope I am not the only one who lived with this message for a while, because everything was working as expected. But even though I never noticed any real problem, the message surely gets on your nerve after a while, so it’s time to make it go away…

The Solution

The solution is actually very easy. As mentioned on the Debian Bug Tracking System ages ago, all you need to do is to purge the suhosin package (the php5-suhosin package, to be precise):

sudo aptitude purge php5-suhosin

(In case you have not enabled sudo, just do the usual and run this command as superuser without the sudo.)

Enabling HTML5

Go to http://www.youtube.com/html5 and at the bottom you will see this:

Here you can see the capabilities of your browser and if you currently are in the HTML5 trial (which means HTML5 will be enabled). As you can see here, it states “You are not currently in the HTML5 trial”.

But directly below this statement, there is a link which reads “Join the HTML5 Trial”. When you click on it, HTML5 on Youtube will be enabled and the site will now look like this:

That’s it. You don’t need to do anything else. But one thing you should know is that the HTML5 based player will not work on all videos. Therefore, if you still happen to see the flash based video player on a lot of videos, it does not mean that enabling HTML5 did not work. It just means that those videos can not be presented to you using the HTML5 based player.

Check Which Player Is Used On A Specific Video

You can check if the HTML5 based player is used by right clicking on a video while it’s playing or paused. If the HTML5 based player is used, you will see something like this when right clicking on it):

The “About HTML5″ indicates that this is the HTML5 based player.

When the default Flash based played is used, the menu presented to you when right-clicking on the video will look like this instead (the version at the bottom will be different, but you can clearly see that it’s the “Adobe Flash Player” which is used):

Like I said, the HTML5 based player will not be used for every video and you might even be wondering if entering the HTML5 trial worked at all, because quite a lot of videos will still be played with the Flash based player. All I can tell you is: It does work! The number of videos that will be presented to you this way will probably increase over time.

http://www.tordeu.com/commands/md5sum

md5sum Command Overview (Cheat Sheet)

What Aliases Are

Here is a short introduction to aliases in case you have not idea what they are:

An alias is simply a different name for a specific command line command. You can call an alias like any other program and the shell will then replace the alias with the command it represents.

If you find yourself typing”aptitude” a lot you could, for example, define an alias “a” for this command instead. Now, instead of typing

aptitude install <package>

you just need to type

a install <package>

Bash will recognize that the command a is really just an alias that stands for “aptitude” and therefore replace a with “aptitude”. You could make your like even easier by assigning an alias “ai” to the command “aptitude install”. Then, when typing

ai <package>

bash will notice that the command “ai” is really just an alias for “aptitude install” and replace “ai” accordingly. Therefore, the command that bash will execute is:

aptitude install <package>

Permanently Storing Your Aliases

It is important to note than running the commands below will only change the alias definitions for the current shell. The changes will not appear in other shells and they will be lost when closing the shell (and logout/shutdown/reboot). This basically means that the changes are only temporary.

Therefore, if you want to permanently define new aliases, you can create new file named

.bash_aliases

in your homefolder (the file will most likely not exist already) and put all you alias definitions in there. Alternatively you can add the definitions to the file

.bashrc

in your home folder, but it’s cleaner to have a separate file for the aliases and the .bashrc should already check for a file named .bash_aliases, so you only need to create the .bash_aliases and the file will automatically loaded.

It is important to note that the .bashrc and therefore the .bash_aliases will only be read when the shell is created. Therefore, you won’t see the changes to .bash_aliases immediately. You need to either create a new shell after saving your modified .bash_aliases or (re)load the .bash_aliases file like this:

. ~/.bash_aliases

You can, of course, create an an alias for this command in your .bash_aliases file…

List All Aliases

To get a list of all aliases which are currently defined, all you need to do is to run:

alias

This will list all defined aliases, one per line, like this:

alias la='ls -la'
alias ls='ls --color=auto'
alias lx='ls -lAh --group-directories-first'

List A Specific Alias

To only get the value of a specific alias, you can type:

alias <name>

You can also use this command to display several aliases:

alias <name1> <name2> ...

Example 1

alias la

will display

alias la='ls -la'

Example 2

alias ls la

will display:

alias ls='ls --color=auto'
alias la='ls -la'

Create A New Alias / Change An Existing Alias

Creating a new alias or changing the value of an existing alias can be done in the same way:

alias <name>=<value>

For example, creating an alias “www” to avoid typing “cd /var/www” all the time, can be done like this:

alias www='cd /var/www'

Combining Aliases

When defining an alias it is possible to use another alias. Let me show you two examples of how this might be put to use:

Supplying (additional) options

The only predefined alias on Debian is

ls='ls --color=auto

By defining an alias la like this:

alias la='ls -la'

You already used an alias for defining the new alias. When typing

la

bash will now recognize that “la” is an alias and replace it with its value:

ls -la

But now, again, bash will recognize that “ls” is an alias as well and replace this will its value “ls –color=auto”, which results in the command:

ls --color=auto -la

(bash will not recognize ls an alias again, so this is where it stops)

In this example the alias “la” used the already defined alias “ls” (which adds coloring to the command ls) to add the additional options “-l” and “-a” to it. This can be used for various purposes. If you want to define various aliases for the ls command, for example, it might be a good idea to create an alias that already contains the common options (like coloring) you want to use for all the other aliases. This will shorten the alias values, which makes them easier to manage. Instead of defining the following aliases:

alias la='ls -la --color=auto'
alias lh='ls -lh --color=auto'
alias lx='ls -lAh --color=auto --group-directories-first'

you could define them like this:

alias la='ls -a'
alias lh='ls -h'
alias ls='ls -l --color=auto'
alias lx='lh -A --group-directories-first'

In this example the alias ls already carried the “-l” and “–color=auto” option, therefore avoiding the others to specify them as well. The definition of the lx alias uses the lh alias, which additionally carries the “-h” option. You should be careful when using this approach, because creating two many connections between aliases can make management more complicated instead of simplifying it and also create some unwanted side effects.

 Supplying (additional) arguments

Similar to applying additional command line options, you can supply additional arguments to

Delete An Alias

To delete an alias you need to use the unalias command:

unalias <name>

It is also possible to delete several aliases at once:

unalias <name1> <name2> ...

Example

To delete the www alias that we just created, type:

unalias www

you will be surprised that if offers you the possibility to change the time the system has to be idle for the monitor to be turned off from 1 minute to 1 hour. But what is missing is an option to turn this function off entirely.

Fortunately, it is possible to do that, just not in System Settings and you can either do that from command line or with a GUI.

Explanation

I will not explain GSettings here, but just in case you don’t know: GSettings (which replaces GConf) is used to store the configuration of the GNOME desktops. Don’t worry, you don’t need to know GSettings to follow the instructions below. But GSettings is also used to store the information about when to turn off the display. The keys that are important here are the following:

org.gnome.settings-daemon.plugins.power sleep-display-ac
org.gnome.settings-daemon.plugins.power sleep-display-battery
org.gnome.desktop.session idle-delay

Those are the keys that the System Settings GUI is changing when you use it.

The first two determine when the display is turned off (on a desktop system that is always plugged in the first value is the important one. The second key is used in case the system is running on a battery, which is important for portable devices like notebooks and tablets).

The third key is important, because it is used to determine when to start the screensaver and lock the screen, although there are additional values that target those two in org.gnome.desktop.session.

The values of all three keys are in seconds (so a value of 600 stands for 600s = 10min).

But because the System Settings GUI does change these three keys altogether and there is a connection between these three, it is probably a good idea for most people to change all three to the same value by hand as well.

Using Command Line

You can use the gsettings command to change the values of the keys.

First, let’s see what the values of these keys are. You can do that by running the following three commands.

gsettings get org.gnome.settings-daemon.plugins.power sleep-display-ac
gsettings get org.gnome.settings-daemon.plugins.power sleep-display-battery
gsettings get org.gnome.desktop.session idle-delay

Each command will print the value of the given key. You will notice (most likely) that all three values are equal and that they reflect the value that is displayed in System Settings. If you change the value in System Settings, you will notice that these three keys do change accordingly.

To set these by hand you can use the following three commands:

gsettings set org.gnome.settings-daemon.plugins.power sleep-display-ac <value>
gsettings set org.gnome.settings-daemon.plugins.power sleep-display-battery <value>
gsettings set org.gnome.desktop.session idle-delay <value>

Just replace <value> with the number of seconds you want the system to wait before turning off the display (and potentially locking the screen). To tell the system that it should let the display turned on forever, you can use the value 0:

gsettings set org.gnome.settings-daemon.plugins.power sleep-display-ac 0
gsettings set org.gnome.settings-daemon.plugins.power sleep-display-battery 0
gsettings set org.gnome.desktop.session idle-delay 0

Using A GUI

To change the keys you can use “dconf Editor “. You can start the program by one of the following ways:

• go to Applications and either
• search for dconf or
• look for it under “System Tools” or
• press Alt+F2 and enter: dconf-editor or
• open a terminal and run “dconf-editor”

Once dconf Editor starts, you will see the following window:

The dconf-editor window after starting the I

On the left side you now need to navigate to “org.gnome.settings-daemon.plugins.power” (that means: open “org”, then – within “org” – open “gnome” and so on until you reach “power”). Then, you need to find the keys “sleep-display-ac” and “sleep-display-battery” on the right side:

The dconf-edtior window after navigating to the first key

Change both numbers to 0 to prevent the system from turning off the display.

After that you should navigate to “org.gnome.desktop.session” on the left side and change the key “idle-delay” (on the right side) to 0 as well.

After that, just quit the editor (the changes are automatically saved).

When using a virtual machine in VirtualBox you might want to switch to a different console by hitting

where <n> stands for the number of the console you want to access (like Ctrl+Alt+F1 to get a text console and Ctrl+Alt+F7 to get back to your X session).

Unfortunately, key combinations with Ctrl+Alt like the mentioned Ctrl+Alt+F<n> or Ctrl+Alt+Del will not be sent to the guest operating system. Instead, Ctrl+Alt+F<n> will only let you change consoles on your host and Ctrl+Alt+Del will magically disappear and effect neither the host nor the guest OS.

VirtualBox offers two menu entries (under the menu entry “Machine”) to send Ctrl+Alt+Del and Ctrl+Alt+Backspace to the guest OS, but does not offer such a feature for other key combinations.

Solution

Fortunately, you can use the host key (the right Ctrl key by default) as a substitute for Ctrl+Alt. Therefore when pressing

HOST+F<n>

VirtualBox will send

to the guest OS and this will let you change consoles in your guest and also use other key combination that include Ctrl+Alt.

Links

https://www.virtualbox.org/manual/ch01.html#idp7685232

There are several ways one can batch rename files in Linux. One of the possibilities is the linux command rename.

Usage

To rename files you have to supply a Perl expression. Using Perl expressions might be scary for beginners (because they look like someone hit his head on the keyboard), but they allow for complex renaming with a minimum of characters.

Although I won’t go into detail about Perl expressions here, I will try to make it a little easier for beginners to use them for batch renaming.

According to the man page of rename, this is the way to use rename:

rename [ -v ] [ -n ] [ -f ] perlexpr [ files ]

If you have not worked with Perl expressions before, this might not be enough to get you started. So let me present you with the way one would probably use rename most of the time:

rename 's/OLD/NEW/' FILES

OLD is an expressions which describes a pattern in the name filenames. If rename can find this pattern in the name of a file, it will replace this part of the filename with what is defined as NEW. The files rename should rename are defined by FILES.

Let me provide you with two examples:

Examples

Example 1 – Replacing a single word/string

Let’s start with a very simple example: Imagine, you have a lot of images that are named

picture 1.jpg
picture 2.jpg
...

and you would like to replace the word “picture” with the word “image”, so that the files will be named like this:

image 1.jpg
image 2.jpg
...

As describes under usage, OLD represents the part that we want to replace. As we want  to replace the word “picture”, in this example OLD will be “picture”.

And because NEW defines with what OLD is replaced with, in our example. We want the OLD(=”picture”) to be replaced with “image”, so here NEW=”image”.

And because we want to do this only for all the pictures which name starts with “picture” FILES will be “picture*.jpg”.

Therefore the general command

rename 's/OLD/NEW/' FILES

becomes:

rename 's/picture/image/' picture*.jpg

It might have not been necessary for us to restrict this to the the files “picture*.jpg”. We might have just used *.jpg (all files in the current directory with the extension .jpg) or even * (all files in the current directory), because rename will only change the filename, if the pattern OLD (here: “picture”) is found in the filename. You have to be careful, though. A file with the name “just a picture.jpg” would have been renamed to “just a image.jpg”, because we told rename to replace “picture” with “image”.

Example 2

Let’s go back to Example 1. One problem I mentioned is that running

rename 's/picture/image' *.jpg

to rename files like “picture 23.jpg” to “image 23.jpg” would also rename files like “just a picture.jpg” to “just a image.jpg”, because rename would find the word “picture” and replace it with “image”, although this is not what we intended.

We could prevent this by calling rename like this:

rename 's/picture/image' picture*.jpg

This would call rename only for the .jpg files starting with the word “picture”. But this is not really a solution, because files like “picture of a sunset.jpg” would still be renamed to “image of a sunset.jpg”.

To make sure that rename really does what we want it to do, we need to be very clear about what should be renamed. Because what we want is not to replace the word “picture” with the word “image” in every case, we want to replace the word “picture” with the word “image”, but only for the files which name consists of the word “picture”, then a space and then a number and then the extension “.jpg”.

This can be achieved with the following command:

rename 's/^picture( [0-9]*\.jpg)$/image$1/' *.jpg

This might look a little scary, but is a good example of what you can do with Perl expressions. Because this would only rename the desired files. Files like “my picture 11.jpg” or “picture 28 (beach).jpg” would not be renamed and in this example that is exactly what we want to do.

Let me go through the different parts of the expression above briefly, to give you an idea of how this works. Keep in mind that this just an example and not intended as a complete tutorial. I will just try to explain to you the various elements of this expression to show you some of the possibilities and to demystify them a little bit.

When you compare the command to the general form under “Usage”, you will see that in this case:

• OLD = ^picture( [0-9]*\.jpg)$
• NEW = image$1
• FILES = *.jpg

In this example OLD makes sure that only the desired files are renamed by defining the structure of what we are looking for exactly. This works, because OLD defines what should be renamed. That means that files where the pattern/structure defined by OLD can not be found will not be renamed. Therefore, OLD automatically works as a filter to make sure that only the desired files get renamed. The trick is to make sure that OLD and NEW reflect what you wish to do. Let’s dissect it:

Let’s ignore the “^” at the beginning, the “$” at the end, the parentheses and the “\”  at the moment. This leaves the following:

picture [0-9]*.jpg

This describes our basic structure. First, we have the word “picture”, then a space. [0-9] means any character from 0 to 9, which essentially means “a digit” and when putting a “*” after it, it means that there can be “any number of” digits. We need this, because we don’t know how many digits there will be. We can have files like “picture 7.jpg”, where there is only 1 digit or files like “picture 1432.jpg”, where he have four of them. So, “[0-9]*” stands for “any number of digits”, which just means: a number. And then we have “.jpg”, our extensions.

It is important to note that  “[0-9]*” really means “any number of digits” and that “any number” could also mean 0. This means that the number is optional and a file named “picture .jpg” would also be renamed. In this example it probably would not make a real difference, but in general you need to be careful. If there really has to be a number and it can not be optional, you can use a “+” instead of a “*”, because “[0-9]+” means “at least one digit”.  But because it will not be a problem in this case, we will keep the “*”.

Now, let’s add the parts we ignored:

The “.” is a special character which stand for “any character”. But in our pattern, we want to make clear that the filename ends with “.jpg”. But “.jpg” would be interpreted as “any character, then j, then p, then g”. Therefore a file like “picture 234Xjpg” would be renamed, because the . (which stand for “any character”) would be “X” in this case. But really want to make sure that the file ends with “.jpg” and therefore need to make it clear that the “.” really stand for “.” and not for “any character”. This can be done by escaping it with a “\”. Therefore, we need to write “\.jpg”.

The parentheses are added, because the pattern we are creating will be matching the complete filename. If we would run a command like this:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

A file like “picture 23.jgp” would be renamed to “image” and not to “image 23.jpg”. This is because our pattern “^picture [0-9]*\.jpg$” describes the whole filename. So the complete filename would be replace with “image”. But we just want to replace “picture” and keep the rest.

We can do this by telling rename that we want to keep everything after “picture”. While we can’t do this directly, we can put every after “picture” in parentheses and then later use this part to build our new filename, because everything within the parentheses will be saved accessible later as “$1″, so if we use the pattern

picture( [0-9]*\.jpg)

We can now see that the space, the number and the extension “.jpg” are within the parentheses and we can access this part as “$1″. When the filename is “picture 83.jpg”, $1 will therefore contain ” 83.jpg”. Then, when we define our replacement, we can tell rename to use “image$1″ as our replacement for the filename. Because $1 contains the space, the number and the extension, this would translate to “image 83.jpg”.

Now, what’s left are “^” and “$”. “^” stand for the beginning of the filename. This makes sure that files like “some picture 44.jpg” would not be renamed. This is because a pattern like “picture” means: find the word picture anywhere. Whereas “^picture” essentially means: find the word picture at the beginning of the input(=filename).

Similarly, “$” stand for the end of the input (here: filename). We use this to make sure that something like “picture 74.jpg.gz” does not get renamed.

Combining “^” and “$” therefore ensures that the filename only consists of the pattern we defined and there is nothing before “picture” and nothing after our “.jpg”.

Therefore, our final pattern is:

^picture( [0-9]*\.jpg)$

And the command to rename the files is, again:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

Example 4 – add a prefix to all filenames (added on 2012-05-20)

In case you want to add a prefix at the beginning of a filename, you can use this line:

rename ‘s/(.*)/PREFIX$1/’ FILES

Substitute PREFIX to whatever you want to put in front of the filename and substitute FILES for the files you want to rename (see Example 6 below for some examples)

If you run

rename ‘s/(.*)/foo_$1/’ *.txt

All the .txt files in the current directory will get an “foo_” in front of of their name. (So info.txt would be renamed to foo_info.txt, for example)

Example 5 – add a suffix to all filenames (added on 2012-05-20)

Adding a suffix at the end of a filename can be as simple as adding a prefix; you could simply run:

rename 's/(.*)/$1SUFFIX/' FILES

The problem is that this might not be what you expected, because the suffix will be added at the end of the filename, which also means after the suffix the file might already have to denote its type (e.g. “.txt”, “.tar”, “.jpg” etc. Running

rename 's/(.*)/$1boo/' info.tar

would rename the file “info.tar” to “info.tar.boo”. If that is what you want, you can use the line above, but if you would want to rename it to “infoboo.tar”, then you can use the following line:

rename 's/(.*)\.(.*)/$1SUFFIX.$2/' FILES

with this, running

rename 's/(.*)\.(.*)/$1boo.$2/' FILES

would rename “info.tar” to “infoboo.tar”.

Be aware that this will not work for files with suffixes that contain two dots (like “archive.tar.gz”).

Improvement 1 (Update 2012-05-22):

The fact that files like “archive.tar.gz” would be renamed as well and the result would certainly not be as hoped, we can try to improve the pattern above a little bit:

rename 's/^([^.]*)\.([^.]*)$/$1SUFFIX.$2/' FILES

This approach will only rename files that only contain a single dot and leave all other files alone.

Improvement 2 (Update 2012-05-22):

If you want to rename files with extensions like “.tar.gz” correctly, you can use the following approach:

rename 's/^([^.]*)\.(.*)$/$1SUFFIX.$2/' FILES

This will essentially add the suffix directly in front of the first dot. However, this approach will not work in case you have files that contain dots that are not supposed to be part of the file extension (in “some.great.file.txt”, the suffix “111″ would be added like this: “some111.great.file.txt”)

Example 6 – how to define which files to rename (added on 2012-05-20)

In the beginning I noted the general form of how to use rename:

rename 's/OLD/NEW/' FILES

I now want to give you some simple examples of what you can do with “FILES”, which tells rename which files it
should try to rename in the first place. This list is by no means complete. It just provides you with a few (hopefully useful) examples.

• to rename a single file just state its name. Example: backup.tar
• to rename several specific files just list all their names. Example: backup.tar mypicture.jpg asong.ogg
• to rename all files in the current directory just use “*” (without the “).
• to rename all files with a specific ending (e.g. .jpg) use “*ENDING”. Example: *.jpg
• to rename files with different endings, just list them all. Example: *.jpg *.jpeg *.mp3 *.txt *.ar
• to rename files that start with the same word/characters use “START*”. Example: my* old*
• to rename files that contain the same word/sequence of characters use “*WITHIN*”. Example: *good*
• you can combine all of those things. Example: my*.txt *boo*.jpg foo* test.tmp

Conclusion

I hope that this article succeeds in demonstrating how rename can be used to batch rename files (not in detail, but at least in pushing you in the right direction). And I also hope that while covering Perl expressions in detail is beyond the scope of this article, the second example gives you an idea of how powerful and useful they can be and why it can make sense to learn more about them.

When converting FLAC files to MP3, the first problem you will notice is that lame does not support FLAC files. This might now seem like big problem, because you can easily decode FLAC files using the command line tool flac and then use the decoded file with lame.

The Problem

The real problem is that you will loose your metadata in this process, so the tags you added to your FLAC won’t be copied to the MP3 file. While you could “easily” add them by hand, it is pretty annoying to do that even if you only want to convert a handful of files.

The solution

The solution is to extract the metadata from the FLAC file using metaflac and to use the options lame provides to inject the tags into the MP3 file when calling lame.

Note:

This section is merely provided to explain the steps involved. You do not need to read this nor do you need to do this by hand, since I offer you a small script that will do these steps for you (look at the very first line of the article or below under “Download” to download the script).

Step 1 – Extract the Metadata

To extract a single tag, you can use metaflac like this:

metaflac --show-tag=<tag> <file>

To extract the artist of the track from the file named “1 – Let It In.flac”, you could call:

metaflac --show-tag=ARTIST "1 - Let It In.flac"

In general you will get a result like this:

<TAG>=<VALUE>

In the mentioned example you might get the following:

ARTIST=Josh Woodward

 Step 2 – Fomat the Metadata

We only need the name of the artist, so we need to get rid of  “ARTIST=”. This can be easily achieved with sed.  The general way of replacing something with sed is this:

sed 's/OLD/NEW/'

OLD is the part that you want to replace and NEW is the part that you want to replace it with. What we want to replace is “ARTIST=” (which is our OLD) and what we want to replace it with is nothing (which will essentially remove OLD), so our NEW is empty. And this is what we get:

sed 's/ARTIST=//'

But that would only work for the ARTIST tag. A general solution would be to remove anything up to and including the equal sign. I won’t go into detail on this one, but this would be achieved by setting OLD to “.*=” and the line would look like this:

sed 's/.*=//'

To make this work, we need to we need to pass the output of metaflac to our sed command, which we would do like this:

metaflac --show-tag=ARTIST "1 - Let It In.flac" | sed 's/.*=//'

This way the output of metaflac (“ARTIST=Josh Woodward”) is send to our sed command, which then removes the “ARTIST=” part and thus we get the output:

Josh Woodward

Step 3 – Store the tag

While the line from Step 2 works, it merely prints the tag. What we need to do is to store the tag somehow, so that we can use it again later for adding the tag to the MP3 file. To store the output of a command in a variable, you generally type:

<var>=`<command>`

(Those are not single quotes in this line, but backticks/grave accents) This will execute <command> and then store the output to the variable <var>.

In this example we could do this:

ARTIST=`metaflac –show-tag=ARTIST “1 – Let It In.flac” | sed ‘s/.*=//’`

This would execute out metaflac command and save the output (“Josh Woodward”) in the variable ARTIST.

We can test if everything worked by printing the value of ARTIST:

echo $ARTIST

which should now give us:

Josh Woodward

Step 4 – Passing the tags to lame

In general, calling lame (and using VBR mode) would work like this:

lame -V <oldfile> <mp3file>

If you want lame to save metadata to the mp3 file, you can use several options do to this. To continue our example, let’s assume we want to add the name of the artist (that we have stored in the variable ARTIST in the last step) to the new MP3 file. This can be done with the –ta option:

lame -V --ta "$ARTIST" <oldfile> <mp3file>

In a similar way, we can add other tags to the mp3 file as well. Here is a small table that shows you the options lame offers to add metadata, the name of the FLAC tag that theese options correspond to and what they mean.

Step 5 – Passing the FLAC to lame

We have not solved the original problem yet: you can not pass a flac file to lame. We could decode the FLAC to WAV and then pass the WAV file to lame, but we don’t need do really create a WAV file, because we can just decode the FLAC and pass the decoded data directly to lame. To do this, we need to call flac with two options:

• -d to tell it we want to decode a flac file
• -c, so that the decoded data is not written to a file, but to stdout

Then, we can tell lame that it should read the data from stdin instead of from a file, which can be done by providing a dash for the <oldfile> parameter. Now we can connect them both with a pipe and the decoded flac data will directly flow into our lame command:

flac -c -d <flacfile>| lame - <mp3file>

In our example, we would get something like this (which includes adding the ARTIST tag and a VBR quality of 6):

flac -c -d "1 - Let It In.flac" | lame -V 6 --ta "$ARTIST" - "1 - Let It In.mp3"

Now that the basic  steps involved are covered, we can let a script do the work.

The Script

I wrote a small script that converts a FLAC file to MP3 while preserving  the following tags (=all the tags listed in “Step 4″ above):

• Track Title
• Track Artist
• Album Title
• Year
• Comment
• Tracknumber
• Total number of tracks
• Genre

Download

You can download the script here: flac2mp3.sh

Usage

The script takes three arguments:

• The VBR quality (This corresponds to the -V option of lame, which means that you can use a number between 0 and 9, with smaller numbers meaning higher quality and bigger files). If you omit this option, -V 4 will be used.
• The filename of the FLAC file you want to convert
• The filename of the new MP3 file that you want to create.
• You can (but don’t have to) add “mtime” as the fourth argument in which case the script will not start the conversion if the MP3 file is newer than the FLAC file, which indicates that a conversion is not necessary. (If you don’t add “mtime”, the script will convert the files no matter what)

Example:

If you want to convert the file “1 – Let It In.flac” to “1 – Let It In.mp3″ with a VBR quality level of 3, you would call the script like this:

flac2mp3.sh 3 "1 - Let It In.flac" "1 - Let It In.mp3"

flac2mp3.sh 3 "1 - Let It In.flac" "1 - Let It In.mp3" mtime

Source

The script generally works as described under “The Solution”, but instead of repeating the line from “Step 3″ for every tag, it uses a more elegant approach (which in this case just means less code). But instead of posting the complete source code (which you can look at by download the script), let me just show you  the meat of the script (extracting the 8 tags and passing them to lame for conversion):

for tag in TITLE ARTIST ALBUM DATE COMMENT TRACKNUMBER TRACKTOTAL GENRE; do
    eval "$tag=\"`metaflac --show-tag=$tag "$FLAC" | sed 's/.*=//'`\""
done

flac -cd "$FLAC" | lame -V "$V" --tt "$TITLE" --ta "$ARTIST" --tl "$ALBUM" --ty "$DATE" --tc "$COMMENT" --tn "$TRACKNUMBER/$TRACKTOTAL" --tg "$GENRE" - "$MP3"

Update (2012-06-05)

I have updated the script a little. It’s now possible to append a “mtime” after the three arguments. When adding “mtime”, the script will only start the conversion if the MP3 file does not exist yet or the FLAC file is newer than the MP3 file.

This will avoid unnecessary conversions in case the MP3 is newer than the FLAC file, which indicates it is up-to-date. This is useful when using this script to somehow manage your library as it will reduce a large number of conversions.