1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
#include "audio_decoder.hpp"
#include <string.h>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include "cbor/tinycbor/src/cborinternal_p.h"
#include "freertos/FreeRTOS.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "freertos/message_buffer.h"
#include "freertos/portmacro.h"
#include "audio_element.hpp"
#include "chunk.hpp"
#include "fatfs_audio_input.hpp"
#include "stream_info.hpp"
namespace audio {
static const char* kTag = "DEC";
AudioDecoder::AudioDecoder()
: IAudioElement(),
stream_info_({}),
has_samples_to_send_(false),
needs_more_input_(true) {}
AudioDecoder::~AudioDecoder() {}
auto AudioDecoder::ProcessStreamInfo(const StreamInfo& info) -> bool {
if (!std::holds_alternative<StreamInfo::Encoded>(info.data)) {
return false;
}
const auto& encoded = std::get<StreamInfo::Encoded>(info.data);
// Reuse the existing codec if we can. This will help with gapless playback,
// since we can potentially just continue to decode as we were before,
// without any setup overhead.
// TODO: use audio type from stream
if (current_codec_ != nullptr &&
current_codec_->CanHandleType(encoded.type)) {
current_codec_->ResetForNewStream();
return true;
}
// TODO: use audio type from stream
auto result = codecs::CreateCodecForType(encoded.type);
if (result.has_value()) {
current_codec_ = std::move(result.value());
} else {
ESP_LOGE(kTag, "no codec for this file");
return false;
}
return true;
}
auto AudioDecoder::Process(std::vector<Stream>* inputs, MutableStream* output)
-> void {
// We don't really expect multiple inputs, so just pick the first that
// contains data. If none of them contain data, then we can still flush
// pending samples.
auto input =
std::find_if(inputs->begin(), inputs->end(),
[](const Stream& s) { return s.data.size_bytes() > 0; });
if (input != inputs->end()) {
const StreamInfo* info = input->info;
if (!stream_info_ || *stream_info_ != *info) {
// The input stream has changed! Immediately throw everything away and
// start from scratch.
// TODO: special case gapless playback? needs thought.
stream_info_ = *info;
has_samples_to_send_ = false;
has_set_stream_info_ = false;
ProcessStreamInfo(*info);
}
current_codec_->SetInput(input->data);
}
while (true) {
if (has_samples_to_send_) {
if (!has_set_stream_info_) {
has_set_stream_info_ = true;
auto format = current_codec_->GetOutputFormat();
output->info->data.emplace<StreamInfo::Pcm>(
format.bits_per_sample, format.sample_rate_hz, format.num_channels);
}
auto write_res = current_codec_->WriteOutputSamples(
output->data.subspan(output->info->bytes_in_stream));
output->info->bytes_in_stream += write_res.first;
has_samples_to_send_ = !write_res.second;
if (has_samples_to_send_) {
// We weren't able to fit all the generated samples into the output
// buffer. Stop trying; we'll finish up during the next pass.
break;
}
}
if (input != inputs->end()) {
auto res = current_codec_->ProcessNextFrame();
if (res.has_error()) {
// TODO(jacqueline): Handle errors.
return;
}
input->data = input->data.subspan(current_codec_->GetInputPosition());
if (res.value()) {
// We're out of data in this buffer. Finish immediately; there's nothing
// to send.
break;
} else {
has_samples_to_send_ = true;
}
} else {
// No input; nothing to do.
break;
}
}
}
} // namespace audio
|
