From 6fb346cc8b6331486391989be5ec4c2c46e2708c Mon Sep 17 00:00:00 2001 From: Scott Lamb Date: Sun, 29 Dec 2019 08:35:39 -0600 Subject: [PATCH] address AVStream::codec deprecation The codec -> codecpar move was sufficiently long ago (libavformat 57.5.0 on 2016-04-11) that I think we can just get away with requiring the new version. Let's try it. But if someone complains, AVCodecParameters and AVCodecContext look sufficiently similar we could probably just use one or the other based on the version we're compiling with. --- ffmpeg/build.rs | 2 +- ffmpeg/lib.rs | 32 ++++++++++++++++---------------- ffmpeg/wrapper.c | 16 +++++++++------- src/stream.rs | 4 ++-- 4 files changed, 28 insertions(+), 26 deletions(-) diff --git a/ffmpeg/build.rs b/ffmpeg/build.rs index 759c6f1..ede4c9f 100644 --- a/ffmpeg/build.rs +++ b/ffmpeg/build.rs @@ -32,7 +32,7 @@ fn main() { let libraries = [ pkg_config::Config::new().atleast_version("54.1").probe("libavutil").unwrap(), pkg_config::Config::new().atleast_version("56.0").probe("libavcodec").unwrap(), - pkg_config::Config::new().atleast_version("56.0").probe("libavformat").unwrap(), + pkg_config::Config::new().atleast_version("57.5").probe("libavformat").unwrap(), ]; let mut wrapper = cc::Build::new(); diff --git a/ffmpeg/lib.rs b/ffmpeg/lib.rs index a1fc936..a41b99b 100644 --- a/ffmpeg/lib.rs +++ b/ffmpeg/lib.rs @@ -43,11 +43,11 @@ extern "C" { fn av_init_packet(p: *mut AVPacket); fn av_packet_unref(p: *mut AVPacket); - fn moonfire_ffmpeg_cctx_codec_id(ctx: *const AVCodecContext) -> libc::c_int; - fn moonfire_ffmpeg_cctx_codec_type(ctx: *const AVCodecContext) -> libc::c_int; - fn moonfire_ffmpeg_cctx_extradata(ctx: *const AVCodecContext) -> DataLen; - fn moonfire_ffmpeg_cctx_height(ctx: *const AVCodecContext) -> libc::c_int; - fn moonfire_ffmpeg_cctx_width(ctx: *const AVCodecContext) -> libc::c_int; + fn moonfire_ffmpeg_codecpar_codec_id(ctx: *const AVCodecParameters) -> libc::c_int; + fn moonfire_ffmpeg_codecpar_codec_type(ctx: *const AVCodecParameters) -> libc::c_int; + fn moonfire_ffmpeg_codecpar_extradata(ctx: *const AVCodecParameters) -> DataLen; + fn moonfire_ffmpeg_codecpar_height(ctx: *const AVCodecParameters) -> libc::c_int; + fn moonfire_ffmpeg_codecpar_width(ctx: *const AVCodecParameters) -> libc::c_int; } //#[link(name = "avformat")] @@ -66,7 +66,7 @@ extern "C" { fn moonfire_ffmpeg_fctx_streams(ctx: *const AVFormatContext) -> StreamsLen; - fn moonfire_ffmpeg_stream_codec(stream: *const AVStream) -> *const AVCodecContext; + fn moonfire_ffmpeg_stream_codecpar(stream: *const AVStream) -> *const AVCodecParameters; fn moonfire_ffmpeg_stream_time_base(stream: *const AVStream) -> AVRational; } @@ -127,7 +127,7 @@ pub struct AVRational { } // No ABI stability assumption here; use heap allocation/deallocation and accessors only. -enum AVCodecContext {} +enum AVCodecParameters {} enum AVDictionary {} enum AVFormatContext {} enum AVInputFormat {} @@ -259,8 +259,8 @@ impl<'owner> Streams<'owner> { pub struct Stream<'o>(&'o AVStream); impl<'o> Stream<'o> { - pub fn codec<'s>(&'s self) -> CodecContext<'s> { - CodecContext(unsafe { moonfire_ffmpeg_stream_codec(self.0).as_ref() }.unwrap()) + pub fn codecpar<'s>(&'s self) -> CodecParameters<'s> { + CodecParameters(unsafe { moonfire_ffmpeg_stream_codecpar(self.0).as_ref() }.unwrap()) } pub fn time_base(&self) -> AVRational { @@ -268,22 +268,22 @@ impl<'o> Stream<'o> { } } -pub struct CodecContext<'s>(&'s AVCodecContext); +pub struct CodecParameters<'s>(&'s AVCodecParameters); -impl<'s> CodecContext<'s> { +impl<'s> CodecParameters<'s> { pub fn extradata(&self) -> &[u8] { unsafe { - let d = moonfire_ffmpeg_cctx_extradata(self.0); + let d = moonfire_ffmpeg_codecpar_extradata(self.0); ::std::slice::from_raw_parts(d.data, d.len) } } - pub fn width(&self) -> libc::c_int { unsafe { moonfire_ffmpeg_cctx_width(self.0) } } - pub fn height(&self) -> libc::c_int { unsafe { moonfire_ffmpeg_cctx_height(self.0) } } + pub fn width(&self) -> libc::c_int { unsafe { moonfire_ffmpeg_codecpar_width(self.0) } } + pub fn height(&self) -> libc::c_int { unsafe { moonfire_ffmpeg_codecpar_height(self.0) } } pub fn codec_id(&self) -> CodecId { - CodecId(unsafe { moonfire_ffmpeg_cctx_codec_id(self.0) }) + CodecId(unsafe { moonfire_ffmpeg_codecpar_codec_id(self.0) }) } pub fn codec_type(&self) -> MediaType { - MediaType(unsafe { moonfire_ffmpeg_cctx_codec_type(self.0) }) + MediaType(unsafe { moonfire_ffmpeg_codecpar_codec_type(self.0) }) } } diff --git a/ffmpeg/wrapper.c b/ffmpeg/wrapper.c index 3484f19..7a0dc00 100644 --- a/ffmpeg/wrapper.c +++ b/ffmpeg/wrapper.c @@ -136,14 +136,16 @@ struct moonfire_ffmpeg_data moonfire_ffmpeg_packet_data(AVPacket *pkt) { return d; } -AVCodecContext *moonfire_ffmpeg_stream_codec(AVStream *stream) { return stream->codec; } +AVCodecParameters *moonfire_ffmpeg_stream_codecpar(AVStream *stream) { return stream->codecpar; } AVRational moonfire_ffmpeg_stream_time_base(AVStream *stream) { return stream->time_base; } -int moonfire_ffmpeg_cctx_codec_id(AVCodecContext *cctx) { return cctx->codec_id; } -int moonfire_ffmpeg_cctx_codec_type(AVCodecContext *cctx) { return cctx->codec_type; } -struct moonfire_ffmpeg_data moonfire_ffmpeg_cctx_extradata(AVCodecContext *cctx) { - struct moonfire_ffmpeg_data d = {cctx->extradata, cctx->extradata_size}; +int moonfire_ffmpeg_codecpar_codec_id(AVCodecParameters *codecpar) { return codecpar->codec_id; } +int moonfire_ffmpeg_codecpar_codec_type(AVCodecParameters *codecpar) { + return codecpar->codec_type; +} +struct moonfire_ffmpeg_data moonfire_ffmpeg_codecpar_extradata(AVCodecParameters *codecpar) { + struct moonfire_ffmpeg_data d = {codecpar->extradata, codecpar->extradata_size}; return d; } -int moonfire_ffmpeg_cctx_height(AVCodecContext *cctx) { return cctx->height; } -int moonfire_ffmpeg_cctx_width(AVCodecContext *cctx) { return cctx->width; } +int moonfire_ffmpeg_codecpar_height(AVCodecParameters *codecpar) { return codecpar->height; } +int moonfire_ffmpeg_codecpar_width(AVCodecParameters *codecpar) { return codecpar->width; } diff --git a/src/stream.rs b/src/stream.rs index a617bc0..92c29b9 100644 --- a/src/stream.rs +++ b/src/stream.rs @@ -123,7 +123,7 @@ impl Opener for Ffmpeg { { let s = input.streams(); for i in 0 .. s.len() { - if s.get(i).codec().codec_type().is_video() { + if s.get(i).codecpar().codec_type().is_video() { debug!("Video stream index is {}", i); video_i = Some(i); break; @@ -161,7 +161,7 @@ impl Stream for FfmpegStream { if tb.num != 1 || tb.den != 90000 { bail!("video stream has timebase {}/{}; expected 1/90000", tb.num, tb.den); } - let codec = video.codec(); + let codec = video.codecpar(); let codec_id = codec.codec_id(); if !codec_id.is_h264() { bail!("stream's video codec {:?} is not h264", codec_id);