you can now stop the wav player with the X key

.gitignore

@@ -43,6 +43,8 @@
 *.idb
 *.pdb
 
+core
+
 # Kernel Module Compile Results
 *.mod*
 *.cmd

CheckResolv/.gitignore

@@ -0,0 +1,3 @@
+
+checkresolv
+

DumpGDBM/.gitignore

@@ -1,3 +1,6 @@
 MANIFEST
 
 *.gdbm
+
+dumpgdbm
+cleargdbm

DumpGDBM/README.md

@@ -9,8 +9,44 @@ https://en.wikipedia.org/wiki/DBM_(computing)
 ## Exemple
 
 Le mini-script Perl `exemple.pl` montre bien comment faire une "base de données
-associative" en Perl.
+associative" en Perl. Il extrait les champs _usernale_ et _GECOS_ du fichier
-
+`/etc/passwd` et les injecte dans un fichier gdbm.
-
+
+```
+tth@redlady:~/Devel/KlugyTools/DumpGDBM$ ./exemple.pl 
+tth@redlady:~/Devel/KlugyTools/DumpGDBM$ ./dumpgdbm -i exemple.gdbm 
+working on [exemple.gdbm]
+
+dumpgdbm > first
+K: rtkit.
+D: RealtimeKit,,,.
+
+dumpgdbm > next
+K: man.
+D: man.
+
+dumpgdbm > next
+K: lightdm.
+D: Light Display Manager.
+
+dumpgdbm > ? ks
+
+command [ks]
+  Search a posix regex pattern in all the key fields.
+
+dumpgdbm > ks root
+K: root.
+D: root.
+
+dumpgdbm > ks tth
+K: tth.
+D: tTh,,,.
+
+dumpgdbm > 
+EOF ?
+tth@redlady:~/Devel/KlugyTools/DumpGDBM$ 
+```
+
+Well done bro.
 
 

DumpGDBM/exemple.pl

@@ -15,6 +15,7 @@ while (<SOURCE>)
 	@champs = split ":", $_;
 	$user = $champs[0]."\0";
 	$gecos = $champs[4]."\0";
+	# print $user, " ", $gecos, "\n";
 	$DB{$user} = $gecos;
 	}
 

Ecoute/.gitignore

@@ -0,0 +1,11 @@
+
+ecoute
+
+*.wav
+*.ogg
+*.flac
+*.mp3
+*.au
+*.opus
+
+toto

Ecoute/README.md

