static gboolean gst_isoff_traf_box_parse (GstTrafBox * traf, GstByteReader * reader) { gboolean had_tfhd = FALSE; memset (traf, 0, sizeof (*traf)); traf->trun = g_array_new (FALSE, FALSE, sizeof (GstTrunBox)); g_array_set_clear_func (traf->trun, (GDestroyNotify) gst_isoff_trun_box_clear); while (gst_byte_reader_get_remaining (reader) > 0) { guint32 fourcc; guint header_size; guint64 size; if (!gst_isoff_parse_box_header (reader, &fourcc, NULL, &header_size, &size)) goto error; if (gst_byte_reader_get_remaining (reader) < size - header_size) goto error; switch (fourcc) { case GST_ISOFF_FOURCC_TFHD:{ GstByteReader sub_reader; gst_byte_reader_get_sub_reader (reader, &sub_reader, size - header_size); if (!gst_isoff_tfhd_box_parse (&traf->tfhd, &sub_reader)) goto error; had_tfhd = TRUE; break; } case GST_ISOFF_FOURCC_TRUN:{ GstByteReader sub_reader; GstTrunBox trun; gst_byte_reader_get_sub_reader (reader, &sub_reader, size - header_size); if (!gst_isoff_trun_box_parse (&trun, &sub_reader)) goto error; g_array_append_val (traf->trun, trun); break; } default: gst_byte_reader_skip (reader, size - header_size); break; } } if (!had_tfhd) goto error; return TRUE; error: gst_isoff_traf_box_clear (traf); return FALSE; }
static GstBuffer * gst_vdp_mpeg_packetizer_get_next_packet (GstVdpMpegPacketizer * packetizer) { guint offset, size; GstBuffer *buf; if (packetizer->start == -1) return NULL; if (!gst_byte_reader_set_pos (&packetizer->reader, packetizer->start + 3)) return NULL; offset = gst_byte_reader_masked_scan_uint32 (&packetizer->reader, 0xffffff00, 0x00000100, 0, gst_byte_reader_get_remaining (&packetizer->reader)); if (offset != -1) { offset = gst_byte_reader_get_pos (&packetizer->reader) + offset; size = offset - packetizer->start; } else size = gst_byte_reader_get_remaining (&packetizer->reader) + 3; buf = gst_buffer_create_sub (packetizer->buffer, packetizer->start, size); packetizer->start = offset; return buf; }
GstMoofBox * gst_isoff_moof_box_parse (GstByteReader * reader) { GstMoofBox *moof; gboolean had_mfhd = FALSE; moof = g_new0 (GstMoofBox, 1); moof->traf = g_array_new (FALSE, FALSE, sizeof (GstTrafBox)); g_array_set_clear_func (moof->traf, (GDestroyNotify) gst_isoff_traf_box_clear); while (gst_byte_reader_get_remaining (reader) > 0) { guint32 fourcc; guint header_size; guint64 size; if (!gst_isoff_parse_box_header (reader, &fourcc, NULL, &header_size, &size)) goto error; if (gst_byte_reader_get_remaining (reader) < size - header_size) goto error; switch (fourcc) { case GST_ISOFF_FOURCC_MFHD:{ GstByteReader sub_reader; gst_byte_reader_get_sub_reader (reader, &sub_reader, size - header_size); if (!gst_isoff_mfhd_box_parse (&moof->mfhd, &sub_reader)) goto error; had_mfhd = TRUE; break; } case GST_ISOFF_FOURCC_TRAF:{ GstByteReader sub_reader; GstTrafBox traf; gst_byte_reader_get_sub_reader (reader, &sub_reader, size - header_size); if (!gst_isoff_traf_box_parse (&traf, &sub_reader)) goto error; g_array_append_val (moof->traf, traf); break; } default: gst_byte_reader_skip (reader, size - header_size); break; } } if (!had_mfhd) goto error; return moof; error: gst_isoff_moof_box_free (moof); return NULL; }
static guint find_psc (GstBuffer * buffer, guint skip) { GstMapInfo map; GstByteReader br; guint psc_pos = -1, psc; gst_buffer_map (buffer, &map, GST_MAP_READ); gst_byte_reader_init (&br, map.data, map.size); if (!gst_byte_reader_set_pos (&br, skip)) goto out; if (gst_byte_reader_peek_uint24_be (&br, &psc) == FALSE) goto out; /* Scan for the picture start code (22 bits - 0x0020) */ while ((gst_byte_reader_get_remaining (&br) >= 3)) { if (gst_byte_reader_peek_uint24_be (&br, &psc) && ((psc & 0xffffc0) == 0x000080)) { psc_pos = gst_byte_reader_get_pos (&br); break; } else if (gst_byte_reader_skip (&br, 1) == FALSE) break; } out: gst_buffer_unmap (buffer, &map); return psc_pos; }
static gboolean gst_isoff_trun_box_parse (GstTrunBox * trun, GstByteReader * reader) { gint i; memset (trun, 0, sizeof (*trun)); if (gst_byte_reader_get_remaining (reader) < 4) return FALSE; trun->version = gst_byte_reader_get_uint8_unchecked (reader); if (trun->version != 0 && trun->version != 1) return FALSE; trun->flags = gst_byte_reader_get_uint24_be_unchecked (reader); if (!gst_byte_reader_get_uint32_be (reader, &trun->sample_count)) return FALSE; trun->samples = g_array_sized_new (FALSE, FALSE, sizeof (GstTrunSample), trun->sample_count); if ((trun->flags & GST_TRUN_FLAGS_DATA_OFFSET_PRESENT) && !gst_byte_reader_get_uint32_be (reader, (guint32 *) & trun->data_offset)) return FALSE; if ((trun->flags & GST_TRUN_FLAGS_FIRST_SAMPLE_FLAGS_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &trun->first_sample_flags)) return FALSE; for (i = 0; i < trun->sample_count; i++) { GstTrunSample sample = { 0, }; if ((trun->flags & GST_TRUN_FLAGS_SAMPLE_DURATION_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &sample.sample_duration)) goto error; if ((trun->flags & GST_TRUN_FLAGS_SAMPLE_SIZE_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &sample.sample_size)) goto error; if ((trun->flags & GST_TRUN_FLAGS_SAMPLE_FLAGS_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &sample.sample_flags)) goto error; if ((trun->flags & GST_TRUN_FLAGS_SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &sample.sample_composition_time_offset.u)) goto error; g_array_append_val (trun->samples, sample); } return TRUE; error: gst_isoff_trun_box_clear (trun); return FALSE; }
static guint find_psc (GstBuffer * buffer, guint skip) { GstByteReader br; guint psc_pos = -1, psc; gst_byte_reader_init_from_buffer (&br, buffer); if (!gst_byte_reader_set_pos (&br, skip)) goto out; gst_byte_reader_peek_uint24_be (&br, &psc); /* Scan for the picture start code (22 bits - 0x0020) */ while ((gst_byte_reader_get_remaining (&br) >= 3)) { if (gst_byte_reader_peek_uint24_be (&br, &psc) && ((psc & 0xffffc0) == 0x000080)) { psc_pos = gst_byte_reader_get_pos (&br); break; } else gst_byte_reader_skip (&br, 1); } out: return psc_pos; }
static inline gboolean gst_jpeg_parse_remove_marker (GstJpegParse * parse, GstByteReader * reader, guint8 marker, GstBuffer * buffer) { guint16 size = 0; guint pos = gst_byte_reader_get_pos (reader); guint8 *data; gsize bsize; if (!gst_byte_reader_peek_uint16_be (reader, &size)) return FALSE; if (gst_byte_reader_get_remaining (reader) < size) return FALSE; GST_LOG_OBJECT (parse, "unhandled marker %x removing %u bytes", marker, size); data = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READWRITE); memmove (&data[pos], &data[pos + size], bsize - (pos + size)); gst_buffer_unmap (buffer, data, bsize - size); if (!gst_byte_reader_set_pos (reader, pos - size)) return FALSE; return TRUE; }
/* gst_isoff_parse_box: * @reader: * @type: type that was found at the current position * @extended_type: (allow-none): extended type if type=='uuid' * @header_size: (allow-none): size of the box header (type, extended type and size) * @size: size of the complete box including type, extended type and size * * Advances the byte reader to the start of the box content. To skip * over the complete box, skip size - header_size bytes. * * Returns: TRUE if a box header could be parsed, FALSE if more data is needed */ gboolean gst_isoff_parse_box_header (GstByteReader * reader, guint32 * type, guint8 extended_type[16], guint * header_size, guint64 * size) { guint header_start_offset; guint32 size_field; header_start_offset = gst_byte_reader_get_pos (reader); if (gst_byte_reader_get_remaining (reader) < 8) goto not_enough_data; size_field = gst_byte_reader_get_uint32_be_unchecked (reader); *type = gst_byte_reader_get_uint32_le_unchecked (reader); if (size_field == 1) { if (gst_byte_reader_get_remaining (reader) < 8) goto not_enough_data; *size = gst_byte_reader_get_uint64_be_unchecked (reader); } else { *size = size_field; } if (*type == GST_ISOFF_FOURCC_UUID) { if (gst_byte_reader_get_remaining (reader) < 16) goto not_enough_data; if (extended_type) memcpy (extended_type, gst_byte_reader_get_data_unchecked (reader, 16), 16); } if (header_size) *header_size = gst_byte_reader_get_pos (reader) - header_start_offset; return TRUE; not_enough_data: gst_byte_reader_set_pos (reader, header_start_offset); return FALSE; }
static void gst_vdp_mpeg_packetizer_init (GstVdpMpegPacketizer * packetizer, GstBuffer * buffer) { guint offset; gst_byte_reader_init_from_buffer (&packetizer->reader, buffer); packetizer->buffer = buffer; offset = gst_byte_reader_masked_scan_uint32 (&packetizer->reader, 0xffffff00, 0x00000100, 0, gst_byte_reader_get_remaining (&packetizer->reader)); packetizer->start = offset; }
/* finds next startcode == 00 00 01, along with a subsequent byte */ static guint gst_h264_parse_find_sc (GstBuffer * buffer, guint skip) { GstByteReader br; guint sc_pos = -1; gst_byte_reader_init_from_buffer (&br, buffer); /* NALU not empty, so we can at least expect 1 (even 2) bytes following sc */ sc_pos = gst_byte_reader_masked_scan_uint32 (&br, 0xffffff00, 0x00000100, skip, gst_byte_reader_get_remaining (&br) - skip); return sc_pos; }
EXPORT_C #endif gboolean gst_byte_reader_skip (GstByteReader * reader, guint nbytes) { g_return_val_if_fail (reader != NULL, FALSE); if (gst_byte_reader_get_remaining (reader) < nbytes) return FALSE; reader->byte += nbytes; return TRUE; }
EXPORT_C #endif gboolean gst_byte_reader_peek_data (GstByteReader * reader, guint size, const guint8 ** val) { g_return_val_if_fail (reader != NULL, FALSE); g_return_val_if_fail (val != NULL, FALSE); if (gst_byte_reader_get_remaining (reader) < size) return FALSE; *val = reader->data + reader->byte; return TRUE; }
EXPORT_C #endif gboolean gst_byte_reader_peek_uint24_le (GstByteReader * reader, guint32 * val) { g_return_val_if_fail (reader != NULL, FALSE); g_return_val_if_fail (val != NULL, FALSE); if (gst_byte_reader_get_remaining (reader) < 3) return FALSE; *val = GST_READ_UINT24_LE (&reader->data[reader->byte]); return TRUE; }
GstIsoffParserResult gst_isoff_sidx_parser_add_buffer (GstSidxParser * parser, GstBuffer * buffer, guint * consumed) { GstIsoffParserResult res = GST_ISOFF_PARSER_OK; GstByteReader reader; GstMapInfo info; guint32 fourcc; if (!gst_buffer_map (buffer, &info, GST_MAP_READ)) { *consumed = 0; return GST_ISOFF_PARSER_ERROR; } gst_byte_reader_init (&reader, info.data, info.size); if (parser->status == GST_ISOFF_SIDX_PARSER_INIT) { if (!gst_isoff_parse_box_header (&reader, &fourcc, NULL, NULL, &parser->size)) goto done; if (fourcc != GST_ISOFF_FOURCC_SIDX) { res = GST_ISOFF_PARSER_UNEXPECTED; gst_byte_reader_set_pos (&reader, 0); goto done; } if (parser->size == 0) { res = GST_ISOFF_PARSER_ERROR; gst_byte_reader_set_pos (&reader, 0); goto done; } /* Try again once we have enough data for the FullBox header */ if (gst_byte_reader_get_remaining (&reader) < 4) { gst_byte_reader_set_pos (&reader, 0); goto done; } } res = gst_isoff_sidx_parser_parse (parser, &reader, consumed); done: gst_buffer_unmap (buffer, &info); return res; }
static gboolean gst_isoff_mfhd_box_parse (GstMfhdBox * mfhd, GstByteReader * reader) { guint8 version; guint32 flags; if (gst_byte_reader_get_remaining (reader) != 8) return FALSE; version = gst_byte_reader_get_uint8_unchecked (reader); if (version != 0) return FALSE; flags = gst_byte_reader_get_uint24_be_unchecked (reader); if (flags != 0) return FALSE; mfhd->sequence_number = gst_byte_reader_get_uint32_be_unchecked (reader); return TRUE; }
EXPORT_C #endif gboolean gst_byte_reader_peek_int24_be (GstByteReader * reader, gint32 * val) { guint32 ret; g_return_val_if_fail (reader != NULL, FALSE); g_return_val_if_fail (val != NULL, FALSE); if (gst_byte_reader_get_remaining (reader) < 3) return FALSE; ret = GST_READ_UINT24_BE (&reader->data[reader->byte]); if (ret & 0x00800000) ret |= 0xff000000; *val = ret; return TRUE; }
static gboolean gst_isoff_tfhd_box_parse (GstTfhdBox * tfhd, GstByteReader * reader) { memset (tfhd, 0, sizeof (*tfhd)); if (gst_byte_reader_get_remaining (reader) < 4) return FALSE; tfhd->version = gst_byte_reader_get_uint8_unchecked (reader); if (tfhd->version != 0) return FALSE; tfhd->flags = gst_byte_reader_get_uint24_be_unchecked (reader); if (!gst_byte_reader_get_uint32_be (reader, &tfhd->track_id)) return FALSE; if ((tfhd->flags & GST_TFHD_FLAGS_BASE_DATA_OFFSET_PRESENT) && !gst_byte_reader_get_uint64_be (reader, &tfhd->base_data_offset)) return FALSE; if ((tfhd->flags & GST_TFHD_FLAGS_SAMPLE_DESCRIPTION_INDEX_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &tfhd->sample_description_index)) return FALSE; if ((tfhd->flags & GST_TFHD_FLAGS_DEFAULT_SAMPLE_DURATION_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &tfhd->default_sample_duration)) return FALSE; if ((tfhd->flags & GST_TFHD_FLAGS_DEFAULT_SAMPLE_SIZE_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &tfhd->default_sample_size)) return FALSE; if ((tfhd->flags & GST_TFHD_FLAGS_DEFAULT_SAMPLE_FLAGS_PRESENT) && !gst_byte_reader_get_uint32_be (reader, &tfhd->default_sample_flags)) return FALSE; return TRUE; }
static guint find_psc (GstByteReader * br) { guint psc_pos = -1, psc; if (!gst_byte_reader_peek_uint24_be (br, &psc)) goto failed; /* Scan for the picture start code (22 bits - 0x0020) */ while ((gst_byte_reader_get_remaining (br) >= 3)) { if (gst_byte_reader_peek_uint24_be (br, &psc) && ((psc & 0xfffffc) == 0x000080)) { psc_pos = gst_byte_reader_get_pos (br); break; } else gst_byte_reader_skip_unchecked (br, 1); } failed: return psc_pos; }
static inline gboolean gst_jpeg_parse_remove_marker (GstJpegParse * parse, GstByteReader * reader, guint8 marker, GstBuffer * buffer) { guint16 size = 0; guint pos = gst_byte_reader_get_pos (reader); guint8 *data = GST_BUFFER_DATA (buffer); if (!gst_byte_reader_peek_uint16_be (reader, &size)) return FALSE; if (gst_byte_reader_get_remaining (reader) < size) return FALSE; GST_LOG_OBJECT (parse, "unhandled marker %x removing %u bytes", marker, size); memmove (&data[pos], &data[pos + size], GST_BUFFER_SIZE (buffer) - (pos + size)); GST_BUFFER_SIZE (buffer) -= size; if (!gst_byte_reader_set_pos (reader, pos - size)) return FALSE; return TRUE; }
GstIsoffParserResult gst_isoff_sidx_parser_parse (GstSidxParser * parser, GstByteReader * reader, guint * consumed) { GstIsoffParserResult res = GST_ISOFF_PARSER_OK; gsize remaining; switch (parser->status) { case GST_ISOFF_SIDX_PARSER_INIT: /* Try again once we have enough data for the FullBox header */ if (gst_byte_reader_get_remaining (reader) < 4) { gst_byte_reader_set_pos (reader, 0); break; } parser->sidx.version = gst_byte_reader_get_uint8_unchecked (reader); parser->sidx.flags = gst_byte_reader_get_uint24_le_unchecked (reader); parser->status = GST_ISOFF_SIDX_PARSER_HEADER; case GST_ISOFF_SIDX_PARSER_HEADER: remaining = gst_byte_reader_get_remaining (reader); if (remaining < 12 + (parser->sidx.version == 0 ? 8 : 16)) { break; } parser->sidx.ref_id = gst_byte_reader_get_uint32_be_unchecked (reader); parser->sidx.timescale = gst_byte_reader_get_uint32_be_unchecked (reader); if (parser->sidx.version == 0) { parser->sidx.earliest_pts = gst_byte_reader_get_uint32_be_unchecked (reader); parser->sidx.first_offset = gst_byte_reader_get_uint32_be_unchecked (reader); } else { parser->sidx.earliest_pts = gst_byte_reader_get_uint64_be_unchecked (reader); parser->sidx.first_offset = gst_byte_reader_get_uint64_be_unchecked (reader); } /* skip 2 reserved bytes */ gst_byte_reader_skip_unchecked (reader, 2); parser->sidx.entries_count = gst_byte_reader_get_uint16_be_unchecked (reader); GST_LOG ("Timescale: %" G_GUINT32_FORMAT, parser->sidx.timescale); GST_LOG ("Earliest pts: %" G_GUINT64_FORMAT, parser->sidx.earliest_pts); GST_LOG ("First offset: %" G_GUINT64_FORMAT, parser->sidx.first_offset); parser->cumulative_pts = gst_util_uint64_scale_int_round (parser->sidx.earliest_pts, GST_SECOND, parser->sidx.timescale); if (parser->sidx.entries_count) { parser->sidx.entries = g_malloc (sizeof (GstSidxBoxEntry) * parser->sidx.entries_count); } parser->sidx.entry_index = 0; parser->status = GST_ISOFF_SIDX_PARSER_DATA; case GST_ISOFF_SIDX_PARSER_DATA: while (parser->sidx.entry_index < parser->sidx.entries_count) { GstSidxBoxEntry *entry = &parser->sidx.entries[parser->sidx.entry_index]; remaining = gst_byte_reader_get_remaining (reader); if (remaining < 12) break; entry->offset = parser->cumulative_entry_size; entry->pts = parser->cumulative_pts; gst_isoff_parse_sidx_entry (entry, reader); entry->duration = gst_util_uint64_scale_int_round (entry->duration, GST_SECOND, parser->sidx.timescale); parser->cumulative_entry_size += entry->size; parser->cumulative_pts += entry->duration; GST_LOG ("Sidx entry %d) offset: %" G_GUINT64_FORMAT ", pts: %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT " - size %" G_GUINT32_FORMAT, parser->sidx.entry_index, entry->offset, GST_TIME_ARGS (entry->pts), GST_TIME_ARGS (entry->duration), entry->size); parser->sidx.entry_index++; } if (parser->sidx.entry_index == parser->sidx.entries_count) parser->status = GST_ISOFF_SIDX_PARSER_FINISHED; else break; case GST_ISOFF_SIDX_PARSER_FINISHED: parser->sidx.entry_index = 0; res = GST_ISOFF_PARSER_DONE; break; } *consumed = gst_byte_reader_get_pos (reader); return res; }
static gboolean gst_jif_mux_parse_image (GstJifMux * self, GstBuffer * buf) { GstByteReader reader = GST_BYTE_READER_INIT_FROM_BUFFER (buf); GstJifMuxMarker *m; guint8 marker = 0; guint16 size = 0; const guint8 *data = NULL; GST_LOG_OBJECT (self, "Received buffer of size: %u", GST_BUFFER_SIZE (buf)); if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; while (marker == 0xff) { if (!gst_byte_reader_skip (&reader, 1)) goto error; if (!gst_byte_reader_get_uint8 (&reader, &marker)) goto error; switch (marker) { case RST0: case RST1: case RST2: case RST3: case RST4: case RST5: case RST6: case RST7: case SOI: GST_DEBUG_OBJECT (self, "marker = %x", marker); m = gst_jif_mux_new_marker (marker, 0, NULL, FALSE); self->priv->markers = g_list_prepend (self->priv->markers, m); break; case EOI: GST_DEBUG_OBJECT (self, "marker = %x", marker); m = gst_jif_mux_new_marker (marker, 0, NULL, FALSE); self->priv->markers = g_list_prepend (self->priv->markers, m); goto done; break; default: if (!gst_byte_reader_get_uint16_be (&reader, &size)) goto error; if (!gst_byte_reader_get_data (&reader, size - 2, &data)) goto error; m = gst_jif_mux_new_marker (marker, size - 2, data, FALSE); self->priv->markers = g_list_prepend (self->priv->markers, m); GST_DEBUG_OBJECT (self, "marker = %2x, size = %u", marker, size); break; } if (marker == SOS) { gint eoi_pos = -1; gint i; /* search the last 5 bytes for the EOI marker */ g_assert (GST_BUFFER_SIZE (buf) >= 5); for (i = 5; i >= 2; i--) { if (GST_BUFFER_DATA (buf)[GST_BUFFER_SIZE (buf) - i] == 0xFF && GST_BUFFER_DATA (buf)[GST_BUFFER_SIZE (buf) - i + 1] == EOI) { eoi_pos = GST_BUFFER_SIZE (buf) - i; break; } } if (eoi_pos == -1) { GST_WARNING_OBJECT (self, "Couldn't find an EOI marker"); eoi_pos = GST_BUFFER_SIZE (buf); } /* remaining size except EOI is scan data */ self->priv->scan_size = eoi_pos - gst_byte_reader_get_pos (&reader); if (!gst_byte_reader_get_data (&reader, self->priv->scan_size, &self->priv->scan_data)) goto error; GST_DEBUG_OBJECT (self, "scan data, size = %u", self->priv->scan_size); } if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; } GST_INFO_OBJECT (self, "done parsing at 0x%x / 0x%x", gst_byte_reader_get_pos (&reader), GST_BUFFER_SIZE (buf)); done: self->priv->markers = g_list_reverse (self->priv->markers); return TRUE; error: GST_WARNING_OBJECT (self, "Error parsing image header (need more that %u bytes available)", gst_byte_reader_get_remaining (&reader)); return FALSE; }
static gboolean gst_jpeg_parse_read_header (GstJpegParse * parse, GstBuffer * buffer) { GstByteReader reader = GST_BYTE_READER_INIT_FROM_BUFFER (buffer); guint8 marker = 0; gboolean foundSOF = FALSE; if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; while (marker == 0xff) { if (!gst_byte_reader_skip (&reader, 1)) goto error; if (!gst_byte_reader_get_uint8 (&reader, &marker)) goto error; GST_DEBUG_OBJECT (parse, "marker = %x", marker); switch (marker) { case SOS: /* start of scan (begins compressed data) */ return foundSOF; case SOI: break; case DRI: if (!gst_byte_reader_skip (&reader, 4)) /* fixed size */ goto error; break; case COM: if (!gst_jpeg_parse_com (parse, &reader)) goto error; break; case APP1: if (!gst_jpeg_parse_app1 (parse, &reader)) goto error; break; case DHT: case DQT: /* Ignore these codes */ if (!gst_jpeg_parse_skip_marker (parse, &reader, marker)) goto error; break; case SOF2: parse->priv->interlaced = TRUE; /* fall through */ case SOF0: foundSOF = TRUE; /* parse Start Of Frame */ if (!gst_jpeg_parse_sof (parse, &reader)) goto error; return TRUE; default: if (marker == JPG || (marker >= JPG0 && marker <= JPG13)) { /* we'd like to remove them from the buffer */ if (!gst_jpeg_parse_remove_marker (parse, &reader, marker, buffer)) goto error; } else if (marker >= APP0 && marker <= APP15) { if (!gst_jpeg_parse_skip_marker (parse, &reader, marker)) goto error; } else { GST_WARNING_OBJECT (parse, "unhandled marker %x, leaving", marker); /* Not SOF or SOI. Must not be a JPEG file (or file pointer * is placed wrong). In either case, it's an error. */ return FALSE; } } if (!gst_byte_reader_peek_uint8 (&reader, &marker)) goto error; } return foundSOF; error: GST_WARNING_OBJECT (parse, "Error parsing image header (need more than %u bytes available)", gst_byte_reader_get_remaining (&reader)); return FALSE; }
static GstFlowReturn gst_pngdec_parse (GstVideoDecoder * decoder, GstVideoCodecFrame * frame, GstAdapter * adapter, gboolean at_eos) { gsize toadd = 0; GstByteReader reader; gconstpointer data; guint64 signature; gsize size; GstPngDec *pngdec = (GstPngDec *) decoder; GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame); /* FIXME : The overhead of using scan_uint32 is massive */ size = gst_adapter_available (adapter); GST_DEBUG ("Parsing PNG image data (%" G_GSIZE_FORMAT " bytes)", size); if (size < 8) goto need_more_data; data = gst_adapter_map (adapter, size); gst_byte_reader_init (&reader, data, size); if (pngdec->read_data == 0) { if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto need_more_data; if (signature != PNG_SIGNATURE) { for (;;) { guint offset; offset = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, 0x89504E47, 0, gst_byte_reader_get_remaining (&reader)); if (offset == -1) { gst_adapter_flush (adapter, gst_byte_reader_get_remaining (&reader) - 4); goto need_more_data; } if (!gst_byte_reader_skip (&reader, offset)) goto need_more_data; if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto need_more_data; if (signature == PNG_SIGNATURE) { /* We're skipping, go out, we'll be back */ gst_adapter_flush (adapter, gst_byte_reader_get_pos (&reader)); goto need_more_data; } if (!gst_byte_reader_skip (&reader, 4)) goto need_more_data; } } pngdec->read_data = 8; } if (!gst_byte_reader_skip (&reader, pngdec->read_data)) goto need_more_data; for (;;) { guint32 length; guint32 code; if (!gst_byte_reader_get_uint32_be (&reader, &length)) goto need_more_data; if (!gst_byte_reader_get_uint32_le (&reader, &code)) goto need_more_data; if (!gst_byte_reader_skip (&reader, length + 4)) goto need_more_data; if (code == GST_MAKE_FOURCC ('I', 'E', 'N', 'D')) { /* Have complete frame */ toadd = gst_byte_reader_get_pos (&reader); GST_DEBUG_OBJECT (decoder, "Have complete frame of size %" G_GSIZE_FORMAT, toadd); pngdec->read_data = 0; goto have_full_frame; } else pngdec->read_data += length + 12; } g_assert_not_reached (); return GST_FLOW_ERROR; need_more_data: return GST_VIDEO_DECODER_FLOW_NEED_DATA; have_full_frame: if (toadd) gst_video_decoder_add_to_frame (decoder, toadd); return gst_video_decoder_have_frame (decoder); }
GstIsoffParserResult gst_isoff_sidx_parser_add_buffer (GstSidxParser * parser, GstBuffer * buffer, guint * consumed) { GstIsoffParserResult res = GST_ISOFF_PARSER_OK; GstByteReader reader; GstMapInfo info; gsize remaining; guint32 fourcc; if (!gst_buffer_map (buffer, &info, GST_MAP_READ)) { *consumed = 0; return GST_ISOFF_PARSER_ERROR; } gst_byte_reader_init (&reader, info.data, info.size); switch (parser->status) { case GST_ISOFF_SIDX_PARSER_INIT: if (gst_byte_reader_get_remaining (&reader) < GST_ISOFF_FULL_BOX_SIZE) { break; } parser->size = gst_byte_reader_get_uint32_be_unchecked (&reader); fourcc = gst_byte_reader_get_uint32_le_unchecked (&reader); if (fourcc != GST_ISOFF_FOURCC_SIDX) { res = GST_ISOFF_PARSER_UNEXPECTED; gst_byte_reader_set_pos (&reader, 0); break; } if (parser->size == 1) { if (gst_byte_reader_get_remaining (&reader) < 12) { gst_byte_reader_set_pos (&reader, 0); break; } parser->size = gst_byte_reader_get_uint64_be_unchecked (&reader); } if (parser->size == 0) { res = GST_ISOFF_PARSER_ERROR; gst_byte_reader_set_pos (&reader, 0); break; } parser->sidx.version = gst_byte_reader_get_uint8_unchecked (&reader); parser->sidx.flags = gst_byte_reader_get_uint24_le_unchecked (&reader); parser->status = GST_ISOFF_SIDX_PARSER_HEADER; case GST_ISOFF_SIDX_PARSER_HEADER: remaining = gst_byte_reader_get_remaining (&reader); if (remaining < 12 + (parser->sidx.version == 0 ? 8 : 16)) { break; } parser->sidx.ref_id = gst_byte_reader_get_uint32_be_unchecked (&reader); parser->sidx.timescale = gst_byte_reader_get_uint32_be_unchecked (&reader); if (parser->sidx.version == 0) { parser->sidx.earliest_pts = gst_byte_reader_get_uint32_be_unchecked (&reader); parser->sidx.first_offset = parser->sidx.earliest_pts = gst_byte_reader_get_uint32_be_unchecked (&reader); } else { parser->sidx.earliest_pts = gst_byte_reader_get_uint64_be_unchecked (&reader); parser->sidx.first_offset = gst_byte_reader_get_uint64_be_unchecked (&reader); } /* skip 2 reserved bytes */ gst_byte_reader_skip_unchecked (&reader, 2); parser->sidx.entries_count = gst_byte_reader_get_uint16_be_unchecked (&reader); GST_LOG ("Timescale: %" G_GUINT32_FORMAT, parser->sidx.timescale); GST_LOG ("Earliest pts: %" G_GUINT64_FORMAT, parser->sidx.earliest_pts); GST_LOG ("First offset: %" G_GUINT64_FORMAT, parser->sidx.first_offset); parser->cumulative_pts = gst_util_uint64_scale_int_round (parser->sidx.earliest_pts, GST_SECOND, parser->sidx.timescale); if (parser->sidx.entries_count) { parser->sidx.entries = g_malloc (sizeof (GstSidxBoxEntry) * parser->sidx.entries_count); } parser->sidx.entry_index = 0; parser->status = GST_ISOFF_SIDX_PARSER_DATA; case GST_ISOFF_SIDX_PARSER_DATA: while (parser->sidx.entry_index < parser->sidx.entries_count) { GstSidxBoxEntry *entry = &parser->sidx.entries[parser->sidx.entry_index]; remaining = gst_byte_reader_get_remaining (&reader);; if (remaining < 12) break; entry->offset = parser->cumulative_entry_size; entry->pts = parser->cumulative_pts; gst_isoff_parse_sidx_entry (entry, &reader); entry->duration = gst_util_uint64_scale_int_round (entry->duration, GST_SECOND, parser->sidx.timescale); parser->cumulative_entry_size += entry->size; parser->cumulative_pts += entry->duration; GST_LOG ("Sidx entry %d) offset: %" G_GUINT64_FORMAT ", pts: %" GST_TIME_FORMAT ", duration %" GST_TIME_FORMAT " - size %" G_GUINT32_FORMAT, parser->sidx.entry_index, entry->offset, GST_TIME_ARGS (entry->pts), GST_TIME_ARGS (entry->duration), entry->size); parser->sidx.entry_index++; } if (parser->sidx.entry_index == parser->sidx.entries_count) parser->status = GST_ISOFF_SIDX_PARSER_FINISHED; else break; case GST_ISOFF_SIDX_PARSER_FINISHED: parser->sidx.entry_index = 0; res = GST_ISOFF_PARSER_DONE; break; } *consumed = gst_byte_reader_get_pos (&reader); gst_buffer_unmap (buffer, &info); return res; }
static GstFlowReturn gst_h264_parse_chain (GstPad * pad, GstBuffer * buffer) { GstH264Parse *h264parse = GST_H264_PARSE (GST_PAD_PARENT (pad)); if (h264parse->packetized && buffer) { GstByteReader br; GstBuffer *sub; GstFlowReturn ret = GST_FLOW_OK; guint32 len; const guint nl = h264parse->nal_length_size; GST_LOG_OBJECT (h264parse, "processing packet buffer of size %d", GST_BUFFER_SIZE (buffer)); gst_byte_reader_init_from_buffer (&br, buffer); while (ret == GST_FLOW_OK && gst_byte_reader_get_remaining (&br)) { GST_DEBUG_OBJECT (h264parse, "AVC nal offset %d", gst_byte_reader_get_pos (&br)); if (gst_byte_reader_get_remaining (&br) < nl) goto parse_failed; switch (nl) { case 4: len = gst_byte_reader_get_uint32_be_unchecked (&br); break; case 3: len = gst_byte_reader_get_uint24_be_unchecked (&br); break; case 2: len = gst_byte_reader_get_uint16_be_unchecked (&br); break; case 1: len = gst_byte_reader_get_uint8_unchecked (&br); break; default: goto not_negotiated; break; } GST_DEBUG_OBJECT (h264parse, "AVC nal size %d", len); if (gst_byte_reader_get_remaining (&br) < len) goto parse_failed; if (h264parse->split_packetized) { /* convert to NAL aligned byte stream input */ sub = gst_h264_parse_wrap_nal (h264parse, GST_H264_PARSE_FORMAT_BYTE, (guint8 *) gst_byte_reader_get_data_unchecked (&br, len), len); /* at least this should make sense */ GST_BUFFER_TIMESTAMP (sub) = GST_BUFFER_TIMESTAMP (buffer); GST_LOG_OBJECT (h264parse, "pushing NAL of size %d", len); ret = h264parse->parse_chain (pad, sub); } else { /* pass-through: no looking for frames (and nal processing), * so need to parse to collect data here */ /* NOTE: so if it is really configured to do so, * pre_push can/will still insert codec-data at intervals, * which is not really pure pass-through, but anyway ... */ gst_h264_parse_process_nal (h264parse, GST_BUFFER_DATA (buffer), gst_byte_reader_get_pos (&br) - nl, gst_byte_reader_get_pos (&br), len); gst_byte_reader_skip_unchecked (&br, len); } } if (h264parse->split_packetized) return ret; } exit: /* nal processing in pass-through might have collected stuff; * ensure nothing happens with this later on */ gst_adapter_clear (h264parse->frame_out); return h264parse->parse_chain (pad, buffer); /* ERRORS */ not_negotiated: { GST_DEBUG_OBJECT (h264parse, "insufficient data to split input"); return GST_FLOW_NOT_NEGOTIATED; } parse_failed: { if (h264parse->split_packetized) { GST_ELEMENT_ERROR (h264parse, STREAM, FAILED, (NULL), ("invalid AVC input data")); return GST_FLOW_ERROR; } else { /* do not meddle to much in this case */ GST_DEBUG_OBJECT (h264parse, "parsing packet failed"); goto exit; } } }
static GstFlowReturn gst_png_parse_handle_frame (GstBaseParse * parse, GstBaseParseFrame * frame, gint * skipsize) { GstPngParse *pngparse = GST_PNG_PARSE (parse); GstMapInfo map; GstByteReader reader; GstFlowReturn ret = GST_FLOW_OK; guint64 signature; guint width = 0, height = 0; gst_buffer_map (frame->buffer, &map, GST_MAP_READ); gst_byte_reader_init (&reader, map.data, map.size); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature != PNG_SIGNATURE) { for (;;) { guint offset; offset = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, 0x89504E47, 0, gst_byte_reader_get_remaining (&reader)); if (offset == -1) { *skipsize = gst_byte_reader_get_remaining (&reader) - 4; goto beach; } gst_byte_reader_skip (&reader, offset); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature == PNG_SIGNATURE) { /* We're skipping, go out, we'll be back */ *skipsize = gst_byte_reader_get_pos (&reader); goto beach; } gst_byte_reader_skip (&reader, 4); } } gst_byte_reader_skip (&reader, 8); for (;;) { guint32 length; guint32 code; if (!gst_byte_reader_get_uint32_be (&reader, &length)) goto beach; if (!gst_byte_reader_get_uint32_le (&reader, &code)) goto beach; if (code == GST_MAKE_FOURCC ('I', 'H', 'D', 'R')) { if (!gst_byte_reader_get_uint32_be (&reader, &width)) goto beach; if (!gst_byte_reader_get_uint32_be (&reader, &height)) goto beach; length -= 8; } if (!gst_byte_reader_skip (&reader, length + 4)) goto beach; if (code == GST_MAKE_FOURCC ('I', 'E', 'N', 'D')) { if (pngparse->width != width || pngparse->height != height) { GstStructure *st = NULL; GstCaps *caps, *sink_caps; gint fr_num, fr_denom; pngparse->height = height; pngparse->width = width; sink_caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (pngparse)); if (sink_caps && (st = gst_caps_get_structure (sink_caps, 0)) && gst_structure_get_fraction (st, "framerate", &fr_num, &fr_denom)) { /* Got it in caps - nothing more to do */ GST_DEBUG_OBJECT (pngparse, "sink caps override framerate from headers"); } else { GST_INFO_OBJECT (pngparse, "No framerate set"); } caps = gst_caps_new_simple ("image/png", "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, "framerate", GST_TYPE_FRACTION, fr_num, fr_denom, NULL); if (!gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps)) { ret = GST_FLOW_NOT_NEGOTIATED; } gst_caps_unref (caps); if (ret != GST_FLOW_OK) goto beach; } gst_buffer_unmap (frame->buffer, &map); return gst_base_parse_finish_frame (parse, frame, gst_byte_reader_get_pos (&reader)); } } beach: gst_buffer_unmap (frame->buffer, &map); return ret; }
static GstFlowReturn gst_png_parse_handle_frame (GstBaseParse * parse, GstBaseParseFrame * frame, gint * skipsize) { GstPngParse *pngparse = GST_PNG_PARSE (parse); GstMapInfo map; GstByteReader reader; GstFlowReturn ret = GST_FLOW_OK; guint64 signature; guint width = 0, height = 0; gst_buffer_map (frame->buffer, &map, GST_MAP_READ); gst_byte_reader_init (&reader, map.data, map.size); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature != PNG_SIGNATURE) { for (;;) { guint offset; offset = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, 0x89504E47, 0, gst_byte_reader_get_remaining (&reader)); if (offset == -1) { *skipsize = gst_byte_reader_get_remaining (&reader) - 4; goto beach; } gst_byte_reader_skip (&reader, offset); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature == PNG_SIGNATURE) { /* We're skipping, go out, we'll be back */ *skipsize = gst_byte_reader_get_pos (&reader); goto beach; } gst_byte_reader_skip (&reader, 4); } } gst_byte_reader_skip (&reader, 8); for (;;) { guint32 length; guint32 code; if (!gst_byte_reader_get_uint32_be (&reader, &length)) goto beach; if (!gst_byte_reader_get_uint32_le (&reader, &code)) goto beach; if (code == GST_MAKE_FOURCC ('I', 'H', 'D', 'R')) { if (!gst_byte_reader_get_uint32_be (&reader, &width)) goto beach; if (!gst_byte_reader_get_uint32_be (&reader, &height)) goto beach; length -= 8; } if (!gst_byte_reader_skip (&reader, length + 4)) goto beach; if (code == GST_MAKE_FOURCC ('I', 'E', 'N', 'D')) { if (pngparse->width != width || pngparse->height != height) { GstCaps *caps; pngparse->height = height; pngparse->width = width; caps = gst_caps_new_simple ("image/png", "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL); if (!gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps)) { ret = GST_FLOW_NOT_NEGOTIATED; } gst_caps_unref (caps); if (ret != GST_FLOW_OK) goto beach; } gst_buffer_unmap (frame->buffer, &map); return gst_base_parse_finish_frame (parse, frame, gst_byte_reader_get_pos (&reader)); } } beach: gst_buffer_unmap (frame->buffer, &map); return ret; }
static GstFlowReturn gst_png_parse_handle_frame (GstBaseParse * parse, GstBaseParseFrame * frame, gint * skipsize) { GstPngParse *pngparse = GST_PNG_PARSE (parse); GstMapInfo map; GstByteReader reader; GstFlowReturn ret = GST_FLOW_OK; guint64 signature; guint width = 0, height = 0; gst_buffer_map (frame->buffer, &map, GST_MAP_READ); gst_byte_reader_init (&reader, map.data, map.size); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature != PNG_SIGNATURE) { for (;;) { guint offset; offset = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff, 0x89504E47, 0, gst_byte_reader_get_remaining (&reader)); if (offset == -1) { *skipsize = gst_byte_reader_get_remaining (&reader) - 4; goto beach; } gst_byte_reader_skip (&reader, offset); if (!gst_byte_reader_peek_uint64_be (&reader, &signature)) goto beach; if (signature == PNG_SIGNATURE) { /* We're skipping, go out, we'll be back */ *skipsize = gst_byte_reader_get_pos (&reader); goto beach; } gst_byte_reader_skip (&reader, 4); } } gst_byte_reader_skip (&reader, 8); for (;;) { guint32 length; guint32 code; if (!gst_byte_reader_get_uint32_be (&reader, &length)) goto beach; if (!gst_byte_reader_get_uint32_le (&reader, &code)) goto beach; GST_TRACE_OBJECT (parse, "%" GST_FOURCC_FORMAT " chunk, %u bytes", GST_FOURCC_ARGS (code), length); if (code == GST_MAKE_FOURCC ('I', 'H', 'D', 'R')) { if (!gst_byte_reader_get_uint32_be (&reader, &width)) goto beach; if (!gst_byte_reader_get_uint32_be (&reader, &height)) goto beach; length -= 8; } else if (code == GST_MAKE_FOURCC ('I', 'D', 'A', 'T')) { gst_base_parse_set_min_frame_size (parse, gst_byte_reader_get_pos (&reader) + 4 + length + 12); } if (!gst_byte_reader_skip (&reader, length + 4)) goto beach; if (code == GST_MAKE_FOURCC ('I', 'E', 'N', 'D')) { /* the start code and at least 2 empty frames (IHDR and IEND) */ gst_base_parse_set_min_frame_size (parse, 8 + 12 + 12); if (pngparse->width != width || pngparse->height != height) { GstCaps *caps, *sink_caps; pngparse->height = height; pngparse->width = width; caps = gst_caps_new_simple ("image/png", "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL); sink_caps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (pngparse)); if (sink_caps) { GstStructure *st; gint fr_num, fr_denom; st = gst_caps_get_structure (sink_caps, 0); if (st && gst_structure_get_fraction (st, "framerate", &fr_num, &fr_denom)) { gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, fr_num, fr_denom, NULL); } else { GST_WARNING_OBJECT (pngparse, "No framerate set"); } gst_caps_unref (sink_caps); } if (!gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps)) ret = GST_FLOW_NOT_NEGOTIATED; gst_caps_unref (caps); if (ret != GST_FLOW_OK) goto beach; } gst_buffer_unmap (frame->buffer, &map); return gst_base_parse_finish_frame (parse, frame, gst_byte_reader_get_pos (&reader)); } } beach: gst_buffer_unmap (frame->buffer, &map); return ret; }
gboolean gst_mss_fragment_parser_add_buffer (GstMssFragmentParser * parser, GstBuffer * buffer) { GstByteReader reader; GstMapInfo info; guint64 size; guint32 fourcc; guint header_size; gboolean error = FALSE; if (!gst_buffer_map (buffer, &info, GST_MAP_READ)) { return FALSE; } gst_byte_reader_init (&reader, info.data, info.size); GST_TRACE ("Total buffer size: %u", gst_byte_reader_get_size (&reader)); do { parser->current_fourcc = 0; if (!gst_isoff_parse_box_header (&reader, &fourcc, NULL, &header_size, &size)) { break; } parser->current_fourcc = fourcc; GST_LOG ("box %" GST_FOURCC_FORMAT " size %" G_GUINT64_FORMAT, GST_FOURCC_ARGS (fourcc), size); parser->current_fourcc = fourcc; if (parser->current_fourcc == GST_ISOFF_FOURCC_MOOF) { GstByteReader sub_reader; g_assert (parser->moof == NULL); gst_byte_reader_get_sub_reader (&reader, &sub_reader, size - header_size); parser->moof = gst_isoff_moof_box_parse (&sub_reader); if (parser->moof == NULL) { GST_ERROR ("Failed to parse moof"); error = TRUE; } } else if (parser->current_fourcc == GST_ISOFF_FOURCC_MDAT) { goto beach; } else { gst_byte_reader_skip (&reader, size - header_size); } } while (gst_byte_reader_get_remaining (&reader) > 0); beach: /* Do sanity check */ if (parser->current_fourcc != GST_ISOFF_FOURCC_MDAT || !parser->moof || parser->moof->traf->len == 0) error = TRUE; if (!error) { GstTrafBox *traf = &g_array_index (parser->moof->traf, GstTrafBox, 0); if (!traf->tfxd) { GST_ERROR ("no tfxd box"); error = TRUE; } else if (!traf->tfrf) { GST_ERROR ("no tfrf box"); error = TRUE; } } if (!error) parser->status = GST_MSS_FRAGMENT_HEADER_PARSER_FINISHED; GST_LOG ("Fragment parsing successful: %s", error ? "no" : "yes"); gst_buffer_unmap (buffer, &info); return !error; }