WavTo1BitTextCpp.cpp

#define NOMINMAX

#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>
#include <mmsystem.h>
#include <shellapi.h>
#include <shlwapi.h>
#include <commctrl.h>
#include <cstdint>
#include <string>
#include <vector>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <regex>

#pragma comment(lib, "Comdlg32.lib")
#pragma comment(lib, "Winmm.lib")
#pragma comment(lib, "Shell32.lib")
#pragma comment(lib, "Shlwapi.lib")
#pragma comment(lib, "Comctl32.lib")

#define APP_TITLE L"WavTo1BitTextCpp"

struct RateOption { const wchar_t* label; int hz; const wchar_t* tValue; };
static const RateOption kRates[] = {
    {L"1960Hz", 1960, L"t0240"}, {L"2205Hz", 2205, L"t0263"}, {L"2756Hz", 2756, L"t0325"},
    {L"3675Hz", 3675, L"t0425"}, {L"4410Hz", 4410, L"t0502"}, {L"5512Hz", 5512, L"t0613"},
    {L"7350Hz", 7350, L"t0788"}, {L"11025Hz", 11025, L"t1103"}, {L"22050Hz", 22050, L"t1838"},
};

enum ControlId {
    IDC_FILE_LIST = 1001, IDC_BTN_ADD, IDC_BTN_CLEAR, IDC_RATE_COMBO, IDC_RAD_JSON, IDC_RAD_TXT,
    IDC_ZERO_EDIT, IDC_ONE_EDIT, IDC_PREFIX_EDIT, IDC_MAX_EDIT, IDC_BTN_CONVERT, IDC_BTN_REFRESH,
    IDC_BTN_PLAY, IDC_BTN_STOP, IDC_PREVIEW_EDIT, IDC_PREVIEW_TARGET, IDC_PREVIEW_STATS, IDC_DROP_INFO,
    IDC_THRESH_EDIT, IDC_RAD_DIFF, IDC_RAD_SIGMADELTA, IDC_DITHER_EDIT,
    IDC_EXPANDED_LIMIT_CHECK, IDC_EXPANDED_LIMIT_EDIT
};

struct EncodedRun { int bit = 0; int count = 0; };
struct WavData { std::vector<float> mono; int sampleRate = 0; };
struct EncodeResult { std::wstring encoded; int usedBudget = 0; int usedTokens = 0; int expandedBits = 0; std::vector<EncodedRun> runs; };
enum class ConvertMode { Difference, SigmaDelta };

static HINSTANCE g_hInst = nullptr;
static HWND g_main = nullptr, g_list = nullptr, g_rate = nullptr, g_zero = nullptr, g_one = nullptr,
            g_prefix = nullptr, g_max = nullptr, g_preview = nullptr, g_target = nullptr, g_stats = nullptr,
            g_radioJson = nullptr, g_radioTxt = nullptr, g_dropInfo = nullptr, g_thresh = nullptr,
            g_radioDiff = nullptr, g_radioSigmaDelta = nullptr, g_dither = nullptr,
            g_expandedLimitCheck = nullptr, g_expandedLimitEdit = nullptr;
struct FileSettings {
    int rateIndex = 8;
    bool jsonOutput = true;
    std::wstring zeroToken = L"r";
    std::wstring oneToken = L"c";
    std::wstring prefix = L"o-5 c%22 l%1";
    float threshold = 0.0f;
    ConvertMode convertMode = ConvertMode::Difference;
    float ditherAmount = 0.0f;
    bool expandedLimitEnabled = false;
    int expandedBitLimit = 3840;
};

struct FileEntry {
    std::wstring path;
    FileSettings settings;
};

struct PreparedFile {
    bool ok = false;
    std::wstring error;
    int srcRate = 0;
    std::vector<int> bits;
    EncodeResult enc;
    std::wstring finalText;
};

static std::vector<FileEntry> g_files;
static int g_loadedFileIndex = -1;
static bool g_isInitializingControls = false;
static std::wstring g_tempPlayFile;


// Wavetable 29897 - INITIAL SETTING 6 29891
// BEEP      30716 - INITIAL SETTING 6 30710
#define	__MAX_ELEMENTS	29891

static std::wstring GetWindowTextString(HWND h){ int len=GetWindowTextLengthW(h); std::wstring s(len,L'\0'); GetWindowTextW(h,s.data(),len+1); return s; }
static void SetControlText(HWND h,const std::wstring& s){ SetWindowTextW(h,s.c_str()); }
static int GetMaxElements(){ int v=_wtoi(GetWindowTextString(g_max).c_str()); return v>0?v:__MAX_ELEMENTS; }
static float NormalizeUnitFloat(float v){ if(v<0.0f) v=-v; return (v>1.0f)?1.0f:v; }
static int NormalizePositiveInt(int v,int fallback){ return v>0 ? v : fallback; }
static const wchar_t* GetConvertModeLabel(ConvertMode mode){ return mode==ConvertMode::SigmaDelta ? L"シグマ・デルタ変調" : L"差分しきい値"; }

static FileSettings MakeDefaultFileSettings(){ return FileSettings{}; }

static bool AreSettingControlsReady()
{
    return g_rate &&
           g_zero &&
           g_one &&
           g_prefix &&
           g_max &&
           g_radioJson &&
           g_radioTxt &&
           g_radioDiff &&
           g_radioSigmaDelta &&
           g_thresh &&
           g_dither &&
           g_expandedLimitCheck &&
           g_expandedLimitEdit;
}

static void UpdatePreview();

static FileSettings ReadSettingsFromControls(){
    FileSettings s = MakeDefaultFileSettings();
    if(!AreSettingControlsReady()) return s;
    int idx=ComboBox_GetCurSel(g_rate); s.rateIndex = idx<0 ? 4 : idx;
    s.jsonOutput = Button_GetCheck(g_radioJson)==BST_CHECKED;
    s.zeroToken = GetWindowTextString(g_zero);
    s.oneToken = GetWindowTextString(g_one);
    s.prefix = GetWindowTextString(g_prefix);
    s.threshold = NormalizeUnitFloat((float)_wtof(GetWindowTextString(g_thresh).c_str()));
    s.convertMode = Button_GetCheck(g_radioSigmaDelta)==BST_CHECKED ? ConvertMode::SigmaDelta : ConvertMode::Difference;
    s.ditherAmount = NormalizeUnitFloat((float)_wtof(GetWindowTextString(g_dither).c_str()));
    s.expandedLimitEnabled = Button_GetCheck(g_expandedLimitCheck)==BST_CHECKED;
    s.expandedBitLimit = NormalizePositiveInt(_wtoi(GetWindowTextString(g_expandedLimitEdit).c_str()), 3840);
    return s;
}

