C#으로 Sound Control 제어하기 (사운드믹서)

사운드 컨트롤을 제어해서 지정된 어플에서만 음성을 받아오도록 해야하는 과제가 주어졌다.

일단, 대전제로 아래와같이 Mute 는 사용하지 않으면서, 해당어플에서 내보내는 경고음을 유저에게 내보내야한다.

자, 여기서부터 문제
어떻게 제어를 해야할까??

일단, 한번 검색부터 해보자.

Controlling Volume Mixer

라는 글이 보인다.

그리고, 아래의 글도 많은 도움이 되었다.

C# (CSharp) MIXERLINECONTROLS Code Examples

자, 그럼 이제 본격적으로 하나 만들어보자.

화면은 아래와 같이 구성하였다.

시스템 비프음을 내고, 시스템사운드를 이용한 음향효과를 내보내는 긴 버튼
그리고, 해당 어플에서 음량을 100%로 효과발산(?) 해주는 버튼

스피커 음량의 초기셋팅은 아래와같이 지정해둔것을 전제로 한다.

스피커는 MAX 100% 지정되어있으며, 나머지는 모두 0% 로 지정 (소리를 받지않겠다는 강한의지!!)

일단, 여기저기 있는 함수를 끌어~ 끌어~모아서 baseClass 작성
baseClass는 아래와 같다.

using System;
using System.IO;
using System.Runtime.InteropServices;
 
namespace WindowsFormsApplication1
{
    public sealed class SoundUtils
    {
        public const int MMSYSERR_NOERROR = 0;
        public const int MAXPNAMELEN = 32;
        public const int MIXER_LONG_NAME_CHARS = 64;
        public const int MIXER_SHORT_NAME_CHARS = 16;
        public const int MIXER_GETLINEINFOF_COMPONENTTYPE = 0x3;
        public const int MIXER_GETCONTROLDETAILSF_VALUE = 0x0;
        public const int MIXER_GETLINECONTROLSF_ONEBYTYPE = 0x2;
        public const int MIXER_SETCONTROLDETAILSF_VALUE = 0x0;
        public const int MIXERLINE_COMPONENTTYPE_DST_FIRST = 0x0;
        public const int MIXERLINE_COMPONENTTYPE_SRC_FIRST = 0x1000;
        public const int MIXERLINE_COMPONENTTYPE_DST_SPEAKERS =
            (MIXERLINE_COMPONENTTYPE_DST_FIRST + 4);
        public const int MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE =
            (MIXERLINE_COMPONENTTYPE_SRC_FIRST + 3);
        public const int MIXERLINE_COMPONENTTYPE_SRC_LINE =
            (MIXERLINE_COMPONENTTYPE_SRC_FIRST + 2);
        public const int MIXERCONTROL_CT_CLASS_FADER = 0x50000000;
        public const int MIXERCONTROL_CT_UNITS_UNSIGNED = 0x30000;
        public const int MIXERCONTROL_CONTROLTYPE_FADER =
            (MIXERCONTROL_CT_CLASS_FADER | MIXERCONTROL_CT_UNITS_UNSIGNED);
        public const int MIXERCONTROL_CONTROLTYPE_VOLUME =
            (MIXERCONTROL_CONTROLTYPE_FADER + 1);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerClose(int hmx);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetControlDetailsA(int hmxobj, ref
            MIXERCONTROLDETAILS pmxcd, int fdwDetails);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetDevCapsA(int uMxId, MIXERCAPS
            pmxcaps, int cbmxcaps);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetID(int hmxobj, int pumxID, int
            fdwId);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetLineControlsA(int hmxobj, ref
            MIXERLINECONTROLS pmxlc, int fdwControls);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetLineInfoA(int hmxobj, ref
            MIXERLINE pmxl, int fdwInfo);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerGetNumDevs();
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerMessage(int hmx, int uMsg, int
            dwParam1, int dwParam2);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerOpen(out int phmx, int uMxId,
            int dwCallback, int dwInstance, int fdwOpen);
 
