struct.js

/** 
 * mtp struct types
 * @module mtp
 */
/*jslint node:true */
"use strict";

// Require
var ref = require('ref');
var StructType = require('ref-struct');
var pointer = require('./pointer');

// Structs

// Set all struct types to the struct object
var struct = {};

/**
 * A data structure to hold MTP device entries.
 * @typedef LIBMTP_device_entry_struct
 * @type {object}
 * @property {string} vendor - The vendor of this device
 * @property {uint16} vendor_id - Vendor ID for this device
 * @property {string} product - The product name of this device
 * @property {uint16} product_id - Product ID for this device
 * @property {uint32} device_flags - Bugs, device specifics etc
 */
/** 
 * LIBMTP_device_entry_struct
 * @type {LIBMTP_device_entry_struct}
 */
struct.LIBMTP_device_entry_struct = new StructType({
    vendor: 'string',
    vendor_id: 'uint16',
    product: 'string',
    product_id: 'uint16',
    device_flags: 'uint32'
});

/**
 * A data structure to hold a raw MTP device connected
 * to the bus.
 */
struct.LIBMTP_raw_device_struct = new StructType({
    'device_entry': struct.LIBMTP_device_entry_struct,
    //  The device entry for this raw device */
    'bus_location': 'uint32',
    //  Location of the bus, if device available */
    'devnum': 'uint8' //  Device number on the bus, if device available */
});

/**
 * LIBMTP Device Storage structure
 */
struct.LIBMTP_devicestorage_struct = new StructType({
    //  Unique ID for this storage */
    id: 'uint32',
    //  Storage type */
    StorageType: 'uint16',
    //  Filesystem type */
    FilesystemType: 'uint16',
    //  Access capability */
    AccessCapability: 'uint16',
    //  Maximum capability */
    MaxCapacity: 'uint64',
    //  Free space in bytes */
    FreeSpaceInBytes: 'uint64',
    //  Free space in objects */
    FreeSpaceInObjects: 'uint64',
    //  A brief description of this storage */
    StorageDescription: 'string',
    //  A volume identifier */
    VolumeIdentifier: 'string'
    //  Next storage, follow this link until NULL */
    // next: ref.refType(LIBMTP_devicestorage_struct),
    //  Previous storage */
    // prev: ref.refType(LIBMTP_devicestorage_struct)
});
struct.LIBMTP_devicestorage_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_devicestorage_struct));
struct.LIBMTP_devicestorage_struct.defineProperty('prev',
    ref.refType(struct.LIBMTP_devicestorage_struct));

/**
 * A data structure to hold errors from the library.
 */
struct.LIBMTP_error_struct = new StructType({
    errornumber: 'int',
    error_text: 'string'
    // next: ref.refType(LIBMTP_error_struct)
});
struct.LIBMTP_error_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_error_struct));

/**
 * MTP device extension holder struct
 */
struct.LIBMTP_device_extension_struct = new StructType({
    /**
     * Name of extension e.g. "foo.com"
     */
    name: 'string',
    /**
     * Major revision of extension
     */
    major: 'int',
    /**
     * Minor revision of extension
     */
    minor: 'int'
    /**
     * Pointer to the next extension or NULL if this is the
     * last extension.
     */
    // next: ref.refType(LIBMTP_device_extension_struct)
});
struct.LIBMTP_device_extension_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_device_extension_struct));

/**
 * Main MTP device object struct
 */
struct.LIBMTP_mtpdevice_struct = new StructType({
    /**
     * Object bitsize, typically 32 or 64.
     */
    object_bitsize: 'uint8',
    /**
     * Parameters for this device, must be cast into
     * \c (PTPParams*) before internal use.
     */
    params: pointer.voidPtr,
    /**
     * USB device for this device, must be cast into
     * \c (PTP_USB*) before internal use.
     */
    usbinfo: pointer.voidPtr,
    /**
     * The storage for this device, do not use strings in here without
     * copying them first, and beware that this list may be rebuilt at
     * any time.
     * @see LIBMTP_Get_Storage()
     */
    storage: ref.refType(struct.LIBMTP_devicestorage_struct),
    /**
     * The error stack. This shall be handled using the error getting
     * and clearing functions, not by dereferencing this list.
     */
    errorstack: ref.refType(struct.LIBMTP_error_struct),
    /** The maximum battery level for this device */
    maximum_battery_level: 'uint8',
    /** Default music folder */
    default_music_folder: 'uint32',
    /** Default playlist folder */
    default_playlist_folder: 'uint32',
    /** Default picture folder */
    default_picture_folder: 'uint32',
    /** Default video folder */
    default_video_folder: 'uint32',
    /** Default organizer folder */
    default_organizer_folder: 'uint32',
    /** Default ZENcast folder (only Creative devices...) */
    default_zencast_folder: 'uint32',
    /** Default Album folder */
    default_album_folder: 'uint32',
    /** Default Text folder */
    default_text_folder: 'uint32',
    /** Per device iconv() converters, only used internally */
    cd: pointer.voidPtr,
    /** Extension list */
    extensions: ref.refType(struct.LIBMTP_device_extension_struct),
    /** Whether the device uses caching, only used internally */
    cached: 'int'

    /** Pointer to next device in linked list; NULL if this is the last device */
    // next: ref.refType(LIBMTP_mtpdevice_struct)
});
struct.LIBMTP_mtpdevice_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_mtpdevice_struct));