static void ApplySettingsToControls(const FileSettings& s){
    if(!AreSettingControlsReady()) return;
    g_isInitializingControls = true;
    ComboBox_SetCurSel(g_rate, (s.rateIndex>=0 && s.rateIndex<(int)(sizeof(kRates)/sizeof(kRates[0]))) ? s.rateIndex : 4);
    Button_SetCheck(g_radioJson, s.jsonOutput ? BST_CHECKED : BST_UNCHECKED);
    Button_SetCheck(g_radioTxt, s.jsonOutput ? BST_UNCHECKED : BST_CHECKED);
    SetControlText(g_zero, s.zeroToken);
    SetControlText(g_one, s.oneToken);
    SetControlText(g_prefix, s.prefix);
    SetControlText(g_thresh, std::to_wstring(NormalizeUnitFloat(s.threshold)));
    Button_SetCheck(g_radioDiff, s.convertMode==ConvertMode::Difference ? BST_CHECKED : BST_UNCHECKED);
    Button_SetCheck(g_radioSigmaDelta, s.convertMode==ConvertMode::SigmaDelta ? BST_CHECKED : BST_UNCHECKED);
    SetControlText(g_dither, std::to_wstring(NormalizeUnitFloat(s.ditherAmount)));
    Button_SetCheck(g_expandedLimitCheck, s.expandedLimitEnabled ? BST_CHECKED : BST_UNCHECKED);
    SetControlText(g_expandedLimitEdit, std::to_wstring(NormalizePositiveInt(s.expandedBitLimit, 3840)));
    EnableWindow(g_expandedLimitEdit, s.expandedLimitEnabled ? TRUE : FALSE);
    g_isInitializingControls = false;
}

static int GetRateHz(const FileSettings& s){ int idx=(s.rateIndex>=0 && s.rateIndex<(int)(sizeof(kRates)/sizeof(kRates[0]))) ? s.rateIndex : 4; return kRates[idx].hz; }
static const wchar_t* GetRateT(const FileSettings& s){ int idx=(s.rateIndex>=0 && s.rateIndex<(int)(sizeof(kRates)/sizeof(kRates[0]))) ? s.rateIndex : 4; return kRates[idx].tValue; }

static int GetSelectedFileIndex(){ int sel=ListBox_GetCurSel(g_list); return (sel==LB_ERR||sel<0||sel>=(int)g_files.size()) ? -1 : sel; }
static FileEntry* GetFileEntryByIndex(int index){ return (index>=0 && index<(int)g_files.size()) ? &g_files[index] : nullptr; }
static const FileEntry* GetFileEntryByIndexConst(int index){ return (index>=0 && index<(int)g_files.size()) ? &g_files[index] : nullptr; }
static FileEntry* GetSelectedFileEntry(){ return GetFileEntryByIndex(GetSelectedFileIndex()); }
static const FileEntry* GetSelectedFileEntryConst(){ return GetFileEntryByIndexConst(GetSelectedFileIndex()); }
static void SaveLoadedFileSettingsFromControls(){ if(g_isInitializingControls || !AreSettingControlsReady()) return; if(auto* entry=GetFileEntryByIndex(g_loadedFileIndex)) entry->settings = ReadSettingsFromControls(); }
static void SaveSelectedFileSettingsFromControls(){ if(g_isInitializingControls || !AreSettingControlsReady()) return; if(auto* entry=GetSelectedFileEntry()) entry->settings = ReadSettingsFromControls(); }
static void LoadSelectedFileSettingsToControls(){ if(!AreSettingControlsReady()) return; if(const auto* entry=GetSelectedFileEntryConst()) ApplySettingsToControls(entry->settings); else ApplySettingsToControls(MakeDefaultFileSettings()); g_loadedFileIndex = GetSelectedFileIndex(); }
static void OnSelectedFileChanged(){ SaveLoadedFileSettingsFromControls(); LoadSelectedFileSettingsToControls(); }


static HFONT g_font = nullptr;

BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM)
{
    if (g_font) {
        SendMessageW(hwnd, WM_SETFONT, (WPARAM)g_font, TRUE);
    }
    return TRUE;
}

static std::wstring JsonEscape(const std::wstring& s){
    std::wstring out;
    for (wchar_t c: s){
        switch(c){ case L'\\': out+=L"\\\\"; break; case L'"': out+=L"\\\""; break; case L'\n': out+=L"\\n"; break; case L'\t': out+=L"\\t"; break; case L'\r': break; default: out+=c; break; }
    }
    return out;
}
static std::wstring GetFileStem(const std::wstring& path){ wchar_t fname[_MAX_FNAME]={}; _wsplitpath_s(path.c_str(),nullptr,0,nullptr,0,fname,_MAX_FNAME,nullptr,0); return fname; }
static std::wstring ChangeExtension(const std::wstring& path,const wchar_t* ext){ wchar_t drive[_MAX_DRIVE]={},dir[_MAX_DIR]={},fname[_MAX_FNAME]={},buf[MAX_PATH]={}; _wsplitpath_s(path.c_str(),drive,_MAX_DRIVE,dir,_MAX_DIR,fname,_MAX_FNAME,nullptr,0); _wmakepath_s(buf,drive,dir,fname,ext); return buf; }
static bool Exists(const std::wstring& p){ return PathFileExistsW(p.c_str())==TRUE; }

static std::wstring SuggestOutputPath(const std::wstring& inputPath,const wchar_t* ext){
    std::wstring base=ChangeExtension(inputPath,ext); if(!Exists(base)) return base;
    wchar_t drive[_MAX_DRIVE]={},dir[_MAX_DIR]={},fname[_MAX_FNAME]={};
    _wsplitpath_s(base.c_str(),drive,_MAX_DRIVE,dir,_MAX_DIR,fname,_MAX_FNAME,nullptr,0);
    std::wstring stem=fname, root=stem; int startNum=1;
    std::wregex re(LR"(^(.*)\((\d+)\)$)"); std::wsmatch m;
    if(std::regex_match(stem,m,re)){ root=m[1].str(); startNum=_wtoi(m[2].str().c_str())+1; }
    for(int i=startNum;;++i){ std::wstringstream ss; ss<<drive<<dir<<root<<L"("<<i<<L")"<<ext; if(!Exists(ss.str())) return ss.str(); }
}

static bool ReadEntireFile(const std::wstring& path,std::vector<uint8_t>& out){
    std::ifstream f(path, std::ios::binary); if(!f) return false;
    f.seekg(0,std::ios::end); size_t size=(size_t)f.tellg(); f.seekg(0,std::ios::beg);
    out.resize(size); if(size) f.read((char*)out.data(), size); return true;
}
static uint16_t ReadLE16(const uint8_t* p){ return uint16_t(p[0]|(p[1]<<8)); }
static uint32_t ReadLE32(const uint8_t* p){ return uint32_t(p[0]|(p[1]<<8)|(p[2]<<16)|(p[3]<<24)); }
static int32_t ReadLE24Signed(const uint8_t* p){ int32_t v=(p[0]|(p[1]<<8)|(p[2]<<16)); if(v&0x800000) v|=~0xFFFFFF; return v; }

