Et les bruitages ?

[bfg]

Bonjour,

dans la doc HuC je vois de quoi piloter le lecteur CD. Mais ça, ça pourrait marcher pour la musique éventuellement. Mais comment fait on des bruitages ? Y à t'il un lib pour ça ? Idem pour de la musique hors CD. Je suppose que c'est possible, mais y a t'il de quoi faire ça en C ?

Merci d'avance.

[touko]

Sous huc de base rien ..

Sinon tu peux utiliser si tu fais un cd-rom, soit l'adpcm ,huc intègre des fonctions pour pouvoir l'utiliser .
Il s'agit d'une option présente que sur cd, et qui te permet de jouer des samples 4 bit 16khz max en mono, et tu disposes d'une mémoire indépendante de 64 ko pour stocker les samples adpcm ..
La lecture des samples se fait sans utiliser de ressources CPU .

Ensuite tu as le dda, c'est la capacité qu'a le circuit audio de jouer des samples 5 bit 15 khz max, mais pour cela il faut que l'intérruption timer soit activée ..
Donc sous huc c'est délicat,et consomme bien plus de CPU que l'adpcm .

Et pour finir tu as une lib faite par des mecs du homebrew ici : http://www.aetherbyte.com/psg.php
C'est prévu pour être facilement intégré à huc ..

Donc perso je pense que tu devrais utiliser l'adpcm, ça oblige de faire un jeu cd-rom, mais pour du son c'est super simple à utiliser.
Si tu veux faire une ROM (donc HuCard), faut programmer directement le psg, mais bon si tu es aussi doué que moi pour le son, oublies

Si malgré tout ça t'interesse la prog du psg tu peux voir ici :
http://www.zeograd.com/download_present ... =en&id=176

Sur cette page : http://www.zeograd.com/creation_downloa ... =en&page=9
tu vas sur Ultimate Huc Sample Player
Celui là est très simple à comprendre, c'est en français en plus il me semble, je l'ai déjà utilisé, le soucis c'est comme j'y connais rien en création de son via un PSG, bah

[bfg]

Bon, ben on va regarder tout ça de prêt !
Sinon des exemples d'adpcm il y à ? (J'avoue pas mis retrouver du tout sur zeograd ...)

Edit : merci de ne pas citer le message precedent. Shubi

[touko]

Non j'ai pas ça sous la main .

Même sous zeograd y'a rien, j'essayerai de te faire ça .

[bfg]

Bon,

j'ai commencé à regarder, c'es tout sauf facile ...

Le plus simple c'est Ultimate Huic Sample. Le problème c'est que le prog d'exemple, je vois bien comment il marche pour un sample ... Mais pour 2 ...

A un moment j'ai l'impression qu'il charge le sample en mémoire, ou dans la banque de son avant la boucle principale :

wave_temp()
{
char temp;
for(temp=0 ; temp<32 ; temp++)
poke(0x0806, sample[temp]);
}

0x0806 je suppose que ça doit balancer dans une entrée qui transfère ou il faut. J'ai essayé de doubler le son, en lui balançant en double en mémoire, nada. Je fonctionne en aveugle là ... Et si il faut balancer un son différent comme ça à chaque action avant de le jouer ça me parait lourd ...

Sinon le mmltest.zip ne link pas ...
#[1] mmltest.s
107 05:A000 lda #PSG_INIT
Undefined symbol in operand field!
111 05:A009 lda #PSG_ON
Undefined symbol in operand field!
122 05:A020 lda #PSG_TRACK
Undefined symbol in operand field!
129 05:A02F lda #PSG_PLAY
Undefined symbol in operand field!
# 4 error(s)

Le Azasel.zip c'est que de l'ASM.

Il reste le squirell2.zip, mais j'arrive pas à jouer les mml en démo. J'ai pas l'impression qu'il le link ou il faut ... Il faut que je bosse là dessus, mais ça joue de la musique à priori, ça joue pas des sons ...

Bref, je sens que je vais ramer comme sur Coleco !!!!!

[bfg]

Sinon pour info, voici un bout de code que je viens de pondre par rapport aux sources codes trouvé, pour jouer DO RE MI FA SOL LA SI ... Mais ça joue comme une crécelle...

Code : Tout sélectionner

#include "huc.h"

/* Pour info */
const int Mus_Notes[]= {
/*	 C		C#	   D	  D#	 E		F	   F#	  G	 	 G#	    A	   A#	  B        */
																   0x0fe4,0x0f00,0x0e28,/*0*/
	0x0d5d,0x0c9d,0x0be7,0x0b3d,0x0a9b,0x0a03,0x0973,0x08eb,0x086a,0x07f2,0x0780,0x0714,/*1*/
	0x06af,0x064f,0x05f4,0x059e,0x054e,0x0502,0x04b9,0x0476,0x0435,0x03f9,0x03c0,0x038a,/*2*/
	0x0357,0x0327,0x02fa,0x02cf,0x02a7,0x0281,0x025d,0x023b,0x021b,0x01fc,0x01e0,0x01c5,/*3*/
	0x01ac,0x0193,0x017d,0x0168,0x0153,0x0140,0x012e,0x011d,0x010d,0x00fe,0x00f0,0x00e3,/*4*/
	0x00d6,0x00ca,0x00be,0x00b4,0x00aa,0x00a0,0x0097,0x008f,0x0087,0x007f,0x0078,0x0071,/*5*/
	0x006b,0x0065,0x005f,0x005a,0x0055,0x0050,0x004b,0x0046,0x0043,0x0040,0x003c,0x0039,/*6*/
	0x0035,0x0032,0x0030,0x002d,0x002a,0x0028,0x0026,0x0024,0x0022,0x0020,0x001e,0x001c,/*7*/
	0x001b
};

