C# 如何在WinPhone上获取视频文件列表？

我想从收集的视频中获取视频文件列表（我建议从音频+视频中心）。 我尝试使用MediaLibrary（Microsoft.Xna），但我可以看到音频相册和歌曲，而不是视频

你能帮帮我吗

---

谢谢大家!

不幸的是，目前无法从媒体库访问视频

---

请参阅支持的操作。

尝试SmoothStreamingMediaElement for audio and video，希望对您有所帮助

XAML

<Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="0.90*"/>
            <RowDefinition Height="0.10*"/>
        </Grid.RowDefinitions>
        <SSME:SmoothStreamingMediaElement x:Name="video" Grid.Row="0" />
        <!--TitlePanel contains the name of the application and page title-->

        <StackPanel Orientation="Horizontal" Grid.Row="1">

            <Button   x:Name="PlayButton" Width="150" Click="PlayButton_Click"  Loaded="PlayButton_Loaded"/>
            <Button   x:Name="StopButton" Content="Stop" Width="100" Click="StopButton_Click" />

            <TextBlock x:Name="status"/>
            <TextBlock x:Name="currentBitrate"/>

        </StackPanel>

        <!--ContentPanel - place additional content here-->
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0"></Grid>
    </Grid>

C#代码：

 public partial class VIdeoStraming : PhoneApplicationPage
    {
        string VideoUrl,StreamingUrl;
        public VIdeoStraming()
        {
            InitializeComponent();
        }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            VideoUrl = this.NavigationContext.QueryString["parameter0"];
            string Manifest="/Manifest";
            StreamingUrl = VideoUrl + Manifest;                     
        }

        private void PlayButton_Click(object sender, RoutedEventArgs e)
        {
            //Monitor the state of the content to determine the right action to take on this button being clicked
            //and then change the text to reflect the next action
            switch (video.CurrentState)
            {
                case SmoothStreamingMediaElementState.Playing:
                    video.Pause();
                    PlayButton.Content = "Play";
                    break;
                case SmoothStreamingMediaElementState.Stopped:
                case SmoothStreamingMediaElementState.Paused:
                    video.Play();
                    PlayButton.Content = "Pause";
                    break;
            }
        }

        private void PlayButton_Loaded(object sender, RoutedEventArgs e)
        {
            switch (video.AutoPlay)
            {
                case false:
                    PlayButton.Content = "Play";
                    break;
                case true:
                    PlayButton.Content = "Pause";
                    break;
            }
        }

        private void StopButton_Click(object sender, RoutedEventArgs e)
        {

            //This should simply stop the playback

                video.Stop();
                //We should also reflect the chang on the play button
                PlayButton.Content = "Play";

        }

        private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
        {

            video.CurrentStateChanged += new RoutedEventHandler(video_CurrentStateChanged);
            video.PlaybackTrackChanged += new EventHandler<Microsoft.Web.Media.SmoothStreaming.TrackChangedEventArgs>(video_PlaybackTrackChanged);
            //video.SmoothStreamingSource = new Uri("http://64.120.251.114:1945/live/sharedobjects/layoutvideo/mp4:1311370468970.MP4/Manifest");
            video.SmoothStreamingSource = new Uri(StreamingUrl);
            video.ManifestReady += new EventHandler<EventArgs>(video_ManifestReady);
        }

        //when use in mobile device
        void video_ManifestReady(object sender, EventArgs e)
        {
            SmoothStreamingMediaElement ssme = sender as SmoothStreamingMediaElement;

            if (ssme == null)
            {
                return;
            }

            // Select the highest band of tracks which all have the same resolution.
            // maxMobileBitrate depends on the encoding settings
            const ulong maxMobileBitrate = 1000000;
            foreach (SegmentInfo segment in ssme.ManifestInfo.Segments)
            {
                foreach (StreamInfo streamInfo in segment.AvailableStreams)
                {
                    if (MediaStreamType.Video == streamInfo.Type)
                    {
                        List<TrackInfo> widestBand = new List<TrackInfo>();
                        List<TrackInfo> currentBand = new List<TrackInfo>();
                        ulong lastHeight = 0;
                        ulong lastWidth = 0;
                        ulong index = 0;

                        foreach (TrackInfo track in streamInfo.AvailableTracks)
                        {
                            index += 1;

                            string strMaxWidth;
                            string strMaxHeight;
                            // If can't find width/height, choose only the top bitrate.
                            ulong ulMaxWidth = index;
                            // If can't find width/height, choose only the top bitrate.
                            ulong ulMaxHeight = index;
                            // V2 manifests require "MaxWidth", while v1 manifests used "Width".
                            if (track.Attributes.TryGetValue("MaxWidth", out strMaxWidth) ||
                                track.Attributes.TryGetValue("Width", out strMaxWidth))
                            {
                                ulong.TryParse(strMaxWidth, out ulMaxWidth);
                            }

                            if (track.Attributes.TryGetValue("MaxHeight", out strMaxHeight) ||
                                track.Attributes.TryGetValue("Height", out strMaxHeight))
                            {
                                ulong.TryParse(strMaxHeight, out ulMaxHeight);
                            }

                            if (ulMaxWidth != lastWidth ||
                                ulMaxHeight != lastHeight)
                            {
                                // Current band is now finished, check if it is the widest.
                                // If same size, current band preferred over previous
                                // widest, because it will be of higher bitrate.
                                if (currentBand.Count >= widestBand.Count)
                                {
                                    //  A new widest band:
                                    widestBand = currentBand;
                                    currentBand = new List<TrackInfo>();
                                }
                            }

                            if (track.Bitrate > maxMobileBitrate)
                            {
                                break;
                            }

                            // Current track always gets added to current band.
                            currentBand.Add(track);
                            lastWidth = ulMaxWidth;
                            lastHeight = ulMaxHeight;
                        }

                        if (0 == widestBand.Count &&
                            0 == currentBand.Count)
                        {
                            // Lowest bitrate band is > maxMobileBitrate.
                            widestBand.Add(streamInfo.AvailableTracks[0]);
                        }
                        else if (currentBand.Count >= widestBand.Count)
                        {
                            // Need to check the last band which was constructed.
                            Debug.Assert(currentBand.Count > 0);
                            widestBand = currentBand; // Winner by default.
                        }

                        Debug.Assert(widestBand.Count >= 1);
                        streamInfo.RestrictTracks(widestBand);
                    }
                }
            }

        }
        void video_PlaybackTrackChanged(object sender, Microsoft.Web.Media.SmoothStreaming.TrackChangedEventArgs e)
        {
            currentBitrate.Text = e.NewTrack.Bitrate.ToString();
        }

        void video_CurrentStateChanged(object sender, RoutedEventArgs e)
        {
            status.Text = video.CurrentState.ToString();
        }

        private void imghdrleft_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            NavigationService.GoBack();
        }

        private void imghdrright_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            NavigationService.Navigate(new Uri("/Planet41VIew/Settings.xaml", UriKind.RelativeOrAbsolute));
        }
    }

