C# 使用SDL2实现Mp4文件播放音视频操作

播放音视频的关键：视频的格式是H264，音频的格式是AAC。使用ffmpeg探测流的方式来实现音视频流的解码播放。

数据处理逻辑：H264->YUV AAC->PCM。

SDL2工具类

using SDL2;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks; 
namespace CvNetVideo
{
 public unsafe class SDLHelper
 {
  private IntPtr screen;
  private IntPtr sdlrenderer;
  private IntPtr sdltexture;
  SDL.SDL_Rect sdlrect;
  SDL.SDL_Event sdlevent;
  bool isInit = false;
  public SDLHelper()
  { 
  }  
  public void SDL_MaximizeWindow()
  {
 
  } 
  public int SDL_Init(int width, int height, IntPtr intPtr)
  {
   lock (this)
   {
    if (!isInit)
    {
     // 初始化调用SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_TIMER)
     if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_TIMER) < 0)
     {
      Console.WriteLine("Could not initialize SDL - {0}\n", SDL.SDL_GetError());
      return -1;
     }
     isInit = true;
    }
    #region SDL调用
    if (sdltexture != IntPtr.Zero)
    {
     SDL.SDL_DestroyTexture(sdltexture);
    }
    if (sdlrenderer != IntPtr.Zero)
    {
     SDL.SDL_DestroyRenderer(sdlrenderer);
    }
    if (screen != IntPtr.Zero)
    {
     SDL.SDL_DestroyWindow(screen);
     SDL.SDL_RaiseWindow(screen);
     SDL.SDL_RestoreWindow(screen);
    }
    //创建显示窗口 
    screen = SDL.SDL_CreateWindowFrom(intPtr);
    SDL.SDL_ShowWindow(screen);
 
    SDL.SDL_SetWindowSize(screen, width, height);
    //screen = SDL.SDL_CreateWindow("SDL EVENT TEST", SDL.SDL_WINDOWPOS_UNDEFINED, SDL.SDL_WINDOWPOS_UNDEFINED, width, height, SDL.SDL_WindowFlags.SDL_WINDOW_OPENGL | SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE);
    //screen = SDL.SDL_CreateWindow("SDL EVENT TEST", SDL.SDL_WINDOWPOS_UNDEFINED, SDL.SDL_WINDOWPOS_UNDEFINED, screen_w, screen_h, SDL.SDL_WindowFlags.SDL_WINDOW_OPENGL | SDL.SDL_WindowFlags.SDL_WINDOW_RESIZABLE);
    if (screen == IntPtr.Zero)
    {
     Console.WriteLine("Can't creat a window:{0}\n", SDL.SDL_GetError());
     return -1;
    }
 
    //创建渲染器
    sdlrenderer = SDL.SDL_CreateRenderer(screen, -1, SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED);
    //创建纹理 
    sdltexture = SDL.SDL_CreateTexture(sdlrenderer, SDL.SDL_PIXELFORMAT_IYUV, (int)SDL.SDL_TextureAccess.SDL_TEXTUREACCESS_STREAMING, width, height);
    #endregion
 
    return 0;
   }
  } 
  public int SDL_Display(int width, int height, IntPtr pixels, int pixelsSize,
   int pitch)
  {
   lock (this)
   {
    #region SDL 视频数据渲染播放
    //设置纹理的数据
    sdlrect.x = 0;
    sdlrect.y = 0;
    sdlrect.w = width;
    sdlrect.h = height;
    //SDL.SDL_UpdateTexture(sdltexture, ref sdlrect, pixels, pitch);
    SDL.SDL_UpdateTexture(sdltexture, IntPtr.Zero, pixels, pitch);
    //复制纹理信息到渲染器目标
    SDL.SDL_RenderClear(sdltexture);
    //SDL.SDL_Rect srcRect = sdlrect;
    //SDL.SDL_RenderCopy(sdlrenderer, sdltexture, ref srcRect, ref sdlrect);
 
    SDL.SDL_RenderCopy(sdlrenderer, sdltexture, IntPtr.Zero, IntPtr.Zero);
    //视频渲染显示
    SDL.SDL_RenderPresent(sdlrenderer);
    return 0;
   }   
   #endregion   
  }
 }
 public unsafe class SDLAudio
 {
  class aa
  {
   public byte[] pcm;
   public int len;
  }
  int lastIndex = 0;
 
  private List<aa> data = new List<aa>();
 
  //private List<byte> data = new List<byte>();
  SDL.SDL_AudioCallback Callback;
  public void PlayAudio(IntPtr pcm, int len)
  {
   lock (this)
   {
    byte[] bts = new byte[len];
    Marshal.Copy(pcm, bts, 0, len);
    data.Add(new aa
    {
     len = len,
     pcm = bts
    });
   }
 
   //SDL.SDL_Delay(10);
  }
  void SDL_AudioCallback(IntPtr userdata, IntPtr stream, int len)
  {
   SDL 2.0 
   SDL.SDL_RWFromMem(stream, 0, len);
   //if (audio_len == 0)
   // return;
   //len = (len > audio_len ? audio_len : len);
   if (data.Count == 0)
   {
    for (int i = 0; i < len; i++)
    {
     ((byte*)stream)[i] = 0;
    }
    return;
   }
   for (int i = 0; i < len; i++)
   {
    if (data[0].len > i)
    {
     ((byte*)stream)[i] = data[0].pcm[i];
    }
    else
     ((byte*)stream)[i] = 0;
   }
   data.RemoveAt(0);   
  }
  public int SDL_Init()
  {
   Callback = SDL_AudioCallback;
   #region SDL调用
    初始化调用SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_TIMER)
   //if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_TIMER) < 0)
   //{
   // Console.WriteLine("Could not initialize SDL - {0}\n", SDL.SDL_GetError());
   // return -1;
   //}
 
   #endregion 
   SDL.SDL_AudioSpec wanted_spec = new SDL.SDL_AudioSpec();
   wanted_spec.freq = 8000;
   wanted_spec.format = SDL.AUDIO_S16;
   wanted_spec.channels = 1;
   wanted_spec.silence = 0;
   wanted_spec.samples = 320;
   wanted_spec.callback = Callback; 
 
   if (SDL.SDL_OpenAudio(ref wanted_spec, IntPtr.Zero) < 0)
   {
    Console.WriteLine("can't open audio.");
    return -1;
   }
   //Play 
   SDL.SDL_PauseAudio(0);
   return 0;
  } 
 } 
}

SDL实现了基础的播放功能。

C# Mp4文件音视频编码器类

