PeerStreamer

    total_size = url_fsize(oc->pb);

    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too

    buf[0] = '\0';

    ti1 = 1e10;

        }

        /* finish if limit size exhausted */

            break;

        /* read a frame from it and output it in the fifo */

                        }else if(cur_stream->audio_stream >= 0 && cur_stream->audio_pkt.pos>=0){

                            pos= cur_stream->audio_pkt.pos;

                        }else

                        if (cur_stream->ic->bit_rate)

                            incr *= cur_stream->ic->bit_rate / 8.0;

                        else

                return AVERROR(EIO);

            pkt->stream_index = fourxm->video_stream_index;

            pkt->pts = fourxm->video_pts;

            memcpy(pkt->data, header, 8);

            ret = avio_read(s->pb, &pkt->data[8], size);

            get_meta(s, "comment"  , size);

            break;

        case MKTAG('S', 'S', 'N', 'D'):     /* Sampled sound chunk */

            offset = avio_rb32(pb);      /* Offset of sound data */

            avio_rb32(pb);               /* BlockSize... don't care */

            if (st->codec->block_align)    /* Assume COMM already parsed */

                goto got_sound;

            if (url_is_streamed(pb)) {

    int res, size;

    /* calculate size of remaining data */

    if (max_size <= 0)

        return AVERROR_EOF;

    /* FORM AIFF header */

    ffio_wfourcc(pb, "FORM");

    avio_wb32(pb, 0);                    /* file length */

    ffio_wfourcc(pb, aifc ? "AIFC" : "AIFF");

    avio_wb32(pb, aifc ? 24 : 18); /* size */

    avio_wb16(pb, enc->channels);  /* Number of channels */

    avio_wb32(pb, 0);              /* Number of frames */

    if (!enc->bits_per_coded_sample)

    /* Sound data chunk */

    ffio_wfourcc(pb, "SSND");

    avio_wb32(pb, 0);                    /* Sound samples data size */

    avio_wb32(pb, 0);                    /* Data offset */

    avio_wb32(pb, 0);                    /* Block-size (block align) */

    /* Chunks sizes must be even */

    int64_t file_size, end_size;

    if (file_size & 1) {

        avio_w8(pb, 0);

        end_size++;

    }

    pkt->stream_index = 0;

    pkt->data[0]=toc;

    pkt->duration= enc->codec_id == CODEC_ID_AMR_NB ? 160 : 320;

    read = avio_read(s->pb, pkt->data+1, size-1);

    }

    /* fetch record size */

    avio_seek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) +

              8 + anm->record * 2, SEEK_SET);

    record_size = avio_rl16(pb);

static void get_tag(AVFormatContext *s, const char *key, int type, int len)

