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; }
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; }
// 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; }
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; }