From ab379f2bb081f3fe2ea77ed163f755f59a49e6cf Mon Sep 17 00:00:00 2001 From: Takamichi Horikawa Date: Wed, 12 Apr 2017 01:04:15 +0900 Subject: added wave output --- win32/fmplayer.mak | 4 + win32/main.c | 118 ++++++++---------------------- win32/wavesave.c | 210 +++++++++++++++++++++++++++++++++++++++++++++++++++++ win32/wavesave.h | 9 +++ win32/wavewrite.c | 90 +++++++++++++++++++++++ win32/wavewrite.h | 15 ++++ 6 files changed, 357 insertions(+), 89 deletions(-) create mode 100644 win32/wavesave.c create mode 100644 win32/wavesave.h create mode 100644 win32/wavewrite.c create mode 100644 win32/wavewrite.h (limited to 'win32') diff --git a/win32/fmplayer.mak b/win32/fmplayer.mak index 14e3246..9a514b2 100644 --- a/win32/fmplayer.mak +++ b/win32/fmplayer.mak @@ -28,6 +28,8 @@ SSEOBJBASE=opnassg-sinc-sse2 \ OBJBASE=main \ toneview \ oscilloview \ + wavesave \ + wavewrite \ soundout \ dsoundout \ waveout \ @@ -35,6 +37,8 @@ OBJBASE=main \ guid \ fmplayer_file \ fmplayer_file_win \ + fmplayer_drumrom_win \ + fmplayer_work_opna \ about \ $(FMDRIVER_OBJS) \ $(LIBOPNA_OBJS) \ diff --git a/win32/main.c b/win32/main.c index 76cd883..66a1bf0 100644 --- a/win32/main.c +++ b/win32/main.c @@ -20,6 +20,8 @@ #include "oscillo/oscillo.h" #include "oscilloview.h" #include "about.h" +#include "common/fmplayer_common.h" +#include "wavesave.h" enum { ID_OPENFILE = 0x10, @@ -28,6 +30,7 @@ enum { ID_TONEVIEW, ID_OSCILLOVIEW, ID_ABOUT, + ID_WAVESAVE, }; #define FMPLAYER_CLASSNAME L"myon_fmplayer_ym2608_win32" @@ -58,12 +61,10 @@ static struct { struct fmdsp_font font; uint8_t fontrom[FONT_ROM_FILESIZE]; bool font_loaded; - void *drum_rom; uint8_t opna_adpcm_ram[OPNA_ADPCM_RAM_SIZE]; bool paused; HWND mainwnd; WNDPROC btn_defproc; - HWND driverinfo; HWND button_2x, button_toneview, button_oscilloview, button_about; bool toneview_on, oscilloview_on, about_on; const wchar_t *lastopenpath; @@ -72,39 +73,11 @@ static struct { UINT mmtimer; HBITMAP bitmap_vram; uint8_t *vram32; + bool drum_loaded; } g; HWND g_currentdlg; -static void opna_int_cb(void *userptr) { - struct fmdriver_work *work = (struct fmdriver_work *)userptr; - work->driver_opna_interrupt(work); -} - -static void opna_mix_cb(void *userptr, int16_t *buf, unsigned samples) { - struct ppz8 *ppz8 = (struct ppz8 *)userptr; - ppz8_mix(ppz8, buf, samples); -} - -static void opna_writereg_libopna(struct fmdriver_work *work, unsigned addr, unsigned data) { - struct opna_timer *timer = (struct opna_timer *)work->opna; - opna_timer_writereg(timer, addr, data); -} - -static unsigned opna_readreg_libopna(struct fmdriver_work *work, unsigned addr) { -// struct opna_timer *timer = (struct opna_timer *)work->opna; - return opna_readreg(&g.opna, addr); -} - -static uint8_t opna_status_libopna(struct fmdriver_work *work, bool a1) { - struct opna_timer *timer = (struct opna_timer *)work->opna; - uint8_t status = opna_timer_status(timer); - if (!a1) { - status &= 0x83; - } - return status; -} - static void sound_cb(void *p, int16_t *buf, unsigned frames) { struct opna_timer *timer = (struct opna_timer *)p; ZeroMemory(buf, sizeof(int16_t)*frames*2); @@ -159,39 +132,6 @@ static void loadfont(void) { } } -static void loadrom(void) { - const wchar_t *path = L"ym2608_adpcm_rom.bin"; - wchar_t exepath[MAX_PATH]; - if (GetModuleFileName(0, exepath, MAX_PATH)) { - PathRemoveFileSpec(exepath); - if ((lstrlen(exepath) + lstrlen(path) + 1) < MAX_PATH) { - lstrcat(exepath, L"\\"); - lstrcat(exepath, path); - path = exepath; - } - } - HANDLE file = CreateFile(path, GENERIC_READ, - 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); - if (file == INVALID_HANDLE_VALUE) goto err; - DWORD filesize = GetFileSize(file, 0); - if (filesize != OPNA_ROM_SIZE) goto err_file; - void *buf = HeapAlloc(g.heap, 0, OPNA_ROM_SIZE); - if (!buf) goto err_file; - DWORD readbytes; - if (!ReadFile(file, buf, OPNA_ROM_SIZE, &readbytes, 0) - || readbytes != OPNA_ROM_SIZE) goto err_buf; - CloseHandle(file); - g.drum_rom = buf; - about_set_adpcmrom_loaded(true); - return; -err_buf: - HeapFree(g.heap, 0, buf); -err_file: - CloseHandle(file); -err: - return; -} - static void openfile(HWND hwnd, const wchar_t *path) { enum fmplayer_file_error error; struct fmplayer_file *fmfile = fmplayer_file_alloc(path, &error); @@ -213,27 +153,17 @@ static void openfile(HWND hwnd, const wchar_t *path) { fmplayer_file_free(g.fmfile); g.fmfile = fmfile; unsigned mask = opna_get_mask(&g.opna); - opna_reset(&g.opna); + fmplayer_init_work_opna(&g.work, &g.ppz8, &g.opna, &g.opna_timer, g.opna_adpcm_ram); + if (!g.drum_loaded && fmplayer_drum_loaded()) { + g.drum_loaded = true; + about_set_adpcmrom_loaded(true); + } opna_set_mask(&g.opna, mask); - if (g.drum_rom) opna_drum_set_rom(&g.opna.drum, g.drum_rom); - opna_adpcm_set_ram_256k(&g.opna.adpcm, g.opna_adpcm_ram); - opna_timer_reset(&g.opna_timer, &g.opna); - ppz8_init(&g.ppz8, SRATE, PPZ8MIX); - ZeroMemory(&g.work, sizeof(g.work)); - g.work.opna_writereg = opna_writereg_libopna; - g.work.opna_readreg = opna_readreg_libopna; - g.work.opna_status = opna_status_libopna; - g.work.opna = &g.opna_timer; - g.work.ppz8 = &g.ppz8; - g.work.ppz8_functbl = &ppz8_functbl; WideCharToMultiByte(932, WC_NO_BEST_FIT_CHARS, path, -1, g.work.filename, sizeof(g.work.filename), 0, 0); - opna_timer_set_int_callback(&g.opna_timer, opna_int_cb, &g.work); - opna_timer_set_mix_callback(&g.opna_timer, opna_mix_cb, &g.ppz8); - fmplayer_file_load(&g.work, g.fmfile); + fmplayer_file_load(&g.work, g.fmfile, 1); if (!g.sound) { g.sound = sound_init(hwnd, SRATE, SECTLEN, sound_cb, &g.opna_timer); - SetWindowText(g.driverinfo, g.sound->apiname); about_setsoundapiname(g.sound->apiname); } fmdsp_vram_init(&g.fmdsp, &g.work, g.vram); @@ -516,14 +446,14 @@ static bool on_create(HWND hwnd, CREATESTRUCT *cs) { 50, 25, hwnd, (HMENU)ID_PAUSE, g.hinst, 0 ); - g.driverinfo = CreateWindowEx( + HWND wavesavebutton = CreateWindowEx( 0, - L"STATIC", - L"", - WS_VISIBLE | WS_CHILD, - 110, 15, + L"BUTTON", + L"&Wave output", + WS_TABSTOP | WS_VISIBLE | WS_CHILD, + 110, 10, 100, 25, - hwnd, 0, g.hinst, 0 + hwnd, (HMENU)ID_WAVESAVE, g.hinst, 0 ); g.button_2x = CreateWindowEx( 0, @@ -564,6 +494,7 @@ static bool on_create(HWND hwnd, CREATESTRUCT *cs) { g.btn_defproc = (WNDPROC)GetWindowLongPtr(button, GWLP_WNDPROC); SetWindowLongPtr(button, GWLP_WNDPROC, (intptr_t)btn_wndproc); SetWindowLongPtr(pbutton, GWLP_WNDPROC, (intptr_t)btn_wndproc); + SetWindowLongPtr(wavesavebutton, GWLP_WNDPROC, (intptr_t)btn_wndproc); SetWindowLongPtr(g.button_2x, GWLP_WNDPROC, (intptr_t)btn_wndproc); SetWindowLongPtr(g.button_toneview, GWLP_WNDPROC, (intptr_t)btn_wndproc); SetWindowLongPtr(g.button_oscilloview, GWLP_WNDPROC, (intptr_t)btn_wndproc); @@ -574,12 +505,11 @@ static bool on_create(HWND hwnd, CREATESTRUCT *cs) { HFONT font = CreateFontIndirect(&ncm.lfMessageFont); SetWindowFont(button, font, TRUE); SetWindowFont(pbutton, font, TRUE); - SetWindowFont(g.driverinfo, font, TRUE); + SetWindowFont(wavesavebutton, font, TRUE); SetWindowFont(g.button_2x, font, TRUE); SetWindowFont(g.button_toneview, font, TRUE); SetWindowFont(g.button_oscilloview, font, TRUE); SetWindowFont(g.button_about, font, TRUE); - loadrom(); loadfont(); fmdsp_init(&g.fmdsp, g.font_loaded ? &g.font : 0); fmdsp_vram_init(&g.fmdsp, &g.work, g.vram); @@ -658,6 +588,17 @@ static void on_command(HWND hwnd, int id, HWND hwnd_c, UINT code) { Button_SetCheck(g.button_about, false); } break; + case ID_WAVESAVE: + { + if (g.lastopenpath) { + wchar_t *path = wcsdup(g.lastopenpath); + if (path) { + wavesave_dialog(hwnd, path); + free(path); + } + } + } + break; } } @@ -666,7 +607,6 @@ static void on_destroy(HWND hwnd) { timeKillEvent(g.mmtimer); if (g.sound) g.sound->free(g.sound); fmplayer_file_free(g.fmfile); - if (g.drum_rom) HeapFree(g.heap, 0, g.drum_rom); PostQuitMessage(0); } diff --git a/win32/wavesave.c b/win32/wavesave.c new file mode 100644 index 0000000..cb12f2a --- /dev/null +++ b/win32/wavesave.c @@ -0,0 +1,210 @@ +#include "wavesave.h" +#include +#include +#include "common/fmplayer_file.h" +#include "common/fmplayer_common.h" +#include "libopna/opnatimer.h" +#include "libopna/opna.h" +#include "wavewrite.h" +#include +#include +#include + +enum { + SRATE = 55467, + LOOPCNT = 2, +}; + +static struct { + ATOM class; +} g; + +struct fadeout { + struct opna_timer *timer; + struct fmdriver_work *work; + uint64_t vol; + uint8_t loopcnt; +}; + +static bool fadeout_mix( + struct fadeout *fadeout, + int16_t *buf, unsigned frames +) { + opna_timer_mix(fadeout->timer, buf, frames); + for (unsigned i = 0; i < frames; i++) { + int vol = fadeout->vol >> 16; + buf[i*2+0] = (buf[i*2+0] * vol) >> 16; + buf[i*2+1] = (buf[i*2+1] * vol) >> 16; + if (fadeout->work->loop_cnt >= fadeout->loopcnt) { + fadeout->vol = (fadeout->vol * 0xffff0000ull) >> 32; + } + } + return fadeout->vol; +} + +struct wavesave_instance { + struct opna opna; + struct opna_timer timer; + struct ppz8 ppz8; + struct fmdriver_work work; + struct fadeout fadeout; + struct fmplayer_file *fmfile; + struct wavefile *wavefile; + HWND wnd; + HWND pbar; + int ppos; + HANDLE thread; + DWORD th_exit; + uint8_t adpcm_ram[OPNA_ADPCM_RAM_SIZE]; +}; + +static DWORD CALLBACK thread_write(void *ptr) { + struct wavesave_instance *inst = ptr; + enum { + BUFLEN = 1024, + }; + int16_t buf[BUFLEN*2]; + for (;;) { + if (inst->th_exit) return 0; + memset(buf, 0, sizeof(buf)); + bool end = !fadeout_mix(&inst->fadeout, buf, BUFLEN); + if (wavewrite_write(inst->wavefile, buf, BUFLEN) != BUFLEN) { + break; + } + int newpos = 100 * inst->work.timerb_cnt / inst->work.loop_timerb_cnt; + if (newpos != inst->ppos) { + inst->ppos = newpos; + PostMessage(inst->pbar, PBM_SETPOS, newpos, 0); + } + /* + double newfrac = (double)data->work.timerb_cnt / data->work.loop_timerb_cnt; + if ((newfrac - data->fraction) > 0.005) { + data->fraction = newfrac; + g_idle_add(idle_progress_fraction, ptr); + } + */ + if (end) break; + } + PostMessage(inst->wnd, WM_USER, 0, 0); + return 0; +} + +static void wavesave(HWND parent, + struct fmplayer_file *fmfile, + const wchar_t *savepath) { + struct wavefile *wavefile = 0; + struct wavesave_instance *inst = 0; + wavefile = wavewrite_open_w(savepath, SRATE); + if (!wavefile) { + MessageBox(parent, L"Cannot open output wave file", L"Error", MB_ICONSTOP); + goto err; + } + inst = malloc(sizeof(*inst)); + if (!inst) { + MessageBox(parent, L"Cannot allocate memory", L"Error", MB_ICONSTOP); + goto err; + } + *inst = (struct wavesave_instance){0}; + fmplayer_init_work_opna(&inst->work, &inst->ppz8, &inst->opna, &inst->timer, inst->adpcm_ram); + fmplayer_file_load(&inst->work, fmfile, LOOPCNT); + inst->fadeout.timer = &inst->timer; + inst->fadeout.work = &inst->work; + inst->fadeout.vol = 1ull<<32; + inst->fadeout.loopcnt = LOOPCNT; + inst->fmfile = fmfile; + inst->wavefile = wavefile; + CreateWindow(MAKEINTATOM(g.class), + L"Progress", + WS_CAPTION | WS_SYSMENU, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + parent, 0, GetModuleHandle(0), inst); + return; +err: + if (wavefile) wavewrite_close(wavefile); + free(inst); +} + +static bool on_create(HWND hwnd, const CREATESTRUCT *cs) { + struct wavesave_instance *inst = cs->lpCreateParams; + SetWindowLongPtr(hwnd, GWLP_USERDATA, (intptr_t)inst); + inst->wnd = hwnd; + RECT wr = { + .left = 0, + .top = 0, + .right = 200, + .bottom = 100, + }; + DWORD style = GetWindowLongPtr(hwnd, GWL_STYLE); + DWORD exstyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE); + AdjustWindowRectEx(&wr, style, 0, exstyle); + SetWindowPos(hwnd, HWND_TOP, 0, 0, wr.right-wr.left, wr.bottom-wr.top, + SWP_NOZORDER | SWP_NOMOVE); + + inst->pbar = CreateWindow(PROGRESS_CLASS, 0, + WS_CHILD | WS_VISIBLE, + 10, 10, 180, 15, + hwnd, 0, cs->hInstance, 0); + + ShowWindow(hwnd, SW_SHOW); + inst->thread = CreateThread(0, 0, thread_write, inst, 0, 0); + return true; +} + +static void on_destroy(HWND hwnd) { + struct wavesave_instance *inst = (struct wavesave_instance *)GetWindowLongPtr(hwnd, GWLP_USERDATA); + inst->th_exit = 1; + WaitForSingleObject(inst->thread, INFINITE); + fmplayer_file_free(inst->fmfile); + wavewrite_close(inst->wavefile); + free(inst); +} + +static LRESULT CALLBACK wndproc( + HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam +) { + switch (msg) { + HANDLE_MSG(hwnd, WM_DESTROY, on_destroy); + HANDLE_MSG(hwnd, WM_CREATE, on_create); + case WM_USER: + DestroyWindow(hwnd); + return 0; + } + return DefWindowProc(hwnd, msg, wParam, lParam); +} + +void wavesave_dialog(HWND parent, const wchar_t *fmpath) { + HINSTANCE hinst = GetModuleHandle(0); + if (!g.class) { + WNDCLASS wc = { + .lpfnWndProc = wndproc, + .hInstance = hinst, + .hIcon = LoadIcon(hinst, MAKEINTRESOURCE(1)), + .hCursor = LoadCursor(0, IDC_ARROW), + .hbrBackground = (HBRUSH)(COLOR_BTNFACE+1), + .lpszClassName = L"myon_fmplayer_ym2608_wavesave_progress", + }; + g.class = RegisterClass(&wc); + if (!g.class) { + MessageBox(parent, L"Cannot register wavesave window class", L"Error", MB_ICONSTOP); + return; + } + } + wchar_t path[MAX_PATH] = {0}; + + OPENFILENAME ofn = { + .lStructSize = sizeof(ofn), + .hwndOwner = parent, + .lpstrFilter = L"RIFF WAVE (*.wav)\0" + "*.wav\0\0", + .lpstrFile = path, + .nMaxFile = sizeof(path)/sizeof(path[0]), + .Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY, + }; + if (!GetSaveFileName(&ofn)) return; + struct fmplayer_file *fmfile = fmplayer_file_alloc(fmpath, 0); + if (!fmfile) { + MessageBox(parent, L"Cannot open file", L"Error", MB_ICONSTOP); + return; + } + wavesave(parent, fmfile, path); +} diff --git a/win32/wavesave.h b/win32/wavesave.h new file mode 100644 index 0000000..8769c14 --- /dev/null +++ b/win32/wavesave.h @@ -0,0 +1,9 @@ +#ifndef MYON_FMPLAYER_WIN32_WAVESAVE_H_INCLUDED +#define MYON_FMPLAYER_WIN32_WAVESAVE_H_INCLUDED + +#define WIN32_LEAN_AND_MEAN +#include + +void wavesave_dialog(HWND parent, const wchar_t *fmpath); + +#endif // MYON_FMPLAYER_WIN32_WAVESAVE_H_INCLUDED diff --git a/win32/wavewrite.c b/win32/wavewrite.c new file mode 100644 index 0000000..7c2d6da --- /dev/null +++ b/win32/wavewrite.c @@ -0,0 +1,90 @@ +#include "wavewrite.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include + +struct wavefile { + HANDLE file; + uint32_t written_frames; +}; + +static void write16le(uint8_t *ptr, uint16_t data) { + ptr[0] = data; + ptr[1] = data >> 8; +} + +static void write32le(uint8_t *ptr, uint32_t data) { + ptr[0] = data; + ptr[1] = data >> 8; + ptr[2] = data >> 16; + ptr[3] = data >> 24; +} + +struct wavefile *wavewrite_open_w(const wchar_t *path, uint32_t samplerate) { + struct wavefile *wavefile = 0; + wavefile = malloc(sizeof(*wavefile)); + if (!wavefile) goto err; + *wavefile = (struct wavefile){ + .file = INVALID_HANDLE_VALUE + }; + wavefile->file = CreateFile(path, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); + if (wavefile->file == INVALID_HANDLE_VALUE) goto err; + uint8_t waveheader[44] = {0}; + memcpy(waveheader, "RIFF", 4); + memcpy(waveheader+8, "WAVE", 4); + memcpy(waveheader+12, "fmt ", 4); + write32le(waveheader+16, 16); + write16le(waveheader+20, 1); + write16le(waveheader+22, 2); + write32le(waveheader+24, samplerate); + write32le(waveheader+28, samplerate * 2 * 2); + write16le(waveheader+32, 4); + write16le(waveheader+34, 16); + memcpy(waveheader+36, "data", 4); + DWORD written; + if (!WriteFile(wavefile->file, waveheader, sizeof(waveheader), &written, 0) || (written != sizeof(waveheader))) { + goto err; + } + return wavefile; +err: + if (wavefile) { + if (wavefile->file != INVALID_HANDLE_VALUE) CloseHandle(wavefile->file); + free(wavefile); + } + return 0; +} + +size_t wavewrite_write(struct wavefile *wavefile, const int16_t *buf, size_t frames) { + if (frames >= (1ull<<(32-2))) return 0; + DWORD written; + if (!WriteFile(wavefile->file, buf, frames*4, &written, 0)) { + return 0; + } + uint32_t written_frames = written / 4u; + wavefile->written_frames += written_frames; + return written_frames; +} + +void wavewrite_close(struct wavefile *wavefile) { + LONG fp; + uint32_t size; + DWORD written; + if ((SetFilePointer(wavefile->file, 40, &fp, FILE_BEGIN) == INVALID_SET_FILE_POINTER) || (fp != 40)) { + goto cleanup; + } + size = wavefile->written_frames * 4; + if (!WriteFile(wavefile->file, &size, sizeof(size), &written, 0) || (written != sizeof(size))) { + goto cleanup; + } + if ((SetFilePointer(wavefile->file, 4, &fp, FILE_BEGIN) == INVALID_SET_FILE_POINTER) || (fp != 4)) { + goto cleanup; + } + size += 4 + 8 + 16 + 8; + if (!WriteFile(wavefile->file, &size, sizeof(size), &written, 0) || (written != sizeof(size))) { + goto cleanup; + } +cleanup: + CloseHandle(wavefile->file); + free(wavefile); +} diff --git a/win32/wavewrite.h b/win32/wavewrite.h new file mode 100644 index 0000000..58db0aa --- /dev/null +++ b/win32/wavewrite.h @@ -0,0 +1,15 @@ +#ifndef MYON_FMPLAYER_WIN32_WAVEWRITE_H_INCLUDED +#define MYON_FMPLAYER_WIN32_WAVEWRITE_H_INCLUDED + +#include +#include + +struct wavefile; + +struct wavefile *wavewrite_open_w(const wchar_t *path, uint32_t samplerate); + +size_t wavewrite_write(struct wavefile *wavefile, const int16_t *buf, size_t frames); + +void wavewrite_close(struct wavefile *wavefile); + +#endif // MYON_FMPLAYER_WIN32_WAVEWRITE_H_INCLUDED -- cgit v1.2.3