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 data = new List();
 
  //private List data = new List();
  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
 {
  
  /// 
  /// 指示当前解码是否在运行
  /// 
  public bool IsRun { get; protected set; }
  /// 
  /// 视频线程
  /// 
  private Thread threadVideo;
  /// 
  /// 音频线程
  /// 
  private Thread threadAudio;
  /// 
  /// 退出控制
  /// 
  private bool exit_thread = false;
  /// 
  /// 暂停控制
  /// 
  private bool pause_thread = false;
  /// 
  /// 视频输出流videoindex
  /// 
  private int videoindex = -1;
  /// 
  /// 音频输出流audioindex
  /// 
  private int audioindex = -1;
 
  /// 
  /// 视频H264转YUV并使用SDL进行播放
  /// 
  /// 
  /// 
  /// 
  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;
  }
 
  /// 
  /// 音频AAC转PCM并使用SDL进行播放
  /// 
  /// 
  /// 
  /// 
  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;
  } 
 
  /// 
  /// 开启线程
  /// 
  /// 
  /// 
  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();
  }
 
  /// 
  /// 暂停继续
  /// 
  public void GoOn()
  {
   pause_thread = false;
 
  }
 
  /// 
  /// 暂停
  /// 
  public void Pause()
  {
   pause_thread = true;
  }
 
  /// 
  /// 停止
  /// 
  public void Stop()
  {
   exit_thread = true;
  }
 }
}

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

测试代码及效果图

C# 使用SDL2实现Mp4文件播放音视频操作_第1张图片

 /// 
  /// 播放
  /// 
  /// 
  /// 
  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);
  }

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

/// 
  /// 播放视频
  /// 
  /// 
  /// 
  /// 
  /// 
  /// 
  /// 
  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);//此处代码导致播放窗口绿色阴影

修改后效果：

C# 使用SDL2实现Mp4文件播放音视频操作_第2张图片

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

