react-native-queue-player 1.0.0

package/android/src/main/cpp/third_party/dmap-parser/dmap_parser.c

@@ -0,0 +1,545 @@
+#include "dmap_parser.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define DMAP_STRINGIFY_(x) #x
+#define DMAP_STRINGIFY(x) DMAP_STRINGIFY_(x)
+
+typedef enum {
+	DMAP_UNKNOWN,
+	DMAP_UINT,
+	DMAP_INT,
+	DMAP_STR,
+	DMAP_DATA,
+	DMAP_DATE,
+	DMAP_VERS,
+	DMAP_DICT,
+	DMAP_ITEM
+} DMAP_TYPE;
+
+typedef struct {
+	/**
+	 * The four-character code used in the encoded message.
+	 */
+	const char *code;
+
+	/**
+	 * The type of data associated with the content code.
+	 */
+	DMAP_TYPE type;
+
+	/**
+	 * For listings, the type of their listing item children.
+	 *
+	 * Listing items (mlit) can be of any type, and as with other content codes
+	 * their type information is not encoded in the message. Parsers must
+	 * determine the type of the listing items based on their parent context.
+	 */
+	DMAP_TYPE list_item_type;
+
+	/**
+	 * A human-readable name for the content code.
+	 */
+	const char *name;
+} dmap_field;
+
+static const dmap_field dmap_fields[] = {
+	{ "abal",    DMAP_DICT, DMAP_STR,  "daap.browsealbumlisting" },
+	{ "abar",    DMAP_DICT, DMAP_STR,  "daap.browseartistlisting" },
+	{ "abcp",    DMAP_DICT, DMAP_STR,  "daap.browsecomposerlisting" },
+	{ "abgn",    DMAP_DICT, DMAP_STR,  "daap.browsegenrelisting" },
+	{ "abpl",    DMAP_UINT, 0,         "daap.baseplaylist" },
+	{ "abro",    DMAP_DICT, 0,         "daap.databasebrowse" },
+	{ "adbs",    DMAP_DICT, 0,         "daap.databasesongs" },
+	{ "aeAD",    DMAP_DICT, 0,         "com.apple.itunes.adam-ids-array" },
+	{ "aeAI",    DMAP_UINT, 0,         "com.apple.itunes.itms-artistid" },
+	{ "aeCD",    DMAP_DATA, 0,         "com.apple.itunes.flat-chapter-data" },
+	{ "aeCF",    DMAP_UINT, 0,         "com.apple.itunes.cloud-flavor-id" },
+	{ "aeCI",    DMAP_UINT, 0,         "com.apple.itunes.itms-composerid" },
+	{ "aeCK",    DMAP_UINT, 0,         "com.apple.itunes.cloud-library-kind" },
+	{ "aeCM",    DMAP_UINT, 0,         "com.apple.itunes.cloud-match-type" },
+	{ "aeCR",    DMAP_STR,  0,         "com.apple.itunes.content-rating" } ,
+	{ "aeCS",    DMAP_UINT, 0,         "com.apple.itunes.artworkchecksum" },
+	{ "aeCU",    DMAP_UINT, 0,         "com.apple.itunes.cloud-user-id" },
+	{ "aeCd",    DMAP_UINT, 0,         "com.apple.itunes.cloud-id" },
+	{ "aeDE",    DMAP_STR,  0,         "com.apple.itunes.longest-content-description" },
+	{ "aeDL",    DMAP_UINT, 0,         "com.apple.itunes.drm-downloader-user-id" },
+	{ "aeDP",    DMAP_UINT, 0,         "com.apple.itunes.drm-platform-id" },
+	{ "aeDR",    DMAP_UINT, 0,         "com.apple.itunes.drm-user-id" },
+	{ "aeDV",    DMAP_UINT, 0,         "com.apple.itunes.drm-versions" },
+	{ "aeEN",    DMAP_STR,  0,         "com.apple.itunes.episode-num-str" },
+	{ "aeES",    DMAP_UINT, 0,         "com.apple.itunes.episode-sort" },
+	{ "aeFA",    DMAP_UINT, 0,         "com.apple.itunes.drm-family-id" },
+	{ "aeGD",    DMAP_UINT, 0,         "com.apple.itunes.gapless-enc-dr" } ,
+	{ "aeGE",    DMAP_UINT, 0,         "com.apple.itunes.gapless-enc-del" },
+	{ "aeGH",    DMAP_UINT, 0,         "com.apple.itunes.gapless-heur" },
+	{ "aeGI",    DMAP_UINT, 0,         "com.apple.itunes.itms-genreid" },
+	{ "aeGR",    DMAP_UINT, 0,         "com.apple.itunes.gapless-resy" },
+	{ "aeGU",    DMAP_UINT, 0,         "com.apple.itunes.gapless-dur" },
+	{ "aeGs",    DMAP_UINT, 0,         "com.apple.itunes.can-be-genius-seed" },
+	{ "aeHC",    DMAP_UINT, 0,         "com.apple.itunes.has-chapter-data" },
+	{ "aeHD",    DMAP_UINT, 0,         "com.apple.itunes.is-hd-video" },
+	{ "aeHV",    DMAP_UINT, 0,         "com.apple.itunes.has-video" },
+	{ "aeK1",    DMAP_UINT, 0,         "com.apple.itunes.drm-key1-id" },
+	{ "aeK2",    DMAP_UINT, 0,         "com.apple.itunes.drm-key2-id" },
+	{ "aeMC",    DMAP_UINT, 0,         "com.apple.itunes.playlist-contains-media-type-count" },
+	{ "aeMK",    DMAP_UINT, 0,         "com.apple.itunes.mediakind" },
+	{ "aeMX",    DMAP_STR,  0,         "com.apple.itunes.movie-info-xml" },
+	{ "aeMk",    DMAP_UINT, 0,         "com.apple.itunes.extended-media-kind" },
+	{ "aeND",    DMAP_UINT, 0,         "com.apple.itunes.non-drm-user-id" },
+	{ "aeNN",    DMAP_STR,  0,         "com.apple.itunes.network-name" },
+	{ "aeNV",    DMAP_UINT, 0,         "com.apple.itunes.norm-volume" },
+	{ "aePC",    DMAP_UINT, 0,         "com.apple.itunes.is-podcast" },
+	{ "aePI",    DMAP_UINT, 0,         "com.apple.itunes.itms-playlistid" },
+	{ "aePP",    DMAP_UINT, 0,         "com.apple.itunes.is-podcast-playlist" },
+	{ "aePS",    DMAP_UINT, 0,         "com.apple.itunes.special-playlist" },
+	{ "aeRD",    DMAP_UINT, 0,         "com.apple.itunes.rental-duration" },
+	{ "aeRP",    DMAP_UINT, 0,         "com.apple.itunes.rental-pb-start" },
+	{ "aeRS",    DMAP_UINT, 0,         "com.apple.itunes.rental-start" },
+	{ "aeRU",    DMAP_UINT, 0,         "com.apple.itunes.rental-pb-duration" },
+	{ "aeRf",    DMAP_UINT, 0,         "com.apple.itunes.is-featured" },
+	{ "aeSE",    DMAP_UINT, 0,         "com.apple.itunes.store-pers-id" },
+	{ "aeSF",    DMAP_UINT, 0,         "com.apple.itunes.itms-storefrontid" },
+	{ "aeSG",    DMAP_UINT, 0,         "com.apple.itunes.saved-genius" },
+	{ "aeSI",    DMAP_UINT, 0,         "com.apple.itunes.itms-songid" },
+	{ "aeSN",    DMAP_STR,  0,         "com.apple.itunes.series-name" },
+	{ "aeSP",    DMAP_UINT, 0,         "com.apple.itunes.smart-playlist" },
+	{ "aeSU",    DMAP_UINT, 0,         "com.apple.itunes.season-num" },
+	{ "aeSV",    DMAP_VERS, 0,         "com.apple.itunes.music-sharing-version" },
+	{ "aeXD",    DMAP_STR,  0,         "com.apple.itunes.xid" },
+	{ "aecp",    DMAP_STR,  0,         "com.apple.itunes.collection-description" },
+	{ "aels",    DMAP_UINT, 0,         "com.apple.itunes.liked-state" },
+	{ "aemi",    DMAP_DICT, 0,         "com.apple.itunes.media-kind-listing-item" },
+	{ "aeml",    DMAP_DICT, 0,         "com.apple.itunes.media-kind-listing" },
+	{ "agac",    DMAP_UINT, 0,         "daap.groupalbumcount" },
+	{ "agma",    DMAP_UINT, 0,         "daap.groupmatchedqueryalbumcount" },
+	{ "agmi",    DMAP_UINT, 0,         "daap.groupmatchedqueryitemcount" },
+	{ "agrp",    DMAP_STR,  0,         "daap.songgrouping" },
+	{ "ajAE",    DMAP_UINT, 0,         "com.apple.itunes.store.ams-episode-type" },
+	{ "ajAS",    DMAP_UINT, 0,         "com.apple.itunes.store.ams-episode-sort-order" },
+	{ "ajAT",    DMAP_UINT, 0,         "com.apple.itunes.store.ams-show-type" },
+	{ "ajAV",    DMAP_UINT, 0,         "com.apple.itunes.store.is-ams-video" },
+	{ "ajal",    DMAP_UINT, 0,         "com.apple.itunes.store.album-liked-state" },
+	{ "ajcA",    DMAP_UINT, 0,         "com.apple.itunes.store.show-composer-as-artist" },
+	{ "ajca",    DMAP_UINT, 0,         "com.apple.itunes.store.show-composer-as-artist" },
+	{ "ajuw",    DMAP_UINT, 0,         "com.apple.itunes.store.use-work-name-as-display-name" },
+	{ "amvc",    DMAP_UINT, 0,         "daap.songmovementcount" },
+	{ "amvm",    DMAP_STR,  0,         "daap.songmovementname" },
+	{ "amvn",    DMAP_UINT, 0,         "daap.songmovementnumber" },
+	{ "aply",    DMAP_DICT, 0,         "daap.databaseplaylists" },
+	{ "aprm",    DMAP_UINT, 0,         "daap.playlistrepeatmode" },
+	{ "apro",    DMAP_VERS, 0,         "daap.protocolversion" },
+	{ "apsm",    DMAP_UINT, 0,         "daap.playlistshufflemode" },
+	{ "apso",    DMAP_DICT, 0,         "daap.playlistsongs" },
+	{ "arif",    DMAP_DICT, 0,         "daap.resolveinfo" },
+	{ "arsv",    DMAP_DICT, 0,         "daap.resolve" },
+	{ "asaa",    DMAP_STR,  0,         "daap.songalbumartist" },
+	{ "asac",    DMAP_UINT, 0,         "daap.songartworkcount" },
+	{ "asai",    DMAP_UINT, 0,         "daap.songalbumid" },
+	{ "asal",    DMAP_STR,  0,         "daap.songalbum" },
+	{ "asar",    DMAP_STR,  0,         "daap.songartist" },
+	{ "asas",    DMAP_UINT, 0,         "daap.songalbumuserratingstatus" },
+	{ "asbk",    DMAP_UINT, 0,         "daap.bookmarkable" },
+	{ "asbo",    DMAP_UINT, 0,         "daap.songbookmark" },
+	{ "asbr",    DMAP_UINT, 0,         "daap.songbitrate" },
+	{ "asbt",    DMAP_UINT, 0,         "daap.songbeatsperminute" },
+	{ "ascd",    DMAP_UINT, 0,         "daap.songcodectype" },
+	{ "ascm",    DMAP_STR,  0,         "daap.songcomment" },
+	{ "ascn",    DMAP_STR,  0,         "daap.songcontentdescription" },
+	{ "asco",    DMAP_UINT, 0,         "daap.songcompilation" },
+	{ "ascp",    DMAP_STR,  0,         "daap.songcomposer" },
+	{ "ascr",    DMAP_UINT, 0,         "daap.songcontentrating" },
+	{ "ascs",    DMAP_UINT, 0,         "daap.songcodecsubtype" },
+	{ "asct",    DMAP_STR,  0,         "daap.songcategory" },
+	{ "asda",    DMAP_DATE, 0,         "daap.songdateadded" },
+	{ "asdb",    DMAP_UINT, 0,         "daap.songdisabled" },
+	{ "asdc",    DMAP_UINT, 0,         "daap.songdisccount" },
+	{ "asdk",    DMAP_UINT, 0,         "daap.songdatakind" },
+	{ "asdm",    DMAP_DATE, 0,         "daap.songdatemodified" },
+	{ "asdn",    DMAP_UINT, 0,         "daap.songdiscnumber" },
+	{ "asdp",    DMAP_DATE, 0,         "daap.songdatepurchased" },
+	{ "asdr",    DMAP_DATE, 0,         "daap.songdatereleased" },
+	{ "asdt",    DMAP_STR,  0,         "daap.songdescription" },
+	{ "ased",    DMAP_UINT, 0,         "daap.songextradata" },
+	{ "aseq",    DMAP_STR,  0,         "daap.songeqpreset" },
+	{ "ases",    DMAP_UINT, 0,         "daap.songexcludefromshuffle" },
+	{ "asfm",    DMAP_STR,  0,         "daap.songformat" },
+	{ "asgn",    DMAP_STR,  0,         "daap.songgenre" },
+	{ "asgp",    DMAP_UINT, 0,         "daap.songgapless" },
+	{ "asgr",    DMAP_UINT, 0,         "daap.supportsgroups" },
+	{ "ashp",    DMAP_UINT, 0,         "daap.songhasbeenplayed" },
+	{ "askd",    DMAP_DATE, 0,         "daap.songlastskipdate" },
+	{ "askp",    DMAP_UINT, 0,         "daap.songuserskipcount" },
+	{ "asky",    DMAP_STR,  0,         "daap.songkeywords" },
+	{ "aslc",    DMAP_STR,  0,         "daap.songlongcontentdescription" },
+	{ "aslr",    DMAP_UINT, 0,         "daap.songalbumuserrating" },
+	{ "asls",    DMAP_UINT, 0,         "daap.songlongsize" },
+	{ "aspc",    DMAP_UINT, 0,         "daap.songuserplaycount" },
+	{ "aspl",    DMAP_DATE, 0,         "daap.songdateplayed" },
+	{ "aspu",    DMAP_STR,  0,         "daap.songpodcasturl" },
+	{ "asri",    DMAP_UINT, 0,         "daap.songartistid" },
+	{ "asrs",    DMAP_UINT, 0,         "daap.songuserratingstatus" },
+	{ "asrv",    DMAP_INT,  0,         "daap.songrelativevolume" },
+	{ "assa",    DMAP_STR,  0,         "daap.sortartist" },
+	{ "assc",    DMAP_STR,  0,         "daap.sortcomposer" },
+	{ "assl",    DMAP_STR,  0,         "daap.sortalbumartist" },
+	{ "assn",    DMAP_STR,  0,         "daap.sortname" },
+	{ "assp",    DMAP_UINT, 0,         "daap.songstoptime" },
+	{ "assr",    DMAP_UINT, 0,         "daap.songsamplerate" },
+	{ "asss",    DMAP_STR,  0,         "daap.sortseriesname" },
+	{ "asst",    DMAP_UINT, 0,         "daap.songstarttime" },
+	{ "assu",    DMAP_STR,  0,         "daap.sortalbum" },
+	{ "assz",    DMAP_UINT, 0,         "daap.songsize" },
+	{ "astc",    DMAP_UINT, 0,         "daap.songtrackcount" },
+	{ "astm",    DMAP_UINT, 0,         "daap.songtime" },
+	{ "astn",    DMAP_UINT, 0,         "daap.songtracknumber" },
+	{ "asul",    DMAP_STR,  0,         "daap.songdataurl" },
+	{ "asur",    DMAP_UINT, 0,         "daap.songuserrating" },
+	{ "asvc",    DMAP_UINT, 0,         "daap.songprimaryvideocodec" },
+	{ "asyr",    DMAP_UINT, 0,         "daap.songyear" },
+	{ "ated",    DMAP_UINT, 0,         "daap.supportsextradata" },
+	{ "avdb",    DMAP_DICT, 0,         "daap.serverdatabases" },
+	{ "awrk",    DMAP_STR,  0,         "daap.songwork" },
+	{ "caar",    DMAP_UINT, 0,         "dacp.availablerepeatstates" },
+	{ "caas",    DMAP_UINT, 0,         "dacp.availableshufflestates" },
+	{ "caci",    DMAP_DICT, 0,         "caci" },
+	{ "cafe",    DMAP_UINT, 0,         "dacp.fullscreenenabled" },
+	{ "cafs",    DMAP_UINT, 0,         "dacp.fullscreen" },
+	{ "caia",    DMAP_UINT, 0,         "dacp.isactive" },
+	{ "cana",    DMAP_STR,  0,         "dacp.nowplayingartist" },
+	{ "cang",    DMAP_STR,  0,         "dacp.nowplayinggenre" },
+	{ "canl",    DMAP_STR,  0,         "dacp.nowplayingalbum" },
+	{ "cann",    DMAP_STR,  0,         "dacp.nowplayingname" },
+	{ "canp",    DMAP_UINT, 0,         "dacp.nowplayingids" },
+	{ "cant",    DMAP_UINT, 0,         "dacp.nowplayingtime" },
+	{ "capr",    DMAP_VERS, 0,         "dacp.protocolversion" },
+	{ "caps",    DMAP_UINT, 0,         "dacp.playerstate" },
+	{ "carp",    DMAP_UINT, 0,         "dacp.repeatstate" },
+	{ "cash",    DMAP_UINT, 0,         "dacp.shufflestate" },
+	{ "casp",    DMAP_DICT, 0,         "dacp.speakers" },
+	{ "cast",    DMAP_UINT, 0,         "dacp.songtime" },
+	{ "cavc",    DMAP_UINT, 0,         "dacp.volumecontrollable" },
+	{ "cave",    DMAP_UINT, 0,         "dacp.visualizerenabled" },
+	{ "cavs",    DMAP_UINT, 0,         "dacp.visualizer" },
+	{ "ceJC",    DMAP_UINT, 0,         "com.apple.itunes.jukebox-client-vote" },
+	{ "ceJI",    DMAP_UINT, 0,         "com.apple.itunes.jukebox-current" },
+	{ "ceJS",    DMAP_UINT, 0,         "com.apple.itunes.jukebox-score" },
+	{ "ceJV",    DMAP_UINT, 0,         "com.apple.itunes.jukebox-vote" },
+	{ "ceQR",    DMAP_DICT, 0,         "com.apple.itunes.playqueue-contents-response" },
+	{ "ceQa",    DMAP_STR,  0,         "com.apple.itunes.playqueue-album" },
+	{ "ceQg",    DMAP_STR,  0,         "com.apple.itunes.playqueue-genre" },
+	{ "ceQn",    DMAP_STR,  0,         "com.apple.itunes.playqueue-name" },
+	{ "ceQr",    DMAP_STR,  0,         "com.apple.itunes.playqueue-artist" },
+	{ "cmgt",    DMAP_DICT, 0,         "dmcp.getpropertyresponse" },
+	{ "cmmk",    DMAP_UINT, 0,         "dmcp.mediakind" },
+	{ "cmpr",    DMAP_VERS, 0,         "dmcp.protocolversion" },
+	{ "cmsr",    DMAP_UINT, 0,         "dmcp.serverrevision" },
+	{ "cmst",    DMAP_DICT, 0,         "dmcp.playstatus" },
+	{ "cmvo",    DMAP_UINT, 0,         "dmcp.volume" },
+	{ "f\215ch", DMAP_UINT, 0,         "dmap.haschildcontainers" },
+	{ "ipsa",    DMAP_DICT, 0,         "dpap.iphotoslideshowadvancedoptions" },
+	{ "ipsl",    DMAP_DICT, 0,         "dpap.iphotoslideshowoptions" },
+	{ "mbcl",    DMAP_DICT, 0,         "dmap.bag" },
+	{ "mccr",    DMAP_DICT, 0,         "dmap.contentcodesresponse" },
+	{ "mcna",    DMAP_STR,  0,         "dmap.contentcodesname" },
+	{ "mcnm",    DMAP_UINT, 0,         "dmap.contentcodesnumber" },
+	{ "mcon",    DMAP_DICT, 0,         "dmap.container" },
+	{ "mctc",    DMAP_UINT, 0,         "dmap.containercount" },
+	{ "mcti",    DMAP_UINT, 0,         "dmap.containeritemid" },
+	{ "mcty",    DMAP_UINT, 0,         "dmap.contentcodestype" },
+	{ "mdbk",    DMAP_UINT, 0,         "dmap.databasekind" },
+	{ "mdcl",    DMAP_DICT, 0,         "dmap.dictionary" },
+	{ "mdst",    DMAP_UINT, 0,         "dmap.downloadstatus" },
+	{ "meds",    DMAP_UINT, 0,         "dmap.editcommandssupported" },
+	{ "meia",    DMAP_UINT, 0,         "dmap.itemdateadded" },
+	{ "meip",    DMAP_UINT, 0,         "dmap.itemdateplayed" },
+	{ "mext",    DMAP_UINT, 0,         "dmap.objectextradata" },
+	{ "miid",    DMAP_UINT, 0,         "dmap.itemid" },
+	{ "mikd",    DMAP_UINT, 0,         "dmap.itemkind" },
+	{ "mimc",    DMAP_UINT, 0,         "dmap.itemcount" },
+	{ "minm",    DMAP_STR,  0,         "dmap.itemname" },
+	{ "mlcl",    DMAP_DICT, DMAP_DICT, "dmap.listing" },
+	{ "mlid",    DMAP_UINT, 0,         "dmap.sessionid" },
+	{ "mlit",    DMAP_ITEM, 0,         "dmap.listingitem" },
+	{ "mlog",    DMAP_DICT, 0,         "dmap.loginresponse" },
+	{ "mpco",    DMAP_UINT, 0,         "dmap.parentcontainerid" },
+	{ "mper",    DMAP_UINT, 0,         "dmap.persistentid" },
+	{ "mpro",    DMAP_VERS, 0,         "dmap.protocolversion" },
+	{ "mrco",    DMAP_UINT, 0,         "dmap.returnedcount" },
+	{ "mrpr",    DMAP_UINT, 0,         "dmap.remotepersistentid" },
+	{ "msal",    DMAP_UINT, 0,         "dmap.supportsautologout" },
+	{ "msas",    DMAP_UINT, 0,         "dmap.authenticationschemes" },
+	{ "msau",    DMAP_UINT, 0,         "dmap.authenticationmethod" },
+	{ "msbr",    DMAP_UINT, 0,         "dmap.supportsbrowse" },
+	{ "msdc",    DMAP_UINT, 0,         "dmap.databasescount" },
+	{ "msex",    DMAP_UINT, 0,         "dmap.supportsextensions" },
+	{ "msix",    DMAP_UINT, 0,         "dmap.supportsindex" },
+	{ "mslr",    DMAP_UINT, 0,         "dmap.loginrequired" },
+	{ "msma",    DMAP_UINT, 0,         "dmap.machineaddress" },
+	{ "msml",    DMAP_DICT, 0,         "msml" },
+	{ "mspi",    DMAP_UINT, 0,         "dmap.supportspersistentids" },
+	{ "msqy",    DMAP_UINT, 0,         "dmap.supportsquery" },
+	{ "msrs",    DMAP_UINT, 0,         "dmap.supportsresolve" },
+	{ "msrv",    DMAP_DICT, 0,         "dmap.serverinforesponse" },
+	{ "mstc",    DMAP_DATE, 0,         "dmap.utctime" },
+	{ "mstm",    DMAP_UINT, 0,         "dmap.timeoutinterval" },
+	{ "msto",    DMAP_INT,  0,         "dmap.utcoffset" },
+	{ "msts",    DMAP_STR,  0,         "dmap.statusstring" },
+	{ "mstt",    DMAP_UINT, 0,         "dmap.status" },
+	{ "msup",    DMAP_UINT, 0,         "dmap.supportsupdate" },
+	{ "mtco",    DMAP_UINT, 0,         "dmap.specifiedtotalcount" },
+	{ "mudl",    DMAP_DICT, 0,         "dmap.deletedidlisting" },
+	{ "mupd",    DMAP_DICT, 0,         "dmap.updateresponse" },
+	{ "musr",    DMAP_UINT, 0,         "dmap.serverrevision" },
+	{ "muty",    DMAP_UINT, 0,         "dmap.updatetype" },
+	{ "pasp",    DMAP_STR,  0,         "dpap.aspectratio" },
+	{ "pcmt",    DMAP_STR,  0,         "dpap.imagecomments" },
+	{ "peak",    DMAP_UINT, 0,         "com.apple.itunes.photos.album-kind" },
+	{ "peed",    DMAP_DATE, 0,         "com.apple.itunes.photos.exposure-date" },
+	{ "pefc",    DMAP_DICT, 0,         "com.apple.itunes.photos.faces" },
+	{ "peki",    DMAP_UINT, 0,         "com.apple.itunes.photos.key-image-id" },
+	{ "pekm",    DMAP_DICT, 0,         "com.apple.itunes.photos.key-image" },
+	{ "pemd",    DMAP_DATE, 0,         "com.apple.itunes.photos.modification-date" },
+	{ "pfai",    DMAP_DICT, 0,         "dpap.failureids" },
+	{ "pfdt",    DMAP_DICT, 0,         "dpap.filedata" },
+	{ "pfmt",    DMAP_STR,  0,         "dpap.imageformat" },
+	{ "phgt",    DMAP_UINT, 0,         "dpap.imagepixelheight" },
+	{ "picd",    DMAP_DATE, 0,         "dpap.creationdate" },
+	{ "pifs",    DMAP_UINT, 0,         "dpap.imagefilesize" },
+	{ "pimf",    DMAP_STR,  0,         "dpap.imagefilename" },
+	{ "plsz",    DMAP_UINT, 0,         "dpap.imagelargefilesize" },
+	{ "ppro",    DMAP_VERS, 0,         "dpap.protocolversion" },
+	{ "prat",    DMAP_UINT, 0,         "dpap.imagerating" },
+	{ "pret",    DMAP_DICT, 0,         "dpap.retryids" },
+	{ "pwth",    DMAP_UINT, 0,         "dpap.imagepixelwidth" }
+};
+static const size_t dmap_field_count = sizeof(dmap_fields) / sizeof(dmap_field);
+
+typedef int (*sort_func) (const void *, const void *);
+
+int dmap_version(void) {
+	return DMAP_VERSION;
+}
+
+const char *dmap_version_string(void) {
+	return DMAP_STRINGIFY(DMAP_VERSION_MAJOR) "."
+	       DMAP_STRINGIFY(DMAP_VERSION_MINOR) "."
+	       DMAP_STRINGIFY(DMAP_VERSION_PATCH);
+}
+
+static int dmap_field_sort(const dmap_field *a, const dmap_field *b) {
+	return memcmp(a->code, b->code, 4);
+}
+
+static const dmap_field *dmap_field_from_code(const char *code) {
+	dmap_field key;
+	key.code = code;
+	return bsearch(&key, dmap_fields, dmap_field_count, sizeof(dmap_field), (sort_func)dmap_field_sort);
+}
+
+const char *dmap_name_from_code(const char *code) {
+	const dmap_field *field;
+	if (!code)
+		return NULL;
+
+	field = dmap_field_from_code(code);
+	return field ? field->name : NULL;
+}
+
+static uint16_t dmap_read_u16(const char *buf) {
+	return (uint16_t)(((buf[0] & 0xff) << 8) | (buf[1] & 0xff));
+}
+
+static int16_t dmap_read_i16(const char *buf) {
+	return (int16_t)dmap_read_u16(buf);
+}
+
+static uint32_t dmap_read_u32(const char *buf) {
+	return ((uint32_t)(buf[0] & 0xff) << 24) |
+	((uint32_t)(buf[1] & 0xff) << 16) |
+	((uint32_t)(buf[2] & 0xff) <<  8) |
+	((uint32_t)(buf[3] & 0xff));
+}
+
+static int32_t dmap_read_i32(const char *buf) {
+	return (int32_t)dmap_read_u32(buf);
+}
+
+static uint64_t dmap_read_u64(const char *buf) {
+	return ((uint64_t)(buf[0] & 0xff) << 56) |
+	((uint64_t)(buf[1] & 0xff) << 48) |
+	((uint64_t)(buf[2] & 0xff) << 40) |
+	((uint64_t)(buf[3] & 0xff) << 32) |
+	((uint64_t)(buf[4] & 0xff) << 24) |
+	((uint64_t)(buf[5] & 0xff) << 16) |
+	((uint64_t)(buf[6] & 0xff) <<  8) |
+	((uint64_t)(buf[7] & 0xff));
+}
+
+static int64_t dmap_read_i64(const char *buf) {
+	return (int64_t)dmap_read_u64(buf);
+}
+
+static int dmap_parse_internal(const dmap_settings *settings, const char *buf, size_t len, const dmap_field *parent) {
+	const dmap_field *field;
+	DMAP_TYPE field_type;
+	size_t field_len;
+	const char *field_name;
+	const char *p = buf;
+	const char *end = buf + len;
+	char code[5] = {0};
+
+	if (!settings || !buf)
+		return -1;
+
+	while (end - p >= 8) {
+		memcpy(code, p, 4);
+		field = dmap_field_from_code(code);
+		p += 4;
+
+		field_len = dmap_read_u32(p);
+		p += 4;
+
+		if (p + field_len > end)
+			return -1;
+
+		if (field) {
+			field_type = field->type;
+			field_name = field->name;
+
+			if (field_type == DMAP_ITEM) {
+				if (parent != NULL && parent->list_item_type) {
+					field_type = parent->list_item_type;
+				} else {
+					field_type = DMAP_DICT;
+				}
+			}
+		} else {
+			/* Make a best guess of the type */
+			field_type = DMAP_UNKNOWN;
+			field_name = code;
+
+			if (field_len >= 8) {
+				/* Look for a four char code followed by a length within the current field */
+				if (isalpha(p[0] & 0xff) &&
+				    isalpha(p[1] & 0xff) &&
+				    isalpha(p[2] & 0xff) &&
+				    isalpha(p[3] & 0xff)) {
+					if (dmap_read_u32(p + 4) < field_len)
+						field_type = DMAP_DICT;
+				}
+			}
+
+			if (field_type == DMAP_UNKNOWN) {
+				size_t i;
+				int is_string = 1;
+				for (i=0; i < field_len; i++) {
+					if (!isprint(p[i] & 0xff)) {
+						is_string = 0;
+						break;
+					}
+				}
+
+				field_type = is_string ? DMAP_STR : DMAP_UINT;
+			}
+		}
+
+		switch (field_type) {
+			case DMAP_UINT:
+				/* Determine the integer's type based on its size */
+				switch (field_len) {
+					case 1:
+						if (settings->on_uint32)
+							settings->on_uint32(settings->ctx, code, field_name, (unsigned char)*p);
+						break;
+					case 2:
+						if (settings->on_uint32)
+							settings->on_uint32(settings->ctx, code, field_name, dmap_read_u16(p));
+						break;
+					case 4:
+						if (settings->on_uint32)
+							settings->on_uint32(settings->ctx, code, field_name, dmap_read_u32(p));
+						break;
+					case 8:
+						if (settings->on_uint64)
+							settings->on_uint64(settings->ctx, code, field_name, dmap_read_u64(p));
+						break;
+					default:
+						if (settings->on_data)
+							settings->on_data(settings->ctx, code, field_name, p, field_len);
+						break;
+				}
+				break;
+			case DMAP_INT:
+				switch (field_len) {
+					case 1:
+						if (settings->on_int32)
+							settings->on_int32(settings->ctx, code, field_name, *p);
+						break;
+					case 2:
+						if (settings->on_int32)
+							settings->on_int32(settings->ctx, code, field_name, dmap_read_i16(p));
+						break;
+					case 4:
+						if (settings->on_int32)
+							settings->on_int32(settings->ctx, code, field_name, dmap_read_i32(p));
+						break;
+					case 8:
+						if (settings->on_int64)
+							settings->on_int64(settings->ctx, code, field_name, dmap_read_i64(p));
+						break;
+					default:
+						if (settings->on_data)
+							settings->on_data(settings->ctx, code, field_name, p, field_len);
+						break;
+				}
+				break;
+			case DMAP_STR:
+				if (settings->on_string)
+					settings->on_string(settings->ctx, code, field_name, p, field_len);
+				break;
+			case DMAP_DATA:
+				if (settings->on_data)
+					settings->on_data(settings->ctx, code, field_name, p, field_len);
+				break;
+			case DMAP_DATE:
+				/* Seconds since epoch */
+				if (settings->on_date)
+					settings->on_date(settings->ctx, code, field_name, dmap_read_u32(p));
+				break;
+			case DMAP_VERS:
+				if (settings->on_string && field_len >= 4) {
+					char version[20];
+					sprintf(version, "%u.%u", dmap_read_u16(p), dmap_read_u16(p+2));
+					settings->on_string(settings->ctx, code, field_name, version, strlen(version));
+				}
+				break;
+			case DMAP_DICT:
+				if (settings->on_dict_start)
+					settings->on_dict_start(settings->ctx, code, field_name);
+				if (dmap_parse_internal(settings, p, field_len, field) != 0)
+					return -1;
+				if (settings->on_dict_end)
+					settings->on_dict_end(settings->ctx, code, field_name);
+				break;
+			case DMAP_ITEM:
+				/* Unreachable: listing item types are always mapped to another type */
+				abort();
+			case DMAP_UNKNOWN:
+				break;
+		}
+
+		p += field_len;
+	}
+
+	if (p != end)
+		return -1;
+
+	return 0;
+}
+
+int dmap_parse(const dmap_settings *settings, const char *buf, size_t len) {
+	return dmap_parse_internal(settings, buf, len, NULL);
+}