        [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
        private static extern int mixerSetControlDetails(int hmxobj, ref
            MIXERCONTROLDETAILS pmxcd, int fdwDetails);
 
        [DllImport("winmm.dll", EntryPoint = "sndPlaySoundA")]
        private static extern int sndPlaySound(string lpszSoundName, int uFlags);
        public enum SND
        {
            SND_SYNC = 0x0000,/* play synchronously (default) */
            SND_ASYNC = 0x0001, /* play asynchronously */
            SND_NODEFAULT = 0x0002, /* silence (!default) if sound not found */
            SND_MEMORY = 0x0004, /* pszSound points to a memory file */
            SND_LOOP = 0x0008, /* loop the sound until next sndPlaySound */
            SND_NOSTOP = 0x0010, /* don't stop any currently playing sound */
            SND_NOWAIT = 0x00002000, /* don't wait if the driver is busy */
            SND_ALIAS = 0x00010000,/* name is a registry alias */
            SND_ALIAS_ID = 0x00110000, /* alias is a pre d ID */
            SND_FILENAME = 0x00020000, /* name is file name */
            SND_RESOURCE = 0x00040004, /* name is resource name or atom */
            SND_PURGE = 0x0040,  /* purge non-static events for task */
            SND_APPLICATION = 0x0080  /* look for application specific association */
        }
 
        public struct MIXERCAPS
        {
            public int wMid;
            public int wPid;
            public int vDriverVersion;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)]
            public string szPname;
            public int fdwSupport;
            public int cDestinations;
        }
 
        public struct MIXERCONTROL
        {
            public int cbStruct;
            public int dwControlID;
            public int dwControlType;
            public int fdwControl;
            public int cMultipleItems;
            [MarshalAs(UnmanagedType.ByValTStr,
                 SizeConst = MIXER_SHORT_NAME_CHARS)]
            public string szShortName;
            [MarshalAs(UnmanagedType.ByValTStr,
                 SizeConst = MIXER_LONG_NAME_CHARS)]
            public string szName;
            public int lMinimum;
            public int lMaximum;
            [MarshalAs(UnmanagedType.U4, SizeConst = 10)]
            public int reserved;
        }
 
        public struct MIXERCONTROLDETAILS
        {
            public int cbStruct;
            public int dwControlID;
            public int cChannels;
            public int item;
            public int cbDetails;
            public IntPtr paDetails;
        }
 
        public struct MIXERCONTROLDETAILS_UNSIGNED
        {
            public int dwValue;
        }
 
