mvd/source/main.c

#include <stdio.h>
#include <string.h>
 
#include <3ds.h>
 
u8* inaddr;
u8* outaddr;
 
void mvd_colorconvert()
{
    Result ret;
 
    FILE *f = NULL;
 
    u8* bufAdr = gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL);
    u8* gfxtopadr = gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL);
 
    MVDSTD_Config config;
 
    printf("mvd color-format-conversion example.\n");
 
    f = fopen("sdmc:/mvd_indata.bin", "r");
    if(f)
    {
        fread(inaddr, 1, 0x46500, f);
        fclose(f);
    }
    else
    {
        memcpy(inaddr, bufAdr, 320*240*3);
    }
 
    memset(gfxtopadr, 0, 0x46500);
    GSPGPU_FlushDataCache(inaddr, 0x46500);
    GSPGPU_FlushDataCache(gfxtopadr, 0x46500);
 
    ret = mvdstdInit(MVDMODE_COLORFORMATCONV, MVD_INPUT_YUYV422, MVD_OUTPUT_BGR565, 0, NULL);
    printf("mvdstdInit(): 0x%08x\n", (unsigned int)ret);
 
    if(ret==0)
    {
        mvdstdGenerateDefaultConfig(&config, 320, 240, 320, 240, (u32*)inaddr, (u32*)outaddr, (u32*)&outaddr[0x12c00]);
 
        ret = mvdstdConvertImage(&config);
        printf("mvdstdConvertImage(): 0x%08x\n", (unsigned int)ret);
    }
 
    f = fopen("sdmc:/mvd_outdata.bin", "w");
    if(f)
    {
        fwrite(outaddr, 1, 0x100000, f);
        fclose(f);
    }
 
    memcpy(gfxtopadr, outaddr, 0x46500);
 
    mvdstdExit();
 
    gfxFlushBuffers();
    gfxSwapBuffersGpu();
    gspWaitForVBlank();
}
 
void mvd_video()
{
    Result ret;
    size_t video_size, nalunitsize;
    u32 video_pos=0;
    u32 cur_nalunit_pos=0, prev_nalunit_pos=0;
    u32 nalcount=0;
    u8 *video;
 
    u32 flagval=0;
 
    FILE *f = NULL;
 
    u8* gfxtopadr=NULL;
 
    MVDSTD_Config config;
 
    u32 prefix_offset;
    u8 prefix[4] = {0x00, 0x00, 0x00, 0x01};
 
    printf("Loading video...\n");
 
    //This loads the entire video into memory, normally you'd use a library to stream it.
    f = fopen("romfs:/video.h264", "r");
    if(f==NULL)
    {
        printf("Faile to open the video in romfs.\n");
        return;
    }
 
    video = &inaddr[0x100000];
    video_size = fread(video, 1, 0xF00000, f);
    fclose(f);
 
    if(video_size==0 || video_size>=0xF00000)
    {
        printf("Failed to read video / video is too large.\n");
        return;
    }
 
    ret = mvdstdInit(MVDMODE_VIDEOPROCESSING, MVD_INPUT_H264, MVD_OUTPUT_BGR565, MVD_DEFAULT_WORKBUF_SIZE, NULL);
    printf("mvdstdInit(): 0x%08x\n", (unsigned int)ret);
    if(ret!=0)return;
 
    printf("Processing 0x%08x-byte video...\n", (unsigned int)video_size);
 
    mvdstdGenerateDefaultConfig(&config, 240, 400, 240, 400, NULL, (u32*)outaddr, (u32*)outaddr);//Normally you'd set the input dimensions here to dimensions loaded from the actual video.
 
    //Normally you'd use a library to load each NAL-unit, this example just parses the data manually.
    while(video_pos < video_size+1)
    {
        cur_nalunit_pos = video_pos;
        video_pos++;
 
        prefix_offset = 1;
 
        if(cur_nalunit_pos<video_size)
        {
            /*
            {
                if(memcmp(&video[cur_nalunit_pos], &prefix[1], 3)==0 && cur_nalunit_pos==0x2dd)
                {
                    prefix_offset = 0;
                }
            }
            if(prefix_offset)*/
            //else
            {
                if(memcmp(&video[cur_nalunit_pos], prefix, 4))
                {
                    continue;
                }
                else
                {
                    video_pos++;
                }
            }
        }
 
        if(nalcount && prev_nalunit_pos!=cur_nalunit_pos)
        {
            nalunitsize = cur_nalunit_pos - prev_nalunit_pos - prefix_offset;
            if(nalunitsize > 0x100000)
            {
                printf("The NAL-unit at offset 0x%08x is too large.\n", (unsigned int)nalunitsize);
                break;
            }
 
            memcpy(inaddr, &video[prev_nalunit_pos+prefix_offset], nalunitsize);
            GSPGPU_FlushDataCache(inaddr, nalunitsize);
 
            MVDSTD_ProcessNALUnitOut tmpout;//Normally you don't really need to use this.
 
            //printf("Processing NAL-unit at offset 0x%08x size 0x%08x...\n", (unsigned int)prev_nalunit_pos, (unsigned int)nalunitsize);
            ret = mvdstdProcessVideoFrame(inaddr, nalunitsize, flagval, &tmpout);
            if(!MVD_CHECKNALUPROC_SUCCESS(ret))
            {
                printf("mvdstdProcessVideoFrame() at NAL-unit offset 0x%08x size 0x%08x returned: 0x%08x. remaining_size=0x%08x.\n", (unsigned int)prev_nalunit_pos, (unsigned int)nalunitsize, (unsigned int)ret, (unsigned int)tmpout.remaining_size);
                break;
            }
 
            if(ret!=MVD_STATUS_PARAMSET && ret!=MVD_STATUS_INCOMPLETEPROCESSING)
            {
                gfxtopadr = gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL);
                config.physaddr_outdata0 = osConvertVirtToPhys(gfxtopadr);
 
                //This sets the MVD output to the framebuffer directly. This is to avoid doing the video->framebuffer image rotation on the ARM11.
                //Normally you'd use a seperate MVD output buffer, then transfer that to the framebuffer(such as with GPU rendering).
 
                ret = mvdstdRenderVideoFrame(&config, true);
                if(ret!=MVD_STATUS_OK)
                {
                    printf("mvdstdRenderVideoFrame() at NAL-unit offset 0x%08x returned: 0x%08x\n", (unsigned int)prev_nalunit_pos, (unsigned int)ret);
                    break;
                }
 
                hidScanInput();
                if(hidKeysDown() & KEY_B)break;
 
                //Enable/disable the flag passed to mvdstdProcessVideoFrame().
                if(hidKeysDown() & KEY_DOWN)
                {
                    flagval-= 0x1;
                    printf("0x%08x\n", (unsigned int)flagval);
                }
                if(hidKeysDown() & KEY_UP)
                {
                    flagval+= 0x1;
                    printf("0x%08x\n", (unsigned int)flagval);
                }
 
                //gspWaitForVBlank();//Can't use this under this example without a major slowdown. This is due to this example not doing any buffering for the frames.
                gfxSwapBuffersGpu();
            }
        }
 
        nalcount++;
 
        prev_nalunit_pos = cur_nalunit_pos;
    }
 
    mvdstdExit();
}
 
