format_vorbis.c 17.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/* Icecast
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright 2000-2004, Jack Moffitt <jack@xiph.org, 
 *                      Michael Smith <msmith@xiph.org>,
 *                      oddsock <oddsock@xiph.org>,
 *                      Karl Heyes <karl@xiph.org>
 *                      and others (see AUTHORS for details).
 */

13 14

/* Ogg codec handler for vorbis streams */
Jack Moffitt's avatar
Jack Moffitt committed
15

16 17 18 19
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

Jack Moffitt's avatar
Jack Moffitt committed
20 21 22
#include <stdlib.h>
#include <ogg/ogg.h>
#include <vorbis/codec.h>
23
#include <memory.h>
24
#include <string.h>
Jack Moffitt's avatar
Jack Moffitt committed
25 26

#include "refbuf.h"
Michael Smith's avatar
Michael Smith committed
27 28
#include "source.h"
#include "client.h"
Jack Moffitt's avatar
Jack Moffitt committed
29

30
#include "format_ogg.h"
Michael Smith's avatar
Michael Smith committed
31
#include "stats.h"
Jack Moffitt's avatar
Jack Moffitt committed
32 33
#include "format.h"

34 35 36
#define CATMODULE "format-vorbis"
#include "logging.h"

Michael Smith's avatar
Michael Smith committed
37

38
typedef struct vorbis_codec_tag 
Jack Moffitt's avatar
Jack Moffitt committed
39
{
40
    vorbis_info    vi;
41 42
    vorbis_comment vc;

43 44
    int rebuild_comment;
    int stream_notify;
45
    int initial_audio_page;
Jack Moffitt's avatar
Jack Moffitt committed
46

47 48 49 50 51 52 53 54 55 56 57 58
    ogg_stream_state    new_os;
    int                 page_samples_trigger;
    ogg_int64_t         prev_granulepos;
    ogg_packet          *prev_packet;
    ogg_int64_t         granulepos;
    ogg_int64_t         initial_page_granulepos;
    ogg_int64_t         samples_in_page;
    int                 prev_window;
    int                 initial_audio_packet;

    ogg_page    bos_page;
    ogg_packet  *header[3];
59 60 61 62
    ogg_int64_t prev_page_samples;

    int (*process_packet)(ogg_state_t *ogg_info, ogg_codec_t *codec);
    refbuf_t *(*get_buffer_page)(ogg_state_t *ogg_info, ogg_codec_t *codec);
Karl Heyes's avatar
Karl Heyes committed
63

64
} vorbis_codec_t;
Karl Heyes's avatar
Karl Heyes committed
65

66 67 68 69
static int process_vorbis_headers (ogg_state_t *ogg_info, ogg_codec_t *codec);
static refbuf_t *process_vorbis_page (ogg_state_t *ogg_info,
                ogg_codec_t *codec, ogg_page *page);
static refbuf_t *process_vorbis (ogg_state_t *ogg_info, ogg_codec_t *codec);
70
static void vorbis_set_tag (format_plugin_t *plugin, const char *tag, const char *value, const char *charset);
Jack Moffitt's avatar
Jack Moffitt committed
71

Karl Heyes's avatar
Karl Heyes committed
72

73
static void free_ogg_packet (ogg_packet *packet)
Jack Moffitt's avatar
Jack Moffitt committed
74
{
75 76 77 78 79 80
    if (packet)
    {
        free (packet->packet);
        free (packet);
    }
}
Jack Moffitt's avatar
Jack Moffitt committed
81

82

83 84 85 86
static void vorbis_codec_free (ogg_state_t *ogg_info, ogg_codec_t *codec)
{
    vorbis_codec_t *vorbis = codec->specific;

87
    ICECAST_LOG_DEBUG("freeing vorbis codec");
88 89 90
    stats_event (ogg_info->mount, "audio_bitrate", NULL);
    stats_event (ogg_info->mount, "audio_channels", NULL);
    stats_event (ogg_info->mount, "audio_samplerate", NULL);
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
    vorbis_info_clear (&vorbis->vi);
    vorbis_comment_clear (&vorbis->vc);
    ogg_stream_clear (&codec->os);
    ogg_stream_clear (&vorbis->new_os);
    free_ogg_packet (vorbis->header[0]);
    free_ogg_packet (vorbis->header[1]);
    free_ogg_packet (vorbis->header[2]);
    free_ogg_packet (vorbis->prev_packet);
    free (vorbis->bos_page.header);
    free (vorbis);
    free (codec);
}