const int partoche[] =
{
	0x01ac,0x017d,0x0153,0x0140,0x011d,0x00fe,0x00e3
};

const char sample[]=
{
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff
};

char son,channel;
char compteur;
int current_note;

initchannelwave()
{
	char temp;
	compteur = 0;
	poke(0x0801, 0xFF); /* Met le volume global à fond */
	poke(0x0800, 0);    /* On choisit la voix 1 */
	poke(0x0805, 0x00); /* Le volume de cette voix est à 0 à droite et gauche */
	poke(0x0804, 0x0F); /* On va charger le sample */
	for(temp=0 ; temp<32 ; temp++)  /* Chargement du sample 32 octets */
		poke(0x0806, sample[temp]);
	poke(0x0804, 0x8F); /* Fin de chargement */
	channel=1;
}


playsound()
{

	poke(0x0800, 0x0); /* Channel 0 sélectionnée */
	if (compteur<32 && channel!=0) /* Durée de la note */
		{
			poke(0x0805, 0xff); /*Volume à fond*/
			poke(0x0803, (partoche[current_note]>>8)&0xF); /* On joue la note*/
			poke(0x0802, (partoche[current_note])&0xFF);
		}
	else {poke(0x0805, 0x00);current_note++; /* Volume à 0, on passe à la note suivante*/}

		compteur++;

	if (compteur>32)
		{
		compteur=0;
		son=0;
		}
	put_number(current_note,5,0,0);
}

main()
{

disp_off();
cls();

current_note=0;




disp_on();
vsync(1);

initchannelwave();
son=0;

	for (;;)
	{

		son = 1;
		switch(son)
		{
			case 1:
				playsound();
			break;
		}
		if (current_note==7) current_note = 0;
		vsync(1);

	}

}

Je peux jouer des bruitages par contre maintenant avec le Ultimate HuC Sample, je vais tenter d'encapsuler le truc pour en jouer plusieurs de manière efficace.


EDIT : C'est à devenir fou !! Je tente de refaire de la musique depuis tout à l'heure sans succès, je repart donc du bout de code plus haut, qui fonctionnait, et ça ne fonctionne plus !!! Je n'y comprends rien du tout. Ca va être beaucoup plus compliqué que prévue cette histoire

EDIT2 : Le code source marche ... Je n'explique pas tout, il semble que si je fais planter cette rom, il faut que je charge une autre rom pour réinitialiser le son ... Je comprends rien ... Bon, je vais continuer mes investigations après une bonne nuit de sommeil ...

[bfg]

Bon, j'ai un peu bossé la chose coté PSG.

Voici en 1er code source, une lib non optimisé de ma conception pour jouer des bruitages et des musiques.

Code : Tout sélectionner

#include "huc.h"

#define LOOP	32
#define END		64
#define SILENCE	128


int idx_part_channel0;
int idx_part_channel1;
int idx_part_channel2;
int idx_part_channel3;
int idx_part_channel4;
int *partc0;
int *partc1;
int *partc2;
int *partc3;
int *partc4;
int compteur_part_channel0;
int compteur_part_channel1;
int compteur_part_channel2;
int compteur_part_channel3;
int compteur_part_channel4;
int c0_on;
int c1_on;
int c2_on;
int c3_on;
int c4_on;

/* Initialise la librairie sonore*/
snd_init()
{
c0_on = 0;
c1_on = 0;
c2_on = 0;
c3_on = 0;
c4_on = 0;
compteur_part_channel0 = 0;
compteur_part_channel1 = 0;
compteur_part_channel2 = 0;
compteur_part_channel3 = 0;
compteur_part_channel4 = 0;
idx_part_channel0 = 0;
idx_part_channel1 = 0;
idx_part_channel2 = 0;
idx_part_channel3 = 0;
idx_part_channel4 = 0;
}
/* Se positionne au début de la partition de la voix "c" */
snd_resetPartChannel(c)
int c;
{
	if (c==0) {idx_part_channel0=0;compteur_part_channel0=0;}
	else if (c==1) {idx_part_channel1=0;compteur_part_channel1=0;}
	else if (c==2) {idx_part_channel2=0;compteur_part_channel2=0;}
	else if (c==3) {idx_part_channel3=0;compteur_part_channel3=0;}
	else {idx_part_channel4=0;compteur_part_channel4=0;} /* White noise */
}

/* Affecte une partition "p" à la voix "c" */
snd_setPartChannel(c,p)
int c;
int *p;
{
	if (c==0) {partc0=p;snd_resetPartChannel(c);c0_on=0;}
	else if (c==1) {partc1=p;snd_resetPartChannel(c);c1_on=0;}
	else if (c==2) {partc2=p;snd_resetPartChannel(c);c2_on=0;}
	else if (c==3) {partc3=p;snd_resetPartChannel(c);c3_on=0;}
	else {partc4=p;snd_resetPartChannel(c);c4_on=0;} /* White noise */
}

/* Change le volume global */
snd_setGlobalVolume(v)
int v;
{
	poke(0x0801,v);
}

/* Sélectionne la voix "c" sur laquelle on va travailler */
snd_selectChannel(c)
int c;
{
	if (c==0) poke(0x0800,0);
	else if (c==1) poke(0x0800,2);
	else if (c==2) poke(0x0800,3);
	else if (c==3) poke(0x0800,4);
	else poke(0x0800,5); /* White noise */
	
}

/* Change la balance de la voix courante */
snd_setChannelBalance(v)
int v;
{
	poke(0x0805,v);
}