        public struct MIXERLINE
        {
            public int cbStruct;
            public int dwDestination;
            public int dwSource;
            public int dwLineID;
            public int fdwLine;
            public int dwUser;
            public int dwComponentType;
            public int cChannels;
            public int cConnections;
            public int cControls;
            [MarshalAs(UnmanagedType.ByValTStr,
                 SizeConst = MIXER_SHORT_NAME_CHARS)]
            public string szShortName;
            [MarshalAs(UnmanagedType.ByValTStr,
                 SizeConst = MIXER_LONG_NAME_CHARS)]
            public string szName;
            public int dwType;
            public int dwDeviceID;
            public int wMid;
            public int wPid;
            public int vDriverVersion;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)]
            public string szPname;
        }
 
        public struct MIXERLINECONTROLS
        {
            public int cbStruct;
            public int dwLineID;
 
            public int dwControl;
            public int cControls;
            public int cbmxctrl;
            public IntPtr pamxctrl;
        }
 
        private static bool GetVolumeControl(int hmixer, int componentType,
            int ctrlType, out MIXERCONTROL mxc, out int vCurrentVol)
        {
            // This function attempts to obtain a mixer control. 
            // Returns True if successful. 
            MIXERLINECONTROLS mxlc = new MIXERLINECONTROLS();
            MIXERLINE mxl = new MIXERLINE();
            MIXERCONTROLDETAILS pmxcd = new MIXERCONTROLDETAILS();
            MIXERCONTROLDETAILS_UNSIGNED du = new
                MIXERCONTROLDETAILS_UNSIGNED();
            mxc = new MIXERCONTROL();
            int rc;
            bool retValue;
            vCurrentVol = -1;
 
            mxl.cbStruct = Marshal.SizeOf(mxl);
            mxl.dwComponentType = componentType;
 
            rc = mixerGetLineInfoA(hmixer, ref mxl,
                MIXER_GETLINEINFOF_COMPONENTTYPE);
 
            if (MMSYSERR_NOERROR == rc)
            {
                int sizeofMIXERCONTROL = 152;
                int ctrl = Marshal.SizeOf(typeof(MIXERCONTROL));
                mxlc.pamxctrl = Marshal.AllocCoTaskMem(sizeofMIXERCONTROL);
                mxlc.cbStruct = Marshal.SizeOf(mxlc);
                mxlc.dwLineID = mxl.dwLineID;
                mxlc.dwControl = ctrlType;
                mxlc.cControls = 1;
                mxlc.cbmxctrl = sizeofMIXERCONTROL;
 
                // Allocate a buffer for the control 
                mxc.cbStruct = sizeofMIXERCONTROL;
 
                // Get the control 
                rc = mixerGetLineControlsA(hmixer, ref mxlc,
                    MIXER_GETLINECONTROLSF_ONEBYTYPE);
 
                if (MMSYSERR_NOERROR == rc)
                {
                    retValue = true;
 
                    // Copy the control into the destination structure 
                    mxc = (MIXERCONTROL)Marshal.PtrToStructure(
                        mxlc.pamxctrl, typeof(MIXERCONTROL));
                }
                else
                {
                    retValue = false;
                }
                int sizeofMIXERCONTROLDETAILS =
                    Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
                int sizeofMIXERCONTROLDETAILS_UNSIGNED =
                    Marshal.SizeOf(typeof(MIXERCONTROLDETAILS_UNSIGNED));
                pmxcd.cbStruct = sizeofMIXERCONTROLDETAILS;
                pmxcd.dwControlID = mxc.dwControlID;
                pmxcd.paDetails =
 
                    Marshal.AllocCoTaskMem(sizeofMIXERCONTROLDETAILS_UNSIGNED);
                pmxcd.cChannels = 1;
                pmxcd.item = 0;
                pmxcd.cbDetails = sizeofMIXERCONTROLDETAILS_UNSIGNED;
 
                rc = mixerGetControlDetailsA(hmixer, ref pmxcd,
                    MIXER_GETCONTROLDETAILSF_VALUE);
 
                du = (MIXERCONTROLDETAILS_UNSIGNED)Marshal.PtrToStructure(
                    pmxcd.paDetails, typeof(MIXERCONTROLDETAILS_UNSIGNED));
 
                vCurrentVol = du.dwValue;
 
                return retValue;
            }
 
            retValue = false;
            return retValue;
        }
 
        private static bool SetVolumeControl(int hmixer, MIXERCONTROL mxc,
            int volume)
        {
            // This function sets the value for a volume control. 
            // Returns True if successful 
 
            bool retValue;
            int rc;
            MIXERCONTROLDETAILS mxcd = new MIXERCONTROLDETAILS();
            MIXERCONTROLDETAILS_UNSIGNED vol = new
                MIXERCONTROLDETAILS_UNSIGNED();
 
            mxcd.item = 0;
            mxcd.dwControlID = mxc.dwControlID;
            mxcd.cbStruct = Marshal.SizeOf(mxcd);
            mxcd.cbDetails = Marshal.SizeOf(vol);
 
            // Allocate a buffer for the control value buffer 
            mxcd.cChannels = 1;
            vol.dwValue = volume;
 
            // Copy the data into the control value buffer 
            mxcd.paDetails = Marshal.AllocCoTaskMem(Marshal.SizeOf(
                typeof(MIXERCONTROLDETAILS_UNSIGNED)));
            Marshal.StructureToPtr(vol, mxcd.paDetails, false);
 
            // Set the control value 
            rc = mixerSetControlDetails(hmixer, ref mxcd,
                MIXER_SETCONTROLDETAILSF_VALUE);
 
            if (MMSYSERR_NOERROR == rc)
            {
                retValue = true;
            }
            else
            {
                retValue = false;
            }
            return retValue;
        }
 
        /// <summary>
        /// 薄仙税 瑳拳聖 亜閃身
        /// </summary>
        /// <returns></returns>
        public static int GetVolume()
        {
            int mixer;
            int currentVol;
            MIXERCONTROL volCtrl = new MIXERCONTROL();
            mixerOpen(out mixer, 0, 0, 0, 0);
            int type = MIXERCONTROL_CONTROLTYPE_VOLUME;
            GetVolumeControl(mixer,
                MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
                currentVol);
            mixerClose(mixer);
 
            return currentVol;
        }
 
        /// <summary>
        /// ボリューム設定
        /// </summary>
        /// <param name="vVolume"></param>
        public static void SetVolume(int vVolume)
        {
            int mixer;
            MIXERCONTROL volCtrl = new MIXERCONTROL();
            int currentVol;
            mixerOpen(out mixer, 0, 0, 0, 0);
            int type = MIXERCONTROL_CONTROLTYPE_VOLUME;
            GetVolumeControl(mixer,
                MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
                currentVol);
            if (vVolume > volCtrl.lMaximum) vVolume = volCtrl.lMaximum;
            if (vVolume < volCtrl.lMinimum) vVolume = volCtrl.lMinimum;
            SetVolumeControl(mixer, volCtrl, vVolume);
            GetVolumeControl(mixer,
                MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
                currentVol);
            if (vVolume != currentVol)
            {
                throw new Exception("Cannot Set Volume");
            }
            mixerClose(mixer);
        }
 
        /// <summary>
        /// ボリュームをパーセントで設定
        /// </summary>
        /// <param name="iPercent"></param>
        public static void SetVolumePercent(int iPercent)
        {
            int iVolumn = 0;
            int mixer;
            int currentVol;
 
            if (iPercent < 0)
                iPercent = 0;
            else if (iPercent > 100)
                iPercent = 100;
 
            MIXERCONTROL volCtrl = new MIXERCONTROL();
            mixerOpen(out mixer, 0, 0, 0, 0);
            int type = MIXERCONTROL_CONTROLTYPE_VOLUME;
            GetVolumeControl(mixer,
                MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
                currentVol);
 
            iVolumn = volCtrl.lMaximum * iPercent / 100;
 
            SetVolumeControl(mixer, volCtrl, iVolumn);
            GetVolumeControl(mixer,
                MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
                currentVol);
            if (iVolumn != currentVol)
            {
                throw new Exception("Cannot Set Volume");
            }
            mixerClose(mixer);
 
        }
 
        /// <summary>
        /// WAVファイルを流す
        /// </summary>
        /// <param name="filename">Wavファイルプルパス</param>
        /// <param name="loop">true:再生成功, false:再生失敗</param>
        public static void PlaySound(string filename, bool loop)
        {
            if (File.Exists(filename))
            {
                if (loop)
                    sndPlaySound(filename, (int)SND.SND_ASYNC | (int)SND.SND_LOOP);
                else
                    sndPlaySound(filename, (int)SND.SND_ASYNC);
            }
        }
 
        private Microsoft.VisualBasic.Devices.Audio audio = new Microsoft.VisualBasic.Devices.Audio();
 
        /// <summary>
        /// 指定したファイルを流す
        /// </summary>
        /// <param name="wavFilePath"></param>
        public void PlaySoundWav(string wavFilePath)
        {
            //バックグラウンドでWAVを再生する
            audio.Play(wavFilePath, Microsoft.VisualBasic.AudioPlayMode.Background);
 
            //次のようにすると、ループ再生される
            //audio.Play(wavFilePath,
            //    Microsoft.VisualBasic.AudioPlayMode.BackgroundLoop);
 
            //次のようにすると、最後まで再生し終えるまで待機する
            //audio.Play(wavFilePath,
            //    Microsoft.VisualBasic.AudioPlayMode.WaitToComplete);
 
            //再生しているWAVを停止する
            audio.Stop();
        }
    }
}
 

