legacy ffmpeg support

git-svn-id: http://svn.code.sf.net/p/qmmp-dev/code/trunk/qmmp@2539 90c681e8-e032-0410-971d-27865f9a5e38

7 files changed, 500 insertions, 16 deletions

diff --git a/src/plugins/Input/ffmpeg/CMakeLists.txt b/src/plugins/Input/ffmpeg/CMakeLists.txt
index 47fa78ef3..0122c5137 100644
--- a/src/plugins/Input/ffmpeg/CMakeLists.txt
+++ b/src/plugins/Input/ffmpeg/CMakeLists.txt
@@ -28,7 +28,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../../)
 link_directories(${CMAKE_CURRENT_BINARY_DIR}/../../../qmmp)
 
 # ffmpeg
-pkg_check_modules(FFMPEG libavcodec>=53.42.4 libavformat>=53.24.2 libavutil>=51.32.0)
+pkg_check_modules(FFMPEG libavcodec>=52.72.2 libavformat>=52.64.2 libavutil>=50.15.1)
 
 include_directories(${FFMPEG_INCLUDE_DIRS})
 link_directories(${FFMPEG_LIBRARY_DIRS})
diff --git a/src/plugins/Input/ffmpeg/decoder_ffmpeg.cpp b/src/plugins/Input/ffmpeg/decoder_ffmpeg.cpp
index 9d62be278..5d4b3f647 100644
--- a/src/plugins/Input/ffmpeg/decoder_ffmpeg.cpp
+++ b/src/plugins/Input/ffmpeg/decoder_ffmpeg.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2006-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2006-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -20,9 +20,6 @@
 
 #include <QObject>
 #include <QFile>
-#include <qmmp/buffer.h>
-#include <qmmp/output.h>
-#include <qmmp/recycler.h>
 #include "decoder_ffmpeg.h"
 
 // callbacks
@@ -61,6 +58,8 @@ static int64_t ffmpeg_seek(void *data, int64_t offset, int whence)
 
 // Decoder class
 
+#if (LIBAVCODEC_VERSION_INT >= ((53<<16)+(42<<8)+4))
+
 DecoderFFmpeg::DecoderFFmpeg(const QString &path, QIODevice *i)
         : Decoder(i)
 {
@@ -422,3 +421,349 @@ void DecoderFFmpeg::fillBuffer()
         }
     }
 }