/// 
 /// MP4播放(音视频使用同一个线程)
 /// 
 public unsafe class JT1078CodecToPlayMp4Two
 {
 
  /// 
  /// 指示当前解码是否在运行
  /// 
  public bool IsRun { get; protected set; }
  /// 
  /// 当前线程
  /// 
  private Thread thread;
  /// 
  /// 退出控制
  /// 
  private bool exit_thread = false;
  /// 
  /// 暂停控制
  /// 
  private bool pause_thread = false;
  /// 
  /// 视频输出流videoindex
  /// 
  private int videoindex = -1;
  /// 
  /// 音频输出流audioindex
  /// 
  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;
 
  /// 
  /// 初始化
  /// 
  /// 
  /// 
  /// 
  /// 
  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;
  } 
 
  /// 
  /// 读取音视频流文件并进行播放
  /// 
  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;
  }
 
  /// 
  /// 开启线程
  /// 
  /// 
  /// 
  /// 
  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(); 
  }
 
  /// 
  /// 暂停继续
  /// 
  public void GoOnPlay()
  {
   pause_thread = false;
   sdlVideo.PlayVideo();
   sdlAudio.PlayAudio();
  }
 
  /// 
  /// 暂停
  /// 
  public void Pause()
  {
   pause_thread = true;
   sdlVideo.PauseVideo();
   sdlAudio.PauseAudio();
  }
 
  /// 
  /// 停止
  /// 
  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
{ 
 /// 
 /// MP4播放(音视频使用同一个线程)
 /// 
 public unsafe class JT1078CodecToPlayMp4
 { 
  /// 
  /// 指示当前解码是否在运行
  /// 
  public bool IsRun { get; protected set; }
  /// 
  /// 指示当前解码是否在暂停
  /// 
  public bool IsPause { get; protected set; }
  /// 
  /// 当前线程
  /// 
  public Thread thread;
  /// 
  /// 退出控制
  /// 
  private bool exit_thread = false;
  /// 
  /// 暂停控制
  /// 
  private bool pause_thread = false;
  /// 
  /// 视频输出流videoindex
  /// 
  private int videoindex = -1;
  /// 
  /// 音频输出流audioindex
  /// 
  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;
 
  int contrast;// 对比度
  int brightness;// 亮度
  int contrast_last;// 对比度
  int brightness_last;// 亮度
 
  //对比度亮度
  private VideoFiltering m_video_filtering = new VideoFiltering();
 
  /// 
  /// 设置图像对比度和亮度
  /// 
  /// 
  /// 
  /// 
  public void SetContrastAndBrightness(int contrast, int brightness)
  {
   this.contrast = contrast;
   this.brightness = brightness;
  }
  /// 
  /// YUV宽度
  /// 
  public int YuvWidth { get; set; }
  /// 
  /// YUV高度
  /// 
  public int YuvHeight { get; set; }
 
  /// 
  /// 记录上一帧数据
  /// 
  List list = new List();
 
  /// 
  /// 初始化
  /// 
  /// 
  /// 
  /// 
  /// 
  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;
  } 
 
  /// 
  /// 读取音视频流文件并进行播放
  /// 
  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;
  /// 
  /// 控制快慢
  /// 
  /// 
  /// 
  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);
		 } 
  }
 
  /// 
  /// 控制快慢
  /// 
  /// 
  private int ControlFastOrSlow(int delayTime)
  {
   if (playFastly)
   {
    // 快放
    delayTime /= play_speed;
   }
   else if (playSlowly)
   {
    // 慢放
    delayTime *= play_speed;
   }
   return delayTime;
  } 
  /// 
  /// 开启线程
  /// 
  /// 
  /// 
  /// 
  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(); 
  }
 
  /// 
  /// 暂停继续
  /// 
  public void GoOnPlay()
  {
   // 重置第一帧pts，处理暂停后音视频不同步
   firstPts = -1;
   // 继续的相关操作和变量修改
   pause_thread = false;
   IsPause = pause_thread;
   sdlVideo.PlayVideo();
   sdlAudio.PlayAudio();
  }
 
  /// 
  /// 暂停
  /// 
  public void Pause()
  {
   // 暂停的相关操作和变量修改
   pause_thread = true;
   IsPause = pause_thread;
   sdlVideo.PauseVideo();
   sdlAudio.PauseAudio();
  }
 
  /// 
  /// 停止
  /// 
  public void Stop()
  {
   exit_thread = true;
   if (thread != null && thread.IsAlive)
   {
    thread.Abort();
    thread.Join();
    thread = null;
   }
  }
 
  /// 
  /// 快放
  /// 
  public void PlayFast()
  {
   if (pause_thread)
   {
    // 激活播放
    GoOnPlay();
   }
   if (playSlowly)
   {
    play_speed = 1;
    playSlowly = false;
   }
   else
   {
    play_speed++;
   }
   playFastly = true; 
  } 
 
  /// 
  /// 慢放
  /// 
  public void PlaySlow()
  {
   if (pause_thread)
   {
    // 激活播放
    GoOnPlay();
   }
   if (playFastly)
   {
    play_speed = 1;
    playFastly = false;
   }
   else
   {
    play_speed++;
   }
   playSlowly = true; 
  }
 
  /// 
  /// 上一帧
  /// 
  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();
   }   
  }
 
  /// 
  /// 下一帧
  /// 
  public void PlayNextFrame()
  {
   // 暂停以区分帧
   Pause();
   // 播放以完成下一帧图像显示或声音播放
   GoOnPlay();
   // 下一帧播放完成暂停标志
   isNextFrame = true;
  }
 }
 
 class Media
 {
  /// 
  /// 0:video,1:audio
  /// 
  public int type { get; set; }
 
  /// 
  /// pts value
  /// 
  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文件播放音视频操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

你可能感兴趣的:(C# 使用SDL2实现Mp4文件播放音视频操作)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 下载github patch到本地 小米人er 我的博客gitpatch
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 微信开发者验证接口开发 362217990 微信 开发者 token 验证
    微信开发者接口验证。 Token，自己随便定义，与微信填写一致就可以了。 根据微信接入指南描述 http://mp.weixin.qq.com/wiki/17/2d4265491f12608cd170a95559800f2d.html 第一步：填写服务器配置 第二步：验证服务器地址的有效性 第三步：依据接口文档实现业务逻辑 这里主要讲第二步验证服务器有效性。 建一个
  • 一个小编程题-类似约瑟夫环问题 BrokenDreams 编程
            今天群友出了一题：         一个数列,把第一个元素删除,然后把第二个元素放到数列的最后,依次操作下去,直到把数列中所有的数都删除,要求依次打印出这个过程中删除的数。      &
  • linux复习笔记之bash shell (5) 关于减号-的作用 eksliang linux关于减号“-”的含义linux关于减号“-”的用途linux关于“-”的含义linux关于减号的含义
        转载请出自出处： http://eksliang.iteye.com/blog/2105677        管道命令在bash的连续处理程序中是相当重要的，尤其在使用到前一个命令的studout（标准输出）作为这次的stdin（标准输入）时，就显得太重要了，某些命令需要用到文件名，例如上篇文档的的切割命令（split）、还有
  • Unix(3) 18289753290 unix ksh
    1)若该变量需要在其他子进程执行，则可用"$变量名称"或${变量}累加内容 什么是子进程？在我目前这个shell情况下，去打开一个新的shell，新的那个shell就是子进程。一般状态下，父进程的自定义变量是无法在子进程内使用的，但通过export将变量变成环境变量后就能够在子进程里面应用了。 2)条件判断： &&代表and  ||代表or&nbs
  • 关于ListView中性能优化中图片加载问题 酷的飞上天空 ListView
    ListView的性能优化网上很多信息，但是涉及到异步加载图片问题就会出现问题。 具体参看上篇文章http://314858770.iteye.com/admin/blogs/1217594   如果每次都重新inflate一个新的View出来肯定会造成性能损失严重，可能会出现listview滚动是很卡的情况，还会出现内存溢出。 现在想出一个方法就是每次都添加一个标识，然后设置图
  • 德国总理默多克：给国人的一堂“震撼教育”课 永夜-极光 教育
    http://bbs.voc.com.cn/topic-2443617-1-1.html德国总理默多克：给国人的一堂“震撼教育”课　 安吉拉—默克尔，一位经历过社会主义的东德人，她利用自己的博客，发表一番来华前的谈话，该说的话，都在上面说了，全世界想看想传播——去看看默克尔总理的博客吧！ 　　德国总理默克尔以她的低调、朴素、谦和、平易近人等品格给国人留下了深刻印象。她以实际行动为中国人上了一堂
  • 关于Java继承的一个小问题。。。 随便小屋 java
    今天看Java 编程思想的时候遇见一个问题，运行的结果和自己想想的完全不一样。先把代码贴出来！ //CanFight接口 interface Canfight { void fight(); } //ActionCharacter类 class ActionCharacter { public void fight() { System.out.pr
  • 23种基本的设计模式 aijuans 设计模式
    Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 　　Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 　　Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 　　Builder：将一个复杂对象的构建与它的表示分离，使得同
  • 《周鸿祎自述：我的互联网方法论》读书笔记 aoyouzi 读书笔记
    从用户的角度来看,能解决问题的产品才是好产品,能方便/快速地解决问题的产品,就是一流产品.   商业模式不是赚钱模式 一款产品免费获得海量用户后,它的边际成本趋于0,然后再通过广告或者增值服务的方式赚钱,实际上就是创造了新的价值链.   商业模式的基础是用户,木有用户,任何商业模式都是浮云.商业模式的核心是产品,本质是通过产品为用户创造价值. 商业模式还包括寻找需求
  • JavaScript动态改变样式访问技术 百合不是茶 JavaScriptstyle属性ClassName属性
      一:style属性 格式:  HTML元素.style.样式属性="值";   创建菜单:在html标签中创建 或者 在head标签中用数组创建   <html> <head> <title>style改变样式</title> </head> &l
  • jQuery的deferred对象详解 bijian1013 jquerydeferred对象
            jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。         每个版本都会引入一些新功能，从jQuery 1.5.0版本开始引入的一个新功能----deferred对象。    &nb
  • 淘宝开放平台TOP Bill_chen C++c物流C#
    淘宝网开放平台首页：http://open.taobao.com/ 淘宝开放平台是淘宝TOP团队的产品，TOP即TaoBao Open Platform， 是淘宝合作伙伴开发、发布、交易其服务的平台。 支撑TOP的三条主线为：    1.开放数据和业务流程     * 以API数据形式开放商品、交易、物流等业务；  &
  • 【大型网站架构一】大型网站架构概述 bit1129 网站架构
    大型互联网特点 面对海量用户、海量数据 大型互联网架构的关键指标 高并发 高性能 高可用 高可扩展性 线性伸缩性 安全性 大型互联网技术要点   前端优化 CDN缓存 反向代理 KV缓存 消息系统 分布式存储 NoSQL数据库 搜索 监控 安全 想到的问题： 1.对于订单系统这种事务型系统，如
  • eclipse插件hibernate tools安装 白糖_ Hibernate
    eclipse helios(3.6)版 1.启动eclipse 2.选择 Help > Install New Software...> 3.添加如下地址： http://download.jboss.org/jbosstools/updates/stable/helios/ 4.选择性安装：hibernate tools在All Jboss tool
  • Jquery easyui Form表单提交注意事项 bozch jquery easyui
    jquery easyui对表单的提交进行了封装，提交的方式采用的是ajax的方式，在开发的时候应该注意的事项如下：         1、在定义form标签的时候，要将method属性设置成post或者get，特别是进行大字段的文本信息提交的时候，要将method设置成post方式提交，否则页面会抛出跨域访问等异常。所以这个要
  • Trie tree(字典树)的Java实现及其应用-统计以某字符串为前缀的单词的数量 bylijinnan java实现
    import java.util.LinkedList; public class CaseInsensitiveTrie { /** 字典树的Java实现。实现了插入、查询以及深度优先遍历。 Trie tree's java implementation.(Insert,Search,DFS) Problem Description Igna
  • html css 鼠标形状样式汇总 chenbowen00 htmlcss
    css鼠标手型cursor中hand与pointer  Example：CSS鼠标手型效果 <a href="#" style="cursor:hand">CSS鼠标手型效果</a><br/>  Example：CSS鼠标手型效果 <a href="#" style=&qu
  • [IT与投资]IT投资的几个原则 comsci it
          无论是想在电商,软件,硬件还是互联网领域投资,都需要大量资金,虽然各个国家政府在媒体上都给予大家承诺,既要让市场的流动性宽松,又要保持经济的高速增长....但是,事实上,整个市场和社会对于真正的资金投入是非常渴望的,也就是说,表面上看起来,市场很活跃,但是投入的资金并不是很充足的......    
  • oracle with语句详解 daizj oraclewithwith as
    oracle with语句详解 转 在oracle中，select 查询语句，可以使用with,就是一个子查询，oracle 会把子查询的结果放到临时表中，可以反复使用 例子:注意，这是sql语句，不是pl/sql语句， 可以直接放到jdbc执行的 ----------------------------------------------------------------
  • hbase的简单操作 deng520159 数据库hbase
    近期公司用hbase来存储日志,然后再来分析 ,把hbase开发经常要用的命令找了出来. 用ssh登陆安装hbase那台linux后 用hbase shell进行hbase命令控制台! 表的管理 1）查看有哪些表 hbase(main)> list 2）创建表   # 语法：create <table>, {NAME => <family&g
  • C语言scanf继续学习、算术运算符学习和逻辑运算符 dcj3sjt126com c
    /* 2013年3月11日20:37:32 地点：北京潘家园 功能：完成用户格式化输入多个值 目的：学习scanf函数的使用 */ # include <stdio.h> int main(void) { int i, j, k; printf("please input three number:\n"); //提示用
  • 2015越来越好 dcj3sjt126com 歌曲
    越来越好 房子大了电话小了 感觉越来越好 假期多了收入高了 工作越来越好 商品精了价格活了 心情越来越好 天更蓝了水更清了 环境越来越好 活得有奔头人会步步高 想做到你要努力去做到 幸福的笑容天天挂眉梢 越来越好 婆媳和了家庭暖了 生活越来越好 孩子高了懂事多了 学习越来越好 朋友多了心相通了 大家越来越好 道路宽了心气顺了 日子越来越好 活的有精神人就不显
  • java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Tim feiteyizu mysql
    数据表中有记录的time字段（属性为timestamp）其值为：“0000-00-00 00:00:00” 程序使用select 语句从中取数据时出现以下异常： java.sql.SQLException:Value '0000-00-00' can not be represented as java.sql.Date   java.sql.SQLException: Valu
  • Ehcache（07）——Ehcache对并发的支持 234390216 并发ehcache锁ReadLockWriteLock
    Ehcache对并发的支持          在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同
  • mysql中blob,text字段的合成索引 jackyrong mysql
      在mysql中，原来有一个叫合成索引的，可以提高blob,text字段的效率性能， 但只能用在精确查询，核心是增加一个列，然后可以用md5进行散列，用散列值查找 则速度快 比如： create table abc(id varchar(10),context blog,hash_value varchar(40)); insert into abc(1,rep
  • 逻辑运算与移位运算 latty 位运算逻辑运算
    源码：正数的补码与原码相同例+7 源码：00000111 补码 ：00000111 （用8位二进制表示一个数） 负数的补码： 符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。   -7 源码： 10000111 ，其绝对值为00000111  取反加一：11111001 为-7补码 已知一个数的补码，求原码的操作分两种情况：
  • 利用XSD 验证XML文件 newerdragon javaxmlxsd
    XSD文件 （XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。 具体使用方法和定义请参看： http://www.w3school.com.cn/schema/index.asp java自jdk1.5以上新增了SchemaFactory类 可以实现对XSD验证的支持，使用起来也很方便。 以下代码可用在J
  • 搭建 CentOS 6 服务器(12) - Samba rensanning centos
    （1）安装 # yum -y install samba Installed: samba.i686 0:3.6.9-169.el6_5 # pdbedit -a rensn new password:123456 retype new password:123456 …… （2）Home文件夹 # mkdir /etc
  • Learn Nodejs 01 toknowme nodejs
    （1）下载nodejs https://nodejs.org/download/ 选择相应的版本进行下载     （2）安装nodejs 安装的方式比较多，请baidu下 我这边下载的是“node-v0.12.7-linux-x64.tar.gz”这个版本 （1）上传服务器 （2）解压 tar -zxvf  node-v0.12.
  • jquery控制自动刷新的代码举例 xp9802 jquery
    1、html内容部分  复制代码代码示例: <div id='log_reload'> <select name="id_s" size="1"> <option value='2'>-2s-</option> <option value='3'>-3s-</option
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他