gstreamer/gst-libs/gst/vaapi/gstvaapidecoder_mpeg2.c
Gwenole Beauchesne 292b2f51b4 mpeg2: disable video cropping as picture_display_extension() is missing.
Disable video cropping in MPEG-2 codec because it is partially implemented
and actually because nobody implements it that way, and the standard spec
does not specify the display process either anyway.

Most notably, there are two possible use cases for sequence_display_extension()
horizontal_display_size & vertical_display_size: (i) guesstimating the
pixel-aspect-ratio, or (ii) implement some kind of span & scan process
in conjunction with picture_display_extension() information.

https://bugzilla.gnome.org/show_bug.cgi?id=704848
2013-08-26 16:19:01 +02:00

1586 lines
54 KiB
C

/*
* gstvaapidecoder_mpeg2.c - MPEG-2 decoder
*
* Copyright (C) 2011-2013 Intel Corporation
*
* 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 = 0;
pts = tsg->gop_pts + pts_get_duration(tsg, tsg->ovl_tsn * 1024 + 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);
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)
{
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.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 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;
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 (!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;
GST_DEBUG("slice %d (%u bytes)", slice_hdr->mb_row, unit->size);
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;
}
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;
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);
}