/* Reset le chargement de sample pour la voix courante */
snd_resetSampleLoad()
{
	poke(0x0804,64);
}

/* Commence le chargement de sample pour la voix courante */
snd_beginSampleLoad()
{
	poke(0x0804, 0);
}

/* Termine le chargement de sample pour la voix courante */
snd_endSampleLoad()
{
	poke(0x0804, 0x8F);
}

/* Charge le sample "sample" pour la voix courante */
snd_loadSample(sample)
int *sample;
{
	int temp;
	   
	for(temp=0 ; temp<32 ; temp++) /* Chargement du sample 32 octets */
         poke(0x0806, sample[temp]);
}

/* Charge un sample "s" dans une voix "c" */
snd_initChannelSample(c,s)
int c;
int *s;
{
   char temp;
   int channel;
   
   	if (c==0) channel=0;
	else if (c==1) channel=2;
	else if (c==2) channel=3;
	else if (c==3) channel=4;
	else channel=5; /* White noise */
   
   snd_setGlobalVolume(255); /* Met le volume global à fond */
   snd_selectChannel(channel);    /* On choisit la voix 1 */
   snd_setChannelBalance(0);
   snd_resetSampleLoad();  /* On reset le chargement du sample */
   snd_beginSampleLoad(); /* On va charger le sample */
   snd_loadSample(s);
   snd_endSampleLoad(); /* Fin de chargement */
   snd_setChannelBalance(255);
}

snd_stopChannel(c)
int c;
{
	if (c==0){c0_on=0;}
	else if (c==1) {c1_on=0;}
	else if (c==2) {c2_on=0;}
	else if (c==3) {c3_on=0;}
	else if (c==4) {c4_on=0;} /* White noise */
}

snd_playChannel(c,p)
int c;
int *p;
{
	snd_setPartChannel(c,p);
	
	if ((c==0) && (c0_on==0) ){partc0=p;snd_resetPartChannel(c);c0_on=1;compteur_part_channel0=0;}
	else if ((c==1)  && (c1_on==0) ){partc1=p;snd_resetPartChannel(c);c1_on=1;compteur_part_channel1=0;}
	else if ((c==2) && (c2_on==0) ) {partc2=p;snd_resetPartChannel(c);c2_on=1;compteur_part_channel2=0;}
	else if ((c==3)  && (c3_on==0) ){partc3=p;snd_resetPartChannel(c);c3_on=1;compteur_part_channel3=0;}
	else if ((c==3)  && (c4_on==0) ){partc4=p;snd_resetPartChannel(c);c4_on=1;compteur_part_channel4=0;} /* White noise */
}
   
/* Joue la partition de la voix "c" */
snd_playsound(c)
int c;
{	
	int *test_on;
	int *idx_part;
	int *compteur_part;
	int *part;
	
	if (c==0)
	{
		test_on = &c0_on;
		idx_part = &idx_part_channel0;
		compteur_part = &compteur_part_channel0;
		part = partc0;
	} else
	if (c==1)
	{
		test_on = &c1_on;
		idx_part = &idx_part_channel1;
		compteur_part = &compteur_part_channel1;
		part = partc1;
	} else
	if (c==2)
	{
		test_on = &c2_on;
		idx_part = &idx_part_channel2;
		compteur_part = &compteur_part_channel2;
		part = partc2;
	} else
	if (c==3)
	{
		test_on = &c3_on;
		idx_part = &idx_part_channel3;
		compteur_part = &compteur_part_channel3;
		part = partc3;
	} else
	if (c==4)
	{
		test_on = &c4_on;
		idx_part = &idx_part_channel4;
		compteur_part = &compteur_part_channel4;
		part = partc4;
	}
		
	if ((*test_on)==1)
	{
		/* Loop */
		if (part[(*idx_part)]==LOOP)
		{
			(*idx_part)=0;
		}
		else
		/* End */
		if (part[(*idx_part)]==END)
		{
			(*idx_part)=0;
			(*test_on)=0;
			(*compteur_part)=0;		
		}
	}
			
	if ((*test_on)==1)
	{
		poke(0x0800, 0x0); /* Channel 0 sélectionnée */
		if ((*compteur_part)<partc0[(*idx_part)]) /* Durée de la note */
		{
			poke(0x0805, 0xff); /*Volume à fond*/
			poke(0x0803, (part[(*idx_part)+1]>>8)&0xF); /* On joue la note*/
			poke(0x0802, (part[(*idx_part)+1])&0xFF);
		}
		else 
		{
			poke(0x0805, 0x00);
			(*idx_part)+=2; /* Volume à 0, on passe à la note suivante*/}
		}

		(*compteur_part)++;

		if ((*compteur_part)>partc0[(*idx_part)])
		{
			(*compteur_part)=0;
		}
}

   
snd_playAll()
{
	snd_playsound(0);
	snd_playsound(1);
	snd_playsound(2);
	snd_playsound(3);
	snd_playsound(4);
}

Et voici comment elle s'utilise :

Code : Tout sélectionner

#include "SndLib.c"

/* Pour info 
 Non utilisé dans cet exemple */
