src/audio/fatfs_audio_input.cpp


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

#include "fatfs_audio_input.hpp"

#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <variant>

#include "arena.hpp"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "ff.h"
#include "freertos/portmacro.h"

#include "audio_element.hpp"
#include "chunk.hpp"
#include "stream_buffer.hpp"
#include "stream_event.hpp"
#include "stream_info.hpp"
#include "stream_message.hpp"
#include "types.hpp"

static const char* kTag = "SRC";

namespace audio {

FatfsAudioInput::FatfsAudioInput()
    : IAudioElement(), current_file_(), is_file_open_(false) {}

FatfsAudioInput::~FatfsAudioInput() {}

auto FatfsAudioInput::OpenFile(const std::string& path) -> void {
  if (is_file_open_) {
    f_close(&current_file_);
    is_file_open_ = false;
  }
  ESP_LOGI(kTag, "opening file %s", path.c_str());
  FRESULT res = f_open(&current_file_, path.c_str(), FA_READ);
  if (res != FR_OK) {
    ESP_LOGE(kTag, "failed to open file! res: %i", res);
    // TODO(jacqueline): Handle errors.
    return;
  }

  is_file_open_ = true;
}

auto FatfsAudioInput::Process(const std::vector<InputStream>& inputs,
                              OutputStream* output) -> void {
  if (!is_file_open_) {
    // TODO(jacqueline): should we clear the stream format?
    // output->prepare({});
    return;
  }

  StreamInfo::Format format = StreamInfo::Encoded{codecs::STREAM_MP3};
  if (!output->prepare(format)) {
    return;
  }

  std::size_t max_size = output->data().size_bytes();
  std::size_t size = 0;
  FRESULT result =
      f_read(&current_file_, output->data().data(), max_size, &size);
  if (result != FR_OK) {
    ESP_LOGE(kTag, "file I/O error %d", result);
    // TODO(jacqueline): Handle errors.
    return;
  }

  output->add(size);

  if (size < max_size || f_eof(&current_file_)) {
    f_close(&current_file_);
    is_file_open_ = false;
  }
}

}  // namespace audio