int
main (int argc, char ** argv)
{
OGGZ * oggz;
OggzTable * tracks;
long n;
if (argc < 2) {
printf ("usage: %s filename\n", argv[0]);
}
tracks = oggz_table_new ();
if ((oggz = oggz_open ((char *)argv[1], OGGZ_READ | OGGZ_AUTO)) == NULL) {
printf ("unable to open file %s\n", argv[1]);
exit (1);
}
oggz_set_read_page (oggz, -1, read_page, tracks);
while ((n = oggz_read (oggz, 1024)) > 0);
oggz_close (oggz);
oggz_table_delete (tracks);
exit (0);
}
int play (char * file, char ** opts) {
OGGZ * oggz;
struct roarfish_play_inst inst;
inst.roarfh = -1;
inst.begun = 0;
inst.fsound = fish_sound_new(FISH_SOUND_DECODE, &inst.fsinfo);
fish_sound_set_interleave(inst.fsound, 1);
fish_sound_set_decoded_float_ilv(inst.fsound, decoded_float, (void*)&inst);
if ((oggz = oggz_open(file, OGGZ_READ)) == NULL) {
ROAR_ERR("Can not open input file: %s", file);
return -1;
}
oggz_set_read_callback(oggz, -1, read_packet, inst.fsound);
// TODO: add some status display here?
while (oggz_read(oggz, 1024));
oggz_close(oggz);
fish_sound_delete(inst.fsound);
return -1;
}
void load_ogg_file(const char *filename)
{
OGGZ *oggz;
oggz = oggz_open(filename, OGGZ_READ | OGGZ_AUTO);
if ( oggz == NULL )
{
mylog("Error opening ogg file\n");
}
mylog("Successfully opened ogg file %s\n", filename);
// Initialize internal streams
audio_stream = calloc(1, sizeof(struct ogg_stream));
video_stream = calloc(1, sizeof(struct ogg_stream));
oggz_set_read_callback(oggz, -1, read_cb, NULL);
oggz_set_read_page(oggz, -1, read_page_cb, NULL);
oggz_run(oggz);
//mylog("Audio stream, serialno=%d\n", audio_stream->serialno);
//dump_stream(audio_stream);
//mylog("Video stream, serialno=%d\n", video_stream->serialno);
//dump_stream(video_stream);
oggz_close(oggz);
}
static FS_DecEnc *
fs_encdec_new (char * infilename, char * outfilename, int format,
int interleave, int blocksize)
{
FS_DecEnc * ed;
if (infilename == NULL || outfilename == NULL) return NULL;
ed = malloc (sizeof (FS_DecEnc));
ed->infilename = strdup (infilename);
ed->outfilename = strdup (outfilename);
ed->oggz_in = oggz_open (infilename, OGGZ_READ);
ed->oggz_out = oggz_open (outfilename, OGGZ_WRITE);
oggz_set_read_callback (ed->oggz_in, -1, read_packet, ed);
ed->serialno = oggz_serialno_new (ed->oggz_out);
ed->decoder = fish_sound_new (FISH_SOUND_DECODE, NULL);
fish_sound_set_interleave (ed->decoder, interleave);
fish_sound_set_decoded_float_ilv (ed->decoder, decoded, ed);
ed->format = format;
ed->interleave = interleave;
ed->blocksize = blocksize;
ed->begun = 0;
ed->b_o_s = 1;
/* Delay the setting of channels and allocation of PCM buffers until
* the number of channels is known from decoding the headers */
ed->channels = 0;
ed->pcm = NULL;
ed->frames_in = 0;
ed->frames_out = 0;
return ed;
}
int
main (int argc, char ** argv)
{
OGGZ * oggz;
if (argc < 2) {
printf ("usage: %s filename\n", argv[0]);
}
if ((oggz = oggz_open ((char *)argv[1], OGGZ_READ | OGGZ_AUTO)) == NULL) {
printf ("unable to open file %s\n", argv[1]);
exit (1);
}
oggz_set_read_callback (oggz, -1, read_packet, NULL);
oggz_run (oggz);
oggz_close (oggz);
exit (0);
}
OggVorbisReadStream::OggVorbisReadStream(QString path) :
m_path(path),
m_d(new D(this))
{
m_channelCount = 0;
m_sampleRate = 0;
if (!(m_d->m_oggz = oggz_open(path.toLocal8Bit().data(), OGGZ_READ))) {
m_error = QString("File \"%1\" is not an OGG file.").arg(path);
return;
}
FishSoundInfo fsinfo;
m_d->m_fishSound = fish_sound_new(FISH_SOUND_DECODE, &fsinfo);
fish_sound_set_decoded_callback(m_d->m_fishSound, D::acceptFramesStatic, m_d);
oggz_set_read_callback(m_d->m_oggz, -1, D::acceptPacketStatic, m_d);
// initialise m_channelCount
while (m_channelCount == 0 && !m_d->m_finished) {
m_d->readNextBlock();
}
}
int
speex_dec_open(decoder_t * dec, char * filename) {
speex_pdata_t * pd = (speex_pdata_t *)dec->pdata;
file_decoder_t * fdec = dec->fdec;
int enh = 1;
char ogg_sig[4];
long length_in_bytes = 0;
long length_in_samples = 0;
if ((pd->speex_file = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "speex_decoder_open: fopen() failed\n");
return DECODER_OPEN_FERROR;
}
if (fread(ogg_sig, 1, 4, pd->speex_file) != 4) {
fprintf(stderr, "couldn't read OGG signature from %s\n", filename);
return DECODER_OPEN_FERROR;
}
if ((ogg_sig[0] != 'O') ||
(ogg_sig[1] != 'g') ||
(ogg_sig[2] != 'g') ||
(ogg_sig[3] != 'S')) {
/* not an OGG stream */
fclose(pd->speex_file);
return DECODER_OPEN_BADLIB;
}
if ((pd->oggz = oggz_open(filename, OGGZ_READ | OGGZ_AUTO)) == NULL) {
printf("nonexistent or unaccessible file %s\n", filename);
return DECODER_OPEN_FERROR;
}
oggz_set_read_callback(pd->oggz, -1, read_ogg_packet, dec);
pd->packetno = 0;
pd->exploring = 1;
pd->error = 0;
while (pd->packetno < 2) { /* process Speex header and comments */
oggz_read(pd->oggz, 1024);
}
if (pd->error != 0) {
printf("Error opening Speex\n");
oggz_close(pd->oggz);
return DECODER_OPEN_BADLIB;
}
/* parse ogg packets till eof to get the last granulepos */
while (oggz_read(pd->oggz, 1024) > 0)
;
length_in_bytes = oggz_tell(pd->oggz);
oggz_close(pd->oggz);
speex_bits_destroy(&(pd->bits));
speex_decoder_destroy(pd->decoder);
if ((pd->channels != 1) && (pd->channels != 2)) {
printf("Sorry, Ogg Speex with %d channels is unsupported\n", pd->channels);
return DECODER_OPEN_FERROR;
}
pd->packetno = 0;
pd->exploring = 0;
pd->error = 0;
pd->oggz = oggz_open(filename, OGGZ_READ | OGGZ_AUTO);
oggz_set_read_callback(pd->oggz, -1, read_ogg_packet, dec);
speex_bits_init(&(pd->bits));
pd->decoder = speex_decoder_init(pd->mode);
speex_decoder_ctl(pd->decoder, SPEEX_SET_ENH, &enh);
pd->is_eos = 0;
pd->rb = rb_create(pd->channels * sample_size * RB_SPEEX_SIZE);
fdec->fileinfo.channels = pd->channels;
fdec->fileinfo.sample_rate = pd->sample_rate;
length_in_samples = pd->granulepos + pd->nframes - 1;
fdec->fileinfo.total_samples = length_in_samples;
fdec->fileinfo.bps = 8 * length_in_bytes / (length_in_samples / pd->sample_rate);
fdec->file_lib = SPEEX_LIB;
strcpy(dec->format_str, "Ogg Speex");
return DECODER_OPEN_SUCCESS;
}
