VideoTexture.kt

    fun load(videoPath: String): Boolean {
        // If loading the same video, just seek to start
        if (videoPath == currentVideoPath && decoder != null) {
            seek(0.0)
            return true
        }

        // Create new decoder
        val newDecoder = VideoDecoder(videoPath, pixelFormat)
        if (!newDecoder.open()) {
            lprintln("error,video", "Failed to open video: $videoPath")
            return false
        }
        val newLoopDecoder = if (backgroundDecode) VideoDecoder(videoPath, pixelFormat).also {
            if (!it.open()) {
                newDecoder.close()
                lprintln("error,video", "Failed to open loop-ahead decoder: $videoPath")
                return false
            }
        } else null

        val newWidth = newDecoder.width
        val newHeight = newDecoder.height

        // Check if we can reuse existing textures (same dimensions)
        val texturesAllocated = when (pixelFormat) {
            VideoDecodeFormat.P010 -> lumaTextures.all { it != null } && chromaTextures.all { it != null }
            VideoDecodeFormat.RGBA8 -> rgbaTextures.all { it != null }
        }
        val canReuseTextures = (newWidth == videoWidth && newHeight == videoHeight && texturesAllocated)

        // Close old decoder if exists. A background decoder owns FFmpeg exclusively while running.
        stopDecodeWorker()
        decoder?.close()
        loopDecoder?.close()
        decoder = newDecoder
        loopDecoder = newLoopDecoder
        currentVideoPath = videoPath

        if (canReuseTextures) {
            lprintln("info,video", "Reusing existing textures for video: $videoPath (${newWidth}x${newHeight})")
        } else {
            lprintln("info,video", "Creating new textures for video: $videoPath (${newWidth}x${newHeight})")

            // Clean up old textures if they exist
            cleanupTextures()

            // Update dimensions
            videoWidth = newWidth
            videoHeight = newHeight

            // Create the upload textures for the selected decode contract.
            for (i in 0 until textureSlots) {
                when (pixelFormat) {
                    VideoDecodeFormat.P010 -> {
                        lumaTextures[i] = VideoPlaneTexture(
                            renderer = renderer,
                            width = videoWidth,
                            height = videoHeight,
                            format = lumaFormat,
                            name = "video_luma_$i"
                        )
                        chromaTextures[i] = VideoPlaneTexture(
                            renderer = renderer,
                            width = videoWidth / 2,
                            height = videoHeight / 2,
                            format = chromaFormat,
                            name = "video_chroma_$i"
                        )
                    }
                    VideoDecodeFormat.RGBA8 -> rgbaTextures[i] = VideoPlaneTexture(
                        renderer = renderer,
                        width = videoWidth,
                        height = videoHeight,
                        format = VK10.VK_FORMAT_R8G8B8A8_UNORM,
                        name = "video_rgba_$i"
                    )
                }
            }
        }

        currentTimestamp = 0.0
        lastFrameTimestamp = 0.0
        uploadedFrame = false
        uploadedFrameIndex = -1
        currentSlot.set(0)
        pendingFrameRefresh = true
        lastRequestedFrame = Long.MIN_VALUE
        seenDecodedSerial = -1L
        clearDecodedFrame()

        // Reset internal clock when loading a new video
        if (clock == null) {
            internalClock.reset()
        }

        if (backgroundDecode) startDecodeWorker(newDecoder, checkNotNull(newLoopDecoder))

        return true
    }

    fun update(commandBuffer: CommandBuffer): Boolean {
        val activeDecoder = decoder ?: return false
        val allowWhilePaused = pendingFrameRefresh
        val shouldUpdate = isPlaying || allowWhilePaused

        if (!shouldUpdate) {
            return false
        }

        // Get target timestamp from the active clock
        val targetTimestamp = activeClock.getCurrentTime()

        if (backgroundDecode) {
            return updateFromBackground(commandBuffer, activeDecoder, targetTimestamp)
        }

        // Check if we need to decode a new frame
        // We decode if:
        // 1. We're significantly behind the clock (more than one frame)
        // 2. We're paused and need a refresh
        val frameDuration = if (activeDecoder.fps > 0) 1.0 / activeDecoder.fps else 0.033
        val delta = targetTimestamp - lastFrameTimestamp
        // An external timeline can scrub or loop. Decoding forward from the old cursor cannot reach a
        // time behind it, and walking hundreds of frames after a large jump is the wrong latency.
        val discontinuity = delta < -frameDuration * 0.5 || delta > frameDuration * 12.0
        if (discontinuity) {
            if (!activeDecoder.seek(targetTimestamp.coerceAtLeast(0.0))) return false
            lastFrameTimestamp = targetTimestamp - frameDuration
        }
        val needsNewFrame = discontinuity || (targetTimestamp - lastFrameTimestamp) >= frameDuration || allowWhilePaused

        if (!needsNewFrame) {
            return false
        }

        // Decode frames until we reach or pass the target timestamp
        var decodedFrame: VideoFrame? = null
        var attempts = 0
        val maxAttempts = 10  // Prevent infinite loops

        while (attempts < maxAttempts) {
            val frame = activeDecoder.decodeNextFrame() ?: break

            decodedFrame?.close()
            decodedFrame = frame
            attempts++

            // If this frame is at or past the target time, use it
            if (frame.timestamp >= targetTimestamp) {
                break
            }

            // If we're more than 2 frames ahead, we're seeking or lagging - use this frame
            if (targetTimestamp - frame.timestamp > frameDuration * 2) {
                // Skip frames when catching up
                continue
            }

            // Frame is close enough to target, use it
            break
        }

        lprint("info, video", "decoded frame in ${attempts} attempts")

        val frame = decodedFrame ?: return false
        try {
            // Check if we're past the video duration
            if (frame.timestamp >= activeDecoder.duration) {
                // Loop back to start
                activeDecoder.seek(0.0)
                lastFrameTimestamp = 0.0

                // Reset internal clock if we're using it
                if (clock == null) {
                    internalClock.seek(0.0)
                }

                return false
            }

            // Switch to next slot
            val nextSlot = (currentSlot.get() + 1) % textureSlots

            when (pixelFormat) {
                VideoDecodeFormat.P010 -> {
                    val lumaTexture = lumaTextures[nextSlot] ?: return false
                    val chromaTexture = chromaTextures[nextSlot] ?: return false
                    lumaTexture.upload(commandBuffer, frame.plane0)
                    chromaTexture.upload(commandBuffer, frame.plane1)
                }
                VideoDecodeFormat.RGBA8 -> {
                    val rgbaTexture = rgbaTextures[nextSlot] ?: return false
                    rgbaTexture.upload(commandBuffer, frame.plane0)
                }
            }

            // Update current slot
            currentSlot.set(nextSlot)

            // Track the timestamp of this frame
            lastFrameTimestamp = frame.timestamp
            currentTimestamp = frame.timestamp
            uploadedFrame = true
            uploadedFrameIndex = if (fps > 0) VideoFrameIndex.decoded(frame.timestamp, fps) else -1

            // If we were paused and refreshing after a scrub, stop the temporary refresh
            if (!isPlaying && pendingFrameRefresh) {
                pendingFrameRefresh = false
            }

            return true
        } finally {
            frame.close()
        }
    }

    override fun render(command: CommandBuffer, index: Int) {
        update(command)
    }

    private fun updateFromBackground(
        commandBuffer: CommandBuffer,
        activeDecoder: VideoDecoder,
        targetTimestamp: Double
    ): Boolean {
        decodeFailure?.let { throw IllegalStateException("background video decode failed", it) }
        val frameDuration = if (activeDecoder.fps > 0) 1.0 / activeDecoder.fps else 0.033
        val targetFrame = VideoFrameIndex.requested(targetTimestamp, 1.0 / frameDuration)
        if (targetFrame != lastRequestedFrame) {
            lastRequestedFrame = targetFrame
            requestBackgroundDecode(targetFrame * frameDuration)
        }

        return synchronized(decodedFrameLock) {
            val ready = decodedFrame.get() ?: return@synchronized false
            if (ready.serial == seenDecodedSerial) return@synchronized false
            uploadDecodedFrame(commandBuffer, ready)
        }
    }

    private fun uploadDecodedFrame(commandBuffer: CommandBuffer, ready: DecodedFrame): Boolean {
        val frame = ready.frame
        val nextSlot = (currentSlot.get() + 1) % textureSlots
        when (pixelFormat) {
            VideoDecodeFormat.P010 -> {
                val lumaTexture = lumaTextures[nextSlot] ?: return false
                val chromaTexture = chromaTextures[nextSlot] ?: return false
                lumaTexture.upload(commandBuffer, frame.plane0)
                chromaTexture.upload(commandBuffer, frame.plane1)
            }
            VideoDecodeFormat.RGBA8 -> {
                val rgbaTexture = rgbaTextures[nextSlot] ?: return false
                rgbaTexture.upload(commandBuffer, frame.plane0)
            }
        }
        seenDecodedSerial = ready.serial
        currentSlot.set(nextSlot)
        lastFrameTimestamp = frame.timestamp
        currentTimestamp = frame.timestamp
        uploadedFrame = true
        uploadedFrameIndex = if (fps > 0) VideoFrameIndex.decoded(frame.timestamp, fps) else -1
        pendingFrameRefresh = false
        return true
    }

    private fun requestBackgroundDecode(timestamp: Double, exactFrame: Long? = null) {
        val request = DecodeRequest(decodeGeneration.incrementAndGet(), timestamp.coerceAtLeast(0.0), exactFrame)
        requestedDecode.set(request)
        pendingDecode.set(request)
        LockSupport.unpark(decodeWorker)
    }

    private fun startDecodeWorker(activeDecoder: VideoDecoder, loopDecoder: VideoDecoder) {
        check(!decodeWorkerRunning)
        decodeFailure = null
        requestedDecode.set(null)
        pendingDecode.set(null)
        decodeWorkerRunning = true
        decodeWorker = thread(name = "video-decode-${pixelFormat.name.lowercase()}", isDaemon = true) {
            runDecodeWorker(activeDecoder, loopDecoder)
        }
    }

    private fun runDecodeWorker(initialDecoder: VideoDecoder, initialLoopDecoder: VideoDecoder) {
        var activeDecoder = initialDecoder
        var standbyDecoder = initialLoopDecoder
        val standbyReady = AtomicBoolean(false)
        rewindLoopDecoder(initialLoopDecoder, standbyReady, warmUp = true)
        var decoderTimestamp = Double.NaN
        try {
            while (decodeWorkerRunning) {
                val request = pendingDecode.getAndSet(null)
                if (request == null) {
                    LockSupport.parkNanos(2_000_000L)
                    continue
                }
                val frameDuration = if (activeDecoder.fps > 0) 1.0 / activeDecoder.fps else 0.033
                var rewindAfterPublish: VideoDecoder? = null
                // The expensive end-to-start FFmpeg seek used to puncture every short looping cue.
                // Alternate two already-open decoders instead: the standby is sitting at frame zero,
                // while the exhausted decoder rewinds on its own thread during the next loop.
                if (request.exactFrame == 0L && decoderTimestamp.isFinite() &&
                    decoderTimestamp > frameDuration * 2.0 && standbyReady.compareAndSet(true, false)) {
                    val exhausted = activeDecoder
                    activeDecoder = standbyDecoder
                    standbyDecoder = exhausted
                    rewindAfterPublish = standbyDecoder
                    decoderTimestamp = -frameDuration
                }
                val already = synchronized(decodedFrameLock) { decodedFrame.get() }
                if (request.exactFrame != null && already != null &&
                    VideoFrameIndex.decoded(already.frame.timestamp, activeDecoder.fps) == request.exactFrame) continue
                val delta = request.timestamp - decoderTimestamp
                // Forward playback is deliberately sequential. A long-GOP movie may seek back to
                // frame zero anyway, and repeatedly restarting that decode is both slower and prone
                // to starving. Backward motion (including loop wrap) still seeks immediately.
                if (!decoderTimestamp.isFinite() || delta < -frameDuration * 0.5 ||
                    (request.exactFrame != null && delta <= frameDuration * 0.5)) {
                    check(activeDecoder.seek(request.timestamp)) { "could not seek video to ${request.timestamp}s" }
                    decoderTimestamp = request.timestamp - frameDuration
                }

                var attempts = 0
                var reached = false
                while (decodeWorkerRunning && attempts < 48) {
                    if (request.exactFrame != null && requestedDecode.get()?.generation != request.generation) break
                    val latestTarget = requestedDecode.get()?.timestamp ?: request.timestamp
                    if (decoderTimestamp.isFinite() && latestTarget < decoderTimestamp - frameDuration * 0.5) break
                    val frameStarted = System.nanoTime()
                    val frame = activeDecoder.decodeNextFrame()
                    if (frame == null) {
                        check(request.exactFrame == null) { "video ended before requested source frame ${request.exactFrame}" }
                        break
                    }
                    decoderTimestamp = frame.timestamp
                    attempts++
                    backgroundDecodeMicros = (System.nanoTime() - frameStarted) / 1_000L
                    var published = false
                    try {
                        if (request.exactFrame != null) {
                            val frameIndex = VideoFrameIndex.decoded(frame.timestamp, activeDecoder.fps)
                            check(frameIndex <= request.exactFrame) { "video skipped requested frame ${request.exactFrame}, got $frameIndex" }
                            if (frameIndex == request.exactFrame) {
                                publishDecodedFrame(frame)
                                published = true
                                reached = true
                                break
                            }
                        } else {
                            publishDecodedFrame(frame)
                            published = true
                            if (frame.timestamp + frameDuration * 0.5 >= latestTarget) break
                        }
                    } finally {
                        if (!published) frame.close()
                    }
                }
                // Long-GOP seeks can need more than one bounded decode pass. Keep the exact request
                // alive, but never overwrite a newer seek/loop request.
                if (request.exactFrame != null && !reached && requestedDecode.get()?.generation == request.generation) {
                    pendingDecode.compareAndSet(null, request)
                }
                // The decoder stopped being active as soon as we swapped it out. Rewind it even if
                // an explicit seek superseded frame zero before publication, otherwise one unlucky
                // scrub at the loop boundary permanently loses the prepared standby.
                if (rewindAfterPublish != null) {
                    rewindLoopDecoder(checkNotNull(rewindAfterPublish), standbyReady)
                }
            }
        } catch (t: Throwable) {
            if (decodeWorkerRunning) decodeFailure = t
        } finally {
            decodeWorkerRunning = false
        }
    }

    private fun rewindLoopDecoder(value: VideoDecoder, ready: AtomicBoolean, warmUp: Boolean = false) {
        loopResetWorker?.join(5_000L)
        check(loopResetWorker?.isAlive != true) { "previous loop decoder is still rewinding" }
        loopResetWorker = thread(name = "video-loop-rewind-${pixelFormat.name.lowercase()}", isDaemon = true) {
            // Opening FFmpeg is not enough to pay its first-decode costs. Prime the initially cold
            // standby during the first loop, then return it to frame zero before advertising it.
            if (warmUp) value.decodeNextFrame()?.close()
            if (value.seek(0.0) && decodeWorkerRunning) ready.set(true)
            else if (decodeWorkerRunning) lprintln("warning,video", "Could not pre-rewind loop decoder")
        }
    }

    private fun stopDecodeWorker() {
        decodeWorkerRunning = false
        LockSupport.unpark(decodeWorker)
        decodeWorker?.interrupt()
        decodeWorker?.join(5_000L)
        check(decodeWorker?.isAlive != true) { "video decode worker did not stop" }
        decodeWorker = null
        loopResetWorker?.join(5_000L)
        check(loopResetWorker?.isAlive != true) { "video loop rewind worker did not stop" }
        loopResetWorker = null
        requestedDecode.set(null)
        pendingDecode.set(null)
        clearDecodedFrame()
    }

    private fun publishDecodedFrame(frame: VideoFrame) {
        synchronized(decodedFrameLock) {
            decodedFrame.getAndSet(DecodedFrame(decodeSerial.incrementAndGet(), frame))?.frame?.close()
        }
    }

    private fun clearDecodedFrame() {
        synchronized(decodedFrameLock) {
            decodedFrame.getAndSet(null)?.frame?.close()
        }
    }
}

