Hydrogenaudio Knowledgebase - User contributions [en]

Rubyripper

2007-07-08T19:38:06Z

Frodoontop: update for 0.4.2 release

Rubyripper

2007-06-23T12:17:40Z

Frodoontop: Update for 0.4.1 version.

Rubyripper

2006-12-07T17:55:44Z

Frodoontop: /* Development progress */

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
These screenshots are taken with the 0.3 release:
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/cddb-info.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/codecs.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/other-settings.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/ripping-settings.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/status-window.png The status window]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and aren't difficult to make, once you know your gui toolkit. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. From a starting point it would be best to use the current GTK2 or CLI code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

The basic idea is that the gui first presents the info of a Cddb instance. And when the user wants to start, a new Rubyripper instance is started with all the settings in a Hash as a parameter. You can copy most of the code from the other user interfaces. The user interface should also have an update function. This is used as a communication channel of the Rubyripper instance.

# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* reworking the Secure_rip class to allow partial reripping tracks with problems. This will be a time savior for hard to rip cd's. However, the implementation is not so simple. Now that 0.3 version is released, work is started on this. Minimum ripping size will be +/- 2,5 MB to prevent cache problems.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-12-06T12:19:53Z

Frodoontop: /* Introduction */

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
These screenshots are taken with the 0.3 release:
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/cddb-info.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/codecs.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/other-settings.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/ripping-settings.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/status-window.png The status window]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and aren't difficult to make, once you know your gui toolkit. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. From a starting point it would be best to use the current GTK2 or CLI code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

The basic idea is that the gui first presents the info of a Cddb instance. And when the user wants to start, a new Rubyripper instance is started with all the settings in a Hash as a parameter. You can copy most of the code from the other user interfaces. The user interface should also have an update function. This is used as a communication channel of the Rubyripper instance.

# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. It was improved by opening the main window with a fixed size. The tracklist becomes scrollable, if it is to large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* He also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. The task that is being decided upon is, which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-12-06T12:19:20Z

Frodoontop: /* Screenshots */

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
These screenshots are taken with the 0.3 release:
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/cddb-info.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/codecs.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/other-settings.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/ripping-settings.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/status-window.png The status window]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and aren't difficult to make, once you know your gui toolkit. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. From a starting point it would be best to use the current GTK2 or CLI code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

The basic idea is that the gui first presents the info of a Cddb instance. And when the user wants to start, a new Rubyripper instance is started with all the settings in a Hash as a parameter. You can copy most of the code from the other user interfaces. The user interface should also have an update function. This is used as a communication channel of the Rubyripper instance.

# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. It was improved by opening the main window with a fixed size. The tracklist becomes scrollable, if it is to large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* He also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. The task that is being decided upon is, which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-12-06T12:12:54Z

Frodoontop: /* Screenshots */ Updated for 0.3 release

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
These screenshots are taken with the 0.3 release:
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/cddb-info.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/codecs.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/other-settings.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/ripping-settings.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/0.3/status-window.png The status tab]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and aren't difficult to make, once you know your gui toolkit. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. From a starting point it would be best to use the current GTK2 or CLI code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

The basic idea is that the gui first presents the info of a Cddb instance. And when the user wants to start, a new Rubyripper instance is started with all the settings in a Hash as a parameter. You can copy most of the code from the other user interfaces. The user interface should also have an update function. This is used as a communication channel of the Rubyripper instance.

# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. It was improved by opening the main window with a fixed size. The tracklist becomes scrollable, if it is to large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* He also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. The task that is being decided upon is, which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-12-04T22:12:20Z

Frodoontop: /* Adding a new frontend */ deleting some obsolete info, was too much anyway

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

==Rubyripper Guides==
* [[Rubyripper Debian and Ubuntu Based Distro Installation]] guide for installing Rubyripper on Debian/Linux platforms.

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and aren't difficult to make, once you know your gui toolkit. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. From a starting point it would be best to use the current GTK2 or CLI code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

The basic idea is that the gui first presents the info of a Cddb instance. And when the user wants to start, a new Rubyripper instance is started with all the settings in a Hash as a parameter. You can copy most of the code from the other user interfaces. The user interface should also have an update function. This is used as a communication channel of the Rubyripper instance.

# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. It was improved by opening the main window with a fixed size. The tracklist becomes scrollable, if it is to large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* He also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. The task that is being decided upon is, which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-12-04T22:04:39Z

Frodoontop: /* Introduction */ update for the 0.3 release

