Control Speaker Volume - C# Discussion Boards

Re: What is the better approach between IQueryable and IEnumerable ?

15-Feb-11 4:19

So what? The compiler can't enforce intents expressed in documentation. All that matters is that the class provides the signatures required by the interface -- the members don't even need to do anything, or they can throw NotImplementedExceptions for all the compiler cares.

A developer can implement an interface any darn way he likes; an IEnumerable can access a database or a Random or any old thing, an IQueryable can access a Web Service or IME or shared memory, the interfaces don't care. It all depends on what the developer needs to do. It is then up to the user of the class to decide whether or not that class provides the desired information in a useful manner. Other than that, the class is a black box and you shouldn't go poking your fingers in it.

dasblinkenlight15-Feb-11 5:15

dasblinkenlight

15-Feb-11 5:15

There are two sides to interfaces: one for communicating with a compiler, and one for communicating with programmers who read your code. You keep arguing that there's only the first side, pretending the second side does not exist. However, it's there, and I am sure you've been made painfully aware of it on more than one occasion, when the code compiled but did not work.
There are legitimate concerns that compilers simply cannot enforce, yet these concerns do not become less relevant because of it. For example, compilers cannot enforce exact type casts inside fast enumeration loops, but this means only that the programmers should pay more attention.
There is more to implementing an interface than providing implementations to all its methods so that the compiler stops complaining. For example, if you implement IQueryable in a way that reads everything from the database and then filters in memory, you will "provide the desired information", but not "in a useful manner". That does not make your class useless - others may still use it in their code. It's just that they will not be using it in a way they normally use an IQueryable.
I completely agree with your "class is a black box" comment, yet "poking one's finger into a class" is drastically different from understanding the intent behind its implementation.

Re: What is the better approach between IQueryable and IEnumerable ?

PIEBALDconsult15-Feb-11 8:32

Re: What is the better approach between IQueryable and IEnumerable ?

15-Feb-11 8:32

dasblinkenlight wrote:
one for communicating with programmers who read your code

Which is the name of the interface and the signatures of the members -- any intent expressed in other documentation, while instructive, is not part of the contract and may be incorrect or may not have been obeyed by the developer of any particular class that implements the interface. Such documentation should be taken with a shot of tequila.

My own pet peeve with this regard is the documentation of IDataReader, which Microsoft's providers implement in surprising ways.

dasblinkenlight15-Feb-11 9:40

dasblinkenlight

15-Feb-11 9:40

Name+signatures is a good start, but there are other items there that everyone follows:
- Documentation may ask not to pass null or negative values for certain arguments,
- Documentation may ask to pass only sorted collections to certain methods (e.g. a binary search),
- Documentation may ask not to call a method in a particular state (e.g. creating a statement on a closed connection),
- Documentation may ask to call a method in a context of an ambient transaction,
- Documentation may ask not to call a method before calling another method (e.g. obtaining a write lock without releasing a read lock first)
The list goes on and on. I'm sure there are classes and methods with awful documentation, as well as implementations written without regard to the interface documentation (as you mentioned). But that does not mean that all documentation is somehow bad, only that there is some room to grow Smile | :)

Re: What is the better approach between IQueryable and IEnumerable ?

PIEBALDconsult15-Feb-11 10:03

Re: What is the better approach between IQueryable and IEnumerable ?

15-Feb-11 10:03

That sounds like implementation-specific documentation, not interface documentation. One needs to keep the two concepts separate.

PIEBALDconsult15-Feb-11 10:09

15-Feb-11 10:09

dasblinkenlight wrote:
In case of LINQ to SQL, this means pushing the query logic into RDBMS

Which has no bearing on any other particular implementation the OP may be considering.

Control Speaker Volume

Kevin Marois14-Feb-11 8:21

14-Feb-11 8:21

I'm using VS 2010 on Windows 7. I found this code in a Google search, and it compiles and runs, but when I pass in values to SetVolume, there is no change in the sound volume:

public static class Volume
{
    [DllImport("winmm.dll")]
    private static extern int waveOutGetVolume(IntPtr hwo, out uint dwVolume);

    [DllImport("winmm.dll")]
    private static extern int waveOutSetVolume(IntPtr hwo, uint dwVolume);

    public static int GetVolume()
    {
        // By the default set the volume to 0
        uint CurrVol = 0;

        // At this point, CurrVol gets assigned the volume
        waveOutGetVolume(IntPtr.Zero, out CurrVol);
                
        // Calculate the volume
        ushort CalcVol = (ushort)(CurrVol & 0x0000ffff);
                
        // Get the volume on a scale of 1 to 10 (to fit the trackbar)
        int volume = CalcVol / (ushort.MaxValue / 10);

        return volume;
    }

    public static void SetVolume(int Volume)
    {
        // Calculate the volume that's being set
        int NewVolume = ((ushort.MaxValue / 10) * Volume);

        // Set the same volume for both the left and the right channels
        uint NewVolumeAllChannels = (((uint)NewVolume & 0x0000ffff) | ((uint)NewVolume << 16));
                
        // Set the volume
        waveOutSetVolume(IntPtr.Zero, NewVolumeAllChannels);
    }
}