const int Mus_Notes[]= {
/*    C      C#      D     D#    E      F      F#     G        G#       A      A#     B        */
                                                   0x0fe4,0x0f00,0x0e28,/*0*/
   0x0d5d,0x0c9d,0x0be7,0x0b3d,0x0a9b,0x0a03,0x0973,0x08eb,0x086a,0x07f2,0x0780,0x0714,/*1*/
   0x06af,0x064f,0x05f4,0x059e,0x054e,0x0502,0x04b9,0x0476,0x0435,0x03f9,0x03c0,0x038a,/*2*/
   0x0357,0x0327,0x02fa,0x02cf,0x02a7,0x0281,0x025d,0x023b,0x021b,0x01fc,0x01e0,0x01c5,/*3*/
   0x01ac,0x0193,0x017d,0x0168,0x0153,0x0140,0x012e,0x011d,0x010d,0x00fe,0x00f0,0x00e3,/*4*/
   0x00d6,0x00ca,0x00be,0x00b4,0x00aa,0x00a0,0x0097,0x008f,0x0087,0x007f,0x0078,0x0071,/*5*/
   0x006b,0x0065,0x005f,0x005a,0x0055,0x0050,0x004b,0x0046,0x0043,0x0040,0x003c,0x0039,/*6*/
   0x0035,0x0032,0x0030,0x002d,0x002a,0x0028,0x0026,0x0024,0x0022,0x0020,0x001e,0x001c,/*7*/
   0x001b
};

/*
	Commande,Note
	<31 = temps pour jouer une note, Note
	END -> Fin de partition
	LOOP -> Boucle au début de la partition
	SILENCE,durée --> A CODER
*/
const int part_channel0[] =
{
   
   1,0x01ac,1,0x017d,1,0x0153,1,0x0140,1,0x011d,1,0x00fe,1,0x00e3,LOOP
};

const char sin_sample[]=
{
18,22,24,26,28,30,30,
30,30,28,28,26,24,22,18
,12,8,6,4,2,2,0,0,
0,0,2,2,4,6,8,12
};

main()
{

disp_off();
cls();

disp_on();
vsync(1);

snd_init();

/* initialisation du sample sur la voix 0*/
snd_initChannelSample(0,sin_sample);
/* Demande à jouer la voix 0 avec la partition*/
snd_playChannel(0,part_channel0);
	
   for (;;)
   {

		/* A lancer dans la boucle de jeu */
		snd_playAll();
		
      
      vsync(1);satb_update();
		
   }

}

C'est pas encore propre, pas optimisé coté mémoire (utilisation de int partout), mais ça fonctionne. On ne peut pas encore utiliser de silence dans les partitions, mais je vais implémenter le truc.
Si ça peut dépanner quelqu'un, profitez en ...

[touko]

LOL, putin du bosses sur le psg

Pour le psg il faut initialiser les channels avec un type d'onde (carré, triangles, sinus), avant de jouer un son .
Ultimate Huc Sample est simple, il faut utiliser le .pce qui te sert à créer un son, ensuite il te donne le numero de l'onde à mettre dans la voix avant de jouer le son ..

En tout cas c'est pas mal, pour un début, mais franchement je peux pas t'aider ..
Pour l'adpcm il faut que tes samples soit sur 4 bit en 8khz ou 16khz.
Moi j'utilise sox pour convertir mes samples.

Ensuite si tu n'utilise pas d'overlay pour stocker tes samples(donc pas dans le prog principal), il faut utiliser la fonction ad_write il me semble, car j'ai jamais utilisé.
ou alors ad_trans(); si tu stocke tes samples dans un overlay .

Les samples sont ensuite joués avec ad_play();

Perso, et c'est l'avis de tout ceux qui connaise rien en son, l'adpcm est le plus simple (vraiment), mais faut mettre ses sons sur un overlay pour simplifier.

[bfg]

Ben, là j'suis partit sur le PSG, c'est pas trop compliqué pour le Channel 0, mais j'arrive pas à jouer sur les autres Channel. Je met le nouveau source code si jamais quelqu'un essaye et percute le soucis ...

Code : Tout sélectionner

#include "huc.h"

#define LOOP	32
#define END		64
#define SILENCE	128


int idx_part_channel[5];
int *partc0;
int *partc1;
int *partc2;
int *partc3;
int *partc4;
int compteur_part_channel[5];
int c_on[5];

/* Initialise la librairie sonore*/
snd_init()
{
	int i;
	for (i=0;i<5;i++)
	{
		c_on[i]=0;
		compteur_part_channel[i]=0;
		idx_part_channel[i]=0;
		
	}

	}
/* Se positionne au début de la partition de la voix "c" */
snd_resetPartChannel(c)
int c;
{
	idx_part_channel[c] = 0;
	compteur_part_channel[c] = 0;
}

/* Affecte une partition "p" à la voix "c" */
snd_setPartChannel(c,p)
int c;
int *p;
{
	if (c==0) partc0=p;
	else if (c==1) partc1=p;
	else if (c==2) partc2=p;
	else if (c==3) partc3=p;
	else partc4=p;
	
	snd_resetPartChannel(c);
	c_on[c]=0;	
}

/* Change le volume global */
snd_setGlobalVolume(v)
int v;
{
	poke(0x0801,v);
}

/* Sélectionne la voix "c" sur laquelle on va travailler */
snd_selectChannel(c)
int c;
{
	if (c==0) poke(0x0800,0);
	else if (c==1) poke(0x0800,2);
	else if (c==2) poke(0x0800,3);
	else if (c==3) poke(0x0800,4);
	else poke(0x0800,5); /* White noise */
	
	
	
}

/* Change la balance de la voix courante */
snd_setChannelBalance(v)
int v;
{
	poke(0x0805,v);
}

/* Reset le chargement de sample pour la voix courante */
snd_resetSampleLoad()
{
	poke(0x0804,64);
}

/* Commence le chargement de sample pour la voix courante */
snd_beginSampleLoad()
{
	poke(0x0804, 0);
}

/* Termine le chargement de sample pour la voix courante */
snd_endSampleLoad()
{
	poke(0x0804, 0x8F);
}

