/* check if the provided BOS page is the start of a vorbis stream. If so
* then setup a structure so it can be used
*/
ogg_codec_t *initial_vorbis_page (format_plugin_t *plugin, ogg_page *page)
{
ogg_state_t *ogg_info = plugin->_state;
ogg_codec_t *codec = calloc (1, sizeof (ogg_codec_t));
ogg_packet packet;
vorbis_codec_t *vorbis = calloc (1, sizeof (vorbis_codec_t));
ogg_stream_init (&codec->os, ogg_page_serialno (page));
ogg_stream_pagein (&codec->os, page);
vorbis_info_init (&vorbis->vi);
vorbis_comment_init (&vorbis->vc);
ogg_stream_packetout (&codec->os, &packet);
DEBUG0("checking for vorbis codec");
if (vorbis_synthesis_headerin (&vorbis->vi, &vorbis->vc, &packet) < 0)
{
ogg_stream_clear (&codec->os);
vorbis_info_clear (&vorbis->vi);
vorbis_comment_clear (&vorbis->vc);
free (vorbis);
free (codec);
return NULL;
}
INFO0 ("seen initial vorbis header");
codec->specific = vorbis;
codec->codec_free = vorbis_codec_free;
codec->headers = 1;
codec->parent = ogg_info;
codec->name = "Vorbis";
free_ogg_packet (vorbis->header[0]);
free_ogg_packet (vorbis->header[1]);
free_ogg_packet (vorbis->header[2]);
memset (vorbis->header, 0, sizeof (vorbis->header));
vorbis->header [0] = copy_ogg_packet (&packet);
ogg_stream_init (&vorbis->new_os, rand());
codec->process_page = process_vorbis_page;
codec->process = process_vorbis;
plugin->set_tag = vorbis_set_tag;
vorbis->bos_page.header = malloc (page->header_len + page->body_len);
memcpy (vorbis->bos_page.header, page->header, page->header_len);
vorbis->bos_page.header_len = page->header_len;
vorbis->bos_page.body = vorbis->bos_page.header + page->header_len;
memcpy (vorbis->bos_page.body, page->body, page->body_len);
vorbis->bos_page.body_len = page->body_len;
return codec;
}
/* process the vorbis audio packets. Here we just take each packet out
* and add them into the new stream, flushing after so many samples. We
* also check if an new headers are requested after each processed page
*/
static int process_vorbis_audio (ogg_state_t *ogg_info, ogg_codec_t *codec)
{
vorbis_codec_t *source_vorbis = codec->specific;
while (1)
{
int window;
ogg_packet packet;
/* now, lets extract what packets we can */
if (ogg_stream_packetout (&codec->os, &packet) <= 0)
break;
/* calculate granulepos for the packet */
window = vorbis_packet_blocksize (&source_vorbis->vi, &packet) / 4;
source_vorbis->granulepos += window;
if (source_vorbis->prev_packet)
{
ogg_packet *prev_packet = source_vorbis->prev_packet;
add_audio_packet (source_vorbis, prev_packet);
free_ogg_packet (prev_packet);
packet . granulepos = source_vorbis->granulepos;
}
else
{
packet . granulepos = 0;
}
/* store the current packet details */
source_vorbis->prev_window = window;
source_vorbis->prev_packet = copy_ogg_packet (&packet);
if (packet.e_o_s)
{
initiate_flush (source_vorbis);
free_ogg_packet (source_vorbis->prev_packet);
source_vorbis->prev_packet = NULL;
return 1;
}
/* allow for pages to be flushed if there's over a certain number of samples */
if (source_vorbis->samples_in_page > source_vorbis->page_samples_trigger)
return 1;
}
if (source_vorbis->stream_notify)
{
initiate_flush (source_vorbis);
source_vorbis->stream_notify = 0;
return 1;
}
return -1;
}
/* handle incoming page. as the stream is being rebuilt, we need to
* add all pages from the stream before processing packets
*/
static refbuf_t *process_vorbis_page (ogg_state_t *ogg_info,
ogg_codec_t *codec, ogg_page *page)
{
ogg_packet header;
vorbis_codec_t *source_vorbis = codec->specific;
char *comment;
if (ogg_stream_pagein (&codec->os, page) < 0)
{
ogg_info->error = 1;
return NULL;
}
if (codec->headers == 3)
return NULL;
while (codec->headers < 3)
{
/* now, lets extract the packets */
DEBUG1 ("processing incoming header packet (%d)", codec->headers);
if (ogg_stream_packetout (&codec->os, &header) <= 0)
{
if (ogg_info->codecs->next)
format_ogg_attach_header (ogg_info, page);
return NULL;
}
/* change comments here if need be */
if (vorbis_synthesis_headerin (&source_vorbis->vi, &source_vorbis->vc, &header) < 0)
{
ogg_info->error = 1;
WARN0 ("Problem parsing ogg vorbis header");
return NULL;
}
header.granulepos = 0;
source_vorbis->header [codec->headers] = copy_ogg_packet (&header);
codec->headers++;
}
DEBUG0 ("we have the header packets now");
/* if vorbis is the only codec then allow rebuilding of the streams */
if (ogg_info->codecs->next == NULL)
{
/* set queued vorbis pages to contain about 1/2 of a second worth of samples */
source_vorbis->page_samples_trigger = source_vorbis->vi.rate / 2;
source_vorbis->process_packet = process_vorbis_headers;
}
else
{
format_ogg_attach_header (ogg_info, &source_vorbis->bos_page);
format_ogg_attach_header (ogg_info, page);
codec->process_page = process_vorbis_passthru_page;
}
free (ogg_info->title);
comment = vorbis_comment_query (&source_vorbis->vc, "TITLE", 0);
if (comment)
ogg_info->title = strdup (comment);
else
ogg_info->title = NULL;
free (ogg_info->artist);
comment = vorbis_comment_query (&source_vorbis->vc, "ARTIST", 0);
if (comment)
ogg_info->artist = strdup (comment);
else
ogg_info->artist = NULL;
ogg_info->log_metadata = 1;
stats_event_args (ogg_info->mount, "audio_samplerate", "%ld", (long)source_vorbis->vi.rate);
stats_event_args (ogg_info->mount, "audio_channels", "%ld", (long)source_vorbis->vi.channels);
stats_event_args (ogg_info->mount, "audio_bitrate", "%ld", (long)source_vorbis->vi.bitrate_nominal);
stats_event_args (ogg_info->mount, "ice-bitrate", "%ld", (long)source_vorbis->vi.bitrate_nominal/1000);
return NULL;
}
