vorbisfile-python/vorbisfile.c

   1 #include <Python.h>
   2 #include <vorbis/vorbisfile.h>
   3
   4 static size_t read_func(void *ptr, size_t size, size_t nmemb, void *datasource)
   5 {
   6     PyObject *file, *read;
   7     PyObject *arglist, *result;
   8     char *str;
   9     size_t strsize;
  10
  11     file = (PyObject *)datasource;
  12     read = PyObject_GetAttrString(file, "read");
  13
  14     arglist = Py_BuildValue("(i)", size*nmemb);
  15     result = PyEval_CallObject(read, arglist);
  16     Py_DECREF(arglist);
  17
  18     if (result == NULL) {
  19         printf("DEBUG: got null result from read()\n");
  20         PyErr_Print();
  21         return -1;
  22     }
  23
  24     if (!PyString_Check(result)) {
  25         printf("DEBUG: result is not a string!\n");
  26         PyErr_SetString(PyExc_StandardError, "Result of read callback not a string");
  27         return -1;
  28     }
  29
  30
  31     strsize = PyString_Size(result);
  32     str = PyString_AsString(result);
  33     memcpy(ptr, (void *)str, strsize);
  34
  35     Py_DECREF(result);
  36
  37     return strsize;
  38 }
  39
  40 static int seek_func(void *datasource, ogg_int64_t offset, int whence)
  41 {
  42     PyObject *file, *seek, *result;
  43     PyObject *arglist;
  44     int ret;
  45
  46     file = (PyObject *)datasource;
  47     seek = PyObject_GetAttrString(file, "seek");
  48
  49     /* call seek func */
  50     arglist = Py_BuildValue("(li)", (long)offset, whence);
  51     result = PyEval_CallObject(seek, arglist);
  52     Py_DECREF(arglist);
  53
  54     if (result == NULL) {
  55         printf("DEBUG: got null result from seek\n");
  56         PyErr_Print();
  57         return -1;
  58     }
  59
  60     ret = PyInt_AsLong(result);
  61     Py_DECREF(result);
  62
  63     return ret;
  64 }
  65
  66 static int close_func(void *datasource)
  67 {
  68     PyObject *file, *close;
  69     PyObject *result;
  70
  71     file = (PyObject *)datasource;
  72     close = PyObject_GetAttrString(file, "close");
  73
  74     result = PyEval_CallObject(close, NULL);
  75     if (result != NULL) Py_DECREF(result);
  76
  77     Py_DECREF(file);
  78
  79     return 0;
  80 }
  81
  82 static long tell_func(void *datasource)
  83 {
  84     PyObject *file, *tell;
  85     PyObject *result;
  86     long ret;
  87
  88     file = (PyObject *)datasource;
  89     tell = PyObject_GetAttrString(file, "tell");
  90
  91     result = PyEval_CallObject(tell, NULL);
  92
  93     if (result == NULL) {
  94         printf("DEBUG: got null result from tell\n");
  95         PyErr_Print();
  96         return -1;
  97     }
  98
  99     if (PyLong_Check(result)) {
 100         ret = PyLong_AsLong(result);
 101     } else if (PyInt_Check(result)) {
 102         ret = PyInt_AsLong(result);
 103     } else {
 104         printf("DEBUG: got non-long/non-int from tell\n");
 105         return -1;
 106     }
 107
 108     return ret;
 109 }
 110
 111 static void vf_destroy(void *data)
 112 {
 113     ov_clear((OggVorbis_File *)data);
 114 }
 115
 116 /* ov_open_py(file)
 117 ** returns a vorbisfile object
 118 */
 119 static PyObject *ov_open_py(PyObject *self, PyObject *args)
 120 {
 121     PyObject *file, *read, *seek, *close, *tell;
 122     PyObject *result;
 123     ov_callbacks callbacks;
 124     OggVorbis_File *vf;
 125     int ret;
 126
 127     if (!PyArg_ParseTuple(args, "O", &file)) {
 128         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 129         return NULL;
 130     }
 131
 132     if (!PyFile_Check(file)) {
 133         PyErr_SetString(PyExc_TypeError, "Expected a file object");
 134         return NULL;
 135     }
 136
 137     /* setup callback functions */
 138     callbacks.read_func = read_func;
 139     callbacks.seek_func = seek_func;
 140     callbacks.tell_func = tell_func;
 141     callbacks.close_func = close_func;
 142
 143
 144     vf = (OggVorbis_File *)PyMem_Malloc(sizeof(OggVorbis_File));
 145     Py_INCREF(file);
 146     ret = ov_open_callbacks((void *)file, vf, NULL, 0, callbacks);
 147     if (ret != 0) {
 148         /* FIXME: handle open failures more gracefully */
 149         PyErr_SetString(PyExc_StandardError, "ov_open failed");
 150         PyMem_Free((void *)vf);
 151         return NULL;
 152     }
 153
 154     result = PyCObject_FromVoidPtr((void *)vf, vf_destroy);
 155
 156     return result;
 157 }
 158
 159 static PyObject *ov_test_py(PyObject *self, PyObject *args)
 160 {
 161     PyObject *file, *read, *seek, *close, *tell;
 162     PyObject *result;
 163     ov_callbacks callbacks;
 164     OggVorbis_File *vf;
 165     int ret;
 166
 167     if (!PyArg_ParseTuple(args, "O", &file)) {
 168         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 169         return NULL;
 170     }
 171
 172     if (!PyFile_Check(file)) {
 173         PyErr_SetString(PyExc_TypeError, "Expected a file object");
 174         return NULL;
 175     }
 176
 177     /* setup callback functions */
 178     callbacks.read_func = read_func;
 179     callbacks.seek_func = seek_func;
 180     callbacks.tell_func = tell_func;
 181     callbacks.close_func = close_func;
 182
 183
 184     vf = (OggVorbis_File *)PyMem_Malloc(sizeof(OggVorbis_File));
 185     Py_INCREF(file);
 186     ret = ov_test_callbacks((void *)file, vf, NULL, 0, callbacks);
 187     if (ret != 0) {
 188         /* FIXME: implement error handling */
 189         PyErr_SetString(PyExc_StandardError, "ov_test failed");
 190         PyMem_Free((void *)vf);
 191         return NULL;
 192     }
 193
 194     result = PyCObject_FromVoidPtr((void *)vf, vf_destroy);
 195
 196     return result;
 197 }
 198
 199 static PyObject *ov_test_open_py(PyObject *self, PyObject *args)
 200 {
 201     PyObject *cobj, *result;
 202     int ret;
 203     OggVorbis_File *vf;
 204
 205     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 206         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 207         return NULL;
 208     }
 209
 210     if (!PyCObject_Check(cobj)) {
 211         PyErr_SetString(PyExc_TypeError, "Expected a vorbisfile object");
 212         return NULL;
 213     }
 214
 215     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 216     ret = ov_test_open(vf);
 217
 218     result = Py_BuildValue("i", ret);
 219     return result;
 220 }
 221
 222 static PyObject *ov_clear_py(PyObject *self, PyObject *args)
 223 {
 224     PyObject *cobj;
 225     OggVorbis_File *vf;
 226     int ret;
 227     PyObject *result;
 228
 229     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 230         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 231         return NULL;
 232     }
 233
 234     if (!PyCObject_Check(cobj)) {
 235         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 236         return NULL;
 237     }
 238
 239     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 240     ret = ov_clear(vf);
 241
 242     result = Py_BuildValue("i", ret);
 243     return result;
 244 }
 245
 246 static PyObject *ov_bitrate_py(PyObject *self, PyObject *args)
 247 {
 248     PyObject *cobj, *result;
 249     int link;
 250     long ret;
 251     OggVorbis_File *vf;
 252
 253     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 254         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 255         return NULL;
 256     }
 257
 258     if (!PyCObject_Check(cobj)) {
 259         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 260         return NULL;
 261     }
 262
 263     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 264
 265     ret = ov_bitrate(vf, link);
 266
 267     result = Py_BuildValue("i", ret);
 268     return result;
 269 }
 270
 271 static PyObject *ov_bitrate_instant_py(PyObject *self, PyObject *args)
 272 {
 273     PyObject *cobj, *result;
 274     long ret;
 275     OggVorbis_File *vf;
 276
 277     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 278         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 279         return NULL;
 280     }
 281
 282     if (!PyCObject_Check(cobj)) {
 283         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 284         return NULL;
 285     }
 286
 287     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 288     ret = ov_bitrate_instant(vf);
 289
 290     result = Py_BuildValue("i", ret);
 291     return result;
 292 }
 293
 294 static PyObject *ov_streams_py(PyObject *self, PyObject *args)
 295 {
 296     PyObject *cobj, *result;
 297     long ret;
 298     OggVorbis_File *vf;
 299
 300     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 301         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 302         return NULL;
 303     }
 304
 305     if (!PyCObject_Check(cobj)) {
 306         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 307         return NULL;
 308     }
 309
 310     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 311     ret = ov_streams(vf);
 312
 313     result = Py_BuildValue("i", ret);
 314     return result;
 315 }
 316
 317 static PyObject *ov_seekable_py(PyObject *self, PyObject *args)
 318 {
 319     PyObject *cobj, *result;
 320     long ret;
 321     OggVorbis_File *vf;
 322
 323     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 324         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 325         return NULL;
 326     }
 327
 328     if (!PyCObject_Check(cobj)) {
 329         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 330         return NULL;
 331     }
 332
 333     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 334     ret = ov_seekable(vf);
 335
 336     result = Py_BuildValue("i", ret);
 337     return result;
 338 }
 339
 340 static PyObject *ov_serialnumber_py(PyObject *self, PyObject *args)
 341 {
 342     PyObject *cobj, *result;
 343     long ret;
 344     int link;
 345     OggVorbis_File *vf;
 346
 347     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 348         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 349         return NULL;
 350     }
 351
 352     if (!PyCObject_Check(cobj)) {
 353         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 354         return NULL;
 355     }
 356
 357     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 358     ret = ov_serialnumber(vf, link);
 359
 360     result = Py_BuildValue("i", ret);
 361     return result;
 362 }
 363
 364 static PyObject *ov_raw_total_py(PyObject *self, PyObject *args)
 365 {
 366     PyObject *cobj, *result;
 367     ogg_int64_t ret;
 368     int link;
 369     OggVorbis_File *vf;
 370
 371     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 372         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 373         return NULL;
 374     }
 375
 376     if (!PyCObject_Check(cobj)) {
 377         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 378         return NULL;
 379     }
 380
 381     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 382     ret = ov_raw_total(vf, link);
 383
 384     result = PyLong_FromLongLong(ret);
 385     return result;
 386 }
 387
 388 static PyObject *ov_pcm_total_py(PyObject *self, PyObject *args)
 389 {
 390     PyObject *cobj, *result;
 391     ogg_int64_t ret;
 392     int link;
 393     OggVorbis_File *vf;
 394
 395     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 396         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 397         return NULL;
 398     }
 399
 400     if (!PyCObject_Check(cobj)) {
 401         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 402         return NULL;
 403     }
 404
 405     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 406     ret = ov_pcm_total(vf, link);
 407
 408     result = PyLong_FromLongLong(ret);
 409     return result;
 410 }
 411
 412 static PyObject *ov_time_total_py(PyObject *self, PyObject *args)
 413 {
 414     PyObject *cobj, *result;
 415     double ret;
 416     int link;
 417     OggVorbis_File *vf;
 418
 419     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 420         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 421         return NULL;
 422     }
 423
 424     if (!PyCObject_Check(cobj)) {
 425         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 426         return NULL;
 427     }
 428
 429     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 430     ret = ov_time_total(vf, link);
 431
 432     result = Py_BuildValue("d", ret);
 433     return result;
 434 }
 435
 436 static PyObject *ov_raw_seek_py(PyObject *self, PyObject *args)
 437 {
 438     PyObject *cobj, *result;
 439     int ret;
 440     ogg_int64_t pos;
 441     OggVorbis_File *vf;
 442
 443     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 444         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 445         return NULL;
 446     }
 447
 448     if (!PyCObject_Check(cobj)) {
 449         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 450         return NULL;
 451     }
 452
 453     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 454     ret = ov_raw_seek(vf, pos);
 455
 456     result = Py_BuildValue("i", ret);
 457     return result;
 458 }
 459
 460 static PyObject *ov_pcm_seek_py(PyObject *self, PyObject *args)
 461 {
 462     PyObject *cobj, *result;
 463     int ret;
 464     ogg_int64_t pos;
 465     OggVorbis_File *vf;
 466
 467     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 468         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 469         return NULL;
 470     }
 471
 472     if (!PyCObject_Check(cobj)) {
 473         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 474         return NULL;
 475     }
 476
 477     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 478     ret = ov_pcm_seek(vf, pos);
 479
 480     result = Py_BuildValue("i", ret);
 481     return result;
 482 }
 483
 484 static PyObject *ov_pcm_seek_page_py(PyObject *self, PyObject *args)
 485 {
 486     PyObject *cobj, *result;
 487     int ret;
 488     ogg_int64_t pos;
 489     OggVorbis_File *vf;
 490
 491     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 492         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 493         return NULL;
 494     }
 495
 496     if (!PyCObject_Check(cobj)) {
 497         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 498         return NULL;
 499     }
 500
 501     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 502     ret = ov_pcm_seek_page(vf, pos);
 503
 504     result = Py_BuildValue("i", ret);
 505     return result;
 506 }
 507
 508 static PyObject *ov_time_seek_py(PyObject *self, PyObject *args)
 509 {
 510     PyObject *cobj, *result;
 511     int ret;
 512     double pos;
 513     OggVorbis_File *vf;
 514
 515     if (!PyArg_ParseTuple(args, "Od", &cobj, &pos)) {
 516         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 517         return NULL;
 518     }
 519
 520     if (!PyCObject_Check(cobj)) {
 521         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 522         return NULL;
 523     }
 524
 525     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 526     ret = ov_time_seek(vf, pos);
 527
 528     result = Py_BuildValue("i", ret);
 529     return result;
 530 }
 531
 532 static PyObject *ov_time_seek_page_py(PyObject *self, PyObject *args)
 533 {
 534     PyObject *cobj, *result;
 535     int ret;
 536     double pos;
 537     OggVorbis_File *vf;
 538
 539     if (!PyArg_ParseTuple(args, "Od", &cobj, &pos)) {
 540         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 541         return NULL;
 542     }
 543
 544     if (!PyCObject_Check(cobj)) {
 545         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 546         return NULL;
 547     }
 548
 549     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 550     ret = ov_time_seek_page(vf, pos);
 551
 552     result = Py_BuildValue("i", ret);
 553     return result;
 554 }
 555
 556 static PyObject *ov_raw_seek_lap_py(PyObject *self, PyObject *args)
 557 {
 558     PyObject *cobj, *result;
 559     int ret;
 560     ogg_int64_t pos;
 561     OggVorbis_File *vf;
 562
 563     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 564         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 565         return NULL;
 566     }
 567
 568     if (!PyCObject_Check(cobj)) {
 569         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 570         return NULL;
 571     }
 572
 573     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 574     ret = ov_raw_seek_lap(vf, pos);
 575
 576     result = Py_BuildValue("i", ret);
 577     return result;
 578 }
 579
 580 static PyObject *ov_pcm_seek_lap_py(PyObject *self, PyObject *args)
 581 {
 582     PyObject *cobj, *result;
 583     int ret;
 584     ogg_int64_t pos;
 585     OggVorbis_File *vf;
 586
 587     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 588         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 589         return NULL;
 590     }
 591
 592     if (!PyCObject_Check(cobj)) {
 593         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 594         return NULL;
 595     }
 596
 597     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 598     ret = ov_pcm_seek_lap(vf, pos);
 599
 600     result = Py_BuildValue("i", ret);
 601     return result;
 602 }
 603
 604 static PyObject *ov_pcm_seek_page_lap_py(PyObject *self, PyObject *args)
 605 {
 606     PyObject *cobj, *result;
 607     int ret;
 608     ogg_int64_t pos;
 609     OggVorbis_File *vf;
 610
 611     if (!PyArg_ParseTuple(args, "OL", &cobj, &pos)) {
 612         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 613         return NULL;
 614     }
 615
 616     if (!PyCObject_Check(cobj)) {
 617         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 618         return NULL;
 619     }
 620
 621     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 622     ret = ov_pcm_seek_page_lap(vf, pos);
 623
 624     result = Py_BuildValue("i", ret);
 625     return result;
 626 }
 627
 628 static PyObject *ov_time_seek_lap_py(PyObject *self, PyObject *args)
 629 {
 630     PyObject *cobj, *result;
 631     int ret;
 632     double pos;
 633     OggVorbis_File *vf;
 634
 635     if (!PyArg_ParseTuple(args, "Od", &cobj, &pos)) {
 636         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 637         return NULL;
 638     }
 639
 640     if (!PyCObject_Check(cobj)) {
 641         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 642         return NULL;
 643     }
 644
 645     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 646     ret = ov_time_seek_lap(vf, pos);
 647
 648     result = Py_BuildValue("i", ret);
 649     return result;
 650 }
 651
 652 static PyObject *ov_time_seek_page_lap_py(PyObject *self, PyObject *args)
 653 {
 654     PyObject *cobj, *result;
 655     int ret;
 656     double pos;
 657     OggVorbis_File *vf;
 658
 659     if (!PyArg_ParseTuple(args, "Od", &cobj, &pos)) {
 660         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 661         return NULL;
 662     }
 663
 664     if (!PyCObject_Check(cobj)) {
 665         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 666         return NULL;
 667     }
 668
 669     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 670     ret = ov_time_seek_page_lap(vf, pos);
 671
 672     result = Py_BuildValue("i", ret);
 673     return result;
 674 }
 675
 676 static PyObject *ov_raw_tell_py(PyObject *self, PyObject *args)
 677 {
 678     PyObject *cobj, *result;
 679     ogg_int64_t ret;
 680     OggVorbis_File *vf;
 681
 682     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 683         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 684         return NULL;
 685     }
 686
 687     if (!PyCObject_Check(cobj)) {
 688         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 689         return NULL;
 690     }
 691
 692     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 693     ret = ov_raw_tell(vf);
 694
 695     result = PyLong_FromLongLong(ret);
 696     return result;
 697 }
 698
 699 static PyObject *ov_pcm_tell_py(PyObject *self, PyObject *args)
 700 {
 701     PyObject *cobj, *result;
 702     ogg_int64_t ret;
 703     OggVorbis_File *vf;
 704
 705     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 706         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 707         return NULL;
 708     }
 709
 710     if (!PyCObject_Check(cobj)) {
 711         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 712         return NULL;
 713     }
 714
 715     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 716     ret = ov_pcm_tell(vf);
 717
 718     result = PyLong_FromLongLong(ret);
 719     return result;
 720 }
 721
 722 static PyObject *ov_time_tell_py(PyObject *self, PyObject *args)
 723 {
 724     PyObject *cobj, *result;
 725     double ret;
 726     OggVorbis_File *vf;
 727
 728     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 729         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 730         return NULL;
 731     }
 732
 733     if (!PyCObject_Check(cobj)) {
 734         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 735         return NULL;
 736     }
 737
 738     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 739     ret = ov_time_tell(vf);
 740
 741     result = Py_BuildValue("d", ret);
 742     return result;
 743 }
 744
 745 static PyObject *ov_info_py(PyObject *self, PyObject *args)
 746 {
 747     PyObject *cobj, *result;
 748     vorbis_info *ret;
 749     int link;
 750     OggVorbis_File *vf;
 751
 752     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 753         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 754         return NULL;
 755     }
 756
 757     if (!PyCObject_Check(cobj)) {
 758         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 759         return NULL;
 760     }
 761
 762     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 763     ret = ov_info(vf, link);
 764
 765     result = PyCObject_FromVoidPtr((void *)ret, NULL);
 766     return result;
 767 }
 768
 769 static PyObject *ov_comment_py(PyObject *self, PyObject *args)
 770 {
 771     PyObject *cobj, *result;
 772     vorbis_comment *ret;
 773     int link;
 774     OggVorbis_File *vf;
 775
 776     if (!PyArg_ParseTuple(args, "Oi", &cobj, &link)) {
 777         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 778         return NULL;
 779     }
 780
 781     if (!PyCObject_Check(cobj)) {
 782         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 783         return NULL;
 784     }
 785
 786     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 787     ret = ov_comment(vf, link);
 788
 789     result = PyCObject_FromVoidPtr((void *)ret, NULL);
 790     return result;
 791 }
 792
 793 static PyObject *ov_read_float_py(PyObject *self, PyObject *args)
 794 {
 795     PyObject *cobj, *result, *channel[255], *list;
 796     long ret;
 797     int current_section, samples, channels, i, j;
 798     float **pcm_channels;
 799     OggVorbis_File *vf;
 800
 801     if (!PyArg_ParseTuple(args, "Oi", &cobj, &samples)) {
 802         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 803         return NULL;
 804     }
 805
 806     if (!PyCObject_Check(cobj)) {
 807         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 808         return NULL;
 809     }
 810
 811     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 812     channels = vf->vi->channels;
 813
 814     ret = ov_read_float(vf, &pcm_channels, samples, &current_section);
 815     if (ret > 0) {
 816         list = PyList_New(channels);
 817         for (i=0; i<channels; i++) {
 818             channel[i] = PyList_New(ret);
 819             PyList_SetItem(list, i, channel[i]);
 820             for (j=0; j<ret; j++) {
 821                 PyList_SetItem(channel[i], j,
 822                                PyFloat_FromDouble(pcm_channels[i][j]));
 823             }
 824         }
 825     }
 826
 827     result = Py_BuildValue("(lOi)", ret, list, current_section);
 828     return result;
 829 }
 830
 831 static PyObject *ov_read_py(PyObject *self, PyObject *args)
 832 {
 833     PyObject *cobj, *result;
 834     long ret;
 835     int current_section, len, bigendianp, word, sgned;
 836     OggVorbis_File *vf;
 837     char *buffer;
 838
 839     if (!PyArg_ParseTuple(args, "Oiiii", &cobj, &len, &bigendianp, &word,
 840                           &sgned)) {
 841         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 842         return NULL;
 843     }
 844
 845     if (!PyCObject_Check(cobj)) {
 846         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 847         return NULL;
 848     }
 849
 850     buffer = (char *)PyMem_Malloc(len);
 851     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 852     ret = ov_read(vf, buffer, len, bigendianp, word, sgned, &current_section);
 853     if (ret >= 0) {
 854         result = Py_BuildValue("(ls#i)", ret, buffer, ret, current_section);
 855     } else {
 856         result = Py_BuildValue("(ls#i)", ret, buffer, 0, current_section);
 857     }
 858     PyMem_Free(buffer);
 859     return result;
 860 }
 861
 862 static PyObject *ov_crosslap_py(PyObject *self, PyObject *args)
 863 {
 864     PyObject *cobj1, *cobj2, *result;
 865     int ret;
 866     OggVorbis_File *vf1, *vf2;
 867
 868     if (!PyArg_ParseTuple(args, "OO", &cobj1, &cobj2)) {
 869         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 870         return NULL;
 871     }
 872
 873     if (!PyCObject_Check(cobj1)) {
 874         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 875         return NULL;
 876     }
 877
 878     if (!PyCObject_Check(cobj2)) {
 879         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 880         return NULL;
 881     }
 882
 883     vf1 = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj1);
 884     vf2 = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj2);
 885     ret = ov_crosslap(vf1, vf2);
 886
 887     result = Py_BuildValue("i", ret);
 888     return result;
 889 }
 890
 891 static PyObject *ov_halfrate_py(PyObject *self, PyObject *args)
 892 {
 893     PyObject *cobj, *result;
 894     int ret, flag;
 895     OggVorbis_File *vf;
 896
 897     if (!PyArg_ParseTuple(args, "Oi", &cobj, &flag)) {
 898         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 899         return NULL;
 900     }
 901
 902     if (!PyCObject_Check(cobj)) {
 903         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 904         return NULL;
 905     }
 906
 907     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 908     ret = ov_halfrate(vf, flag);
 909
 910     result = Py_BuildValue("i", ret);
 911     return result;
 912 }
 913
 914 static PyObject *ov_halfrate_p_py(PyObject *self, PyObject *args)
 915 {
 916     PyObject *cobj, *result;
 917     int ret;
 918     OggVorbis_File *vf;
 919
 920     if (!PyArg_ParseTuple(args, "O", &cobj)) {
 921         PyErr_SetString(PyExc_StandardError, "Couldn't parse arguments");
 922         return NULL;
 923     }
 924
 925     if (!PyCObject_Check(cobj)) {
 926         PyErr_SetString(PyExc_StandardError, "Expected vorbisfile object");
 927         return NULL;
 928     }
 929
 930     vf = (OggVorbis_File *)PyCObject_AsVoidPtr(cobj);
 931     ret = ov_halfrate_p(vf);
 932
 933     result = Py_BuildValue("i", ret);
 934     return result;
 935 }
 936
 937 static PyMethodDef vorbisfileMethods[] = {
 938     {"ov_open", ov_open_py, METH_VARARGS,
 939      "Opens a Vorbis file"},
 940     {"ov_test", ov_test_py, METH_VARARGS,
 941      "Tests if a file is a Vorbis file"},
 942     {"ov_test_open", ov_test_open_py, METH_VARARGS,
 943      "Opens a Vorbis file after testing"},
 944     {"ov_clear", ov_clear_py, METH_VARARGS,
 945      "Clears a vorbisfile object"},
 946     {"ov_bitrate", ov_bitrate_py, METH_VARARGS,
 947      "Returns bitrate of chain(s)"},
 948     {"ov_bitrate_instant", ov_bitrate_instant_py, METH_VARARGS,
 949      "Returns instantaneous bitrate"},
 950     {"ov_streams", ov_streams_py, METH_VARARGS,
 951      "Returns number of chains"},
 952     {"ov_seekable", ov_seekable_py, METH_VARARGS,
 953      "Returns whether stream is seekable"},
 954     {"ov_serialnumber", ov_serialnumber_py, METH_VARARGS,
 955      "Returns a link's serial number"},
 956     {"ov_raw_total", ov_raw_total_py, METH_VARARGS,
 957      "Returns total raw compressed length of bitstream"},
 958     {"ov_pcm_total", ov_pcm_total_py, METH_VARARGS,
 959      "Returns total number of PCM samples"},
 960     {"ov_time_total", ov_time_total_py, METH_VARARGS,
 961      "Returns total length of bitstream in seconds"},
 962     {"ov_raw_seek", ov_raw_seek_py, METH_VARARGS,
 963      "Seeks to an offset relative to compressed data"},
 964     {"ov_pcm_seek", ov_pcm_seek_py, METH_VARARGS,
 965      "Seeks to a sample offset of the PCM data"},
 966     {"ov_pcm_seek_page", ov_pcm_seek_page_py, METH_VARARGS,
 967      "Seeks to page near sample offset"},
 968     {"ov_time_seek", ov_time_seek_py, METH_VARARGS,
 969      "Seeks to sample at time"},
 970     {"ov_time_seek_page", ov_time_seek_page_py, METH_VARARGS,
 971      "Seeks to page near sample at time"},
 972     {"ov_raw_seek_lap", ov_raw_seek_lap_py, METH_VARARGS,
 973      "Seeks something (FIXME)"},
 974     {"ov_pcm_seek_lap", ov_pcm_seek_lap_py, METH_VARARGS,
 975      "Seeks something (FIXME)"},
 976     {"ov_pcm_seek_page_lap", ov_pcm_seek_page_lap_py, METH_VARARGS,
 977      "Seeks something (FIXME)"},
 978     {"ov_time_seek_lap", ov_time_seek_lap_py, METH_VARARGS,
 979      "Seeks something (FIXME)"},
 980     {"ov_time_seek_page_lap", ov_time_seek_page_lap_py, METH_VARARGS,
 981      "Seeks something (FIXME)"},
 982     {"ov_raw_tell", ov_raw_tell_py, METH_VARARGS,
 983      "Returns the current stream offset"},
 984     {"ov_pcm_tell", ov_pcm_tell_py, METH_VARARGS,
 985      "Returns PCM offset of next sample to be read"},
 986     {"ov_time_tell", ov_time_tell_py, METH_VARARGS,
 987      "Returns time offset of next sample to be read"},
 988     {"ov_info", ov_info_py, METH_VARARGS,
 989      "Returns the vorbis_info object for the current chain"},
 990     {"ov_comment", ov_comment_py, METH_VARARGS,
 991      "Returns the vorbis_comment object for the current chain"},
 992     {"ov_read_float", ov_read_float_py, METH_VARARGS,
 993      "Returns array of decoded float data"},
 994     {"ov_read", ov_read_py, METH_VARARGS,
 995      "Returns array of decoded sample data"},
 996     {"ov_crosslap", ov_crosslap_py, METH_VARARGS,
 997      "Crosses something (FIXME)"},
 998     {"ov_halfrate", ov_halfrate_py, METH_VARARGS,
 999      "Does something (FIXME)"},
1000     {"ov_halfrate_p", ov_halfrate_p_py, METH_VARARGS,
1001      "Does something (FIXME)"},
1002     {NULL, NULL, 0, NULL}
1003 };
1004
1005 PyMODINIT_FUNC init_vorbisfile(void)
1006 {
1007     Py_InitModule("_vorbisfile", vorbisfileMethods);
1008 }