static bool LoadWav(const std::wstring& path,WavData& out,std::wstring& err){
    std::vector<uint8_t> data; if(!ReadEntireFile(path,data)){ err=L"ファイルを読めません。"; return false; }
    if(data.size()<44 || memcmp(data.data(),"RIFF",4)!=0 || memcmp(data.data()+8,"WAVE",4)!=0){ err=L"有効な WAV ではありません。"; return false; }
    size_t pos=12; uint16_t audioFormat=0,channels=0,bitsPerSample=0; uint32_t sampleRate=0; const uint8_t* pcm=nullptr; uint32_t pcmSize=0;
    while(pos+8<=data.size()){
        const uint8_t* chunk=data.data()+pos; uint32_t size=ReadLE32(chunk+4); if(pos+8+size>data.size()) break;
        if(memcmp(chunk,"fmt ",4)==0 && size>=16){ audioFormat=ReadLE16(chunk+8); channels=ReadLE16(chunk+10); sampleRate=ReadLE32(chunk+12); bitsPerSample=ReadLE16(chunk+22); }
        else if(memcmp(chunk,"data",4)==0){ pcm=chunk+8; pcmSize=size; }
        pos += 8 + size + (size & 1);
    }
    if(!pcm || !sampleRate || !channels || !bitsPerSample){ err=L"WAV の解析に失敗しました。"; return false; }
    if(audioFormat!=1){ err=L"PCM 形式のみ対応です。"; return false; }
    if(!(bitsPerSample==8||bitsPerSample==16||bitsPerSample==24||bitsPerSample==32)){ err=L"8/16/24/32bit PCM のみ対応です。"; return false; }

    int bps=bitsPerSample/8; size_t frames=pcmSize/(bps*channels); out.mono.reserve(frames);
    for(size_t i=0;i<frames;++i){
        double sum=0.0;
        for(int ch=0; ch<channels; ++ch){
            const uint8_t* p=pcm+(i*channels+ch)*bps; float v=0.0f;
            if(bitsPerSample==8) v=float(int(*p)-128)/128.0f;
            else if(bitsPerSample==16) v=float((int16_t)ReadLE16(p))/32768.0f;
            else if(bitsPerSample==24) v=float(ReadLE24Signed(p))/8388608.0f;
            else if(bitsPerSample==32) v=float((int32_t)ReadLE32(p))/2147483648.0f;
            sum += v;
        }
        out.mono.push_back((float)(sum/channels));
    }
    out.sampleRate=(int)sampleRate; return true;
}

static std::vector<float> ResampleLinear(const std::vector<float>& in,int srcRate,int dstRate){
    if(in.empty()) return {}; int dstLen=std::max(1, (int)std::llround( (double)in.size() * dstRate / srcRate));
    if(in.size()==1) return std::vector<float>(dstLen,in[0]);
    std::vector<float> out; out.reserve(dstLen);
    for(int i=0;i<dstLen;++i){ double pos=double(i)*(in.size()-1)/std::max(1,dstLen-1); size_t j=(size_t)std::floor(pos); double frac=pos-j; float v=(j>=in.size()-1)?in.back():float(in[j]*(1.0-frac)+in[j+1]*frac); out.push_back(v); }
    return out;
}

static uint32_t HashWideString(const std::wstring& s){
    uint32_t h=2166136261u;
    for(wchar_t c : s){ h ^= (uint32_t)c; h *= 16777619u; }
    return h ? h : 1u;
}

static float NextRandomSigned(uint32_t& state){
    state = state * 1664525u + 1013904223u;
    float a = float((state >> 8) & 0x00FFFFFF) / float(0x01000000);
    state = state * 1664525u + 1013904223u;
    float b = float((state >> 8) & 0x00FFFFFF) / float(0x01000000);
    return (a + b) - 1.0f; // TPDF [-1, +1]
}

static std::vector<float> BuildDitheredSamples(const std::vector<float>& src,float ditherAmount,uint32_t seed){
    if(ditherAmount<=0.0f) return src;
    std::vector<float> out; out.reserve(src.size());
    uint32_t state = seed;
    for(float v : src){
        float dv = v + NextRandomSigned(state) * ditherAmount;
        out.push_back(std::clamp(dv, -1.0f, 1.0f));
    }
    return out;
}

static bool BuildBits(const std::wstring& path,const FileSettings& settings,std::vector<int>& bits,int& srcRate,std::wstring& err){
    WavData wav; if(!LoadWav(path,wav,err)) return false; srcRate=wav.sampleRate;
    const int outputRate = GetRateHz(settings);
    auto rs=ResampleLinear(wav.mono,wav.sampleRate,outputRate);
    auto proc=BuildDitheredSamples(rs,NormalizeUnitFloat(settings.ditherAmount),HashWideString(path) ^ (uint32_t(outputRate) * 2654435761u));
    bits.resize(proc.size());

    if(settings.convertMode==ConvertMode::SigmaDelta){
        double integrator=0.0;
        double feedback=-1.0;
        for(size_t i=0;i<proc.size();++i){
            double input=std::clamp((double)proc[i], -1.0, 1.0);
            integrator += input - feedback;
            bits[i] = (integrator >= 0.0) ? 1 : 0;
            feedback = bits[i] ? 1.0 : -1.0;
        }
        return true;
    }

    const float threshold = NormalizeUnitFloat(settings.threshold);
    for(size_t i=0;i<proc.size();++i)
    {
      auto sr = proc[i];
      if( i == 0 )
      {
        bits[i] = proc[i]>0.0f?1:0;
      }
      else
      {
        sr = proc[i-1] - sr;
        if( std::abs(sr)>threshold )
        {
          bits[i] = sr>0.0f?1:0;
        }
        else
        {
          bits[i] = bits[i-1];
        }
      }
    }
    return true;
}