using CV.Video.Base;
using CV.Video.Base.FFmpeg;
using FFmpeg.AutoGen;
using JX;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace CvNetVideo.Codec.Video
{
 public unsafe class JT1078CodecForMp4
 {
  
  /// <summary>
  /// 指示当前解码是否在运行
  /// </summary>
  public bool IsRun { get; protected set; }
  /// <summary>
  /// 视频线程
  /// </summary>
  private Thread threadVideo;
  /// <summary>
  /// 音频线程
  /// </summary>
  private Thread threadAudio;
  /// <summary>
  /// 退出控制
  /// </summary>
  private bool exit_thread = false;
  /// <summary>
  /// 暂停控制
  /// </summary>
  private bool pause_thread = false;
  /// <summary>
  /// 视频输出流videoindex
  /// </summary>
  private int videoindex = -1;
  /// <summary>
  /// 音频输出流audioindex
  /// </summary>
  private int audioindex = -1;
 
  /// <summary>
  /// 视频H264转YUV并使用SDL进行播放
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  /// <returns></returns>
  public unsafe int RunVideo(string fileName,SDLHelper sdlVideo)
  {
   IsRun = true;
   exit_thread = false;
   pause_thread = false;
   threadVideo = Thread.CurrentThread;
   int error, frame_count = 0;
   int got_picture, ret;
   SwsContext* pSwsCtx = null;
   AVFormatContext* ofmt_ctx = null;
   IntPtr convertedFrameBufferPtr = IntPtr.Zero;
   try
   {
    // 注册编解码器
    ffmpeg.avcodec_register_all();
 
    // 获取文件信息上下文初始化
    ofmt_ctx = ffmpeg.avformat_alloc_context();
 
    // 打开媒体文件
    error = ffmpeg.avformat_open_input(&ofmt_ctx, fileName, null, null);
    if (error != 0)
    {
     throw new ApplicationException(FFmpegBinariesHelper.GetErrorMessage(error));
    }
 
    // 获取流的通道
    for (int i = 0; i < ofmt_ctx->nb_streams; i++)
    {
     if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
     {
      videoindex = i;
      Console.WriteLine("video.............."+videoindex);
     }
    }
 
    if (videoindex == -1)
    {
     Console.WriteLine("Couldn't find a video stream.（没有找到视频流）");
     return -1;
    }
 
    // 视频流处理
    if (videoindex > -1)
    {
     //获取视频流中的编解码上下文
     AVCodecContext* pCodecCtx = ofmt_ctx->streams[videoindex]->codec;
 
     //根据编解码上下文中的编码id查找对应的解码
     AVCodec* pCodec = ffmpeg.avcodec_find_decoder(pCodecCtx->codec_id);
     if (pCodec == null)
     {
      Console.WriteLine("没有找到编码器");
      return -1;
     }
 
     //打开编码器
     if (ffmpeg.avcodec_open2(pCodecCtx, pCodec, null) < 0)
     {
      Console.WriteLine("编码器无法打开");
      return -1;
     }
     Console.WriteLine("Find a video stream.channel=" + videoindex);
 
     //输出视频信息
     var format = ofmt_ctx->iformat->name->ToString();
     var len = (ofmt_ctx->duration) / 1000000;
     var width = pCodecCtx->width;
     var height = pCodecCtx->height;
     Console.WriteLine("video format：" + format);
     Console.WriteLine("video length：" + len);
     Console.WriteLine("video width&height：width=" + width + " height=" + height);
     Console.WriteLine("video codec name：" + pCodec->name->ToString());
 
     //准备读取
     //AVPacket用于存储一帧一帧的压缩数据（H264）
     //缓冲区，开辟空间
     AVPacket* packet = (AVPacket*)ffmpeg.av_malloc((ulong)sizeof(AVPacket));
 
     //AVFrame用于存储解码后的像素数据(YUV)
     //内存分配
     AVFrame* pFrame = ffmpeg.av_frame_alloc();
     //YUV420
     AVFrame* pFrameYUV = ffmpeg.av_frame_alloc();
     //只有指定了AVFrame的像素格式、画面大小才能真正分配内存
     //缓冲区分配内存
     int out_buffer_size = ffmpeg.avpicture_get_size(AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
     byte* out_buffer = (byte*)ffmpeg.av_malloc((ulong)out_buffer_size);
     //初始化缓冲区
     ffmpeg.avpicture_fill((AVPicture*)pFrameYUV, out_buffer, AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
 
     //用于转码（缩放）的参数，转之前的宽高，转之后的宽高，格式等
     SwsContext* sws_ctx = ffmpeg.sws_getContext(pCodecCtx->width, pCodecCtx->height, AVPixelFormat.AV_PIX_FMT_YUV420P /*pCodecCtx->pix_fmt*/, pCodecCtx->width, pCodecCtx->height, AVPixelFormat.AV_PIX_FMT_YUV420P, ffmpeg.SWS_BICUBIC, null, null, null);
 
     while (ffmpeg.av_read_frame(ofmt_ctx, packet) >= 0)
     {
      // 退出线程
      if (exit_thread)
      {
       break;
      }
      // 暂停解析
      if (pause_thread)
      {
       while (pause_thread)
       {
        Thread.Sleep(100);
       }
      }
      //只要视频压缩数据（根据流的索引位置判断）
      if (packet->stream_index == videoindex)
      {
       //解码一帧视频压缩数据，得到视频像素数据
       ret = ffmpeg.avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
       if (ret < 0)
       {
        Console.WriteLine("视频解码错误");
        return -1;
       }
 
       // 读取解码后的帧数据
       if (got_picture>0)
       {
        frame_count++;
        Console.WriteLine("视频帧数:第 " + frame_count + " 帧");
 
        //AVFrame转为像素格式YUV420，宽高
        ffmpeg.sws_scale(sws_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);
 
        //SDL播放YUV数据
        var data = out_buffer;
        sdlVideo.SDL_Display(pCodecCtx->width, pCodecCtx->height, (IntPtr)data, out_buffer_size, pFrameYUV->linesize[0]);
       }
      }
 
      //释放资源
      ffmpeg.av_free_packet(packet);
     } 
    } 
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex);
   }
   finally
   {
    if (&ofmt_ctx != null)
    {
     ffmpeg.avformat_close_input(&ofmt_ctx);//关闭流文件 
    }    
   }
   IsRun = false;
   return 0;
  }
 
  /// <summary>
  /// 音频AAC转PCM并使用SDL进行播放
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlAudio"></param>
  /// <returns></returns>
  public unsafe int RunAudio(string fileName, SDLAudio sdlAudio)
  {
   IsRun = true;
   exit_thread = false;
   pause_thread = false;
   threadAudio = Thread.CurrentThread;
   int error, frame_count = 0;
   int got_frame, ret;
   AVFormatContext* ofmt_ctx = null;
   SwsContext* pSwsCtx = null;
   IntPtr convertedFrameBufferPtr = IntPtr.Zero;
   try
   {
    // 注册编解码器
    ffmpeg.avcodec_register_all();
 
    // 获取文件信息上下文初始化
    ofmt_ctx = ffmpeg.avformat_alloc_context();
 
    // 打开媒体文件
    error = ffmpeg.avformat_open_input(&ofmt_ctx, fileName, null, null);
    if (error != 0)
    {
     throw new ApplicationException(FFmpegBinariesHelper.GetErrorMessage(error));
    }
 
    // 获取流的通道
    for (int i = 0; i < ofmt_ctx->nb_streams; i++)
    {
     if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_AUDIO)
     {
      audioindex = i;
      Console.WriteLine("audio.............." + audioindex);
     }
    }
 
    if (audioindex == -1)
    {
     Console.WriteLine("Couldn't find a audio stream.（没有找到音频流）");
     return -1;
    }
 
    // 音频流处理
    if (audioindex > -1)
    {
     //根据索引拿到对应的流,根据流拿到解码器上下文
     AVCodecContext* pCodeCtx = ofmt_ctx->streams[audioindex]->codec;
 
     //再根据上下文拿到编解码id，通过该id拿到解码器
     AVCodec* pCodec = ffmpeg.avcodec_find_decoder(pCodeCtx->codec_id);
     if (pCodec == null)
     {
      Console.WriteLine("没有找到编码器");
      return -1;
     }
     //打开编码器
     if (ffmpeg.avcodec_open2(pCodeCtx,pCodec, null)<0)
     {
      Console.WriteLine("编码器无法打开");
      return -1;
     }
     Console.WriteLine("Find a audio stream. channel=" + audioindex);
 
     //编码数据
     AVPacket* packet = (AVPacket*)ffmpeg.av_malloc((ulong)(sizeof(AVPacket)));
     //解压缩数据
     AVFrame* frame = ffmpeg.av_frame_alloc();
 
     //frame->16bit 44100 PCM 统一音频采样格式与采样率
     SwrContext* swrCtx = ffmpeg.swr_alloc();
     //重采样设置选项-----------------------------------------------------------start
     //输入的采样格式
     AVSampleFormat in_sample_fmt = pCodeCtx->sample_fmt;
     //输出的采样格式 16bit PCM
     AVSampleFormat out_sample_fmt = AVSampleFormat.AV_SAMPLE_FMT_S16;
     //输入的采样率
     int in_sample_rate = pCodeCtx->sample_rate;
     //输出的采样率
     int out_sample_rate = 44100;
     //输入的声道布局
     long in_ch_layout = (long)pCodeCtx->channel_layout;
     //输出的声道布局
     int out_ch_layout = ffmpeg.AV_CH_LAYOUT_MONO;
 
     ffmpeg.swr_alloc_set_opts(swrCtx, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt, in_sample_rate, 0, null);
     ffmpeg.swr_init(swrCtx);
     //重采样设置选项-----------------------------------------------------------end
     //获取输出的声道个数
     int out_channel_nb = ffmpeg.av_get_channel_layout_nb_channels((ulong)out_ch_layout);
     //存储pcm数据
     byte* out_buffer = (byte*)ffmpeg.av_malloc(2 * 44100);
     
     //一帧一帧读取压缩的音频数据AVPacket
     while (ffmpeg.av_read_frame(ofmt_ctx, packet) >= 0)
     {
      // 退出线程
      if (exit_thread)
      {
       break;
      }
      // 暂停解析
      if (pause_thread)
      {
       while (pause_thread)
       {
        Thread.Sleep(100);
       }
      }
      if (packet->stream_index == audioindex)
      {
       //解码AVPacket->AVFrame
       ret = ffmpeg.avcodec_decode_audio4(pCodeCtx, frame, &got_frame, packet);
       if (ret < 0)
       {
        Console.WriteLine("音频解码失败");
        return -1;
       }
       // 读取帧数据
       if (got_frame>0)
       {
        frame_count++;
        Console.WriteLine("音频帧数:第 "+ frame_count + " 帧");
        var data_ = frame->data;
        ffmpeg.swr_convert(swrCtx, &out_buffer, 2 * 44100,(byte**)&data_, frame->nb_samples);
        //获取sample的size
        int out_buffer_size = ffmpeg.av_samples_get_buffer_size(null, out_channel_nb, frame->nb_samples, out_sample_fmt, 1);
        //写入文件进行测试
        var data=out_buffer;
        sdlAudio.PlayAudio((IntPtr)data, out_buffer_size);
       }
      }
      ffmpeg.av_free_packet(packet);
     } 
    } 
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex);
   }
   finally
   {
    if (&ofmt_ctx != null)
    {
     ffmpeg.avformat_close_input(&ofmt_ctx);//关闭流文件 
    } 
   }
   IsRun = false;
   return 0;
  } 
 
  /// <summary>
  /// 开启线程
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  public void Start(string fileName, SDLHelper sdlVideo,SDLAudio sdlAudio)
  {
   // 视频线程
   threadVideo = new Thread(() =>
    {
     try
     {
      RunVideo(fileName, sdlVideo);
     }
     catch (Exception ex)
     {
      SQ.Base.ErrorLog.WriteLog4Ex("JT1078CodecForMp4.Run Video", ex);
     }
    });
   threadVideo.IsBackground = true;
   threadVideo.Start();
 
   // 音频线程
   threadAudio = new Thread(() =>
   {
    try
    {
     RunAudio(fileName, sdlAudio);
    }
    catch (Exception ex)
    {
     SQ.Base.ErrorLog.WriteLog4Ex("JT1078CodecForMp4.Run Audio", ex);
    }
   });
   threadAudio.IsBackground = true;
   threadAudio.Start();
  }
 
  /// <summary>
  /// 暂停继续
  /// </summary>
  public void GoOn()
  {
   pause_thread = false;
 
  }
 
  /// <summary>
  /// 暂停
  /// </summary>
  public void Pause()
  {
   pause_thread = true;
  }
 
  /// <summary>
  /// 停止
  /// </summary>
  public void Stop()
  {
   exit_thread = true;
  }
 }
}

