Блог

Моя задача — открыть существующий аудиофайл с mka расширением (контейнер Matroska) и извлечь необработанные аудиоданные. В этом примере показан только пример извлечения необработанных данных из mp2 файла. Я не знаю, как это сделать с mka контейнером. Я хотел бы иметь что-то вроде этого:

UPD

Я нашел возможность сохранять аудиоданные в том формате, в котором они были записаны в аудиофайле. Пример показан ниже.

PS. Это только тестовая версия, и, скорее всего, есть утечки памяти и другие проблемы.

 
#include <QFile>
#include <QDebug>
#include "audiodecoder.h"

int main(int argc, char* argv[])
{
    AudioDecoder decoder("/home/test/test.mka");
    bool started = decoder.start();
    if (!started) {
        return EXIT_FAILURE;
    }

    QFile file("/home/test/rawData.bin");
    file.open(QIODevice::WriteOnly);

    while (true) {
        auto data = decoder.getData(255);
        if (data.isEmpty()) {
            break;
        }
        file.write(data.data(), data.size());
    }
    file.close();
    return EXIT_SUCCESS;
}

  

audiodecoder.h

 class AudioDecoder {
public:
    AudioDecoder(const QStringamp; fileName);
    AudioDecoderamp; operator=(const AudioDecoderamp; rhs) = delete;
    AudioDecoderamp; operator=(AudioDecoderamp;amp; rhs) = delete;
    AudioDecoder(const AudioDecoderamp; rhs) = delete;
    AudioDecoder(AudioDecoderamp;amp; rhs) = delete;
    virtual ~AudioDecoder(void);

    virtual bool start(void) noexcept;
    virtual QByteArray getData(const quint16amp; size) noexcept;
    virtual bool stop(void) noexcept;

protected:
    bool m_initialized;
    QString m_fileName;

    AVFrame* p_frame = nullptr;
    AVPacket* p_packet = nullptr;
    AVCodecContext* p_cdcCtx = nullptr;
    AVFormatContext* p_frmCtx = nullptr;
};
  

audiodecoder.cpp

 
static void logging(const char* message)
{
    qDebug() << message;
}

AudioDecoder::AudioDecoder(const QStringamp; fileName)
    : m_initialized(false)
    , m_fileName(fileName)
    , p_cdcCtx(nullptr)
    , p_frmCtx(nullptr)
{
    av_register_all();
}

QByteArray AudioDecoder::getData(const quint16amp; dataSize) noexcept
{
    QByteArray data;
    qint32 response = 0;
    if (av_read_frame(p_frmCtx, p_packet) >= 0) {
        //logging(QString("AVPacket->pts %1").arg(p_packet->pts).toStdString().c_str());
        //response = decode_packet(p_packet, p_cdcCtx, p_frame);
        response = avcodec_send_packet(p_cdcCtx, p_packet);
        if (response < 0) {
            logging("Error while sending a packet to the decoder");
            return {};
        }
        while (response >= 0) {
            response = avcodec_receive_frame(p_cdcCtx, p_frame);
            if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
                break;
            }
            else if (response < 0) {
                logging("Error while receiving a frame from the decoder");
                return {};
            }
            if (response >= 0) {
                logging(QString("Frame %1 (type=%2, size=%3 bytes) pts %4 key_frame %5 [DTS %6], duration[%7]")
                            .arg(p_cdcCtx->frame_number)
                            .arg(av_get_picture_type_char(p_frame->pict_type))
                            .arg(p_frame->pkt_size)
                            .arg(p_frame->pts)
                            .arg(p_frame->key_frame)
                            .arg(p_frame->coded_picture_number)
                            .arg(p_frame->pkt_duration)
                            .toStdString()
                            .c_str());

                for (int i = 0; i < p_frame->linesize[0];   i) {
                    data.push_back(p_frame->data[0][i]);
                }
            }
        }
        av_packet_unref(p_packet);
        return data;
    }
    return {};
}

bool AudioDecoder::start(void) noexcept
{
    if (m_initialized) {
        return true;
    }

    int error;
    // Open the input file to read from it.
    if ((error = avformat_open_input(amp;p_frmCtx,
             m_fileName.toStdString().c_str(), nullptr, nullptr))
        < 0) {
        qDebug() << "Could not open input file: " << m_fileName;
        p_frmCtx = nullptr;
        return false;
    }
    // Get information on the input file (number of streams etc.).
    if ((error = avformat_find_stream_info(p_frmCtx, nullptr)) < 0) {
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }
    // Make sure that there is only one stream in the input file.
    if ((p_frmCtx)->nb_streams != 1) {
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }

    if (p_frmCtx->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }

    // Find a decoder for the audio stream.
    AVCodec* input_codec = nullptr;
    if (!(input_codec = avcodec_find_decoder((p_frmCtx)->streams[0]->codecpar->codec_id))) {
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }
    // Allocate a new decoding context.
    AVCodecContext* avctx = avcodec_alloc_context3(input_codec);
    if (!avctx) {
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }
    // Initialize the stream parameters with demuxer information.
    error = avcodec_parameters_to_context(avctx, (p_frmCtx)->streams[0]->codecpar);
    if (error < 0) {
        avformat_close_input(amp;p_frmCtx);
        avcodec_free_context(amp;avctx);
        qDebug() << __LINE__;
        return false;
    }
    /* Open the decoder for the audio stream to use it later. */
    if ((error = avcodec_open2(avctx, input_codec, NULL)) < 0) {
        avcodec_free_context(amp;avctx);
        avformat_close_input(amp;p_frmCtx);
        qDebug() << __LINE__;
        return false;
    }
    /* Save the decoder context for easier access later. */
    p_cdcCtx = avctx;
    av_dump_format(p_frmCtx, 0, m_fileName.toStdString().c_str(), 0);

    p_frame = av_frame_alloc();
    if (!p_frame) {
        logging("failed to allocated memory for AVFrame");
        return false;
    }
    p_packet = av_packet_alloc();
    if (!p_packet) {
        logging("failed to allocated memory for AVPacket");
        return false;
    }
    return m_initialized = true;
}

bool AudioDecoder::stop(void) noexcept
{
    if (p_cdcCtx != nullptr) {
        avcodec_free_context(amp;p_cdcCtx);
    }
    if (p_frmCtx != nullptr) {
        avformat_close_input(amp;p_frmCtx);
    }
    return true;
}

AudioDecoder::~AudioDecoder(void)
{
    stop();
}
  

Но проблема в этом примере заключается в том, что я не реализовал возможность получения точно запрошенного размера аудиоданных. В моем случае это просто игнорируется.

Если вы хотите извлечь аудиоданные, закодированные в формате, в котором вы их получаете из аудиофайла, вам следует просмотреть этот пример. В этом примере вам нужно будет изменить тип вывода с acc на alaw . Сжатый поток будет находиться в AVPacket::buf:

Ссылка на буфер с подсчетом ссылок, в котором хранятся пакетные данные.

Я также рекомендую просмотреть эту статью. Это поможет вам 🙂