Recherche avancée
Médias (91)
-
DJ Z-trip - Victory Lap : The Obama Mix Pt. 2
15 septembre 2011
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Matmos - Action at a Distance
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
DJ Dolores - Oslodum 2004 (includes (cc) sample of “Oslodum” by Gilberto Gil)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Danger Mouse & Jemini - What U Sittin’ On ? (starring Cee Lo and Tha Alkaholiks)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Cornelius - Wataridori 2
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
The Rapture - Sister Saviour (Blackstrobe Remix)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
Sur d’autres sites (362)
-
Qt Open Source Product 2 - Vlc Demo [closed]
3 juin 2021, par cool codeⅠ. Preface


The previous work was made by the FFmpeg kernel, and FFmpeg is too powerful for many beginners to understand. There are also a lot of users only need a simple video stream can be played, do not need to be involved in the responsible decoding and transcoding, so VLC came in handy, it directly made FFMPEG deep encapsulation, to provide a friendly interface. There's an MPV that does the same thing, and MPV is even better than VLC in that it's just one library file, and it looks like it's packaged as a static library, unlike VLC, VLC comes with a bunch of dynamic library files and plug-in files.
Of course, the simplicity of VLC is that it only needs a few lines of code to start, so that beginners immediately see the effect is very important, very excited, you can more quickly carry out the next step of coding, experience the fun of coding.


Ⅱ. Code framework


#include "ffmpeg.h"

FFmpegThread::FFmpegThread(QObject *parent) : QThread(parent)
{
 setObjectName("FFmpegThread");
 stopped = false;
 isPlay = false;

 frameFinish = false;
 videoWidth = 0;
 videoHeight = 0;
 oldWidth = 0;
 oldHeight = 0;
 videoStreamIndex = -1;
 audioStreamIndex = -1;

 url = "rtsp://192.168.1.128:554/1";

 buffer = NULL;
 avPacket = NULL;
 avFrame = NULL;
 avFrame2 = NULL;
 avFrame3 = NULL;
 avFormatContext = NULL;
 videoCodec = NULL;
 audioCodec = NULL;
 swsContext = NULL;

 options = NULL;
 videoDecoder = NULL;
 audioDecoder = NULL;

 //Initial registration, only register once in a software
 FFmpegThread::initlib();
}

//Only need to initialize once in a software
void FFmpegThread::initlib()
{
 static QMutex mutex;
 QMutexLocker locker(&mutex);
 static bool isInit = false;
 if (!isInit) {
 //Register all available file formats and decoders in the library
 av_register_all();
 //Register all devices, mainly for local camera playback support
#ifdef ffmpegdevice
 avdevice_register_all();
#endif
 //Initialize the network stream format, which must be executed first when using the network stream
 avformat_network_init();

 isInit = true;
 qDebug() << TIMEMS << "init ffmpeg lib ok" << " version:" << FFMPEG_VERSION;
#if 0
 //Output all supported decoder names
 QStringList listCodeName;
 AVCodec *code = av_codec_next(NULL);
 while (code != NULL) {
 listCodeName << code->name;
 code = code->next;
 }

 qDebug() << TIMEMS << listCodeName;
#endif
 }
}

