str-player.hh

Go to the documentation of this file.

/*
 
MIT License
 
Copyright (c) 2026 PCSX-Redux authors
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
*/
 
#pragma once
 
#include <EASTL/functional.h>
#include <EASTL/string_view.h>
#include <stdint.h>
 
#include "psyqo/cdrom-device.hh"
#include "psyqo/gpu.hh"
#include "psyqo/iso9660-parser.hh"
 
namespace psyqo::paths {
 
class ArchiveManager;
 
class StrPlayer {
  public:
    enum class Present : uint8_t {
        // Show a decoded frame at the first vblank after the NEXT frame has
        // arrived off the disc, the way Sony's libraries do: the disc sets the
        // rate, and the vblank wait keeps the swap out of the visible picture.
        // A 320x240 24-bit frame takes about 480 scanlines to decode, so a
        // 30 fps movie holds 30 fps at 60 Hz but is shown at 25 fps at 50 Hz,
        // dropping one frame in six.
        STREAM,
        // Switch the display to a frame the moment it is decoded, wherever the
        // beam is. Keeps 30 fps at 50 Hz, but the swap lands anywhere in the
        // picture and tears visibly on fast motion.
        ASAP,
    };
 
    struct Options {
        bool rgb24 = true;
        bool audio = true;
        // Off for a movie encoded for single speed (psxavenc -x 1).
        bool doubleSpeed = true;
        // Setfilter: only play the XA channel matching file/channel. When false,
        // the drive plays every audio sector it meets.
        bool xaFilter = false;
        uint8_t xaFile = 0;
        uint8_t xaChannel = 0;
        Present present = Present::STREAM;
        // Number of frames the reassembly ring holds, and the sector budget of a
        // single frame. A frame using more chunks than this is dropped.
        uint8_t frameSlots = 3;
        uint8_t maxSectorsPerFrame = 12;
        // Run-level buffer for bsdec, in halfwords; two are allocated. A frame
        // needing more is dropped. Retail 320x240 movies need up to 26304
        // (Suikoden II) and 25600 (Castlevania SOTN).
        uint32_t rlHalfwords = 28672;
        // Size of the display the frame is centered in, in pixels.
        uint16_t displayWidth = 320;
        uint16_t displayHeight = 240;
        // Where in VRAM to decode, for a frame drawn as a texture: always 15-bit (rgb24 is ignored). -1 for the back
        // buffer. One rectangle, not double buffered: each frame lands in it during frame(), so a caller that draws
        // from it waits for its own chain to finish before calling frame().
        int16_t vramX = -1;
        int16_t vramY = 0;
    };
 
    enum class Status : uint8_t { IDLE, PLAYING, ENDED, FAILED };
 
    struct Stats {
        uint32_t framesShown = 0;
        uint32_t framesDropped = 0;   // lost in reassembly: missing chunks, or no free slot
        uint32_t dropIncomplete = 0;  // of which a new frame started before every chunk arrived
        uint32_t dropRingFull = 0;    // of which the decoder was behind and no slot was free
        uint32_t framesRejected = 0;  // complete, but bsdec or the MDEC refused them
        uint32_t videoSectors = 0;
        uint32_t otherSectors = 0;
        uint32_t readErrors = 0;
        uint32_t badAddresses = 0;
        uint32_t lastFrameNumber = 0;
        // Vsyncs between two consecutive presented frames, 1, 2, 3, and 4 or more.
        uint32_t vsyncHistogram[4] = {};
        // Scanline the display switch happened on, counted from the start of
        // vblank, in buckets of 32 lines. Only filled in Present::ASAP.
        uint32_t switchLineHistogram[10] = {};
        // Scanlines from the start of a decode to its last column landing in
        // VRAM, in buckets of 64 lines, the last one 704 and up.
        uint32_t decodeLineHistogram[12] = {};
    };
 
    StrPlayer(CDRomDevice &cdrom, GPU &gpu) : m_cdrom(cdrom), m_gpu(gpu) {}
    ~StrPlayer();
 
