mirror of
https://github.com/SourMesen/Mesen2.git
synced 2025-04-02 10:21:44 -04:00
257 lines
7 KiB
C++
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);
|
|
}
|
|
}
|