PeerStreamer

#define MAX_PAGE_SIZE 65025

typedef struct {

    int64_t granule;

    int stream_index;

    uint8_t flags;

    uint8_t segments_count;

    uint8_t segments[255];

    uint8_t data[MAX_PAGE_SIZE];

    uint16_t size;

} OGGPage;

    unsigned page_count; ///< number of page buffered

    OGGPage page; ///< current page

typedef struct OGGPageList {

    OGGPage page;

    struct OGGPageList *next;

} OGGPageList;

typedef struct {

    OGGPageList *page_list;

} OGGContext;

static void ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)

    OGGStreamContext *oggstream = s->streams[page->stream_index]->priv_data;

    put_byte(s->pb, page->flags | extra_flags);

    put_le64(s->pb, page->granule);

    put_le32(s->pb, page->stream_index);

    put_byte(s->pb, page->segments_count);

    put_buffer(s->pb, page->segments, page->segments_count);

    put_buffer(s->pb, page->data, page->size);

    oggstream->page_count--;

}

static int64_t ogg_granule_to_timestamp(OGGStreamContext *oggstream, OGGPage *page)

{

    if (oggstream->kfgshift)

        return (page->granule>>oggstream->kfgshift) +

            (page->granule & ((1<<oggstream->kfgshift)-1));

    else

        return page->granule;

}

static int ogg_compare_granule(AVFormatContext *s, OGGPage *next, OGGPage *page)

{

    AVStream *st2 = s->streams[next->stream_index];

    AVStream *st  = s->streams[page->stream_index];

    int64_t next_granule, cur_granule;

    if (next->granule == -1 || page->granule == -1)

        return 0;

    next_granule = av_rescale_q(ogg_granule_to_timestamp(st2->priv_data, next),

                                st2->time_base, AV_TIME_BASE_Q);

    cur_granule  = av_rescale_q(ogg_granule_to_timestamp(st->priv_data, page),

                                st ->time_base, AV_TIME_BASE_Q);

    return next_granule > cur_granule;

}

static int ogg_reset_cur_page(OGGStreamContext *oggstream)

{

    oggstream->page.granule = -1;

    oggstream->page.flags = 0;

    oggstream->page.segments_count = 0;

    oggstream->page.size = 0;

    return 0;

}

static int ogg_buffer_page(AVFormatContext *s, OGGStreamContext *oggstream)

{

    OGGContext *ogg = s->priv_data;

    OGGPageList **p = &ogg->page_list;

    OGGPageList *l = av_mallocz(sizeof(*l));

    if (!l)

        return AVERROR(ENOMEM);

    l->page = oggstream->page;

    oggstream->page_count++;

    ogg_reset_cur_page(oggstream);

    while (*p) {

        if (ogg_compare_granule(s, &(*p)->page, &l->page))

            break;

        p = &(*p)->next;

    }

    l->next = *p;

    *p = l;

    return 0;

}

static int ogg_buffer_data(AVFormatContext *s, AVStream *st,

                           uint8_t *data, unsigned size, int64_t granule)

{

    OGGStreamContext *oggstream = st->priv_data;

    int total_segments = size / 255 + 1;

    uint8_t *p = data;

    int i, segments, len;

    for (i = 0; i < total_segments; ) {

        OGGPage *page = &oggstream->page;

        segments = FFMIN(total_segments - i, 255 - page->segments_count);

        if (i && !page->segments_count)

            page->flags |= 1; // continued packet

        memset(page->segments+page->segments_count, 255, segments - 1);

        page->segments_count += segments - 1;

        len = FFMIN(size, segments*255);

        page->segments[page->segments_count++] = len - (segments-1)*255;

        memcpy(page->data+page->size, p, len);

        p += len;

        size -= len;

        i += segments;

        page->size += len;

        if (i == total_segments)

            page->granule = granule;

        if (page->segments_count == 255) {

            ogg_buffer_page(s, oggstream);

        }

    }

    return 0;

        oggstream->page.stream_index = i;

    for (j = 0; j < s->nb_streams; j++) {

        OGGStreamContext *oggstream = s->streams[j]->priv_data;

        ogg_buffer_data(s, s->streams[j], oggstream->header[0],

                        oggstream->header_len[0], 0);

        oggstream->page.flags |= 2; // bos

        ogg_buffer_page(s, oggstream);

    }

    for (j = 0; j < s->nb_streams; j++) {

        AVStream *st = s->streams[j];

        OGGStreamContext *oggstream = st->priv_data;

        for (i = 1; i < 3; i++) {

            if (oggstream && oggstream->header_len[i])

                ogg_buffer_data(s, st, oggstream->header[i],

                                oggstream->header_len[i], 0);

        ogg_buffer_page(s, oggstream);

static void ogg_write_pages(AVFormatContext *s, int flush)

{

    OGGContext *ogg = s->priv_data;

    OGGPageList *next, *p;

    if (!ogg->page_list)

        return;

    for (p = ogg->page_list; p; ) {

        OGGStreamContext *oggstream =

            s->streams[p->page.stream_index]->priv_data;

        if (oggstream->page_count < 2 && !flush)

            break;

        ogg_write_page(s, &p->page,

                       flush && oggstream->page_count == 1 ? 4 : 0); // eos

        next = p->next;

        av_freep(&p);

        p = next;

    }

    ogg->page_list = p;

}

    int ret;

    ret = ogg_buffer_data(s, st, pkt->data, pkt->size, granule);

    if (ret < 0)

        return ret;

    ogg_write_pages(s, 0);

    return 0;

static int ogg_write_trailer(AVFormatContext *s)

    int i;

    /* flush current page */

    for (i = 0; i < s->nb_streams; i++)

        ogg_buffer_page(s, s->streams[i]->priv_data);

    ogg_write_pages(s, 1);

    sizeof(OGGContext),

364714f1087f3c1320b60f4209191d23 *./tests/data/lavf/lavf.ogg

13820 ./tests/data/lavf/lavf.ogg

ret:-1         st:-1 flags:0  ts:-1.000000

ret:-1         st: 0 flags:0  ts: 0.788345

ret:-1         st: 0 flags:1  ts:-0.317506

ret:-1         st: 0 flags:0  ts: 0.365011

ret:-1         st: 0 flags:1  ts:-0.740839

ret:-1         st: 0 flags:0  ts:-0.058322

ret:-1         st:-1 flags:1  ts: 0.624171

ret:-1         st: 0 flags:0  ts:-0.481655

ret:-1         st:-1 flags:1  ts: 0.200839

ret:-1         st: 0 flags:0  ts:-0.904989

ret:-1         st:-1 flags:1  ts:-0.222493

ret:-1         st:-1 flags:0  ts: 0.460008

ret:-1         st:-1 flags:1  ts:-0.645825