bool FFmpegThread::init()
{
 //Before opening the code stream, specify various parameters such as: detection time/timeout time/maximum delay, etc.
 //Set the cache size, 1080p can increase the value
 av_dict_set(&options, "buffer_size", "8192000", 0);
 //Open in tcp mode, if open in udp mode, replace tcp with udp
 av_dict_set(&options, "rtsp_transport", "tcp", 0);
 //Set the timeout disconnection time, the unit is microseconds, 3000000 means 3 seconds
 av_dict_set(&options, "stimeout", "3000000", 0);
 //Set the maximum delay, in microseconds, 1000000 means 1 second
 av_dict_set(&options, "max_delay", "1000000", 0);
 //Automatically start the number of threads
 av_dict_set(&options, "threads", "auto", 0);

 //Open video stream
 avFormatContext = avformat_alloc_context();

 int result = avformat_open_input(&avFormatContext, url.toStdString().data(), NULL, &options);
 if (result < 0) {
 qDebug() << TIMEMS << "open input error" << url;
 return false;
 }

 //Release setting parameters
 if (options != NULL) {
 av_dict_free(&options);
 }

 //Get flow information
 result = avformat_find_stream_info(avFormatContext, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "find stream info error";
 return false;
 }

 //----------At the beginning of the video stream part, make a mark to facilitate the folding of the code----------
 if (1) {
 videoStreamIndex = av_find_best_stream(avFormatContext, AVMEDIA_TYPE_VIDEO, -1, -1, &videoDecoder, 0);
 if (videoStreamIndex < 0) {
 qDebug() << TIMEMS << "find video stream index error";
 return false;
 }

 //Get video stream
 AVStream *videoStream = avFormatContext->streams[videoStreamIndex];

 //Get the video stream decoder, or specify the decoder
 videoCodec = videoStream->codec;
 videoDecoder = avcodec_find_decoder(videoCodec->codec_id);
 //videoDecoder = avcodec_find_decoder_by_name("h264_qsv");
 if (videoDecoder == NULL) {
 qDebug() << TIMEMS << "video decoder not found";
 return false;
 }

 //Set up accelerated decoding
 videoCodec->lowres = videoDecoder->max_lowres;
 videoCodec->flags2 |= AV_CODEC_FLAG2_FAST;

 //Open the video decoder
 result = avcodec_open2(videoCodec, videoDecoder, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "open video codec error";
 return false;
 }

 //Get the resolution size
 videoWidth = videoStream->codec->width;
 videoHeight = videoStream->codec->height;

 //If the width and height are not obtained, return
 if (videoWidth == 0 || videoHeight == 0) {
 qDebug() << TIMEMS << "find width height error";
 return false;
 }

 QString videoInfo = QString("Video stream info -> index: %1 decode: %2 format: %3 duration: %4 s Resolution: %5*%6")
 .arg(videoStreamIndex).arg(videoDecoder->name).arg(avFormatContext->iformat->name)
 .arg((avFormatContext->duration) / 1000000).arg(videoWidth).arg(videoHeight);
 qDebug() << TIMEMS << videoInfo;
 }
 //----------The video stream part starts----------

 //----------Start the audio stream part, mark it to facilitate the code folding----------
 if (1) {
 //Loop to find audio stream index
 audioStreamIndex = -1;
 for (uint i = 0; i < avFormatContext->nb_streams; i++) {
 if (avFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 audioStreamIndex = i;
 break;
 }
 }

 //Some have no audio stream, so there is no need to return here
 if (audioStreamIndex == -1) {
 qDebug() << TIMEMS << "find audio stream index error";
 } else {
 //Get audio stream
 AVStream *audioStream = avFormatContext->streams[audioStreamIndex];
 audioCodec = audioStream->codec;

 //Get the audio stream decoder, or specify the decoder
 audioDecoder = avcodec_find_decoder(audioCodec->codec_id);
 //audioDecoder = avcodec_find_decoder_by_name("aac");
 if (audioDecoder == NULL) {
 qDebug() << TIMEMS << "audio codec not found";
 return false;
 }

 //Open the audio decoder
 result = avcodec_open2(audioCodec, audioDecoder, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "open audio codec error";
 return false;
 }

 QString audioInfo = QString("Audio stream information -> index: %1 decode: %2 Bit rate: %3 channel num: %4 sampling: %5")
 .arg(audioStreamIndex).arg(audioDecoder->name).arg(avFormatContext->bit_rate)
 .arg(audioCodec->channels).arg(audioCodec->sample_rate);
 qDebug() << TIMEMS << audioInfo;
 }
 }
 //----------End of audio stream----------

 //Pre-allocated memory
 avPacket = av_packet_alloc();
 avFrame = av_frame_alloc();
 avFrame2 = av_frame_alloc();
 avFrame3 = av_frame_alloc();

 //Compare the width and height of the last file. When changing, you need to reallocate the memory
 if (oldWidth != videoWidth || oldHeight != videoHeight) {
 int byte = avpicture_get_size(AV_PIX_FMT_RGB32, videoWidth, videoHeight);
 buffer = (uint8_t *)av_malloc(byte * sizeof(uint8_t));
 oldWidth = videoWidth;
 oldHeight = videoHeight;
 }

 //Define pixel format
 AVPixelFormat srcFormat = AV_PIX_FMT_YUV420P;
 AVPixelFormat dstFormat = AV_PIX_FMT_RGB32;
 //Get the decoded format through the decoder
 srcFormat = videoCodec->pix_fmt;

 //The SWS_FAST_BILINEAR parameter used by the default fastest decoding may lose part of the picture data, and you can change it to other parameters by yourself
 int flags = SWS_FAST_BILINEAR;

 //Open up a cache to store one frame of data
 //The following two methods are ok, avpicture_fill has been gradually abandoned
 //avpicture_fill((AVPicture *)avFrame3, buffer, dstFormat, videoWidth, videoHeight);
 av_image_fill_arrays(avFrame3->data, avFrame3->linesize, buffer, dstFormat, videoWidth, videoHeight, 1);

 //Image conversion
 swsContext = sws_getContext(videoWidth, videoHeight, srcFormat, videoWidth, videoHeight, dstFormat, flags, NULL, NULL, NULL);

 //Output video information
 //av_dump_format(avFormatContext, 0, url.toStdString().data(), 0);

 //qDebug() << TIMEMS << "init ffmpeg finsh";
 return true;
}

