oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

remove unused sources

Browse Source 
These are results from failed merges which I didn't notice.
This commit is contained in:
Max Kellermann 2008-10-24 17:41:13 +02:00
parent f4e6bb2815
commit 18c6ebb023
2 changed files with 0 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
src/outputBuffer_accessors.h
View File

@ -1,88 +0,0 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
* This project's homepage is: http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Some of the most boring code in the world that I didn't want cluttering
* up outputBuffer.c
*/
unsigned long ob_get_elapsed_time(void)
{
return (unsigned long)(ob.elapsed_time + 0.5);
}
unsigned long ob_get_total_time(void)
{
return (unsigned long)(ob.total_time + 0.5);
}
unsigned int ob_get_bit_rate(void)
{
return (unsigned int)ob.bit_rate;
}
unsigned int ob_get_channels(void)
{
return (unsigned int)ob.audio_format.channels;
}
unsigned int ob_get_sample_rate(void)
{
return (unsigned int)ob.audio_format.sampleRate;
}
unsigned int ob_get_bits(void)
{
return (unsigned int)ob.audio_format.bits;
}
void ob_set_sw_volume(int volume)
{
ob.sw_vol = (volume > 1000) ? 1000 : (volume < 0 ? 0 : volume);
}
void ob_set_xfade(float xfade_sec)
{
ob.xfade_time = (xfade_sec < 0) ? 0 : xfade_sec;
}
float ob_get_xfade(void)
{
return ob.xfade_time;
}
enum ob_state ob_get_state(void)
{
return ob.state;
}
AudioFormat *ob_audio_format(void)
{
return &ob.audio_format;
}
uint8_t ob_get_decoder_sequence(void)
{
return ob.seq_decoder;
}
uint8_t ob_get_player_sequence(void)
{
return ob.seq_player;
}

133
src/outputBuffer_ob_send.h
View File

@ -1,133 +0,0 @@
/*
* 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;
}