private void Open_BNK_B_Click(object sender, RoutedEventArgs e)
 {
     if (IsClosing || IsBusy)
     {
         return;
     }
     System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog()
     {
         Title       = ".bnkファイルを選択してください。",
         Multiselect = true,
         Filter      = ".bnkファイル(*.bnk)|*.bnk"
     };
     if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         try
         {
             foreach (string FileNames in ofd.FileNames)
             {
                 string Select_Name = Path.GetFileName(FileNames);
                 bool   IsExist     = false;
                 foreach (string File_Now in BNK_File)
                 {
                     if (Path.GetFileName(File_Now) == Select_Name)
                     {
                         MessageBox.Show(Select_Name + "は既に追加されています。別のファイル名を指定する必要があります。");
                         IsExist = true;
                         break;
                     }
                 }
                 if (IsExist)
                 {
                     continue;
                 }
                 Wwise_Class.BNK_Parse p = new Wwise_Class.BNK_Parse(FileNames);
                 int Count = p.Get_File_Count();
                 if (Count == 0)
                 {
                     MessageBox.Show(Select_Name + "にサウンドファイルが含まれていませんでした。");
                     p.Clear();
                     continue;
                 }
                 p.Clear();
                 BNK_Sound_Count.Add((uint)Count);
                 BNK_File.Add(FileNames);
                 Info_List.Items.Add("追加:" + Select_Name);
             }
             Info_List.Items[0] = "BNKファイル数:" + BNK_File.Count + "個";
             uint All_Count = 0;
             foreach (uint Counts in BNK_Sound_Count)
             {
                 All_Count += Counts;
             }
             Info_List.Items[4] = "サウンド数:" + All_Count;
         }
         catch
         {
             Message_Feed_Out("選択したファイルは破損している可能性があります。");
         }
     }
 }
 private void Open_Init_B_Click(object sender, RoutedEventArgs e)
 {
     if (IsClosing || IsBusy)
     {
         return;
     }
     System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog()
     {
         Title       = "Init.bnkファイルを選択してください。",
         Multiselect = false,
         Filter      = "Init.bnkファイル(Init.bnk)|Init.bnk"
     };
     if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         try
         {
             Wwise_Class.BNK_Parse p = new Wwise_Class.BNK_Parse(ofd.FileName);
             if (!p.IsInitBNK())
             {
                 Message_Feed_Out("指定したInit.bnkは対応していません。");
                 p.Clear();
                 return;
             }
             p.Clear();
             Info_List.Items[2] = "Initファイル:選択済み";
             Init_File          = ofd.FileName;
         }
         catch
         {
             Message_Feed_Out("選択したファイルは破損している可能性があります。");
         }
     }
 }
