mirror of
https://github.com/yuzu-emu/yuzu.git
synced 2024-05-20 00:16:43 +00:00
649 lines
20 KiB
C++
649 lines
20 KiB
C++
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#pragma once
|
|
|
|
#include <condition_variable>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <thread>
|
|
|
|
#include "common/common_types.h"
|
|
#include "common/scratch_buffer.h"
|
|
#include "video_core/cdma_pusher.h"
|
|
|
|
namespace Tegra::Host1x {
|
|
class Host1x;
|
|
class Nvdec;
|
|
|
|
struct Pixel {
|
|
u16 r;
|
|
u16 g;
|
|
u16 b;
|
|
u16 a;
|
|
};
|
|
|
|
// One underscore represents separate pixels.
|
|
// Double underscore represents separate planes.
|
|
// _N represents chroma subsampling, not a separate pixel.
|
|
enum class VideoPixelFormat : u32 {
|
|
A8 = 0,
|
|
L8 = 1,
|
|
A4L4 = 2,
|
|
L4A4 = 3,
|
|
R8 = 4,
|
|
A8L8 = 5,
|
|
L8A8 = 6,
|
|
R8G8 = 7,
|
|
G8R8 = 8,
|
|
B5G6R5 = 9,
|
|
R5G6B5 = 10,
|
|
B6G5R5 = 11,
|
|
R5G5B6 = 12,
|
|
A1B5G5R5 = 13,
|
|
A1R5G5B5 = 14,
|
|
B5G5R5A1 = 15,
|
|
R5G5B5A1 = 16,
|
|
A5B5G5R1 = 17,
|
|
A5R1G5B5 = 18,
|
|
B5G5R1A5 = 19,
|
|
R1G5B5A5 = 20,
|
|
X1B5G5R5 = 21,
|
|
X1R5G5B5 = 22,
|
|
B5G5R5X1 = 23,
|
|
R5G5B5X1 = 24,
|
|
A4B4G5R4 = 25,
|
|
A4R4G4B4 = 26,
|
|
B4G4R4A4 = 27,
|
|
R4G4B4A4 = 28,
|
|
B8G8R8 = 29,
|
|
R8G8B8 = 30,
|
|
A8B8G8R8 = 31,
|
|
A8R8G8B8 = 32,
|
|
B8G8R8A8 = 33,
|
|
R8G8B8A8 = 34,
|
|
X8B8G8R8 = 35,
|
|
X8R8G8B8 = 36,
|
|
B8G8R8X8 = 37,
|
|
R8G8B8X8 = 38,
|
|
A8B10G10R10 = 39,
|
|
A2R10G10B10 = 40,
|
|
B10G10R10A2 = 41,
|
|
R10G10B10A2 = 42,
|
|
A4P4 = 43,
|
|
P4A4 = 44,
|
|
P8A8 = 45,
|
|
A8P8 = 46,
|
|
P8 = 47,
|
|
P1 = 48,
|
|
U8V8 = 49,
|
|
V8U8 = 50,
|
|
A8Y8U8V8 = 51,
|
|
V8U8Y8A8 = 52,
|
|
Y8U8V8 = 53,
|
|
Y8V8U8 = 54,
|
|
U8V8Y8 = 55,
|
|
V8U8Y8 = 56,
|
|
Y8U8_Y8V8 = 57,
|
|
Y8V8_Y8U8 = 58,
|
|
U8Y8_V8Y8 = 59,
|
|
V8Y8_U8Y8 = 60,
|
|
Y8__U8V8_N444 = 61,
|
|
Y8__V8U8_N444 = 62,
|
|
Y8__U8V8_N422 = 63,
|
|
Y8__V8U8_N422 = 64,
|
|
Y8__U8V8_N422R = 65,
|
|
Y8__V8U8_N422R = 66,
|
|
Y8__U8V8_N420 = 67,
|
|
Y8__V8U8_N420 = 68,
|
|
Y8__U8__V8_N444 = 69,
|
|
Y8__U8__V8_N422 = 70,
|
|
Y8__U8__V8_N422R = 71,
|
|
Y8__U8__V8_N420 = 72,
|
|
U8 = 73,
|
|
V8 = 74,
|
|
};
|
|
|
|
struct Offset {
|
|
constexpr u32 Address() const noexcept {
|
|
return offset << 8;
|
|
}
|
|
|
|
private:
|
|
u32 offset;
|
|
};
|
|
static_assert(std::is_trivial_v<Offset>, "Offset must be trivial");
|
|
static_assert(sizeof(Offset) == 0x4, "Offset has the wrong size!");
|
|
|
|
struct PlaneOffsets {
|
|
Offset luma;
|
|
Offset chroma_u;
|
|
Offset chroma_v;
|
|
};
|
|
static_assert(sizeof(PlaneOffsets) == 0xC, "PlaneOffsets has the wrong size!");
|
|
|
|
enum SurfaceIndex : u32 {
|
|
Current = 0,
|
|
Previous = 1,
|
|
Next = 2,
|
|
NextNoiseReduced = 3,
|
|
CurrentMotion = 4,
|
|
PreviousMotion = 5,
|
|
PreviousPreviousMotion = 6,
|
|
CombinedMotion = 7,
|
|
};
|
|
|
|
enum class DXVAHD_ALPHA_FILL_MODE : u32 {
|
|
OPAQUE = 0,
|
|
BACKGROUND = 1,
|
|
DESTINATION = 2,
|
|
SOURCE_STREAM = 3,
|
|
COMPOSITED = 4,
|
|
SOURCE_ALPHA = 5,
|
|
};
|
|
|
|
enum class DXVAHD_FRAME_FORMAT : u64 {
|
|
PROGRESSIVE = 0,
|
|
INTERLACED_TOP_FIELD_FIRST = 1,
|
|
INTERLACED_BOTTOM_FIELD_FIRST = 2,
|
|
TOP_FIELD = 3,
|
|
BOTTOM_FIELD = 4,
|
|
SUBPIC_PROGRESSIVE = 5,
|
|
SUBPIC_INTERLACED_TOP_FIELD_FIRST = 6,
|
|
SUBPIC_INTERLACED_BOTTOM_FIELD_FIRST = 7,
|
|
SUBPIC_TOP_FIELD = 8,
|
|
SUBPIC_BOTTOM_FIELD = 9,
|
|
TOP_FIELD_CHROMA_BOTTOM = 10,
|
|
BOTTOM_FIELD_CHROMA_TOP = 11,
|
|
SUBPIC_TOP_FIELD_CHROMA_BOTTOM = 12,
|
|
SUBPIC_BOTTOM_FIELD_CHROMA_TOP = 13,
|
|
};
|
|
|
|
enum class DXVAHD_DEINTERLACE_MODE_PRIVATE : u64 {
|
|
WEAVE = 0,
|
|
BOB_FIELD = 1,
|
|
BOB = 2,
|
|
NEWBOB = 3,
|
|
DISI1 = 4,
|
|
WEAVE_LUMA_BOB_FIELD_CHROMA = 5,
|
|
MAX = 0xF,
|
|
};
|
|
|
|
enum class BLK_KIND {
|
|
PITCH = 0,
|
|
GENERIC_16Bx2 = 1,
|
|
// These are unsupported in the vic
|
|
BL_NAIVE = 2,
|
|
BL_KEPLER_XBAR_RAW = 3,
|
|
VP2_TILED = 15,
|
|
};
|
|
|
|
enum class BLEND_SRCFACTC : u32 {
|
|
K1 = 0,
|
|
K1_TIMES_DST = 1,
|
|
NEG_K1_TIMES_DST = 2,
|
|
K1_TIMES_SRC = 3,
|
|
ZERO = 4,
|
|
};
|
|
|
|
enum class BLEND_DSTFACTC : u32 {
|
|
K1 = 0,
|
|
K2 = 1,
|
|
K1_TIMES_DST = 2,
|
|
NEG_K1_TIMES_DST = 3,
|
|
NEG_K1_TIMES_SRC = 4,
|
|
ZERO = 5,
|
|
ONE = 6,
|
|
};
|
|
|
|
enum class BLEND_SRCFACTA : u32 {
|
|
K1 = 0,
|
|
K2 = 1,
|
|
NEG_K1_TIMES_DST = 2,
|
|
ZERO = 3,
|
|
MAX = 7,
|
|
};
|
|
|
|
enum class BLEND_DSTFACTA : u32 {
|
|
K2 = 0,
|
|
NEG_K1_TIMES_SRC = 1,
|
|
ZERO = 2,
|
|
ONE = 3,
|
|
MAX = 7,
|
|
};
|
|
|
|
struct PipeConfig {
|
|
union {
|
|
BitField<0, 11, u32> downsample_horiz;
|
|
BitField<11, 5, u32> reserved0;
|
|
BitField<16, 11, u32> downsample_vert;
|
|
BitField<27, 5, u32> reserved1;
|
|
};
|
|
u32 reserved2;
|
|
u32 reserved3;
|
|
u32 reserved4;
|
|
};
|
|
static_assert(sizeof(PipeConfig) == 0x10, "PipeConfig has the wrong size!");
|
|
|
|
struct OutputConfig {
|
|
union {
|
|
BitField<0, 3, DXVAHD_ALPHA_FILL_MODE> alpha_fill_mode;
|
|
BitField<3, 3, u64> alpha_fill_slot;
|
|
BitField<6, 10, u64> background_a;
|
|
BitField<16, 10, u64> background_r;
|
|
BitField<26, 10, u64> background_g;
|
|
BitField<36, 10, u64> background_b;
|
|
BitField<46, 2, u64> regamma_mode;
|
|
BitField<48, 1, u64> output_flip_x;
|
|
BitField<49, 1, u64> output_flip_y;
|
|
BitField<50, 1, u64> output_transpose;
|
|
BitField<51, 1, u64> reserved1;
|
|
BitField<52, 12, u64> reserved2;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> target_rect_left;
|
|
BitField<14, 2, u32> reserved3;
|
|
BitField<16, 14, u32> target_rect_right;
|
|
BitField<30, 2, u32> reserved4;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> target_rect_top;
|
|
BitField<14, 2, u32> reserved5;
|
|
BitField<16, 14, u32> target_rect_bottom;
|
|
BitField<30, 2, u32> reserved6;
|
|
};
|
|
};
|
|
static_assert(sizeof(OutputConfig) == 0x10, "OutputConfig has the wrong size!");
|
|
|
|
struct OutputSurfaceConfig {
|
|
union {
|
|
BitField<0, 7, VideoPixelFormat> out_pixel_format;
|
|
BitField<7, 2, u32> out_chroma_loc_horiz;
|
|
BitField<9, 2, u32> out_chroma_loc_vert;
|
|
BitField<11, 4, BLK_KIND> out_block_kind;
|
|
BitField<15, 4, u32> out_block_height; // in gobs, log2
|
|
BitField<19, 3, u32> reserved0;
|
|
BitField<22, 10, u32> reserved1;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> out_surface_width; // - 1
|
|
BitField<14, 14, u32> out_surface_height; // - 1
|
|
BitField<28, 4, u32> reserved2;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> out_luma_width; // - 1
|
|
BitField<14, 14, u32> out_luma_height; // - 1
|
|
BitField<28, 4, u32> reserved3;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> out_chroma_width; // - 1
|
|
BitField<14, 14, u32> out_chroma_height; // - 1
|
|
BitField<28, 4, u32> reserved4;
|
|
};
|
|
};
|
|
static_assert(sizeof(OutputSurfaceConfig) == 0x10, "OutputSurfaceConfig has the wrong size!");
|
|
|
|
struct MatrixStruct {
|
|
union {
|
|
BitField<0, 20, s64> matrix_coeff00; // (0,0) of 4x3 conversion matrix
|
|
BitField<20, 20, s64> matrix_coeff10; // (1,0) of 4x3 conversion matrix
|
|
BitField<40, 20, s64> matrix_coeff20; // (2,0) of 4x3 conversion matrix
|
|
BitField<60, 4, u64> matrix_r_shift;
|
|
};
|
|
union {
|
|
BitField<0, 20, s64> matrix_coeff01; // (0,1) of 4x3 conversion matrix
|
|
BitField<20, 20, s64> matrix_coeff11; // (1,1) of 4x3 conversion matrix
|
|
BitField<40, 20, s64> matrix_coeff21; // (2,1) of 4x3 conversion matrix
|
|
BitField<60, 3, u64> reserved0;
|
|
BitField<63, 1, u64> matrix_enable;
|
|
};
|
|
union {
|
|
BitField<0, 20, s64> matrix_coeff02; // (0,2) of 4x3 conversion matrix
|
|
BitField<20, 20, s64> matrix_coeff12; // (1,2) of 4x3 conversion matrix
|
|
BitField<40, 20, s64> matrix_coeff22; // (2,2) of 4x3 conversion matrix
|
|
BitField<60, 4, u64> reserved1;
|
|
};
|
|
union {
|
|
BitField<0, 20, s64> matrix_coeff03; // (0,3) of 4x3 conversion matrix
|
|
BitField<20, 20, s64> matrix_coeff13; // (1,3) of 4x3 conversion matrix
|
|
BitField<40, 20, s64> matrix_coeff23; // (2,3) of 4x3 conversion matrix
|
|
BitField<60, 4, u64> reserved2;
|
|
};
|
|
};
|
|
static_assert(sizeof(MatrixStruct) == 0x20, "MatrixStruct has the wrong size!");
|
|
|
|
struct ClearRectStruct {
|
|
union {
|
|
BitField<0, 14, u32> clear_rect0_left;
|
|
BitField<14, 2, u32> reserved0;
|
|
BitField<16, 14, u32> clear_rect0_right;
|
|
BitField<30, 2, u32> reserved1;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> clear_rect0_top;
|
|
BitField<14, 2, u32> reserved2;
|
|
BitField<16, 14, u32> clear_rect0_bottom;
|
|
BitField<30, 2, u32> reserved3;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> clear_rect1_left;
|
|
BitField<14, 2, u32> reserved4;
|
|
BitField<16, 14, u32> clear_rect1_right;
|
|
BitField<30, 2, u32> reserved5;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> clear_rect1_top;
|
|
BitField<14, 2, u32> reserved6;
|
|
BitField<16, 14, u32> clear_rect1_bottom;
|
|
BitField<30, 2, u32> reserved7;
|
|
};
|
|
};
|
|
static_assert(sizeof(ClearRectStruct) == 0x10, "ClearRectStruct has the wrong size!");
|
|
|
|
struct SlotConfig {
|
|
union {
|
|
BitField<0, 1, u64> slot_enable;
|
|
BitField<1, 1, u64> denoise;
|
|
BitField<2, 1, u64> advanced_denoise;
|
|
BitField<3, 1, u64> cadence_detect;
|
|
BitField<4, 1, u64> motion_map;
|
|
BitField<5, 1, u64> motion_map_capture;
|
|
BitField<6, 1, u64> is_even;
|
|
BitField<7, 1, u64> chroma_even;
|
|
// fetch control struct
|
|
BitField<8, 1, u64> current_field_enable;
|
|
BitField<9, 1, u64> prev_field_enable;
|
|
BitField<10, 1, u64> next_field_enable;
|
|
BitField<11, 1, u64> next_nr_field_enable; // noise reduction
|
|
BitField<12, 1, u64> current_motion_field_enable;
|
|
BitField<13, 1, u64> prev_motion_field_enable;
|
|
BitField<14, 1, u64> prev_prev_motion_field_enable;
|
|
BitField<15, 1, u64> combined_motion_field_enable;
|
|
|
|
BitField<16, 4, DXVAHD_FRAME_FORMAT> frame_format;
|
|
BitField<20, 2, u64> filter_length_y; // 0: 1-tap, 1: 2-tap, 2: 5-tap, 3: 10-tap
|
|
BitField<22, 2, u64> filter_length_x;
|
|
BitField<24, 12, u64> panoramic;
|
|
BitField<36, 22, u64> reserved1;
|
|
BitField<58, 6, u64> detail_filter_clamp;
|
|
};
|
|
union {
|
|
BitField<0, 10, u64> filter_noise;
|
|
BitField<10, 10, u64> filter_detail;
|
|
BitField<20, 10, u64> chroma_noise;
|
|
BitField<30, 10, u64> chroma_detail;
|
|
BitField<40, 4, DXVAHD_DEINTERLACE_MODE_PRIVATE> deinterlace_mode;
|
|
BitField<44, 3, u64> motion_accumulation_weight;
|
|
BitField<47, 11, u64> noise_iir;
|
|
BitField<58, 4, u64> light_level;
|
|
BitField<62, 2, u64> reserved4;
|
|
};
|
|
union {
|
|
BitField<0, 10, u64> soft_clamp_low;
|
|
BitField<10, 10, u64> soft_clamp_high;
|
|
BitField<20, 3, u64> reserved5;
|
|
BitField<23, 9, u64> reserved6;
|
|
BitField<32, 10, u64> planar_alpha;
|
|
BitField<42, 1, u64> constant_alpha;
|
|
BitField<43, 3, u64> stereo_interleave;
|
|
BitField<46, 1, u64> clip_enabled;
|
|
BitField<47, 8, u64> clear_rect_mask;
|
|
BitField<55, 2, u64> degamma_mode;
|
|
BitField<57, 1, u64> reserved7;
|
|
BitField<58, 1, u64> decompress_enable;
|
|
BitField<59, 5, u64> reserved9;
|
|
};
|
|
union {
|
|
BitField<0, 8, u64> decompress_ctb_count;
|
|
BitField<8, 32, u64> decompress_zbc_count;
|
|
BitField<40, 24, u64> reserved12;
|
|
};
|
|
union {
|
|
BitField<0, 30, u64> source_rect_left;
|
|
BitField<30, 2, u64> reserved14;
|
|
BitField<32, 30, u64> source_rect_right;
|
|
BitField<62, 2, u64> reserved15;
|
|
};
|
|
union {
|
|
BitField<0, 30, u64> source_rect_top;
|
|
BitField<30, 2, u64> reserved16;
|
|
BitField<32, 30, u64> source_rect_bottom;
|
|
BitField<62, 2, u64> reserved17;
|
|
};
|
|
union {
|
|
BitField<0, 14, u64> dest_rect_left;
|
|
BitField<14, 2, u64> reserved18;
|
|
BitField<16, 14, u64> dest_rect_right;
|
|
BitField<30, 2, u64> reserved19;
|
|
BitField<32, 14, u64> dest_rect_top;
|
|
BitField<46, 2, u64> reserved20;
|
|
BitField<48, 14, u64> dest_rect_bottom;
|
|
BitField<62, 2, u64> reserved21;
|
|
};
|
|
u32 reserved22;
|
|
u32 reserved23;
|
|
};
|
|
static_assert(sizeof(SlotConfig) == 0x40, "SlotConfig has the wrong size!");
|
|
|
|
struct SlotSurfaceConfig {
|
|
union {
|
|
BitField<0, 7, VideoPixelFormat> slot_pixel_format;
|
|
BitField<7, 2, u32> slot_chroma_loc_horiz;
|
|
BitField<9, 2, u32> slot_chroma_loc_vert;
|
|
BitField<11, 4, u32> slot_block_kind;
|
|
BitField<15, 4, u32> slot_block_height;
|
|
BitField<19, 3, u32> slot_cache_width;
|
|
BitField<22, 10, u32> reserved0;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> slot_surface_width; // - 1
|
|
BitField<14, 14, u32> slot_surface_height; // - 1
|
|
BitField<28, 4, u32> reserved1;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> slot_luma_width; // padded, - 1
|
|
BitField<14, 14, u32> slot_luma_height; // padded, - 1
|
|
BitField<28, 4, u32> reserved2;
|
|
};
|
|
union {
|
|
BitField<0, 14, u32> slot_chroma_width; // padded, - 1
|
|
BitField<14, 14, u32> slot_chroma_height; // padded, - 1
|
|
BitField<28, 4, u32> reserved3;
|
|
};
|
|
};
|
|
static_assert(sizeof(SlotSurfaceConfig) == 0x10, "SlotSurfaceConfig has the wrong size!");
|
|
|
|
struct LumaKeyStruct {
|
|
union {
|
|
BitField<0, 20, u64> luma_coeff0; // (0) of 4x1 conversion matrix, S12.8 format
|
|
BitField<20, 20, u64> luma_coeff1; // (1) of 4x1 conversion matrix, S12.8 format
|
|
BitField<40, 20, u64> luma_coeff2; // (2) of 4x1 conversion matrix, S12.8 format
|
|
BitField<60, 4, u64> luma_r_shift;
|
|
};
|
|
union {
|
|
BitField<0, 20, u64> luma_coeff3; // (3) of 4x1 conversion matrix, S12.8 format
|
|
BitField<20, 10, u64> luma_key_lower;
|
|
BitField<30, 10, u64> luma_key_upper;
|
|
BitField<40, 1, u64> luma_key_enabled;
|
|
BitField<41, 2, u64> reserved0;
|
|
BitField<43, 21, u64> reserved1;
|
|
};
|
|
};
|
|
static_assert(sizeof(LumaKeyStruct) == 0x10, "LumaKeyStruct has the wrong size!");
|
|
|
|
struct BlendingSlotStruct {
|
|
union {
|
|
BitField<0, 10, u32> alpha_k1;
|
|
BitField<10, 6, u32> reserved0;
|
|
BitField<16, 10, u32> alpha_k2;
|
|
BitField<26, 6, u32> reserved1;
|
|
};
|
|
union {
|
|
BitField<0, 3, BLEND_SRCFACTC> src_factor_color_match_select;
|
|
BitField<3, 1, u32> reserved2;
|
|
BitField<4, 3, BLEND_DSTFACTC> dst_factor_color_match_select;
|
|
BitField<7, 1, u32> reserved3;
|
|
BitField<8, 3, BLEND_SRCFACTA> src_factor_a_match_select;
|
|
BitField<11, 1, u32> reserved4;
|
|
BitField<12, 3, BLEND_DSTFACTA> dst_factor_a_match_select;
|
|
BitField<15, 1, u32> reserved5;
|
|
BitField<16, 4, u32> reserved6;
|
|
BitField<20, 4, u32> reserved7;
|
|
BitField<24, 4, u32> reserved8;
|
|
BitField<28, 4, u32> reserved9;
|
|
};
|
|
union {
|
|
BitField<0, 2, u32> reserved10;
|
|
BitField<2, 10, u32> override_r;
|
|
BitField<12, 10, u32> override_g;
|
|
BitField<22, 10, u32> override_b;
|
|
};
|
|
union {
|
|
BitField<0, 10, u32> override_a;
|
|
BitField<10, 2, u32> reserved11;
|
|
BitField<12, 1, u32> use_override_r;
|
|
BitField<13, 1, u32> use_override_g;
|
|
BitField<14, 1, u32> use_override_b;
|
|
BitField<15, 1, u32> use_override_a;
|
|
BitField<16, 1, u32> mask_r;
|
|
BitField<17, 1, u32> mask_g;
|
|
BitField<18, 1, u32> mask_b;
|
|
BitField<19, 1, u32> mask_a;
|
|
BitField<20, 12, u32> reserved12;
|
|
};
|
|
};
|
|
static_assert(sizeof(BlendingSlotStruct) == 0x10, "BlendingSlotStruct has the wrong size!");
|
|
|
|
struct SlotStruct {
|
|
SlotConfig config;
|
|
SlotSurfaceConfig surface_config;
|
|
LumaKeyStruct luma_key;
|
|
MatrixStruct color_matrix;
|
|
MatrixStruct gamut_matrix;
|
|
BlendingSlotStruct blending;
|
|
};
|
|
static_assert(sizeof(SlotStruct) == 0xB0, "SlotStruct has the wrong size!");
|
|
|
|
struct ConfigStruct {
|
|
PipeConfig pipe_config;
|
|
OutputConfig output_config;
|
|
OutputSurfaceConfig output_surface_config;
|
|
MatrixStruct out_color_matrix;
|
|
std::array<ClearRectStruct, 4> clear_rects;
|
|
std::array<SlotStruct, 8> slot_structs;
|
|
};
|
|
static_assert(offsetof(ConfigStruct, pipe_config) == 0x0, "pipe_config is in the wrong place!");
|
|
static_assert(offsetof(ConfigStruct, output_config) == 0x10,
|
|
"output_config is in the wrong place!");
|
|
static_assert(offsetof(ConfigStruct, output_surface_config) == 0x20,
|
|
"output_surface_config is in the wrong place!");
|
|
static_assert(offsetof(ConfigStruct, out_color_matrix) == 0x30,
|
|
"out_color_matrix is in the wrong place!");
|
|
static_assert(offsetof(ConfigStruct, clear_rects) == 0x50, "clear_rects is in the wrong place!");
|
|
static_assert(offsetof(ConfigStruct, slot_structs) == 0x90, "slot_structs is in the wrong place!");
|
|
static_assert(sizeof(ConfigStruct) == 0x610, "ConfigStruct has the wrong size!");
|
|
|
|
struct VicRegisters {
|
|
static constexpr std::size_t NUM_REGS = 0x446;
|
|
|
|
union {
|
|
struct {
|
|
INSERT_PADDING_WORDS_NOINIT(0xC0);
|
|
u32 execute;
|
|
INSERT_PADDING_WORDS_NOINIT(0x3F);
|
|
std::array<std::array<PlaneOffsets, 8>, 8> surfaces;
|
|
u32 picture_index;
|
|
u32 control_params;
|
|
Offset config_struct_offset;
|
|
Offset filter_struct_offset;
|
|
Offset palette_offset;
|
|
Offset hist_offset;
|
|
u32 context_id;
|
|
u32 fce_ucode_size;
|
|
PlaneOffsets output_surface;
|
|
Offset fce_ucode_offset;
|
|
INSERT_PADDING_WORDS_NOINIT(0x4);
|
|
std::array<u32, 8> slot_context_ids;
|
|
std::array<Offset, 8> comp_tag_buffer_offsets;
|
|
std::array<Offset, 8> history_buffer_offset;
|
|
INSERT_PADDING_WORDS_NOINIT(0x25D);
|
|
u32 pm_trigger_end;
|
|
};
|
|
std::array<u32, NUM_REGS> reg_array;
|
|
};
|
|
};
|
|
static_assert(offsetof(VicRegisters, execute) == 0x300, "execute is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, surfaces) == 0x400, "surfaces is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, picture_index) == 0x700,
|
|
"picture_index is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, control_params) == 0x704,
|
|
"control_params is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, config_struct_offset) == 0x708,
|
|
"config_struct_offset is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, output_surface) == 0x720,
|
|
"output_surface is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, slot_context_ids) == 0x740,
|
|
"slot_context_ids is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, history_buffer_offset) == 0x780,
|
|
"history_buffer_offset is in the wrong place!");
|
|
static_assert(offsetof(VicRegisters, pm_trigger_end) == 0x1114,
|
|
"pm_trigger_end is in the wrong place!");
|
|
static_assert(sizeof(VicRegisters) == 0x1118, "VicRegisters has the wrong size!");
|
|
|
|
class Vic final : public CDmaPusher {
|
|
public:
|
|
enum class Method : u32 {
|
|
Execute = offsetof(VicRegisters, execute),
|
|
SetControlParams = offsetof(VicRegisters, control_params),
|
|
SetConfigStructOffset = offsetof(VicRegisters, config_struct_offset),
|
|
SetOutputSurfaceLumaOffset = offsetof(VicRegisters, output_surface.luma),
|
|
SetOutputSurfaceChromaOffset = offsetof(VicRegisters, output_surface.chroma_u),
|
|
SetOutputSurfaceChromaUnusedOffset = offsetof(VicRegisters, output_surface.chroma_v)
|
|
};
|
|
|
|
explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue);
|
|
~Vic();
|
|
|
|
/// Write to the device state.
|
|
void ProcessMethod(u32 method, u32 arg) override;
|
|
|
|
private:
|
|
void Execute();
|
|
|
|
void Blend(const ConfigStruct& config, const SlotStruct& slot);
|
|
|
|
template <bool Planar, bool Interlaced = false>
|
|
void ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
|
|
std::shared_ptr<const FFmpeg::Frame> frame);
|
|
template <bool Planar, bool TopField>
|
|
void ReadInterlacedY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
|
|
std::shared_ptr<const FFmpeg::Frame> frame);
|
|
|
|
template <bool Planar>
|
|
void ReadY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
|
|
std::shared_ptr<const FFmpeg::Frame> frame);
|
|
|
|
void WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config);
|
|
|
|
template <VideoPixelFormat Format>
|
|
void WriteABGR(const OutputSurfaceConfig& output_surface_config);
|
|
|
|
s32 id;
|
|
s32 nvdec_id{-1};
|
|
u32 syncpoint;
|
|
|
|
VicRegisters regs{};
|
|
FrameQueue& frame_queue;
|
|
|
|
const bool has_sse41{false};
|
|
|
|
Common::ScratchBuffer<Pixel> output_surface;
|
|
Common::ScratchBuffer<Pixel> slot_surface;
|
|
Common::ScratchBuffer<u8> luma_scratch;
|
|
Common::ScratchBuffer<u8> chroma_scratch;
|
|
Common::ScratchBuffer<u8> swizzle_scratch;
|
|
};
|
|
|
|
} // namespace Tegra::Host1x
|