src/player/player.h

   1 /*****************************************************************************
   2  * player.h: Player internal interface
   3  *****************************************************************************
   4  * Copyright © 2018-2019 VLC authors and VideoLAN
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifndef VLC_PLAYER_INTERNAL_H
  22 #define VLC_PLAYER_INTERNAL_H
  23
  24 #include <vlc_player.h>
  25 #include <vlc_list.h>
  26 #include <vlc_vector.h>
  27 #include <vlc_atomic.h>
  28 #include <vlc_media_library.h>
  29
  30 #include "input/input_internal.h"
  31
  32 struct vlc_player_track_priv
  33 {
  34     struct vlc_player_track t;
  35     vout_thread_t *vout; /* weak reference */
  36     vlc_tick_t delay;
  37     /* only valid if selected and if category is VIDEO_ES or SPU_ES */
  38     enum vlc_vout_order vout_order;
  39     /* Used to save or not the track selection */
  40     bool selected_by_user;
  41 };
  42
  43 typedef struct VLC_VECTOR(struct vlc_player_program *)
  44     vlc_player_program_vector;
  45
  46 typedef struct VLC_VECTOR(struct vlc_player_track_priv *)
  47     vlc_player_track_vector;
  48
  49 struct vlc_player_title_list
  50 {
  51     vlc_atomic_rc_t rc;
  52     size_t count;
  53     struct vlc_player_title array[];
  54 };
  55
  56 struct vlc_player_input
  57 {
  58     input_thread_t *thread;
  59     vlc_player_t *player;
  60     bool started;
  61
  62     enum vlc_player_state state;
  63     enum vlc_player_error error;
  64     float rate;
  65     int capabilities;
  66     vlc_tick_t length;
  67
  68     float position;
  69     vlc_tick_t time;
  70     vlc_tick_t normal_time;
  71
  72     vlc_tick_t pause_date;
  73
  74     bool recording;
  75
  76     float signal_quality;
  77     float signal_strength;
  78     float cache;
  79
  80     struct input_stats_t stats;
  81
  82     vlc_tick_t cat_delays[DATA_ES];
  83
  84     vlc_player_program_vector program_vector;
  85     vlc_player_track_vector video_track_vector;
  86     vlc_player_track_vector audio_track_vector;
  87     vlc_player_track_vector spu_track_vector;
  88     const struct vlc_player_track_priv *teletext_source;
  89
  90     struct vlc_player_title_list *titles;
  91
  92     size_t title_selected;
  93     size_t chapter_selected;
  94
  95     struct vlc_list node;
  96
  97     bool teletext_enabled;
  98     bool teletext_transparent;
  99     unsigned teletext_page;
 100
 101     struct
 102     {
 103         vlc_tick_t time;
 104         float pos;
 105         bool set;
 106     } abloop_state[2];
 107
 108     struct
 109     {
 110         vlc_ml_playback_states_all states;
 111         enum
 112         {
 113             VLC_RESTOREPOINT_TITLE,
 114             VLC_RESTOREPOINT_POSITION,
 115             VLC_RESTOREPOINT_NONE,
 116         } restore;
 117         float pos;
 118         bool restore_states;
 119         bool delay_restore;
 120         /* Keep a trace of tracks as they appear since they won't be available
 121          * for probing when the input gets stopped
 122          */
 123         bool has_video_tracks;
 124         bool has_audio_tracks;
 125     } ml;
 126 };
 127
 128 struct vlc_player_listener_id
 129 {
 130     const struct vlc_player_cbs *cbs;
 131     void *cbs_data;
 132     struct vlc_list node;
 133 };
 134
 135 struct vlc_player_metadata_listener_id
 136 {
 137     const union vlc_player_metadata_cbs *cbs;
 138     void *cbs_data;
 139
 140     enum vlc_player_metadata_option option;
 141     union
 142     {
 143         vlc_audio_meter_plugin *audio_meter;
 144     };
 145     struct vlc_list node;
 146 };
 147
 148 struct vlc_player_vout_listener_id
 149 {
 150     const struct vlc_player_vout_cbs *cbs;
 151     void *cbs_data;
 152     struct vlc_list node;
 153 };
 154
 155 struct vlc_player_aout_listener_id
 156 {
 157     const struct vlc_player_aout_cbs *cbs;
 158     void *cbs_data;
 159     struct vlc_list node;
 160 };
 161
 162 enum vlc_player_timer_source_type
 163 {
 164     VLC_PLAYER_TIMER_TYPE_BEST,
 165     VLC_PLAYER_TIMER_TYPE_SMPTE,
 166     VLC_PLAYER_TIMER_TYPE_COUNT
 167 };
 168
 169 struct vlc_player_timer_id
 170 {
 171     vlc_tick_t period;
 172     vlc_tick_t last_update_date;
 173
 174     union
 175     {
 176         const struct vlc_player_timer_cbs *cbs;
 177         const struct vlc_player_timer_smpte_cbs *smpte_cbs;
 178     };
 179     void *data;
 180
 181     struct vlc_list node;
 182 };
 183
 184 struct vlc_player_timer_source
 185 {
 186     struct vlc_list listeners; /* list of struct vlc_player_timer_id */
 187     vlc_es_id_t *es; /* weak reference */
 188     struct vlc_player_timer_point point;
 189     union
 190     {
 191         struct {
 192             unsigned long last_framenum;
 193             unsigned frame_rate;
 194             unsigned frame_rate_base;
 195             unsigned frame_resolution;
 196             unsigned df_fps;
 197             int df;
 198             int frames_per_10mins;
 199         } smpte;
 200     };
 201 };
 202
 203 enum vlc_player_timer_state
 204 {
 205     VLC_PLAYER_TIMER_STATE_PLAYING,
 206     VLC_PLAYER_TIMER_STATE_PAUSED,
 207     VLC_PLAYER_TIMER_STATE_DISCONTINUITY,
 208 };
 209
 210 struct vlc_player_timer
 211 {
 212     vlc_mutex_t lock;
 213
 214     enum vlc_player_timer_state state;
 215     bool seeking;
 216
 217     vlc_tick_t input_length;
 218     vlc_tick_t input_normal_time;
 219     vlc_tick_t last_ts;
 220     float input_position;
 221
 222     struct vlc_player_timer_source sources[VLC_PLAYER_TIMER_TYPE_COUNT];
 223 #define best_source sources[VLC_PLAYER_TIMER_TYPE_BEST]
 224 #define smpte_source sources[VLC_PLAYER_TIMER_TYPE_SMPTE]
 225 };
 226
 227 struct vlc_player_t
 228 {
 229     struct vlc_object_t obj;
 230     vlc_mutex_t lock;
 231     vlc_mutex_t metadata_listeners_lock;
 232     vlc_mutex_t aout_listeners_lock;
 233     vlc_mutex_t vout_listeners_lock;
 234     vlc_cond_t start_delay_cond;
 235
 236     enum vlc_player_media_stopped_action media_stopped_action;
 237     bool start_paused;
 238
 239     const struct vlc_player_media_provider *media_provider;
 240     void *media_provider_data;
 241
 242     bool pause_on_cork;
 243     bool corked;
 244
 245     struct vlc_list listeners;
 246     struct vlc_list metadata_listeners;
 247     struct vlc_list aout_listeners;
 248     struct vlc_list vout_listeners;
 249
 250     input_resource_t *resource;
 251     vlc_renderer_item_t *renderer;
 252
 253     input_item_t *media;
 254     struct vlc_player_input *input;
 255
 256     bool releasing_media;
 257     bool next_media_requested;
 258     input_item_t *next_media;
 259
 260     char *video_string_ids;
 261     char *audio_string_ids;
 262     char *sub_string_ids;
 263
 264     enum vlc_player_state global_state;
 265     bool started;
 266
 267     unsigned error_count;
 268
 269     bool deleting;
 270     struct
 271     {
 272         vlc_thread_t thread;
 273         vlc_cond_t wait;
 274         vlc_cond_t notify;
 275         struct vlc_list inputs;
 276         struct vlc_list stopping_inputs;
 277         struct vlc_list joinable_inputs;
 278     } destructor;
 279
 280     struct vlc_player_timer timer;
 281 };
 282
 283 #ifndef NDEBUG
 284 /*
 285  * Assert that the player mutex is locked.
 286  *
 287  * This is exposed in this internal header because the playlist and its
 288  * associated player share the lock to avoid lock-order inversion issues.
 289  */
 290 static inline void
 291 vlc_player_assert_locked(vlc_player_t *player)
 292 {
 293     assert(player);
 294     vlc_mutex_assert(&player->lock);
 295 }
 296 #else
 297 #define vlc_player_assert_locked(x) ((void) (0))
 298 #endif
 299
 300 static inline struct vlc_player_input *
 301 vlc_player_get_input_locked(vlc_player_t *player)
 302 {
 303     vlc_player_assert_locked(player);
 304     return player->input;
 305 }
 306
 307 #define vlc_player_SendEvent(player, event, ...) do { \
 308     vlc_player_listener_id *listener; \
 309     vlc_list_foreach(listener, &player->listeners, node) \
 310     { \
 311         if (listener->cbs->event) \
 312             listener->cbs->event(player, ##__VA_ARGS__, listener->cbs_data); \
 313     } \
 314 } while(0)
 315
 316 static inline const char *
 317 es_format_category_to_string(enum es_format_category_e cat)
 318 {
 319     switch (cat)
 320     {
 321         case VIDEO_ES: return "Video";
 322         case AUDIO_ES: return "Audio";
 323         case SPU_ES: return "Subtitle";
 324         default: return NULL;
 325     }
 326 }
 327
 328 /*
 329  * player.c
 330  */
 331
 332 vlc_object_t *
 333 vlc_player_GetObject(vlc_player_t *player);
 334
 335 int
 336 vlc_player_OpenNextMedia(vlc_player_t *player);
 337
 338 void
 339 vlc_player_PrepareNextMedia(vlc_player_t *player);
 340
 341 void
 342 vlc_player_destructor_AddStoppingInput(vlc_player_t *player,
 343                                        struct vlc_player_input *input);
 344
 345 void
 346 vlc_player_destructor_AddJoinableInput(vlc_player_t *player,
 347                                        struct vlc_player_input *input);
 348
 349 /*
 350  * player_track.c
 351  */
 352
 353 struct vlc_player_program *
 354 vlc_player_program_New(int id, const char *name);
 355
 356 int
 357 vlc_player_program_Update(struct vlc_player_program *prgm, int id,
 358                           const char *name);
 359
 360 struct vlc_player_program *
 361 vlc_player_program_vector_FindById(vlc_player_program_vector *vec, int id,
 362                                    size_t *idx);
 363
 364 struct vlc_player_track_priv *
 365 vlc_player_track_priv_New(vlc_es_id_t *id, const char *name, const es_format_t *fmt);
 366
 367 void
 368 vlc_player_track_priv_Delete(struct vlc_player_track_priv *trackpriv);
 369
 370 int
 371 vlc_player_track_priv_Update(struct vlc_player_track_priv *trackpriv,
 372                              const char *name, const es_format_t *fmt);
 373
 374 struct vlc_player_track_priv *
 375 vlc_player_track_vector_FindById(vlc_player_track_vector *vec, vlc_es_id_t *id,
 376                                  size_t *idx);
 377
 378 int
 379 vlc_player_GetFirstSelectedTrackId(const vlc_player_track_vector* tracks);
 380
 381 /*
 382  * player_title.c
 383  */
 384
 385 struct vlc_player_title_list *
 386 vlc_player_title_list_Create(input_title_t *const *array, size_t count,
 387                              int title_offset, int chapter_offset);
 388
 389 /*
 390  * player_input.c
 391  */
 392
 393 static inline vlc_player_track_vector *
 394 vlc_player_input_GetTrackVector(struct vlc_player_input *input,
 395                                 enum es_format_category_e cat)
 396 {
 397     switch (cat)
 398     {
 399         case VIDEO_ES:
 400             return &input->video_track_vector;
 401         case AUDIO_ES:
 402             return &input->audio_track_vector;
 403         case SPU_ES:
 404             return &input->spu_track_vector;
 405         default:
 406             return NULL;
 407     }
 408 }
 409
 410 struct vlc_player_track_priv *
 411 vlc_player_input_FindTrackById(struct vlc_player_input *input, vlc_es_id_t *id,
 412                                size_t *idx);
 413
 414 struct vlc_player_input *
 415 vlc_player_input_New(vlc_player_t *player, input_item_t *item);
 416
 417 void
 418 vlc_player_input_Delete(struct vlc_player_input *input);
 419
 420 void
 421 vlc_player_input_SelectTracksByStringIds(struct vlc_player_input *input,
 422                                          enum es_format_category_e cat,
 423                                          const char *str_ids);
 424
 425 char *
 426 vlc_player_input_GetSelectedTrackStringIds(struct vlc_player_input *input,
 427                                            enum es_format_category_e cat);
 428
 429 vlc_tick_t
 430 vlc_player_input_GetTime(struct vlc_player_input *input);
 431
 432 float
 433 vlc_player_input_GetPos(struct vlc_player_input *input);
 434
 435 int
 436 vlc_player_input_Start(struct vlc_player_input *input);
 437
 438 void
 439 vlc_player_input_HandleState(struct vlc_player_input *, enum vlc_player_state,
 440                              vlc_tick_t state_date);
 441
 442 struct vlc_player_timer_point
 443 vlc_player_input_GetTimerValue(struct vlc_player_input *input);
 444
 445 /*
 446  * player_timer.c
 447 */
 448
 449 void
 450 vlc_player_InitTimer(vlc_player_t *player);
 451
 452 void
 453 vlc_player_DestroyTimer(vlc_player_t *player);
 454
 455 void
 456 vlc_player_ResetTimer(vlc_player_t *player);
 457
 458 void
 459 vlc_player_UpdateTimerState(vlc_player_t *player, vlc_es_id_t *es_source,
 460                             enum vlc_player_timer_state state,
 461                             vlc_tick_t system_date);
 462
 463 void
 464 vlc_player_UpdateTimer(vlc_player_t *player, vlc_es_id_t *es_source,
 465                        bool es_source_is_master,
 466                        const struct vlc_player_timer_point *point,
 467                        vlc_tick_t normal_time,
 468                        unsigned frame_rate, unsigned frame_rate_base);
 469
 470 void
 471 vlc_player_RemoveTimerSource(vlc_player_t *player, vlc_es_id_t *es_source);
 472
 473 int
 474 vlc_player_GetTimerPoint(vlc_player_t *player, vlc_tick_t system_now,
 475                          vlc_tick_t *out_ts, float *out_pos);
 476
 477 /*
 478  * player_vout.c
 479  */
 480
 481 void
 482 vlc_player_vout_AddCallbacks(vlc_player_t *player, vout_thread_t *vout);
 483
 484 void
 485 vlc_player_vout_DelCallbacks(vlc_player_t *player, vout_thread_t *vout);
 486
 487 /*
 488  * player_aout.c
 489  */
 490
 491 audio_output_t *
 492 vlc_player_aout_Init(vlc_player_t *player);
 493
 494 void
 495 vlc_player_aout_Deinit(vlc_player_t *player);
 496
 497 /*
 498  * player_osd.c
 499  */
 500
 501 void
 502 vlc_player_osd_Message(vlc_player_t *player, const char *fmt, ...);
 503
 504 void
 505 vlc_player_osd_Icon(vlc_player_t *player, short type);
 506
 507 void
 508 vlc_player_osd_Position(vlc_player_t *player,
 509                         struct vlc_player_input *input, vlc_tick_t time,
 510                         float position, enum vlc_player_whence whence);
 511 void
 512 vlc_player_osd_Volume(vlc_player_t *player, bool mute_action);
 513
 514 int
 515 vlc_player_vout_OSDCallback(vlc_object_t *this, const char *var,
 516                             vlc_value_t oldval, vlc_value_t newval, void *data);
 517
 518 void
 519 vlc_player_osd_Track(vlc_player_t *player, vlc_es_id_t *id, bool select);
 520
 521 void
 522 vlc_player_osd_Tracks(vlc_player_t *player, vlc_es_id_t * const*selected, vlc_es_id_t *unselect);
 523
 524 void
 525 vlc_player_osd_Program(vlc_player_t *player, const char *name);
 526
 527 /*
 528  * player/medialib.c
 529  */
 530
 531 void
 532 vlc_player_input_RestoreMlStates(struct vlc_player_input* input, bool force_pos);
 533
 534 void
 535 vlc_player_UpdateMLStates(vlc_player_t *player, struct vlc_player_input* input);
 536
 537 #endif