Recherche avancée
Autres articles (37)
-
La file d’attente de SPIPmotion
28 novembre 2010, parUne file d’attente stockée dans la base de donnée
Lors de son installation, SPIPmotion crée une nouvelle table dans la base de donnée intitulée spip_spipmotion_attentes.
Cette nouvelle table est constituée des champs suivants : id_spipmotion_attente, l’identifiant numérique unique de la tâche à traiter ; id_document, l’identifiant numérique du document original à encoder ; id_objet l’identifiant unique de l’objet auquel le document encodé devra être attaché automatiquement ; objet, le type d’objet auquel (...) -
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir -
Demande de création d’un canal
12 mars 2010, parEn fonction de la configuration de la plateforme, l’utilisateur peu avoir à sa disposition deux méthodes différentes de demande de création de canal. La première est au moment de son inscription, la seconde, après son inscription en remplissant un formulaire de demande.
Les deux manières demandent les mêmes choses fonctionnent à peu près de la même manière, le futur utilisateur doit remplir une série de champ de formulaire permettant tout d’abord aux administrateurs d’avoir des informations quant à (...)
Sur d’autres sites (6039)
-
Decoding an MKA audio file into raw data (MKA Audio to raw audio data)
9 octobre 2020, par bbddMy task is to open an existing audio file with the
mkaextension (Matroska container) and extract the raw audio data. This example shows only an example of extracting raw data from anmp2file. I do not know how to do this with themkacontainer. I would like to have something like this :

UPD


I found an option to save audio data in the format in which it was recorded in the audio file. An example is shown below.


PS. This is only a test version and most likely there are memory leaks and other problems.



#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;
}

</qdebug></qfile>

audiodecoder.h


class AudioDecoder {
public:
 AudioDecoder(const QString& fileName);
 AudioDecoder& operator=(const AudioDecoder& rhs) = delete;
 AudioDecoder& operator=(AudioDecoder&& rhs) = delete;
 AudioDecoder(const AudioDecoder& rhs) = delete;
 AudioDecoder(AudioDecoder&& rhs) = delete;
 virtual ~AudioDecoder(void);

 virtual bool start(void) noexcept;
 virtual QByteArray getData(const quint16& 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 QString& fileName)
 : m_initialized(false)
 , m_fileName(fileName)
 , p_cdcCtx(nullptr)
 , p_frmCtx(nullptr)
{
 av_register_all();
}

QByteArray AudioDecoder::getData(const quint16& 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(&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(&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(&p_frmCtx);
 qDebug() << __LINE__;
 return false;
 }

 if (p_frmCtx->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
 avformat_close_input(&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(&p_frmCtx);
 qDebug() << __LINE__;
 return false;
 }
 // Allocate a new decoding context.
 AVCodecContext* avctx = avcodec_alloc_context3(input_codec);
 if (!avctx) {
 avformat_close_input(&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(&p_frmCtx);
 avcodec_free_context(&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(&avctx);
 avformat_close_input(&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(&p_cdcCtx);
 }
 if (p_frmCtx != nullptr) {
 avformat_close_input(&p_frmCtx);
 }
 return true;
}

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


But the problem in this example is that I didn't implement the ability to get exactly the requested size of audio data. In my case, it's just ignored.


-
Revision 33976 : bugs html
27 décembre 2009, par cedric@… — Logbugs html
-
Revision 29928 : On réutilise l’ancien code pour débuter notre branche
17 juillet 2009, par kent1@… — LogOn réutilise l’ancien code pour débuter notre branche
Syndiquer tout le site