static EncodeResult EncodeBits(const std::vector<int>& bits,const FileSettings& settings,int maxBudget){
    EncodeResult r; if(bits.empty()) return r;
    auto makeToken=[&](int bit,int count){ std::wstring tok=bit?settings.oneToken:settings.zeroToken; if(count!=1){ tok+=L"%"; tok+=std::to_wstring(count);} return tok; };

    std::vector<EncodedRun> srcRuns;
    {
        int current=bits[0], count=1;
        for(size_t i=1;i<bits.size();++i){
            if(bits[i]==current) count++;
            else{
                srcRuns.push_back({current,count});
                current=bits[i];
                count=1;
            }
        }
        srcRuns.push_back({current,count});
    }

    std::vector<EncodedRun> outRuns;
    const int tokenCost = 2;
    int budget = 0;
    const int allowedBudget = std::max(0, maxBudget);
    for(const auto& run : srcRuns){
        if(budget + tokenCost > allowedBudget) break;
        outRuns.push_back(run);
        budget += tokenCost;
    }

    if(settings.expandedLimitEnabled){
        const int targetBits = NormalizePositiveInt(settings.expandedBitLimit, 3840);
        int sumBits = 0;
        std::vector<EncodedRun> limitedRuns;
        limitedRuns.reserve(outRuns.size() + 1);

        for(const auto& run : outRuns){
            if(sumBits >= targetBits) break;
            if(sumBits + run.count <= targetBits){
                limitedRuns.push_back(run);
                sumBits += run.count;
            }else{
                int remain = targetBits - sumBits;
                if(remain > 0){
                    limitedRuns.push_back({run.bit, remain});
                    sumBits += remain;
                }
                break;
            }
        }

        if(sumBits < targetBits){
            int pad = targetBits - sumBits;
            if(!limitedRuns.empty() && limitedRuns.back().bit == 0){
                limitedRuns.back().count += pad;
            }else if(!limitedRuns.empty() && budget + tokenCost <= allowedBudget){
                limitedRuns.push_back({0, pad});
                budget += tokenCost;
            }else if(limitedRuns.empty() && allowedBudget >= tokenCost){
                limitedRuns.push_back({0, pad});
                budget = tokenCost;
            }else if(!limitedRuns.empty()){
                if(limitedRuns.size() == 1){
                    limitedRuns[0] = {0, targetBits};
                }else{
                    int preserved = 0;
                    for(size_t i=0;i+1<limitedRuns.size();++i) preserved += limitedRuns[i].count;
                    int tail = std::max(0, targetBits - preserved);
                    limitedRuns.back() = {0, tail};
                }
            }
            sumBits = targetBits;
        }

        outRuns.swap(limitedRuns);
    }

    r.runs = outRuns;
    for(const auto& run : outRuns){
        r.encoded += makeToken(run.bit, run.count);
        r.usedBudget += tokenCost;
        r.usedTokens += 1;
        r.expandedBits += run.count;
    }
    return r;
}

static std::wstring BuildFinalText(const std::wstring& inputPath,const EncodeResult& enc,const FileSettings& settings){
    std::wstring track = settings.prefix.empty() ? (std::wstring(GetRateT(settings)) + enc.encoded) : (settings.prefix + L" " + GetRateT(settings) + enc.encoded);
    if(!settings.jsonOutput) return track;
    std::wstring name=GetFileStem(inputPath);
    return L"{\"name\":\""+JsonEscape(name)+L"\",\"tracks\":[\""+JsonEscape(track)+L"\"]}";
}

static bool WriteUtf8File(const std::wstring& path,const std::wstring& text){
    int bytes=WideCharToMultiByte(CP_UTF8,0,text.c_str(),(int)text.size(),nullptr,0,nullptr,nullptr);
    std::string utf8(bytes,'\0'); WideCharToMultiByte(CP_UTF8,0,text.c_str(),(int)text.size(),utf8.data(),bytes,nullptr,nullptr);
    std::ofstream f(path,std::ios::binary); if(!f) return false; f.write(utf8.data(), utf8.size()); return true;
}

static std::vector<int> ExpandRuns(const std::vector<EncodedRun>& runs){
    std::vector<int> out;
    size_t total = 0;
    for(const auto& run : runs) total += std::max(0, run.count);
    out.reserve(total);
    for(const auto& run : runs){
        for(int i=0;i<run.count;++i) out.push_back(run.bit ? 1 : 0);
    }
    return out;
}

static bool Save16BitMonoWav(const std::wstring& path,const std::vector<int>& bits,int rate){
    std::ofstream f(path,std::ios::binary); if(!f) return false; uint32_t dataSize=(uint32_t)(bits.size()*2), riffSize=36+dataSize;
    auto w16=[&](uint16_t v){ f.put((char)(v&0xFF)); f.put((char)((v>>8)&0xFF)); };
    auto w32=[&](uint32_t v){ f.put((char)(v&0xFF)); f.put((char)((v>>8)&0xFF)); f.put((char)((v>>16)&0xFF)); f.put((char)((v>>24)&0xFF)); };
    f.write("RIFF",4); w32(riffSize); f.write("WAVE",4); f.write("fmt ",4); w32(16); w16(1); w16(1); w32(rate); w32(rate*2); w16(2); w16(16); f.write("data",4); w32(dataSize);
    for(int b: bits){ int16_t s=b?32767:-32768; w16((uint16_t)s); } return true;
}

static void RefreshFileList(){
    ListBox_ResetContent(g_list);
    for(const auto& f: g_files) ListBox_AddString(g_list,f.path.c_str());
    if(!g_files.empty()&&ListBox_GetCurSel(g_list)==LB_ERR) ListBox_SetCurSel(g_list,0);
}

static void SetPreview(const std::wstring& target,const std::wstring& stats,const std::wstring& body){ SetControlText(g_target,target); SetControlText(g_stats,stats); SetControlText(g_preview,body); }

static bool PrepareFileAtIndex(int index,int budgetLimit,PreparedFile& out){
    if(index<0 || index>=(int)g_files.size()){ out.ok=false; out.error=L"対象ファイルがありません。"; return false; }
    const auto& entry = g_files[index];
    std::wstring err;
    if(entry.settings.zeroToken.empty() || entry.settings.oneToken.empty()){
        out.ok = false;
        out.error = L"0/1 の出力文字列は空にできません。";
        return false;
    }
    if(!BuildBits(entry.path, entry.settings, out.bits, out.srcRate, err)){
        out.ok = false;
        out.error = err;
        return false;
    }
    out.enc = EncodeBits(out.bits, entry.settings, budgetLimit);
    out.finalText = BuildFinalText(entry.path, out.enc, entry.settings);
    out.ok = true;
    return true;
}

static bool PrepareSelectedFileUsingSharedBudget(PreparedFile& out,int* remainingBudgetAfter=nullptr,int* remainingBudgetBefore=nullptr){
    int sel = GetSelectedFileIndex();
    if(sel<0){ out.ok=false; out.error=L""; return false; }
    int remaining = GetMaxElements();
    for(int i=0;i<=sel;++i){
        PreparedFile cur;
        if(!PrepareFileAtIndex(i, remaining, cur)){
            out = cur;
            return false;
        }
        if(i==sel){
            if(remainingBudgetBefore) *remainingBudgetBefore = remaining;
            remaining = std::max(0, remaining - cur.enc.usedBudget);
            if(remainingBudgetAfter) *remainingBudgetAfter = remaining;
            out = cur;
            return true;
        }
        remaining = std::max(0, remaining - cur.enc.usedBudget);
    }
    out.ok=false;
    out.error=L"";
    return false;
}

