wpf 推送h264视频，并显示

要在 WPF 中推送 H264 视频并显示，你可以使用 MediaElement 控件。MediaElement 控件可以播放各种视频格式，包括 H264。具体步骤如下：

1. 安装 Microsoft Expression Encoder 4。这是一个免费的软件，提供了一个 H264 编码器。

2. 使用 Expression Encoder 将你的视频编码为 H264 格式。

3. 在 WPF 界面中添加一个 MediaElement 控件。

4. 在代码中设置 MediaElement 的 Source 属性为你的 H264 视频文件的路径。

5. 调用 MediaElement 的 Play() 方法，即可开始播放视频。

以下是示例代码：

<MediaElement x:Name="mediaElement" Width="640" Height="480" />

string path = @"C:\path\to\your\h264\video.mp4";
mediaElement.Source = new Uri(path);
mediaElement.Play();

请注意，如果你的 H264 视频文件不是 MP4 格式，你可能需要使用其他的编解码器或库来将其解码为原始视频流。

相关问题

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);
        }
    }
}

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

wpf VLC推送h264类

你可以使用LibVLCSharp.WPF库来在WPF应用程序中推送h264视频流。下面是一个简单的示例代码：

using System;
using System.Windows;
using LibVLCSharp.Shared;
using LibVLCSharp.WPF;

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

        public MainWindow()
        {
            InitializeComponent();

            // 初始化LibVLC
            Core.Initialize();

            // 创建LibVLC实例和MediaPlayer实例
            _libVLC = new LibVLC();
            _mediaPlayer = new MediaPlayer(_libVLC);

            // 设置视频编码器为h264
            _mediaPlayer.Video.Encoders.Add(new VideoEncoder() { CodecName = "h264" });

            // 打开一个输出流
            var outputOptions = new[] { ":sout=#transcode{vcodec=h264}:std{access=udp,mux=ts,dst=127.0.0.1:1234}" };
            _mediaPlayer.SetMedia(new Media(_libVLC, @"C:\path\to\your\video.mp4", FromType.FromPath, outputOptions));

            // 将MediaPlayer控件添加到WPF窗口中
            MediaPlayerContainer.Child = new VideoView { MediaPlayer = _mediaPlayer };

            // 播放视频
            _mediaPlayer.Play();
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);

            // 停止播放并释放资源
            _mediaPlayer.Stop();
            _mediaPlayer.Dispose();
            _libVLC.Dispose();
        }
    }
}

这个例子使用LibVLCSharp.WPF库的`VideoView`控件来显示视频，使用`VideoEncoder`类来设置视频编码器为h264，并使用`SetMedia`方法打开一个输出流。在输出流中，我们使用了VLC的`transcode`模块来对视频进行转码，将视频编码为h264格式，并将输出流发送到localhost的UDP端口1234。你可以根据自己的需要修改输出流的参数。

注意，这个例子假设你已经将`libvlc.dll`和`libvlccore.dll`这两个文件拷贝到了你的应用程序目录下，或者将其添加到了项目的嵌入资源中。如果你还没有这两个文件，请先下载并安装VLC播放器，然后从VLC的安装目录中找到这两个文件并拷贝到你的应用程序目录下。