107 lines
5.8 KiB
C++
107 lines
5.8 KiB
C++
#include "call_video_decoder.h"
|
|
#include "debug_config.h"
|
|
#include "../../../src/call/call_video_bitstream.h"
|
|
#include <QTransform>
|
|
#ifdef HAVE_FFMPEG
|
|
extern "C" {
|
|
#include <libavcodec/avcodec.h>
|
|
#include <libavutil/imgutils.h>
|
|
#include <libswscale/swscale.h>
|
|
}
|
|
#endif
|
|
struct CallVideoDecoder::Impl {
|
|
call_video_format format{};
|
|
#ifdef HAVE_FFMPEG
|
|
AVCodecContext* codec = nullptr;
|
|
SwsContext* scale = nullptr;
|
|
#endif
|
|
};
|
|
CallVideoDecoder::CallVideoDecoder() : m(std::make_unique<Impl>()) {}
|
|
CallVideoDecoder::~CallVideoDecoder() { close(); }
|
|
void CallVideoDecoder::close() {
|
|
#ifdef HAVE_FFMPEG
|
|
avcodec_free_context(&m->codec); sws_freeContext(m->scale); m->scale = nullptr;
|
|
#endif
|
|
m->format = {};
|
|
}
|
|
call_video_caps CallVideoDecoder::capabilities() {
|
|
call_video_caps caps{};
|
|
for (unsigned codec = 1; codec <= 2; ++codec) {
|
|
unsigned profiles = 0;
|
|
for (unsigned profile = 1; profile <= (codec == 1 ? 2u : 1u); ++profile) {
|
|
uint8_t bytes[8192]; int size = call_video_probe_key(codec, profile, bytes, sizeof(bytes));
|
|
if (size < 0) continue;
|
|
call_video_frame f{}; f.call_id = 1; f.flags = CALL_VIDEO_KEY; f.data = bytes; f.size = f.length = size;
|
|
f.format = {1, 1280, 720, 30, 0, (uint8_t)codec, (uint8_t)(codec == 1 ? 31 : 93), 4000000, (uint8_t)profile};
|
|
CallVideoDecoder decoder; bool valid = true;
|
|
for (unsigned i = 0; i < 4 && valid; ++i) {
|
|
f.frame_id = i + 1; f.pts_us = 1000000 + i * 33333;
|
|
QImage image; valid = decoder.decode(f, image);
|
|
}
|
|
if (valid) profiles |= profile;
|
|
else DEBUG_WARN(DEBUG_CATEGORY_CALL, "video independent decoder probe failed codec=%u profile=%u", codec, profile);
|
|
}
|
|
if (profiles) caps.decode[codec - 1] = {1280, 720, 30, 1280 * 720 * 30, 4000000,
|
|
(uint8_t)profiles, (uint8_t)(codec == 1 ? 31 : 93)};
|
|
DEBUG_INFO(DEBUG_CATEGORY_CALL, "video decoder probe codec=%u profiles=%u", codec, profiles);
|
|
}
|
|
return caps;
|
|
}
|
|
bool CallVideoDecoder::decode(const call_video_frame& f, QImage& image) {
|
|
#ifdef HAVE_FFMPEG
|
|
auto failed = [this, &f](const char* reason) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_CALL, "video decode rejected frame=%llu generation=%llu reason=%s",
|
|
(unsigned long long)f.frame_id, (unsigned long long)f.format.generation, reason);
|
|
close(); return false;
|
|
};
|
|
if (!call_video_format_valid(&f.format) || !f.data || !f.size || f.size > CALL_VIDEO_MAX_FRAME) return failed("format");
|
|
bool changed = !call_video_same_format(&m->format, &f.format);
|
|
const uint8_t* data = f.data; unsigned size = f.size;
|
|
if (f.flags & CALL_VIDEO_KEY) {
|
|
if (call_video_check_key(&f.format, f.data, f.size)) return failed("bitstream contract");
|
|
if (size < 5) return failed("KEY envelope");
|
|
uint32_t config = (uint32_t)data[0] << 24 | (uint32_t)data[1] << 16 | (uint32_t)data[2] << 8 | data[3];
|
|
if (config > 65536 || config >= size - 4) return failed("KEY config length");
|
|
data += 4; size -= 4; // Annex B configuration и access unit подаются вместе.
|
|
} else if (changed || !m->codec) return failed("KEY required");
|
|
if (changed || !m->codec) {
|
|
close();
|
|
const AVCodec* codec = avcodec_find_decoder(f.format.codec == CALL_VIDEO_H265 ? AV_CODEC_ID_HEVC : AV_CODEC_ID_H264);
|
|
if (!codec || !(m->codec = avcodec_alloc_context3(codec))) return failed("decoder unavailable");
|
|
m->codec->thread_count = 1; m->codec->flags |= AV_CODEC_FLAG_LOW_DELAY;
|
|
if (avcodec_open2(m->codec, codec, nullptr) < 0) return failed("decoder open");
|
|
m->format = f.format;
|
|
DEBUG_INFO(DEBUG_CATEGORY_CALL, "video decoder opened codec=%u level=%u generation=%llu",
|
|
f.format.codec, f.format.level, (unsigned long long)f.format.generation);
|
|
}
|
|
AVPacket* packet = av_packet_alloc(); AVFrame* decoded = av_frame_alloc();
|
|
if (!packet || !decoded) { av_packet_free(&packet); av_frame_free(&decoded); return failed("allocation"); }
|
|
int result = av_new_packet(packet, size);
|
|
if (result >= 0) {
|
|
memcpy(packet->data, data, size); packet->pts = packet->dts = f.pts_us;
|
|
result = avcodec_send_packet(m->codec, packet);
|
|
if (result >= 0) result = avcodec_receive_frame(m->codec, decoded);
|
|
}
|
|
bool valid = result >= 0 && decoded->pts == f.pts_us && decoded->width == f.format.width && decoded->height == f.format.height
|
|
&& decoded->format == AV_PIX_FMT_YUV420P && !m->codec->has_b_frames && m->codec->level <= f.format.level;
|
|
int profile = f.format.codec == CALL_VIDEO_H265 ? AV_PROFILE_HEVC_MAIN : AV_PROFILE_H264_CONSTRAINED_BASELINE;
|
|
valid = valid && (m->codec->profile == profile || (f.format.codec == CALL_VIDEO_H264
|
|
&& f.format.profile == CALL_VIDEO_BASELINE && m->codec->profile == AV_PROFILE_H264_BASELINE));
|
|
if (valid) {
|
|
QImage output(decoded->width, decoded->height, QImage::Format_RGB888);
|
|
m->scale = sws_getCachedContext(m->scale, decoded->width, decoded->height, AV_PIX_FMT_YUV420P,
|
|
decoded->width, decoded->height, AV_PIX_FMT_RGB24, SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
|
|
if (!m->scale || output.isNull()) valid = false;
|
|
else {
|
|
uint8_t* planes[4] = {output.bits(), nullptr, nullptr, nullptr}; int strides[4] = {(int)output.bytesPerLine(), 0, 0, 0};
|
|
valid = sws_scale(m->scale, decoded->data, decoded->linesize, 0, decoded->height, planes, strides) == decoded->height;
|
|
if (valid) image = f.format.rotation ? output.transformed(QTransform().rotate(f.format.rotation)) : output;
|
|
}
|
|
}
|
|
av_packet_free(&packet); av_frame_free(&decoded);
|
|
return valid ? true : failed("PTS/profile/level/geometry/output");
|
|
#else
|
|
Q_UNUSED(f); Q_UNUSED(image); DEBUG_WARN(DEBUG_CATEGORY_CALL, "video decoder unavailable: no FFmpeg"); return false;
|
|
#endif
|
|
}
|