C# 使用FFmpeg.Autogen对byte[]进行编解码，参考：https://github.com/vanjoge/CSharpVideoDemo
入口调用类：
using System;
using System.IO;
using System.Drawing;
using System.Runtime.InteropServices;
using FFmpeg.AutoGen;
namespace FFmpegAnalyzer
{
public class FFmpegWrapper
{
///
/// 默认的编码格式
///
public AVCodecID DefaultCodecFormat { get; set; } = AVCodecID.AV_CODEC_ID_H264;
///
/// 注册FFmpeg
///
public static void RegisterFFmpeg()
{
FFmpegBinariesHelper.RegisterFFmpegBinaries();
// 初始化注册ffmpeg相关的编码器
ffmpeg.av_register_all();
ffmpeg.avcodec_register_all();
ffmpeg.avformat_network_init();
}
///
/// 注册日志
/// .NET Framework 不支持日志注册
///
private unsafe void RegisterFFmpegLogger()
{
// 设置记录ffmpeg日志级别
ffmpeg.av_log_set_level(ffmpeg.AV_LOG_VERBOSE);
av_log_set_callback_callback logCallback = (p0, level, format, vl) =>
{
if (level > ffmpeg.av_log_get_level()) return;
var lineSize = 1024;
var lineBuffer = stackalloc byte[lineSize];
var printPrefix = 1;
ffmpeg.av_log_format_line(p0, level, format, vl, lineBuffer, lineSize, &printPrefix);
var line = Marshal.PtrToStringAnsi((IntPtr)lineBuffer);
Console.Write(line);
};
ffmpeg.av_log_set_callback(logCallback);
}
#region 编码器
///
/// 创建编码器
///
/// 编码前一帧原始数据的大小
/// rgb数据
public void CreateEncoder(Size frameSize, bool isRgb = true)
{
_fFmpegEncoder = new FFmpegEncoder(frameSize, isRgb);
_fFmpegEncoder.CreateEncoder(DefaultCodecFormat);
}
///
/// 编码
///
/// 编码帧数据
///
/// 释放编码器
///
public void DisposeEncoder()
{
_fFmpegEncoder.Dispose();
}
#endregion
#region 解码器
///
/// 创建解码器
///
/// 解码后数据的大小
/// Rgb数据
public void CreateDecoder(Size decodedFrameSize, bool isRgb = true)
{
_fFmpegDecoder = new FFmpegDecoder(decodedFrameSize, isRgb);
_fFmpegDecoder.CreateDecoder(DefaultCodecFormat);
}
///
/// 解码
///
/// 解码帧数据
///
/// 释放解码器
///
public void DisposeDecoder()
{
_fFmpegDecoder.Dispose();
}
#endregion
/// 编码器
private FFmpegEncoder _fFmpegEncoder;
/// 解码器
private FFmpegDecoder _fFmpegDecoder;
}
}
其它业务类：
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace FFmpegAnalyzer
{
internal class FFmpegBinariesHelper
{
private const string LD_LIBRARY_PATH = "LD_LIBRARY_PATH";
internal static void RegisterFFmpegBinaries()
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
var current = AppDomain.CurrentDomain.BaseDirectory;
var probe = $"FFmpeg/bin/{(Environment.Is64BitProcess ? @"x64" : @"x86")}";
while (current != null)
{
var ffmpegDirectory = Path.Combine(current, probe);
if (Directory.Exists(ffmpegDirectory))
{
Console.WriteLine($"FFmpeg binaries found in: {ffmpegDirectory}");
RegisterLibrariesSearchPath(ffmpegDirectory);
return;
}
current = Directory.GetParent(current)?.FullName;
}
break;
case PlatformID.Unix:
case PlatformID.MacOSX:
var libraryPath = Environment.GetEnvironmentVariable(LD_LIBRARY_PATH);
RegisterLibrariesSearchPath(libraryPath);
break;
}
}
private static void RegisterLibrariesSearchPath(string path)
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
SetDllDirectory(path);
break;
case PlatformID.Unix:
case PlatformID.MacOSX:
string currentValue = Environment.GetEnvironmentVariable(LD_LIBRARY_PATH);
if (string.IsNullOrWhiteSpace(currentValue) == false && currentValue.Contains(path) == false)
{
string newValue = currentValue + Path.PathSeparator + path;
Environment.SetEnvironmentVariable(LD_LIBRARY_PATH, newValue);
}
break;
}
}
[DllImport("kernel32", SetLastError = true)]
private static extern bool SetDllDirectory(string lpPathName);
}
}
using System;
using System.Drawing;
using System.Runtime.InteropServices;
using FFmpeg.AutoGen;
namespace FFmpegAnalyzer
{
///
/// 解码器
///
internal unsafe class FFmpegDecoder
{
/// 解码后数据的大小
/// Rgb数据
public FFmpegDecoder(Size decodedFrameSize, bool isRgb = true)
{
_decodedFrameSize = decodedFrameSize;
_isRgb = isRgb;
}
///
/// 创建解码器
///
/// 解码格式
public void CreateDecoder(AVCodecID codecFormat)
{
var originPixelFormat = AVPixelFormat.AV_PIX_FMT_YUV420P;
var destinationPixelFormat = _isRgb ? AVPixelFormat.AV_PIX_FMT_RGB24 : AVPixelFormat.AV_PIX_FMT_BGRA;
//获取解码器
_pDecodec = ffmpeg.avcodec_find_decoder(codecFormat);
if (_pDecodec == null) throw new InvalidOperationException("Codec not found.");
_pDecodecContext = ffmpeg.avcodec_alloc_context3(_pDecodec);
_pDecodecContext->width = _decodedFrameSize.Width;
_pDecodecContext->height = _decodedFrameSize.Height;
_pDecodecContext->time_base = new AVRational { num = 1, den = 30 };
_pDecodecContext->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
_pDecodecContext->framerate = new AVRational { num = 30, den = 1 };
_pDecodecContext->gop_size = 30;
// 设置预测算法
_pDecodecContext->flags |= ffmpeg.AV_CODEC_FLAG_PSNR;
_pDecodecContext->flags2 |= ffmpeg.AV_CODEC_FLAG2_FAST;
_pDecodecContext->max_b_frames = 0;
ffmpeg.av_opt_set(_pDecodecContext->priv_data, "preset", "veryfast", 0);
ffmpeg.av_opt_set(_pDecodecContext->priv_data, "tune", "zerolatency", 0);
//打开解码器
ffmpeg.avcodec_open2(_pDecodecContext, _pDecodec, null);
_pConvertContext = ffmpeg.sws_getContext(
_decodedFrameSize.Width,
_decodedFrameSize.Height,
originPixelFormat,
_decodedFrameSize.Width,
_decodedFrameSize.Height,
destinationPixelFormat,
ffmpeg.SWS_FAST_BILINEAR,
null, null, null);
if (_pConvertContext == null)
throw new ApplicationException("Could not initialize the conversion context.");
var convertedFrameBufferSize = ffmpeg.av_image_get_buffer_size(destinationPixelFormat, _decodedFrameSize.Width, _decodedFrameSize.Height, 1);
_convertedFrameBufferPtr = Marshal.AllocHGlobal(convertedFrameBufferSize);
_dstData = new byte_ptrArray4();
_dstLineSize = new int_array4();
ffmpeg.av_image_fill_arrays(ref _dstData, ref _dstLineSize, (byte*)_convertedFrameBufferPtr, destinationPixelFormat,
_decodedFrameSize.Width, _decodedFrameSize.Height, 1);
_isCodecRunning = true;
}
///
/// 解码
///
///
///
/// 释放
///
public void Dispose()
{
_isCodecRunning = false;
//释放解码器
ffmpeg.avcodec_close(_pDecodecContext);
ffmpeg.av_free(_pDecodecContext);
//释放转换器
Marshal.FreeHGlobal(_convertedFrameBufferPtr);
ffmpeg.sws_freeContext(_pConvertContext);
}
///
/// 转换成Rgb
///
///
///
using System;
using System.Runtime.InteropServices;
using System.Drawing;
using FFmpeg.AutoGen;
namespace FFmpegAnalyzer
{
///
/// 编码器
///
internal unsafe class FFmpegEncoder
{
/// 编码前一帧原始数据的大小
/// rgb数据
public FFmpegEncoder(Size frameSize, bool isRgb = true)
{
_frameSize = frameSize;
_isRgb = isRgb;
_rowPitch = isRgb ? _frameSize.Width * 3 : _frameSize.Width * 4;
}
///
/// 创建编码器
///
public void CreateEncoder(AVCodecID codecFormat)
{
var originPixelFormat = _isRgb ? AVPixelFormat.AV_PIX_FMT_RGB24 : AVPixelFormat.AV_PIX_FMT_BGRA;
var destinationPixelFormat = AVPixelFormat.AV_PIX_FMT_YUV420P;
_pCodec = ffmpeg.avcodec_find_encoder(codecFormat);
if (_pCodec == null)
throw new InvalidOperationException("Codec not found.");
_pCodecContext = ffmpeg.avcodec_alloc_context3(_pCodec);
_pCodecContext->width = _frameSize.Width;
_pCodecContext->height = _frameSize.Height;
_pCodecContext->framerate = new AVRational { num = 30, den = 1 };
_pCodecContext->time_base = new AVRational {num = 1, den = 30};
_pCodecContext->gop_size = 30;
_pCodecContext->pix_fmt = destinationPixelFormat;
// 设置预测算法
_pCodecContext->flags |= ffmpeg.AV_CODEC_FLAG_PSNR;
_pCodecContext->flags2 |= ffmpeg.AV_CODEC_FLAG2_FAST;
_pCodecContext->max_b_frames = 0;
ffmpeg.av_opt_set(_pCodecContext->priv_data, "preset", "veryfast", 0);
ffmpeg.av_opt_set(_pCodecContext->priv_data, "tune", "zerolatency", 0);
//打开编码器
ffmpeg.avcodec_open2(_pCodecContext, _pCodec, null);
_pConvertContext = ffmpeg.sws_getContext(_frameSize.Width, _frameSize.Height, originPixelFormat, _frameSize.Width, _frameSize.Height, destinationPixelFormat,
ffmpeg.SWS_FAST_BILINEAR, null, null, null);
if (_pConvertContext == null)
throw new ApplicationException("Could not initialize the conversion context.");
var convertedFrameBufferSize = ffmpeg.av_image_get_buffer_size(destinationPixelFormat, _frameSize.Width, _frameSize.Height, 1);
_convertedFrameBufferPtr = Marshal.AllocHGlobal(convertedFrameBufferSize);
_dstData = new byte_ptrArray4();
_dstLineSize = new int_array4();
ffmpeg.av_image_fill_arrays(ref _dstData, ref _dstLineSize, (byte*)_convertedFrameBufferPtr, destinationPixelFormat, _frameSize.Width, _frameSize.Height, 1);
_isCodecRunning = true;
}
///
/// 释放
///
public void Dispose()
{
if (!_isCodecRunning) return;
_isCodecRunning = false;
//释放编码器
ffmpeg.avcodec_close(_pCodecContext);
ffmpeg.av_free(_pCodecContext);
//释放转换器
Marshal.FreeHGlobal(_convertedFrameBufferPtr);
ffmpeg.sws_freeContext(_pConvertContext);
}
///
/// 编码
///
///
///
/// 转换成Yuv格式
///
///
///
///
///
using FFmpeg.AutoGen;
using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows;
namespace FFmpegAnalyzer
{
public sealed unsafe class VideoFrameConverter : IDisposable
{
private readonly IntPtr _convertedFrameBufferPtr;
private readonly System.Drawing.Size _destinationSize;
private readonly byte_ptrArray4 _dstData;
private readonly int_array4 _dstLinesize;
private readonly SwsContext* _pConvertContext;
///
/// 帧格式转换
///
///
///
///
///
public VideoFrameConverter(System.Drawing.Size sourceSize, AVPixelFormat sourcePixelFormat,
System.Drawing.Size destinationSize, AVPixelFormat destinationPixelFormat)
{
_destinationSize = destinationSize;
//分配并返回一个SwsContext。您需要它使用sws_scale()执行伸缩/转换操作
//主要就是使用SwsContext进行转换！！！
_pConvertContext = ffmpeg.sws_getContext((int)sourceSize.Width, (int)sourceSize.Height, sourcePixelFormat,
(int)destinationSize.Width,
(int)destinationSize.Height
, destinationPixelFormat,
ffmpeg.SWS_FAST_BILINEAR //默认算法 还有其他算法
, null
, null
, null //额外参数 在flasgs指定的算法，而使用的参数。如果 SWS_BICUBIC SWS_GAUSS SWS_LANCZOS这些算法。 这里没有使用
);
if (_pConvertContext == null) throw new ApplicationException("Could not initialize the conversion context.");
//获取媒体帧所需要的大小
var convertedFrameBufferSize = ffmpeg.av_image_get_buffer_size(destinationPixelFormat
, (int)destinationSize.Width, (int)destinationSize.Height
, 1);
//申请非托管内存,unsafe代码
_convertedFrameBufferPtr = Marshal.AllocHGlobal(convertedFrameBufferSize);
//转换帧的内存指针
_dstData = new byte_ptrArray4();
_dstLinesize = new int_array4();
//挂在帧数据的内存区把_dstData里存的的指针指向_convertedFrameBufferPtr
ffmpeg.av_image_fill_arrays(ref _dstData, ref _dstLinesize
, (byte*)_convertedFrameBufferPtr
, destinationPixelFormat
, (int)destinationSize.Width, (int)destinationSize.Height
, 1);
}
public void Dispose()
{
Marshal.FreeHGlobal(_convertedFrameBufferPtr);
ffmpeg.sws_freeContext(_pConvertContext);
}
public AVFrame Convert(AVFrame sourceFrame)
{
//转换格式
ffmpeg.sws_scale(_pConvertContext
, sourceFrame.data
, sourceFrame.linesize
, 0, sourceFrame.height
, _dstData, _dstLinesize);
var data = new byte_ptrArray8();
data.UpdateFrom(_dstData);
var linesize = new int_array8();
linesize.UpdateFrom(_dstLinesize);
return new AVFrame
{
data = data,
linesize = linesize,
width = (int)_destinationSize.Width,
height = (int)_destinationSize.Height
};
}
}
}
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows;
using FFmpeg.AutoGen;
namespace FFmpegAnalyzer
{
public sealed unsafe class VideoStreamDecoder : IDisposable
{
private readonly AVCodecContext* _pCodecContext;
private readonly AVFormatContext* _pFormatContext;
private readonly int _streamIndex;
//
private readonly AVFrame* _pFrame;
//
private readonly AVFrame* _receivedFrame;
private readonly AVPacket* _pPacket;
///
/// 视频解码器
///
/// 视频流URL
/// 硬件解码器类型(默认AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
public VideoStreamDecoder(string url, AVHWDeviceType HWDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
//分配一个AVFormatContext
_pFormatContext = ffmpeg.avformat_alloc_context();
//分配一个AVFrame
_receivedFrame = ffmpeg.av_frame_alloc();
var pFormatContext = _pFormatContext;
//将源音视频流传递给ffmpeg即ffmpeg打开源视频流
ffmpeg.avformat_open_input(&pFormatContext, url, null, null);
//获取音视频流信息
ffmpeg.avformat_find_stream_info(_pFormatContext, null);
AVCodec* codec = null;
//在源里找到最佳的流，如果指定了解码器，则根据解码器寻找流，将解码器传递给codec
_streamIndex = ffmpeg.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
//根据解码器分配一个AVCodecContext ，仅仅分配工具，还没有初始化。
_pCodecContext = ffmpeg.avcodec_alloc_context3(codec);
//如果硬解码
if (HWDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
//根据硬件编码类型创建AVHWDeviceContext，存在AVFormatContext.hw_device_ctx (_pCodecContext->hw_device_ctx)
ffmpeg.av_hwdevice_ctx_create(&_pCodecContext->hw_device_ctx, HWDeviceType, null, null, 0);
}
//将最佳流的格式参数传递给codecContext
ffmpeg.avcodec_parameters_to_context(_pCodecContext, _pFormatContext->streams[_streamIndex]->codecpar);
//根据codec初始化pCodecContext 。与_pCodecContext = ffmpeg.avcodec_alloc_context3(codec);对应
ffmpeg.avcodec_open2(_pCodecContext, codec, null);
CodecName = ffmpeg.avcodec_get_name(codec->id);
FrameSize = new System.Drawing.Size(_pCodecContext->width, _pCodecContext->height);
PixelFormat = _pCodecContext->pix_fmt;
//分配AVPacket
/* AVPacket用于存储压缩的数据，分别包括有音频压缩数据，视频压缩数据和字幕压缩数据。
它通常在解复用操作后存储压缩数据，然后作为输入传给解码器。或者由编码器输出然后传递给复用器。
对于视频压缩数据，一个AVPacket通常包括一个视频帧。对于音频压缩数据，可能包括几个压缩的音频帧。
*/
_pPacket = ffmpeg.av_packet_alloc();
//分配AVFrame
/*AVFrame用于存储解码后的音频或者视频数据。
AVFrame必须通过av_frame_alloc进行分配，通过av_frame_free释放。
*/
_pFrame = ffmpeg.av_frame_alloc();
}
public string CodecName { get; }
public System.Drawing.Size FrameSize { get; }
public AVPixelFormat PixelFormat { get; }
public void Dispose()
{
ffmpeg.av_frame_unref(_pFrame);
ffmpeg.av_free(_pFrame);
ffmpeg.av_packet_unref(_pPacket);
ffmpeg.av_free(_pPacket);
ffmpeg.avcodec_close(_pCodecContext);
var pFormatContext = _pFormatContext;
ffmpeg.avformat_close_input(&pFormatContext);
}
///
/// 解码下一帧帧
///
/// 参数返回解码后的帧
///
/// 获取媒体TAG信息
///
/// GetContextInfo()
{
AVDictionaryEntry* tag = null;
var result = new Dictionary();
while ((tag = ffmpeg.av_dict_get(_pFormatContext->metadata, "", tag, ffmpeg.AV_DICT_IGNORE_SUFFIX)) != null)
{
var key = Marshal.PtrToStringAnsi((IntPtr)tag->key);
var value = Marshal.PtrToStringAnsi((IntPtr)tag->value);
result.Add(key, value);
}
return result;
}
}
}
需要将ffmpeg的类库复制到生成目录上(对应FFmpegBinariesHelper.RegisterFFmpegBinaries()中的生成路径)
![C# 使用FFmpeg.Autogen对byte[]进行编解码_第1张图片](http://img.e-com-net.com/image/info8/327dde66764741cca94fd5dbecf3ba65.png)
使用代码：
FFmpegWrapper.RegisterFFmpeg();
_ffMpegWrapper = new FFmpegWrapper();
_ffMpegWrapper.CreateEncoder(new System.Drawing.Size(1920, 1080), true);
_ffMpegWrapper1 = new FFmpegWrapper();
_ffMpegWrapper1.CreateDecoder(new System.Drawing.Size(1920, 1080), true);
var encodeFrames = _ffMpegWrapper.EncodeFrames(Data);
var decodeFrames = _ffMpegWrapper1.DecodeFrames(encodeFrames);