void FFmpegThread::run()
{
 while (!stopped) {
 //Perform initialization based on the flag bit
 if (isPlay) {
 this->init();
 isPlay = false;
 continue;
 }

 if (av_read_frame(avFormatContext, avPacket) >= 0) {
 //Determine whether the current package is video or audio
 int index = avPacket->stream_index;
 if (index == videoStreamIndex) {
 //Decode video stream avcodec_decode_video2 method has been deprecated
#if 0
 avcodec_decode_video2(videoCodec, avFrame2, &frameFinish, avPacket);
#else
 frameFinish = avcodec_send_packet(videoCodec, avPacket);
 if (frameFinish < 0) {
 continue;
 }

 frameFinish = avcodec_receive_frame(videoCodec, avFrame2);
 if (frameFinish < 0) {
 continue;
 }
#endif

 if (frameFinish >= 0) {
 //Turn the data into a picture
 sws_scale(swsContext, (const uint8_t *const *)avFrame2->data, avFrame2->linesize, 0, videoHeight, avFrame3->data, avFrame3->linesize);

 //The following two methods can be used
 //QImage image(avFrame3->data[0], videoWidth, videoHeight, QImage::Format_RGB32);
 QImage image((uchar *)buffer, videoWidth, videoHeight, QImage::Format_RGB32);
 if (!image.isNull()) {
 emit receiveImage(image);
 }

 msleep(1);
 }
 } else if (index == audioStreamIndex) {
 //Decode the audio stream, it will not be processed here, and will be handed over to sdl to play
 }
 }

 av_packet_unref(avPacket);
 av_freep(avPacket);
 msleep(1);
 }

 //Release resources after the thread ends
 free();
 stopped = false;
 isPlay = false;
 qDebug() << TIMEMS << "stop ffmpeg thread";
}

void FFmpegThread::setUrl(const QString &url)
{
 this->url = url;
}

void FFmpegThread::free()
{
 if (swsContext != NULL) {
 sws_freeContext(swsContext);
 swsContext = NULL;
 }

 if (avPacket != NULL) {
 av_packet_unref(avPacket);
 avPacket = NULL;
 }

 if (avFrame != NULL) {
 av_frame_free(&avFrame);
 avFrame = NULL;
 }

 if (avFrame2 != NULL) {
 av_frame_free(&avFrame2);
 avFrame2 = NULL;
 }

 if (avFrame3 != NULL) {
 av_frame_free(&avFrame3);
 avFrame3 = NULL;
 }

 if (videoCodec != NULL) {
 avcodec_close(videoCodec);
 videoCodec = NULL;
 }

 if (audioCodec != NULL) {
 avcodec_close(audioCodec);
 audioCodec = NULL;
 }

 if (avFormatContext != NULL) {
 avformat_close_input(&avFormatContext);
 avFormatContext = NULL;
 }

 av_dict_free(&options);
 //qDebug() << TIMEMS << "close ffmpeg ok";
}

void FFmpegThread::play()
{
 //Let the thread perform initialization through the flag bit
 isPlay = true;
}

void FFmpegThread::pause()
{

}

void FFmpegThread::next()
{

}

void FFmpegThread::stop()
{
 //Stop the thread through the flag
 stopped = true;
}

//Real-time video display form class
FFmpegWidget::FFmpegWidget(QWidget *parent) : QWidget(parent)
{
 thread = new FFmpegThread(this);
 connect(thread, SIGNAL(receiveImage(QImage)), this, SLOT(updateImage(QImage)));
 image = QImage();
}