公共部分类录像：PhoneApplicationPage
{
字符串VideoUrl，StreamingUrl；
公共录像带
{
初始化组件（）；
}
受保护的覆盖无效OnNavigatedTo（System.Windows.Navigation.NavigationEventArgs e）
{
基地。导航到（e）；
VideoUrl=this.NavigationContext.QueryString[“parameter0”]；
字符串Manifest=“/Manifest”；
StreamingUrl=视频URL+清单；
}
私有void播放按钮（对象发送者，路由目标e）
{
//监视内容的状态，以确定单击此按钮时要采取的正确操作
//然后更改文本以反映下一个操作
开关（视频.CurrentState）
{
case SmoothStreamingMediaElementState.播放：
video.Pause（）；
PlayButton.Content=“Play”；
打破
案例SmoothStreamingMediaElementState。已停止：
案例SmoothStreamingMediaElementState。已暂停：
video.Play（）；
PlayButton.Content=“暂停”；
打破
}
}
已加载专用void播放按钮（对象发送器，路由目标e）
{
开关（视频自动播放）
{
案例错误：
PlayButton.Content=“Play”；
打破
大小写正确：
PlayButton.Content=“暂停”；
打破
}
}
私有无效停止按钮\单击（对象发送者，路由目标）
{
//这应该只是停止播放
video.Stop（）；
//我们还应该在播放按钮上反映变化
PlayButton.Content=“Play”；
}
已加载专用void PhoneApplicationPage_（对象发送方，路由目标）
{
video.CurrentStateChanged+=新路由EventHandler（video\u CurrentStateChanged）；
video.PlaybackTrackChanged+=新事件处理程序（video\u PlaybackTrackChanged）；
//video.SmoothStreamingSource=新Uri（“http://64.120.251.114:1945/live/sharedobjects/layoutvideo/mp4:1311370468970.MP4/Manifest");
video.SmoothStreamingSource=新Uri（StreamingUrl）；
video.ManifestReady+=新事件处理程序（video_ManifestReady）；
}
//在移动设备中使用时
void video_ManifestReady（对象发送方，事件参数e）
{
SmoothStreamingMediaElement ssme=发送方作为SmoothStreamingMediaElement；
if（ssme==null）
{
返回；
}
//选择所有具有相同分辨率的轨迹的最高波段。
//MaxMobileBrate取决于编码设置
const ulong maxMobileBitrate=1000000；
foreach（ssme.ManifestInfo.Segments中的SegmentInfo段）
{
foreach（段中的StreamInfo StreamInfo.AvailableStreams）
{
如果（MediaStreamType.Video==streamInfo.Type）
{
列表宽度带=新列表（）；
List currentBand=新列表（）；
ulong lastHeight=0；
ulong lastWidth=0；
乌龙指数=0；
foreach（streamInfo.AvailableTracks中的TrackInfo轨迹）
{
指数+=1；
字符串strMaxWidth；
字符串strMaxHeight；
//如果找不到宽度/高度，请仅选择最高比特率。
ulong ulMaxWidth=索引；
//如果找不到宽度/高度，请仅选择最高比特率。
ulong ulMaxHeight=指数；
//V2清单需要“MaxWidth”，而v1清单使用“Width”。
if（track.Attributes.TryGetValue（“MaxWidth”，out strMaxWidth）||
track.Attributes.TryGetValue（“宽度”，out strMaxWidth））
{
ulong.TryParse（strMaxWidth，out-ulMaxWidth）；
}
if（track.Attributes.TryGetValue（“MaxHeight”，out strMaxHeight）||
track.Attributes.TryGetValue（“高度”，超出标准高度））
{
乌龙锥虫（标准高度，超标准高度）；
}
如果（ulMaxWidth！=lastWidth||
ulMaxHeight！=最后高度）
{
//当前频带现在已完成，请检查它是否最宽。
//如果尺寸相同，则当前波段优先于前一波段
//最宽，因为它将具有更高的比特率。
如果（currentBand.Count>=宽频带.Count）
{