+
+#else
+//legacy ffmpeg support
+DecoderFFmpeg::DecoderFFmpeg(const QString &path, QIODevice *i)
+        : Decoder(i)
+{
+    m_bitrate = 0;
+    m_skip = false;
+    m_totalTime = 0;
+    ic = 0;
+    m_path = path;
+    m_temp_pkt.size = 0;
+    m_pkt.size = 0;
+    m_pkt.data = 0;
+    m_output_buf = 0;
+    m_output_at = 0;
+    m_skipBytes = 0;
+    m_stream = 0;
+    av_init_packet(&m_pkt);
+    av_init_packet(&m_temp_pkt);
+}
+
+
+DecoderFFmpeg::~DecoderFFmpeg()
+{
+    m_bitrate = 0;
+    m_temp_pkt.size = 0;
+    if (ic)
+        av_close_input_stream(ic);
+   if(m_pkt.data)
+        av_free_packet(&m_pkt);
+    if(m_output_buf)
+        av_free(m_output_buf);
+    if(m_stream)
+        av_free(m_stream);
+}
+
+bool DecoderFFmpeg::initialize()
+{
+    m_bitrate = 0;
+    m_skip = false;
+    m_totalTime = 0;
+    m_seekTime = -1;
+    av_register_all();
+
+    AVProbeData  pd;
+    uint8_t buf[PROBE_BUFFER_SIZE + AVPROBE_PADDING_SIZE];
+    pd.filename = m_path.toLocal8Bit().constData();
+    pd.buf_size = input()->peek((char*)buf, sizeof(buf) - AVPROBE_PADDING_SIZE);
+    pd.buf = buf;
+    if(pd.buf_size < PROBE_BUFFER_SIZE)
+    {
+        qWarning("DecoderFFmpeg: too small buffer size: %d bytes", pd.buf_size);
+        return false;
+    }
+    AVInputFormat *fmt = av_probe_input_format(&pd, 1);
+    if(!fmt)
+    {
+        qWarning("DecoderFFmpeg: usupported format");
+        return false;
+    }
+    qDebug("DecoderFFmpeg: detected format: %s", fmt->long_name);
+    qDebug("=%s=", fmt->name);
+
+#if (LIBAVFORMAT_VERSION_INT >= ((52<<16)+(105<<8)+0))
+    m_stream = avio_alloc_context(m_input_buf, INPUT_BUFFER_SIZE, 0, this, ffmpeg_read, NULL, ffmpeg_seek);
+    if(!m_stream)
+    {
+        qWarning("DecoderFFmpeg: unable to initialize I/O callbacks");
+        return false;
+    }
+    m_stream->seekable = !input()->isSequential();
+#else
+    m_stream = (ByteIOContext *)av_malloc(sizeof(ByteIOContext));
+    init_put_byte(m_stream, m_input_buf, INPUT_BUFFER_SIZE, 0, this, ffmpeg_read, NULL, ffmpeg_seek);
+    m_stream->is_streamed = input()->isSequential();
+#endif
+    m_stream->max_packet_size = INPUT_BUFFER_SIZE;
+
+    AVFormatParameters ap;
+    memset(&ap, 0, sizeof(ap));
+
+    if(av_open_input_stream(&ic, m_stream, m_path.toLocal8Bit(), fmt, &ap) != 0)
+    {
+        qDebug("DecoderFFmpeg: av_open_input_stream() failed");
+        return false;
+    }
+    av_find_stream_info(ic);
+    if(ic->pb)
+        ic->pb->eof_reached = 0;
+
+    if (input()->isSequential())
+    {
+        QMap<Qmmp::MetaData, QString> metaData;
+        AVMetadataTag *album = av_metadata_get(ic->metadata,"album",0,0);
+        if(!album)
+            album = av_metadata_get(ic->metadata,"WM/AlbumTitle",0,0);
+        AVMetadataTag *artist = av_metadata_get(ic->metadata,"artist",0,0);
+        if(!artist)
+            artist = av_metadata_get(ic->metadata,"author",0,0);
+        AVMetadataTag *comment = av_metadata_get(ic->metadata,"comment",0,0);
+        AVMetadataTag *genre = av_metadata_get(ic->metadata,"genre",0,0);
+        AVMetadataTag *title = av_metadata_get(ic->metadata,"title",0,0);
+        AVMetadataTag *year = av_metadata_get(ic->metadata,"WM/Year",0,0);
+        if(!year)
+            year = av_metadata_get(ic->metadata,"year",0,0);
+        if(!year)
+            year = av_metadata_get(ic->metadata,"date",0,0);
+        AVMetadataTag *track = av_metadata_get(ic->metadata,"track",0,0);
+        if(!track)
+            track = av_metadata_get(ic->metadata,"WM/Track",0,0);
+        if(!track)
+            track = av_metadata_get(ic->metadata,"WM/TrackNumber",0,0);
+
+        if(album)
+            metaData.insert(Qmmp::ALBUM, QString::fromUtf8(album->value).trimmed());
+        if(artist)
+            metaData.insert(Qmmp::ARTIST, QString::fromUtf8(artist->value).trimmed());
+        if(comment)
+            metaData.insert(Qmmp::COMMENT, QString::fromUtf8(comment->value).trimmed());
+        if(genre)
+            metaData.insert(Qmmp::GENRE, QString::fromUtf8(genre->value).trimmed());
+        if(title)
+            metaData.insert(Qmmp::TITLE, QString::fromUtf8(title->value).trimmed());
+        if(year)
+            metaData.insert(Qmmp::YEAR, year->value);
+        if(track)
+            metaData.insert(Qmmp::TRACK, track->value);
+        metaData.insert(Qmmp::URL, m_path);
+        addMetaData(metaData);
+    }
+
+    ic->flags |= AVFMT_FLAG_GENPTS;
+    av_read_play(ic);
+    for (wma_idx = 0; wma_idx < (int)ic->nb_streams; wma_idx++)
+    {
+        c = ic->streams[wma_idx]->codec;
+#if LIBAVCODEC_VERSION_MAJOR < 53
+        if (c->codec_type == CODEC_TYPE_AUDIO)
+#else
+        if (c->codec_type == AVMEDIA_TYPE_AUDIO)
+#endif
+            break;
+    }
+
+    if (c->channels > 0)
+         c->request_channels = qMin(2, c->channels);
+    else
+         c->request_channels = 2;
+
+#if (LIBAVCODEC_VERSION_INT >= ((52<<16)+(101<<8)+0))
+    av_dump_format(ic,0,0,0);
+#else
+    dump_format(ic,0,0,0);
+#endif
+    AVCodec *codec = avcodec_find_decoder(c->codec_id);
+
+    if (!codec)
+    {
+        qWarning("DecoderFFmpeg: unsupported codec for output stream");
+        return false;
+    }
+
+    if (avcodec_open(c, codec) < 0)
+    {
+        qWarning("DecoderFFmpeg: error while opening codec for output stream");
+        return false;
+    }
+
+    m_totalTime = input()->isSequential() ? 0 : ic->duration * 1000 / AV_TIME_BASE;
+    m_output_buf = (uint8_t *)av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE*2);
+
+#if (LIBAVCODEC_VERSION_INT >= ((52<<16)+(20<<8)+0))
+    if(c->codec_id == CODEC_ID_SHORTEN) //ffmpeg bug workaround
+        m_totalTime = 0;
+#endif
+
+#if (LIBAVUTIL_VERSION_INT >= ((50<<16)+(38<<8)+0))
+    if(c->sample_fmt == AV_SAMPLE_FMT_S32)
+        configure(c->sample_rate, c->request_channels, Qmmp::PCM_S32LE);
+    else
+        configure(c->sample_rate, c->request_channels, Qmmp::PCM_S16LE);
+#else
+    if(c->sample_fmt == SAMPLE_FMT_S32)
+        configure(c->sample_rate, c->request_channels, Qmmp::PCM_S32LE);
+    else
+        configure(c->sample_rate, c->request_channels, Qmmp::PCM_S16LE);
+#endif
+    if(ic->bit_rate)
+        m_bitrate = ic->bit_rate/1000;
+    if(c->bit_rate)
+        m_bitrate = c->bit_rate/1000;
+    qDebug("DecoderFFmpeg: initialize succes");
+    return true;
+}
+
+
+qint64 DecoderFFmpeg::totalTime()
+{
+    return m_totalTime;
+}
+
+int DecoderFFmpeg::bitrate()
+{
+    return m_bitrate;
+}
+
+qint64 DecoderFFmpeg::read(char *audio, qint64 maxSize)
+{
+    m_skipBytes = 0;
+    if (m_skip)
+    {
+        while(m_temp_pkt.size)
+            ffmpeg_decode(m_output_buf);
+        m_output_at = 0;
+        m_skip = false;
+    }
+    if(!m_output_at)
+        fillBuffer();
+    if(!m_output_at)
+        return 0;
+    qint64 len = qMin(m_output_at, maxSize);
+    memcpy(audio, m_output_buf, len);
+    m_output_at -= len;
+    memmove(m_output_buf, m_output_buf + len, m_output_at);
+    return len;
+}
+
+qint64 DecoderFFmpeg::ffmpeg_decode(uint8_t *audio)
+{
+    int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE * 2;
+    if((m_pkt.stream_index == wma_idx))
+    {
+#if (LIBAVCODEC_VERSION_INT >= ((52<<16)+(23<<8)+0))
+        int l = avcodec_decode_audio3(c, (int16_t *)(audio), &out_size, &m_temp_pkt);
+#else
+        int l = avcodec_decode_audio2(c, (int16_t *)(audio), &out_size, m_temp_pkt.data, m_temp_pkt.size);
+#endif
+        if(c->bit_rate)
+            m_bitrate = c->bit_rate/1000;
+        if(l < 0)
+            return l;
+        m_temp_pkt.data += l;
+        m_temp_pkt.size -= l;
+    }
+    if (!m_temp_pkt.size && m_pkt.data)
+        av_free_packet(&m_pkt);
+
+    return out_size;
+}
+
+void DecoderFFmpeg::seek(qint64 pos)
+{
+   int64_t timestamp = int64_t(pos)*AV_TIME_BASE/1000;
+    if (ic->start_time != (qint64)AV_NOPTS_VALUE)
+        timestamp += ic->start_time;
+    m_seekTime = timestamp;
+    av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
+    if(m_pkt.size)
+        m_skip = true;
+}
+
+void DecoderFFmpeg::fillBuffer()
+{
+    while(!m_output_at)
+    {
+        if(!m_temp_pkt.size)
+        {
+            if (av_read_frame(ic, &m_pkt) < 0)
+            {
+                m_temp_pkt.size = 0;
+                break;
+            }
+            m_temp_pkt.size = m_pkt.size;
+            m_temp_pkt.data = m_pkt.data;
+
+            if(m_pkt.stream_index != wma_idx)
+            {
+                if(m_pkt.data)
+                    av_free_packet(&m_pkt);
+                m_temp_pkt.size = 0;
+                continue;
+            }
+            if(m_seekTime && c->codec_id == CODEC_ID_APE)
+            {
+                int64_t rescaledPts = av_rescale(m_pkt.pts,
+                                                 AV_TIME_BASE * (int64_t)
+                                                 ic->streams[m_pkt.stream_index]->time_base.num,
+                                                 ic->streams[m_pkt.stream_index]->time_base.den);
+                m_skipBytes =  (m_seekTime - rescaledPts) * c->sample_rate * 4 / AV_TIME_BASE;
+            }
+            else
+                m_skipBytes = 0;
+            m_seekTime = 0;
+        }
+
+        if(m_skipBytes > 0 && c->codec_id == CODEC_ID_APE)
+        {
+            while (m_skipBytes > 0)
+            {
+                m_output_at = ffmpeg_decode(m_output_buf);
+                if(m_output_at < 0)
+                    break;
+                m_skipBytes -= m_output_at;
+            }
+
+            if(m_skipBytes < 0)
+            {
+                qint64 size = m_output_at;
+                m_output_at = - m_skipBytes;
+                m_output_at = m_output_at/4*4;
+                memmove(m_output_buf, (m_output_buf + size - m_output_at), m_output_at);
+                m_skipBytes = 0;
+            }
+        }
+        else
+            m_output_at = ffmpeg_decode(m_output_buf);
+
+        if(m_output_at < 0)
+        {
+            m_output_at = 0;
+            m_temp_pkt.size = 0;
+
+            if(c->codec_id == CODEC_ID_SHORTEN)
+            {
+                if(m_pkt.data)
+                    av_free_packet(&m_pkt);
+                m_pkt.data = 0;
+                break;
+            }
+            continue;
+        }
+        else if(m_output_at == 0)
+        {
+            if(c->codec_id == CODEC_ID_SHORTEN)
+                continue;
+
+            if(m_pkt.data)
+                av_free_packet(&m_pkt);
+            m_pkt.data = 0;
+            break;
+        }
+    }
+}
+
+#endif
diff --git a/src/plugins/Input/ffmpeg/decoder_ffmpeg.h b/src/plugins/Input/ffmpeg/decoder_ffmpeg.h
index 4c87fc291..ee1be2871 100644
--- a/src/plugins/Input/ffmpeg/decoder_ffmpeg.h
+++ b/src/plugins/Input/ffmpeg/decoder_ffmpeg.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2006-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2006-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -25,8 +25,12 @@ extern "C"{
 #include <libavformat/avformat.h>
 #include <libavcodec/avcodec.h>
 #include <libavutil/mathematics.h>
+#if (LIBAVUTIL_VERSION_INT >= ((51<<16)+(32<<8)+0))
 #include <libavutil/dict.h>
+#endif
 }