FFmpegWidget::~FFmpegWidget()
{
 close();
}

void FFmpegWidget::paintEvent(QPaintEvent *)
{
 if (image.isNull()) {
 return;
 }

 //qDebug() << TIMEMS << "paintEvent" << objectName();
 QPainter painter(this);
 painter.drawImage(this->rect(), image);
}

void FFmpegWidget::updateImage(const QImage &image)
{
 //this->image = image.copy();
 this->image = image;
 this->update();
}

void FFmpegWidget::setUrl(const QString &url)
{
 thread->setUrl(url);
}

void FFmpegWidget::open()
{
 //qDebug() << TIMEMS << "open video" << objectName();
 clear();

 thread->play();
 thread->start();
}

void FFmpegWidget::pause()
{
 thread->pause();
}

void FFmpegWidget::next()
{
 thread->next();
}

void FFmpegWidget::close()
{
 //qDebug() << TIMEMS << "close video" << objectName();
 if (thread->isRunning()) {
 thread->stop();
 thread->quit();
 thread->wait(500);
 }

 QTimer::singleShot(1, this, SLOT(clear()));
}

void FFmpegWidget::clear()
{
 image = QImage();
 update();
}



Ⅲ. Renderings




Ⅳ. Open source code download URL


1.download URL for dropbox :


https://www.dropbox.com/sh/n58ucs57pscp25e/AABWBQlg4U3Oz2WF9YOJDrj1a?dl=0


2.download URL for box :


https://app.box.com/s/x48a7ttpk667afqqdk7t1fqok4fmvmyv


-
FFmpeg C++ API : Using HW acceleration (VAAPI) to transcode video coming from a webcam [closed]
16 avril, par nicohI'm actually trying to use HW acceleration with the FFmpeg C++ API in order to transcode the video coming from a webcam (which may vary from one config to another) into a given output format (i.e : converting the video stream coming from the webcam in MJPEG to H264 so that it can be written into a MP4 file).


I already succeeded to achieve this by transferring the AVFrame output by the HW decoder from GPU to CPU, then transfer this to the HW encoder input (so from CPU to GPU).
This is not so optimized and on top of that, for the given above config (MJPEG => H264), I cannot provide the output of the decoder as an input for the encoder as the MJPEG HW decoder wants to output in RGBA pixel format, and the H264 encoder wants NV12. So I have to perform pixel format conversion on CPU side.


That's why I would like to connect the output of the HW video decoder directly to the input of the HW encoder (inside the GPU).
To do this, I followed this example given by FFmpeg : https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/vaapi_transcode.c.


This works fine when transcoding an AVI file with MJPEG inside to H264 but it fails when using a MJPEG stream coming from a webcam as input.
In this case, the encoder says :


[h264_vaapi @ 0x5555555e5140] No usable encoding profile found.


Below the code of the FFmpeg example I modified to connect on webcam instead of opening input file :


/*
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
 * @file Intel VAAPI-accelerated transcoding API usage example
 * @example vaapi_transcode.c
 *
 * Perform VAAPI-accelerated transcoding.
 * Usage: vaapi_transcode input_stream codec output_stream
 * e.g: - vaapi_transcode input.mp4 h264_vaapi output_h264.mp4
 * - vaapi_transcode input.mp4 vp9_vaapi output_vp9.ivf
 */

#include 
#include 
#include <iostream>

//#define USE_INPUT_FILE

extern "C"{
#include <libavutil></libavutil>hwcontext.h>
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavdevice></libavdevice>avdevice.h>
}

static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
static AVBufferRef *hw_device_ctx = NULL;
static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
static int video_stream = -1;
static AVStream *ost;
static int initialized = 0;

static enum AVPixelFormat get_vaapi_format(AVCodecContext *ctx,
 const enum AVPixelFormat *pix_fmts)
{
 const enum AVPixelFormat *p;

 for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
 if (*p == AV_PIX_FMT_VAAPI)
 return *p;
 }

 std::cout << "Unable to decode this file using VA-API." << std::endl;
 return AV_PIX_FMT_NONE;
}

