In questo secondo articolo sul portatile di casa Nintendo vedremo come riprodurre i file audio utilizzando le Advanced Sound Libraries. Premetto che si tratteranno di file audio precompilati, ovvero sceglieremo a priori quali files riprodurre ed il programma potrà riprodurre solo quelli. Ma vedremo presto ( spero..) qualcosa di più avanzato unendo il codice qui di seguito con la gestione del file system.

Vedremo ora come riprodurre due tipi di files, mp3 e raw, i primi utilizzati per riprodurre veri e propri brani, i secondi per riprodurre brevi effetti sonori. Inoltre vedremo anche come far riprodurre al Nintendo DS delle note senza la necessità di files audio esterni.

Una nota importante prima di cominciare riguarda la locazione dei file audio: questi devono essere all’interno della cartella data del template del progetto. Se la cartella non esiste createla. Inoltre da porre particolare attenzione alle caratteristiche dei file MP3: questi devono essere 8bit, samplerate massimo 32000 Hz, 80 kbps massimo. Alcuni di questi limiti possono essere sorpassati ma non vi è la necessità. Altri invece possono causare il non funzionamento dell’audio. Potete trovare al termine dell’articolo una breve nota riguardo la conversione di un mp3 per poterlo utilizzare senza problemi. Infine la dimensione totale dei file audio non deve superare i 4MB, in quanto occuperebbero totalmente la dimensione della ram del Nintendo DS.

Organizzeremo questa breve applicazione in 3 modalità, MP3,SFX,PSG, switchabili tramite la pressione della croce direzionale destra e sinistra.

Siccome il listato completo è piuttosto lungo, inserirò il codice man mano che procederò con le spiegazioni.

Inclusioni e inizializzazione variabili

In questa prima porzione includiamo le librerie ed inizializziamo le variabili. Non mi dilungherò su cosa è una struct, per questo argomento vi consiglio di cercarvi un manuale di C o una guida su internet. Successivamente alla struct abbiamo l’inizializzazione delle funzioni che compongono questa applicazione. Queste sono incluse nel file dopo la main class, quindi abbiamo la necessità di dichiararle prima.

  #include <nds.h>
  #include <pa9.h>
  //#include <fat.h>

  // Il file MP3
  #include "milk.h"

  // I files RAW
  #include "sfxa.h"
  #include "sfxb.h"	

  // Struct comprendente le variabili
  typedef struct{
		int rate, newrate, modalita;
    bool autopan;
    u8 lastsfx, duty, pan, fx_mode, usage;
    s32 note;
    char next[4];
    char prev[4];
    char actl[4];
	} AudioData;

  // Inizializzazione funzioni
  void SwitchMode(AudioData * AData);
  void ModeMp3(AudioData * AData);
  void ModeSfx(AudioData * AData);
  void ModePsg(AudioData * AData);
  void RemoveSound(AudioData * AData);

La main class dell’applicazione

La seguente porzione di codice include la main class dell’applicazione. Questa si occupa di inizializzare PALib, Inizializzare ASLib, definire le modalità disponibili, istanziare la struct ed attribuire dei valori iniziali alle sue proprietà, creare il ciclo dell’applicazione.

Nel ciclo dell’applicazione, oltre che inizializzare la visualizzazione di alcune stringhe di testo, inseriamo uno switch sul valore della proprietà modalita: questa viene modificata alla pressione della croce direzionale ( dx e sx ), all’interno della funzion SwitchMode.

