Mesen2/Core/Shared/Video/VideoDecoder.cpp
2024-09-19 21:19:43 +09:00

257 lines
7 KiB
C++

#include "pch.h"
#include "Shared/Interfaces/IRenderingDevice.h"
#include "Shared/Video/VideoDecoder.h"
#include "Shared/Video/VideoRenderer.h"
#include "Shared/Video/BaseVideoFilter.h"
#include "Shared/NotificationManager.h"
#include "Shared/Emulator.h"
#include "Shared/RewindManager.h"
#include "Shared/EmuSettings.h"
#include "Shared/SettingTypes.h"
#include "Shared/Video/ScaleFilter.h"
#include "Shared/Video/RotateFilter.h"
#include "Shared/Video/ScanlineFilter.h"
#include "Shared/Video/DebugHud.h"
#include "Shared/InputHud.h"
#include "Shared/RenderedFrame.h"
#include "Shared/Video/SystemHud.h"
#include "SNES/CartTypes.h"
VideoDecoder::VideoDecoder(Emulator* emu)
{
_emu = emu;
_frameChanged = false;
_stopFlag = false;
_baseFrameSize = { 256, 239 };
_lastFrameSize = _baseFrameSize;
}
VideoDecoder::~VideoDecoder()
{
StopThread();
}
void VideoDecoder::Init()
{
UpdateVideoFilter();
_videoFilter->SetBaseFrameInfo(_baseFrameSize);
}
FrameInfo VideoDecoder::GetBaseFrameInfo(bool removeOverscan)
{
if(removeOverscan) {
OverscanDimensions overscan = _emu->GetSettings()->GetOverscan();
uint32_t hOverscan = overscan.Left + overscan.Right;
uint32_t vOverscan = overscan.Top + overscan.Bottom;
bool swapOverscan = (_emu->GetSettings()->GetVideoConfig().ScreenRotation % 180) != 0;
if(swapOverscan) {
std::swap(hOverscan, vOverscan);
}
return {
(uint32_t)(_baseFrameSize.Width * _frame.Scale) - hOverscan,
(uint32_t)(_baseFrameSize.Height * _frame.Scale) - vOverscan
};
} else {
return {
(uint32_t)(_baseFrameSize.Width * _frame.Scale),
(uint32_t)(_baseFrameSize.Height * _frame.Scale)
};
}
}
FrameInfo VideoDecoder::GetFrameInfo()
{
return _lastFrameSize;
}
void VideoDecoder::UpdateVideoFilter()
{
VideoFilterType newFilter = _emu->GetSettings()->GetVideoConfig().VideoFilter;
ConsoleType consoleType = _emu->GetConsoleType();
if(_videoFilterType != newFilter || _videoFilter == nullptr || _consoleType != consoleType || _forceFilterUpdate) {
_videoFilterType = newFilter;
_consoleType = consoleType;
_videoFilter.reset(_emu->GetVideoFilter());
_scaleFilter = ScaleFilter::GetScaleFilter(_emu, _videoFilterType);
_forceFilterUpdate = false;
}
uint32_t screenRotation = _emu->GetSettings()->GetVideoConfig().ScreenRotation;
_emu->GetScreenRotationOverride(screenRotation);
if(screenRotation != 0) {
if(!_rotateFilter || _rotateFilter->GetAngle() != screenRotation) {
_rotateFilter.reset(new RotateFilter(screenRotation));
}
} else {
_rotateFilter.reset();
}
}
void VideoDecoder::DecodeFrame(bool forRewind)
{
UpdateVideoFilter();
bool isAudioPlayer = _emu->GetAudioPlayerHud() != nullptr;
if(isAudioPlayer) {
//When an audio file is loaded, force base resolution to 256x240 for all consoles
_baseFrameSize.Width = 256;
_baseFrameSize.Height = 240;
} else {
_baseFrameSize.Width = _frame.Width;
_baseFrameSize.Height = _frame.Height;
}
_videoFilter->SetBaseFrameInfo(_baseFrameSize);
FrameInfo frameSize = _videoFilter->SendFrame((uint16_t*)_frame.FrameBuffer, _frame.FrameNumber, _frame.VideoPhase, _frame.Data);
uint32_t* outputBuffer = _videoFilter->GetOutputBuffer();
OverscanDimensions overscan = _videoFilter->GetOverscan();
if(_rotateFilter && !isAudioPlayer) {
outputBuffer = _rotateFilter->ApplyFilter(outputBuffer, frameSize.Width, frameSize.Height);
if((_rotateFilter->GetAngle() % 180) != 0) {
//90 or 270 rotation, swap height & width
std::swap(_baseFrameSize.Width, _baseFrameSize.Height);
frameSize = _rotateFilter->GetFrameInfo(frameSize);
}
}
_emu->GetDebugHud()->Draw(outputBuffer, frameSize, overscan, _frame.FrameNumber, _videoFilter->GetScaleFactor());
if(_scaleFilter && !isAudioPlayer) {
outputBuffer = _scaleFilter->ApplyFilter(outputBuffer, frameSize.Width, frameSize.Height);
frameSize = _scaleFilter->GetFrameInfo(frameSize);
}
if(!isAudioPlayer) {
uint8_t scale = std::max<uint8_t>(1, (uint8_t)((double)frameSize.Height / (_frame.Height - overscan.Top - overscan.Bottom)));
ScanlineFilter::ApplyFilter(outputBuffer, frameSize.Width, frameSize.Height, _emu->GetSettings()->GetVideoConfig().ScanlineIntensity, scale);
}
RenderedFrame convertedFrame((void*)outputBuffer, frameSize.Width, frameSize.Height, _frame.Scale, _frame.FrameNumber, _frame.InputData);
double aspectRatio = _emu->GetSettings()->GetAspectRatio(_emu->GetRegion(), _baseFrameSize);
if(frameSize.Height != _lastFrameSize.Height || frameSize.Width != _lastFrameSize.Width || aspectRatio != _lastAspectRatio) {
_emu->GetNotificationManager()->SendNotification(ConsoleNotificationType::ResolutionChanged);
}
_lastAspectRatio = aspectRatio;
_lastFrameSize = frameSize;
//Rewind manager will take care of sending the correct frame to the video renderer
_emu->GetRewindManager()->SendFrame(convertedFrame, forRewind);
_frameChanged = false;
}
void VideoDecoder::DecodeThread()
{
//This thread will decode the PPU's output (color ID to RGB, intensify r/g/b and produce a HD version of the frame if needed)
while(!_stopFlag.load()) {
//DecodeFrame returns the final ARGB frame we want to display in the emulator window
while(!_frameChanged) {
_waitForFrame.Wait();
if(_stopFlag.load()) {
return;
}
}
DecodeFrame();
}
}
uint32_t VideoDecoder::GetFrameCount()
{
return _frameCount;
}
void VideoDecoder::WaitForAsyncFrameDecode()
{
while(_frameChanged) {
//Spin until decode is done
std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(15));
}
}
void VideoDecoder::UpdateFrame(RenderedFrame frame, bool sync, bool forRewind)
{
if(_emu->IsRunAheadFrame()) {
return;
}
if(_frameChanged) {
//Last frame isn't done decoding yet - sometimes Signal() introduces a 25-30ms delay
while(_frameChanged) {
//Spin until decode is done
}
//At this point, we are sure that the decode thread is no longer busy
}
_emu->OnBeforeSendFrame();
_frame = frame;
if(sync) {
DecodeFrame(forRewind);
} else {
_frameChanged = true;
_waitForFrame.Signal();
}
_frameCount++;
}
void VideoDecoder::StartThread()
{
auto lock = _stopStartLock.AcquireSafe();
if(!_decodeThread) {
_videoFilter.reset();
UpdateVideoFilter();
_videoFilter->SetBaseFrameInfo(_baseFrameSize);
_stopFlag = false;
_frameChanged = false;
_frameCount = 0;
_waitForFrame.Reset();
_emu->GetVideoRenderer()->ClearFrame();
_decodeThread.reset(new thread(&VideoDecoder::DecodeThread, this));
}
}
void VideoDecoder::StopThread()
{
auto lock = _stopStartLock.AcquireSafe();
_stopFlag = true;
if(_decodeThread) {
_waitForFrame.Signal();
_decodeThread->join();
_decodeThread.reset();
//Clear whole screen
_emu->GetVideoRenderer()->ClearFrame();
}
}
bool VideoDecoder::IsRunning()
{
return _decodeThread != nullptr;
}
void VideoDecoder::TakeScreenshot()
{
if(_videoFilter) {
_videoFilter->TakeScreenshot(_emu->GetRomInfo().RomFile.GetFileName(), _videoFilterType);
}
}
void VideoDecoder::TakeScreenshot(std::stringstream &stream)
{
if(_videoFilter) {
_videoFilter->TakeScreenshot(_videoFilterType, "", &stream);
}
}