mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-24 10:41:04 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/vaapi/gstvaapidecoder_mpeg2.c

1607 lines
52 KiB
C
Raw Blame History

/*
* 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 <string.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;
};
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);
}
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 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;
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_class_init (GstVaapiDecoderMpeg2Class * klass)
{
GstVaapiMiniObjectClass *const object_class =
GST_VAAPI_MINI_OBJECT_CLASS (klass);
GstVaapiDecoderClass *const decoder_class = GST_VAAPI_DECODER_CLASS (klass);
object_class->size = sizeof (GstVaapiDecoderMpeg2);
object_class->finalize = (GDestroyNotify) gst_vaapi_decoder_finalize;
decoder_class->create = gst_vaapi_decoder_mpeg2_create;
decoder_class->destroy = gst_vaapi_decoder_mpeg2_destroy;
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 inline const GstVaapiDecoderClass *
gst_vaapi_decoder_mpeg2_class (void)
{
static GstVaapiDecoderMpeg2Class g_class;
static gsize g_class_init = FALSE;
if (g_once_init_enter (&g_class_init)) {
gst_vaapi_decoder_mpeg2_class_init (&g_class);
g_once_init_leave (&g_class_init, TRUE);
}
return GST_VAAPI_DECODER_CLASS (&g_class);
}
/**
* 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 gst_vaapi_decoder_new (gst_vaapi_decoder_mpeg2_class (),
display, caps);
}
Reference in a new issue View git blame Copy permalink