暂停、继续、停止在此处的意义不大，因为解析的速度很快。

测试代码及效果图

 /// <summary>
  /// 播放
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private void btnPlay_Click(object sender, EventArgs e)
  {
   // 音视频媒体文件路径
   string fileName = "test.mp4";// 表示${Project_home}/bin/Debug/test.mp4
   // 线程读取音视频流
   jt1078CodecForMp4 = new JT1078CodecForMp4();
   jt1078CodecForMp4.Start(fileName,sdlVideo,sdlAudio);
  }

注意：此处出现绿色，是不正常的。修改播放方法的数据设置方式：

/// <summary>
  /// 播放视频
  /// </summary>
  /// <param name="width"></param>
  /// <param name="height"></param>
  /// <param name="pixels"></param>
  /// <param name="pixelsSize"></param>
  /// <param name="pitch"></param>
  /// <returns></returns>
  public int SDL_Display(int width, int height, IntPtr pixels, int pixelsSize,
   int pitch)
  {
   lock (this)
   {
    while (isPause)
    {
     SDL.SDL_Delay(20);//延迟播放
    }
 
    #region SDL 视频数据渲染播放
    //设置纹理的数据
    sdlrect.x = 0;
    sdlrect.y = 0;
    sdlrect.w = width;
    sdlrect.h = height;
    SDL.SDL_UpdateTexture(sdltexture, ref sdlrect, pixels, pitch);
    //SDL.SDL_UpdateTexture(sdltexture, IntPtr.Zero, pixels, pitch);//此处代码导致播放窗口绿色阴影
    //复制纹理信息到渲染器目标
    SDL.SDL_RenderClear(sdltexture);
    //SDL.SDL_Rect srcRect = sdlrect;
    //SDL.SDL_RenderCopy(sdlrenderer, sdltexture, ref srcRect, ref sdlrect);
 
    SDL.SDL_RenderCopy(sdlrenderer, sdltexture, IntPtr.Zero, IntPtr.Zero);
    //视频渲染显示
    SDL.SDL_RenderPresent(sdlrenderer);
    //SDL.SDL_Delay(40);
    //SDL.SDL_PollEvent(out sdlevent);
    //switch (sdlevent.type)
    //{
    // case SDL.SDL_EventType.SDL_QUIT:
    //  SDL.SDL_Quit();
    //  return -1;
    // default:
    //  break;
    //}
    return 0;
   } 
 
   //SDL.SDL_RenderClear(sdlrenderer);
   //SDL.SDL_RenderCopy(sdlrenderer, sdltexture, ref srcRect, ref sdlrect);
   //SDL.SDL_RenderPresent(sdlrenderer);
   Delay 40ms 
   //SDL.SDL_Delay(40);
   #endregion 
 
   //#region SDL 视频数据渲染播放
   //设置纹理的数据
   sdlrect.x = 0;
   sdlrect.y = 0;
   sdlrect.w = width;
   sdlrect.h = height;
   SDL.SDL_UpdateTexture(sdltexture, ref sdlrect, pixels, pitch);
   //复制纹理信息到渲染器目标
   SDL.SDL_Rect srcRect = sdlrect;
   SDL.SDL_RenderCopy(sdlrenderer, sdltexture, ref srcRect, ref sdlrect);
   //视频渲染显示
   SDL.SDL_RenderPresent(sdlrenderer);
   //SDL.SDL_Delay(40);
   SDL.SDL_PollEvent(out sdlevent);
   switch (sdlevent.type)
   {
    case SDL.SDL_EventType.SDL_QUIT:
     SDL.SDL_Quit();
     return -1;
    default:
     break;
   }
   return 0;
   //#endregion
  }
 }

