使用C语言扩展Python(四)

上一篇里的LAME项目已经展示了python如何与C语言交互,但程序仍不够理想,在python这一端仅仅是传递源文件和目标文件的路径,再调用C模块的encode方法来进行编码,但问题在于你无法控制encode函数,比如你想编码的源文件如果不是原始数据,而是wav文件或者其他格式呢?对于这个问题,有两种方法可以选择,一种模仿前面的C模块,在你的Python代码中读取数据,并将数据块逐个传递给encode函数,另一种方法是你传进去一个对象,这个对象带有一个read方法,这样你就可以在C模块里直接调用它的read方法来读取其数据。
听起来好像第二种更加面向对象,但实际上第一种方法反而是更为合适的选择,因为它更为灵活,下面我们就在上一篇的基础上,利用第一种思路对其进行改造。在这种新方法中,我们需要多次调用C模块的函数,类似于将其视为类的方法。可C语言是不支持类的,因此需要将状态信息存储在某个地方。除此以外,我们需要将“类”暴露给外部的Python程序,使其能创建“类“的实例,并调用它的方法。在“类对象“的内部我们则将其写数据的文件信息储存在”对象“的状态中。听上去就是一种面向对象的方法,不是吗?
首先,遵循"测试先行"的原则,先来看我们改造后的Python这一端,你可以每次读取音频源文件的一个数据块,将其转递给Encoder对象的encode方法,这样无论你的源文件是何种格式,你都可以在Encoder中进行自由的控制,示例代码如下:
代码
import clame

INBUFSIZE 
= 4096

if __name__ == '__main__':
    encoder 
= clame.Encoder('test.mp3')
    input 
= file('test.raw''rb')
    data 
= input.read(INBUFSIZE)

    
while data != '':
        encoder.encode(data)
        data 
= input.read(INBUFSIZE)
    input.close()
    encoder.close()

 再来看C扩展模块这一端,下面是完整的代码:

代码
#include <Python.h>
#include 
<lame.h>

typedef 
struct {
    PyObject_HEAD
    FILE
* outfp;
    lame_global_flags
* gfp;
}clame_EncoderObject;

static PyObject* Encoder_new(PyTypeObject* type, PyObject* args, PyObject* kw) {
    clame_EncoderObject
* self = (clame_EncoderObject* )type->tp_alloc(type, 0);
    self
->outfp = NULL;
    self
->gfp = NULL;
    
return (PyObject*)self;
}

static void Encoder_dealloc(clame_EncoderObject* self) {
    
if (self->gfp) {
        lame_close(self
->gfp);
    }
    
if (self->outfp) {
        fclose(self
->outfp);
    }
    self
->ob_type->tp_free(self);
}

static int Encoder_init(clame_EncoderObject* self, PyObject* args, PyObject* kw) {
    
char* outPath;
    
if (!PyArg_ParseTuple(args, "s"&outPath)) {
        
return -1;
    }
    
if (self->outfp || self->gfp) {    
        PyErr_SetString(PyExc_Exception, 
"__init__ already called");
        
return -1;
    }
    self
->outfp = fopen(outPath, "wb");
    self
->gfp = lame_init();
    lame_init_params(self
->gfp);
    
return 0;
}

static PyObject* Encoder_encode(clame_EncoderObject* self, PyObject* args) {
    
char* in_buffer;
    
int in_length;
    
int mp3_length;
    
char* mp3_buffer;
    
int mp3_bytes;
    
if (!(self->outfp || self->gfp)) {
        PyErr_SetString(PyExc_Exception, 
"encoder not open");
        
return NULL;
    }
    
if (!PyArg_ParseTuple(args, "s#"&in_buffer, &in_length)) {
        
return NULL;
    }
    in_length 
/= 2;
    mp3_length 
= (int)(1.25 * in_length) + 7200;
    mp3_buffer 
= (char*)malloc(mp3_length);
    
if (in_length > 0) {
        mp3_bytes 
= lame_encode_buffer_interleaved(self->gfp, (short*)in_buffer, in_length/2, mp3_buffer, mp3_length);
        
if (mp3_bytes > 0) {
            fwrite(mp3_buffer, 
1, mp3_bytes, self->outfp);
        }
    }
    free(mp3_buffer);
    Py_RETURN_NONE;
}

