PeerStreamer

        }

        ret = av_read_frame(ic, pkt);

        if (ret < 0) {

                eof=1;

            if (url_ferror(ic->pb))

                break;

            return ret;

        fourcc_tag = AV_RL32(&header[0]);

        size = AV_RL32(&header[4]);

            return AVERROR(EIO);

        switch (fourcc_tag) {

{

    int size;

        return AVERROR(EIO);

    *tag = avio_rl32(pb);

    AVCodecContext *enc = s->streams[0]->codec;

    int read, size = 0, toc, mode;

    {

        return AVERROR(EIO);

    }

    Page *p;

    int tmp, record_size;

        return AVERROR(EIO);

    if (anm->page < 0)

    APEContext *ape = s->priv_data;

    uint32_t extra_size = 8;

        return AVERROR(EIO);

    if (ape->currentframe > ape->totalframes)

        return AVERROR(EIO);

    if (var)

        free_segment_list(var);

    c->finished = 0;

        read_chomp_line(in, line, sizeof(line));

        if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {

            struct variant_info info = {{0}};

        if (var->pb && !var->pkt.data) {

            ret = av_read_frame(var->ctx, &var->pkt);

            if (ret < 0) {

                    return ret;

                reset_packet(&var->pkt);

            }

    free_segment_list(s);

    s->finished = 0;

        read_chomp_line(in, line, sizeof(line));

        if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {

            struct variant_info info = {{0}};

            continue;

        } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {

            asf_read_marker(s, gsize);

            return -1;

        } else {

            if (!s->keylen) {

    avio_rl64(pb);

    avio_r8(pb);

    avio_r8(pb);

        return -1;

    asf->data_offset = avio_tell(pb);

    asf->packet_size_left = 0;

         */

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

            return AVERROR(EAGAIN);

            av_log(s, AV_LOG_ERROR, "ff asf bad header %x  at:%"PRId64"\n", c, avio_tell(pb));

    }

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

        if (d || e) {

                av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");

            return -1;

        }

    ASFStream *asf_st = 0;

    for (;;) {

        int ret;

            return AVERROR_EOF;

        if (asf->packet_size_left < FRAME_HEADER_SIZE

            || asf->packet_segments < 1) {

       skip them until the simple index object is reached */

    while (ff_guidcmp(&g, &index_guid)) {

        int64_t gsize= avio_rl64(s->pb);

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

            return;

        }

    header_remaining= INT_MAX;

    dst[0] = &st->codec->extradata;

    dst[1] = &ass->event_buffer;

        uint8_t line[MAX_LINESIZE];

        len = ff_get_line(pb, line, sizeof(line));

#ifdef DEBUG_SEEK

            av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len);

#endif

                return -1;

            if(last_pos == pos || pos == base - 8)

            avio_rl32(pb);       /* size */

            duration = avio_rl32(pb);

                return -1;

            pos = avio_tell(pb);

    codec_type = -1;

    frame_period = 0;

    for(;;) {

            goto fail;

        tag = avio_rl32(pb);

        size = avio_rl32(pb);

    }

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

        int j;

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

#if defined(DEBUG_SEEK)

        av_log(s, AV_LOG_DEBUG, "%d cum_len=%"PRId64"\n", len, ast->cum_len);

#endif

            return -1;

        if(last_pos == pos)

    printf("movi_end=0x%"PRIx64"\n", avi->movi_end);

#endif

    for(;;) {

            break;

        tag = avio_rl32(pb);

        size = avio_rl32(pb);

/**

 * @}

 */

#endif

AVIOContext *avio_alloc_context(

 */

int64_t avio_size(AVIOContext *s);

int url_ferror(AVIOContext *s);

int av_url_read_fpause(AVIOContext *h, int pause);

    return size;

}

int url_feof(AVIOContext *s)

{

    if(!s)

        return 0;

    return s->eof_reached;

}

int url_ferror(AVIOContext *s)

{

    }

    if (size1 == size) {

        if (url_ferror(s)) return url_ferror(s);

    }

    return size1 - size;

}

    s->buf_ptr += len;

    if (!len) {

        if (url_ferror(s)) return url_ferror(s);

    }

    return len;

}

    char *q;

    c = avio_r8(s);

        return NULL;

    q = buf;

    for(;;) {

            break;

        if ((q - buf) < buf_size - 1)

            *q++ = c;

    int audio_length;

    int ret_value;

        return AVERROR(EIO);

    block_type = avio_r8(pb);

    BFIContext *bfi = s->priv_data;

    AVIOContext *pb = s->pb;

    int ret, audio_offset, video_offset, chunk_size, audio_size = 0;

        return AVERROR(EIO);

    }

    if (!bfi->avflag) {

        uint32_t state = 0;

        while(state != MKTAG('S','A','V','I')){

                return AVERROR(EIO);

            state = 256*state + avio_r8(pb);

        }

    /* parse each chunk */

    found_data = 0;

        /* stop at data chunk if seeking is not supported or

           data chunk size is unknown */

        tag  = avio_rb32(pb);

        size = avio_rb64(pb);

            break;

        switch (tag) {

    int res, pkt_size = 0, pkt_frames = 0;

    int64_t left      = CAF_MAX_PKT_SIZE;

        return AVERROR(EIO);

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

static int daud_packet(AVFormatContext *s, AVPacket *pkt) {

    AVIOContext *pb = s->pb;

    int ret, size;

        return AVERROR(EIO);

    size = avio_rb16(pb);

    avio_rb16(pb); // unknown

    hdr->video_frame_size = avio_rl32(pb);

    hdr->audio_frame_size = avio_rl32(pb);

        return AVERROR(EIO);

    if (avio_rl32(pb) != 0xAA55AA55)

    state = avio_rb32(s->pb);

    while ((state & 0xffffff7f) != 0x1f07003f) {

            av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");

            return -1;

        }

            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;

        return 0;

    }

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

        avio_read(s->pb, buf, 4);

        switch(AV_RL32(buf)){

        case MKTAG('N', 'U', 'L', 'L'):

    ea->sample_rate = -1;

    ea->num_channels = 1;

        int inSubheader;

        uint8_t byte;

        byte = avio_r8(pb);

        case 0xFD:

            av_log (s, AV_LOG_DEBUG, "entered audio subheader\n");

            inSubheader = 1;

                uint8_t subbyte;

                subbyte = avio_r8(pb);

{

    av_log(s, AV_LOG_ERROR, "resyncing\n");

    while (state != PACKET_ID) {

            av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");

            return -1;

        }

                buf[i++] = c;

        }

        buf[i] = 0;

}

static AVChapter *read_chapter(AVFormatContext *s)

    AVMetadata **m = &s->metadata;

    uint8_t line[1024];

        get_line(s->pb, line, sizeof(line));

        if (!memcmp(line, ID_STREAM, strlen(ID_STREAM))) {

    FilmstripDemuxContext *film = s->priv_data;

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

        return AVERROR(EIO);

    pkt->dts = avio_tell(s->pb) / (st->codec->width * (st->codec->height + film->leading) * 4);

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

    }

    /* process metadata blocks */

        avio_read(s->pb, header, 4);

        ff_flac_parse_block_header(header, &metadata_last, &metadata_type,

                                   &metadata_size);

    dts = avio_rb24(s->pb);

    dts |= avio_r8(s->pb) << 24;

//    av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);

        return AVERROR_EOF;

    avio_seek(s->pb, 3, SEEK_CUR); /* stream id, always 0 */

    flags = 0;

#define READ_ONE() \

    { \

            goto out; \

        tmp = tmp << 8 | avio_r8(pb); \

    }

    AVIOContext *pb = s->pb;

    GXFPktType pkt_type;

    int pkt_len;

        AVStream *st;

        int track_type, track_id, ret;

        int field_nr, field_info, skip = 0;

        int stream_index;

        if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {

                av_log(s, AV_LOG_ERROR, "sync lost\n");

            return -1;

        }

    unsigned char r, g, b;

    unsigned char palette_buffer[768];

        return AVERROR(EIO);

    if (idcin->next_chunk_is_video) {

    while (!packet_read) {

            return AVERROR(EIO);

        /* get the next chunk preamble */

    // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content

    st->codec->codec_tag = avio_rl32(pb);

        uint64_t orig_pos;

        int res;

        const char *metadata_tag = NULL;

            infer_size(&codec->width, &codec->height, size[0]);

    } else {

        f[0] = s1->pb;

            return AVERROR(EIO);

        size[0]= 4096;

    }

        return chunk_type;

    /* read the next chunk, wherever the file happens to be pointing */

        return CHUNK_EOF;

    if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) !=

        CHUNK_PREAMBLE_SIZE)

    while ((chunk_size > 0) && (chunk_type != CHUNK_BAD)) {

        /* read the next chunk, wherever the file happens to be pointing */

            chunk_type = CHUNK_EOF;

            break;

        }

    while (memcmp(signature_buffer, signature, sizeof(signature))) {

        memmove(signature_buffer, signature_buffer + 1, sizeof(signature_buffer) - 1);

        signature_buffer[sizeof(signature_buffer) - 1] = avio_r8(pb);

            return AVERROR_EOF;

    }

    /* initialize private context members */

        return ret < 0 ? ret : AVERROR_EOF;

    while (memcmp(buf, LXF_IDENT, LXF_IDENT_LENGTH)) {

            return AVERROR_EOF;

        memmove(buf, &buf[1], LXF_IDENT_LENGTH-1);

     * use it safely here to catch EOS. */

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

        /* we might encounter EOS here */

            int64_t pos = avio_tell(pb);

            av_log(matroska->ctx, AV_LOG_ERROR,

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

    AVStream *st;

    int ret, size;

        return AVERROR(EIO);

    st = s->streams[0];

    if (atom.size < 0)

        atom.size = INT64_MAX;

        int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;

        a.size = atom.size;

        a.type=0;

        mov->found_mdat = 0;

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

            mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||

            return AVERROR_EOF;

        av_dlog(s, "read fragments, offset 0x%llx\n", avio_tell(s->pb));

        goto retry;

        return -1;

    }

        pos = avio_tell(pb);

        mpc8_get_chunk_header(pb, &tag, &size);

        if(tag == TAG_STREAMHDR)

    int tag;

    int64_t pos, size;

        pos = avio_tell(s->pb);

        mpc8_get_chunk_header(s->pb, &tag, &size);

        if (size < 0)

    state = *header_state;

    n = *size_ptr;

    while (n > 0) {

            break;

        v = avio_r8(pb);

        n--;

        last_sync = avio_tell(s->pb);

    //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, avio_tell(s->pb));

    if (startcode < 0){

            return AVERROR_EOF;

        //FIXME we should remember header_state

        return AVERROR(EAGAIN);

    for(i = 0;i < MAX_RESYNC_SIZE; i++) {

        c = avio_r8(pb);

            return -1;

        if (c == 0x47) {

            avio_seek(pb, -1, SEEK_CUR);

    /* Some files start with "connected\r\n\r\n".

     * So skip until we find the first byte of struct size */

        av_log(ctx, AV_LOG_ERROR, "Could not find valid start.");

        return -1;

    }

static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)

{

    int i, b;

        b = avio_r8(pb);

        if (b == key[0])

            i = 0;

{

    KLVPacket klv;

        if (klv_read_packet(&klv, s->pb) < 0)

            return -1;

        PRINT_KEY(s, "read packet", klv.key);

    }

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

    mxf->fc = s;

        const MXFMetadataReadTableEntry *metadata;

        if (klv_read_packet(&klv, s->pb) < 0)

    uint8_t *startmarker_ptr, *end, *search_end, marker;

    MXGContext *mxg = s->priv_data;

        if (mxg->cache_size <= OVERREAD_SIZE) {

            /* update internal buffer */

            ret = mxg_update_cache(s, DEFAULT_PACKET_SIZE + OVERREAD_SIZE);

    uint32_t state=-1;

    while (state != NC_VIDEO_FLAG) {

            return AVERROR(EIO);

        state = (state<<8) + avio_r8(s->pb);

    }

    //nsv->state = NSV_UNSYNC;

    for (i = 0; i < NSV_MAX_RESYNC; i++) {

            av_dlog(s, "NSV EOF\n");

            nsv->state = NSV_UNSYNC;

            return -1;

    table_entries_used = avio_rl32(pb);

    av_dlog(s, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n",

            strings_size, table_entries, table_entries_used);

        return -1;

    av_dlog(s, "NSV got header; filepos %"PRId64"\n", avio_tell(pb));

        }

        av_free(strings);

    }

        return -1;

    av_dlog(s, "NSV got infos; filepos %"PRId64"\n", avio_tell(pb));

    avio_seek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */

        return -1;

    nsv->state = NSV_HAS_READ_NSVF;

    return 0;

        return 0; //-1; /* hey! eat what you've in your plate first! */

null_chunk_retry:

        return -1;

    for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++)

        vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming braindead */

    }

        return -1;

    if (!vsize && !asize) {

        nsv->state = NSV_UNSYNC;

    if(pos >= 0)

        avio_seek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we currently are

        state= (state<<8) | avio_r8(bc);

        if((state>>56) != 'N')

            continue;

            pos-=8;

        }else{

            frame_code = avio_r8(bc);

                return -1;

            if(frame_code == 'N'){

                tmp= frame_code;

    nuv_frametype frametype;

    if (!vst && !myth)

        return 1; // no codec data needed

        int size, subtype;

        frametype = avio_r8(pb);

        switch (frametype) {

    uint8_t hdr[HDRSIZE];

    nuv_frametype frametype;

    int ret, size;

        int copyhdrsize = ctx->rtjpg_video ? HDRSIZE : 0;

        uint64_t pos = avio_tell(pb);

        ret = avio_read(pb, hdr, HDRSIZE);

            break;

        c = avio_r8(bc);

            return -1;

        sync[sp++ & 3] = c;

    }while (i++ < MAX_PAGE_SIZE);

            break;

        }

            return AVERROR(EIO);

    }

}

    QCPContext    *c  = s->priv_data;

    unsigned int  chunk_size, tag;

        if (c->data_size) {

            int pkt_size, ret, mode = avio_r8(pb);

    avio_rb32(pb); /* number of headers */

    for(;;) {

            return -1;

        tag = avio_rl32(pb);

        tag_size = avio_rb32(pb);

    AVStream *st;

    uint32_t state=0xFFFFFFFF;

        int len, num, i;

        *pos= avio_tell(pb) - 3;

        if(rm->remaining_len > 0){

                    st = s->streams[i];

            }

                return AVERROR(EIO);

            res = ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt,

    int palchange = 0;

    int pos;

        return AVERROR_EOF;

    /* if we demuxed all streams, pass another frame */

{

    int ret;

        return AVERROR(EIO);

    ret= av_get_packet(s->pb, pkt, MAX_SIZE);

    pkt->stream_index = 0;

{

    int ret, size;

        return AVERROR_EOF;

    size = SOX_SAMPLES*s->streams[0]->codec->block_align;

    while (state != (AV_BSWAP16C(SYNCWORD1) << 16 | AV_BSWAP16C(SYNCWORD2))) {

        state = (state << 8) | avio_r8(pb);

            return AVERROR_EOF;

    }

    do {

        ptr2 = ptr;

        ptr += ff_get_line(s->pb, ptr, sizeof(buffer)+buffer-ptr);

    if (buffer[0] && !(res = av_new_packet(pkt, ptr-buffer))) {

        memcpy(pkt->data, buffer, pkt->size);

{

    int tag, len;

        return -1;

    tag = avio_rl16(pb);

    int ret, pkt_size = tmv->stream_index ?

                        tmv->audio_chunk_size : tmv->video_chunk_size;

        return AVERROR_EOF;

    ret = av_get_packet(pb, pkt, pkt_size);

    TtyDemuxContext *s = avctx->priv_data;

    int n;

        return AVERROR_EOF;

    n = s->chars_per_frame;

    chunk_size = avio_rl32(pb);

    marker     = avio_rl32(pb);

        return AVERROR_EOF;

    if (marker != TXD_MARKER && marker != TXD_MARKER2) {

        av_log(s, AV_LOG_ERROR, "marker does not match\n");

    int keyframe = 0;

    uint32_t pts;

        return AVERROR(EIO);

    frame_size = avio_rl24(pb);

    int64_t size;

    for (;;) {

            return -1;

        size = next_tag(pb, &tag);

        if (tag == tag1)

    av_set_pts_info(st, 64, 1, st->codec->sample_rate);

    for (;;) {

            return -1;

        size = next_tag(pb, &tag);

        if (tag == MKTAG('d', 'a', 't', 'a')){

    uint8_t guid[16];

    int64_t size;

        avio_read(pb, guid, 16);

        size = avio_rl64(pb);

        if (size <= 24)

        fourcc_tag = avio_rl32(pb);

        /* chunk sizes are 16-bit aligned */

        size = (avio_rb32(pb) + 1) & (~1);

            return AVERROR(EIO);

    } while (fourcc_tag != BRCH_TAG);

        fourcc_tag = avio_rl32(pb);

        /* chunk sizes are 16-bit aligned */

        size = (avio_rb32(pb) + 1) & (~1);

            return AVERROR(EIO);

        switch (fourcc_tag) {

    if (wf->error || url_ferror(pb))

        return -1;

        return 0;

    buf_size = FFMIN(buf_size, wf->length - wf->position);

{

    ff_asf_guid guid;

    int length, type;

        char key[1024];

        ff_get_guid(pb, &guid);

        type   = avio_rl32(pb);

{

    WtvContext *wtv = s->priv_data;

    AVIOContext *pb = wtv->pb;

        ff_asf_guid g;

        int len, sid, consumed;

            while(1) {

                uint64_t timestamp = avio_rl64(pb);

                uint64_t frame_nb  = avio_rl64(pb);

                    break;

                ff_add_index_entry(&wtv->index_entries, &wtv->nb_index_entries, &wtv->index_entries_allocated_size,

                                   0, timestamp, frame_nb, 0, AVINDEX_KEYFRAME);

                    while (1) {

                        uint64_t frame_nb = avio_rl64(pb);

                        uint64_t position = avio_rl64(pb);

                            break;

                        for (i = wtv->nb_index_entries - 1; i >= 0; i--) {

                            AVIndexEntry *e = wtv->index_entries + i;

    int ret;

    int size, ver, off;

        return AVERROR(EIO);

    if(wc->block_parsed){

        if(wv_read_block_header(s, s->pb, 0) < 0)