@@ -0,0 +1,77 @@
+# Écoute, un player...
+
+Écoute n'est pas un player comme les autres.
+Vous êtes prévenus.
+Certaines fonctionalités que l'on nomme *classiques*, comme
+le support des *playlists* ou la recherche de pochette
+de disque ne sont pas là.
+
+En fait, j'ai commencé à écrire ce logiciel il y a très
+longtemps pour découvrir
+[libsndfile](https://en.wikipedia.org/wiki/Libsndfile).
+Ensuite, je l'ai un peu oublié dans son coin.
+Il manque même pas mal de formats de base (ex, le .ogg) dans
+ce qu'il connait. Mais je
+viens de lui trouver une nouvelle utilité, il va m'aider
+à trier les fichiers de mon [Tascam](https://www.thomann.de/intl/tascam_dr_05x.htm). Il faut juste rajouter les fonctions
+qui manquent.
+
+
+## Compilation
+
+Il faut installer les paquets
+`libao-dev`, `libogg-dev`,  et `libsndfile-dev` avoir de
+pouvoir générer le moindre exécutable.
+Les machins *ncurses* sont censé être là, sinon
+c'est `ncurses-dev` qui manque.
+
+Ensuite, un tout simple
+run de `make` fera le travail.
+Dans le [Makefile](Makefile), vous avez quelques options à
+régler, genre le `DEBUG_LEVEL` si vous ne voulez pas
+submerger votre stderr.
+Mais si vous avez activé cette friture, vous
+lancer le logiciel par `./ecoute 2> tracelog` dans un xterm,
+puis vous lancez `tail -f tracelog` dans un autre xterm
+pour le voir raconter sa vie. *Astuce !*
+
+## Utilisation
+
+Une fois lancé, le logiciel vous affiche la liste des
+fichiers sons dans le répertoire courant. Parfois il
+en manque.
+
+La touche **`?`** affiche une petite fenêtre d'aide.
+La touche **`Q`** (*:q!*) sort de ce machin.
+
+Il y a des fonctions de tri (nom, taille, ...) par
+les touches dédiées (voir l'aide).
+En pressant **`I`** des informations diverses et 
+souvent inutiles sur le fichier pointé.
+Le **`D`** propose un dump hexadécimal et ascii qui
+va être grandement amélioré dans les jours qui viennent.
+Et enfin avec **`$`**, vous aurez quelques informations techniques
+sur les trucs techniques.
+
+
+## Pour la suite ?
+
+Première étape : Prévoir la possibilité de faire un *abort*
+pendant la lecture d'un fichier son. Ça ne va pas être simple, il
+faut d'abord factoriser la fonction de scrutation du clavier
+pendant la lecture du son, et ensuite la brancher dans les
+différents modules.
+
+Deuxième étape : Implémenter une fonction bien *molly-guarded* pour pouvoir
+effacer un fichier sans le moindre risque d'erreur.
+
+Troisième étape : Ajouter un controle du volume sonore, ce qui implique
+de replonger dans `alsa` ou la doc de la libao...
+
+tTh.
+
+
+
+
+
+

Ecoute/ecoute.man

@@ -0,0 +1,30 @@
+.TH Ecoute 1 "2005 September" "various OS" "Tonton Th"
+
+.SH NAME
+ecoute \- ncurses based note,wav,ogg,au player.
+
+.SH SYNOPSYS
+\fBecoute\fP 
+
+.SH OPTIONS
+-s <newdir> : change working directory to <newdir>.
+
+.SH INTERACTIVE
+This player is a real ncurses based interactive software.
+Full of bugs, a lot of to_be_done functions. You can try
+the '?' key at main screen.
+
+.SH CONFIG FILE
+All your config files are belong to us. 
+
+.SH WHAT IS A .note FILE ?
+This a raw, monophonic, 16 bits, 24000 smpl/s binary file.
+You can seek the web for a 'ziktth' software if you need more informations.
+
+
+.SH AUTHOR(S)
+Thierry (aka tth) Boudet. http://tboudet.free.fr/
+
+.SH DEDICACE
+This software is dedicated to DEC, who build the pdp11.
+

Ecoute/src/Makefile

@@ -0,0 +1,62 @@
+#----------------------------------------------------------------
+#
+#	abominable sound console player
+#	by Thierry 'tth' Boudet		- build on Slackware.
+#
+#	Recent versions: http://tontonth.free.fr/
+#	complains go to "tontonth O free o fr".
+#
+#----------------------------------------------------------------
+
+VERSION=0.0040
+
+TEKFLAG = -DDEBUG_LEVEL=1 -g
+CFLAGS  = -std=c11 -Wall -Wextra -ansi -Wlogical-op	\
+		  $(TEKFLAG) -DVERSION=\"$(VERSION)\"
+BIBS    = -lncurses -lao -lsndfile -logg
+
+#---------------------------------------------------------
+
+all:	ecoute
+
+#---------------------------------------------------------
+
+main.o:		main.c		ecoute.h	Makefile
+ecran.o:	ecran.c		ecoute.h	Makefile
+dump.o:		dump.c		ecoute.h	Makefile
+magic.o:	magic.c		ecoute.h	Makefile
+interactive.o:	interactive.c	ecoute.h	Makefile
+fonctions.o:	fonctions.c	ecoute.h	Makefile
+ifao.o:		ifao.c		ecoute.h	Makefile
+playwav.o:	playwav.c	ecoute.h	Makefile
+playnote.o:	playnote.c	ecoute.h	Makefile
+playau.o:	playau.c	ecoute.h	Makefile
+playogg.o:	playogg.c	ecoute.h	Makefile
+playspeex.o:	playspeex.c	ecoute.h	Makefile
+playflac.o:	playflac.c	ecoute.h	Makefile
+rmfile.o:	rmfile.c	ecoute.h	Makefile
+
+OBJ=main.o ecran.o playnote.o playwav.o playogg.o fonctions.o interactive.o \
+	dump.o playau.o playspeex.o playflac.o magic.o ifao.o rmfile.o
+
+ecoute:		$(OBJ)
+	gcc $(CFLAGS) $(OBJ) $(BIBS) -o ecoute
+
+#---------------------------------------------------------
+#  services targets
+
+FILES=*.c *.h *.txt Makefile *.man *.html
+
+install:	ecoute
+	cp ./ecoute /usr/local/bin
+
+lines:
+	wc  $(FILES) | sort -n
+
+tarball: $(FILES)
+	ls $^ > MANIFEST ;			\
+	( cd .. ;				\
+	tar zcvf ecoute-$(VERSION).tar.gz `sed 's/^/Ecoute\//' Ecoute/MANIFEST` )
+	date >> tarball
+
+#---------------------------------------------------------

Ecoute/src/README.md

@@ -0,0 +1,13 @@
+## dump.c
+## ecran.c
+## fonctions.c
+## ifao.c
+## interactive.c
+## magic.c
+## main.c
+## playau.c
+## playflac.c
+## playnote.c
+## playogg.c
+## playspeex.c
+## playwav.c

Ecoute/src/dump.c

@@ -0,0 +1,83 @@
+/*
+ *	dump.c
+ *	======	debug module for 'Ecoute' - 2005.03.06
+ *
+ *  Warning: gruik coding inside.
+ */
+
+#include    <unistd.h>
+#include    <fcntl.h>
+#include    <string.h>
+#include    <ctype.h>
+#include    "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+#define T_BUFF_HEX	(16*16)
+
+static int hexadump(char *fname, WINDOW *w)
+{
+int		fd;
+unsigned char	buffer[T_BUFF_HEX];
+int		lig, col, idx;
+char		chaine[10], lettre;
+
+#if DEBUG_LEVEL
+fprintf(stderr, "hexadump of %s\n", fname);
+#endif
+
+if ( (fd=open(fname, O_RDONLY)) < 0 ) {
+	mvwaddstr(w, 2, 2, "err open");		wrefresh(w);
+	getch();
+	return -1;
+	}
+
+if ( T_BUFF_HEX != read(fd, buffer, T_BUFF_HEX) ) {
+	mvwaddstr(w, 2, 2, "err read");		wrefresh(w);
+	getch();
+	}
+close(fd);
+
+for (lig=0; lig<16; lig++) {
+	for (col=0; col<16; col++) {
+		idx = (lig*16) + col;
+		sprintf(chaine, "%02x", buffer[idx]);
+		mvwaddstr(w, lig+1, (col*3)+1, chaine);
+		if (isprint(buffer[idx]))
+			lettre = buffer[idx];
+		else
+			lettre = '.';
+		mvwaddch(w, lig+1, col+50, lettre);
+		}
+	}
+wrefresh(w);
+
+return 0;
+}
+/*==------------------------------------------------------------------==*/
+/*
+ *	public entry point.
+ */
+int dump_this_file(char *fname, int flag)
+{
+WINDOW		*popup;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">> dump_this_file ( '%s' %d )\n", fname, flag);
+#endif
+
+popup = newwin(18, 68, L_POPUP, C_POPUP);
+bordure(popup, 1);
+mvwaddstr(popup, 0, 2, "{ dump of ");
+mvwaddstr(popup, 0, 12, fname);
+mvwaddstr(popup, 0, 12+strlen(fname), " }");
+wrefresh(popup);
+
+(void)hexadump(fname, popup);
+
+wrefresh(popup);
+getch();
+delwin(popup);	
+touchwin(stdscr); refresh();
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/ecoute.h

@@ -0,0 +1,102 @@
+/*
+ *	ecoute.h
+ *	--------		Fevrier 2005 a Frontignan-Plage
+ *
+ */
+#include  <ncurses.h>
+
+#define		T_BUFFER	8192
+
+/*==------------------------------------------------------------------==*/
+void	about(void);
+void	help(void);
+/*==------------------------------------------------------------------==*/
+/*
+ *	ecran.c - ncurses related functions and global vars.
+ */
+#define		L_POPUP		5
+#define		C_POPUP		9
+
+void	bordure(WINDOW * w, int flag);
+int	progress_bar(WINDOW *win, long val, long maxval, int type);
+void	prepare_ecran(void);
+void	say_goodbye(void);
+
+extern int	couleur;
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	interactive.c - choice a file to play
+ */
+#define SORT_NAME_A	1
+#define SORT_NAME_B	2
+
+int	fileselector(void);
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	sound file types
+ */
+#define		SON_UNKNOW	0
+#define		SON_NOTE	42
+#define		SON_WAV		95
+#define		SON_OGG		20
+#define		SON_SPEEX	21
+#define		SON_FLAC	22
+#define		SON_OPUS	23
+#define		SON_MP3		24
+#define		SON_AU		128
+
+/*
+ *	players functions
+ */
+int	note_player(char *fname, WINDOW *popup);
+int	wav_player(char *fname, WINDOW *popup);
+int	au_player(char *fname, WINDOW *popup);
+int	ogg_player(char *fname, WINDOW *popup);
+int	speex_player(char *fname, WINDOW *popup);
+int	flac_player(char *fname, WINDOW *popup);
+/*==------------------------------------------------------------------==*/
+/*
+ *	_magic.c_ 	check if the file is a sound file.
+ */
+int	magic_detect(char *filename, long *pb);
+void	magic_plop(int type);
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	'fonctions.c'
+ */
+long	taille_fichier(int fd);
+int	type_du_fichier(char *nom);
+char	*type2ext(int type);
+char	*type2descr(int type);
+
+/*
+ *	Flags  is a bitfield
+ */
+int	play_this_file(char *nom, int type, int flags);
+
+/*
+ *	new, 18 Avril 2005, proto may change.
+ */
+int	info_about_this_file(char *nom, int type);
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	hexadecimal dumper.
+ */
+int	dump_this_file(char *fname, int flag);
+
+/*
+ *	libao technical interface
+ */
+int	init_sound_output(char *dev, int k);
+int	setup_sound_output(int splr, int nbch);
+int	start_sound_output(int k);
+int	stop_sound_output(int k);
+int	infos_sound_output(char *title);
+
+void  infos_techniques(void);
+
+/*==------------------------------------------------------------------==*/

Ecoute/src/ecran.c

@@ -0,0 +1,161 @@
+/*
+ *	ecran.c
+ *	-------
+ * 
+ *  Maybe, one day, we can have colors...
+ *
+ */
+
+#define _POSIX_C_SOURCE 600L			/* for fileno(3) */
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+
+#include  <sys/select.h>
+
+#include  "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	global variables
+ */
+int	couleur = 0;
+/*==------------------------------------------------------------------==*/
+void bordure(WINDOW * w, int flag)
+{
+if (flag)	box(w, 0, 0);
+else		wborder(w, '|', '|', '-', '-', '+', '+', '+', '+');
+}
+/*==------------------------------------------------------------------==*/
+int alerte(char *texte, int flag)
+{
+/*
+ * this func is a stub. real implementation for the next release.
+ */
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+#define T_MAX_PB 90
+int	progress_bar(WINDOW *win, long val, long maxval, int type)
+{
+int	foo, largeur;
+int	larg_win, haut_win;
+int	curseur;
+char	chaine[T_MAX_PB+1];
+
+/*
+ *	premier defi, retrouver largeur et hauteur de la fenetre
+ */
+larg_win = getmaxx(win);
+haut_win = getmaxy(win);
+
+largeur = (T_MAX_PB<larg_win ? T_MAX_PB : larg_win) - 6;
+
+#if DEBUG_LEVEL > 1
+sprintf(chaine, "> x %-4d y %-4d l %-4d <", larg_win, haut_win, largeur);
+mvwaddstr(win, 1, 1, chaine);
+wrefresh(win);
+#endif
+
+curseur = (val*largeur) / maxval;
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "maxval %ld  val %ld  largeur %d  curseur %d\n",
+			maxval, val, largeur, curseur);
+#endif
+
+chaine[0] = '[', chaine[largeur] = ']', chaine[largeur+1] = '\0';
+for (foo=1; foo<largeur; foo++) {
+	if (type) {
+		if (foo<curseur)	chaine[foo] = 'o';
+		else			chaine[foo] = '-';
+		}
+	else	{
+		if (foo<curseur)	chaine[foo] = '*';
+		else			chaine[foo] = '.';
+		}
+
+	}
+mvwaddstr(win, haut_win-3, 2, chaine);
+wrefresh(win);
+
+foo = 42;
+return foo;
+}
+/*==------------------------------------------------------------------==*/
+/*
+ *  detection de la frappe d'une touche clavier -- remember kbhit() ?
+ */
+int is_a_key_hitted(void)
+{
+int		fd,retv;
+fd_set		in_fds;
+struct timeval	tv;
+
+fd = fileno(stdin);
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: fileno -> %d\n", __func__, fd);
+#endif
+
+FD_ZERO(&in_fds);	FD_SET(fd, &in_fds);
+tv.tv_sec = tv.tv_usec = 0;
+
+retv = select(1, &in_fds, NULL, NULL, &tv);
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: select -> %d\n", __func__, retv);
+#endif
+
+if (-1 == retv) {
+	perror("select()");
+	}
+else if (0 == retv) {
+	/* no key hit */
+	}
+else	{
+	/* got a keypress */
+	return 1;
+	}
+
+return 0;
+}
+/*==------------------------------------------------------------------==*/
+void termine_ecran(void)
+{
+endwin();	exit(0);
+}
+/*==------------------------------------------------------------------==*/
+void prepare_ecran(void)
+{
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( )\n", __func__);
+#endif
+
+initscr();
+
+if (has_colors()) {
+	use_default_colors();
+	couleur = 1;
+	}
+
+nonl();		cbreak();	noecho();
+
+keypad(stdscr, TRUE);		/* acces aux touches 'curseur' */
+
+bordure(stdscr, 1);
+standout();
+mvaddstr(0, 5, "{ Ecoute v " VERSION " - by tTh }");
+mvaddstr(LINES-1, 5, "{ hit '?' for help, 'Q' for quit }");
+standend();
+refresh();
+
+atexit(termine_ecran);
+}
+/*==------------------------------------------------------------------==*/
+void	say_goodbye(void)
+{
+bordure(stdscr, 0);
+wrefresh(stdscr);
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/fonctions.c

@@ -0,0 +1,225 @@
+/*
+ *	fonctions.c		Ecoute: a sound player.
+ *	-----------		23 Fev 2005 - dans le froid de Frontignan
+ */
+
+#include    <stdio.h>
+#include    <string.h>
+#include    <sys/types.h>
+#include    <sys/stat.h>
+
+#include    "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+long	taille_fichier(int fd)
+{
+struct stat	st;
+int		foo;
+
+foo = fstat(fd, &st);
+if (foo) {
+	perror("fonctions.c:18 fstat");
+	return -1;
+	}
+return st.st_size;
+}
+/*==------------------------------------------------------------------==*/
+struct un_type_de_fichier {
+	char	*extension;
+	int	numtype;
+	char	*descr;
+	} types_de_fichiers[] = {
+ {	".note",	SON_NOTE,	"tTh .note files"		},
+ {	".wav",		SON_WAV,	"Microsoft Wave"		},
+ {	".ogg",		SON_OGG,	"Xiph Ogg/Vorbis"		},
+ {	".speex",	SON_SPEEX,	"Xiph Compressed speach"	},
+ {	".au",		SON_AU,		"Sun/NeXT audio data"		},
+ {	".flac",	SON_FLAC,	"Free Lossless Audio Codec"	},
+ {	".opus",	SON_OPUS,	"OPUS"				},
+ {	".mp3",		SON_MP3,	"mp3"				},
+};
+#define NBR_TYPES 	\
+	(sizeof(types_de_fichiers)/sizeof(struct un_type_de_fichier))
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	this function is based on the .extension of the filename.
+ *	this is a very crude system, because we run on Unix, where
+ *	file extensions are not a hard law.
+ *
+ *	see also 'magic.c' for a more advanced function...
+ */
+int	type_du_fichier(char *nom)
+{
+int		foo, len_nom, len_ext;
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "type_du_fichier(%s)\n", nom);
+#endif
+len_nom = strlen(nom);
+for (foo=0; foo<(int)NBR_TYPES; foo++) {
+	len_ext = strlen(types_de_fichiers[foo].extension);
+	if ( (len_nom > len_ext) &&
+	     !strcmp(nom+(len_nom-len_ext), types_de_fichiers[foo].extension) ) {
+#if DEBUG_LEVEL > 1
+		fprintf(stderr, "   found %s\n", types_de_fichiers[foo].descr);
+#endif
+		return(types_de_fichiers[foo].numtype);
+		}
+	}
+
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "    fail...\n");
+#endif
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+char	*type2ext(int type)
+{
+int	foo;
+
+if (type == SON_UNKNOW)		return "unknow";
+
+for (foo=0; foo<(int)NBR_TYPES; foo++) {
+	if (type==types_de_fichiers[foo].numtype)
+		return (types_de_fichiers[foo].extension)+1;
+	}
+return "???";
+}
+/*==------------------------------------------------------------------==*/
+char	*type2descr(int type)
+{
+int	foo;
+
+if (type == SON_UNKNOW)		return "unknow";
+
+for (foo=0; foo<(int)NBR_TYPES; foo++) {
+	if (type==types_de_fichiers[foo].numtype)
+		return (types_de_fichiers[foo].descr);
+	}
+return "lp0 on fire";
+}
+/*==------------------------------------------------------------------==*/
+int	play_this_file(char *nom, int type, int flags)
+{
+int		foo;
+WINDOW		*popup;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %d 0x%x )\n", __func__, nom, type, flags);
+#endif
+
+if (NULL==nom) {
+	/* molly-guard */
+	fprintf(stderr, "%s:%s called with a NULL name\n", __FILE__, __func__);
+	return -1;
+	}
+/*
+ *	ncurses initial stuff
+ */
+popup = newwin(12, 60, L_POPUP, C_POPUP);
+bordure(popup, 1);
+/* wstandout(popup); */
+mvwaddstr(popup, 0, 2, "{ playing ");
+mvwaddstr(popup, 0, 12, nom);
+mvwaddstr(popup, 0, 12+strlen(nom), " }");
+/*wstandend(popup); */
+wrefresh(popup);
+
+foo = start_sound_output(0);
+
+switch (type)
+	{
+	case SON_NOTE:
+		foo = note_player(nom, popup);
+		break;	
+	case SON_WAV:
+		foo = wav_player(nom, popup);
+		break;
+	case SON_OGG:
+		foo = ogg_player(nom, popup);
+		break;
+	case SON_AU:
+		foo = au_player(nom, popup);
+		break;
+	case SON_SPEEX:
+		foo = speex_player(nom, popup);
+		break;
+	case SON_FLAC:
+		foo = flac_player(nom, popup);
+		break;
+	}
+
+(void)stop_sound_output(0);
+
+/*
+ *	screen washing.
+ */
+delwin(popup);
+touchwin(stdscr);	refresh();
+
+#if DEBUG_LEVEL
+fprintf(stderr, "    end of %s\n", __func__);
+#endif
+
+return foo;
+}
+/*==------------------------------------------------------------------==*/
+/*
+ *	mey be, here, we can use the internals functions
+ *	of libsndfile ?
+ */
+int	info_about_this_file(char *nom, int type)
+{
+int		foo;
+WINDOW		*popup;
+char		chaine[100];
+struct stat	st;
+
+/*
+ *	ncurses initial stuff
+ */
+popup = newwin(12, 64, L_POPUP, C_POPUP);
+bordure(popup, 1);
+wstandout(popup);
+mvwaddstr(popup, 0, 2, "{ infos about ");
+mvwaddstr(popup, 0, 16, nom);
+mvwaddstr(popup, 0, 16+strlen(nom), " }");
+wstandend(popup);
+wrefresh(popup);
+
+/*
+ *	filesystem infos
+ */
+foo = stat(nom, &st);
+if (foo != 0) {
+	mvwaddstr(popup, 2, 2, "hu ho, stat failed ?");
+	}
+else	{
+	sprintf(chaine, "owned by:  user id %d, group id %d", 
+			st.st_uid, st.st_gid);
+	mvwaddstr(popup, 2, 2, chaine);
+	sprintf(chaine, "size:      %ld bytes or %ld MB.",
+				st.st_size,
+				1 + (st.st_size / (1024*1024)) );
+	mvwaddstr(popup, 3, 2, chaine);
+	}
+
+/*
+ *	internals infos
+ */
+sprintf(chaine, "magic_detect: %4d  /  ", type);
+mvwaddstr(popup, 6, 2, chaine);
+mvwaddstr(popup, 6, 25, type2descr(type));
+wrefresh(popup);
+getch();
+
+/*
+ *	screen cleanup.
+ */
+delwin(popup);
+touchwin(stdscr);	refresh();
+
+return foo;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/ifao.c

@@ -0,0 +1,126 @@
+/*
+ *		ifao.c		(libao interface)
+ *		------
+ */
+
+#include    <stdlib.h>
+#include    <unistd.h>
+#include    <string.h>
+#include    <ao/ao.h>
+#include    <sndfile.h>
+#include    "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+/*
+ *	privates variables of this module. MUST be static !
+ */
+
+#define TBUF	100
+
+static int			isactive;
+static char			devname[TBUF+1];
+static ao_sample_format		AOSF;
+
+/*==------------------------------------------------------------------==*/
+/*
+ */
+int setup_sound_output(int splr, int nbch)
+{
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d %d )\n", __func__, splr, nbch);
+#endif
+
+if (splr)	AOSF.rate        = splr;
+if (nbch)	AOSF.channels    = nbch;
+
+return 0;
+}
+/*==------------------------------------------------------------------==*/
+/*
+ *	initialisation of this module who MUST be called
+ *	before any use of this module !
+ */
+int   init_sound_output(char *device, int k)
+{
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, device, k);
+#endif
+
+/* some default values */
+AOSF.rate 		= 44100;
+AOSF.channels		= 2;
+AOSF.bits		= 16;
+AOSF.byte_format	= AO_FMT_LITTLE;		/* XXX ??? */
+
+/*  XXX    see the libao documentation for exact syntax */
+if (TBUF < strlen(device)) {
+	fprintf(stderr, "buffer overflow in %s\n", __func__);
+	exit(1);
+	}
+strcpy(devname, device);
+
+return 0;
+}
+/*==------------------------------------------------------------------==*/
+int   start_sound_output(int k)
+{
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
+#endif
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+int   stop_sound_output(int k)
+{
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
+#endif
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+int   infos_sound_output(char *title)
+{
+
+if (NULL==title) {
+	abort();
+	}
+
+fprintf(stderr, "   +------ snd out infos (%s)\n", title);
+fprintf(stderr, "   |  device name      '%s'\n", devname);
+fprintf(stderr, "   |  sample rate      %d\n", AOSF.rate);
+fprintf(stderr, "   |  channels         %d\n", AOSF.channels );
+fprintf(stderr, "   |  bits/smpl        %d\n", AOSF.bits );
+fprintf(stderr, "   |  is active ?      %s\n", isactive ? "yes" : "no");
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+void  infos_techniques(void)
+{
+int		foo;
+WINDOW		*popup;
+char		*cptr;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( )\n", __func__);
+#endif
+
+popup = newwin(12, 60, L_POPUP, C_POPUP);
+bordure(popup, 1);
+mvwaddstr(popup, 0, 2, "{ Technical infos }");
+
+cptr = sf_version_string();
+mvwaddstr(popup, 2, 3, cptr);
+
+/* mvwaddstr(popup, 11, 2, "*   hit any key to reboot  *"); */
+wrefresh(popup);
+getch();
+delwin(popup);
+touchwin(stdscr);	refresh();
+
+}
+/*==------------------------------------------------------------------==*/
+

Ecoute/src/interactive.c

@@ -0,0 +1,303 @@
+/*
+ *	fileselector.c
+ *	--------------		18 Fevrier 2005.
+ *
+ *	some code borrowed from 'Visual Hexdiff' :-)
+ */
+
+#include    <stdio.h>
+#include    <stdlib.h>
+#include    <string.h>
+#include    <sys/time.h>
+#include    <sys/stat.h>
+#include    <dirent.h>
+#include    <errno.h>
+
+#include    "ecoute.h"
+
+extern char *strdup(const char *);		/* WTF? */
+
+/*==------------------------------------------------------------------==*/
+typedef struct {
+	long		smplrate;
+	short		channels;
+	short		type;
+	} FICH_SON;
+
+typedef struct  {
+	long		taille;
+	char		*nom;
+	int		idx;
+	time_t		epochtime;
+	FICH_SON	son;
+	} FICH;
+	
+static FICH	*liste;
+static int	taille;		/* taille de la liste */
+static int	nombre;		/* nbre d'entrées dans la liste */
+
+#define		TCHONK	42
+/*==------------------------------------------------------------------==*/
+/*
+ *	return 1 if we can safely read the file
+ */
+int	teste_fichier(char *nom, struct stat *stb, int flag)
+{
+int		foo;
+
+if (flag) {
+	fprintf(stderr, "in %s, flag must be 0, was %d\n", __func__, flag);
+	}
+
+foo = stat(nom, stb);
+if (foo) {
+	fprintf(stderr, "in %s stat -> %d\n", __func__, errno);
+	}
+if (S_ISDIR(stb->st_mode))	return 0;
+/* XXX
+ *	check if the file is readable
+ */
+return 1;
+}
+/*==------------------------------------------------------------------==*/
+/*
+ *	dedicated comparaison functions for sorting in the file selector.
+ *
+ */
+static int cmp_name_asc(const void *a, const void *b)
+{ return strcmp( ((FICH *)a)->nom, ((FICH *)b)->nom); }
+static int cmp_name_dsc(const void *a, const void *b)
+{ return strcmp( ((FICH *)b)->nom, ((FICH *)a)->nom); }
+
+static int cmp_idx_asc(const void *a, const void *b)
+{ return ((FICH *)a)->idx - ((FICH *)b)->idx; }
+static int cmp_idx_dsc(const void *a, const void *b)
+{ return ((FICH *)b)->idx - ((FICH *)a)->idx; }
+
+static int cmp_size_asc(const void *a, const void *b)
+{ return ((FICH *)a)->taille - ((FICH *)b)->taille; }
+static int cmp_size_dsc(const void *a, const void *b)
+{ return ((FICH *)b)->taille - ((FICH *)a)->taille; }
+
+/* and sorting by date ? */
+
+
+/*==------------------------------------------------------------------==*/
+int	trier_la_liste(int mode)
+{
+#if DEBUG_LEVEL
+fprintf(stderr, "tri de la liste, mode=%d\n", mode);
+#endif
+switch(mode) {
+	case 1:
+		qsort(liste, nombre, sizeof(FICH), cmp_name_asc);
+		break;
+	case 2:
+		qsort(liste, nombre, sizeof(FICH), cmp_name_dsc);
+		break;
+	case 3:
+		qsort(liste, nombre, sizeof(FICH), cmp_size_asc);
+		break;
+	case 4:
+		qsort(liste, nombre, sizeof(FICH), cmp_size_dsc);
+		break;
+	case 10:
+		qsort(liste, nombre, sizeof(FICH), cmp_idx_asc);
+		break;
+	case 11:
+		qsort(liste, nombre, sizeof(FICH), cmp_idx_dsc);
+		break;
+	}
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/
+int	faire_la_liste(void)
+{
+DIR		*dir;
+struct dirent	*de;
+struct stat	statbuf;
+int		foo, type;
+int		devine;
+long		magicbits;
+
+if ( NULL == (liste = malloc(TCHONK*sizeof(FICH))) ) {
+	fprintf(stderr, "\nno memory in file-listing\n");
+	abort();
+	}
+
+dir = opendir(".");
+if (dir == NULL) { abort(); }		/* XXX hard failure */
+
+nombre = 0;
+while ( (de=readdir(dir)) != NULL) {
+	if ( ! teste_fichier(de->d_name, &statbuf, 0) ) {
+		continue;
+		}
+	type = type_du_fichier(de->d_name);
+	if (type < 0) {
+		continue;
+		}
+
+	/* use the magic system (new 13 mai, may be bugged) */
+	devine = magic_detect(de->d_name, &magicbits);
+#if DEBUG_LEVEL
+	fprintf(stderr, "%s %s %d\n", __func__, de->d_name, devine);
+#endif
+
+	/* strdup is a 'non-portable' function ? */
+	liste[nombre].nom = strdup(de->d_name);
+	liste[nombre].taille = statbuf.st_size;
+	liste[nombre].idx = nombre;
+	liste[nombre].son.type = type;
+	liste[nombre].epochtime = 15000;
+#if DEBUG_LEVEL > 1
+	fprintf(stderr, "%4d: %-20s %8ld  %4d\n",
+			nombre, liste[nombre].nom, liste[nombre].taille, type);
+#endif
+	nombre++;
+	/* if needed, increase the size of the list */
+	if (nombre >= taille) {
+		liste = realloc(liste, sizeof(FICH)*(taille+TCHONK));
+		taille += TCHONK;
+		}
+	}
+
+foo = closedir(dir);
+
+return nombre;			/* ??? */
+}
+/*==------------------------------------------------------------------==*/
+int print_entry(WINDOW *w, int number, int line)
+{
+int	ln;
+
+ln = strlen(liste[number].nom);
+
+mvwprintw(w, line, 2, " %3d  %-50s    %9d  ", 
+				liste[number].idx,
+				liste[number].nom,
+				liste[number].taille);
+return 0;
+}
+/*==------------------------------------------------------------------==*/
+int fileselector(void)
+{
+int		foo;
+WINDOW		*wfs;
+int		first, curseur, idx, affh;
+int		key, flag_exit;
+char		chaine[100];
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( )\n", __func__);
+#endif
+
+foo = faire_la_liste();
+if (0 == foo) {
+	/* XXX ERROR MESSAGE AND QUIT  ? */
+	}
+affh = LINES-7;
+/*
+ *	create a subwindow for list of files
+ */
+wfs = derwin(stdscr, affh, COLS-2, 2, 1);
+#if DEBUG_LEVEL > 1
+bordure(wfs, 0);
+#endif
+wrefresh(wfs);
+
+first = curseur = 0;
+flag_exit = 0;
+
+#if DEBUG_LEVEL
+fprintf(stderr, "    %s enter interactive\n", __func__);
+#endif
+
+do	{
+#if DEBUG_LEVEL > 1
+	sprintf(chaine, "nombre:%3d first:%3d  curseur:%3d",
+				nombre, first, curseur);
+	mvwaddstr(wfs, 0, 50, chaine);
+#endif
+
+	for (foo=0; foo<affh; foo++) {
+		idx = foo+first;
+		if (idx >= nombre)	break;
+
+		if (curseur==foo)	wstandout(wfs);
+		/*
+		 * display the entry, need more work :(
+		 */
+		print_entry(wfs, idx, foo);
+		if (curseur==foo)	wstandend(wfs);
+		}
+	wrefresh(wfs);
+
+	key = getch();
+	/*
+	 *	ici il faudrait effacer le curseur ?
+	 */
+	switch (key) {
+		case KEY_UP:
+			if (curseur)			curseur--;
+			else if (first>0)		first--;
+			break;
+
+		case KEY_DOWN:
+			if ((curseur+first) >= (nombre-1))	break;
+			if (curseur < affh-1)		curseur++;
+			else if (first<(nombre-affh))	first++;
+			break;
+
+		case KEY_HOME:
+			curseur = first = 0;
+			break;
+
+		/* the show must go on */
+		case '\r': case 'p':
+			idx = curseur+first;	/* ??? */
+			foo = play_this_file(liste[idx].nom, liste[idx].son.type, 0);
+#if DEBUG_LEVEL
+			fprintf(stderr, "play '%s' => %d\n",liste[idx].nom, foo);
+#endif
+			break;
+
+		case 'D':	case 'd':
+			idx = curseur+first;
+			/* second parameter is ignored */
+			dump_this_file(liste[idx].nom, 0);
+			break;
+
+		case 'I':	case 'i':
+			idx = curseur+first;
+			info_about_this_file(liste[idx].nom,
+						liste[idx].son.type);
+			break;
+
+		case 'A':	case 'a':		about(); break;
+		case 'H':	case 'h':	case '?': help(); break;
+
+		case 'n':	trier_la_liste(1);	break;
+		case 'N':	trier_la_liste(2);	break;
+		case 's':	trier_la_liste(3);	break;
+		case 'S':	trier_la_liste(4);	break;
+		case 'u':	trier_la_liste(10);	break;
+		case 'U':	trier_la_liste(11);	break;
+
+		case '$':	infos_techniques();	break;
+
+		case 'Q':
+			flag_exit = 1;
+			break;
+		}
+
+	} while ( ! flag_exit );
+
+#if DEBUG_LEVEL
+fprintf(stderr, "    %s exit interactive\n", __func__);
+#endif
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/magic.c

@@ -0,0 +1,69 @@
+/*
+ *	magic.c
+ *	=======		26 Avril 2005
+ *
+ *	reconnaissance heuristique des fichiers sons.
+ *	Gruik coding inside.
+ */
+
+#include    <stdio.h>
+#include    <unistd.h>
+#include    <fcntl.h>
+#include    <string.h>
+#include    "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+#define   T_BUFF_MAGIC	222
+
+int	magic_detect(char *fname, long *pbits)
+{
+int		fd;
+char		buffer[T_BUFF_MAGIC];
+
+if ( (fd=open(fname, O_RDONLY)) < 0 ) {
+	perror(fname);
+	return -1;
+	}
+if ( T_BUFF_MAGIC != read(fd, buffer, T_BUFF_MAGIC) ) {
+	close(fd);
+	return -2;
+	}
+close(fd);		
+
+/* now, we have the first bytes of the file in the buffer, so we can
+   try the divination process... */
+
+*pbits = 0L;
+
+if (0 == strncmp(buffer, "RIFF", 4))
+	{
+	if (0 == strncmp(buffer+8, "WAVE", 4))
+		{
+		return SON_WAV;
+		}
+	}
+
+if (0 == strncmp(buffer, ".snd", 4))
+	{
+	return SON_AU;
+	}
+
+if (0 == strncmp(buffer, "OggS", 4))
+	{
+	if (0 == strncmp(buffer+28, "\x01vorbis", 7))
+		{
+		return SON_OGG;
+		}
+	if (0 == strncmp(buffer+28, "Speex   ", 7))
+		{
+		return SON_SPEEX;
+		}
+	}
+
+/* please add FLAC magic here XXX */
+
+
+/* really don't know, baylout */
+return SON_UNKNOW;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/main.c

@@ -0,0 +1,171 @@
+/*
+ *		------
+ *		Ecoute
+ *		------  an ogg/note/wav player from tth
+ *
+ * 15 juillet 2007: ogg palying don(t work, sorry...
+ *
+ */
+
+#include    <stdlib.h>
+#include    <unistd.h>
+#include    <string.h>
+#include    <getopt.h>
+
+#include    "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+static char *about_texte[] = 
+	{
+	"{ About... }",
+	"Ecoute, a sound player - version " VERSION,
+	"Another ugly software made by tontonTh",
+	"",
+	"Send bugs reports: tontonth(O)free(o)fr",
+	"",
+	"Binary build: " __DATE__ "  /  " __TIME__,
+	NULL
+	};
+static char *help_texte[] = 
+	{
+	"{ Help me }",
+	"<enter>     Play the selected file",
+	"A           About this software...",
+	"D           Dump begin of file in hexadecimal",
+	"R           Play a randomly selected file",
+	"nN          Sort by name",
+	"sS          Sort by file size",
+	"tT          Sort by file time",
+	"uU          Sort by order (unsort)",
+	"I           Infos about this file",
+	"$           Technical infos",
+	"",
+	"Q           Quit",
+	NULL
+	};
+void popup_texte(char *lignes[])
+{
+WINDOW * popup;
+int	nblignes;
+int	foo, largmax;
+char	**ptr;
+
+nblignes = largmax = 0;
+ptr = lignes+1;
+while ( *ptr != NULL ) {
+#if DEBUG_LEVEL > 1
+	fprintf(stderr, "%p  %s\n", ptr, *ptr);
+#endif
+	foo = strlen(*ptr);
+	if (largmax < foo)	largmax = foo;
+	nblignes++;
+	ptr++;
+	}
+
+popup = newwin((nblignes)+4, largmax+7, L_POPUP, C_POPUP);
+bordure(popup, 1);
+wrefresh(popup);
+
+for (foo=1; foo<=nblignes; foo++) {
+	mvwaddstr(popup, (foo)+1, 3, lignes[foo]);
+#if DEBUG_LEVEL > 1
+	fprintf(stderr, "%4d %s\n", foo, lignes[foo]);
+#endif
+	}
+mvwaddstr(popup, 0, 5, *lignes);		/* window title */
+wmove(popup, 0, 0);
+wrefresh(popup);
+getch();
+delwin(popup);	
+			/* pourquoi, quand je fait le 'delwin', ncurses
+			   ne rafraichit pas la zone qui était masquée ? */
+touchwin(stdscr); refresh();
+}
+/*==------------------------------------------------------------------==*/
+void about(void)
+{
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "------------ about\n");
+#endif
+popup_texte(about_texte);
+}
+void help(void)
+{
+#if DEBUG_LEVEL > 1
+fprintf(stderr, "------------ help\n");
+#endif
+popup_texte(help_texte);
+}
+/*==------------------------------------------------------------------==*/
+void help_cli(char *command)
+{
+printf("Usage: %s <options>\n", command);
+puts("Options:");
+puts("\t-d\taudio device");
+puts("\t-h\tthis help");
+puts("\t-x\tenable crash");
+
+exit(0);
+}
+/*==------------------------------------------------------------------==*/
+/*									*/
+int main(int argc, char * argv[])
+{
+int		opt = 0;
+int		foo;
+char		*audiodevice = "none";
+char		*newdir = NULL;
+
+#if DEBUG_LEVEL
+fprintf(stderr, "\n\tE C O U T E   %d\n\n", getpid());
+#endif
+
+while ((opt = getopt(argc, argv, "d:hs:x")) != -1) {
+	switch (opt) {
+		case 'd':
+			audiodevice = optarg;
+			break;
+		case 'h':
+			help_cli(argv[0]);		break;
+		case 's':
+			newdir = optarg;
+			break;
+		case 'x':
+			fprintf(stderr, "no crash available\n");
+			exit(0);
+		default:
+			fprintf(stderr, "gni %c ?\n", opt);
+			break;
+		}
+	}
+
+#if DEBUG_LEVEL
+fprintf(stderr, "audio device = %s\n", audiodevice);
+#endif
+
+if (NULL != newdir) {
+#if DEBUG_LEVEL
+	fprintf(stderr, "newdir = '%s'\n", newdir);
+#endif
+	foo = chdir(newdir);
+	}
+
+foo = init_sound_output(audiodevice, 0);
+if (foo) {
+	fprintf(stderr, "init sound output -> %d\n", foo);
+	exit(1);
+	}
+
+#if DEBUG_LEVEL
+infos_sound_output("dans main");
+#endif
+
+prepare_ecran();
+
+fileselector();
+
+say_goodbye();
+
+return 0;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/playau.c

@@ -0,0 +1,143 @@
+/*
+ *	playau.c
+ *	--------			2 Mars 2005
+ *
+ *	This code is almost a copy'n'past from "playwav.c", but
+ *	it was slightly updated. May be I have introduced new bugs,
+ *	who have to be backported :)
+ *
+ */
+
+#include   <fcntl.h>
+#include   <string.h>
+#include   <sndfile.h>
+#include   <ao/ao.h>		/* for the sound output */
+
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int	au_player(char *fname, WINDOW *popup)
+{
+SNDFILE			* sndf;
+SF_INFO			sfinfo;
+ao_sample_format	format;
+ao_device		* device;
+int			driver;
+
+char			chaine[100];
+short			* samples;
+long			total_lu;
+int			foo, bar, lu;
+int			maxsample;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, fname, popup);
+#endif
+
+/*
+ *	get help from 'sndfile' for getting datas
+ */
+memset(&sfinfo, 0, sizeof(sfinfo));
+
+sndf = sf_open(fname, SFM_READ, &sfinfo);
+if (NULL == sndf)	{
+	mvwaddstr(popup, 4, 4, "Invalid file ?");
+	wrefresh(popup);
+	getch();
+	delwin(popup);
+	touchwin(stdscr);	refresh();
+	return -1;
+	}
+
+sprintf(chaine, "frames         %lu", (unsigned long)sfinfo.frames);
+mvwaddstr(popup, 2, 5, chaine);
+sprintf(chaine, "sample rate    %d", sfinfo.samplerate);
+mvwaddstr(popup, 3, 5, chaine);
+sprintf(chaine, "channels       %d", sfinfo.channels);
+mvwaddstr(popup, 4, 5, chaine);
+sprintf(chaine, "format         %x", sfinfo.format);
+mvwaddstr(popup, 5, 5, chaine);
+wrefresh(popup);
+
+/*
+ *	memory allocation
+ *	warning, we can get multiples channels.
+ */
+if ( NULL == (samples = malloc(T_BUFFER*sizeof(short)))) {
+	perror("no memory in AU player\n");
+	abort();
+	}
+
+/*
+ *	configuration of the sound output
+ */
+ao_initialize();
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: ao ititialised\n", __func__);
+#endif
+	
+driver = ao_default_driver_id();
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: ao default driver = %d\n", __func__, driver);
+#endif
+
+memset(&format, 0, sizeof(format));
+format.bits		= 16;				/* ? */
+format.channels		= sfinfo.channels;
+format.rate		= sfinfo.samplerate;
+format.byte_format	= AO_FMT_LITTLE;		/* XXX ??? */
+
+fprintf(stderr, "%s: going to open ao\n", __func__);
+
+device = ao_open_live(driver, &format, NULL);
+fprintf(stderr, "%s: open live -> %p\n", __func__, device);
+if (NULL == device) {
+	fprintf(stderr, "\nEcoute: Error open device\n");
+	/*
+	 *  comment connaitre la cause de l'erreur ?
+	 */
+	abort();  
+	}
+
+/*
+ *	Go! Read the samples, compute some numbers and...
+ *	...???
+ */
+total_lu = 0L;
+maxsample = 0;
+
+#if DEBUG_LEVEL
+fprintf(stderr, "%s: enter loop\n", __func__);
+#endif
+while ( (lu=sf_read_short(sndf, samples, T_BUFFER)) > 0 ) {
+	ao_play(device, (char *)samples, lu*2);
+	for (foo=0; foo<lu; foo++) {
+		bar = abs(samples[foo]);
+		if (bar > maxsample) {
+			sprintf(chaine, "%9ld   max %6d", total_lu, bar);
+			mvwaddstr(popup, 7, 1, chaine);
+			wrefresh(popup);
+			maxsample = bar;
+			}
+		}
+	maxsample = 0;
+
+	total_lu += (long)lu;
+	progress_bar(popup, total_lu/sfinfo.channels, sfinfo.frames, 1);
+	wrefresh(popup);
+	}
+
+#if DEBUG_LEVEL
+fprintf(stderr, "maxsample = %d\n", maxsample);
+#endif
+
+/*
+ *	some cleanup...
+ */
+free(samples);					/* kill buff */
+sf_close(sndf);
+ao_close(device);	ao_shutdown();	
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/playflac.c

@@ -0,0 +1,28 @@
+/*
+ *	playflac.c
+ *	----------			20 Janvier 2022
+ */
+
+#include   <fcntl.h>
+#include   <unistd.h>
+#include   <ao/ao.h>		/* for the sound output */
+
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int	flac_player(char *fname, WINDOW *popup)
+{
+int			ret;
+
+ret = 43;
+
+mvwaddstr(popup, 1, 2, "Flac playing: work in progress...");
+wrefresh(popup);	sleep(1);
+
+mvwaddstr(popup, 6, 6, "*** COREDUMPING ***");
+wrefresh(popup);	getch();
+
+return ret; 		/* XXX */
+}
+/*==------------------------------------------------------------------==*/
+

Ecoute/src/playnote.c

@@ -0,0 +1,92 @@
+/*
+ *	playnote.c
+ *	----------			23 Fevrier 2005
+ * 
+ *  this subplayer is a personnal subplayer. Far back in the past,
+ *  I've made a lot of softwares around sound synteses. The unique
+ *  file format was 16bits, 2400samples/seconds and Intel endianism.
+ *
+ *		Here is the player.
+ */
+
+#include   <unistd.h>
+#include   <fcntl.h>
+#include   <ao/ao.h>		/* for the sound output */
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int note_player(char *fname, WINDOW *popup)
+{
+int			driver;
+ao_sample_format	format;
+ao_device		*device;
+int			lu, fd;
+short			*samples;
+char			chaine[100];
+long			taille, total;
+
+/*
+ *	file and memory stuff
+ */
+if ( NULL == (samples = malloc(T_BUFFER*sizeof(short))) )
+	{
+	perror("memory in note_player");
+	abort();
+	}
+if ( 0 > (fd=open(fname, O_RDONLY)) )
+	{
+	perror(fname);
+	abort();
+	}
+taille = taille_fichier(fd);
+if (taille < 0) {
+	fprintf(stderr, "%s: size < 0        WTF?\n", __func__);
+	}
+sprintf(chaine, "%10ld samples, %5ld seconds", taille/2, taille/(24000*2));
+mvwaddstr(popup, 2, 2, chaine);
+wrefresh(popup);
+
+ao_initialize();			/* must be paired with ao_shutdown */
+driver = ao_default_driver_id();
+
+format.bits		= 16;
+format.channels		= 1;
+format.rate		= 24000;
+format.byte_format	= AO_FMT_LITTLE;		/* XXX ??? */
+device = ao_open_live(driver, &format, NULL);
+if (device == NULL)
+	{
+	fprintf(stderr, "\r\n%s: Error open device\n", __func__);
+	/* comment connaitre la cause de l'erreur ? */
+	abort();
+	}
+
+/*
+ *		+-------------------------------+
+ *		|   let's the show go on...     |
+ *		+-------------------------------+
+ */
+total = 0L;
+while ( (lu=read(fd, samples, T_BUFFER)) > 0 )
+	{
+#if DEBUG_LEVEL
+	sprintf(chaine, "%9ld Kb    %-7d", total/1024, lu);
+#else
+	sprintf(chaine, "%9ld Kb", total/1024);
+#endif
+	mvwaddstr(popup, 5, 7, chaine); wrefresh(popup); 
+	total += lu;
+	progress_bar(popup, total, taille, 0);
+	ao_play(device, (char *)samples, lu);
+	}
+
+/*
+ *	this is the end, my friends...
+ */
+free(samples);
+ao_close(device);
+ao_shutdown();				/* must be paired with ao_initialise */
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/playogg.c

@@ -0,0 +1,59 @@
+/*
+ *	playogg.c
+ *	---------			2 Mars 2005
+ *
+ *
+ *  2005, Apr 11:	just downloaded some tarball from xiph.org, thinking
+ *			about some code samples...
+ */
+
+#include   <fcntl.h>
+#include   <unistd.h>
+#include   <string.h>
+#include   <ogg/ogg.h>
+#include   <ao/ao.h>		/* for the sound output */
+
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int	ogg_player(char *fname, WINDOW *popup)
+{
+ogg_sync_state		oy;
+char			*oggbuff;
+int			ret;
+
+mvwaddstr(popup, 5, 2, fname);
+mvwaddstr(popup, 3, 2, "Ogg playing: work in progress...");
+wrefresh(popup);	sleep(1);
+
+/* mvwaddstr(popup, 6, 6, "*** COREDUMPING ***"); */
+wrefresh(popup);	getch();
+
+return -42; 		/* XXX */
+
+/*
+ *	preparation
+ */
+memset(&oy, 0, sizeof(oy));
+ret = ogg_sync_init(&oy);
+mvwprintw(popup, 2, 2, "ogg_sync_init -> %d", ret);
+
+oggbuff = ogg_sync_buffer(&oy, T_BUFFER);
+mvwprintw(popup, 3, 2, "ogg_sync_buffer -> %p", oggbuff);
+wrefresh(popup);
+getch();
+
+/*
+ *	action !
+ */
+
+/*
+ *	termination
+ */
+ogg_sync_clear(&oy);
+ogg_sync_destroy(&oy);
+getch();
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/playspeex.c

@@ -0,0 +1,26 @@
+/*
+ *	playspeex.c
+ *	-----------			12 Avril 2005
+ *
+ */
+
+#include   <fcntl.h>
+#include   <unistd.h>
+#include   <ogg/ogg.h>
+#include   <ao/ao.h>		/* for the sound output */
+
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int	speex_player(char *fname, WINDOW *popup)
+{
+mvwaddstr(popup, 1, 2, fname);
+mvwaddstr(popup, 1, 4, "Speex playing: work in progress...");
+wrefresh(popup);	sleep(1);
+
+mvwaddstr(popup, 6, 6, "*** COREDUMPING ***");
+wrefresh(popup);	getch();
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Ecoute/src/playwav.c

@@ -0,0 +1,136 @@
+/*
+ *	playwav.c
+ *	---------			23 Fevrier 2005
+ */
+
+#include   <fcntl.h>
+#include   <string.h>
+#include   <sndfile.h>
+#include   <ao/ao.h>		/* for the sound output */
+
+#include   "ecoute.h"
+
+/*==------------------------------------------------------------------==*/
+int	wav_player(char *fname, WINDOW *popup)
+{
+SNDFILE			* sndf;
+SF_INFO			sfinfo;
+int			driver;
+ao_sample_format	format;
+ao_device		* device;
+char			chaine[120];
+short			* samples;
+int			lu, key;
+long			total_lu;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, fname, popup);
+#endif
+
+/*
+ *	get help from 'sndfile' for getting datas
+ */
+memset(&sfinfo, 0, sizeof(sfinfo));
+sndf = sf_open(fname, SFM_READ, &sfinfo);
+if (NULL==sndf)
+	{
+	mvwaddstr(popup, 4, 4, "Invalid file ?");
+	wrefresh(popup);
+	getch();
+	delwin(popup);
+	touchwin(stdscr);	refresh();
+	return -1;
+	}
+
+sprintf(chaine, "frames      %lu", (unsigned long)sfinfo.frames);
+mvwaddstr(popup, 2, 5, chaine);
+sprintf(chaine, "smplrate    %d", sfinfo.samplerate);
+mvwaddstr(popup, 3, 5, chaine);
+sprintf(chaine, "channels    %d", sfinfo.channels);
+mvwaddstr(popup, 4, 5, chaine);
+sprintf(chaine, "format      0x%x", sfinfo.format);
+mvwaddstr(popup, 5, 5, chaine);
+sprintf(chaine, "sections    %d", sfinfo.sections);
+mvwaddstr(popup, 6, 5, chaine);
+wrefresh(popup);
+
+#if DEBUG_LEVEL > 1
+getch();					/* XXX */
+#endif
+
+/*
+ *	memory allocation
+ *	warning, we can get multiples channels.
+ */
+if ( NULL == (samples = malloc(T_BUFFER*sizeof(short))) )
+	{
+	perror("memory shortage in WAV player");
+	abort();
+	}
+
+/*
+ *	initialize the "Cabasse Sampan" output device (aka libao)
+ */
+ao_initialize();
+driver = ao_default_driver_id();
+/* XXX valeurs provisoires XXX */
+memset(&format, 0, sizeof(ao_sample_format));
+format.bits		= 16;
+format.channels		= sfinfo.channels;
+format.rate		= sfinfo.samplerate;
+format.byte_format	= AO_FMT_LITTLE;		/* XXX ??? */
+device = ao_open_live(driver, &format, NULL);
+if (NULL==device)
+	{
+	fprintf(stderr, "\nEcoute: Error open device\n");
+	/*
+	 *  comment connaitre la cause de l'erreur ?
+	 */
+	abort();  
+	}
+
+/*
+ *	**********************
+ *	*  the playing loop  *
+ *	**********************
+ */
+total_lu = 0L;
+while ( (lu=sf_read_short(sndf, samples, T_BUFFER)) > 0 )
+	{
+	ao_play(device, (char *)samples, lu*2);
+	total_lu += (long)lu;
+	progress_bar(popup, total_lu/sfinfo.channels, sfinfo.frames, 0);
+	wrefresh(popup);
+
+	/* HERE WE HAVE TO DETECT A 'STOP LISTEN' FUNCTION. */
+	if (is_a_key_hitted()) {
+		key = getch();
+		fprintf(stderr, "%s key pressed 0x%X\n", __func__, key);
+		if ('X' == key) {
+			break;
+			}
+		}
+	}
+
+/*
+ *	shutdown "La voix du Theatre"
+ */
+ao_close(device);	ao_shutdown();	
+
+/*
+ *	memory release
+ */
+free(samples);
+
+/*
+ *	releasing 'sndfile' ressources
+ */
+sf_close(sndf);
+
+#if DEBUG_LEVEL
+fprintf(stderr, "    end of %s\n", __func__);
+#endif
+
+return -1;
+}
+/*==------------------------------------------------------------------==*/

Hexdiff/Makefile

@@ -4,9 +4,11 @@
 #
 #	old site : http://tboudet.free.fr/hexdiff/
 #
+#	https://git.tetalab.org/tTh/KlugyTools/src/branch/main/Hexdiff
+#
 
 OU_LE_METTRE = /usr/local
-VERSION=0.0.50
+VERSION=0.0.51
 
 TARNAME="hexdiff-$(VERSION).tar.gz"
 
@@ -51,8 +53,7 @@ hexdiff:	Makefile $(OBJECTS)
 install:	
 	cp hexdiff hexdiff.install
 	strip hexdiff.install
-	cp hexdiff.install $(OU_LE_METTRE)/bin/hexdiff
+	mv hexdiff.install $(OU_LE_METTRE)/bin/hexdiff
-	rm hexdiff.install
 	cp hexdiff.1 $(OU_LE_METTRE)/man/man1/hexdiff.1
 	@echo "you can copy hexdiff.rc in your HOME as .hexdiffrc"
 

Hexdiff/asciiview.c

@@ -162,9 +162,11 @@ do
 			fenetre_active ^= 1;
 			break;
 		case KEY_UP:
-			if (clig>0)	clig--;		break;
+			if (clig>0)	clig--;
+			break;
 		case KEY_DOWN:
-			if (clig<15)	clig++;		break;
+			if (clig<15)	clig++;
+			break;
 		case KEY_LEFT:
 			if (ccol>0)	ccol--;
 			else if (clig>0)

Hexdiff/fileinfo.c

@@ -28,9 +28,9 @@
 static void prtime(time_t t, char *pstr)
 {
 struct tm *ptm;
-int	foo;
+
 ptm = gmtime(&t);
-foo = strftime(pstr, 99, "%Y-%m-%d  %H:%M:%S", ptm);
+strftime(pstr, 99, "%Y-%m-%d  %H:%M:%S", ptm);
 }
 /*----------------------------------------------------------------*/
 #define  W_FILEINFO 48

Hexdiff/fonctions.c

@@ -33,17 +33,14 @@ struct stat statbuf;
 Fichier *fichier;
 long	offset;
  
-if ( (fd=open(nom, O_RDONLY)) < 0)
+if ( (fd=open(nom, O_RDONLY)) < 0) {
-	{
 	return 0;
 	}
 
-if (fenetre_active==0)
+if (fenetre_active==0) {
-	{
 	fichier = &f1;		offset = f2.offset;
 	}
-else
+else	{
-	{
 	fichier = &f2;		offset = f1.offset;
 	}
 
@@ -57,6 +54,7 @@ close(fichier->fd);
  */
 strncpy(fichier->nom, nom, T_NOM);
 foo = fstat(fd, &statbuf);
+if (foo) perror(__func__);
 fichier->fd = fd;
 fichier->taille = statbuf.st_size;
 fichier->offset = offset;
@@ -127,7 +125,7 @@ char	buffer[200];
 
 barre_inverse(' ', 0);
 standout();
-mvaddstr(0, 2, " Visuel HexDiff v " VERSION " by tTh 2007 ");
+mvaddstr(0, 2, " Visuel HexDiff v " VERSION " by tTh 2024 ");
 #if TRACE
 sprintf(buffer, " screen size %dx%d ", COLS, LINES);
 foo = strlen(buffer);
@@ -213,8 +211,9 @@ delwin(popup);
 static char *about_texte[] = 
 	{
 	"Visuel Hexdiff - version " VERSION,
-	"(c) 2007 by Thierry [tth] Boudet",
+	"(c) 2024 by Thierry [tTh] Boudet",
 	"http://tboudet.free.fr/hexdiff/",
+	"https://git.tetalab.org/tTh/KlugyTools/",
 	"send bugs reports: tontonth@free.fr",
 	"binary build: " __DATE__ "/" __TIME__,
 	};
@@ -229,7 +228,7 @@ int	foo;
 fprintf(stderr, "boite about: %d lignes\n", nblignes);
 #endif
 
-popup = newwin((nblignes*2)+3, 43, L_POPUP, C_POPUP);
+popup = newwin((nblignes*2)+3, 46, L_POPUP, C_POPUP);
 bordure(popup);
 
 for (foo=0; foo<nblignes; foo++)
@@ -320,8 +319,9 @@ return -1;
 /*----------------------------------------------------------------*/
 void version(void)
 {
-fprintf(stderr, "\nThis is 'hexdiff' v "VERSION", made by tontonTh in 2007\n");
+fprintf(stderr, "\nThis is 'hexdiff' v "VERSION", made by tTh in 2024\n");
-fprintf(stderr, "homepage: http://tboudet.free.fr/hexdiff/\n");
+/* fprintf(stderr, "homepage: http://tboudet.free.fr/hexdiff/\n"); */
+fprintf(stderr, "homepage: https://git.tetalab.org/tTh/KlugyTools/\n");
 #if TRACE
 fprintf(stderr, "Warning ! compiled with active TRACE !\n");
 #endif

Hexdiff/sel_file.c

@@ -45,6 +45,7 @@ static int teste_dirent(const struct dirent *de, struct stat *pstat)
 int		foo;
 
 foo = stat(de->d_name, pstat);
+if (foo) perror(__func__);
 
 if (S_ISDIR(pstat->st_mode))
 	return 0;
@@ -109,7 +110,6 @@ static int liste_fichiers(WINDOW *win, int flag)
 DIR		*dir;
 struct dirent	*de;
 struct stat	statbuf;
-int		foo;
 
 /*
  *	initializing local vars, for list-of-files 
@@ -154,7 +154,7 @@ while ( (de=readdir(dir)) != NULL)
 		}
 	}
 
-foo = closedir(dir);
+closedir(dir);
 
 return nombre;
 }

README.md

@@ -2,12 +2,66 @@
 
 Divers outils pour faire des choses diverses...
 
-Beaucoup de choses anciennes que je traine de systèmes en systèmes, et qui ont
+Beaucoup de choses anciennes que je traine de systèmes en systèmes, et qui ont parfois une utilité limitée.
-parfois une utilité limitée. Du code qui a presque vingt ans.
+Du code qui a parfois presque vingt ans, et qui
+nécessite donc un peu de nettoyage.
 
-* DumpGDBM : debug de fichier `key/data` 
+## DumpGDBM
-* Hexdiff : comparer deux fichiers binaires
+
-* Checkresolv : fouiller la résolution de nom.
+Pour le [debug](DumpGDBM) des fichiers `key/data` géres par GDBM.
+Ligne de commande avec une interface _readline_.
+
+```
+tth@redlady:~/Devel/KlugyTools/DumpGDBM$ ./dumpgdbm -i exemple.gdbm 
+working on [exemple.gdbm]
+dumpgdbm > ?
+----------------( Help me Obi Wan ! )---------------
+q ZZ :q :q! exit quit bye x hex hexa a ascii o octal h help ? f first 
+m maxoctets maxbytes n next p print ks keysearch ds datasearch empty 7 
+8 V version commands listcom sux 
+-----------( use '? command' for details )----------
+dumpgdbm > p
+K: rtkit.
+D: RealtimeKit,,,.
+
+dumpgdbm > n
+K: lightdm.
+D: Light Display Manager.
+
+dumpgdbm > hex
+dumpgdbm > p
+K:  6c 69 67 68 74 64 6d 00
+D:  4c 69 67 68 74 20 44 69 73 70 6c 61 79 20 4d 61 6e 61 67 65 72 00
+```
+
+## Hexdiff
+
+Pour comparer visuellement deux fichiers binaires.
+Interface `ncurses` trop choupie.
+Devrait peut-être un jour (mais flemme) passer à la couleur.
+
+![Hexdiff](http://tboudet.free.fr/hexdiff/ecran.png "Hexdiff")
 
 
+## Checkresolv
+
+Vieux truc rudimentaire pour [fouiller](CheckResolv) dans la résolution de nom.
+L'adaptation à `IPv6` est à l'étude.
+Contrairement à d'autres outils similaires, il utilise les
+fonctions de résolution de la `libc` au lieu de s'adresser directement
+au serveur de noms.
+
+```
+tth@redlady:~/Devel/KlugyTools/CheckResolv$ ./checkresolv -r tetalab.org
+------------( tetalab.org 
+h_name:       tetalab.org
+ip:           89.234.156.223
+reverse 89.234.156.223   -> bobby.tetalab.org
+```
+
+## Ecoute
+
+Un [joueur](Ecoute) de fichiers musicaux surgi d'un lointain passé,
+qui va prendre un coup de jeune pour gérer les formats modernes.
+