{{Infobox Software
| name = Rubyripper
| screenshot = [[Image:Rubyripper-screenshot.png|100px]]
| caption = Open-source secure ripper for Linux
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux, BSD should work but is untested. OS X can be supported in the near future if some tester stands up. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.3 was released on 4 December 2006.'''
* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''cd-discid'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair. Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''cd-discid'', ''ruby-libglade2'' and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=8282

See the README file for installation instructions or just type: make install

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
Please post any ideas, bugs or wishes at the Google bug tracker.
* http://code.google.com/p/rubyripper/issues/list

==Known Bugs==
* <none>

==Rubyripper Guides==
* [[Rubyripper Debian and Ubuntu Based Distro Installation]] guide for installing Rubyripper on Debian/Linux platforms.

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. He won't implement this himself though, due to the fact that he is more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. He doesn't use any new features, therefore it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

SVN Checkout now possible. 
Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

If you're ready, please contact him at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. Being the only lead developer, the hope is you will be consistent with the current GTK2 interface design. If there are valid reasons to make any adjustments, please consult with him first. From a starting point it would be best to use the current GTK2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

What requirements would code for a new GUI have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> <code>'require ./rr_lib.rb'</code>
# Make a class of the GUI code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from <code>$HOME/rubyripper_settings</code> if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the GUI. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the GUI.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class. This is done by passing the settings Hash as an argument. ''(In other languages sometimes called a dictionary)''
# The hash should contain all settings: <code>
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped) </code>
# All communication back to the GUI happens via the update function, that should be in the GUI, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* <code>ripping_progress</code>. value is a float. <math>100 % = 1.0. </math> Used to update the progress bar.
#* <code>encoding_progress</code>. value is a float. <math>100 % = 1.0.</math> Used to update the progress bar.
#* <code>log_change</code>. value is a string. Used to update the status screen.
#* <code>track_finished.</code> value is an integer. Used to deselect the track in the GUI.
#* <code>finished.</code> value is not important. This means that the ripping and encoding are finished. Used to unlock the GUI-buttons.
#* <code>error.</code> value is a string. Used to bring up a popup window with the error message.
#* <code>cddb_hit.</code> value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is an effective way of getting a responsive GUI.

== Mac OS/X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows Mac OS/X [[core audio]] very well and can test any code if needed is a necessity. The main differences with Mac OS/X and Linux support are:

* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
This section was added in order to figure out the right way to implement features into Rubyripper.
Currently work is being done on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. It was improved by opening the main window with a fixed size. The tracklist becomes scrollable, if it is to large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* He also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. The task that is being decided upon is, which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Talk:Rubyripper

2006-11-01T20:48:40Z

Frodoontop: A big thanks to HotShotGG

@HotShotGG: I really appreciate the work you're doing. As English is not my native language and my time is limited, I naturally make (hopefully small) mistakes. Your latest changes seem to be an improvement as well. I didn't realize that a personal viewpoint of writing isn't all that professional ;)

Rubyripper

2006-10-27T20:57:01Z

Frodoontop: /* Installation */ Add notion of svn source

{{Infobox Software
| name = Rubyripper
| screenshot =
| caption =
| maintainer = Bouke Woudstra
| stable_release = 0.2
| preview_release = 0.1.1
| operating_system = Linux
| use = Digital Audio Extraction
| license = GPL
| website = [http://rubyforge.org/projects/rubyripper/ Rubyforge Website]
}}

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''. The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

SVN Checkout now possible. I finally got my lazy a** to set it up. It wasn't that difficult after all :) Use: <code>svn checkout http://rubyripper.googlecode.com/svn/trunk/ rubyripper </code> to get the latest source code.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. I won't implement this myself though, due to the fact that I am more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. I don't use any new features, therefore I think it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

If you're ready, please contact me at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. Being the only lead developer, I hope you will be consistent with the current GTK2 interface design. If there are valid reasons to make any adjustments, please consult with me first. From a starting point it would be best to use the current GTK2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

What requirements would code for a new GUI have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> <code>'require ./rr_lib.rb'</code>
# Make a class of the GUI code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from <code>$HOME/rubyripper_settings</code> if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the GUI. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the GUI.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class. This is done by passing the settings Hash as an argument. ''(In other languages sometimes called a dictionary)''
# The hash should contain all settings: <code>
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped) </code>
# All communication back to the GUI happens via the update function, that should be in the GUI, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* <code>ripping_progress</code>. value is a float. <math>100 % = 1.0. </math> Used to update the progress bar.
#* <code>encoding_progress</code>. value is a float. <math>100 % = 1.0.</math> Used to update the progress bar.
#* <code>log_change</code>. value is a string. Used to update the status screen.
#* <code>track_finished.</code> value is an integer. Used to deselect the track in the GUI.
#* <code>finished.</code> value is not important. This means that the ripping and encoding are finished. Used to unlock the GUI-buttons.
#* <code>error.</code> value is a string. Used to bring up a popup window with the error message.
#* <code>cddb_hit.</code> value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is an effective way of getting a responsive GUI.

==OS X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows OS X very well and can test any code if needed is a necessity. The main differences with OS X and Linux support are:
* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

=Development progress=
I added this section in order to figure out the right way to implement features into Rubyripper.
I am currently working on:
* The tracklist presentation. Someone on the forums suggested, the interface isn't perfect. I improved it by opening the main window with a fixed size. The tracklist becomes scrollable, if it is too large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window was added, instead of a tab. This can be seen in the previous screenshots.
* I also removed the status bars and the status tab from the main view. They were moved to a separate ripping window, like [[EAC]]. I am still working on which buttons should remain visible. If you have any ideas how to improve the GUI shown in the next screenshot, feel free to share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.rarewares.org/debian/packages/unstable/rubyripper_0.2-0rarewares1_i386.deb Debian Package] unstable Debian compile of Rubyripper.
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

[[Category:CD Rippers]]

Rubyripper

2006-08-12T13:32:18Z

Frodoontop: /* Developement progress */

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. I won't implement this myself though, due to the fact that I am more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. I don't use any new features, therefore I think it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

If you're ready, please contact me at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. Being the only lead developer, I hope you will be consistent with the current GTK2 interface design. If there are valid reasons to make any adjustments, please consult with me first. From a starting point it would be best to use the current GTK2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> <code>'require ./rr_lib.rb'</code>
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from <code>$HOME/rubyripper_settings</code> if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class. This is done by passings the settings Hash as an argument. ''(In other languages sometimes called a dictionary)''
# The hash should contain all settings: <code>
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped) </code>
# All communication back to the GUI happens via the update function, that should be in the GUI, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. <math>100 % = 1.0. </math> Used to update the progress bar.
#* encoding_progress. value is a float. <math>100 % = 1.0.</math> Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the GUI.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the GUI-buttons.
#* error. value is a string. Used to bring up a popup window with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is an effective way of getting a responsive GUI.

==OS X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows OS X very well and can test any code if needed is a necessity. The main differences with OS X and Linux support are:
* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Development progress=
When implementing features, I often wonder what should be the right way. For this kind of discussion, I added this section.
I am currently working at:
* The tracklist presentation. As someone at the forums suggested, the interface isn't perfect. I improved it by opening the main window with a fixed size. The tracklist becomes scrollable, if it is too large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window, instead of a tab. As can be seen in the previous screenshots, I also removed the status bars and the status tab from the main view. They are moved to a separate ripping window, like [[EAC]]. Still working on which buttons should be visible though.If you have any ideas how to improve the looks as shown in the next screenshot, please share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

Rubyripper

2006-08-12T12:22:20Z

Frodoontop: Added development progress

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

=Development API=
This section will give some technical information, which should be useful for interested developers. It will outline how the code is structured and what the API of Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simple to add new frontends to the current codebase. Currently there are CLI and GTK2 frontends. A Qt frontend or a Cocoa Mac OS frontend, should not be terribly difficult to implement. I won't implement this myself though, due to the fact that I am more interested in fine tuning the Rubyripper logic codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter "Until Trouble Strikes". This is a somewhat dated version, but still perfectly usable. I don't use any new features, therefore I think it should be fine.
* Some basic knowledge of a GUI-toolkit in case you want to add a new frontend.

If you're ready, please contact me at ''rubyripperdev@nospam@gmail.com''. You can leave out the @nospam part.

==Data files and class structures==
The 0.2 release has three ruby files and one glade file included:
* <code>rr_lib.rb.</code> This contains the Rubyripper codebase. It consists of five classes:
** <code>Gui_Support.</code> This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). This is were log file is generated and the error analysis takes place.
** <code>Cddb.</code> This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that, it's using an old contact protocol and never gives away any information on the current year. This is the main reason why the Cddb class handles all server contact.
** <code>Secure_rip.</code> As might be expected, all error correction logic is put in here.
** <code>Encode. </code> As might be expected, this handles the encoding of the different formats supported.
** <code>Rubyripper.</code> Handles the usage of the different classes. It also performs some logical checks before starting at all.
* <code>rubyripper_cli.rb.</code> It has one class that contains the code for the command line interface frontend.
* <code>rubyripper_gtk.rb.M</code> It has one class that contains the code for the GTK2 user interface frontend.
* <code>rubyripper.glade.</code> This is a help file for the GTK interface. It's made with Glade, a program for designing user interfaces for GTK2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. Take for instance, the current GTK2 frontend, which consists of only 350 lines of code ''(+ the glade file, but this code is automatically created)'''. Being the only lead developer, I hope you will be consistent with the current GTK2 interface design. If there are valid reasons to make any adjustments, please consult with me first. From a starting point it would be best to use the current GTK2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.

What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> <code>'require ./rr_lib.rb'</code>
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from <code>$HOME/rubyripper_settings</code> if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class. This is done by passings the settings Hash as an argument. ''(In other languages sometimes called a dictionary)''
# The hash should contain all settings: <code>
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped) </code>
# All communication back to the GUI happens via the update function, that should be in the GUI, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. <math>100 % = 1.0. </math> Used to update the progress bar.
#* encoding_progress. value is a float. <math>100 % = 1.0.</math> Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the GUI.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the GUI-buttons.
#* error. value is a string. Used to bring up a popup window with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is an effective way of getting a responsive GUI.

==OS X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows OS X very well and can test any code if needed is a necessity. The main differences with OS X and Linux support are:
* Audio cd's may have to be unmounted before they can be ripped.
* Linux doesn't mount audio cd's at all.
* In [[cdparanoia]] an option to set the cdrom device is missing, which is there in Linux.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Developement progress=
When implementing features, I often wonder what should be the right way. For this kind of discussion, I added this section.
I am currently working at:
* The tracklist presentation. As someone at the forums suggested, the interface isn't perfect. I improved it by opening the main window with a fixed size. The tracklist becomes scrollable, if it is too large too fit. Screenshots:
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection1.png New tracklist loading 1]
** [http://b-woudstra.speedlinq.nl/screenshots/track_selection2.png New tracklist loading 2]
* A separate status window, instead of a tab. As can be seen in the previous screenshots, I also removed the status bars and the status tab from the main view. They are moved to a separate ripping window, like [[EAC]]. Still working on which buttons should be visible though.If you have any ideas how to improve the looks as shown in the next screenshot, please share your opinion!
** [http://b-woudstra.speedlinq.nl/screenshots/status_window.png New separate status window]

Rubyripper

2006-08-07T10:11:12Z

Frodoontop: /* Developer info */ Added a subpage about OS X support

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Developer info=
This section will give some technical information, which should be usefull for interested developers. It will outline how the code is structured and what the API of the Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simply to add new frontends to the current codebase. Currently there is a CLI and a GTK2 frontend. But a Qt frontend or a Cocoa Mac OS frontend isn't terribly difficult to achieve. I won't implement this myself though, as I'm more interested to finetune the Rubyripper codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter Until trouble strikes. This is a somewhat dated version, but still perfectly usable. As I don't use any new features I think it should be fine.
* Some basic knowledge of a gui-toolkit in case you want to add a new frontend.

If you're ready, please contact me at rubyripperdev@nospam@gmail.com. You can leave out the @nospam part.

==Rubyripper files and classes==
The 0.2 release has three ruby files and one glade file included:
* rr_lib.rb. This contains the Rubyripper codebase. It consists of five classes:
** Gui_Support. This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). Also the log file and error analyzing takes place in here.
** Cddb. This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that it is using an old contact protocol and it almost always don't give any year info. So the Cddb class handles all server contact.
** Secure_rip. As might be expected, all error correction logic is put in here.
** Encode. As might be expected, this handles the encoding of the different formats supported.
** Rubyripper. Handles the usage of the different classes. Also performs some logical checks before starting at all.
* rubyripper_cli.rb. It has one class that contains the code for the command line interface frontend.
* rubyripper_gtk.rb. It has one class that contains the code for the gtk2 user interface frontend.
* rubyripper.glade. This is a help file for the gtk interface. It's made with Glade, a program for designing user interfaces for gtk2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. For instance, current gtk2 frontend is only 350 lines of code (+ the glade file, but this code is automatically created). As lead developer I only hope you will be consistent with the current gtk2 interface design. If there are good reasons to do it differently, please have a chat with me.
As a start it would be best to use the current Gtk2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.
 
What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> 'require ./rr_lib.rb'
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from $HOME/rubyripper_settings if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class, passing the settings Hash as argument. (In other languages sometimes called a dictionary)
# The hash should contain all settings:
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped)
# All communication back to the gui, happens via the update function that should be in the gui, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* encoding_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the gui.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the gui-buttons.
#* error. value is a string. Used to bring up a popup with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is a good idea for getting a responsive gui.

