giftstate.c

Last change: 2008-02-03 This is the source code of KCeasy。

    }
#endif

//	msg_Dbg( p_access, "read %d / %d", (int)i_ret, (int)i_len );

    if( i_ret < 0 )
    {
        msg_Err( p_access, "read failed" );

        /* Delay a bit to avoid consuming all the CPU. This is particularly
         * useful when reading from an unconnected FIFO. */
        msleep( INPUT_ERROR_SLEEP );
    }
 
    p_access_data->i_nb_reads++;

	/* check for file size changes */
    if ( p_access->info.i_size != 0 &&
	     (p_access_data->i_nb_reads % INPUT_FSTAT_NB_READS) == 0 )
    {
	    size_t i_size;

#ifdef WIN32
		if((i_size = GetFileSize( (HANDLE)p_access_data->fd, NULL )) == 0xFFFFFFFF)
		{
            i_size = 0;
			msg_Warn( p_access, "couldn't get file size again" );
		}
#else
        struct stat stat_info;

        if ( fstat( p_access_data->fd, &stat_info ) == -1 )
        {
			i_size = 0;
            msg_Warn( p_access, "couldn't stat file again" );
        }
		else
		{
			i_size = stat_info.st_size;
		}
#endif /* WIN32 */

        if ( i_size > 0 )
        {
/*
			msg_Dbg( p_access, "resetting file size to %d", i_size );
*/
            p_access->info.i_size = i_size;
			p_access->info.i_update |= INPUT_UPDATE_SIZE;
        }
    }

    if( i_ret > 0 )
        p_access->info.i_pos += i_ret;
    else if( i_ret == 0 )
        p_access->info.b_eof = VLC_TRUE;

    return i_ret;
}

/*****************************************************************************
 * Seek: seek to a specific location in a file
 *****************************************************************************/
static int Seek( access_t * p_access, int64_t i_pos )
{
    access_sys_t *p_access_data = p_access->p_sys;

/*
	msg_Dbg( p_access, "seeking to %d", (int)i_pos );
*/

#ifdef WIN32
	SetFilePointer( (HANDLE)p_access_data->fd, i_pos,
	                0, FILE_BEGIN );
#else
    lseek( p_access_data->fd, i_pos, SEEK_SET );
#endif

    p_access->info.i_pos = i_pos;
    if( p_access->info.i_size < p_access->info.i_pos )
    {
        msg_Err( p_access, "seeking too far" );
        p_access->info.i_pos = p_access->info.i_size;
    }
    else if( p_access->info.i_pos < 0 )
    {
        msg_Err( p_access, "seeking too early" );
        p_access->info.i_pos = 0;
    }

    /* Reset eof */
    p_access->info.b_eof = VLC_FALSE;


	return VLC_SUCCESS;
}

/*****************************************************************************
 * Control:
 *****************************************************************************/
static int Control( access_t *p_access, int i_query, va_list args )
{
    access_sys_t *p_access_data = p_access->p_sys;
    vlc_bool_t   *pb_bool;
    int          *pi_int;
    int64_t      *pi_64;

    switch( i_query )
    {
        /* */
        case ACCESS_CAN_SEEK:
        case ACCESS_CAN_FASTSEEK:
            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
            *pb_bool = p_access_data->b_seekable;
            break;

        case ACCESS_CAN_PAUSE:
        case ACCESS_CAN_CONTROL_PACE:
            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
            *pb_bool = p_access_data->b_pace_control;
            break;

        /* */
        case ACCESS_GET_MTU:
            pi_int = (int*)va_arg( args, int * );
            *pi_int = 0;
            break;

        case ACCESS_GET_PTS_DELAY:
            pi_64 = (int64_t*)va_arg( args, int64_t * );
            *pi_64 = (int64_t)var_GetInteger( p_access, "file-caching" ) * I64C(1000);
            break;
        /* */
        case ACCESS_SET_PAUSE_STATE:
            /* Nothing to do */
            break;

        case ACCESS_GET_TITLE_INFO:
        case ACCESS_SET_TITLE:
        case ACCESS_SET_SEEKPOINT:
        case ACCESS_SET_PRIVATE_ID_STATE:
            return VLC_EGENERIC;

        default:
            msg_Err( p_access, "unimplemented query in control" );
            return VLC_EGENERIC;

    }
    return VLC_SUCCESS;
}

/*****************************************************************************
 * OpenMediaFile: Open media file
 *****************************************************************************/
static int OpenMediaFile( access_t * p_access, char *psz_mediafile )
{
    access_sys_t *p_access_data = p_access->p_sys;
#ifdef WIN32
	OSVERSIONINFO osvi;
	DWORD dw_share_flags;
	size_t i_size;
#endif
	

#ifdef WIN32
	dw_share_flags = FILE_SHARE_READ | FILE_SHARE_WRITE;

	/* check if we have  FILE_SHARE_DELETE */
	memset (&osvi, 0, sizeof(OSVERSIONINFO));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	if (GetVersionEx (&osvi))
	{
		if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
		{
			p_access_data->b_manual_delete = 0;
			dw_share_flags |= FILE_SHARE_DELETE;
		}
	}

    p_access_data->fd = CreateFile( psz_mediafile,
	                                GENERIC_READ,
	                                dw_share_flags, NULL,
	                                OPEN_EXISTING,
	                                FILE_ATTRIBUTE_NORMAL,
	                                NULL );

    if ( p_access_data->fd == INVALID_HANDLE_VALUE )
    {
        return VLC_EGENERIC;
    }

	/* Set size again since the stat in Open() doesn't always work correctly
	 * when the file is being written to.
	 */
	i_size = GetFileSize( (HANDLE)p_access_data->fd, NULL );
	if(i_size != 0xFFFFFFFF)
	{
		msg_Dbg( p_access, "resetting file size: %d", i_size );

		p_access->info.i_size = i_size;
		p_access->info.i_update |= INPUT_UPDATE_SIZE;
	}

#else

    p_access_data->fd = open( psz_mediafile, O_NONBLOCK);

    if ( p_access_data->fd == -1 )
    {
        return VLC_EGENERIC;
    }
#endif

	return VLC_SUCCESS;
}

/*****************************************************************************
 * ReadStateFile: Reads data from giFT state file
 *****************************************************************************/
static char * ReadStateFile( access_t * p_access, char *psz_statefile )
{
    char *psz_mediafile;

	/* check that this is a .state file */
	if ( strlen(psz_statefile) < 8 ||
	     strcasecmp (psz_statefile + strlen( psz_statefile ) - 6, ".state") != 0 )
	{
        return NULL;
	}

	/* get path from state file */
	if(!(psz_mediafile = malloc (sizeof (char) * MAX_PATH)))
	{
        msg_Err( p_access, "out of memory" );
		return NULL;
	}

#ifdef WIN32
	if (GetPrivateProfileString( "transfer", "path", "", psz_mediafile, MAX_PATH,
	                             psz_statefile) == 0)
	{
        msg_Err( p_access, "invalid state file %s", psz_statefile );
		free (psz_mediafile);
        return NULL;
	}
#else
# error "state file reading not implemented"
#endif

	return psz_mediafile;
}

/*****************************************************************************
 * GetDemuxer: Get the right demuxer from file name
 *****************************************************************************/
static char * GetDemuxer( access_t * p_access, char *psz_mediafile )
{
    char *psz_extension;
	char *psz_demuxer = NULL;

	if (!(psz_extension = strrchr (psz_mediafile, '.')))
	{
        msg_Dbg( p_access, "no extension in file %s", psz_mediafile );
		return NULL;
	}

	/* skip '.' */
	psz_extension++;

	if (!strcasecmp (psz_extension, "mp3"))
	{
		psz_demuxer = strdup ("mp3");
	}
	else if (!strcasecmp (psz_extension, "aac"))
	{
		psz_demuxer = strdup ("aac");
	}

	return psz_demuxer;
}