{

    char *value;

    if ((unsigned)len >= (UINT_MAX - 1)/2)

        return;

        return AVERROR(EINVAL);

    }

    st = av_new_stream(s, 0);

    if (!st)

            st->need_parsing = AVSTREAM_PARSE_FULL;

        }

        /* We have to init the frame size at some point .... */

        if (size >= (pos2 + 8 - pos1 + 24)) {

            asf_st->ds_span = avio_r8(pb);

            asf_st->ds_packet_size = avio_rl16(pb);

                break;

        }

    } else if (type == AVMEDIA_TYPE_VIDEO &&

        avio_rl32(pb);

        avio_rl32(pb);

        avio_r8(pb);

        if(st->codec->codec_id == CODEC_ID_H264)

            st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;

    }

    avio_seek(pb, size - (pos2 - pos1 + 24), SEEK_CUR);

    return 0;

    avio_r8(pb);

    memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));

    for(;;) {

        ff_get_guid(pb, &g);

        gsize = avio_rl64(pb);

        av_dlog(s, "%08"PRIx64": ", gpos);

        print_guid(&g);

        av_dlog(s, "  size=0x%"PRIx64"\n", gsize);

        if (!ff_guidcmp(&g, &ff_asf_data_header)) {

            // if not streaming, gsize is not unlimited (how?), and there is enough space in the file..

            if (!(asf->hdr.flags & 0x01) && gsize >= 100) {

                asf->data_object_size = gsize - 24;

                }

            }

        }

        avio_seek(pb, gpos + gsize, SEEK_SET);

    }

    ff_get_guid(pb, &g);

    avio_r8(pb);

    if (url_feof(pb))

        return -1;

    asf->packet_size_left = 0;

    // if we do not know packet size, allow skipping up to 32 kB

    off= 32768;

    if (s->packet_size > 0)

    c=d=e=-1;

    while(off-- > 0){

        if (url_ferror(pb) == AVERROR(EAGAIN))

            return AVERROR(EAGAIN);

        if (!url_feof(pb))

    }

    if ((c & 0x8f) == 0x82) {

        if (d || e) {

    //the following checks prevent overflows and infinite loops

    if(!packet_length || packet_length >= (1U<<29)){

        return -1;

    }

    if(padsize >= packet_length){

        return -1;

    }

            || asf->packet_segments < 1) {

            //asf->packet_size_left <= asf->packet_padsize) {

            int ret = asf->packet_size_left + asf->packet_padsize;

            assert(ret>=0);

            /* fail safe */

            avio_seek(pb, ret, SEEK_CUR);

            if (asf->data_object_size != (uint64_t)-1 &&

                (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))

                return AVERROR_EOF; /* Do not exceed the size of the data object */

{

    ff_asf_guid g;

    ASFContext *asf = s->priv_data;

    int i;

    avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET);

    //    avio_seek(s->pb, pos, SEEK_SET);

    //    key_pos = pos;

    //     for(i=0;i<16;i++){

    //         if (av_read_frame(s, &pkt) < 0){

    //             av_log(s, AV_LOG_INFO, "seek failed\n");

    //             return -1;

{

    int64_t pos;

    put_guid(pb, g);

    avio_wl64(pb, 24);

    return pos;

{

    int64_t pos1;

    avio_seek(pb, pos + 16, SEEK_SET);

    avio_wl64(pb, pos1 - pos);

    avio_seek(pb, pos1, SEEK_SET);

    avio_w8(pb, 2); /* ??? */

    /* file header */

    hpos = put_header(pb, &ff_asf_file_header);

    put_guid(pb, &ff_asf_my_guid);

    avio_wl64(pb, file_size);

            put_guid(pb, &ff_asf_video_conceal_none);

        }

        avio_wl64(pb, 0); /* ??? */

        avio_wl32(pb, extra_size); /* wav header len */

        avio_wl32(pb, extra_size2); /* additional data len */

        avio_wl16(pb, n + 1); /* stream number */

            if (wavsize < 0)

                return -1;

            if (wavsize != extra_size) {

                avio_seek(pb, es_pos, SEEK_SET);

                avio_wl32(pb, wavsize); /* wav header len */

                avio_seek(pb, cur_pos, SEEK_SET);

    /* patch the header size fields */

    header_size = cur_pos - header_offset;

    if (asf->is_streamed) {

        header_size += 8 + 30 + 50;

    ASFContext *asf = s->priv_data;

    AVIOContext *pb = s->pb;

    int ppi_size, i;

    int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;

    if (asf->multi_payloads_present)

        avio_w8(pb, nb_payloads | ASF_PAYLOAD_FLAGS);

    return ppi_size;

}

        flush_packet(s);

    /* write index */

    if ((!asf->is_streamed) && (asf->nb_index_count != 0)) {

        asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->nb_index_count);

    }

        put_chunk(s, 0x4524, 0, 0); /* end of stream */

    } else {

        /* rewrite an updated header */

        avio_seek(s->pb, 0, SEEK_SET);

        asf_write_header1(s, file_size, data_size - asf->data_offset);

    }

    if (!url_is_streamed(s->pb)) {

        /* update file size */

        avio_seek(pb, 8, SEEK_SET);

        avio_wb32(pb, (uint32_t)(file_size - 24));

        avio_seek(pb, file_size, SEEK_SET);

    /* check RIFF header */

    avio_read(pb, header, 4);

    avi->riff_end = avio_rl32(pb);  /* RIFF chunk size */

    avio_read(pb, header+4, 4);

    for(i=0; avi_headers[i][0]; i++)

            if(url_feof(pb))

                return -1;

            if(avi->odml_depth > MAX_ODML_DEPTH){

                av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");

static void avi_read_info(AVFormatContext *s, uint64_t end)

{

        uint32_t tag  = avio_rl32(s->pb);

        uint32_t size = avio_rl32(s->pb);

        avi_read_tag(s, NULL, tag, size);

static void avi_read_nikon(AVFormatContext *s, uint64_t end)

{

        uint32_t tag  = avio_rl32(s->pb);

        uint32_t size = avio_rl32(s->pb);

        switch (tag) {

        case MKTAG('n', 'c', 't', 'g'): {  /* Nikon Tags */

                uint16_t tag  = avio_rl16(s->pb);

                uint16_t size = avio_rl16(s->pb);

                const char *name = NULL;

        switch(tag) {

        case MKTAG('L', 'I', 'S', 'T'):

            /* Ignored, except at start of video packets. */

            tag1 = avio_rl32(pb);

            print_tag("list", tag1, 0);

            if (tag1 == MKTAG('m', 'o', 'v', 'i')) {

                if(size) avi->movi_end = avi->movi_list + size + (size & 1);

                else     avi->movi_end = url_fsize(pb);

                av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end);

            if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {

                avio_seek(pb, size, SEEK_CUR);

            } else {

                if (cur_pos < list_end)

                    size = FFMIN(size, list_end - cur_pos);

                st = s->streams[stream_index];

            }

            break;

        case MKTAG('i', 'n', 'd', 'x'):

            if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){

                read_braindead_odml_indx(s, 0);

            }

            if(size > 1000000){

                av_log(s, AV_LOG_ERROR, "Something went wrong during header parsing, "

                                        "I will ignore it and try to continue anyway.\n");

                avi->movi_end  = url_fsize(pb);

                goto end_of_header;

            }

        if(size > ast->remaining)

            size= ast->remaining;

        err= av_get_packet(pb, pkt, size);

        if(err<0)

            return err;

    }

    memset(d, -1, sizeof(int)*8);

        int j;

        for(j=0; j<7; j++)

                ast->remaining= size;

                if(size || !ast->sample_size){

                    if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){

                        av_add_index_entry(st, pos, ast->frame_offset, size, 0, AVINDEX_KEYFRAME);

                    }

    int i;

    int64_t last_start=0;

    int64_t first_end= INT64_MAX;

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

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

    AVIContext *avi = s->priv_data;

    AVIOContext *pb = s->pb;

    uint32_t tag, size;

    int ret = -1;

    if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)

    int64_t file_size;

    AVCodecContext* stream;

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

        AVIStream *avist= s->streams[n]->priv_data;

        avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */

    else

        avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */

    avio_wl32(pb, nb_frames); /* nb frames, filled later */

    avio_wl32(pb, 0); /* initial frame */

    avio_wl32(pb, s->nb_streams); /* nb streams */

        av_set_pts_info(s->streams[i], 64, au_scale, au_byterate);

        avio_wl32(pb, 0); /* start */

        if (url_is_streamed(pb))

            avio_wl32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */

        else

         ix_tag[3] = '0' + i;

         /* Writing AVI OpenDML leaf index chunk */

         ffio_wfourcc(pb, ix_tag);     /* ix?? */

         avio_wl32(pb, avist->indexes.entry * 8 + 24);

                                      /* chunk size */

                          (ie->flags & 0x10 ? 0 : 0x80000000));

         }

         put_flush_packet(pb);

         /* Updating one entry in the AVI OpenDML master index */

         avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET);

    // Make sure to put an OpenDML chunk when the file size exceeds the limits

    if (!url_is_streamed(pb) &&

        avi_write_ix(s);

        ff_end_tag(pb, avi->movi_list);

        }

        idx->cluster[cl][id].flags = flags;

        idx->cluster[cl][id].len = size;

        idx->entry++;

    }

            ff_end_tag(pb, avi->movi_list);

            ff_end_tag(pb, avi->riff_start);

            avio_seek(pb, avi->odml_list - 8, SEEK_SET);

            ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */

            avio_seek(pb, 16, SEEK_CUR);

attribute_deprecated int url_fclose(AVIOContext *s);

attribute_deprecated int64_t url_fseek(AVIOContext *s, int64_t offset, int whence);

attribute_deprecated int url_fskip(AVIOContext *s, int64_t offset);

/**

 * @}

 */

 * ftell() equivalent for AVIOContext.

 * @return position or AVERROR.

 */

/**

 * Get the filesize.

    int64_t ret = avio_seek(s, offset, SEEK_CUR);

    return ret < 0 ? ret : 0;

}

int64_t url_ftell(AVIOContext *s)

{

    return avio_seek(s, 0, SEEK_CUR);

}

int64_t url_fsize(AVIOContext *s)

{

    AvsFormat *avs = s->priv_data;

    int ret, size;

    ret = voc_get_packet(s, pkt, avs->st_audio, avs->remaining_audio_size);

    avs->remaining_audio_size -= size;

    if (ret == AVERROR(EIO))

        return AVERROR(ENOMEM);

    // save the file position for the packet, include block type

    vidbuf_start[vidbuf_nbytes++] = block_type;

        int strt, skip;

        MOVAtom atom;

        ff_mov_read_esds(s, pb, atom);

        if (skip < 0 || !st->codec->extradata ||

            st->codec->codec_id != CODEC_ID_AAC) {

            av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n");

    int64_t pos = 0, ccount;

    int num_packets, i;

    num_packets = avio_rb64(pb);

    if (num_packets < 0 || INT32_MAX / sizeof(AVIndexEntry) < num_packets)

        st->duration += caf->frames_per_packet ? caf->frames_per_packet : ff_mp4_read_descr_len(pb);

    }

        av_log(s, AV_LOG_ERROR, "error reading packet table\n");

        return -1;

    }

        switch (tag) {

        case MKBETAG('d','a','t','a'):

            avio_seek(pb, 4, SEEK_CUR); /* edit count */

            caf->data_size  = size < 0 ? -1 : size - 4;

            if (caf->data_size > 0 && !url_is_streamed(pb))

                avio_seek(pb, caf->data_size, SEEK_CUR);

    /* don't read past end of data chunk */

    if (caf->data_size > 0) {

        if (left <= 0)

            return AVERROR(EIO);

    }

            return -1;

        }

        if (state == 0x003f0700 || state == 0xff3f0700)

            avio_seek(s->pb, -163, SEEK_CUR);

            state = avio_rb32(s->pb);

            break;

        uint32_t size, fsize;

        c->has_sound = 1;

        size = avio_rb32(pb);

        avio_seek(pb, 16, SEEK_CUR);

        fsize = avio_rl32(pb);

            return -1;

        ff_get_wav_header(pb, ast->codec, fsize);

        // find 'data' chunk

            tag = avio_rl32(pb);

            fsize = avio_rl32(pb);

            if(tag == MKTAG('d', 'a', 't', 'a')) break;

        if(ast->codec->block_align)

            c->bpc = ((c->bpc + ast->codec->block_align - 1) / ast->codec->block_align) * ast->codec->block_align;

        c->bytes_left = fsize;

        avio_seek(pb, c->vidpos, SEEK_SET);

    }

        st->codec->height >>= 1;

    }

    c->readvid = !c->has_sound;

    s->start_time = 0;

    s->duration = (int64_t)c->frames * AV_TIME_BASE * num / den;

    av_log(s, AV_LOG_DEBUG, "%d frame(s)\n",c->frames);

        if(ret != size)

            return AVERROR(EIO);

        c->bytes_left -= size;

        return 0;

    }

    avio_seek(s->pb, c->vidpos, SEEK_SET);

            if(pal_size) memcpy(pkt->data, pal, pal_size);

            memcpy(pkt->data + pal_size, buf, 4);

            c->frames--;

            c->readvid = 0;

            return 0;

        case MKTAG('C', 'M', 'A', 'P'):

            if(pal_size) memcpy(pkt->data, pal, pal_size);

            pkt->stream_index = 0;

            c->frames--;

            c->readvid = 0;

            return 0;

        default:

    int i;

    for (i=0; i<5 && (!ea->audio_codec || !ea->video_codec); i++) {

        int err = 0;

        blockid = avio_rl32(pb);

    len = ffm->packet_end - ffm->packet_ptr;

    if (size <= len)

        return 1;

    if (!ffm->write_index) {

        if (pos == ffm->file_size)

            return AVERROR_EOF;

        if (len > size)

            len = size;

        if (len == 0) {

                avio_seek(pb, ffm->packet_size, SEEK_SET);

    retry_read:

            id = avio_rb16(pb); /* PACKET_ID */

            if (ffm->first_packet || (frame_offset & 0x8000)) {

                if (!frame_offset) {

                    /* This packet has no frame headers in it */

                        avio_seek(pb, -ffm->packet_size * 2, SEEK_CUR);

                        goto retry_read;

                    }

    //int64_t orig_write_index = ffm->write_index;

    int64_t pos_min, pos_max;

    int64_t pts_start;

    pos_min = 0;

    }

    /* get until end of block reached */

        avio_r8(pb);

    /* init packet demux */

            return ret;

        av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",

        if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=

            FRAME_HEADER_SIZE)

            return -1;

            ffm->read_state = READ_HEADER;

            return -1;

        }

        if (ffm->header[1] & FLAG_KEY_FRAME)

            pkt->flags |= AV_PKT_FLAG_KEY;

    fill_size = ffm->packet_end - ffm->packet_ptr;

    memset(ffm->packet_ptr, 0, fill_size);

        av_abort();

    /* put header */

    }

    /* flush until end of block reached */

        avio_w8(pb, 0);

    put_flush_packet(pb);

    if (url_feof(s->pb))

        return AVERROR(EIO);

    pkt->size = av_get_packet(s->pb, pkt, st->codec->width * st->codec->height * 4);

    avio_seek(s->pb, st->codec->width * film->leading * 4, SEEK_CUR);

    if (pkt->size < 0)

    if (!url_is_streamed(pb)) {

        /* rewrite the STREAMINFO header block data */

        avio_seek(pb, 8, SEEK_SET);

        avio_write(pb, streaminfo, FLAC_STREAMINFO_SIZE);

        avio_seek(pb, file_size, SEEK_SET);

            }

            pkt->stream_index = flic->video_stream_index;

            pkt->pts = flic->frame_number++;

            memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE);

            ret = avio_read(pb, pkt->data + FLIC_PREAMBLE_SIZE,

                size - FLIC_PREAMBLE_SIZE);

            avio_seek(pb, 10, SEEK_CUR);

            pkt->stream_index = flic->audio_stream_index;

            ret = avio_read(pb, pkt->data, size);

            if (ret != size) {

        case AMF_DATA_TYPE_OBJECT: {

            unsigned int keylen;

                avio_seek(ioc, keylen, SEEK_CUR); //skip key string

                if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)

                    return -1; //if we couldn't skip, bomb out.

            break; //these take up no additional space

        case AMF_DATA_TYPE_MIXEDARRAY:

            avio_seek(ioc, 4, SEEK_CUR); //skip 32-bit max array index

                //this is the only case in which we would want a nested parse to not skip over the object

                if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)

                    return -1;

            unsigned int arraylen, i;

            arraylen = avio_rb32(ioc);

                if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)

                    return -1; //if we couldn't skip, bomb out.

            }

    AVStream *st = NULL;

 for(;;avio_seek(s->pb, 4, SEEK_CUR)){ /* pkt size is repeated at end. skip it */

    type = avio_r8(s->pb);

    size = avio_rb24(s->pb);

    dts = avio_rb24(s->pb);

    if(size == 0)

        continue;

    if (type == FLV_TAG_TYPE_AUDIO) {

        is_audio=1;

    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps

    if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){

        int size;

        const int64_t fsize= url_fsize(s->pb);

        avio_seek(s->pb, fsize-4, SEEK_SET);

        size= avio_rb32(s->pb);

    /* write meta_tag */

    avio_w8(pb, 18);         // tag type META

    avio_wb24(pb, 0);          // size of data part (sum of all parts below)

    avio_wb24(pb, 0);          // time stamp

    avio_wb32(pb, 0);          // reserved

    avio_wb32(pb, 5*!!video_enc + 5*!!audio_enc + 2); // +2 for duration and file size

    put_amf_string(pb, "duration");

    put_amf_double(pb, s->duration / AV_TIME_BASE); // fill in the guessed duration, it'll be corrected later if incorrect

    if(video_enc){

    }

    put_amf_string(pb, "filesize");

    put_amf_double(pb, 0); // delayed write

    put_amf_string(pb, "");

    avio_w8(pb, AMF_END_OF_OBJECT);

    /* write total size of tag */

    avio_seek(pb, metadata_size_pos, SEEK_SET);

    avio_wb24(pb, data_size);

    avio_seek(pb, data_size + 10 - 3, SEEK_CUR);

            avio_wb24(pb, 0); // ts

            avio_w8(pb, 0); // ts ext

            avio_wb24(pb, 0); // streamid

            if (enc->codec_id == CODEC_ID_AAC) {

                avio_w8(pb, get_audio_flags(enc));

                avio_w8(pb, 0); // AAC sequence header

                avio_wb24(pb, 0); // composition time

                ff_isom_write_avcc(pb, enc->extradata, enc->extradata_size);

            }

            avio_seek(pb, -data_size - 10, SEEK_CUR);

            avio_wb24(pb, data_size);

            avio_seek(pb, data_size + 10 - 3, SEEK_CUR);

        }

    }

    /* update informations */

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

    READ_ONE();

    if (tmp != 1)

        goto start;

    if (avio_seek(pb, -5, SEEK_CUR) < 0)

        goto out;

    if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {

    avio_r8(pb);

    cur_track = avio_r8(pb);

    cur_timestamp = avio_rb32(pb);

    if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {

        if (avio_seek(pb, last_pos, SEEK_SET) >= 0)

            goto start;

    if (avio_seek(pb, *pos, SEEK_SET) < 0)

        return AV_NOPTS_VALUE;

    res = gxf_resync_media(s, pos_limit - *pos, -1, -1);

    return res;

}

    int64_t curpos;

    int size;

    if (size % 4) {

        gxf_write_padding(pb, 4 - size % 4);

    }

    avio_seek(pb, pos + 6, SEEK_SET);

    avio_wb32(pb, size);

    avio_seek(pb, curpos, SEEK_SET);

{

    int64_t curpos;

    avio_seek(pb, pos, SEEK_SET);

    avio_wb16(pb, curpos - pos - 2);

    avio_seek(pb, curpos, SEEK_SET);

    avio_w8(pb, sc->media_type + 0x80);

    avio_w8(pb, index + 0xC0);

    avio_wb16(pb, 0); /* size */

    /* media file name */

    int len;

    const char *filename = strrchr(s->filename, '/');

    avio_wb16(pb, 0); /* size */

    /* name */

    int64_t pos;

    int i;

    avio_wb16(pb, 0); /* size */

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

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

{

    GXFContext *gxf = s->priv_data;

    AVIOContext *pb = s->pb;

    if (!rewrite) {

        if (!(gxf->map_offsets_nb % 30)) {

{

    GXFContext *gxf = s->priv_data;

    AVIOContext *pb = s->pb;

    int fields_per_flt = (gxf->nb_fields+1) / 1000 + 1;

    int flt_entries = gxf->nb_fields / fields_per_flt;

    int i = 0;

{

    AVIOContext *pb = s->pb;

    GXFContext *gxf = s->priv_data;

    int i;

    gxf->umf_track_offset = pos - gxf->umf_start_offset;

    avio_wl16(pb, gxf->timecode_track.media_info);

    avio_wl16(pb, 1);

}

static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st)

    int64_t pos;

    int i, j;

    gxf->umf_media_offset = pos - gxf->umf_start_offset;

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

        GXFStreamContext *sc;

        else

            sc = s->streams[i]->priv_data;

        avio_wl16(pb, 0); /* length */

        avio_wl16(pb, sc->media_info);

        avio_wl16(pb, 0); /* reserved */

            }

        }

        avio_seek(pb, startpos, SEEK_SET);

        avio_wl16(pb, curpos - startpos);

        avio_seek(pb, curpos, SEEK_SET);

    }

}

static int gxf_write_umf_packet(AVFormatContext *s)

{

    GXFContext *gxf = s->priv_data;

    AVIOContext *pb = s->pb;

    gxf_write_packet_header(pb, PKT_UMF);

    avio_w8(pb, 3); /* first and last (only) packet */

    avio_wb32(pb, gxf->umf_length); /* data length */

    gxf_write_umf_payload(s);

    gxf_write_umf_material_description(s);

    gxf->umf_track_size = gxf_write_umf_track_description(s);

    gxf->umf_media_size = gxf_write_umf_media_description(s);

    return updatePacketSize(pb, pos);

}

static int gxf_write_eos_packet(AVIOContext *pb)

{

    gxf_write_packet_header(pb, PKT_EOS);

    return updatePacketSize(pb, pos);

    ff_audio_interleave_close(s);

    gxf_write_eos_packet(pb);

    avio_seek(pb, 0, SEEK_SET);

    /* overwrite map, flt and umf packets with new values */

    gxf_write_map_packet(s, 1);

    GXFContext *gxf = s->priv_data;

    AVIOContext *pb = s->pb;

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

    int padding = 0;

    gxf_write_packet_header(pb, PKT_MEDIA);

    if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */

        if (len < 0)

            break;

        if (tflags & ID3v2_FLAG_DATALEN) {

            avio_rb32(s->pb);

    do {

        /* save the current offset in case there's nothing to read/skip */

        ret = avio_read(s->pb, buf, ID3v2_HEADER_SIZE);

        if (ret != ID3v2_HEADER_SIZE)

            break;

        case RoQ_QUAD_CODEBOOK:

            /* packet needs to contain both this codebook and next VQ chunk */

            codebook_size = chunk_size;

            avio_seek(pb, codebook_size, SEEK_CUR);

            if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=

                roq->audio_frame_count += (chunk_size / roq->audio_channels);

            }

            ret = avio_read(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,

                chunk_size);

            if (ret != chunk_size)

        const char *metadata_tag = NULL;

        chunk_id = avio_rl32(pb);

        data_size = avio_rb32(pb);

        switch(chunk_id) {

        case ID_VHDR:

            break;

        case ID_BODY:

            iff->body_size = data_size;

            break;

                return res;

            }

        }

    }

    avio_seek(pb, iff->body_pos, SEEK_SET);

    if (av_new_packet(pkt, size) < 0)

        return AVERROR(ENOMEM);

    pkt->stream_index = 0;

    ret = avio_read(s->pb, pkt->data, size);

    if (ret < 0) {

            debug_ipmovie("audio frame\n");

            /* log position and move on for now */

            s->audio_chunk_size = opcode_size;

            avio_seek(pb, opcode_size, SEEK_CUR);

            break;

            debug_ipmovie("set decoding map\n");

            /* log position and move on for now */

            s->decode_map_chunk_size = opcode_size;

            avio_seek(pb, opcode_size, SEEK_CUR);

            break;

            debug_ipmovie("set video data\n");

            /* log position and move on for now */

            s->video_chunk_size = opcode_size;

            avio_seek(pb, opcode_size, SEEK_CUR);

            break;

    }

    /* make a note of where the stream is sitting */

    /* dispatch the first of any pending packets */

    if ((chunk_type == CHUNK_VIDEO) || (chunk_type == CHUNK_AUDIO_ONLY))

    ipmovie->decode_map_chunk_offset = 0;

    /* on the first read, this will position the stream at the first chunk */

    /* process the first chunk which should be CHUNK_INIT_VIDEO */

    if (process_ipmovie_chunk(ipmovie, pb, &pkt) != CHUNK_INIT_VIDEO)

    get_token(pb, token, sizeof(token)); //Version ID

    get_token(pb, token, sizeof(token)); //Size

    st = av_new_stream(s, 0);

    if (!st)

        return AVERROR(EIO);

    pkt->stream_index = 0;

    if(s->streams[0]->codec->channels > 0)

        pkt->pts /= s->streams[0]->codec->channels*2;

    return 0;

    if (pd.flags & NUT_FLAG_KEY) pkt->flags |= AV_PKT_FLAG_KEY;

    pkt->pts = pd.pts;

    pkt->stream_index = pd.stream;

    ret = nut_read_frame(priv->nut, &pd.len, pkt->data);

static int ebml_level_end(MatroskaDemuxContext *matroska)

{

    AVIOContext *pb = matroska->ctx->pb;

    if (matroska->num_levels > 0) {

        MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];

    if (!(total = avio_r8(pb))) {

        /* we might encounter EOS here */

        if (!url_feof(pb)) {

            av_log(matroska->ctx, AV_LOG_ERROR,

                   "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",

                   pos, pos);

    /* get the length of the EBML number */

    read = 8 - ff_log2_tab[total];