==OS X support==
Since the lead developer doesn't have a Mac, he cannot test anything. Therefore support from someone who knows a mac very well and can test any code is needed. Main differences with OS X and Linux support are:
* Audio-cd's may have to be unmounted before they can be ripped? Linux doesn't mount audio cd's at all.
* In cdparanoia an option to set cdrom is missing, which is there in Linux.

Rubyripper

2006-08-07T10:00:21Z

Frodoontop: /* Adding a new frontend */ spelling mistake

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Developer info=
This section will give some technical information, which should be usefull for interested developers. It will outline how the code is structured and what the API of the Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simply to add new frontends to the current codebase. Currently there is a CLI and a GTK2 frontend. But a Qt frontend or a Cocoa Mac OS frontend isn't terribly difficult to achieve. I won't implement this myself though, as I'm more interested to finetune the Rubyripper codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter Until trouble strikes. This is a somewhat dated version, but still perfectly usable. As I don't use any new features I think it should be fine.
* Some basic knowledge of a gui-toolkit in case you want to add a new frontend.

If you're ready, please contact me at rubyripperdev@nospam@gmail.com. You can leave out the @nospam part.

==Rubyripper files and classes==
The 0.2 release has three ruby files and one glade file included:
* rr_lib.rb. This contains the Rubyripper codebase. It consists of five classes:
** Gui_Support. This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). Also the log file and error analyzing takes place in here.
** Cddb. This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that it is using an old contact protocol and it almost always don't give any year info. So the Cddb class handles all server contact.
** Secure_rip. As might be expected, all error correction logic is put in here.
** Encode. As might be expected, this handles the encoding of the different formats supported.
** Rubyripper. Handles the usage of the different classes. Also performs some logical checks before starting at all.
* rubyripper_cli.rb. It has one class that contains the code for the command line interface frontend.
* rubyripper_gtk.rb. It has one class that contains the code for the gtk2 user interface frontend.
* rubyripper.glade. This is a help file for the gtk interface. It's made with Glade, a program for designing user interfaces for gtk2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. For instance, current gtk2 frontend is only 350 lines of code (+ the glade file, but this code is automatically created). As lead developer I only hope you will be consistent with the current gtk2 interface design. If there are good reasons to do it differently, please have a chat with me.
As a start it would be best to use the current Gtk2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.
 