static PyObject* Encoder_close(clame_EncoderObject* self) {
    
int mp3_length;
    
char* mp3_buffer;
    
int mp3_bytes;
    
if (!(self->outfp && self->gfp)) {
        PyErr_SetString(PyExc_Exception, 
"encoder not open");
        
return NULL;
    }
    mp3_length 
= 7200;
    mp3_buffer 
= (char*)malloc(mp3_length);
    mp3_bytes 
= lame_encode_flush(self->gfp, mp3_buffer, sizeof(mp3_buffer));
    
if (mp3_bytes > 0) {
        fwrite(mp3_buffer, 
1, mp3_bytes, self->outfp);        
    }
    free(mp3_buffer);
    lame_close(self
->gfp);
    self
->gfp = NULL;
    fclose(self
->outfp);
    self
->outfp = NULL;
    Py_RETURN_NONE;
}

static PyMethodDef Encoder_methods[] = {
    {
"encode", (PyCFunction)Encoder_encode, METH_VARARGS, "encodes and writes data to the output file."},
    {
"close", (PyCFunction)Encoder_close, METH_NOARGS, "close the output file."},
    {NULL, NULL, 
0, NULL}
};

static PyTypeObject clame_EncoderType = {
    PyObject_HEAD_INIT(NULL)
    
0,                                    // ob_size
    "clame.Encoder",                    // tp_name
    sizeof(clame_EncoderObject),        // tp_basicsize
    0,                                    // tp_itemsize
    (destructor)Encoder_dealloc,        // tp_dealloc
    0,                                    // tp_print
    0,                                    // tp_getattr
    0,                                    // tp_setattr
    0,                                    // tp_compare
    0,                                    // tp_repr
    0,                                    // tp_as_number
    0,                                    // tp_as_sequence
    0,                                    // tp_as_mapping
    0,                                    // tp_hash
    0,                                     // tp_call
    0,                                    // tp_str
    0,                                    // tp_getattro
    0,                                    // tp_setattro
    0,                                    // tp_as_buffer
    Py_TPFLAGS_DEFAULT,                    // tp_flags
    "My first encoder object.",            // tp_doc
    0,                                    // tp_traverse
    0,                                    // tp_clear
    0,                                    // tp_richcompare
    0,                                    // tp_weaklistoffset
    0,                                    // tp_iter
    0,                                    // tp_iternext
    Encoder_methods,                    // tp_methods
    0,                                    // tp_members
    0,                                    // tp_getset
    0,                                    // tp_base
    0,                                    // tp_dict
    0,                                    // tp_descr_get
    0,                                    // tp_descr_set
    0,                                    // tp_dictoffset
    (initproc)Encoder_init,                // tp_init
    0,                                    // tp_alloc
    Encoder_new,                        // tp_new
    0,                                    // tp_free
};

static PyMethodDef clame_methods[] = {    
    {NULL, NULL, 
0, NULL}
};

PyMODINIT_FUNC initclame() {
    PyObject
* m;
    
if (PyType_Ready(&clame_EncoderType) < 0) {
        
return;
    
    m 
= Py_InitModule3("clame", clame_methods, "My second lame module.");
    Py_INCREF(
&clame_EncoderType);
    PyModule_AddObject(m, 
"Encoder", (PyObject*&clame_EncoderType);
}

编译过程:

gcc -shared -I /usr/include/python2.6 -I /usr/local/include/lame clame.c -lmp3lame -o clame.so

首先定义了clame_EncoderObject结构体,这个结构体就是用来存储状态信息的,字段outfp用来存储输出文件,gfp则保存lame的状态,可以用来检查是否已经是重复调用已经调用过的函数了。

为了创建这个结构体的一个新实例,我们需要定义Encoder_new函数,你可以把这个函数视为Python里的__new__方法,当Python解释器需要创建你定义的类型的新实例时就会去调用这个方法。在这个方法里没作什么操作,仅仅是做初始化工作,把outfp和gfp都设置为NULL,此外,与Encoder_new函数对应,还需要定义Encoder_dealloc方法来对实例进行析构,你可以把这个函数视为Python的__del__方法,clame_EncoderType结构体则是真正定义了我们的Encoder对象,它的各个字段指定了_new,_close,_encode,_dealloc等方法。在initclame方法中,PyModuleObject则实际指定了在Python程序中使用的Encoder对象。 

 

 

posted on 2010-05-23 00:43  Phinecos(洞庭散人)  阅读(4007)  评论(2编辑  收藏  举报

导航