关键代码：

SDL.SDL_UpdateTexture(sdltexture, ref sdlrect, pixels, pitch);

//SDL.SDL_UpdateTexture(sdltexture, IntPtr.Zero, pixels, pitch);//此处代码导致播放窗口绿色阴影

修改后效果：

代码改进，采用同一个线程播放音视频：

/// <summary>
 /// MP4播放(音视频使用同一个线程)
 /// </summary>
 public unsafe class JT1078CodecToPlayMp4Two
 {
 
  /// <summary>
  /// 指示当前解码是否在运行
  /// </summary>
  public bool IsRun { get; protected set; }
  /// <summary>
  /// 当前线程
  /// </summary>
  private Thread thread;
  /// <summary>
  /// 退出控制
  /// </summary>
  private bool exit_thread = false;
  /// <summary>
  /// 暂停控制
  /// </summary>
  private bool pause_thread = false;
  /// <summary>
  /// 视频输出流videoindex
  /// </summary>
  private int videoindex = -1;
  /// <summary>
  /// 音频输出流audioindex
  /// </summary>
  private int audioindex = -1; 
  private bool isInit = false; 
 
  int error;
  AVFormatContext* ofmt_ctx = null;
  AVPacket* packet;
  AVCodecContext* pCodecCtx_Video;
  AVCodec* pCodec_Video;
  AVFrame* pFrame_Video;
  AVFrame* pFrameYUV_Video;
  SwsContext* sws_ctx_video;
  SDLHelper sdlVideo;
  SDLAudio sdlAudio;
 
  int out_buffer_size_video;
  byte* out_buffer_video;
  int video_frame_count, audio_frame_count; 
 
  AVCodecContext* pCodeCtx_Audio;
  AVCodec* pCodec_Audio;
  AVFrame* frame_Audio;
  SwrContext* swrCtx_Audio;
 
  byte* out_buffer_audio;
  int out_buffer_size_audio;
  int out_channel_nb;
  AVSampleFormat out_sample_fmt;
 
  /// <summary>
  /// 初始化
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  /// <param name="sdlAudio"></param>
  /// <returns></returns>
  public int Init(string fileName, SDLHelper sdlVideo, SDLAudio sdlAudio)
  {
   AVFormatContext* ofmt_ctx;
 
   // 注册编解码器
   ffmpeg.avcodec_register_all();
 
   // 获取文件信息上下文初始化
   ofmt_ctx = ffmpeg.avformat_alloc_context();
   this.ofmt_ctx = ofmt_ctx;
 
   // 打开媒体文件
   error = ffmpeg.avformat_open_input(&ofmt_ctx, fileName, null, null);
   if (error != 0)
   {
    throw new ApplicationException(FFmpegBinariesHelper.GetErrorMessage(error));
   }
 
   // 获取流的通道
   for (int i = 0; i < ofmt_ctx->nb_streams; i++)
   {
    if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
    {
     videoindex = i;
     Console.WriteLine("video.............." + videoindex);
    }
    if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_AUDIO)
    {
     audioindex = i;
     Console.WriteLine("audio.............." + audioindex);
    }
   }
 
   if (videoindex == -1)
   {
    Console.WriteLine("Couldn't find a video stream.（没有找到视频流）");
    return -1;
   }
 
   if (audioindex == -1)
   {
    Console.WriteLine("Couldn't find a audio stream.（没有找到音频流）");
    return -1;
   }
 
   #region 初始化视频
 
   // 视频流处理
   if (videoindex > -1)
   {
    //获取视频流中的编解码上下文
    pCodecCtx_Video = ofmt_ctx->streams[videoindex]->codec;
 
    //根据编解码上下文中的编码id查找对应的解码
    pCodec_Video = ffmpeg.avcodec_find_decoder(pCodecCtx_Video->codec_id);
    if (pCodec_Video == null)
    {
     Console.WriteLine("没有找到编码器");
     return -1;
    }
 
    //打开编码器
    if (ffmpeg.avcodec_open2(pCodecCtx_Video, pCodec_Video, null) < 0)
    {
     Console.WriteLine("编码器无法打开");
     return -1;
    }
    Console.WriteLine("Find a video stream.channel=" + videoindex);
 
    //输出视频信息
    var format = ofmt_ctx->iformat->name->ToString();
    var len = (ofmt_ctx->duration) / 1000000;
    var width = pCodecCtx_Video->width;
    var height = pCodecCtx_Video->height;
    Console.WriteLine("video format：" + format);
    Console.WriteLine("video length：" + len);
    Console.WriteLine("video width&height：width=" + width + " height=" + height);
    Console.WriteLine("video codec name：" + pCodec_Video->name->ToString());
 
    //准备读取
    //AVPacket用于存储一帧一帧的压缩数据（H264）
 
    //AVFrame用于存储解码后的像素数据(YUV)
    //内存分配
    pFrame_Video = ffmpeg.av_frame_alloc();
    //YUV420
    pFrameYUV_Video = ffmpeg.av_frame_alloc();
    //只有指定了AVFrame的像素格式、画面大小才能真正分配内存
    //缓冲区分配内存
    out_buffer_size_video = ffmpeg.avpicture_get_size(AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height);
    out_buffer_video = (byte*)ffmpeg.av_malloc((ulong)out_buffer_size_video);
    //初始化缓冲区
    ffmpeg.avpicture_fill((AVPicture*)pFrameYUV_Video, out_buffer_video, AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height);
    //用于转码（缩放）的参数，转之前的宽高，转之后的宽高，格式等
    sws_ctx_video = ffmpeg.sws_getContext(pCodecCtx_Video->width, pCodecCtx_Video->height, AVPixelFormat.AV_PIX_FMT_YUV420P /*pCodecCtx->pix_fmt*/, pCodecCtx_Video->width, pCodecCtx_Video->height, AVPixelFormat.AV_PIX_FMT_YUV420P, ffmpeg.SWS_BICUBIC, null, null, null);
   }
   #endregion
 
   #region 初始化音频
   // 音频流处理
   if (audioindex > -1)
   {
    //根据索引拿到对应的流,根据流拿到解码器上下文
    pCodeCtx_Audio = ofmt_ctx->streams[audioindex]->codec;
 
    //再根据上下文拿到编解码id，通过该id拿到解码器
    pCodec_Audio = ffmpeg.avcodec_find_decoder(pCodeCtx_Audio->codec_id);
    if (pCodec_Audio == null)
    {
     Console.WriteLine("没有找到编码器");
     return -1;
    }
    //打开编码器
    if (ffmpeg.avcodec_open2(pCodeCtx_Audio, pCodec_Audio, null) < 0)
    {
     Console.WriteLine("编码器无法打开");
     return -1;
    }
    Console.WriteLine("Find a audio stream. channel=" + audioindex);
 
    //解压缩数据
    frame_Audio = ffmpeg.av_frame_alloc();
 
    //frame->16bit 44100 PCM 统一音频采样格式与采样率
    swrCtx_Audio = ffmpeg.swr_alloc();
    //重采样设置选项-----------------------------------------------------------start
    //输入的采样格式
    AVSampleFormat in_sample_fmt = pCodeCtx_Audio->sample_fmt;
    //输出的采样格式 16bit PCM
    out_sample_fmt = AVSampleFormat.AV_SAMPLE_FMT_S16;
    //输入的采样率
    int in_sample_rate = pCodeCtx_Audio->sample_rate;
    //输出的采样率
    int out_sample_rate = 44100;
    //输入的声道布局
    long in_ch_layout = (long)pCodeCtx_Audio->channel_layout;
    //输出的声道布局
    int out_ch_layout = ffmpeg.AV_CH_LAYOUT_MONO;
 
    ffmpeg.swr_alloc_set_opts(swrCtx_Audio, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt, in_sample_rate, 0, null);
    ffmpeg.swr_init(swrCtx_Audio);
    //重采样设置选项-----------------------------------------------------------end
    //获取输出的声道个数
    out_channel_nb = ffmpeg.av_get_channel_layout_nb_channels((ulong)out_ch_layout);
    //存储pcm数据
    out_buffer_audio = (byte*)ffmpeg.av_malloc(2 * 44100);
   }
   #endregion
 
   //缓冲区，开辟空间
   packet = (AVPacket*)ffmpeg.av_malloc((ulong)sizeof(AVPacket));
 
   // 设置SDL播放对象
   this.sdlVideo = sdlVideo;
   this.sdlAudio = sdlAudio; 
   isInit = true; 
   return 0;
  } 
 
  /// <summary>
  /// 读取音视频流文件并进行播放
  /// </summary>
  public unsafe int ReadAndPlay()
  {
   IsRun = true;
   exit_thread = false;
   pause_thread = false;
   thread = Thread.CurrentThread;
   //int error, frame_count = 0;
   int got_frame, ret;
   //SwsContext* pSwsCtx = null;
 
   byte* out_audio_buffer = out_buffer_audio;
 
   try
   { 
    while (ffmpeg.av_read_frame(ofmt_ctx, packet) >= 0)
    {
 
     // 退出线程
     if (exit_thread)
     {
      break;
     }
     // 暂停解析
     while (pause_thread)
     {
      Thread.Sleep(100);
     }
     #region 视频H264转YUV并使用SDL进行播放
     if (packet->stream_index == videoindex)
     {
      //解码一帧视频压缩数据，得到视频像素数据
      ret = ffmpeg.avcodec_decode_video2(pCodecCtx_Video, pFrame_Video, &got_frame, packet);
      if (ret < 0)
      {
       Console.WriteLine("视频解码错误");
       return -1;
      }
 
      // 读取解码后的帧数据
      if (got_frame > 0)
      {
       double pts = 0; //ffmpeg.av_frame_get_best_effort_timestamp(pFrameYUV_Video);
       //VideoState* vs = null;
       //vs->video_clock = pts;
       //vs->video_st = ofmt_ctx->streams[videoindex];
       //pts = synchronize_video(vs, pFrame_Video, pts);
       //if (queue_picture(is, pFrame, pts) < 0)
       //{
       // break;
       //}
       video_frame_count++;
       //存在问题的PTS计算
 
       //int pts = video_frame_count++ * (pCodecCtx_Video->pkt_timebase.num * 1000 / 25 /* pCodecCtx->pkt_timebase.den*/);
 
       Console.WriteLine("视频帧数:第 " + video_frame_count + " 帧");
 
       //AVFrame转为像素格式YUV420，宽高
       ffmpeg.sws_scale(sws_ctx_video, pFrame_Video->data, pFrame_Video->linesize, 0, pCodecCtx_Video->height, pFrameYUV_Video->data, pFrameYUV_Video->linesize);
 
       Console.WriteLine("视频: pts= " + packet->pts + " dts=" + packet->dts);
 
       // SDL播放YUV数据：下面两种方式都可以进行播放
       sdlVideo.SDL_Display(pCodecCtx_Video->width, pCodecCtx_Video->height, (IntPtr)out_buffer_video, out_buffer_size_video, pFrameYUV_Video->linesize[0]);
       //sdlVideo.SDL_Display(pCodecCtx_Video->width, pCodecCtx_Video->height, (IntPtr)pFrameYUV_Video->data[0], out_buffer_size_video, pFrameYUV_Video->linesize[0]);
 
       //DeleyToPlay_Video(packet->pts);
      }
     }
     #endregion
 
     #region 音频AAC转PCM并使用SDL进行播放
     if (packet->stream_index == audioindex)
     {
      //解码AVPacket->AVFrame
      ret = ffmpeg.avcodec_decode_audio4(pCodeCtx_Audio, frame_Audio, &got_frame, packet);
      if (ret < 0)
      {
       Console.WriteLine("音频解码失败");
       return -1;
      }
      // 读取帧数据
      if (got_frame > 0)
      {
       audio_frame_count++;
       Console.WriteLine("音频帧数:第 " + audio_frame_count + " 帧");
       // 变换音频
       ffmpeg.swr_convert(swrCtx_Audio, &out_audio_buffer, 2 * 44100, (byte**)&frame_Audio->data, frame_Audio->nb_samples);
 
       // 获取sample的size
       out_buffer_size_audio = ffmpeg.av_samples_get_buffer_size(null, out_channel_nb, frame_Audio->nb_samples, out_sample_fmt, 1);
 
       Console.WriteLine("音频: pts= " + packet->pts + " dts=" + packet->dts);
 
       // SDL进行音频播放
       sdlAudio.PlayAudio((IntPtr)out_audio_buffer, out_buffer_size_audio);
 
       //DeleyToPlay_Audio(packet->pts);
 
      }
     }
     #endregion
     Thread.Sleep(20);
     //释放资源
     ffmpeg.av_free_packet(packet);
    } 
 
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex);
   }
   finally
   {
    //if (&ofmt_ctx != null)
    //{
    // ffmpeg.avformat_close_input(&ofmt_ctx);//关闭流文件 
    //}
 
   }
   IsRun = false;
   return 0;
  }
 
  /// <summary>
  /// 开启线程
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  /// <param name="sdlAudio"></param>
  public void Start()
  {
   if (!isInit)
   {
    MessageBox.Show("没有初始化");
   }
   thread = new Thread(() =>
   {
    try
    {
     ReadAndPlay();
    }
    catch (Exception ex)
    {
     SQ.Base.ErrorLog.WriteLog4Ex("JT1078CodecForMp4.Run Video", ex);
    }
   });
   thread.IsBackground = true;
   thread.Start(); 
  }
 
  /// <summary>
  /// 暂停继续
  /// </summary>
  public void GoOnPlay()
  {
   pause_thread = false;
   sdlVideo.PlayVideo();
   sdlAudio.PlayAudio();
  }
 
  /// <summary>
  /// 暂停
  /// </summary>
  public void Pause()
  {
   pause_thread = true;
   sdlVideo.PauseVideo();
   sdlAudio.PauseAudio();
  }
 
  /// <summary>
  /// 停止
  /// </summary>
  public void Stop()
  {
   exit_thread = true;
  }
 
  long lastPts_Video = 0;
  DateTime lastTS_Video;
 
  long lastPts_Audio = 0;
  DateTime lastTS_Audio;
 
  private void DeleyToPlay_Video(long pts)
  {
   if (lastPts_Video > 0 && lastTS_Video != null)
   {
    double delay = (DateTime.Now - lastTS_Video).TotalMilliseconds;
    var i = (int)(pts - lastPts_Video - delay);
    if (i >= 1)
    {
     Thread.Sleep(i);
    }
   }
   lastTS_Video = DateTime.Now;
   lastPts_Video = pts;
  }
 
  private void DeleyToPlay_Audio(long pts)
  {
   if (lastPts_Audio > 0 && lastTS_Audio != null)
   {
    double delay = (DateTime.Now - lastTS_Audio).TotalMilliseconds;
    var i = (int)(pts - lastPts_Audio - delay);
    if (i >= 1)
    {
     Thread.Sleep(i);
    }
   }
   lastTS_Audio = DateTime.Now;
   lastPts_Audio = pts;
  }
 
  # http://dranger.com/ffmpeg/tutorial05.html
  //public struct VideoState
  //{
  // public double video_clock; // pts of last decoded frame / predicted pts of next decoded frame
 
  // public AVStream* video_st;// video stream
  //}
 
  //public unsafe double synchronize_video(VideoState* vs, AVFrame* src_frame, double pts)
  //{
 
  // double frame_delay;
 
  // if (pts != 0)
  // {
  //  /* if we have pts, set video clock to it */
  //  vs->video_clock = pts;
  // }
  // else
  // {
  //  /* if we aren't given a pts, set it to the clock */
  //  pts = vs->video_clock;
  // }
  // /* update the video clock */
  // frame_delay = av_q2d(vs->video_st->codec->time_base);
  // /* if we are repeating a frame, adjust clock accordingly */
  // frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
  // vs->video_clock += frame_delay;
  // return pts;
  //}
 
  //struct VideoPicture
  //{
  // double pts;
  //}
  //int queue_picture(VideoState* vs, AVFrame* pFrame, double pts)
  //{
  // if (vp->bmp)
  // {
  // ... convert picture ...
  //   vp->pts = pts;
  // ... alert queue ...
  // }
 
  //}
 }

