C / C++ Código Fonte Reprodutor de arquivos WAV.

[WCG147]

Código Fonte Reprodutor de arquivos WAV.

Olá pessoal quero compartilhar com vocês um código fonte de um reprodutor de arquivos WAV.

Reprodutor de arquivos WAV

/AVISO: Você precisa de um modelo de memória para executar este ENORME CÓDIGO.

#include "ALLOC.H"
#include "DOS.H"
#include "CONIO.H"
#include "STDIO.H"

void main()
{
 char *name;
 printf("
 Digite o nome do arquivo...:");
 scanf("%s",name);


 playwav(name,1.0);

}


void playwav(char wavefile[14],float delaytime);
struct WaveData {
  unsigned int SoundLength, Frequency;
  char *Sample;
};


struct HeaderType {
  long         RIFF;      //RIFF cabeçalho
  char         NI1 [18];  //Não é importante

  unsigned int Channels;  //Canais 1 = mono; 2 = estéreo
  long         Frequency; //Amostra de frquência
  char         NI2 [6];   //Não é importante
  char         BitRes;    //Bits de resolução 16/08 bit
  char         NI3 [12];  //Não é importante
} Header;





struct WaveData Voice;         //Ponteiro para o arquivo wav


unsigned int    Base;          //Endereço base Sound Blaster


char            WaveFile [25]; //Nome do arquivo para o arquivo wav a ser
played


/ Verifica se uma Sound Blaster existe em um determinado endereço, retorna
   verdadeiro se Sound Blaster for encontrado, falso se não.
/
int ResetDSP(unsigned int Test)
{
  //Redefinir a DSP
  outportb (Test + 0x6, 1);
  delay(10);
  outportb (Test + 0x6, 0);
  delay(10);
  //Verifique se (reset was succesfull
  if ((inportb(Test + 0xE) & 0x80 == 0x80) && (inportb(Test + 0xA) ==
0xAA))
  {
    //DSP foi encontrado
    Base = Test;
    return (1);
  }
  else
    //DSP não foi encontrado
    return (0);
}


/ Enviar um byte para o DSP (Digital Signal Processor) no som
Blaster
/
void WriteDSP(unsigned char Value)
{
  //Aguarde o DSP para estar pronto para aceitar os dados
  while ((inportb(Base + 0xC) & 0x80) == 0x80);
  //Enviar byte

  outportb (Base + 0xC, Value);
}


/ Desempenha uma parte da memória/

void PlayBack (struct WaveData *Wave)
{
  long          LinearAddress;
  unsigned int  Page, OffSet;
  unsigned char TimeConstant;


  TimeConstant = (65536 - (256000000 / Wave->Frequency)) >> 8;
  WriteDSP(0x40);                  //DSP-comando 40h - amostra Set
frequency
  WriteDSP(TimeConstant);          //Escreva constante de tempo


  //Converter ponteiro para o endereço linear
  LinearAddress = FP_SEG (Wave->Sample);
  LinearAddress = (LinearAddress << 4) + FP_OFF (Wave->Sample);
  Page = LinearAddress >> 16;      //Calcular página
  OffSet = LinearAddress & 0xFFFF; //Calcular deslocamento na página
  /*
      Nota - Este procedimento só funciona com o DMA canal 1
  */
  outportb (0x0A, 5);              //Máscara DMA canal 1
  outportb (0x0C, 0);              //Ponteiro byte clara
  outportb (0x0B, 0x49);           //Definir o modo
  /*
      O modo consiste no seguinte:
       0x49 = binário 01 00 10 01
                     | | | |
                     | | | + - DMA canal 01
                     | | +---- Operação de Read (o DSP lê
memória)
                     | +------- Modo de ciclo único
                     +---------- Modo de Bloco
  */


  outportb (0x02, OffSet & 0x100); //Escreva o deslocamento para a DMA
controller
  outportb (0x02, OffSet >> 8);


  outportb (0x83, Page);           //Escrever a página para a DMA
controller


  outportb (0x03, Wave->SoundLength & 0x100);
  outportb (0x03, Wave->SoundLength >> 8);


  outportb (0x0A, 1);              //Desmascarar canal DMA



  WriteDSP(0x14);                  // DSP-comando 14h - Ciclo Único
playback
  WriteDSP(Wave->SoundLength & 0xFF);
  WriteDSP(Wave->SoundLength >> 8);
}


// Carrega um arquivo wav na memória. Este procedimento espera um cabeçalho onda _very_ padrão. 
//Não faz muita checagem de erro.

int LoadVoice (struct WaveData *Voice, char *FileName)
{
  FILE *WAVFile;


  //Se ele não pode ser aberto...
  WAVFile = fopen(FileName, "rb");
  if (WAVFile == NULL) {
    //..exibir mensagem de erro


    return (0);
  }


  //Retorna o tamanho do arquivo de som para o comprimento de menos de 48 bytes. WAV
header
  fseek(WAVFile, 0L, SEEK_END);
  Voice->SoundLength = ftell (WAVFile) - 48;
  fseek(WAVFile, 0L, SEEK_SET);


  //Verifique cabeçalho RIFF
  if (Voice->SoundLength > 32000) {




    if (Voice->SoundLength > 64000) {


      Voice->SoundLength = 64000;
    }
  }
  free(Voice->Sample);
  Voice->Sample = (char *)malloc(Voice->SoundLength); //Atribuir memória
  if (!Voice->Sample) {

    return (0);
  }


  //Carregar os dados da amostra
  fread(&Header, 46, 1, WAVFile);


  //Verifique cabeçalho RIFF
  if (Header.RIFF != 0x46464952) {
    printf ("Não um arquivo wav
");
    return (0);
  }


  //Verifique canais
  if (Header.Channels != 1) {
    printf ("Não é um arquivo wav mono
");
    return (0);
  }


  //Verifique a resolução bit
  if (Header.BitRes != 8) {
    printf ("Não um arquivo wav de 8 bits
");
    return (0);
  }


  Voice->Frequency = Header.Frequency;


  //Carregar os dados da amostra
  fread(Voice->Sample, Voice->SoundLength + 2, 1, WAVFile);


  fclose (WAVFile); //Feche o arquivo


  return (1);
}


void playwav (char wavefile[14], float delaytime  )
{
  delaytime=1.0;
  if (ResetDSP (0x220)) {
    //Em 220h
    printf ("");
  } else {
    if (ResetDSP (0x240)) {

      //Em 240h
      printf ("");
    } else {
      //Ou nenhum
      printf ("");
      return;
    }
  }




  //Carregar o arquivo wav
  if (LoadVoice (&Voice, wavefile)) {


    //Iniciar a reprodução
    PlayBack (&Voice);


    delay(delaytime*1000);


    //Pára-DMA de transferência
    WriteDSP (0xD0);
  }
}

Créditos : Happy Codings.


Espero que gostem.


WCG 147

[#Franco]

Valeu WCG147,quando você me falou que tinha um source de um reprodutor de video só faltei pirar.
kkkkkkkkk valeu cara sempre traga novos source pra o GH....