decode_external.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. /*
  2. * Squeezelite for esp32
  3. *
  4. * (c) Sebastien 2019
  5. * Philippe G. 2019, philippe_44@outlook.com
  6. *
  7. * This software is released under the MIT License.
  8. * https://opensource.org/licenses/MIT
  9. *
  10. */
  11. #include "platform_config.h"
  12. #include "squeezelite.h"
  13. #include "bt_app_sink.h"
  14. #include "raop_sink.h"
  15. #include <math.h>
  16. #define LOCK_O mutex_lock(outputbuf->mutex)
  17. #define UNLOCK_O mutex_unlock(outputbuf->mutex)
  18. #define LOCK_D mutex_lock(decode.mutex);
  19. #define UNLOCK_D mutex_unlock(decode.mutex);
  20. enum { DECODE_BT = 1, DECODE_RAOP };
  21. extern struct outputstate output;
  22. extern struct decodestate decode;
  23. extern struct buffer *outputbuf;
  24. // this is the only system-wide loglevel variable
  25. extern log_level loglevel;
  26. static bool enable_bt_sink;
  27. static bool enable_airplay;
  28. #define RAOP_OUTPUT_SIZE (((RAOP_SAMPLE_RATE * BYTES_PER_FRAME * 2 * 120) / 100) & ~BYTES_PER_FRAME)
  29. #define SYNC_WIN_SLOW 32
  30. #define SYNC_WIN_CHECK 8
  31. #define SYNC_WIN_FAST 2
  32. static raop_event_t raop_state;
  33. static EXT_RAM_ATTR struct {
  34. bool enabled;
  35. int sum, count, win, errors[SYNC_WIN_SLOW];
  36. s32_t len;
  37. u32_t start_time, playtime;
  38. } raop_sync;
  39. /****************************************************************************************
  40. * Common sink data handler
  41. */
  42. static void sink_data_handler(const uint8_t *data, uint32_t len)
  43. {
  44. size_t bytes, space;
  45. int wait = 5;
  46. // would be better to lock output, but really, it does not matter
  47. if (!output.external) {
  48. LOG_SDEBUG("Cannot use external sink while LMS is controlling player");
  49. return;
  50. }
  51. // there will always be room at some point
  52. while (len) {
  53. LOCK_O;
  54. bytes = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / (BYTES_PER_FRAME / 4);
  55. bytes = min(len, bytes);
  56. #if BYTES_PER_FRAME == 4
  57. memcpy(outputbuf->writep, data, bytes);
  58. #else
  59. {
  60. s16_t *iptr = (s16_t*) data;
  61. ISAMPLE_T *optr = (ISAMPLE_T *) outputbuf->writep;
  62. size_t n = bytes / 2;
  63. while (n--) *optr++ = *iptr++ << 16;
  64. }
  65. #endif
  66. _buf_inc_writep(outputbuf, bytes * BYTES_PER_FRAME / 4);
  67. space = _buf_space(outputbuf);
  68. len -= bytes;
  69. data += bytes;
  70. UNLOCK_O;
  71. // allow i2s to empty the buffer if needed
  72. if (len && !space && wait--) usleep(20000);
  73. }
  74. if (!wait) {
  75. LOG_WARN("Waited too long, dropping frames");
  76. }
  77. }
  78. /****************************************************************************************
  79. * BT sink command handler
  80. */
  81. static bool bt_sink_cmd_handler(bt_sink_cmd_t cmd, va_list args)
  82. {
  83. // don't LOCK_O as there is always a chance that LMS takes control later anyway
  84. if (output.external != DECODE_BT && output.state > OUTPUT_STOPPED) {
  85. LOG_WARN("Cannot use BT sink while LMS/AirPlay is controlling player");
  86. return false;
  87. }
  88. LOCK_D;
  89. if (cmd != BT_SINK_VOLUME) LOCK_O;
  90. switch(cmd) {
  91. case BT_SINK_AUDIO_STARTED:
  92. output.next_sample_rate = output.current_sample_rate = va_arg(args, u32_t);
  93. output.external = DECODE_BT;
  94. output.state = OUTPUT_STOPPED;
  95. output.frames_played = 0;
  96. _buf_flush(outputbuf);
  97. if (decode.state != DECODE_STOPPED) decode.state = DECODE_ERROR;
  98. LOG_INFO("BT sink started");
  99. break;
  100. case BT_SINK_AUDIO_STOPPED:
  101. if (output.external == DECODE_BT) {
  102. if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED;
  103. output.stop_time = gettime_ms();
  104. LOG_INFO("BT sink stopped");
  105. }
  106. break;
  107. case BT_SINK_PLAY:
  108. output.state = OUTPUT_RUNNING;
  109. LOG_INFO("BT playing");
  110. break;
  111. case BT_SINK_STOP:
  112. _buf_flush(outputbuf);
  113. output.state = OUTPUT_STOPPED;
  114. output.stop_time = gettime_ms();
  115. LOG_INFO("BT stopped");
  116. break;
  117. case BT_SINK_PAUSE:
  118. output.stop_time = gettime_ms();
  119. LOG_INFO("BT paused, just silence");
  120. break;
  121. case BT_SINK_RATE:
  122. output.next_sample_rate = output.current_sample_rate = va_arg(args, u32_t);
  123. LOG_INFO("Setting BT sample rate %u", output.next_sample_rate);
  124. break;
  125. case BT_SINK_VOLUME: {
  126. u32_t volume = va_arg(args, u32_t);
  127. volume = 65536 * powf(volume / 128.0f, 3);
  128. set_volume(volume, volume);
  129. break;
  130. default:
  131. break;
  132. }
  133. }
  134. if (cmd != BT_SINK_VOLUME) UNLOCK_O;
  135. UNLOCK_D;
  136. return true;
  137. }
  138. /****************************************************************************************
  139. * raop sink data handler
  140. */
  141. static void raop_sink_data_handler(const uint8_t *data, uint32_t len, u32_t playtime) {
  142. raop_sync.playtime = playtime;
  143. raop_sync.len = len;
  144. sink_data_handler(data, len);
  145. }
  146. /****************************************************************************************
  147. * AirPlay sink command handler
  148. */
  149. static bool raop_sink_cmd_handler(raop_event_t event, va_list args)
  150. {
  151. // don't LOCK_O as there is always a chance that LMS takes control later anyway
  152. if (output.external != DECODE_RAOP && output.state > OUTPUT_STOPPED) {
  153. LOG_WARN("Cannot use Airplay sink while LMS/BT is controlling player");
  154. return false;
  155. }
  156. LOCK_D;
  157. if (event != RAOP_VOLUME) LOCK_O;
  158. // this is async, so player might have been deleted
  159. switch (event) {
  160. case RAOP_TIMING: {
  161. if (!raop_sync.enabled || output.state != OUTPUT_RUNNING || output.frames_played_dmp < output.device_frames) break;
  162. u32_t ms, now = gettime_ms();
  163. u32_t level = _buf_used(outputbuf);
  164. int error;
  165. // in how many ms will the most recent block play
  166. ms = (((s32_t)(level - raop_sync.len) / BYTES_PER_FRAME + output.device_frames + output.frames_in_process) * 10) / (RAOP_SAMPLE_RATE / 100) - (s32_t) (now - output.updated);
  167. // when outputbuf is empty, it means we have a network black-out or something
  168. error = level ? (raop_sync.playtime - now) - ms : 0;
  169. if (loglevel == lDEBUG || !level) {
  170. LOG_INFO("head local:%d, remote:%d (delta:%d)", ms, raop_sync.playtime - now, error);
  171. LOG_INFO("obuf:%u, sync_len:%u, devframes:%u, inproc:%u", _buf_used(outputbuf), raop_sync.len, output.device_frames, output.frames_in_process);
  172. }
  173. // calculate sum, error and update sliding window
  174. raop_sync.errors[raop_sync.count++ % raop_sync.win] = error;
  175. raop_sync.sum += error;
  176. error = raop_sync.sum / min(raop_sync.count, raop_sync.win);
  177. // wait till we have enough data or there is a strong deviation
  178. if ((raop_sync.count >= raop_sync.win && abs(error) > 10) || (raop_sync.count >= SYNC_WIN_CHECK && abs(error) > 100)) {
  179. if (error < 0) {
  180. output.skip_frames = -(error * RAOP_SAMPLE_RATE) / 1000;
  181. output.state = OUTPUT_SKIP_FRAMES;
  182. LOG_INFO("skipping %u frames (count:%d)", output.skip_frames, raop_sync.count);
  183. } else {
  184. output.pause_frames = (error * RAOP_SAMPLE_RATE) / 1000;
  185. output.state = OUTPUT_PAUSE_FRAMES;
  186. LOG_INFO("pausing for %u frames (count: %d)", output.pause_frames, raop_sync.count);
  187. }
  188. raop_sync.sum = raop_sync.count = 0;
  189. memset(raop_sync.errors, 0, sizeof(raop_sync.errors));
  190. }
  191. // move to normal mode if possible
  192. if (raop_sync.win == 1) {
  193. raop_sync.win = SYNC_WIN_FAST;
  194. LOG_INFO("backend played %u, desired %u, (delta:%d)", ms, raop_sync.playtime - now, error);
  195. } else if (raop_sync.win == SYNC_WIN_FAST && raop_sync.count >= SYNC_WIN_FAST && abs(error) < 10) {
  196. raop_sync.win = SYNC_WIN_SLOW;
  197. LOG_INFO("switching to slow sync mode %u", raop_sync.win);
  198. }
  199. break;
  200. }
  201. case RAOP_SETUP:
  202. // we need a fair bit of space for RTP process
  203. _buf_resize(outputbuf, RAOP_OUTPUT_SIZE);
  204. output.frames_played = 0;
  205. output.external = DECODE_RAOP;
  206. output.state = OUTPUT_STOPPED;
  207. if (decode.state != DECODE_STOPPED) decode.state = DECODE_ERROR;
  208. LOG_INFO("resizing buffer %u", outputbuf->size);
  209. break;
  210. case RAOP_STREAM:
  211. LOG_INFO("Stream", NULL);
  212. raop_state = event;
  213. raop_sync.win = 1;
  214. raop_sync.sum = raop_sync.count = 0;
  215. memset(raop_sync.errors, 0, sizeof(raop_sync.errors));
  216. raop_sync.enabled = !strcasestr(output.device, "BT");
  217. output.next_sample_rate = output.current_sample_rate = RAOP_SAMPLE_RATE;
  218. break;
  219. case RAOP_STOP:
  220. case RAOP_FLUSH:
  221. if (event == RAOP_FLUSH) { LOG_INFO("Flush", NULL); }
  222. else { LOG_INFO("Stop", NULL); }
  223. raop_state = event;
  224. _buf_flush(outputbuf);
  225. if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED;
  226. output.frames_played = 0;
  227. output.stop_time = gettime_ms();
  228. break;
  229. case RAOP_PLAY: {
  230. LOG_INFO("Play", NULL);
  231. if (raop_state != RAOP_PLAY) {
  232. output.state = OUTPUT_START_AT;
  233. output.start_at = va_arg(args, u32_t);
  234. raop_sync.start_time = output.start_at;
  235. LOG_INFO("Starting at %u (in %d ms)", output.start_at, output.start_at - gettime_ms());
  236. }
  237. raop_state = event;
  238. break;
  239. }
  240. case RAOP_VOLUME: {
  241. float volume = va_arg(args, double);
  242. LOG_INFO("Volume[0..1] %0.4f", volume);
  243. volume = 65536 * powf(volume, 3);
  244. set_volume(volume, volume);
  245. break;
  246. }
  247. default:
  248. break;
  249. }
  250. if (event != RAOP_VOLUME) UNLOCK_O;
  251. UNLOCK_D;
  252. return true;
  253. }
  254. /****************************************************************************************
  255. * We provide the generic codec register option
  256. */
  257. void register_external(void) {
  258. char *p;
  259. if ((p = config_alloc_get(NVS_TYPE_STR, "enable_bt_sink")) != NULL) {
  260. enable_bt_sink = strcmp(p,"1") == 0 || strcasecmp(p,"y") == 0;
  261. free(p);
  262. }
  263. if ((p = config_alloc_get(NVS_TYPE_STR, "enable_airplay")) != NULL) {
  264. enable_airplay = strcmp(p,"1") == 0 || strcasecmp(p,"y") == 0;
  265. free(p);
  266. }
  267. if (!strcasestr(output.device, "BT ") ) {
  268. if(enable_bt_sink){
  269. bt_sink_init(bt_sink_cmd_handler, sink_data_handler);
  270. LOG_INFO("Initializing BT sink");
  271. }
  272. } else {
  273. LOG_WARN("Cannot be a BT sink and source");
  274. }
  275. if (enable_airplay){
  276. raop_sink_init(raop_sink_cmd_handler, raop_sink_data_handler);
  277. LOG_INFO("Initializing AirPlay sink");
  278. }
  279. }
  280. void deregister_external(void) {
  281. if (!strcasestr(output.device, "BT ") && enable_bt_sink) {
  282. LOG_INFO("Stopping BT sink");
  283. bt_sink_deinit();
  284. }
  285. if (enable_airplay){
  286. LOG_INFO("Stopping AirPlay sink");
  287. raop_sink_deinit();
  288. }
  289. }
  290. void decode_restore(int external) {
  291. switch (external) {
  292. case DECODE_BT:
  293. bt_disconnect();
  294. break;
  295. case DECODE_RAOP:
  296. raop_disconnect();
  297. raop_state = RAOP_STOP;
  298. break;
  299. }
  300. }