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.
