Use different read and write buffer sizes. Due to interaction between common transfer...
[kugel-rb.git] / docs / PLUGIN_API.new
blob7e597eed5878235d5d5d3f140afbd7c2c9be0912
1 # Auto generated documentation by Rockbox plugin API generator v2
2 # Made by Maurus Cuelenaere
3 #             __________               __   ___.
4 #   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
5 #   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
6 #   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
7 #   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
8 #                     \/            \/     \/    \/            \/
9 # $Id$
11 # Generated from http://svn.rockbox.org/viewvc.cgi/trunk/apps/plugin.h
13 # Format:
14 # \group memory and strings
15 # \conditions defined(HAVE_BACKLIGHT)
16 # \param fmt
17 # \return
18 # \description
19 # \see func1 func2 [S[apps/plugin.c]]
21 # Markup:
22 # [W[wiki url]]
23 # [S[svn url]]
24 # [F[function]]
25 # [[url]]
26 # %BR%
27 # =code=
29 char *strcasestr (const char* phaystack, const char* pneedle)
30     \group strings and memory
31     \param phaystack
32     \param pneedle
33     \return
34     \description
36 bool action_userabort(int timeout)
37     \group action handling
38     \param timeout
39     \return
40     \description
42 const char *appsversion
43     \return version of the plugin API
44     \description
46 void ata_sleep(void)
47     \group file
48     \description Give the disk some rest
50 void ata_spin(void)
51     \group file
52     \description
54 void ata_spindown(int seconds)
55     \group file
56     \param seconds
57     \description
59 int atoi(const char *str)
60     \group strings and memory
61     \param str
62     \return
63     \description he atoi() function converts the initial portion of a string pointed to by str to int
65 struct mp3entry* audio_current_track(void)
66     \group playback control
67     \return the mp3entry struct of the currently playing track
68     \description
69     \see [S[firmware/export/id3.h]]
71 void audio_ff_rewind(long newtime)
72     \group playback control
73     \param newtime
74     \description
76 void audio_flush_and_reload_tracks(void)
77     \group playback control
78     \description
80 int audio_get_file_pos(void)
81     \group playback control
82     \return
83     \description
85 bool audio_has_changed_track(void)
86     \group playback control
87     \return
88     \description
90 void audio_next(void)
91     \group playback control
92     \description
94 struct mp3entry* audio_next_track(void)
95     \group playback control
96     \return the mp3entry struct of the upcoming track
97     \description
98     \see [S[firmware/export/id3.h]]
100 void audio_pause(void)
101     \group playback control
102     \description
104 void audio_prev(void)
105     \group playback control
106     \description
108 void audio_resume(void)
109     \group playback control
110     \description
112 void audio_set_input_source(int source, unsigned flags)
113     \group sound
114     \conditions (CONFIG_CODEC == SWCODEC) && (INPUT_SRC_CAPS != 0)
115     \param source
116     \param flags
117     \description
119 void audio_set_output_source(int monitor)
120     \group sound
121     \conditions (CONFIG_CODEC == SWCODEC) && (INPUT_SRC_CAPS != 0)
122     \param monitor
123     \description
125 void audio_set_recording_gain(int left, int right, int type)
126     \group sound
127     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
128     \param left
129     \param right
130     \param type
131     \description
133 int audio_status(void)
134     \group playback control
135     \return
136     \description
138 void audio_stop(void)
139     \group playback control
140     \description
142 void backlight_off(void)
143     \group backlight
144     \description Turns the backlight off
146 void backlight_on(void)
147     \group backlight
148     \description Turns the backlight on
150 void backlight_set_brightness(int val)
151     \group backlight
152     \conditions (defined(HAVE_BACKLIGHT_BRIGHTNESS))
153     \param val
154     \description
156 void backlight_set_timeout(int index)
157     \group backlight
158     \param index 0 : backlight always off%BR%1 : no time out%BR%2 : 1s%BR%3 : 2s%BR%4 : 3s%BR%5 : 4s%BR%6 : 5s%BR%7 : 6s%BR%8 : 7s%BR%9 : 8s%BR%10 : 9s%BR%11 : 10s%BR%12 : 15s%BR%13 : 20s%BR%14 : 25s%BR%15 : 30s%BR%16 : 45s%BR%17 : 60s%BR%18 : 90s%BR%other : backlight always off
159     \description Set the backlight timeout
161 void backlight_set_timeout_plugged(int index)
162     \conditions (CONFIG_CHARGING)
163     \param index
164     \description
166 int battery_level(void)
167     \group power
168     \return battery level in percent
169     \description On the simulator, battery_level is always 75
171 bool battery_level_safe(void)
172     \group power
173     \return
174     \description
176 int battery_time(void)
177     \group power
178     \return
179     \description
181 unsigned int battery_voltage(void)
182     \group power
183     \conditions (!defined(SIMULATOR))
184     \return
185     \description
187 unsigned short *bidi_l2v( const unsigned char *str, int orientation )
188     \conditions !defined(HAVE_LCD_CHARCELLS) 
189     \param str
190     \param orientation
191     \return
192     \description
194 void bitswap(unsigned char *data, int length)
195     \group sound
196     \conditions (!defined(SIMULATOR)) && (CONFIG_CODEC != SWCODEC)
197     \param data
198     \param length
199     \description Swap the bits for each element of array =data= of size =length=
201 int bufadvance(int handle_id, off_t offset)
202     \group buffering API
203     \conditions ((CONFIG_CODEC == SWCODEC))
204     \param handle_id
205     \param offset
206     \return
207     \description
209 int bufalloc(const void *src, size_t size, enum data_type type)
210     \group buffering API
211     \conditions ((CONFIG_CODEC == SWCODEC))
212     \param src
213     \param size
214     \param type
215     \return
216     \description
218 bool bufclose(int handle_id)
219     \group buffering API
220     \conditions ((CONFIG_CODEC == SWCODEC))
221     \param handle_id
222     \return
223     \description
225 ssize_t bufcuttail(int handle_id, size_t size)
226     \group buffering API
227     \conditions ((CONFIG_CODEC == SWCODEC))
228     \param handle_id
229     \param size
230     \return
231     \description
233 ssize_t bufgetdata(int handle_id, size_t size, void **data)
234     \group buffering API
235     \conditions ((CONFIG_CODEC == SWCODEC))
236     \param handle_id
237     \param size
238     \param data
239     \return
240     \description
242 ssize_t bufgettail(int handle_id, size_t size, void **data)
243     \group buffering API
244     \conditions ((CONFIG_CODEC == SWCODEC))
245     \param handle_id
246     \param size
247     \param data
248     \return
249     \description
251 int bufopen(const char *file, size_t offset, enum data_type type)
252     \group buffering API
253     \conditions ((CONFIG_CODEC == SWCODEC))
254     \param file
255     \param offset
256     \param type
257     \return
258     \description
260 ssize_t bufread(int handle_id, size_t size, void *dest)
261     \group buffering API
262     \conditions ((CONFIG_CODEC == SWCODEC))
263     \param handle_id
264     \param size
265     \param dest
266     \return
267     \description
269 int bufseek(int handle_id, size_t newpos)
270     \group buffering API
271     \conditions ((CONFIG_CODEC == SWCODEC))
272     \param handle_id
273     \param newpos
274     \return
275     \description
277 ssize_t buf_get_offset(int handle_id, void *ptr)
278     \conditions ((CONFIG_CODEC == SWCODEC))
279     \param handle_id
280     \param ptr
281     \return
282     \description
284 ssize_t buf_handle_offset(int handle_id)
285     \conditions ((CONFIG_CODEC == SWCODEC))
286     \param handle_id
287     \return
288     \description
290 void buf_request_buffer_handle(int handle_id)
291     \conditions ((CONFIG_CODEC == SWCODEC))
292     \param handle_id
293     \description
295 void buf_set_base_handle(int handle_id)
296     \conditions ((CONFIG_CODEC == SWCODEC))
297     \param handle_id
298     \description
300 size_t buf_used(void)
301     \conditions ((CONFIG_CODEC == SWCODEC))
302     \return
303     \description
305 void buttonlight_off(void)
306     \group button
307     \conditions (defined(HAVE_BUTTON_LIGHT))
308     \description
310 void buttonlight_on(void)
311     \group button
312     \conditions (defined(HAVE_BUTTON_LIGHT))
313     \description
315 void buttonlight_set_brightness(int val)
316     \group button
317     \conditions (defined(HAVE_BUTTON_LIGHT)) && (defined(HAVE_BUTTONLIGHT_BRIGHTNESS))
318     \param val
319     \description
321 void buttonlight_set_timeout(int value)
322     \group button
323     \conditions (defined(HAVE_BUTTON_LIGHT))
324     \param value
325     \description
327 void button_clear_queue(void)
328     \group button
329     \description Empty the button queue
331 long button_get(bool block)
332     \group button
333     \param block If is set TRUE, button_get won't return until a key is pressed
334     \return a bitmask for which keys were pressed
335     \description
337 intptr_t button_get_data(void)
338     \group button
339     \conditions (defined(HAVE_BUTTON_DATA))
340     \return
341     \description
343 long button_get_w_tmo(int ticks)
344     \group button
345     \param ticks
346     \return a bitmask for which keys were pressed; if no key was pressed, return BUTTON_NONE
347     \description Wait for a key press for =ticks= ticks. (there are HZ ticks per second)
349 bool button_hold(void)
350     \group button
351     \conditions (defined(HAS_BUTTON_HOLD))
352     \return
353     \description
355 struct event_queue *button_queue
356     \conditions !defined(HAVE_LCD_CHARCELLS) )) && (defined(HAVE_LCD_ENABLE
357     \return
358     \description
360 int button_queue_count(void)
361     \group button
362     \return
363     \description
365 int button_status(void)
366     \group button
367     \return a bitmask for which keys are currently pressed
368     \description
370 void cancel_cpu_boost(void)
371     \conditions (defined(HAVE_SCHEDULER_BOOSTCTRL))
372     \description Unboosts the CPU for the current thread
374 const unsigned char *font_get_bits( struct font *pf, unsigned short char_code )
375     \conditions !defined(HAVE_LCD_CHARCELLS) 
376     \param pf
377     \param char_code
378     \return
379     \description
381 const unsigned char* utf8decode(const unsigned char *utf8, unsigned short *ucs)
382     \group unicode stuff
383     \param utf8
384     \param ucs
385     \return
386     \description
388 const unsigned char *_ctype_
389     \group strings and memory
390     \return
391     \description
393 bool charger_inserted(void)
394     \group power
395     \conditions (CONFIG_CHARGING)
396     \return
397     \description
399 bool charging_state(void)
400     \group power
401     \conditions (CONFIG_CHARGING) && (CONFIG_CHARGING == CHARGING_MONITOR)
402     \return
403     \description
405 int closedir(DIR* dir)
406     \group dir
407     \param dir
408     \return
409     \description The closedir() function closes the directory stream associated with =dir=. The directory stream descriptor dir is not available after this call.
411 int codec_load_file(const char* codec, struct codec_api *api)
412     \group misc
413     \conditions (CONFIG_CODEC == SWCODEC)
414     \param codec
415     \param api
416     \return
417     \description
419 int count_mp3_frames(int fd, int startpos, int filesize, void (*progressfunc)(int))
420     \group misc
421     \param fd
422     \param startpos
423     \param filesize
424     \param progressfunc
425     \return
426     \description
428 void cpu_boost(bool on_off)
429     \conditions (!defined(SIMULATOR)) && (defined(HAVE_ADJUSTABLE_CPU_FREQ)) && !defined(CPU_BOOST_LOGGING) 
430     \param on_off
431     \description Boosts the CPU if =on_off= is true, otherwise it unboosts the CPU
433 void cpu_boost_(bool on_off,char*location,int line)
434     \conditions (!defined(SIMULATOR)) && (defined(HAVE_ADJUSTABLE_CPU_FREQ)) && (defined(CPU_BOOST_LOGGING))
435     \param on_off
436     \param charlocation
437     \param line
438     \description
440 long *cpu_frequency
441     \conditions (!defined(SIMULATOR))
442     \return the current cpu frequency
443     \description
445 char *create_numbered_filename(char *buffer, const char *path, const char *prefix, const char *suffix, int numberlen IF_CNFN_NUM_(, int *num))
446     \group file
447     \param buffer
448     \param path
449     \param prefix
450     \param suffix
451     \param num
452     \param numberlen
453     \return
454     \description
456 struct thread_entry* create_thread(void (*function)(void), void* stack, size_t stack_size, unsigned flags, const char *name IF_PRIO(, int priority) IF_COP(, unsigned int core))
457     \group kernel/ system
458     \param function
459     \param stack
460     \param stack_size
461     \param flags
462     \param priority
463     \param core
464     \param name
465     \return its ID if context area could be allocated, else return -1
466     \description Creates a thread
467     \see [W[RockboxKernel#struct_thread_entry_create_threa]]
469 int create_xing_header(int fd, long startpos, long filesize, unsigned char *buf, unsigned long num_frames, unsigned long rec_time, unsigned long header_template, void (*progressfunc)(int), bool generate_toc)
470     \group misc
471     \param fd
472     \param startpos
473     \param filesize
474     \param buf
475     \param num_frames
476     \param rec_time
477     \param header_template
478     \param progressfunc
479     \param generate_toc
480     \return
481     \description
483 volatile long* current_tick
484     \group kernel/ system
485     \return
486     \description
488 void debugf(const char *fmt, ...) ATTRIBUTE_PRINTF(1, 2)
489     \group misc
490     \conditions (defined(DEBUG) || defined(SIMULATOR))
491     \param fmt
492     \description Prints =fmt= in a printf-like fashion to STDERR
494 long default_event_handler(long event)
495     \group kernel/ system
496     \param event
497     \return SYS_USB_CONNECTED and call usb_screen() if =event= equals to SYS_USB_CONNECTED, else do nothing and return 0
498     \description
500 long default_event_handler_ex(long event, void (*callback)(void *), void *parameter)
501     \group kernel/ system
502     \param event
503     \param callback
504     \param parameter
505     \return
506     \description
508 bool detect_flashed_ramimage(void)
509     \group Routines for the iriver_flash -plugin.
510     \conditions (defined(IRIVER_H100_SERIES))
511     \return
512     \description
514 bool detect_flashed_romimage(void)
515     \group Routines for the iriver_flash -plugin.
516     \conditions (defined(IRIVER_H100_SERIES))
517     \return
518     \description
520 bool detect_original_firmware(void)
521     \group Routines for the iriver_flash -plugin.
522     \conditions (defined(IRIVER_H100_SERIES))
523     \return
524     \description
526 bool dir_exists(const char *path)
527     \group dir
528     \param path
529     \return
530     \description
532 int do_menu(const struct menu_item_ex *menu, int *start_selected, struct viewport parent[NB_SCREENS], bool hide_bars)
533     \group menu
534     \param menu
535     \param start_selected
536     \param parent[NB_SCREENS]
537     \param hide_bars
538     \return
539     \description
541 intptr_t dsp_configure(struct dsp_config *dsp, int setting, intptr_t value)
542     \group sound
543     \conditions (CONFIG_CODEC == SWCODEC)
544     \param dsp
545     \param setting
546     \param value
547     \return
548     \description
550 void dsp_dither_enable(bool enable)
551     \group sound
552     \conditions (CONFIG_CODEC == SWCODEC)
553     \param enable
554     \description
556 int dsp_process(struct dsp_config *dsp, char *dest, const char *src[], int count)
557     \group sound
558     \conditions (CONFIG_CODEC == SWCODEC)
559     \param dsp
560     \param dest
561     \param src[]
562     \param count
563     \return
564     \description
566 void dsp_set_crossfeed(bool enable)
567     \group sound
568     \conditions (CONFIG_CODEC == SWCODEC)
569     \param enable
570     \description
572 void dsp_set_eq(bool enable)
573     \group sound
574     \conditions (CONFIG_CODEC == SWCODEC)
575     \param enable
576     \description
578 void event_init(struct event *e, unsigned int flags)
579     \conditions (defined(HAVE_EVENT_OBJECTS))
580     \param e
581     \param flags
582     \description
584 void event_set_state(struct event *e, unsigned int state)
585     \conditions (defined(HAVE_EVENT_OBJECTS))
586     \param e
587     \param state
588     \description
590 void event_wait(struct event *e, unsigned int for_state)
591     \conditions (defined(HAVE_EVENT_OBJECTS))
592     \param e
593     \param for_state
594     \description
596 int fdprintf(int fd, const char *fmt, ...) ATTRIBUTE_PRINTF(2, 3)
597     \group file
598     \param fd
599     \param fmt
600     \return number of characters writen to =fd= or a negative value upon error
601     \description Write a formated string in the =fd=
603 bool file_exists(const char *file)
604     \group file
605     \param file
606     \return
607     \description
609 bool find_albumart(const struct mp3entry *id3, char *buf, int buflen)
610     \conditions (defined(HAVE_ALBUMART))
611     \param id3
612     \param buf
613     \param buflen
614     \return
615     \description
617 unsigned long find_next_frame(int fd, long *offset, long max_offset, unsigned long last_header)
618     \group misc
619     \param fd
620     \param offset
621     \param max_offset
622     \param last_header
623     \return
624     \description
626 void flush_icache(void)
627     \conditions (defined(CACHE_FUNCTIONS_AS_CALL))
628     \description
630 struct font* font_get(int font)
631     \conditions !defined(HAVE_LCD_CHARCELLS) 
632     \param font
633     \return the font structure for =font=
634     \description If the requested font isn't loaded/compiled-in, decrement the font number and try again.
635     \see [S[firmware/export/font.h]]
637 int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
638     \conditions !defined(HAVE_LCD_CHARCELLS) 
639     \param str
640     \param w
641     \param h
642     \param fontnumber
643     \return
644     \description
646 int font_get_width(struct font* pf, unsigned short char_code)
647     \conditions !defined(HAVE_LCD_CHARCELLS) 
648     \param pf
649     \param char_code
650     \return
651     \description
653 struct font* font_load(const char *path)
654     \conditions !defined(HAVE_LCD_CHARCELLS) 
655     \param path
656     \return
657     \description Load font =path= and returns a struct font pointer for it
658     \see [S[firmware/export/font.h]]
660 int get_action(int context, int timeout)
661     \group action handling
662     \param context
663     \param timeout
664     \return
665     \description
667 const char *get_codec_filename(int cod_spec)
668     \group misc
669     \conditions (CONFIG_CODEC == SWCODEC)
670     \param cod_spec
671     \return
672     \description
674 int get_custom_action(int context,int timeout, const struct button_mapping* (*get_context_map)(int))
675     \group action handling
676     \param context
677     \param timeout
678     \param get_context_map
679     \return
680     \description
682 bool get_metadata(struct mp3entry* id3, int fd, const char* trackname)
683     \group misc
684     \conditions (CONFIG_CODEC == SWCODEC)
685     \param id3
686     \param fd
687     \param trackname
688     \return
689     \description
691 struct tm* get_time(void)
692     \group misc
693     \return current time
694     \description
695     \see [S[firmware/include/time.h]]
697 struct user_settings* global_settings
698     \group misc
699     \return the global_settings struct
700     \description
701     \see [S[apps/settings.h]]
703 struct system_status *global_status
704     \group misc
705     \return the global_status struct
706     \description
707     \see [S[apps/settings.h]]
709 void gui_scrollbar_draw(struct screen * screen, int x, int y, int width, int height, int items, int min_shown, int max_shown, unsigned flags)
710     \conditions !defined(HAVE_LCD_CHARCELLS) 
711     \param screen
712     \param x
713     \param y
714     \param width
715     \param height
716     \param items
717     \param min_shown
718     \param max_shown
719     \param flags
720     \description
722 void gui_synclist_add_item(struct gui_synclist * lists)
723     \group list
724     \param lists
725     \description
727 void gui_synclist_del_item(struct gui_synclist * lists)
728     \group list
729     \param lists
730     \description
732 bool gui_synclist_do_button(struct gui_synclist * lists, unsigned *action, enum list_wrap wrap)
733     \group list
734     \param lists
735     \param action
736     \param wrap
737     \return
738     \description
740 void gui_synclist_draw(struct gui_synclist * lists)
741     \group list
742     \param lists
743     \description
745 int gui_synclist_get_nb_items(struct gui_synclist * lists)
746     \group list
747     \param lists
748     \return
749     \description
751 int gui_synclist_get_sel_pos(struct gui_synclist * lists)
752     \group list
753     \param lists
754     \return
755     \description
757 void gui_synclist_init(struct gui_synclist * lists, list_get_name callback_get_item_name, void * data, bool scroll_all,int selected_size, struct viewport parent[NB_SCREENS])
758     \group list
759     \param lists
760     \param callback_get_item_name
761     \param data
762     \param scroll_all
763     \param selected_size
764     \param parent[NB_SCREENS]
765     \description
767 void gui_synclist_limit_scroll(struct gui_synclist * lists, bool scroll)
768     \group list
769     \param lists
770     \param scroll
771     \description
773 void gui_synclist_select_item(struct gui_synclist * lists, int item_number)
774     \group list
775     \param lists
776     \param item_number
777     \description
779 void gui_synclist_set_icon_callback(struct gui_synclist * lists, list_get_icon icon_callback)
780     \group list
781     \param lists
782     \param icon_callback
783     \description
785 void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items)
786     \group list
787     \param lists
788     \param nb_items
789     \description
791 void gui_synclist_set_title(struct gui_synclist *lists, char* title, int icon)
792     \group list
793     \param lists
794     \param title
795     \param icon
796     \description
798 void gui_syncstatusbar_draw(struct gui_syncstatusbar * bars, bool force_redraw)
799     \group scroll bar
800     \param bars
801     \param force_redraw refreshes =bars= if true
802     \description Draws an initialized statusbar =bars= on the screen and refreshs it if =force_redraw= is true.
803     \see [S[apps/gui/statusbar.h]]
805 enum yesno_res gui_syncyesno_run(const struct text_message * main_message, const struct text_message * yes_message, const struct text_message * no_message)
806     \group list
807     \param main_message
808     \param yes_message
809     \param no_message
810     \return
811     \description
813 void i2c_begin(void)
814     \group MAS communication
815     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
816     \description
818 void i2c_end(void)
819     \group MAS communication
820     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
821     \description
823 int i2c_write(int address, const unsigned char* buf, int count )
824     \group MAS communication
825     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
826     \param address
827     \param buf
828     \param count
829     \return
830     \description
832 void invalidate_icache(void)
833     \conditions (defined(CACHE_FUNCTIONS_AS_CALL))
834     \description
836 unsigned char* iso_decode(const unsigned char *iso, unsigned char *utf8, int cp, int count)
837     \group unicode stuff
838     \param iso
839     \param utf8
840     \param cp
841     \param count
842     \return
843     \description
845 bool is_backlight_on(bool ignore_always_off)
846     \param ignore_always_off
847     \return
848     \description
850 int kbd_input(char* buffer, int buflen)
851     \group misc
852     \param buffer
853     \param buflen
854     \return FALSE upon success
855     \description Prompt for a string to be stored in =buffer= which is of length =buflen=
857 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
858     \group lcd
859     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
860     \param src
861     \param x
862     \param y
863     \param width
864     \param height
865     \description Put a bitmap at given XY coordinates. Element src[i] is the binary representation of column number i of the bitmap read from bottom to top.
867 void lcd_bitmap_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
868     \group lcd
869     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
870     \param src
871     \param src_x
872     \param src_y
873     \param stride
874     \param x
875     \param y
876     \param width
877     \param height
878     \description
880 void lcd_bitmap_transparent(const fb_data *src, int x, int y, int width, int height)
881     \group lcd
882     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH == 16)
883     \param src
884     \param x
885     \param y
886     \param width
887     \param height
888     \description
890 void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
891     \group lcd
892     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH == 16)
893     \param src
894     \param src_x
895     \param src_y
896     \param stride
897     \param x
898     \param y
899     \param width
900     \param height
901     \description
903 void lcd_blit_grey_phase(unsigned char *values, unsigned char *phases, int bx, int by, int bwidth, int bheight, int stride)
904     \group lcd
905     \conditions !defined(HAVE_LCD_CHARCELLS) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
906     \param values
907     \param phases
908     \param bx
909     \param by
910     \param bwidth
911     \param bheight
912     \param stride
913     \description
915 void lcd_blit_mono(const unsigned char *data, int x, int by, int width, int bheight, int stride)
916     \group lcd
917     \conditions !defined(HAVE_LCD_CHARCELLS) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
918     \param data
919     \param x
920     \param by
921     \param width
922     \param bheight
923     \param stride
924     \description
926 void lcd_blit_yuv(unsigned char * const src[3], int src_x, int src_y, int stride, int x, int y, int width, int height)
927     \group lcd
928     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH == 16)
929     \param src[3]
930     \param src_x
931     \param src_y
932     \param stride
933     \param x
934     \param y
935     \param width
936     \param height
937     \description
939 void lcd_clear_display(void)
940     \group lcd
941     \description Clears the LCD and the framebuffer
943 void lcd_define_pattern(unsigned long ucs, const char *pattern)
944     \group lcd
945     \conditions (defined(HAVE_LCD_CHARCELLS))
946     \param ucs
947     \param pattern is a 8x8 pixelbitmap
948     \description Define a custom pattern for index =ucs=
950 void lcd_double_height(bool on)
951     \group lcd
952     \conditions (defined(HAVE_LCD_CHARCELLS))
953     \param on
954     \description
956 void lcd_drawline(int x1, int y1, int x2, int y2)
957     \group lcd
958     \conditions !defined(HAVE_LCD_CHARCELLS) 
959     \param x1 X top coordinate
960     \param y1 Y top coordinate
961     \param x2 X bottom coordinate
962     \param y2 Y bottom coordinate
963     \description Draws a line at (=x1=, =y1=) -> (=x2=, =y2=) within current drawing mode
965 void lcd_drawpixel(int x, int y)
966     \group lcd
967     \conditions !defined(HAVE_LCD_CHARCELLS) 
968     \param x
969     \param y
970     \description Draws a pixel at (=x=, =y=) within current drawing mode
972 void lcd_drawrect(int x, int y, int width, int height)
973     \group lcd
974     \conditions !defined(HAVE_LCD_CHARCELLS) 
975     \param x
976     \param y
977     \param width
978     \param height
979     \description Draws a rectangle at (=x=, =y=) -> (=x= + =width=, =y= + =height=) within current drawing mode
981 void lcd_fillrect(int x, int y, int width, int height)
982     \group lcd
983     \conditions !defined(HAVE_LCD_CHARCELLS) 
984     \param x
985     \param y
986     \param width
987     \param height
988     \description Draws a filled rectangle at (=x=, =y=) -> (=x= + =width=, =y= + =height=) within current drawing mode
990 fb_data* lcd_framebuffer
991     \group lcd
992     \conditions !defined(HAVE_LCD_CHARCELLS) 
993     \return
994     \description Pointer to the framebuffer
995     \see [S[firmware/export/lcd.h]]
997 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
998     \group lcd
999     \param str String
1000     \param w Width
1001     \param h Height
1002     \return Success or not
1003     \description Stores the width and height of the string in =w= and =h=
1005 fb_data* lcd_get_backdrop(void)
1006     \group lcd
1007     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1008     \return Pointer to framebuffer data
1009     \description Gets the current backdrop
1010     \see lcd_framebuffer
1012 unsigned lcd_get_background(void)
1013     \group lcd
1014     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1015     \return
1016     \description
1018 int lcd_get_drawmode(void)
1019     \group lcd
1020     \conditions !defined(HAVE_LCD_CHARCELLS) 
1021     \return current LCD drawing mode
1022     \description
1024 unsigned lcd_get_foreground(void)
1025     \group lcd
1026     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1027     \return
1028     \description
1030 unsigned long lcd_get_locked_pattern(void)
1031     \group lcd
1032     \conditions (defined(HAVE_LCD_CHARCELLS))
1033     \return
1034     \description Get a locked pattern index
1035     \see [S[firmware/drivers/lcd-player.c]]
1037 void lcd_hline(int x1, int x2, int y)
1038     \group lcd
1039     \conditions !defined(HAVE_LCD_CHARCELLS) 
1040     \param x1 X start coordinate
1041     \param x2 X end coordinate
1042     \param y Y coordinate
1043     \description Draws a horizontal line at (=x1=, =y=) -> (=x2=, =y=) within current drawing mode
1045 void lcd_icon(int icon, bool enable)
1046     \group lcd
1047     \conditions (defined(HAVE_LCD_CHARCELLS))
1048     \param icon
1049     \param enable
1050     \description
1051     \see [S[firmware/drivers/lcd-player.c]]
1053 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
1054     \group lcd
1055     \conditions !defined(HAVE_LCD_CHARCELLS) 
1056     \param src
1057     \param x
1058     \param y
1059     \param width
1060     \param height
1061     \description
1063 void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
1064     \group lcd
1065     \conditions !defined(HAVE_LCD_CHARCELLS) 
1066     \param src
1067     \param src_x
1068     \param src_y
1069     \param stride
1070     \param x
1071     \param y
1072     \param width
1073     \param height
1074     \description
1076 void lcd_putc(int x, int y, unsigned long ucs)
1077     \group lcd
1078     \conditions (defined(HAVE_LCD_CHARCELLS))
1079     \param x
1080     \param y
1081     \param ucs
1082     \description Put character =ucs= at coordinates (=x=, =y=)
1084 void lcd_puts(int x, int y, const unsigned char *string)
1085     \group lcd
1086     \param x Row X
1087     \param y Column Y
1088     \param string
1089     \description Puts string on the LCD at row =x= and column =y=
1091 void lcd_putsxy(int x, int y, const unsigned char *string)
1092     \group lcd
1093     \param x X coordinate
1094     \param y Y coordinate
1095     \param string
1096     \description Puts string on the LCD at position (=x=, =y=)
1098 void lcd_puts_scroll(int x, int y, const unsigned char* string)
1099     \group lcd
1100     \param x Row X
1101     \param y Column Y
1102     \param string
1103     \description Puts scrolling string on the LCD at row =x= and column =y=. The scrolling style is STYLE_DEFAULT.
1105 void lcd_puts_scroll_style(int x, int y, const unsigned char* string, int style)
1106     \group lcd
1107     \conditions !defined(HAVE_LCD_CHARCELLS) 
1108     \param x
1109     \param y
1110     \param string
1111     \param style
1112     \description Same as lcd_puts_style, but with scrolling is enabled
1113     \see lcd_puts_style
1115 void lcd_puts_style(int x, int y, const unsigned char *str, int style)
1116     \group lcd
1117     \conditions !defined(HAVE_LCD_CHARCELLS) 
1118     \param x Row X
1119     \param y Column Y
1120     \param str
1121     \param style can be STYLE_DEFAULT for black text display or STYLE_INVERT for white text display
1122     \description Put a string at row =x= and column =y=
1124 void lcd_put_cursor(int x, int y, unsigned long ucs)
1125     \group lcd
1126     \conditions (defined(HAVE_LCD_CHARCELLS))
1127     \param x
1128     \param y
1129     \param ucs
1130     \description Put cursor at coordinates (=x=, =y=)
1131     \see [S[firmware/export/lcd.h]]
1133 void lcd_remote_bitmap(const fb_remote_data *src, int x, int y, int width, int height)
1134     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1135     \param src
1136     \param x
1137     \param y
1138     \param width
1139     \param height
1140     \description
1142 void lcd_remote_bitmap_part(const fb_remote_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
1143     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1144     \param src
1145     \param src_x
1146     \param src_y
1147     \param stride
1148     \param x
1149     \param y
1150     \param width
1151     \param height
1152     \description
1154 void lcd_remote_clear_display(void)
1155     \group remote lcd
1156     \conditions (defined(HAVE_REMOTE_LCD))
1157     \description
1159 void lcd_remote_drawline(int x1, int y1, int x2, int y2)
1160     \group remote lcd
1161     \conditions (defined(HAVE_REMOTE_LCD))
1162     \param x1 X top coordinate
1163     \param y1 Y top coordinate
1164     \param x2 X bottom coordinate
1165     \param y2 Y bottom coordinate
1166     \description Draws a line at (=x1=, =y1=) -> (=x2=, =y2=) within current drawing mode
1168 void lcd_remote_drawpixel(int x, int y)
1169     \group remote lcd
1170     \conditions (defined(HAVE_REMOTE_LCD))
1171     \param x
1172     \param y
1173     \description Draws a pixel at (=x=, =y=) within current drawing mode
1175 void lcd_remote_drawrect(int x, int y, int nx, int ny)
1176     \group remote lcd
1177     \conditions (defined(HAVE_REMOTE_LCD))
1178     \param x
1179     \param y
1180     \param nx
1181     \param ny
1182     \description
1184 void lcd_remote_fillrect(int x, int y, int nx, int ny)
1185     \group remote lcd
1186     \conditions (defined(HAVE_REMOTE_LCD))
1187     \param x
1188     \param y
1189     \param nx
1190     \param ny
1191     \description
1193 fb_remote_data* lcd_remote_framebuffer
1194     \group remote lcd
1195     \conditions (defined(HAVE_REMOTE_LCD))
1196     \return
1197     \description
1199 int lcd_remote_getstringsize(const unsigned char *str, int *w, int *h)
1200     \group remote lcd
1201     \conditions (defined(HAVE_REMOTE_LCD))
1202     \param str String
1203     \param w Width
1204     \param h Height
1205     \return Success or not
1206     \description Stores the width and height of the string in =w= and =h=
1208 unsigned lcd_remote_get_background(void)
1209     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1210     \return
1211     \description
1213 int lcd_remote_get_drawmode(void)
1214     \group remote lcd
1215     \conditions (defined(HAVE_REMOTE_LCD))
1216     \return
1217     \description
1219 unsigned lcd_remote_get_foreground(void)
1220     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1221     \return
1222     \description
1224 void lcd_remote_hline(int x1, int x2, int y)
1225     \group remote lcd
1226     \conditions (defined(HAVE_REMOTE_LCD))
1227     \param x1
1228     \param x2
1229     \param y
1230     \description
1232 void lcd_remote_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
1233     \group remote lcd
1234     \conditions (defined(HAVE_REMOTE_LCD))
1235     \param src
1236     \param x
1237     \param y
1238     \param width
1239     \param height
1240     \description
1242 void lcd_remote_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
1243     \group remote lcd
1244     \conditions (defined(HAVE_REMOTE_LCD))
1245     \param src
1246     \param src_x
1247     \param src_y
1248     \param stride
1249     \param x
1250     \param y
1251     \param width
1252     \param height
1253     \description
1255 void lcd_remote_puts(int x, int y, const unsigned char *string)
1256     \group remote lcd
1257     \conditions (defined(HAVE_REMOTE_LCD))
1258     \param x
1259     \param y
1260     \param string
1261     \description
1263 void lcd_remote_putsxy(int x, int y, const unsigned char *string)
1264     \group remote lcd
1265     \conditions (defined(HAVE_REMOTE_LCD))
1266     \param x
1267     \param y
1268     \param string
1269     \description
1271 void lcd_remote_puts_scroll(int x, int y, const unsigned char* string)
1272     \group remote lcd
1273     \conditions (defined(HAVE_REMOTE_LCD))
1274     \param x
1275     \param y
1276     \param string
1277     \description
1279 void lcd_remote_puts_scroll_style(int x, int y, const unsigned char* string, int style)
1280     \group remote lcd
1281     \conditions (defined(HAVE_REMOTE_LCD))
1282     \param x
1283     \param y
1284     \param string
1285     \param style
1286     \description
1288 void lcd_remote_puts_style(int x, int y, const unsigned char *str, int style)
1289     \group remote lcd
1290     \conditions (defined(HAVE_REMOTE_LCD))
1291     \param x
1292     \param y
1293     \param str
1294     \param style
1295     \description
1297 void lcd_remote_setfont(int font)
1298     \group remote lcd
1299     \conditions (defined(HAVE_REMOTE_LCD))
1300     \param font
1301     \description Set default font
1303 void lcd_remote_set_background(unsigned background)
1304     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1305     \param background
1306     \description
1308 void lcd_remote_set_contrast(int x)
1309     \group remote lcd
1310     \conditions (defined(HAVE_REMOTE_LCD))
1311     \param x
1312     \description
1314 void lcd_remote_set_drawmode(int mode)
1315     \group remote lcd
1316     \conditions (defined(HAVE_REMOTE_LCD))
1317     \param mode
1318     \description
1320 void lcd_remote_set_foreground(unsigned foreground)
1321     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1322     \param foreground
1323     \description
1325 void lcd_remote_stop_scroll(void)
1326     \group remote lcd
1327     \conditions (defined(HAVE_REMOTE_LCD))
1328     \description Stop all scrolling lines on the screen
1330 void lcd_remote_update(void)
1331     \group remote lcd
1332     \conditions (defined(HAVE_REMOTE_LCD))
1333     \description
1335 void lcd_remote_update_rect(int x, int y, int width, int height)
1336     \group remote lcd
1337     \conditions (defined(HAVE_REMOTE_LCD))
1338     \param x
1339     \param y
1340     \param width
1341     \param height
1342     \description
1344 void lcd_remote_vline(int x, int y1, int y2)
1345     \group remote lcd
1346     \conditions (defined(HAVE_REMOTE_LCD))
1347     \param x
1348     \param y1
1349     \param y2
1350     \description
1352 void lcd_remove_cursor(void)
1353     \group lcd
1354     \conditions (defined(HAVE_LCD_CHARCELLS))
1355     \description Remove the cursor from the screen
1357 void lcd_setfont(int font)
1358     \group lcd
1359     \conditions !defined(HAVE_LCD_CHARCELLS) 
1360     \param font
1361     \description Set default font
1363 void lcd_set_backdrop(fb_data* backdrop)
1364     \group lcd
1365     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1366     \param backdrop Pointer to backdrop image
1367     \description Set the backdrop to =backdrop=
1368     \see lcd_framebuffer
1370 void lcd_set_background(unsigned foreground)
1371     \group lcd
1372     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1373     \param foreground
1374     \description
1376 void lcd_set_contrast(int x)
1377     \group lcd
1378     \param x Should be between =MIN_CONTRAST_SETTING= and =MAX_CONTRAST_SETTING=
1379     \description Sets LCD contrast to value =x=
1381 void lcd_set_drawmode(int mode)
1382     \group lcd
1383     \conditions !defined(HAVE_LCD_CHARCELLS) 
1384     \param mode
1385     \description
1387 void lcd_activation_set_hook(void (*enable_hook)(void))
1388     \conditions !defined(HAVE_LCD_CHARCELLS) && (defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP))
1389     \param enable_hook
1390     \description
1392 void lcd_set_foreground(unsigned foreground)
1393     \group lcd
1394     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1395     \param foreground
1396     \description
1398 void lcd_set_invert_display(bool yesno)
1399     \group lcd
1400     \conditions !defined(HAVE_LCD_CHARCELLS) )) && (defined(HAVE_LCD_INVERT
1401     \param yesno
1402     \description
1404 void lcd_stop_scroll(void)
1405     \group lcd
1406     \description Stop all scrolling lines on the screen
1408 void lcd_unlock_pattern(unsigned long ucs)
1409     \group lcd
1410     \conditions (defined(HAVE_LCD_CHARCELLS))
1411     \param ucs
1412     \description Unlock pattern of index =ucs=
1414 void lcd_update(void)
1415     \group lcd
1416     \description Pushes LCD framebuffer changes to the LCD
1418 void lcd_update_rect(int x, int y, int width, int height)
1419     \group lcd
1420     \conditions !defined(HAVE_LCD_CHARCELLS) 
1421     \param x measured in pixels
1422     \param y measured in pixels
1423     \param width measured in pixels
1424     \param height measured in pixels
1425     \description Pushes LCD framebuffer changes to the LCD within rectangle (=x=, =y=) -> (=x= + =width=, =y= + =height=). Notice that the smallest vertical resolution in updates that the hardware supports is 8 pixels.
1427 void lcd_vline(int x, int y1, int y2)
1428     \group lcd
1429     \conditions !defined(HAVE_LCD_CHARCELLS) 
1430     \param x X coordinate
1431     \param y1 Y start coordinate
1432     \param y2 Y end coordinate
1433     \description Draws a vertical line at (=x=, =y1=) -> (=x=, =y2=) within current drawing mode
1435 void lcd_yuv_set_options(unsigned options)
1436     \group lcd
1437     \conditions !defined(HAVE_LCD_CHARCELLS) )) && (LCD_DEPTH == 16) && (defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200) || defined(SANSA_C200)  || defined(IRIVER_H10) || defined(COWON_D2
1438     \param options
1439     \description
1441 void led(bool on)
1442     \param on
1443     \description
1445 void logf(const char *fmt, ...) ATTRIBUTE_PRINTF(1, 2)
1446     \group misc
1447     \conditions (defined(ROCKBOX_HAS_LOGF))
1448     \param fmt
1449     \description
1451 const unsigned long *audio_master_sampr_list
1452     \group sound
1453     \conditions (CONFIG_CODEC == SWCODEC)
1454     \return
1455     \description
1457 const unsigned long *hw_freq_sampr
1458     \group sound
1459     \conditions (CONFIG_CODEC == SWCODEC)
1460     \return
1461     \description
1463 const unsigned long *rec_freq_sampr
1464     \group sound
1465     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1466     \return
1467     \description
1469 int mas_codec_readreg(int reg)
1470     \group MAS communication
1471     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
1472     \param reg
1473     \return
1474     \description
1476 int mas_codec_writereg(int reg, unsigned int val)
1477     \group MAS communication
1478     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
1479     \param reg
1480     \param val
1481     \return
1482     \description
1484 int mas_readmem(int bank, int addr, unsigned long* dest, int len)
1485     \group MAS communication
1486     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1487     \param bank
1488     \param addr
1489     \param dest
1490     \param len
1491     \return
1492     \description
1494 int mas_readreg(int reg)
1495     \group MAS communication
1496     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1497     \param reg
1498     \return
1499     \description
1501 int mas_writemem(int bank, int addr, const unsigned long* src, int len)
1502     \group MAS communication
1503     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1504     \param bank
1505     \param addr
1506     \param src
1507     \param len
1508     \return
1509     \description
1511 int mas_writereg(int reg, unsigned int val)
1512     \group MAS communication
1513     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1514     \param reg
1515     \param val
1516     \return
1517     \description
1519 void *memchr(const void *s1, int c, size_t n)
1520     \group strings and memory
1521     \param s1
1522     \param c
1523     \param n
1524     \return
1525     \description
1527 int memcmp(const void *s1, const void *s2, size_t n)
1528     \group strings and memory
1529     \param s1
1530     \param s2
1531     \param n
1532     \return
1533     \description
1535 void* memcpy(void *out, const void *in, size_t n)
1536     \group strings and memory
1537     \param out
1538     \param in
1539     \param n
1540     \return
1541     \description Copies =n= bytes of data in memory from =in= to =out=
1543 void* memmove(void *out, const void *in, size_t n)
1544     \group strings and memory
1545     \param out
1546     \param in
1547     \param n
1548     \return
1549     \description
1551 void* memset(void *dst, int c, size_t length)
1552     \group strings and memory
1553     \param dst
1554     \param c
1555     \param length
1556     \return
1557     \description Fills a memory region with specified byte value =c=
1559 int mkdir(const char *name)
1560     \group dir
1561     \param name
1562     \return
1563     \description
1565 time_t mktime(struct tm *t)
1566     \group misc
1567     \conditions (CONFIG_RTC)
1568     \param t
1569     \return
1570     \description
1572 bool mp3info(struct mp3entry *entry, const char *filename)
1573     \group misc
1574     \param entry
1575     \param filename
1576     \return FALSE if successfull
1577     \description The given =entry= is filled in with whatever id3 info it could find about the given =filename=
1579 bool mp3_is_playing(void)
1580     \group sound
1581     \conditions (!defined(SIMULATOR))
1582     \return true if an mp3 is playing, else return false
1583     \description Note: a paused mp3 is considered as a playing mp3
1585 void mp3_play_data(const unsigned char* start, int size, void (*get_more)(unsigned char** start, size_t* size))
1586     \group sound
1587     \conditions (!defined(SIMULATOR))
1588     \param start points to the begining of the file to play
1589     \param size is the size to play
1590     \param get_more is a callback function
1591     \description Plays a chunk of an mp3 file
1593 void mp3_play_pause(bool play)
1594     \group sound
1595     \conditions (!defined(SIMULATOR))
1596     \param play
1597     \description If playback was paused and =play= is TRUE, resume playback. If playback isn't paused and =play= is FALSE, pause playback.
1599 void mp3_play_stop(void)
1600     \group sound
1601     \conditions (!defined(SIMULATOR))
1602     \description Stops playback
1604 unsigned long mpeg_get_last_header(void)
1605     \group playback control
1606     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1607     \return
1608     \description
1610 void mutex_init(struct mutex *m)
1611     \group kernel/ system
1612     \conditions (CONFIG_CODEC == SWCODEC)
1613     \param m
1614     \description
1616 void mutex_lock(struct mutex *m)
1617     \group kernel/ system
1618     \conditions (CONFIG_CODEC == SWCODEC)
1619     \param m
1620     \description
1622 void mutex_unlock(struct mutex *m)
1623     \group kernel/ system
1624     \conditions (CONFIG_CODEC == SWCODEC)
1625     \param m
1626     \description
1628 DIR* opendir(const char* name)
1629     \group dir
1630     \param name
1631     \return a pointer to the directory stream
1632     \description The opendir() function opens a directory stream corresponding to the directory name.  The stream is positioned at the first entry in the directory.
1634 bool option_screen(const struct settings_list *setting, struct viewport parent[NB_SCREENS], bool use_temp_var, unsigned char* option_title)
1635     \group options
1636     \param setting
1637     \param parent[NB_SCREENS]
1638     \param use_temp_var
1639     \param option_title
1640     \return
1641     \description
1643 void pcm_apply_settings(void)
1644     \group sound
1645     \conditions (CONFIG_CODEC == SWCODEC)
1646     \description
1648 void pcm_calculate_peaks(int *left, int *right)
1649     \group sound
1650     \conditions (CONFIG_CODEC == SWCODEC)
1651     \param left
1652     \param right
1653     \description
1655 void pcm_calculate_rec_peaks(int *left, int *right)
1656     \group sound
1657     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1658     \param left
1659     \param right
1660     \description
1662 void pcm_close_recording(void)
1663     \group sound
1664     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1665     \description
1667 size_t pcm_get_bytes_waiting(void)
1668     \group sound
1669     \conditions (CONFIG_CODEC == SWCODEC)
1670     \return
1671     \description
1673 void pcm_init_recording(void)
1674     \group sound
1675     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1676     \description
1678 bool pcm_is_paused(void)
1679     \group sound
1680     \conditions (CONFIG_CODEC == SWCODEC)
1681     \return true if playback is paused, else false
1682     \description
1684 bool pcm_is_playing(void)
1685     \group sound
1686     \conditions (CONFIG_CODEC == SWCODEC)
1687     \return true unless playback is paused
1688     \description
1690 void pcm_play_data(pcm_more_callback_type get_more, unsigned char* start, size_t size)
1691     \group sound
1692     \conditions (CONFIG_CODEC == SWCODEC)
1693     \param get_more Optional callback
1694     \param start is the address of raw 16-16, interleaved PCM data
1695     \param size is the size of the data to play
1696     \description May be used without the callback parameter in order to play a single clip. If you wish to play sound continuously, then use the callback instead and return the buffer address and size to be played from that callback. Every time that a buffer is played out, the callback is asked for the next buffer to play but without stopping and starting playback. The callback is called asynchronously in interrupt context so what you may do in there is limited. 
1698 void pcm_play_lock(void)
1699     \group sound
1700     \conditions (CONFIG_CODEC == SWCODEC)
1701     \description
1703 void pcm_play_pause(bool play)
1704     \group sound
1705     \conditions (CONFIG_CODEC == SWCODEC)
1706     \param play
1707     \description Pauses or unpauses the playback depending on the truth value of =play=
1709 void pcm_play_stop(void)
1710     \group sound
1711     \conditions (CONFIG_CODEC == SWCODEC)
1712     \description Stops the playback and empties the audio buffer unlike [F[pcm_play_pause]]
1714 void pcm_play_unlock(void)
1715     \group sound
1716     \conditions (CONFIG_CODEC == SWCODEC)
1717     \description
1719 void pcm_record_data(pcm_more_callback_type2 more_ready, void *start, size_t size)
1720     \group sound
1721     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1722     \param more_ready
1723     \param start
1724     \param size
1725     \description
1727 void pcm_record_more(void *start, size_t size)
1728     \group sound
1729     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1730     \param start
1731     \param size
1732     \description
1734 void pcm_set_frequency(unsigned int frequency)
1735     \group sound
1736     \conditions (CONFIG_CODEC == SWCODEC)
1737     \param frequency
1738     \description
1740 void pcm_stop_recording(void)
1741     \group sound
1742     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1743     \description
1745 bool peak_meter_get_use_dbfs(void)
1746     \conditions ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
1747     \return 1 if the meter currently is displaying dBfs values, 0 if the meter is displaying percent values
1748     \description
1750 unsigned short peak_meter_scale_value(unsigned short val, int meterwidth)
1751     \conditions ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
1752     \param val is the volume value (range: 0 <= val < MAX_PEAK)
1753     \param meterwidth is the width of the meter in pixel
1754     \return a value between 0 and meterwidth
1755     \description Scales a peak value as read from the MAS to the range of =meterwidth=. The scaling is performed according to the scaling method (dBfs / linear) and the range (peak_meter_range_min .. peak_meter_range_max).
1757 void peak_meter_set_use_dbfs(bool use)
1758     \conditions ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
1759     \param use If =use= is 0 use linear percent scale, else use dBfs
1760     \description Specifies whether the values displayed are scaled as dBfs or as linear percent values
1762 int playlist_amount(void)
1763     \group playback control
1764     \return the number of tracks in current playlist
1765     \description
1767 int playlist_resume(void)
1768     \group playback control
1769     \return
1770     \description
1772 int playlist_start(int start_index, int offset)
1773     \group playback control
1774     \param start_index
1775     \param offset
1776     \return
1777     \description
1779 void* plugin_get_audio_buffer(size_t *buffer_size)
1780     \group misc
1781     \param buffer_size
1782     \return
1783     \description Steals =buffer_size= bytes from the available RAM, reducing the available buffer for audio buffering
1785 void* plugin_get_buffer(size_t *buffer_size)
1786     \group misc
1787     \param buffer_size this is the memory size left in plugin buffer upon return
1788     \return a pointer to the portion of the plugin buffer that is not already being used. If no plugin is loaded, returns the entire plugin buffer.
1789     \description
1791 char* plugin_get_current_filename(void)
1792     \group misc
1793     \return
1794     \description
1796 void plugin_iram_init(char *iramstart, char *iramcopy, size_t iram_size, char *iedata, size_t iedata_size)
1797     \group misc
1798     \conditions (defined(PLUGIN_USE_IRAM))
1799     \param iramstart
1800     \param iramcopy
1801     \param iram_size
1802     \param iedata
1803     \param iedata_size
1804     \description
1806 void plugin_tsr(bool (*exit_callback)(bool reenter))
1807     \group misc
1808     \param exit_callback
1809     \description
1811 void PREFIX(audio_play)(long offset)
1812     \group playback control
1813     \param audio_play
1814     \param offset
1815     \description
1817 int PREFIX(close)(int fd)
1818     \group file
1819     \param close
1820     \param fd
1821     \return 0 upon success
1822     \description The close() function will deallocate the file descriptor indicated by =fd=.  To deallocate means to make the file descriptor available for return by subsequent calls to open() or other functions that allocate file descriptors.
1824 int PREFIX(creat)(const char *pathname)
1825     \group file
1826     \param creat
1827     \param pathname
1828     \return the file descriptor associated to this file
1829     \description Create a file with mode O_RDONLY, O_WRONLY or O_RDWR
1831 off_t PREFIX(filesize)(int fd)
1832     \group file
1833     \param filesize
1834     \param fd
1835     \return size of a file; upon error, returns -1
1836     \description
1838 int PREFIX(ftruncate)(int fd, off_t length)
1839     \group file
1840     \param ftruncate
1841     \param fd
1842     \param length
1843     \return
1844     \description Truncate file to the specified =length=
1846 off_t PREFIX(lseek)(int fd, off_t offset, int whence)
1847     \group file
1848     \param lseek
1849     \param fd
1850     \param offset
1851     \param whence
1852     \return
1853     \description The lseek() function sets the file pointer associated with the open file descriptor specified by =fd= as follows: If =whence= is SEEK_SET, the pointer is set to =offset= bytes. If =whence= is SEEK_CUR, the pointer is set to its current location plus =offset=. If =whence= is SEEK_END, the pointer is set to the size of the file plus =offset=.
1855 int PREFIX(open)(const char* pathname, int flags)
1856     \group file
1857     \param open
1858     \param pathname
1859     \param flags
1860     \return
1861     \description The open() function establishes the connection between a file and a file descriptor. It creates an open file description that refers to a file and a file descriptor that refers to that open file description. The file descriptor is used by other I/O functions to refer to that file.
1863 ssize_t PREFIX(read)(int fd, void* buf, size_t count)
1864     \group file
1865     \param read
1866     \param fd
1867     \param buf
1868     \param count
1869     \return
1870     \description The read() function attempts to read =count= bytes from the file associated with the open file descriptor, =fd=, into the buffer pointed to by =buf=
1872 int PREFIX(remove)(const char* pathname)
1873     \group file
1874     \param remove
1875     \param pathname
1876     \return
1877     \description remove() deletes a name from the filesystem. It calls unlink for files, and rmdir for directories.
1879 int PREFIX(rename)(const char* path, const char* newname)
1880     \group file
1881     \param rename
1882     \param path points to the pathname of the file to be renamed
1883     \param newname points to the new pathname of the file
1884     \return
1885     \description The rename() function changes the name of a file
1887 void PREFIX(sleep)(int ticks)
1888     \group kernel/ system
1889     \param sleep
1890     \param ticks
1891     \description Sleep a specified number of =ticks=, we have HZ ticks per second
1893 ssize_t PREFIX(write)(int fd, const void* buf, size_t count)
1894     \group file
1895     \param write
1896     \param fd
1897     \param buf
1898     \param count
1899     \return
1900     \description Write writes up to =count= bytes to the file referenced by the file descriptor =fd= from the buffer starting at =buf=
1902 void profile_func_enter(void *this_fn, void *call_site)
1903     \conditions (defined(RB_PROFILE))
1904     \param this_fn
1905     \param call_site
1906     \description
1908 void profile_func_exit(void *this_fn, void *call_site)
1909     \conditions (defined(RB_PROFILE))
1910     \param this_fn
1911     \param call_site
1912     \description
1914 void profile_thread(void)
1915     \conditions (defined(RB_PROFILE))
1916     \description
1918 void profstop(void)
1919     \conditions (defined(RB_PROFILE))
1920     \description
1922 void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *))
1923     \group misc
1924     \param base start of array
1925     \param nmemb number of elements
1926     \param size describes the size of each element of the array
1927     \param compar
1928     \description qsort sorts an array (begining at =base=) of =nmemb= objects
1930 void queue_delete(struct event_queue *q)
1931     \param q
1932     \description
1934 bool queue_empty(const struct event_queue *q)
1935     \conditions (CONFIG_CODEC == SWCODEC)
1936     \param q
1937     \return
1938     \description
1940 void queue_enable_queue_send(struct event_queue *q, struct queue_sender_list *send, struct thread_entry *owner)
1941     \conditions (CONFIG_CODEC == SWCODEC)
1942     \param q
1943     \param send
1944     \param owner
1945     \description
1947 void queue_init(struct event_queue *q, bool register_queue)
1948     \param q
1949     \param register_queue
1950     \description
1952 void queue_post(struct event_queue *q, long id, intptr_t data)
1953     \param q
1954     \param id
1955     \param data
1956     \description
1958 void queue_reply(struct event_queue *q, intptr_t retval)
1959     \conditions (CONFIG_CODEC == SWCODEC)
1960     \param q
1961     \param retval
1962     \description
1964 intptr_t queue_send(struct event_queue *q, long id, intptr_t data)
1965     \conditions (CONFIG_CODEC == SWCODEC)
1966     \param q
1967     \param id
1968     \param data
1969     \return
1970     \description
1972 void queue_wait(struct event_queue *q, struct queue_event *ev)
1973     \conditions (CONFIG_CODEC == SWCODEC)
1974     \param q
1975     \param ev
1976     \description
1978 void queue_wait_w_tmo(struct event_queue *q, struct queue_event *ev, int ticks)
1979     \param q
1980     \param ev
1981     \param ticks
1982     \description
1984 int rand(void)
1985     \group misc
1986     \return a pseudo random number between 0 and 0x7fffffff
1987     \description
1989 struct dirent* readdir(DIR* dir)
1990     \group dir
1991     \param dir
1992     \return a pointer to a dirent structure representing the next directory entry in the directory stream pointed to by =dir= or NULL on reaching the end-of-file or if an error occurred
1993     \description
1995 int read_bmp_file(const char* filename, struct bitmap *bm, int maxsize, int format)
1996     \conditions (defined(HAVE_LCD_BITMAP))
1997     \param filename
1998     \param bm
1999     \param maxsize
2000     \param format
2001     \return
2002     \description
2004 int read_line(int fd, char* buffer, int buffer_size)
2005     \group file
2006     \param fd
2007     \param buffer
2008     \param buffer_size
2009     \return number of bytes read (which may be larger than the number of bytes stored in buffer) or upon error -1 (and buffer contains whatever could be read)
2010     \description Read (up to) a line of text from =fd= into =buffer=. A line is terminated by a LF char. Neither LF nor CR chars are stored in buffer.
2012 void register_ata_idle_func(ata_idle_notify function)
2013     \group file
2014     \conditions (USING_ATA_CALLBACK)
2015     \param function
2016     \description
2018 void reload_directory(void)
2019     \group file
2020     \description
2022 void remote_backlight_off(void)
2023     \conditions (defined(HAVE_REMOTE_LCD))
2024     \description Turns the remote backlight off
2026 void remote_backlight_on(void)
2027     \conditions (defined(HAVE_REMOTE_LCD))
2028     \description Turns the remote backlight on
2030 void remote_backlight_set_timeout(int index)
2031     \conditions (defined(HAVE_REMOTE_LCD))
2032     \param index
2033     \description
2035 void remote_backlight_set_timeout_plugged(int index)
2036     \conditions (defined(HAVE_REMOTE_LCD)) && (CONFIG_CHARGING)
2037     \param index
2038     \description
2040 void reset_poweroff_timer(void)
2041     \description The function name pretty much says what it's supposed to do
2043 int rmdir(const char *name)
2044     \group dir
2045     \param name
2046     \return
2047     \description
2049 struct screen* screens[NB_SCREENS]
2050     \return
2051     \description
2053 void screen_clear_area(struct screen * display, int xstart, int ystart, int width, int height)
2054     \conditions !defined(HAVE_LCD_CHARCELLS) 
2055     \param display
2056     \param xstart
2057     \param ystart
2058     \param width
2059     \param height
2060     \description
2062 void screen_dump_set_hook(void (*hook)(int fh))
2063     \conditions (defined(HAVE_LCD_BITMAP))
2064     \param hook
2065     \description
2067 bool search_albumart_files(const struct mp3entry *id3, const char *size_string, char *buf, int buflen)
2068     \conditions (defined(HAVE_ALBUMART))
2069     \param id3
2070     \param size_string
2071     \param buf Pointer to output
2072     \param buflen Max length for =buf=
2073     \return true if an album art was found
2074     \description Searches the the album art file for the given =id3= struct, appending the =size_string= to the search pattern (cover.bmp). It writes the complete path into =buf=, but not more bytes than =buflen=.
2076 void semaphore_init(struct semaphore *s, int max, int start)
2077     \conditions (defined(HAVE_SEMAPHORE_OBJECTS))
2078     \param s
2079     \param max
2080     \param start
2081     \description
2083 void semaphore_release(struct semaphore *s)
2084     \conditions (defined(HAVE_SEMAPHORE_OBJECTS))
2085     \param s
2086     \description
2088 void semaphore_wait(struct semaphore *s)
2089     \conditions (defined(HAVE_SEMAPHORE_OBJECTS))
2090     \param s
2091     \description
2093 const struct settings_list* find_setting(const void* variable, int *id)
2094     \group options
2095     \param variable
2096     \param id
2097     \return
2098     \description
2100 bool settings_parseline(char* line, char** name, char** value)
2101     \group file
2102     \param line
2103     \param name
2104     \param value
2105     \return false if no valid config entry was found
2106     \description Parse a line from a configuration file. The line format is: 'name: value'. Any whitespace before setting name or value (after ':') is ignored. A # as first non-whitespace character discards the whole line. Function sets pointers to null-terminated setting name and value.
2108 bool set_bool(const char* string, const bool* variable )
2109     \group options
2110     \param string
2111     \param variable
2112     \return
2113     \description
2115 bool set_bool_options(const char* string, const bool* variable, const char* yes_str, int yes_voice, const char* no_str, int no_voice, void (*function)(bool))
2116     \group options
2117     \param string
2118     \param variable
2119     \param yes_str
2120     \param yes_voice
2121     \param no_str
2122     \param no_voice
2123     \param function
2124     \return
2125     \description
2127 bool set_color(struct screen *display, char *title, unsigned *color, unsigned banned_color)
2128     \conditions (defined(HAVE_LCD_COLOR))
2129     \param display
2130     \param title
2131     \param color
2132     \param banned_color
2133     \return
2134     \description
2136 void set_current_file(char* path)
2137     \param path
2138     \description
2140 void set_dirfilter(int l_dirfilter)
2141     \param l_dirfilter
2142     \description
2144 bool set_int(const unsigned char* string, const char* unit, int voice_unit, const int* variable, void (*function)(int), int step, int min, int max, void (*formatter)(char*, size_t, int, const char*) )
2145     \group options
2146     \param string
2147     \param unit
2148     \param voice_unit
2149     \param variable
2150     \param function
2151     \param step
2152     \param min
2153     \param max
2154     \param formatter
2155     \return
2156     \description
2158 bool set_option(const char* string, const void* variable, enum optiontype type, const struct opt_items* options, int numoptions, void (*function)(int))
2159     \group options
2160     \param string
2161     \param variable
2162     \param type
2163     \param options
2164     \param numoptions
2165     \param function
2166     \return
2167     \description
2169 int set_time(const struct tm *tm)
2170     \group misc
2171     \param tm
2172     \return FALSE upon success
2173     \description Set current time
2174     \see get_time
2176 int show_logo(void)
2177     \return
2178     \description
2180 void simplelist_info_init(struct simplelist_info *info, char* title, int count, void* data)
2181     \group list
2182     \param info
2183     \param title
2184     \param count
2185     \param data
2186     \description
2188 bool simplelist_show_list(struct simplelist_info *info)
2189     \group list
2190     \param info
2191     \return
2192     \description
2194 void sim_lcd_ex_init(int shades, unsigned long (*getpixel)(int, int))
2195     \group special simulator hooks
2196     \conditions (defined(SIMULATOR)) && (defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8)
2197     \param shades
2198     \param getpixel
2199     \description
2201 void sim_lcd_ex_update_rect(int x, int y, int width, int height)
2202     \group special simulator hooks
2203     \conditions (defined(SIMULATOR)) && (defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8)
2204     \param x
2205     \param y
2206     \param width
2207     \param height
2208     \description
2210 int snprintf(char *buf, size_t size, const char *fmt, ...) ATTRIBUTE_PRINTF(3, 4)
2211     \group strings and memory
2212     \param buf
2213     \param size
2214     \param fmt
2215     \return the number of characters printed or that would have been printed if the output was truncated (not including the trailing NULL character) upon success
2216     \description Write a formatted string =fmt= in buffer =buf= of size =size= (including the trailing NULL character). These support %c, %s, %d and %x only with the width and zero padding flag only.
2218 int sound_default(int setting)
2219     \group sound
2220     \param setting
2221     \return
2222     \description
2224 int sound_max(int setting)
2225     \group sound
2226     \param setting
2227     \return
2228     \description
2230 int sound_min(int setting)
2231     \group sound
2232     \param setting
2233     \return
2234     \description
2236 void sound_set(int setting, int value)
2237     \group sound
2238     \param setting
2239     \param value
2240     \description
2242 void sound_set_pitch(int pitch)
2243     \group playback control
2244     \conditions ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) ||  (CONFIG_CODEC == SWCODEC))
2245     \param pitch
2246     \description
2248 const char * sound_unit(int setting)
2249     \group sound
2250     \param setting
2251     \return
2252     \description
2254 int sound_val2phys(int setting, int value)
2255     \group sound
2256     \param setting
2257     \param value
2258     \return
2259     \description
2261 void splash(int ticks, const char *str)
2262     \param ticks
2263     \param str
2264     \description Display a formatted string in a box for =ticks= time. The string is formatted as with the printf function. (there are =HZ= ticks per second)
2266 void splashf(int ticks, const char *fmt, ...) ATTRIBUTE_PRINTF(2, 3)
2267     \param ticks
2268     \param fmt
2269     \description
2271 void srand(unsigned int seed)
2272     \group misc
2273     \param seed
2274     \description Seed the random number generator
2276 struct gui_syncstatusbar *statusbars
2277     \group scroll bar
2278     \return
2279     \description
2281 int strcasecmp(const char *, const char *)
2282     \group strings and memory
2283     \param 
2284     \param 
2285     \return an integer less than, equal to, or greater than zero if s1 is found, respectively, to be less than, to match, or be greater than s2
2286     \description The  strcasecmp() function compares the two strings s1 and s2, ignoring the case of the characters
2288 char *strcat(char *s1, const char *s2)
2289     \group strings and memory
2290     \param s1
2291     \param s2
2292     \return =s1= concatenated with =s2=
2293     \description Appends =s2= to =s1=, replacing the NULL terminating character of =s1= and returns it
2295 char *strchr(const char *s, int c)
2296     \group strings and memory
2297     \param s
2298     \param c
2299     \return
2300     \description
2302 int strcmp(const char *, const char *)
2303     \group strings and memory
2304     \param 
2305     \param 
2306     \return
2307     \description strcmp() compares the string a to string b. If a sorts lexicographically after b, strcmp returns a number greater than zero. If the two strings match, strcmp returns zero. If a sorts lexicographically before b, strcmp returns a number less than zero.
2309 char* strcpy(char *dst, const char *src)
2310     \group strings and memory
2311     \param dst
2312     \param src
2313     \return the initial value of =dst=
2314     \description strcpy() copies the string pointed to by =src= (including the terminating null character) to the array pointed to by =dst=
2316 size_t strlen(const char *str)
2317     \group strings and memory
2318     \param str
2319     \return the character count
2320     \description The strlen() function works out the length of the string starting at =str= by counting characters until it reaches a null character.
2322 int strncasecmp(const char *s1, const char *s2, size_t n)
2323     \group strings and memory
2324     \param s1
2325     \param s2
2326     \param n
2327     \return
2328     \description Like strcasecmp() but only on the first =n= characters
2329     \see strcasecmp
2331 int strncmp(const char *, const char *, size_t)
2332     \group strings and memory
2333     \param 
2334     \param 
2335     \param size_t
2336     \return
2337     \description
2339 char* strncpy(char *dst, const char *src, size_t length)
2340     \group strings and memory
2341     \param dst
2342     \param src
2343     \param length
2344     \return the initial value of =dst=
2345     \description strncpy() copies not more than =length= characters from the string pointed to by =src= (including the terminating null character) to the array pointed to by =dst=. If the string pointed to by =src= is shorter than length characters, null characters are appended to the destination array until a total of =length= characters have been written.
2347 char * strrchr(const char *s, int c)
2348     \group strings and memory
2349     \param s
2350     \param c
2351     \return a pointer to the located character, or a null pointer if =c= does not occur in string.
2352     \description This function finds the last occurence of =c= (converted to a char) in the string pointed to by string (including the terminating null character)
2354 char* strtok_r(char *ptr, const char *sep, char **end)
2355     \group strings and memory
2356     \param ptr
2357     \param sep
2358     \param end
2359     \return
2360     \description
2362 int system_memory_guard(int newmode)
2363     \conditions (!defined(SIMULATOR))
2364     \param newmode
2365     \return
2366     \description
2368 bool tagcache_get_next(struct tagcache_search *tcs)
2369     \conditions (defined(HAVE_TAGCACHE))
2370     \param tcs
2371     \return
2372     \description
2374 long tagcache_get_numeric(const struct tagcache_search *tcs, int tag)
2375     \conditions (defined(HAVE_TAGCACHE))
2376     \param tcs
2377     \param tag
2378     \return
2379     \description
2381 bool tagcache_retrieve(struct tagcache_search *tcs, int idxid, int tag, char *buf, long size)
2382     \conditions (defined(HAVE_TAGCACHE))
2383     \param tcs
2384     \param idxid
2385     \param tag
2386     \param buf
2387     \param size
2388     \return
2389     \description
2391 bool tagcache_search(struct tagcache_search *tcs, int tag)
2392     \conditions (defined(HAVE_TAGCACHE))
2393     \param tcs
2394     \param tag
2395     \return
2396     \description
2398 bool tagcache_search_add_filter(struct tagcache_search *tcs, int tag, int seek)
2399     \conditions (defined(HAVE_TAGCACHE))
2400     \param tcs
2401     \param tag
2402     \param seek
2403     \return
2404     \description
2406 void tagcache_search_finish(struct tagcache_search *tcs)
2407     \conditions (defined(HAVE_TAGCACHE))
2408     \param tcs
2409     \description
2411 void tagcache_search_set_uniqbuf(struct tagcache_search *tcs, void *buffer, long length)
2412     \conditions (defined(HAVE_TAGCACHE))
2413     \param tcs
2414     \param buffer
2415     \param length
2416     \description
2418 void talk_disable(bool disable)
2419     \group misc
2420     \param disable
2421     \description
2423 struct thread_entry* threads
2424     \group kernel/ system
2425     \return
2426     \description
2428 void thread_exit(void)
2429     \group kernel/ system
2430     \description
2432 void thread_thaw(struct thread_entry *thread)
2433     \param thread
2434     \description
2436 void thread_wait(struct thread_entry *thread)
2437     \group kernel/ system
2438     \param thread
2439     \description
2441 bool timer_register(int reg_prio, void (*unregister_callback)(void), long cycles, int int_prio, void (*timer_callback)(void) IF_COP(, int core))
2442     \param reg_prio
2443     \param unregister_callback
2444     \param cycles
2445     \param int_prio
2446     \param core
2447     \param timer_callback
2448     \return
2449     \description
2451 bool timer_set_period(long count)
2452     \param count
2453     \return
2454     \description
2456 void timer_unregister(void)
2457     \description
2459 void touchscreen_set_mode(enum touchscreen_mode)
2460     \group button
2461     \conditions (defined(HAVE_TOUCHSCREEN))
2462     \param touchscreen_mode
2463     \description
2465 struct tree_context* tree_get_context(void)
2466     \return
2467     \description
2469 void trigger_cpu_boost(void)
2470     \conditions (defined(HAVE_SCHEDULER_BOOSTCTRL))
2471     \description Boosts the CPU for the current thread
2473 void unregister_ata_idle_func(ata_idle_notify function, bool run)
2474     \group file
2475     \conditions (USING_ATA_CALLBACK)
2476     \param function
2477     \param run
2478     \description
2480 void usb_acknowledge(long id)
2481     \param id
2482     \description
2484 bool usb_powered(void)
2485     \group power
2486     \conditions (defined(HAVE_USB_POWER))
2487     \return
2488     \description
2490 unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8)
2491     \group unicode stuff
2492     \param ucs
2493     \param utf8
2494     \return
2495     \description
2497 unsigned long utf8length(const unsigned char *utf8)
2498     \group unicode stuff
2499     \param utf8
2500     \return
2501     \description
2503 int utf8seek(const unsigned char* utf8, int offset)
2504     \group unicode stuff
2505     \param utf8
2506     \param offset
2507     \return
2508     \description
2510 unsigned char* utf16BEdecode(const unsigned char *utf16, unsigned char *utf8, int count)
2511     \group unicode stuff
2512     \param utf16
2513     \param utf8
2514     \param count
2515     \return
2516     \description
2518 unsigned char* utf16LEdecode(const unsigned char *utf16, unsigned char *utf8, int count)
2519     \group unicode stuff
2520     \param utf16
2521     \param utf8
2522     \param count
2523     \return
2524     \description
2526 void viewport_set_defaults(struct viewport *vp, enum screen_type screen)
2527     \param vp
2528     \param screen
2529     \description
2531 int vsnprintf(char *buf, int size, const char *fmt, va_list ap)
2532     \group strings and memory
2533     \param buf
2534     \param size
2535     \param fmt
2536     \param ap
2537     \return
2538     \description
2540 void wheel_send_events(bool send)
2541     \conditions (defined(HAVE_WHEEL_POSITION))
2542     \param send
2543     \description
2545 int wheel_status(void)
2546     \conditions (defined(HAVE_WHEEL_POSITION))
2547     \return
2548     \description
2550 void yield(void)
2551     \group kernel/ system
2552     \description Let another thread run. This should be used as soon as you have to "wait" for something or similar, and also if you do anything that takes "a long time". This function is the entire foundation that our "cooperative multitasking" is based on. Use it!
2553     \see [W[RockboxKernel]]
2555 # END