mirror of
https://github.com/curioustorvald/tsvm.git
synced 2026-03-07 19:51:51 +09:00
915 lines
32 KiB
JavaScript
915 lines
32 KiB
JavaScript
// Created by CuriousTorvald and Claude on 2025-08-18.
|
|
// TSVM Enhanced Video (TEV) Format Decoder - YCoCg-R 4:2:0 Version
|
|
// Usage: playtev moviefile.tev [options]
|
|
// Options: -i (interactive), -debug-mv (show motion vector debug visualization)
|
|
// -deinterlace=algorithm (yadif or bwdif, default: yadif)
|
|
// -nodeblock (disable post-processing deblocking filter)
|
|
// -boundaryaware (enable boundary-aware decoding to prevent artifacts at DCT level)
|
|
|
|
const WIDTH = 560
|
|
const HEIGHT = 448
|
|
const BLOCK_SIZE = 16 // 16x16 blocks for YCoCg-R
|
|
const TEV_MAGIC = [0x1F, 0x54, 0x53, 0x56, 0x4D, 0x54, 0x45, 0x56] // "\x1FTSVM TEV"
|
|
const TEV_VERSION_YCOCG = 2 // YCoCg-R version
|
|
const TEV_VERSION_ICtCp = 3 // ICtCp version
|
|
const SND_BASE_ADDR = audio.getBaseAddr()
|
|
const pcm = require("pcm")
|
|
const MP2_FRAME_SIZE = [144,216,252,288,360,432,504,576,720,864,1008,1152,1440,1728]
|
|
|
|
// Block encoding modes
|
|
const TEV_MODE_SKIP = 0x00
|
|
const TEV_MODE_INTRA = 0x01
|
|
const TEV_MODE_INTER = 0x02
|
|
const TEV_MODE_MOTION = 0x03
|
|
|
|
// Packet types
|
|
const TEV_PACKET_IFRAME = 0x10
|
|
const TEV_PACKET_PFRAME = 0x11
|
|
const TEV_PACKET_AUDIO_MP2 = 0x20
|
|
const TEV_PACKET_SUBTITLE = 0x30 // Legacy SSF (frame-locked)
|
|
const TEV_PACKET_SUBTITLE_TC = 0x31 // SSF-TC (timecode-based)
|
|
const TEV_PACKET_SYNC = 0xFF
|
|
|
|
// Subtitle opcodes (SSF format)
|
|
const SSF_OP_NOP = 0x00
|
|
const SSF_OP_SHOW = 0x01
|
|
const SSF_OP_HIDE = 0x02
|
|
const SSF_OP_MOVE = 0x03
|
|
const SSF_OP_UPLOAD_LOW_FONT = 0x80
|
|
const SSF_OP_UPLOAD_HIGH_FONT = 0x81
|
|
|
|
// Subtitle state
|
|
let subtitleVisible = false
|
|
let subtitleText = ""
|
|
let subtitlePosition = 0 // 0=bottom center (default)
|
|
|
|
// SSF-TC subtitle event buffer
|
|
let subtitleEvents = [] // Array of {timecode_ns, index, opcode, text}
|
|
let nextSubtitleEventIndex = 0 // Next event to check
|
|
|
|
// Parse command line options
|
|
let interactive = false
|
|
let debugMotionVectors = false
|
|
let deinterlaceAlgorithm = "yadif"
|
|
let enableDeblocking = false // Default: disabled (use -deblock to enable)
|
|
let enableBoundaryAwareDecoding = false // Default: disabled (use -boundaryaware to enable) // suitable for still frame and slide shows, absolutely unsuitable for videos
|
|
|
|
if (exec_args.length > 2) {
|
|
for (let i = 2; i < exec_args.length; i++) {
|
|
const arg = exec_args[i].toLowerCase()
|
|
if (arg === "-i") {
|
|
interactive = true
|
|
} else if (arg === "-debug-mv") {
|
|
debugMotionVectors = true
|
|
} else if (arg === "-deblock") {
|
|
enableDeblocking = true
|
|
} else if (arg === "-boundaryaware") {
|
|
enableBoundaryAwareDecoding = true
|
|
} else if (arg.startsWith("-deinterlace=")) {
|
|
deinterlaceAlgorithm = arg.substring(13)
|
|
}
|
|
}
|
|
}
|
|
const fullFilePath = _G.shell.resolvePathInput(exec_args[1])
|
|
const FILE_LENGTH = files.open(fullFilePath.full).size
|
|
|
|
let videoRateBin = []
|
|
let errorlevel = 0
|
|
let notifHideTimer = 0
|
|
const NOTIF_SHOWUPTIME = 3000000000
|
|
let [cy, cx] = con.getyx()
|
|
|
|
let gui = require("playgui")
|
|
let seqread = undefined
|
|
let fullFilePathStr = fullFilePath.full
|
|
|
|
// Select seqread driver to use
|
|
if (fullFilePathStr.startsWith('$:/TAPE') || fullFilePathStr.startsWith('$:\\TAPE')) {
|
|
seqread = require("seqreadtape")
|
|
seqread.prepare(fullFilePathStr)
|
|
seqread.seek(0)
|
|
} else {
|
|
seqread = require("seqread")
|
|
seqread.prepare(fullFilePathStr)
|
|
}
|
|
|
|
con.clear()
|
|
con.curs_set(0)
|
|
graphics.setGraphicsMode(4) // 4096-color mode
|
|
graphics.clearPixels(0)
|
|
graphics.clearPixels2(0)
|
|
|
|
// Initialize audio
|
|
audio.resetParams(0)
|
|
audio.purgeQueue(0)
|
|
audio.setPcmMode(0)
|
|
audio.setMasterVolume(0, 255)
|
|
|
|
// set colour zero as half-opaque black
|
|
graphics.setPalette(0, 0, 0, 0, 9)
|
|
|
|
// Subtitle display functions
|
|
function clearSubtitleArea() {
|
|
// Clear the subtitle area at the bottom of the screen
|
|
// Text mode is 80x32, so clear the bottom few lines
|
|
let oldFgColor = con.get_color_fore()
|
|
let oldBgColor = con.get_color_back()
|
|
|
|
con.color_pair(255, 255) // transparent to clear
|
|
|
|
// Clear bottom 4 lines for subtitles
|
|
for (let row = 29; row <= 32; row++) {
|
|
con.move(row, 1)
|
|
for (let col = 1; col <= 80; col++) {
|
|
print(" ")
|
|
}
|
|
}
|
|
|
|
con.color_pair(oldFgColor, oldBgColor)
|
|
}
|
|
|
|
function getVisualLength(line) {
|
|
// Calculate the visual length of a line excluding formatting tags
|
|
let visualLength = 0
|
|
let i = 0
|
|
|
|
while (i < line.length) {
|
|
if (i < line.length - 2 && line[i] === '<') {
|
|
// Check for formatting tags and skip them
|
|
if (line.substring(i, i + 3).toLowerCase() === '<b>' ||
|
|
line.substring(i, i + 3).toLowerCase() === '<i>') {
|
|
i += 3 // Skip tag
|
|
} else if (i < line.length - 3 &&
|
|
(line.substring(i, i + 4).toLowerCase() === '</b>' ||
|
|
line.substring(i, i + 4).toLowerCase() === '</i>')) {
|
|
i += 4 // Skip closing tag
|
|
} else {
|
|
// Not a formatting tag, count the character
|
|
visualLength++
|
|
i++
|
|
}
|
|
} else {
|
|
// Regular character, count it
|
|
visualLength++
|
|
i++
|
|
}
|
|
}
|
|
|
|
return visualLength
|
|
}
|
|
|
|
function displayFormattedLine(line) {
|
|
// Parse line and handle <b> and <i> tags with color changes
|
|
// Default subtitle color: yellow (231), formatted text: white (254)
|
|
|
|
let i = 0
|
|
let inBoldOrItalic = false
|
|
|
|
// insert initial padding block
|
|
con.color_pair(0, 255)
|
|
con.prnch(0xDE)
|
|
con.color_pair(231, 0)
|
|
|
|
while (i < line.length) {
|
|
if (i < line.length - 2 && line[i] === '<') {
|
|
// Check for opening tags
|
|
if (line.substring(i, i + 3).toLowerCase() === '<b>' ||
|
|
line.substring(i, i + 3).toLowerCase() === '<i>') {
|
|
con.color_pair(254, 0) // Switch to white for formatted text
|
|
inBoldOrItalic = true
|
|
i += 3
|
|
} else if (i < line.length - 3 &&
|
|
(line.substring(i, i + 4).toLowerCase() === '</b>' ||
|
|
line.substring(i, i + 4).toLowerCase() === '</i>')) {
|
|
con.color_pair(231, 0) // Switch back to yellow for normal text
|
|
inBoldOrItalic = false
|
|
i += 4
|
|
} else {
|
|
// Not a formatting tag, print the character
|
|
print(line[i])
|
|
i++
|
|
}
|
|
} else {
|
|
// Regular character, print it
|
|
print(line[i])
|
|
i++
|
|
}
|
|
}
|
|
|
|
// insert final padding block
|
|
con.color_pair(0, 255)
|
|
con.prnch(0xDD)
|
|
con.color_pair(231, 0)
|
|
}
|
|
|
|
function displaySubtitle(text, position = 0) {
|
|
if (!text || text.length === 0) {
|
|
clearSubtitleArea()
|
|
return
|
|
}
|
|
|
|
// Set subtitle colors: yellow (231) on black (0)
|
|
let oldFgColor = con.get_color_fore()
|
|
let oldBgColor = con.get_color_back()
|
|
con.color_pair(231, 0)
|
|
|
|
// Split text into lines
|
|
let lines = text.split('\n')
|
|
|
|
// Calculate position based on subtitle position setting
|
|
let startRow, startCol
|
|
// Calculate visual length without formatting tags for positioning
|
|
let longestLineLength = lines.map(s => getVisualLength(s)).sort().last()
|
|
|
|
switch (position) {
|
|
case 2: // center left
|
|
case 6: // center right
|
|
case 8: // dead center
|
|
startRow = 16 - Math.floor(lines.length / 2)
|
|
break
|
|
case 3: // top left
|
|
case 4: // top center
|
|
case 5: // top right
|
|
startRow = 2
|
|
break
|
|
case 0: // bottom center
|
|
case 1: // bottom left
|
|
case 7: // bottom right
|
|
default:
|
|
startRow = 32 - lines.length
|
|
startRow = 32 - lines.length
|
|
startRow = 32 - lines.length // Default to bottom center
|
|
}
|
|
|
|
// Display each line
|
|
for (let i = 0; i < lines.length; i++) {
|
|
let line = lines[i].trim()
|
|
if (line.length === 0) continue
|
|
|
|
let row = startRow + i
|
|
if (row < 1) row = 1
|
|
if (row > 32) row = 32
|
|
|
|
// Calculate column based on alignment
|
|
switch (position) {
|
|
case 1: // bottom left
|
|
case 2: // center left
|
|
case 3: // top left
|
|
startCol = 1
|
|
break
|
|
case 5: // top right
|
|
case 6: // center right
|
|
case 7: // bottom right
|
|
startCol = Math.max(1, 78 - getVisualLength(line) - 2)
|
|
break
|
|
case 0: // bottom center
|
|
case 4: // top center
|
|
case 8: // dead center
|
|
default:
|
|
startCol = Math.max(1, Math.floor((80 - longestLineLength - 2) / 2) + 1)
|
|
break
|
|
}
|
|
|
|
con.move(row, startCol)
|
|
|
|
// Parse and display line with formatting tag support
|
|
displayFormattedLine(line)
|
|
}
|
|
|
|
con.color_pair(oldFgColor, oldBgColor)
|
|
}
|
|
|
|
// Parse SSF-TC subtitle packet and add to event buffer (0x31)
|
|
function parseSubtitlePacketTC(packetSize) {
|
|
// Read subtitle index (24-bit, little-endian)
|
|
let indexByte0 = seqread.readOneByte()
|
|
let indexByte1 = seqread.readOneByte()
|
|
let indexByte2 = seqread.readOneByte()
|
|
let index = indexByte0 | (indexByte1 << 8) | (indexByte2 << 16)
|
|
|
|
// Read timecode (64-bit, little-endian)
|
|
let timecode_ns = 0
|
|
for (let i = 0; i < 8; i++) {
|
|
let byte = seqread.readOneByte()
|
|
timecode_ns += byte * Math.pow(2, i * 8)
|
|
}
|
|
|
|
// Read opcode
|
|
let opcode = seqread.readOneByte()
|
|
let remainingBytes = packetSize - 12 // Subtract 3 (index) + 8 (timecode) + 1 (opcode)
|
|
|
|
// Read text if present
|
|
let text = null
|
|
if (remainingBytes > 1 && (opcode === SSF_OP_SHOW || (opcode >= 0x10 && opcode <= 0x2F))) {
|
|
let textBytes = seqread.readBytes(remainingBytes)
|
|
text = ""
|
|
for (let i = 0; i < remainingBytes - 1; i++) { // -1 for null terminator
|
|
let byte = sys.peek(textBytes + i)
|
|
if (byte === 0) break
|
|
text += String.fromCharCode(byte)
|
|
}
|
|
sys.free(textBytes)
|
|
} else if (remainingBytes > 0) {
|
|
// Skip remaining bytes
|
|
let skipBytes = seqread.readBytes(remainingBytes)
|
|
sys.free(skipBytes)
|
|
}
|
|
|
|
// Add event to buffer
|
|
subtitleEvents.push({
|
|
timecode_ns: timecode_ns,
|
|
index: index,
|
|
opcode: opcode,
|
|
text: text
|
|
})
|
|
}
|
|
|
|
// Process subtitle events based on current playback time
|
|
function processSubtitleEvents(currentTimeNs) {
|
|
// Process all events whose timecode has been reached
|
|
while (nextSubtitleEventIndex < subtitleEvents.length) {
|
|
let event = subtitleEvents[nextSubtitleEventIndex]
|
|
|
|
if (event.timecode_ns > currentTimeNs) {
|
|
break // Haven't reached this event yet
|
|
}
|
|
|
|
// Execute the subtitle event
|
|
switch (event.opcode) {
|
|
case SSF_OP_SHOW:
|
|
subtitleText = event.text || ""
|
|
subtitleVisible = true
|
|
displaySubtitle(subtitleText, subtitlePosition)
|
|
break
|
|
|
|
case SSF_OP_HIDE:
|
|
subtitleVisible = false
|
|
subtitleText = ""
|
|
clearSubtitleArea()
|
|
break
|
|
|
|
case SSF_OP_MOVE:
|
|
if (event.text && event.text.length > 0) {
|
|
let newPosition = event.text.charCodeAt(0)
|
|
if (newPosition >= 0 && newPosition <= 8) {
|
|
subtitlePosition = newPosition
|
|
if (subtitleVisible && subtitleText.length > 0) {
|
|
clearSubtitleArea()
|
|
displaySubtitle(subtitleText, subtitlePosition)
|
|
}
|
|
}
|
|
}
|
|
break
|
|
|
|
case SSF_OP_UPLOAD_LOW_FONT:
|
|
case SSF_OP_UPLOAD_HIGH_FONT:
|
|
// Font upload handled during packet parsing
|
|
break
|
|
}
|
|
|
|
nextSubtitleEventIndex++
|
|
}
|
|
}
|
|
|
|
// Process legacy frame-locked subtitle packet (0x30)
|
|
function processSubtitlePacket(packetSize) {
|
|
// Read subtitle packet data according to SSF format
|
|
// uint24 index + uint8 opcode + variable arguments
|
|
|
|
let index = 0
|
|
// Read 24-bit index (little-endian)
|
|
let indexByte0 = seqread.readOneByte()
|
|
let indexByte1 = seqread.readOneByte()
|
|
let indexByte2 = seqread.readOneByte()
|
|
index = indexByte0 | (indexByte1 << 8) | (indexByte2 << 16)
|
|
|
|
let opcode = seqread.readOneByte()
|
|
let remainingBytes = packetSize - 4 // Subtract 3 bytes for index + 1 byte for opcode
|
|
|
|
switch (opcode) {
|
|
case SSF_OP_SHOW: {
|
|
// Read UTF-8 text until null terminator
|
|
if (remainingBytes > 1) {
|
|
let textBytes = seqread.readBytes(remainingBytes)
|
|
let textStr = ""
|
|
|
|
// Convert bytes to string, stopping at null terminator
|
|
for (let i = 0; i < remainingBytes - 1; i++) { // -1 for null terminator
|
|
let byte = sys.peek(textBytes + i)
|
|
if (byte === 0) break
|
|
textStr += String.fromCharCode(byte)
|
|
}
|
|
|
|
sys.free(textBytes)
|
|
subtitleText = textStr
|
|
subtitleVisible = true
|
|
displaySubtitle(subtitleText, subtitlePosition)
|
|
}
|
|
break
|
|
}
|
|
|
|
case SSF_OP_HIDE: {
|
|
subtitleVisible = false
|
|
subtitleText = ""
|
|
clearSubtitleArea()
|
|
break
|
|
}
|
|
|
|
case SSF_OP_MOVE: {
|
|
if (remainingBytes >= 2) { // Need at least 1 byte for position + 1 null terminator
|
|
let newPosition = seqread.readOneByte()
|
|
seqread.readOneByte() // Read null terminator
|
|
|
|
if (newPosition >= 0 && newPosition <= 7) {
|
|
subtitlePosition = newPosition
|
|
|
|
// Re-display current subtitle at new position if visible
|
|
if (subtitleVisible && subtitleText.length > 0) {
|
|
clearSubtitleArea()
|
|
displaySubtitle(subtitleText, subtitlePosition)
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
case SSF_OP_UPLOAD_LOW_FONT:
|
|
case SSF_OP_UPLOAD_HIGH_FONT: {
|
|
// Font upload - read payload length and font data
|
|
if (remainingBytes >= 3) { // uint16 length + at least 1 byte data
|
|
let payloadLen = seqread.readShort()
|
|
if (remainingBytes >= payloadLen + 2) {
|
|
let fontData = seqread.readBytes(payloadLen)
|
|
|
|
// upload font data
|
|
for (let i = 0; i < Math.min(payloadLen, 1920); i++) sys.poke(-1300607 - i, sys.peek(fontData + i))
|
|
sys.poke(-1299460, (opcode == SSF_OP_UPLOAD_LOW_FONT) ? 18 : 19)
|
|
|
|
sys.free(fontData)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
case SSF_OP_NOP:
|
|
default: {
|
|
// Skip remaining bytes
|
|
if (remainingBytes > 0) {
|
|
let skipBytes = seqread.readBytes(remainingBytes)
|
|
sys.free(skipBytes)
|
|
}
|
|
|
|
if (interactive && opcode !== SSF_OP_NOP) {
|
|
serial.println(`[SUBTITLE UNKNOWN] Index: ${index}, Opcode: 0x${opcode.toString(16).padStart(2, '0')}`)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check magic number
|
|
let magic = seqread.readBytes(8)
|
|
let magicMatching = true
|
|
let actualMagic = []
|
|
|
|
TEV_MAGIC.forEach((b, i) => {
|
|
let testb = sys.peek(magic + i) & 255
|
|
actualMagic.push(testb)
|
|
if (testb != b) {
|
|
magicMatching = false
|
|
}
|
|
})
|
|
sys.free(magic)
|
|
|
|
if (!magicMatching) {
|
|
println("Not a TEV file (MAGIC mismatch) -- got " + actualMagic.join())
|
|
return 1
|
|
}
|
|
|
|
// Read header
|
|
let version = seqread.readOneByte()
|
|
if (version !== TEV_VERSION_YCOCG && version !== TEV_VERSION_ICtCp) {
|
|
println(`Unsupported TEV version: ${version} (expected ${TEV_VERSION_YCOCG} for YCoCg-R or ${TEV_VERSION_ICtCp} for ICtCp)`)
|
|
return 1
|
|
}
|
|
|
|
let colorSpace = (version === TEV_VERSION_ICtCp) ? "ICtCp" : "YCoCg"
|
|
if (interactive) {
|
|
con.move(1,1)
|
|
println(`Push and hold Backspace to exit | ${colorSpace} | Deblock: ${enableDeblocking ? 'ON' : 'OFF'} | EdgeAware: ${enableBoundaryAwareDecoding ? 'ON' : 'OFF'}`);
|
|
}
|
|
|
|
let width = seqread.readShort()
|
|
let height = seqread.readShort()
|
|
let fps = seqread.readOneByte()
|
|
let totalFrames = seqread.readInt()
|
|
let qualityY = seqread.readOneByte()
|
|
let qualityCo = seqread.readOneByte()
|
|
let qualityCg = seqread.readOneByte()
|
|
let flags = seqread.readOneByte()
|
|
let hasAudio = !!(flags & 1)
|
|
let hasSubtitle = !!(flags & 2)
|
|
let videoFlags = seqread.readOneByte()
|
|
let isInterlaced = !!(videoFlags & 1)
|
|
let isNTSC = !!(videoFlags & 2)
|
|
let unused2 = seqread.readOneByte()
|
|
|
|
|
|
serial.println(`Video metadata:`)
|
|
serial.println(` Frames: ${totalFrames}`)
|
|
serial.println(` FPS: ${(isNTSC) ? (fps * 1000 / 1001) : fps}`)
|
|
serial.println(` Duration: ${totalFrames / fps}`)
|
|
serial.println(` Audio: ${hasAudio ? "Yes" : "No"}`)
|
|
serial.println(` Resolution: ${width}x${height}, ${isInterlaced ? "interlaced" : "progressive"}`)
|
|
serial.println(` Quality: Y=${qualityY}, Co=${qualityCo}, Cg=${qualityCg}`)
|
|
|
|
|
|
// DEBUG interlace raw output
|
|
//if (isInterlaced) {
|
|
// height = height >> 1
|
|
// isInterlaced = false
|
|
//}
|
|
// END OF DEBUG
|
|
|
|
|
|
serial.println(`TEV Format ${version} (${colorSpace}); Q: ${qualityY} ${qualityCo} ${qualityCg}; Interlaced: ${isInterlaced ? 'Yes' : 'No'}`)
|
|
|
|
function updateDataRateBin(rate) {
|
|
videoRateBin.push(rate)
|
|
if (videoRateBin.length > fps) {
|
|
videoRateBin.shift()
|
|
}
|
|
}
|
|
|
|
function getVideoRate() {
|
|
let baseRate = videoRateBin.reduce((a, c) => a + c, 0)
|
|
let mult = fps / videoRateBin.length
|
|
return baseRate * mult
|
|
}
|
|
|
|
let FRAME_TIME = 1.0 / fps
|
|
let FRAME_TIME_NS = (1000000000.0 / fps) // Frame time in nanoseconds for subtitle timing
|
|
// Ultra-fast approach: always render to display, use dedicated previous frame buffer
|
|
const FRAME_PIXELS = width * height
|
|
|
|
// Frame buffer addresses for graphics display
|
|
const DISPLAY_RG_ADDR = -1048577 // Main graphics RG plane (displayed)
|
|
const DISPLAY_BA_ADDR = -1310721 // Main graphics BA plane (displayed)
|
|
|
|
// RGB frame buffers (24-bit: R,G,B per pixel)
|
|
const FRAME_SIZE = 560*448*3 // Total frame size = 752,640 bytes
|
|
|
|
// Ping-pong frame buffers to eliminate memcpy overhead
|
|
const RGB_BUFFER_A = sys.malloc(FRAME_SIZE)
|
|
const RGB_BUFFER_B = sys.malloc(FRAME_SIZE)
|
|
|
|
// Static Yadif deinterlacing buffers (half-height field buffers for interlaced mode)
|
|
const FIELD_SIZE = 560 * 224 * 3 // Half-height field buffer size
|
|
const CURR_FIELD_BUFFER = isInterlaced ? sys.malloc(FIELD_SIZE) : 0
|
|
const PREV_FIELD_BUFFER = isInterlaced ? sys.malloc(FIELD_SIZE) : 0
|
|
const NEXT_FIELD_BUFFER = isInterlaced ? sys.malloc(FIELD_SIZE) : 0 // For temporal prediction
|
|
|
|
// Ping-pong buffer pointers (swap instead of copy)
|
|
let CURRENT_RGB_ADDR = RGB_BUFFER_A
|
|
let PREV_RGB_ADDR = RGB_BUFFER_B
|
|
|
|
// Initialize RGB frame buffers to black (0,0,0)
|
|
sys.memset(RGB_BUFFER_A, 0, FRAME_PIXELS * 3)
|
|
sys.memset(RGB_BUFFER_B, 0, FRAME_PIXELS * 3)
|
|
|
|
// Initialize Yadif field buffers to black
|
|
sys.memset(CURR_FIELD_BUFFER, 0, FIELD_SIZE)
|
|
sys.memset(PREV_FIELD_BUFFER, 0, FIELD_SIZE)
|
|
sys.memset(NEXT_FIELD_BUFFER, 0, FIELD_SIZE)
|
|
|
|
// Initialize display framebuffer to black
|
|
sys.memset(DISPLAY_RG_ADDR, 0, FRAME_PIXELS) // Black in RG plane
|
|
sys.memset(DISPLAY_BA_ADDR, 15, FRAME_PIXELS) // Black with alpha=15 (opaque) in BA plane
|
|
|
|
let frameCount = 0
|
|
let trueFrameCount = 0
|
|
let stopPlay = false
|
|
let akku = FRAME_TIME
|
|
let akku2 = 0.0
|
|
|
|
// Frame buffering for temporal prediction (interlaced mode only)
|
|
let bufferedFrames = [] // Queue of decoded frames for temporal prediction
|
|
let frameBuffer1 = null // Current frame data
|
|
let frameBuffer2 = null // Previous frame data
|
|
let frameDisplayDelay = 1 // Display frames 1 frame delayed for temporal prediction
|
|
let mp2Initialised = false
|
|
let audioFired = false
|
|
|
|
// Performance tracking variables
|
|
let decompressTime = 0
|
|
let decodeTime = 0
|
|
let uploadTime = 0
|
|
let biasTime = 0
|
|
|
|
const BIAS_LIGHTING_MIN = 1.0 / 16.0
|
|
let oldBgcol = [BIAS_LIGHTING_MIN, BIAS_LIGHTING_MIN, BIAS_LIGHTING_MIN]
|
|
|
|
let notifHidden = false
|
|
|
|
function getRGBfromScr(x, y) {
|
|
let offset = y * WIDTH + x
|
|
let rg = sys.peek(-1048577 - offset)
|
|
let ba = sys.peek(-1310721 - offset)
|
|
|
|
return [(rg >>> 4) / 15.0, (rg & 15) / 15.0, (ba >>> 4) / 15.0]
|
|
}
|
|
|
|
function setBiasLighting() {
|
|
let samples = []
|
|
|
|
// Get native resolution for centering calculation
|
|
let nativeWidth = graphics.getPixelDimension()[0]
|
|
let nativeHeight = graphics.getPixelDimension()[1]
|
|
|
|
// Calculate video position offset (centered)
|
|
let offsetX = Math.floor((nativeWidth - width) / 2)
|
|
let offsetY = Math.floor((nativeHeight - height) / 2)
|
|
|
|
// Sample from video borders, scaled to actual video dimensions
|
|
let sampleStepX = Math.max(8, Math.floor(width / 18)) // ~18 samples across width
|
|
let sampleStepY = Math.max(8, Math.floor(height / 17)) // ~17 samples across height
|
|
let borderMargin = Math.min(8, Math.floor(width / 70)) // Proportional border margin
|
|
|
|
// Sample top and bottom borders
|
|
for (let x = borderMargin; x < width - borderMargin; x += sampleStepX) {
|
|
samples.push(getRGBfromScr(x + offsetX, borderMargin + offsetY))
|
|
samples.push(getRGBfromScr(x + offsetX, height - borderMargin - 1 + offsetY))
|
|
}
|
|
|
|
// Sample left and right borders
|
|
for (let y = borderMargin; y < height - borderMargin; y += sampleStepY) {
|
|
samples.push(getRGBfromScr(borderMargin + offsetX, y + offsetY))
|
|
samples.push(getRGBfromScr(width - borderMargin - 1 + offsetX, y + offsetY))
|
|
}
|
|
|
|
let out = [0.0, 0.0, 0.0]
|
|
samples.forEach(rgb=>{
|
|
out[0] += rgb[0]
|
|
out[1] += rgb[1]
|
|
out[2] += rgb[2]
|
|
})
|
|
out[0] = BIAS_LIGHTING_MIN + (out[0] / samples.length / 2.0) // darken a bit
|
|
out[1] = BIAS_LIGHTING_MIN + (out[1] / samples.length / 2.0)
|
|
out[2] = BIAS_LIGHTING_MIN + (out[2] / samples.length / 2.0)
|
|
|
|
let bgr = (oldBgcol[0]*5 + out[0]) / 6.0
|
|
let bgg = (oldBgcol[1]*5 + out[1]) / 6.0
|
|
let bgb = (oldBgcol[2]*5 + out[2]) / 6.0
|
|
|
|
oldBgcol = [bgr, bgg, bgb]
|
|
|
|
graphics.setBackground(Math.round(bgr * 255), Math.round(bgg * 255), Math.round(bgb * 255))
|
|
}
|
|
|
|
let blockDataPtr = sys.malloc(FRAME_SIZE)
|
|
|
|
// Streaming frame buffer rotation for temporal prediction
|
|
// Buffers rotate: NEXT -> CURRENT -> PREV each frame
|
|
let currentFieldAddr = CURR_FIELD_BUFFER // Currently being decoded
|
|
let prevFieldAddr = PREV_FIELD_BUFFER // Previous field for temporal prediction
|
|
let nextFieldAddr = NEXT_FIELD_BUFFER // Next field for temporal prediction
|
|
|
|
function rotateFieldBuffers() {
|
|
// Rotate buffers: NEXT -> CURRENT -> PREV
|
|
let temp = prevFieldAddr
|
|
prevFieldAddr = currentFieldAddr
|
|
currentFieldAddr = nextFieldAddr
|
|
nextFieldAddr = temp
|
|
}
|
|
|
|
let frameDuped = false
|
|
let currentFrameType = "I"
|
|
|
|
// Main decoding loop - simplified for performance
|
|
try {
|
|
let t1 = sys.nanoTime()
|
|
while (!stopPlay && seqread.getReadCount() < FILE_LENGTH /*&& trueFrameCount < totalFrames*/) {
|
|
|
|
// Handle interactive controls
|
|
if (interactive) {
|
|
sys.poke(-40, 1)
|
|
if (sys.peek(-41) == 67) { // Backspace
|
|
stopPlay = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if (akku >= FRAME_TIME) {
|
|
// Read packet (1 byte: type)
|
|
let packetType = seqread.readOneByte()
|
|
|
|
if (packetType == 0xFF) { // Sync packet
|
|
akku -= FRAME_TIME
|
|
|
|
// Sync packet - frame complete
|
|
frameCount++
|
|
trueFrameCount++
|
|
|
|
// Swap ping-pong buffers instead of expensive memcpy (752KB copy eliminated!)
|
|
let temp = CURRENT_RGB_ADDR
|
|
CURRENT_RGB_ADDR = PREV_RGB_ADDR
|
|
PREV_RGB_ADDR = temp
|
|
|
|
} else if (packetType == TEV_PACKET_IFRAME || packetType == TEV_PACKET_PFRAME) {
|
|
// Video frame packet
|
|
let payloadLen = seqread.readInt()
|
|
let compressedPtr = seqread.readBytes(payloadLen)
|
|
updateDataRateBin(payloadLen)
|
|
|
|
|
|
// Basic sanity check on compressed data
|
|
if (payloadLen <= 0 || payloadLen > 1000000) {
|
|
serial.println(`Frame ${frameCount}: Invalid payload length: ${payloadLen}`)
|
|
sys.free(compressedPtr)
|
|
continue
|
|
}
|
|
|
|
// Decompress using gzip
|
|
// Optimized buffer size calculation for TEV YCoCg-R blocks
|
|
let actualSize
|
|
let decompressStart = sys.nanoTime()
|
|
try {
|
|
// Use gzip decompression (only compression format supported in TSVM JS)
|
|
actualSize = gzip.decompFromTo(compressedPtr, payloadLen, blockDataPtr)
|
|
decompressTime = (sys.nanoTime() - decompressStart) / 1000000.0 // Convert to milliseconds
|
|
} catch (e) {
|
|
// Decompression failed - skip this frame
|
|
decompressTime = (sys.nanoTime() - decompressStart) / 1000000.0 // Still measure time
|
|
serial.println(`Frame ${frameCount}: Gzip decompression failed, skipping (compressed size: ${payloadLen}, error: ${e})`)
|
|
sys.free(compressedPtr)
|
|
continue
|
|
}
|
|
|
|
// Hardware-accelerated TEV decoding to RGB buffers (YCoCg-R or ICtCp based on version)
|
|
try {
|
|
// duplicate every 1000th frame (pass a turn every 1000n+501st) if NTSC
|
|
if (!isNTSC || frameCount % 1000 != 501 || frameDuped) {
|
|
frameDuped = false
|
|
|
|
let decodeStart = sys.nanoTime()
|
|
let decodingHeight = isInterlaced ? (height / 2)|0 : height
|
|
|
|
if (isInterlaced) {
|
|
// For interlaced: decode current frame into currentFieldAddr
|
|
// For display: use prevFieldAddr as current, currentFieldAddr as next
|
|
graphics.tevDecode(blockDataPtr, nextFieldAddr, currentFieldAddr, width, decodingHeight, qualityY, qualityCo, qualityCg, trueFrameCount, debugMotionVectors, version, enableDeblocking, enableBoundaryAwareDecoding)
|
|
graphics.tevDeinterlace(trueFrameCount, width, decodingHeight, prevFieldAddr, currentFieldAddr, nextFieldAddr, CURRENT_RGB_ADDR, deinterlaceAlgorithm)
|
|
|
|
// Rotate field buffers for next frame: NEXT -> CURRENT -> PREV
|
|
rotateFieldBuffers()
|
|
} else {
|
|
// Progressive or first frame: normal decoding without temporal prediction
|
|
graphics.tevDecode(blockDataPtr, CURRENT_RGB_ADDR, PREV_RGB_ADDR, width, decodingHeight, qualityY, qualityCo, qualityCg, trueFrameCount, debugMotionVectors, version, enableDeblocking, enableBoundaryAwareDecoding)
|
|
}
|
|
|
|
decodeTime = (sys.nanoTime() - decodeStart) / 1000000.0 // Convert to milliseconds
|
|
|
|
|
|
// Upload RGB buffer to display framebuffer with dithering
|
|
let uploadStart = sys.nanoTime()
|
|
graphics.uploadRGBToFramebuffer(CURRENT_RGB_ADDR, width, height, frameCount, false)
|
|
uploadTime = (sys.nanoTime() - uploadStart) / 1000000.0 // Convert to milliseconds
|
|
}
|
|
else {
|
|
frameCount -= 1
|
|
frameDuped = true
|
|
serial.println(`Frame ${frameCount}: Duplicating previous frame`)
|
|
}
|
|
|
|
// Process SSF-TC subtitle events based on current playback time
|
|
if (subtitleEvents.length > 0) {
|
|
let currentTimeNs = frameCount * FRAME_TIME_NS
|
|
processSubtitleEvents(currentTimeNs)
|
|
}
|
|
|
|
// Defer audio playback until a first frame is sent
|
|
if (isInterlaced) {
|
|
// fire audio after frame 1
|
|
if (!audioFired && frameCount > 0) {
|
|
audio.play(0)
|
|
audioFired = true
|
|
}
|
|
}
|
|
else {
|
|
// fire audio after frame 0
|
|
if (!audioFired) {
|
|
audio.play(0)
|
|
audioFired = true
|
|
}
|
|
}
|
|
} catch (e) {
|
|
serial.println(`Frame ${frameCount}: Hardware ${colorSpace} decode failed: ${e}`)
|
|
}
|
|
|
|
sys.free(compressedPtr)
|
|
|
|
let biasStart = sys.nanoTime()
|
|
setBiasLighting()
|
|
biasTime = (sys.nanoTime() - biasStart) / 1000000.0 // Convert to milliseconds
|
|
|
|
// Log performance data every 60 frames (and also frame 0 for debugging)
|
|
if (frameCount % 60 == 0 || frameCount == 0) {
|
|
let totalTime = decompressTime + decodeTime + uploadTime + biasTime
|
|
serial.println(`Frame ${frameCount}: Decompress=${decompressTime.toFixed(1)}ms, Decode=${decodeTime.toFixed(1)}ms, Upload=${uploadTime.toFixed(1)}ms, Bias=${biasTime.toFixed(1)}ms, Total=${totalTime.toFixed(1)}ms`)
|
|
}
|
|
|
|
currentFrameType = packetType == TEV_PACKET_IFRAME ? "I" : "P"
|
|
|
|
} else if (packetType == TEV_PACKET_AUDIO_MP2) {
|
|
// MP2 Audio packet
|
|
let audioLen = seqread.readInt()
|
|
|
|
if (!mp2Initialised) {
|
|
mp2Initialised = true
|
|
audio.mp2Init()
|
|
}
|
|
|
|
seqread.readBytes(audioLen, SND_BASE_ADDR - 2368)
|
|
audio.mp2Decode()
|
|
audio.mp2UploadDecoded(0)
|
|
|
|
} else if (packetType == TEV_PACKET_SUBTITLE) {
|
|
// Legacy frame-locked subtitle packet (0x30)
|
|
let packetSize = seqread.readInt()
|
|
processSubtitlePacket(packetSize)
|
|
|
|
} else if (packetType == TEV_PACKET_SUBTITLE_TC) {
|
|
// SSF-TC subtitle packet (0x31) - parse and buffer for later playback
|
|
let packetSize = seqread.readInt()
|
|
parseSubtitlePacketTC(packetSize)
|
|
} else if (packetType == 0x00) {
|
|
// Silently discard, faulty subtitle creation can cause this as 0x00 is used as an argument terminator
|
|
} else {
|
|
println(`Unknown packet type: 0x${packetType.toString(16)}`)
|
|
break
|
|
}
|
|
}
|
|
|
|
let t2 = sys.nanoTime()
|
|
akku += (t2 - t1) / 1000000000.0
|
|
akku2 += (t2 - t1) / 1000000000.0
|
|
|
|
// Simple progress display
|
|
if (interactive) {
|
|
notifHideTimer += (t2 - t1)
|
|
if (!notifHidden && notifHideTimer > (NOTIF_SHOWUPTIME + FRAME_TIME)) {
|
|
// clearing function here
|
|
notifHidden = true
|
|
}
|
|
|
|
|
|
con.color_pair(253, 0)
|
|
let guiStatus = {
|
|
fps: fps,
|
|
videoRate: getVideoRate(),
|
|
frameCount: frameCount,
|
|
totalFrames: totalFrames,
|
|
frameMode: currentFrameType,
|
|
qY: qualityY,
|
|
qCo: qualityCo,
|
|
qCg: qualityCg,
|
|
akku: akku2,
|
|
fileName: fullFilePathStr,
|
|
fileOrd: 1,
|
|
resolution: `${width}x${height}${(isInterlaced) ? 'i' : ''}`,
|
|
colourSpace: colorSpace,
|
|
currentStatus: 1
|
|
}
|
|
gui.printBottomBar(guiStatus)
|
|
gui.printTopBar(guiStatus, 1)
|
|
}
|
|
|
|
t1 = t2
|
|
}
|
|
}
|
|
catch (e) {
|
|
serial.printerr(`TEV ${colorSpace} decode error: ${e}`)
|
|
errorlevel = 1
|
|
}
|
|
finally {
|
|
// Cleanup working memory (graphics memory is automatically managed)
|
|
if (blockDataPtr > 0) sys.free(blockDataPtr)
|
|
if (RGB_BUFFER_A > 0) sys.free(RGB_BUFFER_A)
|
|
if (RGB_BUFFER_B > 0) sys.free(RGB_BUFFER_B)
|
|
if (CURR_FIELD_BUFFER > 0) sys.free(CURR_FIELD_BUFFER)
|
|
if (PREV_FIELD_BUFFER > 0) sys.free(PREV_FIELD_BUFFER)
|
|
if (NEXT_FIELD_BUFFER > 0) sys.free(NEXT_FIELD_BUFFER)
|
|
|
|
audio.stop(0)
|
|
audio.purgeQueue(0)
|
|
|
|
if (interactive) {
|
|
//con.clear()
|
|
}
|
|
|
|
// set colour zero as opaque black
|
|
}
|
|
|
|
graphics.setPalette(0, 0, 0, 0, 0)
|
|
con.move(cy, cx) // restore cursor
|
|
return errorlevel |