wpf 显示视频mp4

要在WPF应用程序中显示视频MP4，你可以使用MediaElement控件。它是一个内置的控件，用于媒体播放，可以轻松地将MP4文件嵌入到你的应用程序中。

以下是一个简单的示例，演示如何在WPF中使用MediaElement控件来显示MP4视频：

<MediaElement Source="video.mp4" Width="640" Height="480" />

在这个示例中，我们将视频文件命名为“video.mp4”，并将其放置在应用程序的根目录中。我们还设置了MediaElement控件的宽度和高度，以使视频正确缩放和显示。

你可以使用MediaElement控件的其他属性来自定义视频播放，例如控制音量、播放速度、重复播放等。

希望这可以帮助你开始在WPF中显示MP4视频。

相关问题

wpf vlcH264推送并显示视频

要在 WPF 应用程序中使用 VLC 来推送和显示 H264 视频，您可以使用 LibVLCSharp 库来实现。以下是一些基本步骤：

1. 安装 LibVLCSharp NuGet 包。
2. 在 WPF 窗口中添加一个名为“VideoView”的控件。
3. 在代码中，实例化一个名为“LibVLC”的对象，并将其附加到“VideoView”控件。
4. 创建一个名为“Media”的对象，该对象包含您要推送和显示的视频的 URL。
5. 实例化一个名为“MediaPlayer”的对象，并将其与“LibVLC”对象和“Media”对象一起使用。
6. 调用“MediaPlayer”的“Play”方法以开始播放视频。

以下是示例代码，可以帮助您入门：

using LibVLCSharp.Shared;
using System.Windows;

namespace WpfVlcH264
{
    public partial class MainWindow : Window
    {
        private LibVLC _libVLC;
        private MediaPlayer _mediaPlayer;

        public MainWindow()
        {
            InitializeComponent();

            Core.Initialize();

            _libVLC = new LibVLC();
            videoView.MediaPlayer = new MediaPlayer(_libVLC);
            _mediaPlayer = videoView.MediaPlayer;

            var media = new Media(_libVLC, "http://example.com/myvideo.mp4", FromType.FromLocation);
            _mediaPlayer.Play(media);
        }
    }
}

请注意，这只是一个基本示例。您需要根据您的确切需求进行更改和配置。您还需要确保您的 VLC 安装支持 H264 编解码器。

wpf 推送h264、h265视频，并显示视频

在 WPF 中推送 H264 或 H265 视频并显示，你可以使用 MediaElement 控件和 FFmpeg 库。

具体步骤如下：

1. 下载 FFmpeg 库。你可以从官网（https://ffmpeg.org/download.html）下载最新版本的 FFmpeg 库。

2. 将 FFmpeg 库中的 `ffmpeg.dll`、`avcodec-XX.dll`、`avformat-XX.dll`、`avutil-XX.dll`、`swscale-XX.dll` 文件复制到你的项目中，并设置这些文件的“复制到输出目录”属性为“始终复制”。

3. 在代码中使用 FFmpeg 库来读取 H264 或 H265 视频文件，并将视频帧渲染到 WPF 界面中的 Image 控件中。

以下是示例代码：

<Grid>
    <Image x:Name="image" Width="640" Height="480" />
</Grid>

using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using FFmpeg.AutoGen;

namespace WpfApp
{
    public partial class MainWindow : Window
    {
        private AVFormatContext* _formatContext;
        private AVCodecContext* _codecContext;
        private AVFrame* _frame;
        private AVFrame* _frameRgb;
        private SwsContext* _imgConvertContext;
        private IntPtr _buffer;
        private Bitmap _bitmap;
        private readonly object _lock = new object();
        private bool _isPlaying;

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            ffmpeg.av_register_all();
            ffmpeg.avcodec_register_all();

            string path = @"C:\path\to\your\h264\video.mp4";

            AVDictionary* options = null;
            ffmpeg.av_dict_set(&options, "rtsp_transport", "tcp", 0);
            ffmpeg.av_dict_set(&options, "stimeout", "5000000", 0);

            int errorCode = ffmpeg.avformat_open_input(&_formatContext, path, null, &options);
            if (errorCode < 0)
            {
                MessageBox.Show($"Could not open input file: {errorCode}");
                return;
            }

            errorCode = ffmpeg.avformat_find_stream_info(_formatContext, null);
            if (errorCode < 0)
            {
                MessageBox.Show($"Could not find stream information: {errorCode}");
                return;
            }

            AVCodec* codec = null;
            int streamIndex = ffmpeg.av_find_best_stream(_formatContext, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
            if (streamIndex < 0)
            {
                MessageBox.Show($"Could not find video stream: {streamIndex}");
                return;
            }

            _codecContext = ffmpeg.avcodec_alloc_context3(codec);
            if (_codecContext == null)
            {
                MessageBox.Show("Could not allocate codec context");
                return;
            }

            errorCode = ffmpeg.avcodec_parameters_to_context(_codecContext, _formatContext->streams[streamIndex]->codecpar);
            if (errorCode < 0)
            {
                MessageBox.Show($"Could not copy codec parameters: {errorCode}");
                return;
            }

            errorCode = ffmpeg.avcodec_open2(_codecContext, codec, null);
            if (errorCode < 0)
            {
                MessageBox.Show($"Could not open codec: {errorCode}");
                return;
            }

            _frame = ffmpeg.av_frame_alloc();
            _frameRgb = ffmpeg.av_frame_alloc();

            int bufferLength = ffmpeg.av_image_get_buffer_size(AVPixelFormat.AV_PIX_FMT_BGR24, _codecContext->width, _codecContext->height, 1);
            _buffer = Marshal.AllocHGlobal(bufferLength);

            ffmpeg.av_image_fill_arrays(_frameRgb->data, _frameRgb->linesize, (byte*)_buffer, AVPixelFormat.AV_PIX_FMT_BGR24, _codecContext->width, _codecContext->height, 1);

            _imgConvertContext = ffmpeg.sws_getContext(_codecContext->width, _codecContext->height, _codecContext->pix_fmt, _codecContext->width, _codecContext->height, AVPixelFormat.AV_PIX_FMT_BGR24, ffmpeg.SWS_BICUBIC, null, null, null);

            _bitmap = new Bitmap(_codecContext->width, _codecContext->height, _frameRgb->linesize[0], System.Drawing.Imaging.PixelFormat.Format24bppRgb, _buffer);

            _isPlaying = true;
            _ = ReadFramesAsync();
        }

        private async Task ReadFramesAsync()
        {
            AVPacket packet;
            ffmpeg.av_init_packet(&packet);

            while (_isPlaying && ffmpeg.av_read_frame(_formatContext, &packet) == 0)
            {
                if (packet.stream_index == _codecContext->stream_index)
                {
                    int errorCode = ffmpeg.avcodec_send_packet(_codecContext, &packet);
                    if (errorCode < 0)
                    {
                        MessageBox.Show($"Error sending packet to decoder: {errorCode}");
                        break;
                    }

                    while (true)
                    {
                        errorCode = ffmpeg.avcodec_receive_frame(_codecContext, _frame);
                        if (errorCode == ffmpeg.AVERROR(ffmpeg.EAGAIN) || errorCode == ffmpeg.AVERROR_EOF)
                        {
                            break;
                        }
                        else if (errorCode < 0)
                        {
                            MessageBox.Show($"Error receiving frame from decoder: {errorCode}");
                            return;
                        }

                        ffmpeg.sws_scale(_imgConvertContext, _frame->data, _frame->linesize, 0, _codecContext->height, _frameRgb->data, _frameRgb->linesize);

                        lock (_lock)
                        {
                            _bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
                            BitmapSource bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(_bitmap.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
                            image.Source = bitmapSource;
                        }

                        await Task.Delay(1);
                    }
                }

                ffmpeg.av_packet_unref(&packet);
            }
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            _isPlaying = false;

            Marshal.FreeHGlobal(_buffer);

            ffmpeg.sws_freeContext(_imgConvertContext);

            ffmpeg.av_frame_free(&_frame);
            ffmpeg.av_frame_free(&_frameRgb);

            ffmpeg.avcodec_close(_codecContext);
            ffmpeg.avcodec_free_context(&_codecContext);

            ffmpeg.avformat_close_input(&_formatContext);
            ffmpeg.avformat_free_context(_formatContext);
        }
    }
}

请注意，这只是一个简单的示例，实际应用中可能需要根据视频文件的具体情况进行更复杂的处理。