解决音视频同步问题版本

using CV.Media.Utils.Filter;
using CV.Video.Base;
using CV.Video.Base.FFmpeg;
using FFmpeg.AutoGen;
using JX;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static CvNetVideo.UCVideo;
 
namespace CvNetVideo.Codec.Video
{ 
 /// <summary>
 /// MP4播放(音视频使用同一个线程)
 /// </summary>
 public unsafe class JT1078CodecToPlayMp4
 { 
  /// <summary>
  /// 指示当前解码是否在运行
  /// </summary>
  public bool IsRun { get; protected set; }
  /// <summary>
  /// 指示当前解码是否在暂停
  /// </summary>
  public bool IsPause { get; protected set; }
  /// <summary>
  /// 当前线程
  /// </summary>
  public Thread thread;
  /// <summary>
  /// 退出控制
  /// </summary>
  private bool exit_thread = false;
  /// <summary>
  /// 暂停控制
  /// </summary>
  private bool pause_thread = false;
  /// <summary>
  /// 视频输出流videoindex
  /// </summary>
  private int videoindex = -1;
  /// <summary>
  /// 音频输出流audioindex
  /// </summary>
  private int audioindex = -1;
  /// <summary>
  /// 是否初始化
  /// </summary>
  private bool isInit = false; 
 