static ogg_packet *copy_ogg_packet (ogg_packet *packet)
{
    ogg_packet *next;
    do
    {
        next = malloc (sizeof (ogg_packet));
        if (next == NULL)
            break;
        memcpy (next, packet, sizeof (ogg_packet));
        next->packet = malloc (next->bytes);
        if (next->packet == NULL)
            break;
        memcpy (next->packet, packet->packet, next->bytes);
        return next;
    } while (0);
Jack Moffitt's avatar
Jack Moffitt committed
120

121 122 123 124
    if (next)
        free (next);
    return NULL;
}
Jack Moffitt's avatar
Jack Moffitt committed
125 126


127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
static void add_audio_packet (vorbis_codec_t *source_vorbis, ogg_packet *packet)
{
    if (source_vorbis->initial_audio_packet)
    {
        packet->granulepos = 0;
        source_vorbis->initial_audio_packet = 0;
    }
    else
    {
        source_vorbis->samples_in_page +=
            (packet->granulepos - source_vorbis->prev_granulepos);
        source_vorbis->prev_granulepos = packet->granulepos;
        source_vorbis->granulepos += source_vorbis->prev_window;
    }
    ogg_stream_packetin (&source_vorbis->new_os, packet);
Jack Moffitt's avatar
Jack Moffitt committed
142 143
}

144 145

static refbuf_t *get_buffer_audio (ogg_state_t *ogg_info, ogg_codec_t *codec)
146
{
147 148 149 150
    refbuf_t *refbuf = NULL;
    ogg_page page;
    vorbis_codec_t *source_vorbis = codec->specific;
    int (*get_ogg_page)(ogg_stream_state*, ogg_page *) = ogg_stream_pageout;
151

152 153
    if (source_vorbis->samples_in_page > source_vorbis->page_samples_trigger)
        get_ogg_page = ogg_stream_flush;
154

155
    if (get_ogg_page (&source_vorbis->new_os, &page) > 0)
Karl Heyes's avatar
Karl Heyes committed
156
    {
157 158 159 160 161
        /* squeeze a page copy into a buffer */
        source_vorbis->samples_in_page -= (ogg_page_granulepos (&page) - source_vorbis->prev_page_samples);
        source_vorbis->prev_page_samples = ogg_page_granulepos (&page);

        refbuf = make_refbuf_with_page (&page);
Karl Heyes's avatar
Karl Heyes committed
162
    }
163 164 165
    return refbuf;
}

166

167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
static refbuf_t *get_buffer_header (ogg_state_t *ogg_info, ogg_codec_t *codec)
{
    int headers_flushed = 0;
    ogg_page page;
    vorbis_codec_t *source_vorbis = codec->specific;

    while (ogg_stream_flush (&source_vorbis->new_os, &page) > 0)
    {
        format_ogg_attach_header (ogg_info, &page);
        headers_flushed = 1;
    }
    if (headers_flushed)
    {
        source_vorbis->get_buffer_page = get_buffer_audio;
    }
    return NULL;
183 184
}

185

186
static refbuf_t *get_buffer_finished(ogg_state_t *ogg_info, ogg_codec_t *codec)
Jack Moffitt's avatar
Jack Moffitt committed
187
{
188 189 190 191 192
    vorbis_codec_t *source_vorbis = codec->specific;
    ogg_page page;
    refbuf_t *refbuf;

    if (ogg_stream_flush (&source_vorbis->new_os, &page) > 0)
Karl Heyes's avatar
Karl Heyes committed
193
    {
194 195 196 197
        source_vorbis->samples_in_page -= (ogg_page_granulepos (&page) - source_vorbis->prev_page_samples);
        source_vorbis->prev_page_samples = ogg_page_granulepos (&page);

        refbuf = make_refbuf_with_page (&page);
198
        ICECAST_LOG_DEBUG("flushing page");
199
        return refbuf;
200
    }
201 202 203 204 205
    ogg_stream_clear (&source_vorbis->new_os);
    ogg_stream_init (&source_vorbis->new_os, rand());

    format_ogg_free_headers (ogg_info);
    source_vorbis->get_buffer_page = NULL;
206 207 208 209 210
    if (source_vorbis->prev_packet)
        source_vorbis->process_packet = process_vorbis_headers;
    else
        source_vorbis->process_packet = NULL;

211 212 213 214 215 216 217 218 219 220 221
    if (source_vorbis->initial_audio_packet == 0)
        source_vorbis->prev_window = 0;

    return NULL;
}


