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

Merge tag 'v0.19.5'

Browse Source
This commit is contained in:
Max Kellermann
2014-11-26 20:19:17 +01:00
parent 12b6959ea2 67cba251c8
commit 737a56a030
17 changed files with 140 additions and 430 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/archive/plugins/ZzipArchivePlugin.cxx
View File

@@ -168,12 +168,13 @@ bool
ZzipInputStream::Seek(offset_type new_offset, Error &error)
{
zzip_off_t ofs = zzip_seek(file, new_offset, SEEK_SET);
if (ofs != -1) {
if (ofs < 0) {
error.Set(zzip_domain, "zzip_seek() has failed");
offset = ofs;
return true;
return false;
}
return false;
offset = ofs;
return true;
}
/* exported structures */

4
src/decoder/DecoderList.cxx
View File

@@ -37,7 +37,6 @@
#include "plugins/MadDecoderPlugin.hxx"
#include "plugins/SndfileDecoderPlugin.hxx"
#include "plugins/Mpg123DecoderPlugin.hxx"
#include "plugins/Mp4v2DecoderPlugin.hxx"
#include "plugins/WildmidiDecoderPlugin.hxx"
#include "plugins/MikmodDecoderPlugin.hxx"
#include "plugins/ModplugDecoderPlugin.hxx"
@@ -55,9 +54,6 @@ const struct DecoderPlugin *const decoder_plugins[] = {
#ifdef ENABLE_MPG123
&mpg123_decoder_plugin,
#endif
#ifdef HAVE_MP4V2
&mp4v2_decoder_plugin,
#endif
#ifdef ENABLE_VORBIS_DECODER
&vorbis_decoder_plugin,
#endif

330
src/decoder/plugins/Mp4v2DecoderPlugin.cxx
View File

@@ -1,330 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h" /* must be first for large file support */
#include "Mp4v2DecoderPlugin.hxx"
#include "../DecoderAPI.hxx"
#include "CheckAudioFormat.hxx"
#include "tag/TagHandler.hxx"
#include "fs/Path.hxx"
#include "util/Error.hxx"
#include "util/Domain.hxx"
#include "Log.hxx"
#include <mp4v2/mp4v2.h>
#include <neaacdec.h>
#include <cstdio>
#include <cstdlib>
static constexpr Domain mp4v2_decoder_domain("mp4v2");
static MP4TrackId
mp4_get_aac_track(MP4FileHandle handle, NeAACDecHandle decoder,
AudioFormat &audio_format, Error &error)
{
unsigned long sample_rate;
const MP4TrackId tracks = MP4GetNumberOfTracks(handle);
for (MP4TrackId id = 1; id <= tracks; id++) {
const char* track_type = MP4GetTrackType(handle, id);
if (track_type == 0)
continue;
const auto obj_type = MP4GetTrackEsdsObjectTypeId(handle, id);
if (obj_type == MP4_INVALID_AUDIO_TYPE)
continue;
if (obj_type == MP4_MPEG4_AUDIO_TYPE) {
const auto mpeg_type = MP4GetTrackAudioMpeg4Type(handle, id);
if (!MP4_IS_MPEG4_AAC_AUDIO_TYPE(mpeg_type))
continue;
} else if (!MP4_IS_AAC_AUDIO_TYPE(obj_type))
continue;
if (decoder == nullptr)
/* found audio track, no decoder */
return id;
unsigned char *buff = nullptr;
unsigned buff_size = 0;
if (!MP4GetTrackESConfiguration(handle, id, &buff, &buff_size))
continue;
uint8_t channels;
int32_t nbytes = NeAACDecInit(decoder, buff, buff_size,
&sample_rate, &channels);
free(buff);
if (nbytes < 0)
/* invalid stream */
continue;
if (!audio_format_init_checked(audio_format, sample_rate,
SampleFormat::S16,
channels,
error))
continue;
return id;
}
error.Set(mp4v2_decoder_domain, "no valid aac track found");
return MP4_INVALID_TRACK_ID;
}
static NeAACDecHandle
mp4_faad_new(MP4FileHandle handle, AudioFormat &audio_format, Error &error)
{
const NeAACDecHandle decoder = NeAACDecOpen();
const NeAACDecConfigurationPtr config =
NeAACDecGetCurrentConfiguration(decoder);
config->outputFormat = FAAD_FMT_16BIT;
config->downMatrix = 1;
config->dontUpSampleImplicitSBR = 0;
NeAACDecSetConfiguration(decoder, config);
const auto track = mp4_get_aac_track(handle, decoder, audio_format, error);
if (track == MP4_INVALID_TRACK_ID) {
NeAACDecClose(decoder);
return nullptr;
}
return decoder;
}
static void
mp4_file_decode(Decoder &mpd_decoder, Path path_fs)
{
const MP4FileHandle handle = MP4Read(path_fs.c_str());
if (handle == MP4_INVALID_FILE_HANDLE) {
FormatError(mp4v2_decoder_domain,
"unable to open file");
return;
}
AudioFormat audio_format;
Error error;
const NeAACDecHandle decoder = mp4_faad_new(handle, audio_format, error);
if (decoder == nullptr) {
LogError(error);
MP4Close(handle);
return;
}
const MP4TrackId track = mp4_get_aac_track(handle, nullptr, audio_format, error);
/* initialize the MPD core */
const MP4Timestamp scale = MP4GetTrackTimeScale(handle, track);
const SongTime duration = SongTime::FromScale<uint64_t>(MP4GetTrackDuration(handle, track),
scale);
const MP4SampleId num_samples = MP4GetTrackNumberOfSamples(handle, track);
decoder_initialized(mpd_decoder, audio_format, true, duration);
/* the decoder loop */
DecoderCommand cmd = DecoderCommand::NONE;
for (MP4SampleId sample = 1;
sample < num_samples && cmd != DecoderCommand::STOP;
sample++) {
unsigned char *data = nullptr;
unsigned int data_length = 0;
if (cmd == DecoderCommand::SEEK) {
const MP4Timestamp offset =
decoder_seek_time(mpd_decoder).ToScale(scale);
sample = MP4GetSampleIdFromTime(handle, track, offset,
false);
decoder_command_finished(mpd_decoder);
}
/* read */
if (MP4ReadSample(handle, track, sample, &data, &data_length) == 0) {
FormatError(mp4v2_decoder_domain, "unable to read sample");
break;
}
/* decode it */
NeAACDecFrameInfo frame_info;
const void *const decoded = NeAACDecDecode(decoder, &frame_info, data, data_length);
if (frame_info.error > 0) {
FormatWarning(mp4v2_decoder_domain,
"error decoding AAC stream: %s",
NeAACDecGetErrorMessage(frame_info.error));
break;
}
if (frame_info.channels != audio_format.channels) {
FormatDefault(mp4v2_decoder_domain,
"channel count changed from %u to %u",
audio_format.channels, frame_info.channels);
break;
}
if (frame_info.samplerate != audio_format.sample_rate) {
FormatDefault(mp4v2_decoder_domain,
"sample rate changed from %u to %lu",
audio_format.sample_rate,
(unsigned long)frame_info.samplerate);
break;
}
/* update bit rate and position */
unsigned bit_rate = 0;
if (frame_info.samples > 0) {
bit_rate = frame_info.bytesconsumed * 8.0 *
frame_info.channels * audio_format.sample_rate /
frame_info.samples / 1000 + 0.5;
}
/* send PCM samples to MPD */
cmd = decoder_data(mpd_decoder, nullptr, decoded,
(size_t)frame_info.samples * 2,
bit_rate);
free(data);
}
/* cleanup */
NeAACDecClose(decoder);
MP4Close(handle);
}
static inline void
mp4_safe_invoke_tag(const struct tag_handler *handler, void *handler_ctx,
TagType tag, const char *value)
{
if (value != nullptr)
tag_handler_invoke_tag(handler, handler_ctx, tag, value);
}
static bool
mp4_scan_file(Path path_fs,
const struct tag_handler *handler, void *handler_ctx)
{
const MP4FileHandle handle = MP4Read(path_fs.c_str());
if (handle == MP4_INVALID_FILE_HANDLE)
return false;
AudioFormat tmp_audio_format;
Error error;
const MP4TrackId id = mp4_get_aac_track(handle, nullptr, tmp_audio_format, error);
if (id == MP4_INVALID_TRACK_ID) {
LogError(error);
MP4Close(handle);
return false;
}
const MP4Timestamp scale = MP4GetTrackTimeScale(handle, id);
const SongTime dur =
SongTime::FromScale<uint64_t>(MP4GetTrackDuration(handle, id),
scale);
tag_handler_invoke_duration(handler, handler_ctx, dur);
const MP4Tags* tags = MP4TagsAlloc();
MP4TagsFetch(tags, handle);
static constexpr struct {
const char *MP4Tags::*p;
TagType tag_type;
} mp4v2_tags[] = {
{ &MP4Tags::name, TAG_NAME },
{ &MP4Tags::artist, TAG_ARTIST },
{ &MP4Tags::albumArtist, TAG_ALBUM_ARTIST },
{ &MP4Tags::album, TAG_ALBUM },
{ &MP4Tags::composer, TAG_COMPOSER },
{ &MP4Tags::comments, TAG_COMMENT },
{ &MP4Tags::genre, TAG_GENRE },
{ &MP4Tags::releaseDate, TAG_DATE },
{ &MP4Tags::sortArtist, TAG_ARTIST_SORT },
{ &MP4Tags::sortAlbumArtist, TAG_ALBUM_ARTIST_SORT },
};
for (const auto &i : mp4v2_tags)
mp4_safe_invoke_tag(handler, handler_ctx,
i.tag_type, tags->*i.p);
char buff[8]; /* tmp buffer for index to string. */
if (tags->track != nullptr) {
sprintf(buff, "%d", tags->track->index);
tag_handler_invoke_tag(handler, handler_ctx, TAG_TRACK, buff);
}
if (tags->disk != nullptr) {
sprintf(buff, "%d", tags->disk->index);
tag_handler_invoke_tag(handler, handler_ctx, TAG_DISC, buff);
}
MP4TagsFree(tags);
MP4Close(handle);
return true;
}
static const char *const mp4_suffixes[] = {
"mp4",
"m4a",
/* "m4p", encrypted */
/* "m4b", audio book */
/* "m4r", ring tones */
/* "m4v", video */
nullptr
};
static const char *const mp4_mime_types[] = {
"application/mp4",
"application/m4a",
"audio/mp4",
"audio/m4a",
/* "audio/m4p", */
/* "audio/m4b", */
/* "audio/m4r", */
/* "audio/m4v", */
nullptr
};
const struct DecoderPlugin mp4v2_decoder_plugin = {
"mp4v2",
nullptr,
nullptr,
nullptr,
mp4_file_decode,
mp4_scan_file,
nullptr,
nullptr,
mp4_suffixes,
mp4_mime_types
};

25
src/decoder/plugins/Mp4v2DecoderPlugin.hxx
View File

@@ -1,25 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_DECODER_MP4V2_HXX
#define MPD_DECODER_MP4V2_HXX
extern const struct DecoderPlugin mp4v2_decoder_plugin;
#endif

3
src/event/DeferredMonitor.hxx
View File

@@ -21,9 +21,6 @@
#define MPD_SOCKET_DEFERRED_MONITOR_HXX
#include "check.h"
#include "Compiler.h"
#include <atomic>
class EventLoop;

2
src/input/plugins/AlsaInputPlugin.cxx
View File

@@ -43,6 +43,8 @@
#include <alsa/asoundlib.h>
#include <atomic>
#include <assert.h>
#include <string.h>

12
src/lib/nfs/Connection.cxx
View File

@@ -327,6 +327,10 @@ NfsConnection::DestroyContext()
assert(GetEventLoop().IsInside());
assert(context != nullptr);
/* cancel pending DeferredMonitor that was scheduled to notify
new leases */
DeferredMonitor::Cancel();
if (SocketMonitor::IsDefined())
SocketMonitor::Cancel();
@@ -405,10 +409,10 @@ NfsConnection::OnSocketReady(unsigned flags)
error.Format(nfs_domain, "NFS connection has failed: %s",
nfs_get_error(context));
BroadcastError(std::move(error));
DestroyContext();
closed = true;
BroadcastError(std::move(error));
} else if (SocketMonitor::IsDefined() && nfs_get_fd(context) < 0) {
/* this happens when rpc_reconnect_requeue() is called
after the connection broke, but autoreconnet was
@@ -421,10 +425,10 @@ NfsConnection::OnSocketReady(unsigned flags)
error.Format(nfs_domain,
"NFS socket disappeared: %s", msg);
BroadcastError(std::move(error));
DestroyContext();
closed = true;
BroadcastError(std::move(error));
}
assert(in_event);

38
src/lib/nfs/FileReader.cxx
View File

@@ -56,8 +56,18 @@ NfsFileReader::Close()
return;
}
/* this cancels State::MOUNT */
connection->RemoveLease(*this);
CancelOrClose();
}
void
NfsFileReader::CancelOrClose()
{
assert(state != State::INITIAL &&
state != State::DEFER);
if (state == State::IDLE)
/* no async operation in progress: can close
immediately */
@@ -164,6 +174,8 @@ NfsFileReader::OnNfsConnectionFailed(const Error &error)
{
assert(state == State::MOUNT);
state = State::INITIAL;
Error copy;
copy.Set(error);
OnNfsFileError(std::move(copy));
@@ -174,7 +186,7 @@ NfsFileReader::OnNfsConnectionDisconnected(const Error &error)
{
assert(state > State::MOUNT);
state = State::INITIAL;
CancelOrClose();
Error copy;
copy.Set(error);
@@ -246,6 +258,30 @@ NfsFileReader::OnNfsCallback(unsigned status, void *data)
void
NfsFileReader::OnNfsError(Error &&error)
{
switch (state) {
case State::INITIAL:
case State::DEFER:
case State::MOUNT:
case State::IDLE:
assert(false);
gcc_unreachable();
case State::OPEN:
connection->RemoveLease(*this);
state = State::INITIAL;
break;
case State::STAT:
connection->RemoveLease(*this);
connection->Close(fh);
state = State::INITIAL;
break;
case State::READ:
state = State::IDLE;
break;
}
OnNfsFileError(std::move(error));
}

7
src/lib/nfs/FileReader.hxx
View File

@@ -24,6 +24,7 @@
#include "Lease.hxx"
#include "Callback.hxx"
#include "event/DeferredMonitor.hxx"
#include "Compiler.h"
#include <string>
@@ -75,6 +76,12 @@ protected:
virtual void OnNfsFileError(Error &&error) = 0;
private:
/**
* Cancel the current operation, if any. The NfsLease must be
* unregistered already.
*/
void CancelOrClose();
void OpenCallback(nfsfh *_fh);
void StatCallback(const struct stat *st);

30
src/lib/nfs/Manager.cxx
View File

@@ -29,8 +29,10 @@ NfsManager::ManagedConnection::OnNfsConnectionError(Error &&error)
{
FormatError(error, "NFS error on %s:%s", GetServer(), GetExportName());
manager.connections.erase(manager.connections.iterator_to(*this));
delete this;
/* defer deletion so the caller
(i.e. NfsConnection::OnSocketReady()) can still use this
object */
manager.ScheduleDelete(*this);
}
inline bool
@@ -59,7 +61,9 @@ NfsManager::Compare::operator()(const ManagedConnection &a,
NfsManager::~NfsManager()
{
assert(loop.IsInside());
assert(GetEventLoop().IsInside());
CollectGarbage();
connections.clear_and_dispose([](ManagedConnection *c){
delete c;
@@ -71,13 +75,13 @@ NfsManager::GetConnection(const char *server, const char *export_name)
{
assert(server != nullptr);
assert(export_name != nullptr);
assert(loop.IsInside());
assert(GetEventLoop().IsInside());
Map::insert_commit_data hint;
auto result = connections.insert_check(LookupKey{server, export_name},
Compare(), hint);
if (result.second) {
auto c = new ManagedConnection(*this, loop,
auto c = new ManagedConnection(*this, GetEventLoop(),
server, export_name);
connections.insert_commit(*c, hint);
return *c;
@@ -85,3 +89,19 @@ NfsManager::GetConnection(const char *server, const char *export_name)
return *result.first;
}
}
void
NfsManager::CollectGarbage()
{
assert(GetEventLoop().IsInside());
garbage.clear_and_dispose([](ManagedConnection *c){
delete c;
});
}
void
NfsManager::OnIdle()
{
CollectGarbage();
}

33
src/lib/nfs/Manager.hxx
View File

@@ -23,14 +23,16 @@
#include "check.h"
#include "Connection.hxx"
#include "Compiler.h"
#include "event/IdleMonitor.hxx"
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/slist.hpp>
/**
* A manager for NFS connections. Handles multiple connections to
* multiple NFS servers.
*/
class NfsManager {
class NfsManager final : IdleMonitor {
struct LookupKey {
const char *server;
const char *export_name;
@@ -38,6 +40,7 @@ class NfsManager {
class ManagedConnection final
: public NfsConnection,
public boost::intrusive::slist_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>,
public boost::intrusive::set_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>> {
NfsManager &manager;
@@ -63,8 +66,6 @@ class NfsManager {
const LookupKey b) const;
};
EventLoop &loop;
/**
* Maps server and export_name to #ManagedConnection.
*/
@@ -74,9 +75,18 @@ class NfsManager {
Map connections;
typedef boost::intrusive::slist<ManagedConnection> List;
/**
* A list of "garbage" connection objects. Their destruction
* is postponed because they were thrown into the garbage list
* when callers on the stack were still using them.
*/
List garbage;
public:
NfsManager(EventLoop &_loop)
:loop(_loop) {}
:IdleMonitor(_loop) {}
/**
* Must be run from EventLoop's thread.
@@ -86,6 +96,21 @@ public:
gcc_pure
NfsConnection &GetConnection(const char *server,
const char *export_name);
private:
void ScheduleDelete(ManagedConnection &c) {
connections.erase(connections.iterator_to(c));
garbage.push_front(c);
IdleMonitor::Schedule();
}
/**
* Delete all connections on the #garbage list.
*/
void CollectGarbage();
/* virtual methods from IdleMonitor */
void OnIdle() override;
};
#endif