git.sesse.net Git - vlc/blob - include/vlc_media_library.h

   1 /*****************************************************************************
   2  * vlc_media_library.h: SQL-based media library
   3  *****************************************************************************
   4  * Copyright (C) 2008-2010 the VideoLAN Team and AUTHORS
   5  * $Id$
   6  *
   7  * Authors: Antoine Lejeune <phytos@videolan.org>
   8  *          Jean-Philippe André <jpeg@videolan.org>
   9  *          Rémi Duraffort <ivoire@videolan.org>
  10  *          Adrien Maglo <magsoft@videolan.org>
  11  *          Srikanth Raju <srikiraju at gmail dot com>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 #ifndef VLC_MEDIA_LIBRARY_H
  29 # define VLC_MEDIA_LIBRARY_H
  30
  31 # ifdef __cplusplus
  32 extern "C" {
  33 # endif
  34
  35 #include <vlc_common.h>
  36 #include <vlc_playlist.h>
  37
  38 /*****************************************************************************
  39  * ML Enums
  40  *****************************************************************************/
  41
  42 #define ML_PERSON_ARTIST        "Artist"
  43 #define ML_PERSON_ALBUM_ARTIST  "Album Artist"
  44 #define ML_PERSON_ENCODER       "Encoder"
  45 #define ML_PERSON_PUBLISHER     "Publisher"
  46
  47
  48 #define ml_priv( gc, t ) ((t *)(((char *)(gc)) - offsetof(t, ml_gc_data)))
  49
  50 /** List of Query select types.
  51  * In a query array or variable argument list, each select type is followed
  52  * by an argument (X) of variable type (char* or int, @see ml_element_t).
  53  * These types can be used either in the query list or in the result array.
  54  * Some types are reserved for the result array:
  55  */
  56 typedef enum
  57 {
  58     ML_ALBUM = 1,              /**< Album Title */
  59     ML_ALBUM_ID,               /**< Album ID */
  60     ML_ALBUM_COVER,            /**< Album Cover art url */
  61     /* FIXME: Remove ML_ARTIST */
  62     ML_ARTIST,                 /**< Artist, interpreted as ML_PEOPLE
  63                                     && ML_PEOPLE_ROLE = ML_PERSON_ARTIST */
  64     ML_ARTIST_ID,              /**< Artist ID, interpreted as ML_PEOPLE_ID
  65                                     && ML_PEOPLE_ROLE = ML_PERSON_ARTIST */
  66     ML_COMMENT,                /**< Comment about media */
  67     ML_COUNT_MEDIA,            /**< Number of medias */
  68     ML_COUNT_ALBUM,            /**< Number of albums */
  69     ML_COUNT_PEOPLE,           /**< Number of people */
  70     ML_COVER,                  /**< Cover art url */
  71     ML_DURATION,               /**< Duration in ms */
  72     ML_DISC_NUMBER,            /**< Disc number of the track */
  73     ML_EXTRA,                  /**< Extra/comment (string) on the media */
  74     ML_FIRST_PLAYED,           /**< First time media was played */
  75     ML_FILESIZE,               /**< Size of the media file */
  76     ML_GENRE,                  /**< Genre of the media (if any) */
  77     ML_ID,                     /**< Media ID */
  78     ML_IMPORT_TIME,            /**< Date when media was imported */
  79     ML_LANGUAGE,               /**< Language */
  80     ML_LAST_PLAYED,            /**< Last play UNIX timestamp */
  81     ML_LAST_SKIPPED,           /**< Time when media was last skipped */
  82     ML_ORIGINAL_TITLE,         /**< Media original title (if any) */
  83     ML_PEOPLE,                 /**< Any People associated with this media */
  84     ML_PEOPLE_ID,              /**< Id of a person */
  85     ML_PEOPLE_ROLE,            /**< Person role */
  86     ML_PLAYED_COUNT,           /**< Media play count */
  87     ML_PREVIEW,                /**< Url of the video preview */
  88     ML_SKIPPED_COUNT,          /**< Number of times skipped */
  89     ML_SCORE,                  /**< Computed media score */
  90     ML_TITLE,                  /**< Media title */
  91     ML_TRACK_NUMBER,           /**< Media track number (if any) */
  92     ML_TYPE,                   /**< Media type. @see ml_type_e */
  93     ML_URI,                    /**< Media full URI. */
  94     ML_VOTE,                   /**< Media user vote value */
  95     ML_YEAR,                   /**< Media publishing year */
  96     ML_DIRECTORY,              /**< Monitored directory */
  97     ML_MEDIA,                  /**< Full media descriptor. @see ml_media_t */
  98     ML_MEDIA_SPARSE,           /**< Sparse media. @see ml_media_t */
  99     ML_MEDIA_EXTRA,            /**< Sparse + Extra = Full media */
 100
 101     /* Some special elements */
 102     ML_LIMIT     = -1,         /**< Limit a query to X results */
 103     ML_SORT_DESC = -2,         /**< Sort a query descending on argument X */
 104     ML_SORT_ASC  = -3,         /**< Sort a query ascending on argument X */
 105     ML_DISTINCT  = -4,         /**< Add DISTINCT to SELECT statements. */
 106     ML_END       = -42         /**< End of argument list */
 107 } ml_select_e;
 108
 109 /** Media types (audio, video, etc...) */
 110 typedef enum
 111 {
 112     ML_UNKNOWN   = 0,       /**< Unknown media type */
 113     ML_AUDIO     = 1 << 0,  /**< Audio only media */
 114     ML_VIDEO     = 1 << 1,  /**< Video media. May contain audio channels */
 115     ML_STREAM    = 1 << 2,  /**< Streamed media = not a local file */
 116     ML_NODE      = 1 << 3,  /**< Nodes like simple nodes, directories, playlists, etc */
 117     ML_REMOVABLE = 1 << 4,  /**< Removable media: CD/DVD/Card/... */
 118 } ml_type_e;
 119
 120 /** Query result item/list type: integers, strings, medias, timestamps */
 121 typedef enum {
 122     ML_TYPE_INT,        /**< Object is an int */
 123     ML_TYPE_PSZ,        /**< A string char* */
 124     ML_TYPE_TIME,       /**< A timestamp mtime_t */
 125     ML_TYPE_MEDIA,      /**< A pointer to a media ml_media_t* */
 126 } ml_result_type_e;
 127
 128 /** Arguments for VLC Control for the media library */
 129 typedef enum
 130 {
 131     ML_SET_DATABASE,      /**< arg1 = char *psz_host
 132                                arg2 = int i_port
 133                                arg3 = char *psz_user
 134                                arg4 = char *psz_pass */
 135     ML_INIT_DATABASE,     /**< No arg */
 136     ML_ADD_INPUT_ITEM,    /**< arg1 = input_item_t* */
 137     ML_ADD_PLAYLIST_ITEM, /**< arg1 = playlist_item_t * */
 138     ML_ADD_MONITORED,     /**< arg1 = char* */
 139     ML_DEL_MONITORED,     /**< arg1 = char* */
 140     ML_GET_MONITORED,     /**< arg1 = vlc_array_t* */
 141 } ml_control_e;
 142
 143 /* Operations that can be specified between find conditions */
 144 typedef enum
 145 {
 146     ML_OP_NONE = 0,       /**< This is to specify an actual condition */
 147     ML_OP_AND,            /**< AND condition */
 148     ML_OP_OR,             /**< OR condition */
 149     ML_OP_NOT,            /**< NOT condition */
 150     ML_OP_SPECIAL         /**< This is for inclusion of
 151                             *  special stuffs like LIMIT */
 152 } ml_op_e;
 153
 154 /* Comparison operators used in a single find condition */
 155 typedef enum
 156 {
 157     ML_COMP_NONE = 0,
 158     ML_COMP_LESSER,              ///< <
 159     ML_COMP_LESSER_OR_EQUAL,     ///< <=
 160     ML_COMP_EQUAL,               ///< ==
 161     ML_COMP_GREATER_OR_EQUAL,    ///< >=
 162     ML_COMP_GREATER,             ///< >
 163     ML_COMP_HAS,                 ///< "Contains", equivalent to SQL "LIKE %x%"
 164     ML_COMP_STARTS_WITH,         ///< Equivalent to SQL "LIKE %x"
 165     ML_COMP_ENDS_WITH,           ///< Equivalent to SQL "LIKE x%"
 166 } ml_comp_e;
 167
 168 /*****************************************************************************
 169  * ML Structures and types
 170  *****************************************************************************/
 171
 172 typedef struct media_library_t media_library_t;
 173 typedef struct media_library_sys_t media_library_sys_t;
 174
 175 typedef struct ml_media_t      ml_media_t;
 176 typedef struct ml_result_t     ml_result_t;
 177 typedef struct ml_element_t    ml_element_t;
 178 typedef struct ml_person_t     ml_person_t;
 179 typedef struct ml_ftree_t      ml_ftree_t;
 180
 181
 182 typedef struct ml_gc_object_t
 183 {
 184     vlc_spinlock_t spin;
 185     bool           pool;
 186     uintptr_t      refs;
 187     void          (*pf_destructor) (struct ml_gc_object_t *);
 188 } ml_gc_object_t;
 189
 190 #define ML_GC_MEMBERS ml_gc_object_t ml_gc_data;
 191
 192 /** Main structure of the media library. VLC object. */
 193 struct media_library_t
 194 {
 195     VLC_COMMON_MEMBERS
 196
 197     module_t             *p_module;  /**< the media library module */
 198     media_library_sys_t  *p_sys;     /**< internal struture */
 199
 200     /** Member functions */
 201     struct
 202     {
 203         /**< Search in the database */
 204         int ( * pf_Find )            ( media_library_t *p_media_library,
 205                                        vlc_array_t *p_result_array,
 206                                        va_list args );
 207
 208         /**< Search in the database using an array of arguments */
 209         int ( * pf_FindAdv )         ( media_library_t *p_media_library,
 210                                        vlc_array_t *p_result_array,
 211                                        ml_select_e selected_type,
 212                                        const char *psz_lvalue,
 213                                        ml_ftree_t *tree );
 214
 215         /**< Update the database using an array of arguments */
 216         int ( * pf_Update )          ( media_library_t *p_media_library,
 217                                        ml_select_e selected_type,
 218                                        const char *psz_lvalue,
 219                                        ml_ftree_t *where,
 220                                        vlc_array_t *changes );
 221
 222         /**< Delete many medias in the database */
 223         int ( * pf_Delete )    ( media_library_t *p_media_library,
 224                                        vlc_array_t *p_array );
 225
 226         /**< Control the media library */
 227         int ( * pf_Control ) ( media_library_t *p_media_library,
 228                                int i_query, va_list args );
 229
 230         /**< Create associated input item */
 231         input_item_t* ( * pf_InputItemFromMedia ) (
 232                     media_library_t *p_media_library, int i_media );
 233
 234         /**< Get a media */
 235         ml_media_t* ( * pf_GetMedia ) (
 236                     media_library_t *p_media_library, int i_media,
 237                     ml_select_e select, bool reload );
 238     } functions;
 239 };
 240
 241
 242 /**
 243  * @brief Structure to describe a media
 244  *
 245  * This is the main structure holding the meta data in ML.
 246  * @see b_sparse indicates whether the media struct has valid values
 247  * in its Extra fields. Otherwise, it must be loaded with the API
 248  * function.
 249  * @see i_id indicates whether this struct is saved in the ML if i_id > 0
 250  * Otherwise, it can be added to the database
 251  */
 252 struct ml_media_t
 253 {
 254     ML_GC_MEMBERS
 255     vlc_mutex_t     lock;               /**< Mutex for multithreaded access */
 256     bool            b_sparse;           /**< Specifies if media is loaded fully */
 257     ml_type_e       i_type;             /**< Type of the media (ml_type_e) */
 258     int8_t          i_vote;             /**< User vote */
 259     int16_t         i_disc_number;      /**< Disc number of media */
 260     int16_t         i_track_number;     /**< Track number */
 261     int16_t         i_year;             /**< Year of release */
 262     int32_t         i_id;               /**< Media ID in the database */
 263     int32_t         i_score;            /**< Score computed about the media */
 264     int32_t         i_album_id;         /**< Album id */
 265     int32_t         i_played_count;     /**< How many time the media was played */
 266     int32_t         i_skipped_count;    /**< No. of times file was skipped */
 267     int32_t         i_bitrate;          /**< Extra: Bitrate of the media */
 268     int32_t         i_samplerate;       /**< Extra: Samplerate of the media */
 269     int32_t         i_bpm;              /**< Extra: Beats per minute */
 270     char            *psz_uri;           /**< URI to find the media */
 271     char            *psz_title;         /**< Title of the media */
 272     char            *psz_orig_title;    /**< Original title (mainly for movies) */
 273     char            *psz_album;         /**< Name of the album */
 274     char            *psz_cover;         /**< URI of the cover */
 275     char            *psz_genre;         /**< Genre of the media */
 276     char            *psz_preview;       /**< Preview thumbnail for video, if any */
 277     char            *psz_comment;       /**< Comment or description about media */
 278     char            *psz_language;      /**< Extra: Language */
 279     char            *psz_extra;         /**< Extra: Some extra datas like lyrics */
 280     ml_person_t     *p_people;          /**< Extra: People associated with this
 281                                              media This meta holds only one
 282                                              artist if b_sparse = true */
 283     int64_t         i_filesize;         /**< Size of the file */
 284     mtime_t         i_duration;         /**< Duration in microseconds */
 285     mtime_t         i_last_played;      /**< Time when the media was last played */
 286     mtime_t         i_last_skipped;     /**< Time when the media was last skipped */
 287     mtime_t         i_first_played;     /**< First played */
 288     mtime_t         i_import_time;      /**< Time when media was added */
 289
 290 };
 291
 292
 293 /**
 294  * @brief Main communication struct between GUI and sql_media_library.
 295  * Generic representation of an ML/SQL query result.
 296  */
 297 struct ml_result_t
 298 {
 299     int32_t          id;        /**< Media/Album/Artist... ID (if any) */
 300     ml_result_type_e type;      /**< Type of value */
 301     union
 302     {
 303         /* Classical results */
 304         int             i;
 305         char           *psz;
 306         mtime_t         time;
 307
 308         /* Complex result: media descriptor */
 309         ml_media_t     *p_media;
 310     } value;                    /**< Value of the result obtained */
 311 };
 312
 313
 314 /**
 315  * @brief Element of a query: criteria type/value pair
 316  * Used for update and delete queries
 317  */
 318 struct ml_element_t
 319 {
 320     ml_select_e    criteria;    /**< SELECT criteria type. @see ml_select_e */
 321     union
 322     {
 323         int     i;
 324         char*   str;
 325     } value;                    /**< SELECT criteria value (string or int) */
 326     union
 327     {
 328         int     i;
 329         char*   str;
 330     } lvalue;                   /**< Refer to @see ml_ftree_t lvalue docs */
 331 };
 332
 333 /**
 334  * Binary tree used to parse the WHERE condition for a search
 335  *
 336  * Let [expr] indicate a valid expression
 337  * [expr] = [expr] AND [expr], where the left and right are respective
 338  * [expr] = [expr] OR [expr]
 339  * [expr] = [expr] NOT [NULL]
 340  * [expr] = [expr] SPEC [spec_expr]
 341  * [expr] = [criteria=val]
 342  * [spec_expr] = [DISTINCT/LIMIT/ASC/DESC = val ]
 343  */
 344 struct ml_ftree_t
 345 {
 346     ml_op_e         op;         /**< Operator. ML_OP_NONE means this is a leaf
 347                                   *  node. Criteria and value gives its data.
 348                                   *  ML_OP_SPECIAL specifies a special node
 349                                   *  that does not form a part of the WHERE.
 350                                   *  The right node consists of the data
 351                                   *  with its criteria set to the special val
 352                                   *  and the left node is the corresponding
 353                                   *  subtree of the parent node.
 354                                   *  ML_OP_NOT only left sub tree is considered
 355                                   *  ML_OP_AND and ML_OP_OR consider both
 356                                   *  left and right subtrees */
 357     ml_ftree_t      *left;      /**< Left child of Bin tree */
 358     ml_ftree_t      *right;     /**< Right child of Bin tree */
 359     ml_select_e     criteria;   /**< SELECT criteria type @see ml_select_e
 360                                   *  The criteria value is considered only when
 361                                   *  op = ML_OP_NONE i.e. in leaf nodes */
 362     ml_comp_e       comp;       /**< Condition between type and value */
 363     union
 364     {
 365         int     i;
 366         char    *str;
 367     } value;                    /**< SELECT criteria value ( string or int ) */
 368     union
 369     {
 370         int     i;
 371         char    *str;
 372     } lvalue;                   /**< Used as key value for people types/roles.
 373                                      An empty string "" denotes ANY person role.
 374                                      NULL is used for all other criterias */
 375 };
 376
 377
 378 /**
 379  * Person class. Implemented as a linked list
 380  */
 381 struct ml_person_t
 382 {
 383     char               *psz_role;   /**< Type of person */
 384     char               *psz_name;   /**< Name of the person */
 385     int                 i_id;       /**< ID in the database */
 386     ml_person_t        *p_next;     /**< Next person in list */
 387 };
 388
 389
 390 /*****************************************************************************
 391  * ML Function headers
 392  *****************************************************************************/
 393
 394 /**
 395  * @brief Acquire a reference to the media library singleton
 396  * @param p_this The object holding the media library
 397  * @return The media library object. NULL if the media library
 398  * object could not be loaded
 399  */
 400 VLC_EXPORT( media_library_t*, ml_Hold, ( vlc_object_t* p_this ) );
 401 #define ml_Hold( a ) ml_Hold( VLC_OBJECT(a) )
 402
 403 /**
 404  * @brief Discard your ref to media library
 405  * @param p_this The object holding the media library
 406  */
 407 VLC_EXPORT( void, ml_Release, ( vlc_object_t* p_this ) );
 408 #define ml_Release(a) ml_Release( VLC_OBJECT(a) )
 409
 410 /**
 411  * @brief Create a Media Library VLC object.
 412  * @param p_this Parent to attach the ML object to.
 413  * @param psz_name Name for the module
 414  * @return The ML object.
 415  */
 416 VLC_EXPORT( media_library_t*, ml_Create, ( vlc_object_t *p_this, char* psz_name ) );
 417
 418 /**
 419  * @brief Destructor for the Media library singleton
 420  * @param p_this Parent the ML object is attached to
 421  */
 422 VLC_EXPORT( void, ml_Destroy, ( vlc_object_t* p_this ) );
 423
 424 /**
 425  * @brief Control the Media Library
 426  * @param p_media_library the media library object
 427  * @param i_type one of ml_control_e values @see ml_control_e.
 428  * @param ... optional arguments.
 429  * @return VLC_SUCCESS or an error
 430  */
 431 static inline int ml_ControlVa( media_library_t *p_media_library,
 432                                 ml_control_e i_type, va_list args )
 433 {
 434     return p_media_library->functions.pf_Control( p_media_library,
 435                                                   i_type,
 436                                                   args );
 437 }
 438
 439 /**
 440  * @brief Control the Media Library
 441  * @param i_type one of ml_control_e values @see ml_control_e.
 442  * Variable arguments list equivalent
 443  */
 444 #define ml_Control( a, b, args... )     __ml_Control( a, b, ## args )
 445 static inline int __ml_Control( media_library_t *p_media_library,
 446                                 ml_control_e i_type, ... )
 447 {
 448     va_list args;
 449     int returned;
 450
 451     va_start( args, i_type );
 452     returned = ml_ControlVa( p_media_library, i_type, args );
 453     va_end( args );
 454
 455     return returned;
 456 }
 457
 458 /**
 459  * @brief Determine an attribute's type (int or string)
 460  * @param meta Attribute to test @see ml_select_e
 461  * @return -1 if invalid, 0 if this is an integer, 1 if this is a string
 462  */
 463 static inline int ml_AttributeIsString( ml_select_e meta )
 464 {
 465     switch( meta )
 466     {
 467     /* Strings */
 468     case ML_ALBUM:
 469     case ML_ARTIST:
 470     case ML_COMMENT:
 471     case ML_COVER:
 472     case ML_EXTRA:
 473     case ML_GENRE:
 474     case ML_LANGUAGE:
 475     case ML_PREVIEW:
 476     case ML_PEOPLE:
 477     case ML_PEOPLE_ROLE:
 478     case ML_ORIGINAL_TITLE:
 479     case ML_TITLE:
 480     case ML_URI:
 481         return 1;
 482
 483     /* Integers */
 484     case ML_ALBUM_ID:
 485     case ML_ARTIST_ID:
 486     case ML_DURATION:
 487     case ML_DISC_NUMBER:
 488     case ML_COUNT_MEDIA:
 489     case ML_COUNT_ALBUM:
 490     case ML_COUNT_PEOPLE:
 491     case ML_FILESIZE:
 492     case ML_FIRST_PLAYED:
 493     case ML_ID:
 494     case ML_IMPORT_TIME:
 495     case ML_LAST_PLAYED:
 496     case ML_LIMIT:
 497     case ML_PLAYED_COUNT:
 498     case ML_PEOPLE_ID:
 499     case ML_SCORE:
 500     case ML_SKIPPED_COUNT:
 501     case ML_TRACK_NUMBER:
 502     case ML_TYPE:
 503     case ML_VOTE:
 504     case ML_YEAR:
 505         return 0;
 506
 507     /* Invalid or no following value (in a SELECT statement) */
 508     default:
 509         return -1;
 510     }
 511 }
 512
 513 /* Reference Counting Functions */
 514 /**
 515  * @brief Increment reference count of media
 516  * @param p_media The media object
 517  */
 518 static inline void ml_gc_incref( ml_media_t* p_media )
 519 {
 520     unsigned refs;
 521     ml_gc_object_t* p_gc = &p_media->ml_gc_data;
 522     if( p_gc == NULL )
 523         return;
 524
 525     vlc_spin_lock (&p_gc->spin);
 526     refs = ++p_gc->refs;
 527     vlc_spin_unlock (&p_gc->spin);
 528 }
 529
 530 /**
 531  * @brief Decrease reference count of media
 532  * @param p_media The media object
 533  */
 534 static inline void ml_gc_decref( ml_media_t* p_media )
 535 {
 536     /* The below code is from vlc_release(). */
 537     unsigned refs;
 538     bool pool;
 539     ml_gc_object_t* p_gc = &p_media->ml_gc_data;
 540     if( p_gc == NULL )
 541         return;
 542
 543     vlc_spin_lock (&p_gc->spin);
 544     refs = --p_gc->refs;
 545     pool = p_gc->pool;
 546     vlc_spin_unlock (&p_gc->spin);
 547
 548     if( refs == 0 && pool == false )
 549     {
 550         vlc_spin_destroy (&p_gc->spin);
 551         p_gc->pf_destructor (p_gc);
 552     }
 553 }
 554
 555 /*****************************************************************************
 556  * ML Free Functions
 557  *****************************************************************************/
 558
 559 /**
 560  * @brief Free a person object
 561  * @param p_media Person object to free
 562  * @note This function is NOT threadsafe
 563  */
 564 static inline void ml_FreePeople( ml_person_t *p_person )
 565 {
 566     if( p_person == NULL )
 567         return;
 568     ml_FreePeople( p_person->p_next );
 569     free( p_person->psz_name );
 570     free( p_person->psz_role );
 571     free( p_person );
 572 }
 573
 574 /**
 575  * @brief Free only the content of a media. @see ml_media_t
 576  * @param p_media Media object
 577  * @note This function is NOT threadsafe.
 578  */
 579 static inline void ml_FreeMediaContent( ml_media_t *p_media )
 580 {
 581     free( p_media->psz_uri );
 582     free( p_media->psz_title );
 583     free( p_media->psz_orig_title );
 584     free( p_media->psz_cover );
 585     free( p_media->psz_comment );
 586     free( p_media->psz_extra );
 587     free( p_media->psz_genre );
 588     free( p_media->psz_album );
 589     free( p_media->psz_preview );
 590     free( p_media->psz_language );
 591     ml_FreePeople( p_media->p_people );
 592     p_media->b_sparse = true;
 593     p_media->i_id = 0;
 594     p_media->i_type = ML_UNKNOWN;
 595     p_media->i_album_id = 0;
 596     p_media->i_disc_number = 0;
 597     p_media->i_track_number = 0;
 598     p_media->i_year = 0;
 599     p_media->i_vote = 0;
 600     p_media->i_score = 0;
 601     p_media->i_filesize = 0;
 602     p_media->i_duration = 0;
 603     p_media->i_played_count = 0;
 604     p_media->i_last_played = 0;
 605     p_media->i_skipped_count = 0;
 606     p_media->i_last_skipped = 0;
 607     p_media->i_first_played = 0;
 608     p_media->i_import_time = 0;
 609     p_media->i_bitrate = 0;
 610     p_media->i_samplerate = 0;
 611     p_media->i_bpm = 0;
 612 }
 613
 614 /**
 615  * @brief Free a result item. @see ml_result_t
 616  * @param p_result Result item to free
 617  * @note This will free any strings and decref medias.
 618  */
 619 static inline void ml_FreeResult( ml_result_t *p_result )
 620 {
 621     if( p_result )
 622     {
 623         switch( p_result->type )
 624         {
 625             case ML_TYPE_PSZ:
 626                 free( p_result->value.psz );
 627                 break;
 628             case ML_TYPE_MEDIA:
 629                 ml_gc_decref( p_result->value.p_media );
 630                 break;
 631             default:
 632                 break;
 633         }
 634         free( p_result );
 635     }
 636 }
 637
 638
 639 /**
 640  * @brief Free a ml_element_t item.
 641  * @param p_find Find object to free
 642  * @see ml_element_t */
 643 static inline void ml_FreeElement( ml_element_t *p_elt )
 644 {
 645     if( p_elt )
 646     {
 647         if( ml_AttributeIsString( p_elt->criteria ) )
 648         {
 649             free( p_elt->value.str );
 650         }
 651         if( p_elt->criteria == ML_PEOPLE )
 652         {
 653             free( p_elt->lvalue.str );
 654         }
 655         free( p_elt );
 656     }
 657 }
 658
 659
 660 /**
 661  * @brief Destroy a vlc_array_t of ml_result_t
 662  * @param ml_result_array The result array to free
 663  * @note Frees all results and contents of the results
 664  */
 665 static inline void ml_DestroyResultArray( vlc_array_t *p_result_array )
 666 {
 667     for( int i = 0; i < vlc_array_count( p_result_array ); i++ )
 668     {
 669         ml_FreeResult( ( ml_result_t* ) vlc_array_item_at_index(
 670                 p_result_array, i ) );
 671     }
 672 }
 673
 674
 675
 676 /*****************************************************************************
 677  * ML Object Management Functions
 678  *****************************************************************************/
 679
 680 /** Helpers for locking and unlocking */
 681 #define ml_LockMedia( a )      vlc_mutex_lock( &a->lock )
 682 #define ml_UnlockMedia( a )    vlc_mutex_unlock( &a->lock )
 683
 684 /**
 685  * @brief Object constructor for ml_media_t
 686  * @param p_ml The media library object
 687  * @param id If 0, this item isn't in database. If non zero, it is and
 688  * it will be a singleton
 689  * @param select Type of object
 690  * @param reload Whether to reload from database
 691  */
 692 VLC_EXPORT( ml_media_t*, media_New, ( media_library_t* p_ml, int id,
 693         ml_select_e select, bool reload ) );
 694
 695
 696 /* Forward declaration */
 697 static inline int ml_CopyPersons( ml_person_t** a, ml_person_t* b );
 698
 699 /**
 700  * @brief Copy all members of a ml_media_t to another.
 701  * @param b Destination media, already allocated
 702  * @param a Source media, cannot be NULL, const
 703  * @note This does not check memory allocation (for strdup). It is threadsafe
 704  * @todo Free b content, before inserting a?
 705  */
 706 static inline int ml_CopyMedia( ml_media_t *b, ml_media_t *a )
 707 {
 708     if( !a || !b ) return VLC_EGENERIC;
 709     if( a == b ) return VLC_SUCCESS;
 710     ml_LockMedia( a );
 711     ml_LockMedia( b );
 712     b->b_sparse = a->b_sparse;
 713     b->i_id = a->i_id;
 714     b->i_type = a->i_type;
 715     b->i_album_id = a->i_album_id;
 716     b->i_disc_number = a->i_disc_number;
 717     b->i_track_number = a->i_track_number;
 718     b->i_year = a->i_year;
 719     b->i_vote = a->i_vote;
 720     b->i_score = a->i_score;
 721     b->i_filesize = a->i_filesize;
 722     b->i_duration = a->i_duration;
 723     b->i_played_count = a->i_played_count;
 724     b->i_last_played = a->i_last_played;
 725     b->i_skipped_count = a->i_skipped_count;
 726     b->i_last_skipped = a->i_last_skipped;
 727     b->i_first_played = a->i_first_played;
 728     b->i_import_time = a->i_import_time;
 729     b->i_bitrate = a->i_bitrate;
 730     b->i_samplerate = a->i_samplerate;
 731     b->i_bpm = a->i_bpm;
 732     free( b->psz_uri );
 733     if( a->psz_uri )
 734         b->psz_uri = strdup( a->psz_uri );
 735     free( b->psz_title );
 736     if( a->psz_title )
 737         b->psz_title = strdup( a->psz_title );
 738     free( b->psz_orig_title );
 739     if( a->psz_orig_title )
 740         b->psz_orig_title = strdup( a->psz_orig_title );
 741     free( b->psz_album );
 742     if( a->psz_album )
 743         b->psz_album = strdup( a->psz_album );
 744     free( b->psz_cover );
 745     if( a->psz_cover )
 746         b->psz_cover = strdup( a->psz_cover );
 747     free( b->psz_genre );
 748     if( a->psz_genre )
 749         b->psz_genre = strdup( a->psz_genre );
 750     free( b->psz_comment );
 751     if( a->psz_comment )
 752         b->psz_comment = strdup( a->psz_comment );
 753     free( b->psz_extra );
 754     if( a->psz_extra )
 755         b->psz_extra = strdup( a->psz_extra );
 756     free( b->psz_preview );
 757     if( a->psz_preview )
 758         b->psz_preview = strdup( a->psz_preview );
 759     free( b->psz_language );
 760     if( a->psz_language )
 761         b->psz_language = strdup( a->psz_language );
 762     ml_FreePeople( b->p_people );
 763     if( a->p_people )        ml_CopyPersons( &( b->p_people ), a->p_people );
 764     ml_UnlockMedia( b );
 765     ml_UnlockMedia( a );
 766     return VLC_SUCCESS;
 767 }
 768
 769 /*****************************************************************************
 770  * ML Find Tree Related Functions
 771  *****************************************************************************/
 772 #define ml_FreeFindTree( tree )          ml_GenericFreeFindTree( tree, true )
 773 #define ml_ShallowFreeFindTree( tree )   ml_GenericFreeFindTree( tree, false )
 774 /**
 775  * @brief Free a find tree
 776  * @param Find tree to free
 777  * @param true to free any associated strings, false to not free them
 778  */
 779 static inline void ml_GenericFreeFindTree( ml_ftree_t* tree, bool freestrings )
 780 {
 781     if( tree == NULL )
 782         return;
 783     if( tree->left )
 784     {
 785         ml_GenericFreeFindTree( tree->left, freestrings );
 786         free( tree->left );
 787     }
 788     if( tree->right )
 789     {
 790         ml_GenericFreeFindTree( tree->right, freestrings );
 791         free( tree->right );
 792     }
 793     if( tree->op == ML_OP_NONE && ml_AttributeIsString( tree->criteria )
 794             && freestrings == true)
 795     {
 796         free( tree->value.str );
 797         if( tree->criteria == ML_PEOPLE )
 798             free( tree->lvalue.str );
 799     }
 800 }
 801
 802 /**
 803  * @brief Checks if a given find tree has leaf nodes
 804  * @param Find tree
 805  * @return Number of leaf nodes
 806  */
 807 static inline int ml_FtreeHasOp( ml_ftree_t* tree )
 808 {
 809     if( tree == NULL )
 810         return 0;
 811     if( tree->criteria > 0 && tree->op == ML_OP_NONE )
 812         return 1;
 813     else
 814         return ml_FtreeHasOp( tree->left ) + ml_FtreeHasOp( tree->right );
 815 }
 816
 817
 818 /**
 819  * @brief Connect up a find tree
 820  * @param op operator to connect with
 821  * If op = ML_OP_NONE, then you are connecting to a tree consisting of
 822  * only SPECIAL nodes.
 823  * If op = ML_OP_NOT, then right MUST be NULL
 824  * op must not be ML_OP_SPECIAL, @see ml_FtreeSpec
 825  * @param left part of the tree
 826  * @param right part of the tree
 827  * @return Pointer to new tree
 828  * @note Use the helpers!
 829  */
 830 VLC_EXPORT( ml_ftree_t*, ml_OpConnectChilds, ( ml_op_e op, ml_ftree_t* left,
 831         ml_ftree_t* right ) );
 832
 833 /**
 834  * @brief Attaches a special node to a tree
 835  * @param tree Tree to attach special node to
 836  * @param crit Criteria may be SORT_ASC, SORT_DESC, LIMIT or DISTINCT
 837  * @param limit Limit used if LIMIT criteria used
 838  * @param Sort string used if SORT criteria is used
 839  * @return Pointer to new tree
 840  * @note Use the helpers
 841  */
 842 VLC_EXPORT( ml_ftree_t*, ml_FtreeSpec, ( ml_ftree_t* tree,
 843                                           ml_select_e crit,
 844                                           int limit,
 845                                           char* sort ) );
 846
 847 /**
 848  * @brief This function gives quick sequential adding capability
 849  * @param left Tree to add to. This may be NULL
 850  * @param right Tree to append. May not be NULL
 851  * @return Pointer to new tree.*/
 852 static inline ml_ftree_t* ml_FtreeFastAnd( ml_ftree_t* left,
 853                                            ml_ftree_t* right )
 854 {
 855     if( ml_FtreeHasOp( left ) == 0 )
 856     {
 857         return ml_OpConnectChilds( ML_OP_NONE, left, right );
 858     }
 859     else
 860     {
 861         return ml_OpConnectChilds( ML_OP_AND, left, right );
 862     }
 863 }
 864 #define ml_FtreeAnd( left, right ) ml_OpConnectChilds( ML_OP_AND, left, right )
 865 #define ml_FtreeOr( left, right )  ml_OpConnectChilds( ML_OP_OR, left, right )
 866 #define ml_FtreeNot( left )        ml_OpConnectChilds( ML_OP_NOT, left, NULL )
 867
 868 #define ml_FtreeSpecAsc( tree, str )        ml_FtreeSpec( tree, ML_SORT_ASC, 0, str )
 869 #define ml_FtreeSpecDesc( tree, str )       ml_FtreeSpec( tree, ML_SORT_DESC, 0, str )
 870 #define ml_FtreeSpecLimit( tree, limit )    ml_FtreeSpec( tree, ML_LIMIT, limit, NULL )
 871 #define ml_FtreeSpecDistinct( tree )        ml_FtreeSpec( tree, ML_DISTINCT, 0, NULL )
 872
 873
 874 /*****************************************************************************
 875  * ML Core Functions
 876  *****************************************************************************/
 877
 878 /**
 879  * @brief Create input item from media
 880  * @param p_media_library This ML instance.
 881  * @param i_media_id ID of the media to use to create an input_item.
 882  * @return The media item.
 883  */
 884 static inline input_item_t* ml_CreateInputItem(
 885         media_library_t *p_media_library, int i_media_id )
 886 {
 887     return p_media_library->functions.pf_InputItemFromMedia( p_media_library,
 888                                                              i_media_id );
 889 }
 890
 891 /**
 892  * @brief Search in the database according some criterias
 893  *
 894  * @param p_media_library the media library object
 895  * @param result a pointer to a result array
 896  * @param ... parameters to select the data
 897  * @return VLC_SUCCESS or an error
 898  */
 899 static inline int __ml_Find( media_library_t *p_media_library,
 900                              vlc_array_t *p_result_array, ... )
 901 {
 902     va_list args;
 903     int returned;
 904
 905     va_start( args, p_result_array );
 906     returned = p_media_library->functions.pf_Find( p_media_library,
 907                                                    p_result_array, args );
 908     va_end( args );
 909
 910     return returned;
 911 }
 912
 913
 914 /**
 915  * @brief Search in the database according some criterias (threaded)
 916  * @param p_media_library the media library object
 917  * @param result_array a pointer to a result array
 918  * @param result_type type of data to retrieve
 919  * @param psz_lvalue This should contain any necessary lvalue/key
 920  * for the given result_type. Used for ML_PEOPLE. Otherwise NULL
 921  * @param args parameters to select the data
 922  * @return VLC_SUCCESS or an error
 923  */
 924 static inline int ml_FindAdv( media_library_t *p_media_library,
 925                               vlc_array_t *p_result_array,
 926                               ml_select_e result_type,
 927                               char* psz_lvalue,
 928                               ml_ftree_t *tree )
 929 {
 930     return p_media_library->functions.pf_FindAdv( p_media_library,
 931                                                   p_result_array,
 932                                                   result_type,
 933                                                   psz_lvalue,
 934                                                   tree );
 935 }
 936
 937
 938 /**
 939  * @brief Find a value in the ML database, fill p_result with it.
 940  * @param p_media_library Media library object
 941  * @param p_result Object to put result into
 942  * @param Args [ SelectType [ PersonType ] Value ] ... ML_END
 943  * @note Do not use this function directly.
 944  */
 945 static inline int __ml_GetValue( media_library_t *p_media_library,
 946                                   ml_result_t *p_result,
 947                                   va_list args )
 948 {
 949     vlc_array_t *p_result_array = vlc_array_new();
 950     int i_ret = p_media_library->functions.pf_Find( p_media_library,
 951                                                     p_result_array,
 952                                                     args );
 953     if( i_ret != VLC_SUCCESS )
 954         goto exit;
 955     if( vlc_array_count( p_result_array ) > 0 )
 956         memcpy( p_result,
 957                 ( ml_result_t* ) vlc_array_item_at_index( p_result_array, 0 ),
 958                 sizeof( ml_result_t) );
 959     else
 960         i_ret = VLC_EGENERIC;
 961
 962 exit:
 963     /* Note: Do not free the results, because of memcpy */
 964     vlc_array_destroy( p_result_array );
 965     return i_ret;
 966 }
 967
 968 /**
 969  * @brief Search an INTEGER in the database
 970  * This uses a Query but returns only one integer (>0), or an error code.
 971  *
 972  * @param p_media_library the media library object
 973  * @param va_args parameters to select the data
 974  * @return Found INTEGER >= 0 or an error
 975  */
 976 #define ml_GetInt( ml, ... ) __ml_GetInt( ml, __VA_ARGS__, ML_LIMIT, 1, ML_END )
 977 static inline int __ml_GetInt( media_library_t *p_media_library, ... )
 978 {
 979     va_list args;
 980     va_start( args, p_media_library );
 981     ml_result_t result;
 982     int i_ret = __ml_GetValue( p_media_library, &result, args );
 983     va_end( args );
 984     if( i_ret != VLC_SUCCESS )
 985         return i_ret;
 986     else
 987         return result.value.i;
 988 }
 989
 990
 991 /**
 992  * @brief Search a string (VARCHAR) in the database
 993  * This uses a Query but returns only one integer (>0), or an error code.
 994  *
 995  * @param p_media_library the media library object
 996  * @param va_args parameters to select the data
 997  * @return Found string, or NULL if not found or in case of error
 998  */
 999 #define ml_FindPsz( ml, ... ) __ml_GetPsz( ml, __VA_ARGS__, ML_LIMIT, 1, ML_END )
