diff options
Diffstat (limited to 'apps')
-rw-r--r-- | apps/playback.c | 160 |
1 files changed, 80 insertions, 80 deletions
diff --git a/apps/playback.c b/apps/playback.c index cb4900e1ae..d1f098b2ed 100644 --- a/apps/playback.c +++ b/apps/playback.c | |||
@@ -199,6 +199,7 @@ size_t filebufused; | |||
199 | static volatile size_t buf_ridx IDATA_ATTR; | 199 | static volatile size_t buf_ridx IDATA_ATTR; |
200 | static volatile size_t buf_widx IDATA_ATTR; | 200 | static volatile size_t buf_widx IDATA_ATTR; |
201 | 201 | ||
202 | /* Codec swapping pointers */ | ||
202 | static unsigned char *iram_buf[2]; | 203 | static unsigned char *iram_buf[2]; |
203 | static unsigned char *dram_buf[2]; | 204 | static unsigned char *dram_buf[2]; |
204 | 205 | ||
@@ -221,7 +222,9 @@ static size_t fill_bytesleft; | |||
221 | static struct track_info tracks[MAX_TRACK]; /* Audio thread */ | 222 | static struct track_info tracks[MAX_TRACK]; /* Audio thread */ |
222 | 223 | ||
223 | /* Pointer to track info structure about current song playing. */ | 224 | /* Pointer to track info structure about current song playing. */ |
224 | static struct track_info *cur_ti; /* Audio and codec threads */ | 225 | #define CUR_TI (&tracks[track_ridx]) |
226 | |||
227 | /* Pointer to track info structure about previous played song. */ | ||
225 | static struct track_info *prev_ti; /* Audio and codec threads */ | 228 | static struct track_info *prev_ti; /* Audio and codec threads */ |
226 | 229 | ||
227 | /* Have we reached end of the current playlist. */ | 230 | /* Have we reached end of the current playlist. */ |
@@ -619,7 +622,7 @@ void audio_set_crossfade(int enable) | |||
619 | if (was_playing) | 622 | if (was_playing) |
620 | { | 623 | { |
621 | /* Store the track resume position */ | 624 | /* Store the track resume position */ |
622 | offset = cur_ti->id3.offset; | 625 | offset = CUR_TI->id3.offset; |
623 | 626 | ||
624 | /* Playback has to be stopped before changing the buffer size. */ | 627 | /* Playback has to be stopped before changing the buffer size. */ |
625 | gui_syncsplash(0, true, (char *)str(LANG_RESTARTING_PLAYBACK)); | 628 | gui_syncsplash(0, true, (char *)str(LANG_RESTARTING_PLAYBACK)); |
@@ -673,8 +676,8 @@ void audio_preinit(void) | |||
673 | track_buffer_callback = NULL; | 676 | track_buffer_callback = NULL; |
674 | track_unbuffer_callback = NULL; | 677 | track_unbuffer_callback = NULL; |
675 | track_changed_callback = NULL; | 678 | track_changed_callback = NULL; |
676 | /* Just to prevent cur_ti never be anything random. */ | 679 | /* Just to prevent CUR_TI never be anything random. */ |
677 | cur_ti = &tracks[0]; | 680 | track_ridx = 0; |
678 | 681 | ||
679 | mutex_init(&mutex_codecthread); | 682 | mutex_init(&mutex_codecthread); |
680 | 683 | ||
@@ -785,7 +788,7 @@ static void set_filebuf_watermark(int seconds) | |||
785 | if (!filebuf) | 788 | if (!filebuf) |
786 | return; /* Audio buffers not yet set up */ | 789 | return; /* Audio buffers not yet set up */ |
787 | 790 | ||
788 | bytes = MAX(cur_ti->id3.bitrate * seconds * (1000/8), conf_watermark); | 791 | bytes = MAX(CUR_TI->id3.bitrate * seconds * (1000/8), conf_watermark); |
789 | bytes = MIN(bytes, filebuflen / 2); | 792 | bytes = MIN(bytes, filebuflen / 2); |
790 | conf_watermark = bytes; | 793 | conf_watermark = bytes; |
791 | } | 794 | } |
@@ -1223,11 +1226,11 @@ static void codec_set_elapsed_callback(unsigned int value) | |||
1223 | 1226 | ||
1224 | latency = pcmbuf_get_latency(); | 1227 | latency = pcmbuf_get_latency(); |
1225 | if (value < latency) | 1228 | if (value < latency) |
1226 | cur_ti->id3.elapsed = 0; | 1229 | CUR_TI->id3.elapsed = 0; |
1227 | else if (value - latency > cur_ti->id3.elapsed || | 1230 | else if (value - latency > CUR_TI->id3.elapsed || |
1228 | value - latency < cur_ti->id3.elapsed - 2) | 1231 | value - latency < CUR_TI->id3.elapsed - 2) |
1229 | { | 1232 | { |
1230 | cur_ti->id3.elapsed = value - latency; | 1233 | CUR_TI->id3.elapsed = value - latency; |
1231 | } | 1234 | } |
1232 | } | 1235 | } |
1233 | 1236 | ||
@@ -1238,11 +1241,11 @@ static void codec_set_offset_callback(size_t value) | |||
1238 | if (ci.seek_time) | 1241 | if (ci.seek_time) |
1239 | return; | 1242 | return; |
1240 | 1243 | ||
1241 | latency = pcmbuf_get_latency() * cur_ti->id3.bitrate / 8; | 1244 | latency = pcmbuf_get_latency() * CUR_TI->id3.bitrate / 8; |
1242 | if (value < latency) | 1245 | if (value < latency) |
1243 | cur_ti->id3.offset = 0; | 1246 | CUR_TI->id3.offset = 0; |
1244 | else | 1247 | else |
1245 | cur_ti->id3.offset = value - latency; | 1248 | CUR_TI->id3.offset = value - latency; |
1246 | } | 1249 | } |
1247 | 1250 | ||
1248 | static void codec_advance_buffer_counters(size_t amount) | 1251 | static void codec_advance_buffer_counters(size_t amount) |
@@ -1253,7 +1256,7 @@ static void codec_advance_buffer_counters(size_t amount) | |||
1253 | buf_ridx -= filebuflen; | 1256 | buf_ridx -= filebuflen; |
1254 | 1257 | ||
1255 | ci.curpos += amount; | 1258 | ci.curpos += amount; |
1256 | cur_ti->available -= amount; | 1259 | CUR_TI->available -= amount; |
1257 | filebufused -= amount; | 1260 | filebufused -= amount; |
1258 | 1261 | ||
1259 | /* Start buffer filling as necessary. */ | 1262 | /* Start buffer filling as necessary. */ |
@@ -1279,14 +1282,14 @@ static size_t codec_filebuf_callback(void *ptr, size_t size) | |||
1279 | 1282 | ||
1280 | /* The ammount to copy is the lesser of the requested amount and the | 1283 | /* The ammount to copy is the lesser of the requested amount and the |
1281 | * amount left of the current track (both on disk and already loaded) */ | 1284 | * amount left of the current track (both on disk and already loaded) */ |
1282 | copy_n = MIN(size, cur_ti->available + cur_ti->filerem); | 1285 | copy_n = MIN(size, CUR_TI->available + CUR_TI->filerem); |
1283 | 1286 | ||
1284 | /* Nothing requested OR nothing left */ | 1287 | /* Nothing requested OR nothing left */ |
1285 | if (copy_n == 0) | 1288 | if (copy_n == 0) |
1286 | return 0; | 1289 | return 0; |
1287 | 1290 | ||
1288 | /* Let the disk buffer catch fill until enough data is available */ | 1291 | /* Let the disk buffer catch fill until enough data is available */ |
1289 | while (copy_n > cur_ti->available) | 1292 | while (copy_n > CUR_TI->available) |
1290 | { | 1293 | { |
1291 | if (!filling) | 1294 | if (!filling) |
1292 | { | 1295 | { |
@@ -1324,14 +1327,14 @@ static void* codec_request_buffer_callback(size_t *realsize, size_t reqsize) | |||
1324 | return NULL; | 1327 | return NULL; |
1325 | } | 1328 | } |
1326 | 1329 | ||
1327 | copy_n = MIN(reqsize, cur_ti->available + cur_ti->filerem); | 1330 | copy_n = MIN(reqsize, CUR_TI->available + CUR_TI->filerem); |
1328 | if (copy_n == 0) | 1331 | if (copy_n == 0) |
1329 | { | 1332 | { |
1330 | *realsize = 0; | 1333 | *realsize = 0; |
1331 | return NULL; | 1334 | return NULL; |
1332 | } | 1335 | } |
1333 | 1336 | ||
1334 | while (copy_n > cur_ti->available) | 1337 | while (copy_n > CUR_TI->available) |
1335 | { | 1338 | { |
1336 | if (!filling) | 1339 | if (!filling) |
1337 | { | 1340 | { |
@@ -1382,13 +1385,13 @@ static int get_codec_base_type(int type) | |||
1382 | 1385 | ||
1383 | static void codec_advance_buffer_callback(size_t amount) | 1386 | static void codec_advance_buffer_callback(size_t amount) |
1384 | { | 1387 | { |
1385 | if (amount > cur_ti->available + cur_ti->filerem) | 1388 | if (amount > CUR_TI->available + CUR_TI->filerem) |
1386 | amount = cur_ti->available + cur_ti->filerem; | 1389 | amount = CUR_TI->available + CUR_TI->filerem; |
1387 | 1390 | ||
1388 | while (amount > cur_ti->available && filling) | 1391 | while (amount > CUR_TI->available && filling) |
1389 | sleep(1); | 1392 | sleep(1); |
1390 | 1393 | ||
1391 | if (amount > cur_ti->available) | 1394 | if (amount > CUR_TI->available) |
1392 | { | 1395 | { |
1393 | struct event ev; | 1396 | struct event ev; |
1394 | 1397 | ||
@@ -1487,7 +1490,7 @@ static off_t codec_mp3_get_filepos_callback(int newtime) | |||
1487 | { | 1490 | { |
1488 | off_t newpos; | 1491 | off_t newpos; |
1489 | 1492 | ||
1490 | cur_ti->id3.elapsed = newtime; | 1493 | CUR_TI->id3.elapsed = newtime; |
1491 | newpos = codec_get_file_pos(); | 1494 | newpos = codec_get_file_pos(); |
1492 | 1495 | ||
1493 | return newpos; | 1496 | return newpos; |
@@ -1514,8 +1517,8 @@ static bool codec_seek_buffer_callback(size_t newpos) | |||
1514 | 1517 | ||
1515 | logf("codec_seek_buffer_callback"); | 1518 | logf("codec_seek_buffer_callback"); |
1516 | 1519 | ||
1517 | if (newpos >= cur_ti->filesize) | 1520 | if (newpos >= CUR_TI->filesize) |
1518 | newpos = cur_ti->filesize - 1; | 1521 | newpos = CUR_TI->filesize - 1; |
1519 | 1522 | ||
1520 | difference = newpos - ci.curpos; | 1523 | difference = newpos - ci.curpos; |
1521 | if (difference >= 0) | 1524 | if (difference >= 0) |
@@ -1532,7 +1535,7 @@ static bool codec_seek_buffer_callback(size_t newpos) | |||
1532 | difference = ci.curpos; | 1535 | difference = ci.curpos; |
1533 | 1536 | ||
1534 | /* We need to reload the song. */ | 1537 | /* We need to reload the song. */ |
1535 | if (newpos < cur_ti->start_pos) | 1538 | if (newpos < CUR_TI->start_pos) |
1536 | { | 1539 | { |
1537 | struct event ev; | 1540 | struct event ev; |
1538 | 1541 | ||
@@ -1560,7 +1563,7 @@ static bool codec_seek_buffer_callback(size_t newpos) | |||
1560 | /* Seeking inside buffer space. */ | 1563 | /* Seeking inside buffer space. */ |
1561 | logf("seek: -%d", difference); | 1564 | logf("seek: -%d", difference); |
1562 | filebufused += difference; | 1565 | filebufused += difference; |
1563 | cur_ti->available += difference; | 1566 | CUR_TI->available += difference; |
1564 | if (buf_ridx < (unsigned)difference) | 1567 | if (buf_ridx < (unsigned)difference) |
1565 | buf_ridx += filebuflen; | 1568 | buf_ridx += filebuflen; |
1566 | buf_ridx -= difference; | 1569 | buf_ridx -= difference; |
@@ -1606,23 +1609,23 @@ static void codec_pcmbuf_track_changed_callback(void) | |||
1606 | 1609 | ||
1607 | static void codec_discard_codec_callback(void) | 1610 | static void codec_discard_codec_callback(void) |
1608 | { | 1611 | { |
1609 | if (cur_ti->has_codec) | 1612 | if (CUR_TI->has_codec) |
1610 | { | 1613 | { |
1611 | cur_ti->has_codec = false; | 1614 | CUR_TI->has_codec = false; |
1612 | filebufused -= cur_ti->codecsize; | 1615 | filebufused -= CUR_TI->codecsize; |
1613 | buf_ridx += cur_ti->codecsize; | 1616 | buf_ridx += CUR_TI->codecsize; |
1614 | if (buf_ridx >= filebuflen) | 1617 | if (buf_ridx >= filebuflen) |
1615 | buf_ridx -= filebuflen; | 1618 | buf_ridx -= filebuflen; |
1616 | } | 1619 | } |
1617 | 1620 | ||
1618 | #if 0 | 1621 | #if 0 |
1619 | /* Check if a buffer desync has happened, log it and stop playback. */ | 1622 | /* Check if a buffer desync has happened, log it and stop playback. */ |
1620 | if (buf_ridx != cur_ti->buf_idx) | 1623 | if (buf_ridx != CUR_TI->buf_idx) |
1621 | { | 1624 | { |
1622 | int offset = cur_ti->buf_idx - buf_ridx; | 1625 | int offset = CUR_TI->buf_idx - buf_ridx; |
1623 | size_t new_used = filebufused - offset; | 1626 | size_t new_used = filebufused - offset; |
1624 | 1627 | ||
1625 | logf("Buf off :%d=%d-%d", offset, cur_ti->buf_idx, buf_ridx); | 1628 | logf("Buf off :%d=%d-%d", offset, CUR_TI->buf_idx, buf_ridx); |
1626 | logf("Used off:%d",filebufused - new_used); | 1629 | logf("Used off:%d",filebufused - new_used); |
1627 | 1630 | ||
1628 | /* This is a fatal internal error and it's not safe to | 1631 | /* This is a fatal internal error and it's not safe to |
@@ -1718,13 +1721,13 @@ static bool codec_request_next_track_callback(void) | |||
1718 | if (ci.stop_codec || !playing) | 1721 | if (ci.stop_codec || !playing) |
1719 | return false; | 1722 | return false; |
1720 | 1723 | ||
1721 | prev_codectype = get_codec_base_type(cur_ti->id3.codectype); | 1724 | prev_codectype = get_codec_base_type(CUR_TI->id3.codectype); |
1722 | 1725 | ||
1723 | if (!codec_load_next_track()) | 1726 | if (!codec_load_next_track()) |
1724 | return false; | 1727 | return false; |
1725 | 1728 | ||
1726 | /* Check if the next codec is the same file. */ | 1729 | /* Check if the next codec is the same file. */ |
1727 | if (prev_codectype == get_codec_base_type(cur_ti->id3.codectype)) | 1730 | if (prev_codectype == get_codec_base_type(CUR_TI->id3.codectype)) |
1728 | { | 1731 | { |
1729 | logf("New track loaded"); | 1732 | logf("New track loaded"); |
1730 | codec_discard_codec_callback(); | 1733 | codec_discard_codec_callback(); |
@@ -1732,7 +1735,7 @@ static bool codec_request_next_track_callback(void) | |||
1732 | } | 1735 | } |
1733 | else | 1736 | else |
1734 | { | 1737 | { |
1735 | logf("New codec:%d/%d", cur_ti->id3.codectype, prev_codectype); | 1738 | logf("New codec:%d/%d", CUR_TI->id3.codectype, prev_codectype); |
1736 | return false; | 1739 | return false; |
1737 | } | 1740 | } |
1738 | } | 1741 | } |
@@ -1768,7 +1771,7 @@ static void codec_thread(void) | |||
1768 | 1771 | ||
1769 | case Q_CODEC_LOAD: | 1772 | case Q_CODEC_LOAD: |
1770 | LOGFQUEUE("codec < Q_CODEC_LOAD"); | 1773 | LOGFQUEUE("codec < Q_CODEC_LOAD"); |
1771 | if (!cur_ti->has_codec) { | 1774 | if (!CUR_TI->has_codec) { |
1772 | logf("Codec slot is empty!"); | 1775 | logf("Codec slot is empty!"); |
1773 | /* Wait for the pcm buffer to go empty */ | 1776 | /* Wait for the pcm buffer to go empty */ |
1774 | while (pcm_is_playing()) | 1777 | while (pcm_is_playing()) |
@@ -1791,8 +1794,8 @@ static void codec_thread(void) | |||
1791 | mutex_lock(&mutex_codecthread); | 1794 | mutex_lock(&mutex_codecthread); |
1792 | current_codec = CODEC_IDX_AUDIO; | 1795 | current_codec = CODEC_IDX_AUDIO; |
1793 | ci.stop_codec = false; | 1796 | ci.stop_codec = false; |
1794 | wrap = (size_t)&filebuf[filebuflen] - (size_t)cur_ti->codecbuf; | 1797 | wrap = (size_t)&filebuf[filebuflen] - (size_t)CUR_TI->codecbuf; |
1795 | status = codec_load_ram(cur_ti->codecbuf, cur_ti->codecsize, | 1798 | status = codec_load_ram(CUR_TI->codecbuf, CUR_TI->codecsize, |
1796 | &filebuf[0], wrap, &ci); | 1799 | &filebuf[0], wrap, &ci); |
1797 | mutex_unlock(&mutex_codecthread); | 1800 | mutex_unlock(&mutex_codecthread); |
1798 | break ; | 1801 | break ; |
@@ -1877,14 +1880,14 @@ static void codec_thread(void) | |||
1877 | } | 1880 | } |
1878 | } | 1881 | } |
1879 | 1882 | ||
1880 | if (cur_ti->has_codec) | 1883 | if (CUR_TI->has_codec) |
1881 | { | 1884 | { |
1882 | LOGFQUEUE("codec > codec Q_CODEC_LOAD"); | 1885 | LOGFQUEUE("codec > codec Q_CODEC_LOAD"); |
1883 | queue_post(&codec_queue, Q_CODEC_LOAD, 0); | 1886 | queue_post(&codec_queue, Q_CODEC_LOAD, 0); |
1884 | } | 1887 | } |
1885 | else | 1888 | else |
1886 | { | 1889 | { |
1887 | const char *codec_fn = get_codec_filename(cur_ti->id3.codectype); | 1890 | const char *codec_fn = get_codec_filename(CUR_TI->id3.codectype); |
1888 | LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK"); | 1891 | LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK"); |
1889 | queue_post(&codec_queue, Q_CODEC_LOAD_DISK, | 1892 | queue_post(&codec_queue, Q_CODEC_LOAD_DISK, |
1890 | (void *)codec_fn); | 1893 | (void *)codec_fn); |
@@ -1909,7 +1912,7 @@ static bool audio_filebuf_is_lowdata(void) | |||
1909 | 1912 | ||
1910 | static bool audio_have_tracks(void) | 1913 | static bool audio_have_tracks(void) |
1911 | { | 1914 | { |
1912 | return track_ridx != track_widx || cur_ti->filesize; | 1915 | return track_ridx != track_widx || CUR_TI->filesize; |
1913 | } | 1916 | } |
1914 | 1917 | ||
1915 | static bool audio_have_free_tracks(void) | 1918 | static bool audio_have_free_tracks(void) |
@@ -2042,12 +2045,12 @@ static bool audio_buffer_wind_backward(int new_track_ridx, int old_track_ridx) | |||
2042 | 2045 | ||
2043 | static void audio_update_trackinfo(void) | 2046 | static void audio_update_trackinfo(void) |
2044 | { | 2047 | { |
2045 | ci.filesize = cur_ti->filesize; | 2048 | ci.filesize = CUR_TI->filesize; |
2046 | cur_ti->id3.elapsed = 0; | 2049 | CUR_TI->id3.elapsed = 0; |
2047 | cur_ti->id3.offset = 0; | 2050 | CUR_TI->id3.offset = 0; |
2048 | ci.id3 = &cur_ti->id3; | 2051 | ci.id3 = &CUR_TI->id3; |
2049 | ci.curpos = 0; | 2052 | ci.curpos = 0; |
2050 | ci.taginfo_ready = &cur_ti->taginfo_ready; | 2053 | ci.taginfo_ready = &CUR_TI->taginfo_ready; |
2051 | } | 2054 | } |
2052 | 2055 | ||
2053 | /* Yield to codecs for as long as possible if they are in need of data | 2056 | /* Yield to codecs for as long as possible if they are in need of data |
@@ -2268,10 +2271,9 @@ static bool audio_loadcodec(bool start_play) | |||
2268 | { | 2271 | { |
2269 | /* Load the codec directly from disk and save some memory. */ | 2272 | /* Load the codec directly from disk and save some memory. */ |
2270 | track_ridx = track_widx; | 2273 | track_ridx = track_widx; |
2271 | cur_ti = &tracks[track_ridx]; | 2274 | ci.filesize = CUR_TI->filesize; |
2272 | ci.filesize = cur_ti->filesize; | 2275 | ci.id3 = &CUR_TI->id3; |
2273 | ci.id3 = &cur_ti->id3; | 2276 | ci.taginfo_ready = &CUR_TI->taginfo_ready; |
2274 | ci.taginfo_ready = &cur_ti->taginfo_ready; | ||
2275 | ci.curpos = 0; | 2277 | ci.curpos = 0; |
2276 | LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK"); | 2278 | LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK"); |
2277 | queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (void *)codec_fn); | 2279 | queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (void *)codec_fn); |
@@ -2677,8 +2679,8 @@ static bool audio_initialize_buffer_fill(bool clear_tracks) | |||
2677 | * | 2679 | * |
2678 | * This really doesn't look right, so don't use it. | 2680 | * This really doesn't look right, so don't use it. |
2679 | */ | 2681 | */ |
2680 | // if (buf_ridx > cur_ti->buf_idx) | 2682 | // if (buf_ridx > CUR_TI->buf_idx) |
2681 | // cur_ti->start_pos = buf_ridx - cur_ti->buf_idx; | 2683 | // CUR_TI->start_pos = buf_ridx - CUR_TI->buf_idx; |
2682 | 2684 | ||
2683 | /* Set the filling flag true before calling audio_clear_tracks as that | 2685 | /* Set the filling flag true before calling audio_clear_tracks as that |
2684 | * function can yield and we start looping. */ | 2686 | * function can yield and we start looping. */ |
@@ -2760,19 +2762,18 @@ static void audio_rebuffer(void) | |||
2760 | /* Reset buffer and track pointers */ | 2762 | /* Reset buffer and track pointers */ |
2761 | tracks[track_ridx].buf_idx = buf_ridx = buf_widx = 0; | 2763 | tracks[track_ridx].buf_idx = buf_ridx = buf_widx = 0; |
2762 | track_widx = track_ridx; | 2764 | track_widx = track_ridx; |
2763 | cur_ti = &tracks[track_ridx]; | ||
2764 | audio_clear_track_entries(true, true, false); | 2765 | audio_clear_track_entries(true, true, false); |
2765 | filebufused = 0; | 2766 | filebufused = 0; |
2766 | cur_ti->available = 0; | 2767 | CUR_TI->available = 0; |
2767 | 2768 | ||
2768 | /* Fill the buffer */ | 2769 | /* Fill the buffer */ |
2769 | last_peek_offset = -1; | 2770 | last_peek_offset = -1; |
2770 | cur_ti->filesize = 0; | 2771 | CUR_TI->filesize = 0; |
2771 | cur_ti->start_pos = 0; | 2772 | CUR_TI->start_pos = 0; |
2772 | ci.curpos = 0; | 2773 | ci.curpos = 0; |
2773 | 2774 | ||
2774 | if (!cur_ti->taginfo_ready) | 2775 | if (!CUR_TI->taginfo_ready) |
2775 | memset(&cur_ti->id3, 0, sizeof(struct mp3entry)); | 2776 | memset(&CUR_TI->id3, 0, sizeof(struct mp3entry)); |
2776 | 2777 | ||
2777 | audio_fill_file_buffer(false, true, 0); | 2778 | audio_fill_file_buffer(false, true, 0); |
2778 | } | 2779 | } |
@@ -2789,7 +2790,7 @@ static void audio_check_new_track(void) | |||
2789 | if (playlist_next_dir(ci.new_track)) | 2790 | if (playlist_next_dir(ci.new_track)) |
2790 | { | 2791 | { |
2791 | ci.new_track = 0; | 2792 | ci.new_track = 0; |
2792 | cur_ti->taginfo_ready = false; | 2793 | CUR_TI->taginfo_ready = false; |
2793 | audio_rebuffer(); | 2794 | audio_rebuffer(); |
2794 | goto skip_done; | 2795 | goto skip_done; |
2795 | } | 2796 | } |
@@ -2838,13 +2839,12 @@ static void audio_check_new_track(void) | |||
2838 | new_playlist = false; | 2839 | new_playlist = false; |
2839 | } | 2840 | } |
2840 | 2841 | ||
2841 | track_ridx += ci.new_track; | ||
2842 | track_ridx &= MAX_TRACK_MASK; | ||
2843 | |||
2844 | /* Save the old track */ | 2842 | /* Save the old track */ |
2845 | prev_ti = cur_ti; | 2843 | prev_ti = CUR_TI; |
2844 | |||
2846 | /* Move to the new track */ | 2845 | /* Move to the new track */ |
2847 | cur_ti = &tracks[track_ridx]; | 2846 | track_ridx += ci.new_track; |
2847 | track_ridx &= MAX_TRACK_MASK; | ||
2848 | 2848 | ||
2849 | if (automatic_skip) | 2849 | if (automatic_skip) |
2850 | playlist_end = false; | 2850 | playlist_end = false; |
@@ -2855,7 +2855,7 @@ static void audio_check_new_track(void) | |||
2855 | if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK) | 2855 | if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK) |
2856 | { | 2856 | { |
2857 | ci.new_track = 0; | 2857 | ci.new_track = 0; |
2858 | cur_ti->taginfo_ready = false; | 2858 | CUR_TI->taginfo_ready = false; |
2859 | audio_rebuffer(); | 2859 | audio_rebuffer(); |
2860 | goto skip_done; | 2860 | goto skip_done; |
2861 | } | 2861 | } |
@@ -2864,7 +2864,7 @@ static void audio_check_new_track(void) | |||
2864 | ci.new_track = 0; | 2864 | ci.new_track = 0; |
2865 | 2865 | ||
2866 | /* If the target track is clearly not in memory */ | 2866 | /* If the target track is clearly not in memory */ |
2867 | if (cur_ti->filesize == 0 || !cur_ti->taginfo_ready) | 2867 | if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready) |
2868 | { | 2868 | { |
2869 | audio_rebuffer(); | 2869 | audio_rebuffer(); |
2870 | goto skip_done; | 2870 | goto skip_done; |
@@ -2907,7 +2907,7 @@ static void audio_check_new_track(void) | |||
2907 | } | 2907 | } |
2908 | else | 2908 | else |
2909 | { | 2909 | { |
2910 | cur_ti->taginfo_ready = false; | 2910 | CUR_TI->taginfo_ready = false; |
2911 | audio_rebuffer(); | 2911 | audio_rebuffer(); |
2912 | } | 2912 | } |
2913 | } | 2913 | } |
@@ -2954,18 +2954,18 @@ static void audio_rebuffer_and_seek(size_t newpos) | |||
2954 | 2954 | ||
2955 | if (newpos > conf_preseek) { | 2955 | if (newpos > conf_preseek) { |
2956 | buf_ridx += conf_preseek; | 2956 | buf_ridx += conf_preseek; |
2957 | cur_ti->start_pos = newpos - conf_preseek; | 2957 | CUR_TI->start_pos = newpos - conf_preseek; |
2958 | } | 2958 | } |
2959 | else | 2959 | else |
2960 | { | 2960 | { |
2961 | buf_ridx += newpos; | 2961 | buf_ridx += newpos; |
2962 | cur_ti->start_pos = 0; | 2962 | CUR_TI->start_pos = 0; |
2963 | } | 2963 | } |
2964 | 2964 | ||
2965 | cur_ti->filerem = cur_ti->filesize - cur_ti->start_pos; | 2965 | CUR_TI->filerem = CUR_TI->filesize - CUR_TI->start_pos; |
2966 | cur_ti->available = 0; | 2966 | CUR_TI->available = 0; |
2967 | 2967 | ||
2968 | lseek(current_fd, cur_ti->start_pos, SEEK_SET); | 2968 | lseek(current_fd, CUR_TI->start_pos, SEEK_SET); |
2969 | 2969 | ||
2970 | LOGFQUEUE("audio > codec Q_CODEC_REQUEST_COMPLETE"); | 2970 | LOGFQUEUE("audio > codec Q_CODEC_REQUEST_COMPLETE"); |
2971 | queue_post(&codec_callback_queue, Q_CODEC_REQUEST_COMPLETE, 0); | 2971 | queue_post(&codec_callback_queue, Q_CODEC_REQUEST_COMPLETE, 0); |
@@ -3081,8 +3081,8 @@ void audio_invalidate_tracks(void) | |||
3081 | track_widx = (track_widx + 1) & MAX_TRACK_MASK; | 3081 | track_widx = (track_widx + 1) & MAX_TRACK_MASK; |
3082 | 3082 | ||
3083 | /* Mark all other entries null (also buffered wrong metadata). */ | 3083 | /* Mark all other entries null (also buffered wrong metadata). */ |
3084 | filebufused = cur_ti->available; | 3084 | filebufused = CUR_TI->available; |
3085 | buf_widx = buf_ridx + cur_ti->available; | 3085 | buf_widx = buf_ridx + CUR_TI->available; |
3086 | if (buf_widx >= filebuflen) | 3086 | if (buf_widx >= filebuflen) |
3087 | buf_widx -= filebuflen; | 3087 | buf_widx -= filebuflen; |
3088 | 3088 | ||
@@ -3103,16 +3103,16 @@ static void audio_new_playlist(void) | |||
3103 | track_widx &= MAX_TRACK_MASK; | 3103 | track_widx &= MAX_TRACK_MASK; |
3104 | 3104 | ||
3105 | /* Stop reading the current track */ | 3105 | /* Stop reading the current track */ |
3106 | cur_ti->filerem = 0; | 3106 | CUR_TI->filerem = 0; |
3107 | close(current_fd); | 3107 | close(current_fd); |
3108 | current_fd = -1; | 3108 | current_fd = -1; |
3109 | 3109 | ||
3110 | /* Mark the current track as invalid to prevent skipping back to it */ | 3110 | /* Mark the current track as invalid to prevent skipping back to it */ |
3111 | cur_ti->taginfo_ready = false; | 3111 | CUR_TI->taginfo_ready = false; |
3112 | 3112 | ||
3113 | /* Invalidate the buffer other than the playing track */ | 3113 | /* Invalidate the buffer other than the playing track */ |
3114 | filebufused = cur_ti->available; | 3114 | filebufused = CUR_TI->available; |
3115 | buf_widx = buf_ridx + cur_ti->available; | 3115 | buf_widx = buf_ridx + CUR_TI->available; |
3116 | if (buf_widx >= filebuflen) | 3116 | if (buf_widx >= filebuflen) |
3117 | buf_widx -= filebuflen; | 3117 | buf_widx -= filebuflen; |
3118 | } | 3118 | } |
@@ -3367,7 +3367,7 @@ static void audio_thread(void) | |||
3367 | case Q_AUDIO_TRACK_CHANGED: | 3367 | case Q_AUDIO_TRACK_CHANGED: |
3368 | LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED"); | 3368 | LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED"); |
3369 | if (track_changed_callback) | 3369 | if (track_changed_callback) |
3370 | track_changed_callback(&cur_ti->id3); | 3370 | track_changed_callback(&CUR_TI->id3); |
3371 | track_changed = true; | 3371 | track_changed = true; |
3372 | playlist_update_resume_info(audio_current_track()); | 3372 | playlist_update_resume_info(audio_current_track()); |
3373 | break ; | 3373 | break ; |