static int open_input_file(const char *filename)
{
 int ret;
 AVCodec *decoder = NULL;
 AVStream *video = NULL;
 AVDictionary *pInputOptions = nullptr;

#ifdef USE_INPUT_FILE
 if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open input file '" << filename << "', Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
#else
 avdevice_register_all();
 av_dict_set(&pInputOptions, "input_format", "mjpeg", 0);
 av_dict_set(&pInputOptions, "framerate", "30", 0);
 av_dict_set(&pInputOptions, "video_size", "640x480", 0);

 if ((ret = avformat_open_input(&ifmt_ctx, "/dev/video0", NULL, &pInputOptions)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open input file '" << filename << "', Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
#endif

 ifmt_ctx->flags |= AVFMT_FLAG_NONBLOCK;

 if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot find input stream information. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot find a video stream in the input file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
 video_stream = ret;

 if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
 return AVERROR(ENOMEM);

 video = ifmt_ctx->streams[video_stream];
 if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "avcodec_parameters_to_context error. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
 if (!decoder_ctx->hw_device_ctx) {
 std::cout << "A hardware device reference create failed." << std::endl;
 return AVERROR(ENOMEM);
 }
 decoder_ctx->get_format = get_vaapi_format;

 if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
 {
 char errMsg[1024] = {0};
 std::cout << "Failed to open codec for decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 }

 return ret;
}

static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
{
 int ret = 0;

 av_packet_unref(enc_pkt);

 AVHWDeviceContext *pHwDevCtx = reinterpret_cast(encoder_ctx->hw_device_ctx);
 AVHWFramesContext *pHwFrameCtx = reinterpret_cast(encoder_ctx->hw_frames_ctx);

 if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during encoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }
 while (1) {
 ret = avcodec_receive_packet(encoder_ctx, enc_pkt);
 if (ret)
 break;

 enc_pkt->stream_index = 0;
 av_packet_rescale_ts(enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
 ofmt_ctx->streams[0]->time_base);
 ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during writing data to output file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return -1;
 }
 }

end:
 if (ret == AVERROR_EOF)
 return 0;
 ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
 return ret;
}

static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec, AVCodecContext *pDecCtx)
{
 AVFrame *frame;
 int ret = 0;

 ret = avcodec_send_packet(decoder_ctx, pkt);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 while (ret >= 0) {
 if (!(frame = av_frame_alloc()))
 return AVERROR(ENOMEM);

 ret = avcodec_receive_frame(decoder_ctx, frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 av_frame_free(&frame);
 return 0;
 } else if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error while decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 if (!initialized) {
 AVHWFramesContext *pHwFrameCtx = reinterpret_cast(decoder_ctx->hw_frames_ctx);
 
 /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 encoder_ctx->hw_frames_ctx = av_buffer_ref(pDecCtx->hw_frames_ctx);
 if (!encoder_ctx->hw_frames_ctx) {
 ret = AVERROR(ENOMEM);
 goto fail;
 }
 /* set AVCodecContext Parameters for encoder, here we keep them stay
 * the same as decoder.
 * xxx: now the sample can't handle resolution change case.
 */
 if(encoder_ctx->time_base.den == 1 && encoder_ctx->time_base.num == 0)
 {
 encoder_ctx->time_base = av_inv_q(ifmt_ctx->streams[video_stream]->avg_frame_rate);
 }
 else
 {
 encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 }
 encoder_ctx->pix_fmt = AV_PIX_FMT_VAAPI;
 encoder_ctx->width = decoder_ctx->width;
 encoder_ctx->height = decoder_ctx->height;

 if ((ret = avcodec_open2(encoder_ctx, enc_codec, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to open encode codec. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 std::cout << "Failed to allocate stream for output format." << std::endl;
 ret = AVERROR(ENOMEM);
 goto fail;
 }

 ost->time_base = encoder_ctx->time_base;
 ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to copy the stream parameters. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 /* write the stream header */
 if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error while writing stream header. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 initialized = 1;
 }

 if ((ret = encode_write(pkt, frame)) < 0)
 std::cout << "Error during encoding and writing." << std::endl;

fail:
 av_frame_free(&frame);
 if (ret < 0)
 return ret;
 }
 return 0;
}

int main(int argc, char **argv)
{
 const AVCodec *enc_codec;
 int ret = 0;
 AVPacket *dec_pkt;

 if (argc != 4) {
 fprintf(stderr, "Usage: %s <input file="file" /> <encode codec="codec"> <output file="file">\n"
 "The output format is guessed according to the file extension.\n"
 "\n", argv[0]);
 return -1;
 }

 ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to create a VAAPI device. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return -1;
 }

 dec_pkt = av_packet_alloc();
 if (!dec_pkt) {
 std::cout << "Failed to allocate decode packet" << std::endl;
 goto end;
 }

 if ((ret = open_input_file(argv[1])) < 0)
 goto end;

 if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 std::cout << "Could not find encoder '" << argv[2] << "'" << std::endl;
 ret = -1;
 goto end;
 }

 if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to deduce output format from file extension. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }

 if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 ret = AVERROR(ENOMEM);
 goto end;
 }

 ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open output file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }

 /* read all packets and only transcoding video */
 while (ret >= 0) {
 if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
 break;

 if (video_stream == dec_pkt->stream_index)
 ret = dec_enc(dec_pkt, enc_codec, decoder_ctx);

 av_packet_unref(dec_pkt);
 }

 /* flush decoder */
 av_packet_unref(dec_pkt);
 ret = dec_enc(dec_pkt, enc_codec, decoder_ctx);

 /* flush encoder */
 ret = encode_write(dec_pkt, NULL);

 /* write the trailer for output stream */
 av_write_trailer(ofmt_ctx);

