modules/lua/libs/input.c

   1 /*****************************************************************************
   2  * input.c
   3  *****************************************************************************
   4  * Copyright (C) 2007-2008 the VideoLAN team
   5  *
   6  * Authors: Antoine Cellerier <dionoea at videolan tod org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifndef  _GNU_SOURCE
  27 #   define  _GNU_SOURCE
  28 #endif
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include <vlc_es.h>
  36 #include <vlc_meta.h>
  37 #include <vlc_url.h>
  38 #include <vlc_playlist.h>
  39 #include <vlc_player.h>
  40
  41 #include <assert.h>
  42
  43 #include "../vlc.h"
  44 #include "input.h"
  45 #include "../libs.h"
  46 #include "../extension.h"
  47
  48 vout_thread_t *vlclua_get_vout_internal(lua_State *L)
  49 {
  50     vlc_player_t *player = vlclua_get_player_internal(L);
  51     return vlc_player_vout_Hold(player);
  52 }
  53
  54 audio_output_t *vlclua_get_aout_internal(lua_State *L)
  55 {
  56     vlc_player_t *player = vlclua_get_player_internal(L);
  57     return vlc_player_aout_Hold(player);
  58 }
  59
  60 static input_item_t* vlclua_input_item_get_internal( lua_State *L );
  61
  62 static int vlclua_input_item_info( lua_State *L )
  63 {
  64     input_item_t *p_item = vlclua_input_item_get_internal( L );
  65     int i_cat;
  66     int i;
  67     i_cat = p_item->i_categories;
  68     lua_createtable( L, 0, i_cat );
  69     for( i = 0; i < i_cat; i++ )
  70     {
  71         info_category_t *p_category = p_item->pp_categories[i];
  72         info_t *p_info;
  73
  74         lua_pushstring( L, p_category->psz_name );
  75         lua_newtable( L );
  76         info_foreach(p_info, &p_category->infos)
  77         {
  78             lua_pushstring( L, p_info->psz_name );
  79             lua_pushstring( L, p_info->psz_value );
  80             lua_settable( L, -3 );
  81         }
  82         lua_settable( L, -3 );
  83     }
  84     return 1;
  85 }
  86
  87 static int vlclua_input_is_playing( lua_State *L )
  88 {
  89     vlc_player_t *player = vlclua_get_player_internal(L);
  90
  91     vlc_player_Lock(player);
  92     bool started = vlc_player_IsStarted(player);
  93     vlc_player_Unlock(player);
  94     lua_pushboolean(L, started);
  95     return 1;
  96 }
  97
  98 static int vlclua_player_get_title_index(lua_State *L)
  99 {
 100     vlc_player_t *player = vlclua_get_player_internal(L);
 101
 102     vlc_player_Lock(player);
 103     ssize_t idx = vlc_player_GetSelectedTitleIdx(player);
 104     vlc_player_Unlock(player);
 105
 106     lua_pushinteger(L, idx);
 107     return 1;
 108 }
 109
 110 static int vlclua_player_get_titles_count(lua_State *L)
 111 {
 112     vlc_player_t *player = vlclua_get_player_internal(L);
 113
 114     vlc_player_Lock(player);
 115     struct vlc_player_title_list *titles = vlc_player_GetTitleList(player);
 116     size_t count = titles ? vlc_player_title_list_GetCount(titles) : 0;
 117     vlc_player_Unlock(player);
 118
 119     lua_pushinteger(L, count);
 120     return 1;
 121 }
 122
 123 static int vlclua_player_title_next(lua_State *L)
 124 {
 125     vlc_player_t *player = vlclua_get_player_internal(L);
 126
 127     vlc_player_Lock(player);
 128     vlc_player_SelectNextTitle(player);
 129     vlc_player_Unlock(player);
 130
 131     return 0;
 132 }
 133
 134 static int vlclua_player_title_prev(lua_State *L)
 135 {
 136     vlc_player_t *player = vlclua_get_player_internal(L);
 137
 138     vlc_player_Lock(player);
 139     vlc_player_SelectPrevTitle(player);
 140     vlc_player_Unlock(player);
 141
 142     return 0;
 143 }
 144
 145 static int vlclua_player_title_goto(lua_State *L)
 146 {
 147     int idx = luaL_checkinteger(L, 1);
 148
 149     vlc_player_t *player = vlclua_get_player_internal(L);
 150
 151     vlc_player_Lock(player);
 152     vlc_player_SelectTitleIdx(player, idx);
 153     vlc_player_Unlock(player);
 154
 155     return 0;
 156 }
 157
 158 static int vlclua_player_get_chapter_index(lua_State *L)
 159 {
 160     vlc_player_t *player = vlclua_get_player_internal(L);
 161
 162     vlc_player_Lock(player);
 163     ssize_t idx = vlc_player_GetSelectedChapterIdx(player);
 164     vlc_player_Unlock(player);
 165
 166     lua_pushinteger(L, idx);
 167     return 1;
 168 }
 169
 170 static int vlclua_player_get_chapters_count(lua_State *L)
 171 {
 172     vlc_player_t *player = vlclua_get_player_internal(L);
 173
 174     vlc_player_Lock(player);
 175     const struct vlc_player_title *current_title =
 176         vlc_player_GetSelectedTitle(player);
 177
 178     size_t count = current_title ? current_title->chapter_count : 0;
 179     vlc_player_Unlock(player);
 180
 181     lua_pushinteger(L, count);
 182     return 1;
 183 }
 184
 185 static int vlclua_player_chapter_next(lua_State *L)
 186 {
 187     vlc_player_t *player = vlclua_get_player_internal(L);
 188
 189     vlc_player_Lock(player);
 190     vlc_player_SelectNextChapter(player);
 191     vlc_player_Unlock(player);
 192
 193     return 0;
 194 }
 195
 196 static int vlclua_player_chapter_prev(lua_State *L)
 197 {
 198     vlc_player_t *player = vlclua_get_player_internal(L);
 199
 200     vlc_player_Lock(player);
 201     vlc_player_SelectPrevChapter(player);
 202     vlc_player_Unlock(player);
 203
 204     return 0;
 205 }
 206
 207 static int vlclua_player_chapter_goto(lua_State *L)
 208 {
 209     int idx = luaL_checkinteger(L, 1);
 210
 211     vlc_player_t *player = vlclua_get_player_internal(L);
 212
 213     vlc_player_Lock(player);
 214     vlc_player_SelectChapterIdx(player, idx);
 215     vlc_player_Unlock(player);
 216
 217     return 0;
 218 }
 219
 220 static int vlclua_player_get_time(lua_State *L)
 221 {
 222     vlc_player_t *player = vlclua_get_player_internal(L);
 223
 224     vlc_player_Lock(player);
 225     vlc_tick_t time = vlc_player_GetTime(player);
 226     vlc_player_Unlock(player);
 227
 228     lua_pushinteger(L, US_FROM_VLC_TICK(time));
 229     return 1;
 230 }
 231
 232 static int vlclua_player_get_position(lua_State *L)
 233 {
 234     vlc_player_t *player = vlclua_get_player_internal(L);
 235
 236     vlc_player_Lock(player);
 237     float pos = vlc_player_GetPosition(player);
 238     vlc_player_Unlock(player);
 239
 240     lua_pushnumber(L, pos);
 241     return 1;
 242 }
 243
 244 static int vlclua_player_get_rate(lua_State *L)
 245 {
 246     vlc_player_t *player = vlclua_get_player_internal(L);
 247
 248     vlc_player_Lock(player);
 249     float rate = vlc_player_GetRate(player);
 250     vlc_player_Unlock(player);
 251
 252     lua_pushnumber(L, rate);
 253     return 1;
 254 }
 255
 256 static int vlclua_player_set_rate(lua_State *L)
 257 {
 258     vlc_player_t *player = vlclua_get_player_internal(L);
 259
 260     float rate = luaL_checknumber(L, 1);
 261
 262     vlc_player_Lock(player);
 263     vlc_player_ChangeRate(player, rate);
 264     vlc_player_Unlock(player);
 265
 266     return 0;
 267 }
 268
 269 static int vlclua_player_increment_rate(lua_State *L)
 270 {
 271     vlc_player_t *player = vlclua_get_player_internal(L);
 272
 273     vlc_player_Lock(player);
 274     vlc_player_IncrementRate(player);
 275     vlc_player_Unlock(player);
 276
 277     return 0;
 278 }
 279
 280 static int vlclua_player_decrement_rate(lua_State *L)
 281 {
 282     vlc_player_t *player = vlclua_get_player_internal(L);
 283
 284     vlc_player_Lock(player);
 285     vlc_player_DecrementRate(player);
 286     vlc_player_Unlock(player);
 287
 288     return 0;
 289 }
 290
 291 static int vlclua_player_get_tracks_(lua_State *L,
 292                                      enum es_format_category_e cat)
 293 {
 294     vlc_player_t *player = vlclua_get_player_internal(L);
 295
 296     vlc_player_Lock(player);
 297
 298     size_t count = vlc_player_GetTrackCount(player, cat);
 299     lua_createtable(L, count, 0);
 300
 301     for (size_t i = 0; i < count; ++i)
 302     {
 303         const struct vlc_player_track *track =
 304                 vlc_player_GetTrackAt(player, cat, i);
 305         if (!track) {
 306             continue;
 307         }
 308
 309         lua_newtable(L);
 310
 311         lua_pushinteger(L, vlc_es_id_GetInputId(track->es_id));
 312         lua_setfield(L, -2, "id");
 313
 314         lua_pushstring(L, track->name);
 315         lua_setfield(L, -2, "name");
 316
 317         lua_pushboolean(L, track->selected);
 318         lua_setfield(L, -2, "selected");
 319
 320         lua_rawseti(L, -2, i + 1);
 321     }
 322
 323     vlc_player_Unlock(player);
 324
 325     return 1;
 326 }
 327
 328 static int vlclua_player_get_video_tracks(lua_State *L)
 329 {
 330     return vlclua_player_get_tracks_(L, VIDEO_ES);
 331 }
 332
 333 static int vlclua_player_get_audio_tracks(lua_State *L)
 334 {
 335     return vlclua_player_get_tracks_(L, AUDIO_ES);
 336 }
 337
 338 static int vlclua_player_get_spu_tracks(lua_State *L)
 339 {
 340     return vlclua_player_get_tracks_(L, SPU_ES);
 341 }
 342
 343 static const struct vlc_player_track *
 344 FindTrack(vlc_player_t *player, enum es_format_category_e cat, int id)
 345 {
 346     size_t count = vlc_player_GetTrackCount(player, cat);
 347     for (size_t i = 0; i < count; ++i)
 348     {
 349         const struct vlc_player_track *track =
 350                 vlc_player_GetTrackAt(player, cat, i);
 351         if (id == vlc_es_id_GetInputId(track->es_id))
 352             return track;
 353     }
 354     return NULL;
 355 }
 356
 357 static int vlclua_player_toggle_track_(lua_State *L,
 358                                        enum es_format_category_e cat,
 359                                        int id)
 360 {
 361     vlc_player_t *player = vlclua_get_player_internal(L);
 362
 363     vlc_player_Lock(player);
 364
 365     const struct vlc_player_track *track = FindTrack(player, cat, id);
 366     if (track) {
 367         if (track->selected)
 368             vlc_player_UnselectTrack(player, track);
 369         else
 370             vlc_player_SelectTrack(player, track, VLC_PLAYER_SELECT_EXCLUSIVE);
 371     }
 372
 373     vlc_player_Unlock(player);
 374
 375     return 0;
 376 }
 377
 378 static int vlclua_player_toggle_video_track(lua_State *L)
 379 {
 380     int id = luaL_checkinteger(L, 1);
 381     return vlclua_player_toggle_track_(L, VIDEO_ES, id);
 382 }
 383
 384 static int vlclua_player_toggle_audio_track(lua_State *L)
 385 {
 386     int id = luaL_checkinteger(L, 1);
 387     return vlclua_player_toggle_track_(L, AUDIO_ES, id);
 388 }
 389
 390 static int vlclua_player_toggle_spu_track(lua_State *L)
 391 {
 392     int id = luaL_checkinteger(L, 1);
 393     return vlclua_player_toggle_track_(L, SPU_ES, id);
 394 }
 395
 396 static int vlclua_player_next_video_frame(lua_State *L)
 397 {
 398     vlc_player_t *player = vlclua_get_player_internal(L);
 399
 400     vlc_player_Lock(player);
 401     vlc_player_NextVideoFrame(player);
 402     vlc_player_Unlock(player);
 403
 404     return 0;
 405 }
 406
 407 static int vlclua_player_seek_by_pos_(lua_State *L,
 408                                       enum vlc_player_whence whence)
 409 {
 410     float position = luaL_checknumber(L, 1);
 411
 412     vlc_player_t *player = vlclua_get_player_internal(L);
 413
 414     vlc_player_Lock(player);
 415     vlc_player_SeekByPos(player, position, VLC_PLAYER_SEEK_PRECISE, whence);
 416     vlc_player_Unlock(player);
 417
 418     return 0;
 419 }
 420
 421 static int vlclua_player_seek_by_pos_absolute(lua_State *L)
 422 {
 423     return vlclua_player_seek_by_pos_(L, VLC_PLAYER_WHENCE_ABSOLUTE);
 424 }
 425
 426 static int vlclua_player_seek_by_pos_relative(lua_State *L)
 427 {
 428     return vlclua_player_seek_by_pos_(L, VLC_PLAYER_WHENCE_RELATIVE);
 429 }
 430
 431 static int vlclua_player_seek_by_time_(lua_State *L,
 432                                        enum vlc_player_whence whence)
 433 {
 434     int usec = luaL_checkinteger(L, 1);
 435     vlc_tick_t time = VLC_TICK_FROM_US(usec);
 436
 437     vlc_player_t *player = vlclua_get_player_internal(L);
 438
 439     vlc_player_Lock(player);
 440     vlc_player_SeekByTime(player, time, VLC_PLAYER_SEEK_PRECISE, whence);
 441     vlc_player_Unlock(player);
 442
 443     return 0;
 444 }
 445
 446 static int vlclua_player_seek_by_time_absolute(lua_State *L)
 447 {
 448     return vlclua_player_seek_by_time_(L, VLC_PLAYER_WHENCE_ABSOLUTE);
 449 }
 450
 451 static int vlclua_player_seek_by_time_relative(lua_State *L)
 452 {
 453     return vlclua_player_seek_by_time_(L, VLC_PLAYER_WHENCE_RELATIVE);
 454 }
 455
 456 static int vlclua_player_get_audio_delay(lua_State *L)
 457 {
 458     vlc_player_t *player = vlclua_get_player_internal(L);
 459
 460     vlc_player_Lock(player);
 461     vlc_tick_t delay = vlc_player_GetAudioDelay(player);
 462     vlc_player_Unlock(player);
 463
 464     double delay_sec = secf_from_vlc_tick(delay);
 465
 466     lua_pushnumber(L, delay_sec);
 467     return 1;
 468 }
 469
 470 static int vlclua_player_set_audio_delay(lua_State *L)
 471 {
 472     vlc_player_t *player = vlclua_get_player_internal(L);
 473
 474     double delay_sec = luaL_checknumber(L, 1);
 475     vlc_tick_t delay = vlc_tick_from_sec(delay_sec);
 476
 477     vlc_player_Lock(player);
 478     vlc_player_SetAudioDelay(player, delay, VLC_PLAYER_WHENCE_ABSOLUTE);
 479     vlc_player_Unlock(player);
 480
 481     return 0;
 482 }
 483
 484 static int vlclua_player_get_subtitle_delay(lua_State *L)
 485 {
 486     vlc_player_t *player = vlclua_get_player_internal(L);
 487
 488     vlc_player_Lock(player);
 489     vlc_tick_t delay = vlc_player_GetSubtitleDelay(player);
 490     vlc_player_Unlock(player);
 491
 492     double delay_sec = secf_from_vlc_tick(delay);
 493
 494     lua_pushnumber(L, delay_sec);
 495     return 1;
 496 }
 497
 498 static int vlclua_player_set_subtitle_delay(lua_State *L)
 499 {
 500     vlc_player_t *player = vlclua_get_player_internal(L);
 501
 502     double delay_sec = luaL_checknumber(L, 1);
 503     vlc_tick_t delay = vlc_tick_from_sec(delay_sec);
 504
 505     vlc_player_Lock(player);
 506     vlc_player_SetSubtitleDelay(player, delay, VLC_PLAYER_WHENCE_ABSOLUTE);
 507     vlc_player_Unlock(player);
 508
 509     return 0;
 510 }
 511
 512 static int vlclua_input_metas_internal( lua_State *L, input_item_t *p_item )
 513 {
 514     if( !p_item )
 515     {
 516         lua_pushnil( L );
 517         return 1;
 518     }
 519
 520     lua_newtable( L );
 521     const char *psz_meta;
 522
 523     char* psz_uri = input_item_GetURI( p_item );
 524     char* psz_filename = psz_uri ? strrchr( psz_uri, '/' ) : NULL;
 525
 526     if( psz_filename && psz_filename[1] == '\0' )
 527     {
 528         /* trailing slash, get the preceeding data */
 529         psz_filename[0] = '\0';
 530         psz_filename = strrchr( psz_uri, '/' );
 531     }
 532
 533     if( psz_filename )
 534     {
 535         /* url decode, without leading slash */
 536         psz_filename = vlc_uri_decode( psz_filename + 1 );
 537     }
 538
 539     lua_pushstring( L, psz_filename );
 540     lua_setfield( L, -2, "filename" );
 541
 542     free( psz_uri );
 543
 544 #define PUSH_META( n, m ) \
 545     psz_meta = vlc_meta_Get( p_item->p_meta, vlc_meta_ ## n ); \
 546     lua_pushstring( L, psz_meta ); \
 547     lua_setfield( L, -2, m )
 548
 549     vlc_mutex_lock(&p_item->lock);
 550
 551     if (p_item->p_meta)
 552     {
 553         PUSH_META( Title, "title" );
 554         PUSH_META( Artist, "artist" );
 555         PUSH_META( Genre, "genre" );
 556         PUSH_META( Copyright, "copyright" );
 557         PUSH_META( Album, "album" );
 558         PUSH_META( TrackNumber, "track_number" );
 559         PUSH_META( Description, "description" );
 560         PUSH_META( Rating, "rating" );
 561         PUSH_META( Date, "date" );
 562         PUSH_META( Setting, "setting" );
 563         PUSH_META( URL, "url" );
 564         PUSH_META( Language, "language" );
 565         PUSH_META( NowPlaying, "now_playing" );
 566         PUSH_META( Publisher, "publisher" );
 567         PUSH_META( EncodedBy, "encoded_by" );
 568         PUSH_META( ArtworkURL, "artwork_url" );
 569         PUSH_META( TrackID, "track_id" );
 570         PUSH_META( TrackTotal, "track_total" );
 571         PUSH_META( Director, "director" );
 572         PUSH_META( Season, "season" );
 573         PUSH_META( Episode, "episode" );
 574         PUSH_META( ShowName, "show_name" );
 575         PUSH_META( Actors, "actors" );
 576
 577 #undef PUSH_META
 578
 579         char **names = vlc_meta_CopyExtraNames(p_item->p_meta);
 580         for(int i = 0; names[i]; i++)
 581         {
 582             const char *meta = vlc_meta_GetExtra(p_item->p_meta, names[i]);
 583             lua_pushstring( L, meta );
 584             lua_setfield( L, -2, names[i] );
 585             free(names[i]);
 586         }
 587         free(names);
 588     }
 589     vlc_mutex_unlock(&p_item->lock);
 590
 591     return 1;
 592 }
 593
 594 static int vlclua_input_item_stats( lua_State *L )
 595 {
 596     input_item_t *p_item = vlclua_input_item_get_internal( L );
 597     lua_newtable( L );
 598     if( p_item == NULL )
 599         return 1;
 600
 601     vlc_mutex_lock( &p_item->lock );
 602     input_stats_t *p_stats = p_item->p_stats;
 603     if( p_stats != NULL )
 604     {
 605 #define STATS_INT( n ) lua_pushinteger( L, p_item->p_stats->i_ ## n ); \
 606                        lua_setfield( L, -2, #n );
 607 #define STATS_FLOAT( n ) lua_pushnumber( L, p_item->p_stats->f_ ## n ); \
 608                          lua_setfield( L, -2, #n );
 609         STATS_INT( read_packets )
 610         STATS_INT( read_bytes )
 611         STATS_FLOAT( input_bitrate )
 612         STATS_INT( demux_read_packets )
 613         STATS_INT( demux_read_bytes )
 614         STATS_FLOAT( demux_bitrate )
 615         STATS_INT( demux_corrupted )
 616         STATS_INT( demux_discontinuity )
 617         STATS_INT( decoded_audio )
 618         STATS_INT( decoded_video )
 619         STATS_INT( displayed_pictures )
 620         STATS_INT( late_pictures )
 621         STATS_INT( lost_pictures )
 622         STATS_INT( played_abuffers )
 623         STATS_INT( lost_abuffers )
 624 #undef STATS_INT
 625 #undef STATS_FLOAT
 626     }
 627     vlc_mutex_unlock( &p_item->lock );
 628     return 1;
 629 }
 630
 631 static int vlclua_input_add_subtitle(lua_State *L, bool b_path)
 632 {
 633     vlc_player_t *player = vlclua_get_player_internal(L);
 634
 635     if (!lua_isstring(L, 1))
 636         return luaL_error( L, "vlc.player.add_subtitle() usage: (path, autoselect=false)" );
 637
 638     bool autoselect = false;
 639     if (lua_gettop(L) >= 2)
 640         autoselect = lua_toboolean(L, 2);
 641
 642     const char *sub = luaL_checkstring(L, 1);
 643     char *mrl;
 644     if (b_path)
 645         mrl = vlc_path2uri(sub, NULL);
 646
 647     const char *uri = b_path ? mrl : sub;
 648     vlc_player_Lock(player);
 649     vlc_player_AddAssociatedMedia(player, SPU_ES, uri, autoselect, true, false);
 650     vlc_player_Unlock(player);
 651     if (b_path)
 652         free(mrl);
 653
 654     return 1;
 655 }
 656
 657 static int vlclua_input_add_subtitle_path( lua_State *L )
 658 {
 659     return vlclua_input_add_subtitle( L, true );
 660 }
 661
 662 static int vlclua_input_add_subtitle_mrl( lua_State *L )
 663 {
 664     return vlclua_input_add_subtitle( L, false );
 665 }
 666
 667 /*****************************************************************************
 668  * Input items
 669  *****************************************************************************/
 670
 671 static input_item_t* vlclua_input_item_get_internal( lua_State *L )
 672 {
 673     input_item_t **pp_item = luaL_checkudata( L, 1, "input_item" );
 674     input_item_t *p_item = *pp_item;
 675
 676     if( !p_item )
 677         luaL_error( L, "script went completely foobar" );
 678
 679     return p_item;
 680 }
 681
 682 /* Garbage collection of an input_item_t */
 683 static int vlclua_input_item_delete( lua_State *L )
 684 {
 685     input_item_t **pp_item = luaL_checkudata( L, 1, "input_item" );
 686     input_item_t *p_item = *pp_item;
 687
 688     if( !p_item )
 689         return luaL_error( L, "script went completely foobar" );
 690
 691     *pp_item = NULL;
 692     input_item_Release( p_item );
 693
 694     return 1;
 695 }
 696
 697 static int vlclua_input_item_get_current( lua_State *L )
 698 {
 699     vlc_player_t *player = vlclua_get_player_internal(L);
 700
 701     vlc_player_Lock(player);
 702     input_item_t *media = vlc_player_GetCurrentMedia(player);
 703     if (media)
 704         vlclua_input_item_get(L, media);
 705     else
 706         lua_pushnil(L);
 707     vlc_player_Unlock(player);
 708
 709     return 1;
 710 }
 711
 712 static int vlclua_input_item_metas( lua_State *L )
 713 {
 714     vlclua_input_metas_internal( L, vlclua_input_item_get_internal( L ) );
 715     return 1;
 716 }
 717
 718 static int vlclua_input_item_is_preparsed( lua_State *L )
 719 {
 720     lua_pushboolean( L, input_item_IsPreparsed( vlclua_input_item_get_internal( L ) ) );
 721     return 1;
 722 }
 723
 724 static int vlclua_input_item_uri( lua_State *L )
 725 {
 726     char *uri = input_item_GetURI( vlclua_input_item_get_internal( L ) );
 727     lua_pushstring( L, uri );
 728     free( uri );
 729     return 1;
 730 }
 731
 732 static int vlclua_input_item_name( lua_State *L )
 733 {
 734     char *name = input_item_GetName( vlclua_input_item_get_internal( L ) );
 735     lua_pushstring( L, name );
 736     free( name );
 737     return 1;
 738 }
 739
 740 static int vlclua_input_item_duration( lua_State *L )
 741 {
 742     vlc_tick_t duration = input_item_GetDuration( vlclua_input_item_get_internal( L ) );
 743     lua_pushnumber( L, secf_from_vlc_tick(duration) );
 744     return 1;
 745 }
 746
 747 static int vlclua_input_item_set_meta( lua_State *L )
 748 {
 749     input_item_t *p_item = vlclua_input_item_get_internal( L );
 750     lua_settop( L, 1 + 2 ); // two arguments
 751     const char *psz_name = luaL_checkstring( L, 2 ),
 752                *psz_value = luaL_checkstring( L, 3 );
 753
 754 #define META_TYPE( n, s ) { s, vlc_meta_ ## n },
 755     static const struct
 756     {
 757         const char psz_name[15];
 758         unsigned char type;
 759     } pp_meta_types[] = {
 760         META_TYPE( Title, "title" )
 761         META_TYPE( Artist, "artist" )
 762         META_TYPE( Genre, "genre" )
 763         META_TYPE( Copyright, "copyright" )
 764         META_TYPE( Album, "album" )
 765         META_TYPE( TrackNumber, "track_number" )
 766         META_TYPE( Description, "description" )
 767         META_TYPE( Rating, "rating" )
 768         META_TYPE( Date, "date" )
 769         META_TYPE( Setting, "setting" )
 770         META_TYPE( URL, "url" )
 771         META_TYPE( Language, "language" )
 772         META_TYPE( NowPlaying, "now_playing" )
 773         META_TYPE( ESNowPlaying, "now_playing" )
 774         META_TYPE( Publisher, "publisher" )
 775         META_TYPE( EncodedBy, "encoded_by" )
 776         META_TYPE( ArtworkURL, "artwork_url" )
 777         META_TYPE( TrackID, "track_id" )
 778         META_TYPE( TrackTotal, "track_total" )
 779         META_TYPE( Director, "director" )
 780         META_TYPE( Season, "season" )
 781         META_TYPE( Episode, "episode" )
 782         META_TYPE( ShowName, "show_name" )
 783         META_TYPE( Actors, "actors" )
 784         META_TYPE( AlbumArtist, "album_artist" )
 785         META_TYPE( DiscNumber, "disc_number" )
 786         META_TYPE( DiscTotal, "disc_total" )
 787     };
 788 #undef META_TYPE
 789
 790     static_assert( sizeof(pp_meta_types)
 791                       == VLC_META_TYPE_COUNT * sizeof(pp_meta_types[0]),
 792                    "Inconsistent meta data types" );
 793     vlc_meta_type_t type = vlc_meta_Title;
 794     for( unsigned i = 0; i < VLC_META_TYPE_COUNT; i++ )
 795     {
 796         if( !strcasecmp( pp_meta_types[i].psz_name, psz_name ) )
 797         {
 798             type = pp_meta_types[i].type;
 799             input_item_SetMeta( p_item, type, psz_value );
 800             return 1;
 801         }
 802     }
 803
 804     vlc_meta_AddExtra( p_item->p_meta, psz_name, psz_value );
 805     return 1;
 806 }
 807
 808 /*****************************************************************************
 809  * Lua bindings
 810  *****************************************************************************/
 811 static const luaL_Reg vlclua_input_reg[] = {
 812     { "is_playing", vlclua_input_is_playing },
 813     { "item", vlclua_input_item_get_current },
 814     { "add_subtitle", vlclua_input_add_subtitle_path },
 815     { "add_subtitle_mrl", vlclua_input_add_subtitle_mrl },
 816     { "get_title_index", vlclua_player_get_title_index },
 817     { "get_titles_count", vlclua_player_get_titles_count },
 818     { "title_next", vlclua_player_title_next },
 819     { "title_prev", vlclua_player_title_prev },
 820     { "title_goto", vlclua_player_title_goto },
 821     { "get_chapter_index", vlclua_player_get_chapter_index },
 822     { "get_chapters_count", vlclua_player_get_chapters_count },
 823     { "chapter_next", vlclua_player_chapter_next },
 824     { "chapter_prev", vlclua_player_chapter_prev },
 825     { "chapter_goto", vlclua_player_chapter_goto },
 826     { "get_time", vlclua_player_get_time },
 827     { "get_position", vlclua_player_get_position },
 828     { "get_rate", vlclua_player_get_rate },
 829     { "set_rate", vlclua_player_set_rate },
 830     { "increment_rate", vlclua_player_increment_rate },
 831     { "decrement_rate", vlclua_player_decrement_rate },
 832     { "get_video_tracks", vlclua_player_get_video_tracks },
 833     { "get_audio_tracks", vlclua_player_get_audio_tracks },
 834     { "get_spu_tracks", vlclua_player_get_spu_tracks },
 835     { "toggle_video_track", vlclua_player_toggle_video_track },
 836     { "toggle_audio_track", vlclua_player_toggle_audio_track },
 837     { "toggle_spu_track", vlclua_player_toggle_spu_track },
 838     { "next_video_frame", vlclua_player_next_video_frame },
 839     { "seek_by_pos_absolute", vlclua_player_seek_by_pos_absolute },
 840     { "seek_by_pos_relative", vlclua_player_seek_by_pos_relative },
 841     { "seek_by_time_absolute", vlclua_player_seek_by_time_absolute },
 842     { "seek_by_time_relative", vlclua_player_seek_by_time_relative },
 843     { "get_audio_delay", vlclua_player_get_audio_delay },
 844     { "set_audio_delay", vlclua_player_set_audio_delay },
 845     { "get_subtitle_delay", vlclua_player_get_subtitle_delay },
 846     { "set_subtitle_delay", vlclua_player_set_subtitle_delay },
 847     { NULL, NULL }
 848 };
 849
 850 void luaopen_input( lua_State *L )
 851 {
 852     lua_newtable( L );
 853     luaL_register( L, NULL, vlclua_input_reg );
 854     lua_setfield( L, -2, "player" );
 855 }
 856
 857 static const luaL_Reg vlclua_input_item_reg[] = {
 858     { "is_preparsed", vlclua_input_item_is_preparsed },
 859     { "metas", vlclua_input_item_metas },
 860     { "set_meta", vlclua_input_item_set_meta },
 861     { "uri", vlclua_input_item_uri },
 862     { "name", vlclua_input_item_name },
 863     { "duration", vlclua_input_item_duration },
 864     { "stats", vlclua_input_item_stats },
 865     { "info", vlclua_input_item_info },
 866     { NULL, NULL }
 867 };
 868
 869 int vlclua_input_item_get( lua_State *L, input_item_t *p_item )
 870 {
 871     input_item_Hold( p_item );
 872     input_item_t **pp = lua_newuserdata( L, sizeof( input_item_t* ) );
 873     *pp = p_item;
 874
 875     if( luaL_newmetatable( L, "input_item" ) )
 876     {
 877         lua_newtable( L );
 878         luaL_register( L, NULL, vlclua_input_item_reg );
 879         lua_setfield( L, -2, "__index" );
 880         lua_pushcfunction( L, vlclua_input_item_delete );
 881         lua_setfield( L, -2, "__gc" );
 882     }
 883
 884     lua_setmetatable(L, -2);
 885
 886     return 1;
 887 }
 888
 889
 890 void luaopen_input_item( lua_State *L, input_item_t *item )
 891 {
 892     assert(item);
 893     vlclua_input_item_get( L, item );
 894     lua_setfield( L, -2, "item" );
 895 }