Source: struct.js

  1. /** 
  2.  * mtp struct types
  3.  * @module mtp
  4.  */
  5. /*jslint node:true */
  6. "use strict";
  8. // Require
  9. var ref = require('ref');
  10. var StructType = require('ref-struct');
  11. var pointer = require('./pointer');
  13. // Structs
  15. // Set all struct types to the struct object
  16. var struct = {};
  18. /**
  19.  * A data structure to hold MTP device entries.
  20.  * @typedef LIBMTP_device_entry_struct
  21.  * @type {object}
  22.  * @property {string} vendor - The vendor of this device
  23.  * @property {uint16} vendor_id - Vendor ID for this device
  24.  * @property {string} product - The product name of this device
  25.  * @property {uint16} product_id - Product ID for this device
  26.  * @property {uint32} device_flags - Bugs, device specifics etc
  27.  */
  28. /** 
  29.  * LIBMTP_device_entry_struct
  30.  * @type {LIBMTP_device_entry_struct}
  31.  */
  32. struct.LIBMTP_device_entry_struct = new StructType({
  33.     vendor: 'string',
  34.     vendor_id: 'uint16',
  35.     product: 'string',
  36.     product_id: 'uint16',
  37.     device_flags: 'uint32'
  38. });
  40. /**
  41.  * A data structure to hold a raw MTP device connected
  42.  * to the bus.
  43.  */
  44. struct.LIBMTP_raw_device_struct = new StructType({
  45.     'device_entry': struct.LIBMTP_device_entry_struct,
  46.     //  The device entry for this raw device */
  47.     'bus_location': 'uint32',
  48.     //  Location of the bus, if device available */
  49.     'devnum': 'uint8' //  Device number on the bus, if device available */
  50. });
  52. /**
  53.  * LIBMTP Device Storage structure
  54.  */
  55. struct.LIBMTP_devicestorage_struct = new StructType({
  56.     //  Unique ID for this storage */
  57.     id: 'uint32',
  58.     //  Storage type */
  59.     StorageType: 'uint16',
  60.     //  Filesystem type */
  61.     FilesystemType: 'uint16',
  62.     //  Access capability */
  63.     AccessCapability: 'uint16',
  64.     //  Maximum capability */
  65.     MaxCapacity: 'uint64',
  66.     //  Free space in bytes */
  67.     FreeSpaceInBytes: 'uint64',
  68.     //  Free space in objects */
  69.     FreeSpaceInObjects: 'uint64',
  70.     //  A brief description of this storage */
  71.     StorageDescription: 'string',
  72.     //  A volume identifier */
  73.     VolumeIdentifier: 'string'
  74.     //  Next storage, follow this link until NULL */
  75.     // next: ref.refType(LIBMTP_devicestorage_struct),
  76.     //  Previous storage */
  77.     // prev: ref.refType(LIBMTP_devicestorage_struct)
  78. });
  79. struct.LIBMTP_devicestorage_struct.defineProperty('next',
  80.     ref.refType(struct.LIBMTP_devicestorage_struct));
  81. struct.LIBMTP_devicestorage_struct.defineProperty('prev',
  82.     ref.refType(struct.LIBMTP_devicestorage_struct));
  84. /**
  85.  * A data structure to hold errors from the library.
  86.  */
  87. struct.LIBMTP_error_struct = new StructType({
  88.     errornumber: 'int',
  89.     error_text: 'string'
  90.     // next: ref.refType(LIBMTP_error_struct)
  91. });
  92. struct.LIBMTP_error_struct.defineProperty('next',
  93.     ref.refType(struct.LIBMTP_error_struct));
  95. /**
  96.  * MTP device extension holder struct
  97.  */
  98. struct.LIBMTP_device_extension_struct = new StructType({
  99.     /**
  100.      * Name of extension e.g. "foo.com"
  101.      */
  102.     name: 'string',
  103.     /**
  104.      * Major revision of extension
  105.      */
  106.     major: 'int',
  107.     /**
  108.      * Minor revision of extension
  109.      */
  110.     minor: 'int'
  111.     /**
  112.      * Pointer to the next extension or NULL if this is the
  113.      * last extension.
  114.      */
  115.     // next: ref.refType(LIBMTP_device_extension_struct)
  116. });
  117. struct.LIBMTP_device_extension_struct.defineProperty('next',
  118.     ref.refType(struct.LIBMTP_device_extension_struct));
  120. /**
  121.  * Main MTP device object struct
  122.  */
  123. struct.LIBMTP_mtpdevice_struct = new StructType({
  124.     /**
  125.      * Object bitsize, typically 32 or 64.
  126.      */
  127.     object_bitsize: 'uint8',
  128.     /**
  129.      * Parameters for this device, must be cast into
  130.      * \c (PTPParams*) before internal use.
  131.      */
  132.     params: pointer.voidPtr,
  133.     /**
  134.      * USB device for this device, must be cast into
  135.      * \c (PTP_USB*) before internal use.
  136.      */
  137.     usbinfo: pointer.voidPtr,
  138.     /**
  139.      * The storage for this device, do not use strings in here without
  140.      * copying them first, and beware that this list may be rebuilt at
  141.      * any time.
  142.      * @see LIBMTP_Get_Storage()
  143.      */
  144.     storage: ref.refType(struct.LIBMTP_devicestorage_struct),
  145.     /**
  146.      * The error stack. This shall be handled using the error getting
  147.      * and clearing functions, not by dereferencing this list.
  148.      */
  149.     errorstack: ref.refType(struct.LIBMTP_error_struct),
  150.     /** The maximum battery level for this device */
  151.     maximum_battery_level: 'uint8',
  152.     /** Default music folder */
  153.     default_music_folder: 'uint32',
  154.     /** Default playlist folder */
  155.     default_playlist_folder: 'uint32',
  156.     /** Default picture folder */
  157.     default_picture_folder: 'uint32',
  158.     /** Default video folder */
  159.     default_video_folder: 'uint32',
  160.     /** Default organizer folder */
  161.     default_organizer_folder: 'uint32',
  162.     /** Default ZENcast folder (only Creative devices...) */
  163.     default_zencast_folder: 'uint32',
  164.     /** Default Album folder */
  165.     default_album_folder: 'uint32',
  166.     /** Default Text folder */
  167.     default_text_folder: 'uint32',
  168.     /** Per device iconv() converters, only used internally */
  169.     cd: pointer.voidPtr,
  170.     /** Extension list */
  171.     extensions: ref.refType(struct.LIBMTP_device_extension_struct),
  172.     /** Whether the device uses caching, only used internally */
  173.     cached: 'int'
  175.     /** Pointer to next device in linked list; NULL if this is the last device */
  176.     // next: ref.refType(LIBMTP_mtpdevice_struct)
  177. });
  178. struct.LIBMTP_mtpdevice_struct.defineProperty('next',
  179.     ref.refType(struct.LIBMTP_mtpdevice_struct));
  181. /**
  182.  * MTP file struct
  183.  */
  184. struct.LIBMTP_file_struct = new StructType({
  185.     //  Unique item ID */
  186.     item_id: 'uint32',
  187.     //  ID of parent folder */
  188.     parent_id: 'uint32',
  189.     //  ID of storage holding this file */
  190.     storage_id: 'uint32',
  191.     //  Filename of this file */
  192.     filename: 'string',
  193.     //  Size of file in bytes */
  194.     filesize: 'uint64',
  195.     //  Date of last alteration of the file */
  196.     modificationdate: 'long',
  197.     //  LIBMTP_filetype_t Filetype used for the current file */
  198.     filetype: 'int'
  199.     //  Next file in list or NULL if last file */
  200.     // LIBMTP_file_t *next;
  201. });
  202. struct.LIBMTP_file_struct.defineProperty('next',
  203.     ref.refType(struct.LIBMTP_file_struct));
  205. /**
  206.  * A data structure to hold allowed ranges of values
  207.  */
  208. struct.LIBMTP_allowed_values_struct = new StructType({
  209.     u8max: 'uint8',
  210.     u8min: 'uint8',
  211.     u8step: 'uint8',
  212.     u8vals: pointer.uint8Ptr,
  213.     i8max: 'int8',
  214.     i8min: 'int8',
  215.     i8step: 'int8',
  216.     i8vals: pointer.int8Ptr,
  217.     u16max: 'uint16',
  218.     u16min: 'uint16',
  219.     u16step: 'uint16',
  220.     u16vals: pointer.uint16Ptr,
  221.     i16max: 'int16',
  222.     i16min: 'int16',
  223.     i16step: 'int16',
  224.     i16vals: pointer.int16Ptr,
  225.     u32max: 'uint32',
  226.     u32min: 'uint32',
  227.     u32step: 'uint32',
  228.     u32vals: pointer.uint32Ptr,
  229.     i32max: 'int32',
  230.     i32min: 'int32',
  231.     i32step: 'int32',
  232.     i32vals: pointer.int32Ptr,
  233.     u64max: 'uint64',
  234.     u64min: 'uint64',
  235.     u64step: 'uint64',
  236.     u64vals: pointer.uint64Ptr,
  237.     i64max: 'int64',
  238.     i64min: 'int64',
  239.     i64step: 'int64',
  240.     i64vals: pointer.int64Ptr,
  241.     /**
  242.     * Number of entries in the vals array
  243.     */
  244.     num_entries: 'int16',
  245.     /**
  246.     * The datatype specifying which of the above is used.
  247.     * LIBMTP_datatype_t
  248.     */
  249.     datatype: 'int',
  250.     /**
  251.     * Non zero for range, 0 for enum
  252.     */
  253.     is_range: 'int'
  254. });
  256. /**
  257.  * MTP Playlist structure
  258.  */
  259. struct.LIBMTP_playlist_struct = new StructType({
  260.     //  Unique playlist ID */
  261.     playlist_id: 'uint32',
  262.     //  ID of parent folder */
  263.     parent_id: 'uint32',
  264.     //  ID of storage holding this playlist */
  265.     storage_id: 'uint32',
  266.     //  Name of playlist */
  267.     name: 'string',
  268.     //  The tracks in this playlist */
  269.     tracks: pointer.uint32Ptr,
  270.     //  The number of tracks in this playlist */
  271.     no_tracks: 'uint32'
  272.     //  Next playlist or NULL if last playlist */
  273.     // LIBMTP_playlist_t *next; 
  274. });
  275. struct.LIBMTP_playlist_struct.defineProperty('next',
  276.     ref.refType(struct.LIBMTP_playlist_struct));
  278. /**
  279.  * MTP Album structure
  280.  */
  281. struct.LIBMTP_album_struct = new StructType({
  282.     //  Unique playlist ID */
  283.     album_id: 'uint32',
  284.     //  ID of parent folder */
  285.     parent_id: 'uint32',
  286.     //  ID of storage holding this album */
  287.     storage_id: 'uint32',
  288.     //  Name of album */
  289.     name: 'string',
  290.     //  Name of album artist */
  291.     artist: 'string',
  292.     //  Name of recording composer */
  293.     composer: 'string',
  294.     //  Genre of album */
  295.     genre: 'string',
  296.     //  The tracks in this album */
  297.     tracks: pointer.uint32Ptr,
  298.     //  The number of tracks in this album */
  299.     no_tracks: 'uint32'
  300.     //  Next album or NULL if last album */
  301.     // LIBMTP_album_t *next;
  302. });
  303. struct.LIBMTP_album_struct.defineProperty('next',
  304.     ref.refType(struct.LIBMTP_album_struct));
  306. /**
  307.  * MTP Folder structure
  308.  */
  309. struct.LIBMTP_folder_struct = new StructType({
  310.     //  Unique folder ID */
  311.     folder_id: 'uint32',
  312.     //  ID of parent folder */
  313.     parent_id: 'uint32',
  314.     //  ID of storage holding this folder */
  315.     storage_id: 'uint32',
  316.     //  Name of folder */
  317.     name: 'string'
  318.     //  Next folder at same level or NULL if no more */
  319.     // LIBMTP_folder_t *sibling; 
  320.     //  Child folder or NULL if no children */
  321.     // LIBMTP_folder_t *child;
  322. });
  323. struct.LIBMTP_folder_struct.defineProperty('sibling',
  324.     ref.refType(struct.LIBMTP_folder_struct));
  325. struct.LIBMTP_folder_struct.defineProperty('child',
  326.     ref.refType(struct.LIBMTP_folder_struct));
  328. /**
  329.  * LIBMTP Object RepresentativeSampleData Structure
  330.  */
  331. struct.LIBMTP_filesampledata_struct = new StructType({
  332.     //  Width of sample if it is an image */
  333.     width: 'uint32',
  334.     //  Height of sample if it is an image */
  335.     height: 'uint32',
  336.     //  Duration in milliseconds if it is audio */
  337.     duration: 'uint32',
  338.     //  LIBMTP_filetype_t Filetype used for the sample */
  339.     filetype: 'int',
  340.     //  Size of sample data in bytes */
  341.     size: 'uint64',
  342.     //  Sample data */
  343.     data: pointer.charPtr
  344. });
  346. module.exports = struct;