/* Charge le sample "sample" pour la voix courante */
snd_loadSample(sample)
int *sample;
{
	int temp;
	   
	for(temp=0 ; temp<32 ; temp++) /* Chargement du sample 32 octets */
         poke(0x0806, sample[temp]);
}

/* Charge un sample "s" dans une voix "c" */
snd_initChannelSample(c,s)
int c;
int *s;
{
   char temp;
   int channel;
   
   	if (c==0) channel=0;
	else if (c==1) channel=2;
	else if (c==2) channel=3;
	else if (c==3) channel=4;
	else channel=5; /* White noise */   
   snd_setGlobalVolume(0); /* Met le volume global à fond */
   snd_selectChannel(channel);    /* On choisit la voix 1 */
   snd_setChannelBalance(0);
   snd_resetSampleLoad();  /* On reset le chargement du sample */
   snd_beginSampleLoad(); /* On va charger le sample */
   snd_loadSample(s);
   snd_endSampleLoad(); /* Fin de chargement */
   /*snd_setChannelBalance(255);*/
}

snd_initChannel(c)
int c;
{
   char temp;
   int channel;
   
   	if (c==0) channel=0;
	else if (c==1) channel=2;
	else if (c==2) channel=3;
	else if (c==3) channel=4;
	else channel=5; /* White noise */
   
   snd_setGlobalVolume(0); /* Met le volume global à fond */
   snd_selectChannel(channel);    /* On choisit la voix 1 */
   snd_setChannelBalance(0);   
   snd_setChannelBalance(255);
}

snd_stopChannel(c)
int c;
{
	c_on[c]=0;
}

snd_playChannel(c,p)
int c;
int *p;
{
	if (c_on[c]==0)
	{
		snd_setPartChannel(c,p);
		compteur_part_channel[c]=0;
	
		if (c==0) partc0=p;
		else if (c==1) partc1=p;
		else if (c==2) partc2=p;
		else if (c==3) partc3=p;
		else if (c==4) partc4=p;
		
		snd_resetPartChannel(c);
		c_on[c]=1;
	}
}
   
/* Joue la partition de la voix "c" */
snd_playsound(c)
int c;
{	
	int *part;
	int channel_select;
			
	if (c==0) {part = partc0;channel_select=0;}
	else if (c==1) {part = partc1;channel_select=2;}
	else if (c==2) {part = partc2;channel_select=3;}
	else if (c==3) {part = partc3;channel_select=4;}
	else if (c==4) {part = partc4;channel_select=5;}
		
	if (c_on[c]==1)
	{
		snd_setGlobalVolume(255);
		/* Loop */
		if (part[idx_part_channel[c]]==LOOP)
		{
			idx_part_channel[c]=0;
		}
		else
		/* End */
		if (part[idx_part_channel[c]]==END)
		{
			idx_part_channel[c]=0;
			c_on[c]=0;
			compteur_part_channel[c]=0;					
		}
	}
			
	if (c_on[c]==1)
	{
		poke(0x0800, channel_select); /* Channel 0 sélectionnée */
		if (compteur_part_channel[c]<part[idx_part_channel[c]]) /* Durée de la note */
		{
			poke(0x0805, 0xff); /*Volume à fond --> A paramétrer dans la partition !!*/
			poke(0x0803, (part[idx_part_channel[c]+1]>>8)&0xF); /* On joue la note*/
			poke(0x0802, (part[idx_part_channel[c]+1])&0xFF);
		}
		else 
		{
			poke(0x0805, 0x00);
			idx_part_channel[c]+=2; /* Volume à 0, on passe à la note suivante*/}
		}

		compteur_part_channel[c]++;

		if (compteur_part_channel[c]>part[idx_part_channel[c]])
		{
			compteur_part_channel[c]=0;
		}
}

   
snd_playAll()
{
	snd_playsound(0);
	snd_playsound(1);
	snd_playsound(2);
	snd_playsound(3);
	snd_playsound(4);
}

Et le test :

Code : Tout sélectionner

#include "SndLib.c"

/* Pour info 
 Non utilisé dans cet exemple */
const int Mus_Notes[]= {
/*    C      C#      D     D#    E      F      F#     G        G#       A      A#     B        */
                                                   0x0fe4,0x0f00,0x0e28,/*0*/
   0x0d5d,0x0c9d,0x0be7,0x0b3d,0x0a9b,0x0a03,0x0973,0x08eb,0x086a,0x07f2,0x0780,0x0714,/*1*/
   0x06af,0x064f,0x05f4,0x059e,0x054e,0x0502,0x04b9,0x0476,0x0435,0x03f9,0x03c0,0x038a,/*2*/
   0x0357,0x0327,0x02fa,0x02cf,0x02a7,0x0281,0x025d,0x023b,0x021b,0x01fc,0x01e0,0x01c5,/*3*/
   0x01ac,0x0193,0x017d,0x0168,0x0153,0x0140,0x012e,0x011d,0x010d,0x00fe,0x00f0,0x00e3,/*4*/
   0x00d6,0x00ca,0x00be,0x00b4,0x00aa,0x00a0,0x0097,0x008f,0x0087,0x007f,0x0078,0x0071,/*5*/
   0x006b,0x0065,0x005f,0x005a,0x0055,0x0050,0x004b,0x0046,0x0043,0x0040,0x003c,0x0039,/*6*/
   0x0035,0x0032,0x0030,0x002d,0x002a,0x0028,0x0026,0x0024,0x0022,0x0020,0x001e,0x001c,/*7*/
   0x001b
};