Exemple #3
0
        //PC版WoTの音声ファイルを指定
        private async void Open_File_B_Click(object sender, RoutedEventArgs e)
        {
            if (IsClosing || IsBusy)
            {
                return;
            }
            OpenFileDialog ofd = new OpenFileDialog()
            {
                Title       = "BNKファイルを選択してください。",
                Multiselect = false,
                Filter      = "BNKファイル(*.bnk)|*.bnk"
            };

            if (ofd.ShowDialog() == DialogResult.OK)
            {
                string PCK_File_Path = Path.GetDirectoryName(ofd.FileName) + "/" + Path.GetFileNameWithoutExtension(ofd.FileName) + ".pck";
                if (PCK_Mode_C.IsChecked.Value && !File.Exists(PCK_File_Path))
                {
                    Message_Feed_Out(Path.GetFileNameWithoutExtension(ofd.FileName) + ".pckが見つかりませんでした。");
                    IsBusy = false;
                    return;
                }
                string XML_File_Path = Path.GetDirectoryName(ofd.FileName) + "/audio_mods.xml";
                if (XML_Mode_C.IsChecked.Value && !File.Exists(XML_File_Path))
                {
                    Message_Feed_Out("audio_mods.xmlが見つかりませんでした。");
                    IsBusy = false;
                    return;
                }
                Bass.BASS_ChannelStop(Stream);
                Bass.BASS_StreamFree(Stream);
                try
                {
                    if (Directory.Exists(Voice_Set.Special_Path + "/Wwise/BNK_WAV"))
                    {
                        Directory.Delete(Voice_Set.Special_Path + "/Wwise/BNK_WAV", true);
                    }
                }
                catch (Exception e1)
                {
                    Sub_Code.Error_Log_Write(e1.Message);
                }
                IsBusy = true;
                try
                {
                    Message_T.Text = ".bnkファイルを解析しています...";
                    await Task.Delay(50);

                    Wwise_Class.BNK_Parse p = new Wwise_Class.BNK_Parse(ofd.FileName);
                    Message_T.Text = "audio_mods.xmlからイベントIDを取得しています...";
                    await Task.Delay(50);

                    if (!p.IsVoiceFile())
                    {
                        Message_Feed_Out("選択されたbnkファイルは音声データではありません。");
                        IsBusy = false;
                        return;
                    }
                    Message_T.Text = "各イベント内の音声IDを取得しています...";
                    await Task.Delay(50);

                    BNK_Voices_Enable.Clear();
                    BNK_Voices = p.Get_Voices(false);
                    if (XML_Mode_C.IsChecked.Value)
                    {
                        p.Get_Event_ID_From_XML(XML_File_Path);
                        List <List <string> > Temp = p.Get_Voices(false);
                        for (int Number = 0; Number < Temp.Count; Number++)
                        {
                            if (BNK_Voices[Number].Count == 0)
                            {
                                BNK_Voices[Number] = Temp[Number];
                            }
                        }
                    }
                    List <string> Need_Files = new List <string>();
                    foreach (List <string> Types in BNK_Voices)
                    {
                        BNK_Voices_Enable.Add(new List <bool>());
                        foreach (string File_Now in Types)
                        {
                            Need_Files.Add(File_Now);
                            BNK_Voices_Enable[BNK_Voices_Enable.Count - 1].Add(true);
                        }
                    }
                    if (Need_Files.Count == 0)
                    {
                        BNK_Voices_Enable.Clear();
                        Message_T.Text = "移植できるファイルが見つからなかったため、特殊な方法で解析しています...";
                        await Task.Delay(50);

                        p.SpecialBNKFileMode = 1;
                        BNK_Voices           = p.Get_Voices(false);
                        foreach (List <string> Types in BNK_Voices)
                        {
                            BNK_Voices_Enable.Add(new List <bool>());
                            foreach (string File_Now in Types)
                            {
                                Need_Files.Add(File_Now);
                                BNK_Voices_Enable[BNK_Voices_Enable.Count - 1].Add(true);
                            }
                        }
                        if (Need_Files.Count == 0)
                        {
                            p.Clear();
                            BNK_Voices.Clear();
                            BNK_Voices_Enable.Clear();
                            Message_Feed_Out("移植できる音声が見つかりませんでした。");
                            IsBusy = false;
                            return;
                        }
                    }
                    p.Clear();
                    Get_Available_Voice_Count();
                    Voices_L.Items.Clear();
                    Voice_Type_L.Items.Clear();
                    for (int Number = 0; Number < BNK_Voices.Count; Number++)
                    {
                        Voices_L.Items.Add(Voice_Set.Get_Voice_Type_Japanese_Name_V2(Number) + " : " + BNK_Voices[Number].Count + "個");
                    }
                    BGM_Count_Change();
                    if (PCK_Mode_C.IsChecked.Value)
                    {
                        Message_T.Text = ".wemファイルに変換しています...";
                        await Task.Delay(50);

                        Wwise_PCK        = new Wwise_File_Extract_V1(PCK_File_Path);
                        Max_Stream_Count = Wwise_PCK.Wwise_Get_File_Count();
                        await Wwise_PCK.Async_Wwise_Extract_To_WEM_Directory(Voice_Set.Special_Path + "/Wwise/BNK_WAV");

                        Message_T.Text = ".wemファイルを.oggに変換しています...";
                        await Task.Delay(50);

                        await Wwise_PCK.Async_Wwise_Extract_To_OGG_Directory(Voice_Set.Special_Path + "/Wwise/BNK_WAV");
                    }
                    else
                    {
                        Message_T.Text = ".wavまたは.oggに変換しています...";
                        await Task.Delay(50);

                        Wwise_BNK        = new Wwise_File_Extract_V2(ofd.FileName);
                        Max_Stream_Count = Wwise_BNK.Wwise_Get_Numbers();
                        Wwise_BNK.Wwise_Extract_To_WEM_Directory_V2(Voice_Set.Special_Path + "/Wwise/BNK_WAV");
                    }
                    string[] Files = Directory.GetFiles(Voice_Set.Special_Path + "/Wwise/BNK_WAV", "*.wem", SearchOption.TopDirectoryOnly);
                    foreach (string File_Now in Files)
                    {
                        Sub_Code.File_Delete_V2(File_Now);
                    }
                    Message_T.Text = "不要な音声ファイルを削除しています...";
                    await Task.Delay(50);

                    string[] All_Files = Directory.GetFiles(Voice_Set.Special_Path + "/Wwise/BNK_WAV", "*", SearchOption.TopDirectoryOnly);
                    foreach (string File_Now in All_Files)
                    {
                        if (!Need_Files.Contains(Path.GetFileNameWithoutExtension(File_Now)))
                        {
                            Sub_Code.File_Delete_V2(File_Now);
                        }
                    }
                    File_Name_T.Text = Path.GetFileName(ofd.FileName);
                    Message_Feed_Out(".bnkファイルをロードしました。");
                }
                catch (Exception e1)
                {
                    Sub_Code.Error_Log_Write(e1.Message);
                    Message_Feed_Out("解析に失敗しました。Error_Log.txtを参照してください。");
                }
                IsBusy = false;
            }
        }
