git.sesse.net Git - vlc/blob - src/control/media.c

   1 /*****************************************************************************
   2  * media.c: Libvlc API media descripor management
   3  *****************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Pierre d'Herbemont <pdherbemont@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <vlc/libvlc.h>
  29 #include <vlc/libvlc_media.h>
  30 #include <vlc/libvlc_media_list.h> // For the subitems, here for convenience
  31 #include <vlc/libvlc_events.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_input.h>
  35 #include <vlc_meta.h>
  36 #include <vlc_playlist.h> /* For the preparser */
  37
  38 #include "libvlc.h"
  39
  40 #include "libvlc_internal.h"
  41 #include "media_internal.h"
  42
  43 static const vlc_meta_type_t libvlc_to_vlc_meta[] =
  44 {
  45     [libvlc_meta_Title]        = vlc_meta_Title,
  46     [libvlc_meta_Artist]       = vlc_meta_Artist,
  47     [libvlc_meta_Genre]        = vlc_meta_Genre,
  48     [libvlc_meta_Copyright]    = vlc_meta_Copyright,
  49     [libvlc_meta_Album]        = vlc_meta_Album,
  50     [libvlc_meta_TrackNumber]  = vlc_meta_TrackNumber,
  51     [libvlc_meta_Description]  = vlc_meta_Description,
  52     [libvlc_meta_Rating]       = vlc_meta_Rating,
  53     [libvlc_meta_Date]         = vlc_meta_Date,
  54     [libvlc_meta_Setting]      = vlc_meta_Setting,
  55     [libvlc_meta_URL]          = vlc_meta_URL,
  56     [libvlc_meta_Language]     = vlc_meta_Language,
  57     [libvlc_meta_NowPlaying]   = vlc_meta_NowPlaying,
  58     [libvlc_meta_Publisher]    = vlc_meta_Publisher,
  59     [libvlc_meta_EncodedBy]    = vlc_meta_EncodedBy,
  60     [libvlc_meta_ArtworkURL]   = vlc_meta_ArtworkURL,
  61     [libvlc_meta_TrackID]      = vlc_meta_TrackID
  62 };
  63
  64 static const libvlc_meta_t vlc_to_libvlc_meta[] =
  65 {
  66     [vlc_meta_Title]        = libvlc_meta_Title,
  67     [vlc_meta_Artist]       = libvlc_meta_Artist,
  68     [vlc_meta_Genre]        = libvlc_meta_Genre,
  69     [vlc_meta_Copyright]    = libvlc_meta_Copyright,
  70     [vlc_meta_Album]        = libvlc_meta_Album,
  71     [vlc_meta_TrackNumber]  = libvlc_meta_TrackNumber,
  72     [vlc_meta_Description]  = libvlc_meta_Description,
  73     [vlc_meta_Rating]       = libvlc_meta_Rating,
  74     [vlc_meta_Date]         = libvlc_meta_Date,
  75     [vlc_meta_Setting]      = libvlc_meta_Setting,
  76     [vlc_meta_URL]          = libvlc_meta_URL,
  77     [vlc_meta_Language]     = libvlc_meta_Language,
  78     [vlc_meta_NowPlaying]   = libvlc_meta_NowPlaying,
  79     [vlc_meta_Publisher]    = libvlc_meta_Publisher,
  80     [vlc_meta_EncodedBy]    = libvlc_meta_EncodedBy,
  81     [vlc_meta_ArtworkURL]   = libvlc_meta_ArtworkURL,
  82     [vlc_meta_TrackID]      = libvlc_meta_TrackID
  83 };
  84
  85 /**************************************************************************
  86  * input_item_subitem_added (Private) (vlc event Callback)
  87  **************************************************************************/
  88 static void input_item_subitem_added( const vlc_event_t *p_event,
  89                                        void * user_data )
  90 {
  91     libvlc_media_t * p_md = user_data;
  92     libvlc_media_t * p_md_child;
  93     libvlc_event_t event;
  94
  95     p_md_child = libvlc_media_new_from_input_item(
  96                 p_md->p_libvlc_instance,
  97                 p_event->u.input_item_subitem_added.p_new_child, NULL );
  98
  99     /* Add this to our media list */
 100     if( !p_md->p_subitems )
 101     {
 102         p_md->p_subitems = libvlc_media_list_new( p_md->p_libvlc_instance, NULL );
 103         libvlc_media_list_set_media( p_md->p_subitems, p_md, NULL );
 104     }
 105     if( p_md->p_subitems )
 106     {
 107         libvlc_media_list_add_media( p_md->p_subitems, p_md_child, NULL );
 108     }
 109
 110     /* Construct the event */
 111     event.type = libvlc_MediaSubItemAdded;
 112     event.u.media_subitem_added.new_child = p_md_child;
 113
 114     /* Send the event */
 115     libvlc_event_send( p_md->p_event_manager, &event );
 116     libvlc_media_release( p_md_child );
 117 }
 118
 119 /**************************************************************************
 120  * input_item_meta_changed (Private) (vlc event Callback)
 121  **************************************************************************/
 122 static void input_item_meta_changed( const vlc_event_t *p_event,
 123                                      void * user_data )
 124 {
 125     libvlc_media_t * p_md = user_data;
 126     libvlc_event_t event;
 127
 128     /* Construct the event */
 129     event.type = libvlc_MediaMetaChanged;
 130     event.u.media_meta_changed.meta_type =
 131         vlc_to_libvlc_meta[p_event->u.input_item_meta_changed.meta_type];
 132
 133     /* Send the event */
 134     libvlc_event_send( p_md->p_event_manager, &event );
 135 }
 136
 137 /**************************************************************************
 138  * input_item_duration_changed (Private) (vlc event Callback)
 139  **************************************************************************/
 140 static void input_item_duration_changed( const vlc_event_t *p_event,
 141                                          void * user_data )
 142 {
 143     libvlc_media_t * p_md = user_data;
 144     libvlc_event_t event;
 145
 146     /* Construct the event */
 147     event.type = libvlc_MediaDurationChanged;
 148     event.u.media_duration_changed.new_duration =
 149         p_event->u.input_item_duration_changed.new_duration;
 150
 151     /* Send the event */
 152     libvlc_event_send( p_md->p_event_manager, &event );
 153 }
 154
 155 /**************************************************************************
 156  * input_item_preparsed_changed (Private) (vlc event Callback)
 157  **************************************************************************/
 158 static void input_item_preparsed_changed( const vlc_event_t *p_event,
 159                                           void * user_data )
 160 {
 161     libvlc_media_t * p_md = user_data;
 162     libvlc_event_t event;
 163
 164     /* Construct the event */
 165     event.type = libvlc_MediaPreparsedChanged;
 166     event.u.media_preparsed_changed.new_status =
 167         p_event->u.input_item_preparsed_changed.new_status;
 168
 169     /* Send the event */
 170     libvlc_event_send( p_md->p_event_manager, &event );
 171 }
 172
 173 /**************************************************************************
 174  * Install event handler (Private)
 175  **************************************************************************/
 176 static void install_input_item_observer( libvlc_media_t *p_md )
 177 {
 178     vlc_event_attach( &p_md->p_input_item->event_manager,
 179                       vlc_InputItemSubItemAdded,
 180                       input_item_subitem_added,
 181                       p_md );
 182     vlc_event_attach( &p_md->p_input_item->event_manager,
 183                       vlc_InputItemMetaChanged,
 184                       input_item_meta_changed,
 185                       p_md );
 186     vlc_event_attach( &p_md->p_input_item->event_manager,
 187                       vlc_InputItemDurationChanged,
 188                       input_item_duration_changed,
 189                       p_md );
 190     vlc_event_attach( &p_md->p_input_item->event_manager,
 191                       vlc_InputItemPreparsedChanged,
 192                       input_item_preparsed_changed,
 193                       p_md );
 194 }
 195
 196 /**************************************************************************
 197  * Uninstall event handler (Private)
 198  **************************************************************************/
 199 static void uninstall_input_item_observer( libvlc_media_t *p_md )
 200 {
 201     vlc_event_detach( &p_md->p_input_item->event_manager,
 202                       vlc_InputItemSubItemAdded,
 203                       input_item_subitem_added,
 204                       p_md );
 205     vlc_event_detach( &p_md->p_input_item->event_manager,
 206                       vlc_InputItemMetaChanged,
 207                       input_item_meta_changed,
 208                       p_md );
 209     vlc_event_detach( &p_md->p_input_item->event_manager,
 210                       vlc_InputItemDurationChanged,
 211                       input_item_duration_changed,
 212                       p_md );
 213     vlc_event_detach( &p_md->p_input_item->event_manager,
 214                       vlc_InputItemPreparsedChanged,
 215                       input_item_preparsed_changed,
 216                       p_md );
 217 }
 218
 219 /**************************************************************************
 220  * Preparse if not already done (Private)
 221  **************************************************************************/
 222 static void preparse_if_needed( libvlc_media_t *p_md )
 223 {
 224     /* XXX: need some locking here */
 225     if (!p_md->b_preparsed)
 226     {
 227         playlist_PreparseEnqueue(
 228                 libvlc_priv (p_md->p_libvlc_instance->p_libvlc_int)->p_playlist,
 229                 p_md->p_input_item, pl_Unlocked );
 230         p_md->b_preparsed = true;
 231     }
 232 }
 233
 234 /**************************************************************************
 235  * Create a new media descriptor object from an input_item
 236  * (libvlc internal)
 237  * That's the generic constructor
 238  **************************************************************************/
 239 libvlc_media_t * libvlc_media_new_from_input_item(
 240                                    libvlc_instance_t *p_instance,
 241                                    input_item_t *p_input_item,
 242                                    libvlc_exception_t *p_e )
 243 {
 244     libvlc_media_t * p_md;
 245
 246     if (!p_input_item)
 247     {
 248         libvlc_exception_raise( p_e );
 249         libvlc_printerr( "No input item given" );
 250         return NULL;
 251     }
 252
 253     p_md = malloc( sizeof(libvlc_media_t) );
 254     if( !p_md )
 255     {
 256         libvlc_exception_raise( p_e );
 257         libvlc_printerr( "Not enough memory" );
 258         return NULL;
 259     }
 260
 261     p_md->p_libvlc_instance = p_instance;
 262     p_md->p_input_item      = p_input_item;
 263     p_md->b_preparsed       = false;
 264     p_md->i_refcount        = 1;
 265     p_md->p_user_data       = NULL;
 266
 267     p_md->state = libvlc_NothingSpecial;
 268
 269     /* A media descriptor can be a playlist. When you open a playlist
 270      * It can give a bunch of item to read. */
 271     p_md->p_subitems        = NULL;
 272
 273     p_md->p_event_manager = libvlc_event_manager_new( p_md, p_instance, p_e );
 274     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 275         libvlc_MediaMetaChanged, p_e );
 276     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 277         libvlc_MediaSubItemAdded, p_e );
 278     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 279         libvlc_MediaFreed, p_e );
 280     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 281         libvlc_MediaDurationChanged, p_e );
 282     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 283         libvlc_MediaStateChanged, p_e );
 284
 285     vlc_gc_incref( p_md->p_input_item );
 286
 287     install_input_item_observer( p_md );
 288
 289     return p_md;
 290 }
 291
 292 /**************************************************************************
 293  * Create a new media descriptor object
 294  **************************************************************************/
 295 libvlc_media_t * libvlc_media_new(
 296                                    libvlc_instance_t *p_instance,
 297                                    const char * psz_mrl,
 298                                    libvlc_exception_t *p_e )
 299 {
 300     input_item_t * p_input_item;
 301     libvlc_media_t * p_md;
 302
 303     p_input_item = input_item_New( p_instance->p_libvlc_int, psz_mrl, NULL );
 304
 305     if (!p_input_item)
 306     {
 307         libvlc_exception_raise( p_e );
 308         libvlc_printerr( "Not enough memory" );
 309         return NULL;
 310     }
 311
 312     p_md = libvlc_media_new_from_input_item( p_instance,
 313                 p_input_item, p_e );
 314
 315     /* The p_input_item is retained in libvlc_media_new_from_input_item */
 316     vlc_gc_decref( p_input_item );
 317
 318     return p_md;
 319 }
 320
 321 /**************************************************************************
 322  * Create a new media descriptor object
 323  **************************************************************************/
 324 libvlc_media_t * libvlc_media_new_as_node(
 325                                    libvlc_instance_t *p_instance,
 326                                    const char * psz_name,
 327                                    libvlc_exception_t *p_e )
 328 {
 329     input_item_t * p_input_item;
 330     libvlc_media_t * p_md;
 331
 332     p_input_item = input_item_New( p_instance->p_libvlc_int, "vlc://nop", psz_name );
 333
 334     if (!p_input_item)
 335     {
 336         libvlc_exception_raise( p_e );
 337         libvlc_printerr( "Not enough memory" );
 338         return NULL;
 339     }
 340
 341     p_md = libvlc_media_new_from_input_item( p_instance,
 342                 p_input_item, p_e );
 343
 344     p_md->p_subitems = libvlc_media_list_new( p_md->p_libvlc_instance, NULL );
 345
 346     return p_md;
 347 }
 348
 349 /**************************************************************************
 350  * Add an option to the media descriptor,
 351  * that will be used to determine how the media_player will read the
 352  * media. This allow to use VLC advanced reading/streaming
 353  * options in a per-media basis
 354  *
 355  * The options are detailled in vlc --long-help, for instance "--sout-all"
 356  **************************************************************************/
 357 void libvlc_media_add_option(
 358                                    libvlc_media_t * p_md,
 359                                    const char * psz_option )
 360 {
 361     input_item_AddOption( p_md->p_input_item, psz_option,
 362                           VLC_INPUT_OPTION_UNIQUE|VLC_INPUT_OPTION_TRUSTED );
 363 }
 364
 365 /**************************************************************************
 366  * Same as libvlc_media_add_option but with configurable flags.
 367  **************************************************************************/
 368 void libvlc_media_add_option_flag(
 369                                    libvlc_media_t * p_md,
 370                                    const char * ppsz_option,
 371                                    libvlc_media_option_t i_flags )
 372 {
 373     input_item_AddOption( p_md->p_input_item, ppsz_option,
 374                           i_flags );
 375 }
 376
 377 /**************************************************************************
 378  * Delete a media descriptor object
 379  **************************************************************************/
 380 void libvlc_media_release( libvlc_media_t *p_md )
 381 {
 382     if (!p_md)
 383         return;
 384
 385     p_md->i_refcount--;
 386
 387     if( p_md->i_refcount > 0 )
 388         return;
 389
 390     if( p_md->p_subitems )
 391         libvlc_media_list_release( p_md->p_subitems );
 392
 393     uninstall_input_item_observer( p_md );
 394     vlc_gc_decref( p_md->p_input_item );
 395
 396     /* Construct the event */
 397     libvlc_event_t event;
 398     event.type = libvlc_MediaFreed;
 399     event.u.media_freed.md = p_md;
 400
 401     /* Send the event */
 402     libvlc_event_send( p_md->p_event_manager, &event );
 403
 404     libvlc_event_manager_release( p_md->p_event_manager );
 405
 406     free( p_md );
 407 }
 408
 409 /**************************************************************************
 410  * Retain a media descriptor object
 411  **************************************************************************/
 412 void libvlc_media_retain( libvlc_media_t *p_md )
 413 {
 414     if (!p_md)
 415         return;
 416
 417     p_md->i_refcount++;
 418 }
 419
 420 /**************************************************************************
 421  * Duplicate a media descriptor object
 422  **************************************************************************/
 423 libvlc_media_t *
 424 libvlc_media_duplicate( libvlc_media_t *p_md_orig )
 425 {
 426     return libvlc_media_new_from_input_item(
 427         p_md_orig->p_libvlc_instance, p_md_orig->p_input_item, NULL );
 428 }
 429
 430 /**************************************************************************
 431  * Get mrl from a media descriptor object
 432  **************************************************************************/
 433 char *
 434 libvlc_media_get_mrl( libvlc_media_t * p_md )
 435 {
 436     assert( p_md );
 437     return input_item_GetURI( p_md->p_input_item );
 438 }
 439
 440 /**************************************************************************
 441  * Getter for meta information
 442  **************************************************************************/
 443
 444 char *libvlc_media_get_meta( libvlc_media_t *p_md, libvlc_meta_t e_meta )
 445 {
 446     char * psz_meta;
 447
 448     assert( p_md );
 449     /* XXX: locking */
 450
 451     preparse_if_needed( p_md );
 452
 453     psz_meta = input_item_GetMeta( p_md->p_input_item,
 454                                    libvlc_to_vlc_meta[e_meta] );
 455
 456     if( e_meta == libvlc_meta_ArtworkURL && !psz_meta )
 457     {
 458         playlist_AskForArtEnqueue(
 459                 libvlc_priv(p_md->p_libvlc_instance->p_libvlc_int)->p_playlist,
 460                 p_md->p_input_item, pl_Unlocked );
 461     }
 462
 463     /* Should be integrated in core */
 464     if( !psz_meta && e_meta == libvlc_meta_Title && p_md->p_input_item->psz_name )
 465     {
 466         free( psz_meta );
 467         return strdup( p_md->p_input_item->psz_name );
 468     }
 469
 470     return psz_meta;
 471 }
 472
 473 /**************************************************************************
 474  * Getter for state information
 475  * Can be error, playing, buffering, NothingSpecial.
 476  **************************************************************************/
 477
 478 libvlc_state_t
 479 libvlc_media_get_state( libvlc_media_t *p_md )
 480 {
 481     assert( p_md );
 482     return p_md->state;
 483 }
 484
 485 /**************************************************************************
 486  * Setter for state information (LibVLC Internal)
 487  **************************************************************************/
 488
 489 void
 490 libvlc_media_set_state( libvlc_media_t *p_md,
 491                                    libvlc_state_t state )
 492 {
 493     libvlc_event_t event;
 494     VLC_UNUSED(p_e);
 495
 496     p_md->state = state;
 497
 498     /* Construct the event */
 499     event.type = libvlc_MediaStateChanged;
 500     event.u.media_state_changed.new_state = state;
 501
 502     /* Send the event */
 503     libvlc_event_send( p_md->p_event_manager, &event );
 504 }
 505
 506 /**************************************************************************
 507  * subitems
 508  **************************************************************************/
 509 libvlc_media_list_t *
 510 libvlc_media_subitems( libvlc_media_t * p_md )
 511 {
 512     if( p_md->p_subitems )
 513         libvlc_media_list_retain( p_md->p_subitems );
 514     return p_md->p_subitems;
 515 }
 516
 517 /**************************************************************************
 518  * event_manager
 519  **************************************************************************/
 520 libvlc_event_manager_t *
 521 libvlc_media_event_manager( libvlc_media_t * p_md )
 522 {
 523     assert( p_md );
 524
 525     return p_md->p_event_manager;
 526 }
 527
 528 /**************************************************************************
 529  * Get duration of media object (in ms)
 530  **************************************************************************/
 531 int64_t
 532 libvlc_media_get_duration( libvlc_media_t * p_md )
 533 {
 534     assert( p_md );
 535
 536     if( !p_md->p_input_item )
 537     {
 538         libvlc_exception_raise( p_e );
 539         libvlc_printerr( "No input item" );
 540         return -1;
 541     }
 542
 543     return input_item_GetDuration( p_md->p_input_item ) / 1000;
 544 }
 545
 546 /**************************************************************************
 547  * Get preparsed status for media object.
 548  **************************************************************************/
 549 int
 550 libvlc_media_is_preparsed( libvlc_media_t * p_md )
 551 {
 552     assert( p_md );
 553     VLC_UNUSED(p_e);
 554
 555     if( !p_md->p_input_item )
 556     {
 557         libvlc_exception_raise( p_e );
 558         libvlc_printerr( "No input item" );
 559         return false;
 560     }
 561
 562     return input_item_IsPreparsed( p_md->p_input_item );
 563 }
 564
 565 /**************************************************************************
 566  * Sets media descriptor's user_data. user_data is specialized data
 567  * accessed by the host application, VLC.framework uses it as a pointer to
 568  * an native object that references a libvlc_media_t pointer
 569  **************************************************************************/
 570 void
 571 libvlc_media_set_user_data( libvlc_media_t * p_md, void * p_new_user_data )
 572 {
 573     assert( p_md );
 574     p_md->p_user_data = p_new_user_data;
 575 }
 576
 577 /**************************************************************************
 578  * Get media descriptor's user_data. user_data is specialized data
 579  * accessed by the host application, VLC.framework uses it as a pointer to
 580  * an native object that references a libvlc_media_t pointer
 581  **************************************************************************/
 582 void *
 583 libvlc_media_get_user_data( libvlc_media_t * p_md )
 584 {
 585     assert( p_md );
 586     return p_md->p_user_data;
 587 }