mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-11 02:46:33 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/d3d11/gstd3d11av1dec.cpp
Seungha Yang 349f8de13e d3d11decoder: Handle input caps change 
Update output caps if it's notified by baseclass

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3328>
2022-11-16 13:12:38 +00:00

1371 lines
42 KiB
C++
Raw Blame History

/* GStreamer
* Copyright (C) 2021 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-d3d11av1dec
* @title: d3d11av1dec
*
* A Direct3D11/DXVA based AV1 video decoder
*
* ## Example launch line
* ```
* gst-launch-1.0 filesrc location=/path/to/av1/file ! parsebin ! d3d11av1dec ! d3d11videosink
* ```
*
* Since: 1.20
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gstd3d11av1dec.h"
#include <gst/codecs/gstav1decoder.h>
#include <string.h>
#include <vector>
/* HACK: to expose dxva data structure on UWP */
#ifdef WINAPI_PARTITION_DESKTOP
#undef WINAPI_PARTITION_DESKTOP
#endif
#define WINAPI_PARTITION_DESKTOP 1
#include <d3d9.h>
#include <dxva.h>
GST_DEBUG_CATEGORY_EXTERN (gst_d3d11_av1_dec_debug);
#define GST_CAT_DEFAULT gst_d3d11_av1_dec_debug
/* Might not be defined in dxva.h, copied from DXVA AV1 spec available at
* https://www.microsoft.com/en-us/download/confirmation.aspx?id=101577
* and modified with "GST_" prefix
*/
#pragma pack(push, 1)
/* AV1 picture entry data structure */
typedef struct _GST_DXVA_PicEntry_AV1
{
UINT width;
UINT height;
// Global motion parameters
INT wmmat[6];
union
{
struct
{
UCHAR wminvalid:1;
UCHAR wmtype:2;
UCHAR Reserved:5;
};
UCHAR GlobalMotionFlags;
} DUMMYUNIONNAME;
UCHAR Index;
UINT16 Reserved16Bits;
} GST_DXVA_PicEntry_AV1;
/* AV1 picture parameters structure */
typedef struct _GST_DXVA_PicParams_AV1
{
UINT width;
UINT height;
UINT max_width;
UINT max_height;
UCHAR CurrPicTextureIndex;
UCHAR superres_denom;
UCHAR bitdepth;
UCHAR seq_profile;
// Tiles:
struct
{
UCHAR cols;
UCHAR rows;
USHORT context_update_id;
USHORT widths[64];
USHORT heights[64];
} tiles;
// Coding Tools
union
{
struct
{
UINT use_128x128_superblock:1;
UINT intra_edge_filter:1;
UINT interintra_compound:1;
UINT masked_compound:1;
UINT warped_motion:1;
UINT dual_filter:1;
UINT jnt_comp:1;
UINT screen_content_tools:1;
UINT integer_mv:1;
UINT cdef:1;
UINT restoration:1;
UINT film_grain:1;
UINT intrabc:1;
UINT high_precision_mv:1;
UINT switchable_motion_mode:1;
UINT filter_intra:1;
UINT disable_frame_end_update_cdf:1;
UINT disable_cdf_update:1;
UINT reference_mode:1;
UINT skip_mode:1;
UINT reduced_tx_set:1;
UINT superres:1;
UINT tx_mode:2;
UINT use_ref_frame_mvs:1;
UINT enable_ref_frame_mvs:1;
UINT reference_frame_update:1;
UINT Reserved:5;
};
UINT32 CodingParamToolFlags;
} coding;
// Format & Picture Info flags
union
{
struct
{
UCHAR frame_type:2;
UCHAR show_frame:1;
UCHAR showable_frame:1;
UCHAR subsampling_x:1;
UCHAR subsampling_y:1;
UCHAR mono_chrome:1;
UCHAR Reserved:1;
};
UCHAR FormatAndPictureInfoFlags;
} format;
// References
UCHAR primary_ref_frame;
UCHAR order_hint;
UCHAR order_hint_bits;
GST_DXVA_PicEntry_AV1 frame_refs[7];
UCHAR RefFrameMapTextureIndex[8];
// Loop filter parameters
struct
{
UCHAR filter_level[2];
UCHAR filter_level_u;
UCHAR filter_level_v;
UCHAR sharpness_level;
union
{
struct
{
UCHAR mode_ref_delta_enabled:1;
UCHAR mode_ref_delta_update:1;
UCHAR delta_lf_multi:1;
UCHAR delta_lf_present:1;
UCHAR Reserved:4;
};
UCHAR ControlFlags;
} DUMMYUNIONNAME;
CHAR ref_deltas[8];
CHAR mode_deltas[2];
UCHAR delta_lf_res;
UCHAR frame_restoration_type[3];
USHORT log2_restoration_unit_size[3];
UINT16 Reserved16Bits;
} loop_filter;
// Quantization
struct
{
union
{
struct
{
UCHAR delta_q_present:1;
UCHAR delta_q_res:2;
UCHAR Reserved:5;
};
UCHAR ControlFlags;
} DUMMYUNIONNAME;
UCHAR base_qindex;
CHAR y_dc_delta_q;
CHAR u_dc_delta_q;
CHAR v_dc_delta_q;
CHAR u_ac_delta_q;
CHAR v_ac_delta_q;
// using_qmatrix:
UCHAR qm_y;
UCHAR qm_u;
UCHAR qm_v;
UINT16 Reserved16Bits;
} quantization;
// Cdef parameters
struct
{
union
{
struct
{
UCHAR damping:2;
UCHAR bits:2;
UCHAR Reserved:4;
};
UCHAR ControlFlags;
} DUMMYUNIONNAME;
union
{
struct
{
UCHAR primary:6;
UCHAR secondary:2;
};
UCHAR combined;
} y_strengths[8];
union
{
struct
{
UCHAR primary:6;
UCHAR secondary:2;
};
UCHAR combined;
} uv_strengths[8];
} cdef;
UCHAR interp_filter;
// Segmentation
struct
{
union
{
struct
{
UCHAR enabled:1;
UCHAR update_map:1;
UCHAR update_data:1;
UCHAR temporal_update:1;
UCHAR Reserved:4;
};
UCHAR ControlFlags;
} DUMMYUNIONNAME;
UCHAR Reserved24Bits[3];
union
{
struct
{
UCHAR alt_q:1;
UCHAR alt_lf_y_v:1;
UCHAR alt_lf_y_h:1;
UCHAR alt_lf_u:1;
UCHAR alt_lf_v:1;
UCHAR ref_frame:1;
UCHAR skip:1;
UCHAR globalmv:1;
};
UCHAR mask;
} feature_mask[8];
SHORT feature_data[8][8];
} segmentation;
struct
{
union
{
struct
{
USHORT apply_grain:1;
USHORT scaling_shift_minus8:2;
USHORT chroma_scaling_from_luma:1;
USHORT ar_coeff_lag:2;
USHORT ar_coeff_shift_minus6:2;
USHORT grain_scale_shift:2;
USHORT overlap_flag:1;
USHORT clip_to_restricted_range:1;
USHORT matrix_coeff_is_identity:1;
USHORT Reserved:3;
};
USHORT ControlFlags;
} DUMMYUNIONNAME;
USHORT grain_seed;
UCHAR scaling_points_y[14][2];
UCHAR num_y_points;
UCHAR scaling_points_cb[10][2];
UCHAR num_cb_points;
UCHAR scaling_points_cr[10][2];
UCHAR num_cr_points;
UCHAR ar_coeffs_y[24];
UCHAR ar_coeffs_cb[25];
UCHAR ar_coeffs_cr[25];
UCHAR cb_mult;
UCHAR cb_luma_mult;
UCHAR cr_mult;
UCHAR cr_luma_mult;
UCHAR Reserved8Bits;
SHORT cb_offset;
SHORT cr_offset;
} film_grain;
UINT Reserved32Bits;
UINT StatusReportFeedbackNumber;
} GST_DXVA_PicParams_AV1;
/* AV1 tile structure */
typedef struct _GST_DXVA_Tile_AV1
{
UINT DataOffset;
UINT DataSize;
USHORT row;
USHORT column;
UINT16 Reserved16Bits;
UCHAR anchor_frame;
UCHAR Reserved8Bits;
} GST_DXVA_Tile_AV1;
/* AV1 status reporting data structure */
typedef struct _GST_DXVA_Status_AV1
{
UINT StatusReportFeedbackNumber;
GST_DXVA_PicEntry_AV1 CurrPic;
UCHAR BufType;
UCHAR Status;
UCHAR Reserved8Bits;
USHORT NumMbsAffected;
} GST_DXVA_Status_AV1;
#pragma pack(pop)
/* *INDENT-OFF* */
typedef struct _GstD3D11AV1DecInner
{
GstD3D11Device *device = nullptr;
GstD3D11Decoder *d3d11_decoder = nullptr;
GstAV1SequenceHeaderOBU seq_hdr;
GST_DXVA_PicParams_AV1 pic_params;
std::vector<GST_DXVA_Tile_AV1> tile_list;
std::vector<guint8> bitstream_buffer;
guint max_width = 0;
guint max_height = 0;
guint bitdepth = 0;
} GstD3D11AV1DecInner;
/* *INDENT-ON* */
typedef struct _GstD3D11AV1Dec
{
GstAV1Decoder parent;
GstD3D11AV1DecInner *inner;
} GstD3D11AV1Dec;
typedef struct _GstD3D11AV1DecClass
{
GstAV1DecoderClass parent_class;
GstD3D11DecoderSubClassData class_data;
} GstD3D11AV1DecClass;
static GstElementClass *parent_class = NULL;
#define GST_D3D11_AV1_DEC(object) ((GstD3D11AV1Dec *) (object))
#define GST_D3D11_AV1_DEC_GET_CLASS(object) \
(G_TYPE_INSTANCE_GET_CLASS ((object),G_TYPE_FROM_INSTANCE (object),GstD3D11AV1DecClass))
static void gst_d3d11_av1_dec_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec);
static void gst_d3d11_av1_dec_finalize (GObject * object);
static void gst_d3d11_av1_dec_set_context (GstElement * element,
GstContext * context);
static gboolean gst_d3d11_av1_dec_open (GstVideoDecoder * decoder);
static gboolean gst_d3d11_av1_dec_close (GstVideoDecoder * decoder);
static gboolean gst_d3d11_av1_dec_negotiate (GstVideoDecoder * decoder);
static gboolean gst_d3d11_av1_dec_decide_allocation (GstVideoDecoder *
decoder, GstQuery * query);
static gboolean gst_d3d11_av1_dec_src_query (GstVideoDecoder * decoder,
GstQuery * query);
static gboolean gst_d3d11_av1_dec_sink_event (GstVideoDecoder * decoder,
GstEvent * event);
/* GstAV1Decoder */
static GstFlowReturn gst_d3d11_av1_dec_new_sequence (GstAV1Decoder * decoder,
const GstAV1SequenceHeaderOBU * seq_hdr, gint max_dpb_size);
static GstFlowReturn gst_d3d11_av1_dec_new_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture);
static GstAV1Picture *gst_d3d11_av1_dec_duplicate_picture (GstAV1Decoder *
decoder, GstVideoCodecFrame * frame, GstAV1Picture * picture);
static GstFlowReturn gst_d3d11_av1_dec_start_picture (GstAV1Decoder * decoder,
GstAV1Picture * picture, GstAV1Dpb * dpb);
static GstFlowReturn gst_d3d11_av1_dec_decode_tile (GstAV1Decoder * decoder,
GstAV1Picture * picture, GstAV1Tile * tile);
static GstFlowReturn gst_d3d11_av1_dec_end_picture (GstAV1Decoder * decoder,
GstAV1Picture * picture);
static GstFlowReturn gst_d3d11_av1_dec_output_picture (GstAV1Decoder *
decoder, GstVideoCodecFrame * frame, GstAV1Picture * picture);
static void
gst_d3d11_av1_dec_class_init (GstD3D11AV1DecClass * klass, gpointer data)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (klass);
GstAV1DecoderClass *av1decoder_class = GST_AV1_DECODER_CLASS (klass);
GstD3D11DecoderClassData *cdata = (GstD3D11DecoderClassData *) data;
gobject_class->get_property = gst_d3d11_av1_dec_get_property;
gobject_class->finalize = gst_d3d11_av1_dec_finalize;
element_class->set_context =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_set_context);
parent_class = (GstElementClass *) g_type_class_peek_parent (klass);
gst_d3d11_decoder_class_data_fill_subclass_data (cdata, &klass->class_data);
/**
* GstD3D11AV1Dec:adapter-luid:
*
* DXGI Adapter LUID for this element
*
* Since: 1.20
*/
gst_d3d11_decoder_proxy_class_init (element_class, cdata,
"Seungha Yang <seungha@centricular.com>");
decoder_class->open = GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_open);
decoder_class->close = GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_close);
decoder_class->negotiate = GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_negotiate);
decoder_class->decide_allocation =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_decide_allocation);
decoder_class->src_query = GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_src_query);
decoder_class->sink_event = GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_sink_event);
av1decoder_class->new_sequence =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_new_sequence);
av1decoder_class->new_picture =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_new_picture);
av1decoder_class->duplicate_picture =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_duplicate_picture);
av1decoder_class->start_picture =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_start_picture);
av1decoder_class->decode_tile =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_decode_tile);
av1decoder_class->end_picture =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_end_picture);
av1decoder_class->output_picture =
GST_DEBUG_FUNCPTR (gst_d3d11_av1_dec_output_picture);
}
static void
gst_d3d11_av1_dec_init (GstD3D11AV1Dec * self)
{
self->inner = new GstD3D11AV1DecInner ();
}
static void
gst_d3d11_av1_dec_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstD3D11AV1DecClass *klass = GST_D3D11_AV1_DEC_GET_CLASS (object);
GstD3D11DecoderSubClassData *cdata = &klass->class_data;
gst_d3d11_decoder_proxy_get_property (object, prop_id, value, pspec, cdata);
}
static void
gst_d3d11_av1_dec_finalize (GObject * object)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (object);
delete self->inner;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_d3d11_av1_dec_set_context (GstElement * element, GstContext * context)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (element);
GstD3D11AV1DecInner *inner = self->inner;
GstD3D11AV1DecClass *klass = GST_D3D11_AV1_DEC_GET_CLASS (self);
GstD3D11DecoderSubClassData *cdata = &klass->class_data;
gst_d3d11_handle_set_context_for_adapter_luid (element,
context, cdata->adapter_luid, &inner->device);
GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
}
static gboolean
gst_d3d11_av1_dec_open (GstVideoDecoder * decoder)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
GstD3D11AV1DecClass *klass = GST_D3D11_AV1_DEC_GET_CLASS (self);
GstD3D11DecoderSubClassData *cdata = &klass->class_data;
if (!gst_d3d11_decoder_proxy_open (decoder,
cdata, &inner->device, &inner->d3d11_decoder)) {
GST_ERROR_OBJECT (self, "Failed to open decoder");
return FALSE;
}
return TRUE;
}
static gboolean
gst_d3d11_av1_dec_close (GstVideoDecoder * decoder)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
gst_clear_object (&inner->d3d11_decoder);
gst_clear_object (&inner->device);
return TRUE;
}
static gboolean
gst_d3d11_av1_dec_negotiate (GstVideoDecoder * decoder)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
if (!gst_d3d11_decoder_negotiate (inner->d3d11_decoder, decoder))
return FALSE;
return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder);
}
static gboolean
gst_d3d11_av1_dec_decide_allocation (GstVideoDecoder * decoder,
GstQuery * query)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
if (!gst_d3d11_decoder_decide_allocation (inner->d3d11_decoder,
decoder, query)) {
return FALSE;
}
return GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation
(decoder, query);
}
static gboolean
gst_d3d11_av1_dec_src_query (GstVideoDecoder * decoder, GstQuery * query)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT:
if (gst_d3d11_handle_context_query (GST_ELEMENT (decoder),
query, inner->device)) {
return TRUE;
}
break;
default:
break;
}
return GST_VIDEO_DECODER_CLASS (parent_class)->src_query (decoder, query);
}
static gboolean
gst_d3d11_av1_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH_START:
if (inner->d3d11_decoder)
gst_d3d11_decoder_set_flushing (inner->d3d11_decoder, decoder, TRUE);
break;
case GST_EVENT_FLUSH_STOP:
if (inner->d3d11_decoder)
gst_d3d11_decoder_set_flushing (inner->d3d11_decoder, decoder, FALSE);
break;
default:
break;
}
return GST_VIDEO_DECODER_CLASS (parent_class)->sink_event (decoder, event);
}
static GstFlowReturn
gst_d3d11_av1_dec_new_sequence (GstAV1Decoder * decoder,
const GstAV1SequenceHeaderOBU * seq_hdr, gint max_dpb_size)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
gboolean modified = FALSE;
guint max_width, max_height;
GST_LOG_OBJECT (self, "new sequence");
if (seq_hdr->seq_profile != GST_AV1_PROFILE_0) {
GST_WARNING_OBJECT (self, "Unsupported profile %d", seq_hdr->seq_profile);
return GST_FLOW_NOT_NEGOTIATED;
}
if (seq_hdr->num_planes != 3) {
GST_WARNING_OBJECT (self, "Monochrome is not supported");
return GST_FLOW_NOT_NEGOTIATED;
}
inner->seq_hdr = *seq_hdr;
if (inner->bitdepth != seq_hdr->bit_depth) {
GST_INFO_OBJECT (self, "Bitdepth changed %d -> %d", inner->bitdepth,
seq_hdr->bit_depth);
inner->bitdepth = seq_hdr->bit_depth;
modified = TRUE;
}
max_width = seq_hdr->max_frame_width_minus_1 + 1;
max_height = seq_hdr->max_frame_height_minus_1 + 1;
if (inner->max_width != max_width || inner->max_height != max_height) {
GST_INFO_OBJECT (self, "Resolution changed %dx%d -> %dx%d",
inner->max_width, inner->max_height, max_width, max_height);
inner->max_width = max_width;
inner->max_height = max_height;
modified = TRUE;
}
if (modified || !gst_d3d11_decoder_is_configured (inner->d3d11_decoder)) {
GstVideoInfo info;
GstVideoFormat out_format = GST_VIDEO_FORMAT_UNKNOWN;
if (inner->bitdepth == 8) {
out_format = GST_VIDEO_FORMAT_NV12;
} else if (inner->bitdepth == 10) {
out_format = GST_VIDEO_FORMAT_P010_10LE;
} else {
GST_WARNING_OBJECT (self, "Invalid bit-depth %d", seq_hdr->bit_depth);
return GST_FLOW_NOT_NEGOTIATED;
}
gst_video_info_set_format (&info,
out_format, inner->max_width, inner->max_height);
if (!gst_d3d11_decoder_configure (inner->d3d11_decoder,
decoder->input_state, &info, 0, 0, (gint) inner->max_width,
(gint) inner->max_height, max_dpb_size)) {
GST_ERROR_OBJECT (self, "Failed to create decoder");
return GST_FLOW_NOT_NEGOTIATED;
}
if (!gst_video_decoder_negotiate (GST_VIDEO_DECODER (self))) {
GST_WARNING_OBJECT (self, "Failed to negotiate with downstream");
return GST_FLOW_NOT_NEGOTIATED;
}
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d11_av1_dec_new_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
GstBuffer *view_buffer;
view_buffer = gst_d3d11_decoder_get_output_view_buffer (inner->d3d11_decoder,
GST_VIDEO_DECODER (decoder));
if (!view_buffer) {
GST_DEBUG_OBJECT (self, "No available output view buffer");
return GST_FLOW_FLUSHING;
}
GST_LOG_OBJECT (self, "New output view buffer %" GST_PTR_FORMAT, view_buffer);
gst_av1_picture_set_user_data (picture,
view_buffer, (GDestroyNotify) gst_buffer_unref);
GST_LOG_OBJECT (self, "New AV1 picture %p", picture);
return GST_FLOW_OK;
}
static GstAV1Picture *
gst_d3d11_av1_dec_duplicate_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstBuffer *view_buffer;
GstAV1Picture *new_picture;
view_buffer = (GstBuffer *) gst_av1_picture_get_user_data (picture);
if (!view_buffer) {
GST_ERROR_OBJECT (self, "Parent picture does not have output view buffer");
return NULL;
}
new_picture = gst_av1_picture_new ();
GST_LOG_OBJECT (self, "Duplicate output with buffer %" GST_PTR_FORMAT,
view_buffer);
gst_av1_picture_set_user_data (new_picture,
gst_buffer_ref (view_buffer), (GDestroyNotify) gst_buffer_unref);
return new_picture;
}
static ID3D11VideoDecoderOutputView *
gst_d3d11_av1_dec_get_output_view_from_picture (GstD3D11AV1Dec * self,
GstAV1Picture * picture, guint8 * view_id)
{
GstD3D11AV1DecInner *inner = self->inner;
GstBuffer *view_buffer;
ID3D11VideoDecoderOutputView *view;
view_buffer = (GstBuffer *) gst_av1_picture_get_user_data (picture);
if (!view_buffer) {
GST_DEBUG_OBJECT (self, "current picture does not have output view buffer");
return NULL;
}
view =
gst_d3d11_decoder_get_output_view_from_buffer (inner->d3d11_decoder,
view_buffer, view_id);
if (!view) {
GST_DEBUG_OBJECT (self, "current picture does not have output view handle");
return NULL;
}
return view;
}
static GstFlowReturn
gst_d3d11_av1_dec_start_picture (GstAV1Decoder * decoder,
GstAV1Picture * picture, GstAV1Dpb * dpb)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
const GstAV1SequenceHeaderOBU *seq_hdr = &inner->seq_hdr;
const GstAV1FrameHeaderOBU *frame_hdr = &picture->frame_hdr;
ID3D11VideoDecoderOutputView *view;
GST_DXVA_PicParams_AV1 *pic_params = &inner->pic_params;
guint8 view_id = 0xff;
guint i, j;
view = gst_d3d11_av1_dec_get_output_view_from_picture (self, picture,
&view_id);
if (!view) {
GST_ERROR_OBJECT (self, "current picture does not have output view handle");
return GST_FLOW_OK;
}
memset (pic_params, 0, sizeof (GST_DXVA_PicParams_AV1));
pic_params->width = frame_hdr->frame_width;
pic_params->height = frame_hdr->frame_height;
pic_params->max_width = seq_hdr->max_frame_width_minus_1 + 1;
pic_params->max_height = seq_hdr->max_frame_height_minus_1 + 1;
pic_params->CurrPicTextureIndex = view_id;
pic_params->superres_denom = frame_hdr->superres_denom;
pic_params->bitdepth = seq_hdr->bit_depth;
pic_params->seq_profile = seq_hdr->seq_profile;
/* TILES */
pic_params->tiles.cols = frame_hdr->tile_info.tile_cols;
pic_params->tiles.rows = frame_hdr->tile_info.tile_rows;
pic_params->tiles.context_update_id =
frame_hdr->tile_info.context_update_tile_id;
for (i = 0; i < pic_params->tiles.cols; i++) {
pic_params->tiles.widths[i] =
frame_hdr->tile_info.width_in_sbs_minus_1[i] + 1;
}
for (i = 0; i < pic_params->tiles.rows; i++) {
pic_params->tiles.heights[i] =
frame_hdr->tile_info.height_in_sbs_minus_1[i] + 1;
}
/* CODING TOOLS */
pic_params->coding.use_128x128_superblock = seq_hdr->use_128x128_superblock;
pic_params->coding.intra_edge_filter = seq_hdr->enable_filter_intra;
pic_params->coding.interintra_compound = seq_hdr->enable_interintra_compound;
pic_params->coding.masked_compound = seq_hdr->enable_masked_compound;
pic_params->coding.warped_motion = frame_hdr->allow_warped_motion;
pic_params->coding.dual_filter = seq_hdr->enable_dual_filter;
pic_params->coding.jnt_comp = seq_hdr->enable_jnt_comp;
pic_params->coding.screen_content_tools =
frame_hdr->allow_screen_content_tools;
pic_params->coding.integer_mv = frame_hdr->force_integer_mv;
pic_params->coding.cdef = seq_hdr->enable_cdef;
pic_params->coding.restoration = seq_hdr->enable_restoration;
pic_params->coding.film_grain = seq_hdr->film_grain_params_present;
pic_params->coding.intrabc = frame_hdr->allow_intrabc;
pic_params->coding.high_precision_mv = frame_hdr->allow_high_precision_mv;
pic_params->coding.switchable_motion_mode =
frame_hdr->is_motion_mode_switchable;
pic_params->coding.filter_intra = seq_hdr->enable_filter_intra;
pic_params->coding.disable_frame_end_update_cdf =
frame_hdr->disable_frame_end_update_cdf;
pic_params->coding.disable_cdf_update = frame_hdr->disable_cdf_update;
pic_params->coding.reference_mode = frame_hdr->reference_select;
pic_params->coding.skip_mode = frame_hdr->skip_mode_present;
pic_params->coding.reduced_tx_set = frame_hdr->reduced_tx_set;
pic_params->coding.superres = frame_hdr->use_superres;
pic_params->coding.tx_mode = frame_hdr->tx_mode;
pic_params->coding.use_ref_frame_mvs = frame_hdr->use_ref_frame_mvs;
pic_params->coding.enable_ref_frame_mvs = seq_hdr->enable_ref_frame_mvs;
pic_params->coding.reference_frame_update = 1;
/* FORMAT */
pic_params->format.frame_type = frame_hdr->frame_type;
pic_params->format.show_frame = frame_hdr->show_frame;
pic_params->format.showable_frame = frame_hdr->showable_frame;
pic_params->format.subsampling_x = seq_hdr->color_config.subsampling_x;
pic_params->format.subsampling_y = seq_hdr->color_config.subsampling_y;
pic_params->format.mono_chrome = seq_hdr->color_config.mono_chrome;
/* REFERENCES */
pic_params->primary_ref_frame = frame_hdr->primary_ref_frame;
pic_params->order_hint = frame_hdr->order_hint;
if (seq_hdr->enable_order_hint) {
pic_params->order_hint_bits = seq_hdr->order_hint_bits_minus_1 + 1;
} else {
pic_params->order_hint_bits = 0;
}
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
if (dpb->pic_list[i]) {
GstAV1Picture *other_pic = dpb->pic_list[i];
const GstAV1GlobalMotionParams *gmp = &frame_hdr->global_motion_params;
pic_params->frame_refs[i].width = other_pic->frame_hdr.frame_width;
pic_params->frame_refs[i].height = other_pic->frame_hdr.frame_height;
for (j = 0; j < 6; j++) {
pic_params->frame_refs[i].wmmat[j] =
gmp->gm_params[GST_AV1_REF_LAST_FRAME + i][j];
}
pic_params->frame_refs[i].wminvalid =
(gmp->gm_type[GST_AV1_REF_LAST_FRAME + i] ==
GST_AV1_WARP_MODEL_IDENTITY);
pic_params->frame_refs[i].wmtype =
gmp->gm_type[GST_AV1_REF_LAST_FRAME + i];
pic_params->frame_refs[i].Index = frame_hdr->ref_frame_idx[i];
} else {
pic_params->frame_refs[i].Index = 0xff;
}
}
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
if (dpb->pic_list[i]) {
GstAV1Picture *other_pic = dpb->pic_list[i];
ID3D11VideoDecoderOutputView *other_view;
guint8 other_view_id = 0xff;
other_view = gst_d3d11_av1_dec_get_output_view_from_picture (self,
other_pic, &other_view_id);
if (!other_view) {
GST_ERROR_OBJECT (self,
"current picture does not have output view handle");
return GST_FLOW_ERROR;
}
pic_params->RefFrameMapTextureIndex[i] = other_view_id;
} else {
pic_params->RefFrameMapTextureIndex[i] = 0xff;
}
}
/* LOOP FILTER PARAMS */
pic_params->loop_filter.filter_level[0] =
frame_hdr->loop_filter_params.loop_filter_level[0];
pic_params->loop_filter.filter_level[1] =
frame_hdr->loop_filter_params.loop_filter_level[1];
pic_params->loop_filter.filter_level_u =
frame_hdr->loop_filter_params.loop_filter_level[2];
pic_params->loop_filter.filter_level_v =
frame_hdr->loop_filter_params.loop_filter_level[3];
pic_params->loop_filter.sharpness_level =
frame_hdr->loop_filter_params.loop_filter_sharpness;
pic_params->loop_filter.mode_ref_delta_enabled =
frame_hdr->loop_filter_params.loop_filter_delta_enabled;
pic_params->loop_filter.mode_ref_delta_update =
frame_hdr->loop_filter_params.loop_filter_delta_update;
pic_params->loop_filter.delta_lf_multi =
frame_hdr->loop_filter_params.delta_lf_multi;
pic_params->loop_filter.delta_lf_present =
frame_hdr->loop_filter_params.delta_lf_present;
for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++) {
pic_params->loop_filter.ref_deltas[i] =
frame_hdr->loop_filter_params.loop_filter_ref_deltas[i];
}
for (i = 0; i < 2; i++) {
pic_params->loop_filter.mode_deltas[i] =
frame_hdr->loop_filter_params.loop_filter_mode_deltas[i];
}
pic_params->loop_filter.delta_lf_res =
frame_hdr->loop_filter_params.delta_lf_res;
for (i = 0; i < GST_AV1_MAX_NUM_PLANES; i++) {
pic_params->loop_filter.frame_restoration_type[i] =
frame_hdr->loop_restoration_params.frame_restoration_type[i];
}
if (frame_hdr->loop_restoration_params.uses_lr) {
pic_params->loop_filter.log2_restoration_unit_size[0] =
(6 + frame_hdr->loop_restoration_params.lr_unit_shift);
pic_params->loop_filter.log2_restoration_unit_size[1] =
pic_params->loop_filter.log2_restoration_unit_size[2] =
(6 + frame_hdr->loop_restoration_params.lr_unit_shift -
frame_hdr->loop_restoration_params.lr_uv_shift);
} else {
pic_params->loop_filter.log2_restoration_unit_size[0] =
pic_params->loop_filter.log2_restoration_unit_size[1] =
pic_params->loop_filter.log2_restoration_unit_size[2] = 8;
}
/* QUANTIZATION */
pic_params->quantization.delta_q_present =
frame_hdr->quantization_params.delta_q_present;
pic_params->quantization.delta_q_res =
frame_hdr->quantization_params.delta_q_res;
pic_params->quantization.base_qindex =
frame_hdr->quantization_params.base_q_idx;
pic_params->quantization.y_dc_delta_q =
frame_hdr->quantization_params.delta_q_y_dc;
pic_params->quantization.u_dc_delta_q =
frame_hdr->quantization_params.delta_q_u_dc;
pic_params->quantization.v_dc_delta_q =
frame_hdr->quantization_params.delta_q_v_dc;
pic_params->quantization.u_ac_delta_q =
frame_hdr->quantization_params.delta_q_u_ac;
pic_params->quantization.v_ac_delta_q =
frame_hdr->quantization_params.delta_q_v_ac;
if (frame_hdr->quantization_params.using_qmatrix) {
pic_params->quantization.qm_y = frame_hdr->quantization_params.qm_y;
pic_params->quantization.qm_u = frame_hdr->quantization_params.qm_u;
pic_params->quantization.qm_v = frame_hdr->quantization_params.qm_v;
} else {
pic_params->quantization.qm_y = 0xff;
pic_params->quantization.qm_u = 0xff;
pic_params->quantization.qm_v = 0xff;
}
/* Cdef params */
pic_params->cdef.damping = frame_hdr->cdef_params.cdef_damping - 3;
pic_params->cdef.bits = frame_hdr->cdef_params.cdef_bits;
for (i = 0; i < GST_AV1_CDEF_MAX; i++) {
guint8 secondary;
pic_params->cdef.y_strengths[i].primary =
frame_hdr->cdef_params.cdef_y_pri_strength[i];
secondary = frame_hdr->cdef_params.cdef_y_sec_strength[i];
if (secondary == 4)
secondary--;
pic_params->cdef.y_strengths[i].secondary = secondary;
pic_params->cdef.uv_strengths[i].primary =
frame_hdr->cdef_params.cdef_uv_pri_strength[i];
secondary = frame_hdr->cdef_params.cdef_uv_sec_strength[i];
if (secondary == 4)
secondary--;
pic_params->cdef.uv_strengths[i].secondary = secondary;
}
pic_params->interp_filter = frame_hdr->interpolation_filter;
/* SEGMENTATION */
pic_params->segmentation.enabled =
frame_hdr->segmentation_params.segmentation_enabled;
pic_params->segmentation.update_map =
frame_hdr->segmentation_params.segmentation_update_map;
pic_params->segmentation.update_data =
frame_hdr->segmentation_params.segmentation_update_data;
pic_params->segmentation.temporal_update =
frame_hdr->segmentation_params.segmentation_temporal_update;
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
pic_params->segmentation.feature_mask[i].mask |=
(frame_hdr->segmentation_params.feature_enabled[i][j] << j);
pic_params->segmentation.feature_data[i][j] =
frame_hdr->segmentation_params.feature_data[i][j];
}
}
/* FILM GRAIN */
if (frame_hdr->film_grain_params.apply_grain) {
pic_params->film_grain.apply_grain = 1;
pic_params->film_grain.scaling_shift_minus8 =
frame_hdr->film_grain_params.grain_scaling_minus_8;
pic_params->film_grain.chroma_scaling_from_luma =
frame_hdr->film_grain_params.chroma_scaling_from_luma;
pic_params->film_grain.ar_coeff_lag =
frame_hdr->film_grain_params.ar_coeff_lag;
pic_params->film_grain.ar_coeff_shift_minus6 =
frame_hdr->film_grain_params.ar_coeff_shift_minus_6;
pic_params->film_grain.grain_scale_shift =
frame_hdr->film_grain_params.grain_scale_shift;
pic_params->film_grain.overlap_flag =
frame_hdr->film_grain_params.overlap_flag;
pic_params->film_grain.clip_to_restricted_range =
frame_hdr->film_grain_params.clip_to_restricted_range;
pic_params->film_grain.matrix_coeff_is_identity =
(seq_hdr->color_config.matrix_coefficients == GST_AV1_MC_IDENTITY);
pic_params->film_grain.grain_seed = frame_hdr->film_grain_params.grain_seed;
for (i = 0; i < frame_hdr->film_grain_params.num_y_points && i < 14; i++) {
pic_params->film_grain.scaling_points_y[i][0] =
frame_hdr->film_grain_params.point_y_value[i];
pic_params->film_grain.scaling_points_y[i][1] =
frame_hdr->film_grain_params.point_y_scaling[i];
}
pic_params->film_grain.num_y_points =
frame_hdr->film_grain_params.num_y_points;
for (i = 0; i < frame_hdr->film_grain_params.num_cb_points && i < 10; i++) {
pic_params->film_grain.scaling_points_cb[i][0] =
frame_hdr->film_grain_params.point_cb_value[i];
pic_params->film_grain.scaling_points_cb[i][1] =
frame_hdr->film_grain_params.point_cb_scaling[i];
}
pic_params->film_grain.num_cb_points =
frame_hdr->film_grain_params.num_cb_points;
for (i = 0; i < frame_hdr->film_grain_params.num_cr_points && i < 10; i++) {
pic_params->film_grain.scaling_points_cr[i][0] =
frame_hdr->film_grain_params.point_cr_value[i];
pic_params->film_grain.scaling_points_cr[i][1] =
frame_hdr->film_grain_params.point_cr_scaling[i];
}
pic_params->film_grain.num_cr_points =
frame_hdr->film_grain_params.num_cr_points;
for (i = 0; i < 24; i++) {
pic_params->film_grain.ar_coeffs_y[i] =
frame_hdr->film_grain_params.ar_coeffs_y_plus_128[i];
}
for (i = 0; i < 25; i++) {
pic_params->film_grain.ar_coeffs_cb[i] =
frame_hdr->film_grain_params.ar_coeffs_cb_plus_128[i];
pic_params->film_grain.ar_coeffs_cr[i] =
frame_hdr->film_grain_params.ar_coeffs_cr_plus_128[i];
}
pic_params->film_grain.cb_mult = frame_hdr->film_grain_params.cb_mult;
pic_params->film_grain.cb_luma_mult =
frame_hdr->film_grain_params.cb_luma_mult;
pic_params->film_grain.cr_mult = frame_hdr->film_grain_params.cr_mult;
pic_params->film_grain.cr_luma_mult =
frame_hdr->film_grain_params.cr_luma_mult;
pic_params->film_grain.cb_offset = frame_hdr->film_grain_params.cb_offset;
pic_params->film_grain.cr_offset = frame_hdr->film_grain_params.cr_offset;
}
inner->bitstream_buffer.resize (0);
inner->tile_list.resize (0);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d11_av1_dec_decode_tile (GstAV1Decoder * decoder,
GstAV1Picture * picture, GstAV1Tile * tile)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
GstAV1TileGroupOBU *tile_group = &tile->tile_group;
if (tile_group->num_tiles > inner->tile_list.size ())
inner->tile_list.resize (tile_group->num_tiles);
g_assert (tile_group->tg_end < inner->tile_list.size ());
GST_LOG_OBJECT (self, "Decode tile, tile count %d (start: %d - end: %d)",
tile_group->num_tiles, tile_group->tg_start, tile_group->tg_end);
for (guint i = tile_group->tg_start; i <= tile_group->tg_end; i++) {
GST_DXVA_Tile_AV1 *dxva_tile = &inner->tile_list[i];
GST_TRACE_OBJECT (self,
"Tile offset %d, size %d, row %d, col %d",
tile_group->entry[i].tile_offset, tile_group->entry[i].tile_size,
tile_group->entry[i].tile_row, tile_group->entry[i].tile_col);
dxva_tile->DataOffset = inner->bitstream_buffer.size () +
tile_group->entry[i].tile_offset;
dxva_tile->DataSize = tile_group->entry[i].tile_size;
dxva_tile->row = tile_group->entry[i].tile_row;
dxva_tile->column = tile_group->entry[i].tile_col;
/* TODO: used for tile list OBU */
dxva_tile->anchor_frame = 0xff;
}
GST_TRACE_OBJECT (self, "OBU size %d", tile->obu.obu_size);
size_t pos = inner->bitstream_buffer.size ();
inner->bitstream_buffer.resize (pos + tile->obu.obu_size);
memcpy (&inner->bitstream_buffer[0] + pos,
tile->obu.data, tile->obu.obu_size);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_d3d11_av1_dec_end_picture (GstAV1Decoder * decoder, GstAV1Picture * picture)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
ID3D11VideoDecoderOutputView *view;
guint8 view_id = 0xff;
size_t bitstream_buffer_size;
size_t bitstream_pos;
GstD3D11DecodeInputStreamArgs input_args;
if (inner->bitstream_buffer.empty () || inner->tile_list.empty ()) {
GST_ERROR_OBJECT (self, "No bitstream buffer to submit");
return GST_FLOW_ERROR;
}
view = gst_d3d11_av1_dec_get_output_view_from_picture (self, picture,
&view_id);
if (!view) {
GST_ERROR_OBJECT (self, "current picture does not have output view handle");
return GST_FLOW_ERROR;
}
memset (&input_args, 0, sizeof (GstD3D11DecodeInputStreamArgs));
bitstream_pos = inner->bitstream_buffer.size ();
bitstream_buffer_size = GST_ROUND_UP_128 (bitstream_pos);
if (bitstream_buffer_size > bitstream_pos) {
size_t padding = bitstream_buffer_size - bitstream_pos;
/* As per DXVA spec, total amount of bitstream buffer size should be
* 128 bytes aligned. If actual data is not multiple of 128 bytes,
* the last slice data needs to be zero-padded */
inner->bitstream_buffer.resize (bitstream_buffer_size, 0);
GST_DXVA_Tile_AV1 & tile = inner->tile_list.back ();
tile.DataSize += padding;
}
input_args.picture_params = &inner->pic_params;
input_args.picture_params_size = sizeof (GST_DXVA_PicParams_AV1);
input_args.slice_control = &inner->tile_list[0];
input_args.slice_control_size =
sizeof (GST_DXVA_Tile_AV1) * inner->tile_list.size ();
input_args.bitstream = &inner->bitstream_buffer[0];
input_args.bitstream_size = inner->bitstream_buffer.size ();
return gst_d3d11_decoder_decode_frame (inner->d3d11_decoder,
view, &input_args);
}
static GstFlowReturn
gst_d3d11_av1_dec_output_picture (GstAV1Decoder * decoder,
GstVideoCodecFrame * frame, GstAV1Picture * picture)
{
GstD3D11AV1Dec *self = GST_D3D11_AV1_DEC (decoder);
GstD3D11AV1DecInner *inner = self->inner;
GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder);
GstBuffer *view_buffer;
GST_LOG_OBJECT (self, "Outputting picture %p, %dx%d", picture,
picture->frame_hdr.render_width, picture->frame_hdr.render_height);
view_buffer = (GstBuffer *) gst_av1_picture_get_user_data (picture);
if (!view_buffer) {
GST_ERROR_OBJECT (self, "Could not get output view");
goto error;
}
if (!gst_d3d11_decoder_process_output (inner->d3d11_decoder, vdec,
picture->discont_state, picture->frame_hdr.render_width,
picture->frame_hdr.render_height, view_buffer,
&frame->output_buffer)) {
GST_ERROR_OBJECT (self, "Failed to copy buffer");
goto error;
}
gst_av1_picture_unref (picture);
return gst_video_decoder_finish_frame (vdec, frame);
error:
gst_av1_picture_unref (picture);
gst_video_decoder_release_frame (vdec, frame);
return GST_FLOW_ERROR;
}
void
gst_d3d11_av1_dec_register (GstPlugin * plugin, GstD3D11Device * device,
guint rank)
{
GType type;
gchar *type_name;
gchar *feature_name;
guint index = 0;
guint i;
GTypeInfo type_info = {
sizeof (GstD3D11AV1DecClass),
NULL,
NULL,
(GClassInitFunc) gst_d3d11_av1_dec_class_init,
NULL,
NULL,
sizeof (GstD3D11AV1Dec),
0,
(GInstanceInitFunc) gst_d3d11_av1_dec_init,
};
const GUID *profile_guid = NULL;
GstCaps *sink_caps = NULL;
GstCaps *src_caps = NULL;
guint max_width = 0;
guint max_height = 0;
guint resolution;
gboolean have_p010 = FALSE;
gboolean have_gray = FALSE;
gboolean have_gray10 = FALSE;
if (!gst_d3d11_decoder_get_supported_decoder_profile (device,
GST_DXVA_CODEC_AV1, GST_VIDEO_FORMAT_NV12, &profile_guid)) {
GST_INFO_OBJECT (device, "device does not support AV1 decoding");
return;
}
have_p010 = gst_d3d11_decoder_supports_format (device,
profile_guid, DXGI_FORMAT_P010);
have_gray = gst_d3d11_decoder_supports_format (device,
profile_guid, DXGI_FORMAT_R8_UNORM);
have_gray10 = gst_d3d11_decoder_supports_format (device,
profile_guid, DXGI_FORMAT_R16_UNORM);
GST_INFO_OBJECT (device, "Decoder support P010: %d, R8: %d, R16: %d",
have_p010, have_gray, have_gray10);
/* TODO: add test monochrome formats */
for (i = 0; i < G_N_ELEMENTS (gst_dxva_resolutions); i++) {
if (gst_d3d11_decoder_supports_resolution (device, profile_guid,
DXGI_FORMAT_NV12, gst_dxva_resolutions[i].width,
gst_dxva_resolutions[i].height)) {
max_width = gst_dxva_resolutions[i].width;
max_height = gst_dxva_resolutions[i].height;
GST_DEBUG_OBJECT (device,
"device support resolution %dx%d", max_width, max_height);
} else {
break;
}
}
if (max_width == 0 || max_height == 0) {
GST_WARNING_OBJECT (device, "Couldn't query supported resolution");
return;
}
sink_caps =
gst_caps_from_string ("video/x-av1, "
"alignment = (string) frame, profile = (string) main");
src_caps = gst_caps_from_string ("video/x-raw("
GST_CAPS_FEATURE_MEMORY_D3D11_MEMORY "); video/x-raw");
if (have_p010) {
GValue format_list = G_VALUE_INIT;
GValue format_value = G_VALUE_INIT;
g_value_init (&format_list, GST_TYPE_LIST);
g_value_init (&format_value, G_TYPE_STRING);
g_value_set_string (&format_value, "NV12");
gst_value_list_append_and_take_value (&format_list, &format_value);
g_value_init (&format_value, G_TYPE_STRING);
g_value_set_string (&format_value, "P010_10LE");
gst_value_list_append_and_take_value (&format_list, &format_value);
gst_caps_set_value (src_caps, "format", &format_list);
g_value_unset (&format_list);
} else {
gst_caps_set_simple (src_caps, "format", G_TYPE_STRING, "NV12", NULL);
}
/* To cover both landscape and portrait, select max value */
resolution = MAX (max_width, max_height);
type_info.class_data =
gst_d3d11_decoder_class_data_new (device, GST_DXVA_CODEC_AV1,
sink_caps, src_caps, resolution);
type_name = g_strdup ("GstD3D11AV1Dec");
feature_name = g_strdup ("d3d11av1dec");
while (g_type_from_name (type_name)) {
index++;
g_free (type_name);
g_free (feature_name);
type_name = g_strdup_printf ("GstD3D11AV1Device%dDec", index);
feature_name = g_strdup_printf ("d3d11av1device%ddec", index);
}
type = g_type_register_static (GST_TYPE_AV1_DECODER,
type_name, &type_info, (GTypeFlags) 0);
/* make lower rank than default device */
if (rank > 0 && index != 0)
rank--;
if (index != 0)
gst_element_type_set_skip_documentation (type);
if (!gst_element_register (plugin, feature_name, rank, type))
GST_WARNING ("Failed to register plugin '%s'", type_name);
g_free (type_name);
g_free (feature_name);
}
Reference in a new issue View git blame Copy permalink