/* GStreamer h264 parser * Copyright (C) 2005 Michal Benes * (C) 2008 Wim Taymans * (C) 2009 Mark Nauwelaerts * (C) 2009 Nokia Corporation. All rights reserved. * Contact: Stefan Kost * * 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. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #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 #define DEFAULT_SPLIT_PACKETIZED FALSE #define DEFAULT_ACCESS_UNIT FALSE #define DEFAULT_OUTPUT_FORMAT GST_H264_PARSE_FORMAT_INPUT #define DEFAULT_CONFIG_INTERVAL (0) enum { PROP_0, PROP_SPLIT_PACKETIZED, PROP_ACCESS_UNIT, PROP_CONFIG_INTERVAL, PROP_OUTPUT_FORMAT, PROP_LAST }; enum { GST_H264_PARSE_FORMAT_SAMPLE = 0, GST_H264_PARSE_FORMAT_BYTE, GST_H264_PARSE_FORMAT_INPUT }; #define GST_H264_PARSE_FORMAT_TYPE (gst_h264_parse_format_get_type()) static GType gst_h264_parse_format_get_type (void) { static GType format_type = 0; static const GEnumValue format_types[] = { {GST_H264_PARSE_FORMAT_SAMPLE, "AVC Sample Format", "sample"}, {GST_H264_PARSE_FORMAT_BYTE, "Bytestream Format", "byte"}, {GST_H264_PARSE_FORMAT_INPUT, "Input Format", "input"}, {0, NULL, NULL} }; if (!format_type) { format_type = g_enum_register_static ("GstH264ParseFormat", format_types); } return format_type; } 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)); } /* read signed Exp-Golomb code */ static gint gst_nal_bs_read_se (GstNalBs * bs) { gint i = 0; i = gst_nal_bs_read_ue (bs); /* (-1)^(i+1) Ceil (i / 2) */ i = (i + 1) / 2 * (i & 1 ? 1 : -1); return 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... */ /* derived values */ gint width, height; }; /* 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); 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, "timing info: dur=%d/%d fixed=%d", num_units_in_tick, 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; guint subwc[] = { 1, 2, 2, 1 }; guint subhc[] = { 1, 2, 1, 1 }; guint chroma; guint fc_top, fc_bottom, fc_left, fc_right; gint width, height; 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) { gint scp_flag = 0; if ((chroma = gst_nal_bs_read_ue (bs)) == 3) { /* chroma_format_idc */ scp_flag = 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 */ gint i, j, m, d; m = (chroma != 3) ? 8 : 12; for (i = 0; i < m; i++) { /* seq_scaling_list_present_flag[i] */ d = gst_nal_bs_read (bs, 1); if (d) { gint lastScale = 8, nextScale = 8, deltaScale; j = (i < 6) ? 16 : 64; for (; j > 0; j--) { if (nextScale != 0) { deltaScale = gst_nal_bs_read_se (bs); nextScale = (lastScale + deltaScale + 256) % 256; } if (nextScale != 0) lastScale = nextScale; } } } } if (scp_flag) chroma = 0; } else { /* inferred value */ chroma = 1; } 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) { gint d; /* delta_pic_order_always_zero_flag */ gst_nal_bs_read (bs, 1); /* offset_for_non_ref_pic */ gst_nal_bs_read_ue (bs); /* offset_for_top_to_bottom_field */ gst_nal_bs_read_ue (bs); /* num_ref_frames_in_pic_order_cnt_cycle */ d = gst_nal_bs_read_ue (bs); for (; d > 0; d--) { /* offset_for_ref_frame[i] */ gst_nal_bs_read_ue (bs); } } gst_nal_bs_read_ue (bs); /* max_num_ref_frames */ gst_nal_bs_read (bs, 1); /* gaps_in_frame_num_value_allowed_flag */ width = gst_nal_bs_read_ue (bs); /* pic_width_in_mbs_minus1 */ height = 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 */ } width++; width *= 16; height++; height *= 16 * (2 - sps->frame_mbs_only_flag); gst_nal_bs_read (bs, 1); /* direct_8x8_inference_flag */ if (gst_nal_bs_read (bs, 1)) { /* frame_cropping_flag */ fc_left = gst_nal_bs_read_ue (bs); /* frame_crop_left_offset */ fc_right = gst_nal_bs_read_ue (bs); /* frame_crop_right_offset */ fc_top = gst_nal_bs_read_ue (bs); /* frame_crop_top_offset */ fc_bottom = gst_nal_bs_read_ue (bs); /* frame_crop_bottom_offset */ } else fc_left = fc_right = fc_top = fc_bottom = 0; 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); /* calculate width and height */ GST_DEBUG_OBJECT (h, "initial width=%d, height=%d", width, height); GST_DEBUG_OBJECT (h, "crop (%d,%d)(%d,%d)", fc_left, fc_top, fc_right, fc_bottom); if (chroma > 3) { GST_DEBUG_OBJECT (h, "chroma=%d in SPS is out of range", chroma); return FALSE; } width -= (fc_left + fc_right) * subwc[chroma]; height -= (fc_top + fc_bottom) * subhc[chroma] * (2 - sps->frame_mbs_only_flag); if (width < 0 || height < 0) { GST_DEBUG_OBJECT (h, "invalid width/height in SPS"); return FALSE; } GST_DEBUG_OBJECT (h, "final width=%u, height=%u", width, height); sps->width = width; sps->height = height; 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) { gint pps_id; GstH264Pps *pps = NULL; pps_id = gst_nal_bs_read_ue (bs); if (pps_id >= MAX_PPS_COUNT) { GST_DEBUG_OBJECT (h, "requested pps_id=%04x out of range", pps_id); return FALSE; } 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); if (!h->sps) return FALSE; /* 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; } typedef GstH264Parse GstLegacyH264Parse; typedef GstH264ParseClass GstLegacyH264ParseClass; GST_BOILERPLATE (GstLegacyH264Parse, gst_h264_parse, GstElement, GST_TYPE_ELEMENT); static void gst_h264_parse_reset (GstH264Parse * h264parse); 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_simple (gstelement_class, "H264Parse", "Codec/Parser/Video", "Parses raw h264 stream", "Michal Benes ," "Wim Taymans "); GST_DEBUG_CATEGORY_INIT (h264_parse_debug, "legacy h264parse", 0, "legacy 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 | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ACCESS_UNIT, g_param_spec_boolean ("access-unit", "Access Units", "Output Acess Units rather than NALUs", DEFAULT_ACCESS_UNIT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_OUTPUT_FORMAT, g_param_spec_enum ("output-format", "Output Format", "Output Format of stream (bytestream or otherwise)", GST_H264_PARSE_FORMAT_TYPE, DEFAULT_OUTPUT_FORMAT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_CONFIG_INTERVAL, g_param_spec_uint ("config-interval", "SPS PPS Send Interval", "Send SPS and PPS Insertion Interval in seconds (sprop parameter sets " "will be multiplexed in the data stream when detected.) (0 = disabled)", 0, 3600, DEFAULT_CONFIG_INTERVAL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gstelement_class->change_state = gst_h264_parse_change_state; } static void gst_h264_parse_init (GstH264Parse * h264parse, GstH264ParseClass * g_class) { 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 (); h264parse->merge = DEFAULT_ACCESS_UNIT; h264parse->picture_adapter = gst_adapter_new (); h264parse->interval = DEFAULT_CONFIG_INTERVAL; h264parse->last_report = GST_CLOCK_TIME_NONE; h264parse->format = GST_H264_PARSE_FORMAT_INPUT; gst_h264_parse_reset (h264parse); } static void gst_h264_parse_reset (GstH264Parse * h264parse) { gint i; GSList *list; for (i = 0; i < MAX_SPS_COUNT; i++) { if (h264parse->sps_buffers[i]) g_slice_free (GstH264Sps, h264parse->sps_buffers[i]); h264parse->sps_buffers[i] = NULL; gst_buffer_replace (&h264parse->sps_nals[i], NULL); } for (i = 0; i < MAX_PPS_COUNT; i++) { if (h264parse->pps_buffers[i]) g_slice_free (GstH264Pps, h264parse->pps_buffers[i]); h264parse->pps_buffers[i] = NULL; gst_buffer_replace (&h264parse->pps_nals[i], NULL); } h264parse->sps = NULL; h264parse->pps = 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; list = h264parse->codec_nals; g_slist_foreach (list, (GFunc) gst_buffer_unref, NULL); g_slist_free (h264parse->codec_nals); h264parse->codec_nals = NULL; h264parse->picture_start = FALSE; h264parse->idr_offset = -1; if (h264parse->pending_segment) gst_event_unref (h264parse->pending_segment); h264parse->pending_segment = NULL; g_list_foreach (h264parse->pending_events, (GFunc) gst_event_unref, NULL); g_list_free (h264parse->pending_events); h264parse->pending_events = NULL; gst_caps_replace (&h264parse->src_caps, NULL); } static void gst_h264_parse_finalize (GObject * object) { GstH264Parse *h264parse; h264parse = GST_H264PARSE (object); gst_h264_parse_reset (h264parse); g_object_unref (h264parse->adapter); g_object_unref (h264parse->picture_adapter); 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; case PROP_ACCESS_UNIT: parse->merge = g_value_get_boolean (value); break; case PROP_OUTPUT_FORMAT: parse->format = g_value_get_enum (value); break; case PROP_CONFIG_INTERVAL: parse->interval = g_value_get_uint (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; case PROP_ACCESS_UNIT: g_value_set_boolean (value, parse->merge); break; case PROP_OUTPUT_FORMAT: g_value_set_enum (value, parse->format); break; case PROP_CONFIG_INTERVAL: g_value_set_uint (value, parse->interval); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } /* make a buffer consisting of a 4-byte start code following by * (a copy of) given nal data */ static GstBuffer * gst_h264_parse_make_nal (GstH264Parse * h264parse, const guint8 * data, guint len) { GstBuffer *buf; buf = gst_buffer_new_and_alloc (4 + len); GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), 1); memcpy (GST_BUFFER_DATA (buf) + 4, data, len); return buf; } /* byte together avc codec data based on collected pps and sps so far */ static GstBuffer * gst_h264_parse_make_codec_data (GstH264Parse * h264parse) { GstBuffer *buf, *nal; gint i, sps_size = 0, pps_size = 0, num_sps = 0, num_pps = 0; guint8 profile_idc = 0, profile_comp = 0, level_idc = 0; gboolean found = FALSE; guint8 *data; /* sps_nals and pps_nals contain start code */ for (i = 0; i < MAX_SPS_COUNT; i++) { if ((nal = h264parse->sps_nals[i])) { num_sps++; /* size bytes also count */ sps_size += GST_BUFFER_SIZE (nal) - 4 + 2; if (GST_BUFFER_SIZE (nal) >= 7) { found = TRUE; profile_idc = (GST_BUFFER_DATA (nal))[4]; profile_comp = (GST_BUFFER_DATA (nal))[5]; level_idc = (GST_BUFFER_DATA (nal))[6]; } } } for (i = 0; i < MAX_PPS_COUNT; i++) { if ((nal = h264parse->pps_nals[i])) { num_pps++; /* size bytes also count */ pps_size += GST_BUFFER_SIZE (nal) - 4 + 2; } } GST_DEBUG_OBJECT (h264parse, "constructing codec_data: num_sps=%d, num_pps=%d", num_sps, num_pps); if (!found || !num_pps) return NULL; buf = gst_buffer_new_and_alloc (5 + 1 + sps_size + 1 + pps_size); data = GST_BUFFER_DATA (buf); data[0] = 1; /* AVC Decoder Configuration Record ver. 1 */ data[1] = profile_idc; /* profile_idc */ data[2] = profile_comp; /* profile_compability */ data[3] = level_idc; /* level_idc */ data[4] = 0xfc | (4 - 1); /* nal_length_size_minus1 */ data[5] = 0xe0 | num_sps; /* number of SPSs */ data += 6; for (i = 0; i < MAX_SPS_COUNT; i++) { if ((nal = h264parse->sps_nals[i])) { GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (nal) - 4); memcpy (data + 2, GST_BUFFER_DATA (nal) + 4, GST_BUFFER_SIZE (nal) - 4); data += 2 + GST_BUFFER_SIZE (nal) - 4; } } data[0] = num_pps; data++; for (i = 0; i < MAX_PPS_COUNT; i++) { if ((nal = h264parse->pps_nals[i])) { GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (nal) - 4); memcpy (data + 2, GST_BUFFER_DATA (nal) + 4, GST_BUFFER_SIZE (nal) - 4); data += 2 + GST_BUFFER_SIZE (nal) - 4; } } return buf; } static guint gst_h264_parse_parse_stream_format (GstH264Parse * h264parse, const gchar * stream_format) { if (strcmp (stream_format, "avc") == 0) { return GST_H264_PARSE_FORMAT_SAMPLE; } else if (strcmp (stream_format, "byte-stream") == 0) { return GST_H264_PARSE_FORMAT_BYTE; } return GST_H264_PARSE_FORMAT_INPUT; /* this means we don't know */ } static gboolean gst_h264_parse_update_src_caps (GstH264Parse * h264parse, GstCaps * caps) { GstH264Sps *sps = NULL; GstCaps *src_caps = NULL; GstStructure *structure; gboolean modified = FALSE; const gchar *stream_format, *alignment; /* current PPS dictates which SPS to use */ if (h264parse->pps && h264parse->pps->sps_id < MAX_SPS_COUNT) { sps = h264parse->sps_buffers[h264parse->pps->sps_id]; } /* failing that, we'll take most recent SPS we can get */ if (!sps) { sps = h264parse->sps; } if (G_UNLIKELY (h264parse->src_caps == NULL)) { src_caps = gst_caps_copy (caps); modified = TRUE; } else { src_caps = gst_caps_ref (h264parse->src_caps); } src_caps = gst_caps_make_writable (src_caps); g_return_val_if_fail (src_caps != NULL, FALSE); /* if some upstream metadata missing, fill in from parsed stream */ /* width / height */ if (sps && (sps->width > 0 && sps->height > 0) && (h264parse->width != sps->width || h264parse->height != sps->height)) { gint width, height; width = h264parse->width = sps->width; height = h264parse->height = sps->height; GST_DEBUG_OBJECT (h264parse, "updating caps w/h %dx%d", width, height); gst_caps_set_simple (src_caps, "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL); modified = TRUE; } /* framerate */ if (sps && (sps->time_scale > 0 && sps->num_units_in_tick > 0) && (h264parse->fps_num != sps->time_scale || h264parse->fps_den != sps->num_units_in_tick)) { gint fps_num, fps_den; fps_num = h264parse->fps_num = sps->time_scale; fps_den = h264parse->fps_den = sps->num_units_in_tick; /* FIXME verify / also handle other cases */ if (sps->fixed_frame_rate_flag && sps->frame_mbs_only_flag && !sps->pic_struct_present_flag) { fps_den *= 2; /* picture is a frame = 2 fields */ GST_DEBUG_OBJECT (h264parse, "updating caps fps %d/%d", fps_num, fps_den); gst_caps_set_simple (src_caps, "framerate", GST_TYPE_FRACTION, fps_num, fps_den, NULL); modified = TRUE; } } structure = gst_caps_get_structure (src_caps, 0); /* we replace the stream-format on caps if needed */ stream_format = gst_structure_get_string (structure, "stream-format"); if (stream_format) { guint input_format; guint output_format; input_format = gst_h264_parse_parse_stream_format (h264parse, stream_format); output_format = h264parse->format; if (output_format == GST_H264_PARSE_FORMAT_INPUT) { if (h264parse->packetized) { output_format = GST_H264_PARSE_FORMAT_SAMPLE; } else { output_format = GST_H264_PARSE_FORMAT_BYTE; } } if (input_format != output_format) { /* we need to replace it */ stream_format = NULL; } } /* we need to add a new stream-format */ if (stream_format == NULL) { gst_structure_remove_field (structure, "stream-format"); if (h264parse->format == GST_H264_PARSE_FORMAT_SAMPLE) { stream_format = "avc"; } else if (h264parse->format == GST_H264_PARSE_FORMAT_BYTE) { stream_format = "byte-stream"; } else { if (h264parse->packetized) { stream_format = "avc"; } else { stream_format = "byte-stream"; } } gst_structure_set (structure, "stream-format", G_TYPE_STRING, stream_format, NULL); modified = TRUE; } /* set alignment field */ if (h264parse->merge) { alignment = "au"; } else { if (h264parse->packetized) { /* if packetized input, take upstream alignment if validly provided, * otherwise assume au aligned ... */ alignment = gst_structure_get_string (structure, "alignment"); if (!alignment || (alignment && strcmp (alignment, "au") != 0 && strcmp (alignment, "nal") != 0)) { if (h264parse->split_packetized) alignment = "nal"; else alignment = "au"; } } else { alignment = "nal"; } } /* now only set if changed */ { const gchar *old_alignment; old_alignment = gst_structure_get_string (structure, "alignment"); if (!old_alignment || strcmp (alignment, old_alignment) != 0) { gst_structure_set (structure, "alignment", G_TYPE_STRING, alignment, NULL); modified = TRUE; } } /* transforming to non-bytestream needs to make codec-data */ if (h264parse->format == GST_H264_PARSE_FORMAT_SAMPLE) { GstBuffer *buf; const GValue *value = NULL; const GstBuffer *codec_data = NULL; value = gst_structure_get_value (structure, "codec_data"); if (value != NULL) codec_data = gst_value_get_buffer (value); buf = gst_h264_parse_make_codec_data (h264parse); if (buf) { if (!codec_data || GST_BUFFER_SIZE (buf) != GST_BUFFER_SIZE (codec_data) || memcmp (GST_BUFFER_DATA (buf), GST_BUFFER_DATA (codec_data), GST_BUFFER_SIZE (buf))) { GST_DEBUG_OBJECT (h264parse, "setting new codec_data"); gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER, buf, NULL); modified = TRUE; } gst_buffer_unref (buf); } else { GST_DEBUG_OBJECT (h264parse, "no codec_data yet"); } } else if (h264parse->format == GST_H264_PARSE_FORMAT_BYTE) { /* need to remove the codec_data */ if (gst_structure_has_field (structure, "codec_data")) { gst_structure_remove_field (structure, "codec_data"); modified = TRUE; } } /* save as new caps, caps will be set when pushing data */ /* avoid replacing caps by a mere identical copy, thereby triggering * negotiating (which e.g. some container might not appreciate) */ if (modified) gst_caps_replace (&h264parse->src_caps, src_caps); gst_caps_unref (src_caps); return TRUE; } static gboolean gst_h264_parse_sink_setcaps (GstPad * pad, GstCaps * caps) { GstH264Parse *h264parse; GstStructure *str; const GValue *value; guint8 *data; guint size, num_sps, num_pps; h264parse = GST_H264PARSE (GST_PAD_PARENT (pad)); str = gst_caps_get_structure (caps, 0); /* accept upstream info if provided */ gst_structure_get_int (str, "width", &h264parse->width); gst_structure_get_int (str, "height", &h264parse->height); gst_structure_get_fraction (str, "framerate", &h264parse->fps_num, &h264parse->fps_den); /* packetized video has a codec_data */ if ((value = gst_structure_get_value (str, "codec_data"))) { GstBuffer *buffer; gint profile; GstNalBs bs; gint i, len; GSList *nlist = NULL; 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); num_sps = data[5] & 0x1f; data += 6; size -= 6; for (i = 0; i < num_sps; i++) { len = GST_READ_UINT16_BE (data); if (size < len + 2) goto avcc_too_small; gst_nal_bs_init (&bs, data + 2 + 1, len - 1); gst_nal_decode_sps (h264parse, &bs); /* store for later use, e.g. insertion */ if (h264parse->sps) { h264parse->sps_nals[h264parse->sps->sps_id] = gst_h264_parse_make_nal (h264parse, data + 2, len); } if (h264parse->format == GST_H264_PARSE_FORMAT_BYTE) nlist = g_slist_append (nlist, gst_h264_parse_make_nal (h264parse, data + 2, len)); data += len + 2; size -= len + 2; } num_pps = data[0]; data++; size++; for (i = 0; i < num_pps; i++) { len = GST_READ_UINT16_BE (data); if (size < len + 2) goto avcc_too_small; gst_nal_bs_init (&bs, data + 2 + 1, len - 1); gst_nal_decode_pps (h264parse, &bs); /* store for later use, e.g. insertion */ if (h264parse->pps) { h264parse->pps_nals[h264parse->pps->pps_id] = gst_h264_parse_make_nal (h264parse, data + 2, len); } if (h264parse->format == GST_H264_PARSE_FORMAT_BYTE) nlist = g_slist_append (nlist, gst_h264_parse_make_nal (h264parse, data + 2, len)); data += len + 2; size -= len + 2; } h264parse->codec_nals = nlist; } else { GST_DEBUG_OBJECT (h264parse, "have bytestream h264"); h264parse->packetized = FALSE; /* we have 4 sync bytes */ h264parse->nal_length_size = 4; } /* forward the caps */ return gst_h264_parse_update_src_caps (h264parse, caps); /* 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; } } /* if forced output mode, * ensures that NALU @nal starts with start code or length * takes ownership of nal and returns buffer */ static GstBuffer * gst_h264_parse_write_nal_prefix (GstH264Parse * h264parse, GstBuffer * nal) { guint nal_length = h264parse->nal_length_size; gint i; g_assert (nal_length <= 4); /* ensure proper transformation on prefix if needed */ if (h264parse->format == GST_H264_PARSE_FORMAT_SAMPLE) { nal = gst_buffer_make_writable (nal); switch (nal_length) { case 1: GST_WRITE_UINT8 (GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal) - nal_length); break; case 2: GST_WRITE_UINT16_BE (GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal) - nal_length); break; case 3: GST_WRITE_UINT24_BE (GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal) - nal_length); break; case 4: GST_WRITE_UINT32_BE (GST_BUFFER_DATA (nal), GST_BUFFER_SIZE (nal) - nal_length); break; default: g_assert_not_reached (); break; } } else if (h264parse->format == GST_H264_PARSE_FORMAT_BYTE) { gint offset = 0; guint nalu_size = 0; if (nal_length == 4) { nal = gst_buffer_make_writable (nal); while (offset + 4 <= GST_BUFFER_SIZE (nal)) { nalu_size = GST_READ_UINT32_BE (GST_BUFFER_DATA (nal) + offset); /* input may already be in byte-stream */ if (nalu_size == 1) break; GST_WRITE_UINT32_BE (GST_BUFFER_DATA (nal) + offset, 0x01); offset += nalu_size + 4; } } else { GstAdapter *adapter = gst_adapter_new (); GstBuffer *sub; while (offset + nal_length <= GST_BUFFER_SIZE (nal)) { nalu_size = 0; for (i = 0; i < nal_length; i++) nalu_size = (nalu_size << 8) | GST_BUFFER_DATA (nal)[i]; if (nalu_size > GST_BUFFER_SIZE (nal) - nal_length - offset) { GST_WARNING_OBJECT (h264parse, "NAL size %u is larger than buffer, " "reducing it to the buffer size: %u", nalu_size, GST_BUFFER_SIZE (nal) - nal_length - offset); nalu_size = GST_BUFFER_SIZE (nal) - nal_length - offset; } sub = gst_h264_parse_make_nal (h264parse, GST_BUFFER_DATA (nal) + nal_length + offset, nalu_size); gst_adapter_push (adapter, sub); offset += nalu_size + nal_length; } sub = gst_adapter_take_buffer (adapter, gst_adapter_available (adapter)); gst_buffer_copy_metadata (sub, nal, GST_BUFFER_COPY_ALL); gst_buffer_unref (nal); nal = sub; g_object_unref (adapter); } } /* in any case, ensure metadata can be messed with later on */ nal = gst_buffer_make_metadata_writable (nal); return nal; } /* sends a codec NAL downstream, decorating and transforming as needed. * No ownership is taken of @nal */ static GstFlowReturn gst_h264_parse_push_codec_buffer (GstH264Parse * h264parse, GstBuffer * nal, GstClockTime ts) { nal = gst_buffer_copy (nal); nal = gst_h264_parse_write_nal_prefix (h264parse, nal); GST_BUFFER_TIMESTAMP (nal) = ts; GST_BUFFER_DURATION (nal) = 0; gst_buffer_set_caps (nal, h264parse->src_caps); return gst_pad_push (h264parse->srcpad, nal); } /* sends buffer downstream, inserting codec_data NALUs if needed */ static GstFlowReturn gst_h264_parse_push_buffer (GstH264Parse * h264parse, GstBuffer * buf) { GstFlowReturn res = GST_FLOW_OK; /* We can send pending events if this is the first call, since we now have * caps for the srcpad */ if (G_UNLIKELY (h264parse->pending_segment != NULL)) { gst_pad_push_event (h264parse->srcpad, h264parse->pending_segment); h264parse->pending_segment = NULL; if (G_UNLIKELY (h264parse->pending_events != NULL)) { GList *l; for (l = h264parse->pending_events; l != NULL; l = l->next) gst_pad_push_event (h264parse->srcpad, GST_EVENT (l->data)); g_list_free (h264parse->pending_events); h264parse->pending_events = NULL; } } if (G_UNLIKELY (h264parse->width == 0 || h264parse->height == 0)) { GST_DEBUG ("Delaying actual push until we are configured"); h264parse->gather = g_list_append (h264parse->gather, buf); goto beach; } if (G_UNLIKELY (h264parse->gather)) { GList *pendingbuffers = h264parse->gather; GList *tmp; GST_DEBUG ("Pushing out pending buffers"); /* Yes, we're recursively calling in... */ h264parse->gather = NULL; for (tmp = pendingbuffers; tmp; tmp = tmp->next) { res = gst_h264_parse_push_buffer (h264parse, (GstBuffer *) tmp->data); if (res != GST_FLOW_OK && res != GST_FLOW_NOT_LINKED) break; } g_list_free (pendingbuffers); if (res != GST_FLOW_OK && res != GST_FLOW_NOT_LINKED) { gst_buffer_unref (buf); goto beach; } } /* start of picture is good time to slip in codec_data NALUs * (when outputting NALS and transforming to bytestream) */ if (G_UNLIKELY (h264parse->codec_nals && h264parse->picture_start)) { GSList *nals = h264parse->codec_nals; while (nals) { GST_DEBUG_OBJECT (h264parse, "pushing codec_nal of size %d", GST_BUFFER_SIZE (nals->data)); GST_BUFFER_TIMESTAMP (nals->data) = GST_BUFFER_TIMESTAMP (buf); GST_BUFFER_DURATION (nals->data) = 0; gst_buffer_set_caps (nals->data, h264parse->src_caps); (void) gst_pad_push (h264parse->srcpad, nals->data); nals = g_slist_delete_link (nals, nals); } h264parse->codec_nals = NULL; } /* periodic SPS/PPS sending */ if (h264parse->interval > 0) { gint nal_type = 0; guint8 *data = GST_BUFFER_DATA (buf); guint nal_length = h264parse->nal_length_size; guint64 diff; GstClockTime timestamp = GST_BUFFER_TIMESTAMP (buf); /* init */ if (!GST_CLOCK_TIME_IS_VALID (h264parse->last_report)) { h264parse->last_report = timestamp; } if (!h264parse->merge) { nal_type = data[nal_length] & 0x1f; GST_LOG_OBJECT (h264parse, "- nal type: %d", nal_type); } else if (h264parse->idr_offset >= 0) { GST_LOG_OBJECT (h264parse, "AU has IDR nal at offset %d", h264parse->idr_offset); nal_type = 5; } /* insert on IDR */ if (G_UNLIKELY (nal_type == 5)) { if (timestamp > h264parse->last_report) diff = timestamp - h264parse->last_report; else diff = 0; GST_LOG_OBJECT (h264parse, "now %" GST_TIME_FORMAT ", last SPS/PPS %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp), GST_TIME_ARGS (h264parse->last_report)); GST_DEBUG_OBJECT (h264parse, "interval since last SPS/PPS %" GST_TIME_FORMAT, GST_TIME_ARGS (diff)); if (GST_TIME_AS_SECONDS (diff) >= h264parse->interval) { gint i; if (!h264parse->merge) { /* send separate config NAL buffers */ GST_DEBUG_OBJECT (h264parse, "- sending SPS/PPS"); for (i = 0; i < MAX_SPS_COUNT; i++) { if (h264parse->sps_nals[i]) { GST_DEBUG_OBJECT (h264parse, "sending SPS nal"); gst_h264_parse_push_codec_buffer (h264parse, h264parse->sps_nals[i], timestamp); h264parse->last_report = timestamp; } } for (i = 0; i < MAX_PPS_COUNT; i++) { if (h264parse->pps_nals[i]) { GST_DEBUG_OBJECT (h264parse, "sending PPS nal"); gst_h264_parse_push_codec_buffer (h264parse, h264parse->pps_nals[i], timestamp); h264parse->last_report = timestamp; } } } else { /* insert config NALs into AU */ GstByteWriter bw; GstBuffer *codec_nal, *new_buf; gst_byte_writer_init_with_size (&bw, GST_BUFFER_SIZE (buf), FALSE); gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (buf), h264parse->idr_offset); GST_DEBUG_OBJECT (h264parse, "- inserting SPS/PPS"); for (i = 0; i < MAX_SPS_COUNT; i++) { if (h264parse->sps_nals[i]) { GST_DEBUG_OBJECT (h264parse, "inserting SPS nal"); codec_nal = gst_buffer_copy (h264parse->sps_nals[i]); codec_nal = gst_h264_parse_write_nal_prefix (h264parse, codec_nal); gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (codec_nal), GST_BUFFER_SIZE (codec_nal)); h264parse->last_report = timestamp; } } for (i = 0; i < MAX_PPS_COUNT; i++) { if (h264parse->pps_nals[i]) { GST_DEBUG_OBJECT (h264parse, "inserting PPS nal"); codec_nal = gst_buffer_copy (h264parse->pps_nals[i]); codec_nal = gst_h264_parse_write_nal_prefix (h264parse, codec_nal); gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (codec_nal), GST_BUFFER_SIZE (codec_nal)); h264parse->last_report = timestamp; } } gst_byte_writer_put_data (&bw, GST_BUFFER_DATA (buf) + h264parse->idr_offset, GST_BUFFER_SIZE (buf) - h264parse->idr_offset); /* collect result and push */ new_buf = gst_byte_writer_reset_and_get_buffer (&bw); gst_buffer_copy_metadata (new_buf, buf, GST_BUFFER_COPY_ALL); gst_buffer_unref (buf); buf = new_buf; } } } } gst_buffer_set_caps (buf, h264parse->src_caps); res = gst_pad_push (h264parse->srcpad, buf); beach: return res; } /* takes over ownership of nal and returns fresh buffer */ static GstBuffer * gst_h264_parse_push_nal (GstH264Parse * h264parse, GstBuffer * nal, guint8 * next_nal, gboolean * _start) { gint nal_type; guint8 *data; GstBuffer *outbuf = NULL; guint outsize, size, nal_length = h264parse->nal_length_size; gboolean start; gboolean complete; data = GST_BUFFER_DATA (nal); size = GST_BUFFER_SIZE (nal); /* deal with 3-byte start code by normalizing to 4-byte here */ if (!h264parse->packetized && data[2] == 0x01) { GstBuffer *tmp; /* ouch, copy */ GST_DEBUG_OBJECT (h264parse, "replacing 3-byte startcode"); tmp = gst_buffer_new_and_alloc (1); GST_BUFFER_DATA (tmp)[0] = 0; gst_buffer_ref (nal); tmp = gst_buffer_join (tmp, nal); GST_BUFFER_TIMESTAMP (tmp) = GST_BUFFER_TIMESTAMP (nal); gst_buffer_unref (nal); nal = tmp; data = GST_BUFFER_DATA (nal); size = GST_BUFFER_SIZE (nal); } /* caller ensures number of bytes available */ g_return_val_if_fail (size >= nal_length + 1, NULL); /* determine if AU complete */ nal_type = data[nal_length] & 0x1f; GST_LOG_OBJECT (h264parse, "nal type: %d", nal_type); h264parse->picture_start |= (nal_type == 1 || nal_type == 2 || nal_type == 5); /* first_mb_in_slice == 0 considered start of frame */ start = h264parse->picture_start && (data[nal_length + 1] & 0x80); if (G_UNLIKELY (!next_nal)) { complete = TRUE; } else { /* consider a coded slices (IDR or not) to start a picture, * (so ending the previous one) if first_mb_in_slice == 0 * (non-0 is part of previous one) */ /* NOTE this is not entirely according to Access Unit specs in 7.4.1.2.4, * but in practice it works in sane cases, needs not much parsing, * and also works with broken frame_num in NAL * (where spec-wise would fail) */ nal_type = next_nal[nal_length] & 0x1f; GST_LOG_OBJECT (h264parse, "next nal type: %d", nal_type); complete = h264parse->picture_start && (nal_type >= 6 && nal_type <= 9); complete |= h264parse->picture_start && (nal_type == 1 || nal_type == 2 || nal_type == 5) && (next_nal[nal_length + 1] & 0x80); } /* collect SPS and PPS NALUs to make up codec_data, if so needed */ nal_type = data[nal_length] & 0x1f; if (G_UNLIKELY (nal_type == NAL_SPS)) { GstNalBs bs; guint id; gst_nal_bs_init (&bs, data + nal_length + 1, size - nal_length - 1); gst_nal_bs_read (&bs, 24); /* profile_idc, profile_compatibility, level_idc */ id = gst_nal_bs_read_ue (&bs); if (!gst_nal_bs_eos (&bs) && id < MAX_SPS_COUNT) { GST_DEBUG_OBJECT (h264parse, "storing SPS id %d", id); gst_buffer_replace (&h264parse->sps_nals[id], NULL); h264parse->sps_nals[id] = gst_h264_parse_make_nal (h264parse, data + nal_length, size - nal_length); gst_h264_parse_update_src_caps (h264parse, NULL); } } else if (G_UNLIKELY (nal_type == NAL_PPS)) { GstNalBs bs; guint id; gst_nal_bs_init (&bs, data + nal_length + 1, size - nal_length - 1); id = gst_nal_bs_read_ue (&bs); if (!gst_nal_bs_eos (&bs) && id < MAX_PPS_COUNT) { GST_DEBUG_OBJECT (h264parse, "storing PPS id %d", id); gst_buffer_replace (&h264parse->pps_nals[id], NULL); h264parse->pps_nals[id] = gst_h264_parse_make_nal (h264parse, data + nal_length, size - nal_length); gst_h264_parse_update_src_caps (h264parse, NULL); } } if (h264parse->merge) { /* clear IDR mark state */ if (gst_adapter_available (h264parse->picture_adapter) == 0) h264parse->idr_offset = -1; /* proper prefix */ nal = gst_h264_parse_write_nal_prefix (h264parse, nal); /* start of a picture is a good time to insert codec SPS and PPS */ if (G_UNLIKELY (h264parse->codec_nals && h264parse->picture_start)) { while (h264parse->codec_nals) { GST_DEBUG_OBJECT (h264parse, "inserting codec_nal of size %d into AU", GST_BUFFER_SIZE (h264parse->codec_nals->data)); gst_adapter_push (h264parse->picture_adapter, h264parse->codec_nals->data); h264parse->codec_nals = g_slist_delete_link (h264parse->codec_nals, h264parse->codec_nals); } } /* mark IDR nal location for later possible config insertion */ if (nal_type == 5 && h264parse->idr_offset < 0) h264parse->idr_offset = gst_adapter_available (h264parse->picture_adapter); /* regardless, collect this NALU */ gst_adapter_push (h264parse->picture_adapter, nal); if (complete) { GstClockTime ts; h264parse->picture_start = FALSE; ts = gst_adapter_prev_timestamp (h264parse->picture_adapter, NULL); outsize = gst_adapter_available (h264parse->picture_adapter); outbuf = gst_adapter_take_buffer (h264parse->picture_adapter, outsize); outbuf = gst_buffer_make_metadata_writable (outbuf); GST_BUFFER_TIMESTAMP (outbuf) = ts; /* AU always starts a frame */ start = TRUE; } } else { outbuf = gst_h264_parse_write_nal_prefix (h264parse, nal); } if (_start) *_start = start; return outbuf; } 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; gst_adapter_clear (h264parse->picture_adapter); h264parse->picture_start = 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 + 2) break; data = gst_adapter_peek (h264parse->adapter, avail); if (!h264parse->packetized) { /* Bytestream format, first 3/4 bytes are sync code */ /* re-sync; locate initial startcode */ if (G_UNLIKELY (h264parse->discont)) { guint32 value; /* check for initial 00 00 01 */ i = gst_adapter_masked_scan_uint32 (h264parse->adapter, 0xffffff00, 0x00000100, 0, 4); if (i < 0) { i = gst_adapter_masked_scan_uint32_peek (h264parse->adapter, 0x00ffffff, 0x01, 0, avail, &value); if (i < 0) { /* no sync code, flush and try next time */ gst_adapter_flush (h264parse->adapter, avail - 2); break; } else { if (value >> 24 != 00) /* so a 3 byte startcode */ i++; gst_adapter_flush (h264parse->adapter, i); avail -= i; data = gst_adapter_peek (h264parse->adapter, avail); } } GST_DEBUG_OBJECT (h264parse, "re-sync found startcode at %d", i); } /* Find next NALU header, might be 3 or 4 bytes */ for (i = 1; i < avail - 4; ++i) { if (data[i + 1] == 0 && data[i + 2] == 0 && data[i + 3] == 1) { if (data[i + 0] == 0) next_nalu_pos = i; else next_nalu_pos = i + 1; break; } } /* skip sync */ if (data[2] == 0x1) { data += 3; avail -= 3; } else { data += 4; avail -= 4; } } 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 */ 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; gboolean start; guint8 *next_data; outbuf_dts = gst_adapter_prev_timestamp (h264parse->adapter, NULL); /* Better value for the second parameter? */ outbuf = gst_adapter_take_buffer (h264parse->adapter, next_nalu_pos); /* packetized will have no next data, which serves fine here */ next_data = (guint8 *) gst_adapter_peek (h264parse->adapter, 6); outbuf = gst_h264_parse_push_nal (h264parse, outbuf, next_data, &start); if (!outbuf) { /* no complete unit yet, go for next round */ continue; } /* 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) && start) { 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); res = gst_h264_parse_push_buffer (h264parse, 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; h264parse->decode = gst_nal_list_delete_head (h264parse->decode); h264parse->decode_len--; GST_DEBUG_OBJECT (h264parse, "have type: %d, I frame: %d", link->nal_type, link->i_frame); buf = gst_h264_parse_push_nal (h264parse, buf, h264parse->decode ? GST_BUFFER_DATA (h264parse->decode->buffer) : NULL, NULL); if (!buf) continue; 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))); gst_buffer_set_caps (buf, h264parse->src_caps); res = gst_pad_push (h264parse->srcpad, buf); } /* 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, last; guint32 code; GstBuffer *prev; GstClockTime timestamp; GST_DEBUG_OBJECT (h264parse, "received discont, copy gathered buffers for decoding"); /* init start code accumulator */ 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 (!h264parse->src_caps) { /* 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); /* 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; h264parse->src_caps = 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; } 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); h264parse->last_outbuf_dts = GST_CLOCK_TIME_NONE; res = gst_pad_push_event (h264parse->srcpad, event); break; case GST_EVENT_EOS: GST_DEBUG_OBJECT (h264parse, "received EOS"); if (h264parse->pending_segment) { /* Send pending newsegment before EOS */ gst_pad_push_event (h264parse->srcpad, h264parse->pending_segment); h264parse->pending_segment = NULL; } 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; GstEvent **ev; 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, "Keeping 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); ev = &h264parse->pending_segment; gst_event_replace (ev, event); gst_event_unref (event); res = TRUE; break; } case GST_EVENT_FLUSH_START: { res = gst_pad_push_event (h264parse->srcpad, event); break; } default: { if (G_UNLIKELY (h264parse->src_caps == NULL || h264parse->pending_segment)) { /* We don't yet have enough data to set caps on the srcpad, so collect * non-critical events till we do */ h264parse->pending_events = g_list_append (h264parse->pending_events, event); res = TRUE; } else 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); gst_h264_parse_reset (h264parse); break; default: break; } return ret; } static gboolean plugin_init (GstPlugin * plugin) { return gst_element_register (plugin, "legacyh264parse", 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)