1000 static inline char* __ml_GetPsz( media_library_t *p_media_library, ... )
1001 {
1002     va_list args;
1003     va_start( args, p_media_library );
1004     ml_result_t result;
1005     int i_ret = __ml_GetValue( p_media_library, &result, args );
1006     va_end( args );
1007     if( i_ret != VLC_SUCCESS )
1008         return NULL;
1009     else
1010         return result.value.psz; // no need to duplicate
1011 }
1012
1013 /**
1014  * @brief Generic update in Media Library database
1015  *
1016  * @param p_media_library the media library object
1017  * @param selected_type the type of the element we're selecting
1018  * @param where list of ids/uris to be changed
1019  * @param changes list of changes to make in the entries
1020  * @return VLC_SUCCESS or VLC_EGENERIC
1021  */
1022 static inline int ml_Update( media_library_t *p_media_library,
1023                              ml_select_e selected_type,
1024                              const char* psz_lvalue,
1025                              ml_ftree_t *where,
1026                              vlc_array_t *changes )
1027 {
1028     return p_media_library->functions.pf_Update( p_media_library,
1029                                                  selected_type, psz_lvalue,
1030                                                  where, changes );
1031 }
1032
1033 /**
1034  * @brief Update a given table
1035  * @param p_media_library The media library object
1036  * @param selected_type The table to update
1037  * @param psz_lvalue The role of the person if selected_type = ML_PEOPLE
1038  * @param id The id of the row to update
1039  * @param ... The update data. [SelectType [RoleType] Value]
1040  */
1041 VLC_EXPORT( int, ml_UpdateSimple, ( media_library_t *p_media_library,
1042                                      ml_select_e selected_type,
1043                                      const char* psz_lvalue,
1044                                      int id, ... ) );
1045 #define ml_UpdateSimple( ml, sel, lval, id, ... ) \
1046         ml_UpdateSimple( ml, sel, lval, id, __VA_ARGS__, ML_END )
1047
1048 /**
1049  * @brief Generic DELETE function
1050  * Delete a media and all its references which don't point
1051  * to anything else.
1052  *
1053  * @param p_media_library This media_library_t object
1054  * @param id the id of the media to delete
1055  * @return VLC_SUCCESS or VLC_EGENERIC
1056  */
1057 static inline int
1058 ml_DeleteSimple( media_library_t *p_media_library, int id )
1059 {
1060     vlc_array_t* p_where = vlc_array_new();
1061     ml_element_t* p_find = (ml_element_t *) calloc( 1, sizeof( ml_element_t ) );
1062     p_find->criteria = ML_ID;
1063     p_find->value.i = id;
1064     vlc_array_append( p_where, p_find );
1065     int i_return =  p_media_library->functions.pf_Delete( p_media_library,
1066             p_where );
1067     free( p_find );
1068     vlc_array_destroy( p_where );
1069     return i_return;
1070 }
1071
1072 /**
1073  * @brief Delete many medias in the media library
1074  * @param p_media_library Media library object
1075  * @param p_array Array of ids to delete
1076  * @return VLC_SUCCESS or VLC_EGENERIC
1077  */
1078 static inline int
1079 ml_Delete( media_library_t *p_media_library, vlc_array_t* p_array )
1080 {
1081     return p_media_library->functions.pf_Delete( p_media_library,
1082                                                         p_array );
1083 }
1084
1085
1086 /*****************************************************************************
1087  * ML Person Related Functions
1088  *****************************************************************************/
1089
1090 /**
1091  * @brief Create and append a person object to the given list
1092  * @param pp_person pointer to person list. Set the address to null to create new list
1093  * @param i_role The role of the person
1094  * @param psz_name The name string. Will be strdup'd
1095  * @param i_id The id in the database
1096  * @note This function is NOT thread safe. Please lock any associated media
1097  */
1098 static inline int ml_CreateAppendPersonAdv( ml_person_t **pp_person,
1099         const char* psz_role, const char* psz_name, int i_id )
1100 {
1101     if( i_id == 0 || !( psz_name && *psz_name && psz_role && *psz_role ) )
1102         return VLC_SUCCESS;
1103     if( !pp_person )
1104         return VLC_EGENERIC;
1105     if( *pp_person != NULL )
1106         return ml_CreateAppendPersonAdv( &((**pp_person).p_next),
1107                                          psz_role, psz_name, i_id);
1108     *pp_person = ( ml_person_t * ) calloc( 1, sizeof( ml_person_t ) );
1109     (*pp_person)->psz_name = (psz_name && *psz_name) ? strdup( psz_name ): NULL;
1110     (*pp_person)->psz_role = (psz_role && *psz_role) ? strdup( psz_role ): NULL;
1111     (*pp_person)->i_id = i_id;
1112     (*pp_person)->p_next = NULL;
1113     return VLC_SUCCESS;
1114 }
1115
1116 /**
1117  * @brief Create and append a person object to the given list
1118  * @param pp_person pointer to person list.
1119  * Set the address to NULL to create a new list
1120  * @param personfrom Person object to copy from
1121  * @note Ignores the next variable and copies only the variables.
1122  * Uses ml_CreateAppendPersonAdv
1123  * @note This function is NOT threadsafe
1124  */
1125 static inline int ml_CreateAppendPerson( ml_person_t **pp_person,
1126                                          ml_person_t *p_personfrom )
1127 {
1128     return ml_CreateAppendPersonAdv( pp_person,
1129                                      p_personfrom->psz_role,
1130                                      p_personfrom->psz_name,
1131                                      p_personfrom->i_id );
1132 }
1133
1134 /**
1135  * @brief Copy one person list into another
1136  * @param a To list
1137  * @param b From list
1138  * @note On errors, you have to free any allocated persons yourself
1139  * @note This function is NOT threadsafe. Please ensure your medias are locked
1140  */
1141 static inline int ml_CopyPersons( ml_person_t** a, ml_person_t* b )
1142 {
1143     int i_ret;
1144     while( b )
1145     {
1146         i_ret = ml_CreateAppendPerson( a, b );
1147         if( i_ret != VLC_SUCCESS )
1148             return i_ret;
1149         b = b->p_next;
1150     }
1151     return VLC_SUCCESS;
1152 }
1153
1154
1155 /**
1156  * @brief Returns a person list of given type
1157  * @param p_ml The ML object
1158  * @param p_media The Media object
1159  * @param i_type The person type
1160  * @note This function is thread safe
1161  */
1162 VLC_EXPORT( ml_person_t*, ml_GetPersonsFromMedia, ( media_library_t* p_ml,
1163                                                     ml_media_t* p_media,
1164                                                     const char *psz_role ) );
1165
1166
1167 #define ml_GetAlbumArtistsFromMedia( a, b ) ml_GetPersonsFromMedia( a, b, ML_PERSON_ALBUM_ARTIST );
1168 #define ml_GetArtistsFromMedia( a, b )      ml_GetPersonsFromMedia( a, b, ML_PERSON_ARTIST );
1169 #define ml_GetEncodersFromMedia( a, b )     ml_GetPersonsFromMedia( a, b, ML_PERSON_ENCODER );
1170 #define ml_GetPublishersFromMedia( a, b )   ml_GetPersonsFromMedia( a, b, ML_PERSON_PUBLISHER );
1171
1172 /**
1173  * @brief Delete a certain type of people from a media
1174  * @param p_media Media to delete from
1175  * @param i_type Type of person to delete
1176  * @note This function is threadsafe
1177  */
1178 VLC_EXPORT( void, ml_DeletePersonTypeFromMedia, ( ml_media_t* p_media,
1179                                                  const char *psz_role ) );
1180
1181
1182 /**
1183  * @brief Creates and adds the playlist based on a given find tree
1184  * @param p_ml Media library object
1185  * @param p_tree Find tree to create SELECT
1186  */
1187
1188 VLC_EXPORT( void, ml_PlaySmartPlaylistBasedOn, ( media_library_t* p_ml,
1189                                                 ml_ftree_t* p_tree ) );
1190
1191
1192 /**
1193  * Convenience Macros
1194  */
1195
1196 /**
1197  * Get information using the *media* ID. This returns only 1 information.
1198  * @note You have to free the string returned (if that's a string!).
1199  */
1200 #define ml_GetAlbumById( a, id )            ml_GetPsz( a, ML_ALBUM, ML_ID, id )
1201 #define ml_GetArtistById( a, id )           ml_GetPsz( a, ML_PEOPLE, ML_PERSON_ARTIST, ML_ID, id )
1202 #define ml_GetCoverUriById( a, id )         ml_GetPsz( a, ML_COVER, ML_ID, id )
1203 #define ml_GetEncoderById( a, id )          ml_GetPsz( a, ML_PEOPLE, ML_PERSON_ENCODER, ML_ID, id )
1204 #define ml_GetExtraById( a, id )            ml_GetPsz( a, ML_EXTRA, ML_ID, id )
1205 #define ml_GetGenreById( a, id )            ml_GetPsz( a, ML_GENRE, ML_ID, id )
1206 #define ml_GetOriginalTitleById( a, id )    ml_GetPsz( a, ML_ORIGINAL_TITLE, ML_ID, id )
1207 #define ml_GetPublisherById( a, id )        ml_GetPsz( a, ML_PEOPLE, ML_PERSON_PUBLISHER, ML_ID, id )
1208 #define ml_GetTitleById( a, id )            ml_GetPsz( a, ML_TITLE, ML_ID, id )
1209 #define ml_GetUriById( a, id )              ml_GetPsz( a, ML_URI, ML_ID, id )
1210
1211 #define ml_GetAlbumIdById( a, id )          ml_GetInt( a, ML_ALBUM_ID, ML_ID, id )
1212 #define ml_GetArtistIdById( a, id )         ml_GetInt( a, ML_PEOPLE_ID, ML_PERSON_ARTIST, ML_ID, id )
1213 #define ml_GetDurationById( a, id )         ml_GetInt( a, ML_DURATION, ML_ID, id )
1214 #define ml_GetEncoderIdById( a, id )        ml_GetInt( a, ML_PEOPLE_ID, ML_PERSON_ENCODER, ML_ID, id )
1215 #define ml_GetLastPlayedById( a, id )       ml_GetInt( a, ML_LAST_PLAYED, ML_ID, id )
1216 #define ml_GetPlayedCountById( a, id )      ml_GetInt( a, ML_PLAYED_COUNT, ML_ID, id )
1217 #define ml_GetPublisherIdById( a, id )      ml_GetInt( a, ML_PEOPLE_ID, ML_PERSON_PUBLISHER, ML_ID, id )
1218 #define ml_GetScoreById( a, id )            ml_GetInt( a, ML_SCORE, ML_ID, id )
1219 #define ml_GetTrackNumberById( a, id )      ml_GetInt( a, ML_TRACK_NUMBER, ML_ID, id )
1220 #define ml_GetTypeById( a, id )             ml_GetInt( a, ML_TYPE, ML_ID, id )
1221 #define ml_GetYearById( a, id )             ml_GetInt( a, ML_YEAR, ML_ID, id )
1222 #define ml_GetVoteById( a, id )             ml_GetInt( a, ML_VOTE, ML_ID, id )
1223
1224 /** Albums handling */
1225 #define ml_GetAlbumId( a, b )               ml_GetInt( a, ML_ALBUM_ID, ML_ALBUM, b )
1226
1227 /** People handling */
1228 #define ml_GetArtistId( a, b )              ml_GetInt( a, ML_PERSON_ID, ML_PERSON_ARTIST, ML_PERSON, ML_PERSON_ARTIST, b )
1229 #define ml_GetEncoderId( a, b )             ml_GetInt( a, ML_PERSON_ID, ML_PERSON_ENCODER, ML_PERSON, ML_PERSON_ENCODER, b )
1230 #define ml_GetPublisherId( a, b )           ml_GetInt( a, ML_PERSON_ID, ML_PERSON_PUBLISHER, ML_PERSON, ML_PERSON_PUBLISHER, b )
1231
1232 /** Counts handling */
1233 #define ml_GetMediaCount( a, ... )          __ml_GetInt( a, ML_COUNT_MEDIA,      __VA_ARGS__, ML_END )
1234 #define ml_GetAlbumCount( a, ... )          __ml_GetInt( a, ML_COUNT_ALBUM,      __VA_ARGS__, ML_END )
1235 #define ml_GetPeopleCount( a, ... )         __ml_GetInt( a, ML_COUNT_PEOPLE,     __VA_ARGS__, ML_END )
1236
1237 #define ml_Find( a, b, ... )                __ml_Find( a, b, __VA_ARGS__, ML_END )
1238
1239 #define ml_FindAlbum( a, b, ... )           __ml_Find( a, b, ML_ALBUM,           __VA_ARGS__, ML_END )
1240 #define ml_FindArtist( a, b, ... )          __ml_Find( a, b, ML_PERSON, ML_PERSON_ARTIST, __VA_ARGS__, ML_END )
1241 #define ml_FindEncoder( a, b, ... )         __ml_Find( a, b, ML_PERSON, ML_PERSON_ENCODER, __VA_ARGS__, ML_END )
1242 #define ml_FindGenre( a, b, ... )           __ml_Find( a, b, ML_GENRE,           __VA_ARGS__, ML_END )
1243 #define ml_FindMedia( a, b, ... )           __ml_Find( a, b, ML_MEDIA,           __VA_ARGS__, ML_END )
1244 #define ml_FindOriginalTitle( a, b, ... )   __ml_Find( a, b, ML_ORIGINAL_TITLE,  __VA_ARGS__, ML_END )
1245 #define ml_FindPublisher( a, b, ... )       __ml_Find( a, b, ML_PERSON, ML_PERSON_PUBLISHER, __VA_ARGS__, ML_END )
1246 #define ml_FindTitle( a, b, ... )           __ml_Find( a, b, ML_TITLE,           __VA_ARGS__, ML_END )
1247 #define ml_FindType( a, b, ... )            __ml_Find( a, b, ML_TYPE,            __VA_ARGS__, ML_END )
1248 #define ml_FindUri( a, b, ... )             __ml_Find( a, b, ML_URI,             __VA_ARGS__, ML_END )
1249 #define ml_FindYear( a, b, ... )            __ml_Find( a, b, ML_YEAR,            __VA_ARGS__, ML_END )
1250
1251 #define ml_FindAllAlbums( a, b )            ml_FindAlbum( a, b,         ML_DISTINCT )
1252 #define ml_FindAllArtists( a, b )           ml_FindArtist( a, b,        ML_DISTINCT )
1253 #define ml_FindAllGenres( a, b )            ml_FindGenre( a, b,         ML_DISTINCT )
1254 #define ml_FindAllMedias( a, b )            ml_FindMedia( a, b,         ML_DISTINCT )
1255 #define ml_FindAllOriginalTitles( a, b )    ml_FindOriginalTitle( a, b, ML_DISTINCT )
1256 #define ml_FindAllPublishers( a, b, ... )   ml_FindPublisher( a, b,     ML_DISTINCT )
1257 #define ml_FindAllTitles( a, b )            ml_FindTitle( a, b,         ML_DISTINCT )
1258 #define ml_FindAllTypes( a, b )             ml_FindType( a, b,          ML_DISTINCT )
1259 #define ml_FindAllUris( a, b )              ml_FindUri( a, b,           ML_DISTINCT )
1260 #define ml_FindAllYears( a, b )             ml_FindYear( a, b,          ML_DISTINCT )
1261
1262 #define ml_FindAlbumAdv( a, b, c )          ml_FindAdv( a, b, ML_ALBUM,         NULL, c )
1263 #define ml_FindArtistAdv( a, b, c )         ml_FindAdv( a, b, ML_PERSON,        ML_PERSON_ARTIST, c )
1264 #define ml_FindEncoderAdv( a, b, c )        ml_FindAdv( a, b, ML_PERSON,        ML_PERSON_ENCODER, c )
1265 #define ml_FindGenreAdv( a, b, c )          ml_FindAdv( a, b, ML_GENRE,         NULL, c )
1266 #define ml_FindMediaAdv( a, b, c )          ml_FindAdv( a, b, ML_MEDIA,         NULL, c )
1267 #define ml_FindOriginalTitleAdv( a, b, c )  ml_FindAdv( a, b, ML_ORIGINAL_TITLE,NULL, c )
1268 #define ml_FindPublisherAdv( a, b, c )      ml_FindAdv( a, b, ML_PUBLISHER,     ML_PERSON_PUBLISHER, c )
1269 #define ml_FindTitleAdv( a, b, c )          ml_FindAdv( a, b, ML_TITLE,         NULL, c )
1270 #define ml_FindTypeAdv( a, b, c )           ml_FindAdv( a, b, ML_TYPE,          NULL, c )
1271 #define ml_FindUriAdv( a, b, c )            ml_FindAdv( a, b, ML_URI,           NULL, c )
1272 #define ml_FindYearAdv( a, b, c )           ml_FindAdv( a, b, ML_YEAR,          NULL, c )
1273
1274
1275
1276 #ifdef __cplusplus
1277 }
1278 #endif /* C++ */
1279
1280 #endif /* VLC_MEDIA_LIBRARY_H */