Cómo reproducir música de fondo MP3 en VC++
*** Hay dos archivos de encabezado y dos archivos cpp:
// Sound.h: Interfaz de la clase CSound.
//
////////////////////////// //////// / //////////////////////////////////////
#if ! definido(AFX_SOUND_H__43D8A7ED_654E_4677_AE58_8D50A0B7BAA0__INCLUDED_)
#define AFX_SOUND_H__43D8A7ED_654E_4677_AE58_8D50A0B7BAA0__INCLUDED_
#if _MSC_VER >1000
#pragma once
#endif // _ MSC_VER > 1000
#include "mmsystem.h"
#pragma comentario (lib, "winmm.
clase CSound
{
long m_device;
MIXERCONTROL m_volCtrl;
privado:
bool CSound::GetDevice(int dev,HMIXER &hmixer);
público:
CSound();
virtual ~CSound();
//operar...
bool GetVolumeControl(HMIXER hmixer,long componenteType,long ctrlType,MIXERCONTROL* mxc);
unsigned GetVolumeValue(HMIXER hmixer,MIXERCONTROL *mxc);
bool SetVolumeValue(HMIXER hmixer,MIXERCONTROL *mxc,volumen largo );
long GetMuteValue(HMIXER hmixer,MIXERCONTROL* mxc);
bool SetMuteValue(HMIXER hmixer,MIXERCONTROL *mxc,bool mute);
unsigned GetVolume (UINT dev);
bool SetVolume(largo desarrollo,largo vol);
bool GetMute(largo desarrollo);
bool SetMute(largo desarrollo,bool sonido=VERDADERO);
};
#endif // ! definido (AFX_SOUND_H__43D8A7ED_654E_4677_AE58_8D50A0B7BAA0__INCLUDED_)
// Sound.cpp: Implementa la clase CSound.
/////////////////////////////////////////////////// //// ///////////////////
#include "stdafx.h"
#include "Sound.h "
#ifdef _DEBUG
#undef THIS_FILE
carácter estático THIS_FILE[]=__FILE__;
#definir nuevo DEBUG_NEW
# endif
/////////////////// ////////////////// //////// /////////////////////////////
// Construcción/Destrucción
/// ////////////////////////////////////// //// //////////// /////////////////
CSound::CSound()
{
m_device=0;
}
CSound::~CSound()
{
}
bool CSound ::GetDevice(int dev,HMIXER &hmixer)
{
switch(dev)
{
caso 1: //WAVE
m_device= MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
pausa;
caso 2：//MIDI
m_device=MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER;
break;
caso 3: //LINE IN / volumen CD
caso 4:
m_device =MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC;
descanso;
caso 5: //Volumen del micrófono
m_device=MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
descanso;
caso 6: //Volumen del amplificador de PC
m_device=MIXERLINE_COMPONENTTYPE_SRC_LINE;
break
Predeterminado: //volumen maestro
m_device=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
}
if( mezcladorOpen(&hmixer,0,0,0,0))
return FALSE;
return TRUE;
}
//establecer volumen
bool CSound::GetVolumeControl(HMIXER hmixer,long componenteType,long ctrlType,MIXERCONTROL* mxc)
{
MIXERLINECONTROLS mxlc;
MIXERLINE mxl
mxl.cbS;
truct = sizeof(mxl);
mxl.dwComponentType = componenteType
if(!mixerGetLineInfo((HMIXEROBJ)hmixer,&mxl,MIXER_ GETLINEINFOF_COMPONENTTYPE))
{
mxlc.cbStruct = sizeof(mxlc);
mxlc.dwLineID = mxl.dwLineID
mxlc.dwControlType = ctrlType; p> mxlc.cControls = 1;
mxlc.cbmxctrl = sizeof(MIXERCONTROL);
mxlc.pamxctrl = mxc; )hmixer,&mxlc,MIXER_GETLINECONTROLSF_ONEBYTYPE)))
Devuelve FALSO
else
Devuelve VERDADERO
}
devuelve FALSO.
Devuelve FALSO;
}
long CSound::GetMuteValue(HMIXER hmixer,MIXERCONTROL* mxc)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
mxcd.hwndOwner = 0
mxcd.cbStruct = sizeof(mxcd); p> mxcd.dwControlID = mxc-> dwControlID;
mxcd.cbDetails = sizeof(mxcdMute);
mxcd.paDetails =
mxcd.cChannels; = 1;
mxcd.cMultipleItems = 0;
if(mixerGetControlDetails((HMIXEROBJ)hmixer,&mxcd,
MIXER_OBJECTF_HMIXER|MIXER_GETCONTROLDETAILSF _VALUE))
return -1;
return mxcdMute.fValue;
}
bool CSound::SetMuteValue(HMIXER hmixer,MIXERCONTROL* mxc,bool mute )
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_BOOLEAN mxcdMute;
mxcdMute.fValue=mute
mxcd; .hwndOwner = 0;
mxcd.dwControlID = mxc->dwControlID;
mxcd.cbStruct = sizeof(mxcd);
mxcd.cbDetails = sizeof( mxcdMute);
mxcd.paDetails = &mxcdMute;
mxcd.cChannels = 1
mxcd.cMultipleItems = 0; >
if(mixerSetControlDetails(( HMIXEROBJ)hmixer,&mxcd,
MIXER_OBJECTF_HMIXER|MIXER_SETCONTROLDETAILSF_VALUE))
devuelve FALSO;
devuelve VERDADERO
}
CSound sin firmar::GetVolumeValue(HMIXER hmixer,MIXERCONTROL *mxc)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_UNSIGNED vol; vol.dwValue=0;
mxcd.hwndOwner = 0;
mxcd.cbStruct = sizeof(mxcd);
d.dwControlID = mxc->dwControlID;
mxcd.cbDetails = sizeof(vol);
mxcd.paDetails =
mxcd.cChannels = 1
if( mezcladorGetControlDetails((HMIXEROBJ)hmixer,&mxcd,MIXER_OBJECTF_HMIXER|MIXER_GETCONTROLDETAILSF_VALUE))
retorno
retorno vol.dwValue
}
bool CSound::SetVolumeValue(HMIXER hmixer,MIXERCONTROL *mxc,volumen largo)
{
MIXERCONTROLDETAILS mxcd;
MIXERCONTROLDETAILS_UNSIGNED vol;
vol.dwValue = volumen;
mxcd.hwndOwner = 0;
mxcd.dwControlID = mxc->dwControlID; p>
mxcd.cbStruct = sizeof(mxcd);
mxcd.cbDetails = sizeof(vol
mxcd.paDetails = &vol;
<); p> mxcd.cChannels = 1;if(mixerSetControlDetails((HMIXEROBJ)hmixer,&mxcd,
MIXER_OBJECTF_HMIXER|MIXER_ SETCONTROLDETAILSF_VALUE))
return FALSE;
return TRUE;
}
//Obtener el volumen del dispositivo
unsigned CSound::GetVolume(UINT dev)
{
unsigned rt=0;
HMIXER hmixer
if(! GetDevice(dev,hmixer))
devuelve 0;
if(!GetVolumeControl(hmixer,m _device,MIXERCONTROL_CONTROLTYPE_VOLUME,&m_volCtrl))
devuelve 0;
rt=GetVolumeValue(hmixer,&m_volCtrl)*100/m_ volCtrl.Bounds.lMaximum;
mezcladorClose(hmixer);
return rt;
}
//Establece el volumen del dispositivo
bool CSound::SetVolume(long dev, long vol)
{
bool rc=FALSE;
HMIXER hmixer;
if(!
if(! GetDevice(dev,hmixer)
)
devuelve FALSO
if( GetVolumeControl(hmixer,m_device,MIXERCONTROL_CONTROLTYPE_VOLUME,&m_volCtrl)))
{
vol=vol *m_volCtrl.Bounds.lMaximum/ 100;
if (SetVolumeValue(hmixer,&m_volCtrl,vol))
rc=TRUE
}
mezcladorClose(hmixer);
return rc
}
// Establecer silencio del dispositivo
bool; CSound::SetMute(long dev,bool sound)
{
bool rc=FALSE;
HMIXER hmixer
if( ! GetDevice(dev,hmixer))
return FALSE;
if(GetVolumeControl(hmixer,m_device,MIXERCONTROL_CONTROLTYPE_MUTE,&m_volCtrl))
if( SetMuteValue(hmixer) ,&m_volCtrl,sonido))
rc=TRUE;
mezcladorClose(hmixer);
return rc; /p>
/Comprueba si el dispositivo está silenciado (mute return TRUE)
bool CSound::GetMute(long dev)
{
long rc=0;
HMIXER hmixer;
if(!GetDevice(dev,hmixer))
return false
if( GetVolumeControl(hmixer,m_device,MIXERCONTROL_CONTROLTYPE_MUTE,& m_volCtrl))
rc=GetMuteValue(hmixer,&.m_volCtrl);
mezcladorClose(hmixer);
Si (rc)
Devuelve verdadero;
Devuelve falso;
}
/////////Música h. archivo de encabezado//////// ////
/* Clase de gestión de reproducción de música**
#ifndef MUSIC_H_WFPB
#define MUSIC_H_WFPB
#include "Sonido.
clase CMusic
{
//público:
// CString estático s_strSong;
privado:
UINT m_devID; //Descripción del dispositivo
MCI_SEEK_PARMS m_mciSeekParms; //Marcar la posición de reproducción
CSound m_sound; //Clase de sonido, utilizada para controlar el sonido
BOOL m_bOpen;
pro
tected：
//Función auxiliar
static CString GetMusicExt(CString file); //Obtener el sufijo de la canción
static bool IsEqual (CString fileExt,CString devExt); //Determina si el formato del sufijo es el mismo (no distingue entre mayúsculas y minúsculas).
public:
// static CString s_strong; //Verificación de ruta de la canción
// static void SetSongFile() //Establecer ruta de la canción
bool estático IsMusic(archivo CString);
CMusic();
~CMusic();
público:
DWORD GetCurPos();
HRESULT Open(CString song);//abrir archivo de canción
void Close() //Cerrar el archivo de canción
void Play(); //Reproduce la canción
void CyclePlay(HWND hWnd);
void Repeat() //Reproduce la canción repetidamente
void Stop( ); //Detener la reproducción
void Seek(DWORD pos);
bool IsEof() // Comprueba si la canción ha terminado
bool; IsOpen();
DWORD GetLength();
void AddVoice(UINT n); //Agregar voz
p> void SubVoice(UINT n); //Disminuir la voz
void SetVoice(UINT n); //Establecer la voz
UINT GetVoice() //Obtener el volumen del sonido
void SetSilent(bool silent=true );/.//Interruptor silencioso
bool IsSilent(); //Está en silencio
};
//CString CMusic ::s_strSong="" ;
#endif //MUSIC_H_WFPB
///////Archivo fuente Music.cpp//////////// //////
#include "StdAfx.h"
#include "music.h"
//Función auxiliar
CString CMusic:: GetMusicExt(archivo CString) // /getSongExtension
{
devuelve el archivo.Right(file.GetLength()-
archivo. ReverseFind('.') -1);
}
bool CMusic::IsEqual(CString fileExt,CString devExt) //Asegúrese de que los formatos de sufijo sean los mismos (no distingue entre mayúsculas y minúsculas) ).
{
int devlen=fileExt.GetLength();
if(devlen!=devExt.GetLength())
Regresar falso;
CString str1=fileExt;
CString str2=devExt;
str1.MakeLower();
str2.
}
//Constructor
CMusic::CMusic()
{
m_devID=0 ;
memset(&m_mciSeekParms,0,sizeof(MCI_SEEK_PARMS));
m_bOpen=false;
}
CMúsica ::~CMúsica()
{
Cerrar();
}