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, "No input item given" );
 249         return NULL;
 250     }
 251
 252     p_md = malloc( sizeof(libvlc_media_t) );
 253     if( !p_md )
 254     {
 255         libvlc_exception_raise( p_e, "Not enough memory" );
 256         return NULL;
 257     }
 258
 259     p_md->p_libvlc_instance = p_instance;
 260     p_md->p_input_item      = p_input_item;
 261     p_md->b_preparsed       = false;
 262     p_md->i_refcount        = 1;
 263     p_md->p_user_data       = NULL;
 264
 265     p_md->state = libvlc_NothingSpecial;
 266
 267     /* A media descriptor can be a playlist. When you open a playlist
 268      * It can give a bunch of item to read. */
 269     p_md->p_subitems        = NULL;
 270
 271     p_md->p_event_manager = libvlc_event_manager_new( p_md, p_instance, p_e );
 272     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 273         libvlc_MediaMetaChanged, p_e );
 274     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 275         libvlc_MediaSubItemAdded, p_e );
 276     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 277         libvlc_MediaFreed, p_e );
 278     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 279         libvlc_MediaDurationChanged, p_e );
 280     libvlc_event_manager_register_event_type( p_md->p_event_manager,
 281         libvlc_MediaStateChanged, p_e );
 282
 283     vlc_gc_incref( p_md->p_input_item );
 284
 285     install_input_item_observer( p_md );
 286
 287     return p_md;
 288 }
 289
 290 /**************************************************************************
 291  * Create a new media descriptor object
 292  **************************************************************************/
 293 libvlc_media_t * libvlc_media_new(
 294                                    libvlc_instance_t *p_instance,
 295                                    const char * psz_mrl,
 296                                    libvlc_exception_t *p_e )
 297 {
 298     input_item_t * p_input_item;
 299     libvlc_media_t * p_md;
 300
 301     p_input_item = input_item_New( p_instance->p_libvlc_int, psz_mrl, NULL );
 302
 303     if (!p_input_item)
 304     {
 305         libvlc_exception_raise( p_e, "Can't create md's input_item" );
 306         return NULL;
 307     }
 308
 309     p_md = libvlc_media_new_from_input_item( p_instance,
 310                 p_input_item, p_e );
 311
 312     /* The p_input_item is retained in libvlc_media_new_from_input_item */
 313     vlc_gc_decref( p_input_item );
 314
 315     return p_md;
 316 }
 317
 318 /**************************************************************************
 319  * Create a new media descriptor object
 320  **************************************************************************/
 321 libvlc_media_t * libvlc_media_new_as_node(
 322                                    libvlc_instance_t *p_instance,
 323                                    const char * psz_name,
 324                                    libvlc_exception_t *p_e )
 325 {
 326     input_item_t * p_input_item;
 327     libvlc_media_t * p_md;
 328
 329     p_input_item = input_item_New( p_instance->p_libvlc_int, "vlc://nop", psz_name );
 330
 331     if (!p_input_item)
 332     {
 333         libvlc_exception_raise( p_e, "Can't create md's input_item" );
 334         return NULL;
 335     }
 336
 337     p_md = libvlc_media_new_from_input_item( p_instance,
 338                 p_input_item, p_e );
 339
 340     p_md->p_subitems = libvlc_media_list_new( p_md->p_libvlc_instance, NULL );
 341
 342     return p_md;
 343 }
 344
 345 /**************************************************************************
 346  * Add an option to the media descriptor,
 347  * that will be used to determine how the media_player will read the
 348  * media. This allow to use VLC advanced reading/streaming
 349  * options in a per-media basis
 350  *
 351  * The options are detailled in vlc --long-help, for instance "--sout-all"
 352  **************************************************************************/
 353 void libvlc_media_add_option(
 354                                    libvlc_media_t * p_md,
 355                                    const char * ppsz_option,
 356                                    libvlc_exception_t *p_e )
 357 {
 358     VLC_UNUSED(p_e);
 359     input_item_AddOption( p_md->p_input_item, ppsz_option,
 360                           VLC_INPUT_OPTION_UNIQUE|VLC_INPUT_OPTION_TRUSTED );
 361 }
 362
 363 /**************************************************************************
 364  * Same as libvlc_media_add_option but with untrusted source.
 365  **************************************************************************/
 366 void libvlc_media_add_option_untrusted(
 367                                    libvlc_media_t * p_md,
 368                                    const char * ppsz_option,
 369                                    libvlc_exception_t *p_e )
 370 {
 371     VLC_UNUSED(p_e);
 372     input_item_AddOption( p_md->p_input_item, ppsz_option,
 373                           VLC_INPUT_OPTION_UNIQUE );
 374 }
 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                                  libvlc_exception_t * p_e )
 436 {
 437     VLC_UNUSED(p_e);
 438     return input_item_GetURI( p_md->p_input_item );
 439 }
 440
 441 /**************************************************************************
 442  * Getter for meta information
 443  **************************************************************************/
 444
 445 char * libvlc_media_get_meta( libvlc_media_t *p_md,
 446                                          libvlc_meta_t e_meta,
 447                                          libvlc_exception_t *p_e )
 448 {
 449     char * psz_meta;
 450     VLC_UNUSED(p_e);
 451
 452     /* XXX: locking */
 453
 454     preparse_if_needed( p_md );
 455
 456     psz_meta = input_item_GetMeta( p_md->p_input_item,
 457                                    libvlc_to_vlc_meta[e_meta] );
 458
 459     if( e_meta == libvlc_meta_ArtworkURL && !psz_meta )
 460     {
 461         playlist_AskForArtEnqueue(
 462                 libvlc_priv(p_md->p_libvlc_instance->p_libvlc_int)->p_playlist,
 463                 p_md->p_input_item, pl_Unlocked );
 464     }
 465
 466     /* Should be integrated in core */
 467     if( !psz_meta && e_meta == libvlc_meta_Title && p_md->p_input_item->psz_name )
 468     {
 469         free( psz_meta );
 470         return strdup( p_md->p_input_item->psz_name );
 471     }
 472
 473     return psz_meta;
 474 }
 475
 476 /**************************************************************************
 477  * Getter for state information
 478  * Can be error, playing, buffering, NothingSpecial.
 479  **************************************************************************/
 480
 481 libvlc_state_t
 482 libvlc_media_get_state( libvlc_media_t *p_md,
 483                                    libvlc_exception_t *p_e )
 484 {
 485     VLC_UNUSED(p_e);
 486     return p_md->state;
 487 }
 488
 489 /**************************************************************************
 490  * Setter for state information (LibVLC Internal)
 491  **************************************************************************/
 492
 493 void
 494 libvlc_media_set_state( libvlc_media_t *p_md,
 495                                    libvlc_state_t state,
 496                                    libvlc_exception_t *p_e )
 497 {
 498     libvlc_event_t event;
 499     VLC_UNUSED(p_e);
 500
 501     p_md->state = state;
 502
 503     /* Construct the event */
 504     event.type = libvlc_MediaStateChanged;
 505     event.u.media_state_changed.new_state = state;
 506
 507     /* Send the event */
 508     libvlc_event_send( p_md->p_event_manager, &event );
 509 }
 510
 511 /**************************************************************************
 512  * subitems
 513  **************************************************************************/
 514 libvlc_media_list_t *
 515 libvlc_media_subitems( libvlc_media_t * p_md,
 516                                   libvlc_exception_t * p_e )
 517 {
 518     VLC_UNUSED(p_e);
 519
 520     if( p_md->p_subitems )
 521         libvlc_media_list_retain( p_md->p_subitems );
 522     return p_md->p_subitems;
 523 }
 524
 525 /**************************************************************************
 526  * event_manager
 527  **************************************************************************/
 528 libvlc_event_manager_t *
 529 libvlc_media_event_manager( libvlc_media_t * p_md,
 530                                        libvlc_exception_t * p_e )
 531 {
 532     VLC_UNUSED(p_e);
 533
 534     return p_md->p_event_manager;
 535 }
 536
 537 /**************************************************************************
 538  * Get duration of media object.
 539  **************************************************************************/
 540 int64_t
 541 libvlc_media_get_duration( libvlc_media_t * p_md,
 542                                       libvlc_exception_t * p_e )
 543 {
 544     VLC_UNUSED(p_e);
 545
 546     if( !p_md || !p_md->p_input_item)
 547     {
 548         libvlc_exception_raise( p_e, "No input item" );
 549         return -1;
 550     }
 551
 552     return input_item_GetDuration( p_md->p_input_item );
 553 }
 554
 555 /**************************************************************************
 556  * Get preparsed status for media object.
 557  **************************************************************************/
 558 int
 559 libvlc_media_is_preparsed( libvlc_media_t * p_md,
 560                                        libvlc_exception_t * p_e )
 561 {
 562     VLC_UNUSED(p_e);
 563
 564     if( !p_md || !p_md->p_input_item)
 565     {
 566         libvlc_exception_raise( p_e, "No input item" );
 567         return false;
 568     }
 569
 570     return input_item_IsPreparsed( p_md->p_input_item );
 571 }
 572
 573 /**************************************************************************
 574  * Sets media descriptor's user_data. user_data is specialized data
 575  * accessed by the host application, VLC.framework uses it as a pointer to
 576  * an native object that references a libvlc_media_t pointer
 577  **************************************************************************/
 578 void
 579 libvlc_media_set_user_data( libvlc_media_t * p_md,
 580                                        void * p_new_user_data,
 581                                        libvlc_exception_t * p_e )
 582 {
 583     VLC_UNUSED(p_e);
 584
 585     if( p_md )
 586     {
 587         p_md->p_user_data = p_new_user_data;
 588     }
 589 }
 590
 591 /**************************************************************************
 592  * Get media descriptor's user_data. user_data is specialized data
 593  * accessed by the host application, VLC.framework uses it as a pointer to
 594  * an native object that references a libvlc_media_t pointer
 595  **************************************************************************/
 596 void *
 597 libvlc_media_get_user_data( libvlc_media_t * p_md,
 598                                        libvlc_exception_t * p_e )
 599 {
 600     VLC_UNUSED(p_e);
 601
 602     if( p_md )
 603     {
 604         return p_md->p_user_data;
 605     }
 606     else
 607     {
 608         return NULL;
 609     }
 610 }