In base alla modalità sarà richiamata la funzione relativa alla modalità richiesta.

  int main(int argc, char** argv)
  {
    // Inizializzazione PALib
    PA_Init();
    PA_InitVBL();
    PA_InitText(0, 0);
    PA_InitText(1, 0);

    // Inizializzazione ASLib
    PA_VBLFunctionInit(AS_SoundVBL);
    AS_Init(AS_MODE_MP3 | AS_MODE_SURROUND | AS_MODE_16CH);
    AS_SetDefaultSettings(AS_PCM_8BIT, 11050, AS_SURROUND);

    // Le modalità disponibili
    #define MODALITA_MP3 0
    #define MODALITA_SFX 1
    #define MODALITA_PSG 2

    AudioData Audio;

    // Valori per le proprietà della struct
    Audio.rate = 0;
    Audio.newrate = 0;
    Audio.modalita = MODALITA_MP3;
    Audio.autopan = false;
    Audio.lastsfx = 0;
    Audio.pan = 0;
    Audio.usage = 0;
    Audio.fx_mode = AS_SURROUND;
    strcpy(Audio.next,"SFX");
    strcpy(Audio.prev,"PSG");
    strcpy(Audio.actl,"MP3");    

    // Ciclo dell'applicazione
    while (1){
      // Schermo superiore
      PA_OutputText(1, 0, 3,  "  Esempio ASLib by Razorblade\n");
      PA_OutputText(1, 0, 5,  "       PadLeft e PadRight/n/n"
                              "     per cambiare modalità\n");

      PA_OutputText(1, 0, 20, "  Le modalità sono MP3,SFX,PSG \n");

      // Schermo Inferiore
      PA_OutputText(0, 0, 2,  " http://razorblade.netsons.org\n");

      switch(Audio.modalita){
        // Modalità Mp3
        case MODALITA_MP3: ModeMp3(&Audio); break;
        // Modalità Sfx
        case MODALITA_SFX: ModeSfx(&Audio); break;
        // Modalità Psg
        case MODALITA_PSG: ModePsg(&Audio); break;
      }

      SwitchMode(&Audio);

      // Comando per lo switch
      PA_OutputText(1, 0, 22, "PREV: %s  || %s ||  NEXT: %s\n", Audio.prev, Audio.actl, Audio.next);

      // Sincronizzazione
      PA_WaitForVBL();
    }
    return 0;
  }

Le funzioni SwitchMode e RemoveSound

Si occupa di modificare le modalità la funzione SwitchMode, qui di seguito il suo codice che non merita particolari spiegazioni. La funzione RemoveSound è un helper che rimuove suoni in riproduzione ( se ce ne sono ) al cambio di modalità

	//
  //  SwitchMode
  //  Passa alla modalità successiva
  //

  void SwitchMode(AudioData * AData){
    bool clearScreen = false;

    switch(AData->modalita){
      case MODALITA_MP3:
        strcpy(AData->prev,"PSG");
        strcpy(AData->next,"SFX");
        strcpy(AData->actl,"MP3");
      break;
      case MODALITA_SFX:
        strcpy(AData->prev,"MP3");
        strcpy(AData->next,"PSG");
        strcpy(AData->actl,"SFX");
      break;
      case MODALITA_PSG:
        strcpy(AData->prev,"SFX");
        strcpy(AData->next,"MP3");
        strcpy(AData->actl,"PSG");
      break;
    }

    if ((Pad.Newpress.Right)){
      clearScreen = true;
      RemoveSound(AData);
      AData->modalita = AData->modalita == MODALITA_PSG ? MODALITA_MP3 : (AData->modalita+1);
    }
    if ((Pad.Newpress.Left)) {
      clearScreen = true;
      RemoveSound(AData);
      AData->modalita = AData->modalita == MODALITA_MP3 ? MODALITA_PSG : (AData->modalita-1);
    }
    if(clearScreen){
    	// Rimuoviamo tutti i tasti dallo schermo superiore
    	PA_ClearTextBg(0);
    	PA_ClearTextBg(1);
    }
  }

	//
  //  RemoveSound
  //  Rimuove i suoni inizializzati
  //

  void RemoveSound(AudioData * AData){
    switch(AData->modalita){
      case MODALITA_MP3:
        AS_MP3Stop();
      break;
      case MODALITA_SFX:
      break;
      case MODALITA_PSG:
        PA_PlayPSG(8, 0, 0, 0, 0);
        PA_PlayPSG(9, 0, 0, 0, 0);
      break;
    }
  }

La modalita MP3

