自学教程：C++ url_fskip函数代码示例

int CEASpliterFilter::process_video_header_vp6(){		EaDemuxContext *ea = (EaDemuxContext *)m_pea;	url_fskip(pb, 16);	ea->time_base.den = get_le32(pb);	ea->time_base.num = get_le32(pb);	ea->video_codec = CODEC_ID_VP6;	return 1;}

static int process_video_header_mdec(AVFormatContext *s){    EaDemuxContext *ea = s->priv_data;    ByteIOContext *pb = s->pb;    url_fskip(pb, 4);    ea->width  = get_le16(pb);    ea->height = get_le16(pb);    ea->time_base = (AVRational){1,15};    ea->video_codec = CODEC_ID_MDEC;    return 1;}

static int avi_write_trailer(AVFormatContext *s){    AVIContext *avi = s->priv_data;    ByteIOContext *pb = s->pb;    int res = 0;    int i, j, n, nb_frames;    int64_t file_size;    if (!url_is_streamed(pb)){        if (avi->riff_id == 1) {            ff_end_tag(pb, avi->movi_list);            res = avi_write_idx1(s);            ff_end_tag(pb, avi->riff_start);        } else {            avi_write_ix(s);            ff_end_tag(pb, avi->movi_list);            ff_end_tag(pb, avi->riff_start);            file_size = url_ftell(pb);            url_fseek(pb, avi->odml_list - 8, SEEK_SET);            put_tag(pb, "LIST"); /* Making this AVI OpenDML one */            url_fskip(pb, 16);            for (n=nb_frames=0;n<s->nb_streams;n++) {                AVCodecContext *stream = s->streams[n]->codec;                AVIStream *avist= s->streams[n]->priv_data;                if (stream->codec_type == AVMEDIA_TYPE_VIDEO) {                    if (nb_frames < avist->packet_count)                        nb_frames = avist->packet_count;                } else {                    if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3) {                        nb_frames += avist->packet_count;                    }                }            }            put_le32(pb, nb_frames);            url_fseek(pb, file_size, SEEK_SET);            avi_write_counters(s, avi->riff_id);        }    }    put_flush_packet(pb);    for (i=0; i<s->nb_streams; i++) {         AVIStream *avist= s->streams[i]->priv_data;         for (j=0; j<avist->indexes.ents_allocated/AVI_INDEX_CLUSTER_SIZE; j++)              av_free(avist->indexes.cluster[j]);         av_freep(&avist->indexes.cluster);         avist->indexes.ents_allocated = avist->indexes.entry = 0;    }    return res;}