end:
 avformat_close_input(&ifmt_ctx);
 avformat_close_input(&ofmt_ctx);
 avcodec_free_context(&decoder_ctx);
 avcodec_free_context(&encoder_ctx);
 av_buffer_unref(&hw_device_ctx);
 av_packet_free(&dec_pkt);
 return ret;
}
</output></encode></iostream>

And the content of the associated CMakeLists.txt file to build it using gcc :


cmake_minimum_required(VERSION 3.5)

include(FetchContent)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_VERBOSE_MAKEFILE ON)

SET (FFMPEG_HW_TRANSCODE_INCS
 ${CMAKE_CURRENT_LIST_DIR})

include_directories(
 ${CMAKE_INCLUDE_PATH}
 ${CMAKE_CURRENT_LIST_DIR}
)

project(FFmpeg_HW_transcode LANGUAGES CXX)

set(CMAKE_CXX_FLAGS "-Wall -Werror=return-type -pedantic -fPIC -gdwarf-4")
set(CMAKE_CPP_FLAGS "-Wall -Werror=return-type -pedantic -fPIC -gdwarf-4")

set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_LIST_DIR}/build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode")
set(LIBRARY_OUTPUT_PATH "${CMAKE_CURRENT_LIST_DIR}/build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode")

add_executable(${PROJECT_NAME})

target_sources(${PROJECT_NAME} PRIVATE
 vaapi_transcode.cpp)

target_link_libraries(${PROJECT_NAME}
 -L${CMAKE_CURRENT_LIST_DIR}/../build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode
 -lavdevice
 -lavformat
 -lavutil
 -lavcodec)


Has anyone tried to do this kind of stuff ?


Thanks for your help.


-
FFmpeg C++ API : Using HW acceleration (VAAPI) to transcode video coming from a webcam
17 avril, par nicohI'm actually trying to use HW acceleration with the FFmpeg C++ API in order to transcode the video coming from a webcam (which may vary from one config to another) into a given output format (i.e : converting the video stream coming from the webcam in MJPEG to H264 so that it can be written into a MP4 file).


I already succeeded to achieve this by transferring the AVFrame output by the HW decoder from GPU to CPU, then transfer this to the HW encoder input (so from CPU to GPU).
This is not so optimized and on top of that, for the given above config (MJPEG => H264), I cannot provide the output of the decoder as an input for the encoder as the MJPEG HW decoder wants to output in RGBA pixel format, and the H264 encoder wants NV12. So I have to perform pixel format conversion on CPU side.


That's why I would like to connect the output of the HW video decoder directly to the input of the HW encoder (inside the GPU).
To do this, I followed this example given by FFmpeg : https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/vaapi_transcode.c.


This works fine when transcoding an AVI file with MJPEG inside to H264 but it fails when using a MJPEG stream coming from a webcam as input.
In this case, the encoder says :


[h264_vaapi @ 0x5555555e5140] No usable encoding profile found.


Below the code of the FFmpeg example I modified to connect on webcam instead of opening input file :


/*
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
 * @file Intel VAAPI-accelerated transcoding API usage example
 * @example vaapi_transcode.c
 *
 * Perform VAAPI-accelerated transcoding.
 * Usage: vaapi_transcode input_stream codec output_stream
 * e.g: - vaapi_transcode input.mp4 h264_vaapi output_h264.mp4
 * - vaapi_transcode input.mp4 vp9_vaapi output_vp9.ivf
 */

