private async Task DownloadUrlPhotoAsync(string input, InputMediaType inputType)
{
try
{
var statsFile = $@"{_statsDirectory}\urls.csv";
IResult <string> mediaIdFromUrl = null;
if (!File.Exists(statsFile))
{
using (var csv = new Csv(statsFile, _delimiter))
{
csv.WriteHeader();
}
}
if (inputType == InputMediaType.Url)
{
mediaIdFromUrl = await _instaApi.GetMediaIdFromUrlAsync(new Uri(input));
if (!mediaIdFromUrl.Succeeded)
{
return;
}
}
var mediaId = mediaIdFromUrl == null ? input : mediaIdFromUrl.Value;
var mediaInformation = await _instaApi.GetMediaByIdAsync(mediaId);
if (!mediaInformation.Succeeded)
{
return;
}
_cancellationToken.ThrowIfCancellationRequested();
if (_mediaFilter.CheckFilters(mediaInformation.Value))
{
return;
}
if (CheckTotalDownloads())
{
await DownloadInstaMediaAsync(mediaInformation.Value, statsFile);
}
}
catch (Exception)
{
// something probably went wrong
}
}
private void GetPhotoList()
{
//Ищем фотографии для этого бота
var photo = db.ProductPhoto.Where(p => p.ProductId == ProductId).OrderByDescending(o => o.AttachmentFsId).Take(10);
//Проверяем загружены ли фотографии на сервер телеграм
foreach (ProductPhoto pp in photo)
{
var TelegramAttach = db.AttachmentTelegram.Where(a => a.AttachmentFsId == pp.AttachmentFsId && a.BotInfoId == BotId).LastOrDefault();
//файл уже загружен на сервер. Вытаскиваем FileID
if (TelegramAttach != null && TelegramAttach.FileId != null && TelegramAttach.FileId != "")
{
string Caption = db.AttachmentFs.Find(TelegramAttach.AttachmentFsId).Caption;
InputMediaType inputMediaType = new InputMediaType(TelegramAttach.FileId);
InputMediaPhoto mediaPhoto = new InputMediaPhoto {
Media = inputMediaType, Caption = Caption
};
PhotoListMedia.Add(mediaPhoto);
//Добавляем в ассоциативный массив данные о том что эта фотография уже загружена на сервер телеграм
MediaGroupPhoto.FsIdTelegramFileId.Add(Convert.ToInt32(TelegramAttach.AttachmentFsId), TelegramAttach.FileId);
}
//Файл еще не загруже на север телеграм
else
{
var AttachFs = db.AttachmentFs.Find(Convert.ToInt32(pp.AttachmentFsId));
MemoryStream ms = new MemoryStream(AttachFs.Fs);
InputMediaType inputMediaType = new InputMediaType(AttachFs.Name, ms);
InputMediaPhoto mediaPhoto = new InputMediaPhoto {
Media = inputMediaType, Caption = AttachFs.Caption
};
PhotoListMedia.Add(mediaPhoto);
MediaGroupPhoto.FsIdTelegramFileId.Add(Convert.ToInt32(pp.AttachmentFsId), null);
}
}
}
public void Close()
{
logger.Debug("MfH264Dxva2Decoder::Close()");
if (InputMediaType != null)
{
InputMediaType.Dispose();
InputMediaType = null;
}
if (OutputMediaType != null)
{
OutputMediaType.Dispose();
OutputMediaType = null;
}
if (decoder != null)
{
decoder.Dispose();
decoder = null;
}
}
public void Close()
{
logger.Debug("MfVideoProcessor::Close()");
if (InputMediaType != null)
{
InputMediaType.Dispose();
InputMediaType = null;
}
if (OutputMediaType != null)
{
OutputMediaType.Dispose();
OutputMediaType = null;
}
if (processor != null)
{
processor.Dispose();
processor = null;
}
}
public void Setup(MfVideoArgs inputArgs)
{
logger.Debug("MfH264Dxva2Decoder::Setup(...)");
var width = inputArgs.Width;
var height = inputArgs.Height;
var inputFormat = VideoFormatGuids.H264;
var frameRate = inputArgs.FrameRate;
LowLatency = inputArgs.LowLatency;
try
{
var transformFlags = //TransformEnumFlag.Hardware |
TransformEnumFlag.SortAndFilter;
var inputType = new TRegisterTypeInformation
{
GuidMajorType = MediaTypeGuids.Video,
GuidSubtype = VideoFormatGuids.H264
};
var transformActivators = MediaFactory.FindTransform(TransformCategoryGuids.VideoDecoder, transformFlags, inputType, null);
try
{
foreach (var activator in transformActivators)
{
//bool isHardware = flags.HasFlag(TransformEnumFlag.Hardware);
//bool isAsync = flags.HasFlag(TransformEnumFlag.Asyncmft);
string name = activator.Get(TransformAttributeKeys.MftFriendlyNameAttribute);
Guid clsid = activator.Get(TransformAttributeKeys.MftTransformClsidAttribute);
TransformEnumFlag flags = (TransformEnumFlag)activator.Get(TransformAttributeKeys.TransformFlagsAttribute);
bool isAsync = !(flags.HasFlag(TransformEnumFlag.Syncmft));
isAsync |= !!(flags.HasFlag(TransformEnumFlag.Asyncmft));
bool isHardware = !!(flags.HasFlag(TransformEnumFlag.Hardware));
var _flags = Enum.GetValues(typeof(TransformEnumFlag))
.Cast <TransformEnumFlag>()
.Where(m => (m != TransformEnumFlag.None && flags.HasFlag(m)));
var transformInfo = name + " " + clsid.ToString() + " " + string.Join("|", _flags);
logger.Info(transformInfo);
//encoder = activator.ActivateObject<Transform>();
//break;
//var HardwareUrl = activator.Get(TransformAttributeKeys.MftEnumHardwareUrlAttribute);
//logger.Info(HardwareUrl);
//var TransformAsync = activator.Get(TransformAttributeKeys.TransformAsync);
//logger.Info(TransformAsync);
//logger.Info("-------------------------------------");
}
}
finally
{
decoder = transformActivators[0].ActivateObject <Transform>();
foreach (var activator in transformActivators)
{
activator.Dispose();
}
}
using (var attr = decoder.Attributes)
{
bool d3dAware = attr.Get(TransformAttributeKeys.D3DAware);
if (d3dAware)
{
if (d3dDeviceManager != null)
{
decoder.ProcessMessage(TMessageType.SetD3DManager, d3dDeviceManager.NativePointer);
}
else
{
attr.Set(TransformAttributeKeys.D3DAware, false);
}
}
attr.Set(SinkWriterAttributeKeys.LowLatency, LowLatency);
//attr.Set(MFAttributeKeys.MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT, 1);
}
int inputStreamCount = -1;
int outputStreamsCount = -1;
decoder.GetStreamCount(out inputStreamCount, out outputStreamsCount);
int[] inputStreamIDs = new int[inputStreamCount];
int[] outputStreamIDs = new int[outputStreamsCount];
bool res = decoder.TryGetStreamIDs(inputStreamIDs, outputStreamIDs);
if (res)
{
inputStreamId = inputStreamIDs[0];
outputStreamId = outputStreamIDs[0];
}
else
{
inputStreamId = 0;
outputStreamId = 0;
}
for (int i = 0; ; i++)
{
try
{
decoder.GetInputAvailableType(0, i, out MediaType mediaType);
if (mediaType == null)
{
logger.Warn("NoMoreType");
break;
}
var formatId = mediaType.Get(MediaTypeAttributeKeys.Subtype);
if (formatId == inputFormat)
{
logger.Debug("inputFormat " + inputFormat);
InputMediaType = mediaType;
break;
}
mediaType.Dispose();
mediaType = null;
}
catch (SharpDX.SharpDXException ex)
{
if (ex.ResultCode != SharpDX.MediaFoundation.ResultCode.NoMoreTypes)
{
throw;
}
}
}
if (InputMediaType == null)
{
logger.Warn("Unsuported format: " + MfTool.GetMediaTypeName(inputFormat));
return;
}
InputMediaType.Set(MediaTypeAttributeKeys.MajorType, MediaTypeGuids.Video);
InputMediaType.Set(MediaTypeAttributeKeys.Subtype, VideoFormatGuids.H264);
InputMediaType.Set(MediaTypeAttributeKeys.FrameSize, MfTool.PackToLong(width, height));
InputMediaType.Set(MediaTypeAttributeKeys.FrameRate, frameRate);
// InputMediaType.Set(MediaTypeAttributeKeys.PixelAspectRatio, MfTool.PackToLong(1, 1));
InputMediaType.Set(MediaTypeAttributeKeys.InterlaceMode, (int)VideoInterlaceMode.Progressive);
InputMediaType.Set(MediaTypeAttributeKeys.AllSamplesIndependent, 1);
decoder.SetInputType(inputStreamId, InputMediaType, 0);
logger.Info("============== INPUT TYPE==================");
logger.Info(MfTool.LogMediaType(InputMediaType));
OutputMediaType = new MediaType();
OutputMediaType.Set(MediaTypeAttributeKeys.MajorType, MediaTypeGuids.Video);
OutputMediaType.Set(MediaTypeAttributeKeys.Subtype, VideoFormatGuids.NV12);
//OutputMediaType.Set(MediaTypeAttributeKeys.AvgBitrate, 30000000);
OutputMediaType.Set(MediaTypeAttributeKeys.InterlaceMode, (int)VideoInterlaceMode.Progressive);
OutputMediaType.Set(MediaTypeAttributeKeys.FrameSize, MfTool.PackToLong(width, height));
OutputMediaType.Set(MediaTypeAttributeKeys.FrameRate, frameRate);
OutputMediaType.Set(MediaTypeAttributeKeys.AllSamplesIndependent, 1);
decoder.SetOutputType(outputStreamId, OutputMediaType, 0);
logger.Info("============== OUTPUT TYPE==================");
logger.Info(MfTool.LogMediaType(OutputMediaType));
}
catch (Exception ex)
{
logger.Error(ex);
Close();
throw;
}
}
public void Close()
{
logger.Debug("MfEncoderAsync::Close()");
closing = true;
if (InputMediaType != null)
{
InputMediaType.Dispose();
InputMediaType = null;
}
if (OutputMediaType != null)
{
OutputMediaType.Dispose();
OutputMediaType = null;
}
if (encoder != null)
{
//using (var shutdown = encoder.QueryInterface<Shutdownable>())
//{
// shutdown.Shutdown();
// //while(shutdown.ShutdownStatus != ShutdownStatus.Completed)
// //{
// // logger.Warn("shutdown.ShutdownStatus " + shutdown.ShutdownStatus);
// // Thread.Sleep(100);
// //}
//}
encoder.Dispose();
encoder = null;
}
if (bufSample != null)
{
bufSample.Dispose();
bufSample = null;
}
if (bufTexture != null)
{
bufTexture.Dispose();
bufTexture = null;
}
if (eventHandler != null)
{
eventHandler.EventReceived -= HandleMediaEvent;
eventHandler.Dispose();
eventHandler = null;
}
if (mediaEventGenerator != null)
{
mediaEventGenerator.Dispose();
mediaEventGenerator = null;
}
// logger.Info(SharpDX.Diagnostics.ObjectTracker.ReportActiveObjects());
}
private void SetupEncoder(MfVideoArgs args)
{
logger.Debug("SetupEncoder(...)");
var width = args.Width;
var height = args.Height;
var frameRate = args.FrameRate;
int avgBitrate = args.AvgBitrate;
int maxBitrate = args.MaxBitrate;
int mpegProfile = (int)args.Profile;
long pixelAspectRatio = args.AspectRatio;
//var inputFormat = VideoFormatGuids.Argb32;//VideoFormatGuids.NV12;
var inputFormat = args.Format;
logger.Info("Encoder input params: " + width + "x" + height + " fps=" + frameRate + " {" + inputFormat + "}");
using (var attr = encoder.Attributes)
{
// TODO:
// log pref
try
{
syncMode = !(attr.Get(TransformAttributeKeys.TransformAsync) == 1);
}
catch (SharpDX.SharpDXException ex)
{
syncMode = true;
}
if (!syncMode)
{
//var transformAsync = (attr.Get(TransformAttributeKeys.TransformAsync) == 1);
//if (transformAsync)
//{
attr.Set(TransformAttributeKeys.TransformAsyncUnlock, 1);
attr.Set(TransformAttributeKeys.MftSupportDynamicFormatChange, true);
bool d3d11Aware = attr.Get(TransformAttributeKeys.D3D11Aware);
if (d3d11Aware)
{
using (var devMan = new DXGIDeviceManager())
{
devMan.ResetDevice(device);
encoder.ProcessMessage(TMessageType.SetD3DManager, devMan.NativePointer);
}
}
//}
}
attr.Set(CodecApiPropertyKeys.AVLowLatencyMode, args.LowLatency);
attr.Set(CodecApiPropertyKeys.AVEncCommonRateControlMode, args.BitrateMode);
attr.Set(CodecApiPropertyKeys.AVEncCommonQuality, args.Quality);
attr.Set(CodecApiPropertyKeys.AVEncMPVGOPSize, args.GopSize);
// отключаем B-фреймы
attr.Set(CodecApiPropertyKeys.AVEncMPVDefaultBPictureCount, 0);
//attr.Set(CodecApiPropertyKeys.AVEncNumWorkerThreads, 4);
var attrLog = MfTool.LogMediaAttributes(attr);
logger.Debug("\r\nMFT:\r\n-----------------\r\n" + attrLog);
}
int inputStreamCount = -1;
int outputStreamsCount = -1;
encoder.GetStreamCount(out inputStreamCount, out outputStreamsCount);
int[] inputStreamIDs = new int[inputStreamCount];
int[] outputStreamIDs = new int[outputStreamsCount];
bool res = encoder.TryGetStreamIDs(inputStreamIDs, outputStreamIDs);
if (res)
{
inputStreamId = inputStreamIDs[0];
outputStreamId = outputStreamIDs[0];
}
else
{
inputStreamId = 0;
outputStreamId = 0;
}
for (int i = 0; ; i++)
{
if (!encoder.TryGetOutputAvailableType(outputStreamId, i, out MediaType mediaType))
{
//
logger.Warn("NoMoreOutputTypes");
break;
}
//var log = MfTool.LogMediaType(mediaType);
//logger.Warn(log);
mediaType.Set(MediaTypeAttributeKeys.InterlaceMode, (int)VideoInterlaceMode.Progressive);
mediaType.Set(MediaTypeAttributeKeys.FrameSize, MfTool.PackToLong(width, height));
mediaType.Set(MediaTypeAttributeKeys.FrameRate, frameRate);
mediaType.Set(MediaTypeAttributeKeys.AllSamplesIndependent, 1);
mediaType.Set(MediaTypeAttributeKeys.Mpeg2Profile, mpegProfile);
mediaType.Set(MediaTypeAttributeKeys.AvgBitrate, avgBitrate);
mediaType.Set(CodecApiPropertyKeys.AVEncCommonMaxBitRate, maxBitrate);
mediaType.Set(MediaTypeAttributeKeys.PixelAspectRatio, pixelAspectRatio);
encoder.SetOutputType(outputStreamId, mediaType, 0);
OutputMediaType = mediaType;
var _mediaLog = MfTool.LogMediaType(mediaType);
logger.Debug("\r\nOutputMediaType:\r\n-----------------\r\n" + _mediaLog);
//logger.Debug("\r\n" + i + ". AvailableOutputMediaType:\r\n-----------------\r\n" + mediaLog);
//mediaType.Dispose();
//mediaType = null;
break;
}
if (OutputMediaType == null)
{
//...
}
for (int i = 0; ; i++)
{
try
{
encoder.GetInputAvailableType(0, i, out MediaType availableType);
//var log = MfTool.LogMediaType(availableType);
//logger.Debug("\r\n" + i + ". AvalibleInputMediaType:\r\n-----------------\r\n" + log);
var formatId = availableType.Get(MediaTypeAttributeKeys.Subtype);
if (formatId == inputFormat)
{
InputMediaType = availableType;
availableType = null;
//logger.Debug("inputFormat " + inputFormat);
break;
}
if (availableType != null)
{
availableType.Dispose();
availableType = null;
}
}
catch (SharpDX.SharpDXException ex)
{
if (ex.ResultCode != SharpDX.MediaFoundation.ResultCode.NoMoreTypes)
{
throw;
}
break;
}
}
if (InputMediaType == null)
{
throw new FormatException("Unsuported input format: " + MfTool.GetMediaTypeName(inputFormat));
}
//InputMediaType.Set(MediaTypeAttributeKeys.MajorType, MediaTypeGuids.Video);
//InputMediaType.Set(MediaTypeAttributeKeys.Subtype, VideoFormatGuids.NV12);
InputMediaType.Set(MediaTypeAttributeKeys.FrameSize, MfTool.PackToLong(width, height));
InputMediaType.Set(MediaTypeAttributeKeys.FrameRate, frameRate);
InputMediaType.Set(MediaTypeAttributeKeys.InterlaceMode, (int)VideoInterlaceMode.Progressive);
InputMediaType.Set(MediaTypeAttributeKeys.AllSamplesIndependent, 1);
encoder.SetInputType(inputStreamId, InputMediaType, 0);
var mediaLog = MfTool.LogMediaType(InputMediaType);
logger.Debug("\r\nInputMediaType:\r\n-----------------\r\n" + mediaLog);
if (!syncMode)
{
mediaEventGenerator = encoder.QueryInterface <MediaEventGenerator>();
eventHandler = new MediaEventHandler(mediaEventGenerator);
eventHandler.EventReceived += HandleMediaEvent;
}
//encoder.GetInputStreamInfo(0, out TInputStreamInformation inputStreamInfo);
//var inputInfoFlags = (MftInputStreamInformationFlags)inputStreamInfo.DwFlags;
//logger.Debug(MfTool.LogEnumFlags(inputInfoFlags));
//encoder.GetOutputStreamInfo(0, out TOutputStreamInformation outputStreamInfo);
//var outputInfoFlags = (MftOutputStreamInformationFlags)outputStreamInfo.DwFlags;
//logger.Debug(MfTool.LogEnumFlags(outputInfoFlags));
//var guid = new Guid("901db4c7-31ce-41a2-85dc-8fa0bf41b8da");
//encoder.QueryInterface(guid, out var pUnk);
//var codecApi = (NativeAPIs.DShow.ICodecAPI)Marshal.GetObjectForIUnknown(pUnk);
////var code = codecApi.GetParameterRange(CodecApiPropertyKeys.AVEncMPVDefaultBPictureCount.Guid, out var valMin, out var valMax, out var sDelta);
//var code = codecApi.GetValue(CodecApiPropertyKeys.AVEncMPVDefaultBPictureCount.Guid, out var val);
}