/* * Process EA file header * Returns 1 if the EA file is valid and successfully opened, 0 otherwise */static int process_ea_header(AVFormatContext *s) {    uint32_t blockid, size = 0;    EaDemuxContext *ea = s->priv_data;    ByteIOContext *pb = &s->pb;    int i;    for (i=0; i<5 && (!ea->audio_codec || !ea->video_codec); i++) {        unsigned int startpos = url_ftell(pb);        int err = 0;        blockid = get_le32(pb);        size = get_le32(pb);        if (i == 0)            ea->big_endian = size > 0x000FFFFF;        if (ea->big_endian)            size = bswap_32(size);        switch (blockid) {            case ISNh_TAG:                if (get_le32(pb) != EACS_TAG) {                    av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid/n");                    return 0;                }                err = process_audio_header_eacs(s);                break;            case SCHl_TAG :                blockid = get_le32(pb);                if (blockid == GSTR_TAG) {                    url_fskip(pb, 4);                } else if (blockid != PT00_TAG) {                    av_log (s, AV_LOG_ERROR, "unknown SCHl headerid/n");                    return 0;                }                err = process_audio_header_elements(s);                break;            case MVhd_TAG :                err = process_video_header_vp6(s);                break;        }        if (err < 0) {            av_log(s, AV_LOG_ERROR, "error parsing header: %i/n", err);            return err;        }        url_fseek(pb, startpos + size, SEEK_SET);    }    url_fseek(pb, 0, SEEK_SET);    return 1;}

// this function is a small avi parser to get the video track's fourcc as// fast as possible, so we can decide whether we can handle the necessary // image description extensions for the format in ValidateDataRef() quicklyOSType get_avi_strf_fourcc(ByteIOContext *pb){	OSType tag, subtag;	unsigned int size;		if (get_be32(pb) != 'RIFF')		return 0;		// file size	get_le32(pb);		if (get_be32(pb) != 'AVI ')		return 0;		while (!url_feof(pb)) {		tag = get_be32(pb);		size = get_le32(pb);				if (tag == 'LIST') {			subtag = get_be32(pb);						// only lists we care about: hdrl & strl, so skip the rest			if (subtag != 'hdrl' && subtag != 'strl')				url_fskip(pb, size - 4 + (size & 1));					} else if (tag == 'strf') {			// 16-byte offset to the fourcc			url_fskip(pb, 16);			return get_be32(pb);		} else if (tag == 'strh'){			// 4-byte offset to the fourcc			OSType tag1 = get_be32(pb);			if(tag1 == 'iavs' || tag1 == 'ivas')				return get_be32(pb);			else				url_fskip(pb, size + (size & 1) - 4);		} else			url_fskip(pb, size + (size & 1));	}	return 0;}

static int process_video_header_vp6(AVFormatContext *s){    EaDemuxContext *ea = s->priv_data;    ByteIOContext *pb = s->pb;    url_fskip(pb, 16);    ea->time_base.den = get_le32(pb);    ea->time_base.num = get_le32(pb);    ea->video_codec = CODEC_ID_VP6;    return 1;}

static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt){    ByteIOContext *pb = ctx->pb;    uint16_t keyframe;    uint32_t size, timestamp;    url_fskip(pb, 1); /* one byte has been read ahead */    url_fskip(pb, 2);    url_fskip(pb, 2);    keyframe = get_le16(pb);    size = get_le32(pb);    url_fskip(pb, 4);    url_fskip(pb, 4);    timestamp = get_le32(pb);    if(!size || av_get_packet(pb, pkt, size) != size)        return -1;    url_fskip(pb, 1); /* Read ahead one byte of struct size like read_header */    pkt->pts = timestamp;    pkt->dts = timestamp;    pkt->stream_index = 0;    /* Some aMsn generated videos (or was it Mercury Messenger?) don't set     * this bit and rely on the codec to get keyframe information */    if(keyframe&1)        pkt->flags |= PKT_FLAG_KEY;    return HEADER_SIZE + size;}

static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap){    voc_dec_context_t *voc = s->priv_data;    ByteIOContext *pb = s->pb;    int header_size;    AVStream *st;    url_fskip(pb, 20);    header_size = get_le16(pb) - 22;    if (header_size != 4) {        av_log(s, AV_LOG_ERROR, "unknown header size: %d/n", header_size);        return AVERROR(ENOSYS);    }    url_fskip(pb, header_size);    st = av_new_stream(s, 0);    if (!st)        return AVERROR(ENOMEM);    st->codec->codec_type = CODEC_TYPE_AUDIO;    voc->remaining_size = 0;    return 0;}

static int read_packet(AVFormatContext *s,                       AVPacket *pkt){    AnmDemuxContext *anm = s->priv_data;    ByteIOContext *pb = s->pb;    Page *p;    int tmp, record_size;    if (url_feof(s->pb))        return AVERROR(EIO);    if (anm->page < 0)        return 0;repeat:    p = &anm->pt[anm->page];    /* parse page header */    if (anm->record < 0) {        url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16), SEEK_SET);        url_fskip(pb, 8 + 2*p->nb_records);        anm->record = 0;    }    /* if we have fetched all records in this page, then find the       next page and repeat */    if (anm->record >= p->nb_records) {        anm->page = find_record(anm, p->base_record + p->nb_records);        if (anm->page < 0)            return anm->page;        anm->record = -1;        goto repeat;    }    /* fetch record size */    tmp = url_ftell(pb);    url_fseek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16) +              8 + anm->record * 2, SEEK_SET);    record_size = get_le16(pb);    url_fseek(pb, tmp, SEEK_SET);    /* fetch record */    pkt->size = av_get_packet(s->pb, pkt, record_size);    if (pkt->size < 0)        return pkt->size;    if (p->base_record + anm->record == 0)        pkt->flags |= PKT_FLAG_KEY;    anm->record++;    return 0;}

