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 const char *appsversion
  43     \return version of the plugin API
  44     \description
  45
  46 void ata_sleep(void)
  47     \group file
  48     \description Give the disk some rest
  49
  50 void ata_spin(void)
  51     \group file
  52     \description
  53
  54 void ata_spindown(int seconds)
  55     \group file
  56     \param seconds
  57     \description
  58
  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
  64
  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]]
  70
  71 void audio_ff_rewind(long newtime)
  72     \group playback control
  73     \param newtime
  74     \description
  75
  76 void audio_flush_and_reload_tracks(void)
  77     \group playback control
  78     \description
  79
  80 int audio_get_file_pos(void)
  81     \group playback control
  82     \return
  83     \description
  84
  85 bool audio_has_changed_track(void)
  86     \group playback control
  87     \return
  88     \description
  89
  90 void audio_next(void)
  91     \group playback control
  92     \description
  93
  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]]
  99
 100 void audio_pause(void)
 101     \group playback control
 102     \description
 103
 104 void audio_prev(void)
 105     \group playback control
 106     \description
 107
 108 void audio_resume(void)
 109     \group playback control
 110     \description
 111
 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
 118
 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
 124
 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
 132
 133 int audio_status(void)
 134     \group playback control
 135     \return
 136     \description
 137
 138 void audio_stop(void)
 139     \group playback control
 140     \description
 141
 142 void backlight_off(void)
 143     \group backlight
 144     \description Turns the backlight off
 145
 146 void backlight_on(void)
 147     \group backlight
 148     \description Turns the backlight on
 149
 150 void backlight_set_brightness(int val)
 151     \group backlight
 152     \conditions (defined(HAVE_BACKLIGHT_BRIGHTNESS))
 153     \param val
 154     \description
 155
 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
 160
 161 void backlight_set_timeout_plugged(int index)
 162     \conditions (CONFIG_CHARGING)
 163     \param index
 164     \description
 165
 166 int battery_level(void)
 167     \group power
 168     \return battery level in percent
 169     \description On the simulator, battery_level is always 75
 170
 171 bool battery_level_safe(void)
 172     \group power
 173     \return
 174     \description
 175
 176 int battery_time(void)
 177     \group power
 178     \return
 179     \description
 180
 181 unsigned int battery_voltage(void)
 182     \group power
 183     \conditions (!defined(SIMULATOR))
 184     \return
 185     \description
 186
 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
 193
 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=
 200
 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
 208
 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
 217
 218 bool bufclose(int handle_id)
 219     \group buffering API
 220     \conditions ((CONFIG_CODEC == SWCODEC))
 221     \param handle_id
 222     \return
 223     \description
 224
 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
 232
 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
 241
 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
 250
 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
 259
 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
 268
 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
 276
 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
 283
 284 ssize_t buf_handle_offset(int handle_id)
 285     \conditions ((CONFIG_CODEC == SWCODEC))
 286     \param handle_id
 287     \return
 288     \description
 289
 290 void buf_request_buffer_handle(int handle_id)
 291     \conditions ((CONFIG_CODEC == SWCODEC))
 292     \param handle_id
 293     \description
 294
 295 void buf_set_base_handle(int handle_id)
 296     \conditions ((CONFIG_CODEC == SWCODEC))
 297     \param handle_id
 298     \description
 299
 300 size_t buf_used(void)
 301     \conditions ((CONFIG_CODEC == SWCODEC))
 302     \return
 303     \description
 304
 305 void buttonlight_off(void)
 306     \group button
 307     \conditions (defined(HAVE_BUTTON_LIGHT))
 308     \description
 309
 310 void buttonlight_on(void)
 311     \group button
 312     \conditions (defined(HAVE_BUTTON_LIGHT))
 313     \description
 314
 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
 320
 321 void buttonlight_set_timeout(int value)
 322     \group button
 323     \conditions (defined(HAVE_BUTTON_LIGHT))
 324     \param value
 325     \description
 326
 327 void button_clear_queue(void)
 328     \group button
 329     \description Empty the button queue
 330
 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
 336
 337 intptr_t button_get_data(void)
 338     \group button
 339     \conditions (defined(HAVE_BUTTON_DATA))
 340     \return
 341     \description
 342
 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)
 348
 349 bool button_hold(void)
 350     \group button
 351     \conditions (defined(HAS_BUTTON_HOLD))
 352     \return
 353     \description
 354
 355 struct event_queue *button_queue
 356     \conditions !defined(HAVE_LCD_CHARCELLS) )) && (defined(HAVE_LCD_ENABLE
 357     \return
 358     \description
 359
 360 int button_queue_count(void)
 361     \group button
 362     \return
 363     \description
 364
 365 int button_status(void)
 366     \group button
 367     \return a bitmask for which keys are currently pressed
 368     \description
 369
 370 void cancel_cpu_boost(void)
 371     \conditions (defined(HAVE_SCHEDULER_BOOSTCTRL))
 372     \description Unboosts the CPU for the current thread
 373
 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
 380
 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
 387
 388 const unsigned char *_ctype_
 389     \group strings and memory
 390     \return
 391     \description
 392
 393 bool charger_inserted(void)
 394     \group power
 395     \conditions (CONFIG_CHARGING)
 396     \return
 397     \description
 398
 399 bool charging_state(void)
 400     \group power
 401     \conditions (CONFIG_CHARGING) && (CONFIG_CHARGING == CHARGING_MONITOR)
 402     \return
 403     \description
 404
 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.
 410
 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
 418
 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
 427
 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
 432
 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
 439
 440 long *cpu_frequency
 441     \conditions (!defined(SIMULATOR))
 442     \return the current cpu frequency
 443     \description
 444
 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
 455
 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]]
 468
 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
 482
 483 volatile long* current_tick
 484     \group kernel/ system
 485     \return
 486     \description
 487
 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
 493
 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
 499
 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
 507
 508 bool detect_flashed_ramimage(void)
 509     \group Routines for the iriver_flash -plugin.
 510     \conditions (defined(IRIVER_H100_SERIES))
 511     \return
 512     \description
 513
 514 bool detect_flashed_romimage(void)
 515     \group Routines for the iriver_flash -plugin.
 516     \conditions (defined(IRIVER_H100_SERIES))
 517     \return
 518     \description
 519
 520 bool detect_original_firmware(void)
 521     \group Routines for the iriver_flash -plugin.
 522     \conditions (defined(IRIVER_H100_SERIES))
 523     \return
 524     \description
 525
 526 bool dir_exists(const char *path)
 527     \group dir
 528     \param path
 529     \return
 530     \description
 531
 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
 540
 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
 549
 550 void dsp_dither_enable(bool enable)
 551     \group sound
 552     \conditions (CONFIG_CODEC == SWCODEC)
 553     \param enable
 554     \description
 555
 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
 565
 566 void dsp_set_crossfeed(bool enable)
 567     \group sound
 568     \conditions (CONFIG_CODEC == SWCODEC)
 569     \param enable
 570     \description
 571
 572 void dsp_set_eq(bool enable)
 573     \group sound
 574     \conditions (CONFIG_CODEC == SWCODEC)
 575     \param enable
 576     \description
 577
 578 void event_init(struct event *e, unsigned int flags)
 579     \conditions (defined(HAVE_EVENT_OBJECTS))
 580     \param e
 581     \param flags
 582     \description
 583
 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
 589
 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
 595
 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=
 602
 603 bool file_exists(const char *file)
 604     \group file
 605     \param file
 606     \return
 607     \description
 608
 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
 616
 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
 625
 626 void flush_icache(void)
 627     \conditions (defined(CACHE_FUNCTIONS_AS_CALL))
 628     \description
 629
 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]]
 636
 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
 645
 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
 652
 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]]
 659
 660 int get_action(int context, int timeout)
 661     \group action handling
 662     \param context
 663     \param timeout
 664     \return
 665     \description
 666
 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
 673
 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
 681
 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
 690
 691 struct tm* get_time(void)
 692     \group misc
 693     \return current time
 694     \description
 695     \see [S[firmware/include/time.h]]
 696
 697 struct user_settings* global_settings
 698     \group misc
 699     \return the global_settings struct
 700     \description
 701     \see [S[apps/settings.h]]
 702
 703 struct system_status *global_status
 704     \group misc
 705     \return the global_status struct
 706     \description
 707     \see [S[apps/settings.h]]
 708
 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
 721
 722 void gui_synclist_add_item(struct gui_synclist * lists)
 723     \group list
 724     \param lists
 725     \description
 726
 727 void gui_synclist_del_item(struct gui_synclist * lists)
 728     \group list
 729     \param lists
 730     \description
 731
 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
 739
 740 void gui_synclist_draw(struct gui_synclist * lists)
 741     \group list
 742     \param lists
 743     \description
 744
 745 int gui_synclist_get_nb_items(struct gui_synclist * lists)
 746     \group list
 747     \param lists
 748     \return
 749     \description
 750
 751 int gui_synclist_get_sel_pos(struct gui_synclist * lists)
 752     \group list
 753     \param lists
 754     \return
 755     \description
 756
 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
 766
 767 void gui_synclist_limit_scroll(struct gui_synclist * lists, bool scroll)
 768     \group list
 769     \param lists
 770     \param scroll
 771     \description
 772
 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
 778
 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
 784
 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
 790
 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
 797
 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]]
 804
 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
 812
 813 void i2c_begin(void)
 814     \group MAS communication
 815     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
 816     \description
 817
 818 void i2c_end(void)
 819     \group MAS communication
 820     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)) && ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F))
 821     \description
 822
 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
 831
 832 void invalidate_icache(void)
 833     \conditions (defined(CACHE_FUNCTIONS_AS_CALL))
 834     \description
 835
 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
 844
 845 bool is_backlight_on(bool ignore_always_off)
 846     \param ignore_always_off
 847     \return
 848     \description
 849
 850 int kbd_input(char* buffer, int buflen)
 851     \group misc
 852     \param buffer
 853     \param buflen
 854     \return 0 upon success, negative upon failure
 855     \description Prompt for a string to be stored in =buffer= which is of length =buflen=
 856
 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.
 866
 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
 879
 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
 889
 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
 902
 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
 914
 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
 925
 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
 938
 939 void lcd_clear_display(void)
 940     \group lcd
 941     \description Clears the LCD and the framebuffer
 942
 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=
 949
 950 void lcd_double_height(bool on)
 951     \group lcd
 952     \conditions (defined(HAVE_LCD_CHARCELLS))
 953     \param on
 954     \description
 955
 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
 964
 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
 971
 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
 980
 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
 989
 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]]
 996
 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=