/*
	Commande,Note
	<31 = temps pour jouer une note, Note
	END -> Fin de partition
	LOOP -> Boucle au début de la partition
	SILENCE,durée --> A CODER
	VOLUME,valeur --> A CODER !
*/
const int part_channel0[] =
{
   
   /*1,0x01ac,1,0x017d,1,0x0153,1,0x0140,1,0x011d,1,0x00fe,1,0x00e3,LOOP*/
   10,0x0153,10,0x0140,END
};

const int part_channel1[] =
{
   
   5,0x01ac,5,0x017d,END
};


const char sin_sample[]=
{
18,22,24,26,28,30,30,
30,30,28,28,26,24,22,18
,12,8,6,4,2,2,0,0,
0,0,2,2,4,6,8,12
};

main()
{

disp_off();
cls();

disp_on();
vsync(1);

snd_init();

/* initialisation du sample sur la voix 0*/
snd_initChannelSample(0,sin_sample);
snd_initChannelSample(1,sin_sample);
/* Demande à jouer la voix 0 avec la partition*/


	
   for (;;)
   {

		/* A lancer dans la boucle de jeu */
		
		if (joy(0)&JOY_LEFT) {snd_playChannel(0,part_channel0);}		
		if (joy(0)&JOY_RGHT) {snd_playChannel(1,part_channel1);}	

      snd_playAll();
      vsync(1);satb_update();
		
   }

}

[touko]

J'ai jeté un coup d'oeil et c'est pas simple de s'y retrouver lol ..

Pourquoi tu squizes la voix 1 ??

Sinon j'utilisais ça avant :

Code : Tout sélectionner

* fonctions faites par JyCet */
/* Fonctions made by JyCet  */

/* Modifiées par Moi ;-) */
/* Modified by Me ;-) */

#include "sfx.h"

char channel;

wave_temp(sample_cour2)
    char *sample_cour2;
{
  char temp;

  for(temp = 0 ; temp < 32 ; temp++)
	poke(0x0806, sample_cour2[temp]);
}

initchannelwave(voix,sample_cour1)
            int voix;
			char *sample_cour1;
{
	poke(0x0800, voix);
	poke(0x0805, 0x00);
	poke(0x0804, 0x0F);
	wave_temp(sample_cour1);
	poke(0x0804, 0x8F);
	channel = 1;
}

initchan()
{
	poke(0x0801, 0xFF);
	channel = 0;
}

playsound(volume_cour,son_final_cour,voix,compteur)
    char *volume_cour;
	int  *son_final_cour,voix,*compteur;
{  
	poke(0x0800, voix);
	if (*compteur < 32 && channel)
		{
			poke(0x0805, volume_cour[*compteur]);
			poke(0x0803, (son_final_cour[*compteur] >> 8) & 0xF);
			poke(0x0802, (son_final_cour[(*compteur)++]) & 0xFF);
		}
	else 
     {
       poke(0x0805, 0x00);
       *compteur = 0;
	   son = 0;
     }	 
}

calcul_final_sound(cour_pitch,son_final_cour,note)
             char *cour_pitch;
			 int *son_final_cour,note;
{
	char i;

	for (i = 0;i < 32;i++)
	  son_final_cour[i] = Notes_Mus[(cour_pitch[i] - 127) + note];
}

Code : Tout sélectionner

/* DATA SON par JyCet */

const int Notes_Mus[] = {
/*	 C		C#	   D	  D#	 E		F	   F#	  G	 	 G#	    A	   A#	  B        */
																   0x0fe4,0x0f00,0x0e28,/*0*/
	0x0d5d,0x0c9d,0x0be7,0x0b3d,0x0a9b,0x0a03,0x0973,0x08eb,0x086a,0x07f2,0x0780,0x0714,/*1*/
	0x06af,0x064f,0x05f4,0x059e,0x054e,0x0502,0x04b9,0x0476,0x0435,0x03f9,0x03c0,0x038a,/*2*/
	0x0357,0x0327,0x02fa,0x02cf,0x02a7,0x0281,0x025d,0x023b,0x021b,0x01fc,0x01e0,0x01c5,/*3*/
	0x01ac,0x0193,0x017d,0x0168,0x0153,0x0140,0x012e,0x011d,0x010d,0x00fe,0x00f0,0x00e3,/*4*/
	0x00d6,0x00ca,0x00be,0x00b4,0x00aa,0x00a0,0x0097,0x008f,0x0087,0x007f,0x0078,0x0071,/*5*/
	0x006b,0x0065,0x005f,0x005a,0x0055,0x0050,0x004b,0x0046,0x0043,0x0040,0x003c,0x0039,/*6*/
	0x0035,0x0032,0x0030,0x002d,0x002a,0x0028,0x0026,0x0024,0x0022,0x0020,0x001e,0x001c,/*7*/
	0x001b
};

/*************************************/
/* Parametre son tir vaisseau joueur            */ 
/*************************************/

int son_final[32];
const char sample[] =
{
/*sample # 28*/
0x0f,0x16,0x1b,0x1e,
0x1f,0x1e,0x1b,0x16,
0x0f,0x08,0x04,0x01,
0x00,0x01,0x04,0x08,
0x0f,0x00,0x00,0x00,
0x1f,0x1f,0x1f,0x1f,
0x1c,0x18,0x14,0x10,
0x0c,0x07,0x03,0x00
};

const char volume[] =
{
/*#03 fondu fermeture*/
0xff,0xff,0xee,0xee,0xdd,0xdd,0xcc,0xcc,
0xbb,0xbb,0xaa,0xaa,0x99,0x99,0x88,0x88,
0x77,0x77,0x66,0x66,0x55,0x55,0x44,0x44,
0x33,0x33,0x22,0x22,0x11,0x11,0x00,0x00
};

