mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
ae2fbf951a
Since sysdeps.h includes string.h there's no need to include it again.
1625 lines
52 KiB
C
1625 lines
52 KiB
C
/*
|
|
* gstvaapidecoder_mpeg2.c - MPEG-2 decoder
|
|
*
|
|
* Copyright (C) 2011-2013 Intel Corporation
|
|
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1
|
|
* 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free
|
|
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gstvaapidecoder_mpeg2
|
|
* @short_description: MPEG-2 decoder
|
|
*/
|
|
|
|
#include "sysdeps.h"
|
|
#include <gst/base/gstbitreader.h>
|
|
#include <gst/codecparsers/gstmpegvideoparser.h>
|
|
#include "gstvaapidecoder_mpeg2.h"
|
|
#include "gstvaapidecoder_objects.h"
|
|
#include "gstvaapidecoder_dpb.h"
|
|
#include "gstvaapidecoder_priv.h"
|
|
#include "gstvaapidisplay_priv.h"
|
|
#include "gstvaapiobject_priv.h"
|
|
|
|
#define DEBUG 1
|
|
#include "gstvaapidebug.h"
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* --- PTS Generator --- */
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
typedef struct _PTSGenerator PTSGenerator;
|
|
struct _PTSGenerator
|
|
{
|
|
GstClockTime gop_pts; // Current GOP PTS
|
|
GstClockTime max_pts; // Max picture PTS
|
|
guint gop_tsn; // Absolute GOP TSN
|
|
guint max_tsn; // Max picture TSN, relative to last GOP TSN
|
|
guint ovl_tsn; // How many times TSN overflowed since GOP
|
|
guint lst_tsn; // Last picture TSN
|
|
guint fps_n;
|
|
guint fps_d;
|
|
};
|
|
|
|
static void
|
|
pts_init (PTSGenerator * tsg)
|
|
{
|
|
tsg->gop_pts = GST_CLOCK_TIME_NONE;
|
|
tsg->max_pts = GST_CLOCK_TIME_NONE;
|
|
tsg->gop_tsn = 0;
|
|
tsg->max_tsn = 0;
|
|
tsg->ovl_tsn = 0;
|
|
tsg->lst_tsn = 0;
|
|
tsg->fps_n = 0;
|
|
tsg->fps_d = 0;
|
|
}
|
|
|
|
static inline GstClockTime
|
|
pts_get_duration (PTSGenerator * tsg, guint num_frames)
|
|
{
|
|
return gst_util_uint64_scale (num_frames,
|
|
GST_SECOND * tsg->fps_d, tsg->fps_n);
|
|
}
|
|
|
|
static inline guint
|
|
pts_get_poc (PTSGenerator * tsg)
|
|
{
|
|
return tsg->gop_tsn + tsg->ovl_tsn * 1024 + tsg->lst_tsn;
|
|
}
|
|
|
|
static void
|
|
pts_set_framerate (PTSGenerator * tsg, guint fps_n, guint fps_d)
|
|
{
|
|
tsg->fps_n = fps_n;
|
|
tsg->fps_d = fps_d;
|
|
}
|
|
|
|
static void
|
|
pts_sync (PTSGenerator * tsg, GstClockTime gop_pts)
|
|
{
|
|
guint gop_tsn;
|
|
|
|
if (!GST_CLOCK_TIME_IS_VALID (gop_pts) ||
|
|
(GST_CLOCK_TIME_IS_VALID (tsg->max_pts) && tsg->max_pts >= gop_pts)) {
|
|
/* Invalid GOP PTS, interpolate from the last known picture PTS */
|
|
if (GST_CLOCK_TIME_IS_VALID (tsg->max_pts)) {
|
|
gop_pts = tsg->max_pts + pts_get_duration (tsg, 1);
|
|
gop_tsn = tsg->gop_tsn + tsg->ovl_tsn * 1024 + tsg->max_tsn + 1;
|
|
} else {
|
|
gop_pts = 0;
|
|
gop_tsn = 0;
|
|
}
|
|
} else {
|
|
/* Interpolate GOP TSN from this valid PTS */
|
|
if (GST_CLOCK_TIME_IS_VALID (tsg->gop_pts))
|
|
gop_tsn =
|
|
tsg->gop_tsn + gst_util_uint64_scale (gop_pts - tsg->gop_pts +
|
|
pts_get_duration (tsg, 1) - 1, tsg->fps_n, GST_SECOND * tsg->fps_d);
|
|
else
|
|
gop_tsn = 0;
|
|
}
|
|
|
|
tsg->gop_pts = gop_pts;
|
|
tsg->gop_tsn = gop_tsn;
|
|
tsg->max_tsn = 0;
|
|
tsg->ovl_tsn = 0;
|
|
tsg->lst_tsn = 0;
|
|
}
|
|
|
|
static GstClockTime
|
|
pts_eval (PTSGenerator * tsg, GstClockTime pic_pts, guint pic_tsn)
|
|
{
|
|
GstClockTime pts;
|
|
|
|
if (!GST_CLOCK_TIME_IS_VALID (tsg->gop_pts))
|
|
tsg->gop_pts = pts_get_duration (tsg, pic_tsn);
|
|
|
|
pts = pic_pts;
|
|
if (!GST_CLOCK_TIME_IS_VALID (pts))
|
|
pts = tsg->gop_pts + pts_get_duration (tsg, tsg->ovl_tsn * 1024 + pic_tsn);
|
|
else if (pts == tsg->gop_pts) {
|
|
/* The picture following the GOP header shall be an I-frame.
|
|
So we can compensate for the GOP start time from here */
|
|
tsg->gop_pts -= pts_get_duration (tsg, pic_tsn);
|
|
}
|
|
|
|
if (!GST_CLOCK_TIME_IS_VALID (tsg->max_pts) || tsg->max_pts < pts)
|
|
tsg->max_pts = pts;
|
|
|
|
if (tsg->max_tsn < pic_tsn)
|
|
tsg->max_tsn = pic_tsn;
|
|
else if (tsg->max_tsn == 1023 && pic_tsn < tsg->lst_tsn) { /* TSN wrapped */
|
|
tsg->max_tsn = pic_tsn;
|
|
tsg->ovl_tsn++;
|
|
}
|
|
tsg->lst_tsn = pic_tsn;
|
|
|
|
return pts;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* --- MPEG-2 Parser Info --- */
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
typedef struct _GstVaapiParserInfoMpeg2 GstVaapiParserInfoMpeg2;
|
|
struct _GstVaapiParserInfoMpeg2
|
|
{
|
|
GstVaapiMiniObject parent_instance;
|
|
GstMpegVideoPacket packet;
|
|
guint8 extension_type; /* for Extension packets */
|
|
union
|
|
{
|
|
GstMpegVideoSequenceHdr seq_hdr;
|
|
GstMpegVideoSequenceExt seq_ext;
|
|
GstMpegVideoSequenceDisplayExt seq_display_ext;
|
|
GstMpegVideoSequenceScalableExt seq_scalable_ext;
|
|
GstMpegVideoGop gop;
|
|
GstMpegVideoQuantMatrixExt quant_matrix;
|
|
GstMpegVideoPictureHdr pic_hdr;
|
|
GstMpegVideoPictureExt pic_ext;
|
|
GstMpegVideoSliceHdr slice_hdr;
|
|
} data;
|
|
};
|
|
|
|
static inline const GstVaapiMiniObjectClass *
|
|
gst_vaapi_parser_info_mpeg2_class (void)
|
|
{
|
|
static const GstVaapiMiniObjectClass GstVaapiParserInfoMpeg2Class = {
|
|
sizeof (GstVaapiParserInfoMpeg2),
|
|
NULL
|
|
};
|
|
return &GstVaapiParserInfoMpeg2Class;
|
|
}
|
|
|
|
static inline GstVaapiParserInfoMpeg2 *
|
|
gst_vaapi_parser_info_mpeg2_new (void)
|
|
{
|
|
return (GstVaapiParserInfoMpeg2 *)
|
|
gst_vaapi_mini_object_new (gst_vaapi_parser_info_mpeg2_class ());
|
|
}
|
|
|
|
static inline GstVaapiParserInfoMpeg2 *
|
|
gst_vaapi_parser_info_mpeg2_ensure (GstVaapiParserInfoMpeg2 ** pi_ptr)
|
|
{
|
|
GstVaapiParserInfoMpeg2 *pi = *pi_ptr;
|
|
|
|
if (G_LIKELY (pi != NULL))
|
|
return pi;
|
|
|
|
*pi_ptr = pi = gst_vaapi_parser_info_mpeg2_new ();
|
|
return pi;
|
|
}
|
|
|
|
#define gst_vaapi_parser_info_mpeg2_ref(pi) \
|
|
gst_vaapi_mini_object_ref(GST_VAAPI_MINI_OBJECT(pi))
|
|
|
|
#define gst_vaapi_parser_info_mpeg2_unref(pi) \
|
|
gst_vaapi_mini_object_unref(GST_VAAPI_MINI_OBJECT(pi))
|
|
|
|
#define gst_vaapi_parser_info_mpeg2_replace(old_pi_ptr, new_pi) \
|
|
gst_vaapi_mini_object_replace((GstVaapiMiniObject **)(old_pi_ptr), \
|
|
(GstVaapiMiniObject *)(new_pi))
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* --- MPEG-2 Decoder --- */
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
#define GST_VAAPI_DECODER_MPEG2_CAST(decoder) \
|
|
((GstVaapiDecoderMpeg2 *)(decoder))
|
|
|
|
typedef struct _GstVaapiDecoderMpeg2Private GstVaapiDecoderMpeg2Private;
|
|
typedef struct _GstVaapiDecoderMpeg2Class GstVaapiDecoderMpeg2Class;
|
|
|
|
typedef enum
|
|
{
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR = 1 << 0,
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT = 1 << 1,
|
|
GST_MPEG_VIDEO_STATE_GOT_PIC_HDR = 1 << 2,
|
|
GST_MPEG_VIDEO_STATE_GOT_PIC_EXT = 1 << 3,
|
|
GST_MPEG_VIDEO_STATE_GOT_SLICE = 1 << 4,
|
|
|
|
GST_MPEG_VIDEO_STATE_VALID_SEQ_HEADERS = (GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR |
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT),
|
|
GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS = (GST_MPEG_VIDEO_STATE_GOT_PIC_HDR |
|
|
GST_MPEG_VIDEO_STATE_GOT_PIC_EXT),
|
|
GST_MPEG_VIDEO_STATE_VALID_PICTURE = (GST_MPEG_VIDEO_STATE_VALID_SEQ_HEADERS |
|
|
GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS | GST_MPEG_VIDEO_STATE_GOT_SLICE)
|
|
} GstMpegVideoState;
|
|
|
|
struct _GstVaapiDecoderMpeg2Private
|
|
{
|
|
GstVaapiProfile profile;
|
|
GstVaapiProfile hw_profile;
|
|
guint width;
|
|
guint height;
|
|
guint fps_n;
|
|
guint fps_d;
|
|
guint state;
|
|
GstVaapiRectangle crop_rect;
|
|
GstVaapiParserInfoMpeg2 *seq_hdr;
|
|
GstVaapiParserInfoMpeg2 *seq_ext;
|
|
GstVaapiParserInfoMpeg2 *seq_display_ext;
|
|
GstVaapiParserInfoMpeg2 *seq_scalable_ext;
|
|
GstVaapiParserInfoMpeg2 *gop;
|
|
GstVaapiParserInfoMpeg2 *pic_hdr;
|
|
GstVaapiParserInfoMpeg2 *pic_ext;
|
|
GstVaapiParserInfoMpeg2 *pic_display_ext;
|
|
GstVaapiParserInfoMpeg2 *quant_matrix;
|
|
GstVaapiParserInfoMpeg2 *slice_hdr;
|
|
GstVaapiPicture *current_picture;
|
|
GstVaapiDpb *dpb;
|
|
PTSGenerator tsg;
|
|
guint is_opened:1;
|
|
guint size_changed:1;
|
|
guint profile_changed:1;
|
|
guint quant_matrix_changed:1;
|
|
guint progressive_sequence:1;
|
|
guint closed_gop:1;
|
|
guint broken_link:1;
|
|
};
|
|
|
|
/**
|
|
* GstVaapiDecoderMpeg2:
|
|
*
|
|
* A decoder based on Mpeg2.
|
|
*/
|
|
struct _GstVaapiDecoderMpeg2
|
|
{
|
|
/*< private > */
|
|
GstVaapiDecoder parent_instance;
|
|
GstVaapiDecoderMpeg2Private priv;
|
|
};
|
|
|
|
/**
|
|
* GstVaapiDecoderMpeg2Class:
|
|
*
|
|
* A decoder class based on Mpeg2.
|
|
*/
|
|
struct _GstVaapiDecoderMpeg2Class
|
|
{
|
|
/*< private > */
|
|
GstVaapiDecoderClass parent_class;
|
|
};
|
|
|
|
G_DEFINE_TYPE (GstVaapiDecoderMpeg2, gst_vaapi_decoder_mpeg2,
|
|
GST_TYPE_VAAPI_DECODER);
|
|
|
|
static void
|
|
gst_vaapi_decoder_mpeg2_close (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
gst_vaapi_picture_replace (&priv->current_picture, NULL);
|
|
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_hdr, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_display_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_scalable_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->gop, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->pic_hdr, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->pic_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->pic_display_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->quant_matrix, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->slice_hdr, NULL);
|
|
|
|
priv->state = 0;
|
|
|
|
gst_vaapi_dpb_replace (&priv->dpb, NULL);
|
|
|
|
priv->is_opened = FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_vaapi_decoder_mpeg2_open (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
gst_vaapi_decoder_mpeg2_close (decoder);
|
|
|
|
priv->dpb = gst_vaapi_dpb_new (2);
|
|
if (!priv->dpb)
|
|
return FALSE;
|
|
|
|
pts_init (&priv->tsg);
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_decoder_mpeg2_destroy (GstVaapiDecoder * base_decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
|
|
gst_vaapi_decoder_mpeg2_close (decoder);
|
|
}
|
|
|
|
static gboolean
|
|
gst_vaapi_decoder_mpeg2_create (GstVaapiDecoder * base_decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
priv->hw_profile = GST_VAAPI_PROFILE_UNKNOWN;
|
|
priv->profile = GST_VAAPI_PROFILE_MPEG2_SIMPLE;
|
|
priv->profile_changed = TRUE; /* Allow fallbacks to work */
|
|
return TRUE;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_reset (GstVaapiDecoder * base_decoder)
|
|
{
|
|
gst_vaapi_decoder_mpeg2_destroy (base_decoder);
|
|
gst_vaapi_decoder_mpeg2_create (base_decoder);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void
|
|
copy_quant_matrix (guint8 dst[64], const guint8 src[64])
|
|
{
|
|
memcpy (dst, src, 64);
|
|
}
|
|
|
|
static const char *
|
|
get_profile_str (GstVaapiProfile profile)
|
|
{
|
|
const char *str;
|
|
|
|
switch (profile) {
|
|
case GST_VAAPI_PROFILE_MPEG2_SIMPLE:
|
|
str = "simple";
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_MAIN:
|
|
str = "main";
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_HIGH:
|
|
str = "high";
|
|
break;
|
|
default:
|
|
str = "<unknown>";
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static GstVaapiProfile
|
|
get_profile (GstVaapiDecoderMpeg2 * decoder, GstVaapiEntrypoint entrypoint)
|
|
{
|
|
GstVaapiDisplay *const va_display = GST_VAAPI_DECODER_DISPLAY (decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstVaapiProfile profile = priv->profile;
|
|
|
|
do {
|
|
/* Return immediately if the exact same profile was found */
|
|
if (gst_vaapi_display_has_decoder (va_display, profile, entrypoint))
|
|
break;
|
|
|
|
/* Otherwise, try to map to a higher profile */
|
|
switch (profile) {
|
|
case GST_VAAPI_PROFILE_MPEG2_SIMPLE:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_MAIN;
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_MAIN:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_HIGH;
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_HIGH:
|
|
// Try to map to main profile if no high profile specific bits used
|
|
if (priv->profile == profile &&
|
|
!priv->seq_scalable_ext &&
|
|
(priv->seq_ext && priv->seq_ext->data.seq_ext.chroma_format == 1)) {
|
|
profile = GST_VAAPI_PROFILE_MPEG2_MAIN;
|
|
break;
|
|
}
|
|
// fall-through
|
|
default:
|
|
profile = GST_VAAPI_PROFILE_UNKNOWN;
|
|
break;
|
|
}
|
|
} while (profile != GST_VAAPI_PROFILE_UNKNOWN);
|
|
|
|
if (profile != priv->profile)
|
|
GST_INFO ("forced %s profile to %s profile",
|
|
get_profile_str (priv->profile), get_profile_str (profile));
|
|
return profile;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
ensure_context (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstVaapiEntrypoint entrypoint = GST_VAAPI_ENTRYPOINT_VLD;
|
|
gboolean reset_context = FALSE;
|
|
|
|
if (priv->profile_changed) {
|
|
GST_DEBUG ("profile changed");
|
|
priv->profile_changed = FALSE;
|
|
reset_context = TRUE;
|
|
|
|
priv->hw_profile = get_profile (decoder, entrypoint);
|
|
if (priv->hw_profile == GST_VAAPI_PROFILE_UNKNOWN)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
|
|
}
|
|
|
|
if (priv->size_changed) {
|
|
GST_DEBUG ("size changed");
|
|
priv->size_changed = FALSE;
|
|
reset_context = TRUE;
|
|
}
|
|
|
|
if (reset_context) {
|
|
GstVaapiContextInfo info;
|
|
|
|
info.profile = priv->hw_profile;
|
|
info.entrypoint = entrypoint;
|
|
info.chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420;
|
|
info.width = priv->width;
|
|
info.height = priv->height;
|
|
info.ref_frames = 2;
|
|
reset_context =
|
|
gst_vaapi_decoder_ensure_context (GST_VAAPI_DECODER_CAST (decoder),
|
|
&info);
|
|
if (!reset_context)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
ensure_quant_matrix (GstVaapiDecoderMpeg2 * decoder, GstVaapiPicture * picture)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceHdr *const seq_hdr = &priv->seq_hdr->data.seq_hdr;
|
|
VAIQMatrixBufferMPEG2 *iq_matrix;
|
|
guint8 *intra_quant_matrix = NULL;
|
|
guint8 *non_intra_quant_matrix = NULL;
|
|
guint8 *chroma_intra_quant_matrix = NULL;
|
|
guint8 *chroma_non_intra_quant_matrix = NULL;
|
|
|
|
if (!priv->quant_matrix_changed)
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
priv->quant_matrix_changed = FALSE;
|
|
|
|
picture->iq_matrix = GST_VAAPI_IQ_MATRIX_NEW (MPEG2, decoder);
|
|
if (!picture->iq_matrix) {
|
|
GST_ERROR ("failed to allocate IQ matrix");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
iq_matrix = picture->iq_matrix->param;
|
|
|
|
intra_quant_matrix = seq_hdr->intra_quantizer_matrix;
|
|
non_intra_quant_matrix = seq_hdr->non_intra_quantizer_matrix;
|
|
|
|
if (priv->quant_matrix) {
|
|
GstMpegVideoQuantMatrixExt *const quant_matrix =
|
|
&priv->quant_matrix->data.quant_matrix;
|
|
if (quant_matrix->load_intra_quantiser_matrix)
|
|
intra_quant_matrix = quant_matrix->intra_quantiser_matrix;
|
|
if (quant_matrix->load_non_intra_quantiser_matrix)
|
|
non_intra_quant_matrix = quant_matrix->non_intra_quantiser_matrix;
|
|
if (quant_matrix->load_chroma_intra_quantiser_matrix)
|
|
chroma_intra_quant_matrix = quant_matrix->chroma_intra_quantiser_matrix;
|
|
if (quant_matrix->load_chroma_non_intra_quantiser_matrix)
|
|
chroma_non_intra_quant_matrix =
|
|
quant_matrix->chroma_non_intra_quantiser_matrix;
|
|
}
|
|
|
|
iq_matrix->load_intra_quantiser_matrix = intra_quant_matrix != NULL;
|
|
if (intra_quant_matrix)
|
|
copy_quant_matrix (iq_matrix->intra_quantiser_matrix, intra_quant_matrix);
|
|
|
|
iq_matrix->load_non_intra_quantiser_matrix = non_intra_quant_matrix != NULL;
|
|
if (non_intra_quant_matrix)
|
|
copy_quant_matrix (iq_matrix->non_intra_quantiser_matrix,
|
|
non_intra_quant_matrix);
|
|
|
|
iq_matrix->load_chroma_intra_quantiser_matrix =
|
|
chroma_intra_quant_matrix != NULL;
|
|
if (chroma_intra_quant_matrix)
|
|
copy_quant_matrix (iq_matrix->chroma_intra_quantiser_matrix,
|
|
chroma_intra_quant_matrix);
|
|
|
|
iq_matrix->load_chroma_non_intra_quantiser_matrix =
|
|
chroma_non_intra_quant_matrix != NULL;
|
|
if (chroma_non_intra_quant_matrix)
|
|
copy_quant_matrix (iq_matrix->chroma_non_intra_quantiser_matrix,
|
|
chroma_non_intra_quant_matrix);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline gboolean
|
|
is_valid_state (GstVaapiDecoderMpeg2 * decoder, guint state)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
return (priv->state & state) == state;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_current_picture (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstVaapiPicture *const picture = priv->current_picture;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_VALID_PICTURE))
|
|
goto drop_frame;
|
|
priv->state &= GST_MPEG_VIDEO_STATE_VALID_SEQ_HEADERS;
|
|
|
|
if (!picture)
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
if (!gst_vaapi_picture_decode (picture))
|
|
goto error;
|
|
if (GST_VAAPI_PICTURE_IS_COMPLETE (picture)) {
|
|
if (!gst_vaapi_dpb_add (priv->dpb, picture))
|
|
goto error;
|
|
gst_vaapi_picture_replace (&priv->current_picture, NULL);
|
|
}
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
/* XXX: fix for cases where first field failed to be decoded */
|
|
gst_vaapi_picture_replace (&priv->current_picture, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
|
|
drop_frame:
|
|
{
|
|
priv->state &= GST_MPEG_VIDEO_STATE_VALID_SEQ_HEADERS;
|
|
return (GstVaapiDecoderStatus) GST_VAAPI_DECODER_STATUS_DROP_FRAME;
|
|
}
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_sequence (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceHdr *seq_hdr;
|
|
|
|
priv->state = 0;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->seq_hdr)) {
|
|
GST_ERROR ("failed to allocate parser info for sequence header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
seq_hdr = &priv->seq_hdr->data.seq_hdr;
|
|
|
|
if (!gst_mpeg_video_packet_parse_sequence_header (packet, seq_hdr)) {
|
|
GST_ERROR ("failed to parse sequence header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, seq_hdr, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_sequence (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER_CAST (decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceHdr *const seq_hdr = unit->parsed_info;
|
|
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_display_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->seq_scalable_ext, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->quant_matrix, NULL);
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->pic_display_ext, NULL);
|
|
|
|
priv->fps_n = seq_hdr->fps_n;
|
|
priv->fps_d = seq_hdr->fps_d;
|
|
pts_set_framerate (&priv->tsg, priv->fps_n, priv->fps_d);
|
|
gst_vaapi_decoder_set_framerate (base_decoder, priv->fps_n, priv->fps_d);
|
|
|
|
priv->width = seq_hdr->width;
|
|
priv->height = seq_hdr->height;
|
|
priv->size_changed = TRUE;
|
|
priv->quant_matrix_changed = TRUE;
|
|
priv->progressive_sequence = TRUE;
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_sequence_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceExt *seq_ext;
|
|
|
|
priv->state &= GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->seq_ext)) {
|
|
GST_ERROR ("failed to allocate parser info for sequence extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
seq_ext = &priv->seq_ext->data.seq_ext;
|
|
|
|
if (!gst_mpeg_video_packet_parse_sequence_extension (packet, seq_ext)) {
|
|
GST_ERROR ("failed to parse sequence-extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, seq_ext, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_sequence_ext (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER_CAST (decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceExt *const seq_ext = unit->parsed_info;
|
|
GstVaapiProfile profile;
|
|
guint width, height;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
priv->progressive_sequence = seq_ext->progressive;
|
|
gst_vaapi_decoder_set_interlaced (base_decoder, !priv->progressive_sequence);
|
|
|
|
width = (priv->width & 0x0fff) | ((guint32) seq_ext->horiz_size_ext << 12);
|
|
height = (priv->height & 0x0fff) | ((guint32) seq_ext->vert_size_ext << 12);
|
|
GST_DEBUG ("video resolution %ux%u", width, height);
|
|
|
|
if (seq_ext->fps_n_ext && seq_ext->fps_d_ext) {
|
|
priv->fps_n *= seq_ext->fps_n_ext + 1;
|
|
priv->fps_d *= seq_ext->fps_d_ext + 1;
|
|
pts_set_framerate (&priv->tsg, priv->fps_n, priv->fps_d);
|
|
gst_vaapi_decoder_set_framerate (base_decoder, priv->fps_n, priv->fps_d);
|
|
}
|
|
|
|
if (priv->width != width) {
|
|
priv->width = width;
|
|
priv->size_changed = TRUE;
|
|
}
|
|
|
|
if (priv->height != height) {
|
|
priv->height = height;
|
|
priv->size_changed = TRUE;
|
|
}
|
|
|
|
switch (seq_ext->profile) {
|
|
case GST_MPEG_VIDEO_PROFILE_SIMPLE:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_SIMPLE;
|
|
break;
|
|
case GST_MPEG_VIDEO_PROFILE_MAIN:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_MAIN;
|
|
break;
|
|
case GST_MPEG_VIDEO_PROFILE_HIGH:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_HIGH;
|
|
break;
|
|
default:
|
|
GST_ERROR ("unsupported profile %d", seq_ext->profile);
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
|
|
}
|
|
if (priv->profile != profile) {
|
|
priv->profile = profile;
|
|
priv->profile_changed = TRUE;
|
|
}
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_sequence_display_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceDisplayExt *seq_display_ext;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->seq_display_ext)) {
|
|
GST_ERROR ("failed to allocate parser info for sequence display extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
seq_display_ext = &priv->seq_display_ext->data.seq_display_ext;
|
|
|
|
if (!gst_mpeg_video_packet_parse_sequence_display_extension (packet,
|
|
seq_display_ext)) {
|
|
GST_ERROR ("failed to parse sequence-display-extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, seq_display_ext, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_sequence_display_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceDisplayExt *seq_display_ext;
|
|
|
|
seq_display_ext = priv->seq_display_ext ?
|
|
&priv->seq_display_ext->data.seq_display_ext : NULL;
|
|
|
|
/* Update cropping rectangle */
|
|
if (seq_display_ext) {
|
|
GstVaapiRectangle *const crop_rect = &priv->crop_rect;
|
|
crop_rect->x = 0;
|
|
crop_rect->y = 0;
|
|
crop_rect->width = seq_display_ext->display_horizontal_size;
|
|
crop_rect->height = seq_display_ext->display_vertical_size;
|
|
}
|
|
|
|
/* XXX: handle color primaries */
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_sequence_scalable_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceScalableExt *seq_scalable_ext;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->seq_scalable_ext)) {
|
|
GST_ERROR
|
|
("failed to allocate parser info for sequence scalable extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
seq_scalable_ext = &priv->seq_scalable_ext->data.seq_scalable_ext;
|
|
|
|
if (!gst_mpeg_video_packet_parse_sequence_scalable_extension (packet,
|
|
seq_scalable_ext)) {
|
|
GST_ERROR ("failed to parse sequence-scalable-extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, seq_scalable_ext, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_sequence_scalable_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit)
|
|
{
|
|
/* XXX: unsupported header -- ignore */
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_sequence_end (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
if (priv->dpb)
|
|
gst_vaapi_dpb_flush (priv->dpb);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_quant_matrix_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoQuantMatrixExt *quant_matrix;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->quant_matrix)) {
|
|
GST_ERROR ("failed to allocate parser info for quantization matrix");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
quant_matrix = &priv->quant_matrix->data.quant_matrix;
|
|
|
|
if (!gst_mpeg_video_packet_parse_quant_matrix_extension (packet,
|
|
quant_matrix)) {
|
|
GST_ERROR ("failed to parse quant-matrix-extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, quant_matrix, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_quant_matrix_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
priv->quant_matrix_changed = TRUE;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_gop (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoGop *gop;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->gop)) {
|
|
GST_ERROR ("failed to allocate parser info for GOP");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
gop = &priv->gop->data.gop;
|
|
|
|
if (!gst_mpeg_video_packet_parse_gop (packet, gop)) {
|
|
GST_ERROR ("failed to parse GOP");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, gop, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_gop (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoGop *const gop = unit->parsed_info;
|
|
|
|
priv->closed_gop = gop->closed_gop;
|
|
priv->broken_link = gop->broken_link;
|
|
|
|
GST_DEBUG ("GOP %02u:%02u:%02u:%02u (closed_gop %d, broken_link %d)",
|
|
gop->hour, gop->minute, gop->second, gop->frame,
|
|
priv->closed_gop, priv->broken_link);
|
|
|
|
pts_sync (&priv->tsg, GST_VAAPI_DECODER_CODEC_FRAME (decoder)->pts);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_picture (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoPictureHdr *pic_hdr;
|
|
|
|
priv->state &= (GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR |
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT);
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->pic_hdr)) {
|
|
GST_ERROR ("failed to allocate parser info for picture header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
pic_hdr = &priv->pic_hdr->data.pic_hdr;
|
|
|
|
if (!gst_mpeg_video_packet_parse_picture_header (packet, pic_hdr)) {
|
|
GST_ERROR ("failed to parse picture header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, pic_hdr, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_picture (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_VALID_SEQ_HEADERS))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
gst_vaapi_parser_info_mpeg2_replace (&priv->pic_ext, NULL);
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_GOT_PIC_HDR;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_picture_ext (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoPictureExt *pic_ext;
|
|
|
|
priv->state &= (GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR |
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT | GST_MPEG_VIDEO_STATE_GOT_PIC_HDR);
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->pic_ext)) {
|
|
GST_ERROR ("failed to allocate parser info for picture extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
pic_ext = &priv->pic_ext->data.pic_ext;
|
|
|
|
if (!gst_mpeg_video_packet_parse_picture_extension (packet, pic_ext)) {
|
|
GST_ERROR ("failed to parse picture-extension");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, pic_ext, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_picture_ext (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoPictureExt *const pic_ext = unit->parsed_info;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_GOT_PIC_HDR))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
if (priv->progressive_sequence && !pic_ext->progressive_frame) {
|
|
GST_WARNING ("invalid interlaced frame in progressive sequence, fixing");
|
|
pic_ext->progressive_frame = 1;
|
|
}
|
|
|
|
if (pic_ext->picture_structure == 0 ||
|
|
(pic_ext->progressive_frame &&
|
|
pic_ext->picture_structure !=
|
|
GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME)) {
|
|
GST_WARNING ("invalid picture_structure %d, replacing with \"frame\"",
|
|
pic_ext->picture_structure);
|
|
pic_ext->picture_structure = GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME;
|
|
}
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_GOT_PIC_EXT;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline guint32
|
|
pack_f_code (guint8 f_code[2][2])
|
|
{
|
|
return (((guint32) f_code[0][0] << 12) |
|
|
((guint32) f_code[0][1] << 8) |
|
|
((guint32) f_code[1][0] << 4) | (f_code[1][1]));
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
init_picture (GstVaapiDecoderMpeg2 * decoder, GstVaapiPicture * picture)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoPictureHdr *const pic_hdr = &priv->pic_hdr->data.pic_hdr;
|
|
GstMpegVideoPictureExt *const pic_ext = &priv->pic_ext->data.pic_ext;
|
|
|
|
switch (pic_hdr->pic_type) {
|
|
case GST_MPEG_VIDEO_PICTURE_TYPE_I:
|
|
GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_REFERENCE);
|
|
picture->type = GST_VAAPI_PICTURE_TYPE_I;
|
|
break;
|
|
case GST_MPEG_VIDEO_PICTURE_TYPE_P:
|
|
GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_REFERENCE);
|
|
picture->type = GST_VAAPI_PICTURE_TYPE_P;
|
|
break;
|
|
case GST_MPEG_VIDEO_PICTURE_TYPE_B:
|
|
picture->type = GST_VAAPI_PICTURE_TYPE_B;
|
|
break;
|
|
default:
|
|
GST_ERROR ("unsupported picture type %d", pic_hdr->pic_type);
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
|
|
if (!priv->progressive_sequence && !pic_ext->progressive_frame) {
|
|
GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_INTERLACED);
|
|
if (pic_ext->top_field_first)
|
|
GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_TFF);
|
|
}
|
|
|
|
switch (pic_ext->picture_structure) {
|
|
case GST_MPEG_VIDEO_PICTURE_STRUCTURE_TOP_FIELD:
|
|
picture->structure = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
|
|
break;
|
|
case GST_MPEG_VIDEO_PICTURE_STRUCTURE_BOTTOM_FIELD:
|
|
picture->structure = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
|
|
break;
|
|
case GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME:
|
|
picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
|
|
break;
|
|
}
|
|
|
|
/* Allocate dummy picture for first field based I-frame */
|
|
if (picture->type == GST_VAAPI_PICTURE_TYPE_I &&
|
|
!GST_VAAPI_PICTURE_IS_FRAME (picture) &&
|
|
gst_vaapi_dpb_size (priv->dpb) == 0) {
|
|
GstVaapiPicture *dummy_picture;
|
|
gboolean success;
|
|
|
|
dummy_picture = GST_VAAPI_PICTURE_NEW (MPEG2, decoder);
|
|
if (!dummy_picture) {
|
|
GST_ERROR ("failed to allocate dummy picture");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
dummy_picture->type = GST_VAAPI_PICTURE_TYPE_I;
|
|
dummy_picture->pts = GST_CLOCK_TIME_NONE;
|
|
dummy_picture->poc = -1;
|
|
dummy_picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
|
|
|
|
GST_VAAPI_PICTURE_FLAG_SET (dummy_picture,
|
|
(GST_VAAPI_PICTURE_FLAG_SKIPPED |
|
|
GST_VAAPI_PICTURE_FLAG_OUTPUT | GST_VAAPI_PICTURE_FLAG_REFERENCE)
|
|
);
|
|
|
|
success = gst_vaapi_dpb_add (priv->dpb, dummy_picture);
|
|
gst_vaapi_picture_unref (dummy_picture);
|
|
if (!success) {
|
|
GST_ERROR ("failed to add dummy picture into DPB");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
GST_INFO ("allocated dummy picture for first field based I-frame");
|
|
}
|
|
|
|
/* Update presentation time */
|
|
picture->pts = pts_eval (&priv->tsg,
|
|
GST_VAAPI_DECODER_CODEC_FRAME (decoder)->pts, pic_hdr->tsn);
|
|
picture->poc = pts_get_poc (&priv->tsg);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
fill_picture (GstVaapiDecoderMpeg2 * decoder, GstVaapiPicture * picture)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
VAPictureParameterBufferMPEG2 *const pic_param = picture->param;
|
|
GstMpegVideoPictureHdr *const pic_hdr = &priv->pic_hdr->data.pic_hdr;
|
|
GstMpegVideoPictureExt *const pic_ext = &priv->pic_ext->data.pic_ext;
|
|
GstVaapiPicture *prev_picture, *next_picture;
|
|
|
|
/* Fill in VAPictureParameterBufferMPEG2 */
|
|
pic_param->horizontal_size = priv->width;
|
|
pic_param->vertical_size = priv->height;
|
|
pic_param->forward_reference_picture = VA_INVALID_ID;
|
|
pic_param->backward_reference_picture = VA_INVALID_ID;
|
|
pic_param->picture_coding_type = pic_hdr->pic_type;
|
|
pic_param->f_code = pack_f_code (pic_ext->f_code);
|
|
|
|
#define COPY_FIELD(a, b, f) \
|
|
pic_param->a.b.f = pic_ext->f
|
|
pic_param->picture_coding_extension.value = 0;
|
|
pic_param->picture_coding_extension.bits.is_first_field =
|
|
GST_VAAPI_PICTURE_IS_FIRST_FIELD (picture);
|
|
COPY_FIELD (picture_coding_extension, bits, intra_dc_precision);
|
|
COPY_FIELD (picture_coding_extension, bits, picture_structure);
|
|
COPY_FIELD (picture_coding_extension, bits, top_field_first);
|
|
COPY_FIELD (picture_coding_extension, bits, frame_pred_frame_dct);
|
|
COPY_FIELD (picture_coding_extension, bits, concealment_motion_vectors);
|
|
COPY_FIELD (picture_coding_extension, bits, q_scale_type);
|
|
COPY_FIELD (picture_coding_extension, bits, intra_vlc_format);
|
|
COPY_FIELD (picture_coding_extension, bits, alternate_scan);
|
|
COPY_FIELD (picture_coding_extension, bits, repeat_first_field);
|
|
COPY_FIELD (picture_coding_extension, bits, progressive_frame);
|
|
|
|
gst_vaapi_dpb_get_neighbours (priv->dpb, picture,
|
|
&prev_picture, &next_picture);
|
|
|
|
switch (pic_hdr->pic_type) {
|
|
case GST_MPEG_VIDEO_PICTURE_TYPE_B:
|
|
if (next_picture)
|
|
pic_param->backward_reference_picture = next_picture->surface_id;
|
|
if (prev_picture)
|
|
pic_param->forward_reference_picture = prev_picture->surface_id;
|
|
else if (!priv->closed_gop)
|
|
GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_SKIPPED);
|
|
break;
|
|
case GST_MPEG_VIDEO_PICTURE_TYPE_P:
|
|
if (prev_picture)
|
|
pic_param->forward_reference_picture = prev_picture->surface_id;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_slice (GstVaapiDecoderMpeg2 * decoder,
|
|
GstVaapiDecoderUnit * unit, const GstMpegVideoPacket * packet)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSliceHdr *slice_hdr;
|
|
GstMpegVideoSequenceHdr *seq_hdr;
|
|
GstMpegVideoSequenceScalableExt *seq_scalable_ext;
|
|
|
|
priv->state &= (GST_MPEG_VIDEO_STATE_GOT_SEQ_HDR |
|
|
GST_MPEG_VIDEO_STATE_GOT_SEQ_EXT |
|
|
GST_MPEG_VIDEO_STATE_GOT_PIC_HDR | GST_MPEG_VIDEO_STATE_GOT_PIC_EXT);
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
if (!gst_vaapi_parser_info_mpeg2_ensure (&priv->slice_hdr)) {
|
|
GST_ERROR ("failed to allocate parser info for slice header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
|
|
slice_hdr = &priv->slice_hdr->data.slice_hdr;
|
|
seq_hdr = &priv->seq_hdr->data.seq_hdr;
|
|
seq_scalable_ext = priv->seq_scalable_ext ?
|
|
&priv->seq_scalable_ext->data.seq_scalable_ext : NULL;
|
|
|
|
if (!gst_mpeg_video_packet_parse_slice_header (packet, slice_hdr,
|
|
seq_hdr, seq_scalable_ext)) {
|
|
GST_ERROR ("failed to parse slice header");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
}
|
|
|
|
gst_vaapi_decoder_unit_set_parsed_info (unit, slice_hdr, NULL);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_slice (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstVaapiPicture *const picture = priv->current_picture;
|
|
GstVaapiSlice *slice;
|
|
VASliceParameterBufferMPEG2 *slice_param;
|
|
GstMpegVideoSliceHdr *const slice_hdr = unit->parsed_info;
|
|
GstBuffer *const buffer =
|
|
GST_VAAPI_DECODER_CODEC_FRAME (decoder)->input_buffer;
|
|
GstMapInfo map_info;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
|
|
if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ)) {
|
|
GST_ERROR ("failed to map buffer");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
|
|
GST_DEBUG ("slice %d (%u bytes)", slice_hdr->mb_row, unit->size);
|
|
|
|
slice = GST_VAAPI_SLICE_NEW (MPEG2, decoder,
|
|
(map_info.data + unit->offset), unit->size);
|
|
gst_buffer_unmap (buffer, &map_info);
|
|
if (!slice) {
|
|
GST_ERROR ("failed to allocate slice");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
gst_vaapi_picture_add_slice (picture, slice);
|
|
|
|
/* Fill in VASliceParameterBufferMPEG2 */
|
|
slice_param = slice->param;
|
|
slice_param->macroblock_offset = slice_hdr->header_size + 32;
|
|
slice_param->slice_horizontal_position = slice_hdr->mb_column;
|
|
slice_param->slice_vertical_position = slice_hdr->mb_row;
|
|
slice_param->quantiser_scale_code = slice_hdr->quantiser_scale_code;
|
|
slice_param->intra_slice_flag = slice_hdr->intra_slice;
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_GOT_SLICE;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline gint
|
|
scan_for_start_code (const guchar * buf, guint buf_size,
|
|
GstMpegVideoPacketTypeCode * type_ptr)
|
|
{
|
|
guint i = 0;
|
|
|
|
while (i <= (buf_size - 4)) {
|
|
if (buf[i + 2] > 1)
|
|
i += 3;
|
|
else if (buf[i + 1])
|
|
i += 2;
|
|
else if (buf[i] || buf[i + 2] != 1)
|
|
i++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (i <= (buf_size - 4)) {
|
|
if (type_ptr)
|
|
*type_ptr = buf[i + 3];
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
parse_unit (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit,
|
|
GstMpegVideoPacket * packet)
|
|
{
|
|
GstMpegVideoPacketTypeCode type;
|
|
GstMpegVideoPacketExtensionCode ext_type;
|
|
GstVaapiDecoderStatus status;
|
|
|
|
type = packet->type;
|
|
switch (type) {
|
|
case GST_MPEG_VIDEO_PACKET_PICTURE:
|
|
status = parse_picture (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE:
|
|
status = parse_sequence (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXTENSION:
|
|
ext_type = packet->data[4] >> 4;
|
|
switch (ext_type) {
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE:
|
|
status = parse_sequence_ext (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_DISPLAY:
|
|
status = parse_sequence_display_ext (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_SCALABLE:
|
|
status = parse_sequence_scalable_ext (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_QUANT_MATRIX:
|
|
status = parse_quant_matrix_ext (decoder, unit, packet);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_PICTURE:
|
|
status = parse_picture_ext (decoder, unit, packet);
|
|
break;
|
|
default:
|
|
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_GOP:
|
|
status = parse_gop (decoder, unit, packet);
|
|
break;
|
|
default:
|
|
if (type >= GST_MPEG_VIDEO_PACKET_SLICE_MIN &&
|
|
type <= GST_MPEG_VIDEO_PACKET_SLICE_MAX) {
|
|
status = parse_slice (decoder, unit, packet);
|
|
break;
|
|
}
|
|
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
decode_unit (GstVaapiDecoderMpeg2 * decoder, GstVaapiDecoderUnit * unit,
|
|
GstMpegVideoPacket * packet)
|
|
{
|
|
GstMpegVideoPacketTypeCode type;
|
|
GstMpegVideoPacketExtensionCode ext_type;
|
|
GstVaapiDecoderStatus status;
|
|
|
|
type = packet->type;
|
|
switch (type) {
|
|
case GST_MPEG_VIDEO_PACKET_PICTURE:
|
|
status = decode_picture (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE:
|
|
status = decode_sequence (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXTENSION:
|
|
ext_type = packet->data[4] >> 4;
|
|
switch (ext_type) {
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE:
|
|
status = decode_sequence_ext (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_DISPLAY:
|
|
status = decode_sequence_display_ext (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_SCALABLE:
|
|
status = decode_sequence_scalable_ext (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_QUANT_MATRIX:
|
|
status = decode_quant_matrix_ext (decoder, unit);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXT_PICTURE:
|
|
status = decode_picture_ext (decoder, unit);
|
|
break;
|
|
default:
|
|
// Ignore unknown start-code extensions
|
|
GST_WARNING ("unsupported packet extension type 0x%02x", ext_type);
|
|
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE_END:
|
|
status = decode_sequence_end (decoder);
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_GOP:
|
|
status = decode_gop (decoder, unit);
|
|
break;
|
|
default:
|
|
if (type >= GST_MPEG_VIDEO_PACKET_SLICE_MIN &&
|
|
type <= GST_MPEG_VIDEO_PACKET_SLICE_MAX) {
|
|
status = decode_slice (decoder, unit);
|
|
break;
|
|
}
|
|
GST_WARNING ("unsupported packet type 0x%02x", type);
|
|
status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
ensure_decoder (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
if (!priv->is_opened) {
|
|
priv->is_opened = gst_vaapi_decoder_mpeg2_open (decoder);
|
|
if (!priv->is_opened)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC;
|
|
}
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_parse (GstVaapiDecoder * base_decoder,
|
|
GstAdapter * adapter, gboolean at_eos, GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
GstVaapiParserState *const ps = GST_VAAPI_PARSER_STATE (base_decoder);
|
|
GstVaapiDecoderStatus status;
|
|
GstMpegVideoPacketTypeCode type, type2 = GST_MPEG_VIDEO_PACKET_NONE;
|
|
const guchar *buf;
|
|
guint buf_size, flags;
|
|
gint ofs, ofs1, ofs2;
|
|
|
|
status = ensure_decoder (decoder);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
|
|
return status;
|
|
|
|
buf_size = gst_adapter_available (adapter);
|
|
if (buf_size < 4)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
|
|
|
|
buf = gst_adapter_map (adapter, buf_size);
|
|
if (!buf)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
|
|
|
|
ofs = scan_for_start_code (buf, buf_size, &type);
|
|
if (ofs < 0)
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
|
|
ofs1 = ofs;
|
|
|
|
ofs2 = ps->input_offset2 - 4;
|
|
if (ofs2 < ofs1 + 4)
|
|
ofs2 = ofs1 + 4;
|
|
|
|
ofs = G_UNLIKELY (buf_size < ofs2 + 4) ? -1 :
|
|
scan_for_start_code (&buf[ofs2], buf_size - ofs2, &type2);
|
|
if (ofs < 0) {
|
|
// Assume the whole packet is present if end-of-stream
|
|
if (!at_eos) {
|
|
ps->input_offset2 = buf_size;
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
|
|
}
|
|
ofs = buf_size - ofs2;
|
|
}
|
|
ofs2 += ofs;
|
|
|
|
unit->size = ofs2 - ofs1;
|
|
gst_adapter_flush (adapter, ofs1);
|
|
ps->input_offset2 = 4;
|
|
|
|
/* Check for start of new picture */
|
|
flags = 0;
|
|
switch (type) {
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE_END:
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END;
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_STREAM_END;
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_USER_DATA:
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SKIP;
|
|
/* fall-through */
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE:
|
|
case GST_MPEG_VIDEO_PACKET_GOP:
|
|
case GST_MPEG_VIDEO_PACKET_PICTURE:
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
|
|
break;
|
|
case GST_MPEG_VIDEO_PACKET_EXTENSION:
|
|
if (G_UNLIKELY (unit->size < 5))
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
|
|
break;
|
|
default:
|
|
if (type >= GST_MPEG_VIDEO_PACKET_SLICE_MIN &&
|
|
type <= GST_MPEG_VIDEO_PACKET_SLICE_MAX) {
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE;
|
|
switch (type2) {
|
|
case GST_MPEG_VIDEO_PACKET_USER_DATA:
|
|
case GST_MPEG_VIDEO_PACKET_SEQUENCE:
|
|
case GST_MPEG_VIDEO_PACKET_GOP:
|
|
case GST_MPEG_VIDEO_PACKET_PICTURE:
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// Ignore system start codes (PES headers)
|
|
else if (type >= 0xb9 && type <= 0xff)
|
|
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SKIP;
|
|
break;
|
|
}
|
|
GST_VAAPI_DECODER_UNIT_FLAG_SET (unit, flags);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_decode (GstVaapiDecoder * base_decoder,
|
|
GstVaapiDecoderUnit * unit)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
GstVaapiDecoderStatus status;
|
|
GstMpegVideoPacket packet;
|
|
GstBuffer *const buffer =
|
|
GST_VAAPI_DECODER_CODEC_FRAME (decoder)->input_buffer;
|
|
GstMapInfo map_info;
|
|
|
|
status = ensure_decoder (decoder);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
|
|
return status;
|
|
|
|
if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ)) {
|
|
GST_ERROR ("failed to map buffer");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
|
|
}
|
|
|
|
packet.data = map_info.data + unit->offset;
|
|
packet.size = unit->size;
|
|
packet.type = packet.data[3];
|
|
packet.offset = 4;
|
|
|
|
status = parse_unit (decoder, unit, &packet);
|
|
gst_buffer_unmap (buffer, &map_info);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
|
|
return status;
|
|
return decode_unit (decoder, unit, &packet);
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_start_frame (GstVaapiDecoder * base_decoder,
|
|
GstVaapiDecoderUnit * base_unit)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
GstMpegVideoSequenceHdr *seq_hdr;
|
|
GstMpegVideoSequenceExt *seq_ext;
|
|
GstMpegVideoSequenceDisplayExt *seq_display_ext;
|
|
GstVaapiPicture *picture;
|
|
GstVaapiDecoderStatus status;
|
|
|
|
if (!is_valid_state (decoder, GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS))
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
priv->state &= ~GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS;
|
|
|
|
seq_hdr = &priv->seq_hdr->data.seq_hdr;
|
|
seq_ext = priv->seq_ext ? &priv->seq_ext->data.seq_ext : NULL;
|
|
seq_display_ext = priv->seq_display_ext ?
|
|
&priv->seq_display_ext->data.seq_display_ext : NULL;
|
|
if (gst_mpeg_video_finalise_mpeg2_sequence_header (seq_hdr, seq_ext,
|
|
seq_display_ext))
|
|
gst_vaapi_decoder_set_pixel_aspect_ratio (base_decoder,
|
|
seq_hdr->par_w, seq_hdr->par_h);
|
|
|
|
status = ensure_context (decoder);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) {
|
|
GST_ERROR ("failed to reset context");
|
|
return status;
|
|
}
|
|
|
|
if (priv->current_picture) {
|
|
/* Re-use current picture where the first field was decoded */
|
|
picture = gst_vaapi_picture_new_field (priv->current_picture);
|
|
if (!picture) {
|
|
GST_ERROR ("failed to allocate field picture");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
} else {
|
|
/* Create new picture */
|
|
picture = GST_VAAPI_PICTURE_NEW (MPEG2, decoder);
|
|
if (!picture) {
|
|
GST_ERROR ("failed to allocate picture");
|
|
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
}
|
|
gst_vaapi_picture_replace (&priv->current_picture, picture);
|
|
gst_vaapi_picture_unref (picture);
|
|
|
|
/* Update cropping rectangle */
|
|
/* XXX: handle picture_display_extension() */
|
|
if (seq_display_ext && priv->pic_display_ext) {
|
|
GstVaapiRectangle *const crop_rect = &priv->crop_rect;
|
|
if (crop_rect->x + crop_rect->width <= priv->width &&
|
|
crop_rect->y + crop_rect->height <= priv->height)
|
|
gst_vaapi_picture_set_crop_rect (picture, crop_rect);
|
|
}
|
|
|
|
status = ensure_quant_matrix (decoder, picture);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) {
|
|
GST_ERROR ("failed to reset quantizer matrix");
|
|
return status;
|
|
}
|
|
|
|
status = init_picture (decoder, picture);
|
|
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
|
|
return status;
|
|
|
|
fill_picture (decoder, picture);
|
|
|
|
priv->state |= GST_MPEG_VIDEO_STATE_VALID_PIC_HEADERS;
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_end_frame (GstVaapiDecoder * base_decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
|
|
return decode_current_picture (decoder);
|
|
}
|
|
|
|
static GstVaapiDecoderStatus
|
|
gst_vaapi_decoder_mpeg2_flush (GstVaapiDecoder * base_decoder)
|
|
{
|
|
GstVaapiDecoderMpeg2 *const decoder =
|
|
GST_VAAPI_DECODER_MPEG2_CAST (base_decoder);
|
|
GstVaapiDecoderMpeg2Private *const priv = &decoder->priv;
|
|
|
|
if (priv->dpb)
|
|
gst_vaapi_dpb_flush (priv->dpb);
|
|
return GST_VAAPI_DECODER_STATUS_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_decoder_mpeg2_finalize (GObject * object)
|
|
{
|
|
GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (object);
|
|
|
|
gst_vaapi_decoder_mpeg2_destroy (base_decoder);
|
|
G_OBJECT_CLASS (gst_vaapi_decoder_mpeg2_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_decoder_mpeg2_class_init (GstVaapiDecoderMpeg2Class * klass)
|
|
{
|
|
GObjectClass *const object_class = G_OBJECT_CLASS (klass);
|
|
GstVaapiDecoderClass *const decoder_class = GST_VAAPI_DECODER_CLASS (klass);
|
|
|
|
object_class->finalize = gst_vaapi_decoder_mpeg2_finalize;
|
|
|
|
decoder_class->reset = gst_vaapi_decoder_mpeg2_reset;
|
|
decoder_class->parse = gst_vaapi_decoder_mpeg2_parse;
|
|
decoder_class->decode = gst_vaapi_decoder_mpeg2_decode;
|
|
decoder_class->start_frame = gst_vaapi_decoder_mpeg2_start_frame;
|
|
decoder_class->end_frame = gst_vaapi_decoder_mpeg2_end_frame;
|
|
decoder_class->flush = gst_vaapi_decoder_mpeg2_flush;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_decoder_mpeg2_init (GstVaapiDecoderMpeg2 * decoder)
|
|
{
|
|
GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (decoder);
|
|
|
|
gst_vaapi_decoder_mpeg2_create (base_decoder);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_decoder_mpeg2_new:
|
|
* @display: a #GstVaapiDisplay
|
|
* @caps: a #GstCaps holding codec information
|
|
*
|
|
* Creates a new #GstVaapiDecoder for MPEG-2 decoding. The @caps can
|
|
* hold extra information like codec-data and pictured coded size.
|
|
*
|
|
* Return value: the newly allocated #GstVaapiDecoder object
|
|
*/
|
|
GstVaapiDecoder *
|
|
gst_vaapi_decoder_mpeg2_new (GstVaapiDisplay * display, GstCaps * caps)
|
|
{
|
|
return g_object_new (GST_TYPE_VAAPI_DECODER_MPEG2, "display", display,
|
|
"caps", caps, NULL);
|
|
}
|