ppsspp/GPU/Debugger/Record.h

// Copyright (c) 2017- PPSSPP Project.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License 2.0 for more details.

// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/

// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.

#pragma once

#include <functional>
#include <atomic>
#include <mutex>
#include <vector>
#include <set>

#include "Common/CommonTypes.h"
#include "GPU/Debugger/RecordFormat.h"

class Path;

namespace GPURecord {

constexpr uint32_t DIRTY_VRAM_SHIFT = 8;
constexpr uint32_t DIRTY_VRAM_ROUND = (1 << DIRTY_VRAM_SHIFT) - 1;
constexpr uint32_t DIRTY_VRAM_SIZE = (2 * 1024 * 1024) >> DIRTY_VRAM_SHIFT;
constexpr uint32_t DIRTY_VRAM_MASK = (2 * 1024 * 1024 - 1) >> DIRTY_VRAM_SHIFT;
enum class DirtyVRAMFlag : uint8_t {
	CLEAN = 0,
	UNKNOWN = 1,
	DIRTY = 2,
	DRAWN = 3,
};

class Recorder {
public:
	bool IsActive() const {
		return active;
	}
	bool IsActivePending() const {
		return nextFrame || active;
	}
	bool RecordNextFrame(const std::function<void(const Path &)> callback);
	// A savestate load replaced everything a recording in progress started from. It starts over
	// from the loaded state, at the next frame.
	void RestartAfterLoad();
	void ClearCallback() {
		std::lock_guard<std::mutex> guard(callbackLock_);
		writeCallback = nullptr;
	}

	void NotifyCommand(u32 pc);
	void NotifyMemcpy(u32 dest, u32 src, u32 sz);
	void NotifyMemset(u32 dest, int v, u32 sz);
	void NotifyUpload(u32 dest, u32 sz);
	void NotifyDisplay(u32 addr, int stride, int fmt);
	void NotifyBeginFrame();
	void NotifyCPU();
private:
	void FlushRegisters();
	void DirtyAllVRAM(DirtyVRAMFlag flag);
	void DirtyVRAM(u32 start, u32 sz, DirtyVRAMFlag flag);
	void DirtyDrawnVRAM();

	bool BeginRecording();
	Path WriteRecording();

	bool HasDrawCommands() const;
	void CheckEdramTrans();
	void FinishRecording();

	Command EmitCommandWithRAM(CommandType t, const void *p, u32 sz, u32 align);

	void UpdateLastVRAM(u32 addr, u32 bytes);
	void ClearLastVRAM(u32 addr, u8 c, u32 bytes);
	int CompareLastVRAM(u32 addr, u32 bytes) const;

	u32 GetTargetFlags(u32 addr, u32 sizeInRAM);
	void ReadbackUndrawnVRAM(u32 addr, u32 bytes);
	void NoteTargetWrite(u32 addr, u32 bytes);
	bool DisplayDrawnEarly(u32 addr, u32 bytes) const;
	void PushDisplay(u32 framebuf, int stride, int fmt);

	void FlushPrimState(int vcount);
	void EmitTextureData(int level, u32 texaddr);
	void EmitTransfer(u32 op);
	void EmitClut(u32 op);
	void EmitPrim(u32 op);
	void EmitBezierSpline(u32 op);

	bool active = false;
	std::atomic<bool> nextFrame = false;
	int flipLastAction = -1;
	int flipFinishAt = -1;
	uint32_t lastEdramTrans = 0x400;
	std::function<void(const Path &)> writeCallback;
	// RecordNextFrame is called from other threads. Guards writeCallback, nextFrame and the writes to active.
	std::mutex callbackLock_;

	std::vector<u8> pushbuf;
	std::vector<Command> commands;
	std::vector<u32> lastRegisters;
	std::vector<u32> lastTextures;
	std::set<u32> lastRenderTargets;
	std::set<u32> readbackAddrs;

	// The VRAM each draw or transfer wrote (offsets in VRAM), and when, to see whether the display buffer only got
	// an early copy (see NotifyDisplay).
	struct TargetWrite {
		u32 start;
		u32 end;
		int last;
	};
	std::vector<TargetWrite> targetWrites_;
	int writeCount_ = 0;
	// Recording one more frame, whose start copies the recorded one to the display.
	bool waitForDisplayCopy_ = false;
	std::vector<u8> lastVRAM;

	DirtyVRAMFlag dirtyVRAM[DIRTY_VRAM_SIZE];
};

}  // namespace GPURecord