1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2007 Nicolas Pennequin
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
27 #include "buffering.h"
45 #include "mp3_playback.h"
51 #include "appevents.h"
55 #include "jpeg_load.h"
59 #define GUARD_BUFSIZE (32*1024)
61 /* Define LOGF_ENABLE to enable logf output in this file */
62 /*#define LOGF_ENABLE*/
65 /* macros to enable logf for queues
66 logging on SYS_TIMEOUT can be disabled */
68 /* Define this for logf output of all queuing except SYS_TIMEOUT */
69 #define BUFFERING_LOGQUEUES
70 /* Define this to logf SYS_TIMEOUT messages */
71 /* #define BUFFERING_LOGQUEUES_SYS_TIMEOUT */
74 #ifdef BUFFERING_LOGQUEUES
75 #define LOGFQUEUE logf
77 #define LOGFQUEUE(...)
80 #ifdef BUFFERING_LOGQUEUES_SYS_TIMEOUT
81 #define LOGFQUEUE_SYS_TIMEOUT logf
83 #define LOGFQUEUE_SYS_TIMEOUT(...)
86 /* default point to start buffer refill */
87 #define BUFFERING_DEFAULT_WATERMARK (1024*128)
88 /* amount of data to read in one read() call */
89 #define BUFFERING_DEFAULT_FILECHUNK (1024*32)
91 #define BUF_HANDLE_MASK 0x7FFFFFFF
94 /* assert(sizeof(struct memory_handle)%4==0) */
95 struct memory_handle
{
96 int id
; /* A unique ID for the handle */
97 enum data_type type
; /* Type of data buffered with this handle */
98 char path
[MAX_PATH
]; /* Path if data originated in a file */
99 int fd
; /* File descriptor to path (-1 if closed) */
100 size_t start
; /* Start index of the handle's data buffer,
101 for use by reset_handle. */
102 size_t data
; /* Start index of the handle's data */
103 volatile size_t ridx
; /* Read pointer, relative to the main buffer */
104 size_t widx
; /* Write pointer */
105 size_t filesize
; /* File total length */
106 size_t filerem
; /* Remaining bytes of file NOT in buffer */
107 volatile size_t available
; /* Available bytes to read from buffer */
108 size_t offset
; /* Offset at which we started reading the file */
109 struct memory_handle
*next
;
111 /* invariant: filesize == offset + available + filerem */
114 static char *guard_buffer
;
116 static size_t buffer_len
;
118 static volatile size_t buf_widx
; /* current writing position */
119 static volatile size_t buf_ridx
; /* current reading position */
120 /* buf_*idx are values relative to the buffer, not real pointers. */
123 static size_t conf_watermark
= 0; /* Level to trigger filebuf fill */
125 static size_t high_watermark
= 0; /* High watermark for rebuffer */
128 /* current memory handle in the linked list. NULL when the list is empty. */
129 static struct memory_handle
*cur_handle
;
130 /* first memory handle in the linked list. NULL when the list is empty. */
131 static struct memory_handle
*first_handle
;
133 static int num_handles
; /* number of handles in the list */
135 static int base_handle_id
;
137 static struct mutex llist_mutex
;
138 static struct mutex llist_mod_mutex
;
140 /* Handle cache (makes find_handle faster).
141 This is global so that move_handle and rm_handle can invalidate it. */
142 static struct memory_handle
*cached_handle
= NULL
;
145 size_t remaining
; /* Amount of data needing to be buffered */
146 size_t wasted
; /* Amount of space available for freeing */
147 size_t buffered
; /* Amount of data currently in the buffer */
148 size_t useful
; /* Amount of data still useful to the user */
152 /* Messages available to communicate with the buffering thread */
154 Q_BUFFER_HANDLE
= 1, /* Request buffering of a handle, this should not be
155 used in a low buffer situation. */
156 Q_RESET_HANDLE
, /* (internal) Request resetting of a handle to its
157 offset (the offset has to be set beforehand) */
158 Q_CLOSE_HANDLE
, /* Request closing a handle */
159 Q_BASE_HANDLE
, /* Set the reference handle for buf_useful_data */
162 Q_START_FILL
, /* Request that the buffering thread initiate a buffer
163 fill at its earliest convenience */
164 Q_HANDLE_ADDED
, /* Inform the buffering thread that a handle was added,
165 (which means the disk is spinning) */
168 /* Buffering thread */
169 static void buffering_thread(void);
170 static long buffering_stack
[(DEFAULT_STACK_SIZE
+ 0x2000)/sizeof(long)];
171 static const char buffering_thread_name
[] = "buffering";
172 static unsigned int buffering_thread_id
= 0;
173 static struct event_queue buffering_queue
;
174 static struct queue_sender_list buffering_queue_sender_list
;
178 /* Ring buffer helper functions */
179 /* Buffer pointer (p) plus value (v), wrapped if necessary */
180 static inline uintptr_t ringbuf_add(uintptr_t p
, size_t v
)
182 uintptr_t res
= p
+ v
;
183 if (res
>= buffer_len
)
184 res
-= buffer_len
; /* wrap if necssary */
189 /* Buffer pointer (p) minus value (v), wrapped if necessary */
190 static inline uintptr_t ringbuf_sub(uintptr_t p
, size_t v
)
194 res
+= buffer_len
; /* wrap */
200 /* How far value (v) plus buffer pointer (p1) will cross buffer pointer (p2) */
201 static inline ssize_t
ringbuf_add_cross(uintptr_t p1
, size_t v
, uintptr_t p2
)
203 ssize_t res
= p1
+ v
- p2
;
204 if (p1
>= p2
) /* wrap if necessary */
210 /* Bytes available in the buffer */
211 #define BUF_USED ringbuf_sub(buf_widx, buf_ridx)
214 LINKED LIST MANAGEMENT
215 ======================
217 add_handle : Add a handle to the list
218 rm_handle : Remove a handle from the list
219 find_handle : Get a handle pointer from an ID
220 move_handle : Move a handle in the buffer (with or without its data)
222 These functions only handle the linked list structure. They don't touch the
223 contents of the struct memory_handle headers. They also change the buf_*idx
224 pointers when necessary and manage the handle IDs.
226 The first and current (== last) handle are kept track of.
227 A new handle is added at buf_widx and becomes the current one.
228 buf_widx always points to the current writing position for the current handle
229 buf_ridx always points to the location of the first handle.
230 buf_ridx == buf_widx means the buffer is empty.
234 /* Add a new handle to the linked list and return it. It will have become the
236 data_size must contain the size of what will be in the handle.
237 can_wrap tells us whether this type of data may wrap on buffer
238 alloc_all tells us if we must immediately be able to allocate data_size
239 returns a valid memory handle if all conditions for allocation are met.
240 NULL if there memory_handle itself cannot be allocated or if the
241 data_size cannot be allocated and alloc_all is set. This function's
242 only potential side effect is to allocate space for the cur_handle
245 static struct memory_handle
*add_handle(size_t data_size
, bool can_wrap
,
248 /* gives each handle a unique id */
249 static int cur_handle_id
= 0;
255 if (num_handles
>= BUF_MAX_HANDLES
)
258 mutex_lock(&llist_mutex
);
259 mutex_lock(&llist_mod_mutex
);
261 if (cur_handle
&& cur_handle
->filerem
> 0) {
262 /* the current handle hasn't finished buffering. We can only add
263 a new one if there is already enough free space to finish
265 size_t req
= cur_handle
->filerem
+ sizeof(struct memory_handle
);
266 if (ringbuf_add_cross(cur_handle
->widx
, req
, buf_ridx
) >= 0) {
267 /* Not enough space */
268 mutex_unlock(&llist_mod_mutex
);
269 mutex_unlock(&llist_mutex
);
272 /* Allocate the remainder of the space for the current handle */
273 buf_widx
= ringbuf_add(cur_handle
->widx
, cur_handle
->filerem
);
277 /* align to 4 bytes up */
278 new_widx
= ringbuf_add(buf_widx
, 3) & ~3;
280 len
= data_size
+ sizeof(struct memory_handle
);
282 /* First, will the handle wrap? */
283 /* If the handle would wrap, move to the beginning of the buffer,
284 * or if the data must not but would wrap, move it to the beginning */
285 if( (new_widx
+ sizeof(struct memory_handle
) > buffer_len
) ||
286 (!can_wrap
&& (new_widx
+ len
> buffer_len
)) ) {
290 /* How far we shifted buf_widx to align things, must be < buffer_len */
291 shift
= ringbuf_sub(new_widx
, buf_widx
);
293 /* How much space are we short in the actual ring buffer? */
294 overlap
= ringbuf_add_cross(buf_widx
, shift
+ len
, buf_ridx
);
295 if (overlap
>= 0 && (alloc_all
|| (unsigned)overlap
> data_size
)) {
296 /* Not enough space for required allocations */
297 mutex_unlock(&llist_mod_mutex
);
298 mutex_unlock(&llist_mutex
);
302 /* There is enough space for the required data, advance the buf_widx and
303 * initialize the struct */
306 struct memory_handle
*new_handle
=
307 (struct memory_handle
*)(&buffer
[buf_widx
]);
309 /* only advance the buffer write index of the size of the struct */
310 buf_widx
= ringbuf_add(buf_widx
, sizeof(struct memory_handle
));
312 new_handle
->id
= cur_handle_id
;
313 /* Wrap signed int is safe and 0 doesn't happen */
314 cur_handle_id
= (cur_handle_id
+ 1) & BUF_HANDLE_MASK
;
315 new_handle
->next
= NULL
;
319 /* the new handle is the first one */
320 first_handle
= new_handle
;
323 cur_handle
->next
= new_handle
;
325 cur_handle
= new_handle
;
327 mutex_unlock(&llist_mod_mutex
);
328 mutex_unlock(&llist_mutex
);
332 /* Delete a given memory handle from the linked list
333 and return true for success. Nothing is actually erased from memory. */
334 static bool rm_handle(const struct memory_handle
*h
)
339 mutex_lock(&llist_mutex
);
340 mutex_lock(&llist_mod_mutex
);
342 if (h
== first_handle
) {
343 first_handle
= h
->next
;
344 if (h
== cur_handle
) {
345 /* h was the first and last handle: the buffer is now empty */
347 buf_ridx
= buf_widx
= 0;
349 /* update buf_ridx to point to the new first handle */
350 buf_ridx
= (void *)first_handle
- (void *)buffer
;
353 struct memory_handle
*m
= first_handle
;
354 /* Find the previous handle */
355 while (m
&& m
->next
!= h
) {
358 if (m
&& m
->next
== h
) {
360 if (h
== cur_handle
) {
362 buf_widx
= cur_handle
->widx
;
365 mutex_unlock(&llist_mod_mutex
);
366 mutex_unlock(&llist_mutex
);
371 /* Invalidate the cache to prevent it from keeping the old location of h */
372 if (h
== cached_handle
)
373 cached_handle
= NULL
;
377 mutex_unlock(&llist_mod_mutex
);
378 mutex_unlock(&llist_mutex
);
382 /* Return a pointer to the memory handle of given ID.
383 NULL if the handle wasn't found */
384 static struct memory_handle
*find_handle(int handle_id
)
389 mutex_lock(&llist_mutex
);
391 /* simple caching because most of the time the requested handle
392 will either be the same as the last, or the one after the last */
395 if (cached_handle
->id
== handle_id
) {
396 mutex_unlock(&llist_mutex
);
397 return cached_handle
;
398 } else if (cached_handle
->next
&&
399 (cached_handle
->next
->id
== handle_id
)) {
400 cached_handle
= cached_handle
->next
;
401 mutex_unlock(&llist_mutex
);
402 return cached_handle
;
406 struct memory_handle
*m
= first_handle
;
407 while (m
&& m
->id
!= handle_id
) {
410 /* This condition can only be reached with !m or m->id == handle_id */
414 mutex_unlock(&llist_mutex
);
418 /* Move a memory handle and data_size of its data delta bytes along the buffer.
419 delta maximum bytes available to move the handle. If the move is performed
420 it is set to the actual distance moved.
421 data_size is the amount of data to move along with the struct.
422 returns a valid memory_handle if the move is successful
423 NULL if the handle is NULL, the move would be less than the size of
424 a memory_handle after correcting for wraps or if the handle is not
425 found in the linked list for adjustment. This function has no side
426 effects if NULL is returned. */
427 static bool move_handle(struct memory_handle
**h
, size_t *delta
,
428 size_t data_size
, bool can_wrap
)
430 struct memory_handle
*dest
;
431 const struct memory_handle
*src
;
439 size_t final_delta
= *delta
;
444 if (h
== NULL
|| (src
= *h
) == NULL
)
447 size_to_move
= sizeof(struct memory_handle
) + data_size
;
449 /* Align to four bytes, down */
451 if (final_delta
< sizeof(struct memory_handle
)) {
452 /* It's not legal to move less than the size of the struct */
456 mutex_lock(&llist_mutex
);
457 mutex_lock(&llist_mod_mutex
);
459 oldpos
= (void *)src
- (void *)buffer
;
460 newpos
= ringbuf_add(oldpos
, final_delta
);
461 overlap
= ringbuf_add_cross(newpos
, size_to_move
, buffer_len
- 1);
462 overlap_old
= ringbuf_add_cross(oldpos
, size_to_move
, buffer_len
-1);
465 /* Some part of the struct + data would wrap, maybe ok */
466 size_t correction
= 0;
467 /* If the overlap lands inside the memory_handle */
469 /* Otherwise the overlap falls in the data area and must all be
470 * backed out. This may become conditional if ever we move
471 * data that is allowed to wrap (ie audio) */
472 correction
= overlap
;
473 } else if ((unsigned)overlap
> data_size
) {
474 /* Correct the position and real delta to prevent the struct from
475 * wrapping, this guarantees an aligned delta, I think */
476 correction
= overlap
- data_size
;
479 /* Align correction to four bytes up */
480 correction
= (correction
+ 3) & ~3;
481 if (final_delta
< correction
+ sizeof(struct memory_handle
)) {
482 /* Delta cannot end up less than the size of the struct */
483 mutex_unlock(&llist_mod_mutex
);
484 mutex_unlock(&llist_mutex
);
487 newpos
-= correction
;
488 overlap
-= correction
;/* Used below to know how to split the data */
489 final_delta
-= correction
;
493 dest
= (struct memory_handle
*)(&buffer
[newpos
]);
495 if (src
== first_handle
) {
499 struct memory_handle
*m
= first_handle
;
500 while (m
&& m
->next
!= src
) {
503 if (m
&& m
->next
== src
) {
506 mutex_unlock(&llist_mod_mutex
);
507 mutex_unlock(&llist_mutex
);
513 /* Update the cache to prevent it from keeping the old location of h */
514 if (src
== cached_handle
)
515 cached_handle
= dest
;
517 /* the cur_handle pointer might need updating */
518 if (src
== cur_handle
)
522 /* Copying routine takes into account that the handles have a
523 * distance between each other which is a multiple of four. Faster 2 word
524 * copy may be ok but do this for safety and because wrapped copies should
525 * be fairly uncommon */
527 here
= (int32_t *)((ringbuf_add(oldpos
, size_to_move
- 1) & ~3)+ (intptr_t)buffer
);
528 there
=(int32_t *)((ringbuf_add(newpos
, size_to_move
- 1) & ~3)+ (intptr_t)buffer
);
529 end
= (int32_t *)(( intptr_t)buffer
+ buffer_len
- 4);
530 begin
=(int32_t *)buffer
;
532 n
= (size_to_move
& ~3)/4;
534 if ( overlap_old
> 0 || overlap
> 0 ) {
535 /* Old or moved handle wraps */
544 /* both handles do not wrap */
545 memmove(dest
,src
,size_to_move
);
549 /* Update the caller with the new location of h and the distance moved */
551 *delta
= final_delta
;
552 mutex_unlock(&llist_mod_mutex
);
553 mutex_unlock(&llist_mutex
);
559 BUFFER SPACE MANAGEMENT
560 =======================
562 update_data_counters: Updates the values in data_counters
563 buffer_is_low : Returns true if the amount of useful data in the buffer is low
564 buffer_handle : Buffer data for a handle
565 reset_handle : Reset write position and data buffer of a handle to its offset
566 rebuffer_handle : Seek to a nonbuffered part of a handle by rebuffering the data
567 shrink_handle : Free buffer space by moving a handle
568 fill_buffer : Call buffer_handle for all handles that have data to buffer
570 These functions are used by the buffering thread to manage buffer space.
573 static void update_data_counters(void)
575 struct memory_handle
*m
= find_handle(base_handle_id
);
576 bool is_useful
= m
==NULL
;
580 size_t remaining
= 0;
583 mutex_lock(&llist_mutex
);
587 buffered
+= m
->available
;
588 wasted
+= ringbuf_sub(m
->ridx
, m
->data
);
589 remaining
+= m
->filerem
;
591 if (m
->id
== base_handle_id
)
595 useful
+= ringbuf_sub(m
->widx
, m
->ridx
);
600 mutex_unlock(&llist_mutex
);
602 data_counters
.buffered
= buffered
;
603 data_counters
.wasted
= wasted
;
604 data_counters
.remaining
= remaining
;
605 data_counters
.useful
= useful
;
608 static inline bool buffer_is_low(void)
610 update_data_counters();
611 return data_counters
.useful
< (conf_watermark
/ 2);
614 /* Buffer data for the given handle.
615 Return whether or not the buffering should continue explicitly. */
616 static bool buffer_handle(int handle_id
)
618 logf("buffer_handle(%d)", handle_id
);
619 struct memory_handle
*h
= find_handle(handle_id
);
625 if (h
->filerem
== 0) {
626 /* nothing left to buffer */
630 if (h
->fd
< 0) /* file closed, reopen */
633 h
->fd
= open(h
->path
, O_RDONLY
);
637 /* could not open the file, truncate it where it is */
638 h
->filesize
-= h
->filerem
;
644 lseek(h
->fd
, h
->offset
, SEEK_SET
);
649 if (h
->type
== TYPE_ID3
)
651 if (!get_metadata((struct mp3entry
*)(buffer
+ h
->data
), h
->fd
, h
->path
))
653 /* metadata parsing failed: clear the buffer. */
654 memset(buffer
+ h
->data
, 0, sizeof(struct mp3entry
));
659 h
->available
= sizeof(struct mp3entry
);
660 h
->widx
+= sizeof(struct mp3entry
);
661 send_event(BUFFER_EVENT_FINISHED
, &h
->id
);
665 while (h
->filerem
> 0 && !stop
)
667 /* max amount to copy */
668 size_t copy_n
= MIN( MIN(h
->filerem
, BUFFERING_DEFAULT_FILECHUNK
),
669 buffer_len
- h
->widx
);
672 intptr_t next_handle
= (intptr_t)h
->next
- (intptr_t)buffer
;
674 /* stop copying if it would overwrite the reading position */
675 if (ringbuf_add_cross(h
->widx
, copy_n
, buf_ridx
) >= 0)
678 /* FIXME: This would overwrite the next handle
679 * If this is true, then there's a handle even though we have still
680 * data to buffer. This should NEVER EVER happen! (but it does :( ) */
681 if (h
->next
&& (overlap
682 = ringbuf_add_cross(h
->widx
, copy_n
, next_handle
)) > 0)
684 /* stop buffering data for now and post-pone buffering the rest */
686 DEBUGF( "%s(): Preventing handle corruption: h1.id:%d h2.id:%d"
687 " copy_n:%lu overlap:%ld h1.filerem:%lu\n", __func__
,
688 h
->id
, h
->next
->id
, copy_n
, overlap
, h
->filerem
);
692 /* rc is the actual amount read */
693 int rc
= read(h
->fd
, &buffer
[h
->widx
], copy_n
);
697 /* Some kind of filesystem error, maybe recoverable if not codec */
698 if (h
->type
== TYPE_CODEC
) {
699 logf("Partial codec");
703 DEBUGF("File ended %ld bytes early\n", (long)h
->filerem
);
704 h
->filesize
-= h
->filerem
;
710 h
->widx
= ringbuf_add(h
->widx
, rc
);
716 /* If this is a large file, see if we need to break or give the codec
718 if (h
->type
== TYPE_PACKET_AUDIO
&&
719 pcmbuf_is_lowdata() && !buffer_is_low())
728 if (!queue_empty(&buffering_queue
))
732 if (h
->filerem
== 0) {
733 /* finished buffering the file */
736 send_event(BUFFER_EVENT_FINISHED
, &h
->id
);
742 /* Reset writing position and data buffer of a handle to its current offset.
743 Use this after having set the new offset to use. */
744 static void reset_handle(int handle_id
)
746 size_t alignment_pad
;
748 logf("reset_handle(%d)", handle_id
);
750 struct memory_handle
*h
= find_handle(handle_id
);
754 /* Align to desired storage alignment */
755 alignment_pad
= (h
->offset
- (size_t)(&buffer
[h
->start
]))
756 & STORAGE_ALIGN_MASK
;
757 h
->ridx
= h
->widx
= h
->data
= ringbuf_add(h
->start
, alignment_pad
);
762 h
->filerem
= h
->filesize
- h
->offset
;
765 lseek(h
->fd
, h
->offset
, SEEK_SET
);
769 /* Seek to a nonbuffered part of a handle by rebuffering the data. */
770 static void rebuffer_handle(int handle_id
, size_t newpos
)
772 struct memory_handle
*h
= find_handle(handle_id
);
776 /* When seeking foward off of the buffer, if it is a short seek don't
777 rebuffer the whole track, just read enough to satisfy */
778 if (newpos
> h
->offset
&& newpos
- h
->offset
< BUFFERING_DEFAULT_FILECHUNK
)
780 LOGFQUEUE("buffering >| Q_BUFFER_HANDLE %d", handle_id
);
781 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, handle_id
);
782 h
->ridx
= h
->data
+ newpos
;
788 /* Reset the handle to its new offset */
789 LOGFQUEUE("buffering >| Q_RESET_HANDLE %d", handle_id
);
790 queue_send(&buffering_queue
, Q_RESET_HANDLE
, handle_id
);
792 size_t next
= (intptr_t)h
->next
- (intptr_t)buffer
;
793 if (ringbuf_sub(next
, h
->data
) < h
->filesize
- newpos
)
795 /* There isn't enough space to rebuffer all of the track from its new
796 offset, so we ask the user to free some */
797 DEBUGF("%s(): space is needed\n", __func__
);
798 send_event(BUFFER_EVENT_REBUFFER
, &handle_id
);
801 /* Now we ask for a rebuffer */
802 LOGFQUEUE("buffering >| Q_BUFFER_HANDLE %d", handle_id
);
803 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, handle_id
);
806 static bool close_handle(int handle_id
)
808 struct memory_handle
*h
= find_handle(handle_id
);
810 /* If the handle is not found, it is closed */
819 /* rm_handle returns true unless the handle somehow persists after exit */
823 /* Free buffer space by moving the handle struct right before the useful
824 part of its data buffer or by moving all the data. */
825 static void shrink_handle(struct memory_handle
*h
)
832 if (h
->next
&& h
->filerem
== 0 &&
833 (h
->type
== TYPE_ID3
|| h
->type
== TYPE_CUESHEET
||
834 h
->type
== TYPE_BITMAP
|| h
->type
== TYPE_CODEC
||
835 h
->type
== TYPE_ATOMIC_AUDIO
))
837 /* metadata handle: we can move all of it */
838 size_t handle_distance
=
839 ringbuf_sub((unsigned)((void *)h
->next
- (void*)buffer
), h
->data
);
840 delta
= handle_distance
- h
->available
;
842 /* The value of delta might change for alignment reasons */
843 if (!move_handle(&h
, &delta
, h
->available
, h
->type
==TYPE_CODEC
))
846 size_t olddata
= h
->data
;
847 h
->data
= ringbuf_add(h
->data
, delta
);
848 h
->ridx
= ringbuf_add(h
->ridx
, delta
);
849 h
->widx
= ringbuf_add(h
->widx
, delta
);
851 if (h
->type
== TYPE_ID3
&& h
->filesize
== sizeof(struct mp3entry
)) {
852 /* when moving an mp3entry we need to readjust its pointers. */
853 adjust_mp3entry((struct mp3entry
*)&buffer
[h
->data
],
854 (void *)&buffer
[h
->data
],
855 (const void *)&buffer
[olddata
]);
856 } else if (h
->type
== TYPE_BITMAP
) {
857 /* adjust the bitmap's pointer */
858 struct bitmap
*bmp
= (struct bitmap
*)&buffer
[h
->data
];
859 bmp
->data
= &buffer
[h
->data
+ sizeof(struct bitmap
)];
864 /* only move the handle struct */
865 delta
= ringbuf_sub(h
->ridx
, h
->data
);
866 if (!move_handle(&h
, &delta
, 0, true))
869 h
->data
= ringbuf_add(h
->data
, delta
);
870 h
->start
= ringbuf_add(h
->start
, delta
);
871 h
->available
-= delta
;
876 /* Fill the buffer by buffering as much data as possible for handles that still
877 have data left to buffer
878 Return whether or not to continue filling after this */
879 static bool fill_buffer(void)
881 logf("fill_buffer()");
882 struct memory_handle
*m
;
883 shrink_handle(first_handle
);
885 while (queue_empty(&buffering_queue
) && m
) {
886 if (m
->filerem
> 0) {
887 if (!buffer_handle(m
->id
)) {
900 /* only spin the disk down if the filling wasn't interrupted by an
901 event arriving in the queue. */
908 /* Given a file descriptor to a bitmap file, write the bitmap data to the
909 buffer, with a struct bitmap and the actual data immediately following.
910 Return value is the total size (struct + data). */
911 static int load_image(int fd
, const char *path
, struct dim
*dim
)
914 struct bitmap
*bmp
= (struct bitmap
*)&buffer
[buf_widx
];
916 /* get the desired image size */
917 bmp
->width
= dim
->width
, bmp
->height
= dim
->height
;
918 /* FIXME: alignment may be needed for the data buffer. */
919 bmp
->data
= &buffer
[buf_widx
+ sizeof(struct bitmap
)];
923 #if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
924 bmp
->maskdata
= NULL
;
927 int free
= (int)MIN(buffer_len
- BUF_USED
, buffer_len
- buf_widx
)
928 - sizeof(struct bitmap
);
931 int pathlen
= strlen(path
);
932 if (strcmp(path
+ pathlen
- 4, ".bmp"))
933 rc
= read_jpeg_fd(fd
, bmp
, free
, FORMAT_NATIVE
|FORMAT_DITHER
|
934 FORMAT_RESIZE
|FORMAT_KEEP_ASPECT
, NULL
);
937 rc
= read_bmp_fd(fd
, bmp
, free
, FORMAT_NATIVE
|FORMAT_DITHER
|
938 FORMAT_RESIZE
|FORMAT_KEEP_ASPECT
, NULL
);
939 return rc
+ (rc
> 0 ? sizeof(struct bitmap
) : 0);
945 MAIN BUFFERING API CALLS
946 ========================
948 bufopen : Request the opening of a new handle for a file
949 bufalloc : Open a new handle for data other than a file.
950 bufclose : Close an open handle
951 bufseek : Set the read pointer in a handle
952 bufadvance : Move the read pointer in a handle
953 bufread : Copy data from a handle into a given buffer
954 bufgetdata : Give a pointer to the handle's data
956 These functions are exported, to allow interaction with the buffer.
957 They take care of the content of the structs, and rely on the linked list
958 management functions for all the actual handle management work.
962 /* Reserve space in the buffer for a file.
963 filename: name of the file to open
964 offset: offset at which to start buffering the file, useful when the first
965 (offset-1) bytes of the file aren't needed.
966 type: one of the data types supported (audio, image, cuesheet, others
967 user_data: user data passed possibly passed in subcalls specific to a
968 data_type (only used for image (albumart) buffering so far )
969 return value: <0 if the file cannot be opened, or one file already
970 queued to be opened, otherwise the handle for the file in the buffer
972 int bufopen(const char *file
, size_t offset
, enum data_type type
,
975 #ifndef HAVE_ALBUMART
976 /* currently only used for aa loading */
979 if (type
== TYPE_ID3
)
981 /* ID3 case: allocate space, init the handle and return. */
983 struct memory_handle
*h
= add_handle(sizeof(struct mp3entry
), false, true);
985 return ERR_BUFFER_FULL
;
988 h
->filesize
= sizeof(struct mp3entry
);
989 h
->filerem
= sizeof(struct mp3entry
);
996 strlcpy(h
->path
, file
, MAX_PATH
);
998 buf_widx
+= sizeof(struct mp3entry
); /* safe because the handle
1001 /* Inform the buffering thread that we added a handle */
1002 LOGFQUEUE("buffering > Q_HANDLE_ADDED %d", h
->id
);
1003 queue_post(&buffering_queue
, Q_HANDLE_ADDED
, h
->id
);
1008 /* Other cases: there is a little more work. */
1010 int fd
= open(file
, O_RDONLY
);
1012 return ERR_FILE_ERROR
;
1014 size_t size
= filesize(fd
);
1015 bool can_wrap
= type
==TYPE_PACKET_AUDIO
|| type
==TYPE_CODEC
;
1017 size_t adjusted_offset
= offset
;
1018 if (adjusted_offset
> size
)
1019 adjusted_offset
= 0;
1021 /* Reserve extra space because alignment can move data forward */
1022 struct memory_handle
*h
= add_handle(size
-adjusted_offset
+STORAGE_ALIGN_MASK
,
1026 DEBUGF("%s(): failed to add handle\n", __func__
);
1028 return ERR_BUFFER_FULL
;
1031 strlcpy(h
->path
, file
, MAX_PATH
);
1032 h
->offset
= adjusted_offset
;
1034 /* Don't bother to storage align bitmaps because they are not
1035 * loaded directly into the buffer.
1037 if (type
!= TYPE_BITMAP
)
1039 size_t alignment_pad
;
1041 /* Remember where data area starts, for use by reset_handle */
1042 h
->start
= buf_widx
;
1044 /* Align to desired storage alignment */
1045 alignment_pad
= (adjusted_offset
- (size_t)(&buffer
[buf_widx
]))
1046 & STORAGE_ALIGN_MASK
;
1047 buf_widx
= ringbuf_add(buf_widx
, alignment_pad
);
1057 #ifdef HAVE_ALBUMART
1058 if (type
== TYPE_BITMAP
)
1060 /* Bitmap file: we load the data instead of the file */
1062 mutex_lock(&llist_mod_mutex
); /* Lock because load_bitmap yields */
1063 rc
= load_image(fd
, file
, (struct dim
*)user_data
);
1064 mutex_unlock(&llist_mod_mutex
);
1069 return ERR_FILE_ERROR
;
1074 h
->widx
= buf_widx
+ rc
; /* safe because the data doesn't wrap */
1075 buf_widx
+= rc
; /* safe too */
1080 h
->filerem
= size
- adjusted_offset
;
1086 if (type
== TYPE_CUESHEET
) {
1088 /* Immediately start buffering those */
1089 LOGFQUEUE("buffering >| Q_BUFFER_HANDLE %d", h
->id
);
1090 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, h
->id
);
1092 /* Other types will get buffered in the course of normal operations */
1096 /* Inform the buffering thread that we added a handle */
1097 LOGFQUEUE("buffering > Q_HANDLE_ADDED %d", h
->id
);
1098 queue_post(&buffering_queue
, Q_HANDLE_ADDED
, h
->id
);
1101 logf("bufopen: new hdl %d", h
->id
);
1105 /* Open a new handle from data that needs to be copied from memory.
1106 src is the source buffer from which to copy data. It can be NULL to simply
1107 reserve buffer space.
1108 size is the requested size. The call will only be successful if the
1109 requested amount of data can entirely fit in the buffer without wrapping.
1110 Return value is the handle id for success or <0 for failure.
1112 int bufalloc(const void *src
, size_t size
, enum data_type type
)
1114 struct memory_handle
*h
= add_handle(size
, false, true);
1117 return ERR_BUFFER_FULL
;
1120 if (type
== TYPE_ID3
&& size
== sizeof(struct mp3entry
)) {
1121 /* specially take care of struct mp3entry */
1122 copy_mp3entry((struct mp3entry
*)&buffer
[buf_widx
],
1123 (const struct mp3entry
*)src
);
1125 memcpy(&buffer
[buf_widx
], src
, size
);
1135 h
->widx
= buf_widx
+ size
; /* this is safe because the data doesn't wrap */
1137 h
->available
= size
;
1140 buf_widx
+= size
; /* safe too */
1142 logf("bufalloc: new hdl %d", h
->id
);
1146 /* Close the handle. Return true for success and false for failure */
1147 bool bufclose(int handle_id
)
1149 logf("bufclose(%d)", handle_id
);
1151 LOGFQUEUE("buffering >| Q_CLOSE_HANDLE %d", handle_id
);
1152 return queue_send(&buffering_queue
, Q_CLOSE_HANDLE
, handle_id
);
1155 /* Set reading index in handle (relatively to the start of the file).
1156 Access before the available data will trigger a rebuffer.
1157 Return 0 for success and < 0 for failure:
1158 -1 if the handle wasn't found
1159 -2 if the new requested position was beyond the end of the file
1161 int bufseek(int handle_id
, size_t newpos
)
1163 struct memory_handle
*h
= find_handle(handle_id
);
1165 return ERR_HANDLE_NOT_FOUND
;
1167 if (newpos
> h
->filesize
) {
1168 /* access beyond the end of the file */
1169 return ERR_INVALID_VALUE
;
1171 else if (newpos
< h
->offset
|| h
->offset
+ h
->available
< newpos
) {
1172 /* access before or after buffered data. A rebuffer is needed. */
1173 rebuffer_handle(handle_id
, newpos
);
1176 h
->ridx
= ringbuf_add(h
->data
, newpos
- h
->offset
);
1181 /* Advance the reading index in a handle (relatively to its current position).
1182 Return 0 for success and < 0 for failure */
1183 int bufadvance(int handle_id
, off_t offset
)
1185 const struct memory_handle
*h
= find_handle(handle_id
);
1187 return ERR_HANDLE_NOT_FOUND
;
1189 size_t newpos
= h
->offset
+ ringbuf_sub(h
->ridx
, h
->data
) + offset
;
1190 return bufseek(handle_id
, newpos
);
1193 /* Used by bufread and bufgetdata to prepare the buffer and retrieve the
1194 * actual amount of data available for reading. This function explicitly
1195 * does not check the validity of the input handle. It does do range checks
1196 * on size and returns a valid (and explicit) amount of data for reading */
1197 static struct memory_handle
*prep_bufdata(int handle_id
, size_t *size
,
1198 bool guardbuf_limit
)
1200 struct memory_handle
*h
= find_handle(handle_id
);
1204 size_t avail
= ringbuf_sub(h
->widx
, h
->ridx
);
1206 if (avail
== 0 && h
->filerem
== 0)
1208 /* File is finished reading */
1213 if (*size
== 0 || *size
> avail
+ h
->filerem
)
1214 *size
= avail
+ h
->filerem
;
1216 if (guardbuf_limit
&& h
->type
== TYPE_PACKET_AUDIO
&& *size
> GUARD_BUFSIZE
)
1218 logf("data request > guardbuf");
1219 /* If more than the size of the guardbuf is requested and this is a
1220 * bufgetdata, limit to guard_bufsize over the end of the buffer */
1221 *size
= MIN(*size
, buffer_len
- h
->ridx
+ GUARD_BUFSIZE
);
1222 /* this ensures *size <= buffer_len - h->ridx + GUARD_BUFSIZE */
1225 if (h
->filerem
> 0 && avail
< *size
)
1227 /* Data isn't ready. Request buffering */
1228 buf_request_buffer_handle(handle_id
);
1229 /* Wait for the data to be ready */
1233 /* it is not safe for a non-buffering thread to sleep while
1234 * holding a handle */
1235 h
= find_handle(handle_id
);
1238 avail
= ringbuf_sub(h
->widx
, h
->ridx
);
1240 while (h
->filerem
> 0 && avail
< *size
);
1243 *size
= MIN(*size
,avail
);
1247 /* Copy data from the given handle to the dest buffer.
1248 Return the number of bytes copied or < 0 for failure (handle not found).
1249 The caller is blocked until the requested amount of data is available.
1251 ssize_t
bufread(int handle_id
, size_t size
, void *dest
)
1253 const struct memory_handle
*h
;
1254 size_t adjusted_size
= size
;
1256 h
= prep_bufdata(handle_id
, &adjusted_size
, false);
1258 return ERR_HANDLE_NOT_FOUND
;
1260 if (h
->ridx
+ adjusted_size
> buffer_len
)
1262 /* the data wraps around the end of the buffer */
1263 size_t read
= buffer_len
- h
->ridx
;
1264 memcpy(dest
, &buffer
[h
->ridx
], read
);
1265 memcpy(dest
+read
, buffer
, adjusted_size
- read
);
1269 memcpy(dest
, &buffer
[h
->ridx
], adjusted_size
);
1272 return adjusted_size
;
1275 /* Update the "data" pointer to make the handle's data available to the caller.
1276 Return the length of the available linear data or < 0 for failure (handle
1278 The caller is blocked until the requested amount of data is available.
1279 size is the amount of linear data requested. it can be 0 to get as
1281 The guard buffer may be used to provide the requested size. This means it's
1282 unsafe to request more than the size of the guard buffer.
1284 ssize_t
bufgetdata(int handle_id
, size_t size
, void **data
)
1286 const struct memory_handle
*h
;
1287 size_t adjusted_size
= size
;
1289 h
= prep_bufdata(handle_id
, &adjusted_size
, true);
1291 return ERR_HANDLE_NOT_FOUND
;
1293 if (h
->ridx
+ adjusted_size
> buffer_len
)
1295 /* the data wraps around the end of the buffer :
1296 use the guard buffer to provide the requested amount of data. */
1297 size_t copy_n
= h
->ridx
+ adjusted_size
- buffer_len
;
1298 /* prep_bufdata ensures adjusted_size <= buffer_len - h->ridx + GUARD_BUFSIZE,
1299 so copy_n <= GUARD_BUFSIZE */
1300 memcpy(guard_buffer
, (const unsigned char *)buffer
, copy_n
);
1304 *data
= &buffer
[h
->ridx
];
1306 return adjusted_size
;
1309 ssize_t
bufgettail(int handle_id
, size_t size
, void **data
)
1313 const struct memory_handle
*h
;
1315 h
= find_handle(handle_id
);
1318 return ERR_HANDLE_NOT_FOUND
;
1321 return ERR_HANDLE_NOT_DONE
;
1323 /* We don't support tail requests of > guardbuf_size, for simplicity */
1324 if (size
> GUARD_BUFSIZE
)
1325 return ERR_INVALID_VALUE
;
1327 tidx
= ringbuf_sub(h
->widx
, size
);
1329 if (tidx
+ size
> buffer_len
)
1331 size_t copy_n
= tidx
+ size
- buffer_len
;
1332 memcpy(guard_buffer
, (const unsigned char *)buffer
, copy_n
);
1335 *data
= &buffer
[tidx
];
1339 ssize_t
bufcuttail(int handle_id
, size_t size
)
1341 struct memory_handle
*h
;
1342 size_t adjusted_size
= size
;
1344 h
= find_handle(handle_id
);
1347 return ERR_HANDLE_NOT_FOUND
;
1350 return ERR_HANDLE_NOT_DONE
;
1352 if (h
->available
< adjusted_size
)
1353 adjusted_size
= h
->available
;
1355 h
->available
-= adjusted_size
;
1356 h
->filesize
-= adjusted_size
;
1357 h
->widx
= ringbuf_sub(h
->widx
, adjusted_size
);
1358 if (h
== cur_handle
)
1361 return adjusted_size
;
1366 SECONDARY EXPORTED FUNCTIONS
1367 ============================
1371 buf_request_buffer_handle
1374 register_buffering_callback
1375 unregister_buffering_callback
1377 These functions are exported, to allow interaction with the buffer.
1378 They take care of the content of the structs, and rely on the linked list
1379 management functions for all the actual handle management work.
1382 /* Get a handle offset from a pointer */
1383 ssize_t
buf_get_offset(int handle_id
, void *ptr
)
1385 const struct memory_handle
*h
= find_handle(handle_id
);
1387 return ERR_HANDLE_NOT_FOUND
;
1389 return (size_t)ptr
- (size_t)&buffer
[h
->ridx
];
1392 ssize_t
buf_handle_offset(int handle_id
)
1394 const struct memory_handle
*h
= find_handle(handle_id
);
1396 return ERR_HANDLE_NOT_FOUND
;
1400 void buf_request_buffer_handle(int handle_id
)
1402 LOGFQUEUE("buffering >| Q_START_FILL %d",handle_id
);
1403 queue_send(&buffering_queue
, Q_START_FILL
, handle_id
);
1406 void buf_set_base_handle(int handle_id
)
1408 LOGFQUEUE("buffering > Q_BASE_HANDLE %d", handle_id
);
1409 queue_post(&buffering_queue
, Q_BASE_HANDLE
, handle_id
);
1412 /* Return the amount of buffer space used */
1413 size_t buf_used(void)
1418 void buf_set_watermark(size_t bytes
)
1420 conf_watermark
= bytes
;
1423 static void shrink_buffer_inner(struct memory_handle
*h
)
1428 shrink_buffer_inner(h
->next
);
1433 static void shrink_buffer(void)
1435 logf("shrink_buffer()");
1436 shrink_buffer_inner(first_handle
);
1439 void buffering_thread(void)
1441 bool filling
= false;
1442 struct queue_event ev
;
1450 queue_wait_w_tmo(&buffering_queue
, &ev
, filling
? 5 : HZ
/2);
1455 LOGFQUEUE("buffering < Q_START_FILL %d", (int)ev
.data
);
1456 /* Call buffer callbacks here because this is one of two ways
1457 * to begin a full buffer fill */
1458 send_event(BUFFER_EVENT_BUFFER_LOW
, 0);
1460 queue_reply(&buffering_queue
, 1);
1461 filling
|= buffer_handle((int)ev
.data
);
1464 case Q_BUFFER_HANDLE
:
1465 LOGFQUEUE("buffering < Q_BUFFER_HANDLE %d", (int)ev
.data
);
1466 queue_reply(&buffering_queue
, 1);
1467 buffer_handle((int)ev
.data
);
1470 case Q_RESET_HANDLE
:
1471 LOGFQUEUE("buffering < Q_RESET_HANDLE %d", (int)ev
.data
);
1472 queue_reply(&buffering_queue
, 1);
1473 reset_handle((int)ev
.data
);
1476 case Q_CLOSE_HANDLE
:
1477 LOGFQUEUE("buffering < Q_CLOSE_HANDLE %d", (int)ev
.data
);
1478 queue_reply(&buffering_queue
, close_handle((int)ev
.data
));
1481 case Q_HANDLE_ADDED
:
1482 LOGFQUEUE("buffering < Q_HANDLE_ADDED %d", (int)ev
.data
);
1483 /* A handle was added: the disk is spinning, so we can fill */
1488 LOGFQUEUE("buffering < Q_BASE_HANDLE %d", (int)ev
.data
);
1489 base_handle_id
= (int)ev
.data
;
1493 case SYS_USB_CONNECTED
:
1494 LOGFQUEUE("buffering < SYS_USB_CONNECTED");
1495 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1496 usb_wait_for_disconnect(&buffering_queue
);
1501 LOGFQUEUE_SYS_TIMEOUT("buffering < SYS_TIMEOUT");
1505 update_data_counters();
1507 /* If the buffer is low, call the callbacks to get new data */
1508 if (num_handles
> 0 && data_counters
.useful
<= conf_watermark
)
1509 send_event(BUFFER_EVENT_BUFFER_LOW
, 0);
1512 /* TODO: This needs to be fixed to use the idle callback, disable it
1513 * for simplicity until its done right */
1515 /* If the disk is spinning, take advantage by filling the buffer */
1516 else if (storage_disk_is_active() && queue_empty(&buffering_queue
))
1518 if (num_handles
> 0 && data_counters
.useful
<= high_watermark
)
1519 send_event(BUFFER_EVENT_BUFFER_LOW
, 0);
1521 if (data_counters
.remaining
> 0 && BUF_USED
<= high_watermark
)
1523 /* This is a new fill, shrink the buffer up first */
1526 filling
= fill_buffer();
1527 update_data_counters();
1533 if (queue_empty(&buffering_queue
)) {
1535 if (data_counters
.remaining
> 0 && BUF_USED
< buffer_len
)
1536 filling
= fill_buffer();
1537 else if (data_counters
.remaining
== 0)
1540 else if (ev
.id
== SYS_TIMEOUT
)
1542 if (data_counters
.remaining
> 0 &&
1543 data_counters
.useful
<= conf_watermark
) {
1545 filling
= fill_buffer();
1552 void buffering_init(void)
1554 mutex_init(&llist_mutex
);
1555 mutex_init(&llist_mod_mutex
);
1556 #ifdef HAVE_PRIORITY_SCHEDULING
1557 /* This behavior not safe atm */
1558 mutex_set_preempt(&llist_mutex
, false);
1559 mutex_set_preempt(&llist_mod_mutex
, false);
1562 conf_watermark
= BUFFERING_DEFAULT_WATERMARK
;
1564 queue_init(&buffering_queue
, true);
1565 buffering_thread_id
= create_thread( buffering_thread
, buffering_stack
,
1566 sizeof(buffering_stack
), CREATE_THREAD_FROZEN
,
1567 buffering_thread_name
IF_PRIO(, PRIORITY_BUFFERING
)
1570 queue_enable_queue_send(&buffering_queue
, &buffering_queue_sender_list
,
1571 buffering_thread_id
);
1574 /* Initialise the buffering subsystem */
1575 bool buffering_reset(char *buf
, size_t buflen
)
1577 if (!buf
|| !buflen
)
1581 /* Preserve alignment when wrapping around */
1582 buffer_len
= buflen
& ~STORAGE_ALIGN_MASK
;
1583 guard_buffer
= buf
+ buflen
;
1588 first_handle
= NULL
;
1590 cached_handle
= NULL
;
1592 base_handle_id
= -1;
1594 /* Set the high watermark as 75% full...or 25% empty :) */
1596 high_watermark
= 3*buflen
/ 4;
1599 thread_thaw(buffering_thread_id
);
1604 void buffering_get_debugdata(struct buffering_debug
*dbgdata
)
1606 update_data_counters();
1607 dbgdata
->num_handles
= num_handles
;
1608 dbgdata
->data_rem
= data_counters
.remaining
;
1609 dbgdata
->wasted_space
= data_counters
.wasted
;
1610 dbgdata
->buffered_data
= data_counters
.buffered
;
1611 dbgdata
->useful_data
= data_counters
.useful
;
1612 dbgdata
->watermark
= conf_watermark
;