什么是 Python 相当于 Lame MP3 转换器？

Question

I need to convert mp3 audio files to 64kbps on the server side.

Right now, I am using subprocess to call lame , but I wonder if there are any good alternatives?

Answer 1

There seems to be a slightly old thread on that topic here: http://www.dreamincode.net/forums/topic/72083-lame-mp3-encoder-for-python/

The final conclusion was to create a custom binding to lame_enc.dll via Python->C bindings.

The reason for that conclusion was that the existing binding libraries (pymedia/py-lame) have not been maintained.

Unfortunately the guy didn't get it to work:)

Maybe you should continue to use subprocess . You could take advantage of that choice, abstract your encoding at a slightly higher level, and reuse the code/strategy to optionally execute other command line encoding tools (such as ogg or shn tools).

I've seen several audio ripping tools adopt that strategy.

Answer 2

I've been working with Python Audio Tools , which is capable of make conversions between different audio formats.

I've already used it to convert.wav files into mp3, .flac and.m4a.

Answer 3

Well, Gstreamer has the "ugly plugin" lamemp3enc and there arepython bindings for Gstreamer (gst-python 1.2, supports python 3.3). I haven't tried going this route myself so I'm not really in a position to recommend anything... Frankly, a subprocess solution seems a lot simpler, if not "cleaner", to me.

Answer 4

If you want to use LAME to encode your MP3s (and not PyMedia), you can always use ctypes to wrap the lame encoder DLL (or.so if you are on Linux). The exact wrapper code you'll use is going to be tied to the LAME DLL version (and there are many of these flying around, unfortunately), so I can't really give you any example, but the ctypes docs should be clear enough about wrapping DLLs.

Answer 5

Caveat: relatively new programmer here and I haven't had a need to convert audio files before.

However, if I understand what you mean by server-side, correctly, you might be looking for a good approach to manage mass conversions, and your interest in a python solution might be in part to be able to better manage the resource use or integrate into your processing chain. I had a similar problem/goal, which I resolved using a mix of Merlyn's recommendation and Celery . I don't use django-celery, but if this is for a django-based project, that might appeal to you as well. You can find out more about celery here:

• http://celeryproject.org/community.html
• http://ask.github.com/celery/getting-started/introduction.html

Depending on what you have setup already, there may be a little upfront time needed to get setup. To take advantage of everything you'll need rabbitmq/erlang installed, but if you follow the guide on the sites above, it's pretty quick now.

Here's an example of how I use celery with subprocess to address a similar issue. Similar to the poster's suggestion above, I use subprocess to call ffmpeg, which is as good as it gets for video tools, and probably would actually be as good as it gets for audio tools too. I'm including a bit more than necessary here to give you a feel for how you might configure your own a little.

    #example of configuring an option, here I'm selecting how much I want to adjust bitrate
    #based on my input's format
    def generate_command_line_method(self):
        if self.bitrate:
            compression_dict =  {'.mp4':1.5, '.rm':1.5, '.avi': 1.2, 
                                '.mkv': 1.2, '.mpg': 1, '.mpeg':1}
            if self.ext.lower() in compression_dict.keys():
                compression_factor = compression_dict[self.ext.lower()]

        #Making a list to send to the command line through subprocess
        ffscript = ['ffmpeg',
                   '-i', self.fullpath,
                   '-b', str(self.bitrate * compression_factor),
                   '-qscale', '3', #quality factor, based on trial and error
                   '-g', '90', #iframe roughly per 3 seconds
                   '-intra',
                    outpath
                   ]
        return ffscript

        #The celery side of things, I'd have a celeryconfig.py file in the 
        #same directory as the script that points to the following function, so my task 
        #queue would know the specifics of the function I'll call through it.  You can
        #see example configs on the sites above, but it's basically just going to be
        #a tuple that says, here are the modules I want you to look in, celery, e.g.
        #CELERY_MODULES = ("exciting_asynchronous_module.py",).  This file then contains, 


        from celery.decorators import task
        from mymodule import myobject
        from subprocess import Popen

        @task(time_limit=600) #say, for example, 10 mins
        def run_ffscript(ffscript):
            some_result = Popen(ffscript).wait() 

            #Note: we'll wait because we don't want to compound
            #the asynchronous aspect (we don't want celery to launch the subprocess and think
            #it has finished.

        #Then I start up celery/rabbitmq, and got into my interactive shell (ipython shown):
        #I'll have some generator feeding these ffscripts command lines, then process them 
        #with something like:

        In[1]: for generated_ffscript in generator:
                  run_ffscript.delay(generated_ffscript)

Let me know if this was useful to you. I'm relatively new to answering questions here and not sure if my attempts are helpful or not. Good luck!