mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-02 00:32:43 +00:00
Code Issues 1 Projects Releases Wiki Activity

Remove legacy mpegvideoparse plugin

Browse source 
There's a new one in the videoparsers plugin.
This commit is contained in:
Tim-Philipp Müller 2012-01-22 19:27:59 +00:00
parent a15029922f
commit 840a3a5b36
10 changed files with 1 additions and 2116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
configure.ac
View file

@ -315,7 +315,7 @@ GST_PLUGINS_NONPORTED=" adpcmdec adpcmenc aiff asfmux \
fieldanalysis freeverb freeze frei0r gaudieffects geometrictransform h264parse \
hdvparse hls id3tag inter interlace ivfparse jpegformat jp2kdecimator \
kate liveadder legacyresample librfb mpegdemux mpegtsmux \
mpegpsmux mpegvideoparse mve mxf mythtv nsf nuvdemux \
mpegpsmux mve mxf mythtv nsf nuvdemux \
patchdetect pnm rawparse real removesilence rtpmux rtpvp8 scaletempo \
sdi segmentclip siren speed subenc stereo tta videofilters \
videomaxrate videomeasure videosignal vmnc \
@ -368,7 +368,6 @@ AG_GST_CHECK_PLUGIN(mpegdemux)
AG_GST_CHECK_PLUGIN(mpegtsdemux)
AG_GST_CHECK_PLUGIN(mpegtsmux)
AG_GST_CHECK_PLUGIN(mpegpsmux)
AG_GST_CHECK_PLUGIN(mpegvideoparse)
AG_GST_CHECK_PLUGIN(multifdsink)
AG_GST_CHECK_PLUGIN(mve)
AG_GST_CHECK_PLUGIN(mxf)
@ -1977,7 +1976,6 @@ gst/mpegtsdemux/Makefile
gst/mpegtsmux/Makefile
gst/mpegtsmux/tsmux/Makefile
gst/mpegpsmux/Makefile
gst/mpegvideoparse/Makefile
gst/multifdsink/Makefile
gst/mve/Makefile
gst/mxf/Makefile

1
docs/plugins/gst-plugins-bad-plugins-docs.sgml
View file

@ -184,7 +184,6 @@
<xi:include href="xml/plugin-mpegdemux2.xml" />
<xi:include href="xml/plugin-mpegpsmux.xml" />
<xi:include href="xml/plugin-mpegtsmux.xml" />
<xi:include href="xml/plugin-mpegvideoparse.xml" />
<xi:include href="xml/plugin-mplex.xml" />
<xi:include href="xml/plugin-musepack.xml" />
<xi:include href="xml/plugin-musicbrainz.xml" />

34
docs/plugins/inspect/plugin-mpegvideoparse.xml
View file

@ -1,34 +0,0 @@
<plugin>
<name>mpegvideoparse</name>
<description>MPEG-1 and MPEG-2 video parser</description>
<filename>../../gst/mpegvideoparse/.libs/libgstmpegvideoparse.so</filename>
<basename>libgstmpegvideoparse.so</basename>
<version>0.10.22.1</version>
<license>LGPL</license>
<source>gst-plugins-bad</source>
<package>GStreamer Bad Plug-ins git</package>
<origin>Unknown package origin</origin>
<elements>
<element>
<name>legacympegvideoparse</name>
<longname>MPEG video elementary stream parser</longname>
<class>Codec/Parser/Video</class>
<description>Parses and frames MPEG-1 and MPEG-2 elementary video streams</description>
<author>Wim Taymans &lt;wim.taymans@chello.be&gt;, Jan Schmidt &lt;thaytan@mad.scientist.com&gt;</author>
<pads>
<caps>
<name>sink</name>
<direction>sink</direction>
<presence>always</presence>
<details>video/mpeg, mpegversion=(int)[ 1, 2 ], parsed=(boolean)false, systemstream=(boolean)false</details>
</caps>
<caps>
<name>src</name>
<direction>source</direction>
<presence>always</presence>
<details>video/mpeg, mpegversion=(int)[ 1, 2 ], parsed=(boolean)true, systemstream=(boolean)false, width=(int)[ 16, 4096 ], height=(int)[ 16, 4096 ], pixel-aspect-ratio=(fraction)[ 0/1, 2147483647/1 ], framerate=(fraction)[ 0/1, 2147483647/1 ]</details>
</caps>
</pads>
</element>
</elements>
</plugin>

3
gst-plugins-bad.spec.in
View file

