mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-26 10:10:32 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/vaapi/gstvaapidecoder_h264.c

3097 lines
102 KiB
C
Raw Normal View History

Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/*
* gstvaapidecoder_h264.c - H.264 decoder
*
* Copyright (C) 2011-2012 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_h264
* @short_description: H.264 decoder
*/
Add header for system-dependent definitions.
2012-01-30 17:12:59 +00:00
#include "sysdeps.h"
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
#include <string.h>
h264: fix presentation timestamps.
2012-01-23 14:20:51 +00:00
#include <gst/base/gstadapter.h>
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
#include <gst/codecparsers/gsth264parser.h>
#include "gstvaapidecoder_h264.h"
#include "gstvaapidecoder_objects.h"
#include "gstvaapidecoder_priv.h"
#include "gstvaapidisplay_priv.h"
#include "gstvaapiobject_priv.h"
#define DEBUG 1
#include "gstvaapidebug.h"
h264: add flag to compile with strict DPB ordering mode. Allow build with strict DPB ordering mode whereby evicted entries are replaced by the next entries, in order instead of optimizing it away with the last entry in the DPB. This is only useful for debugging purpose, against a reference SW decoder for example.
2012-10-16 14:52:04 +00:00
/* Defined to 1 if strict ordering of DPB is needed. Only useful for debug */
#define USE_STRICT_DPB_ORDERING 0
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
typedef struct _GstVaapiFrameStore GstVaapiFrameStore;
typedef struct _GstVaapiFrameStoreClass GstVaapiFrameStoreClass;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
typedef struct _GstVaapiDecoderUnitH264 GstVaapiDecoderUnitH264;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
typedef struct _GstVaapiPictureH264 GstVaapiPictureH264;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
// Used for field_poc[]
#define TOP_FIELD 0
#define BOTTOM_FIELD 1
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
/* ------------------------------------------------------------------------- */
/* --- H.264 Decoder Units --- */
/* ------------------------------------------------------------------------- */
struct _GstVaapiDecoderUnitH264 {
GstVaapiDecoderUnit base;
GstH264NalUnit nalu;
union {
GstH264SPS sps;
GstH264PPS pps;
GstH264SliceHdr slice_hdr;
} data;
};
static GstVaapiDecoderUnitH264 *
gst_vaapi_decoder_unit_h264_new(guint size)
{
GstVaapiDecoderUnitH264 *unit;
static const GstVaapiMiniObjectClass GstVaapiDecoderUnitH264Class = {
sizeof(GstVaapiDecoderUnitH264),
(GDestroyNotify)gst_vaapi_decoder_unit_finalize
};
unit = (GstVaapiDecoderUnitH264 *)
h264: optimize initialization process of decoder units. Decoder units were zero-initialized, including the SPS/PPS/slice headers. The latter don't require zero-initialization since the codecparsers/ lib will do so for key variables already. This is not a great value per se but at least it makes it possible to check whether the default initialization decisions made in the codecparsers/ lib were right or not. This can be reverted if this exposes too many issues.
2012-12-18 13:57:36 +00:00
gst_vaapi_mini_object_new(&GstVaapiDecoderUnitH264Class);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
if (!unit)
return NULL;
h264: optimize initialization process of decoder units. Decoder units were zero-initialized, including the SPS/PPS/slice headers. The latter don't require zero-initialization since the codecparsers/ lib will do so for key variables already. This is not a great value per se but at least it makes it possible to check whether the default initialization decisions made in the codecparsers/ lib were right or not. This can be reverted if this exposes too many issues.
2012-12-18 13:57:36 +00:00
gst_vaapi_decoder_unit_init(&unit->base, size);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
return unit;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* ------------------------------------------------------------------------- */
/* --- H.264 Pictures --- */
/* ------------------------------------------------------------------------- */
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
/*
* Extended picture flags:
*
* @GST_VAAPI_PICTURE_FLAG_IDR: flag that specifies an IDR picture
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
* @GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE: flag that specifies
* "used for short-term reference"
* @GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE: flag that specifies
* "used for long-term reference"
* @GST_VAAPI_PICTURE_FLAGS_REFERENCE: mask covering any kind of
* reference picture (short-term reference or long-term reference)
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
*/
enum {
GST_VAAPI_PICTURE_FLAG_IDR = (GST_VAAPI_PICTURE_FLAG_LAST << 0),
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE = (
GST_VAAPI_PICTURE_FLAG_REFERENCE),
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE = (
GST_VAAPI_PICTURE_FLAG_REFERENCE | (GST_VAAPI_PICTURE_FLAG_LAST << 1)),
GST_VAAPI_PICTURE_FLAGS_REFERENCE = (
GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE |
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE),
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
};
#define GST_VAAPI_PICTURE_IS_IDR(picture) \
(GST_VAAPI_PICTURE_FLAG_IS_SET(picture, GST_VAAPI_PICTURE_FLAG_IDR))
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
#define GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(picture) \
((GST_VAAPI_PICTURE_FLAGS(picture) & \
GST_VAAPI_PICTURE_FLAGS_REFERENCE) == \
GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE)
#define GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(picture) \
((GST_VAAPI_PICTURE_FLAGS(picture) & \
GST_VAAPI_PICTURE_FLAGS_REFERENCE) == \
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
struct _GstVaapiPictureH264 {
GstVaapiPicture base;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstH264PPS *pps;
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
GstH264SliceHdr *last_slice_hdr;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
guint structure;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
gint32 field_poc[2];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gint32 frame_num; // Original frame_num from slice_header()
gint32 frame_num_wrap; // Temporary for ref pic marking: FrameNumWrap
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
gint32 long_term_frame_idx; // Temporary for ref pic marking: LongTermFrameIdx
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gint32 pic_num; // Temporary for ref pic marking: PicNum
gint32 long_term_pic_num; // Temporary for ref pic marking: LongTermPicNum
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
GstVaapiPictureH264 *other_field; // Temporary for ref pic marking: other field in the same frame store
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
guint output_flag : 1;
guint output_needed : 1;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
};
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
GST_VAAPI_CODEC_DEFINE_TYPE(GstVaapiPictureH264, gst_vaapi_picture_h264);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
void
gst_vaapi_picture_h264_destroy(GstVaapiPictureH264 *picture)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
gst_vaapi_picture_destroy(GST_VAAPI_PICTURE(picture));
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
gboolean
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gst_vaapi_picture_h264_create(
GstVaapiPictureH264 *picture,
const GstVaapiCodecObjectConstructorArgs *args
)
{
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
if (!gst_vaapi_picture_create(GST_VAAPI_PICTURE(picture), args))
return FALSE;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
picture->field_poc[0] = G_MAXINT32;
picture->field_poc[1] = G_MAXINT32;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
picture->output_needed = FALSE;
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
return TRUE;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static inline GstVaapiPictureH264 *
gst_vaapi_picture_h264_new(GstVaapiDecoderH264 *decoder)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
return (GstVaapiPictureH264 *)gst_vaapi_codec_object_new(
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
&GstVaapiPictureH264Class,
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_VAAPI_CODEC_BASE(decoder),
NULL, sizeof(VAPictureParameterBufferH264),
Port codec objects to GstVaapiMiniObject.
2012-12-03 10:19:08 +00:00
NULL, 0,
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
0);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
static inline void
gst_vaapi_picture_h264_set_reference(
GstVaapiPictureH264 *picture,
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
guint reference_flags,
gboolean other_field
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
if (!picture)
return;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
GST_VAAPI_PICTURE_FLAG_UNSET(picture, GST_VAAPI_PICTURE_FLAGS_REFERENCE);
GST_VAAPI_PICTURE_FLAG_SET(picture, reference_flags);
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
if (!other_field || !(picture = picture->other_field))
return;
GST_VAAPI_PICTURE_FLAG_UNSET(picture, GST_VAAPI_PICTURE_FLAGS_REFERENCE);
GST_VAAPI_PICTURE_FLAG_SET(picture, reference_flags);
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
static inline GstVaapiPictureH264 *
gst_vaapi_picture_h264_new_field(GstVaapiPictureH264 *picture)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
g_return_val_if_fail(picture, NULL);
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
return (GstVaapiPictureH264 *)gst_vaapi_picture_new_field(&picture->base);
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
/* ------------------------------------------------------------------------- */
/* --- Frame Buffers (DPB) --- */
/* ------------------------------------------------------------------------- */
struct _GstVaapiFrameStore {
/*< private >*/
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
GstVaapiMiniObject parent_instance;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
guint structure;
GstVaapiPictureH264 *buffers[2];
guint num_buffers;
guint output_needed;
};
static void
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
gst_vaapi_frame_store_finalize(gpointer object)
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
{
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
GstVaapiFrameStore * const fs = object;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
guint i;
for (i = 0; i < fs->num_buffers; i++)
gst_vaapi_picture_replace(&fs->buffers[i], NULL);
}
static GstVaapiFrameStore *
gst_vaapi_frame_store_new(GstVaapiPictureH264 *picture)
{
GstVaapiFrameStore *fs;
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
static const GstVaapiMiniObjectClass GstVaapiFrameStoreClass = {
sizeof(GstVaapiFrameStore),
gst_vaapi_frame_store_finalize
};
fs = (GstVaapiFrameStore *)
gst_vaapi_mini_object_new(&GstVaapiFrameStoreClass);
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
if (!fs)
return NULL;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
fs->structure = picture->structure;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
fs->buffers[0] = gst_vaapi_picture_ref(picture);
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
fs->buffers[1] = NULL;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
fs->num_buffers = 1;
fs->output_needed = picture->output_needed;
return fs;
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
static gboolean
gst_vaapi_frame_store_add(GstVaapiFrameStore *fs, GstVaapiPictureH264 *picture)
{
guint field;
g_return_val_if_fail(fs->num_buffers == 1, FALSE);
g_return_val_if_fail(!GST_VAAPI_PICTURE_IS_FRAME(picture), FALSE);
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
g_return_val_if_fail(!GST_VAAPI_PICTURE_IS_FIRST_FIELD(picture), FALSE);
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
gst_vaapi_picture_replace(&fs->buffers[fs->num_buffers++], picture);
if (picture->output_flag) {
picture->output_needed = TRUE;
fs->output_needed++;
}
fs->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
field = picture->structure == GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD ?
TOP_FIELD : BOTTOM_FIELD;
g_return_val_if_fail(fs->buffers[0]->field_poc[field] == G_MAXINT32, FALSE);
fs->buffers[0]->field_poc[field] = picture->field_poc[field];
g_return_val_if_fail(picture->field_poc[!field] == G_MAXINT32, FALSE);
picture->field_poc[!field] = fs->buffers[0]->field_poc[!field];
return TRUE;
}
static gboolean
gst_vaapi_frame_store_split_fields(GstVaapiFrameStore *fs)
{
GstVaapiPictureH264 * const first_field = fs->buffers[0];
GstVaapiPictureH264 *second_field;
g_return_val_if_fail(fs->num_buffers == 1, FALSE);
first_field->base.structure = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
GST_VAAPI_PICTURE_FLAG_SET(first_field, GST_VAAPI_PICTURE_FLAG_INTERLACED);
second_field = gst_vaapi_picture_h264_new_field(first_field);
if (!second_field)
return FALSE;
gst_vaapi_picture_replace(&fs->buffers[fs->num_buffers++], second_field);
gst_vaapi_picture_unref(second_field);
second_field->frame_num = first_field->frame_num;
second_field->field_poc[0] = first_field->field_poc[0];
second_field->field_poc[1] = first_field->field_poc[1];
second_field->output_flag = first_field->output_flag;
if (second_field->output_flag) {
second_field->output_needed = TRUE;
fs->output_needed++;
}
return TRUE;
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
static inline gboolean
gst_vaapi_frame_store_has_frame(GstVaapiFrameStore *fs)
{
return fs->structure == GST_VAAPI_PICTURE_STRUCTURE_FRAME;
}
static inline gboolean
gst_vaapi_frame_store_has_reference(GstVaapiFrameStore *fs)
{
guint i;
for (i = 0; i < fs->num_buffers; i++) {
if (GST_VAAPI_PICTURE_IS_REFERENCE(fs->buffers[i]))
return TRUE;
}
return FALSE;
}
#define gst_vaapi_frame_store_ref(fs) \
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
gst_vaapi_mini_object_ref(GST_VAAPI_MINI_OBJECT(fs))
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
#define gst_vaapi_frame_store_unref(fs) \
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
gst_vaapi_mini_object_unref(GST_VAAPI_MINI_OBJECT(fs))
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
Port GstVaapiFrameStore to GstVaapiMiniObject.
2012-12-03 13:09:01 +00:00
#define gst_vaapi_frame_store_replace(old_fs_p, new_fs) \
gst_vaapi_mini_object_replace((GstVaapiMiniObject **)(old_fs_p), \
(GstVaapiMiniObject *)(new_fs))
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* ------------------------------------------------------------------------- */
/* --- H.264 Decoder --- */
/* ------------------------------------------------------------------------- */
G_DEFINE_TYPE(GstVaapiDecoderH264,
gst_vaapi_decoder_h264,
libs: fix build in strict ISO C mode.
2012-09-07 14:14:11 +00:00
GST_VAAPI_TYPE_DECODER)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
#define GST_VAAPI_DECODER_H264_CAST(decoder) \
((GstVaapiDecoderH264 *)(decoder))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
#define GST_VAAPI_DECODER_H264_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE((obj), \
GST_VAAPI_TYPE_DECODER_H264, \
GstVaapiDecoderH264Private))
struct _GstVaapiDecoderH264Private {
GstH264NalParser *parser;
GstVaapiPictureH264 *current_picture;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
GstVaapiDecoderUnitH264 *prev_slice_unit;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
GstVaapiFrameStore *prev_frame;
GstVaapiFrameStore *dpb[16];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
guint dpb_count;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
guint dpb_size;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstVaapiProfile profile;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstVaapiEntrypoint entrypoint;
GstVaapiChromaType chroma_type;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
GstVaapiPictureH264 *short_ref[32];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
guint short_ref_count;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
GstVaapiPictureH264 *long_ref[32];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
guint long_ref_count;
GstVaapiPictureH264 *RefPicList0[32];
guint RefPicList0_count;
GstVaapiPictureH264 *RefPicList1[32];
guint RefPicList1_count;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
guint nal_length_size;
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
guint mb_width;
guint mb_height;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gint32 field_poc[2]; // 0:TopFieldOrderCnt / 1:BottomFieldOrderCnt
gint32 poc_msb; // PicOrderCntMsb
gint32 poc_lsb; // pic_order_cnt_lsb (from slice_header())
gint32 prev_poc_msb; // prevPicOrderCntMsb
gint32 prev_poc_lsb; // prevPicOrderCntLsb
gint32 frame_num_offset; // FrameNumOffset
gint32 frame_num; // frame_num (from slice_header())
gint32 prev_frame_num; // prevFrameNum
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
gboolean prev_pic_has_mmco5; // prevMmco5Pic
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
gboolean prev_pic_structure; // previous picture structure
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
guint is_constructed : 1;
guint is_opened : 1;
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
guint is_avcC : 1;
h264: start decoding slices after first SPS/PPS activation. Only start decoding slices when at least one SPS and PPS got activated. This fixes cases when a source represents a substream of another stream and no SPS and PPS was inserted before the first slice of the generated substream.
2012-11-14 17:40:47 +00:00
guint got_sps : 1;
guint got_pps : 1;
h264: create VA context earlier when SPS is parsed.
2012-02-08 17:07:14 +00:00
guint has_context : 1;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
guint progressive_sequence : 1;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
};
static gboolean
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
exec_ref_pic_marking(GstVaapiDecoderH264 *decoder, GstVaapiPictureH264 *picture);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
decoder: cope with new GstVaapiContextInfo based API. Update decoders to report the maximum number of reference frames to use.
2012-09-10 16:26:51 +00:00
/* Get number of reference frames to use */
static guint
get_max_dec_frame_buffering(GstH264SPS *sps)
{
guint max_dec_frame_buffering, MaxDpbMbs, PicSizeMbs;
/* Table A-1 - Level limits */
switch (sps->level_idc) {
case 10: MaxDpbMbs = 396; break;
case 11: MaxDpbMbs = 900; break;
case 12: MaxDpbMbs = 2376; break;
case 13: MaxDpbMbs = 2376; break;
case 20: MaxDpbMbs = 2376; break;
case 21: MaxDpbMbs = 4752; break;
case 22: MaxDpbMbs = 8100; break;
case 30: MaxDpbMbs = 8100; break;
case 31: MaxDpbMbs = 18000; break;
case 32: MaxDpbMbs = 20480; break;
case 40: MaxDpbMbs = 32768; break;
case 41: MaxDpbMbs = 32768; break;
case 42: MaxDpbMbs = 34816; break;
case 50: MaxDpbMbs = 110400; break;
case 51: MaxDpbMbs = 184320; break;
default:
g_assert(0 && "unhandled level");
break;
}
PicSizeMbs = ((sps->pic_width_in_mbs_minus1 + 1) *
(sps->pic_height_in_map_units_minus1 + 1) *
(sps->frame_mbs_only_flag ? 1 : 2));
max_dec_frame_buffering = MaxDpbMbs / PicSizeMbs;
/* VUI parameters */
if (sps->vui_parameters_present_flag) {
GstH264VUIParams * const vui_params = &sps->vui_parameters;
if (vui_params->bitstream_restriction_flag)
max_dec_frame_buffering = vui_params->max_dec_frame_buffering;
else {
switch (sps->profile_idc) {
case 44: // CAVLC 4:4:4 Intra profile
case 86: // Scalable High profile
case 100: // High profile
case 110: // High 10 profile
case 122: // High 4:2:2 profile
case 244: // High 4:4:4 Predictive profile
if (sps->constraint_set3_flag)
max_dec_frame_buffering = 0;
break;
}
}
}
if (max_dec_frame_buffering > 16)
max_dec_frame_buffering = 16;
else if (max_dec_frame_buffering < sps->num_ref_frames)
max_dec_frame_buffering = sps->num_ref_frames;
return MAX(1, max_dec_frame_buffering);
}
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
static void
array_remove_index_fast(void *array, guint *array_length_ptr, guint index)
{
gpointer * const entries = array;
guint num_entries = *array_length_ptr;
g_return_if_fail(index < num_entries);
if (index != --num_entries)
entries[index] = entries[num_entries];
entries[num_entries] = NULL;
*array_length_ptr = num_entries;
}
#if 1
static inline void
array_remove_index(void *array, guint *array_length_ptr, guint index)
{
array_remove_index_fast(array, array_length_ptr, index);
}
#else
static void
array_remove_index(void *array, guint *array_length_ptr, guint index)
{
gpointer * const entries = array;
const guint num_entries = *array_length_ptr - 1;
guint i;
g_return_if_fail(index <= num_entries);
for (i = index; i < num_entries; i++)
entries[i] = entries[i + 1];
entries[num_entries] = NULL;
*array_length_ptr = num_entries;
}
#endif
#define ARRAY_REMOVE_INDEX(array, index) \
array_remove_index(array, &array##_count, index)
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
static void
dpb_remove_index(GstVaapiDecoderH264 *decoder, guint index)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
guint i, num_frames = --priv->dpb_count;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
h264: add flag to compile with strict DPB ordering mode. Allow build with strict DPB ordering mode whereby evicted entries are replaced by the next entries, in order instead of optimizing it away with the last entry in the DPB. This is only useful for debugging purpose, against a reference SW decoder for example.
2012-10-16 14:52:04 +00:00
if (USE_STRICT_DPB_ORDERING) {
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
for (i = index; i < num_frames; i++)
gst_vaapi_frame_store_replace(&priv->dpb[i], priv->dpb[i + 1]);
h264: add flag to compile with strict DPB ordering mode. Allow build with strict DPB ordering mode whereby evicted entries are replaced by the next entries, in order instead of optimizing it away with the last entry in the DPB. This is only useful for debugging purpose, against a reference SW decoder for example.
2012-10-16 14:52:04 +00:00
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
else if (index != num_frames)
gst_vaapi_frame_store_replace(&priv->dpb[index], priv->dpb[num_frames]);
gst_vaapi_frame_store_replace(&priv->dpb[num_frames], NULL);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
static gboolean
dpb_output(
GstVaapiDecoderH264 *decoder,
GstVaapiFrameStore *fs,
GstVaapiPictureH264 *picture
)
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
{
picture->output_needed = FALSE;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (fs) {
if (--fs->output_needed > 0)
return TRUE;
picture = fs->buffers[0];
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
/* XXX: update cropping rectangle */
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
return gst_vaapi_picture_output(GST_VAAPI_PICTURE_CAST(picture));
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
static inline void
dpb_evict(GstVaapiDecoderH264 *decoder, GstVaapiPictureH264 *picture, guint i)
{
GstVaapiFrameStore * const fs = decoder->priv->dpb[i];
if (!fs->output_needed && !gst_vaapi_frame_store_has_reference(fs))
dpb_remove_index(decoder, i);
}
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
static gboolean
dpb_bump(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
GstVaapiPictureH264 *found_picture = NULL;
guint i, j, found_index;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
gboolean success;
for (i = 0; i < priv->dpb_count; i++) {
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
GstVaapiFrameStore * const fs = priv->dpb[i];
if (!fs->output_needed)
continue;
for (j = 0; j < fs->num_buffers; j++) {
GstVaapiPictureH264 * const picture = fs->buffers[j];
if (!picture->output_needed)
continue;
if (!found_picture || found_picture->base.poc > picture->base.poc)
found_picture = picture, found_index = i;
}
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
if (!found_picture)
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
return FALSE;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
success = dpb_output(decoder, priv->dpb[found_index], found_picture);
dpb_evict(decoder, found_picture, found_index);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
return success;
}
static void
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
dpb_clear(GstVaapiDecoderH264 *decoder)
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
guint i;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
for (i = 0; i < priv->dpb_count; i++)
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
gst_vaapi_frame_store_replace(&priv->dpb[i], NULL);
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
priv->dpb_count = 0;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
gst_vaapi_frame_store_replace(&priv->prev_frame, NULL);
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
}
static void
dpb_flush(GstVaapiDecoderH264 *decoder)
{
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
while (dpb_bump(decoder))
;
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
dpb_clear(decoder);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
static gboolean
dpb_add(GstVaapiDecoderH264 *decoder, GstVaapiPictureH264 *picture)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
GstVaapiFrameStore *fs;
guint i, j;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
// Remove all unused pictures
h264: minor clean-ups. Move DPB flush up if the current picture to decode is an IDR. Besides, don't bother to check for IDR pictures in dpb_add() function since an explicit DPB flush was already performed in this case.
2012-10-31 15:37:14 +00:00
if (!GST_VAAPI_PICTURE_IS_IDR(picture)) {
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
i = 0;
while (i < priv->dpb_count) {
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
GstVaapiFrameStore * const fs = priv->dpb[i];
if (!fs->output_needed && !gst_vaapi_frame_store_has_reference(fs))
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
dpb_remove_index(decoder, i);
else
i++;
}
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
// Check if picture is the second field and the first field is still in DPB
fs = priv->prev_frame;
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
if (fs && !gst_vaapi_frame_store_has_frame(fs))
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
return gst_vaapi_frame_store_add(fs, picture);
// Create new frame store, and split fields if necessary
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
fs = gst_vaapi_frame_store_new(picture);
if (!fs)
return FALSE;
gst_vaapi_frame_store_replace(&priv->prev_frame, fs);
gst_vaapi_frame_store_unref(fs);
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (!priv->progressive_sequence && gst_vaapi_frame_store_has_frame(fs)) {
if (!gst_vaapi_frame_store_split_fields(fs))
return FALSE;
}
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
// C.4.5.1 - Storage and marking of a reference decoded picture into the DPB
if (GST_VAAPI_PICTURE_IS_REFERENCE(picture)) {
while (priv->dpb_count == priv->dpb_size) {
if (!dpb_bump(decoder))
return FALSE;
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
gst_vaapi_frame_store_replace(&priv->dpb[priv->dpb_count++], fs);
if (picture->output_flag) {
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
picture->output_needed = TRUE;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
fs->output_needed++;
}
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
// C.4.5.2 - Storage and marking of a non-reference decoded picture into the DPB
else {
if (!picture->output_flag)
return TRUE;
while (priv->dpb_count == priv->dpb_size) {
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
gboolean found_picture = FALSE;
for (i = 0; !found_picture && i < priv->dpb_count; i++) {
GstVaapiFrameStore * const fs = priv->dpb[i];
if (!fs->output_needed)
continue;
for (j = 0; !found_picture && j < fs->num_buffers; j++)
found_picture = fs->buffers[j]->output_needed &&
fs->buffers[j]->base.poc < picture->base.poc;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
if (!found_picture)
return dpb_output(decoder, NULL, picture);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
if (!dpb_bump(decoder))
return FALSE;
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
gst_vaapi_frame_store_replace(&priv->dpb[priv->dpb_count++], fs);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
picture->output_needed = TRUE;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
fs->output_needed++;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
}
return TRUE;
}
decoder: cope with new GstVaapiContextInfo based API. Update decoders to report the maximum number of reference frames to use.
2012-09-10 16:26:51 +00:00
static inline void
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
dpb_reset(GstVaapiDecoderH264 *decoder, GstH264SPS *sps)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
decoder: cope with new GstVaapiContextInfo based API. Update decoders to report the maximum number of reference frames to use.
2012-09-10 16:26:51 +00:00
priv->dpb_size = get_max_dec_frame_buffering(sps);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
GST_DEBUG("DPB size %u", priv->dpb_size);
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
get_status(GstH264ParserResult result)
{
GstVaapiDecoderStatus status;
switch (result) {
case GST_H264_PARSER_OK:
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
break;
case GST_H264_PARSER_NO_NAL_END:
status = GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
break;
case GST_H264_PARSER_ERROR:
status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
break;
default:
status = GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
break;
}
return status;
}
static void
gst_vaapi_decoder_h264_close(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
gst_vaapi_picture_replace(&priv->current_picture, NULL);
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
gst_vaapi_decoder_unit_replace(&priv->prev_slice_unit, NULL);
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
dpb_clear(decoder);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (priv->parser) {
gst_h264_nal_parser_free(priv->parser);
priv->parser = NULL;
}
}
static gboolean
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
gst_vaapi_decoder_h264_open(GstVaapiDecoderH264 *decoder)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
gst_vaapi_decoder_h264_close(decoder);
priv->parser = gst_h264_nal_parser_new();
if (!priv->parser)
return FALSE;
return TRUE;
}
static void
gst_vaapi_decoder_h264_destroy(GstVaapiDecoderH264 *decoder)
{
gst_vaapi_decoder_h264_close(decoder);
}
static gboolean
gst_vaapi_decoder_h264_create(GstVaapiDecoderH264 *decoder)
{
if (!GST_VAAPI_DECODER_CODEC(decoder))
return FALSE;
return TRUE;
}
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
static guint
h264_get_profile(GstH264SPS *sps)
{
guint profile = 0;
switch (sps->profile_idc) {
case 66:
profile = GST_VAAPI_PROFILE_H264_BASELINE;
break;
case 77:
profile = GST_VAAPI_PROFILE_H264_MAIN;
break;
case 100:
profile = GST_VAAPI_PROFILE_H264_HIGH;
break;
}
return profile;
}
static guint
h264_get_chroma_type(GstH264SPS *sps)
{
guint chroma_type = 0;
switch (sps->chroma_format_idc) {
case 1:
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420;
break;
case 2:
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV422;
break;
case 3:
if (!sps->separate_colour_plane_flag)
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV444;
break;
}
return chroma_type;
}
static GstVaapiProfile
get_profile(GstVaapiDecoderH264 *decoder, GstH264SPS *sps)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiDisplay * const display = GST_VAAPI_DECODER_DISPLAY(decoder);
GstVaapiProfile profile, profiles[2];
guint i, n_profiles = 0;
profile = h264_get_profile(sps);
if (!profile)
return GST_VAAPI_PROFILE_UNKNOWN;
profiles[n_profiles++] = profile;
switch (profile) {
case GST_VAAPI_PROFILE_H264_MAIN:
profiles[n_profiles++] = GST_VAAPI_PROFILE_H264_HIGH;
break;
default:
break;
}
/* If the preferred profile (profiles[0]) matches one that we already
found, then just return it now instead of searching for it again */
if (profiles[0] == priv->profile)
return priv->profile;
for (i = 0; i < n_profiles; i++) {
if (gst_vaapi_display_has_decoder(display, profiles[i], priv->entrypoint))
return profiles[i];
}
return GST_VAAPI_PROFILE_UNKNOWN;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
ensure_context(GstVaapiDecoderH264 *decoder, GstH264SPS *sps)
{
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstVaapiDecoder * const base_decoder = GST_VAAPI_DECODER_CAST(decoder);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstVaapiContextInfo info;
GstVaapiProfile profile;
GstVaapiChromaType chroma_type;
gboolean reset_context = FALSE;
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
guint mb_width, mb_height;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
profile = get_profile(decoder, sps);
if (!profile) {
GST_ERROR("unsupported profile_idc %u", sps->profile_idc);
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
}
if (priv->profile != profile) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("profile changed");
reset_context = TRUE;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
priv->profile = profile;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
chroma_type = h264_get_chroma_type(sps);
if (!chroma_type || chroma_type != GST_VAAPI_CHROMA_TYPE_YUV420) {
GST_ERROR("unsupported chroma_format_idc %u", sps->chroma_format_idc);
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CHROMA_FORMAT;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
if (priv->chroma_type != chroma_type) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("chroma format changed");
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
reset_context = TRUE;
priv->chroma_type = chroma_type;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
mb_width = sps->pic_width_in_mbs_minus1 + 1;
mb_height = (sps->pic_height_in_map_units_minus1 + 1) <<
!sps->frame_mbs_only_flag;
if (priv->mb_width != mb_width || priv->mb_height != mb_height) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("size changed");
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
reset_context = TRUE;
priv->mb_width = mb_width;
priv->mb_height = mb_height;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
priv->progressive_sequence = sps->frame_mbs_only_flag;
#if 0
/* XXX: we only output complete frames for now */
gst_vaapi_decoder_set_interlaced(base_decoder, !priv->progressive_sequence);
#endif
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
gst_vaapi_decoder_set_pixel_aspect_ratio(
base_decoder,
sps->vui_parameters.par_n,
sps->vui_parameters.par_d
);
decoder: cope with new GstVaapiContextInfo based API. Update decoders to report the maximum number of reference frames to use.
2012-09-10 16:26:51 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
if (!reset_context && priv->has_context)
return GST_VAAPI_DECODER_STATUS_SUCCESS;
decoder: cope with new GstVaapiContextInfo based API. Update decoders to report the maximum number of reference frames to use.
2012-09-10 16:26:51 +00:00
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
/* XXX: fix surface size when cropping is implemented */
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
info.profile = priv->profile;
info.entrypoint = priv->entrypoint;
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
info.width = sps->width;
info.height = sps->height;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
info.ref_frames = get_max_dec_frame_buffering(sps);
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
if (!gst_vaapi_decoder_ensure_context(GST_VAAPI_DECODER(decoder), &info))
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
priv->has_context = TRUE;
/* Reset DPB */
dpb_reset(decoder, sps);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
h264: fix scaling list generation. ... aka fix regression from efaab79. In particular, ScalingList8x8[] array was partially copied to the VAIQMatrixBufferH264. While we are at it, also improve bounds checking and avoid copying 8x8 scaling lists if transform_8x8_mode_flag is set to 0.
2012-10-26 11:17:43 +00:00
static void
fill_iq_matrix_4x4(VAIQMatrixBufferH264 *iq_matrix, const GstH264PPS *pps)
{
const guint8 (* const ScalingList4x4)[6][16] = &pps->scaling_lists_4x4;
guint i, j;
/* There are always 6 4x4 scaling lists */
g_assert(G_N_ELEMENTS(iq_matrix->ScalingList4x4) == 6);
g_assert(G_N_ELEMENTS(iq_matrix->ScalingList4x4[0]) == 16);
if (sizeof(iq_matrix->ScalingList4x4[0][0]) == 1)
memcpy(iq_matrix->ScalingList4x4, *ScalingList4x4,
sizeof(iq_matrix->ScalingList4x4));
else {
for (i = 0; i < G_N_ELEMENTS(iq_matrix->ScalingList4x4); i++) {
for (j = 0; j < G_N_ELEMENTS(iq_matrix->ScalingList4x4[i]); j++)
iq_matrix->ScalingList4x4[i][j] = (*ScalingList4x4)[i][j];
}
}
}
static void
fill_iq_matrix_8x8(VAIQMatrixBufferH264 *iq_matrix, const GstH264PPS *pps)
{
const guint8 (* const ScalingList8x8)[6][64] = &pps->scaling_lists_8x8;
const GstH264SPS * const sps = pps->sequence;
guint i, j, n;
/* If chroma_format_idc != 3, there are up to 2 8x8 scaling lists */
if (!pps->transform_8x8_mode_flag)
return;
g_assert(G_N_ELEMENTS(iq_matrix->ScalingList8x8) >= 2);
g_assert(G_N_ELEMENTS(iq_matrix->ScalingList8x8[0]) == 64);
if (sizeof(iq_matrix->ScalingList8x8[0][0]) == 1)
memcpy(iq_matrix->ScalingList8x8, *ScalingList8x8,
sizeof(iq_matrix->ScalingList8x8));
else {
n = (sps->chroma_format_idc != 3) ? 2 : 6;
for (i = 0; i < n; i++) {
for (j = 0; j < G_N_ELEMENTS(iq_matrix->ScalingList8x8[i]); j++)
iq_matrix->ScalingList8x8[i][j] = (*ScalingList8x8)[i][j];
}
}
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
ensure_quant_matrix(GstVaapiDecoderH264 *decoder, GstVaapiPictureH264 *picture)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
GstVaapiPicture * const base_picture = &picture->base;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstH264PPS * const pps = picture->pps;
GstH264SPS * const sps = pps->sequence;
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
VAIQMatrixBufferH264 *iq_matrix;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
base_picture->iq_matrix = GST_VAAPI_IQ_MATRIX_NEW(H264, decoder);
if (!base_picture->iq_matrix) {
GST_ERROR("failed to allocate IQ matrix");
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
}
iq_matrix = base_picture->iq_matrix->param;
/* XXX: we can only support 4:2:0 or 4:2:2 since ScalingLists8x8[]
is not large enough to hold lists for 4:4:4 */
if (sps->chroma_format_idc == 3)
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CHROMA_FORMAT;
h264: fix scaling list generation. ... aka fix regression from efaab79. In particular, ScalingList8x8[] array was partially copied to the VAIQMatrixBufferH264. While we are at it, also improve bounds checking and avoid copying 8x8 scaling lists if transform_8x8_mode_flag is set to 0.
2012-10-26 11:17:43 +00:00
fill_iq_matrix_4x4(iq_matrix, pps);
fill_iq_matrix_8x8(iq_matrix, pps);
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
static GstVaapiDecoderStatus
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
decode_current_picture(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPictureH264 * const picture = priv->current_picture;
if (!picture)
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
if (!exec_ref_pic_marking(decoder, picture))
goto error;
if (!dpb_add(decoder, picture))
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
goto error;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (!gst_vaapi_picture_decode(GST_VAAPI_PICTURE_CAST(picture)))
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
goto error;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (priv->prev_frame && gst_vaapi_frame_store_has_frame(priv->prev_frame))
gst_vaapi_picture_replace(&priv->current_picture, NULL);
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
error:
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
/* XXX: fix for cases where first field failed to be decoded */
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
gst_vaapi_picture_replace(&priv->current_picture, NULL);
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static GstVaapiDecoderStatus
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
parse_sps(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GstH264SPS * const sps = &unit->data.sps;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstH264ParserResult result;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_DEBUG("parse SPS");
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
result = gst_h264_parser_parse_sps(priv->parser, &unit->nalu, sps, TRUE);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (result != GST_H264_PARSER_OK)
return get_status(result);
h264: fix incorrect integration of previous commit (4d31e1e). git am got confused somehow, though the end result doesn't change at all since we require both SPS and PPS to be parsed prior to decoding the first slice.
2012-11-14 18:22:13 +00:00
priv->got_sps = TRUE;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static GstVaapiDecoderStatus
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
parse_pps(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GstH264PPS * const pps = &unit->data.pps;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstH264ParserResult result;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_DEBUG("parse PPS");
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
result = gst_h264_parser_parse_pps(priv->parser, &unit->nalu, pps);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (result != GST_H264_PARSER_OK)
return get_status(result);
h264: fix incorrect integration of previous commit (4d31e1e). git am got confused somehow, though the end result doesn't change at all since we require both SPS and PPS to be parsed prior to decoding the first slice.
2012-11-14 18:22:13 +00:00
priv->got_pps = TRUE;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
static GstVaapiDecoderStatus
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
parse_sei(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264SEIMessage sei;
GstH264ParserResult result;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_DEBUG("parse SEI");
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
memset(&sei, 0, sizeof(sei));
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
result = gst_h264_parser_parse_sei(priv->parser, &unit->nalu, &sei);
h264: skip all Access Unit (AU) NALs. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-02-21 07:11:20 +00:00
if (result != GST_H264_PARSER_OK) {
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_WARNING("failed to parse SEI, payload type:%d", sei.payloadType);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return get_status(result);
h264: skip all Access Unit (AU) NALs. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-02-21 07:11:20 +00:00
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
static GstVaapiDecoderStatus
parse_slice(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
GstH264ParserResult result;
GST_DEBUG("parse slice");
result = gst_h264_parser_parse_slice_hdr(priv->parser, &unit->nalu,
slice_hdr, TRUE, TRUE);
if (result != GST_H264_PARSER_OK)
return get_status(result);
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
decode_sequence_end(GstVaapiDecoderH264 *decoder)
{
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstVaapiDecoderStatus status;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("decode sequence-end");
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
status = decode_current_picture(decoder);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
h264: flush DPB when the end of the sequence is reached.
2012-01-27 15:08:03 +00:00
dpb_flush(decoder);
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
/* 8.2.1.1 - Decoding process for picture order count type 0 */
static void
init_picture_poc_0(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
const gint32 MaxPicOrderCntLsb = 1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
gint32 temp_poc;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("decode picture order count type 0");
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
if (GST_VAAPI_PICTURE_IS_IDR(picture)) {
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->prev_poc_msb = 0;
priv->prev_poc_lsb = 0;
}
else if (priv->prev_pic_has_mmco5) {
priv->prev_poc_msb = 0;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
priv->prev_poc_lsb =
(priv->prev_pic_structure == GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD ?
0 : priv->field_poc[TOP_FIELD]);
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
}
else {
priv->prev_poc_msb = priv->poc_msb;
priv->prev_poc_lsb = priv->poc_lsb;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
// (8-3)
priv->poc_lsb = slice_hdr->pic_order_cnt_lsb;
if (priv->poc_lsb < priv->prev_poc_lsb &&
(priv->prev_poc_lsb - priv->poc_lsb) >= (MaxPicOrderCntLsb / 2))
priv->poc_msb = priv->prev_poc_msb + MaxPicOrderCntLsb;
else if (priv->poc_lsb > priv->prev_poc_lsb &&
(priv->poc_lsb - priv->prev_poc_lsb) > (MaxPicOrderCntLsb / 2))
priv->poc_msb = priv->prev_poc_msb - MaxPicOrderCntLsb;
else
priv->poc_msb = priv->prev_poc_msb;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
temp_poc = priv->poc_msb + priv->poc_lsb;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
switch (picture->structure) {
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
case GST_VAAPI_PICTURE_STRUCTURE_FRAME:
// (8-4, 8-5)
priv->field_poc[TOP_FIELD] = temp_poc;
priv->field_poc[BOTTOM_FIELD] = temp_poc +
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
slice_hdr->delta_pic_order_cnt_bottom;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
break;
case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD:
// (8-4)
priv->field_poc[TOP_FIELD] = temp_poc;
break;
case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD:
// (8-5)
priv->field_poc[BOTTOM_FIELD] = temp_poc;
break;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
/* 8.2.1.2 - Decoding process for picture order count type 1 */
static void
init_picture_poc_1(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
const gint32 MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
gint32 prev_frame_num_offset, abs_frame_num, expected_poc;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
guint i;
GST_DEBUG("decode picture order count type 1");
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
if (priv->prev_pic_has_mmco5)
prev_frame_num_offset = 0;
else
prev_frame_num_offset = priv->frame_num_offset;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
// (8-6)
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
if (GST_VAAPI_PICTURE_IS_IDR(picture))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->frame_num_offset = 0;
else if (priv->prev_frame_num > priv->frame_num)
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->frame_num_offset = prev_frame_num_offset + MaxFrameNum;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
else
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->frame_num_offset = prev_frame_num_offset;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
// (8-7)
if (sps->num_ref_frames_in_pic_order_cnt_cycle != 0)
abs_frame_num = priv->frame_num_offset + priv->frame_num;
else
abs_frame_num = 0;
if (!GST_VAAPI_PICTURE_IS_REFERENCE(picture) && abs_frame_num > 0)
abs_frame_num = abs_frame_num - 1;
if (abs_frame_num > 0) {
gint32 expected_delta_per_poc_cycle;
gint32 poc_cycle_cnt, frame_num_in_poc_cycle;
expected_delta_per_poc_cycle = 0;
for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
// (8-8)
poc_cycle_cnt = (abs_frame_num - 1) /
sps->num_ref_frames_in_pic_order_cnt_cycle;
frame_num_in_poc_cycle = (abs_frame_num - 1) %
sps->num_ref_frames_in_pic_order_cnt_cycle;
// (8-9)
expected_poc = poc_cycle_cnt * expected_delta_per_poc_cycle;
for (i = 0; i <= frame_num_in_poc_cycle; i++)
expected_poc += sps->offset_for_ref_frame[i];
}
else
expected_poc = 0;
if (!GST_VAAPI_PICTURE_IS_REFERENCE(picture))
expected_poc += sps->offset_for_non_ref_pic;
// (8-10)
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
switch (picture->structure) {
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
case GST_VAAPI_PICTURE_STRUCTURE_FRAME:
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->field_poc[TOP_FIELD] = expected_poc +
slice_hdr->delta_pic_order_cnt[0];
priv->field_poc[BOTTOM_FIELD] = priv->field_poc[TOP_FIELD] +
sps->offset_for_top_to_bottom_field +
slice_hdr->delta_pic_order_cnt[1];
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
break;
case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD:
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->field_poc[TOP_FIELD] = expected_poc +
slice_hdr->delta_pic_order_cnt[0];
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
break;
case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD:
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->field_poc[BOTTOM_FIELD] = expected_poc +
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
sps->offset_for_top_to_bottom_field +
slice_hdr->delta_pic_order_cnt[0];
break;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
/* 8.2.1.3 - Decoding process for picture order count type 2 */
static void
init_picture_poc_2(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
const gint32 MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
gint32 prev_frame_num_offset, temp_poc;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("decode picture order count type 2");
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
if (priv->prev_pic_has_mmco5)
prev_frame_num_offset = 0;
else
prev_frame_num_offset = priv->frame_num_offset;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
// (8-11)
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
if (GST_VAAPI_PICTURE_IS_IDR(picture))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->frame_num_offset = 0;
else if (priv->prev_frame_num > priv->frame_num)
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->frame_num_offset = prev_frame_num_offset + MaxFrameNum;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
else
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->frame_num_offset = prev_frame_num_offset;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
// (8-12)
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
if (GST_VAAPI_PICTURE_IS_IDR(picture))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
temp_poc = 0;
else if (!GST_VAAPI_PICTURE_IS_REFERENCE(picture))
temp_poc = 2 * (priv->frame_num_offset + priv->frame_num) - 1;
else
temp_poc = 2 * (priv->frame_num_offset + priv->frame_num);
// (8-13)
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->field_poc[TOP_FIELD] = temp_poc;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->field_poc[BOTTOM_FIELD] = temp_poc;
}
/* 8.2.1 - Decoding process for picture order count */
static void
init_picture_poc(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
switch (sps->pic_order_cnt_type) {
case 0:
init_picture_poc_0(decoder, picture, slice_hdr);
break;
case 1:
init_picture_poc_1(decoder, picture, slice_hdr);
break;
case 2:
init_picture_poc_2(decoder, picture, slice_hdr);
break;
}
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD)
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
picture->field_poc[TOP_FIELD] = priv->field_poc[TOP_FIELD];
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD)
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
picture->field_poc[BOTTOM_FIELD] = priv->field_poc[BOTTOM_FIELD];
picture->base.poc = MIN(picture->field_poc[0], picture->field_poc[1]);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static int
compare_picture_pic_num_dec(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
return picB->pic_num - picA->pic_num;
}
static int
compare_picture_long_term_pic_num_inc(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
return picA->long_term_pic_num - picB->long_term_pic_num;
}
static int
compare_picture_poc_dec(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
return picB->base.poc - picA->base.poc;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static int
compare_picture_poc_inc(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
return picA->base.poc - picB->base.poc;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static int
compare_picture_frame_num_wrap_dec(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
return picB->frame_num_wrap - picA->frame_num_wrap;
}
static int
compare_picture_long_term_frame_idx_inc(const void *a, const void *b)
{
const GstVaapiPictureH264 * const picA = *(GstVaapiPictureH264 **)a;
const GstVaapiPictureH264 * const picB = *(GstVaapiPictureH264 **)b;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
return picA->long_term_frame_idx - picB->long_term_frame_idx;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
/* 8.2.4.1 - Decoding process for picture numbers */
static void
init_picture_refs_pic_num(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
const gint32 MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
guint i;
GST_DEBUG("decode picture numbers");
for (i = 0; i < priv->short_ref_count; i++) {
GstVaapiPictureH264 * const pic = priv->short_ref[i];
// (8-27)
if (pic->frame_num > priv->frame_num)
pic->frame_num_wrap = pic->frame_num - MaxFrameNum;
else
pic->frame_num_wrap = pic->frame_num;
// (8-28, 8-30, 8-31)
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(picture))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
pic->pic_num = pic->frame_num_wrap;
else {
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (pic->structure == picture->structure)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
pic->pic_num = 2 * pic->frame_num_wrap + 1;
else
pic->pic_num = 2 * pic->frame_num_wrap;
}
}
for (i = 0; i < priv->long_ref_count; i++) {
GstVaapiPictureH264 * const pic = priv->long_ref[i];
// (8-29, 8-32, 8-33)
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(picture))
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
pic->long_term_pic_num = pic->long_term_frame_idx;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
else {
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (pic->structure == picture->structure)
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
pic->long_term_pic_num = 2 * pic->long_term_frame_idx + 1;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
else
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
pic->long_term_pic_num = 2 * pic->long_term_frame_idx;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
}
}
#define SORT_REF_LIST(list, n, compare_func) \
qsort(list, n, sizeof(*(list)), compare_picture_##compare_func)
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
static void
init_picture_refs_fields_1(
guint picture_structure,
GstVaapiPictureH264 *RefPicList[32],
guint *RefPicList_count,
GstVaapiPictureH264 *ref_list[32],
guint ref_list_count
)
{
guint i, j, n;
i = 0;
j = 0;
n = *RefPicList_count;
do {
g_assert(n < 32);
for (; i < ref_list_count; i++) {
if (ref_list[i]->structure == picture_structure) {
RefPicList[n++] = ref_list[i++];
break;
}
}
for (; j < ref_list_count; j++) {
if (ref_list[j]->structure != picture_structure) {
RefPicList[n++] = ref_list[j++];
break;
}
}
} while (i < ref_list_count || j < ref_list_count);
*RefPicList_count = n;
}
static inline void
init_picture_refs_fields(
GstVaapiPictureH264 *picture,
GstVaapiPictureH264 *RefPicList[32],
guint *RefPicList_count,
GstVaapiPictureH264 *short_ref[32],
guint short_ref_count,
GstVaapiPictureH264 *long_ref[32],
guint long_ref_count
)
{
guint n = 0;
/* 8.2.4.2.5 - reference picture lists in fields */
init_picture_refs_fields_1(picture->structure, RefPicList, &n,
short_ref, short_ref_count);
init_picture_refs_fields_1(picture->structure, RefPicList, &n,
long_ref, long_ref_count);
*RefPicList_count = n;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static void
init_picture_refs_p_slice(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPictureH264 **ref_list;
guint i;
GST_DEBUG("decode reference picture list for P and SP slices");
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(picture)) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* 8.2.4.2.1 - P and SP slices in frames */
if (priv->short_ref_count > 0) {
ref_list = priv->RefPicList0;
for (i = 0; i < priv->short_ref_count; i++)
ref_list[i] = priv->short_ref[i];
SORT_REF_LIST(ref_list, i, pic_num_dec);
priv->RefPicList0_count += i;
}
if (priv->long_ref_count > 0) {
ref_list = &priv->RefPicList0[priv->RefPicList0_count];
for (i = 0; i < priv->long_ref_count; i++)
ref_list[i] = priv->long_ref[i];
SORT_REF_LIST(ref_list, i, long_term_pic_num_inc);
priv->RefPicList0_count += i;
}
}
else {
/* 8.2.4.2.2 - P and SP slices in fields */
GstVaapiPictureH264 *short_ref[32];
guint short_ref_count = 0;
GstVaapiPictureH264 *long_ref[32];
guint long_ref_count = 0;
if (priv->short_ref_count > 0) {
for (i = 0; i < priv->short_ref_count; i++)
short_ref[i] = priv->short_ref[i];
SORT_REF_LIST(short_ref, i, frame_num_wrap_dec);
short_ref_count = i;
}
if (priv->long_ref_count > 0) {
for (i = 0; i < priv->long_ref_count; i++)
long_ref[i] = priv->long_ref[i];
SORT_REF_LIST(long_ref, i, long_term_frame_idx_inc);
long_ref_count = i;
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
init_picture_refs_fields(
picture,
priv->RefPicList0, &priv->RefPicList0_count,
short_ref, short_ref_count,
long_ref, long_ref_count
);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
}
static void
init_picture_refs_b_slice(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPictureH264 **ref_list;
guint i, n;
GST_DEBUG("decode reference picture list for B slices");
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(picture)) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* 8.2.4.2.3 - B slices in frames */
/* RefPicList0 */
if (priv->short_ref_count > 0) {
// 1. Short-term references
ref_list = priv->RefPicList0;
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc < picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_dec);
priv->RefPicList0_count += n;
ref_list = &priv->RefPicList0[priv->RefPicList0_count];
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc >= picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_inc);
priv->RefPicList0_count += n;
}
if (priv->long_ref_count > 0) {
// 2. Long-term references
ref_list = &priv->RefPicList0[priv->RefPicList0_count];
for (n = 0, i = 0; i < priv->long_ref_count; i++)
ref_list[n++] = priv->long_ref[i];
SORT_REF_LIST(ref_list, n, long_term_pic_num_inc);
priv->RefPicList0_count += n;
}
/* RefPicList1 */
if (priv->short_ref_count > 0) {
// 1. Short-term references
ref_list = priv->RefPicList1;
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc > picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_inc);
priv->RefPicList1_count += n;
ref_list = &priv->RefPicList1[priv->RefPicList1_count];
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc <= picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_dec);
priv->RefPicList1_count += n;
}
if (priv->long_ref_count > 0) {
// 2. Long-term references
ref_list = &priv->RefPicList1[priv->RefPicList1_count];
for (n = 0, i = 0; i < priv->long_ref_count; i++)
ref_list[n++] = priv->long_ref[i];
SORT_REF_LIST(ref_list, n, long_term_pic_num_inc);
priv->RefPicList1_count += n;
}
}
else {
/* 8.2.4.2.4 - B slices in fields */
GstVaapiPictureH264 *short_ref0[32];
guint short_ref0_count = 0;
GstVaapiPictureH264 *short_ref1[32];
guint short_ref1_count = 0;
GstVaapiPictureH264 *long_ref[32];
guint long_ref_count = 0;
/* refFrameList0ShortTerm */
if (priv->short_ref_count > 0) {
ref_list = short_ref0;
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc <= picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_dec);
short_ref0_count += n;
ref_list = &short_ref0[short_ref0_count];
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc > picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_inc);
short_ref0_count += n;
}
/* refFrameList1ShortTerm */
if (priv->short_ref_count > 0) {
ref_list = short_ref1;
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc > picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_inc);
short_ref1_count += n;
ref_list = &short_ref1[short_ref1_count];
for (n = 0, i = 0; i < priv->short_ref_count; i++) {
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
if (priv->short_ref[i]->base.poc <= picture->base.poc)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[n++] = priv->short_ref[i];
}
SORT_REF_LIST(ref_list, n, poc_dec);
short_ref1_count += n;
}
/* refFrameListLongTerm */
if (priv->long_ref_count > 0) {
for (i = 0; i < priv->long_ref_count; i++)
long_ref[i] = priv->long_ref[i];
SORT_REF_LIST(long_ref, i, long_term_frame_idx_inc);
long_ref_count = i;
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
init_picture_refs_fields(
picture,
priv->RefPicList0, &priv->RefPicList0_count,
short_ref0, short_ref0_count,
long_ref, long_ref_count
);
init_picture_refs_fields(
picture,
priv->RefPicList1, &priv->RefPicList1_count,
short_ref1, short_ref1_count,
long_ref, long_ref_count
);
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* Check whether RefPicList1 is identical to RefPicList0, then
swap if necessary */
if (priv->RefPicList1_count > 1 &&
priv->RefPicList1_count == priv->RefPicList0_count &&
memcmp(priv->RefPicList0, priv->RefPicList1,
priv->RefPicList0_count * sizeof(priv->RefPicList0[0])) == 0) {
GstVaapiPictureH264 * const tmp = priv->RefPicList1[0];
priv->RefPicList1[0] = priv->RefPicList1[1];
priv->RefPicList1[1] = tmp;
}
}
#undef SORT_REF_LIST
static gint
find_short_term_reference(GstVaapiDecoderH264 *decoder, gint32 pic_num)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
guint i;
for (i = 0; i < priv->short_ref_count; i++) {
if (priv->short_ref[i]->pic_num == pic_num)
return i;
}
GST_ERROR("found no short-term reference picture with PicNum = %d",
pic_num);
return -1;
}
static gint
find_long_term_reference(GstVaapiDecoderH264 *decoder, gint32 long_term_pic_num)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
guint i;
for (i = 0; i < priv->long_ref_count; i++) {
if (priv->long_ref[i]->long_term_pic_num == long_term_pic_num)
return i;
}
GST_ERROR("found no long-term reference picture with LongTermPicNum = %d",
long_term_pic_num);
return -1;
}
static void
exec_picture_refs_modification_1(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr,
guint list
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
GstH264RefPicListModification *ref_pic_list_modification;
guint num_ref_pic_list_modifications;
GstVaapiPictureH264 **ref_list;
guint *ref_list_count_ptr, ref_list_count, ref_list_idx = 0;
guint i, j, n, num_refs;
gint found_ref_idx;
gint32 MaxPicNum, CurrPicNum, picNumPred;
GST_DEBUG("modification process of reference picture list %u", list);
if (list == 0) {
ref_pic_list_modification = slice_hdr->ref_pic_list_modification_l0;
num_ref_pic_list_modifications = slice_hdr->n_ref_pic_list_modification_l0;
ref_list = priv->RefPicList0;
ref_list_count_ptr = &priv->RefPicList0_count;
num_refs = slice_hdr->num_ref_idx_l0_active_minus1 + 1;
}
else {
ref_pic_list_modification = slice_hdr->ref_pic_list_modification_l1;
num_ref_pic_list_modifications = slice_hdr->n_ref_pic_list_modification_l1;
ref_list = priv->RefPicList1;
ref_list_count_ptr = &priv->RefPicList1_count;
num_refs = slice_hdr->num_ref_idx_l1_active_minus1 + 1;
}
ref_list_count = *ref_list_count_ptr;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (!GST_VAAPI_PICTURE_IS_FRAME(picture)) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
MaxPicNum = 1 << (sps->log2_max_frame_num_minus4 + 5); // 2 * MaxFrameNum
CurrPicNum = 2 * slice_hdr->frame_num + 1; // 2 * frame_num + 1
}
else {
MaxPicNum = 1 << (sps->log2_max_frame_num_minus4 + 4); // MaxFrameNum
CurrPicNum = slice_hdr->frame_num; // frame_num
}
picNumPred = CurrPicNum;
for (i = 0; i < num_ref_pic_list_modifications; i++) {
GstH264RefPicListModification * const l = &ref_pic_list_modification[i];
if (l->modification_of_pic_nums_idc == 3)
break;
/* 8.2.4.3.1 - Short-term reference pictures */
if (l->modification_of_pic_nums_idc == 0 || l->modification_of_pic_nums_idc == 1) {
gint32 abs_diff_pic_num = l->value.abs_diff_pic_num_minus1 + 1;
gint32 picNum, picNumNoWrap;
// (8-34)
if (l->modification_of_pic_nums_idc == 0) {
picNumNoWrap = picNumPred - abs_diff_pic_num;
if (picNumNoWrap < 0)
picNumNoWrap += MaxPicNum;
}
// (8-35)
else {
picNumNoWrap = picNumPred + abs_diff_pic_num;
if (picNumNoWrap >= MaxPicNum)
picNumNoWrap -= MaxPicNum;
}
picNumPred = picNumNoWrap;
// (8-36)
picNum = picNumNoWrap;
if (picNum > CurrPicNum)
picNum -= MaxPicNum;
h264: fix modification process of reference picture lists. Construction of RefPicList0/1 could be off by one element. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-02-29 08:08:46 +00:00
// (8-37)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
for (j = num_refs; j > ref_list_idx; j--)
ref_list[j] = ref_list[j - 1];
found_ref_idx = find_short_term_reference(decoder, picNum);
ref_list[ref_list_idx++] =
found_ref_idx >= 0 ? priv->short_ref[found_ref_idx] : NULL;
n = ref_list_idx;
h264: fix modification process of reference picture lists. Construction of RefPicList0/1 could be off by one element. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-02-29 08:08:46 +00:00
for (j = ref_list_idx; j <= num_refs; j++) {
gint32 PicNumF;
if (!ref_list[j])
continue;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
PicNumF =
GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(ref_list[j]) ?
ref_list[j]->pic_num : MaxPicNum;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (PicNumF != picNum)
ref_list[n++] = ref_list[j];
}
}
/* 8.2.4.3.2 - Long-term reference pictures */
else {
for (j = num_refs; j > ref_list_idx; j--)
ref_list[j] = ref_list[j - 1];
found_ref_idx =
find_long_term_reference(decoder, l->value.long_term_pic_num);
ref_list[ref_list_idx++] =
found_ref_idx >= 0 ? priv->long_ref[found_ref_idx] : NULL;
n = ref_list_idx;
h264: fix modification process of reference picture lists. Construction of RefPicList0/1 could be off by one element. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2012-02-29 08:08:46 +00:00
for (j = ref_list_idx; j <= num_refs; j++) {
gint32 LongTermPicNumF;
if (!ref_list[j])
continue;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
LongTermPicNumF =
GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(ref_list[j]) ?
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
ref_list[j]->long_term_pic_num : INT_MAX;
if (LongTermPicNumF != l->value.long_term_pic_num)
ref_list[n++] = ref_list[j];
}
}
}
#if DEBUG
for (i = 0; i < num_refs; i++)
if (!ref_list[i])
GST_ERROR("list %u entry %u is empty", list, i);
#endif
*ref_list_count_ptr = num_refs;
}
/* 8.2.4.3 - Modification process for reference picture lists */
static void
exec_picture_refs_modification(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GST_DEBUG("execute ref_pic_list_modification()");
/* RefPicList0 */
if (!GST_H264_IS_I_SLICE(slice_hdr) && !GST_H264_IS_SI_SLICE(slice_hdr) &&
slice_hdr->ref_pic_list_modification_flag_l0)
exec_picture_refs_modification_1(decoder, picture, slice_hdr, 0);
/* RefPicList1 */
if (GST_H264_IS_B_SLICE(slice_hdr) &&
slice_hdr->ref_pic_list_modification_flag_l1)
exec_picture_refs_modification_1(decoder, picture, slice_hdr, 1);
}
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
static void
init_picture_ref_lists(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
guint i, j, short_ref_count, long_ref_count;
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
short_ref_count = 0;
long_ref_count = 0;
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(priv->current_picture)) {
for (i = 0; i < priv->dpb_count; i++) {
GstVaapiFrameStore * const fs = priv->dpb[i];
GstVaapiPictureH264 *picture;
if (!gst_vaapi_frame_store_has_frame(fs))
continue;
picture = fs->buffers[0];
if (GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(picture))
priv->short_ref[short_ref_count++] = picture;
else if (GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(picture))
priv->long_ref[long_ref_count++] = picture;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
picture->other_field = fs->buffers[1];
}
}
else {
for (i = 0; i < priv->dpb_count; i++) {
GstVaapiFrameStore * const fs = priv->dpb[i];
for (j = 0; j < fs->num_buffers; j++) {
GstVaapiPictureH264 * const picture = fs->buffers[j];
if (GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(picture))
priv->short_ref[short_ref_count++] = picture;
else if (GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(picture))
priv->long_ref[long_ref_count++] = picture;
picture->structure = picture->base.structure;
picture->other_field = fs->buffers[j ^ 1];
}
h264: introduce new frame store structure. The frame store represents a Decoded Picture Buffer entry, which can hold up to two fields. So far, the frame store is only used to hold full frames.
2012-11-02 14:14:58 +00:00
}
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
}
for (i = short_ref_count; i < priv->short_ref_count; i++)
priv->short_ref[i] = NULL;
priv->short_ref_count = short_ref_count;
for (i = long_ref_count; i < priv->long_ref_count; i++)
priv->long_ref[i] = NULL;
priv->long_ref_count = long_ref_count;
}
h264: minor clean-ups. Move DPB flush up if the current picture to decode is an IDR. Besides, don't bother to check for IDR pictures in dpb_add() function since an explicit DPB flush was already performed in this case.
2012-10-31 15:37:14 +00:00
static void
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
init_picture_refs(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264SliceHdr *slice_hdr
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPicture * const base_picture = &picture->base;
guint i, num_refs;
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
init_picture_ref_lists(decoder);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
init_picture_refs_pic_num(decoder, picture, slice_hdr);
priv->RefPicList0_count = 0;
priv->RefPicList1_count = 0;
switch (base_picture->type) {
case GST_VAAPI_PICTURE_TYPE_P:
case GST_VAAPI_PICTURE_TYPE_SP:
init_picture_refs_p_slice(decoder, picture, slice_hdr);
break;
case GST_VAAPI_PICTURE_TYPE_B:
init_picture_refs_b_slice(decoder, picture, slice_hdr);
break;
default:
break;
}
exec_picture_refs_modification(decoder, picture, slice_hdr);
switch (base_picture->type) {
case GST_VAAPI_PICTURE_TYPE_B:
num_refs = 1 + slice_hdr->num_ref_idx_l1_active_minus1;
for (i = priv->RefPicList1_count; i < num_refs; i++)
priv->RefPicList1[i] = NULL;
priv->RefPicList1_count = num_refs;
// fall-through
case GST_VAAPI_PICTURE_TYPE_P:
case GST_VAAPI_PICTURE_TYPE_SP:
num_refs = 1 + slice_hdr->num_ref_idx_l0_active_minus1;
for (i = priv->RefPicList0_count; i < num_refs; i++)
priv->RefPicList0[i] = NULL;
priv->RefPicList0_count = num_refs;
break;
default:
break;
}
}
static gboolean
init_picture(
GstVaapiDecoderH264 *decoder,
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstVaapiPictureH264 *picture, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPicture * const base_picture = &picture->base;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->prev_frame_num = priv->frame_num;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
priv->frame_num = slice_hdr->frame_num;
picture->frame_num = priv->frame_num;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
picture->frame_num_wrap = priv->frame_num;
h264: handle Decoded Picture Buffer (DPB).
2012-01-24 14:38:14 +00:00
picture->output_flag = TRUE; /* XXX: conformant to Annex A only */
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
base_picture->pts = GST_VAAPI_DECODER_CODEC_FRAME(decoder)->pts;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
/* Reset decoder state for IDR pictures */
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
if (unit->nalu.type == GST_H264_NAL_SLICE_IDR) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("<IDR>");
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
GST_VAAPI_PICTURE_FLAG_SET(picture, GST_VAAPI_PICTURE_FLAG_IDR);
h264: minor clean-ups. Move DPB flush up if the current picture to decode is an IDR. Besides, don't bother to check for IDR pictures in dpb_add() function since an explicit DPB flush was already performed in this case.
2012-10-31 15:37:14 +00:00
dpb_flush(decoder);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
/* Initialize slice type */
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
switch (slice_hdr->type % 5) {
case GST_H264_P_SLICE:
base_picture->type = GST_VAAPI_PICTURE_TYPE_P;
break;
case GST_H264_B_SLICE:
base_picture->type = GST_VAAPI_PICTURE_TYPE_B;
break;
case GST_H264_I_SLICE:
base_picture->type = GST_VAAPI_PICTURE_TYPE_I;
break;
case GST_H264_SP_SLICE:
base_picture->type = GST_VAAPI_PICTURE_TYPE_SP;
break;
case GST_H264_SI_SLICE:
base_picture->type = GST_VAAPI_PICTURE_TYPE_SI;
break;
}
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
/* Initialize picture structure */
if (!slice_hdr->field_pic_flag)
base_picture->structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
else {
GST_VAAPI_PICTURE_FLAG_SET(picture, GST_VAAPI_PICTURE_FLAG_INTERLACED);
if (!slice_hdr->bottom_field_flag)
base_picture->structure = GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD;
else
base_picture->structure = GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD;
}
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
picture->structure = base_picture->structure;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
h264: minor clean-ups. Move DPB flush up if the current picture to decode is an IDR. Besides, don't bother to check for IDR pictures in dpb_add() function since an explicit DPB flush was already performed in this case.
2012-10-31 15:37:14 +00:00
/* Initialize reference flags */
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
if (unit->nalu.ref_idc) {
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstH264DecRefPicMarking * const dec_ref_pic_marking =
&slice_hdr->dec_ref_pic_marking;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
if (GST_VAAPI_PICTURE_IS_IDR(picture) &&
dec_ref_pic_marking->long_term_reference_flag)
GST_VAAPI_PICTURE_FLAG_SET(picture,
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE);
else
GST_VAAPI_PICTURE_FLAG_SET(picture,
GST_VAAPI_PICTURE_FLAG_SHORT_TERM_REFERENCE);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
init_picture_poc(decoder, picture, slice_hdr);
h264: minor clean-ups. Move DPB flush up if the current picture to decode is an IDR. Besides, don't bother to check for IDR pictures in dpb_add() function since an explicit DPB flush was already performed in this case.
2012-10-31 15:37:14 +00:00
init_picture_refs(decoder, picture, slice_hdr);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return TRUE;
}
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
/* 8.2.5.3 - Sliding window decoded reference picture marking process */
static gboolean
exec_ref_pic_marking_sliding_window(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstH264PPS * const pps = priv->current_picture->pps;
GstH264SPS * const sps = pps->sequence;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
GstVaapiPictureH264 *ref_picture;
guint i, m, max_num_ref_frames;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
GST_DEBUG("reference picture marking process (sliding window)");
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (!GST_VAAPI_PICTURE_IS_FIRST_FIELD(priv->current_picture))
return TRUE;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
max_num_ref_frames = sps->num_ref_frames;
if (max_num_ref_frames == 0)
max_num_ref_frames = 1;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (!GST_VAAPI_PICTURE_IS_FRAME(priv->current_picture))
max_num_ref_frames <<= 1;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
if (priv->short_ref_count + priv->long_ref_count < max_num_ref_frames)
return TRUE;
if (priv->short_ref_count < 1)
return FALSE;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
for (m = 0, i = 1; i < priv->short_ref_count; i++) {
GstVaapiPictureH264 * const picture = priv->short_ref[i];
if (picture->frame_num_wrap < priv->short_ref[m]->frame_num_wrap)
m = i;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
}
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ref_picture = priv->short_ref[m];
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
gst_vaapi_picture_h264_set_reference(ref_picture, 0, TRUE);
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ARRAY_REMOVE_INDEX(priv->short_ref, m);
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
/* Both fields need to be marked as "unused for reference", so
remove the other field from the short_ref[] list as well */
if (!GST_VAAPI_PICTURE_IS_FRAME(priv->current_picture) && ref_picture->other_field) {
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
for (i = 0; i < priv->short_ref_count; i++) {
if (priv->short_ref[i] == ref_picture->other_field) {
ARRAY_REMOVE_INDEX(priv->short_ref, i);
break;
}
}
}
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
return TRUE;
}
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
static inline gint32
get_picNumX(GstVaapiPictureH264 *picture, GstH264RefPicMarking *ref_pic_marking)
{
gint32 pic_num;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
if (GST_VAAPI_PICTURE_IS_FRAME(picture))
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
pic_num = picture->frame_num_wrap;
else
pic_num = 2 * picture->frame_num_wrap + 1;
pic_num -= ref_pic_marking->difference_of_pic_nums_minus1 + 1;
return pic_num;
}
h264: simplify reference picture marking process. ... to build the short_ref[] and long_ref[] lists from the DPB, instead of maintaining them separately. This avoids refs/unrefs while making it possible to generate the list based on the actual picture structure. This also ensures that the list of generated ReferenceFrames[] actually matches what reference frames are available in the DPB. i.e. short_ref[] and long_ref[] entries are implied from the DPB, so there is no risk of having "dangling" references.
2012-10-31 13:24:09 +00:00
/* 8.2.5.4.1. Mark short-term reference picture as "unused for reference" */
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
static void
exec_ref_pic_marking_adaptive_mmco_1(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
gint32 i, picNumX;
picNumX = get_picNumX(picture, ref_pic_marking);
i = find_short_term_reference(decoder, picNumX);
if (i < 0)
return;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
gst_vaapi_picture_h264_set_reference(priv->short_ref[i], 0,
GST_VAAPI_PICTURE_IS_FRAME(picture));
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ARRAY_REMOVE_INDEX(priv->short_ref, i);
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
}
/* 8.2.5.4.2. Mark long-term reference picture as "unused for reference" */
static void
exec_ref_pic_marking_adaptive_mmco_2(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
gint32 i;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
i = find_long_term_reference(decoder, ref_pic_marking->long_term_pic_num);
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
if (i < 0)
return;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
gst_vaapi_picture_h264_set_reference(priv->long_ref[i], 0,
GST_VAAPI_PICTURE_IS_FRAME(picture));
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ARRAY_REMOVE_INDEX(priv->long_ref, i);
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
}
/* 8.2.5.4.3. Assign LongTermFrameIdx to a short-term reference picture */
static void
exec_ref_pic_marking_adaptive_mmco_3(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
GstVaapiPictureH264 *ref_picture;
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
gint32 i, picNumX;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
for (i = 0; i < priv->long_ref_count; i++) {
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
if (priv->long_ref[i]->long_term_frame_idx == ref_pic_marking->long_term_frame_idx)
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
break;
}
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
if (i != priv->long_ref_count) {
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
gst_vaapi_picture_h264_set_reference(priv->long_ref[i], 0, TRUE);
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ARRAY_REMOVE_INDEX(priv->long_ref, i);
}
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
picNumX = get_picNumX(picture, ref_pic_marking);
i = find_short_term_reference(decoder, picNumX);
if (i < 0)
return;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ref_picture = priv->short_ref[i];
ARRAY_REMOVE_INDEX(priv->short_ref, i);
priv->long_ref[priv->long_ref_count++] = ref_picture;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ref_picture->long_term_frame_idx = ref_pic_marking->long_term_frame_idx;
gst_vaapi_picture_h264_set_reference(ref_picture,
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE,
GST_VAAPI_PICTURE_IS_FRAME(picture));
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
}
/* 8.2.5.4.4. Mark pictures with LongTermFramIdx > max_long_term_frame_idx
* as "unused for reference" */
static void
exec_ref_pic_marking_adaptive_mmco_4(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
gint32 i, long_term_frame_idx;
long_term_frame_idx = ref_pic_marking->max_long_term_frame_idx_plus1 - 1;
for (i = 0; i < priv->long_ref_count; i++) {
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
if (priv->long_ref[i]->long_term_frame_idx <= long_term_frame_idx)
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
continue;
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
gst_vaapi_picture_h264_set_reference(priv->long_ref[i], 0, FALSE);
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
ARRAY_REMOVE_INDEX(priv->long_ref, i);
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
i--;
}
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
}
/* 8.2.5.4.5. Mark all reference pictures as "unused for reference" */
static void
exec_ref_pic_marking_adaptive_mmco_5(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
dpb_flush(decoder);
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->prev_pic_has_mmco5 = TRUE;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
/* The picture shall be inferred to have had frame_num equal to 0 (7.4.3) */
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->frame_num = 0;
priv->frame_num_offset = 0;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
picture->frame_num = 0;
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
/* Update TopFieldOrderCnt and BottomFieldOrderCnt (8.2.1) */
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD)
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
picture->field_poc[TOP_FIELD] -= picture->base.poc;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
if (picture->structure != GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD)
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
picture->field_poc[BOTTOM_FIELD] -= picture->base.poc;
picture->base.poc = 0;
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
}
/* 8.2.5.4.6. Assign a long-term frame index to the current picture */
static void
exec_ref_pic_marking_adaptive_mmco_6(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
)
{
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
picture->long_term_frame_idx = ref_pic_marking->long_term_frame_idx;
h264: split remove_reference_at() into finer units. Split remove_reference_at() into a function that actually removes the specified entry from the short-term or long-term reference picture array, and a function that sets reference flags to the desired value, possibly zero. The latters marks the picture as "unused for reference".
2012-11-13 15:35:30 +00:00
gst_vaapi_picture_h264_set_reference(picture,
h264: fix interlaced stream decoding with MMCO. Fix decoding of interlaced streams when adaptive_ref_pic_marking_mode_flag is equal to 1, i.e. when memory management control operations are used. In particular, when field_pic_flag is set to 0, the new reference flags shall be applied to both fields.
2012-11-14 09:27:12 +00:00
GST_VAAPI_PICTURE_FLAG_LONG_TERM_REFERENCE, FALSE);
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
}
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
/* 8.2.5.4. Adaptive memory control decoded reference picture marking process */
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
static gboolean
exec_ref_pic_marking_adaptive(
GstVaapiDecoderH264 *decoder,
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
GstVaapiPictureH264 *picture,
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
GstH264DecRefPicMarking *dec_ref_pic_marking
)
{
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
guint i;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
GST_DEBUG("reference picture marking process (adaptive memory control)");
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
typedef void (*exec_ref_pic_marking_adaptive_mmco_func)(
GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture,
GstH264RefPicMarking *ref_pic_marking
);
static const exec_ref_pic_marking_adaptive_mmco_func mmco_funcs[] = {
NULL,
exec_ref_pic_marking_adaptive_mmco_1,
exec_ref_pic_marking_adaptive_mmco_2,
exec_ref_pic_marking_adaptive_mmco_3,
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
exec_ref_pic_marking_adaptive_mmco_4,
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
exec_ref_pic_marking_adaptive_mmco_5,
h264: fix MMCO-based reference picture marking process. Fix adaptive memory control decoded reference picture marking process implementation for operations 2 to 6, thus also fixing support for long-term reference pictures.
2012-10-22 09:52:13 +00:00
exec_ref_pic_marking_adaptive_mmco_6,
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
};
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
for (i = 0; i < dec_ref_pic_marking->n_ref_pic_marking; i++) {
GstH264RefPicMarking * const ref_pic_marking =
&dec_ref_pic_marking->ref_pic_marking[i];
h264: move MMCO handlers out of the loop (cosmetics). This change only splits each individual MMCO handler into several functions dedicated for each operation. This is needed to perform further work later on.
2012-10-22 08:50:29 +00:00
const guint mmco = ref_pic_marking->memory_management_control_operation;
if (mmco < G_N_ELEMENTS(mmco_funcs) && mmco_funcs[mmco])
mmco_funcs[mmco](decoder, picture, ref_pic_marking);
else {
GST_ERROR("unhandled MMCO %u", mmco);
return FALSE;
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
}
}
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
return TRUE;
}
/* 8.2.5 - Execute reference picture marking process */
static gboolean
exec_ref_pic_marking(GstVaapiDecoderH264 *decoder, GstVaapiPictureH264 *picture)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
priv->prev_pic_has_mmco5 = FALSE;
h264: add picture structure for reference picture marking process. Introduce new `structure' field to the H.264 specific picture structure so that to simplify the reference picture marking process. That local picture structure is derived from the original picture structure, as defined by the syntax elements field_pic_flag and bottom_field_flag.
2012-11-13 13:04:31 +00:00
priv->prev_pic_structure = picture->structure;
h264: simplify code when MMCO is 5. Remove exit_picture() and exit_picture_poc() since PicOrderCnt(CurrPic) is now updated accordingly to the standard. Besides, MMCO = 5 specific operations are moved up to exec_ref_pic_marking_adaptive_mmco_5().
2012-10-23 08:33:50 +00:00
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
if (!GST_VAAPI_PICTURE_IS_REFERENCE(picture))
return TRUE;
h264: introduce GST_VAAPI_PICTURE_FLAG_IDR flag.
2012-10-31 10:33:40 +00:00
if (!GST_VAAPI_PICTURE_IS_IDR(picture)) {
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
GstH264DecRefPicMarking * const dec_ref_pic_marking =
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
&picture->last_slice_hdr->dec_ref_pic_marking;
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
if (dec_ref_pic_marking->adaptive_ref_pic_marking_mode_flag) {
h264: execute reference picture marking process (MMCO).
2012-01-23 14:03:07 +00:00
if (!exec_ref_pic_marking_adaptive(decoder, picture, dec_ref_pic_marking))
h264: execute reference picture marking process (sliding window).
2012-01-18 12:38:34 +00:00
return FALSE;
}
else {
if (!exec_ref_pic_marking_sliding_window(decoder))
return FALSE;
}
}
return TRUE;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static void
vaapi_init_picture(VAPictureH264 *pic)
{
pic->picture_id = VA_INVALID_ID;
pic->frame_idx = 0;
pic->flags = VA_PICTURE_H264_INVALID;
pic->TopFieldOrderCnt = 0;
pic->BottomFieldOrderCnt = 0;
}
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
static void
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
vaapi_fill_picture(VAPictureH264 *pic, GstVaapiPictureH264 *picture,
guint picture_structure)
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
{
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
if (!picture_structure)
picture_structure = picture->structure;
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->picture_id = picture->base.surface_id;
pic->flags = 0;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
if (GST_VAAPI_PICTURE_IS_LONG_TERM_REFERENCE(picture)) {
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->flags |= VA_PICTURE_H264_LONG_TERM_REFERENCE;
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
pic->frame_idx = picture->long_term_frame_idx;
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
}
else {
h264: introduce GST_VAAPI_PICTURE_{SHORT,LONG}_TERM_REFERENCE flags. Further get rid of GstVaapiPictureH264-local VAPictureH264.flags for reference bits, thus simplifying the reference picture marking process to only track a single set of reference flags. Also introduce a new long_term_frame_idx member.
2012-10-31 10:45:14 +00:00
if (GST_VAAPI_PICTURE_IS_SHORT_TERM_REFERENCE(picture))
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->flags |= VA_PICTURE_H264_SHORT_TERM_REFERENCE;
pic->frame_idx = picture->frame_num;
}
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
switch (picture_structure) {
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
case GST_VAAPI_PICTURE_STRUCTURE_FRAME:
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
pic->TopFieldOrderCnt = picture->field_poc[TOP_FIELD];
pic->BottomFieldOrderCnt = picture->field_poc[BOTTOM_FIELD];
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
break;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD:
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->flags |= VA_PICTURE_H264_TOP_FIELD;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
pic->TopFieldOrderCnt = picture->field_poc[TOP_FIELD];
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->BottomFieldOrderCnt = 0;
break;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD:
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->flags |= VA_PICTURE_H264_BOTTOM_FIELD;
h264: introduce per-field POC in GstVaapiPictureH264. Use the POC member available in the GstVaapiPicture base class and get rid of the dependency on the local VAPictureH264 TopFieldOrderCnt and BottomFieldOrderCnt. Rather, use a simple field_poc[] array initialized to INT_MAX, so that to simplify picture POC calculation for non frame pictures.
2012-10-31 10:52:03 +00:00
pic->BottomFieldOrderCnt = picture->field_poc[BOTTOM_FIELD];
h264: add vaapi_fill_picture() helper. Add vaapi_fill_picture() helper function to convert GstVaapiPictureH264 to VAPictureH264 structure. This is preparatory work to get rid of the local VAPictureH264 member in GstVaapiPictureH264.
2012-10-31 10:07:48 +00:00
pic->TopFieldOrderCnt = 0;
break;
}
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static gboolean
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
fill_picture(GstVaapiDecoderH264 *decoder,
GstVaapiPictureH264 *picture, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiPicture * const base_picture = &picture->base;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
GstH264PPS * const pps = picture->pps;
GstH264SPS * const sps = pps->sequence;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
VAPictureParameterBufferH264 * const pic_param = base_picture->param;
guint i, n;
/* Fill in VAPictureParameterBufferH264 */
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
vaapi_fill_picture(&pic_param->CurrPic, picture, 0);
for (i = 0, n = 0; i < priv->dpb_count; i++) {
GstVaapiFrameStore * const fs = priv->dpb[i];
if (gst_vaapi_frame_store_has_reference(fs))
vaapi_fill_picture(&pic_param->ReferenceFrames[n++],
fs->buffers[0], fs->structure);
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
for (; n < G_N_ELEMENTS(pic_param->ReferenceFrames); n++)
vaapi_init_picture(&pic_param->ReferenceFrames[n]);
#define COPY_FIELD(s, f) \
pic_param->f = (s)->f
#define COPY_BFM(a, s, f) \
pic_param->a.bits.f = (s)->f
h264: fix picture size in macroblocks. The picture size signalled by sps->{width,height} is the actual size with cropping applied, not the original size derived from pic_width_in_mbs_minus1 and pic_height_in_map_units_minus1. VA driver expects that original size, uncropped. There is another issue pending: frame cropping information needs to be taken care of.
2012-11-16 17:00:10 +00:00
pic_param->picture_width_in_mbs_minus1 = priv->mb_width - 1;
pic_param->picture_height_in_mbs_minus1 = priv->mb_height - 1;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
pic_param->frame_num = priv->frame_num;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
COPY_FIELD(sps, bit_depth_luma_minus8);
COPY_FIELD(sps, bit_depth_chroma_minus8);
COPY_FIELD(sps, num_ref_frames);
COPY_FIELD(pps, num_slice_groups_minus1);
COPY_FIELD(pps, slice_group_map_type);
COPY_FIELD(pps, slice_group_change_rate_minus1);
COPY_FIELD(pps, pic_init_qp_minus26);
COPY_FIELD(pps, pic_init_qs_minus26);
COPY_FIELD(pps, chroma_qp_index_offset);
COPY_FIELD(pps, second_chroma_qp_index_offset);
pic_param->seq_fields.value = 0; /* reset all bits */
pic_param->seq_fields.bits.residual_colour_transform_flag = sps->separate_colour_plane_flag;
pic_param->seq_fields.bits.MinLumaBiPredSize8x8 = sps->level_idc >= 31; /* A.3.3.2 */
COPY_BFM(seq_fields, sps, chroma_format_idc);
COPY_BFM(seq_fields, sps, gaps_in_frame_num_value_allowed_flag);
COPY_BFM(seq_fields, sps, frame_mbs_only_flag);
COPY_BFM(seq_fields, sps, mb_adaptive_frame_field_flag);
COPY_BFM(seq_fields, sps, direct_8x8_inference_flag);
COPY_BFM(seq_fields, sps, log2_max_frame_num_minus4);
COPY_BFM(seq_fields, sps, pic_order_cnt_type);
COPY_BFM(seq_fields, sps, log2_max_pic_order_cnt_lsb_minus4);
COPY_BFM(seq_fields, sps, delta_pic_order_always_zero_flag);
pic_param->pic_fields.value = 0; /* reset all bits */
pic_param->pic_fields.bits.field_pic_flag = slice_hdr->field_pic_flag;
pic_param->pic_fields.bits.reference_pic_flag = GST_VAAPI_PICTURE_IS_REFERENCE(picture);
COPY_BFM(pic_fields, pps, entropy_coding_mode_flag);
COPY_BFM(pic_fields, pps, weighted_pred_flag);
COPY_BFM(pic_fields, pps, weighted_bipred_idc);
COPY_BFM(pic_fields, pps, transform_8x8_mode_flag);
COPY_BFM(pic_fields, pps, constrained_intra_pred_flag);
COPY_BFM(pic_fields, pps, pic_order_present_flag);
COPY_BFM(pic_fields, pps, deblocking_filter_control_present_flag);
COPY_BFM(pic_fields, pps, redundant_pic_cnt_present_flag);
return TRUE;
}
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
/* Detection of the first VCL NAL unit of a primary coded picture (7.4.1.2.4) */
static gboolean
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
is_new_picture(GstVaapiDecoderUnitH264 *unit,
GstVaapiDecoderUnitH264 *prev_unit)
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
{
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
GstH264SliceHdr *prev_slice_hdr;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
if (!prev_unit)
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
return TRUE;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
prev_slice_hdr = &prev_unit->data.slice_hdr;
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
#define CHECK_EXPR(expr, field_name) do { \
if (!(expr)) { \
GST_DEBUG(field_name " differs in value"); \
return TRUE; \
} \
} while (0)
#define CHECK_VALUE(new_slice_hdr, old_slice_hdr, field) \
CHECK_EXPR(((new_slice_hdr)->field == (old_slice_hdr)->field), #field)
/* frame_num differs in value, regardless of inferred values to 0 */
CHECK_VALUE(slice_hdr, prev_slice_hdr, frame_num);
/* pic_parameter_set_id differs in value */
CHECK_VALUE(slice_hdr, prev_slice_hdr, pps);
/* field_pic_flag differs in value */
CHECK_VALUE(slice_hdr, prev_slice_hdr, field_pic_flag);
/* bottom_field_flag is present in both and differs in value */
if (slice_hdr->field_pic_flag && prev_slice_hdr->field_pic_flag)
CHECK_VALUE(slice_hdr, prev_slice_hdr, bottom_field_flag);
/* nal_ref_idc differs in value with one of the nal_ref_idc values is 0 */
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
CHECK_EXPR((unit->nalu.ref_idc != 0) ==
(prev_unit->nalu.ref_idc != 0), "nal_ref_idc");
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
/* POC type is 0 for both and either pic_order_cnt_lsb differs in
value or delta_pic_order_cnt_bottom differs in value */
if (sps->pic_order_cnt_type == 0) {
CHECK_VALUE(slice_hdr, prev_slice_hdr, pic_order_cnt_lsb);
if (pps->pic_order_present_flag && !slice_hdr->field_pic_flag)
CHECK_VALUE(slice_hdr, prev_slice_hdr, delta_pic_order_cnt_bottom);
}
/* POC type is 1 for both and either delta_pic_order_cnt[0]
differs in value or delta_pic_order_cnt[1] differs in value */
else if (sps->pic_order_cnt_type == 1) {
CHECK_VALUE(slice_hdr, prev_slice_hdr, delta_pic_order_cnt[0]);
CHECK_VALUE(slice_hdr, prev_slice_hdr, delta_pic_order_cnt[1]);
}
/* IdrPicFlag differs in value */
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
CHECK_VALUE(&unit->nalu, &prev_unit->nalu, idr_pic_flag);
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
/* IdrPicFlag is equal to 1 for both and idr_pic_id differs in value */
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
if (unit->nalu.idr_pic_flag)
h264: fix detection of picture boundaries. Strictly follow the standard (7.4.1.2.4) to detect the first VCL NAL unit of a primary coded picture.
2012-10-24 16:23:09 +00:00
CHECK_VALUE(slice_hdr, prev_slice_hdr, idr_pic_id);
#undef CHECK_EXPR
#undef CHECK_VALUE
return FALSE;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
decode_picture(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstVaapiPictureH264 *picture;
GstVaapiDecoderStatus status;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
status = ensure_context(decoder, sps);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
if (priv->current_picture) {
/* Re-use current picture where the first field was decoded */
picture = gst_vaapi_picture_h264_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_h264_new(decoder);
if (!picture) {
GST_ERROR("failed to allocate picture");
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
gst_vaapi_picture_replace(&priv->current_picture, picture);
gst_vaapi_picture_unref(picture);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
picture->pps = pps;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: optimize handling of scaling lists. Don't copy scaling lists twice to an intermediate state. Rather, directly use the scaling lists from GstH264PPS since they would match those provided by SPS header, if necessary. i.e. if PPS-specific scaling lists are not available in the bitstream.
2012-10-23 12:50:14 +00:00
status = ensure_quant_matrix(decoder, picture);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) {
h264: review and report errors accordingly. Use GST_ERROR() to report real errors instead of hiding them into GST_DEBUG().
2012-09-21 14:43:38 +00:00
GST_ERROR("failed to reset quantizer matrix");
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return status;
}
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
if (!init_picture(decoder, picture, unit))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
if (!fill_picture(decoder, picture, unit))
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
h264: fix slice_data_bit_offset calculation. Unlike what VA-API documentation defines, the slice_data_bit_offset represents the offset to the first macroblock in the slice data, minus any emulation prevention bytes in the slice_header(). This fix copes with binary-only VA drivers that won't be fixed any time soon. Besides, this aligns with the current FFmpeg behaviour that was based on those proprietary drivers implementing the API incorrectly.
2012-03-02 12:41:16 +00:00
static inline guint
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
get_slice_data_bit_offset(GstH264SliceHdr *slice_hdr)
h264: fix slice_data_bit_offset calculation. Unlike what VA-API documentation defines, the slice_data_bit_offset represents the offset to the first macroblock in the slice data, minus any emulation prevention bytes in the slice_header(). This fix copes with binary-only VA drivers that won't be fixed any time soon. Besides, this aligns with the current FFmpeg behaviour that was based on those proprietary drivers implementing the API incorrectly.
2012-03-02 12:41:16 +00:00
{
guint epb_count;
epb_count = slice_hdr->n_emulation_prevention_bytes;
return 8 /* nal_unit_type */ + slice_hdr->header_size - epb_count * 8;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static gboolean
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
fill_pred_weight_table(GstVaapiDecoderH264 *decoder,
GstVaapiSlice *slice, GstH264SliceHdr *slice_hdr)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
VASliceParameterBufferH264 * const slice_param = slice->param;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstH264PPS * const pps = slice_hdr->pps;
GstH264SPS * const sps = pps->sequence;
GstH264PredWeightTable * const w = &slice_hdr->pred_weight_table;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
guint num_weight_tables = 0;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gint i, j;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
if (pps->weighted_pred_flag &&
(GST_H264_IS_P_SLICE(slice_hdr) || GST_H264_IS_SP_SLICE(slice_hdr)))
num_weight_tables = 1;
else if (pps->weighted_bipred_idc == 1 && GST_H264_IS_B_SLICE(slice_hdr))
num_weight_tables = 2;
else
num_weight_tables = 0;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
slice_param->luma_log2_weight_denom = w->luma_log2_weight_denom;
slice_param->chroma_log2_weight_denom = w->chroma_log2_weight_denom;
slice_param->luma_weight_l0_flag = 0;
slice_param->chroma_weight_l0_flag = 0;
slice_param->luma_weight_l1_flag = 0;
slice_param->chroma_weight_l1_flag = 0;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
if (num_weight_tables < 1)
return TRUE;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
slice_param->luma_weight_l0_flag = 1;
for (i = 0; i <= slice_param->num_ref_idx_l0_active_minus1; i++) {
slice_param->luma_weight_l0[i] = w->luma_weight_l0[i];
slice_param->luma_offset_l0[i] = w->luma_offset_l0[i];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
slice_param->chroma_weight_l0_flag = sps->chroma_array_type != 0;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (slice_param->chroma_weight_l0_flag) {
for (i = 0; i <= slice_param->num_ref_idx_l0_active_minus1; i++) {
for (j = 0; j < 2; j++) {
slice_param->chroma_weight_l0[i][j] = w->chroma_weight_l0[i][j];
slice_param->chroma_offset_l0[i][j] = w->chroma_offset_l0[i][j];
}
}
}
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
if (num_weight_tables < 2)
return TRUE;
slice_param->luma_weight_l1_flag = 1;
for (i = 0; i <= slice_param->num_ref_idx_l1_active_minus1; i++) {
slice_param->luma_weight_l1[i] = w->luma_weight_l1[i];
slice_param->luma_offset_l1[i] = w->luma_offset_l1[i];
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
slice_param->chroma_weight_l1_flag = sps->chroma_array_type != 0;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (slice_param->chroma_weight_l1_flag) {
for (i = 0; i <= slice_param->num_ref_idx_l1_active_minus1; i++) {
for (j = 0; j < 2; j++) {
slice_param->chroma_weight_l1[i][j] = w->chroma_weight_l1[i][j];
slice_param->chroma_offset_l1[i][j] = w->chroma_offset_l1[i][j];
}
}
}
return TRUE;
}
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
static gboolean
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
fill_RefPicList(GstVaapiDecoderH264 *decoder,
GstVaapiSlice *slice, GstH264SliceHdr *slice_hdr)
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
VASliceParameterBufferH264 * const slice_param = slice->param;
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
guint i, num_ref_lists = 0;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
slice_param->num_ref_idx_l0_active_minus1 = 0;
slice_param->num_ref_idx_l1_active_minus1 = 0;
if (GST_H264_IS_B_SLICE(slice_hdr))
num_ref_lists = 2;
else if (GST_H264_IS_I_SLICE(slice_hdr))
num_ref_lists = 0;
else
num_ref_lists = 1;
if (num_ref_lists < 1)
return TRUE;
slice_param->num_ref_idx_l0_active_minus1 =
slice_hdr->num_ref_idx_l0_active_minus1;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
for (i = 0; i < priv->RefPicList0_count && priv->RefPicList0[i]; i++)
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
vaapi_fill_picture(&slice_param->RefPicList0[i], priv->RefPicList0[i], 0);
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
for (; i <= slice_param->num_ref_idx_l0_active_minus1; i++)
vaapi_init_picture(&slice_param->RefPicList0[i]);
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
if (num_ref_lists < 2)
return TRUE;
slice_param->num_ref_idx_l1_active_minus1 =
slice_hdr->num_ref_idx_l1_active_minus1;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
for (i = 0; i < priv->RefPicList1_count && priv->RefPicList1[i]; i++)
h264: fix VAPictureParameterBufferH264.ReferenceFrames[] construction. ... for interlaced streams. The short_ref[] and long_ref[] arrays may contain up to 32 fields but VA ReferenceFrames[] array expects up to 16 reference frames, thus including both fields.
2012-11-14 13:25:34 +00:00
vaapi_fill_picture(&slice_param->RefPicList1[i], priv->RefPicList1[i], 0);
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
for (; i <= slice_param->num_ref_idx_l1_active_minus1; i++)
vaapi_init_picture(&slice_param->RefPicList1[i]);
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
return TRUE;
}
static gboolean
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
fill_slice(GstVaapiDecoderH264 *decoder,
GstVaapiSlice *slice, GstH264SliceHdr *slice_hdr)
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
{
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
VASliceParameterBufferH264 * const slice_param = slice->param;
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
/* Fill in VASliceParameterBufferH264 */
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
slice_param->slice_data_bit_offset = get_slice_data_bit_offset(slice_hdr);
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
slice_param->first_mb_in_slice = slice_hdr->first_mb_in_slice;
slice_param->slice_type = slice_hdr->type % 5;
slice_param->direct_spatial_mv_pred_flag = slice_hdr->direct_spatial_mv_pred_flag;
slice_param->cabac_init_idc = slice_hdr->cabac_init_idc;
slice_param->slice_qp_delta = slice_hdr->slice_qp_delta;
slice_param->disable_deblocking_filter_idc = slice_hdr->disable_deblocking_filter_idc;
slice_param->slice_alpha_c0_offset_div2 = slice_hdr->slice_alpha_c0_offset_div2;
slice_param->slice_beta_offset_div2 = slice_hdr->slice_beta_offset_div2;
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
if (!fill_RefPicList(decoder, slice, slice_hdr))
h264: simplify RefPicList reconstruction.
2012-01-27 16:28:50 +00:00
return FALSE;
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
if (!fill_pred_weight_table(decoder, slice, slice_hdr))
h264: fix pred_weight_table() reconstruction. Only the explicit pred_weight_table(), possibly with the inferred default values, shall be required. e.g. don't fill in the table if weighted_pred_flag is not set for P/SP slices.
2012-01-24 08:20:25 +00:00
return FALSE;
return TRUE;
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static GstVaapiDecoderStatus
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
decode_slice(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
GstVaapiPictureH264 * const picture = priv->current_picture;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GstH264SliceHdr * const slice_hdr = &unit->data.slice_hdr;
GstH264NalUnit * const nalu = &unit->nalu;
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
GstVaapiSlice *slice;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GST_DEBUG("slice (%u bytes)", nalu->size);
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
if (!priv->got_sps || !priv->got_pps) {
GST_ERROR("not initialized yet");
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
}
h264: initialize VA context before allocating the first slice. Fix decode_slice() to ensure a VA context exists prior to creating a new GstVaapiSliceH264, which invokes vaCreateBuffer() with some VA context ID. i.e. the latter was not initialized, thus causing failures on Cedar Trail for example.
2012-12-17 12:42:29 +00:00
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
unit->base.buffer = gst_buffer_create_sub(
GST_VAAPI_DECODER_CODEC_FRAME(decoder)->input_buffer,
unit->base.offset, unit->base.size);
if (!unit->base.buffer) {
GST_ERROR("failed to allocate slice data");
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
}
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
slice = GST_VAAPI_SLICE_NEW(H264, decoder,
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_BUFFER_DATA(unit->base.buffer) + nalu->offset, nalu->size);
if (!slice) {
GST_ERROR("failed to allocate slice");
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
if (!fill_slice(decoder, slice, slice_hdr)) {
gst_vaapi_mini_object_unref(GST_VAAPI_MINI_OBJECT(slice));
return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: drop GstVaapiSliceH264 object. Use standard GstVaapiSlice object from now on since we already have parsed and recorded the slice headers (GstH264SliceHdr decode units).
2012-12-07 16:45:03 +00:00
gst_vaapi_picture_add_slice(GST_VAAPI_PICTURE_CAST(picture), slice);
picture->last_slice_hdr = slice_hdr;
return GST_VAAPI_DECODER_STATUS_SUCCESS;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: exclusively use GstAdapter, drop sub-buffer hack. Maintaining the sub-buffer is rather suboptimal especially since we were also maintaining a GstAdapter. Now, we only use the GstAdapter thus requiring minor extra parsing when receiving avcC buffers.
2012-09-20 15:58:21 +00:00
static inline gint
scan_for_start_code(GstAdapter *adapter, guint ofs, guint size, guint32 *scp)
{
return (gint)gst_adapter_masked_scan_uint32_peek(adapter,
0xffffff00, 0x00000100,
ofs, size,
scp);
}
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
static GstVaapiDecoderStatus
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
decode_unit(GstVaapiDecoderH264 *decoder, GstVaapiDecoderUnitH264 *unit)
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
{
GstVaapiDecoderStatus status;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
switch (unit->nalu.type) {
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
case GST_H264_NAL_SLICE_IDR:
/* fall-through. IDR specifics are handled in init_picture() */
case GST_H264_NAL_SLICE:
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
status = decode_slice(decoder, unit);
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
break;
case GST_H264_NAL_SEQ_END:
status = decode_sequence_end(decoder);
break;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
case GST_H264_NAL_SEI:
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
break;
default:
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GST_WARNING("unsupported NAL unit type %d", unit->nalu.type);
h264: add decode_nalu() helper function. Split decode_buffer() into the core infrastructure that determines the NAL units contained in the adapter and the actual function that decodes the NAL unit.
2012-10-10 08:35:20 +00:00
status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
break;
}
return status;
}
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
static GstVaapiDecoderStatus
decode_codec_data(GstVaapiDecoderH264 *decoder, GstBuffer *buffer)
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
GstVaapiDecoderStatus status;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GstVaapiDecoderUnitH264 unit;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
GstH264ParserResult result;
guchar *buf;
guint buf_size;
guint i, ofs, num_sps, num_pps;
buf = GST_BUFFER_DATA(buffer);
buf_size = GST_BUFFER_SIZE(buffer);
if (!buf || buf_size == 0)
return GST_VAAPI_DECODER_STATUS_SUCCESS;
if (buf_size < 8)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
if (buf[0] != 1) {
h264: review and report errors accordingly. Use GST_ERROR() to report real errors instead of hiding them into GST_DEBUG().
2012-09-21 14:43:38 +00:00
GST_ERROR("failed to decode codec-data, not in avcC format");
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
return GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
}
priv->nal_length_size = (buf[4] & 0x03) + 1;
num_sps = buf[5] & 0x1f;
ofs = 6;
for (i = 0; i < num_sps; i++) {
result = gst_h264_parser_identify_nalu_avc(
priv->parser,
buf, ofs, buf_size, 2,
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
&unit.nalu
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
);
if (result != GST_H264_PARSER_OK)
return get_status(result);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
status = parse_sps(decoder, &unit);
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
ofs = unit.nalu.offset + unit.nalu.size;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
}
num_pps = buf[ofs];
ofs++;
for (i = 0; i < num_pps; i++) {
result = gst_h264_parser_identify_nalu_avc(
priv->parser,
buf, ofs, buf_size, 2,
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
&unit.nalu
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
);
if (result != GST_H264_PARSER_OK)
return get_status(result);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
status = parse_pps(decoder, &unit);
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
ofs = unit.nalu.offset + unit.nalu.size;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
}
h264: handle avcC format for decoding buffers.
2012-01-17 09:42:49 +00:00
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
priv->is_avcC = TRUE;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
}
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
static GstVaapiDecoderStatus
ensure_decoder(GstVaapiDecoderH264 *decoder)
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
{
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
GstVaapiDecoderStatus status;
GstBuffer *codec_data;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
g_return_val_if_fail(priv->is_constructed,
GST_VAAPI_DECODER_STATUS_ERROR_INIT_FAILED);
if (!priv->is_opened) {
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
priv->is_opened = gst_vaapi_decoder_h264_open(decoder);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
if (!priv->is_opened)
return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC;
h264: handle codec-data. Signed-off-by: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
2011-11-25 12:37:00 +00:00
codec_data = GST_VAAPI_DECODER_CODEC_DATA(decoder);
if (codec_data) {
status = decode_codec_data(decoder, codec_data);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
}
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
}
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
static GstVaapiDecoderStatus
gst_vaapi_decoder_h264_parse(GstVaapiDecoder *base_decoder,
GstAdapter *adapter, gboolean at_eos, GstVaapiDecoderUnit **unit_ptr)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder =
GST_VAAPI_DECODER_H264_CAST(base_decoder);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
GstVaapiDecoderH264Private * const priv = decoder->priv;
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
GstVaapiParserState * const ps = GST_VAAPI_PARSER_STATE(base_decoder);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
GstVaapiDecoderUnitH264 *unit;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
GstVaapiDecoderStatus status;
GstH264ParserResult result;
guchar *buf;
guint i, size, buf_size, nalu_size, flags;
guint32 start_code;
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
gint ofs, ofs2;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
status = ensure_decoder(decoder);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
size = gst_adapter_available(adapter);
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
if (priv->is_avcC) {
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
if (size < priv->nal_length_size)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
buf = (guchar *)&start_code;
g_assert(priv->nal_length_size <= sizeof(start_code));
gst_adapter_copy(adapter, buf, 0, priv->nal_length_size);
nalu_size = 0;
for (i = 0; i < priv->nal_length_size; i++)
nalu_size = (nalu_size << 8) | buf[i];
buf_size = priv->nal_length_size + nalu_size;
if (size < buf_size)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
}
else {
if (size < 4)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
ofs = scan_for_start_code(adapter, 0, size, NULL);
if (ofs < 0)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
if (ofs > 0) {
gst_adapter_flush(adapter, ofs);
size -= ofs;
}
ofs2 = ps->input_offset2 - ofs - 4;
if (ofs2 < 4)
ofs2 = 4;
ofs = G_UNLIKELY(size < ofs2 + 4) ? -1 :
scan_for_start_code(adapter, ofs2, size - ofs2, NULL);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
if (ofs < 0) {
// Assume the whole NAL unit is present if end-of-stream
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
if (!at_eos) {
ps->input_offset2 = size;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
}
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
ofs = size;
}
buf_size = ofs;
}
h264: optimize scan for the second start code. Optimize scan for the second start code, on the next parse() call so that to avoid scanning again earlier bytes where we didn't find any start code.
2012-12-12 17:33:52 +00:00
ps->input_offset2 = 0;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
buf = (guchar *)gst_adapter_peek(adapter, buf_size);
if (!buf)
return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
unit = gst_vaapi_decoder_unit_h264_new(buf_size);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
if (!unit)
return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
if (priv->is_avcC)
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
result = gst_h264_parser_identify_nalu_avc(priv->parser,
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
buf, 0, buf_size, priv->nal_length_size, &unit->nalu);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
else
result = gst_h264_parser_identify_nalu_unchecked(priv->parser,
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
buf, 0, buf_size, &unit->nalu);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
status = get_status(result);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) {
gst_vaapi_decoder_unit_unref(unit);
return status;
}
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
switch (unit->nalu.type) {
case GST_H264_NAL_SPS:
status = parse_sps(decoder, unit);
break;
case GST_H264_NAL_PPS:
status = parse_pps(decoder, unit);
break;
case GST_H264_NAL_SEI:
status = parse_sei(decoder, unit);
break;
case GST_H264_NAL_SLICE_IDR:
case GST_H264_NAL_SLICE:
status = parse_slice(decoder, unit);
break;
default:
status = GST_VAAPI_DECODER_STATUS_SUCCESS;
break;
}
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
flags = 0;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
switch (unit->nalu.type) {
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
case GST_H264_NAL_AU_DELIMITER:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
/* fall-through */
case GST_H264_NAL_FILLER_DATA:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SKIP;
break;
case GST_H264_NAL_STREAM_END:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_STREAM_END;
/* fall-through */
case GST_H264_NAL_SEQ_END:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END;
break;
case GST_H264_NAL_SPS:
case GST_H264_NAL_PPS:
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SKIP;
/* fall-through */
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
case GST_H264_NAL_SEI:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
break;
case GST_H264_NAL_SLICE_IDR:
case GST_H264_NAL_SLICE:
flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
if (is_new_picture(unit, priv->prev_slice_unit))
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
h264: detect new pictures from decode-units. Update is_new_picture() to cope with GstVaapiDecoderUnitH264, instead of assuming frame boundaries when first_mb_in_slice is zero.
2012-12-13 09:47:25 +00:00
gst_vaapi_decoder_unit_replace(&priv->prev_slice_unit, unit);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
break;
default:
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
if (unit->nalu.type >= 14 && unit->nalu.type <= 18)
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
break;
}
GST_VAAPI_DECODER_UNIT_FLAG_SET(unit, flags);
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
unit->nalu.data = NULL;
*unit_ptr = &unit->base;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
return GST_VAAPI_DECODER_STATUS_SUCCESS;
}
static GstVaapiDecoderStatus
gst_vaapi_decoder_h264_decode(GstVaapiDecoder *base_decoder,
GstVaapiDecoderUnit *unit)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder =
GST_VAAPI_DECODER_H264_CAST(base_decoder);
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
GstVaapiDecoderStatus status;
status = ensure_decoder(decoder);
if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
return status;
h264: add codec specific decoder unit. Introduce new GstVaapiDecoderUnitH264 object, which holds the standard NAL unit header (GstH264NalUnit) and additional parsed header info. Besides, we now parse headers as early as in the _parse() function so that to avoid un-necessary creation of sub-buffers in _decode() for NAL units that are not slices. This is a performance win by ~+1.1% only.
2012-12-06 16:25:01 +00:00
return decode_unit(decoder, (GstVaapiDecoderUnitH264 *)unit);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
static GstVaapiDecoderStatus
gst_vaapi_decoder_h264_start_frame(GstVaapiDecoder *base_decoder,
GstVaapiDecoderUnit *base_unit)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder =
GST_VAAPI_DECODER_H264_CAST(base_decoder);
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
GstVaapiDecoderUnitH264 * const unit = (GstVaapiDecoderUnitH264 *)base_unit;
return decode_picture(decoder, unit);
}
static GstVaapiDecoderStatus
gst_vaapi_decoder_h264_end_frame(GstVaapiDecoder *base_decoder)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder =
GST_VAAPI_DECODER_H264_CAST(base_decoder);
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
return decode_current_picture(decoder);
}
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
static void
gst_vaapi_decoder_h264_finalize(GObject *object)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder = GST_VAAPI_DECODER_H264_CAST(object);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
gst_vaapi_decoder_h264_destroy(decoder);
G_OBJECT_CLASS(gst_vaapi_decoder_h264_parent_class)->finalize(object);
}
static void
gst_vaapi_decoder_h264_constructed(GObject *object)
{
h264: minor clean-ups. Drop explicit initialization of most fields that are implicitly set to zero. Drop helper macros for casting to GstVaapiPictureH264 or GstVaapiFrameStore. Also remove some useless checks for NULL pointers.
2012-12-13 10:48:06 +00:00
GstVaapiDecoderH264 * const decoder = GST_VAAPI_DECODER_H264_CAST(object);
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
GstVaapiDecoderH264Private * const priv = decoder->priv;
GObjectClass *parent_class;
parent_class = G_OBJECT_CLASS(gst_vaapi_decoder_h264_parent_class);
if (parent_class->constructed)
parent_class->constructed(object);
priv->is_constructed = gst_vaapi_decoder_h264_create(decoder);
}
static void
gst_vaapi_decoder_h264_class_init(GstVaapiDecoderH264Class *klass)
{
GObjectClass * const object_class = G_OBJECT_CLASS(klass);
GstVaapiDecoderClass * const decoder_class = GST_VAAPI_DECODER_CLASS(klass);
g_type_class_add_private(klass, sizeof(GstVaapiDecoderH264Private));
object_class->finalize = gst_vaapi_decoder_h264_finalize;
object_class->constructed = gst_vaapi_decoder_h264_constructed;
h264: initial port to new GstVaapiDecoder API
2012-12-06 13:02:17 +00:00
decoder_class->parse = gst_vaapi_decoder_h264_parse;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
decoder_class->decode = gst_vaapi_decoder_h264_decode;
h264: implement {start,end}_frame() hooks. Implement GstVaapiDecoder.start_frame() and end_frame() semantics so that to create new VA context earlier and submit VA pictures to the HW for decoding as soon as possible. i.e. don't wait for the next frame to start decoding the previous one.
2012-12-13 09:21:46 +00:00
decoder_class->start_frame = gst_vaapi_decoder_h264_start_frame;
decoder_class->end_frame = gst_vaapi_decoder_h264_end_frame;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
static void
gst_vaapi_decoder_h264_init(GstVaapiDecoderH264 *decoder)
{
GstVaapiDecoderH264Private *priv;
priv = GST_VAAPI_DECODER_H264_GET_PRIVATE(decoder);
decoder->priv = priv;
h264: fix activation order of picture and sequence parameters. Delay ensure_context() until we actually need a VA context for allocating new VA surfaces, and then GstVaapiPictures, but also when a real activation of a new picture parameter set occurs, thus also implying an activation of the related sequence parameter set. The most important thing was to drop the global pps and sps pointers since they may not have matched the currently activated picture parameter or sequence parameter sets at the specified decode point. Anoter positive side-effect is that this cleans up all occurrences of decode_current_picture() to only keep those useful in decode_picture(), before a new picture is allocated, or in decode_sequence_end() when an end-of-stream or end-of-sequence condition occurred.
2012-10-26 14:12:05 +00:00
priv->profile = GST_VAAPI_PROFILE_UNKNOWN;
priv->entrypoint = GST_VAAPI_ENTRYPOINT_VLD;
priv->chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420;
h264: fill in GstVaapiPicture structure. ... and get rid of local VAPictureH264.flags fields in GstVaapiPictureH264.
2012-10-31 09:56:15 +00:00
priv->prev_pic_structure = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
h264: add initial support for interlaced streams. Decoded frames are only output when they are complete, i.e. when both fields are decoded. This also means that the "interlaced" caps is not propagated to vaapipostproc or vaapisink elements. Another limitation is that interlaced bitstreams with MMCO are unlikely to work.
2012-11-13 16:14:39 +00:00
priv->progressive_sequence = TRUE;
Add initial H.264 decoder.
2011-08-12 15:43:55 +00:00
}
/**
* gst_vaapi_decoder_h264_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_h264_new(GstVaapiDisplay *display, GstCaps *caps)
{
GstVaapiDecoderH264 *decoder;
g_return_val_if_fail(GST_VAAPI_IS_DISPLAY(display), NULL);
g_return_val_if_fail(GST_IS_CAPS(caps), NULL);
decoder = g_object_new(
GST_VAAPI_TYPE_DECODER_H264,
"display", display,
"caps", caps,
NULL
);
if (!decoder->priv->is_constructed) {
g_object_unref(decoder);
return NULL;
}
return GST_VAAPI_DECODER_CAST(decoder);
}
Reference in a new issue Copy permalink