Qui di seguito il codice della funzione che gestisce la modalità mp3. Nella blocco successivo al commento ‘controlli’ potete vedere le funzionalità che servono effettivamente a controllare la riproduzione del file audio. In questa modalità potete usare la Stylus per modificare in tempo reale il sample rate. Se per caso vi viene in mente di modificare il calcolo del nuovo samplerate al movimento della stylus fate solo attenzione perchè superando certi limiti sia l’emulatore che la console Nintendo DS crashano ( il calcolo attuale modifica il samplerate al limite gestibile ).

	//
  //  ModeMp3
  //  Gestisce la modalità MP3
  //

  void ModeMp3(AudioData * AData){
    // Mostriamo i comandi su schermo
    PA_OutputText(1, 0, 9,  "   A: play MP3   B: pause MP3\n\n"
                            "X: stop MP3   Y: surround ON/OFF\n\n"
                            "  Stylus : <> pan   ^ v pitch\n\n" );

    // Visualizzazione Sample Rate e Pan
    PA_OutputText(1, 0, 14, " Sample rate : %d   pan : %d  \n", AData->newrate, IPC_Sound->chan[IPC_Sound->mp3.channelL].snd.pan);

    // show surround status
    PA_OutputText(1, 0, 16, "          Surround : %s\n", (IPC_Sound->mp3.delay ? "ON " : "OFF"));
    PA_OutputText(1, 0, 17, "  ( stop e play per applicare )");

    // show playback status
    PA_OutputText(0, 0, 19, "     MP3 Status : ");
    switch (AS_GetMP3Status()) {
      case (MP3ST_STOPPED)      : PA_OutputText(0, 18, 19, "stopped         "); break;
      case (MP3ST_PAUSED)       : PA_OutputText(0, 18, 19, "paused          "); break;
      case (MP3ST_PLAYING)      : PA_OutputText(0, 18, 19, "playing         "); break;
      case (MP3ST_OUT_OF_DATA)  : PA_OutputText(0, 18, 19, "out of data     "); break;
      case (MP3ST_DECODE_ERROR) : PA_OutputText(0, 18, 19, "decoding error  "); break;
      case (MP3ST_INITFAILED)   : PA_OutputText(0, 18, 19, "init failed     "); break;
    }

    // I Controlli
    if (Pad.Newpress.A){
      if (AS_GetMP3Status() & MP3ST_PAUSED) {
        AS_MP3Unpause();
      }else{
        AS_MP3StreamPlay("milk.mp3");
        AS_MP3DirectPlay((u8*)milk, (u32)milk_size);
        AS_SetMP3Loop(true);
        AData->rate = 0;
        AData->newrate = 0;
      }
    }
    if (Pad.Newpress.B){
      AS_MP3Pause();
    }
    if (Pad.Newpress.X){
      AS_MP3Stop();
    }
    if (Pad.Newpress.Y){
      if(IPC_Sound->mp3.delay){
        AS_SetMP3Delay(AS_NO_DELAY);
      }else{
        AS_SetMP3Delay(AS_SURROUND);
      }
    }
    if((Stylus.Held) && AData->rate && (AS_GetMP3Status() & MP3ST_PLAYING)){
      //AData->newrate = (AData->rate + AData->rate/4) - (AData->rate * Stylus.Y / 96 / 4);
      AData->newrate = AData->rate + ((190 - Stylus.Y - 95) * 150);
      AS_SetMP3Rate(AData->newrate);
      AS_SetMP3Pan(Stylus.X / 2);
    }

    // Nuovo Sample Rate
    if(AData->rate == 0 && IPC_Sound->mp3.rate && (AS_GetMP3Status() & MP3ST_PLAYING)) {
      AData->rate = IPC_Sound->mp3.rate;
      AData->newrate = AData->rate;
    }
  }

La modalita SFX