1004
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
1011
1012 unsigned lcd_get_background(void)
1013     \group lcd
1014     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1015     \return
1016     \description
1017
1018 int lcd_get_drawmode(void)
1019     \group lcd
1020     \conditions !defined(HAVE_LCD_CHARCELLS)
1021     \return current LCD drawing mode
1022     \description
1023
1024 unsigned lcd_get_foreground(void)
1025     \group lcd
1026     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1027     \return
1028     \description
1029
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]]
1036
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
1044
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]]
1052
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
1062
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
1075
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=)
1083
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=
1090
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=)
1097
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.
1104
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
1114
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=
1123
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]]
1132
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
1141
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
1153
1154 void lcd_remote_clear_display(void)
1155     \group remote lcd
1156     \conditions (defined(HAVE_REMOTE_LCD))
1157     \description
1158
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
1167
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
1174
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
1183
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
1192
1193 fb_remote_data* lcd_remote_framebuffer
1194     \group remote lcd
1195     \conditions (defined(HAVE_REMOTE_LCD))
1196     \return
1197     \description
1198
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=
1207
1208 unsigned lcd_remote_get_background(void)
1209     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1210     \return
1211     \description
1212
1213 int lcd_remote_get_drawmode(void)
1214     \group remote lcd
1215     \conditions (defined(HAVE_REMOTE_LCD))
1216     \return
1217     \description
1218
1219 unsigned lcd_remote_get_foreground(void)
1220     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1221     \return
1222     \description
1223
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
1231
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
1241
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
1254
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
1262
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
1270
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
1278
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
1287
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
1296
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
1302
1303 void lcd_remote_set_background(unsigned background)
1304     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1305     \param background
1306     \description
1307
1308 void lcd_remote_set_contrast(int x)
1309     \group remote lcd
1310     \conditions (defined(HAVE_REMOTE_LCD))
1311     \param x
1312     \description
1313
1314 void lcd_remote_set_drawmode(int mode)
1315     \group remote lcd
1316     \conditions (defined(HAVE_REMOTE_LCD))
1317     \param mode
1318     \description
1319
1320 void lcd_remote_set_foreground(unsigned foreground)
1321     \conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1322     \param foreground
1323     \description
1324
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
1329
1330 void lcd_remote_update(void)
1331     \group remote lcd
1332     \conditions (defined(HAVE_REMOTE_LCD))
1333     \description
1334
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
1343
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
1351
1352 void lcd_remove_cursor(void)
1353     \group lcd
1354     \conditions (defined(HAVE_LCD_CHARCELLS))
1355     \description Remove the cursor from the screen
1356
1357 void lcd_setfont(int font)
1358     \group lcd
1359     \conditions !defined(HAVE_LCD_CHARCELLS)
1360     \param font
1361     \description Set default font
1362
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
1369
1370 void lcd_set_background(unsigned foreground)
1371     \group lcd
1372     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1373     \param foreground
1374     \description
1375
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=
1380
1381 void lcd_set_drawmode(int mode)
1382     \group lcd
1383     \conditions !defined(HAVE_LCD_CHARCELLS)
1384     \param mode
1385     \description
1386
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
1391
1392 void lcd_set_foreground(unsigned foreground)
1393     \group lcd
1394     \conditions !defined(HAVE_LCD_CHARCELLS)  && (LCD_DEPTH > 1)
1395     \param foreground
1396     \description
1397
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
1403
1404 void lcd_stop_scroll(void)
1405     \group lcd
1406     \description Stop all scrolling lines on the screen
1407
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=
1413
1414 void lcd_update(void)
1415     \group lcd
1416     \description Pushes LCD framebuffer changes to the LCD
1417
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.
1426
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
1434
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
1440
1441 void led(bool on)
1442     \param on
1443     \description
1444
1445 void logf(const char *fmt, ...) ATTRIBUTE_PRINTF(1, 2)
1446     \group misc
1447     \conditions (defined(ROCKBOX_HAS_LOGF))
1448     \param fmt
1449     \description
1450
1451 const unsigned long *audio_master_sampr_list
1452     \group sound
1453     \conditions (CONFIG_CODEC == SWCODEC)
1454     \return
1455     \description
1456
1457 const unsigned long *hw_freq_sampr
1458     \group sound
1459     \conditions (CONFIG_CODEC == SWCODEC)
1460     \return
1461     \description
1462
1463 const unsigned long *rec_freq_sampr
1464     \group sound
1465     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1466     \return
1467     \description
1468
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
1475
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
1483
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
1493
1494 int mas_readreg(int reg)
1495     \group MAS communication
1496     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1497     \param reg
1498     \return
1499     \description
1500
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
1510
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
1518
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
1526
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
1534
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=
1542
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
1550
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=
1558
1559 int mkdir(const char *name)
1560     \group dir
1561     \param name
1562     \return
1563     \description
1564
1565 time_t mktime(struct tm *t)
1566     \group misc
1567     \conditions (CONFIG_RTC)
1568     \param t
1569     \return
1570     \description
1571
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=
1578
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
1584
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
1592
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.
1598
1599 void mp3_play_stop(void)
1600     \group sound
1601     \conditions (!defined(SIMULATOR))
1602     \description Stops playback
1603
1604 unsigned long mpeg_get_last_header(void)
1605     \group playback control
1606     \conditions (!defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC))
1607     \return
1608     \description
1609
1610 void mutex_init(struct mutex *m)
1611     \group kernel/ system
1612     \conditions (CONFIG_CODEC == SWCODEC)
1613     \param m
1614     \description
1615
1616 void mutex_lock(struct mutex *m)
1617     \group kernel/ system
1618     \conditions (CONFIG_CODEC == SWCODEC)
1619     \param m
1620     \description
1621
1622 void mutex_unlock(struct mutex *m)
1623     \group kernel/ system
1624     \conditions (CONFIG_CODEC == SWCODEC)
1625     \param m
1626     \description
1627
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.
1633
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
1642
1643 void pcm_apply_settings(void)
1644     \group sound
1645     \conditions (CONFIG_CODEC == SWCODEC)
1646     \description
1647
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
1654
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
1661
1662 void pcm_close_recording(void)
1663     \group sound
1664     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1665     \description
1666
1667 size_t pcm_get_bytes_waiting(void)
1668     \group sound
1669     \conditions (CONFIG_CODEC == SWCODEC)
1670     \return
1671     \description
1672
1673 void pcm_init_recording(void)
1674     \group sound
1675     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1676     \description
1677
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
1683
1684 bool pcm_is_playing(void)
1685     \group sound
1686     \conditions (CONFIG_CODEC == SWCODEC)
1687     \return true unless playback is paused
1688     \description
1689
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.
1697
1698 void pcm_play_lock(void)
1699     \group sound
1700     \conditions (CONFIG_CODEC == SWCODEC)
1701     \description
1702
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=
1708
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]]
1713
1714 void pcm_play_unlock(void)
1715     \group sound
1716     \conditions (CONFIG_CODEC == SWCODEC)
1717     \description
1718
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
1726
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
1733
1734 void pcm_set_frequency(unsigned int frequency)
1735     \group sound
1736     \conditions (CONFIG_CODEC == SWCODEC)
1737     \param frequency
1738     \description
1739
1740 void pcm_stop_recording(void)
1741     \group sound
1742     \conditions (CONFIG_CODEC == SWCODEC) && (defined(HAVE_RECORDING))
1743     \description
1744
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
1749
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).
1756
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
1761
1762 int playlist_amount(void)
1763     \group playback control
1764     \return the number of tracks in current playlist
1765     \description
1766
1767 int playlist_resume(void)
1768     \group playback control
1769     \return
1770     \description
1771
1772 int playlist_start(int start_index, int offset)
1773     \group playback control
1774     \param start_index
1775     \param offset
1776     \return
1777     \description
1778
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
1784
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
1790
1791 char* plugin_get_current_filename(void)
1792     \group misc
1793     \return
1794     \description
1795
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
1805
1806 void plugin_tsr(bool (*exit_callback)(bool reenter))
1807     \group misc
1808     \param exit_callback
1809     \description
1810
1811 void PREFIX(audio_play)(long offset)
1812     \group playback control
1813     \param audio_play
1814     \param offset
1815     \description
1816
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.
1823
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
1830
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
1837
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=
1845
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=.
1854
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.
1862
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=
1871
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.
1878
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
1886
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
1892
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=
1901
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
1907
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
1913
1914 void profile_thread(void)
1915     \conditions (defined(RB_PROFILE))
1916     \description
1917
1918 void profstop(void)
1919     \conditions (defined(RB_PROFILE))
1920     \description
1921
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
1929
1930 void queue_delete(struct event_queue *q)
1931     \param q
1932     \description
1933
1934 bool queue_empty(const struct event_queue *q)
1935     \conditions (CONFIG_CODEC == SWCODEC)
1936     \param q
1937     \return
1938     \description
1939
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
1946
1947 void queue_init(struct event_queue *q, bool register_queue)
1948     \param q
1949     \param register_queue
1950     \description
1951
1952 void queue_post(struct event_queue *q, long id, intptr_t data)
1953     \param q
1954     \param id
1955     \param data
1956     \description
1957
1958 void queue_reply(struct event_queue *q, intptr_t retval)
1959     \conditions (CONFIG_CODEC == SWCODEC)
1960     \param q
1961     \param retval
1962     \description
1963
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
1971
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
1977
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
1983
1984 int rand(void)
1985     \group misc
1986     \return a pseudo random number between 0 and 0x7fffffff
1987     \description
1988
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
1994
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
2003
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.
2011
2012 void register_ata_idle_func(ata_idle_notify function)
2013     \group file
2014     \conditions (USING_ATA_CALLBACK)
2015     \param function
2016     \description
2017
2018 void reload_directory(void)
2019     \group file
2020     \description
2021
2022 void remote_backlight_off(void)
2023     \conditions (defined(HAVE_REMOTE_LCD))
2024     \description Turns the remote backlight off
2025
2026 void remote_backlight_on(void)
2027     \conditions (defined(HAVE_REMOTE_LCD))
2028     \description Turns the remote backlight on
2029
2030 void remote_backlight_set_timeout(int index)
2031     \conditions (defined(HAVE_REMOTE_LCD))
2032     \param index
2033     \description
2034
2035 void remote_backlight_set_timeout_plugged(int index)
2036     \conditions (defined(HAVE_REMOTE_LCD)) && (CONFIG_CHARGING)
2037     \param index
2038     \description
2039
2040 void reset_poweroff_timer(void)
2041     \description The function name pretty much says what it's supposed to do
2042
2043 int rmdir(const char *name)
2044     \group dir
2045     \param name
2046     \return
2047     \description
2048
2049 struct screen* screens[NB_SCREENS]
2050     \return
2051     \description
2052
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
2061
2062 void screen_dump_set_hook(void (*hook)(int fh))
2063     \conditions (defined(HAVE_LCD_BITMAP))
2064     \param hook
2065     \description
2066
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=.
2075
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
2082
2083 void semaphore_release(struct semaphore *s)
2084     \conditions (defined(HAVE_SEMAPHORE_OBJECTS))
2085     \param s
2086     \description
2087
2088 void semaphore_wait(struct semaphore *s)
2089     \conditions (defined(HAVE_SEMAPHORE_OBJECTS))
2090     \param s
2091     \description
2092
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
2099
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.
2107
2108 bool set_bool(const char* string, const bool* variable )
2109     \group options
2110     \param string
2111     \param variable
2112     \return
2113     \description
2114
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
2126
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
2135
2136 void set_current_file(char* path)
2137     \param path
2138     \description
2139
2140 void set_dirfilter(int l_dirfilter)
2141     \param l_dirfilter
2142     \description
2143
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
2157
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
2168
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
2175
2176 int show_logo(void)
2177     \return
2178     \description
2179
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
2187
2188 bool simplelist_show_list(struct simplelist_info *info)
2189     \group list
2190     \param info
2191     \return
2192     \description
2193
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
2200
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
2209
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.
2217
2218 int sound_default(int setting)
2219     \group sound
2220     \param setting
2221     \return
2222     \description
2223
2224 int sound_max(int setting)
2225     \group sound
2226     \param setting
2227     \return
2228     \description
2229
2230 int sound_min(int setting)
2231     \group sound
2232     \param setting
2233     \return
2234     \description
2235
2236 void sound_set(int setting, int value)
2237     \group sound
2238     \param setting
2239     \param value
2240     \description
2241
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
2247
2248 const char * sound_unit(int setting)
2249     \group sound
2250     \param setting
2251     \return
2252     \description
2253
2254 int sound_val2phys(int setting, int value)
2255     \group sound
2256     \param setting
2257     \param value
2258     \return
2259     \description
2260
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)
2265
2266 void splashf(int ticks, const char *fmt, ...) ATTRIBUTE_PRINTF(2, 3)
2267     \param ticks
2268     \param fmt
2269     \description
2270
2271 void srand(unsigned int seed)
2272     \group misc
2273     \param seed
2274     \description Seed the random number generator
2275
2276 struct gui_syncstatusbar *statusbars
2277     \group scroll bar
2278     \return
2279     \description
2280
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
2287
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
2294
2295 char *strchr(const char *s, int c)
2296     \group strings and memory
2297     \param s
2298     \param c
2299     \return
2300     \description
2301
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.
2308
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=
2315
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.
2321
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
2330
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
2338
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.
2346
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)
2353
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
2361
2362 int system_memory_guard(int newmode)
2363     \conditions (!defined(SIMULATOR))
2364     \param newmode
2365     \return
2366     \description
2367
2368 bool tagcache_get_next(struct tagcache_search *tcs)
2369     \conditions (defined(HAVE_TAGCACHE))
2370     \param tcs
2371     \return
2372     \description
2373
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
2380
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
2390
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
2397
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
2405
2406 void tagcache_search_finish(struct tagcache_search *tcs)
2407     \conditions (defined(HAVE_TAGCACHE))
2408     \param tcs
2409     \description
2410
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
2417
2418 void talk_disable(bool disable)
2419     \group misc
2420     \param disable
2421     \description
2422
2423 struct thread_entry* threads
2424     \group kernel/ system
2425     \return
2426     \description
2427
2428 void thread_exit(void)
2429     \group kernel/ system
2430     \description
2431
2432 void thread_thaw(struct thread_entry *thread)
2433     \param thread
2434     \description
2435
2436 void thread_wait(struct thread_entry *thread)
2437     \group kernel/ system
2438     \param thread
2439     \description
2440
2441 bool timer_register(int reg_prio, void (*unregister_callback)(void), long cycles, void (*timer_callback)(void) IF_COP(, int core))
2442     \param reg_prio
2443     \param unregister_callback
2444     \param cycles
2445     \param core
2446     \param timer_callback
2447     \return
2448     \description
2449
2450 bool timer_set_period(long count)
2451     \param count
2452     \return
2453     \description
2454
2455 void timer_unregister(void)
2456     \description
2457
2458 void touchscreen_set_mode(enum touchscreen_mode)
2459     \group button
2460     \conditions (defined(HAVE_TOUCHSCREEN))
2461     \param touchscreen_mode
2462     \description
2463
2464 struct tree_context* tree_get_context(void)
2465     \return
2466     \description
2467
2468 void trigger_cpu_boost(void)
2469     \conditions (defined(HAVE_SCHEDULER_BOOSTCTRL))
2470     \description Boosts the CPU for the current thread
2471
2472 void unregister_ata_idle_func(ata_idle_notify function, bool run)
2473     \group file
2474     \conditions (USING_ATA_CALLBACK)
2475     \param function
2476     \param run
2477     \description
2478
2479 void usb_acknowledge(long id)
2480     \param id
2481     \description
2482
2483 bool usb_powered(void)
2484     \group power
2485     \conditions (defined(HAVE_USB_POWER))
2486     \return
2487     \description
2488
2489 unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8)
2490     \group unicode stuff
2491     \param ucs
2492     \param utf8
2493     \return
2494     \description
2495
2496 unsigned long utf8length(const unsigned char *utf8)
2497     \group unicode stuff
2498     \param utf8
2499     \return
2500     \description
2501
2502 int utf8seek(const unsigned char* utf8, int offset)
2503     \group unicode stuff
2504     \param utf8
2505     \param offset
2506     \return
2507     \description
2508
2509 unsigned char* utf16BEdecode(const unsigned char *utf16, unsigned char *utf8, int count)
2510     \group unicode stuff
2511     \param utf16
2512     \param utf8
2513     \param count
2514     \return
2515     \description
2516
2517 unsigned char* utf16LEdecode(const unsigned char *utf16, unsigned char *utf8, int count)
2518     \group unicode stuff
2519     \param utf16
2520     \param utf8
2521     \param count
2522     \return
2523     \description
2524
2525 void viewport_set_defaults(struct viewport *vp, enum screen_type screen)
2526     \param vp
2527     \param screen
2528     \description
2529
2530 int vsnprintf(char *buf, int size, const char *fmt, va_list ap)
2531     \group strings and memory
2532     \param buf
2533     \param size
2534     \param fmt
2535     \param ap
2536     \return
2537     \description
2538
2539 void wheel_send_events(bool send)
2540     \conditions (defined(HAVE_WHEEL_POSITION))
2541     \param send
2542     \description
2543
2544 int wheel_status(void)
2545     \conditions (defined(HAVE_WHEEL_POSITION))
2546     \return
2547     \description
2548
2549 void yield(void)
2550     \group kernel/ system
2551     \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!
2552     \see [W[RockboxKernel]]
2553
2554 # END