+
+
 #include <qmmp/decoder.h>
 
 #define PROBE_BUFFER_SIZE 8192
@@ -48,26 +52,40 @@ public:
 private:
     //helper functions
     void fillBuffer();
-    qint64 ffmpeg_decode();
 
     AVFormatContext *ic;
     AVCodecContext *c;
+
     uint wma_st_buff, wma_idx2;
     int m_bitrate, wma_idx;
+
     QString m_path;
     qint64 m_totalTime;
-
     AVPacket m_pkt;
     AVPacket m_temp_pkt;
+    qint64 m_output_at;
+    uchar m_input_buf[INPUT_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+    int64_t m_seekTime;
+    qint64  m_skipBytes;
 
+#if (LIBAVCODEC_VERSION_INT >= ((53<<16)+(42<<8)+4))
+    qint64 ffmpeg_decode();
     AVIOContext *m_stream;
     AVFrame *m_decoded_frame;
 
-    qint64 m_output_at;
-    uchar m_input_buf[INPUT_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+#else
+    qint64 ffmpeg_decode(uint8_t *audio);
+    bool m_skip;
 
-    int64_t m_seekTime;
-    qint64  m_skipBytes;
+#if (LIBAVCODEC_VERSION_INT >= ((52<<16)+(102<<8)+0))
+    AVIOContext *m_stream;
+#else
+    ByteIOContext *m_stream;
+#endif
+
+    uint8_t *m_output_buf;
+
+#endif
 };
 
 
diff --git a/src/plugins/Input/ffmpeg/decoderffmpegfactory.cpp b/src/plugins/Input/ffmpeg/decoderffmpegfactory.cpp
index 93cc4566b..63e291ab0 100644
--- a/src/plugins/Input/ffmpeg/decoderffmpegfactory.cpp
+++ b/src/plugins/Input/ffmpeg/decoderffmpegfactory.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2008-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2008-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -24,7 +24,9 @@
 extern "C"{
 #include <libavformat/avformat.h>
 #include <libavcodec/avcodec.h>
+#if (LIBAVUTIL_VERSION_INT >= ((51<<16)+(32<<8)+0))
 #include <libavutil/dict.h>
+#endif
 }
 
 #include "ffmpegmetadatamodel.h"
@@ -125,6 +127,7 @@ Decoder *DecoderFFmpegFactory::create(const QString &path, QIODevice *input)
 
 QList<FileInfo *> DecoderFFmpegFactory::createPlayList(const QString &fileName, bool useMetaData)
 {
+#if (LIBAVCODEC_VERSION_INT >= ((53<<16)+(42<<8)+4))
     QList <FileInfo*> list;
     avcodec_register_all();
     avformat_network_init();
@@ -178,6 +181,61 @@ QList<FileInfo *> DecoderFFmpegFactory::createPlayList(const QString &fileName,
     }
     info->setLength(in->duration/AV_TIME_BASE);
     avformat_close_input(&in);
+#else
+    QList <FileInfo*> list;
+    avcodec_init();
+    avcodec_register_all();
+    av_register_all();
+    AVFormatContext *in = 0;
+
+    if (av_open_input_file(&in, fileName.toLocal8Bit(), 0, 0, 0) < 0)
+    {
+        qDebug("DecoderFFmpegFactory: unable to open file");
+        return list;
+    }
+    FileInfo *info = new FileInfo(fileName);
+    av_find_stream_info(in);
+
+    if (useMetaData)
+    {
+        AVMetadataTag *album = av_metadata_get(in->metadata,"album",0,0);
+        if(!album)
+            album = av_metadata_get(in->metadata,"WM/AlbumTitle",0,0);
+        AVMetadataTag *artist = av_metadata_get(in->metadata,"artist",0,0);
+        if(!artist)
+            artist = av_metadata_get(in->metadata,"author",0,0);
+        AVMetadataTag *comment = av_metadata_get(in->metadata,"comment",0,0);
+        AVMetadataTag *genre = av_metadata_get(in->metadata,"genre",0,0);
+        AVMetadataTag *title = av_metadata_get(in->metadata,"title",0,0);
+        AVMetadataTag *year = av_metadata_get(in->metadata,"WM/Year",0,0);
+        if(!year)
+            year = av_metadata_get(in->metadata,"year",0,0);
+        if(!year)
+            year = av_metadata_get(in->metadata,"date",0,0);
+        AVMetadataTag *track = av_metadata_get(in->metadata,"track",0,0);
+        if(!track)
+            track = av_metadata_get(in->metadata,"WM/Track",0,0);
+        if(!track)
+            track = av_metadata_get(in->metadata,"WM/TrackNumber",0,0);
+
+        if(album)
+            info->setMetaData(Qmmp::ALBUM, QString::fromUtf8(album->value).trimmed());
+        if(artist)
+            info->setMetaData(Qmmp::ARTIST, QString::fromUtf8(artist->value).trimmed());
+        if(comment)
+            info->setMetaData(Qmmp::COMMENT, QString::fromUtf8(comment->value).trimmed());
+        if(genre)
+            info->setMetaData(Qmmp::GENRE, QString::fromUtf8(genre->value).trimmed());
+        if(title)
+            info->setMetaData(Qmmp::TITLE, QString::fromUtf8(title->value).trimmed());
+        if(year)
+            info->setMetaData(Qmmp::YEAR, year->value);
+        if(track)
+            info->setMetaData(Qmmp::TRACK, track->value);
+    }
+    info->setLength(in->duration/AV_TIME_BASE);
+    av_close_input_file(in);
+#endif
     list << info;
     return list;
 }
diff --git a/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.cpp b/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.cpp
index c99a0b809..4205d0f7d 100644
--- a/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.cpp
+++ b/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2009-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2009-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -20,6 +20,8 @@
 
 #include "ffmpegmetadatamodel.h"
 
+#if (LIBAVCODEC_VERSION_INT >= ((53<<16)+(42<<8)+4))
+
 FFmpegMetaDataModel::FFmpegMetaDataModel(const QString &path, QObject *parent) : MetaDataModel(parent)
 {
     m_in = 0;
@@ -66,3 +68,56 @@ QHash<QString, QString> FFmpegMetaDataModel::audioProperties()
     }
     return ap;
 }