const char pitch[] =
{
/*#04 -/+ 1 octave */
127,127,127,126,
126,125,124,123,
122,121,120,119,
118,117,116,115,
115,116,117,118,
119,120,121,122,
123,124,125,126,
126,127,127,127
};

/***********************************************/
/* Parametre son explosion aliens              */
/* générée avec la methode et le log de jycet  */ 
/***********************************************/
int son_final_aliens[32];
const char expl_aliens_sample[] =  
{
/*sample # 2E*/
0x0f,0x15,0x19,0x1b,
0x1d,0x1e,0x1f,0x1e,
0x1d,0x1b,0x19,0x15,
0x0f,0x07,0x17,0x0a,
0x14,0x0d,0x12,0x0f,
0x10,0x0a,0x06,0x04,
0x02,0x01,0x00,0x01,
0x02,0x04,0x06,0x0a
};

const char volume_expl_aliens[] = 
{
/*#00 volume maxi constant*/
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
};

const char pitch_expl_aliens[] = 
{
/*#07 modulation*/
127,127,127,129,
127,123,127,131,
127,124,127,130,
127,125,127,129,
129,127,125,127,
130,127,124,127,
131,127,123,127,
129,127,127,127
};

[bfg]

Pourquoi je squizze la voix 1 ? Et bien pour tout faire bugger mon enfant !
Dans la doc j'ai lu (Channel 1 muted) donc j'ai cru je ne sais pourquoi qu'elle n'était pas utilisable ...

Voici le code corrigé qui joue des sons sur 4 voix avec les directions.

Code : Tout sélectionner

#include "huc.h"

#define LOOP	32
#define END		64
#define SILENCE	128


int idx_part_channel[5];
int *partc0;
int *partc1;
int *partc2;
int *partc3;
int *partc4;
int compteur_part_channel[5];
int c_on[5];

/* Initialise la librairie sonore*/
snd_init()
{
	int i;
	for (i=0;i<5;i++)
	{
		c_on[i]=0;
		compteur_part_channel[i]=0;
		idx_part_channel[i]=0;
		
	}

	}
/* Se positionne au début de la partition de la voix "c" */
snd_resetPartChannel(c)
int c;
{
	idx_part_channel[c] = 0;
	compteur_part_channel[c] = 0;
}

/* Affecte une partition "p" à la voix "c" */
snd_setPartChannel(c,p)
int c;
int *p;
{
	if (c==0) partc0=p;
	else if (c==1) partc1=p;
	else if (c==2) partc2=p;
	else if (c==3) partc3=p;
	else partc4=p;
	
	snd_resetPartChannel(c);
	c_on[c]=0;	
}

/* Change le volume global */
snd_setGlobalVolume(v)
int v;
{
	poke(0x0801,v);
}

/* Sélectionne la voix "c" sur laquelle on va travailler */
snd_selectChannel(c)
int c;
{
	poke (0x0800,c);	
}

/* Change la balance de la voix courante */
snd_setChannelBalance(v)
int v;
{
	poke(0x0805,v);
}

/* Reset le chargement de sample pour la voix courante */
snd_resetSampleLoad()
{
	poke(0x0804,64);
}

/* Commence le chargement de sample pour la voix courante */
snd_beginSampleLoad()
{
	poke(0x0804, 0);
}

/* Termine le chargement de sample pour la voix courante */
snd_endSampleLoad()
{
	poke(0x0804, 0x8F);
}

/* Charge le sample "sample" pour la voix courante */
snd_loadSample(sample)
int *sample;
{
	int temp;
	   
	for(temp=0 ; temp<32 ; temp++) /* Chargement du sample 32 octets */
         poke(0x0806, sample[temp]);
}

/* Charge un sample "s" dans une voix "c" */
snd_initChannelSample(c,s)
int c;
int *s;
{
   char temp;
   int channel;
   
   channel = c;
   snd_setGlobalVolume(0); /* Met le volume global à 0 */
   snd_selectChannel(channel);    /* On choisit la voix 1 */
   snd_setChannelBalance(0);
   snd_resetSampleLoad();  /* On reset le chargement du sample */
   snd_beginSampleLoad(); /* On va charger le sample */
   snd_loadSample(s);
   snd_endSampleLoad(); /* Fin de chargement */
   /*snd_setChannelBalance(255);*/
}

snd_initChannel(c)
int c;
{
   char temp;
   int channel;
   
   channel=c;   
   snd_setGlobalVolume(0); /* Met le volume global à fond */
   snd_selectChannel(channel);    /* On choisit la voix 1 */
   snd_setChannelBalance(0);   
   snd_setChannelBalance(255);
}

snd_stopChannel(c)
int c;
{
	c_on[c]=0;
}

snd_playChannel(c,p)
int c;
int *p;
{
	if (c_on[c]==0)
	{
		snd_setPartChannel(c,p);
		compteur_part_channel[c]=0;
	
		if (c==0) partc0=p;
		else if (c==1) partc1=p;
		else if (c==2) partc2=p;
		else if (c==3) partc3=p;
		else if (c==4) partc4=p;
		
		snd_resetPartChannel(c);
		c_on[c]=1;
	}
}
   