화면의 코드는 아래와같다.

using System;
using System.Windows.Forms;
using System.Media;
using Microsoft.VisualBasic;
 
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            Console.Beep();
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            Interaction.Beep();
        }
        
        private void button3_Click(object sender, EventArgs e)
        {
            Console.Beep(10000, 500);
        }
        
        private void button4_Click(object sender, EventArgs e)
        {
            //SystemSounds.Beep.Play();
            //SystemSounds.Exclamation.Play();
            SystemSounds.Question.Play();
            //SystemSounds.Asterisk.Play();
            //SystemSounds.Hand.Play();
        }
 
        private void button5_Click(object sender, EventArgs e)
        {
            SoundUtils.SetVolumePercent(100);
        }
 
        private void button6_Click(object sender, EventArgs e)
        {
            SoundUtils.SetVolumePercent(50);
        }
 
        private void button7_Click(object sender, EventArgs e)
        {
            SoundUtils.SetVolumePercent(0);
        }
 
        private void button8_Click(object sender, EventArgs e)
        {
            SoundUtils.GetVolume();
 
            SoundUtils.SetVolume(100);
        }
    }
}
 

실행시켜보면, 사운드 믹서에 해당어플이 등록되어서 볼륨제어가 가능해진다.

[실행전]

[실행후] & 100% 눌렀을때,

[실행후] & 50% 눌렀을때,

[실행후] & 0% 눌렀을때,

다른어플에 대해서도 어플ID 및 ProcessName 등을 통해서 사운드를 제어할수 있다.

추후과제

어플의 초기 기동시에 전체 권한을 부여받아서 Mute 를 해제하고,

Speaker 의 Sound Volume을 MAX 로 지정하고,

타어플에 대해서는 모든 Volume를 Min 0% 로 지정한 후,

지금의 어플동작을 실시하면, 모든 과제는 해결될 것으로 보여진다.

지금까지 만든 소스는 아래에 첨부한다.

SoundUtils.zip

SoundUtils.zip

password = toshu1203