private class VideoPlaneTexture(
    private val renderer: Renderer,
    val width: Int,
    val height: Int,
    val format: Int,
    val name: String
) : HasImageView {

    private val image: Image
    override val imageView: ImageView
    private val stagingBuffer: VulkanBuffer
    private var currentLayout = VK10.VK_IMAGE_LAYOUT_UNDEFINED

    init {
        val bytesPerPixel = vkFormatBytesPerPixel(format, "$name plane")
        val imageSize = width * height * bytesPerPixel

        // Create staging buffer for uploads
        stagingBuffer = VulkanBuffer(
            renderer,
            imageSize.toLong(),
            VK10.VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
            VK10.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT or VK10.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
        )

        // Create image
        val imageData = Image.ImageData()
            .width(width)
            .height(height)
            .format(format)
            .usage(VK10.VK_IMAGE_USAGE_TRANSFER_DST_BIT or VK10.VK_IMAGE_USAGE_SAMPLED_BIT)
            .mipLevels(1)

        image = Image(renderer.device, imageData)

        // Create image view
        val imageViewData = ImageView.ImageViewData()
            .format(format)
            .aspectMask(VK10.VK_IMAGE_ASPECT_COLOR_BIT)
            .mipLevels(1)

        imageView = ImageView(renderer.device, image, imageViewData)
    }

    /**
     * Upload data to this texture plane.
     */
    fun upload(cmd: CommandBuffer, data: ByteBuffer) {
        // Create a duplicate to avoid modifying the caller's buffer position
        val dataCopy = data.duplicate()

        // Copy data to staging buffer
        val mappedMemory = stagingBuffer.map()
        val buffer = MemoryUtil.memByteBuffer(mappedMemory, dataCopy.remaining())
        buffer.put(dataCopy)
        stagingBuffer.unmap()

        MemoryStack.stackPush().use { stack ->
            // Transition to transfer destination
            recordImageTransition(stack, cmd, currentLayout, VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)

            // Copy buffer to image
            recordCopyBuffer(stack, cmd)

            // Transition to shader read
            recordImageTransition(
                stack,
                cmd,
                VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                VK10.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
            )
        }

        currentLayout = VK10.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
    }

    private fun recordCopyBuffer(stack: MemoryStack, cmd: CommandBuffer) {
        val region = VkBufferImageCopy.calloc(1, stack)
            .bufferOffset(0)
            .bufferRowLength(0)
            .bufferImageHeight(0)
            .imageSubresource { it: VkImageSubresourceLayers ->
                it.aspectMask(VK10.VK_IMAGE_ASPECT_COLOR_BIT)
                    .mipLevel(0)
                    .baseArrayLayer(0)
                    .layerCount(1)
            }
            .imageOffset { it: VkOffset3D -> it.x(0).y(0).z(0) }
            .imageExtent { it: VkExtent3D ->
                it.width(width).height(height).depth(1)
            }

        VK10.vkCmdCopyBufferToImage(
            cmd.vkCommandBuffer,
            stagingBuffer.buffer,
            image.vkImage,
            vkLayout(VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL),
            region
        )
    }

    private fun recordImageTransition(
        stack: MemoryStack,
        cmd: CommandBuffer,
        oldLayout: Int,
        newLayout: Int
    ) {
        val barrier = VkImageMemoryBarrier.calloc(1, stack)
            .sType(VK10.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER)
            .oldLayout(vkLayout(oldLayout))
            .newLayout(vkLayout(newLayout))
            .srcQueueFamilyIndex(VK10.VK_QUEUE_FAMILY_IGNORED)
            .dstQueueFamilyIndex(VK10.VK_QUEUE_FAMILY_IGNORED)
            .image(image.vkImage)
            .subresourceRange { it: VkImageSubresourceRange ->
                it.aspectMask(VK10.VK_IMAGE_ASPECT_COLOR_BIT)
                    .baseMipLevel(0)
                    .levelCount(1)
                    .baseArrayLayer(0)
                    .layerCount(1)
            }

        val srcStage: Int
        val srcAccessMask: Int
        val dstAccessMask: Int
        val dstStage: Int

        when {
            oldLayout == VK10.VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL -> {
                srcStage = VK10.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
                srcAccessMask = 0
                dstStage = VK10.VK_PIPELINE_STAGE_TRANSFER_BIT
                dstAccessMask = VK10.VK_ACCESS_TRANSFER_WRITE_BIT
            }
            oldLayout == VK10.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL && newLayout == VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL -> {
                // Video can drive vertex projection and compute forces as well as fragment colour.
                srcStage = VK10.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
                srcAccessMask = VK10.VK_ACCESS_SHADER_READ_BIT
                dstStage = VK10.VK_PIPELINE_STAGE_TRANSFER_BIT
                dstAccessMask = VK10.VK_ACCESS_TRANSFER_WRITE_BIT
            }
            oldLayout == VK10.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK10.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL -> {
                srcStage = VK10.VK_PIPELINE_STAGE_TRANSFER_BIT
                srcAccessMask = VK10.VK_ACCESS_TRANSFER_WRITE_BIT
                dstStage = VK10.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
                dstAccessMask = VK10.VK_ACCESS_SHADER_READ_BIT
            }
            else -> throw RuntimeException("Unsupported layout transition: $oldLayout -> $newLayout")
        }

        barrier.srcAccessMask(srcAccessMask)
        barrier.dstAccessMask(dstAccessMask)

        VK10.vkCmdPipelineBarrier(cmd.vkCommandBuffer, srcStage, dstStage, 0, null, null, barrier)
    }

    fun cleanup() {
        imageView.cleanup()
        image.cleanup()
        stagingBuffer.cleanup()
    }



}