1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2007 Nicolas Pennequin
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
25 #include "buffering.h"
44 #include "mp3_playback.h"
52 #include "ata_idle_notify.h"
55 #define ata_disk_is_active() 1
59 #define GUARD_BUFSIZE (32*1024)
61 #define GUARD_BUFSIZE (8*1024)
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(...)
87 /* amount of data to read in one read() call */
88 #define AUDIO_DEFAULT_FILECHUNK (1024*32)
90 /* Ring buffer helper macros */
91 /* Buffer pointer (p) plus value (v), wrapped if necessary */
92 #define RINGBUF_ADD(p,v) ((p+v)<buffer_len ? p+v : p+v-buffer_len)
93 /* Buffer pointer (p) minus value (v), wrapped if necessary */
94 #define RINGBUF_SUB(p,v) ((p>=v) ? p-v : p+buffer_len-v)
95 /* How far value (v) plus buffer pointer (p1) will cross buffer pointer (p2) */
96 #define RINGBUF_ADD_CROSS(p1,v,p2) \
97 ((p1<p2) ? (int)(p1+v)-(int)p2 : (int)(p1+v-p2)-(int)buffer_len)
98 /* Bytes available in the buffer */
99 #define BUF_USED RINGBUF_SUB(buf_widx, buf_ridx)
101 struct memory_handle
{
102 int id
; /* A unique ID for the handle */
106 size_t data
; /* Start index of the handle's data buffer */
107 size_t ridx
; /* Current read pointer, relative to the main buffer */
108 size_t widx
; /* Current write pointer */
109 size_t filesize
; /* File total length */
110 size_t filerem
; /* Remaining bytes of file NOT in buffer */
111 size_t available
; /* Available bytes to read from buffer */
112 size_t offset
; /* Offset at which we started reading the file */
113 struct memory_handle
*next
;
115 /* at all times, we have: filesize == offset + available + filerem */
119 static char *guard_buffer
;
121 static size_t buffer_len
;
123 static size_t buf_widx
; /* current writing position */
124 static size_t buf_ridx
; /* current reading position */
125 /* buf_*idx are values relative to the buffer, not real pointers. */
127 static size_t conf_filechunk
= 0;
128 static size_t conf_watermark
= 0; /* Level to trigger filebuf fill */
130 static size_t high_watermark
= 0; /* High watermark for rebuffer */
134 /* current memory handle in the linked list. NULL when the list is empty. */
135 static struct memory_handle
*cur_handle
;
136 /* first memory handle in the linked list. NULL when the list is empty. */
137 static struct memory_handle
*first_handle
;
139 static int num_handles
; /* number of handles in the list */
141 static struct mutex llist_mutex
;
143 /* Handle cache (makes find_handle faster).
144 These need to be global so that move_handle can invalidate them. */
145 static int cached_handle_id
= -1;
146 static struct memory_handle
*cached_handle
= NULL
;
149 /* Messages available to communicate with the buffering thread */
151 Q_BUFFER_HANDLE
= 1, /* Request buffering of a handle */
152 Q_RESET_HANDLE
, /* (internal) Request resetting of a handle to its
153 offset (the offset has to be set beforehand) */
155 Q_BUFFERING_FILL_BUFFER_IF_ACTIVE_ATA
,
158 /* Buffering thread */
159 void buffering_thread(void);
160 static long buffering_stack
[(DEFAULT_STACK_SIZE
+ 0x2000)/sizeof(long)];
161 static const char buffering_thread_name
[] = "buffering";
162 struct thread_entry
*buffering_thread_p
;
163 struct event_queue buffering_queue
;
164 struct queue_sender_list buffering_queue_sender_list
;
168 LINKED LIST MANAGEMENT
169 ======================
171 add_handle : Add a handle to the list
172 rm_handle : Remove a handle from the list
173 find_handle : Get a handle pointer from an ID
174 move_handle : Move a handle in the buffer (with or without its data)
176 These functions only handle the linked list structure. They don't touch the
177 contents of the struct memory_handle headers. They also change the buf_*idx
178 pointers when necessary and manage the handle IDs.
180 The first and current (== last) handle are kept track of.
181 A new handle is added at buf_widx and becomes the current one.
182 buf_widx always points to the current writing position for the current handle
183 buf_ridx always points to the location of the first handle.
184 buf_ridx == buf_widx means the buffer is empty.
188 /* Add a new handle to the linked list and return it. It will have become the
189 new current handle. The handle will reserve "data_size" bytes or if that's
190 not possible, decrease "data_size" to allow adding the handle. */
191 static struct memory_handle
*add_handle(size_t *data_size
)
193 mutex_lock(&llist_mutex
);
195 /* this will give each handle a unique id */
196 static int cur_handle_id
= 1;
198 /* make sure buf_widx is 32-bit aligned so that the handle struct is,
199 but before that we check we can actually align. */
200 if (RINGBUF_ADD_CROSS(buf_widx
, 3, buf_ridx
) >= 0) {
201 mutex_unlock(&llist_mutex
);
204 buf_widx
= (RINGBUF_ADD(buf_widx
, 3)) & ~3;
206 size_t len
= (data_size
? *data_size
: 0)
207 + sizeof(struct memory_handle
);
209 /* check that we actually can add the handle and its data */
210 int overlap
= RINGBUF_ADD_CROSS(buf_widx
, len
, buf_ridx
);
212 *data_size
-= overlap
;
215 if (len
< sizeof(struct memory_handle
)) {
216 /* There isn't even enough space to write the struct */
217 mutex_unlock(&llist_mutex
);
221 struct memory_handle
*new_handle
=
222 (struct memory_handle
*)(&buffer
[buf_widx
]);
224 /* only advance the buffer write index of the size of the struct */
225 buf_widx
= RINGBUF_ADD(buf_widx
, sizeof(struct memory_handle
));
228 /* the new handle is the first one */
229 first_handle
= new_handle
;
233 cur_handle
->next
= new_handle
;
236 cur_handle
= new_handle
;
237 cur_handle
->id
= cur_handle_id
++;
238 cur_handle
->next
= NULL
;
241 mutex_unlock(&llist_mutex
);
245 /* Delete a given memory handle from the linked list
246 and return true for success. Nothing is actually erased from memory. */
247 static bool rm_handle(struct memory_handle
*h
)
249 mutex_lock(&llist_mutex
);
251 if (h
== first_handle
) {
252 first_handle
= h
->next
;
253 if (h
== cur_handle
) {
254 /* h was the first and last handle: the buffer is now empty */
258 /* update buf_ridx to point to the new first handle */
259 buf_ridx
= (void *)first_handle
- (void *)buffer
;
262 struct memory_handle
*m
= first_handle
;
263 while (m
&& m
->next
!= h
) {
266 if (h
&& m
&& m
->next
== h
) {
268 if (h
== cur_handle
) {
270 buf_widx
= cur_handle
->widx
;
273 mutex_unlock(&llist_mutex
);
278 /* Invalidate the cache to prevent it from keeping the old location of h */
279 if (h
== cached_handle
)
280 cached_handle
= NULL
;
284 mutex_unlock(&llist_mutex
);
288 /* Return a pointer to the memory handle of given ID.
289 NULL if the handle wasn't found */
290 static struct memory_handle
*find_handle(int handle_id
)
292 mutex_lock(&llist_mutex
);
294 /* simple caching because most of the time the requested handle
295 will either be the same as the last, or the one after the last */
298 if (cached_handle_id
== handle_id
&&
299 cached_handle_id
== cached_handle
->id
) {
300 mutex_unlock(&llist_mutex
);
301 return cached_handle
;
302 } else if (cached_handle
->next
&&
303 (cached_handle
->next
->id
== handle_id
)) {
304 cached_handle
= cached_handle
->next
;
305 cached_handle_id
= handle_id
;
306 mutex_unlock(&llist_mutex
);
307 return cached_handle
;
311 struct memory_handle
*m
= first_handle
;
312 while (m
&& m
->id
!= handle_id
) {
315 cached_handle_id
= handle_id
;
317 struct memory_handle
*ret
= (m
&& m
->id
== handle_id
) ? m
: NULL
;
319 mutex_unlock(&llist_mutex
);
323 /* Move a memory handle and data_size of its data of delta.
324 Return a pointer to the new location of the handle.
325 delta is the value of which to move the struct data.
326 data_size is the amount of data to move along with the struct. */
327 static struct memory_handle
*move_handle(struct memory_handle
*h
,
328 size_t *delta
, size_t data_size
)
330 mutex_lock(&llist_mutex
);
333 /* aligning backwards would yield a negative result,
334 and moving the handle of such a small amount is a waste
336 mutex_unlock(&llist_mutex
);
339 /* make sure delta is 32-bit aligned so that the handle struct is. */
340 *delta
= (*delta
- 3) & ~3;
342 size_t newpos
= RINGBUF_ADD((void *)h
- (void *)buffer
, *delta
);
344 struct memory_handle
*dest
= (struct memory_handle
*)(&buffer
[newpos
]);
346 /* Invalidate the cache to prevent it from keeping the old location of h */
347 if (h
== cached_handle
)
348 cached_handle
= NULL
;
350 /* the cur_handle pointer might need updating */
351 if (h
== cur_handle
) {
355 if (h
== first_handle
) {
359 struct memory_handle
*m
= first_handle
;
360 while (m
&& m
->next
!= h
) {
363 if (h
&& m
&& m
->next
== h
) {
366 mutex_unlock(&llist_mutex
);
371 memmove(dest
, h
, sizeof(struct memory_handle
) + data_size
);
373 mutex_unlock(&llist_mutex
);
379 BUFFER SPACE MANAGEMENT
380 =======================
382 yield_codec : Used by buffer_handle to know if it should interrupt buffering
383 buffer_handle : Buffer data for a handle
384 reset_handle : Reset writing position and data buffer of a handle to its
386 rebuffer_handle : Seek to a nonbuffered part of a handle by rebuffering the data
387 shrink_handle : Free buffer space by moving a handle
388 fill_buffer : Call buffer_handle for all handles that have data to buffer
389 can_add_handle : Indicate whether it's safe to add a handle
390 data_rem : Total amount of data needing to be buffered
391 wasted_space : Total amount of space available for freeing
392 buffered_data : Total amount of data currently in the buffer
394 These functions are used by the buffering thread to manage buffer space.
397 static bool filebuf_is_lowdata(void)
399 return BUF_USED
< AUDIO_FILEBUF_CRITICAL
;
402 /* Yield to the codec thread for as long as possible if it is in need of data.
403 Return true if the caller should break to let the buffering thread process
405 static bool yield_codec(void)
409 if (!queue_empty(&buffering_queue
))
412 while (pcmbuf_is_lowdata() && !filebuf_is_lowdata())
416 if (!queue_empty(&buffering_queue
))
423 /* Buffer data for the given handle. Return the amount of data buffered
424 or -1 if the handle wasn't found */
425 static ssize_t
buffer_handle(int handle_id
)
427 DEBUGF("buffer_handle(%d)\n", handle_id
);
428 struct memory_handle
*h
= find_handle(handle_id
);
432 if (h
->filerem
== 0) {
433 /* nothing left to buffer */
437 if (h
->fd
< 0) /* file closed, reopen */
440 h
->fd
= open(h
->path
, O_RDONLY
);
448 lseek(h
->fd
, h
->offset
, SEEK_SET
);
455 while (h
->filerem
> 0)
457 /* max amount to copy */
458 size_t copy_n
= MIN( MIN(h
->filerem
, conf_filechunk
),
459 buffer_len
- h
->widx
);
461 /* stop copying if it would overwrite the reading position
462 or the next handle */
463 if (RINGBUF_ADD_CROSS(h
->widx
, copy_n
, buf_ridx
) >= 0 || (h
->next
&&
464 RINGBUF_ADD_CROSS(h
->widx
, copy_n
, (unsigned)
465 ((void *)h
->next
- (void *)buffer
)) > 0))
468 /* rc is the actual amount read */
469 int rc
= read(h
->fd
, &buffer
[h
->widx
], copy_n
);
473 if (h
->type
== TYPE_CODEC
) {
474 DEBUGF("Partial codec\n");
478 DEBUGF("File ended %ld bytes early\n", (long)h
->filerem
);
479 h
->filesize
-= h
->filerem
;
485 h
->widx
= RINGBUF_ADD(h
->widx
, rc
);
492 /* DEBUGF("buffer_handle(%d): buffered %ld bytes. done: %ld. remaining: %ld.\n",
493 h->id, rc, h->available, h->filerem); */
495 /* Stop buffering if new queue events have arrived */
500 if (h
->filerem
== 0) {
501 /* finished buffering the file */
506 DEBUGF("buffer_handle(%d): buffered %ld bytes (%ld of %ld available, "
507 "rem: %ld, off: %ld)\n",
508 handle_id
, (long)ret
, (long)h
->available
, (long)h
->filesize
,
509 (long)h
->filerem
, (long)h
->offset
);
515 void request_buffer_handle(int handle_id
)
517 LOGFQUEUE("buffering >| buffering Q_BUFFER_HANDLE");
518 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, handle_id
);
521 /* Reset writing position and data buffer of a handle to its current offset.
522 Use this after having set the new offset to use.
523 Returns 0 for success or -1 if the handle wasn't found. */
524 static void reset_handle(int handle_id
)
526 DEBUGF("reset_handle(%d)\n", handle_id
);
528 struct memory_handle
*h
= find_handle(handle_id
);
536 h
->filerem
= h
->filesize
- h
->offset
;
539 lseek(h
->fd
, h
->offset
, SEEK_SET
);
543 /* Seek to a nonbuffered part of a handle by rebuffering the data. */
544 static void rebuffer_handle(int handle_id
, size_t newpos
)
546 struct memory_handle
*h
= find_handle(handle_id
);
550 DEBUGF("rebuffer_handle: resetting the handle to offset %ld\n", (long)newpos
);
553 LOGFQUEUE("? >| buffering Q_RESET_HANDLE");
554 queue_send(&buffering_queue
, Q_RESET_HANDLE
, handle_id
);
556 LOGFQUEUE("? >| buffering Q_BUFFER_HANDLE");
557 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, handle_id
);
562 static int close_handle(int handle_id
)
564 struct memory_handle
*h
= find_handle(handle_id
);
577 /* Free buffer space by moving the handle struct right before the useful
578 part of its data buffer or by moving all the data. */
579 static void shrink_handle(int handle_id
)
581 struct memory_handle
*h
= find_handle(handle_id
);
586 /* The value of delta might change for alignment reasons */
588 if (h
->next
&& (h
->type
== TYPE_ID3
|| h
->type
== TYPE_CUESHEET
||
589 h
->type
== TYPE_IMAGE
) && h
->filerem
== 0 )
591 /* metadata handle: we can move all of it */
592 delta
= RINGBUF_SUB( (unsigned)((void *)h
->next
- (void *)buffer
),
593 h
->data
) - h
->available
;
594 h
= move_handle(h
, &delta
, h
->available
);
596 h
->data
= RINGBUF_ADD(h
->data
, delta
);
597 h
->ridx
= RINGBUF_ADD(h
->ridx
, delta
);
598 h
->widx
= RINGBUF_ADD(h
->widx
, delta
);
600 /* when moving a struct mp3entry we need to readjust its pointers. */
601 if (h
->type
== TYPE_ID3
&& h
->filesize
== sizeof(struct mp3entry
)) {
602 adjust_mp3entry((struct mp3entry
*)&buffer
[h
->data
],
603 (void *)&buffer
[h
->data
],
604 (void *)&buffer
[RINGBUF_SUB(h
->data
, delta
)]);
607 DEBUGF("shrink_handle(%d): metadata, moved by %ld bytes\n",
608 handle_id
, (long)delta
);
612 /* only move the handle struct */
613 delta
= RINGBUF_SUB(h
->ridx
, h
->data
);
614 h
= move_handle(h
, &delta
, 0);
616 h
->data
= RINGBUF_ADD(h
->data
, delta
);
617 h
->available
-= delta
;
619 DEBUGF("shrink_handle(%d): audio, %ld bytes freed\n",
620 handle_id
, (long)delta
);
624 /* Fill the buffer by buffering as much data as possible for handles that still
625 have data left to buffer */
626 static void fill_buffer(void)
628 DEBUGF("fill_buffer()\n");
629 struct memory_handle
*m
= first_handle
;
630 while (queue_empty(&buffering_queue
) && m
) {
631 if (m
->filerem
> 0) {
632 buffer_handle(m
->id
);
638 if (queue_empty(&buffering_queue
)) {
639 /* only spin the disk down if the filling wasn't interrupted by an
640 event arriving in the queue. */
646 /* Check whether it's safe to add a new handle and reserve space to let the
647 current one finish buffering its data. Used by bufopen and bufalloc as
648 a preliminary check before even trying to physically add the handle.
649 Returns true if it's ok to add a new handle, false if not.
651 static bool can_add_handle(void)
653 if (cur_handle
&& cur_handle
->filerem
> 0) {
654 /* the current handle hasn't finished buffering. We can only add
655 a new one if there is already enough free space to finish
657 if (cur_handle
->filerem
< (buffer_len
- BUF_USED
)) {
658 /* Before adding the new handle we reserve some space for the
659 current one to finish buffering its data. */
660 buf_widx
= RINGBUF_ADD(buf_widx
, cur_handle
->filerem
);
669 /* Return the total amount of data left to be buffered for all the handles */
670 static size_t data_rem(void)
674 struct memory_handle
*m
= first_handle
;
683 /* Return the amount of data we have but don't need anymore. This data can be
684 safely erased to reclaim buffer space. */
685 static size_t wasted_space(void)
689 struct memory_handle
*m
= first_handle
;
691 ret
+= RINGBUF_SUB(m
->ridx
, m
->data
);
698 static size_t buffered_data(void)
701 struct memory_handle
*m
= first_handle
;
709 size_t useful_data(int start_handle_id
)
711 /* use a static var to remember which handle to start with when the caller
712 doesn't have access to the playback data. */
713 static int start_id
= 0;
714 if (start_handle_id
> 0)
715 start_id
= start_handle_id
;
718 struct memory_handle
*m
= first_handle
;
720 if (m
->id
>= start_id
)
721 ret
+= m
->available
- RINGBUF_SUB(m
->ridx
, m
->data
);
727 ssize_t
handleoffset(int handle_id
)
729 struct memory_handle
*h
= find_handle(handle_id
);
737 BUFFERING API FUNCTIONS
738 =======================
740 bufopen : Request the opening of a new handle for a file
741 bufalloc : Open a new handle for data other than a file.
742 bufclose : Close an open handle
743 bufseek : Set the read pointer in a handle
744 bufadvance : Move the read pointer in a handle
745 bufread : Copy data from a handle into a given buffer
746 bufgetdata : Give a pointer to the handle's data
747 bufused : Return the amount of buffer space used
749 These functions are exported, to allow interaction with the buffer.
750 They take care of the content of the structs, and rely on the linked list
751 management functions for all the actual handle management work.
755 /* Reserve space in the buffer for a file.
756 filename: name of the file to open
757 offset: offset at which to start buffering the file, useful when the first
758 (offset-1) bytes of the file aren't needed.
759 return value: <0 if the file cannot be opened, or one file already
760 queued to be opened, otherwise the handle for the file in the buffer
762 int bufopen(char *file
, size_t offset
, enum data_type type
)
764 if (!can_add_handle())
767 int fd
= open(file
, O_RDONLY
);
771 size_t size
= filesize(fd
) - offset
;
773 if (type
!= TYPE_AUDIO
&&
774 size
+ sizeof(struct memory_handle
) > buffer_len
- buf_widx
)
776 /* for types other than audio, the data can't wrap, so we force it */
780 DEBUGF("bufopen: %s (offset: %ld) (%ld bytes needed)...\n",
781 file
, (long)offset
, (long)size
);
783 struct memory_handle
*h
= add_handle(&size
);
786 DEBUGF("bufopen: failed to add handle\n");
791 strncpy(h
->path
, file
, MAX_PATH
);
793 h
->filesize
= filesize(fd
);
794 h
->filerem
= h
->filesize
- offset
;
804 DEBUGF("bufopen: allocated %ld bytes. ID: %d\n", (long)size
, h
->id
);
806 if (type
== TYPE_CODEC
|| type
== TYPE_CUESHEET
|| type
== TYPE_IMAGE
) {
807 /* Immediately buffer those */
808 LOGFQUEUE("? >| buffering Q_BUFFER_HANDLE");
809 queue_send(&buffering_queue
, Q_BUFFER_HANDLE
, h
->id
);
812 DEBUGF("bufopen: opened handle %d\n", h
->id
);
816 /* Open a new handle from data that needs to be copied from memory.
817 src is the source buffer from which to copy data. It can be NULL to simply
818 reserve buffer space.
819 size is the requested size. The call will only be successful if the
820 requested amount of data can entirely fit in the buffer without wrapping.
821 Return value is the handle id for success or <0 for failure.
823 int bufalloc(void *src
, size_t size
, enum data_type type
)
825 if (!can_add_handle())
828 if (size
+ sizeof(struct memory_handle
) > buffer_len
- buf_widx
) {
829 /* The data would need to wrap. */
830 DEBUGF("bufalloc: data wrap\n");
834 size_t allocsize
= size
;
835 struct memory_handle
*h
= add_handle(&allocsize
);
837 if (!h
|| allocsize
!= size
)
841 if (type
== TYPE_ID3
&& size
== sizeof(struct mp3entry
)) {
842 DEBUGF("bufalloc: allocating metadata\n");
843 /* specially take care of struct mp3entry */
844 copy_mp3entry((struct mp3entry
*)&buffer
[buf_widx
],
845 (struct mp3entry
*)src
);
847 memcpy(&buffer
[buf_widx
], src
, size
);
862 buf_widx
= RINGBUF_ADD(buf_widx
, size
);
864 DEBUGF("bufalloc: opened handle %d\n", h
->id
);
868 /* Close the handle. Return 0 for success and < 0 for failure */
869 int bufclose(int handle_id
)
871 DEBUGF("bufclose(%d)\n", handle_id
);
873 LOGFQUEUE("buffering >| Q_CLOSE_HANDLE");
874 return queue_send(&buffering_queue
, Q_CLOSE_HANDLE
, handle_id
);
877 /* Set reading index in handle (relatively to the start of the file).
878 Access before the available data will trigger a rebuffer.
879 Return 0 for success and < 0 for failure:
880 -1 if the handle wasn't found
881 -2 if the new requested position was beyond the end of the file
883 int bufseek(int handle_id
, size_t newpos
)
885 struct memory_handle
*h
= find_handle(handle_id
);
889 if (newpos
> h
->filesize
) {
890 /* access beyond the end of the file */
893 else if (newpos
< h
->offset
|| h
->offset
+ h
->available
< newpos
) {
894 /* access before or after buffered data. A rebuffer is needed. */
895 rebuffer_handle(handle_id
, newpos
);
898 h
->ridx
= RINGBUF_ADD(h
->data
, newpos
- h
->offset
);
903 /* Advance the reading index in a handle (relatively to its current position).
904 Return 0 for success and < 0 for failure */
905 int bufadvance(int handle_id
, off_t offset
)
907 struct memory_handle
*h
= find_handle(handle_id
);
911 size_t newpos
= h
->offset
+ RINGBUF_SUB(h
->ridx
, h
->data
) + offset
;
913 return bufseek(handle_id
, newpos
);
916 /* Copy data from the given handle to the dest buffer.
917 Return the number of bytes copied or < 0 for failure. */
918 ssize_t
bufread(int handle_id
, size_t size
, void *dest
)
920 struct memory_handle
*h
= find_handle(handle_id
);
921 size_t buffered_data
;
925 if (size
== 0 && h
->filerem
> 0 &&
926 h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) == 0)
927 /* Data isn't ready */
930 if (h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) < size
&& h
->filerem
> 0)
931 /* Data isn't ready */
934 if (h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) == 0 && h
->filerem
== 0)
935 /* File is finished reading */
938 buffered_data
= MIN(size
, h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
));
940 if (h
->ridx
+ buffered_data
> buffer_len
)
942 /* the data wraps around the end of the buffer */
943 size_t read
= buffer_len
- h
->ridx
;
944 memcpy(dest
, &buffer
[h
->ridx
], read
);
945 memcpy(dest
+read
, buffer
, buffered_data
- read
);
947 else memcpy(dest
, &buffer
[h
->ridx
], buffered_data
);
949 return buffered_data
;
952 /* Update the "data" pointer to make the handle's data available to the caller.
953 Return the length of the available linear data or < 0 for failure.
954 size is the amount of linear data requested. it can be 0 to get as
956 The guard buffer may be used to provide the requested size */
957 ssize_t
bufgetdata(int handle_id
, size_t size
, void **data
)
959 struct memory_handle
*h
= find_handle(handle_id
);
963 if (size
== 0 && h
->filerem
> 0 &&
964 h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) == 0)
965 /* Data isn't ready */
968 if (h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) < size
&& h
->filerem
> 0)
969 /* Data isn't ready */
972 if (h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) == 0 && h
->filerem
== 0)
973 /* File is finished reading */
978 if (h
->ridx
+ size
> buffer_len
&&
979 h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
) >= size
)
981 /* the data wraps around the end of the buffer :
982 use the guard buffer to provide the requested amount of data. */
983 size_t copy_n
= MIN(h
->ridx
+ size
- buffer_len
, GUARD_BUFSIZE
);
984 memcpy(guard_buffer
, (unsigned char *)buffer
, copy_n
);
985 ret
= buffer_len
- h
->ridx
+ copy_n
;
986 DEBUGF("used the guard buffer to complete\n");
990 ret
= MIN(h
->available
- RINGBUF_SUB(h
->ridx
, h
->data
),
991 buffer_len
- h
->ridx
);
994 *data
= &buffer
[h
->ridx
];
996 /* DEBUGF("bufgetdata(%d): h->ridx=%ld, ret=%ld\n", handle_id,
997 (long)h->ridx, ret); */
1001 /* Return the amount of buffer space used */
1002 size_t bufused(void)
1007 /* Initialise the buffering subsystem */
1008 bool buffering_init(char *filebuf
, size_t filebuflen
)
1010 if (!filebuf
|| !filebuflen
)
1016 buffer_len
= filebuflen
;
1017 guard_buffer
= buffer
+ buffer_len
;
1022 first_handle
= NULL
;
1025 mutex_init(&llist_mutex
);
1027 conf_filechunk
= AUDIO_DEFAULT_FILECHUNK
;
1028 conf_watermark
= AUDIO_DEFAULT_WATERMARK
;
1030 /* Set the high watermark as 75% full...or 25% empty :) */
1032 high_watermark
= 3*filebuflen
/ 4;
1035 buffering_thread_p
= create_thread( buffering_thread
, buffering_stack
,
1036 sizeof(buffering_stack
), 0,
1037 buffering_thread_name
IF_PRIO(, PRIORITY_BUFFERING
)
1040 queue_init(&buffering_queue
, true);
1041 queue_enable_queue_send(&buffering_queue
, &buffering_queue_sender_list
);
1047 /* we dont want this rebuffering on targets with little ram
1048 because the disk may never spin down */
1049 static bool ata_fillbuffer_callback(void)
1051 queue_post(&buffering_queue
, Q_BUFFERING_FILL_BUFFER_IF_ACTIVE_ATA
, 0);
1056 void buffering_thread(void)
1058 struct queue_event ev
;
1062 queue_wait_w_tmo(&buffering_queue
, &ev
, HZ
/2);
1065 if ((ev
.id
== SYS_TIMEOUT
) && (buffered_data() < high_watermark
))
1066 register_ata_idle_func(ata_fillbuffer_callback
);
1071 case Q_BUFFER_HANDLE
:
1072 LOGFQUEUE("buffering < Q_BUFFER_HANDLE");
1073 queue_reply(&buffering_queue
, 1);
1074 buffer_handle((int)ev
.data
);
1077 case Q_RESET_HANDLE
:
1078 LOGFQUEUE("buffering < Q_RESET_HANDLE");
1079 queue_reply(&buffering_queue
, 1);
1080 reset_handle((int)ev
.data
);
1083 case Q_CLOSE_HANDLE
:
1084 LOGFQUEUE("buffering < Q_CLOSE_HANDLE");
1085 queue_reply(&buffering_queue
, close_handle((int)ev
.data
));
1089 case Q_BUFFERING_FILL_BUFFER_IF_ACTIVE_ATA
:
1090 /* only fill if the disk is still spining */
1092 if (!ata_disk_is_active())
1095 if (num_handles
> 0 && data_rem() > 0)
1098 #endif /* MEM > 8 */
1101 case SYS_USB_CONNECTED
:
1102 LOGFQUEUE("buffering < SYS_USB_CONNECTED");
1103 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1104 usb_wait_for_disconnect(&buffering_queue
);
1109 LOGFQUEUE_SYS_TIMEOUT("buffering < SYS_TIMEOUT");
1113 if (ev
.id
== SYS_TIMEOUT
&& queue_empty(&buffering_queue
))
1115 if (data_rem() > 0 && wasted_space() > buffered_data()/2)
1117 DEBUGF("there is %ld bytes of wasted space\n",
1118 (long)wasted_space());
1120 /* free buffer from outdated audio data */
1121 struct memory_handle
*m
= first_handle
;
1123 if (m
->type
== TYPE_AUDIO
)
1124 shrink_handle(m
->id
);
1128 /* free buffer by moving metadata */
1131 if (m
->type
!= TYPE_AUDIO
)
1132 shrink_handle(m
->id
);
1138 if (data_rem() > 0 && buffered_data() < conf_watermark
)
1140 DEBUGF("%ld bytes left to buffer and the buffer is low\n",
1149 /* Get a buffer offset from a pointer */
1150 ssize_t
get_offset(int handle_id
, void *ptr
)
1152 struct memory_handle
*h
= find_handle(handle_id
);
1156 return (size_t)ptr
- (size_t)&buffer
[h
->ridx
];
1159 void buffering_get_debugdata(struct buffering_debug
*dbgdata
)
1161 dbgdata
->num_handles
= num_handles
;
1162 dbgdata
->data_rem
= data_rem();
1163 dbgdata
->wasted_space
= wasted_space();
1164 dbgdata
->buffered_data
= buffered_data();
1165 dbgdata
->useful_data
= useful_data(0);
1166 dbgdata
->buffering
= buffering
;