diff options
Diffstat (limited to 'sys/d3d11/gstd3d11mpeg2dec.cpp')
| -rw-r--r-- | sys/d3d11/gstd3d11mpeg2dec.cpp | 539 |
1 files changed, 208 insertions, 331 deletions
diff --git a/sys/d3d11/gstd3d11mpeg2dec.cpp b/sys/d3d11/gstd3d11mpeg2dec.cpp index b1e1b8ba1..a18c07aae 100644 --- a/sys/d3d11/gstd3d11mpeg2dec.cpp +++ b/sys/d3d11/gstd3d11mpeg2dec.cpp @@ -40,6 +40,7 @@ #include <gst/codecs/gstmpeg2decoder.h> #include <string.h> +#include <vector> /* HACK: to expose dxva data structure on UWP */ #ifdef WINAPI_PARTITION_DESKTOP @@ -55,28 +56,35 @@ GST_DEBUG_CATEGORY_EXTERN (gst_d3d11_mpeg2_dec_debug); /* reference list 2 + 4 margin */ #define NUM_OUTPUT_VIEW 6 -typedef struct _GstD3D11Mpeg2Dec +/* *INDENT-OFF* */ +typedef struct _GstD3D11Mpeg2DecInner { - GstMpeg2Decoder parent; + GstD3D11Device *device = nullptr; + GstD3D11Decoder *d3d11_decoder = nullptr; - GstD3D11Device *device; - GstD3D11Decoder *d3d11_decoder; + DXVA_PictureParameters pic_params; + DXVA_QmatrixData iq_matrix; - gint width, height; - guint width_in_mb, height_in_mb; - GstVideoFormat out_format; - GstMpegVideoSequenceHdr seq; - GstMpegVideoProfile profile; - gboolean interlaced; + std::vector<DXVA_SliceInfo> slice_list; + std::vector<guint8> bitstream_buffer; - /* Array of DXVA_SliceInfo */ - GArray *slice_list; gboolean submit_iq_data; - /* Pointing current bitstream buffer */ - guint written_buffer_size; - guint remaining_buffer_size; - guint8 *bitstream_buffer_data; + gint width = 0; + gint height = 0; + guint width_in_mb = 0; + guint height_in_mb = 0; + GstVideoFormat out_format = GST_VIDEO_FORMAT_UNKNOWN; + GstMpegVideoSequenceHdr seq; + GstMpegVideoProfile profile = GST_MPEG_VIDEO_PROFILE_MAIN; + gboolean interlaced = FALSE; +} GstD3D11Mpeg2DecInner; +/* *INDENT-ON* */ + +typedef struct _GstD3D11Mpeg2Dec +{ + GstMpeg2Decoder parent; + GstD3D11Mpeg2DecInner *inner; } GstD3D11Mpeg2Dec; typedef struct _GstD3D11Mpeg2DecClass @@ -91,9 +99,9 @@ static GstElementClass *parent_class = NULL; #define GST_D3D11_MPEG2_DEC_GET_CLASS(object) \ (G_TYPE_INSTANCE_GET_CLASS ((object),G_TYPE_FROM_INSTANCE (object),GstD3D11Mpeg2DecClass)) -static void gst_d3d11_mpeg2_dec_finalize (GObject * object); static void gst_d3d11_mpeg2_dec_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); +static void gst_d3d11_mpeg2_dec_finalize (GObject * object); static void gst_d3d11_mpeg2_dec_set_context (GstElement * element, GstContext * context); @@ -176,18 +184,7 @@ gst_d3d11_mpeg2_dec_class_init (GstD3D11Mpeg2DecClass * klass, gpointer data) static void gst_d3d11_mpeg2_dec_init (GstD3D11Mpeg2Dec * self) { - self->slice_list = g_array_new (FALSE, TRUE, sizeof (DXVA_SliceInfo)); - self->profile = GST_MPEG_VIDEO_PROFILE_MAIN; -} - -static void -gst_d3d11_mpeg2_dec_finalize (GObject * object) -{ - GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (object); - - g_array_unref (self->slice_list); - - G_OBJECT_CLASS (parent_class)->finalize (object); + self->inner = new GstD3D11Mpeg2DecInner (); } static void @@ -201,14 +198,25 @@ gst_d3d11_mpeg2_dec_get_property (GObject * object, guint prop_id, } static void +gst_d3d11_mpeg2_dec_finalize (GObject * object) +{ + GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (object); + + delete self->inner; + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void gst_d3d11_mpeg2_dec_set_context (GstElement * element, GstContext * context) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (element); + GstD3D11Mpeg2DecInner *inner = self->inner; GstD3D11Mpeg2DecClass *klass = GST_D3D11_MPEG2_DEC_GET_CLASS (self); GstD3D11DecoderSubClassData *cdata = &klass->class_data; gst_d3d11_handle_set_context (element, context, cdata->adapter, - &self->device); + &inner->device); GST_ELEMENT_CLASS (parent_class)->set_context (element, context); } @@ -217,20 +225,22 @@ static gboolean gst_d3d11_mpeg2_dec_open (GstVideoDecoder * decoder) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; GstD3D11Mpeg2DecClass *klass = GST_D3D11_MPEG2_DEC_GET_CLASS (self); GstD3D11DecoderSubClassData *cdata = &klass->class_data; if (!gst_d3d11_ensure_element_data (GST_ELEMENT_CAST (self), cdata->adapter, - &self->device)) { + &inner->device)) { GST_ERROR_OBJECT (self, "Cannot create d3d11device"); return FALSE; } - self->d3d11_decoder = gst_d3d11_decoder_new (self->device); + inner->d3d11_decoder = gst_d3d11_decoder_new (inner->device, + GST_DXVA_CODEC_MPEG2); - if (!self->d3d11_decoder) { + if (!inner->d3d11_decoder) { GST_ERROR_OBJECT (self, "Cannot create d3d11 decoder"); - gst_clear_object (&self->device); + gst_clear_object (&inner->device); return FALSE; } @@ -241,9 +251,10 @@ static gboolean gst_d3d11_mpeg2_dec_close (GstVideoDecoder * decoder) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; - gst_clear_object (&self->d3d11_decoder); - gst_clear_object (&self->device); + gst_clear_object (&inner->d3d11_decoder); + gst_clear_object (&inner->device); return TRUE; } @@ -252,8 +263,9 @@ static gboolean gst_d3d11_mpeg2_dec_negotiate (GstVideoDecoder * decoder) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; - if (!gst_d3d11_decoder_negotiate (self->d3d11_decoder, decoder)) + if (!gst_d3d11_decoder_negotiate (inner->d3d11_decoder, decoder)) return FALSE; return GST_VIDEO_DECODER_CLASS (parent_class)->negotiate (decoder); @@ -264,8 +276,9 @@ gst_d3d11_mpeg2_dec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; - if (!gst_d3d11_decoder_decide_allocation (self->d3d11_decoder, + if (!gst_d3d11_decoder_decide_allocation (inner->d3d11_decoder, decoder, query)) { return FALSE; } @@ -278,11 +291,12 @@ static gboolean gst_d3d11_mpeg2_dec_src_query (GstVideoDecoder * decoder, GstQuery * query) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CONTEXT: if (gst_d3d11_handle_context_query (GST_ELEMENT (decoder), - query, self->device)) { + query, inner->device)) { return TRUE; } break; @@ -297,15 +311,16 @@ static gboolean gst_d3d11_mpeg2_dec_sink_event (GstVideoDecoder * decoder, GstEvent * event) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: - if (self->d3d11_decoder) - gst_d3d11_decoder_set_flushing (self->d3d11_decoder, decoder, TRUE); + if (inner->d3d11_decoder) + gst_d3d11_decoder_set_flushing (inner->d3d11_decoder, decoder, TRUE); break; case GST_EVENT_FLUSH_STOP: - if (self->d3d11_decoder) - gst_d3d11_decoder_set_flushing (self->d3d11_decoder, decoder, FALSE); + if (inner->d3d11_decoder) + gst_d3d11_decoder_set_flushing (inner->d3d11_decoder, decoder, FALSE); default: break; } @@ -321,6 +336,7 @@ gst_d3d11_mpeg2_dec_new_sequence (GstMpeg2Decoder * decoder, const GstMpegVideoSequenceScalableExt * seq_scalable_ext) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; gboolean interlaced; gboolean modified = FALSE; gint width, height; @@ -329,9 +345,9 @@ gst_d3d11_mpeg2_dec_new_sequence (GstMpeg2Decoder * decoder, GST_LOG_OBJECT (self, "new sequence"); interlaced = seq_ext ? !seq_ext->progressive : FALSE; - if (self->interlaced != interlaced) { + if (inner->interlaced != interlaced) { GST_INFO_OBJECT (self, "interlaced sequence change"); - self->interlaced = interlaced; + inner->interlaced = interlaced; modified = TRUE; } @@ -342,13 +358,13 @@ gst_d3d11_mpeg2_dec_new_sequence (GstMpeg2Decoder * decoder, height = (height & 0x0fff) | ((guint32) seq_ext->vert_size_ext << 12); } - if (self->width != width || self->height != height) { + if (inner->width != width || inner->height != height) { GST_INFO_OBJECT (self, "resolution change %dx%d -> %dx%d", - self->width, self->height, width, height); - self->width = width; - self->height = height; - self->width_in_mb = GST_ROUND_UP_16 (width) >> 4; - self->height_in_mb = GST_ROUND_UP_16 (height) >> 4; + inner->width, inner->height, width, height); + inner->width = width; + inner->height = height; + inner->width_in_mb = GST_ROUND_UP_16 (width) >> 4; + inner->height_in_mb = GST_ROUND_UP_16 (height) >> 4; modified = TRUE; } @@ -362,27 +378,27 @@ gst_d3d11_mpeg2_dec_new_sequence (GstMpeg2Decoder * decoder, return FALSE; } - if (self->profile != mpeg_profile) { + if (inner->profile != mpeg_profile) { GST_INFO_OBJECT (self, "Profile change %d -> %d", - self->profile, mpeg_profile); - self->profile = mpeg_profile; + inner->profile, mpeg_profile); + inner->profile = mpeg_profile; modified = TRUE; } - if (modified || !gst_d3d11_decoder_is_configured (self->d3d11_decoder)) { + if (modified || !gst_d3d11_decoder_is_configured (inner->d3d11_decoder)) { GstVideoInfo info; /* FIXME: support I420 */ - self->out_format = GST_VIDEO_FORMAT_NV12; + inner->out_format = GST_VIDEO_FORMAT_NV12; gst_video_info_set_format (&info, - self->out_format, self->width, self->height); - if (self->interlaced) + inner->out_format, inner->width, inner->height); + if (inner->interlaced) GST_VIDEO_INFO_INTERLACE_MODE (&info) = GST_VIDEO_INTERLACE_MODE_MIXED; - if (!gst_d3d11_decoder_configure (self->d3d11_decoder, - GST_D3D11_CODEC_MPEG2, decoder->input_state, &info, - self->width, self->height, NUM_OUTPUT_VIEW)) { + if (!gst_d3d11_decoder_configure (inner->d3d11_decoder, + decoder->input_state, &info, + inner->width, inner->height, NUM_OUTPUT_VIEW)) { GST_ERROR_OBJECT (self, "Failed to create decoder"); return FALSE; } @@ -401,9 +417,10 @@ gst_d3d11_mpeg2_dec_new_picture (GstMpeg2Decoder * decoder, GstVideoCodecFrame * frame, GstMpeg2Picture * picture) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; GstBuffer *view_buffer; - view_buffer = gst_d3d11_decoder_get_output_view_buffer (self->d3d11_decoder, + 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"); @@ -444,33 +461,11 @@ gst_d3d11_mpeg2_dec_new_field_picture (GstMpeg2Decoder * decoder, return TRUE; } -static gboolean -gst_d3d11_mpeg2_dec_get_bitstream_buffer (GstD3D11Mpeg2Dec * self) -{ - GST_TRACE_OBJECT (self, "Getting bitstream buffer"); - - self->written_buffer_size = 0; - self->remaining_buffer_size = 0; - self->bitstream_buffer_data = NULL; - - if (!gst_d3d11_decoder_get_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_BITSTREAM, &self->remaining_buffer_size, - (gpointer *) & self->bitstream_buffer_data)) { - GST_ERROR_OBJECT (self, "Faild to get bitstream buffer"); - return FALSE; - } - - GST_TRACE_OBJECT (self, "Got bitstream buffer %p with size %d", - self->bitstream_buffer_data, self->remaining_buffer_size); - self->written_buffer_size = 0; - - return TRUE; -} - static ID3D11VideoDecoderOutputView * gst_d3d11_mpeg2_dec_get_output_view_from_picture (GstD3D11Mpeg2Dec * self, GstMpeg2Picture * picture, guint8 * view_id) { + GstD3D11Mpeg2DecInner *inner = self->inner; GstBuffer *view_buffer; ID3D11VideoDecoderOutputView *view; @@ -484,7 +479,7 @@ gst_d3d11_mpeg2_dec_get_output_view_from_picture (GstD3D11Mpeg2Dec * self, } view = - gst_d3d11_decoder_get_output_view_from_buffer (self->d3d11_decoder, + 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"); @@ -525,14 +520,13 @@ gst_d3d11_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder, GstMpeg2Picture * prev_picture, GstMpeg2Picture * next_picture) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; + DXVA_PictureParameters *pic_params = &inner->pic_params; + DXVA_QmatrixData *iq_matrix = &inner->iq_matrix; ID3D11VideoDecoderOutputView *view; ID3D11VideoDecoderOutputView *other_view; guint8 view_id = 0xff; guint8 other_view_id = 0xff; - DXVA_PictureParameters pic_params = { 0, }; - DXVA_QmatrixData iq_matrix = { 0, }; - guint d3d11_buffer_size = 0; - gpointer d3d11_buffer = NULL; gboolean is_field = picture->structure != GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME; @@ -543,16 +537,13 @@ gst_d3d11_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder, return FALSE; } - GST_TRACE_OBJECT (self, "Begin frame"); - if (!gst_d3d11_decoder_begin_frame (self->d3d11_decoder, view, 0, NULL)) { - GST_ERROR_OBJECT (self, "Failed to begin frame"); - return FALSE; - } + memset (pic_params, 0, sizeof (DXVA_PictureParameters)); + memset (iq_matrix, 0, sizeof (DXVA_QmatrixData)); /* Fill DXVA_PictureParameters */ - pic_params.wDecodedPictureIndex = view_id; - pic_params.wForwardRefPictureIndex = 0xffff; - pic_params.wBackwardRefPictureIndex = 0xffff; + pic_params->wDecodedPictureIndex = view_id; + pic_params->wForwardRefPictureIndex = 0xffff; + pic_params->wBackwardRefPictureIndex = 0xffff; switch (picture->type) { case GST_MPEG_VIDEO_PICTURE_TYPE_B:{ @@ -561,7 +552,7 @@ gst_d3d11_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder, gst_d3d11_mpeg2_dec_get_output_view_from_picture (self, next_picture, &other_view_id); if (other_view) - pic_params.wBackwardRefPictureIndex = other_view_id; + pic_params->wBackwardRefPictureIndex = other_view_id; } } /* fall-through */ @@ -571,51 +562,33 @@ gst_d3d11_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder, gst_d3d11_mpeg2_dec_get_output_view_from_picture (self, prev_picture, &other_view_id); if (other_view) - pic_params.wForwardRefPictureIndex = other_view_id; + pic_params->wForwardRefPictureIndex = other_view_id; } } default: break; } - /* *INDENT-OFF* */ - pic_params.wPicWidthInMBminus1 = self->width_in_mb - 1; - pic_params.wPicHeightInMBminus1 = (self->height_in_mb >> is_field) - 1; - pic_params.bMacroblockWidthMinus1 = 15; - pic_params.bMacroblockHeightMinus1 = 15; - pic_params.bBlockWidthMinus1 = 7; - pic_params.bBlockHeightMinus1 = 7; - pic_params.bBPPminus1 = 7; - pic_params.bPicStructure = (BYTE) picture->structure; - pic_params.bSecondField = is_field && ! !picture->first_field; - pic_params.bPicIntra = picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_I; - pic_params.bPicBackwardPrediction = + pic_params->wPicWidthInMBminus1 = inner->width_in_mb - 1; + pic_params->wPicHeightInMBminus1 = (inner->height_in_mb >> is_field) - 1; + pic_params->bMacroblockWidthMinus1 = 15; + pic_params->bMacroblockHeightMinus1 = 15; + pic_params->bBlockWidthMinus1 = 7; + pic_params->bBlockHeightMinus1 = 7; + pic_params->bBPPminus1 = 7; + pic_params->bPicStructure = (BYTE) picture->structure; + if (picture->first_field && is_field) { + pic_params->bSecondField = TRUE; + } + pic_params->bPicIntra = picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_I; + pic_params->bPicBackwardPrediction = picture->type == GST_MPEG_VIDEO_PICTURE_TYPE_B; /* FIXME: 1 -> 4:2:0, 2 -> 4:2:2, 3 -> 4:4:4 */ - pic_params.bChromaFormat = 1; - pic_params.bPicScanFixed = 1; - pic_params.bPicScanMethod = slice->pic_ext->alternate_scan; - pic_params.wBitstreamFcodes = _pack_f_codes (slice->pic_ext->f_code); - pic_params.wBitstreamPCEelements = _pack_pce_elements (slice); - /* *INDENT-ON* */ - - GST_TRACE_OBJECT (self, "Getting picture param decoder buffer"); - if (!gst_d3d11_decoder_get_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS, &d3d11_buffer_size, - &d3d11_buffer)) { - GST_ERROR_OBJECT (self, - "Failed to get decoder buffer for picture parameters"); - return FALSE; - } - - memcpy (d3d11_buffer, &pic_params, sizeof (pic_params)); - - GST_TRACE_OBJECT (self, "Release picture param decoder buffer"); - if (!gst_d3d11_decoder_release_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS)) { - GST_ERROR_OBJECT (self, "Failed to release decoder buffer"); - return FALSE; - } + pic_params->bChromaFormat = 1; + pic_params->bPicScanFixed = 1; + pic_params->bPicScanMethod = slice->pic_ext->alternate_scan; + pic_params->wBitstreamFcodes = _pack_f_codes (slice->pic_ext->f_code); + pic_params->wBitstreamPCEelements = _pack_pce_elements (slice); /* Fill DXVA_QmatrixData */ if (slice->quant_matrix && @@ -625,157 +598,46 @@ gst_d3d11_mpeg2_dec_start_picture (GstMpeg2Decoder * decoder, (slice->quant_matrix->load_intra_quantiser_matrix || slice->quant_matrix->load_non_intra_quantiser_matrix)) { GstMpegVideoQuantMatrixExt *quant_matrix = slice->quant_matrix; - self->submit_iq_data = TRUE; if (quant_matrix->load_intra_quantiser_matrix) { - iq_matrix.bNewQmatrix[0] = 1; - memcpy (iq_matrix.Qmatrix[0], quant_matrix->intra_quantiser_matrix, - sizeof (quant_matrix->intra_quantiser_matrix)); + iq_matrix->bNewQmatrix[0] = 1; + for (guint i = 0; i < 64; i++) { + iq_matrix->Qmatrix[0][i] = quant_matrix->intra_quantiser_matrix[i]; + } } if (quant_matrix->load_non_intra_quantiser_matrix) { - iq_matrix.bNewQmatrix[1] = 1; - memcpy (iq_matrix.Qmatrix[1], quant_matrix->non_intra_quantiser_matrix, - sizeof (quant_matrix->non_intra_quantiser_matrix)); + iq_matrix->bNewQmatrix[1] = 1; + for (guint i = 0; i < 64; i++) { + iq_matrix->Qmatrix[1][i] = quant_matrix->non_intra_quantiser_matrix[i]; + } } if (quant_matrix->load_chroma_intra_quantiser_matrix) { - iq_matrix.bNewQmatrix[2] = 1; - memcpy (iq_matrix.Qmatrix[2], quant_matrix->chroma_intra_quantiser_matrix, - sizeof (quant_matrix->chroma_intra_quantiser_matrix)); + iq_matrix->bNewQmatrix[2] = 1; + for (guint i = 0; i < 64; i++) { + iq_matrix->Qmatrix[2][i] = + quant_matrix->chroma_intra_quantiser_matrix[i]; + } } if (quant_matrix->load_chroma_non_intra_quantiser_matrix) { - iq_matrix.bNewQmatrix[3] = 1; - memcpy (iq_matrix.Qmatrix[3], - quant_matrix->chroma_non_intra_quantiser_matrix, - sizeof (quant_matrix->chroma_non_intra_quantiser_matrix)); - } - - GST_TRACE_OBJECT (self, "Getting inverse quantization matrix buffer"); - if (!gst_d3d11_decoder_get_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX, - &d3d11_buffer_size, &d3d11_buffer)) { - GST_ERROR_OBJECT (self, - "Failed to get decoder buffer for inv. quantization matrix"); - return FALSE; + iq_matrix->bNewQmatrix[3] = 1; + for (guint i = 0; i < 64; i++) { + iq_matrix->Qmatrix[3][i] = + quant_matrix->chroma_non_intra_quantiser_matrix[i]; + } } - memcpy (d3d11_buffer, &iq_matrix, sizeof (DXVA_QmatrixData)); - - GST_TRACE_OBJECT (self, "Release inverse quantization matrix buffer"); - if (!gst_d3d11_decoder_release_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX)) { - GST_ERROR_OBJECT (self, "Failed to release decoder buffer"); - return FALSE; - } + inner->submit_iq_data = TRUE; } else { - self->submit_iq_data = FALSE; + inner->submit_iq_data = FALSE; } - g_array_set_size (self->slice_list, 0); - - return gst_d3d11_mpeg2_dec_get_bitstream_buffer (self); -} - -static gboolean -gst_d3d11_mpeg2_dec_submit_slice_data (GstD3D11Mpeg2Dec * self, - GstMpeg2Picture * picture) -{ - guint buffer_size; - gpointer buffer; - guint8 *data; - gsize offset = 0; - guint i; - D3D11_VIDEO_DECODER_BUFFER_DESC buffer_desc[4]; - gboolean ret; - guint buffer_count = 0; - DXVA_SliceInfo *slice_data; - gboolean is_field = - picture->structure != GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME; - guint mb_count = self->width_in_mb * (self->height_in_mb >> is_field); - - if (self->slice_list->len < 1) { - GST_WARNING_OBJECT (self, "Nothing to submit"); - return FALSE; - } - - memset (buffer_desc, 0, sizeof (buffer_desc)); - - GST_TRACE_OBJECT (self, "Getting slice control buffer"); - - if (!gst_d3d11_decoder_get_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL, &buffer_size, &buffer)) { - GST_ERROR_OBJECT (self, "Couldn't get slice control buffer"); - return FALSE; - } + inner->slice_list.resize (0); + inner->bitstream_buffer.resize (0); - data = (guint8 *) buffer; - for (i = 0; i < self->slice_list->len; i++) { - slice_data = &g_array_index (self->slice_list, DXVA_SliceInfo, i); - - /* Update the number of MBs per slice */ - if (i == self->slice_list->len - 1) { - slice_data->wNumberMBsInSlice = mb_count - slice_data->wNumberMBsInSlice; - } else { - DXVA_SliceInfo *next = - &g_array_index (self->slice_list, DXVA_SliceInfo, i + 1); - slice_data->wNumberMBsInSlice = - next->wNumberMBsInSlice - slice_data->wNumberMBsInSlice; - } - - memcpy (data + offset, slice_data, sizeof (DXVA_SliceInfo)); - offset += sizeof (DXVA_SliceInfo); - } - - GST_TRACE_OBJECT (self, "Release slice control buffer"); - if (!gst_d3d11_decoder_release_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL)) { - GST_ERROR_OBJECT (self, "Failed to release slice control buffer"); - return FALSE; - } - - if (!gst_d3d11_decoder_release_decoder_buffer (self->d3d11_decoder, - D3D11_VIDEO_DECODER_BUFFER_BITSTREAM)) { - GST_ERROR_OBJECT (self, "Failed to release bitstream buffer"); - return FALSE; - } - - buffer_desc[buffer_count].BufferType = - D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS; - buffer_desc[buffer_count].DataOffset = 0; - buffer_desc[buffer_count].DataSize = sizeof (DXVA_PictureParameters); - buffer_count++; - - if (self->submit_iq_data) { - buffer_desc[buffer_count].BufferType = - D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX; - buffer_desc[buffer_count].DataOffset = 0; - buffer_desc[buffer_count].DataSize = sizeof (DXVA_QmatrixData); - buffer_count++; - } - - buffer_desc[buffer_count].BufferType = - D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL; - buffer_desc[buffer_count].DataOffset = 0; - buffer_desc[buffer_count].DataSize = - sizeof (DXVA_SliceInfo) * self->slice_list->len; - buffer_count++; - - buffer_desc[buffer_count].BufferType = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM; - buffer_desc[buffer_count].DataOffset = 0; - buffer_desc[buffer_count].DataSize = self->written_buffer_size; - buffer_count++; - - ret = gst_d3d11_decoder_submit_decoder_buffers (self->d3d11_decoder, - buffer_count, buffer_desc); - - self->written_buffer_size = 0; - self->bitstream_buffer_data = NULL; - self->remaining_buffer_size = 0; - g_array_set_size (self->slice_list, 0); - - return ret; + return TRUE; } static gboolean @@ -783,58 +645,98 @@ gst_d3d11_mpeg2_dec_decode_slice (GstMpeg2Decoder * decoder, GstMpeg2Picture * picture, GstMpeg2Slice * slice) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; GstMpegVideoSliceHdr *header = &slice->header; GstMpegVideoPacket *packet = &slice->packet; - /* including start code 4 bytes */ - guint to_write = packet->size + 4; DXVA_SliceInfo slice_info = { 0, }; g_assert (packet->offset >= 4); - /* FIXME: DXVA wants to know the number of MBs per slice - * (not sure whether it's actually used by driver). But in case that - * one slice is splitted into two bitstream buffer, it's almost impossible - * to know the number of MBs per splitted bitstream buffer. - * So, we will not support too large bitstream buffer which requires multiple - * hardware bitstream buffer at this moment. - */ - if (self->remaining_buffer_size < to_write) { - /* Submit slice data we have so that release acquired bitstream buffers */ - if (self->bitstream_buffer_data) - gst_d3d11_mpeg2_dec_submit_slice_data (self, picture); - self->bitstream_buffer_data = 0; - - GST_ERROR_OBJECT (self, "Slice data is too large"); - - return FALSE; - } - slice_info.wHorizontalPosition = header->mb_column; slice_info.wVerticalPosition = header->mb_row; - slice_info.dwSliceBitsInBuffer = 8 * to_write; - slice_info.dwSliceDataLocation = self->written_buffer_size; + /* including start code 4 bytes */ + slice_info.dwSliceBitsInBuffer = 8 * (packet->size + 4); + slice_info.dwSliceDataLocation = inner->bitstream_buffer.size (); /* XXX: We don't have information about the number of MBs in this slice. * Just store offset here, and actual number will be calculated later */ slice_info.wNumberMBsInSlice = - (header->mb_row * self->width_in_mb) + header->mb_column; + (header->mb_row * inner->width_in_mb) + header->mb_column; slice_info.wQuantizerScaleCode = header->quantiser_scale_code; slice_info.wMBbitOffset = header->header_size + 32; - memcpy (self->bitstream_buffer_data, packet->data + packet->offset - 4, - to_write); - g_array_append_val (self->slice_list, slice_info); - self->remaining_buffer_size -= to_write; - self->written_buffer_size += to_write; - self->bitstream_buffer_data += to_write; + inner->slice_list.push_back (slice_info); + + size_t pos = inner->bitstream_buffer.size (); + inner->bitstream_buffer.resize (pos + packet->size + 4); + memcpy (&inner->bitstream_buffer[0] + pos, packet->data + packet->offset - 4, + packet->size + 4); return TRUE; } +static gboolean +gst_d3d11_mpeg2_dec_end_picture (GstMpeg2Decoder * decoder, + GstMpeg2Picture * picture) +{ + GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; + ID3D11VideoDecoderOutputView *view; + guint8 view_id = 0xff; + GstD3D11DecodeInputStreamArgs input_args; + gboolean is_field = + picture->structure != GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME; + guint mb_count = inner->width_in_mb * (inner->height_in_mb >> is_field); + + if (inner->bitstream_buffer.empty ()) { + GST_ERROR_OBJECT (self, "No bitstream buffer to submit"); + return FALSE; + } + + view = gst_d3d11_mpeg2_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 FALSE; + } + + memset (&input_args, 0, sizeof (GstD3D11DecodeInputStreamArgs)); + + DXVA_SliceInfo *first = &inner->slice_list[0]; + for (size_t i = 0; i < inner->slice_list.size (); i++) { + DXVA_SliceInfo *slice = first + i; + + /* Update the number of MBs per slice */ + if (i == inner->slice_list.size () - 1) { + slice->wNumberMBsInSlice = mb_count - slice->wNumberMBsInSlice; + } else { + DXVA_SliceInfo *next = first + i + 1; + slice->wNumberMBsInSlice = + next->wNumberMBsInSlice - slice->wNumberMBsInSlice; + } + } + + input_args.picture_params = &inner->pic_params; + input_args.picture_params_size = sizeof (DXVA_PictureParameters); + input_args.slice_control = &inner->slice_list[0]; + input_args.slice_control_size = + sizeof (DXVA_SliceInfo) * inner->slice_list.size (); + input_args.bitstream = &inner->bitstream_buffer[0]; + input_args.bitstream_size = inner->bitstream_buffer.size (); + if (inner->submit_iq_data) { + input_args.inverse_quantization_matrix = &inner->iq_matrix; + input_args.inverse_quantization_matrix_size = sizeof (DXVA_QmatrixData); + } + + return gst_d3d11_decoder_decode_frame (inner->d3d11_decoder, + view, &input_args); +} + static GstFlowReturn gst_d3d11_mpeg2_dec_output_picture (GstMpeg2Decoder * decoder, GstVideoCodecFrame * frame, GstMpeg2Picture * picture) { GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); + GstD3D11Mpeg2DecInner *inner = self->inner; GstVideoDecoder *vdec = GST_VIDEO_DECODER (decoder); GstBuffer *view_buffer; @@ -847,8 +749,8 @@ gst_d3d11_mpeg2_dec_output_picture (GstMpeg2Decoder * decoder, goto error; } - if (!gst_d3d11_decoder_process_output (self->d3d11_decoder, vdec, - self->width, self->height, view_buffer, &frame->output_buffer)) { + if (!gst_d3d11_decoder_process_output (inner->d3d11_decoder, vdec, + inner->width, inner->height, view_buffer, &frame->output_buffer)) { GST_ERROR_OBJECT (self, "Failed to copy buffer"); goto error; } @@ -869,40 +771,15 @@ gst_d3d11_mpeg2_dec_output_picture (GstMpeg2Decoder * decoder, return gst_video_decoder_finish_frame (vdec, frame); error: - gst_video_decoder_drop_frame (vdec, frame); gst_mpeg2_picture_unref (picture); + gst_video_decoder_release_frame (vdec, frame); return GST_FLOW_ERROR; } -static gboolean -gst_d3d11_mpeg2_dec_end_picture (GstMpeg2Decoder * decoder, - GstMpeg2Picture * picture) -{ - GstD3D11Mpeg2Dec *self = GST_D3D11_MPEG2_DEC (decoder); - - if (!gst_d3d11_mpeg2_dec_submit_slice_data (self, picture)) { - GST_ERROR_OBJECT (self, "Failed to submit slice data"); - return FALSE; - } - - if (!gst_d3d11_decoder_end_frame (self->d3d11_decoder)) { - GST_ERROR_OBJECT (self, "Failed to EndFrame"); - return FALSE; - } - - return TRUE; -} - -typedef struct -{ - guint width; - guint height; -} GstD3D11Mpeg2DecResolution; - void gst_d3d11_mpeg2_dec_register (GstPlugin * plugin, GstD3D11Device * device, - GstD3D11Decoder * decoder, guint rank) + guint rank) { GType type; gchar *type_name; @@ -923,8 +800,8 @@ gst_d3d11_mpeg2_dec_register (GstPlugin * plugin, GstD3D11Device * device, GstCaps *sink_caps = NULL; GstCaps *src_caps = NULL; - if (!gst_d3d11_decoder_get_supported_decoder_profile (decoder, - GST_D3D11_CODEC_MPEG2, GST_VIDEO_FORMAT_NV12, &supported_profile)) { + if (!gst_d3d11_decoder_get_supported_decoder_profile (device, + GST_DXVA_CODEC_MPEG2, GST_VIDEO_FORMAT_NV12, &supported_profile)) { GST_INFO_OBJECT (device, "device does not support MPEG-2 video decoding"); return; } @@ -946,7 +823,7 @@ gst_d3d11_mpeg2_dec_register (GstPlugin * plugin, GstD3D11Device * device, "height", GST_TYPE_INT_RANGE, 1, 1920, NULL); type_info.class_data = - gst_d3d11_decoder_class_data_new (device, GST_D3D11_CODEC_MPEG2, + gst_d3d11_decoder_class_data_new (device, GST_DXVA_CODEC_MPEG2, sink_caps, src_caps); type_name = g_strdup ("GstD3D11Mpeg2Dec"); |