1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* This file only contains ob_send() and private functions
* needed to implement ob_send()
*/
/*
* This is one of two places where dc.thread can block,
* the other is readFromInputStream
*/
static enum dc_action await_buffer_space(void)
{
assert(pthread_equal(pthread_self(), dc.thread));
/* DEBUG("Waiting for buffer space\n"); */
assert(dc.state != DC_STATE_STOP);
dc_halt();
/* DEBUG("done waiting for buffer space\n"); */
return dc.action;
}
/* This will modify its input */
static void do_audio_conversion(void **data, size_t *len)
{
size_t newlen;
assert(pthread_equal(pthread_self(), dc.thread));
newlen = pcm_sizeOfConvBuffer(&dc.audio_format, *len, &ob.audio_format);
if (newlen > ob.conv_buf_len) {
ob.conv_buf = xrealloc(ob.conv_buf, newlen);
ob.conv_buf_len = newlen;
}
*len = pcm_convertAudioFormat(&dc.audio_format, *data, *len,
&ob.audio_format, ob.conv_buf,
&ob.conv_state);
*data = ob.conv_buf;
}
static void ensure_audio_format_sanity(void **data, size_t *len)
{
static uint8_t seq_last;
assert(pthread_equal(pthread_self(), dc.thread));
if (mpd_unlikely(seq_last != ob.seq_decoder)) {
seq_last = ob.seq_decoder;
if (cmpAudioFormat(&dc.audio_format, &ob.audio_format))
getOutputAudioFormat(&dc.audio_format,
&ob.audio_format);
}
if (cmpAudioFormat(&ob.audio_format, &dc.audio_format))
do_audio_conversion(data, len);
}
static void start_playback(void)
{
assert(pthread_equal(pthread_self(), dc.thread));
if (mpd_unlikely(ob.state == OB_STATE_STOP &&
player_errno == PLAYER_ERROR_NONE)) {
ob_trigger_action(OB_ACTION_PLAY);
}
}
enum dc_action
ob_send(void *data, size_t len,
float decode_time, uint16_t bit_rate, ReplayGainInfo * rgi)
{
struct rbvec vec[2];
struct ob_chunk *c;
size_t idx;
size_t i, j;
assert(pthread_equal(pthread_self(), dc.thread));
ensure_audio_format_sanity(&data, &len);
if (rgi && (replayGainState != REPLAYGAIN_OFF))
doReplayGain(rgi, data, len, &ob.audio_format);
else if (normalizationEnabled)
normalizeData(data, len, &ob.audio_format);
while (1) {
/* full buffer, loop check in case of spurious wakeups */
while (!ringbuf_get_write_vector(ob.index, vec)) {
enum dc_action rv = await_buffer_space();
if (rv != DC_ACTION_NONE)
return rv;
}
for (i = 0; i < ARRAY_SIZE(vec); i++) {
for (j = 0; j < vec[i].len; j++) {
size_t c_len;
idx = vec[i].base - ob.index->buf + j;
c = &(ob.chunks[idx]);
if (!c->len) { /* populate empty chunk */
c->seq = ob.seq_decoder;
c->time = decode_time;
c->bit_rate = bit_rate;
c_len = len > CHUNK_SIZE ? CHUNK_SIZE
: len;
c->len = (uint16_t)c_len;
memcpy(c->data, data, c_len);
} else { /* partially filled chunk */
size_t max = CHUNK_SIZE - c->len;
assert(c->seq == ob.seq_decoder);
c_len = len > max ? max : len;
assert(c_len <= CHUNK_SIZE);
memcpy(c->data + c->len, data, c_len);
c->len += c_len;
assert(c->len <= CHUNK_SIZE);
}
/*
* feed ob.thread ASAP, otherwise ob.thread
* will just play silence
*/
if (c->len == CHUNK_SIZE)
ringbuf_write_advance(ob.index, 1);
assert(len >= c_len);
len -= c_len;
if (!len) {
start_playback();
return dc.action;
}
data = (unsigned char *)data + c_len;
}
}
}
assert(__FILE__ && __LINE__ && "We should never get here" && 0);
return DC_ACTION_NONE;
}
|
