mic.c

Go to the documentation of this file.

#include <stdlib.h>
#include <string.h>
#include <3ds.h>

//See also: http://3dbrew.org/wiki/MIC_Services

Handle MIC_handle;

static u8 *MIC_sharedmem;
static u32 MIC_sharedmem_size;
static u32 *MIC_sharedmem_offsetfield, MIC_sharedmem_offsetfield_location;
static Handle MIC_sharedmem_handle;
static Handle MIC_event;

static u32 MIC_prev_endpos, MIC_cur_endpos;

Result MIC_Initialize(u32 *sharedmem, u32 sharedmem_size, u8 control, u8 recording, u8 unk0, u8 unk1, u8 unk2)
{
    Result ret=0;

    MIC_sharedmem = (u8*)sharedmem;
    MIC_sharedmem_size = sharedmem_size;
    MIC_sharedmem_offsetfield_location = MIC_sharedmem_size - 4;
    MIC_sharedmem_offsetfield = (u32*)&MIC_sharedmem[MIC_sharedmem_offsetfield_location];
    MIC_event = 0;
    MIC_prev_endpos = 0;
    MIC_cur_endpos = 0;

    ret = srvGetServiceHandle(&MIC_handle, "mic:u");
    if(ret!=0)return ret;

    ret = svcCreateMemoryBlock(&MIC_sharedmem_handle, (u32)MIC_sharedmem, MIC_sharedmem_size, 3, 3);
    if(ret!=0)return ret;

    ret = MIC_SetControl(control);
    if(ret!=0)return ret;

    ret = MIC_MapSharedMem(MIC_sharedmem_handle, sharedmem_size);
    if(ret!=0)return ret;

    ret = MIC_SetRecording(recording);
    if(ret!=0)return ret;

    ret = MIC_cmd3_Initialize(unk0, unk1, 0, MIC_sharedmem_size-4, unk2);
    if(ret!=0)return ret;

    ret = MIC_GetEventHandle(&MIC_event);
    if(ret!=0)return ret;
    svcClearEvent(MIC_event);

    return 0;
}

Result MIC_Shutdown()
{
    Result ret=0;

    MIC_cmd5();
    MIC_SetRecording(0);

    ret = MIC_UnmapSharedMem();
    if(ret!=0)return ret;

    MIC_cmd5();

    ret = svcUnmapMemoryBlock(MIC_sharedmem_handle, (u32)MIC_sharedmem);
    if(ret!=0)return ret;

    ret = svcCloseHandle(MIC_sharedmem_handle);
    if(ret!=0)return ret;

    ret = svcCloseHandle(MIC_event);
    if(ret!=0)return ret;

    ret = svcCloseHandle(MIC_handle);
    if(ret!=0)return ret;

    MIC_sharedmem_offsetfield = NULL;
    MIC_sharedmem = NULL;
    MIC_sharedmem_size = 0;
    MIC_handle = 0;
    MIC_event = 0;

    return 0;
}

u32 MIC_GetSharedMemOffsetValue()
{
    u32 pos = 0;

    if(MIC_sharedmem_offsetfield==NULL)return pos;
    pos = *MIC_sharedmem_offsetfield;
    if(pos > MIC_sharedmem_offsetfield_location)pos = MIC_sharedmem_offsetfield_location;

    return pos;
}

u32 MIC_ReadAudioData(u8 *outbuf, u32 readsize, u32 waitforevent)
{
    u32 pos = 0, bufpos = 0;
    
    if(waitforevent)
    {
        svcClearEvent(MIC_event);
        svcWaitSynchronization(MIC_event, U64_MAX);
    }

    MIC_prev_endpos = MIC_cur_endpos;
    MIC_cur_endpos = MIC_GetSharedMemOffsetValue();
    pos = MIC_prev_endpos;

    while(pos != MIC_cur_endpos)
    {
        if(pos >= MIC_sharedmem_offsetfield_location)pos = 0;
        if(bufpos>=readsize)break;

        outbuf[bufpos] = MIC_sharedmem[pos];
        bufpos++;
        pos++;
    }

    return bufpos;
}

Result MIC_MapSharedMem(Handle handle, u32 size)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00010042;
    cmdbuf[1] = size;
    cmdbuf[2] = 0;
    cmdbuf[3] = handle;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    return (Result)cmdbuf[1];
}

Result MIC_UnmapSharedMem()
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00020000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    return (Result)cmdbuf[1];
}

Result MIC_cmd3_Initialize(u8 unk0, u8 unk1, u32 sharedmem_baseoffset, u32 sharedmem_endoffset, u8 unk2)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00030140;
    cmdbuf[1] = unk0;
    cmdbuf[2] = unk1;
    cmdbuf[3] = sharedmem_baseoffset;
    cmdbuf[4] = sharedmem_endoffset;
    cmdbuf[5] = unk2;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    return (Result)cmdbuf[1];
}

Result MIC_cmd5()
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00050000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    return (Result)cmdbuf[1];
}

Result MIC_GetCNTBit15(u8 *out)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00060000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    if(out)*out = cmdbuf[2];

    return (Result)cmdbuf[1];
}

Result MIC_GetEventHandle(Handle *handle)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    if(MIC_event)
    {
        *handle = MIC_event;
        return 0;
    }

    cmdbuf[0] = 0x00070000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    if(handle)*handle = cmdbuf[2];

    return (Result)cmdbuf[1];
}

Result MIC_SetControl(u8 value)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00080040;
    cmdbuf[1] = value;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    return (Result)cmdbuf[1];
}

Result MIC_GetControl(u8 *value)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x00090000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    if(value)*value = cmdbuf[2];

    return (Result)cmdbuf[1];
}

Result MIC_SetRecording(u8 value)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x000A0040;
    cmdbuf[1] = value;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    if(value==1)MIC_cur_endpos = MIC_GetSharedMemOffsetValue();

    return (Result)cmdbuf[1];
}

Result MIC_IsRecoding(u8 *value)
{
    Result ret=0;
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x000B0000;

    if((ret = svcSendSyncRequest(MIC_handle))!=0)return ret;

    if(value)*value = cmdbuf[2];

    return (Result)cmdbuf[1];
}