/* push last packet into stream marked with eos */
static void initiate_flush (vorbis_codec_t *source_vorbis)
{
    if (source_vorbis->prev_packet)
Karl Heyes's avatar
Karl Heyes committed
222
    {
223
        /* insert prev_packet with eos */
224
        ICECAST_LOG_DEBUG("adding EOS packet");
225 226 227
        source_vorbis->prev_packet->e_o_s = 1;
        add_audio_packet (source_vorbis, source_vorbis->prev_packet);
        source_vorbis->prev_packet->e_o_s = 0;
Karl Heyes's avatar
Karl Heyes committed
228
    }
229 230 231
    source_vorbis->get_buffer_page = get_buffer_finished;
    source_vorbis->initial_audio_packet = 1;
}
Jack Moffitt's avatar
Jack Moffitt committed
232

233

234 235 236 237
/* 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
 */
238
static int process_vorbis_audio(ogg_state_t *ogg_info, ogg_codec_t *codec)
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
{
    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);
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

            /* check for short values on first initial page */
            if (packet . packetno == 4)
            {
                if (source_vorbis->initial_page_granulepos < source_vorbis->granulepos)
                {
                    source_vorbis->granulepos -= source_vorbis->initial_page_granulepos;
                    source_vorbis->samples_in_page = source_vorbis->page_samples_trigger;
                }
            }
            /* check for long values on first page */
            if (packet.granulepos == source_vorbis->initial_page_granulepos)
            {
                if (source_vorbis->initial_page_granulepos > source_vorbis->granulepos)
                    source_vorbis->granulepos = source_vorbis->initial_page_granulepos;
            }

            if (packet.e_o_s == 0)
                packet . granulepos = source_vorbis->granulepos;
Karl Heyes's avatar
Karl Heyes committed
280
        }
281
        else
Karl Heyes's avatar
Karl Heyes committed
282
        {
283
            packet . granulepos = 0;
284
        }
Jack Moffitt's avatar
Jack Moffitt committed
285

286 287 288 289 290 291
        /* 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);
292 293
            free_ogg_packet (source_vorbis->prev_packet);
            source_vorbis->prev_packet = NULL;
294 295
            return 1;
        }
Jack Moffitt's avatar
Jack Moffitt committed
296

297 298 299 300 301 302 303 304
        /* 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;
305
        return 1;
306 307
    }
    return -1;
Jack Moffitt's avatar
Jack Moffitt committed
308 309
}

310 311 312 313 314

/* This handles the headers at the backend, here we insert the header packets
 * we want for the queue.
 */
