/** this function assumes that the demuxer has already seeked to the start * of the INDX chunk, and will bail out if not. */ static int rm_read_index(AVFormatContext *s) { AVIOContext *pb = s->pb; unsigned int size, n_pkts, str_id, next_off, n, pos, pts; AVStream *st; do { if (avio_rl32(pb) != MKTAG('I','N','D','X')) return -1; size = avio_rb32(pb); if (size < 20) return -1; avio_skip(pb, 2); n_pkts = avio_rb32(pb); str_id = avio_rb16(pb); next_off = avio_rb32(pb); for (n = 0; n < s->nb_streams; n++) if (s->streams[n]->id == str_id) { st = s->streams[n]; break; } if (n == s->nb_streams) { av_log(s, AV_LOG_ERROR, "Invalid stream index %d for index at pos %"PRId64"\n", str_id, avio_tell(pb)); goto skip; } else if ((avio_size(pb) - avio_tell(pb)) / 14 < n_pkts) { av_log(s, AV_LOG_ERROR, "Nr. of packets in packet index for stream index %d " "exceeds filesize (%"PRId64" at %"PRId64" = %"PRId64")\n", str_id, avio_size(pb), avio_tell(pb), (avio_size(pb) - avio_tell(pb)) / 14); goto skip; } for (n = 0; n < n_pkts; n++) { avio_skip(pb, 2); pts = avio_rb32(pb); pos = avio_rb32(pb); avio_skip(pb, 4); /* packet no. */ av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME); } skip: if (next_off && avio_tell(pb) < next_off && avio_seek(pb, next_off, SEEK_SET) < 0) { av_log(s, AV_LOG_ERROR, "Non-linear index detected, not supported\n"); return -1; } } while (next_off); return 0; }
static int stream_ffmpeg_open(stream_wrapper_t * wrapper, char *stream_name) { int ret = 0; const char *filename = stream_name; AVIOContext *ctx = NULL; int64_t size; int dummy; int flags = AVIO_FLAG_READ; stream_ctrl_t *info = &wrapper->info; av_register_all(); avformat_network_init(); if (!strncmp(filename, prefix, strlen(prefix))) { filename += strlen(prefix); } dummy = strncmp(filename, "rtsp:", 5); if (!dummy) { dt_info(TAG, "[ffmpeg] rtsp use ffmpeg inside streamer.\n"); return -1; } dt_info(TAG, "[ffmpeg] Opening %s\n", filename); ret = avio_open(&ctx, filename, flags); if (ret < 0) { dt_info(TAG, "[ffmpeg] Opening %s failed. ret:%d\n", filename, ret); return -1; } wrapper->stream_priv = ctx; size = dummy ? 0 : avio_size(ctx); info->stream_size = size; info->seek_support = ctx->seekable; return DTERROR_NONE; }
void set_filesize(AVFormatContext *ic) { char value[30] = "0"; int64_t size = ic->pb ? avio_size(ic->pb) : -1; sprintf(value, "%"PRId64, size); av_dict_set(&ic->metadata, FILESIZE, value, 0); }
static TF_Buffer *read_graph(const char *model_filename) { TF_Buffer *graph_buf; unsigned char *graph_data = NULL; AVIOContext *model_file_context; long size, bytes_read; if (avio_open(&model_file_context, model_filename, AVIO_FLAG_READ) < 0){ return NULL; } size = avio_size(model_file_context); graph_data = av_malloc(size); if (!graph_data){ avio_closep(&model_file_context); return NULL; } bytes_read = avio_read(model_file_context, graph_data, size); avio_closep(&model_file_context); if (bytes_read != size){ av_freep(&graph_data); return NULL; } graph_buf = TF_NewBuffer(); graph_buf->data = (void *)graph_data; graph_buf->length = size; graph_buf->data_deallocator = free_buffer; return graph_buf; }
static int control(stream_t *s, int cmd, void *arg) { AVIOContext *ctx = s->priv; int64_t size, ts; double pts; switch(cmd) { case STREAM_CTRL_GET_SIZE: size = avio_size(s->priv); if(size >= 0) { *(uint64_t *)arg = size; return 1; } break; case STREAM_CTRL_SEEK_TO_TIME: pts = *(double *)arg; ts = pts * AV_TIME_BASE; if (!ctx->read_seek) break; ts = ctx->read_seek(s->priv, -1, ts, 0); if (ts >= 0) return 1; break; } return STREAM_UNSUPPORTED; }
static int stream_ffmpeg_open (stream_wrapper_t * wrapper,char *stream_name) { const char *filename = stream_name; AVIOContext *ctx = NULL; int64_t size; int dummy; int flags = AVIO_FLAG_READ; stream_ctrl_t *info = &wrapper->info; av_register_all(); avformat_network_init(); if (!strncmp(filename, prefix, strlen(prefix))) filename += strlen(prefix); dummy = !strncmp(filename, "rtsp:", 5); dt_info(TAG, "[ffmpeg] Opening %s\n", filename); if (!dummy && avio_open(&ctx, filename, flags) < 0) return -1; wrapper->stream_priv = ctx; size = dummy ? 0 : avio_size(ctx); info->stream_size = size; info->seek_support = ctx->seekable; return DTERROR_NONE; }
static void show_format(AVFormatContext *fmt_ctx) { char val_str[128]; int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1; probe_object_header("format"); probe_str("filename", fmt_ctx->filename); probe_int("nb_streams", fmt_ctx->nb_streams); probe_str("format_name", fmt_ctx->iformat->name); probe_str("format_long_name", fmt_ctx->iformat->long_name); probe_str("start_time", time_value_string(val_str, sizeof(val_str), fmt_ctx->start_time, &AV_TIME_BASE_Q)); probe_str("duration", time_value_string(val_str, sizeof(val_str), fmt_ctx->duration, &AV_TIME_BASE_Q)); probe_str("size", size >= 0 ? value_string(val_str, sizeof(val_str), size, unit_byte_str) : "unknown"); probe_str("bit_rate", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate, unit_bit_per_second_str)); probe_dict(fmt_ctx->metadata, "tags"); probe_object_footer("format"); }
static int yop_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) { YopDecContext *yop = s->priv_data; int64_t frame_pos, pos_min, pos_max; int frame_count; if (!stream_index) return -1; pos_min = s->data_offset; pos_max = avio_size(s->pb) - yop->frame_size; frame_count = (pos_max - pos_min) / yop->frame_size; timestamp = FFMAX(0, FFMIN(frame_count, timestamp)); frame_pos = timestamp * yop->frame_size + pos_min; if (avio_seek(s->pb, frame_pos, SEEK_SET) < 0) return -1; av_free_packet(&yop->video_packet); yop->odd_frame = timestamp & 1; return 0; }
int64_t FileHandle::Size() { int64_t size = avio_size(avio); if (size < 0) throw FFMS_Exception(error_source, FFMS_ERROR_FILE_READ, "Failed to get file size for '" + filename +"'"); return size; }
static void show_format(AVFormatContext *fmt_ctx) { AVDictionaryEntry *tag = NULL; char val_str[128]; int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1; print_format_entry(NULL, "[FORMAT]"); print_format_entry("filename", fmt_ctx->filename); snprintf(val_str, sizeof(val_str) - 1, "%d", fmt_ctx->nb_streams); print_format_entry("nb_streams", val_str); print_format_entry("format_name", fmt_ctx->iformat->name); print_format_entry("format_long_name", fmt_ctx->iformat->long_name); print_format_entry("start_time", time_value_string(val_str, sizeof(val_str), fmt_ctx->start_time, &AV_TIME_BASE_Q)); print_format_entry("duration", time_value_string(val_str, sizeof(val_str), fmt_ctx->duration, &AV_TIME_BASE_Q)); print_format_entry("size", size >= 0 ? value_string(val_str, sizeof(val_str), size, unit_byte_str) : "unknown"); print_format_entry("bit_rate", value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate, unit_bit_per_second_str)); while ((tag = av_dict_get(fmt_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) { snprintf(val_str, sizeof(val_str) - 1, "TAG:%s", tag->key); print_format_entry(val_str, tag->value); } print_format_entry(NULL, "[/FORMAT]"); }
static int open_f(stream_t *stream, int mode, void *opts, int *file_format) { int flags = 0; const char *filename; AVIOContext *avio = NULL; int res = STREAM_ERROR; int64_t size; int dummy; if (mode == STREAM_READ) flags = URL_RDONLY; else if (mode == STREAM_WRITE) flags = URL_WRONLY; else { mp_msg(MSGT_OPEN, MSGL_ERR, "[ffmpeg] Unknown open mode %d\n", mode); res = STREAM_UNSUPPORTED; goto out; } if (stream->url) filename = stream->url; else { mp_msg(MSGT_OPEN, MSGL_ERR, "[ffmpeg] No URL\n"); goto out; } if (!strncmp(filename, prefix, strlen(prefix))) filename += strlen(prefix); dummy = !strncmp(filename, "rtsp:", 5); mp_msg(MSGT_OPEN, MSGL_V, "[ffmpeg] Opening %s\n", filename); if (!dummy && avio_open(&avio, filename, flags) < 0) goto out; char *rtmp[] = {"rtmp:", "rtmpt:", "rtmpe:", "rtmpte:", "rtmps:"}; for (int i = 0; i < FF_ARRAY_ELEMS(rtmp); i++) if (!strncmp(filename, rtmp[i], strlen(rtmp[i]))) { *file_format = DEMUXER_TYPE_LAVF; stream->lavf_type = "flv"; } stream->priv = avio; size = dummy ? 0 : avio_size(avio); if (size >= 0) stream->end_pos = size; stream->type = STREAMTYPE_FILE; stream->seek = seek; if (dummy || !avio->seekable) { stream->type = STREAMTYPE_STREAM; stream->seek = NULL; } if (!dummy) { stream->fill_buffer = fill_buffer; stream->write_buffer = write_buffer; stream->control = control; stream->close = close_f; } res = STREAM_OK; out: return res; }
static int import_pem(URLContext *h, char *path, CFArrayRef *array) { AVIOContext *s = NULL; CFDataRef data = NULL; int64_t ret = 0; char *buf = NULL; SecExternalFormat format = kSecFormatPEMSequence; SecExternalFormat type = kSecItemTypeAggregate; CFStringRef pathStr = CFStringCreateWithCString(NULL, path, 0x08000100); if (!pathStr) { ret = AVERROR(ENOMEM); goto end; } if ((ret = ffio_open_whitelist(&s, path, AVIO_FLAG_READ, &h->interrupt_callback, NULL, h->protocol_whitelist, h->protocol_blacklist)) < 0) goto end; if ((ret = avio_size(s)) < 0) goto end; if (ret == 0) { ret = AVERROR_INVALIDDATA; goto end; } if (!(buf = av_malloc(ret))) { ret = AVERROR(ENOMEM); goto end; } if ((ret = avio_read(s, buf, ret)) < 0) goto end; data = CFDataCreate(kCFAllocatorDefault, buf, ret); if (SecItemImport(data, pathStr, &format, &type, 0, NULL, NULL, array) != noErr || !array) { ret = AVERROR_UNKNOWN; goto end; } if (CFArrayGetCount(*array) == 0) { ret = AVERROR_INVALIDDATA; goto end; } end: av_free(buf); if (pathStr) CFRelease(pathStr); if (data) CFRelease(data); if (s) avio_close(s); return ret; }
//get total display time int CCPlayer::GetTotalDurationBySecond(int64_t* pTotalDuration) { if(m_pAVFormatCtx != NULL) { *pTotalDuration = avio_size(m_pAVFormatCtx->pb) / (m_pAVFormatCtx->bit_rate / 8); return 0; } return -1; }
static off_t input_avio_get_length (input_plugin_t *this_gen) { avio_input_plugin_t *this = (avio_input_plugin_t *) this_gen; if (this->pb) { return avio_size(this->pb); } return -1; }
static int read_header_gme(AVFormatContext *s) { AVStream *st; AVIOContext *pb = s->pb; GMEContext *gme = s->priv_data; int64_t sz = avio_size(pb); char *buf; char dummy; if (sz < 0) { av_log(s, AV_LOG_WARNING, "Could not determine file size\n"); sz = gme->max_size; } else if (gme->max_size && sz > gme->max_size) { sz = gme->max_size; } buf = av_malloc(sz); if (!buf) return AVERROR(ENOMEM); sz = avio_read(pb, buf, sz); // Data left means our buffer (the max_size option) is too small if (avio_read(pb, &dummy, 1) == 1) { av_log(s, AV_LOG_ERROR, "File size is larger than max_size option " "value %"PRIi64", consider increasing the max_size option\n", gme->max_size); return AVERROR_BUFFER_TOO_SMALL; } if (gme_open_data(buf, sz, &gme->music_emu, gme->sample_rate)) { av_freep(&buf); return AVERROR_INVALIDDATA; } av_freep(&buf); if (gme_track_info(gme->music_emu, &gme->info, gme->track_index)) return AVERROR_STREAM_NOT_FOUND; if (gme_start_track(gme->music_emu, gme->track_index)) return AVERROR_UNKNOWN; load_metadata(s); st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); avpriv_set_pts_info(st, 64, 1, 1000); if (st->duration > 0) st->duration = gme->info->length; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_id = AV_NE(AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE); st->codecpar->channels = 2; st->codecpar->sample_rate = gme->sample_rate; return 0; }
int64_t ff_ape_parse_tag(AVFormatContext *s) { AVIOContext *pb = s->pb; int64_t file_size = avio_size(pb); uint32_t val, fields, tag_bytes; uint8_t buf[8]; int64_t tag_start; int i; if (file_size < APE_TAG_FOOTER_BYTES) return 0; avio_seek(pb, file_size - APE_TAG_FOOTER_BYTES, SEEK_SET); avio_read(pb, buf, 8); /* APETAGEX */ if (strncmp(buf, APE_TAG_PREAMBLE, 8)) { return 0; } val = avio_rl32(pb); /* APE tag version */ if (val > APE_TAG_VERSION) { av_log(s, AV_LOG_ERROR, "Unsupported tag version. (>=%d)\n", APE_TAG_VERSION); return 0; } tag_bytes = avio_rl32(pb); /* tag size */ if (tag_bytes - APE_TAG_FOOTER_BYTES > (1024 * 1024 * 16)) { av_log(s, AV_LOG_ERROR, "Tag size is way too big\n"); return 0; } if (tag_bytes > file_size - APE_TAG_FOOTER_BYTES) { av_log(s, AV_LOG_ERROR, "Invalid tag size %"PRIu32".\n", tag_bytes); return 0; } tag_start = file_size - tag_bytes - APE_TAG_FOOTER_BYTES; fields = avio_rl32(pb); /* number of fields */ if (fields > 65536) { av_log(s, AV_LOG_ERROR, "Too many tag fields (%"PRIu32")\n", fields); return 0; } val = avio_rl32(pb); /* flags */ if (val & APE_TAG_FLAG_IS_HEADER) { av_log(s, AV_LOG_ERROR, "APE Tag is a header\n"); return 0; } avio_seek(pb, file_size - tag_bytes, SEEK_SET); for (i=0; i<fields; i++) if (ape_tag_read_field(s) < 0) break; return tag_start; }
static int r3d_read_header(AVFormatContext *s) { R3DContext *r3d = s->priv_data; Atom atom; int ret; if (read_atom(s, &atom) < 0) { av_log(s, AV_LOG_ERROR, "error reading atom\n"); return -1; } if (atom.tag == MKTAG('R','E','D','1')) { if ((ret = r3d_read_red1(s)) < 0) { av_log(s, AV_LOG_ERROR, "error parsing 'red1' atom\n"); return ret; } } else { av_log(s, AV_LOG_ERROR, "could not find 'red1' atom\n"); return -1; } /* we cannot create the audio stream now because we do not know the * sample rate */ if (r3d->audio_channels) s->ctx_flags |= AVFMTCTX_NOHEADER; s->internal->data_offset = avio_tell(s->pb); av_log(s, AV_LOG_TRACE, "data offset %#"PRIx64"\n", s->internal->data_offset); if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) return 0; // find REOB/REOF/REOS to load index avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET); if (read_atom(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error reading end atom\n"); if (atom.tag != MKTAG('R','E','O','B') && atom.tag != MKTAG('R','E','O','F') && atom.tag != MKTAG('R','E','O','S')) goto out; r3d_read_reos(s); if (r3d->rdvo_offset) { avio_seek(s->pb, r3d->rdvo_offset, SEEK_SET); if (read_atom(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error reading 'rdvo' atom\n"); if (atom.tag == MKTAG('R','D','V','O')) { if (r3d_read_rdvo(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error parsing 'rdvo' atom\n"); } } out: avio_seek(s->pb, s->internal->data_offset, SEEK_SET); return 0; }
static struct input_stream * input_ffmpeg_open(const char *uri, GMutex *mutex, GCond *cond, GError **error_r) { struct input_ffmpeg *i; if (!g_str_has_prefix(uri, "gopher://") && !g_str_has_prefix(uri, "rtp://") && !g_str_has_prefix(uri, "rtsp://") && !g_str_has_prefix(uri, "rtmp://") && !g_str_has_prefix(uri, "rtmpt://") && !g_str_has_prefix(uri, "rtmps://")) return NULL; i = g_new(struct input_ffmpeg, 1); input_stream_init(&i->base, &input_plugin_ffmpeg, uri, mutex, cond); #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,1,0) int ret = avio_open(&i->h, uri, AVIO_FLAG_READ); #elif LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0) int ret = avio_open(&i->h, uri, AVIO_RDONLY); #else int ret = url_open(&i->h, uri, URL_RDONLY); #endif if (ret != 0) { g_free(i); g_set_error(error_r, ffmpeg_quark(), ret, "libavformat failed to open the URI"); return NULL; } i->eof = false; i->base.ready = true; #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0) i->base.seekable = (i->h->seekable & AVIO_SEEKABLE_NORMAL) != 0; i->base.size = avio_size(i->h); #else i->base.seekable = !i->h->is_streamed; i->base.size = url_filesize(i->h); #endif /* hack to make MPD select the "ffmpeg" decoder plugin - since avio.h doesn't tell us the MIME type of the resource, we can't select a decoder plugin, but the "ffmpeg" plugin is quite good at auto-detection */ i->base.mime = g_strdup("audio/x-mpd-ffmpeg"); return &i->base; }
char* PMS_IssueHttpRequest(const char* url, const char* verb) { char* reply = NULL; AVIOContext *ioctx = NULL; AVDictionary *settings = NULL; int size = 0; int ret; char headers[1024]; const char *token = getenv("X_PLEX_TOKEN"); if (token && *token) snprintf(headers, sizeof(headers), "X-Plex-Token: %s\r\n", token); av_dict_set(&settings, "method", verb, 0); if (token && *token) av_dict_set(&settings, "headers", headers, 0); ret = avio_open2(&ioctx, url, AVIO_FLAG_READ, NULL, &settings); if (ret < 0) goto fail; size = avio_size(ioctx); if (size < 0) size = 4095; else if (!size) goto fail; reply = av_malloc(size + 1); if (!reply) goto fail; ret = avio_read(ioctx, reply, size); if (ret < 0) goto fail; reply[ret] = 0; avio_close(ioctx); av_dict_free(&settings); return reply; fail: avio_close(ioctx); av_dict_free(&settings); if (reply) av_free(reply); return NULL; }
static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap) { R3DContext *r3d = s->priv_data; Atom atom; int ret; if (read_atom(s, &atom) < 0) { av_log(s, AV_LOG_ERROR, "error reading atom\n"); return -1; } if (atom.tag == MKTAG('R','E','D','1')) { if ((ret = r3d_read_red1(s)) < 0) { av_log(s, AV_LOG_ERROR, "error parsing 'red1' atom\n"); return ret; } } else { av_log(s, AV_LOG_ERROR, "could not find 'red1' atom\n"); return -1; } s->data_offset = avio_tell(s->pb); av_dlog(s, "data offset %#llx\n", s->data_offset); if (!s->pb->seekable) return 0; // find REOB/REOF/REOS to load index avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET); if (read_atom(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error reading end atom\n"); if (atom.tag != MKTAG('R','E','O','B') && atom.tag != MKTAG('R','E','O','F') && atom.tag != MKTAG('R','E','O','S')) goto out; r3d_read_reos(s); if (r3d->rdvo_offset) { avio_seek(s->pb, r3d->rdvo_offset, SEEK_SET); if (read_atom(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error reading 'rdvo' atom\n"); if (atom.tag == MKTAG('R','D','V','O')) { if (r3d_read_rdvo(s, &atom) < 0) av_log(s, AV_LOG_ERROR, "error parsing 'rdvo' atom\n"); } } out: avio_seek(s->pb, s->data_offset, SEEK_SET); return 0; }
static int gxf_write_material_data_section(AVFormatContext *s) { GXFContext *gxf = s->priv_data; AVIOContext *pb = s->pb; int64_t pos; int len; const char *filename = strrchr(s->filename, '/'); pos = avio_tell(pb); avio_wb16(pb, 0); /* size */ /* name */ if (filename) filename++; else filename = s->filename; len = strlen(filename); avio_w8(pb, MAT_NAME); avio_w8(pb, strlen(SERVER_PATH) + len + 1); avio_write(pb, SERVER_PATH, sizeof(SERVER_PATH) - 1); avio_write(pb, filename, len); avio_w8(pb, 0); /* first field */ avio_w8(pb, MAT_FIRST_FIELD); avio_w8(pb, 4); avio_wb32(pb, 0); /* last field */ avio_w8(pb, MAT_LAST_FIELD); avio_w8(pb, 4); avio_wb32(pb, gxf->nb_fields); /* reserved */ avio_w8(pb, MAT_MARK_IN); avio_w8(pb, 4); avio_wb32(pb, 0); avio_w8(pb, MAT_MARK_OUT); avio_w8(pb, 4); avio_wb32(pb, gxf->nb_fields); /* estimated size */ avio_w8(pb, MAT_SIZE); avio_w8(pb, 4); avio_wb32(pb, avio_size(pb) / 1024); return updateSize(pb, pos); }
static int stream_ffmpeg_seek(stream_wrapper_t * wrapper, int64_t pos, int whence) { AVIOContext *ctx = (AVIOContext *)wrapper->stream_priv; stream_ctrl_t *info = &wrapper->info; info->eof_flag = 0; if (whence == AVSEEK_SIZE) { dt_debug(TAG, "REQUEST STREAM SIZE:%lld \n", info->stream_size); return avio_size(ctx); } return avio_seek(ctx, pos, whence); }
static int sds_read_header(AVFormatContext *ctx) { SDSContext *s = ctx->priv_data; unsigned sample_period; AVIOContext *pb = ctx->pb; AVStream *st; st = avformat_new_stream(ctx, NULL); if (!st) return AVERROR(ENOMEM); avio_skip(pb, 4); avio_skip(pb, 2); s->bit_depth = avio_r8(pb); if (s->bit_depth < 8 || s->bit_depth > 28) return AVERROR_INVALIDDATA; if (s->bit_depth < 14) { s->read_block = byte2_read; s->size = 60 * 4; } else if (s->bit_depth < 21) { s->read_block = byte3_read; s->size = 40 * 4; } else { s->read_block = byte4_read; s->size = 30 * 4; } st->codecpar->codec_id = AV_CODEC_ID_PCM_U32LE; sample_period = avio_rl24(pb); sample_period = SDS_3BYTE_TO_INT_DECODE(sample_period); avio_skip(pb, 11); st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->channels = 1; st->codecpar->sample_rate = sample_period ? 1000000000 / sample_period : 16000; st->duration = (avio_size(pb) - 21) / (127) * s->size / 4; avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate); return 0; }
void ff_id3v1_read(AVFormatContext *s) { int ret; uint8_t buf[ID3v1_TAG_SIZE]; int64_t filesize, position = avio_tell(s->pb); if (s->pb->seekable) { /* XXX: change that */ filesize = avio_size(s->pb); if (filesize > 128) { avio_seek(s->pb, filesize - 128, SEEK_SET); ret = avio_read(s->pb, buf, ID3v1_TAG_SIZE); if (ret == ID3v1_TAG_SIZE) { parse_tag(s, buf); } avio_seek(s->pb, position, SEEK_SET); } } }
static off_t input_avio_seek (input_plugin_t *this_gen, off_t offset, int origin) { avio_input_plugin_t *this = (avio_input_plugin_t *) this_gen; off_t size; off_t newpos; if (!this->pb || !this->pb->seekable) { return -1; } /* convert relative seeks to absolute */ switch (origin) { case SEEK_SET: break; case SEEK_CUR: offset += this->curpos; break; case SEEK_END: size = avio_size(this->pb); if (size < 1) { return -1; } offset = size + offset; if (offset < 0) offset = 0; if (offset > size) offset = size; break; } /* seek, take care of preview buffer */ newpos = offset; if (offset < this->preview_size) { offset = this->preview_size; } if (offset != avio_seek(this->pb, offset, SEEK_SET)) { return -1; } this->curpos = newpos; return this->curpos; }
static int ffio_limit(AVIOContext *s, int size) { if (s->maxsize>= 0) { int64_t remaining= s->maxsize - avio_tell(s); if (remaining < size) { int64_t newsize = avio_size(s); if (!s->maxsize || s->maxsize<newsize) s->maxsize = newsize - !newsize; remaining= s->maxsize - avio_tell(s); remaining= FFMAX(remaining, 0); } if (s->maxsize>= 0 && remaining+1 < size) { av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1); size = remaining+1; } } return size; }
static int read_header(AVFormatContext *s, AVFormatParameters *ap) { FilmstripDemuxContext *film = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; if (!s->pb->seekable) return AVERROR(EIO); avio_seek(pb, avio_size(pb) - 36, SEEK_SET); if (avio_rb32(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 = avio_rb32(pb); if (avio_rb16(pb) != 0) { av_log_ask_for_sample(s, "unsupported packing method\n"); return AVERROR_INVALIDDATA; } avio_skip(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 = avio_rb16(pb); st->codec->height = avio_rb16(pb); film->leading = avio_rb16(pb); av_set_pts_info(st, 64, 1, avio_rb16(pb)); avio_seek(pb, 0, SEEK_SET); return 0; }
uint8_t * fa_libav_load_and_close(AVIOContext *avio, size_t *sizep) { size_t r, size = avio_size(avio); uint8_t *mem = malloc(size+1); avio_seek(avio, 0, SEEK_SET); r = avio_read(avio, mem, size); fa_libav_close(avio); if(r != size) { free(mem); return NULL; } if(sizep != NULL) *sizep = size; mem[size] = 0; return mem; }
static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration) { int i; MP3Context *mp3 = s->priv_data; if (!filesize && !(filesize = avio_size(s->pb))) { av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n"); return; } for (i = 0; i < XING_TOC_COUNT; i++) { uint8_t b = avio_r8(s->pb); av_add_index_entry(s->streams[0], av_rescale(b, filesize, 256), av_rescale(i, duration, XING_TOC_COUNT), 0, 0, AVINDEX_KEYFRAME); } mp3->xing_toc = 1; }
static int read_header(AVFormatContext *s) { AVStream *vst; int ret; vst = avformat_new_stream(s, NULL); if (!vst) return AVERROR(ENOMEM); vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codec->codec_id = CODEC_ID_CDGRAPHICS; /// 75 sectors/sec * 4 packets/sector = 300 packets/sec avpriv_set_pts_info(vst, 32, 1, 300); ret = avio_size(s->pb); if (ret > 0) vst->duration = (ret * vst->time_base.den) / (CDG_PACKET_SIZE * 300); return 0; }