+
+#else
+
+FFmpegMetaDataModel::FFmpegMetaDataModel(const QString &path, QObject *parent) : MetaDataModel(parent)
+{
+    m_in = 0;
+    avcodec_init();
+    avcodec_register_all();
+    av_register_all();
+    if (av_open_input_file(&m_in, path.toLocal8Bit(), NULL,0, NULL) < 0)
+        return;
+    av_find_stream_info(m_in);
+    av_read_play(m_in);
+}
+
+FFmpegMetaDataModel::~FFmpegMetaDataModel()
+{
+    if(m_in)
+        av_close_input_file(m_in);
+}
+
+QHash<QString, QString> FFmpegMetaDataModel::audioProperties()
+{
+    QHash<QString, QString> ap;
+    if(!m_in)
+        return ap;
+    QString text = QString("%1").arg(int(m_in->duration/AV_TIME_BASE)/60);
+    text +=":"+QString("%1").arg(int(m_in->duration/AV_TIME_BASE)%60,2,10,QChar('0'));
+    ap.insert(tr("Length"), text);
+    ap.insert(tr("File size"),  QString("%1 ").arg(m_in->file_size/1024)+" "+tr("KB"));
+    ap.insert(tr("Bitrate"), QString("%1 "+tr("kbps")).arg(m_in->bit_rate/1000));
+
+    AVCodecContext *c = 0;
+    uint wma_idx;
+    for (wma_idx = 0; wma_idx < m_in->nb_streams; wma_idx++)
+    {
+        c = m_in->streams[wma_idx]->codec;
+#if LIBAVCODEC_VERSION_MAJOR < 53
+        if (c->codec_type == CODEC_TYPE_AUDIO)
+#else
+        if (c->codec_type == AVMEDIA_TYPE_AUDIO)
+#endif
+            break;
+    }
+    if (c)
+    {
+        ap.insert(tr("Sample rate"), QString("%1 " + tr("Hz")).arg(c->sample_rate));
+        ap.insert(tr("Channels"), QString("%1").arg(c->channels));
+    }
+    return ap;
+}
+
+#endif
diff --git a/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.h b/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.h
index da58afcd4..8acf13deb 100644
--- a/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.h
+++ b/src/plugins/Input/ffmpeg/ffmpegmetadatamodel.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2009-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2009-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -24,7 +24,9 @@
 extern "C"{
 #include <libavformat/avformat.h>
 #include <libavcodec/avcodec.h>
+#if (LIBAVUTIL_VERSION_INT >= ((51<<16)+(32<<8)+0))
 #include <libavutil/dict.h>
+#endif
 }
 
 #include <qmmp/metadatamodel.h>