@ -223,16 +223,13 @@ make ERROR_CFLAGS='' ERROR_CXXFLAGS=''
# %{_libdir}/gstreamer-%{majorminor}/libgstgaudieffects.so
# %{_libdir}/gstreamer-%{majorminor}/libgstgeometrictransform.so
# %{_libdir}/gstreamer-%{majorminor}/libgstgsettingselements.so
# %{_libdir}/gstreamer-%{majorminor}/libgsth264parse.so
# %{_libdir}/gstreamer-%{majorminor}/libgsthdvparse.so
# %{_libdir}/gstreamer-%{majorminor}/libgstid3tag.so
# %{_libdir}/gstreamer-%{majorminor}/libgstivfparse.so
# %{_libdir}/gstreamer-%{majorminor}/libgstjpegformat.so
# %{_libdir}/gstreamer-%{majorminor}/libgstlegacyresample.so
# %{_libdir}/gstreamer-%{majorminor}/libgstliveadder.so
#%{_libdir}/gstreamer-%{majorminor}/libgstmpeg4videoparse.so
# %{_libdir}/gstreamer-%{majorminor}/libgstmpegdemux.so
# %{_libdir}/gstreamer-%{majorminor}/libgstmpegvideoparse.so
# %{_libdir}/gstreamer-%{majorminor}/libgstmve.so
# %{_libdir}/gstreamer-%{majorminor}/libgstmxf.so
# %{_libdir}/gstreamer-%{majorminor}/libgstnsf.so

24
gst/mpegvideoparse/Makefile.am
View file

@ -1,24 +0,0 @@
plugin_LTLIBRARIES = libgstmpegvideoparse.la
libgstmpegvideoparse_la_SOURCES = mpegvideoparse.c mpegpacketiser.c
libgstmpegvideoparse_la_CFLAGS = $(GST_CFLAGS)
libgstmpegvideoparse_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS)
libgstmpegvideoparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstmpegvideoparse_la_LIBTOOLFLAGS = --tag=disable-static
noinst_HEADERS = mpegvideoparse.h mpegpacketiser.h
Android.mk: Makefile.am $(BUILT_SOURCES)
androgenizer \
-:PROJECT libgstmpegvideoparse -:SHARED libgstmpegvideoparse \
-:TAGS eng debug \
-:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \
-:SOURCES $(libgstmpegvideoparse_la_SOURCES) \
-:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstmpegvideoparse_la_CFLAGS) \
-:LDFLAGS $(libgstmpegvideoparse_la_LDFLAGS) \
$(libgstmpegvideoparse_la_LIBADD) \
-ldl \
-:PASSTHROUGH LOCAL_ARM_MODE:=arm \
LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-0.10' \
> $@

641
gst/mpegvideoparse/mpegpacketiser.c
View file