#include 
#include 
#include <iostream>

//#define USE_INPUT_FILE

extern "C"{
#include <libavutil></libavutil>hwcontext.h>
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavdevice></libavdevice>avdevice.h>
}

static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
static AVBufferRef *hw_device_ctx = NULL;
static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
static int video_stream = -1;
static AVStream *ost;
static int initialized = 0;

static enum AVPixelFormat get_vaapi_format(AVCodecContext *ctx,
 const enum AVPixelFormat *pix_fmts)
{
 const enum AVPixelFormat *p;

 for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
 if (*p == AV_PIX_FMT_VAAPI)
 return *p;
 }

 std::cout << "Unable to decode this file using VA-API." << std::endl;
 return AV_PIX_FMT_NONE;
}

static int open_input_file(const char *filename)
{
 int ret;
 AVCodec *decoder = NULL;
 AVStream *video = NULL;
 AVDictionary *pInputOptions = nullptr;

#ifdef USE_INPUT_FILE
 if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open input file '" << filename << "', Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
#else
 avdevice_register_all();
 av_dict_set(&pInputOptions, "input_format", "mjpeg", 0);
 av_dict_set(&pInputOptions, "framerate", "30", 0);
 av_dict_set(&pInputOptions, "video_size", "640x480", 0);

 if ((ret = avformat_open_input(&ifmt_ctx, "/dev/video0", NULL, &pInputOptions)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open input file '" << filename << "', Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
#endif

 ifmt_ctx->flags |= AVFMT_FLAG_NONBLOCK;

 if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot find input stream information. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot find a video stream in the input file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }
 video_stream = ret;

 if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
 return AVERROR(ENOMEM);

 video = ifmt_ctx->streams[video_stream];
 if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "avcodec_parameters_to_context error. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
 if (!decoder_ctx->hw_device_ctx) {
 std::cout << "A hardware device reference create failed." << std::endl;
 return AVERROR(ENOMEM);
 }
 decoder_ctx->get_format = get_vaapi_format;

 if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
 {
 char errMsg[1024] = {0};
 std::cout << "Failed to open codec for decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 }

 return ret;
}

static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
{
 int ret = 0;

 av_packet_unref(enc_pkt);

 AVHWDeviceContext *pHwDevCtx = reinterpret_cast(encoder_ctx->hw_device_ctx);
 AVHWFramesContext *pHwFrameCtx = reinterpret_cast(encoder_ctx->hw_frames_ctx);

 if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during encoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }
 while (1) {
 ret = avcodec_receive_packet(encoder_ctx, enc_pkt);
 if (ret)
 break;

 enc_pkt->stream_index = 0;
 av_packet_rescale_ts(enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
 ofmt_ctx->streams[0]->time_base);
 ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during writing data to output file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return -1;
 }
 }

end:
 if (ret == AVERROR_EOF)
 return 0;
 ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
 return ret;
}

static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec, AVCodecContext *pDecCtx)
{
 AVFrame *frame;
 int ret = 0;

 ret = avcodec_send_packet(decoder_ctx, pkt);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error during decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return ret;
 }

 while (ret >= 0) {
 if (!(frame = av_frame_alloc()))
 return AVERROR(ENOMEM);

 ret = avcodec_receive_frame(decoder_ctx, frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 av_frame_free(&frame);
 return 0;
 } else if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error while decoding. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 if (!initialized) {
 AVHWFramesContext *pHwFrameCtx = reinterpret_cast(decoder_ctx->hw_frames_ctx);
 
 /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 encoder_ctx->hw_frames_ctx = av_buffer_ref(pDecCtx->hw_frames_ctx);
 if (!encoder_ctx->hw_frames_ctx) {
 ret = AVERROR(ENOMEM);
 goto fail;
 }
 /* set AVCodecContext Parameters for encoder, here we keep them stay
 * the same as decoder.
 * xxx: now the sample can't handle resolution change case.
 */
 if(encoder_ctx->time_base.den == 1 && encoder_ctx->time_base.num == 0)
 {
 encoder_ctx->time_base = av_inv_q(ifmt_ctx->streams[video_stream]->avg_frame_rate);
 }
 else
 {
 encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 }
 encoder_ctx->pix_fmt = AV_PIX_FMT_VAAPI;
 encoder_ctx->width = decoder_ctx->width;
 encoder_ctx->height = decoder_ctx->height;

 if ((ret = avcodec_open2(encoder_ctx, enc_codec, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to open encode codec. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 std::cout << "Failed to allocate stream for output format." << std::endl;
 ret = AVERROR(ENOMEM);
 goto fail;
 }

 ost->time_base = encoder_ctx->time_base;
 ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to copy the stream parameters. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 /* write the stream header */
 if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Error while writing stream header. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto fail;
 }

 initialized = 1;
 }

 if ((ret = encode_write(pkt, frame)) < 0)
 std::cout << "Error during encoding and writing." << std::endl;

fail:
 av_frame_free(&frame);
 if (ret < 0)
 return ret;
 }
 return 0;
}

