C++程序
|
9212行
|
311.84 KB
/**
* \file libmtp.c
*
* Copyright (C) 2005-2011 Linus Walleij <triad@df.lth.se>
* Copyright (C) 2005-2008 Richard A. Low <richard@wentnet.com>
* Copyright (C) 2007 Ted Bullock <tbullock@canada.com>
* Copyright (C) 2007 Tero Saarni <tero.saarni@gmail.com>
* Copyright (C) 2008 Florent Mertens <flomertens@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* This file provides an interface "glue" to the underlying
* PTP implementation from libgphoto2. It uses some local
* code to convert from/to UTF-8 (stored in unicode.c/.h)
* and some small utility functions, mainly for debugging
* (stored in util.c/.h).
*
* The three PTP files (ptp.c, ptp.h and ptp-pack.c) are
* plain copied from the libhphoto2 codebase.
*
* The files libusb-glue.c/.h are just what they say: an
* interface to libusb for the actual, physical USB traffic.
*/
#include "config.h"
#include "libmtp.h"
#include "unicode.h"
#include "ptp.h"
#include "libusb-glue.h"
#include "device-flags.h"
#include "playlist-spl.h"
#include "util.h"
#include "mtpz.h"
#include <stdarg.h>
#include <stdlib.h>
#include <limits.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#ifdef _MSC_VER // For MSVC++
#define USE_WINDOWS_IO_H
#include <io.h>
#endif
/**
* Global debug level
* We use a flag system to enable a part of logs.
*
* The LIBMTP_DEBUG environment variable sets the debug flags for any binary
* that uses libmtp and calls LIBMTP_Init. The value can be given in decimal
* (must not start with "0" or it will be interpreted in octal), or in
* hexadecimal (must start with "0x").
*
* The value "-1" enables all debug flags.
*
* Some of the utilities in examples/ also take a command-line flag "-d" that
* enables LIBMTP_DEBUG_PTP and LIBMTP_DEBUG_DATA (same as setting
* LIBMTP_DEBUG=9).
*
* Flags (combine by adding the hex values):
* 0x00 [0000 0000] : LIBMTP_DEBUG_NONE : no debug (default)
* 0x01 [0000 0001] : LIBMTP_DEBUG_PTP : PTP debug
* 0x02 [0000 0010] : LIBMTP_DEBUG_PLST : Playlist debug
* 0x04 [0000 0100] : LIBMTP_DEBUG_USB : USB debug
* 0x08 [0000 1000] : LIBMTP_DEBUG_DATA : USB data debug
*
* (Please keep this list in sync with libmtp.h.)
*/
int LIBMTP_debug = LIBMTP_DEBUG_NONE;
/*
* This is a mapping between libmtp internal MTP filetypes and
* the libgphoto2/PTP equivalent defines. We need this because
* otherwise the libmtp.h device has to be dependent on ptp.h
* to be installed too, and we don't want that.
*/
//typedef struct filemap_struct filemap_t;
typedef struct filemap_struct {
char *description; /**< Text description for the file type */
LIBMTP_filetype_t id; /**< LIBMTP internal type for the file type */
uint16_t ptp_id; /**< PTP ID for the filetype */
struct filemap_struct *next;
} filemap_t;
/*
* This is a mapping between libmtp internal MTP properties and
* the libgphoto2/PTP equivalent defines. We need this because
* otherwise the libmtp.h device has to be dependent on ptp.h
* to be installed too, and we don't want that.
*/
typedef struct propertymap_struct {
char *description; /**< Text description for the property */
LIBMTP_property_t id; /**< LIBMTP internal type for the property */
uint16_t ptp_id; /**< PTP ID for the property */
struct propertymap_struct *next;
} propertymap_t;
/*
* This is a simple container for holding our callback and user_data
* for parsing onwards to the usb_event_async function.
*/
typedef struct event_cb_data_struct {
LIBMTP_event_cb_fn cb;
void *user_data;
} event_cb_data_t;
// Global variables
// This holds the global filetype mapping table
static filemap_t *g_filemap = NULL;
// This holds the global property mapping table
static propertymap_t *g_propertymap = NULL;
static int load_cache_on_demand = 0;
/*
* Forward declarations of local (static) functions.
*/
static int register_filetype(char const * const description, LIBMTP_filetype_t const id,
uint16_t const ptp_id);
static void init_filemap();
static int register_property(char const * const description, LIBMTP_property_t const id,
uint16_t const ptp_id);
static void init_propertymap();
static void add_error_to_errorstack(LIBMTP_mtpdevice_t *device,
LIBMTP_error_number_t errornumber,
char const * const error_text);
static void add_ptp_error_to_errorstack(LIBMTP_mtpdevice_t *device,
uint16_t ptp_error,
char const * const error_text);
static void flush_handles(LIBMTP_mtpdevice_t *device);
static void get_handles_recursively(LIBMTP_mtpdevice_t *device,
PTPParams *params,
uint32_t storageid,
uint32_t parent);
static void free_storage_list(LIBMTP_mtpdevice_t *device);
static int sort_storage_by(LIBMTP_mtpdevice_t *device, int const sortby);
static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device,
uint64_t fitsize);
static int get_storage_freespace(LIBMTP_mtpdevice_t *device,
LIBMTP_devicestorage_t *storage,
uint64_t *freespace);
static int check_if_file_fits(LIBMTP_mtpdevice_t *device,
LIBMTP_devicestorage_t *storage,
uint64_t const filesize);
static uint16_t map_libmtp_type_to_ptp_type(LIBMTP_filetype_t intype);
static LIBMTP_filetype_t map_ptp_type_to_libmtp_type(uint16_t intype);
static uint16_t map_libmtp_property_to_ptp_property(LIBMTP_property_t inproperty);
static LIBMTP_property_t map_ptp_property_to_libmtp_property(uint16_t intype);
static int get_device_unicode_property(LIBMTP_mtpdevice_t *device,
char **unicstring, uint16_t property);
static uint16_t adjust_u16(uint16_t val, PTPObjectPropDesc *opd);
static uint32_t adjust_u32(uint32_t val, PTPObjectPropDesc *opd);
static char *get_iso8601_stamp(void);
static char *get_string_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id);
static uint64_t get_u64_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
uint16_t const attribute_id, uint64_t const value_default);
static uint32_t get_u32_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
uint16_t const attribute_id, uint32_t const value_default);
static uint16_t get_u16_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint16_t const value_default);
static uint8_t get_u8_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint8_t const value_default);
static int set_object_string(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, char const * const string);
static int set_object_u32(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint32_t const value);
static int set_object_u16(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint16_t const value);
static int set_object_u8(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint8_t const value);
static void get_track_metadata(LIBMTP_mtpdevice_t *device, uint16_t objectformat,
LIBMTP_track_t *track);
static LIBMTP_folder_t *get_subfolders_for_folder(LIBMTP_folder_t *list, uint32_t parent);
static int create_new_abstract_list(LIBMTP_mtpdevice_t *device,
char const * const name,
char const * const artist,
char const * const composer,
char const * const genre,
uint32_t const parenthandle,
uint32_t const storageid,
uint16_t const objectformat,
char const * const suffix,
uint32_t * const newid,
uint32_t const * const tracks,
uint32_t const no_tracks);
static int update_abstract_list(LIBMTP_mtpdevice_t *device,
char const * const name,
char const * const artist,
char const * const composer,
char const * const genre,
uint32_t const objecthandle,
uint16_t const objectformat,
uint32_t const * const tracks,
uint32_t const no_tracks);
static int send_file_object_info(LIBMTP_mtpdevice_t *device, LIBMTP_file_t *filedata);
static void add_object_to_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id);
static void update_metadata_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id);
static int set_object_filename(LIBMTP_mtpdevice_t *device,
uint32_t object_id,
uint16_t ptp_type,
const char **newname);
static char *generate_unique_filename(PTPParams* params, char const * const filename);
static int check_filename_exists(PTPParams* params, char const * const filename);
static void LIBMTP_Handle_Event(PTPContainer *ptp_event,
LIBMTP_event_t *event, uint32_t *out1);
/**
* These are to wrap the get/put handlers to convert from the MTP types to PTP types
* in a reliable way
*/
typedef struct _MTPDataHandler {
MTPDataGetFunc getfunc;
MTPDataPutFunc putfunc;
void *priv;
} MTPDataHandler;
static uint16_t get_func_wrapper(PTPParams* params, void* priv, unsigned long wantlen, unsigned char *data, unsigned long *gotlen);
static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data);
/**
* Checks if a filename ends with ".ogg". Used in various
* situations when the device has no idea that it support
* OGG but still does.
*
* @param name string to be checked.
* @return 0 if this does not end with ogg, any other
* value means it does.
*/
static int has_ogg_extension(char *name) {
char *ptype;
if (name == NULL)
return 0;
ptype = strrchr(name,'.');
if (ptype == NULL)
return 0;
if (!strcasecmp (ptype, ".ogg"))
return 1;
return 0;
}
/**
* Checks if a filename ends with ".flac". Used in various
* situations when the device has no idea that it support
* FLAC but still does.
*
* @param name string to be checked.
* @return 0 if this does not end with flac, any other
* value means it does.
*/
static int has_flac_extension(char *name) {
char *ptype;
if (name == NULL)
return 0;
ptype = strrchr(name,'.');
if (ptype == NULL)
return 0;
if (!strcasecmp (ptype, ".flac"))
return 1;
return 0;
}
/**
* Create a new file mapping entry
* @return a newly allocated filemapping entry.
*/
static filemap_t *new_filemap_entry()
{
filemap_t *filemap;
filemap = (filemap_t *)malloc(sizeof(filemap_t));
if( filemap != NULL ) {
filemap->description = NULL;
filemap->id = LIBMTP_FILETYPE_UNKNOWN;
filemap->ptp_id = PTP_OFC_Undefined;
filemap->next = NULL;
}
return filemap;
}
/**
* Register an MTP or PTP filetype for data retrieval
*
* @param description Text description of filetype
* @param id libmtp internal filetype id
* @param ptp_id PTP filetype id
* @return 0 for success any other value means error.
*/
static int register_filetype(char const * const description, LIBMTP_filetype_t const id,
uint16_t const ptp_id)
{
filemap_t *new = NULL, *current;
// Has this LIBMTP filetype been registered before ?
current = g_filemap;
while (current != NULL) {
if(current->id == id) {
break;
}
current = current->next;
}
// Create the entry
if(current == NULL) {
new = new_filemap_entry();
if(new == NULL) {
return 1;
}
new->id = id;
if(description != NULL) {
new->description = strdup(description);
}
new->ptp_id = ptp_id;
// Add the entry to the list
if(g_filemap == NULL) {
g_filemap = new;
} else {
current = g_filemap;
while (current->next != NULL ) current=current->next;
current->next = new;
}
// Update the existing entry
} else {
if (current->description != NULL) {
free(current->description);
}
current->description = NULL;
if(description != NULL) {
current->description = strdup(description);
}
current->ptp_id = ptp_id;
}
return 0;
}
static void init_filemap()
{
register_filetype("Folder", LIBMTP_FILETYPE_FOLDER, PTP_OFC_Association);
register_filetype("MediaCard", LIBMTP_FILETYPE_MEDIACARD, PTP_OFC_MTP_MediaCard);
register_filetype("RIFF WAVE file", LIBMTP_FILETYPE_WAV, PTP_OFC_WAV);
register_filetype("ISO MPEG-1 Audio Layer 3", LIBMTP_FILETYPE_MP3, PTP_OFC_MP3);
register_filetype("ISO MPEG-1 Audio Layer 2", LIBMTP_FILETYPE_MP2, PTP_OFC_MTP_MP2);
register_filetype("Microsoft Windows Media Audio", LIBMTP_FILETYPE_WMA, PTP_OFC_MTP_WMA);
register_filetype("Ogg container format", LIBMTP_FILETYPE_OGG, PTP_OFC_MTP_OGG);
register_filetype("Free Lossless Audio Codec (FLAC)", LIBMTP_FILETYPE_FLAC, PTP_OFC_MTP_FLAC);
register_filetype("Advanced Audio Coding (AAC)/MPEG-2 Part 7/MPEG-4 Part 3", LIBMTP_FILETYPE_AAC, PTP_OFC_MTP_AAC);
register_filetype("MPEG-4 Part 14 Container Format (Audio Emphasis)", LIBMTP_FILETYPE_M4A, PTP_OFC_MTP_M4A);
register_filetype("MPEG-4 Part 14 Container Format (Audio+Video Emphasis)", LIBMTP_FILETYPE_MP4, PTP_OFC_MTP_MP4);
register_filetype("Audible.com Audio Codec", LIBMTP_FILETYPE_AUDIBLE, PTP_OFC_MTP_AudibleCodec);
register_filetype("Undefined audio file", LIBMTP_FILETYPE_UNDEF_AUDIO, PTP_OFC_MTP_UndefinedAudio);
register_filetype("Microsoft Windows Media Video", LIBMTP_FILETYPE_WMV, PTP_OFC_MTP_WMV);
register_filetype("Audio Video Interleave", LIBMTP_FILETYPE_AVI, PTP_OFC_AVI);
register_filetype("MPEG video stream", LIBMTP_FILETYPE_MPEG, PTP_OFC_MPEG);
register_filetype("Microsoft Advanced Systems Format", LIBMTP_FILETYPE_ASF, PTP_OFC_ASF);
register_filetype("Apple Quicktime container format", LIBMTP_FILETYPE_QT, PTP_OFC_QT);
register_filetype("Undefined video file", LIBMTP_FILETYPE_UNDEF_VIDEO, PTP_OFC_MTP_UndefinedVideo);
register_filetype("JPEG file", LIBMTP_FILETYPE_JPEG, PTP_OFC_EXIF_JPEG);
register_filetype("JP2 file", LIBMTP_FILETYPE_JP2, PTP_OFC_JP2);
register_filetype("JPX file", LIBMTP_FILETYPE_JPX, PTP_OFC_JPX);
register_filetype("JFIF file", LIBMTP_FILETYPE_JFIF, PTP_OFC_JFIF);
register_filetype("TIFF bitmap file", LIBMTP_FILETYPE_TIFF, PTP_OFC_TIFF);
register_filetype("BMP bitmap file", LIBMTP_FILETYPE_BMP, PTP_OFC_BMP);
register_filetype("GIF bitmap file", LIBMTP_FILETYPE_GIF, PTP_OFC_GIF);
register_filetype("PICT bitmap file", LIBMTP_FILETYPE_PICT, PTP_OFC_PICT);
register_filetype("Portable Network Graphics", LIBMTP_FILETYPE_PNG, PTP_OFC_PNG);
register_filetype("Microsoft Windows Image Format", LIBMTP_FILETYPE_WINDOWSIMAGEFORMAT, PTP_OFC_MTP_WindowsImageFormat);
register_filetype("VCalendar version 1", LIBMTP_FILETYPE_VCALENDAR1, PTP_OFC_MTP_vCalendar1);
register_filetype("VCalendar version 2", LIBMTP_FILETYPE_VCALENDAR2, PTP_OFC_MTP_vCalendar2);
register_filetype("VCard version 2", LIBMTP_FILETYPE_VCARD2, PTP_OFC_MTP_vCard2);
register_filetype("VCard version 3", LIBMTP_FILETYPE_VCARD3, PTP_OFC_MTP_vCard3);
register_filetype("Undefined Windows executable file", LIBMTP_FILETYPE_WINEXEC, PTP_OFC_MTP_UndefinedWindowsExecutable);
register_filetype("Text file", LIBMTP_FILETYPE_TEXT, PTP_OFC_Text);
register_filetype("HTML file", LIBMTP_FILETYPE_HTML, PTP_OFC_HTML);
register_filetype("XML file", LIBMTP_FILETYPE_XML, PTP_OFC_MTP_XMLDocument);
register_filetype("DOC file", LIBMTP_FILETYPE_DOC, PTP_OFC_MTP_MSWordDocument);
register_filetype("XLS file", LIBMTP_FILETYPE_XLS, PTP_OFC_MTP_MSExcelSpreadsheetXLS);
register_filetype("PPT file", LIBMTP_FILETYPE_PPT, PTP_OFC_MTP_MSPowerpointPresentationPPT);
register_filetype("MHT file", LIBMTP_FILETYPE_MHT, PTP_OFC_MTP_MHTCompiledHTMLDocument);
register_filetype("Firmware file", LIBMTP_FILETYPE_FIRMWARE, PTP_OFC_MTP_Firmware);
register_filetype("Abstract Album file", LIBMTP_FILETYPE_ALBUM, PTP_OFC_MTP_AbstractAudioAlbum);
register_filetype("Abstract Playlist file", LIBMTP_FILETYPE_PLAYLIST, PTP_OFC_MTP_AbstractAudioVideoPlaylist);
register_filetype("Undefined filetype", LIBMTP_FILETYPE_UNKNOWN, PTP_OFC_Undefined);
}
/**
* Returns the PTP filetype that maps to a certain libmtp internal file type.
* @param intype the MTP library interface type
* @return the PTP (libgphoto2) interface type
*/
static uint16_t map_libmtp_type_to_ptp_type(LIBMTP_filetype_t intype)
{
filemap_t *current;
current = g_filemap;
while (current != NULL) {
if(current->id == intype) {
return current->ptp_id;
}
current = current->next;
}
// printf("map_libmtp_type_to_ptp_type: unknown filetype.\n");
return PTP_OFC_Undefined;
}
/**
* Returns the MTP internal interface type that maps to a certain ptp
* interface type.
* @param intype the PTP (libgphoto2) interface type
* @return the MTP library interface type
*/
static LIBMTP_filetype_t map_ptp_type_to_libmtp_type(uint16_t intype)
{
filemap_t *current;
current = g_filemap;
while (current != NULL) {
if(current->ptp_id == intype) {
return current->id;
}
current = current->next;
}
// printf("map_ptp_type_to_libmtp_type: unknown filetype.\n");
return LIBMTP_FILETYPE_UNKNOWN;
}
/**
* Create a new property mapping entry
* @return a newly allocated propertymapping entry.
*/
static propertymap_t *new_propertymap_entry()
{
propertymap_t *propertymap;
propertymap = (propertymap_t *)malloc(sizeof(propertymap_t));
if( propertymap != NULL ) {
propertymap->description = NULL;
propertymap->id = LIBMTP_PROPERTY_UNKNOWN;
propertymap->ptp_id = 0;
propertymap->next = NULL;
}
return propertymap;
}
/**
* Register an MTP or PTP property for data retrieval
*
* @param description Text description of property
* @param id libmtp internal property id
* @param ptp_id PTP property id
* @return 0 for success any other value means error.
*/
static int register_property(char const * const description, LIBMTP_property_t const id,
uint16_t const ptp_id)
{
propertymap_t *new = NULL, *current;
// Has this LIBMTP propety been registered before ?
current = g_propertymap;
while (current != NULL) {
if(current->id == id) {
break;
}
current = current->next;
}
// Create the entry
if(current == NULL) {
new = new_propertymap_entry();
if(new == NULL) {
return 1;
}
new->id = id;
if(description != NULL) {
new->description = strdup(description);
}
new->ptp_id = ptp_id;
// Add the entry to the list
if(g_propertymap == NULL) {
g_propertymap = new;
} else {
current = g_propertymap;
while (current->next != NULL ) current=current->next;
current->next = new;
}
// Update the existing entry
} else {
if (current->description != NULL) {
free(current->description);
}
current->description = NULL;
if(description != NULL) {
current->description = strdup(description);
}
current->ptp_id = ptp_id;
}
return 0;
}
static void init_propertymap()
{
register_property("Storage ID", LIBMTP_PROPERTY_StorageID, PTP_OPC_StorageID);
register_property("Object Format", LIBMTP_PROPERTY_ObjectFormat, PTP_OPC_ObjectFormat);
register_property("Protection Status", LIBMTP_PROPERTY_ProtectionStatus, PTP_OPC_ProtectionStatus);
register_property("Object Size", LIBMTP_PROPERTY_ObjectSize, PTP_OPC_ObjectSize);
register_property("Association Type", LIBMTP_PROPERTY_AssociationType, PTP_OPC_AssociationType);
register_property("Association Desc", LIBMTP_PROPERTY_AssociationDesc, PTP_OPC_AssociationDesc);
register_property("Object File Name", LIBMTP_PROPERTY_ObjectFileName, PTP_OPC_ObjectFileName);
register_property("Date Created", LIBMTP_PROPERTY_DateCreated, PTP_OPC_DateCreated);
register_property("Date Modified", LIBMTP_PROPERTY_DateModified, PTP_OPC_DateModified);
register_property("Keywords", LIBMTP_PROPERTY_Keywords, PTP_OPC_Keywords);
register_property("Parent Object", LIBMTP_PROPERTY_ParentObject, PTP_OPC_ParentObject);
register_property("Allowed Folder Contents", LIBMTP_PROPERTY_AllowedFolderContents, PTP_OPC_AllowedFolderContents);
register_property("Hidden", LIBMTP_PROPERTY_Hidden, PTP_OPC_Hidden);
register_property("System Object", LIBMTP_PROPERTY_SystemObject, PTP_OPC_SystemObject);
register_property("Persistant Unique Object Identifier", LIBMTP_PROPERTY_PersistantUniqueObjectIdentifier, PTP_OPC_PersistantUniqueObjectIdentifier);
register_property("Sync ID", LIBMTP_PROPERTY_SyncID, PTP_OPC_SyncID);
register_property("Property Bag", LIBMTP_PROPERTY_PropertyBag, PTP_OPC_PropertyBag);
register_property("Name", LIBMTP_PROPERTY_Name, PTP_OPC_Name);
register_property("Created By", LIBMTP_PROPERTY_CreatedBy, PTP_OPC_CreatedBy);
register_property("Artist", LIBMTP_PROPERTY_Artist, PTP_OPC_Artist);
register_property("Date Authored", LIBMTP_PROPERTY_DateAuthored, PTP_OPC_DateAuthored);
register_property("Description", LIBMTP_PROPERTY_Description, PTP_OPC_Description);
register_property("URL Reference", LIBMTP_PROPERTY_URLReference, PTP_OPC_URLReference);
register_property("Language Locale", LIBMTP_PROPERTY_LanguageLocale, PTP_OPC_LanguageLocale);
register_property("Copyright Information", LIBMTP_PROPERTY_CopyrightInformation, PTP_OPC_CopyrightInformation);
register_property("Source", LIBMTP_PROPERTY_Source, PTP_OPC_Source);
register_property("Origin Location", LIBMTP_PROPERTY_OriginLocation, PTP_OPC_OriginLocation);
register_property("Date Added", LIBMTP_PROPERTY_DateAdded, PTP_OPC_DateAdded);
register_property("Non Consumable", LIBMTP_PROPERTY_NonConsumable, PTP_OPC_NonConsumable);
register_property("Corrupt Or Unplayable", LIBMTP_PROPERTY_CorruptOrUnplayable, PTP_OPC_CorruptOrUnplayable);
register_property("Producer Serial Number", LIBMTP_PROPERTY_ProducerSerialNumber, PTP_OPC_ProducerSerialNumber);
register_property("Representative Sample Format", LIBMTP_PROPERTY_RepresentativeSampleFormat, PTP_OPC_RepresentativeSampleFormat);
register_property("Representative Sample Sise", LIBMTP_PROPERTY_RepresentativeSampleSize, PTP_OPC_RepresentativeSampleSize);
register_property("Representative Sample Height", LIBMTP_PROPERTY_RepresentativeSampleHeight, PTP_OPC_RepresentativeSampleHeight);
register_property("Representative Sample Width", LIBMTP_PROPERTY_RepresentativeSampleWidth, PTP_OPC_RepresentativeSampleWidth);
register_property("Representative Sample Duration", LIBMTP_PROPERTY_RepresentativeSampleDuration, PTP_OPC_RepresentativeSampleDuration);
register_property("Representative Sample Data", LIBMTP_PROPERTY_RepresentativeSampleData, PTP_OPC_RepresentativeSampleData);
register_property("Width", LIBMTP_PROPERTY_Width, PTP_OPC_Width);
register_property("Height", LIBMTP_PROPERTY_Height, PTP_OPC_Height);
register_property("Duration", LIBMTP_PROPERTY_Duration, PTP_OPC_Duration);
register_property("Rating", LIBMTP_PROPERTY_Rating, PTP_OPC_Rating);
register_property("Track", LIBMTP_PROPERTY_Track, PTP_OPC_Track);
register_property("Genre", LIBMTP_PROPERTY_Genre, PTP_OPC_Genre);
register_property("Credits", LIBMTP_PROPERTY_Credits, PTP_OPC_Credits);
register_property("Lyrics", LIBMTP_PROPERTY_Lyrics, PTP_OPC_Lyrics);
register_property("Subscription Content ID", LIBMTP_PROPERTY_SubscriptionContentID, PTP_OPC_SubscriptionContentID);
register_property("Produced By", LIBMTP_PROPERTY_ProducedBy, PTP_OPC_ProducedBy);
register_property("Use Count", LIBMTP_PROPERTY_UseCount, PTP_OPC_UseCount);
register_property("Skip Count", LIBMTP_PROPERTY_SkipCount, PTP_OPC_SkipCount);
register_property("Last Accessed", LIBMTP_PROPERTY_LastAccessed, PTP_OPC_LastAccessed);
register_property("Parental Rating", LIBMTP_PROPERTY_ParentalRating, PTP_OPC_ParentalRating);
register_property("Meta Genre", LIBMTP_PROPERTY_MetaGenre, PTP_OPC_MetaGenre);
register_property("Composer", LIBMTP_PROPERTY_Composer, PTP_OPC_Composer);
register_property("Effective Rating", LIBMTP_PROPERTY_EffectiveRating, PTP_OPC_EffectiveRating);
register_property("Subtitle", LIBMTP_PROPERTY_Subtitle, PTP_OPC_Subtitle);
register_property("Original Release Date", LIBMTP_PROPERTY_OriginalReleaseDate, PTP_OPC_OriginalReleaseDate);
register_property("Album Name", LIBMTP_PROPERTY_AlbumName, PTP_OPC_AlbumName);
register_property("Album Artist", LIBMTP_PROPERTY_AlbumArtist, PTP_OPC_AlbumArtist);
register_property("Mood", LIBMTP_PROPERTY_Mood, PTP_OPC_Mood);
register_property("DRM Status", LIBMTP_PROPERTY_DRMStatus, PTP_OPC_DRMStatus);
register_property("Sub Description", LIBMTP_PROPERTY_SubDescription, PTP_OPC_SubDescription);
register_property("Is Cropped", LIBMTP_PROPERTY_IsCropped, PTP_OPC_IsCropped);
register_property("Is Color Corrected", LIBMTP_PROPERTY_IsColorCorrected, PTP_OPC_IsColorCorrected);
register_property("Image Bit Depth", LIBMTP_PROPERTY_ImageBitDepth, PTP_OPC_ImageBitDepth);
register_property("f Number", LIBMTP_PROPERTY_Fnumber, PTP_OPC_Fnumber);
register_property("Exposure Time", LIBMTP_PROPERTY_ExposureTime, PTP_OPC_ExposureTime);
register_property("Exposure Index", LIBMTP_PROPERTY_ExposureIndex, PTP_OPC_ExposureIndex);
register_property("Display Name", LIBMTP_PROPERTY_DisplayName, PTP_OPC_DisplayName);
register_property("Body Text", LIBMTP_PROPERTY_BodyText, PTP_OPC_BodyText);
register_property("Subject", LIBMTP_PROPERTY_Subject, PTP_OPC_Subject);
register_property("Priority", LIBMTP_PROPERTY_Priority, PTP_OPC_Priority);
register_property("Given Name", LIBMTP_PROPERTY_GivenName, PTP_OPC_GivenName);
register_property("Middle Names", LIBMTP_PROPERTY_MiddleNames, PTP_OPC_MiddleNames);
register_property("Family Name", LIBMTP_PROPERTY_FamilyName, PTP_OPC_FamilyName);
register_property("Prefix", LIBMTP_PROPERTY_Prefix, PTP_OPC_Prefix);
register_property("Suffix", LIBMTP_PROPERTY_Suffix, PTP_OPC_Suffix);
register_property("Phonetic Given Name", LIBMTP_PROPERTY_PhoneticGivenName, PTP_OPC_PhoneticGivenName);
register_property("Phonetic Family Name", LIBMTP_PROPERTY_PhoneticFamilyName, PTP_OPC_PhoneticFamilyName);
register_property("Email: Primary", LIBMTP_PROPERTY_EmailPrimary, PTP_OPC_EmailPrimary);
register_property("Email: Personal 1", LIBMTP_PROPERTY_EmailPersonal1, PTP_OPC_EmailPersonal1);
register_property("Email: Personal 2", LIBMTP_PROPERTY_EmailPersonal2, PTP_OPC_EmailPersonal2);
register_property("Email: Business 1", LIBMTP_PROPERTY_EmailBusiness1, PTP_OPC_EmailBusiness1);
register_property("Email: Business 2", LIBMTP_PROPERTY_EmailBusiness2, PTP_OPC_EmailBusiness2);
register_property("Email: Others", LIBMTP_PROPERTY_EmailOthers, PTP_OPC_EmailOthers);
register_property("Phone Number: Primary", LIBMTP_PROPERTY_PhoneNumberPrimary, PTP_OPC_PhoneNumberPrimary);
register_property("Phone Number: Personal", LIBMTP_PROPERTY_PhoneNumberPersonal, PTP_OPC_PhoneNumberPersonal);
register_property("Phone Number: Personal 2", LIBMTP_PROPERTY_PhoneNumberPersonal2, PTP_OPC_PhoneNumberPersonal2);
register_property("Phone Number: Business", LIBMTP_PROPERTY_PhoneNumberBusiness, PTP_OPC_PhoneNumberBusiness);
register_property("Phone Number: Business 2", LIBMTP_PROPERTY_PhoneNumberBusiness2, PTP_OPC_PhoneNumberBusiness2);
register_property("Phone Number: Mobile", LIBMTP_PROPERTY_PhoneNumberMobile, PTP_OPC_PhoneNumberMobile);
register_property("Phone Number: Mobile 2", LIBMTP_PROPERTY_PhoneNumberMobile2, PTP_OPC_PhoneNumberMobile2);
register_property("Fax Number: Primary", LIBMTP_PROPERTY_FaxNumberPrimary, PTP_OPC_FaxNumberPrimary);
register_property("Fax Number: Personal", LIBMTP_PROPERTY_FaxNumberPersonal, PTP_OPC_FaxNumberPersonal);
register_property("Fax Number: Business", LIBMTP_PROPERTY_FaxNumberBusiness, PTP_OPC_FaxNumberBusiness);
register_property("Pager Number", LIBMTP_PROPERTY_PagerNumber, PTP_OPC_PagerNumber);
register_property("Phone Number: Others", LIBMTP_PROPERTY_PhoneNumberOthers, PTP_OPC_PhoneNumberOthers);
register_property("Primary Web Address", LIBMTP_PROPERTY_PrimaryWebAddress, PTP_OPC_PrimaryWebAddress);
register_property("Personal Web Address", LIBMTP_PROPERTY_PersonalWebAddress, PTP_OPC_PersonalWebAddress);
register_property("Business Web Address", LIBMTP_PROPERTY_BusinessWebAddress, PTP_OPC_BusinessWebAddress);
register_property("Instant Messenger Address 1", LIBMTP_PROPERTY_InstantMessengerAddress, PTP_OPC_InstantMessengerAddress);
register_property("Instant Messenger Address 2", LIBMTP_PROPERTY_InstantMessengerAddress2, PTP_OPC_InstantMessengerAddress2);
register_property("Instant Messenger Address 3", LIBMTP_PROPERTY_InstantMessengerAddress3, PTP_OPC_InstantMessengerAddress3);
register_property("Postal Address: Personal: Full", LIBMTP_PROPERTY_PostalAddressPersonalFull, PTP_OPC_PostalAddressPersonalFull);
register_property("Postal Address: Personal: Line 1", LIBMTP_PROPERTY_PostalAddressPersonalFullLine1, PTP_OPC_PostalAddressPersonalFullLine1);
register_property("Postal Address: Personal: Line 2", LIBMTP_PROPERTY_PostalAddressPersonalFullLine2, PTP_OPC_PostalAddressPersonalFullLine2);
register_property("Postal Address: Personal: City", LIBMTP_PROPERTY_PostalAddressPersonalFullCity, PTP_OPC_PostalAddressPersonalFullCity);
register_property("Postal Address: Personal: Region", LIBMTP_PROPERTY_PostalAddressPersonalFullRegion, PTP_OPC_PostalAddressPersonalFullRegion);
register_property("Postal Address: Personal: Postal Code", LIBMTP_PROPERTY_PostalAddressPersonalFullPostalCode, PTP_OPC_PostalAddressPersonalFullPostalCode);
register_property("Postal Address: Personal: Country", LIBMTP_PROPERTY_PostalAddressPersonalFullCountry, PTP_OPC_PostalAddressPersonalFullCountry);
register_property("Postal Address: Business: Full", LIBMTP_PROPERTY_PostalAddressBusinessFull, PTP_OPC_PostalAddressBusinessFull);
register_property("Postal Address: Business: Line 1", LIBMTP_PROPERTY_PostalAddressBusinessLine1, PTP_OPC_PostalAddressBusinessLine1);
register_property("Postal Address: Business: Line 2", LIBMTP_PROPERTY_PostalAddressBusinessLine2, PTP_OPC_PostalAddressBusinessLine2);
register_property("Postal Address: Business: City", LIBMTP_PROPERTY_PostalAddressBusinessCity, PTP_OPC_PostalAddressBusinessCity);
register_property("Postal Address: Business: Region", LIBMTP_PROPERTY_PostalAddressBusinessRegion, PTP_OPC_PostalAddressBusinessRegion);
register_property("Postal Address: Business: Postal Code", LIBMTP_PROPERTY_PostalAddressBusinessPostalCode, PTP_OPC_PostalAddressBusinessPostalCode);
register_property("Postal Address: Business: Country", LIBMTP_PROPERTY_PostalAddressBusinessCountry, PTP_OPC_PostalAddressBusinessCountry);
register_property("Postal Address: Other: Full", LIBMTP_PROPERTY_PostalAddressOtherFull, PTP_OPC_PostalAddressOtherFull);
register_property("Postal Address: Other: Line 1", LIBMTP_PROPERTY_PostalAddressOtherLine1, PTP_OPC_PostalAddressOtherLine1);
register_property("Postal Address: Other: Line 2", LIBMTP_PROPERTY_PostalAddressOtherLine2, PTP_OPC_PostalAddressOtherLine2);
register_property("Postal Address: Other: City", LIBMTP_PROPERTY_PostalAddressOtherCity, PTP_OPC_PostalAddressOtherCity);
register_property("Postal Address: Other: Region", LIBMTP_PROPERTY_PostalAddressOtherRegion, PTP_OPC_PostalAddressOtherRegion);
register_property("Postal Address: Other: Postal Code", LIBMTP_PROPERTY_PostalAddressOtherPostalCode, PTP_OPC_PostalAddressOtherPostalCode);
register_property("Postal Address: Other: Counrtry", LIBMTP_PROPERTY_PostalAddressOtherCountry, PTP_OPC_PostalAddressOtherCountry);
register_property("Organization Name", LIBMTP_PROPERTY_OrganizationName, PTP_OPC_OrganizationName);
register_property("Phonetic Organization Name", LIBMTP_PROPERTY_PhoneticOrganizationName, PTP_OPC_PhoneticOrganizationName);
register_property("Role", LIBMTP_PROPERTY_Role, PTP_OPC_Role);
register_property("Birthdate", LIBMTP_PROPERTY_Birthdate, PTP_OPC_Birthdate);
register_property("Message To", LIBMTP_PROPERTY_MessageTo, PTP_OPC_MessageTo);
register_property("Message CC", LIBMTP_PROPERTY_MessageCC, PTP_OPC_MessageCC);
register_property("Message BCC", LIBMTP_PROPERTY_MessageBCC, PTP_OPC_MessageBCC);
register_property("Message Read", LIBMTP_PROPERTY_MessageRead, PTP_OPC_MessageRead);
register_property("Message Received Time", LIBMTP_PROPERTY_MessageReceivedTime, PTP_OPC_MessageReceivedTime);
register_property("Message Sender", LIBMTP_PROPERTY_MessageSender, PTP_OPC_MessageSender);
register_property("Activity Begin Time", LIBMTP_PROPERTY_ActivityBeginTime, PTP_OPC_ActivityBeginTime);
register_property("Activity End Time", LIBMTP_PROPERTY_ActivityEndTime, PTP_OPC_ActivityEndTime);
register_property("Activity Location", LIBMTP_PROPERTY_ActivityLocation, PTP_OPC_ActivityLocation);
register_property("Activity Required Attendees", LIBMTP_PROPERTY_ActivityRequiredAttendees, PTP_OPC_ActivityRequiredAttendees);
register_property("Optional Attendees", LIBMTP_PROPERTY_ActivityOptionalAttendees, PTP_OPC_ActivityOptionalAttendees);
register_property("Activity Resources", LIBMTP_PROPERTY_ActivityResources, PTP_OPC_ActivityResources);
register_property("Activity Accepted", LIBMTP_PROPERTY_ActivityAccepted, PTP_OPC_ActivityAccepted);
register_property("Owner", LIBMTP_PROPERTY_Owner, PTP_OPC_Owner);
register_property("Editor", LIBMTP_PROPERTY_Editor, PTP_OPC_Editor);
register_property("Webmaster", LIBMTP_PROPERTY_Webmaster, PTP_OPC_Webmaster);
register_property("URL Source", LIBMTP_PROPERTY_URLSource, PTP_OPC_URLSource);
register_property("URL Destination", LIBMTP_PROPERTY_URLDestination, PTP_OPC_URLDestination);
register_property("Time Bookmark", LIBMTP_PROPERTY_TimeBookmark, PTP_OPC_TimeBookmark);
register_property("Object Bookmark", LIBMTP_PROPERTY_ObjectBookmark, PTP_OPC_ObjectBookmark);
register_property("Byte Bookmark", LIBMTP_PROPERTY_ByteBookmark, PTP_OPC_ByteBookmark);
register_property("Last Build Date", LIBMTP_PROPERTY_LastBuildDate, PTP_OPC_LastBuildDate);
register_property("Time To Live", LIBMTP_PROPERTY_TimetoLive, PTP_OPC_TimetoLive);
register_property("Media GUID", LIBMTP_PROPERTY_MediaGUID, PTP_OPC_MediaGUID);
register_property("Total Bit Rate", LIBMTP_PROPERTY_TotalBitRate, PTP_OPC_TotalBitRate);
register_property("Bit Rate Type", LIBMTP_PROPERTY_BitRateType, PTP_OPC_BitRateType);
register_property("Sample Rate", LIBMTP_PROPERTY_SampleRate, PTP_OPC_SampleRate);
register_property("Number Of Channels", LIBMTP_PROPERTY_NumberOfChannels, PTP_OPC_NumberOfChannels);
register_property("Audio Bit Depth", LIBMTP_PROPERTY_AudioBitDepth, PTP_OPC_AudioBitDepth);
register_property("Scan Depth", LIBMTP_PROPERTY_ScanDepth, PTP_OPC_ScanDepth);
register_property("Audio WAVE Codec", LIBMTP_PROPERTY_AudioWAVECodec, PTP_OPC_AudioWAVECodec);
register_property("Audio Bit Rate", LIBMTP_PROPERTY_AudioBitRate, PTP_OPC_AudioBitRate);
register_property("Video Four CC Codec", LIBMTP_PROPERTY_VideoFourCCCodec, PTP_OPC_VideoFourCCCodec);
register_property("Video Bit Rate", LIBMTP_PROPERTY_VideoBitRate, PTP_OPC_VideoBitRate);
register_property("Frames Per Thousand Seconds", LIBMTP_PROPERTY_FramesPerThousandSeconds, PTP_OPC_FramesPerThousandSeconds);
register_property("Key Frame Distance", LIBMTP_PROPERTY_KeyFrameDistance, PTP_OPC_KeyFrameDistance);
register_property("Buffer Size", LIBMTP_PROPERTY_BufferSize, PTP_OPC_BufferSize);
register_property("Encoding Quality", LIBMTP_PROPERTY_EncodingQuality, PTP_OPC_EncodingQuality);
register_property("Encoding Profile", LIBMTP_PROPERTY_EncodingProfile, PTP_OPC_EncodingProfile);
register_property("Buy flag", LIBMTP_PROPERTY_BuyFlag, PTP_OPC_BuyFlag);
register_property("Unknown property", LIBMTP_PROPERTY_UNKNOWN, 0);
}
/**
* Returns the PTP property that maps to a certain libmtp internal property type.
* @param inproperty the MTP library interface property
* @return the PTP (libgphoto2) property type
*/
static uint16_t map_libmtp_property_to_ptp_property(LIBMTP_property_t inproperty)
{
propertymap_t *current;
current = g_propertymap;
while (current != NULL) {
if(current->id == inproperty) {
return current->ptp_id;
}
current = current->next;
}
return 0;
}
/**
* Returns the MTP internal interface property that maps to a certain ptp
* interface property.
* @param inproperty the PTP (libgphoto2) interface property
* @return the MTP library interface property
*/
static LIBMTP_property_t map_ptp_property_to_libmtp_property(uint16_t inproperty)
{
propertymap_t *current;
current = g_propertymap;
while (current != NULL) {
if(current->ptp_id == inproperty) {
return current->id;
}
current = current->next;
}
// printf("map_ptp_type_to_libmtp_type: unknown filetype.\n");
return LIBMTP_PROPERTY_UNKNOWN;
}
/**
* Set the debug level.
*
* By default, the debug level is set to '0' (disable).
*/
void LIBMTP_Set_Debug(int level)
{
if (LIBMTP_debug || level)
LIBMTP_ERROR("LIBMTP_Set_Debug: Setting debugging level to %d (0x%02x) "
"(%s)\n", level, level, level ? "on" : "off");
LIBMTP_debug = level;
}
/**
* Initialize the library. You are only supposed to call this
* one, before using the library for the first time in a program.
* Never re-initialize libmtp!
*
* The only thing this does at the moment is to initialise the
* filetype mapping table, as well as load MTPZ data if necessary.
*/
void LIBMTP_Init(void)
{
const char *env_debug = getenv("LIBMTP_DEBUG");
if (env_debug) {
const long debug_flags = strtol(env_debug, NULL, 0);
if (debug_flags != LONG_MIN && debug_flags != LONG_MAX &&
INT_MIN <= debug_flags && debug_flags <= INT_MAX) {
LIBMTP_Set_Debug(debug_flags);
} else {
fprintf(stderr, "LIBMTP_Init: error setting debug flags from environment "
"value \"%s\"\n", env_debug);
}
}
init_filemap();
init_propertymap();
if (mtpz_loaddata() == -1)
use_mtpz = 0;
else
use_mtpz = 1;
return;
}
/**
* This helper function returns a textual description for a libmtp
* file type to be used in dialog boxes etc.
* @param intype the libmtp internal filetype to get a description for.
* @return a string representing the filetype, this must <b>NOT</b>
* be free():ed by the caller!
*/
char const * LIBMTP_Get_Filetype_Description(LIBMTP_filetype_t intype)
{
filemap_t *current;
current = g_filemap;
while (current != NULL) {
if(current->id == intype) {
return current->description;
}
current = current->next;
}
return "Unknown filetype";
}
/**
* This helper function returns a textual description for a libmtp
* property to be used in dialog boxes etc.
* @param inproperty the libmtp internal property to get a description for.
* @return a string representing the filetype, this must <b>NOT</b>
* be free():ed by the caller!
*/
char const * LIBMTP_Get_Property_Description(LIBMTP_property_t inproperty)
{
propertymap_t *current;
current = g_propertymap;
while (current != NULL) {
if(current->id == inproperty) {
return current->description;
}
current = current->next;
}
return "Unknown property";
}
/**
* This function will do its best to fit a 16bit
* value into a PTP object property if the property
* is limited in range or step sizes.
*/
static uint16_t adjust_u16(uint16_t val, PTPObjectPropDesc *opd)
{
switch (opd->FormFlag) {
case PTP_DPFF_Range:
if (val < opd->FORM.Range.MinimumValue.u16) {
return opd->FORM.Range.MinimumValue.u16;
}
if (val > opd->FORM.Range.MaximumValue.u16) {
return opd->FORM.Range.MaximumValue.u16;
}
// Round down to last step.
if (val % opd->FORM.Range.StepSize.u16 != 0) {
return val - (val % opd->FORM.Range.StepSize.u16);
}
return val;
break;
case PTP_DPFF_Enumeration:
{
int i;
uint16_t bestfit = opd->FORM.Enum.SupportedValue[0].u16;
for (i=0; i<opd->FORM.Enum.NumberOfValues; i++) {
if (val == opd->FORM.Enum.SupportedValue[i].u16) {
return val;
}
// Rough guess of best fit
if (opd->FORM.Enum.SupportedValue[i].u16 < val) {
bestfit = opd->FORM.Enum.SupportedValue[i].u16;
}
}
// Just some default that'll work.
return bestfit;
}
default:
// Will accept any value
break;
}
return val;
}
/**
* This function will do its best to fit a 32bit
* value into a PTP object property if the property
* is limited in range or step sizes.
*/
static uint32_t adjust_u32(uint32_t val, PTPObjectPropDesc *opd)
{
switch (opd->FormFlag) {
case PTP_DPFF_Range:
if (val < opd->FORM.Range.MinimumValue.u32) {
return opd->FORM.Range.MinimumValue.u32;
}
if (val > opd->FORM.Range.MaximumValue.u32) {
return opd->FORM.Range.MaximumValue.u32;
}
// Round down to last step.
if (val % opd->FORM.Range.StepSize.u32 != 0) {
return val - (val % opd->FORM.Range.StepSize.u32);
}
return val;
break;
case PTP_DPFF_Enumeration:
{
int i;
uint32_t bestfit = opd->FORM.Enum.SupportedValue[0].u32;
for (i=0; i<opd->FORM.Enum.NumberOfValues; i++) {
if (val == opd->FORM.Enum.SupportedValue[i].u32) {
return val;
}
// Rough guess of best fit
if (opd->FORM.Enum.SupportedValue[i].u32 < val) {
bestfit = opd->FORM.Enum.SupportedValue[i].u32;
}
}
// Just some default that'll work.
return bestfit;
}
default:
// Will accept any value
break;
}
return val;
}
/**
* This function returns a newly created ISO 8601 timestamp with the
* current time in as high precision as possible. It even adds
* the time zone if it can.
*/
static char *get_iso8601_stamp(void)
{
time_t curtime;
struct tm *loctime;
char tmp[64];
curtime = time(NULL);
loctime = localtime(&curtime);
strftime (tmp, sizeof(tmp), "%Y%m%dT%H%M%S.0%z", loctime);
return strdup(tmp);
}
/**
* Gets the allowed values (range or enum) for a property
* @param device a pointer to an MTP device
* @param property the property to query
* @param filetype the filetype of the object you want to set values for
* @param allowed_vals pointer to a LIBMTP_allowed_values_t struct to
* receive the allowed values. Call LIBMTP_destroy_allowed_values_t
* on this on successful completion.
* @return 0 on success, any other value means failure
*/
int LIBMTP_Get_Allowed_Property_Values(LIBMTP_mtpdevice_t *device, LIBMTP_property_t const property,
LIBMTP_filetype_t const filetype, LIBMTP_allowed_values_t *allowed_vals)
{
PTPObjectPropDesc opd;
uint16_t ret = 0;
ret = ptp_mtp_getobjectpropdesc(device->params, map_libmtp_property_to_ptp_property(property), map_libmtp_type_to_ptp_type(filetype), &opd);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Allowed_Property_Values(): could not get property description.");
return -1;
}
if (opd.FormFlag == PTP_OPFF_Enumeration) {
int i = 0;
allowed_vals->is_range = 0;
allowed_vals->num_entries = opd.FORM.Enum.NumberOfValues;
switch (opd.DataType)
{
case PTP_DTC_INT8:
allowed_vals->i8vals = malloc(sizeof(int8_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_INT8;
break;
case PTP_DTC_UINT8:
allowed_vals->u8vals = malloc(sizeof(uint8_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_UINT8;
break;
case PTP_DTC_INT16:
allowed_vals->i16vals = malloc(sizeof(int16_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_INT16;
break;
case PTP_DTC_UINT16:
allowed_vals->u16vals = malloc(sizeof(uint16_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_UINT16;
break;
case PTP_DTC_INT32:
allowed_vals->i32vals = malloc(sizeof(int32_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_INT32;
break;
case PTP_DTC_UINT32:
allowed_vals->u32vals = malloc(sizeof(uint32_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_UINT32;
break;
case PTP_DTC_INT64:
allowed_vals->i64vals = malloc(sizeof(int64_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_INT64;
break;
case PTP_DTC_UINT64:
allowed_vals->u64vals = malloc(sizeof(uint64_t) * opd.FORM.Enum.NumberOfValues);
allowed_vals->datatype = LIBMTP_DATATYPE_UINT64;
break;
}
for (i = 0; i < opd.FORM.Enum.NumberOfValues; i++) {
switch (opd.DataType)
{
case PTP_DTC_INT8:
allowed_vals->i8vals[i] = opd.FORM.Enum.SupportedValue[i].i8;
break;
case PTP_DTC_UINT8:
allowed_vals->u8vals[i] = opd.FORM.Enum.SupportedValue[i].u8;
break;
case PTP_DTC_INT16:
allowed_vals->i16vals[i] = opd.FORM.Enum.SupportedValue[i].i16;
break;
case PTP_DTC_UINT16:
allowed_vals->u16vals[i] = opd.FORM.Enum.SupportedValue[i].u16;
break;
case PTP_DTC_INT32:
allowed_vals->i32vals[i] = opd.FORM.Enum.SupportedValue[i].i32;
break;
case PTP_DTC_UINT32:
allowed_vals->u32vals[i] = opd.FORM.Enum.SupportedValue[i].u32;
break;
case PTP_DTC_INT64:
allowed_vals->i64vals[i] = opd.FORM.Enum.SupportedValue[i].i64;
break;
case PTP_DTC_UINT64:
allowed_vals->u64vals[i] = opd.FORM.Enum.SupportedValue[i].u64;
break;
}
}
ptp_free_objectpropdesc(&opd);
return 0;
} else if (opd.FormFlag == PTP_OPFF_Range) {
allowed_vals->is_range = 1;
switch (opd.DataType)
{
case PTP_DTC_INT8:
allowed_vals->i8min = opd.FORM.Range.MinimumValue.i8;
allowed_vals->i8max = opd.FORM.Range.MaximumValue.i8;
allowed_vals->i8step = opd.FORM.Range.StepSize.i8;
allowed_vals->datatype = LIBMTP_DATATYPE_INT8;
break;
case PTP_DTC_UINT8:
allowed_vals->u8min = opd.FORM.Range.MinimumValue.u8;
allowed_vals->u8max = opd.FORM.Range.MaximumValue.u8;
allowed_vals->u8step = opd.FORM.Range.StepSize.u8;
allowed_vals->datatype = LIBMTP_DATATYPE_UINT8;
break;
case PTP_DTC_INT16:
allowed_vals->i16min = opd.FORM.Range.MinimumValue.i16;
allowed_vals->i16max = opd.FORM.Range.MaximumValue.i16;
allowed_vals->i16step = opd.FORM.Range.StepSize.i16;
allowed_vals->datatype = LIBMTP_DATATYPE_INT16;
break;
case PTP_DTC_UINT16:
allowed_vals->u16min = opd.FORM.Range.MinimumValue.u16;
allowed_vals->u16max = opd.FORM.Range.MaximumValue.u16;
allowed_vals->u16step = opd.FORM.Range.StepSize.u16;
allowed_vals->datatype = LIBMTP_DATATYPE_UINT16;
break;
case PTP_DTC_INT32:
allowed_vals->i32min = opd.FORM.Range.MinimumValue.i32;
allowed_vals->i32max = opd.FORM.Range.MaximumValue.i32;
allowed_vals->i32step = opd.FORM.Range.StepSize.i32;
allowed_vals->datatype = LIBMTP_DATATYPE_INT32;
break;
case PTP_DTC_UINT32:
allowed_vals->u32min = opd.FORM.Range.MinimumValue.u32;
allowed_vals->u32max = opd.FORM.Range.MaximumValue.u32;
allowed_vals->u32step = opd.FORM.Range.StepSize.u32;
allowed_vals->datatype = LIBMTP_DATATYPE_UINT32;
break;
case PTP_DTC_INT64:
allowed_vals->i64min = opd.FORM.Range.MinimumValue.i64;
allowed_vals->i64max = opd.FORM.Range.MaximumValue.i64;
allowed_vals->i64step = opd.FORM.Range.StepSize.i64;
allowed_vals->datatype = LIBMTP_DATATYPE_INT64;
break;
case PTP_DTC_UINT64:
allowed_vals->u64min = opd.FORM.Range.MinimumValue.u64;
allowed_vals->u64max = opd.FORM.Range.MaximumValue.u64;
allowed_vals->u64step = opd.FORM.Range.StepSize.u64;
allowed_vals->datatype = LIBMTP_DATATYPE_UINT64;
break;
}
return 0;
} else
return -1;
}
/**
* Destroys a LIBMTP_allowed_values_t struct
* @param allowed_vals the struct to destroy
*/
void LIBMTP_destroy_allowed_values_t(LIBMTP_allowed_values_t *allowed_vals)
{
if (!allowed_vals->is_range)
{
switch (allowed_vals->datatype)
{
case LIBMTP_DATATYPE_INT8:
if (allowed_vals->i8vals)
free(allowed_vals->i8vals);
break;
case LIBMTP_DATATYPE_UINT8:
if (allowed_vals->u8vals)
free(allowed_vals->u8vals);
break;
case LIBMTP_DATATYPE_INT16:
if (allowed_vals->i16vals)
free(allowed_vals->i16vals);
break;
case LIBMTP_DATATYPE_UINT16:
if (allowed_vals->u16vals)
free(allowed_vals->u16vals);
break;
case LIBMTP_DATATYPE_INT32:
if (allowed_vals->i32vals)
free(allowed_vals->i32vals);
break;
case LIBMTP_DATATYPE_UINT32:
if (allowed_vals->u32vals)
free(allowed_vals->u32vals);
break;
case LIBMTP_DATATYPE_INT64:
if (allowed_vals->i64vals)
free(allowed_vals->i64vals);
break;
case LIBMTP_DATATYPE_UINT64:
if (allowed_vals->u64vals)
free(allowed_vals->u64vals);
break;
}
}
}
/**
* Determine if a property is supported for a given file type
* @param device a pointer to an MTP device
* @param property the property to query
* @param filetype the filetype of the object you want to set values for
* @return 0 if not supported, positive if supported, negative on error
*/
int LIBMTP_Is_Property_Supported(LIBMTP_mtpdevice_t *device, LIBMTP_property_t const property,
LIBMTP_filetype_t const filetype)
{
uint16_t *props = NULL;
uint32_t propcnt = 0;
uint16_t ret = 0;
int i = 0;
int supported = 0;
uint16_t ptp_prop = map_libmtp_property_to_ptp_property(property);
if (!ptp_operation_issupported(device->params, PTP_OC_MTP_GetObjectPropsSupported))
return 0;
ret = ptp_mtp_getobjectpropssupported(device->params, map_libmtp_type_to_ptp_type(filetype), &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Is_Property_Supported(): could not get properties supported.");
return -1;
}
for (i = 0; i < propcnt; i++) {
if (props[i] == ptp_prop) {
supported = 1;
break;
}
}
free(props);
return supported;
}
/**
* Retrieves a string from an object
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @return valid string or NULL on failure. The returned string
* must bee <code>free()</code>:ed by the caller after
* use.
*/
char *LIBMTP_Get_String_From_Object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id)
{
return get_string_from_object(device, object_id, attribute_id);
}
/**
* Retrieves an unsigned 64-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value_default Default value to return on failure
* @return the value
*/
uint64_t LIBMTP_Get_u64_From_Object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint64_t const value_default)
{
return get_u64_from_object(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value_default);
}
/**
* Retrieves an unsigned 32-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value_default Default value to return on failure
* @return the value
*/
uint32_t LIBMTP_Get_u32_From_Object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint32_t const value_default)
{
return get_u32_from_object(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value_default);
}
/**
* Retrieves an unsigned 16-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value_default Default value to return on failure
* @return a value
*/
uint16_t LIBMTP_Get_u16_From_Object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint16_t const value_default)
{
return get_u16_from_object(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value_default);
}
/**
* Retrieves an unsigned 8-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value_default Default value to return on failure
* @return a value
*/
uint8_t LIBMTP_Get_u8_From_Object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint8_t const value_default)
{
return get_u8_from_object(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value_default);
}
/**
* Sets an object attribute from a string
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param string string value to set
* @return 0 on success, any other value means failure
*/
int LIBMTP_Set_Object_String(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, char const * const string)
{
return set_object_string(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), string);
}
/**
* Sets an object attribute from an unsigned 32-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value 32-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
int LIBMTP_Set_Object_u32(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint32_t const value)
{
return set_object_u32(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value);
}
/**
* Sets an object attribute from an unsigned 16-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value 16-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
int LIBMTP_Set_Object_u16(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint16_t const value)
{
return set_object_u16(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value);
}
/**
* Sets an object attribute from an unsigned 8-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id MTP attribute ID
* @param value 8-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
int LIBMTP_Set_Object_u8(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
LIBMTP_property_t const attribute_id, uint8_t const value)
{
return set_object_u8(device, object_id, map_libmtp_property_to_ptp_property(attribute_id), value);
}
/**
* Retrieves a string from an object
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @return valid string or NULL on failure. The returned string
* must bee <code>free()</code>:ed by the caller after
* use.
*/
static char *get_string_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id)
{
PTPPropertyValue propval;
char *retstring = NULL;
PTPParams *params;
uint16_t ret;
MTPProperties *prop;
if (!device || !object_id)
return NULL;
params = (PTPParams *) device->params;
prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
if (prop) {
if (prop->propval.str != NULL)
return strdup(prop->propval.str);
else
return NULL;
}
ret = ptp_mtp_getobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_STR);
if (ret == PTP_RC_OK) {
if (propval.str != NULL) {
retstring = (char *) strdup(propval.str);
free(propval.str);
}
} else {
add_ptp_error_to_errorstack(device, ret, "get_string_from_object(): could not get object string.");
}
return retstring;
}
/**
* Retrieves an unsigned 64-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value_default Default value to return on failure
* @return the value
*/
static uint64_t get_u64_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
uint16_t const attribute_id, uint64_t const value_default)
{
PTPPropertyValue propval;
uint64_t retval = value_default;
PTPParams *params;
uint16_t ret;
MTPProperties *prop;
if (!device)
return value_default;
params = (PTPParams *) device->params;
prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
if (prop)
return prop->propval.u64;
ret = ptp_mtp_getobjectpropvalue(params, object_id,
attribute_id,
&propval,
PTP_DTC_UINT64);
if (ret == PTP_RC_OK) {
retval = propval.u64;
} else {
add_ptp_error_to_errorstack(device, ret, "get_u64_from_object(): could not get unsigned 64bit integer from object.");
}
return retval;
}
/**
* Retrieves an unsigned 32-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value_default Default value to return on failure
* @return the value
*/
static uint32_t get_u32_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
uint16_t const attribute_id, uint32_t const value_default)
{
PTPPropertyValue propval;
uint32_t retval = value_default;
PTPParams *params;
uint16_t ret;
MTPProperties *prop;
if (!device)
return value_default;
params = (PTPParams *) device->params;
prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
if (prop)
return prop->propval.u32;
ret = ptp_mtp_getobjectpropvalue(params, object_id,
attribute_id,
&propval,
PTP_DTC_UINT32);
if (ret == PTP_RC_OK) {
retval = propval.u32;
} else {
add_ptp_error_to_errorstack(device, ret, "get_u32_from_object(): could not get unsigned 32bit integer from object.");
}
return retval;
}
/**
* Retrieves an unsigned 16-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value_default Default value to return on failure
* @return a value
*/
static uint16_t get_u16_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint16_t const value_default)
{
PTPPropertyValue propval;
uint16_t retval = value_default;
PTPParams *params;
uint16_t ret;
MTPProperties *prop;
if (!device)
return value_default;
params = (PTPParams *) device->params;
// This O(n) search should not be used so often, since code
// using the cached properties don't usually call this function.
prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
if (prop)
return prop->propval.u16;
ret = ptp_mtp_getobjectpropvalue(params, object_id,
attribute_id,
&propval,
PTP_DTC_UINT16);
if (ret == PTP_RC_OK) {
retval = propval.u16;
} else {
add_ptp_error_to_errorstack(device, ret, "get_u16_from_object(): could not get unsigned 16bit integer from object.");
}
return retval;
}
/**
* Retrieves an unsigned 8-bit integer from an object attribute
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value_default Default value to return on failure
* @return a value
*/
static uint8_t get_u8_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint8_t const value_default)
{
PTPPropertyValue propval;
uint8_t retval = value_default;
PTPParams *params;
uint16_t ret;
MTPProperties *prop;
if (!device)
return value_default;
params = (PTPParams *) device->params;
// This O(n) search should not be used so often, since code
// using the cached properties don't usually call this function.
prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
if (prop)
return prop->propval.u8;
ret = ptp_mtp_getobjectpropvalue(params, object_id,
attribute_id,
&propval,
PTP_DTC_UINT8);
if (ret == PTP_RC_OK) {
retval = propval.u8;
} else {
add_ptp_error_to_errorstack(device, ret, "get_u8_from_object(): could not get unsigned 8bit integer from object.");
}
return retval;
}
/**
* Sets an object attribute from a string
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param string string value to set
* @return 0 on success, any other value means failure
*/
static int set_object_string(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, char const * const string)
{
PTPPropertyValue propval;
PTPParams *params;
uint16_t ret;
if (!device || !string)
return -1;
params = (PTPParams *) device->params;
if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_string(): could not set object string: "
"PTP_OC_MTP_SetObjectPropValue not supported.");
return -1;
}
propval.str = (char *) string;
ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_STR);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "set_object_string(): could not set object string.");
return -1;
}
return 0;
}
/**
* Sets an object attribute from an unsigned 32-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value 32-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
static int set_object_u32(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint32_t const value)
{
PTPPropertyValue propval;
PTPParams *params;
uint16_t ret;
if (!device)
return -1;
params = (PTPParams *) device->params;
if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u32(): could not set unsigned 32bit integer property: "
"PTP_OC_MTP_SetObjectPropValue not supported.");
return -1;
}
propval.u32 = value;
ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT32);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "set_object_u32(): could not set unsigned 32bit integer property.");
return -1;
}
return 0;
}
/**
* Sets an object attribute from an unsigned 16-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value 16-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
static int set_object_u16(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint16_t const value)
{
PTPPropertyValue propval;
PTPParams *params;
uint16_t ret;
if (!device)
return 1;
params = (PTPParams *) device->params;
if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u16(): could not set unsigned 16bit integer property: "
"PTP_OC_MTP_SetObjectPropValue not supported.");
return -1;
}
propval.u16 = value;
ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT16);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "set_object_u16(): could not set unsigned 16bit integer property.");
return 1;
}
return 0;
}
/**
* Sets an object attribute from an unsigned 8-bit integer
*
* @param device a pointer to an MTP device.
* @param object_id Object reference
* @param attribute_id PTP attribute ID
* @param value 8-bit unsigned integer to set
* @return 0 on success, any other value means failure
*/
static int set_object_u8(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
uint16_t const attribute_id, uint8_t const value)
{
PTPPropertyValue propval;
PTPParams *params;
uint16_t ret;
if (!device)
return 1;
params = (PTPParams *) device->params;
if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u8(): could not set unsigned 8bit integer property: "
"PTP_OC_MTP_SetObjectPropValue not supported.");
return -1;
}
propval.u8 = value;
ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT8);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "set_object_u8(): could not set unsigned 8bit integer property.");
return 1;
}
return 0;
}
/**
* Get the first (as in "first in the list of") connected MTP device.
* @return a device pointer.
* @see LIBMTP_Get_Connected_Devices()
*/
LIBMTP_mtpdevice_t *LIBMTP_Get_First_Device(void)
{
LIBMTP_mtpdevice_t *first_device = NULL;
LIBMTP_raw_device_t *devices;
int numdevs;
LIBMTP_error_number_t ret;
ret = LIBMTP_Detect_Raw_Devices(&devices, &numdevs);
if (ret != LIBMTP_ERROR_NONE) {
return NULL;
}
if (devices == NULL || numdevs == 0) {
free(devices);
return NULL;
}
first_device = LIBMTP_Open_Raw_Device(&devices[0]);
free(devices);
return first_device;
}
/**
* Overriding debug function.
* This way we can disable debug prints.
*/
static void
#ifdef __GNUC__
__attribute__((__format__(printf,2,0)))
#endif
LIBMTP_ptp_debug(void *data, const char *format, va_list args)
{
if ((LIBMTP_debug & LIBMTP_DEBUG_PTP) != 0) {
vfprintf (stderr, format, args);
fprintf (stderr, "\n");
fflush (stderr);
}
}
/**
* Overriding error function.
* This way we can capture all error etc to our errorstack.
*/
static void
#ifdef __GNUC__
__attribute__((__format__(printf,2,0)))
#endif
LIBMTP_ptp_error(void *data, const char *format, va_list args)
{
// if (data == NULL) {
vfprintf (stderr, format, args);
fflush (stderr);
/*
FIXME: find out how we shall get the device here.
} else {
PTP_USB *ptp_usb = data;
LIBMTP_mtpdevice_t *device = ...;
char buf[2048];
vsnprintf (buf, sizeof (buf), format, args);
add_error_to_errorstack(device,
LIBMTP_ERROR_PTP_LAYER,
buf);
}
*/
}
/**
* Parses the extension descriptor, there may be stuff in
* this that we want to know about.
*/
static void parse_extension_descriptor(LIBMTP_mtpdevice_t *mtpdevice,
char *desc)
{
int start = 0;
int end = 0;
/* NULL on Canon A70 */
if (!desc)
return;
/* descriptors are divided by semicolons */
while (end < strlen(desc)) {
/* Skip past initial whitespace */
while ((end < strlen(desc)) && (desc[start] == ' ' )) {
start++;
end++;
}
/* Detect extension */
while ((end < strlen(desc)) && (desc[end] != ';'))
end++;
if (end < strlen(desc)) {
char *element = strndup(desc + start, end-start);
if (element) {
int i = 0;
// printf(" Element: \"%s\"\n", element);
/* Parse for an extension */
while ((i < strlen(element)) && (element[i] != ':'))
i++;
if (i < strlen(element)) {
char *name = strndup(element, i);
int major = 0, minor = 0;
/* extension versions have to be MAJOR.MINOR, but Samsung has one
* with just 0, so just cope with those cases too */
if ( (2 == sscanf(element+i+1,"%d.%d",&major,&minor)) ||
(1 == sscanf(element+i+1,"%d",&major))
) {
LIBMTP_device_extension_t *extension;
extension = malloc(sizeof(LIBMTP_device_extension_t));
extension->name = name;
extension->major = major;
extension->minor = minor;
extension->next = NULL;
if (mtpdevice->extensions == NULL) {
mtpdevice->extensions = extension;
} else {
LIBMTP_device_extension_t *tmp = mtpdevice->extensions;
while (tmp->next != NULL)
tmp = tmp->next;
tmp->next = extension;
}
} else {
LIBMTP_ERROR("LIBMTP ERROR: couldnt parse extension %s\n",
element);
}
}
free(element);
}
}
end++;
start = end;
}
}
/**
* This function opens a device from a raw device. It is the
* preferred way to access devices in the new interface where
* several devices can come and go as the library is working
* on a certain device.
* @param rawdevice the raw device to open a "real" device for.
* @return an open device.
*/
LIBMTP_mtpdevice_t *LIBMTP_Open_Raw_Device_Uncached(LIBMTP_raw_device_t *rawdevice)
{
LIBMTP_mtpdevice_t *mtp_device;
uint8_t bs = 0;
PTPParams *current_params;
PTP_USB *ptp_usb;
LIBMTP_error_number_t err;
int i;
/* Allocate dynamic space for our device */
mtp_device = (LIBMTP_mtpdevice_t *) malloc(sizeof(LIBMTP_mtpdevice_t));
/* Check if there was a memory allocation error */
if(mtp_device == NULL) {
/* There has been an memory allocation error. We are going to ignore this
device and attempt to continue */
/* TODO: This error statement could probably be a bit more robust */
LIBMTP_ERROR("LIBMTP PANIC: connect_usb_devices encountered a memory "
"allocation error with device %d on bus %d, trying to continue",
rawdevice->devnum, rawdevice->bus_location);
return NULL;
}
memset(mtp_device, 0, sizeof(LIBMTP_mtpdevice_t));
// Non-cached by default
mtp_device->cached = 0;
/* Create PTP params */
current_params = (PTPParams *) malloc(sizeof(PTPParams));
if (current_params == NULL) {
free(mtp_device);
return NULL;
}
memset(current_params, 0, sizeof(PTPParams));
current_params->device_flags = rawdevice->device_entry.device_flags;
current_params->nrofobjects = 0;
current_params->cachetime = 2;
current_params->objects = NULL;
current_params->response_packet_size = 0;
current_params->response_packet = NULL;
/* This will be a pointer to PTP_USB later */
current_params->data = NULL;
/* Set upp local debug and error functions */
current_params->debug_func = LIBMTP_ptp_debug;
current_params->error_func = LIBMTP_ptp_error;
/* TODO: Will this always be little endian? */
current_params->byteorder = PTP_DL_LE;
current_params->cd_locale_to_ucs2 = iconv_open("UCS-2LE", "UTF-8");
current_params->cd_ucs2_to_locale = iconv_open("UTF-8", "UCS-2LE");
if(current_params->cd_locale_to_ucs2 == (iconv_t) -1 ||
current_params->cd_ucs2_to_locale == (iconv_t) -1) {
LIBMTP_ERROR("LIBMTP PANIC: Cannot open iconv() converters to/from UCS-2!\n"
"Too old stdlibc, glibc and libiconv?\n");
free(current_params);
free(mtp_device);
return NULL;
}
mtp_device->params = current_params;
/* Create usbinfo, this also opens the session */
err = configure_usb_device(rawdevice,
current_params,
&mtp_device->usbinfo);
if (err != LIBMTP_ERROR_NONE) {
free(current_params);
free(mtp_device);
return NULL;
}
ptp_usb = (PTP_USB*) mtp_device->usbinfo;
/* Set pointer back to params */
ptp_usb->params = current_params;
/* Cache the device information for later use */
if (ptp_getdeviceinfo(current_params,
¤t_params->deviceinfo) != PTP_RC_OK) {
LIBMTP_ERROR("LIBMTP PANIC: Unable to read device information on device "
"%d on bus %d, trying to continue",
rawdevice->devnum, rawdevice->bus_location);
/* Prevent memory leaks for this device */
free(mtp_device->usbinfo);
free(mtp_device->params);
current_params = NULL;
free(mtp_device);
return NULL;
}
/* Check: if this is a PTP device, is it really tagged as MTP? */
if (current_params->deviceinfo.VendorExtensionID != 0x00000006) {
LIBMTP_ERROR("LIBMTP WARNING: no MTP vendor extension on device "
"%d on bus %d",
rawdevice->devnum, rawdevice->bus_location);
LIBMTP_ERROR("LIBMTP WARNING: VendorExtensionID: %08x",
current_params->deviceinfo.VendorExtensionID);
LIBMTP_ERROR("LIBMTP WARNING: VendorExtensionDesc: %s",
current_params->deviceinfo.VendorExtensionDesc);
LIBMTP_ERROR("LIBMTP WARNING: this typically means the device is PTP "
"(i.e. a camera) but not an MTP device at all. "
"Trying to continue anyway.");
}
parse_extension_descriptor(mtp_device,
current_params->deviceinfo.VendorExtensionDesc);
/*
* Android has a number of bugs, force-assign these bug flags
* if Android is encountered. Same thing for devices we detect
* as SONY NWZ Walkmen. I have no clue what "sony.net/WMFU" means
* I just know only NWZs have it.
*/
{
LIBMTP_device_extension_t *tmpext = mtp_device->extensions;
int is_microsoft_com_wpdna = 0;
int is_android = 0;
int is_sony_net_wmfu = 0;
int is_sonyericsson_com_se = 0;
/* Loop over extensions and set flags */
while (tmpext != NULL) {
if (!strcmp(tmpext->name, "microsoft.com/WPDNA"))
is_microsoft_com_wpdna = 1;
if (!strcmp(tmpext->name, "android.com"))
is_android = 1;
if (!strcmp(tmpext->name, "sony.net/WMFU"))
is_sony_net_wmfu = 1;
if (!strcmp(tmpext->name, "sonyericsson.com/SE"))
is_sonyericsson_com_se = 1;
tmpext = tmpext->next;
}
/* Check for specific stacks */
if (is_microsoft_com_wpdna && is_sonyericsson_com_se && !is_android) {
/*
* The Aricent stack seems to be detected by providing WPDNA, the SonyEricsson
* extension and NO Android extension.
*/
ptp_usb->rawdevice.device_entry.device_flags |= DEVICE_FLAGS_ARICENT_BUGS;
LIBMTP_INFO("Aricent MTP stack device detected, assigning default bug flags\n");
}
else if (is_android) {
/*
* If bugs are fixed in later versions, test on tmpext->major, tmpext->minor
*/
ptp_usb->rawdevice.device_entry.device_flags |= DEVICE_FLAGS_ANDROID_BUGS;
LIBMTP_INFO("Android device detected, assigning default bug flags\n");
}
else if (is_sony_net_wmfu) {
ptp_usb->rawdevice.device_entry.device_flags |= DEVICE_FLAGS_SONY_NWZ_BUGS;
LIBMTP_INFO("SONY NWZ device detected, assigning default bug flags\n");
}
}
/*
* If the OGG or FLAC filetypes are flagged as "unknown", check
* if the firmware has been updated to actually support it.
*/
if (FLAG_OGG_IS_UNKNOWN(ptp_usb)) {
for (i=0;i<current_params->deviceinfo.ImageFormats_len;i++) {
if (current_params->deviceinfo.ImageFormats[i] == PTP_OFC_MTP_OGG) {
/* This is not unknown anymore, unflag it */
ptp_usb->rawdevice.device_entry.device_flags &=
~DEVICE_FLAG_OGG_IS_UNKNOWN;
break;
}
}
}
if (FLAG_FLAC_IS_UNKNOWN(ptp_usb)) {
for (i=0;i<current_params->deviceinfo.ImageFormats_len;i++) {
if (current_params->deviceinfo.ImageFormats[i] == PTP_OFC_MTP_FLAC) {
/* This is not unknown anymore, unflag it */
ptp_usb->rawdevice.device_entry.device_flags &=
~DEVICE_FLAG_FLAC_IS_UNKNOWN;
break;
}
}
}
/* Determine if the object size supported is 32 or 64 bit wide */
if (ptp_operation_issupported(current_params,PTP_OC_MTP_GetObjectPropsSupported)) {
for (i=0;i<current_params->deviceinfo.ImageFormats_len;i++) {
PTPObjectPropDesc opd;
if (ptp_mtp_getobjectpropdesc(current_params,
PTP_OPC_ObjectSize,
current_params->deviceinfo.ImageFormats[i],
&opd) != PTP_RC_OK) {
LIBMTP_ERROR("LIBMTP PANIC: "
"could not inspect object property descriptions!\n");
} else {
if (opd.DataType == PTP_DTC_UINT32) {
if (bs == 0) {
bs = 32;
} else if (bs != 32) {
LIBMTP_ERROR("LIBMTP PANIC: "
"different objects support different object sizes!\n");
bs = 0;
break;
}
} else if (opd.DataType == PTP_DTC_UINT64) {
if (bs == 0) {
bs = 64;
} else if (bs != 64) {
LIBMTP_ERROR("LIBMTP PANIC: "
"different objects support different object sizes!\n");
bs = 0;
break;
}
} else {
// Ignore if other size.
LIBMTP_ERROR("LIBMTP PANIC: "
"awkward object size data type: %04x\n", opd.DataType);
bs = 0;
break;
}
}
}
}
if (bs == 0) {
// Could not detect object bitsize, assume 32 bits
bs = 32;
}
mtp_device->object_bitsize = bs;
/* No Errors yet for this device */
mtp_device->errorstack = NULL;
/* Default Max Battery Level, we will adjust this if possible */
mtp_device->maximum_battery_level = 100;
/* Check if device supports reading maximum battery level */
if(!FLAG_BROKEN_BATTERY_LEVEL(ptp_usb) &&
ptp_property_issupported( current_params, PTP_DPC_BatteryLevel)) {
PTPDevicePropDesc dpd;
/* Try to read maximum battery level */
if(ptp_getdevicepropdesc(current_params,
PTP_DPC_BatteryLevel,
&dpd) != PTP_RC_OK) {
add_error_to_errorstack(mtp_device,
LIBMTP_ERROR_CONNECTING,
"Unable to read Maximum Battery Level for this "
"device even though the device supposedly "
"supports this functionality");
}
/* TODO: is this appropriate? */
/* If max battery level is 0 then leave the default, otherwise assign */
if (dpd.FORM.Range.MaximumValue.u8 != 0) {
mtp_device->maximum_battery_level = dpd.FORM.Range.MaximumValue.u8;
}
ptp_free_devicepropdesc(&dpd);
}
/* Set all default folders to 0xffffffffU (root directory) */
mtp_device->default_music_folder = 0xffffffffU;
mtp_device->default_playlist_folder = 0xffffffffU;
mtp_device->default_picture_folder = 0xffffffffU;
mtp_device->default_video_folder = 0xffffffffU;
mtp_device->default_organizer_folder = 0xffffffffU;
mtp_device->default_zencast_folder = 0xffffffffU;
mtp_device->default_album_folder = 0xffffffffU;
mtp_device->default_text_folder = 0xffffffffU;
/* Set initial storage information */
mtp_device->storage = NULL;
if (LIBMTP_Get_Storage(mtp_device, LIBMTP_STORAGE_SORTBY_NOTSORTED) == -1) {
add_error_to_errorstack(mtp_device,
LIBMTP_ERROR_GENERAL,
"Get Storage information failed.");
mtp_device->storage = NULL;
}
return mtp_device;
}
LIBMTP_mtpdevice_t *LIBMTP_Open_Raw_Device(LIBMTP_raw_device_t *rawdevice)
{
LIBMTP_mtpdevice_t *mtp_device = LIBMTP_Open_Raw_Device_Uncached(rawdevice);
if (mtp_device == NULL)
return NULL;
/* Check for MTPZ devices. */
if (use_mtpz) {
LIBMTP_device_extension_t *tmpext = mtp_device->extensions;
while (tmpext != NULL) {
if (!strcmp(tmpext->name, "microsoft.com/MTPZ")) {
LIBMTP_INFO("MTPZ device detected. Authenticating...\n");
if (PTP_RC_OK == ptp_mtpz_handshake(mtp_device->params)) {
LIBMTP_INFO ("(MTPZ) Successfully authenticated with device.\n");
} else {
LIBMTP_INFO ("(MTPZ) Failure - could not authenticate with device.\n");
}
break;
}
tmpext = tmpext->next;
}
}
// Set up this device as cached
mtp_device->cached = 1;
/*
* Then get the handles and try to locate the default folders.
* This has the desired side effect of caching all handles from
* the device which speeds up later operations.
*/
flush_handles(mtp_device);
return mtp_device;
}
/**
* To read events sent by the device, repeatedly call this function from a secondary
* thread until the return value is < 0.
*
* @param device a pointer to the MTP device to poll for events.
* @param event contains a pointer to be filled in with the event retrieved if the call
* is successful.
* @param out1 contains the param1 value from the raw event.
* @return 0 on success, any other value means the polling loop shall be
* terminated immediately for this session.
*/
int LIBMTP_Read_Event(LIBMTP_mtpdevice_t *device, LIBMTP_event_t *event, uint32_t *out1)
{
/*
* FIXME: Potential race-condition here, if client deallocs device
* while we're *not* waiting for input. As we'll be waiting for
* input most of the time, it's unlikely but still worth considering
* for improvement. Also we cannot affect the state of the cache etc
* unless we know we are the sole user on the device. A spinlock or
* mutex in the LIBMTP_mtpdevice_t is needed for this to work.
*/
PTPParams *params = (PTPParams *) device->params;
PTPContainer ptp_event;
uint16_t ret = ptp_usb_event_wait(params, &ptp_event);
if (ret != PTP_RC_OK) {
/* Device is closing down or other fatal stuff, exit thread */
return -1;
}
LIBMTP_Handle_Event(&ptp_event, event, out1);
return 0;
}
void LIBMTP_Handle_Event(PTPContainer *ptp_event,
LIBMTP_event_t *event, uint32_t *out1) {
uint16_t code;
uint32_t session_id;
uint32_t param1;
*event = LIBMTP_EVENT_NONE;
/* Process the event */
code = ptp_event->Code;
session_id = ptp_event->SessionID;
param1 = ptp_event->Param1;
switch(code) {
case PTP_EC_Undefined:
LIBMTP_INFO("Received event PTP_EC_Undefined in session %u\n", session_id);
break;
case PTP_EC_CancelTransaction:
LIBMTP_INFO("Received event PTP_EC_CancelTransaction in session %u\n", session_id);
break;
case PTP_EC_ObjectAdded:
LIBMTP_INFO("Received event PTP_EC_ObjectAdded in session %u\n", session_id);
*event = LIBMTP_EVENT_OBJECT_ADDED;
*out1 = param1;
break;
case PTP_EC_ObjectRemoved:
LIBMTP_INFO("Received event PTP_EC_ObjectRemoved in session %u\n", session_id);
*event = LIBMTP_EVENT_OBJECT_REMOVED;
*out1 = param1;
break;
case PTP_EC_StoreAdded:
LIBMTP_INFO("Received event PTP_EC_StoreAdded in session %u\n", session_id);
/* TODO: rescan storages */
*event = LIBMTP_EVENT_STORE_ADDED;
*out1 = param1;
break;
case PTP_EC_StoreRemoved:
LIBMTP_INFO("Received event PTP_EC_StoreRemoved in session %u\n", session_id);
/* TODO: rescan storages */
*event = LIBMTP_EVENT_STORE_REMOVED;
*out1 = param1;
break;
case PTP_EC_DevicePropChanged:
LIBMTP_INFO("Received event PTP_EC_DevicePropChanged in session %u\n", session_id);
/* TODO: update device properties */
break;
case PTP_EC_ObjectInfoChanged:
LIBMTP_INFO("Received event PTP_EC_ObjectInfoChanged in session %u\n", session_id);
/* TODO: rescan object cache or just for this one object */
break;
case PTP_EC_DeviceInfoChanged:
LIBMTP_INFO("Received event PTP_EC_DeviceInfoChanged in session %u\n", session_id);
/* TODO: update device info */
break;
case PTP_EC_RequestObjectTransfer:
LIBMTP_INFO("Received event PTP_EC_RequestObjectTransfer in session %u\n", session_id);
break;
case PTP_EC_StoreFull:
LIBMTP_INFO("Received event PTP_EC_StoreFull in session %u\n", session_id);
break;
case PTP_EC_DeviceReset:
LIBMTP_INFO("Received event PTP_EC_DeviceReset in session %u\n", session_id);
break;
case PTP_EC_StorageInfoChanged :
LIBMTP_INFO( "Received event PTP_EC_StorageInfoChanged in session %u\n", session_id);
/* TODO: update storage info */
break;
case PTP_EC_CaptureComplete :
LIBMTP_INFO( "Received event PTP_EC_CaptureComplete in session %u\n", session_id);
break;
case PTP_EC_UnreportedStatus :
LIBMTP_INFO( "Received event PTP_EC_UnreportedStatus in session %u\n", session_id);
break;
default :
LIBMTP_INFO( "Received unknown event in session %u\n", session_id);
break;
}
}
static void LIBMTP_Read_Event_Cb(PTPParams *params, uint16_t ret_code,
PTPContainer *ptp_event, void *user_data) {
event_cb_data_t *data = user_data;
LIBMTP_event_t event = LIBMTP_EVENT_NONE;
uint32_t param1 = 0;
int handler_ret;
switch (ret_code) {
case PTP_RC_OK:
handler_ret = LIBMTP_HANDLER_RETURN_OK;
LIBMTP_Handle_Event(ptp_event, &event, ¶m1);
break;
case PTP_ERROR_CANCEL:
handler_ret = LIBMTP_HANDLER_RETURN_CANCEL;
break;
default:
handler_ret = LIBMTP_HANDLER_RETURN_ERROR;
break;
}
data->cb(handler_ret, event, param1, data->user_data);
free(data);
}
/**
* This function reads events sent by the device, in a non-blocking manner.
* The callback function will be called when an event is received, but for the function
* to make progress, polling must take place, using LIBMTP_Handle_Events_Timeout_Completed.
*
* After an event is received, this function should be called again to listen for the next
* event.
*
* For now, this non-blocking mechanism only works with libusb-1.0, and not any of the
* other usb library backends. Attempting to call this method with another backend will
* always return an error.
*
* @param device a pointer to the MTP device to poll for events.
* @param cb a callback to be invoked when an event is received.
* @param user_data arbitrary user data passed to the callback.
* @return 0 on success, any other value means that the callback was not registered and
* no event notification will take place.
*/
int LIBMTP_Read_Event_Async(LIBMTP_mtpdevice_t *device, LIBMTP_event_cb_fn cb, void *user_data) {
PTPParams *params = (PTPParams *) device->params;
event_cb_data_t *data = malloc(sizeof(event_cb_data_t));
uint16_t ret;
data->cb = cb;
data->user_data = user_data;
ret = ptp_usb_event_async(params, LIBMTP_Read_Event_Cb, data);
return ret == PTP_RC_OK ? 0 : -1;
}
/**
* Recursive function that adds MTP devices to a linked list
* @param devices a list of raw devices to have real devices created for.
* @return a device pointer to a newly created mtpdevice (used in linked
* list creation).
*/
static LIBMTP_mtpdevice_t * create_usb_mtp_devices(LIBMTP_raw_device_t *devices, int numdevs)
{
uint8_t i;
LIBMTP_mtpdevice_t *mtp_device_list = NULL;
LIBMTP_mtpdevice_t *current_device = NULL;
for (i=0; i < numdevs; i++) {
LIBMTP_mtpdevice_t *mtp_device;
mtp_device = LIBMTP_Open_Raw_Device(&devices[i]);
/* On error, try next device */
if (mtp_device == NULL)
continue;
/* Add the device to the list */
mtp_device->next = NULL;
if (mtp_device_list == NULL) {
mtp_device_list = current_device = mtp_device;
} else {
current_device->next = mtp_device;
current_device = mtp_device;
}
}
return mtp_device_list;
}
/**
* Get the number of devices that are available in the listed device list
* @param device_list Pointer to a linked list of devices
* @return Number of devices in the device list device_list
* @see LIBMTP_Get_Connected_Devices()
*/
uint32_t LIBMTP_Number_Devices_In_List(LIBMTP_mtpdevice_t *device_list)
{
uint32_t numdevices = 0;
LIBMTP_mtpdevice_t *iter;
for(iter = device_list; iter != NULL; iter = iter->next)
numdevices++;
return numdevices;
}
/**
* Get the first connected MTP device node in the linked list of devices.
* Currently this only provides access to USB devices
* @param device_list A list of devices ready to be used by the caller. You
* need to know how many there are.
* @return Any error information gathered from device connections
* @see LIBMTP_Number_Devices_In_List()
*/
LIBMTP_error_number_t LIBMTP_Get_Connected_Devices(LIBMTP_mtpdevice_t **device_list)
{
LIBMTP_raw_device_t *devices;
int numdevs;
LIBMTP_error_number_t ret;
ret = LIBMTP_Detect_Raw_Devices(&devices, &numdevs);
if (ret != LIBMTP_ERROR_NONE) {
*device_list = NULL;
return ret;
}
/* Assign linked list of devices */
if (devices == NULL || numdevs == 0) {
*device_list = NULL;
free(devices);
return LIBMTP_ERROR_NO_DEVICE_ATTACHED;
}
*device_list = create_usb_mtp_devices(devices, numdevs);
free(devices);
/* TODO: Add wifi device access here */
/* We have found some devices but create failed */
if (*device_list == NULL)
return LIBMTP_ERROR_CONNECTING;
return LIBMTP_ERROR_NONE;
}
/**
* This closes and releases an allocated MTP device.
* @param device a pointer to the MTP device to release.
*/
void LIBMTP_Release_Device_List(LIBMTP_mtpdevice_t *device)
{
if(device != NULL)
{
if(device->next != NULL)
{
LIBMTP_Release_Device_List(device->next);
}
LIBMTP_Release_Device(device);
}
}
/**
* This closes and releases an allocated MTP device.
* @param device a pointer to the MTP device to release.
*/
void LIBMTP_Release_Device(LIBMTP_mtpdevice_t *device)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
close_device(ptp_usb, params);
// Clear error stack
LIBMTP_Clear_Errorstack(device);
// Free iconv() converters...
iconv_close(params->cd_locale_to_ucs2);
iconv_close(params->cd_ucs2_to_locale);
free(ptp_usb);
ptp_free_params(params);
free(params);
free_storage_list(device);
// Free extension list...
if (device->extensions != NULL) {
LIBMTP_device_extension_t *tmp = device->extensions;
while (tmp != NULL) {
LIBMTP_device_extension_t *next = tmp->next;
if (tmp->name)
free(tmp->name);
free(tmp);
tmp = next;
}
}
free(device);
}
/**
* This can be used by any libmtp-intrinsic code that
* need to stack up an error on the stack. You are only
* supposed to add errors to the error stack using this
* function, do not create and reference error entries
* directly.
*/
static void add_error_to_errorstack(LIBMTP_mtpdevice_t *device,
LIBMTP_error_number_t errornumber,
char const * const error_text)
{
LIBMTP_error_t *newerror;
if (device == NULL) {
LIBMTP_ERROR("LIBMTP PANIC: Trying to add error to a NULL device!\n");
return;
}
newerror = (LIBMTP_error_t *) malloc(sizeof(LIBMTP_error_t));
newerror->errornumber = errornumber;
newerror->error_text = strdup(error_text);
newerror->next = NULL;
if (device->errorstack == NULL) {
device->errorstack = newerror;
} else {
LIBMTP_error_t *tmp = device->errorstack;
while (tmp->next != NULL) {
tmp = tmp->next;
}
tmp->next = newerror;
}
}
/**
* Adds an error from the PTP layer to the error stack.
*/
static void add_ptp_error_to_errorstack(LIBMTP_mtpdevice_t *device,
uint16_t ptp_error,
char const * const error_text)
{
PTPParams *params = (PTPParams *) device->params;
if (device == NULL) {
LIBMTP_ERROR("LIBMTP PANIC: Trying to add PTP error to a NULL device!\n");
return;
} else {
char outstr[256];
snprintf(outstr, sizeof(outstr), "PTP Layer error %04x: %s", ptp_error, error_text);
outstr[sizeof(outstr)-1] = '\0';
add_error_to_errorstack(device, LIBMTP_ERROR_PTP_LAYER, outstr);
snprintf(outstr, sizeof(outstr), "Error %04x: %s", ptp_error, ptp_strerror(ptp_error, params->deviceinfo.VendorExtensionID));
outstr[sizeof(outstr)-1] = '\0';
add_error_to_errorstack(device, LIBMTP_ERROR_PTP_LAYER, outstr);
}
}
/**
* This returns the error stack for a device in case you
* need to either reference the error numbers (e.g. when
* creating multilingual apps with multiple-language text
* representations for each error number) or when you need
* to build a multi-line error text widget or something like
* that. You need to call the <code>LIBMTP_Clear_Errorstack</code>
* to clear it when you're finished with it.
* @param device a pointer to the MTP device to get the error
* stack for.
* @return the error stack or NULL if there are no errors
* on the stack.
* @see LIBMTP_Clear_Errorstack()
* @see LIBMTP_Dump_Errorstack()
*/
LIBMTP_error_t *LIBMTP_Get_Errorstack(LIBMTP_mtpdevice_t *device)
{
if (device == NULL) {
LIBMTP_ERROR("LIBMTP PANIC: Trying to get the error stack of a NULL device!\n");
return NULL;
}
return device->errorstack;
}
/**
* This function clears the error stack of a device and frees
* any memory used by it. Call this when you're finished with
* using the errors.
* @param device a pointer to the MTP device to clear the error
* stack for.
*/
void LIBMTP_Clear_Errorstack(LIBMTP_mtpdevice_t *device)
{
if (device == NULL) {
LIBMTP_ERROR("LIBMTP PANIC: Trying to clear the error stack of a NULL device!\n");
} else {
LIBMTP_error_t *tmp = device->errorstack;
while (tmp != NULL) {
LIBMTP_error_t *tmp2;
if (tmp->error_text != NULL) {
free(tmp->error_text);
}
tmp2 = tmp;
tmp = tmp->next;
free(tmp2);
}
device->errorstack = NULL;
}
}
/**
* This function dumps the error stack to <code>stderr</code>.
* (You still have to clear the stack though.)
* @param device a pointer to the MTP device to dump the error
* stack for.
*/
void LIBMTP_Dump_Errorstack(LIBMTP_mtpdevice_t *device)
{
if (device == NULL) {
LIBMTP_ERROR("LIBMTP PANIC: Trying to dump the error stack of a NULL device!\n");
} else {
LIBMTP_error_t *tmp = device->errorstack;
while (tmp != NULL) {
if (tmp->error_text != NULL) {
LIBMTP_ERROR("Error %d: %s\n", tmp->errornumber, tmp->error_text);
} else {
LIBMTP_ERROR("Error %d: (unknown)\n", tmp->errornumber);
}
tmp = tmp->next;
}
}
}
void LIBMTP_Set_Device_Timeout(LIBMTP_mtpdevice_t *device, int milliseconds)
{
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
set_usb_device_timeout(ptp_usb, milliseconds);
}
void LIBMTP_Get_Device_Timeout(LIBMTP_mtpdevice_t *device, int *milliseconds)
{
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
get_usb_device_timeout(ptp_usb, milliseconds);
}
/**
* This command gets all handles and stuff by FAST directory retrieveal
* which is available by getting all metadata for object
* <code>0xffffffff</code> which simply means "all metadata for all objects".
* This works on the vast majority of MTP devices (there ARE exceptions!)
* and is quite quick. Check the error stack to see if there were
* problems getting the metadata.
* @return 0 if all was OK, -1 on failure.
*/
static int get_all_metadata_fast(LIBMTP_mtpdevice_t *device)
{
PTPParams *params = (PTPParams *) device->params;
int cnt = 0;
int i, j, nrofprops;
uint32_t lasthandle = 0xffffffff;
MTPProperties *props = NULL;
MTPProperties *prop;
uint16_t ret;
int oldtimeout;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
/*
* The follow request causes the device to generate
* a list of every file on the device and return it
* in a single response.
*
* Some slow devices as well as devices with very
* large file systems can easily take longer then
* the standard timeout value before it is able
* to return a response.
*
* Temporarly set timeout to allow working with
* widest range of devices.
*/
get_usb_device_timeout(ptp_usb, &oldtimeout);
set_usb_device_timeout(ptp_usb, 60000);
ret = ptp_mtp_getobjectproplist(params, 0xffffffff, &props, &nrofprops);
set_usb_device_timeout(ptp_usb, oldtimeout);
if (ret == PTP_RC_MTP_Specification_By_Group_Unsupported) {
// What's the point in the device implementing this command if
// you cannot use it to get all props for AT LEAST one object?
// Well, whatever...
add_ptp_error_to_errorstack(device, ret, "get_all_metadata_fast(): "
"cannot retrieve all metadata for an object on this device.");
return -1;
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "get_all_metadata_fast(): "
"could not get proplist of all objects.");
return -1;
}
if (props == NULL && nrofprops != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"get_all_metadata_fast(): "
"call to ptp_mtp_getobjectproplist() returned "
"inconsistent results.");
return -1;
}
/*
* We count the number of objects by counting the ObjectHandle
* references, whenever it changes we get a new object, when it's
* the same, it is just different properties of the same object.
*/
prop = props;
for (i=0;i<nrofprops;i++) {
if (lasthandle != prop->ObjectHandle) {
cnt++;
lasthandle = prop->ObjectHandle;
}
prop++;
}
lasthandle = 0xffffffff;
params->objects = calloc (cnt, sizeof(PTPObject));
prop = props;
i = -1;
for (j=0;j<nrofprops;j++) {
if (lasthandle != prop->ObjectHandle) {
if (i >= 0) {
params->objects[i].flags |= PTPOBJECT_OBJECTINFO_LOADED;
if (!params->objects[i].oi.Filename) {
/* I have one such file on my Creative (Marcus) */
params->objects[i].oi.Filename = strdup("<null>");
}
}
i++;
lasthandle = prop->ObjectHandle;
params->objects[i].oid = prop->ObjectHandle;
}
switch (prop->property) {
case PTP_OPC_ParentObject:
params->objects[i].oi.ParentObject = prop->propval.u32;
params->objects[i].flags |= PTPOBJECT_PARENTOBJECT_LOADED;
break;
case PTP_OPC_ObjectFormat:
params->objects[i].oi.ObjectFormat = prop->propval.u16;
break;
case PTP_OPC_ObjectSize:
// We loose precision here, up to 32 bits! However the commands that
// retrieve metadata for files and tracks will make sure that the
// PTP_OPC_ObjectSize is read in and duplicated again.
if (device->object_bitsize == 64) {
params->objects[i].oi.ObjectCompressedSize = (uint32_t) prop->propval.u64;
} else {
params->objects[i].oi.ObjectCompressedSize = prop->propval.u32;
}
break;
case PTP_OPC_StorageID:
params->objects[i].oi.StorageID = prop->propval.u32;
params->objects[i].flags |= PTPOBJECT_STORAGEID_LOADED;
break;
case PTP_OPC_ObjectFileName:
if (prop->propval.str != NULL)
params->objects[i].oi.Filename = strdup(prop->propval.str);
break;
default: {
MTPProperties *newprops;
/* Copy all of the other MTP oprierties into the per-object proplist */
if (params->objects[i].nrofmtpprops) {
newprops = realloc(params->objects[i].mtpprops,
(params->objects[i].nrofmtpprops+1)*sizeof(MTPProperties));
} else {
newprops = calloc(1,sizeof(MTPProperties));
}
if (!newprops) return 0; /* FIXME: error handling? */
params->objects[i].mtpprops = newprops;
memcpy(¶ms->objects[i].mtpprops[params->objects[i].nrofmtpprops],
&props[j],sizeof(props[j]));
params->objects[i].nrofmtpprops++;
params->objects[i].flags |= PTPOBJECT_MTPPROPLIST_LOADED;
break;
}
}
prop++;
}
/* mark last entry also */
if (i >= 0) {
params->objects[i].flags |= PTPOBJECT_OBJECTINFO_LOADED;
params->nrofobjects = i+1;
} else {
params->nrofobjects = 0;
}
free (props);
/* The device might not give the list in linear ascending order */
ptp_objects_sort (params);
return 0;
}
/**
* This function will recurse through all the directories on the device,
* starting at the root directory, gathering metadata as it moves along.
* It works better on some devices that will only return data for a
* certain directory and does not respect the option to get all metadata
* for all objects.
*/
static void get_handles_recursively(LIBMTP_mtpdevice_t *device,
PTPParams *params,
uint32_t storageid,
uint32_t parent)
{
PTPObjectHandles currentHandles;
int i = 0;
uint16_t ret = ptp_getobjecthandles(params,
storageid,
PTP_GOH_ALL_FORMATS,
parent,
¤tHandles);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "get_handles_recursively(): could not get object handles.");
return;
}
if (currentHandles.Handler == NULL || currentHandles.n == 0)
return;
// Now descend into any subdirectories found
for (i = 0; i < currentHandles.n; i++) {
PTPObject *ob;
ret = ptp_object_want(params,currentHandles.Handler[i],
PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret == PTP_RC_OK) {
if (ob->oi.ObjectFormat == PTP_OFC_Association)
get_handles_recursively(device, params,
storageid, currentHandles.Handler[i]);
} else {
add_error_to_errorstack(device,
LIBMTP_ERROR_CONNECTING,
"Found a bad handle, trying to ignore it.");
}
}
free(currentHandles.Handler);
}
/**
* This function refresh the internal handle list whenever
* the items stored inside the device is altered. On operations
* that do not add or remove objects, this is typically not
* called.
* @param device a pointer to the MTP device to flush handles for.
*/
static void flush_handles(LIBMTP_mtpdevice_t *device)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
int ret;
uint32_t i;
if (!device->cached) {
return;
}
if (load_cache_on_demand) {
return;
}
if (params->objects != NULL) {
for (i=0;i<params->nrofobjects;i++)
ptp_free_object (¶ms->objects[i]);
free(params->objects);
params->objects = NULL;
params->nrofobjects = 0;
}
if (ptp_operation_issupported(params,PTP_OC_MTP_GetObjPropList)
&& !FLAG_BROKEN_MTPGETOBJPROPLIST(ptp_usb)
&& !FLAG_BROKEN_MTPGETOBJPROPLIST_ALL(ptp_usb)) {
// Use the fast method. Ignore return value for now.
ret = get_all_metadata_fast(device);
}
// If the previous failed or returned no objects, use classic
// methods instead.
if (params->nrofobjects == 0) {
// Get all the handles using just standard commands.
if (device->storage == NULL) {
get_handles_recursively(device, params,
PTP_GOH_ALL_STORAGE,
PTP_GOH_ROOT_PARENT);
} else {
// Get handles for each storage in turn.
LIBMTP_devicestorage_t *storage = device->storage;
while(storage != NULL) {
get_handles_recursively(device, params,
storage->id,
PTP_GOH_ROOT_PARENT);
storage = storage->next;
}
}
}
/*
* Loop over the handles, fix up any NULL filenames or
* keywords, then attempt to locate some default folders
* in the root directory of the primary storage.
*/
for(i = 0; i < params->nrofobjects; i++) {
PTPObject *ob, *xob;
ob = ¶ms->objects[i];
ret = ptp_object_want(params,params->objects[i].oid,
PTPOBJECT_OBJECTINFO_LOADED, &xob);
if (ret != PTP_RC_OK) {
LIBMTP_ERROR("broken! %x not found\n", params->objects[i].oid);
}
if (ob->oi.Filename == NULL)
ob->oi.Filename = strdup("<null>");
if (ob->oi.Keywords == NULL)
ob->oi.Keywords = strdup("<null>");
/* Ignore handles that point to non-folders */
if(ob->oi.ObjectFormat != PTP_OFC_Association)
continue;
/* Only look in the root folder */
if (ob->oi.ParentObject == 0xffffffffU) {
LIBMTP_ERROR("object %x has parent 0xffffffff (-1) continuing anyway\n",
ob->oid);
} else if (ob->oi.ParentObject != 0x00000000U)
continue;
/* Only look in the primary storage */
if (device->storage != NULL && ob->oi.StorageID != device->storage->id)
continue;
/* Is this the Music Folder */
if (!strcasecmp(ob->oi.Filename, "My Music") ||
!strcasecmp(ob->oi.Filename, "My_Music") ||
!strcasecmp(ob->oi.Filename, "Music")) {
device->default_music_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "My Playlists") ||
!strcasecmp(ob->oi.Filename, "My_Playlists") ||
!strcasecmp(ob->oi.Filename, "Playlists")) {
device->default_playlist_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "My Pictures") ||
!strcasecmp(ob->oi.Filename, "My_Pictures") ||
!strcasecmp(ob->oi.Filename, "Pictures")) {
device->default_picture_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "My Video") ||
!strcasecmp(ob->oi.Filename, "My_Video") ||
!strcasecmp(ob->oi.Filename, "Video")) {
device->default_video_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "My Organizer") ||
!strcasecmp(ob->oi.Filename, "My_Organizer")) {
device->default_organizer_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "ZENcast") ||
!strcasecmp(ob->oi.Filename, "Datacasts")) {
device->default_zencast_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "My Albums") ||
!strcasecmp(ob->oi.Filename, "My_Albums") ||
!strcasecmp(ob->oi.Filename, "Albums")) {
device->default_album_folder = ob->oid;
}
else if (!strcasecmp(ob->oi.Filename, "Text") ||
!strcasecmp(ob->oi.Filename, "Texts")) {
device->default_text_folder = ob->oid;
}
}
}
/**
* This function traverses a devices storage list freeing up the
* strings and the structs.
* @param device a pointer to the MTP device to free the storage
* list for.
*/
static void free_storage_list(LIBMTP_mtpdevice_t *device)
{
LIBMTP_devicestorage_t *storage;
LIBMTP_devicestorage_t *tmp;
storage = device->storage;
while(storage != NULL) {
if (storage->StorageDescription != NULL) {
free(storage->StorageDescription);
}
if (storage->VolumeIdentifier != NULL) {
free(storage->VolumeIdentifier);
}
tmp = storage;
storage = storage->next;
free(tmp);
}
device->storage = NULL;
return;
}
/**
* This function traverses a devices storage list freeing up the
* strings and the structs.
* @param device a pointer to the MTP device to free the storage
* list for.
*/
static int sort_storage_by(LIBMTP_mtpdevice_t *device,int const sortby)
{
LIBMTP_devicestorage_t *oldhead, *ptr1, *ptr2, *newlist;
if (device->storage == NULL)
return -1;
if (sortby == LIBMTP_STORAGE_SORTBY_NOTSORTED)
return 0;
oldhead = ptr1 = ptr2 = device->storage;
newlist = NULL;
while(oldhead != NULL) {
ptr1 = ptr2 = oldhead;
while(ptr1 != NULL) {
if (sortby == LIBMTP_STORAGE_SORTBY_FREESPACE && ptr1->FreeSpaceInBytes > ptr2->FreeSpaceInBytes)
ptr2 = ptr1;
if (sortby == LIBMTP_STORAGE_SORTBY_MAXSPACE && ptr1->FreeSpaceInBytes > ptr2->FreeSpaceInBytes)
ptr2 = ptr1;
ptr1 = ptr1->next;
}
// Make our previous entries next point to our next
if(ptr2->prev != NULL) {
ptr1 = ptr2->prev;
ptr1->next = ptr2->next;
} else {
oldhead = ptr2->next;
if(oldhead != NULL)
oldhead->prev = NULL;
}
// Make our next entries previous point to our previous
ptr1 = ptr2->next;
if(ptr1 != NULL) {
ptr1->prev = ptr2->prev;
} else {
ptr1 = ptr2->prev;
if(ptr1 != NULL)
ptr1->next = NULL;
}
if(newlist == NULL) {
newlist = ptr2;
newlist->prev = NULL;
} else {
ptr2->prev = newlist;
newlist->next = ptr2;
newlist = newlist->next;
}
}
if (newlist != NULL) {
newlist->next = NULL;
while(newlist->prev != NULL)
newlist = newlist->prev;
device->storage = newlist;
}
return 0;
}
/**
* This function grabs the first writeable storageid from the
* device storage list.
* @param device a pointer to the MTP device to locate writeable
* storage for.
* @param fitsize a file of this file must fit on the device.
*/
static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device,
uint64_t fitsize)
{
LIBMTP_devicestorage_t *storage;
uint32_t store = 0x00000000; //Should this be 0xffffffffu instead?
int subcall_ret;
// See if there is some storage we can fit this file on.
storage = device->storage;
if (storage == NULL) {
// Sometimes the storage just cannot be detected.
store = 0x00000000U;
} else {
while(storage != NULL) {
// These storages cannot be used.
if (storage->StorageType == PTP_ST_FixedROM ||
storage->StorageType == PTP_ST_RemovableROM) {
storage = storage->next;
continue;
}
// Storage IDs with the lower 16 bits 0x0000 are not supposed
// to be writeable.
if ((storage->id & 0x0000FFFFU) == 0x00000000U) {
storage = storage->next;
continue;
}
// Also check the access capability to avoid e.g. deletable only storages
if (storage->AccessCapability == PTP_AC_ReadOnly ||
storage->AccessCapability == PTP_AC_ReadOnly_with_Object_Deletion) {
storage = storage->next;
continue;
}
// Then see if we can fit the file.
subcall_ret = check_if_file_fits(device, storage, fitsize);
if (subcall_ret != 0) {
storage = storage->next;
} else {
// We found a storage that is writable and can fit the file!
break;
}
}
if (storage == NULL) {
add_error_to_errorstack(device, LIBMTP_ERROR_STORAGE_FULL,
"get_writeable_storageid(): "
"all device storage is full or corrupt.");
return -1;
}
store = storage->id;
}
return store;
}
/**
* Tries to suggest a storage_id of a given ID when we have a parent
* @param device a pointer to the device where to search for the storage ID
* @param fitsize a file of this file must fit on the device.
* @param parent_id look for this ID
* @ret storageID
*/
static int get_suggested_storage_id(LIBMTP_mtpdevice_t *device,
uint64_t fitsize,
uint32_t parent_id)
{
PTPParams *params = (PTPParams *) device->params;
PTPObject *ob;
uint16_t ret;
ret = ptp_object_want(params, parent_id, PTPOBJECT_MTPPROPLIST_LOADED, &ob);
if ((ret != PTP_RC_OK) || (ob->oi.StorageID == 0)) {
add_ptp_error_to_errorstack(device, ret, "get_suggested_storage_id(): "
"could not get storage id from parent id.");
return get_writeable_storageid(device, fitsize);
} else {
/* OK we know the parent storage, then use that */
return ob->oi.StorageID;
}
}
/**
* This function grabs the freespace from a certain storage in
* device storage list.
* @param device a pointer to the MTP device to free the storage
* list for.
* @param storageid the storage ID for the storage to flush and
* get free space for.
* @param freespace the free space on this storage will be returned
* in this variable.
*/
static int get_storage_freespace(LIBMTP_mtpdevice_t *device,
LIBMTP_devicestorage_t *storage,
uint64_t *freespace)
{
PTPParams *params = (PTPParams *) device->params;
// Always query the device about this, since some models explicitly
// needs that. We flush all data on queries storage here.
if (ptp_operation_issupported(params,PTP_OC_GetStorageInfo)) {
PTPStorageInfo storageInfo;
uint16_t ret;
ret = ptp_getstorageinfo(params, storage->id, &storageInfo);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret,
"get_storage_freespace(): could not get storage info.");
return -1;
}
if (storage->StorageDescription != NULL) {
free(storage->StorageDescription);
}
if (storage->VolumeIdentifier != NULL) {
free(storage->VolumeIdentifier);
}
storage->StorageType = storageInfo.StorageType;
storage->FilesystemType = storageInfo.FilesystemType;
storage->AccessCapability = storageInfo.AccessCapability;
storage->MaxCapacity = storageInfo.MaxCapability;
storage->FreeSpaceInBytes = storageInfo.FreeSpaceInBytes;
storage->FreeSpaceInObjects = storageInfo.FreeSpaceInImages;
storage->StorageDescription = storageInfo.StorageDescription;
storage->VolumeIdentifier = storageInfo.VolumeLabel;
}
if(storage->FreeSpaceInBytes == (uint64_t) -1)
return -1;
*freespace = storage->FreeSpaceInBytes;
return 0;
}
/**
* This function dumps out a large chunk of textual information
* provided from the PTP protocol and additionally some extra
* MTP-specific information where applicable.
* @param device a pointer to the MTP device to report info from.
*/
void LIBMTP_Dump_Device_Info(LIBMTP_mtpdevice_t *device)
{
int i;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
LIBMTP_devicestorage_t *storage = device->storage;
LIBMTP_device_extension_t *tmpext = device->extensions;
printf("USB low-level info:\n");
dump_usbinfo(ptp_usb);
/* Print out some verbose information */
printf("Device info:\n");
printf(" Manufacturer: %s\n", params->deviceinfo.Manufacturer);
printf(" Model: %s\n", params->deviceinfo.Model);
printf(" Device version: %s\n", params->deviceinfo.DeviceVersion);
printf(" Serial number: %s\n", params->deviceinfo.SerialNumber);
printf(" Vendor extension ID: 0x%08x\n",
params->deviceinfo.VendorExtensionID);
printf(" Vendor extension description: %s\n",
params->deviceinfo.VendorExtensionDesc);
printf(" Detected object size: %d bits\n",
device->object_bitsize);
printf(" Extensions:\n");
while (tmpext != NULL) {
printf(" %s: %d.%d\n",
tmpext->name,
tmpext->major,
tmpext->minor);
tmpext = tmpext->next;
}
printf("Supported operations:\n");
for (i=0;i<params->deviceinfo.OperationsSupported_len;i++)
printf(" %04x: %s\n", params->deviceinfo.OperationsSupported[i], ptp_get_opcode_name(params, params->deviceinfo.OperationsSupported[i]));
printf("Events supported:\n");
if (params->deviceinfo.EventsSupported_len == 0) {
printf(" None.\n");
} else {
for (i=0;i<params->deviceinfo.EventsSupported_len;i++) {
printf(" 0x%04x (%s)\n", params->deviceinfo.EventsSupported[i], ptp_strerror(params->deviceinfo.EventsSupported[i], params->deviceinfo.VendorExtensionID));
}
}
printf("Device Properties Supported:\n");
for (i=0;i<params->deviceinfo.DevicePropertiesSupported_len;i++) {
char const *propdesc = ptp_get_property_description(params,
params->deviceinfo.DevicePropertiesSupported[i]);
if (propdesc != NULL) {
printf(" 0x%04x: %s\n",
params->deviceinfo.DevicePropertiesSupported[i], propdesc);
} else {
uint16_t prop = params->deviceinfo.DevicePropertiesSupported[i];
printf(" 0x%04x: Unknown property\n", prop);
}
}
if (ptp_operation_issupported(params,PTP_OC_MTP_GetObjectPropsSupported)) {
printf("Playable File (Object) Types and Object Properties Supported:\n");
for (i=0;i<params->deviceinfo.ImageFormats_len;i++) {
char txt[256];
uint16_t ret;
uint16_t *props = NULL;
uint32_t propcnt = 0;
int j;
(void) ptp_render_ofc (params, params->deviceinfo.ImageFormats[i],
sizeof(txt), txt);
printf(" %04x: %s\n", params->deviceinfo.ImageFormats[i], txt);
ret = ptp_mtp_getobjectpropssupported (params,
params->deviceinfo.ImageFormats[i], &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Dump_Device_Info(): "
"error on query for object properties.");
} else {
for (j=0;j<propcnt;j++) {
PTPObjectPropDesc opd;
int k;
printf(" %04x: %s", props[j],
LIBMTP_Get_Property_Description(map_ptp_property_to_libmtp_property(props[j])));
// Get a more verbose description
ret = ptp_mtp_getobjectpropdesc(params, props[j],
params->deviceinfo.ImageFormats[i],
&opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Dump_Device_Info(): "
"could not get property description.");
break;
}
if (opd.DataType == PTP_DTC_STR) {
printf(" STRING data type");
switch (opd.FormFlag) {
case PTP_OPFF_DateTime:
printf(" DATETIME FORM");
break;
case PTP_OPFF_RegularExpression:
printf(" REGULAR EXPRESSION FORM");
break;
case PTP_OPFF_LongString:
printf(" LONG STRING FORM");
break;
default:
break;
}
} else {
if (opd.DataType & PTP_DTC_ARRAY_MASK) {
printf(" array of");
}
switch (opd.DataType & (~PTP_DTC_ARRAY_MASK)) {
case PTP_DTC_UNDEF:
printf(" UNDEFINED data type");
break;
case PTP_DTC_INT8:
printf(" INT8 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.i8,
opd.FORM.Range.MaximumValue.i8,
opd.FORM.Range.StepSize.i8);
break;
case PTP_OPFF_Enumeration:
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].i8);
}
break;
case PTP_OPFF_ByteArray:
printf(" byte array: ");
break;
default:
printf(" ANY 8BIT VALUE form");
break;
}
break;
case PTP_DTC_UINT8:
printf(" UINT8 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.u8,
opd.FORM.Range.MaximumValue.u8,
opd.FORM.Range.StepSize.u8);
break;
case PTP_OPFF_Enumeration:
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].u8);
}
break;
case PTP_OPFF_ByteArray:
printf(" byte array: ");
break;
default:
printf(" ANY 8BIT VALUE form");
break;
}
break;
case PTP_DTC_INT16:
printf(" INT16 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.i16,
opd.FORM.Range.MaximumValue.i16,
opd.FORM.Range.StepSize.i16);
break;
case PTP_OPFF_Enumeration:
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].i16);
}
break;
default:
printf(" ANY 16BIT VALUE form");
break;
}
break;
case PTP_DTC_UINT16:
printf(" UINT16 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.u16,
opd.FORM.Range.MaximumValue.u16,
opd.FORM.Range.StepSize.u16);
break;
case PTP_OPFF_Enumeration:
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].u16);
}
break;
default:
printf(" ANY 16BIT VALUE form");
break;
}
break;
case PTP_DTC_INT32:
printf(" INT32 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.i32,
opd.FORM.Range.MaximumValue.i32,
opd.FORM.Range.StepSize.i32);
break;
case PTP_OPFF_Enumeration:
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].i32);
}
break;
default:
printf(" ANY 32BIT VALUE form");
break;
}
break;
case PTP_DTC_UINT32:
printf(" UINT32 data type");
switch (opd.FormFlag) {
case PTP_OPFF_Range:
printf(" range: MIN %d, MAX %d, STEP %d",
opd.FORM.Range.MinimumValue.u32,
opd.FORM.Range.MaximumValue.u32,
opd.FORM.Range.StepSize.u32);
break;
case PTP_OPFF_Enumeration:
// Special pretty-print for FOURCC codes
if (params->deviceinfo.ImageFormats[i] == PTP_OPC_VideoFourCCCodec) {
printf(" enumeration of u32 casted FOURCC: ");
for (k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
if (opd.FORM.Enum.SupportedValue[k].u32 == 0) {
printf("ANY, ");
} else {
char fourcc[6];
fourcc[0] = (opd.FORM.Enum.SupportedValue[k].u32 >> 24) & 0xFFU;
fourcc[1] = (opd.FORM.Enum.SupportedValue[k].u32 >> 16) & 0xFFU;
fourcc[2] = (opd.FORM.Enum.SupportedValue[k].u32 >> 8) & 0xFFU;
fourcc[3] = opd.FORM.Enum.SupportedValue[k].u32 & 0xFFU;
fourcc[4] = '\n';
fourcc[5] = '\0';
printf("\"%s\", ", fourcc);
}
}
} else {
printf(" enumeration: ");
for(k=0;k<opd.FORM.Enum.NumberOfValues;k++) {
printf("%d, ", opd.FORM.Enum.SupportedValue[k].u32);
}
}
break;
default:
printf(" ANY 32BIT VALUE form");
break;
}
break;
case PTP_DTC_INT64:
printf(" INT64 data type");
break;
case PTP_DTC_UINT64:
printf(" UINT64 data type");
break;
case PTP_DTC_INT128:
printf(" INT128 data type");
break;
case PTP_DTC_UINT128:
printf(" UINT128 data type");
break;
default:
printf(" UNKNOWN data type");
break;
}
}
if (opd.GetSet) {
printf(" GET/SET");
} else {
printf(" READ ONLY");
}
printf("\n");
ptp_free_objectpropdesc(&opd);
}
free(props);
}
}
}
if(storage != NULL &&
ptp_operation_issupported(params,PTP_OC_GetStorageInfo)) {
printf("Storage Devices:\n");
while(storage != NULL) {
printf(" StorageID: 0x%08x\n",storage->id);
printf(" StorageType: 0x%04x ",storage->StorageType);
switch (storage->StorageType) {
case PTP_ST_Undefined:
printf("(undefined)\n");
break;
case PTP_ST_FixedROM:
printf("fixed ROM storage\n");
break;
case PTP_ST_RemovableROM:
printf("removable ROM storage\n");
break;
case PTP_ST_FixedRAM:
printf("fixed RAM storage\n");
break;
case PTP_ST_RemovableRAM:
printf("removable RAM storage\n");
break;
default:
printf("UNKNOWN storage\n");
break;
}
printf(" FilesystemType: 0x%04x ",storage->FilesystemType);
switch(storage->FilesystemType) {
case PTP_FST_Undefined:
printf("(undefined)\n");
break;
case PTP_FST_GenericFlat:
printf("generic flat filesystem\n");
break;
case PTP_FST_GenericHierarchical:
printf("generic hierarchical\n");
break;
case PTP_FST_DCF:
printf("DCF\n");
break;
default:
printf("UNKNONWN filesystem type\n");
break;
}
printf(" AccessCapability: 0x%04x ",storage->AccessCapability);
switch(storage->AccessCapability) {
case PTP_AC_ReadWrite:
printf("read/write\n");
break;
case PTP_AC_ReadOnly:
printf("read only\n");
break;
case PTP_AC_ReadOnly_with_Object_Deletion:
printf("read only + object deletion\n");
break;
default:
printf("UNKNOWN access capability\n");
break;
}
printf(" MaxCapacity: %llu\n",
(long long unsigned int) storage->MaxCapacity);
printf(" FreeSpaceInBytes: %llu\n",
(long long unsigned int) storage->FreeSpaceInBytes);
printf(" FreeSpaceInObjects: %llu\n",
(long long unsigned int) storage->FreeSpaceInObjects);
printf(" StorageDescription: %s\n",storage->StorageDescription);
printf(" VolumeIdentifier: %s\n",storage->VolumeIdentifier);
storage = storage->next;
}
}
printf("Special directories:\n");
printf(" Default music folder: 0x%08x\n",
device->default_music_folder);
printf(" Default playlist folder: 0x%08x\n",
device->default_playlist_folder);
printf(" Default picture folder: 0x%08x\n",
device->default_picture_folder);
printf(" Default video folder: 0x%08x\n",
device->default_video_folder);
printf(" Default organizer folder: 0x%08x\n",
device->default_organizer_folder);
printf(" Default zencast folder: 0x%08x\n",
device->default_zencast_folder);
printf(" Default album folder: 0x%08x\n",
device->default_album_folder);
printf(" Default text folder: 0x%08x\n",
device->default_text_folder);
}
/**
* This resets a device in case it supports the <code>PTP_OC_ResetDevice</code>
* operation code (0x1010).
* @param device a pointer to the device to reset.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Reset_Device(LIBMTP_mtpdevice_t *device)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params,PTP_OC_ResetDevice)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Reset_Device(): "
"device does not support resetting.");
return -1;
}
ret = ptp_resetdevice(params);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "Error resetting.");
return -1;
}
return 0;
}
/**
* This retrieves the manufacturer name of an MTP device.
* @param device a pointer to the device to get the manufacturer name for.
* @return a newly allocated UTF-8 string representing the manufacturer name.
* The string must be freed by the caller after use. If the call
* was unsuccessful this will contain NULL.
*/
char *LIBMTP_Get_Manufacturername(LIBMTP_mtpdevice_t *device)
{
char *retmanuf = NULL;
PTPParams *params = (PTPParams *) device->params;
if (params->deviceinfo.Manufacturer != NULL) {
retmanuf = strdup(params->deviceinfo.Manufacturer);
}
return retmanuf;
}
/**
* This retrieves the model name (often equal to product name)
* of an MTP device.
* @param device a pointer to the device to get the model name for.
* @return a newly allocated UTF-8 string representing the model name.
* The string must be freed by the caller after use. If the call
* was unsuccessful this will contain NULL.
*/
char *LIBMTP_Get_Modelname(LIBMTP_mtpdevice_t *device)
{
char *retmodel = NULL;
PTPParams *params = (PTPParams *) device->params;
if (params->deviceinfo.Model != NULL) {
retmodel = strdup(params->deviceinfo.Model);
}
return retmodel;
}
/**
* This retrieves the serial number of an MTP device.
* @param device a pointer to the device to get the serial number for.
* @return a newly allocated UTF-8 string representing the serial number.
* The string must be freed by the caller after use. If the call
* was unsuccessful this will contain NULL.
*/
char *LIBMTP_Get_Serialnumber(LIBMTP_mtpdevice_t *device)
{
char *retnumber = NULL;
PTPParams *params = (PTPParams *) device->params;
if (params->deviceinfo.SerialNumber != NULL) {
retnumber = strdup(params->deviceinfo.SerialNumber);
}
return retnumber;
}
/**
* This retrieves the device version (hardware and firmware version) of an
* MTP device.
* @param device a pointer to the device to get the device version for.
* @return a newly allocated UTF-8 string representing the device version.
* The string must be freed by the caller after use. If the call
* was unsuccessful this will contain NULL.
*/
char *LIBMTP_Get_Deviceversion(LIBMTP_mtpdevice_t *device)
{
char *retversion = NULL;
PTPParams *params = (PTPParams *) device->params;
if (params->deviceinfo.DeviceVersion != NULL) {
retversion = strdup(params->deviceinfo.DeviceVersion);
}
return retversion;
}
/**
* This retrieves the "friendly name" of an MTP device. Usually
* this is simply the name of the owner or something like
* "John Doe's Digital Audio Player". This property should be supported
* by all MTP devices.
* @param device a pointer to the device to get the friendly name for.
* @return a newly allocated UTF-8 string representing the friendly name.
* The string must be freed by the caller after use.
* @see LIBMTP_Set_Friendlyname()
*/
char *LIBMTP_Get_Friendlyname(LIBMTP_mtpdevice_t *device)
{
PTPPropertyValue propval;
char *retstring = NULL;
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_property_issupported(params, PTP_DPC_MTP_DeviceFriendlyName)) {
return NULL;
}
ret = ptp_getdevicepropvalue(params,
PTP_DPC_MTP_DeviceFriendlyName,
&propval,
PTP_DTC_STR);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "Error getting friendlyname.");
return NULL;
}
if (propval.str != NULL) {
retstring = strdup(propval.str);
free(propval.str);
}
return retstring;
}
/**
* Sets the "friendly name" of an MTP device.
* @param device a pointer to the device to set the friendly name for.
* @param friendlyname the new friendly name for the device.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Get_Friendlyname()
*/
int LIBMTP_Set_Friendlyname(LIBMTP_mtpdevice_t *device,
char const * const friendlyname)
{
PTPPropertyValue propval;
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_property_issupported(params, PTP_DPC_MTP_DeviceFriendlyName)) {
return -1;
}
propval.str = (char *) friendlyname;
ret = ptp_setdevicepropvalue(params,
PTP_DPC_MTP_DeviceFriendlyName,
&propval,
PTP_DTC_STR);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "Error setting friendlyname.");
return -1;
}
return 0;
}
/**
* This retrieves the syncronization partner of an MTP device. This
* property should be supported by all MTP devices.
* @param device a pointer to the device to get the sync partner for.
* @return a newly allocated UTF-8 string representing the synchronization
* partner. The string must be freed by the caller after use.
* @see LIBMTP_Set_Syncpartner()
*/
char *LIBMTP_Get_Syncpartner(LIBMTP_mtpdevice_t *device)
{
PTPPropertyValue propval;
char *retstring = NULL;
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_property_issupported(params, PTP_DPC_MTP_SynchronizationPartner)) {
return NULL;
}
ret = ptp_getdevicepropvalue(params,
PTP_DPC_MTP_SynchronizationPartner,
&propval,
PTP_DTC_STR);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "Error getting syncpartner.");
return NULL;
}
if (propval.str != NULL) {
retstring = strdup(propval.str);
free(propval.str);
}
return retstring;
}
/**
* Sets the synchronization partner of an MTP device. Note that
* we have no idea what the effect of setting this to "foobar"
* may be. But the general idea seems to be to tell which program
* shall synchronize with this device and tell others to leave
* it alone.
* @param device a pointer to the device to set the sync partner for.
* @param syncpartner the new synchronization partner for the device.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Get_Syncpartner()
*/
int LIBMTP_Set_Syncpartner(LIBMTP_mtpdevice_t *device,
char const * const syncpartner)
{
PTPPropertyValue propval;
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_property_issupported(params, PTP_DPC_MTP_SynchronizationPartner)) {
return -1;
}
propval.str = (char *) syncpartner;
ret = ptp_setdevicepropvalue(params,
PTP_DPC_MTP_SynchronizationPartner,
&propval,
PTP_DTC_STR);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "Error setting syncpartner.");
return -1;
}
return 0;
}
/**
* Checks if the device can stora a file of this size or
* if it's too big.
* @param device a pointer to the device.
* @param filesize the size of the file to check whether it will fit.
* @param storageid the ID of the storage to try to fit the file on.
* @return 0 if the file fits, any other value means failure.
*/
static int check_if_file_fits(LIBMTP_mtpdevice_t *device,
LIBMTP_devicestorage_t *storage,
uint64_t const filesize) {
PTPParams *params = (PTPParams *) device->params;
uint64_t freebytes;
int ret;
// If we cannot check the storage, no big deal.
if (!ptp_operation_issupported(params,PTP_OC_GetStorageInfo)) {
return 0;
}
ret = get_storage_freespace(device, storage, &freebytes);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"check_if_file_fits(): error checking free storage.");
return -1;
} else {
// See if it fits.
if (filesize > freebytes) {
return -1;
}
}
return 0;
}
/**
* This function retrieves the current battery level on the device.
* @param device a pointer to the device to get the battery level for.
* @param maximum_level a pointer to a variable that will hold the
* maximum level of the battery if the call was successful.
* @param current_level a pointer to a variable that will hold the
* current level of the battery if the call was successful.
* A value of 0 means that the device is on external power.
* @return 0 if the storage info was successfully retrieved, any other
* means failure. A typical cause of failure is that
* the device does not support the battery level property.
*/
int LIBMTP_Get_Batterylevel(LIBMTP_mtpdevice_t *device,
uint8_t * const maximum_level,
uint8_t * const current_level)
{
PTPPropertyValue propval;
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
*maximum_level = 0;
*current_level = 0;
if (FLAG_BROKEN_BATTERY_LEVEL(ptp_usb) ||
!ptp_property_issupported(params, PTP_DPC_BatteryLevel)) {
return -1;
}
ret = ptp_getdevicepropvalue(params, PTP_DPC_BatteryLevel,
&propval, PTP_DTC_UINT8);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret,
"LIBMTP_Get_Batterylevel(): "
"could not get device property value.");
return -1;
}
*maximum_level = device->maximum_battery_level;
*current_level = propval.u8;
return 0;
}
/**
* Formats device storage (if the device supports the operation).
* WARNING: This WILL delete all data from the device. Make sure you've
* got confirmation from the user BEFORE you call this function.
*
* @param device a pointer to the device containing the storage to format.
* @param storage the actual storage to format.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Format_Storage(LIBMTP_mtpdevice_t *device,
LIBMTP_devicestorage_t *storage)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
if (!ptp_operation_issupported(params,PTP_OC_FormatStore)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Format_Storage(): "
"device does not support formatting storage.");
return -1;
}
ret = ptp_formatstore(params, storage->id);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Format_Storage(): "
"failed to format storage.");
return -1;
}
return 0;
}
/**
* Helper function to extract a unicode property off a device.
* This is the standard way of retrieveing unicode device
* properties as described by the PTP spec.
* @param device a pointer to the device to get the property from.
* @param unicstring a pointer to a pointer that will hold the
* property after this call is completed.
* @param property the property to retrieve.
* @return 0 on success, any other value means failure.
*/
static int get_device_unicode_property(LIBMTP_mtpdevice_t *device,
char **unicstring, uint16_t property)
{
PTPPropertyValue propval;
PTPParams *params = (PTPParams *) device->params;
uint16_t *tmp;
uint16_t ret;
int i;
if (!ptp_property_issupported(params, property)) {
return -1;
}
// Unicode strings are 16bit unsigned integer arrays.
ret = ptp_getdevicepropvalue(params,
property,
&propval,
PTP_DTC_AUINT16);
if (ret != PTP_RC_OK) {
// TODO: add a note on WHICH property that we failed to get.
*unicstring = NULL;
add_ptp_error_to_errorstack(device, ret,
"get_device_unicode_property(): "
"failed to get unicode property.");
return -1;
}
// Extract the actual array.
// printf("Array of %d elements\n", propval.a.count);
tmp = malloc((propval.a.count + 1)*sizeof(uint16_t));
for (i = 0; i < propval.a.count; i++) {
tmp[i] = propval.a.v[i].u16;
// printf("%04x ", tmp[i]);
}
tmp[propval.a.count] = 0x0000U;
free(propval.a.v);
*unicstring = utf16_to_utf8(device, tmp);
free(tmp);
return 0;
}
/**
* This function returns the secure time as an XML document string from
* the device.
* @param device a pointer to the device to get the secure time for.
* @param sectime the secure time string as an XML document or NULL if the call
* failed or the secure time property is not supported. This string
* must be <code>free()</code>:ed by the caller after use.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Get_Secure_Time(LIBMTP_mtpdevice_t *device, char ** const sectime)
{
return get_device_unicode_property(device, sectime, PTP_DPC_MTP_SecureTime);
}
/**
* This function returns the device (public key) certificate as an
* XML document string from the device.
* @param device a pointer to the device to get the device certificate for.
* @param devcert the device certificate as an XML string or NULL if the call
* failed or the device certificate property is not supported. This
* string must be <code>free()</code>:ed by the caller after use.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Get_Device_Certificate(LIBMTP_mtpdevice_t *device, char ** const devcert)
{
return get_device_unicode_property(device, devcert,
PTP_DPC_MTP_DeviceCertificate);
}
/**
* This function retrieves a list of supported file types, i.e. the file
* types that this device claims it supports, e.g. audio file types that
* the device can play etc. This list is mitigated to
* inlcude the file types that libmtp can handle, i.e. it will not list
* filetypes that libmtp will handle internally like playlists and folders.
* @param device a pointer to the device to get the filetype capabilities for.
* @param filetypes a pointer to a pointer that will hold the list of
* supported filetypes if the call was successful. This list must
* be <code>free()</code>:ed by the caller after use.
* @param length a pointer to a variable that will hold the length of the
* list of supported filetypes if the call was successful.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Get_Filetype_Description()
*/
int LIBMTP_Get_Supported_Filetypes(LIBMTP_mtpdevice_t *device, uint16_t ** const filetypes,
uint16_t * const length)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint16_t *localtypes;
uint16_t localtypelen;
uint32_t i;
// This is more memory than needed if there are unknown types, but what the heck.
localtypes = (uint16_t *) malloc(params->deviceinfo.ImageFormats_len * sizeof(uint16_t));
localtypelen = 0;
for (i=0;i<params->deviceinfo.ImageFormats_len;i++) {
uint16_t localtype = map_ptp_type_to_libmtp_type(params->deviceinfo.ImageFormats[i]);
if (localtype != LIBMTP_FILETYPE_UNKNOWN) {
localtypes[localtypelen] = localtype;
localtypelen++;
}
}
// The forgotten Ogg support on YP-10 and others...
if (FLAG_OGG_IS_UNKNOWN(ptp_usb)) {
localtypes = (uint16_t *) realloc(localtypes,
(params->deviceinfo.ImageFormats_len+1) * sizeof(uint16_t));
localtypes[localtypelen] = LIBMTP_FILETYPE_OGG;
localtypelen++;
}
// The forgotten FLAC support on Cowon iAudio S9 and others...
if (FLAG_FLAC_IS_UNKNOWN(ptp_usb)) {
localtypes = (uint16_t *) realloc(localtypes,
(params->deviceinfo.ImageFormats_len+1) * sizeof(uint16_t));
localtypes[localtypelen] = LIBMTP_FILETYPE_FLAC;
localtypelen++;
}
*filetypes = localtypes;
*length = localtypelen;
return 0;
}
/**
* This function checks if the device has some specific capabilities, in
* order to avoid calling APIs that may disturb the device.
*
* @param device a pointer to the device to check the capability on.
* @param cap the capability to check.
* @return 0 if not supported, any other value means the device has the
* requested capability.
*/
int LIBMTP_Check_Capability(LIBMTP_mtpdevice_t *device, LIBMTP_devicecap_t cap)
{
switch (cap) {
case LIBMTP_DEVICECAP_GetPartialObject:
return (ptp_operation_issupported(device->params,
PTP_OC_GetPartialObject) ||
ptp_operation_issupported(device->params,
PTP_OC_ANDROID_GetPartialObject64));
case LIBMTP_DEVICECAP_SendPartialObject:
return ptp_operation_issupported(device->params,
PTP_OC_ANDROID_SendPartialObject);
case LIBMTP_DEVICECAP_EditObjects:
return (ptp_operation_issupported(device->params,
PTP_OC_ANDROID_TruncateObject) &&
ptp_operation_issupported(device->params,
PTP_OC_ANDROID_BeginEditObject) &&
ptp_operation_issupported(device->params,
PTP_OC_ANDROID_EndEditObject));
/*
* Handle other capabilities here, this is also a good place to
* blacklist some advanced operations on specific devices if need
* be.
*/
default:
break;
}
return 0;
}
/**
* This function updates all the storage id's of a device and their
* properties, then creates a linked list and puts the list head into
* the device struct. It also optionally sorts this list. If you want
* to display storage information in your application you should call
* this function, then dereference the device struct
* (<code>device->storage</code>) to get out information on the storage.
*
* You need to call this everytime you want to update the
* <code>device->storage</code> list, for example anytime you need
* to check available storage somewhere.
*
* <b>WARNING:</b> since this list is dynamically updated, do not
* reference its fields in external applications by pointer! E.g
* do not put a reference to any <code>char *</code> field. instead
* <code>strncpy()</code> it!
*
* @param device a pointer to the device to get the storage for.
* @param sortby an integer that determines the sorting of the storage list.
* Valid sort methods are defined in libmtp.h with beginning with
* LIBMTP_STORAGE_SORTBY_. 0 or LIBMTP_STORAGE_SORTBY_NOTSORTED to not
* sort.
* @return 0 on success, 1 success but only with storage id's, storage
* properities could not be retrieved and -1 means failure.
*/
int LIBMTP_Get_Storage(LIBMTP_mtpdevice_t *device, int const sortby)
{
uint32_t i = 0;
PTPStorageInfo storageInfo;
PTPParams *params = (PTPParams *) device->params;
PTPStorageIDs storageIDs;
LIBMTP_devicestorage_t *storage = NULL;
LIBMTP_devicestorage_t *storageprev = NULL;
if (device->storage != NULL)
free_storage_list(device);
// if (!ptp_operation_issupported(params,PTP_OC_GetStorageIDs))
// return -1;
if (ptp_getstorageids (params, &storageIDs) != PTP_RC_OK)
return -1;
if (storageIDs.n < 1)
return -1;
if (!ptp_operation_issupported(params,PTP_OC_GetStorageInfo)) {
for (i = 0; i < storageIDs.n; i++) {
storage = (LIBMTP_devicestorage_t *)
malloc(sizeof(LIBMTP_devicestorage_t));
storage->prev = storageprev;
if (storageprev != NULL)
storageprev->next = storage;
if (device->storage == NULL)
device->storage = storage;
storage->id = storageIDs.Storage[i];
storage->StorageType = PTP_ST_Undefined;
storage->FilesystemType = PTP_FST_Undefined;
storage->AccessCapability = PTP_AC_ReadWrite;
storage->MaxCapacity = (uint64_t) -1;
storage->FreeSpaceInBytes = (uint64_t) -1;
storage->FreeSpaceInObjects = (uint64_t) -1;
storage->StorageDescription = strdup("Unknown storage");
storage->VolumeIdentifier = strdup("Unknown volume");
storage->next = NULL;
storageprev = storage;
}
free(storageIDs.Storage);
return 1;
} else {
for (i = 0; i < storageIDs.n; i++) {
uint16_t ret;
ret = ptp_getstorageinfo(params, storageIDs.Storage[i], &storageInfo);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Storage(): "
"Could not get storage info.");
if (device->storage != NULL) {
free_storage_list(device);
}
return -1;
}
storage = (LIBMTP_devicestorage_t *)
malloc(sizeof(LIBMTP_devicestorage_t));
storage->prev = storageprev;
if (storageprev != NULL)
storageprev->next = storage;
if (device->storage == NULL)
device->storage = storage;
storage->id = storageIDs.Storage[i];
storage->StorageType = storageInfo.StorageType;
storage->FilesystemType = storageInfo.FilesystemType;
storage->AccessCapability = storageInfo.AccessCapability;
storage->MaxCapacity = storageInfo.MaxCapability;
storage->FreeSpaceInBytes = storageInfo.FreeSpaceInBytes;
storage->FreeSpaceInObjects = storageInfo.FreeSpaceInImages;
storage->StorageDescription = storageInfo.StorageDescription;
storage->VolumeIdentifier = storageInfo.VolumeLabel;
storage->next = NULL;
storageprev = storage;
}
if (storage != NULL)
storage->next = NULL;
sort_storage_by(device,sortby);
free(storageIDs.Storage);
return 0;
}
}
/**
* This creates a new file metadata structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_destroy_file_t</code>
* operation later, so be careful of using strdup() when assigning
* strings, e.g.:
*
* <pre>
* LIBMTP_file_t *file = LIBMTP_new_file_t();
* file->filename = strdup(namestr);
* ....
* LIBMTP_destroy_file_t(file);
* </pre>
*
* @return a pointer to the newly allocated metadata structure.
* @see LIBMTP_destroy_file_t()
*/
LIBMTP_file_t *LIBMTP_new_file_t(void)
{
LIBMTP_file_t *new = (LIBMTP_file_t *) malloc(sizeof(LIBMTP_file_t));
if (new == NULL) {
return NULL;
}
new->filename = NULL;
new->item_id = 0;
new->parent_id = 0;
new->storage_id = 0;
new->filesize = 0;
new->modificationdate = 0;
new->filetype = LIBMTP_FILETYPE_UNKNOWN;
new->next = NULL;
return new;
}
/**
* This destroys a file metadata structure and deallocates the memory
* used by it, including any strings. Never use a file metadata
* structure again after calling this function on it.
* @param file the file metadata to destroy.
* @see LIBMTP_new_file_t()
*/
void LIBMTP_destroy_file_t(LIBMTP_file_t *file)
{
if (file == NULL) {
return;
}
if (file->filename != NULL)
free(file->filename);
free(file);
return;
}
/**
* Helper function that takes one PTP object and creates a
* LIBMTP_file_t metadata entry.
*/
static LIBMTP_file_t *obj2file(LIBMTP_mtpdevice_t *device, PTPObject *ob)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
LIBMTP_file_t *file;
int i;
// Allocate a new file type
file = LIBMTP_new_file_t();
file->parent_id = ob->oi.ParentObject;
file->storage_id = ob->oi.StorageID;
// Set the filetype
file->filetype = map_ptp_type_to_libmtp_type(ob->oi.ObjectFormat);
/*
* A special quirk for devices that doesn't quite
* remember that some files marked as "unknown" type are
* actually OGG or FLAC files. We look at the filename extension
* and see if it happens that this was atleast named "ogg" or "flac"
* and fall back on this heuristic approach in that case,
* for these bugged devices only.
*/
if (file->filetype == LIBMTP_FILETYPE_UNKNOWN) {
if ((FLAG_IRIVER_OGG_ALZHEIMER(ptp_usb) ||
FLAG_OGG_IS_UNKNOWN(ptp_usb)) &&
has_ogg_extension(file->filename)) {
file->filetype = LIBMTP_FILETYPE_OGG;
}
if (FLAG_FLAC_IS_UNKNOWN(ptp_usb) && has_flac_extension(file->filename)) {
file->filetype = LIBMTP_FILETYPE_FLAC;
}
}
// Set the modification date
file->modificationdate = ob->oi.ModificationDate;
// We only have 32-bit file size here; later we use the PTP_OPC_ObjectSize property
file->filesize = ob->oi.ObjectCompressedSize;
if (ob->oi.Filename != NULL) {
file->filename = strdup(ob->oi.Filename);
}
// This is a unique ID so we can keep track of the file.
file->item_id = ob->oid;
/*
* If we have a cached, large set of metadata, then use it!
*/
if (ob->mtpprops) {
MTPProperties *prop = ob->mtpprops;
for (i=0; i < ob->nrofmtpprops; i++, prop++) {
// Pick ObjectSize here...
if (prop->property == PTP_OPC_ObjectSize) {
// This may already be set, but this 64bit precision value
// is better than the PTP 32bit value, so let it override.
if (device->object_bitsize == 64) {
file->filesize = prop->propval.u64;
} else {
file->filesize = prop->propval.u32;
}
break;
}
}
} else if (ptp_operation_issupported(params,PTP_OC_MTP_GetObjectPropsSupported)) {
uint16_t *props = NULL;
uint32_t propcnt = 0;
int ret;
// First see which properties can be retrieved for this object format
ret = ptp_mtp_getobjectpropssupported(params, map_libmtp_type_to_ptp_type(file->filetype), &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "obj2file: call to ptp_mtp_getobjectpropssupported() failed.");
// Silently fall through.
} else {
for (i = 0; i < propcnt; i++) {
switch (props[i]) {
case PTP_OPC_ObjectSize:
if (device->object_bitsize == 64) {
file->filesize = get_u64_from_object(device, file->item_id, PTP_OPC_ObjectSize, 0);
} else {
file->filesize = get_u32_from_object(device, file->item_id, PTP_OPC_ObjectSize, 0);
}
break;
default:
break;
}
}
free(props);
}
}
return file;
}
/**
* This function retrieves the metadata for a single file off
* the device.
*
* Do not call this function repeatedly! The file handles are linearly
* searched O(n) and the call may involve (slow) USB traffic, so use
* <code>LIBMTP_Get_Filelisting()</code> and cache the file, preferably
* as an efficient data structure such as a hash list.
*
* Incidentally this function will return metadata for
* a folder (association) as well, but this is not a proper use
* of it, it is intended for file manipulation, not folder manipulation.
*
* @param device a pointer to the device to get the file metadata from.
* @param fileid the object ID of the file that you want the metadata for.
* @return a metadata entry on success or NULL on failure.
* @see LIBMTP_Get_Filelisting()
*/
LIBMTP_file_t *LIBMTP_Get_Filemetadata(LIBMTP_mtpdevice_t *device, uint32_t const fileid)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
PTPObject *ob;
// Get all the handles if we haven't already done that
// (Only on cached devices.)
if (device->cached && params->nrofobjects == 0) {
flush_handles(device);
}
ret = ptp_object_want(params, fileid, PTPOBJECT_OBJECTINFO_LOADED|PTPOBJECT_MTPPROPLIST_LOADED, &ob);
if (ret != PTP_RC_OK)
return NULL;
return obj2file(device, ob);
}
/**
* THIS FUNCTION IS DEPRECATED. PLEASE UPDATE YOUR CODE IN ORDER
* NOT TO USE IT.
* @see LIBMTP_Get_Filelisting_With_Callback()
*/
LIBMTP_file_t *LIBMTP_Get_Filelisting(LIBMTP_mtpdevice_t *device)
{
LIBMTP_INFO("WARNING: LIBMTP_Get_Filelisting() is deprecated.\n");
LIBMTP_INFO("WARNING: please update your code to use LIBMTP_Get_Filelisting_With_Callback()\n");
return LIBMTP_Get_Filelisting_With_Callback(device, NULL, NULL);
}
/**
* This returns a long list of all files available
* on the current MTP device. Folders will not be returned, but abstract
* entities like playlists and albums will show up as "files". Typical usage:
*
* <pre>
* LIBMTP_file_t *filelist;
*
* filelist = LIBMTP_Get_Filelisting_With_Callback(device, callback, data);
* while (filelist != NULL) {
* LIBMTP_file_t *tmp;
*
* // Do something on each element in the list here...
* tmp = filelist;
* filelist = filelist->next;
* LIBMTP_destroy_file_t(tmp);
* }
* </pre>
*
* If you want to group your file listing by storage (per storage unit) or
* arrange files into folders, you must dereference the <code>storage_id</code>
* and/or <code>parent_id</code> field of the returned <code>LIBMTP_file_t</code>
* struct. To arrange by folders or files you typically have to create the proper
* trees by calls to <code>LIBMTP_Get_Storage()</code> and/or
* <code>LIBMTP_Get_Folder_List()</code> first.
*
* @param device a pointer to the device to get the file listing for.
* @param callback a function to be called during the tracklisting retrieveal
* for displaying progress bars etc, or NULL if you don't want
* any callbacks.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return a list of files that can be followed using the <code>next</code>
* field of the <code>LIBMTP_file_t</code> data structure.
* Each of the metadata tags must be freed after use, and may
* contain only partial metadata information, i.e. one or several
* fields may be NULL or 0.
* @see LIBMTP_Get_Filemetadata()
*/
LIBMTP_file_t *LIBMTP_Get_Filelisting_With_Callback(LIBMTP_mtpdevice_t *device,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
uint32_t i = 0;
LIBMTP_file_t *retfiles = NULL;
LIBMTP_file_t *curfile = NULL;
PTPParams *params = (PTPParams *) device->params;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0) {
flush_handles(device);
}
for (i = 0; i < params->nrofobjects; i++) {
LIBMTP_file_t *file;
PTPObject *ob;
if (callback != NULL)
callback(i, params->nrofobjects, data);
ob = ¶ms->objects[i];
if (ob->oi.ObjectFormat == PTP_OFC_Association) {
// MTP use this object format for folders which means
// these "files" will turn up on a folder listing instead.
continue;
}
// Look up metadata
file = obj2file(device, ob);
if (file == NULL) {
continue;
}
// Add track to a list that will be returned afterwards.
if (retfiles == NULL) {
retfiles = file;
curfile = file;
} else {
curfile->next = file;
curfile = file;
}
// Call listing callback
// double progressPercent = (double)i*(double)100.0 / (double)params->handles.n;
} // Handle counting loop
return retfiles;
}
/**
* This function retrieves the contents of a certain folder
* with id parent on a certain storage on a certain device.
* The result contains both files and folders.
* The device used with this operations must have been opened with
* LIBMTP_Open_Raw_Device_Uncached() or it will fail.
*
* NOTE: the request will always perform I/O with the device.
* @param device a pointer to the MTP device to report info from.
* @param storage a storage on the device to report info from. If
* 0 is passed in, the files for the given parent will be
* searched across all available storages.
* @param parent the parent folder id.
*/
LIBMTP_file_t * LIBMTP_Get_Files_And_Folders(LIBMTP_mtpdevice_t *device,
uint32_t const storage,
uint32_t const parent)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
LIBMTP_file_t *retfiles = NULL;
LIBMTP_file_t *curfile = NULL;
PTPObjectHandles currentHandles;
uint32_t storageid;
uint16_t ret;
int i = 0;
if (device->cached) {
// This function is only supposed to be used by devices
// opened as uncached!
LIBMTP_ERROR("tried to use %s on a cached device!\n",
__func__);
return NULL;
}
if (FLAG_BROKEN_GET_OBJECT_PROPVAL(ptp_usb)) {
// These devices cannot handle the commands needed for
// Uncached access!
LIBMTP_ERROR("tried to use %s on an unsupported device, "
"this command does not work on all devices "
"due to missing low-level support to read "
"information on individual tracks\n",
__func__);
return NULL;
}
if (storage == 0)
storageid = PTP_GOH_ALL_STORAGE;
else
storageid = storage;
ret = ptp_getobjecthandles(params,
storageid,
PTP_GOH_ALL_FORMATS,
parent,
¤tHandles);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret,
"LIBMTP_Get_Files_And_Folders(): could not get object handles.");
return NULL;
}
if (currentHandles.Handler == NULL || currentHandles.n == 0)
return NULL;
for (i = 0; i < currentHandles.n; i++) {
LIBMTP_file_t *file;
// Get metadata for one file, if it fails, try next file
file = LIBMTP_Get_Filemetadata(device, currentHandles.Handler[i]);
if (file == NULL)
continue;
// Add track to a list that will be returned afterwards.
if (curfile == NULL) {
curfile = file;
retfiles = file;
} else {
curfile->next = file;
curfile = file;
}
}
free(currentHandles.Handler);
// Return a pointer to the original first file
// in the big list.
return retfiles;
}
void LIBMTP_Set_Load_Cache_On_Demand(int flag)
{
load_cache_on_demand = flag;
}
/**
* This creates a new track metadata structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_destroy_track_t</code>
* operation later, so be careful of using strdup() when assigning
* strings, e.g.:
*
* <pre>
* LIBMTP_track_t *track = LIBMTP_new_track_t();
* track->title = strdup(titlestr);
* ....
* LIBMTP_destroy_track_t(track);
* </pre>
*
* @return a pointer to the newly allocated metadata structure.
* @see LIBMTP_destroy_track_t()
*/
LIBMTP_track_t *LIBMTP_new_track_t(void)
{
LIBMTP_track_t *new = (LIBMTP_track_t *) malloc(sizeof(LIBMTP_track_t));
if (new == NULL) {
return NULL;
}
new->item_id = 0;
new->parent_id = 0;
new->storage_id = 0;
new->title = NULL;
new->artist = NULL;
new->composer = NULL;
new->album = NULL;
new->genre = NULL;
new->date = NULL;
new->filename = NULL;
new->duration = 0;
new->tracknumber = 0;
new->filesize = 0;
new->filetype = LIBMTP_FILETYPE_UNKNOWN;
new->samplerate = 0;
new->nochannels = 0;
new->wavecodec = 0;
new->bitrate = 0;
new->bitratetype = 0;
new->rating = 0;
new->usecount = 0;
new->modificationdate = 0;
new->next = NULL;
return new;
}
/**
* This destroys a track metadata structure and deallocates the memory
* used by it, including any strings. Never use a track metadata
* structure again after calling this function on it.
* @param track the track metadata to destroy.
* @see LIBMTP_new_track_t()
*/
void LIBMTP_destroy_track_t(LIBMTP_track_t *track)
{
if (track == NULL) {
return;
}
if (track->title != NULL)
free(track->title);
if (track->artist != NULL)
free(track->artist);
if (track->composer != NULL)
free(track->composer);
if (track->album != NULL)
free(track->album);
if (track->genre != NULL)
free(track->genre);
if (track->date != NULL)
free(track->date);
if (track->filename != NULL)
free(track->filename);
free(track);
return;
}
/**
* This function maps and copies a property onto the track metadata if applicable.
*/
static void pick_property_to_track_metadata(LIBMTP_mtpdevice_t *device, MTPProperties *prop, LIBMTP_track_t *track)
{
switch (prop->property) {
case PTP_OPC_Name:
if (prop->propval.str != NULL)
track->title = strdup(prop->propval.str);
else
track->title = NULL;
break;
case PTP_OPC_Artist:
if (prop->propval.str != NULL)
track->artist = strdup(prop->propval.str);
else
track->artist = NULL;
break;
case PTP_OPC_Composer:
if (prop->propval.str != NULL)
track->composer = strdup(prop->propval.str);
else
track->composer = NULL;
break;
case PTP_OPC_Duration:
track->duration = prop->propval.u32;
break;
case PTP_OPC_Track:
track->tracknumber = prop->propval.u16;
break;
case PTP_OPC_Genre:
if (prop->propval.str != NULL)
track->genre = strdup(prop->propval.str);
else
track->genre = NULL;
break;
case PTP_OPC_AlbumName:
if (prop->propval.str != NULL)
track->album = strdup(prop->propval.str);
else
track->album = NULL;
break;
case PTP_OPC_OriginalReleaseDate:
if (prop->propval.str != NULL)
track->date = strdup(prop->propval.str);
else
track->date = NULL;
break;
// These are, well not so important.
case PTP_OPC_SampleRate:
track->samplerate = prop->propval.u32;
break;
case PTP_OPC_NumberOfChannels:
track->nochannels = prop->propval.u16;
break;
case PTP_OPC_AudioWAVECodec:
track->wavecodec = prop->propval.u32;
break;
case PTP_OPC_AudioBitRate:
track->bitrate = prop->propval.u32;
break;
case PTP_OPC_BitRateType:
track->bitratetype = prop->propval.u16;
break;
case PTP_OPC_Rating:
track->rating = prop->propval.u16;
break;
case PTP_OPC_UseCount:
track->usecount = prop->propval.u32;
break;
case PTP_OPC_ObjectSize:
if (device->object_bitsize == 64) {
track->filesize = prop->propval.u64;
} else {
track->filesize = prop->propval.u32;
}
break;
default:
break;
}
}
/**
* This function retrieves the track metadata for a track
* given by a unique ID.
* @param device a pointer to the device to get the track metadata off.
* @param trackid the unique ID of the track.
* @param objectformat the object format of this track, so we know what it supports.
* @param track a metadata set to fill in.
*/
static void get_track_metadata(LIBMTP_mtpdevice_t *device, uint16_t objectformat,
LIBMTP_track_t *track)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
uint32_t i;
MTPProperties *prop;
PTPObject *ob;
/*
* If we have a cached, large set of metadata, then use it!
*/
ret = ptp_object_want(params, track->item_id, PTPOBJECT_MTPPROPLIST_LOADED, &ob);
if (ob->mtpprops) {
prop = ob->mtpprops;
for (i=0;i<ob->nrofmtpprops;i++,prop++)
pick_property_to_track_metadata(device, prop, track);
} else {
uint16_t *props = NULL;
uint32_t propcnt = 0;
// First see which properties can be retrieved for this object format
ret = ptp_mtp_getobjectpropssupported(params, map_libmtp_type_to_ptp_type(track->filetype), &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "get_track_metadata(): call to ptp_mtp_getobjectpropssupported() failed.");
// Just bail out for now, nothing is ever set.
return;
} else {
for (i=0;i<propcnt;i++) {
switch (props[i]) {
case PTP_OPC_Name:
track->title = get_string_from_object(device, track->item_id, PTP_OPC_Name);
break;
case PTP_OPC_Artist:
track->artist = get_string_from_object(device, track->item_id, PTP_OPC_Artist);
break;
case PTP_OPC_Composer:
track->composer = get_string_from_object(device, track->item_id, PTP_OPC_Composer);
break;
case PTP_OPC_Duration:
track->duration = get_u32_from_object(device, track->item_id, PTP_OPC_Duration, 0);
break;
case PTP_OPC_Track:
track->tracknumber = get_u16_from_object(device, track->item_id, PTP_OPC_Track, 0);
break;
case PTP_OPC_Genre:
track->genre = get_string_from_object(device, track->item_id, PTP_OPC_Genre);
break;
case PTP_OPC_AlbumName:
track->album = get_string_from_object(device, track->item_id, PTP_OPC_AlbumName);
break;
case PTP_OPC_OriginalReleaseDate:
track->date = get_string_from_object(device, track->item_id, PTP_OPC_OriginalReleaseDate);
break;
// These are, well not so important.
case PTP_OPC_SampleRate:
track->samplerate = get_u32_from_object(device, track->item_id, PTP_OPC_SampleRate, 0);
break;
case PTP_OPC_NumberOfChannels:
track->nochannels = get_u16_from_object(device, track->item_id, PTP_OPC_NumberOfChannels, 0);
break;
case PTP_OPC_AudioWAVECodec:
track->wavecodec = get_u32_from_object(device, track->item_id, PTP_OPC_AudioWAVECodec, 0);
break;
case PTP_OPC_AudioBitRate:
track->bitrate = get_u32_from_object(device, track->item_id, PTP_OPC_AudioBitRate, 0);
break;
case PTP_OPC_BitRateType:
track->bitratetype = get_u16_from_object(device, track->item_id, PTP_OPC_BitRateType, 0);
break;
case PTP_OPC_Rating:
track->rating = get_u16_from_object(device, track->item_id, PTP_OPC_Rating, 0);
break;
case PTP_OPC_UseCount:
track->usecount = get_u32_from_object(device, track->item_id, PTP_OPC_UseCount, 0);
break;
case PTP_OPC_ObjectSize:
if (device->object_bitsize == 64) {
track->filesize = get_u64_from_object(device, track->item_id, PTP_OPC_ObjectSize, 0);
} else {
track->filesize = (uint64_t) get_u32_from_object(device, track->item_id, PTP_OPC_ObjectSize, 0);
}
break;
}
}
free(props);
}
}
}
/**
* THIS FUNCTION IS DEPRECATED. PLEASE UPDATE YOUR CODE IN ORDER
* NOT TO USE IT.
* @see LIBMTP_Get_Tracklisting_With_Callback()
*/
LIBMTP_track_t *LIBMTP_Get_Tracklisting(LIBMTP_mtpdevice_t *device)
{
LIBMTP_INFO("WARNING: LIBMTP_Get_Tracklisting() is deprecated.\n");
LIBMTP_INFO("WARNING: please update your code to use LIBMTP_Get_Tracklisting_With_Callback()\n");
return LIBMTP_Get_Tracklisting_With_Callback(device, NULL, NULL);
}
/**
* This returns a long list of all tracks available on the current MTP device.
* Tracks include multimedia objects, both music tracks and video tracks.
* Typical usage:
*
* <pre>
* LIBMTP_track_t *tracklist;
*
* tracklist = LIBMTP_Get_Tracklisting_With_Callback(device, callback, data);
* while (tracklist != NULL) {
* LIBMTP_track_t *tmp;
*
* // Do something on each element in the list here...
* tmp = tracklist;
* tracklist = tracklist->next;
* LIBMTP_destroy_track_t(tmp);
* }
* </pre>
*
* If you want to group your track listing by storage (per storage unit) or
* arrange tracks into folders, you must dereference the <code>storage_id</code>
* and/or <code>parent_id</code> field of the returned <code>LIBMTP_track_t</code>
* struct. To arrange by folders or files you typically have to create the proper
* trees by calls to <code>LIBMTP_Get_Storage()</code> and/or
* <code>LIBMTP_Get_Folder_List()</code> first.
*
* @param device a pointer to the device to get the track listing for.
* @param callback a function to be called during the tracklisting retrieveal
* for displaying progress bars etc, or NULL if you don't want
* any callbacks.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return a list of tracks that can be followed using the <code>next</code>
* field of the <code>LIBMTP_track_t</code> data structure.
* Each of the metadata tags must be freed after use, and may
* contain only partial metadata information, i.e. one or several
* fields may be NULL or 0.
* @see LIBMTP_Get_Trackmetadata()
*/
LIBMTP_track_t *LIBMTP_Get_Tracklisting_With_Callback(LIBMTP_mtpdevice_t *device,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
return LIBMTP_Get_Tracklisting_With_Callback_For_Storage(device, 0, callback, data);
}
/**
* This returns a long list of all tracks available on the current MTP device.
* Tracks include multimedia objects, both music tracks and video tracks.
* Typical usage:
*
* <pre>
* LIBMTP_track_t *tracklist;
*
* tracklist = LIBMTP_Get_Tracklisting_With_Callback_For_Storage(device, storage_id, callback, data);
* while (tracklist != NULL) {
* LIBMTP_track_t *tmp;
*
* // Do something on each element in the list here...
* tmp = tracklist;
* tracklist = tracklist->next;
* LIBMTP_destroy_track_t(tmp);
* }
* </pre>
*
* If you want to group your track listing by storage (per storage unit) or
* arrange tracks into folders, you must dereference the <code>storage_id</code>
* and/or <code>parent_id</code> field of the returned <code>LIBMTP_track_t</code>
* struct. To arrange by folders or files you typically have to create the proper
* trees by calls to <code>LIBMTP_Get_Storage()</code> and/or
* <code>LIBMTP_Get_Folder_List()</code> first.
*
* @param device a pointer to the device to get the track listing for.
* @param storage_id ID of device storage (if null, no filter)
* @param callback a function to be called during the tracklisting retrieveal
* for displaying progress bars etc, or NULL if you don't want
* any callbacks.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return a list of tracks that can be followed using the <code>next</code>
* field of the <code>LIBMTP_track_t</code> data structure.
* Each of the metadata tags must be freed after use, and may
* contain only partial metadata information, i.e. one or several
* fields may be NULL or 0.
* @see LIBMTP_Get_Trackmetadata()
*/
LIBMTP_track_t *LIBMTP_Get_Tracklisting_With_Callback_For_Storage(LIBMTP_mtpdevice_t *device, uint32_t const storage_id,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
uint32_t i = 0;
LIBMTP_track_t *retracks = NULL;
LIBMTP_track_t *curtrack = NULL;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0) {
flush_handles(device);
}
for (i = 0; i < params->nrofobjects; i++) {
LIBMTP_track_t *track;
PTPObject *ob;
LIBMTP_filetype_t mtptype;
if (callback != NULL)
callback(i, params->nrofobjects, data);
ob = ¶ms->objects[i];
mtptype = map_ptp_type_to_libmtp_type(ob->oi.ObjectFormat);
// Ignore stuff we don't know how to handle...
// TODO: get this list as an intersection of the sets
// supported by the device and the from the device and
// all known track files?
if (!LIBMTP_FILETYPE_IS_TRACK(mtptype) &&
// This row lets through undefined files for examination since they may be forgotten OGG files.
(ob->oi.ObjectFormat != PTP_OFC_Undefined ||
(!FLAG_IRIVER_OGG_ALZHEIMER(ptp_usb) &&
!FLAG_OGG_IS_UNKNOWN(ptp_usb) &&
!FLAG_FLAC_IS_UNKNOWN(ptp_usb)))
) {
//printf("Not a music track (name: %s format: %d), skipping...\n", oi->Filename, oi->ObjectFormat);
continue;
}
// Ignore stuff that isn't into the storage device
if ((storage_id != 0) && (ob->oi.StorageID != storage_id ))
continue;
// Allocate a new track type
track = LIBMTP_new_track_t();
// This is some sort of unique ID so we can keep track of the track.
track->item_id = ob->oid;
track->parent_id = ob->oi.ParentObject;
track->storage_id = ob->oi.StorageID;
track->modificationdate = ob->oi.ModificationDate;
track->filetype = mtptype;
// Original file-specific properties
track->filesize = ob->oi.ObjectCompressedSize;
if (ob->oi.Filename != NULL) {
track->filename = strdup(ob->oi.Filename);
}
get_track_metadata(device, ob->oi.ObjectFormat, track);
/*
* A special quirk for iriver devices that doesn't quite
* remember that some files marked as "unknown" type are
* actually OGG or FLAC files. We look at the filename extension
* and see if it happens that this was atleast named "ogg" or "flac"
* and fall back on this heuristic approach in that case,
* for these bugged devices only.
*/
if (track->filetype == LIBMTP_FILETYPE_UNKNOWN &&
track->filename != NULL) {
if ((FLAG_IRIVER_OGG_ALZHEIMER(ptp_usb) ||
FLAG_OGG_IS_UNKNOWN(ptp_usb)) &&
has_ogg_extension(track->filename))
track->filetype = LIBMTP_FILETYPE_OGG;
else if (FLAG_FLAC_IS_UNKNOWN(ptp_usb) &&
has_flac_extension(track->filename))
track->filetype = LIBMTP_FILETYPE_FLAC;
else {
// This was not an OGG/FLAC file so discard it and continue
LIBMTP_destroy_track_t(track);
continue;
}
}
// Add track to a list that will be returned afterwards.
if (retracks == NULL) {
retracks = track;
curtrack = track;
} else {
curtrack->next = track;
curtrack = track;
}
// Call listing callback
// double progressPercent = (double)i*(double)100.0 / (double)params->handles.n;
} // Handle counting loop
return retracks;
}
/**
* This function retrieves the metadata for a single track off
* the device.
*
* Do not call this function repeatedly! The track handles are linearly
* searched O(n) and the call may involve (slow) USB traffic, so use
* <code>LIBMTP_Get_Tracklisting()</code> and cache the tracks, preferably
* as an efficient data structure such as a hash list.
*
* @param device a pointer to the device to get the track metadata from.
* @param trackid the object ID of the track that you want the metadata for.
* @return a track metadata entry on success or NULL on failure.
* @see LIBMTP_Get_Tracklisting()
*/
LIBMTP_track_t *LIBMTP_Get_Trackmetadata(LIBMTP_mtpdevice_t *device, uint32_t const trackid)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPObject *ob;
LIBMTP_track_t *track;
LIBMTP_filetype_t mtptype;
uint16_t ret;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0)
flush_handles(device);
ret = ptp_object_want (params, trackid, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK)
return NULL;
mtptype = map_ptp_type_to_libmtp_type(ob->oi.ObjectFormat);
// Ignore stuff we don't know how to handle...
if (!LIBMTP_FILETYPE_IS_TRACK(mtptype) &&
/*
* This row lets through undefined files for examination
* since they may be forgotten OGG or FLAC files.
*/
(ob->oi.ObjectFormat != PTP_OFC_Undefined ||
(!FLAG_IRIVER_OGG_ALZHEIMER(ptp_usb) &&
!FLAG_OGG_IS_UNKNOWN(ptp_usb) &&
!FLAG_FLAC_IS_UNKNOWN(ptp_usb)))
) {
//printf("Not a music track (name: %s format: %d), skipping...\n", oi->Filename, oi->ObjectFormat);
return NULL;
}
// Allocate a new track type
track = LIBMTP_new_track_t();
// This is some sort of unique ID so we can keep track of the track.
track->item_id = ob->oid;
track->parent_id = ob->oi.ParentObject;
track->storage_id = ob->oi.StorageID;
track->modificationdate = ob->oi.ModificationDate;
track->filetype = mtptype;
// Original file-specific properties
track->filesize = ob->oi.ObjectCompressedSize;
if (ob->oi.Filename != NULL) {
track->filename = strdup(ob->oi.Filename);
}
/*
* A special quirk for devices that doesn't quite
* remember that some files marked as "unknown" type are
* actually OGG or FLAC files. We look at the filename extension
* and see if it happens that this was atleast named "ogg"
* and fall back on this heuristic approach in that case,
* for these bugged devices only.
*/
if (track->filetype == LIBMTP_FILETYPE_UNKNOWN &&
track->filename != NULL) {
if ((FLAG_IRIVER_OGG_ALZHEIMER(ptp_usb) ||
FLAG_OGG_IS_UNKNOWN(ptp_usb)) &&
has_ogg_extension(track->filename))
track->filetype = LIBMTP_FILETYPE_OGG;
else if (FLAG_FLAC_IS_UNKNOWN(ptp_usb) &&
has_flac_extension(track->filename))
track->filetype = LIBMTP_FILETYPE_FLAC;
else {
// This was not an OGG/FLAC file so discard it
LIBMTP_destroy_track_t(track);
return NULL;
}
}
get_track_metadata(device, ob->oi.ObjectFormat, track);
return track;
}
/**
* This is a manual conversion from MTPDataGetFunc to PTPDataGetFunc
* to isolate the internal type.
*/
static uint16_t get_func_wrapper(PTPParams* params, void* priv, unsigned long wantlen, unsigned char *data, unsigned long *gotlen)
{
MTPDataHandler *handler = (MTPDataHandler *)priv;
uint16_t ret;
uint32_t local_gotlen = 0;
ret = handler->getfunc(params, handler->priv, wantlen, data, &local_gotlen);
*gotlen = local_gotlen;
switch (ret)
{
case LIBMTP_HANDLER_RETURN_OK:
return PTP_RC_OK;
case LIBMTP_HANDLER_RETURN_ERROR:
return PTP_ERROR_IO;
case LIBMTP_HANDLER_RETURN_CANCEL:
return PTP_ERROR_CANCEL;
default:
return PTP_ERROR_IO;
}
}
/**
* This is a manual conversion from MTPDataPutFunc to PTPDataPutFunc
* to isolate the internal type.
*/
static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data)
{
MTPDataHandler *handler = (MTPDataHandler *)priv;
uint16_t ret;
uint32_t local_putlen = 0;
ret = handler->putfunc(params, handler->priv, sendlen, data, &local_putlen);
switch (ret)
{
case LIBMTP_HANDLER_RETURN_OK:
if (local_putlen != sendlen)
return PTP_ERROR_IO;
return PTP_RC_OK;
case LIBMTP_HANDLER_RETURN_ERROR:
return PTP_ERROR_IO;
case LIBMTP_HANDLER_RETURN_CANCEL:
return PTP_ERROR_CANCEL;
default:
return PTP_ERROR_IO;
}
}
/**
* This gets a file off the device to a local file identified
* by a filename.
* @param device a pointer to the device to get the track from.
* @param id the file ID of the file to retrieve.
* @param path a filename to use for the retrieved file.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Get_File_To_File_Descriptor()
*/
int LIBMTP_Get_File_To_File(LIBMTP_mtpdevice_t *device, uint32_t const id,
char const * const path, LIBMTP_progressfunc_t const callback,
void const * const data)
{
int fd = -1;
int ret;
// Sanity check
if (path == NULL) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File(): Bad arguments, path was NULL.");
return -1;
}
// Open file
#ifdef __WIN32__
#ifdef USE_WINDOWS_IO_H
if ( (fd = _open(path, O_RDWR|O_CREAT|O_TRUNC|O_BINARY,_S_IREAD)) == -1 ) {
#else
if ( (fd = open(path, O_RDWR|O_CREAT|O_TRUNC|O_BINARY,S_IRWXU)) == -1 ) {
#endif
#else
if ( (fd = open(path, O_RDWR|O_CREAT|O_TRUNC,S_IRWXU|S_IRGRP)) == -1) {
#endif
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File(): Could not create file.");
return -1;
}
ret = LIBMTP_Get_File_To_File_Descriptor(device, id, fd, callback, data);
// Close file
close(fd);
// Delete partial file.
if (ret == -1) {
unlink(path);
}
return ret;
}
/**
* This gets a file off the device to a file identified
* by a file descriptor.
*
* This function can potentially be used for streaming
* files off the device for playback or broadcast for example,
* by downloading the file into a stream sink e.g. a socket.
*
* @param device a pointer to the device to get the file from.
* @param id the file ID of the file to retrieve.
* @param fd a local file descriptor to write the file to.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Get_File_To_File()
*/
int LIBMTP_Get_File_To_File_Descriptor(LIBMTP_mtpdevice_t *device,
uint32_t const id,
int const fd,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPObject *ob;
ret = ptp_object_want (params, id, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File_Descriptor(): Could not get object info.");
return -1;
}
if (ob->oi.ObjectFormat == PTP_OFC_Association) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File_Descriptor(): Bad object format.");
return -1;
}
// Callbacks
ptp_usb->callback_active = 1;
ptp_usb->current_transfer_total = ob->oi.ObjectCompressedSize+
PTP_USB_BULK_HDR_LEN+sizeof(uint32_t); // Request length, one parameter
ptp_usb->current_transfer_complete = 0;
ptp_usb->current_transfer_callback = callback;
ptp_usb->current_transfer_callback_data = data;
ret = ptp_getobject_tofd(params, id, fd);
ptp_usb->callback_active = 0;
ptp_usb->current_transfer_callback = NULL;
ptp_usb->current_transfer_callback_data = NULL;
if (ret == PTP_ERROR_CANCEL) {
add_error_to_errorstack(device, LIBMTP_ERROR_CANCELLED, "LIBMTP_Get_File_From_File_Descriptor(): Cancelled transfer.");
return -1;
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_File_To_File_Descriptor(): Could not get file from device.");
return -1;
}
return 0;
}
/**
* This gets a file off the device and calls put_func
* with chunks of data
*
* @param device a pointer to the device to get the file from.
* @param id the file ID of the file to retrieve.
* @param put_func the function to call when we have data.
* @param priv the user-defined pointer that is passed to
* <code>put_func</code>.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
*/
int LIBMTP_Get_File_To_Handler(LIBMTP_mtpdevice_t *device,
uint32_t const id,
MTPDataPutFunc put_func,
void * priv,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
PTPObject *ob;
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
ret = ptp_object_want (params, id, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File_Descriptor(): Could not get object info.");
return -1;
}
if (ob->oi.ObjectFormat == PTP_OFC_Association) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_File_To_File_Descriptor(): Bad object format.");
return -1;
}
// Callbacks
ptp_usb->callback_active = 1;
ptp_usb->current_transfer_total = ob->oi.ObjectCompressedSize+
PTP_USB_BULK_HDR_LEN+sizeof(uint32_t); // Request length, one parameter
ptp_usb->current_transfer_complete = 0;
ptp_usb->current_transfer_callback = callback;
ptp_usb->current_transfer_callback_data = data;
MTPDataHandler mtp_handler;
mtp_handler.getfunc = NULL;
mtp_handler.putfunc = put_func;
mtp_handler.priv = priv;
PTPDataHandler handler;
handler.getfunc = NULL;
handler.putfunc = put_func_wrapper;
handler.priv = &mtp_handler;
ret = ptp_getobject_to_handler(params, id, &handler);
ptp_usb->callback_active = 0;
ptp_usb->current_transfer_callback = NULL;
ptp_usb->current_transfer_callback_data = NULL;
if (ret == PTP_ERROR_CANCEL) {
add_error_to_errorstack(device, LIBMTP_ERROR_CANCELLED, "LIBMTP_Get_File_From_File_Descriptor(): Cancelled transfer.");
return -1;
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_File_To_File_Descriptor(): Could not get file from device.");
return -1;
}
return 0;
}
/**
* This gets a track off the device to a file identified
* by a filename. This is actually just a wrapper for the
* \c LIBMTP_Get_Track_To_File() function.
* @param device a pointer to the device to get the track from.
* @param id the track ID of the track to retrieve.
* @param path a filename to use for the retrieved track.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Get_Track_To_File_Descriptor()
*/
int LIBMTP_Get_Track_To_File(LIBMTP_mtpdevice_t *device, uint32_t const id,
char const * const path, LIBMTP_progressfunc_t const callback,
void const * const data)
{
// This is just a wrapper
return LIBMTP_Get_File_To_File(device, id, path, callback, data);
}
/**
* This gets a track off the device to a file identified
* by a file descriptor. This is actually just a wrapper for
* the \c LIBMTP_Get_File_To_File_Descriptor() function.
* @param device a pointer to the device to get the track from.
* @param id the track ID of the track to retrieve.
* @param fd a file descriptor to write the track to.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Get_Track_To_File()
*/
int LIBMTP_Get_Track_To_File_Descriptor(LIBMTP_mtpdevice_t *device,
uint32_t const id,
int const fd,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
// This is just a wrapper
return LIBMTP_Get_File_To_File_Descriptor(device, id, fd, callback, data);
}
/**
* This gets a track off the device to a handler function.
* This is actually just a wrapper for
* the \c LIBMTP_Get_File_To_Handler() function.
* @param device a pointer to the device to get the track from.
* @param id the track ID of the track to retrieve.
* @param put_func the function to call when we have data.
* @param priv the user-defined pointer that is passed to
* <code>put_func</code>.
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
*/
int LIBMTP_Get_Track_To_Handler(LIBMTP_mtpdevice_t *device,
uint32_t const id,
MTPDataPutFunc put_func,
void * priv,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
// This is just a wrapper
return LIBMTP_Get_File_To_Handler(device, id, put_func, priv, callback, data);
}
/**
* This function sends a track from a local file to an
* MTP device. A filename and a set of metadata must be
* given as input.
* @param device a pointer to the device to send the track to.
* @param path the filename of a local file which will be sent.
* @param metadata a track metadata set to be written along with the file.
* After this call the field <code>metadata->item_id</code>
* will contain the new track ID. Other fields such
* as the <code>metadata->filename</code>, <code>metadata->parent_id</code>
* or <code>metadata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>metadata->parent_id</code> should be set to the parent
* (e.g. folder) to store this track in. Since some
* devices are a bit picky about where files
* are placed, a default folder will be chosen if libmtp
* has detected one for the current filetype and this
* parameter is set to 0. If this is 0 and no default folder
* can be found, the file will be stored in the root folder.
* <li><code>metadata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this track in. Setting this to 0 will store
* the track on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_Track_From_File_Descriptor()
* @see LIBMTP_Send_File_From_File()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_Track_From_File(LIBMTP_mtpdevice_t *device,
char const * const path, LIBMTP_track_t * const metadata,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
int fd;
int ret;
// Sanity check
if (path == NULL) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Send_Track_From_File(): Bad arguments, path was NULL.");
return -1;
}
// Open file
#ifdef __WIN32__
#ifdef USE_WINDOWS_IO_H
if ( (fd = _open(path, O_RDONLY|O_BINARY)) == -1 ) {
#else
if ( (fd = open(path, O_RDONLY|O_BINARY)) == -1 ) {
#endif
#else
if ( (fd = open(path, O_RDONLY)) == -1) {
#endif
LIBMTP_ERROR("LIBMTP_Send_Track_From_File(): Could not open source file \"%s\"\n", path);
return -1;
}
ret = LIBMTP_Send_Track_From_File_Descriptor(device, fd, metadata, callback, data);
// Close file.
#ifdef USE_WINDOWS_IO_H
_close(fd);
#else
close(fd);
#endif
return ret;
}
/**
* This helper function checks if a filename already exists on the device
* @param PTPParams*
* @param string representing the filename
* @return 0 if the filename doesn't exist, -1 if it does
*/
static int check_filename_exists(PTPParams* params, char const * const filename)
{
int i;
for (i = 0; i < params->nrofobjects; i++) {
char *fname = params->objects[i].oi.Filename;
if ((fname != NULL) && (strcmp(filename, fname) == 0))
{
return -1;
}
}
return 0;
}
/**
* This helper function returns a unique filename, with a random string before the extension
* @param string representing the original filename
* @return a string representing the unique filename
*/
static char *generate_unique_filename(PTPParams* params, char const * const filename)
{
int suffix;
char * extension_position;
if (check_filename_exists(params, filename))
{
extension_position = strrchr(filename,'.');
char basename[extension_position - filename + 1];
strncpy(basename, filename, extension_position - filename);
basename[extension_position - filename] = '\0';
suffix = 1;
char newname[ strlen(basename) + 6 + strlen(extension_position)];
sprintf(newname, "%s_%d%s", basename, suffix, extension_position);
while ((check_filename_exists(params, newname)) && (suffix < 1000000)) {
suffix++;
sprintf(newname, "%s_%d%s", basename, suffix, extension_position);
}
return strdup(newname);
}
else
{
return strdup(filename);
}
}
/**
* This function sends a track from a file descriptor to an
* MTP device. A filename and a set of metadata must be
* given as input.
* @param device a pointer to the device to send the track to.
* @param fd the filedescriptor for a local file which will be sent.
* @param metadata a track metadata set to be written along with the file.
* After this call the field <code>metadata->item_id</code>
* will contain the new track ID. Other fields such
* as the <code>metadata->filename</code>, <code>metadata->parent_id</code>
* or <code>metadata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>metadata->parent_id</code> should be set to the parent
* (e.g. folder) to store this track in. Since some
* devices are a bit picky about where files
* are placed, a default folder will be chosen if libmtp
* has detected one for the current filetype and this
* parameter is set to 0. If this is 0 and no default folder
* can be found, the file will be stored in the root folder.
* <li><code>metadata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this track in. Setting this to 0 will store
* the track on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_Track_From_File()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_Track_From_File_Descriptor(LIBMTP_mtpdevice_t *device,
int const fd, LIBMTP_track_t * const metadata,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
int subcall_ret;
LIBMTP_file_t filedata;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPParams *params = (PTPParams *) device->params;
// Sanity check, is this really a track?
if (!LIBMTP_FILETYPE_IS_TRACK(metadata->filetype)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_Track_From_File_Descriptor(): "
"I don't think this is actually a track, strange filetype...");
}
// Wrap around the file transfer function
filedata.item_id = metadata->item_id;
filedata.parent_id = metadata->parent_id;
filedata.storage_id = metadata->storage_id;
if FLAG_UNIQUE_FILENAMES(ptp_usb) {
filedata.filename = generate_unique_filename(params, metadata->filename);
}
else {
filedata.filename = metadata->filename;
}
filedata.filesize = metadata->filesize;
filedata.filetype = metadata->filetype;
filedata.next = NULL;
subcall_ret = LIBMTP_Send_File_From_File_Descriptor(device,
fd,
&filedata,
callback,
data);
if (subcall_ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_Track_From_File_Descriptor(): "
"subcall to LIBMTP_Send_File_From_File_Descriptor failed.");
// We used to delete the file here, but don't... It might be OK after all.
// (void) LIBMTP_Delete_Object(device, metadata->item_id);
return -1;
}
// Pick up new item (and parent, storage) ID
metadata->item_id = filedata.item_id;
metadata->parent_id = filedata.parent_id;
metadata->storage_id = filedata.storage_id;
// Set track metadata for the new fine track
subcall_ret = LIBMTP_Update_Track_Metadata(device, metadata);
if (subcall_ret != 0) {
// Subcall will add error to errorstack
// We used to delete the file here, but don't... It might be OK after all.
// (void) LIBMTP_Delete_Object(device, metadata->item_id);
return -1;
}
// note we don't need to update the cache here because LIBMTP_Send_File_From_File_Descriptor
// has added the object handle and LIBMTP_Update_Track_Metadata has added the metadata.
return 0;
}
/**
* This function sends a track from a handler function to an
* MTP device. A filename and a set of metadata must be
* given as input.
* @param device a pointer to the device to send the track to.
* @param get_func the function to call when we have data.
* @param priv the user-defined pointer that is passed to
* <code>get_func</code>.
* @param metadata a track metadata set to be written along with the file.
* After this call the field <code>metadata->item_id</code>
* will contain the new track ID. Other fields such
* as the <code>metadata->filename</code>, <code>metadata->parent_id</code>
* or <code>metadata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>metadata->parent_id</code> should be set to the parent
* (e.g. folder) to store this track in. Since some
* devices are a bit picky about where files
* are placed, a default folder will be chosen if libmtp
* has detected one for the current filetype and this
* parameter is set to 0. If this is 0 and no default folder
* can be found, the file will be stored in the root folder.
* <li><code>metadata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this track in. Setting this to 0 will store
* the track on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_Track_From_File()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_Track_From_Handler(LIBMTP_mtpdevice_t *device,
MTPDataGetFunc get_func, void * priv, LIBMTP_track_t * const metadata,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
int subcall_ret;
LIBMTP_file_t filedata;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPParams *params = (PTPParams *) device->params;
// Sanity check, is this really a track?
if (!LIBMTP_FILETYPE_IS_TRACK(metadata->filetype)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_Track_From_Handler(): "
"I don't think this is actually a track, strange filetype...");
}
// Wrap around the file transfer function
filedata.item_id = metadata->item_id;
filedata.parent_id = metadata->parent_id;
filedata.storage_id = metadata->storage_id;
if FLAG_UNIQUE_FILENAMES(ptp_usb) {
filedata.filename = generate_unique_filename(params, metadata->filename);
}
else {
filedata.filename = metadata->filename;
}
filedata.filesize = metadata->filesize;
filedata.filetype = metadata->filetype;
filedata.next = NULL;
subcall_ret = LIBMTP_Send_File_From_Handler(device,
get_func,
priv,
&filedata,
callback,
data);
if (subcall_ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_Track_From_Handler(): "
"subcall to LIBMTP_Send_File_From_Handler failed.");
// We used to delete the file here, but don't... It might be OK after all.
// (void) LIBMTP_Delete_Object(device, metadata->item_id);
return -1;
}
// Pick up new item (and parent, storage) ID
metadata->item_id = filedata.item_id;
metadata->parent_id = filedata.parent_id;
metadata->storage_id = filedata.storage_id;
// Set track metadata for the new fine track
subcall_ret = LIBMTP_Update_Track_Metadata(device, metadata);
if (subcall_ret != 0) {
// Subcall will add error to errorstack
// We used to delete the file here, but don't... It might be OK after all.
// (void) LIBMTP_Delete_Object(device, metadata->item_id);
return -1;
}
// note we don't need to update the cache here because LIBMTP_Send_File_From_File_Descriptor
// has added the object handle and LIBMTP_Update_Track_Metadata has added the metadata.
return 0;
}
/**
* This function sends a local file to an MTP device.
* A filename and a set of metadata must be
* given as input.
* @param device a pointer to the device to send the track to.
* @param path the filename of a local file which will be sent.
* @param filedata a file metadata set to be written along with the file.
* After this call the field <code>filedata->item_id</code>
* will contain the new file ID. Other fields such
* as the <code>filedata->filename</code>, <code>filedata->parent_id</code>
* or <code>filedata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>filedata->parent_id</code> should be set to the parent
* (e.g. folder) to store this file in. If this is 0,
* the file will be stored in the root folder.
* <li><code>filedata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this file in. Setting this to 0 will store
* the file on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_File_From_File_Descriptor()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_File_From_File(LIBMTP_mtpdevice_t *device,
char const * const path, LIBMTP_file_t * const filedata,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
int fd;
int ret;
// Sanity check
if (path == NULL) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Send_File_From_File(): Bad arguments, path was NULL.");
return -1;
}
// Open file
#ifdef __WIN32__
#ifdef USE_WINDOWS_IO_H
if ( (fd = _open(path, O_RDONLY|O_BINARY)) == -1 ) {
#else
if ( (fd = open(path, O_RDONLY|O_BINARY)) == -1 ) {
#endif
#else
if ( (fd = open(path, O_RDONLY)) == -1) {
#endif
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Send_File_From_File(): Could not open source file.");
return -1;
}
ret = LIBMTP_Send_File_From_File_Descriptor(device, fd, filedata, callback, data);
// Close file.
#ifdef USE_WINDOWS_IO_H
_close(fd);
#else
close(fd);
#endif
return ret;
}
/**
* This function sends a generic file from a file descriptor to an
* MTP device. A filename and a set of metadata must be
* given as input.
*
* This can potentially be used for sending in a stream of unknown
* length. Send music files with
* <code>LIBMTP_Send_Track_From_File_Descriptor()</code>
*
* @param device a pointer to the device to send the file to.
* @param fd the filedescriptor for a local file which will be sent.
* @param filedata a file metadata set to be written along with the file.
* After this call the field <code>filedata->item_id</code>
* will contain the new file ID. Other fields such
* as the <code>filedata->filename</code>, <code>filedata->parent_id</code>
* or <code>filedata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>filedata->parent_id</code> should be set to the parent
* (e.g. folder) to store this file in. If this is 0,
* the file will be stored in the root folder.
* <li><code>filedata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this file in. Setting this to 0 will store
* the file on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_File_From_File()
* @see LIBMTP_Send_Track_From_File_Descriptor()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_File_From_File_Descriptor(LIBMTP_mtpdevice_t *device,
int const fd, LIBMTP_file_t * const filedata,
LIBMTP_progressfunc_t const callback,
void const * const data)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
LIBMTP_file_t *newfilemeta;
int oldtimeout;
int timeout;
if (send_file_object_info(device, filedata))
{
// no need to output an error since send_file_object_info will already have done so
return -1;
}
// Callbacks
ptp_usb->callback_active = 1;
// The callback will deactivate itself after this amount of data has been sent
// One BULK header for the request, one for the data phase. No parameters to the request.
ptp_usb->current_transfer_total = filedata->filesize+PTP_USB_BULK_HDR_LEN*2;
ptp_usb->current_transfer_complete = 0;
ptp_usb->current_transfer_callback = callback;
ptp_usb->current_transfer_callback_data = data;
/*
* We might need to increase the timeout here, files can be pretty
* large. Take the default timeout and add the calculated time for
* this transfer
*/
get_usb_device_timeout(ptp_usb, &oldtimeout);
timeout = oldtimeout +
(ptp_usb->current_transfer_total / guess_usb_speed(ptp_usb)) * 1000;
set_usb_device_timeout(ptp_usb, timeout);
ret = ptp_sendobject_fromfd(params, fd, filedata->filesize);
ptp_usb->callback_active = 0;
ptp_usb->current_transfer_callback = NULL;
ptp_usb->current_transfer_callback_data = NULL;
set_usb_device_timeout(ptp_usb, oldtimeout);
if (ret == PTP_ERROR_CANCEL) {
add_error_to_errorstack(device, LIBMTP_ERROR_CANCELLED, "LIBMTP_Send_File_From_File_Descriptor(): Cancelled transfer.");
return -1;
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Send_File_From_File_Descriptor(): "
"Could not send object.");
return -1;
}
add_object_to_cache(device, filedata->item_id);
/*
* Get the device-assigned parent_id from the cache.
* The operation that adds it to the cache will
* look it up from the device, so we get the new
* parent_id from the cache.
*/
newfilemeta = LIBMTP_Get_Filemetadata(device, filedata->item_id);
if (newfilemeta != NULL) {
filedata->parent_id = newfilemeta->parent_id;
filedata->storage_id = newfilemeta->storage_id;
LIBMTP_destroy_file_t(newfilemeta);
} else {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_File_From_File_Descriptor(): "
"Could not retrieve updated metadata.");
return -1;
}
return 0;
}
/**
* This function sends a generic file from a handler function to an
* MTP device. A filename and a set of metadata must be
* given as input.
*
* This can potentially be used for sending in a stream of unknown
* length. Send music files with
* <code>LIBMTP_Send_Track_From_Handler()</code>
*
* @param device a pointer to the device to send the file to.
* @param get_func the function to call to get data to write
* @param priv a user-defined pointer that is passed along to
* <code>get_func</code>. If not used, this is set to NULL.
* @param filedata a file metadata set to be written along with the file.
* After this call the field <code>filedata->item_id</code>
* will contain the new file ID. Other fields such
* as the <code>filedata->filename</code>, <code>filedata->parent_id</code>
* or <code>filedata->storage_id</code> may also change during this
* operation due to device restrictions, so do not rely on the
* contents of this struct to be preserved in any way.
* <ul>
* <li><code>filedata->parent_id</code> should be set to the parent
* (e.g. folder) to store this file in. If this is 0,
* the file will be stored in the root folder.
* <li><code>filedata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this file in. Setting this to 0 will store
* the file on the primary storage.
* </ul>
* @param callback a progress indicator function or NULL to ignore.
* @param data a user-defined pointer that is passed along to
* the <code>progress</code> function in order to
* pass along some user defined data to the progress
* updates. If not used, set this to NULL.
* @return 0 if the transfer was successful, any other value means
* failure.
* @see LIBMTP_Send_File_From_File()
* @see LIBMTP_Send_Track_From_File_Descriptor()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Send_File_From_Handler(LIBMTP_mtpdevice_t *device,
MTPDataGetFunc get_func, void * priv, LIBMTP_file_t * const filedata,
LIBMTP_progressfunc_t const callback, void const * const data)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
LIBMTP_file_t *newfilemeta;
if (send_file_object_info(device, filedata))
{
// no need to output an error since send_file_object_info will already have done so
return -1;
}
// Callbacks
ptp_usb->callback_active = 1;
// The callback will deactivate itself after this amount of data has been sent
// One BULK header for the request, one for the data phase. No parameters to the request.
ptp_usb->current_transfer_total = filedata->filesize+PTP_USB_BULK_HDR_LEN*2;
ptp_usb->current_transfer_complete = 0;
ptp_usb->current_transfer_callback = callback;
ptp_usb->current_transfer_callback_data = data;
MTPDataHandler mtp_handler;
mtp_handler.getfunc = get_func;
mtp_handler.putfunc = NULL;
mtp_handler.priv = priv;
PTPDataHandler handler;
handler.getfunc = get_func_wrapper;
handler.putfunc = NULL;
handler.priv = &mtp_handler;
ret = ptp_sendobject_from_handler(params, &handler, filedata->filesize);
ptp_usb->callback_active = 0;
ptp_usb->current_transfer_callback = NULL;
ptp_usb->current_transfer_callback_data = NULL;
if (ret == PTP_ERROR_CANCEL) {
add_error_to_errorstack(device, LIBMTP_ERROR_CANCELLED, "LIBMTP_Send_File_From_Handler(): Cancelled transfer.");
return -1;
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Send_File_From_Handler(): "
"Could not send object.");
return -1;
}
add_object_to_cache(device, filedata->item_id);
/*
* Get the device-assined parent_id from the cache.
* The operation that adds it to the cache will
* look it up from the device, so we get the new
* parent_id from the cache.
*/
newfilemeta = LIBMTP_Get_Filemetadata(device, filedata->item_id);
if (newfilemeta != NULL) {
filedata->parent_id = newfilemeta->parent_id;
filedata->storage_id = newfilemeta->storage_id;
LIBMTP_destroy_file_t(newfilemeta);
} else {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_Send_File_From_Handler(): "
"Could not retrieve updated metadata.");
return -1;
}
return 0;
}
/**
* This function sends the file object info, ready for sendobject
* @param device a pointer to the device to send the file to.
* @param filedata a file metadata set to be written along with the file.
* @return 0 if the transfer was successful, any other value means
* failure.
*/
static int send_file_object_info(LIBMTP_mtpdevice_t *device, LIBMTP_file_t *filedata)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint32_t store;
int use_primary_storage = 1;
uint16_t of = map_libmtp_type_to_ptp_type(filedata->filetype);
LIBMTP_devicestorage_t *storage;
uint32_t localph = filedata->parent_id;
uint16_t ret;
int i;
#if 0
// Sanity check: no zerolength files on some devices?
// If the zerolength files cause problems on some devices,
// then add a bug flag for this.
if (filedata->filesize == 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "send_file_object_info(): "
"File of zero size.");
return -1;
}
#endif
if (filedata->storage_id != 0) {
store = filedata->storage_id;
} else {
store = get_suggested_storage_id(device, filedata->filesize, localph);
}
// Detect if something non-primary is in use.
storage = device->storage;
if (storage != NULL && store != storage->id) {
use_primary_storage = 0;
}
/*
* If no destination folder was given, look up a default
* folder if possible. Perhaps there is some way of retrieveing
* the default folder for different forms of content, what
* do I know, we use a fixed list in lack of any better method.
* Some devices obviously need to have their files in certain
* folders in order to find/display them at all (hello Creative),
* so we have to have a method for this. We only do this if the
* primary storage is in use.
*/
if (localph == 0 && use_primary_storage) {
if (LIBMTP_FILETYPE_IS_AUDIO(filedata->filetype)) {
localph = device->default_music_folder;
} else if (LIBMTP_FILETYPE_IS_VIDEO(filedata->filetype)) {
localph = device->default_video_folder;
} else if (of == PTP_OFC_EXIF_JPEG ||
of == PTP_OFC_JP2 ||
of == PTP_OFC_JPX ||
of == PTP_OFC_JFIF ||
of == PTP_OFC_TIFF ||
of == PTP_OFC_TIFF_IT ||
of == PTP_OFC_BMP ||
of == PTP_OFC_GIF ||
of == PTP_OFC_PICT ||
of == PTP_OFC_PNG ||
of == PTP_OFC_MTP_WindowsImageFormat) {
localph = device->default_picture_folder;
} else if (of == PTP_OFC_MTP_vCalendar1 ||
of == PTP_OFC_MTP_vCalendar2 ||
of == PTP_OFC_MTP_UndefinedContact ||
of == PTP_OFC_MTP_vCard2 ||
of == PTP_OFC_MTP_vCard3 ||
of == PTP_OFC_MTP_UndefinedCalendarItem) {
localph = device->default_organizer_folder;
} else if (of == PTP_OFC_Text) {
localph = device->default_text_folder;
}
}
// Here we wire the type to unknown on bugged, but
// Ogg or FLAC-supportive devices.
if (FLAG_OGG_IS_UNKNOWN(ptp_usb) && of == PTP_OFC_MTP_OGG) {
of = PTP_OFC_Undefined;
}
if (FLAG_FLAC_IS_UNKNOWN(ptp_usb) && of == PTP_OFC_MTP_FLAC) {
of = PTP_OFC_Undefined;
}
if (ptp_operation_issupported(params, PTP_OC_MTP_SendObjectPropList) &&
!FLAG_BROKEN_SEND_OBJECT_PROPLIST(ptp_usb)) {
/*
* MTP enhanched does it this way (from a sniff):
* -> PTP_OC_MTP_SendObjectPropList (0x9808):
* 20 00 00 00 01 00 08 98 1B 00 00 00 01 00 01 00
* FF FF FF FF 00 30 00 00 00 00 00 00 12 5E 00 00
* Length: 0x00000020
* Type: 0x0001 PTP_USB_CONTAINER_COMMAND
* Code: 0x9808
* Transaction ID: 0x0000001B
* Param1: 0x00010001 <- store
* Param2: 0xffffffff <- parent handle (-1 ?)
* Param3: 0x00003000 <- file type PTP_OFC_Undefined - we don't know about PDF files
* Param4: 0x00000000 <- file length MSB (-0x0c header len)
* Param5: 0x00005e12 <- file length LSB (-0x0c header len)
*
* -> PTP_OC_MTP_SendObjectPropList (0x9808):
* 46 00 00 00 02 00 08 98 1B 00 00 00 03 00 00 00
* 00 00 00 00 07 DC FF FF 0D 4B 00 53 00 30 00 36 - dc07 = file name
* 00 30 00 33 00 30 00 36 00 2E 00 70 00 64 00 66
* 00 00 00 00 00 00 00 03 DC 04 00 00 00 00 00 00 - dc03 = protection status
* 00 4F DC 02 00 01 - dc4f = non consumable
* Length: 0x00000046
* Type: 0x0002 PTP_USB_CONTAINER_DATA
* Code: 0x9808
* Transaction ID: 0x0000001B
* Metadata....
* 0x00000003 <- Number of metadata items
* 0x00000000 <- Object handle, set to 0x00000000 since it is unknown!
* 0xdc07 <- metadata type: file name
* 0xffff <- metadata type: string
* 0x0d <- number of (uint16_t) characters
* 4b 53 30 36 30 33 30 36 2e 50 64 66 00 "KS060306.pdf", null terminated
* 0x00000000 <- Object handle, set to 0x00000000 since it is unknown!
* 0xdc03 <- metadata type: protection status
* 0x0004 <- metadata type: uint16_t
* 0x0000 <- not protected
* 0x00000000 <- Object handle, set to 0x00000000 since it is unknown!
* 0xdc4f <- non consumable
* 0x0002 <- metadata type: uint8_t
* 0x01 <- non-consumable (this device cannot display PDF)
*
* <- Read 0x18 bytes back
* 18 00 00 00 03 00 01 20 1B 00 00 00 01 00 01 00
* 00 00 00 00 01 40 00 00
* Length: 0x000000018
* Type: 0x0003 PTP_USB_CONTAINER_RESPONSE
* Code: 0x2001 PTP_OK
* Transaction ID: 0x0000001B
* Param1: 0x00010001 <- store
* Param2: 0x00000000 <- parent handle
* Param3: 0x00004001 <- new file/object ID
*
* -> PTP_OC_SendObject (0x100d)
* 0C 00 00 00 01 00 0D 10 1C 00 00 00
* -> ... all the bytes ...
* <- Read 0x0c bytes back
* 0C 00 00 00 03 00 01 20 1C 00 00 00
* ... Then update metadata one-by one, actually (instead of sending it first!) ...
*/
MTPProperties *props = NULL;
int nrofprops = 0;
MTPProperties *prop = NULL;
uint16_t *properties = NULL;
uint32_t propcnt = 0;
// default parent handle
if (localph == 0)
localph = 0xFFFFFFFFU; // Set to -1
// Must be 0x00000000U for new objects
filedata->item_id = 0x00000000U;
ret = ptp_mtp_getobjectpropssupported(params, of, &propcnt, &properties);
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], of, &opd);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "send_file_object_info(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_ObjectFileName:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = filedata->item_id;
prop->property = PTP_OPC_ObjectFileName;
prop->datatype = PTP_DTC_STR;
if (filedata->filename != NULL) {
prop->propval.str = strdup(filedata->filename);
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(prop->propval.str);
}
}
break;
case PTP_OPC_ProtectionStatus:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = filedata->item_id;
prop->property = PTP_OPC_ProtectionStatus;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = 0x0000U; /* Not protected */
break;
case PTP_OPC_NonConsumable:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = filedata->item_id;
prop->property = PTP_OPC_NonConsumable;
prop->datatype = PTP_DTC_UINT8;
prop->propval.u8 = 0x00; /* It is supported, then it is consumable */
break;
case PTP_OPC_Name:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = filedata->item_id;
prop->property = PTP_OPC_Name;
prop->datatype = PTP_DTC_STR;
if (filedata->filename != NULL)
prop->propval.str = strdup(filedata->filename);
break;
case PTP_OPC_DateModified:
// Tag with current time if that is supported
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = filedata->item_id;
prop->property = PTP_OPC_DateModified;
prop->datatype = PTP_DTC_STR;
prop->propval.str = get_iso8601_stamp();
filedata->modificationdate = time(NULL);
}
break;
}
}
ptp_free_objectpropdesc(&opd);
}
free(properties);
ret = ptp_mtp_sendobjectproplist(params, &store, &localph, &filedata->item_id,
of, filedata->filesize, props, nrofprops);
/* Free property list */
ptp_destroy_object_prop_list(props, nrofprops);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "send_file_object_info():"
"Could not send object property list.");
if (ret == PTP_RC_AccessDenied) {
add_ptp_error_to_errorstack(device, ret, "ACCESS DENIED.");
}
return -1;
}
} else if (ptp_operation_issupported(params,PTP_OC_SendObjectInfo)) {
PTPObjectInfo new_file;
memset(&new_file, 0, sizeof(PTPObjectInfo));
new_file.Filename = filedata->filename;
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(new_file.Filename);
}
if (filedata->filesize > 0xFFFFFFFFL) {
// This is a kludge in the MTP standard for large files.
new_file.ObjectCompressedSize = (uint32_t) 0xFFFFFFFF;
} else {
new_file.ObjectCompressedSize = (uint32_t) filedata->filesize;
}
new_file.ObjectFormat = of;
new_file.StorageID = store;
new_file.ParentObject = localph;
new_file.ModificationDate = time(NULL);
// Create the object
ret = ptp_sendobjectinfo(params, &store, &localph, &filedata->item_id, &new_file);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "send_file_object_info(): "
"Could not send object info.");
if (ret == PTP_RC_AccessDenied) {
add_ptp_error_to_errorstack(device, ret, "ACCESS DENIED.");
}
return -1;
}
// NOTE: the char* pointers inside new_file are not copies so don't
// try to destroy this objectinfo!
}
// Now there IS an object with this parent handle.
filedata->parent_id = localph;
return 0;
}
/**
* This function updates the MTP track object metadata on a
* single file identified by an object ID.
* @param device a pointer to the device to update the track
* metadata on.
* @param metadata a track metadata set to be written to the file.
* notice that the <code>track_id</code> field of the
* metadata structure must be correct so that the
* function can update the right file. If some properties
* of this metadata are set to NULL (strings) or 0
* (numerical values) they will be discarded and the
* track will not be tagged with these blank values.
* @return 0 on success, any other value means failure. If some
* or all of the properties fail to update we will still
* return success. On some devices (notably iRiver T30)
* properties that exist cannot be updated.
*/
int LIBMTP_Update_Track_Metadata(LIBMTP_mtpdevice_t *device,
LIBMTP_track_t const * const metadata)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint32_t i;
uint16_t *properties = NULL;
uint32_t propcnt = 0;
// First see which properties can be set on this file format and apply accordingly
// i.e only try to update this metadata for object tags that exist on the current player.
ret = ptp_mtp_getobjectpropssupported(params, map_libmtp_type_to_ptp_type(metadata->filetype), &propcnt, &properties);
if (ret != PTP_RC_OK) {
// Just bail out for now, nothing is ever set.
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not retrieve supported object properties.");
return -1;
}
if (ptp_operation_issupported(params, PTP_OC_MTP_SetObjPropList) &&
!FLAG_BROKEN_SET_OBJECT_PROPLIST(ptp_usb)) {
MTPProperties *props = NULL;
MTPProperties *prop = NULL;
int nrofprops = 0;
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], map_libmtp_type_to_ptp_type(metadata->filetype), &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_Name:
if (metadata->title == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Name;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->title);
break;
case PTP_OPC_AlbumName:
if (metadata->album == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_AlbumName;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->album);
break;
case PTP_OPC_Artist:
if (metadata->artist == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Artist;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->artist);
break;
case PTP_OPC_Composer:
if (metadata->composer == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Composer;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->composer);
break;
case PTP_OPC_Genre:
if (metadata->genre == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Genre;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->genre);
break;
case PTP_OPC_Duration:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Duration;
prop->datatype = PTP_DTC_UINT32;
prop->propval.u32 = adjust_u32(metadata->duration, &opd);
break;
case PTP_OPC_Track:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Track;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = adjust_u16(metadata->tracknumber, &opd);
break;
case PTP_OPC_OriginalReleaseDate:
if (metadata->date == NULL)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_OriginalReleaseDate;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(metadata->date);
break;
case PTP_OPC_SampleRate:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_SampleRate;
prop->datatype = PTP_DTC_UINT32;
prop->propval.u32 = adjust_u32(metadata->samplerate, &opd);
break;
case PTP_OPC_NumberOfChannels:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_NumberOfChannels;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = adjust_u16(metadata->nochannels, &opd);
break;
case PTP_OPC_AudioWAVECodec:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_AudioWAVECodec;
prop->datatype = PTP_DTC_UINT32;
prop->propval.u32 = adjust_u32(metadata->wavecodec, &opd);
break;
case PTP_OPC_AudioBitRate:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_AudioBitRate;
prop->datatype = PTP_DTC_UINT32;
prop->propval.u32 = adjust_u32(metadata->bitrate, &opd);
break;
case PTP_OPC_BitRateType:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_BitRateType;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = adjust_u16(metadata->bitratetype, &opd);
break;
case PTP_OPC_Rating:
// TODO: shall this be set for rating 0?
if (metadata->rating == 0)
break;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_Rating;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = adjust_u16(metadata->rating, &opd);
break;
case PTP_OPC_UseCount:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_UseCount;
prop->datatype = PTP_DTC_UINT32;
prop->propval.u32 = adjust_u32(metadata->usecount, &opd);
break;
case PTP_OPC_DateModified:
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
// Tag with current time if that is supported
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = metadata->item_id;
prop->property = PTP_OPC_DateModified;
prop->datatype = PTP_DTC_STR;
prop->propval.str = get_iso8601_stamp();
}
break;
default:
break;
}
}
ptp_free_objectpropdesc(&opd);
}
// NOTE: File size is not updated, this should not change anyway.
// neither will we change the filename.
ret = ptp_mtp_setobjectproplist(params, props, nrofprops);
ptp_destroy_object_prop_list(props, nrofprops);
if (ret != PTP_RC_OK) {
// TODO: return error of which property we couldn't set
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set object property list.");
free(properties);
return -1;
}
} else if (ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], map_libmtp_type_to_ptp_type(metadata->filetype), &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_Name:
// Update title
ret = set_object_string(device, metadata->item_id, PTP_OPC_Name, metadata->title);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track title.");
}
break;
case PTP_OPC_AlbumName:
// Update album
ret = set_object_string(device, metadata->item_id, PTP_OPC_AlbumName, metadata->album);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track album name.");
}
break;
case PTP_OPC_Artist:
// Update artist
ret = set_object_string(device, metadata->item_id, PTP_OPC_Artist, metadata->artist);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track artist name.");
}
break;
case PTP_OPC_Composer:
// Update composer
ret = set_object_string(device, metadata->item_id, PTP_OPC_Composer, metadata->composer);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track composer name.");
}
break;
case PTP_OPC_Genre:
// Update genre (but only if valid)
if (metadata->genre) {
ret = set_object_string(device, metadata->item_id, PTP_OPC_Genre, metadata->genre);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set genre.");
}
}
break;
case PTP_OPC_Duration:
// Update duration
if (metadata->duration != 0) {
ret = set_object_u32(device, metadata->item_id, PTP_OPC_Duration, adjust_u32(metadata->duration, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track duration.");
}
}
break;
case PTP_OPC_Track:
// Update track number.
if (metadata->tracknumber != 0) {
ret = set_object_u16(device, metadata->item_id, PTP_OPC_Track, adjust_u16(metadata->tracknumber, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track tracknumber.");
}
}
break;
case PTP_OPC_OriginalReleaseDate:
// Update creation datetime
// The date can be zero, but some devices do not support setting zero
// dates (and it seems that a zero date should never be set anyway)
if (metadata->date) {
ret = set_object_string(device, metadata->item_id, PTP_OPC_OriginalReleaseDate, metadata->date);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set track release date.");
}
}
break;
// These are, well not so important.
case PTP_OPC_SampleRate:
// Update sample rate
if (metadata->samplerate != 0) {
ret = set_object_u32(device, metadata->item_id, PTP_OPC_SampleRate, adjust_u32(metadata->samplerate, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set samplerate.");
}
}
break;
case PTP_OPC_NumberOfChannels:
// Update number of channels
if (metadata->nochannels != 0) {
ret = set_object_u16(device, metadata->item_id, PTP_OPC_NumberOfChannels, adjust_u16(metadata->nochannels, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set number of channels.");
}
}
break;
case PTP_OPC_AudioWAVECodec:
// Update WAVE codec
if (metadata->wavecodec != 0) {
ret = set_object_u32(device, metadata->item_id, PTP_OPC_AudioWAVECodec, adjust_u32(metadata->wavecodec, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set WAVE codec.");
}
}
break;
case PTP_OPC_AudioBitRate:
// Update bitrate
if (metadata->bitrate != 0) {
ret = set_object_u32(device, metadata->item_id, PTP_OPC_AudioBitRate, adjust_u32(metadata->bitrate, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set bitrate.");
}
}
break;
case PTP_OPC_BitRateType:
// Update bitrate type
if (metadata->bitratetype != 0) {
ret = set_object_u16(device, metadata->item_id, PTP_OPC_BitRateType, adjust_u16(metadata->bitratetype, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set bitratetype.");
}
}
break;
case PTP_OPC_Rating:
// Update user rating
// TODO: shall this be set for rating 0?
if (metadata->rating != 0) {
ret = set_object_u16(device, metadata->item_id, PTP_OPC_Rating, adjust_u16(metadata->rating, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set user rating.");
}
}
break;
case PTP_OPC_UseCount:
// Update use count, set even to zero if desired.
ret = set_object_u32(device, metadata->item_id, PTP_OPC_UseCount, adjust_u32(metadata->usecount, &opd));
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set use count.");
}
break;
case PTP_OPC_DateModified:
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
// Update modification time if supported
char *tmpstamp = get_iso8601_stamp();
ret = set_object_string(device, metadata->item_id, PTP_OPC_DateModified, tmpstamp);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"could not set modification date.");
}
free(tmpstamp);
}
break;
// NOTE: File size is not updated, this should not change anyway.
// neither will we change the filename.
default:
break;
}
}
ptp_free_objectpropdesc(&opd);
}
} else {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Update_Track_Metadata(): "
"Your device doesn't seem to support any known way of setting metadata.");
free(properties);
return -1;
}
// update cached object properties if metadata cache exists
update_metadata_cache(device, metadata->item_id);
free(properties);
return 0;
}
/**
* This function deletes a single file, track, playlist, folder or
* any other object off the MTP device, identified by the object ID.
*
* If you delete a folder, there is no guarantee that the device will
* really delete all the files that were in that folder, rather it is
* expected that they will not be deleted, and will turn up in object
* listings with parent set to a non-existant object ID. The safe way
* to do this is to recursively delete all files (and folders) contained
* in the folder, then the folder itself.
*
* @param device a pointer to the device to delete the object from.
* @param object_id the object to delete.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Delete_Object(LIBMTP_mtpdevice_t *device,
uint32_t object_id)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
ret = ptp_deleteobject(params, object_id, 0);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Delete_Object(): could not delete object.");
return -1;
}
return 0;
}
/**
* Internal function to update an object filename property.
*/
static int set_object_filename(LIBMTP_mtpdevice_t *device,
uint32_t object_id, uint16_t ptp_type,
const char **newname_ptr)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPObjectPropDesc opd;
uint16_t ret;
char *newname;
// See if we can modify the filename on this kind of files.
ret = ptp_mtp_getobjectpropdesc(params, PTP_OPC_ObjectFileName, ptp_type, &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_filename(): "
"could not get property description.");
return -1;
}
if (!opd.GetSet) {
ptp_free_objectpropdesc(&opd);
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_filename(): "
" property is not settable.");
// TODO: we COULD actually upload/download the object here, if we feel
// like wasting time for the user.
return -1;
}
newname = strdup(*newname_ptr);
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(newname);
}
if (ptp_operation_issupported(params, PTP_OC_MTP_SetObjPropList) &&
!FLAG_BROKEN_SET_OBJECT_PROPLIST(ptp_usb)) {
MTPProperties *props = NULL;
MTPProperties *prop = NULL;
int nrofprops = 0;
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = object_id;
prop->property = PTP_OPC_ObjectFileName;
prop->datatype = PTP_DTC_STR;
prop->propval.str = newname;
ret = ptp_mtp_setobjectproplist(params, props, nrofprops);
ptp_destroy_object_prop_list(props, nrofprops);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_filename(): "
" could not set object property list.");
ptp_free_objectpropdesc(&opd);
return -1;
}
} else if (ptp_operation_issupported(params, PTP_OC_MTP_SetObjectPropValue)) {
ret = set_object_string(device, object_id, PTP_OPC_ObjectFileName, newname);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_filename(): "
" could not set object filename.");
ptp_free_objectpropdesc(&opd);
return -1;
}
} else {
free(newname);
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_filename(): "
" your device doesn't seem to support any known way of setting metadata.");
ptp_free_objectpropdesc(&opd);
return -1;
}
ptp_free_objectpropdesc(&opd);
// update cached object properties if metadata cache exists
update_metadata_cache(device, object_id);
return 0;
}
/**
* This function renames a single file.
* This simply means that the PTP_OPC_ObjectFileName property
* is updated, if this is supported by the device.
*
* @param device a pointer to the device that contains the file.
* @param file the file metadata of the file to rename.
* On success, the filename member is updated. Be aware, that
* this name can be different than newname depending of device restrictions.
* @param newname the new filename for this object.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Set_File_Name(LIBMTP_mtpdevice_t *device,
LIBMTP_file_t *file, const char *newname)
{
int ret;
ret = set_object_filename(device, file->item_id,
map_libmtp_type_to_ptp_type(file->filetype),
&newname);
if (ret != 0) {
return ret;
}
free(file->filename);
file->filename = strdup(newname);
return ret;
}
/**
* This function renames a single folder.
* This simply means that the PTP_OPC_ObjectFileName property
* is updated, if this is supported by the device.
*
* @param device a pointer to the device that contains the file.
* @param folder the folder metadata of the folder to rename.
* On success, the name member is updated. Be aware, that
* this name can be different than newname depending of device restrictions.
* @param newname the new name for this object.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Set_Folder_Name(LIBMTP_mtpdevice_t *device,
LIBMTP_folder_t *folder, const char* newname)
{
int ret;
ret = set_object_filename(device, folder->folder_id,
PTP_OFC_Association,
&newname);
if (ret != 0) {
return ret;
}
free(folder->name);
folder->name = strdup(newname);
return ret;
}
/**
* This function renames a single track.
* This simply means that the PTP_OPC_ObjectFileName property
* is updated, if this is supported by the device.
*
* @param device a pointer to the device that contains the file.
* @param track the track metadata of the track to rename.
* On success, the filename member is updated. Be aware, that
* this name can be different than newname depending of device restrictions.
* @param newname the new filename for this object.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Set_Track_Name(LIBMTP_mtpdevice_t *device,
LIBMTP_track_t *track, const char* newname)
{
int ret;
ret = set_object_filename(device, track->item_id,
map_libmtp_type_to_ptp_type(track->filetype),
&newname);
if (ret != 0) {
return ret;
}
free(track->filename);
track->filename = strdup(newname);
return ret;
}
/**
* This function renames a single playlist object file holder.
* This simply means that the <code>PTP_OPC_ObjectFileName</code>
* property is updated, if this is supported by the device.
* The playlist filename should nominally end with an extension
* like ".pla".
*
* NOTE: if you want to change the metadata the device display
* about a playlist you must <i>not</i> use this function,
* use <code>LIBMTP_Update_Playlist()</code> instead!
*
* @param device a pointer to the device that contains the file.
* @param playlist the playlist metadata of the playlist to rename.
* On success, the name member is updated. Be aware, that
* this name can be different than newname depending of device restrictions.
* @param newname the new name for this object.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Update_Playlist()
*/
int LIBMTP_Set_Playlist_Name(LIBMTP_mtpdevice_t *device,
LIBMTP_playlist_t *playlist, const char* newname)
{
int ret;
ret = set_object_filename(device, playlist->playlist_id,
PTP_OFC_MTP_AbstractAudioVideoPlaylist,
&newname);
if (ret != 0) {
return ret;
}
free(playlist->name);
playlist->name = strdup(newname);
return ret;
}
/**
* This function renames a single album.
* This simply means that the <code>PTP_OPC_ObjectFileName</code>
* property is updated, if this is supported by the device.
* The album filename should nominally end with an extension
* like ".alb".
*
* NOTE: if you want to change the metadata the device display
* about a playlist you must <i>not</i> use this function,
* use <code>LIBMTP_Update_Album()</code> instead!
*
* @param device a pointer to the device that contains the file.
* @param album the album metadata of the album to rename.
* On success, the name member is updated. Be aware, that
* this name can be different than newname depending of device restrictions.
* @param newname the new name for this object.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Update_Album()
*/
int LIBMTP_Set_Album_Name(LIBMTP_mtpdevice_t *device,
LIBMTP_album_t *album, const char* newname)
{
int ret;
ret = set_object_filename(device, album->album_id,
PTP_OFC_MTP_AbstractAudioAlbum,
&newname);
if (ret != 0) {
return ret;
}
free(album->name);
album->name = strdup(newname);
return ret;
}
/**
* THIS FUNCTION IS DEPRECATED. PLEASE UPDATE YOUR CODE IN ORDER
* NOT TO USE IT.
*
* @see LIBMTP_Set_File_Name()
* @see LIBMTP_Set_Track_Name()
* @see LIBMTP_Set_Folder_Name()
* @see LIBMTP_Set_Playlist_Name()
* @see LIBMTP_Set_Album_Name()
*/
int LIBMTP_Set_Object_Filename(LIBMTP_mtpdevice_t *device,
uint32_t object_id, char* newname)
{
int ret;
LIBMTP_file_t *file;
file = LIBMTP_Get_Filemetadata(device, object_id);
if (file == NULL) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Set_Object_Filename(): "
"could not get file metadata for target object.");
return -1;
}
ret = set_object_filename(device, object_id, map_libmtp_type_to_ptp_type(file->filetype), (const char **) &newname);
free(file);
return ret;
}
/**
* Helper function. This indicates if a track exists on the device
* @param device a pointer to the device to get the track from.
* @param id the track ID of the track to retrieve.
* @return TRUE (!=0) if the track exists, FALSE (0) if not
*/
int LIBMTP_Track_Exists(LIBMTP_mtpdevice_t *device,
uint32_t const id)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
PTPObject *ob;
ret = ptp_object_want (params, id, 0, &ob);
if (ret == PTP_RC_OK)
return -1;
return 0;
}
/**
* This creates a new folder structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_folder_track_t</code>
* operation later, so be careful of using strdup() when assigning
* strings, e.g.:
*
* @return a pointer to the newly allocated folder structure.
* @see LIBMTP_destroy_folder_t()
*/
LIBMTP_folder_t *LIBMTP_new_folder_t(void)
{
LIBMTP_folder_t *new = (LIBMTP_folder_t *) malloc(sizeof(LIBMTP_folder_t));
if (new == NULL) {
return NULL;
}
new->folder_id = 0;
new->parent_id = 0;
new->storage_id = 0;
new->name = NULL;
new->sibling = NULL;
new->child = NULL;
return new;
}
/**
* This recursively deletes the memory for a folder structure.
* This shall typically be called on a top-level folder list to
* detsroy the entire folder tree.
*
* @param folder folder structure to destroy
* @see LIBMTP_new_folder_t()
*/
void LIBMTP_destroy_folder_t(LIBMTP_folder_t *folder)
{
if(folder == NULL) {
return;
}
//Destroy from the bottom up
if(folder->child != NULL) {
LIBMTP_destroy_folder_t(folder->child);
}
if(folder->sibling != NULL) {
LIBMTP_destroy_folder_t(folder->sibling);
}
if(folder->name != NULL) {
free(folder->name);
}
free(folder);
}
/**
* Helper function. Returns a folder structure for a
* specified id.
*
* @param folderlist list of folders to search
* @id id of folder to look for
* @return a folder or NULL if not found
*/
LIBMTP_folder_t *LIBMTP_Find_Folder(LIBMTP_folder_t *folderlist, uint32_t id)
{
LIBMTP_folder_t *ret = NULL;
if(folderlist == NULL) {
return NULL;
}
if(folderlist->folder_id == id) {
return folderlist;
}
if(folderlist->sibling) {
ret = LIBMTP_Find_Folder(folderlist->sibling, id);
}
if(folderlist->child && ret == NULL) {
ret = LIBMTP_Find_Folder(folderlist->child, id);
}
return ret;
}
/**
* Function used to recursively get subfolders from params.
*/
static LIBMTP_folder_t *get_subfolders_for_folder(LIBMTP_folder_t *list, uint32_t parent)
{
LIBMTP_folder_t *retfolders = NULL;
LIBMTP_folder_t *children, *iter, *curr;
iter = list->sibling;
while(iter != list) {
if (iter->parent_id != parent) {
iter = iter->sibling;
continue;
}
/* We know that iter is a child of 'parent', therefore we can safely
* hold on to 'iter' locally since no one else will steal it
* from the 'list' as we recurse. */
children = get_subfolders_for_folder(list, iter->folder_id);
curr = iter;
iter = iter->sibling;
// Remove curr from the list.
curr->child->sibling = curr->sibling;
curr->sibling->child = curr->child;
// Attach the children to curr.
curr->child = children;
// Put this folder into the list of siblings.
curr->sibling = retfolders;
retfolders = curr;
}
return retfolders;
}
/**
* This returns a list of all folders available
* on the current MTP device.
*
* @param device a pointer to the device to get the folder listing for.
* @param storage a storage ID to get the folder list from
* @return a list of folders
*/
LIBMTP_folder_t *LIBMTP_Get_Folder_List_For_Storage(LIBMTP_mtpdevice_t *device,
uint32_t const storage)
{
PTPParams *params = (PTPParams *) device->params;
LIBMTP_folder_t head, *rv;
int i;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0) {
flush_handles(device);
}
/*
* This creates a temporary list of the folders, this is in a
* reverse order and uses the Folder pointers that are already
* in the Folder structure. From this we can then build up the
* folder hierarchy with only looking at this temporary list,
* and removing the folders from this temporary list as we go.
* This significantly reduces the number of operations that we
* have to do in building the folder hierarchy. Also since the
* temp list is in reverse order, when we prepend to the sibling
* list things are in the same order as they were originally
* in the handle list.
*/
head.sibling = &head;
head.child = &head;
for (i = 0; i < params->nrofobjects; i++) {
LIBMTP_folder_t *folder;
PTPObject *ob;
ob = ¶ms->objects[i];
if (ob->oi.ObjectFormat != PTP_OFC_Association) {
continue;
}
if (storage != PTP_GOH_ALL_STORAGE && storage != ob->oi.StorageID) {
continue;
}
/*
* Do we know how to handle these? They are part
* of the MTP 1.0 specification paragraph 3.6.4.
* For AssociationDesc 0x00000001U ptp_mtp_getobjectreferences()
* should be called on these to get the contained objects, but
* we basically don't care. Hopefully parent_id is maintained for all
* children, because we rely on that instead.
*/
if (ob->oi.AssociationDesc != 0x00000000U) {
LIBMTP_INFO("MTP extended association type 0x%08x encountered\n", ob->oi.AssociationDesc);
}
// Create a folder struct...
folder = LIBMTP_new_folder_t();
if (folder == NULL) {
// malloc failure or so.
return NULL;
}
folder->folder_id = ob->oid;
folder->parent_id = ob->oi.ParentObject;
folder->storage_id = ob->oi.StorageID;
folder->name = (ob->oi.Filename) ? (char *)strdup(ob->oi.Filename) : NULL;
// pretend sibling says next, and child says prev.
folder->sibling = head.sibling;
folder->child = &head;
head.sibling->child = folder;
head.sibling = folder;
}
// We begin at the given root folder and get them all recursively
rv = get_subfolders_for_folder(&head, 0x00000000U);
// Some buggy devices may have some files in the "root folder"
// 0xffffffff so if 0x00000000 didn't return any folders,
// look for children of the root 0xffffffffU
if (rv == NULL) {
rv = get_subfolders_for_folder(&head, 0xffffffffU);
if (rv != NULL)
LIBMTP_ERROR("Device have files in \"root folder\" 0xffffffffU - "
"this is a firmware bug (but continuing)\n");
}
// The temp list should be empty. Clean up any orphans just in case.
while(head.sibling != &head) {
LIBMTP_folder_t *curr = head.sibling;
LIBMTP_INFO("Orphan folder with ID: 0x%08x name: \"%s\" encountered.\n",
curr->folder_id,
curr->name);
curr->sibling->child = curr->child;
curr->child->sibling = curr->sibling;
curr->child = NULL;
curr->sibling = NULL;
LIBMTP_destroy_folder_t(curr);
}
return rv;
}
/**
* This returns a list of all folders available
* on the current MTP device.
*
* @param device a pointer to the device to get the folder listing for.
* @return a list of folders
*/
LIBMTP_folder_t *LIBMTP_Get_Folder_List(LIBMTP_mtpdevice_t *device)
{
return LIBMTP_Get_Folder_List_For_Storage(device, PTP_GOH_ALL_STORAGE);
}
/**
* This create a folder on the current MTP device. The PTP name
* for a folder is "association". The PTP/MTP devices does not
* have an internal "folder" concept really, it contains a flat
* list of all files and some file are "associations" that other
* files and folders may refer to as its "parent".
*
* @param device a pointer to the device to create the folder on.
* @param name the name of the new folder. Note this can be modified
* if the device does not support all the characters in the
* name.
* @param parent_id id of parent folder to add the new folder to,
* or 0xFFFFFFFF to put it in the root directory.
* @param storage_id id of the storage to add this new folder to.
* notice that you cannot mismatch storage id and parent id:
* they must both be on the same storage! Pass in 0 if you
* want to create this folder on the default storage.
* @return id to new folder or 0 if an error occured
*/
uint32_t LIBMTP_Create_Folder(LIBMTP_mtpdevice_t *device, char *name,
uint32_t parent_id, uint32_t storage_id)
{
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint32_t parenthandle = 0;
uint32_t store;
PTPObjectInfo new_folder;
uint16_t ret;
uint32_t new_id = 0;
if (storage_id == 0) {
// I'm just guessing that a folder may require 512 bytes
store = get_suggested_storage_id(device, 512, parent_id);
} else {
store = storage_id;
}
parenthandle = parent_id;
memset(&new_folder, 0, sizeof(new_folder));
new_folder.Filename = name;
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(new_folder.Filename);
}
new_folder.ObjectCompressedSize = 0;
new_folder.ObjectFormat = PTP_OFC_Association;
new_folder.ProtectionStatus = PTP_PS_NoProtection;
new_folder.AssociationType = PTP_AT_GenericFolder;
new_folder.ParentObject = parent_id;
new_folder.StorageID = store;
// Create the object
if (!(params->device_flags & DEVICE_FLAG_BROKEN_SEND_OBJECT_PROPLIST) &&
ptp_operation_issupported(params,PTP_OC_MTP_SendObjectPropList)) {
MTPProperties *props = (MTPProperties*)calloc(2,sizeof(MTPProperties));
props[0].property = PTP_OPC_ObjectFileName;
props[0].datatype = PTP_DTC_STR;
props[0].propval.str = name;
props[1].property = PTP_OPC_Name;
props[1].datatype = PTP_DTC_STR;
props[1].propval.str = name;
ret = ptp_mtp_sendobjectproplist(params, &store, &parenthandle, &new_id, PTP_OFC_Association,
0, props, 1);
free(props);
} else {
ret = ptp_sendobjectinfo(params, &store, &parenthandle, &new_id, &new_folder);
}
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Create_Folder: Could not send object info.");
if (ret == PTP_RC_AccessDenied) {
add_ptp_error_to_errorstack(device, ret, "ACCESS DENIED.");
}
return 0;
}
// NOTE: don't destroy the new_folder objectinfo, because it is statically referencing
// several strings.
add_object_to_cache(device, new_id);
return new_id;
}
/**
* This creates a new playlist metadata structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_destroy_playlist_t</code>
* operation later, so be careful of using strdup() when assigning
* strings, e.g.:
*
* <pre>
* LIBMTP_playlist_t *pl = LIBMTP_new_playlist_t();
* pl->name = strdup(str);
* ....
* LIBMTP_destroy_playlist_t(pl);
* </pre>
*
* @return a pointer to the newly allocated metadata structure.
* @see LIBMTP_destroy_playlist_t()
*/
LIBMTP_playlist_t *LIBMTP_new_playlist_t(void)
{
LIBMTP_playlist_t *new = (LIBMTP_playlist_t *) malloc(sizeof(LIBMTP_playlist_t));
if (new == NULL) {
return NULL;
}
new->playlist_id = 0;
new->parent_id = 0;
new->storage_id = 0;
new->name = NULL;
new->tracks = NULL;
new->no_tracks = 0;
new->next = NULL;
return new;
}
/**
* This destroys a playlist metadata structure and deallocates the memory
* used by it, including any strings. Never use a track metadata
* structure again after calling this function on it.
* @param playlist the playlist metadata to destroy.
* @see LIBMTP_new_playlist_t()
*/
void LIBMTP_destroy_playlist_t(LIBMTP_playlist_t *playlist)
{
if (playlist == NULL) {
return;
}
if (playlist->name != NULL)
free(playlist->name);
if (playlist->tracks != NULL)
free(playlist->tracks);
free(playlist);
return;
}
/**
* This function returns a list of the playlists available on the
* device. Typical usage:
*
* <pre>
* </pre>
*
* @param device a pointer to the device to get the playlist listing from.
* @return a playlist list on success, else NULL. If there are no playlists
* on the device, NULL will be returned as well.
* @see LIBMTP_Get_Playlist()
*/
LIBMTP_playlist_t *LIBMTP_Get_Playlist_List(LIBMTP_mtpdevice_t *device)
{
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
const int REQ_SPL = FLAG_PLAYLIST_SPL(ptp_usb);
PTPParams *params = (PTPParams *) device->params;
LIBMTP_playlist_t *retlists = NULL;
LIBMTP_playlist_t *curlist = NULL;
uint32_t i;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0) {
flush_handles(device);
}
for (i = 0; i < params->nrofobjects; i++) {
LIBMTP_playlist_t *pl;
PTPObject *ob;
uint16_t ret;
ob = ¶ms->objects[i];
// Ignore stuff that isn't playlists
// For Samsung players we must look for the .spl extension explicitly since
// playlists are not stored as playlist objects.
if ( REQ_SPL && is_spl_playlist(&ob->oi) ) {
// Allocate a new playlist type
pl = LIBMTP_new_playlist_t();
spl_to_playlist_t(device, &ob->oi, ob->oid, pl);
}
else if ( ob->oi.ObjectFormat != PTP_OFC_MTP_AbstractAudioVideoPlaylist ) {
continue;
}
else {
// Allocate a new playlist type
pl = LIBMTP_new_playlist_t();
// Try to look up proper name, else use the oi->Filename field.
pl->name = get_string_from_object(device, ob->oid, PTP_OPC_Name);
if (pl->name == NULL) {
pl->name = strdup(ob->oi.Filename);
}
pl->playlist_id = ob->oid;
pl->parent_id = ob->oi.ParentObject;
pl->storage_id = ob->oi.StorageID;
// Then get the track listing for this playlist
ret = ptp_mtp_getobjectreferences(params, pl->playlist_id, &pl->tracks, &pl->no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Playlist_List(): "
"could not get object references.");
pl->tracks = NULL;
pl->no_tracks = 0;
}
}
// Add playlist to a list that will be returned afterwards.
if (retlists == NULL) {
retlists = pl;
curlist = pl;
} else {
curlist->next = pl;
curlist = pl;
}
// Call callback here if we decide to add that possibility...
}
return retlists;
}
/**
* This function retrieves an individual playlist from the device.
* @param device a pointer to the device to get the playlist from.
* @param plid the unique ID of the playlist to retrieve.
* @return a valid playlist metadata post or NULL on failure.
* @see LIBMTP_Get_Playlist_List()
*/
LIBMTP_playlist_t *LIBMTP_Get_Playlist(LIBMTP_mtpdevice_t *device, uint32_t const plid)
{
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
const int REQ_SPL = FLAG_PLAYLIST_SPL(ptp_usb);
PTPParams *params = (PTPParams *) device->params;
PTPObject *ob;
LIBMTP_playlist_t *pl;
uint16_t ret;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0) {
flush_handles(device);
}
ret = ptp_object_want (params, plid, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK)
return NULL;
// For Samsung players we must look for the .spl extension explicitly since
// playlists are not stored as playlist objects.
if ( REQ_SPL && is_spl_playlist(&ob->oi) ) {
// Allocate a new playlist type
pl = LIBMTP_new_playlist_t();
spl_to_playlist_t(device, &ob->oi, ob->oid, pl);
return pl;
}
// Ignore stuff that isn't playlists
else if ( ob->oi.ObjectFormat != PTP_OFC_MTP_AbstractAudioVideoPlaylist ) {
return NULL;
}
// Allocate a new playlist type
pl = LIBMTP_new_playlist_t();
pl->name = get_string_from_object(device, ob->oid, PTP_OPC_Name);
if (pl->name == NULL) {
pl->name = strdup(ob->oi.Filename);
}
pl->playlist_id = ob->oid;
pl->parent_id = ob->oi.ParentObject;
pl->storage_id = ob->oi.StorageID;
// Then get the track listing for this playlist
ret = ptp_mtp_getobjectreferences(params, pl->playlist_id, &pl->tracks, &pl->no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Playlist(): Could not get object references.");
pl->tracks = NULL;
pl->no_tracks = 0;
}
return pl;
}
/**
* This function creates a new abstract list such as a playlist
* or an album.
*
* @param device a pointer to the device to create the new abstract list
* on.
* @param name the name of the new abstract list.
* @param artist the artist of the new abstract list or NULL.
* @param genre the genre of the new abstract list or NULL.
* @param parenthandle the handle of the parent or 0 for no parent
* i.e. the root folder.
* @param objectformat the abstract list type to create.
* @param suffix the ".foo" (4 characters) suffix to use for the virtual
* "file" created by this operation.
* @param newid a pointer to a variable that will hold the new object
* ID if this call is successful.
* @param tracks an array of tracks to associate with this list.
* @param no_tracks the number of tracks in the list.
* @return 0 on success, any other value means failure.
*/
static int create_new_abstract_list(LIBMTP_mtpdevice_t *device,
char const * const name,
char const * const artist,
char const * const composer,
char const * const genre,
uint32_t const parenthandle,
uint32_t const storageid,
uint16_t const objectformat,
char const * const suffix,
uint32_t * const newid,
uint32_t const * const tracks,
uint32_t const no_tracks)
{
int i;
int supported = 0;
uint16_t ret;
uint16_t *properties = NULL;
uint32_t propcnt = 0;
uint32_t store;
uint32_t localph = parenthandle;
uint8_t nonconsumable = 0x00U; /* By default it is consumable */
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
char fname[256];
//uint8_t data[2];
// NULL check
if (!name) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): list name was NULL, using default name \"Unknown\"");
return -1;
}
if (storageid == 0) {
// I'm just guessing that an abstract list may require 512 bytes
store = get_suggested_storage_id(device, 512, localph);
} else {
store = storageid;
}
// Check if we can create an object of this type
for ( i=0; i < params->deviceinfo.ImageFormats_len; i++ ) {
if (params->deviceinfo.ImageFormats[i] == objectformat) {
supported = 1;
break;
}
}
if (!supported) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): player does not support this abstract type");
LIBMTP_ERROR("Unsupported abstract list type: %04x\n", objectformat);
return -1;
}
// add the new suffix if it isn't there
fname[0] = '\0';
if (strlen(name) > strlen(suffix)) {
char const * const suff = &name[strlen(name)-strlen(suffix)];
if (!strcmp(suff, suffix)) {
// Home free.
strncpy(fname, name, sizeof(fname));
}
}
// If it didn't end with "<suffix>" then add that here.
if (fname[0] == '\0') {
strncpy(fname, name, sizeof(fname)-strlen(suffix)-1);
strcat(fname, suffix);
fname[sizeof(fname)-1] = '\0';
}
if (ptp_operation_issupported(params, PTP_OC_MTP_SendObjectPropList) &&
!FLAG_BROKEN_SEND_OBJECT_PROPLIST(ptp_usb)) {
MTPProperties *props = NULL;
MTPProperties *prop = NULL;
int nrofprops = 0;
*newid = 0x00000000U;
ret = ptp_mtp_getobjectpropssupported(params, objectformat, &propcnt, &properties);
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], objectformat, &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_ObjectFileName:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_ObjectFileName;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(fname);
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(prop->propval.str);
}
break;
case PTP_OPC_ProtectionStatus:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_ProtectionStatus;
prop->datatype = PTP_DTC_UINT16;
prop->propval.u16 = 0x0000U; /* Not protected */
break;
case PTP_OPC_NonConsumable:
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_NonConsumable;
prop->datatype = PTP_DTC_UINT8;
prop->propval.u8 = nonconsumable;
break;
case PTP_OPC_Name:
if (name != NULL) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_Name;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(name);
}
break;
case PTP_OPC_AlbumArtist:
if (artist != NULL) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_AlbumArtist;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(artist);
}
break;
case PTP_OPC_Artist:
if (artist != NULL) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_Artist;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(artist);
}
break;
case PTP_OPC_Composer:
if (composer != NULL) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_Composer;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(composer);
}
break;
case PTP_OPC_Genre:
if (genre != NULL) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_Genre;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(genre);
}
break;
case PTP_OPC_DateModified:
// Tag with current time if that is supported
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
prop = ptp_get_new_object_prop_entry(&props,&nrofprops);
prop->ObjectHandle = *newid;
prop->property = PTP_OPC_DateModified;
prop->datatype = PTP_DTC_STR;
prop->propval.str = get_iso8601_stamp();
}
break;
}
}
ptp_free_objectpropdesc(&opd);
}
free(properties);
ret = ptp_mtp_sendobjectproplist(params, &store, &localph, newid,
objectformat, 0, props, nrofprops);
/* Free property list */
ptp_destroy_object_prop_list(props, nrofprops);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "create_new_abstract_list(): Could not send object property list.");
if (ret == PTP_RC_AccessDenied) {
add_ptp_error_to_errorstack(device, ret, "ACCESS DENIED.");
}
return -1;
}
// now send the blank object
ret = ptp_sendobject(params, NULL, 0);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "create_new_abstract_list(): Could not send blank object data.");
return -1;
}
} else if (ptp_operation_issupported(params,PTP_OC_SendObjectInfo)) {
PTPObjectInfo new_object;
new_object.Filename = fname;
if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
strip_7bit_from_utf8(new_object.Filename);
}
// At one point this had to be one
new_object.ObjectCompressedSize = 0;
new_object.ObjectFormat = objectformat;
// Create the object
ret = ptp_sendobjectinfo(params, &store, &localph, newid, &new_object);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "create_new_abstract_list(): Could not send object info (the playlist itself).");
if (ret == PTP_RC_AccessDenied) {
add_ptp_error_to_errorstack(device, ret, "ACCESS DENIED.");
}
return -1;
}
// NOTE: don't destroy new_object objectinfo afterwards - the strings it contains are
// not copies.
#if 0
/*
* At one time we had to send this one blank data byte.
* If we didn't, the handle will not be created and thus there is
* no playlist. Possibly this was masking some bug, so removing it
* now.
*/
data[0] = '\0';
data[1] = '\0';
ret = ptp_sendobject(params, data, 1);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "create_new_abstract_list(): Could not send blank object data.");
return -1;
}
#endif
// set the properties one by one
ret = ptp_mtp_getobjectpropssupported(params, objectformat, &propcnt, &properties);
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], objectformat, &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_Name:
if (name != NULL) {
ret = set_object_string(device, *newid, PTP_OPC_Name, name);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set entity name.");
return -1;
}
}
break;
case PTP_OPC_AlbumArtist:
if (artist != NULL) {
ret = set_object_string(device, *newid, PTP_OPC_AlbumArtist, artist);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set entity album artist.");
return -1;
}
}
break;
case PTP_OPC_Artist:
if (artist != NULL) {
ret = set_object_string(device, *newid, PTP_OPC_Artist, artist);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set entity artist.");
return -1;
}
}
break;
case PTP_OPC_Composer:
if (composer != NULL) {
ret = set_object_string(device, *newid, PTP_OPC_Composer, composer);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set entity composer.");
return -1;
}
}
break;
case PTP_OPC_Genre:
if (genre != NULL) {
ret = set_object_string(device, *newid, PTP_OPC_Genre, genre);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set entity genre.");
return -1;
}
}
break;
case PTP_OPC_DateModified:
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
ret = set_object_string(device, *newid, PTP_OPC_DateModified, get_iso8601_stamp());
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): could not set date modified.");
return -1;
}
}
break;
}
}
ptp_free_objectpropdesc(&opd);
}
free(properties);
}
if (no_tracks > 0) {
// Add tracks to the list as object references.
ret = ptp_mtp_setobjectreferences (params, *newid, (uint32_t *) tracks, no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "create_new_abstract_list(): could not add tracks as object references.");
return -1;
}
}
add_object_to_cache(device, *newid);
return 0;
}
/**
* This updates the metadata and track listing
* for an abstract list.
* @param device a pointer to the device that the abstract list
* resides on.
* @param name the name of the abstract list.
* @param artist the artist of the abstract list or NULL.
* @param genre the genre of the abstract list or NULL.
* @param objecthandle the object to be updated.
* @param objectformat the abstract list type to update.
* @param tracks an array of tracks to associate with this list.
* @param no_tracks the number of tracks in the list.
* @return 0 on success, any other value means failure.
*/
static int update_abstract_list(LIBMTP_mtpdevice_t *device,
char const * const name,
char const * const artist,
char const * const composer,
char const * const genre,
uint32_t const objecthandle,
uint16_t const objectformat,
uint32_t const * const tracks,
uint32_t const no_tracks)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint16_t *properties = NULL;
uint32_t propcnt = 0;
int i;
// First see which properties can be set
// i.e only try to update this metadata for object tags that exist on the current player.
ret = ptp_mtp_getobjectpropssupported(params, objectformat, &propcnt, &properties);
if (ret != PTP_RC_OK) {
// Just bail out for now, nothing is ever set.
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not retrieve supported object properties.");
return -1;
}
if (ptp_operation_issupported(params,PTP_OC_MTP_SetObjPropList) &&
!FLAG_BROKEN_SET_OBJECT_PROPLIST(ptp_usb)) {
MTPProperties *props = NULL;
MTPProperties *prop = NULL;
int nrofprops = 0;
for (i=0;i<propcnt;i++) {
PTPObjectPropDesc opd;
ret = ptp_mtp_getobjectpropdesc(params, properties[i], objectformat, &opd);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not get property description.");
} else if (opd.GetSet) {
switch (properties[i]) {
case PTP_OPC_Name:
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_Name;
prop->datatype = PTP_DTC_STR;
if (name != NULL)
prop->propval.str = strdup(name);
break;
case PTP_OPC_AlbumArtist:
if (artist != NULL) {
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_AlbumArtist;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(artist);
}
break;
case PTP_OPC_Artist:
if (artist != NULL) {
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_Artist;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(artist);
}
break;
case PTP_OPC_Composer:
if (composer != NULL) {
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_Composer;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(composer);
}
break;
case PTP_OPC_Genre:
if (genre != NULL) {
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_Genre;
prop->datatype = PTP_DTC_STR;
prop->propval.str = strdup(genre);
}
break;
case PTP_OPC_DateModified:
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
// Tag with current time if that is supported
prop = ptp_get_new_object_prop_entry(&props, &nrofprops);
prop->ObjectHandle = objecthandle;
prop->property = PTP_OPC_DateModified;
prop->datatype = PTP_DTC_STR;
prop->propval.str = get_iso8601_stamp();
}
break;
default:
break;
}
}
ptp_free_objectpropdesc(&opd);
}
// proplist could be NULL if we can't write any properties
if (props != NULL) {
ret = ptp_mtp_setobjectproplist(params, props, nrofprops);
ptp_destroy_object_prop_list(props, nrofprops);
if (ret != PTP_RC_OK) {
// TODO: return error of which property we couldn't set
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set object property list.");
free(properties);
return -1;
}
}
} else if (ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
for (i=0;i<propcnt;i++) {
switch (properties[i]) {
case PTP_OPC_Name:
// Update title
ret = set_object_string(device, objecthandle, PTP_OPC_Name, name);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set title.");
}
break;
case PTP_OPC_AlbumArtist:
// Update album artist
ret = set_object_string(device, objecthandle, PTP_OPC_AlbumArtist, artist);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set album artist name.");
}
break;
case PTP_OPC_Artist:
// Update artist
ret = set_object_string(device, objecthandle, PTP_OPC_Artist, artist);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set artist name.");
}
break;
case PTP_OPC_Composer:
// Update composer
ret = set_object_string(device, objecthandle, PTP_OPC_Composer, composer);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set composer name.");
}
break;
case PTP_OPC_Genre:
// Update genre (but only if valid)
if(genre) {
ret = set_object_string(device, objecthandle, PTP_OPC_Genre, genre);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set genre.");
}
}
break;
case PTP_OPC_DateModified:
// Update date modified
if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
char *tmpdate = get_iso8601_stamp();
ret = set_object_string(device, objecthandle, PTP_OPC_DateModified, tmpdate);
if (ret != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"could not set modification date.");
}
free(tmpdate);
}
break;
default:
break;
}
}
} else {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
"Your device doesn't seem to support any known way of setting metadata.");
free(properties);
return -1;
}
// Then the object references...
ret = ptp_mtp_setobjectreferences (params, objecthandle, (uint32_t *) tracks, no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "update_abstract_list(): could not add tracks as object references.");
free(properties);
return -1;
}
free(properties);
update_metadata_cache(device, objecthandle);
return 0;
}
/**
* This routine creates a new playlist based on the metadata
* supplied. If the <code>tracks</code> field of the metadata
* contains a track listing, these tracks will be added to the
* playlist.
* @param device a pointer to the device to create the new playlist on.
* @param metadata the metadata for the new playlist. If the function
* exits with success, the <code>playlist_id</code> field of this
* struct will contain the new playlist ID of the playlist.
* <ul>
* <li><code>metadata->parent_id</code> should be set to the parent
* (e.g. folder) to store this track in. Since some
* devices are a bit picky about where files
* are placed, a default folder will be chosen if libmtp
* has detected one for the current filetype and this
* parameter is set to 0. If this is 0 and no default folder
* can be found, the file will be stored in the root folder.
* <li><code>metadata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this track in. Setting this to 0 will store
* the track on the primary storage.
* </ul>
* @return 0 on success, any other value means failure.
* @see LIBMTP_Update_Playlist()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Create_New_Playlist(LIBMTP_mtpdevice_t *device,
LIBMTP_playlist_t * const metadata)
{
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
uint32_t localph = metadata->parent_id;
// Use a default folder if none given
if (localph == 0) {
if (device->default_playlist_folder != 0)
localph = device->default_playlist_folder;
else
localph = device->default_music_folder;
}
metadata->parent_id = localph;
// Samsung needs its own special type of playlists
if(FLAG_PLAYLIST_SPL(ptp_usb)) {
return playlist_t_to_spl(device, metadata);
}
// Just create a new abstract audio/video playlist...
return create_new_abstract_list(device,
metadata->name,
NULL,
NULL,
NULL,
localph,
metadata->storage_id,
PTP_OFC_MTP_AbstractAudioVideoPlaylist,
get_playlist_extension(ptp_usb),
&metadata->playlist_id,
metadata->tracks,
metadata->no_tracks);
}
/**
* This routine updates a playlist based on the metadata
* supplied. If the <code>tracks</code> field of the metadata
* contains a track listing, these tracks will be added to the
* playlist in place of those already present, i.e. the
* previous track listing will be deleted. For Samsung devices the
* playlist id (metadata->playlist_id) is likely to change.
* @param device a pointer to the device to create the new playlist on.
* @param metadata the metadata for the playlist to be updated.
* notice that the field <code>playlist_id</code>
* must contain the apropriate playlist ID. Playlist ID
* be modified to a new playlist ID by the time the
* function returns since edit-in-place is not always possible.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Create_New_Playlist()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Update_Playlist(LIBMTP_mtpdevice_t *device,
LIBMTP_playlist_t * const metadata)
{
// Samsung needs its own special type of playlists
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
if(FLAG_PLAYLIST_SPL(ptp_usb)) {
return update_spl_playlist(device, metadata);
}
return update_abstract_list(device,
metadata->name,
NULL,
NULL,
NULL,
metadata->playlist_id,
PTP_OFC_MTP_AbstractAudioVideoPlaylist,
metadata->tracks,
metadata->no_tracks);
}
/**
* This creates a new album metadata structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_destroy_album_t</code>
* operation later, so be careful of using strdup() when assigning
* strings.
*
* @return a pointer to the newly allocated metadata structure.
* @see LIBMTP_destroy_album_t()
*/
LIBMTP_album_t *LIBMTP_new_album_t(void)
{
LIBMTP_album_t *new = (LIBMTP_album_t *) malloc(sizeof(LIBMTP_album_t));
if (new == NULL) {
return NULL;
}
new->album_id = 0;
new->parent_id = 0;
new->storage_id = 0;
new->name = NULL;
new->artist = NULL;
new->composer = NULL;
new->genre = NULL;
new->tracks = NULL;
new->no_tracks = 0;
new->next = NULL;
return new;
}
/**
* This recursively deletes the memory for an album structure
*
* @param album structure to destroy
* @see LIBMTP_new_album_t()
*/
void LIBMTP_destroy_album_t(LIBMTP_album_t *album)
{
if (album == NULL) {
return;
}
if (album->name != NULL)
free(album->name);
if (album->artist != NULL)
free(album->artist);
if (album->composer != NULL)
free(album->composer);
if (album->genre != NULL)
free(album->genre);
if (album->tracks != NULL)
free(album->tracks);
free(album);
return;
}
/**
* This function maps and copies a property onto the album metadata if applicable.
*/
static void pick_property_to_album_metadata(LIBMTP_mtpdevice_t *device,
MTPProperties *prop, LIBMTP_album_t *alb)
{
switch (prop->property) {
case PTP_OPC_Name:
if (prop->propval.str != NULL)
alb->name = strdup(prop->propval.str);
else
alb->name = NULL;
break;
case PTP_OPC_AlbumArtist:
if (prop->propval.str != NULL) {
// This should take precedence over plain "Artist"
if (alb->artist != NULL)
free(alb->artist);
alb->artist = strdup(prop->propval.str);
} else
alb->artist = NULL;
break;
case PTP_OPC_Artist:
if (prop->propval.str != NULL) {
// Only use of AlbumArtist is not set
if (alb->artist == NULL)
alb->artist = strdup(prop->propval.str);
} else
alb->artist = NULL;
break;
case PTP_OPC_Composer:
if (prop->propval.str != NULL)
alb->composer = strdup(prop->propval.str);
else
alb->composer = NULL;
break;
case PTP_OPC_Genre:
if (prop->propval.str != NULL)
alb->genre = strdup(prop->propval.str);
else
alb->genre = NULL;
break;
}
}
/**
* This function retrieves the album metadata for an album
* given by a unique ID.
* @param device a pointer to the device to get the track metadata off.
* @param alb an album metadata metadata set to fill in.
*/
static void get_album_metadata(LIBMTP_mtpdevice_t *device,
LIBMTP_album_t *alb)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
uint32_t i;
MTPProperties *prop;
PTPObject *ob;
/*
* If we have a cached, large set of metadata, then use it!
*/
ret = ptp_object_want(params, alb->album_id, PTPOBJECT_MTPPROPLIST_LOADED, &ob);
if (ob->mtpprops) {
prop = ob->mtpprops;
for (i=0;i<ob->nrofmtpprops;i++,prop++)
pick_property_to_album_metadata(device, prop, alb);
} else {
uint16_t *props = NULL;
uint32_t propcnt = 0;
// First see which properties can be retrieved for albums
ret = ptp_mtp_getobjectpropssupported(params, PTP_OFC_MTP_AbstractAudioAlbum, &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "get_album_metadata(): call to ptp_mtp_getobjectpropssupported() failed.");
// Just bail out for now, nothing is ever set.
return;
} else {
for (i=0;i<propcnt;i++) {
switch (props[i]) {
case PTP_OPC_Name:
alb->name = get_string_from_object(device, ob->oid, PTP_OPC_Name);
break;
case PTP_OPC_AlbumArtist:
if (alb->artist != NULL)
free(alb->artist);
alb->artist = get_string_from_object(device, ob->oid, PTP_OPC_AlbumArtist);
break;
case PTP_OPC_Artist:
if (alb->artist == NULL)
alb->artist = get_string_from_object(device, ob->oid, PTP_OPC_Artist);
break;
case PTP_OPC_Composer:
alb->composer = get_string_from_object(device, ob->oid, PTP_OPC_Composer);
break;
case PTP_OPC_Genre:
alb->genre = get_string_from_object(device, ob->oid, PTP_OPC_Genre);
break;
default:
break;
}
}
free(props);
}
}
}
/**
* This function returns a list of the albums available on the
* device.
*
* @param device a pointer to the device to get the album listing from.
* @return an album list on success, else NULL. If there are no albums
* on the device, NULL will be returned as well.
* @see LIBMTP_Get_Album()
*/
LIBMTP_album_t *LIBMTP_Get_Album_List(LIBMTP_mtpdevice_t *device)
{
// Read all storage devices
return LIBMTP_Get_Album_List_For_Storage(device, 0);
}
/**
* This function returns a list of the albums available on the
* device. You can filter on the storage ID.
*
* @param device a pointer to the device to get the album listing from.
* @param storage_id ID of device storage (if null, all storages)
*
* @return an album list on success, else NULL. If there are no albums
* on the device, NULL will be returned as well.
* @see LIBMTP_Get_Album()
*/
LIBMTP_album_t *LIBMTP_Get_Album_List_For_Storage(LIBMTP_mtpdevice_t *device, uint32_t const storage_id)
{
PTPParams *params = (PTPParams *) device->params;
LIBMTP_album_t *retalbums = NULL;
LIBMTP_album_t *curalbum = NULL;
uint32_t i;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0)
flush_handles(device);
for (i = 0; i < params->nrofobjects; i++) {
LIBMTP_album_t *alb;
PTPObject *ob;
uint16_t ret;
ob = ¶ms->objects[i];
// Ignore stuff that isn't an album
if ( ob->oi.ObjectFormat != PTP_OFC_MTP_AbstractAudioAlbum )
continue;
// Ignore stuff that isn't into the storage device
if ((storage_id != 0) && (ob->oi.StorageID != storage_id ))
continue;
// Allocate a new album type
alb = LIBMTP_new_album_t();
alb->album_id = ob->oid;
alb->parent_id = ob->oi.ParentObject;
alb->storage_id = ob->oi.StorageID;
// Fetch supported metadata
get_album_metadata(device, alb);
// Then get the track listing for this album
ret = ptp_mtp_getobjectreferences(params, alb->album_id, &alb->tracks, &alb->no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Album_List(): Could not get object references.");
alb->tracks = NULL;
alb->no_tracks = 0;
}
// Add album to a list that will be returned afterwards.
if (retalbums == NULL) {
retalbums = alb;
curalbum = alb;
} else {
curalbum->next = alb;
curalbum = alb;
}
}
return retalbums;
}
/**
* This function retrieves an individual album from the device.
* @param device a pointer to the device to get the album from.
* @param albid the unique ID of the album to retrieve.
* @return a valid album metadata or NULL on failure.
* @see LIBMTP_Get_Album_List()
*/
LIBMTP_album_t *LIBMTP_Get_Album(LIBMTP_mtpdevice_t *device, uint32_t const albid)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
PTPObject *ob;
LIBMTP_album_t *alb;
// Get all the handles if we haven't already done that
if (params->nrofobjects == 0)
flush_handles(device);
ret = ptp_object_want(params, albid, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK)
return NULL;
// Ignore stuff that isn't an album
if (ob->oi.ObjectFormat != PTP_OFC_MTP_AbstractAudioAlbum)
return NULL;
// Allocate a new album type
alb = LIBMTP_new_album_t();
alb->album_id = ob->oid;
alb->parent_id = ob->oi.ParentObject;
alb->storage_id = ob->oi.StorageID;
// Fetch supported metadata
get_album_metadata(device, alb);
// Then get the track listing for this album
ret = ptp_mtp_getobjectreferences(params, alb->album_id, &alb->tracks, &alb->no_tracks);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Album: Could not get object references.");
alb->tracks = NULL;
alb->no_tracks = 0;
}
return alb;
}
/**
* This routine creates a new album based on the metadata
* supplied. If the <code>tracks</code> field of the metadata
* contains a track listing, these tracks will be added to the
* album.
* @param device a pointer to the device to create the new album on.
* @param metadata the metadata for the new album. If the function
* exits with success, the <code>album_id</code> field of this
* struct will contain the new ID of the album.
* <ul>
* <li><code>metadata->parent_id</code> should be set to the parent
* (e.g. folder) to store this track in. Since some
* devices are a bit picky about where files
* are placed, a default folder will be chosen if libmtp
* has detected one for the current filetype and this
* parameter is set to 0. If this is 0 and no default folder
* can be found, the file will be stored in the root folder.
* <li><code>metadata->storage_id</code> should be set to the
* desired storage (e.g. memory card or whatever your device
* presents) to store this track in. Setting this to 0 will store
* the track on the primary storage.
* </ul>
* @return 0 on success, any other value means failure.
* @see LIBMTP_Update_Album()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Create_New_Album(LIBMTP_mtpdevice_t *device,
LIBMTP_album_t * const metadata)
{
uint32_t localph = metadata->parent_id;
// Use a default folder if none given
if (localph == 0) {
if (device->default_album_folder != 0)
localph = device->default_album_folder;
else
localph = device->default_music_folder;
}
metadata->parent_id = localph;
// Just create a new abstract album...
return create_new_abstract_list(device,
metadata->name,
metadata->artist,
metadata->composer,
metadata->genre,
localph,
metadata->storage_id,
PTP_OFC_MTP_AbstractAudioAlbum,
".alb",
&metadata->album_id,
metadata->tracks,
metadata->no_tracks);
}
/**
* This creates a new sample data metadata structure and allocates memory
* for it. Notice that if you add strings to this structure they
* will be freed by the corresponding <code>LIBMTP_destroy_sampledata_t</code>
* operation later, so be careful of using strdup() when assigning
* strings.
*
* @return a pointer to the newly allocated metadata structure.
* @see LIBMTP_destroy_sampledata_t()
*/
LIBMTP_filesampledata_t *LIBMTP_new_filesampledata_t(void)
{
LIBMTP_filesampledata_t *new = (LIBMTP_filesampledata_t *) malloc(sizeof(LIBMTP_filesampledata_t));
if (new == NULL) {
return NULL;
}
new->height=0;
new->width = 0;
new->data = NULL;
new->duration = 0;
new->size = 0;
return new;
}
/**
* This destroys a file sample metadata type.
* @param sample the file sample metadata to be destroyed.
*/
void LIBMTP_destroy_filesampledata_t(LIBMTP_filesampledata_t * sample)
{
if (sample == NULL) {
return;
}
if (sample->data != NULL) {
free(sample->data);
}
free(sample);
}
/**
* This routine figures out whether a certain filetype supports
* representative samples (small thumbnail images) or not. This
* typically applies to JPEG files, MP3 files and Album abstract
* playlists, but in theory any filetype could support representative
* samples.
* @param device a pointer to the device which is to be examined.
* @param filetype the fileype to examine, and return the representative sample
* properties for.
* @param sample this will contain a new sample type with the fields
* filled in with suitable default values. For example, the
* supported sample type will be set, the supported height and
* width will be set to max values if it is an image sample,
* and duration will also be given some suitable default value
* which should not be exceeded on audio samples. If the
* device does not support samples for this filetype, this
* pointer will be NULL. If it is not NULL, the user must
* destroy this struct with <code>LIBMTP_destroy_filesampledata_t()</code>
* after use.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Send_Representative_Sample()
* @see LIBMTP_Create_New_Album()
*/
int LIBMTP_Get_Representative_Sample_Format(LIBMTP_mtpdevice_t *device,
LIBMTP_filetype_t const filetype,
LIBMTP_filesampledata_t ** sample)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
uint16_t *props = NULL;
uint32_t propcnt = 0;
int i;
// TODO: Get rid of these when we can properly query the device.
int support_data = 0;
int support_format = 0;
int support_height = 0;
int support_width = 0;
int support_duration = 0;
int support_size = 0;
PTPObjectPropDesc opd_height;
PTPObjectPropDesc opd_width;
PTPObjectPropDesc opd_format;
PTPObjectPropDesc opd_duration;
PTPObjectPropDesc opd_size;
// Default to no type supported.
*sample = NULL;
ret = ptp_mtp_getobjectpropssupported(params, map_libmtp_type_to_ptp_type(filetype), &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Representative_Sample_Format(): could not get object properties.");
return -1;
}
/*
* TODO: when walking through these object properties, make calls to
* a new function in ptp.h/ptp.c that can send the command
* PTP_OC_MTP_GetObjectPropDesc to get max/min values of the properties
* supported.
*/
for (i = 0; i < propcnt; i++) {
switch(props[i]) {
case PTP_OPC_RepresentativeSampleData:
support_data = 1;
break;
case PTP_OPC_RepresentativeSampleFormat:
support_format = 1;
break;
case PTP_OPC_RepresentativeSampleSize:
support_size = 1;
break;
case PTP_OPC_RepresentativeSampleHeight:
support_height = 1;
break;
case PTP_OPC_RepresentativeSampleWidth:
support_width = 1;
break;
case PTP_OPC_RepresentativeSampleDuration:
support_duration = 1;
break;
default:
break;
}
}
free(props);
if (support_data && support_format && support_height && support_width && !support_duration) {
// Something that supports height and width and not duration is likely to be JPEG
LIBMTP_filesampledata_t *retsam = LIBMTP_new_filesampledata_t();
/*
* Populate the sample format with the first supported format
*
* TODO: figure out how to pass back more than one format if more are
* supported by the device.
*/
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleFormat, map_libmtp_type_to_ptp_type(filetype), &opd_format);
retsam->filetype = map_ptp_type_to_libmtp_type(opd_format.FORM.Enum.SupportedValue[0].u16);
ptp_free_objectpropdesc(&opd_format);
/* Populate the maximum image height */
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleWidth, map_libmtp_type_to_ptp_type(filetype), &opd_width);
retsam->width = opd_width.FORM.Range.MaximumValue.u32;
ptp_free_objectpropdesc(&opd_width);
/* Populate the maximum image width */
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleHeight, map_libmtp_type_to_ptp_type(filetype), &opd_height);
retsam->height = opd_height.FORM.Range.MaximumValue.u32;
ptp_free_objectpropdesc(&opd_height);
/* Populate the maximum size */
if (support_size) {
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleSize, map_libmtp_type_to_ptp_type(filetype), &opd_size);
retsam->size = opd_size.FORM.Range.MaximumValue.u32;
ptp_free_objectpropdesc(&opd_size);
}
*sample = retsam;
} else if (support_data && support_format && !support_height && !support_width && support_duration) {
// Another qualified guess
LIBMTP_filesampledata_t *retsam = LIBMTP_new_filesampledata_t();
/*
* Populate the sample format with the first supported format
*
* TODO: figure out how to pass back more than one format if more are
* supported by the device.
*/
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleFormat, map_libmtp_type_to_ptp_type(filetype), &opd_format);
retsam->filetype = map_ptp_type_to_libmtp_type(opd_format.FORM.Enum.SupportedValue[0].u16);
ptp_free_objectpropdesc(&opd_format);
/* Populate the maximum duration */
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleDuration, map_libmtp_type_to_ptp_type(filetype), &opd_duration);
retsam->duration = opd_duration.FORM.Range.MaximumValue.u32;
ptp_free_objectpropdesc(&opd_duration);
/* Populate the maximum size */
if (support_size) {
ptp_mtp_getobjectpropdesc (params, PTP_OPC_RepresentativeSampleSize, map_libmtp_type_to_ptp_type(filetype), &opd_size);
retsam->size = opd_size.FORM.Range.MaximumValue.u32;
ptp_free_objectpropdesc(&opd_size);
}
*sample = retsam;
}
return 0;
}
/**
* This routine sends representative sample data for an object.
* This uses the RepresentativeSampleData property of the album,
* if the device supports it. The data should be of a format acceptable
* to the player (for iRiver and Creative, this seems to be JPEG) and
* must not be too large. (for a Creative, max seems to be about 20KB.)
* Check by calling LIBMTP_Get_Representative_Sample_Format() to get
* maximum size, dimensions, etc..
* @param device a pointer to the device which the object is on.
* @param id unique id of the object to set artwork for.
* @param pointer to LIBMTP_filesampledata_t struct containing data
* @return 0 on success, any other value means failure.
* @see LIBMTP_Get_Representative_Sample()
* @see LIBMTP_Get_Representative_Sample_Format()
* @see LIBMTP_Create_New_Album()
*/
int LIBMTP_Send_Representative_Sample(LIBMTP_mtpdevice_t *device,
uint32_t const id,
LIBMTP_filesampledata_t *sampledata)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
PTPPropertyValue propval;
PTPObject *ob;
uint32_t i;
uint16_t *props = NULL;
uint32_t propcnt = 0;
int supported = 0;
// get the file format for the object we're going to send representative data for
ret = ptp_object_want (params, id, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Send_Representative_Sample(): could not get object info.");
return -1;
}
// check that we can send representative sample data for this object format
ret = ptp_mtp_getobjectpropssupported(params, ob->oi.ObjectFormat, &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Send_Representative_Sample(): could not get object properties.");
return -1;
}
for (i = 0; i < propcnt; i++) {
if (props[i] == PTP_OPC_RepresentativeSampleData) {
supported = 1;
break;
}
}
if (!supported) {
free(props);
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Send_Representative_Sample(): object type doesn't support RepresentativeSampleData.");
return -1;
}
free(props);
// Go ahead and send the data
propval.a.count = sampledata->size;
propval.a.v = malloc(sizeof(PTPPropertyValue) * sampledata->size);
for (i = 0; i < sampledata->size; i++) {
propval.a.v[i].u8 = sampledata->data[i];
}
ret = ptp_mtp_setobjectpropvalue(params,id,PTP_OPC_RepresentativeSampleData,
&propval,PTP_DTC_AUINT8);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Send_Representative_Sample(): could not send sample data.");
free(propval.a.v);
return -1;
}
free(propval.a.v);
/* Set the height and width if the sample is an image, otherwise just
* set the duration and size */
switch(sampledata->filetype) {
case LIBMTP_FILETYPE_JPEG:
case LIBMTP_FILETYPE_JFIF:
case LIBMTP_FILETYPE_TIFF:
case LIBMTP_FILETYPE_BMP:
case LIBMTP_FILETYPE_GIF:
case LIBMTP_FILETYPE_PICT:
case LIBMTP_FILETYPE_PNG:
if (!FLAG_BROKEN_SET_SAMPLE_DIMENSIONS(ptp_usb)) {
// For images, set the height and width
set_object_u32(device, id, PTP_OPC_RepresentativeSampleHeight, sampledata->height);
set_object_u32(device, id, PTP_OPC_RepresentativeSampleWidth, sampledata->width);
}
break;
default:
// For anything not an image, set the duration and size
set_object_u32(device, id, PTP_OPC_RepresentativeSampleDuration, sampledata->duration);
set_object_u32(device, id, PTP_OPC_RepresentativeSampleSize, sampledata->size);
break;
}
return 0;
}
/**
* This routine gets representative sample data for an object.
* This uses the RepresentativeSampleData property of the album,
* if the device supports it.
* @param device a pointer to the device which the object is on.
* @param id unique id of the object to get data for.
* @param pointer to LIBMTP_filesampledata_t struct to receive data
* @return 0 on success, any other value means failure.
* @see LIBMTP_Send_Representative_Sample()
* @see LIBMTP_Get_Representative_Sample_Format()
* @see LIBMTP_Create_New_Album()
*/
int LIBMTP_Get_Representative_Sample(LIBMTP_mtpdevice_t *device,
uint32_t const id,
LIBMTP_filesampledata_t *sampledata)
{
uint16_t ret;
PTPParams *params = (PTPParams *) device->params;
PTPPropertyValue propval;
PTPObject *ob;
uint32_t i;
uint16_t *props = NULL;
uint32_t propcnt = 0;
int supported = 0;
// get the file format for the object we're going to send representative data for
ret = ptp_object_want (params, id, PTPOBJECT_OBJECTINFO_LOADED, &ob);
if (ret != PTP_RC_OK) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_Representative_Sample(): could not get object info.");
return -1;
}
// check that we can store representative sample data for this object format
ret = ptp_mtp_getobjectpropssupported(params, ob->oi.ObjectFormat, &propcnt, &props);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Representative_Sample(): could not get object properties.");
return -1;
}
for (i = 0; i < propcnt; i++) {
if (props[i] == PTP_OPC_RepresentativeSampleData) {
supported = 1;
break;
}
}
if (!supported) {
free(props);
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "LIBMTP_Get_Representative_Sample(): object type doesn't support RepresentativeSampleData.");
return -1;
}
free(props);
// Get the data
ret = ptp_mtp_getobjectpropvalue(params,id,PTP_OPC_RepresentativeSampleData,
&propval,PTP_DTC_AUINT8);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Representative_Sample(): could not get sample data.");
return -1;
}
// Store it
sampledata->size = propval.a.count;
sampledata->data = malloc(sizeof(PTPPropertyValue) * propval.a.count);
for (i = 0; i < propval.a.count; i++) {
sampledata->data[i] = propval.a.v[i].u8;
}
free(propval.a.v);
// Get the other properties
sampledata->width = get_u32_from_object(device, id, PTP_OPC_RepresentativeSampleWidth, 0);
sampledata->height = get_u32_from_object(device, id, PTP_OPC_RepresentativeSampleHeight, 0);
sampledata->duration = get_u32_from_object(device, id, PTP_OPC_RepresentativeSampleDuration, 0);
sampledata->filetype = map_ptp_type_to_libmtp_type(
get_u16_from_object(device, id, PTP_OPC_RepresentativeSampleFormat, LIBMTP_FILETYPE_UNKNOWN));
return 0;
}
/**
* Retrieve the thumbnail for a file.
* @param device a pointer to the device to get the thumbnail from.
* @param id the object ID of the file to retrieve the thumbnail for.
* @return 0 on success, any other value means failure.
*/
int LIBMTP_Get_Thumbnail(LIBMTP_mtpdevice_t *device, uint32_t const id,
unsigned char **data, unsigned int *size)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
ret = ptp_getthumb(params, id, data, size);
if (ret == PTP_RC_OK)
return 0;
return -1;
}
int LIBMTP_GetPartialObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
uint64_t offset, uint32_t maxbytes,
unsigned char **data, unsigned int *size)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params, PTP_OC_ANDROID_GetPartialObject64)) {
if (!ptp_operation_issupported(params, PTP_OC_GetPartialObject)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_GetPartialObject: PTP_OC_GetPartialObject not supported");
return -1;
}
if (offset >> 32 != 0) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_GetPartialObject: PTP_OC_GetPartialObject only supports 32bit offsets");
return -1;
}
ret = ptp_getpartialobject(params, id, (uint32_t)offset, maxbytes, data, size);
} else {
ret = ptp_android_getpartialobject64(params, id, offset, maxbytes, data, size);
}
if (ret == PTP_RC_OK)
return 0;
return -1;
}
int LIBMTP_SendPartialObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
uint64_t offset, unsigned char *data, unsigned int size)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params, PTP_OC_ANDROID_SendPartialObject)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_SendPartialObject: PTP_OC_ANDROID_SendPartialObject not supported");
return -1;
}
ret = ptp_android_sendpartialobject(params, id, offset, data, size);
if (ret == PTP_RC_OK)
return 0;
return -1;
}
int LIBMTP_BeginEditObject(LIBMTP_mtpdevice_t *device, uint32_t const id)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params, PTP_OC_ANDROID_BeginEditObject)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_BeginEditObject: PTP_OC_ANDROID_BeginEditObject not supported");
return -1;
}
ret = ptp_android_begineditobject(params, id);
if (ret == PTP_RC_OK)
return 0;
return -1;
}
int LIBMTP_EndEditObject(LIBMTP_mtpdevice_t *device, uint32_t const id)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params, PTP_OC_ANDROID_EndEditObject)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_EndEditObject: PTP_OC_ANDROID_EndEditObject not supported");
return -1;
}
ret = ptp_android_endeditobject(params, id);
if (ret == PTP_RC_OK) {
// update cached object properties if metadata cache exists
update_metadata_cache(device, id);
return 0;
}
return -1;
}
int LIBMTP_TruncateObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
uint64_t offset)
{
PTPParams *params = (PTPParams *) device->params;
uint16_t ret;
if (!ptp_operation_issupported(params, PTP_OC_ANDROID_TruncateObject)) {
add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
"LIBMTP_TruncateObject: PTP_OC_ANDROID_TruncateObject not supported");
return -1;
}
ret = ptp_android_truncate(params, id, offset);
if (ret == PTP_RC_OK)
return 0;
return -1;
}
/**
* This routine updates an album based on the metadata
* supplied. If the <code>tracks</code> field of the metadata
* contains a track listing, these tracks will be added to the
* album in place of those already present, i.e. the
* previous track listing will be deleted.
* @param device a pointer to the device to create the new album on.
* @param metadata the metadata for the album to be updated.
* notice that the field <code>album_id</code>
* must contain the apropriate album ID.
* @return 0 on success, any other value means failure.
* @see LIBMTP_Create_New_Album()
* @see LIBMTP_Delete_Object()
*/
int LIBMTP_Update_Album(LIBMTP_mtpdevice_t *device,
LIBMTP_album_t const * const metadata)
{
return update_abstract_list(device,
metadata->name,
metadata->artist,
metadata->composer,
metadata->genre,
metadata->album_id,
PTP_OFC_MTP_AbstractAudioAlbum,
metadata->tracks,
metadata->no_tracks);
}
/**
* Dummy function needed to interface to upstream
* ptp.c/ptp.h files.
*/
void ptp_nikon_getptpipguid (unsigned char* guid) {
return;
}
/**
* Add an object to cache.
* @param device the device which may have a cache to which the object should be added.
* @param object_id the object to add to the cache.
*/
static void add_object_to_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id)
{
PTPParams *params = (PTPParams *)device->params;
uint16_t ret;
ret = ptp_add_object_to_cache(params, object_id);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "add_object_to_cache(): couldn't add object to cache");
}
}
/**
* Update cache after object has been modified
* @param device the device which may have a cache to which the object should be updated.
* @param object_id the object to update.
*/
static void update_metadata_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id)
{
PTPParams *params = (PTPParams *)device->params;
ptp_remove_object_from_cache(params, object_id);
add_object_to_cache(device, object_id);
}
/**
* Issue custom (e.g. vendor specific) operation (without data phase)
* @param device a pointer to the device to send custom operation to.
* @param code operation code to send.
* @param n_param number of parameters passed.
* @param ... uint32_t operation specific parameters.
*/
int LIBMTP_Custom_Operation(LIBMTP_mtpdevice_t *device, uint16_t code, int n_param, ...)
{
PTPParams *params = (PTPParams *) device->params;
PTPContainer ptp;
va_list args;
uint16_t ret;
int i;
ptp.Code = code;
ptp.Nparam = n_param;
va_start(args, n_param);
for (i = 0; i < n_param; i++)
(&ptp.Param1)[i] = va_arg(args, uint32_t);
va_end(args);
ret = ptp_transaction_new(params, &ptp, PTP_DP_NODATA, 0, NULL);
if (ret != PTP_RC_OK) {
add_ptp_error_to_errorstack(device, ret, "LIBMTP_Custom_Operation(): failed to execute operation.");
return -1;
}
return 0;
}