mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 20:21:24 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/h264parse/gsth264parse.c
Alessandro Decina a17393fd34 Fix warnings with gcc 4.0.1.
2009-09-23 12:34:47 +02:00

1742 lines
52 KiB
C
Raw Blame History

/* GStreamer h264 parser
* Copyright (C) 2005 Michal Benes <michal.benes@itonis.tv>
* (C) 2008 Wim Taymans <wim.taymans@gmail.com>
*
* gsth264parse.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "gsth264parse.h"
static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/x-h264"));
static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/x-h264"));
GST_DEBUG_CATEGORY_STATIC (h264_parse_debug);
#define GST_CAT_DEFAULT h264_parse_debug
static const GstElementDetails gst_h264_parse_details =
GST_ELEMENT_DETAILS ("H264Parse",
"Codec/Parser/Video",
"Parses raw h264 stream",
"Michal Benes <michal.benes@itonis.tv>,"
"Wim Taymans <wim.taymans@gmail.com>");
#define DEFAULT_SPLIT_PACKETIZED FALSE
enum
{
PROP_0,
PROP_SPLIT_PACKETIZED
};
typedef enum
{
NAL_UNKNOWN = 0,
NAL_SLICE = 1,
NAL_SLICE_DPA = 2,
NAL_SLICE_DPB = 3,
NAL_SLICE_DPC = 4,
NAL_SLICE_IDR = 5,
NAL_SEI = 6,
NAL_SPS = 7,
NAL_PPS = 8,
NAL_AU_DELIMITER = 9,
NAL_SEQ_END = 10,
NAL_STREAM_END = 11,
NAL_FILTER_DATA = 12
} GstNalUnitType;
/* small linked list implementation to allocate the list entry and the data in
* one go */
struct _GstNalList
{
GstNalList *next;
gint nal_type;
gint nal_ref_idc;
gint first_mb_in_slice;
gint slice_type;
gboolean slice;
gboolean i_frame;
GstBuffer *buffer;
};
static GstNalList *
gst_nal_list_new (GstBuffer * buffer)
{
GstNalList *new_list;
new_list = g_slice_new0 (GstNalList);
new_list->buffer = buffer;
return new_list;
}
static GstNalList *
gst_nal_list_prepend_link (GstNalList * list, GstNalList * link)
{
link->next = list;
return link;
}
static GstNalList *
gst_nal_list_delete_head (GstNalList * list)
{
if (list) {
GstNalList *old = list;
list = list->next;
g_slice_free (GstNalList, old);
}
return list;
}
/* simple bitstream parser, automatically skips over
* emulation_prevention_three_bytes. */
typedef struct
{
const guint8 *data;
const guint8 *end;
gint head; /* bitpos in the cache of next bit */
guint64 cache; /* cached bytes */
} GstNalBs;
static void
gst_nal_bs_init (GstNalBs * bs, const guint8 * data, guint size)
{
bs->data = data;
bs->end = data + size;
bs->head = 0;
/* fill with something other than 0 to detect emulation prevention bytes */
bs->cache = 0xffffffff;
}
static guint32
gst_nal_bs_read (GstNalBs * bs, guint n)
{
guint32 res = 0;
gint shift;
if (n == 0)
return res;
/* fill up the cache if we need to */
while (bs->head < n) {
guint8 byte;
gboolean check_three_byte;
check_three_byte = TRUE;
next_byte:
if (bs->data >= bs->end) {
/* we're at the end, can't produce more than head number of bits */
n = bs->head;
break;
}
/* get the byte, this can be an emulation_prevention_three_byte that we need
* to ignore. */
byte = *bs->data++;
if (check_three_byte && byte == 0x03 && ((bs->cache & 0xffff) == 0)) {
/* next byte goes unconditionally to the cache, even if it's 0x03 */
check_three_byte = FALSE;
goto next_byte;
}
/* shift bytes in cache, moving the head bits of the cache left */
bs->cache = (bs->cache << 8) | byte;
bs->head += 8;
}
/* bring the required bits down and truncate */
if ((shift = bs->head - n) > 0)
res = bs->cache >> shift;
else
res = bs->cache;
/* mask out required bits */
if (n < 32)
res &= (1 << n) - 1;
bs->head = shift;
return res;
}
static gboolean
gst_nal_bs_eos (GstNalBs * bs)
{
return (bs->data >= bs->end) && (bs->head == 0);
}
/* read unsigned Exp-Golomb code */
static gint
gst_nal_bs_read_ue (GstNalBs * bs)
{
gint i = 0;
while (gst_nal_bs_read (bs, 1) == 0 && !gst_nal_bs_eos (bs) && i < 32)
i++;
return ((1 << i) - 1 + gst_nal_bs_read (bs, i));
}
/* SEI type */
typedef enum
{
SEI_BUF_PERIOD = 0,
SEI_PIC_TIMING = 1
/* and more... */
} GstSeiPayloadType;
/* SEI pic_struct type */
typedef enum
{
SEI_PIC_STRUCT_FRAME = 0, /* 0: %frame */
SEI_PIC_STRUCT_TOP_FIELD = 1, /* 1: top field */
SEI_PIC_STRUCT_BOTTOM_FIELD = 2, /* 2: bottom field */
SEI_PIC_STRUCT_TOP_BOTTOM = 3, /* 3: top field, bottom field, in that order */
SEI_PIC_STRUCT_BOTTOM_TOP = 4, /* 4: bottom field, top field, in that order */
SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5, /* 5: top field, bottom field, top field repeated, in that order */
SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, /* 6: bottom field, top field, bottom field repeated, in that order */
SEI_PIC_STRUCT_FRAME_DOUBLING = 7, /* 7: %frame doubling */
SEI_PIC_STRUCT_FRAME_TRIPLING = 8 /* 8: %frame tripling */
} GstSeiPicStructType;
/* pic_struct to NumClockTS lookup table */
static const guint8 sei_num_clock_ts_table[9] = {
1, 1, 1, 2, 2, 3, 3, 2, 3
};
#define Extended_SAR 255
/* SPS: sequential parameter sets */
struct _GstH264Sps
{
guint8 profile_idc;
guint8 level_idc;
guint8 sps_id;
guint8 pic_order_cnt_type;
guint8 log2_max_frame_num_minus4;
gboolean frame_mbs_only_flag;
guint8 log2_max_pic_order_cnt_lsb_minus4;
gboolean frame_cropping_flag;
/* VUI parameters */
gboolean vui_parameters_present_flag;
gboolean timing_info_present_flag;
guint32 num_units_in_tick;
guint32 time_scale;
gboolean fixed_frame_rate_flag;
gboolean nal_hrd_parameters_present_flag;
gboolean vcl_hrd_parameters_present_flag;
/* hrd parameters */
guint8 cpb_cnt_minus1;
gint initial_cpb_removal_delay_length_minus1; /* initial_cpb_removal_delay_length_minus1 */
gint cpb_removal_delay_length_minus1; /* cpb_removal_delay_length_minus1 */
gint dpb_output_delay_length_minus1; /* dpb_output_delay_length_minus1 */
gboolean time_offset_length_minus1;
gboolean pic_struct_present_flag;
/* And more... */
};
/* PPS: pic parameter sets */
struct _GstH264Pps
{
guint8 pps_id;
guint8 sps_id;
};
static GstH264Sps *
gst_h264_parse_get_sps (GstH264Parse * h, guint8 sps_id)
{
GstH264Sps *sps;
g_return_val_if_fail (h != NULL, NULL);
if (sps_id >= MAX_SPS_COUNT) {
GST_DEBUG_OBJECT (h, "requested sps_id=%04x out of range", sps_id);
return NULL;
}
sps = h->sps_buffers[sps_id];
if (sps == NULL) {
GST_DEBUG_OBJECT (h, "Creating sps with sps_id=%04x", sps_id);
sps = h->sps_buffers[sps_id] = g_slice_new0 (GstH264Sps);
if (sps == NULL) {
GST_DEBUG_OBJECT (h, "Allocation failed!");
}
}
h->sps = h->sps_buffers[sps_id] = sps;
return sps;
}
static GstH264Pps *
gst_h264_parse_get_pps (GstH264Parse * h, guint8 pps_id)
{
GstH264Pps *pps;
g_return_val_if_fail (h != NULL, NULL);
if (pps_id >= MAX_PPS_COUNT) {
GST_DEBUG_OBJECT (h, "requested pps_id=%04x out of range", pps_id);
return NULL;
}
pps = h->pps_buffers[pps_id];
if (pps == NULL) {
GST_DEBUG_OBJECT (h, "Creating pps with pps_id=%04x", pps_id);
pps = g_slice_new0 (GstH264Pps);
if (pps == NULL) {
GST_DEBUG_OBJECT (h, "Failed!");
}
}
h->pps = h->pps_buffers[pps_id] = pps;
return pps;
}
/* decode hrd parameters */
static gboolean
gst_vui_decode_hrd_parameters (GstH264Parse * h, GstNalBs * bs)
{
GstH264Sps *sps = h->sps;
gint sched_sel_idx;
sps->cpb_cnt_minus1 = gst_nal_bs_read_ue (bs);
if (sps->cpb_cnt_minus1 > 31U) {
GST_ERROR_OBJECT (h, "cpb_cnt_minus1 = %d out of range",
sps->cpb_cnt_minus1);
return FALSE;
}
gst_nal_bs_read (bs, 4); /* bit_rate_scale */
gst_nal_bs_read (bs, 4); /* cpb_size_scale */
for (sched_sel_idx = 0; sched_sel_idx <= sps->cpb_cnt_minus1; sched_sel_idx++) {
gst_nal_bs_read_ue (bs); /* bit_rate_value_minus1 */
gst_nal_bs_read_ue (bs); /* cpb_size_value_minus1 */
gst_nal_bs_read (bs, 1); /* cbr_flag */
}
sps->initial_cpb_removal_delay_length_minus1 = gst_nal_bs_read (bs, 5);
sps->cpb_removal_delay_length_minus1 = gst_nal_bs_read (bs, 5);
sps->dpb_output_delay_length_minus1 = gst_nal_bs_read (bs, 5);
sps->time_offset_length_minus1 = gst_nal_bs_read (bs, 5);
return TRUE;
}
/* decode vui parameters */
static gboolean
gst_sps_decode_vui (GstH264Parse * h, GstNalBs * bs)
{
GstH264Sps *sps = h->sps;
if (gst_nal_bs_read (bs, 1)) { /* aspect_ratio_info_present_flag */
if (gst_nal_bs_read (bs, 8) == Extended_SAR) { /* aspect_ratio_idc */
gst_nal_bs_read (bs, 16); /* sar_width */
gst_nal_bs_read (bs, 16); /* sar_height */
}
}
if (gst_nal_bs_read (bs, 1)) { /* overscan_info_present_flag */
gst_nal_bs_read (bs, 1); /* overscan_appropriate_flag */
}
if (gst_nal_bs_read (bs, 1)) { /* video_signal_type_present_flag */
gst_nal_bs_read (bs, 3); /* video_format */
gst_nal_bs_read (bs, 1); /* video_full_range_flag */
if (gst_nal_bs_read (bs, 1)) { /* colour_description_present_flag */
gst_nal_bs_read (bs, 8); /* colour_primaries */
gst_nal_bs_read (bs, 8); /* transfer_characteristics */
gst_nal_bs_read (bs, 8); /* matrix_coefficients */
}
}
if (gst_nal_bs_read (bs, 1)) { /* chroma_loc_info_present_flag */
gst_nal_bs_read_ue (bs); /* chroma_sample_loc_type_top_field */
gst_nal_bs_read_ue (bs); /* chroma_sample_loc_type_bottom_field */
}
/*
GST_DEBUG_OBJECT (h,
"aspect_ratio_info_present_flag = %d, "
"overscan_info_present_flag = %d, "
"video_signal_type_present_flag = %d, "
"chroma_loc_info_present_flag = %d\n",
sps->aspect_ratio_info_present_flag, sps->overscan_info_present_flag,
sps->video_signal_type_present_flag, sps->chroma_loc_info_present_flag);
*/
sps->timing_info_present_flag = gst_nal_bs_read (bs, 1);
if (sps->timing_info_present_flag) {
guint32 num_units_in_tick = gst_nal_bs_read (bs, 32);
guint32 time_scale = gst_nal_bs_read (bs, 32);
/* If any of these parameters = 0, discard all timing_info */
if (time_scale == 0) {
GST_WARNING_OBJECT (h,
"time_scale = 0 detected in stream (incompliant to H.264 E.2.1)."
" Discarding related info.");
} else if (num_units_in_tick == 0) {
GST_WARNING_OBJECT (h,
"num_units_in_tick = 0 detected in stream (incompliant to H.264 E.2.1)."
" Discarding related info.");
} else {
sps->num_units_in_tick = num_units_in_tick;
sps->time_scale = time_scale;
sps->fixed_frame_rate_flag = gst_nal_bs_read (bs, 1);
}
GST_DEBUG_OBJECT (h,
"num_units_in_tick = %d, time_scale = %d, "
"fixed_frame_rate_flag = %d\n",
sps->num_units_in_tick, sps->time_scale, sps->fixed_frame_rate_flag);
}
sps->nal_hrd_parameters_present_flag = gst_nal_bs_read (bs, 1);
if (sps->nal_hrd_parameters_present_flag) {
gst_vui_decode_hrd_parameters (h, bs);
}
sps->vcl_hrd_parameters_present_flag = gst_nal_bs_read (bs, 1);
if (sps->vcl_hrd_parameters_present_flag) {
gst_vui_decode_hrd_parameters (h, bs);
}
if (sps->nal_hrd_parameters_present_flag
|| sps->vcl_hrd_parameters_present_flag) {
gst_nal_bs_read (bs, 1); /* low_delay_hrd_flag */
}
sps->pic_struct_present_flag = gst_nal_bs_read (bs, 1);
#if 0
/* Not going down anymore */
if (gst_nal_bs_read (bs, 1)) { /* bitstream_restriction_flag */
gst_nal_bs_read (bs, 1); /* motion_vectors_over_pic_boundaries_flag */
gst_nal_bs_read_ue (bs); /* max_bytes_per_pic_denom */
gst_nal_bs_read_ue (bs); /* max_bits_per_mb_denom */
gst_nal_bs_read_ue (bs); /* log2_max_mv_length_horizontal */
gst_nal_bs_read_ue (bs); /* log2_max_mv_length_vertical */
gst_nal_bs_read_ue (bs); /* num_reorder_frames */
gst_nal_bs_read_ue (bs); /* max_dec_frame_buffering */
}
#endif
return TRUE;
}
/* decode sequential parameter sets */
static gboolean
gst_nal_decode_sps (GstH264Parse * h, GstNalBs * bs)
{
guint8 profile_idc, level_idc;
guint8 sps_id;
GstH264Sps *sps = NULL;
profile_idc = gst_nal_bs_read (bs, 8);
gst_nal_bs_read (bs, 1); /* constraint_set0_flag */
gst_nal_bs_read (bs, 1); /* constraint_set1_flag */
gst_nal_bs_read (bs, 1); /* constraint_set2_flag */
gst_nal_bs_read (bs, 1); /* constraint_set3_flag */
gst_nal_bs_read (bs, 4); /* reserved */
level_idc = gst_nal_bs_read (bs, 8);
sps_id = gst_nal_bs_read_ue (bs);
sps = gst_h264_parse_get_sps (h, sps_id);
if (sps == NULL) {
return FALSE;
}
sps->profile_idc = profile_idc;
sps->level_idc = level_idc;
if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122
|| profile_idc == 244 || profile_idc == 44 ||
profile_idc == 83 || profile_idc == 86) {
if (gst_nal_bs_read_ue (bs) == 3) { /* chroma_format_idc */
gst_nal_bs_read (bs, 1); /* separate_colour_plane_flag */
}
gst_nal_bs_read_ue (bs); /* bit_depth_luma_minus8 */
gst_nal_bs_read_ue (bs); /* bit_depth_chroma_minus8 */
gst_nal_bs_read (bs, 1); /* qpprime_y_zero_transform_bypass_flag */
if (gst_nal_bs_read (bs, 1)) { /* seq_scaling_matrix_present_flag */
/* TODO: unfinished */
}
}
sps->log2_max_frame_num_minus4 = gst_nal_bs_read_ue (bs); /* between 0 and 12 */
if (sps->log2_max_frame_num_minus4 > 12) {
GST_DEBUG_OBJECT (h, "log2_max_frame_num_minus4 = %d out of range"
" [0,12]", sps->log2_max_frame_num_minus4);
return FALSE;
}
sps->pic_order_cnt_type = gst_nal_bs_read_ue (bs);
if (sps->pic_order_cnt_type == 0) {
sps->log2_max_pic_order_cnt_lsb_minus4 = gst_nal_bs_read_ue (bs);
} else if (sps->pic_order_cnt_type == 1) {
/* TODO: unfinished */
/*
delta_pic_order_always_zero_flag = gst_nal_bs_read (bs, 1);
offset_for_non_ref_pic = gst_nal_bs_read_se (bs);
offset_for_top_to_bottom_field = gst_nal_bs_read_se (bs);
num_ref_frames_in_pic_order_cnt_cycle = gst_nal_bs_read_ue (bs);
for( i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++ )
offset_for_ref_frame[i] = gst_nal_bs_read_se (bs);
*/
}
gst_nal_bs_read_ue (bs); /* max_num_ref_frames */
gst_nal_bs_read (bs, 1); /* gaps_in_frame_num_value_allowed_flag */
gst_nal_bs_read_ue (bs); /* pic_width_in_mbs_minus1 */
gst_nal_bs_read_ue (bs); /* pic_height_in_map_units_minus1 */
sps->frame_mbs_only_flag = gst_nal_bs_read (bs, 1);
if (!sps->frame_mbs_only_flag) {
gst_nal_bs_read (bs, 1); /* mb_adaptive_frame_field_flag */
}
gst_nal_bs_read (bs, 1); /* direct_8x8_inference_flag */
if (gst_nal_bs_read (bs, 1)) { /* frame_cropping_flag */
gst_nal_bs_read_ue (bs); /* frame_crop_left_offset */
gst_nal_bs_read_ue (bs); /* frame_crop_right_offset */
gst_nal_bs_read_ue (bs); /* frame_crop_top_offset */
gst_nal_bs_read_ue (bs); /* frame_crop_bottom_offset */
}
GST_DEBUG_OBJECT (h, "Decoding SPS: profile_idc = %d, "
"level_idc = %d, "
"sps_id = %d, "
"pic_order_cnt_type = %d, "
"frame_mbs_only_flag = %d\n",
sps->profile_idc,
sps->level_idc,
sps_id, sps->pic_order_cnt_type, sps->frame_mbs_only_flag);
sps->vui_parameters_present_flag = gst_nal_bs_read (bs, 1);
if (sps->vui_parameters_present_flag) {
gst_sps_decode_vui (h, bs);
}
return TRUE;
}
/* decode pic parameter set */
static gboolean
gst_nal_decode_pps (GstH264Parse * h, GstNalBs * bs)
{
guint8 pps_id;
GstH264Pps *pps = NULL;
pps_id = gst_nal_bs_read_ue (bs);
pps = gst_h264_parse_get_pps (h, pps_id);
if (pps == NULL) {
return FALSE;
}
h->pps = pps;
pps->sps_id = gst_nal_bs_read_ue (bs);
/* not parsing the rest for the time being */
return TRUE;
}
/* decode buffering periods */
static gboolean
gst_sei_decode_buffering_period (GstH264Parse * h, GstNalBs * bs)
{
guint8 sps_id;
gint sched_sel_idx;
GstH264Sps *sps;
sps_id = gst_nal_bs_read_ue (bs);
sps = gst_h264_parse_get_sps (h, sps_id);
if (!sps)
return FALSE;
if (sps->nal_hrd_parameters_present_flag) {
for (sched_sel_idx = 0; sched_sel_idx <= sps->cpb_cnt_minus1;
sched_sel_idx++) {
h->initial_cpb_removal_delay[sched_sel_idx]
= gst_nal_bs_read (bs,
sps->initial_cpb_removal_delay_length_minus1 + 1);
gst_nal_bs_read (bs, sps->initial_cpb_removal_delay_length_minus1 + 1); /* initial_cpb_removal_delay_offset */
}
}
if (sps->vcl_hrd_parameters_present_flag) {
for (sched_sel_idx = 0; sched_sel_idx <= sps->cpb_cnt_minus1;
sched_sel_idx++) {
h->initial_cpb_removal_delay[sched_sel_idx]
= gst_nal_bs_read (bs,
sps->initial_cpb_removal_delay_length_minus1 + 1);
gst_nal_bs_read (bs, sps->initial_cpb_removal_delay_length_minus1 + 1); /* initial_cpb_removal_delay_offset */
}
}
#if 0
h->ts_trn_nb = MPEGTIME_TO_GSTTIME (h->initial_cpb_removal_delay[0]); /* Assuming SchedSelIdx=0 */
#endif
if (h->ts_trn_nb == GST_CLOCK_TIME_NONE || h->dts == GST_CLOCK_TIME_NONE)
h->ts_trn_nb = 0;
else
h->ts_trn_nb = h->dts;
GST_DEBUG_OBJECT (h, "h->ts_trn_nb updated: %" GST_TIME_FORMAT,
GST_TIME_ARGS (h->ts_trn_nb));
return 0;
}
/* decode SEI picture timing message */
static gboolean
gst_sei_decode_picture_timing (GstH264Parse * h, GstNalBs * bs)
{
GstH264Sps *sps = h->sps;
if (sps == NULL) {
GST_WARNING_OBJECT (h, "h->sps=NULL; delayed decoding of picture timing "
"info not implemented yet");
return FALSE;
}
if (sps->nal_hrd_parameters_present_flag
|| sps->vcl_hrd_parameters_present_flag) {
h->sei_cpb_removal_delay =
gst_nal_bs_read (bs, sps->cpb_removal_delay_length_minus1 + 1);
h->sei_dpb_output_delay =
gst_nal_bs_read (bs, sps->dpb_output_delay_length_minus1 + 1);
}
if (sps->pic_struct_present_flag) {
guint i, num_clock_ts;
h->sei_pic_struct = gst_nal_bs_read (bs, 4);
h->sei_ct_type = 0;
if (h->sei_pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)
return FALSE;
num_clock_ts = sei_num_clock_ts_table[h->sei_pic_struct];
for (i = 0; i < num_clock_ts; i++) {
if (gst_nal_bs_read (bs, 1)) { /* clock_timestamp_flag */
guint full_timestamp_flag;
h->sei_ct_type |= 1 << gst_nal_bs_read (bs, 2);
gst_nal_bs_read (bs, 1); /* nuit_field_based_flag */
gst_nal_bs_read (bs, 5); /* counting_type */
full_timestamp_flag = gst_nal_bs_read (bs, 1);
gst_nal_bs_read (bs, 1); /* discontinuity_flag */
gst_nal_bs_read (bs, 1); /* cnt_dropped_flag */
gst_nal_bs_read (bs, 8); /* n_frames */
if (full_timestamp_flag) {
gst_nal_bs_read (bs, 6); /* seconds_value 0..59 */
gst_nal_bs_read (bs, 6); /* minutes_value 0..59 */
gst_nal_bs_read (bs, 5); /* hours_value 0..23 */
} else {
if (gst_nal_bs_read (bs, 1)) { /* seconds_flag */
gst_nal_bs_read (bs, 6); /* seconds_value range 0..59 */
if (gst_nal_bs_read (bs, 1)) { /* minutes_flag */
gst_nal_bs_read (bs, 6); /* minutes_value 0..59 */
if (gst_nal_bs_read (bs, 1)) /* hours_flag */
gst_nal_bs_read (bs, 5); /* hours_value 0..23 */
}
}
}
if (sps->time_offset_length_minus1 >= 0)
gst_nal_bs_read (bs, sps->time_offset_length_minus1 + 1); /* time_offset */
}
}
GST_DEBUG_OBJECT (h, "ct_type:%X pic_struct:%d\n", h->sei_ct_type,
h->sei_pic_struct);
}
return 0;
}
/* decode supplimental enhancement information */
static gboolean
gst_nal_decode_sei (GstH264Parse * h, GstNalBs * bs)
{
guint8 tmp;
GstSeiPayloadType payloadType = 0;
gint8 payloadSize = 0;
do {
tmp = gst_nal_bs_read (bs, 8);
payloadType += tmp;
} while (tmp == 255);
do {
tmp = gst_nal_bs_read (bs, 8);
payloadSize += tmp;
} while (tmp == 255);
GST_DEBUG_OBJECT (h,
"SEI message received: payloadType = %d, payloadSize = %d bytes",
payloadType, payloadSize);
switch (payloadType) {
case SEI_BUF_PERIOD:
if (!gst_sei_decode_buffering_period (h, bs))
return FALSE;
break;
case SEI_PIC_TIMING:
/* TODO: According to H264 D2.2 Note1, it might be the case that the
* picture timing SEI message is encountered before the corresponding SPS
* is specified. Need to hold down the message and decode it later. */
if (!gst_sei_decode_picture_timing (h, bs))
return FALSE;
break;
default:
GST_DEBUG_OBJECT (h, "SEI message of payloadType = %d is recieved but not"
" parsed", payloadType);
}
return TRUE;
}
/* decode slice header */
static gboolean
gst_nal_decode_slice_header (GstH264Parse * h, GstNalBs * bs)
{
guint8 pps_id, sps_id;
h->first_mb_in_slice = gst_nal_bs_read_ue (bs);
h->slice_type = gst_nal_bs_read_ue (bs);
pps_id = gst_nal_bs_read_ue (bs);
h->pps = gst_h264_parse_get_pps (h, pps_id);
if (!h->pps)
return FALSE;
/* FIXME: note that pps might be uninitialized */
sps_id = h->pps->sps_id;
h->sps = gst_h264_parse_get_sps (h, sps_id);
/* FIXME: in some streams sps/pps may not be ready before the first slice
* header. In this case it is not a good idea to _get_sps()/_pps() at this
* point
* TODO: scan one round beforehand for SPS/PPS before decoding slice headers?
* */
/* TODO: separate_color_plane_flag: from SPS, not implemented yet, assumed to
* be false */
h->frame_num =
gst_nal_bs_read (bs, h->sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
if (!h->sps && !h->sps->frame_mbs_only_flag) {
h->field_pic_flag = gst_nal_bs_read (bs, 1);
if (h->field_pic_flag)
h->bottom_field_flag = gst_nal_bs_read (bs, 1);
}
/* not parsing the rest for the time being */
return TRUE;
}
GST_BOILERPLATE (GstH264Parse, gst_h264_parse, GstElement, GST_TYPE_ELEMENT);
static void gst_h264_parse_finalize (GObject * object);
static void gst_h264_parse_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_h264_parse_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstFlowReturn gst_h264_parse_chain (GstPad * pad, GstBuffer * buf);
static gboolean gst_h264_parse_sink_event (GstPad * pad, GstEvent * event);
static gboolean gst_h264_parse_sink_setcaps (GstPad * pad, GstCaps * caps);
static GstStateChangeReturn gst_h264_parse_change_state (GstElement * element,
GstStateChange transition);
static void
gst_h264_parse_base_init (gpointer g_class)
{
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&srctemplate));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&sinktemplate));
gst_element_class_set_details (gstelement_class, &gst_h264_parse_details);
GST_DEBUG_CATEGORY_INIT (h264_parse_debug, "h264parse", 0, "h264 parser");
}
static void
gst_h264_parse_class_init (GstH264ParseClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = G_OBJECT_CLASS (klass);
gstelement_class = (GstElementClass *) klass;
gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_h264_parse_finalize);
gobject_class->set_property = gst_h264_parse_set_property;
gobject_class->get_property = gst_h264_parse_get_property;
g_object_class_install_property (gobject_class, PROP_SPLIT_PACKETIZED,
g_param_spec_boolean ("split-packetized", "Split packetized",
"Split NAL units of packetized streams", DEFAULT_SPLIT_PACKETIZED,
G_PARAM_READWRITE));
gstelement_class->change_state = gst_h264_parse_change_state;
}
static void
gst_h264_parse_init (GstH264Parse * h264parse, GstH264ParseClass * g_class)
{
gint i;
h264parse->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink");
gst_pad_set_chain_function (h264parse->sinkpad,
GST_DEBUG_FUNCPTR (gst_h264_parse_chain));
gst_pad_set_event_function (h264parse->sinkpad,
GST_DEBUG_FUNCPTR (gst_h264_parse_sink_event));
gst_pad_set_setcaps_function (h264parse->sinkpad,
GST_DEBUG_FUNCPTR (gst_h264_parse_sink_setcaps));
gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->sinkpad);
h264parse->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
gst_element_add_pad (GST_ELEMENT (h264parse), h264parse->srcpad);
h264parse->split_packetized = DEFAULT_SPLIT_PACKETIZED;
h264parse->adapter = gst_adapter_new ();
for (i = 0; i < MAX_SPS_COUNT; i++)
h264parse->sps_buffers[i] = NULL;
h264parse->sps = NULL;
h264parse->first_mb_in_slice = -1;
h264parse->slice_type = -1;
h264parse->pps_id = -1;
h264parse->frame_num = -1;
h264parse->field_pic_flag = FALSE;
h264parse->bottom_field_flag = FALSE;
for (i = 0; i < 32; i++)
h264parse->initial_cpb_removal_delay[i] = -1;
h264parse->sei_cpb_removal_delay = 0;
h264parse->sei_dpb_output_delay = 0;
h264parse->sei_pic_struct = -1;
h264parse->sei_ct_type = -1;
h264parse->dts = GST_CLOCK_TIME_NONE;
h264parse->ts_trn_nb = GST_CLOCK_TIME_NONE;
h264parse->cur_duration = 0;
h264parse->last_outbuf_dts = GST_CLOCK_TIME_NONE;
}
static void
gst_h264_parse_finalize (GObject * object)
{
GstH264Parse *h264parse;
gint i;
h264parse = GST_H264PARSE (object);
g_object_unref (h264parse->adapter);
for (i = 0; i < MAX_SPS_COUNT; i++) {
if (h264parse->sps_buffers[i] != NULL)
g_slice_free (GstH264Sps, h264parse->sps_buffers[i]);
}
for (i = 0; i < MAX_PPS_COUNT; i++) {
if (h264parse->pps_buffers[i] != NULL)
g_slice_free (GstH264Pps, h264parse->pps_buffers[i]);
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_h264_parse_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstH264Parse *parse;
parse = GST_H264PARSE (object);
switch (prop_id) {
case PROP_SPLIT_PACKETIZED:
parse->split_packetized = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_h264_parse_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstH264Parse *parse;
parse = GST_H264PARSE (object);
switch (prop_id) {
case PROP_SPLIT_PACKETIZED:
g_value_set_boolean (value, parse->split_packetized);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_h264_parse_sink_setcaps (GstPad * pad, GstCaps * caps)
{
gboolean res;
GstH264Parse *h264parse;
GstStructure *str;
const GValue *value;
guint8 *data;
guint size;
h264parse = GST_H264PARSE (GST_PAD_PARENT (pad));
str = gst_caps_get_structure (caps, 0);
/* packetized video has a codec_data */
if ((value = gst_structure_get_value (str, "codec_data"))) {
GstBuffer *buffer;
gint profile;
GST_DEBUG_OBJECT (h264parse, "have packetized h264");
h264parse->packetized = TRUE;
buffer = gst_value_get_buffer (value);
data = GST_BUFFER_DATA (buffer);
size = GST_BUFFER_SIZE (buffer);
/* parse the avcC data */
if (size < 7)
goto avcc_too_small;
/* parse the version, this must be 1 */
if (data[0] != 1)
goto wrong_version;
/* AVCProfileIndication */
/* profile_compat */
/* AVCLevelIndication */
profile = (data[1] << 16) | (data[2] << 8) | data[3];
GST_DEBUG_OBJECT (h264parse, "profile %06x", profile);
/* 6 bits reserved | 2 bits lengthSizeMinusOne */
/* this is the number of bytes in front of the NAL units to mark their
* length */
h264parse->nal_length_size = (data[4] & 0x03) + 1;
GST_DEBUG_OBJECT (h264parse, "nal length %u", h264parse->nal_length_size);
/* FIXME, PPS, SPS have vital info for detecting new I-frames */
} else {
GST_DEBUG_OBJECT (h264parse, "have bytestream h264");
h264parse->packetized = FALSE;
/* we have 4 sync bytes */
h264parse->nal_length_size = 4;
}
/* forward the caps */
res = gst_pad_set_caps (h264parse->srcpad, caps);
return res;
/* ERRORS */
avcc_too_small:
{
GST_ERROR_OBJECT (h264parse, "avcC size %u < 7", size);
return FALSE;
}
wrong_version:
{
GST_ERROR_OBJECT (h264parse, "wrong avcC version");
return FALSE;
}
}
static void
gst_h264_parse_clear_queues (GstH264Parse * h264parse)
{
g_list_foreach (h264parse->gather, (GFunc) gst_mini_object_unref, NULL);
g_list_free (h264parse->gather);
h264parse->gather = NULL;
while (h264parse->decode) {
gst_buffer_unref (h264parse->decode->buffer);
h264parse->decode = gst_nal_list_delete_head (h264parse->decode);
}
h264parse->decode = NULL;
h264parse->decode_len = 0;
if (h264parse->prev) {
gst_buffer_unref (h264parse->prev);
h264parse->prev = NULL;
}
gst_adapter_clear (h264parse->adapter);
h264parse->have_i_frame = FALSE;
}
static GstFlowReturn
gst_h264_parse_chain_forward (GstH264Parse * h264parse, gboolean discont,
GstBuffer * buffer)
{
GstFlowReturn res = GST_FLOW_OK;
const guint8 *data;
if (discont) {
gst_adapter_clear (h264parse->adapter);
h264parse->discont = TRUE;
}
gst_adapter_push (h264parse->adapter, buffer);
while (res == GST_FLOW_OK) {
gint i;
gint next_nalu_pos = -1;
gint avail;
gboolean delta_unit = FALSE;
gboolean got_frame = FALSE;
avail = gst_adapter_available (h264parse->adapter);
if (avail < h264parse->nal_length_size + 1)
break;
data = gst_adapter_peek (h264parse->adapter, avail);
if (!h264parse->packetized) {
/* Bytestream format, first 4 bytes are sync code */
/* Find next NALU header */
for (i = 1; i < avail - 4; ++i) {
if (data[i + 0] == 0 && data[i + 1] == 0 && data[i + 2] == 0
&& data[i + 3] == 1) {
next_nalu_pos = i;
break;
}
}
} else {
guint32 nalu_size;
nalu_size = 0;
for (i = 0; i < h264parse->nal_length_size; i++)
nalu_size = (nalu_size << 8) | data[i];
GST_LOG_OBJECT (h264parse, "got NALU size %u", nalu_size);
/* check for invalid NALU sizes, assume the size if the available bytes
* when something is fishy */
if (nalu_size <= 1 || nalu_size + h264parse->nal_length_size > avail) {
nalu_size = avail - h264parse->nal_length_size;
GST_DEBUG_OBJECT (h264parse, "fixing invalid NALU size to %u",
nalu_size);
}
/* Packetized format, see if we have to split it, usually splitting is not
* a good idea as decoders have no way of handling it. */
if (h264parse->split_packetized) {
if (nalu_size + h264parse->nal_length_size <= avail)
next_nalu_pos = nalu_size + h264parse->nal_length_size;
} else {
next_nalu_pos = avail;
}
}
/* skip nalu_size bytes or sync */
data += h264parse->nal_length_size;
avail -= h264parse->nal_length_size;
/* Figure out if this is a delta unit */
{
GstNalUnitType nal_type;
gint nal_ref_idc;
GstNalBs bs;
nal_type = (data[0] & 0x1f);
nal_ref_idc = (data[0] & 0x60) >> 5;
GST_DEBUG_OBJECT (h264parse, "NAL type: %d, ref_idc: %d", nal_type,
nal_ref_idc);
gst_nal_bs_init (&bs, data + 1, avail - 1);
/* first parse some things needed to get to the frame type */
switch (nal_type) {
case NAL_SLICE:
case NAL_SLICE_DPA:
case NAL_SLICE_DPB:
case NAL_SLICE_DPC:
case NAL_SLICE_IDR:
{
gint first_mb_in_slice, slice_type;
gst_nal_decode_slice_header (h264parse, &bs);
first_mb_in_slice = h264parse->first_mb_in_slice;
slice_type = h264parse->slice_type;
GST_DEBUG_OBJECT (h264parse, "first MB: %d, slice type: %d",
first_mb_in_slice, slice_type);
switch (slice_type) {
case 0:
case 5:
case 3:
case 8: /* SP */
/* P frames */
GST_DEBUG_OBJECT (h264parse, "we have a P slice");
delta_unit = TRUE;
break;
case 1:
case 6:
/* B frames */
GST_DEBUG_OBJECT (h264parse, "we have a B slice");
delta_unit = TRUE;
break;
case 2:
case 7:
case 4:
case 9:
/* I frames */
GST_DEBUG_OBJECT (h264parse, "we have an I slice");
got_frame = TRUE;
break;
}
break;
}
case NAL_SEI:
GST_DEBUG_OBJECT (h264parse, "we have an SEI NAL");
gst_nal_decode_sei (h264parse, &bs);
break;
case NAL_SPS:
GST_DEBUG_OBJECT (h264parse, "we have an SPS NAL");
gst_nal_decode_sps (h264parse, &bs);
break;
case NAL_PPS:
GST_DEBUG_OBJECT (h264parse, "we have a PPS NAL");
gst_nal_decode_pps (h264parse, &bs);
break;
case NAL_AU_DELIMITER:
GST_DEBUG_OBJECT (h264parse, "we have an access unit delimiter.");
break;
default:
GST_DEBUG_OBJECT (h264parse,
"NAL of nal_type = %d encountered but not parsed", nal_type);
}
}
/* we have a packet */
if (next_nalu_pos > 0) {
GstBuffer *outbuf;
GstClockTime outbuf_dts = GST_CLOCK_TIME_NONE;
outbuf = gst_adapter_take_buffer (h264parse->adapter, next_nalu_pos);
outbuf_dts = gst_adapter_prev_timestamp (h264parse->adapter, NULL); /* Better value for the second parameter? */
/* Ignore upstream dts that stalls or goes backward. Upstream elements
* like filesrc would keep on writing timestamp=0. XXX: is this correct?
* TODO: better way to detect whether upstream timstamps are useful */
if (h264parse->last_outbuf_dts != GST_CLOCK_TIME_NONE
&& outbuf_dts != GST_CLOCK_TIME_NONE
&& outbuf_dts <= h264parse->last_outbuf_dts)
outbuf_dts = GST_CLOCK_TIME_NONE;
if (got_frame || delta_unit) {
GstH264Sps *sps = h264parse->sps;
gint duration = 1;
if (!sps) {
GST_DEBUG_OBJECT (h264parse, "referred SPS invalid");
goto TIMESTAMP_FINISH;
} else if (!sps->timing_info_present_flag) {
GST_DEBUG_OBJECT (h264parse,
"unable to compute timestamp: timing info not present");
goto TIMESTAMP_FINISH;
} else if (sps->time_scale == 0) {
GST_DEBUG_OBJECT (h264parse,
"unable to compute timestamp: time_scale = 0 "
"(this is forbidden in spec; bitstream probably contains error)");
goto TIMESTAMP_FINISH;
}
if (sps->pic_struct_present_flag
&& h264parse->sei_pic_struct != (guint8) - 1) {
/* Note that when h264parse->sei_pic_struct == -1 (unspecified), there
* are ways to infer its value. This is related to computing the
* TopFieldOrderCnt and BottomFieldOrderCnt, which looks
* complicated and thus not implemented for the time being. Yet
* the value we have here is correct for many applications
*/
switch (h264parse->sei_pic_struct) {
case SEI_PIC_STRUCT_TOP_FIELD:
case SEI_PIC_STRUCT_BOTTOM_FIELD:
duration = 1;
break;
case SEI_PIC_STRUCT_FRAME:
case SEI_PIC_STRUCT_TOP_BOTTOM:
case SEI_PIC_STRUCT_BOTTOM_TOP:
duration = 2;
break;
case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
duration = 3;
break;
case SEI_PIC_STRUCT_FRAME_DOUBLING:
duration = 4;
break;
case SEI_PIC_STRUCT_FRAME_TRIPLING:
duration = 6;
break;
default:
GST_DEBUG_OBJECT (h264parse,
"h264parse->sei_pic_struct of unknown value %d. Not parsed",
h264parse->sei_pic_struct);
}
} else {
duration = h264parse->field_pic_flag ? 1 : 2;
}
/*
* h264parse.264 C.1.2 Timing of coded picture removal (equivalent to DTS):
* Tr,n(0) = initial_cpb_removal_delay[ SchedSelIdx ] / 90000
* Tr,n(n) = Tr,n(nb) + Tc * cpb_removal_delay(n)
* where
* Tc = num_units_in_tick / time_scale
*/
if (h264parse->ts_trn_nb != GST_CLOCK_TIME_NONE) {
/* buffering period is present */
if (outbuf_dts != GST_CLOCK_TIME_NONE) {
/* If upstream timestamp is valid, we respect it and adjust current
* reference point */
h264parse->ts_trn_nb = outbuf_dts -
(GstClockTime) gst_util_uint64_scale_int
(h264parse->sei_cpb_removal_delay * GST_SECOND,
sps->num_units_in_tick, sps->time_scale);
} else {
/* If no upstream timestamp is given, we write in new timestamp */
h264parse->dts = h264parse->ts_trn_nb +
(GstClockTime) gst_util_uint64_scale_int
(h264parse->sei_cpb_removal_delay * GST_SECOND,
sps->num_units_in_tick, sps->time_scale);
}
} else {
/* naive method: no removal delay specified, use best guess (add prev
* frame duration) */
if (outbuf_dts != GST_CLOCK_TIME_NONE)
h264parse->dts = outbuf_dts;
else if (h264parse->dts != GST_CLOCK_TIME_NONE)
h264parse->dts += (GstClockTime)
gst_util_uint64_scale_int (h264parse->cur_duration * GST_SECOND,
sps->num_units_in_tick, sps->time_scale);
else
h264parse->dts = 0; /* initialization */
/* TODO: better approach: construct a buffer queue and put all these
* NALs into the buffer. Wait until we are able to get any valid dts
* or such like, and dump the buffer and estimate the timestamps of
* the NALs by their duration.
*/
}
h264parse->cur_duration = duration;
h264parse->frame_cnt += 1;
if (outbuf_dts != GST_CLOCK_TIME_NONE)
h264parse->last_outbuf_dts = outbuf_dts;
}
if (outbuf_dts == GST_CLOCK_TIME_NONE)
outbuf_dts = h264parse->dts;
else
h264parse->dts = outbuf_dts;
TIMESTAMP_FINISH:
GST_BUFFER_TIMESTAMP (outbuf) = outbuf_dts;
GST_DEBUG_OBJECT (h264parse,
"pushing buffer %p, size %u, ts %" GST_TIME_FORMAT, outbuf,
next_nalu_pos, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)));
if (h264parse->discont) {
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
h264parse->discont = FALSE;
}
if (delta_unit)
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
else
GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (h264parse->srcpad));
res = gst_pad_push (h264parse->srcpad, outbuf);
} else {
/* NALU can not be parsed yet, we wait for more data in the adapter. */
break;
}
}
return res;
}
static GstFlowReturn
gst_h264_parse_flush_decode (GstH264Parse * h264parse)
{
GstFlowReturn res = GST_FLOW_OK;
gboolean first = TRUE;
while (h264parse->decode) {
GstNalList *link;
GstBuffer *buf;
link = h264parse->decode;
buf = link->buffer;
GST_DEBUG_OBJECT (h264parse, "have type: %d, I frame: %d", link->nal_type,
link->i_frame);
if (first) {
/* first buffer has discont */
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
first = FALSE;
} else {
/* next buffers are not discont */
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
}
if (link->i_frame)
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
else
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
GST_DEBUG_OBJECT (h264parse, "pushing buffer %p, ts %" GST_TIME_FORMAT,
buf, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
res = gst_pad_push (h264parse->srcpad, buf);
h264parse->decode = gst_nal_list_delete_head (h264parse->decode);
h264parse->decode_len--;
}
/* the i frame is gone now */
h264parse->have_i_frame = FALSE;
return res;
}
/* check that the decode queue contains a valid sync code that should be pushed
* out before adding @buffer to the decode queue */
static GstFlowReturn
gst_h264_parse_queue_buffer (GstH264Parse * parse, GstBuffer * buffer)
{
guint8 *data;
guint size;
guint32 nalu_size;
GstNalBs bs;
GstNalList *link;
GstFlowReturn res = GST_FLOW_OK;
GstClockTime timestamp;
/* create new NALU link */
link = gst_nal_list_new (buffer);
/* first parse the buffer */
data = GST_BUFFER_DATA (buffer);
size = GST_BUFFER_SIZE (buffer);
timestamp = GST_BUFFER_TIMESTAMP (buffer);
link->slice = FALSE;
link->i_frame = FALSE;
GST_DEBUG_OBJECT (parse,
"analyse buffer of size %u, timestamp %" GST_TIME_FORMAT, size,
GST_TIME_ARGS (timestamp));
/* now parse all the NAL units in this buffer, for bytestream we only have one
* NAL unit but for packetized streams we can have multiple ones */
while (size >= parse->nal_length_size + 1) {
gint i;
nalu_size = 0;
if (parse->packetized) {
for (i = 0; i < parse->nal_length_size; i++)
nalu_size = (nalu_size << 8) | data[i];
}
/* skip nalu_size or sync bytes */
data += parse->nal_length_size;
size -= parse->nal_length_size;
link->nal_ref_idc = (data[0] & 0x60) >> 5;
link->nal_type = (data[0] & 0x1f);
/* nalu_size is 0 for bytestream, we have a complete packet */
GST_DEBUG_OBJECT (parse, "size: %u, NAL type: %d, ref_idc: %d",
nalu_size, link->nal_type, link->nal_ref_idc);
/* first parse some things needed to get to the frame type */
if (link->nal_type >= NAL_SLICE && link->nal_type <= NAL_SLICE_IDR) {
gst_nal_bs_init (&bs, data + 1, size - 1);
link->first_mb_in_slice = gst_nal_bs_read_ue (&bs);
link->slice_type = gst_nal_bs_read_ue (&bs);
link->slice = TRUE;
GST_DEBUG_OBJECT (parse, "first MB: %d, slice type: %d",
link->first_mb_in_slice, link->slice_type);
switch (link->slice_type) {
case 0:
case 5:
case 3:
case 8: /* SP */
/* P frames */
GST_DEBUG_OBJECT (parse, "we have a P slice");
break;
case 1:
case 6:
/* B frames */
GST_DEBUG_OBJECT (parse, "we have a B slice");
break;
case 2:
case 7:
case 4:
case 9:
/* I frames */
GST_DEBUG_OBJECT (parse, "we have an I slice");
link->i_frame = TRUE;
break;
}
}
/* bytestream, we can exit now */
if (!parse->packetized)
break;
/* packetized format, continue parsing all packets, skip size, we already
* skipped the nal_length_size bytes */
data += nalu_size;
size -= nalu_size;
}
/* we have an I frame in the queue, this new NAL unit is a slice but not
* an I frame, output the decode queue */
GST_DEBUG_OBJECT (parse, "have_I_frame: %d, I_frame: %d, slice: %d",
parse->have_i_frame, link->i_frame, link->slice);
if (parse->have_i_frame && !link->i_frame && link->slice) {
GST_DEBUG_OBJECT (parse, "flushing decode queue");
res = gst_h264_parse_flush_decode (parse);
}
if (link->i_frame)
/* we're going to add a new I-frame in the queue */
parse->have_i_frame = TRUE;
parse->decode = gst_nal_list_prepend_link (parse->decode, link);
parse->decode_len++;
GST_DEBUG_OBJECT (parse,
"copied %d bytes of NAL to decode queue. queue size %d", size,
parse->decode_len);
return res;
}
static guint
gst_h264_parse_find_start_reverse (GstH264Parse * parse, guint8 * data,
guint size, guint32 * code)
{
guint32 search = *code;
while (size > 0) {
/* the sync code is kept in reverse */
search = (search << 8) | (data[size - 1]);
if (search == 0x01000000)
break;
size--;
}
*code = search;
return size - 1;
}
static GstFlowReturn
gst_h264_parse_chain_reverse (GstH264Parse * h264parse, gboolean discont,
GstBuffer * buffer)
{
GstFlowReturn res = GST_FLOW_OK;
GstBuffer *gbuf = NULL;
/* if we have a discont, move buffers to the decode list */
if (G_UNLIKELY (discont)) {
guint start, stop, last;
guint32 code;
GstBuffer *prev;
GstClockTime timestamp;
GST_DEBUG_OBJECT (h264parse,
"received discont, copy gathered buffers for decoding");
/* init start code accumulator */
stop = -1;
prev = h264parse->prev;
h264parse->prev = NULL;
while (h264parse->gather) {
guint8 *data;
/* get new buffer and init the start code search to the end position */
if (gbuf != NULL)
gst_buffer_unref (gbuf);
gbuf = GST_BUFFER_CAST (h264parse->gather->data);
/* remove from the gather list, they are in reverse order */
h264parse->gather =
g_list_delete_link (h264parse->gather, h264parse->gather);
if (h264parse->packetized) {
/* packetized the packets are already split, we can just parse and
* store them */
GST_DEBUG_OBJECT (h264parse, "copied packetized buffer");
res = gst_h264_parse_queue_buffer (h264parse, gbuf);
gbuf = NULL;
} else {
/* bytestream, we have to split the NALUs on the sync markers */
code = 0xffffffff;
if (prev) {
/* if we have a previous buffer or a leftover, merge them together
* now */
GST_DEBUG_OBJECT (h264parse, "merging previous buffer");
gbuf = gst_buffer_join (gbuf, prev);
prev = NULL;
}
last = GST_BUFFER_SIZE (gbuf);
data = GST_BUFFER_DATA (gbuf);
timestamp = GST_BUFFER_TIMESTAMP (gbuf);
GST_DEBUG_OBJECT (h264parse,
"buffer size: %u, timestamp %" GST_TIME_FORMAT, last,
GST_TIME_ARGS (timestamp));
while (last > 0) {
GST_DEBUG_OBJECT (h264parse, "scan from %u", last);
/* find a start code searching backwards in this buffer */
start =
gst_h264_parse_find_start_reverse (h264parse, data, last, &code);
if (start != -1) {
GstBuffer *decode;
GST_DEBUG_OBJECT (h264parse, "found start code at %u", start);
/* we found a start code, copy everything starting from it to the
* decode queue. */
decode = gst_buffer_create_sub (gbuf, start, last - start);
GST_BUFFER_TIMESTAMP (decode) = timestamp;
/* see what we have here */
res = gst_h264_parse_queue_buffer (h264parse, decode);
last = start;
} else {
/* no start code found, keep the buffer and merge with potential next
* buffer. */
GST_DEBUG_OBJECT (h264parse, "no start code, keeping buffer to %u",
last);
prev = gst_buffer_create_sub (gbuf, 0, last);
gst_buffer_unref (gbuf);
gbuf = NULL;
break;
}
}
}
}
if (prev) {
GST_DEBUG_OBJECT (h264parse, "keeping buffer");
h264parse->prev = prev;
}
}
if (buffer) {
/* add buffer to gather queue */
GST_DEBUG_OBJECT (h264parse, "gathering buffer %p, size %u", buffer,
GST_BUFFER_SIZE (buffer));
h264parse->gather = g_list_prepend (h264parse->gather, buffer);
}
if (gbuf) {
gst_buffer_unref (gbuf);
gbuf = NULL;
}
return res;
}
static GstFlowReturn
gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer)
{
GstFlowReturn res;
GstH264Parse *h264parse;
gboolean discont;
GstCaps *caps;
h264parse = GST_H264PARSE (GST_PAD_PARENT (pad));
if (!GST_PAD_CAPS (h264parse->srcpad)) {
/* Set default caps if the sink caps were not negotiated, this is when we
* are reading from a file or so */
caps = gst_caps_new_simple ("video/x-h264", NULL);
/* Set source caps */
if (!gst_pad_set_caps (h264parse->srcpad, caps))
goto caps_failed;
/* we assume the bytestream format. If the data turns out to be packetized,
* we have a problem because we don't know the length of the nalu_size
* indicator. Packetized input MUST set the codec_data. */
h264parse->packetized = FALSE;
h264parse->nal_length_size = 4;
gst_caps_unref (caps);
}
discont = GST_BUFFER_IS_DISCONT (buffer);
GST_DEBUG_OBJECT (h264parse, "received buffer of size %u",
GST_BUFFER_SIZE (buffer));
if (h264parse->segment.rate > 0.0)
res = gst_h264_parse_chain_forward (h264parse, discont, buffer);
else
res = gst_h264_parse_chain_reverse (h264parse, discont, buffer);
return res;
/* ERRORS */
caps_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (h264parse),
CORE, NEGOTIATION, (NULL), ("failed to set caps"));
gst_caps_unref (caps);
return GST_FLOW_ERROR;
}
}
static gboolean
gst_h264_parse_sink_event (GstPad * pad, GstEvent * event)
{
GstH264Parse *h264parse;
gboolean res;
h264parse = GST_H264PARSE (gst_pad_get_parent (pad));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH_STOP:
GST_DEBUG_OBJECT (h264parse, "received FLUSH stop");
gst_segment_init (&h264parse->segment, GST_FORMAT_UNDEFINED);
gst_h264_parse_clear_queues (h264parse);
res = gst_pad_push_event (h264parse->srcpad, event);
break;
case GST_EVENT_EOS:
GST_DEBUG_OBJECT (h264parse, "received EOS");
if (h264parse->segment.rate < 0.0) {
gst_h264_parse_chain_reverse (h264parse, TRUE, NULL);
gst_h264_parse_flush_decode (h264parse);
}
res = gst_pad_push_event (h264parse->srcpad, event);
break;
case GST_EVENT_NEWSEGMENT:
{
gdouble rate, applied_rate;
GstFormat format;
gint64 start, stop, pos;
gboolean update;
gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
&format, &start, &stop, &pos);
/* now configure the values */
gst_segment_set_newsegment_full (&h264parse->segment, update,
rate, applied_rate, format, start, stop, pos);
GST_DEBUG_OBJECT (h264parse,
"Pushing newseg rate %g, applied rate %g, format %d, start %"
G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT ", pos %" G_GINT64_FORMAT,
rate, applied_rate, format, start, stop, pos);
res = gst_pad_push_event (h264parse->srcpad, event);
break;
}
default:
res = gst_pad_push_event (h264parse->srcpad, event);
break;
}
gst_object_unref (h264parse);
return res;
}
static GstStateChangeReturn
gst_h264_parse_change_state (GstElement * element, GstStateChange transition)
{
GstH264Parse *h264parse;
GstStateChangeReturn ret;
h264parse = GST_H264PARSE (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_segment_init (&h264parse->segment, GST_FORMAT_UNDEFINED);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_h264_parse_clear_queues (h264parse);
break;
default:
break;
}
return ret;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
return gst_element_register (plugin, "h264parse",
GST_RANK_NONE, GST_TYPE_H264PARSE);
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"h264parse",
"Element parsing raw h264 streams",
plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
Reference in a new issue View git blame Copy permalink