static int process_vorbis_headers (ogg_state_t *ogg_info, ogg_codec_t *codec)
Michael Smith's avatar
Michael Smith committed
315
{
316 317 318 319
    vorbis_codec_t *source_vorbis = codec->specific;

    if (source_vorbis->header [0] == NULL)
        return 0;
Karl Heyes's avatar
Karl Heyes committed
320

321
    ICECAST_LOG_DEBUG("Adding the 3 header packets");
322 323 324
    ogg_stream_packetin (&source_vorbis->new_os, source_vorbis->header [0]);
    /* NOTE: we could build a separate comment packet each time */
    if (source_vorbis->rebuild_comment)
Karl Heyes's avatar
Karl Heyes committed
325
    {
326 327
        vorbis_comment vc;
        ogg_packet header;
328
        ice_config_t *config;
329 330 331 332 333 334

        vorbis_comment_init (&vc);
        if (ogg_info->artist) 
            vorbis_comment_add_tag (&vc, "artist", ogg_info->artist);
        if (ogg_info->title)
            vorbis_comment_add_tag (&vc, "title", ogg_info->title);
335 336 337
        config = config_get_config();
        vorbis_comment_add_tag (&vc, "server", config->server_id);
        config_release_config();
338 339 340 341 342
        vorbis_commentheader_out (&vc, &header);

        ogg_stream_packetin (&source_vorbis->new_os, &header);
        vorbis_comment_clear (&vc);
        ogg_packet_clear (&header);
Karl Heyes's avatar
Karl Heyes committed
343
    }
344 345 346 347 348 349 350 351 352 353 354
    else
        ogg_stream_packetin (&source_vorbis->new_os, source_vorbis->header [1]);
    ogg_stream_packetin (&source_vorbis->new_os, source_vorbis->header [2]);
    source_vorbis->rebuild_comment = 0;

    ogg_info->log_metadata = 1;
    source_vorbis->get_buffer_page = get_buffer_header;
    source_vorbis->process_packet = process_vorbis_audio;
    source_vorbis->granulepos = source_vorbis->prev_window;
    source_vorbis->initial_audio_packet = 1;
    return 1;
355
}
Jack Moffitt's avatar
Jack Moffitt committed
356

357 358 359 360 361

/* 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)
Michael Smith's avatar
Michael Smith committed
362
{
363 364 365 366 367 368 369 370 371 372 373 374 375
    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);

376
    ICECAST_LOG_DEBUG("checking for vorbis codec");
377 378 379 380 381 382 383 384 385
    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;
    }
386
    ICECAST_LOG_INFO("seen initial vorbis header");
387 388 389
    codec->specific = vorbis;
    codec->codec_free = vorbis_codec_free;
    codec->headers = 1;
390
    codec->name = "Vorbis";
391

392 393 394 395 396 397
    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());
398 399 400 401 402

    codec->process_page = process_vorbis_page;
    codec->process = process_vorbis;
    plugin->set_tag = vorbis_set_tag;

403 404 405
    vorbis->bos_page.header = malloc(page->header_len + page->body_len);

    memcpy(vorbis->bos_page.header, page->header, page->header_len);
406
    vorbis->bos_page.header_len = page->header_len;
Michael Smith's avatar
Michael Smith committed
407

408
    vorbis->bos_page.body = vorbis->bos_page.header + page->header_len;
409
    memcpy(vorbis->bos_page.body, page->body, page->body_len);
410
    vorbis->bos_page.body_len = page->body_len;
Michael Smith's avatar
Michael Smith committed
411

412
    return codec;
Michael Smith's avatar
Michael Smith committed
413 414
}

Karl Heyes's avatar
Karl Heyes committed
415

416 417 418
/* called from the admin interface, here we update the artist/title info
 * and schedule a new set of header pages
 */
419
static void vorbis_set_tag (format_plugin_t *plugin, const char *tag, const char *in_value, const char *charset)
420 421 422 423
{   
    ogg_state_t *ogg_info = plugin->_state;
    ogg_codec_t *codec = ogg_info->codecs;
    vorbis_codec_t *source_vorbis;
424
    char *value;
425 426 427 428 429 430 431

    /* avoid updating if multiple codecs in use */
    if (codec && codec->next == NULL)
        source_vorbis = codec->specific;
    else
        return;

432 433 434 435 436 437 438
    if (tag == NULL)
    {
        source_vorbis->stream_notify = 1;
        source_vorbis->rebuild_comment = 1;
        return;
    }

Karl Heyes's avatar
Karl Heyes committed
439
    value = util_conv_string (in_value, charset, "UTF-8");
440 441 442
    if (value == NULL)
        value = strdup (in_value);

443
    if (strcmp (tag, "artist") == 0)
Karl Heyes's avatar
Karl Heyes committed
444
    {
445 446
        free (ogg_info->artist);
        ogg_info->artist = value;
Karl Heyes's avatar
Karl Heyes committed
447
    }
448
    else if (strcmp (tag, "title") == 0)
Karl Heyes's avatar
Karl Heyes committed
449
    {
450 451
        free (ogg_info->title);
        ogg_info->title = value;
452
    }
453
    else if (strcmp (tag, "song") == 0)
454
    {
455 456
        free (ogg_info->title);
        ogg_info->title = value;
457
    }
458 459
    else
        free (value);
Karl Heyes's avatar
Karl Heyes committed
460 461 462
}


