docs/PLUGIN_API.new

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