Кодировать видео из C ++ с помощью LibavCodec и Vaapi ⇐ C++

[Anonymous]

Я пытаюсь кодировать видео в H.264 с Libavcodec (версия 3.4.6). Он работает, когда я использую программный кодер Аппаратное кодирование с FFMPEG через VAAPI работает из командной строки (используя команды отсюда). < /P>

Очевидно, нет примера или учебного пособия, как кодировать с Ваапи и Либав*. Я прочитал примеры FFMPEG, которые охватывают соответствующий вариант использования (аппаратное декодирование, кодирование программного обеспечения, мышление) и пытались соответствующим образом адаптировать их. Консоль: < /p>


несоответствие avcodeccontext.pix_fmt и avhwframescontext.format < /p>
< /blockquote>

Вы можете найти его на конце Encoder :: setupencoder () < /> Вы можете найти его на конце Encoder :: setupencoder () < /> . Что мне не хватает?#ifndef ENCODER_H
#define ENCODER_H
#include

extern "C" {
#include
#include
#include
#include
}

class Encoder
{
public:
Encoder(const bool hwAccel);
void addFrame(AVFrame* frame);
void flush();

static constexpr int s_width = 640;
static constexpr int s_height = 480;
static constexpr int s_fps = 25;
private:
void setup();
void setupEncoder();
void encodeFrame(AVFrame* frame);

// members
int m_frameId = 1;
const bool m_hardwareAcceleration = false;

AVCodecContext* m_encoder = nullptr;
AVFormatContext* m_muxer = nullptr;
AVStream* m_avStream = nullptr;
AVBufferRef* m_device = nullptr;

AVFrame* m_hwFrame = nullptr;
};

#endif // ENCODER_H
< /code>

encoder.cpp

#include "encoder.h"

extern "C" {

static enum AVPixelFormat get_vaapi_format(AVCodecContext*, 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;
}
fprintf(stderr, "Failed to get HW surface format.\n");
return AV_PIX_FMT_NONE;
}

}

Encoder::Encoder(const bool hwAccel)
: m_hardwareAcceleration(hwAccel)
{
setup();
}
void Encoder::addFrame(AVFrame* frame)
{
AVFrame* frameToEncode = frame;
if(m_hardwareAcceleration) {
assert(frame->format == AV_PIX_FMT_NV12);
av_hwframe_transfer_data(m_hwFrame, frame, 0);
assert(m_hwFrame->format == AV_PIX_FMT_VAAPI);
frameToEncode = m_hwFrame;
}

frameToEncode->pts = m_frameId++;
encodeFrame(frameToEncode);
}
void Encoder::flush()
{
encodeFrame(nullptr);
av_write_trailer(m_muxer);
}

void Encoder::setup()
{
assert(avformat_alloc_output_context2(&m_muxer, nullptr, "matroska", nullptr) == 0);
assert(m_muxer != nullptr);

setupEncoder();

m_avStream = avformat_new_stream(m_muxer, nullptr);
assert(m_avStream != nullptr);
m_avStream->id = m_muxer->nb_streams-1;
m_avStream->time_base = m_encoder->time_base;

// Some formats want stream headers to be separate.
if(m_muxer->oformat->flags & AVFMT_GLOBALHEADER)
m_encoder->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

assert(avcodec_parameters_from_context(m_avStream->codecpar, m_encoder) == 0);
assert(avio_open(&m_muxer->pb, m_hardwareAcceleration? "hardware.mkv": "software.mkv", AVIO_FLAG_WRITE) == 0);
assert(avformat_write_header(m_muxer, nullptr) == 0);
}
void Encoder::setupEncoder()
{
const char* encoderName = m_hardwareAcceleration? "h264_vaapi": "libx264";
AVCodec* videoCodec = avcodec_find_encoder_by_name(encoderName);
m_encoder = avcodec_alloc_context3(videoCodec);
m_encoder->bit_rate = s_width * s_height * s_fps * 2;
m_encoder->width = s_width;
m_encoder->height = s_height;
m_encoder->time_base = (AVRational){1, s_fps};
m_encoder->framerate = (AVRational){s_fps, 1};

m_encoder->gop_size = s_fps; // have at least 1 I-frame per second
m_encoder->max_b_frames = 1;
m_encoder->pix_fmt = AV_PIX_FMT_YUV420P;

if(m_hardwareAcceleration) {
m_encoder->pix_fmt = AV_PIX_FMT_VAAPI;
m_encoder->get_format = get_vaapi_format;

assert(av_hwdevice_ctx_create(&m_device, AV_HWDEVICE_TYPE_VAAPI, "/dev/dri/renderD128", nullptr, 0) == 0);

AVHWDeviceContext* deviceCtx = (AVHWDeviceContext*) m_device->data;
assert(deviceCtx->type == AV_HWDEVICE_TYPE_VAAPI);

m_encoder->hw_device_ctx = av_hwframe_ctx_alloc(m_device);
m_encoder->hw_frames_ctx = av_buffer_ref(m_device);
m_hwFrame = av_frame_alloc();
av_hwframe_get_buffer(m_encoder->hw_device_ctx, m_hwFrame, 0);
}

assert(avcodec_open2(m_encoder, videoCodec, nullptr) == 0); // video_codec_id = videoCodec->id;
m_muxer->video_codec = videoCodec;
}
void Encoder::encodeFrame(AVFrame* frame)
{
assert(avcodec_send_frame(m_encoder, frame) == 0);

AVPacket packet;
av_init_packet(&packet);
int ret = 0;
while(ret >= 0) {
ret = avcodec_receive_packet(m_encoder, &packet);
if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
return; // nothing to write
}
assert(ret >= 0);

av_packet_rescale_ts(&packet, m_encoder->time_base, m_avStream->time_base);
packet.stream_index = m_avStream->index;
av_interleaved_write_frame(m_muxer, &packet);
av_packet_unref(&packet);
}
}
< /code>

main.cpp

#include "encoder.h"

AVFrame* createFrame(const int format)
{
AVFrame* frame = av_frame_alloc();
frame->format = format;
frame->width = Encoder::s_width;
frame->height = Encoder::s_height;
assert(av_frame_get_buffer(frame, 0) == 0);
assert(av_frame_make_writable(frame) == 0);

// Y
for(int y=0; yheight; y++) {
for(int x=0; xwidth; x++) {
frame->data[0][y * frame->linesize[0] + x] = 0;
}
}

// CbCr
const int widthCbCr = frame->width / 2;
const int heightCbCr = frame->height / 2;

if(format == AV_PIX_FMT_YUV420P) {
for(int y=0; ylinesize[1] + x] = 0; // Cb
frame->data[2][y * frame->linesize[2] + x] = 0; // Cr
}
}
return frame;
}
else if(format == AV_PIX_FMT_NV12) {
for(int y=0; ylinesize[0] + x] = 0;
}
}
return frame;
}

return nullptr;
}

int main()
{
av_register_all();

AVFrame* yuv420pFrame = createFrame(AV_PIX_FMT_YUV420P);
AVFrame* nv12Frame = createFrame(AV_PIX_FMT_NV12);

// works well
Encoder softwareEncoder(false);
for(int i=0; i

Подробнее здесь: https://stackoverflow.com/questions/596 ... -and-vaapi