public void EnviarAmostra(ref ICarenBuffer Param_Buffer, uint Param_CountAudioBytes)
{
//Sincroniza o acesso a lista que contém os buffers de áudio.
lock (SyncList)
{
//Novo buffer a ser adicionado.
ICarenBuffer NewBuffer = new CarenBuffer();
//Cria o buffer com a quantidade de dados validos.
NewBuffer.CreateBuffer(Param_CountAudioBytes);
//Cópia os dados do buffer do dispositivo de áudio para a amostra atual.
NewBuffer.Write(Param_Buffer, 0, Param_CountAudioBytes);
//Reseta a posição do buffer.
NewBuffer.SetPosition(0);
//Define as informações.
NewBuffer.TamanhoValido = Param_CountAudioBytes;
NewBuffer.Tamanho = Param_CountAudioBytes;
//Adiciona na lista.
ListaBuffersAudio.Add(NewBuffer);
}
}
public void ReleaseAllInterfaces()
{
try
{
//Abre um While para liberar todas as amostras pendentes.
while (true)
{
//Verifica se a lista contém amostras ainda pendente.
if (ListaBuffersAudio is not null && ListaBuffersAudio.Count > 0)
{
//Obtém o buffer a ser removido.
ICarenBuffer TempBuffer = ObterProximaAmostra();
//Verifica se é valido e libera os dados.
if (TempBuffer is not null)
{
TempBuffer.ReleaseBuffer();
TempBuffer = null;
}
}
else
{
//Sai do laço.
break;
}
}
/// <summary>
/// Método responsável por criar e preparar o arquivo que vai receber os dados capturados do dispositivo de áudio.
/// </summary>
/// <param name="Param_Url">A url para o arquivo que será criado.</param>
/// <returns></returns>
public CarenResult CriarArquivoWav(String Param_Url)
{
//Variavel que vai retornar o resultado.
CarenResult Resultado = new CarenResult(ResultCode.ER_FAIL, false);
//Variaveis
ICarenBuffer BufferHeaderZero = null;
ulong RefTotalWritten = 0;
//Deleta o arquivo se ja existir.
File.Delete(Param_Url);
//Chama o construtor para criar o arquivo de destino.
myCaptureAudio.StreamFile = new CarenStream(Param_Url, CA_STGMs.CA_STGM_READWRITE, CA_FILE_ATTRIBUTES.CA_FILE_ATTRIBUTE_NORMAL, true);
//Verifica se não houve erro.
if (myCaptureAudio.StreamFile is null)
{
//Define erro na operação.
Resultado.AdicionarCodigo(ResultCode.ER_FAIL, false);
//Sai do método.
goto Done;
}
//Cria um buffer que vai conter o tamanho do HEADER do arquivo Wav, mais preenchidos com zero.
BufferHeaderZero = new CarenBuffer();
BufferHeaderZero.CreateBuffer(MyHeaderInfoFile.HeaderSize);
//Preenche o buffer com Zeros.
BufferHeaderZero.FillBuffer();
//Escreve o tamanho do header no inicio do fluxo para poder reservar.
Resultado = myCaptureAudio.StreamFile.Write(BufferHeaderZero, MyHeaderInfoFile.HeaderSize, ref RefTotalWritten);
//Verifica se obteve sucesso
if (Resultado.StatusCode != ResultCode.SS_OK)
{
//A operação falhou.
//Mostra uma mensagem de erro.
ShowMensagem(
"Ocorreu uma falha ao escrever o HEADER vazio no inicio do fluxo. Mensagem de erro -> "
+ Resultado.ObterMensagem((int)Resultado.HResult), true);
//Sai do método
goto Done;
}
//Define sucesso na operação
Resultado.AdicionarCodigo(ResultCode.SS_OK, true);
Done :;
//Retorna
return(Resultado);
}
public ICarenBuffer ObterProximaAmostra()
{
//Sincroniza o acesso a lista que contém os buffers de áudio.
lock (SyncList)
{
//Variavel a ser retornada.
ICarenBuffer NextBuffer = null;
//Verifica se a lista contém amostras.
if (ListaBuffersAudio.Count <= 0)
{
goto Done; //Nenhuma amostra disponivel.
}
//Obtém a amostra.
NextBuffer = ListaBuffersAudio.ElementAtOrDefault(0);
//Remove o buffer da lista.
ListaBuffersAudio.RemoveAt(0);
Done :;
//Retorna a amostra.
return(NextBuffer);
}
}
/// <summary>
/// Método responsável por criar a task que fica escrevendo os dados no buffer.
/// </summary>
public void IniciarEscritorDados()
{
//Cria o buffer que vai conter as amostras de áudio.
ListaBuffersAudio = new List <ICarenBuffer>(SIZE_INITIAL_BUFFER);
//Cria a task responsável por ficar escrever no arquivo.
Task_EscritorDados = new Task(async() =>
{
//Variaveis
CarenResult Resultado = new CarenResult(ResultCode.ER_FAIL, false);
ICarenBuffer BufferNextWriter = null;
ulong RefTotalWrittenBytes = 0;
uint ActualSamplesWrited = 0;
//Define que o escritor de dados está processando
StatusEscritorDados = true;
//Define o status geral para true.
StatusGeral = true;
//Abre um laço que vai ficar escrevendo os dados no arquivo.
while (StatusEscritorDados)
{
//Verifica se o Status geral não é false.
if (!StatusGeral)
{
//Define que o laço vai sair
StatusEscritorDados = false;
//Sai do laço.
break;
}
//Verifica se tém buffers para serem escritos
if (GetCountBuffersAudio() <= 0)
{
goto Done; //Pula para o Delay.
}
//Remove e obtém o proximo buffer da lista a ser escrito.
BufferNextWriter = ObterProximaAmostra();
//Verifica se a amostra não é nula.
if (BufferNextWriter is null)
{
goto Done; //O buffer é invalido.
}
//Chama o método para escrever os dados no fluxo.
Resultado = myCaptureAudio.StreamFile.Write(BufferNextWriter, BufferNextWriter.TamanhoValido, ref RefTotalWrittenBytes);
//Verifica se não houve erro.
if (Resultado.StatusCode != ResultCode.SS_OK)
{
//A operação de escrita falhou.
//Mostra uma mensagem de erro.
ShowMensagem(
"Ocorreu uma falha ao escrever os dados do buffer de áudio no arquivo de destino. Mensagem de erro -> "
+ Resultado.ObterMensagem((int)Resultado.HResult), true);
//Define que o status geral é false.
StatusGeral = false;
//Define que vai sair do laço.
StatusEscritorDados = false;
}
//Libera o buffer.
BufferNextWriter.ReleaseBuffer();
BufferNextWriter = null;
//Incrementa a quantidade de amostras escritas.
ActualSamplesWrited++;
//Verifica a quantidade e chama o GC se necessário.
if (ActualSamplesWrited >= 300)
{
//Chama o GC.
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
//Reseta a quantidade.
ActualSamplesWrited = 0;
}
//Chama o continue para pular o delay
continue;
Done:;
await Task.Delay(5);
}
//Chama o GC.
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
});
//Inicia o escritor de dados.
Task_EscritorDados.Start();
}