static void AddFiles(const std::vector<std::wstring>& files){
    std::wstring invalid;
    std::wstring limitMessage;
    for(auto& f: files){
        WavData tmp; std::wstring err;
        if(!LoadWav(f,tmp,err)){ invalid += PathFindFileNameW(f.c_str()); invalid += L" : "; invalid += err; invalid += L"\r\n"; continue; }
        auto it = std::find_if(g_files.begin(), g_files.end(), [&](const FileEntry& e){ return e.path == f; });
        if(it != g_files.end()) continue;
        if(g_files.size() >= 7){
            if(limitMessage.empty()) limitMessage = L"登録できる WAV ファイルは最大 7 つまでです。";
            continue;
        }
        FileEntry entry;
        entry.path = f;
        entry.settings = MakeDefaultFileSettings();
        g_files.push_back(entry);
    }
    RefreshFileList();
    if(g_loadedFileIndex < 0 && !g_files.empty()){
        ListBox_SetCurSel(g_list, 0);
        LoadSelectedFileSettingsToControls();
        UpdatePreview();
    }
    if(!limitMessage.empty()) MessageBoxW(g_main, limitMessage.c_str(), APP_TITLE, MB_ICONWARNING);
    if(!invalid.empty()) MessageBoxW(g_main, invalid.c_str(), APP_TITLE, MB_ICONWARNING);
}

static std::wstring GetSelectedFile(){ const auto* entry = GetSelectedFileEntryConst(); return entry ? entry->path : L""; }

static void UpdatePreview(){
    if(GetSelectedFileIndex() < 0){ LoadSelectedFileSettingsToControls(); SetPreview(L"対象: なし",L"",L""); return; }
    const auto* entry = GetSelectedFileEntryConst();
    if(!entry){ SetPreview(L"対象: なし",L"",L""); return; }

    if(entry->settings.zeroToken.empty() || entry->settings.oneToken.empty()){
        SetPreview(L"対象: "+GetFileStem(entry->path), L"0/1 の出力文字列は空にできません。", L"");
        return;
    }

    PreparedFile prepared;
    int remainingBefore = 0, remainingAfter = 0;
    if(!PrepareSelectedFileUsingSharedBudget(prepared, &remainingAfter, &remainingBefore)){
        SetPreview(L"対象: "+GetFileStem(entry->path), L"プレビュー生成中にエラー", prepared.error);
        return;
    }

    std::wstringstream ss;
    ss<<L"入力 "<<prepared.srcRate<<L" Hz / 出力 "<<GetRateHz(entry->settings)<<L" Hz / 形式 "<<(entry->settings.jsonOutput?L"json":L"txt")
      <<L" / 方式 "<<GetConvertModeLabel(entry->settings.convertMode)<<L" / "<<GetRateT(entry->settings)
      <<L" / 全ビット "<<prepared.bits.size()
      <<L" / 伸長後使用ビット "<<prepared.enc.expandedBits
      <<L" / 出力トークン "<<prepared.enc.usedTokens
      <<L" / このファイルの消費 "<<prepared.enc.usedBudget
      <<L" / 全体残量 "<<remainingAfter<<L"/"<<GetMaxElements()
      <<L" / ディザ量 "<<NormalizeUnitFloat(entry->settings.ditherAmount);
    if(entry->settings.convertMode==ConvertMode::Difference) ss<<L" / 閾値 "<<NormalizeUnitFloat(entry->settings.threshold);
    if(entry->settings.expandedLimitEnabled) ss<<L" / 伸長後使用ビット上限 "<<NormalizePositiveInt(entry->settings.expandedBitLimit, 3840);
    if(prepared.enc.usedBudget < remainingBefore && prepared.enc.expandedBits < (int)prepared.bits.size()) ss<<L" / 制限で切り詰め";

    SetPreview(L"対象: "+GetFileStem(entry->path), ss.str(), prepared.finalText);
}
static void Layout(HWND h){
    RECT rc; GetClientRect(h,&rc); const int m=12, top=70, leftW=430, gap=12; int rightX=m+leftW+gap, rightW=(std::max<int>)(100,rc.right - rightX-m), leftH=rc.bottom-top-m;
    MoveWindow(GetDlgItem(h,2001), m, top, leftW, 220, TRUE);
#define	__WINDOW_OFFSET (-80)
    MoveWindow(GetDlgItem(h,2002), m, top+230, leftW, 470 + __WINDOW_OFFSET, TRUE);
    MoveWindow(GetDlgItem(h,2004), rightX, top, rightW, leftH, TRUE);

    MoveWindow(GetDlgItem(h,IDC_BTN_ADD), 22, top+22, 100, 24, TRUE); MoveWindow(GetDlgItem(h,IDC_BTN_CLEAR), 130, top+22, 100, 24, TRUE);
    MoveWindow(g_dropInfo, 22, top+52, leftW-20, 18, TRUE); MoveWindow(g_list, 22, top+74, leftW-20, 130, TRUE);

    int baseX=m, baseY=top+230, y=22;
    auto ML=[&](int id,int x,int yy,int w=120,int hh=20){ MoveWindow(GetDlgItem(h,id), baseX+x, baseY+yy, w, hh, TRUE); };
    ML(3001,10,y); MoveWindow(g_rate, baseX+130, baseY+y-2, 100, 200, TRUE); ML(3002,240,y,150,20); y+=34;
    ML(3003,10,y); MoveWindow(g_radioJson, baseX+130, baseY+y-2, 70, 20, TRUE); MoveWindow(g_radioTxt, baseX+210, baseY+y-2, 60, 20, TRUE); y+=34;
    ML(3004,10,y); MoveWindow(g_zero, baseX+130, baseY+y-2, 90, 24, TRUE); y+=34;
    ML(3005,10,y); MoveWindow(g_one, baseX+130, baseY+y-2, 90, 24, TRUE); y+=34;
    ML(3006,10,y); MoveWindow(g_prefix, baseX+130, baseY+y-2, leftW-150, 24, TRUE); y+=34;
    ML(3007,10,y); MoveWindow(g_max, baseX+130, baseY+y-2, 90, 24, TRUE); ML(3008,230,y,160,20); y+=30;
    ML(3009,10,y); MoveWindow(g_radioDiff, baseX+130, baseY+y-2, 110, 20, TRUE); MoveWindow(g_radioSigmaDelta, baseX+250, baseY+y-2, 150, 20, TRUE); y+=34;
    ML(3016,10,y); MoveWindow(g_thresh, baseX+130, baseY+y-2, 90, 24, TRUE); y+=34;
    ML(3017,10,y); MoveWindow(g_dither, baseX+130, baseY+y-2, 90, 24, TRUE); y+=34;
    MoveWindow(g_expandedLimitCheck, baseX+10, baseY+y, 220, 20, TRUE); MoveWindow(g_expandedLimitEdit, baseX+240, baseY+y-2, 90, 24, TRUE); y+=34;
    for(int i=3010;i<=3015;++i,y+=22) ML(i,10,y,leftW-20,20);
#define	__BTN_OFFSET (640-55)
    MoveWindow(GetDlgItem(h,IDC_BTN_CONVERT), m+20, top + __BTN_OFFSET, 90, 28, TRUE); MoveWindow(GetDlgItem(h,IDC_BTN_REFRESH), m+98+20, top + __BTN_OFFSET, 90, 28, TRUE);
    MoveWindow(GetDlgItem(h,IDC_BTN_PLAY), m+196+20, top + __BTN_OFFSET, 90, 28, TRUE); MoveWindow(GetDlgItem(h,IDC_BTN_STOP), m+294+20, top + __BTN_OFFSET, 90, 28, TRUE);

    MoveWindow(g_target, rightX+10, top+22, rightW-20, 18, TRUE); MoveWindow(g_stats, rightX+10, top+44, rightW-20, 38, TRUE); MoveWindow(g_preview, rightX+10, top+86, rightW-20, leftH-96, TRUE);
}

