public static AVPixelFormat GetFormat(AVCodecContext *context, AVPixelFormat *px_fmts)
{
while (*px_fmts != AVPixelFormat.AV_PIX_FMT_NONE)
{
if (*px_fmts == AVPixelFormat.AV_PIX_FMT_QSV)
{
AVHWFramesContext * fr_ctx;
AVQSVFramesContext *qsv_fr_ctx;
context->hw_frames_ctx = ffmpeg.av_hwframe_ctx_alloc(context->hw_device_ctx);
fr_ctx = (AVHWFramesContext *)context->hw_frames_ctx->data;
qsv_fr_ctx = (AVQSVFramesContext *)fr_ctx->hwctx;
int initialPoolSize = 32;
fr_ctx->format = AVPixelFormat.AV_PIX_FMT_QSV;
fr_ctx->sw_format = context->sw_pix_fmt;
fr_ctx->width = context->coded_width.FFALIGN(initialPoolSize);
fr_ctx->height = context->coded_height.FFALIGN(initialPoolSize);
fr_ctx->initial_pool_size = initialPoolSize;
qsv_fr_ctx->frame_type = (int)MFX_MEMTYPE.MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
ffmpeg.av_hwframe_ctx_init(context->hw_frames_ctx).ThrowExceptionIfError();
return(AVPixelFormat.AV_PIX_FMT_QSV);
}
px_fmts++;
}
return(AVPixelFormat.AV_PIX_FMT_NONE);
}
public AVPixelFormat GetPixelFormat(AVCodecContext *ctx, AVPixelFormat *pix_fmts)
{
for (var p = pix_fmts; *p != AVPixelFormat.AV_PIX_FMT_NONE; p++)
{
if (*pix_fmts == _hwPixFmt)
{
return(_hwPixFmt);
}
pix_fmts++;
}
return(_videoCodecContext->pix_fmt);
}
private AVPixelFormat GetFormatFunction(AVCodecContext *context, AVPixelFormat *formats)
{
for (var pixelFormat = formats; *pixelFormat != AVPixelFormat.AV_PIX_FMT_NONE; pixelFormat++)
{
var value = *pixelFormat;
if (value == found)
{
return(value);
}
}
throw new FFMpegException($"Failed to get hardware pixel format {found}");
}
private static AVPixelFormat GetFormat(AVCodecContext *s, AVPixelFormat *fmt)
{
int i = 0;
while ((int)fmt[i] != -1)
{
if (fmt[i] == AVPixelFormat.AV_PIX_FMT_YUVJ444P)
{
fmt[i] = AVPixelFormat.AV_PIX_FMT_YUV444P;
}
i++;
}
return(ffmpeg.avcodec_default_get_format(s, fmt));
}
/// <summary>
/// DXVA Video Callback when AVCodec Opening to determine if the track matches the HWAccel format
/// </summary>
/// <param name="avctx"></param>
/// <param name="pix_fmts"></param>
/// <returns></returns>
private unsafe AVPixelFormat Get_Format_DXVA(AVCodecContext *avctx, AVPixelFormat *pix_fmts)
{
while (*pix_fmts != AVPixelFormat.AV_PIX_FMT_NONE)
{
if (*pix_fmts == AVPixelFormat.AV_PIX_FMT_DXVA2_VLD)
{
return(AVPixelFormat.AV_PIX_FMT_D3D11VA_VLD);
}
pix_fmts++;
}
WriteLine("The DXVA2 pixel format not offered in get_format()\n");
return(AVPixelFormat.AV_PIX_FMT_NONE);
}
/// <summary>
/// Cuda Video Callback when AVCodec Opening to determine if the track matches the HWAccel format
/// </summary>
/// <param name="avctx"></param>
/// <param name="pix_fmts"></param>
/// <returns></returns>
private unsafe AVPixelFormat Get_Format_CUDA(AVCodecContext *avctx, AVPixelFormat *pix_fmts)
{
WriteLine("Get_Format: CUDA");
while (*pix_fmts != AVPixelFormat.AV_PIX_FMT_NONE)
{
if (*pix_fmts == AVPixelFormat.AV_PIX_FMT_CUDA)
{
//DecodeContext* decode = avctx->opaque;
AVHWFramesContext *frames_ctx;
//ffmpeg.AVQSVFramesContext* frames_hwctx;
int ret;
/* create a pool of surfaces to be used by the decoder */
avctx->hw_frames_ctx = ffmpeg.av_hwframe_ctx_alloc(avctx->hw_device_ctx);
if (avctx->hw_frames_ctx == null)
{
return(AVPixelFormat.AV_PIX_FMT_NONE);
}
frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
//frames_hwctx = (ffmpeg.AVQSVFramesContext*)frames_ctx->hwctx;
frames_ctx->format = AVPixelFormat.AV_PIX_FMT_CUDA;
frames_ctx->sw_format = avctx->sw_pix_fmt;
frames_ctx->width = avctx->coded_width;
frames_ctx->height = avctx->coded_height;
frames_ctx->initial_pool_size = 1;
//frames_hwctx->frame_type = (int)ffmpeg.MFXMemType.MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
ret = ffmpeg.av_hwframe_ctx_init(avctx->hw_frames_ctx);
if (ret < 0)
{
return(AVPixelFormat.AV_PIX_FMT_NONE);
}
return(AVPixelFormat.AV_PIX_FMT_CUDA);
}
pix_fmts++;
}
WriteLine("The CUDA pixel format not offered in get_format()\n");
return(AVPixelFormat.AV_PIX_FMT_NONE);
}
private unsafe AVPixelFormat GetHWPixelFormat(AVHWDeviceType hwDevice, AVCodec *codec)
{
const int AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 1;
AVPixelFormat pixelFormat = AVPixelFormat.AV_PIX_FMT_NONE;
for (int i = 0; ; i++)
{
AVCodecHWConfig *hwConfig = ffmpeg.avcodec_get_hw_config(codec, i);
if (hwConfig == null)
{
throw new Exception($"Failed to find compatible pixel format for {hwDevice}");
}
if ((hwConfig->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) == 0 || hwConfig->device_type != hwDevice)
{
continue;
}
AVHWFramesConstraints *hwConstraints = ffmpeg.av_hwdevice_get_hwframe_constraints(_pCodecContext->hw_device_ctx, hwConfig);
if (hwConstraints != null)
{
for (AVPixelFormat *p = hwConstraints->valid_sw_formats; *p != AVPixelFormat.AV_PIX_FMT_NONE; p++)
{
pixelFormat = *p;
if (ffmpeg.sws_isSupportedInput(pixelFormat) > 0)
{
break;
}
else
{
pixelFormat = AVPixelFormat.AV_PIX_FMT_NONE;
}
}
ffmpeg.av_hwframe_constraints_free(&hwConstraints);
}
if (pixelFormat != AVPixelFormat.AV_PIX_FMT_NONE)
{
return(pixelFormat);
}
}
}
/// <summary>
/// Gets the pixel format.
/// Port of (get_format) method in ffmpeg.c
/// </summary>
/// <param name="avctx">The codec context.</param>
/// <param name="pix_fmts">The pixel formats.</param>
/// <returns>The real pixel format that the codec will be using</returns>
private AVPixelFormat GetPixelFormat(AVCodecContext *avctx, AVPixelFormat *pix_fmts)
{
// The default output is the first pixel format found.
var output = *pix_fmts;
// Iterate throught the different pixel formats provided by the codec
for (var p = pix_fmts; *p != AVPixelFormat.AV_PIX_FMT_NONE; p++)
{
// Try to select a hardware output pixel format that matches the HW device
if (*pix_fmts == PixelFormat)
{
output = PixelFormat;
break;
}
// Otherwise, just use the default SW pixel format
output = *p;
}
// Return the current pixel format.
return(output);
}
public static extern int av_opt_get_pixel_fmt(void *obj, byte *name, int search_flags, AVPixelFormat *out_fmt);
public static extern AVPixelFormat avcodec_default_get_format(AVCodecContext *s, AVPixelFormat *fmt);
public static extern AVPixelFormat avcodec_find_best_pix_fmt_of_list(AVPixelFormat *pix_fmt_list, AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);