463 464 465 466 467 468 469
/* main backend routine when rebuilding streams. Here we loop until we either
 * have a refbuf to add onto the queue, or we want more data to process.
 */
static refbuf_t *process_vorbis (ogg_state_t *ogg_info, ogg_codec_t *codec)
{
    vorbis_codec_t *source_vorbis = codec->specific;
    refbuf_t *refbuf;
Karl Heyes's avatar
Karl Heyes committed
470

471
    while (1)
Karl Heyes's avatar
Karl Heyes committed
472
    {
473
        if (source_vorbis->get_buffer_page)
Karl Heyes's avatar
Karl Heyes committed
474
        {
475 476 477
            refbuf = source_vorbis->get_buffer_page (ogg_info, codec);
            if (refbuf)
                return refbuf;
Karl Heyes's avatar
Karl Heyes committed
478 479
        }

480 481 482 483 484
        if (source_vorbis->process_packet &&
                source_vorbis->process_packet (ogg_info, codec) > 0)
            continue;
        return NULL;
    }
Karl Heyes's avatar
Karl Heyes committed
485 486
}

487 488 489 490 491 492 493 494

/* no processing of pages, just wrap them up in a refbuf and pass
 * back for adding to the queue
 */
static refbuf_t *process_vorbis_passthru_page (ogg_state_t *ogg_info,
        ogg_codec_t *codec, ogg_page *page)
{
    return make_refbuf_with_page (page);
Karl Heyes's avatar
Karl Heyes committed
495 496 497
}


498 499 500 501 502 503 504 505 506
/* 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;
Karl Heyes's avatar
Karl Heyes committed
507

508 509 510 511 512 513
    if (ogg_stream_pagein (&codec->os, page) < 0)
    {
        ogg_info->error = 1;
        return NULL;
    }
    if (codec->headers == 3)
514 515 516 517 518 519
    {
        if (source_vorbis->initial_audio_page)
        {
            source_vorbis->initial_page_granulepos = ogg_page_granulepos (page);
            source_vorbis->initial_audio_page = 0;
        }
520
        return NULL;
521
    }
Karl Heyes's avatar
Karl Heyes committed
522

523
    while (codec->headers < 3)
Karl Heyes's avatar
Karl Heyes committed
524
    {
525
        /* now, lets extract the packets */
526
        ICECAST_LOG_DEBUG("processing incoming header packet (%d)", codec->headers);
527 528 529 530

        if (ogg_stream_packetout (&codec->os, &header) <= 0)
        {
            if (ogg_info->codecs->next)
531
                format_ogg_attach_header(ogg_info, page);
532 533 534 535 536
            return NULL;
        }

        /* change comments here if need be */
        if (vorbis_synthesis_headerin (&source_vorbis->vi, &source_vorbis->vc, &header) < 0)
Karl Heyes's avatar
Karl Heyes committed
537
        {
538
            ogg_info->error = 1;
539
            ICECAST_LOG_WARN("Problem parsing ogg vorbis header");
540
            return NULL;
Karl Heyes's avatar
Karl Heyes committed
541
        }
542
        header.granulepos = 0;
543
        source_vorbis->header[codec->headers] = copy_ogg_packet(&header);
544 545
        codec->headers++;
    }
546
    ICECAST_LOG_DEBUG("we have the header packets now");
547 548 549 550 551 552 553

    /* 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;
554
        source_vorbis->initial_audio_page = 1;
555 556 557 558 559 560
    }
    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;
Karl Heyes's avatar
Karl Heyes committed
561
    }
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577

    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;

578 579 580
    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);
581 582 583
    stats_event_args (ogg_info->mount, "ice-bitrate", "%ld", (long)source_vorbis->vi.bitrate_nominal/1000);

    return NULL;
Karl Heyes's avatar
Karl Heyes committed
584
}
Jack Moffitt's avatar
Jack Moffitt committed
585