int main(int argc, char *argv[]) {
/*perform simple round-trip using page reader and writer*/
BitstreamReader *reader = br_open(stdin, BS_LITTLE_ENDIAN);
BitstreamWriter *writer = bw_open(stdout, BS_LITTLE_ENDIAN);
struct ogg_page page;
do {
ogg_status result;
if ((result = read_ogg_page(reader, &page)) == OGG_OK) {
write_ogg_page(writer, &page);
} else {
fprintf(stderr, "*** Error: %s", ogg_strerror(result));
goto error;
}
} while (!page.header.stream_end);
reader->close(reader);
writer->close(writer);
return 0;
error:
reader->close(reader);
writer->close(writer);
return 1;
}
int
ALACDecoder_init(decoders_ALACDecoder *self,
PyObject *args, PyObject *kwds)
{
char *filename;
static char *kwlist[] = {"filename", NULL};
unsigned i;
self->filename = NULL;
self->file = NULL;
self->bitstream = NULL;
self->audiotools_pcm = NULL;
self->frameset_channels = array_ia_new();
self->frame_channels = array_ia_new();
self->uncompressed_LSBs = array_i_new();
self->residuals = array_i_new();
for (i = 0; i < MAX_CHANNELS; i++) {
self->subframe_headers[i].qlp_coeff = array_i_new();
}
if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &filename))
return -1;
/*open the alac file as a BitstreamReader*/
if ((self->file = fopen(filename, "rb")) == NULL) {
PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
return -1;
} else {
self->bitstream = br_open(self->file, BS_BIG_ENDIAN);
}
self->filename = strdup(filename);
self->bitstream->mark(self->bitstream);
if (parse_decoding_parameters(self)) {
self->bitstream->unmark(self->bitstream);
return -1;
} else {
self->bitstream->rewind(self->bitstream);
}
/*seek to the 'mdat' atom, which contains the ALAC stream*/
if (seek_mdat(self->bitstream) == ERROR) {
self->bitstream->unmark(self->bitstream);
PyErr_SetString(PyExc_ValueError,
"Unable to locate 'mdat' atom in stream");
return -1;
} else {
self->bitstream->unmark(self->bitstream);
}
/*setup a framelist generator function*/
if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL)
return -1;
return 0;
}
OggPacketIterator*
oggiterator_open(FILE *stream)
{
OggPacketIterator *iterator = malloc(sizeof(OggPacketIterator));
iterator->reader = br_open(stream, BS_LITTLE_ENDIAN);
/*force next read to read in a new page*/
iterator->page.header.segment_count = 0;
iterator->current_segment = 1;
iterator->page.header.stream_end = 0;
return iterator;
}
OggReader*
oggreader_open(FILE *stream) {
OggReader *reader = malloc(sizeof(OggReader));
reader->ogg_stream = br_open(stream, BS_LITTLE_ENDIAN);
reader->current_segment = 1;
reader->current_header.page_segment_count = 0;
reader->current_header.type = 0;
reader->current_header.checksum = 0;
reader->checksum = 0;
br_add_callback(reader->ogg_stream, ogg_crc, &(reader->checksum));
return reader;
}
int
FlacDecoder_init(decoders_FlacDecoder *self,
PyObject *args, PyObject *kwds)
{
char* filename;
int stream_offset = 0;
self->filename = NULL;
self->file = NULL;
self->bitstream = NULL;
self->seektable = array_o_new((ARRAY_COPY_FUNC)seekpoint_copy,
free,
NULL);
self->subframe_data = array_ia_new();
self->residuals = array_i_new();
self->qlp_coeffs = array_i_new();
self->framelist_data = array_i_new();
self->audiotools_pcm = NULL;
self->remaining_samples = 0;
if (!PyArg_ParseTuple(args, "si|i",
&filename,
&(self->channel_mask),
&stream_offset))
return -1;
if (self->channel_mask < 0) {
PyErr_SetString(PyExc_ValueError, "channel_mask must be >= 0");
return -1;
}
if (stream_offset < 0) {
PyErr_SetString(PyExc_ValueError, "stream offset must be >= 0");
return -1;
}
/*open the flac file*/
self->file = fopen(filename, "rb");
if (self->file == NULL) {
PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
return -1;
} else {
self->bitstream = br_open(self->file, BS_BIG_ENDIAN);
}
/*skip the given number of bytes, if any*/
if (stream_offset != 0)
fseek(self->file, stream_offset, SEEK_SET);
self->filename = strdup(filename);
/*read the STREAMINFO block, SEEKTABLE block
and setup the total number of samples to read*/
if (flacdec_read_metadata(self->bitstream,
&(self->streaminfo),
self->seektable)) {
self->streaminfo.channels = 0;
return -1;
}
self->remaining_samples = self->streaminfo.total_samples;
/*initialize the output MD5 sum*/
audiotools__MD5Init(&(self->md5));
self->perform_validation = 1;
self->stream_finalized = 0;
/*setup a framelist generator function*/
if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL)
return -1;
/*place mark at beginning of stream in case seeking is needed*/
self->bitstream->mark(self->bitstream);
/*mark stream as not closed and ready for reading*/
self->closed = 0;
return 0;
}
int
FlacDecoder_init(decoders_FlacDecoder *self,
PyObject *args, PyObject *kwds)
{
self->file = NULL;
self->bitstream = NULL;
self->seektable = a_obj_new((ARRAY_COPY_FUNC)seekpoint_copy,
free,
NULL);
self->subframe_data = aa_int_new();
self->residuals = a_int_new();
self->qlp_coeffs = a_int_new();
self->framelist_data = a_int_new();
self->audiotools_pcm = NULL;
self->remaining_samples = 0;
if (!PyArg_ParseTuple(args, "O", &self->file)) {
return -1;
} else {
Py_INCREF(self->file);
}
/*open BitstreamReader from FLAC file stream
based on whether it's a low-level file object*/
if (PyFile_Check(self->file)) {
/*open bitstream through file object*/
self->bitstream = br_open(PyFile_AsFile(self->file), BS_BIG_ENDIAN);
} else {
/*treat file as Python-implemented file-like object*/
self->bitstream = br_open_external(
self->file,
BS_BIG_ENDIAN,
4096,
(ext_read_f)br_read_python,
(ext_close_f)bs_close_python,
(ext_free_f)bs_free_python_nodecref);
}
/*read the STREAMINFO block, SEEKTABLE block
and setup the total number of samples to read*/
if (flacdec_read_metadata(self->bitstream,
&(self->streaminfo),
self->seektable,
&(self->channel_mask))) {
self->streaminfo.channels = 0;
return -1;
}
if (PyFile_Check(self->file)) {
/*place mark at beginning of stream but after metadata
in case seeking is needed*/
self->bitstream->mark(self->bitstream);
}
self->remaining_samples = self->streaminfo.total_samples;
/*initialize the output MD5 sum*/
audiotools__MD5Init(&(self->md5));
self->perform_validation = 1;
self->stream_finalized = 0;
/*setup a framelist generator function*/
if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL)
return -1;
/*mark stream as not closed and ready for reading*/
self->closed = 0;
return 0;
}
PyObject*
verifymodule_ogg(PyObject *dummy, PyObject *args) {
PyObject *file_obj;
BitstreamReader *bitstream;
int has_previous_header = 0;
struct ogg_header previous_header;
struct ogg_header header;
uint8_t *data_buffer = NULL;
int data_buffer_size = 0;
int i;
uint32_t checksum;
/*fixes a "may be used unitialized" warning*/
previous_header.bitstream_serial_number =
previous_header.page_sequence_number = 0;
if (!PyArg_ParseTuple(args, "O", &file_obj))
return NULL;
if (!PyFile_CheckExact(file_obj)) {
PyErr_SetString(PyExc_TypeError,
"first argument must be an actual file object");
return NULL;
} else {
bitstream = br_open(PyFile_AsFile(file_obj), BS_LITTLE_ENDIAN);
br_add_callback(bitstream, ogg_crc, &checksum);
}
if (!setjmp(*br_try(bitstream))) {
do {
checksum = 0;
if (verifymodule_read_ogg_header(bitstream, &header) == OK) {
if (data_buffer_size < header.segment_length_total) {
data_buffer = realloc(data_buffer,
header.segment_length_total);
data_buffer_size = header.segment_length_total;
}
if (fread(data_buffer,
sizeof(uint8_t),
header.segment_length_total,
bitstream->input.file) !=
header.segment_length_total) {
PyErr_SetString(PyExc_IOError, "I/O error reading stream");
goto error;
}
for (i = 0; i < header.segment_length_total; i++)
ogg_crc(data_buffer[i], &checksum);
if (header.checksum != checksum) {
PyErr_SetString(PyExc_ValueError,
"checksum mismatch in stream");
goto error;
}
/* printf("calculated checksum : 0x%8.8X\n", checksum); */
if (has_previous_header) {
if (header.bitstream_serial_number !=
previous_header.bitstream_serial_number) {
PyErr_SetString(PyExc_ValueError,
"differing serial numbers in stream");
goto error;
}
if (header.page_sequence_number !=
(previous_header.page_sequence_number + 1)) {
PyErr_SetString(PyExc_ValueError,
"page sequence number not incrementing");
goto error;
}
previous_header = header;
} else {
previous_header = header;
has_previous_header = 1;
}
} else {
goto error;
}
} while (!(header.type & 0x4));
} else {
PyErr_SetString(PyExc_IOError, "I/O error reading stream");
goto error;
}
br_etry(bitstream);
free(data_buffer);
bitstream->input.file = NULL;
bitstream->free(bitstream);
Py_INCREF(Py_None);
return Py_None;
error:
br_etry(bitstream);
if (data_buffer != NULL)
free(data_buffer);
bitstream->input.file = NULL;
bitstream->free(bitstream);
return NULL;
}