/**
 * MTP file struct
 */
struct.LIBMTP_file_struct = new StructType({
    //  Unique item ID */
    item_id: 'uint32',
    //  ID of parent folder */
    parent_id: 'uint32',
    //  ID of storage holding this file */
    storage_id: 'uint32',
    //  Filename of this file */
    filename: 'string',
    //  Size of file in bytes */
    filesize: 'uint64',
    //  Date of last alteration of the file */
    modificationdate: 'long',
    //  LIBMTP_filetype_t Filetype used for the current file */
    filetype: 'int'
    //  Next file in list or NULL if last file */
    // LIBMTP_file_t *next;
});
struct.LIBMTP_file_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_file_struct));

/**
 * A data structure to hold allowed ranges of values
 */
struct.LIBMTP_allowed_values_struct = new StructType({
    u8max: 'uint8',
    u8min: 'uint8',
    u8step: 'uint8',
    u8vals: pointer.uint8Ptr,
    i8max: 'int8',
    i8min: 'int8',
    i8step: 'int8',
    i8vals: pointer.int8Ptr,
    u16max: 'uint16',
    u16min: 'uint16',
    u16step: 'uint16',
    u16vals: pointer.uint16Ptr,
    i16max: 'int16',
    i16min: 'int16',
    i16step: 'int16',
    i16vals: pointer.int16Ptr,
    u32max: 'uint32',
    u32min: 'uint32',
    u32step: 'uint32',
    u32vals: pointer.uint32Ptr,
    i32max: 'int32',
    i32min: 'int32',
    i32step: 'int32',
    i32vals: pointer.int32Ptr,
    u64max: 'uint64',
    u64min: 'uint64',
    u64step: 'uint64',
    u64vals: pointer.uint64Ptr,
    i64max: 'int64',
    i64min: 'int64',
    i64step: 'int64',
    i64vals: pointer.int64Ptr,
    /**
    * Number of entries in the vals array
    */
    num_entries: 'int16',
    /**
    * The datatype specifying which of the above is used.
    * LIBMTP_datatype_t
    */
    datatype: 'int',
    /**
    * Non zero for range, 0 for enum
    */
    is_range: 'int'
});

/**
 * MTP Playlist structure
 */
struct.LIBMTP_playlist_struct = new StructType({
    //  Unique playlist ID */
    playlist_id: 'uint32',
    //  ID of parent folder */
    parent_id: 'uint32',
    //  ID of storage holding this playlist */
    storage_id: 'uint32',
    //  Name of playlist */
    name: 'string',
    //  The tracks in this playlist */
    tracks: pointer.uint32Ptr,
    //  The number of tracks in this playlist */
    no_tracks: 'uint32'
    //  Next playlist or NULL if last playlist */
    // LIBMTP_playlist_t *next; 
});
struct.LIBMTP_playlist_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_playlist_struct));

/**
 * MTP Album structure
 */
struct.LIBMTP_album_struct = new StructType({
    //  Unique playlist ID */
    album_id: 'uint32',
    //  ID of parent folder */
    parent_id: 'uint32',
    //  ID of storage holding this album */
    storage_id: 'uint32',
    //  Name of album */
    name: 'string',
    //  Name of album artist */
    artist: 'string',
    //  Name of recording composer */
    composer: 'string',
    //  Genre of album */
    genre: 'string',
    //  The tracks in this album */
    tracks: pointer.uint32Ptr,
    //  The number of tracks in this album */
    no_tracks: 'uint32'
    //  Next album or NULL if last album */
    // LIBMTP_album_t *next;
});
struct.LIBMTP_album_struct.defineProperty('next',
    ref.refType(struct.LIBMTP_album_struct));

/**
 * MTP Folder structure
 */
struct.LIBMTP_folder_struct = new StructType({
    //  Unique folder ID */
    folder_id: 'uint32',
    //  ID of parent folder */
    parent_id: 'uint32',
    //  ID of storage holding this folder */
    storage_id: 'uint32',
    //  Name of folder */
    name: 'string'
    //  Next folder at same level or NULL if no more */
    // LIBMTP_folder_t *sibling; 
    //  Child folder or NULL if no children */
    // LIBMTP_folder_t *child;
});
struct.LIBMTP_folder_struct.defineProperty('sibling',
    ref.refType(struct.LIBMTP_folder_struct));
struct.LIBMTP_folder_struct.defineProperty('child',
    ref.refType(struct.LIBMTP_folder_struct));

/**
 * LIBMTP Object RepresentativeSampleData Structure
 */
struct.LIBMTP_filesampledata_struct = new StructType({
    //  Width of sample if it is an image */
    width: 'uint32',
    //  Height of sample if it is an image */
    height: 'uint32',
    //  Duration in milliseconds if it is audio */
    duration: 'uint32',
    //  LIBMTP_filetype_t Filetype used for the sample */
    filetype: 'int',
    //  Size of sample data in bytes */
    size: 'uint64',
    //  Sample data */
    data: pointer.charPtr
});

module.exports = struct;