int main(int argc, char **argv)
{
 const AVCodec *enc_codec;
 int ret = 0;
 AVPacket *dec_pkt;

 if (argc != 4) {
 fprintf(stderr, "Usage: %s <input file="file" /> <encode codec="codec"> <output file="file">\n"
 "The output format is guessed according to the file extension.\n"
 "\n", argv[0]);
 return -1;
 }

 ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to create a VAAPI device. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 return -1;
 }

 dec_pkt = av_packet_alloc();
 if (!dec_pkt) {
 std::cout << "Failed to allocate decode packet" << std::endl;
 goto end;
 }

 if ((ret = open_input_file(argv[1])) < 0)
 goto end;

 if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 std::cout << "Could not find encoder '" << argv[2] << "'" << std::endl;
 ret = -1;
 goto end;
 }

 if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 char errMsg[1024] = {0};
 std::cout << "Failed to deduce output format from file extension. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }

 if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 ret = AVERROR(ENOMEM);
 goto end;
 }

 ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 if (ret < 0) {
 char errMsg[1024] = {0};
 std::cout << "Cannot open output file. Error code: " << av_make_error_string(errMsg, 1024, ret) << std::endl;
 goto end;
 }

 /* read all packets and only transcoding video */
 while (ret >= 0) {
 if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
 break;

 if (video_stream == dec_pkt->stream_index)
 ret = dec_enc(dec_pkt, enc_codec, decoder_ctx);

 av_packet_unref(dec_pkt);
 }

 /* flush decoder */
 av_packet_unref(dec_pkt);
 ret = dec_enc(dec_pkt, enc_codec, decoder_ctx);

 /* flush encoder */
 ret = encode_write(dec_pkt, NULL);

 /* write the trailer for output stream */
 av_write_trailer(ofmt_ctx);

end:
 avformat_close_input(&ifmt_ctx);
 avformat_close_input(&ofmt_ctx);
 avcodec_free_context(&decoder_ctx);
 avcodec_free_context(&encoder_ctx);
 av_buffer_unref(&hw_device_ctx);
 av_packet_free(&dec_pkt);
 return ret;
}
</output></encode></iostream>

And the content of the associated CMakeLists.txt file to build it using gcc :


cmake_minimum_required(VERSION 3.5)

include(FetchContent)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_VERBOSE_MAKEFILE ON)

SET (FFMPEG_HW_TRANSCODE_INCS
 ${CMAKE_CURRENT_LIST_DIR})

include_directories(
 ${CMAKE_INCLUDE_PATH}
 ${CMAKE_CURRENT_LIST_DIR}
)

project(FFmpeg_HW_transcode LANGUAGES CXX)

set(CMAKE_CXX_FLAGS "-Wall -Werror=return-type -pedantic -fPIC -gdwarf-4")
set(CMAKE_CPP_FLAGS "-Wall -Werror=return-type -pedantic -fPIC -gdwarf-4")

set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_LIST_DIR}/build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode")
set(LIBRARY_OUTPUT_PATH "${CMAKE_CURRENT_LIST_DIR}/build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode")

add_executable(${PROJECT_NAME})

target_sources(${PROJECT_NAME} PRIVATE
 vaapi_transcode.cpp)

target_link_libraries(${PROJECT_NAME}
 -L${CMAKE_CURRENT_LIST_DIR}/../build/${CMAKE_BUILD_TYPE}/FFmpeg_HW_transcode
 -lavdevice
 -lavformat
 -lavutil
 -lavcodec)


Has anyone tried to do this kind of stuff ?


Thanks for your help.


Syndiquer tout le site
