buffers.c 2.68 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8
#include <linux/console.h>
#include <linux/types.h>
#include <linux/wait.h>

#include "speakup.h"
#include "spk_priv.h"

9
#define SYNTH_BUF_SIZE 8192	/* currently 8K bytes */
10

11 12 13 14
static u16 synth_buffer[SYNTH_BUF_SIZE];	/* guess what this is for! */
static u16 *buff_in = synth_buffer;
static u16 *buff_out = synth_buffer;
static u16 *buffer_end = synth_buffer + SYNTH_BUF_SIZE - 1;
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

/* These try to throttle applications by stopping the TTYs
 * Note: we need to make sure that we will restart them eventually, which is
 * usually not possible to do from the notifiers. TODO: it should be possible
 * starting from linux 2.6.26.
 *
 * So we only stop when we know alive == 1 (else we discard the data anyway),
 * and the alive synth will eventually call start_ttys from the thread context.
 */
void speakup_start_ttys(void)
{
	int i;

	for (i = 0; i < MAX_NR_CONSOLES; i++) {
		if (speakup_console[i] && speakup_console[i]->tty_stopped)
			continue;
31
		if (vc_cons[i].d && vc_cons[i].d->port.tty)
32
			start_tty(vc_cons[i].d->port.tty);
33 34 35 36 37 38 39 40 41
	}
}
EXPORT_SYMBOL_GPL(speakup_start_ttys);

static void speakup_stop_ttys(void)
{
	int i;

	for (i = 0; i < MAX_NR_CONSOLES; i++)
42
		if (vc_cons[i].d && vc_cons[i].d->port.tty)
43
			stop_tty(vc_cons[i].d->port.tty);
44 45 46 47
}

static int synth_buffer_free(void)
{
48
	int chars_free;
49 50

	if (buff_in >= buff_out)
51
		chars_free = SYNTH_BUF_SIZE - (buff_in - buff_out);
52
	else
53 54
		chars_free = buff_out - buff_in;
	return chars_free;
55 56 57 58 59 60 61 62
}

int synth_buffer_empty(void)
{
	return (buff_in == buff_out);
}
EXPORT_SYMBOL_GPL(synth_buffer_empty);

63
void synth_buffer_add(u16 ch)
64 65 66
{
	if (!synth->alive) {
		/* This makes sure that we won't stop TTYs if there is no synth
67 68
		 * to restart them
		 */
69 70 71 72 73 74 75 76 77 78 79
		return;
	}
	if (synth_buffer_free() <= 100) {
		synth_start();
		speakup_stop_ttys();
	}
	if (synth_buffer_free() <= 1)
		return;
	*buff_in++ = ch;
	if (buff_in > buffer_end)
		buff_in = synth_buffer;
80
	/* We have written something to the speech synthesis, so we are not
81 82
	 * paused any more.
	 */
83
	spk_paused = false;
84 85
}

86
u16 synth_buffer_getc(void)
87
{
88
	u16 ch;
89 90 91 92 93 94 95 96 97 98

	if (buff_out == buff_in)
		return 0;
	ch = *buff_out++;
	if (buff_out > buffer_end)
		buff_out = synth_buffer;
	return ch;
}
EXPORT_SYMBOL_GPL(synth_buffer_getc);

99
u16 synth_buffer_peek(void)
100 101 102 103 104 105 106
{
	if (buff_out == buff_in)
		return 0;
	return *buff_out;
}
EXPORT_SYMBOL_GPL(synth_buffer_peek);

107 108 109 110 111 112 113 114 115 116 117 118
void synth_buffer_skip_nonlatin1(void)
{
	while (buff_out != buff_in) {
		if (*buff_out < 0x100)
			return;
		buff_out++;
		if (buff_out > buffer_end)
			buff_out = synth_buffer;
	}
}
EXPORT_SYMBOL_GPL(synth_buffer_skip_nonlatin1);

119 120
void synth_buffer_clear(void)
{
121 122
	buff_in = synth_buffer;
	buff_out = synth_buffer;
123 124
}
EXPORT_SYMBOL_GPL(synth_buffer_clear);