tex3ds.c

Go to the documentation of this file.

/*------------------------------------------------------------------------------
 * Copyright (c) 2017
 *     Michael Theall (mtheall)
 *
 * This file is part of citro3d.
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from the
 * use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 *   1. The origin of this software must not be misrepresented; you must not
 *      claim that you wrote the original software. If you use this software in
 *      a product, an acknowledgment in the product documentation would be
 *      appreciated but is not required.
 *   2. Altered source versions must be plainly marked as such, and must not be
 *      misrepresented as being the original software.
 *   3. This notice may not be removed or altered from any source distribution.
 *----------------------------------------------------------------------------*/
#include <tex3ds.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
struct Tex3DS_Texture_s
{
    u16 numSubTextures;               
    u16 width;                        
    u16 height;                       
    u8  format;                       
    u8  mipmapLevels;                 
    Tex3DS_SubTexture subTextures[];  
};
 
typedef struct __attribute__((packed))
{
    u16 numSubTextures;
    u8  width_log2  : 3;
    u8  height_log2 : 3;
    u8  type        : 1;
    u8  format;
    u8  mipmapLevels;
} Tex3DSi_Header;
 
typedef struct
{
    u16 width, height;
    u16 left, top, right, bottom;
} Tex3DSi_SubTexture;
 
static inline bool Tex3DSi_ReadData(decompressCallback callback, void** userdata, void* buffer, size_t size, size_t* insize)
{
    if (callback)
        return callback(*userdata, buffer, size) == size;
    if (size > *insize)
        return false;
 
    memcpy(buffer, *userdata, size);
    *userdata = (u8*)*userdata + size;
    *insize -= size;
    return true;
}
 
static Tex3DS_Texture
Tex3DSi_ImportCommon(C3D_Tex* tex, C3D_TexCube* texcube, bool vram, decompressCallback callback, void* userdata, size_t insize)
{
    // Read header
    Tex3DSi_Header hdr;
    if (!Tex3DSi_ReadData(callback, &userdata, &hdr, sizeof(hdr), &insize))
        return NULL;
 
    // Allocate space for header + subtextures
    Tex3DS_Texture texture = (Tex3DS_Texture)malloc(sizeof(struct Tex3DS_Texture_s) + hdr.numSubTextures*sizeof(Tex3DS_SubTexture));
    if (!texture)
        return NULL;
 
    // Fill texture metadata structure
    texture->numSubTextures = hdr.numSubTextures;
    texture->width          = 1 << (hdr.width_log2  + 3);
    texture->height         = 1 << (hdr.height_log2 + 3);
    texture->format         = hdr.format;
    texture->mipmapLevels   = hdr.mipmapLevels;
 
    // Read subtexture info
    for (size_t i = 0; i < hdr.numSubTextures; i ++)
    {
        Tex3DSi_SubTexture subtex;
        if (!Tex3DSi_ReadData(callback, &userdata, &subtex, sizeof(Tex3DSi_SubTexture), &insize))
        {
            free(texture);
            return NULL;
        }
        texture->subTextures[i].width  = subtex.width;
        texture->subTextures[i].height = subtex.height;
        texture->subTextures[i].left   = subtex.left   / 1024.0f;
        texture->subTextures[i].top    = subtex.top    / 1024.0f;
        texture->subTextures[i].right  = subtex.right  / 1024.0f;
        texture->subTextures[i].bottom = subtex.bottom / 1024.0f;
    }
 
    // Allocate texture memory
    C3D_TexInitParams params;
    params.width    = texture->width;
    params.height   = texture->height;
    params.maxLevel = texture->mipmapLevels;
    params.format   = texture->format;
    params.type     = (GPU_TEXTURE_MODE_PARAM)hdr.type;
    params.onVram   = vram;
    if (!C3D_TexInitWithParams(tex, texcube, params))
    {
        free(texture);
        return NULL;
    }
 
    // Get texture size, including mipmaps
    size_t base_texsize = C3D_TexCalcTotalSize(tex->size, texture->mipmapLevels);
    size_t texsize = base_texsize;
 
    // If this is a cubemap/skybox, there are 6 textures
    if (params.type == GPU_TEX_CUBE_MAP)
        texsize *= 6;
 
    if (vram)
    {
        // Allocate staging buffer in linear memory
        void* texdata = linearAlloc(texsize);
        if (!texdata)
        {
            C3D_TexDelete(tex);
            free(texture);
            return NULL;
        }
 
        // Decompress into staging buffer for VRAM upload
        if (!decompress(texdata, texsize, callback, userdata, insize))
        {
            linearFree(texdata);
            C3D_TexDelete(tex);
            free(texture);
            return NULL;
        }
 
        // Flush buffer to prepare DMA to VRAM
        GSPGPU_FlushDataCache(texdata, texsize);
 
        size_t texcount = 1;
        if (params.type == GPU_TEX_CUBE_MAP)
            texcount = 6;
 
        // Upload texture(s) to VRAM
        for (size_t i = 0; i < texcount; ++i)
            C3D_TexLoadImage(tex, (u8*)texdata + i * base_texsize, i, -1);
 
        linearFree(texdata);
    } else if (params.type == GPU_TEX_CUBE_MAP)
    {
        decompressIOVec iov[6];
 
        // Setup IO vectors
        for (size_t i = 0; i < 6; ++i)
        {
            u32 size;
            iov[i].data = C3D_TexCubeGetImagePtr(tex, i, -1, &size);
            iov[i].size = size;
        }
 
        // Decompress into texture memory
        if (!decompressV(iov, 6, callback, userdata, insize))
        {
            C3D_TexDelete(tex);
            free(texture);
            return NULL;
        }
    } else
    {
        u32 size;
        void* data = C3D_Tex2DGetImagePtr(tex, -1, &size);
 
        // Decompress into texture memory
        if (!decompress(data, size, callback, userdata, insize))
        {
            C3D_TexDelete(tex);
            free(texture);
            return NULL;
        }
    }
 
    return texture;
}
 
Tex3DS_Texture
Tex3DS_TextureImport(const void* input, size_t insize, C3D_Tex* tex, C3D_TexCube* texcube, bool vram)
{
    return Tex3DSi_ImportCommon(tex, texcube, vram, NULL, (void*)input, insize);
}
 
Tex3DS_Texture
Tex3DS_TextureImportCallback(C3D_Tex* tex, C3D_TexCube* texcube, bool vram, decompressCallback callback, void* userdata)
{
    return Tex3DSi_ImportCommon(tex, texcube, vram, callback, userdata, 0);
}
 
Tex3DS_Texture
Tex3DS_TextureImportFD(int fd, C3D_Tex* tex, C3D_TexCube* texcube, bool vram)
{
    return Tex3DSi_ImportCommon(tex, texcube, vram, decompressCallback_FD, &fd, 0);
}
 
Tex3DS_Texture
Tex3DS_TextureImportStdio(FILE* fp, C3D_Tex* tex, C3D_TexCube* texcube, bool vram)
{
    return Tex3DSi_ImportCommon(tex, texcube, vram, decompressCallback_Stdio, fp, 0);
}
 
size_t
Tex3DS_GetNumSubTextures(const Tex3DS_Texture texture)
{
    return texture->numSubTextures;
}
 
const Tex3DS_SubTexture*
Tex3DS_GetSubTexture(const Tex3DS_Texture texture, size_t index)
{
    if (index < texture->numSubTextures)
        return &texture->subTextures[index];
    return NULL;
}
 
void Tex3DS_TextureFree(Tex3DS_Texture texture)
{
    free(texture);
}