void patchMenuRop(int processId, u32* argbuf, u32 argbuflength)
{
// grab un-processed backup ropbin
GSPGPU_FlushDataCache(NULL, (u8*)&gspHeap[0x00100000], 0x8000);
doGspwn((u32*)MENU_LOADEDROP_BKP_BUFADR, (u32*)&gspHeap[0x00100000], 0x8000);
svc_sleepThread(50*1000*1000);
// patch it
if(processId == -2 && argbuf && argbuf[0] >= 2)
{
memorymap_t* mmap = getMmapArgbuf(argbuf, argbuflength);
patchPayload((u32*)&gspHeap[0x00100000], processId, mmap);
}else patchPayload((u32*)&gspHeap[0x00100000], processId, NULL);
// copy it to destination
GSPGPU_FlushDataCache(NULL, (u8*)&gspHeap[0x00100000], 0x8000);
doGspwn((u32*)&gspHeap[0x00100000], (u32*)MENU_LOADEDROP_BUFADR, 0x8000);
svc_sleepThread(50*1000*1000);
// copy parameter block
if(argbuf)memcpy(&gspHeap[0x00200000], argbuf, argbuflength);
else memset(&gspHeap[0x00200000], 0x00, MENU_PARAMETER_SIZE);
GSPGPU_FlushDataCache(NULL, (u8*)&gspHeap[0x00200000], MENU_PARAMETER_SIZE);
doGspwn((u32*)&gspHeap[0x00200000], (u32*)(MENU_PARAMETER_BUFADR), MENU_PARAMETER_SIZE);
svc_sleepThread(20*1000*1000);
}
struct GUIFont* GUIFontCreate(void) {
struct GUIFont* guiFont = malloc(sizeof(struct GUIFont));
if (!guiFont) {
return 0;
}
struct ctrTexture* tex = &guiFont->texture;
ctrTexture_Init(tex);
tex->data = vramAlloc(256 * 128 * 2);
tex->format = GPU_RGBA5551;
tex->width = 256;
tex->height = 128;
GSPGPU_FlushDataCache(font, font_size);
GX_RequestDma((u32*) font, tex->data, font_size);
gspWaitForDMA();
tex = &guiFont->icons;
ctrTexture_Init(tex);
tex->data = vramAlloc(256 * 64 * 2);
tex->format = GPU_RGBA5551;
tex->width = 256;
tex->height = 64;
GSPGPU_FlushDataCache(icons, icons_size);
GX_RequestDma((u32*) icons, tex->data, icons_size);
gspWaitForDMA();
return guiFont;
}
void setClockrate(u8 setting)
{
int j, i;
u32* patchArea = linearAlloc(0x00100000);
if(setting != 0) setting = 3;
// grab waitLoop stub
GSPGPU_FlushDataCache(NULL, (u8*)patchArea, 0x100);
gspwn(patchArea, (u32*)(MENU_LOADEDROP_BUFADR-0x100), 0x100);
svcSleepThread(20*1000*1000);
// patch it
for(i=0; i<0x100/4; i++)
{
if(patchArea[i] == 0x67666E63) // "cnfg"
{
patchArea[i+1] = (patchArea[i+1] & ~0xFF) | setting;
break;
}
}
// copy it back
GSPGPU_FlushDataCache(NULL, (u8*)patchArea, 0x100);
gspwn((u32*)(MENU_LOADEDROP_BUFADR-0x100), patchArea, 0x100);
svcSleepThread(20*1000*1000);
// ghetto dcache invalidation
// don't judge me
for(j=0; j<4; j++)
for(i=0; i<0x00100000/0x4; i+=0x4)
patchArea[i+j]^=0xDEADBABE;
linearFree(patchArea);
}
static int lua_startBMPV(lua_State *L){
int argc = lua_gettop(L);
if ((argc != 3) && (argc != 4)) return luaL_error(L, "wrong number of arguments");
BMPV* src = (BMPV*)luaL_checkint(L, 1);
int loop = luaL_checkint(L, 2);
int ch1 = luaL_checkint(L, 3);
if (argc == 4){
int ch2 = luaL_checkint(L, 4);
src->ch2 = ch2;
}
src->loop = loop;
src->isPlaying = true;
src->ch1 = ch1;
src->currentFrame = 0;
u32 bytesRead;
if (src->samplerate != 0 && src->audio_size != 0 && !GW_MODE){
while(src->mem_size > MAX_RAM_ALLOCATION){
src->mem_size = src->mem_size / 2;
}
if (src->audiotype == 1){
FSFILE_Read(src->sourceFile, &bytesRead, 28, src->audiobuf, src->mem_size);
GSPGPU_FlushDataCache(NULL, src->audiobuf, src->audio_size);
My_CSND_playsound(ch1, CSND_LOOP_ENABLE, CSND_ENCODING_PCM16, src->samplerate, (u32*)src->audiobuf, (u32*)src->audiobuf, src->mem_size, 0xFFFF, 0xFFFF);
}else{
u8* audiobuf = (u8*)linearAlloc(src->mem_size);
FSFILE_Read(src->sourceFile, &bytesRead, 28, audiobuf, src->mem_size);
src->audiobuf = (u8*)linearAlloc(src->mem_size/2);
src->audiobuf2 = (u8*)linearAlloc(src->mem_size/2);
u32 off=0;
u32 i=0;
u16 z;
while (i < (src->mem_size)){
z=0;
while (z < (src->bytepersample/2)){
src->audiobuf[off+z] = audiobuf[i+z];
src->audiobuf2[off+z] = audiobuf[i+z+(src->bytepersample/2)];
z++;
}
i=i+src->bytepersample;
off=off+(src->bytepersample/2);
}
linearFree(audiobuf);
GSPGPU_FlushDataCache(NULL, src->audiobuf, src->mem_size/2);
GSPGPU_FlushDataCache(NULL, src->audiobuf2, src->mem_size/2);
My_CSND_playsound(src->ch1, CSND_LOOP_ENABLE, CSND_ENCODING_PCM16, src->samplerate, (u32*)src->audiobuf, (u32*)src->audiobuf, src->mem_size/2, 0xFFFF, 0);
My_CSND_playsound(src->ch2, CSND_LOOP_ENABLE, CSND_ENCODING_PCM16, src->samplerate, (u32*)src->audiobuf2, (u32*)src->audiobuf2, src->mem_size/2, 0, 0xFFFF);
}
src->tick = osGetTime();
CSND_setchannel_playbackstate(ch1, 1);
if (src->audiotype == 2){
CSND_setchannel_playbackstate(src->ch2, 1);
}
CSND_sharedmemtype0_cmdupdatestate(0);
src->moltiplier = 1;
}else{
src->tick = osGetTime();
}
return 0;
}
void gfxFlushBuffers(void)
{
u32 topSize = 400 * 240 * __get_bytes_per_pixel(gfxGetScreenFormat(GFX_TOP));
u32 bottomSize = 320 * 240 * __get_bytes_per_pixel(gfxGetScreenFormat(GFX_BOTTOM));
GSPGPU_FlushDataCache(gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL), topSize);
if(enable3d)GSPGPU_FlushDataCache(gfxGetFramebuffer(GFX_TOP, GFX_RIGHT, NULL, NULL), topSize);
GSPGPU_FlushDataCache(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), bottomSize);
}
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
D3DSDevice::FlushBuffers()
{
u32 bytes_top = 400 * 240 * GetBytesPerPixel( m_FBFormatTop );
u32 bytes_btm = 320 * 240 * GetBytesPerPixel( m_FBFormatBottom );
GSPGPU_FlushDataCache( GetFramebufferPtr(D3DS_FRAMEBUFFER_TOP_LEFT,nullptr,nullptr), bytes_top );
if (m_b3DEnabled)
GSPGPU_FlushDataCache( GetFramebufferPtr(D3DS_FRAMEBUFFER_TOP_RIGHT,nullptr,nullptr), bytes_top );
GSPGPU_FlushDataCache( GetFramebufferPtr(D3DS_FRAMEBUFFER_BOTTOM,nullptr,nullptr), bytes_btm );
}
static void flashScreen(void)
{
// Fills the bottom buffer with a random pattern
// Change this to the addresses read from gpu reg later
void *src = work_buffer; // Random buffer location, see pointers.11.h
for (int i = 0; i < 3; i++)
{ // Do it 3 times to be safe
GSPGPU_FlushDataCache(src, 0x00038400);
GX_SetTextureCopy(src, (void *)0x1F48F000, 0x00038400, 0, 0, 0, 0, 8);
svc_sleepThread(0x400000LL);
GSPGPU_FlushDataCache(src, 0x00038400);
GX_SetTextureCopy(src, (void *)0x1F4C7800, 0x00038400, 0, 0, 0, 0, 8);
svc_sleepThread(0x400000LL);
}
}
uint8_t* audio_load(uint8_t* buf, const char *audio) {
FILE* file = fopen(audio, "rb");
off_t size = 0;
if (file != NULL) {
fseek(file, 0, SEEK_END);
size = ftell(file);
buf = linearAlloc(size);
fseek(file, 0, SEEK_SET);
fread(buf, 1, size, file);
if (ferror(file)) {
return NULL;
}
fclose(file);
}
uint8_t channel = 0x8;
uint32_t sample_rate = 44100;
uint32_t flags = SOUND_FORMAT_16BIT | SOUND_ONE_SHOT;
//channel++;
//channel%=8;
GSPGPU_FlushDataCache(buf, size);
csndPlaySound(channel, flags, sample_rate, 1.0, 0.0, buf, buf, size);
return buf;
}
Result runStub(Handle nssHandle, memorymap_t* m, u8* code_data)
{
u32 tmp;
// flush code we're about to copy
void* src_adr = (void*)(code_data);
void* dst_adr = (void*)(FIRM_APPMEMALLOC_LINEAR - m->processLinearOffset);
Result ret = GSPGPU_FlushDataCache(NULL, src_adr, HANS_LOADER_SIZE);
if(ret)return ret;
// need to load those now because we're about to unmap bss
Handle local_gspGpuHandle = gspGpuHandle;
Handle local_gspSharedMemHandle = gspSharedMemHandle;
void (*local_stub)(Handle gsp, Handle nss, Handle gspMem) = stub;
// free GSP heap
svc_controlMemory(&tmp, (u32)gspHeap, 0x0, gspHeap_size, MEMOP_FREE, 0x0);
// start copying code
doGspwn(src_adr, dst_adr, HANS_LOADER_SIZE);
// // free heap (includes bss !)
// svc_controlMemory(&tmp, (u32)0x08000000, 0x0, _heap_size, MEMOP_FREE, 0x0);
local_stub(local_gspGpuHandle, nssHandle, local_gspSharedMemHandle);
return 0;
}
void audio_stop(void) {
csndExecCmds(true);
CSND_SetPlayState(0x8, 0);
memset(buffer, 0, size);
GSPGPU_FlushDataCache(buffer, size);
linearFree(buffer);
}
void load_texture(C3D_Tex *tex, const u8 *img, const u32 img_size) {
unsigned int width, height;
u8* image;
lodepng_decode32(&image, &width, &height, img, img_size);
u8 *gpusrc = (u8 *) linearAlloc(width * height * 4);
// lodepng outputs big endian rgba so we need to convert
convert_endianess(gpusrc, image, width * height);
// ensure data is in physical ram
GSPGPU_FlushDataCache(gpusrc, width * height * 4);
// Load the texture and bind it to the first texture unit
C3D_TexInit(tex, width, height, GPU_RGBA8);
// Convert image to 3DS tiled texture format
C3D_SyncDisplayTransfer((u32*)gpusrc, GX_BUFFER_DIM(width, height), (u32*) tex->data, GX_BUFFER_DIM(width, height), TEXTURE_TRANSFER_FLAGS);
C3D_TexSetFilter(tex, GPU_LINEAR, GPU_NEAREST);
free(image);
linearFree(gpusrc);
}
static void ctr_set_texture_frame(void* data, const void* frame, bool rgb32,
unsigned width, unsigned height, float alpha)
{
int i;
ctr_video_t* ctr = (ctr_video_t*)data;
uint16_t* dst = (uint16_t*)ctr->menu.texture_linear;
const uint16_t* src = frame;
int line_width = width;
(void)rgb32;
(void)alpha;
if (line_width > ctr->menu.texture_width)
line_width = ctr->menu.texture_width;
if (height > (unsigned)ctr->menu.texture_height)
height = (unsigned)ctr->menu.texture_height;
for (i = 0; i < height; i++)
{
memcpy(dst, src, line_width * sizeof(uint16_t));
dst += ctr->menu.texture_width;
src += width;
}
ctr->menu.frame_coords->x0 = (CTR_TOP_FRAMEBUFFER_WIDTH - width) / 2;
ctr->menu.frame_coords->y0 = (CTR_TOP_FRAMEBUFFER_HEIGHT - height) / 2;
ctr->menu.frame_coords->x1 = ctr->menu.frame_coords->x0 + width;
ctr->menu.frame_coords->y1 = ctr->menu.frame_coords->y0 + height;
ctr->menu.frame_coords->u = width;
ctr->menu.frame_coords->v = height;
GSPGPU_FlushDataCache(NULL, (u8*)ctr->menu.frame_coords, sizeof(ctr_vertex_t));
}
void pm_3ds_sound_start(int freq, int len)
{
bufferpos = 0;
soundstate=1;
pm_3ds_sound_callback(len*1.2); // Filling first frame with +25% of samples to avoid buffer get empty
GSPGPU_FlushDataCache(NULL, stream, SOUND_BUFFER_SIZE);
csndPlaySound(0x8, SOUND_REPEAT | SOUND_FORMAT_8BIT, freq, 1.0, 0.0, (u32*)stream, (u32*)stream, SOUND_BUFFER_SIZE);
}
void pm_3ds_sound_callback(int len)
{
int buffertail;
if(soundstate) {
if (bufferpos+len<=SOUND_BUFFER_SIZE) {
MinxAudio_GetSamplesU8(stream+bufferpos, len); // I call a modded func that return S8 instead of U8
GSPGPU_FlushDataCache(NULL, stream+bufferpos, len);
} else {
buffertail = SOUND_BUFFER_SIZE - bufferpos;
MinxAudio_GetSamplesU8(stream+bufferpos, buffertail);
MinxAudio_GetSamplesU8(stream, len-buffertail);
GSPGPU_FlushDataCache(NULL, stream+bufferpos, buffertail);
GSPGPU_FlushDataCache(NULL, stream, len-buffertail);
}
bufferpos= (bufferpos+len) % SOUND_BUFFER_SIZE;
}
}
void copyBuffer()
{
//copy topleft FB
u8 copiedBuffer=currentBuffer^1;
u8* bufAdr=&gspHeap[0x46500*copiedBuffer];
GSPGPU_FlushDataCache(NULL, bufAdr, 0x46500);
GX_RequestDma(gxCmdBuf, (u32*)bufAdr, (u32*)topLeftFramebuffers[copiedBuffer], 0x46500);
}
static void _postAudioBuffer(struct GBAAVStream* stream, struct GBAAudio* audio) {
UNUSED(stream);
memset(audioLeft, 0, AUDIO_SAMPLES * sizeof(int16_t));
memset(audioRight, 0, AUDIO_SAMPLES * sizeof(int16_t));
#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
blip_read_samples(audio->left, audioLeft, AUDIO_SAMPLES, false);
blip_read_samples(audio->right, audioRight, AUDIO_SAMPLES, false);
#elif RESAMPLE_LIBRARY == RESAMPLE_NN
GBAAudioCopy(audio, audioLeft, audioRight, AUDIO_SAMPLES);
#endif
GSPGPU_FlushDataCache(0, (void*) audioLeft, AUDIO_SAMPLES * sizeof(int16_t));
GSPGPU_FlushDataCache(0, (void*) audioRight, AUDIO_SAMPLES * sizeof(int16_t));
csndPlaySound(0x8, SOUND_ONE_SHOT | SOUND_FORMAT_16BIT, 0x8000, 1.0, -1.0, audioLeft, audioLeft, AUDIO_SAMPLES * sizeof(int16_t));
csndPlaySound(0x9, SOUND_ONE_SHOT | SOUND_FORMAT_16BIT, 0x8000, 1.0, 1.0, audioRight, audioRight, AUDIO_SAMPLES * sizeof(int16_t));
CSND_SetPlayState(0x8, 1);
CSND_SetPlayState(0x9, 1);
csndExecCmds(false);
}
Result writehax_sharedmem_physmem(u32 *linearaddr)
{
Result ret=0;
u32 chunksize = 0x1000;
u32 *tmpbuf;
//Allocate memory for the sharedmem page, then copy the sharedmem physmem data into the buf.
tmpbuf = linearAlloc(chunksize);
if(tmpbuf==NULL)
{
printf("Failed to allocate mem for tmpbuf.\n");
return -1;
}
memset(tmpbuf, 0, chunksize);
GSPGPU_FlushDataCache(tmpbuf, chunksize);
GX_TextureCopy(linearaddr, 0, tmpbuf, 0, chunksize, 0x8);
gspWaitForPPF();
ret = init_hax_sharedmem(tmpbuf);
if(ret)
{
linearFree(tmpbuf);
return ret;
}
//Flush dcache for the modified sharedmem, then copy the data back into the sharedmem physmem.
GSPGPU_FlushDataCache(tmpbuf, chunksize);
GX_TextureCopy(tmpbuf, 0, linearaddr, 0, chunksize, 0x8);
gspWaitForPPF();
linearFree(tmpbuf);
return 0;
}
void gfxLoadBorder(u8* imgData, int imgWidth, int imgHeight) {
if(imgData == NULL || (borderInit && (borderWidth != imgWidth || borderHeight != imgHeight))) {
if(borderInit) {
C3D_TexDelete(&borderTexture);
borderInit = false;
}
borderWidth = 0;
borderHeight = 0;
gpuBorderWidth = 0;
gpuBorderHeight = 0;
if(imgData == NULL) {
return;
}
}
// Adjust the texture to power-of-two dimensions.
borderWidth = imgWidth;
borderHeight = imgHeight;
gpuBorderWidth = (int) pow(2, ceil(log(borderWidth) / log(2)));
gpuBorderHeight = (int) pow(2, ceil(log(borderHeight) / log(2)));
// Create the texture.
if(!borderInit && !C3D_TexInit(&borderTexture, gpuBorderWidth, gpuBorderHeight, GPU_RGBA8)) {
return;
}
C3D_TexSetFilter(&borderTexture, GPU_LINEAR, GPU_LINEAR);
// Copy the texture to a power-of-two sized buffer.
u32* imgBuffer = (u32*) imgData;
u32* temp = (u32*) linearAlloc(gpuBorderWidth * gpuBorderHeight * sizeof(u32));
for(int x = 0; x < borderWidth; x++) {
for(int y = 0; y < borderHeight; y++) {
temp[y * gpuBorderWidth + x] = imgBuffer[y * borderWidth + x];
}
}
GSPGPU_FlushDataCache(temp, gpuBorderWidth * gpuBorderHeight * sizeof(u32));
if(R_SUCCEEDED(GX_DisplayTransfer(temp, (u32) GX_BUFFER_DIM(gpuBorderWidth, gpuBorderHeight), (u32*) borderTexture.data, (u32) GX_BUFFER_DIM(gpuBorderWidth, gpuBorderHeight), GX_TRANSFER_FLIP_VERT(1) | GX_TRANSFER_OUT_TILED(1) | GX_TRANSFER_RAW_COPY(0) | GX_TRANSFER_IN_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_OUT_FORMAT(GX_TRANSFER_FMT_RGBA8) | GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_NO)))) {
gspWaitForPPF();
}
linearFree(temp);
GSPGPU_InvalidateDataCache(borderTexture.data, borderTexture.size);
borderInit = true;
}
void Sprite::render() {
if (dirtyPixels) {
dirtyPixels = false;
GSPGPU_FlushDataCache(pixels, w * h * format.bytesPerPixel);
C3D_SafeDisplayTransfer((u32*)pixels, GX_BUFFER_DIM(w, h), (u32*)texture.data, GX_BUFFER_DIM(w, h), TEXTURE_TRANSFER_FLAGS);
gspWaitForPPF();
}
C3D_TexBind(0, &texture);
C3D_BufInfo *bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
BufInfo_Add(bufInfo, vertices, sizeof(vertex), 2, 0x10);
C3D_DrawArrays(GPU_TRIANGLE_STRIP, 0, 4);
}
static void svchax_gspwn(u32 dst, u32 src, u32 size, u8* flush_buffer)
{
extern Handle gspEvents[GSPEVENT_MAX];
memcpy(flush_buffer, flush_buffer + 0x4000, 0x4000);
GSPGPU_InvalidateDataCache(dst, size);
GSPGPU_FlushDataCache(src, size);
memcpy(flush_buffer, flush_buffer + 0x4000, 0x4000);
svcClearEvent(gspEvents[GSPEVENT_PPF]);
GX_TextureCopy(src, 0, dst, 0, size, 8);
svcWaitSynchronization(gspEvents[GSPEVENT_PPF], U64_MAX);
memcpy(flush_buffer, flush_buffer + 0x4000, 0x4000);
}
void ctrFlushBatch(void) {
if (ctrNumVerts == 0) {
return;
}
C3D_BufInfo* bufInfo = C3D_GetBufInfo();
BufInfo_Init(bufInfo);
BufInfo_Add(bufInfo, &ctrVertexBuffer[ctrVertStart], sizeof(struct ctrUIVertex), 4, 0x3210);
GSPGPU_FlushDataCache(&ctrVertexBuffer[ctrVertStart], sizeof(struct ctrUIVertex) * ctrNumVerts);
C3D_DrawArrays(GPU_GEOMETRY_PRIM, 0, ctrNumVerts);
ctrVertStart += ctrNumVerts;
ctrNumVerts = 0;
}
void copyBuffer()
{
//copy topleft FB
u8 copiedBuffer=currentBuffer^1;
u8* bufAdr=&gspHeap[0x46500*copiedBuffer];
GSPGPU_FlushDataCache(gspGpuHandle, bufAdr, 0x46500);
//GX RequestDma
u32 gxCommand[0x8];
gxCommand[0]=0x00; //CommandID
gxCommand[1]=(u32)bufAdr; //source address
gxCommand[2]=(u32)topLeftFramebuffers[copiedBuffer]; //destination address
gxCommand[3]=0x46500; //size
gxCommand[4]=gxCommand[5]=gxCommand[6]=gxCommand[7]=0x0;
GSPGPU_submitGxCommand(gxCmdBuf, gxCommand, gspGpuHandle);
}
// Mic thread
void threadMic(){
while(1) {
svcWaitSynchronization(threadRequest, U64_MAX);
svcClearEvent(threadRequest);
if(threadExit) svcExitThread();
touchPosition touch;
hidTouchRead(&touch);
u32 kDown = hidKeysDown();
if((touchInCircle(touch, 85, 120, 35) || kDown & KEY_A) && recording == 0)
{
audiobuf_pos = 0;
MIC_SetRecording(1);
recording = 1;
}
if((recording == 1) && (audiobuf_pos < audiobuf_size))
{
audiobuf_pos+= MIC_ReadAudioData(&audiobuf[audiobuf_pos], audiobuf_size-audiobuf_pos, 0);
if(audiobuf_pos > audiobuf_size)audiobuf_pos = audiobuf_size;
if(audiobuf_pos >= 32704 && print == 0){
print = 1;
}
}
if((touchInCircle(touch, 165, 120, 35) || kDown & KEY_B) && recording == 1)
{
print = 0;
MIC_SetRecording(0);
recording = 2;
//Prevent first mute second to be allocated in wav struct
if(audiobuf_pos >= 32704){
nomute_audiobuf = (u8*)linearAlloc(audiobuf_pos - 32704);
memcpy(nomute_audiobuf,&audiobuf[32704],audiobuf_pos - 32704);
buf_size = (audiobuf_pos - 32704) / 2;
write_wav("audio.wav", buf_size, (short int *)nomute_audiobuf, S_RATE);
}
GSPGPU_FlushDataCache(NULL, nomute_audiobuf, audiobuf_pos);
recording = 0;
}
}
}
void Audio_Pause()
{
if(isPlaying)
{
// stop
if (Audio_Type == 1)
{
CSND_SetPlayState(8, 0);
CSND_SetPlayState(9, 0);
csndExecCmds(0);
}
memset(Audio_Buffer, 0, MIXBUFSIZE*4*2);
GSPGPU_FlushDataCache(NULL, Audio_Buffer, MIXBUFSIZE*4*2);
isPlaying = false;
}
}
static INLINE void ctr_check_3D_slider(ctr_video_t* ctr)
{
float slider_val = *(float*)0x1FF81080;
ctr_video_mode_enum old_mode = ctr->video_mode;
if (slider_val == 0.0)
ctr->video_mode = CTR_VIDEO_MODE_NORMAL;
else if (slider_val < 0.2)
ctr->video_mode = CTR_VIDEO_MODE_800x240;
else if (slider_val < 0.5)
ctr->video_mode = CTR_VIDEO_MODE_400x240;
else
ctr->video_mode = CTR_VIDEO_MODE_3D;
if (ctr->video_mode)
{
switch (ctr->video_mode)
{
case CTR_VIDEO_MODE_800x240:
case CTR_VIDEO_MODE_400x240:
ctr_set_parallax_layer(false);
break;
case CTR_VIDEO_MODE_3D:
{
s16 offset = (slider_val - 0.6) * 10.0;
ctr->frame_coords[1] = ctr->frame_coords[0];
ctr->frame_coords[2] = ctr->frame_coords[0];
ctr->frame_coords[1].x0 -= offset;
ctr->frame_coords[1].x1 -= offset;
ctr->frame_coords[2].x0 += offset;
ctr->frame_coords[2].x1 += offset;
GSPGPU_FlushDataCache(ctr->frame_coords, 3 * sizeof(ctr_vertex_t));
ctr_set_parallax_layer(true);
break;
}
default:
break;
}
}
}
bool Audio_Begin()
{
if(isPlaying)
return 0;
memset(Audio_Buffer, 0, MIXBUFSIZE*4*2);
GSPGPU_FlushDataCache(NULL, Audio_Buffer, MIXBUFSIZE*4*2);
if (Audio_Type == 1)
{
myCSND_SetSound(8, SOUND_FORMAT_16BIT | SOUND_REPEAT, 32000, &Audio_Buffer[0], &Audio_Buffer[0], MIXBUFSIZE*4, 0xFFFF, 0);
myCSND_SetSound(9, SOUND_FORMAT_16BIT | SOUND_REPEAT, 32000, &Audio_Buffer[MIXBUFSIZE*2], &Audio_Buffer[MIXBUFSIZE*2], MIXBUFSIZE*4, 0, 0xFFFF);
csndExecCmds(0);
}
cursample = MIXBUFSIZE;//(MIXBUFSIZE * 3) >> 1;
isPlaying = true;
return 1;
}
void apply_map(memorymap_t* m)
{
if(!m)return;
int i;
vu32* APP_START_LINEAR = &_APP_START_LINEAR;
for(i=0; i<m->header.num; i++)
{
int remaining_size = m->map[i].size;
u32 offset = 0;
while(remaining_size > 0)
{
int size = remaining_size;
if(size > 0x00080000)size = 0x00080000;
GSPGPU_FlushDataCache(NULL, (u8*)&gspHeap[m->map[i].src + offset], size);
svc_sleepThread(5*1000*1000);
doGspwn((u32*)&gspHeap[m->map[i].src + offset], (u32*)(*APP_START_LINEAR + m->map[i].dst + offset), size);
remaining_size -= size;
offset += size;
}
}
}
Result apply_map(memorymap_t* m, u8* code_data, u32 code_skip)
{
if(!m)return -1;
Result ret = 0;
int i;
for(i=0; i<m->num; i++)
{
int remaining_size = m->map[i].size;
u32 offset = 0;
if(!i)
{
// assume code_skip will always be less than the first map region
// (it probably will tbh)
offset = code_skip;
remaining_size -= offset;
}
while(remaining_size > 0)
{
int size = remaining_size;
if(size > 0x00080000) size = 0x00080000;
ret = GSPGPU_FlushDataCache(NULL, (u8*)&code_data[m->map[i].src + offset], size);
if(ret) return ret;
svc_sleepThread(5*1000*1000);
doGspwn((u32*)&code_data[m->map[i].src - 0x00100000 + offset], (u32*)(FIRM_APPMEMALLOC_LINEAR - m->processLinearOffset + m->map[i].dst + offset), size);
remaining_size -= size;
offset += size;
}
}
return ret;
}
void gfxFlushBuffers()
{
GSPGPU_FlushDataCache(NULL, gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL), 0x46500);
if(enable3d)GSPGPU_FlushDataCache(NULL, gfxGetFramebuffer(GFX_TOP, GFX_RIGHT, NULL, NULL), 0x46500);
GSPGPU_FlushDataCache(NULL, gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), 0x38400);
}
