int get_packet(ogg_sync_state *oy,ogg_stream_state *os,int *init,ogg_packet *op)
{
char *buffer;
size_t bytes;
ogg_page og;
/* try to get a packet from the stream */
if (*init && ogg_stream_packetout(os,op)) return 0;
/* read data and feed the pages to ogg */
buffer=ogg_sync_buffer(oy,4096);
bytes=fread(buffer,1,4096,stdin);
if (bytes==0) return 1; /* we're done */
ogg_sync_wrote(oy,bytes);
while (ogg_sync_pageout(oy,&og)>0) {
if (!*init && ogg_page_bos(&og)) {
ogg_stream_init(os,ogg_page_serialno(&og));
}
ogg_stream_pagein(os,&og);
if (!*init && ogg_page_bos(&og)) {
ogg_packet op;
ogg_stream_packetpeek(os,&op);
if (op.bytes>=8 && !memcmp(op.packet,"\200kate\0\0\0",8)) {
*init=1;
}
else {
ogg_stream_clear(os);
}
}
}
/* try again with the new data */
return get_packet(oy,os,init,op);
}
/*
General reader. Read a page and hand it over for processing.
*/
file_status_e
ogm_reader_c::read(generic_packetizer_c *,
bool) {
// Some tracks may contain huge gaps. We don't want to suck in the complete
// file.
if (get_queued_bytes() > 20 * 1024 * 1024)
return FILE_STATUS_HOLDING;
ogg_page og;
do {
// Make sure we have a page that we can work with.
if (read_page(&og) == FILE_STATUS_DONE)
return flush_packetizers();
// Is this the first page of a new stream? No, so process it normally.
if (!ogg_page_bos(&og))
process_page(&og);
} while (ogg_page_bos(&og));
size_t i;
// Are there streams that have not finished yet?
for (i = 0; i < sdemuxers.size(); i++)
if (!sdemuxers[i]->eos && sdemuxers[i]->in_use)
return FILE_STATUS_MOREDATA;
// No, we're done with this file.
return flush_packetizers();
}
static gboolean demux_next_page(VideoPlayer* player, GError** err)
{
int serialno;
ogg_stream_state* ostream;
/* Demux the next page into player->current_page. */
while (ogg_sync_pageout(&player->osync, &player->current_page) != 1) {
char* buf = ogg_sync_buffer(&player->osync, 65536);
int bytes = fread(buf, 1, 65536, player->file);
if (bytes == 0) {
player->eof = TRUE;
return TRUE;
} else if (bytes < 0) {
g_set_error(err, G_FILE_ERROR, g_file_error_from_errno(errno),
"Failed to read video: %s", g_strerror(errno));
return FALSE;
}
ogg_sync_wrote(&player->osync, bytes);
}
/* Dispatch it to the correct ogg_stream_state. */
serialno = ogg_page_serialno(&player->current_page);
ostream = g_hash_table_lookup(player->stream_table, &serialno);
if (ostream != NULL) {
ogg_stream_pagein(ostream, &player->current_page);
} else if (ogg_page_bos(&player->current_page)) {
int* key = g_new(int, 1);
*key = serialno;
ostream = g_new(ogg_stream_state, 1);
ogg_stream_init(ostream, serialno);
g_hash_table_insert(player->stream_table, key, ostream);
ogg_stream_pagein(ostream, &player->current_page);
}
bool
flac_header_extractor_c::read_page() {
while (1) {
int np = ogg_sync_pageseek(&oy, &og);
if (np <= 0) {
if (np < 0)
return false;
unsigned char *buf = (unsigned char *)ogg_sync_buffer(&oy, BUFFER_SIZE);
if (!buf)
return false;
int nread;
if ((nread = file->read(buf, BUFFER_SIZE)) <= 0)
return false;
ogg_sync_wrote(&oy, nread);
} else if (ogg_page_serialno(&og) == sid)
break;
}
if (ogg_page_bos(&og))
ogg_stream_init(&os, sid);
ogg_stream_pagein(&os, &og);
return true;
}
/* routine for taking the provided page (should be a header page) and
* placing it on the collection of header pages
*/
void format_ogg_attach_header (ogg_codec_t *codec, ogg_page *page)
{
ogg_state_t *ogg_info = codec->parent;
refbuf_t *refbuf;
if (codec->filtered)
return;
refbuf = make_refbuf_with_page (codec, page);
if (ogg_page_bos (page))
{
DEBUG0 ("attaching BOS page");
if (*ogg_info->bos_end == NULL)
ogg_info->header_pages_tail = refbuf;
refbuf->associated = *ogg_info->bos_end;
*ogg_info->bos_end = refbuf;
ogg_info->bos_end = &refbuf->associated;
return;
}
DEBUG0 ("attaching header page");
if (ogg_info->header_pages_tail)
ogg_info->header_pages_tail->associated = refbuf;
ogg_info->header_pages_tail = refbuf;
if (ogg_info->header_pages == NULL)
ogg_info->header_pages = refbuf;
}
static PyObject * py_ogg_ogg_page_bos(PyObject *self, PyObject *args) {
int size;
int c_out;
ogg_page * og;
PyArg_ParseTuple(args, "s#", &og, &size);
c_out = ogg_page_bos(og);
return Py_BuildValue("i", c_out);
};
static ChainState *
validate_ogg_page (ogg_page * page)
{
gulong serialno;
gint64 granule;
ChainState *state;
serialno = ogg_page_serialno (page);
granule = ogg_page_granulepos (page);
state = g_hash_table_lookup (eos_chain_states, GINT_TO_POINTER (serialno));
fail_if (ogg_page_packets (page) == 0 && granule != -1,
"Must have granulepos -1 when page has no packets, has %" G_GINT64_FORMAT,
granule);
if (ogg_page_bos (page)) {
fail_unless (state == NULL, "Extraneous BOS flag on chain %u", serialno);
state = g_new0 (ChainState, 1);
g_hash_table_insert (eos_chain_states, GINT_TO_POINTER (serialno), state);
state->serialno = serialno;
state->last_granule = granule;
state->codec = get_page_codec (page);
/* check for things like BOS ordering, etc */
switch (state->codec) {
case CODEC_THEORA:
/* check we have no vorbis/speex chains yet */
g_hash_table_foreach (eos_chain_states, (GHFunc) fail_if_audio, NULL);
break;
case CODEC_VORBIS:
case CODEC_SPEEX:
/* no checks (yet) */
break;
case CODEC_UNKNOWN:
default:
break;
}
} else if (ogg_page_eos (page)) {
fail_unless (state != NULL, "Missing BOS flag on chain %u", serialno);
state->eos = TRUE;
} else {
fail_unless (state != NULL, "Missing BOS flag on chain %u", serialno);
fail_unless (!state->eos, "Data after EOS flag on chain %u", serialno);
}
if (granule != -1) {
fail_unless (granule >= state->last_granule,
"Granulepos out-of-order for chain %u: old=%" G_GINT64_FORMAT ", new="
G_GINT64_FORMAT, serialno, state->last_granule, granule);
state->last_granule = granule;
}
return state;
}
static int
read_page (OGGZ * oggz, const ogg_page * og, long serialno, void * user_data)
{
OggzTable * tracks = (OggzTable *)user_data;
if (ogg_page_bos ((ogg_page *)og)) {
oggz_table_insert (tracks, serialno, NULL);
}
if (fwrite (og->header, 1, og->header_len, stdout) == (size_t)og->header_len)
if (fwrite (og->body, 1, og->body_len, stdout) != (size_t)og->body_len)
return OGGZ_STOP_ERR;
return 0;
}
nsOggCodecState*
nsOggCodecState::Create(ogg_page* aPage)
{
NS_ASSERTION(ogg_page_bos(aPage), "Only call on BOS page!");
nsAutoPtr<nsOggCodecState> codecState;
if (aPage->body_len > 6 && memcmp(aPage->body+1, "theora", 6) == 0) {
codecState = new nsTheoraState(aPage);
} else if (aPage->body_len > 6 && memcmp(aPage->body+1, "vorbis", 6) == 0) {
codecState = new nsVorbisState(aPage);
} else if (aPage->body_len > 8 && memcmp(aPage->body, "fishead\0", 8) == 0) {
codecState = new nsSkeletonState(aPage);
} else {
codecState = new nsOggCodecState(aPage, PR_FALSE);
}
return codecState->nsOggCodecState::Init() ? codecState.forget() : nsnull;
}
static bool_t vorbis_check_fd (const char * filename, VFSFile * file)
{
ogg_sync_state oy = {0};
ogg_stream_state os = {0};
ogg_page og = {0};
ogg_packet op = {0};
bool_t result = FALSE;
ogg_sync_init (& oy);
while (1)
{
int64_t bytes = ogg_sync_pageseek (& oy, & og);
if (bytes < 0) /* skipped some bytes */
continue;
if (bytes > 0) /* got a page */
break;
void * buffer = ogg_sync_buffer (& oy, 2048);
bytes = vfs_fread (buffer, 1, 2048, file);
if (bytes <= 0)
goto end;
ogg_sync_wrote (& oy, bytes);
}
if (! ogg_page_bos (& og))
goto end;
ogg_stream_init (& os, ogg_page_serialno (& og));
ogg_stream_pagein (& os, & og);
if (ogg_stream_packetout (& os, & op) > 0 && vorbis_synthesis_idheader (& op))
result = TRUE;
end:
ogg_sync_clear (& oy);
ogg_stream_clear (& os);
return result;
}
static int vcedit_supported_stream(vcedit_state *state, ogg_page *og) {
ogg_stream_state os;
vorbis_info vi;
vorbis_comment vc;
ogg_packet header;
int result = 0;
ogg_stream_init(&os, ogg_page_serialno(og));
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
if( !ogg_page_bos(og) )
result = -1;
if(result >= 0 && ogg_stream_pagein(&os, og) < 0)
{
state->lasterror =
_("Error reading first page of Ogg bitstream.");
result = -1;
}
if(result >= 0 && ogg_stream_packetout(&os, &header) != 1)
{
state->lasterror = _("Error reading initial header packet.");
result = -1;
}
if(result >= 0 && vorbis_synthesis_headerin(&vi, &vc, &header) >= 0)
{
result = 1;
} else {
/* Not vorbis, may eventually become a chain of checks (Speex,
* Theora), but for the moment return 0, bos scan will push
* the current page onto the buffer.
*/
}
ogg_stream_clear(&os);
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
return result;
}
/* routine for taking the provided page (should be a header page) and
* placing it on the collection of header pages
*/
void format_ogg_attach_header (ogg_state_t *ogg_info, ogg_page *page)
{
refbuf_t *refbuf = make_refbuf_with_page (page);
if (ogg_page_bos (page))
{
DEBUG0 ("attaching BOS page");
if (*ogg_info->bos_end == NULL)
ogg_info->header_pages_tail = refbuf;
refbuf->next = *ogg_info->bos_end;
*ogg_info->bos_end = refbuf;
ogg_info->bos_end = &refbuf->next;
return;
}
DEBUG0 ("attaching header page");
if (ogg_info->header_pages_tail)
ogg_info->header_pages_tail->next = refbuf;
ogg_info->header_pages_tail = refbuf;
if (ogg_info->header_pages == NULL)
ogg_info->header_pages = refbuf;
}
/*
Read all header packets and - for Vorbis streams - the comment and
codec data packets.
*/
int
ogm_reader_c::read_headers_internal() {
ogg_page og;
bool done = false;
while (!done) {
// Make sure we have a page that we can work with.
if (read_page(&og) == FILE_STATUS_DONE)
return 0;
// Is this the first page of a new stream?
if (ogg_page_bos(&og))
handle_new_stream_and_packets(&og);
else { // No, so check if it's still a header page.
bos_pages_read = 1;
process_header_page(&og);
done = true;
size_t i;
for (i = 0; i < sdemuxers.size(); i++) {
ogm_demuxer_cptr &dmx = sdemuxers[i];
if (!dmx->headers_read && dmx->in_use) {
done = false;
break;
}
}
}
}
m_in->setFilePointer(0, seek_beginning);
ogg_sync_clear(&oy);
ogg_sync_init(&oy);
return 1;
}
/* Reads in buffers, parses them, reframes into one-buffer-per-ogg-page, submits
* pages to output pad.
*/
static GstFlowReturn
gst_ogg_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstOggParse *ogg;
GstFlowReturn result = GST_FLOW_OK;
gint ret = -1;
guint32 serialno;
GstBuffer *pagebuffer;
GstClockTime buffertimestamp = GST_BUFFER_TIMESTAMP (buffer);
ogg = GST_OGG_PARSE (parent);
GST_LOG_OBJECT (ogg,
"Chain function received buffer of size %" G_GSIZE_FORMAT,
gst_buffer_get_size (buffer));
gst_ogg_parse_submit_buffer (ogg, buffer);
while (ret != 0 && result == GST_FLOW_OK) {
ogg_page page;
/* We use ogg_sync_pageseek() rather than ogg_sync_pageout() so that we can
* track how many bytes the ogg layer discarded (in the case of sync errors,
* etc.); this allows us to accurately track the current stream offset
*/
ret = ogg_sync_pageseek (&ogg->sync, &page);
if (ret == 0) {
/* need more data, that's fine... */
break;
} else if (ret < 0) {
/* discontinuity; track how many bytes we skipped (-ret) */
ogg->offset -= ret;
} else {
gint64 granule = ogg_page_granulepos (&page);
#ifndef GST_DISABLE_GST_DEBUG
int bos = ogg_page_bos (&page);
#endif
guint64 startoffset = ogg->offset;
GstOggStream *stream;
gboolean keyframe;
serialno = ogg_page_serialno (&page);
stream = gst_ogg_parse_find_stream (ogg, serialno);
GST_LOG_OBJECT (ogg, "Timestamping outgoing buffer as %" GST_TIME_FORMAT,
GST_TIME_ARGS (buffertimestamp));
if (stream) {
buffertimestamp = gst_ogg_stream_get_end_time_for_granulepos (stream,
granule);
if (ogg->video_stream) {
if (stream == ogg->video_stream) {
keyframe = gst_ogg_stream_granulepos_is_key_frame (stream, granule);
} else {
keyframe = FALSE;
}
} else {
keyframe = TRUE;
}
} else {
buffertimestamp = GST_CLOCK_TIME_NONE;
keyframe = TRUE;
}
pagebuffer = gst_ogg_parse_buffer_from_page (&page, startoffset,
buffertimestamp);
/* We read out 'ret' bytes, so we set the next offset appropriately */
ogg->offset += ret;
GST_LOG_OBJECT (ogg,
"processing ogg page (serial %08x, pageno %ld, "
"granule pos %" G_GUINT64_FORMAT ", bos %d, offset %"
G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT ") keyframe=%d",
serialno, ogg_page_pageno (&page),
granule, bos, startoffset, ogg->offset, keyframe);
if (ogg_page_bos (&page)) {
/* If we've seen this serialno before, this is technically an error,
* we log this case but accept it - this one replaces the previous
* stream with this serialno. We can do this since we're streaming, and
* not supporting seeking...
*/
GstOggStream *stream = gst_ogg_parse_find_stream (ogg, serialno);
if (stream != NULL) {
GST_LOG_OBJECT (ogg, "Incorrect stream; repeats serial number %08x "
"at offset %" G_GINT64_FORMAT, serialno, ogg->offset);
}
if (ogg->last_page_not_bos) {
GST_LOG_OBJECT (ogg, "Deleting all referenced streams, found a new "
"chain starting with serial %u", serialno);
gst_ogg_parse_delete_all_streams (ogg);
}
stream = gst_ogg_parse_new_stream (ogg, &page);
ogg->last_page_not_bos = FALSE;
gst_buffer_ref (pagebuffer);
stream->headers = g_list_append (stream->headers, pagebuffer);
if (!ogg->in_headers) {
GST_LOG_OBJECT (ogg,
"Found start of new chain at offset %" G_GUINT64_FORMAT,
startoffset);
ogg->in_headers = 1;
}
/* For now, we just keep the header buffer in the stream->headers list;
* it actually gets output once we've collected the entire set
*/
} else {
/* Non-BOS page. Either: we're outside headers, and this isn't a
* header (normal data), outside headers and this is (error!), inside
* headers, this is (append header), or inside headers and this isn't
* (we've found the end of headers; flush the lot!)
*
* Before that, we flag that the last page seen (this one) was not a
* BOS page; that way we know that when we next see a BOS page it's a
* new chain, and we can flush all existing streams.
*/
page_type type;
GstOggStream *stream = gst_ogg_parse_find_stream (ogg, serialno);
if (!stream) {
GST_LOG_OBJECT (ogg,
"Non-BOS page unexpectedly found at %" G_GINT64_FORMAT,
ogg->offset);
goto failure;
}
ogg->last_page_not_bos = TRUE;
type = gst_ogg_parse_is_header (ogg, stream, &page);
if (type == PAGE_PENDING && ogg->in_headers) {
gst_buffer_ref (pagebuffer);
stream->unknown_pages = g_list_append (stream->unknown_pages,
pagebuffer);
} else if (type == PAGE_HEADER) {
if (!ogg->in_headers) {
GST_LOG_OBJECT (ogg, "Header page unexpectedly found outside "
"headers at offset %" G_GINT64_FORMAT, ogg->offset);
goto failure;
} else {
/* Append the header to the buffer list, after any unknown previous
* pages
*/
stream->headers = g_list_concat (stream->headers,
stream->unknown_pages);
g_list_free (stream->unknown_pages);
gst_buffer_ref (pagebuffer);
stream->headers = g_list_append (stream->headers, pagebuffer);
}
} else { /* PAGE_DATA, or PAGE_PENDING but outside headers */
if (ogg->in_headers) {
/* First non-header page... set caps, flush headers.
*
* First up, we build a single GValue list of all the pagebuffers
* we're using for the headers, in order.
* Then we set this on the caps structure. Then we can start pushing
* buffers for the headers, and finally we send this non-header
* page.
*/
GstCaps *caps;
GstStructure *structure;
GValue array = { 0 };
gint count = 0;
gboolean found_pending_headers = FALSE;
GSList *l;
g_value_init (&array, GST_TYPE_ARRAY);
for (l = ogg->oggstreams; l != NULL; l = l->next) {
GstOggStream *stream = (GstOggStream *) l->data;
if (g_list_length (stream->headers) == 0) {
GST_LOG_OBJECT (ogg, "No primary header found for stream %08x",
stream->serialno);
goto failure;
}
gst_ogg_parse_append_header (&array,
GST_BUFFER (stream->headers->data));
count++;
}
for (l = ogg->oggstreams; l != NULL; l = l->next) {
GstOggStream *stream = (GstOggStream *) l->data;
GList *j;
/* already appended the first header, now do headers 2-N */
for (j = stream->headers->next; j != NULL; j = j->next) {
gst_ogg_parse_append_header (&array, GST_BUFFER (j->data));
count++;
}
}
caps = gst_pad_query_caps (ogg->srcpad, NULL);
caps = gst_caps_make_writable (caps);
structure = gst_caps_get_structure (caps, 0);
gst_structure_take_value (structure, "streamheader", &array);
gst_pad_set_caps (ogg->srcpad, caps);
if (ogg->caps)
gst_caps_unref (ogg->caps);
ogg->caps = caps;
GST_LOG_OBJECT (ogg, "Set \"streamheader\" caps with %d buffers "
"(one per page)", count);
/* Now, we do the same thing, but push buffers... */
for (l = ogg->oggstreams; l != NULL; l = l->next) {
GstOggStream *stream = (GstOggStream *) l->data;
GstBuffer *buf = GST_BUFFER (stream->headers->data);
result = gst_pad_push (ogg->srcpad, buf);
if (result != GST_FLOW_OK)
return result;
}
for (l = ogg->oggstreams; l != NULL; l = l->next) {
GstOggStream *stream = (GstOggStream *) l->data;
GList *j;
/* pushed the first one for each stream already, now do 2-N */
for (j = stream->headers->next; j != NULL; j = j->next) {
GstBuffer *buf = GST_BUFFER (j->data);
result = gst_pad_push (ogg->srcpad, buf);
if (result != GST_FLOW_OK)
return result;
}
}
ogg->in_headers = 0;
/* And finally the pending data pages */
for (l = ogg->oggstreams; l != NULL; l = l->next) {
GstOggStream *stream = (GstOggStream *) l->data;
GList *k;
if (stream->unknown_pages == NULL)
continue;
if (found_pending_headers) {
GST_WARNING_OBJECT (ogg, "Incorrectly muxed headers found at "
"approximate offset %" G_GINT64_FORMAT, ogg->offset);
}
found_pending_headers = TRUE;
GST_LOG_OBJECT (ogg, "Pushing %d pending pages after headers",
g_list_length (stream->unknown_pages) + 1);
for (k = stream->unknown_pages; k != NULL; k = k->next) {
GstBuffer *buf = GST_BUFFER (k->data);
result = gst_pad_push (ogg->srcpad, buf);
if (result != GST_FLOW_OK)
return result;
}
g_list_foreach (stream->unknown_pages,
(GFunc) gst_mini_object_unref, NULL);
g_list_free (stream->unknown_pages);
stream->unknown_pages = NULL;
}
}
if (granule == -1) {
stream->stored_buffers = g_list_append (stream->stored_buffers,
pagebuffer);
} else {
while (stream->stored_buffers) {
GstBuffer *buf = stream->stored_buffers->data;
buf = gst_buffer_make_writable (buf);
GST_BUFFER_TIMESTAMP (buf) = buffertimestamp;
if (!keyframe) {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
} else {
keyframe = FALSE;
}
result = gst_pad_push (ogg->srcpad, buf);
if (result != GST_FLOW_OK)
return result;
stream->stored_buffers =
g_list_delete_link (stream->stored_buffers,
stream->stored_buffers);
}
pagebuffer = gst_buffer_make_writable (pagebuffer);
if (!keyframe) {
GST_BUFFER_FLAG_SET (pagebuffer, GST_BUFFER_FLAG_DELTA_UNIT);
} else {
keyframe = FALSE;
}
result = gst_pad_push (ogg->srcpad, pagebuffer);
if (result != GST_FLOW_OK)
return result;
}
}
}
}
}
return result;
failure:
gst_pad_push_event (GST_PAD (ogg->srcpad), gst_event_new_eos ());
return GST_FLOW_ERROR;
}
/* Core streaming function for this module
* This is what actually produces the data which gets streamed.
*
* returns: >0 Number of bytes read
* 0 Non-fatal error.
* <0 Fatal error.
*/
static int playlist_read(void *self, ref_buffer *rb)
{
playlist_state_t *pl = (playlist_state_t *)self;
int bytes;
unsigned char *buf;
char *newfn;
int result;
ogg_page og;
if (pl->errors > 5)
{
LOG_WARN0("Too many consecutive errors - exiting");
return -1;
}
if (!pl->current_file || pl->nexttrack)
{
pl->nexttrack = 0;
if (pl->current_file && strcmp (pl->filename, "-"))
{
fclose(pl->current_file);
pl->current_file = NULL;
}
if (pl->file_ended)
{
pl->file_ended(pl->data, pl->filename);
}
newfn = pl->get_filename(pl->data);
if (!newfn)
{
LOG_INFO0("No more filenames available, end of playlist");
return -1; /* No more files available */
}
if (strcmp (newfn, "-"))
{
if (!pl->allow_repeat && pl->filename && !strcmp(pl->filename, newfn))
{
LOG_ERROR0("Cannot play same file twice in a row, skipping");
pl->errors++;
pl->free_filename (pl->data, newfn);
return 0;
}
pl->free_filename(pl->data, pl->filename);
pl->filename = newfn;
pl->current_file = fopen(pl->filename, "rb");
if (!pl->current_file)
{
LOG_WARN2("Error opening file \"%s\": %s",pl->filename, strerror(errno));
pl->errors++;
return 0;
}
LOG_INFO1("Currently playing \"%s\"", pl->filename);
}
else
{
LOG_INFO0("Currently playing from stdin");
pl->current_file = stdin;
pl->free_filename(pl->data, pl->filename);
pl->filename = newfn;
}
/* Reinit sync, so that dead data from previous file is discarded */
ogg_sync_clear(&pl->oy);
ogg_sync_init(&pl->oy);
}
input_sleep ();
while(1)
{
result = ogg_sync_pageout(&pl->oy, &og);
if(result < 0)
LOG_WARN1("Corrupt or missing data in file (%s)", pl->filename);
else if(result > 0)
{
if (ogg_page_bos (&og))
{
if (ogg_page_serialno (&og) == pl->current_serial)
LOG_WARN1 ("detected duplicate serial number reading \"%s\"", pl->filename);
pl->current_serial = ogg_page_serialno (&og);
}
if (input_calculate_ogg_sleep (&og) < 0)
{
pl->nexttrack = 1;
return 0;
}
rb->len = og.header_len + og.body_len;
rb->buf = malloc(rb->len);
rb->aux_data = og.header_len;
memcpy(rb->buf, og.header, og.header_len);
memcpy(rb->buf+og.header_len, og.body, og.body_len);
if(ogg_page_granulepos(&og)==0)
rb->critical = 1;
break;
}
/* If we got to here, we didn't have enough data. */
buf = ogg_sync_buffer(&pl->oy, BUFSIZE);
bytes = fread(buf,1, BUFSIZE, pl->current_file);
if (bytes <= 0)
{
if (feof(pl->current_file))
{
pl->nexttrack = 1;
return playlist_read(pl,rb);
}
else
{
LOG_ERROR2("Read error from \"%s\": %s", pl->filename, strerror(errno));
fclose(pl->current_file);
pl->current_file=NULL;
pl->errors++;
return 0;
}
}
else
ogg_sync_wrote(&pl->oy, bytes);
}
pl->errors=0;
return rb->len;
}
int input_calculate_ogg_sleep(ogg_page *page)
{
static ogg_stream_state os;
ogg_packet op;
static vorbis_info vi;
static vorbis_comment vc;
static int need_start_pos, need_headers, state_in_use = 0;
static int serialno = 0;
static uint64_t offset;
static uint64_t first_granulepos;
if (ogg_page_granulepos(page) == -1)
{
LOG_ERROR0("Timing control: corrupt timing information in vorbis file, cannot stream.");
return -1;
}
if (ogg_page_bos (page))
{
control.oldsamples = 0;
if (state_in_use)
ogg_stream_clear (&os);
ogg_stream_init (&os, ogg_page_serialno (page));
serialno = ogg_page_serialno (page);
state_in_use = 1;
vorbis_info_init (&vi);
vorbis_comment_init (&vc);
need_start_pos = 1;
need_headers = 3;
offset = (uint64_t)0;
}
if (need_start_pos)
{
int found_first_granulepos = 0;
ogg_stream_pagein (&os, page);
while (ogg_stream_packetout (&os, &op) == 1)
{
if (need_headers)
{
if (vorbis_synthesis_headerin (&vi, &vc, &op) < 0)
{
LOG_ERROR0("Timing control: can't determine sample rate for input, not vorbis.");
control.samplerate = 0;
return -1;
}
need_headers--;
control.samplerate = vi.rate;
if (need_headers == 0)
{
vorbis_comment_clear (&vc);
first_granulepos = (uint64_t)0;
return 0;
}
continue;
}
/* headers have been read */
if (first_granulepos == 0 && op.granulepos > 0)
{
first_granulepos = op.granulepos;
found_first_granulepos = 1;
}
offset += vorbis_packet_blocksize (&vi, &op) / 4;
}
if (!found_first_granulepos)
return 0;
need_start_pos = 0;
control.oldsamples = first_granulepos - offset;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
state_in_use = 0;
}
if (serialno != ogg_page_serialno (page))
{
LOG_ERROR0 ("Found page which does not belong to current logical stream");
return -1;
}
control.samples = ogg_page_granulepos (page) - control.oldsamples;
control.oldsamples = ogg_page_granulepos (page);
control.senttime += ((uint64_t)control.samples * 1000000 /
(uint64_t)control.samplerate);
return 0;
}
int main () {
ogg_sync_state oy; /* sync and verify incoming physical bitstream */
ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
ogg_page og; /* one Ogg bitstream page. Vorbis packets are inside */
ogg_packet op; /* one raw packet of data for decode */
struct stream *st = NULL;
int r;
char *buffer;
int bytes;
int eos = 0;
int i;
int bufferSize = 4096;
r = ogg_sync_init(&oy); /* Now we can read pages */
assert(r == 0);
while (1) { /* we repeat if the bitstream is chained */
/* submit a 4k block to the libogg sync layer */
buffer = ogg_sync_buffer(&oy, bufferSize);
bytes = fread(buffer, 1, bufferSize, stdin);
if (bytes == 0) {
fprintf(stderr, "Got stdin EOF.\n");
r = 0; break;
}
r = ogg_sync_wrote(&oy, bytes);
assert(r == 0);
/* Get the first page. */
r = ogg_sync_pageout(&oy, &og);
if (r == 0) {
fprintf(stderr, "Need more data.\n");
continue;
} else if (r < 1) {
/* have we simply run out of data? If so, we're done. */
if (bytes < bufferSize) break;
/* error case. Must not be Vorbis data */
fprintf(stderr, "Input does not appear to be an Ogg bitstream.\n");
r = 1; break;
}
assert(r == 1);
/* Get the serial number and set up the rest of decode. */
/* serialno first; use it to set up a logical stream */
int serialno = ogg_page_serialno(&og);
int packets = ogg_page_packets(&og);
fprintf(stderr, "version: %d\n", ogg_page_version(&og));
fprintf(stderr, "continued: %d\n", ogg_page_continued(&og));
fprintf(stderr, "pageno: %ld\n", ogg_page_pageno(&og));
fprintf(stderr, "serialno: %d\n", serialno);
fprintf(stderr, "packets: %d\n", packets);
fprintf(stderr, "granulepos: %lld\n", ogg_page_granulepos(&og));
fprintf(stderr, "eos: %d\n", ogg_page_eos(&og));
fprintf(stderr, "bos: %d\n", ogg_page_bos(&og));
/* we need to get the correct "ogg_stream_state" struct based on the serialno */
struct stream *s = st;
while (1) {
if (s == NULL) {
fprintf(stderr, "creating struct stream for %d\n", serialno);
s = malloc(sizeof(struct stream));
s->next = NULL;
s->serialno = serialno;
ogg_stream_init(&s->os, serialno);
if (st == NULL) {
st = s;
} else {
/* have to set "s" to the last element of the "st" linked list */
struct stream *t = st;
while (1) {
if (t->next == NULL) {
t->next = s;
break;
} else {
t = t->next;
}
}
}
break;
}
if (s->serialno == serialno) {
break;
}
s = s->next;
}
assert(s->serialno == serialno);
fprintf(stderr, "using struct stream %d\n", s->serialno);
/* holy shit that sucked... */
if (ogg_stream_pagein(&s->os, &og) < 0) {
/* error; stream version mismatch perhaps */
fprintf(stderr, "Error reading page of Ogg bitstream data.\n");
r = 1; break;
}
/* iterate though the "packets" in the page */
for (i=0; i<packets; i++) {
fprintf(stderr, " Reading packet %d.\n", i);
r = ogg_stream_packetout(&s->os, &op);
fprintf(stderr, " Reading packet result %d.\n", r);
if (r != 1) {
/* no page? must not be vorbis */
fprintf(stderr, " Error reading packet.\n");
r = 1; break;
}
/**
* At this point, you'd pass the raw packet data to the vorbis decoder or
* whatever your destination is....
*/
fprintf(stderr, " bytes: %ld\n", op.bytes);
fprintf(stderr, " b_o_s: %ld\n", op.b_o_s);
fprintf(stderr, " e_o_s: %ld\n", op.e_o_s);
fprintf(stderr, " granulepos: %lld\n", op.granulepos);
fprintf(stderr, " packetno: %lld\n", op.packetno);
}
fprintf(stderr, "\n");
}
/* OK, clean up the framer */
ogg_sync_clear(&oy);
fprintf(stderr,"\nDone.\n");
return r;
}
void VideoStreamPlaybackTheora::set_file(const String &p_file) {
ERR_FAIL_COND(playing);
ogg_packet op;
th_setup_info *ts = NULL;
file_name = p_file;
if (file) {
memdelete(file);
}
file = FileAccess::open(p_file, FileAccess::READ);
ERR_FAIL_COND(!file);
#ifdef THEORA_USE_THREAD_STREAMING
thread_exit = false;
thread_eof = false;
//pre-fill buffer
int to_read = ring_buffer.space_left();
int read = file->get_buffer(read_buffer.ptr(), to_read);
ring_buffer.write(read_buffer.ptr(), read);
thread = Thread::create(_streaming_thread, this);
#endif
ogg_sync_init(&oy);
/* init supporting Vorbis structures needed in header parsing */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
/* init supporting Theora structures needed in header parsing */
th_comment_init(&tc);
th_info_init(&ti);
theora_eos = false;
vorbis_eos = false;
/* Ogg file open; parse the headers */
/* Only interested in Vorbis/Theora streams */
int stateflag = 0;
int audio_track_skip = audio_track;
while (!stateflag) {
int ret = buffer_data();
if (ret == 0) break;
while (ogg_sync_pageout(&oy, &og) > 0) {
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if (!ogg_page_bos(&og)) {
/* don't leak the page; get it into the appropriate stream */
queue_page(&og);
stateflag = 1;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&og));
ogg_stream_pagein(&test, &og);
ogg_stream_packetout(&test, &op);
/* identify the codec: try theora */
if (!theora_p && th_decode_headerin(&ti, &tc, &ts, &op) >= 0) {
/* it is theora */
copymem(&to, &test, sizeof(test));
theora_p = 1;
} else if (!vorbis_p && vorbis_synthesis_headerin(&vi, &vc, &op) >= 0) {
/* it is vorbis */
if (audio_track_skip) {
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
ogg_stream_clear(&test);
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
audio_track_skip--;
} else {
copymem(&vo, &test, sizeof(test));
vorbis_p = 1;
}
} else {
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
/* we're expecting more header packets. */
while ((theora_p && theora_p < 3) || (vorbis_p && vorbis_p < 3)) {
int ret;
/* look for further theora headers */
while (theora_p && (theora_p < 3) && (ret = ogg_stream_packetout(&to, &op))) {
if (ret < 0) {
fprintf(stderr, "Error parsing Theora stream headers; "
"corrupt stream?\n");
clear();
return;
}
if (!th_decode_headerin(&ti, &tc, &ts, &op)) {
fprintf(stderr, "Error parsing Theora stream headers; "
"corrupt stream?\n");
clear();
return;
}
theora_p++;
}
/* look for more vorbis header packets */
while (vorbis_p && (vorbis_p < 3) && (ret = ogg_stream_packetout(&vo, &op))) {
if (ret < 0) {
fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?\n");
clear();
return;
}
ret = vorbis_synthesis_headerin(&vi, &vc, &op);
if (ret) {
fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?\n");
clear();
return;
}
vorbis_p++;
if (vorbis_p == 3) break;
}
/* The header pages/packets will arrive before anything else we
care about, or the stream is not obeying spec */
if (ogg_sync_pageout(&oy, &og) > 0) {
queue_page(&og); /* demux into the appropriate stream */
} else {
int ret = buffer_data(); /* someone needs more data */
if (ret == 0) {
fprintf(stderr, "End of file while searching for codec headers.\n");
clear();
return;
}
}
}
/* and now we have it all. initialize decoders */
if (theora_p) {
td = th_decode_alloc(&ti, ts);
printf("Ogg logical stream %lx is Theora %dx%d %.02f fps",
to.serialno, ti.pic_width, ti.pic_height,
(double)ti.fps_numerator / ti.fps_denominator);
px_fmt = ti.pixel_fmt;
switch (ti.pixel_fmt) {
case TH_PF_420: printf(" 4:2:0 video\n"); break;
case TH_PF_422: printf(" 4:2:2 video\n"); break;
case TH_PF_444: printf(" 4:4:4 video\n"); break;
case TH_PF_RSVD:
default:
printf(" video\n (UNKNOWN Chroma sampling!)\n");
break;
}
if (ti.pic_width != ti.frame_width || ti.pic_height != ti.frame_height)
printf(" Frame content is %dx%d with offset (%d,%d).\n",
ti.frame_width, ti.frame_height, ti.pic_x, ti.pic_y);
th_decode_ctl(td, TH_DECCTL_GET_PPLEVEL_MAX, &pp_level_max,
sizeof(pp_level_max));
pp_level = 0;
th_decode_ctl(td, TH_DECCTL_SET_PPLEVEL, &pp_level, sizeof(pp_level));
pp_inc = 0;
int w;
int h;
w = (ti.pic_x + ti.frame_width + 1 & ~1) - (ti.pic_x & ~1);
h = (ti.pic_y + ti.frame_height + 1 & ~1) - (ti.pic_y & ~1);
size.x = w;
size.y = h;
texture->create(w, h, Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
} else {
/* tear down the partial theora setup */
th_info_clear(&ti);
th_comment_clear(&tc);
}
th_setup_free(ts);
if (vorbis_p) {
vorbis_synthesis_init(&vd, &vi);
vorbis_block_init(&vd, &vb);
fprintf(stderr, "Ogg logical stream %lx is Vorbis %d channel %ld Hz audio.\n",
vo.serialno, vi.channels, vi.rate);
//_setup(vi.channels, vi.rate);
} else {
/* tear down the partial vorbis setup */
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
playing = false;
buffering = true;
time = 0;
audio_frames_wrote = 0;
};
bool TheoraDecoder::loadStream(Common::SeekableReadStream *stream) {
close();
_fileStream = stream;
// start up Ogg stream synchronization layer
ogg_sync_init(&_oggSync);
// init supporting Vorbis structures needed in header parsing
vorbis_info_init(&_vorbisInfo);
vorbis_comment vorbisComment;
vorbis_comment_init(&vorbisComment);
// init supporting Theora structures needed in header parsing
th_info theoraInfo;
th_info_init(&theoraInfo);
th_comment theoraComment;
th_comment_init(&theoraComment);
th_setup_info *theoraSetup = 0;
uint theoraPackets = 0, vorbisPackets = 0;
// Ogg file open; parse the headers
// Only interested in Vorbis/Theora streams
bool foundHeader = false;
while (!foundHeader) {
int ret = bufferData();
if (ret == 0)
break; // FIXME: Shouldn't this error out?
while (ogg_sync_pageout(&_oggSync, &_oggPage) > 0) {
ogg_stream_state test;
// is this a mandated initial header? If not, stop parsing
if (!ogg_page_bos(&_oggPage)) {
// don't leak the page; get it into the appropriate stream
queuePage(&_oggPage);
foundHeader = true;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&_oggPage));
ogg_stream_pagein(&test, &_oggPage);
ogg_stream_packetout(&test, &_oggPacket);
// identify the codec: try theora
if (theoraPackets == 0 && th_decode_headerin(&theoraInfo, &theoraComment, &theoraSetup, &_oggPacket) >= 0) {
// it is theora
memcpy(&_theoraOut, &test, sizeof(test));
theoraPackets = 1;
_hasVideo = true;
} else if (vorbisPackets == 0 && vorbis_synthesis_headerin(&_vorbisInfo, &vorbisComment, &_oggPacket) >= 0) {
// it is vorbis
memcpy(&_vorbisOut, &test, sizeof(test));
vorbisPackets = 1;
_hasAudio = true;
} else {
// whatever it is, we don't care about it
ogg_stream_clear(&test);
}
}
// fall through to non-bos page parsing
}
// we're expecting more header packets.
while ((theoraPackets && theoraPackets < 3) || (vorbisPackets && vorbisPackets < 3)) {
int ret;
// look for further theora headers
while (theoraPackets && (theoraPackets < 3) && (ret = ogg_stream_packetout(&_theoraOut, &_oggPacket))) {
if (ret < 0)
error("Error parsing Theora stream headers; corrupt stream?");
if (!th_decode_headerin(&theoraInfo, &theoraComment, &theoraSetup, &_oggPacket))
error("Error parsing Theora stream headers; corrupt stream?");
theoraPackets++;
}
// look for more vorbis header packets
while (vorbisPackets && (vorbisPackets < 3) && (ret = ogg_stream_packetout(&_vorbisOut, &_oggPacket))) {
if (ret < 0)
error("Error parsing Vorbis stream headers; corrupt stream?");
if (vorbis_synthesis_headerin(&_vorbisInfo, &vorbisComment, &_oggPacket))
error("Error parsing Vorbis stream headers; corrupt stream?");
vorbisPackets++;
if (vorbisPackets == 3)
break;
}
// The header pages/packets will arrive before anything else we
// care about, or the stream is not obeying spec
if (ogg_sync_pageout(&_oggSync, &_oggPage) > 0) {
queuePage(&_oggPage); // demux into the appropriate stream
} else {
ret = bufferData(); // someone needs more data
if (ret == 0)
error("End of file while searching for codec headers.");
}
}
// And now we have it all. Initialize decoders next
if (_hasVideo) {
_videoTrack = new TheoraVideoTrack(getDefaultHighColorFormat(), theoraInfo, theoraSetup);
addTrack(_videoTrack);
}
th_info_clear(&theoraInfo);
th_comment_clear(&theoraComment);
th_setup_free(theoraSetup);
if (_hasAudio) {
_audioTrack = new VorbisAudioTrack(_soundType, _vorbisInfo);
// Get enough audio data to start us off
while (!_audioTrack->hasAudio()) {
// Queue more data
bufferData();
while (ogg_sync_pageout(&_oggSync, &_oggPage) > 0)
queuePage(&_oggPage);
queueAudio();
}
addTrack(_audioTrack);
}
vorbis_comment_clear(&vorbisComment);
return true;
}
void TheoraPlayer::OpenFile(const String &path)
{
ReleaseData();
if(path == "")
return;
filePath = path;
file = File::Create(path, File::OPEN | File::READ);
ogg_sync_init(&theoraData->syncState);
th_info_init(&theoraData->thInfo);
th_comment_init(&theoraData->thComment);
int32 stateflag = 0;
while(!stateflag)
{
if(!BufferData())
break;
while(ogg_sync_pageout(&theoraData->syncState, &theoraData->page) > 0)
{
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&theoraData->page))
{
/* don't leak the page; get it into the appropriate stream */
ogg_stream_pagein(&theoraData->state, &theoraData->page);
stateflag = 1;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&theoraData->page));
ogg_stream_pagein(&test, &theoraData->page);
ogg_stream_packetout(&test, &theoraData->packet);
/* identify the codec: try theora */
if(!theora_p && th_decode_headerin(&theoraData->thInfo, &theoraData->thComment, &theoraData->thSetup, &theoraData->packet) >= 0)
{
/* it is theora */
memcpy(&theoraData->state, &test, sizeof(test));
theora_p = 1;
}
else
{
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
while(theora_p && theora_p < 3)
{
int ret;
/* look for further theora headers */
while(theora_p && (theora_p < 3) && (ret = ogg_stream_packetout(&theoraData->state, &theoraData->packet)))
{
if(ret < 0)
{
Logger::Error("TheoraPlayer: Error parsing Theora stream headers; corrupt stream?\n");
return;
}
if(!th_decode_headerin(&theoraData->thInfo, &theoraData->thComment, &theoraData->thSetup, &theoraData->packet))
{
Logger::Error("TheoraPlayer: Error parsing Theora stream headers; corrupt stream?\n");
return;
}
theora_p++;
}
/* The header pages/packets will arrive before anything else we
care about, or the stream is not obeying spec */
if(ogg_sync_pageout(&theoraData->syncState, &theoraData->page) > 0)
{
ogg_stream_pagein(&theoraData->state, &theoraData->page); /* demux into the appropriate stream */
}
else
{
int ret = BufferData(); /* someone needs more data */
if(ret == 0)
{
Logger::Error("TheoraPlayer: End of file while searching for codec headers.\n");
return;
}
}
}
if(theora_p)
{
theoraData->thCtx = th_decode_alloc(&theoraData->thInfo, theoraData->thSetup);
th_decode_ctl(theoraData->thCtx, TH_DECCTL_GET_PPLEVEL_MAX, &pp_level_max, sizeof(pp_level_max));
pp_level=pp_level_max;
th_decode_ctl(theoraData->thCtx, TH_DECCTL_SET_PPLEVEL, &pp_level, sizeof(pp_level));
pp_inc=0;
}
else
{
/* tear down the partial theora setup */
th_info_clear(&theoraData->thInfo);
th_comment_clear(&theoraData->thComment);
}
if(theoraData->thSetup)
th_setup_free(theoraData->thSetup);
theoraData->thSetup = 0;
frameBufferW = binCeil(theoraData->thInfo.pic_width);
frameBufferH = binCeil(theoraData->thInfo.pic_height);
frameBuffer = new unsigned char[frameBufferW * frameBufferH * 4];
repeatFilePos = file->GetPos();
frameTime = (float32)(theoraData->thInfo.fps_denominator)/(float32)(theoraData->thInfo.fps_numerator);
isPlaying = true;
}
int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
unsigned char *header=og->header;
unsigned char *body=og->body;
long bodysize=og->body_len;
int segptr=0;
int version=ogg_page_version(og);
int continued=ogg_page_continued(og);
int bos=ogg_page_bos(og);
int eos=ogg_page_eos(og);
ogg_int64_t granulepos=ogg_page_granulepos(og);
int serialno=ogg_page_serialno(og);
long pageno=ogg_page_pageno(og);
int segments=header[26];
/* clean up 'returned data' */
{
long lr=os->lacing_returned;
long br=os->body_returned;
/* body data */
if(br){
os->body_fill-=br;
if(os->body_fill)
memmove(os->body_data,os->body_data+br,os->body_fill);
os->body_returned=0;
}
if(lr){
/* segment table */
if(os->lacing_fill-lr){
memmove(os->lacing_vals,os->lacing_vals+lr,
(os->lacing_fill-lr)*sizeof(*os->lacing_vals));
memmove(os->granule_vals,os->granule_vals+lr,
(os->lacing_fill-lr)*sizeof(*os->granule_vals));
}
os->lacing_fill-=lr;
os->lacing_packet-=lr;
os->lacing_returned=0;
}
}
/* check the serial number */
if(serialno!=os->serialno)return(-1);
if(version>0)return(-1);
_os_lacing_expand(os,segments+1);
/* are we in sequence? */
if(pageno!=os->pageno){
int i;
/* unroll previous partial packet (if any) */
for(i=os->lacing_packet;i<os->lacing_fill;i++)
os->body_fill-=os->lacing_vals[i]&0xff;
os->lacing_fill=os->lacing_packet;
/* make a note of dropped data in segment table */
if(os->pageno!=-1){
os->lacing_vals[os->lacing_fill++]=0x400;
os->lacing_packet++;
}
/* are we a 'continued packet' page? If so, we'll need to skip
some segments */
if(continued){
bos=0;
for(;segptr<segments;segptr++){
int val=header[27+segptr];
body+=val;
bodysize-=val;
if(val<255){
segptr++;
break;
}
}
}
}
if(bodysize){
_os_body_expand(os,bodysize);
memcpy(os->body_data+os->body_fill,body,bodysize);
os->body_fill+=bodysize;
}
{
int saved=-1;
while(segptr<segments){
int val=header[27+segptr];
os->lacing_vals[os->lacing_fill]=val;
os->granule_vals[os->lacing_fill]=-1;
if(bos){
os->lacing_vals[os->lacing_fill]|=0x100;
bos=0;
}
if(val<255)saved=os->lacing_fill;
os->lacing_fill++;
segptr++;
if(val<255)os->lacing_packet=os->lacing_fill;
}
/* set the granulepos on the last granuleval of the last full packet */
if(saved!=-1){
os->granule_vals[saved]=granulepos;
}
}
if(eos){
os->e_o_s=1;
if(os->lacing_fill>0)
os->lacing_vals[os->lacing_fill-1]|=0x200;
}
os->pageno=pageno+1;
return(0);
}
/* Opens the Ogg stream, searching for and initializing Theora and Vorbis media
*/
int alogg_open(APEG_LAYER *layer)
{
ALOGG_INFO *info;
int vok = 0, aok = 0;
int flag, cs, size;
info = calloc(1, sizeof(ALOGG_INFO));
if(!info)
return APEG_ERROR;
LOCK_DATA(info, sizeof(ALOGG_INFO));
ogg_sync_init(&info->osync);
theora_comment_init(&info->tcomment);
theora_info_init(&info->tinfo);
vorbis_info_init(&info->vinfo);
vorbis_comment_init(&info->vcomment);
flag = FALSE;
while(!flag)
{
int ret = buffer_data(layer, info);
if(ret == 0)
break;
while(ogg_sync_pageout(&info->osync, &info->opage) > 0)
{
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&info->opage))
{
if(vok > 0)
ogg_stream_pagein(&info->ostream[0], &info->opage);
if(aok > 0)
ogg_stream_pagein(&info->ostream[1], &info->opage);
flag = TRUE;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&info->opage));
ogg_stream_pagein(&test, &info->opage);
ogg_stream_packetout(&test, &info->opkt);
/* identify the codec: try theora */
if(!vok && theora_decode_header(&info->tinfo, &info->tcomment,
&info->opkt) >= 0)
{
/* it is theora */
if(!_apeg_ignore_video)
{
memcpy(&info->ostream[0], &test, sizeof(test));
vok = 1;
}
else
ogg_stream_clear(&test);
}
else if(!aok && vorbis_synthesis_headerin(&info->vinfo,
&info->vcomment, &info->opkt) >= 0)
{
/* it is vorbis */
if(!_apeg_ignore_audio)
{
memcpy(&info->ostream[1], &test, sizeof(test));
aok = 1;
}
else
ogg_stream_clear(&test);
}
/* whatever it is, we don't care about it */
else
ogg_stream_clear(&test);
}
/* fall through to non-bos page parsing */
}
/* look for further theora headers */
while((vok > 0 && vok < 3) || (aok > 0 && aok < 3))
{
int ret;
// Get the last two of three Theora headers
while(vok > 0 && vok < 3 &&
(ret = ogg_stream_packetout(&info->ostream[0], &info->opkt)))
{
if(ret < 0)
goto error;
if(theora_decode_header(&info->tinfo, &info->tcomment, &info->opkt))
goto error;
++vok;
}
// Get the last two of three Vorbis headers
while(aok > 0 && aok < 3 &&
(ret = ogg_stream_packetout(&info->ostream[1], &info->opkt)))
{
if(ret < 0)
goto error;
if(vorbis_synthesis_headerin(&info->vinfo, &info->vcomment,
&info->opkt))
goto error;
++aok;
}
if(ogg_sync_pageout(&info->osync, &info->opage) <= 0)
{
/* need more data */
if(buffer_data(layer, info) == 0)
break;
}
else
{
if(vok > 0)
ogg_stream_pagein(&info->ostream[0], &info->opage);
if(aok > 0)
ogg_stream_pagein(&info->ostream[1], &info->opage);
}
}
// Neither Vorbis or Theora fully initialized. Error.
if(vok != 3 && aok != 3)
goto error;
layer->ogg_info = info;
if(aok == 3)
{
vorbis_synthesis_init(&info->vdsp, &info->vinfo);
vorbis_block_init(&info->vdsp, &info->vblock);
if(info->vinfo.channels == 1)
layer->stream.audio.down_channel = FALSE;
layer->stream.audio.channels = info->vinfo.channels;
layer->stream.audio.freq = info->vinfo.rate >>
layer->stream.audio.down_sample;
if(_apeg_audio_reset_parameters(layer) != APEG_OK)
{
vorbis_block_clear(&info->vblock);
vorbis_dsp_clear(&info->vdsp);
goto error;
}
// layer->audio.inited = TRUE;
layer->stream.flags |= APEG_VORBIS_AUDIO;
}
void VideoClip_Theora::_readTheoraVorbisHeaders()
{
ogg_packet tempOggPacket;
//init Vorbis/Theora Layer
//Ensure all structures get cleared out.
memset(&this->info.OggSyncState, 0, sizeof(ogg_sync_state));
memset(&this->info.OggPage, 0, sizeof(ogg_page));
memset(&this->info.VorbisStreamState, 0, sizeof(ogg_stream_state));
memset(&this->info.TheoraStreamState, 0, sizeof(ogg_stream_state));
memset(&this->info.TheoraInfo, 0, sizeof(th_info));
memset(&this->info.TheoraComment, 0, sizeof(th_comment));
memset(&this->info.VorbisInfo, 0, sizeof(vorbis_info));
memset(&this->info.VorbisDSPState, 0, sizeof(vorbis_dsp_state));
memset(&this->info.VorbisBlock, 0, sizeof(vorbis_block));
memset(&this->info.VorbisComment, 0, sizeof(vorbis_comment));
// init all structures
ogg_sync_init(&this->info.OggSyncState);
th_comment_init(&this->info.TheoraComment);
th_info_init(&this->info.TheoraInfo);
vorbis_info_init(&this->info.VorbisInfo);
vorbis_comment_init(&this->info.VorbisComment);
// start
ogg_stream_state oggStateTest;
bool decodeAudio = (theoraplayer::manager->getAudioInterfaceFactory() != NULL);
char* buffer = NULL;
int bytesRead = 0;
bool done = false;
while (!done)
{
buffer = ogg_sync_buffer(&this->info.OggSyncState, BUFFER_SIZE);
bytesRead = this->stream->read(buffer, BUFFER_SIZE);
ogg_sync_wrote(&this->info.OggSyncState, bytesRead);
if (bytesRead == 0)
{
break;
}
while (ogg_sync_pageout(&this->info.OggSyncState, &this->info.OggPage) > 0)
{
memset(&oggStateTest, 0, sizeof(oggStateTest));
//is this an initial header? If not, stop
if (ogg_page_bos(&this->info.OggPage) == 0)
{
//This is done blindly, because stream only accept themselves
if (this->theoraStreams > 0)
{
ogg_stream_pagein(&this->info.TheoraStreamState, &this->info.OggPage);
}
if (this->vorbisStreams > 0)
{
ogg_stream_pagein(&this->info.VorbisStreamState, &this->info.OggPage);
}
done = true;
break;
}
ogg_stream_init(&oggStateTest, ogg_page_serialno(&this->info.OggPage));
ogg_stream_pagein(&oggStateTest, &this->info.OggPage);
ogg_stream_packetout(&oggStateTest, &tempOggPacket);
// identify the codec
if (this->theoraStreams == 0 && th_decode_headerin(&this->info.TheoraInfo, &this->info.TheoraComment, &this->info.TheoraSetup, &tempOggPacket) > 0)
{
// This is the Theora Header
memcpy(&this->info.TheoraStreamState, &oggStateTest, sizeof(oggStateTest));
this->theoraStreams = 1;
}
else if (decodeAudio && this->vorbisStreams == 0 && vorbis_synthesis_headerin(&this->info.VorbisInfo, &this->info.VorbisComment, &tempOggPacket) >= 0)
{
// This is vorbis header
memcpy(&this->info.VorbisStreamState, &oggStateTest, sizeof(oggStateTest));
this->vorbisStreams = 1;
}
else // Hm, guess it's not a header we support, so erase it
{
ogg_stream_clear(&oggStateTest);
}
}
}
int result = 0;
while ((this->theoraStreams > 0 && this->theoraStreams < 3) || (this->vorbisStreams && this->vorbisStreams < 3))
{
// Check 2nd'dary headers... Theora First
while (this->theoraStreams > 0 && this->theoraStreams < 3 && (result = ogg_stream_packetout(&this->info.TheoraStreamState, &tempOggPacket)))
{
if (result < 0)
{
throw TheoraplayerException("Error parsing Theora stream headers!");
}
if (th_decode_headerin(&this->info.TheoraInfo, &this->info.TheoraComment, &this->info.TheoraSetup, &tempOggPacket) == 0)
{
throw TheoraplayerException("Invalid theora stream!");
}
++this->theoraStreams;
} // end while looking for more theora headers
// look 2nd vorbis header packets
while (this->vorbisStreams < 3 && (result = ogg_stream_packetout(&this->info.VorbisStreamState, &tempOggPacket)))
{
if (result < 0)
{
throw TheoraplayerException("Error parsing vorbis stream headers!");
}
if (vorbis_synthesis_headerin(&this->info.VorbisInfo, &this->info.VorbisComment, &tempOggPacket) != 0)
{
throw TheoraplayerException("Invalid stream!");
}
++this->vorbisStreams;
} // end while looking for more vorbis headers
// Not finished with Headers, get some more file data
if (ogg_sync_pageout(&this->info.OggSyncState, &this->info.OggPage) > 0)
{
if (this->theoraStreams > 0)
{
ogg_stream_pagein(&this->info.TheoraStreamState, &this->info.OggPage);
}
if (this->vorbisStreams > 0)
{
ogg_stream_pagein(&this->info.VorbisStreamState, &this->info.OggPage);
}
}
else
{
buffer = ogg_sync_buffer(&this->info.OggSyncState, BUFFER_SIZE);
bytesRead = this->stream->read(buffer, BUFFER_SIZE);
ogg_sync_wrote(&this->info.OggSyncState, bytesRead);
if (bytesRead == 0)
{
throw TheoraplayerException("End of file found prematurely!");
}
}
} // end while looking for all headers
//log("Vorbis Headers: " + str(mVorbisHeaders) + " Theora Headers : " + str(mTheoraHeaders));
}
bool parseHeaders(CStretchyBuffer& buffer)
// Parse the headers
// Only interested in Vorbis/Theora streams
{
// extracted from player_sample.c test file for theora alpha
ogg_packet op;
bool stateflag=false;
while (!stateflag)
{
int ret=buffer_data(&oy, buffer);
if (ret==0) break;
while (ogg_sync_pageout(&oy,&og)>0)
{
ogg_stream_state test;
// is this a mandated initial header? If not, stop parsing
if(!ogg_page_bos(&og)){
// don't leak the page; get it into the appropriate stream
queue_page(&og);
stateflag=true;
break;
}
ogg_stream_init(&test,ogg_page_serialno(&og));
ogg_stream_pagein(&test,&og);
ogg_stream_packetout(&test,&op);
// identify the codec: try theora
if (!theora_p && theora_decode_header(&ti,&tc,&op)>=0)
{
// it is theora
memcpy(&to,&test,sizeof(test));
theora_p=1;
} else if(!vorbis_p && vorbis_synthesis_headerin(&vi,&vc,&op)>=0) {
// it is vorbis
memcpy(&vo,&test,sizeof(test));
vorbis_p=1;
} else {
// whatever it is, we don't care about it
ogg_stream_clear(&test);
}
}
}
// we've now identified all the bitstreams. parse the secondary header packets.
while((theora_p && theora_p<3) || (vorbis_p && vorbis_p<3))
{
int ret;
// look for further theora headers
while (theora_p && (theora_p<3) && (ret=ogg_stream_packetout(&to,&op)))
{
if (ret<0) {
ASSERT(!"Error parsing Theora stream headers; corrupt stream?");
return false;
}
if (theora_decode_header(&ti,&tc,&op)) {
ASSERT(!"Error parsing Theora stream headers; corrupt stream?");
return false;
}
++theora_p;
if (theora_p==3)
break;
}
// look for more vorbis header packets
while (vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op)))
{
if (ret<0) {
ASSERT(!"Error parsing Vorbis stream headers; corrupt stream?");
return false;
}
if (vorbis_synthesis_headerin(&vi,&vc,&op)) {
ASSERT(!"Error parsing Vorbis stream headers; corrupt stream?");
return false;
}
++vorbis_p;
if (vorbis_p==3)
break;
}
// The header pages/packets will arrive before anything else we
// care about, or the stream is not obeying spec
if (ogg_sync_pageout(&oy,&og)>0) {
queue_page(&og); // demux into the appropriate stream
} else {
int ret=buffer_data(&oy, buffer);
if(ret==0){
ASSERT(!"End of file while searching for codec headers.");
return false;
}
}
}
return true;
}
int main(int argc,char *argv[]){
int i,j;
ogg_packet op;
FILE *infile = stdin;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
#endif
/* open the input file if any */
if(argc==2){
infile=fopen(argv[1],"rb");
if(infile==NULL){
fprintf(stderr,"Unable to open '%s' for playback.\n", argv[1]);
exit(1);
}
}
if(argc>2){
usage();
exit(1);
}
/* start up Ogg stream synchronization layer */
ogg_sync_init(&oy);
/* init supporting Vorbis structures needed in header parsing */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
/* init supporting Theora structures needed in header parsing */
theora_comment_init(&tc);
theora_info_init(&ti);
/* Ogg file open; parse the headers */
/* Only interested in Vorbis/Theora streams */
while(!stateflag){
int ret=buffer_data(infile,&oy);
if(ret==0)break;
while(ogg_sync_pageout(&oy,&og)>0){
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&og)){
/* don't leak the page; get it into the appropriate stream */
queue_page(&og);
stateflag=1;
break;
}
ogg_stream_init(&test,ogg_page_serialno(&og));
ogg_stream_pagein(&test,&og);
ogg_stream_packetout(&test,&op);
/* identify the codec: try theora */
if(!theora_p && theora_decode_header(&ti,&tc,&op)>=0){
/* it is theora */
memcpy(&to,&test,sizeof(test));
theora_p=1;
}else if(!vorbis_p && vorbis_synthesis_headerin(&vi,&vc,&op)>=0){
/* it is vorbis */
memcpy(&vo,&test,sizeof(test));
vorbis_p=1;
}else{
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
/* we're expecting more header packets. */
while((theora_p && theora_p<3) || (vorbis_p && vorbis_p<3)){
int ret;
/* look for further theora headers */
while(theora_p && (theora_p<3) && (ret=ogg_stream_packetout(&to,&op))){
if(ret<0){
fprintf(stderr,"Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
if(theora_decode_header(&ti,&tc,&op)){
printf("Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
theora_p++;
if(theora_p==3)break;
}
/* look for more vorbis header packets */
while(vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op))){
if(ret<0){
fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)){
fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
vorbis_p++;
if(vorbis_p==3)break;
}
/* The header pages/packets will arrive before anything else we
care about, or the stream is not obeying spec */
if(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og); /* demux into the appropriate stream */
}else{
int ret=buffer_data(infile,&oy); /* someone needs more data */
if(ret==0){
fprintf(stderr,"End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if(theora_p){
theora_decode_init(&td,&ti);
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n",
(unsigned int)to.serialno,ti.width,ti.height,
(double)ti.fps_numerator/ti.fps_denominator);
if(ti.width!=ti.frame_width || ti.height!=ti.frame_height)
printf(" Frame content is %dx%d with offset (%d,%d).\n",
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
report_colorspace(&ti);
dump_comments(&tc);
}else{
/* tear down the partial theora setup */
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
if(vorbis_p){
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
fprintf(stderr,"Ogg logical stream %x is Vorbis %d channel %d Hz audio.\n",
(unsigned int)vo.serialno,vi.channels,(int)vi.rate);
}else{
/* tear down the partial vorbis setup */
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
/* open audio */
if(vorbis_p)open_audio();
/* open video */
if(theora_p)open_video();
/* install signal handler as SDL clobbered the default */
signal (SIGINT, sigint_handler);
/* on to the main decode loop. We assume in this example that audio
and video start roughly together, and don't begin playback until
we have a start frame for both. This is not necessarily a valid
assumption in Ogg A/V streams! It will always be true of the
example_encoder (and most streams) though. */
stateflag=0; /* playback has not begun */
while(!got_sigint){
/* we want a video and audio frame ready to go at all times. If
we have to buffer incoming, buffer the compressed data (ie, let
ogg do the buffering) */
while(vorbis_p && !audiobuf_ready){
int ret;
float **pcm;
/* if there's pending, decoded audio, grab it */
if((ret=vorbis_synthesis_pcmout(&vd,&pcm))>0){
int count=audiobuf_fill/2;
int maxsamples=(audiofd_fragsize-audiobuf_fill)/2/vi.channels;
for(i=0;i<ret && i<maxsamples;i++)
for(j=0;j<vi.channels;j++){
int val=rint(pcm[j][i]*32767.f);
if(val>32767)val=32767;
if(val<-32768)val=-32768;
audiobuf[count++]=val;
}
vorbis_synthesis_read(&vd,i);
audiobuf_fill+=i*vi.channels*2;
if(audiobuf_fill==audiofd_fragsize)audiobuf_ready=1;
if(vd.granulepos>=0)
audiobuf_granulepos=vd.granulepos-ret+i;
else
audiobuf_granulepos+=i;
}else{
/* no pending audio; is there a pending packet to decode? */
if(ogg_stream_packetout(&vo,&op)>0){
if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
vorbis_synthesis_blockin(&vd,&vb);
}else /* we need more data; break out to suck in another page */
break;
}
}
while(theora_p && !videobuf_ready){
/* theora is one in, one out... */
if(ogg_stream_packetout(&to,&op)>0){
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
/* is it already too old to be useful? This is only actually
useful cosmetically after a SIGSTOP. Note that we have to
decode the frame even if we don't show it (for now) due to
keyframing. Soon enough libtheora will be able to deal
with non-keyframe seeks. */
if(videobuf_time>=get_time())
videobuf_ready=1;
}else
break;
}
if(!videobuf_ready && !audiobuf_ready && feof(infile))break;
if(!videobuf_ready || !audiobuf_ready){
/* no data yet for somebody. Grab another page */
int bytes=buffer_data(infile,&oy);
while(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
}
/* If playback has begun, top audio buffer off immediately. */
if(stateflag) audio_write_nonblocking();
/* are we at or past time for this video frame? */
if(stateflag && videobuf_ready && videobuf_time<=get_time()){
video_write();
videobuf_ready=0;
}
if(stateflag &&
(audiobuf_ready || !vorbis_p) &&
(videobuf_ready || !theora_p) &&
!got_sigint){
/* we have an audio frame ready (which means the audio buffer is
full), it's not time to play video, so wait until one of the
audio buffer is ready or it's near time to play video */
/* set up select wait on the audiobuffer and a timeout for video */
struct timeval timeout;
fd_set writefs;
fd_set empty;
int n=0;
FD_ZERO(&writefs);
FD_ZERO(&empty);
if(audiofd>=0){
FD_SET(audiofd,&writefs);
n=audiofd+1;
}
if(theora_p){
long milliseconds=(videobuf_time-get_time())*1000-5;
if(milliseconds>500)milliseconds=500;
if(milliseconds>0){
timeout.tv_sec=milliseconds/1000;
timeout.tv_usec=(milliseconds%1000)*1000;
n=select(n,&empty,&writefs,&empty,&timeout);
if(n)audio_calibrate_timer(0);
}
}else{
select(n,&empty,&writefs,&empty,NULL);
}
}
/* if our buffers either don't exist or are ready to go,
we can begin playback */
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready))stateflag=1;
/* same if we've run out of input */
if(feof(infile))stateflag=1;
}
/* tear it all down */
audio_close();
SDL_Quit();
if(vorbis_p){
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if(theora_p){
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
if(infile && infile!=stdin)fclose(infile);
fprintf(stderr,
"\r "
"\nDone.\n");
return(0);
}
void probe_ogg(info_t *ipipe)
{
ogg_sync_state sync;
ogg_page page;
ogg_packet pack;
char *buf;
int nread, np, sno, nvtracks = 0, natracks = 0, i, idx;
//int endofstream = 0, k, n;
struct demux_t streams[MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS];
int fdin = -1;
char vid_codec[5];
ogm_stream_header *sth;
fdin = ipipe->fd_in;
if (fdin == -1) {
tc_log_error(__FILE__, "Could not open file.");
goto ogg_out;
}
ipipe->probe_info->magic=TC_MAGIC_OGG;
memset(streams, 0, sizeof(streams));
for (i = 0; i < (MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS); i++)
streams[i].serial = -1;
ogg_sync_init(&sync);
while (1) {
np = ogg_sync_pageseek(&sync, &page);
if (np < 0) {
tc_log_error(__FILE__, "ogg_sync_pageseek failed");
goto ogg_out;
}
if (np == 0) {
buf = ogg_sync_buffer(&sync, BLOCK_SIZE);
if (!buf) {
tc_log_error(__FILE__, "ogg_sync_buffer failed");
goto ogg_out;
}
if ((nread = read(fdin, buf, BLOCK_SIZE)) <= 0) {
}
ogg_sync_wrote(&sync, nread);
continue;
}
if (!ogg_page_bos(&page)) {
break;
} else {
ogg_stream_state sstate;
vorbis_info *inf = tc_malloc (sizeof(vorbis_info));
vorbis_comment *com = tc_malloc (sizeof(vorbis_comment));
if (!inf || !com) {
tc_log_error(__FILE__, "Out of Memory at %d", __LINE__);
goto ogg_out;
}
sno = ogg_page_serialno(&page);
if (ogg_stream_init(&sstate, sno)) {
tc_log_error(__FILE__, "ogg_stream_init failed");
goto ogg_out;
}
ogg_stream_pagein(&sstate, &page);
ogg_stream_packetout(&sstate, &pack);
switch (ogm_packet_type(pack))
{
case Vorbis:
vorbis_info_init(inf);
vorbis_comment_init(com);
if(vorbis_synthesis_headerin(inf, com, &pack) < 0) {
tc_log_warn(__FILE__, "Could not decode vorbis header "
"packet - invalid vorbis stream ()");
} else {
#ifdef OGM_DEBUG
tc_log_msg(__FILE__, "(a%d/%d) Vorbis audio; "
"rate: %ldHz, channels: %d, bitrate %3.2f kb/s",
natracks + 1, natracks + nvtracks + 1, inf->rate,
inf->channels, (double)inf->bitrate_nominal/1000.0);
#endif
ipipe->probe_info->track[natracks].samplerate = inf->rate;
ipipe->probe_info->track[natracks].chan = inf->channels;
ipipe->probe_info->track[natracks].bits = 0; /* XXX --tibit*/
ipipe->probe_info->track[natracks].format = TC_CODEC_VORBIS;
ipipe->probe_info->track[natracks].bitrate = (double)inf->bitrate_nominal/1000.0;
ipipe->probe_info->track[natracks].tid=natracks;
if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks;
streams[natracks].serial = sno;
streams[natracks].vorbis = 1;
ac_memcpy(&streams[natracks].state, &sstate, sizeof(sstate));
natracks++;
}
break;
#ifdef HAVE_THEORA
case Theora:
{
theora_info ti;
theora_comment tc;
theora_decode_header(&ti, &tc, &pack);
ipipe->probe_info->width = ti.width;
ipipe->probe_info->height = ti.height;
ipipe->probe_info->fps = (double)ti.fps_numerator/ti.fps_denominator;
tc_frc_code_from_ratio(&(ipipe->probe_info->frc),
ti.fps_numerator, ti.fps_denominator);
ipipe->probe_info->codec=TC_CODEC_THEORA;
idx = natracks + MAX_AUDIO_TRACKS;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
nvtracks++;
break;
}
#endif
case DirectShow:
if ((*(int32_t*)(pack.packet+96) == 0x05589f80) &&
(pack.bytes >= 184)) {
tc_log_warn(__FILE__, "(v%d/%d) Found old video "
"header. Not supported.", nvtracks + 1,
natracks + nvtracks + 1);
} else if (*(int32_t*)pack.packet+96 == 0x05589F81) {
tc_log_warn(__FILE__, "(a%d/%d) Found old audio "
"header. Not supported.", natracks + 1,
natracks + nvtracks + 1);
}
break;
case StreamHeader:
sth = (ogm_stream_header *)(pack.packet + 1);
if (!strncmp(sth->streamtype, "video", 5)) {
#ifdef OGM_DEBUG
unsigned long codec;
codec = (sth->subtype[0] << 24) +
(sth->subtype[1] << 16) + (sth->subtype[2] << 8) + sth->subtype[3];
tc_log_msg(__FILE__, "(v%d/%d) video; fps: %.3f width height: %dx%d "
"codec: %p (%c%c%c%c)", nvtracks + 1,
natracks + nvtracks + 1,
(double)10000000 / (double)sth->time_unit,
sth->sh.video.width, sth->sh.video.height, (void *)codec,
sth->subtype[0], sth->subtype[1], sth->subtype[2],
sth->subtype[3]);
#endif
vid_codec[0] = sth->subtype[0];
vid_codec[1] = sth->subtype[1];
vid_codec[2] = sth->subtype[2];
vid_codec[3] = sth->subtype[3];
vid_codec[4] = '\0';
//ipipe->probe_info->frames = AVI_video_frames(avifile);
ipipe->probe_info->width = sth->sh.video.width;
ipipe->probe_info->height = sth->sh.video.height;
ipipe->probe_info->fps = (double)10000000 / (double)sth->time_unit;
tc_frc_code_from_value(&(ipipe->probe_info->frc),
ipipe->probe_info->fps);
ipipe->probe_info->codec=TC_CODEC_UNKNOWN; // gets rewritten
if(strlen(vid_codec)==0) {
ipipe->probe_info->codec=TC_CODEC_RGB24;
} else {
if(strcasecmp(vid_codec,"dvsd")==0)
ipipe->probe_info->codec=TC_CODEC_DV;
if(strcasecmp(vid_codec,"DIV3")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX3;
if(strcasecmp(vid_codec,"DIVX")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX4;
if(strcasecmp(vid_codec,"DX50")==0)
ipipe->probe_info->codec=TC_CODEC_DIVX5;
if(strcasecmp(vid_codec,"XVID")==0)
ipipe->probe_info->codec=TC_CODEC_XVID;
if(strcasecmp(vid_codec,"MJPG")==0)
ipipe->probe_info->codec=TC_CODEC_MJPEG;
}
idx = natracks + MAX_AUDIO_TRACKS;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
nvtracks++;
} else if (!strncmp(sth->streamtype, "audio", 5)) {
int codec;
char buf[5];
ac_memcpy(buf, sth->subtype, 4);
buf[4] = 0;
codec = strtoul(buf, NULL, 16);
#ifdef OGM_DEBUG
tc_log_msg(__FILE__, "(a%d/%d) codec: %d (0x%04x) (%s) bits per "
"sample: %d channels: %hd samples per second: %ld "
"avgbytespersec: %hd blockalign: %d",
natracks + 1, natracks + nvtracks + 1,
codec, codec,
codec == 0x1 ? "PCM" : codec == 55 ? "MP3" :
codec == 0x55 ? "MP3" :
codec == 0x2000 ? "AC3" : "unknown",
sth->bits_per_sample, sth->sh.audio.channels,
(long)sth->samples_per_unit,
sth->sh.audio.avgbytespersec,
sth->sh.audio.blockalign);
#endif
idx = natracks;
ipipe->probe_info->track[natracks].samplerate = sth->samples_per_unit;
ipipe->probe_info->track[natracks].chan = sth->sh.audio.channels;
ipipe->probe_info->track[natracks].bits =
(sth->bits_per_sample<4)?sth->bits_per_sample*8:sth->bits_per_sample;
ipipe->probe_info->track[natracks].format = codec;
ipipe->probe_info->track[natracks].bitrate = 0;
ipipe->probe_info->track[natracks].tid=natracks;
if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks;
streams[idx].serial = sno;
ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate));
natracks++;
} else {
tc_log_warn(__FILE__, "(%d) found new header of unknown/"
"unsupported type\n", nvtracks + natracks + 1);
}
break;
case none:
tc_log_warn(__FILE__, "OGG stream %d is of an unknown type "
"(bad header?)", nvtracks + natracks + 1);
break;
} /* switch type */
free(inf);
free(com);
ogg_stream_clear(&sstate);
} /* beginning of page */
} /* while (1) */
ogg_out:
//close(fdin);
return;
}
int input_calculate_ogg_sleep(ogg_page *page)
{
static ogg_stream_state os;
ogg_packet op;
static vorbis_info vi;
static vorbis_comment vc;
static input_type codec = ICES_INPUT_UNKNOWN;
static int need_start_pos, need_headers, state_in_use = 0;
static int serialno = 0;
static uint64_t offset;
static uint64_t first_granulepos;
if (ogg_page_granulepos(page) == -1)
{
LOG_ERROR0("Timing control: corrupt timing information in vorbis file, cannot stream.");
return -1;
}
if (ogg_page_bos (page))
{
control.oldsamples = 0;
if (state_in_use)
ogg_stream_clear (&os);
ogg_stream_init (&os, ogg_page_serialno (page));
serialno = ogg_page_serialno (page);
state_in_use = 1;
vorbis_info_init (&vi);
vorbis_comment_init (&vc);
need_start_pos = 1;
need_headers = 3;
codec = ICES_INPUT_UNKNOWN;
offset = (uint64_t)0;
}
if (need_start_pos)
{
int found_first_granulepos = 0;
ogg_stream_pagein (&os, page);
while (ogg_stream_packetout (&os, &op) == 1)
{
if (need_headers)
{
/* check for Vorbis. For Vorbis the Magic is {0x01|0x03|0x05}"vorbis" */
if (op.bytes > 7 && memcmp(op.packet+1, "vorbis", 6) == 0)
{
if (vorbis_synthesis_headerin (&vi, &vc, &op) < 0)
{
LOG_ERROR0("Timing control: can't determine sample rate for input, not vorbis.");
control.samplerate = 0;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
return -1;
}
control.samplerate = vi.rate;
codec = ICES_INPUT_VORBIS;
}
/* check for Opus. For Opus the magic is "OpusHead" */
else if (op.bytes == 19 && memcmp(op.packet, "OpusHead", 8) == 0)
{
if (op.packet[8] != 1)
{
LOG_ERROR0("Timing control: can't determine sample rate for input, unsupported Opus version.");
control.samplerate = 0;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
return -1;
}
/* Sample rate is fixed for Opus: 48kHz */
control.samplerate = 48000;
codec = ICES_INPUT_OGG;
/* No more headers after this one needed */
need_headers = 1;
}
else if (op.bytes >= 80 && memcmp(op.packet, "Speex ", 8) == 0)
{
if (__read_int32_le(op.packet+28) != 1 || __read_int32_le(op.packet+32) != op.bytes)
{
LOG_ERROR0("Timing control: can't determine sample rate for input, bad or unsupported Speex header.");
control.samplerate = 0;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
return -1;
}
control.samplerate = __read_int32_le(op.packet+36);
codec = ICES_INPUT_OGG;
/* No more headers after this one needed */
need_headers = 1;
}
else if (op.bytes >= 51 && memcmp(op.packet, "\177FLAC\1\0", 7) == 0 && memcmp(op.packet+9, "fLaC\0", 5) == 0)
{
control.samplerate = __read_int20_be(op.packet+27);
codec = ICES_INPUT_OGG;
/* No more headers after this one needed */
need_headers = 1;
}
else if (codec == ICES_INPUT_UNKNOWN)
{
LOG_ERROR0("Timing control: can't determine sample rate for input, unsupported input format.");
control.samplerate = 0;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
return -1;
}
need_headers--;
if (need_headers == 0)
{
vorbis_comment_clear (&vc);
first_granulepos = (uint64_t)0;
return 0;
}
continue;
}
/* headers have been read */
if (first_granulepos == 0 && op.granulepos > 0)
{
first_granulepos = op.granulepos;
found_first_granulepos = 1;
}
if (codec == ICES_INPUT_VORBIS)
{
offset += vorbis_packet_blocksize (&vi, &op) / 4;
}
}
if (!found_first_granulepos)
return 0;
need_start_pos = 0;
control.oldsamples = first_granulepos - offset;
vorbis_info_clear (&vi);
ogg_stream_clear (&os);
state_in_use = 0;
}
if (serialno != ogg_page_serialno (page))
{
LOG_ERROR0 ("Found page which does not belong to current logical stream");
return -1;
}
control.samples = ogg_page_granulepos (page) - control.oldsamples;
control.oldsamples = ogg_page_granulepos (page);
control.senttime += ((uint64_t)control.samples * 1000000 /
(uint64_t)control.samplerate);
return 0;
}
/* main plugin handler for getting a buffer for the queue. In here we
* just add an incoming page to the codecs and process it until either
* more data is needed or we prodice a buffer for the queue.
*/
static refbuf_t *ogg_get_buffer (source_t *source)
{
ogg_state_t *ogg_info = source->format->_state;
format_plugin_t *format = source->format;
char *data = NULL;
int bytes = 0;
while (1)
{
while (1)
{
ogg_page page;
refbuf_t *refbuf = NULL;
ogg_codec_t *codec = ogg_info->current;
/* if a codec has just been given a page then process it */
if (codec && codec->process)
{
refbuf = codec->process (ogg_info, codec);
if (refbuf)
return complete_buffer (source, refbuf);
ogg_info->current = NULL;
}
if (ogg_sync_pageout (&ogg_info->oy, &page) > 0)
{
if (ogg_page_bos (&page))
{
process_initial_page (source->format, &page);
}
else
{
ogg_info->bos_completed = 1;
refbuf = process_ogg_page (ogg_info, &page);
}
if (ogg_info->error)
{
ERROR0 ("Problem processing stream");
source->flags &= ~SOURCE_RUNNING;
return NULL;
}
if (refbuf)
return complete_buffer (source, refbuf);
continue;
}
/* need more stream data */
break;
}
/* we need more data to continue getting pages */
data = ogg_sync_buffer (&ogg_info->oy, 4096);
bytes = client_read_bytes (source->client, data, 4096);
if (bytes <= 0)
{
ogg_sync_wrote (&ogg_info->oy, 0);
return NULL;
}
format->read_bytes += bytes;
rate_add (format->in_bitrate, bytes, source->client->worker->current_time.tv_sec);
ogg_sync_wrote (&ogg_info->oy, bytes);
}
}
int OggInit(CFile *f, OggData *data)
{
ogg_packet packet;
int num_vorbis;
#ifdef USE_THEORA
int num_theora;
#endif
int stream_start;
int ret;
unsigned magic;
f->read(&magic, sizeof(magic));
if (SDL_SwapLE32(magic) != 0x5367674F) { // "OggS" in ASCII
return -1;
}
f->seek(0, SEEK_SET);
ogg_sync_init(&data->sync);
vorbis_info_init(&data->vinfo);
vorbis_comment_init(&data->vcomment);
#ifdef USE_THEORA
theora_info_init(&data->tinfo);
theora_comment_init(&data->tcomment);
#endif
#ifdef USE_THEORA
num_theora = 0;
#endif
num_vorbis = 0;
stream_start = 0;
while (!stream_start) {
ogg_stream_state test;
if (OggGetNextPage(&data->page, &data->sync, f)) {
return -1;
}
if (!ogg_page_bos(&data->page)) {
if (num_vorbis) {
ogg_stream_pagein(&data->astream, &data->page);
}
#ifdef USE_THEORA
if (num_theora) {
ogg_stream_pagein(&data->vstream, &data->page);
}
#endif
stream_start = 1;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&data->page));
ogg_stream_pagein(&test, &data->page);
// initial codec headers
while (ogg_stream_packetout(&test, &packet) == 1) {
#ifdef USE_THEORA
if (theora_decode_header(&data->tinfo, &data->tcomment, &packet) >= 0) {
memcpy(&data->vstream, &test, sizeof(test));
++num_theora;
} else
#endif
if (!vorbis_synthesis_headerin(&data->vinfo, &data->vcomment, &packet)) {
memcpy(&data->astream, &test, sizeof(test));
++num_vorbis;
} else {
ogg_stream_clear(&test);
}
}
}
data->audio = num_vorbis;
#ifdef USE_THEORA
data->video = num_theora;
#endif
// remainint codec headers
while ((num_vorbis && num_vorbis < 3)
#ifdef USE_THEORA
|| (num_theora && num_theora < 3) ) {
// are we in the theora page ?
while (num_theora && num_theora < 3 &&
(ret = ogg_stream_packetout(&data->vstream, &packet))) {
if (ret < 0) {
return -1;
}
if (theora_decode_header(&data->tinfo, &data->tcomment, &packet)) {
return -1;
}
++num_theora;
}
#else
) {
#endif
// are we in the vorbis page ?
while (num_vorbis && num_vorbis < 3 &&
(ret = ogg_stream_packetout(&data->astream, &packet))) {
if (ret < 0) {
return -1;
}
if (vorbis_synthesis_headerin(&data->vinfo, &data->vcomment, &packet)) {
return -1;
}
++num_vorbis;
}
if (OggGetNextPage(&data->page, &data->sync, f)) {
break;
}
if (num_vorbis) {
ogg_stream_pagein(&data->astream, &data->page);
}
#ifdef USE_THEORA
if (num_theora) {
ogg_stream_pagein(&data->vstream, &data->page);
}
#endif
}
if (num_vorbis) {
vorbis_synthesis_init(&data->vdsp, &data->vinfo);
vorbis_block_init(&data->vdsp, &data->vblock);
} else {
vorbis_info_clear(&data->vinfo);
vorbis_comment_clear(&data->vcomment);
}
#ifdef USE_THEORA
if (num_theora) {
theora_decode_init(&data->tstate, &data->tinfo);
data->tstate.internal_encode = NULL; // needed for a bug in libtheora (fixed in next release)
} else {
theora_info_clear(&data->tinfo);
theora_comment_clear(&data->tcomment);
}
return !(num_vorbis || num_theora);
#else
return !num_vorbis;
#endif
}
void DGVideo::load() {
int stateFlag = 0;
if (!_hasResource) {
log->error(DGModVideo, "%s", DGMsg280005);
return;
}
//log->trace(DGModVideo, "%s %s", DGMsg080001, _resource);
_handle = fopen(_resource, "rb");
if (_handle == NULL) {
log->error(DGModVideo, "%s: %s", DGMsg280002, _resource);
return;
}
ogg_sync_init(&_theoraInfo->oy);
theora_comment_init(&_theoraInfo->tc);
theora_info_init(&_theoraInfo->ti);
while (!stateFlag) {
size_t ret = _bufferData(&_theoraInfo->oy);
if (ret == 0)
break;
while (ogg_sync_pageout(&_theoraInfo->oy, &_theoraInfo->og) > 0) {
ogg_stream_state test;
if (!ogg_page_bos(&_theoraInfo->og)) {
_queuePage(_theoraInfo, &_theoraInfo->og);
stateFlag = 1;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&_theoraInfo->og));
ogg_stream_pagein(&test, &_theoraInfo->og);
ogg_stream_packetout(&test, &_theoraInfo->op);
if (!_theoraInfo->theora_p &&
theora_decode_header(&_theoraInfo->ti, &_theoraInfo->tc, &_theoraInfo->op) >= 0) {
memcpy(&_theoraInfo->to, &test, sizeof(test));
_theoraInfo->theora_p = 1;
} else {
ogg_stream_clear(&test);
}
}
}
while (_theoraInfo->theora_p && _theoraInfo->theora_p < 3) {
int ret;
while (_theoraInfo->theora_p && (_theoraInfo->theora_p < 3) &&
(ret = ogg_stream_packetout(&_theoraInfo->to, &_theoraInfo->op))) {
if (ret < 0) {
log->error(DGModVideo, "%s", DGMsg280003);
return;
}
if (theora_decode_header(&_theoraInfo->ti, &_theoraInfo->tc, &_theoraInfo->op)) {
log->error(DGModVideo, "%s", DGMsg280003);
return;
}
_theoraInfo->theora_p++;
if (_theoraInfo->theora_p == 3)
break;
}
if (ogg_sync_pageout(& _theoraInfo->oy, & _theoraInfo->og) > 0)
_queuePage(_theoraInfo, &_theoraInfo->og);
else {
size_t ret = _bufferData(&_theoraInfo->oy);
if (ret == 0) {
log->error(DGModVideo, "%s", DGMsg280004);
return;
}
}
}
if (_theoraInfo->theora_p) {
theora_decode_init(&_theoraInfo->td, &_theoraInfo->ti);
} else {
theora_info_clear(&_theoraInfo->ti);
theora_comment_clear(&_theoraInfo->tc);
}
_currentFrame.width = _theoraInfo->ti.width;
_currentFrame.height = _theoraInfo->ti.height;
_currentFrame.depth = 24; // NOTE: We only support flat RGB for now
_currentFrame.data = (unsigned char*)malloc((_theoraInfo->ti.width * _theoraInfo->ti.height) * 3);
while (ogg_sync_pageout(&_theoraInfo->oy, &_theoraInfo->og) > 0) {
_queuePage(_theoraInfo, &_theoraInfo->og);
}
_frameDuration = (float)(1/((double)_theoraInfo->ti.fps_numerator / _theoraInfo->ti.fps_denominator));
_isLoaded = true;
}