package/android/src/main/cpp/third_party/dmap-parser/dmap_parser.h

@@ -0,0 +1,90 @@
+#ifndef dmap_parser_h
+#define dmap_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#define DMAP_VERSION_MAJOR 1
+#define DMAP_VERSION_MINOR 2
+#define DMAP_VERSION_PATCH 1
+
+#define DMAP_VERSION (DMAP_VERSION_MAJOR * 1000000 + \
+                      DMAP_VERSION_MINOR * 1000 + \
+                      DMAP_VERSION_PATCH)
+
+/*
+ * Callbacks invoked during parsing.
+ *
+ * @param ctx  The context pointer specified in the dmap_settings structure.
+ * @param code The content code from the message.
+ * @param name The name associated with the content code, if known. If there is
+ *             no known name this parameter contains the same value as the code
+ *             parameter.
+ */
+typedef void (*dmap_dict_cb)   (void *ctx, const char *code, const char *name);
+typedef void (*dmap_int32_cb)  (void *ctx, const char *code, const char *name, int32_t value);
+typedef void (*dmap_int64_cb)  (void *ctx, const char *code, const char *name, int64_t value);
+typedef void (*dmap_uint32_cb) (void *ctx, const char *code, const char *name, uint32_t value);
+typedef void (*dmap_uint64_cb) (void *ctx, const char *code, const char *name, uint64_t value);
+typedef void (*dmap_data_cb)   (void *ctx, const char *code, const char *name, const char *buf, size_t len);
+
+typedef struct {
+	/* Callbacks to indicate the start and end of dictionary fields. */
+	dmap_dict_cb   on_dict_start;
+	dmap_dict_cb   on_dict_end;
+
+	/* Callbacks for field data. */
+	dmap_int32_cb  on_int32;
+	dmap_int64_cb  on_int64;
+	dmap_uint32_cb on_uint32;
+	dmap_uint64_cb on_uint64;
+	dmap_uint32_cb on_date;
+	dmap_data_cb   on_string;
+	dmap_data_cb   on_data;
+
+	/** A context pointer passed to each callback function. */
+	void *ctx;
+} dmap_settings;
+
+/**
+ * Returns the library version number.
+ *
+ * The version number format is (major * 1000000) + (minor * 1000) + patch.
+ * For example, the value for version 1.2.3 is 1002003.
+ */
+int dmap_version(void);
+
+/**
+ * Returns the library version as a string.
+ */
+const char *dmap_version_string(void);
+
+/**
+ * Returns the name associated with the provided content code, or NULL if there
+ * is no known name.
+ *
+ * For example, if given the code "minm" this function returns "dmap.itemname".
+ */
+const char *dmap_name_from_code(const char *code);
+
+/**
+ * Parses a DMAP message buffer using the provided settings.
+ *
+ * @param settings A dmap_settings structure populated with the callbacks to
+ *                 invoke during parsing.
+ * @param buf      Pointer to a DMAP message buffer. The buffer must contain a
+ *                 complete message.
+ * @param len      The length of the DMAP message buffer.
+ *
+ * @return 0 if parsing was successful, or -1 if an error occurred.
+ */
+int dmap_parse(const dmap_settings *settings, const char *buf, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+#endif