static void DoConvert(){
    if(g_files.empty()){ MessageBoxW(g_main,L"WAV ファイルを選択してください。",APP_TITLE,MB_ICONWARNING); return; }
    SaveLoadedFileSettingsFromControls();

    for(const auto& entry : g_files){
        if(entry.settings.zeroToken.empty() || entry.settings.oneToken.empty()){
            std::wstring msg = GetFileStem(entry.path) + L" : 0/1 の出力文字列は空にできません。";
            MessageBoxW(g_main,msg.c_str(),APP_TITLE,MB_ICONERROR);
            return;
        }
    }

    int remainingBudget = GetMaxElements();
    for(int index=0; index<(int)g_files.size(); ++index){
        const auto& entry = g_files[index];
        PreparedFile prepared;
        if(!PrepareFileAtIndex(index, remainingBudget, prepared)){ 
            std::wstring msg = GetFileStem(entry.path) + L" : " + prepared.error;
            MessageBoxW(g_main,msg.c_str(),APP_TITLE,MB_ICONERROR);
            continue; 
        }
        remainingBudget = std::max(0, remainingBudget - prepared.enc.usedBudget);

        std::wstring suggest=SuggestOutputPath(entry.path,entry.settings.jsonOutput?L".json":L".txt"); wchar_t buf[MAX_PATH]={}; wcsncpy_s(buf,suggest.c_str(),_TRUNCATE);
        OPENFILENAMEW ofn{}; ofn.lStructSize=sizeof(ofn); ofn.hwndOwner=g_main; ofn.lpstrFile=buf; ofn.nMaxFile=MAX_PATH; ofn.lpstrFilter=entry.settings.jsonOutput?L"JSON Files (*.json)\0*.json\0All Files\0*.*\0":L"Text Files (*.txt)\0*.txt\0All Files\0*.*\0"; ofn.nFilterIndex=1; ofn.Flags=OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST; ofn.lpstrDefExt=entry.settings.jsonOutput?L"json":L"txt";
        if(!GetSaveFileNameW(&ofn)) continue;
        if(!WriteUtf8File(buf,prepared.finalText)) MessageBoxW(g_main,L"保存に失敗しました。",APP_TITLE,MB_ICONERROR);
    }
}

static void StopPlayback(){ PlaySoundW(nullptr,nullptr,0); if(!g_tempPlayFile.empty()){ DeleteFileW(g_tempPlayFile.c_str()); g_tempPlayFile.clear(); } }

static void DoPlay(){
    if(GetSelectedFileIndex() < 0){ MessageBoxW(g_main,L"再生する WAV ファイルを選択してください。",APP_TITLE,MB_ICONWARNING); return; }
    SaveLoadedFileSettingsFromControls();
    const auto* entry = GetSelectedFileEntryConst();
    if(!entry){ MessageBoxW(g_main,L"再生する WAV ファイルを選択してください。",APP_TITLE,MB_ICONWARNING); return; }

    PreparedFile prepared;
    if(!PrepareSelectedFileUsingSharedBudget(prepared)){
        MessageBoxW(g_main,prepared.error.c_str(),APP_TITLE,MB_ICONERROR);
        return;
    }
    std::vector<int> playback=ExpandRuns(prepared.enc.runs);
    if(playback.empty()){ MessageBoxW(g_main,L"再生できるデータがありません。",APP_TITLE,MB_ICONWARNING); return; }

    wchar_t tempPath[MAX_PATH]={}, tempFile[MAX_PATH]={}; GetTempPathW(MAX_PATH,tempPath); GetTempFileNameW(tempPath,L"w1b",0,tempFile); std::wstring wavPath=std::wstring(tempFile)+L".wav"; DeleteFileW(tempFile);
    if(!Save16BitMonoWav(wavPath,playback,GetRateHz(entry->settings))){ MessageBoxW(g_main,L"再生用 WAV を作成できません。",APP_TITLE,MB_ICONERROR); return; }
    StopPlayback(); g_tempPlayFile=wavPath; PlaySoundW(g_tempPlayFile.c_str(),nullptr,SND_FILENAME|SND_ASYNC);
}

static void BrowseFiles(){
    wchar_t buf[32768]={}; OPENFILENAMEW ofn{}; ofn.lStructSize=sizeof(ofn); ofn.hwndOwner=g_main; ofn.lpstrFilter=L"WAV Files (*.wav)\0*.wav\0All Files\0*.*\0"; ofn.lpstrFile=buf; ofn.nMaxFile=32768; ofn.Flags=OFN_ALLOWMULTISELECT|OFN_EXPLORER|OFN_FILEMUSTEXIST;
    if(!GetOpenFileNameW(&ofn)) return;
    std::vector<std::wstring> files; const wchar_t* p=buf; std::wstring dir=p; p+=dir.size()+1;
    if(*p==0) files.push_back(dir); else while(*p){ files.push_back(dir+L"\\"+p); p+=wcslen(p)+1; }
    AddFiles(files);
}

static void RemoveSelectedFile(){
    int sel=GetSelectedFileIndex();
    if(sel<0) return;
    g_files.erase(g_files.begin()+sel);
    RefreshFileList();
    if(sel < (int)g_files.size()) ListBox_SetCurSel(g_list, sel);
    else if(!g_files.empty()) ListBox_SetCurSel(g_list, (int)g_files.size()-1);
    LoadSelectedFileSettingsToControls();
    UpdatePreview();
}


