diff --git a/src/AvTranscoder/Library.cpp b/src/AvTranscoder/Library.cpp
index 9c5ba23c..aed1f827 100644
--- a/src/AvTranscoder/Library.cpp
+++ b/src/AvTranscoder/Library.cpp
@@ -11,6 +11,7 @@ extern "C" {
 #else
 #include <libswresample/version.h>
 #endif
+#include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 #include <libavfilter/avfilter.h>
 }
diff --git a/src/AvTranscoder/codec/ICodec.hpp b/src/AvTranscoder/codec/ICodec.hpp
index de3203dd..8ad135ee 100644
--- a/src/AvTranscoder/codec/ICodec.hpp
+++ b/src/AvTranscoder/codec/ICodec.hpp
@@ -54,7 +54,6 @@ class AvExport ICodec
 #ifndef SWIG
     AVCodecContext& getAVCodecContext() { return *_avCodecContext; }
     const AVCodecContext& getAVCodecContext() const { return *_avCodecContext; }
-    AVCodec& getAVCodec() { return *_avCodec; }
     const AVCodec& getAVCodec() const { return *_avCodec; }
 #endif
 
@@ -66,7 +65,7 @@ class AvExport ICodec
 
 protected:
     AVCodecContext* _avCodecContext;     ///< Full codec instance description (has ownership)
-    AVCodec* _avCodec;                   ///< Codec abstract description
+    const AVCodec* _avCodec;             ///< Codec abstract description
     const bool _isCodecContextAllocated; ///< Is the AVCodecContext allocated by the class
 
     ECodecType _type;
diff --git a/src/AvTranscoder/common.hpp b/src/AvTranscoder/common.hpp
index bfd80899..8829bec0 100644
--- a/src/AvTranscoder/common.hpp
+++ b/src/AvTranscoder/common.hpp
@@ -2,8 +2,8 @@
 #define _AV_TRANSCODER_COMMON_HPP_
 
 #define AVTRANSCODER_VERSION_MAJOR 0
-#define AVTRANSCODER_VERSION_MINOR 15
-#define AVTRANSCODER_VERSION_MICRO 5
+#define AVTRANSCODER_VERSION_MINOR 16
+#define AVTRANSCODER_VERSION_MICRO 0
 
 #include <AvTranscoder/system.hpp>
 
diff --git a/src/AvTranscoder/data/coded/CodedData.cpp b/src/AvTranscoder/data/coded/CodedData.cpp
index 6247a0d6..074a0f83 100644
--- a/src/AvTranscoder/data/coded/CodedData.cpp
+++ b/src/AvTranscoder/data/coded/CodedData.cpp
@@ -87,7 +87,7 @@ void CodedData::assign(const size_t size, const int value)
 
 void CodedData::initAVPacket()
 {
-    av_init_packet(&_packet);
+    _packet = *av_packet_alloc();
     _packet.data = NULL;
     _packet.size = 0;
 }
diff --git a/src/AvTranscoder/decoder/AudioDecoder.cpp b/src/AvTranscoder/decoder/AudioDecoder.cpp
index f1086fcc..1a7a7d99 100644
--- a/src/AvTranscoder/decoder/AudioDecoder.cpp
+++ b/src/AvTranscoder/decoder/AudioDecoder.cpp
@@ -87,7 +87,7 @@ bool AudioDecoder::decodeNextFrame(IFrame& frameBuffer)
     if(!_isSetup)
         setupDecoder();
 
