Từ 1 tới 2 trên tổng số 2 kết quả

Đề tài: Thay đổi và lấy âm lượng hệ thống trong lập trình C#

  1. #1
    Ngày gia nhập
    07 2007
    Bài viết
    44

    Mặc định Thay đổi và lấy âm lượng hệ thống trong lập trình C#

    Có ai biết lấy và thay đổi âm lương của hệ thống(Mastervolume) bằng hàm nào không vậy?

    Mình vừa vào trang này _http://www.codeproject.com/audio/alexfmixer.asp
    Mình đã add cái lớp của tác giả vào project của mình(mình chưa include cũng như khái báo biến gì thêm) mình chạy thử F5 thì nó hiện ra lỗi này

    Click vào hình ảnh để lấy hình ảnh lớn

Tên:		loiMixer.jpg
Lần xem:	9
Size:		71.1 KB
ID:		5046

    Ai có thể cho mình biết lỗi gì được không?
    Sữa thế nào đây?

  2. #2
    Ngày gia nhập
    09 2006
    Bài viết
    711

    Đã include <mmsystem.h> vào chưa ?
    Nhớ link với lib winmm.lib: #pragma comment(lib, "winmm.lib");
    Dưới đây là đoạn code C# mà tui tìm được trên máy tui:
    Visual C# Code:
    1. using System;
    2. using System.Runtime.InteropServices;
    3.  
    4. namespace PhidgetTest
    5. {
    6.     public class AudioMixerHelper
    7.     {
    8.         public const int MMSYSERR_NOERROR = 0;
    9.         public const int MAXPNAMELEN = 32;
    10.         public const int MIXER_LONG_NAME_CHARS = 64;
    11.         public const int MIXER_SHORT_NAME_CHARS = 16;
    12.         public const int MIXER_GETLINEINFOF_COMPONENTTYPE = 0x3;
    13.         public const int MIXER_GETCONTROLDETAILSF_VALUE = 0x0;
    14.         public const int MIXER_GETLINECONTROLSF_ONEBYTYPE = 0x2;
    15.         public const int MIXER_SETCONTROLDETAILSF_VALUE = 0x0;
    16.         public const int MIXERLINE_COMPONENTTYPE_DST_FIRST = 0x0;
    17.         public const int MIXERLINE_COMPONENTTYPE_SRC_FIRST = 0x1000;
    18.         public const int MIXERLINE_COMPONENTTYPE_DST_SPEAKERS =
    19.             (MIXERLINE_COMPONENTTYPE_DST_FIRST + 4);
    20.         public const int MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE =
    21.             (MIXERLINE_COMPONENTTYPE_SRC_FIRST + 3);
    22.         public const int MIXERLINE_COMPONENTTYPE_SRC_LINE =
    23.             (MIXERLINE_COMPONENTTYPE_SRC_FIRST + 2);
    24.         public const int MIXERCONTROL_CT_CLASS_FADER = 0x50000000;
    25.         public const int MIXERCONTROL_CT_UNITS_UNSIGNED = 0x30000;
    26.         public const int MIXERCONTROL_CONTROLTYPE_FADER =
    27.             (MIXERCONTROL_CT_CLASS_FADER | MIXERCONTROL_CT_UNITS_UNSIGNED);
    28.         public const int MIXERCONTROL_CONTROLTYPE_VOLUME =
    29.             (MIXERCONTROL_CONTROLTYPE_FADER + 1);
    30.  
    31.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    32.         private static extern int mixerClose(int hmx);
    33.  
    34.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    35.         private static extern int mixerGetControlDetailsA(int hmxobj, ref
    36.                   MIXERCONTROLDETAILS pmxcd, int fdwDetails);
    37.  
    38.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    39.         private static extern int mixerGetDevCapsA(int uMxId, MIXERCAPS
    40.             pmxcaps, int cbmxcaps);
    41.  
    42.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    43.         private static extern int mixerGetID(int hmxobj, int pumxID, int fdwId);
    44.  
    45.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    46.         private static extern int mixerGetLineControlsA(int hmxobj, ref
    47.                   MIXERLINECONTROLS pmxlc, int fdwControls);
    48.  
    49.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    50.         private static extern int mixerGetLineInfoA(int hmxobj, ref
    51.                   MIXERLINE pmxl, int fdwInfo);
    52.  
    53.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    54.         private static extern int mixerGetNumDevs();
    55.  
    56.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    57.         private static extern int mixerMessage(int hmx, int uMsg, int
    58.             dwParam1, int dwParam2);
    59.  
    60.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    61.         private static extern int mixerOpen(out int phmx, int uMxId,
    62.             int dwCallback, int dwInstance, int fdwOpen);
    63.  
    64.         [DllImport("winmm.dll", CharSet = CharSet.Ansi)]
    65.         private static extern int mixerSetControlDetails(int hmxobj, ref
    66.                   MIXERCONTROLDETAILS pmxcd, int fdwDetails);
    67.  
    68.          public struct MIXERCAPS
    69.         {
    70.             public int wMid;
    71.             public int wPid;
    72.             public int vDriverVersion;
    73.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)]
    74.             public string szPname;
    75.             public int fdwSupport;
    76.             public int cDestinations;
    77.         }
    78.  
    79.         public struct MIXERCONTROL
    80.         {
    81.             public int cbStruct;
    82.             public int dwControlID;
    83.             public int dwControlType;
    84.             public int fdwControl;
    85.             public int cMultipleItems;
    86.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_SHORT_NAME_CHARS)]
    87.             public string szShortName;
    88.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_LONG_NAME_CHARS)]
    89.             public string szName;
    90.             public int lMinimum;
    91.             public int lMaximum;
    92.             [MarshalAs(UnmanagedType.U4, SizeConst = 10)]
    93.             public int reserved;
    94.         }
    95.  
    96.         public struct MIXERCONTROLDETAILS
    97.         {
    98.             public int cbStruct;
    99.             public int dwControlID;
    100.             public int cChannels;
    101.             public int item;
    102.             public int cbDetails;
    103.             public IntPtr paDetails;
    104.         }
    105.  
    106.         public struct MIXERCONTROLDETAILS_UNSIGNED
    107.         {
    108.             public int dwValue;
    109.         }
    110.  
    111.         public struct MIXERLINE
    112.         {
    113.             public int cbStruct;
    114.             public int dwDestination;
    115.             public int dwSource;
    116.             public int dwLineID;
    117.             public int fdwLine;
    118.             public int dwUser;
    119.             public int dwComponentType;
    120.             public int cChannels;
    121.             public int cConnections;
    122.             public int cControls;
    123.             [MarshalAs(UnmanagedType.ByValTStr,
    124.                  SizeConst = MIXER_SHORT_NAME_CHARS)]
    125.             public string szShortName;
    126.             [MarshalAs(UnmanagedType.ByValTStr,
    127.                  SizeConst = MIXER_LONG_NAME_CHARS)]
    128.             public string szName;
    129.             public int dwType;
    130.             public int dwDeviceID;
    131.             public int wMid;
    132.             public int wPid;
    133.             public int vDriverVersion;
    134.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)]
    135.             public string szPname;
    136.         }
    137.  
    138.         public struct MIXERLINECONTROLS
    139.         {
    140.             public int cbStruct;
    141.             public int dwLineID;
    142.             public int dwControl;
    143.             public int cControls;
    144.             public int cbmxctrl;
    145.             public IntPtr pamxctrl;
    146.         }
    147.  
    148.         private static bool GetVolumeControl(int hmixer, int componentType,
    149.             int ctrlType, out MIXERCONTROL mxc, out int vCurrentVol)
    150.         {
    151.             // This function attempts to obtain a mixer control.
    152.             // Returns True if successful.
    153.             MIXERLINECONTROLS mxlc = new MIXERLINECONTROLS();
    154.             MIXERLINE mxl = new MIXERLINE();
    155.             MIXERCONTROLDETAILS pmxcd = new MIXERCONTROLDETAILS();
    156.             MIXERCONTROLDETAILS_UNSIGNED du = new MIXERCONTROLDETAILS_UNSIGNED();
    157.             mxc = new MIXERCONTROL();
    158.  
    159.             int rc;
    160.             bool retValue;
    161.  
    162.             vCurrentVol = -1;
    163.  
    164.             mxl.cbStruct = Marshal.SizeOf(mxl);
    165.             mxl.dwComponentType = componentType;
    166.  
    167.             rc = mixerGetLineInfoA(hmixer, ref mxl, MIXER_GETLINEINFOF_COMPONENTTYPE);
    168.             if (MMSYSERR_NOERROR == rc)
    169.             {
    170.                 int sizeofMIXERCONTROL = 152;
    171.                 int ctrl = Marshal.SizeOf(typeof(MIXERCONTROL));
    172.                 mxlc.pamxctrl = Marshal.AllocCoTaskMem(sizeofMIXERCONTROL);
    173.                 mxlc.cbStruct = Marshal.SizeOf(mxlc);
    174.                 mxlc.dwLineID = mxl.dwLineID;
    175.                 mxlc.dwControl = ctrlType;
    176.                 mxlc.cControls = 1;
    177.                 mxlc.cbmxctrl = sizeofMIXERCONTROL;
    178.  
    179.                 // Allocate a buffer for the control
    180.                 mxc.cbStruct = sizeofMIXERCONTROL;
    181.  
    182.                 // Get the control
    183.                 rc = mixerGetLineControlsA(hmixer, ref mxlc, MIXER_GETLINECONTROLSF_ONEBYTYPE);
    184.                 if (MMSYSERR_NOERROR == rc)
    185.                 {
    186.                     retValue = true;
    187.  
    188.                     // Copy the control into the destination structure
    189.                     mxc = (MIXERCONTROL)Marshal.PtrToStructure(mxlc.pamxctrl, typeof(MIXERCONTROL));
    190.                 }
    191.                 else
    192.                 {
    193.                     retValue = false;
    194.                 }
    195.  
    196.                 int sizeofMIXERCONTROLDETAILS = Marshal.SizeOf(typeof(MIXERCONTROLDETAILS));
    197.  
    198.                 int sizeofMIXERCONTROLDETAILS_UNSIGNED =
    199.  
    200.                     Marshal.SizeOf(typeof(MIXERCONTROLDETAILS_UNSIGNED));
    201.  
    202.                 pmxcd.cbStruct = sizeofMIXERCONTROLDETAILS;
    203.  
    204.                 pmxcd.dwControlID = mxc.dwControlID;
    205.  
    206.                 pmxcd.paDetails =
    207.  
    208.  
    209.  
    210.                     Marshal.AllocCoTaskMem(sizeofMIXERCONTROLDETAILS_UNSIGNED);
    211.  
    212.                 pmxcd.cChannels = 1;
    213.  
    214.                 pmxcd.item = 0;
    215.  
    216.                 pmxcd.cbDetails = sizeofMIXERCONTROLDETAILS_UNSIGNED;
    217.  
    218.  
    219.  
    220.                 rc = mixerGetControlDetailsA(hmixer, ref pmxcd,
    221.  
    222.                     MIXER_GETCONTROLDETAILSF_VALUE);
    223.  
    224.  
    225.  
    226.                 du = (MIXERCONTROLDETAILS_UNSIGNED)Marshal.PtrToStructure(
    227.  
    228.                     pmxcd.paDetails, typeof(MIXERCONTROLDETAILS_UNSIGNED));
    229.  
    230.  
    231.  
    232.                 vCurrentVol = du.dwValue;
    233.  
    234.  
    235.  
    236.                 return retValue;
    237.  
    238.             }
    239.  
    240.  
    241.  
    242.             retValue = false;
    243.  
    244.             return retValue;
    245.  
    246.         }
    247.  
    248.  
    249.  
    250.         private static bool SetVolumeControl(int hmixer, MIXERCONTROL mxc,
    251.  
    252.             int volume)
    253.  
    254.         {
    255.  
    256.             // This function sets the value for a volume control.
    257.  
    258.             // Returns True if successful
    259.  
    260.  
    261.  
    262.             bool retValue;
    263.  
    264.             int rc;
    265.  
    266.             MIXERCONTROLDETAILS mxcd = new MIXERCONTROLDETAILS();
    267.  
    268.             MIXERCONTROLDETAILS_UNSIGNED vol = new
    269.  
    270.                 MIXERCONTROLDETAILS_UNSIGNED();
    271.  
    272.  
    273.  
    274.             mxcd.item = 0;
    275.  
    276.             mxcd.dwControlID = mxc.dwControlID;
    277.  
    278.             mxcd.cbStruct = Marshal.SizeOf(mxcd);
    279.  
    280.             mxcd.cbDetails = Marshal.SizeOf(vol);
    281.  
    282.  
    283.  
    284.             // Allocate a buffer for the control value buffer
    285.  
    286.             mxcd.cChannels = 1;
    287.  
    288.             vol.dwValue = volume;
    289.  
    290.  
    291.  
    292.             // Copy the data into the control value buffer
    293.  
    294.             mxcd.paDetails = Marshal.AllocCoTaskMem(Marshal.SizeOf(
    295.  
    296.                 typeof(MIXERCONTROLDETAILS_UNSIGNED)));
    297.  
    298.             Marshal.StructureToPtr(vol, mxcd.paDetails, false);
    299.  
    300.  
    301.  
    302.             // Set the control value
    303.  
    304.             rc = mixerSetControlDetails(hmixer, ref mxcd,
    305.  
    306.                 MIXER_SETCONTROLDETAILSF_VALUE);
    307.  
    308.  
    309.  
    310.             if (MMSYSERR_NOERROR == rc)
    311.  
    312.             {
    313.  
    314.                 retValue = true;
    315.  
    316.             }
    317.  
    318.             else
    319.  
    320.             {
    321.  
    322.                 retValue = false;
    323.  
    324.             } return retValue;
    325.  
    326.         }
    327.  
    328.  
    329.  
    330.         public static int GetVolume()
    331.  
    332.         {
    333.  
    334.             int mixer;
    335.  
    336.             MIXERCONTROL volCtrl = new MIXERCONTROL();
    337.  
    338.             int currentVol;
    339.  
    340.             mixerOpen(out mixer, 0, 0, 0, 0);
    341.  
    342.             int type = MIXERCONTROL_CONTROLTYPE_VOLUME;
    343.  
    344.             GetVolumeControl(mixer,
    345.  
    346.                 MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
    347.  
    348.                         currentVol);
    349.  
    350.             mixerClose(mixer);
    351.  
    352.  
    353.  
    354.             return currentVol;
    355.  
    356.         }
    357.  
    358.  
    359.  
    360.         public static void SetVolume(int vVolume)
    361.  
    362.         {
    363.  
    364.             int mixer;
    365.  
    366.             MIXERCONTROL volCtrl = new MIXERCONTROL();
    367.  
    368.             int currentVol;
    369.  
    370.             mixerOpen(out mixer, 0, 0, 0, 0);
    371.  
    372.             int type = MIXERCONTROL_CONTROLTYPE_VOLUME;
    373.  
    374.             GetVolumeControl(mixer,
    375.  
    376.                 MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
    377.  
    378.                         currentVol);
    379.  
    380.             if (vVolume > volCtrl.lMaximum) vVolume = volCtrl.lMaximum;
    381.  
    382.             if (vVolume < volCtrl.lMinimum) vVolume = volCtrl.lMinimum;
    383.  
    384.             SetVolumeControl(mixer, volCtrl, vVolume);
    385.  
    386.             GetVolumeControl(mixer,
    387.  
    388.                 MIXERLINE_COMPONENTTYPE_DST_SPEAKERS, type, out volCtrl, out
    389.  
    390.                         currentVol);
    391.  
    392.             if (vVolume != currentVol)
    393.  
    394.             {
    395.  
    396.                 throw new Exception("Cannot Set Volume");
    397.  
    398.             }
    399.  
    400.             mixerClose(mixer);
    401.         }
    402.     }
    403. }
    Code C# dài dòng vậy nhưng cậu có thể dể dàng port lại qua C++, ngắn gọn hơn, không declare, mashal gì đó tá lã nữa.
    Tui khuyên cậu nên tự tay port code trên qua C++, sẽ có lợi cho cậu: nâng cao khả năng code, đọc và hiểu tại sao lại làm như vậy, dùng hàm nào, nhớ được trong đầu. Nó sẽ tốt hơn là chỉ biết lấy code có sẵn include vào rồi run mà không biết tại sao, bên trong nó làm cái gì trong đó. Còn nếu lười, code gắng debug từng dòng vào cái lib đó nhiều lần để tìm hiểu. Nếu không lỡ nó có bug thì cậu bó tay hay sau này cậu cần modify để nâng cao tính năng của nó.
    Đã được chỉnh sửa lần cuối bởi TQN : 21-10-2007 lúc 09:23 PM.

Các đề tài tương tự

  1. Kỹ thuật C++ Cách thay đổi 1 giá trị bất kỳ trong tập tin nhị phân, mà không làm thay đổi các phần tử còn lại???
    Gửi bởi bratlove123 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 8
    Bài viết cuối: 11-05-2012, 02:55 PM
  2. Khi thay đổi text trong Combo Box sẽ thay đổi cách hiển thị trong ListView?
    Gửi bởi 0nly trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 3
    Bài viết cuối: 12-03-2012, 09:30 PM
  3. Trả lời: 3
    Bài viết cuối: 08-08-2011, 02:26 PM
  4. Thay đổi màu của cell bị thay đổi trong Data Grid Views
    Gửi bởi tetuonggu trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 6
    Bài viết cuối: 16-10-2009, 10:33 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn