示例#1
0
文件: dv.c 项目: skoruga/vlc-shaders
static void* Raw1394EventThread( vlc_object_t *p_this )
{
    event_thread_t *p_ev = (event_thread_t *) p_this;
    access_t *p_access = (access_t *) p_ev->p_access;
    access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
    int result = 0;
    int canc = vlc_savecancel ();

    AVCPlay( p_access, p_sys->i_node );

    while( vlc_object_alive (p_sys->p_ev) )
    {
        while( ( result = poll( &(p_sys->raw1394_poll), 1, 200 ) ) < 0 )
        {
            if( !( errno == EAGAIN || errno == EINTR ) )
            {
                perror( "error: raw1394 poll" );
                msg_Err( p_access, "retrying device raw1394" );
            }
        }
        if( !vlc_object_alive (p_sys->p_ev) )
                break;
        if( result > 0 && ( ( p_sys->raw1394_poll.revents & POLLIN )
                || ( p_sys->raw1394_poll.revents & POLLPRI ) ) )
            result = raw1394_loop_iterate( p_sys->p_raw1394 );
    }

    AVCStop( p_access, p_sys->i_node );
    vlc_restorecancel (canc);
    return NULL;
}
示例#2
0
/**
 * Run the main control thread itself
 */
static void* RunControlThread ( vlc_object_t *p_this )
{
    playlist_t *p_playlist = (playlist_t*)p_this;
    /* Tell above that we're ready */
    vlc_thread_ready( p_playlist );

    vlc_object_lock( p_playlist );
    while( vlc_object_alive( p_playlist ) )
    {
        playlist_MainLoop( p_playlist );

        /* The playlist lock has been unlocked, so we can't tell if
         * someone has killed us in the meantime. Check now. */
        if( !vlc_object_alive( p_playlist ) )
            break;

        if( p_playlist->b_cant_sleep )
        {
            /* 100 ms is an acceptable delay for playlist operations */
            vlc_object_unlock( p_playlist );

            msleep( INTF_IDLE_SLEEP*2 );

            vlc_object_lock( p_playlist );
        }
        else
        {
            vlc_object_wait( p_playlist );
        }
    }
    vlc_object_unlock( p_playlist );

    playlist_LastLoop( p_playlist );
    return NULL;
}
示例#3
0
文件: alsa.c 项目: FLYKingdom/vlc
/*****************************************************************************
 * ALSAThread: asynchronous thread used to DMA the data to the device
 *****************************************************************************/
static void* ALSAThread( vlc_object_t* p_this )
{
    aout_instance_t * p_aout = (aout_instance_t*)p_this;
    struct aout_sys_t * p_sys = p_aout->output.p_sys;
    int canc = vlc_savecancel ();
    p_sys->p_status = (snd_pcm_status_t *)malloc(snd_pcm_status_sizeof());

    /* Wait for the exact time to start playing (avoids resampling) */
    vlc_mutex_lock( &p_sys->lock );
    while( !p_sys->start_date && vlc_object_alive (p_aout) )
        vlc_cond_wait( &p_sys->wait, &p_sys->lock );
    vlc_mutex_unlock( &p_sys->lock );

    if( !vlc_object_alive (p_aout) )
        goto cleanup;

    mwait( p_sys->start_date - AOUT_PTS_TOLERANCE / 4 );

    while ( vlc_object_alive (p_aout) )
    {
        ALSAFill( p_aout );
    }

cleanup:
    snd_pcm_drop( p_sys->p_snd_pcm );
    free( p_aout->output.p_sys->p_status );
    vlc_restorecancel (canc);
    return NULL;
}
示例#4
0
文件: showintf.c 项目: Kafay/vlc
/*****************************************************************************
 * RunIntf: main loop
 *****************************************************************************/
static void RunIntf( intf_thread_t *p_intf )
{
    int canc = vlc_savecancel( );

    /* Main loop */
    while( vlc_object_alive( p_intf ) )
    {
        vlc_mutex_lock( &p_intf->p_sys->lock );

        /* Notify the interfaces */
        if( p_intf->p_sys->b_triggered )
        {
            var_SetBool( p_intf->p_libvlc, "intf-show", true );
            p_intf->p_sys->b_triggered = false;
        }

        vlc_mutex_unlock( &p_intf->p_sys->lock );


        /* Take care of the video output */
        if( p_intf->p_sys->p_vout && !vlc_object_alive (p_intf->p_sys->p_vout) )
        {
            var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
                             MouseEvent, p_intf );
            var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
                             MouseEvent, p_intf );
            vlc_object_release( p_intf->p_sys->p_vout );
            p_intf->p_sys->p_vout = NULL;
        }

        if( p_intf->p_sys->p_vout == NULL )
        {
            p_intf->p_sys->p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
                                                     FIND_ANYWHERE );
            if( p_intf->p_sys->p_vout )
            {
                var_AddCallback( p_intf->p_sys->p_vout, "mouse-moved",
                                 MouseEvent, p_intf );
                var_AddCallback( p_intf->p_sys->p_vout, "mouse-button-down",
                                 MouseEvent, p_intf );
            }
        }

        /* Wait a bit */
        msleep( INTF_IDLE_SLEEP );
    }

    if( p_intf->p_sys->p_vout )
    {
        var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
                         MouseEvent, p_intf );
        var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
                         MouseEvent, p_intf );
        vlc_object_release( p_intf->p_sys->p_vout );
    }
    vlc_restorecancel( canc );
}
示例#5
0
static void LoopRequest( playlist_t *p_playlist )
{
    playlist_private_t *p_sys = pl_priv(p_playlist);
    assert( !p_sys->p_input );

    /* No input. Several cases
     *  - No request, running status -> start new item
     *  - No request, stopped status -> collect garbage
     *  - Request, running requested -> start new item
     *  - Request, stopped requested -> collect garbage
    */
    const int i_status = p_sys->request.b_request ?
                         p_sys->request.i_status : p_sys->status.i_status;

    if( i_status == PLAYLIST_STOPPED || !vlc_object_alive( p_playlist ) )
    {
        p_sys->status.i_status = PLAYLIST_STOPPED;

        if( p_sys->p_input_resource &&
            input_resource_HasVout( p_sys->p_input_resource ) )
        {
            /* XXX We can unlock if we don't issue the wait as we will be
             * call again without anything else done between the calls */
            PL_UNLOCK;

            /* input_resource_t must be manipulated without playlist lock */
            input_resource_TerminateVout( p_sys->p_input_resource );

            PL_LOCK;
        }
        else
        {
            if( vlc_object_alive( p_playlist ) )
                vlc_cond_wait( &p_sys->signal, &p_sys->lock );
        }
        return;
    }

    playlist_item_t *p_item = NextItem( p_playlist );
    if( p_item )
    {
        msg_Dbg( p_playlist, "starting playback of the new playlist item" );
        PlayItem( p_playlist, p_item );
        return;
    }

    msg_Dbg( p_playlist, "nothing to play" );
    p_sys->status.i_status = PLAYLIST_STOPPED;

    if( var_GetBool( p_playlist, "play-and-exit" ) )
    {
        msg_Info( p_playlist, "end of playlist, exiting" );
        libvlc_Quit( p_playlist->p_libvlc );
    }
}
示例#6
0
文件: video.c 项目: iamnpc/myfaplayer
static void* EncoderThread( vlc_object_t* p_this )
{
    sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_this;
    sout_stream_id_t *id = p_sys->id_video;
    picture_t *p_pic;
    int canc = vlc_savecancel ();

    while( vlc_object_alive (p_sys) && !p_sys->b_error )
    {
        block_t *p_block;

        vlc_mutex_lock( &p_sys->lock_out );
        while( p_sys->i_last_pic == p_sys->i_first_pic )
        {
            vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );
            if( !vlc_object_alive (p_sys) || p_sys->b_error ) break;
        }
        if( !vlc_object_alive (p_sys) || p_sys->b_error )
        {
            vlc_mutex_unlock( &p_sys->lock_out );
            break;
        }

        p_pic = p_sys->pp_pics[p_sys->i_first_pic++];
        p_sys->i_first_pic %= PICTURE_RING_SIZE;
        vlc_mutex_unlock( &p_sys->lock_out );

        video_timer_start( id->p_encoder );
        p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
        video_timer_stop( id->p_encoder );

        vlc_mutex_lock( &p_sys->lock_out );
        block_ChainAppend( &p_sys->p_buffers, p_block );

        vlc_mutex_unlock( &p_sys->lock_out );
        picture_Release( p_pic );
    }

    while( p_sys->i_last_pic != p_sys->i_first_pic )
    {
        p_pic = p_sys->pp_pics[p_sys->i_first_pic++];
        p_sys->i_first_pic %= PICTURE_RING_SIZE;
        picture_Release( p_pic );
    }
    block_ChainRelease( p_sys->p_buffers );

    vlc_restorecancel (canc);
    return NULL;
}
示例#7
0
/**
 * Run the main control thread itself
 */
static void *Thread ( void *data )
{
    playlist_t *p_playlist = data;
    playlist_private_t *p_sys = pl_priv(p_playlist);

    playlist_Lock( p_playlist );
    while( vlc_object_alive( p_playlist ) || p_sys->p_input )
    {
        /* FIXME: what's that ! */
        if( p_sys->b_reset_currently_playing &&
            mdate() - p_sys->last_rebuild_date > 30000 ) // 30 ms
        {
            ResetCurrentlyPlaying( p_playlist,
                                   get_current_status_item( p_playlist ) );
            p_sys->last_rebuild_date = mdate();
        }

        /* If there is an input, check that it doesn't need to die. */
        while( !LoopInput( p_playlist ) )
            vlc_cond_wait( &p_sys->signal, &p_sys->lock );

        LoopRequest( p_playlist );
    }
    playlist_Unlock( p_playlist );

    return NULL;
}
示例#8
0
/* Define the Input used.
   Add the callbacks on input
   p_input is held once here */
void InputManager::setInput( input_thread_t *_p_input )
{
    delInput();
    p_input = _p_input;
    if( p_input && !( p_input->b_dead || !vlc_object_alive (p_input) ) )
    {
        msg_Dbg( p_intf, "IM: Setting an input" );
        vlc_object_hold( p_input );
        addCallbacks();
        UpdateStatus();
        UpdateName();
        UpdateArt();
        UpdateTeletext();
        UpdateNavigation();
        UpdateVout();

        p_item = input_GetItem( p_input );
        emit rateChanged( var_GetFloat( p_input, "rate" ) );
    }
    else
    {
        p_input = NULL;
        p_item = NULL;
        assert( !p_input_vbi );
        emit rateChanged( var_InheritFloat( p_intf, "rate" ) );
    }
}
示例#9
0
/**
 * @brief Directory Monitoring thread loop
 */
void *RunMonitoringThread( void *p_this )
{
    monitoring_thread_t *p_mon = (monitoring_thread_t*) p_this;
    vlc_cond_init( &p_mon->wait );
    vlc_mutex_init( &p_mon->lock );

    var_Create( p_mon, "ml-recursive-scan", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );

    while( vlc_object_alive( p_mon ) )
    {
        vlc_mutex_lock( &p_mon->lock );

        /* Update */
        UpdateLibrary( p_mon );

        /* We wait MONITORING_DELAY seconds or wait that the media library
           signals us to do something */
        vlc_cond_timedwait( &p_mon->wait, &p_mon->lock,
                            mdate() + 1000000*MONITORING_DELAY );

        vlc_mutex_unlock( &p_mon->lock );
    }
    vlc_cond_destroy( &p_mon->wait );
    vlc_mutex_destroy( &p_mon->lock );
    return NULL;
}
示例#10
0
/*****************************************************************************
 * MonitorLibVLCDeath: Used when b_should_run_on_first_thread is set.
 *****************************************************************************/
static void * MonitorLibVLCDeath( vlc_object_t * p_this )
{
    intf_thread_t *p_intf = (intf_thread_t *)p_this;
    libvlc_int_t * p_libvlc = p_intf->p_libvlc;
    vlc_object_lock( p_libvlc );
    while(vlc_object_alive( p_libvlc ) )
    {
        if(p_intf->b_die)
        {
            vlc_object_unlock( p_libvlc );
            return NULL;
        }
        vlc_object_wait( p_libvlc );
    }
    vlc_object_unlock( p_libvlc );

    /* Someone killed libvlc */

    /* Make sure we kill all interface objects, especially
     * those that are blocking libvlc (running on main thread) */
    vlc_list_t * p_list = vlc_list_find( p_libvlc, VLC_OBJECT_INTF, FIND_CHILD );
    for( int i = 0; i < p_list->i_count; i++ )
    {
        vlc_object_t * p_intf = p_list->p_values[i].p_object;
        vlc_object_kill( p_intf );
    }
    vlc_list_release( p_list );
    return NULL;
}
示例#11
0
文件: mms.c 项目: 371816210/vlc_vlc
/*****************************************************************************
 * Open:
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    access_t *p_access = (access_t*)p_this;

    /* use specified method */
    if( *p_access->psz_access )
    {
        if( !strncmp( p_access->psz_access, "mmsu", 4 ) )
        {
            return  MMSTUOpen ( p_access );
        }
        else if( !strncmp( p_access->psz_access, "mmst", 4 ) )
        {
            return  MMSTUOpen ( p_access );
        }
        else if( !strncmp( p_access->psz_access, "mmsh", 4 ) ||
                 !strncmp( p_access->psz_access, "http", 4 ) )
        {
            return  MMSHOpen ( p_access );
        }
    }

    if( MMSTUOpen ( p_access ) )
    {
        if( !vlc_object_alive(p_access) )
            return VLC_EGENERIC;

        /* try mmsh if mmstu failed */
        return  MMSHOpen ( p_access );
    }
    return VLC_SUCCESS;
}
示例#12
0
文件: lirc.c 项目: blinry/vlc
static void Process( intf_thread_t *p_intf )
{
    for( ;; )
    {
        char *code, *c;
        if( lirc_nextcode( &code ) )
            return;

        if( code == NULL )
            return;

        while( vlc_object_alive( p_intf )
                && (lirc_code2char( p_intf->p_sys->config, code, &c ) == 0)
                && (c != NULL) )
        {
            if( !strncmp( "key-", c, 4 ) )
            {
                vlc_action_t i_key = vlc_GetActionId( c );
                if( i_key )
                    var_SetInteger( p_intf->p_libvlc, "key-action", i_key );
                else
                    msg_Err( p_intf, "Unknown hotkey '%s'", c );
            }
            else
            {
                msg_Err( p_intf, "this doesn't appear to be a valid keycombo "
                                 "lirc sent us. Please look at the "
                                 "doc/lirc/example.lirc file in VLC" );
                break;
            }
        }
        free( code );
    }
}
示例#13
0
文件: item.c 项目: cspowart/vlc
/**
 * Add an input item to a given node
 *
 * \param p_playlist the playlist to add into
 * \param p_input the input item to add
 * \param p_parent the parent item to add into
 * \param i_mode the mode used when addin
 * \param i_pos the position in the playlist where to add. If this is
 *        PLAYLIST_END the item will be added at the end of the playlist
 *        regardless of its size
 * \param b_locked TRUE if the playlist is locked
 * \return the new playlist item
 */
playlist_item_t * playlist_NodeAddInput( playlist_t *p_playlist,
                                         input_item_t *p_input,
                                         playlist_item_t *p_parent,
                                         int i_mode, int i_pos,
                                         bool b_locked )
{
    playlist_item_t *p_item;
    assert( p_input );
    assert( p_parent && p_parent->i_children != -1 );

    /* FIXME: use b_killed instead: */
    if( !vlc_object_alive(p_playlist) )
        return NULL;

    PL_LOCK_IF( !b_locked );

    p_item = playlist_ItemNewFromInput( p_playlist, p_input );
    if( p_item == NULL ) return NULL;
    AddItem( p_playlist, p_item, p_parent, i_mode, i_pos );

    GoAndPreparse( p_playlist, i_mode, p_item );

    PL_UNLOCK_IF( !b_locked );

    return p_item;
}
示例#14
0
文件: crop.c 项目: CSRedRat/vlc
/*****************************************************************************
 * Render: display previously rendered output
 *****************************************************************************
 * This function sends the currently rendered image to Crop image, waits
 * until it is displayed and switches the two rendering buffers, preparing next
 * frame.
 *****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
    picture_t *p_outpic = NULL;
    int i_plane;

    if( p_vout->p_sys->b_changed )
    {
        return;
    }

    while( ( p_outpic =
                 vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 )
           ) == NULL )
    {
        if( !vlc_object_alive (p_vout) || p_vout->b_error )
        {
            vout_DestroyPicture( p_vout->p_sys->p_vout, p_outpic );
            return;
        }

        msleep( VOUT_OUTMEM_SLEEP );
    }

    p_outpic->date = p_pic->date;
    vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );

    for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
    {
        uint8_t *p_in, *p_out, *p_out_end;
        int i_in_pitch = p_pic->p[i_plane].i_pitch;
        const int i_out_pitch = p_outpic->p[i_plane].i_pitch;
        const int i_copy_pitch = p_outpic->p[i_plane].i_visible_pitch;

        p_in = p_pic->p[i_plane].p_pixels
                /* Skip the right amount of lines */
                + i_in_pitch * ( p_pic->p[i_plane].i_visible_lines *
                                 p_vout->p_sys->i_y / p_vout->output.i_height )
                /* Skip the right amount of columns */
                + i_in_pitch * p_vout->p_sys->i_x / p_vout->output.i_width;

        p_out = p_outpic->p[i_plane].p_pixels;
        p_out_end = p_out + i_out_pitch * p_outpic->p[i_plane].i_visible_lines;

        while( p_out < p_out_end )
        {
            vlc_memcpy( p_out, p_in, i_copy_pitch );
            p_in += i_in_pitch;
            p_out += i_out_pitch;
        }
    }

    vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
    vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );

    /* The source image may still be in the cache ... parse it! */
    vlc_mutex_lock( &p_vout->p_sys->lock );
    if( p_vout->p_sys->b_autocrop )
        UpdateStats( p_vout, p_pic );
    vlc_mutex_unlock( &p_vout->p_sys->lock );
}
示例#15
0
 bool hasInput()
 {
     return p_input /* We have an input */
            && !p_input->b_dead /* not dead yet, */
            && !p_input->b_eof  /* not EOF either, */
            && vlc_object_alive (p_input); /* and the VLC object is alive */
 }
示例#16
0
/*****************************************************************************
 * Render: displays previously rendered output
 *****************************************************************************
 * This function send the currently rendered image to the internal opencv
 * filter for processing.
 *****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
    picture_t *p_outpic = NULL;
    clock_t start, finish;
    double  duration;

    while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
              == NULL )
    {
        if( !vlc_object_alive (p_vout) || p_vout->b_error )
        {   return; }
        msleep( VOUT_OUTMEM_SLEEP );
    }

    vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );

    start = clock();

    if (p_vout->p_sys->i_wrapper_output == VINPUT)  //output = input video
    {
        //This copy is a bit unfortunate but image_Convert can't write into an existing image so it is better to copy the
        //(say) 16bit YUV image here than a 32bit RGB image somehwere else.
        //It is also not that expensive in time.
        picture_Copy( p_outpic, p_pic );
        VlcPictureToIplImage( p_vout, p_pic);
        //pass the image to the internal opencv filter for processing
        if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
            p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
    }
    else    //output = processed video (NONE option not working yet)
    {
        VlcPictureToIplImage( p_vout, p_pic);
        //pass the image to the internal opencv filter for processing
        if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
            p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
        //copy the processed image into the output image
        if ((p_vout->p_sys->p_proc_image) && (p_vout->p_sys->p_proc_image->i_planes > 0))
            picture_Copy( p_outpic, p_vout->p_sys->p_proc_image );
    }

    //calculate duration
    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    if (p_vout->p_sys->i_verbosity > VERB_WARN)
        msg_Dbg( p_vout, "Render took %2.4f seconds", duration );

    ReleaseImages(p_vout);
    p_outpic->date  = p_pic->date;
    
    vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
    vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
}
static int WindowOpen( vout_window_t *pWnd, const vout_window_cfg_t *cfg )
{
    vout_window_sys_t* sys;

    vlc_mutex_lock( &skin_load.mutex );
    intf_thread_t *pIntf = skin_load.intf;
    if( pIntf )
        vlc_object_hold( pIntf );
    vlc_mutex_unlock( &skin_load.mutex );

    if( pIntf == NULL )
        return VLC_EGENERIC;

    if( !vlc_object_alive( pIntf ) ||
        !var_InheritBool( pIntf, "skinned-video") ||
        cfg->is_standalone )
    {
        vlc_object_release( pIntf );
        return VLC_EGENERIC;
    }

    sys = (vout_window_sys_t*)calloc( 1, sizeof( *sys ) );
    if( !sys )
    {
        vlc_object_release( pIntf );
        return VLC_ENOMEM;
    }

    pWnd->sys = sys;
    pWnd->sys->cfg = *cfg;
    pWnd->sys->pIntf = pIntf;
    pWnd->control = WindowControl;

    // force execution in the skins2 thread context
    CmdExecuteBlock* cmd = new CmdExecuteBlock( pIntf, VLC_OBJECT( pWnd ),
                                                WindowOpenLocal );
    CmdExecuteBlock::executeWait( CmdGenericPtr( cmd ) );

#ifdef X11_SKINS
    if( !pWnd->handle.xid )
#else
    if( !pWnd->handle.hwnd )
#endif
    {
        free( sys );
        vlc_object_release( pIntf );
        return VLC_EGENERIC;
    }

    return VLC_SUCCESS;
}
示例#18
0
static int LoopInput( playlist_t *p_playlist )
{
    playlist_private_t *p_sys = pl_priv(p_playlist);
    input_thread_t *p_input = p_sys->p_input;

    if( !p_input )
        return VLC_EGENERIC;

    if( ( p_sys->request.b_request || !vlc_object_alive( p_playlist ) ) && !p_input->b_die )
    {
        PL_DEBUG( "incoming request - stopping current input" );
        input_Stop( p_input, true );
    }

    /* This input is dead. Remove it ! */
    if( p_input->b_dead )
    {
        PL_DEBUG( "dead input" );

        PL_UNLOCK;
        /* We can unlock as we return VLC_EGENERIC (no event will be lost) */

        /* input_resource_t must be manipulated without playlist lock */
        if( !var_CreateGetBool( p_input, "sout-keep" ) )
            input_resource_TerminateSout( p_sys->p_input_resource );

        /* The DelCallback must be issued without playlist lock */
        var_DelCallback( p_input, "intf-event", InputEvent, p_playlist );

        PL_LOCK;

        p_sys->p_input = NULL;
        input_Close( p_input );

        UpdateActivity( p_playlist, -DEFAULT_INPUT_ACTIVITY );

        return VLC_EGENERIC;
    }
    /* This input is dying, let it do */
    else if( p_input->b_die )
    {
        PL_DEBUG( "dying input" );
    }
    /* This input has finished, ask it to die ! */
    else if( p_input->b_error || p_input->b_eof )
    {
        PL_DEBUG( "finished input" );
        input_Stop( p_input, false );
    }
    return VLC_SUCCESS;
}
示例#19
0
void VlcProc::manage()
{
    // Did the user request to quit vlc ?
    if( !vlc_object_alive( getIntf() ) )
    {
        // Get the instance of OSFactory
        OSFactory *pOsFactory = OSFactory::instance( getIntf() );

        // Exit the main OS loop
        pOsFactory->getOSLoop()->exit();

        return;
    }
}
示例#20
0
static void* update_request_thread( vlc_object_t *p_thread_obj )
{
    filter_t* p_filter = (filter_t*)(p_thread_obj->p_parent);
    filter_sys_t *p_sys = p_filter->p_sys;
    int canc = vlc_savecancel ();

    msg_Dbg( p_filter, "VNC update request thread started" );

    rfbFramebufferUpdateRequestMsg udr;
    udr.type = rfbFramebufferUpdateRequest;
    udr.incremental = 0;
    udr.x = 0;
    udr.y = 0;
    udr.w = htons(p_sys->i_vnc_width);
    udr.h = htons(p_sys->i_vnc_height);

    if( !write_exact(p_filter, p_sys->i_socket, (char*)&udr,
                     sz_rfbFramebufferUpdateRequestMsg) )
    {
        msg_Err( p_filter, "Could not write rfbFramebufferUpdateRequestMsg." );
        p_sys->b_continue = false;
        return NULL;
    }

    udr.incremental = 1;
    mtime_t i_poll_interval_microsec = p_sys->i_vnc_poll_interval * 1000;

    if( p_sys->b_vnc_poll)
    {
        while( vlc_object_alive( p_thread_obj ) )
        {
            msleep( i_poll_interval_microsec );
            if( !write_exact(p_filter, p_sys->i_socket, (char*)&udr,
                             sz_rfbFramebufferUpdateRequestMsg))
            {
                msg_Err( p_filter, "Could not write rfbFramebufferUpdateRequestMsg." );
                break;
            }
        }
        p_sys->b_continue = false;
    }
    else
    {
        msg_Dbg( p_filter, "VNC polling disabled." );
    }

    msg_Dbg( p_filter, "VNC update request thread ended" );
    vlc_restorecancel (canc);
    return NULL;
}
示例#21
0
/*****************************************************************************
 * Thread: thread used to DMA the data to the device
 *****************************************************************************/
static void* Thread( vlc_object_t *p_this )
{
    aout_instance_t * p_aout = (aout_instance_t*)p_this;
    aout_buffer_t * p_buffer;
    struct aout_sys_t * p_sys = p_aout->output.p_sys;
    PCMAudioPlayer * pPlayer = p_sys->pPlayer;
    int canc = vlc_savecancel ();

    while( vlc_object_alive (p_aout) )
    {
        pPlayer->WaitForBuffer();

        vlc_mutex_lock( &p_aout->output_fifo_lock );
        p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
        vlc_mutex_unlock( &p_aout->output_fifo_lock );

#define i p_sys->nNextBufferIndex
        if( p_buffer == NULL )
        {
            vlc_memset( p_aout, p_sys->ppBuffers[ i ], 0,
                                      p_sys->nBufferSize );
        }
        else
        {
            InterleaveS16( (int16_t *)p_buffer->p_buffer,
                           (int16_t *)p_sys->ppBuffers[ i ] );
            aout_BufferFree( p_buffer );
        }

        if( !pPlayer->QueueBuffer( (s16 *)p_sys->ppBuffers[ i ],
                                   p_sys->nBufferSize / 2 ) )
        {
            msg_Err( p_aout, "QueueBuffer failed" );
        }

        i = (i + 1) % p_sys->nBuffers;
#undef i
    }

    vlc_restorecancel (canc);
    return NULL;
}
示例#22
0
文件: transform.c 项目: paa/vlc
/*****************************************************************************
 * Render: displays previously rendered output
 *****************************************************************************
 * This function send the currently rendered image to Transform image, waits
 * until it is displayed and switch the two rendering buffers, preparing next
 * frame.
 *****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
    picture_t *p_outpic;

    /* This is a new frame. Get a structure from the video_output. */
    while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
              == NULL )
    {
        if( !vlc_object_alive (p_vout) || p_vout->b_error )
        {
            return;
        }
        msleep( VOUT_OUTMEM_SLEEP );
    }

    p_outpic->date = p_pic->date;

    p_vout->p_sys->pf_filter( p_vout, p_pic, p_outpic );

    vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
}
示例#23
0
// Callbacks for vout requests
static int WindowOpen( vlc_object_t *p_this )
{
    vout_window_t *pWnd = (vout_window_t *)p_this;

    vlc_mutex_lock( &skin_load.mutex );
    intf_thread_t *pIntf = skin_load.intf;
    if( pIntf )
        vlc_object_hold( pIntf );
    vlc_mutex_unlock( &skin_load.mutex );

    if( pIntf == NULL )
        return VLC_EGENERIC;

    if( !vlc_object_alive( pIntf ) ||
        !var_InheritBool( pIntf, "skinned-video") ||
        pWnd->cfg->is_standalone )
    {
        vlc_object_release( pIntf );
        return VLC_EGENERIC;
    }

    vlc_mutex_lock( &serializer );

    pWnd->handle.hwnd = VoutManager::getWindow( pIntf, pWnd );

    if( pWnd->handle.hwnd )
    {
        pWnd->control = &VoutManager::controlWindow;
        pWnd->sys = (vout_window_sys_t*)pIntf;

        vlc_mutex_unlock( &serializer );
        return VLC_SUCCESS;
    }
    else
    {
        vlc_object_release( pIntf );
        vlc_mutex_unlock( &serializer );
        return VLC_EGENERIC;
    }
}
示例#24
0
文件: visual.c 项目: paa/vlc
/*****************************************************************************
 * DoWork: convert a buffer
 *****************************************************************************
 * Audio part pasted from trivial.c
 ****************************************************************************/
static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf )
{
    filter_sys_t *p_sys = p_filter->p_sys;
    picture_t *p_outpic;
    int i;

    /* First, get a new picture */
    while( ( p_outpic = vout_CreatePicture( p_sys->p_vout, 0, 0, 3 ) ) == NULL)
    {   /* XXX: This looks like a bad idea. Don't run to me for sympathy if it
         * dead locks... */
        if( !vlc_object_alive (p_sys->p_vout) )
            return NULL;
        msleep( VOUT_OUTMEM_SLEEP );
    }

    /* Blank the picture */
    for( i = 0 ; i < p_outpic->i_planes ; i++ )
    {
        memset( p_outpic->p[i].p_pixels, i > 0 ? 0x80 : 0x00,
                p_outpic->p[i].i_visible_lines * p_outpic->p[i].i_pitch );
    }

    /* We can now call our visualization effects */
    for( i = 0; i < p_sys->i_effect; i++ )
    {
#define p_effect p_sys->effect[i]
        if( p_effect->pf_run )
        {
            p_effect->pf_run( p_effect, VLC_OBJECT(p_filter),
                              p_in_buf, p_outpic );
        }
#undef p_effect
    }

    p_outpic->date = p_in_buf->i_pts + (p_in_buf->i_length / 2);

    vout_DisplayPicture( p_sys->p_vout, p_outpic );
    return p_in_buf;
}
示例#25
0
/**
 * Gets a datagram from the network.
 * @param fd datagram file descriptor
 * @return a block or NULL on fatal error (socket dead)
 */
static block_t *rtp_dgram_recv (vlc_object_t *obj, int fd)
{
    block_t *block = block_Alloc (0xffff);
    ssize_t len;

    block_cleanup_push (block);
    do
    {
        len = net_Read (obj, fd, NULL,
                        block->p_buffer, block->i_buffer, false);

        if (((len <= 0) && fd_dead (fd)) || !vlc_object_alive (obj))
        {   /* POLLHUP -> permanent (DCCP) socket error */
            block_Release (block);
            block = NULL;
            break;
        }
    }
    while (len == -1);
    vlc_cleanup_pop ();

    return block ? block_Realloc (block, 0, len) : NULL;
}
示例#26
0
文件: access.c 项目: CSRedRat/vlc
static ssize_t AccessReadStream( access_t *access, uint8_t *buf, size_t len )
{
    demux_sys_t *sys = (demux_sys_t *)access->p_sys;
    struct pollfd ufd;
    int i_ret;

    ufd.fd = sys->i_fd;
    ufd.events = POLLIN;

    if( access->info.b_eof )
        return 0;

    /* FIXME: kill timeout and vlc_object_alive() */
    do
    {
        if( !vlc_object_alive(access) )
            return 0;

        ufd.revents = 0;
    }
    while( ( i_ret = poll( &ufd, 1, 500 ) ) == 0 );

    if( i_ret < 0 )
    {
        if( errno != EINTR )
            msg_Err( access, "poll error: %m" );
        return -1;
    }

    i_ret = v4l2_read( sys->i_fd, buf, len );
    if( i_ret == 0 )
        access->info.b_eof = true;
    else if( i_ret > 0 )
        access->info.i_pos += i_ret;

    return i_ret;
}
示例#27
0
文件: item.c 项目: cspowart/vlc
/**
 * Add an input item to the playlist node
 *
 * \param p_playlist the playlist to add into
 * \param p_input the input item to add
 * \param i_mode the mode used when adding
 * \param i_pos the position in the playlist where to add. If this is
 *        PLAYLIST_END the item will be added at the end of the playlist
 *        regardless of its size
 * \param b_playlist TRUE for playlist, FALSE for media library
 * \param b_locked TRUE if the playlist is locked
 * \return VLC_SUCCESS or VLC_ENOMEM or VLC_EGENERIC
*/
int playlist_AddInput( playlist_t* p_playlist, input_item_t *p_input,
                       int i_mode, int i_pos, bool b_playlist,
                       bool b_locked )
{
    playlist_item_t *p_item;
    /* FIXME: use b_killed instead: */
    if( !vlc_object_alive(p_playlist) ) return VLC_EGENERIC;
    if( !pl_priv(p_playlist)->b_doing_ml )
        PL_DEBUG( "adding item `%s' ( %s )", p_input->psz_name,
                                             p_input->psz_uri );

    PL_LOCK_IF( !b_locked );

    p_item = playlist_ItemNewFromInput( p_playlist, p_input );
    if( p_item == NULL ) return VLC_ENOMEM;
    AddItem( p_playlist, p_item,
             b_playlist ? p_playlist->p_playing :
                          p_playlist->p_media_library , i_mode, i_pos );

    GoAndPreparse( p_playlist, i_mode, p_item );

    PL_UNLOCK_IF( !b_locked );
    return VLC_SUCCESS;
}
示例#28
0
文件: qte.cpp 项目: Kafay/vlc
/*****************************************************************************
 * main loop of qtapplication
 *****************************************************************************/
static void* RunQtThread( vlc_object_t *p_this )
{
    event_thread_t *p_event = (event_thread_t *)p_this;
    int canc = vlc_savecancel ();
    msg_Dbg( p_event->p_vout, "RunQtThread starting" );

#ifdef NEED_QTE_MAIN
    if (qApp)
    {
        p_event->p_vout->p_sys->p_QApplication = qApp;
        p_event->p_vout->p_sys->bOwnsQApp = FALSE;
        p_event->p_vout->p_sys->p_VideoWidget = qApp->mainWidget();
        msg_Dbg( p_event->p_vout, "RunQtThread applicaton attached" );
    }
#else
    if (qApp==NULL)
    {
        int argc = 0;
        QApplication* pApp = new QApplication(argc, NULL);
        if(pApp)
        {
            p_event->p_vout->p_sys->p_QApplication = pApp;
            p_event->p_vout->p_sys->bOwnsQApp = TRUE;
        }
        QWidget* pWidget = new QWidget();
        if (pWidget)
            {
            p_event->p_vout->p_sys->p_VideoWidget = pWidget;
        }
    }
#endif
    /* signal the creation of the window */
    vlc_thread_ready( p_event );
    msg_Dbg( p_event->p_vout, "RunQtThread ready" );

    if (p_event->p_vout->p_sys->p_QApplication)
    {
        /* Set default window width and heigh to exactly preferred size. */
            QWidget *desktop = p_event->p_vout->p_sys->p_QApplication->desktop();
            p_event->p_vout->p_sys->p_VideoWidget->setMinimumWidth( 10 );
             p_event->p_vout->p_sys->p_VideoWidget->setMinimumHeight( 10 );
            p_event->p_vout->p_sys->p_VideoWidget->setBaseSize( p_event->p_vout->p_sys->i_width,
            p_event->p_vout->p_sys->i_height );
        p_event->p_vout->p_sys->p_VideoWidget->setMaximumWidth( desktop->width() );
        p_event->p_vout->p_sys->p_VideoWidget->setMaximumHeight( desktop->height() );
        /* Check on fullscreen */
        if (p_event->p_vout->b_fullscreen)
                  p_event->p_vout->p_sys->p_VideoWidget->showFullScreen();
        else
                p_event->p_vout->p_sys->p_VideoWidget->showNormal();

        p_event->p_vout->p_sys->p_VideoWidget->show();
        p_event->p_vout->p_sys->bRunning = TRUE;

#ifdef NEED_QTE_MAIN
        while(vlc_object_alive (p_event) && p_event->p_vout->p_sys->bRunning)
              {
               /* Check if we are asked to exit */
           if( !vlc_object_alive (p_event) )
               break;

               msleep(100);
            }
#else
        // run the main loop of qtapplication until someone says: 'quit'
        p_event->p_vout->p_sys->pcQApplication->exec();
#endif
    }

#ifndef NEED_QTE_MAIN
    if(p_event->p_vout->p_sys->p_QApplication)
    {
        delete p_event->p_vout->p_sys->p_VideoWidget;
        p_event->p_vout->p_sys->p_VideoWidget = NULL;
        delete p_event->p_vout->p_sys->p_QApplication;
        p_event->p_vout->p_sys->p_QApplication = NULL;
    }
#else
    p_event->p_vout->p_sys->p_VideoWidget = NULL;
#endif

    msg_Dbg( p_event->p_vout, "RunQtThread terminating" );
    vlc_restorecancel (canc);
    return NULL;
}
示例#29
0
static void Run(intf_thread_t *p_intf) {
    intf_sys_t *p_sys = p_intf->p_sys;
    input_thread_t *p_input = NULL;
    playlist_t *p_playlist = pl_Get(p_intf);
    int *pi_fd, i_listen = 0, i_err;

    p_intf->p_sys->p_playlist = p_playlist;

    for (pi_fd = p_sys->pi_socket; *pi_fd != -1; pi_fd++)
        i_listen++;
    for (; vlc_object_alive(p_intf);) {
        vlc_value_t val;
        struct pollfd fd[i_listen + 2];

        vlc_testcancel();

        if (p_input == NULL) {
            p_input = playlist_CurrentInput(p_playlist);
            if (p_input) {
                var_AddCallback(p_input, "intf-event", InputEvent, p_intf);
            }
        }
        else {
            if (p_input->b_dead || !vlc_object_alive(p_input)) {
                var_DelCallback(p_input, "intf-event", InputEvent, p_intf);
                vlc_object_release(p_input);
                p_input = NULL;
            }
        }
        memset(&fd, 0, sizeof(fd[0]) * (i_listen + 1));
        if (p_sys->i_socket == -1) {
            for (int i = 0; i < i_listen; i++) {
                fd[i].fd = p_sys->pi_socket[i];
                fd[i].events = POLLIN;
                fd[i].revents = 0;
            }
        }
        else {
            fd[0].fd = p_sys->i_wakeup[0];
            fd[0].events = POLLIN;
            fd[0].revents = 0;
            fd[1].fd = p_sys->i_socket;
            fd[1].events = POLLIN | (p_sys->i_write_length > 0 ? POLLOUT : 0);
            fd[1].revents = 0;
        }
        i_err = poll(fd, (p_sys->i_socket != -1) ? 2 : i_listen, -1);
        if (i_err < 0) {
            msg_Dbg(p_intf, "poll() failed");
            vlc_object_kill(p_intf);
            break;
        }
        if (i_err == 0)
            continue;
        if (p_sys->i_socket == -1) {
            for (int i = 0; i < i_listen; i++) {
                if (fd[i].revents & POLLIN) {
                    int client = net_AcceptSingle(VLC_OBJECT(p_intf), fd[i].fd);
                    if (client == -1)
                        continue;
                    p_sys->i_socket = client;
                    break;
                }
            }
        }
        else {
            if (fd[0].revents & POLLIN) {
                char ch;

                read(fd[0].fd, &ch, 1);
            }
            if (fd[1].revents & (POLLERR|POLLHUP|POLLNVAL)) {
                net_Close(fd[0].fd);
                p_sys->i_socket = -1;
                msg_Dbg(VLC_OBJECT(p_intf), "connection error");
                continue;
            }
            ssize_t i_len, i_test;
            if (fd[1].revents & POLLIN) {
                //msg_Dbg(VLC_OBJECT(p_intf), "poll in");
                bool b_line = false;
                while ((i_len = recv(fd[1].fd, p_sys->p_read_buffer + p_sys->i_read_offset, 1, 0)) > 0) {
                    char ch;

                    ch = p_sys->p_read_buffer[p_sys->i_read_offset];
                    switch (ch) {
                    case '\r':
                    case '\n':
                        p_sys->p_read_buffer[p_sys->i_read_offset] = '\0';
                        b_line = true;
                        break;
                    case '\0':
                        b_line = true;
                        break;
                    default:
                        break;
                    }
                    p_sys->i_read_offset++;
                    if (p_sys->i_read_offset == sizeof(p_sys->p_read_buffer) && !b_line) {
                        net_Close(p_sys->i_socket);
                        p_sys->i_socket = -1;
                        msg_Dbg(VLC_OBJECT(p_intf), "input is too long, close connection");
                        break;
                    }
                }
                if (b_line && strlen(p_sys->p_read_buffer)) {
                    p_sys->i_read_offset = 0;
                    //msg_Dbg(VLC_OBJECT(p_intf), "%s\n", p_sys->p_read_buffer);
                    ProcessCommand(p_intf, p_sys->p_read_buffer);
                }
                if(i_len == 0) {
                    net_Close(p_sys->i_socket);
                    p_sys->i_socket = -1;
                    msg_Dbg(VLC_OBJECT(p_intf), "connection is closed by client");
                }
            }
            if (fd[1].revents & POLLOUT) {
                vlc_mutex_lock(&p_sys->o_write_lock);
                if (p_sys->i_write_length) {
                    int i_first, i_second;

                    i_first = sizeof(p_sys->p_write_buffer) - p_sys->i_write_offset;
                    i_second = (p_sys->i_write_offset + p_sys->i_write_length) % sizeof(p_sys->p_write_buffer);
                    i_test = 0;
                    if (i_first >= p_sys->i_write_length)
                        i_len = send(fd[1].fd, p_sys->p_write_buffer + p_sys->i_write_offset, p_sys->i_write_length, 0);
                    else {
                        i_len = send(fd[1].fd, p_sys->p_write_buffer + p_sys->i_write_offset, i_first, 0);
                        if (i_len == i_first)
                            i_test = send(fd[1].fd, p_sys->p_write_buffer, i_second, 0);
                        if (i_test > 0)
                            i_len += i_test;
                    }
                    if (i_len > 0) {
                        p_sys->i_write_offset += i_len;
                        p_sys->i_write_offset %= sizeof(p_sys->p_write_buffer);
                        p_sys->i_write_length -= i_len;
                        if (p_sys->i_write_length == 0)
                            p_sys->i_write_offset = 0;
                    }
                }
                vlc_mutex_unlock(&p_sys->o_write_lock);
            }
        }
    }
}
示例#30
0
/*****************************************************************************
 * RunInterface: setups necessary data and give control to the interface
 *****************************************************************************/
