Kieran/ffmpeg-the-third
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*: format code with rustfmt and fix clippy suggestions

Browse Source 
* Add avformat_close_input call to clean up AVFormantContext
* Format code with rustfmt
* Fix clippy lint double_parens
* Fix clippy lint deref_addrof
* Fix clippy lint identity_conversion
* Fix clippy lint match_ref_pats
* Fix clippy lint cast_lossless
* Fix clippy lint cmp_null
* Fix clippy lint clone_on_ref_ptr
* Fix clippy lint map_clone
* Fix clippy lint needless_borrow
* Fix clippy lint needless_pass_by_value
* Fix clippy lints for examples
* Fix clippy lint unused_io_amount
* Fix clippy lint new_without_default
* Ignore inline_always clippy lint
* Add vim temp files to .gitignore
This commit is contained in:
Tadas Barzdžius
2018-04-10 17:06:42 +03:00
committed by meh
parent 20c7ef399a
commit 0bcd4550b8
128 changed files with 10643 additions and 10233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
src/codec/encoder/audio.rs
View File

@ -1,200 +1,206 @@
use std::ops::{Deref, DerefMut};
use std::ptr;
use libc::c_int;
use ffi::*;
use libc::c_int;
use super::Encoder as Super;
use ::{packet, Error, Dictionary, ChannelLayout, frame};
use ::util::format;
use codec::{traits, Context};
use util::format;
use {frame, packet, ChannelLayout, Dictionary, Error};
pub struct Audio(pub Super);
impl Audio {
pub fn open(mut self) -> Result<Encoder, Error> {
unsafe {
match avcodec_open2(self.as_mut_ptr(), ptr::null(), ptr::null_mut()) {
0 => Ok(Encoder(self)),
e => Err(Error::from(e))
}
}
}
pub fn open(mut self) -> Result<Encoder, Error> {
unsafe {
match avcodec_open2(self.as_mut_ptr(), ptr::null(), ptr::null_mut()) {
0 => Ok(Encoder(self)),
e => Err(Error::from(e)),
}
}
}
pub fn open_as<E: traits::Encoder>(mut self, codec: E) -> Result<Encoder, Error> {
unsafe {
if let Some(codec) = codec.encoder() {
match avcodec_open2(self.as_mut_ptr(), codec.as_ptr(), ptr::null_mut()) {
0 => Ok(Encoder(self)),
e => Err(Error::from(e))
}
}
else {
Err(Error::EncoderNotFound)
}
}
}
pub fn open_as<E: traits::Encoder>(mut self, codec: E) -> Result<Encoder, Error> {
unsafe {
if let Some(codec) = codec.encoder() {
match avcodec_open2(self.as_mut_ptr(), codec.as_ptr(), ptr::null_mut()) {
0 => Ok(Encoder(self)),
e => Err(Error::from(e)),
}
} else {
Err(Error::EncoderNotFound)
}
}
}
pub fn open_with(mut self, options: Dictionary) -> Result<Encoder, Error> {
unsafe {
let mut opts = options.disown();
let res = avcodec_open2(self.as_mut_ptr(), ptr::null(), &mut opts);
pub fn open_with(mut self, options: Dictionary) -> Result<Encoder, Error> {
unsafe {
let mut opts = options.disown();
let res = avcodec_open2(self.as_mut_ptr(), ptr::null(), &mut opts);
Dictionary::own(opts);
Dictionary::own(opts);
match res {
0 => Ok(Encoder(self)),
e => Err(Error::from(e))
}
}
}
match res {
0 => Ok(Encoder(self)),
e => Err(Error::from(e)),
}
}
}
pub fn open_as_with<E: traits::Encoder>(mut self, codec: E, options: Dictionary) -> Result<Encoder, Error> {
unsafe {
if let Some(codec) = codec.encoder() {
let mut opts = options.disown();
let res = avcodec_open2(self.as_mut_ptr(), codec.as_ptr(), &mut opts);
pub fn open_as_with<E: traits::Encoder>(
mut self,
codec: E,
options: Dictionary,
) -> Result<Encoder, Error> {
unsafe {
if let Some(codec) = codec.encoder() {
let mut opts = options.disown();
let res = avcodec_open2(self.as_mut_ptr(), codec.as_ptr(), &mut opts);
Dictionary::own(opts);
Dictionary::own(opts);
match res {
0 => Ok(Encoder(self)),
e => Err(Error::from(e))
}
}
else {
Err(Error::EncoderNotFound)
}
}
}
match res {
0 => Ok(Encoder(self)),
e => Err(Error::from(e)),
}
} else {
Err(Error::EncoderNotFound)
}
}
}
pub fn set_rate(&mut self, rate: i32) {
unsafe {
(*self.as_mut_ptr()).sample_rate = rate;
}
}
pub fn set_rate(&mut self, rate: i32) {
unsafe {
(*self.as_mut_ptr()).sample_rate = rate;
}
}
pub fn rate(&self) -> u32 {
unsafe {
(*self.as_ptr()).sample_rate as u32
}
}
pub fn rate(&self) -> u32 {
unsafe { (*self.as_ptr()).sample_rate as u32 }
}
pub fn set_format(&mut self, value: format::Sample) {
unsafe {
(*self.as_mut_ptr()).sample_fmt = value.into();
}
}
pub fn set_format(&mut self, value: format::Sample) {
unsafe {
(*self.as_mut_ptr()).sample_fmt = value.into();
}
}
pub fn format(&self) -> format::Sample {
unsafe {
format::Sample::from((*self.as_ptr()).sample_fmt)
}
}
pub fn format(&self) -> format::Sample {
unsafe { format::Sample::from((*self.as_ptr()).sample_fmt) }
}
pub fn set_channel_layout(&mut self, value: ChannelLayout) {
unsafe {
(*self.as_mut_ptr()).channel_layout = value.bits();
}
}
pub fn set_channel_layout(&mut self, value: ChannelLayout) {
unsafe {
(*self.as_mut_ptr()).channel_layout = value.bits();
}
}
pub fn channel_layout(&self) -> ChannelLayout {
unsafe {
ChannelLayout::from_bits_truncate((*self.as_ptr()).channel_layout)
}
}
pub fn channel_layout(&self) -> ChannelLayout {
unsafe { ChannelLayout::from_bits_truncate((*self.as_ptr()).channel_layout) }
}
pub fn set_channels(&mut self, value: i32) {
unsafe {
(*self.as_mut_ptr()).channels = value;
}
}
pub fn set_channels(&mut self, value: i32) {
unsafe {
(*self.as_mut_ptr()).channels = value;
}
}
pub fn channels(&self) -> u16 {
unsafe {
(*self.as_ptr()).channels as u16
}
}
pub fn channels(&self) -> u16 {
unsafe { (*self.as_ptr()).channels as u16 }
}
}
impl Deref for Audio {
type Target = Super;
type Target = Super;
fn deref(&self) -> &<Self as Deref>::Target {
&self.0
}
fn deref(&self) -> &<Self as Deref>::Target {
&self.0
}
}
impl DerefMut for Audio {
fn deref_mut(&mut self) -> &mut<Self as Deref>::Target {
&mut self.0
}
fn deref_mut(&mut self) -> &mut <Self as Deref>::Target {
&mut self.0
}
}
impl AsRef<Context> for Audio {
fn as_ref(&self) -> &Context {
&self
}
fn as_ref(&self) -> &Context {
self
}
}
impl AsMut<Context> for Audio {
fn as_mut(&mut self) -> &mut Context {
&mut self.0
}
fn as_mut(&mut self) -> &mut Context {
&mut self.0
}
}
pub struct Encoder(pub Audio);
impl Encoder {
pub fn encode<P: packet::Mut>(&mut self, frame: &frame::Audio, out: &mut P) -> Result<bool, Error> {
unsafe {
if self.format() != frame.format() {
return Err(Error::InvalidData);
}
pub fn encode<P: packet::Mut>(
&mut self,
frame: &frame::Audio,
out: &mut P,
) -> Result<bool, Error> {
unsafe {
if self.format() != frame.format() {
return Err(Error::InvalidData);
}
let mut got: c_int = 0;
let mut got: c_int = 0;
match avcodec_encode_audio2(self.0.as_mut_ptr(), out.as_mut_ptr(), frame.as_ptr(), &mut got) {
e if e < 0 => Err(Error::from(e)),
_ => Ok(got != 0)
}
}
}
match avcodec_encode_audio2(
self.0.as_mut_ptr(),
out.as_mut_ptr(),
frame.as_ptr(),
&mut got,
) {
e if e < 0 => Err(Error::from(e)),
_ => Ok(got != 0),
}
}
}
pub fn flush<P: packet::Mut>(&mut self, out: &mut P) -> Result<bool, Error> {
unsafe {
let mut got: c_int = 0;
pub fn flush<P: packet::Mut>(&mut self, out: &mut P) -> Result<bool, Error> {
unsafe {
let mut got: c_int = 0;
match avcodec_encode_audio2(self.0.as_mut_ptr(), out.as_mut_ptr(), ptr::null(), &mut got) {
e if e < 0 => Err(Error::from(e)),
_ => Ok(got != 0)
}
}
}
match avcodec_encode_audio2(
self.0.as_mut_ptr(),
out.as_mut_ptr(),
ptr::null(),
&mut got,
) {
e if e < 0 => Err(Error::from(e)),
_ => Ok(got != 0),
}
}
}
pub fn frame_size(&self) -> u32 {
unsafe {
(*self.as_ptr()).frame_size as u32
}
}
pub fn frame_size(&self) -> u32 {
unsafe { (*self.as_ptr()).frame_size as u32 }
}
}
impl Deref for Encoder {
type Target = Audio;
type Target = Audio;
fn deref(&self) -> &<Self as Deref>::Target {
&self.0
}
fn deref(&self) -> &<Self as Deref>::Target {
&self.0
}
}
impl AsRef<Context> for Encoder {
fn as_ref(&self) -> &Context {
&self
}
fn as_ref(&self) -> &Context {
self
}
}
impl AsMut<Context> for Encoder {
fn as_mut(&mut self) -> &mut Context {
&mut self.0
}
fn as_mut(&mut self) -> &mut Context {
&mut self.0
}
}