Comment utiliser ALSA est snd_pcm_writei()?
Quelqu'un peut m'expliquer comment snd_pcm_writei
snd_pcm_sframes_t snd_pcm_writei(snd_pcm_t *pcm, const void *buffer,
snd_pcm_uframes_t size)
fonctionne?
Je l'ai utilisé comme:
for (int i = 0; i < 1; i++) {
f = snd_pcm_writei(handle, buffer, frames);
...
}
L'intégralité du code source à http://pastebin.com/m2f28b578
Est-ce à dire, que je ne devrais pas donner snd_pcm_writei()
le nombre de
toutes les images de buffer
, mais seulement
sample_rate * temps de latence = frames
?
Donc, si j'ai par exemple:
sample_rate = 44100
la latence = 0.5 [s]
all_frames = 100000
Le nombre d'images que je devrais donner à snd_pcm_writei()
serait
sample_rate * temps de latence = images
44100*0.5 = 22050
et le nombre d'itérations de la boucle for doit être?:
(int) 100000/22050 = 4; avec des cadres=22050
et un de plus, mais seulement avec
100000 mod 22050 = 11800
cadres?
Est que la façon dont il fonctionne?
Louise
http://www.alsa-project.org/alsa-doc/alsa-lib/group___p_c_m.html#gf13067c0ebde29118ca05af76e5b17a9
OriginalL'auteur Louise | 2010-02-01
Vous devez vous connecter pour publier un commentaire.
cadres devrait être le nombre d'images (échantillons) vous souhaitez écrire à partir de la mémoire tampon. Votre système de son du pilote commence le transfert de ces échantillons à la carte son droit de suite, et ils seront joués à un taux constant.
Le temps de latence est introduit dans plusieurs endroits. Il y a de la latence des données mises en mémoire tampon par le pilote, en attendant d'être transféré à la carte. Il y a au moins un tampon plein de données qui est en cours de transfert vers la carte à un moment donné, et il y a mise en mémoire tampon sur le côté application, qui est ce que vous semblez préoccupé.
De réduire la latence sur le côté application, vous devez écrire le plus petit tampon qui va travailler pour vous. Si votre application effectue une DSP tâche, qui est généralement une fenêtre de données.
Il n'y a aucun avantage à écrire de petits tampons dans une boucle - juste aller de l'avant et de tout écrire en une seule fois - mais il y a un point important à comprendre: pour réduire le temps de latence, votre application doit écrire le pilote pas plus vite que le pilote est de l'écriture des données de la carte son, ou vous finirez accumulent plus de données et d'accumuler plus de et plus de latence.
Un design qui rend la production de données va de pair avec le pilote audio relativement facile, regardez jack ( http://jackaudio.org/ ), qui est basée sur l'enregistrement d'une fonction de rappel avec le son moteur de lecture. En fait, vous êtes probablement mieux d'utiliser jack au lieu d'essayer de le faire vous-même si vous êtes vraiment préoccupés par le temps de latence.
17000 échantillons est inférieure à une seconde de la lecture. Par l'écriture de la mémoire tampon à plusieurs reprises pour le son du pilote et vous avez l'impression de jouer encore et encore, mais à partir de votre description, il semble que si quelque chose dans votre système empêche le début de la lecture du son. Tout d'abord, entrer dans la mémoire tampon est la bonne chose à faire; vous n'avez pas besoin d'écrire un échantillon plus d'une fois. Deuxièmement, vérifier si votre pilote audio ou carte son ne parvient pas à lire le début de son, essayez de rembourrage votre tampon avec environ une seconde vaut de 0 échantillons au début, et voir si que fait une différence.
Merci beaucoup pour la compensation de tout cela. Maintenant, quand tu en parles, j'ai quelques problèmes avec l'audio lors de la lecture d'ALSA par exemple MPlayer. Les 2 premières secondes ou si rien n'est joué, et puis il joue. Je vais essayer et mise à jour pour Fedora 12, puis essayez de nouveau. Merci encore =)
OriginalL'auteur Ori Pessach
J'ai fait quelques tests afin de déterminer pourquoi
snd_pcm_writei()
ne semble pas fonctionner pour moi à l'aide de plusieurs exemples que j'ai trouvé dans le ALSA tutoriels et ce que j'en avait conclu que les simples exemples ont fait unsnd_pcm_close ()
avant que le son de l'appareil pourrait jouer l'intégralité de flux envoyé.J'ai fixé les taux de
11025
, utilisé un 128 octets aléatoires de la mémoire tampon, et pour la bouclesnd_pcm_writei()
pour 11025/128 pour chaque seconde de son. Deux secondes nécessaires 86*2 appelssnd_pcm_write()
pour obtenir deux secondes de son.Afin de donner à l'appareil de suffisamment de temps pour convertir les données audio, je l'ai mis a utilisé une boucle for, après la
snd_pcm_writei()
boucle de retarder l'exécution de lasnd_pcm_close()
fonction.Après le test, j'ai dû conclure que l'exemple de code n'a pas fourni assez d'échantillons pour surmonter l'appareil de latence avant la
snd_pcm_close
fonction a été appelée ce qui implique que la fonction de fermeture a moins de latence que lesnd_pcm_write()
fonction.OriginalL'auteur axismann
Je pense que la raison de la "prématuré" dispositif de fermeture, c'est que vous avez besoin d'appeler
snd_pcm_drain(handle);
avantsnd_pcm_close(handle);
pour s'assurer que toutes les données se joue avant de l'appareil est fermé.OriginalL'auteur cordeg
Si le pilote ALSA commencer seuil n'est pas correctement réglé (si dans votre cas, il est d'environ 2s), alors vous aurez besoin de faire appel snd_pcm_start() pour démarrer le rendu des données immédiatement après snd_pcm_writei().
Ou vous pouvez définir un seuil approprié dans le sud-ouest params de ALSA appareil.
ref:
OriginalL'auteur