La modalità SFX si occupa di riprodurre i file .raw. In questa modalità includiamo il conteggio dei canali audio impegnati.

	//
  //  ModeSfx
  //  Gestisce la modalità SFX
  //

  void ModeSfx(AudioData * AData){
    // Mostriamo i comandi su schermo
    PA_OutputText(1, 0, 9,  "   A: play SFXA  B: play SFXB \n\n"
                            "  X: autopan ON/OFF Y: FX mode\n" );

    // Visualizza l'utilizzo dei canali, lo stato dell'autopan e l'ultimo suono avviato
    PA_OutputText(1, 0, 13, "      Canali Usati : %d / %d  \n\n", AData->usage, IPC_Sound->num_chan - 1);
    PA_OutputText(1, 0, 15, "        Autopan : %s\n\n", (AData->autopan ? "on " : "off"));
    PA_OutputText(1, 0, 17, "       Last SFX pan : %d  \n", IPC_Sound->chan[AData->lastsfx].snd.pan);

    // Visualizza Modalità FX
    PA_OutputText(1, 0, 19, "     Effetto SFX : %s\n", (AData->fx_mode == AS_SURROUND ? "surround" : ( AData->fx_mode == AS_REVERB ? "reverb  " : "no fx   ")));
    PA_OutputText(1, 0, 20, " ( riavvia SFX per applicare )");

    // I Controlli
    if (Pad.Newpress.A) {
      AData->lastsfx = AS_SoundQuickPlay(sfxa); // Ritorna il canale audio in modo da potergli applicare degli effetti come pan, volume ecc..
    }
    if (Pad.Newpress.B) {
      AData->lastsfx = AS_SoundQuickPlay(sfxb); // Ritorna il canale audio in modo da potergli applicare degli effetti come pan, volume ecc..
    }
    if (Pad.Newpress.X) {
      AData->autopan = !AData->autopan;
    }
    if (Pad.Newpress.Y) {
      if(AData->fx_mode == AS_SURROUND){
        AData->fx_mode = AS_REVERB;
      } else if(AData->fx_mode == AS_REVERB){
        AData->fx_mode = AS_NO_DELAY;
      } else {
        AData->fx_mode = AS_SURROUND;
      }
      // set new default sound settings
      AS_SetDefaultSettings(AS_PCM_8BIT, 11025, AData->fx_mode);
    }      

    // Autopan
    if(AData->autopan){
      AS_SetSoundPan(AData->lastsfx, (++AData->pan > 127 ? 255 - AData->pan : AData->pan));
    }            

    // get the number of busy channels
    AData->usage = 0;
    u8 i;
    for(i = 1; i < IPC_Sound->num_chan; i++){
      if(IPC_Sound->chan[i].busy){
        AData->usage = (AData->usage+1);
      }
    }
  }

La modalita PSG

La modalità PSG si occupa di far riprodurre delle note al Nintendo DS senza la necessità di utilizzare files esterni. Per riprodurre le note possiamo utilizzare la stylus, ed ovviamente cambia la nota al cambiare della posizione

	//
  //  ModePsg
  //  Gestisce la modalità PSG
  //

  void ModePsg(AudioData * AData){
    int C_scale[8] = {33,37,41,44,49,55,62,65}; // Scale for notes in C major scale
    AData->pan = 64;
    PA_OutputText(1, 0, 9,"Usa il pennino per cambiare nota");
    PA_OutputText(1, 0, 12, "     Canali Usati : %d / %d  \n\n", AData->usage, IPC_Sound->num_chan - 1);
		AData->note = C_scale[(Stylus.X>>5)]< <4;
		//pan = (Stylus.Y*0.66);
		AData->pan += Pad.Held.Right-Pad.Held.Left; // Change pan with pad
		AData->duty = Stylus.Y/24; // 0-7

		// Check the stylus presses :
		if (Stylus.Held){
      PA_PlayPSG(8, 127, AData->pan, AData->note, AData->duty);
      PA_PlayPSG(9, 127, AData->pan, AData->note*2, AData->duty);//octave
    }else{
      PA_PlayPSG(8, 0, 0, 0, 0);  // Blank sound
      PA_PlayPSG(9, 0, 0, 0, 0);  // Blank sound
    }	

		// Get the stylus position and show it on screen
		PA_OutputText(1, 0, 15, "Coordinate Pennino XY : %d, %d   ", Stylus.X, Stylus.Y);
		PA_OutputText(1, 0, 17, " Nota : %d  Pan : %d  Duty : %d    ", AData->note, AData->pan, AData->duty);	          

    // get the number of busy channels
    AData->usage = 0;
    u8 i;
    for(i = 1; i < IPC_Sound->num_chan; i++){
      if(IPC_Sound->chan[i].busy){
        AData->usage = (AData->usage+1);
      }
    }
  }

