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); }