What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> 'require ./rr_lib.rb'
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from $HOME/rubyripper_settings if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class, passing the settings Hash as argument. (In other languages sometimes called a dictionary)
# The hash should contain all settings:
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settings'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped)
# All communication back to the gui, happens via the update function that should be in the gui, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* encoding_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the gui.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the gui-buttons.
#* error. value is a string. Used to bring up a popup with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is a good idea for getting a responsive gui.

Rubyripper

2006-08-07T09:58:47Z

Frodoontop: /* Becoming a developer */ Added a mail adress.

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Developer info=
This section will give some technical information, which should be usefull for interested developers. It will outline how the code is structured and what the API of the Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simply to add new frontends to the current codebase. Currently there is a CLI and a GTK2 frontend. But a Qt frontend or a Cocoa Mac OS frontend isn't terribly difficult to achieve. I won't implement this myself though, as I'm more interested to finetune the Rubyripper codebase.
 

==Becoming a Rubyripper developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter Until trouble strikes. This is a somewhat dated version, but still perfectly usable. As I don't use any new features I think it should be fine.
* Some basic knowledge of a gui-toolkit in case you want to add a new frontend.

If you're ready, please contact me at rubyripperdev@nospam@gmail.com. You can leave out the @nospam part.

==Rubyripper files and classes==
The 0.2 release has three ruby files and one glade file included:
* rr_lib.rb. This contains the Rubyripper codebase. It consists of five classes:
** Gui_Support. This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). Also the log file and error analyzing takes place in here.
** Cddb. This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that it is using an old contact protocol and it almost always don't give any year info. So the Cddb class handles all server contact.
** Secure_rip. As might be expected, all error correction logic is put in here.
** Encode. As might be expected, this handles the encoding of the different formats supported.
** Rubyripper. Handles the usage of the different classes. Also performs some logical checks before starting at all.
* rubyripper_cli.rb. It has one class that contains the code for the command line interface frontend.
* rubyripper_gtk.rb. It has one class that contains the code for the gtk2 user interface frontend.
* rubyripper.glade. This is a help file for the gtk interface. It's made with Glade, a program for designing user interfaces for gtk2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. For instance, current gtk2 frontend is only 350 lines of code (+ the glade file, but this code is automatically created). As lead developer I only hope you will be consistent with the current gtk2 interface design. If there are good reasons to do it differently, please have a chat with me.
As a start it would be best to use the current Gtk2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.
 
