1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
| #include "stdafx.h"
#include "bass.h"
#include "bassmix.h"
#include <sstream>
#include <string>
#include <iostream>
#include <random>
#include <time.h>
//#include <wchar.h>
typedef struct {
HSTREAM G_Mixer; //Mixer pour synchro playlist
HSTREAM G_Source;
HANDLE G_Objet;
} WD_BASS_PLAYLIST;
//WD_BASS_PLAYLIST str_retourne;
class Play_list {
private:
// METHODE
int rand_a_b(int a, int b);
int* init_tableau(int a, int b);
void melanger(int* tableau, int taille);
std::string new_file_audio();
static void CALLBACK SyncProc(HSYNC handle, DWORD channel, DWORD data, void *user);
// ATTRIBUTS
WD_BASS_PLAYLIST m_str_playlist;
std::string m_liste_fichier_audio; // Liste des fichiers audio qui composent la Playlist.
const char *m_PlayList;
const int m_nombre_fichier_audio; // Nombre total de fichiers audio dans la play list.
int* m_tab_playlist; // Tableau d'ordre de lecture de la playlist.
int m_cpt_tab; // Position interne de parcours de la playlist.
const bool m_lect_alea; // Flag pour forcer la lecture aléatoire Vrai = Lecture aléatoire - Faux = Lecture chronologique.
DWORD m_mixer;
DWORD m_source;
public:
// METHODES
Play_list(); // Constructeur par défaut
Play_list(const char *m_PlayList, int nombre_fichier_audio, bool lect_alea); // Constructeur surchargé 4 paramètres
~Play_list(); // Destructeur
//void Creer(DWORD P_HDMixer, DWORD P_Nb_File_audio, const char *P_PlayList, DWORD P_len_char, BOOL P_Lect_alea);
WD_BASS_PLAYLIST* Creer();
};
//Constructeur par défaut
Play_list::lay_list() : m_PlayList(0), m_nombre_fichier_audio(0),m_lect_alea(false), m_cpt_tab(0), m_mixer(0), m_source(0)
{
}
// Constructeur avec paramètres
Play_list::lay_list(const char *PlayList, int nombre_fichier_audio, bool lect_alea) : m_PlayList(PlayList), m_nombre_fichier_audio(nombre_fichier_audio),m_lect_alea(lect_alea), m_cpt_tab(0), m_mixer(0), m_source(0)
{
}
// Destructeur
Play_list::~Play_list()
{
}
//FUNCTION RANDOM BORNEE
//----------------------
int Play_list::rand_a_b(int a, int b) {
return rand()%(b-a) + a;
}
//FUNCTION REMPLIR TABLEAU
//------------------------
int* Play_list::init_tableau(int a, int b) {
int taille = b - a+1;
int* resultat=(int*)malloc(taille*sizeof(int));
srand(time(NULL));
// On remplit le tableau chronologiguement
for(int i=0;i<taille;i++){
resultat[i]=i+a;
}
return resultat;
}
//FUNCTION DE MELANGE DE TABLEAU
//------------------------------
void Play_list::melanger(int* tableau, int taille) {
int i=0;
int nombre_tire=0;
int temp=0;
for (i=0;i<taille;i++) {
nombre_tire=this->rand_a_b(0,taille);
temp = tableau[i];
tableau[i] = tableau[nombre_tire];
tableau[nombre_tire] = temp;
}
}
// FUNCTION : Fournis un fichier Audio depuis la PlayList en fonction du tableau de distribution (aléatoire ou chrono)
//------------------------------------------------------------------------------------------------------------------
std::string Play_list::new_file_audio()
{
// Déclaration
int i=1;
[/COLOR] std::istringstream iss(m_liste_fichier_audio);
std::string L_Fichier_audio;
int L_nb_iter; //
//Code
if (this->m_cpt_tab>=this->m_nombre_fichier_audio) this->m_cpt_tab=0;
L_nb_iter = this->m_tab_playlist[this->m_cpt_tab];
while ( std::getline( iss, L_Fichier_audio,';')[COLOR=#0000FF])
{
if (i>=(L_nb_iter)){
this->m_cpt_tab++;
return L_Fichier_audio;
}
i++;
}
this->m_cpt_tab++;
return L_Fichier_audio;
}
// FUNCTION DE CALLBACK SPECIFIQUE BASS
//-------------------------------------
void CALLBACK Play_list::SyncProc(HSYNC handle, DWORD channel, DWORD data, void *user)
{
Play_list *self=(Play_list*)user;
HSTREAM l_next_stream=0;
BOOL l_return;
std::string l_fic_audio = self->new_file_audio();
l_next_stream = BASS_StreamCreateFile(false,l_fic_audio.c_str(),0,0,BASS_STREAM_DECODE|BASS_SAMPLE_FLOAT);
l_return = BASS_Mixer_StreamAddChannel(self->m_mixer, l_next_stream, BASS_STREAM_AUTOFREE|BASS_MIXER_NORAMPIN);
l_return = BASS_ChannelSetPosition(self->m_mixer,0,BASS_POS_BYTE);
}
WD_BASS_PLAYLIST* Play_list::Creer()
//void Play_list::Creer(DWORD P_HDMixer, DWORD P_Nb_File_audio, const char *P_PlayList, DWORD P_len_char, BOOL P_Lect_alea)
// Paramètres à passer :
//---------------------
// P_HDMixer est le steam mixer créé pour lire la playlist
// P_Flags paramètres pour (voir doc bass)
// P_Param paramètres pour (voir doc bass)
// P_Nb_File_audio est le nombre de morceaux (fichiers audio) contenu dans la playlist
// *P_PlayList est le pointeur sur P_PlayList qui est la chaine qui contient la liste des fichiers son séparés par un ;
// P_len_char est la longuer de P_PlayList en nombre d'octets
// P_Lect_alea est l'information de lecture aléatoire de la playlist True=1=Lecture aléatoire / False=0=Lecture séquentielle
// Valeur de retour :
//-------------------
// Hstream est le N° Stream créé pour la lecture des fichiers audio
{
m_liste_fichier_audio = m_PlayList;
m_tab_playlist=init_tableau(1,m_nombre_fichier_audio);
// On mélange si lecture aléatoire demandée
//-----------------------------------------
//m_lect_alea = false;
if (this->m_lect_alea) this->melanger(this->m_tab_playlist,this->m_nombre_fichier_audio-1);
std::string First_Fic_Audio = this->new_file_audio();
this->m_mixer = BASS_Mixer_StreamCreate(44100,2,BASS_MIXER_END);
BASS_ChannelSetSync(this->m_mixer,BASS_SYNC_END|BASS_SYNC_MIXTIME,0,this->SyncProc,this);
this->m_source = BASS_StreamCreateFile(false,First_Fic_Audio.c_str(),0,0,BASS_STREAM_DECODE|BASS_SAMPLE_FLOAT); //1st file open
BASS_Mixer_StreamAddChannel(m_mixer,this->m_source,BASS_STREAM_AUTOFREE);
this->m_str_playlist.G_Mixer = this->m_mixer;
this->m_str_playlist.G_Source = this->m_source;
Play_list *const lc_Objet = this;
this->m_str_playlist.G_Objet = static_cast<HANDLE>(lc_Objet);
return &this->m_str_playlist;
}
extern "C" __declspec(dllexport) WD_BASS_PLAYLIST* SynchroPlaylist_Obj(const char *P_PlayList, DWORD P_Nb_File_audio, BOOL P_Lect_alea)
{
Play_list * Playlist_ids;
Playlist_ids = new Play_list(P_PlayList, P_Nb_File_audio,P_Lect_alea);
return Playlist_ids->Creer();
}
extern "C" __declspec(dllexport) bool DeletePlaylist_Obj(Play_list *const id_objet)
{
delete id_objet;
return true;
} |
