python c example2:pylame2

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

//pyton object variables
typedef struct{
    PyObject_HEAD
    FILE *outfp;
    lame_global_flags *gfp;
} pylame2_EncoderObject;

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

static void Encoder_dealloc(pylame2_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(pylame2_EncoderObject * self, PyObject *args, PyObject *kw)
{
    char *outpath;
    if(!PyArg_ParseTuple(args, "s", &outpath))
    {
        return -;
    }
    if(self->outfp || self->gfp)
    {
        PyErr_SetString(PyExc_Exception, "__init__ already called");
        return -;
    }
    self->outfp = fopen(outpath, "wb");
    self->gfp = lame_init();
    lame_init_params(self->gfp);
    return ;
}

static PyObject *Encoder_encode(pylame2_EncoderObject *self, PyObject *args)
{
    char *in_buffer;
    int in_length;
    int mp3_length;
    char *mp3_buffer;
    int mp3_bytes;
    if(!(self->outfp && self->gtp))
    {
        PyErr_SetString(PyExc_Exception, "encoder not open");
        return NULL;
    }
    if(!PyArg_ParseTuple(args, "s#", &in_buffer, &in_length))
    {
        return NULL;
    }
    in_length /=;
    mp3_length = (int)(1.25 * in_length) + ;
    mp3_buffer = (char*)malloc(mp3_length);
    if(in_length > )
    {
        mp3_bytes = lame_encode_buffer_interleaved(
            self->gtp,
            (short *)in_buffer,
            in_length / ,
            mp3_buffer,
            mp3_length
        );
        if(mpe3_bytes > )
        {
            fwrite(mp3_buffer, , mp3_bytes, self->outfp);
        }
    }
    free(mp3_buffer);
    Py_RETURN_NONE;
}
static PyObject *Encoder_close(pylame2_EncoderObject * self)
{
    int mp3_length;
    char * mp3_buffer;
    int mpe3_bytes;
    if(!(self->outfp && self->gfp))
    {
        PyErr_SetString(PyExc_Exception, "encoder not open");
        return NULL;
    }
    mp3_length = ;
    mp3_buffer = (char*)malloc(mp3_length);
    mp3_bytes = lame_encode_flush(self->gfp, mp3_buffer, sizeof(mp3_buffer));
    if(mp3_bytes > )
    {
        fwrite(mp3_buffer, , 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, "Closes the output file."},
    {NULL, NULL, , NULL}
};
static PyTypeObject pylame2_EncoderType = {
    PyObject_HEAD_INIT(NULL)
    ,                                  /* ob_size */
    "pylame2.Encoder",                  /* tp_name */
    sizeof(pylame2_EncoderObject),      /* tp_basicsize */
    ,                                  /* tp_itemsize */
    (destructor)Encoder_dealloc,        /* tp_dealloc */
    ,                                  /* tp_print */
    ,                                  /* tp_getattr */
    ,                                  /* tp_setattr */
    ,                                  /* tp_compare */
    ,                                  /* tp_repr */
    ,                                  /* tp_as_number */
    ,                                  /* tp_as_sequence */
    ,                                  /* tp_as_mapping */
    ,                                  /* tp_hash */
    ,                                  /* tp_call */
    ,                                  /* tp_str */
    ,                                  /* tp_getattro */
    ,                                  /* tp_setattro */
    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
    "My first encoder object.",         /* tp_doc */
    ,                                  /* tp_traverse */
    ,                                  /* tp_clear */
    ,                                  /* tp_richcompare */
    ,                                  /* tp_weaklistoffset */
    ,                                  /* tp_iter */
    ,                                  /* tp_iternext */
    Encoder_methods,                    /* tp_methods */
    ,                                  /* tp_members */
    ,                                  /* tp_getset */
    ,                                  /* tp_base */
    ,                                  /* tp_dict */
    ,                                  /* tp_descr_get */
    ,                                  /* tp_descr_set */
    ,                                  /* tp_dictoffset */
    (initproc)Encoder_init,             /* tp_init */
    ,                                  /* tp_alloc */
    Encoder_new,                        /* tp_new */
    ,                                  /* tp_free */
};

static PyMethodDef pylame2_methods[] = {
    {NULL, NULL, , NULL}
};

PyMODINIT_FUNC initpylame2(){
    PyObject *m;
    if(PyType_Ready(&pylame2_EncoderType) < )
    {
        return;
    }
    m = Py_InitModule3("pylame2", pylame2_methods, "My Second LAME module.");
    Py_INCREF(&pylame2_EncoderType);
    PyModule_AddObject(m, "Encoder", (PyObject *)&pylame2_EncoderType);
};

/*
    gcc -shared -I/usr/include/pytyon3.1 -I/usr/include/lame pylame2.c -lmp3lame -o pylame2.so
*/
/*python code
    import pylame2

    INBUFSIZE = 4096

    encoder = pylame2.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()
*/

use the python object's methods in c code

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

//pyton object variables
typedef struct{
    PyObject_HEAD
    //FILE *outfp;
    PyObject *outfp;
    lame_global_flags *gfp;
} pylame2_EncoderObject;

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

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

static int Encoder_init(pylame2_EncoderObject * self, PyObject *args, PyObject *kw)
{
    //char *outpath;
    PyObject *outfp;
    if(!PyArg_ParseTuple(args, "O", &outfp))
    {
        return -;
    }
    if(self->outfp || self->gfp)
    {
        PyErr_SetString(PyExc_Exception, "__init__ already called");
        return -;
    }
    //self->outfp = fopen(outpath, "wb");
    self->outfp = outfp;
    Py_INCREF(self->outfp);
    self->gfp = lame_init();
    lame_init_params(self->gfp);
    return ;
}

static PyObject *Encoder_encode(pylame2_EncoderObject *self, PyObject *args)
{
    char *in_buffer;
    int in_length;
    int mp3_length;
    char *mp3_buffer;
    int mp3_bytes;
    if(!(self->outfp && self->gtp))
    {
        PyErr_SetString(PyExc_Exception, "encoder not open");
        return NULL;
    }

    if(!PyArg_ParseTuple(args, "s#", &in_buffer, &in_length))
    {
        return NULL;
    }
    in_length /=;
    mp3_length = (int)(1.25 * in_length) + ;
    mp3_buffer = (char*)malloc(mp3_length);

    if(in_length > )
    {
        mp3_bytes = lame_encode_buffer_interleaved(
            self->gtp,
            (short *)in_buffer,
            in_length / ,
            mp3_buffer,
            mp3_length
        );
        if(mpe3_bytes > )
        {
            //fwrite(mp3_buffer, 1, mp3_bytes, self->outfp);
            PyObject * write_result = PyObject_CallMethod(self->outfp, "write", "(s#)", mp3_buffer, mp3_bytes);
            if(!write_result)
            {
                free(mp3_buffer);
                return NULL;
            }
            Py_DECREF(write_result);
        }
    }
   // free(mp3_buffer);
   // Py_RETURN_NONE;
}
static PyObject *Encoder_close(pylame2_EncoderObject * self)
{
    int mp3_length;
    char * mp3_buffer;
    int mpe3_bytes;
    if(!(self->outfp && self->gfp))
    {
        PyErr_SetString(PyExc_Exception, "encoder not open");
        return NULL;
    }
    mp3_length = ;
    mp3_buffer = (char*)malloc(mp3_length);
    mp3_bytes = lame_encode_flush(self->gfp, mp3_buffer, sizeof(mp3_buffer));
    if(mp3_bytes > )
    {
        fwrite(mp3_buffer, , 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, "Closes the output file."},
    {NULL, NULL, , NULL}
};
static PyTypeObject pylame2_EncoderType = {
    PyObject_HEAD_INIT(NULL)
    ,                                  /* ob_size */
    "pylame2.Encoder",                  /* tp_name */
    sizeof(pylame2_EncoderObject),      /* tp_basicsize */
    ,                                  /* tp_itemsize */
    (destructor)Encoder_dealloc,        /* tp_dealloc */
    ,                                  /* tp_print */
    ,                                  /* tp_getattr */
    ,                                  /* tp_setattr */
    ,                                  /* tp_compare */
    ,                                  /* tp_repr */
    ,                                  /* tp_as_number */
    ,                                  /* tp_as_sequence */
    ,                                  /* tp_as_mapping */
    ,                                  /* tp_hash */
    ,                                  /* tp_call */
    ,                                  /* tp_str */
    ,                                  /* tp_getattro */
    ,                                  /* tp_setattro */
    Py_TPFLAGS_DEFAULT,                 /* tp_flags */
    "My first encoder object.",         /* tp_doc */
    ,                                  /* tp_traverse */
    ,                                  /* tp_clear */
    ,                                  /* tp_richcompare */
    ,                                  /* tp_weaklistoffset */
    ,                                  /* tp_iter */
    ,                                  /* tp_iternext */
    Encoder_methods,                    /* tp_methods */
    ,                                  /* tp_members */
    ,                                  /* tp_getset */
    ,                                  /* tp_base */
    ,                                  /* tp_dict */
    ,                                  /* tp_descr_get */
    ,                                  /* tp_descr_set */
    ,                                  /* tp_dictoffset */
    (initproc)Encoder_init,             /* tp_init */
    ,                                  /* tp_alloc */
    Encoder_new,                        /* tp_new */
    ,                                  /* tp_free */
};

static PyMethodDef pylame2_methods[] = {
    {NULL, NULL, , NULL}
};

PyMODINIT_FUNC initpylame2(){
    PyObject *m;
    if(PyType_Ready(&pylame2_EncoderType) < )
    {
        return;
    }
    m = Py_InitModule3("pylame2", pylame2_methods, "My Second LAME module.");
    Py_INCREF(&pylame2_EncoderType);
    PyModule_AddObject(m, "Encoder", (PyObject *)&pylame2_EncoderType);
};

/*
    gcc -shared -I/usr/include/pytyon3.1 -I/usr/include/lame pylame2.c -lmp3lame -o pylame2.so
*/
/*python code
    import pylame2

    INBUFSIZE = 4096

    class MyFile(file):
        def __init__(self, path, mode):
            file.__init__(self, path, mode)
            self.n = 0

        def write(self, s):
            file.write(self, s)
            self.n += 1

    output = MyFile('test3.mp3', 'wb')
    encoder = pylame2.Encoder(output)
    input = file('test.raw', 'rb')

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

    input.close()
    encoder.close()
    output.close()

    print("output.write was called %d times" % output.n)
*/