static LRESULT CALLBACK WndProc(HWND h, UINT m, WPARAM w, LPARAM l){
    switch(m){
    case WM_CREATE:{
	    g_font = CreateFontW(
	        -14,                // 
	        0,                  // 
	        0,                  // X
	        0,                  // 
	        FW_NORMAL,          // 
	        FALSE,              // italic
	        FALSE,              // underline
	        FALSE,              // strikeout
	        DEFAULT_CHARSET,
	        OUT_DEFAULT_PRECIS,
	        CLIP_DEFAULT_PRECIS,
	        CLEARTYPE_QUALITY,
	        DEFAULT_PITCH | FF_DONTCARE,
	        L"Segoe UI"
	    );

        DragAcceptFiles(h, TRUE);
        CreateWindowW(L"STATIC",L"WAV を 1bit テキストに変換",WS_CHILD|WS_VISIBLE,12,12,500,20,h,0,g_hInst,0);
        CreateWindowW(L"STATIC",L"入力 WAV と出力周波数を指定すると、内容を .txt または .json で保存します。",WS_CHILD|WS_VISIBLE,12,36,800,20,h,0,g_hInst,0);
        CreateWindowW(L"BUTTON",L"入力 WAV ファイル",WS_CHILD|WS_VISIBLE|BS_GROUPBOX,0,0,0,0,h,(HMENU)2001,g_hInst,0);
        CreateWindowW(L"BUTTON",L"変換設定",WS_CHILD|WS_VISIBLE|BS_GROUPBOX,0,0,0,0,h,(HMENU)2002,g_hInst,0);
        CreateWindowW(L"BUTTON",L"出力プレビュー",WS_CHILD|WS_VISIBLE|BS_GROUPBOX,0,0,0,0,h,(HMENU)2004,g_hInst,0);
        CreateWindowW(L"BUTTON",L"ファイルを選択",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_ADD,g_hInst,0);
        CreateWindowW(L"BUTTON",L"一覧をクリア",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_CLEAR,g_hInst,0);
        g_dropInfo=CreateWindowW(L"STATIC",L"※ 有効な WAV はこのウィンドウへドラッグ＆ドロップでも追加できます。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_DROP_INFO,g_hInst,0);
        g_list=CreateWindowExW(WS_EX_CLIENTEDGE,L"LISTBOX",L"",WS_CHILD|WS_VISIBLE|LBS_NOTIFY|WS_VSCROLL|WS_TABSTOP,0,0,0,0,h,(HMENU)IDC_FILE_LIST,g_hInst,0);

        CreateWindowW(L"STATIC",L"出力周波数",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3001,g_hInst,0);
        g_rate=CreateWindowW(WC_COMBOBOXW,L"",WS_CHILD|WS_VISIBLE|CBS_DROPDOWNLIST|WS_TABSTOP,0,0,0,0,h,(HMENU)IDC_RATE_COMBO,g_hInst,0);
        for(auto& r:kRates) ComboBox_AddString(g_rate,r.label); ComboBox_SetCurSel(g_rate,8);
        CreateWindowW(L"STATIC",L"t値は周波数に連動",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3002,g_hInst,0);
        CreateWindowW(L"STATIC",L"出力形式",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3003,g_hInst,0);
        g_radioJson=CreateWindowW(L"BUTTON",L"json",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON|WS_GROUP,0,0,0,0,h,(HMENU)IDC_RAD_JSON,g_hInst,0);
        g_radioTxt=CreateWindowW(L"BUTTON",L"txt",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,0,0,0,h,(HMENU)IDC_RAD_TXT,g_hInst,0); Button_SetCheck(g_radioJson,BST_CHECKED);
        CreateWindowW(L"STATIC",L"0 の出力文字列",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3004,g_hInst,0); g_zero=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"r",WS_CHILD|WS_VISIBLE|WS_TABSTOP,0,0,0,0,h,(HMENU)IDC_ZERO_EDIT,g_hInst,0);
        CreateWindowW(L"STATIC",L"1 の出力文字列",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3005,g_hInst,0); g_one=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"c",WS_CHILD|WS_VISIBLE|WS_TABSTOP,0,0,0,0,h,(HMENU)IDC_ONE_EDIT,g_hInst,0);
        CreateWindowW(L"STATIC",L"追加する文字列",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3006,g_hInst,0); g_prefix=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"o-5 c%22 l%1",WS_CHILD|WS_VISIBLE|WS_TABSTOP|ES_AUTOHSCROLL,0,0,0,0,h,(HMENU)IDC_PREFIX_EDIT,g_hInst,0);
        CreateWindowW(L"STATIC",L"出力要素数の最大値",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3007,g_hInst,0); g_max=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"__MAX_ELEMENTS",WS_CHILD|WS_VISIBLE|WS_TABSTOP|ES_AUTOHSCROLL,0,0,0,0,h,(HMENU)IDC_MAX_EDIT,g_hInst,0);
        CreateWindowW(L"STATIC",L"1要素=2消費",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3008,g_hInst,0);
        CreateWindowW(L"STATIC",L"1bitPCM変換方式",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3009,g_hInst,0);
        g_radioDiff=CreateWindowW(L"BUTTON",L"差分しきい値",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON|WS_GROUP,0,0,0,0,h,(HMENU)IDC_RAD_DIFF,g_hInst,0);
        g_radioSigmaDelta=CreateWindowW(L"BUTTON",L"シグマ・デルタ変調",WS_CHILD|WS_VISIBLE|BS_AUTORADIOBUTTON,0,0,0,0,h,(HMENU)IDC_RAD_SIGMADELTA,g_hInst,0);
        Button_SetCheck(g_radioDiff,BST_CHECKED);
        CreateWindowW(L"STATIC",L"無視する変化差分 (0.0-1.0)",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3016,g_hInst,0); g_thresh=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"0.0",WS_CHILD|WS_VISIBLE|WS_TABSTOP|ES_AUTOHSCROLL,0,0,0,0,h,(HMENU)IDC_THRESH_EDIT,g_hInst,0);
        CreateWindowW(L"STATIC",L"ディザリング量 (0.0-1.0 / 0=無効)",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3017,g_hInst,0); g_dither=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"0.0",WS_CHILD|WS_VISIBLE|WS_TABSTOP|ES_AUTOHSCROLL,0,0,0,0,h,(HMENU)IDC_DITHER_EDIT,g_hInst,0);
        g_expandedLimitCheck=CreateWindowW(L"BUTTON",L"伸長後使用ビット最大値",WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX|WS_TABSTOP,0,0,0,0,h,(HMENU)IDC_EXPANDED_LIMIT_CHECK,g_hInst,0);
        g_expandedLimitEdit=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"3840",WS_CHILD|WS_VISIBLE|WS_TABSTOP|ES_AUTOHSCROLL,0,0,0,0,h,(HMENU)IDC_EXPANDED_LIMIT_EDIT,g_hInst,0);
        EnableWindow(g_expandedLimitEdit, FALSE);