What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> 'require ./rr_lib.rb'
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from $HOME/rubyripper_settings if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class, passing the settings Hash as argument. (In other languages sometimes called a dictionary)
# The hash should contain all settings:
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settigns'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped)
# All communication back to the gui, happens via the update function that should be in the gui, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* encoding_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the gui.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the gui-buttons.
#* error. value is a string. Used to bring up a popup with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is a good idea for getting a responsive gui.

Rubyripper

2006-08-07T09:51:05Z

Frodoontop: /* Adding a new frontend */ Give some more details

=Introduction=

What is Rubyripper? Rubyripper is a digital audio extraction algorithm that uses [[cdparanoia]] or cdda2wav in a sophisticated way to make sure that a CD rip is done succesfully and accurately. It is very similiar to and inspired by [[EAC]]. Rubyripper is written in the ruby programming language.

It's currently available for Linux (partial BSD support). OS X will most likely be supported in the near future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.2 was released on 4 August 2006.'''
* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface
* Sophisticated error correction mechanism
* A command line interface (CLI) available
* CDDB-info is fetched via the ''ruby-freedb'' module
* Info can be edited after fetching
* The codecs supported are FLAC, Vorbis, MP3, and Wav
* Multiple codecs can be used in one run
* Direct offset support
* Detailed logfile creation
* A detailed overview of hard-to-correct positions
* Create m3u playlists

==Correction mechanism==

Rubyripper correction mechanism goes beyond that of [[cdparanoia]]. Every track gets ripped at least twice and is byte compared with the ''Ruby cmp'' feature. If any differences are found, each of the 1,000 bytes of the two files is compared. The next trial run looks to see if differing positions or a match can be found. ''(1,000 bytes is about 0.006 seconds)''
 
The main underlying Philosophy is that an erronous read of an underlying ripper will produce random results. This seems so far to be correct. A possibility still exists that with randomn results the same result will be wrong.
 
If the full 1,000 bytes are erronous, than a false repair seems to be highly unlikely since there are <math>1000 \times 256</math> possibilities in theory. (As a byte consists of 8 bits, 28=256). This would need an infinite amount of trials to match. The main principle however is, the more trials that are needed, consequently the higher a chance of a false repair.
 
Suppose only 3 bytes in a sample of 1,000 bytes give random information. This would still mean <math>3 \times 256</math> possibilities within each of these bytes, really 2 bits could be a problem. This reduces the possibilities to <math>3 \times 2 \times 2 = 12</math> possibilies. So, a false repair still seems to be possible. One has to wonder though: can 3 bytes actually be heard in a wav file that produces 180.000 bytes per second?
 
In conclusion: Rubyripper won't guarantee a consequent ''MD5-sum'' on tracks that needed correction. However it will repair any files so that it's impossible to succesfully blind-test with the original. The log file will report any position that needed more than 3 trials, so you can check the position yourself.

==Installation==

Make sure to have ''ruby-freedb'', ''ruby-libglade2'' and [[cdparanoia]] or cdda2wav installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you wish to use.

Then download Rubyripper:
http://rubyforge.org/frs/?group_id=1284&release_id=6293

Documentation of some of the ripping logic used can be found at: (somewhat dated) 
http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal or console:

:<code>cd <download_dir> (Go to the directory where you saved the downloaded archive)</code>
:<code>tar xfj <filename_download> (Unpack the archive)</code>
:<code>cd rubyripper-<version> (Move into the just unpacked directory)</code>
:<code>chmod +x *.rb (Make all .rb files executable)</code>
:<code>./rubyripper_gtk.rb (Launch gtk2 user interface)</code>
:<code>./rubyripper_cli.rb (Launch command line user interface)</code>

