开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
input_manager.cpp
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：28k
源码类别：

midi

开发平台：

Unix_Linux

input_manager.cpp：源码内容
  1. /*****************************************************************************
  2.  * input_manager.cpp : Manage an input and interact with its GUI elements
  3.  ****************************************************************************
  4.  * Copyright (C) 2006-2008 the VideoLAN team
  5.  * $Id: d032f55b19d2e55dbf8a58fc3d9d70e9470c861e $
  6.  *
  7.  * Authors: Clément Stenac <zorglub@videolan.org>
  8.  *          Ilkka Ollakka  <ileoo@videolan.org>
  9.  *          Jean-Baptiste <jb@videolan.org>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24.  *****************************************************************************/
  26. #ifdef HAVE_CONFIG_H
  27. # include "config.h"
  28. #endif
  30. #include "input_manager.hpp"
  31. #include <vlc_keys.h>
  32. #include <vlc_url.h>
  34. #include <QApplication>
  36. #include <assert.h>
  38. static int ItemChanged( vlc_object_t *, const char *,
  39.                         vlc_value_t, vlc_value_t, void * );
  40. static int PLItemChanged( vlc_object_t *, const char *,
  41.                         vlc_value_t, vlc_value_t, void * );
  42. static int VolumeChanged( vlc_object_t *, const char *,
  43.                         vlc_value_t, vlc_value_t, void * );
  45. static int InputEvent( vlc_object_t *, const char *,
  46.                        vlc_value_t, vlc_value_t, void * );
  47. static int VbiEvent( vlc_object_t *, const char *,
  48.                      vlc_value_t, vlc_value_t, void * );
  51. /**********************************************************************
  52.  * InputManager implementation
  53.  **********************************************************************
  54.  * The Input Manager can be the main one around the playlist
  55.  * But can also be used for VLM dialog or similar
  56.  **********************************************************************/
  58. InputManager::InputManager( QObject *parent, intf_thread_t *_p_intf) :
  59.                            QObject( parent ), p_intf( _p_intf )
  60. {
  61.     i_old_playing_status = END_S;
  62.     oldName      = "";
  63.     artUrl       = "";
  64.     p_input      = NULL;
  65.     i_rate       = 0;
  66.     i_input_id   = 0;
  67.     b_video      = false;
  68.     timeA        = 0;
  69.     timeB        = 0;
  70.     f_cache      = -1.; /* impossible initial value, different from all */
  71. }
  73. InputManager::~InputManager()
  74. {
  75.     delInput();
  76. }
  78. /* Define the Input used.
  79.    Add the callbacks on input
  80.    p_input is held once here */
  81. void InputManager::setInput( input_thread_t *_p_input )
  82. {
  83.     delInput();
  84.     p_input = _p_input;
  85.     if( p_input && !( p_input->b_dead || !vlc_object_alive (p_input) ) )
  86.     {
  87.         msg_Dbg( p_intf, "IM: Setting an input" );
  88.         vlc_object_hold( p_input );
  89.         emit statusChanged( PLAYING_S );
  90.         UpdateName();
  91.         UpdateArt();
  92.         UpdateTeletext();
  93.         UpdateNavigation();
  94.         UpdateVout();
  95.         addCallbacks();
  96.         i_input_id = input_GetItem( p_input )->i_id;
  97.     }
  98.     else
  99.     {
  100.         p_input = NULL;
  101.         i_input_id = 0;
  102.         emit rateChanged( INPUT_RATE_DEFAULT );
  103.     }
  104. }
  106. /* delete Input if it ever existed.
  107.    Delete the callbacls on input
  108.    p_input is released once here */
  109. void InputManager::delInput()
  110. {
  111.     if( !p_input ) return;
  112.     msg_Dbg( p_intf, "IM: Deleting the input" );
  114.     delCallbacks();
  115.     i_old_playing_status = END_S;
  116.     i_input_id           = 0;
  117.     oldName              = "";
  118.     artUrl               = "";
  119.     b_video              = false;
  120.     timeA                = 0;
  121.     timeB                = 0;
  123.     vlc_object_release( p_input );
  124.     p_input = NULL;
  126.     emit positionUpdated( -1.0, 0 ,0 );
  127.     emit rateChanged( INPUT_RATE_DEFAULT ); /* TODO: Do we want this ? */
  128.     emit nameChanged( "" );
  129.     emit chapterChanged( 0 );
  130.     emit titleChanged( 0 );
  131.     emit statusChanged( END_S );
  133.     emit teletextPossible( false );
  134.     emit AtoBchanged( false, false );
  135.     emit voutChanged( false );
  136.     emit voutListChanged( NULL, 0 );
  138.     /* Reset all InfoPanels but stats */
  139.     emit artChanged( NULL );
  140.     emit infoChanged( NULL );
  141.     emit metaChanged( (input_item_t *)NULL );
  143.     emit encryptionChanged( false );
  144.     emit recordingStateChanged( false );
  145. }
  147. /* Convert the event from the callbacks in actions */
  148. void InputManager::customEvent( QEvent *event )
  149. {
  150.     int i_type = event->type();
  151.     IMEvent *ple = static_cast<IMEvent *>(event);
  153.     if( i_type == ItemChanged_Type )
  154.         UpdateMeta( ple->i_id );
  156.     if( !hasInput() )
  157.         return;
  159. #ifndef NDEBUG
  160.     if( i_type != PositionUpdate_Type &&
  161.         i_type != StatisticsUpdate_Type &&
  162.         i_type != ItemChanged_Type )
  163.         msg_Dbg( p_intf, "New Event: type %i", i_type );
  164. #endif
  166.     /* Actions */
  167.     switch( i_type )
  168.     {
  169.     case PositionUpdate_Type:
  170.         UpdatePosition();
  171.         break;
  172.     case StatisticsUpdate_Type:
  173.         UpdateStats();
  174.         break;
  175.     case ItemChanged_Type:
  176.         /* Ignore ItemChanged_Type event that does not apply to our input */
  177.         if( i_input_id == ple->i_id )
  178.         {
  179.             UpdateStatus();
  180.             // UpdateName();
  181.             UpdateArt();
  182.             /* Update duration of file */
  183.         }
  184.         break;
  185.     case ItemStateChanged_Type:
  186.         // TODO: Fusion with above state
  187.         UpdateStatus();
  188.         // UpdateName();
  189.         // UpdateNavigation(); This shouldn't be useful now
  190.         // UpdateTeletext(); Same
  191.         break;
  192.     case NameChanged_Type:
  193.         UpdateName();
  194.         break;
  195.     case MetaChanged_Type:
  196.         UpdateMeta();
  197.         UpdateName(); /* Needed for NowPlaying */
  198.         UpdateArt(); /* Art is part of meta in the core */
  199.         break;
  200.     case InfoChanged_Type:
  201.         UpdateInfo();
  202.         break;
  203.     case ItemTitleChanged_Type:
  204.         UpdateNavigation();
  205.         UpdateName(); /* Display the name of the Chapter, if exists */
  206.         break;
  207.     case ItemRateChanged_Type:
  208.         UpdateRate();
  209.         break;
  210.     case ItemEsChanged_Type:
  211.         UpdateTeletext();
  212.         // We don't do anything ES related. Why ?
  213.         break;
  214.     case ItemTeletextChanged_Type:
  215.         UpdateTeletext();
  216.         break;
  217.     case InterfaceVoutUpdate_Type:
  218.         UpdateVout();
  219.         break;
  220.     case SynchroChanged_Type:
  221.         emit synchroChanged();
  222.         break;
  223.     case CachingEvent_Type:
  224.         UpdateCaching();
  225.         break;
  226.     case BookmarksChanged_Type:
  227.         emit bookmarksChanged();
  228.         break;
  229.     case InterfaceAoutUpdate_Type:
  230.         UpdateAout();
  231.         break;
  232.     case RecordingEvent_Type:
  233.         UpdateRecord();
  234.         break;
  235.     case ProgramChanged_Type:
  236.         UpdateProgramEvent();
  237.         break;
  238.     default:
  239.         msg_Warn( p_intf, "This shouldn't happen: %i", i_type );
  240.         assert(0);
  241.     }
  242. }
  244. /* Add the callbacks on Input. Self explanatory */
  245. inline void InputManager::addCallbacks()
  246. {
  247.     var_AddCallback( p_input, "intf-event", InputEvent, this );
  248. }
  250. /* Delete the callbacks on Input. Self explanatory */
  251. inline void InputManager::delCallbacks()
  252. {
  253.     var_DelCallback( p_input, "intf-event", InputEvent, this );
  254. }
  256. /* Static callbacks for IM */
  257. static int ItemChanged( vlc_object_t *p_this, const char *psz_var,
  258.                         vlc_value_t oldval, vlc_value_t newval, void *param )
  259. {
  260.     InputManager *im = (InputManager*)param;
  262.     IMEvent *event = new IMEvent( ItemChanged_Type, newval.i_int );
  263.     QApplication::postEvent( im, event );
  264.     return VLC_SUCCESS;
  265. }
  267. static int InputEvent( vlc_object_t *p_this, const char *,
  268.                        vlc_value_t, vlc_value_t newval, void *param )
  269. {
  270.     InputManager *im = (InputManager*)param;
  271.     IMEvent *event;
  273.     switch( newval.i_int )
  274.     {
  275.     case INPUT_EVENT_STATE:
  276.         event = new IMEvent( ItemStateChanged_Type, 0 );
  277.         break;
  278.     case INPUT_EVENT_RATE:
  279.         event = new IMEvent( ItemRateChanged_Type, 0 );
  280.         break;
  281.     case INPUT_EVENT_TIMES:
  282.         event = new IMEvent( PositionUpdate_Type, 0 );
  283.         break;
  285.     case INPUT_EVENT_TITLE:
  286.     case INPUT_EVENT_CHAPTER:
  287.         event = new IMEvent( ItemTitleChanged_Type, 0 );
  288.         break;
  290.     case INPUT_EVENT_ES:
  291.         event = new IMEvent( ItemEsChanged_Type, 0 );
  292.         break;
  293.     case INPUT_EVENT_TELETEXT:
  294.         event = new IMEvent( ItemTeletextChanged_Type, 0 );
  295.         break;
  297.     case INPUT_EVENT_STATISTICS:
  298.         event = new IMEvent( StatisticsUpdate_Type, 0 );
  299.         break;
  301.     case INPUT_EVENT_VOUT:
  302.         event = new IMEvent( InterfaceVoutUpdate_Type, 0 );
  303.         break;
  304.     case INPUT_EVENT_AOUT:
  305.         event = new IMEvent( InterfaceAoutUpdate_Type, 0 );
  306.         break;
  308.     case INPUT_EVENT_ITEM_META: /* Codec MetaData + Art */
  309.         event = new IMEvent( MetaChanged_Type, 0 );
  310.         break;
  311.     case INPUT_EVENT_ITEM_INFO: /* Codec Info */
  312.         event = new IMEvent( InfoChanged_Type, 0 );
  313.         break;
  314.     case INPUT_EVENT_ITEM_NAME:
  315.         event = new IMEvent( NameChanged_Type, 0 );
  316.         break;
  318.     case INPUT_EVENT_AUDIO_DELAY:
  319.     case INPUT_EVENT_SUBTITLE_DELAY:
  320.         event = new IMEvent( SynchroChanged_Type, 0 );
  321.         break;
  323.     case INPUT_EVENT_CACHE:
  324.         event = new IMEvent( CachingEvent_Type, 0 );
  325.         break;
  327.     case INPUT_EVENT_BOOKMARK:
  328.         event = new IMEvent( BookmarksChanged_Type, 0 );
  329.         break;
  331.     case INPUT_EVENT_RECORD:
  332.         event = new IMEvent( RecordingEvent_Type, 0 );
  333.         break;
  335.     case INPUT_EVENT_PROGRAM:
  336.         /* This is for PID changes */
  337.         event = new IMEvent( ProgramChanged_Type, 0 );
  338.         break;
  340.     case INPUT_EVENT_SIGNAL:
  341.         /* This is for capture-card signals */
  342.         /* event = new IMEvent( SignalChanged_Type, 0 );
  343.         break; */
  344.     default:
  345.         event = NULL;
  346.         break;
  347.     }
  349.     if( event )
  350.         QApplication::postEvent( im, event );
  351.     return VLC_SUCCESS;
  352. }
  354. static int VbiEvent( vlc_object_t *, const char *,
  355.                      vlc_value_t, vlc_value_t, void *param )
  356. {
  357.     InputManager *im = (InputManager*)param;
  358.     IMEvent *event = new IMEvent( ItemTeletextChanged_Type, 0 );
  360.     QApplication::postEvent( im, event );
  361.     return VLC_SUCCESS;
  362. }
  364. void InputManager::UpdatePosition()
  365. {
  366.     /* Update position */
  367.     int i_length, i_time; /* Int is enough, since we store seconds */
  368.     float f_pos;
  369.     i_length = var_GetTime(  p_input , "length" ) / 1000000;
  370.     i_time = var_GetTime(  p_input , "time") / 1000000;
  371.     f_pos = var_GetFloat(  p_input , "position" );
  372.     emit positionUpdated( f_pos, i_time, i_length );
  373. }
  375. void InputManager::UpdateNavigation()
  376. {
  377.     /* Update navigation status */
  378.     vlc_value_t val; val.i_int = 0;
  380.     if( hasInput() )
  381.         var_Change( p_input, "title", VLC_VAR_CHOICESCOUNT, &val, NULL );
  383.     if( val.i_int > 0 )
  384.     {
  385.         emit titleChanged( true );
  386.         msg_Dbg( p_intf, "Title %i", val.i_int );
  387.         /* p_input != NULL since val.i_int != 0 */
  388.         val.i_int = 0;
  389.         var_Change( p_input, "chapter", VLC_VAR_CHOICESCOUNT, &val, NULL );
  390.         emit chapterChanged( (val.i_int > 0) );
  391.         msg_Dbg( p_intf, "Chapter: %i", val.i_int );
  392.     }
  393.     else
  394.         emit titleChanged( false );
  395. }
  397. void InputManager::UpdateStatus()
  398. {
  399.     /* Update playing status */
  400.     vlc_value_t val; val.i_int = 0;
  401.     var_Get( p_input, "state", &val );
  402.     if( i_old_playing_status != val.i_int )
  403.     {
  404.         i_old_playing_status = val.i_int;
  405.         emit statusChanged( val.i_int );
  406.     }
  407. }
  409. void InputManager::UpdateRate()
  410. {
  411.     /* Update Rate */
  412.     int i_new_rate = var_GetInteger( p_input, "rate");
  413.     if( i_new_rate != i_rate )
  414.     {
  415.         i_rate = i_new_rate;
  416.         /* Update rate */
  417.         emit rateChanged( i_rate );
  418.     }
  419. }
  421. void InputManager::UpdateName()
  422. {
  423.     /* Update text, name and nowplaying */
  424.     QString text;
  426.     /* Try to get the Title, then the Name */
  427.     char *psz_name = input_item_GetTitleFbName( input_GetItem( p_input ) );
  429.     /* Try to get the nowplaying */
  430.     char *psz_nowplaying =
  431.         input_item_GetNowPlaying( input_GetItem( p_input ) );
  432.     if( !EMPTY_STR( psz_nowplaying ) )
  433.     {
  434.         text.sprintf( "%s - %s", psz_nowplaying, psz_name );
  435.     }
  436.     else  /* Do it ourself */
  437.     {
  438.         char *psz_artist = input_item_GetArtist( input_GetItem( p_input ) );
  440.         if( !EMPTY_STR( psz_artist ) )
  441.             text.sprintf( "%s - %s", psz_artist, psz_name );
  442.         else
  443.             text.sprintf( "%s", psz_name );
  445.         free( psz_artist );
  446.     }
  447.     /* Free everything */
  448.     free( psz_name );
  449.     free( psz_nowplaying );
  451.     /* If we have Nothing */
  452.     if( text.isEmpty() )
  453.     {
  454.         psz_name = input_item_GetURI( input_GetItem( p_input ) );
  455.         text.sprintf( "%s", psz_name );
  456.         text = text.remove( 0, text.lastIndexOf( DIR_SEP ) + 1 );
  457.         free( psz_name );
  458.     }
  460.     if( oldName != text )
  461.     {
  462.         emit nameChanged( text );
  463.         oldName = text;
  464.     }
  465. }
  467. bool InputManager::hasAudio()
  468. {
  469.     if( hasInput() )
  470.     {
  471.         vlc_value_t val;
  472.         var_Change( p_input, "audio-es", VLC_VAR_CHOICESCOUNT, &val, NULL );
  473.         return val.i_int > 0;
  474.     }
  475.     return false;
  476. }
  478. void InputManager::UpdateTeletext()
  479. {
  480.     if( hasInput() )
  481.     {
  482.         const bool b_enabled = var_CountChoices( p_input, "teletext-es" ) > 0;
  483.         const int i_teletext_es = var_GetInteger( p_input, "teletext-es" );
  485.         /* Teletext is possible. Show the buttons */
  486.         emit teletextPossible( b_enabled );
  488.         /* If Teletext is selected */
  489.         if( b_enabled && i_teletext_es >= 0 )
  490.         {
  491.             /* Then, find the current page */
  492.             int i_page = 100;
  493.             bool b_transparent = false;
  495.             vlc_object_t *p_vbi = (vlc_object_t *)
  496.                 vlc_object_find_name( p_input, "zvbi", FIND_CHILD );
  498.             if( p_vbi )
  499.             {
  500.                 /* We deleted it (if not here, it does not harm), because
  501.                  * var_AddCallback will silently add a duplicated one */
  502.                 var_DelCallback( p_vbi, "vbi-page", VbiEvent, this );
  503.                 /* This callback is not remove explicitly, but interfaces
  504.                  * are guaranted to outlive input */
  505.                 var_AddCallback( p_vbi, "vbi-page", VbiEvent, this );
  507.                 i_page = var_GetInteger( p_vbi, "vbi-page" );
  508.                 b_transparent = !var_GetBool( p_vbi, "vbi-opaque" );
  509.                 vlc_object_release( p_vbi );
  510.             }
  511.             emit newTelexPageSet( i_page );
  512.             emit teletextTransparencyActivated( b_transparent );
  514.         }
  515.         emit teletextActivated( b_enabled && i_teletext_es >= 0 );
  516.     }
  517.     else
  518.     {
  519.         emit teletextActivated( false );
  520.         emit teletextPossible( false );
  521.     }
  522. }
  524. void InputManager::UpdateVout()
  525. {
  526.     if( hasInput() )
  527.     {
  528.         /* Get current vout lists from input */
  529.         int i_vout;
  530.         vout_thread_t **pp_vout;
  531.         if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) )
  532.         {
  533.             i_vout = 0;
  534.             pp_vout = NULL;
  535.         }
  537.         /* */
  538.         emit voutListChanged( pp_vout, i_vout );
  540.         /* */
  541.         bool b_old_video = b_video;
  542.         b_video = i_vout > 0;
  543.         if( !!b_old_video != !!b_video )
  544.             emit voutChanged( b_video );
  546.         /* Release the vout list */
  547.         for( int i = 0; i < i_vout; i++ )
  548.             vlc_object_release( (vlc_object_t*)pp_vout[i] );
  549.         free( pp_vout );
  550.     }
  551. }
  552. void InputManager::UpdateAout()
  553. {
  554.     if( hasInput() )
  555.     {
  556.         /* TODO */
  557.     }
  558. }
  559. void InputManager::UpdateCaching()
  560. {
  561.     if(!hasInput()) return;
  563.     float f_newCache = var_GetFloat ( p_input, "cache" );
  564.     if( f_newCache != f_cache )
  565.     {
  566.         f_cache = f_newCache;
  567.         /* Update rate */
  568.         emit cachingChanged( f_cache );
  569.     }
  570. }
  572. void InputManager::requestArtUpdate()
  573. {
  574.     if( hasInput() )
  575.     {
  576.         playlist_t *p_playlist = pl_Hold( p_intf );
  577.         playlist_AskForArtEnqueue( p_playlist, input_GetItem( p_input ), pl_Unlocked );
  578.         pl_Release( p_intf );
  579.     }
  580.     else
  581.     {
  582.         /* No input will signal the cover art to update,
  583.          * let's do it ourself */
  584.         UpdateArt();
  585.     }
  586. }
  588. void InputManager::UpdateArt()
  589. {
  590.     QString url;
  592.     if( hasInput() )
  593.     {
  594.         char *psz_art = input_item_GetArtURL( input_GetItem( p_input ) );
  595.         if( psz_art && !strncmp( psz_art, "file://", 7 ) &&
  596.                 decode_URI( psz_art + 7 ) )
  597. #ifdef WIN32
  598.             url = qfu( psz_art + 8 ); // Remove extra / starting on Win32.
  599. #else
  600.             url = qfu( psz_art + 7 );
  601. #endif
  602.         free( psz_art );
  603.     }
  605.     /* Update Art meta */
  606.     emit artChanged( url );
  607. }
  609. inline void InputManager::UpdateStats()
  610. {
  611.     emit statisticsUpdated( input_GetItem( p_input ) );
  612. }
  614. inline void InputManager::UpdateMeta( int id )
  615. {
  616.     emit metaChanged( id );
  617. }
  619. inline void InputManager::UpdateMeta()
  620. {
  621.     emit metaChanged( input_GetItem( p_input ) );
  622. }
  624. inline void InputManager::UpdateInfo()
  625. {
  626.     emit infoChanged( input_GetItem( p_input ) );
  627. }
  629. void InputManager::UpdateRecord()
  630. {
  631.     if( hasInput() )
  632.     {
  633.         emit recordingStateChanged( var_GetBool( p_input, "record" ) );
  634.     }
  635. }
  637. void InputManager::UpdateProgramEvent()
  638. {
  639.     if( hasInput() )
  640.     {
  641.         bool b_scrambled = var_GetBool( p_input, "program-scrambled" );
  642.         emit encryptionChanged( b_scrambled );
  643.     }
  644. }
  646. /* User update of the slider */
  647. void InputManager::sliderUpdate( float new_pos )
  648. {
  649.     if( hasInput() )
  650.         var_SetFloat( p_input, "position", new_pos );
  651. }
  653. /* User togglePlayPause */
  654. void InputManager::togglePlayPause()
  655. {
  656.     if( hasInput() )
  657.     {
  658.         int state = var_GetInteger( p_input, "state" );
  659.         state = ( state != PLAYING_S ) ? PLAYING_S : PAUSE_S;
  660.         var_SetInteger( p_input, "state", state );
  661.         emit statusChanged( state );
  662.     }
  663. }
  665. void InputManager::sectionPrev()
  666. {
  667.     if( hasInput() )
  668.     {
  669.         int i_type = var_Type( p_input, "next-chapter" );
  670.         var_SetVoid( p_input, (i_type & VLC_VAR_TYPE) != 0 ?
  671.                             "prev-chapter":"prev-title" );
  672.     }
  673. }
  675. void InputManager::sectionNext()
  676. {
  677.     if( hasInput() )
  678.     {
  679.         int i_type = var_Type( p_input, "next-chapter" );
  680.         var_SetVoid( p_input, (i_type & VLC_VAR_TYPE) != 0 ?
  681.                             "next-chapter":"next-title" );
  682.     }
  683. }
  685. void InputManager::sectionMenu()
  686. {
  687.     if( hasInput() )
  688.     {
  689.         vlc_value_t val, text;
  691.         if( var_Change( p_input, "title  0", VLC_VAR_GETLIST, &val, &text ) < 0 )
  692.             return;
  694.         /* XXX is it "Root" or "Title" we want here ?" (set 0 by default) */
  695.         int root = 0;
  696.         for( int i = 0; i < val.p_list->i_count; i++ )
  697.         {
  698.             if( !strcmp( text.p_list->p_values[i].psz_string, "Title" ) )
  699.                 root = i;
  700.         }
  701.         var_Change( p_input, "title  0", VLC_VAR_FREELIST, &val, &text );
  703.         var_SetInteger( p_input, "title  0", root );
  704.     }
  705. }
  707. /*
  708.  *  Teletext Functions
  709.  */
  711. /* Set a new Teletext Page */
  712. void InputManager::telexSetPage( int page )
  713. {
  714.     if( hasInput() )
  715.     {
  716.         const int i_teletext_es = var_GetInteger( p_input, "teletext-es" );
  718.         if( i_teletext_es >= 0 )
  719.         {
  720.             vlc_object_t *p_vbi = (vlc_object_t *) vlc_object_find_name( p_input,
  721.                         "zvbi", FIND_CHILD );
  722.             if( p_vbi )
  723.             {
  724.                 var_SetInteger( p_vbi, "vbi-page", page );
  725.                 vlc_object_release( p_vbi );
  726.                 emit newTelexPageSet( page );
  727.             }
  728.         }
  729.     }
  730. }
  732. /* Set the transparency on teletext */
  733. void InputManager::telexSetTransparency( bool b_transparentTelextext )
  734. {
  735.     if( hasInput() )
  736.     {
  737.         vlc_object_t *p_vbi = (vlc_object_t *) vlc_object_find_name( p_input,
  738.                     "zvbi", FIND_CHILD );
  739.         if( p_vbi )
  740.         {
  741.             var_SetBool( p_vbi, "vbi-opaque", !b_transparentTelextext );
  742.             vlc_object_release( p_vbi );
  743.             emit teletextTransparencyActivated( b_transparentTelextext );
  744.         }
  745.     }
  746. }
  748. void InputManager::activateTeletext( bool b_enable )
  749. {
  750.     vlc_value_t list;
  751.     vlc_value_t text;
  752.     if( hasInput() && !var_Change( p_input, "teletext-es", VLC_VAR_GETLIST, &list, &text ) )
  753.     {
  754.         if( list.p_list->i_count > 0 )
  755.         {
  756.             /* Prefer the page 100 if it is present */
  757.             int i;
  758.             for( i = 0; i < text.p_list->i_count; i++ )
  759.             {
  760.                 /* The description is the page number as a string */
  761.                 const char *psz_page = text.p_list->p_values[i].psz_string;
  762.                 if( psz_page && !strcmp( psz_page, "100" ) )
  763.                     break;
  764.             }
  765.             if( i >= list.p_list->i_count )
  766.                 i = 0;
  767.             var_SetInteger( p_input, "spu-es", b_enable ? list.p_list->p_values[i].i_int : -1 );
  768.         }
  769.         var_Change( p_input, "teletext-es", VLC_VAR_FREELIST, &list, &text );
  770.     }
  771. }
  773. void InputManager::reverse()
  774. {
  775.     if( hasInput() )
  776.     {
  777.         int i_rate = var_GetInteger( p_input, "rate" );
  778.         var_SetInteger( p_input, "rate", -i_rate );
  779.     }
  780. }
  782. void InputManager::slower()
  783. {
  784.     if( hasInput() )
  785.         var_SetVoid( p_input, "rate-slower" );
  786. }
  788. void InputManager::faster()
  789. {
  790.     if( hasInput() )
  791.         var_SetVoid( p_input, "rate-faster" );
  792. }
  794. void InputManager::littlefaster()
  795. {
  796.     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_RATE_FASTER_FINE );
  797. }
  799. void InputManager::littleslower()
  800. {
  801.     var_SetInteger( p_intf->p_libvlc, "key-action", ACTIONID_RATE_SLOWER_FINE );
  802. }
  804. void InputManager::normalRate()
  805. {
  806.     if( hasInput() )
  807.         var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT );
  808. }
  810. void InputManager::setRate( int new_rate )
  811. {
  812.     if( hasInput() )
  813.         var_SetInteger( p_input, "rate", new_rate );
  814. }
  816. void InputManager::jumpFwd()
  817. {
  818.     int i_interval = config_GetInt( p_input, "short-jump-size" );
  819.     if( i_interval > 0 )
  820.     {
  821.         mtime_t val = (mtime_t)(i_interval) * 1000000L;
  822.         var_SetTime( p_input, "time-offset", val );
  823.     }
  824. }
  826. void InputManager::jumpBwd()
  827. {
  828.     int i_interval = config_GetInt( p_input, "short-jump-size" );
  829.     if( i_interval > 0 )
  830.     {
  831.         mtime_t val = -1 *(mtime_t)(i_interval) * 1000000L;
  832.         var_SetTime( p_input, "time-offset", val );
  833.     }
  834. }
  836. void InputManager::setAtoB()
  837. {
  838.     if( !timeA )
  839.     {
  840.         timeA = var_GetTime( THEMIM->getInput(), "time"  );
  841.     }
  842.     else if( !timeB )
  843.     {
  844.         timeB = var_GetTime( THEMIM->getInput(), "time"  );
  845.         var_SetTime( THEMIM->getInput(), "time" , timeA );
  846.         CONNECT( this, positionUpdated( float, int, int ),
  847.                  this, AtoBLoop( float, int, int ) );
  848.     }
  849.     else
  850.     {
  851.         timeA = 0;
  852.         timeB = 0;
  853.         disconnect( this, SIGNAL( positionUpdated( float, int, int ) ),
  854.                     this, SLOT( AtoBLoop( float, int, int ) ) );
  855.     }
  856.     emit AtoBchanged( (timeA != 0 ), (timeB != 0 ) );
  857. }
  859. /* Function called regularly when in an AtoB loop */
  860. void InputManager::AtoBLoop( float, int i_time, int )
  861. {
  862.     if( timeB )
  863.     {
  864.         if( ( i_time >= (int)( timeB/1000000 ) )
  865.             || ( i_time < (int)( timeA/1000000 ) ) )
  866.             var_SetTime( THEMIM->getInput(), "time" , timeA );
  867.     }
  868. }
  870. /**********************************************************************
  871.  * MainInputManager implementation. Wrap an input manager and
  872.  * take care of updating the main playlist input.
  873.  * Used in the main playlist Dialog
  874.  **********************************************************************/
  875. MainInputManager * MainInputManager::instance = NULL;
  877. MainInputManager::MainInputManager( intf_thread_t *_p_intf )
  878.                  : QObject(NULL), p_intf( _p_intf )
  879. {
  880.     p_input = NULL;
  881.     im = new InputManager( this, p_intf );
  883.     var_AddCallback( THEPL, "item-change", ItemChanged, im );
  884.     var_AddCallback( THEPL, "item-current", PLItemChanged, this );
  885.     var_AddCallback( THEPL, "activity", PLItemChanged, this );
  887.     var_AddCallback( p_intf->p_libvlc, "volume-change", VolumeChanged, this );
  889.     /* Warn our embedded IM about input changes */
  890.     CONNECT( this, inputChanged( input_thread_t * ),
  891.              im, setInput( input_thread_t * ) );
  893.     /* emit check if playlist has already started playing */
  894.     IMEvent *event = new IMEvent( ItemChanged_Type,
  895.                                   var_GetInteger( THEPL, "item-current" ) );
  896.     customEvent( event );
  897.     delete event;
  898. }
  900. MainInputManager::~MainInputManager()
  901. {
  902.     if( p_input )
  903.     {
  904.        emit inputChanged( NULL );
  905.        var_DelCallback( p_input, "state", PLItemChanged, this );
  906.        vlc_object_release( p_input );
  907.     }
  909.     var_DelCallback( p_intf->p_libvlc, "volume-change", VolumeChanged, this );
  911.     var_DelCallback( THEPL, "activity", PLItemChanged, this );
  912.     var_DelCallback( THEPL, "item-change", ItemChanged, im );
  914.     var_DelCallback( THEPL, "item-current", PLItemChanged, this );
  915. }
  917. vout_thread_t* MainInputManager::getVout()
  918. {
  919.     return p_input ? input_GetVout( p_input ) : NULL;
  920. }
  922. aout_instance_t * MainInputManager::getAout()
  923. {
  924.     return p_input ? input_GetAout( p_input ) : NULL;
  925. }
  927. void MainInputManager::customEvent( QEvent *event )
  928. {
  929.     int type = event->type();
  930.     if ( type != ItemChanged_Type && type != VolumeChanged_Type )
  931.         return;
  933.     // msg_Dbg( p_intf, "New MainIM Event of type: %i", type );
  934.     if( type == VolumeChanged_Type )
  935.     {
  936.         emit volumeChanged();
  937.         return;
  938.     }
  940.     /* Should be PLItemChanged Event */
  941.     if( !p_intf->p_sys->b_isDialogProvider )
  942.     {
  943.         if( p_input && ( p_input->b_dead || !vlc_object_alive (p_input) ) )
  944.         {
  945.             emit inputChanged( p_input );
  946.             var_DelCallback( p_input, "state", PLItemChanged, this );
  947.             vlc_object_release( p_input );
  948.             p_input = NULL;
  949.             return;
  950.         }
  952.         if( !p_input )
  953.         {
  954.             p_input = playlist_CurrentInput(THEPL);
  955.             if( p_input )
  956.             {
  957.                 var_AddCallback( p_input, "state", PLItemChanged, this );
  958.                 emit inputChanged( p_input );
  959.             }
  960.         }
  961.     }
  962.     else
  963.     {
  964.         /* remove previous stored p_input */
  965.         if( p_input )
  966.         {
  967.             vlc_object_release( p_input );
  968.             p_input = NULL;
  969.         }
  970.         /* we are working as a dialogs provider */
  971.         playlist_t *p_playlist = pl_Hold( p_intf );
  972.         p_input = playlist_CurrentInput( p_playlist );
  973.         if( p_input )
  974.         {
  975.             emit inputChanged( p_input );
  976.         }
  977.         pl_Release( p_intf );
  978.     }
  979. }
  981. /* Playlist Control functions */
  982. void MainInputManager::stop()
  983. {
  984.    playlist_Stop( THEPL );
  985. }
  987. void MainInputManager::next()
  988. {
  989.    playlist_Next( THEPL );
  990. }
  992. void MainInputManager::prev()
  993. {
  994.    playlist_Prev( THEPL );
  995. }
  997. void MainInputManager::togglePlayPause()
  998. {
  999.     /* No input, play */
  1000.     if( !p_input )
  1001.         playlist_Play( THEPL );
  1002.     else
  1003.         getIM()->togglePlayPause();
  1004. }
  1006. void MainInputManager::activatePlayQuit( bool b_exit )
  1007. {
  1008.     var_SetBool( THEPL, "play-and-exit", b_exit );
  1009. }
  1011. /* Static callbacks for MIM */
  1012. static int PLItemChanged( vlc_object_t *p_this, const char *psz_var,
  1013.                         vlc_value_t oldval, vlc_value_t newval, void *param )
  1014. {
  1015.     MainInputManager *mim = (MainInputManager*)param;
  1017.     IMEvent *event = new IMEvent( ItemChanged_Type, newval.i_int );
  1018.     QApplication::postEvent( mim, event );
  1019.     return VLC_SUCCESS;
  1020. }
  1022. static int VolumeChanged( vlc_object_t *p_this, const char *psz_var,
  1023.                         vlc_value_t oldval, vlc_value_t newval, void *param )
  1024. {
  1025.     MainInputManager *mim = (MainInputManager*)param;
  1027.     IMEvent *event = new IMEvent( VolumeChanged_Type, newval.i_int );
  1028.     QApplication::postEvent( mim, event );
  1029.     return VLC_SUCCESS;
  1030. }