1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-14 10:12:59 +02:00
vcmi/client/media/CVideoHandler.cpp
2024-06-01 11:48:54 +00:00

666 lines
19 KiB
C++

/*
* CVideoHandler.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "CVideoHandler.h"
#ifndef DISABLE_VIDEO
#include "ISoundPlayer.h"
#include "../CGameInfo.h"
#include "../CMT.h"
#include "../eventsSDL/InputHandler.h"
#include "../gui/CGuiHandler.h"
#include "../render/Canvas.h"
#include "../renderSDL/SDL_Extensions.h"
#include "../../lib/filesystem/CInputStream.h"
#include "../../lib/filesystem/Filesystem.h"
#include "../../lib/CGeneralTextHandler.h"
#include "../../lib/Languages.h"
#include <SDL_render.h>
extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
// Define a set of functions to read data
static int lodRead(void * opaque, uint8_t * buf, int size)
{
auto * data = static_cast<CInputStream *>(opaque);
auto bytesRead = data->read(buf, size);
if(bytesRead == 0)
return AVERROR_EOF;
return bytesRead;
}
static si64 lodSeek(void * opaque, si64 pos, int whence)
{
auto * data = static_cast<CInputStream *>(opaque);
if(whence & AVSEEK_SIZE)
return data->getSize();
return data->seek(pos);
}
[[noreturn]] static void throwFFmpegError(int errorCode)
{
std::array<char, AV_ERROR_MAX_STRING_SIZE> errorMessage{};
av_strerror(errorCode, errorMessage.data(), errorMessage.size());
throw std::runtime_error(errorMessage.data());
}
static std::unique_ptr<CInputStream> findVideoData(const VideoPath & videoToOpen)
{
if(CResourceHandler::get()->existsResource(videoToOpen))
return CResourceHandler::get()->load(videoToOpen);
auto highQualityVideoToOpenWithDir = videoToOpen.addPrefix("VIDEO/");
auto lowQualityVideo = videoToOpen.toType<EResType::VIDEO_LOW_QUALITY>();
auto lowQualityVideoWithDir = highQualityVideoToOpenWithDir.toType<EResType::VIDEO_LOW_QUALITY>();
if(CResourceHandler::get()->existsResource(highQualityVideoToOpenWithDir))
return CResourceHandler::get()->load(highQualityVideoToOpenWithDir);
if(CResourceHandler::get()->existsResource(lowQualityVideo))
return CResourceHandler::get()->load(lowQualityVideo);
if(CResourceHandler::get()->existsResource(lowQualityVideoWithDir))
return CResourceHandler::get()->load(lowQualityVideoWithDir);
return nullptr;
}
bool FFMpegStream::openInput(const VideoPath & videoToOpen)
{
input = findVideoData(videoToOpen);
return input != nullptr;
}
void FFMpegStream::openContext()
{
static const int BUFFER_SIZE = 4096;
input->seek(0);
auto * buffer = static_cast<unsigned char *>(av_malloc(BUFFER_SIZE)); // will be freed by ffmpeg
context = avio_alloc_context(buffer, BUFFER_SIZE, 0, input.get(), lodRead, nullptr, lodSeek);
formatContext = avformat_alloc_context();
formatContext->pb = context;
// filename is not needed - file was already open and stored in this->data;
int avfopen = avformat_open_input(&formatContext, "dummyFilename", nullptr, nullptr);
if(avfopen != 0)
throwFFmpegError(avfopen);
// Retrieve stream information
int findStreamInfo = avformat_find_stream_info(formatContext, nullptr);
if(avfopen < 0)
throwFFmpegError(findStreamInfo);
}
void FFMpegStream::openCodec(int desiredStreamIndex)
{
streamIndex = desiredStreamIndex;
// Find the decoder for the stream
codec = avcodec_find_decoder(formatContext->streams[streamIndex]->codecpar->codec_id);
if(codec == nullptr)
throw std::runtime_error("Unsupported codec");
codecContext = avcodec_alloc_context3(codec);
if(codecContext == nullptr)
throw std::runtime_error("Failed to create codec context");
// Get a pointer to the codec context for the video stream
int ret = avcodec_parameters_to_context(codecContext, formatContext->streams[streamIndex]->codecpar);
if(ret < 0)
{
//We cannot get codec from parameters
avcodec_free_context(&codecContext);
throwFFmpegError(ret);
}
// Open codec
ret = avcodec_open2(codecContext, codec, nullptr);
if(ret < 0)
{
// Could not open codec
codec = nullptr;
throwFFmpegError(ret);
}
// Allocate video frame
frame = av_frame_alloc();
}
const AVCodecParameters * FFMpegStream::getCodecParameters() const
{
return formatContext->streams[streamIndex]->codecpar;
}
const AVCodecContext * FFMpegStream::getCodecContext() const
{
return codecContext;
}
const AVFrame * FFMpegStream::getCurrentFrame() const
{
return frame;
}
void CVideoInstance::openVideo()
{
openContext();
openCodec(findVideoStream());
}
void CVideoInstance::prepareOutput(bool scaleToScreenSize, bool useTextureOutput)
{
//setup scaling
if(scaleToScreenSize)
{
dimensions.x = screen->w;
dimensions.y = screen->h;
}
else
{
dimensions.x = getCodecContext()->width;
dimensions.y = getCodecContext()->height;
}
// Allocate a place to put our YUV image on that screen
if (useTextureOutput)
{
std::array potentialFormats = {
AV_PIX_FMT_YUV420P, // -> SDL_PIXELFORMAT_IYUV - most of H3 videos use YUV format, so it is preferred to save some space & conversion time
AV_PIX_FMT_RGB32, // -> SDL_PIXELFORMAT_ARGB8888 - some .smk videos actually use palette, so RGB > YUV. This is also our screen texture format
AV_PIX_FMT_NONE
};
auto preferredFormat = avcodec_find_best_pix_fmt_of_list(potentialFormats.data(), getCodecContext()->pix_fmt, false, nullptr);
if (preferredFormat == AV_PIX_FMT_YUV420P)
textureYUV = SDL_CreateTexture( mainRenderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING, dimensions.x, dimensions.y);
else
textureRGB = SDL_CreateTexture( mainRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, dimensions.x, dimensions.y);
sws = sws_getContext(getCodecContext()->width, getCodecContext()->height, getCodecContext()->pix_fmt,
dimensions.x, dimensions.y, preferredFormat,
SWS_BICUBIC, nullptr, nullptr, nullptr);
}
else
{
surface = CSDL_Ext::newSurface(dimensions.x, dimensions.y);
sws = sws_getContext(getCodecContext()->width, getCodecContext()->height, getCodecContext()->pix_fmt,
dimensions.x, dimensions.y, AV_PIX_FMT_RGB32,
SWS_BICUBIC, nullptr, nullptr, nullptr);
}
if (sws == nullptr)
throw std::runtime_error("Failed to create sws");
}
void FFMpegStream::decodeNextFrame()
{
int rc = avcodec_receive_frame(codecContext, frame);
// frame extracted - data that was sent to codecContext before was sufficient
if (rc == 0)
return;
// returning AVERROR(EAGAIN) is legal - this indicates that codec requires more data from input stream to decode next frame
if(rc != AVERROR(EAGAIN))
throwFFmpegError(rc);
for(;;)
{
AVPacket packet;
// codecContext does not have enough input data - read next packet from input stream
int ret = av_read_frame(formatContext, &packet);
if(ret < 0)
{
if(ret == AVERROR_EOF)
{
av_packet_unref(&packet);
av_frame_free(&frame);
frame = nullptr;
return;
}
throwFFmpegError(ret);
}
// Is this a packet from the stream that needs decoding?
if(packet.stream_index == streamIndex)
{
// Decode read packet
// Note: this method may return AVERROR(EAGAIN). However this should never happen with ffmpeg API
// since there is guaranteed call to avcodec_receive_frame and ffmpeg API promises that *both* of these methods will never return AVERROR(EAGAIN).
int rc = avcodec_send_packet(codecContext, &packet);
if(rc < 0)
throwFFmpegError(rc);
rc = avcodec_receive_frame(codecContext, frame);
if(rc == AVERROR(EAGAIN))
{
// still need more data - read next packet
av_packet_unref(&packet);
continue;
}
else if(rc < 0)
{
throwFFmpegError(rc);
}
else
{
// read succesful. Exit the loop
av_packet_unref(&packet);
return;
}
}
av_packet_unref(&packet);
}
}
bool CVideoInstance::loadNextFrame()
{
decodeNextFrame();
const AVFrame * frame = getCurrentFrame();
if(!frame)
return false;
uint8_t * data[4] = {};
int linesize[4] = {};
if(textureYUV)
{
av_image_alloc(data, linesize, dimensions.x, dimensions.y, AV_PIX_FMT_YUV420P, 1);
sws_scale(sws, frame->data, frame->linesize, 0, getCodecContext()->height, data, linesize);
SDL_UpdateYUVTexture(textureYUV, nullptr, data[0], linesize[0], data[1], linesize[1], data[2], linesize[2]);
av_freep(&data[0]);
}
if(textureRGB)
{
av_image_alloc(data, linesize, dimensions.x, dimensions.y, AV_PIX_FMT_RGB32, 1);
sws_scale(sws, frame->data, frame->linesize, 0, getCodecContext()->height, data, linesize);
SDL_UpdateTexture(textureRGB, nullptr, data[0], linesize[0]);
av_freep(&data[0]);
}
if(surface)
{
// Avoid buffer overflow caused by sws_scale():
// http://trac.ffmpeg.org/ticket/9254
size_t pic_bytes = surface->pitch * surface->h;
size_t ffmped_pad = 1024; /* a few bytes of overflow will go here */
void * for_sws = av_malloc(pic_bytes + ffmped_pad);
data[0] = (ui8 *)for_sws;
linesize[0] = surface->pitch;
sws_scale(sws, frame->data, frame->linesize, 0, getCodecContext()->height, data, linesize);
memcpy(surface->pixels, for_sws, pic_bytes);
av_free(for_sws);
}
return true;
}
bool CVideoInstance::videoEnded()
{
return getCurrentFrame() == nullptr;
}
CVideoInstance::~CVideoInstance()
{
sws_freeContext(sws);
SDL_DestroyTexture(textureYUV);
SDL_DestroyTexture(textureRGB);
SDL_FreeSurface(surface);
}
FFMpegStream::~FFMpegStream()
{
av_frame_free(&frame);
avcodec_close(codecContext);
avcodec_free_context(&codecContext);
avcodec_close(codecContext);
avcodec_free_context(&codecContext);
avformat_close_input(&formatContext);
av_free(context);
}
Point CVideoInstance::size()
{
if(!getCurrentFrame())
throw std::runtime_error("Invalid video frame!");
return Point(getCurrentFrame()->width, getCurrentFrame()->height);
}
void CVideoInstance::show(const Point & position, Canvas & canvas)
{
if(sws == nullptr)
throw std::runtime_error("No video to show!");
CSDL_Ext::blitSurface(surface, canvas.getInternalSurface(), position);
}
double FFMpegStream::getCurrentFrameEndTime() const
{
#if(LIBAVUTIL_VERSION_MAJOR < 58)
auto packet_duration = frame->pkt_duration;
#else
auto packet_duration = frame->duration;
#endif
return (frame->pts + packet_duration) * av_q2d(formatContext->streams[streamIndex]->time_base);
}
double FFMpegStream::getCurrentFrameDuration() const
{
#if(LIBAVUTIL_VERSION_MAJOR < 58)
auto packet_duration = frame->pkt_duration;
#else
auto packet_duration = frame->duration;
#endif
return packet_duration * av_q2d(formatContext->streams[streamIndex]->time_base);
}
void CVideoInstance::tick(uint32_t msPassed)
{
if(sws == nullptr)
throw std::runtime_error("No video to show!");
if(videoEnded())
throw std::runtime_error("Video already ended!");
frameTime += msPassed / 1000.0;
if(frameTime >= getCurrentFrameEndTime())
loadNextFrame();
}
struct FFMpegFormatDescription
{
uint8_t sampleSizeBytes;
uint8_t wavFormatID;
bool isPlanar;
};
static FFMpegFormatDescription getAudioFormatProperties(int audioFormat)
{
switch (audioFormat)
{
case AV_SAMPLE_FMT_U8: return { 1, 1, false};
case AV_SAMPLE_FMT_U8P: return { 1, 1, true};
case AV_SAMPLE_FMT_S16: return { 2, 1, false};
case AV_SAMPLE_FMT_S16P: return { 2, 1, true};
case AV_SAMPLE_FMT_S32: return { 4, 1, false};
case AV_SAMPLE_FMT_S32P: return { 4, 1, true};
case AV_SAMPLE_FMT_S64: return { 8, 1, false};
case AV_SAMPLE_FMT_S64P: return { 8, 1, true};
case AV_SAMPLE_FMT_FLT: return { 4, 3, false};
case AV_SAMPLE_FMT_FLTP: return { 4, 3, true};
case AV_SAMPLE_FMT_DBL: return { 8, 3, false};
case AV_SAMPLE_FMT_DBLP: return { 8, 3, true};
}
throw std::runtime_error("Invalid audio format");
}
int FFMpegStream::findAudioStream() const
{
std::vector<int> audioStreamIndices;
for(int i = 0; i < formatContext->nb_streams; i++)
if(formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
audioStreamIndices.push_back(i);
if (audioStreamIndices.empty())
return -1;
if (audioStreamIndices.size() == 1)
return audioStreamIndices.front();
// multiple audio streams - try to pick best one based on language settings
std::map<int, std::string> streamToLanguage;
// Approach 1 - check if stream has language set in metadata
for (auto const & index : audioStreamIndices)
{
const AVDictionaryEntry *e = av_dict_get(formatContext->streams[index]->metadata, "language", nullptr, 0);
if (e)
streamToLanguage[index] = e->value;
}
// Approach 2 - no metadata found. This may be video from Chronicles which have predefined (presumably hardcoded) list of languages
if (streamToLanguage.empty())
{
if (audioStreamIndices.size() == 2)
{
streamToLanguage[audioStreamIndices[0]] = Languages::getLanguageOptions(Languages::ELanguages::ENGLISH).tagISO2;
streamToLanguage[audioStreamIndices[1]] = Languages::getLanguageOptions(Languages::ELanguages::GERMAN).tagISO2;
}
if (audioStreamIndices.size() == 5)
{
streamToLanguage[audioStreamIndices[0]] = Languages::getLanguageOptions(Languages::ELanguages::ENGLISH).tagISO2;
streamToLanguage[audioStreamIndices[1]] = Languages::getLanguageOptions(Languages::ELanguages::FRENCH).tagISO2;
streamToLanguage[audioStreamIndices[2]] = Languages::getLanguageOptions(Languages::ELanguages::GERMAN).tagISO2;
streamToLanguage[audioStreamIndices[3]] = Languages::getLanguageOptions(Languages::ELanguages::ITALIAN).tagISO2;
streamToLanguage[audioStreamIndices[4]] = Languages::getLanguageOptions(Languages::ELanguages::SPANISH).tagISO2;
}
}
std::string preferredLanguageName = CGI->generaltexth->getPreferredLanguage();
std::string preferredTag = Languages::getLanguageOptions(preferredLanguageName).tagISO2;
for (auto const & entry : streamToLanguage)
if (entry.second == preferredTag)
return entry.first;
return audioStreamIndices.front();
}
int FFMpegStream::findVideoStream() const
{
for(int i = 0; i < formatContext->nb_streams; i++)
if(formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
return i;
return -1;
}
std::pair<std::unique_ptr<ui8 []>, si64> CAudioInstance::extractAudio(const VideoPath & videoToOpen)
{
if (!openInput(videoToOpen))
return { nullptr, 0};
openContext();
openCodec(findAudioStream());
const auto * codecpar = getCodecParameters();
std::vector<ui8> samples;
auto formatProperties = getAudioFormatProperties(codecpar->format);
#if(LIBAVUTIL_VERSION_MAJOR < 58)
int numChannels = codecpar->channels;
#else
int numChannels = codecpar->ch_layout.nb_channels;
#endif
samples.reserve(44100 * 5); // arbitrary 5-second buffer
for (;;)
{
decodeNextFrame();
const AVFrame * frame = getCurrentFrame();
if (!frame)
break;
int samplesToRead = frame->nb_samples * numChannels;
int bytesToRead = samplesToRead * formatProperties.sampleSizeBytes;
if (formatProperties.isPlanar && numChannels > 1)
{
// Workaround for lack of resampler
// Currently, ffmpeg on conan systems is built without sws resampler
// Because of that, and because wav format does not supports 'planar' formats from ffmpeg
// we need to de-planarize it and convert to "normal" (non-planar / interleaved) stream
samples.reserve(samples.size() + bytesToRead);
for (int sm = 0; sm < frame->nb_samples; ++sm)
for (int ch = 0; ch < numChannels; ++ch)
samples.insert(samples.end(), frame->data[ch] + sm * formatProperties.sampleSizeBytes, frame->data[ch] + (sm+1) * formatProperties.sampleSizeBytes );
}
else
{
samples.insert(samples.end(), frame->data[0], frame->data[0] + bytesToRead);
}
}
struct WavHeader {
ui8 RIFF[4] = {'R', 'I', 'F', 'F'};
ui32 ChunkSize;
ui8 WAVE[4] = {'W', 'A', 'V', 'E'};
ui8 fmt[4] = {'f', 'm', 't', ' '};
ui32 Subchunk1Size = 16;
ui16 AudioFormat = 1;
ui16 NumOfChan = 2;
ui32 SamplesPerSec = 22050;
ui32 bytesPerSec = 22050 * 2;
ui16 blockAlign = 2;
ui16 bitsPerSample = 32;
ui8 Subchunk2ID[4] = {'d', 'a', 't', 'a'};
ui32 Subchunk2Size;
};
WavHeader wav;
wav.ChunkSize = samples.size() + sizeof(WavHeader) - 8;
wav.AudioFormat = formatProperties.wavFormatID; // 1 = PCM, 3 = IEEE float
wav.NumOfChan = numChannels;
wav.SamplesPerSec = codecpar->sample_rate;
wav.bytesPerSec = codecpar->sample_rate * formatProperties.sampleSizeBytes;
wav.bitsPerSample = formatProperties.sampleSizeBytes * 8;
wav.Subchunk2Size = samples.size() + sizeof(WavHeader) - 44;
auto * wavPtr = reinterpret_cast<ui8*>(&wav);
auto dat = std::make_pair(std::make_unique<ui8[]>(samples.size() + sizeof(WavHeader)), samples.size() + sizeof(WavHeader));
std::copy(wavPtr, wavPtr + sizeof(WavHeader), dat.first.get());
std::copy(samples.begin(), samples.end(), dat.first.get() + sizeof(WavHeader));
return dat;
}
bool CVideoPlayer::openAndPlayVideoImpl(const VideoPath & name, const Point & position, bool useOverlay, bool scale, bool stopOnKey)
{
CVideoInstance instance;
CAudioInstance audio;
auto extractedAudio = audio.extractAudio(name);
int audioHandle = CCS->soundh->playSound(extractedAudio);
if (!instance.openInput(name))
return true;
instance.openVideo();
instance.prepareOutput(scale, useOverlay);
auto lastTimePoint = boost::chrono::steady_clock::now();
while(instance.loadNextFrame())
{
if(stopOnKey)
{
GH.input().fetchEvents();
if(GH.input().ignoreEventsUntilInput())
{
CCS->soundh->stopSound(audioHandle);
return false;
}
}
SDL_Rect rect;
rect.x = position.x;
rect.y = position.y;
rect.w = instance.dimensions.x;
rect.h = instance.dimensions.y;
if(useOverlay)
SDL_RenderFillRect(mainRenderer, &rect);
else
SDL_RenderClear(mainRenderer);
if(instance.textureYUV)
SDL_RenderCopy(mainRenderer, instance.textureYUV, nullptr, &rect);
else
SDL_RenderCopy(mainRenderer, instance.textureRGB, nullptr, &rect);
SDL_RenderPresent(mainRenderer);
// Framerate delay
double targetFrameTimeSeconds = instance.getCurrentFrameDuration();
auto targetFrameTime = boost::chrono::milliseconds(static_cast<int>(1000 * targetFrameTimeSeconds));
auto timePointAfterPresent = boost::chrono::steady_clock::now();
auto timeSpentBusy = boost::chrono::duration_cast<boost::chrono::milliseconds>(timePointAfterPresent - lastTimePoint);
logGlobal->info("Sleeping for %d", (targetFrameTime - timeSpentBusy).count());
if(targetFrameTime > timeSpentBusy)
boost::this_thread::sleep_for(targetFrameTime - timeSpentBusy);
lastTimePoint = boost::chrono::steady_clock::now();
}
return true;
}
bool CVideoPlayer::playIntroVideo(const VideoPath & name)
{
return openAndPlayVideoImpl(name, Point(0, 0), true, true, true);
}
void CVideoPlayer::playSpellbookAnimation(const VideoPath & name, const Point & position)
{
openAndPlayVideoImpl(name, position, false, false, false);
}
std::unique_ptr<IVideoInstance> CVideoPlayer::open(const VideoPath & name, bool scaleToScreen)
{
auto result = std::make_unique<CVideoInstance>();
if (!result->openInput(name))
return nullptr;
result->openVideo();
result->prepareOutput(scaleToScreen, false);
result->loadNextFrame(); // prepare 1st frame
return result;
}
std::pair<std::unique_ptr<ui8[]>, si64> CVideoPlayer::getAudio(const VideoPath & videoToOpen)
{
CAudioInstance audio;
return audio.extractAudio(videoToOpen);
}
#endif