These parameters must be protected with a mutex, too. Wrap everything
inside player_lock()/player_unlock(), and use player_command_locked()
instead of player_command().
After CANCEL, call g_cond_wait() only if the new command is still
NONE. Problem is that ao_command_finished() has to unlock the
audio_output object, and in the meantime, the player thread might have
submitted a new command.
Use a single GString buffer object in all functions loading the
database. Enlarge it automatically for long lines. This eliminates
the maximum line length for tag values. There is still an upper limit
of 512 kB to prevent denial of service, but that's reasonable I guess.
Allocate the directory object after the "directory:" line. Assign the
mtime from the input file to this new object, instead of to the parent
directory.
The line buffer had a fixed size of 5 kB, and was allocated on the
stack. This was too small for some users. As a hotfix, we're
increasing the buffer size to 32 kB now, allocated on the heap. In
MPD 0.16, we'll switch to dynamic allocation.
Use GMutex/GCond instead of the notify library. Manually lock the
player_control object before accessing the protected attributes. Use
the GCond object to notify the player thread and the main thread.
Right after seeking and song change, the elapsed_time shows old
information, because the output thread didn't finish a full chunk
yet. This patch re-adds a second elapsed_time variable, and keeps
track of a fallback value, in case the output thread can't provide a
reliable value.
Return false when there was no chunk in the pipe. If the function
returns true, then audio_output_task() will not wait for a notify from
the player thread. This fixes a race condition.
Don't set the error in play_chunk(); do all the error handling in the
caller. The errored_song attribute isn't set anymore; it doesn't make
sense for PLAYER_ERROR_AUDIO.
drain() is the opposite of cancel(): it waits until all data in the
buffer has finished playing. Instead of implicitly draining in the
close() method like the ALSA plugin has been doing it forever, let the
output thread decide whether to drain or to cancel.
Convert the metadata with the libavformat function av_metadata_conv().
This ensures that canonical tag names are provided by libavformat, and
we can remove the "artist" vs "author" workaround.
When you disable the "follow_outside_symlinks" or the
"follow_inside_symlinks" setting, the next update should remove the
now-ignored files from the database.
With these methods, an output plugin can allocate some global
resources only if it is actually enabled. The method enable() is
called after daemonization, which allows for more sophisticated
resource allocation during that method.
Don't let the mixer plugin "override" the libpulse callbacks.
Instead, add a "mixer" attribute to the pulse_output struct, and call
the mixer on all interesting events.
If the method get_volume() returns -1 and no error object is set, then
the volume is currently unavailable, but the mixer should not be
closed immediately.
This is a complete rewrite of the PulseAudio output plugin. It uses
the asynchronous API, which gives us more control over everything.
Additionally, it connects to the PulseAudio server on startup, and
keeps this connection up while MPD runs. During pause, instead of
closing the stream, it enables "cork".
I'm not sure about the advantages of calling g_set_application_name(),
because I don't use a task manager (except for ps and kill), but it
sure doesn't hurt.
svn r13289 of libvorbis introduced static callbacks (like OV_CALLBACKS_DEFAULT)
defined in "vorbisfile.h" header. First released version with this change is libvorbis-1.2.2.
In libversion-1.2.3 OV_EXCLUDE_STATIC_CALLBACKS define was added to avoid
warnings about unused static callbacks. Information on the OV_EXCLUDE_STATIC_CALLBACKS
can be found in http://svn.xiph.org/trunk/vorbis/CHANGES.
It will be possible to enable replay gain at runtime even when it is
disabled in the configuration file. This patch enables the preamp
settings in this case.
Don't initialize "vc" and "cs" with FLAC__metadata_object_new(); that
value is overwritten by FLAC__metadata_get_tags() and
FLAC__metadata_get_cuesheet().
When the player thread unpauses, it sends CANCEL to the output thread,
after having checked that the output is still open. Problem is when
the output thread closes the device before it can process the CANCEL
command - race condition. This patch adds another "open" check inside
the output thread.
When the audio output fails to open, MPD pauses playback, but doesn't
reset player.play_audio_format. This leads to an assertion failure in
audio_output_all_check() on the next REFRESH command, because no audio
output is open.
This has been replaced by the last.fm playlist plugin. The input
plugin has never worked well, and was just a playground to experiment
with the last.fm radio protocol.
When the connection is lost while buffering, the CURL input plugin may
enter an endless loop, because it does not check the EOF condition.
This patch makes fill_buffer() return success only if there's at least
one buffer, which is enough of a check.x
Accidently, MPD has been using several GLib 2.16 functions for a
while, and nobody noticed yet. To simplify the code base, let's bump
the minimum GLib version for MPD to 2.16. That version is old enough,
and it's reasonable to expect users to have it.
Based on this API, we will add parsers for EXTM3U, PLS, ASX, last.fm
radio and others.
There is no integration into the MPD core yet. Right now, we have a
command line test program. This is work in progress.
The "off_t" type may change when you enable or disable large file
support on 32 bit platforms. This caused severe ABI problems within
MPD when we enabled LFS for the first time: two sources included
config.h and sys/types.h in different order, and had different off_t
sizes - leading to memory corruption because of ABI incompatibility.
This patch attempts to get rid of all public "off_t" uses: it removes
"off_t" from the input_stream ABI/API, and switches to GLib's 64 bit
"goffset" type. This may hurt 32 bit embedded platforms a tiny bit,
but that's not even measurable.
On 32 bit systems with large file support enabled (i.e. "sizeof(off_t)
> sizeof(size_t)") gcc emits a warning because a size_t cast to off_t
can never become negative.
When there is no Content-Type response header, try the "mad" decoder
plugin. It uesd to be named "mp3", and we forgot to change the
fallback name in decoder_thread.c.
When a received chunk of data has only icy-metadata, there was no
usable data left for input_curl_read() to return, and thus it returned
0 bytes. "0" however is a special value for "end of file" or
"error". This patch makes input_curl_read() read more data from the
socket, until the read request can be fulfilled (or until there's
really EOF).
Tracking the "elapsed" time from the chunks which we have sent to the
output pipe is very imprecise: since we have implemented the music
pipe, we're sending large number of chunks at once, giving the
"elapsed" time stamp a resolution of usually more than a second.
This patch changes the source of this information to the outputs. If
a chunk has been played by all outputs, the "elapsed" time stamp is
updated.
The new command PLAYER_COMMAND_REFRESH makes the player thread update
its status information: it tells the outputs to update the chunk time
stamp. After that, player_control.elapsed_time is current.
The new player_status struct replaces a bunch of playerGetX()
functions. When we add proper locking to the player_control struct,
we will only need to lock once for the "status" command.
No more CD player emulation. The current behaviour of "previous" is
difficult for a client to predict, because it does not definitely know
the current position within the song. If a client wants to restart
the current song, it can always send "playid".
If nothing has changed since the last save, don't save the state
file. Saving will spin up the hard drive, which is undesirable on
hosts where MPD is idling in background.
Usually, we read our "artist" tag from ffmpeg's "author" tag. In some
cases however (e.g. APE), this tag is named "artist". This patch
implements a fallback: if no "author" is found, MPD tries to use
"artist".
When the ID3 tag in an AAC file is larger than the current buffer, the
function decoder_buffer_consume() aborts. By using the new function
decoder_buffer_skip() instead, we can safely skip the ID3 tag.
This patch implements a light-weight inotify library, and watches all
directories below the music directory. It updates all directories
where files changed after a delay of 5 seconds.
Allow most printable characters in unquoted words. The tokenizer
patch introduced very strict requirements for command parameters -
those were undocumented, and we're reverting the strictness now.
Don't call g_error(), which will abort the process and dump core.
This patch does not affect all the config_get_X() functions. These
need some more refactoring.
using ov_test_callback with function CALLBACKS_STREAMONLY will cause
scanning to stop after the comment field. ov_open (and ov_test)
default to CALLBACKS_DEFAULT which scans the file structure causing a
huge slowdown. The speed improvement is huge: It scanned my files
around 10x faster This procedure has been recommended by monthy (main
vorbis developer) and was said to be safe for scanning files.
The recorder plugin writes audio played by MPD to a file. This may be
useful for recording radio streams.
This implementation is incomplete, because support for tags is
missing, and MPD should be able to record each track to a different
file.
MPD checks if every flac (possibly other types as well) file contains
cuesheet on every update, which produces unneeded I/O. My music
collection is on NFS share, so it's quite noticeable. IMHO, it
shouldn't re-read unchanged files, so I wrote simple patch to fix it.
Explicitly make the output thread leave the ao_pause() loop. This
patch is a workaround, and the "pause" flag is not managed in a
thread-safe way, but that's good enough for now.
The function flac_cue_track() first calls FLAC__metadata_object_new(),
then overwrites this pointer with FLAC__metadata_get_cuesheet(). This
allocate two FLAC__StreamMetadata objects, but the first pointer is
lost, and never freed.
Replace decoder_control.notify with decoder_control.mutex and
decoder_control.cond. Lock the mutex on all accesses to
decoder_control.command and decoder_control.state.
For systems that cannot support fork() (like no-mmu Linux), use daemon() if
it is available for the daemonizing code.
Signed-off-by: Mike Frysinger <vapier@gentoo.org>
Splitted tag_id3_import_frame() into two specialized functions:
tag_id3_import_text() and tag_id3_import_comment(). Use
id3_frame_field() instead of directly accessing id3_frame.fields.
Added a patch to flush out the last.fm input plugin slightly. It
basically turns it into a wrapper for the appropriate plugin. Most
notably metadata is now extracted.
Instead of hard-coding the path "/etc/mpd.conf", use the configured
$(sysconfdir) path. This can be set with:
./configure --sysconfdir=/etc
Note that this changes the default path to "/usr/local/etc/mpd.conf",
given the default prefix "/usr/local". This is actually more correct
than the old default.
Calculate the total play time with the audio_format object each time,
using audio_format_time_to_size(). The function
audioFormatSizeToTime() is not needed anymore, and will be removed
with this patch.
Currently, byteswapping is performed on the format_buffer. This can
go wrong when this buffer is used twice during one run. Add a
separate buffer for swapping the byte order.
Changed function to first close standard input (this may
fail but we don't care) and then try to open /dev/null (this
may fail but it shouldn't on Unix platforms plus we don't
know what to do in such case anyways). Since standard input
has the "zeroth" descriptor number next "open" will use it.
Since there is no "/dev/null" on Windows (It's not even
a valid path!) the second step is skipped if WIN32 is
defined.
As a final touch, since the function consists of merely two
function calls it has been moved to header file and declared
static inline.
[mk: un-inline daemonize_close_stdin()]
When libid3tag is disabled, the libmad decoder plugin is unable to
identify ID3 frames. If the file starts with an (unidentified) ID3
frame, it assumes that the file is not a valid MP3 song. This patch
solves this by adding minimal stubs for the ID3 functions.
The function tag_ape_load() retrieves a 32 bit unsigned integer from
the input file, and passes it to g_malloc(). This is dangerous, and
may be used for a denial of service attack on MPD.
On Windows only daemonize_close_stdin() function does
something. Other functions are either empty or generate an
error. Those have been moved to header file and declared
static inline so compiler can remove the call all together.
The functions were not "const" (they examined values pointed
by arguments passed to them, quoting gcc's doc: "Note that
a function that has pointer arguments and examines the data
pointed to must _not_ be declared 'const'.") but rather
"pure" and still not all of them.
Note also, that even some of the functions declared "pure"
are not pure, however, due to reasons stated in source code
the attribute has been kept.
The "group" configuration option is similar to "user" as it
sets user set what group MPD shall run as. With "user"
option, MPD changed GID to the GID of the user, however,
more control could be desired.
Moreover, the patch changes the way of checking whether no
setuid(2)/setgid(2) is required -- previously user names
were compered, now UID and GIDs are compered (ie. the one we
already have (getuid(2)/getgid(2)) with the one we want to
change to).
The expression "tagLen - size > 0" may result in an integer underflow
and a buffer overflow, when "size" is larger than "tagLen". "size" is
read from the input file, and must not be trusted. This patch changes
the expression to "tagLen > size", which is a lot safer.
The glue_*() functions act as a glue between MPD's main() function and
its libraries. They handle disabled features, and pass validated
configuration options.
Since version 0.14, MPD has been logging to standard error instead of
standard output. The option name should reflect that. The old option
continues to work, we will remove it in a future MPD release.
This encoder plugin is a replacement for the LAME encoder plugin for
those who prefer a "free" (non-patent encumbered) encoder library.
Most of the plugin source code is copied from the LAME encoder plugin,
since the LAME and TwoLAME APIs are nearly the same.
According to the ID3 2.4 documentation, "TOPE" is "Original
artist/performer", not "performer". Removed "TOPE" support. Instead,
map TPE3 ("Conductor/performer refinement") and TPE4 ("Interpreted,
remixed, or otherwise modified by") to "performer".
The tag_id3.c library supports both the documented "TSO2" tag, and the
inofficial TXXX/ALBUMARTISTSORT.
The Vorbis/FLAC decoder automatically supports the new tag, without
further change.
Do all the software volume stuff inside each output thread, not in the
player thread. This allows one software mixer per output device, and
also allows the user to configure the mixer type (hardware or
software) for each audio output.
This moves the global "mixer_type" setting into the "audio_output"
section, deprecating the "mixer_enabled" flag.
This mixer plugin may be used instead of the traditional global
software mixer. It integrates with the "volume" filter plugin, and
can control the software volume of an audio output which has no
hardware mixer.
Converted the range checks in volume_level_change() to assertions.
Changed all volume types to "unsigned", expect for those which must be
able to indicate error (-1).
When song->mtime was not initialized properly, it was revealed that
strftime() might crash when gmtime_r() returns NULL due to an invalid
time_t input value.
This patch adds initial filter support for audio outputs. Each audio
output gets a "filter" attribute, which is used by ao_play_chunk().
The PCM conversion is now performed by convert_filter_plugin.
audio_output.convert_state has been removed.
A recent change to the boolean parser introduced a bug: instead of
using the block_param's value with get_bool(), we passed param->value
(which is always NULL in this case).
Some clients have visual feedback for "database update is running".
Using the "database" idle event is unreliable, because it is only
emitted when the database was actually modified. This patch adds the
"update" event, which is emitted when the update is started, and again
when the update is finished, disregarding whether it has been
modified.
The "volume" filter plugin will replace the current software volume
code. One "volume" filter may be attached to each output device.
This will allow the user to use hardware mixers for some devices, and
software mixers for other devices at the same time.
Currently, neither the filter API nor the "volume" plugin is
integrated into MPD.
When the filesystem_charset is changed in mpd.conf, MPD should discard
the old database. In this error branch, MPD did not fill the GError
object properly, and logged a warning message instead, which caused a
segmentation fault.
This patch fixes an assertion failure:
Assertion `order < queue->length' failed.
This happens when the state file is saved, when there is no "current"
song: current==-1, and queue_order_to_position(-1) is called.
When MPD was paused, and the client sent the "stop" command (or
"clear"), a glitch caused MPD to continue playback for a split second.
This was because audio_output_all_cancel() calls
audio_output_all_update(), which reopens all output devices, and
re-ignites the playback loop.
At the moment mpd doesn't store or restore the current track to/from
its state file when the daemon is stopped/started while in 'stopped'
state. I believe the preferred behaviour would be to store and
restore the current track even when the daemon is in stopped state
when shutting down.
I made a small patch to adapt this behaviour. If you believe this is
not the preferred behaviour, maybe this should be realized as a
configuration option. I'm not sure how to do this, but made a small
comment, where one would have to put the option.
Instead of returning an artificial three-state integer, return a
"success" value and put the boolean value into a "bool" pointer.
That's a little bit more overhead, but an API which looks more
natural.
When decoding a local file, the decoder thread tries to run all
matching decoders, until one succeeds. Both file_decode() and
stream_decode() can decode a stream, but MPD closes the stream before
calling file_decode(). Problem is: when this decoder fails, and the
next's stream_decode() method is invoked, the input_stream is still
closed. This patch reopens it.
Several users had problems with binding MPD to "localhost". The cause
was duplicate /etc/hosts entries: the resolver library returns
127.0.0.1 twice, and of course, MPD attempts to bind to "both" of
them. This patch makes failures non-fatal, given that at least one
address was bound successfully. This is a workaround; users should
rather fix their /etc/hosts file.
When client_defer_output() aborts the connection to the client,
client_write_output() called client_write_deferred() anyway. This
caused an assertion failure. Fix it by checking for the "expired"
flag again after client_defer_output() returns.
When the decoder is finished, break out of the player loop only after
another player.pipe check. We did check the pipe size a few lines
above, but that check was kind of racy.
When a music_chunk only contains a tag but no PCM data, play_chunk()
returns true without freeing the chunk. The caller now assumes that
the chunk is moved into some music_pipe and does not bother to free it
either.
To check for leaked music_chunk objects, free the music buffer on
CLOSE_AUDIO. This invokes an assertion check which ensures that all
chunks have been returned to the buffer.
Instead of returning the local variable "ret" which is always true at
this point, hard-code the "true" return value, because that might be
more readable.
If a file is removed the library, next time mpd will try to play it it
will result in an error 'ERROR: problems decoding some/file.ogg'.
Nothing is written in log files (verbose mode or not)
[mk: append strerror(errno)]
Commit f78cddb4 introduced a regression: when the playlist reached its
end, MPD did not reset the "current song" pointer anymore after stop.
Add a "current = -1" code line.
The only pc_seek() caller clears the error, rendering the check
useless. Even if the previous PLAY command resulted in a player
error, this check is not very useful.
Flush the encoder before calling encoder_tag(). The first page
generated by the encoder after sending the tag will be the new
"header" page, which is sent to all HTTP clients when they connect.
This is a little bit specific to the vorbis encoder, but there are no
other encoders which support tags (yet).
When a new tag is set, end the current stream and begin a new one.
Use vorbis_analysis_headerout() to write a full ogg header. This
fixes a problem with icecast: after a song change in MPD, icecast
stops forwarding ogg packets to its clients.
When a song was in the database twice (which shouldn't happen), and
the first song had no tag items, MPD calledd tag_free(NULL). Add a
check to that source location, and an assertion to tag_free().
libvorbis goes into a very long loop if we try to add data after a
flush was invoked by vorbis_analysis_wrote(0). This seems to be a
problem with the internal end-of-stream marker. Thus, we cannot reuse
the vorbis_dsp_state object.
When the decoder thread has a pending command, send the STOP command
to cancel this command. Send STOP again if the decoder thread is
still running after that, just in case the decoder thread has executed
the previous command (which was overwritten).
Using two different kinds of locks may result in a race condition with
a deadlock. The libpulse callbacks need no locks at all, because the
mainloop object can be assumed to be already locked.
When all audio outputs have been closed due to failures, pause the
playback instead of stopping it. This way, the user may resume
at the current position after the problem has been dealt with.
When no audio outputs could be opened while seeking, leave MPD seeked
at that position and pause playback. The user may continue from this
point at any time, as soon as the audio outputs are fixed. The old
behaviour triggered an assertion failure: the failure wasn't passed
properly to the do_play() function, which attempted to play audio
chunks.
snd_config_update_free_global() frees cached ALSA configuration. This
keeps valgrind a little bit more quiet. This patch moves the call
from the open() method into the finish() method, which seems more
natural: it allows the use of the config cache, and improves the
cleanup phase.
[mk: folded with patch "Put icy related functions in extra source
files"; moved icy_server.c from HAVE_CURL to ENABLE_HTTPD_OUTPUT;
removed an unused variable]
When a new song starts playing, send its tag (song->tag) to the music
pipe. This allows output plugins to render tags for all songs, not
only those with embedded tags understood by the decoder plugin.
db_get_song was being called once for all sub-handlers, but with the
addition of the find command, we don't have a URI coming in, so doing
db_get_song once won't work anymore.
[mk: fixed initialization order]
On both locations, the result of write() can be ignored safely. In
event_pipe_emit_fast(), that can only be "EAGAIN", which means that
the pipe buffer is full - no further notification required. In
client_init(), that would be a fatal connection error, which would be
caught by the next event.
This patch fixes gcc warnings.
Cuesheets are often saved as vorbis comment
flac files (CUESHEET=.. case doesn't matter).
We can parse this now and use the information to
tag the subtracks (from the embedded cuesheets).
With these methods a tag struct can be created
from the cdtext information in a cue sheet.
The methods depend on a cue parsing library.
Reading from strings (char*) as well as from
a file (FILE*) is supported.
This is a little ugly, but as nextSongInPlaylist is both called when
queued is update (in case playlist ended) and for user "next" command,
there isn't any other (simple) solution
Previous cast to float didn't have any effect because one value is uint
and the other is a floating type but the number itself is even..
This caused some tracks to end before they were really at an end.
The strings passed to tag_pool_get_item() are not null-terminated, and
the caller passes the string length. Don't assume it is
null-terminated anyway by using strcmp().
There are numerous race conditions between the libpulse thread
(pulse_mixer.c callbacks) and the rest of MPD. Protect the volatile
attributes of the pulse_mixer struct with a mutex to fix that.
Don't mess with pulse_mixer.volume for setting the volume. This
variable should only be used to transfer the current volume from
sink_input_vol() to pulse_mixer_get_volume().
The pa_context_get_sink_input_info() function is asynchronous, and
after it returns, libpulse does not guarantee that the operation has
completed yet; in fact, it is not likely. Explicitly wait for the
operation to complete.
The code for the new pulse_wait_for_operation() function was inspired
by mplayer and xine code.
The function mixer_failed() expects the mixer mutex to be already
locked, yet it calls mixer_close(), which attempts to lock the mutex
again, deadlocking itself.
The smartstop feature is a way to tell mpd to stop playing after
current song.
This patche provides:
- 'state' command returns 'smartstop' state (1 or 0)
- 'smartstop' can activate or not the smartstop state
- when song is terminated, mpd stops playing and smartstop is set to 0
This patch fixes a longer delay when moving around songs in the
playlist. The main thread wants to enqueue a new "next" song into the
player thread, but the player thread is waiting inside
audio_output_all_wait() for the output threads. Use
player_control.notify there, so audio_output_all_wait() gets woken up
by the main thread, too.
The functions playPlaylist() and seekSongInPlaylist() expect a song
position, not a song order number. Don't convert the "current"
variable with queue_position_to_order().
The move command now accepts a range for the first argument, in the same
form as other range commands, e.g. move 15:17 3. The first song in the
range is placed at the destination position. Note that as with other
range commands, the range is inclusive on the left only; this example
would move only songs 15 and 16, not 17.
[mk: fixed signed/unsigned warnings; use G_MAXUINT instead of
UINT_MAX]
The pm->volume attribute was allocated in pulse_mixer_init(), but is
never freed. This leaks memory. Instead of adding the g_free() call
to pulse_mixer_finish(), let's just make "volume" a static attribute
of the pulse_mixer struct. That is easier to deal with.
Nobody needs to modify these strings. We can make them const, and
convert config_dup_block_string() to config_get_block_string(). This
also fixes memory leaks in the pulse mixer.