static int w64_read_header(AVFormatContext *s, AVFormatParameters *ap){    int64_t size;    ByteIOContext *pb  = s->pb;    WAVContext    *wav = s->priv_data;    AVStream *st;    uint8_t guid[16];    get_buffer(pb, guid, 16);    if (memcmp(guid, guid_riff, 16))        return -1;    if (get_le64(pb) < 16 + 8 + 16 + 8 + 16 + 8) /* riff + wave + fmt + sizes */        return -1;    get_buffer(pb, guid, 16);    if (memcmp(guid, guid_wave, 16)) {        av_log(s, AV_LOG_ERROR, "could not find wave guid/n");        return -1;    }    size = find_guid(pb, guid_fmt);    if (size < 0) {        av_log(s, AV_LOG_ERROR, "could not find fmt guid/n");        return -1;    }    st = av_new_stream(s, 0);    if (!st)        return AVERROR(ENOMEM);    /* subtract chunk header size - normal wav file doesn't count it */    ff_get_wav_header(pb, st->codec, size - 24);    url_fskip(pb, FFALIGN(size, INT64_C(8)) - size);    st->need_parsing = AVSTREAM_PARSE_FULL;    av_set_pts_info(st, 64, 1, st->codec->sample_rate);    size = find_guid(pb, guid_data);    if (size < 0) {        av_log(s, AV_LOG_ERROR, "could not find data guid/n");        return -1;    }    wav->data_end = url_ftell(pb) + size - 24;    wav->w64      = 1;    return 0;}

static int process_video_header_mdec(AVFormatContext *s){    EaDemuxContext *ea = s->priv_data;    ByteIOContext *pb = s->pb;    url_fskip(pb, 4);    ea->width  = get_le16(pb);    ea->height = get_le16(pb);#ifndef _MSC_VER    ea->time_base = (AVRational){1,15};#else	ea->time_base = av_create_rational(1,15);#endif    ea->video_codec = CODEC_ID_MDEC;    return 1;}

static void ape_tag_read_field(AVFormatContext *s){    ByteIOContext *pb = s->pb;    uint8_t key[1024], value[1024];    uint32_t size;    int i, l;    size = get_le32(pb);  /* field size */    url_fskip(pb, 4);     /* skip field flags */    for (i=0; pb->buf_ptr[i]!='0' && pb->buf_ptr[i]>=0x20 && pb->buf_ptr[i]<=0x7E; i++);    l = FFMIN(i,    sizeof(key) -1);    get_buffer(pb, key,  l);    key[l]  = 0;    url_fskip(pb, 1 + i-l);    l = FFMIN(size, sizeof(value)-1);    get_buffer(pb, value, l);    value[l] = 0;    url_fskip(pb, size-l);    if (l < size)        av_log(s, AV_LOG_WARNING, "Too long '%s' tag was truncated./n", key);    av_metadata_set(&s->metadata, key, value);}

static int avi_write_trailer(AVFormatContext *s){    AVIContext *avi = s->priv_data;    ByteIOContext *pb = &s->pb;    int res = 0;    int i, j, n, nb_frames;    offset_t file_size;    if (avi->riff_id == 1) {        end_tag(pb, avi->movi_list);        res = avi_write_idx1(s);	end_tag(pb, avi->riff_start);    } else {        avi_write_ix(s);        end_tag(pb, avi->movi_list);	end_tag(pb, avi->riff_start);        file_size = url_ftell(pb);	url_fseek(pb, avi->odml_list - 8, SEEK_SET);	put_tag(pb, "LIST"); /* Making this AVI OpenDML one */	url_fskip(pb, 16);        for (n=nb_frames=0;n<s->nb_streams;n++) {             AVCodecContext *stream = &s->streams[n]->codec;             if (stream->codec_type == CODEC_TYPE_VIDEO) {                 if (nb_frames < stream->frame_number)                     nb_frames = stream->frame_number;             } else {                 if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3) {                     nb_frames += stream->frame_number;                }            }        }	put_le32(pb, nb_frames);	url_fseek(pb, file_size, SEEK_SET);    }    put_flush_packet(pb);    for (i=0; i<MAX_STREAMS; i++) {	 for (j=0; j<avi->indexes[i].ents_allocated/AVI_INDEX_CLUSTER_SIZE; j++)              av_free(avi->indexes[i].cluster[j]);	 av_free(avi->indexes[i].cluster);	 avi->indexes[i].cluster = NULL;	 avi->indexes[i].ents_allocated = avi->indexes[i].entry = 0;    }        return res;}

