diff --git a/sys/src/avformat/format.rs b/sys/src/avformat/format.rs
new file mode 100644
index 0000000..852d2f1
--- /dev/null
+++ b/sys/src/avformat/format.rs
@@ -0,0 +1,563 @@
+use libc::{c_void, c_char, c_uchar, c_int, c_uint, c_double, uint8_t, int64_t, size_t, FILE};
+use super::io::{AVIOContext, AVIOInterruptCB};
+use super::super::avutil::{AVClass, AVRational, AVDictionary, AVFrame, AVMediaType};
+use super::super::avcodec::{AVCodec, AVCodecID, AVCodecContext, AVPacket, AVPacketSideData, AVCodecParserContext, AVDiscard};
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVFrac {
+	pub val: int64_t,
+	pub num: int64_t,
+	pub den: int64_t,
+}
+
+pub type AVCodecTag = c_void;
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVProbeData {
+	pub filename: *const c_char,
+	pub buf: *mut c_uchar,
+	pub buf_size: c_int,
+	pub mime_type: *const c_char,
+}
+
+pub const AVPROBE_SCORE_EXTENSION:    c_int = 50;
+pub const AVPROBE_SCORE_MIME:         c_int = 75;
+pub const AVPROBE_SCORE_MAX:          c_int = 100;
+pub const AVPROBE_SCORE_RETRY:        c_int = AVPROBE_SCORE_MAX / 4;
+pub const AVPROBE_SCORE_STREAM_RETRY: c_int = AVPROBE_SCORE_MAX / 4 - 1;
+
+pub const AVPROBE_PADDING_SIZE: c_int = 32;
+
+pub const AVFMT_NOFILE:        c_int = 0x0001;
+pub const AVFMT_NEEDNUMBER:    c_int = 0x0002;
+pub const AVFMT_SHOW_IDS:      c_int = 0x0008;
+pub const AVFMT_RAWPICTURE:    c_int = 0x0020;
+pub const AVFMT_GLOBALHEADER:  c_int = 0x0040;
+pub const AVFMT_NOTIMESTAMPS:  c_int = 0x0080;
+pub const AVFMT_GENERIC_INDEX: c_int = 0x0100;
+pub const AVFMT_TS_DISCONT:    c_int = 0x0200;
+pub const AVFMT_VARIABLE_FPS:  c_int = 0x0400;
+pub const AVFMT_NODIMENSIONS:  c_int = 0x0800;
+pub const AVFMT_NOSTREAMS:     c_int = 0x1000;
+pub const AVFMT_NOBINSEARCH:   c_int = 0x2000;
+pub const AVFMT_NOGENSEARCH:   c_int = 0x4000;
+pub const AVFMT_NO_BYTE_SEEK:  c_int = 0x8000;
+pub const AVFMT_ALLOW_FLUSH:   c_int = 0x10000;
+pub const AVFMT_TS_NONSTRICT:  c_int = 0x20000;
+pub const AVFMT_TS_NEGATIVE:   c_int = 0x40000;
+pub const AVFMT_SEEK_TO_PTS:   c_int = 0x4000000;
+
+#[repr(C)]
+pub struct AVOutputFormat {
+	pub name:      *const c_char,
+	pub long_name: *const c_char,
+
+	pub mime_type:  *const c_char,
+	pub extensions: *const c_char,
+
+	pub audio_codec:    AVCodecID,
+	pub video_codec:    AVCodecID,
+	pub subtitle_codec: AVCodecID,
+
+	pub flags: c_int,
+	pub codec_tag:  *const *const AVCodecTag,
+	pub priv_class: *const AVClass,
+	pub next: *mut AVOutputFormat,
+	pub priv_data_size: c_int,
+
+	pub write_header:  extern fn(ctx: *mut AVFormatContext) -> c_int,
+	pub write_packet:  extern fn(ctx: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int,
+	pub write_trailer: extern fn(ctx: *mut AVFormatContext) -> c_int,
+
+	pub interleave_packet: extern fn(ctx: *mut AVFormatContext, out: *mut AVPacket, inp: *mut AVPacket, flush: c_int) -> c_int,
+	pub query_codec: extern fn(id: AVCodecID, std_compliance: c_int) -> c_int,
+	pub get_output_timestamp: extern fn(ctx: *mut AVFormatContext, stream: c_int, dts: *mut int64_t, wall: *mut int64_t),
+	pub control_message: extern fn(ctx: *mut AVFormatContext, kind: c_int, data: *mut c_void, data_size: size_t) -> c_int,
+	pub write_uncoded_frame: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, frame: *mut *mut AVFrame, flags: c_uint) -> c_int,
+
+	pub get_device_list: extern fn(ctx: *mut AVFormatContext, device_list: *mut c_void) -> c_int,
+	pub create_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int,
+	pub free_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int,
+
+	pub data_codec: AVCodecID,
+}
+
+#[repr(C)]
+pub struct AVInputFormat {
+	pub name:      *const c_char,
+	pub long_name: *const c_char,
+
+	pub flags: c_int,
+	pub extensions: *const c_char,
+	pub codec_tag: *const *const AVCodecTag,
+	pub priv_class: *const AVClass,
+	pub mime_type: *const c_char,
+	pub next: *mut AVInputFormat,
+	pub raw_codec_id: c_int,
+	pub priv_data_size: c_int,
+
+	pub read_probe:     extern fn(data: *mut AVProbeData) -> c_int,
+	pub read_header:    extern fn(ctx: *mut AVFormatContext) -> c_int,
+	pub read_packet:    extern fn(ctx: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int,
+	pub read_close:     extern fn(ctx: *mut AVFormatContext) -> c_int,
+	pub read_seek:      extern fn(ctx: *mut AVFormatContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> c_int,
+	pub read_timestamp: extern fn(ctx: *mut AVFormatContext, stream_index: c_int, pos: *mut int64_t, pos_limit: int64_t) -> int64_t,
+	pub read_play:      extern fn(ctx: *mut AVFormatContext) -> c_int,
+	pub read_pause:     extern fn(ctx: *mut AVFormatContext) -> c_int,
+	pub read_seek2:     extern fn(ctx: *mut AVFormatContext, stream_index: c_int, min_ts: int64_t, ts: int64_t, max_ts: int64_t, flags: c_int) -> c_int,
+
+	pub get_device_list: extern fn(ctx: *mut AVFormatContext, device_list: *mut c_void) -> c_int,
+	pub create_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int,
+	pub free_device_capabilities: extern fn(ctx: *mut AVFormatContext, caps: *mut c_void) -> c_int,
+}
+
+#[derive(Eq, PartialEq, Debug)]
+#[repr(C)]
+pub enum AVStreamParseType {
+	AVSTREAM_PARSE_NONE,
+	AVSTREAM_PARSE_FULL,
+	AVSTREAM_PARSE_HEADERS,
+	AVSTREAM_PARSE_TIMESTAMPS,
+	AVSTREAM_PARSE_FULL_ONCE,
+	AVSTREAM_PARSE_FULL_RAW = MKTAG!(0, b'R', b'A', b'W'),
+}
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVIndexEntry {
+	pub pos: int64_t,
+	pub timestamp: int64_t,
+	data: i32,
+	pub min_distance: c_int,
+}
+
+impl AVIndexEntry {
+	pub fn flags(&self) -> c_int {
+		self.data >> 30
+	}
+
+	pub fn size(&self) -> c_int {
+		self.data & 0b00111111111111111111111111111111
+	}
+}
+
+pub const AVINDEX_KEYFRAME: c_int = 0x0001;
+
+pub const AV_DISPOSITION_DEFAULT:          c_int = 0x0001;
+pub const AV_DISPOSITION_DUB:              c_int = 0x0002;
+pub const AV_DISPOSITION_ORIGINAL:         c_int = 0x0004;
+pub const AV_DISPOSITION_COMMENT:          c_int = 0x0008;
+pub const AV_DISPOSITION_LYRICS:           c_int = 0x0010;
+pub const AV_DISPOSITION_KARAOKE:          c_int = 0x0020;
+pub const AV_DISPOSITION_FORCED:           c_int = 0x0040;
+pub const AV_DISPOSITION_HEARING_IMPAIRED: c_int = 0x0080;
+pub const AV_DISPOSITION_VISUAL_IMPAIRED:  c_int = 0x0100;
+pub const AV_DISPOSITION_CLEAN_EFFECTS:    c_int = 0x0200;
+pub const AV_DISPOSITION_ATTACHED_PIC:     c_int = 0x0400;
+pub const AV_DISPOSITION_CAPTIONS:         c_int = 0x10000;
+pub const AV_DISPOSITION_DESCRIPTIONS:     c_int = 0x20000;
+pub const AV_DISPOSITION_METADATA:         c_int = 0x40000;
+
+pub const AV_PTS_WRAP_IGNORE:     c_int = 0;
+pub const AV_PTS_WRAP_ADD_OFFSET: c_int = 1;
+pub const AV_PTS_WRAP_SUB_OFFSET: c_int = -1;
+
+pub const AVSTREAM_EVENT_FLAG_METADATA_UPDATED: c_int = 0x0001;
+
+pub const MAX_STD_TIMEBASES: usize = 30 * 12 + 7 + 6;
+pub const MAX_PROBE_PACKETS: usize = 2500;
+pub const MAX_REORDER_DELAY: usize = 16;
+
+#[repr(C)]
+pub struct AVStreamInfo {
+	pub last_dts: int64_t,
+	pub duration_gcd: int64_t,
+	pub duration_count: c_int,
+	pub rfps_duration_sum: int64_t,
+	pub duration_error: [[*mut c_double; MAX_STD_TIMEBASES]; 2],
+	pub codec_info_duration: int64_t,
+	pub codec_info_duration_fields: int64_t,
+	pub found_decoder: c_int,
+	pub last_duration: int64_t,
+	pub fps_first_dts: int64_t,
+	pub fps_first_dts_idx: c_int,
+	pub fps_last_dts: int64_t,
+	pub fps_last_dts_idx: c_int,
+}
+
+#[repr(C)]
+pub struct AVStream {
+	pub index: c_int,
+	pub id: c_int,
+	pub codec: *mut AVCodecContext,
+	pub priv_data: *mut c_void,
+	pub pts: *mut AVFrac, // figure out how to handle optional compilation things
+	pub time_base: AVRational,
+	pub start_time: int64_t,
+	pub duration: int64_t,
+	pub nb_frames: int64_t,
+	pub disposition: c_int,
+	pub discard: AVDiscard,
+	pub sample_aspect_ratio: AVRational,
+	pub metadata: *mut AVDictionary,
+	pub avg_frame_rate: AVRational,
+	pub attached_pic: AVPacket,
+	pub side_data: *mut AVPacketSideData,
+	pub nb_side_data: c_int,
+	pub event_flags: c_int,
+	pub info: *mut AVStreamInfo,
+	pub pts_wrap_bits: c_int,
+	pub first_dts: int64_t,
+	pub cur_dts: int64_t,
+	pub last_IP_pts: int64_t,
+	pub last_IP_duration: c_int,
+	pub probe_packets: c_int,
+	pub codec_info_nb_frames: c_int,
+	pub need_parsing: AVStreamParseType,
+	pub parser: *mut AVCodecParserContext,
+	pub last_in_packet_buffer: *mut AVPacketList,
+	pub probe_data: AVProbeData,
+	pub pts_buffer: [int64_t; MAX_REORDER_DELAY + 1],
+	pub index_entries: *mut AVIndexEntry,
+	pub nb_index_entries: c_int,
+	pub index_entries_allocated_size: c_uint,
+	pub r_frame_rate: AVRational,
+	pub stream_identifiers: c_int,
+	pub interleaver_chunk_size: int64_t,
+	pub interleaver_chunk_duration: int64_t,
+	pub request_probe: c_int,
+	pub skip_to_keyframe: c_int,
+	pub skip_samples: c_int,
+	pub first_discard_sample: int64_t,
+	pub last_discard_sample: int64_t,
+	pub nb_decoded_frames: c_int,
+	pub mux_ts_offset: int64_t,
+	pub pts_wrap_reference: int64_t,
+	pub pts_wrap_behavior: c_int,
+	pub update_initial_durations_done: c_int,
+	pub pts_reorder_error: [int64_t; MAX_REORDER_DELAY + 1],
+	pub pts_reorder_error_count: [uint8_t; MAX_REORDER_DELAY + 1],
+	pub last_dts_for_order_check: int64_t,
+	pub dts_ordered: uint8_t,
+	pub dts_misordered: uint8_t,
+	pub inject_global_side_data: c_int,
+	pub recommended_encoder_configuration: *mut c_char,
+	pub display_aspect_ratio: AVRational,
+}
+
+pub const AV_PROGRAM_RUNNING: c_int = 1;
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVProgram {
+	pub id: c_int,
+	pub flags: c_int,
+	pub discard: AVDiscard,
+	pub stream_index: *mut c_uint,
+	pub nb_stream_indexes: c_uint,
+	pub metadata: *mut AVDictionary,
+	pub program_num: c_int,
+	pub pmt_pid: c_int,
+	pub pcr_pid: c_int,
+
+	pub start_time: int64_t,
+	pub end_time: int64_t,
+	pub pts_wrap_reference: int64_t,
+	pub pts_wrap_behavior: c_int,
+}
+
+pub const AVFMTCTX_NOHEADER: c_int = 0x0001;
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVChapter {
+	pub id: c_int,
+	pub time_base: AVRational,
+	pub start: int64_t,
+	pub end: int64_t,
+	pub metadata: *mut AVDictionary,
+}
+
+pub type av_format_control_message = extern fn(s: *mut AVFormatContext, kind: c_int, data: *mut c_void, data_size: size_t) -> c_int;
+
+#[derive(Eq, PartialEq, Debug)]
+#[repr(C)]
+pub enum AVDurationEstimationMethod {
+	AVFMT_DURATION_FROM_PTS,
+	AVFMT_DURATION_FROM_STREAM,
+	AVFMT_DURATION_FROM_BITRATE,
+}
+
+pub type AVFormatInternal = c_void;
+
+#[repr(C)]
+pub struct AVFormatContext {
+	pub av_class: *const AVClass,
+
+	pub iformat: *mut AVInputFormat,
+	pub oformat: *mut AVOutputFormat,
+
+	pub priv_data: *mut c_void,
+
+	pub pb: *mut AVIOContext,
+
+	pub ctx_flags: c_int,
+
+	pub nb_streams: c_uint,
+	pub streams:    *mut *mut AVStream,
+
+	pub filename: [c_char; 1024],
+
+	pub start_time: int64_t,
+	pub duration:   int64_t,
+
+	pub bit_rate:    c_int,
+	pub packet_size: c_uint,
+	pub max_delay:   c_int,
+	pub flags:       c_int,
+
+	pub probesize: c_uint,
+	pub max_analyze_duration: c_int,
+
+	pub key:    *const uint8_t,
+	pub keylen: c_int,
+
+	pub nb_programs: c_uint,
+	pub programs:    *mut *mut AVProgram,
+
+	pub video_codec_id:    AVCodecID,
+	pub audio_codec_id:    AVCodecID,
+	pub subtitle_codec_id: AVCodecID,
+
+	pub max_index_size:     c_uint,
+	pub max_picture_buffer: c_uint,
+
+	pub nb_chapters: c_uint,
+	pub chapters:    *mut *mut AVChapter,
+
+	pub metadata: *mut AVDictionary,
+
+	pub start_time_realtime: int64_t,
+	pub fps_probe_size: c_int,
+	pub error_recognition: c_int,
+
+	pub interrupt_callback: AVIOInterruptCB,
+
+	pub debug: c_int,
+
+	pub max_interleave_delta: int64_t,
+	pub strict_std_compliance: c_int,
+	pub event_flags: c_int,
+	pub max_ts_probe: c_int,
+	pub avoid_negative_ts: c_int,
+	pub ts_id: c_int,
+	pub audio_preload: c_int,
+
+	pub max_chunk_duration: c_int,
+	pub max_chunk_size: c_int,
+
+	pub use_wallclock_as_timestamp: c_int,
+	pub avio_flags: c_int,
+	pub duration_estimation_method: AVDurationEstimationMethod,
+	pub skip_initial_bytes: int64_t,
+	pub correct_ts_overflow: c_uint,
+	pub seek2any: c_int,
+	pub flush_packets: c_int,
+	pub probe_score: c_int,
+	pub format_probesize: c_int,
+
+	pub codec_whitelist:  *mut c_char,
+	pub format_whitelist: *mut c_char,
+
+	pub internal: *mut AVFormatInternal,
+
+	pub io_repositioned: c_int,
+
+	pub video_codec:    *mut AVCodec,
+	pub audio_codec:    *mut AVCodec,
+	pub subtitle_codec: *mut AVCodec,
+	pub data_codec:     *mut AVCodec,
+
+	pub metadata_header_padding: c_int,
+	pub opaque: *mut c_void,
+
+	pub control_message_cb: av_format_control_message,
+
+	pub output_ts_offset: int64_t,
+	pub max_analyze_duration2: int64_t,
+	pub probesize2: int64_t,
+
+	pub dump_separator: *mut uint8_t,
+	pub data_codec_id: AVCodecID,
+}
+
+pub const AVFMT_FLAG_GENPTS:          c_int = 0x0001;
+pub const AVFMT_FLAG_IGNIDX:          c_int = 0x0002;
+pub const AVFMT_FLAG_NONBLOCK:        c_int = 0x0004;
+pub const AVFMT_FLAG_IGNDTS:          c_int = 0x0008;
+pub const AVFMT_FLAG_NOFILLIN:        c_int = 0x0010;
+pub const AVFMT_FLAG_NOPARSE:         c_int = 0x0020;
+pub const AVFMT_FLAG_NOBUFFER:        c_int = 0x0040;
+pub const AVFMT_FLAG_CUSTOM_IO:       c_int = 0x0080;
+pub const AVFMT_FLAG_DISCARD_CORRUPT: c_int = 0x0100;
+pub const AVFMT_FLAG_FLUSH_PACKETS:   c_int = 0x0200;
+pub const AVFMT_FLAG_BITEXACT:        c_int = 0x0400;
+pub const AVFMT_FLAG_MP4A_LATM:       c_int = 0x8000;
+pub const AVFMT_FLAG_SORT_DTS:        c_int = 0x10000;
+pub const AVFMT_FLAG_PRIV_OPT:        c_int = 0x20000;
+pub const AVFMT_FLAG_KEEP_SIDE_DATA:  c_int = 0x40000;
+
+pub const FF_FDEBUG_TS: c_int = 0x0001;
+
+pub const AVFMT_EVENT_FLAG_METADATA_UPDATED: c_int = 0x0001;
+
+pub const AVFMT_AVOID_NEG_TS_AUTO:              c_int = -1;
+pub const AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE: c_int = 1;
+pub const AVFMT_AVOID_NEG_TS_MAKE_ZERO:         c_int = 2;
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct AVPacketList {
+	pub pkt: AVPacket,
+	pub next: *mut AVPacketList,
+}
+
+pub const AVSEEK_FLAG_BACKWARD: c_int = 1;
+pub const AVSEEK_FLAG_BYTE:     c_int = 2;
+pub const AVSEEK_FLAG_ANY:      c_int = 4;
+pub const AVSEEK_FLAG_FRAME:    c_int = 8;
+
+#[link(name = "avformat")]
+extern {
+	pub fn av_get_packet(s: *mut AVIOContext, pkt: *mut AVPacket, size: c_int) -> c_int;
+	pub fn av_append_packet(s: *mut AVIOContext, pkt: *mut AVPacket, size: c_int) -> c_int;
+
+	pub fn av_stream_get_r_frame_rate(s: *const AVStream) -> AVRational;
+	pub fn av_stream_set_r_frame_rate(s: *mut AVStream, r: AVRational);
+
+	pub fn av_stream_get_parser(s: *const AVStream) -> *mut AVCodecParserContext;
+
+	pub fn av_stream_get_recommended_encoder_configuration(s: *const AVStream) -> *mut c_char;
+	pub fn av_stream_set_recommended_encoder_configuration(s: *mut AVStream, configuration: *mut c_char);
+
+	pub fn av_stream_get_end_pts(st: *const AVStream);
+
+	pub fn av_format_get_probe_score(s: *const AVFormatContext) -> c_int;
+
+	pub fn av_format_get_video_codec(s: *const AVFormatContext) -> *mut AVCodec;
+	pub fn av_format_set_video_codec(s: *mut AVFormatContext, c: *mut AVCodec);
+
+	pub fn av_format_get_audio_codec(s: *const AVFormatContext) -> *mut AVCodec;
+	pub fn av_format_set_audio_codec(s: *mut AVFormatContext, c: *mut AVCodec);
+
+	pub fn av_format_get_subtitle_codec(s: *const AVFormatContext) -> *mut AVCodec;
+	pub fn av_format_set_subtitle_codec(s: *mut AVFormatContext, c: *mut AVCodec);
+
+	pub fn av_format_get_data_codec(s: *const AVFormatContext) -> *mut AVCodec;
+	pub fn av_format_set_data_codec(s: *mut AVFormatContext, c: *mut AVCodec);
+
+	pub fn av_format_get_metadata_header_padding(s: *const AVFormatContext) -> c_int;
+	pub fn av_format_set_metadata_header_padding(s: *mut AVFormatContext, c: c_int);
+
+	pub fn av_format_get_opaque(s: *const AVFormatContext) -> *mut c_void;
+	pub fn av_format_set_opaque(s: *mut AVFormatContext, opaque: *mut c_void);
+
+	pub fn av_format_get_control_message_cb(s: *const AVFormatContext) -> av_format_control_message;
+	pub fn av_format_set_control_message_cb(s: *mut AVFormatContext, callback: av_format_control_message);
+
+	pub fn av_format_inject_global_side_data(s: *mut AVFormatContext);
+
+	pub fn av_fmt_ctx_get_duration_estimation_method(ctx: *const AVFormatContext) -> AVDurationEstimationMethod;
+
+	pub fn avformat_version() -> c_uint;
+	pub fn avformat_configuration() -> *const c_char;
+	pub fn avformat_license() -> *const c_char;
+
+	pub fn av_register_all();
+	pub fn av_register_input_format(format: *mut AVInputFormat);
+	pub fn av_register_output_format(format: *mut AVOutputFormat);
+
+	pub fn avformat_network_init() -> c_int;
+	pub fn avformat_network_deinit() -> c_int;
+
+	pub fn av_iformat_next(f: *const AVInputFormat) -> *mut AVInputFormat;
+	pub fn av_oformat_next(f: *const AVOutputFormat) -> *mut AVOutputFormat;
+
+	pub fn avformat_alloc_context() -> *mut AVFormatContext;
+	pub fn avformat_free_context(s: *mut AVFormatContext);
+	pub fn avformat_get_class() -> *const AVClass;
+
+	pub fn avformat_new_stream(s: *mut AVFormatContext, c: *const AVCodec) -> *mut AVStream;
+	pub fn av_stream_get_side_data(stream: *mut AVStream, kind: AVPacketSideData, size: *mut c_int) -> *mut uint8_t;
+
+	pub fn av_new_program(s: *mut AVFormatContext, id: c_int) -> *mut AVProgram;
+
+	pub fn avformat_alloc_output_context2(ctx: *mut *mut AVFormatContext, oformat: *mut AVOutputFormat, format_name: *const c_char, filename: *const c_char) -> c_int;
+
+	pub fn av_find_input_format(short_name: *const c_char) -> *mut AVInputFormat;
+	pub fn av_probe_input_format(pd: *mut AVProbeData, is_opened: c_int) -> *mut AVInputFormat;
+	pub fn av_probe_input_format2(pd: *mut AVProbeData, is_opened: c_int, score_max: *mut c_int) -> *mut AVInputFormat;
+	pub fn av_probe_input_format3(pd: *mut AVProbeData, is_opened: c_int, score_ret: *mut c_int) -> *mut AVInputFormat;
+	pub fn av_probe_input_buffer2(pb: *mut AVIOContext, fmt: *mut *mut AVInputFormat, filename: *const c_char, logctx: *mut c_void, offset: c_uint, max_probe_size: c_uint) -> c_int;
+	pub fn av_probe_input_buffer(pb: *mut AVIOContext, fmt: *mut *mut AVInputFormat, filename: *const c_char, logctx: *mut c_void, offset: c_uint, max_probe_size: c_uint) -> c_int;
+
+	pub fn avformat_open_input(ps: *mut *mut AVFormatContext, filename: *const c_char, fmt: *mut AVInputFormat, options: *mut *mut AVDictionary) -> c_int;
+	pub fn avformat_find_stream_info(ic: *mut AVFormatContext, options: *mut *mut AVDictionary) -> c_int;
+	pub fn av_find_program_from_stream(ic: *mut AVFormatContext, last: *mut AVProgram, s: c_int) -> *mut AVProgram;
+	pub fn av_find_best_stream(ic: *mut AVFormatContext, kind: AVMediaType, wanetd_stream_nb: c_int, related_stream: c_int, decoder_ret: *mut *mut AVCodec, flags: c_int) -> c_int;
+
+	pub fn av_read_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int;
+	pub fn av_seek_frame(s: *mut AVFormatContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> c_int;
+	pub fn avformat_seek_file(s: *mut AVFormatContext, stream_index: c_int, min_ts: int64_t, ts: int64_t, max_ts: int64_t, flags: c_int) -> c_int;
+	pub fn avformat_flush(s: *mut AVFormatContext) -> c_int;
+	pub fn av_read_play(s: *mut AVFormatContext) -> c_int;
+	pub fn av_read_pause(s: *mut AVFormatContext) -> c_int;
+	pub fn avformat_close_input(s: *mut *mut AVFormatContext);
+
+	pub fn avformat_write_header(s: *mut AVFormatContext, options: *mut *mut AVDictionary) -> c_int;
+	pub fn av_write_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int;
+	pub fn av_interleaved_write_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> c_int;
+	pub fn av_write_uncoded_frame(s: *mut AVFormatContext, stream_index: c_int, frame: *mut AVFrame) -> c_int;
+	pub fn av_interleaved_write_uncoded_frame(s: *mut AVFormatContext, stream_index: c_int, frame: *mut AVFrame) -> c_int;
+	pub fn av_write_uncoded_frame_query(s: *mut AVFormatContext, stream_index: c_int) -> c_int;
+	pub fn av_write_trailer(s: *mut AVFormatContext) -> c_int;
+
+	pub fn av_guess_format(short_name: *const c_char, filename: *const c_char, mime_type: *const c_char) -> *mut AVOutputFormat;
+	pub fn av_guess_codec(fmt: *mut AVOutputFormat, short_name: *const c_char, filename: *const c_char, mime_type: *const c_char, kind: AVMediaType) -> AVCodecID;
+
+	pub fn av_get_output_timestamp(s: *mut AVFormatContext, stream: c_int, dts: *mut int64_t, wall: *mut int64_t) -> c_int;
+
+	pub fn av_hex_dump(f: *mut FILE, buf: *mut uint8_t, size: c_int);
+	pub fn av_hex_dump_log(avcl: *mut c_void, level: c_int, buf: *const uint8_t, size: c_int);
+	pub fn av_pkt_dump2(f: *mut FILE, pkt: *const AVPacket, dump_payload: c_int, st: *const AVStream);
+	pub fn av_pkt_dump_log2(avcl: *mut c_void, level: c_int, pkt: *const AVPacket, dump_payload: c_int, st: *const AVStream);
+
+	pub fn av_codec_get_id(tags: *const *const AVCodecTag, tag: c_uint) -> AVCodecID;
+	pub fn av_codec_get_tag(tags: *const *const AVCodecTag, id: AVCodecID) -> c_uint;
+	pub fn av_codec_get_tag2(tags: *const *const AVCodecTag, id: AVCodecID, tag: *mut c_uint) -> c_int;
+
+	pub fn av_index_search_timestamp(st: *mut AVStream, timestamp: int64_t, flags: c_int) -> c_int;
+	pub fn av_add_index_entry(st: *mut AVStream, pos: int64_t, timestamp: int64_t, size: c_int, distance: c_int, flags: c_int) -> c_int;
+	pub fn av_url_split(proto: *mut c_char, proto_size: c_int, authorization: *mut c_char, authorization_size: c_int, hostname: *mut c_char, hostname_size: c_int, port_ptr: *mut c_int, path: *mut c_char, path_size: c_int, url: *const c_char);
+
+	pub fn av_dump_format(ic: *mut AVFormatContext, index: c_int, url: *const c_char, is_output: c_int);
+
+	pub fn av_get_frame_filename(buf: *mut c_char, buf_size: c_int, path: *const c_char, number: c_int) -> c_int;
+	pub fn av_filename_number_test(filename: *const c_char) -> c_int;
+	pub fn av_sdp_create(ac: *mut *mut AVFormatContext, n_files: c_int, buf: *mut c_char, size: c_int) -> c_int;
+	pub fn av_match_ext(filename: *const c_char, extensions: *const c_char) -> c_int;
+	
+	pub fn avformat_query_codec(ofmt: *const AVOutputFormat, codec_id: AVCodecID, std_compliance: c_int) -> c_int;
+	pub fn avformat_get_riff_video_tags() -> *const AVCodecTag;
+	pub fn avformat_get_riff_audio_tags() -> *const AVCodecTag;
+	pub fn avformat_get_mov_video_tags() -> *const AVCodecTag;
+	pub fn avformat_get_mov_audio_tags() -> *const AVCodecTag;
+
+	pub fn av_guess_sample_aspect_ratio(format: *mut AVFormatContext, stream: *mut AVStream, frame: *mut AVFrame) -> AVRational;
+	pub fn av_guess_frame_rate(ctx: *mut AVFormatContext, stream: *mut AVStream, frame: *mut AVStream) -> AVRational;
+
+	pub fn avformat_match_stream_specifier(s: *mut AVFormatContext, st: *mut AVStream, spec: *const c_char) -> c_int;
+	pub fn avformat_queue_attached_pictures(s: *mut AVFormatContext) -> c_int;
+}
diff --git a/sys/src/avformat/io.rs b/sys/src/avformat/io.rs
new file mode 100644
index 0000000..aad85ba
--- /dev/null
+++ b/sys/src/avformat/io.rs
@@ -0,0 +1,114 @@
+use libc::{c_void, c_char, c_uchar, c_int, c_uint, c_ulong, uint8_t, int64_t, uint64_t, size_t, SEEK_CUR};
+use super::super::avutil::{AVClass, AVBPrint, AVDictionary};
+
+pub const AVIO_SEEKABLE_NORMAL: c_int = 0x0001;
+
+pub const AVSEEK_SIZE:  c_int = 0x10000;
+pub const AVSEEK_FORCE: c_int = 0x20000;
+
+pub const AVIO_FLAG_READ:       c_int = 1;
+pub const AVIO_FLAG_WRITE:      c_int = 2;
+pub const AVIO_FLAG_READ_WRITE: c_int = AVIO_FLAG_READ | AVIO_FLAG_WRITE;
+pub const AVIO_FLAG_NONBLOCK:   c_int = 8;
+pub const AVIO_FLAG_DIRECT:     c_int = 0x8000;
+
+#[repr(C)]
+pub struct AVIOInterruptCB {
+	pub callback: extern fn(*mut c_void) -> c_int,
+	pub opaque: *mut c_void,
+}
+
+#[repr(C)]
+pub struct AVIOContext {
+	pub av_class: *mut AVClass,
+	pub buffer: *mut c_uchar,
+	pub buffer_size: c_int,
+	pub buf_ptr: *mut c_uchar,
+	pub buf_end: *mut c_uchar,
+	pub opaque: *mut c_void,
+	pub read_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int,
+	pub write_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int,
+	pub seek: extern fn(*mut c_void, int64_t, c_int) -> int64_t,
+	pub pos: int64_t,
+	pub must_flush: c_int,
+	pub eof_reached: c_int,
+	pub write_flag: c_int,
+	pub max_packet_size: c_int,
+	pub checksum: c_ulong,
+	pub checksum_ptr: *mut c_uchar,
+	pub update_checksum: extern fn(c_ulong, *const uint8_t, c_uint) -> c_uint,
+	pub error: c_int,
+	pub read_pause: extern fn(*mut c_void, c_int) -> c_int,
+	pub read_seek: extern fn(*mut c_void, c_int, int64_t, c_int) -> int64_t,
+	pub seekable: c_int,
+	pub maxsize: int64_t,
+	pub direct: c_int,
+	pub bytes_read: int64_t,
+	pub seek_count: c_int,
+	pub writeout_count: c_int,
+	pub orig_buffer_size: c_int,
+}
+
+#[inline(always)]
+pub unsafe fn avio_tell(s: *mut AVIOContext) -> int64_t {
+	avio_seek(s, 0, SEEK_CUR)
+}
+
+#[link(name = "avformat")]
+extern {
+	pub fn avio_find_protocol_name(url: *const c_char) -> *const c_char;
+	pub fn avio_check(url: *const c_char, flags: c_int) -> c_int;
+	pub fn avio_alloc_context(buffer: *mut c_uchar, buffer_size: c_int, write_flag: c_int, opaque: *mut c_void, read_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, write_packet: extern fn(*mut c_void, *mut uint8_t, c_int) -> c_int, seek: extern fn(*mut c_void, int64_t, c_int) -> int64_t) -> *mut AVIOContext;
+
+	pub fn avio_write(s: *mut AVIOContext, buf: *const c_uchar, size: c_int);
+	pub fn avio_w8(s: *mut AVIOContext, b: c_int);
+	pub fn avio_wl64(s: *mut AVIOContext, val: uint64_t);
+	pub fn avio_wb64(s: *mut AVIOContext, val: uint64_t);
+	pub fn avio_wl32(s: *mut AVIOContext, val: c_uint);
+	pub fn avio_wb32(s: *mut AVIOContext, val: c_uint);
+	pub fn avio_wl24(s: *mut AVIOContext, val: c_uint);
+	pub fn avio_wb24(s: *mut AVIOContext, val: c_uint);
+	pub fn avio_wl16(s: *mut AVIOContext, val: c_uint);
+	pub fn avio_wb16(s: *mut AVIOContext, val: c_uint);
+
+	pub fn avio_put_str(s: *mut AVIOContext, string: *const c_char) -> c_int;
+	pub fn avio_put_str16le(s: *mut AVIOContext, string: *const c_char) -> c_int;
+	pub fn avio_put_str16be(s: *mut AVIOContext, string: *const c_char) -> c_int;
+
+	pub fn avio_seek(s: *mut AVIOContext, offset: int64_t, whence: c_int) -> int64_t;
+	pub fn avio_skip(s: *mut AVIOContext, offset: int64_t) -> int64_t;
+	pub fn avio_size(s: *mut AVIOContext) -> int64_t;
+	pub fn avio_feof(s: *mut AVIOContext) -> c_int;
+
+	pub fn avio_printf(s: *mut AVIOContext, fmt: *const c_char, ...) -> c_int;
+	pub fn avio_flush(s: *mut AVIOContext);
+
+	pub fn avio_read(s: *mut AVIOContext, buf: *mut c_uchar, size: c_int) -> c_int;
+	pub fn avio_r8(s: *mut AVIOContext) -> c_int;
+	pub fn avio_rl16(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rl24(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rl32(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rl64(s: *mut AVIOContext) -> uint64_t;
+	pub fn avio_rb16(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rb24(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rb32(s: *mut AVIOContext) -> c_uint;
+	pub fn avio_rb64(s: *mut AVIOContext) -> uint64_t;
+
+	pub fn avio_get_str(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int;
+	pub fn avio_get_str16le(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int;
+	pub fn avio_get_str16be(pb: *mut AVIOContext, maxlen: c_int, buf: *mut c_char, buflen: c_int) -> c_int;
+
+	pub fn avio_open(s: *mut *mut AVIOContext, url: *const c_char, flags: c_int) -> c_int;
+	pub fn avio_open2(s: *mut *mut AVIOContext, url: *const c_char, flags: c_int, int_cb: *const AVIOInterruptCB, options: *mut *mut AVDictionary) -> c_int;
+
+	pub fn avio_close(s: *mut AVIOContext) -> c_int;
+	pub fn avio_closep(s: *mut *mut AVIOContext) -> c_int;
+
+	pub fn avio_open_dyn_buf(s: *mut *mut AVIOContext) -> c_int;
+	pub fn avio_close_dyn_buf(s: *mut AVIOContext, pbuffer: *mut *mut uint8_t) -> c_int;
+
+	pub fn avio_enum_protocols(opaque: *mut *mut c_void, output: c_int) -> *const c_char;
+	pub fn avio_pause(h: *mut AVIOContext, pause: c_int) -> c_int;
+	pub fn avio_seek_time(h: *mut AVIOContext, stream_index: c_int, timestamp: int64_t, flags: c_int) -> int64_t;
+	pub fn avio_read_to_bprint(h: *mut AVIOContext, pb: *mut AVBPrint, max_size: size_t) -> c_int;
+}
diff --git a/sys/src/avformat/mod.rs b/sys/src/avformat/mod.rs
new file mode 100644
index 0000000..d8d815e
--- /dev/null
+++ b/sys/src/avformat/mod.rs
@@ -0,0 +1,5 @@
+mod format;
+pub use self::format::*;
+
+mod io;
+pub use self::io::*;
diff --git a/sys/src/lib.rs b/sys/src/lib.rs
index a027dfb..450dc2b 100644
--- a/sys/src/lib.rs
+++ b/sys/src/lib.rs
@@ -9,3 +9,6 @@ pub use avutil::*;
 
 mod avcodec;
 pub use avcodec::*;
+
+mod avformat;
+pub use avformat::*;