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 enum 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 configurable flags.
 365  **************************************************************************/
 366 void libvlc_media_add_option_flag(
 367                                    libvlc_media_t * p_md,
 368                                    const char * ppsz_option,
 369                                    unsigned i_flags,
 370                                    libvlc_exception_t *p_e )
 371 {
 372     VLC_UNUSED(p_e);
 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                                  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, unsigned e_meta,
 446                                          libvlc_exception_t *p_e )
 447 {
 448     char * psz_meta;
 449     VLC_UNUSED(p_e);
 450
 451     /* XXX: locking */
 452
 453     preparse_if_needed( p_md );
 454
 455     psz_meta = input_item_GetMeta( p_md->p_input_item,
 456                                    libvlc_to_vlc_meta[e_meta] );
 457
 458     if( e_meta == libvlc_meta_ArtworkURL && !psz_meta )
 459     {
 460         playlist_AskForArtEnqueue(
 461                 libvlc_priv(p_md->p_libvlc_instance->p_libvlc_int)->p_playlist,
 462                 p_md->p_input_item, pl_Unlocked );
 463     }
 464
 465     /* Should be integrated in core */
 466     if( !psz_meta && e_meta == libvlc_meta_Title && p_md->p_input_item->psz_name )
 467     {
 468         free( psz_meta );
 469         return strdup( p_md->p_input_item->psz_name );
 470     }
 471
 472     return psz_meta;
 473 }
 474
 475 /**************************************************************************
 476  * Getter for state information
 477  * Can be error, playing, buffering, NothingSpecial.
 478  **************************************************************************/
 479
 480 unsigned
 481 libvlc_media_get_state( libvlc_media_t *p_md,
 482                                    libvlc_exception_t *p_e )
 483 {
 484     VLC_UNUSED(p_e);
 485     return p_md->state;
 486 }
 487
 488 /**************************************************************************
 489  * Setter for state information (LibVLC Internal)
 490  **************************************************************************/
 491
 492 void
 493 libvlc_media_set_state( libvlc_media_t *p_md, enum libvlc_state_t state,
 494                                    libvlc_exception_t *p_e )
 495 {
 496     libvlc_event_t event;
 497     VLC_UNUSED(p_e);
 498
 499     p_md->state = state;
 500
 501     /* Construct the event */
 502     event.type = libvlc_MediaStateChanged;
 503     event.u.media_state_changed.new_state = state;
 504
 505     /* Send the event */
 506     libvlc_event_send( p_md->p_event_manager, &event );
 507 }
 508
 509 /**************************************************************************
 510  * subitems
 511  **************************************************************************/
 512 libvlc_media_list_t *
 513 libvlc_media_subitems( libvlc_media_t * p_md,
 514                                   libvlc_exception_t * p_e )
 515 {
 516     VLC_UNUSED(p_e);
 517
 518     if( p_md->p_subitems )
 519         libvlc_media_list_retain( p_md->p_subitems );
 520     return p_md->p_subitems;
 521 }
 522
 523 /**************************************************************************
 524  * event_manager
 525  **************************************************************************/
 526 libvlc_event_manager_t *
 527 libvlc_media_event_manager( libvlc_media_t * p_md,
 528                                        libvlc_exception_t * p_e )
 529 {
 530     VLC_UNUSED(p_e);
 531
 532     return p_md->p_event_manager;
 533 }
 534
 535 /**************************************************************************
 536  * Get duration of media object.
 537  **************************************************************************/
 538 int64_t
 539 libvlc_media_get_duration( libvlc_media_t * p_md,
 540                                       libvlc_exception_t * p_e )
 541 {
 542     VLC_UNUSED(p_e);
 543
 544     if( !p_md || !p_md->p_input_item)
 545     {
 546         libvlc_exception_raise( p_e, "No input item" );
 547         return -1;
 548     }
 549
 550     return input_item_GetDuration( p_md->p_input_item );
 551 }
 552
 553 /**************************************************************************
 554  * Get preparsed status for media object.
 555  **************************************************************************/
 556 int
 557 libvlc_media_is_preparsed( libvlc_media_t * p_md,
 558                                        libvlc_exception_t * p_e )
 559 {
 560     VLC_UNUSED(p_e);
 561
 562     if( !p_md || !p_md->p_input_item)
 563     {
 564         libvlc_exception_raise( p_e, "No input item" );
 565         return false;
 566     }
 567
 568     return input_item_IsPreparsed( p_md->p_input_item );
 569 }
 570
 571 /**************************************************************************
 572  * Sets media descriptor's user_data. user_data is specialized data
 573  * accessed by the host application, VLC.framework uses it as a pointer to
 574  * an native object that references a libvlc_media_t pointer
 575  **************************************************************************/
 576 void
 577 libvlc_media_set_user_data( libvlc_media_t * p_md,
 578                                        void * p_new_user_data,
 579                                        libvlc_exception_t * p_e )
 580 {
 581     VLC_UNUSED(p_e);
 582
 583     if( p_md )
 584     {
 585         p_md->p_user_data = p_new_user_data;
 586     }
 587 }
 588
 589 /**************************************************************************
 590  * Get media descriptor's user_data. user_data is specialized data
 591  * accessed by the host application, VLC.framework uses it as a pointer to
 592  * an native object that references a libvlc_media_t pointer
 593  **************************************************************************/
 594 void *
 595 libvlc_media_get_user_data( libvlc_media_t * p_md,
 596                                        libvlc_exception_t * p_e )
 597 {
 598     VLC_UNUSED(p_e);
 599
 600     if( p_md )
 601     {
 602         return p_md->p_user_data;
 603     }
 604     else
 605     {
 606         return NULL;
 607     }
 608 }