If Rubyripper doesn't start make sure the dependencies are ok. When launched from a terminal rubyripper should now tell which dependency it's missing.

==Screenshots==
The theme used in the screenshots is GTK-Qt-theme.
* [http://b-woudstra.speedlinq.nl/screenshots/Cddb-info_GTK-QT-theme.png The Cddb-info tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Codecs_GTK-QT-theme.png The Codecs tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Other-settings_GTK-QT-theme.png The Other settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Ripping-settings_GTK-QT-theme.png The Ripping settings tab]
* [http://b-woudstra.speedlinq.nl/screenshots/Status_GTK-QT-theme.png The status tab]

==Suggestions for next version==
* Try to rip only parts that contain errors to save time
* Erronous parts should be matched more than once
* OS X support. As the only developer I need some help, for I don't have a Mac. A Mac user could help to get the cli-version working. A ruby programmer could help to make the GUI for OS X. I'll be glad to add support for this task.
* Let the user choose which freedb hit he/she will use

==Known Bugs==
*If the first trial of a track has a different size than the second track, it assumes that the size of the first track is right. We don't know that for sure.

==External links==
* [http://rubyforge.org/projects/rubyripper/ Rubyripper] the official Rubyforge website
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread] the first public release of Rubyripper

=Developer info=
This section will give some technical information, which should be usefull for interested developers. It will outline how the code is structured and what the API of the Rubyripper codebase is for adding new user interfaces. Since version 0.2 it is quite simply to add new frontends to the current codebase. Currently there is a CLI and a GTK2 frontend. But a Qt frontend or a Cocoa Mac OS frontend isn't terribly difficult to achieve. I won't implement this myself though, as I'm more interested to finetune the Rubyripper codebase.
 

==Becoming a developer==
To become a developer you should have:
* Some basic knowledge of the Ruby programming language. Read for instance the [http://www.ruby-doc.org/docs/ProgrammingRuby/ free online book], at least until the chapter Until trouble strikes. This is a somewhat dated version, but still perfectly usable. As I don't use any new features I think it should be fine.
* Some basic knowledge of a gui-toolkit in case you want to add a new frontend.

==Rubyripper files and classes==
The 0.2 release has three ruby files and one glade file included:
* rr_lib.rb. This contains the Rubyripper codebase. It consists of five classes:
** Gui_Support. This class handles all feedback communication with the user interface and is used a lot by the other classes (except Cddb). Also the log file and error analyzing takes place in here.
** Cddb. This class handles the freedb fetching. It uses the Freedb class (dependent on ruby-freedb) to get info about the disc. The server contact is handled in the Cddb class itself. Some problems of the Freedb class made it impossible to rely on it. The biggest problem with using Freedb class is that it is using an old contact protocol and it almost always don't give any year info. So the Cddb class handles all server contact.
** Secure_rip. As might be expected, all error correction logic is put in here.
** Encode. As might be expected, this handles the encoding of the different formats supported.
** Rubyripper. Handles the usage of the different classes. Also performs some logical checks before starting at all.
* rubyripper_cli.rb. It has one class that contains the code for the command line interface frontend.
* rubyripper_gtk.rb. It has one class that contains the code for the gtk2 user interface frontend.
* rubyripper.glade. This is a help file for the gtk interface. It's made with Glade, a program for designing user interfaces for gtk2.

==Adding a new frontend==
New frontends are encouraged and shouldn't be difficult to make. For instance, current gtk2 frontend is only 350 lines of code (+ the glade file, but this code is automatically created). As lead developer I only hope you will be consistent with the current gtk2 interface design. If there are good reasons to do it differently, please have a chat with me.
As a start it would be best to use the current Gtk2 code and just plainly rewrite it for the other toolkit. The basic ideas should be more or less the same.
 
What requirements would code for a new gui have to work correctly with the Rubyripper codebase?
# Load the Rubyripper codebase -> 'require ./rr_lib.rb'
# Make a class of the gui code, we will later pass this to the Rubyripper codebase.
# Get info from the user which cdrom should be used (load it from $HOME/rubyripper_settings if it exists)
# Start a new instance of Cddb class -> @instance = Cddb.new(cdrom <string>, self <class>, multiple_freedb_hits? <bool>, verbose? <bool>)
# Test if @instance.disc_ok <bool> is true. If so, you can use @instance.track_numbers <int> and @instance.tracks_length <string> to update the amount and playlength of the tracks into the gui. Also start @instance.make_internet_contact()
# Test if @instance.internet_ok <bool> is true. If so, update the info of @instance.artist <string>, @instance.album <string>, @instance.year <string>, @instance.genre <string> and tracklist <array_of_strings> in the gui.
# As soon as the user wants to start the ripping process, start a new instance of the Rubyripper class, passing the settings Hash as argument. (In other languages sometimes called a dictionary)
# The hash should contain all settings:
#* @settings['instance'] = the Gui instance -> self
#* @settings['cd_info'] = the Cddb instance -> @instance
#* @settings['verbose'] = bool
#* @settings['debug'] = bool
#* @settings['flac'] = bool
#* @settings['vorbis'] = bool
#* @settings['mp3'] = bool
#* @settings['wav'] = bool
#* @settings['flacsettings'] = string
#* @settings['vorbissettings'] = string
#* @settings['mp3settigns'] = string
#* @settings['playlist'] = bool (m3u playlist wanted?)
#* @settings['use_threading'] = bool (ripping and encoding don't wait for each other)
#* @settings['ripper'] = string (cdda2wav or cdparanoia)
#* @settings['rippersettings'] = string or false
#* @settings['max_tries'] = int
#* @settings['cdrom'] = string (same as the one passed to Cddb instance)
#* @settings['offset'] = int
#* @settings['temp_dir'] = string
#* @settings['destination_dir'] = string
#* @settings['save_log'] = bool
#* @settings['tracklist'] = array of integers (which tracks should be ripped)
# All communication back to the gui, happens via the update function that should be in the gui, accepting two parameters: modus <string> and value <can be anything, dependent on the modus>. Notice that this is a great ruby feature! The different modus are:
#* ripping_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* encoding_progress. value is a float. 100 % = 1.0. Used to update the progress bar.
#* log_change. value is a string. Used to update the status screen.
#* track_finished. value is an integer. Used to deselect the track in the gui.
#* finished. value is not important. This means that the ripping and encoding are finished. Used to unlock the gui-buttons.
#* error. value is a string. Used to bring up a popup with the error message.
#* cddb_hit. value is an array of strings with the multiple hits. Return the index of the array.
# Using a new thread for launching instances is a good idea for getting a responsive gui.

Rubyripper

2006-08-06T20:54:55Z

Frodoontop: Added some developer info, more will follow

Rubyripper

2006-08-05T08:37:25Z

Frodoontop: /* Screenshots */ Added some links to a few screenshots

Rubyripper

2006-08-05T07:18:37Z

Frodoontop: /* Installation */

Rubyripper

2006-08-05T07:14:10Z

Frodoontop: /* Suggestions for next version */

Rubyripper

2006-08-05T06:41:04Z

Frodoontop: /* Correction mechanism */

Rubyripper

2006-08-04T20:55:55Z

Frodoontop: /* Introduction */ Added Suggestions for next version

Rubyripper

2006-08-04T20:35:59Z

Frodoontop: /* Features */ Update the feature list because of new release

Rubyripper

2006-08-04T20:17:14Z

Frodoontop: /* Correction mechanism */ More precise explanation of underlying idea

Rubyripper

2006-08-04T19:30:20Z

Frodoontop: /* Installation */ oops forgot the </code> tag

Rubyripper

2006-08-04T19:29:28Z

Frodoontop: /* Installation */

Rubyripper

2006-08-04T19:27:09Z

Frodoontop: /* Introduction */ new version

Rubyripper

2006-08-04T17:52:30Z

Frodoontop: /* External links */ (spelling mistake)

Rubyripper

2006-08-04T17:51:54Z

Frodoontop: /* Features */ Wav - NOT wavpack

Rubyripper

2006-08-03T17:52:37Z

Frodoontop: /* External links */

=Introduction=

What is Rubyripper? Rubyripper is a cd-ripper that uses [[cdparanoia]] or [[cdda2wav]] in a smart way to make sure that the rip is done succesfully. It is very much inspired by [[EAC]]. Rubyripper is written in the Ruby programming language.

It's currently available for Linux (BSD will probably work too). OSX will probably be supported in the future. The source (same as executable) is published under the GPL license.

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

=Features=

* A GTK2 user interface.
* Correction mechanism which goes further than standard [[cdparanoia]]. Every track gets ripped at least twice and is bytecompared with the Ruby cmp feature. If differences are found, each 1000 bytes of the two files is compared. Next trial looks if for the differing positions a match can be found. (1000 bytes is about 0,006 seconds)
* CDDB-info is fetched via the ruby-freedb module.
* Codecs supported are flac, mp3, vorbis and wav.
* Except wav, each codec can be configured. Sensible defaults are otherwise used.
* Multiple codecs can be used in one run
* You can set the output directory

=How to install=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]
* [http://www.hydrogenaudio.org/forums/index.php?showtopic=38418 Hydrogenaudio forum thread]

Rubyripper

2006-08-03T16:36:22Z

Frodoontop: /* Introduction */

Rubyripper

2006-08-03T16:35:18Z

Frodoontop: /* Rubyripper configuration */

=Introduction=

What is Rubyripper? Rubyripper is a cd-ripper that uses [[cdparanoia]] or [[cdda2wav]] in a smart way to make sure that the rip is done succesfully. It is very much inspired by [[EAC]]. Rubyripper is written in the Ruby programming language.

It's currently available for Linux (BSD will probably work too). OSX will probably be supported in the future. The source (same as executable) is published under the (GPL license).

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

=Features=

* A GTK2 user interface.
* Correction mechanism which goes further than standard [[cdparanoia]]. Every track gets ripped at least twice and is bytecompared with the Ruby cmp feature. If differences are found, each 1000 bytes of the two files is compared. Next trial looks if for the differing positions a match can be found. (1000 bytes is about 0,006 seconds)
* CDDB-info is fetched via the ruby-freedb module.
* Codecs supported are flac, mp3, vorbis and wav.
* Except wav, each codec can be configured. Sensible defaults are otherwise used.
* Multiple codecs can be used in one run
* You can set the output directory

=How to install=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]

Rubyripper

2006-08-03T16:34:25Z

Frodoontop: /* Introduction */

=Introduction=

What is Rubyripper? Rubyripper is a cd-ripper that uses [[cdparanoia]] or [[cdda2wav]] in a smart way to make sure that the rip is done succesfully. It is very much inspired by [[EAC]]. Rubyripper is written in the Ruby programming language.

It's currently available for Linux (BSD will probably work too). OSX will probably be supported in the future. The source (same as executable) is published under the (GPL license).

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

=Features=

* A GTK2 user interface.
* Correction mechanism which goes further than standard [[cdparanoia]]. Every track gets ripped at least twice and is bytecompared with the Ruby cmp feature. If differences are found, each 1000 bytes of the two files is compared. Next trial looks if for the differing positions a match can be found. (1000 bytes is about 0,006 seconds)
* CDDB-info is fetched via the ruby-freedb module.
* Codecs supported are flac, mp3, vorbis and wav.
* Except wav, each codec can be configured. Sensible defaults are otherwise used.
* Multiple codecs can be used in one run
* You can set the output directory

=Rubyripper configuration=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]

Rubyripper

2006-08-03T16:33:53Z

Frodoontop: /* Introduction */

=Introduction=

What is Rubyripper? Rubyripper is a cd-ripper that uses [[cdparanoia]] or [[cdda2wav]] in a smart way to make sure that the rip is done succesfully. It is very much inspired by [[EAC]]. Rubyripper is written in the Ruby programming language.

It's currently available for Linux (BSD will probably work too). OSX will probably be supported in the future. The source (same as executable) is published under the (GPL license).

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface.
* Correction mechanism which goes further than standard [[cdparanoia]]. Every track gets ripped at least twice and is bytecompared with the Ruby cmp feature. If differences are found, each 1000 bytes of the two files is compared. Next trial looks if for the differing positions a match can be found. (1000 bytes is about 0,006 seconds)
* CDDB-info is fetched via the ruby-freedb module.
* Codecs supported are flac, mp3, vorbis and wav.
* Except wav, each codec can be configured. Sensible defaults are otherwise used.
* Multiple codecs can be used in one run
* You can set the output directory

=Rubyripper configuration=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]