static void* RunInterface( vlc_object_t *p_this )
{
    intf_thread_t *p_intf = (intf_thread_t *)p_this;
    vlc_value_t val, text;
    char *psz_intf;

    /* Variable used for interface spawning */
    var_Create( p_intf, "intf-add", VLC_VAR_STRING |
                VLC_VAR_HASCHOICE | VLC_VAR_ISCOMMAND );
    text.psz_string = _("Add Interface");
    var_Change( p_intf, "intf-add", VLC_VAR_SETTEXT, &text, NULL );

    val.psz_string = (char *)"rc";
    text.psz_string = (char *)_("Console");
    var_Change( p_intf, "intf-add", VLC_VAR_ADDCHOICE, &val, &text );
    val.psz_string = (char *)"telnet";
    text.psz_string = (char *)_("Telnet Interface");
    var_Change( p_intf, "intf-add", VLC_VAR_ADDCHOICE, &val, &text );
    val.psz_string = (char *)"http";
    text.psz_string = (char *)_("Web Interface");
    var_Change( p_intf, "intf-add", VLC_VAR_ADDCHOICE, &val, &text );
    val.psz_string = (char *)"logger";
    text.psz_string = (char *)_("Debug logging");
    var_Change( p_intf, "intf-add", VLC_VAR_ADDCHOICE, &val, &text );
    val.psz_string = (char *)"gestures";
    text.psz_string = (char *)_("Mouse Gestures");
    var_Change( p_intf, "intf-add", VLC_VAR_ADDCHOICE, &val, &text );

    var_AddCallback( p_intf, "intf-add", AddIntfCallback, NULL );

    do
    {
        /* Give control to the interface */
        if( p_intf->pf_run )
            p_intf->pf_run( p_intf );
        else
        {
            vlc_object_lock( p_intf );
            while( vlc_object_alive( p_intf ) )
                vlc_object_wait( p_intf );
            vlc_object_unlock( p_intf );
        }

        if( !p_intf->psz_switch_intf )
        {
            break;
        }

        /* Make sure the old interface is completely uninitialized */
        module_Unneed( p_intf, p_intf->p_module );

        /* Provide ability to switch the main interface on the fly */
        psz_intf = p_intf->psz_switch_intf;
        p_intf->psz_switch_intf = NULL;

        vlc_object_lock( p_intf );
        p_intf->b_die = false; /* FIXME */
        p_intf->b_dead = false;

        vlc_object_unlock( p_intf );

        p_intf->psz_intf = psz_intf;
        p_intf->p_module = module_Need( p_intf, "interface", psz_intf, 0 );
    }
    while( p_intf->p_module );
    return NULL;
}