22 #include <mfx/mfxvideo.h> 47 #define QSV_VERSION_ATLEAST(MAJOR, MINOR) \ 48 (MFX_VERSION_MAJOR > (MAJOR) || \ 49 MFX_VERSION_MAJOR == (MAJOR) && MFX_VERSION_MINOR >= (MINOR)) 85 mfxExtBuffer *ext_buffers[1];
102 static const struct {
113 #if QSV_VERSION_ATLEAST(1, 27) 141 if (err == MFX_ERR_NONE) {
150 "from the session\n");
154 if (err == MFX_ERR_NONE)
155 err = MFXQueryVersion(hwctx->
session, &s->
ver);
156 if (err != MFX_ERR_NONE) {
226 if (!device_priv->
handle) {
228 "Cannot create a non-opaque internal surface pool without " 229 "a hardware handle\n");
234 if (!child_device_ref)
241 child_device_hwctx->
display = (VADisplay)device_priv->
handle;
247 child_device_hwctx->
devmgr = (IDirect3DDeviceManager9*)device_priv->
handle;
258 if (!child_frames_ref) {
273 if (hwctx->
frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET)
274 child_frames_hwctx->
surface_type = DXVA2_VideoProcessorRenderTarget;
276 child_frames_hwctx->
surface_type = DXVA2_VideoDecoderRenderTarget;
291 hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
299 if (child_frames_hwctx->
surface_type == DXVA2_VideoProcessorRenderTarget)
300 hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
302 hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
307 child_frames_ref =
NULL;
328 surf->Info.BitDepthLuma = desc->
comp[0].
depth;
329 surf->Info.BitDepthChroma = desc->
comp[0].
depth;
330 surf->Info.Shift = desc->
comp[0].
depth > 8;
333 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
335 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV422;
337 surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV444;
339 surf->Info.FourCC =
fourcc;
341 surf->Info.CropW = ctx->
width;
343 surf->Info.CropH = ctx->
height;
344 surf->Info.FrameRateExtN = 25;
345 surf->Info.FrameRateExtD = 1;
346 surf->Info.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
374 if (!(frames_hwctx->
frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) {
391 static mfxStatus
frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
392 mfxFrameAllocResponse *resp)
397 mfxFrameInfo *
i = &req->Info;
398 mfxFrameInfo *i1 = &hwctx->
surfaces[0].Info;
400 if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
401 !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
402 !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
403 return MFX_ERR_UNSUPPORTED;
404 if (i->Width > i1->Width || i->Height > i1->Height ||
405 i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) {
407 "allocation request: %dx%d %d %d vs %dx%d %d %d\n",
408 i->Width, i->Height, i->FourCC, i->ChromaFormat,
409 i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat);
410 return MFX_ERR_UNSUPPORTED;
419 static mfxStatus
frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
424 static mfxStatus
frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
426 return MFX_ERR_UNSUPPORTED;
429 static mfxStatus
frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
431 return MFX_ERR_UNSUPPORTED;
441 mfxSession *session,
int upload)
446 int opaque = !!(frames_hwctx->
frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
448 mfxFrameAllocator frame_allocator = {
460 err = MFXInit(device_priv->
impl, &device_priv->
ver, session);
461 if (err != MFX_ERR_NONE) {
466 if (device_priv->
handle) {
467 err = MFXVideoCORE_SetHandle(*session, device_priv->
handle_type,
469 if (err != MFX_ERR_NONE)
474 err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator);
475 if (err != MFX_ERR_NONE)
479 memset(&par, 0,
sizeof(par));
484 par.IOPattern = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY :
485 MFX_IOPATTERN_IN_OPAQUE_MEMORY;
487 par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY :
488 MFX_IOPATTERN_IN_VIDEO_MEMORY;
491 par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY :
492 MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
495 par.vpp.In = frames_hwctx->
surfaces[0].Info;
501 par.vpp.In.FrameRateExtN = 25;
502 par.vpp.In.FrameRateExtD = 1;
503 par.vpp.Out = par.vpp.In;
505 err = MFXVideoVPP_Init(*session, &par);
506 if (err != MFX_ERR_NONE) {
508 "Surface upload/download will not be possible\n");
521 int opaque = !!(frames_hwctx->
frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
555 s->
opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
631 *(VASurfaceID*)src_hwctx->
surfaces[
i].Data.MemId;
646 (IDirect3DSurface9*)src_hwctx->
surfaces[
i].Data.MemId;
648 if (src_hwctx->
frame_type == MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
649 dst_hwctx->
surface_type = DXVA2_VideoDecoderRenderTarget;
651 dst_hwctx->
surface_type = DXVA2_VideoProcessorRenderTarget;
666 mfxFrameSurface1 *surf = (mfxFrameSurface1*)src->
data[3];
677 switch (child_frames_ctx->device_ctx->type) {
680 child_data = (
uint8_t*)(intptr_t)*(VASurfaceID*)surf->Data.MemId;
685 child_data = surf->Data.MemId;
692 if (dst->
format == child_frames_ctx->format) {
700 dst->
data[3] = child_data;
720 dummy->format = child_frames_ctx->format;
723 dummy->data[3] = child_data;
739 mfxFrameSurface1 *surf = (mfxFrameSurface1*)(download ? src->
data[3] : dst->
data[3]);
751 dummy->
buf[0] = download ? src->
buf[0] : dst->
buf[0];
752 dummy->
data[3] = surf->Data.MemId;
772 surface->Data.Y = frame->
data[0];
773 surface->Data.UV = frame->
data[1];
777 surface->Data.Y = frame->
data[0];
778 surface->Data.U = frame->
data[1];
779 surface->Data.V = frame->
data[2];
783 surface->Data.B = frame->
data[0];
784 surface->Data.G = frame->
data[0] + 1;
785 surface->Data.R = frame->
data[0] + 2;
786 surface->Data.A = frame->
data[0] + 3;
790 surface->Data.Y = frame->
data[0];
791 surface->Data.U = frame->
data[0] + 1;
792 surface->Data.V = frame->
data[0] + 3;
796 surface->Data.Y16 = (mfxU16 *)frame->
data[0];
797 surface->Data.U16 = (mfxU16 *)frame->
data[0] + 1;
798 surface->Data.V16 = (mfxU16 *)frame->
data[0] + 3;
802 return MFX_ERR_UNSUPPORTED;
804 surface->Data.Pitch = frame->
linesize[0];
805 surface->Data.TimeStamp = frame->
pts;
814 mfxFrameSurface1
out = {{ 0 }};
815 mfxFrameSurface1 *
in = (mfxFrameSurface1*)src->
data[3];
817 mfxSyncPoint sync =
NULL;
823 if (pthread_mutex_trylock(&s->session_lock) == 0) {
859 if (err == MFX_WRN_DEVICE_BUSY)
861 }
while (err == MFX_WRN_DEVICE_BUSY);
863 if (err < 0 || !sync) {
870 }
while (err == MFX_WRN_IN_EXECUTION);
883 mfxFrameSurface1
in = {{ 0 }};
884 mfxFrameSurface1 *
out = (mfxFrameSurface1*)dst->
data[3];
886 mfxSyncPoint sync =
NULL;
897 if (pthread_mutex_trylock(&s->session_lock) == 0) {
921 memset(&tmp_frame, 0,
sizeof(tmp_frame));
922 tmp_frame.format = src->
format;
936 src_frame = realigned ? &tmp_frame :
src;
951 if (err == MFX_WRN_DEVICE_BUSY)
953 }
while (err == MFX_WRN_DEVICE_BUSY);
955 if (err < 0 || !sync) {
962 }
while (err == MFX_WRN_IN_EXECUTION);
995 dst_hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
1012 if (src_hwctx->
surface_type == DXVA2_VideoProcessorRenderTarget)
1013 dst_hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
1015 dst_hwctx->
frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
1036 if (*(VASurfaceID*)hwctx->
surfaces[i].Data.MemId ==
1037 (VASurfaceID)(uintptr_t)src->
data[3])
1041 if ((IDirect3DSurface9*)hwctx->
surfaces[i].Data.MemId ==
1042 (IDirect3DSurface9*)(uintptr_t)src->
data[3])
1048 "is not in the mapped frames context.\n");
1065 const void *hwconfig,
1103 static const struct {
1107 {
"auto", MFX_IMPL_AUTO },
1108 {
"sw", MFX_IMPL_SOFTWARE },
1109 {
"hw", MFX_IMPL_HARDWARE },
1110 {
"auto_any", MFX_IMPL_AUTO_ANY },
1111 {
"hw_any", MFX_IMPL_HARDWARE_ANY },
1112 {
"hw2", MFX_IMPL_HARDWARE2 },
1113 {
"hw3", MFX_IMPL_HARDWARE3 },
1114 {
"hw4", MFX_IMPL_HARDWARE4 },
1117 mfxIMPL impl = MFX_IMPL_AUTO_ANY;
1122 if (!strcmp(device, impl_map[i].
name)) {
1123 impl = impl_map[
i].impl;
1127 impl = strtol(device,
NULL, 0);
1134 mfxIMPL implementation,
1140 mfxVersion ver = { { 3, 1 } };
1146 switch (child_device_ctx->
type) {
1151 handle_type = MFX_HANDLE_VA_DISPLAY;
1152 handle = (mfxHDL)child_device_hwctx->
display;
1160 handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
1161 handle = (mfxHDL)child_device_hwctx->
devmgr;
1170 err = MFXInit(implementation, &ver, &hwctx->
session);
1171 if (err != MFX_ERR_NONE) {
1178 err = MFXQueryVersion(hwctx->
session, &ver);
1179 if (err != MFX_ERR_NONE) {
1186 "Initialize MFX session: API version is %d.%d, implementation version is %d.%d\n",
1187 MFX_VERSION_MAJOR, MFX_VERSION_MINOR, ver.Major, ver.Minor);
1191 err = MFXInit(implementation, &ver, &hwctx->
session);
1192 if (err != MFX_ERR_NONE) {
1194 "Error initializing an MFX session: %d.\n", err);
1199 err = MFXVideoCORE_SetHandle(hwctx->
session, handle_type, handle);
1200 if (err != MFX_ERR_NONE) {
1220 child_device_ctx, flags);
1244 child_device_opts =
NULL;
1252 av_dict_set(&child_device_opts,
"kernel_driver",
"i915", 0);
1253 av_dict_set(&child_device_opts,
"driver",
"iHD", 0);
1262 e ? e->
value :
NULL, child_device_opts, 0);
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
static int qsv_init_child_ctx(AVHWFramesContext *ctx)
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
VAAPI-specific data associated with a frame pool.
This structure describes decoded (raw) audio or video data.
#define pthread_mutex_lock(a)
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
static int qsv_frames_get_constraints(AVHWDeviceContext *ctx, const void *hwconfig, AVHWFramesConstraints *constraints)
mfxFrameSurface1 * surfaces_internal
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
mfxExtBuffer * ext_buffers[1]
This struct is allocated as AVHWFramesContext.hwctx.
Memory handling functions.
mfxHandleType handle_type
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
This struct is allocated as AVHWFramesContext.hwctx.
An API-specific header for AV_HWDEVICE_TYPE_DXVA2.
int width
The allocated dimensions of the frames in this pool.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
mfxHandleType handle_type
int av_usleep(unsigned usec)
Sleep for a period of time.
static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, mfxFrameAllocResponse *resp)
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
API-specific header for AV_HWDEVICE_TYPE_VAAPI.
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
static int qsv_transfer_data_child(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
AVBufferPool * pool_internal
static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
8 bits with AV_PIX_FMT_RGB32 palette
DWORD surface_type
The surface type (e.g.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
enum AVHWDeviceType child_device_type
static int qsv_map_from(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
#define AV_LOG_VERBOSE
Detailed information.
static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
static int qsv_frames_init(AVHWFramesContext *ctx)
int session_download_init
static int qsv_init_surface(AVHWFramesContext *ctx, mfxFrameSurface1 *surf)
This struct is allocated as AVHWDeviceContext.hwctx.
static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static const struct @297 supported_handle_types[]
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
enum AVHWDeviceType device_type
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
IDirect3DDeviceManager9 * devmgr
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
static int qsv_frames_derive_to(AVHWFramesContext *dst_ctx, AVHWFramesContext *src_ctx, int flags)
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
static int qsv_transfer_get_formats(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
int initial_pool_size
Initial size of the frame pool.
static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
mfxFrameSurface1 ** surface_ptrs
#define pthread_mutex_unlock(a)
mfxSession session_download
AVBufferPool * av_buffer_pool_init2(int size, void *opaque, AVBufferRef *(*alloc)(void *opaque, int size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
#define FF_ARRAY_ELEMS(a)
VADisplay display
The VADisplay handle, to be filled by the user.
static void qsv_frames_uninit(AVHWFramesContext *ctx)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given hardware type.
static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
const HWContextType ff_hwcontext_type_qsv
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
mfxFrameSurface1 * surfaces
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
uint8_t * data
The data buffer.
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
static int map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
int av_hwdevice_ctx_init(AVBufferRef *ref)
Finalize the device context before use.
int ff_hwframe_map_create(AVBufferRef *hwframe_ref, AVFrame *dst, const AVFrame *src, void(*unmap)(AVHWFramesContext *ctx, HWMapDescriptor *hwmap), void *priv)
static int qsv_device_create(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
static int qsv_init_internal_session(AVHWFramesContext *ctx, mfxSession *session, int upload)
This struct describes a set or pool of "hardware" frames (i.e.
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
static mfxIMPL choose_implementation(const char *device)
refcounted data buffer API
enum AVPixelFormat * valid_hw_formats
A list of possible values for format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
mfxExtOpaqueSurfaceAlloc opaque_alloc
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
AVHWFramesInternal * internal
Private data used internally by libavutil.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define flags(name, subs,...)
static AVBufferRef * qsv_pool_alloc(void *opaque, int size)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void * user_opaque
Arbitrary user data, to be used e.g.
static int qsv_device_derive_from_child(AVHWDeviceContext *ctx, mfxIMPL implementation, AVHWDeviceContext *child_device_ctx, int flags)
A reference to a data buffer.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static void qsv_device_free(AVHWDeviceContext *ctx)
common internal and external API header
int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
Map a hardware frame.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
static int qsv_device_init(AVHWDeviceContext *ctx)
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
enum AVPixelFormat child_pix_fmt
IDirect3DSurface9 ** surfaces
The surface pool.
AVHWFrameTransferDirection
AVBufferPool * pool
A pool from which the frames are allocated by av_hwframe_get_buffer().
This struct is allocated as AVHWDeviceContext.hwctx.
static uint32_t qsv_fourcc_from_pix_fmt(enum AVPixelFormat pix_fmt)
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
VAAPI connection details.
static int qsv_device_derive(AVHWDeviceContext *ctx, AVHWDeviceContext *child_device_ctx, AVDictionary *opts, int flags)
static int qsv_frames_derive_from(AVHWFramesContext *dst_ctx, AVHWFramesContext *src_ctx, int flags)
void(* free)(struct AVHWDeviceContext *ctx)
This field may be set by the caller before calling av_hwdevice_ctx_init().
VASurfaceID * surface_ids
The surfaces IDs of all surfaces in the pool after creation.
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVBufferRef * child_device_ctx
AVBufferRef * child_frames_ref
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
#define av_malloc_array(a, b)
AVHWDeviceInternal * internal
Private data used internally by libavutil.
int depth
Number of bits in the component.
static void qsv_pool_release_dummy(void *opaque, uint8_t *data)
static int qsv_map_to(AVHWFramesContext *dst_ctx, AVFrame *dst, const AVFrame *src, int flags)
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
enum AVPixelFormat pix_fmt
mfxSession session_upload
static const struct @298 supported_pixel_formats[]
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().