Rubyripper

2006-08-03T16:27:31Z

Frodoontop: /* Features */

=Introduction=

What is Rubyripper? Rubyripper is simple, but quite sophisticated digital audio extraction tool written in Python programming language that can create secure rip's in Linux/OSX (very similiar to [[EAC]]). The source (same as executable) is published under the (GPL license).

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* A GTK2 user interface.
* Correction mechanism which goes further than standard [[cdparanoia]]. Every track gets ripped at least twice and is bytecompared with the Ruby cmp feature. If differences are found, each 1000 bytes of the two files is compared. Next trial looks if for the differing positions a match can be found. (1000 bytes is about 0,006 seconds)
* CDDB-info is fetched via the ruby-freedb module.
* Codecs supported are flac, mp3, vorbis and wav.
* Except wav, each codec can be configured. Sensible defaults are otherwise used.
* Multiple codecs can be used in one run
* You can set the output directory

=Rubyripper configuration=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]

Rubyripper

2006-08-03T16:16:10Z

Frodoontop: /* Rubyripper configuration */

=Introduction=

What is Rubyripper? Rubyripper is simple, but quite sophisticated digital audio extraction tool written in Python programming language that can create secure rip's in Linux/OSX (very similiar to [[EAC]]). The source (same as executable) is published under the (GPL license).