#if 0
        CreateWindowW(L"STATIC",L"※ 出力本文は RLE で c%数値 / r%数値 に圧縮します。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3010,g_hInst,0);
        CreateWindowW(L"STATIC",L"※ c / r / c%数値 / r%数値 は、どれも 1要素 = 2消費 です。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3011,g_hInst,0);
        CreateWindowW(L"STATIC",L"※ 例: crcr はそのまま、cccrrrccrr は c%3r%3c%2r%2。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3012,g_hInst,0);
        CreateWindowW(L"STATIC",L"※ 通常の出力生成ではビット制限を掛けません。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3013,g_hInst,0);
        CreateWindowW(L"STATIC",L"※ 再生確認時は、RLE結果の伸長後ビット数 expanded_bits まで再生します。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3014,g_hInst,0);
        CreateWindowW(L"STATIC",L"※ プレビュー表示は枠内だけで折り返し、実際の出力文字列には改行を入れません。",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)3015,g_hInst,0);
#endif
        CreateWindowW(L"BUTTON",L"変換実行",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_CONVERT,g_hInst,0);
        CreateWindowW(L"BUTTON",L"プレビュー更新",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_REFRESH,g_hInst,0);
        CreateWindowW(L"BUTTON",L"再生確認",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_PLAY,g_hInst,0);
        CreateWindowW(L"BUTTON",L"再生停止",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_BTN_STOP,g_hInst,0);
        g_target=CreateWindowW(L"STATIC",L"対象: なし",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_PREVIEW_TARGET,g_hInst,0);
        g_stats=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_VISIBLE,0,0,0,0,h,(HMENU)IDC_PREVIEW_STATS,g_hInst,0);
        g_preview=CreateWindowExW(WS_EX_CLIENTEDGE,L"EDIT",L"",WS_CHILD|WS_VISIBLE|WS_VSCROLL|ES_MULTILINE|ES_AUTOVSCROLL|ES_READONLY,0,0,0,0,h,(HMENU)IDC_PREVIEW_EDIT,g_hInst,0);

		EnumChildWindows(h, EnumChildProc, 0);

        Layout(h); return 0; }
    case WM_SIZE: Layout(h); return 0;
    case WM_DROPFILES:{ HDROP drop=(HDROP)w; UINT count=DragQueryFileW(drop,0xFFFFFFFF,nullptr,0); std::vector<std::wstring> files;
        for(UINT i=0;i<count;++i){ wchar_t p[MAX_PATH]={}; DragQueryFileW(drop,i,p,MAX_PATH); files.push_back(p);} DragFinish(drop); AddFiles(files); return 0; }
    case WM_COMMAND:{
        int id=LOWORD(w), code=HIWORD(w);
        if(g_isInitializingControls) return 0;
        if(id==IDC_BTN_ADD && code==BN_CLICKED) BrowseFiles();
        else if(id==IDC_BTN_CLEAR && code==BN_CLICKED){ StopPlayback(); g_files.clear(); g_loadedFileIndex = -1; RefreshFileList(); LoadSelectedFileSettingsToControls(); UpdatePreview(); }
        else if(id==IDC_BTN_CONVERT && code==BN_CLICKED) DoConvert();
        else if(id==IDC_BTN_REFRESH && code==BN_CLICKED) UpdatePreview();
        else if(id==IDC_BTN_PLAY && code==BN_CLICKED) DoPlay();
        else if(id==IDC_BTN_STOP && code==BN_CLICKED) StopPlayback();
        else if(id==IDC_FILE_LIST && code==LBN_SELCHANGE){ OnSelectedFileChanged(); UpdatePreview(); }
        else if(id==IDC_EXPANDED_LIMIT_CHECK && code==BN_CLICKED){
            EnableWindow(g_expandedLimitEdit, Button_GetCheck(g_expandedLimitCheck)==BST_CHECKED ? TRUE : FALSE);
            SaveSelectedFileSettingsFromControls();
            UpdatePreview();
        }
        else if((id==IDC_RATE_COMBO&&code==CBN_SELCHANGE)||id==IDC_RAD_JSON||id==IDC_RAD_TXT||id==IDC_RAD_DIFF||id==IDC_RAD_SIGMADELTA||id==IDC_ZERO_EDIT||id==IDC_ONE_EDIT||id==IDC_PREFIX_EDIT||id==IDC_MAX_EDIT||id==IDC_THRESH_EDIT||id==IDC_DITHER_EDIT||id==IDC_EXPANDED_LIMIT_EDIT){
            if(code==EN_CHANGE||code==BN_CLICKED||code==CBN_SELCHANGE){
                if(id != IDC_MAX_EDIT) SaveSelectedFileSettingsFromControls();
                UpdatePreview();
            }
        } return 0; }
    case WM_CONTEXTMENU:
        if((HWND)w==g_list){ POINT pt{GET_X_LPARAM(l),GET_Y_LPARAM(l)}; if(pt.x==-1&&pt.y==-1){ RECT r; GetWindowRect(g_list,&r); pt.x=r.left+10; pt.y=r.top+10; }
            int sel=ListBox_GetCurSel(g_list); if(sel!=LB_ERR){ HMENU menu=CreatePopupMenu(); AppendMenuW(menu,MF_STRING,1,L"このファイルを削除"); int cmd=TrackPopupMenu(menu,TPM_RETURNCMD|TPM_RIGHTBUTTON,pt.x,pt.y,0,h,nullptr); DestroyMenu(menu); if(cmd==1) RemoveSelectedFile(); } }
        return 0;
    case WM_KEYDOWN: if(w==VK_DELETE && GetFocus()==g_list){ RemoveSelectedFile(); return 0; } break;
    case WM_DESTROY: StopPlayback(); PostQuitMessage(0); return 0;
    }
    return DefWindowProcW(h,m,w,l);
}

int WINAPI wWinMain(HINSTANCE hInst,HINSTANCE, PWSTR, int nCmdShow){
    g_hInst=hInst; INITCOMMONCONTROLSEX icc{sizeof(icc), ICC_WIN95_CLASSES}; InitCommonControlsEx(&icc);
    WNDCLASSW wc{}; wc.lpfnWndProc=WndProc; wc.hInstance=hInst; wc.lpszClassName=L"WavTo1BitTextCppMain"; wc.hCursor=LoadCursor(nullptr,IDC_ARROW); wc.hbrBackground=(HBRUSH)(COLOR_BTNFACE+1);
    RegisterClassW(&wc);
    g_main=CreateWindowW(wc.lpszClassName,L"WavTo1BitTextCpp",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,1280,820 + __WINDOW_OFFSET,nullptr,nullptr,hInst,nullptr);
    ShowWindow(g_main,nCmdShow); UpdateWindow(g_main);
    MSG msg; while(GetMessageW(&msg,nullptr,0,0)){ TranslateMessage(&msg); DispatchMessageW(&msg); } return 0;
}