/// <summary>
/// Opens the video stream with the specified index in the media container.
/// </summary>
/// <param name="container">The media container.</param>
/// <param name="options">The media options.</param>
/// <param name="stream">The stream.</param>
/// <returns>The opened <see cref="Decoder"/>.</returns>
internal static Decoder OpenStream(InputContainer container, MediaOptions options, AVStream *stream)
{
var format = container.Pointer;
AVCodec *codec = null;
var index = ffmpeg.av_find_best_stream(format, stream->codec->codec_type, stream->index, -1, &codec, 0);
index.IfError(ffmpeg.AVERROR_DECODER_NOT_FOUND, "Cannot find a codec for the specified stream.");
if (index < 0)
{
return(null);
}
var codecContext = ffmpeg.avcodec_alloc_context3(codec);
ffmpeg.avcodec_parameters_to_context(codecContext, stream->codecpar)
.ThrowIfError("Cannot open the stream codec!");
codecContext->pkt_timebase = stream->time_base;
var dict = new FFDictionary(options.DecoderOptions, false).Pointer;
ffmpeg.avcodec_open2(codecContext, codec, &dict)
.ThrowIfError("Cannot open the stream codec!");
return(new Decoder(codecContext, stream, container));
}
public bool AvFrameToImageByteArray(AVFrame frame, out byte[] pngData)
{
AVCodec * outCodec = ffmpeg.avcodec_find_encoder(AVCodecID.AV_CODEC_ID_PNG);
AVCodecContext *outCodecCtx = ffmpeg.avcodec_alloc_context3(outCodec);
outCodecCtx->width = _pCodecContext->width;
outCodecCtx->height = _pCodecContext->height;
outCodecCtx->pix_fmt = AVPixelFormat.AV_PIX_FMT_RGB24;
outCodecCtx->codec_type = AVMediaType.AVMEDIA_TYPE_VIDEO;
outCodecCtx->time_base.num = _pCodecContext->time_base.num;
outCodecCtx->time_base.den = _pCodecContext->time_base.den;
if (ffmpeg.avcodec_open2(outCodecCtx, outCodec, null) < 0)
{
pngData = new byte[] { };
return(false);
}
AVPacket outPacket = new AVPacket();
ffmpeg.av_init_packet(&outPacket);
outPacket.size = 0;
outPacket.data = null;
ffmpeg.avcodec_send_frame(outCodecCtx, &frame);
ffmpeg.avcodec_receive_packet(outCodecCtx, &outPacket);
pngData = new byte[outPacket.size];
Marshal.Copy((IntPtr)outPacket.data, pngData, 0, outPacket.size);
return(true);
}
//public AVFormatContext* PFormatContext
//{
// get
// {
// return _pFormatContext;
// }
//}
public VideoStreamDecoder(string url, AVHWDeviceType HWDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
_pFormatContext = ffmpeg.avformat_alloc_context();
_receivedFrame = ffmpeg.av_frame_alloc();
var pFormatContext = _pFormatContext;
ffmpeg.avformat_open_input(&pFormatContext, url, null, null).ThrowExceptionIfError();
ffmpeg.avformat_find_stream_info(_pFormatContext, null).ThrowExceptionIfError();
AVCodec *codec = null;
// TODO: Why is ffmpeg.AV_CODEC_FLAG_LOW_DELAY ignored!
_streamIndex = ffmpeg.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_VIDEO,
-1, -1, &codec, ffmpeg.AV_CODEC_FLAG_LOW_DELAY).ThrowExceptionIfError();
_pCodecContext = ffmpeg.avcodec_alloc_context3(codec);
if (HWDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
ffmpeg.av_hwdevice_ctx_create(&_pCodecContext->hw_device_ctx, HWDeviceType, null, null, 0).ThrowExceptionIfError();
}
ffmpeg.avcodec_parameters_to_context(_pCodecContext, _pFormatContext->streams[_streamIndex]->codecpar).ThrowExceptionIfError();
ffmpeg.avcodec_open2(_pCodecContext, codec, null).ThrowExceptionIfError();
CodecName = ffmpeg.avcodec_get_name(codec->id);
FrameSize = new Size(_pCodecContext->width, _pCodecContext->height);
PixelFormat = _pCodecContext->pix_fmt;
DurationMilliseconds = _pFormatContext->duration;
Framerate = 25;// _pFormatContext->video_codec->supported_framerates[0].num / _pFormatContext->video_codec->supported_framerates[0].den;
_pPacket = ffmpeg.av_packet_alloc();
_pFrame = ffmpeg.av_frame_alloc();
}
public DecoderStream(MediaFile file, ref AVStream stream)
{
// Initialize instance variables
m_disposed = false;
m_position = m_bufferUsedSize = 0;
m_file = file;
m_avStream = stream;
m_avCodecCtx = *m_avStream.codec;
// Open the decoding codec
AVCodec *avCodec = FFmpeg.avcodec_find_decoder(m_avCodecCtx.codec_id);
if (avCodec == null)
{
throw new DecoderException("No decoder found");
}
if (FFmpeg.avcodec_open(ref m_avCodecCtx, avCodec) < 0)
{
throw new DecoderException("Error opening codec");
}
m_codecOpen = true;
}
public StreamDecoder(
AVFormatContext *formatContext,
int streamIndex,
AVCodec *codec,
AVHWDeviceType hwDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
: base(null)
{
_streamIndex = streamIndex;
_formatContext = formatContext;
_stream = formatContext->streams[streamIndex];
_codecContext = ffmpeg.avcodec_alloc_context3(codec);
if (hwDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
ffmpeg.av_hwdevice_ctx_create(&_codecContext->hw_device_ctx, hwDeviceType, null, null, 0)
.ThrowExceptionIfError();
}
ffmpeg.avcodec_parameters_to_context(_codecContext, _stream->codecpar)
.ThrowExceptionIfError();
ffmpeg.avcodec_open2(_codecContext, codec, null).ThrowExceptionIfError();
_codecContext->pkt_timebase = _stream->time_base;
_codec = codec;
_packet = ffmpeg.av_packet_alloc();
_frame = ffmpeg.av_frame_alloc();
_receivedFrame = ffmpeg.av_frame_alloc();
}
public MediaStream(AVFormatContext *formatContext, int streamIndex, AVStream *rawStream, AVCodec *decodeCodec = null)
{
RawFormatContext = formatContext;
StreamIndex = streamIndex;
RawStream = rawStream;
_cachedRawDecodeCodec = decodeCodec;
}
/// <summary>
/// Opens the video stream with the specified index in the media container.
/// </summary>
/// <param name="container">The media container.</param>
/// <param name="options">The media options.</param>
/// <returns>The opened <see cref="Decoder{TFrame}"/>.</returns>
internal static Decoder <VideoFrame> OpenVideo(InputContainer container, MediaOptions options)
{
var format = container.Pointer;
AVCodec *codec = null;
var index = ffmpeg.av_find_best_stream(format, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0);
index.IfError(ffmpeg.AVERROR_DECODER_NOT_FOUND, "Cannot find a codec for the video stream.");
if (index < 0)
{
return(null);
}
var stream = format->streams[index];
var codecContext = ffmpeg.avcodec_alloc_context3(codec);
ffmpeg.avcodec_parameters_to_context(codecContext, stream->codecpar)
.ThrowIfError("Cannot open the video codec!");
codecContext->pkt_timebase = stream->time_base;
var dict = new FFDictionary(options.DecoderOptions, false).Pointer;
ffmpeg.avcodec_open2(codecContext, codec, &dict)
.ThrowIfError("Cannot open the video codec");
return(new Decoder <VideoFrame>(codecContext, stream, container));
}
public void SelectStream(AVMediaType type)
{
AVCodec *avCodec = null;
_streamIndex = ffmpeg.av_find_best_stream(_avFormatContext, type, -1, -1, &avCodec, 0).ThrowOnError();
_avCodecContext = ffmpeg.avcodec_alloc_context3(avCodec);
var stream = _avFormatContext->streams[_streamIndex];
if (HardwareDevice != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
ffmpeg.av_hwdevice_ctx_create(&_avCodecContext->hw_device_ctx, HardwareDevice, null, null, 0).ThrowOnError();
}
ffmpeg.avcodec_parameters_to_context(_avCodecContext, stream->codecpar).ThrowOnError();
ffmpeg.avcodec_open2(_avCodecContext, avCodec, null).ThrowOnError();
CodecId = avCodec->id;
CodecName = ffmpeg.avcodec_get_name(CodecId);
FrameSize = new Size(_avCodecContext->width, _avCodecContext->height);
AudioFrameSize = _avCodecContext->frame_size;;
PixelFormat = HardwareDevice == AVHWDeviceType.AV_HWDEVICE_TYPE_NONE ? _avCodecContext->pix_fmt : GetHWPixelFormat(HardwareDevice);
BitRate = _avCodecContext->bit_rate;
FrameRate = _avCodecContext->framerate;
TimeBase = stream->time_base;
}
public FFmpegContext(AVCodecID codecId)
{
_codec = ffmpeg.avcodec_find_decoder(codecId);
if (_codec == null)
{
Logger.Error?.PrintMsg(LogClass.FFmpeg, $"Codec wasn't found. Make sure you have the {codecId} codec present in your FFmpeg installation.");
return;
}
_context = ffmpeg.avcodec_alloc_context3(_codec);
if (_context == null)
{
Logger.Error?.PrintMsg(LogClass.FFmpeg, "Codec context couldn't be allocated.");
return;
}
if (ffmpeg.avcodec_open2(_context, _codec, null) != 0)
{
Logger.Error?.PrintMsg(LogClass.FFmpeg, "Codec couldn't be opened.");
return;
}
_packet = ffmpeg.av_packet_alloc();
if (_packet == null)
{
Logger.Error?.PrintMsg(LogClass.FFmpeg, "Packet couldn't be allocated.");
return;
}
_decodeFrame = Marshal.GetDelegateForFunctionPointer <AVCodec_decode>(_codec->decode.Pointer);
}
public H264VideoStreamEncoder(Stream stream, int fps, Size frameSize)
{
_stream = stream;
_frameSize = frameSize;
var codecId = AVCodecID.AV_CODEC_ID_H264;
_pCodec = ffmpeg.avcodec_find_encoder(codecId);
if (_pCodec == null)
{
throw new InvalidOperationException("Codec not found.");
}
_pCodecContext = ffmpeg.avcodec_alloc_context3(_pCodec);
_pCodecContext->width = frameSize.Width;
_pCodecContext->height = frameSize.Height;
_pCodecContext->time_base = new AVRational {
num = 1, den = fps
};
_pCodecContext->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
ffmpeg.av_opt_set(_pCodecContext->priv_data, "preset", "veryslow", 0);
ffmpeg.avcodec_open2(_pCodecContext, _pCodec, null).ThrowExceptionIfError();
_linesizeY = frameSize.Width;
_linesizeU = frameSize.Width / 2;
_linesizeV = frameSize.Width / 2;
_ySize = _linesizeY * frameSize.Height;
_uSize = _linesizeU * frameSize.Height / 2;
}
public FFmpegContext()
{
_codec = ffmpeg.avcodec_find_decoder(AVCodecID.AV_CODEC_ID_H264);
_context = ffmpeg.avcodec_alloc_context3(_codec);
ffmpeg.avcodec_open2(_context, _codec, null);
}
//@"D:\cshapdemo\ConsoleApp1\会不会.mp3"
public void open(String url)
{
//var codecId = AVCodecID.AV_CODEC_ID_MP3;
//_pCodecContext = ffmpeg.avcodec_alloc_context3(_pCodec);
// _pCodec = ffmpeg.avcodec_find_encoder(codecId);
//_pCodecContext = ffmpeg.avcodec_alloc_context3(_pCodec);
//_pCodecContext->time_base = new AVRational { num = 1, den = fps };
//ret = ffmpeg.avcodec_open2(_pCodecContext, _pCodec, null);
int ret = 0;
_pFormatContext = ffmpeg.avformat_alloc_context();
var pFormatContext = _pFormatContext;
ret = ffmpeg.avformat_open_input(&pFormatContext, url, null, null);
ret = ffmpeg.avformat_find_stream_info(pFormatContext, null);
for (int i = 0; i < pFormatContext->nb_streams; i++)
{
if (pFormatContext->streams[i]->codecpar->codec_type == AVMediaType.AVMEDIA_TYPE_AUDIO)
{
_streamIndex = i;
break;
}
}
_pCodecContext = pFormatContext->streams[_streamIndex]->codec;
AVCodec *codec = ffmpeg.avcodec_find_decoder(_pCodecContext->codec_id);
ret = ffmpeg.avcodec_open2(_pCodecContext, codec, null);//初始化编码器
ffmpeg.av_dump_format(pFormatContext, _streamIndex, url, 0);
}
public VideoEncoder(AVCodecID codecID, int frameWidth, int frameHeight, int framesPerSecond)
{
_frameWidth = frameWidth;
_frameHeight = frameHeight;
_videoCodec = ffmpeg.avcodec_find_encoder(codecID);
if (_videoCodec == null)
{
throw new ApplicationException($"Codec encoder could not be found for {codecID}.");
}
_videoCodecContext = ffmpeg.avcodec_alloc_context3(_videoCodec);
if (_videoCodecContext == null)
{
throw new ApplicationException("Failed to allocated codec context.");
}
_videoCodecContext->width = frameWidth;
_videoCodecContext->height = frameHeight;
_videoCodecContext->time_base.den = 30;
_videoCodecContext->time_base.num = 1;
_videoCodecContext->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
ffmpeg.avcodec_open2(_videoCodecContext, _videoCodec, null).ThrowExceptionIfError();
}
public VideoDecoder()
{
AVCodec *codec = FFmpegInvoke.avcodec_find_decoder(CodecId);
if (codec == null)
{
throw new Exception("Codec not found");
}
codec_context = FFmpegInvoke.avcodec_alloc_context3(codec);
if (codec_context == null)
{
throw new Exception("Could not allocate video codec context");
}
if (FFmpegInvoke.avcodec_open2(codec_context, codec, null) < 0)
{
throw new Exception("Could not open codec");
}
avFrame = FFmpegInvoke.avcodec_alloc_frame();
if (avFrame == null)
{
throw new Exception("Could not allocate video frame");
}
}
public VideoStreamDecoder(string url, AVHWDeviceType HWDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
_pFormatContext = ffmpeg.avformat_alloc_context();
_receivedFrame = ffmpeg.av_frame_alloc();
var pFormatContext = _pFormatContext;
ffmpeg.avformat_open_input(&pFormatContext, url, null, null).ThrowExceptionIfError();
ffmpeg.avformat_find_stream_info(_pFormatContext, null).ThrowExceptionIfError();
AVCodec *codec = null;
_streamIndex = ffmpeg
.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &codec, 0)
.ThrowExceptionIfError();
_pCodecContext = ffmpeg.avcodec_alloc_context3(codec);
if (HWDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
ffmpeg.av_hwdevice_ctx_create(&_pCodecContext->hw_device_ctx, HWDeviceType, null, null, 0)
.ThrowExceptionIfError();
}
ffmpeg.avcodec_parameters_to_context(_pCodecContext, _pFormatContext->streams[_streamIndex]->codecpar)
.ThrowExceptionIfError();
ffmpeg.avcodec_open2(_pCodecContext, codec, null).ThrowExceptionIfError();
CodecName = ffmpeg.avcodec_get_name(codec->id);
FrameSize = new Size(_pCodecContext->width, _pCodecContext->height);
PixelFormat = _pCodecContext->pix_fmt;
_pPacket = ffmpeg.av_packet_alloc();
_pFrame = ffmpeg.av_frame_alloc();
}
/// <summary>
/// Finds the best stream of the specified type in the file.
/// </summary>
/// <param name="container">The media container.</param>
/// <param name="type">Type of the stream to find.</param>
/// <param name="relStream">Optional. Index of the related stream.</param>
/// <returns>Index of the found stream, otherwise <see langword="null"/>.</returns>
private static int?FindBestStream(AVFormatContext *container, AVMediaType type, int relStream = -1)
{
AVCodec *codec = null;
var id = ffmpeg.av_find_best_stream(container, type, -1, relStream, &codec, 0);
return(id >= 0 ? (int?)id : null);
}
internal StreamContext(AVStream *stream, FFMPEGDecoder source)
{
_stream = stream;
_source = source;
var origCtx = _stream->codec;
//find the corresponding codec
_codec = ffmpeg.avcodec_find_decoder(origCtx->codec_id);
if (_codec == null)
{
throw new NotSupportedException("This " + ffmpeg.av_get_media_type_string(origCtx->codec_type) +
" codec is not supported by the current ffmpeg binaries!");
}
//copy the context from ffmpeg (required because we don't own the other one)
_codecCtx = ffmpeg.avcodec_alloc_context3(_codec);
if (ffmpeg.avcodec_parameters_to_context(_codecCtx, _stream->codecpar) != 0)
{
throw new Exception("Couldn't copy stream parameters!");
}
if (ffmpeg.avcodec_open2(_codecCtx, _codec, null) != 0)
{
throw new Exception("Couldn't copy the codec!");
}
_decoded = ffmpeg.av_frame_alloc();
}
private static unsafe AVStream *add_audio_stream(AVFormatContext *oc, AVCodecID codec_id, int sample_rate = 44100)
{
AVCodecContext *c;
AVCodec * encoder = ffmpeg.avcodec_find_encoder(codec_id);
AVStream * st = ffmpeg.avformat_new_stream(oc, encoder);
if (st == null)
{
die("av_new_stream");
}
c = st->codec;
c->codec_id = codec_id;
c->codec_type = AVMediaType.AVMEDIA_TYPE_AUDIO;
/* put sample parameters */
c->bit_rate = 64000;
c->sample_rate = sample_rate;
c->channels = 2;
c->sample_fmt = encoder->sample_fmts[0];
c->channel_layout = ffmpeg.AV_CH_LAYOUT_STEREO;
// some formats want stream headers to be separate
if ((oc->oformat->flags & ffmpeg.AVFMT_GLOBALHEADER) != 0)
{
c->flags |= ffmpeg.AV_CODEC_FLAG_GLOBAL_HEADER;
}
return(st);
}
public FFmpegCodec(FFmpegFuncs ffmpeg, AVCodec *codec)
{
this.ffmpeg = ffmpeg;
Pointer = codec;
SupportedHwDeviceTypes = new Lazy <IReadOnlyList <AVHWDeviceType> >(() =>
{
var list = new List <AVHWDeviceType>();
int i = 0;
while (true)
{
var hwCfg = ffmpeg.avcodec_get_hw_config(codec, i);
if (hwCfg == null)
{
break;
}
list.Add(hwCfg->device_type);
i++;
}
return(list);
});
}
public static unsafe Codec[] GetAllDecoders()
{
List <Codec> codecs = new List <Codec>();
void * i = null;
AVCodec *c = null;
while ((c = av_codec_iterate(&i)) != null)
{
if (av_codec_is_decoder(c) != 0)
{
var desc = Marshal.PtrToStringAnsi((IntPtr)c->long_name);
var name = Marshal.PtrToStringAnsi((IntPtr)c->name);
List <AVPixelFormat> formats = new List <AVPixelFormat>();
var fmt = c->pix_fmts;
while (fmt != null && *fmt != AVPixelFormat.AV_PIX_FMT_NONE)
{
formats.Add(*fmt);
fmt++;
}
codecs.Add(new Codec(name, desc, formats.ToArray()));
}
}
return(codecs.ToArray());
}
public AudioStreamDecoder(string url, AVHWDeviceType HWDeviceType = AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
_pFormatContext = ffmpeg.avformat_alloc_context();
_receivedFrame = ffmpeg.av_frame_alloc();
var pFormatContext = _pFormatContext;
ffmpeg.avformat_open_input(&pFormatContext, url, null, null).ThrowExceptionIfError();
ffmpeg.avformat_find_stream_info(_pFormatContext, null).ThrowExceptionIfError();
AVCodec *videoCodec = null;
_streamVideoIndex = ffmpeg.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_VIDEO, -1, -1, &videoCodec, 0).ThrowExceptionIfError();
_pVideoCodecContext = ffmpeg.avcodec_alloc_context3(videoCodec);
if (HWDeviceType != AVHWDeviceType.AV_HWDEVICE_TYPE_NONE)
{
ffmpeg.av_hwdevice_ctx_create(&_pVideoCodecContext->hw_device_ctx, HWDeviceType, null, null, 0).ThrowExceptionIfError();
}
ffmpeg.avcodec_parameters_to_context(_pVideoCodecContext, _pFormatContext->streams[_streamVideoIndex]->codecpar).ThrowExceptionIfError();
if (_pFormatContext->streams[_streamVideoIndex]->avg_frame_rate.den != 0)
{
Fps = _pFormatContext->streams[_streamVideoIndex]->avg_frame_rate.num / _pFormatContext->streams[_streamVideoIndex]->avg_frame_rate.den;
Console.WriteLine("计算得到FPS");
}
else
{
Console.WriteLine("默认FPS");
Fps = 25;
}
ffmpeg.avcodec_open2(_pVideoCodecContext, videoCodec, null).ThrowExceptionIfError();
CodecName = ffmpeg.avcodec_get_name(videoCodec->id);
FrameSize = new Size(_pVideoCodecContext->width, _pVideoCodecContext->height);
PixelFormat = _pVideoCodecContext->pix_fmt;
_pPacket = ffmpeg.av_packet_alloc();
_pFrame = ffmpeg.av_frame_alloc();
AVCodec *audioCodec = null;
_streamAudioIndex = ffmpeg.av_find_best_stream(_pFormatContext, AVMediaType.AVMEDIA_TYPE_AUDIO, -1, -1, &audioCodec, 0).ThrowExceptionIfError();
_pAudioCodecContext = ffmpeg.avcodec_alloc_context3(audioCodec);
ffmpeg.avcodec_parameters_to_context(_pAudioCodecContext, _pFormatContext->streams[_streamAudioIndex]->codecpar).ThrowExceptionIfError();
ffmpeg.avcodec_open2(_pAudioCodecContext, audioCodec, null).ThrowExceptionIfError();
if (_streamAudioIndex > 0)
{
AVStream *avs = _pFormatContext->streams[_streamAudioIndex];
Console.WriteLine($"codec_id:{avs->codecpar->codec_id}");
Console.WriteLine($"format:{avs->codecpar->format}");
Console.WriteLine($"sample_rate:{avs->codecpar->sample_rate}");
Console.WriteLine($"channels:{avs->codecpar->channels}");
Console.WriteLine($"frame_size:{avs->codecpar->frame_size}");
in_sample_fmt = _pAudioCodecContext->sample_fmt;
in_sample_rate = _pAudioCodecContext->sample_rate; //输入的采样率
in_ch_layout = _pAudioCodecContext->channel_layout; //输入的声道布局
in_channels = _pAudioCodecContext->channels;
in_start_time = avs->start_time;
}
}
private void InitializeVideo()
{
// Extract pixel format and codec id
var inputCodecContext = *(InputVideoStream->codec);
var inputPixelFormat = inputCodecContext.pix_fmt;
var inputCodecId = inputCodecContext.codec_id;
// Populate basic properties
VideoCodec = inputCodecContext.codec_id.ToString(); // Utils.GetAnsiString(new IntPtr(inputCodecContext.codec_name));
VideoBitrate = (int)inputCodecContext.bit_rate;
VideoFrameWidth = inputCodecContext.width;
VideoFrameHeight = inputCodecContext.height;
VideoFrameRate = Convert.ToDecimal(Convert.ToDouble(inputCodecContext.framerate.num) / Convert.ToDouble(inputCodecContext.framerate.den));
VideoFrameLength = VideoFrameRate > 0M ? 1M / VideoFrameRate : 0M;
// Get an input decoder for the input codec
AVCodec *inputDecoder = ffmpeg.avcodec_find_decoder(inputCodecId);
if (inputDecoder == null)
{
throw new Exception("Unsupported video codec");
}
// Create a Software Sacaling context -- this allows us to do fast colorspace conversion
VideoResampler = ffmpeg.sws_getContext(
VideoFrameWidth, VideoFrameHeight, inputPixelFormat,
VideoFrameWidth, VideoFrameHeight, Constants.VideoOutputPixelFormat,
(int)ffmpeg.SWS_BILINEAR, null, null, null);
if (VideoResampler == null)
{
throw new Exception("Could not initialize the output conversion context");
}
//Create an output codec context. -- We copy the data from the input context and we
//then proceed to adjust some output parameters.
// Before it said: var outputCodecContext = &inputCodecContext;
VideoCodecContext = ffmpeg.avcodec_alloc_context3(inputDecoder);
if (ffmpeg.avcodec_copy_context(VideoCodecContext, &inputCodecContext) != Constants.SuccessCode)
{
throw new Exception("Could not create video output codec context from input");
}
if ((inputDecoder->capabilities & (int)ffmpeg.AV_CODEC_CAP_TRUNCATED) == (int)ffmpeg.AV_CODEC_CAP_TRUNCATED)
{
VideoCodecContext->flags |= (int)ffmpeg.AV_CODEC_FLAG_TRUNCATED;
}
if (ffmpeg.avcodec_open2(VideoCodecContext, inputDecoder, null) < Constants.SuccessCode)
{
throw new Exception("Could not open codec");
}
// All output frames will have the same length and will be held by the same structure; the Decoder frame holder.
DecodedPictureHolder = ffmpeg.av_frame_alloc();
OutputPictureBufferLength = ffmpeg.avpicture_get_size(Constants.VideoOutputPixelFormat, VideoFrameWidth, VideoFrameHeight);
}
public void Initialize(int width, int height, int frames_per_second)
{
Reset();
ffmpeg.avformat_network_init();
fixed(AVFormatContext **c = &formatContext)
{
if (ffmpeg.avformat_alloc_output_context2(c, null, "flv", null) < 0)
{
throw new Exception("Could not allocate output format context!");
}
}
codec = ffmpeg.avcodec_find_encoder(AVCodecID.AV_CODEC_ID_H264);
if (codec == null)
{
throw new Exception("codec not found!");
}
context = ffmpeg.avcodec_alloc_context3(codec);
if (context == null)
{
throw new Exception("alloc context fail");
}
context->codec_id = codec->id;
context->codec_type = AVMediaType.AVMEDIA_TYPE_VIDEO;
context->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
context->bit_rate = 400000;
context->width = width;
context->height = height;
context->time_base = new AVRational {
num = 1, den = frames_per_second
};
context->framerate = new AVRational {
num = frames_per_second, den = 1
};
context->gop_size = 50;
context->max_b_frames = 1;
context->qmin = 10;
context->qmax = 50;
context->level = 41;
context->refs = 1;
// context->max_b_frames = 0; // 去掉B帧只留下I帧和P帧
this.frames_per_second = frames_per_second;
if (codec->id == AVCodecID.AV_CODEC_ID_H264)
{
ffmpeg.av_opt_set(context->priv_data, "preset", "slow", 0);
// ffmpeg.av_opt_set(context->priv_data, "tune", "zerolatency", 0); // 零延迟
}
if ((formatContext->oformat->flags & ffmpeg.AVFMT_GLOBALHEADER) != 0)
{
context->flags |= ffmpeg.AV_CODEC_FLAG_GLOBAL_HEADER;
}
}
public H264Encoder(string outputPath, Size frameSize)
{
ffmpeg.RootPath = Path.Join(TestData.SolutionDir, "ffmpeg", "bin");
Console.WriteLine("FFMPEG version: " + ffmpeg.av_version_info());
_frameSize = frameSize;
var codecId = AVCodecID.AV_CODEC_ID_H264;
_pCodec = ffmpeg.avcodec_find_encoder(codecId);
if (_pCodec == null)
{
throw new InvalidOperationException("Codec not found.");
}
_pCodecContext = ffmpeg.avcodec_alloc_context3(_pCodec);
_pCodecContext->width = frameSize.Width;
_pCodecContext->height = frameSize.Height;
_pCodecContext->time_base = new AVRational {
num = 1, den = 1000
};
_pCodecContext->pix_fmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
ffmpeg.av_opt_set(_pCodecContext->priv_data, "preset", "superfast", 0);
ffmpeg.avcodec_open2(_pCodecContext, _pCodec, null).ThrowExceptionIfError();
_linesizeY = frameSize.Width;
_linesizeU = frameSize.Width / 2;
_linesizeV = frameSize.Width / 2;
_ySize = _linesizeY * frameSize.Height;
_uSize = _linesizeU * frameSize.Height / 2;
_swsContext = null;
// Allocate a frame
_frame = ffmpeg.av_frame_alloc();
_frame->width = _pCodecContext->width;
_frame->height = _pCodecContext->height;
_frame->format = (int)_pCodecContext->pix_fmt;
ffmpeg.av_frame_get_buffer(_frame, 32);
// Create output context for mp4
AVFormatContext *outputContext;
ffmpeg.avformat_alloc_output_context2(&outputContext, null, "mp4", null).ThrowExceptionIfError();
_outputContext = outputContext;
ffmpeg.avio_open2(&_outputContext->pb, outputPath, ffmpeg.AVIO_FLAG_WRITE, null, null);
// Create video stream in mp4 container
_stream = ffmpeg.avformat_new_stream(_outputContext, _pCodec);
ffmpeg.avcodec_parameters_from_context(_stream->codecpar, _pCodecContext)
.ThrowExceptionIfError();
_stream->sample_aspect_ratio = _pCodecContext->sample_aspect_ratio;
_stream->time_base = _pCodecContext->time_base;
ffmpeg.avformat_write_header(_outputContext, null);
}
public Codec(AVCodec *ptr)
{
if (ptr == null)
{
throw new ArgumentNullException(nameof(ptr));
}
_p = ptr;
}
private static AVCodec *CheckCodec(AVCodec *codec)
{
if (codec->Type != AVMediaType.Video)
{
throw new ArgumentException($"{codec->Id}不是视频格式");
}
return(codec);
}
public unsafe void InitialiseSource()
{
if (!_isInitialised)
{
_isInitialised = true;
_fmtCtx = ffmpeg.avformat_alloc_context();
_fmtCtx->flags = ffmpeg.AVFMT_FLAG_NONBLOCK;
var pFormatContext = _fmtCtx;
ffmpeg.avformat_open_input(&pFormatContext, _sourceUrl, _inputFormat, null).ThrowExceptionIfError();
ffmpeg.avformat_find_stream_info(_fmtCtx, null).ThrowExceptionIfError();
ffmpeg.av_dump_format(_fmtCtx, 0, _sourceUrl, 0);
// Set up audio decoder.
AVCodec *audCodec = null;
_audioStreamIndex = ffmpeg.av_find_best_stream(_fmtCtx, AVMediaType.AVMEDIA_TYPE_AUDIO, -1, -1, &audCodec, 0).ThrowExceptionIfError();
logger.LogDebug($"FFmpeg file source decoder {ffmpeg.avcodec_get_name(audCodec->id)} audio codec for stream {_audioStreamIndex}.");
_audDecCtx = ffmpeg.avcodec_alloc_context3(audCodec);
if (_audDecCtx == null)
{
throw new ApplicationException("Failed to allocate audio decoder codec context.");
}
ffmpeg.avcodec_parameters_to_context(_audDecCtx, _fmtCtx->streams[_audioStreamIndex]->codecpar).ThrowExceptionIfError();
ffmpeg.avcodec_open2(_audDecCtx, audCodec, null).ThrowExceptionIfError();
// Set up an audio conversion context so that the decoded samples can always be delivered as signed 16 bit mono PCM.
_swrContext = ffmpeg.swr_alloc();
ffmpeg.av_opt_set_sample_fmt(_swrContext, "in_sample_fmt", _audDecCtx->sample_fmt, 0);
ffmpeg.av_opt_set_sample_fmt(_swrContext, "out_sample_fmt", AVSampleFormat.AV_SAMPLE_FMT_S16, 0);
ffmpeg.av_opt_set_int(_swrContext, "in_sample_rate", _audDecCtx->sample_rate, 0);
ffmpeg.av_opt_set_int(_swrContext, "out_sample_rate", Helper.AUDIO_SAMPLING_RATE, 0);
//FIX:Some Codec's Context Information is missing
if (_audDecCtx->channel_layout == 0)
{
long in_channel_layout = ffmpeg.av_get_default_channel_layout(_audDecCtx->channels);
ffmpeg.av_opt_set_channel_layout(_swrContext, "in_channel_layout", in_channel_layout, 0);
}
else
{
ffmpeg.av_opt_set_channel_layout(_swrContext, "in_channel_layout", (long)_audDecCtx->channel_layout, 0);
}
ffmpeg.av_opt_set_channel_layout(_swrContext, "out_channel_layout", ffmpeg.AV_CH_LAYOUT_MONO, 0);
ffmpeg.swr_init(_swrContext).ThrowExceptionIfError();
_audioTimebase = ffmpeg.av_q2d(_fmtCtx->streams[_audioStreamIndex]->time_base);
_audioAvgFrameRate = ffmpeg.av_q2d(_fmtCtx->streams[_audioStreamIndex]->avg_frame_rate);
_maxAudioFrameSpace = (int)(_audioAvgFrameRate > 0 ? 1000 / _audioAvgFrameRate : 10000 * Helper.AUDIO_SAMPLING_RATE);
}
}
internal static AVCodec *GetEncoder(AVCodecID codecID)
{
AVCodec *codec = FF.avcodec_find_encoder(codecID);
if (codec == null)
{
throw new ArgumentException($"未能找到编码器:{codecID}", nameof(codecID));
}
return(codec);
}
public AVStream *CreateNewStream(AVCodec *codec = null)
{
var stream = ffmpeg.avformat_new_stream(fmtContext, codec);
if (stream == null)
{
throw new FFmpegException(ffmpeg.AVERROR(ffmpeg.ENOMEM), "Failed to create new stream.");
}
return(stream);
}
/// <summary>
/// Inits the Codec context.
/// </summary>
/// <param name="encoder">If set to <c>true</c> encoder.</param>
void CreateContext(bool encoder = false)
{
if (!Initialized)
{
throw new InvalidOperationException("Instance is not initialized yet, call Initialize() first");
}
else if (ContextCreated)
{
throw new InvalidOperationException("Context already initialized!");
}
if (encoder)
{
pCodec = ffmpeg.avcodec_find_encoder(avCodecID);
}
else
{
pCodec = ffmpeg.avcodec_find_decoder(avCodecID);
}
if (pCodec == null)
{
throw new InvalidOperationException("VideoCodec not found");
}
pCodecContext = ffmpeg.avcodec_alloc_context3(pCodec);
if (pCodecContext == null)
{
throw new InvalidOperationException("Could not allocate codec context");
}
// Call to abstract method
SetCodecContextParams(pCodecContext);
if ((pCodec->capabilities & ffmpeg.AV_CODEC_CAP_TRUNCATED) == ffmpeg.AV_CODEC_CAP_TRUNCATED)
{
pCodecContext->flags |= ffmpeg.AV_CODEC_FLAG_TRUNCATED;
}
if (ffmpeg.avcodec_open2(pCodecContext, pCodec, null) < 0)
{
throw new InvalidOperationException("Could not open codec");
}
if (doResample)
{
// Call to abstract method
pResampler = CreateResampler(pCodecContext);
if (ffmpeg.swr_is_initialized(pResampler) <= 0)
{
throw new InvalidOperationException("Failed to init resampler");
}
}
ContextCreated = true;
}
internal Codec (IntPtr ptr, CodecContext context)
{
if (context == null)
throw new ArgumentNullException ("context");
if (ptr == IntPtr.Zero)
throw new ArgumentException ("Null pointer");
this.ptr = ptr;
this.context = context;
this.codec = (AVCodec*)ptr;
Name = Marshal.PtrToStringAnsi ((IntPtr)this.codec->name);
}
