However you put it - in the end you will be reimplementing stuff unnecessary. As I already said once: I strongly recommend you look into GStreamer (with python as language, but as far as I saw there are also bindings for Java).
The good thing about GStreamer is that it is widely used in linux and is gaining popularity on other platforms (Totem uses it for media playing, sound-juicer uses it to extract audio CD's, cheese uses it for web cam, jokosher uses it for sound editig, songbird for cross platform media playing, Firefox and webkit (gtk) will probably use it for html5 <video> and <audio> element)
How GStreamer work is that you construct a pipeline of compatible elements (that can be anything - source, target(sink), encoder, decoder, converter, effects). You can construct such a pipeline programatically and also in CLI using gst-launch command.
A example of a CLI pipeline that converts ANY(gst supported) audio file into a ogg vorbis quality 5 audio file.
gst-launch filesrc location="test.flac" ! decodebin ! audioconvert ! vorbisenc quality=0.5 ! oggmux ! filesink location="test.ogg"
Explanation:
The separator between elements is !
Every element has a source (input) and sink (output).
The stream of the file goes from left to right and the elements transform this stream in their particular way.
gst-inspect command is used to see what elements are available and also what are is and element able to do.
Elements:
filesrc is an element that reads from a file and streams into the next element. The "location" property defines the file that will be used - in the example I used test.flac flac file.
decodebin is a special element that selects the right decoder depending on the format used as its source. Instead of decodebin, flacdec element could be used in this particular example (as the source file is a flac file). The decoder will decode the stream into an uncompressed (raw) form (for example wav) and stream it to the next element.
audioconvert element converts the source stream (now in some raw form) in such a way that it is compatible with its sink element - which is in our case vorbisenc.
vorbisenc takes the source and encodes it into vorbis audio stream with quality 5. The encoded vorbis audio stream will then be send to the sink.
oggmux takes the (compatible) source (vorbis audio stream in our case) and puts it into a ogg container. The stream after this element will be a valid ogg vorbis audio stream but it is yet to be decided what to do with it (it could be streamed over the network to another computer).
filesink takes the source stream and writes it into a file, defined with "location" property.
Once you master this pipeline creating you can create and use it in a program. From the sheer boredom I yesterday created a not-so-nice gui for the upper example in python.
The code:
#!/usr/bin/python
import pygst
pygst.require("0.10")
import gst
import gtk
import os
class Main(object):
def __init__(self):
self.mainWindow = gtk.Window()
self.vBox = gtk.VBox()
self.input = gtk.FileChooserButton("Choose a file")
self.output = gtk.FileChooserButton("Choose a folder")
self.output.set_action(gtk.FILE_CHOOSER_ACTION_SEL ECT_FOLDER)
self.outputFileName = gtk.Entry()
self.convertButton = gtk.Button("Convert")
self.convertButton.connect('clicked', self.onConvertClicked)
self.mainWindow.add(self.vBox)
self.vBox.pack_start(self.input, True, True, 0)
self.vBox.pack_start(self.output, True, True, 0)
self.vBox.pack_start(self.outputFileName, True, True, 0)
self.vBox.pack_start(self.convertButton, False, False, 0)
self.preview = True
self.mainWindow.show_all()
def onConvertClicked(self, widget):
self.pipeline = gst.Pipeline("Convert Pipeline")
sourceFile = self.input.get_filename()
print sourceFile
self.filesrc = gst.element_factory_make("filesrc", "source")
self.filesrc.set_property("location", sourceFile)
self.pipeline.add(self.filesrc)
self.decode = gst.element_factory_make("decodebin", "decode")
self.decode.connect("new-decoded-pad", self.onDynamicPad)
self.pipeline.add(self.decode)
self.filesrc.link(self.decode)
self.convert = gst.element_factory_make("audioconvert", "convert")
self.pipeline.add(self.convert)
destinationFile = os.path.join(self.output.get_filename(), self.outputFileName.get_text())
print destinationFile
self.vorbisenc = gst.element_factory_make("vorbisenc", "vorbisenc")
self.pipeline.add(self.vorbisenc)
self.convert.link(self.vorbisenc)
self.oggmux = gst.element_factory_make("oggmux", "oggmux")
self.pipeline.add(self.oggmux)
self.vorbisenc.link(self.oggmux)
self.sink = gst.element_factory_make("filesink", "sink")
self.sink.set_property("location", destinationFile)
self.pipeline.add(self.sink)
self.oggmux.link(self.sink)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message::eos", self.onEndOfStream)
bus.connect("message::state-changed", self.onStateChanged)
self.pipeline.set_state(gst.STATE_PLAYING)
def onDynamicPad(self, dbin, pad, islast):
pad.link(self.convert.get_pad("sink"))
def onEndOfStream(self, bus, message):
print "End of stream"
def onStateChanged(self, bus, message):
if (message.src == self.pipeline):
state = message.parse_state_changed()
if state[1] == gst.STATE_PAUSED:
print "Pause"
elif state[1] == gst.STATE_PLAYING:
print "Playing"
start=Main()
gtk.main()
In the first button select the source file. in the second target directory and in the third target file. It should start converting if you hit the convert button.
This example only covers converting of audio files. For the videos also to work the pipeline must be branched on some places (because a video usually also has a audio stream or multiple of those and sometimes also subtitles) and merged again into one stream at the end, bu there are a lot of examples that cover this already.
If this does not fit your requests then I don't know what will. ;)