  int error;
  AVFormatContext* ofmt_ctx = null;
  AVPacket* packet;
  AVCodecContext* pCodecCtx_Video;
  AVCodec* pCodec_Video;
  AVFrame* pFrame_Video;
  AVFrame* pFrameYUV_Video;
  SwsContext* sws_ctx_video;
  SDLHelper sdlVideo;
  SDLAudio sdlAudio;
 
  int out_buffer_size_video;
  byte* out_buffer_video;
  int video_frame_count, audio_frame_count; 
 
  AVCodecContext* pCodeCtx_Audio;
  AVCodec* pCodec_Audio;
  AVFrame* frame_Audio;
  SwrContext* swrCtx_Audio;
 
  byte* out_buffer_audio;
  int out_buffer_size_audio;
  int out_channel_nb;
  AVSampleFormat out_sample_fmt;
 
  int contrast;// 对比度
  int brightness;// 亮度
  int contrast_last;// 对比度
  int brightness_last;// 亮度
 
  //对比度亮度
  private VideoFiltering m_video_filtering = new VideoFiltering();
 
  /// <summary>
  /// 设置图像对比度和亮度
  /// </summary>
  /// <param name="contrast"></param>
  /// <param name="brightness"></param>
  /// <returns></returns>
  public void SetContrastAndBrightness(int contrast, int brightness)
  {
   this.contrast = contrast;
   this.brightness = brightness;
  }
  /// <summary>
  /// YUV宽度
  /// </summary>
  public int YuvWidth { get; set; }
  /// <summary>
  /// YUV高度
  /// </summary>
  public int YuvHeight { get; set; }
 
  /// <summary>
  /// 记录上一帧数据
  /// </summary>
  List<AVVideo> list = new List<AVVideo>();
 