* '''UPDATE: New version 0.1.1 was released on 12 February 2006.'''
* '''UPDATE: New version 0.1.0 was released on 5 November 2005.'''

==Features==

* a command-line program which makes use of [[cdparanoia]].
* every track gets ripped twice and is compared with a ''160-bit SHA1 checksum''
* if the checksums differ, the track will be ripped twice again until the checksum matches
* CDDB-info is fetched via the pycddb module.
* It can rip to FLAC, MP3, and Vorbis.
* Lame and Vorbis can be configured, default for lame is: -V2 --vbr-new, default for vorbis is -q 6
* You can choose the ripping device, otherwise default is used.
* See rubyripper --help for more information
* The files will be saved as "working directory/extension/artist (year) album/tracknumber - trackname.extension

=Rubyripper configuration=

Make sure to have ruby-freedb, ruby-libglade2 and [[cdparanoia]] installed as a minimum. You can optionally choose for Lame, Vorbis or FLAC, depending on the codec you like to use.

Then download Rubyripper:
http://rubyforge.org/projects/rubyripper/

Documentation of some of the ripping logic used can be found at: http://rubyforge.org/docman/view.php/1284/310/Rubyripper's%20ripping%20logic.pdf

Currently there isn't an official installer available. Usage from a terminal:

*cd <download_dir> (Go to the directory where you saved the downloaded archive)
*tar xfj <filename_download> (Unpack the archive)
*cd rubyripper-<version> (Move into the just unpacked directory)
*chmod +x rubyripper.rb (Make rubyripper.rb executable)
*./rubyripper.rb (Launch executable)

If Rubyripper doesn't start make sure dependencies are ok.

=External links=
* [http://rubyforge.org/projects/rubyripper/ Official website]