@ -1,641 +0,0 @@
/* GStreamer
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
*
* 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 <string.h>
/* The purpose of the packetiser is to parse the incoming buffers into 'blocks'
* that consist of the stream split at certain packet boundaries. It splits into
* a new block at the start of a GOP, Picture or Sequence packet.
* A GOP or sequence header always starts a new block. A Picture
* header starts a new block only if the previous packet was not a GOP -
* otherwise it is accumulated with the GOP */
#include "mpegpacketiser.h"
GST_DEBUG_CATEGORY_EXTERN (mpv_parse_debug);
#define GST_CAT_DEFAULT mpv_parse_debug
static void collect_packets (MPEGPacketiser * p, GstBuffer * buf);
void
mpeg_packetiser_init (MPEGPacketiser * p)
{
p->adapter = gst_adapter_new ();
p->n_blocks = 0;
p->blocks = NULL;
mpeg_packetiser_flush (p);
}
void
mpeg_packetiser_free (MPEGPacketiser * p)
{
g_object_unref (p->adapter);
g_free (p->blocks);
}
void
mpeg_packetiser_add_buf (MPEGPacketiser * p, GstBuffer * buf)
{
/* Add the buffer to our pool */
gst_adapter_push (p->adapter, buf);
/* Store the timestamp to apply to the next picture that gets collected */
if (p->cur_buf_ts != GST_CLOCK_TIME_NONE) {
p->prev_buf_ts = p->cur_buf_ts;
}
p->cur_buf_ts = GST_BUFFER_TIMESTAMP (buf);
/* read what new packets we have in this buffer */
collect_packets (p, buf);
p->tracked_offset += GST_BUFFER_SIZE (buf);
}
void
mpeg_packetiser_flush (MPEGPacketiser * p)
{
gst_adapter_clear (p->adapter);
p->adapter_offset = 0;
p->sync_word = 0xffffffff;
p->tracked_offset = 0;
p->prev_sync_packet = MPEG_PACKET_NONE;
/* Reset our block info */
p->cur_block_idx = -1;
p->first_block_idx = -1;
/* Clear any pending timestamps */
p->prev_buf_ts = GST_CLOCK_TIME_NONE;
p->cur_buf_ts = GST_CLOCK_TIME_NONE;
}
guint8 *
mpeg_util_find_start_code (guint32 * sync_word, guint8 * cur, guint8 * end)
{
guint32 code;
if (G_UNLIKELY (cur == NULL))
return NULL;
code = *sync_word;
while (cur < end) {
code <<= 8;
if (code == 0x00000100) {
/* Reset the sync word accumulator */
*sync_word = 0xffffffff;
return cur;
}
/* accelerate search for start code */
if (*cur > 1) {
while (cur < (end - 4) && *cur > 1)
if (cur[3] > 1)
cur += 4;
else
cur++;
code = 0xffffff00;
}
/* Add the next available byte to the collected sync word */
code |= *cur++;
}
*sync_word = code;
return NULL;
}
/* When we need to reallocate the blocks array, grow it by this much */
#define BLOCKS_INCREMENT 5
/* Get the index of the next unfilled block in the buffer. May need to grow
* the array first */
static gint
get_next_free_block (MPEGPacketiser * p)
{
gint next;
gboolean grow_array = FALSE;
/* Get a free block from the blocks array. May need to grow
* the array first */
if (p->n_blocks == 0) {
grow_array = TRUE;
next = 0;
} else {
if (G_UNLIKELY (p->cur_block_idx == -1)) {
next = 0;
} else {
next = p->cur_block_idx;
if (((next + 1) % p->n_blocks) == p->first_block_idx)
grow_array = TRUE;
}
}
if (grow_array) {
gint old_n_blocks = p->n_blocks;
p->n_blocks += BLOCKS_INCREMENT;
p->blocks = g_realloc (p->blocks, sizeof (MPEGBlockInfo) * p->n_blocks);
/* Now we may need to move some data up to the end of the array, if the
* cur_block_idx is before the first_block_idx in the array. */
if (p->cur_block_idx < p->first_block_idx) {
GST_LOG ("Moving %d blocks from idx %d to idx %d of %d",
old_n_blocks - p->first_block_idx,
p->first_block_idx, p->first_block_idx + BLOCKS_INCREMENT,
p->n_blocks);
memmove (p->blocks + p->first_block_idx + BLOCKS_INCREMENT,
p->blocks + p->first_block_idx,
sizeof (MPEGBlockInfo) * (old_n_blocks - p->first_block_idx));
p->first_block_idx += BLOCKS_INCREMENT;
}
}
return next;
}
/* Mark the current block as complete */
static void
complete_current_block (MPEGPacketiser * p, guint64 offset)
{
MPEGBlockInfo *block;
if (G_UNLIKELY (p->cur_block_idx == -1))
return; /* No block is in progress */
/* If we're pointing at the first_block_idx, then we're about to re-complete
* a previously completed buffer. Not allowed, because the array should have
* been previously expanded to cope via a get_next_free_block call. */
g_assert (p->cur_block_idx != p->first_block_idx);
/* Get the appropriate entry from the blocks array */
g_assert (p->blocks != NULL && p->cur_block_idx < p->n_blocks);
block = p->blocks + p->cur_block_idx;
/* Extend the block length to the current offset */
g_assert (block->offset < offset);
block->length = offset - block->offset;
GST_LOG ("Completed block of type 0x%02x @ offset %" G_GUINT64_FORMAT
" with size %u", block->first_pack_type, block->offset, block->length);
/* If this is the first complete block, set first_block_idx to be this block */
if (p->first_block_idx == -1)
p->first_block_idx = p->cur_block_idx;
/* Update the statistics regarding the packet we're handling */
if (block->flags & MPEG_BLOCK_FLAG_PICTURE)
p->n_pictures++;
/* And advance the cur_block_idx ptr to the next slot */
p->cur_block_idx = (p->cur_block_idx + 1) % p->n_blocks;
}
/* Accumulate the packet up to 'offset' into the current block
* (discard if no block is in progress). Update the block info
* to indicate what is in it. */
static void
append_to_current_block (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
{
MPEGBlockInfo *block;
if (G_UNLIKELY (p->cur_block_idx == -1))
return; /* No block in progress, drop this packet */
/* Get the appropriate entry from the blocks array */
g_assert (p->blocks != NULL && p->cur_block_idx < p->n_blocks);
block = p->blocks + p->cur_block_idx;
/* Extend the block length to the current offset */
g_assert (block->offset < offset);
block->length = offset - block->offset;
/* Update flags */
switch (pack_type) {
case MPEG_PACKET_SEQUENCE:
g_assert (!(block->flags &
(MPEG_BLOCK_FLAG_GOP | MPEG_BLOCK_FLAG_PICTURE)));
block->flags |= MPEG_BLOCK_FLAG_SEQUENCE;
break;
case MPEG_PACKET_GOP:
block->flags |= MPEG_BLOCK_FLAG_GOP;
break;
case MPEG_PACKET_PICTURE:
block->flags |= MPEG_BLOCK_FLAG_PICTURE;
break;
default:
break;
}
}
static void
start_new_block (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
{
gint block_idx;
MPEGBlockInfo *block;
/* First, append data up to the start of this block to the current one, but
* not including this packet info */
complete_current_block (p, offset);
block_idx = get_next_free_block (p);
/* FIXME: Retrieve the appropriate entry from the blocks array */
/* Get the appropriate entry from the blocks array */
g_assert (p->blocks != NULL && block_idx < p->n_blocks);
block = p->blocks + block_idx;
/* Init the block */
block->first_pack_type = pack_type;
block->offset = offset;
block->ts = GST_CLOCK_TIME_NONE;
/* Initially, the length is 0. It grows as we encounter new sync headers */
block->length = 0;
switch (pack_type) {
case MPEG_PACKET_SEQUENCE:
block->flags = MPEG_BLOCK_FLAG_SEQUENCE;
break;
case MPEG_PACKET_GOP:
block->flags = MPEG_BLOCK_FLAG_GOP;
break;
case MPEG_PACKET_PICTURE:
block->flags = MPEG_BLOCK_FLAG_PICTURE;
break;
default:
/* We don't start blocks with other packet types */
g_assert_not_reached ();
}
/* Make this our current block */
p->cur_block_idx = block_idx;
GST_LOG ("Started new block in slot %d with first pack 0x%02x @ offset %"
G_GUINT64_FORMAT, block_idx, block->first_pack_type, block->offset);
}
static void
handle_packet (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
{
GST_LOG ("offset %" G_GUINT64_FORMAT ", pack_type %2x", offset, pack_type);
switch (pack_type) {
case MPEG_PACKET_SEQUENCE:
case MPEG_PACKET_GOP:
/* Start a new block */
start_new_block (p, offset, pack_type);
p->prev_sync_packet = pack_type;
break;
case MPEG_PACKET_PICTURE:{
MPEGBlockInfo *block;
GstClockTime ts;
/* Start a new block unless the previous sync packet was a GOP */
if (p->prev_sync_packet != MPEG_PACKET_GOP) {
start_new_block (p, offset, pack_type);
} else {
append_to_current_block (p, offset, pack_type);
}
p->prev_sync_packet = pack_type;
/* We have a picture packet, apply any pending timestamp. The logic here
* is that the timestamp on any incoming buffer needs to apply to the next
* picture packet where the _first_byte_ of the sync word starts after the
* packet boundary. We track the ts from the current buffer and a
* previous buffer in order to handle this correctly. It would still be
* possible to get it wrong if there was a PES packet smaller than 3 bytes
* but anyone that does that can suck it. */
if ((offset >= p->tracked_offset)
&& (p->cur_buf_ts != GST_CLOCK_TIME_NONE)) {
/* sync word started within this buffer - take the cur ts */
ts = p->cur_buf_ts;
p->cur_buf_ts = GST_CLOCK_TIME_NONE;
p->prev_buf_ts = GST_CLOCK_TIME_NONE;
} else {
/* sync word started in a previous buffer - take the old ts */
ts = p->prev_buf_ts;
p->prev_buf_ts = GST_CLOCK_TIME_NONE;
}
/* If we didn't drop the packet, set the timestamp on it */
if (G_LIKELY (p->cur_block_idx != -1)) {
block = p->blocks + p->cur_block_idx;
block->ts = ts;
GST_LOG ("Picture @ offset %" G_GINT64_FORMAT " has ts %"
GST_TIME_FORMAT, block->offset, GST_TIME_ARGS (block->ts));
}
break;
}
default:
append_to_current_block (p, offset, pack_type);
break;
}
}
static void
collect_packets (MPEGPacketiser * p, GstBuffer * buf)
{
guint8 *cur;
guint8 *end = GST_BUFFER_DATA (buf) + GST_BUFFER_SIZE (buf);
cur = mpeg_util_find_start_code (&(p->sync_word), GST_BUFFER_DATA (buf), end);
while (cur != NULL) {
/* Calculate the offset as tracked since the last flush. Note that cur
* points to the last byte of the sync word, so we adjust by -3 to get the
* first byte */
guint64 offset = p->tracked_offset + (cur - GST_BUFFER_DATA (buf) - 3);
handle_packet (p, offset, *cur);
cur = mpeg_util_find_start_code (&(p->sync_word), cur, end);
}
}
void
mpeg_packetiser_handle_eos (MPEGPacketiser * p)
{
/* Append any remaining data to the current block */
if (p->tracked_offset > 0) {
complete_current_block (p, p->tracked_offset);
}
}
/* Returns a pointer to the block info for the completed block at the
* head of the queue, and extracts the bytes from the adapter if requested.
* Caller should move to the next block by calling mpeg_packetiser_next_block
* afterward.
*/
MPEGBlockInfo *
mpeg_packetiser_get_block (MPEGPacketiser * p, GstBuffer ** buf)
{
MPEGBlockInfo *block;
if (buf)
*buf = NULL;
if (G_UNLIKELY (p->first_block_idx == -1)) {
return NULL; /* No complete blocks to discard */
}
/* p->first_block_idx can't get set != -1 unless some block storage got
* allocated */
g_assert (p->blocks != NULL && p->n_blocks != 0);
block = p->blocks + p->first_block_idx;
/* Can only get the buffer out once, so we'll return NULL on later attempts */
if (buf != NULL && block->length > 0 && p->adapter_offset <= block->offset) {
/* Kick excess data out of the adapter */
if (p->adapter_offset < block->offset) {
guint64 to_flush = block->offset - p->adapter_offset;
g_assert (gst_adapter_available (p->adapter) >= to_flush);
gst_adapter_flush (p->adapter, to_flush);
p->adapter_offset += to_flush;
}
g_assert (gst_adapter_available (p->adapter) >= block->length);
*buf = gst_adapter_take_buffer (p->adapter, block->length);
p->adapter_offset += block->length;
GST_BUFFER_TIMESTAMP (*buf) = block->ts;
} else {
GST_DEBUG ("we have a block but do not meet all conditions buf: %p "
"block length: %d adapter offset %" G_GUINT64_FORMAT " block offset "
"%" G_GUINT64_FORMAT, buf, block->length, p->adapter_offset,
block->offset);
}
return block;
}
/* Advance the first_block pointer to discard a completed block
* from the queue */
void
mpeg_packetiser_next_block (MPEGPacketiser * p)
{
gint next;
MPEGBlockInfo *block;
block = mpeg_packetiser_get_block (p, NULL);
if (G_UNLIKELY (block == NULL))
return; /* No complete blocks to discard */
/* Update the statistics regarding the block we're discarding */
if (block->flags & MPEG_BLOCK_FLAG_PICTURE)
p->n_pictures--;
next = (p->first_block_idx + 1) % p->n_blocks;
if (next == p->cur_block_idx)
p->first_block_idx = -1; /* Discarding the last block */
else
p->first_block_idx = next;
}
/* Set the Pixel Aspect Ratio in our hdr from a DAR code in the data */
static void
set_par_from_dar (MPEGSeqHdr * hdr, guint8 asr_code)
{
/* Pixel_width = DAR_width * display_vertical_size */
/* Pixel_height = DAR_height * display_horizontal_size */
switch (asr_code) {
case 0x02: /* 3:4 DAR = 4:3 pixels */
hdr->par_w = 4 * hdr->height;
hdr->par_h = 3 * hdr->width;
break;
case 0x03: /* 9:16 DAR */
hdr->par_w = 16 * hdr->height;
hdr->par_h = 9 * hdr->width;
break;
case 0x04: /* 1:2.21 DAR */
hdr->par_w = 221 * hdr->height;
hdr->par_h = 100 * hdr->width;
break;
case 0x01: /* Square pixels */
default:
hdr->par_w = hdr->par_h = 1;
break;
}
}
static void
set_fps_from_code (MPEGSeqHdr * hdr, guint8 fps_code)
{
const gint framerates[][2] = {
{30, 1}, {24000, 1001}, {24, 1}, {25, 1},
{30000, 1001}, {30, 1}, {50, 1}, {60000, 1001},
{60, 1}, {30, 1}
};
if (fps_code < 10) {
hdr->fps_n = framerates[fps_code][0];
hdr->fps_d = framerates[fps_code][1];
} else {
/* Force a valid framerate */
hdr->fps_n = 30000;
hdr->fps_d = 1001;
}
}
static gboolean
mpeg_util_parse_extension_packet (MPEGSeqHdr * hdr, guint8 * data, guint8 * end)
{
guint8 ext_code;
if (G_UNLIKELY (data >= end))
return FALSE; /* short extension packet */
ext_code = data[0] >> 4;
switch (ext_code) {
case MPEG_PACKET_EXT_SEQUENCE:
{
/* Parse a Sequence Extension */
guint8 horiz_size_ext, vert_size_ext;
guint8 fps_n_ext, fps_d_ext;
if (G_UNLIKELY ((end - data) < 6))
/* need at least 10 bytes, minus 4 for the start code 000001b5 */
return FALSE;
hdr->profile = data[0] & 0x0f; /* profile (0:2) + escape bit (3) */
hdr->level = (data[1] >> 4) & 0x0f;
hdr->progressive = data[1] & 0x08;
/* chroma_format = (data[1] >> 2) & 0x03; */
horiz_size_ext = ((data[1] << 1) & 0x02) | ((data[2] >> 7) & 0x01);
vert_size_ext = (data[2] >> 5) & 0x03;
/* low_delay = data[5] >> 7; */
fps_n_ext = (data[5] >> 5) & 0x03;
fps_d_ext = data[5] & 0x1f;
hdr->fps_n *= (fps_n_ext + 1);
hdr->fps_d *= (fps_d_ext + 1);
hdr->width += (horiz_size_ext << 12);
hdr->height += (vert_size_ext << 12);
break;
}
default:
break;
}
return TRUE;
}
gboolean
mpeg_util_parse_sequence_hdr (MPEGSeqHdr * hdr, guint8 * data, guint8 * end)
{
guint32 code;
guint8 dar_idx, fps_idx;
guint32 sync_word = 0xffffffff;
gboolean load_intra_flag;
gboolean load_non_intra_flag;
if (G_UNLIKELY ((end - data) < 12))
return FALSE; /* Too small to be a sequence header */
code = GST_READ_UINT32_BE (data);
if (G_UNLIKELY (code != (0x00000100 | MPEG_PACKET_SEQUENCE)))
return FALSE;
/* Skip the sync word */
data += 4;
/* Parse the MPEG 1 bits */
hdr->mpeg_version = 1;
code = GST_READ_UINT32_BE (data);
hdr->width = (code >> 20) & 0xfff;
hdr->height = (code >> 8) & 0xfff;
dar_idx = (code >> 4) & 0xf;
set_par_from_dar (hdr, dar_idx);
fps_idx = code & 0xf;
set_fps_from_code (hdr, fps_idx);
hdr->bitrate = ((data[6] >> 6) | (data[5] << 2) | (data[4] << 10));
if (hdr->bitrate == 0x3ffff) {
/* VBR stream */
hdr->bitrate = 0;
} else {
/* Value in header is in units of 400 bps */
hdr->bitrate *= 400;
}
/* constrained_flag = (data[7] >> 2) & 0x01; */
load_intra_flag = (data[7] >> 1) & 0x01;
if (load_intra_flag) {
if (G_UNLIKELY ((end - data) < 64))
return FALSE;
data += 64;
}
load_non_intra_flag = data[7] & 0x01;
if (load_non_intra_flag) {
if (G_UNLIKELY ((end - data) < 64))
return FALSE;
data += 64;
}
/* Advance past the rest of the MPEG-1 header */
data += 8;
/* Read MPEG-2 sequence extensions */
data = mpeg_util_find_start_code (&sync_word, data, end);
while (data != NULL) {
if (G_UNLIKELY (data >= end))
return FALSE;
/* data points at the last byte of the start code */
if (data[0] == MPEG_PACKET_EXTENSION) {
if (!mpeg_util_parse_extension_packet (hdr, data + 1, end))
return FALSE;
hdr->mpeg_version = 2;
}
data = mpeg_util_find_start_code (&sync_word, data, end);
}
return TRUE;
}
gboolean
mpeg_util_parse_picture_hdr (MPEGPictureHdr * hdr, guint8 * data, guint8 * end)
{
guint32 code;
if (G_UNLIKELY ((end - data) < 6))
return FALSE; /* Packet too small */
code = GST_READ_UINT32_BE (data);
if (G_UNLIKELY (code != (0x00000100 | MPEG_PACKET_PICTURE)))
return FALSE;
/* Skip the start code */
data += 4;
hdr->pic_type = (data[1] >> 3) & 0x07;
if (hdr->pic_type == 0 || hdr->pic_type > 4)
return FALSE; /* Corrupted picture packet */
return TRUE;
}

153
gst/mpegvideoparse/mpegpacketiser.h
View file

@ -1,153 +0,0 @@
/* GStreamer
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
*
* 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.
*/
#ifndef __MPEGPACKETISER_H__
#define __MPEGPACKETISER_H__
#include <gst/gst.h>
#include <gst/base/gstadapter.h>
typedef struct MPEGPacketiser MPEGPacketiser;
typedef struct MPEGBlockInfo MPEGBlockInfo;
typedef struct MPEGSeqHdr MPEGSeqHdr;
typedef struct MPEGPictureHdr MPEGPictureHdr;
/* Packet ID codes for different packet types we
* care about */
#define MPEG_PACKET_PICTURE 0x00
#define MPEG_PACKET_SLICE_MIN 0x01
#define MPEG_PACKET_SLICE_MAX 0xaf
#define MPEG_PACKET_SEQUENCE 0xb3
#define MPEG_PACKET_EXTENSION 0xb5
#define MPEG_PACKET_SEQUENCE_END 0xb7
#define MPEG_PACKET_GOP 0xb8
#define MPEG_PACKET_NONE 0xff
/* Extension codes we care about */
#define MPEG_PACKET_EXT_SEQUENCE 0x01
#define MPEG_PACKET_EXT_SEQUENCE_DISPLAY 0x02
#define MPEG_PACKET_EXT_QUANT_MATRIX 0x03
/* Flags indicating what type of packets are in this block, some are mutually
* exclusive though - ie, sequence packs are accumulated separately. GOP &
* Picture may occur together or separately */
#define MPEG_BLOCK_FLAG_SEQUENCE 0x01
#define MPEG_BLOCK_FLAG_PICTURE 0x02
#define MPEG_BLOCK_FLAG_GOP 0x04
#define MPEG_PICTURE_TYPE_I 0x01
#define MPEG_PICTURE_TYPE_P 0x02
#define MPEG_PICTURE_TYPE_B 0x03
#define MPEG_PICTURE_TYPE_D 0x04
struct MPEGBlockInfo {
guint8 first_pack_type;
guint8 flags;
guint64 offset;
guint32 length;
GstClockTime ts;
};
struct MPEGSeqHdr
{
/* 0 for unknown, else 1 or 2 */
guint8 mpeg_version;
/* Pixel-Aspect Ratio from DAR code via set_par_from_dar */
gint par_w, par_h;
/* Width and Height of the video */
gint width, height;
/* Framerate */
gint fps_n, fps_d;
/* Bitrate */
guint bitrate;
/* Profile and level */
guint profile, level;
gboolean progressive;
};
struct MPEGPictureHdr
{
guint8 pic_type;
};
struct MPEGPacketiser {
GstAdapter *adapter;
/* position in the adapter */
guint64 adapter_offset;
/* Sync word accumulator */
guint32 sync_word;
/* Offset since the last flush (unrelated to incoming buffer offsets) */
guint64 tracked_offset;
/* Number of picture packets currently collected */
guint n_pictures;
/* 2 sets of timestamps + offsets used to mark picture blocks
* The first is used when a sync word overlaps packet boundaries
* and comes from some buffer in the past. The next one comes from current
* buffer. These are only ever valid when handling streams from a demuxer,
* of course. */
GstClockTime prev_buf_ts;
GstClockTime cur_buf_ts;
/* MPEG id of the previous SEQUENCE, PICTURE or GOP packet.
MPEG_PACKET_NONE after a flush */
guint8 prev_sync_packet;
/* Indices into the blocks array. cur_block_idx is where we're writing and
indicates the end of the populated block entries.
first_block_idx is the read ptr. It may be -1 to indicate there are no
complete blocks available */
gint cur_block_idx;
gint first_block_idx;
/* An array of MPEGBlockInfo entries, used as a growable circular buffer
* indexed by cur_block_idx and bounded by last_block_idx */
gint n_blocks;
MPEGBlockInfo *blocks;
};
void mpeg_packetiser_init (MPEGPacketiser *p);
void mpeg_packetiser_free (MPEGPacketiser *p);
void mpeg_packetiser_add_buf (MPEGPacketiser *p, GstBuffer *buf);
void mpeg_packetiser_handle_eos (MPEGPacketiser *p);
void mpeg_packetiser_flush (MPEGPacketiser *p);
/* Get the blockinfo and buffer for the block at the head of the queue */
MPEGBlockInfo *mpeg_packetiser_get_block (MPEGPacketiser *p, GstBuffer **buf);
/* Advance to the next data block */
void mpeg_packetiser_next_block (MPEGPacketiser *p);
/* Utility functions for parsing MPEG packets */
guint8 *mpeg_util_find_start_code (guint32 *sync_word,
guint8 *cur, guint8 *end);
gboolean mpeg_util_parse_sequence_hdr (MPEGSeqHdr *hdr,
guint8 *data, guint8 *end);
gboolean mpeg_util_parse_picture_hdr (MPEGPictureHdr *hdr,
guint8 *data, guint8 *end);
#endif

1037
gst/mpegvideoparse/mpegvideoparse.c
View file

File diff suppressed because it is too large Load diff

72
gst/mpegvideoparse/mpegvideoparse.h
View file

@ -1,72 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
*
* 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.
*/
#ifndef __MPEGVIDEOPARSE_H__
#define __MPEGVIDEOPARSE_H__
#include <gst/gst.h>
#include "mpegpacketiser.h"
G_BEGIN_DECLS
#define GST_TYPE_MPEGVIDEOPARSE \
(mpegvideoparse_get_type())
#define GST_MPEGVIDEOPARSE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEGVIDEOPARSE,MpegVideoParse))
#define GST_MPEGVIDEOPARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEGVIDEOPARSE,MpegVideoParseClass))
#define GST_IS_MPEGVIDEOPARSE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEGVIDEOPARSE))
#define GST_IS_MPEGVIDEOPARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEGVIDEOPARSE))
typedef struct _MpegVideoParse MpegVideoParse;
typedef struct _MpegVideoParseClass MpegVideoParseClass;
struct _MpegVideoParse {
GstElement element;
GstPad *sinkpad, *srcpad;
GstSegment segment;
GList *pending_segs;
gint64 next_offset;
gboolean need_discont;
/* Info from the Sequence Header */
MPEGSeqHdr seq_hdr;
GstBuffer *seq_hdr_buf;
/* Packetise helper */
MPEGPacketiser packer;
/* gather/decode queues for reverse playback */
GList *gather;
GList *decode;
};
struct _MpegVideoParseClass {
GstElementClass parent_class;
};
GType mpegvideoparse_get_type(void);
G_END_DECLS
#endif /* __MPEGVIDEOPARSE_H__ */

148
gst/mpegvideoparse/mpegvideoparse.vcproj
View file

@ -1,148 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="mpegvideoparse"
ProjectGUID="{979C216F-0ACF-4956-AE00-055A42D678E6}"
Keyword="Win32Proj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="../../win32/Debug"
IntermediateDirectory="../../win32/Debug"
ConfigurationType="2"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;mpegvideoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
OutputFile="$(OutDir)/mpegvideoparse.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="../../../gstreamer/win32/Debug;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile="$(OutDir)/mpegvideoparse.pdb"
SubSystem="2"
OptimizeReferences="2"
ImportLibrary="$(OutDir)/mpegvideoparse.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy /Y $(TargetPath) c:\gstreamer\plugins"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="../../win32/Release"
IntermediateDirectory="../../win32/Release"
ConfigurationType="2"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
PreprocessorDefinitions="WIN32;NDEBUG;GST_DISABLE_GST_DEBUG;_WINDOWS;_USRDLL;mpegvideoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
OutputFile="$(OutDir)/mpegvideoparse.dll"
LinkIncremental="1"
AdditionalLibraryDirectories="../../../gstreamer/win32/Release;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
ImportLibrary="$(OutDir)/mpegvideoparse.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy /Y $(TargetPath) c:\gstreamer\plugins"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
<File
RelativePath=".\mpegvideoparse.c">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath=".\mpegvideoparse.h">
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>