Tutti i codici che abbiamo visto sono delle versioni rivedute dei codici contenuti negli esempi di PALib. Per ulteriori info vi rimando al sito ufficiale.

Nota sulla conversione dei files MP3

Mi è capitato di avere dei problemi a far funzionare a dovere i files MP3. Se anche i vostri mp3 non ne vogliono sapere di funzionare provate ad utilizzare il programma Total Audio Converter, uno dei più completi programmi per la conversione di files audio. Tramite questo programma ho dovuto seguire 2 passaggi per far funzionare l’mp3 finale:

• Conversione dell’mp3 in .wav 8bit
• Conversione del wav risultante in mp3 32000Hz 80Kbps

Potete scaricare un archivio rar contenente l’intero template del progetto cliccando qui.

Termina qui questo tutorial sulla riproduzione dei file audio con il Nintendo DS e le PALib/ASLib, commentate e votate.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

DevKitPro è un tool di sviluppo per la creazone di videogiochi homebrew per Nintendo DS, GameBoy Advance, GP32, Playstation Portable e GameCube.

Possiamo scaricare DevKitPro da questa pagina.

Installazione su sistemi Windows

L’installazione è decisamente semplice in quanto guidata da un installer, che sceglie per noi i componenti da installare in base al sistema per il quale vogliamo sviluppare. L’ultima versione disponibile di questo installer è la 1.4.7. Per procedere all’installazione il consiglio è di inserire l’installer in una directory chiamata DevKitPro, eseguirlo e selezionare l’opzione che mantiene i file da scaricare, in caso avessimo la necessità di reinstalare tutto.

Ogni console richiede i suoi componenti per lo sviluppo, per programmare per il Nintendo DS, il GBA e il GP32 abbiamo bisogno del devkitARM. Per il Gamecube la scelta è il devkitPPC. Infine per la PSP il devkitPSP. Dopo aver proceduto alla selezione per il mantenimento in locale dei files scaricati selezioniamo quindi l’opzione relativa al download del DevKitArm. Non deselezionate nessuno dei componenti che l’installer selezionerà in automatico per voi o avrete milioni di errori.

Una volta scaricati tutti i componenti, l’installer procederà all’installazione vera e propria e la voce DevKitPro comparirà tra i vostri programmi installati, consiglierei di non modificare la path di installazione ( C:/devkitPro ).

PALib, librerie opensource per Nintendo DS

Le Programer Arsenal Libraries, PALib, sono dele librerie per creare giochi homebrew per NIntendo DS. Potete scaricare le librerie dal sito ufficiale.

Scaricato l’installer lanciatelo e installate le librerie nella stessa diretory del DevKitPro ( C:/devkitPro ).

devkitARM_r23 non compatibile

La versione dl devKitArm scaricata dall’installer del devKitPro, la r23 non è compatibile con le PALib al momento in cui scrivo. Per far in modo che tutto funzioni dobbiamo scaricare la versione r21, che possiamo recuperare da sourceforge.

Per effettuare la sostituzone vi cosiglio di entrare in C:/devkitPro, rinominare l’attuale directory devkitARM in devkitARM_r23 ( o quello che vi pare ) ed incollare sempre su C:/devkitPro la versione r21, ovviamente dopo averla scompattata.

Variabili d’ambiente

Affinchè tutto funzioni a dovere non ci rimane altro che modificare una variabile d’ambiente del nostro sistema operativo, aggiungendo 2 percorsi. Cliccate col tasto destro del mouse su Risorse del Computer, selezionate la linguetta ‘avanzate’, guardando in basso dovreste vedere il tasto ‘variabili d’ambiente’. Cliccatelo, comparirà una nuova finestra con due riquadri: quello che interessa a noi è il riquedro in basso, variabili di sistema.

Cerchiamo la voce ‘Path’, clicchiamola 2 volte ( o in alternativa clicchiamo il tasto modifica dopo averla selezionata ), dobbiamo AGGIUNGERE agli eventuali percorsi già esistenti i seguenti percorsi, C:\devkitpro\devkitarm\bin; e c:\devkitPro\msys\bin; .

Verificate che questi percorsi non fossero già esistenti prima di inserirli, quindi date OK fino a chiudere tutte le finestre aperte.

