Esempio n. 1
0
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;
}
Esempio n. 2
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);
    ea->time_base = (AVRational){1,15};
    ea->video_codec = CODEC_ID_MDEC;
    return 1;
}
Esempio n. 3
0
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;
}
Esempio n. 4
0
/*
 * 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;
}
Esempio n. 5
0
int CEASpliterFilter::process_video_header_mdec()
{
	EaDemuxContext *ea = (EaDemuxContext *)m_pea;
	url_fskip(pb, 4);
	ea->width  = get_le16(pb);
	ea->height = get_le16(pb);
	ea->time_base.num = 1;
	ea->time_base.den = 15;
	ea->video_codec = CODEC_ID_MDEC;
	return 1;
}
Esempio n. 6
0
// 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() quickly
OSType 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;
}
Esempio n. 7
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;
}
Esempio n. 8
0
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;
}
Esempio n. 9
0
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;
}
Esempio n. 10
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;
}
Esempio n. 11
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;
}
Esempio n. 12
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);
}
Esempio n. 14
0
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;
}
Esempio n. 15
0
/* 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);
}
Esempio n. 16
0
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);
}
Esempio n. 17
0
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;
}
Esempio n. 18
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;
}
Esempio n. 19
0
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;
}
Esempio n. 20
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);
}
Esempio n. 21
0
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;
}
Esempio n. 22
0
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);
}
Esempio n. 23
0
/* 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);
}
Esempio n. 24
0
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;
}
Esempio n. 25
0
File: tmv.c Progetto: AWilco/xbmc
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;
}
Esempio n. 26
0
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;
}
Esempio n. 27
0
File: lmlm4.c Progetto: AndyA/ffmbc
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;
}
Esempio n. 28
0
File: txd.c Progetto: AndyA/ffmbc
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;
}
Esempio n. 29
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;
}
Esempio n. 30
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;
}