Red de conocimiento informático - Conocimiento del nombre de dominio - Cómo reproducir música de fondo MP3 en VC++

Cómo reproducir música de fondo MP3 en VC++

Dos clases: CSound, CMusic

*** 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();

}