/* Joue la partition de la voix "c" */
snd_playsound(c)
int c;
{	
	int *part;
	int channel_select;
			
	if (c==0) {part = partc0;channel_select=0;}
	else if (c==1) {part = partc1;}
	else if (c==2) {part = partc2;}
	else if (c==3) {part = partc3;}
	else if (c==4) {part = partc4;}
	channel_select = c;	
	
	if (c_on[c]==1)
	{
		snd_setGlobalVolume(255);
		/* Loop */
		if (part[idx_part_channel[c]]==LOOP)
		{
			idx_part_channel[c]=0;
		}
		else
		/* End */
		if (part[idx_part_channel[c]]==END)
		{
			idx_part_channel[c]=0;
			c_on[c]=0;
			compteur_part_channel[c]=0;	
			poke(0x0800, channel_select);
			poke(0x0805, 0x00);			
		}
	}
			
	if (c_on[c]==1)
	{		
		poke(0x0800, channel_select); /* Channel 0 sélectionnée */		
		if (compteur_part_channel[c]<part[idx_part_channel[c]]) /* Durée de la note */
		{
			poke(0x0805, 0xff); /*Volume à fond --> A paramétrer dans la partition !!*/
			poke(0x0803, (part[idx_part_channel[c]+1]>>8)&0xF); /* On joue la note*/
			poke(0x0802, (part[idx_part_channel[c]+1])&0xFF);
		}
		else 
		{			
			idx_part_channel[c]+=2; }
		}

		compteur_part_channel[c]++;

		if (compteur_part_channel[c]>part[idx_part_channel[c]])
		{
			/*poke(0x0805, 0x00);*/			/* Volume à 0 --> Fait tout bugger !!!! */
			compteur_part_channel[c]=0;
		}
}

   
snd_playAll()
{
	snd_playsound(0);
	snd_playsound(1);
	snd_playsound(2);
	snd_playsound(3);
	snd_playsound(4);
}

Et le test

Code : Tout sélectionner

#include "SndLib.c"

/* Pour info 
 Non utilisé dans cet exemple */
const int Mus_Notes[]= {
/*    C      C#      D     D#    E      F      F#     G        G#       A      A#     B        */
                                                   0x0fe4,0x0f00,0x0e28,/*0*/
   0x0d5d,0x0c9d,0x0be7,0x0b3d,0x0a9b,0x0a03,0x0973,0x08eb,0x086a,0x07f2,0x0780,0x0714,/*1*/
   0x06af,0x064f,0x05f4,0x059e,0x054e,0x0502,0x04b9,0x0476,0x0435,0x03f9,0x03c0,0x038a,/*2*/
   0x0357,0x0327,0x02fa,0x02cf,0x02a7,0x0281,0x025d,0x023b,0x021b,0x01fc,0x01e0,0x01c5,/*3*/
   0x01ac,0x0193,0x017d,0x0168,0x0153,0x0140,0x012e,0x011d,0x010d,0x00fe,0x00f0,0x00e3,/*4*/
   0x00d6,0x00ca,0x00be,0x00b4,0x00aa,0x00a0,0x0097,0x008f,0x0087,0x007f,0x0078,0x0071,/*5*/
   0x006b,0x0065,0x005f,0x005a,0x0055,0x0050,0x004b,0x0046,0x0043,0x0040,0x003c,0x0039,/*6*/
   0x0035,0x0032,0x0030,0x002d,0x002a,0x0028,0x0026,0x0024,0x0022,0x0020,0x001e,0x001c,/*7*/
   0x001b
};

/*
	Commande,Note
	<31 = temps pour jouer une note, Note
	END -> Fin de partition
	LOOP -> Boucle au début de la partition
	SILENCE,durée --> A CODER
	VOLUME,valeur --> A CODER !
*/
const int part_channel0[] =
{
   
   1,0x01ac,1,0x017d,1,0x0153,1,0x0140,1,0x011d,1,0x00fe,1,0x00e3,END

};

const int part_channel1[] =
{
   
   30,0x01ac,30,0x017d,END
};


const char sin_sample[]=
{
18,22,24,26,28,30,30,
30,30,28,28,26,24,22,18
,12,8,6,4,2,2,0,0,
0,0,2,2,4,6,8,12
};

main()
{

disp_off();
cls();

disp_on();
vsync(1);

snd_init();

/* initialisation du sample sur la voix 0*/
snd_initChannelSample(0,sin_sample);
snd_initChannelSample(1,sin_sample);
snd_initChannelSample(2,sin_sample);
snd_initChannelSample(3,sin_sample);
/* Demande à jouer la voix 0 avec la partition*/


	
   for (;;)
   {

		/* A lancer dans la boucle de jeu */
		
		if (joy(0)&JOY_LEFT) {snd_playChannel(0,part_channel1);}		
		if (joy(0)&JOY_RGHT) {snd_playChannel(1,part_channel1);}	
		if (joy(0)&JOY_UP) {snd_playChannel(2,part_channel0);}		
		if (joy(0)&JOY_DOWN) {snd_playChannel(3,part_channel0);}		

		
      snd_playAll();
      vsync(1);satb_update();
		
   }

}

Plus qu'a gérer quelques codes pour faire baisser le son quand on le veut etc etc ... J'implémente ça dans Lock'n Chase en m'aidant de Utlimate HuC Sample.
Maintenant, j'ai plus qu'a m'acheter une oreille musicale ... Et ça c'est une autre paire de manche ...

[touko]

LOL elle est muted quand tu utilises la synthese FM ..

En tout cas c'est bien tu avances vites ..
Bon y'a pas mal d'optimisations à faire dans ton code (comme la suppression de tes if else)
Moi quand je faisais des test sur le psg, c'est pas de sortir des sons qui posait problème, mais la création des sons, là j'y comprend que dalle ..

[bfg]

Ben je pourrais dégager les if/else, si je pouvais faire des tableaux de pointeurs ... Mais le compilo veux pas