Exemple #4
0
        private async void Open_File_B_Click(object sender, RoutedEventArgs e)
        {
            if (IsClosing || IsBusy)
            {
                return;
            }
            OpenFileDialog ofd = new OpenFileDialog()
            {
                Title       = "WoTBの音声Modを選択してください。",
                Multiselect = false,
                Filter      = "WoTB音声(*.fsb;*.bnk)|*.fsb;*.bnk"
            };

            if (ofd.ShowDialog() == DialogResult.OK)
            {
                IsBusy = true;
                try
                {
                    string To_Dir = Voice_Set.Special_Path + "/Wwise/BNK_WAV_WoT";
                    try
                    {
                        if (Directory.Exists(To_Dir))
                        {
                            Directory.Delete(To_Dir, true);
                        }
                    }
                    catch (Exception e1)
                    {
                        Sub_Code.Error_Log_Write(e1.Message);
                    }
                    for (int Number = 0; Number < 34; Number++)
                    {
                        BNK_FSB_Enable.Add(new List <bool>());
                    }
                    if (Path.GetExtension(ofd.FileName) == ".bnk")
                    {
                        Message_T.Text = ".bnkファイルを解析しています...";
                        await Task.Delay(50);

                        Wwise_Class.BNK_Parse p = new Wwise_Class.BNK_Parse(ofd.FileName);
                        if (!p.IsVoiceFile(true))
                        {
                            Message_Feed_Out("選択されたbnkファイルは音声データではありません。");
                            IsBusy = false;
                            return;
                        }
                        BNK_FSB_Voices = p.Get_Voices(true);
                        List <string> Need_Files = new List <string>();
                        foreach (List <string> Types in BNK_FSB_Voices)
                        {
                            foreach (string File_Now in Types)
                            {
                                Need_Files.Add(File_Now);
                            }
                        }
                        if (Need_Files.Count == 0)
                        {
                            Message_T.Text = "移植できるファイルが見つからなかったため、特殊な方法で解析しています...";
                            await Task.Delay(50);

                            p.SpecialBNKFileMode = 1;
                            BNK_FSB_Voices       = p.Get_Voices(true);
                            foreach (List <string> Types in BNK_FSB_Voices)
                            {
                                foreach (string File_Now in Types)
                                {
                                    Need_Files.Add(File_Now);
                                }
                            }
                            if (Need_Files.Count == 0)
                            {
                                p.Clear();
                                BNK_FSB_Voices.Clear();
                                Message_Feed_Out("移植できる音声が見つかりませんでした。");
                                IsBusy = false;
                                return;
                            }
                        }
                        p.Clear();
                        Voices_L.Items.Clear();
                        Content_L.Items.Clear();
                        Now_Stream_Count = 0;
                        Message_T.Text   = ".wavまたは.oggに変換しています...";
                        await Task.Delay(50);

                        Wwise_File_Extract_V2 Wwise_BNK = new Wwise_File_Extract_V2(ofd.FileName);
                        Max_Stream_Count = Wwise_BNK.Wwise_Get_Numbers();
                        Wwise_BNK.Wwise_Extract_To_WEM_Directory_V2(To_Dir);
                        Wwise_BNK.Bank_Clear();
                        Message_T.Text = "不要な音声ファイルを削除しています...";
                        await Task.Delay(50);

                        string[] All_Files = Directory.GetFiles(To_Dir, "*", SearchOption.TopDirectoryOnly);
                        foreach (string File_Now in All_Files)
                        {
                            if (!Need_Files.Contains(Path.GetFileNameWithoutExtension(File_Now)))
                            {
                                Sub_Code.File_Delete_V2(File_Now);
                            }
                        }
                        //効果音を削除(これ以外は取り除けない)
                        string[] Files = Directory.GetFiles(To_Dir, "*.wem", SearchOption.TopDirectoryOnly);
                        foreach (string File_Now in Files)
                        {
                            Sub_Code.File_Delete_V2(File_Now);
                        }
                        Message_T.Text = ".oggファイルを.wavファイルに変換しています...";
                        await Task.Delay(50);

                        await Multithread.Convert_To_Wav(Directory.GetFiles(To_Dir, "*.ogg", SearchOption.TopDirectoryOnly), To_Dir, true, true);

                        File_Name_T.Text = Path.GetFileName(ofd.FileName);
                        Message_Feed_Out(".bnkファイルをロードしました。SEが含まれている場合は無効化してください。");
                    }
                    else
                    {
                        Message_T.Text = ".fsbファイルを解析しています...";
                        await Task.Delay(50);

                        bool          IsVoiceExist = false;
                        List <string> Voices       = Fmod_Class.FSB_GetNames(ofd.FileName);
                        foreach (string File_Now in Voices)
                        {
                            string File_Now_01 = File_Now.Replace(" ", "");
                            if (File_Now_01.Contains("battle_01") || File_Now_01.Contains("battle_02") || File_Now_01.Contains("battle_03") || File_Now_01.Contains("start_battle_01"))
                            {
                                IsVoiceExist = true;
                                break;
                            }
                        }
                        if (!IsVoiceExist)
                        {
                            Message_Feed_Out("指定したFSBファイルは対応していません。");
                            IsBusy = false;
                            return;
                        }
                        Voices.Clear();
                        Message_T.Text = "FSBファイルからファイルを抽出しています...";
                        await Task.Delay(50);

                        Max_Stream_Count = Fmod_Class.FSB_GetLength(ofd.FileName);
                        Fmod_File_Extract_V2.FSB_Extract_To_Directory(ofd.FileName, To_Dir + "_TMP");
                        Message_T.Text = ".wavファイルを修正しています...";
                        await Task.Delay(50);

                        await Multithread.Convert_To_Wav(To_Dir + "_TMP", To_Dir, true, true, false, false);

                        Directory.Delete(To_Dir + "_TMP", true);
                        Message_T.Text = "ファイル名からリストに配置しています...";
                        await Task.Delay(50);

                        BNK_FSB_Voices = Voice_Set.Voice_BGM_Name_Change_From_FSB_To_Index(To_Dir);
                        Voices_L.Items.Clear();
                        Content_L.Items.Clear();
                        Now_Stream_Count = 0;
                        Message_T.Text   = "不要なファイルを削除しています...";
                        await Task.Delay(50);

                        foreach (string File_Name in Directory.GetFiles(To_Dir, "*", SearchOption.TopDirectoryOnly))
                        {
                            string Name_Only = Path.GetFileNameWithoutExtension(File_Name);
                            bool   IsExsist  = false;
                            for (int Number = 0; Number < BNK_FSB_Voices.Count; Number++)
                            {
                                foreach (string Name_Now in BNK_FSB_Voices[Number])
                                {
                                    if (Name_Only == Name_Now)
                                    {
                                        IsExsist = true;
                                        break;
                                    }
                                }
                                if (IsExsist)
                                {
                                    break;
                                }
                            }
                            if (!IsExsist)
                            {
                                Sub_Code.File_Delete_V2(File_Name);
                            }
                        }
                        File_Name_T.Text = Path.GetFileName(ofd.FileName);
                        Message_Feed_Out(".fsbファイルをロードしました。");
                    }
                    if (BNK_FSB_Voices[5].Count == 0 && BNK_FSB_Voices[2].Count > 0)
                    {
                        BNK_FSB_Voices[5] = new List <string>(BNK_FSB_Voices[2]);
                    }
                    if (BNK_FSB_Voices[4].Count == 0 && BNK_FSB_Voices[3].Count > 0)
                    {
                        BNK_FSB_Voices[4] = new List <string>(BNK_FSB_Voices[3]);
                    }
                    for (int Number = 0; Number < 34; Number++)
                    {
                        Now_Stream_Count += BNK_FSB_Voices[Number].Count;
                        Voices_L.Items.Add(Voice_Set.Get_Voice_Type_Japanese_Name_V2(Number) + " : " + BNK_FSB_Voices[Number].Count + "個");
                    }
                    for (int Number_01 = 0; Number_01 < BNK_FSB_Voices.Count; Number_01++)
                    {
                        for (int Number_02 = 0; Number_02 < BNK_FSB_Voices[Number_01].Count; Number_02++)
                        {
                            BNK_FSB_Enable[Number_01].Add(true);
                        }
                    }
                }
                catch (Exception e1)
                {
                    IsBusy = false;
                    Sub_Code.Error_Log_Write(e1.Message);
                    BNK_FSB_Clear(false);
                    Message_Feed_Out("エラーが発生しました。Error_Log.txtを参照してください。");
                }
            }
            IsBusy = false;
        }
        private async void Open_File_B_Click(object sender, RoutedEventArgs e)
        {
            if (IsClosing || IsBusy)
            {
                return;
            }
            System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog()
            {
                Title       = "音声Modを選択してください。",
                Filter      = "音声ファイル(*.fsb;*.bnk)|*.fsb;*.bnk",
                Multiselect = false
            };
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    IsBusy = true;
                    string Ex       = Path.GetExtension(ofd.FileName);
                    string PCK_Path = Path.GetDirectoryName(ofd.FileName) + "\\" + Path.GetFileNameWithoutExtension(ofd.FileName) + ".pck";
                    if (Ex == ".fsb")
                    {
                        Message_T.Text = ".fsbファイルを解析しています...";
                        await Task.Delay(50);

                        bool          IsVoiceExist = false;
                        List <string> Voices       = Fmod_Class.FSB_GetNames(ofd.FileName);
                        foreach (string File_Now in Voices)
                        {
                            string File_Now_01 = File_Now.Replace(" ", "");
                            if (File_Now_01.Contains("battle_01") || File_Now_01.Contains("battle_02") || File_Now_01.Contains("battle_03") || File_Now_01.Contains("start_battle_01"))
                            {
                                IsVoiceExist = true;
                                break;
                            }
                        }
                        if (!IsVoiceExist)
                        {
                            Message_Feed_Out("指定したファイルは対応していません。詳しくは注意事項を参照してください。");
                            IsBusy = false;
                            return;
                        }
                        Voices.Clear();
                        Max_Stream_Count = Fmod_Class.FSB_GetLength(ofd.FileName);
                        BNK_FSB_Voices   = Voice_Set.Voice_BGM_Name_Change_From_FSB_To_Index_FSBFile(ofd.FileName);
                        Now_Stream_Count = 0;
                        Voices_L.Items.Clear();
                        for (int Number = 0; Number < 34; Number++)
                        {
                            Now_Stream_Count += BNK_FSB_Voices[Number].Count;
                            Voices_L.Items.Add(Voice_Set.Get_Voice_Type_Japanese_Name_V2(Number) + " : " + BNK_FSB_Voices[Number].Count + "個");
                        }
                    }
                    else if (Ex == ".bnk")
                    {
                        Message_T.Text = ".bnkファイルを解析しています...";
                        await Task.Delay(50);

                        string To_Dir = Voice_Set.Special_Path + "/Wwise/BNK_WAV_WoT";
                        try
                        {
                            if (Directory.Exists(To_Dir))
                            {
                                Directory.Delete(To_Dir, true);
                            }
                        }
                        catch (Exception e1)
                        {
                            Sub_Code.Error_Log_Write(e1.Message);
                        }
                        if (PCK_Mode_C.IsChecked.Value)
                        {
                            if (!File.Exists(PCK_Path))
                            {
                                Message_Feed_Out("PCKファイルが見つかりませんでした。");
                                IsBusy = false;
                                return;
                            }
                            IsPCKMode = true;
                        }
                        else
                        {
                            IsPCKMode = false;
                        }
                        int BNK_Mode            = 0;
                        Wwise_Class.BNK_Parse p = new Wwise_Class.BNK_Parse(ofd.FileName);
                        if (p.IsVoiceFile(true))
                        {
                            BNK_Mode = 1;
                        }
                        else if (p.IsVoiceFile())
                        {
                            BNK_Mode = 2;
                        }
                        else
                        {
                            Message_Feed_Out("選択されたbnkファイルは音声データではありません。");
                            IsBusy = false;
                            return;
                        }
                        bool Mode;
                        if (BNK_Mode == 1)
                        {
                            Mode = true;
                        }
                        else if (BNK_Mode == 2)
                        {
                            Mode = false;
                        }
                        else
                        {
                            Message_Feed_Out("選択されたbnkファイルは音声データではありません。");
                            IsBusy = false;
                            return;
                        }
                        BNK_FSB_Voices = p.Get_Voices(Mode);
                        foreach (List <string> Types in BNK_FSB_Voices)
                        {
                            foreach (string File_Now in Types)
                            {
                                Need_Files.Add(File_Now);
                            }
                        }
                        if (Need_Files.Count == 0)
                        {
                            Message_T.Text = "移植できるファイルが見つからなかったため、特殊な方法で解析しています...";
                            await Task.Delay(50);

                            p.SpecialBNKFileMode = 1;
                            BNK_FSB_Voices       = p.Get_Voices(Mode);
                            foreach (List <string> Types in BNK_FSB_Voices)
                            {
                                foreach (string File_Now in Types)
                                {
                                    Need_Files.Add(File_Now);
                                }
                            }
                        }
                        if (Need_Files.Count == 0)
                        {
                            p.Clear();
                            BNK_FSB_Voices.Clear();
                            Message_Feed_Out("移植できる音声が見つかりませんでした。");
                            IsBusy = false;
                            return;
                        }
                        Max_Stream_Count = p.Get_File_Count();
                        p.Clear();
                        Voices_L.Items.Clear();
                        Now_Stream_Count = 0;
                        for (int Number = 0; Number < 34; Number++)
                        {
                            Now_Stream_Count += BNK_FSB_Voices[Number].Count;
                            Voices_L.Items.Add(Voice_Set.Get_Voice_Type_Japanese_Name_V2(Number) + " : " + BNK_FSB_Voices[Number].Count + "個");
                        }
                    }
                    Message_Feed_Out("解析が完了しました。");
                    if (IsPCKMode)
                    {
                        Selected_File = PCK_Path;
                    }
                    Selected_File    = ofd.FileName;
                    File_Name_T.Text = "ファイル名:" + Path.GetFileName(ofd.FileName);
                }
                catch (Exception e1)
                {
                    Selected_File = "";
                    BNK_FSB_Voices.Clear();
                    Voices_L.Items.Clear();
                    Voices_L.Items.Add("音声ファイルが選択されていません。");
                    Sub_Code.Error_Log_Write(e1.Message);
                    Message_Feed_Out("エラーが発生しました。ファイル形式が正しくない可能性があります。");
                }
            }
            ofd.Dispose();
            IsBusy = false;
        }