int main()
{
    Result ret=0;
 
    int draw=1;
    int ready=0;
    int type=0;
 
    gfxInit(GSP_RGB565_OES,GSP_BGR8_OES,false);
    consoleInit(GFX_BOTTOM, NULL);
 
    ret = romfsInit();
    if(R_FAILED(ret))
    {
        printf("romfsInit() failed: 0x%08x\n", (unsigned int)ret);
        ready = -1;
    }
 
    if(ready==0)
    {
        inaddr = linearMemAlign(0x1000000, 0x40);
        outaddr = linearMemAlign(0x100000, 0x40);
 
        if(!(inaddr && outaddr))
        {
            ready = -2;
            printf("Failed to allocate memory.\n");
        }
    }
 
    // Main loop
    while (aptMainLoop())
    {
        gspWaitForVBlank();
        hidScanInput();
 
        if(draw && type==0)
        {
            consoleClear();
            draw = 0;
 
            if(ready==0)printf("mvd example\n");
 
            printf("Press START to exit.\n");
            if(ready==0)
            {
                printf("Press A for color-format-conversion.\n");
                printf("Press B for video(no sound).\n");
            }
        }
 
        u32 kDown = hidKeysDown();
 
        if(type)
        {
            if(kDown & KEY_A)
            {
                type = 0;
                continue;
            }
        }
 
        if(type)continue;
 
        if (kDown & KEY_START)
            break; // break in order to return to hbmenu
 
        if(ready==0)
        {
            type = 0;
            if (kDown & KEY_A)type = 1;
            if (kDown & KEY_B)type = 2;
 
            if(type)
            {
                memset(inaddr, 0, 0x100000);
                memset(outaddr, 0, 0x100000);
 
                if(type==1)mvd_colorconvert();
                if(type==2)mvd_video();
 
                draw = 1;
                printf("Press A to continue.\n");
            }
        }
    }
 
    if(inaddr)linearFree(inaddr);
    if(outaddr)linearFree(outaddr);
 
    if(ready!=-1)romfsExit();
 
    gfxExit();
    return 0;
}