  /// <summary>
  /// 初始化
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  /// <param name="sdlAudio"></param>
  /// <returns></returns>
  public int Init(string fileName, SDLHelper sdlVideo, SDLAudio sdlAudio)
  {
   AVFormatContext* ofmt_ctx;
 
   // 注册编解码器
   ffmpeg.avcodec_register_all();
 
   // 获取文件信息上下文初始化
   ofmt_ctx = ffmpeg.avformat_alloc_context();
   this.ofmt_ctx = ofmt_ctx;
 
   // 打开媒体文件
   error = ffmpeg.avformat_open_input(&ofmt_ctx, fileName, null, null);
   if (error != 0)
   {
    throw new ApplicationException(FFmpegBinariesHelper.GetErrorMessage(error));
   }
 
   // 获取流的通道
   for (int i = 0; i < ofmt_ctx->nb_streams; i++)
   {
    if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
    {
     videoindex = i;
     Console.WriteLine("video.............." + videoindex);
    }
    if (ofmt_ctx->streams[i]->codec->codec_type == AVMediaType.AVMEDIA_TYPE_AUDIO)
    {
     audioindex = i;
     Console.WriteLine("audio.............." + audioindex);
    }
   }
 
   if (videoindex == -1)
   {
    Console.WriteLine("Couldn't find a video stream.（没有找到视频流）");
    return -1;
   }
 
   if (audioindex == -1)
   {
    Console.WriteLine("Couldn't find a audio stream.（没有找到音频流）");
    return -1;
   }
 
   #region 初始化视频
 
   // 视频流处理
   if (videoindex > -1)
   {
    //获取视频流中的编解码上下文
    pCodecCtx_Video = ofmt_ctx->streams[videoindex]->codec;
 
    //根据编解码上下文中的编码id查找对应的解码
    pCodec_Video = ffmpeg.avcodec_find_decoder(pCodecCtx_Video->codec_id);
    if (pCodec_Video == null)
    {
     Console.WriteLine("没有找到编码器");
     return -1;
    }
 
    //打开编码器
    if (ffmpeg.avcodec_open2(pCodecCtx_Video, pCodec_Video, null) < 0)
    {
     Console.WriteLine("编码器无法打开");
     return -1;
    }
    Console.WriteLine("Find a video stream.channel=" + videoindex);
 
    //输出视频信息
    var format = ofmt_ctx->iformat->name->ToString();
    var len = (ofmt_ctx->duration) / 1000000;
    var width = pCodecCtx_Video->width;
    var height = pCodecCtx_Video->height;
    Console.WriteLine("video format：" + format);
    Console.WriteLine("video length：" + len);
    Console.WriteLine("video width&height：width=" + width + " height=" + height);
    Console.WriteLine("video codec name：" + pCodec_Video->name->ToString());
 
    //准备读取
    //AVPacket用于存储一帧一帧的压缩数据（H264）
 
    //AVFrame用于存储解码后的像素数据(YUV)
    //内存分配
    pFrame_Video = ffmpeg.av_frame_alloc();
    //YUV420
    pFrameYUV_Video = ffmpeg.av_frame_alloc();
    //只有指定了AVFrame的像素格式、画面大小才能真正分配内存
    //缓冲区分配内存
    out_buffer_size_video = ffmpeg.avpicture_get_size(AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height);
    out_buffer_video = (byte*)ffmpeg.av_malloc((ulong)out_buffer_size_video);
    //初始化缓冲区
    ffmpeg.avpicture_fill((AVPicture*)pFrameYUV_Video, out_buffer_video, AVPixelFormat.AV_PIX_FMT_YUV420P, pCodecCtx_Video->width, pCodecCtx_Video->height);
    //用于转码（缩放）的参数，转之前的宽高，转之后的宽高，格式等
    sws_ctx_video = ffmpeg.sws_getContext(pCodecCtx_Video->width, pCodecCtx_Video->height, AVPixelFormat.AV_PIX_FMT_YUV420P /*pCodecCtx->pix_fmt*/, pCodecCtx_Video->width, pCodecCtx_Video->height, AVPixelFormat.AV_PIX_FMT_YUV420P, ffmpeg.SWS_BICUBIC, null, null, null);
   }
   #endregion
 
   #region 初始化音频
   // 音频流处理
   if (audioindex > -1)
   {
    //根据索引拿到对应的流,根据流拿到解码器上下文
    pCodeCtx_Audio = ofmt_ctx->streams[audioindex]->codec;
 
    //再根据上下文拿到编解码id，通过该id拿到解码器
    pCodec_Audio = ffmpeg.avcodec_find_decoder(pCodeCtx_Audio->codec_id);
    if (pCodec_Audio == null)
    {
     Console.WriteLine("没有找到编码器");
     return -1;
    }
    //打开编码器
    if (ffmpeg.avcodec_open2(pCodeCtx_Audio, pCodec_Audio, null) < 0)
    {
     Console.WriteLine("编码器无法打开");
     return -1;
    }
    Console.WriteLine("Find a audio stream. channel=" + audioindex);
 
    //解压缩数据
    frame_Audio = ffmpeg.av_frame_alloc();
 
    //frame->16bit 8000 PCM 统一音频采样格式与采样率
    swrCtx_Audio = ffmpeg.swr_alloc();
    //重采样设置选项-----------------------------------------------------------start
    //输入的采样格式
    AVSampleFormat in_sample_fmt = pCodeCtx_Audio->sample_fmt;
    //输出的采样格式 16bit PCM
    out_sample_fmt = AVSampleFormat.AV_SAMPLE_FMT_S16;
    //输入的采样率
    int in_sample_rate = pCodeCtx_Audio->sample_rate;
    //输出的采样率
    int out_sample_rate = 8000;
    //输入的声道布局
    long in_ch_layout = (long)pCodeCtx_Audio->channel_layout;
    //输出的声道布局
    int out_ch_layout = ffmpeg.AV_CH_LAYOUT_MONO;
 
    ffmpeg.swr_alloc_set_opts(swrCtx_Audio, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt, in_sample_rate, 0, null);
    ffmpeg.swr_init(swrCtx_Audio);
    //重采样设置选项-----------------------------------------------------------end
    //获取输出的声道个数
    out_channel_nb = ffmpeg.av_get_channel_layout_nb_channels((ulong)out_ch_layout);
    //存储pcm数据
    out_buffer_audio = (byte*)ffmpeg.av_malloc(2 * 8000);
   }
   #endregion
 
   //缓冲区，开辟空间
   packet = (AVPacket*)ffmpeg.av_malloc((ulong)sizeof(AVPacket));
 
   // 设置SDL播放对象
   this.sdlVideo = sdlVideo;
   this.sdlAudio = sdlAudio; 
   isInit = true; 
   return 0;
  } 
 
  /// <summary>
  /// 读取音视频流文件并进行播放
  /// </summary>
  public unsafe int ReadAndPlay(PlayFinishedDo playFinishedDo)
  {
   IsRun = true;
   exit_thread = false;
   pause_thread = false;
   thread = Thread.CurrentThread;
   //int error, frame_count = 0;
   int got_frame, ret;
   //SwsContext* pSwsCtx = null;
 
   byte* out_audio_buffer = out_buffer_audio;
 
   try
   {
    AVStream* video_stream = ofmt_ctx->streams[videoindex];
 
    while (ffmpeg.av_read_frame(ofmt_ctx, packet) >= 0&& !exit_thread)
    {
     // 暂停解析
     while (pause_thread||isLastFrame)
     {
      // 退出线程
      if (exit_thread)
      {
       break;
      }
      Thread.Sleep(10);
     }
     // 退出线程
     if (exit_thread)
     {
      break;
     }
 
     // 此处记录视频的第一帧和第一帧的开始时间
     if (firstPts == -1 && packet->stream_index == videoindex)
     {
      firstPts = packet->pts * 1000 / (video_stream->time_base.den / video_stream->time_base.num);
      startTS = DateTime.Now;
     }
     // 针对视频做延时播放，音频自然播放就行不做处理
     if (packet->stream_index == videoindex)
     {
      long pts_1 = packet->pts * 1000 / (video_stream->time_base.den / video_stream->time_base.num);
      DeleyToPlay(pts_1);
     }
 
     #region 视频H264转YUV并使用SDL进行播放
     if (packet->stream_index == videoindex)
     {
      //解码一帧视频压缩数据，得到视频像素数据
      ret = ffmpeg.avcodec_decode_video2(pCodecCtx_Video, pFrame_Video, &got_frame, packet);
      if (ret < 0)
      {
       Console.WriteLine("视频解码错误");
       return -1;
      }
 
      //滤波,亮度，对比度===参考JT1078ToYuv -----------开始
      int width = pCodecCtx_Video->width;
      int height = pCodecCtx_Video->height;
      if (contrast != contrast_last || brightness != brightness_last)
      {
       m_video_filtering.Reset(width, height, contrast, brightness);
       contrast_last = contrast;
       brightness_last = brightness;
      }
 
      //滤波,亮度，对比度===参考JT1078ToYuv -----------结束
 
      // 读取解码后的帧数据
      if (got_frame > 0)
      {
       video_frame_count++;
       //>>>>滤波,亮度，对比度===参考JT1078ToYuv -----------开始
       AVFrame* frame_filter;
       ret = m_video_filtering.Filter(pFrame_Video, &frame_filter);
       //>>>>滤波,亮度，对比度===参考JT1078ToYuv -----------结束
 
 
       //AVFrame转为像素格式YUV420，宽高
       ffmpeg.sws_scale(sws_ctx_video, frame_filter->data, frame_filter->linesize, 0, pCodecCtx_Video->height, pFrameYUV_Video->data, pFrameYUV_Video->linesize);
 
       // 记录上一帧图像保持10个帧数
       AVVideo videoFrame = new AVVideo(pCodecCtx_Video->width, pCodecCtx_Video->height, (IntPtr)out_buffer_video, out_buffer_size_video, pFrameYUV_Video->linesize[0]);
       list.Add(videoFrame);
       if (list.Count > 10) list.RemoveAt(0);
 
       // SDL播放YUV数据：下面两种方式都可以进行播放
       sdlVideo.SDL_Display(pCodecCtx_Video->width, pCodecCtx_Video->height,YuvWidth, YuvHeight, (IntPtr)out_buffer_video, out_buffer_size_video, pFrameYUV_Video->linesize[0]);
       //sdlVideo.SDL_Display(pCodecCtx_Video->width, pCodecCtx_Video->height, (IntPtr)pFrameYUV_Video->data[0], out_buffer_size_video, pFrameYUV_Video->linesize[0]);
 
       // 播放下一帧时进行暂停
       if (isNextFrame)
       {
        Pause();
        isNextFrame = false;
       }
 
       // 释放滤波
       m_video_filtering.UnrefFrame();
      }
     }
     #endregion
 
     #region 音频AAC转PCM并使用SDL进行播放
     if (packet->stream_index == audioindex)
     {
      //解码AVPacket->AVFrame
      ret = ffmpeg.avcodec_decode_audio4(pCodeCtx_Audio, frame_Audio, &got_frame, packet);
      if (ret < 0)
      {
       Console.WriteLine("音频解码失败");
       return -1;
      }
      // 读取帧数据
      if (got_frame > 0)
      {
       audio_frame_count++;
    
       // 变换音频
       ffmpeg.swr_convert(swrCtx_Audio, &out_audio_buffer, 2 * 8000, (byte**)&frame_Audio->data, frame_Audio->nb_samples);
 
       // 获取sample的size
       out_buffer_size_audio = ffmpeg.av_samples_get_buffer_size(null, out_channel_nb, frame_Audio->nb_samples, out_sample_fmt, 1);
 
       // SDL进行音频播放
       sdlAudio.PlayAudio((IntPtr)out_audio_buffer, out_buffer_size_audio); 
      }
     }
     #endregion
     
     //释放资源
     ffmpeg.av_free_packet(packet);
 
     Thread.Sleep(10);
    } 
 
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex);
   }
   finally
   {
    // 释放文件流
    ffmpeg.avformat_free_context(ofmt_ctx);
    // 修改右键菜单回调函数
    playFinishedDo.Invoke();
   }
   IsRun = false;
   IsPause = false;
   return 0;
  }
 
  bool isLastFrame = false;
  bool isNextFrame = false;
  bool playFastly = false;
  bool playSlowly = false;
  int play_speed = 1;
  long firstPts = -1;
  DateTime startTS;
  /// <summary>
  /// 控制快慢
  /// </summary>
  /// <param name="pts"></param>
  /// <param name="speed"></param>
  private void DeleyToPlay(long pts)
  {
   int delayTime = 0;
   try
   {
    // 计算延时
    double delay = (DateTime.Now - startTS).TotalMilliseconds;
    var i = (int)(pts - firstPts - delay);
    if (i >= 100)
    {
     delayTime = 40;
     delayTime = ControlFastOrSlow(delayTime);
    }
    else if (i >= 300)
    {
     delayTime = 60;
     delayTime = ControlFastOrSlow(delayTime);
    }
    else if (i >= 500)
    {
     delayTime = 100;
     delayTime = ControlFastOrSlow(delayTime);
    }
   }
   catch
   {
    Console.WriteLine("Counting delay time error ");
   }
   finally
   {
    Console.WriteLine("Counting delay time = " + delayTime+ " play_speed="+ play_speed);
    if (delayTime > 0)
     Thread.Sleep(delayTime);
		 } 
  }
 
  /// <summary>
  /// 控制快慢
  /// </summary>
  /// <param name="delayTime"></param>
  private int ControlFastOrSlow(int delayTime)
  {
   if (playFastly)
   {
    // 快放
    delayTime /= play_speed;
   }
   else if (playSlowly)
   {
    // 慢放
    delayTime *= play_speed;
   }
   return delayTime;
  } 
  /// <summary>
  /// 开启线程
  /// </summary>
  /// <param name="fileName"></param>
  /// <param name="sdlVideo"></param>
  /// <param name="sdlAudio"></param>
  public void Start(PlayFinishedDo playFinishedDo)
  {
   if (!isInit)
   {
    MessageBox.Show("没有初始化");
   }
   thread = new Thread(() =>
   {
    try
    {
     ReadAndPlay(playFinishedDo);
    }
    catch (Exception ex)
    {
     SQ.Base.ErrorLog.WriteLog4Ex("JT1078CodecForMp4.Run Video", ex);
    }
   });
   thread.IsBackground = true;
   thread.Start(); 
  }
 
  /// <summary>
  /// 暂停继续
  /// </summary>
  public void GoOnPlay()
  {
   // 重置第一帧pts，处理暂停后音视频不同步
   firstPts = -1;
   // 继续的相关操作和变量修改
   pause_thread = false;
   IsPause = pause_thread;
   sdlVideo.PlayVideo();
   sdlAudio.PlayAudio();
  }
 
  /// <summary>
  /// 暂停
  /// </summary>
  public void Pause()
  {
   // 暂停的相关操作和变量修改
   pause_thread = true;
   IsPause = pause_thread;
   sdlVideo.PauseVideo();
   sdlAudio.PauseAudio();
  }
 
  /// <summary>
  /// 停止
  /// </summary>
  public void Stop()
  {
   exit_thread = true;
   if (thread != null && thread.IsAlive)
   {
    thread.Abort();
    thread.Join();
    thread = null;
   }
  }
 
  /// <summary>
  /// 快放
  /// </summary>
  public void PlayFast()
  {
   if (pause_thread)
   {
    // 激活播放
    GoOnPlay();
   }
   if (playSlowly)
   {
    play_speed = 1;
    playSlowly = false;
   }
   else
   {
    play_speed++;
   }
   playFastly = true; 
  } 
 
  /// <summary>
  /// 慢放
  /// </summary>
  public void PlaySlow()
  {
   if (pause_thread)
   {
    // 激活播放
    GoOnPlay();
   }
   if (playFastly)
   {
    play_speed = 1;
    playFastly = false;
   }
   else
   {
    play_speed++;
   }
   playSlowly = true; 
  }
 
  /// <summary>
  /// 上一帧
  /// </summary>
  public void PlayLastFrame()
  {
   // 修改上一帧标志
   isLastFrame = true;
   // 每点击一次向前播一帧
   if (list.Count>0)
   {
    Console.WriteLine("剩余播放帧:"+ list.Count);
    // 激活播放
    GoOnPlay();
    AVVideo lastFrame = list.Last();
    // 播放上一帧图像
    sdlVideo.SDL_Display(lastFrame.width, lastFrame.height, lastFrame.pixels, lastFrame.pixelsSize, lastFrame.pitch);
    // 修改上一帧标志
    isLastFrame = false;
    // 移除已看过的帧
    list.Remove(lastFrame);
    Thread.Sleep(10);
    Pause();
   }   
  }
 
  /// <summary>
  /// 下一帧
  /// </summary>
  public void PlayNextFrame()
  {
   // 暂停以区分帧
   Pause();
   // 播放以完成下一帧图像显示或声音播放
   GoOnPlay();
   // 下一帧播放完成暂停标志
   isNextFrame = true;
  }
 }
 
 class Media
 {
  /// <summary>
  /// 0:video,1:audio
  /// </summary>
  public int type { get; set; }
 
  /// <summary>
  /// pts value
  /// </summary>
  public long pts { get; set; }
 }
 
 class AVVideo : Media
 {
  public int width { get; set; }
  public int height { get; set; }
  public IntPtr pixels { get; set; }
  public int pixelsSize { get; set; }
  public int pitch { get; set; }
 
  public AVVideo(int width, int height, IntPtr pixels, int pixelsSize, int pitch)
  {
   this.width = width;
   this.height = height;
   this.pixels = pixels;
   this.pixelsSize = pixelsSize;
   this.pitch = pitch;
  }
 }
 class AVAudio : Media
 {
  public IntPtr pcm { get; set; }
  public int len { get; set; }
 
  public AVAudio(IntPtr pcm, int len)
  {
   this.pcm = pcm;
   this.len = len;
  }
 }
}

以上这篇C# 使用SDL2实现Mp4文件播放音视频操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持自由互联。