2018-02-12 23:17:19 +01:00
|
|
|
/*
|
2019-06-17 11:17:30 +02:00
|
|
|
* Copyright 2003-2019 The Music Player Daemon Project
|
2018-02-12 23:17:19 +01:00
|
|
|
* 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 "HybridDsdDecoderPlugin.hxx"
|
|
|
|
#include "../DecoderAPI.hxx"
|
|
|
|
#include "input/InputStream.hxx"
|
2019-03-08 10:21:10 +01:00
|
|
|
#include "util/ByteOrder.hxx"
|
2018-02-12 23:17:19 +01:00
|
|
|
#include "util/Domain.hxx"
|
|
|
|
#include "util/WritableBuffer.hxx"
|
|
|
|
#include "util/StaticFifoBuffer.hxx"
|
|
|
|
#include "Log.hxx"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
static constexpr Domain hybrid_dsd_domain("hybrid_dsd");
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
static bool
|
|
|
|
InitHybridDsdDecoder(const ConfigBlock &block)
|
|
|
|
{
|
2018-02-13 09:29:58 +01:00
|
|
|
/* this plugin is disabled by default because for people
|
|
|
|
without a DSD DAC, the PCM (=ALAC) part of the file is
|
|
|
|
better */
|
2018-02-12 23:17:19 +01:00
|
|
|
if (block.GetBlockParam("enabled") == nullptr) {
|
2019-03-29 17:15:43 +01:00
|
|
|
LogDebug(hybrid_dsd_domain,
|
|
|
|
"The Hybrid DSD decoder is disabled because it was not explicitly enabled");
|
2018-02-12 23:17:19 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-13 09:29:58 +01:00
|
|
|
/**
|
|
|
|
* This exception gets thrown by FindHybridDsdData() to indicate a
|
|
|
|
* file format error.
|
|
|
|
*/
|
2018-02-12 23:17:19 +01:00
|
|
|
struct UnsupportedFile {};
|
|
|
|
|
|
|
|
struct Mp4ChunkHeader {
|
|
|
|
uint32_t size;
|
|
|
|
char type[4];
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
ReadFull(DecoderClient &client, InputStream &input,
|
|
|
|
WritableBuffer<uint8_t> dest)
|
|
|
|
{
|
|
|
|
while (!dest.empty()) {
|
|
|
|
size_t nbytes = client.Read(input, dest.data, dest.size);
|
|
|
|
if (nbytes == 0)
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
dest.skip_front(nbytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ReadFull(DecoderClient &client, InputStream &input, WritableBuffer<void> dest)
|
|
|
|
{
|
|
|
|
ReadFull(client, input, WritableBuffer<uint8_t>::FromVoid(dest));
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
T
|
|
|
|
ReadFullT(DecoderClient &client, InputStream &input)
|
|
|
|
{
|
|
|
|
T dest;
|
|
|
|
ReadFull(client, input, WritableBuffer<void>(&dest, sizeof(dest)));
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
Mp4ChunkHeader
|
|
|
|
ReadHeader(DecoderClient &client, InputStream &input)
|
|
|
|
{
|
|
|
|
return ReadFullT<Mp4ChunkHeader>(client, input);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
ReadBE32(DecoderClient &client, InputStream &input)
|
|
|
|
{
|
|
|
|
return FromBE32(ReadFullT<uint32_t>(client, input));
|
|
|
|
}
|
|
|
|
|
|
|
|
} /* anonymous namespace */
|
|
|
|
|
|
|
|
static std::pair<AudioFormat, offset_type>
|
|
|
|
FindHybridDsdData(DecoderClient &client, InputStream &input)
|
|
|
|
{
|
|
|
|
auto audio_format = AudioFormat::Undefined();
|
2018-02-13 09:29:58 +01:00
|
|
|
bool found_version = false;
|
2018-02-12 23:17:19 +01:00
|
|
|
|
|
|
|
while (true) {
|
|
|
|
auto header = ReadHeader(client, input);
|
|
|
|
const size_t header_size = FromBE32(header.size);
|
|
|
|
if (header_size < sizeof(header))
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
size_t remaining = header_size - sizeof(header);
|
|
|
|
if (memcmp(header.type, "bphv", 4) == 0) {
|
2018-02-13 09:29:58 +01:00
|
|
|
/* version; this plugin knows only version
|
|
|
|
1 */
|
2018-02-12 23:17:19 +01:00
|
|
|
if (remaining != 4 || ReadBE32(client, input) != 1)
|
|
|
|
throw UnsupportedFile();
|
|
|
|
remaining -= 4;
|
|
|
|
|
2018-02-13 09:29:58 +01:00
|
|
|
found_version = true;
|
2018-02-12 23:17:19 +01:00
|
|
|
} else if (memcmp(header.type, "bphc", 4) == 0) {
|
|
|
|
/* channel count */
|
|
|
|
if (remaining != 4)
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
auto channels = ReadBE32(client, input);
|
|
|
|
remaining -= 4;
|
|
|
|
|
|
|
|
if (!audio_valid_channel_count(channels))
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
audio_format.channels = channels;
|
|
|
|
} else if (memcmp(header.type, "bphr", 4) == 0) {
|
|
|
|
/* (bit) sample rate */
|
|
|
|
|
|
|
|
if (remaining != 4)
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
auto sample_rate = ReadBE32(client, input) / 8;
|
|
|
|
remaining -= 4;
|
|
|
|
|
|
|
|
if (!audio_valid_sample_rate(sample_rate))
|
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
audio_format.sample_rate = sample_rate;
|
|
|
|
} else if (memcmp(header.type, "bphf", 4) == 0) {
|
2018-02-13 09:29:58 +01:00
|
|
|
/* format: 0 = plain DSD; 1 = DST compressed
|
|
|
|
(only plain DSD is understood by this
|
|
|
|
plugin) */
|
2018-02-12 23:17:19 +01:00
|
|
|
if (remaining != 4 || ReadBE32(client, input) != 0)
|
|
|
|
throw UnsupportedFile();
|
|
|
|
remaining -= 4;
|
2018-02-13 09:29:58 +01:00
|
|
|
|
|
|
|
audio_format.format = SampleFormat::DSD;
|
2018-02-12 23:17:19 +01:00
|
|
|
} else if (memcmp(header.type, "bphd", 4) == 0) {
|
|
|
|
/* the actual DSD data */
|
2018-02-13 09:29:58 +01:00
|
|
|
if (!found_version || !audio_format.IsValid())
|
2018-02-12 23:17:19 +01:00
|
|
|
throw UnsupportedFile();
|
|
|
|
|
|
|
|
return std::make_pair(audio_format, remaining);
|
|
|
|
}
|
|
|
|
|
2018-02-13 09:29:58 +01:00
|
|
|
/* skip this chunk payload */
|
2018-02-12 23:17:19 +01:00
|
|
|
input.LockSkip(remaining);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
HybridDsdDecode(DecoderClient &client, InputStream &input)
|
|
|
|
{
|
|
|
|
if (!input.CheapSeeking())
|
|
|
|
/* probe only if seeking is cheap, i.e. not for HTTP
|
|
|
|
streams */
|
|
|
|
return;
|
|
|
|
|
2018-02-13 09:53:05 +01:00
|
|
|
uint64_t total_frames;
|
2018-02-12 23:17:19 +01:00
|
|
|
size_t frame_size;
|
2018-02-13 09:41:07 +01:00
|
|
|
unsigned kbit_rate;
|
2018-02-12 23:17:19 +01:00
|
|
|
|
|
|
|
try {
|
|
|
|
auto result = FindHybridDsdData(client, input);
|
2018-09-21 19:32:35 +02:00
|
|
|
auto duration = result.first.SizeToTime<SignedSongTime>(result.second);
|
2018-02-13 09:53:05 +01:00
|
|
|
client.Ready(result.first, true, duration);
|
2018-02-12 23:17:19 +01:00
|
|
|
frame_size = result.first.GetFrameSize();
|
2018-02-13 09:41:07 +01:00
|
|
|
kbit_rate = frame_size * result.first.sample_rate /
|
|
|
|
(1024u / 8u);
|
2018-02-13 09:53:05 +01:00
|
|
|
total_frames = result.second / frame_size;
|
2018-02-12 23:17:19 +01:00
|
|
|
} catch (UnsupportedFile) {
|
2018-02-13 09:29:58 +01:00
|
|
|
/* not a Hybrid-DSD file; let the next decoder plugin
|
|
|
|
(e.g. FFmpeg) handle it */
|
2018-02-12 23:17:19 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-13 09:53:05 +01:00
|
|
|
const offset_type start_offset = input.GetOffset();
|
|
|
|
offset_type remaining_bytes = total_frames * frame_size;
|
|
|
|
|
2018-02-12 23:17:19 +01:00
|
|
|
StaticFifoBuffer<uint8_t, 16384> buffer;
|
|
|
|
|
|
|
|
auto cmd = client.GetCommand();
|
|
|
|
while (remaining_bytes > 0) {
|
2018-02-13 09:53:05 +01:00
|
|
|
uint64_t seek_frame;
|
|
|
|
|
2018-02-12 23:17:19 +01:00
|
|
|
switch (cmd) {
|
|
|
|
case DecoderCommand::NONE:
|
|
|
|
case DecoderCommand::START:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DecoderCommand::STOP:
|
|
|
|
return;
|
|
|
|
|
|
|
|
case DecoderCommand::SEEK:
|
2018-02-13 09:53:05 +01:00
|
|
|
seek_frame = client.GetSeekFrame();
|
|
|
|
if (seek_frame >= total_frames) {
|
|
|
|
/* seeking past the end */
|
|
|
|
client.CommandFinished();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
input.LockSeek(start_offset + seek_frame * frame_size);
|
|
|
|
remaining_bytes = (total_frames - seek_frame) * frame_size;
|
|
|
|
buffer.Clear();
|
|
|
|
client.CommandFinished();
|
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
|
|
|
client.SeekError();
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd = DecoderCommand::NONE;
|
2018-02-12 23:17:19 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-02-13 09:29:58 +01:00
|
|
|
/* fill the buffer */
|
2018-02-12 23:17:19 +01:00
|
|
|
auto w = buffer.Write();
|
|
|
|
if (!w.empty()) {
|
|
|
|
if (remaining_bytes < (1<<30ull) &&
|
|
|
|
w.size > size_t(remaining_bytes))
|
|
|
|
w.size = remaining_bytes;
|
|
|
|
|
|
|
|
const size_t nbytes = client.Read(input,
|
|
|
|
w.data, w.size);
|
|
|
|
if (nbytes == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
remaining_bytes -= nbytes;
|
|
|
|
buffer.Append(nbytes);
|
|
|
|
}
|
|
|
|
|
2018-02-13 09:29:58 +01:00
|
|
|
/* submit the buffer to our client */
|
2018-02-12 23:17:19 +01:00
|
|
|
auto r = buffer.Read();
|
|
|
|
auto n_frames = r.size / frame_size;
|
|
|
|
if (n_frames > 0) {
|
|
|
|
cmd = client.SubmitData(input, r.data,
|
|
|
|
n_frames * frame_size,
|
2018-02-13 09:41:07 +01:00
|
|
|
kbit_rate);
|
2018-02-12 23:17:19 +01:00
|
|
|
buffer.Consume(n_frames * frame_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *const hybrid_dsd_suffixes[] = {
|
|
|
|
"m4a",
|
|
|
|
nullptr
|
|
|
|
};
|
|
|
|
|
2019-06-15 14:44:37 +02:00
|
|
|
constexpr DecoderPlugin hybrid_dsd_decoder_plugin =
|
2018-02-13 09:29:58 +01:00
|
|
|
/* no scan method here; the FFmpeg plugin will do that for us,
|
|
|
|
and we only do the decoding */
|
2019-06-15 14:44:37 +02:00
|
|
|
DecoderPlugin("hybrid_dsd", HybridDsdDecode, nullptr)
|
|
|
|
.WithInit(InitHybridDsdDecoder)
|
|
|
|
.WithSuffixes(hybrid_dsd_suffixes);
|