diff --git a/src/plugins/Input/ffmpeg/settingsdialog.cpp b/src/plugins/Input/ffmpeg/settingsdialog.cpp
index 4100b8d77..1ca29fa7b 100644
--- a/src/plugins/Input/ffmpeg/settingsdialog.cpp
+++ b/src/plugins/Input/ffmpeg/settingsdialog.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2008-2011 by Ilya Kotov                                 *
+ *   Copyright (C) 2008-2012 by Ilya Kotov                                 *
  *   forkotov02@hotmail.ru                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -26,7 +26,9 @@
 extern "C"{
 #include <libavformat/avformat.h>
 #include <libavcodec/avcodec.h>
+#if (LIBAVUTIL_VERSION_INT >= ((51<<16)+(32<<8)+0))
 #include <libavutil/dict.h>
+#endif
 }
 #include "settingsdialog.h"
 
@@ -65,7 +67,11 @@ SettingsDialog::SettingsDialog(QWidget *parent)
     ui.mkaCheckBox->setEnabled(avcodec_find_decoder(CODEC_ID_TRUEHD));
     ui.mkaCheckBox->setChecked(filters.contains("*.mka") && avcodec_find_decoder(CODEC_ID_TRUEHD));
     ui.vqfCheckBox->setEnabled(avcodec_find_decoder(CODEC_ID_TWINVQ));
+#if (LIBAVCODEC_VERSION_INT >= ((53<<16)+(42<<8)+4))
     ui.vqfCheckBox->setChecked(filters.contains("*.vqf") && avcodec_find_decoder(CODEC_ID_TWINVQ));
+#else
+    ui.vqfCheckBox->hide();
+#endif
 }
 
 SettingsDialog::~SettingsDialog()