From http://bugs.debian.org/513291
"In mpd.conf, the "admin" permission covers updating the db and
killing mpd.
"Since there are quite some usecases in which the user can upload
music to the mpd's directory by means of anonymous FTP or so, it is
desirable that any user may issue a db update, while killing the mpd
should not be possible.
"I'd suggest to remove the db update from the admin group and either
add it to "control" or an own group."
With mono sound, jack_sample_size is smaller than frame_size (4 vs 2
bytes), and "space/jack_sample_size==0". That means mpd_jack_play()
will return 0, although no error has occurred.
Version 1.0.0 of the libao library added a new field to the
ao_sample_format struct. It is a char * named matrix. When
an ao_sample_format is allocated on the stack, this field contains
garbage. The proper course is to insure that is initialized to NULL.
NULL indicates that we do not want any mapping.
The struct is now initialized using a static initializer, and this
technique is compatible with all known versions of libao.
This fixes the following valgrind warning occuring on the first call of
httpd_output_read_page:
==20124== Conditional jump or move depends on uninitialised value(s)
==20124== at 0x425E65: httpd_output_read_page (httpd_output_plugin.c:240)
==20124== by 0x426087: httpd_output_open (httpd_output_plugin.c:279)
==20124== by 0x41D862: ao_open (output_plugin.h:206)
==20124== by 0x41E133: audio_output_task (output_thread.c:590)
I wanted mpd to play a mp3 stream from a music website. The stream is
only available to subscribers, which restriction is enforced through
normal http authentication. However, the URL I get from the website
is not the final URL of the stream, but a generic URL which points to
the real one through a redirect (code 301). Thus, I cannot predict
the final URL, and so I cannot use the username:password hack to force
the authentication, and mpd (libcurl on mpds behalf) fails to grab the
stream.
libcurl allows the option CURLOPT_NETRC to be set and then the
credentials can be stored in the good old .netrc file (in this case it
would be ~mpd/.netrc, of course). But mpd doesn't set this option. I
think it should.
<stdbool.h> needs to be included unconditionally from definition of
NDEBUG, since »bool« doesn't get defined otherwise.
Signed-off-by: Andreas Wiese <aw-devel@meterriblecrew.net>
Remove the decoder dependency on player_control. All player_control
was needed for is to signal the player thread, and we can do that with
a simple GCond as well.
Allocate a player_control object where needed, and pass it around.
Each "client" object is associated with a "player_control" instance.
This prepares multi-player support.
When a music_chunk to be crossfaded consists only of a tag,
cross-fading is not possible, and led to an assertion failure. This
patch just discards those, as if cross-fading was not enabled.
During the whole output thread, the audio_output object is locked, and
it is only unlocked while waiting for the GCond and while running a
plugin method. The error handler in ao_play_chunk() attempted to lock
the object again, which was code from MPD 0.15.x which should have
been removed a long time ago.
Until the decoder plugin has called decoder_initialized(), the player
may not submit seek commands. This however could occur with a slow
decoder and a CUE file with a virtual song offset. This patch adds
another check.
When you don't explicitly set an output sample rate, liblame tries to
guess an output sample rate from the input sample rate. You would
think that this "guessing" consists of just setting both equal, but
that is not the case. For 44.1kHz at 96kbit/s, liblame chooses
32kHz. This patch explicitly configures the output sample rate, to
stop the bad guessing.
This is a MPD 0.16 regression: when playing a 24 bit file, the switch
to 16 bit was made only partially, after mBytesPerPacket and
mBytesPerFrame had already been applied.
That means mBytesPerFrame referred to 24 bit, and mBitsPerChannel
referred to 16 bits. Of course, that cannot work.
Rename the "version" struct, because it seems to be a reserved name on
Solaris:
"src/decoder/mad_decoder_plugin.c", line 550: (enum) tag redeclared: version
cc: acomp failed for src/decoder/mad_decoder_plugin.c
Should be safe on OS X 10.4 (32-bit), since Apple's OSStatus boils
down to "signed long", and g_set_error() takes gint, which is really
just "int". Assigning "signed long" to "int" on 32-bit Unix should be
just fine, since both are signed 32-bit ints.
No idea if this is safe on 64-bit OS X.
Add new config parameter 'device' to audio_output type "osx":
- if not supplied or set to "default", open default device
- if set to "system", open system device
- otherwise 'device' should be an audio device name: mpd will find and
open the specified audio device, falling back to the default
device if it's not found
this is inconsistent with other commands (e.g. find) and seems wrong --
a song with no stickers attached is a perfectly valid state and an empty
list of stickers is also perfectly valid.
Fixes a regression: for output_plugin.delay(), we added a method to
the timer class which returns the delay in milliseconds. This fails
to detect negative values, because the unsigned integer is divided by
1000, and then casted to signed.
After popular demand, I've switched the order of "artist" and "title"
in the stream title. There is no standard, and there is no reliable
way to parse those from the stream title.
Call access() and print an extra error message when EACCES is
returned. Hopefully this will reduce the number of support requests
due to wrong file permissions.
When one song is played twice, and the decoder is working on the
second "instance", but the first should be seeked, the check in
player_seek_decoder() may assume that it can reuse the decoder without
exchanging pipes. The last thing was the mistake: the pipe pointer
was different, which led to an assertion failure. This patch adds
another check which exchanges the player pipe.
Change the assertion on "fail_timer==NULL" in OPEN to a runtime check.
This assertion crashed when the output thread failed while the player
thread was calling audio_output_open().
When you pass the flag AI_ADDRCONFIG to getaddrinfo(), it does not
consider address families on the loopback device. When run on a
machine without an external network card, just with "lo", it was
unable to look up any address.
Using libffado, to play on firewire audio devices.
Warning: this plugin was not tested successfully. I just couldn't
keep libffado2 from crashing. Use at your own risk.
For details, see my Debian bug reports:
http://bugs.debian.org/601657http://bugs.debian.org/601659
Replaced all occurrences of g_error() with MPD_ERROR() located in a new header
file 'mpd_error.h'. This macro uses g_critical() to print the error message
and then exits gracefully in contrast to g_error() which would internally call
abort() to produce a core dump.
The macro name is distinctive and allows to find all places with dubious error
handling. The long-term goal is to get rid of MPD_ERROR() altogether. To
facilitate the eventual removal of this macro it was added in a new header
file rather than to an existing header file.
This fixes#2995 and #3007.
Added support for a new optional configuration setting for the httpd output
named "bind_to_address". Setting it to a specific IP address (v4 or v6) will
cause the httpd output to bind to that address exclusively. Supporting
multiple addresses in parallel is future work.
This implements the feature requests #2998 and #2646.
According to the mantis bug report 2847, there are several possible
variations of the "album artist" tag:
- "album artist"
- "album_artist"
- "albumartist"
This patch adds support for the latter two.
I've added PIPE_EVENT_SHUTDOWN because calling g_main_loop_quit() do not work when called from another thread.
Main thread was sleeping in g_poll() so I needed some way to wake it up.
By some strange reason call close(event_pipe[0]) in event_pipe_deinit() hangs.
In current implementation that code never reached so that was not a problem :-)
I've added a conditional to leave event_pipe[0] open on Win32.
The ReplayGain filter clamped the gain to max. 100 % even if the
algorithm determined the signal needed a boost. That would result in any
such tracks being played with too low volume, effectively defeating the
purpose of the filter.
Clear the notification before finishing the CANCEL command, so the
notify_wait() after that will always wait for the right notification,
sent by audio_output_all_cancel().
Unfortunately, there's no "optimized" implementation here. We can't
use Linux's proprietary system call dup3(), because it would require
us to specify the new descriptor.
If a song with an absolute path points inside the music directory,
print only the relative part. This happens when partial songs from a
playlist file were loaded.
I've already changed the "playlistinfo" command to hide HTTP
passwords, but forgot to do the same for the simpler "playlist"
command. This patch changes queue_print_uris() to use the code from
song_print_uri().
MPD doesn't have child processes anymore, and thus we're not expecting
to receive SIGCHLD very often. Since hard disk access isn't
interrupted by signals anyway, we don't need those excessive checks.
The function playlist_metadata_load() will overwrite the input buffer
before using the "name" parameter; since "name" points to the same
buffer, we'll get a corrupted string.
Some users reported that MPD crashes when using a new CURL version
with the threaded DNS resolver enabled. It seems that
curl_multi_fdset() returns no file descriptor when the DNS resolver
runs in another thread, so MPD does not have any event to wait for.
On the CURL mailing list, somebody suggested to sleep for a fixed
amount of time. This is not an elegant solution, because daemons
should never have to sleep without waiting for an event. I hope the
CURL developers will review the API and remove the threaded DNS
resolver.
Meanwhile, I'm removing the assertion in question, to allow those
unfortunate users running the latest CURL version to continue using
MPD.
In libwildmidi 0.2.3, the function WildMidi_SampledSeek() was removed,
without changing the SO name. This patch adds an autoconf check for
that function. Fall back to WildMidi_FastSeek() if
WildMidi_SampledSeek() is not available anymore.
libavformat 0.6 does not pass the original URI pointer to the "open"
method, which leads to a crash because MPD was using a dirty hack to
pass a pointer to that method.
This patch switches to av_open_input_stream() with a custom
ByteIOContext class, instead of doing the URI string hack with
av_open_input_file().
Loosely based on a patch from Jasper St. Pierre.
Use the libavformat function av_probe_input_format() to probe the
AVInputFormat, instead of letting av_open_input_file() do it
implicitly. We will switch to av_open_input_stream() very soon, which
does not have the probing code.
Loosely based on a patch from Jasper St. Pierre.
libavformat 0.6 does not pass the original URI pointer to the "open"
method, which leads to a crash because MPD was using a dirty hack to
pass a pointer to that method.
This patch switches to av_open_input_stream() with a custom
ByteIOContext class, instead of doing the URI string hack with
av_open_input_file().
Loosely based on a patch from Jasper St. Pierre.
Use the libavformat function av_probe_input_format() to probe the
AVInputFormat, instead of letting av_open_input_file() do it
implicitly. We will switch to av_open_input_stream() very soon, which
does not have the probing code.
Loosely based on a patch from Jasper St. Pierre.
I've attached a patch that will make file URIs work on operating systems
that provide the getpeereid() function call to check the user ID of the
peer connected to a UNIX domain socket.
I took this tag name from a MusePack sample file I got from a user.
It is not documented in the APE specification:
http://wiki.hydrogenaudio.org/index.php?title=APE_key
People seem to be using undocumented extensions to the specification
anyway, and the best we can do is attempt to support them.
The new function playlist_open_any() combines playlist_mapper_open(),
playlist_list_open_uri() and playlist_list_open_stream(), providing an
easy API for all of them.
Merged both loops into playlist_list_open_stream(). This is needed
because playlist_list_open_stream() needs to know the MIME type, which
is only known after the stream has become "ready".
This buggy implementation failed to allow "..." sequences, because the
dot count was always zero. The usefulness of allowing "..." (or more
dots) is debatable, but since it's a valid file name, we allow it.
libcue's track_get_length() returns 0 for the last track, because that
information is not available in the CUE sheet. This makes MPD quit
playing the last track immediately. If we set "song.end_ms=0", MPD
will play the track until the end of the song file, which is what we
want.
I've attached a patch that will make file URIs work on operating systems
that provide the getpeereid() function call to check the user ID of the
peer connected to a UNIX domain socket.
this greatly improves performance of commands that return a lot
of data, e.g. search results or recursive content of a directory,
while being connected to local mpd via tcp/ip socket.
Memory leak fix. The input_stream object passed to
playlist_list_open_stream_suffix() must be closed by the caller - this
however never happens in playlist_list_open_path(), because it does
not return it to the caller.
Pass sizeof(buf) to decoder_data(), not the number of samples (which
is half the size). At the same time, pass GME_BUF_SIZE to gme_play()
- libgme really wants to get the number of samples, not the number of
stereo frames. Previously, this plugin had been using only the first
half of the buffer.
This is probably unsafe, and doesn't protect against symlink loops,
but we will eventually add this when we bring update*.c and inotify*.c
closer together.
This shouldn't really happen, but insane users might delete/rename the
music directory while MPD runs. What was even more insane was that
MPD crashed due to this. This is a workaround - there is currently
nothing useful we can do in this case; except maybe poll for the music
directory to reappear, but that's too much trouble for a user error.
I took these tag names from a MusePack sample file I got from a user.
These are not documented in the APE specification:
http://wiki.hydrogenaudio.org/index.php?title=APE_key
People seem to be using undocumented extensions to the specification
anyway, and the best we can do is attempt to support them.
Reduce the overhead. Most buffers used by MPD are around 2 to 4 kB.
8 kB seems large enough to keep heap fragmentation low.
Additionally, this patch fixes an off-by-one error in the alignment
formula.
On mingw32, snprintf() expects a 64 bit integer instead of a "long
int" for "%li" - this is not consistent with our expectation, so we're
using plain sprintf().
For some unknown reason, read() blocks on WIN32, even though it was
invoked inside the G_IO_IN callback. By switching to GIOChannel
functions, this problem is solved, and it works on both Linux and
Windows.
On WIN32, use g_io_channel_win32_new_fd() instead of
g_io_channel_unix_new(). There doesn't seem to be a practical
difference, but it seems more correct.
In mingw32, int16_t is not defined by sys/types.h, but it is by stdint.h,
and it is in the int16_t man page as being defined in stdint.h. Thanks to
mithi for help debugging.
Don't add it to the filter chain, because we need to apply replay gain
before cross-fading with the next song. Add a second replay_gain
filter which is used for the song being faded in (chunk->other).
This is useful at the maximum depth level, to update newly created
directories. It is however questionable if the hard-coded 5 seconds
delay is enough to create new directory trees with all of their files,
but we might make that delay configurable in the future.
Without libid3tag, we were trying to skip the ID3 frame (since
0.15.2). Its length however was not calculated at all, we were just
dropping everything from the current input buffer. This lead to the
first few seconds of the file being skipped. This patch attempts to
calculate the ID3v2 frame size with the formula from:
http://www.id3.org/id3v2.4.0-structure 3.1 and 6.2
What's happening is the `ptr' argument to that function is NULL for me
every time. `ptr' is unconditionally dereferenced to generate a log
message, and this is where mpd crashes.
Attached is a simple patch that tests for NULL and omits the log. With
this patch the crash disappeared and mpd went back to working well.
.. rather then append to the end of the previous one
Cuebreakpoints from the cuetools package has three modes of operation,
and the default is to append pregap (INDEX 00) to the end of the
previous track. This is the behavior most compliant to the existing
cue files.
Here is the patch which fixes the issue. I borrowed bits of
implementation from cuebreakpoints. I assumed that the whole audio
file must be covered by head-to-head going tracks, which is how
hardware CD players probably work. In cue_tag I changed rounding from
rounding up to rounding down because the thing in mpd which calculates
actual track duration (and current position) rounds it down, and I
didn't want to see in my playlist values different from whose in a
now-playing progress bar.
I've compared the resultant mpd behaviour with "mplayer -ss MM:SS.MS"
where the time was supplied by cuebreakpoints and noticed that mplayer
started each track a bit earlier then mpd, though this was the same
before the patch.
"When playing musepack files with mpd v0.15.8, rg seems to have no effect.
Using sample file below, mpd says 'computing ReplayGain album scale with gain 122.879997, peak 0.549150'.
One thing though, if I build mpd against old libmpcdec-1.2.6, rg works
as expected: 'computing ReplayGain album scale with gain 16.820000,
peak 0.099765'"
Previously, tags of the new song being cross-faded in were sent
immediately. That can cause wrong information being displayed,
because the "previous" song might send its tag at the end again,
overriding the "next" song's tag. This patch saves & merges the tag
of the next song, and sends it when cross-fading is finished, and the
next song really starts.
When decoder->timestamp is calculated, the PCM data is already
converted to out_audio_format; using in_audio_format may cause funny
speedups/slowdowns.
"There is a bug in fixed-point musepack (musepack_src_r435) playback.
In floating-point audio is OK but in fixed audio is distorted. I have
made a patch for this"
When handle_update() was modified to use uri_safe_local(), suddently
"mpc update ''" and "mpc update '/'" stopped working, because both are
not a "safe" local URI. This patch adds a special case for these, to
retain backwards compatibility.
Did you ever accidently click "stop" while feeding a radio station?
This option sets the output device to "pause" to disable the "close"
method. It falls back to "pause" then, which is specific to the
plugin. Some plugins implement it by feeding silence.
With single+repeat enabled, it is expected that MPD repeats the
current song over andd over. With random mode also enabled, this
didn't work, because the song order was shuffled internally. This
patch adds a special check for this case.
This is a very basic check, which only ensures that the path does not
begin with a slash, doesn't have double slashes and the special names
"." and ".." are forbidden.
Removed the decoder_command_finished() call at the end of
mp3_decode(). This is invalid, because decoder_command_finished() has
already been called in mp3_read().
Add an option for each audio output which enables the use of the
hardware mixer, instead of the software volume code.
This is hardware specific, and assumes linear volume control. This is
not the case for hardware mixers which were tested, making this patch
somewhat useless, but we will use it to experiment with the settings,
to find a good solution.
Apply the replay gain in the output thread. This means a new setting
will be active instantly, without going through the whole music pipe.
And we might have different replay gain settings for each audio output
device.
Don't allocate each replay_gain_info object on the heap. Those
objects who held a pointer now store a full replay_gain_info object.
This reduces the number of allocations and heap fragmentation.
The previous patch not only moved code, it also changed the check.
Negative gain values seem to be valid after all, there just was the
"magic" value 0.0 which means "not available". This patch changes the
"magic" value to "INFINITY", and uses the C99 function isinf() to
check. It might have been a better idea to use "NAN", but the "NAN"
macro is a GNU extension.
When all plugins have failed, MPD used to fall back to the "mad"
decoder plugin, to handle those radio streams without a Content-Type
response header. This however leads to unexpected results (garbage
being played) when the stream isn't really mp3. Since we care little
about "bad" streams, we shouldn't have hacks which have bad side
effects.
Let's get rid of this hack now! Only try to "mad" plugin if there was
no match at all (Content-Type, path suffix) and no other plugin has
been tried.
When enabling the pulse device fails, clear po->mainloop after
pa_threaded_mainloop_free() has finished. This is important for the
assertions.
Two wrong g_free() calls were also removed.
To allow libavformat to detect the format of the input file, append
the suffix of the input file to the URL of the virtual stream. This
specifically enables the "shorten" codec, which is supported by
libavformat/raw.c, detected only by the suffix.
The patch "input/file: don't fall back to parent directory" introduced
a regression: when trying to play a CUE track, decoder_run_song()
tries to open the file as a stream first, but this fails, because the
path is virtual.
This patch fixes decoder_run_song() (instead of reverting the previous
patch) to accept input_stream_open() failures if the song is a local
file. It passes the responsibility to handle non-existing files to
the decoder's file_decode() method.
This function replaces the replay_gain_info parameter for
decoder_data(). This allows the decoder to announce replay gain
changes, instead of having to pass the same object over and over.
Another quirk fixed: after the last chunk of a song has been played,
the "elapsed_time" variable is set to the chunk's time stamp. When
the client receives the PLAYER idle event and asks MPD for the current
time stamp, MPD will return the last time stamp of the previous song
when it hasn't played the first chunk of the current song yet.
This fixes a regression in the patch "return multiple tag values per
song": even when the song has values for the specified tag type, the
empty string gets added to the set, because the "return" was removed.
This patch adds a flag which remembers whether at least one value was
found.
Major API redesign: don't let the caller allocate the input_stream
object. Let each input plugin allocate its own (derived/extended)
input_stream pointer. The "data" attribute can now be removed, and
all input plugins simply cast the input_stream pointer to their own
structure (with an "struct input_stream base" as the first attribute).
This patch changes the following decoder plugins to implement
stream_tag() instead of tag_dup():
faad, ffmpeg, mad, modplug, mp4ff, mpcdec, oggflac
This simplifies their code, because they do not need to take care of
opening/closing the stream.
Make the input_stream implementation hold a reference on the
archive_file object. Allow the caller to "close" the archive_file
object immediately, no matter if the open_stream() method has
succeeded or not.
This replaces the rewinding buffer code from the CURL input plugin.
It is more generic, and allows rewinding even when the server sends
Icy-Metadata (which would have been too difficult to implement within
the CURL plugin).
This is a rather complex patch for the stable branch (v0.15.x), but it
fixes a serious problem: the "vorbis" decoder plugin was unable to
play streams with Icy-Metadata, because it couldn't rewind the stream
after detecting the codec (Vorbis vs. FLAC).
When collecting tag values for the result set, add all of a song's tag
values of the searched type. This affects the "list" command.
Previously, "list" only considered the first tag value of a song.
Seek the decoder to the start of the range before beginning with
playback. Stop the decoder when the end of the range has been
reached. Add the start position to the seek position. Expose the
duration of the range, not the full song file.
Prepend the playlist's base URI to relative song URIs. Look up songs
in the database (if the URI refers to a local song file). Merge
existing database metadata with metadata from the playlist plugin.
Added attributes start_ms, end_ms. This allows us to address a
portion of a song file (important for CUE support). There is no
support yet for storing these attributes in the state file.
Remove the data_time parameter from decoder_data(). This patch
eliminates the timestamp counting in most decoder plugins, because the
MPD core will do it automatically by default.
Don't clear the music pipe when seeking has failed - check the
"seeking" flag instead of "command==SEEK". Clear the "seeking" flag
in decoder_seek_error().
Use the plugin instead of the glue code in normalize.c. This is used
wrapped inside a "autoconv" filter, to enable normalization for all
input file formats.
Make the audio_format argument non-const. Allow the open() method to
modify it, to indicate that it wants a different input audio format
than the one specified. Check that condition in chain_filter_open(),
and fail.
This plugin is the groundwork for MPD's future generic CUE sheet
support. That's not complete yet, e.g. there is no way for a playlist
plugin to address an arbitrary position within a music file.
Fixes a memory leak: the "archive" input plugin opens the archive, but
never closes it. This patch moves the responsibility for doing that
to archive_plugin.open_stream(). This is an slight internal API
change, but it is the simplest and least intrusive fix for the memory
leak.
This fixes an inconsistency in the stored playlist subsystem: when
obtaining the list of playlists (listplaylist, listplaylistinfo), the
file names in the playlist directory are converted to UTF-8 (according
to filesystem_charset), but when saving or loading playlists, the
filesystem_charset setting was ignored.
If both tags (stream and decoder) are present, we prefer the stream tag.
Fixes#2698, where ICY tag contained useful information, but was
overwritten with bogus decoder tag data.
This patch prepares support for floating point samples (and probably
other formats). It changes the meaning of the "bits" attribute from a
bit count to a symbolic value.
The plugin code tried to force libavcodec to supply stereo samples.
That however has never actually worked. By removing this code, we are
able to play surround files for the first time.
Removed the "vtrack" local variable (which triggered a gcc warning
because it was after the newly introduced NULL check), and run
strtol() on the original parameter.
Allow RIFF/AIFF ID3 tags up to 4 MB (old limit was 256 kB). This
might still be too small for some users, and when somebody complains,
we might do something more clever (like streaming the data into
libid3tag?).
On some platforms, libavcodec wants the output buffer aligned to 16
bytes (because it uses SSE/Altivec internally). It will segfault when
you don't obey this rule.
When waiting for the decoder to provide more data, the player thread
generates silence chunks if needed. However, it forgot to initialize
the chunk.times attribute, which had now an undefined value. This
patch sets it to -1.0, meaning "value is undefined". Add a ">= 0.0"
check to audio_output_all_check(). This fixes spurious relative
seeking errors, because sometimes, the "elapsed" value falls back to
0.0.
After we've been hit by Large File Support problems several times in
the past week (which only occur on 32 bit platforms, which I don't
have), this is yet another attempt to fix the issue.
MPD has been supporting 32 bit samples since version 0.15. This patch
changes one check, and removes the 32->24 conversion code.
Note that WavPack floating point samples have 32 bits, and MPD doesn't
have a special check for floating point - therefore, this WavPack
plugin still returns 24 bit integer samples as before (until we have
float support in the MPD core).
Call decoder_initialize() before entering the loop. We don't need to
call ov_read() before ov_info(). When the stream number changes,
check if the audio format is still the same.
Don't update a float timestamp, this will make imprecisions add up
after a while. We already have the number of the current frame, let's
just calculate the float timestamp from that for every decoder_data()
command. For this, we need to add the attribute "first_frame", for
CUE sheet songs.
Removed the "bit_rate" attribute from the flac_data struct. Pass the
number of bytes since the last call to flac_common_write(), and let
it calculate the bit rate.
We don't want to work with floating point values if possible. Get the
integer number of frames from the FLAC__StreamMetadata_StreamInfo
object, and convert it into a float duration on demand. This patch
adds a check if the STREAMINFO packet has been received yet.
The decoder loop of flac_decode_internal(), flac_container_decode()
and flac_filedecode_internal() is merged into this one function. This
unifies the code, and uses the frame number to identify the end of a
CUE sub song.
If flac_container_decode() gets a seek destination which is out of
range, it ignores the SEEK command (never finishes it). This leads to
MPD lockup, because the player thread waits for completion.
When using wave encoder with httpd audio output mpd can input this stream via http and audiofile decoder.
This for example opens simple way to configure lossless audio streaming port(like jack or pulseaudio does but without overhead).
Another possibility can be using it for gathering raw data for visualization plugins (If sync issue will be resolved)
This is a great simplification for flac_common_write(), because we can
convert and submit all of the buffer in one turn. No more partial
buffers with complicated formulas.
Drop the required GLib version from 2.16 to 2.12, because many current
systems still don't have GLib 2.16. This requires several new
compatibility functions in glib_compat.h.
ALSA passes full period buffers to the hardware. If an application
doesn't finish writing a period, libasound will nonetheless send the
partial buffer (with undefined trailing data). This causes noise at
the end of playback. This patch attempts to track the current
position within the period buffer, and generates silence at the end,
before calling snd_pcm_drain().
When there's no queued song, and the current one has finished playing,
first make sure that the hardware outputs have really finished playing
the last chunk: call the drain() method in all audio outputs. Without
this patch, MPD stopped playback shortly before the ALSA sound card
had finished playing.
Added the "fd_util" library, which attempts to use the new thread-safe
Linux system calls pipe2(), accept4() and the options O_CLOEXEC,
SOCK_CLOEXEC. Without these, it falls back to FD_CLOEXEC, which is
not thread safe.
This is particularly important for the "pipe" output plugin (and
others, such as JACK/PulseAudio), because we were heavily leaking file
descriptors to child processes.
When an output's enable() method has failed, and playback starts,
retry to enable it. Without this, the user may be confused, because
he sees the device is "enabled" but cannot use it, and currently there
is no error message in the log.
Moved the global input stream opener to decoder_run_stream().
decoder_run_file() now opens the input stream each time a plugin
provides a stream decoder method.
Same as the previous patch: create up to 16 configured source ports.
The plugin tries to do its best at guessing the right combination for
the given input file, the number of source and destination ports.
This patch allows the client to load a playlist file from the playlist
directory with a plugin. This can be used with the "load" command,
but the client has to pass the file name including the suffix. We
will probably use the music directory in the future, to support
playlist files inside the music directory.
If one plugin has failed to open the playlist, it may have consumed a
part of the stream already. This may lead to a failure in all
following plugins. Fix: rewind the stream before each open() call.
Implement the methods enable() and disable(). Bind the HTTP port in
the enable() method, but reject all incoming connections until the
output is opened.
After playback has stopped, the ring buffers may still contain
samples. These will be played when playback is started the next
time. We should clear the buffers each time.
jack_client_new() is deprecated. This requires libjack 0.100
(released nearly 5 years ago). We havn't been testing older libjack
versions anyway.
As a side effect, there is the new option "autostart".
When a song's tags could not be loaded during database update, log
this as a debug message. Same for a song being removed because its
updated tag could not be read.
Store a list of supported tag items in the database. When loading a
database which does not have a matching list, we must rescan in order
to get the missing information.
When the decoder finishes the "queued" song very quickly (before the
"current" song finishes playing), an assertion in do_play() fails
because it thinks that it should start decoding the queued song,
although that has in fact just finished.
This is only a slight change to the previous locking behaviour: keep
the decoder unlocked during the loop, and lock it only while checking
decoder_control.command.
Reintroduce a fix from commit 52a0653 (Warren Dukes): "don't call
snd_pcm_drain unless we're already in the RUNNING state". This prevents
ALSA with dmix from sometimes hanging when snd_pcm_drain is called, e.g.
when moving from one song to the next (as in mantis issue 2634).
While paused, the player thread re-locks its mutex and waits for a
signal. This is racy: when the command is set while the thread is
waiting for the lock, it may wait forever. This patch adds another
command check before player_wait().
After CANCEL, the output thread waits for another signal before it
continues playback, to synchronize with the caller. There were some
situations where this signal wasn't sent properly. This patch adds an
explicit g_cond_signal() at two code positions.
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).