-    int got_frame = 0;
+    bool got_frame = false;
     while(!got_frame)
     {
         CodedData data;
@@ -98,18 +98,27 @@ bool AudioDecoder::decodeNextFrame(IFrame& frameBuffer)
         // decoding
         // @note could be called several times to return the remaining frames (last call with an empty packet)
         // @see CODEC_CAP_DELAY
-        int ret = avcodec_decode_audio4(&_inputStream->getAudioCodec().getAVCodecContext(), &frameBuffer.getAVFrame(),
-                                        &got_frame, &data.getAVPacket());
+        int ret = avcodec_send_packet(&_inputStream->getAudioCodec().getAVCodecContext(), &data.getAVPacket());
+
         if(ret < 0)
         {
-            throw std::runtime_error("An error occurred during audio decoding: " + getDescriptionFromErrorCode(ret));
+            throw std::runtime_error("An error occurred sending audio packet to decoder: " + getDescriptionFromErrorCode(ret));
         }
 
+        ret = avcodec_receive_frame(&_inputStream->getAudioCodec().getAVCodecContext(), &frameBuffer.getAVFrame());
+
+        if (ret == 0)
+            got_frame = true;
+        else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            got_frame = false;
+        else
+            throw std::runtime_error("An error occurred receiving audio packet from decoder: " + getDescriptionFromErrorCode(ret));
+
         // fixed channel layout value after decoding
         frameBuffer.getAVFrame().channel_layout = channelLayout;
 
         // if no frame could be decompressed
-        if(!nextPacketRead && ret == 0 && got_frame == 0)
+        if(!nextPacketRead && got_frame == 0)
             decodeNextFrame = false;
         else
             decodeNextFrame = true;
diff --git a/src/AvTranscoder/decoder/VideoDecoder.cpp b/src/AvTranscoder/decoder/VideoDecoder.cpp
index 3c1e1beb..447913be 100644
--- a/src/AvTranscoder/decoder/VideoDecoder.cpp
+++ b/src/AvTranscoder/decoder/VideoDecoder.cpp
@@ -94,15 +94,22 @@ bool VideoDecoder::decodeNextFrame(IFrame& frameBuffer)
         // decoding
         // @note could be called several times to return the remaining frames (last call with an empty packet)
         // @see CODEC_CAP_DELAY
-        const int ret = avcodec_decode_video2(&_inputStream->getVideoCodec().getAVCodecContext(), &frameBuffer.getAVFrame(),
-                                              &got_frame, &data.getAVPacket());
-        if(ret < 0)
-        {
-            throw std::runtime_error("An error occurred during video decoding: " + getDescriptionFromErrorCode(ret));
-        }
+        int ret = avcodec_send_packet(&_inputStream->getVideoCodec().getAVCodecContext(), &data.getAVPacket());
+
+        if (ret < 0 && (nextPacketRead || ret != AVERROR_EOF))
+            throw std::runtime_error("An error occurred sending video packet to decoder: " + getDescriptionFromErrorCode(ret));
+
+        ret = avcodec_receive_frame(&_inputStream->getVideoCodec().getAVCodecContext(), &frameBuffer.getAVFrame());
+
+        if (ret == 0)
+            got_frame = true;
+        else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            got_frame = false;
+        else
+            throw std::runtime_error("An error occurred receiving video packet from decoder: " + getDescriptionFromErrorCode(ret));
 
         // if no frame could be decompressed
-        if(!nextPacketRead && ret == 0 && got_frame == 0)
+        if ((!nextPacketRead && ret == 0) || !got_frame)
             decodeNextFrame = false;
         else
             decodeNextFrame = true;
diff --git a/src/AvTranscoder/encoder/AudioEncoder.cpp b/src/AvTranscoder/encoder/AudioEncoder.cpp
index 0e83c0ed..0b0621d6 100644
--- a/src/AvTranscoder/encoder/AudioEncoder.cpp
+++ b/src/AvTranscoder/encoder/AudioEncoder.cpp
@@ -7,6 +7,7 @@ extern "C" {
 }
 
 #include <stdexcept>
+#include <libavcodec/avcodec.h>
 
 namespace avtranscoder
 {
@@ -93,8 +94,6 @@ void AudioEncoder::setupEncoder(const ProfileLoader::Profile& profile)
 
 bool AudioEncoder::encodeFrame(const IFrame& sourceFrame, CodedData& codedFrame)
 {
-    AVCodecContext& avCodecContext = _codec.getAVCodecContext();
-
     AVPacket& packet = codedFrame.getAVPacket();
     const AVFrame& srcAvFrame = sourceFrame.getAVFrame();
     if(srcAvFrame.pts != (int)AV_NOPTS_VALUE)
@@ -121,7 +120,23 @@ bool AudioEncoder::encode(const AVFrame* decodedData, AVPacket& encodedData)
     encodedData.data = NULL;
 
     AVCodecContext& avCodecContext = _codec.getAVCodecContext();
-#if LIBAVCODEC_VERSION_MAJOR > 53
+#if LIBAVCODEC_VERSION_MAJOR > 58
+    int ret = avcodec_send_frame(&avCodecContext, decodedData);
+
+    if(ret != 0)
+        throw std::runtime_error("Error sending audio frame to encoder: " + getDescriptionFromErrorCode(ret));
+
+    ret = avcodec_receive_packet(&avCodecContext, &encodedData);
+
+    if (ret == 0)
+        return true;
+
+    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+        return false;
+
+    throw std::runtime_error("Error receiving audio frame from encoder: " + getDescriptionFromErrorCode(ret));
+
+#elif LIBAVCODEC_VERSION_MAJOR > 53
     int gotPacket = 0;
     const int ret = avcodec_encode_audio2(&avCodecContext, &encodedData, decodedData, &gotPacket);
     if(ret != 0)
diff --git a/src/AvTranscoder/encoder/VideoEncoder.cpp b/src/AvTranscoder/encoder/VideoEncoder.cpp
index 7d878d6a..d8662ff8 100644
--- a/src/AvTranscoder/encoder/VideoEncoder.cpp
+++ b/src/AvTranscoder/encoder/VideoEncoder.cpp
@@ -110,8 +110,6 @@ void VideoEncoder::setupEncoder(const ProfileLoader::Profile& profile)
 
 bool VideoEncoder::encodeFrame(const IFrame& sourceFrame, CodedData& codedFrame)
 {
-    AVCodecContext& avCodecContext = _codec.getAVCodecContext();
-
     AVPacket& packet = codedFrame.getAVPacket();
     const AVFrame& srcAvFrame = sourceFrame.getAVFrame();
     if(srcAvFrame.pts != (int)AV_NOPTS_VALUE)
@@ -138,7 +136,23 @@ bool VideoEncoder::encode(const AVFrame* decodedData, AVPacket& encodedData)
     encodedData.data = NULL;
 
     AVCodecContext& avCodecContext = _codec.getAVCodecContext();
-#if LIBAVCODEC_VERSION_MAJOR > 53
+#if LIBAVCODEC_VERSION_MAJOR > 58
+    int ret = avcodec_send_frame(&avCodecContext, decodedData);
+
+    if (ret != 0 && ret != AVERROR_EOF)
+        throw std::runtime_error("Error sending video frame to encoder: " + getDescriptionFromErrorCode(ret));
+
+    ret = avcodec_receive_packet(&avCodecContext, &encodedData);
+
+    if (ret == 0)
+        return true;
+
+    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+        return false;
+
+    throw std::runtime_error("Error receiving video frame from encoder: " + getDescriptionFromErrorCode(ret));
+
+#elif LIBAVCODEC_VERSION_MAJOR > 53
     int gotPacket = 0;
     const int ret = avcodec_encode_video2(&avCodecContext, &encodedData, decodedData, &gotPacket);
     if(ret != 0)
@@ -146,6 +160,7 @@ bool VideoEncoder::encode(const AVFrame* decodedData, AVPacket& encodedData)
         throw std::runtime_error("Encode video frame error: avcodec encode video frame - " +
                                  getDescriptionFromErrorCode(ret));
     }
+
     return gotPacket == 1;
 #else
     const int ret = avcodec_encode_video(&avCodecContext, encodedData.data, encodedData.size, decodedData);
diff --git a/src/AvTranscoder/file/FormatContext.cpp b/src/AvTranscoder/file/FormatContext.cpp
index 51d78f4e..cd423e85 100644
--- a/src/AvTranscoder/file/FormatContext.cpp
+++ b/src/AvTranscoder/file/FormatContext.cpp
@@ -46,10 +46,6 @@ FormatContext::~FormatContext()
     if(!_avFormatContext)
         return;
 
-    // free the streams added
-    for(std::vector<AVStream*>::iterator it = _avStreamAllocated.begin(); it != _avStreamAllocated.end(); ++it)
-        avcodec_close((*it)->codec);
-
     // free the format context
     if(_isOpen)
         avformat_close_input(&_avFormatContext);
@@ -151,7 +147,7 @@ AVStream& FormatContext::addAVStream(const AVCodec& avCodec)
 
 bool FormatContext::seek(const uint64_t position, const int flag)
 {
-    LOG_INFO("Seek in '" << _avFormatContext->filename << "' at " << position << " with flag '" << flag << "'")
+    LOG_INFO("Seek in '" << _avFormatContext->url << "' at " << position << " with flag '" << flag << "'")
     const int err = av_seek_frame(_avFormatContext, -1, position, flag);
     if(err < 0)
     {
@@ -186,12 +182,13 @@ AVStream& FormatContext::getAVStream(size_t index) const
 
 void FormatContext::setFilename(const std::string& filename)
 {
-    strcpy(&_avFormatContext->filename[0], filename.c_str());
+    _avFormatContext->url = (char*)av_malloc(filename.size());
+    strcpy(_avFormatContext->url, filename.c_str());
 }
 
 void FormatContext::setOutputFormat(const std::string& filename, const std::string& shortName, const std::string& mimeType)
 {
-    AVOutputFormat* oformat = av_guess_format(shortName.c_str(), filename.c_str(), mimeType.c_str());
+    const AVOutputFormat* oformat = av_guess_format(shortName.c_str(), filename.c_str(), mimeType.c_str());
     if(!oformat)
     {
         std::string msg("Unable to find format for ");
diff --git a/src/AvTranscoder/file/FormatContext.hpp b/src/AvTranscoder/file/FormatContext.hpp
index 0a33bbe1..b4283e19 100644
--- a/src/AvTranscoder/file/FormatContext.hpp
+++ b/src/AvTranscoder/file/FormatContext.hpp
@@ -113,8 +113,8 @@ class AvExport FormatContext
 
 #ifndef SWIG
     AVFormatContext& getAVFormatContext() const { return *_avFormatContext; }
-    AVOutputFormat& getAVOutputFormat() const { return *_avFormatContext->oformat; }
-    AVInputFormat& getAVInputFormat() const { return *_avFormatContext->iformat; }
+    const AVOutputFormat& getAVOutputFormat() const { return *_avFormatContext->oformat; }
+    const AVInputFormat& getAVInputFormat() const { return *_avFormatContext->iformat; }
     AVIOContext& getAVIOContext() const { return *_avFormatContext->pb; }
     AVDictionary& getAVMetaData() const { return *_avFormatContext->metadata; }
     AVStream& getAVStream(size_t index) const;
diff --git a/src/AvTranscoder/file/OutputFile.cpp b/src/AvTranscoder/file/OutputFile.cpp
index d446b431..49711abc 100644
--- a/src/AvTranscoder/file/OutputFile.cpp
+++ b/src/AvTranscoder/file/OutputFile.cpp
@@ -3,6 +3,7 @@
 #include <AvTranscoder/util.hpp>
 
 #include <stdexcept>
+#include <libavutil/channel_layout.h>
 
 #ifndef FF_INPUT_BUFFER_PADDING_SIZE
 #define FF_INPUT_BUFFER_PADDING_SIZE 16
@@ -35,31 +36,33 @@ IOutputStream& OutputFile::addVideoStream(const VideoCodec& videoDesc)
 {
     AVStream& stream = _formatContext.addAVStream(videoDesc.getAVCodec());
 
-    stream.codec->width = videoDesc.getAVCodecContext().width;
-    stream.codec->height = videoDesc.getAVCodecContext().height;
-    stream.codec->bit_rate = videoDesc.getAVCodecContext().bit_rate;
-    stream.codec->pix_fmt = videoDesc.getAVCodecContext().pix_fmt;
-    stream.codec->profile = videoDesc.getAVCodecContext().profile;
-    stream.codec->level = videoDesc.getAVCodecContext().level;
-    stream.codec->field_order = videoDesc.getAVCodecContext().field_order;
+    stream.codecpar->codec_type = videoDesc.getAVCodecContext().codec_type;
+    stream.codecpar->codec_id = videoDesc.getAVCodecContext().codec_id;
+    stream.codecpar->codec_tag = videoDesc.getAVCodecContext().codec_tag;
 
-    stream.codec->colorspace = videoDesc.getAVCodecContext().colorspace;
-    stream.codec->color_primaries = videoDesc.getAVCodecContext().color_primaries;
-    stream.codec->color_range = videoDesc.getAVCodecContext().color_range;
-    stream.codec->color_trc = videoDesc.getAVCodecContext().color_trc;
-    stream.codec->chroma_sample_location = videoDesc.getAVCodecContext().chroma_sample_location;
+    stream.codecpar->width = videoDesc.getAVCodecContext().width;
+    stream.codecpar->height = videoDesc.getAVCodecContext().height;
+    stream.codecpar->bit_rate = videoDesc.getAVCodecContext().bit_rate;
+    stream.codecpar->format = videoDesc.getAVCodecContext().pix_fmt;
+    stream.codecpar->profile = videoDesc.getAVCodecContext().profile;
+    stream.codecpar->level = videoDesc.getAVCodecContext().level;
+    stream.codecpar->field_order = videoDesc.getAVCodecContext().field_order;
+
+    stream.codecpar->color_space = videoDesc.getAVCodecContext().colorspace;
+    stream.codecpar->color_primaries = videoDesc.getAVCodecContext().color_primaries;
+    stream.codecpar->color_range = videoDesc.getAVCodecContext().color_range;
+    stream.codecpar->color_trc = videoDesc.getAVCodecContext().color_trc;
+    stream.codecpar->chroma_location = videoDesc.getAVCodecContext().chroma_sample_location;
 
     setOutputStream(stream, videoDesc);
 
     // need to set the time_base on the AVCodecContext and the AVStream
     // compensating the frame rate with the ticks_per_frame and keeping
     // a coherent reading speed.
-    av_reduce(&stream.codec->time_base.num, &stream.codec->time_base.den,
+    av_reduce(&stream.time_base.num, &stream.time_base.den,
               videoDesc.getAVCodecContext().time_base.num * videoDesc.getAVCodecContext().ticks_per_frame,
               videoDesc.getAVCodecContext().time_base.den, INT_MAX);
 
-    stream.time_base = stream.codec->time_base;
-
     OutputStream* outputStream = new OutputStream(*this, _formatContext.getNbStreams() - 1);
     _outputStreams.push_back(outputStream);
 
@@ -70,16 +73,20 @@ IOutputStream& OutputFile::addAudioStream(const AudioCodec& audioDesc)
 {
     AVStream& stream = _formatContext.addAVStream(audioDesc.getAVCodec());
 
-    stream.codec->sample_rate = audioDesc.getAVCodecContext().sample_rate;
-    stream.codec->channels = audioDesc.getAVCodecContext().channels;
-    stream.codec->channel_layout = audioDesc.getAVCodecContext().channel_layout;
-    stream.codec->sample_fmt = audioDesc.getAVCodecContext().sample_fmt;
-    stream.codec->frame_size = audioDesc.getAVCodecContext().frame_size;
+    stream.codecpar->codec_type = audioDesc.getAVCodecContext().codec_type;
+    stream.codecpar->codec_id = audioDesc.getAVCodecContext().codec_id;
+    stream.codecpar->codec_tag = audioDesc.getAVCodecContext().codec_tag;
+
+    stream.codecpar->sample_rate = audioDesc.getAVCodecContext().sample_rate;
+    stream.codecpar->channels = audioDesc.getAVCodecContext().channels;
+    stream.codecpar->channel_layout = audioDesc.getAVCodecContext().channel_layout;
+    stream.codecpar->format = audioDesc.getAVCodecContext().sample_fmt;
+    stream.codecpar->frame_size = audioDesc.getAVCodecContext().frame_size;
 
     setOutputStream(stream, audioDesc);
 
     // need to set the time_base on the AVCodecContext of the AVStream
-    av_reduce(&stream.codec->time_base.num, &stream.codec->time_base.den, audioDesc.getAVCodecContext().time_base.num,
+    av_reduce(&stream.time_base.num, &stream.time_base.den, audioDesc.getAVCodecContext().time_base.num,
               audioDesc.getAVCodecContext().time_base.den, INT_MAX);
 
     OutputStream* outputStream = new OutputStream(*this, _formatContext.getNbStreams() - 1);
@@ -92,14 +99,18 @@ IOutputStream& OutputFile::addCustomStream(const ICodec& iCodecDesc)
 {
     AVStream& stream = _formatContext.addAVStream(iCodecDesc.getAVCodec());
 
-    stream.codec->sample_rate = 48000;
-    stream.codec->channels = 1;
-    stream.codec->channel_layout = AV_CH_LAYOUT_MONO;
-    stream.codec->sample_fmt = AV_SAMPLE_FMT_S32;
-    stream.codec->frame_size = 1920;
+    stream.codecpar->codec_type = iCodecDesc.getAVCodecContext().codec_type;
+    stream.codecpar->codec_id = iCodecDesc.getAVCodecContext().codec_id;
+    stream.codecpar->codec_tag = iCodecDesc.getAVCodecContext().codec_tag;
+
+    stream.codecpar->sample_rate = 48000;
+    stream.codecpar->channels = 1;
+    stream.codecpar->channel_layout = AV_CH_LAYOUT_MONO;
+    stream.codecpar->format = AV_SAMPLE_FMT_S32;
+    stream.codecpar->frame_size = 1920;
 
     // need to set the time_base on the AVCodecContext of the AVStream
-    av_reduce(&stream.codec->time_base.num, &stream.codec->time_base.den, 1, 1, INT_MAX);
+    av_reduce(&stream.time_base.num, &stream.time_base.den, 1, 1, INT_MAX);
 
     OutputStream* outputStream = new OutputStream(*this, _formatContext.getNbStreams() - 1);
     _outputStreams.push_back(outputStream);
@@ -136,7 +147,7 @@ IOutputStream& OutputFile::getStream(const size_t streamIndex)
 
 std::string OutputFile::getFilename() const
 {
-    return std::string(_formatContext.getAVFormatContext().filename);
+    return std::string(_formatContext.getAVFormatContext().url);
 }
 
 std::string OutputFile::getFormatName() const
@@ -194,8 +205,7 @@ IOutputStream::EWrappingStatus OutputFile::wrap(const CodedData& data, const siz
                                 << _frameCount.at(streamIndex) << ")")
 
     // Packet to wrap
-    AVPacket packet;
-    av_init_packet(&packet);
+    AVPacket packet = *av_packet_alloc();
     packet.stream_index = streamIndex;
     packet.data = (uint8_t*)data.getData();
     packet.size = data.getSize();
@@ -348,6 +358,7 @@ void OutputFile::setupRemainingWrappingOptions()
 
 void OutputFile::setOutputStream(AVStream& avStream, const ICodec& codec)
 {
+#if LIBAVCODEC_VERSION_MAJOR < 59
     // depending on the format, place global headers in extradata instead of every keyframe
     if(_formatContext.getAVOutputFormat().flags & AVFMT_GLOBALHEADER)
     {
@@ -368,13 +379,14 @@ void OutputFile::setOutputStream(AVStream& avStream, const ICodec& codec)
         LOG_WARN("This codec is considered experimental by libav/ffmpeg:" << codec.getCodecName());
         avStream.codec->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
     }
+#endif
 
     // some codecs need/can use extradata to decode
     uint8_t* srcExtradata = codec.getAVCodecContext().extradata;
     const int srcExtradataSize = codec.getAVCodecContext().extradata_size;
-    avStream.codec->extradata = (uint8_t*)av_malloc(srcExtradataSize + FF_INPUT_BUFFER_PADDING_SIZE);
-    memcpy(avStream.codec->extradata, srcExtradata, srcExtradataSize);
-    memset(((uint8_t*)avStream.codec->extradata) + srcExtradataSize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
-    avStream.codec->extradata_size = codec.getAVCodecContext().extradata_size;
+    avStream.codecpar->extradata = (uint8_t*)av_malloc(srcExtradataSize + FF_INPUT_BUFFER_PADDING_SIZE);
+    memcpy(avStream.codecpar->extradata, srcExtradata, srcExtradataSize);
+    memset(((uint8_t*)avStream.codecpar->extradata) + srcExtradataSize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+    avStream.codecpar->extradata_size = codec.getAVCodecContext().extradata_size;
 }
 }
diff --git a/src/AvTranscoder/filter/FilterGraph.cpp b/src/AvTranscoder/filter/FilterGraph.cpp
index 8b960ef9..57b6ce2f 100644
--- a/src/AvTranscoder/filter/FilterGraph.cpp
+++ b/src/AvTranscoder/filter/FilterGraph.cpp
@@ -211,7 +211,7 @@ bool FilterGraph::areInputFrameSizesEqual(const std::vector<IFrame*>& inputs)
     if(!inputs.size() || inputs.size() == 1)
         return true;
 
-    const int frameSize = inputs.at(0)->getDataSize();
+    size_t frameSize = inputs.at(0)->getDataSize();
     for(size_t index = 1; index < inputs.size(); ++index)
     {
         if(frameSize != inputs.at(index)->getDataSize())
diff --git a/src/AvTranscoder/log.cpp b/src/AvTranscoder/log.cpp
index 5eab4325..98ffd649 100644
--- a/src/AvTranscoder/log.cpp
+++ b/src/AvTranscoder/log.cpp
@@ -56,7 +56,7 @@ void Logger::log(const int level, const std::string& msg)
     logMessage += "\n";
 
     // send message
-    av_log(NULL, level, logMessage.c_str());
+    av_log(NULL, level, "%s", logMessage.c_str());
 }
 
 void Logger::logInFile()
diff --git a/src/AvTranscoder/properties/AudioProperties.cpp b/src/AvTranscoder/properties/AudioProperties.cpp
index cf5793ef..327edc24 100644
--- a/src/AvTranscoder/properties/AudioProperties.cpp
+++ b/src/AvTranscoder/properties/AudioProperties.cpp
@@ -47,6 +47,8 @@ std::string AudioProperties::getSampleFormatLongName() const
             return "signed 16 bits";
         case AV_SAMPLE_FMT_S32:
             return "signed 32 bits";
+        case AV_SAMPLE_FMT_S64:
+            return "signed 64 bits";
         case AV_SAMPLE_FMT_FLT:
             return "float";
         case AV_SAMPLE_FMT_DBL:
@@ -57,6 +59,8 @@ std::string AudioProperties::getSampleFormatLongName() const
             return "signed 16 bits, planar";
         case AV_SAMPLE_FMT_S32P:
             return "signed 32 bits, planar";
+        case AV_SAMPLE_FMT_S64P:
+            return "signed 64 bits, planar";
         case AV_SAMPLE_FMT_FLTP:
             return "float, planar";
         case AV_SAMPLE_FMT_DBLP:
@@ -113,7 +117,7 @@ size_t AudioProperties::getBitRate() const
     if(_codecContext->bit_rate)
         return _codecContext->bit_rate;
 
-    LOG_WARN("The bitrate of the stream '" << _streamIndex << "' of file '" << _formatContext->filename << "' is unknown.")
+    LOG_WARN("The bitrate of the stream '" << _streamIndex << "' of file '" << _formatContext->url << "' is unknown.")
     LOG_INFO("Compute the audio bitrate (suppose PCM audio data).")
 
     const int bitsPerSample = av_get_bits_per_sample(_codecContext->codec_id); // 0 if unknown for the given codec
diff --git a/src/AvTranscoder/properties/DataProperties.cpp b/src/AvTranscoder/properties/DataProperties.cpp
index af92b09a..f81a19c3 100644
--- a/src/AvTranscoder/properties/DataProperties.cpp
+++ b/src/AvTranscoder/properties/DataProperties.cpp
@@ -13,8 +13,7 @@ namespace avtranscoder
 
 void DataProperties::detectAncillaryData()
 {
-    AVPacket pkt;
-    av_init_packet(&pkt);
+    AVPacket pkt = *av_packet_alloc();
 
     bool detection = false;
 
diff --git a/src/AvTranscoder/properties/FileProperties.cpp b/src/AvTranscoder/properties/FileProperties.cpp
index 6c135a7b..207850ac 100644
--- a/src/AvTranscoder/properties/FileProperties.cpp
+++ b/src/AvTranscoder/properties/FileProperties.cpp
@@ -47,7 +47,7 @@ void FileProperties::extractStreamProperties(IProgress& progress, const EAnalyse
     // reload properties
     for(size_t streamIndex = 0; streamIndex < _formatContext->getNbStreams(); ++streamIndex)
     {
-        switch(_formatContext->getAVStream(streamIndex).codec->codec_type)
+        switch(_formatContext->getAVStream(streamIndex).codecpar->codec_type)
         {
             case AVMEDIA_TYPE_VIDEO:
             {
@@ -139,9 +139,9 @@ void FileProperties::extractStreamProperties(IProgress& progress, const EAnalyse
 
 std::string FileProperties::getFilename() const
 {
-    if(!_avFormatContext || !_avFormatContext->filename)
+    if(!_avFormatContext || !_avFormatContext->url)
         throw std::runtime_error("unknown file name");
-    return _avFormatContext->filename;
+    return _avFormatContext->url;
 }
 
 std::string FileProperties::getFormatName() const
diff --git a/src/AvTranscoder/properties/PixelProperties.cpp b/src/AvTranscoder/properties/PixelProperties.cpp
index 9e58b298..48961d0a 100644
--- a/src/AvTranscoder/properties/PixelProperties.cpp
+++ b/src/AvTranscoder/properties/PixelProperties.cpp
@@ -204,12 +204,17 @@ bool PixelProperties::isRgbPixelData() const
     return (_pixelDesc->flags & AV_PIX_FMT_FLAG_RGB) == AV_PIX_FMT_FLAG_RGB;
 }
 
-bool PixelProperties::isPseudoPaletted() const
-{
-    if(!_pixelDesc)
+#if LIBAVCODEC_VERSION_MAJOR > 58
+bool PixelProperties::isPaletted() const {
+    if (!_pixelDesc)
+        throw std::runtime_error("unable to find pixel description.");
+
+    return (_pixelDesc->flags & AV_PIX_FMT_FLAG_PAL) == AV_PIX_FMT_FLAG_PAL;
+#elif LIBAVCODEC_VERSION_MAJOR > 53
+bool PixelProperties::isPseudoPaletted() const {
+    if (!_pixelDesc)
         throw std::runtime_error("unable to find pixel description.");
 
-#if LIBAVCODEC_VERSION_MAJOR > 53
     return (_pixelDesc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) == AV_PIX_FMT_FLAG_PSEUDOPAL;
 #else
     return false;
@@ -315,7 +320,11 @@ PropertyVector& PixelProperties::fillVector(PropertyVector& data) const
     addProperty(data, "bitWiseAcked", &PixelProperties::isBitWisePacked);
     addProperty(data, "isHardwareAccelerated", &PixelProperties::isHardwareAccelerated);
     addProperty(data, "rgbPixel", &PixelProperties::isRgbPixelData);
+#if LIBAVCODEC_VERSION_MAJOR > 58
+    addProperty(data, "isPaletted", &PixelProperties::isPaletted);
+#else
     addProperty(data, "isPseudoPaletted", &PixelProperties::isPseudoPaletted);
+#endif
 
     try
     {
diff --git a/src/AvTranscoder/properties/PixelProperties.hpp b/src/AvTranscoder/properties/PixelProperties.hpp
index 5e087ef2..b5ba672c 100644
--- a/src/AvTranscoder/properties/PixelProperties.hpp
+++ b/src/AvTranscoder/properties/PixelProperties.hpp
@@ -71,7 +71,11 @@ class AvExport PixelProperties
     bool isBitWisePacked() const;
     bool isHardwareAccelerated() const;
     bool isRgbPixelData() const;
+#if LIBAVCODEC_VERSION_MAJOR > 58
+    bool isPaletted() const;
+#else
     bool isPseudoPaletted() const;
+#endif
 
     std::vector<Channel> getChannels() const;
 
diff --git a/src/AvTranscoder/properties/StreamProperties.cpp b/src/AvTranscoder/properties/StreamProperties.cpp
index 2a860aeb..38a6be72 100644
--- a/src/AvTranscoder/properties/StreamProperties.cpp
+++ b/src/AvTranscoder/properties/StreamProperties.cpp
@@ -27,24 +27,24 @@ StreamProperties::StreamProperties(const FileProperties& fileProperties, const s
             ss << "Stream at index " << _streamIndex << " does not exist.";
             throw std::runtime_error(ss.str());
         }
-        _codecContext = _formatContext->streams[_streamIndex]->codec;
+
+        _codec = avcodec_find_decoder(_formatContext->streams[_streamIndex]->codecpar->codec_id);
+        _codecContext = avcodec_alloc_context3(_codec);
+
+        avcodec_parameters_to_context(_codecContext, _formatContext->streams[_streamIndex]->codecpar);
     }
 
     // find the decoder
-    if(_formatContext && _codecContext)
+    if(_formatContext && _codecContext && _codec)
     {
-        _codec = avcodec_find_decoder(_codecContext->codec_id);
-
-        if(_codec)
-        {
-            // load specific options of the codec
-            loadOptions(_options, _codecContext);
-        }
+        // load specific options of the codec
+        loadOptions(_options, _codecContext);
     }
 }
 
 StreamProperties::~StreamProperties()
 {
+    avcodec_free_context(&_codecContext);
 }
 
 size_t StreamProperties::getStreamId() const
@@ -67,7 +67,7 @@ float StreamProperties::getDuration() const
     const size_t duration = _formatContext->streams[_streamIndex]->duration;
     if(duration == (size_t)AV_NOPTS_VALUE)
     {
-        LOG_WARN("The duration of the stream '" << _streamIndex << "' of file '" << _formatContext->filename
+        LOG_WARN("The duration of the stream '" << _streamIndex << "' of file '" << _formatContext->url
                                                 << "' is unknown.")
         return 0;
     }
@@ -78,7 +78,7 @@ AVMediaType StreamProperties::getStreamType() const
 {
     if(!_formatContext)
         throw std::runtime_error("unknown format context");
-    return _formatContext->streams[_streamIndex]->codec->codec_type;
+    return _formatContext->streams[_streamIndex]->codecpar->codec_type;
 }
 
 size_t StreamProperties::getCodecId() const
diff --git a/src/AvTranscoder/properties/StreamProperties.hpp b/src/AvTranscoder/properties/StreamProperties.hpp
index 2820119b..fca5ffab 100644
--- a/src/AvTranscoder/properties/StreamProperties.hpp
+++ b/src/AvTranscoder/properties/StreamProperties.hpp
@@ -71,7 +71,7 @@ class AvExport StreamProperties
     const FileProperties* _fileProperties; ///< Has link (no ownership)
     const AVFormatContext* _formatContext; ///< Has link (no ownership)
     AVCodecContext* _codecContext;         ///< Has link (no ownership)
-    AVCodec* _codec;                       ///< Has link (no ownership)
+    const AVCodec* _codec;                 ///< Has link (no ownership)
 
     size_t _streamIndex;
     PropertyVector _metadatas;
diff --git a/src/AvTranscoder/properties/VideoProperties.cpp b/src/AvTranscoder/properties/VideoProperties.cpp
index da9f5f39..e2ab5bbd 100644
--- a/src/AvTranscoder/properties/VideoProperties.cpp
+++ b/src/AvTranscoder/properties/VideoProperties.cpp
@@ -35,7 +35,7 @@ VideoProperties::VideoProperties(const FileProperties& fileProperties, const siz
     if(_codecContext)
     {
         _pixelProperties = PixelProperties(_codecContext->pix_fmt);
-        _firstGopTimeCode = _codecContext->timecode_frame_start;
+        _firstGopTimeCode = _formatContext->start_time;
     }
 
     switch(_levelAnalysis)
@@ -350,7 +350,7 @@ size_t VideoProperties::getBitRate() const
     // return bit rate of stream if present or VBR mode
     if(_codecContext->bit_rate || _codecContext->rc_max_rate)
         return _codecContext->bit_rate;
-    LOG_WARN("The bitrate of the stream '" << _streamIndex << "' of file '" << _formatContext->filename << "' is unknown.")
+    LOG_WARN("The bitrate of the stream '" << _streamIndex << "' of file '" << _formatContext->url << "' is unknown.")
 
     if(_levelAnalysis == eAnalyseLevelHeader)
     {
@@ -389,7 +389,7 @@ size_t VideoProperties::getNbFrames() const
     const size_t nbFrames = _formatContext->streams[_streamIndex]->nb_frames;
     if(nbFrames)
         return nbFrames;
-    LOG_WARN("The number of frames of the stream '" << _streamIndex << "' of file '" << _formatContext->filename
+    LOG_WARN("The number of frames of the stream '" << _streamIndex << "' of file '" << _formatContext->url
                                                     << "' is unknown.")
 
     if(_levelAnalysis == eAnalyseLevelHeader)
@@ -472,7 +472,7 @@ float VideoProperties::getDuration() const
     const float duration = StreamProperties::getDuration();
     if(duration != 0)
         return duration;
-    LOG_WARN("The duration of the stream '" << _streamIndex << "' of file '" << _formatContext->filename << "' is unknown.")
+    LOG_WARN("The duration of the stream '" << _streamIndex << "' of file '" << _formatContext->url << "' is unknown.")
 
     if(_levelAnalysis == eAnalyseLevelHeader)
     {
diff --git a/src/AvTranscoder/stream/InputStream.cpp b/src/AvTranscoder/stream/InputStream.cpp
index ece61cc3..31072a1c 100644
--- a/src/AvTranscoder/stream/InputStream.cpp
+++ b/src/AvTranscoder/stream/InputStream.cpp
@@ -21,7 +21,17 @@ InputStream::InputStream(InputFile& inputFile, const size_t streamIndex)
     , _streamIndex(streamIndex)
     , _isActivated(false)
 {
-    AVCodecContext* context = _inputFile->getFormatContext().getAVStream(_streamIndex).codec;
+    AVStream& avStream = _inputFile->getFormatContext().getAVStream(_streamIndex);
+    AVCodecParameters* codecParameters = avStream.codecpar;
+
+    const AVCodec* codec = avcodec_find_decoder(codecParameters->codec_id);
+    AVCodecContext* context = avcodec_alloc_context3(codec);
+
+    int ret = avcodec_parameters_to_context(context, codecParameters);
+    context->time_base = avStream.time_base;
+
+    if (ret < 0)
+        throw std::runtime_error("Failed to copy decoder parameters to input stream context");
 
     switch(context->codec_type)
     {
diff --git a/src/AvTranscoder/stream/OutputStream.cpp b/src/AvTranscoder/stream/OutputStream.cpp
index 0c47d004..92034dc6 100644
--- a/src/AvTranscoder/stream/OutputStream.cpp
+++ b/src/AvTranscoder/stream/OutputStream.cpp
@@ -11,11 +11,37 @@ OutputStream::OutputStream(OutputFile& outputFile, const size_t streamIndex)
     : IOutputStream()
     , _outputFile(outputFile)
     , _outputAVStream(outputFile.getFormatContext().getAVStream(streamIndex))
+    , _codecContext()
     , _streamIndex(streamIndex)
     , _wrappedPacketsDuration(0)
     , _lastWrappedPacketDuration(0)
     , _isPTSGenerated(false)
 {
+    const AVCodec* codec = avcodec_find_encoder(_outputAVStream.codecpar->codec_id);
+    _codecContext = avcodec_alloc_context3(codec);
+
+    int ret = avcodec_parameters_to_context(_codecContext, _outputAVStream.codecpar);
+    if (ret < 0)
+        throw std::runtime_error("Failed to copy encoder parameters to output stream context");
+
+#if LIBAVCODEC_VERSION_MAJOR > 58
+    // depending on the format, place global headers in extradata instead of every keyframe
+#ifdef AV_CODEC_FLAG_GLOBAL_HEADER
+    if(_outputFile.getFormatContext().getAVOutputFormat().flags & AVFMT_GLOBALHEADER)
+    {
+        _codecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+    }
+#endif
+
+    // if the codec is experimental, allow it
+#ifdef AV_CODEC_CAP_EXPERIMENTAL
+    if(codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
+    {
+        LOG_WARN("This codec is considered experimental by libav/ffmpeg:" << codec->name);
+        _codecContext->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
+    }
+#endif
+#endif
 }
 
 float OutputStream::getStreamDuration() const
@@ -73,7 +99,7 @@ IOutputStream::EWrappingStatus OutputStream::wrap(const CodedData& data)
         _wrappedPacketsDuration += data.getAVPacket().duration;
     else
     {
-        switch(_outputAVStream.codec->codec_type)
+        switch(_outputAVStream.codecpar->codec_type)
         {
             case AVMEDIA_TYPE_VIDEO:
             {
@@ -85,14 +111,13 @@ IOutputStream::EWrappingStatus OutputStream::wrap(const CodedData& data)
                 Rational audioPacketDuration;
                 audioPacketDuration.num = 0;
                 audioPacketDuration.den = 0;
-                const int frame_size = av_get_audio_frame_duration(_outputAVStream.codec, data.getSize());
-                if(frame_size <= 0 || _outputAVStream.codec->sample_rate <= 0)
+                const int frame_size = av_get_audio_frame_duration(_codecContext, data.getSize());
+                if (frame_size <= 0 || _outputAVStream.codecpar->sample_rate <= 0)
                     break;
                 audioPacketDuration.num = frame_size;
-                audioPacketDuration.den = _outputAVStream.codec->sample_rate;
-                _wrappedPacketsDuration += av_rescale(1, audioPacketDuration.num * (int64_t)_outputAVStream.time_base.den *
-                                                             _outputAVStream.codec->ticks_per_frame,
-                                                      audioPacketDuration.den * (int64_t)_outputAVStream.time_base.num);
+                audioPacketDuration.den = _outputAVStream.codecpar->sample_rate;
+                _wrappedPacketsDuration += av_rescale(1, audioPacketDuration.num * (int64_t) _outputAVStream.time_base.den * _codecContext->ticks_per_frame,
+                                                      audioPacketDuration.den * (int64_t) _outputAVStream.time_base.num);
                 break;
             }
             default:
diff --git a/src/AvTranscoder/stream/OutputStream.hpp b/src/AvTranscoder/stream/OutputStream.hpp
index 4b2b3a48..b896edb7 100644
--- a/src/AvTranscoder/stream/OutputStream.hpp
+++ b/src/AvTranscoder/stream/OutputStream.hpp
@@ -26,6 +26,7 @@ class AvExport OutputStream : public IOutputStream
 private:
     OutputFile& _outputFile;         ///< Has link (no ownership)
     const AVStream& _outputAVStream; ///< Has link (no ownership)
+    AVCodecContext* _codecContext;
 
     size_t _streamIndex; ///<  Index of the stream in the output file
 
diff --git a/src/AvTranscoder/transcoder/Transcoder.cpp b/src/AvTranscoder/transcoder/Transcoder.cpp
index eb9895ed..0d578fff 100644
--- a/src/AvTranscoder/transcoder/Transcoder.cpp
+++ b/src/AvTranscoder/transcoder/Transcoder.cpp
@@ -217,6 +217,8 @@ bool Transcoder::processFrame(IProgress& progress, const size_t& streamIndex)
                 LOG_INFO("End of process because the main stream at index " << _mainStreamIndex << " failed to process a new frame.")
 
             return false;
+        default:
+            throw std::runtime_error("Unsupported wrapping status");
     }
 }
 
@@ -658,13 +660,35 @@ void Transcoder::fillProcessStat(ProcessStat& processStat)
                     const AVCodecContext& encoderContext = encoder->getCodec().getAVCodecContext();
 
 #ifdef AV_CODEC_FLAG_PSNR
-                    if(encoderContext.coded_frame && (encoderContext.flags & AV_CODEC_FLAG_PSNR))
+                    if(encoderContext.coded_side_data && encoderContext.coded_side_data->type == AV_PKT_DATA_QUALITY_FACTOR && (encoderContext.flags & AV_CODEC_FLAG_PSNR))
 #else
                     if(encoderContext.coded_frame && (encoderContext.flags & CODEC_FLAG_PSNR))
 #endif
                     {
-                        videoStat.setQuality(encoderContext.coded_frame->quality);
-                        videoStat.setPSNR(encoderContext.coded_frame->error[0] /
+                        uint8_t* coded_frame = encoderContext.coded_side_data->data;
+                        uint32_t quality = (uint32_t) coded_frame[3] << 24 |
+                                           (uint32_t) coded_frame[2] << 16 |
+                                           (uint32_t) coded_frame[1] << 8 |
+                                           (uint32_t) coded_frame[0];
+                        // uint8_t picture_type = coded_frame[4];
+                        uint8_t error_count = coded_frame[5];
+
+                        uint64_t errors[error_count];
+                        for (int i = 0; i < error_count; ++i)
+                        {
+                            int index = 6 + i;
+                            errors[i] = (uint64_t) coded_frame[index + 7] << 56 |
+                                        (uint64_t) coded_frame[index + 6] << 48 |
+                                        (uint64_t) coded_frame[index + 5] << 40 |
+                                        (uint64_t) coded_frame[index + 4] << 32 |
+                                        (uint64_t) coded_frame[index + 3] << 24 |
+                                        (uint64_t) coded_frame[2] << 16 |
+                                        (uint64_t) coded_frame[1] << 8 |
+                                        (uint64_t) coded_frame[0];
+                        }
+
+                        videoStat.setQuality(quality);
+                        videoStat.setPSNR((double) errors[0] /
                                           (encoderContext.width * encoderContext.height * 255.0 * 255.0));
                     }
                 }