I Template

I template sono dei file che sono richiesti in ogni progetto. All’interno di C:\devkitPro\palib\template potete vedere quali sono questi files. E’ indispensabile che ogni progetto contenga questi files in quanto sono indispensabili per la compilazione. Inoltre ogni progetto dovrebbe contenere le directories contenute nel template. Qui di seguito uno schema di come deve essere composto un template:

• source: è la cartella che contiene i sorgeti, i files .c o .cpp
• data: è la directory che contiene eventuali file media richiesti dal progetto
• include: è la directory che contiene eventuali file di intestazione, i files .h
• logo.bmp: è il logo che sarà visualizzato usando la modalità wireless
• built.bat: file indispensabile per la compilazione
• clean.bat: file indispensabile per la compilazione
• Makefile: file indispensabile per la compilazione

Codice e compilazione

Il linguaggio utilizzato per scrivere software per il Nintendo DS è il C/C++. Insieme al devKitPro è presente un buon editor, il Programmers Notepad. Ora vedremo come creare il classico ‘Hello World’ utilizzando tutto ciò che abbiamo installato.

Hello World

Create su C:\devkitPro una directory e nominatela helloworld. Ora spostatevi su C:\devkitPro\palib\template e copiate i file e le directories del template, tutto ciò che è stato indicato poche righe fa come indispensabile ( ovvero source, data, include, logo.bmp, built.bat, clean.bat, Makefile ) ed incollatelo in C:\devkitPro\helloworld. Eliminate il file main.c all’interno di source. Aprite il Programmers Notepad e selezionate File -> New -> Project. Vi sarà richiesto un nome per il progetto e una directory. Inserite ‘MyFirstProject’ come nome progetto e selezionate C:\devkitPro\helloworld come directory.

Il passo successivo sarà importare i files fisici del template contenuti nella directory helloworld, nel progetto del Programmers Notepad. Per far ciò cliccate col tasto destro del mouse sul nome del progetto e selezionate la voce Add Magic Folder. Selezionate C:\devkitPro\helloworld e cliccate avanti e quindi fine. I file del template saranno aggiunti al vostro progetto.

Codice Sorgente

Qui di seguito il listato del codice sorgente di Hello World che salveremo all’interno di source con il nome di main.c:

main.c

// Hello World function !!

#include <PA9.h> // Includiamo le PAlib

int main(void)	{

	// Inizializzazione delle PAlib e sincronizzazione dello schermo
	PA_Init();
	PA_InitVBL();

	// Inizializzazione del testo
	PA_InitText(1, // Top screen...
				2);	// Use background number 2

	// Output del testo e posizione
	PA_OutputSimpleText(1,1,1,"Hello World !"); // Top screen, tile x = 1, y = 1...

  // Ciclo infinito dell'applicazione
	while(1) 	{
    // Questa funzione deve sempre esserci in quanto aggiorna i registri del NintendoDS
		PA_WaitForVBL();
	}

	return 0;
}

// ricordarsi a questo punto di lasciare una NewLine andando a capo dopo l'ultima parentesi graffa

Questo esempio era già presente tra i moltissimi esempi già inclusi nella cartella examples di palib, il mio scopo era di illustrare la creazione di un progetto che fosse compilabile direttamente dal Programmers Notepad.
Per far comparire il file main.c appena salvato in source nel nostro progetto di Programmers Notepad, all’interno della finestra Projects, clicchiamo col tasto destro sulla directory principale del nostro progetto, helloworld e selezioniamo refresh. Per compilare selezioniamo Tools -> Make o utilizziamo lo shortcut Alt+1, se non abbiamo comesso errori la compilazione andrà a buon fine.

Testare il progetto

Dopo la compilazione otteremo nella directory del progetto due nuovi files, uno dei quali con estensione .nds, quello che ci serve. Apriamo quindi uno dei molti emulatori Nintendo DS presenti al’interno della directory C:\devkitPro\palib\emulators, per esempio utilizziamo l’Ideas, il risultato sarà il seguente:

Termina qui l’articolo relativo all’installazione dell’ambiente di sviluppo homebrew per Nintendo DS. Per dubbi e richieste vi invito a lasciare un commento.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.