Exemple #6
0
        private async void Open_BNK_B_Click(object sender, RoutedEventArgs e)
        {
            if (IsClosing || IsBusy)
            {
                return;
            }
            System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog()
            {
                Title       = ".bnkファイルを選択してください。",
                Multiselect = false,
                Filter      = ".bnkファイル(*.bnk)|*.bnk"
            };
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    IsBusy = true;
                    string PCK_File_Path = Path.GetDirectoryName(ofd.FileName) + "/" + Path.GetFileNameWithoutExtension(ofd.FileName) + ".pck";
                    if (PCK_Mode_C.IsChecked.Value && !File.Exists(PCK_File_Path))
                    {
                        Message_Feed_Out(Path.GetFileNameWithoutExtension(ofd.FileName) + ".pckが見つかりませんでした。");
                        IsBusy = false;
                        return;
                    }
                    Bass.BASS_ChannelStop(Stream);
                    Bass.BASS_StreamFree(Stream);
                    if (Directory.Exists(Voice_Set.Special_Path + "/Wwise/BNK_WAV_Special"))
                    {
                        Sub_Code.Directory_Delete(Voice_Set.Special_Path + "/Wwise/BNK_WAV_Special");
                    }
                    Message_T.Text = ".bnkファイルを解析しています...";
                    await Task.Delay(50);

                    p = new Wwise_Class.BNK_Parse(ofd.FileName);
                    List <uint> Event_List = p.Get_BNK_Event_ID();
                    Event_Type_L.Items.Clear();
                    Sound_L.Items.Clear();
                    foreach (uint ID in Event_List)
                    {
                        Event_Type_L.Items.Add((Event_Type_L.Items.Count + 1) + ":" + ID);
                    }
                    Event_List.Clear();
                    if (PCK_Mode_C.IsChecked.Value)
                    {
                        Wwise_PCK = new Wwise_File_Extract_V1(PCK_File_Path);
                        IsPCKMode = true;
                    }
                    else
                    {
                        Wwise_BNK = new Wwise_File_Extract_V2(ofd.FileName);
                        IsPCKMode = false;
                    }
                    if (!Directory.Exists(Voice_Set.Special_Path + "/Wwise/BNK_WAV_Special"))
                    {
                        Directory.CreateDirectory(Voice_Set.Special_Path + "/Wwise/BNK_WAV_Special");
                    }
                    File_Name_T.Text = Path.GetFileName(ofd.FileName);
                    Message_Feed_Out(".bnkファイルをロードしました。");
                }
                catch (Exception e1)
                {
                    Sub_Code.Error_Log_Write(e1.Message);
                    if (Wwise_PCK != null)
                    {
                        Wwise_PCK.Pck_Clear();
                    }
                    if (Wwise_BNK != null)
                    {
                        Wwise_BNK.Bank_Clear();
                    }
                    if (p != null)
                    {
                        p.Clear();
                    }
                    Wwise_PCK        = null;
                    Wwise_BNK        = null;
                    p                = null;
                    IsPCKMode        = false;
                    File_Name_T.Text = "";
                    Event_Type_L.Items.Clear();
                    Sound_L.Items.Clear();
                    Message_Feed_Out("エラーが発生しました。詳しくはError_Log.txtを参照してください。");
                }
            }
            IsBusy = false;
        }