mkdd/libs/JSystem/JUtility/JUTDirectFile.cpp

#include <dolphin/os.h>
#include "JSystem/JUtility/JUTDirectFile.h"

int JUTDirectFile::fetch32byte()
{
    mToRead = mLength - ALIGN_PREV(mPos, DVD_MIN_TRANSFER_SIZE);

    if (mToRead > JUTDF_BUFSIZE)
    {
        mToRead = JUTDF_BUFSIZE;
    }
    int interrupts = OSEnableInterrupts();
    int readRes = DVDReadAsync(&mFileInfo, mSectorStart, ALIGN_NEXT(mToRead, DVD_MIN_TRANSFER_SIZE),
                               ALIGN_PREV(mPos, DVD_MIN_TRANSFER_SIZE), nullptr);
    OSRestoreInterrupts(interrupts);
    if (!readRes)
    {
        return -1;
    }
    else
    {
        interrupts = OSEnableInterrupts();
        while (DVDGetCommandBlockStatus(&mFileInfo.cb))
        {
            ;
        }
        OSRestoreInterrupts(interrupts);
        return mToRead;
    }
}

JUTDirectFile::JUTDirectFile()
{
    mLength = 0;
    mPos = 0;
    mToRead = 0;
    mSectorStart = (u8 *)ALIGN_NEXT((u32)mBuffer, DVD_MIN_TRANSFER_SIZE);
    mIsOpen = false;
}

JUTDirectFile::~JUTDirectFile() { mIsOpen = false; }

bool JUTDirectFile::fopen(const char *filename)
{
    if (!filename)
    {
        return false;
    }

    int interrupts = OSEnableInterrupts();
    int dvdRes = DVDOpen(const_cast<char *>(filename), &mFileInfo);
    OSRestoreInterrupts(interrupts);

    if (!dvdRes)
    {
        mIsOpen = false;
        return false;
    }

    int interrupts2 = OSEnableInterrupts();
    mLength = mFileInfo.length;
    OSRestoreInterrupts(interrupts2);

    mPos = 0;
    mIsOpen = true;
    return true;
}

void JUTDirectFile::fclose()
{
    if (mIsOpen)
    {
        int interrupts = OSEnableInterrupts();
        DVDClose(&mFileInfo);
        OSRestoreInterrupts(interrupts);
        mIsOpen = false;
    }
}
/*
 * Gets data of length 'len' and stores in 'buf'.
 * Returns actual length gotten in bytes, or -1 if error.
 */
int JUTDirectFile::fgets(void *buf, int len)
{
    // if file isn't open, return error (-1).
    if (!mIsOpen)
    {
        return -1;
    }

    // if desired length to get is 0, get... 0 bytes.
    if (len == 0)
    {
        return 0;
    }

    // if desired length to get is 1, return 1.
    // (final byte gotten is always 0, so len 1 is pointless).
    if (len == 1)
    {
        return 1;
    }

    // if buffer to read into doesn't exist, return error.
    if (!buf)
    {
        return -1;
    }

    // if we're already beyond the file length, return error.
    if (mPos >= mLength)
    {
        return -1;
    }

    int readMax;
    u8 *byteBuf = (u8 *)buf;
    readMax = len - 1; // desired bytes of data to get (last value is then 0).
    int readCount = 0;

    while (mPos < mLength)
    {
        // if there's nothing left to read, return error.
        if (mToRead == 0 && fetch32byte() < 0)
        {
            return -1;
        }

        // read in each chunk.
        u32 currPos = mPos & (JUTDF_BUFSIZE - 1);
        u32 chunkSize = (mToRead - currPos);
        if (readCount + chunkSize > readMax)
        {
            chunkSize = len - readCount - 1;
        }

        BOOL isAtEnd = FALSE;
        for (int i = 0; i < chunkSize; i++)
        {
            u8 byte = mSectorStart[currPos++];
            *byteBuf++ = byte;

            // if we hit the end of a line, stop reading.
            if (byte == '\n')
            {
                chunkSize = i + 1;
                isAtEnd = TRUE;
                break;
            }
        }

        // if we exceed the buffer size, stop reading.
        if (currPos >= JUTDF_BUFSIZE)
        {
            mToRead = 0;
        }

        // if we hit the end of a line, set final byte to 0 and stop reading.
        if (isAtEnd == TRUE)
        {
            readCount += chunkSize;
            *byteBuf = 0;
            mPos += chunkSize;
            break;
        }

        // we should have read the full chunkSize, so update count/pos.
        readCount += chunkSize;
        mPos += chunkSize;

        // if we're at (or beyond) our desired length, set final byte to 0 and stop reading.
        if (readCount >= readMax)
        {
            *byteBuf = 0;
            break;
        }
    }

    // if got to the end of the data, set final byte to 0.
    if (mPos >= mLength)
    {
        *byteBuf = 0;
    }

    return readCount;
}