/* Metadata string read */static void get_meta(AVFormatContext *s, const char *key, int size){    uint8_t str[1024];    int res = get_buffer(s->pb, str, FFMIN(sizeof(str)-1, size));    if (res < 0)        return;    str[res] = 0;    if (size & 1)        size++;    size -= res;    if (size)        url_fskip(s->pb, size);    av_metadata_set(&s->metadata, key, str);}

static int siff_parse_soun(AVFormatContext *s, SIFFContext *c, ByteIOContext *pb){    if (get_le32(pb) != TAG_SHDR){        av_log(s, AV_LOG_ERROR, "Header chunk is missing/n");        return -1;    }    if(get_be32(pb) != 8){        av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect/n");        return -1;    }    url_fskip(pb, 4); //unknown value    c->rate = get_le16(pb);    c->bits = get_le16(pb);    c->block_align = c->rate * (c->bits >> 3);    return create_audio_stream(s, c);}

static int read_packet(AVFormatContext *s,                       AVPacket *pkt){    FilmstripDemuxContext *film = s->priv_data;    AVStream *st = s->streams[0];    if (url_feof(s->pb))        return AVERROR(EIO);    pkt->dts = url_ftell(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);    url_fskip(s->pb, st->codec->width * film->leading * 4);    if (pkt->size < 0)        return pkt->size;    pkt->flags |= AV_PKT_FLAG_KEY;    return 0;}

/** Find chunk with w64 GUID by skipping over other chunks * @return the size of the found chunk */static int64_t find_guid(ByteIOContext *pb, const uint8_t guid1[16]){    uint8_t guid[16];    int64_t size;    while (!url_feof(pb)) {        get_buffer(pb, guid, 16);        size = get_le64(pb);        if (size <= 24)            return -1;        if (!memcmp(guid, guid1, 16))            return size;        url_fskip(pb, FFALIGN(size, INT64_C(8)) - 24);    }    return -1;}

static int flv_read_header(AVFormatContext *s,                           AVFormatParameters *ap){    int offset, flags;    AVStream *st;        s->ctx_flags |= AVFMTCTX_NOHEADER; //ok we have a header but theres no fps, codec type, sample_rate, ...    url_fskip(&s->pb, 4);    flags = get_byte(&s->pb);    offset = get_be32(&s->pb);    url_fseek(&s->pb, offset, SEEK_SET);    return 0;}

/* Metadata string read */static void get_meta(AVFormatContext *s, const char *key, int size){    uint8_t *str = av_malloc(size+1);    int res;    if (!str) {        url_fskip(s->pb, size);        return;    }    res = get_buffer(s->pb, str, size);    if (res < 0)        return;    str[res] = 0;    av_metadata_set2(&s->metadata, key, str, AV_METADATA_DONT_STRDUP_VAL);}

static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt){    MTVDemuxContext *mtv = s->priv_data;    ByteIOContext *pb = s->pb;    int ret;#ifndef WORDS_BIGENDIAN    int i;#endif    ret = 0;    if(mtv->audio_subsegments >= mtv->audio_packet_count)    {        url_fskip(pb, MTV_AUDIO_PADDING_SIZE);        ret = av_get_packet(pb, pkt, MTV_ASUBCHUNK_DATA_SIZE);        if(ret != MTV_ASUBCHUNK_DATA_SIZE)            return AVERROR(EIO);        mtv->audio_packet_count++;        pkt->stream_index = AUDIO_SID;    }else    {        ret = av_get_packet(pb, pkt, mtv->img_segment_size);        if(ret != mtv->img_segment_size)            return AVERROR(EIO);#ifndef WORDS_BIGENDIAN        /* pkt->data is GGGRRRR BBBBBGGG         * and we need RRRRRGGG GGGBBBBB         * for PIX_FMT_RGB565 so here we         * just swap bytes as they come         */        for(i=0;i<mtv->img_segment_size/2;i++)            *((uint16_t *)pkt->data+i) = bswap_16(*((uint16_t *)pkt->data+i));#endif        mtv->audio_packet_count = 1;        pkt->stream_index = VIDEO_SID;    }    return ret;}

static void r3d_read_reos(AVFormatContext *s){    R3DContext *r3d = s->priv_data;    int tmp;    r3d->rdvo_offset = get_be32(s->pb);    get_be32(s->pb); // rdvs offset    get_be32(s->pb); // rdao offset    get_be32(s->pb); // rdas offset    tmp = get_be32(s->pb);    dprintf(s, "num video chunks %d/n", tmp);    tmp = get_be32(s->pb);    dprintf(s, "num audio chunks %d/n", tmp);    url_fskip(s->pb, 6*4);}

/* Metadata string read */static void get_meta(ByteIOContext *pb, char * str, int strsize, int size){    int res;    if (size > strsize-1)        res = get_buffer(pb, (uint8_t*)str, strsize-1);    else        res = get_buffer(pb, (uint8_t*)str, size);    if (res < 0)        return;    str[res] = 0;    if (size & 1)        size++;    size -= res;    if (size)        url_fskip(pb, size);}

static int vc1t_read_header(AVFormatContext *s,                           AVFormatParameters *ap){    ByteIOContext *pb = s->pb;    AVStream *st;    int frames;    uint32_t fps;    frames = get_le24(pb);    if(get_byte(pb) != 0xC5 || get_le32(pb) != 4)        return -1;    /* init video codec */    st = av_new_stream(s, 0);    if (!st)        return -1;    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;    st->codec->codec_id = CODEC_ID_WMV3;    st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);    st->codec->extradata_size = VC1_EXTRADATA_SIZE;    get_buffer(pb, st->codec->extradata, VC1_EXTRADATA_SIZE);    st->codec->height = get_le32(pb);    st->codec->width = get_le32(pb);    if(get_le32(pb) != 0xC)        return -1;    url_fskip(pb, 8);    fps = get_le32(pb);    if(fps == 0xFFFFFFFF)        av_set_pts_info(st, 32, 1, 1000);    else{        if (!fps) {            av_log(s, AV_LOG_ERROR, "Zero FPS specified, defaulting to 1 FPS/n");            fps = 1;        }        av_set_pts_info(st, 24, 1, fps);        st->duration = frames;    }    return 0;}

static int tmv_read_packet(AVFormatContext *s, AVPacket *pkt){    TMVContext *tmv   = s->priv_data;    ByteIOContext *pb = s->pb;    int ret, pkt_size = tmv->stream_index ?                        tmv->audio_chunk_size : tmv->video_chunk_size;    if (url_feof(pb))        return AVERROR_EOF;    ret = av_get_packet(pb, pkt, pkt_size);    if (tmv->stream_index)        url_fskip(pb, tmv->padding);    pkt->stream_index  = tmv->stream_index;    tmv->stream_index ^= 1;    pkt->flags        |= AV_PKT_FLAG_KEY;    return ret;}

static int read_header(AVFormatContext *s,                       AVFormatParameters *ap){    FilmstripDemuxContext *film = s->priv_data;    ByteIOContext *pb = s->pb;    AVStream *st;    if (url_is_streamed(s->pb))        return AVERROR(EIO);    url_fseek(pb, url_fsize(pb) - 36, SEEK_SET);    if (get_be32(pb) != RAND_TAG) {        av_log(s, AV_LOG_ERROR, "magic number not found");        return AVERROR_INVALIDDATA;    }    st = av_new_stream(s, 0);    if (!st)        return AVERROR(ENOMEM);    st->nb_frames = get_be32(pb);    if (get_be16(pb) != 0) {        av_log_ask_for_sample(s, "unsupported packing method/n");        return AVERROR_INVALIDDATA;    }    url_fskip(pb, 2);    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;    st->codec->codec_id   = CODEC_ID_RAWVIDEO;    st->codec->pix_fmt    = PIX_FMT_RGBA;    st->codec->codec_tag  = 0; /* no fourcc */    st->codec->width      = get_be16(pb);    st->codec->height     = get_be16(pb);    film->leading         = get_be16(pb);    av_set_pts_info(st, 64, 1, get_be16(pb));    url_fseek(pb, 0, SEEK_SET);    return 0;}

static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) {    ByteIOContext *pb = s->pb;    int ret;    unsigned int frame_type, packet_size, padding, frame_size;    get_be16(pb);                       /* channel number */    frame_type  = get_be16(pb);    packet_size = get_be32(pb);    padding     = -packet_size & 511;    frame_size  = packet_size - 8;    if (frame_type > LMLM4_MPEG1L2 || frame_type == LMLM4_INVALID) {        av_log(s, AV_LOG_ERROR, "invalid or unsupported frame_type/n");        return AVERROR(EIO);    }    if (packet_size > LMLM4_MAX_PACKET_SIZE) {        av_log(s, AV_LOG_ERROR, "packet size exceeds maximum/n");        return AVERROR(EIO);    }    if ((ret = av_get_packet(pb, pkt, frame_size)) <= 0)        return AVERROR(EIO);    url_fskip(pb, padding);    switch (frame_type) {    case LMLM4_I_FRAME:        pkt->flags = AV_PKT_FLAG_KEY;    case LMLM4_P_FRAME:    case LMLM4_B_FRAME:        pkt->stream_index = 0;        break;    case LMLM4_MPEG1L2:        pkt->stream_index = 1;        break;    }    return ret;}

static int txd_read_packet(AVFormatContext *s, AVPacket *pkt) {    ByteIOContext *pb = s->pb;    unsigned int id, chunk_size, marker;    int ret;next_chunk:    id         = get_le32(pb);    chunk_size = get_le32(pb);    marker     = get_le32(pb);    if (url_feof(s->pb))        return AVERROR_EOF;    if (marker != TXD_MARKER && marker != TXD_MARKER2) {        av_log(s, AV_LOG_ERROR, "marker does not match/n");        return AVERROR_INVALIDDATA;    }    switch (id) {        case TXD_INFO:            if (chunk_size > 100)                break;        case TXD_EXTRA:            url_fskip(s->pb, chunk_size);        case TXD_FILE:        case TXD_TEXTURE:            goto next_chunk;        default:            av_log(s, AV_LOG_ERROR, "unknown chunk id %i/n", id);            return AVERROR_INVALIDDATA;    }    ret = av_get_packet(s->pb, pkt, chunk_size);    if (ret < 0)        return ret;    pkt->stream_index = 0;    return 0;}

static int vc1t_read_header(AVFormatContext *s,                           AVFormatParameters *ap){    ByteIOContext *pb = s->pb;    AVStream *st;    int fps, frames;    frames = get_le24(pb);    if(get_byte(pb) != 0xC5 || get_le32(pb) != 4)        return -1;    /* init video codec */    st = av_new_stream(s, 0);    if (!st)        return -1;    st->codec->codec_type = CODEC_TYPE_VIDEO;    st->codec->codec_id = CODEC_ID_WMV3;    st->codec->extradata = av_malloc(VC1_EXTRADATA_SIZE);    st->codec->extradata_size = VC1_EXTRADATA_SIZE;    get_buffer(pb, st->codec->extradata, VC1_EXTRADATA_SIZE);    st->codec->height = get_le32(pb);    st->codec->width = get_le32(pb);    if(get_le32(pb) != 0xC)        return -1;    url_fskip(pb, 8);    fps = get_le32(pb);    if(fps == -1)        av_set_pts_info(st, 32, 1, 1000);    else{        av_set_pts_info(st, 24, 1, fps);        st->duration = frames;    }    return 0;}

static int avs_read_header(AVFormatContext * s, AVFormatParameters * ap){    avs_format_t *avs = s->priv_data;    s->ctx_flags |= AVFMTCTX_NOHEADER;    url_fskip(&s->pb, 4);    avs->width = get_le16(&s->pb);    avs->height = get_le16(&s->pb);    avs->bits_per_sample = get_le16(&s->pb);    avs->fps = get_le16(&s->pb);    avs->nb_frames = get_le32(&s->pb);    avs->remaining_frame_size = 0;    avs->remaining_audio_size = 0;    avs->st_video = avs->st_audio = NULL;    if (avs->width != 318 || avs->height != 198)        av_log(s, AV_LOG_ERROR, "This avs pretend to be %dx%d "               "when the avs format is supposed to be 318x198 only./n",               avs->width, avs->height);    return 0;}