PeerStreamer

 */

static void put_ebml_void(AVIOContext *pb, uint64_t size)

{

    assert(size >= 2);

        put_ebml_num(pb, size-1, 0);

    else

        put_ebml_num(pb, size-9, 8);

        avio_w8(pb, 0);

}

    int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;

    put_ebml_id(pb, elementid);

    put_ebml_size_unknown(pb, bytes);

}

static void end_ebml_master(AVIOContext *pb, ebml_master master)

{

    if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)

        return;

    new_seekhead->segment_offset = segment_offset;

    if (numelements > 0) {

        // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID

        // and size, and 3 bytes to guarantee that an EBML void element

        // will fit afterwards

    int64_t currentpos;

    int i;

    if (seekhead->reserved_size > 0)

        if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0)

    end_ebml_master(pb, metaseek);

    if (seekhead->reserved_size > 0) {

        put_ebml_void(pb, remaining);

        avio_seek(pb, currentpos, SEEK_SET);

    int64_t currentpos;

    int i, j;

    cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);

    for (i = 0; i < cues->num_entries; i++) {

    ebml_master tracks;

    int i, j, ret;

    if (ret < 0) return ret;

    tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);

    if (!s->nb_chapters)

        return 0;

    if (ret < 0) return ret;

    chapters     = start_ebml_master(pb, MATROSKA_ID_CHAPTERS    , 0);

    int ret;

    if (!tags->pos) {

        if (ret < 0) return ret;

        *tags = start_ebml_master(s->pb, MATROSKA_ID_TAGS, 0);

    end_ebml_master(pb, ebml_header);

    mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0);

    // we write 2 seek heads - one at the end of the file to point to each

    // cluster, and one at the beginning to point to all other level one

    if (!mkv->main_seekhead)

        return AVERROR(ENOMEM);

    if (ret < 0) return ret;

    segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);

    // reserve space for the duration

    mkv->duration = 0;

    put_ebml_void(pb, 11);                  // assumes double-precision float to be written

    end_ebml_master(pb, segment_info);

        av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "

               "pts %" PRId64 ", duration %d\n",

        blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size));

        put_ebml_id(pb, MATROSKA_ID_BLOCK);

        put_ebml_num(pb, size+4, 0);

    av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "

           "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n",

    if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 &&

        (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1))

        ff_avc_parse_nal_units_buf(pkt->data, &data, &size);

    }

    if (!mkv->cluster_pos) {

        mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0);

        put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, FFMAX(0, ts));

        mkv->cluster_pts = FFMAX(0, ts);

    AVCodecContext *codec = s->streams[pkt->stream_index]->codec;

    int ret, keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);

    int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;

    // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or

    // after 4k and on a keyframe

         ||                      cluster_size > 5*1024*1024 || ts > mkv->cluster_pts + 5000

         || (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe && cluster_size > 4*1024))) {

        av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64

        end_ebml_master(pb, mkv->cluster);

        mkv->cluster_pos = 0;

        if (mkv->dyn_bc)

        // update the duration

        av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);

        avio_seek(pb, mkv->duration_offset, SEEK_SET);

        put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration);