Exemplo n.º 1
0
	void LecteurAudio::joueurLectureMorceau()
	{
		// Si aucun fichier audio n'est actuellement ouvert, on quitte la fonction
		if (!fluxAudio)
		{
			qWarning("Demande de lecture alors qu'aucun fichier n'est ouvert (joueurLectureMorceau - LecteurAudio.cpp)");
			return;
		}

		// Si le lecteur etait a l'arret
		if (etatActuel == arret)
		{
			// L'etat passe a Lecture
			etatActuel = lecture;
			// On initialise le canal audio en commencant la lecture
			canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
			// On se positionne a l'endroit indique par le MJ
			FSOUND_Stream_SetTime(fluxAudio, joueurPositionTemps);
			// On regle le volume
			FSOUND_SetVolume(canalAudio, niveauVolume->value());
		}
		
		// Si le lecteur etait en pause
		else if (etatActuel == pause)
		{
			// L'etat passe a Lecture
			etatActuel = lecture;
			// On reprend la lecture du titre
			FSOUND_SetPaused(canalAudio, false);
		}
		
		// Dans tous les autres cas il s'agit d'une erreur
		else
			qWarning("Demande de lecture d'un titre alors que le lecteur n'est ni en pause, ni a l'arret (joueurLectureMorceau - LecteurAudio.cpp)");
	}
Exemplo n.º 2
0
	void LecteurAudio::appuiLecture(bool etatBouton)
	{
		// Le bouton vient d'etre enfonce
		if (etatBouton)
		{
			// On (re)met en lecture les lecteurs des joueurs
			emettreCommande(lectureMorceau);
			// L'etat passe a Lecture
			etatActuel = lecture;
			// Si le bouton pause etait enfonce il s'agit d'une reprise de pause
			if (actionPause->isChecked())
			{
				// On relache le bouton pause
				actionPause->setChecked(false);
				// On reprend la lecture du titre
				FSOUND_SetPaused(canalAudio, false);
			}

			// Sinon il s'agit d'une premiere lecture
			else
			{
				// On rend inoperant le passage sur un tag : sans cela un tag peut deplacer le curseur de temps entre
				// le lancement de la lecture et le repositionnement dans le temps
				repriseDeLecture = true;
				// On initialise le canal audio en commencant la lecture
				canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
				// On se positionne a l'endroit choisi par l'utilisateur
				FSOUND_Stream_SetTime(fluxAudio, positionTemps->value());
				// On regle le volume
				FSOUND_SetVolume(canalAudio, niveauVolume->value());
				// Le passage sur un tag est a nouveau operationnel
				repriseDeLecture = false;
			}
		}

		// Le bouton vient d'etre relache
		else
		{
			// Le lecteur etait dans l'etat Lecture
			if (etatActuel == lecture)
			{
				// On met en pause les lecteurs des joueurs
				emettreCommande(pauseMorceau);
				// On met le lecteur en Pause
				etatActuel = pause;
				// On enfonce le bouton pause
				actionPause->setChecked(true);
				// On met la lecture en pause
				FSOUND_SetPaused(canalAudio, true);
			}
			
			// Dans les autres cas il y a un probleme
			else
			{
				qWarning("Le bouton lecture etait enfonce alors que le lecteur n'etait pas en en train de lire (appuiLecture - LecteurAudio.cpp)");
				return;
			}
		}
	}
Exemplo n.º 3
0
	void LecteurAudio::changementTempsLecture()
	{
		// On envoie la nouvelle position aux lecteurs des joueurs
		emettreCommande(nouvellePositionMorceau, "", positionTemps->value());

		// Si le lecteur est en lecture ou en pause on le positionne a l'endroit selectionne
		if (etatActuel == lecture || etatActuel == pause)
			FSOUND_Stream_SetTime(fluxAudio, positionTemps->value());
	}
void CAudioManager::SetStreamPositionTime(int id, int position){
  if(m_bValidAudio == false)
    return;

  for(int i = 0; i < m_Stream.size(); i++){
    if(m_Stream[i].AudioID == id){
      FSOUND_Stream_SetTime(m_Stream[i].handle, position);
    }
  }
}
Exemplo n.º 5
0
	void LecteurAudio::joueurChangerPosition(int position)
	{
		// Si aucun fichier audio n'est actuellement ouvert, on quitte la fonction
		if (!fluxAudio)
		{
			qWarning("Demande de changement de position de lecture alors qu'aucun fichier n'est ouvert (joueurChangerPosition - LecteurAudio.cpp)");
			return;
		}
		// On change la position de debut de lecture
		joueurPositionTemps = position;
		// Si le lecteur est en lecture ou en pause on le positionne a l'endroit selectionne
		if (etatActuel == lecture || etatActuel == pause)
			FSOUND_Stream_SetTime(fluxAudio, joueurPositionTemps);
	}
Exemplo n.º 6
0
bool FMODStreamOut::SetTime( int64_t nTimeMS)
{
	return StreamPointer && FSOUND_Stream_SetTime(StreamPointer,(int)nTimeMS);
}
Exemplo n.º 7
0
/*
[
    [DESCRIPTION]
    main entry point into streamer example.

    [PARAMETERS]
    'argc'    Number of command line parameters.
    'argv'    Parameter list
 
    [RETURN_VALUE]
    void

    [REMARKS]

    [SEE_ALSO]
]
*/
int main(int argc, char *argv[])
{
    FSOUND_STREAM *stream;
    FSOUND_SAMPLE *sptr;
    char           key;

    if (FSOUND_GetVersion() < FMOD_VERSION)
    {
        printf("Error : You are using the wrong DLL version!  You should be using FMOD %.02f\n", FMOD_VERSION);
        return 1;
    }

    if (argc < 2)
    {
        printf("-------------------------------------------------------------\n");
        printf("FMOD Streamer example.\n");
        printf("Copyright (c) Firelight Technologies Pty, Ltd, 1999-2004.\n");
        printf("-------------------------------------------------------------\n");
        printf("Syntax: stream infile.[mp2 mp3 wav ogg wma asf]\n\n");
        return 1;
    }

#if defined(WIN32) || defined(_WIN64) || defined(__CYGWIN32__) || defined(__WATCOMC__)
    FSOUND_SetOutput(FSOUND_OUTPUT_WINMM);
#elif defined(__linux__)
    FSOUND_SetOutput(FSOUND_OUTPUT_OSS);
#endif

    // Set custom file callbacks?  This doesnt have to be done, its just here as an example.
    FSOUND_File_SetCallbacks(myopen, myclose, myread, myseek, mytell);

    // ==========================================================================================
    // SELECT DRIVER
    // ==========================================================================================
    {
        long i,driver=0;
        char key;

        // The following list are the drivers for the output method selected above.
        printf("---------------------------------------------------------\n");    
        switch (FSOUND_GetOutput())
        {
            case FSOUND_OUTPUT_NOSOUND:    printf("NoSound"); break;
            case FSOUND_OUTPUT_WINMM:      printf("Windows Multimedia Waveout"); break;
            case FSOUND_OUTPUT_DSOUND:     printf("Direct Sound"); break;
            case FSOUND_OUTPUT_A3D:        printf("A3D"); break;
            case FSOUND_OUTPUT_OSS:        printf("Open Sound System"); break;
            case FSOUND_OUTPUT_ESD:        printf("Enlightenment Sound Daemon"); break;
            case FSOUND_OUTPUT_ALSA:       printf("ALSA"); break;
        };
        printf(" Driver list\n");    
        printf("---------------------------------------------------------\n");    

        for (i=0; i < FSOUND_GetNumDrivers(); i++) 
        {
            printf("%d - %s\n", i+1, FSOUND_GetDriverName(i));    // print driver names
        }
        printf("---------------------------------------------------------\n");    // print driver names
        printf("Press a corresponding number or ESC to quit\n");

        do
        {
            key = getch();
            if (key == 27) exit(0);

            driver = key - '1';
        } while (driver < 0 || driver >= FSOUND_GetNumDrivers());

        FSOUND_SetDriver(driver);                    // Select sound card (0 = default)
    }

    // ==========================================================================================
    // INITIALIZE
    // ==========================================================================================
    if (!FSOUND_Init(44100, 32, 0))
    {
        printf("Error!\n");
        printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
        FSOUND_Close();
        return 1;
    }

    FSOUND_Stream_SetBufferSize(1000);

    // ==========================================================================================
    // OPEN STREAM (use #if 1 for streaming from memory)
    // ==========================================================================================
#if 0
    {
        FILE      *fp;
        int        length;
        char      *data;

        fp = fopen(argv[1], "rb");
        if (!fp)
        {
            printf("Error!\n");
            printf("File Not Found\n");
            FSOUND_Close();
            return 1;
        }
        fseek(fp, 0, SEEK_END);
        length = ftell(fp);
        fseek(fp, 0, SEEK_SET);

        data = (char *)malloc(length);
        fread(data, length, 1, fp);
        fclose(fp);

        stream = FSOUND_Stream_Open(data, FSOUND_NORMAL | FSOUND_MPEGACCURATE | FSOUND_LOADMEMORY, 0, length);

        // The memory pointer MUST remain valid while streaming!
    }
#else

    if (!strnicmp(argv[1], "http:", 5))
    {
        printf("Connecting to %s, please wait (this may take some time)....\n", argv[1]);
    }
    stream = FSOUND_Stream_Open(argv[1], FSOUND_NORMAL | FSOUND_MPEGACCURATE, 0, 0);
    if (!stream)
    {
        printf("Error!\n");
        printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
        FSOUND_Close();

        return 1;
    }

#endif

    // ==========================================================================================
    // SET AN END OF STREAM CALLBACK AND RIFF SYNCH POINTS CALLBACK
    // ==========================================================================================
    FSOUND_Stream_SetEndCallback(stream, endcallback, 0);
    FSOUND_Stream_SetSyncCallback(stream, endcallback, 0);
   

    printf("=========================================================================\n");
    printf("Press SPACE to pause/unpause\n");
    printf("Press 'f'   to fast forward 2 seconds\n");
    printf("Press ESC   to quit\n");
    printf("=========================================================================\n");
    printf("Playing stream...\n\n");
  
    sptr = FSOUND_Stream_GetSample(stream);
    if (sptr)
    {
        int freq;
        FSOUND_Sample_GetDefaults(sptr, &freq, NULL, NULL, NULL);
        printf("Name      : %s\n", FSOUND_Sample_GetName(sptr));
        printf("Frequency : %d\n\n", freq);
    }

    key = 0;
    do
    {
        if (channel < 0)
        {
            // ==========================================================================================
            // PLAY STREAM
            // ==========================================================================================
            channel = FSOUND_Stream_PlayEx(FSOUND_FREE, stream, NULL, TRUE);
            FSOUND_SetPaused(channel, FALSE);
        }

        if (kbhit())
        {
            key = getch();
            if (key == ' ')
            {
                FSOUND_SetPaused(channel, !FSOUND_GetPaused(channel));
            }
            if (key == 'f')
            {
                FSOUND_Stream_SetTime(stream, FSOUND_Stream_GetTime(stream) + 2000);
            }
        }

        printf("pos %6d/%6d time %02d:%02d/%02d:%02d cpu %5.02f%%   \r", FSOUND_Stream_GetPosition(stream), 
                                                                         FSOUND_Stream_GetLength(stream), 
                                                                         FSOUND_Stream_GetTime(stream) / 1000 / 60, 
                                                                         FSOUND_Stream_GetTime(stream) / 1000 % 60, 
                                                                         FSOUND_Stream_GetLengthMs(stream) / 1000 / 60, 
                                                                         FSOUND_Stream_GetLengthMs(stream) / 1000 % 60, 
                                                                         FSOUND_GetCPUUsage());

        Sleep(10);
    
    } while (key != 27);

    printf("\n");

    FSOUND_Stream_Close(stream);

    FSOUND_Close();

    return 0;
}