    bool play(uint32_t lba, uint32_t sectors, const Options &options);
    bool play(uint32_t lba, uint32_t sectors);
 
    static uint32_t heapNeeded(const Options &options);
 
    Status frame();
 
    void stop();
 
    const Stats &stats() const { return m_stats; }
 
  private:
    struct Slot {
        uint8_t *data;
        uint32_t frameNumber;
        uint32_t size;
        uint32_t received;  // bitmask of chunks
        uint16_t chunks;
        uint16_t width;
        uint16_t height;
        uint8_t state;
    };
    friend class StrStreamAction;
    uint8_t *sectorDest(const uint8_t *header, uint32_t lba);
    void sectorLanded();
    void cdDone(bool success);
    void present();
    void checkStall();
    bool vlcNext();
    void startDecode();
    void pump();
    void mdecOutIRQ();
    bool finishDecode();
    void abortDecode();
    void mdecReset();
    void finish();
    uint32_t hsyncs();
    void waitVBlankEdge();
 
    CDRomDevice &m_cdrom;
    GPU &m_gpu;
    Options m_options;
    Stats m_stats;
    struct Layout {
        uint32_t slotBytes, rlBytes, sliceBytes;
        uint32_t slotData, rl, slices, total;
        bool fits;  // false when rlHalfwords is past any PS1 RAM
        static Layout of(const Options &options);
    };
    uint8_t *m_heap = nullptr;
    Slot *m_slots = nullptr;
    struct Rl {
        uint32_t command;
        uint32_t halfwords;
        uint16_t width;
        uint16_t height;
    };
    uint16_t *m_rlBufs[2] = {nullptr, nullptr};
    Rl m_rlMeta[2] = {};
    unsigned m_rlIdx = 0;
    unsigned m_vlcIdx = 0;
    unsigned m_dmaSlot = ~0u;
    uint32_t m_colWords = 0;
    uint32_t m_decodeStart = 0;
    uint32_t m_decodeStartLine = 0;
    uint16_t m_colHeight = 0;
    int16_t m_colHw = 0;
    int16_t m_x0 = 0;
    int16_t m_y0 = 0;
    uint8_t m_colCount = 0;
    uint8_t m_colArmed = 0;
    uint8_t m_colDone = 0;
    uint8_t m_upStarted = 0;
    uint8_t m_upDone = 0;
    bool m_uploading = false;
    bool m_dma1Busy = false;
    bool m_decodeDone = false;
    bool m_decoding = false;
    bool m_decodeOk = false;
    uint16_t *m_slices[2] = {nullptr, nullptr};
    uint32_t m_lba = 0;
    uint32_t m_end = 0;
    uint32_t m_lastLba = 0;
    unsigned m_writeSlot = 0;
    unsigned m_readSlot = 0;
    int m_filling = -1;
    uint32_t m_skipFrame = 0xffffffff;
    bool m_haveRl = false;
    bool m_haveDecoded = false;
    bool m_needReset = false;
    bool m_failed = false;
    bool m_cdRunning = false;
    uint32_t m_lastSectorFrame = 0;
    uint32_t m_lastPresentVsync = 0;
    uint32_t m_hsyncHigh = 0;
    uint16_t m_hsyncLast = 0;
    uint32_t m_vblankRef = 0;
    uint32_t m_landing = 0;
    uint16_t m_savedSpuCtrl = 0;
    uint16_t m_savedCdLeft = 0;
    uint16_t m_savedCdRight = 0;
    uint8_t m_retries = 0;
    bool m_stopping = false;
    Status m_status = Status::IDLE;
};
 
void resolveMovie(ISO9660Parser &parser, eastl::string_view path,
                  eastl::function<void(bool success, uint32_t lba, uint32_t sectors)> &&callback);
 
bool resolveMovie(const ArchiveManager &archive, eastl::string_view path, uint32_t *lba, uint32_t *sectors);
 
}  // namespace psyqo::paths