I found a couple of Mixer type projects here on CP, but they're over the top as far as wat I'm looking for. I simply want to change the volume level of the speakers.

Anyone know how to do this?
>

Everything makes sense in someone's mind

DaveyM6914-Feb-11 9:15

14-Feb-11 9:15

I've never used the Wave functions but I have extensively used the MIDI functions that are very similar and in the same dll.
I belive you may need to call WaveOutOpen first to get a valid handle, then call SetVolume using that handle and finally call WaveOutClose, again using that handle.
I haven't looked at the documentation at all so I may be way off base here, but this is the way the stuff I have used works.

Dave

Binging is like googling, it just feels dirtier.
Please take your VB.NET out of our nice case sensitive forum.
Astonish us. Be exceptional. (Pete O'Hanlon)

BTW, in software, hope and pray is not a viable strategy. (Luc Pattyn)

Kevin Marois14-Feb-11 10:27

14-Feb-11 10:27

Could you share some code? I cannot for the life of me find any C# code that handles getting and setting the speaker volume.

Everything makes sense in someone's mind

DaveyM6914-Feb-11 10:58

14-Feb-11 10:58

I've had a play and this seems to work. This is the extent of my testing but I hope it helps!
It's quite a lot of code - welcome to the world of PInvoke. There is more that needs doing such as checking the result of each API call and raising a custom exception if != MMSYSERR_NOERROR etc...

// WAVEFORMATEX.cs
using System.Runtime.InteropServices;

// http://msdn.microsoft.com/en-us/library/dd757713(v=VS.85).aspx
/*
typedef struct {
  WORD  wFormatTag;
  WORD  nChannels;
  DWORD nSamplesPerSec;
  DWORD nAvgBytesPerSec;
  WORD  nBlockAlign;
  WORD  wBitsPerSample;
  WORD  cbSize;
} WAVEFORMATEX;
*/
[StructLayout(LayoutKind.Sequential)]
internal struct WAVEFORMATEX
{
    public short wFormatTag;
    public short nChannels;
    public int nSamplesPerSec;
    public int nAvgBytesPerSec;
    public short nBlockAlign;
    public short wBitsPerSample;
    public short cbSize;
}

// NativeMethods.cs
using System;
using System.Runtime.InteropServices;

// http://msdn.microsoft.com/en-us/library/dd743869(v=VS.85).aspx
/*
void CALLBACK waveOutProc(
HWAVEOUT hwo,
UINT uMsg,
DWORD_PTR dwInstance,
DWORD_PTR dwParam1,
DWORD_PTR dwParam2
);
*/
internal delegate void waveOutProc(
    IntPtr hwo,
    int uMsg,
    IntPtr dwInstance,
    IntPtr dwParam1,
    IntPtr dwParam2);

// http://msdn.microsoft.com/en-us/library/dd743833(v=VS.85).aspx
internal static class NativeMethods
{
    public const int MMSYSERR_NOERROR = 0;
    public const int CALLBACK_FUNCTION = 0x00030000;

    // http://msdn.microsoft.com/en-us/library/dd743866(v=VS.85).aspx
    /*
MMRESULT waveOutOpen(
LPHWAVEOUT phwo,
UINT_PTR uDeviceID,
LPWAVEFORMATEX pwfx,
DWORD_PTR dwCallback,
DWORD_PTR dwCallbackInstance,
DWORD fdwOpen
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutOpen(
        out IntPtr phwo,
        int uDeviceID,
        ref WAVEFORMATEX pwfx,
        waveOutProc dwCallback,
        IntPtr dwCallbackInstance,
        int fdwOpen);

    // http://msdn.microsoft.com/en-us/library/dd743856(v=VS.85).aspx
    /*
MMRESULT waveOutClose(
HWAVEOUT hwo
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutClose(IntPtr hwo);

    // http://msdn.microsoft.com/en-us/library/dd743864(v=VS.85).aspx
    /*
MMRESULT waveOutGetVolume(
HWAVEOUT hwo,
LPDWORD pdwVolume
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutGetVolume(
        IntPtr hwo,
        out uint pdwVolume);

    // http://msdn.microsoft.com/en-us/library/dd743874(v=VS.85).aspx
    /*
MMRESULT waveOutSetVolume(
HWAVEOUT hwo,
DWORD dwVolume
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutSetVolume(
        IntPtr hwo,
        uint dwVolume);
}

// WaveOut.cs
using System;

/// <summary>
/// WaveOut API wrapper
/// </summary>
public class WaveOut : IDisposable
{
    private waveOutProc callback;
    private IntPtr handle;
    private int id;

    public WaveOut(int id)
    {
        callback = new waveOutProc(Callback);
        this.id = id;
    }
    ~WaveOut()
    {
        Dispose(false);
    }

    public int ID
    {
        get { return id; }
    }

    private void Callback(IntPtr hwo, int uMsg, IntPtr dwInstance,
        IntPtr dwParam1, IntPtr dwParam2)
    {
        // check and handle uMsg here
    }
    public void Close()
    {
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutClose(handle);
        handle = IntPtr.Zero;
    }
    public void Dispose()
    {
        Dispose(true);
        // not calling GC.SuppressFinalize(this); so object can be recreated by calling Open();
    }
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // dispose managed resources
        }
        if (handle != IntPtr.Zero)
            Close();
    }
    public uint GetVolume()
    {
        uint volume = uint.MaxValue;
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutGetVolume(handle, out volume);
        return volume;
    }
    public void Open()
    {
        if (handle == IntPtr.Zero)
        {
            WAVEFORMATEX waveFormatEx = new WAVEFORMATEX();
            // CD quality: 2 channel, 44.1KHz 16 bit, PCM
            waveFormatEx.wFormatTag = 1;
            waveFormatEx.nChannels = 2;
            waveFormatEx.nSamplesPerSec = 44100;
            waveFormatEx.wBitsPerSample = 16;
            waveFormatEx.nBlockAlign = (short)(waveFormatEx.nChannels * (waveFormatEx.wBitsPerSample / 8));
            waveFormatEx.nAvgBytesPerSec = waveFormatEx.nSamplesPerSec * waveFormatEx.nBlockAlign;
            NativeMethods.waveOutOpen(out handle, id,
                ref waveFormatEx, callback, IntPtr.Zero,
                NativeMethods.CALLBACK_FUNCTION);
        }
    }
    public void SetVolume(uint volume)
    {
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutSetVolume(handle, volume);
    }
}

// Test.cs
using System;

internal class Test
{
    private static void ConvertFromVolume(uint volume, out int left, out int right)
    {
        left = (int)volume & 0xFFFF;
        right = (int)(volume >> 16) & 0xFFFF;
    }
    private static uint ConvertToVolume(int left, int right)
    {
        return (uint)right << 16 | (ushort)left;
    }
    public void Run()
    {
        // First device wil have ID of 0
        WaveOut waveOut = new WaveOut(0);

        // Open device
        waveOut.Open();

        // Get and save current volume
        int originalLeft;
        int originalRight;
        ConvertFromVolume(waveOut.GetVolume(), out originalLeft, out originalRight);
        // Write values
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            originalLeft, originalRight);

        // Set new volume
        int newLeft = 32768;
        int newRight = 32768;
        waveOut.SetVolume(ConvertToVolume(newLeft, newRight));

        // Get and write values
        ConvertFromVolume(waveOut.GetVolume(), out newLeft, out newLeft);
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            newLeft, newLeft);

        // Reset to original
        waveOut.SetVolume(ConvertToVolume(originalLeft, originalRight));

        // Get and write values
        ConvertFromVolume(waveOut.GetVolume(), out newLeft, out newLeft);
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            newLeft, newLeft);

        // Close device
        waveOut.Close();
    }
}

// Program.cs
using System;

class Program
{
    static void Main(string[] args)
    {
        new Test().Run();

        // Pause
        Console.ReadKey();
    }
}

Kevin Marois14-Feb-11 11:03

14-Feb-11 11:03

Thanks, I'll have a go at it.

Everything makes sense in someone's mind

Kevin Marois14-Feb-11 11:36

14-Feb-11 11:36

Ok, I've coded it.

What should be happening when I run this?

Everything makes sense in someone's mind

DaveyM6914-Feb-11 11:45

14-Feb-11 11:45

When I run it on my system it
1. retrieves the original volume
2. then changes it and retrieves it agin to show it is changed.
3. It then sets it back to the original and retrieves it again to it has been changed back.

If you remove step 3 it should remain changed to whatever you set it to in 2. Check out the code in Test.Run(), I have commented it all.

Kevin Marois14-Feb-11 11:49

14-Feb-11 11:49

Ok, that's what I figred should be happening.

I'm listening to music right now via headphones. When I run this, the sound level doesn't change.

Everything makes sense in someone's mind

DaveyM6914-Feb-11 11:58

14-Feb-11 11:58

I haven't actually tested it with audio - just the values from GetVolume so I see that the driver has responded. There could be one of two things here...
1. The device ID needs to be the correct one for the device who's volume you want to adjust - I'm not sure without further research how to determine the correct ID for the main audio out device/master
2. Maybe the API only adjusts the volume for the audio stream you play directly - unlikely though.

Edit: you can use waveOutGetNumDevs to get the number of devices and waveOutGetDevCaps in conjuction with WAVEOUTCAPS to get the correct device. Check out this[^] page. If you can't resolve this, let me know and I'll have another look tomorrow, bedtime for me here in the UK - good luck!

DaveyM6914-Feb-11 15:08

14-Feb-11 15:08

Are you using Vista or Windows 7? If so, this[^] may explain why it's not working and a possible workaround?

Edit: Tested demo app and it works!

Kevin Marois15-Feb-11 5:48

15-Feb-11 5:48

Yes, I'm Windows 7.

This app worked. Thank you

Everything makes sense in someone's mind

DaveyM6914-Feb-11 11:04

14-Feb-11 11:04

If the above doesn't help - a search for Audio Mixer C# yielded this[^] - looks good...

Kevin Marois14-Feb-11 11:08