push

.gitignore

@@ -0,0 +1,24 @@
+# normal ignores
+.*
+*~
+*.[ao]
+*.lo
+*.so
+tags
+cscope.out
+!.gitignore
+!.travis.yml
+!.github
+
+# top-level ignores
+/*.spec
+/config
+/config.mk
+/cmus
+/cmus-remote
+
+# Cygwin stuff
+*.exe
+/cmus.base
+/cmus.def
+/cmus.exp

AUTHORS

@@ -0,0 +1,69 @@
+Maintainers
+-----------
+Gregory Petrosyan <gregory.petrosyan@gmail.com>
+Jason Woofenden <jason@jasonwoof.com>
+
+Original Author
+---------------
+Timo Hirvonen <tihirvon@gmail.com>
+
+NOTE: This list is not complete.  Especially small changes/bug fixes may
+      not be listed here.  See the git repository for full list of
+      contributors.
+
+Credits
+-------
+original help window code and mad.charset option by Sergey Kuleshov
+<svyatogor@gentoo.org>
+
+artist/album mode idea and "display artist/album as a tree instead of two
+windows" idea from divxero <divxero@gmx.net>
+
+play queue idea and other misc ideas from Martin Stubenschrott
+<stubenschrott@gmx.net>
+
+original RPM spec file by Eugene Vlasov <eugene@ikz.ru>
+
+Claes Nästen <pekdon@gmail.com>
+  :seek command
+  --volume option for cmus-remote
+
+Frank Terbeck <ft@bewatermyfriend.org>
+  dynamic keybindings patch
+
+alex <pukpuk@gmx.de>
+  Sun output plugin
+  Tremor support for vorbis plugin
+  NetBSD and OpenBSD port
+  Various bug fixes
+
+Chun-Yu Shei <cshei@cs.indiana.edu>
+  mpc plugin
+  gapless MP3 playback
+
+Johannes Weißl <jargon@molb.org>
+  ao plugin
+
+Gregory Petrosyan <gregory.petrosyan@gmail.com>
+  PulseAudio output plugin
+
+Philipp 'ph3-der-loewe' Schafft <lion@lion.leolix.org>
+  RoarAudio output plugin
+
+Jason Woofenden <jason@jasonwoof.com>
+  Tutorial
+  cmus-unofficial patch-commiter
+
+Niko Efthymiou <nefthy-cmus@nefthy.de>
+  Jack plugin
+
+Tuncer Ayaz <tuncer.ayaz@gmail.com>
+  Opus input plugin
+
+Boris Timofeev <mashin87@gmail.com>
+  vtx plugin
+
+Yue Wang <yuleopen@gmail.com>
+  CoreAudio plugin
+
+Google Inc.

COPYING

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

Doc/cmus-remote.txt

@@ -0,0 +1,156 @@
+@title CMUS-REMOTE 1 05/11/2006 cmus
+
+@h1 NAME
+
+cmus-remote - control cmus
+
+
+@h1 SYNOPSIS
+
+cmus-remote [*OPTION*]... [`FILE`|`DIR`|`PLAYLIST`]...@br
+cmus-remote *-C* `COMMAND`...@br
+cmus-remote
+
+
+@h1 DESCRIPTION
+
+Add `FILE/DIR/PLAYLIST` to playlist, library (*-l*) or play queue (*-q*).
+
+If no arguments are given cmus-remote reads raw commands from stdin (one
+command per line).  Raw commands are cmus' command mode commands.  These same
+commands are used in configuration files and key bindings.  *cmus*(1) contains
+full list of commands.  For consistency also searching is supported:
+*-C /text*.
+
+If *-C* is given, all command line arguments are treated as raw commands.
+
+@h1 OPTIONS
+
+--server SOCKET
+	Connect using socket *SOCKET* instead of `$XDG_RUNTIME_DIR/cmus-socket`.
+
+--passwd PASSWD
+	password to use for TCP/IP connection
+
+--help
+	Display usage information and exit.
+
+--version
+	Display version information and exit.
+
+-p, --play
+	Start playing.
+
+-u, --pause
+	Toggle pause.
+
+-U, --pause-playback
+	Pause if currently playing.
+
+-s, --stop
+	Stop playing.
+
+-n, --next
+	Skip forward in playlist.
+
+-r, --prev
+	Skip backward in playlist.
+
+-R, --repeat
+	Toggle repeat.
+
+-S, --shuffle
+	Toggle shuffle.
+
+-v, --volume VOL
+	Change volume. See *vol* command in *cmus*(1).
+
+-k, --seek SEEK
+	Seek. See *seek* command in *cmus*(1).
+
+-f, --file FILE
+	Play from file.
+
+-Q
+	Get player status information.  Same as *-C status*.  Note that
+	*status* is a special command only available to cmus-remote.
+
+-l, --library
+	Modify library instead of playlist.
+
+-P, --playlist
+	Modify playlist (default).
+
+-q, --queue
+	Modify play queue instead of playlist.
+
+-c, --clear
+	Clear playlist, library (*-l*) or play queue (*-q*).
+
+-C, --raw
+	Treat arguments (instead of stdin) as raw commands.
+
+@h1 REMOTE COMMANDS
+
+Special commands only available to cmus-remote.
+
+status
+	Print information about currently playing track.
+
+format_print
+	Print arguments as `Format Strings`. Each argument starts a new line.
+
+@h1 EXAMPLES
+
+Add playlists/files/directories/URLs to library view (1 & 2):
+
+	@pre
+	$ cmus-remote -l music.m3u \\
+	http://live.urn1350.net:8080/urn_high.ogg
+	@endpre
+
+Load (clear and add) playlist to playlist view (3):
+
+	@pre
+	$ cmus-remote -c music.m3u
+	@endpre
+
+Three different ways to toggle repeat:
+
+	@pre
+	$ cmus-remote -R
+	$ cmus-remote -C "toggle repeat"
+	$ cmus-remote
+	toggle repeat
+	^D
+	@endpre
+
+Query settings or key bindings:
+
+	@pre
+	$ cmus-remote -C "set repeat?"
+	setting: 'repeat=false'
+	$ cmus-remote -C "showbind common a"
+	bind common a win-add-l
+	@endpre
+
+Dump the playlist to stdout:
+
+	@pre
+	$ cmus-remote -C "save -p -"
+	[...]
+	@endpre
+
+Search works too:
+
+	@pre
+	$ cmus-remote -C /beatles
+	@endpre
+
+@h1 SEE ALSO
+
+*cmus*(1)
+
+@h1 AUTHOR
+
+Written by Timo Hirvonen <tihirvon\@gmail.com>

Doc/cmus-tutorial.txt

@@ -0,0 +1,264 @@
+@title cmus-tutorial 7 14/02/2010 cmus
+
+
+@h1 NAME
+
+cmus - C\* Music Player tutorial
+
+
+@h1 CONTENTS
+
+Step 1: Starting Cmus
+
+Step 2: Adding Music
+
+Step 3: Playing Tracks From The Library
+
+Step 4: Managing The Queue
+
+Step 5: The Playlists
+
+Step 6: Find that track
+
+Step 7: Customization
+
+Step 8: Quit
+
+Step 9: Further Reading
+
+
+@h1 Step 1: Starting Cmus
+
+When you first launch cmus (just type `cmus` in a terminal and press Enter) it
+will open to the album/artist view, which looks something like this:
+
+@pre
++---------------------------------------------------------------------+
+| Library                    Empty (use :add)                         |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                                                                     |
+| . 00:00                                       library | 100% | C    |
+|                                                                     |
++---------------------------------------------------------------------+
+@endpre
+
+This is the view where your artists and albums will be displayed.
+
+
+@h1 Step 2: Adding Music
+
+Press *5* to switch to the file-browser view so we can add some music. You
+should see something like this:
+
+@pre
++---------------------------------------------------------------------+
+| Browser - /home/jasonwoof                                           |
+| ../                                                                 |
+| Desktop/                                                            |
+| MySqueak/                                                           |
+| audio-projects/                                                     |
+| audio/                                                              |
+| bin/                                                                |
+| config/                                                             |
+|                                                                     |
+| . 00:00                                       library | 100% | C    |
+|                                                                     |
++---------------------------------------------------------------------+
+@endpre
+
+Now, use the arrow keys, Enter and Backspace to navigate to where you have
+audio files stored. To add music to your cmus library, use the arrow keys to
+highlight a file or folder, and press *a*. When you press *a* cmus will move you
+to the next line down (so that it is easy to add a bunch of files/folders in a
+row) and start adding the file/folder you pressed *a* on to your library. This
+can take a while if you added a folder with a lot in it. As files are added,
+you will see the second time in the bottom right go up. This is the total
+duration of all the music in the cmus library.
+
+Note: cmus does not move, duplicate or change your files. It just remembers
+where they are and caches the metadata (duration, artist, etc.)
+
+Just to be on the safe side, let's save. Type *:save* and press Enter.
+
+Note: Cmus automatically saves your settings and library and everything when
+you quit, so you probably won't use the save command much.
+
+
+@h1 Step 3: Playing Tracks From The Library
+
+Press *2* to go to the simple library view. You should see something like
+this:
+
+@pre
++---------------------------------------------------------------------+
+| Library - 31 tracks (1:35:11) sorted by albumartist date album dis… |
+| Flying Lizards         . Money (That's What I Want)           02:31 |
+| Jason Woofenden        . VoR Theme                       2009 01:20 |
+| Keali'i Reichel      06. Wanting Memories                1994 04:28 |
+| Molly Lewis            . Tom Cruise Crazy                     03:13 |
+| NonMemory              . pista1                          2009 03:18 |
+| NonMemory            01. pista1                    2009-04-21 04:13 |
+| Ray Charles          06. Halleluja I Love Her So              02:33 |
+|                                                                     |
+| . 00:00                           artist from library | 100% | C    |
+|                                                                     |
++---------------------------------------------------------------------+
+@endpre
+
+Use the up and down arrow keys to select a track you'd like to hear, and press
+Enter to play it. Here are some keys to control playback:
+
+Press *c* to pause/unpause.
+Press right/left to seek by 10 seconds.
+Press *,*/*.* seek backwards/forwards one minute.
+Press *z* to play the previous track and *b* to play the next track.
+
+cmus has some great options to control what plays next (if anything) when the
+track ends. The state of these settings is shown in the bottom right corner.
+The first of these shows what collection of tracks we are playing (shown here
+as "artist from library"). Press *m* to cycle through the different options for
+this setting. To the right of that (past the volume) cmus shows the state of four
+toggles. Only toggles which are "on" are shown, so now we only see the *C*.
+Here are the toggles:
+
+[C]ontinue
+
+    If this is off, cmus will always stop at the end of the track. You can
+toggle this setting by pressing *shift-C*.
+
+[F]ollow
+
+    If this is on, cmus will select the currently playing track on track change.
+Press *f* to toggle this option.
+
+[R]epeat
+
+    If this is on (and continue is on), when cmus reaches the end of the group
+of tracks you're playing (selected with the *m* key) it will start again from
+the beginning. Press *r* to toggle this setting.
+
+[S]huffle or [&]lbum shuffle
+
+    If this is 'S', cmus will choose a random order to play all tracks once,
+while '&' will do the same for whole albums. Press *s* to toggle this option.
+
+
+@h1 Step 4: Managing The Queue
+
+Lets say you're listening to a song, and you want to select which song will
+play next, without interrupting the currently playing song. No problem! Just go
+to the song you want to hear next (in any of the views) and press *e*. The
+queue is FIFO, meaning if you queue up another track, it will play after the
+one you already had queued up.
+
+Note: The queue is not affected by the "shuffle" option described above.
+
+Press *4* to view/edit the queue. This view works and looks a lot like the
+simple library view. The main difference is that you can change the order of
+the tracks with the *p* and *P* keys. You can press *shift-D* to remove a track
+from the queue.
+
+When cmus is ready to play another track (it's reached the end of a track and
+the "continue" setting is on) it will remove the top entry from the queue and
+start playing it.
+
+
+@h1 Step 5: The Playlists
+
+The playlists work like another set of libraries (like view *2*) except that
+(like the queue) you manually set the order of the tracks. This can be quite
+useful if you want to create a mix of specific tracks or if you want to
+listen to an audio book without having the chapters play when you're playing
+from the library.
+
+The playlists are on view *3*. But before we go there, let's add some tracks.
+Press *2* to go to the simple library view, go to a track you want and press
+*y* to add it to a playlist. The only visual feedback you'll get that anything
+happened is that the highlight will move down one row. Add a few more so you
+have something to work with.
+
+Now press *3* to go to the playlist. You should see something like this:
+
+@pre
++---------------------------------------------------------------------+
+| Playlist                   Default                            11:32 |
+| * Default                | Flying Lizards     . Money (Th...  02:31 |
+|                          | Jason Woofenden    . VoR T... 2009 01:20 |
+|                          | Keali'i Reichel  06. Wanti... 1994 04:28 |
+|                          | Molly Lewis        . Tom Cruis...  03:13 |
+|                          |                                          |
+|                          |                                          |
+|                          |                                          |
+|                                                                     |
+| . 00:00                                       library | 100% | C    |
+|                                                                     |
++---------------------------------------------------------------------+
+@endpre
+
+Just like the queue, you can use the *p*, *P* and *D* keys to move and delete
+tracks from the playlist.
+
+Note: Changing the view (e.g. by pressing *3*) does not affect what cmus will
+play next. To put cmus into "play from the playlist" mode, press Enter on one
+of the tracks in the playlist. To switch modes without interrupting the
+currently-playing song, you can press *shift-M*.
+
+
+@h1 Step 6: Find that track
+
+This step shows various ways you can find track(s) you're looking for.
+
+Search: Press *2* to be sure you're on the simple library view, then press */*
+to start a search. Type a word or two from the track you're looking for. cmus
+will search for tracks that have all those words in them. Press enter to get
+the keyboard out of the search command, and *n* to find the next match.
+
+Tree View: Press *1* to select the tree view. Scroll to the artist, press
+*space* to show their albums, scroll to the album you want, then press tab so
+the keyboard controls the right column. Press tab again to get back to the left
+column.
+
+Filters: See the reference manual (see Further Reading below) for a detailed
+description on how to quickly (and temporarily) hide most of your music.
+
+
+@h1 Step 7: Customization
+
+Cmus has some very cool settings you can tweak, like changing the way tracks
+are displayed (e.g. to display disk numbers), enabling replaygain support or
+changing the keybindings.
+
+Press *7* for a quick overview of the current keybindings and settings.
+
+To change a setting or keybind, just select it (up/down keys) and press enter.
+This will put the command for the current setting in the command line (bottom
+left of your screen), which you can edit to put in a new value/key.
+
+Please see the reference manual (see Further Reading below) for a detailed
+description of all the commands and settings available.
+
+
+@h1 Step 8: Quit
+
+When you're done, type *:q* and press Enter to quit. This will save your
+settings, library, playlist and queue.
+
+
+@h1 Step 9: Further Reading
+
+Cmus comes with a great reference manual. Now that you've got the basics down
+it should be intelligible. Try *man cmus* in a terminal. If that's not
+installed, try opening up `cmus.txt` from the `Doc` directory, or read the latest
+version online:
+
+`https://github.com/cmus/cmus/blob/master/Doc/cmus.txt`
+
+There are more commands and features not covered here like loading and saving
+playlists, controlling cmus remotely with `cmus-remote`, etc.
+

Doc/ttman.c

@@ -0,0 +1,883 @@
+/*
+ * ttman - text to man converter
+ *
+ * Copyright 2006 Timo Hirvonen <tihirvon@gmail.com>
+ *
+ * This file is licensed under the GPLv2.
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+struct token {
+	struct token *next;
+	struct token *prev;
+	enum {
+		TOK_TEXT,	// max one line w/o \n
+		TOK_NL,		// \n
+		TOK_ITALIC,	// `
+		TOK_BOLD,	// *
+		TOK_INDENT,	// \t
+
+		// keywords (@...)
+		TOK_H1,
+		TOK_H2,
+		TOK_LI,
+		TOK_BR,
+		TOK_PRE,
+		TOK_ENDPRE,	// must be after TOK_PRE
+		TOK_RAW,
+		TOK_ENDRAW,	// must be after TOK_RAW
+		TOK_TITLE,	// WRITE 2 2001-12-13 "Linux 2.0.32" "Linux Programmer's Manual"
+	} type;
+	int line;
+
+	// not NUL-terminated
+	const char *text;
+	// length of text
+	int len;
+};
+
+static const char *program;
+static const char *filename;
+static char tmp_file[1024];
+static FILE *outfile;
+static int cur_line = 1;
+static struct token head = { &head, &head, TOK_TEXT, 0, NULL, 0 };
+
+#define CONST_STR(str) { str, sizeof(str) - 1 }
+static const struct {
+	const char *str;
+	int len;
+} token_names[] = {
+	CONST_STR("text"),
+	CONST_STR("nl"),
+	CONST_STR("italic"),
+	CONST_STR("bold"),
+	CONST_STR("indent"),
+
+	// keywords
+	CONST_STR("h1"),
+	CONST_STR("h2"),
+	CONST_STR("li"),
+	CONST_STR("br"),
+	CONST_STR("pre"),
+	CONST_STR("endpre"),
+	CONST_STR("raw"),
+	CONST_STR("endraw"),
+	CONST_STR("title")
+};
+#define NR_TOKEN_NAMES (sizeof(token_names) / sizeof(token_names[0]))
+#define BUG() die("BUG in %s\n", __FUNCTION__)
+
+#ifdef __GNUC__
+#define CMUS_NORETURN	__attribute__((__noreturn__))
+#else
+#define CMUS_NORETURN
+#endif
+
+static CMUS_NORETURN void quit(void)
+{
+	if (tmp_file[0])
+		unlink(tmp_file);
+	exit(1);
+}
+
+static CMUS_NORETURN void die(const char *format, ...)
+{
+	va_list ap;
+
+	fprintf(stderr, "%s: ", program);
+	va_start(ap, format);
+	vfprintf(stderr, format, ap);
+	va_end(ap);
+	quit();
+}
+
+static CMUS_NORETURN void syntax(int line, const char *format, ...)
+{
+	va_list ap;
+
+	fprintf(stderr, "%s:%d: error: ", filename, line);
+	va_start(ap, format);
+	vfprintf(stderr, format, ap);
+	va_end(ap);
+	quit();
+}
+
+static inline const char *keyword_name(int type)
+{
+	if (type < TOK_H1 || type > TOK_TITLE)
+		die("BUG: no keyword name for type %d\n", type);
+	return token_names[type].str;
+}
+
+static void *xmalloc(size_t size)
+{
+	void *ret = malloc(size);
+
+	if (!ret)
+		die("OOM when allocating %ul bytes\n", size);
+	return ret;
+}
+
+static char *memdup(const char *str, int len)
+{
+	char *s = xmalloc(len + 1);
+	memcpy(s, str, len);
+	s[len] = 0;
+	return s;
+}
+
+static struct token *new_token(int type)
+{
+	struct token *tok = xmalloc(sizeof(struct token));
+
+	tok->prev = NULL;
+	tok->next = NULL;
+	tok->type = type;
+	tok->line = cur_line;
+	return tok;
+}
+
+static void free_token(struct token *tok)
+{
+	struct token *prev = tok->prev;
+	struct token *next = tok->next;
+
+	if (tok == &head)
+		BUG();
+
+	prev->next = next;
+	next->prev = prev;
+	free(tok);
+}
+
+static void emit_token(struct token *tok)
+{
+	tok->prev = head.prev;
+	tok->next = &head;
+	head.prev->next = tok;
+	head.prev = tok;
+}
+
+static void emit(int type)
+{
+	struct token *tok = new_token(type);
+	tok->len = 0;
+	tok->text = NULL;
+	emit_token(tok);
+}
+
+static int emit_keyword(const char *buf, int size)
+{
+	int i, len;
+
+	for (len = 0; len < size; len++) {
+		if (!isalnum((unsigned char)buf[len]))
+			break;
+	}
+
+	if (!len)
+		syntax(cur_line, "keyword expected\n");
+
+	for (i = TOK_H1; i < NR_TOKEN_NAMES; i++) {
+		if (len != token_names[i].len)
+			continue;
+		if (!strncmp(buf, token_names[i].str, len)) {
+			emit(i);
+			return len;
+		}
+	}
+	syntax(cur_line, "invalid keyword '@%s'\n", memdup(buf, len));
+}
+
+static int emit_text(const char *buf, int size)
+{
+	struct token *tok;
+	int i;
+
+	for (i = 0; i < size; i++) {
+		int c = buf[i];
+		if (c == '@' || c == '`' || c == '*' || c == '\n' || c == '\\' || c == '\t')
+			break;
+	}
+	tok = new_token(TOK_TEXT);
+	tok->text = buf;
+	tok->len = i;
+	emit_token(tok);
+	return i;
+}
+
+static void tokenize(const char *buf, int size)
+{
+	int pos = 0;
+
+	while (pos < size) {
+		struct token *tok;
+		int ch;
+
+		ch = buf[pos++];
+		switch (ch) {
+		case '@':
+			pos += emit_keyword(buf + pos, size - pos);
+			break;
+		case '`':
+			emit(TOK_ITALIC);
+			break;
+		case '*':
+			emit(TOK_BOLD);
+			break;
+		case '\n':
+			emit(TOK_NL);
+			cur_line++;
+			break;
+		case '\t':
+			emit(TOK_INDENT);
+			break;
+		case '\\':
+			tok = new_token(TOK_TEXT);
+			tok->text = buf + pos;
+			tok->len = 1;
+			pos++;
+			if (pos == size || buf[pos] == '\n') {
+				// just one '\\'
+				tok->text--;
+			}
+
+			if (tok->text[0] == '\\') {
+				tok->text = "\\\\";
+				tok->len = 2;
+			}
+
+			emit_token(tok);
+			break;
+		default:
+			pos--;
+			pos += emit_text(buf + pos, size - pos);
+			break;
+		}
+	}
+}
+
+static int is_empty_line(const struct token *tok)
+{
+	while (tok != &head) {
+		int i;
+
+		switch (tok->type) {
+		case TOK_TEXT:
+			for (i = 0; i < tok->len; i++) {
+				if (tok->text[i] != ' ')
+					return 0;
+			}
+			break;
+		case TOK_INDENT:
+			break;
+		case TOK_NL:
+			return 1;
+		default:
+			return 0;
+		}
+		tok = tok->next;
+	}
+	return 1;
+}
+
+static struct token *remove_line(struct token *tok)
+{
+	while (tok != &head) {
+		struct token *next = tok->next;
+		int type = tok->type;
+
+		free_token(tok);
+		tok = next;
+		if (type == TOK_NL)
+			break;
+	}
+	return tok;
+}
+
+static struct token *skip_after(struct token *tok, int type)
+{
+	struct token *save = tok;
+
+	while (tok != &head) {
+		if (tok->type == type) {
+			tok = tok->next;
+			if (tok->type != TOK_NL)
+				syntax(tok->line, "newline expected after @%s\n",
+						keyword_name(type));
+			return tok->next;
+		}
+		if (tok->type >= TOK_H1)
+			syntax(tok->line, "keywords not allowed betweed @%s and @%s\n",
+					keyword_name(type-1), keyword_name(type));
+		tok = tok->next;
+	}
+	syntax(save->prev->line, "missing @%s\n", keyword_name(type));
+}
+
+static struct token *get_next_line(struct token *tok)
+{
+	while (tok != &head) {
+		int type = tok->type;
+
+		tok = tok->next;
+		if (type == TOK_NL)
+			break;
+	}
+	return tok;
+}
+
+static struct token *get_indent(struct token *tok, int *ip)
+{
+	int i = 0;
+
+	while (tok != &head && tok->type == TOK_INDENT) {
+		tok = tok->next;
+		i++;
+	}
+	*ip = i;
+	return tok;
+}
+
+// line must be non-empty
+static struct token *check_line(struct token *tok, int *ip)
+{
+	struct token *start;
+	int tok_type;
+
+	start = tok = get_indent(tok, ip);
+
+	tok_type = tok->type;
+	switch (tok_type) {
+	case TOK_TEXT:
+	case TOK_BOLD:
+	case TOK_ITALIC:
+	case TOK_BR:
+		tok = tok->next;
+		while (tok != &head) {
+			switch (tok->type) {
+			case TOK_TEXT:
+			case TOK_BOLD:
+			case TOK_ITALIC:
+			case TOK_BR:
+			case TOK_INDENT:
+				break;
+			case TOK_NL:
+				return start;
+			default:
+				syntax(tok->line, "@%s not allowed inside paragraph\n",
+						keyword_name(tok->type));
+			}
+			tok = tok->next;
+		}
+		break;
+	case TOK_H1:
+	case TOK_H2:
+	case TOK_TITLE:
+		if (*ip)
+			goto indentation;
+
+		// check arguments
+		tok = tok->next;
+		while (tok != &head) {
+			switch (tok->type) {
+			case TOK_TEXT:
+			case TOK_INDENT:
+				break;
+			case TOK_NL:
+				return start;
+			default:
+				syntax(tok->line, "@%s can contain only text\n",
+						keyword_name(tok_type));
+			}
+			tok = tok->next;
+		}
+		break;
+	case TOK_LI:
+		// check arguments
+		tok = tok->next;
+		while (tok != &head) {
+			switch (tok->type) {
+			case TOK_TEXT:
+			case TOK_BOLD:
+			case TOK_ITALIC:
+			case TOK_INDENT:
+				break;
+			case TOK_NL:
+				return start;
+			default:
+				syntax(tok->line, "@%s not allowed inside @li\n",
+						keyword_name(tok->type));
+			}
+			tok = tok->next;
+		}
+		break;
+	case TOK_PRE:
+		// checked later
+		break;
+	case TOK_RAW:
+		if (*ip)
+			goto indentation;
+		// checked later
+		break;
+	case TOK_ENDPRE:
+	case TOK_ENDRAW:
+		syntax(tok->line, "@%s not expected\n", keyword_name(tok->type));
+		break;
+	case TOK_NL:
+	case TOK_INDENT:
+		BUG();
+		break;
+	}
+	return start;
+indentation:
+	syntax(tok->line, "indentation before @%s\n", keyword_name(tok->type));
+}
+
+static void insert_nl_before(struct token *next)
+{
+	struct token *prev = next->prev;
+	struct token *new = new_token(TOK_NL);
+
+	new->prev = prev;
+	new->next = next;
+	prev->next = new;
+	next->prev = new;
+}
+
+static void normalize(void)
+{
+	struct token *tok = head.next;
+	/*
+	 * >= 0 if previous line was text (== amount of indent)
+	 *   -1 if previous block was @pre (amount of indent doesn't matter)
+	 *   -2 otherwise (@h1 etc., indent was 0)
+	 */
+	int prev_indent = -2;
+
+	while (tok != &head) {
+		struct token *start;
+		int i, new_para = 0;
+
+		// remove empty lines
+		while (is_empty_line(tok)) {
+			tok = remove_line(tok);
+			new_para = 1;
+			if (tok == &head)
+				return;
+		}
+
+		// skips indent
+		start = tok;
+		tok = check_line(tok, &i);
+
+		switch (tok->type) {
+		case TOK_TEXT:
+		case TOK_ITALIC:
+		case TOK_BOLD:
+		case TOK_BR:
+			// normal text
+			if (new_para && prev_indent >= -1) {
+				// previous line/block was text or @pre
+				// and there was a empty line after it
+				insert_nl_before(start);
+			}
+
+			if (!new_para && prev_indent == i) {
+				// join with previous line
+				struct token *nl = start->prev;
+
+				if (nl->type != TOK_NL)
+					BUG();
+
+				if ((nl->prev != &head && nl->prev->type == TOK_BR) ||
+						tok->type == TOK_BR) {
+					// don't convert \n after/before @br to ' '
+					free_token(nl);
+				} else {
+					// convert "\n" to " "
+					nl->type = TOK_TEXT;
+					nl->text = " ";
+					nl->len = 1;
+				}
+
+				// remove indent
+				while (start->type == TOK_INDENT) {
+					struct token *next = start->next;
+					free_token(start);
+					start = next;
+				}
+			}
+
+			prev_indent = i;
+			tok = get_next_line(tok);
+			break;
+		case TOK_PRE:
+		case TOK_RAW:
+			// these can be directly after normal text
+			// but not joined with the previous line
+			if (new_para && prev_indent >= -1) {
+				// previous line/block was text or @pre
+				// and there was a empty line after it
+				insert_nl_before(start);
+			}
+			tok = skip_after(tok->next, tok->type + 1);
+			prev_indent = -1;
+			break;
+		case TOK_H1:
+		case TOK_H2:
+		case TOK_LI:
+		case TOK_TITLE:
+			// remove white space after H1, H2, L1 and TITLE
+			tok = tok->next;
+			while (tok != &head) {
+				int type = tok->type;
+				struct token *next;
+
+				if (type == TOK_TEXT) {
+					while (tok->len && *tok->text == ' ') {
+						tok->text++;
+						tok->len--;
+					}
+					if (tok->len)
+						break;
+				}
+				if (type != TOK_INDENT)
+					break;
+
+				// empty TOK_TEXT or TOK_INDENT
+				next = tok->next;
+				free_token(tok);
+				tok = next;
+			}
+			// not normal text. can't be joined
+			prev_indent = -2;
+			tok = get_next_line(tok);
+			break;
+		case TOK_NL:
+		case TOK_INDENT:
+		case TOK_ENDPRE:
+		case TOK_ENDRAW:
+			BUG();
+			break;
+		}
+	}
+}
+
+#define output(...) fprintf(outfile, __VA_ARGS__)
+
+static void output_buf(const char *buf, int len)
+{
+	fwrite(buf, 1, len, outfile);
+}
+
+static void output_text(struct token *tok)
+{
+	char buf[1024];
+	const char *str = tok->text;
+	int len = tok->len;
+	int pos = 0;
+
+	while (len) {
+		int c = *str++;
+
+		if (pos >= sizeof(buf) - 1) {
+			output_buf(buf, pos);
+			pos = 0;
+		}
+		if (c == '-')
+			buf[pos++] = '\\';
+		buf[pos++] = c;
+		len--;
+	}
+
+	if (pos)
+		output_buf(buf, pos);
+}
+
+static int bold = 0;
+static int italic = 0;
+static int indent = 0;
+
+static struct token *output_pre(struct token *tok)
+{
+	int bol = 1;
+
+	if (tok->type != TOK_NL)
+		syntax(tok->line, "newline expected after @pre\n");
+
+	output(".nf\n");
+	tok = tok->next;
+	while (tok != &head) {
+		if (bol) {
+			int i;
+
+			tok = get_indent(tok, &i);
+			if (i != indent && tok->type != TOK_NL)
+				syntax(tok->line, "indent changed in @pre\n");
+		}
+
+		switch (tok->type) {
+		case TOK_TEXT:
+			if (bol && tok->len && tok->text[0] == '.')
+				output("\\&");
+			output_text(tok);
+			break;
+		case TOK_NL:
+			output("\n");
+			bol = 1;
+			tok = tok->next;
+			continue;
+		case TOK_ITALIC:
+			output("`");
+			break;
+		case TOK_BOLD:
+			output("*");
+			break;
+		case TOK_INDENT:
+			// FIXME: warn
+			output(" ");
+			break;
+		case TOK_ENDPRE:
+			output(".fi\n");
+			tok = tok->next;
+			if (tok != &head && tok->type == TOK_NL)
+				tok = tok->next;
+			return tok;
+		default:
+			BUG();
+			break;
+		}
+		bol = 0;
+		tok = tok->next;
+	}
+	return tok;
+}
+
+static struct token *output_raw(struct token *tok)
+{
+	if (tok->type != TOK_NL)
+		syntax(tok->line, "newline expected after @raw\n");
+
+	tok = tok->next;
+	while (tok != &head) {
+		switch (tok->type) {
+		case TOK_TEXT:
+			if (tok->len == 2 && !strncmp(tok->text, "\\\\", 2)) {
+				/* ugly special case
+				 * "\\" (\) was converted to "\\\\" (\\) because
+				 * nroff does escaping too.
+				 */
+				output("\\");
+			} else {
+				output_buf(tok->text, tok->len);
+			}
+			break;
+		case TOK_NL:
+			output("\n");
+			break;
+		case TOK_ITALIC:
+			output("`");
+			break;
+		case TOK_BOLD:
+			output("*");
+			break;
+		case TOK_INDENT:
+			output("\t");
+			break;
+		case TOK_ENDRAW:
+			tok = tok->next;
+			if (tok != &head && tok->type == TOK_NL)
+				tok = tok->next;
+			return tok;
+		default:
+			BUG();
+			break;
+		}
+		tok = tok->next;
+	}
+	return tok;
+}
+
+static struct token *output_para(struct token *tok)
+{
+	int bol = 1;
+
+	while (tok != &head) {
+		switch (tok->type) {
+		case TOK_TEXT:
+			output_text(tok);
+			break;
+		case TOK_ITALIC:
+			italic ^= 1;
+			if (italic) {
+				output("\\fI");
+			} else {
+				output("\\fR");
+			}
+			break;
+		case TOK_BOLD:
+			bold ^= 1;
+			if (bold) {
+				output("\\fB");
+			} else {
+				output("\\fR");
+			}
+			break;
+		case TOK_BR:
+			if (bol) {
+				output(".br\n");
+			} else {
+				output("\n.br\n");
+			}
+			bol = 1;
+			tok = tok->next;
+			continue;
+		case TOK_NL:
+			output("\n");
+			return tok->next;
+		case TOK_INDENT:
+			output(" ");
+			break;
+		default:
+			BUG();
+			break;
+		}
+		bol = 0;
+		tok = tok->next;
+	}
+	return tok;
+}
+
+static struct token *title(struct token *tok, const char *cmd)
+{
+	output("%s", cmd);
+	return output_para(tok->next);
+}
+
+static struct token *dump_one(struct token *tok)
+{
+	int i;
+
+	tok = get_indent(tok, &i);
+	if (tok->type != TOK_RAW) {
+		while (indent < i) {
+			output(".RS\n");
+			indent++;
+		}
+		while (indent > i) {
+			output(".RE\n");
+			indent--;
+		}
+	}
+
+	switch (tok->type) {
+	case TOK_TEXT:
+	case TOK_ITALIC:
+	case TOK_BOLD:
+	case TOK_BR:
+		if (tok->type == TOK_TEXT && tok->len && tok->text[0] == '.')
+			output("\\&");
+		tok = output_para(tok);
+		break;
+	case TOK_H1:
+		tok = title(tok, ".SH ");
+		break;
+	case TOK_H2:
+		tok = title(tok, ".SS ");
+		break;
+	case TOK_LI:
+		tok = title(tok, ".TP\n");
+		break;
+	case TOK_PRE:
+		tok = output_pre(tok->next);
+		break;
+	case TOK_RAW:
+		tok = output_raw(tok->next);
+		break;
+	case TOK_TITLE:
+		tok = title(tok, ".TH ");
+		// must be after .TH
+		// no hyphenation, adjust left
+		output(".nh\n.ad l\n");
+		break;
+	case TOK_NL:
+		output("\n");
+		tok = tok->next;
+		break;
+	case TOK_ENDPRE:
+	case TOK_ENDRAW:
+	case TOK_INDENT:
+		BUG();
+		break;
+	}
+	return tok;
+}
+
+static void dump(void)
+{
+	struct token *tok = head.next;
+
+	while (tok != &head)
+		tok = dump_one(tok);
+}
+
+static void process(void)
+{
+	struct stat s = {};
+	const char *buf;
+	int fd;
+
+	fd = open(filename, O_RDONLY);
+	if (fd == -1)
+		die("opening `%s' for reading: %s\n", filename, strerror(errno));
+	fstat(fd, &s);
+	if (s.st_size) {
+		buf = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+		if (buf == MAP_FAILED)
+			die("mmap: %s\n", strerror(errno));
+
+		tokenize(buf, s.st_size);
+		normalize();
+	}
+	close(fd);
+	dump();
+}
+
+int main(int argc, char *argv[])
+{
+	const char *dest;
+	int fd;
+
+	program = argv[0];
+	if (argc != 3) {
+		fprintf(stderr, "Usage: %s <in> <out>\n", program);
+		return 1;
+	}
+	filename = argv[1];
+	dest = argv[2];
+
+	snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", dest);
+	fd = mkstemp(tmp_file);
+	if (fd < 0)
+		die("creating %s: %s\n", tmp_file, strerror(errno));
+	outfile = fdopen(fd, "w");
+	if (!outfile)
+		die("opening %s: %s\n", tmp_file, strerror(errno));
+
+	process();
+	if (rename(tmp_file, dest))
+		die("renaming %s to %s: %s\n", tmp_file, dest, strerror(errno));
+	return 0;
+}

Makefile

@@ -0,0 +1,307 @@
+REV	= HEAD
+
+# version from an annotated tag
+_ver0	= $(shell git describe $(REV) 2>/dev/null)
+# version from a plain tag
+_ver1	= $(shell git describe --tags $(REV) 2>/dev/null)
+# SHA1
+_ver2	= $(shell git rev-parse --verify --short $(REV) 2>/dev/null)
+# hand-made
+_ver3	= v2.12.0
+
+VERSION	= $(or $(_ver0),$(_ver1),$(_ver2),$(_ver3))
+
+all: main plugins man
+
+-include config.mk
+include scripts/lib.mk
+
+CFLAGS += -D_FILE_OFFSET_BITS=64
+
+CMUS_LIBS = $(PTHREAD_LIBS) $(NCURSES_LIBS) $(ICONV_LIBS) $(DL_LIBS) $(DISCID_LIBS) \
+			-lm $(COMPAT_LIBS) $(LIBSYSTEMD_LIBS)
+
+command_mode.o input.o main.o ui_curses.o op/pulse.lo: .version
+command_mode.o input.o main.o ui_curses.o op/pulse.lo: CFLAGS += -DVERSION=\"$(VERSION)\"
+main.o server.o: CFLAGS += -DDEFAULT_PORT=3000
+discid.o: CFLAGS += $(DISCID_CFLAGS)
+mpris.o: CFLAGS += $(LIBSYSTEMD_CFLAGS)
+
+.version: Makefile
+	@test "`cat $@ 2> /dev/null`" = "$(VERSION)" && exit 0; \
+	echo "   GEN    $@"; echo $(VERSION) > $@
+
+# programs {{{
+cmus-y := \
+	ape.o browser.o buffer.o cache.o channelmap.o cmdline.o cmus.o command_mode.o \
+	comment.o convert.lo cue.o cue_utils.o debug.o discid.o editable.o expr.o \
+	filters.o format_print.o gbuf.o glob.o help.o history.o http.o id3.o input.o \
+	job.o keys.o keyval.o lib.o load_dir.o locking.o mergesort.o misc.o options.o \
+	output.o pcm.o player.o play_queue.o pl.o pl_env.o rbtree.o read_wrapper.o \
+	search_mode.o search.o server.o spawn.o tabexp_file.o tabexp.o track_info.o \
+	track.o tree.o uchar.o u_collate.o ui_curses.o window.o worker.o xstrjoin.o
+
+cmus-$(CONFIG_MPRIS) += mpris.o
+
+$(cmus-y): CFLAGS += $(PTHREAD_CFLAGS) $(NCURSES_CFLAGS) $(ICONV_CFLAGS) $(DL_CFLAGS)
+
+cmus: $(cmus-y) file.o path.o prog.o xmalloc.o
+	$(call cmd,ld,$(CMUS_LIBS))
+
+cmus-remote: main.o file.o misc.o path.o prog.o xmalloc.o xstrjoin.o
+	$(call cmd,ld,$(COMPAT_LIBS))
+
+# cygwin compat
+DLLTOOL=dlltool
+
+libcmus-$(CONFIG_CYGWIN) := libcmus.a
+
+libcmus.a: $(cmus-y) file.o path.o prog.o xmalloc.o
+	$(LD) -shared -o cmus.exe -Wl,--out-implib=libcmus.a -Wl,--base-file,cmus.base \
+		-Wl,--export-all-symbols -Wl,--no-whole-archive $^ $(CMUS_LIBS)
+	$(DLLTOOL) --output-def cmus.def --dllname cmus.exe --export-all-symbols $^
+	$(DLLTOOL) --base-file cmus.base --dllname cmus.exe --input-def cmus.def --output-exp cmus.exp
+	$(LD) -o cmus.exe -Wl,cmus.exp $^ $(CMUS_LIBS)
+
+# }}}
+
+# input plugins {{{
+cdio-objs		:= ip/cdio.lo
+flac-objs		:= ip/flac.lo
+mad-objs		:= ip/mad.lo ip/nomad.lo
+mikmod-objs		:= ip/mikmod.lo
+modplug-objs		:= ip/modplug.lo
+bass-objs		:= ip/bass.lo
+mpc-objs		:= ip/mpc.lo
+vorbis-objs		:= ip/vorbis.lo
+opus-objs		:= ip/opus.lo
+wavpack-objs		:= ip/wavpack.lo
+wav-objs		:= ip/wav.lo
+mp4-objs		:= ip/mp4.lo
+aac-objs		:= ip/aac.lo
+ffmpeg-objs		:= ip/ffmpeg.lo
+cue-objs		:= ip/cue.lo
+vtx-objs		:= ip/vtx.lo
+
+ip-$(CONFIG_CDIO)	+= ip/cdio.so
+ip-$(CONFIG_FLAC)	+= ip/flac.so
+ip-$(CONFIG_MAD)	+= ip/mad.so
+ip-$(CONFIG_MIKMOD)	+= ip/mikmod.so
+ip-$(CONFIG_MODPLUG)	+= ip/modplug.so
+ip-$(CONFIG_BASS)	+= ip/bass.so
+ip-$(CONFIG_MPC)	+= ip/mpc.so
+ip-$(CONFIG_VORBIS)	+= ip/vorbis.so
+ip-$(CONFIG_OPUS)	+= ip/opus.so
+ip-$(CONFIG_WAVPACK)	+= ip/wavpack.so
+ip-$(CONFIG_WAV)	+= ip/wav.so
+ip-$(CONFIG_MP4)	+= ip/mp4.so
+ip-$(CONFIG_AAC)	+= ip/aac.so
+ip-$(CONFIG_FFMPEG)	+= ip/ffmpeg.so
+ip-$(CONFIG_CUE)	+= ip/cue.so
+ip-$(CONFIG_VTX)	+= ip/vtx.so
+
+$(cdio-objs):		CFLAGS += $(CDIO_CFLAGS) $(CDDB_CFLAGS)
+$(flac-objs):		CFLAGS += $(FLAC_CFLAGS)
+$(mad-objs):		CFLAGS += $(MAD_CFLAGS)
+$(mikmod-objs):		CFLAGS += $(MIKMOD_CFLAGS)
+$(modplug-objs):	CFLAGS += $(MODPLUG_CFLAGS)
+$(bass-objs):		CFLAGS += $(BASS_CFLAGS)
+$(mpc-objs):		CFLAGS += $(MPC_CFLAGS)
+$(vorbis-objs):		CFLAGS += $(VORBIS_CFLAGS)
+$(opus-objs):		CFLAGS += $(OPUS_CFLAGS)
+$(wavpack-objs):	CFLAGS += $(WAVPACK_CFLAGS)
+$(mp4-objs):		CFLAGS += $(MP4_CFLAGS)
+$(aac-objs):		CFLAGS += $(AAC_CFLAGS)
+$(ffmpeg-objs):		CFLAGS += $(FFMPEG_CFLAGS)
+$(vtx-objs):		CFLAGS += $(VTX_CFLAGS)
+
+ip/cdio.so: $(cdio-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(CDIO_LIBS) $(CDDB_LIBS))
+
+ip/flac.so: $(flac-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(FLAC_LIBS))
+
+ip/mad.so: $(mad-objs) $(libcmus-y)
+	$(call cmd,ld_dl,-lm $(MAD_LIBS) $(ICONV_LIBS))
+
+ip/mikmod.so: $(mikmod-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(MIKMOD_LIBS))
+
+ip/modplug.so: $(modplug-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(MODPLUG_LIBS))
+
+ip/bass.so: $(bass-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(BASS_LIBS))
+
+ip/mpc.so: $(mpc-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(MPC_LIBS))
+
+ip/vorbis.so: $(vorbis-objs) $(libcmus-y)
+	$(call cmd,ld_dl,-lm $(VORBIS_LIBS))
+
+ip/opus.so: $(opus-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(OPUS_LIBS))
+
+ip/wavpack.so: $(wavpack-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(WAVPACK_LIBS))
+
+ip/wav.so: $(wav-objs) $(libcmus-y)
+	$(call cmd,ld_dl,)
+
+ip/mp4.so: $(mp4-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(MP4_LIBS))
+
+ip/aac.so: $(aac-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(AAC_LIBS))
+
+ip/ffmpeg.so: $(ffmpeg-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(FFMPEG_LIBS))
+
+ip/cue.so: $(cue-objs) $(libcmus-y)
+	$(call cmd,ld_dl,-lm)
+
+ip/vtx.so: $(vtx-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(VTX_LIBS))
+
+# }}}
+
+# output plugins {{{
+pulse-objs		:= op/pulse.lo
+alsa-objs		:= op/alsa.lo op/mixer_alsa.lo
+jack-objs		:= op/jack.lo
+arts-objs		:= op/arts.lo
+oss-objs		:= op/oss.lo op/mixer_oss.lo
+sun-objs		:= op/sun.lo op/mixer_sun.lo
+sndio-objs		:= op/sndio.lo
+ao-objs			:= op/ao.lo
+coreaudio-objs		:= op/coreaudio.lo
+waveout-objs		:= op/waveout.lo
+roar-objs               := op/roar.lo
+aaudio-objs		:= op/aaudio.lo
+
+op-$(CONFIG_PULSE)	+= op/pulse.so
+op-$(CONFIG_ALSA)	+= op/alsa.so
+op-$(CONFIG_JACK)	+= op/jack.so
+op-$(CONFIG_ARTS)	+= op/arts.so
+op-$(CONFIG_OSS)	+= op/oss.so
+op-$(CONFIG_SNDIO)	+= op/sndio.so
+op-$(CONFIG_SUN)	+= op/sun.so
+op-$(CONFIG_COREAUDIO)	+= op/coreaudio.so
+op-$(CONFIG_AO)		+= op/ao.so
+op-$(CONFIG_WAVEOUT)	+= op/waveout.so
+op-$(CONFIG_ROAR)       += op/roar.so
+op-$(CONFIG_AAUDIO)	+= op/aaudio.so
+
+$(pulse-objs): CFLAGS		+= $(PULSE_CFLAGS)
+$(alsa-objs): CFLAGS		+= $(ALSA_CFLAGS)
+$(jack-objs): CFLAGS		+= $(JACK_CFLAGS) $(SAMPLERATE_CFLAGS)
+$(arts-objs): CFLAGS		+= $(ARTS_CFLAGS)
+$(oss-objs):  CFLAGS		+= $(OSS_CFLAGS)
+$(sndio-objs): CFLAGS		+= $(SNDIO_CFLAGS)
+$(sun-objs):  CFLAGS		+= $(SUN_CFLAGS)
+$(ao-objs):   CFLAGS		+= $(AO_CFLAGS)
+$(coreaudio-objs): CFLAGS	+= $(COREAUDIO_CFLAGS)
+$(waveout-objs): CFLAGS 	+= $(WAVEOUT_CFLAGS)
+$(roar-objs): CFLAGS		+= $(ROAR_CFLAGS)
+$(aaudio-objs): CFLAGS		+= $(AAUDIO_CFLAGS)
+
+op/pulse.so: $(pulse-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(PULSE_LIBS))
+
+op/alsa.so: $(alsa-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(ALSA_LIBS) -lm)
+
+op/jack.so: $(jack-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(JACK_LIBS) $(SAMPLERATE_LIBS))
+
+op/arts.so: $(arts-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(ARTS_LIBS))
+
+op/oss.so: $(oss-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(OSS_LIBS))
+
+op/sndio.so: $(sndio-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(SNDIO_LIBS))
+
+op/sun.so: $(sun-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(SUN_LIBS))
+
+op/ao.so: $(ao-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(AO_LIBS))
+
+op/coreaudio.so: $(coreaudio-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(COREAUDIO_LIBS))
+
+op/waveout.so: $(waveout-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(WAVEOUT_LIBS))
+
+op/roar.so: $(roar-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(ROAR_LIBS))
+
+op/aaudio.so: $(aaudio-objs) $(libcmus-y)
+	$(call cmd,ld_dl,$(AAUDIO_LIBS))
+# }}}
+
+# man {{{
+man1	:= Doc/cmus.1 Doc/cmus-remote.1
+man7	:= Doc/cmus-tutorial.7
+
+$(man1): Doc/ttman
+$(man7): Doc/ttman
+
+%.1: %.txt
+	$(call cmd,ttman)
+
+%.7: %.txt
+	$(call cmd,ttman)
+
+Doc/ttman.o: Doc/ttman.c
+	$(call cmd,hostcc,)
+
+Doc/ttman: Doc/ttman.o
+	$(call cmd,hostld,)
+
+quiet_cmd_ttman = MAN    $@
+      cmd_ttman = Doc/ttman $< $@
+# }}}
+
+data		= $(wildcard data/*)
+
+clean		+= *.o ip/*.lo op/*.lo ip/*.so op/*.so *.lo cmus libcmus.a cmus.def cmus.base cmus.exp cmus-remote Doc/*.o Doc/ttman Doc/*.1 Doc/*.7 .install.log
+distclean	+= .version config.mk config/*.h tags
+
+main: cmus cmus-remote
+plugins: $(ip-y) $(op-y)
+man: $(man1) $(man7)
+
+install-main: main
+	$(INSTALL) -m755 $(bindir) cmus cmus-remote
+
+install-plugins: plugins
+	$(INSTALL) -m755 $(libdir)/cmus/ip $(ip-y)
+	$(INSTALL) -m755 $(libdir)/cmus/op $(op-y)
+
+install-data: man
+	$(INSTALL) -m644 $(datadir)/cmus $(data)
+	$(INSTALL) -m644 $(mandir)/man1 $(man1)
+	$(INSTALL) -m644 $(mandir)/man7 $(man7)
+	$(INSTALL) -m755 $(exampledir) cmus-status-display
+
+install: all install-main install-plugins install-data
+
+tags:
+	exuberant-ctags *.[ch]
+
+# generating tarball using GIT {{{
+TARNAME	= cmus-$(VERSION)
+
+dist:
+	@tarname=$(TARNAME);						\
+	test "$(_ver2)" || { echo "No such revision $(REV)"; exit 1; };	\
+	echo "   DIST   $$tarname.tar.bz2";				\
+	git archive --format=tar --prefix=$$tarname/ $(REV)^{tree} | bzip2 -c -9 > $$tarname.tar.bz2
+
+# }}}
+
+.PHONY: all main plugins man dist tags
+.PHONY: install install-main install-plugins install-man

README.md

@@ -0,0 +1,102 @@
+# cmus — C\* Music Player
+
+https://cmus.github.io/
+
+[![Build Status](https://github.com/cmus/cmus/actions/workflows/build.yml/badge.svg)](https://github.com/cmus/cmus/actions/workflows/build.yml)
+
+Copyright © 2004-2008 Timo Hirvonen <tihirvon@gmail.com>
+
+Copyright © 2008-2017 Various Authors
+
+
+## Configuration
+
+    $ ./configure
+
+By default, features are auto-detected. To list all configuration options, run
+`./configure --help`. Some common autoconf-style options like `--prefix` are
+also available.
+
+After running configure you can see from the generated `config.mk` file
+what features have been configured in (see the `CONFIG_*` options).
+
+The packages containing dependencies on common distributions are listed below. All dependencies other than pkg-config and ncurses, iconv, and elogind/systemd are for optional input/output plugins. It is assumed that libc headers, a C compiler, git, and GNU Make are available.
+
+| Distro            | Dependencies |
+| :--               | :--          |
+| **Debian/Ubuntu** | apt install pkg-config libncursesw5-dev libfaad-dev libao-dev libasound2-dev libcddb2-dev libcdio-cdda-dev libdiscid-dev libavformat-dev libavcodec-dev libswresample-dev libflac-dev libjack-dev libmad0-dev libmodplug-dev libmpcdec-dev libsystemd-dev libopusfile-dev libpulse-dev libsamplerate0-dev libsndio-dev libvorbis-dev libwavpack-dev |
+| **Fedora/RHEL**   | dnf install 'pkgconfig(ncursesw)' 'pkgconfig(alsa)' 'pkgconfig(ao)' 'pkgconfig(libcddb)' 'pkgconfig(libcdio_cdda)' 'pkgconfig(libdiscid)' 'pkgconfig(libavformat)' 'pkgconfig(libavcodec)' 'pkgconfig(libswresample)' 'pkgconfig(flac)' 'pkgconfig(jack)' 'pkgconfig(mad)' 'pkgconfig(libmodplug)' libmpcdec-devel 'pkgconfig(libsystemd)' 'pkgconfig(opusfile)' 'pkgconfig(libpulse)' 'pkgconfig(samplerate)' 'pkgconfig(vorbisfile)' 'pkgconfig(wavpack)' |
+| **+ RPMFusion**   | dnf install faad2-devel libmp4v2-devel |
+| **Arch Linux**    | pacman -S pkg-config ncurses libiconv faad2 alsa-lib libao libcddb libcdio-paranoia libdiscid ffmpeg flac jack libmad libmodplug libmp4v2 libmpcdec systemd opusfile libpulse libsamplerate libvorbis wavpack |
+| **Alpine**        | apk add pkgconf ncurses-dev gnu-libiconv-dev alsa-lib-dev libao-dev libcddb-dev ffmpeg-dev flac-dev jack-dev libmad-dev libmodplug-dev elogind-dev opus-dev opusfile-dev pulseaudio-dev libsamplerate-dev libvorbis-dev wavpack-dev |
+| **Termux**        | apt install libandroid-support ncurses libiconv ffmpeg libmad libmodplug opusfile pulseaudio libflac libvorbis libwavpack |
+| **Homebrew**      | brew install pkg-config ncurses faad2 libao libcddb libcdio libdiscid ffmpeg flac jack mad libmodplug mp4v2 musepack opusfile libsamplerate libvorbis wavpack |
+
+
+## Building
+
+    $ make
+
+Or on some BSD systems you need to explicitly use GNU make:
+
+    $ gmake
+
+
+## Installation
+
+    $ make install
+
+Or to install to a temporary directory:
+
+    $ make install DESTDIR=~/tmp/cmus
+
+This is useful when creating binary packages.
+
+Remember to replace `make` with `gmake` if needed.
+
+
+## Manuals
+
+    $ man cmus-tutorial
+
+And
+
+    $ man cmus
+
+
+## IRC Channel
+
+Feel free to join IRC channel #cmus on Libera.chat and share you experience,
+problems and issues. Note: This is an unofficial channel and all people hanging
+around there are for the love of cmus.
+
+
+## Reporting Bugs
+
+Bugs should be reported using the GitHub [issue
+tracker](https://github.com/cmus/cmus/issues). When creating a new issue, a
+template will be shown containing instructions on how to collect the necessary
+information.
+
+Additional debug information can be found in `~/cmus-debug.txt` if you
+configured cmus with maximum debug level (`./configure DEBUG=2`). In case of a
+crash the last lines may be helpful.
+
+
+## Git Repository
+
+https://github.com/cmus/cmus
+
+    $ git clone https://github.com/cmus/cmus.git
+
+
+## Hacking
+
+cmus uses the [Linux kernel coding
+style](https://www.kernel.org/doc/html/latest/process/coding-style.html). Use
+hard tabs. Tabs are _always_ 8 characters wide. Keep the style consistent with
+rest of the code.
+
+Bug fixes and implementations of new features should be suggested as a
+[pull request](https://github.com/cmus/cmus/pulls) directly on GitHub.
+

ape.c

@@ -0,0 +1,258 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 Chun-Yu Shei <cshei AT cs.indiana.edu>
+ *
+ * Cleaned up by Timo Hirvonen <tihirvon@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ape.h"
+#include "file.h"
+#include "xmalloc.h"
+#include "utils.h"
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <strings.h>
+
+/* http://www.personal.uni-jena.de/~pfk/mpp/sv8/apetag.html */
+
+#define PREAMBLE_SIZE (8)
+static const char preamble[PREAMBLE_SIZE] = { 'A', 'P', 'E', 'T', 'A', 'G', 'E', 'X' };
+
+/* NOTE: not sizeof(struct ape_header)! */
+#define HEADER_SIZE (32)
+
+/* returns position of APE header or -1 if not found */
+static int find_ape_tag_slow(int fd)
+{
+	char buf[4096];
+	int match = 0;
+	int pos = 0;
+
+	/* seek to start of file */
+	if (lseek(fd, pos, SEEK_SET) == -1)
+		return -1;
+
+	while (1) {
+		int i, got = read(fd, buf, sizeof(buf));
+
+		if (got == -1) {
+			if (errno == EAGAIN || errno == EINTR)
+				continue;
+			break;
+		}
+		if (got == 0)
+			break;
+
+		for (i = 0; i < got; i++) {
+			if (buf[i] != preamble[match]) {
+				match = 0;
+				continue;
+			}
+
+			match++;
+			if (match == PREAMBLE_SIZE)
+				return pos + i + 1 - PREAMBLE_SIZE;
+		}
+		pos += got;
+	}
+	return -1;
+}
+
+static int ape_parse_header(const char *buf, struct ape_header *h)
+{
+	if (memcmp(buf, preamble, PREAMBLE_SIZE))
+		return 0;
+
+	h->version = read_le32(buf + 8);
+	h->size = read_le32(buf + 12);
+	h->count = read_le32(buf + 16);
+	h->flags = read_le32(buf + 20);
+	return 1;
+}
+
+static int read_header(int fd, struct ape_header *h)
+{
+	char buf[HEADER_SIZE];
+
+	if (read_all(fd, buf, sizeof(buf)) != sizeof(buf))
+		return 0;
+
+	return ape_parse_header(buf, h);
+}
+
+/* sets fd right after the header and returns 1 if found,
+ * otherwise returns 0
+ */
+static int find_ape_tag(int fd, struct ape_header *h, int slow)
+{
+	int pos;
+
+	if (lseek(fd, -HEADER_SIZE, SEEK_END) == -1)
+		return 0;
+	if (read_header(fd, h))
+		return 1;
+
+	/* try to skip ID3v1 tag at the end of the file */
+	if (lseek(fd, -(HEADER_SIZE + 128), SEEK_END) == -1)
+		return 0;
+	if (read_header(fd, h))
+		return 1;
+
+	if (!slow)
+		return 0;
+
+	pos = find_ape_tag_slow(fd);
+	if (pos == -1)
+		return 0;
+	if (lseek(fd, pos, SEEK_SET) == -1)
+		return 0;
+	return read_header(fd, h);
+}
+
+/*
+ * All keys are ASCII and length is 2..255
+ *
+ * UTF-8:	Artist, Album, Title, Genre
+ * Integer:	Track (N or N/M)
+ * Date:	Year (release), "Record Date"
+ *
+ * UTF-8 strings are NOT zero terminated.
+ *
+ * Also support "discnumber" (vorbis) and "disc" (non-standard)
+ */
+static int ape_parse_one(const char *buf, int size, char **keyp, char **valp)
+{
+	int pos = 0;
+
+	while (size - pos > 8) {
+		uint32_t val_len, flags;
+		char *key, *val;
+		int64_t max_key_len, key_len;
+
+		val_len = read_le32(buf + pos); pos += 4;
+		flags = read_le32(buf + pos); pos += 4;
+
+		max_key_len = size - pos - (int64_t)val_len - 1;
+		if (max_key_len < 0) {
+			/* corrupt */
+			break;
+		}
+
+		for (key_len = 0; key_len < max_key_len && buf[pos + key_len]; key_len++)
+			; /* nothing */
+		if (buf[pos + key_len]) {
+			/* corrupt */
+			break;
+		}
+
+		if (!AF_IS_UTF8(flags)) {
+			/* ignore binary data */
+			pos += key_len + 1 + val_len;
+			continue;
+		}
+
+		key = xstrdup(buf + pos);
+		pos += key_len + 1;
+
+		/* should not be NUL-terminated */
+		val = xstrndup(buf + pos, val_len);
+		pos += val_len;
+
+		/* could be moved to comment.c but I don't think anyone else would use it */
+		if (!strcasecmp(key, "record date") || !strcasecmp(key, "year")) {
+			free(key);
+			key = xstrdup("date");
+		}
+
+		if (!strcasecmp(key, "date")) {
+			/* Date format
+			 *
+			 * 1999-08-11 12:34:56
+			 * 1999-08-11 12:34
+			 * 1999-08-11
+			 * 1999-08
+			 * 1999
+			 * 1999-W34	(week 34, totally crazy)
+			 *
+			 * convert to year, pl.c supports only years anyways
+			 *
+			 * FIXME: which one is the most common tag (year or record date)?
+			 */
+			if (strlen(val) > 4)
+				val[4] = 0;
+		}
+
+		*keyp = key;
+		*valp = val;
+		return pos;
+	}
+	return -1;
+}
+
+/* return the number of comments, or -1 */
+int ape_read_tags(struct apetag *ape, int fd, int slow)
+{
+	struct ape_header *h = &ape->header;
+	int rc = -1;
+	off_t old_pos;
+
+	/* save position */
+	old_pos = lseek(fd, 0, SEEK_CUR);
+
+	if (!find_ape_tag(fd, h, slow))
+		goto fail;
+
+	if (AF_IS_FOOTER(h->flags)) {
+		/* seek back right after the header */
+		if (lseek(fd, -((int)h->size), SEEK_CUR) == -1)
+			goto fail;
+	}
+
+	/* ignore insane tags */
+	if (h->size > 1024 * 1024)
+		goto fail;
+
+	ape->buf = xnew(char, h->size);
+	if (read_all(fd, ape->buf, h->size) != h->size)
+		goto fail;
+
+	rc = h->count;
+
+fail:
+	lseek(fd, old_pos, SEEK_SET);
+	return rc;
+}
+
+/* returned key-name must be free'd */
+char *ape_get_comment(struct apetag *ape, char **val)
+{
+	struct ape_header *h = &ape->header;
+	char *key;
+	int rc;
+
+	if (ape->pos >= h->size)
+		return NULL;
+
+	rc = ape_parse_one(ape->buf + ape->pos, h->size - ape->pos, &key, val);
+	if (rc < 0)
+		return NULL;
+	ape->pos += rc;
+
+	return key;
+}

ape.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2007 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_APE_H
+#define CMUS_APE_H
+
+#include <stdint.h>
+#include <stdlib.h>
+
+struct ape_header {
+	/* 1000 or 2000 (1.0, 2.0) */
+	uint32_t version;
+
+	/* tag size (header + tags, excluding footer) */
+	uint32_t size;
+
+	/* number of items */
+	uint32_t count;
+
+	/* global flags for each tag
+	 * there are also private flags for every tag
+	 * NOTE: 0 for version 1.0 (1000)
+	 */
+	uint32_t flags;
+};
+
+/* ape flags */
+#define AF_IS_UTF8(f)		(((f) & 6) == 0)
+#define AF_IS_FOOTER(f)		(((f) & (1 << 29)) == 0)
+
+struct apetag {
+	char *buf;
+	int pos;
+	struct ape_header header;
+};
+
+#define APETAG(name) struct apetag name = { .buf = NULL, .pos = 0, }
+
+int ape_read_tags(struct apetag *ape, int fd, int slow);
+char *ape_get_comment(struct apetag *ape, char **val);
+
+static inline void ape_free(struct apetag *ape)
+{
+	free(ape->buf);
+}
+
+#endif

browser.c

@@ -0,0 +1,499 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "browser.h"
+#include "load_dir.h"
+#include "cmus.h"
+#include "xmalloc.h"
+#include "ui_curses.h"
+#include "file.h"
+#include "misc.h"
+#include "options.h"
+#include "uchar.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/mman.h>
+
+struct window *browser_win;
+struct searchable *browser_searchable;
+char *browser_dir;
+
+static LIST_HEAD(browser_head);
+
+static inline void browser_entry_to_iter(struct browser_entry *e, struct iter *iter)
+{
+	iter->data0 = &browser_head;
+	iter->data1 = e;
+	iter->data2 = NULL;
+}
+
+/* filter out names starting with '.' except '..' */
+static int normal_filter(const char *name, const struct stat *s)
+{
+	if (name[0] == '.') {
+		if (name[1] == '.' && name[2] == 0)
+			return 1;
+		return 0;
+	}
+	if (S_ISDIR(s->st_mode))
+		return 1;
+	return cmus_is_supported(name);
+}
+
+/* filter out '.' */
+static int hidden_filter(const char *name, const struct stat *s)
+{
+	if (name[0] == '.' && name[1] == 0)
+		return 0;
+	return 1;
+}
+
+/* only works for BROWSER_ENTRY_DIR and BROWSER_ENTRY_FILE */
+static int entry_cmp(const struct browser_entry *a, const struct browser_entry *b)
+{
+	if (a->type == BROWSER_ENTRY_DIR) {
+		if (b->type == BROWSER_ENTRY_FILE)
+			return -1;
+		if (!strcmp(a->name, "../"))
+			return -1;
+		if (!strcmp(b->name, "../"))
+			return 1;
+		return strcmp(a->name, b->name);
+	}
+	if (b->type == BROWSER_ENTRY_DIR)
+		return 1;
+	return strcmp(a->name, b->name);
+}
+
+static char *fullname(const char *path, const char *name)
+{
+	int l1, l2;
+	char *full;
+
+	l1 = strlen(path);
+	l2 = strlen(name);
+	if (path[l1 - 1] == '/')
+		l1--;
+	full = xnew(char, l1 + 1 + l2 + 1);
+	memcpy(full, path, l1);
+	full[l1] = '/';
+	memcpy(full + l1 + 1, name, l2 + 1);
+	return full;
+}
+
+static void free_browser_list(void)
+{
+	struct list_head *item;
+
+	item = browser_head.next;
+	while (item != &browser_head) {
+		struct list_head *next = item->next;
+		struct browser_entry *entry;
+
+		entry = list_entry(item, struct browser_entry, node);
+		free(entry);
+		item = next;
+	}
+	list_init(&browser_head);
+}
+
+static int add_pl_line(void *data, const char *line)
+{
+	struct browser_entry *e;
+	int name_size = strlen(line) + 1;
+
+	e = xmalloc(sizeof(struct browser_entry) + name_size);
+	memcpy(e->name, line, name_size);
+	e->type = BROWSER_ENTRY_PLLINE;
+	list_add_tail(&e->node, &browser_head);
+	return 0;
+}
+
+static int do_browser_load(const char *name)
+{
+	struct stat st;
+
+	if (stat(name, &st))
+		return -1;
+
+	if (S_ISREG(st.st_mode) && cmus_is_playlist(name)) {
+		char *buf;
+		ssize_t size;
+
+		buf = mmap_file(name, &size);
+		if (size == -1)
+			return -1;
+
+		free_browser_list();
+
+		if (buf) {
+			struct browser_entry *parent_dir_e = xmalloc(sizeof(struct browser_entry) + 4);
+			strcpy(parent_dir_e->name, "../");
+			parent_dir_e->type = BROWSER_ENTRY_DIR;
+			list_add_tail(&parent_dir_e->node, &browser_head);
+
+			cmus_playlist_for_each(buf, size, 0, add_pl_line, NULL);
+			munmap(buf, size);
+		}
+	} else if (S_ISDIR(st.st_mode)) {
+		int (*filter)(const char *, const struct stat *) = normal_filter;
+		struct directory dir;
+		const char *str;
+		int root = !strcmp(name, "/");
+
+		if (show_hidden)
+			filter = hidden_filter;
+
+		if (dir_open(&dir, name))
+			return -1;
+
+		free_browser_list();
+		while ((str = dir_read(&dir))) {
+			struct browser_entry *e;
+			struct list_head *item;
+			int len;
+
+			if (!filter(str, &dir.st))
+				continue;
+
+			/* ignore .. if we are in the root dir */
+			if (root && !strcmp(str, ".."))
+				continue;
+
+			len = strlen(str);
+			e = xmalloc(sizeof(struct browser_entry) + len + 2);
+			e->type = BROWSER_ENTRY_FILE;
+			memcpy(e->name, str, len);
+			if (S_ISDIR(dir.st.st_mode)) {
+				e->type = BROWSER_ENTRY_DIR;
+				e->name[len++] = '/';
+			}
+			e->name[len] = 0;
+
+			item = browser_head.prev;
+			while (item != &browser_head) {
+				struct browser_entry *other;
+
+				other = container_of(item, struct browser_entry, node);
+				if (entry_cmp(e, other) >= 0)
+					break;
+				item = item->prev;
+			}
+			/* add after item */
+			list_add(&e->node, item);
+		}
+		dir_close(&dir);
+
+		/* try to update currect working directory */
+		if (chdir(name))
+			return -1;
+	} else {
+		errno = ENOTDIR;
+		return -1;
+	}
+	return 0;
+}
+
+static int browser_load(const char *name)
+{
+	int rc;
+
+	rc = do_browser_load(name);
+	if (rc)
+		return rc;
+
+	window_set_contents(browser_win, &browser_head);
+	free(browser_dir);
+	browser_dir = xstrdup(name);
+	return 0;
+}
+
+static GENERIC_ITER_PREV(browser_get_prev, struct browser_entry, node)
+static GENERIC_ITER_NEXT(browser_get_next, struct browser_entry, node)
+
+static int browser_search_get_current(void *data, struct iter *iter, enum search_direction dir)
+{
+	return window_get_sel(browser_win, iter);
+}
+
+static int browser_search_matches(void *data, struct iter *iter, const char *text)
+{
+	char **words = get_words(text);
+	int matched = 0;
+
+	if (words[0] != NULL) {
+		struct browser_entry *e;
+		int i;
+
+		e = iter_to_browser_entry(iter);
+		for (i = 0; ; i++) {
+			if (words[i] == NULL) {
+				window_set_sel(browser_win, iter);
+				matched = 1;
+				break;
+			}
+			if (u_strcasestr_filename(e->name, words[i]) == NULL)
+				break;
+		}
+	}
+	free_str_array(words);
+	return matched;
+}
+
+static const struct searchable_ops browser_search_ops = {
+	.get_prev = browser_get_prev,
+	.get_next = browser_get_next,
+	.get_current = browser_search_get_current,
+	.matches = browser_search_matches
+};
+
+void browser_init(void)
+{
+	struct iter iter;
+	char cwd[1024];
+	char *dir;
+
+	if (getcwd(cwd, sizeof(cwd)) == NULL) {
+		dir = xstrdup("/");
+	} else {
+		dir = xstrdup(cwd);
+	}
+	if (do_browser_load(dir)) {
+		free(dir);
+		do_browser_load("/");
+		browser_dir = xstrdup("/");
+	} else {
+		browser_dir = dir;
+	}
+
+	browser_win = window_new(browser_get_prev, browser_get_next);
+	window_set_contents(browser_win, &browser_head);
+	window_changed(browser_win);
+
+	iter.data0 = &browser_head;
+	iter.data1 = NULL;
+	iter.data2 = NULL;
+	browser_searchable = searchable_new(NULL, &iter, &browser_search_ops);
+}
+
+void browser_exit(void)
+{
+	searchable_free(browser_searchable);
+	free_browser_list();
+	window_free(browser_win);
+	free(browser_dir);
+}
+
+int browser_chdir(const char *dir)
+{
+	if (browser_load(dir)) {
+	}
+	return 0;
+}
+
+void browser_up(void)
+{
+	char *new, *ptr, *pos;
+	struct browser_entry *e;
+	int len;
+
+	if (strcmp(browser_dir, "/") == 0)
+		return;
+
+	ptr = strrchr(browser_dir, '/');
+	if (ptr == browser_dir) {
+		new = xstrdup("/");
+	} else {
+		new = xstrndup(browser_dir, ptr - browser_dir);
+	}
+
+	/* remember old position */
+	ptr++;
+	len = strlen(ptr);
+	pos = xstrdup(ptr);
+
+	errno = 0;
+	if (browser_load(new)) {
+		if (errno == ENOENT) {
+			free(pos);
+			free(browser_dir);
+			browser_dir = new;
+			browser_up();
+			return;
+		}
+		error_msg("could not open directory '%s': %s\n", new, strerror(errno));
+		free(new);
+		free(pos);
+		return;
+	}
+	free(new);
+
+	/* select old position */
+	list_for_each_entry(e, &browser_head, node) {
+		if (strncmp(e->name, pos, len) == 0 &&
+		    (e->name[len] == '/' || e->name[len] == '\0')) {
+			struct iter iter;
+
+			browser_entry_to_iter(e, &iter);
+			window_set_sel(browser_win, &iter);
+			break;
+		}
+	}
+	free(pos);
+}
+
+static void browser_cd(const char *dir)
+{
+	char *new;
+	int len;
+
+	if (strcmp(dir, "../") == 0) {
+		browser_up();
+		return;
+	}
+
+	new = fullname(browser_dir, dir);
+	len = strlen(new);
+	if (new[len - 1] == '/')
+		new[len - 1] = 0;
+	if (browser_load(new))
+		error_msg("could not open directory '%s': %s\n", dir, strerror(errno));
+	free(new);
+}
+
+static void browser_cd_playlist(const char *filename)
+{
+	if (browser_load(filename))
+		error_msg("could not read playlist '%s': %s\n", filename, strerror(errno));
+}
+
+void browser_enter(void)
+{
+	struct browser_entry *e;
+	struct iter sel;
+	int len;
+
+	if (!window_get_sel(browser_win, &sel))
+		return;
+	e = iter_to_browser_entry(&sel);
+	len = strlen(e->name);
+	if (len == 0)
+		return;
+	if (e->type == BROWSER_ENTRY_DIR) {
+		browser_cd(e->name);
+	} else {
+		if (e->type == BROWSER_ENTRY_PLLINE) {
+			cmus_play_file(e->name);
+		} else {
+			char *filename;
+
+			filename = fullname(browser_dir, e->name);
+			if (cmus_is_playlist(filename)) {
+				browser_cd_playlist(filename);
+			} else {
+				cmus_play_file(filename);
+			}
+			free(filename);
+		}
+	}
+}
+
+char *browser_get_sel(void)
+{
+	struct browser_entry *e;
+	struct iter sel;
+
+	if (!window_get_sel(browser_win, &sel))
+		return NULL;
+
+	e = iter_to_browser_entry(&sel);
+	if (e->type == BROWSER_ENTRY_PLLINE)
+		return xstrdup(e->name);
+
+	return fullname(browser_dir, e->name);
+}
+
+void browser_delete(void)
+{
+	struct browser_entry *e;
+	struct iter sel;
+	int len;
+
+	if (!window_get_sel(browser_win, &sel))
+		return;
+	e = iter_to_browser_entry(&sel);
+	len = strlen(e->name);
+	if (len == 0)
+		return;
+	if (e->type == BROWSER_ENTRY_FILE) {
+		char *name;
+
+		name = fullname(browser_dir, e->name);
+		if (yes_no_query("Delete file '%s'? [y/N]", e->name) == UI_QUERY_ANSWER_YES) {
+			if (unlink(name) == -1) {
+				error_msg("deleting '%s': %s", e->name, strerror(errno));
+			} else {
+				window_row_vanishes(browser_win, &sel);
+				list_del(&e->node);
+				free(e);
+			}
+		}
+		free(name);
+	}
+}
+
+void browser_reload(void)
+{
+	char *tmp = xstrdup(browser_dir);
+	char *sel = NULL;
+	struct iter iter;
+	struct browser_entry *e;
+
+	/* remember selection */
+	if (window_get_sel(browser_win, &iter)) {
+		e = iter_to_browser_entry(&iter);
+		sel = xstrdup(e->name);
+	}
+
+	/* have to use tmp  */
+	if (browser_load(tmp)) {
+		error_msg("could not update contents '%s': %s\n", tmp, strerror(errno));
+		free(tmp);
+		free(sel);
+		return;
+	}
+
+	if (sel) {
+		/* set selection */
+		list_for_each_entry(e, &browser_head, node) {
+			if (strcmp(e->name, sel) == 0) {
+				browser_entry_to_iter(e, &iter);
+				window_set_sel(browser_win, &iter);
+				break;
+			}
+		}
+	}
+
+	free(tmp);
+	free(sel);
+}

browser.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_BROWSER_H
+#define CMUS_BROWSER_H
+
+#include "list.h"
+#include "window.h"
+#include "search.h"
+
+struct browser_entry {
+	struct list_head node;
+
+	enum { BROWSER_ENTRY_DIR, BROWSER_ENTRY_FILE, BROWSER_ENTRY_PLLINE } type;
+	char name[];
+};
+
+static inline struct browser_entry *iter_to_browser_entry(struct iter *iter)
+{
+	return iter->data1;
+}
+
+extern struct window *browser_win;
+extern char *browser_dir;
+extern struct searchable *browser_searchable;
+
+void browser_init(void);
+void browser_exit(void);
+int browser_chdir(const char *dir);
+char *browser_get_sel(void);
+void browser_up(void);
+void browser_enter(void);
+void browser_delete(void);
+void browser_reload(void);
+void browser_toggle_show_hidden(void);
+
+#endif

buffer.c

@@ -0,0 +1,209 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "buffer.h"
+#include "xmalloc.h"
+#include "locking.h"
+#include "debug.h"
+
+/*
+ * chunk can be accessed by either consumer OR producer, not both at same time
+ * -> no need to lock
+ */
+struct chunk {
+	char data[CHUNK_SIZE];
+
+	/* index to data, first filled byte */
+	unsigned int l;
+
+	/* index to data, last filled byte + 1
+	 *
+	 * there are h - l bytes available (filled)
+	 */
+	unsigned int h : 31;
+
+	/* if chunk is marked filled it can only be accessed by consumer
+	 * otherwise only producer is allowed to access the chunk
+	 */
+	unsigned int filled : 1;
+};
+
+unsigned int buffer_nr_chunks;
+
+static pthread_mutex_t buffer_mutex = CMUS_MUTEX_INITIALIZER;
+static struct chunk *buffer_chunks = NULL;
+static unsigned int buffer_ridx;
+static unsigned int buffer_widx;
+
+void buffer_init(void)
+{
+	free(buffer_chunks);
+	buffer_chunks = xnew(struct chunk, buffer_nr_chunks);
+	buffer_reset();
+}
+
+void buffer_free(void)
+{
+	free(buffer_chunks);
+}
+
+/*
+ * @pos: returned pointer to available data
+ *
+ * Returns number of bytes available at @pos
+ *
+ * After reading bytes mark them consumed calling buffer_consume().
+ */
+int buffer_get_rpos(char **pos)
+{
+	struct chunk *c;
+	int size = 0;
+
+	cmus_mutex_lock(&buffer_mutex);
+	c = &buffer_chunks[buffer_ridx];
+	if (c->filled) {
+		size = c->h - c->l;
+		*pos = c->data + c->l;
+	}
+	cmus_mutex_unlock(&buffer_mutex);
+
+	return size;
+}
+
+/*
+ * @pos: pointer to buffer position where data can be written
+ *
+ * Returns number of bytes can be written to @pos.  If the return value is
+ * non-zero it is guaranteed to be >= 1024.
+ *
+ * After writing bytes mark them filled calling buffer_fill().
+ */
+int buffer_get_wpos(char **pos)
+{
+	struct chunk *c;
+	int size = 0;
+
+	cmus_mutex_lock(&buffer_mutex);
+	c = &buffer_chunks[buffer_widx];
+	if (!c->filled) {
+		size = CHUNK_SIZE - c->h;
+		*pos = c->data + c->h;
+	}
+	cmus_mutex_unlock(&buffer_mutex);
+
+	return size;
+}
+
+void buffer_consume(int count)
+{
+	struct chunk *c;
+
+	BUG_ON(count < 0);
+	cmus_mutex_lock(&buffer_mutex);
+	c = &buffer_chunks[buffer_ridx];
+	BUG_ON(!c->filled);
+	c->l += count;
+	if (c->l == c->h) {
+		c->l = 0;
+		c->h = 0;
+		c->filled = 0;
+		buffer_ridx++;
+		buffer_ridx %= buffer_nr_chunks;
+	}
+	cmus_mutex_unlock(&buffer_mutex);
+}
+
+/* chunk is marked filled if free bytes < 1024 or count == 0 */
+int buffer_fill(int count)
+{
+	struct chunk *c;
+	int filled = 0;
+
+	cmus_mutex_lock(&buffer_mutex);
+	c = &buffer_chunks[buffer_widx];
+	BUG_ON(c->filled);
+	c->h += count;
+
+	if (CHUNK_SIZE - c->h < 1024 || (count == 0 && c->h > 0)) {
+		c->filled = 1;
+		buffer_widx++;
+		buffer_widx %= buffer_nr_chunks;
+		filled = 1;
+	}
+
+	cmus_mutex_unlock(&buffer_mutex);
+	return filled;
+}
+
+void buffer_reset(void)
+{
+	int i;
+
+	cmus_mutex_lock(&buffer_mutex);
+	buffer_ridx = 0;
+	buffer_widx = 0;
+	for (i = 0; i < buffer_nr_chunks; i++) {
+		buffer_chunks[i].l = 0;
+		buffer_chunks[i].h = 0;
+		buffer_chunks[i].filled = 0;
+	}
+	cmus_mutex_unlock(&buffer_mutex);
+}
+
+int buffer_get_filled_chunks(void)
+{
+	int c;
+
+	cmus_mutex_lock(&buffer_mutex);
+	if (buffer_ridx < buffer_widx) {
+		/*
+		 * |__##########____|
+		 *    r         w
+		 *
+		 * |############____|
+		 *  r           w
+		 */
+		c = buffer_widx - buffer_ridx;
+	} else if (buffer_ridx > buffer_widx) {
+		/*
+		 * |#######______###|
+		 *         w     r
+		 *
+		 * |_____________###|
+		 *  w            r
+		 */
+		c = buffer_nr_chunks - buffer_ridx + buffer_widx;
+	} else {
+		/*
+		 * |################|
+		 *     r
+		 *     w
+		 *
+		 * |________________|
+		 *     r
+		 *     w
+		 */
+		if (buffer_chunks[buffer_ridx].filled) {
+			c = buffer_nr_chunks;
+		} else {
+			c = 0;
+		}
+	}
+	cmus_mutex_unlock(&buffer_mutex);
+	return c;
+}

buffer.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_BUFFER_H
+#define CMUS_BUFFER_H
+
+/*
+ * must be a multiple of any supported frame size
+ *
+ * 12 is the LCM of 1, 2, 3 and 4, which corresponds to
+ * 8, 16, 24 and 32 bits respectively
+ *
+ * 840 is the LCM of 1, 2, 3, 4, 5, 6, 7 and 8, which
+ * are the numbers of supported channels
+ *
+ * we used to define the value as 60 * 1024 = 61440
+ * hence the extra 6, which makes the new value 60480
+ */
+#define CHUNK_SIZE (12 * 840 * 6)
+
+extern unsigned int buffer_nr_chunks;
+
+void buffer_init(void);
+void buffer_free(void);
+int buffer_get_rpos(char **pos);
+int buffer_get_wpos(char **pos);
+void buffer_consume(int count);
+int buffer_fill(int count);
+void buffer_reset(void);
+int buffer_get_filled_chunks(void);
+
+#endif

cache.c

@@ -0,0 +1,565 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cache.h"
+#include "misc.h"
+#include "file.h"
+#include "input.h"
+#include "track_info.h"
+#include "utils.h"
+#include "xmalloc.h"
+#include "xstrjoin.h"
+#include "gbuf.h"
+#include "options.h"
+#include "pl_env.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/mman.h>
+
+#define CACHE_VERSION   0x0d
+
+#define CACHE_64_BIT	0x01
+#define CACHE_BE	0x02
+
+#define CACHE_RESERVED_PATTERN  	0xff
+
+#define CACHE_ENTRY_USED_SIZE		28
+#define CACHE_ENTRY_RESERVED_SIZE	52
+#define CACHE_ENTRY_TOTAL_SIZE	(CACHE_ENTRY_RESERVED_SIZE + CACHE_ENTRY_USED_SIZE)
+
+// Cmus Track Cache version X + 4 bytes flags
+static char cache_header[8] CMUS_NONSTRING = "CTC\0\0\0\0\0";
+
+// host byte order
+// mtime is either 32 or 64 bits
+struct cache_entry {
+	// size of this struct including size itself
+	uint32_t size;
+
+	int32_t play_count;
+	int64_t mtime;
+	int32_t duration;
+	int32_t bitrate;
+	int32_t bpm;
+
+	// when introducing new fields decrease the reserved space accordingly
+	uint8_t _reserved[CACHE_ENTRY_RESERVED_SIZE];
+
+	// filename, codec, codec_profile and N * (key, val)
+	char strings[];
+};
+
+// make sure our mmap/sizeof-based code works
+STATIC_ASSERT(CACHE_ENTRY_TOTAL_SIZE == sizeof(struct cache_entry));
+STATIC_ASSERT(CACHE_ENTRY_TOTAL_SIZE == offsetof(struct cache_entry, strings));
+
+
+#define ALIGN(size) (((size) + sizeof(long) - 1) & ~(sizeof(long) - 1))
+#define HASH_SIZE 1023
+
+static struct track_info *hash_table[HASH_SIZE];
+static char *cache_filename;
+static int total;
+
+struct fifo_mutex cache_mutex = FIFO_MUTEX_INITIALIZER;
+
+
+static void add_ti(struct track_info *ti, unsigned int hash)
+{
+	unsigned int pos = hash % HASH_SIZE;
+	struct track_info *next = hash_table[pos];
+
+	ti->next = next;
+	hash_table[pos] = ti;
+	total++;
+}
+
+static int valid_cache_entry(const struct cache_entry *e, unsigned int avail)
+{
+	unsigned int min_size = sizeof(*e);
+	unsigned int str_size;
+	int i, count;
+
+	if (avail < min_size)
+		return 0;
+
+	if (e->size < min_size || e->size > avail)
+		return 0;
+
+	str_size = e->size - min_size;
+	count = 0;
+	for (i = 0; i < str_size; i++) {
+		if (!e->strings[i])
+			count++;
+	}
+	if (count % 2 == 0)
+		return 0;
+	if (e->strings[str_size - 1])
+		return 0;
+	return 1;
+}
+
+static struct track_info *cache_entry_to_ti(struct cache_entry *e)
+{
+	const char *strings = e->strings;
+	struct track_info *ti;
+	struct keyval *kv;
+	int str_size = e->size - sizeof(*e);
+	int pos, i, count;
+	char *proc_filename;
+
+	if (pl_env_var(strings, NULL) && (proc_filename = pl_env_expand(strings))) {
+		ti = track_info_new(proc_filename);
+		free(proc_filename);
+	} else {
+		ti = track_info_new(strings);
+	}
+
+	ti->duration = e->duration;
+	ti->bitrate = e->bitrate;
+	ti->mtime = e->mtime;
+	ti->play_count = e->play_count;
+	ti->bpm = e->bpm;
+
+	// count strings (filename + codec + codec_profile + key/val pairs)
+	count = 0;
+	for (i = 0; i < str_size; i++) {
+		if (!strings[i])
+			count++;
+	}
+	count = (count - 3) / 2;
+
+	// NOTE: filename already copied by track_info_new()
+	pos = strlen(strings) + 1;
+	ti->codec = strings[pos] ? xstrdup(strings + pos) : NULL;
+	pos += strlen(strings + pos) + 1;
+	ti->codec_profile = strings[pos] ? xstrdup(strings + pos) : NULL;
+	pos += strlen(strings + pos) + 1;
+	kv = xnew(struct keyval, count + 1);
+	for (i = 0; i < count; i++) {
+		int size;
+
+		size = strlen(strings + pos) + 1;
+		kv[i].key = xstrdup(strings + pos);
+		pos += size;
+
+		size = strlen(strings + pos) + 1;
+		kv[i].val = xstrdup(strings + pos);
+		pos += size;
+	}
+	kv[i].key = NULL;
+	kv[i].val = NULL;
+	track_info_set_comments(ti, kv);
+	return ti;
+}
+
+struct track_info *lookup_cache_entry(const char *filename, unsigned int hash)
+{
+	struct track_info *ti = hash_table[hash % HASH_SIZE];
+
+	while (ti) {
+		if (!strcmp(filename, ti->filename))
+			return ti;
+		ti = ti->next;
+	}
+	return NULL;
+}
+
+static void do_cache_remove_ti(struct track_info *ti, unsigned int hash)
+{
+	unsigned int pos = hash % HASH_SIZE;
+	struct track_info *t = hash_table[pos];
+	struct track_info *next, *prev = NULL;
+
+	while (t) {
+		next = t->next;
+		if (t == ti) {
+			if (prev) {
+				prev->next = next;
+			} else {
+				hash_table[pos] = next;
+			}
+			total--;
+			track_info_unref(ti);
+			return;
+		}
+		prev = t;
+		t = next;
+	}
+}
+
+void cache_remove_ti(struct track_info *ti)
+{
+	do_cache_remove_ti(ti, hash_str(ti->filename));
+}
+
+static int read_cache(void)
+{
+	unsigned int size, offset = 0;
+	struct stat st = {};
+	char *buf;
+	int fd;
+
+	fd = open(cache_filename, O_RDONLY);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			return 0;
+		return -1;
+	}
+	fstat(fd, &st);
+	if (st.st_size < sizeof(cache_header))
+		goto close;
+	size = st.st_size;
+
+	buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+	if (buf == MAP_FAILED) {
+		close(fd);
+		return -1;
+	}
+
+	if (memcmp(buf, cache_header, sizeof(cache_header)))
+		goto corrupt;
+
+	offset = sizeof(cache_header);
+	while (offset < size) {
+		struct cache_entry *e = (void *)(buf + offset);
+		struct track_info *ti;
+
+		if (!valid_cache_entry(e, size - offset))
+			goto corrupt;
+
+		ti = cache_entry_to_ti(e);
+		add_ti(ti, hash_str(ti->filename));
+		offset += ALIGN(e->size);
+	}
+	munmap(buf, size);
+	close(fd);
+	return 0;
+corrupt:
+	munmap(buf, size);
+close:
+	close(fd);
+	// corrupt
+	return -2;
+}
+
+int cache_init(void)
+{
+	unsigned int flags = 0;
+
+#ifdef WORDS_BIGENDIAN
+	flags |= CACHE_BE;
+#endif
+	if (sizeof(long) == 8)
+		flags |= CACHE_64_BIT;
+
+	cache_header[7] = flags & 0xff; flags >>= 8;
+	cache_header[6] = flags & 0xff; flags >>= 8;
+	cache_header[5] = flags & 0xff; flags >>= 8;
+	cache_header[4] = flags & 0xff;
+
+	/* assumed version */
+	cache_header[3] = CACHE_VERSION;
+
+	cache_filename = xstrjoin(cmus_config_dir, "/cache");
+	return read_cache();
+}
+
+static int ti_filename_cmp(const void *a, const void *b)
+{
+	const struct track_info *ai = *(const struct track_info **)a;
+	const struct track_info *bi = *(const struct track_info **)b;
+
+	return strcmp(ai->filename, bi->filename);
+}
+
+static struct track_info **get_track_infos(bool reference)
+{
+	struct track_info **tis;
+	int i, c;
+
+	tis = xnew(struct track_info *, total);
+	c = 0;
+	for (i = 0; i < HASH_SIZE; i++) {
+		struct track_info *ti = hash_table[i];
+
+		while (ti) {
+			if (reference)
+				track_info_ref(ti);
+			tis[c++] = ti;
+			ti = ti->next;
+		}
+	}
+	qsort(tis, total, sizeof(struct track_info *), ti_filename_cmp);
+	return tis;
+}
+
+static void flush_buffer(int fd, struct gbuf *buf)
+{
+	if (buf->len) {
+		write_all(fd, buf->buffer, buf->len);
+		gbuf_clear(buf);
+	}
+}
+
+static void write_ti(int fd, struct gbuf *buf, struct track_info *ti, unsigned int *offsetp)
+{
+	char *proc_filename = pl_env_reduce(ti->filename);
+	const struct keyval *kv = ti->comments;
+	unsigned int offset = *offsetp;
+	unsigned int pad;
+	struct cache_entry e;
+	int *len, alloc = 64, count, i;
+
+	memset(e._reserved, CACHE_RESERVED_PATTERN, sizeof(e._reserved));
+
+	count = 0;
+	len = xnew(int, alloc);
+	e.size = sizeof(e);
+	e.duration = ti->duration;
+	e.bitrate = ti->bitrate;
+	e.mtime = ti->mtime;
+	e.play_count = ti->play_count;
+	e.bpm = ti->bpm;
+	len[count] = strlen(proc_filename) + 1;
+	e.size += len[count++];
+	len[count] = (ti->codec ? strlen(ti->codec) : 0) + 1;
+	e.size += len[count++];
+	len[count] = (ti->codec_profile ? strlen(ti->codec_profile) : 0) + 1;
+	e.size += len[count++];
+	for (i = 0; kv[i].key; i++) {
+		if (count + 2 > alloc) {
+			alloc *= 2;
+			len = xrenew(int, len, alloc);
+		}
+		len[count] = strlen(kv[i].key) + 1;
+		e.size += len[count++];
+		len[count] = strlen(kv[i].val) + 1;
+		e.size += len[count++];
+	}
+
+	pad = ALIGN(offset) - offset;
+	if (gbuf_avail(buf) < pad + e.size)
+		flush_buffer(fd, buf);
+
+	count = 0;
+	if (pad)
+		gbuf_set(buf, 0, pad);
+	gbuf_add_bytes(buf, &e, sizeof(e));
+	gbuf_add_bytes(buf, proc_filename, len[count++]);
+	gbuf_add_bytes(buf, ti->codec ? ti->codec : "", len[count++]);
+	gbuf_add_bytes(buf, ti->codec_profile ? ti->codec_profile : "", len[count++]);
+	for (i = 0; kv[i].key; i++) {
+		gbuf_add_bytes(buf, kv[i].key, len[count++]);
+		gbuf_add_bytes(buf, kv[i].val, len[count++]);
+	}
+
+	free(len);
+	*offsetp = offset + pad + e.size;
+
+	free(proc_filename);
+}
+
+int cache_close(void)
+{
+	GBUF(buf);
+	struct track_info **tis;
+	unsigned int offset;
+	int i, fd, rc;
+	char *tmp;
+
+	tmp = xstrjoin(cmus_config_dir, "/cache.tmp");
+	fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+	if (fd < 0) {
+		free(tmp);
+		return -1;
+	}
+
+	tis = get_track_infos(false);
+
+	gbuf_grow(&buf, 64 * 1024 - 1);
+	gbuf_add_bytes(&buf, cache_header, sizeof(cache_header));
+	offset = sizeof(cache_header);
+	for (i = 0; i < total; i++)
+		write_ti(fd, &buf, tis[i], &offset);
+	flush_buffer(fd, &buf);
+	gbuf_free(&buf);
+	free(tis);
+
+	close(fd);
+	rc = rename(tmp, cache_filename);
+	free(tmp);
+	return rc;
+}
+
+static struct track_info *ip_get_ti(const char *filename)
+{
+	struct track_info *ti = NULL;
+	struct input_plugin *ip;
+	struct keyval *comments;
+	int rc;
+
+	ip = ip_new(filename);
+	rc = ip_open(ip);
+	if (rc) {
+		ip_delete(ip);
+		return NULL;
+	}
+
+	rc = ip_read_comments(ip, &comments);
+	if (!rc) {
+		ti = track_info_new(filename);
+		track_info_set_comments(ti, comments);
+		ti->duration = ip_duration(ip);
+		ti->bitrate = ip_bitrate(ip);
+		ti->codec = ip_codec(ip);
+		ti->codec_profile = ip_codec_profile(ip);
+		ti->mtime = ip_is_remote(ip) ? -1 : file_get_mtime(filename);
+	}
+	ip_delete(ip);
+	return ti;
+}
+
+struct track_info *cache_get_ti(const char *filename, int force)
+{
+	unsigned int hash = hash_str(filename);
+	struct track_info *ti;
+	int reload = 0;
+
+	if (pl_env_var(filename, NULL)) {
+		struct growing_keyvals c = {NULL, 0, 0};
+		keyvals_terminate(&c);
+
+		ti = track_info_new(filename);
+		ti->duration = 0;
+		track_info_set_comments(ti, c.keyvals);
+
+		track_info_ref(ti);
+		return ti;
+	}
+
+	ti = lookup_cache_entry(filename, hash);
+	if (ti) {
+		if ((!skip_track_info && ti->duration == 0 && !is_http_url(filename)) || force){
+			do_cache_remove_ti(ti, hash);
+			ti = NULL;
+			reload = 1;
+		}
+	}
+	if (!ti) {
+		if (skip_track_info && !reload && !force) {
+			struct growing_keyvals c = {NULL, 0, 0};
+
+			ti = track_info_new(filename);
+
+			keyvals_terminate(&c);
+			track_info_set_comments(ti, c.keyvals);
+
+			ti->duration = 0;
+		} else {
+		       	ti = ip_get_ti(filename);
+		}
+		if (!ti)
+			return NULL;
+		add_ti(ti, hash);
+	}
+	track_info_ref(ti);
+	return ti;
+}
+
+struct track_info **cache_refresh(int *count, int force)
+{
+	struct track_info **tis = get_track_infos(true);
+	int i, n = total;
+
+	for (i = 0; i < n; i++) {
+		unsigned int hash;
+		struct track_info *ti = tis[i];
+		struct stat st;
+		int rc = 0;
+
+		cache_yield();
+
+		/*
+		 * If no-one else has reference to tis[i] then it is set to NULL
+		 * otherwise:
+		 *
+		 * unchanged: tis[i] = NULL
+		 * deleted:   tis[i]->next = NULL
+		 * changed:   tis[i]->next = new
+		 */
+
+		if (!is_url(ti->filename)) {
+			rc = stat(ti->filename, &st);
+			if (!rc && !force && ti->mtime == st.st_mtime) {
+				// unchanged
+				track_info_unref(ti);
+				tis[i] = NULL;
+				continue;
+			}
+		}
+
+		hash = hash_str(ti->filename);
+		do_cache_remove_ti(ti, hash);
+
+		if (!rc) {
+			// changed
+			struct track_info *new_ti;
+
+			// clear cache-only entries
+			if (force && track_info_unique_ref(ti)) {
+				track_info_unref(ti);
+				tis[i] = NULL;
+				continue;
+			}
+
+			new_ti = ip_get_ti(ti->filename);
+			if (new_ti) {
+				add_ti(new_ti, hash);
+
+				if (track_info_unique_ref(ti)) {
+					track_info_unref(ti);
+					tis[i] = NULL;
+				} else {
+					track_info_ref(new_ti);
+					ti->next = new_ti;
+				}
+				continue;
+			}
+			// treat as deleted
+		}
+
+		// deleted
+		if (track_info_unique_ref(ti)) {
+			track_info_unref(ti);
+			tis[i] = NULL;
+		} else {
+			ti->next = NULL;
+		}
+	}
+	*count = n;
+	return tis;
+}

cache.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_CACHE_H
+#define CMUS_CACHE_H
+
+#include "track_info.h"
+#include "locking.h"
+
+extern struct fifo_mutex cache_mutex;
+
+#define cache_lock() fifo_mutex_lock(&cache_mutex)
+#define cache_yield() fifo_mutex_yield(&cache_mutex)
+#define cache_unlock() fifo_mutex_unlock(&cache_mutex)
+
+int cache_init(void);
+int cache_close(void);
+struct track_info *cache_get_ti(const char *filename, int force);
+void cache_remove_ti(struct track_info *ti);
+struct track_info **cache_refresh(int *count, int force);
+struct track_info *lookup_cache_entry(const char *filename, unsigned int hash);
+
+#endif

channelmap.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "channelmap.h"
+#include "utils.h"
+
+void channel_map_init_waveex(int channels, unsigned int mask, channel_position_t *map)
+{
+	/* http://www.microsoft.com/whdc/device/audio/multichaud.mspx#EMLAC */
+	const channel_position_t channel_map_waveex[] = {
+		CHANNEL_POSITION_FRONT_LEFT,
+		CHANNEL_POSITION_FRONT_RIGHT,
+		CHANNEL_POSITION_FRONT_CENTER,
+		CHANNEL_POSITION_LFE,
+		CHANNEL_POSITION_REAR_LEFT,
+		CHANNEL_POSITION_REAR_RIGHT,
+		CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
+		CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
+		CHANNEL_POSITION_REAR_CENTER,
+		CHANNEL_POSITION_SIDE_LEFT,
+		CHANNEL_POSITION_SIDE_RIGHT,
+		CHANNEL_POSITION_TOP_CENTER,
+		CHANNEL_POSITION_TOP_FRONT_LEFT,
+		CHANNEL_POSITION_TOP_FRONT_CENTER,
+		CHANNEL_POSITION_TOP_FRONT_RIGHT,
+		CHANNEL_POSITION_TOP_REAR_LEFT,
+		CHANNEL_POSITION_TOP_REAR_CENTER,
+		CHANNEL_POSITION_TOP_REAR_RIGHT
+	};
+
+	if (channels == 1) {
+		map[0] = CHANNEL_POSITION_MONO;
+	} else if (channels > 1 && channels < N_ELEMENTS(channel_map_waveex)) {
+		int i, j = 0;
+
+		if (!mask)
+			mask = (1 << channels) - 1;
+
+		for (i = 0; i < N_ELEMENTS(channel_map_waveex); i++) {
+			if (mask & (1 << i))
+				map[j++] = channel_map_waveex[i];
+		}
+		if (j != channels)
+			map[0] = CHANNEL_POSITION_INVALID;
+	} else {
+		map[0] = CHANNEL_POSITION_INVALID;
+	}
+}

channelmap.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_CHANNELMAP_H
+#define CMUS_CHANNELMAP_H
+
+#include <string.h>
+
+#define CHANNELS_MAX 32
+
+/* Modelled after PulseAudio */
+enum channel_position {
+	CHANNEL_POSITION_INVALID = -1,
+	CHANNEL_POSITION_MONO = 0,
+	CHANNEL_POSITION_FRONT_LEFT,
+	CHANNEL_POSITION_FRONT_RIGHT,
+	CHANNEL_POSITION_FRONT_CENTER,
+
+	CHANNEL_POSITION_LEFT = CHANNEL_POSITION_FRONT_LEFT,
+	CHANNEL_POSITION_RIGHT = CHANNEL_POSITION_FRONT_RIGHT,
+	CHANNEL_POSITION_CENTER = CHANNEL_POSITION_FRONT_CENTER,
+
+	CHANNEL_POSITION_REAR_CENTER,
+	CHANNEL_POSITION_REAR_LEFT,
+	CHANNEL_POSITION_REAR_RIGHT,
+
+	CHANNEL_POSITION_LFE,
+	CHANNEL_POSITION_SUBWOOFER = CHANNEL_POSITION_LFE,
+
+	CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
+	CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
+
+	CHANNEL_POSITION_SIDE_LEFT,
+	CHANNEL_POSITION_SIDE_RIGHT,
+
+	CHANNEL_POSITION_TOP_CENTER,
+
+	CHANNEL_POSITION_TOP_FRONT_LEFT,
+	CHANNEL_POSITION_TOP_FRONT_RIGHT,
+	CHANNEL_POSITION_TOP_FRONT_CENTER,
+
+	CHANNEL_POSITION_TOP_REAR_LEFT,
+	CHANNEL_POSITION_TOP_REAR_RIGHT,
+	CHANNEL_POSITION_TOP_REAR_CENTER,
+
+	CHANNEL_POSITION_MAX
+};
+
+typedef enum channel_position	channel_position_t;
+
+#define CHANNEL_MAP_INIT	{ CHANNEL_POSITION_INVALID }
+
+#define CHANNEL_MAP(name) \
+	channel_position_t name[CHANNELS_MAX] = CHANNEL_MAP_INIT
+
+static inline int channel_map_valid(const channel_position_t *map)
+{
+	return map[0] != CHANNEL_POSITION_INVALID;
+}
+
+static inline int channel_map_equal(const channel_position_t *a, const channel_position_t *b, int channels)
+{
+	return memcmp(a, b, sizeof(*a) * channels) == 0;
+}
+
+static inline channel_position_t *channel_map_copy(channel_position_t *dst, const channel_position_t *src)
+{
+	return memcpy(dst, src, sizeof(*dst) * CHANNELS_MAX);
+}
+
+static inline void channel_map_init_stereo(channel_position_t *map)
+{
+	map[0] = CHANNEL_POSITION_LEFT;
+	map[1] = CHANNEL_POSITION_RIGHT;
+}
+
+void channel_map_init_waveex(int channels, unsigned int mask, channel_position_t *map);
+
+#endif

cmdline.c

@@ -0,0 +1,225 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cmdline.h"
+#include "uchar.h"
+#include "xmalloc.h"
+
+struct cmdline cmdline;
+
+const char cmdline_word_delimiters[]     = " ";
+const char cmdline_filename_delimiters[] = "/";
+
+void cmdline_init(void)
+{
+	cmdline.blen = 0;
+	cmdline.clen = 0;
+	cmdline.bpos = 0;
+	cmdline.cpos = 0;
+	cmdline.size = 128;
+	cmdline.line = xnew(char, cmdline.size);
+	cmdline.line[0] = 0;
+}
+
+void cmdline_insert_ch(uchar ch)
+{
+	int size;
+
+	size = u_char_size(ch);
+	if (cmdline.blen + size > cmdline.size) {
+		cmdline.size *= 2;
+		cmdline.line = xrenew(char, cmdline.line, cmdline.size);
+	}
+	memmove(cmdline.line + cmdline.bpos + size,
+		cmdline.line + cmdline.bpos,
+		cmdline.blen - cmdline.bpos + 1);
+	u_set_char_raw(cmdline.line, &cmdline.bpos, ch);
+	cmdline.cpos++;
+	cmdline.blen += size;
+	cmdline.clen++;
+}
+
+void cmdline_backspace(void)
+{
+	int bpos, size;
+
+	if (cmdline.bpos == 0)
+		return;
+
+	bpos = cmdline.bpos;
+	u_prev_char_pos(cmdline.line, &bpos);
+	size = cmdline.bpos - bpos;
+
+	memmove(cmdline.line + bpos,
+		cmdline.line + cmdline.bpos,
+		cmdline.blen - cmdline.bpos + 1);
+	cmdline.bpos -= size;
+	cmdline.cpos--;
+	cmdline.blen -= size;
+	cmdline.clen--;
+}
+
+void cmdline_backspace_to_bol(void)
+{
+	while (cmdline.bpos)
+		cmdline_backspace();
+}
+
+void cmdline_delete_ch(void)
+{
+	uchar ch;
+	int size, bpos;
+
+	if (cmdline.bpos == cmdline.blen)
+		return;
+	bpos = cmdline.bpos;
+	ch = u_get_char(cmdline.line, &bpos);
+	size = u_char_size(ch);
+	cmdline.blen -= size;
+	cmdline.clen--;
+	memmove(cmdline.line + cmdline.bpos,
+		cmdline.line + cmdline.bpos + size,
+		cmdline.blen - cmdline.bpos + 1);
+}
+
+void cmdline_set_text(const char *text)
+{
+	int len = strlen(text);
+
+	if (len >= cmdline.size) {
+		while (len >= cmdline.size)
+			cmdline.size *= 2;
+		cmdline.line = xrenew(char, cmdline.line, cmdline.size);
+	}
+	memcpy(cmdline.line, text, len + 1);
+	cmdline.cpos = u_strlen_safe(cmdline.line);
+	cmdline.bpos = len;
+	cmdline.clen = cmdline.cpos;
+	cmdline.blen = len;
+}
+
+void cmdline_clear(void)
+{
+	cmdline.blen = 0;
+	cmdline.clen = 0;
+	cmdline.bpos = 0;
+	cmdline.cpos = 0;
+	cmdline.line[0] = 0;
+}
+
+void cmdline_clear_end(void)
+{
+	cmdline.line[cmdline.bpos] = 0;
+
+	cmdline.clen = u_strlen_safe(cmdline.line);
+	cmdline.blen = strlen(cmdline.line);
+}
+
+void cmdline_move_left(void)
+{
+	if (cmdline.bpos > 0) {
+		cmdline.cpos--;
+		u_prev_char_pos(cmdline.line, &cmdline.bpos);
+	}
+}
+
+void cmdline_move_right(void)
+{
+	if (cmdline.bpos < cmdline.blen) {
+		u_get_char(cmdline.line, &cmdline.bpos);
+		cmdline.cpos++;
+	}
+}
+
+void cmdline_move_home(void)
+{
+	cmdline.cpos = 0;
+	cmdline.bpos = 0;
+}
+
+void cmdline_move_end(void)
+{
+	cmdline.cpos = cmdline.clen;
+	cmdline.bpos = cmdline.blen;
+}
+
+static int next_word(const char *str, int bpos, int *cdiff, const char *delim, int direction)
+{
+	int skip_delim = 1;
+	while ((direction > 0) ? str[bpos] : (bpos > 0)) {
+		uchar ch;
+		int oldp = bpos;
+
+		if (direction > 0) {
+			ch = u_get_char(str, &bpos);
+		} else {
+			u_prev_char_pos(str, &bpos);
+			oldp = bpos;
+			ch = u_get_char(str, &oldp);
+		}
+
+		if (u_strchr(delim, ch)) {
+			if (!skip_delim) {
+				bpos -= bpos - oldp;
+				break;
+			}
+		} else
+			skip_delim = 0;
+
+		*cdiff += direction;
+	}
+	return bpos;
+}
+
+void cmdline_forward_word(const char *delim)
+{
+	cmdline.bpos = next_word(cmdline.line, cmdline.bpos, &cmdline.cpos, delim, +1);
+}
+
+void cmdline_backward_word(const char *delim)
+{
+	cmdline.bpos = next_word(cmdline.line, cmdline.bpos, &cmdline.cpos, delim, -1);
+}
+
+void cmdline_delete_word(const char *delim)
+{
+	int bpos, cdiff = 0;
+
+	bpos = next_word(cmdline.line, cmdline.bpos, &cdiff, delim, +1);
+
+	memmove(cmdline.line + cmdline.bpos,
+		cmdline.line + bpos,
+		cmdline.blen - bpos + 1);
+	cmdline.blen -= bpos - cmdline.bpos;
+	cmdline.clen -= cdiff;
+}
+
+void cmdline_backward_delete_word(const char *delim)
+{
+	int bpos, cdiff = 0;
+
+	bpos = next_word(cmdline.line, cmdline.bpos, &cdiff, delim, -1);
+
+	cmdline.blen += bpos - cmdline.bpos;
+	memmove(cmdline.line + bpos,
+		cmdline.line + cmdline.bpos,
+		cmdline.blen - bpos + 1);
+	cmdline.bpos = bpos;
+	cmdline.clen += cdiff;
+	cmdline.cpos += cdiff;
+}

cmdline.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMDLINE_H
+#define CMDLINE_H
+
+#include "uchar.h"
+
+struct cmdline {
+	/* length in bytes */
+	int blen;
+
+	/* length in characters */
+	int clen;
+
+	/* pos in bytes */
+	int bpos;
+
+	/* pos in characters */
+	int cpos;
+
+	/* allocated size */
+	int size;
+
+	char *line;
+};
+
+extern struct cmdline cmdline;
+
+extern const char cmdline_word_delimiters[];
+extern const char cmdline_filename_delimiters[];
+
+void cmdline_init(void);
+void cmdline_insert_ch(uchar ch);
+void cmdline_backspace(void);
+void cmdline_backspace_to_bol(void);
+void cmdline_delete_ch(void);
+void cmdline_set_text(const char *text);
+void cmdline_clear(void);
+void cmdline_clear_end(void);
+void cmdline_move_left(void);
+void cmdline_move_right(void);
+void cmdline_move_home(void);
+void cmdline_move_end(void);
+
+void cmdline_forward_word(const char *delim);
+void cmdline_backward_word(const char *delim);
+void cmdline_delete_word(const char *delim);
+void cmdline_backward_delete_word(const char *delim);
+
+#endif

cmus-status-display

@@ -0,0 +1,50 @@
+#!/bin/sh
+#
+# cmus-status-display
+#
+# Usage:
+#   in cmus command ":set status_display_program=cmus-status-display"
+#
+# This scripts is executed by cmus when status changes:
+#   cmus-status-display key1 val1 key2 val2 ...
+#
+# All keys contain only chars a-z. Values are UTF-8 strings.
+#
+# Keys: status file url artist album discnumber tracknumber title date
+#   - status (stopped, playing, paused) is always given
+#   - file or url is given only if track is 'loaded' in cmus
+#   - other keys/values are given only if they are available
+#
+
+output()
+{
+	# write status to ~/cmus-status.txt (not very useful though)
+	echo "$*" >> ~/cmus-status.txt 2>&1
+
+	# WMI (http://wmi.modprobe.de/)
+	#wmiremote -t "$*" &> /dev/null
+}
+
+while test $# -ge 2
+do
+	eval _$1='$2'
+	shift
+	shift
+done
+
+if test -n "$_file"
+then
+	h=$(($_duration / 3600))
+	m=$(($_duration % 3600))
+
+	duration=""
+	test $h -gt 0 && dur="$h:"
+	duration="$dur$(printf '%02d:%02d' $(($m / 60)) $(($m % 60)))"
+
+	output "[$_status] $_artist - $_album - $_title ($_date) $duration"
+elif test -n "$_url"
+then
+	output "[$_status] $_url - $_title"
+else
+	output "[$_status]"
+fi

cmus.c

@@ -0,0 +1,549 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cmus.h"
+#include "job.h"
+#include "lib.h"
+#include "pl.h"
+#include "player.h"
+#include "input.h"
+#include "play_queue.h"
+#include "cache.h"
+#include "misc.h"
+#include "file.h"
+#include "utils.h"
+#include "path.h"
+#include "options.h"
+#include "command_mode.h"
+#include "xmalloc.h"
+#include "debug.h"
+#include "load_dir.h"
+#include "ui_curses.h"
+#include "cache.h"
+#include "gbuf.h"
+#include "discid.h"
+#include "locking.h"
+#include "pl_env.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <strings.h>
+
+/* save_playlist_cb, save_ext_playlist_cb */
+typedef int (*save_tracks_cb)(void *data, struct track_info *ti);
+
+static char **playable_exts;
+static const char * const playlist_exts[] = { "m3u", "pl", "pls", NULL };
+
+int cmus_next_track_request_fd;
+static bool play_queue_active = false;
+static int cmus_next_track_request_fd_priv;
+static pthread_mutex_t cmus_next_file_mutex = CMUS_MUTEX_INITIALIZER;
+static pthread_cond_t cmus_next_file_cond = CMUS_COND_INITIALIZER;
+static int cmus_next_file_provided;
+static struct track_info *cmus_next_file;
+
+static int x11_init_done = 0;
+static void *(*x11_open)(void *) = NULL;
+static int (*x11_raise)(void *, int) = NULL;
+static int (*x11_close)(void *) = NULL;
+
+int cmus_init(void)
+{
+	playable_exts = ip_get_supported_extensions();
+	cache_init();
+	job_init();
+	play_queue_init();
+	return 0;
+}
+
+void cmus_exit(void)
+{
+	job_exit();
+	if (cache_close())
+		d_print("error: %s\n", strerror(errno));
+}
+
+void cmus_next(void)
+{
+	struct track_info *info = cmus_get_next_track();
+	if (info)
+		player_set_file(info);
+}
+
+void cmus_prev(void)
+{
+	struct track_info *info;
+
+	if (play_library) {
+		info = lib_goto_prev();
+	} else {
+		info = pl_goto_prev();
+	}
+
+	if (info)
+		player_set_file(info);
+}
+
+void cmus_next_album(void)
+{
+	struct track_info *info;
+
+	if (play_library) {
+		info = lib_goto_next_album();
+	} else {
+		info = pl_goto_next();
+	}
+
+	if (info)
+		player_set_file(info);
+}
+
+void cmus_prev_album(void)
+{
+	struct track_info *info;
+
+	if (play_library) {
+		info = lib_goto_prev_album();
+	} else {
+		info = pl_goto_prev();
+	}
+
+	if (info)
+		player_set_file(info);
+}
+
+void cmus_play_file(const char *filename)
+{
+	struct track_info *ti;
+
+	cache_lock();
+	ti = cache_get_ti(filename, 0);
+	cache_unlock();
+	if (!ti) {
+		error_msg("Couldn't get file information for %s\n", filename);
+		return;
+	}
+
+	player_play_file(ti);
+}
+
+enum file_type cmus_detect_ft(const char *name, char **ret)
+{
+	char *absolute;
+	struct stat st;
+
+	if (is_http_url(name) || is_cue_url(name)) {
+		*ret = xstrdup(name);
+		return FILE_TYPE_URL;
+	}
+
+	if (is_cdda_url(name)) {
+		*ret = complete_cdda_url(cdda_device, name);
+		return FILE_TYPE_CDDA;
+	}
+
+	*ret = NULL;
+	absolute = path_absolute(name);
+	if (absolute == NULL)
+		return FILE_TYPE_INVALID;
+
+	/* stat follows symlinks, lstat does not */
+	if (stat(absolute, &st) == -1) {
+		free(absolute);
+		return FILE_TYPE_INVALID;
+	}
+
+	if (S_ISDIR(st.st_mode)) {
+		*ret = absolute;
+		return FILE_TYPE_DIR;
+	}
+	if (!S_ISREG(st.st_mode)) {
+		free(absolute);
+		errno = EINVAL;
+		return FILE_TYPE_INVALID;
+	}
+
+	*ret = absolute;
+	if (cmus_is_playlist(absolute))
+		return FILE_TYPE_PL;
+
+	/* NOTE: it could be FILE_TYPE_PL too! */
+	return FILE_TYPE_FILE;
+}
+
+void cmus_add(add_ti_cb add, const char *name, enum file_type ft, int jt, int force,
+		void *opaque)
+{
+	struct add_data *data = xnew(struct add_data, 1);
+
+	data->add = add;
+	data->name = xstrdup(name);
+	data->type = ft;
+	data->force = force;
+	data->opaque = opaque;
+
+	job_schedule_add(jt, data);
+}
+
+static int save_ext_playlist_cb(void *data, struct track_info *ti)
+{
+	GBUF(buf);
+	int fd = *(int *)data;
+	int i, rc;
+
+	gbuf_addf(&buf, "file %s\n", escape(ti->filename));
+	gbuf_addf(&buf, "duration %d\n", ti->duration);
+	gbuf_addf(&buf, "codec %s\n", ti->codec);
+	gbuf_addf(&buf, "bitrate %ld\n", ti->bitrate);
+	for (i = 0; ti->comments[i].key; i++)
+		gbuf_addf(&buf, "tag %s %s\n",
+				ti->comments[i].key,
+				escape(ti->comments[i].val));
+
+	rc = write_all(fd, buf.buffer, buf.len);
+	gbuf_free(&buf);
+
+	if (rc == -1)
+		return -1;
+	return 0;
+}
+
+static int save_playlist_cb(void *data, struct track_info *ti)
+{
+	char *proc_filename = pl_env_reduce(ti->filename);
+	int fd = *(int *)data;
+	const char nl = '\n';
+	int rc;
+
+	rc = write_all(fd, proc_filename, strlen(proc_filename));
+	free(proc_filename);
+	if (rc == -1)
+		return -1;
+
+	rc = write_all(fd, &nl, 1);
+	if (rc == -1)
+		return -1;
+
+	return 0;
+}
+
+static int do_cmus_save(for_each_ti_cb for_each_ti, const char *filename,
+		save_tracks_cb save_tracks, void *opaque)
+{
+	int fd, rc;
+
+	if (strcmp(filename, "-") == 0) {
+		if (get_client_fd() == -1) {
+			error_msg("saving to stdout works only remotely");
+			return 0;
+		}
+		fd = dup(get_client_fd());
+	} else
+		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+	if (fd == -1)
+		return -1;
+	rc = for_each_ti(save_tracks, &fd, opaque);
+	close(fd);
+	return rc;
+}
+
+int cmus_save(for_each_ti_cb for_each_ti, const char *filename, void *opaque)
+{
+	return do_cmus_save(for_each_ti, filename, save_playlist_cb, opaque);
+}
+
+int cmus_save_ext(for_each_ti_cb for_each_ti, const char *filename,
+		void *opaque)
+{
+	return do_cmus_save(for_each_ti, filename, save_ext_playlist_cb,
+			opaque);
+}
+
+static int update_cb(void *data, struct track_info *ti)
+{
+	struct update_data *d = data;
+
+	if (d->size == d->used) {
+		if (d->size == 0)
+			d->size = 16;
+		d->size *= 2;
+		d->ti = xrenew(struct track_info *, d->ti, d->size);
+	}
+	track_info_ref(ti);
+	d->ti[d->used++] = ti;
+	return 0;
+}
+
+void cmus_update_cache(int force)
+{
+	struct update_cache_data *data;
+
+	data = xnew(struct update_cache_data, 1);
+	data->force = force;
+
+	job_schedule_update_cache(JOB_TYPE_LIB, data);
+}
+
+void cmus_update_lib(void)
+{
+	struct update_data *data;
+
+	data = xnew0(struct update_data, 1);
+
+	lib_for_each(update_cb, data, NULL);
+
+	job_schedule_update(data);
+}
+
+void cmus_update_tis(struct track_info **tis, int nr, int force)
+{
+	struct update_data *data;
+
+	data = xnew(struct update_data, 1);
+	data->size = nr;
+	data->used = nr;
+	data->ti = tis;
+	data->force = force;
+
+	job_schedule_update(data);
+}
+
+static const char *get_ext(const char *filename)
+{
+	const char *ext = strrchr(filename, '.');
+
+	if (ext)
+		ext++;
+	return ext;
+}
+
+static int str_in_array(const char *str, const char * const *array)
+{
+	int i;
+
+	for (i = 0; array[i]; i++) {
+		if (strcasecmp(str, array[i]) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+int cmus_is_playlist(const char *filename)
+{
+	const char *ext = get_ext(filename);
+
+	return ext && str_in_array(ext, playlist_exts);
+}
+
+int cmus_is_playable(const char *filename)
+{
+	const char *ext = get_ext(filename);
+
+	return ext && str_in_array(ext, (const char * const *)playable_exts);
+}
+
+int cmus_is_supported(const char *filename)
+{
+	const char *ext = get_ext(filename);
+
+	return ext && (str_in_array(ext, (const char * const *)playable_exts) ||
+			str_in_array(ext, playlist_exts));
+}
+
+struct pl_data {
+	int (*cb)(void *data, const char *line);
+	void *data;
+};
+
+static int pl_handle_line(void *data, const char *line)
+{
+	struct pl_data *d = data;
+	int i = 0;
+
+	while (isspace((unsigned char)line[i]))
+		i++;
+	if (line[i] == 0)
+		return 0;
+
+	if (line[i] == '#')
+		return 0;
+
+	return d->cb(d->data, line);
+}
+
+static int pls_handle_line(void *data, const char *line)
+{
+	struct pl_data *d = data;
+
+	if (strncasecmp(line, "file", 4))
+		return 0;
+	line = strchr(line, '=');
+	if (line == NULL)
+		return 0;
+	return d->cb(d->data, line + 1);
+}
+
+int cmus_playlist_for_each(const char *buf, int size, int reverse,
+		int (*cb)(void *data, const char *line),
+		void *data)
+{
+	struct pl_data d = { cb, data };
+	int (*handler)(void *, const char *);
+
+	handler = pl_handle_line;
+	if (size >= 10 && strncasecmp(buf, "[playlist]", 10) == 0)
+		handler = pls_handle_line;
+
+	if (reverse) {
+		buffer_for_each_line_reverse(buf, size, handler, &d);
+	} else {
+		buffer_for_each_line(buf, size, handler, &d);
+	}
+	return 0;
+}
+
+/* multi-threaded next track requests */
+
+#define cmus_next_file_lock() cmus_mutex_lock(&cmus_next_file_mutex)
+#define cmus_next_file_unlock() cmus_mutex_unlock(&cmus_next_file_mutex)
+
+static struct track_info *cmus_get_next_from_main_thread(void)
+{
+	struct track_info *ti = play_queue_remove();
+	if (ti) {
+		play_queue_active = true;
+	} else {
+		if (!play_queue_active || !stop_after_queue)
+			ti = play_library ? lib_goto_next() : pl_goto_next();
+		play_queue_active = false;
+	}
+	return ti;
+}
+
+static struct track_info *cmus_get_next_from_other_thread(void)
+{
+	static pthread_mutex_t mutex = CMUS_MUTEX_INITIALIZER;
+	cmus_mutex_lock(&mutex);
+
+	/* only one thread may request a track at a time */
+
+	notify_via_pipe(cmus_next_track_request_fd_priv);
+
+	cmus_next_file_lock();
+	while (!cmus_next_file_provided)
+		pthread_cond_wait(&cmus_next_file_cond, &cmus_next_file_mutex);
+	struct track_info *ti = cmus_next_file;
+	cmus_next_file_provided = 0;
+	cmus_next_file_unlock();
+
+	cmus_mutex_unlock(&mutex);
+
+	return ti;
+}
+
+struct track_info *cmus_get_next_track(void)
+{
+	pthread_t this_thread = pthread_self();
+	if (pthread_equal(this_thread, main_thread))
+		return cmus_get_next_from_main_thread();
+	return cmus_get_next_from_other_thread();
+}
+
+void cmus_provide_next_track(void)
+{
+	clear_pipe(cmus_next_track_request_fd, 1);
+
+	cmus_next_file_lock();
+	cmus_next_file = cmus_get_next_from_main_thread();
+	cmus_next_file_provided = 1;
+	cmus_next_file_unlock();
+
+	pthread_cond_broadcast(&cmus_next_file_cond);
+}
+
+void cmus_track_request_init(void)
+{
+	init_pipes(&cmus_next_track_request_fd, &cmus_next_track_request_fd_priv);
+}
+
+static int cmus_can_raise_vte_x11(void)
+{
+	return getenv("DISPLAY") && getenv("WINDOWID");
+}
+
+int cmus_can_raise_vte(void)
+{
+	return cmus_can_raise_vte_x11();
+}
+
+static int cmus_raise_vte_x11_error(void)
+{
+	return 0;
+}
+
+void cmus_raise_vte(void)
+{
+	if (cmus_can_raise_vte_x11()) {
+		if (!x11_init_done) {
+			void *x11;
+
+			x11_init_done = 1;
+			x11 = dlopen("libX11.so", RTLD_LAZY);
+
+			if (x11) {
+				int (*x11_error)(void *);
+
+				x11_error = dlsym(x11, "XSetErrorHandler");
+				x11_open = dlsym(x11, "XOpenDisplay");
+				x11_raise = dlsym(x11, "XRaiseWindow");
+				x11_close = dlsym(x11, "XCloseDisplay");
+
+				if (x11_error) {
+					x11_error(cmus_raise_vte_x11_error);
+				}
+			}
+		}
+
+		if (x11_open && x11_raise && x11_close) {
+			char *xid_str;
+			long int xid = 0;
+
+			xid_str = getenv("WINDOWID");
+			if (!str_to_int(xid_str, &xid) && xid != 0) {
+				void *display;
+
+				display = x11_open(NULL);
+				if (display) {
+					x11_raise(display, (int) xid);
+					x11_close(display);
+				}
+			}
+		}
+	}
+}
+
+bool cmus_queue_active(void) {
+	return play_queue_active;
+}

cmus.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_API_H
+#define CMUS_API_H
+
+#include "track_info.h"
+
+enum file_type {
+	/* not found, device file... */
+	FILE_TYPE_INVALID,
+
+	FILE_TYPE_URL,
+	FILE_TYPE_PL,
+	FILE_TYPE_DIR,
+	FILE_TYPE_FILE,
+	FILE_TYPE_CDDA
+};
+
+typedef int (*track_info_cb)(void *data, struct track_info *ti);
+
+/* lib_for_each, lib_for_each_filtered, pl_for_each, play_queue_for_each */
+typedef int (*for_each_ti_cb)(track_info_cb cb, void *data, void *opaque);
+
+/* lib_for_each_sel, pl_for_each_sel, play_queue_for_each_sel */
+typedef int (*for_each_sel_ti_cb)(track_info_cb cb, void *data, int reverse, int advance);
+
+/* lib_add_track, pl_add_track, play_queue_append, play_queue_prepend */
+typedef void (*add_ti_cb)(struct track_info *, void *opaque);
+
+/* cmus_save, cmus_save_ext */
+typedef int (*save_ti_cb)(for_each_ti_cb for_each_ti, const char *filename,
+		void *opaque);
+
+int cmus_init(void);
+void cmus_exit(void);
+void cmus_play_file(const char *filename);
+
+/* detect file type, returns absolute path or url in @ret */
+enum file_type cmus_detect_ft(const char *name, char **ret);
+
+/* add to library, playlist or queue view
+ *
+ * @add   callback that does the actual adding
+ * @name  playlist, directory, file, URL
+ * @ft    detected FILE_TYPE_*
+ * @jt    JOB_TYPE_{LIB,PL,QUEUE}
+ *
+ * returns immediately, actual work is done in the worker thread.
+ */
+void cmus_add(add_ti_cb, const char *name, enum file_type ft, int jt,
+		int force, void *opaque);
+
+int cmus_save(for_each_ti_cb for_each_ti, const char *filename, void *opaque);
+int cmus_save_ext(for_each_ti_cb for_each_ti, const char *filename,
+		void *opaque);
+
+void cmus_update_cache(int force);
+void cmus_update_lib(void);
+void cmus_update_tis(struct track_info **tis, int nr, int force);
+
+int cmus_is_playlist(const char *filename);
+int cmus_is_playable(const char *filename);
+int cmus_is_supported(const char *filename);
+
+int cmus_playlist_for_each(const char *buf, int size, int reverse,
+		int (*cb)(void *data, const char *line),
+		void *data);
+
+void cmus_next(void);
+void cmus_prev(void);
+void cmus_next_album(void);
+void cmus_prev_album(void);
+
+extern int cmus_next_track_request_fd;
+struct track_info *cmus_get_next_track(void);
+void cmus_provide_next_track(void);
+void cmus_track_request_init(void);
+
+int cmus_can_raise_vte(void);
+void cmus_raise_vte(void);
+
+bool cmus_queue_active(void);
+
+#endif

command_mode.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2006 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_COMMAND_MODE_H
+#define CMUS_COMMAND_MODE_H
+
+#include "uchar.h"
+
+#if defined(__sun__)
+#include <ncurses.h>
+#else
+#include <curses.h>
+#endif
+
+enum {
+	/* executing command is disabled over net */
+	CMD_UNSAFE	= 1 << 0,
+	/* execute command after every typed/deleted character */
+	CMD_LIVE	= 1 << 1,
+	/* hide command from completion, useful for deprecated commands */
+	CMD_HIDDEN	= 1 << 2,
+};
+
+struct command {
+	const char *name;
+	void (*func)(char *arg);
+
+	/* min/max number of arguments */
+	int min_args;
+	int max_args;
+
+	void (*expand)(const char *str);
+
+	/* bind count (0 means: unbound) */
+	int bc;
+
+	/* CMD_* */
+	unsigned int flags;
+};
+
+extern struct command commands[];
+extern int run_only_safe_commands;
+
+void command_mode_ch(uchar ch);
+void command_mode_escape(int c);
+void command_mode_key(int key);
+void command_mode_mouse(MEVENT *event);
+void commands_init(void);
+void commands_exit(void);
+int parse_command(const char *buf, char **cmdp, char **argp);
+char **parse_cmd(const char *cmd, int *args_idx, int *ac);
+void run_parsed_command(char *cmd, char *arg);
+void run_command(const char *buf);
+
+struct command *get_command(const char *str);
+
+void view_clear(int view);
+void view_add(int view, char *arg, int prepend);
+void view_load(int view, char *arg);
+void view_save(int view, char *arg, int to_stdout, int filtered, int extended);
+
+struct window *current_win(void);
+
+#endif

comment.c

@@ -0,0 +1,296 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2007 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "comment.h"
+#include "xmalloc.h"
+#include "utils.h"
+#include "uchar.h"
+
+#include <string.h>
+#include <strings.h>
+
+static int is_various_artists(const char *a)
+{
+	return strcasecmp(a, "Various Artists") == 0 ||
+	       strcasecmp(a, "Various")         == 0 ||
+	       strcasecmp(a, "VA")              == 0 ||
+	       strcasecmp(a, "V/A")             == 0;
+}
+
+int track_is_compilation(const struct keyval *comments)
+{
+	const char *c, *a, *aa;
+
+	c = keyvals_get_val(comments, "compilation");
+	if (c && is_freeform_true(c))
+		return 1;
+
+	c = keyvals_get_val(comments, "partofacompilation");
+	if (c && is_freeform_true(c))
+		return 1;
+
+	aa = keyvals_get_val(comments, "albumartist");
+	if (aa && is_various_artists(aa))
+		return 1;
+
+	a = keyvals_get_val(comments, "artist");
+	if (a && is_various_artists(a))
+		return 1;
+
+	if (aa && a && !u_strcase_equal(aa, a))
+		return 1;
+
+	return 0;
+}
+
+int track_is_va_compilation(const struct keyval *comments)
+{
+	const char *c, *a, *aa;
+
+	aa = keyvals_get_val(comments, "albumartist");
+	if (aa)
+		return is_various_artists(aa);
+
+	a = keyvals_get_val(comments, "artist");
+	if (a && is_various_artists(a))
+		return 1;
+
+	c = keyvals_get_val(comments, "compilation");
+	if (c && is_freeform_true(c))
+		return 1;
+
+	c = keyvals_get_val(comments, "partofacompilation");
+	if (c && is_freeform_true(c))
+		return 1;
+
+	return 0;
+}
+
+const char *comments_get_albumartist(const struct keyval *comments)
+{
+	const char *val = keyvals_get_val(comments, "albumartist");
+
+	if (!val || strcmp(val, "") == 0)
+		val = keyvals_get_val(comments, "artist");
+
+	return val;
+}
+
+const char *comments_get_artistsort(const struct keyval *comments)
+{
+	const char *val;
+
+	if (track_is_va_compilation(comments))
+		return NULL;
+
+	val = keyvals_get_val(comments, "albumartistsort");
+	if (!track_is_compilation(comments)) {
+		if (!val || strcmp(val, "") == 0)
+			val = keyvals_get_val(comments, "artistsort");
+	}
+
+	if (!val || strcmp(val, "") == 0)
+		return NULL;
+
+	return val;
+}
+
+int comments_get_int(const struct keyval *comments, const char *key)
+{
+	const char *val;
+	long int ival;
+
+	val = keyvals_get_val(comments, key);
+	if (val == NULL)
+		return -1;
+	while (*val && !(*val >= '0' && *val <= '9'))
+		val++;
+	if (str_to_int(val, &ival) == -1)
+		return -1;
+	return ival;
+}
+
+int comments_get_signed_int(const struct keyval *comments, const char *key, long int *ival)
+{
+	const char *val;
+
+	val = keyvals_get_val(comments, key);
+	if (val == NULL)
+		return -1;
+	while (*val && !(*val == '+' || *val == '-' || (*val >= '0' && *val <= '9')))
+		val++;
+	return str_to_int(val, ival);
+}
+
+double comments_get_double(const struct keyval *comments, const char *key)
+{
+	const char *val;
+	char *end;
+	double d;
+
+	val = keyvals_get_val(comments, key);
+	if (!val || strcmp(val, "") == 0)
+		goto error;
+
+	d = strtod(val, &end);
+	if (val == end)
+		goto error;
+
+	return d;
+
+error:
+	return strtod("NAN", NULL);
+}
+
+/* Return date as an integer in the form YYYYMMDD, for sorting purposes.
+ * This function is not year 10000 compliant. */
+int comments_get_date(const struct keyval *comments, const char *key)
+{
+	const char *val;
+	char *endptr;
+	int year, month, day;
+	long int ival;
+
+	val = keyvals_get_val(comments, key);
+	if (val == NULL)
+		return -1;
+
+	year = strtol(val, &endptr, 10);
+	/* Looking for a four-digit number */
+	if (year < 1000 || year > 9999)
+		return -1;
+	ival = year * 10000;
+
+	if (*endptr == '-' || *endptr == ' ' || *endptr == '/') {
+		month = strtol(endptr+1, &endptr, 10);
+		if (month < 1 || month > 12)
+			return ival;
+		ival += month * 100;
+	}
+
+	if (*endptr == '-' || *endptr == ' ' || *endptr == '/') {
+		day = strtol(endptr+1, &endptr, 10);
+		if (day < 1 || day > 31)
+			return ival;
+		ival += day;
+	}
+
+
+	return ival;
+}
+
+static const char *interesting[] = {
+	"artist", "album", "title", "tracknumber", "discnumber", "totaldiscs", "genre",
+	"date", "compilation", "partofacompilation", "albumartist", "artistsort", "albumartistsort",
+	"albumsort",
+	"originaldate",
+	"r128_track_gain",
+	"r128_album_gain",
+	"replaygain_track_gain",
+	"replaygain_track_peak",
+	"replaygain_album_gain",
+	"replaygain_album_peak",
+	"musicbrainz_trackid",
+	"comment",
+	"bpm",
+	"arranger", "composer", "conductor", "lyricist", "performer",
+	"remixer", "label", "publisher", "work", "opus",
+	"subtitle", "media",
+	NULL
+};
+
+static struct {
+	const char *old;
+	const char *new;
+} key_map[] = {
+	{ "album_artist", "albumartist" },
+	{ "album artist", "albumartist" },
+	{ "disc", "discnumber" },
+	{ "part", "discnumber" },
+	{ "partnumber", "discnumber" },
+	{ "disctotal", "totaldiscs" },
+	{ "tempo", "bpm" },
+	{ "track", "tracknumber" },
+	{ "WM/Year", "date" },
+	{ "WM/ArtistSortOrder", "artistsort" },
+	{ "WM/AlbumArtistSortOrder", "albumartistsort" },
+	{ "WM/AlbumSortOrder", "albumsort" },
+	{ "WM/OriginalReleaseYear", "originaldate" },
+	{ "WM/Media", "media" },
+	{ "sourcemedia", "media" },
+	{ "MusicBrainz Track Id", "musicbrainz_trackid" },
+	{ "version", "subtitle" },
+	/* ffmpeg id3 */
+	{ "artist-sort", "artistsort" },
+	{ "TSO2", "albumartistsort" },
+	{ "album-sort", "albumsort" },
+	/* ffmpeg mp4 */
+	{ "sort_artist", "artistsort" },
+	{ "sort_album_artist", "albumartistsort" },
+	{ "sort_album", "albumsort" },
+	{ NULL, NULL }
+};
+
+static const char *fix_key(const char *key)
+{
+	int i;
+
+	for (i = 0; interesting[i]; i++) {
+		if (!strcasecmp(key, interesting[i]))
+			return interesting[i];
+	}
+	for (i = 0; key_map[i].old; i++) {
+		if (!strcasecmp(key, key_map[i].old))
+			return key_map[i].new;
+	}
+	return NULL;
+}
+
+int comments_add(struct growing_keyvals *c, const char *key, char *val)
+{
+	if (!strcasecmp(key, "songwriter")) {
+		int r = comments_add_const(c, "lyricist", val);
+		return comments_add(c, "composer", val) && r;
+	}
+
+	key = fix_key(key);
+	if (!key) {
+		free(val);
+		return 0;
+	}
+
+	if (!strcmp(key, "tracknumber") || !strcmp(key, "discnumber")) {
+		char *slash = strchr(val, '/');
+		if (slash)
+			*slash = 0;
+	}
+
+	/* don't add duplicates */
+	if (keyvals_get_val_growing(c, key)) {
+		free(val);
+		return 0;
+	}
+
+	keyvals_add(c, key, val);
+	return 1;
+}
+
+int comments_add_const(struct growing_keyvals *c, const char *key, const char *val)
+{
+	return comments_add(c, key, xstrdup(val));
+}

comment.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_COMMENT_H
+#define CMUS_COMMENT_H
+
+#include "keyval.h"
+
+int track_is_compilation(const struct keyval *comments);
+int track_is_va_compilation(const struct keyval *comments);
+
+const char *comments_get_albumartist(const struct keyval *comments);
+const char *comments_get_artistsort(const struct keyval *comments); /* can return NULL */
+
+int comments_get_int(const struct keyval *comments, const char *key);
+int comments_get_signed_int(const struct keyval *comments, const char *key, long int *ival);
+double comments_get_double(const struct keyval *comments, const char *key);
+int comments_get_date(const struct keyval *comments, const char *key);
+
+int comments_add(struct growing_keyvals *c, const char *key, char *val);
+int comments_add_const(struct growing_keyvals *c, const char *key, const char *val);
+
+#endif

compiler.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_COMPILER_H
+#define CMUS_COMPILER_H
+
+#include <stddef.h>
+
+/*
+ * GCC 2.96 or compatible required
+ */
+#if defined(__GNUC__)
+
+#if __GNUC__ > 3
+#undef offsetof
+#define offsetof(type, member) __builtin_offsetof(type, member)
+#endif
+
+/* Optimization: Condition @x is likely */
+#define likely(x)	__builtin_expect(!!(x), 1)
+
+/* Optimization: Condition @x is unlikely */
+#define unlikely(x)	__builtin_expect(!!(x), 0)
+
+#ifndef UNUSED
+#define UNUSED __attribute__((unused))
+#endif
+
+#else
+
+#define likely(x)	(x)
+#define unlikely(x)	(x)
+#define UNUSED
+
+#endif
+
+/* Optimization: Function never returns */
+#define CMUS_NORETURN	__attribute__((__noreturn__))
+
+/* Argument at index @fmt_idx is printf compatible format string and
+ * argument at index @first_idx is the first format argument */
+#define CMUS_FORMAT(fmt_idx, first_idx) __attribute__((format(printf, (fmt_idx), (first_idx))))
+
+#if defined(__GNUC__) && (__GNUC__ >= 3)
+
+/* Optimization: Pointer returned can't alias other pointers */
+#define CMUS_MALLOC	__attribute__((__malloc__))
+
+#else
+
+#define CMUS_MALLOC
+
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ >= 8)
+
+/* Silences the unterminated-string-initialization warnings */
+#define CMUS_NONSTRING __attribute__((nonstring))
+
+#else
+
+#define CMUS_NONSTRING
+
+#endif
+
+
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ *
+ * @ptr:	the pointer to the member.
+ * @type:	the type of the container struct this is embedded in.
+ * @member:	the name of the member within the struct.
+ *
+ */
+#define container_of_portable(ptr, type, member) \
+	((type *)(void *)( (char *)(ptr) - offsetof(type,member)))
+#undef container_of
+#if defined(__GNUC__)
+#define container_of(ptr, type, member) __extension__ ({		\
+	const __typeof__( ((type *)0)->member) *_mptr = (ptr);	\
+	container_of_portable(_mptr, type, member);})
+#else
+#define container_of(ptr, type, member) container_of_portable(ptr, type, member)
+#endif
+
+#endif

configure

@@ -0,0 +1,721 @@
+#!/bin/sh
+
+. scripts/configure.sh || exit 1
+
+c11_code="
+#include <stdatomic.h>
+
+int main(void)
+{
+#ifdef __STDC_NO_ATOMICS__
+#error No C11 atomics
+#endif
+	_Atomic int res = ATOMIC_VAR_INIT(0);
+
+	return res;
+}
+"
+
+check_c11()
+{
+	msg_checking "for C11 (with atomics support)"
+
+	for flag in -std=gnu11 -std=c11 ""
+	do
+		if try_compile_link "$c11_code" $flag
+		then
+			EXTRA_CFLAGS="$EXTRA_CFLAGS $flag"
+			msg_result yes
+			working_c11=y
+			break
+		fi
+	done
+
+	if test -z "$working_c11"
+	then
+		msg_result no
+		return 1
+	fi
+
+	return 0
+}
+
+check_cflags()
+{
+	check_cc_flag -pipe -Wall -Wshadow -Wcast-align -Wpointer-arith \
+		-Wwrite-strings -Wundef -Wmissing-prototypes -Wredundant-decls \
+		-Wextra -Wno-sign-compare -Wformat-security
+
+	for i in -Wold-style-definition \
+		-Wno-pointer-sign \
+		-Werror-implicit-function-declaration \
+		-Wno-unused-parameter \
+		-Wno-missing-field-initializers
+	do
+		check_cc_flag $i
+	done
+	return 0
+}
+
+check_sndio()
+{
+	check_library SNDIO "" "-lsndio"
+	return $?
+}
+
+check_coreaudio()
+{
+	case `uname -s` in
+	Darwin)
+		check_library COREAUDIO "" "-framework CoreAudio -framework AudioUnit"
+		return $?
+	esac
+	return 1
+}
+
+wcwidth_code="
+#include <wchar.h>
+
+/* wchar_t must be 4 bytes to support full unicode */
+extern char check[1/!(4 - sizeof(wchar_t))];
+
+int main(int argc, char *argv[])
+{
+	(void) wcwidth('a');
+	return 0;
+}
+"
+
+check_wcwidth()
+{
+	msg_checking "for uchar compatible wcwidth"
+	if try_compile "$wcwidth_code"
+	then
+		msg_result yes
+		HAVE_WCWIDTH=1
+	else
+		msg_result no
+		HAVE_WCWIDTH=0
+	fi
+	return 0
+}
+
+check_compat()
+{
+	COMPAT_LIBS=
+	case `uname -s` in
+	SunOS)
+		# connect() etc.
+		try_link -lsocket && COMPAT_LIBS="$COMPAT_LIBS -lsocket"
+
+		# gethostbyname()
+		try_link -lnsl && COMPAT_LIBS="$COMPAT_LIBS -lnsl"
+
+		# nanosleep()
+		if try_link -lrt
+		then
+			COMPAT_LIBS="$COMPAT_LIBS -lrt"
+		elif try_link -lposix4
+		then
+			COMPAT_LIBS="$COMPAT_LIBS -lposix4"
+		fi
+		;;
+	CYGWIN*)
+		CONFIG_CYGWIN=y
+		makefile_vars CONFIG_CYGWIN
+	esac
+	makefile_vars COMPAT_LIBS
+}
+
+rtsched_code="
+#include <pthread.h>
+
+int main(int argc, char *argv[])
+{
+	pthread_attr_t attr;
+	struct sched_param param;
+
+	pthread_attr_init(&attr);
+	pthread_attr_setschedpolicy(&attr, SCHED_RR);
+	param.sched_priority = sched_get_priority_max(SCHED_RR);
+	pthread_attr_setschedparam(&attr, &param);
+	return 0;
+}
+"
+
+check_rtsched()
+{
+	msg_checking "for realtime scheduling"
+	if try_compile_link "$rtsched_code" $PTHREAD_CFLAGS $PTHREAD_LIBS
+	then
+		msg_result yes
+		EXTRA_CFLAGS="$EXTRA_CFLAGS -DREALTIME_SCHEDULING"
+	else
+		msg_result no
+	fi
+	return 0
+}
+
+ncurses_include="
+#if defined(__sun__) || defined(__CYGWIN__)
+#include <termios.h>
+#include <ncurses.h>
+#else
+#include <curses.h>
+#endif
+"
+
+ncurses_code="
+$ncurses_include
+
+int main(void)
+{
+	initscr();
+	endwin();
+	return 0;
+}
+"
+
+check_ncurses()
+{
+	if pkg_config NCURSES "ncursesw" "" "-lncursesw"
+	then
+		widechars=y
+	elif pkg_config NCURSES "ncurses" "" "-lncurses" || pkg_config NCURSES "curses" "" "-lcurses"
+	then
+		widechars=n
+		msg_error "Your ncurses does not support wide characters!"
+		msg_error "Install ncursesw if you need wide character support,"
+		msg_error "you can ignore this warning otherwise."
+	fi
+	test -z "$widechars" && return 1
+
+	msg_checking "for working ncurses setup"
+	for flag in "" "-I/usr/include/ncurses" "-I/usr/include/ncursesw"
+	do
+		if try_compile_link "$ncurses_code" $NCURSES_CFLAGS $flag $NCURSES_LIBS
+		then
+			NCURSES_CFLAGS="$NCURSES_CFLAGS $flag"
+			msg_result yes
+			working_curses=y
+			break
+		fi
+	done
+	if test -z "$working_curses"
+	then
+		msg_result no
+		return 1
+	fi
+
+	check_function "resizeterm" $NCURSES_CFLAGS $NCURSES_LIBS
+	HAVE_RESIZETERM=`test $? -ne 0 ; echo $?`
+
+	check_function "use_default_colors" $NCURSES_CFLAGS $NCURSES_LIBS
+	HAVE_USE_DEFAULT_COLORS=`test $? -ne 0 ; echo $?`
+
+	msg_checking "for A_ITALIC"
+	if try_compile_link "$ncurses_include int main(int argc, char *argv[]) { unsigned long x = A_ITALIC; return !!x; }" $NCURSES_CFLAGS $NCURSES_LIBS
+	then
+		msg_result yes
+		HAVE_ITALIC="1"
+	else
+		msg_result no
+		HAVE_ITALIC="0"
+	fi
+
+	return 0
+}
+
+check_discid()
+{
+	HAVE_DISCID=n
+	pkg_config DISCID "libdiscid" "" "-ldiscid" && HAVE_DISCID=y
+	return $?
+}
+
+check_mpc()
+{
+	MPC_SV8=0
+	if check_header mpc/mpcdec.h
+	then
+		MPC_SV8=1
+	else
+		check_header mpcdec/mpcdec.h || return $?
+	fi
+	check_library MPC "" "-lmpcdec -lm"
+	return $?
+}
+
+check_cddb()
+{
+	pkg_config CDDB "libcddb" "" "-lcddb" && HAVE_CDDB=y
+	return $?
+}
+
+check_cdio()
+{
+	pkg_config CDIO "libcdio_cdda" "" "-lcdio_cdio -lcdio -lm"
+	return $?
+}
+
+check_flac()
+{
+	pkg_config FLAC "flac" "" "-lFLAC -lm" || return $?
+
+	# Make sure the FLAC_CFLAGS value is sane, strip trailing '/FLAC'.
+	FLAC_CFLAGS=`echo $FLAC_CFLAGS | sed "s/FLAC$//"`
+	return 0
+}
+
+check_mad()
+{
+	pkg_config MAD "mad" "" "-lmad -lm"
+	return $?
+}
+
+mikmod_code="
+#include <mikmod.h>
+int main() {
+	MikMod_RegisterAllDrivers();
+	return 0;
+}
+"
+check_mikmod()
+{
+	# mikmod is linked against pthread
+	app_config MIKMOD libmikmod-config || \
+		check_library MIKMOD "$PTHREAD_CFLAGS" "-lmikmod $PTHREAD_LIBS" || \
+		return 1
+	try_compile_link "$mikmod_code" $MIKMOD_CFLAGS $MIKMOD_LIBS
+	return $?
+}
+
+check_modplug()
+{
+	pkg_config MODPLUG "libmodplug" "-I/usr/include/libmodplug" "-lmodplug -lstdc++ -lm" || return $?
+	MODPLUG_API_8=0
+	if check_function "ModPlug_GetModuleType" $MODPLUG_CFLAGS $MODPLUG_LIBS
+	then
+		MODPLUG_API_8=1
+	fi
+	return 0
+}
+
+check_bass()
+{
+    check_header bass.h &&
+    check_library BASS "" "-lbass"
+    return $?
+}
+
+check_vtx()
+{
+	check_header ayemu.h &&
+	check_library VTX "" "-layemu"
+	return $?
+}
+
+check_vorbis()
+{
+	if test "$CONFIG_TREMOR" = y
+	then
+		pkg_config VORBIS "vorbisidec" "" "-lvorbisidec -lm"
+		return $?
+	else
+		pkg_config VORBIS "vorbisfile" "" "-lvorbisfile -lvorbis -lm -logg"
+		return $?
+	fi
+}
+
+check_libsystemd()
+{
+	pkg_config LIBSYSTEMD "libsystemd" || pkg_config LIBSYSTEMD "libelogind >= 239.3" || {
+		pkg_config LIBSYSTEMD "basu" && CFLAGS="${CFLAGS} -DCONFIG_MPRIS_BASU"
+	}
+	return $?
+}
+
+check_opus()
+{
+	pkg_config OPUS "opusfile"
+	return $?
+}
+
+check_wavpack()
+{
+	pkg_config WAVPACK "wavpack >= 4.40" "" "-lwavpack"
+	return $?
+}
+
+check_pulse()
+{
+	pkg_config PULSE "libpulse >= 0.9.19"
+	return $?
+}
+
+check_alsa()
+{
+	# the alsa.pc file should be always available
+	pkg_config ALSA "alsa >= 1.0.11"
+	return $?
+}
+
+check_jack()
+{
+	pkg_config JACK "jack"
+	return $?
+}
+
+check_samplerate()
+{
+	pkg_config SAMPLERATE "samplerate" && HAVE_SAMPLERATE=y
+	return $?
+}
+
+check_ao()
+{
+	pkg_config AO "ao" "" "-lao"
+	return $?
+}
+
+arts_code="
+#include <artsc.h>
+int main() {
+	return arts_init();
+}
+"
+check_arts()
+{
+	app_config ARTS artsc-config || return 1
+	try_compile_link "$arts_code" $ARTS_CFLAGS $ARTS_LIBS
+	return $?
+}
+
+check_oss()
+{
+	case `uname -s` in
+		Linux|*FreeBSD)
+			;;
+		*BSD)
+			check_library OSS "" "-lossaudio"
+			return $?
+			;;
+		*)
+			# unknown
+			;;
+	esac
+
+	OSS_CFLAGS=""
+	OSS_LIBS=""
+	msg_checking "for header <sys/soundcard.h>"
+	if test -f /usr/include/sys/soundcard.h
+	then
+		msg_result "yes"
+		makefile_vars OSS_CFLAGS OSS_LIBS
+		return 0
+	else
+		msg_result "no"
+	fi
+	return 1
+}
+
+check_sun()
+{
+	msg_checking "for header <sys/audioio.h>"
+	if test -f /usr/include/sys/audioio.h
+	then
+		msg_result "yes"
+		return 0
+	else
+		msg_result "no"
+		return 1
+	fi
+}
+
+check_waveout()
+{
+	case `uname -s` in
+	CYGWIN*)
+		check_library WAVEOUT "" "-lwinmm"
+		return $?
+	esac
+	return 1
+}
+
+check_roar()
+{
+	pkg_config ROAR "libroar >= 0.4.5"
+	return $?
+}
+
+check_mp4()
+{
+	pkg_config MP4 "mp4v2 faad2" "" "-lmp4v2 -lfaad -lm" || return $?
+	USE_MPEG4IP=0
+	if ! check_header mp4v2/mp4v2.h -std=c11 $MP4_CFLAGS
+	then
+		# couldn't find the v2 header, try falling back to mp4.h
+		USE_MPEG4IP=1
+		check_header mp4.h $MP4_CFLAGS || return $?
+	fi
+	check_header neaacdec.h $MP4_CFLAGS
+	return $?
+}
+
+check_aac()
+{
+	pkg_config AAC faad2 "" "-lfaad -lm" || return $?
+	check_header neaacdec.h $AAC_CFLAGS
+	return $?
+}
+
+check_ffmpeg()
+{
+	pkg_config FFMPEG "libavformat libavcodec libswresample libavutil" || return $?
+	# check the existence of specific headers since they've been renamed before
+	check_header "libavformat/avformat.h" $FFMPEG_CFLAGS || return $?
+	check_header "libavcodec/avcodec.h" $FFMPEG_CFLAGS || return $?
+	check_header "libswresample/swresample.h" $FFMPEG_CFLAGS || return $?
+	check_header "libavutil/avutil.h" $FFMPEG_CFLAGS || return $?
+	# ffmpeg api changes so frequently that it is best to compile the module
+	libs="$LDDLFLAGS $FFMPEG_LIBS"
+	cflags="$SOFLAGS $FFMPEG_CFLAGS"
+	topdir=`dirname "$0"`
+	ffmpeg_code=`cat "$topdir"/ip/ffmpeg.c | sed 's/\\\n//g'`
+	msg_checking "for successful build of ffmpeg.c"
+	if try_compile_link "$ffmpeg_code" $cflags -I$topdir/ip $libs
+	then
+		msg_result yes
+		return 0
+	fi
+	msg_result no
+	return 1
+}
+
+aaudio_code="
+#include <aaudio/AAudio.h>
+int main() {
+	// ensure basic aaudio support
+	if (__builtin_available(android 26, *)) {
+		AAudioStreamBuilder *bld;
+		AAudio_createStreamBuilder(&bld);
+
+		// ensure we have at least api 32 headers
+		if (__builtin_available(android 32, *)) {
+			AAudioStreamBuilder_setChannelMask(bld, AAUDIO_CHANNEL_9POINT1POINT6);
+		}
+	}
+	return 0;
+}
+"
+
+check_aaudio()
+{
+	check_header aaudio/AAudio.h || return $?
+	check_library AAUDIO "-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__ -Werror=unguarded-availability" "-Wl,--no-as-needed -laaudio" || return $?
+
+	msg_checking "for working aaudio api 32 linkage"
+	if try_compile_link "$aaudio_code" $AAUDIO_CFLAGS $AAUDIO_LIBS
+	then
+		msg_result yes
+		return 0
+	fi
+	msg_result no
+	return 1
+}
+
+check_string_function()
+{
+	msg_checking "for function $1"
+	string_function_code="
+#include <string.h>
+int (*ptr)() = (int (*)()) &$1;
+int main() { return 0; }
+"
+	if try_compile_link "$string_function_code"
+	then
+		msg_result yes
+		return 0
+	fi
+	msg_result no
+	return 1
+}
+
+
+# defaults
+prefix=/usr/local
+DEBUG=1
+HAVE_CDDB=n
+CONFIG_TREMOR=n
+CONFIG_MIKMOD=n
+CONFIG_BASS=n
+USE_FALLBACK_IP=n
+HAVE_BYTESWAP_H=n
+HAVE_STRDUP=n
+HAVE_STRNDUP=n
+HAVE_SAMPLERATE=n
+# unset CONFIG_* variables: if check succeeds 'y', otherwise 'n'
+
+USAGE="
+Options:
+  prefix          Installation prefix    [$prefix]
+  bindir          User executables       [\$prefix/bin]
+  datadir         Read-only data         [\$prefix/share]
+  libdir          Libraries              [\$prefix/lib]
+  mandir          Man pages              [\$datadir/man]
+  docdir          Other documentation    [\$datadir/doc/cmus]
+  exampledir      Examples               [\$docdir/examples]
+  DEBUG           Debugging level (0-2)  [$DEBUG]
+
+Optional Features: y/n
+  CONFIG_AAC            AAC (.aac, audio/aac, audio/aacp)               [auto]
+  CONFIG_AAUDIO         Android 8.0+ native audio output                [auto]
+  CONFIG_ALSA           ALSA                                            [auto]
+  CONFIG_AO             Libao cross-platform audio library              [auto]
+  CONFIG_ARTS           ARTS                                            [auto]
+  CONFIG_CDDB           libcddb CDDA identification                     [auto]
+  CONFIG_CDIO           libcdio CDDA input                              [auto]
+  CONFIG_COREAUDIO      CoreAudio                                       [auto]
+  CONFIG_CUE            CUE sheets (.cue)                               [y]
+  CONFIG_DISCID         libdiscid CDDA identification                   [auto]
+  CONFIG_FFMPEG         FFMPEG (.shn, .wma)                             [auto]
+  CONFIG_FLAC           Free Lossless Audio Codec (.flac, .fla)         [auto]
+  CONFIG_JACK           JACK                                            [auto]
+  CONFIG_MAD            MPEG Audio Decoder (.mp3, .mp2, streams)        [auto]
+  CONFIG_MIKMOD         libmikmod (.mod, .x3m, ...)                     [n]
+  CONFIG_BASS           libbass (.mod, .x3m, ...)                       [n]
+  CONFIG_MODPLUG        libmodplug (.mod, .x3m, ...)                    [auto]
+  CONFIG_MP4            MPEG-4 AAC (.mp4, .m4a, .m4b)                   [auto]
+  CONFIG_MPC            libmpcdec (Musepack .mpc, .mpp, .mp+)           [auto]
+  CONFIG_MPRIS          MPRIS                                           [auto]
+  CONFIG_OPUS           Opus (.opus)                                    [auto]
+  CONFIG_OSS            Open Sound System                               [auto]
+  CONFIG_PULSE          native PulseAudio output                        [auto]
+  CONFIG_ROAR           native RoarAudio output                         [auto]
+  CONFIG_SAMPLERATE     Use libsamplerate to resample to JACK's rate    [auto]
+  CONFIG_SNDIO          Sndio                                           [auto]
+  CONFIG_SUN            Sun Audio                                       [auto]
+  CONFIG_TREMOR         Use Tremor as Ogg/Vorbis input plugin           [n]
+  CONFIG_VORBIS         Ogg/Vorbis (.ogg, application/ogg, audio/x-ogg) [auto]
+  CONFIG_VTX            libayemu (.vtx)                                 [auto]
+  CONFIG_WAVEOUT        Windows Wave Out                                [auto]
+  CONFIG_WAVPACK        WavPack (.wv, audio/x-wavpack)                  [auto]
+  CONFIG_WAV            WAV                                             [y]
+  USE_FALLBACK_IP       Use a specific IP for every unrecognized        [n]
+                        input format. Currently set to FFMPEG.
+
+Also many standard variables like CC, LD, CFLAGS, LDFLAGS are recognized.
+Cross compiling is supported via CROSS=target-prefix-
+    optionally set HOSTCC=this-machine-gcc, HOSTLD, HOST_CFLAGS, HOST_LDFLAGS."
+
+parse_command_line "$@"
+
+case $DEBUG in
+[0-2])
+	;;
+*)
+	die "DEBUG must be 0-2"
+	;;
+esac
+
+var_default bindir "${prefix}/bin"
+var_default datadir "${prefix}/share"
+var_default libdir "${prefix}/lib"
+var_default mandir "${datadir}/man"
+var_default docdir "${datadir}/doc/cmus"
+var_default exampledir "${docdir}/examples"
+
+check check_cc
+check check_host_cc
+check check_c11
+check check_cflags
+check check_cc_depgen
+check check_endianness
+check check_compat
+check check_dl
+check check_pthread
+check check_rtsched
+check check_ncurses
+check check_iconv
+check check_wcwidth
+check_header byteswap.h && HAVE_BYTESWAP_H=y
+check_string_function "strdup" && HAVE_STRDUP=y
+check_string_function "strndup" && HAVE_STRNDUP=y
+
+check check_cddb       CONFIG_CDDB
+check check_cdio       CONFIG_CDIO
+check check_flac       CONFIG_FLAC
+check check_mad        CONFIG_MAD
+check check_mikmod     CONFIG_MIKMOD
+check check_modplug    CONFIG_MODPLUG
+check check_bass       CONFIG_BASS
+check check_mpc        CONFIG_MPC
+check check_vorbis     CONFIG_VORBIS
+check check_opus       CONFIG_OPUS
+check check_libsystemd CONFIG_MPRIS
+check check_wavpack    CONFIG_WAVPACK
+check check_mp4        CONFIG_MP4
+check check_aac        CONFIG_AAC
+check check_ffmpeg     CONFIG_FFMPEG
+check check_vtx        CONFIG_VTX
+# nothing to check, just validate the variable values
+check true             CONFIG_TREMOR
+check true             CONFIG_WAV
+check true             CONFIG_CUE
+check check_pulse      CONFIG_PULSE
+check check_alsa       CONFIG_ALSA
+check check_jack       CONFIG_JACK
+check check_samplerate CONFIG_SAMPLERATE
+check check_ao         CONFIG_AO
+check check_coreaudio  CONFIG_COREAUDIO
+check check_arts       CONFIG_ARTS
+check check_oss        CONFIG_OSS
+check check_sndio      CONFIG_SNDIO
+check check_sun        CONFIG_SUN
+check check_waveout    CONFIG_WAVEOUT
+check check_roar       CONFIG_ROAR
+check check_aaudio     CONFIG_AAUDIO
+
+# discid is only needed if at least one cdda plugin is active
+test -z "$CONFIG_DISCID" && CONFIG_DISCID=a
+if test "$CONFIG_DISCID" = a
+then
+	test "$CONFIG_CDIO" = n && CONFIG_DISCID=n
+fi
+check check_discid  CONFIG_DISCID
+
+test "$WORDS_BIGENDIAN" = y && CFLAGS="${CFLAGS} -DWORDS_BIGENDIAN"
+test "$HAVE_DISCID" = y && CFLAGS="${CFLAGS} -DHAVE_DISCID"
+
+DATADIR="$datadir"
+LIBDIR="$libdir"
+
+config_header config/cdio.h HAVE_CDDB
+config_header config/mpris.h CONFIG_MPRIS
+config_header config/datadir.h DATADIR
+config_header config/libdir.h LIBDIR
+config_header config/debug.h DEBUG
+config_header config/tremor.h CONFIG_TREMOR
+config_header config/modplug.h MODPLUG_API_8
+config_header config/mpc.h MPC_SV8
+config_header config/mp4.h USE_MPEG4IP
+config_header config/curses.h HAVE_RESIZETERM HAVE_USE_DEFAULT_COLORS HAVE_ITALIC
+config_header config/ffmpeg.h HAVE_FFMPEG_AVCODEC_H USE_FALLBACK_IP
+config_header config/utils.h HAVE_BYTESWAP_H
+config_header config/iconv.h HAVE_ICONV
+config_header config/wcwidth.h HAVE_WCWIDTH
+config_header config/samplerate.h HAVE_SAMPLERATE
+config_header config/xmalloc.h HAVE_STRDUP HAVE_STRNDUP
+
+CFLAGS="${CFLAGS} -DHAVE_CONFIG"
+
+makefile_vars bindir datadir libdir mandir docdir exampledir
+makefile_vars \
+	CONFIG_AAC CONFIG_ALSA CONFIG_AO CONFIG_ARTS CONFIG_CDIO \
+	CONFIG_COREAUDIO CONFIG_CUE CONFIG_FFMPEG CONFIG_FLAC CONFIG_JACK \
+	CONFIG_MAD CONFIG_MIKMOD CONFIG_MODPLUG CONFIG_MP4 CONFIG_MPC \
+	CONFIG_MPRIS CONFIG_OPUS CONFIG_OSS CONFIG_PULSE CONFIG_ROAR \
+	CONFIG_SAMPLERATE CONFIG_SNDIO CONFIG_SUN CONFIG_VORBIS CONFIG_VTX \
+	CONFIG_WAV CONFIG_WAVEOUT CONFIG_WAVPACK CONFIG_BASS CONFIG_AAUDIO
+
+generate_config_mk

contrib/README

@@ -0,0 +1,10 @@
+_cmus (originally _cmus_remote)
+	zsh completion for cmus-remote by Christian Schneider strcat AT gmx DOT net
+	extended for the main cmus binary by Frank Terbeck.
+
+cmus-updategaim.py
+	 Joshua Kwan <joshk@triplehelix.org>
+
+cmus-updatepidgin.py
+	Based on Joshua's cmus-updategaim.py script.
+	David Thiel <lx@redundancy.redundancy.org>

contrib/_cmus

@@ -0,0 +1,52 @@
+#compdef cmus cmus-remote
+
+local expl cmus_commands
+
+cmus_commands=(
+  add bind browser-up cd clear colorscheme echo factivate
+  filter fset invert load mark player-next player-pause
+  player-play quit refresh run save search-next search-prev
+  seek set showbind shuffle source toggle unbind unmark view
+  vol win-activate win-add-l win-add-p win-add-Q win-add-q
+  win-bottom win-down win-mv-after win-mv-before win-next
+  win-page-down win-page-up win-remove win-sel-cur
+  win-toggle win-top win-up win-update
+)
+_cmus_volume() {
+  local expl
+  compset -P '[-+]'
+  _wanted list expl volume compadd $expl - {0..100}
+}
+
+case $service in
+  (cmus-remote)
+    _arguments -C -s\
+      '--server[connect using socket SOCKET]:socket:_files' \
+      '--help[display this help and exit]:' \
+      '--version[Display version information and exit.]:' \
+      '(--play -p)'{--play,-p}'[Start playing.]:' \
+      '(--pause -u)'{--pause,-u}'[Toggle pause.]:' \
+      '(--stop -s)'{--stop,-s}'[Stop playing.]:' \
+      '(--next -n)'{--next,-n}'[Skip forward in playlist.]:' \
+      '(--prev -r)'{--prev,-r}'[Skip backward in playlist.]:' \
+      '(--file -f)'{--file,-f}'[Play a file.]:file:_files' \
+      '(--repeat -R)'{--repeat,-R}'[Toggle repeat.]:' \
+      '(--shuffle -S)'{--shuffle,-S}'[Toggle shuffle.]:' \
+      '(--volume -v)'{--volume,-V+}'[Change volume. See vol command in cmus(1).]:volume:_cmus_volume' \
+      '(--seek -k)'{--seek,-k+}'[Seek. See seek command in cmus(1).]:seek [+-]<num>[m/h]' \
+      '(--query -Q)'{--query,-Q}'[Get player status (same as -C status).]:' \
+      '(--library -l)'{--library,-l+}'[Modify library instead of playlist.]:playlists/files/directories/URLs:_files' \
+      '(--playlist -P)'{--playlist,-P}'[Modify playlist (default).]::Playlist:_files' \
+      '(--queue -q)'{--queue,-q}'[Modify play queue instead of playlist.]:' \
+      '(--clear -c)'{--clear,-c}'[Clear playlist, library (-l) or play queue (-q).]:playlist' \
+      '(--raw -C)'{--raw,-C+}'[Treat arguments (instead of stdin) as raw commands.]:command:(${cmus_commands[@]}):' \
+    ;;
+  (cmus)
+    _arguments \
+      '--listen[listen on ADDR instead of $CMUS_SOCKET or $XDG_RUNTIME_DIR/cmus-socket]:socket:_files' \
+      '--plugins[list available plugins and exit]'                        \
+      '--help[display this help and exit]'                                \
+      '--version[display version information]'
+    ;;
+esac
+

contrib/cmus-updategaim.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import dbus
+import sys
+
+args = {}
+
+for n in range(1, len(sys.argv) - 1, 2):
+	args[sys.argv[n]] = sys.argv[n + 1]
+
+obj = dbus.SessionBus().get_object("net.sf.gaim.GaimService", "/net/sf/gaim/GaimObject")
+gaim = dbus.Interface(obj, "net.sf.gaim.GaimInterface")
+
+current = gaim.GaimSavedstatusGetCurrent()
+status_type = gaim.GaimSavedstatusGetType(current)
+saved = gaim.GaimSavedstatusNew("", status_type)
+gaim.GaimSavedstatusSetMessage(saved, "♪ %s - %s" % (args["artist"], args["title"]))
+gaim.GaimSavedstatusActivate(saved)
+

contrib/cmus-updatepidgin.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import dbus
+import sys
+
+args = {}
+
+for n in range(1, len(sys.argv) - 1, 2):
+	args[sys.argv[n]] = sys.argv[n + 1]
+
+obj = dbus.SessionBus().get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
+pidgin = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
+
+current = pidgin.PurpleSavedstatusGetCurrent()
+status_type = pidgin.PurpleSavedstatusGetType(current)
+saved = pidgin.PurpleSavedstatusNew("", status_type)
+pidgin.PurpleSavedstatusSetMessage(saved, "♪ %s - %s" % (args["artist"], args["title"]))
+pidgin.PurpleSavedstatusActivate(saved)
+

contrib/cmus.bash-completion

@@ -0,0 +1,75 @@
+# bash completion for cmus-remote and cmus
+
+_cmus-remote()
+{
+	local cur prev longopts shortopts
+	cur="${COMP_WORDS[COMP_CWORD]}"
+	prev="${COMP_WORDS[COMP_CWORD-1]}"
+	# maybe we'll differentiate between $cur starting with - or --
+	longopts="--server --passwd --help --version --play --pause --stop
+		--next --prev --file --repeat --shuffle --volume --seek
+		--library --playlist --queue --clear --raw"
+	shortopts="-p -u -s -n -r -f -R -S -v -k -Q -l -P -q -c -C"
+
+	COMPREPLY=()
+
+	case "${prev}" in
+		--server) # can be a hostname[:port] or a filename
+			compopt -o nospace
+			_known_hosts_real -c "${cur}"
+			;&
+		--file|-f)
+			_filedir
+			return 0
+			;;
+		--passwd) # do not attempt to complete anything
+			;&
+		--volume|-v)
+			;&
+		--seek|-k)
+			;&
+		--raw|-C)
+		# supporting completion for raw commands would be nice (TODO)
+			return 0
+			;;
+		*)
+			;;
+	esac
+
+	if [[ ${cur} == -* ]]; then
+		COMPREPLY=(
+			$(compgen -W "${shortopts[*]} ${longopts[*]}" -- ${cur})
+		)
+	else
+		_filedir
+	fi
+}
+
+_cmus()
+{
+	local cur prev opts
+	cur="${COMP_WORDS[COMP_CWORD]}"
+	prev="${COMP_WORDS[COMP_CWORD-1]}"
+	opts="--listen --plugins --show-cursor --help --version"
+
+	COMPREPLY=()
+
+	case "${prev}" in
+		--listen)
+			compopt -o nospace
+			_ip_addresses
+			_filedir
+			return 0;
+			;;
+		--plugins|--help|--version)
+			return 0;
+			;;
+		*)
+			;;
+	esac
+
+	COMPREPLY=($(compgen -W "${opts[*]}" -- ${cur}))
+}
+
+complete -F _cmus-remote cmus-remote
+complete -F _cmus cmus

convert.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "convert.h"
+#include "xmalloc.h"
+#include "uchar.h"
+#ifdef HAVE_CONFIG
+#include "config/iconv.h"
+#endif
+
+#ifdef HAVE_ICONV
+#include <iconv.h>
+#endif
+#include <string.h>
+#include <errno.h>
+
+ssize_t convert(const char *inbuf, ssize_t inbuf_size,
+		char **outbuf, ssize_t outbuf_estimate,
+		const char *tocode, const char *fromcode)
+{
+#ifdef HAVE_ICONV
+	const char *in;
+	char *out;
+	size_t rc, outbuf_size, inbytesleft, outbytesleft;
+	iconv_t cd;
+	int finished = 0, err_save;
+
+	cd = iconv_open(tocode, fromcode);
+	if (cd == (iconv_t) -1)
+		return -1;
+
+	if (inbuf_size < 0)
+		inbuf_size = strlen(inbuf);
+	inbytesleft = inbuf_size;
+
+	if (outbuf_estimate < 0)
+		outbuf_size = inbuf_size;
+	else
+		outbuf_size = outbuf_estimate;
+	outbytesleft = outbuf_size;
+
+	in = inbuf;
+	out = *outbuf = xnew(char, outbuf_size + 1);
+
+	while (!finished) {
+		finished = 1;
+		rc = iconv(cd, (char **)&in, &inbytesleft, &out, &outbytesleft);
+		if (rc == (size_t) -1) {
+			if (errno == E2BIG) {
+				size_t used = out - *outbuf;
+				outbytesleft += outbuf_size;
+				outbuf_size *= 2;
+				*outbuf = xrenew(char, *outbuf, outbuf_size + 1);
+				out = *outbuf + used;
+				continue;
+			} else if (errno != EINVAL)
+				goto error;
+		}
+	}
+	/* NUL-terminate for safety reasons */
+	*out = '\0';
+	iconv_close(cd);
+	return outbuf_size - outbytesleft;
+
+error:
+	err_save = errno;
+	free(*outbuf);
+	*outbuf = NULL;
+	iconv_close(cd);
+	errno = err_save;
+	return -1;
+
+#else
+	if (inbuf_size < 0)
+		inbuf_size = strlen(inbuf);
+	*outbuf = xnew(char, inbuf_size + 1);
+	memcpy(*outbuf, inbuf, inbuf_size);
+	(*outbuf)[inbuf_size] = '\0';
+	return inbuf_size;
+#endif
+}
+
+int utf8_encode(const char *inbuf, const char *encoding, char **outbuf)
+{
+	size_t inbuf_size, outbuf_size, i;
+	int rc;
+
+	inbuf_size = strlen(inbuf);
+	outbuf_size = inbuf_size;
+	for (i = 0; i < inbuf_size; i++) {
+		unsigned char ch;
+
+		ch = inbuf[i];
+		if (ch > 127)
+			outbuf_size++;
+	}
+
+	rc = convert(inbuf, inbuf_size, outbuf, outbuf_size, "UTF-8", encoding);
+
+	return rc < 0 ? -1 : 0;
+}
+
+char *to_utf8(const char *str, const char *enc)
+{
+	char *outbuf = NULL;
+	int rc;
+
+	if (u_is_valid(str)) {
+		return xstrdup(str);
+	} else {
+		rc = utf8_encode(str, enc, &outbuf);
+		return rc < 0 ? xstrdup(str) : outbuf;
+	}
+}

convert.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_CONVERT_H
+#define CMUS_CONVERT_H
+
+#include <sys/types.h> /* ssize_t */
+
+/* Returns length of *outbuf in bytes (without closing '\0'), -1 on error. */
+ssize_t convert(const char *inbuf, ssize_t inbuf_size,
+		char **outbuf, ssize_t outbuf_estimate,
+		const char *tocode, const char *fromcode);
+
+int utf8_encode(const char *inbuf, const char *encoding, char **outbuf);
+
+char *to_utf8(const char *str, const char *enc);
+
+#endif

cue.c

@@ -0,0 +1,554 @@
+/*
+ * Copyright 2016 Various Authors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "cue.h"
+#include "xmalloc.h"
+#include "file.h"
+
+#define ASCII_LOWER_TO_UPPER(c) ((c) & ~0x20)
+
+struct cue_track_proto {
+	struct list_head node;
+
+	char *file;	/* owned by cue_parser */
+	uint32_t nr;
+	int32_t pregap;
+	int32_t postgap;
+	int32_t index0;
+	int32_t index1;
+
+	struct cue_meta meta;
+};
+
+struct cue_parser {
+	const char *src;
+	size_t len;
+	bool err;
+
+	struct list_head files;
+	struct list_head tracks;
+	size_t num_tracks;
+
+	struct cue_meta meta;
+};
+
+struct cue_switch {
+	const char *cmd;
+	void (*parser)(struct cue_parser *p);
+};
+
+static struct cue_track_proto *cue_last_proto(struct cue_parser *p)
+{
+	if (list_empty(&p->tracks))
+		return NULL;
+	return list_entry(p->tracks.prev, struct cue_track_proto, node);
+}
+
+static inline void cue_consume(struct cue_parser *p)
+{
+	p->len--;
+	p->src++;
+}
+
+static void cue_set_err(struct cue_parser *p)
+{
+	p->err = true;
+}
+
+static bool cue_str_eq(const char *a, size_t a_len, const char *b, size_t b_len)
+{
+	if (a_len != b_len)
+		return false;
+	for (size_t i = 0; i < a_len; i++) {
+		if (ASCII_LOWER_TO_UPPER(a[i]) != ASCII_LOWER_TO_UPPER(b[i]))
+			return false;
+	}
+	return true;
+}
+
+static void cue_skip_spaces(struct cue_parser *p)
+{
+	while (p->len > 0 && (*p->src == ' ' || *p->src == '\t'))
+		cue_consume(p);
+}
+
+static size_t cue_extract_token(struct cue_parser *p, const char **start)
+{
+	cue_skip_spaces(p);
+
+	bool quoted = p->len > 0 && *p->src == '"';
+	if (quoted)
+		cue_consume(p);
+
+	*start = p->src;
+
+	while (p->len > 0) {
+		char c = *p->src;
+		if (c == '\n' || c == '\r')
+			break;
+		if (quoted) {
+			if (c == '"')
+				break;
+		} else {
+			if (c == ' ' || c == '\t')
+				break;
+		}
+		cue_consume(p);
+	}
+
+	if (quoted) {
+		size_t len = p->src - *start;
+		if (p->len > 0 && *p->src == '"')
+			cue_consume(p);
+		return len;
+	}
+
+	return p->src - *start;
+}
+
+static void cue_skip_line(struct cue_parser *p)
+{
+	while (p->len > 0 && *p->src != '\n' && *p->src != '\r')
+		cue_consume(p);
+
+	if (p->len > 0) {
+		char c = *p->src;
+		cue_consume(p);
+		if (p->len > 0 && c == '\r' && *p->src == '\n')
+			cue_consume(p);
+	}
+}
+
+static char *cue_strdup(const char *start, size_t len)
+{
+	char *s = xnew(char, len + 1);
+	s[len] = 0;
+	memcpy(s, start, len);
+	return s;
+}
+
+static uint32_t cue_parse_int(struct cue_parser *p, const char *start, size_t len)
+{
+	uint32_t val = 0;
+	for (size_t i = 0; i < len; i++) {
+		if (!isdigit(start[i])) {
+			cue_set_err(p);
+			return 0;
+		}
+		val = val * 10 + start[i] - '0';
+	}
+	return val;
+}
+
+static void cue_parse_str(struct cue_parser *p, char **dst)
+{
+	const char *start;
+	size_t len = cue_extract_token(p, &start);
+	if (!*dst)
+		*dst = cue_strdup(start, len);
+}
+
+#define CUE_PARSE_STR(field) \
+	static void cue_parse_##field(struct cue_parser *p) \
+	{ \
+		struct cue_track_proto *t = cue_last_proto(p); \
+		if (t) \
+			cue_parse_str(p, &t->meta.field); \
+		else \
+			cue_parse_str(p, &p->meta.field); \
+	}
+
+CUE_PARSE_STR(performer)
+CUE_PARSE_STR(songwriter)
+CUE_PARSE_STR(title)
+CUE_PARSE_STR(genre)
+CUE_PARSE_STR(date)
+CUE_PARSE_STR(comment)
+CUE_PARSE_STR(compilation);
+CUE_PARSE_STR(discnumber);
+CUE_PARSE_STR(rg_gain);
+CUE_PARSE_STR(rg_peak);
+
+static void cue_parse_file(struct cue_parser *p)
+{
+	struct cue_track_file *f = xnew(struct cue_track_file, 1);
+
+	f->file = NULL;
+	cue_parse_str(p, &f->file);
+
+	list_add_tail(&f->node, &p->files);
+}
+
+static char *cue_get_last_file(struct cue_parser *p)
+{
+	if (list_empty(&p->files))
+		return NULL;
+
+	struct list_head *tail = list_prev(&p->files);
+	return list_entry(tail, struct cue_track_file, node)->file;
+}
+
+static void cue_parse_track(struct cue_parser *p)
+{
+	char *curr_file = cue_get_last_file(p);
+
+	if (!curr_file) {
+		cue_set_err(p);
+		return;
+	}
+
+	const char *nr;
+	size_t len = cue_extract_token(p, &nr);
+
+	uint32_t d = cue_parse_int(p, nr, len);
+	if (p->err)
+		return;
+
+	struct cue_track_proto *t = xnew(struct cue_track_proto, 1);
+	*t = (struct cue_track_proto) {
+		.nr = d,
+		.pregap = -1,
+		.postgap = -1,
+		.index0 = -1,
+		.index1 = -1,
+		.file = curr_file,
+	};
+
+	list_add_tail(&t->node, &p->tracks);
+	p->num_tracks++;
+}
+
+static uint32_t cue_parse_time(struct cue_parser *p, const char *start, size_t len)
+{
+	uint32_t vals[] = { 0, 0, 0 };
+	uint32_t *val = vals;
+	for (size_t i = 0; i < len; i++) {
+		if (start[i] == ':') {
+			if (val != &vals[2]) {
+				val++;
+				continue;
+			}
+			break;
+		}
+		if (!isdigit(start[i])) {
+			cue_set_err(p);
+			return 0;
+		}
+		*val = *val * 10 + start[i] - '0';
+	}
+	return (vals[0] * 60 + vals[1]) * 75 + vals[2];
+}
+
+static void cue_parse_index(struct cue_parser *p)
+{
+	const char *nr;
+	size_t nr_len = cue_extract_token(p, &nr);
+
+	uint32_t d = cue_parse_int(p, nr, nr_len);
+	if (p->err || d > 1)
+		return;
+
+	const char *offset_str;
+	size_t offset_len = cue_extract_token(p, &offset_str);
+
+	uint32_t offset = cue_parse_time(p, offset_str, offset_len);
+	if (p->err)
+		return;
+
+	struct cue_track_proto *last = cue_last_proto(p);
+	if (!last)
+		return;
+
+	if (d == 0)
+		last->index0 = offset;
+	else
+		last->index1 = offset;
+}
+
+static void cue_parse_cmd(struct cue_parser *p, struct cue_switch *s)
+{
+	const char *start;
+	size_t len = cue_extract_token(p, &start);
+
+	while (s->cmd) {
+		if (cue_str_eq(start, len, s->cmd, strlen(s->cmd))) {
+			s->parser(p);
+			return;
+		}
+		s++;
+	}
+}
+
+static void cue_parse_rem(struct cue_parser *p)
+{
+	struct cue_switch cmds[] = {
+		{ "DATE",        cue_parse_date        },
+		{ "GENRE",       cue_parse_genre       },
+		{ "COMMENT",     cue_parse_comment     },
+		{ "COMPILATION", cue_parse_compilation },
+		{ "DISCNUMBER",  cue_parse_discnumber  },
+		{ "REPLAYGAIN_ALBUM_GAIN", cue_parse_rg_gain  },
+		{ "REPLAYGAIN_TRACK_GAIN", cue_parse_rg_gain  },
+		{ "REPLAYGAIN_ALBUM_PEAK", cue_parse_rg_peak  },
+		{ "REPLAYGAIN_TRACK_PEAK", cue_parse_rg_peak  },
+		{ 0 },
+	};
+
+	cue_parse_cmd(p, cmds);
+}
+
+static void cue_parse_gap(struct cue_parser *p, bool post)
+{
+	const char *gap_str;
+	size_t gap_len = cue_extract_token(p, &gap_str);
+
+	uint32_t gap = cue_parse_time(p, gap_str, gap_len);
+	if (p->err)
+		return;
+
+	struct cue_track_proto *last = cue_last_proto(p);
+	if (!last)
+		return;
+
+	if (post)
+		last->postgap = gap;
+	else
+		last->pregap = gap;
+}
+
+static void cue_parse_pregap(struct cue_parser *p)
+{
+	cue_parse_gap(p, false);
+}
+
+static void cue_parse_postgap(struct cue_parser *p)
+{
+	cue_parse_gap(p, true);
+}
+
+static void cue_parse_line(struct cue_parser *p)
+{
+	struct cue_switch cmds[] = {
+		{ "FILE",       cue_parse_file       },
+		{ "PERFORMER",  cue_parse_performer  },
+		{ "SONGWRITER", cue_parse_songwriter },
+		{ "TITLE",      cue_parse_title      },
+		{ "TRACK",      cue_parse_track      },
+		{ "INDEX",      cue_parse_index      },
+		{ "REM",        cue_parse_rem        },
+		{ "PREGAP",     cue_parse_pregap     },
+		{ "POSTGAP",    cue_parse_postgap    },
+		{ 0 },
+	};
+
+	cue_parse_cmd(p, cmds);
+	cue_skip_line(p);
+}
+
+static void cue_post_process(struct cue_parser *p)
+{
+	if (list_empty(&p->files) || p->num_tracks == 0)
+		goto err;
+
+	struct cue_track_proto *t;
+	struct cue_track_proto *prev = NULL;
+	list_for_each_entry(t, &p->tracks, node) {
+		if (prev && prev->nr >= t->nr)
+			goto err;
+
+		if (t->index0 == -1 && t->index1 == -1)
+			goto err;
+
+		/*
+		 * NOTE: if we don't have index1, then the pregap spans the
+		 * whole track, so we would have an empty track.
+		 * This is pretty useless, so we do the simple thing
+		 */
+		if (t->index1 == -1)
+			t->index1 = t->index0;
+
+		if (t->index0 == -1)
+			t->index0 = t->index1;
+
+		if (prev && prev->file == t->file && prev->index1 > t->index0)
+			goto err;
+
+		prev = t;
+	}
+
+	return;
+err:
+	cue_set_err(p);
+}
+
+static void cue_meta_move(struct cue_meta *l, struct cue_meta *r)
+{
+	*l = *r;
+	*r = (struct cue_meta) { 0 };
+}
+
+static struct cue_sheet *cue_parser_to_sheet(struct cue_parser *p)
+{
+	struct cue_sheet *s = xnew(struct cue_sheet, 1);
+
+	/* Move file list */
+	list_add(&s->files, &p->files);
+	list_del_init(&p->files);
+
+	s->tracks = xnew(struct cue_track, p->num_tracks);
+	s->num_tracks = p->num_tracks;
+
+	cue_meta_move(&s->meta, &p->meta);
+
+	size_t i = 0;
+	struct cue_track_proto *tp = NULL;
+	struct cue_track_proto *prev_tp = NULL;
+	list_for_each_entry(tp, &p->tracks, node) {
+		struct cue_track *t = &s->tracks[i];
+		t->file = tp->file;
+		t->offset = tp->index1 / 75.0;
+		t->length = -1;
+		t->number = tp->nr;
+
+		if (i > 0 && t->file == s->tracks[i - 1].file) {
+			s->tracks[i - 1].length = (tp->index0 - prev_tp->index1) / 75.0;
+		}
+
+		cue_meta_move(&t->meta, &tp->meta);
+
+		prev_tp = tp;
+		i++;
+	}
+
+	return s;
+}
+
+static void cue_meta_free(struct cue_meta *m)
+{
+	free(m->performer);
+	free(m->songwriter);
+	free(m->title);
+	free(m->genre);
+	free(m->date);
+	free(m->comment);
+	free(m->compilation);
+	free(m->discnumber);
+	free(m->rg_gain);
+	free(m->rg_peak);
+}
+
+static void cue_free_files(struct list_head *files)
+{
+	struct cue_track_file *tf, *next;
+	list_for_each_entry_safe(tf, next, files, node) {
+		free(tf->file);
+		free(tf);
+	}
+}
+
+static void cue_parser_free(struct cue_parser *p)
+{
+	struct cue_track_proto *t, *next;
+	list_for_each_entry_safe(t, next, &p->tracks, node) {
+		cue_meta_free(&t->meta);
+		free(t);
+	}
+
+	cue_free_files(&p->files);
+
+	cue_meta_free(&p->meta);
+}
+
+struct cue_sheet *cue_parse(const char *src, size_t len)
+{
+	struct cue_sheet *res = NULL;
+
+	struct cue_parser p = {
+		.src = src,
+		.len = len,
+	};
+	list_init(&p.tracks);
+	list_init(&p.files);
+
+	while (p.len > 0 && !p.err)
+		cue_parse_line(&p);
+
+	if (p.err)
+		goto out;
+
+	cue_post_process(&p);
+
+	if (p.err)
+		goto out;
+
+	res = cue_parser_to_sheet(&p);
+
+out:
+	cue_parser_free(&p);
+	return res;
+}
+
+struct cue_sheet *cue_from_file(const char *file)
+{
+	ssize_t size;
+	char *buf = mmap_file(file, &size);
+	if (size == -1)
+		return NULL;
+	struct cue_sheet *rv;
+
+	// Check for UTF-8 BOM, and skip ahead if found
+	if (size >= 3 && memcmp(buf, "\xEF\xBB\xBF", 3) == 0) {
+		rv = cue_parse(buf + 3, size - 3);
+	} else {
+		rv = cue_parse(buf, size);
+	}
+
+	munmap(buf, size);
+	return rv;
+}
+
+void cue_free(struct cue_sheet *s)
+{
+	size_t i;
+	for (i = 0; i < s->num_tracks; i++)
+		cue_meta_free(&s->tracks[i].meta);
+	free(s->tracks);
+
+	cue_free_files(&s->files);
+
+	cue_meta_free(&s->meta);
+	free(s);
+}
+
+struct cue_track *cue_get_track(struct cue_sheet *s, size_t n)
+{
+	size_t i;
+	for (i = 0; i < s->num_tracks; i++) {
+		struct cue_track *t = &s->tracks[i];
+		if (t->number == n)
+			return t;
+	}
+	return NULL;
+}

cue.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2016 Various Authors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_CUE_H
+#define CMUS_CUE_H
+
+#include <stdint.h>
+
+#include "list.h"
+
+struct cue_meta {
+	char *performer;
+	char *songwriter;
+	char *title;
+	char *genre;
+	char *date;
+	char *comment;
+	char *compilation;
+	char *discnumber;
+	char *rg_gain;
+	char *rg_peak;
+};
+
+struct cue_track {
+	char *file;	/* owned by cue_sheet */
+	double offset;
+	double length;
+	size_t number;
+
+	struct cue_meta meta;
+};
+
+struct cue_track_file {
+	struct list_head node;
+
+	char *file;
+};
+
+struct cue_sheet {
+	struct list_head files;
+	struct cue_track *tracks;
+	size_t num_tracks;
+
+	struct cue_meta meta;
+};
+
+struct cue_sheet *cue_parse(const char *src, size_t len);
+struct cue_sheet *cue_from_file(const char *file);
+void cue_free(struct cue_sheet *s);
+struct cue_track *cue_get_track(struct cue_sheet *s, size_t n);
+
+#endif

cue_utils.c

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2008-2013 Various Authors
+ * Copyright (C) 2011 Gregory Petrosyan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "path.h"
+#include "utils.h"
+#include "cue_utils.h"
+#include "xmalloc.h"
+#include "cue.h"
+
+#include <stdio.h>
+
+int is_cue(const char *filename)
+{
+	const char *ext = get_extension(filename);
+	return ext != NULL && strcmp(ext, "cue") == 0;
+}
+
+
+int cue_get_track_nums(const char *filename, int **out_nums)
+{
+	struct cue_sheet *cd = cue_from_file(filename);
+	if (!cd)
+		return -1;
+
+	int n = cd->num_tracks;
+	*out_nums = xnew(int, n);
+
+	int i;
+	for (i = 0; i < n; i++)
+		(*out_nums)[i] = cd->tracks[i].number;
+
+	cue_free(cd);
+	return n;
+}
+
+
+int cue_get_files(const char *filename, char ***out_files)
+{
+	struct cue_sheet *cd = cue_from_file(filename);
+	if (!cd)
+		return -1;
+
+	int n = list_len(&cd->files);
+	*out_files = xnew(char *, n);
+
+	int i = 0;
+	struct cue_track_file *tf;
+	list_for_each_entry(tf, &cd->files, node) {
+		(*out_files)[i] = tf->file;
+		tf->file = NULL;
+		i++;
+	}
+
+	cue_free(cd);
+	return n;
+}
+
+
+char *construct_cue_url(const char *cue_filename, int track_n)
+{
+	char buf[4096] = {0};
+
+	snprintf(buf, sizeof(buf), "cue://%s/%d", cue_filename, track_n);
+
+	return xstrdup(buf);
+}

cue_utils.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008-2013 Various Authors
+ * Copyright (C) 2011 Gregory Petrosyan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_CUE_UTILS_H
+#define CMUS_CUE_UTILS_H
+
+#include <stdio.h>
+
+int is_cue(const char *filename);
+int cue_get_track_nums(const char *filename, int **out_nums);
+int cue_get_files(const char *filename, char ***out_files);
+char *construct_cue_url(const char *cue_filename, int track_n);
+
+
+#endif

data/amazon.theme

@@ -0,0 +1,26 @@
+# May, 2020 by @nitwit
+set color_win_fg=228
+set color_win_bg=234
+set color_cmdline_bg=234
+set color_cmdline_fg=220
+set color_error=9
+set color_info=136
+set color_separator=202
+set color_statusline_bg=232
+set color_statusline_fg=208
+set color_statusline_progress_bg=166
+set color_statusline_progress_fg=232
+set color_titleline_bg=232
+set color_titleline_fg=220
+set color_win_title_bg=232
+set color_win_title_fg=220
+set color_win_cur=9
+set color_win_cur_sel_bg=220
+set color_win_cur_sel_fg=88
+set color_win_inactive_cur_sel_bg=214
+set color_win_inactive_cur_sel_fg=88
+set color_win_sel_bg=220
+set color_win_sel_fg=232
+set color_win_inactive_sel_bg=166
+set color_win_inactive_sel_fg=232
+set color_win_dir=208

data/cyan.theme

@@ -0,0 +1,25 @@
+set color_cmdline_bg=default
+set color_cmdline_fg=cyan
+set color_error=lightred
+set color_info=lightyellow
+set color_separator=cyan
+set color_statusline_bg=default
+set color_statusline_fg=cyan
+set color_statusline_progress_bg=cyan
+set color_statusline_progress_fg=black
+set color_titleline_bg=blue
+set color_titleline_fg=white
+set color_win_bg=default
+set color_win_cur=green
+set color_win_cur_sel_bg=blue
+set color_win_cur_sel_fg=lightyellow
+set color_win_dir=lightblue
+set color_win_fg=cyan
+set color_win_inactive_cur_sel_bg=cyan
+set color_win_inactive_cur_sel_fg=black
+set color_win_inactive_sel_bg=gray
+set color_win_inactive_sel_fg=black
+set color_win_sel_bg=red
+set color_win_sel_fg=gray
+set color_win_title_bg=blue
+set color_win_title_fg=white

data/default.theme

@@ -0,0 +1,25 @@
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=lightred
+set color_info=lightyellow
+set color_separator=blue
+set color_statusline_bg=gray
+set color_statusline_fg=black
+set color_statusline_progress_bg=blue
+set color_statusline_progress_fg=white
+set color_titleline_bg=blue
+set color_titleline_fg=white
+set color_win_bg=default
+set color_win_cur=lightyellow
+set color_win_cur_sel_bg=blue
+set color_win_cur_sel_fg=lightyellow
+set color_win_dir=lightblue
+set color_win_fg=default
+set color_win_inactive_cur_sel_bg=gray
+set color_win_inactive_cur_sel_fg=lightyellow
+set color_win_inactive_sel_bg=gray
+set color_win_inactive_sel_fg=black
+set color_win_sel_bg=blue
+set color_win_sel_fg=white
+set color_win_title_bg=blue
+set color_win_title_fg=white

data/dracula.theme

@@ -0,0 +1,26 @@
+### 'Dracula' theme for CMus (for 255 color terms)
+set color_cmdline_bg=default
+set color_cmdline_fg=231
+set color_error=009
+set color_info=231
+set color_separator=004
+set color_statusline_bg=default
+set color_statusline_fg=231
+set color_statusline_progress_bg=010
+set color_statusline_progress_fg=236
+set color_titleline_bg=010
+set color_titleline_fg=236
+set color_win_bg=default
+set color_win_cur=010
+set color_win_cur_sel_bg=010
+set color_win_cur_sel_fg=016
+set color_win_dir=004
+set color_win_fg=004
+set color_win_inactive_cur_sel_bg=default
+set color_win_inactive_cur_sel_fg=014
+set color_win_inactive_sel_bg=default
+set color_win_inactive_sel_fg=014
+set color_win_sel_bg=004
+set color_win_sel_fg=236
+set color_win_title_bg=default
+set color_win_title_fg=014

data/gray-88.theme

@@ -0,0 +1,26 @@
+# 88 color gray theme for urxvt
+set color_cmdline_bg=80
+set color_cmdline_fg=85
+set color_error=lightgreen
+set color_info=green
+set color_separator=darkgray
+set color_statusline_bg=80
+set color_statusline_fg=85
+set color_statusline_progress_bg=darkgray
+set color_statusline_progress_fg=85
+set color_titleline_bg=darkgray
+set color_titleline_fg=85
+set color_win_bg=80
+set color_win_cur=lightgreen
+set color_win_cur_sel_bg=82
+set color_win_cur_sel_fg=lightyellow
+set color_win_dir=83
+set color_win_fg=85
+set color_win_inactive_cur_sel_bg=darkgray
+set color_win_inactive_cur_sel_fg=lightgreen
+set color_win_inactive_sel_bg=darkgray
+set color_win_inactive_sel_fg=black
+set color_win_sel_bg=82
+set color_win_sel_fg=black
+set color_win_title_bg=darkgray
+set color_win_title_fg=85

data/green-mono-88.theme

@@ -0,0 +1,64 @@
+# Clay's Green Monochromatic Color Scheme 1.0 and example file.
+#
+# This theme is designed to be 1) Very readable on high-resolution or blurry
+# displays (dying CRTs and TVs, for example).  2) Be more accessable to color-
+# blind people, by removing chroma cues in favor of brightness and color
+# inversion.  3) Show how to incorperate named and numbered colors into a
+# single theme.  4) Provide a stating point for creating other mono-chromatic
+# themes.
+#
+# Questions, comments (just a heads-up that you use/like this, especially),
+# and such should be directed to clay.barnes@gmail.com
+
+##### Common User Interface Components #########################################
+# Default text color
+set color_win_fg=green
+
+# Overall background color
+set color_win_bg=black
+
+# Command-line colors
+set color_cmdline_bg=black
+set color_cmdline_fg=green
+set color_error=lightgreen
+set color_info=green
+set color_separator=green
+
+# Bottom status line
+set color_statusline_bg=black
+set color_statusline_fg=green
+set color_statusline_progress_bg=green
+set color_statusline_progress_fg=black
+
+# Bottom title line
+set color_titleline_bg=green
+set color_titleline_fg=black
+
+# Top title area
+set color_win_title_bg=green
+set color_win_title_fg=black
+##### Playing File Colors ######################################################
+# Unselected currently playing track's text
+set color_win_cur=lightgreen
+
+# Active selection for currently playing track
+set color_win_cur_sel_bg=28
+set color_win_cur_sel_fg=darkgray
+
+# Inactive selection for currently playing track
+set color_win_inactive_cur_sel_bg=20
+set color_win_inactive_cur_sel_fg=lightgreen
+
+##### Non-Playing File Colors ##################################################
+# Active selection
+set color_win_sel_bg=green
+set color_win_sel_fg=black
+
+# Inactive selection
+set color_win_inactive_sel_bg=20
+set color_win_inactive_sel_fg=black
+
+##### File Browser View Colors #################################################
+# Directory listing color
+set color_win_dir=lightgreen
+

data/green.theme

@@ -0,0 +1,67 @@
+# Another Green Theme for cmus
+#
+# Change this to a red or blue theme by doing the following in vim:
+#
+#  :%s/lightgreen/light<color>/g
+#  :%s/green/<color>/g
+#
+# - roobert@gmail.com
+
+# Directory colors
+set color_win_dir=default
+
+# Normal text
+set color_win_fg=default
+
+# Window background color.
+set color_win_bg=default
+
+# Command line color.
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+
+# Color of error messages displayed on the command line.
+set color_error=lightred
+
+# Color of informational messages displayed on the command line.
+set color_info=lightgreen
+
+# Color of currently playing track.
+set color_win_cur=lightgreen
+
+# Color of the separator line between windows in view (1).
+set color_separator=black
+
+# Color of window titles (topmost line of the screen).
+set color_win_title_bg=default
+set color_win_title_fg=green
+
+# Status line color.
+set color_statusline_bg=default
+set color_statusline_fg=gray
+set color_statusline_progress_bg=234
+set color_statusline_progress_fg=gray
+
+# Color of the line displaying currently playing track.
+set color_titleline_bg=default
+set color_titleline_fg=green
+
+# Color of the selected row which is also the currently playing track in active window.
+set color_win_cur_sel_bg=default
+set color_win_cur_sel_fg=white
+
+# Color of the selected row which is also the currently playing track in inactive window.
+set color_win_inactive_cur_sel_bg=default
+set color_win_inactive_cur_sel_fg=lightgreen
+
+# Color of selected row in inactive window.
+set color_win_inactive_sel_bg=default
+set color_win_inactive_sel_fg=default
+
+# Color of selected row in active window.
+set color_win_sel_bg=default
+set color_win_sel_fg=green
+
+# Command line color.
+set color_cmdline_bg=default
+set color_cmdline_fg=default

data/gruvbox-alt.theme

@@ -0,0 +1,55 @@
+# colors from gruvbox: https://github.com/morhetz/gruvbox
+
+# default text color: fg
+set color_win_fg=223
+
+# overall background color: bg
+set color_win_bg=235
+
+# top title area: bg2/light-blue
+set color_win_title_bg=239
+set color_win_title_fg=109
+
+# separator line between windows in view (1): dark-gray
+set color_separator=245
+
+# bottom title line: dark-gray/bg0
+set color_titleline_bg=245
+set color_titleline_fg=235
+
+# bottom status line: bg0_s/dark-aqua
+set color_statusline_bg=236
+set color_statusline_fg=72
+set color_statusline_progress_bg=234
+set color_statusline_progress_fg=72
+
+# command-line colors: bg/orange/light-red/light-yellow
+set color_cmdline_bg=235
+set color_cmdline_fg=208
+set color_error=167
+set color_info=214
+
+##### playing file colors ######################################################
+# unselected currently playing track's text: light-green
+set color_win_cur=142
+
+# active selection for currently playing track: bg1/light-green
+set color_win_cur_sel_bg=237
+set color_win_cur_sel_fg=142
+
+# inactive selection for currently playing track: bg/light-green
+set color_win_inactive_cur_sel_bg=235
+set color_win_inactive_cur_sel_fg=142
+
+##### non-playing file colors ##################################################
+# active selection: bg1/fg0
+set color_win_sel_bg=237
+set color_win_sel_fg=229
+
+# inactive selection: bg/fg0
+set color_win_inactive_sel_bg=235
+set color_win_inactive_sel_fg=229
+
+##### file browser view colors #################################################
+# directory listing color: fg
+set color_win_dir=223

data/gruvbox-warm.theme

@@ -0,0 +1,53 @@
+# colors from gruvbox: https://github.com/morhetz/gruvbox
+
+# default text color (note: looks best with #ebdbb2)
+set color_win_fg=default
+
+# overall background color (note: looks best with #1d2021)
+set color_win_bg=default
+
+# command-line colors
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=124
+set color_info=72
+set color_separator=246
+
+# bottom status line
+set color_statusline_bg=236
+set color_statusline_fg=66
+set color_statusline_progress_bg=237
+set color_statusline_progress_fg=66
+
+# bottom title line
+set color_titleline_bg=237
+set color_titleline_fg=172
+
+# top title area
+set color_win_title_bg=237
+set color_win_title_fg=172
+
+##### playing file colors ######################################################
+# unselected currently playing track's text
+set color_win_cur=66
+
+# active selection for currently playing track
+set color_win_cur_sel_bg=237
+set color_win_cur_sel_fg=109
+
+# inactive selection for currently playing track
+set color_win_inactive_cur_sel_bg=236
+set color_win_inactive_cur_sel_fg=109
+
+##### non-playing file colors ##################################################
+# active selection
+set color_win_sel_bg=237
+set color_win_sel_fg=223
+
+# inactive selection
+set color_win_inactive_sel_bg=236
+set color_win_inactive_sel_fg=223
+
+##### file browser view colors #################################################
+# directory listing color
+set color_win_dir=229

data/gruvbox.theme

@@ -0,0 +1,51 @@
+# colors from gruvbox: https://github.com/morhetz/gruvbox
+# default text color
+set color_win_fg=default
+
+# overall background color
+set color_win_bg=default
+
+# command-line colors
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=124
+set color_info=172
+set color_separator=246
+
+# bottom status line
+set color_statusline_bg=237
+set color_statusline_fg=72
+set color_statusline_progress_bg=234
+set color_statusline_progress_fg=72
+
+# bottom title line
+set color_titleline_bg=236
+set color_titleline_fg=142
+
+# top title area
+set color_win_title_bg=246
+set color_win_title_fg=235
+##### playing file colors ######################################################
+# unselected currently playing track's text
+set color_win_cur=175
+
+# active selection for currently playing track
+set color_win_cur_sel_bg=237
+set color_win_cur_sel_fg=175
+
+# inactive selection for currently playing track
+set color_win_inactive_cur_sel_bg=236
+set color_win_inactive_cur_sel_fg=175
+
+##### non-playing file colors ##################################################
+# active selection
+set color_win_sel_bg=237
+set color_win_sel_fg=229
+
+# inactive selection
+set color_win_inactive_sel_bg=236
+set color_win_inactive_sel_fg=229
+
+##### file browser view colors #################################################
+# directory listing color
+set color_win_dir=229

data/jellybeans.theme

@@ -0,0 +1,54 @@
+# Jellybeans colorscheme
+# by: Daniel Rivas (https://github.com/DanielRS)
+# based on: https://github.com/nanotech/jellybeans.vim
+# term codes from: http://vim.wikia.com/wiki/Xterm256_color_names_for_console_Vim
+
+# Window
+set color_cmdline_bg=233
+set color_cmdline_fg=188
+set color_cmdline_attr=default
+
+set color_win_title_bg=237
+set color_win_title_fg=110
+set color_win_title_attr=default
+
+set color_win_fg=188
+set color_win_bg=233
+set color_win_attr=default
+
+set color_separator=107
+
+# Bottom status
+set color_titleline_bg=186
+set color_titleline_fg=237
+set color_titleline_attr=default
+
+set color_statusline_bg=237
+set color_statusline_fg=145
+set color_statusline_progress_bg=233
+set color_statusline_progress_fg=145
+
+# Text
+set color_win_cur=183
+set color_win_dir=186
+
+# Menu
+set color_win_sel_bg=254
+set color_win_sel_fg=237
+set color_win_sel_attr=default
+
+set color_win_inactive_sel_bg=237
+set color_win_inactive_sel_fg=145
+set color_win_inactive_sel_attr=default
+
+set color_win_cur_sel_bg=186
+set color_win_cur_sel_fg=237
+set color_win_cur_sel_attr=default
+
+set color_win_inactive_cur_sel_bg=242
+set color_win_inactive_cur_sel_fg=186
+set color_win_inactive_cur_sel_attr=default
+
+# Messages
+set color_error=167
+set color_info=186

data/night.theme

@@ -0,0 +1,29 @@
+### 'Night' theme for CMus (for 255 color terms)
+### (C) 2013 Mladen Pejaković <pejakm@autistici.org>
+### {{{
+set color_cmdline_bg=default
+set color_cmdline_fg=255
+set color_error=196
+set color_info=220
+set color_separator=002
+set color_statusline_bg=234
+set color_statusline_fg=045
+set color_statusline_progress_bg=default
+set color_statusline_progress_fg=045
+set color_titleline_bg=default
+set color_titleline_fg=046
+set color_win_bg=default
+set color_win_cur=046
+set color_win_cur_sel_bg=235
+set color_win_cur_sel_fg=118
+set color_win_dir=250
+set color_win_fg=255
+set color_win_inactive_cur_sel_bg=233
+set color_win_inactive_cur_sel_fg=046
+set color_win_inactive_sel_bg=234
+set color_win_inactive_sel_fg=002
+set color_win_sel_bg=235
+set color_win_sel_fg=045
+set color_win_title_bg=234
+set color_win_title_fg=045
+### }}}

data/rc

@@ -0,0 +1,141 @@
+# Playback
+
+bind common b player-next
+bind common B player-next-album
+bind common c player-pause
+bind common x player-play
+bind common z player-prev
+bind common Z player-prev-album
+bind common v player-stop
+
+bind common ] vol +0 +1%
+bind common [ vol +1% +0
+bind common + vol +10%
+bind common = vol +10%
+bind common } vol -0 -1%
+bind common { vol -1% -0
+bind common - vol -10%
+
+bind common , seek -1m
+bind common . seek +1m
+
+bind common h seek -5
+bind common l seek +5
+
+bind common left seek -5
+bind common right seek +5
+
+bind common mlb_click_bar player-pause
+bind common mlb_click_bar_right player-pause
+bind common mouse_scroll_up_bar seek +5
+bind common mouse_scroll_down_bar seek -5
+bind common mouse_scroll_up_bar_right vol +1%
+bind common mouse_scroll_down_bar_right vol -1%
+
+# Setting toggles
+
+bind common m toggle aaa_mode
+bind common C toggle continue
+bind common M toggle play_library
+bind common o toggle play_sorted
+bind common r toggle repeat
+bind common ^R toggle repeat_current
+bind common t toggle show_remaining_time
+bind common s toggle shuffle
+bind common f toggle follow
+
+# Commands
+
+bind common q quit -i
+bind common ^C echo Type :quit<enter> to exit cmus.
+bind common I echo {}
+
+# note: the single space at the end is intentional
+bind common ! push shell 
+
+# View/window navigation
+
+bind common 1 view tree
+bind common 2 view sorted
+bind common 3 view playlist
+bind common 4 view queue
+bind common 5 view browser
+bind common 6 view filters
+bind common 7 view settings
+
+bind common mouse_scroll_up_title left-view -n
+bind common mouse_scroll_down_title right-view -n
+
+bind common tab win-next
+
+bind common ^L refresh
+
+# Navigation
+
+bind common ^Y win-scroll-up
+bind common ^E win-scroll-down
+bind common ^B win-page-up
+bind common ^F win-page-down
+bind common ^U win-half-page-up
+bind common ^D win-half-page-down
+
+bind common k win-up
+bind common j win-down
+bind common g win-top
+bind common G win-bottom
+
+bind common up win-up
+bind common down win-down
+bind common home win-top
+bind common end win-bottom
+bind common page_up win-page-up
+bind common page_down win-page-down
+
+bind common mouse_scroll_up win-up
+bind common mouse_scroll_down win-down
+
+# Selection
+
+bind common i win-sel-cur
+bind common enter win-activate
+bind common mlb_click_selected win-activate
+
+bind common space win-toggle
+bind common D win-remove
+bind common delete win-remove
+bind common p win-mv-after
+bind common P win-mv-before
+
+bind common E win-add-Q
+bind common a win-add-l
+bind common y win-add-p
+bind common e win-add-q
+
+bind common u update-cache
+bind common U win-update-cache
+
+# Filters
+
+bind common / search-start
+bind common ? search-b-start
+bind common n search-next
+bind common N search-prev
+
+# note: the single space at the end is intentional
+bind common F push filter 
+bind common L push live-filter 
+
+fset 90s=date>=1990&date<2000
+fset classical=genre="Classical"
+fset unheard=play_count=0
+fset missing-tag=!stream&(artist=""|album=""|title=""|tracknumber=-1|date=-1)
+fset mp3=filename="*.mp3"
+fset ogg=filename="*.ogg"
+fset ogg-or-mp3=ogg|mp3
+
+# File browser
+
+bind browser backspace browser-up
+bind browser space win-activate
+bind browser i toggle show_hidden
+bind browser u win-update

data/solarized-dark.theme

@@ -0,0 +1,51 @@
+# colors from solarized: http://ethanschoonover.com/solarized
+# default text color
+set color_win_fg=default
+
+# overall background color
+set color_win_bg=default
+
+# command-line colors
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=160
+set color_info=136
+set color_separator=240
+
+# bottom status line
+set color_statusline_bg=0
+set color_statusline_fg=37
+set color_statusline_progress_bg=233
+set color_statusline_progress_fg=37
+
+# bottom title line
+set color_titleline_bg=0
+set color_titleline_fg=136
+
+# top title area
+set color_win_title_bg=0
+set color_win_title_fg=64
+##### playing file colors ######################################################
+# unselected currently playing track's text
+set color_win_cur=33
+
+# active selection for currently playing track
+set color_win_cur_sel_bg=0
+set color_win_cur_sel_fg=33
+
+# inactive selection for currently playing track
+set color_win_inactive_cur_sel_bg=default
+set color_win_inactive_cur_sel_fg=125
+
+##### non-playing file colors ##################################################
+# active selection
+set color_win_sel_bg=0
+set color_win_sel_fg=166
+
+# inactive selection
+set color_win_inactive_sel_bg=default
+set color_win_inactive_sel_fg=125
+
+##### file browser view colors #################################################
+# directory listing color
+set color_win_dir=33

data/solarized-light.theme

@@ -0,0 +1,51 @@
+# colors from solarized: http://ethanschoonover.com/solarized
+# default text color
+set color_win_fg=default
+
+# overall background color
+set color_win_bg=default
+
+# command-line colors
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=160
+set color_info=136
+set color_separator=245
+
+# bottom status line
+set color_statusline_bg=0
+set color_statusline_fg=37
+set color_statusline_progress_bg=233
+set color_statusline_progress_fg=37
+
+# bottom title line
+set color_titleline_bg=0
+set color_titleline_fg=136
+
+# top title area
+set color_win_title_bg=0
+set color_win_title_fg=64
+##### playing file colors ######################################################
+# unselected currently playing track's text
+set color_win_cur=33
+
+# active selection for currently playing track
+set color_win_cur_sel_bg=0
+set color_win_cur_sel_fg=33
+
+# inactive selection for currently playing track
+set color_win_inactive_cur_sel_bg=default
+set color_win_inactive_cur_sel_fg=125
+
+##### non-playing file colors ##################################################
+# active selection
+set color_win_sel_bg=0
+set color_win_sel_fg=166
+
+# inactive selection
+set color_win_inactive_sel_bg=default
+set color_win_inactive_sel_fg=125
+
+##### file browser view colors #################################################
+# directory listing color
+set color_win_dir=33

data/spotify.theme

@@ -0,0 +1,26 @@
+# @October, 2021 by github.com/frogwine
+set color_win_fg=252
+set color_win_bg=233
+set color_cmdline_bg=233
+set color_cmdline_fg=231
+set color_error=196
+set color_info=81
+set color_separator=47
+set color_statusline_bg=232
+set color_statusline_fg=34
+set color_statusline_progress_bg=234
+set color_statusline_progress_fg=34
+set color_titleline_bg=232
+set color_titleline_fg=83
+set color_win_title_bg=232
+set color_win_title_fg=83
+set color_win_cur=47
+set color_win_cur_sel_bg=239
+set color_win_cur_sel_fg=47
+set color_win_inactive_cur_sel_bg=233
+set color_win_inactive_cur_sel_fg=47
+set color_win_sel_bg=240
+set color_win_sel_fg=47
+set color_win_inactive_sel_bg=235
+set color_win_inactive_sel_fg=47
+set color_win_dir=47

data/xterm-white.theme

@@ -0,0 +1,26 @@
+# looks good with xterm using default settings (white bg)
+set color_cmdline_bg=default
+set color_cmdline_fg=default
+set color_error=lightred
+set color_info=lightblue
+set color_separator=default
+set color_statusline_bg=default
+set color_statusline_fg=default
+set color_statusline_progress_bg=gray
+set color_statusline_progress_fg=default
+set color_titleline_bg=gray
+set color_titleline_fg=default
+set color_win_bg=default
+set color_win_cur=lightblue
+set color_win_cur_sel_bg=green
+set color_win_cur_sel_fg=lightblue
+set color_win_dir=blue
+set color_win_fg=default
+set color_win_inactive_cur_sel_bg=gray
+set color_win_inactive_cur_sel_fg=lightblue
+set color_win_inactive_sel_bg=gray
+set color_win_inactive_sel_fg=default
+set color_win_sel_bg=green
+set color_win_sel_fg=default
+set color_win_title_bg=gray
+set color_win_title_fg=black

data/zenburn.theme

@@ -0,0 +1,54 @@
+# Directory colors
+set color_win_dir=108
+
+# Normal text
+set color_win_fg=188
+
+# Window background color.
+set color_win_bg=237
+
+# Command line color.
+set color_cmdline_bg=237
+set color_cmdline_fg=108
+
+# Color of error messages displayed on the command line.
+set color_error=lightred
+
+# Color of informational messages displayed on the command line.
+set color_info=lightgreen
+
+# Color of the separator line between windows in view (1).
+set color_separator=246
+
+# Color of window titles (topmost line of the screen).
+set color_win_title_bg=235
+set color_win_title_fg=174
+
+# Status line color.
+set color_statusline_bg=237
+set color_statusline_fg=142
+set color_statusline_progress_bg=240
+set color_statusline_progress_fg=142
+
+# Color of currently playing track.
+set color_win_cur=172
+
+# Color of the line displaying currently playing track.
+set color_titleline_bg=235
+set color_titleline_fg=144
+
+# Color of the selected row which is also the currently playing track in active window.
+set color_win_cur_sel_bg=235
+set color_win_cur_sel_fg=223
+
+# Color of the selected row which is also the currently playing track in inactive window.
+set color_win_inactive_cur_sel_bg=238
+set color_win_inactive_cur_sel_fg=116
+
+# Color of selected row in active window.
+set color_win_sel_bg=235
+set color_win_sel_fg=223
+
+# Color of selected row in inactive window.
+set color_win_inactive_sel_bg=238
+set color_win_inactive_sel_fg=116

debug.c

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "prog.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#if DEBUG > 1
+static FILE *debug_stream = NULL;
+#endif
+
+void debug_init(void)
+{
+#if DEBUG > 1
+	char filename[512];
+	const char *dir = getenv("CMUS_HOME");
+
+	if (!dir || !dir[0]) {
+		dir = getenv("HOME");
+		if (!dir)
+			die("error: environment variable HOME not set\n");
+	}
+	snprintf(filename, sizeof(filename), "%s/cmus-debug.txt", dir);
+
+	debug_stream = fopen(filename, "w");
+	if (debug_stream == NULL)
+		die_errno("error opening `%s' for writing", filename);
+#endif
+}
+
+/* This function must be defined even if debugging is disabled in the program
+ * because debugging might still be enabled in some plugin.
+ */
+void _debug_bug(const char *function, const char *fmt, ...)
+{
+	const char *format = "\n%s: BUG: ";
+	va_list ap;
+
+	/* debug_stream exists only if debugging is enabled */
+#if DEBUG > 1
+	fprintf(debug_stream, format, function);
+	va_start(ap, fmt);
+	vfprintf(debug_stream, fmt, ap);
+	va_end(ap);
+#endif
+
+	/* always print bug message to stderr */
+	fprintf(stderr, format, function);
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	exit(127);
+}
+
+void _debug_print(const char *function, const char *fmt, ...)
+{
+#if DEBUG > 1
+	va_list ap;
+
+	fprintf(debug_stream, "%s: ", function);
+	va_start(ap, fmt);
+	vfprintf(debug_stream, fmt, ap);
+	va_end(ap);
+	fflush(debug_stream);
+#endif
+}
+
+uint64_t timer_get(void)
+{
+#if DEBUG > 1
+	struct timeval tv;
+
+	gettimeofday(&tv, NULL);
+	return tv.tv_sec * 1e6L + tv.tv_usec;
+#else
+	return 0;
+#endif
+}
+
+void timer_print(const char *what, uint64_t usec)
+{
+#if DEBUG > 1
+	uint64_t a = usec / 1e6;
+	uint64_t b = usec - a * 1e6;
+
+	_debug_print("TIMER", "%s: %11u.%06u\n", what, (unsigned int)a, (unsigned int)b);
+#endif
+}

debug.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_DEBUG_H
+#define CMUS_DEBUG_H
+
+#include "compiler.h"
+#ifdef HAVE_CONFIG
+#include "config/debug.h"
+#endif
+
+#include <errno.h>
+#include <stdint.h>
+
+void debug_init(void);
+void _debug_bug(const char *function, const char *fmt, ...) CMUS_FORMAT(2, 3) CMUS_NORETURN;
+void _debug_print(const char *function, const char *fmt, ...) CMUS_FORMAT(2, 3);
+
+uint64_t timer_get(void);
+void timer_print(const char *what, uint64_t usec);
+
+#define BUG(...) _debug_bug(__FUNCTION__, __VA_ARGS__)
+
+#define CMUS_STR(a) #a
+
+#define BUG_ON(a)			\
+do {					\
+	if (unlikely(a))		\
+		BUG("%s\n", CMUS_STR(a));	\
+} while (0)
+
+#define d_print(...) _debug_print(__FUNCTION__, __VA_ARGS__)
+
+#endif

discid.c

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "discid.h"
+#include "xmalloc.h"
+#include "path.h"
+#include "utils.h"
+#include "debug.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <limits.h>
+
+#ifdef HAVE_DISCID
+#include <discid/discid.h>
+#endif
+
+char *get_default_cdda_device(void)
+{
+	const char *dev = NULL;
+#ifdef HAVE_DISCID
+	dev = discid_get_default_device();
+#endif
+	if (!dev)
+		dev = "/dev/cdrom";
+	return xstrdup(dev);
+}
+
+int parse_cdda_url(const char *url, char **disc_id, int *start_track, int *end_track)
+{
+	char *slash, *dash;
+	long int t;
+
+	if (!is_cdda_url(url))
+		return 0;
+	url += 7;
+
+	slash = strrchr(url, '/');
+	if (slash) {
+		*disc_id = xstrndup(url, slash - url);
+		url = slash + 1;
+	}
+	dash = strchr(url, '-');
+	if (dash) {
+		char *tmp = xstrndup(url, dash - url);
+		if (str_to_int(tmp, &t) == 0)
+			*start_track = t;
+		if (end_track) {
+			if (str_to_int(dash + 1, &t) == 0)
+				*end_track = t;
+			else
+				*end_track = INT_MAX;
+		}
+		free(tmp);
+	} else {
+		if (str_to_int(url, &t) == 0)
+			*start_track = t;
+	}
+
+	return 1;
+}
+
+char *gen_cdda_url(const char *disc_id, int start_track, int end_track)
+{
+	char buf[256];
+	if (end_track != -1)
+		snprintf(buf, sizeof(buf), "cdda://%s/%d-%d", disc_id, start_track, end_track);
+	else
+		snprintf(buf, sizeof(buf), "cdda://%s/%d", disc_id, start_track);
+	return xstrdup(buf);
+}
+
+char *complete_cdda_url(const char *device, const char *url)
+{
+	char *new_url, *url_disc_id = NULL, *disc_id = NULL;
+	int is_range, start_track = -1, end_track = -1, num_tracks = -1;
+
+	parse_cdda_url(url, &url_disc_id, &start_track, &end_track);
+	is_range = (start_track == -1 && end_track == -1) || end_track == INT_MAX;
+	if (!url_disc_id || is_range) {
+		if (url_disc_id && strchr(url_disc_id, '/'))
+			device = url_disc_id;
+		get_disc_id(device, &disc_id, &num_tracks);
+		if (is_range)
+			end_track = num_tracks;
+		if (!url_disc_id)
+			url_disc_id = disc_id;
+	}
+	if (start_track == -1)
+		start_track = 1;
+
+	new_url = gen_cdda_url(url_disc_id, start_track, end_track);
+	free(disc_id);
+
+	return new_url;
+}
+
+static int get_device_disc_id(const char *device, char **disc_id, int *num_tracks)
+{
+#ifdef HAVE_DISCID
+	DiscId *disc = discid_new();
+	if (!disc)
+		return 0;
+
+	if (!discid_read(disc, device)) {
+		d_print("%s\n", discid_get_error_msg(disc));
+		discid_free(disc);
+		return 0;
+	}
+
+	*disc_id = xstrdup(discid_get_id(disc));
+	if (num_tracks)
+		*num_tracks = discid_get_last_track_num(disc);
+
+	discid_free(disc);
+	return 1;
+#else
+	return 0;
+#endif
+}
+
+int get_disc_id(const char *device, char **disc_id, int *num_tracks)
+{
+	struct stat st;
+
+	if (stat(device, &st) == -1)
+		return 0;
+
+	if (S_ISBLK(st.st_mode))
+		return get_device_disc_id(device, disc_id, num_tracks);
+
+	*disc_id = path_absolute(device);
+	return 1;
+}

discid.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_DISCID_H
+#define CMUS_DISCID_H
+
+char *get_default_cdda_device(void);
+int parse_cdda_url(const char *url, char **disc_id, int *start_track, int *end_track);
+char *gen_cdda_url(const char *disc_id, int start_track, int end_track);
+char *complete_cdda_url(const char *device, const char *url);
+int get_disc_id(const char *device, char **disc_id, int *num_tracks);
+
+#endif

editable.c

@@ -0,0 +1,466 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "editable.h"
+#include "search.h"
+#include "track.h"
+#include "track_info.h"
+#include "expr.h"
+#include "filters.h"
+#include "locking.h"
+#include "mergesort.h"
+#include "xmalloc.h"
+
+static const struct searchable_ops simple_search_ops = {
+	.get_prev = simple_track_get_prev,
+	.get_next = simple_track_get_next,
+	.get_current = simple_track_search_get_current,
+	.matches = simple_track_search_matches
+};
+
+static struct simple_track *get_selected(struct editable *e)
+{
+	struct iter sel;
+
+	if (window_get_sel(e->shared->win, &sel))
+		return iter_to_simple_track(&sel);
+	return NULL;
+}
+
+void editable_shared_init(struct editable_shared *shared,
+		editable_free_track free_track)
+{
+	shared->win = window_new(simple_track_get_prev, simple_track_get_next);
+	shared->sort_keys = xnew(sort_key_t, 1);
+	shared->sort_keys[0] = SORT_INVALID;
+	shared->sort_str[0] = 0;
+	shared->free_track = free_track;
+	shared->owner = NULL;
+
+	struct iter iter = { 0 };
+	shared->searchable = searchable_new(shared->win, &iter,
+			&simple_search_ops);
+}
+
+void editable_init(struct editable *e, struct editable_shared *shared,
+		int take_ownership)
+{
+	list_init(&e->head);
+	e->tree_root = RB_ROOT;
+	e->nr_tracks = 0;
+	e->nr_marked = 0;
+	e->total_time = 0;
+	e->shared = shared;
+
+
+	if (take_ownership)
+		editable_take_ownership(e);
+}
+
+static int editable_owns_shared(struct editable *e)
+{
+	return e->shared->owner == e;
+}
+
+void editable_take_ownership(struct editable *e)
+{
+	if (!editable_owns_shared(e)) {
+		e->shared->owner = e;
+		window_set_contents(e->shared->win, &e->head);
+		e->shared->win->changed = 1;
+
+		struct iter iter = { .data0 = &e->head };
+		searchable_set_head(e->shared->searchable, &iter);
+	}
+}
+
+static void do_editable_add(struct editable *e, struct simple_track *track, int tiebreak)
+{
+	sorted_list_add_track(&e->head, &e->tree_root, track,
+			e->shared->sort_keys, tiebreak);
+	e->nr_tracks++;
+	if (track->info->duration != -1)
+		e->total_time += track->info->duration;
+	if (editable_owns_shared(e))
+		window_changed(e->shared->win);
+}
+
+void editable_add(struct editable *e, struct simple_track *track)
+{
+	do_editable_add(e, track, +1);
+}
+
+void editable_add_before(struct editable *e, struct simple_track *track)
+{
+	do_editable_add(e, track, -1);
+}
+
+void editable_remove_track(struct editable *e, struct simple_track *track)
+{
+	struct track_info *ti = track->info;
+	struct iter iter;
+
+	editable_track_to_iter(e, track, &iter);
+	if (editable_owns_shared(e))
+		window_row_vanishes(e->shared->win, &iter);
+
+	e->nr_tracks--;
+	e->nr_marked -= track->marked;
+	if (ti->duration != -1)
+		e->total_time -= ti->duration;
+
+	sorted_list_remove_track(&e->head, &e->tree_root, track);
+	e->shared->free_track(e, &track->node);
+}
+
+void editable_remove_sel(struct editable *e)
+{
+	struct simple_track *t;
+
+	if (e->nr_marked) {
+		/* treat marked tracks as selected */
+		struct list_head *next, *item = e->head.next;
+
+		while (item != &e->head) {
+			next = item->next;
+			t = to_simple_track(item);
+			if (t->marked)
+				editable_remove_track(e, t);
+			item = next;
+		}
+	} else {
+		t = get_selected(e);
+		if (t)
+			editable_remove_track(e, t);
+	}
+}
+
+void editable_sort(struct editable *e)
+{
+	if (e->nr_tracks <= 1)
+		return;
+	sorted_list_rebuild(&e->head, &e->tree_root, e->shared->sort_keys);
+
+	if (editable_owns_shared(e)) {
+		window_changed(e->shared->win);
+		window_goto_top(e->shared->win);
+	}
+}
+
+void editable_shared_set_sort_keys(struct editable_shared *shared,
+		sort_key_t *keys)
+{
+	free(shared->sort_keys);
+	shared->sort_keys = keys;
+}
+
+void editable_toggle_mark(struct editable *e)
+{
+	struct simple_track *t;
+
+	t = get_selected(e);
+	if (t) {
+		e->nr_marked -= t->marked;
+		t->marked ^= 1;
+		e->nr_marked += t->marked;
+		if (editable_owns_shared(e)) {
+			e->shared->win->changed = 1;
+			window_down(e->shared->win, 1);
+		}
+	}
+}
+
+static void move_item(struct editable *e, struct list_head *head, struct list_head *item)
+{
+	struct simple_track *t = to_simple_track(item);
+	struct iter iter;
+
+	editable_track_to_iter(e, t, &iter);
+	if (editable_owns_shared(e))
+		window_row_vanishes(e->shared->win, &iter);
+
+	list_del(item);
+	list_add(item, head);
+}
+
+static void reset_tree(struct editable *e)
+{
+	struct simple_track *old, *first_track;
+
+	old = tree_node_to_simple_track(rb_first(&e->tree_root));
+	first_track = to_simple_track(e->head.next);
+	if (old != first_track) {
+		rb_replace_node(&old->tree_node, &first_track->tree_node, &e->tree_root);
+		RB_CLEAR_NODE(&old->tree_node);
+	}
+}
+
+static void move_sel(struct editable *e, struct list_head *after)
+{
+	struct simple_track *t;
+	struct list_head *item, *next;
+	struct iter iter;
+	LIST_HEAD(tmp_head);
+
+	if (e->nr_marked) {
+		/* collect marked */
+		item = e->head.next;
+		while (item != &e->head) {
+			t = to_simple_track(item);
+			next = item->next;
+			if (t->marked)
+				move_item(e, &tmp_head, item);
+			item = next;
+		}
+	} else {
+		/* collect the selected track */
+		t = get_selected(e);
+		if (t)
+			move_item(e, &tmp_head, &t->node);
+	}
+
+	/* put them back to the list after @after */
+	item = tmp_head.next;
+	while (item != &tmp_head) {
+		next = item->next;
+		list_add(item, after);
+		item = next;
+	}
+	reset_tree(e);
+
+	/* select top-most of the moved tracks */
+	editable_track_to_iter(e, to_simple_track(after->next), &iter);
+
+	if (editable_owns_shared(e)) {
+		window_changed(e->shared->win);
+		window_set_sel(e->shared->win, &iter);
+	}
+}
+
+static struct list_head *find_insert_after_point(struct editable *e, struct list_head *item)
+{
+	if (e->nr_marked == 0) {
+		/* move the selected track down one row */
+		return item->next;
+	}
+
+	/* move marked after the selected
+	 *
+	 * if the selected track itself is marked we find the first unmarked
+	 * track (or head) before the selected one
+	 */
+	while (item != &e->head) {
+		struct simple_track *t = to_simple_track(item);
+
+		if (!t->marked)
+			break;
+		item = item->prev;
+	}
+	return item;
+}
+
+static struct list_head *find_insert_before_point(struct editable *e, struct list_head *item)
+{
+	item = item->prev;
+	if (e->nr_marked == 0) {
+		/* move the selected track up one row */
+		return item->prev;
+	}
+
+	/* move marked before the selected
+	 *
+	 * if the selected track itself is marked we find the first unmarked
+	 * track (or head) before the selected one
+	 */
+	while (item != &e->head) {
+		struct simple_track *t = to_simple_track(item);
+
+		if (!t->marked)
+			break;
+		item = item->prev;
+	}
+	return item;
+}
+
+void editable_move_after(struct editable *e)
+{
+	struct simple_track *sel;
+
+	if (e->nr_tracks <= 1 || e->shared->sort_keys[0] != SORT_INVALID)
+		return;
+
+	sel = get_selected(e);
+	if (sel)
+		move_sel(e, find_insert_after_point(e, &sel->node));
+}
+
+void editable_move_before(struct editable *e)
+{
+	struct simple_track *sel;
+
+	if (e->nr_tracks <= 1 || e->shared->sort_keys[0] != SORT_INVALID)
+		return;
+
+	sel = get_selected(e);
+	if (sel)
+		move_sel(e, find_insert_before_point(e, &sel->node));
+}
+
+void editable_clear(struct editable *e)
+{
+	struct list_head *item, *tmp;
+
+	list_for_each_safe(item, tmp, &e->head)
+		editable_remove_track(e, to_simple_track(item));
+}
+
+void editable_remove_matching_tracks(struct editable *e,
+		int (*cb)(void *data, struct track_info *ti), void *data)
+{
+	struct list_head *item, *tmp;
+
+	list_for_each_safe(item, tmp, &e->head) {
+		struct simple_track *t = to_simple_track(item);
+		if (cb(data, t->info))
+			editable_remove_track(e, t);
+	}
+}
+
+void editable_mark(struct editable *e, const char *filter)
+{
+	struct expr *expr = NULL;
+	struct simple_track *t;
+
+	if (filter) {
+		expr = parse_filter(filter);
+		if (expr == NULL)
+			return;
+	}
+
+	list_for_each_entry(t, &e->head, node) {
+		e->nr_marked -= t->marked;
+		t->marked = 0;
+		if (expr == NULL || expr_eval(expr, t->info)) {
+			t->marked = 1;
+			e->nr_marked++;
+		}
+	}
+
+	if (editable_owns_shared(e))
+		e->shared->win->changed = 1;
+}
+
+void editable_unmark(struct editable *e)
+{
+	struct simple_track *t;
+
+	list_for_each_entry(t, &e->head, node) {
+		e->nr_marked -= t->marked;
+		t->marked = 0;
+	}
+
+	if (editable_owns_shared(e))
+		e->shared->win->changed = 1;
+}
+
+void editable_invert_marks(struct editable *e)
+{
+	struct simple_track *t;
+
+	list_for_each_entry(t, &e->head, node) {
+		e->nr_marked -= t->marked;
+		t->marked ^= 1;
+		e->nr_marked += t->marked;
+	}
+
+	if (editable_owns_shared(e))
+		e->shared->win->changed = 1;
+}
+
+int _editable_for_each_sel(struct editable *e, track_info_cb cb, void *data,
+		int reverse)
+{
+	int rc = 0;
+
+	if (e->nr_marked) {
+		/* treat marked tracks as selected */
+		rc = simple_list_for_each_marked(&e->head, cb, data, reverse);
+	} else {
+		struct simple_track *t = get_selected(e);
+
+		if (t)
+			rc = cb(data, t->info);
+	}
+	return rc;
+}
+
+int editable_for_each_sel(struct editable *e, track_info_cb cb, void *data,
+		int reverse, int advance)
+{
+	int rc;
+
+	rc = _editable_for_each_sel(e, cb, data, reverse);
+	if (advance && e->nr_marked == 0 && editable_owns_shared(e))
+		window_down(e->shared->win, 1);
+	return rc;
+}
+
+int editable_for_each(struct editable *e, track_info_cb cb, void *data,
+		int reverse)
+{
+	return simple_list_for_each(&e->head, cb, data, reverse);
+}
+
+void editable_update_track(struct editable *e, struct track_info *old, struct track_info *new)
+{
+	struct list_head *item, *tmp;
+	int changed = 0;
+
+	list_for_each_safe(item, tmp, &e->head) {
+		struct simple_track *track = to_simple_track(item);
+		if (track->info == old) {
+			if (new) {
+				track_info_unref(old);
+				track_info_ref(new);
+				track->info = new;
+			} else {
+				editable_remove_track(e, track);
+			}
+			changed = 1;
+		}
+	}
+	if (editable_owns_shared(e))
+		e->shared->win->changed |= changed;
+}
+
+void editable_rand(struct editable *e)
+{
+	if (e->nr_tracks <=1)
+		return;
+	rand_list_rebuild(&e->head, &e->tree_root);
+
+	if (editable_owns_shared(e)) {
+		window_changed(e->shared->win);
+		window_goto_top(e->shared->win);
+	}
+}
+
+int editable_empty(struct editable *e)
+{
+	return list_empty(&e->head);
+}

editable.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_EDITABLE_H
+#define CMUS_EDITABLE_H
+
+#include "window.h"
+#include "list.h"
+#include "rbtree.h"
+#include "track.h"
+#include "locking.h"
+#include "cmus.h"
+
+struct editable;
+
+typedef void (*editable_free_track)(struct editable *e, struct list_head *head);
+
+struct editable_shared {
+	struct editable *owner;
+
+	struct window *win;
+	sort_key_t *sort_keys;
+	char sort_str[128];
+	editable_free_track free_track;
+	struct searchable *searchable;
+};
+
+struct editable {
+	struct list_head head;
+	struct rb_root tree_root;
+	unsigned int nr_tracks;
+	unsigned int nr_marked;
+	unsigned int total_time;
+	struct editable_shared *shared;
+};
+
+void editable_shared_init(struct editable_shared *shared,
+		editable_free_track free_track);
+void editable_shared_set_sort_keys(struct editable_shared *shared,
+		sort_key_t *keys);
+
+void editable_init(struct editable *e, struct editable_shared *shared,
+		int take_ownership);
+void editable_take_ownership(struct editable *e);
+void editable_add(struct editable *e, struct simple_track *track);
+void editable_add_before(struct editable *e, struct simple_track *track);
+void editable_remove_track(struct editable *e, struct simple_track *track);
+void editable_remove_sel(struct editable *e);
+void editable_sort(struct editable *e);
+void editable_rand(struct editable *e);
+void editable_toggle_mark(struct editable *e);
+void editable_move_after(struct editable *e);
+void editable_move_before(struct editable *e);
+void editable_clear(struct editable *e);
+void editable_remove_matching_tracks(struct editable *e,
+		int (*cb)(void *data, struct track_info *ti), void *data);
+void editable_mark(struct editable *e, const char *filter);
+void editable_unmark(struct editable *e);
+void editable_invert_marks(struct editable *e);
+int _editable_for_each_sel(struct editable *e, track_info_cb cb, void *data,
+		int reverse);
+int editable_for_each_sel(struct editable *e, track_info_cb cb, void *data,
+		int reverse, int advance);
+int editable_for_each(struct editable *e, track_info_cb cb, void *data,
+		int reverse);
+void editable_update_track(struct editable *e, struct track_info *old, struct track_info *new);
+int editable_empty(struct editable *e);
+
+static inline void editable_track_to_iter(struct editable *e, struct simple_track *track, struct iter *iter)
+{
+	iter->data0 = &e->head;
+	iter->data1 = track;
+	iter->data2 = NULL;
+}
+
+#endif

expr.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_EXPR_H
+#define CMUS_EXPR_H
+
+#include "track_info.h"
+#include "list.h"
+
+enum { OP_LT, OP_LE, OP_EQ, OP_GE, OP_GT, OP_NE };
+#define NR_OPS (OP_NE + 1)
+
+enum expr_type {
+	EXPR_AND,
+	EXPR_OR,
+
+	EXPR_NOT,
+
+	EXPR_STR,
+	EXPR_INT,
+	EXPR_ID,
+	EXPR_BOOL
+};
+#define NR_EXPRS (EXPR_BOOL + 1)
+
+struct expr {
+	struct expr *left, *right, *parent;
+	enum expr_type type;
+	char *key;
+	union {
+		struct {
+			struct list_head glob_head;
+			enum {
+				SOP_EQ = OP_EQ,
+				SOP_NE = OP_NE
+			} op;
+		} estr;
+		struct {
+			int val;
+			enum {
+				IOP_LT = OP_LT,
+				IOP_LE = OP_LE,
+				IOP_EQ = OP_EQ,
+				IOP_GE = OP_GE,
+				IOP_GT = OP_GT,
+				IOP_NE = OP_NE
+			} op;
+		} eint;
+		struct {
+			char* key;
+			enum {
+				KOP_LT = OP_LT,
+				KOP_LE = OP_LE,
+				KOP_EQ = OP_EQ,
+				KOP_GE = OP_GE,
+				KOP_GT = OP_GT,
+				KOP_NE = OP_NE
+			} op;
+		} eid;
+	};
+};
+
+struct expr *expr_parse(const char *str);
+struct expr* expr_parse_i(const char *str, const char *err_msg, int check_short);
+int expr_check_leaves(struct expr **exprp, const char *(*get_filter)(const char *name));
+int expr_op_to_bool(int res, int op);
+int expr_eval(struct expr *expr, struct track_info *ti);
+void expr_free(struct expr *expr);
+const char *expr_error(void);
+int expr_is_short(const char *str);
+
+unsigned int expr_get_match_type(struct expr *expr);
+/* "harmless" expressions will reduce filter results when adding characters at the beginning/end */
+int expr_is_harmless(const struct expr *expr);
+
+#endif

file.c

@@ -0,0 +1,185 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "file.h"
+#include "xmalloc.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+ssize_t read_all(int fd, void *buf, size_t count)
+{
+	char *buffer = buf;
+	ssize_t pos = 0;
+
+	do {
+		ssize_t rc;
+
+		rc = read(fd, buffer + pos, count - pos);
+		if (rc == -1) {
+			if (errno == EINTR || errno == EAGAIN)
+				continue;
+			return -1;
+		}
+		if (rc == 0) {
+			/* eof */
+			break;
+		}
+		pos += rc;
+	} while (count - pos > 0);
+	return pos;
+}
+
+ssize_t write_all(int fd, const void *buf, size_t count)
+{
+	const char *buffer = buf;
+	int count_save = count;
+
+	do {
+		int rc;
+
+		rc = write(fd, buffer, count);
+		if (rc == -1) {
+			if (errno == EINTR || errno == EAGAIN)
+				continue;
+			return -1;
+		}
+		buffer += rc;
+		count -= rc;
+	} while (count > 0);
+	return count_save;
+}
+
+char *mmap_file(const char *filename, ssize_t *size)
+{
+	struct stat st;
+	char *buf;
+	int fd;
+
+	fd = open(filename, O_RDONLY);
+	if (fd == -1)
+		goto err;
+
+	if (fstat(fd, &st) == -1)
+		goto close_err;
+
+	/* can't mmap empty files */
+	buf = NULL;
+	if (st.st_size) {
+		buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+		if (buf == MAP_FAILED)
+			goto close_err;
+	}
+
+	close(fd);
+	*size = st.st_size;
+	return buf;
+
+close_err:
+	close(fd);
+err:
+	*size = -1;
+	return NULL;
+}
+
+void buffer_for_each_line(const char *buf, int size,
+		int (*cb)(void *data, const char *line),
+		void *data)
+{
+	char *line = NULL;
+	int line_size = 0, pos = 0;
+
+	while (pos < size) {
+		int end, len;
+
+		end = pos;
+		while (end < size && buf[end] != '\n')
+			end++;
+
+		len = end - pos;
+		if (end > pos && buf[end - 1] == '\r')
+			len--;
+
+		if (len >= line_size) {
+			line_size = len + 1;
+			line = xrenew(char, line, line_size);
+		}
+		memcpy(line, buf + pos, len);
+		line[len] = 0;
+		pos = end + 1;
+
+		if (cb(data, line))
+			break;
+	}
+	free(line);
+}
+
+void buffer_for_each_line_reverse(const char *buf, int size,
+		int (*cb)(void *data, const char *line),
+		void *data)
+{
+	char *line = NULL;
+	int line_size = 0, end = size - 1;
+
+	while (end >= 0) {
+		int pos, len;
+
+		if (end > 1 && buf[end] == '\n' && buf[end - 1] == '\r')
+			end--;
+
+		pos = end;
+		while (pos > 0 && buf[pos - 1] != '\n')
+			pos--;
+
+		len = end - pos;
+		if (len >= line_size) {
+			line_size = len + 1;
+			line = xrenew(char, line, line_size);
+		}
+		memcpy(line, buf + pos, len);
+		line[len] = 0;
+		end = pos - 1;
+
+		if (cb(data, line))
+			break;
+	}
+	free(line);
+}
+
+int file_for_each_line(const char *filename,
+		int (*cb)(void *data, const char *line),
+		void *data)
+{
+	char *buf;
+	ssize_t size;
+
+	buf = mmap_file(filename, &size);
+	if (size == -1)
+		return -1;
+
+	if (buf) {
+		buffer_for_each_line(buf, size, cb, data);
+		munmap(buf, size);
+	}
+	return 0;
+}

file.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_FILE_H
+#define CMUS_FILE_H
+
+#include <stddef.h> /* size_t */
+#include <sys/types.h> /* ssize_t */
+
+ssize_t read_all(int fd, void *buf, size_t count);
+ssize_t write_all(int fd, const void *buf, size_t count);
+
+/* @filename  file to mmap for reading
+ * @size      returned size of the file or -1 if failed
+ *
+ * returns buffer or NULL if empty file or failed
+ */
+char *mmap_file(const char *filename, ssize_t *size);
+
+void buffer_for_each_line(const char *buf, int size,
+		int (*cb)(void *data, const char *line),
+		void *data);
+void buffer_for_each_line_reverse(const char *buf, int size,
+		int (*cb)(void *data, const char *line),
+		void *data);
+int file_for_each_line(const char *filename,
+		int (*cb)(void *data, const char *line),
+		void *data);
+
+#endif

filters.c

@@ -0,0 +1,474 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "filters.h"
+#include "cmdline.h"
+#include "expr.h"
+#include "window.h"
+#include "search.h"
+#include "uchar.h"
+#include "lib.h"
+#include "misc.h"
+#include "file.h"
+#include "ui_curses.h"
+#include "xmalloc.h"
+
+#include <stdio.h>
+#include <ctype.h>
+
+struct window *filters_win;
+struct searchable *filters_searchable;
+LIST_HEAD(filters_head);
+
+static const char *recursive_filter;
+
+static inline void filter_entry_to_iter(struct filter_entry *e, struct iter *iter)
+{
+	iter->data0 = &filters_head;
+	iter->data1 = e;
+	iter->data2 = NULL;
+}
+
+static GENERIC_ITER_PREV(filters_get_prev, struct filter_entry, node)
+static GENERIC_ITER_NEXT(filters_get_next, struct filter_entry, node)
+
+static int filters_search_get_current(void *data, struct iter *iter, enum search_direction dir)
+{
+	return window_get_sel(filters_win, iter);
+}
+
+static int filters_search_matches(void *data, struct iter *iter, const char *text)
+{
+	char **words = get_words(text);
+	int matched = 0;
+
+	if (words[0] != NULL) {
+		struct filter_entry *e;
+		int i;
+
+		e = iter_to_filter_entry(iter);
+		for (i = 0; ; i++) {
+			if (words[i] == NULL) {
+				window_set_sel(filters_win, iter);
+				matched = 1;
+				break;
+			}
+			if (u_strcasestr(e->name, words[i]) == NULL)
+				break;
+		}
+	}
+	free_str_array(words);
+	return matched;
+}
+
+static const struct searchable_ops filters_search_ops = {
+	.get_prev = filters_get_prev,
+	.get_next = filters_get_next,
+	.get_current = filters_search_get_current,
+	.matches = filters_search_matches
+};
+
+static void free_filter(struct filter_entry *e)
+{
+	free(e->name);
+	free(e->filter);
+	free(e);
+}
+
+static struct filter_entry *find_filter(const char *name)
+{
+	struct filter_entry *e;
+
+	list_for_each_entry(e, &filters_head, node) {
+		if (strcmp(e->name, name) == 0)
+			return e;
+	}
+	return NULL;
+}
+
+static const char *get_filter(const char *name)
+{
+	struct filter_entry *e = find_filter(name);
+
+	if (e) {
+		if (e->visited) {
+			recursive_filter = e->name;
+			return NULL;
+		}
+		e->visited = 1;
+		return e->filter;
+	}
+	return NULL;
+}
+
+static void edit_sel_filter(void)
+{
+	struct iter sel;
+	struct filter_entry *e;
+	char buf[512];
+
+	if (!window_get_sel(filters_win, &sel))
+		return;
+
+	e = iter_to_filter_entry(&sel);
+	snprintf(buf, sizeof(buf), "fset %s=%s", e->name, e->filter);
+	cmdline_set_text(buf);
+	enter_command_mode();
+}
+
+void filters_activate(int win_activate)
+{
+	struct filter_entry *f;
+	struct expr *e, *expr = NULL;
+	int unchanged = 1;
+
+	/* if no pending selection is to apply, edit currently select filter */
+	list_for_each_entry(f, &filters_head, node) {
+		if (f->act_stat != f->sel_stat)
+			unchanged = 0;
+	}
+
+	if (unchanged) {
+		if (win_activate)
+			edit_sel_filter();
+		else
+			return;
+	}
+
+	/* mark visited and AND together all selected filters
+	 * mark any other filters unvisited */
+	list_for_each_entry(f, &filters_head, node) {
+		f->visited = 0;
+		if (f->sel_stat == FS_IGNORE)
+			continue;
+
+		f->visited = 1;
+		e = expr_parse(f->filter);
+		if (e == NULL) {
+			error_msg("error parsing filter %s: %s", f->name, expr_error());
+			if (expr)
+				expr_free(expr);
+			return;
+		}
+
+		if (f->sel_stat == FS_NO) {
+			/* add ! */
+			struct expr *not = xnew(struct expr, 1);
+
+			not->type = EXPR_NOT;
+			not->key = NULL;
+			not->left = e;
+			not->right = NULL;
+			e = not;
+		}
+		if (expr == NULL) {
+			expr = e;
+		} else {
+			struct expr *and = xnew(struct expr, 1);
+
+			and->type = EXPR_AND;
+			and->key = NULL;
+			and->left = expr;
+			and->right = e;
+			expr->parent = and;
+			e->parent = and;
+			expr = and;
+		}
+	}
+
+	recursive_filter = NULL;
+	if (expr && expr_check_leaves(&expr, get_filter)) {
+		if (recursive_filter) {
+			error_msg("recursion detected in filter %s", recursive_filter);
+		} else {
+			error_msg("error parsing filter: %s", expr_error());
+		}
+		expr_free(expr);
+		return;
+	}
+
+	/* update active flag */
+	list_for_each_entry(f, &filters_head, node) {
+		f->act_stat = f->sel_stat;
+	}
+	lib_set_filter(expr);
+	filters_win->changed = 1;
+}
+
+static int for_each_name(const char *str, int (*cb)(const char *name, int sel_stat))
+{
+	char buf[64];
+	int s, e, len;
+
+	e = 0;
+	do {
+		int sel_stat = FS_YES;
+
+		s = e;
+		while (str[s] == ' ')
+			s++;
+		if (str[s] == '!') {
+			sel_stat = FS_NO;
+			s++;
+		}
+		e = s;
+		while (str[e] && str[e] != ' ')
+			e++;
+
+		len = e - s;
+		if (len == 0)
+			return 0;
+		if (len >= sizeof(buf)) {
+			error_msg("filter name too long");
+			return -1;
+		}
+
+		memcpy(buf, str + s, len);
+		buf[len] = 0;
+
+		if (cb(buf, sel_stat))
+			return -1;
+	} while (1);
+}
+
+static int ensure_filter_name(const char *name, int sel_stat)
+{
+	if (find_filter(name) == NULL) {
+		error_msg("no such filter %s", name);
+		return -1;
+	}
+	return 0;
+}
+
+static int select_filter(const char *name, int sel_stat)
+{
+	struct filter_entry *e = find_filter(name);
+
+	e->sel_stat = sel_stat;
+	return 0;
+}
+
+void filters_activate_names(const char *str)
+{
+	struct filter_entry *f;
+
+	/* first validate all filter names */
+	if (str && for_each_name(str, ensure_filter_name))
+		return;
+
+	/* mark all filters unselected  */
+	list_for_each_entry(f, &filters_head, node)
+		f->sel_stat = FS_IGNORE;
+
+	/* select the filters */
+	if (str)
+		for_each_name(str, select_filter);
+
+	/* activate selected */
+	filters_activate(0);
+}
+
+void filters_toggle_filter(void)
+{
+	struct iter iter;
+
+	if (window_get_sel(filters_win, &iter)) {
+		struct filter_entry *e;
+
+		e = iter_to_filter_entry(&iter);
+		e->sel_stat = (e->sel_stat + 1) % 3;
+		filters_win->changed = 1;
+	}
+}
+
+void filters_delete_filter(void)
+{
+	struct iter iter;
+
+	if (window_get_sel(filters_win, &iter)) {
+		struct filter_entry *e;
+
+		e = iter_to_filter_entry(&iter);
+		if (yes_no_query("Delete filter '%s'? [y/N]", e->name) == UI_QUERY_ANSWER_YES) {
+			window_row_vanishes(filters_win, &iter);
+			list_del(&e->node);
+			free_filter(e);
+		}
+	}
+}
+
+static int validate_filter_name(const char *name)
+{
+	int i;
+
+	for (i = 0; name[i]; i++) {
+		if (isalnum((unsigned char)name[i]))
+			continue;
+		if (name[i] == '_' || name[i] == '-')
+			continue;
+		return 0;
+	}
+	return i != 0;
+}
+
+static void do_filters_set_filter(const char *keyval)
+{
+	const char *eq = strchr(keyval, '=');
+	char *key, *val;
+	struct expr *expr;
+	struct filter_entry *new;
+	struct list_head *item;
+
+	if (eq == NULL) {
+		if (ui_initialized)
+			error_msg("invalid argument ('key=value' expected)");
+		return;
+	}
+	key = xstrndup(keyval, eq - keyval);
+	val = xstrdup(eq + 1);
+	if (!validate_filter_name(key)) {
+		if (ui_initialized)
+			error_msg("invalid filter name (can only contain 'a-zA-Z0-9_-' characters)");
+		free(key);
+		free(val);
+		return;
+	}
+	expr = expr_parse(val);
+	if (expr == NULL) {
+		if (ui_initialized)
+			error_msg("error parsing filter %s: %s", val, expr_error());
+		free(key);
+		free(val);
+		return;
+	}
+	expr_free(expr);
+
+	new = xnew(struct filter_entry, 1);
+	new->name = key;
+	new->filter = val;
+	new->act_stat = FS_IGNORE;
+	new->sel_stat = FS_IGNORE;
+
+	/* add or replace filter */
+	list_for_each(item, &filters_head) {
+		struct filter_entry *e = container_of(item, struct filter_entry, node);
+		int res = strcmp(key, e->name);
+
+		if (res < 0)
+			break;
+		if (res == 0) {
+			/* replace */
+			struct iter iter;
+
+			new->sel_stat = e->sel_stat;
+			if (ui_initialized) {
+				filter_entry_to_iter(e, &iter);
+				window_row_vanishes(filters_win, &iter);
+			}
+			item = item->next;
+			list_del(&e->node);
+			free_filter(e);
+			break;
+		}
+	}
+	/* add before item */
+	list_add_tail(&new->node, item);
+	if (ui_initialized)
+		window_changed(filters_win);
+}
+
+void filters_init(void)
+{
+	struct iter iter;
+
+	filters_win = window_new(filters_get_prev, filters_get_next);
+	window_set_contents(filters_win, &filters_head);
+	window_changed(filters_win);
+
+	iter.data0 = &filters_head;
+	iter.data1 = NULL;
+	iter.data2 = NULL;
+	filters_searchable = searchable_new(NULL, &iter, &filters_search_ops);
+}
+
+void filters_exit(void)
+{
+	searchable_free(filters_searchable);
+	window_free(filters_win);
+}
+
+void filters_set_filter(const char *keyval)
+{
+	do_filters_set_filter(keyval);
+}
+
+struct expr *parse_filter(const char *val)
+{
+	struct expr *e = NULL;
+	struct filter_entry *f;
+
+	if (val) {
+		e = expr_parse(val);
+		if (e == NULL) {
+			error_msg("error parsing filter %s: %s", val, expr_error());
+			return NULL;
+		}
+	}
+
+	/* mark all unvisited so that we can check recursion */
+	list_for_each_entry(f, &filters_head, node)
+		f->visited = 0;
+
+	recursive_filter = NULL;
+	if (e && expr_check_leaves(&e, get_filter)) {
+		if (recursive_filter) {
+			error_msg("recursion detected in filter %s", recursive_filter);
+		} else {
+			error_msg("error parsing filter: %s", expr_error());
+		}
+		expr_free(e);
+		return NULL;
+	}
+	return e;
+}
+
+void filters_set_anonymous(const char *val)
+{
+	struct filter_entry *f;
+	struct expr *e = NULL;
+
+	if (val) {
+		e = parse_filter(val);
+		if (e == NULL)
+			return;
+	}
+
+	/* deactive all filters */
+	list_for_each_entry(f, &filters_head, node)
+		f->act_stat = FS_IGNORE;
+
+	lib_set_filter(e);
+
+	filters_win->changed = 1;
+}
+
+void filters_set_live(const char *val)
+{
+	lib_set_live_filter(val);
+	update_filterline();
+}

filters.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_FILTERS_H
+#define CMUS_FILTERS_H
+
+#include "list.h"
+#include "window.h"
+#include "search.h"
+
+/* factivate foo !bar
+ *
+ * foo: FS_YES
+ * bar: FS_NO
+ * baz: FS_IGNORE
+ */
+enum {
+	/* [ ] filter not selected */
+	FS_IGNORE,
+	/* [*] filter selected */
+	FS_YES,
+	/* [!] filter selected and inverted */
+	FS_NO,
+};
+
+struct filter_entry {
+	struct list_head node;
+
+	char *name;
+	char *filter;
+	unsigned visited : 1;
+
+	/* selected and activated status (FS_* enum) */
+	unsigned sel_stat : 2;
+	unsigned act_stat : 2;
+};
+
+static inline struct filter_entry *iter_to_filter_entry(struct iter *iter)
+{
+	return iter->data1;
+}
+
+extern struct window *filters_win;
+extern struct searchable *filters_searchable;
+extern struct list_head filters_head;
+
+void filters_init(void);
+void filters_exit(void);
+
+/* parse filter and expand sub filters */
+struct expr *parse_filter(const char *val);
+
+/* add filter to filter list (replaces old filter with same name)
+ *
+ * @keyval  "name=value" where value is filter
+ */
+void filters_set_filter(const char *keyval);
+
+/* set throwaway filter (not saved to the filter list)
+ *
+ * @val   filter or NULL to disable filtering
+ */
+void filters_set_anonymous(const char *val);
+
+/* set live filter (not saved to the filter list)
+ *
+ * @val   filter or NULL to disable filtering
+ */
+void filters_set_live(const char *val);
+
+void filters_activate_names(const char *str);
+
+void filters_activate(int win_activate);
+void filters_toggle_filter(void);
+void filters_delete_filter(void);
+
+#endif

format_print.c

@@ -0,0 +1,690 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "format_print.h"
+#include "expr.h"
+#include "glob.h"
+#include "utils.h"
+#include "options.h"
+#include "uchar.h"
+#include "xmalloc.h"
+#include "debug.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+static int width;
+static int align_left;
+static int pad;
+static bool width_is_exact;
+
+static GBUF(cond_buffer);
+static GBUF(l_str);
+static GBUF(m_str);
+static GBUF(r_str);
+static struct fp_len str_len = {0, 0, 0};
+static int *len = &str_len.llen;
+static struct gbuf* str = &l_str;
+
+static void stack_print(char *stack, int stack_len)
+{
+	int i = 0;
+
+	gbuf_grow(str, width ? width : stack_len);
+	char* buf = str->buffer + str->len;
+
+	if (width) {
+		if (align_left) {
+			while (i < width && stack_len)
+				buf[i++] = stack[--stack_len];
+			while (i < width)
+				buf[i++] = pad;
+		} else {
+			int pad_len;
+
+			if (stack_len > width)
+				stack_len = width;
+			pad_len = width - stack_len;
+			while (i < pad_len)
+				buf[i++] = pad;
+			while (i < width)
+				buf[i++] = stack[--stack_len];
+		}
+	} else {
+		while (stack_len)
+			buf[i++] = stack[--stack_len];
+	}
+	gbuf_used(str, i);
+	*len += i;
+}
+
+static void print_num(int num)
+{
+	char stack[20];
+	int i, p;
+
+	if (num < 0) {
+		if (width == 0)
+			width = 1;
+		for (i = 0; i < width; i++)
+			gbuf_add_ch(str, '?');
+		*len += width;
+		return;
+	}
+	p = 0;
+	do {
+		stack[p++] = num % 10 + '0';
+		num /= 10;
+	} while (num);
+
+	stack_print(stack, p);
+}
+
+#define DBL_MAX_LEN (20)
+
+static void print_double(double num)
+{
+	char stack[DBL_MAX_LEN], b[DBL_MAX_LEN];
+	int i, p = 0;
+
+	i = snprintf(b, DBL_MAX_LEN, "%g", num) - 1;
+	while (i >= 0) {
+		stack[p++] = b[i];
+		i--;
+	}
+	stack_print(stack, p);
+}
+
+/* print '{,-}{h:,}mm:ss' */
+static void print_time(int t)
+{
+	int h, m, s;
+	char stack[32];
+	int neg = 0;
+	int p = 0;
+
+	if (t < 0) {
+		neg = 1;
+		t *= -1;
+	}
+	h = t / 3600;
+	t = t % 3600;
+	m = t / 60;
+	s = t % 60;
+
+	/* put all chars to stack in reverse order ;) */
+	stack[p++] = s % 10 + '0';
+	stack[p++] = s / 10 + '0';
+	stack[p++] = ':';
+	stack[p++] = m % 10 + '0';
+	if (m / 10 || h || time_show_leading_zero)
+		stack[p++] = m / 10 + '0';
+	if (h) {
+		stack[p++] = ':';
+		do {
+			stack[p++] = h % 10 + '0';
+			h /= 10;
+		} while (h);
+	}
+	if (neg)
+		stack[p++] = '-';
+
+	stack_print(stack, p);
+}
+
+static void print_str(const char *src)
+{
+	int str_width = u_str_width(src);
+
+	if (width && width_is_exact) {
+		*len += width;
+		if (align_left) {
+			gbuf_add_ustr(str, src, &width);
+			gbuf_set(str, ' ', width);
+		} else {
+			int s = 0;
+			int ws_len = width - str_width;
+			if (ws_len < 0) {
+				int skip = -ws_len;
+				int clipped_mark_len = min_u(u_str_width(clipped_text_internal), width);
+				skip += clipped_mark_len;
+				gbuf_add_ustr(str, clipped_text_internal, &clipped_mark_len);
+				s = u_skip_chars(src, &skip, true);
+				/* pad if a wide character caused us to skip too much */
+				ws_len = -skip;
+
+			}
+			gbuf_set(str, ' ', ws_len);
+			gbuf_add_ustr(str, src + s, &width);
+		}
+	} else {
+		if (!width)
+			width = str_width;
+		*len += width;
+		gbuf_add_ustr(str, src, &width);
+		*len -= width;
+	}
+}
+
+static inline int strnequal(const char *a, const char *b, size_t b_len)
+{
+	return a && (strlen(a) == b_len) && (memcmp(a, b, b_len) == 0);
+}
+
+static const struct format_option *find_fopt(const struct format_option *fopts, const char *key)
+{
+	const struct format_option *fo;
+	char ch = strlen(key) == 1 ? *key : 0;
+	for (fo = fopts; fo->type != 0; fo++) {
+		if ((ch != 0 && fo->ch == ch) || strnequal(fo->str, key, strlen(key))) {
+			return fo;
+		}
+	}
+	return NULL;
+}
+
+static const char *str_val(const char *key, const struct format_option *fopts, char *buf)
+{
+	const struct format_option *fo;
+	const struct cmus_opt *opt;
+	const char *val = NULL;
+
+	fo = find_fopt(fopts, key);
+	if (fo && !fo->empty) {
+		if (fo->type == FO_STR)
+			val = fo->fo_str;
+	} else {
+		opt = option_find_silent(key);
+		if (opt) {
+			opt->get(opt->data, buf, OPTION_MAX_SIZE);
+			val = buf;
+		}
+	}
+	return val;
+}
+
+static int int_val(const char *key, const struct format_option *fopts, char *buf)
+{
+	const struct format_option *fo;
+	int val = -1;
+
+	fo = find_fopt(fopts, key);
+	if (fo && !fo->empty) {
+		if (fo->type == FO_INT)
+			val = fo->fo_int;
+	}
+	return val;
+}
+
+static int format_eval_cond(struct expr* expr, const struct format_option *fopts)
+{
+	if (!expr)
+		return -1;
+	enum expr_type type = expr->type;
+	const char *key;
+	const struct format_option *fo;
+	const struct cmus_opt *opt;
+	char buf[OPTION_MAX_SIZE];
+
+	if (expr->left) {
+		int left = format_eval_cond(expr->left, fopts);
+
+		if (type == EXPR_AND)
+			return left && format_eval_cond(expr->right, fopts);
+		if (type == EXPR_OR)
+			return left || format_eval_cond(expr->right, fopts);
+		/* EXPR_NOT */
+		return !left;
+	}
+
+	key = expr->key;
+	if (type == EXPR_STR) {
+		const char *val = str_val(key, fopts, buf);
+		int res;
+
+		if (!val)
+			val = "";
+		res = glob_match(&expr->estr.glob_head, val);
+		if (expr->estr.op == SOP_EQ)
+			return res;
+		return !res;
+	} else if (type == EXPR_INT) {
+		int val = int_val(key, fopts, buf);
+		int res = val - expr->eint.val;
+		if (val == -1 || expr->eint.val == -1) {
+			switch (expr->eid.op) {
+			case KOP_EQ:
+				return res == 0;
+			case KOP_NE:
+				return res != 0;
+			default:
+				return 0;
+			}
+		}
+		return expr_op_to_bool(res, expr->eint.op);
+	} else if (type == EXPR_ID) {
+		int a = 0, b = 0;
+		const char *sa, *sb;
+		int res = 0;
+		if ((sa = str_val(key, fopts, buf)) && (sb = str_val(expr->eid.key, fopts, buf))) {
+			res = strcmp(sa, sb);
+			return expr_op_to_bool(res, expr->eid.op);
+		} else {
+			a = int_val(key, fopts, buf);
+			b = int_val(expr->eid.key, fopts, buf);
+			res = a - b;
+			if (a == -1 || b == -1) {
+				switch (expr->eid.op) {
+				case KOP_EQ:
+					return res == 0;
+				case KOP_NE:
+					return res != 0;
+				default:
+					return 0;
+				}
+			}
+			return expr_op_to_bool(res, expr->eid.op);
+		}
+		return res;
+	}
+	if (strcmp(key, "stream") == 0) {
+		fo = find_fopt(fopts, "filename");
+		return fo && is_http_url(fo->fo_str);
+	}
+	fo = find_fopt(fopts, key);
+	if (fo)
+		return !fo->empty;
+	opt = option_find_silent(key);
+	if (opt) {
+		opt->get(opt->data, buf, OPTION_MAX_SIZE);
+		if (strcmp(buf, "false") != 0 && strlen(buf) != 0)
+			return 1;
+	}
+	return 0;
+}
+
+static struct expr *format_parse_cond(const char* format, int size)
+{
+	gbuf_clear(&cond_buffer);
+	gbuf_add_bytes(&cond_buffer, format, size);
+	return expr_parse_i(cond_buffer.buffer, "condition contains control characters", 0);
+}
+
+static uchar format_skip_cond_expr(const char *format, int *s)
+{
+	uchar r = 0;
+	while (format[*s]) {
+		uchar u = u_get_char(format, s);
+		if (u == '}' || u == '?') {
+			return u;
+		}
+		if (u != '%') {
+			continue;
+		}
+		u = u_get_char(format, s);
+		if (u == '%' || u == '?' || u == '!' || u == '=') {
+			continue;
+		}
+		if (u == '-') {
+			u = u_get_char(format, s);
+		}
+		if (u == '.')
+			u = u_get_char(format, s);
+		while (isdigit(u)) {
+			u = u_get_char(format, s);
+		}
+		if (u == '{') {
+			unsigned level = 1;
+			while (level) {
+				u = u_get_char(format, s);
+				if (u == 0)
+					return 0;
+				if (u == '}')
+					--level;
+				if (u != '%')
+					continue;
+				u = u_get_char(format, s);
+				if (u == '%' || u == '?' || u == '!' || u == '=')
+					continue;
+				if (u == '-')
+					u = u_get_char(format, s);
+				if (u == '.')
+					u = u_get_char(format, s);
+				while (isdigit(u))
+					u = u_get_char(format, s);
+				if (u == 0)
+					return 0;
+				if (u == '{')
+					++level;
+			}
+		}
+	}
+	return r;
+}
+
+static int format_read_cond(const char *format, int *s, int *a, int *b, int *end)
+{
+	uchar t = format_skip_cond_expr(format, s);
+	if (t != '?')
+		return 1;
+	*a = *s - 1;
+	t = format_skip_cond_expr(format, s);
+	if (t == 0)
+		return 1;
+	if (t == '?') {
+		*b = *s - 1;
+		t = format_skip_cond_expr(format, s);
+		if (t != '}')
+			return 1;
+	}
+	*end = *s - 1;
+	return 0;
+}
+
+static void format_parse(int str_width, const char *format, const struct format_option *fopts, int f_size);
+
+static void format_parse_if(int str_width, const char *format, const struct format_option *fopts, int *s)
+{
+	int cond_pos = *s, then_pos = -1, else_pos = -1, end_pos = -1, cond_res = -1;
+	BUG_ON(format_read_cond(format, s, &then_pos, &else_pos, &end_pos) != 0);
+
+	struct expr *cond = format_parse_cond(format + cond_pos, then_pos - cond_pos);
+	cond_res = format_eval_cond(cond, fopts);
+	if (cond)
+		expr_free(cond);
+
+	BUG_ON(cond_res < 0);
+	if (cond_res) {
+		format_parse(str_width, format + then_pos + 1, fopts,
+				(else_pos > 0 ? else_pos : end_pos) - then_pos - 1);
+	} else if (else_pos > 0) {
+		format_parse(str_width, format + else_pos + 1, fopts, end_pos - else_pos - 1);
+	}
+
+	*s = end_pos + 1;
+}
+
+static void format_parse(int str_width, const char *format, const struct format_option *fopts, int f_size)
+{
+	int s = 0;
+
+	while (s < f_size) {
+		const struct format_option *fo;
+		int long_len = 0;
+		const char *long_begin = NULL;
+		uchar u;
+
+		u = u_get_char(format, &s);
+		if (u != '%') {
+			gbuf_add_uchar(str, u);
+			(*len) += u_char_width(u);
+			continue;
+		}
+		u = u_get_char(format, &s);
+		if (u == '%' || u == '?') {
+			gbuf_add_ch(str, u);
+			++(*len);
+			continue;
+		}
+		if (u == '!') {
+			/* middle (priority) text starts */
+			str = &m_str;
+			len = &str_len.mlen;
+			continue;
+		}
+		if (u == '=') {
+			/* right aligned text starts */
+			str = &r_str;
+			len = &str_len.rlen;
+			continue;
+		}
+		align_left = 0;
+		if (u == '-') {
+			align_left = 1;
+			u = u_get_char(format, &s);
+		}
+		width_is_exact = true;
+		if (u == '.') {
+			width_is_exact = false;
+			u = u_get_char(format, &s);
+		}
+		pad = ' ';
+		if (u == '0') {
+			pad = '0';
+			u = u_get_char(format, &s);
+		}
+		width = 0;
+		while (isdigit(u)) {
+			/* minimum length of this field */
+			width *= 10;
+			width += u - '0';
+			u = u_get_char(format, &s);
+		}
+		if (u == '%') {
+			width = (width * str_width) / 100.0 + 0.5;
+			u = u_get_char(format, &s);
+		}
+		if (u == '{') {
+			long_begin = format + s;
+			if (*long_begin == '?') {
+				++s;
+				format_parse_if(str_width, format, fopts, &s);
+				BUG_ON(s > f_size);
+				continue;
+			}
+			while (1) {
+				BUG_ON(s >= f_size);
+				u = u_get_char(format, &s);
+				if (u == '}')
+					break;
+				long_len++;
+			}
+		}
+		for (fo = fopts; ; fo++) {
+			BUG_ON(fo->type == 0);
+			if (long_len ? strnequal(fo->str, long_begin, long_len)
+				     : (fo->ch == u)) {
+
+				int type = fo->type;
+
+				if (fo->empty) {
+					gbuf_set(str, ' ', width);
+					*len += width;
+				} else if (type == FO_STR) {
+					print_str(fo->fo_str);
+				} else if (type == FO_INT) {
+					print_num(fo->fo_int);
+				} else if (type == FO_TIME) {
+					print_time(fo->fo_time);
+				} else if (type == FO_DOUBLE) {
+					print_double(fo->fo_double);
+				}
+				break;
+			}
+		}
+	}
+}
+
+static void format_read(int str_width, const char *format, const struct format_option *fopts)
+{
+	gbuf_clear(&l_str);
+	gbuf_clear(&m_str);
+	gbuf_clear(&r_str);
+	str_len.llen = 0;
+	str_len.mlen = 0;
+	str_len.rlen = 0;
+	str = &l_str;
+	len = &str_len.llen;
+	format_parse(str_width, format, fopts, strlen(format));
+}
+
+static void format_write(struct gbuf *buf, int str_width)
+{
+	if (str_width == 0)
+		str_width = str_len.llen + str_len.mlen + str_len.rlen + (str_len.rlen > 0);
+
+	/* NOTE: any invalid UTF-8 bytes have already been converted to <xx>
+	 *       (ASCII) where x is hex digit
+	 */
+
+	if (str_len.llen + str_len.mlen + str_len.rlen <= str_width) {
+		/* all fit */
+		int ws_len = str_width - (str_len.llen + str_len.mlen + str_len.rlen);
+
+		gbuf_add_bytes(buf, l_str.buffer, l_str.len);
+		gbuf_add_bytes(buf, m_str.buffer, m_str.len);
+		gbuf_set(buf, ' ', ws_len);
+		gbuf_add_bytes(buf, r_str.buffer, r_str.len);
+	} else {
+		/* keep first character since it's almost always padding */
+		int clipped_mark_len = min_u(u_str_width(clipped_text_internal) + 1, str_width);
+		int r_space = str_width - clipped_mark_len;
+		int r_width = min_i(r_space, str_len.rlen);
+		int m_space = r_space - r_width;
+		int m_width = min_i(m_space, str_len.mlen);
+		int l_space = m_space - m_width;
+		int l_width = l_space + clipped_mark_len;
+		int r_idx = 0, ws_pad = 0;
+
+		gbuf_add_ustr(buf, l_str.buffer, &l_width);
+		ws_pad += l_width;
+		gbuf_add_ustr(buf, m_str.buffer, &m_width);
+		ws_pad += m_width;
+
+		int r_skip = str_len.rlen - r_width;
+		r_idx = u_skip_chars(r_str.buffer, &r_skip, true);
+		ws_pad += -r_skip;
+		gbuf_set(buf, ' ', ws_pad);
+		gbuf_add_bytes(buf, r_str.buffer + r_idx, r_str.len - r_idx);
+	}
+}
+
+struct fp_len format_print(struct gbuf *buf, int str_width, const char *format, const struct format_option *fopts)
+{
+	format_read(str_width, format, fopts);
+
+#if DEBUG > 1
+	if (str_len.llen > 0) {
+		int ul = u_str_width(l_str.buffer);
+		if (ul != str_len.llen)
+			d_print("L %d != %d: size=%zu '%s'\n", ul, str_len.llen, l_str.len, l_str.buffer);
+	}
+
+	if (str_len.rlen > 0) {
+		int ul = u_str_width(r_str.buffer);
+		if (ul != str_len.rlen)
+			d_print("R %d != %d: size=%zu '%s'\n", ul, str_len.rlen, r_str.len, r_str.buffer);
+	}
+#endif
+
+	format_write(buf, str_width);
+	return str_len;
+}
+
+static int format_valid_sub(const char *format, const struct format_option *fopts, int f_size);
+
+static int format_valid_if(const char *format, const struct format_option *fopts, int *s)
+{
+	int cond_pos = *s, then_pos = -1, else_pos = -1, end_pos = -1;
+	if (format_read_cond(format, s, &then_pos, &else_pos, &end_pos) != 0)
+		return 0;
+
+	struct expr *cond = format_parse_cond(format + cond_pos, then_pos - cond_pos);
+	if (cond == NULL)
+		return 0;
+	expr_free(cond);
+
+	if (!format_valid_sub(format + then_pos + 1, fopts,
+				(else_pos > 0 ? else_pos : end_pos) - then_pos - 1))
+		return 0;
+	if (else_pos > 0)
+		if (!format_valid_sub(format + else_pos + 1, fopts, end_pos - else_pos - 1))
+			return 0;
+
+	*s = end_pos + 1;
+	return 1;
+}
+
+static int format_valid_sub(const char *format, const struct format_option *fopts, int f_size)
+{
+	int s = 0;
+
+	while (s < f_size) {
+		uchar u;
+
+		u = u_get_char(format, &s);
+		if (u == '%') {
+			int pad_zero = 0, long_len = 0;
+			const struct format_option *fo;
+			const char *long_begin = NULL;
+
+			u = u_get_char(format, &s);
+			if (u == '%' || u == '?' || u == '!' || u == '=')
+				continue;
+			if (u == '-')
+				u = u_get_char(format, &s);
+			if (u == '.')
+				u = u_get_char(format, &s);
+			if (u == '0') {
+				pad_zero = 1;
+				u = u_get_char(format, &s);
+			}
+			while (isdigit(u))
+				u = u_get_char(format, &s);
+			if (u == '%')
+				u = u_get_char(format, &s);
+			if (u == '{') {
+				long_begin = format + s;
+				if (*long_begin == '?') {
+					++s;
+					if (!format_valid_if(format, fopts, &s))
+						return 0;
+					if (s > f_size)
+						return 0;
+					continue;
+				}
+
+				while (1) {
+					if (s >= f_size)
+						return 0;
+					u = u_get_char(format, &s);
+					if (u == '}')
+						break;
+					long_len++;
+				}
+			}
+			for (fo = fopts; fo->type; fo++) {
+				if (long_len ? strnequal(fo->str, long_begin, long_len)
+					     : (fo->ch == u)) {
+					if (pad_zero && !fo->pad_zero)
+						return 0;
+					break;
+				}
+			}
+			if (! fo->type)
+				return 0;
+		}
+	}
+	return 1;
+}
+
+int format_valid(const char *format, const struct format_option *fopts)
+{
+	return format_valid_sub(format, fopts, strlen(format));
+}

format_print.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_FORMAT_PRINT_H
+#define CMUS_FORMAT_PRINT_H
+
+#include "gbuf.h"
+
+struct format_option {
+	union {
+		/* NULL is treated like "" */
+		const char *fo_str;
+		int fo_int;
+		/* [h:]mm:ss. can be negative */
+		int fo_time;
+		double fo_double;
+	};
+	/* set to 1 if you want to disable printing */
+	unsigned int empty : 1;
+	/* set to 1 if zero padding is allowed */
+	unsigned int pad_zero : 1;
+	enum { FO_STR = 1, FO_INT, FO_TIME, FO_DOUBLE } type;
+	char ch;
+	const char *str;
+};
+
+/* gcc < 4.6 and icc < 12.0 can't properly initialize anonymous unions */
+#if (defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6))) || \
+	(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1200)
+#define UNION_INIT(f, v) { .f = v }
+#else
+#define UNION_INIT(f, v) .f = v
+#endif
+
+#define DEF_FO_STR(c, s, z)    { UNION_INIT(fo_str,  ""),   .type = FO_STR,    .pad_zero = z, .ch = c, .str = s }
+#define DEF_FO_INT(c, s, z)    { UNION_INIT(fo_int,  0),    .type = FO_INT,    .pad_zero = z, .ch = c, .str = s }
+#define DEF_FO_TIME(c, s, z)   { UNION_INIT(fo_time, 0),    .type = FO_TIME,   .pad_zero = z, .ch = c, .str = s }
+#define DEF_FO_DOUBLE(c, s, z) { UNION_INIT(fo_double, 0.), .type = FO_DOUBLE, .pad_zero = z, .ch = c, .str = s }
+#define DEF_FO_END             { .type = 0 }
+
+struct fp_len {
+	int llen;
+	int mlen;
+	int rlen;
+};
+
+struct fp_len format_print(struct gbuf *buf, int str_width, const char *format, const struct format_option *fopts);
+int format_valid(const char *format, const struct format_option *fopts);
+
+#endif

gbuf.c

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2008 Timo Hirvonen
+ *
+ * This code is largely based on strbuf in the GIT version control system.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "gbuf.h"
+#include "options.h"
+#include "utils.h"
+#include "xmalloc.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+char gbuf_empty_buffer[1];
+
+static inline void gbuf_init(struct gbuf *buf)
+{
+	buf->buffer = gbuf_empty_buffer;
+	buf->alloc = 0;
+	buf->len = 0;
+}
+
+void gbuf_grow(struct gbuf *buf, size_t more)
+{
+	size_t align = 64 - 1;
+	size_t alloc = (buf->len + more + 1 + align) & ~align;
+
+	if (alloc > buf->alloc) {
+		if (!buf->alloc)
+			buf->buffer = NULL;
+		buf->alloc = alloc;
+		buf->buffer = xrealloc(buf->buffer, buf->alloc);
+		// gbuf is not NUL terminated if this was first alloc
+		buf->buffer[buf->len] = 0;
+	}
+}
+
+void gbuf_used(struct gbuf *buf, size_t used)
+{
+	buf->len += used;
+	buf->buffer[buf->len] = 0;
+}
+
+void gbuf_free(struct gbuf *buf)
+{
+	if (buf->alloc)
+		free(buf->buffer);
+	gbuf_init(buf);
+}
+
+void gbuf_add_ch(struct gbuf *buf, char ch)
+{
+	gbuf_grow(buf, 1);
+	buf->buffer[buf->len] = ch;
+	gbuf_used(buf, 1);
+}
+
+void gbuf_add_uchar(struct gbuf *buf, uchar u)
+{
+	size_t uchar_len = 0;
+	gbuf_grow(buf, 4);
+	u_set_char(buf->buffer + buf->len, &uchar_len, u);
+	gbuf_used(buf, uchar_len);
+}
+
+void gbuf_add_bytes(struct gbuf *buf, const void *data, size_t len)
+{
+	gbuf_grow(buf, len);
+	memcpy(buf->buffer + buf->len, data, len);
+	gbuf_used(buf, len);
+}
+
+void gbuf_add_str(struct gbuf *buf, const char *str)
+{
+	int len = strlen(str);
+
+	if (!len)
+		return;
+	gbuf_grow(buf, len);
+	memcpy(buf->buffer + buf->len, str, len);
+	gbuf_used(buf, len);
+}
+
+static int gbuf_mark_clipped_text(struct gbuf *buf)
+{
+	int buf_width = u_str_width(buf->buffer);
+	int clipped_mark_len = min_u(u_str_width(clipped_text_internal), buf_width);
+	int skip = buf_width - clipped_mark_len;
+	buf->len = u_skip_chars(buf->buffer, &skip, false);
+	gbuf_grow(buf, strlen(clipped_text_internal));
+	gbuf_used(buf, u_copy_chars(buf->buffer + buf->len, clipped_text_internal, &clipped_mark_len));
+	return skip;
+}
+
+void gbuf_add_ustr(struct gbuf *buf, const char *src, int *width)
+{
+	int src_bytes = u_str_print_size(src) - 1;
+	gbuf_grow(buf, src_bytes);
+	size_t copy_bytes = u_copy_chars(buf->buffer + buf->len, src, width);
+	gbuf_used(buf, copy_bytes);
+	if (copy_bytes != src_bytes) {
+		gbuf_set(buf, ' ', *width);
+		*width = gbuf_mark_clipped_text(buf);
+	}
+}
+
+void gbuf_addf(struct gbuf *buf, const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	gbuf_vaddf(buf, fmt, ap);
+	va_end(ap);
+}
+
+void gbuf_vaddf(struct gbuf *buf, const char *fmt, va_list ap)
+{
+	va_list ap2;
+	int slen;
+
+	va_copy(ap2, ap);
+	slen = vsnprintf(buf->buffer + buf->len, buf->alloc - buf->len, fmt, ap);
+
+	if (slen > gbuf_avail(buf)) {
+		gbuf_grow(buf, slen);
+		slen = vsnprintf(buf->buffer + buf->len, buf->alloc - buf->len, fmt, ap2);
+	}
+	va_end(ap2);
+	gbuf_used(buf, slen);
+}
+
+void gbuf_set(struct gbuf *buf, int c, size_t count)
+{
+	gbuf_grow(buf, count);
+	memset(buf->buffer + buf->len, c, count);
+	gbuf_used(buf, count);
+}
+
+char *gbuf_steal(struct gbuf *buf)
+{
+	char *b = buf->buffer;
+	if (!buf->alloc)
+		b = xnew0(char, 1);
+	gbuf_init(buf);
+	return b;
+}

gbuf.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2008 Timo Hirvonen
+ *
+ * This code is largely based on strbuf in the GIT version control system.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_GBUF_H
+#define CMUS_GBUF_H
+
+#include "compiler.h"
+#include "uchar.h"
+
+#include <stddef.h> /* size_t */
+#include <stdarg.h>
+
+struct gbuf {
+	char *buffer;
+	size_t alloc;
+	size_t len;
+};
+
+extern char gbuf_empty_buffer[];
+
+#define GBUF(name) struct gbuf name = { gbuf_empty_buffer, 0, 0 }
+
+static inline void gbuf_clear(struct gbuf *buf)
+{
+	buf->len = 0;
+	buf->buffer[0] = 0;
+}
+
+static inline size_t gbuf_avail(struct gbuf *buf)
+{
+	if (buf->alloc)
+		return buf->alloc - buf->len - 1;
+	return 0;
+}
+
+void gbuf_grow(struct gbuf *buf, size_t more);
+void gbuf_used(struct gbuf *buf, size_t used);
+void gbuf_free(struct gbuf *buf);
+void gbuf_add_ch(struct gbuf *buf, char ch);
+void gbuf_add_uchar(struct gbuf *buf, uchar u);
+void gbuf_add_bytes(struct gbuf *buf, const void *data, size_t len);
+void gbuf_add_str(struct gbuf *buf, const char *str);
+void gbuf_add_ustr(struct gbuf *buf, const char *src, int *width);
+void gbuf_addf(struct gbuf *buf, const char *fmt, ...) CMUS_FORMAT(2, 3);
+void gbuf_vaddf(struct gbuf *buf, const char *fmt, va_list ap);
+void gbuf_set(struct gbuf *buf, int c, size_t count);
+char *gbuf_steal(struct gbuf *buf);
+
+#endif

glob.c

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "glob.h"
+#include "uchar.h"
+#include "list.h"
+#include "xmalloc.h"
+#include "debug.h"
+
+#include <string.h>
+
+struct glob_item {
+	struct list_head node;
+	enum {
+		GLOB_STAR,
+		GLOB_QMARK,
+		GLOB_TEXT
+	} type;
+	char text[];
+};
+
+/* simplification:
+ *
+ *   ??*? => ???*
+ *   *?*  => ?*
+ *   *?   => ?*
+ *   ...
+ */
+static void simplify(struct list_head *head)
+{
+	struct list_head *item;
+
+	item = head->next;
+	while (item != head) {
+		struct list_head *i, *next;
+		int qcount = 0;
+		int scount = 0;
+
+		i = item;
+		do {
+			struct glob_item *gi;
+
+			gi = container_of(i, struct glob_item, node);
+			if (gi->type == GLOB_STAR) {
+				scount++;
+			} else if (gi->type == GLOB_QMARK) {
+				qcount++;
+			} else {
+				i = i->next;
+				break;
+			}
+			i = i->next;
+		} while (i != head);
+
+		next = i;
+
+		if (scount) {
+			/* move all qmarks to front and
+			 * if there are >1 stars remove all but the last */
+			struct list_head *insert_after = item->prev;
+
+			i = item;
+			while (qcount) {
+				struct glob_item *gi;
+
+				gi = container_of(i, struct glob_item, node);
+				i = i->next;
+				if (gi->type == GLOB_QMARK) {
+					list_del(&gi->node);
+					list_add(&gi->node, insert_after);
+					qcount--;
+				}
+			}
+
+			i = item;
+			while (scount > 1) {
+				struct glob_item *gi;
+
+				gi = container_of(i, struct glob_item, node);
+				i = i->next;
+				if (gi->type == GLOB_STAR) {
+					list_del(&gi->node);
+					free(gi);
+					scount--;
+				}
+			}
+		}
+
+		item = next;
+	}
+}
+
+void glob_compile(struct list_head *head, const char *pattern)
+{
+	int i = 0;
+
+	list_init(head);
+	while (pattern[i]) {
+		struct glob_item *item;
+
+		if (pattern[i] == '*') {
+			item = xnew(struct glob_item, 1);
+			item->type = GLOB_STAR;
+			i++;
+		} else if (pattern[i] == '?') {
+			item = xnew(struct glob_item, 1);
+			item->type = GLOB_QMARK;
+			i++;
+		} else {
+			int start, len, j;
+			char *str;
+
+			start = i;
+			len = 0;
+			while (pattern[i]) {
+				if (pattern[i] == '\\') {
+					i++;
+					len++;
+					if (pattern[i])
+						i++;
+				} else if (pattern[i] == '*') {
+					break;
+				} else if (pattern[i] == '?') {
+					break;
+				} else {
+					i++;
+					len++;
+				}
+			}
+
+			item = xmalloc(sizeof(struct glob_item) + len + 1);
+			item->type = GLOB_TEXT;
+
+			str = item->text;
+			i = start;
+			j = 0;
+			while (j < len) {
+				if (pattern[i] == '\\') {
+					i++;
+					if (pattern[i]) {
+						str[j++] = pattern[i++];
+					} else {
+						str[j++] = '\\';
+					}
+				} else {
+					str[j++] = pattern[i++];
+				}
+			}
+			str[j] = 0;
+		}
+		list_add_tail(&item->node, head);
+	}
+	simplify(head);
+}
+
+void glob_free(struct list_head *head)
+{
+	struct list_head *item = head->next;
+
+	while (item != head) {
+		struct glob_item *gi;
+		struct list_head *next = item->next;
+
+		gi = container_of(item, struct glob_item, node);
+		free(gi);
+		item = next;
+	}
+}
+
+static int do_glob_match(struct list_head *head, struct list_head *first, const char *text)
+{
+	struct list_head *item = first;
+
+	while (item != head) {
+		struct glob_item *gitem;
+
+		gitem = container_of(item, struct glob_item, node);
+		if (gitem->type == GLOB_TEXT) {
+			int len = u_strlen(gitem->text);
+
+			if (!u_strncase_equal_base(gitem->text, text, len))
+				return 0;
+			text += strlen(gitem->text);
+		} else if (gitem->type == GLOB_QMARK) {
+			uchar u;
+			int idx = 0;
+
+			u = u_get_char(text, &idx);
+			if (u == 0)
+				return 0;
+			text += idx;
+		} else if (gitem->type == GLOB_STAR) {
+			/* after star there MUST be normal text (or nothing),
+			 * question marks have been moved before this star and
+			 * other stars have been stripped (see simplify)
+			 */
+			struct list_head *next;
+			struct glob_item *next_gi;
+			const char *t;
+			int tlen;
+
+			next = item->next;
+			if (next == head) {
+				/* this star was the last item => matched */
+				return 1;
+			}
+			next_gi = container_of(next, struct glob_item, node);
+			BUG_ON(next_gi->type != GLOB_TEXT);
+			t = next_gi->text;
+			tlen = strlen(t);
+			while (1) {
+				const char *pos;
+
+				pos = u_strcasestr_base(text, t);
+				if (pos == NULL)
+					return 0;
+				if (do_glob_match(head, next->next, pos + tlen))
+					return 1;
+				text = pos + 1;
+			}
+		}
+		item = item->next;
+	}
+	return text[0] == 0;
+}
+
+int glob_match(struct list_head *head, const char *text)
+{
+	return do_glob_match(head, head->next, text);
+}

glob.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_GLOB_H
+#define CMUS_GLOB_H
+
+#include "list.h"
+
+void glob_compile(struct list_head *head, const char *pattern);
+void glob_free(struct list_head *head);
+int glob_match(struct list_head *head, const char *text);
+
+#endif

help.c

@@ -0,0 +1,327 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 <ft@bewatermyfriend.org>
+ *
+ * heavily based on filters.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "help.h"
+#include "window.h"
+#include "search.h"
+#include "misc.h"
+#include "xmalloc.h"
+#include "keys.h"
+#include "command_mode.h"
+#include "ui_curses.h"
+#include "options.h"
+#include "cmdline.h"
+
+#include <stdio.h>
+
+struct window *help_win;
+struct searchable *help_searchable;
+
+static LIST_HEAD(help_head);
+static struct list_head *bound_head;
+static struct list_head *bound_tail;
+static struct list_head *unbound_head;
+static struct list_head *unbound_tail;
+
+static inline void help_entry_to_iter(struct help_entry *e, struct iter *iter)
+{
+	iter->data0 = &help_head;
+	iter->data1 = e;
+	iter->data2 = NULL;
+}
+
+static GENERIC_ITER_PREV(help_get_prev, struct help_entry, node)
+static GENERIC_ITER_NEXT(help_get_next, struct help_entry, node)
+
+static int help_search_get_current(void *data, struct iter *iter, enum search_direction dir)
+{
+	return window_get_sel(help_win, iter);
+}
+
+static int help_search_matches(void *data, struct iter *iter, const char *text)
+{
+	int matched = 0;
+	char **words = get_words(text);
+
+	if (words[0] != NULL) {
+		struct help_entry *ent;
+		int i;
+
+		ent = iter_to_help_entry(iter);
+		for (i = 0; ; i++) {
+			if (words[i] == NULL) {
+				window_set_sel(help_win, iter);
+				matched = 1;
+				break;
+			}
+			if (ent->type == HE_TEXT) {
+				if (!u_strcasestr(ent->text, words[i]))
+					break;
+			} else if (ent->type == HE_BOUND) {
+				if (!u_strcasestr(ent->binding->cmd, words[i]) &&
+					!u_strcasestr(ent->binding->key->name, words[i]))
+					break;
+			} else if (ent->type == HE_UNBOUND) {
+				if (!u_strcasestr(ent->command->name, words[i]))
+					break;
+			} else if (ent->type == HE_OPTION) {
+				if (!u_strcasestr(ent->option->name, words[i]))
+					break;
+			}
+		}
+	}
+	free_str_array(words);
+	return matched;
+}
+
+static const struct searchable_ops help_search_ops = {
+	.get_prev = help_get_prev,
+	.get_next = help_get_next,
+	.get_current = help_search_get_current,
+	.matches = help_search_matches
+};
+
+static void help_add_text(const char *s)
+{
+	struct help_entry *ent;
+	ent = xnew(struct help_entry, 1);
+	ent->type = HE_TEXT;
+	ent->text = s;
+	list_add_tail(&ent->node, &help_head);
+}
+
+static void help_add_defaults(void)
+{
+	struct cmus_opt *opt;
+
+	help_add_text("Keybindings");
+	help_add_text("-----------");
+	bound_head = help_head.prev;
+	help_add_text("");
+	help_add_text("Unbound Commands");
+	help_add_text("----------------");
+	unbound_head = help_head.prev;
+	help_add_text("");
+	help_add_text("Options");
+	help_add_text("-------");
+
+	list_for_each_entry(opt, &option_head, node) {
+		struct help_entry *ent = xnew(struct help_entry, 1);
+
+		ent->type = HE_OPTION;
+		ent->option = opt;
+		list_add_tail(&ent->node, &help_head);
+	}
+
+	bound_tail = bound_head->next;
+	unbound_tail = unbound_head->next;
+}
+
+void help_remove_unbound(struct command *cmd)
+{
+	struct help_entry *ent;
+	struct iter i;
+	list_for_each_entry(ent, &help_head, node) {
+		if (ent->type != HE_UNBOUND)
+			continue;
+		if (ent->command == cmd) {
+			help_entry_to_iter(ent, &i);
+			window_row_vanishes(help_win, &i);
+			list_del(&ent->node);
+			free(ent);
+			return;
+		}
+	}
+}
+
+static void list_add_sorted(struct list_head *new, struct list_head *head,
+		struct list_head *tail,
+		int (*cmp)(struct list_head *, struct list_head *))
+{
+	struct list_head *item = tail->prev;
+
+	while (item != head) {
+		if (cmp(new, item) >= 0)
+			break;
+		item = item->prev;
+	}
+	/* add after item */
+	list_add(new, item);
+}
+
+static int bound_cmp(struct list_head *ai, struct list_head *bi)
+{
+	struct help_entry *a = container_of(ai, struct help_entry, node);
+	struct help_entry *b = container_of(bi, struct help_entry, node);
+	int ret = a->binding->ctx - b->binding->ctx;
+
+	if (!ret)
+		ret = strcmp(a->binding->key->name, b->binding->key->name);
+	return ret;
+}
+
+static int unbound_cmp(struct list_head *ai, struct list_head *bi)
+{
+	struct help_entry *a = container_of(ai, struct help_entry, node);
+	struct help_entry *b = container_of(bi, struct help_entry, node);
+
+	return strcmp(a->command->name, b->command->name);
+}
+
+void help_add_unbound(struct command *cmd)
+{
+	struct help_entry *ent;
+
+	ent = xnew(struct help_entry, 1);
+	ent->type = HE_UNBOUND;
+	ent->command = cmd;
+	list_add_sorted(&ent->node, unbound_head, unbound_tail, unbound_cmp);
+}
+
+void help_add_all_unbound(void)
+{
+	int i;
+	for (i = 0; commands[i].name; ++i)
+		if (!commands[i].bc)
+			help_add_unbound(&commands[i]);
+}
+
+void help_select(void)
+{
+	struct iter sel;
+	struct help_entry *ent;
+	char buf[OPTION_MAX_SIZE];
+
+	if (!window_get_sel(help_win, &sel))
+		return;
+
+	ent = iter_to_help_entry(&sel);
+	switch (ent->type) {
+	case HE_BOUND:
+		snprintf(buf, sizeof(buf), "bind -f %s %s %s",
+				key_context_names[ent->binding->ctx],
+				ent->binding->key->name,
+				ent->binding->cmd);
+		cmdline_set_text(buf);
+		enter_command_mode();
+		break;
+	case HE_UNBOUND:
+		snprintf(buf, sizeof(buf), "bind common <key> %s",
+				ent->command->name);
+		cmdline_set_text(buf);
+		enter_command_mode();
+		break;
+	case HE_OPTION:
+		snprintf(buf, sizeof(buf), "set %s=", ent->option->name);
+		size_t len = strlen(buf);
+		ent->option->get(ent->option->data, buf + len, sizeof(buf) - len);
+		cmdline_set_text(buf);
+		enter_command_mode();
+		break;
+	default:
+		break;
+	}
+}
+
+void help_toggle(void)
+{
+	struct iter sel;
+	struct help_entry *ent;
+
+	if (!window_get_sel(help_win, &sel))
+		return;
+
+	ent = iter_to_help_entry(&sel);
+	switch (ent->type) {
+	case HE_OPTION:
+		if (ent->option->toggle) {
+			ent->option->toggle(ent->option->data);
+			help_win->changed = 1;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+void help_remove(void)
+{
+	struct iter sel;
+	struct help_entry *ent;
+
+	if (!window_get_sel(help_win, &sel))
+		return;
+
+	ent = iter_to_help_entry(&sel);
+	switch (ent->type) {
+	case HE_BOUND:
+		if (yes_no_query("Remove selected binding? [y/N]") == UI_QUERY_ANSWER_YES)
+			key_unbind(key_context_names[ent->binding->ctx],
+					ent->binding->key->name, 0);
+		break;
+	default:
+		break;
+	}
+}
+
+void help_add_bound(const struct binding *bind)
+{
+	struct help_entry *ent;
+	ent = xnew(struct help_entry, 1);
+	ent->type = HE_BOUND;
+	ent->binding = bind;
+	list_add_sorted(&ent->node, bound_head, bound_tail, bound_cmp);
+}
+
+void help_remove_bound(const struct binding *bind)
+{
+	struct help_entry *ent;
+	struct iter i;
+	list_for_each_entry(ent, &help_head, node) {
+		if (ent->binding == bind) {
+			help_entry_to_iter(ent, &i);
+			window_row_vanishes(help_win, &i);
+			list_del(&ent->node);
+			free(ent);
+			return;
+		}
+	}
+}
+
+void help_init(void)
+{
+	struct iter iter;
+
+	help_win = window_new(help_get_prev, help_get_next);
+	window_set_contents(help_win, &help_head);
+	window_changed(help_win);
+	help_add_defaults();
+
+	iter.data0 = &help_head;
+	iter.data1 = NULL;
+	iter.data2 = NULL;
+	help_searchable = searchable_new(NULL, &iter, &help_search_ops);
+}
+
+void help_exit(void)
+{
+	searchable_free(help_searchable);
+	window_free(help_win);
+}

help.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 <ft@bewatermyfriend.org>
+ *
+ * heavily based on filters.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_HELP_H
+#define CMUS_HELP_H
+
+#include "list.h"
+#include "window.h"
+#include "search.h"
+#include "keys.h"
+
+struct help_entry {
+	struct list_head node;
+	enum {
+		HE_TEXT,		/* text entries 	*/
+		HE_BOUND,		/* bound keys		*/
+		HE_UNBOUND,		/* unbound commands	*/
+		HE_OPTION,
+	} type;
+	union {
+		const char *text;			/* HE_TEXT	*/
+		const struct binding *binding;		/* HE_BOUND	*/
+		const struct command *command;		/* HE_UNBOUND	*/
+		const struct cmus_opt *option;
+	};
+};
+
+static inline struct help_entry *iter_to_help_entry(struct iter *iter)
+{
+	return iter->data1;
+}
+
+extern struct window *help_win;
+extern struct searchable *help_searchable;
+
+void help_select(void);
+void help_toggle(void);
+void help_remove(void);
+
+void help_add_bound(const struct binding *bind);
+void help_remove_bound(const struct binding *bind);
+void help_remove_unbound(struct command *cmd);
+void help_add_unbound(struct command *cmd);
+void help_add_all_unbound(void);
+
+void help_init(void);
+void help_exit(void);
+
+#endif /* HELP_H */

history.c

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "history.h"
+#include "xmalloc.h"
+#include "file.h"
+#include "uchar.h"
+#include "list.h"
+#include "prog.h"
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+
+struct history_entry {
+	struct list_head node;
+	char *text;
+};
+
+static struct history_entry *history_entry_new(const char *text)
+{
+	struct history_entry *new;
+	new = xnew(struct history_entry, 1);
+	new->text = xstrdup(text);
+	return new;
+}
+
+static void history_entry_free(struct history_entry *history)
+{
+	free(history->text);
+	free(history);
+}
+
+void history_free(struct history *history)
+{
+	struct list_head *item, *temp;
+	list_for_each_safe(item, temp, &history->head) {
+		struct history_entry *history_entry;
+		history_entry = list_entry(item, struct history_entry, node);
+		history_entry_free(history_entry);
+	}
+}
+
+static int history_add_tail(void *data, const char *line)
+{
+	struct history *history = data;
+
+	if (history->lines < history->max_lines) {
+		struct history_entry *new;
+
+		new = history_entry_new(line);
+		list_add_tail(&new->node, &history->head);
+		history->lines++;
+	}
+	return 0;
+}
+
+void history_load(struct history *history, char *filename, int max_lines)
+{
+	list_init(&history->head);
+	history->max_lines = max_lines;
+	history->lines = 0;
+	history->search_pos = NULL;
+	history->filename = filename;
+	file_for_each_line(filename, history_add_tail, history);
+}
+
+void history_save(struct history *history)
+{
+	char filename_tmp[512];
+	struct list_head *item;
+	int fd;
+	ssize_t rc;
+
+	snprintf(filename_tmp, sizeof(filename_tmp), "%s.tmp", history->filename);
+	fd = open(filename_tmp, O_CREAT | O_WRONLY | O_TRUNC, 0666);
+	if (fd == -1)
+		return;
+	list_for_each(item, &history->head) {
+		struct history_entry *history_entry;
+		const char nl = '\n';
+
+		history_entry = list_entry(item, struct history_entry, node);
+
+		rc = write(fd, history_entry->text, strlen(history_entry->text));
+		if (rc == -1)
+			goto out;
+
+		rc = write(fd, &nl, 1);
+		if (rc == -1)
+			goto out;
+	}
+out:
+	close(fd);
+
+	rc = rename(filename_tmp, history->filename);
+	if (rc)
+		warn_errno("renaming %s to %s", filename_tmp, history->filename);
+}
+
+void history_add_line(struct history *history, const char *line)
+{
+	struct history_entry *new;
+	struct list_head *item;
+
+	new = history_entry_new(line);
+	list_add(&new->node, &history->head);
+	history->lines++;
+
+	/* remove identical */
+	item = history->head.next->next;
+	while (item != &history->head) {
+		struct list_head *next = item->next;
+		struct history_entry *hentry;
+
+		hentry = container_of(item, struct history_entry, node);
+		if (strcmp(hentry->text, new->text) == 0) {
+			list_del(item);
+			history_entry_free(hentry);
+			history->lines--;
+		}
+		item = next;
+	}
+
+	/* remove oldest if history is 'full' */
+	if (history->lines > history->max_lines) {
+		struct list_head *node;
+		struct history_entry *hentry;
+
+		node = history->head.prev;
+		list_del(node);
+		hentry = list_entry(node, struct history_entry, node);
+		history_entry_free(hentry);
+		history->lines--;
+	}
+}
+
+void history_reset_search(struct history *history)
+{
+	history->search_pos = NULL;
+}
+
+const char *history_search_forward(struct history *history, const char *text)
+{
+	struct list_head *item;
+	int search_len;
+
+	if (history->search_pos == NULL) {
+		/* first time to search. set search */
+		item = history->head.next;
+	} else {
+		item = history->search_pos->next;
+	}
+	search_len = strlen(text);
+	while (item != &history->head) {
+		struct history_entry *hentry;
+
+		hentry = list_entry(item, struct history_entry, node);
+		if (strncmp(text, hentry->text, search_len) == 0) {
+			history->search_pos = item;
+			return hentry->text;
+		}
+		item = item->next;
+	}
+	return NULL;
+}
+
+const char *history_search_backward(struct history *history, const char *text)
+{
+	struct list_head *item;
+	int search_len;
+
+	if (history->search_pos == NULL)
+		return NULL;
+	item = history->search_pos->prev;
+	search_len = strlen(text);
+	while (item != &history->head) {
+		struct history_entry *hentry;
+
+		hentry = list_entry(item, struct history_entry, node);
+		if (strncmp(text, hentry->text, search_len) == 0) {
+			history->search_pos = item;
+			return hentry->text;
+		}
+		item = item->prev;
+	}
+	history->search_pos = NULL;
+	return NULL;
+}

history.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_HISTORY_H
+#define CMUS_HISTORY_H
+
+#include "list.h"
+
+struct history {
+	struct list_head head;
+	struct list_head *search_pos;
+	char *filename;
+	int max_lines;
+	int lines;
+};
+
+void history_load(struct history *history, char *filename, int max_lines);
+void history_save(struct history *history);
+void history_free(struct history *history);
+void history_add_line(struct history *history, const char *line);
+void history_reset_search(struct history *history);
+const char *history_search_forward(struct history *history, const char *text);
+const char *history_search_backward(struct history *history, const char *text);
+
+#endif

http.c

@@ -0,0 +1,516 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "http.h"
+#include "file.h"
+#include "debug.h"
+#include "xmalloc.h"
+#include "gbuf.h"
+
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <errno.h>
+
+/*
+ * @uri is http://[user[:pass]@]host[:port][/path][?query]
+ *
+ * uri(7): If the URL supplies a user  name  but no  password, and the remote
+ * server requests a password, the program interpreting the URL should request
+ * one from the user.
+ */
+int http_parse_uri(const char *uri, struct http_uri *u)
+{
+	const char *str, *colon, *at, *slash, *host_start;
+
+	/* initialize all fields */
+	u->uri  = xstrdup(uri);
+	u->user = NULL;
+	u->pass = NULL;
+	u->host = NULL;
+	u->path = NULL;
+	u->port = 80;
+
+	if (strncmp(uri, "http://", 7))
+		return -1;
+	str = uri + 7;
+	host_start = str;
+
+	/* [/path] */
+	slash = strchr(str, '/');
+	if (slash) {
+		u->path = xstrdup(slash);
+	} else {
+		u->path = xstrdup("/");
+	}
+
+	/* [user[:pass]@] */
+	at = strchr(str, '@');
+	if (at && (!slash || at < slash)) {
+		/* user[:pass]@ */
+		host_start = at + 1;
+		colon = strchr(str, ':');
+		if (colon == NULL || colon > at) {
+			/* user */
+			u->user = xstrndup(str, at - str);
+		} else {
+			/* user:pass */
+			u->user = xstrndup(str, colon - str);
+			u->pass = xstrndup(colon + 1, at - (colon + 1));
+		}
+	}
+
+	/* host[:port] */
+	colon = strchr(host_start, ':');
+	if (colon && (!slash || colon < slash)) {
+		/* host:port */
+		const char *start;
+		int port;
+
+		u->host = xstrndup(host_start, colon - host_start);
+		colon++;
+		start = colon;
+
+		port = 0;
+		while (*colon >= '0' && *colon <= '9') {
+			port *= 10;
+			port += *colon - '0';
+			colon++;
+		}
+		u->port = port;
+
+		if (colon == start || (*colon != 0 && *colon != '/')) {
+			http_free_uri(u);
+			return -1;
+		}
+	} else {
+		/* host */
+		if (slash) {
+			u->host = xstrndup(host_start, slash - host_start);
+		} else {
+			u->host = xstrdup(host_start);
+		}
+	}
+	return 0;
+}
+
+void http_free_uri(struct http_uri *u)
+{
+	free(u->uri);
+	free(u->user);
+	free(u->pass);
+	free(u->host);
+	free(u->path);
+
+	u->uri  = NULL;
+	u->user = NULL;
+	u->pass = NULL;
+	u->host = NULL;
+	u->path = NULL;
+}
+
+int http_open(struct http_get *hg, int timeout_ms)
+{
+	const struct addrinfo hints = {
+		.ai_socktype = SOCK_STREAM
+	};
+	struct addrinfo *result;
+	union {
+		struct sockaddr sa;
+		struct sockaddr_storage sas;
+	} addr;
+	size_t addrlen;
+	struct timeval tv;
+	int save, flags, rc;
+	char port[16];
+
+	char *proxy = getenv("http_proxy");
+	if (proxy) {
+		hg->proxy = xnew(struct http_uri, 1);
+		if (http_parse_uri(proxy, hg->proxy)) {
+			d_print("Failed to parse HTTP proxy URI '%s'\n", proxy);
+			return -1;
+		}
+	} else {
+		hg->proxy = NULL;
+	}
+
+	snprintf(port, sizeof(port), "%d", hg->proxy ? hg->proxy->port : hg->uri.port);
+	rc = getaddrinfo(hg->proxy ? hg->proxy->host : hg->uri.host, port, &hints, &result);
+	if (rc != 0) {
+		d_print("getaddrinfo: %s\n", gai_strerror(rc));
+		return -1;
+	}
+	memcpy(&addr.sa, result->ai_addr, result->ai_addrlen);
+	addrlen = result->ai_addrlen;
+	freeaddrinfo(result);
+
+	hg->fd = socket(addr.sa.sa_family, SOCK_STREAM, 0);
+	if (hg->fd == -1)
+		return -1;
+
+	flags = fcntl(hg->fd, F_GETFL);
+	if (fcntl(hg->fd, F_SETFL, O_NONBLOCK) == -1)
+		goto close_exit;
+
+	tv.tv_sec = timeout_ms / 1000;
+	tv.tv_usec = (timeout_ms % 1000) * 1000;
+	while (1) {
+		fd_set wfds;
+
+		d_print("connecting. timeout=%lld s %lld us\n", (long long)tv.tv_sec, (long long)tv.tv_usec);
+		if (connect(hg->fd, &addr.sa, addrlen) == 0)
+			break;
+		if (errno == EISCONN)
+			break;
+		if (errno != EAGAIN && errno != EINPROGRESS)
+			goto close_exit;
+
+		FD_ZERO(&wfds);
+		FD_SET(hg->fd, &wfds);
+		while (1) {
+			rc = select(hg->fd + 1, NULL, &wfds, NULL, &tv);
+			if (rc == -1) {
+				if (errno != EINTR)
+					goto close_exit;
+				/* signalled */
+				continue;
+			}
+			if (rc == 1) {
+				/* socket ready */
+				break;
+			}
+			if (tv.tv_sec == 0 && tv.tv_usec == 0) {
+				errno = ETIMEDOUT;
+				goto close_exit;
+			}
+		}
+	}
+
+	/* restore old flags */
+	if (fcntl(hg->fd, F_SETFL, flags) == -1)
+		goto close_exit;
+	return 0;
+close_exit:
+	save = errno;
+	close(hg->fd);
+	errno = save;
+	return -1;
+}
+
+static int http_write(int fd, const char *buf, int count, int timeout_ms)
+{
+	struct timeval tv;
+	int pos = 0;
+
+	tv.tv_sec = timeout_ms / 1000;
+	tv.tv_usec = (timeout_ms % 1000) * 1000;
+	while (1) {
+		fd_set wfds;
+		int rc;
+
+		d_print("timeout=%lld s %lld us\n", (long long)tv.tv_sec, (long long)tv.tv_usec);
+
+		FD_ZERO(&wfds);
+		FD_SET(fd, &wfds);
+		rc = select(fd + 1, NULL, &wfds, NULL, &tv);
+		if (rc == -1) {
+			if (errno != EINTR)
+				return -1;
+			/* signalled */
+			continue;
+		}
+		if (rc == 1) {
+			rc = write(fd, buf + pos, count - pos);
+			if (rc == -1) {
+				if (errno == EINTR || errno == EAGAIN)
+					continue;
+				return -1;
+			}
+			pos += rc;
+			if (pos == count)
+				return 0;
+		} else if (tv.tv_sec == 0 && tv.tv_usec == 0) {
+			errno = ETIMEDOUT;
+			return -1;
+		}
+	}
+}
+
+static int read_timeout(int fd, int timeout_ms)
+{
+	struct timeval tv;
+
+	tv.tv_sec = timeout_ms / 1000;
+	tv.tv_usec = (timeout_ms % 1000) * 1000;
+	while (1) {
+		fd_set rfds;
+		int rc;
+
+		FD_ZERO(&rfds);
+		FD_SET(fd, &rfds);
+		rc = select(fd + 1, &rfds, NULL, NULL, &tv);
+		if (rc == -1) {
+			if (errno != EINTR)
+				return -1;
+			/* signalled */
+			continue;
+		}
+		if (rc == 1)
+			return 0;
+		if (tv.tv_sec == 0 && tv.tv_usec == 0) {
+			errno = ETIMEDOUT;
+			return -1;
+		}
+	}
+}
+
+/* reads response, ignores fscking carriage returns */
+static int http_read_response(int fd, struct gbuf *buf, int timeout_ms)
+{
+	char prev = 0;
+
+	if (read_timeout(fd, timeout_ms))
+		return -1;
+	while (1) {
+		int rc;
+		char ch;
+
+		rc = read(fd, &ch, 1);
+		if (rc == -1) {
+			return -1;
+		}
+		if (rc == 0) {
+			return -2;
+		}
+		if (ch == '\r')
+			continue;
+		if (ch == '\n' && prev == '\n')
+			return 0;
+		gbuf_add_ch(buf, ch);
+		prev = ch;
+	}
+}
+
+static int http_parse_response(char *str, struct http_get *hg)
+{
+	/* str is 0 terminated buffer of lines
+	 * every line ends with '\n'
+	 * no carriage returns
+	 * no empty lines
+	 */
+	GROWING_KEYVALS(h);
+	char *end;
+
+	if (strncmp(str, "HTTP/", 5) == 0) {
+		str += 5;
+		while (*str != ' ') {
+			if (*str == '\n') {
+				return -2;
+			}
+			str++;
+		}
+	} else if (strncmp(str, "ICY", 3) == 0) {
+		str += 3;
+	} else {
+		return -2;
+	}
+	while (*str == ' ')
+		str++;
+
+	hg->code = 0;
+	while (*str >= '0' && *str <= '9') {
+		hg->code *= 10;
+		hg->code += *str - '0';
+		str++;
+	}
+	if (!hg->code)
+		return -2;
+	while (*str == ' ')
+		str++;
+
+	end = strchr(str, '\n');
+	hg->reason = xstrndup(str, end - str);
+	str = end + 1;
+
+	/* headers */
+	while (*str) {
+		char *ptr;
+
+		end = strchr(str, '\n');
+		ptr = strchr(str, ':');
+		if (ptr == NULL || ptr > end) {
+			free(hg->reason);
+			hg->reason = NULL;
+			keyvals_terminate(&h);
+			keyvals_free(h.keyvals);
+			return -2;
+		}
+
+		*ptr++ = 0;
+		while (*ptr == ' ')
+			ptr++;
+
+		keyvals_add(&h, str, xstrndup(ptr, end - ptr));
+		str = end + 1;
+	}
+	keyvals_terminate(&h);
+	hg->headers = h.keyvals;
+	return 0;
+}
+
+int http_get(struct http_get *hg, struct keyval *headers, int timeout_ms)
+{
+	GBUF(buf);
+	int i, rc, save;
+
+	gbuf_add_str(&buf, "GET ");
+	gbuf_add_str(&buf, hg->proxy ? hg->uri.uri : hg->uri.path);
+	gbuf_add_str(&buf, " HTTP/1.0\r\n");
+	for (i = 0; headers[i].key; i++) {
+		gbuf_add_str(&buf, headers[i].key);
+		gbuf_add_str(&buf, ": ");
+		gbuf_add_str(&buf, headers[i].val);
+		gbuf_add_str(&buf, "\r\n");
+	}
+	gbuf_add_str(&buf, "\r\n");
+
+	rc = http_write(hg->fd, buf.buffer, buf.len, timeout_ms);
+	if (rc)
+		goto out;
+
+	gbuf_clear(&buf);
+	rc = http_read_response(hg->fd, &buf, timeout_ms);
+	if (rc)
+		goto out;
+
+	rc = http_parse_response(buf.buffer, hg);
+out:
+	save = errno;
+	gbuf_free(&buf);
+	errno = save;
+	return rc;
+}
+
+char *http_read_body(int fd, size_t *size, int timeout_ms)
+{
+	GBUF(buf);
+
+	if (read_timeout(fd, timeout_ms))
+		return NULL;
+	while (1) {
+		int count = 1023;
+		int rc;
+
+		gbuf_grow(&buf, count);
+		rc = read_all(fd, buf.buffer + buf.len, count);
+		if (rc == -1) {
+			gbuf_free(&buf);
+			return NULL;
+		}
+		buf.len += rc;
+		if (rc == 0) {
+			*size = buf.len;
+			return gbuf_steal(&buf);
+		}
+	}
+}
+
+void http_get_free(struct http_get *hg)
+{
+	http_free_uri(&hg->uri);
+	if (hg->proxy) {
+		http_free_uri(hg->proxy);
+		free(hg->proxy);
+	}
+	if (hg->headers)
+		keyvals_free(hg->headers);
+	free(hg->reason);
+}
+
+char *base64_encode(const char *str)
+{
+	static const char t[64] CMUS_NONSTRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	int str_len, buf_len, i, s, d;
+	char *buf;
+	unsigned char b0, b1, b2;
+
+	str_len = strlen(str);
+	buf_len = (str_len + 2) / 3 * 4 + 1;
+	buf = xnew(char, buf_len);
+	s = 0;
+	d = 0;
+	for (i = 0; i < str_len / 3; i++) {
+		b0 = str[s++];
+		b1 = str[s++];
+		b2 = str[s++];
+
+		/* 6 ms bits of b0 */
+		buf[d++] = t[b0 >> 2];
+
+		/* 2 ls bits of b0 . 4 ms bits of b1 */
+		buf[d++] = t[((b0 << 4) | (b1 >> 4)) & 0x3f];
+
+		/* 4 ls bits of b1 . 2 ms bits of b2 */
+		buf[d++] = t[((b1 << 2) | (b2 >> 6)) & 0x3f];
+
+		/* 6 ls bits of b2 */
+		buf[d++] = t[b2 & 0x3f];
+	}
+	switch (str_len % 3) {
+	case 2:
+		b0 = str[s++];
+		b1 = str[s++];
+
+		/* 6 ms bits of b0 */
+		buf[d++] = t[b0 >> 2];
+
+		/* 2 ls bits of b0 . 4 ms bits of b1 */
+		buf[d++] = t[((b0 << 4) | (b1 >> 4)) & 0x3f];
+
+		/* 4 ls bits of b1 */
+		buf[d++] = t[(b1 << 2) & 0x3f];
+
+		buf[d++] = '=';
+		break;
+	case 1:
+		b0 = str[s++];
+
+		/* 6 ms bits of b0 */
+		buf[d++] = t[b0 >> 2];
+
+		/* 2 ls bits of b0 */
+		buf[d++] = t[(b0 << 4) & 0x3f];
+
+		buf[d++] = '=';
+		buf[d++] = '=';
+		break;
+	case 0:
+		break;
+	}
+	buf[d] = 0;
+	return buf;
+}

http.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_HTTP_H
+#define CMUS_HTTP_H
+
+#include "keyval.h"
+
+#include <stddef.h> /* size_t */
+
+/*
+ * 1xx indicates an informational message only
+ * 2xx indicates success of some kind
+ * 3xx redirects the client to another URL
+ * 4xx indicates an error on the client's part
+ * 5xx indicates an error on the server's part
+ */
+
+struct http_uri {
+	char *uri;
+	char *user;
+	char *pass;
+	char *host;
+	char *path;
+	int port;
+};
+
+struct http_get {
+	struct http_uri uri;
+	struct http_uri *proxy;
+	int fd;
+	struct keyval *headers;
+	char *reason;
+	int code;
+};
+
+int http_parse_uri(const char *uri, struct http_uri *u);
+
+/* frees contents of @u, not @u itself */
+void http_free_uri(struct http_uri *u);
+
+int http_open(struct http_get *hg, int timeout_ms);
+
+/*
+ * returns:  0 success
+ *          -1 check errno
+ *          -2 parse error
+ */
+int http_get(struct http_get *hg, struct keyval *headers, int timeout_ms);
+void http_get_free(struct http_get *hg);
+
+char *http_read_body(int fd, size_t *size, int timeout_ms);
+char *base64_encode(const char *str);
+
+#endif

id3.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_ID3_H
+#define CMUS_ID3_H
+
+#include <stdint.h>
+
+/* flags for id3_read_tags */
+#define ID3_V1	(1 << 0)
+#define ID3_V2	(1 << 1)
+
+enum id3_key {
+	ID3_ARTIST,
+	ID3_ALBUM,
+	ID3_TITLE,
+	ID3_DATE,
+	ID3_ORIGINALDATE,
+	ID3_GENRE,
+	ID3_DISC,
+	ID3_TRACK,
+	ID3_ALBUMARTIST,
+	ID3_ARTISTSORT,
+	ID3_ALBUMARTISTSORT,
+	ID3_ALBUMSORT,
+	ID3_COMPILATION,
+	ID3_RG_TRACK_GAIN,
+	ID3_RG_TRACK_PEAK,
+	ID3_RG_ALBUM_GAIN,
+	ID3_RG_ALBUM_PEAK,
+	ID3_COMPOSER,
+	ID3_CONDUCTOR,
+	ID3_LYRICIST,
+	ID3_REMIXER,
+	ID3_LABEL,
+	ID3_PUBLISHER,
+	ID3_SUBTITLE,
+	ID3_COMMENT,
+	ID3_MUSICBRAINZ_TRACKID,
+	ID3_MEDIA,
+	ID3_BPM,
+
+	NUM_ID3_KEYS
+};
+
+struct id3tag {
+	char v1[128];
+	char *v2[NUM_ID3_KEYS];
+
+	unsigned int has_v1 : 1;
+	unsigned int has_v2 : 1;
+};
+
+extern const char * const id3_key_names[NUM_ID3_KEYS];
+
+int id3_tag_size(const char *buf, int buf_size);
+
+void id3_init(struct id3tag *id3);
+void id3_free(struct id3tag *id3);
+
+int id3_read_tags(struct id3tag *id3, int fd, unsigned int flags);
+char *id3_get_comment(struct id3tag *id3, enum id3_key key);
+
+char const *id3_get_genre(uint16_t id);
+
+#endif

input.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_INPUT_H
+#define CMUS_INPUT_H
+
+#include "keyval.h"
+#include "sf.h"
+#include "channelmap.h"
+
+struct input_plugin;
+
+void ip_load_plugins(void);
+
+/*
+ * allocates new struct input_plugin.
+ * never fails. does not check if the file is really playable
+ */
+struct input_plugin *ip_new(const char *filename);
+
+/*
+ * frees struct input_plugin closing it first if necessary
+ */
+void ip_delete(struct input_plugin *ip);
+
+/*
+ * errors: IP_ERROR_{ERRNO, FILE_FORMAT, SAMPLE_FORMAT}
+ */
+int ip_open(struct input_plugin *ip);
+
+void ip_setup(struct input_plugin *ip);
+
+/*
+ * errors: none?
+ */
+int ip_close(struct input_plugin *ip);
+
+/*
+ * errors: IP_ERROR_{ERRNO, FILE_FORMAT}
+ */
+int ip_read(struct input_plugin *ip, char *buffer, int count);
+
+/*
+ * errors: IP_ERROR_{FUNCTION_NOT_SUPPORTED}
+ */
+int ip_seek(struct input_plugin *ip, double offset);
+
+/*
+ * errors: IP_ERROR_{ERRNO}
+ */
+int ip_read_comments(struct input_plugin *ip, struct keyval **comments);
+
+int ip_duration(struct input_plugin *ip);
+int ip_bitrate(struct input_plugin *ip);
+int ip_current_bitrate(struct input_plugin *ip);
+char *ip_codec(struct input_plugin *ip);
+char *ip_codec_profile(struct input_plugin *ip);
+
+sample_format_t ip_get_sf(struct input_plugin *ip);
+void ip_get_channel_map(struct input_plugin *ip, channel_position_t *channel_map);
+const char *ip_get_filename(struct input_plugin *ip);
+const char *ip_get_metadata(struct input_plugin *ip);
+int ip_is_remote(struct input_plugin *ip);
+int ip_metadata_changed(struct input_plugin *ip);
+int ip_eof(struct input_plugin *ip);
+void ip_add_options(void);
+char *ip_get_error_msg(struct input_plugin *ip, int rc, const char *arg);
+char **ip_get_supported_extensions(void);
+void ip_dump_plugins(void);
+
+#endif

ip.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004-2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_IP_H
+#define CMUS_IP_H
+
+#include "keyval.h"
+#include "sf.h"
+#include "channelmap.h"
+
+#ifndef __GNUC__
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#define IP_ABI_VERSION 2
+
+enum {
+	/* no error */
+	IP_ERROR_SUCCESS,
+	/* system error (error code in errno) */
+	IP_ERROR_ERRNO,
+	/* file type not recognized */
+	IP_ERROR_UNRECOGNIZED_FILE_TYPE,
+	/* file type recognized, but not supported */
+	IP_ERROR_UNSUPPORTED_FILE_TYPE,
+	/* function not supported (usually seek) */
+	IP_ERROR_FUNCTION_NOT_SUPPORTED,
+	/* input plugin detected corrupted file */
+	IP_ERROR_FILE_FORMAT,
+	/* malformed uri */
+	IP_ERROR_INVALID_URI,
+	/* sample format not supported */
+	IP_ERROR_SAMPLE_FORMAT,
+	/* wrong disc inserted */
+	IP_ERROR_WRONG_DISC,
+	/* could not read disc */
+	IP_ERROR_NO_DISC,
+	/* error parsing response line / headers */
+	IP_ERROR_HTTP_RESPONSE,
+	/* usually 404 */
+	IP_ERROR_HTTP_STATUS,
+	/* too many redirections */
+	IP_ERROR_HTTP_REDIRECT_LIMIT,
+	/* plugin does not have this option */
+	IP_ERROR_NOT_OPTION,
+	/*  */
+	IP_ERROR_INTERNAL
+};
+
+struct input_plugin_data {
+	/* filled by ip-layer */
+	char *filename;
+	int fd;
+
+	unsigned int remote : 1;
+	unsigned int metadata_changed : 1;
+
+	/* shoutcast */
+	int counter;
+	int metaint;
+	char *metadata;
+	char *icy_name;
+	char *icy_genre;
+	char *icy_url;
+	char *icy_br;
+
+	/* filled by plugin */
+	sample_format_t sf;
+	channel_position_t channel_map[CHANNELS_MAX];
+	void *private;
+};
+
+struct input_plugin_ops {
+	int (*open)(struct input_plugin_data *ip_data);
+	int (*close)(struct input_plugin_data *ip_data);
+	int (*read)(struct input_plugin_data *ip_data, char *buffer, int count);
+	int (*seek)(struct input_plugin_data *ip_data, double offset);
+	int (*read_comments)(struct input_plugin_data *ip_data,
+			struct keyval **comments);
+	int (*duration)(struct input_plugin_data *ip_data);
+	long (*bitrate)(struct input_plugin_data *ip_data);
+	long (*bitrate_current)(struct input_plugin_data *ip_data);
+	char *(*codec)(struct input_plugin_data *ip_data);
+	char *(*codec_profile)(struct input_plugin_data *ip_data);
+};
+
+struct input_plugin_opt {
+	const char *name;
+	int (*set)(const char *val);
+	int (*get)(char **val);
+};
+
+/* symbols exported by plugin */
+extern const struct input_plugin_ops ip_ops;
+extern const int ip_priority;
+extern const char * const ip_extensions[];
+extern const char * const ip_mime_types[];
+extern const struct input_plugin_opt ip_options[];
+extern const unsigned ip_abi_version;
+
+#endif

ip/aac.c

@@ -0,0 +1,541 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 dnk <dnk@bjum.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../xmalloc.h"
+#include "../debug.h"
+#include "../id3.h"
+#include "../comment.h"
+#include "../read_wrapper.h"
+#include "aac.h"
+
+#include <neaacdec.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+/* FAAD_MIN_STREAMSIZE == 768, 6 == # of channels */
+#define BUFFER_SIZE	(FAAD_MIN_STREAMSIZE * 6 * 4)
+
+struct aac_private {
+	char rbuf[BUFFER_SIZE];
+	int rbuf_len;
+	int rbuf_pos;
+
+	unsigned char channels;
+	unsigned long sample_rate;
+	long bitrate;
+	int object_type;
+
+	struct {
+		unsigned long samples;
+		unsigned long bytes;
+	} current;
+
+	char *overflow_buf;
+	int overflow_buf_len;
+
+	NeAACDecHandle decoder;	/* typedef void * */
+};
+
+static inline int buffer_length(const struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+
+	return priv->rbuf_len - priv->rbuf_pos;
+}
+
+static inline void *buffer_data(const struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+
+	return priv->rbuf + priv->rbuf_pos;
+}
+
+static int buffer_fill(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	int32_t n;
+
+	if (priv->rbuf_pos > 0) {
+		priv->rbuf_len = buffer_length(ip_data);
+		memmove(priv->rbuf, priv->rbuf + priv->rbuf_pos, priv->rbuf_len);
+		priv->rbuf_pos = 0;
+	}
+
+	if (priv->rbuf_len == BUFFER_SIZE)
+		return 1;
+
+	n = read_wrapper(ip_data, priv->rbuf + priv->rbuf_len, BUFFER_SIZE - priv->rbuf_len);
+	if (n == -1)
+		return -1;
+	if (n == 0)
+		return 0;
+
+	priv->rbuf_len += n;
+	return 1;
+}
+
+static inline void buffer_consume(struct input_plugin_data *ip_data, int n)
+{
+	struct aac_private *priv = ip_data->private;
+
+	BUG_ON(n > buffer_length(ip_data));
+
+	priv->rbuf_pos += n;
+}
+
+static int buffer_fill_min(struct input_plugin_data *ip_data, int len)
+{
+	int rc;
+
+	BUG_ON(len > BUFFER_SIZE);
+
+	while (buffer_length(ip_data) < len) {
+		rc = buffer_fill(ip_data);
+		if (rc <= 0)
+			return rc;
+	}
+	return 1;
+}
+
+/* 'data' must point to at least 6 bytes of data */
+static inline int parse_frame(const unsigned char data[6])
+{
+	int len;
+
+	/* http://www.audiocoding.com/modules/wiki/?page=ADTS */
+
+	/* first 12 bits must be set */
+	if (data[0] != 0xFF)
+		return 0;
+	if ((data[1] & 0xF0) != 0xF0)
+		return 0;
+
+	/* layer is always '00' */
+	if ((data[1] & 0x06) != 0x00)
+		return 0;
+
+	/* frame length is stored in 13 bits */
+	len  = data[3] << 11;	/* ..1100000000000 */
+	len |= data[4] << 3;	/* ..xx11111111xxx */
+	len |= data[5] >> 5;	/* ..xxxxxxxxxx111 */
+	len &= 0x1FFF;		/* 13 bits */
+	return len;
+}
+
+/* scans forward to the next aac frame and makes sure
+ * the entire frame is in the buffer.
+ */
+static int buffer_fill_frame(struct input_plugin_data *ip_data)
+{
+	unsigned char *data;
+	int rc, n, len;
+	int max = 32768;
+
+	while (1) {
+		/* need at least 6 bytes of data */
+		rc = buffer_fill_min(ip_data, 6);
+		if (rc <= 0)
+			return rc;
+
+		len = buffer_length(ip_data);
+		data = buffer_data(ip_data);
+
+		/* scan for a frame */
+		for (n = 0; n < len - 5; n++) {
+			/* give up after 32KB */
+			if (max-- == 0) {
+				d_print("no frame found!\n");
+				/* FIXME: set errno? */
+				return -1;
+			}
+
+			/* see if there's a frame at this location */
+			rc = parse_frame(data + n);
+			if (rc == 0)
+				continue;
+
+			/* found a frame, consume all data up to the frame */
+			buffer_consume(ip_data, n);
+
+			/* rc == frame length */
+			rc = buffer_fill_min(ip_data, rc);
+			if (rc <= 0)
+				return rc;
+
+			return 1;
+		}
+
+		/* consume what we used */
+		buffer_consume(ip_data, n);
+	}
+	/* not reached */
+}
+
+static void aac_get_channel_map(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	NeAACDecFrameInfo frame_info;
+	void *buf;
+	int i;
+
+	ip_data->channel_map[0] = CHANNEL_POSITION_INVALID;
+
+	if (buffer_fill_frame(ip_data) <= 0)
+		return;
+
+	buf = NeAACDecDecode(priv->decoder, &frame_info, buffer_data(ip_data), buffer_length(ip_data));
+	NeAACDecPostSeekReset(priv->decoder, 0);
+	if (!buf || frame_info.error != 0 || frame_info.bytesconsumed <= 0
+			|| frame_info.channels > CHANNELS_MAX)
+		return;
+
+	for (i = 0; i < frame_info.channels; i++)
+		ip_data->channel_map[i] = channel_position_aac(frame_info.channel_position[i]);
+}
+
+static int aac_open(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv;
+	NeAACDecConfigurationPtr neaac_cfg;
+	int ret, n;
+
+	/* init private struct */
+	const struct aac_private priv_init = {
+		.decoder = NeAACDecOpen(),
+		.bitrate = -1,
+		.object_type = -1
+	};
+	priv = xnew(struct aac_private, 1);
+	*priv = priv_init;
+	ip_data->private = priv;
+
+	/* set decoder config */
+	neaac_cfg = NeAACDecGetCurrentConfiguration(priv->decoder);
+	neaac_cfg->outputFormat = FAAD_FMT_16BIT;	/* force 16 bit audio */
+	neaac_cfg->downMatrix = 0;			/* NOT 5.1 -> stereo */
+	neaac_cfg->dontUpSampleImplicitSBR = 0;		/* upsample, please! */
+	NeAACDecSetConfiguration(priv->decoder, neaac_cfg);
+
+	/* find a frame */
+	if (buffer_fill_frame(ip_data) <= 0) {
+		ret = -IP_ERROR_FILE_FORMAT;
+		goto out;
+	}
+
+	/* in case of a bug, make sure there is at least some data
+	 * in the buffer for NeAACDecInit() to work with.
+	 */
+	if (buffer_fill_min(ip_data, 256) <= 0) {
+		d_print("not enough data\n");
+		ret = -IP_ERROR_FILE_FORMAT;
+		goto out;
+	}
+
+	/* init decoder, returns the length of the header (if any) */
+	n = NeAACDecInit(priv->decoder, buffer_data(ip_data), buffer_length(ip_data),
+		&priv->sample_rate, &priv->channels);
+	if (n < 0) {
+		d_print("NeAACDecInit failed\n");
+		ret = -IP_ERROR_FILE_FORMAT;
+		goto out;
+	}
+
+	d_print("sample rate %luhz, channels %u\n", priv->sample_rate, priv->channels);
+	if (!priv->sample_rate || !priv->channels) {
+		ret = -IP_ERROR_FILE_FORMAT;
+		goto out;
+	}
+
+	/* skip the header */
+	d_print("skipping header (%d bytes)\n", n);
+
+	buffer_consume(ip_data, n);
+
+	/*NeAACDecInitDRM(priv->decoder, priv->sample_rate, priv->channels);*/
+
+	ip_data->sf = sf_rate(priv->sample_rate) | sf_channels(priv->channels) | sf_bits(16) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+	aac_get_channel_map(ip_data);
+
+	return 0;
+out:
+	NeAACDecClose(priv->decoder);
+	free(priv);
+	return ret;
+}
+
+static int aac_close(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+
+	NeAACDecClose(priv->decoder);
+	free(priv);
+	ip_data->private = NULL;
+	return 0;
+}
+
+/* returns -1 on fatal errors
+ * returns -2 on non-fatal errors
+ * 0 on eof
+ * number of bytes put in 'buffer' on success */
+static int decode_one_frame(struct input_plugin_data *ip_data, void *buffer, int count)
+{
+	struct aac_private *priv = ip_data->private;
+	unsigned char *aac_data;
+	unsigned int aac_data_size;
+	NeAACDecFrameInfo frame_info;
+	char *sample_buf;
+	int bytes, rc;
+
+	rc = buffer_fill_frame(ip_data);
+	if (rc <= 0)
+		return rc;
+
+	aac_data = buffer_data(ip_data);
+	aac_data_size = buffer_length(ip_data);
+
+	/* aac data -> raw pcm */
+	sample_buf = NeAACDecDecode(priv->decoder, &frame_info, aac_data, aac_data_size);
+	if (frame_info.error == 0 && frame_info.samples > 0) {
+		priv->current.samples += frame_info.samples;
+		priv->current.bytes += frame_info.bytesconsumed;
+	}
+
+	buffer_consume(ip_data, frame_info.bytesconsumed);
+
+	if (!sample_buf || frame_info.bytesconsumed <= 0) {
+		d_print("fatal error: %s\n", NeAACDecGetErrorMessage(frame_info.error));
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (frame_info.error != 0) {
+		d_print("frame error: %s\n", NeAACDecGetErrorMessage(frame_info.error));
+		return -2;
+	}
+
+	if (frame_info.samples <= 0)
+		return -2;
+
+	if (frame_info.channels != priv->channels || frame_info.samplerate != priv->sample_rate) {
+		d_print("invalid channel or sample_rate count\n");
+		return -2;
+	}
+
+	/* 16-bit samples */
+	bytes = frame_info.samples * 2;
+
+	if (bytes > count) {
+		/* decoded too much, keep overflow */
+		priv->overflow_buf = sample_buf + count;
+		priv->overflow_buf_len = bytes - count;
+		memcpy(buffer, sample_buf, count);
+		return count;
+	} else {
+		memcpy(buffer, sample_buf, bytes);
+	}
+	return bytes;
+}
+
+static int aac_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct aac_private *priv = ip_data->private;
+	int rc;
+
+	/* use overflow from previous call (if any) */
+	if (priv->overflow_buf_len) {
+		int len = priv->overflow_buf_len;
+
+		if (len > count)
+			len = count;
+
+		memcpy(buffer, priv->overflow_buf, len);
+		priv->overflow_buf += len;
+		priv->overflow_buf_len -= len;
+		return len;
+	}
+
+	do {
+		rc = decode_one_frame(ip_data, buffer, count);
+	} while (rc == -2);
+	return rc;
+}
+
+static int aac_seek(struct input_plugin_data *ip_data, double offset)
+{
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static int aac_read_comments(struct input_plugin_data *ip_data,
+		struct keyval **comments)
+{
+	GROWING_KEYVALS(c);
+	struct id3tag id3;
+	int rc, fd, i;
+
+	fd = open(ip_data->filename, O_RDONLY);
+	if (fd == -1)
+		return -1;
+
+	id3_init(&id3);
+	rc = id3_read_tags(&id3, fd, ID3_V1 | ID3_V2);
+	if (rc == -1) {
+		d_print("error: %s\n", strerror(errno));
+		goto out;
+	}
+
+	for (i = 0; i < NUM_ID3_KEYS; i++) {
+		char *val = id3_get_comment(&id3, i);
+
+		if (val)
+			comments_add(&c, id3_key_names[i], val);
+	}
+out:
+	close(fd);
+	id3_free(&id3);
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int aac_duration(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	NeAACDecFrameInfo frame_info;
+	int samples = 0, bytes = 0, frames = 0;
+	off_t file_size;
+
+	file_size = lseek(ip_data->fd, 0, SEEK_END);
+	if (file_size == -1)
+		return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+
+	/* Seek to the middle of the file. There is almost always silence at
+	 * the beginning, which gives wrong results. */
+	if (lseek(ip_data->fd, file_size/2, SEEK_SET) == -1)
+		return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+
+	priv->rbuf_pos = 0;
+	priv->rbuf_len = 0;
+
+	/* guess track length by decoding the first 10 frames */
+	while (frames < 10) {
+		if (buffer_fill_frame(ip_data) <= 0)
+			break;
+
+		NeAACDecDecode(priv->decoder, &frame_info,
+			buffer_data(ip_data), buffer_length(ip_data));
+		if (frame_info.error == 0 && frame_info.samples > 0) {
+			samples += frame_info.samples;
+			bytes += frame_info.bytesconsumed;
+			frames++;
+		}
+		if (frame_info.bytesconsumed == 0)
+			break;
+
+		buffer_consume(ip_data, frame_info.bytesconsumed);
+	}
+
+	if (frames == 0)
+		return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+
+	NeAACDecPostSeekReset(priv->decoder, 0);
+
+	samples /= frames;
+	samples /= priv->channels;
+	bytes /= frames;
+
+	/*  8 * file_size / duration */
+	priv->bitrate = (8 * bytes * priv->sample_rate) / samples;
+
+	priv->object_type = frame_info.object_type;
+
+	return ((file_size / bytes) * samples) / priv->sample_rate;
+}
+
+static long aac_bitrate(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	return priv->bitrate != -1 ? priv->bitrate : -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long aac_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	long bitrate = -1;
+	if (priv->current.samples > 0) {
+		priv->current.samples /= priv->channels;
+		bitrate = (8 * priv->current.bytes * priv->sample_rate) / priv->current.samples;
+		priv->current.samples = 0;
+		priv->current.bytes = 0;
+	}
+	return bitrate;
+}
+
+static char *aac_codec(struct input_plugin_data *ip_data)
+{
+	return xstrdup("aac");
+}
+
+static const char *object_type_to_str(int object_type)
+{
+	switch (object_type) {
+	case MAIN:	return "Main";
+	case LC:	return "LC";
+	case SSR:	return "SSR";
+	case LTP:	return "LTP";
+	case HE_AAC:	return "HE";
+	case ER_LC:	return "ER-LD";
+	case ER_LTP:	return "ER-LTP";
+	case LD:	return "LD";
+	case DRM_ER_LC:	return "DRM-ER-LC";
+	}
+	return NULL;
+}
+
+static char *aac_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct aac_private *priv = ip_data->private;
+	const char *profile = object_type_to_str(priv->object_type);
+
+	return profile ? xstrdup(profile) : NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = aac_open,
+	.close = aac_close,
+	.read = aac_read,
+	.seek = aac_seek,
+	.read_comments = aac_read_comments,
+	.duration = aac_duration,
+	.bitrate = aac_bitrate,
+	.bitrate_current = aac_current_bitrate,
+	.codec = aac_codec,
+	.codec_profile = aac_codec_profile
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = { "aac", NULL };
+const char * const ip_mime_types[] = { "audio/aac", "audio/aacp", NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/aac.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMUS_AAC_H
+#define CMUS_AAC_H
+
+#include "../channelmap.h"
+#include <neaacdec.h>
+
+static inline channel_position_t channel_position_aac(unsigned char c)
+{
+	switch (c) {
+	case FRONT_CHANNEL_CENTER:	return CHANNEL_POSITION_FRONT_CENTER;
+	case FRONT_CHANNEL_LEFT:	return CHANNEL_POSITION_FRONT_LEFT;
+	case FRONT_CHANNEL_RIGHT:	return CHANNEL_POSITION_FRONT_RIGHT;
+	case SIDE_CHANNEL_LEFT:		return CHANNEL_POSITION_SIDE_LEFT;
+	case SIDE_CHANNEL_RIGHT:	return CHANNEL_POSITION_SIDE_RIGHT;
+	case BACK_CHANNEL_LEFT:		return CHANNEL_POSITION_REAR_LEFT;
+	case BACK_CHANNEL_RIGHT:	return CHANNEL_POSITION_REAR_RIGHT;
+	case BACK_CHANNEL_CENTER:	return CHANNEL_POSITION_REAR_CENTER;
+	case LFE_CHANNEL:		return CHANNEL_POSITION_LFE;
+	default:			return CHANNEL_POSITION_INVALID;
+	}
+}
+
+#endif

ip/bass.c

@@ -0,0 +1,213 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2016 Nic Soudée
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../xmalloc.h"
+#include "../comment.h"
+#include "../bass.h"
+#include "../uchar.h"
+
+#define BITS (16)
+#define FREQ (44100)
+#define CHANS (2)
+
+struct bass_private {
+	DWORD chan;
+};
+
+static int bass_init(void)
+{
+	static int inited = 0;
+
+	if (inited)
+		return 1;
+
+	if (!BASS_Init(0, FREQ, 0, 0, NULL))
+		return 0;
+
+	inited = 1;
+	return 1;
+}
+
+static int bass_open(struct input_plugin_data *ip_data)
+{
+	struct bass_private *priv;
+	DWORD chan;
+	DWORD flags;
+
+	if (!bass_init())
+		return -IP_ERROR_INTERNAL;
+
+	flags = BASS_MUSIC_DECODE;
+	flags |= BASS_MUSIC_RAMP;
+	flags |= BASS_MUSIC_PRESCAN;
+	flags |= BASS_MUSIC_STOPBACK;
+
+	chan = BASS_MusicLoad(FALSE, ip_data->filename, 0, 0, flags, 0);
+
+	if (!chan) {
+		return -IP_ERROR_ERRNO;
+	}
+
+	priv = xnew(struct bass_private, 1);
+	priv->chan = chan;
+	ip_data->private = priv;
+	ip_data->sf = sf_bits(BITS) | sf_rate(FREQ) | sf_channels(CHANS) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+	channel_map_init_stereo(ip_data->channel_map);
+	return 0;
+}
+
+static int bass_close(struct input_plugin_data *ip_data)
+{
+	struct bass_private *priv = ip_data->private;
+
+	BASS_MusicFree(priv->chan);
+	free(priv);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int bass_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	int length;
+	struct bass_private *priv = ip_data->private;
+	length = BASS_ChannelGetData(priv->chan, buffer, count);
+	if (length < 0) {
+		return 0;
+	}
+	return length;
+}
+
+static int bass_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct bass_private *priv = ip_data->private;
+	QWORD pos = (QWORD)(offset * (FREQ * CHANS * (BITS / 8)) + 0.5);
+	QWORD flags = BASS_POS_BYTE | BASS_POS_DECODE;
+
+	if (!BASS_ChannelSetPosition(priv->chan, pos, flags)) {
+		return -IP_ERROR_INTERNAL;
+	}
+	return 0;
+}
+
+static unsigned char *encode_ascii_string(const char *str)
+{
+	unsigned char *ret;
+	int n;
+
+	ret = xmalloc(strlen(str) + 1);
+	n = u_to_ascii(ret, str, strlen(str));
+	ret[n] = '\0';
+	return ret;
+}
+
+static int bass_read_comments(struct input_plugin_data *ip_data,
+				struct keyval **comments)
+{
+	struct bass_private *priv = ip_data->private;
+	GROWING_KEYVALS(c);
+	const char *val;
+
+	val = BASS_ChannelGetTags(priv->chan, BASS_TAG_MUSIC_NAME);
+	if (val && val[0]) {
+		unsigned char *val_encoded = encode_ascii_string(val);
+		comments_add_const(&c, "title", (char *)val_encoded);
+		free(val_encoded);
+	}
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int bass_duration(struct input_plugin_data *ip_data)
+{
+	static float length = 0;
+	int pos;
+	struct bass_private *priv = ip_data->private;
+
+	pos = BASS_ChannelGetLength(priv->chan, BASS_POS_BYTE);
+	if (pos && pos != -1) {
+		length = BASS_ChannelBytes2Seconds(priv->chan, pos);
+	}
+	else {
+		length = -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+	}
+	return length;
+}
+
+static long bass_bitrate(struct input_plugin_data *ip_data)
+{
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static const char *bass_type_to_string(int type)
+{
+	/* from <bass.h> */
+	switch (type) {
+		case 0x20000: return "mod";
+		case 0x20001: return "mtm";
+		case 0x20002: return "s3m";
+		case 0x20003: return "xm";
+		case 0x20004: return "it";
+	}
+	return NULL;
+}
+
+static char *bass_codec(struct input_plugin_data *ip_data)
+{
+	const char *codec;
+	int type;
+	BASS_CHANNELINFO info;
+	struct bass_private *priv = ip_data->private;
+
+	if (!(BASS_ChannelGetInfo(priv->chan, &info))) {
+		return NULL;
+	}
+	type = info.ctype;
+	codec = bass_type_to_string(type);
+	return codec ? xstrdup(codec) : NULL;
+}
+
+static char *bass_codec_profile(struct input_plugin_data *ip_data)
+{
+	return NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = bass_open,
+	.close = bass_close,
+	.read = bass_read,
+	.seek = bass_seek,
+	.read_comments = bass_read_comments,
+	.duration = bass_duration,
+	.bitrate = bass_bitrate,
+	.bitrate_current = bass_bitrate,
+	.codec = bass_codec,
+	.codec_profile = bass_codec_profile
+};
+
+const int ip_priority = 60;
+const char * const ip_extensions[] = {
+	"xm", "it", "s3m", "mod", "mtm", "umx", NULL
+};
+
+const char * const ip_mime_types[] = { NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;
+

ip/cdio.c

@@ -0,0 +1,551 @@
+/*
+ * Copyright 2011-2013 Various Authors
+ * Copyright 2011 Johannes Weißl
+ *
+ * Based on cdda.c from XMMS2.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../file.h"
+#include "../xmalloc.h"
+#include "../debug.h"
+#include "../utils.h"
+#include "../options.h"
+#include "../comment.h"
+#include "../discid.h"
+
+#include <cdio/cdio.h>
+#include <cdio/logging.h>
+#if LIBCDIO_VERSION_NUM >= 90
+#include <cdio/paranoia/cdda.h>
+#else
+#include <cdio/cdda.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#undef HAVE_CDDB
+
+#ifdef HAVE_CONFIG
+#include "../config/cdio.h"
+#endif
+
+#ifdef HAVE_CDDB
+#include "../http.h"
+#include "../xstrjoin.h"
+#include <cddb/cddb.h>
+#endif
+
+#ifdef HAVE_CDDB
+static char *cddb_url = NULL;
+#endif
+
+static struct {
+	CdIo_t *cdio;
+	cdrom_drive_t *drive;
+	const char *disc_id;
+	const char *device;
+} cached;
+
+struct cdda_private {
+	CdIo_t *cdio;
+	cdrom_drive_t *drive;
+	char *disc_id;
+	char *device;
+	track_t track;
+	lsn_t first_lsn;
+	lsn_t last_lsn;
+	lsn_t current_lsn;
+	int first_read;
+
+	char read_buf[CDIO_CD_FRAMESIZE_RAW];
+	unsigned long buf_used;
+};
+
+static void libcdio_log(cdio_log_level_t level, const char *message)
+{
+	const char *level_names[] = { "DEBUG", "INFO", "WARN", "ERROR", "ASSERT" };
+	int len = strlen(message);
+	if (len > 0 && message[len-1] == '\n')
+		len--;
+	if (len > 0) {
+		level = clamp(level, 1, N_ELEMENTS(level_names));
+		d_print("%s: %.*s\n", level_names[level-1], len, message);
+	}
+}
+
+static int libcdio_open(struct input_plugin_data *ip_data)
+{
+	struct cdda_private *priv, priv_init = {
+		.first_read = 1,
+		.buf_used = CDIO_CD_FRAMESIZE_RAW
+	};
+	CdIo_t *cdio = NULL;
+	cdrom_drive_t *drive = NULL;
+	const char *device = cdda_device;
+	lsn_t first_lsn;
+	int track = -1;
+	char *disc_id = NULL;
+	char *msg = NULL;
+	int rc = 0, save = 0;
+
+	if (!parse_cdda_url(ip_data->filename, &disc_id, &track, NULL)) {
+		rc = -IP_ERROR_INVALID_URI;
+		goto end;
+	}
+
+	if (track == -1) {
+		d_print("invalid or missing track number, aborting!\n");
+		rc = -IP_ERROR_INVALID_URI;
+		goto end;
+	}
+
+	/* In case of cue/toc/nrg, take filename (= disc_id) as device.
+	 * A real disc_id is base64 encoded and never contains a slash */
+	if (strchr(disc_id, '/'))
+		device = disc_id;
+
+	ip_data->fd = open(device, O_RDONLY);
+	if (ip_data->fd == -1) {
+		save = errno;
+		d_print("could not open device %s\n", device);
+		rc = -IP_ERROR_ERRNO;
+		goto end;
+	}
+
+	if (cached.cdio && strcmp(disc_id, cached.disc_id) == 0 && strcmp(device, cached.device) == 0) {
+		cdio = cached.cdio;
+		drive = cached.drive;
+	} else {
+		cdio_log_set_handler(libcdio_log);
+		cdio = cdio_open(device, DRIVER_UNKNOWN);
+		if (!cdio) {
+			d_print("failed to open device %s\n", device);
+			rc = -IP_ERROR_NO_DISC;
+			goto end;
+		}
+		cdio_set_speed(cdio, 1);
+
+		drive = cdio_cddap_identify_cdio(cdio, CDDA_MESSAGE_LOGIT, &msg);
+		if (!drive) {
+			d_print("failed to identify drive, aborting!\n");
+			rc = -IP_ERROR_NO_DISC;
+			goto end;
+		}
+		d_print("%s", msg);
+		cdio_cddap_verbose_set(drive, CDDA_MESSAGE_LOGIT, CDDA_MESSAGE_LOGIT);
+		drive->b_swap_bytes = 1;
+
+		if (cdio_cddap_open(drive)) {
+			d_print("unable to open disc, aborting!\n");
+			rc = -IP_ERROR_NO_DISC;
+			goto end;
+		}
+	}
+
+	first_lsn = cdio_cddap_track_firstsector(drive, track);
+	if (first_lsn == -1) {
+		d_print("no such track: %d, aborting!\n", track);
+		rc = -IP_ERROR_INVALID_URI;
+		goto end;
+	}
+
+	priv = xnew(struct cdda_private, 1);
+	*priv = priv_init;
+	priv->cdio = cdio;
+	priv->drive = drive;
+	priv->disc_id = xstrdup(disc_id);
+	priv->device = xstrdup(device);
+	priv->track = track;
+	priv->first_lsn = first_lsn;
+	priv->last_lsn = cdio_cddap_track_lastsector(drive, priv->track);
+	priv->current_lsn = first_lsn;
+
+	cached.cdio = priv->cdio;
+	cached.drive = priv->drive;
+	cached.disc_id = priv->disc_id;
+	cached.device = priv->device;
+
+	ip_data->private = priv;
+	ip_data->sf = sf_bits(16) | sf_rate(44100) | sf_channels(2) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+
+end:
+	free(disc_id);
+
+	if (rc < 0) {
+		if (ip_data->fd != -1)
+			close(ip_data->fd);
+		ip_data->fd = -1;
+	}
+
+	if (rc == -IP_ERROR_ERRNO)
+		errno = save;
+	return rc;
+}
+
+static int libcdio_close(struct input_plugin_data *ip_data)
+{
+	struct cdda_private *priv = ip_data->private;
+
+	if (ip_data->fd != -1)
+		close(ip_data->fd);
+	ip_data->fd = -1;
+
+	if (strcmp(priv->disc_id, cached.disc_id) != 0 || strcmp(priv->device, cached.device) != 0) {
+		cdio_cddap_close_no_free_cdio(priv->drive);
+		cdio_destroy(priv->cdio);
+		free(priv->disc_id);
+		free(priv->device);
+	}
+
+	free(priv);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int libcdio_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct cdda_private *priv = ip_data->private;
+	int rc = 0;
+
+	if (priv->first_read || cdio_get_media_changed(priv->cdio)) {
+		char *disc_id;
+		priv->first_read = 0;
+		if (!get_disc_id(priv->device, &disc_id, NULL))
+			return -IP_ERROR_NO_DISC;
+		if (strcmp(disc_id, priv->disc_id) != 0) {
+			free(disc_id);
+			return -IP_ERROR_WRONG_DISC;
+		}
+		free(disc_id);
+	}
+
+	if (priv->current_lsn >= priv->last_lsn)
+		return 0;
+
+	if (priv->buf_used == CDIO_CD_FRAMESIZE_RAW) {
+		cdio_cddap_read(priv->drive, priv->read_buf, priv->current_lsn, 1);
+		priv->current_lsn++;
+		priv->buf_used = 0;
+	}
+
+	if (count >= CDIO_CD_FRAMESIZE_RAW) {
+		rc = CDIO_CD_FRAMESIZE_RAW - priv->buf_used;
+		memcpy(buffer, priv->read_buf + priv->buf_used, rc);
+	} else {
+		unsigned long buf_left = CDIO_CD_FRAMESIZE_RAW - priv->buf_used;
+
+		if (buf_left < count) {
+			memcpy(buffer, priv->read_buf + priv->buf_used, buf_left);
+			rc = buf_left;
+		} else {
+			memcpy(buffer, priv->read_buf + priv->buf_used, count);
+			rc = count;
+		}
+	}
+	priv->buf_used += rc;
+
+	return rc;
+}
+
+static int libcdio_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct cdda_private *priv = ip_data->private;
+	lsn_t new_lsn;
+	int64_t samples = offset * 44100;
+
+	/* Magic number 42... really should think of a better way to do this but
+	 * it seemed that the lsn is off by about 42 everytime...
+	 */
+	new_lsn = samples / 441.0 * CDIO_CD_FRAMES_PER_SEC / 100 + 42;
+
+	if ((priv->first_lsn + new_lsn) > priv->last_lsn) {
+		d_print("trying to seek past the end of track.\n");
+		return -1;
+	}
+
+	priv->current_lsn = priv->first_lsn + new_lsn;
+
+	return 0;
+}
+
+#ifdef HAVE_CDDB
+static int parse_cddb_url(const char *url, struct http_uri *http_uri, int *use_http)
+{
+	char *full_url;
+	int rc;
+
+	if (is_http_url(url)) {
+		*use_http = 1;
+		full_url = xstrdup(url);
+	} else {
+		*use_http = 0;
+		full_url = xstrjoin("http://", url);
+	}
+
+	rc = http_parse_uri(full_url, http_uri);
+	free(full_url);
+	return rc == 0;
+}
+
+static void setup_cddb_conn(cddb_conn_t *cddb_conn)
+{
+	struct http_uri http_uri, http_proxy_uri;
+	const char *proxy;
+	int use_http;
+
+	parse_cddb_url(cddb_url, &http_uri, &use_http);
+
+	proxy = getenv("http_proxy");
+	if (proxy && http_parse_uri(proxy, &http_proxy_uri) == 0) {
+		cddb_http_proxy_enable(cddb_conn);
+		cddb_set_http_proxy_server_name(cddb_conn, http_proxy_uri.host);
+		cddb_set_http_proxy_server_port(cddb_conn, http_proxy_uri.port);
+		if (http_proxy_uri.user)
+			cddb_set_http_proxy_username(cddb_conn, http_proxy_uri.user);
+		if (http_proxy_uri.pass)
+			cddb_set_http_proxy_password(cddb_conn, http_proxy_uri.pass);
+		http_free_uri(&http_proxy_uri);
+	} else
+		cddb_http_proxy_disable(cddb_conn);
+
+	if (use_http)
+		cddb_http_enable(cddb_conn);
+	else
+		cddb_http_disable(cddb_conn);
+
+	cddb_set_server_name(cddb_conn, http_uri.host);
+	cddb_set_email_address(cddb_conn, "me@home");
+	cddb_set_server_port(cddb_conn, http_uri.port);
+	if (strcmp(http_uri.path, "/") != 0)
+		cddb_set_http_path_query(cddb_conn, http_uri.path);
+#ifdef DEBUG_CDDB
+	cddb_cache_disable(cddb_conn);
+#endif
+
+	http_free_uri(&http_uri);
+}
+#endif
+
+
+#define add_comment(c, x)	do { if (x) comments_add_const(c, #x, x); } while (0)
+
+static int libcdio_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct cdda_private *priv = ip_data->private;
+	GROWING_KEYVALS(c);
+	const char *artist = NULL, *albumartist = NULL, *album = NULL,
+		*title = NULL, *genre = NULL, *comment = NULL;
+	const cdtext_t *cdt;
+#ifdef HAVE_CDDB
+	bool track_comments_found = false;
+	cddb_conn_t *cddb_conn = NULL;
+	cddb_disc_t *cddb_disc = NULL;
+#endif
+	char buf[64];
+
+#if LIBCDIO_VERSION_NUM >= 90
+	cdt = cdio_get_cdtext(priv->cdio);
+	if (cdt) {
+		artist = cdtext_get(cdt, CDTEXT_FIELD_PERFORMER, priv->track);
+		title = cdtext_get(cdt, CDTEXT_FIELD_TITLE, priv->track);
+		genre = cdtext_get(cdt, CDTEXT_FIELD_GENRE, priv->track);
+		comment = cdtext_get(cdt, CDTEXT_FIELD_MESSAGE, priv->track);
+
+#ifdef HAVE_CDDB
+		if (title)
+			track_comments_found = true;
+#endif
+
+		album = cdtext_get(cdt, CDTEXT_FIELD_TITLE, 0);
+		albumartist = cdtext_get(cdt, CDTEXT_FIELD_PERFORMER, 0);
+		if (!artist)
+			artist = albumartist;
+		if (!genre)
+			genre = cdtext_get(cdt, CDTEXT_FIELD_GENRE, 0);
+		if (!comment)
+			comment = cdtext_get(cdt, CDTEXT_FIELD_MESSAGE, 0);
+	}
+#else
+	cdt = cdio_get_cdtext(priv->cdio, priv->track);
+	if (cdt) {
+		char * const *field = cdt->field;
+		artist = field[CDTEXT_PERFORMER];
+		title = field[CDTEXT_TITLE];
+		genre = field[CDTEXT_GENRE];
+		comment = field[CDTEXT_MESSAGE];
+#ifdef HAVE_CDDB
+		track_comments_found = true;
+#endif
+	}
+	cdt = cdio_get_cdtext(priv->cdio, 0);
+	if (cdt) {
+		char * const *field = cdt->field;
+		album = field[CDTEXT_TITLE];
+		albumartist = field[CDTEXT_PERFORMER];
+		if (!artist)
+			artist = field[CDTEXT_PERFORMER];
+		if (!genre)
+			genre = field[CDTEXT_GENRE];
+		if (!comment)
+			comment = field[CDTEXT_MESSAGE];
+	}
+#endif
+
+#ifdef HAVE_CDDB
+	if (!track_comments_found && cddb_url && cddb_url[0]) {
+		cddb_track_t *cddb_track;
+		track_t i_tracks = cdio_get_num_tracks(priv->cdio);
+		track_t i_first_track = cdio_get_first_track_num(priv->cdio);
+		unsigned int year;
+		int i;
+
+		cddb_conn = cddb_new();
+		if (!cddb_conn)
+			malloc_fail();
+
+		setup_cddb_conn(cddb_conn);
+
+		cddb_disc = cddb_disc_new();
+		if (!cddb_disc)
+			malloc_fail();
+		for (i = 0; i < i_tracks; i++) {
+			cddb_track = cddb_track_new();
+			if (!cddb_track)
+				malloc_fail();
+			cddb_track_set_frame_offset(cddb_track,
+					cdio_get_track_lba(priv->cdio, i+i_first_track));
+			cddb_disc_add_track(cddb_disc, cddb_track);
+		}
+
+		cddb_disc_set_length(cddb_disc, cdio_get_track_lba(priv->cdio,
+					CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC);
+		if (cddb_query(cddb_conn, cddb_disc) == 1 && cddb_read(cddb_conn, cddb_disc)) {
+			albumartist = cddb_disc_get_artist(cddb_disc);
+			album = cddb_disc_get_title(cddb_disc);
+			genre = cddb_disc_get_genre(cddb_disc);
+			year = cddb_disc_get_year(cddb_disc);
+			if (year) {
+				sprintf(buf, "%u", year);
+				comments_add_const(&c, "date", buf);
+			}
+			cddb_track = cddb_disc_get_track(cddb_disc, priv->track - 1);
+			artist = cddb_track_get_artist(cddb_track);
+			if (!artist)
+				artist = albumartist;
+			title = cddb_track_get_title(cddb_track);
+		}
+	}
+#endif
+
+	add_comment(&c, artist);
+	add_comment(&c, albumartist);
+	add_comment(&c, album);
+	add_comment(&c, title);
+	add_comment(&c, genre);
+	add_comment(&c, comment);
+
+	sprintf(buf, "%02d", priv->track);
+	comments_add_const(&c, "tracknumber", buf);
+
+#ifdef HAVE_CDDB
+	if (cddb_disc)
+		cddb_disc_destroy(cddb_disc);
+	if (cddb_conn)
+		cddb_destroy(cddb_conn);
+#endif
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int libcdio_duration(struct input_plugin_data *ip_data)
+{
+	struct cdda_private *priv = ip_data->private;
+
+	return (priv->last_lsn - priv->first_lsn) / CDIO_CD_FRAMES_PER_SEC;
+}
+
+static long libcdio_bitrate(struct input_plugin_data *ip_data)
+{
+	return 44100 * 16 * 2;
+}
+
+static char *libcdio_codec(struct input_plugin_data *ip_data)
+{
+	return xstrdup("cdda");
+}
+
+static char *libcdio_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct cdda_private *priv = ip_data->private;
+	discmode_t cd_discmode = cdio_get_discmode(priv->cdio);
+
+	return xstrdup(discmode2str[cd_discmode]);
+}
+
+#ifdef HAVE_CDDB
+static int libcdio_set_cddb_url(const char *val)
+{
+	struct http_uri http_uri;
+	int use_http;
+	if (!parse_cddb_url(val, &http_uri, &use_http))
+		return -IP_ERROR_INVALID_URI;
+	http_free_uri(&http_uri);
+	free(cddb_url);
+	cddb_url = xstrdup(val);
+	return 0;
+}
+
+static int libcdio_get_cddb_url(char **val)
+{
+	if (!cddb_url)
+		cddb_url = xstrdup("freedb.freedb.org:8880");
+	*val = xstrdup(cddb_url);
+	return 0;
+}
+#endif
+
+const struct input_plugin_ops ip_ops = {
+	.open = libcdio_open,
+	.close = libcdio_close,
+	.read = libcdio_read,
+	.seek = libcdio_seek,
+	.read_comments = libcdio_read_comments,
+	.duration = libcdio_duration,
+	.bitrate = libcdio_bitrate,
+	.codec = libcdio_codec,
+	.codec_profile = libcdio_codec_profile,
+};
+
+const struct input_plugin_opt ip_options[] = {
+#ifdef HAVE_CDDB
+	{ "cddb_url", libcdio_set_cddb_url, libcdio_get_cddb_url },
+#endif
+	{ NULL },
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = { NULL };
+const char * const ip_mime_types[] = { "x-content/audio-cdda", NULL };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/cue.c

@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2008-2013 Various Authors
+ * Copyright (C) 2011 Gregory Petrosyan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../debug.h"
+#include "../input.h"
+#include "../utils.h"
+#include "../comment.h"
+#include "../xmalloc.h"
+#include "../cue_utils.h"
+#include "../cue.h"
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <math.h>
+
+struct cue_private {
+	struct input_plugin *child;
+
+	char *cue_filename;
+	int track_n;
+
+	double start_offset;
+	double current_offset;
+	double end_offset;
+};
+
+
+static int _parse_cue_url(const char *url, char **filename, int *track_n)
+{
+	const char *slash;
+	long n;
+
+	if (!is_cue_url(url))
+		return 1;
+
+	url += 6;
+
+	slash = strrchr(url, '/');
+	if (!slash)
+		return 1;
+
+	if (str_to_int(slash + 1, &n) != 0)
+		return 1;
+
+	*filename = xstrndup(url, slash - url);
+	*track_n = n;
+	return 0;
+}
+
+
+static char *_make_absolute_path(const char *abs_filename, const char *rel_filename)
+{
+	char *s;
+	const char *slash;
+	char buf[4096] = {0};
+
+	slash = strrchr(abs_filename, '/');
+	if (slash == NULL)
+		return xstrdup(rel_filename);
+
+	s = xstrndup(abs_filename, slash - abs_filename);
+	snprintf(buf, sizeof(buf), "%s/%s", s, rel_filename);
+
+	free(s);
+	return xstrdup(buf);
+}
+
+
+static int cue_open(struct input_plugin_data *ip_data)
+{
+	int rc;
+	char *child_filename;
+	struct cue_sheet *cd;
+	struct cue_track *t;
+	struct cue_private *priv;
+
+	priv = xnew(struct cue_private, 1);
+
+	rc = _parse_cue_url(ip_data->filename, &priv->cue_filename, &priv->track_n);
+	if (rc) {
+		rc = -IP_ERROR_INVALID_URI;
+		goto url_parse_failed;
+	}
+
+	cd = cue_from_file(priv->cue_filename);
+	if (cd == NULL) {
+		rc = -IP_ERROR_FILE_FORMAT;
+		goto cue_parse_failed;
+	}
+
+	t = cue_get_track(cd, priv->track_n);
+	if (!t) {
+		rc = -IP_ERROR_FILE_FORMAT;
+		goto cue_read_failed;
+	}
+
+	child_filename = _make_absolute_path(priv->cue_filename, t->file);
+	priv->child = ip_new(child_filename);
+	free(child_filename);
+
+	rc = ip_open(priv->child);
+	if (rc)
+		goto ip_open_failed;
+
+	ip_setup(priv->child);
+
+	priv->start_offset = t->offset;
+	priv->current_offset = t->offset;
+
+	rc = ip_seek(priv->child, priv->start_offset);
+	if (rc)
+		goto ip_open_failed;
+
+	if (t->length >= 0)
+		priv->end_offset = priv->start_offset + t->length;
+	else
+		priv->end_offset = -1;
+
+	ip_data->fd = open(ip_get_filename(priv->child), O_RDONLY);
+	if (ip_data->fd == -1)
+		goto ip_open_failed;
+
+	ip_data->private = priv;
+	ip_data->sf = ip_get_sf(priv->child);
+	ip_get_channel_map(priv->child, ip_data->channel_map);
+
+	cue_free(cd);
+	return 0;
+
+ip_open_failed:
+	ip_delete(priv->child);
+
+cue_read_failed:
+	cue_free(cd);
+
+cue_parse_failed:
+	free(priv->cue_filename);
+
+url_parse_failed:
+	free(priv);
+
+	return rc;
+}
+
+
+static int cue_close(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+
+	close(ip_data->fd);
+	ip_data->fd = -1;
+
+	ip_delete(priv->child);
+	free(priv->cue_filename);
+
+	free(priv);
+	ip_data->private = NULL;
+
+	return 0;
+}
+
+
+static int cue_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	int rc;
+	struct cue_private *priv = ip_data->private;
+
+	if (priv->end_offset >= 0.0 && priv->current_offset >= priv->end_offset)
+		return 0;
+
+	rc = ip_read(priv->child, buffer, count);
+	if (rc <= 0)
+		return rc;
+
+	if (priv->end_offset >= 0.0) {
+		sample_format_t sf = ip_get_sf(priv->child);
+		double len = (double)rc / sf_get_second_size(sf);
+
+		double rem_len = priv->end_offset - priv->current_offset;
+		priv->current_offset += len;
+
+		if (priv->current_offset >= priv->end_offset)
+			rc = lround(rem_len * sf_get_rate(sf)) * sf_get_frame_size(sf);
+	}
+
+	return rc;
+}
+
+
+static int cue_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct cue_private *priv = ip_data->private;
+	double new_offset = priv->start_offset + offset;
+
+	if (priv->end_offset >= 0.0 && new_offset > priv->end_offset)
+		new_offset = priv->end_offset;
+
+	priv->current_offset = new_offset;
+
+	return ip_seek(priv->child, new_offset);
+}
+
+
+static int cue_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct cue_private *priv = ip_data->private;
+	struct cue_sheet *cd = cue_from_file(priv->cue_filename);
+	struct cue_track *t;
+	int rc;
+	char buf[32] = { 0 };
+	GROWING_KEYVALS(c);
+
+	if (cd == NULL) {
+		rc = -IP_ERROR_FILE_FORMAT;
+		goto cue_parse_failed;
+	}
+
+	t = cue_get_track(cd, priv->track_n);
+	if (!t) {
+		rc = -IP_ERROR_FILE_FORMAT;
+		goto get_track_failed;
+	}
+
+	snprintf(buf, sizeof(buf), "%d", priv->track_n);
+	comments_add_const(&c, "tracknumber", buf);
+
+	if (t->meta.title)
+		comments_add_const(&c, "title", t->meta.title);
+	if (cd->meta.title)
+		comments_add_const(&c, "album", cd->meta.title);
+	if (t->meta.performer)
+		comments_add_const(&c, "artist", t->meta.performer);
+	if (cd->meta.performer)
+		comments_add_const(&c, "albumartist", cd->meta.performer);
+	if (t->meta.date)
+		comments_add_const(&c, "date", t->meta.date);
+	else if (cd->meta.date)
+		comments_add_const(&c, "date", cd->meta.date);
+	if (cd->meta.compilation)
+		comments_add_const(&c, "compilation", cd->meta.compilation);
+	if (cd->meta.discnumber)
+		comments_add_const(&c, "discnumber", cd->meta.discnumber);
+	if (t->meta.genre)
+		comments_add_const(&c, "genre", t->meta.genre);
+	else if (cd->meta.genre)
+		comments_add_const(&c, "genre", cd->meta.genre);
+
+	if (cd->meta.rg_gain)
+		comments_add_const(&c, "replaygain_album_gain", cd->meta.rg_gain);
+	if (cd->meta.rg_peak)
+		comments_add_const(&c, "replaygain_album_peak", cd->meta.rg_peak);
+	if (t->meta.rg_gain)
+		comments_add_const(&c, "replaygain_track_gain", t->meta.rg_gain);
+	if (t->meta.rg_peak)
+		comments_add_const(&c, "replaygain_track_peak", t->meta.rg_peak);
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+
+	cue_free(cd);
+	return 0;
+
+get_track_failed:
+	cue_free(cd);
+
+cue_parse_failed:
+	return rc;
+}
+
+
+static int cue_duration(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+	if (priv->end_offset < 0.0)
+		return ip_duration(priv->child) - priv->start_offset;
+	else
+		return priv->end_offset - priv->start_offset;
+}
+
+
+static long cue_bitrate(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+
+	return ip_bitrate(priv->child);
+}
+
+
+static long cue_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+
+	return ip_current_bitrate(priv->child);
+}
+
+
+static char *cue_codec(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+
+	return ip_codec(priv->child);
+}
+
+
+static char *cue_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct cue_private *priv = ip_data->private;
+
+	return ip_codec_profile(priv->child);
+}
+
+
+const struct input_plugin_ops ip_ops = {
+	.open            = cue_open,
+	.close           = cue_close,
+	.read            = cue_read,
+	.seek            = cue_seek,
+	.read_comments   = cue_read_comments,
+	.duration        = cue_duration,
+	.bitrate         = cue_bitrate,
+	.bitrate_current = cue_current_bitrate,
+	.codec           = cue_codec,
+	.codec_profile   = cue_codec_profile,
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = { "cue", NULL };
+const char * const ip_mime_types[] = { "application/x-cue", NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/ffmpeg.c

@@ -0,0 +1,552 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2007 Kevin Ko <kevin.s.ko@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../xmalloc.h"
+#include "../debug.h"
+#include "../utils.h"
+#include "../comment.h"
+#ifdef HAVE_CONFIG
+#include "../config/ffmpeg.h"
+#endif
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavformat/avio.h>
+#include <libswresample/swresample.h>
+#include <libavutil/opt.h>
+#include <libavutil/channel_layout.h>
+#ifndef AVUTIL_MATHEMATICS_H
+#include <libavutil/mathematics.h>
+#endif
+
+struct ffmpeg_private {
+	AVCodecContext *codec_ctx;
+	AVFormatContext *format_ctx;
+	AVCodec const *codec;
+	SwrContext *swr;
+	int stream_index;
+
+	AVPacket *pkt;
+	AVFrame *frame;
+	double seek_ts;
+	int64_t skip_samples;
+
+	/* A buffer to hold swr_convert()-ed samples */
+	AVFrame *swr_frame;
+	int swr_frame_samples_cap;
+	int swr_frame_start;
+
+	/* Bitrate estimation */
+	unsigned long curr_size;
+	unsigned long curr_duration;
+};
+
+static const char *ffmpeg_errmsg(int err)
+{
+	static char errstr[AV_ERROR_MAX_STRING_SIZE];
+	av_strerror(err, errstr, AV_ERROR_MAX_STRING_SIZE);
+	return errstr;
+}
+
+static void ffmpeg_init(void)
+{
+	static int inited = 0;
+
+	if (inited != 0)
+		return;
+	inited = 1;
+
+	av_log_set_level(AV_LOG_QUIET);
+
+#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(58, 9, 100)
+	/* We could register decoders explicitly to save memory, but we have to
+	 * be careful about compatibility. */
+	av_register_all();
+#endif
+}
+
+static int ffmpeg_open_input(struct input_plugin_data *ip_data,
+		struct ffmpeg_private *priv)
+{
+	AVFormatContext *ic = NULL;
+	AVCodecContext *cc = NULL;
+	AVCodecParameters *cp = NULL;
+	AVCodec const *codec = NULL;
+	int stream_index = -1;
+
+	int err;
+	int res = avformat_open_input(&ic, ip_data->filename, NULL, NULL);
+	if (res < 0) {
+		err = -IP_ERROR_FILE_FORMAT;
+		goto err;
+	}
+
+	res = avformat_find_stream_info(ic, NULL);
+	if (res < 0) {
+		d_print("unable to find stream info\n");
+		err = -IP_ERROR_FILE_FORMAT;
+		goto err;
+	}
+
+	for (int i = 0; i < ic->nb_streams; i++) {
+		cp = ic->streams[i]->codecpar;
+		if (cp->codec_type == AVMEDIA_TYPE_AUDIO) {
+			stream_index = i;
+			break;
+		}
+	}
+
+	if (stream_index == -1) {
+		d_print("could not find audio stream\n");
+		err = -IP_ERROR_FILE_FORMAT;
+		goto err_silent;
+	}
+
+	codec = avcodec_find_decoder(cp->codec_id);
+	if (!codec) {
+		d_print("codec (id: %d, name: %s) not found\n",
+				cc->codec_id, avcodec_get_name(cc->codec_id));
+		err = -IP_ERROR_UNSUPPORTED_FILE_TYPE;
+		goto err_silent;
+	}
+	cc = avcodec_alloc_context3(codec);
+	avcodec_parameters_to_context(cc, cp);
+
+	res = avcodec_open2(cc, codec, NULL);
+	if (res < 0) {
+		d_print("could not open codec (id: %d, name: %s)\n",
+				cc->codec_id, avcodec_get_name(cc->codec_id));
+		err = -IP_ERROR_UNSUPPORTED_FILE_TYPE;
+		goto err;
+	}
+
+	priv->format_ctx = ic;
+	priv->codec_ctx = cc;
+	priv->codec = codec;
+	priv->stream_index = stream_index;
+	return 0;
+err:
+	d_print("%s\n", ffmpeg_errmsg(res));
+err_silent:
+	avcodec_free_context(&cc);
+	avformat_close_input(&ic);
+	return err;
+}
+
+static void ffmpeg_set_sf_and_swr_opts(SwrContext *swr, AVCodecContext *cc,
+		sample_format_t *sf_out, enum AVSampleFormat *out_sample_fmt)
+{
+	int out_sample_rate = min_u(cc->sample_rate, 384000);
+	sample_format_t sf = sf_rate(out_sample_rate) | sf_host_endian();
+	av_opt_set_int(swr, "in_sample_rate", cc->sample_rate, 0);
+	av_opt_set_int(swr, "out_sample_rate", out_sample_rate, 0);
+
+	switch (cc->sample_fmt) {
+		case AV_SAMPLE_FMT_FLT: case AV_SAMPLE_FMT_FLTP:
+		case AV_SAMPLE_FMT_S32: case AV_SAMPLE_FMT_S32P:
+			sf |= sf_bits(32) | sf_signed(1);
+			*out_sample_fmt = AV_SAMPLE_FMT_S32;
+			break;
+		default:
+			sf |= sf_bits(16) | sf_signed(1);
+			*out_sample_fmt = AV_SAMPLE_FMT_S16;
+	}
+	av_opt_set_sample_fmt(swr, "in_sample_fmt", cc->sample_fmt, 0);
+	av_opt_set_sample_fmt(swr, "out_sample_fmt", *out_sample_fmt, 0);
+
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 24, 100)
+	sf |= sf_channels(cc->ch_layout.nb_channels);
+
+	if (cc->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
+		av_channel_layout_default(&cc->ch_layout, cc->ch_layout.nb_channels);
+	av_opt_set_chlayout(swr, "in_chlayout", &cc->ch_layout, 0);
+	av_opt_set_chlayout(swr, "out_chlayout", &cc->ch_layout, 0);
+#else
+	sf |= sf_channels(cc->channels);
+
+	av_opt_set_int(swr, "in_channel_layout",
+			av_get_default_channel_layout(cc->channels), 0);
+	av_opt_set_int(swr, "out_channel_layout",
+			av_get_default_channel_layout(cc->channels), 0);
+#endif
+
+	*sf_out = sf;
+}
+
+static int ffmpeg_init_swr_frame(struct ffmpeg_private *priv,
+		sample_format_t sf, enum AVSampleFormat out_sample_fmt)
+{
+	AVCodecContext *cc = priv->codec_ctx;
+	AVFrame *frame = av_frame_alloc();
+
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 24, 100)
+	av_channel_layout_copy(&frame->ch_layout, &cc->ch_layout);
+#else
+	frame->channel_layout = av_get_default_channel_layout(cc->channels);
+#endif
+
+	frame->sample_rate = sf_get_rate(sf);
+	frame->format = out_sample_fmt;
+
+	/* NOTE: 10 sec is probably too much, but the amount of space
+	 * needed for swr_convert() is unpredictable */
+	frame->nb_samples = 10 * sf_get_rate(sf);
+	int res = av_frame_get_buffer(frame, 0);
+	if (res < 0) {
+		d_print("av_frame_get_buffer(): %s\n", ffmpeg_errmsg(res));
+		return -IP_ERROR_INTERNAL;
+	}
+	priv->swr_frame_samples_cap = frame->nb_samples;
+	frame->nb_samples = 0;
+
+	priv->swr_frame = frame;
+	return 0;
+}
+
+static void ffmpeg_free(struct ffmpeg_private *priv)
+{
+	avcodec_free_context(&priv->codec_ctx);
+	avformat_close_input(&priv->format_ctx);
+
+	swr_free(&priv->swr);
+
+	av_frame_free(&priv->frame);
+	av_packet_free(&priv->pkt);
+	av_frame_free(&priv->swr_frame);
+}
+
+static int ffmpeg_open(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private priv;
+	enum AVSampleFormat out_sample_fmt;
+	memset(&priv, 0, sizeof(struct ffmpeg_private));
+
+	ffmpeg_init();
+
+	int err = ffmpeg_open_input(ip_data, &priv);
+	if (err < 0)
+		return err;
+
+	priv.pkt = av_packet_alloc();
+	priv.frame = av_frame_alloc();
+	priv.seek_ts = -1;
+
+	priv.swr = swr_alloc();
+	ffmpeg_set_sf_and_swr_opts(priv.swr, priv.codec_ctx,
+			&ip_data->sf, &out_sample_fmt);
+	swr_init(priv.swr);
+
+	err = ffmpeg_init_swr_frame(&priv, ip_data->sf, out_sample_fmt);
+	if (err < 0) {
+		ffmpeg_free(&priv);
+		return err;
+	}
+
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 24, 100)
+	channel_map_init_waveex(priv.codec_ctx->ch_layout.nb_channels,
+			priv.codec_ctx->ch_layout.u.mask, ip_data->channel_map);
+#else
+	channel_map_init_waveex(priv.codec_ctx->channels,
+			priv.codec_ctx->channel_layout, ip_data->channel_map);
+#endif
+
+	ip_data->private = xnew(struct ffmpeg_private, 1);
+	memcpy(ip_data->private, &priv, sizeof(struct ffmpeg_private));
+	return 0;
+}
+
+static int ffmpeg_close(struct input_plugin_data *ip_data)
+{
+	ffmpeg_free(ip_data->private);
+	free(ip_data->private);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int64_t ffmpeg_calc_skip_samples(struct ffmpeg_private *priv)
+{
+	int64_t ts;
+	if (priv->frame->pts >= 0) {
+		ts = priv->frame->pts;
+	} else if (priv->frame->pkt_dts >= 0) {
+		ts = priv->frame->pkt_dts;
+	} else {
+		d_print("AVFrame.pts and AVFrame.pkt_dts are unset\n");
+		return -1;
+	}
+
+	AVStream *s = priv->format_ctx->streams[priv->stream_index];
+	double frame_ts = ts * av_q2d(s->time_base);
+
+	d_print("seek_ts: %.6fs, frame_ts: %.6fs\n", priv->seek_ts, frame_ts);
+
+	if (frame_ts >= priv->seek_ts)
+		return 0;
+	return (priv->seek_ts - frame_ts) * priv->frame->sample_rate;
+}
+
+static void ffmpeg_skip_frame_part(struct ffmpeg_private *priv)
+{
+	if (priv->skip_samples >= priv->frame->nb_samples) {
+		d_print("skipping frame: %d samples\n",
+				priv->frame->nb_samples);
+		priv->skip_samples -= priv->frame->nb_samples;
+		priv->frame->nb_samples = 0;
+		return;
+	}
+
+	int bps = av_get_bytes_per_sample(priv->frame->format);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 24, 100)
+	int channels = priv->codec_ctx->ch_layout.nb_channels;
+#else
+	int channels = priv->codec_ctx->channels;
+#endif
+
+	priv->frame->nb_samples -= priv->skip_samples;
+
+	/* Just modify frame's data pointer because it's throw-away */
+	if (av_sample_fmt_is_planar(priv->frame->format)) {
+		for (int i = 0; i < channels; i++)
+			priv->frame->extended_data[i] += priv->skip_samples * bps;
+	} else {
+		priv->frame->extended_data[0] += priv->skip_samples * channels * bps;
+	}
+	d_print("skipping %lld samples\n", (long long)priv->skip_samples);
+	priv->skip_samples = 0;
+}
+
+/*
+ * return:
+ *   <0 - error
+ *    0 - eof
+ *   >0 - ok
+ */
+static int ffmpeg_get_frame(struct ffmpeg_private *priv)
+{
+	int res;
+retry:
+	res = avcodec_receive_frame(priv->codec_ctx, priv->frame);
+	if (res == AVERROR(EAGAIN)) {
+		av_packet_unref(priv->pkt);
+		res = av_read_frame(priv->format_ctx, priv->pkt);
+		if (res < 0)
+			goto err;
+
+		if (priv->pkt->stream_index != priv->stream_index)
+			goto retry;
+
+		priv->curr_size += priv->pkt->size;
+		priv->curr_duration += priv->pkt->duration;
+
+		res = avcodec_send_packet(priv->codec_ctx, priv->pkt);
+		if (res == 0 || res == AVERROR(EAGAIN))
+			goto retry;
+	}
+	if (res < 0)
+		goto err;
+
+	if (priv->seek_ts > 0) {
+		priv->skip_samples = ffmpeg_calc_skip_samples(priv);
+		if (priv->skip_samples >= 0)
+			priv->seek_ts = -1;
+	}
+
+	if (priv->skip_samples > 0) {
+		ffmpeg_skip_frame_part(priv);
+		if (priv->frame->nb_samples == 0)
+			goto retry;
+	}
+	return 1;
+err:
+	if (res == AVERROR_EOF)
+		return 0;
+	d_print("%s\n", ffmpeg_errmsg(res));
+	return -IP_ERROR_INTERNAL;
+}
+
+static int ffmpeg_convert_frame(struct ffmpeg_private *priv)
+{
+	int res = swr_convert(priv->swr,
+			priv->swr_frame->extended_data,
+			priv->swr_frame_samples_cap,
+			(const uint8_t **)priv->frame->extended_data,
+			priv->frame->nb_samples);
+	if (res >= 0) {
+		priv->swr_frame->nb_samples = res;
+		priv->swr_frame_start = 0;
+		return res;
+	}
+	d_print("%s\n", ffmpeg_errmsg(res));
+	return -IP_ERROR_INTERNAL;
+}
+
+static int ffmpeg_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	int written = 0;
+	int res;
+
+	count /= sf_get_frame_size(ip_data->sf);
+
+	while (count) {
+		if (priv->swr_frame->nb_samples == 0) {
+			res = ffmpeg_get_frame(priv);
+			if (res == 0)
+				break;
+			else if (res < 0)
+				return res;
+
+			res = ffmpeg_convert_frame(priv);
+			if (res < 0)
+				return res;
+		}
+
+		int copy_frames = min_i(count, priv->swr_frame->nb_samples);
+		int copy_bytes = copy_frames * sf_get_frame_size(ip_data->sf);
+		void *dst = priv->swr_frame->extended_data[0] + priv->swr_frame_start;
+		memcpy(buffer + written, dst, copy_bytes);
+
+		priv->swr_frame->nb_samples -= copy_frames;
+		priv->swr_frame_start += copy_bytes;
+		count -= copy_frames;
+		written += copy_bytes;
+	}
+	return written;
+}
+
+static int ffmpeg_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	AVStream *st = priv->format_ctx->streams[priv->stream_index];
+
+	priv->seek_ts = offset;
+	priv->skip_samples = 0;
+	int64_t ts = offset / av_q2d(st->time_base);
+
+	int ret = avformat_seek_file(priv->format_ctx,
+			priv->stream_index, 0, ts, ts, 0);
+	if (ret < 0)
+		return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+
+	priv->swr_frame->nb_samples = 0;
+	priv->swr_frame_start = 0;
+	avcodec_flush_buffers(priv->codec_ctx);
+	swr_convert(priv->swr, NULL, 0, NULL, 0); /* flush swr buffer */
+	return 0;
+}
+
+static void ffmpeg_read_metadata(struct growing_keyvals *c, AVDictionary *metadata)
+{
+	AVDictionaryEntry *tag = NULL;
+
+	while ((tag = av_dict_get(metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+		if (tag->value[0])
+			comments_add_const(c, tag->key, tag->value);
+	}
+}
+
+static int ffmpeg_read_comments(struct input_plugin_data *ip_data,
+		struct keyval **comments)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	AVFormatContext *ic = priv->format_ctx;
+
+	GROWING_KEYVALS(c);
+
+	ffmpeg_read_metadata(&c, ic->metadata);
+	for (unsigned i = 0; i < ic->nb_streams; i++) {
+		ffmpeg_read_metadata(&c, ic->streams[i]->metadata);
+	}
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+
+	return 0;
+}
+
+static int ffmpeg_duration(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	return priv->format_ctx->duration / AV_TIME_BASE;
+}
+
+static long ffmpeg_bitrate(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	long bitrate = priv->format_ctx->bit_rate;
+	return bitrate ? bitrate : -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long ffmpeg_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	AVStream *st = priv->format_ctx->streams[priv->stream_index];
+	long bitrate = -1;
+	/* ape codec returns silly numbers */
+	if (priv->codec->id == AV_CODEC_ID_APE)
+		return -1;
+	if (priv->curr_duration > 0) {
+		double seconds = priv->curr_duration * av_q2d(st->time_base);
+		bitrate = (8 * priv->curr_size) / seconds;
+		priv->curr_size = 0;
+		priv->curr_duration = 0;
+	}
+	return bitrate;
+}
+
+static char *ffmpeg_codec(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	return xstrdup(priv->codec->name);
+}
+
+static char *ffmpeg_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct ffmpeg_private *priv = ip_data->private;
+	const char *profile;
+	profile = av_get_profile_name(priv->codec, priv->codec_ctx->profile);
+	return profile ? xstrdup(profile) : NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = ffmpeg_open,
+	.close = ffmpeg_close,
+	.read = ffmpeg_read,
+	.seek = ffmpeg_seek,
+	.read_comments = ffmpeg_read_comments,
+	.duration = ffmpeg_duration,
+	.bitrate = ffmpeg_bitrate,
+	.bitrate_current = ffmpeg_current_bitrate,
+	.codec = ffmpeg_codec,
+	.codec_profile = ffmpeg_codec_profile
+};
+
+const int ip_priority = 30;
+const char *const ip_extensions[] = {
+	"aa", "aac", "ac3", "aif", "aifc", "aiff", "ape", "au", "dsf", "fla",
+	"flac", "m4a", "m4b", "mka", "mkv", "mp+", "mp2", "mp3", "mp4", "mpc",
+	"mpp", "ogg", "opus", "shn", "tak", "tta", "wav", "webm", "wma", "wv",
+#ifdef USE_FALLBACK_IP
+	"*",
+#endif
+	NULL
+};
+const char *const ip_mime_types[] = { NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/flac.c

@@ -0,0 +1,519 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../comment.h"
+#include "../xmalloc.h"
+#include "../debug.h"
+#include "../utils.h"
+
+#include <FLAC/export.h>
+#include <FLAC/stream_decoder.h>
+#include <FLAC/metadata.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+#ifndef UINT64_MAX
+#define UINT64_MAX ((uint64_t)-1)
+#endif
+
+/* Reduce typing.  Namespaces are nice but FLAC API is fscking ridiculous.  */
+
+/* functions, types, enums */
+#define F(s) FLAC__stream_decoder_ ## s
+#define T(s) FLAC__StreamDecoder ## s
+#define Dec FLAC__StreamDecoder
+#define E(s) FLAC__STREAM_DECODER_ ## s
+
+#define FLAC_MAX_CHANNELS 8
+
+struct flac_private {
+	/* file/stream position and length */
+	uint64_t pos;
+	uint64_t len;
+
+	Dec *dec;
+
+	/* PCM data */
+	char *buf;
+	unsigned int buf_size;
+	unsigned int buf_wpos;
+	unsigned int buf_rpos;
+
+	struct keyval *comments;
+	double duration;
+	long bitrate;
+	int bps;
+};
+
+static T(ReadStatus) read_cb(const Dec *dec, unsigned char *buf, size_t *size, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+	int rc;
+
+	if (priv->pos == priv->len) {
+		*size = 0;
+		return E(READ_STATUS_END_OF_STREAM);
+	}
+	if (*size == 0)
+		return E(READ_STATUS_CONTINUE);
+
+	rc = read(ip_data->fd, buf, *size);
+	if (rc == -1) {
+		*size = 0;
+		if (errno == EINTR || errno == EAGAIN) {
+			/* FIXME: not sure how the flac decoder handles this */
+			d_print("interrupted\n");
+			return E(READ_STATUS_CONTINUE);
+		}
+		return E(READ_STATUS_ABORT);
+	}
+
+	priv->pos += rc;
+	*size = rc;
+	if (rc == 0) {
+		/* should not happen */
+		return E(READ_STATUS_END_OF_STREAM);
+	}
+	return E(READ_STATUS_CONTINUE);
+}
+
+static T(SeekStatus) seek_cb(const Dec *dec, uint64_t offset, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+	off_t off;
+
+	if (priv->len == UINT64_MAX)
+		return E(SEEK_STATUS_ERROR);
+	off = lseek(ip_data->fd, offset, SEEK_SET);
+	if (off == -1) {
+		return E(SEEK_STATUS_ERROR);
+	}
+	priv->pos = off;
+	return E(SEEK_STATUS_OK);
+}
+
+static T(TellStatus) tell_cb(const Dec *dec, uint64_t *offset, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+
+	*offset = priv->pos;
+	return E(TELL_STATUS_OK);
+}
+
+static T(LengthStatus) length_cb(const Dec *dec, uint64_t *len, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+
+	if (ip_data->remote) {
+		return E(LENGTH_STATUS_ERROR);
+	}
+	*len = priv->len;
+	return E(LENGTH_STATUS_OK);
+}
+
+static int eof_cb(const Dec *dec, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+
+	return priv->pos == priv->len;;
+}
+
+#if defined(WORDS_BIGENDIAN)
+
+#define LE32(x) swap_uint32(x)
+
+#else
+
+#define LE32(x)	(x)
+
+#endif
+
+static FLAC__StreamDecoderWriteStatus write_cb(const Dec *dec, const FLAC__Frame *frame,
+		const int32_t * const *buf, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+	int frames, bytes, size, channels, bits, depth;
+	int ch, nch, i = 0;
+	char *dest; int32_t src;
+
+	frames = frame->header.blocksize;
+	channels = sf_get_channels(ip_data->sf);
+	bits = sf_get_bits(ip_data->sf);
+	bytes = frames * bits / 8 * channels;
+	size = priv->buf_size;
+
+	if (size - priv->buf_wpos < bytes) {
+		if (size < bytes)
+			size = bytes;
+		size *= 2;
+		priv->buf = xrenew(char, priv->buf, size);
+		priv->buf_size = size;
+	}
+
+	depth = frame->header.bits_per_sample;
+	if (!depth)
+		depth = priv->bps;
+	nch = frame->header.channels;
+	dest = priv->buf + priv->buf_wpos;
+	for (i = 0; i < frames; i++) {
+		for (ch = 0; ch < channels; ch++) {
+			src = LE32(buf[ch % nch][i] << (bits - depth));
+			memcpy(dest, &src, bits / 8);
+			dest += bits / 8;
+		}
+	}
+
+	priv->buf_wpos += bytes;
+	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
+}
+
+/* You should make a copy of metadata with FLAC__metadata_object_clone() if you will
+ * need it elsewhere. Since metadata blocks can potentially be large, by
+ * default the decoder only calls the metadata callback for the STREAMINFO
+ * block; you can instruct the decoder to pass or filter other blocks with
+ * FLAC__stream_decoder_set_metadata_*() calls.
+ */
+static void metadata_cb(const Dec *dec, const FLAC__StreamMetadata *metadata, void *data)
+{
+	struct input_plugin_data *ip_data = data;
+	struct flac_private *priv = ip_data->private;
+
+	switch (metadata->type) {
+	case FLAC__METADATA_TYPE_STREAMINFO:
+		{
+			const FLAC__StreamMetadata_StreamInfo *si = &metadata->data.stream_info;
+			int bits = 0;
+
+			if (si->bits_per_sample >= 4 && si->bits_per_sample <= 32) {
+				bits = priv->bps = si->bits_per_sample;
+				bits = 8 * ((bits + 7) / 8);
+			}
+
+			ip_data->sf = sf_rate(si->sample_rate) |
+				sf_bits(bits) |
+				sf_signed(1) |
+				sf_channels(si->channels);
+			if (!ip_data->remote && si->total_samples) {
+				priv->duration = (double) si->total_samples / si->sample_rate;
+				if (priv->duration >= 1 && priv->len >= 1)
+					priv->bitrate = priv->len * 8 / priv->duration;
+			}
+		}
+		break;
+	case FLAC__METADATA_TYPE_VORBIS_COMMENT:
+		if (priv->comments) {
+			d_print("Ignoring VORBISCOMMENT\n");
+		} else {
+			GROWING_KEYVALS(c);
+			int i, nr;
+
+			nr = metadata->data.vorbis_comment.num_comments;
+			for (i = 0; i < nr; i++) {
+				const char *str = (const char *)metadata->data.vorbis_comment.comments[i].entry;
+				char *key, *val;
+
+				val = strchr(str, '=');
+				if (!val)
+					continue;
+				key = xstrndup(str, val - str);
+				val = xstrdup(val + 1);
+				comments_add(&c, key, val);
+				free(key);
+			}
+			keyvals_terminate(&c);
+			priv->comments = c.keyvals;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+static void error_cb(const Dec *dec, FLAC__StreamDecoderErrorStatus status, void *data)
+{
+	d_print("FLAC error: %s\n", FLAC__StreamDecoderErrorStatusString[status]);
+}
+
+static void free_priv(struct input_plugin_data *ip_data)
+{
+	struct flac_private *priv = ip_data->private;
+	int save = errno;
+
+	F(finish)(priv->dec);
+	F(delete)(priv->dec);
+	if (priv->comments)
+		keyvals_free(priv->comments);
+	free(priv->buf);
+	free(priv);
+	ip_data->private = NULL;
+	errno = save;
+}
+
+/* http://flac.sourceforge.net/format.html#frame_header */
+static void channel_map_init_flac(int channels, channel_position_t *map)
+{
+	if (channels == 1) {
+		map[0] = CHANNEL_POSITION_MONO;
+	} else if (channels == 2) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+	} else if (channels == 3) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_FRONT_CENTER;
+	} else if (channels == 4) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_REAR_LEFT;
+		map[3] = CHANNEL_POSITION_REAR_RIGHT;
+	} else if (channels == 5) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_FRONT_CENTER;
+		map[3] = CHANNEL_POSITION_REAR_LEFT;
+		map[4] = CHANNEL_POSITION_REAR_RIGHT;
+	} else if (channels == 6) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_FRONT_CENTER;
+		map[3] = CHANNEL_POSITION_LFE;
+		map[4] = CHANNEL_POSITION_REAR_LEFT;
+		map[5] = CHANNEL_POSITION_REAR_RIGHT;
+	} else if (channels == 7) {
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_FRONT_CENTER;
+		map[3] = CHANNEL_POSITION_LFE;
+		map[4] = CHANNEL_POSITION_REAR_LEFT;
+		map[5] = CHANNEL_POSITION_REAR_RIGHT;
+		map[6] = CHANNEL_POSITION_REAR_CENTER;
+	} else if (channels >= 8) {
+		if (channels > 8) {
+			d_print("Flac file with %d channels?!", channels);
+		}
+		map[0] = CHANNEL_POSITION_FRONT_LEFT;
+		map[1] = CHANNEL_POSITION_FRONT_RIGHT;
+		map[2] = CHANNEL_POSITION_FRONT_CENTER;
+		map[3] = CHANNEL_POSITION_LFE;
+		map[4] = CHANNEL_POSITION_REAR_LEFT;
+		map[5] = CHANNEL_POSITION_REAR_RIGHT;
+		map[6] = CHANNEL_POSITION_SIDE_LEFT;
+		map[7] = CHANNEL_POSITION_SIDE_RIGHT;
+	}
+}
+
+static int flac_open(struct input_plugin_data *ip_data)
+{
+	struct flac_private *priv;
+
+	Dec *dec = F(new)();
+
+	const struct flac_private priv_init = {
+		.dec      = dec,
+		.duration = -1,
+		.bitrate  = -1,
+		.bps      = 0
+	};
+
+	if (!dec)
+		return -IP_ERROR_INTERNAL;
+
+	priv = xnew(struct flac_private, 1);
+	*priv = priv_init;
+	if (ip_data->remote) {
+		priv->len = UINT64_MAX;
+	} else {
+		off_t off = lseek(ip_data->fd, 0, SEEK_END);
+
+		if (off == -1 || lseek(ip_data->fd, 0, SEEK_SET) == -1) {
+			int save = errno;
+
+			F(delete)(dec);
+			free(priv);
+			errno = save;
+			return -IP_ERROR_ERRNO;
+		}
+		priv->len = off;
+	}
+	ip_data->private = priv;
+
+	FLAC__stream_decoder_set_metadata_respond_all(dec);
+	if (FLAC__stream_decoder_init_stream(dec, read_cb, seek_cb, tell_cb,
+				length_cb, eof_cb, write_cb, metadata_cb,
+				error_cb, ip_data) != E(INIT_STATUS_OK)) {
+		int save = errno;
+
+		d_print("init failed\n");
+		F(delete)(priv->dec);
+		free(priv);
+		ip_data->private = NULL;
+		errno = save;
+		return -IP_ERROR_ERRNO;
+	}
+
+	ip_data->sf = 0;
+	if (!F(process_until_end_of_metadata)(priv->dec)) {
+		free_priv(ip_data);
+		return -IP_ERROR_ERRNO;
+	}
+
+	if (!ip_data->sf) {
+		free_priv(ip_data);
+		return -IP_ERROR_FILE_FORMAT;
+	}
+	int bits = sf_get_bits(ip_data->sf);
+	if (!bits) {
+		free_priv(ip_data);
+		return -IP_ERROR_SAMPLE_FORMAT;
+	}
+
+	int channels = sf_get_channels(ip_data->sf);
+	if (channels > 8) {
+		free_priv(ip_data);
+		return -IP_ERROR_FILE_FORMAT;
+	}
+
+	channel_map_init_flac(sf_get_channels(ip_data->sf), ip_data->channel_map);
+	d_print("sr: %d, ch: %d, bits: %d\n",
+			sf_get_rate(ip_data->sf),
+			channels,
+			bits);
+	return 0;
+}
+
+static int flac_close(struct input_plugin_data *ip_data)
+{
+	free_priv(ip_data);
+	return 0;
+}
+
+static int flac_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct flac_private *priv = ip_data->private;
+	int avail;
+
+	while (1) {
+		avail = priv->buf_wpos - priv->buf_rpos;
+		BUG_ON(avail < 0);
+		if (avail > 0)
+			break;
+		FLAC__bool internal_error = !F(process_single)(priv->dec);
+		FLAC__StreamDecoderState state = F(get_state)(priv->dec);
+		if (state == E(END_OF_STREAM))
+			return 0;
+		if (state == E(ABORTED) || state == E(OGG_ERROR) || internal_error) {
+			d_print("process_single failed\n");
+			return -1;
+		}
+	}
+	if (count > avail)
+		count = avail;
+	memcpy(buffer, priv->buf + priv->buf_rpos, count);
+	priv->buf_rpos += count;
+	BUG_ON(priv->buf_rpos > priv->buf_wpos);
+	if (priv->buf_rpos == priv->buf_wpos) {
+		priv->buf_rpos = 0;
+		priv->buf_wpos = 0;
+	}
+	return count;
+}
+
+/* Flush the input and seek to an absolute sample. Decoding will resume at the
+ * given sample.
+ */
+static int flac_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct flac_private *priv = ip_data->private;
+	priv->buf_rpos = 0;
+	priv->buf_wpos = 0;
+	uint64_t sample;
+
+	sample = (uint64_t)(offset * (double)sf_get_rate(ip_data->sf) + 0.5);
+	if (!F(seek_absolute)(priv->dec, sample)) {
+		if (F(get_state(priv->dec)) == FLAC__STREAM_DECODER_SEEK_ERROR) {
+			if (!F(flush)(priv->dec))
+				d_print("failed to flush\n");
+		}
+		return -IP_ERROR_ERRNO;
+	}
+	return 0;
+}
+
+static int flac_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct flac_private *priv = ip_data->private;
+
+	if (priv->comments) {
+		*comments = keyvals_dup(priv->comments);
+	} else {
+		*comments = keyvals_new(0);
+	}
+	return 0;
+}
+
+static int flac_duration(struct input_plugin_data *ip_data)
+{
+	struct flac_private *priv = ip_data->private;
+
+	return priv->duration;
+}
+
+static long flac_bitrate(struct input_plugin_data *ip_data)
+{
+	struct flac_private *priv = ip_data->private;
+	return priv->bitrate;
+}
+
+static char *flac_codec(struct input_plugin_data *ip_data)
+{
+	return xstrdup("flac");
+}
+
+static char *flac_codec_profile(struct input_plugin_data *ip_data)
+{
+	/* maybe identify compression-level over min/max blocksize/framesize */
+	return NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = flac_open,
+	.close = flac_close,
+	.read = flac_read,
+	.seek = flac_seek,
+	.read_comments = flac_read_comments,
+	.duration = flac_duration,
+	.bitrate = flac_bitrate,
+	.bitrate_current = flac_bitrate,
+	.codec = flac_codec,
+	.codec_profile = flac_codec_profile
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = { "flac", "fla", NULL };
+const char * const ip_mime_types[] = { NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/mad.c

@@ -0,0 +1,287 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2004 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "nomad.h"
+#include "../id3.h"
+#include "../ape.h"
+#include "../xmalloc.h"
+#include "../read_wrapper.h"
+#include "../debug.h"
+#include "../utils.h"
+#include "../comment.h"
+
+#include <stdio.h>
+#include <math.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+/* ------------------------------------------------------------------------- */
+
+static ssize_t read_func(void *datasource, void *buffer, size_t count)
+{
+	struct input_plugin_data *ip_data = datasource;
+
+	return read_wrapper(ip_data, buffer, count);
+}
+
+static off_t lseek_func(void *datasource, off_t offset, int whence)
+{
+	struct input_plugin_data *ip_data = datasource;
+
+	return lseek(ip_data->fd, offset, whence);
+}
+
+static int close_func(void *datasource)
+{
+	struct input_plugin_data *ip_data = datasource;
+	int rc;
+
+	rc = ip_data->fd != -1 ? close(ip_data->fd) : 0;
+	ip_data->fd = -1;
+	return rc;
+}
+
+static struct nomad_callbacks callbacks = {
+	.read = read_func,
+	.lseek = lseek_func,
+	.close = close_func
+};
+
+/* ------------------------------------------------------------------------- */
+
+static int mad_open(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad;
+	const struct nomad_info *info;
+	int rc;
+
+	rc = nomad_open_callbacks(&nomad, ip_data, &callbacks);
+	switch (rc) {
+	case -NOMAD_ERROR_ERRNO:
+		return -1;
+	case -NOMAD_ERROR_FILE_FORMAT:
+		return -IP_ERROR_FILE_FORMAT;
+	}
+	ip_data->private = nomad;
+
+	info = nomad_info(nomad);
+
+	/* always 16-bit signed little-endian */
+	ip_data->sf = sf_rate(info->sample_rate) | sf_channels(info->channels) |
+		sf_bits(16) | sf_signed(1);
+	channel_map_init_waveex(info->channels, 0, ip_data->channel_map);
+	return 0;
+}
+
+static int mad_close(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad;
+
+	nomad = ip_data->private;
+	nomad_close(nomad);
+	ip_data->fd = -1;
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int mad_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct nomad *nomad;
+
+	nomad = ip_data->private;
+	return nomad_read(nomad, buffer, count);
+}
+
+static int mad_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct nomad *nomad;
+
+	nomad = ip_data->private;
+	return nomad_time_seek(nomad, offset);
+}
+
+static int mad_read_comments(struct input_plugin_data *ip_data,
+		struct keyval **comments)
+{
+	struct nomad *nomad = ip_data->private;
+	const struct nomad_lame *lame = nomad_lame(nomad);
+	struct id3tag id3;
+	int fd, rc, save, i;
+	APETAG(ape);
+	GROWING_KEYVALS(c);
+
+	fd = open(ip_data->filename, O_RDONLY);
+	if (fd == -1) {
+		return -1;
+	}
+	d_print("filename: %s\n", ip_data->filename);
+
+	id3_init(&id3);
+	rc = id3_read_tags(&id3, fd, ID3_V1 | ID3_V2);
+	save = errno;
+	close(fd);
+	errno = save;
+	if (rc) {
+		if (rc == -1) {
+			d_print("error: %s\n", strerror(errno));
+			return -1;
+		}
+		d_print("corrupted tag?\n");
+		goto next;
+	}
+
+	for (i = 0; i < NUM_ID3_KEYS; i++) {
+		char *val = id3_get_comment(&id3, i);
+
+		if (val)
+			comments_add(&c, id3_key_names[i], val);
+	}
+
+next:
+	id3_free(&id3);
+
+	rc = ape_read_tags(&ape, ip_data->fd, 0);
+	if (rc < 0)
+		goto out;
+
+	for (i = 0; i < rc; i++) {
+		char *k, *v;
+		k = ape_get_comment(&ape, &v);
+		if (!k)
+			break;
+		comments_add(&c, k, v);
+		free(k);
+	}
+
+out:
+	ape_free(&ape);
+
+	/* add last so the other tags get preference */
+	if (lame && !isnan(lame->trackGain)) {
+		char buf[64];
+
+		if (!isnan(lame->peak)) {
+			sprintf(buf, "%f", lame->peak);
+			comments_add_const(&c, "replaygain_track_peak", buf);
+		}
+		sprintf(buf, "%+.1f dB", lame->trackGain);
+		comments_add_const(&c, "replaygain_track_gain", buf);
+	}
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int mad_duration(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad = ip_data->private;
+
+	return nomad_info(nomad)->duration;
+}
+
+static long mad_bitrate(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad = ip_data->private;
+	long bitrate = nomad_info(nomad)->avg_bitrate;
+
+	return bitrate != -1 ? bitrate : -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long mad_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad = ip_data->private;
+	return nomad_current_bitrate(nomad);
+}
+
+static char *mad_codec(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad = ip_data->private;
+
+	switch (nomad_info(nomad)->layer) {
+	case 3:
+		return xstrdup("mp3");
+	case 2:
+		return xstrdup("mp2");
+	case 1:
+		return xstrdup("mp1");
+	}
+	return NULL;
+}
+
+static char *mad_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct nomad *nomad = ip_data->private;
+	const struct nomad_lame *lame = nomad_lame(nomad);
+	const char *mode = nomad_info(nomad)->vbr ? "VBR" : "CBR";
+
+	if (lame) {
+		/* LAME:
+		 * 0: unknown
+		 * 1: cbr
+		 * 2: abr
+		 * 3: vbr rh (--vbr-old)
+		 * 4: vbr mtrh (--vbr-new)
+		 * 5: vbr mt (obsolete)
+		 */
+		int method = lame->vbr_method;
+		if (method == 2)
+			mode = "ABR";
+		else if (method >= 3 && method <= 5) {
+			const struct nomad_xing *xing = nomad_xing(nomad);
+
+			if (xing && xing->flags & XING_SCALE && xing->scale && xing->scale <= 100) {
+				char buf[16];
+				int v = 10 - (xing->scale + 9) / 10;
+				/* quality (-q): 10 - (xing->scale - ((9 - v) * 10)) */
+
+				sprintf(buf, "VBR V%d", v);
+				return xstrdup(buf);
+
+			}
+		}
+	}
+
+	return xstrdup(mode);
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = mad_open,
+	.close = mad_close,
+	.read = mad_read,
+	.seek = mad_seek,
+	.read_comments = mad_read_comments,
+	.duration = mad_duration,
+	.bitrate = mad_bitrate,
+	.bitrate_current = mad_current_bitrate,
+	.codec = mad_codec,
+	.codec_profile = mad_codec_profile
+};
+
+const int ip_priority = 55;
+const char * const ip_extensions[] = { "mp3", "mp2", NULL };
+const char * const ip_mime_types[] = {
+	"audio/mpeg", "audio/x-mp3", "audio/x-mpeg", NULL
+};
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/mikmod.c

@@ -0,0 +1,176 @@
+/*
+ * Adapted from AlsaPlayer 0.99.76
+ *
+ * mikmod_engine.c
+ * Copyright (C) 1999 Paul N. Fisher <rao@gnu.org>
+ * Copyright (C) 2002 Andy Lo A Foe <andy@alsaplayer.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../xmalloc.h"
+#include <mikmod.h>
+#include "../debug.h"
+#include "../comment.h"
+
+struct mik_private {
+	MODULE *file;
+};
+
+static int mikmod_init(void)
+{
+	static int inited = 0;
+
+	if (inited)
+		return 1;
+
+	MikMod_RegisterAllDrivers();
+	MikMod_RegisterAllLoaders();
+
+	md_reverb = 0;
+	/* we should let the user decide which one is better... */
+	md_mode = DMODE_SOFT_MUSIC | DMODE_SOFT_SNDFX | DMODE_STEREO |
+		DMODE_16BITS | DMODE_INTERP;
+
+	if (MikMod_Init(NULL)) {
+		d_print("Could not initialize mikmod, reason: %s\n",
+				MikMod_strerror(MikMod_errno));
+		return 0;
+	}
+
+	inited = 1;
+	return 1;
+}
+
+static int mik_open(struct input_plugin_data *ip_data)
+{
+	MODULE *mf = NULL;
+	struct mik_private *priv;
+	int mi = mikmod_init();
+
+	if (!mi)
+		return -IP_ERROR_INTERNAL;
+
+	mf = Player_Load(ip_data->filename, 255, 0);
+
+	if (!mf)
+		return -IP_ERROR_ERRNO;
+
+	priv = xnew(struct mik_private, 1);
+	priv->file = mf;
+
+	ip_data->private = priv;
+	ip_data->sf = sf_bits(16) | sf_rate(44100) | sf_channels(2) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+	channel_map_init_stereo(ip_data->channel_map);
+	return 0;
+}
+
+static int mik_close(struct input_plugin_data *ip_data)
+{
+	struct mik_private *priv = ip_data->private;
+
+	Player_Stop();
+	Player_Free(priv->file);
+	free(ip_data->private);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int mik_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	int length;
+	struct mik_private *priv = ip_data->private;
+
+	if (!Player_Active())
+		Player_Start(priv->file);
+
+	if (!Player_Active())
+		return 0;
+
+	length = VC_WriteBytes(buffer, count);
+
+	return length;
+}
+
+static int mik_seek(struct input_plugin_data *ip_data, double offset)
+{
+	/* cannot seek in modules properly */
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static int mik_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct mik_private *priv = ip_data->private;
+	GROWING_KEYVALS(c);
+	const char *val;
+
+	val = priv->file->songname;
+	if (val && val[0])
+		comments_add_const(&c, "title", val);
+
+	val = priv->file->comment;
+	if (val && val[0])
+		comments_add_const(&c, "comment", val);
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int mik_duration(struct input_plugin_data *ip_data)
+{
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long mik_bitrate(struct input_plugin_data *ip_data)
+{
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static char *mik_codec(struct input_plugin_data *ip_data)
+{
+	struct mik_private *priv = ip_data->private;
+	const char *codec = priv->file->modtype;
+	return (codec && codec[0]) ? xstrdup(codec) : NULL;
+}
+
+static char *mik_codec_profile(struct input_plugin_data *ip_data)
+{
+	return NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = mik_open,
+	.close = mik_close,
+	.read = mik_read,
+	.seek = mik_seek,
+	.read_comments = mik_read_comments,
+	.duration = mik_duration,
+	.bitrate = mik_bitrate,
+	.bitrate_current = mik_bitrate,
+	.codec = mik_codec,
+	.codec_profile = mik_codec_profile
+};
+
+const int ip_priority = 40;
+const char * const ip_extensions[] = {
+	"mod", "s3m", "xm", "it", "669", "amf", "dsm",
+	"far", "med", "mtm", "stm", "ult",
+	NULL
+};
+const char * const ip_mime_types[] = { NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/modplug.c

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2005 Timo Hirvonen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../file.h"
+#include "../xmalloc.h"
+#include "../comment.h"
+#ifdef HAVE_CONFIG
+#include "../config/modplug.h"
+#endif
+
+#include <libmodplug/modplug.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+struct mod_private {
+	ModPlugFile *file;
+};
+
+static int mod_open(struct input_plugin_data *ip_data)
+{
+	struct mod_private *priv;
+	char *contents;
+	off_t size;
+	ssize_t rc;
+	ModPlugFile *file;
+	ModPlug_Settings settings;
+
+	size = lseek(ip_data->fd, 0, SEEK_END);
+	if (size == -1)
+		return -IP_ERROR_ERRNO;
+	if (lseek(ip_data->fd, 0, SEEK_SET) == -1)
+		return -IP_ERROR_ERRNO;
+
+	contents = xnew(char, size);
+	rc = read_all(ip_data->fd, contents, size);
+	if (rc == -1) {
+		int save = errno;
+
+		free(contents);
+		errno = save;
+		return -IP_ERROR_ERRNO;
+	}
+	if (rc != size) {
+		free(contents);
+		return -IP_ERROR_FILE_FORMAT;
+	}
+	errno = 0;
+	file = ModPlug_Load(contents, size);
+	if (file == NULL) {
+		int save = errno;
+
+		free(contents);
+		errno = save;
+		if (errno == 0) {
+			/* libmodplug never sets errno? */
+			return -IP_ERROR_FILE_FORMAT;
+		}
+		return -IP_ERROR_ERRNO;
+	}
+	free(contents);
+
+	priv = xnew(struct mod_private, 1);
+	priv->file = file;
+
+	ModPlug_GetSettings(&settings);
+	settings.mFlags = MODPLUG_ENABLE_OVERSAMPLING | MODPLUG_ENABLE_NOISE_REDUCTION;
+/* 	settings.mFlags |= MODPLUG_ENABLE_REVERB; */
+/* 	settings.mFlags |= MODPLUG_ENABLE_MEGABASS; */
+/* 	settings.mFlags |= MODPLUG_ENABLE_SURROUND; */
+	settings.mChannels = 2;
+	settings.mBits = 16;
+	settings.mFrequency = 44100;
+	settings.mResamplingMode = MODPLUG_RESAMPLE_FIR;
+	ModPlug_SetSettings(&settings);
+
+	ip_data->private = priv;
+	ip_data->sf = sf_bits(16) | sf_rate(44100) | sf_channels(2) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+	channel_map_init_stereo(ip_data->channel_map);
+	return 0;
+}
+
+static int mod_close(struct input_plugin_data *ip_data)
+{
+	struct mod_private *priv = ip_data->private;
+
+	ModPlug_Unload(priv->file);
+	free(priv);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int mod_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct mod_private *priv = ip_data->private;
+	int rc;
+
+	errno = 0;
+	rc = ModPlug_Read(priv->file, buffer, count);
+	if (rc < 0) {
+		if (errno == 0)
+			return -IP_ERROR_INTERNAL;
+		return -IP_ERROR_ERRNO;
+	}
+	return rc;
+}
+
+static int mod_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct mod_private *priv = ip_data->private;
+	int ms = (int)(offset * 1000.0 + 0.5);
+
+	/* void */
+	ModPlug_Seek(priv->file, ms);
+	return 0;
+}
+
+static int mod_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct mod_private *priv = ip_data->private;
+	GROWING_KEYVALS(c);
+	const char *val;
+
+	val = ModPlug_GetName(priv->file);
+	if (val && val[0])
+		comments_add_const(&c, "title", val);
+
+#if MODPLUG_API_8
+	val = ModPlug_GetMessage(priv->file);
+	if (val && val[0])
+		comments_add_const(&c, "comment", val);
+#endif
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int mod_duration(struct input_plugin_data *ip_data)
+{
+	struct mod_private *priv = ip_data->private;
+
+	return (ModPlug_GetLength(priv->file) + 500) / 1000;
+}
+
+static long mod_bitrate(struct input_plugin_data *ip_data)
+{
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+#if MODPLUG_API_8
+static const char *mod_type_to_string(int type)
+{
+	/* from <libmodplug/sndfile.h>, which is C++ */
+	switch (type) {
+	case 0x01:	return "mod";
+	case 0x02:	return "s3m";
+	case 0x04:	return "xm";
+	case 0x08:	return "med";
+	case 0x10:	return "mtm";
+	case 0x20:	return "it";
+	case 0x40:	return "699";
+	case 0x80:	return "ult";
+	case 0x100:	return "stm";
+	case 0x200:	return "far";
+	case 0x800:	return "amf";
+	case 0x1000:	return "ams";
+	case 0x2000:	return "dsm";
+	case 0x4000:	return "mdl";
+	case 0x8000:	return "okt";
+	case 0x10000:	return "midi";
+	case 0x20000:	return "dmf";
+	case 0x40000:	return "ptm";
+	case 0x80000:	return "dbm";
+	case 0x100000:	return "mt2";
+	case 0x200000:	return "amf0";
+	case 0x400000:	return "psm";
+	case 0x80000000:return "umx";
+	}
+	return NULL;
+}
+#endif
+
+static char *mod_codec(struct input_plugin_data *ip_data)
+{
+#if MODPLUG_API_8
+	struct mod_private *priv = ip_data->private;
+	const char *codec;
+	int type;
+
+	type = ModPlug_GetModuleType(priv->file);
+	codec = mod_type_to_string(type);
+
+	return codec ? xstrdup(codec) : NULL;
+#else
+	return NULL;
+#endif
+}
+
+static char *mod_codec_profile(struct input_plugin_data *ip_data)
+{
+	return NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = mod_open,
+	.close = mod_close,
+	.read = mod_read,
+	.seek = mod_seek,
+	.read_comments = mod_read_comments,
+	.duration = mod_duration,
+	.bitrate = mod_bitrate,
+	.bitrate_current = mod_bitrate,
+	.codec = mod_codec,
+	.codec_profile = mod_codec_profile
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = {
+	"mod", "s3m", "xm", "it", "669", "amf", "ams", "dbm", "dmf", "dsm",
+	"far", "mdl", "med", "mtm", "okt", "ptm", "stm", "ult", "umx", "mt2",
+	"psm", NULL
+};
+const char * const ip_mime_types[] = { NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/mp4.c

@@ -0,0 +1,699 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 dnk <dnk@bjum.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../xmalloc.h"
+#include "../debug.h"
+#include "../id3.h"
+#include "../file.h"
+#ifdef HAVE_CONFIG
+#include "../config/mp4.h"
+#endif
+#include "../comment.h"
+#include "../utils.h"
+#include "aac.h"
+
+#if USE_MPEG4IP
+#include <mp4.h>
+#else
+#include <mp4v2/mp4v2.h>
+#endif
+
+#include <neaacdec.h>
+
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <strings.h>
+
+/* no perfect fallback, for example faac uses only 1024 samples to prime */
+#define ENCODER_DELAY_DEFAULT 2112
+
+struct mp4_private {
+	char *overflow_buf;
+	int overflow_buf_len;
+
+	unsigned char channels;
+	unsigned long sample_rate;
+	unsigned long frame_size;
+	unsigned long encoder_delay;
+	unsigned long drop_samples;
+	unsigned long decoded_samples;
+
+	NeAACDecHandle decoder;		/* typedef void * */
+
+	struct {
+		MP4FileHandle handle;	/* typedef void * */
+
+		MP4TrackId track;
+		MP4SampleId sample;     /* "media sample" (AAC access unit) id */
+		MP4SampleId num_samples;
+		MP4Duration duration;   /* audio samples, including encoder delay */
+		uint32_t scale;         /* sample_rate but from mp4 header */
+	} mp4;
+
+	struct {
+		unsigned long samples;
+		unsigned long bytes;
+	} current;
+};
+
+static bool try_iTunSMPB(struct mp4_private *priv)
+{
+	/* SMPB == seamless playback, older tag for gapless playback */
+	MP4ItmfItemList *itmf_list = MP4ItmfGetItemsByMeaning(priv->mp4.handle, "com.apple.iTunes", "iTunSMPB");
+	if (!itmf_list)
+		return false;
+
+	MP4ItmfItem* item = itmf_list->elements;
+	if (item == NULL || item->dataList.size == 0) {
+		MP4ItmfItemListFree(itmf_list);
+		return false;
+	}
+
+	char *pos = item->dataList.elements[0].value;
+	(void)strtol(pos, &pos, 16); // pad
+	unsigned long delay = strtol(pos, &pos, 16);
+	(void)strtol(pos, &pos, 16); // remainder
+	unsigned long samples = strtol(pos, &pos, 16);
+	priv->encoder_delay = delay;
+	priv->mp4.duration = delay + samples;
+
+	MP4ItmfItemListFree(itmf_list);
+	return true;
+}
+
+static MP4TrackId mp4_get_track(MP4FileHandle *handle)
+{
+	int i, num_tracks;
+	const char *track_type;
+	uint8_t obj_type;
+	MP4TrackId id;
+
+	num_tracks = MP4GetNumberOfTracks(handle, NULL, 0);
+
+	for (i = 0; i < num_tracks; i++) {
+		id = MP4FindTrackId(handle, i, NULL, 0);
+
+		track_type = MP4GetTrackType(handle, id);
+		if (!track_type)
+			continue;
+
+		if (!MP4_IS_AUDIO_TRACK_TYPE(track_type))
+			continue;
+
+		/* MP4GetTrackAudioType */
+		obj_type = MP4GetTrackEsdsObjectTypeId(handle, id);
+		if (obj_type == MP4_INVALID_AUDIO_TYPE)
+			continue;
+
+		if (obj_type == MP4_MPEG4_AUDIO_TYPE) {
+			obj_type = MP4GetTrackAudioMpeg4Type(handle, id);
+
+			if (MP4_IS_MPEG4_AAC_AUDIO_TYPE(obj_type))
+				return id;
+		} else {
+			if (MP4_IS_AAC_AUDIO_TYPE(obj_type))
+				return id;
+		}
+	}
+
+	return MP4_INVALID_TRACK_ID;
+}
+
+static void mp4_get_channel_map(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv = ip_data->private;
+	unsigned char *aac_data = NULL;
+	unsigned int aac_data_len = 0;
+	NeAACDecFrameInfo frame_info;
+	int i;
+
+	ip_data->channel_map[0] = CHANNEL_POSITION_INVALID;
+
+	if (MP4ReadSample(priv->mp4.handle, priv->mp4.track, priv->mp4.sample,
+			&aac_data, &aac_data_len, NULL, NULL, NULL, NULL) == 0)
+		return;
+
+	if (!aac_data)
+		return;
+
+	NeAACDecDecode(priv->decoder, &frame_info, aac_data, aac_data_len);
+	free(aac_data);
+
+	/* avoid squash of first frame by starting at 1 */
+	NeAACDecPostSeekReset(priv->decoder, 1);
+
+	if (frame_info.error != 0 || frame_info.bytesconsumed <= 0
+			|| frame_info.channels > CHANNELS_MAX)
+		return;
+
+	for (i = 0; i < frame_info.channels; i++)
+		ip_data->channel_map[i] = channel_position_aac(frame_info.channel_position[i]);
+}
+
+static void mp4_close_handle(MP4FileHandle handle)
+{
+#ifdef MP4_CLOSE_DO_NOT_COMPUTE_BITRATE
+	MP4Close(handle, 0);
+#else
+	MP4Close(handle);
+#endif
+}
+
+static int mp4_open(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv;
+	NeAACDecConfigurationPtr neaac_cfg;
+	unsigned char *buf;
+	unsigned int buf_size;
+	int rc = -IP_ERROR_FILE_FORMAT;
+
+	const struct mp4_private priv_init = {
+		.frame_size = 1024,
+		.decoded_samples = 0,
+		.decoder = NULL
+	};
+
+	/* http://sourceforge.net/forum/message.php?msg_id=3578887 */
+	if (ip_data->remote)
+		return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+
+	/* kindly ask mp4v2 to not spam stderr */
+	MP4LogSetLevel(MP4_LOG_NONE);
+
+	/* init private struct */
+	priv = xnew(struct mp4_private, 1);
+	*priv = priv_init;
+	ip_data->private = priv;
+
+	priv->decoder = NeAACDecOpen();
+
+	/* set decoder config */
+	neaac_cfg = NeAACDecGetCurrentConfiguration(priv->decoder);
+	neaac_cfg->outputFormat = FAAD_FMT_16BIT;	/* force 16 bit audio */
+	neaac_cfg->downMatrix = 0;			/* NOT 5.1 -> stereo */
+	NeAACDecSetConfiguration(priv->decoder, neaac_cfg);
+
+	/* open mpeg-4 file */
+#ifdef MP4_DETAILS_ALL
+	priv->mp4.handle = MP4Read(ip_data->filename, 0);
+#else
+	priv->mp4.handle = MP4Read(ip_data->filename);
+#endif
+	if (!priv->mp4.handle) {
+		d_print("MP4Read failed\n");
+		goto out;
+	}
+
+	/* find aac audio track */
+	priv->mp4.track = mp4_get_track(priv->mp4.handle);
+	if (priv->mp4.track == MP4_INVALID_TRACK_ID) {
+		d_print("MP4FindTrackId failed\n");
+		if (MP4GetNumberOfTracks(priv->mp4.handle, MP4_AUDIO_TRACK_TYPE, 0) > 0)
+			rc = -IP_ERROR_UNSUPPORTED_FILE_TYPE;
+		goto out;
+	}
+
+	priv->mp4.num_samples = MP4GetTrackNumberOfSamples(priv->mp4.handle, priv->mp4.track);
+	priv->mp4.sample = 1;
+	priv->mp4.duration = MP4GetTrackDuration(priv->mp4.handle, priv->mp4.track);
+	priv->mp4.scale = MP4GetTrackTimeScale(priv->mp4.handle, priv->mp4.track);
+	if (priv->mp4.scale == 0) {
+		rc = -IP_ERROR_INTERNAL;
+		goto out;
+	}
+
+	if (MP4GetTrackNumberOfEdits(priv->mp4.handle, priv->mp4.track) == 1) {
+		priv->encoder_delay = MP4GetTrackEditMediaStart(priv->mp4.handle, priv->mp4.track, 1); // usually 2048
+
+		/* The Edit List reliably gives the original duration excluding encoder delay (but
+		 * typically only in ms precision). We can convert this to samples and check whether
+		 * the sample accurate TrackDuration includes encoder delay. By my understanding it
+		 * should not, but in the files with an Edit List I looked at it did.
+		 *
+		 * Could just skip the rest of this block and still be mostly compatible...
+		 */
+		uint32_t movie_scale = MP4GetTimeScale(priv->mp4.handle); // usually 1000
+		MP4Duration movie_duration = MP4GetTrackEditDuration(priv->mp4.handle, priv->mp4.track, 1); // usually in ms
+		MP4Duration orig_samples_low_prec = movie_duration * priv->mp4.scale / movie_scale;
+		MP4Duration total_samples_low_prec = priv->encoder_delay + orig_samples_low_prec;
+
+		if (abs_delta(priv->mp4.duration, orig_samples_low_prec) < 100)
+			priv->mp4.duration += priv->encoder_delay;
+		else if (abs_delta(priv->mp4.duration, total_samples_low_prec) > 100)
+			priv->mp4.duration = total_samples_low_prec;
+	} else if (try_iTunSMPB(priv)) {
+		// nothing
+	} else {
+		priv->encoder_delay = ENCODER_DELAY_DEFAULT;
+		priv->mp4.duration += ENCODER_DELAY_DEFAULT;
+	}
+	priv->drop_samples = priv->encoder_delay;
+
+	buf = NULL;
+	buf_size = 0;
+	mp4AudioSpecificConfig mp4ASC = {0};
+	if (!MP4GetTrackESConfiguration(priv->mp4.handle, priv->mp4.track, &buf, &buf_size)) {
+		/* failed to get mpeg-4 audio config... this is ok.
+		 * NeAACDecInit2() will simply use default values instead.
+		 */
+		buf = NULL;
+		buf_size = 0;
+	} else if (NeAACDecAudioSpecificConfig(buf, buf_size, &mp4ASC) >= 0) {
+		if (mp4ASC.frameLengthFlag == 1)
+			priv->frame_size = 960;
+		if (mp4ASC.sbr_present_flag == 1 || mp4ASC.forceUpSampling)
+			priv->frame_size *= 2;
+	}
+
+	/* init decoder according to mpeg-4 audio config */
+	if (NeAACDecInit2(priv->decoder, buf, buf_size, &priv->sample_rate, &priv->channels) < 0) {
+		free(buf);
+		goto out;
+	}
+
+	free(buf);
+
+	d_print("sample rate %luhz, channels %u\n", priv->sample_rate, priv->channels);
+
+	ip_data->sf = sf_rate(priv->sample_rate) | sf_channels(priv->channels) | sf_bits(16) | sf_signed(1);
+	ip_data->sf |= sf_host_endian();
+	mp4_get_channel_map(ip_data);
+
+	return 0;
+
+out:
+	if (priv->mp4.handle)
+		mp4_close_handle(priv->mp4.handle);
+	if (priv->decoder)
+		NeAACDecClose(priv->decoder);
+	free(priv);
+	return rc;
+}
+
+static int mp4_close(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv;
+
+	priv = ip_data->private;
+
+	if (priv->mp4.handle)
+		mp4_close_handle(priv->mp4.handle);
+
+	if (priv->decoder)
+		NeAACDecClose(priv->decoder);
+
+	free(priv);
+	ip_data->private = NULL;
+
+	return 0;
+}
+
+/* returns -1 on fatal errors
+ * returns -2 on non-fatal errors
+ * 0 on eof
+ * number of bytes put in 'buffer' on success */
+static int decode_one_frame(struct input_plugin_data *ip_data, void *buffer, int count)
+{
+	struct mp4_private *priv;
+	unsigned char *aac_data = NULL;
+	unsigned int aac_data_len = 0;
+	NeAACDecFrameInfo frame_info;
+	char *sample_buf;
+	int bytes;
+
+	priv = ip_data->private;
+
+	BUG_ON(priv->overflow_buf_len);
+
+	if (priv->mp4.sample > priv->mp4.num_samples)
+		return 0; /* EOF */
+
+	if (MP4ReadSample(priv->mp4.handle, priv->mp4.track, priv->mp4.sample,
+		&aac_data, &aac_data_len, NULL, NULL, NULL, NULL) == 0) {
+		d_print("error reading mp4 sample %d\n", priv->mp4.sample);
+		errno = EINVAL;
+		return -1;
+	}
+
+	priv->mp4.sample++;
+
+	if (!aac_data) {
+		d_print("aac_data == NULL\n");
+		errno = EINVAL;
+		return -1;
+	}
+
+	sample_buf = NeAACDecDecode(priv->decoder, &frame_info, aac_data, aac_data_len);
+	free(aac_data);
+
+	if (!sample_buf || frame_info.bytesconsumed <= 0) {
+		d_print("fatal error: %s\n", NeAACDecGetErrorMessage(frame_info.error));
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (frame_info.error != 0) {
+		d_print("frame error: %s\n", NeAACDecGetErrorMessage(frame_info.error));
+		return -2;
+	}
+
+	priv->current.samples += frame_info.samples;
+	priv->current.bytes += frame_info.bytesconsumed;
+
+	/* gapless handling */
+
+	int frame_samples = frame_info.samples / frame_info.channels;
+	priv->decoded_samples += frame_samples;
+
+	if (priv->drop_samples) {
+		int skip = min_u(priv->drop_samples, frame_samples);
+		priv->drop_samples -= skip;
+		frame_samples -= skip;
+		frame_info.samples = frame_samples * frame_info.channels;
+		memmove(sample_buf, sample_buf + (skip * frame_info.channels * 2), frame_info.samples * 2);
+	}
+	if (priv->decoded_samples > priv->mp4.duration) {
+		int extra_samples = (priv->decoded_samples - priv->mp4.duration) * frame_info.channels;
+		if (frame_info.samples >= extra_samples)
+			frame_info.samples -= extra_samples;
+	}
+
+	if (frame_info.samples <= 0)
+		return -2;
+
+	if (frame_info.channels != priv->channels || frame_info.samplerate != priv->sample_rate) {
+		d_print("invalid channel or sample_rate count\n");
+		return -2;
+	}
+
+	/* 16-bit samples */
+	bytes = frame_info.samples * 2;
+
+	if (bytes > count) {
+		/* decoded too much; keep overflow. */
+		priv->overflow_buf = sample_buf + count;
+		priv->overflow_buf_len = bytes - count;
+		memcpy(buffer, sample_buf, count);
+		return count;
+	} else {
+		memcpy(buffer, sample_buf, bytes);
+	}
+
+	return bytes;
+}
+
+static int mp4_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct mp4_private *priv;
+	int rc;
+
+	priv = ip_data->private;
+
+	/* use overflow from previous call (if any) */
+	if (priv->overflow_buf_len > 0) {
+		int len = priv->overflow_buf_len;
+
+		if (len > count)
+			len = count;
+
+		memcpy(buffer, priv->overflow_buf, len);
+		priv->overflow_buf += len;
+		priv->overflow_buf_len -= len;
+
+		return len;
+	}
+
+	do {
+		rc = decode_one_frame(ip_data, buffer, count);
+	} while (rc == -2);
+
+	return rc;
+}
+
+static int mp4_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct mp4_private *priv;
+	MP4SampleId sample;
+
+	priv = ip_data->private;
+
+	sample = MP4GetSampleIdFromTime(priv->mp4.handle, priv->mp4.track,
+		(MP4Timestamp)(offset * (double)priv->mp4.scale), 1);
+	if (sample == MP4_INVALID_SAMPLE_ID)
+		return -IP_ERROR_INTERNAL;
+
+	priv->mp4.sample = sample;
+	priv->decoded_samples = (sample - 1) * priv->frame_size;
+
+	if (priv->decoded_samples < priv->encoder_delay)
+		priv->drop_samples = priv->encoder_delay - priv->decoded_samples;
+	else
+		priv->drop_samples = 0;
+
+	NeAACDecPostSeekReset(priv->decoder, sample);
+
+	d_print("seeking to sample %d\n", sample);
+
+	return 0;
+}
+
+static int mp4_read_comments(struct input_plugin_data *ip_data,
+		struct keyval **comments)
+{
+	struct mp4_private *priv;
+#if USE_MPEG4IP
+	uint16_t meta_num, meta_total;
+	uint8_t val;
+	char *str;
+	/*uint8_t *ustr;
+	uint32_t size;*/
+#else
+	const MP4Tags *tags;
+	MP4ItmfItemList* itmf_list;
+#endif
+	GROWING_KEYVALS(c);
+
+	priv = ip_data->private;
+
+#if USE_MPEG4IP
+	/* MP4GetMetadata* provides malloced pointers, and the data
+	 * is in UTF-8 (or at least it should be). */
+	if (MP4GetMetadataArtist(priv->mp4.handle, &str))
+		comments_add(&c, "artist", str);
+	if (MP4GetMetadataAlbum(priv->mp4.handle, &str))
+		comments_add(&c, "album", str);
+	if (MP4GetMetadataName(priv->mp4.handle, &str))
+		comments_add(&c, "title", str);
+	if (MP4GetMetadataGenre(priv->mp4.handle, &str))
+		comments_add(&c, "genre", str);
+	if (MP4GetMetadataYear(priv->mp4.handle, &str))
+		comments_add(&c, "date", str);
+
+	if (MP4GetMetadataCompilation(priv->mp4.handle, &val))
+		comments_add_const(&c, "compilation", val ? "yes" : "no");
+#if 0
+	if (MP4GetBytesProperty(priv->mp4.handle, "moov.udta.meta.ilst.aART.data", &ustr, &size)) {
+		char *xstr;
+
+		/* What's this?
+		 * This is the result from lack of documentation.
+		 * It's supposed to return just a string, but it
+		 * returns an additional 16 bytes of junk at the
+		 * beginning. Could be a bug. Could be intentional.
+		 * Hopefully this works around it:
+		 */
+		if (ustr[0] == 0 && size > 16) {
+			ustr += 16;
+			size -= 16;
+		}
+		xstr = xnew(char, size + 1);
+		memcpy(xstr, ustr, size);
+		xstr[size] = 0;
+		comments_add(&c, "albumartist", xstr);
+		free(xstr);
+	}
+#endif
+	if (MP4GetMetadataTrack(priv->mp4.handle, &meta_num, &meta_total)) {
+		char buf[6];
+		snprintf(buf, 6, "%u", meta_num);
+		comments_add_const(&c, "tracknumber", buf);
+	}
+	if (MP4GetMetadataDisk(priv->mp4.handle, &meta_num, &meta_total)) {
+		char buf[6];
+		snprintf(buf, 6, "%u", meta_num);
+		comments_add_const(&c, "discnumber", buf);
+	}
+
+#else /* !USE_MPEG4IP, new interface */
+
+	tags = MP4TagsAlloc();
+
+	MP4TagsFetch(tags, priv->mp4.handle);
+
+	if (tags->artist)
+		comments_add_const(&c, "artist", tags->artist);
+	if (tags->albumArtist)
+		comments_add_const(&c, "albumartist", tags->albumArtist);
+	if (tags->sortArtist)
+		comments_add_const(&c, "artistsort", tags->sortArtist);
+	if (tags->sortAlbumArtist)
+		comments_add_const(&c, "albumartistsort", tags->sortAlbumArtist);
+	if (tags->sortAlbum)
+		comments_add_const(&c, "albumsort", tags->sortAlbum);
+	if (tags->album)
+		comments_add_const(&c, "album", tags->album);
+	if (tags->name)
+		comments_add_const(&c, "title", tags->name);
+	if (tags->genre) {
+		comments_add_const(&c, "genre", tags->genre);
+	} else if (tags->genreType) {
+		char const *genre = id3_get_genre(*tags->genreType - 1);
+		if (genre)
+			comments_add_const(&c, "genre", genre);
+	}
+	if (tags->releaseDate && strcmp(tags->releaseDate, "0") != 0)
+		comments_add_const(&c, "date", tags->releaseDate);
+	if (tags->compilation)
+		comments_add_const(&c, "compilation", *tags->compilation ? "yes" : "no");
+	if (tags->track) {
+		char buf[6];
+		snprintf(buf, 6, "%u", tags->track->index);
+		comments_add_const(&c, "tracknumber", buf);
+	}
+	if (tags->disk) {
+		char buf[6];
+		snprintf(buf, 6, "%u", tags->disk->index);
+		comments_add_const(&c, "discnumber", buf);
+	}
+	if (tags->tempo) {
+		char buf[6];
+		snprintf(buf, 6, "%u", *tags->tempo);
+		comments_add_const(&c, "bpm", buf);
+	}
+
+	MP4TagsFree(tags);
+
+	itmf_list = MP4ItmfGetItemsByMeaning(priv->mp4.handle, "com.apple.iTunes", NULL);
+	if (itmf_list) {
+		int i;
+		for (i = 0; i < itmf_list->size; i++) {
+			MP4ItmfItem* item = &itmf_list->elements[i];
+			if (item->dataList.size < 1)
+				continue;
+			if (item->dataList.size > 1)
+				d_print("ignore multiple values for tag %s\n", item->name);
+			else {
+				MP4ItmfData* data = &item->dataList.elements[0];
+				char *val = xstrndup(data->value, data->valueSize);
+				comments_add(&c, item->name, val);
+			}
+		}
+		MP4ItmfItemListFree(itmf_list);
+	}
+#endif
+
+	keyvals_terminate(&c);
+	*comments = c.keyvals;
+	return 0;
+}
+
+static int mp4_duration(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv;
+
+	priv = ip_data->private;
+
+	return priv->mp4.duration / priv->mp4.scale;
+}
+
+static long mp4_bitrate(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv = ip_data->private;
+	long bitrate = MP4GetTrackBitRate(priv->mp4.handle, priv->mp4.track);
+	return bitrate ? bitrate : -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long mp4_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv = ip_data->private;
+	long bitrate = -1;
+	if (priv->current.samples > 0) {
+		priv->current.samples /= priv->channels;
+		bitrate = (8 * priv->current.bytes * priv->sample_rate) / priv->current.samples;
+		priv->current.samples = 0;
+		priv->current.bytes = 0;
+	}
+	return bitrate;
+}
+
+static char *mp4_codec(struct input_plugin_data *ip_data)
+{
+	return xstrdup("aac");
+}
+
+static const char *object_type_to_str(uint8_t obj_type)
+{
+	switch (obj_type) {
+	case MP4_MPEG4_AAC_MAIN_AUDIO_TYPE:	return "Main";
+	case MP4_MPEG4_AAC_LC_AUDIO_TYPE:	return "LC";
+	case MP4_MPEG4_AAC_SSR_AUDIO_TYPE:	return "SSR";
+	case MP4_MPEG4_AAC_LTP_AUDIO_TYPE:	return "LTP";
+#ifdef MP4_MPEG4_AAC_HE_AUDIO_TYPE
+	case MP4_MPEG4_AAC_HE_AUDIO_TYPE:	return "HE";
+#endif
+	case MP4_MPEG4_AAC_SCALABLE_AUDIO_TYPE:	return "Scalable";
+	}
+	return NULL;
+}
+
+static char *mp4_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct mp4_private *priv = ip_data->private;
+	const char *profile;
+	uint8_t obj_type;
+
+	obj_type = MP4GetTrackEsdsObjectTypeId(priv->mp4.handle, priv->mp4.track);
+	if (obj_type == MP4_MPEG4_AUDIO_TYPE)
+		obj_type = MP4GetTrackAudioMpeg4Type(priv->mp4.handle, priv->mp4.track);
+
+	profile = object_type_to_str(obj_type);
+
+	return profile ? xstrdup(profile) : NULL;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = mp4_open,
+	.close = mp4_close,
+	.read = mp4_read,
+	.seek = mp4_seek,
+	.read_comments = mp4_read_comments,
+	.duration = mp4_duration,
+	.bitrate = mp4_bitrate,
+	.bitrate_current = mp4_current_bitrate,
+	.codec = mp4_codec,
+	.codec_profile = mp4_codec_profile
+};
+
+const int ip_priority = 50;
+const char * const ip_extensions[] = { "mp4", "m4a", "m4b", NULL };
+const char * const ip_mime_types[] = { /*"audio/mp4", "audio/mp4a-latm",*/ NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;

ip/mpc.c

@@ -0,0 +1,464 @@
+/*
+ * Copyright 2008-2013 Various Authors
+ * Copyright 2006 Chun-Yu Shei <cshei AT cs.indiana.edu>
+ *
+ * Cleaned up by Timo Hirvonen <tihirvon@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../ip.h"
+#include "../ape.h"
+#include "../comment.h"
+#include "../file.h"
+#include "../xmalloc.h"
+#include "../read_wrapper.h"
+
+#ifdef HAVE_CONFIG
+#include "../config/mpc.h"
+#endif
+
+#if MPC_SV8
+#include <mpc/mpcdec.h>
+#define callback_t mpc_reader
+#define get_ip_data(d) (d)->data
+#else
+#include <mpcdec/mpcdec.h>
+#define MPC_FALSE FALSE
+#define MPC_TRUE TRUE
+#define callback_t void
+#define get_ip_data(d) (d)
+#endif
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+struct mpc_private {
+#if MPC_SV8
+	mpc_demux *decoder;
+#else
+	mpc_decoder decoder;
+#endif
+	mpc_reader reader;
+	mpc_streaminfo info;
+
+	off_t file_size;
+
+	int samples_pos;
+	int samples_avail;
+
+	/* mpcdec/mpcdec.h
+	 *
+	 * the api doc says this is pcm samples per mpc frame
+	 * but it's really pcm _frames_ per mpc frame
+	 *     MPC_FRAME_LENGTH = 36 * 32 (1152)
+	 *
+	 * this is wrong, it should be 2 * MPC_FRAME_LENGTH (2304)
+	 *     MPC_DECODER_BUFFER_LENGTH = 4 * MPC_FRAME_LENGTH (4608)
+	 *
+	 * use MPC_DECODER_BUFFER_LENGTH just to be sure it works
+	 */
+	MPC_SAMPLE_FORMAT samples[MPC_DECODER_BUFFER_LENGTH];
+
+	struct {
+		unsigned long samples;
+		unsigned long bits;
+	} current;
+};
+
+/* callbacks */
+static mpc_int32_t read_impl(callback_t *data, void *ptr, mpc_int32_t size)
+{
+	struct input_plugin_data *ip_data = get_ip_data(data);
+	int rc;
+
+	rc = read_wrapper(ip_data, ptr, size);
+	if (rc == -1)
+		return -1;
+	if (rc == 0) {
+		errno = 0;
+		return 0;
+	}
+	return rc;
+}
+
+static mpc_bool_t seek_impl(callback_t *data, mpc_int32_t offset)
+{
+	struct input_plugin_data *ip_data = get_ip_data(data);
+
+	if (lseek(ip_data->fd, offset, SEEK_SET) == -1)
+		return MPC_FALSE;
+	return MPC_TRUE;
+}
+
+static mpc_int32_t tell_impl(callback_t *data)
+{
+	struct input_plugin_data *ip_data = get_ip_data(data);
+
+	return lseek(ip_data->fd, 0, SEEK_CUR);
+}
+
+static mpc_int32_t get_size_impl(callback_t *data)
+{
+	struct input_plugin_data *ip_data = get_ip_data(data);
+	struct mpc_private *priv = ip_data->private;
+
+	return priv->file_size;
+}
+
+static mpc_bool_t canseek_impl(callback_t *data)
+{
+	struct input_plugin_data *ip_data = get_ip_data(data);
+
+	return !ip_data->remote;
+}
+
+static int mpc_open(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv;
+
+	const struct mpc_private priv_init = {
+		.file_size = -1,
+		/* set up an mpc_reader linked to our function implementations */
+		.reader = {
+			.read     = read_impl,
+			.seek     = seek_impl,
+			.tell     = tell_impl,
+			.get_size = get_size_impl,
+			.canseek  = canseek_impl,
+			.data     = ip_data
+		}
+	};
+
+	priv = xnew(struct mpc_private, 1);
+	*priv = priv_init;
+
+	if (!ip_data->remote) {
+		priv->file_size = lseek(ip_data->fd, 0, SEEK_END);
+		lseek(ip_data->fd, 0, SEEK_SET);
+	}
+
+	/* must be before mpc_streaminfo_read() */
+	ip_data->private = priv;
+
+	/* read file's streaminfo data */
+#if MPC_SV8
+	priv->decoder = mpc_demux_init(&priv->reader);
+	if (!priv->decoder) {
+#else
+	mpc_streaminfo_init(&priv->info);
+	if (mpc_streaminfo_read(&priv->info, &priv->reader) != ERROR_CODE_OK) {
+#endif
+		free(priv);
+		return -IP_ERROR_FILE_FORMAT;
+	}
+
+#if MPC_SV8
+	mpc_demux_get_info(priv->decoder, &priv->info);
+#else
+	/* instantiate a decoder with our file reader */
+	mpc_decoder_setup(&priv->decoder, &priv->reader);
+	if (!mpc_decoder_initialize(&priv->decoder, &priv->info)) {
+		free(priv);
+		return -IP_ERROR_FILE_FORMAT;
+	}
+#endif
+
+	priv->samples_avail = 0;
+	priv->samples_pos = 0;
+
+	ip_data->sf = sf_rate(priv->info.sample_freq) | sf_channels(priv->info.channels) |
+		sf_bits(16) | sf_signed(1);
+	channel_map_init_waveex(priv->info.channels, 0, ip_data->channel_map);
+	return 0;
+}
+
+static int mpc_close(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+
+#if MPC_SV8
+	mpc_demux_exit(priv->decoder);
+#endif
+	free(priv);
+	ip_data->private = NULL;
+	return 0;
+}
+
+static int scale(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct mpc_private *priv = ip_data->private;
+	const MPC_SAMPLE_FORMAT *samples;
+	const int clip_min = (unsigned)-1 << (16 - 1);
+	const int clip_max = (1 << (16 - 1)) - 1;
+	const int float_scale = 1 << (16 - 1);
+	int i, sample_count;
+
+	/* number of bytes to 16-bit samples */
+	sample_count = count / 2;
+	if (sample_count > priv->samples_avail)
+		sample_count = priv->samples_avail;
+
+	/* scale 32-bit samples to 16-bit */
+	samples = priv->samples + priv->samples_pos;
+	for (i = 0; i < sample_count; i++) {
+		int val;
+
+		val = samples[i] * float_scale;
+		if (val < clip_min) {
+			val = clip_min;
+		} else if (val > clip_max) {
+			val = clip_max;
+		}
+
+		buffer[i * 2 + 0] = val & 0xff;
+		buffer[i * 2 + 1] = val >> 8;
+	}
+
+	priv->samples_pos += sample_count;
+	priv->samples_avail -= sample_count;
+	if (priv->samples_avail == 0)
+		priv->samples_pos = 0;
+
+	/* number of 16-bit samples to bytes */
+	return sample_count * 2;
+}
+
+static int mpc_read(struct input_plugin_data *ip_data, char *buffer, int count)
+{
+	struct mpc_private *priv = ip_data->private;
+
+#if MPC_SV8
+	mpc_status status;
+	mpc_frame_info frame;
+	int samples;
+
+	frame.buffer = priv->samples;
+
+	while (priv->samples_avail == 0) {
+		status = mpc_demux_decode(priv->decoder, &frame);
+
+		if (status != MPC_STATUS_OK) {
+			return -IP_ERROR_ERRNO;
+		}
+		if (frame.bits == -1) {
+			/* EOF */
+			return 0;
+		}
+
+		samples = frame.samples;
+		priv->samples_avail = samples * priv->info.channels;
+
+		priv->current.samples += frame.samples;
+		priv->current.bits += frame.bits;
+	}
+#else
+
+	if (priv->samples_avail == 0) {
+		uint32_t acc = 0, bits = 0;
+		uint32_t status = mpc_decoder_decode(&priv->decoder, priv->samples, &acc, &bits);
+
+		if (status == (uint32_t)(-1)) {
+			/* right ret val? */
+			return -IP_ERROR_ERRNO;
+		}
+		if (status == 0) {
+			/* EOF */
+			return 0;
+		}
+
+		/* status seems to be number of _frames_
+		 * the api documentation is wrong
+		 */
+		priv->samples_avail = status * priv->info.channels;
+
+		priv->current.samples += status;
+		priv->current.bits += bits;
+	}
+#endif
+
+	return scale(ip_data, buffer, count);
+}
+
+static int mpc_seek(struct input_plugin_data *ip_data, double offset)
+{
+	struct mpc_private *priv = ip_data->private;
+
+	priv->samples_pos = 0;
+	priv->samples_avail = 0;
+
+#if MPC_SV8
+	if (mpc_demux_seek_second(priv->decoder, offset) == MPC_STATUS_OK)
+#else
+	if (mpc_decoder_seek_seconds(&priv->decoder, offset))
+#endif
+		return 0;
+	return -1;
+}
+
+static const char *gain_to_str(int gain)
+{
+	static char buf[16];
+#if MPC_SV8
+	float g = MPC_OLD_GAIN_REF - gain / 256.f;
+	sprintf(buf, "%.2f", g);
+#else
+	int b, a = gain / 100;
+
+	if (gain < 0) {
+		b = -gain % 100;
+	} else {
+		b = gain % 100;
+	}
+	sprintf(buf, "%d.%02d", a, b);
+#endif
+	return buf;
+}
+
+static const char *peak_to_str(unsigned int peak)
+{
+	static char buf[16];
+#if MPC_SV8
+	sprintf(buf, "%.5f", peak / 256.f / 100.f);
+#else
+	sprintf(buf, "%d.%05d", peak / 32767, peak % 32767);
+#endif
+	return buf;
+}
+
+static int mpc_read_comments(struct input_plugin_data *ip_data, struct keyval **comments)
+{
+	struct mpc_private *priv = ip_data->private;
+	GROWING_KEYVALS(c);
+	int count, i;
+	APETAG(ape);
+
+	count = ape_read_tags(&ape, ip_data->fd, 1);
+	if (count < 0)
+		goto out;
+
+	for (i = 0; i < count; i++) {
+		char *k, *v;
+		k = ape_get_comment(&ape, &v);
+		if (!k)
+			break;
+		comments_add(&c, k, v);
+		free(k);
+	}
+
+out:
+	if (priv->info.gain_title && priv->info.peak_title) {
+		comments_add_const(&c, "replaygain_track_gain", gain_to_str(priv->info.gain_title));
+		comments_add_const(&c, "replaygain_track_peak", peak_to_str(priv->info.peak_title));
+	}
+	if (priv->info.gain_album && priv->info.peak_album) {
+		comments_add_const(&c, "replaygain_album_gain", gain_to_str(priv->info.gain_album));
+		comments_add_const(&c, "replaygain_album_peak", peak_to_str(priv->info.peak_album));
+	}
+	keyvals_terminate(&c);
+
+	*comments = c.keyvals;
+	ape_free(&ape);
+	return 0;
+}
+
+static int mpc_duration(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+
+	/* priv->info.pcm_samples seems to be number of frames
+	 * priv->info.frames is _not_ pcm frames
+	 */
+#if MPC_SV8
+	return mpc_streaminfo_get_length(&priv->info);
+#else
+	return priv->info.pcm_samples / priv->info.sample_freq;
+#endif
+}
+
+static long mpc_bitrate(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+	if (priv->info.average_bitrate)
+		return (long) (priv->info.average_bitrate + 0.5);
+	if (priv->info.bitrate)
+		return priv->info.bitrate;
+	return -IP_ERROR_FUNCTION_NOT_SUPPORTED;
+}
+
+static long mpc_current_bitrate(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+	long bitrate = -1;
+	if (priv->current.samples > 0) {
+		bitrate = (priv->info.sample_freq * priv->current.bits) / priv->current.samples;
+		priv->current.samples = 0;
+		priv->current.bits = 0;
+	}
+	return bitrate;
+
+}
+
+static char *mpc_codec(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+	switch (priv->info.stream_version) {
+	case 7:
+		return xstrdup("mpc7");
+	case 8:
+		return xstrdup("mpc8");
+	}
+	return NULL;
+}
+
+static char *mpc_codec_profile(struct input_plugin_data *ip_data)
+{
+	struct mpc_private *priv = ip_data->private;
+	const char *profile = priv->info.profile_name;
+	char *s = NULL;
+
+	if (profile && profile[0]) {
+		int i;
+
+		/* remove single quotes */
+		while (*profile == '\'')
+			profile++;
+		s = xstrdup(profile);
+		for (i = strlen(s) - 1; s[i] == '\'' && i >= 0; i--)
+			s[i] = '\0';
+	}
+
+	return s;
+}
+
+const struct input_plugin_ops ip_ops = {
+	.open = mpc_open,
+	.close = mpc_close,
+	.read = mpc_read,
+	.seek = mpc_seek,
+	.read_comments = mpc_read_comments,
+	.duration = mpc_duration,
+	.bitrate = mpc_bitrate,
+	.bitrate_current = mpc_current_bitrate,
+	.codec = mpc_codec,
+	.codec_profile = mpc_codec_profile
+};
+
+const int ip_priority = 50;
+const char *const ip_extensions[] = { "mpc", "mpp", "mp+", NULL };
+const char *const ip_mime_types[] = { "audio/x-musepack", NULL };
+const struct input_plugin_opt ip_options[] = { { NULL } };
+const unsigned ip_abi_version = IP_ABI_VERSION;