mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-20 15:27:07 +00:00
Code Issues 1 Projects Releases Wiki Activity

mpeg1sys: remove ancient plugin that's never even been ported to 0.8

Browse source
This commit is contained in:
Tim-Philipp Müller 2015-06-22 09:08:00 +01:00
parent bd5db4f72f
commit d43a849833
9 changed files with 0 additions and 1998 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
gst/mpeg1sys/.gitignore vendored
View file

@ -1,7 +0,0 @@
Makefile
Makefile.in
*.o
*.lo
*.la
.deps
.libs

14
gst/mpeg1sys/Makefile.am
View file

@ -1,14 +0,0 @@
plugin_LTLIBRARIES = libgstmpeg1systemencode.la
libgstmpeg1systemencode_la_SOURCES = gstmpeg1systemencode.c \
buffer.c \
systems.c
libgstmpeg1systemencode_la_CFLAGS = $(GST_CFLAGS)
libgstmpeg1systemencode_la_LIBADD =
libgstmpeg1systemencode_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstmpeg1systemencode_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS)
noinst_HEADERS = gstmpeg1systemencode.h \
main.h \
buffer.h

534
gst/mpeg1sys/buffer.c
View file

@ -1,534 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <gst/gst.h>
#include <gst/getbits/getbits.h>
#include "buffer.h"
#define SEQUENCE_HEADER 0x000001b3
#define SEQUENCE_END 0x000001b7
#define PICTURE_START 0x00000100
#define GROUP_START 0x000001b8
#define SYNCWORD_START 0x000001
#define AUDIO_SYNCWORD 0xfff
#define CLOCKS 90000.0
#ifdef G_HAVE_ISO_VARARGS
#define DEBUG(...) g_print (__VA_ARGS__)
#elif defined(G_HAVE_GNUC_VARARGS)
#define DEBUG(a, b...) g_print (##b)
#endif
/* This must match decoder and encoder tables */
static const double picture_rates[16] = {
0.0,
24000.0 / 1001.,
24.0,
25.0,
30000.0 / 1001.,
30.0,
50.0,
60000.0 / 1001.,
60.0,
1,
5,
10,
12,
15,
0,
0
};
/* defined but not used
static double ratio [16] = { 0., 1., 0.6735, 0.7031, 0.7615, 0.8055,
0.8437, 0.8935, 0.9157, 0.9815, 1.0255, 1.0695, 1.0950, 1.1575,
1.2015, 0.};
*/
#ifndef GST_DISABLE_GST_DEBUG
static const char picture_types[4][3] = { "I", "P", "B", "D" };
#endif
static const int bitrate_index[2][3][16] =
{ {{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}},
{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}},
};
static const long frequency[9] =
{ 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 };
static const double dfrequency[9] =
{ 44.1, 48, 32, 22.05, 24, 16, 11.025, 12, 8 };
static const unsigned int samples[4] = { 192, 384, 1152, 1152 };
/* deined but not used
static const char mode [4][15] =
{ "stereo", "joint stereo", "dual channel", "single channel" };
static const char copyright [2][20] =
{ "no copyright","copyright protected" };
static const char original [2][10] =
{ "copy","original" };
static const char emphasis [4][20] =
{ "none", "50/15 microseconds", "reserved", "CCITT J.17" };
*/
static void mpeg1mux_buffer_update_video_info (Mpeg1MuxBuffer * mb);
static void mpeg1mux_buffer_update_audio_info (Mpeg1MuxBuffer * mb);
Mpeg1MuxBuffer *
mpeg1mux_buffer_new (guchar type, guchar id)
{
Mpeg1MuxBuffer *new = g_malloc (sizeof (Mpeg1MuxBuffer));
new->buffer = NULL;
new->length = 0;
new->base = 0;
new->buffer_type = type;
new->stream_id = id;
new->scan_pos = 0;
new->new_frame = TRUE;
new->current_start = 0;
new->timecode_list = NULL;
new->queued_list = NULL;
new->next_frame_time = 0;
return new;
}
void
mpeg1mux_buffer_queue (Mpeg1MuxBuffer * mb, GstBuffer * buf)
{
if (mb->buffer == NULL) {
mb->buffer = g_malloc (GST_BUFFER_SIZE (buf));
mb->length = GST_BUFFER_SIZE (buf);
memcpy (mb->buffer, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
} else {
mb->buffer = g_realloc (mb->buffer, mb->length + GST_BUFFER_SIZE (buf));
memcpy (mb->buffer + mb->length, GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf));
mb->length += GST_BUFFER_SIZE (buf);
}
GST_DEBUG ("queuing buffer %lu", mb->length);
if (mb->buffer_type == BUFFER_TYPE_VIDEO) {
mpeg1mux_buffer_update_video_info (mb);
} else {
mpeg1mux_buffer_update_audio_info (mb);
}
}
gulong
mpeg1mux_buffer_update_queued (Mpeg1MuxBuffer * mb, guint64 scr)
{
GList *queued_list;
Mpeg1MuxTimecode *tc;
gulong total_queued = 0;
GST_DEBUG ("queued in buffer on SCR=%" G_GUINT64_FORMAT, scr);
queued_list = g_list_first (mb->queued_list);
while (queued_list) {
tc = (Mpeg1MuxTimecode *) queued_list->data;
if (tc->DTS < scr) {
/* this buffer should be sent out */
mb->queued_list = g_list_remove (mb->queued_list, tc);
queued_list = g_list_first (mb->queued_list);
} else {
GST_DEBUG ("queued in buffer %ld, %" G_GUINT64_FORMAT,
tc->original_length, tc->DTS);
total_queued += tc->original_length;
queued_list = g_list_next (queued_list);
}
}
GST_DEBUG ("queued in buffer %lu", total_queued);
return total_queued;
}
void
mpeg1mux_buffer_shrink (Mpeg1MuxBuffer * mb, gulong size)
{
GList *timecode_list;
Mpeg1MuxTimecode *tc;
gulong consumed = 0;
gulong count;
GST_DEBUG ("shrinking buffer %lu", size);
g_assert (mb->length >= size);
memcpy (mb->buffer, mb->buffer + size, mb->length - size);
mb->buffer = g_realloc (mb->buffer, mb->length - size);
mb->length -= size;
mb->scan_pos -= size;
mb->current_start -= size;
timecode_list = g_list_first (mb->timecode_list);
tc = (Mpeg1MuxTimecode *) timecode_list->data;
if (tc->length > size) {
tc->length -= size;
mb->new_frame = FALSE;
} else {
consumed += tc->length;
while (size >= consumed) {
GST_DEBUG ("removing timecode: %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT
" %lu %lu", tc->DTS, tc->PTS, tc->length, consumed);
mb->timecode_list = g_list_remove_link (mb->timecode_list, timecode_list);
mb->queued_list = g_list_append (mb->queued_list, tc);
timecode_list = g_list_first (mb->timecode_list);
tc = (Mpeg1MuxTimecode *) timecode_list->data;
consumed += tc->length;
GST_DEBUG ("next timecode: %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT
" %lu %lu", tc->DTS, tc->PTS, tc->length, consumed);
}
mb->new_frame = TRUE;
GST_DEBUG ("leftover frame size from %lu to %lu ", tc->length,
consumed - size);
tc->length = consumed - size;
}
if (mb->buffer_type == BUFFER_TYPE_VIDEO) {
mb->info.video.DTS = tc->DTS;
mb->info.video.PTS = tc->PTS;
mb->next_frame_time = tc->DTS;
} else {
mb->info.audio.PTS = tc->PTS;
mb->next_frame_time = tc->PTS;
}
GST_DEBUG ("next frame time timecode: %" G_GUINT64_FORMAT " %lu",
mb->next_frame_time, tc->length);
/* check buffer consistency */
timecode_list = g_list_first (mb->timecode_list);
count = 0;
while (timecode_list) {
tc = (Mpeg1MuxTimecode *) timecode_list->data;
count += tc->length;
timecode_list = g_list_next (timecode_list);
}
if (count != mb->current_start)
g_print ("********** error %lu != %lu\n", count, mb->current_start);
mb->base += size;
}
static void
mpeg1mux_buffer_update_video_info (Mpeg1MuxBuffer * mb)
{
gboolean have_sync = FALSE;
guchar *data = mb->buffer;
gulong offset = mb->scan_pos;
guint sync_zeros = 0;
gulong id = 0;
guint temporal_reference, temp;
gst_getbits_t gb;
GST_DEBUG ("mpeg1mux::update_video_info %lu %lu", mb->base, mb->scan_pos);
if (mb->base == 0 && mb->scan_pos == 0) {
if ((SYNCWORD_START << 8) + *(mb->buffer + 3) == SEQUENCE_HEADER) {
gst_getbits_init (&gb, NULL, NULL);
gst_getbits_newbuf (&gb, data + 4, mb->length);
mb->info.video.horizontal_size = gst_getbits12 (&gb);
mb->info.video.vertical_size = gst_getbits12 (&gb);
mb->info.video.aspect_ratio = gst_getbits4 (&gb);
mb->info.video.picture_rate = gst_getbits4 (&gb);
mb->info.video.bit_rate = gst_getbits18 (&gb);
if (gst_getbits1 (&gb) != 1) {
g_print ("mpeg1mux::update_video_info: marker bit error\n");
}
mb->info.video.vbv_buffer_size = gst_getbits10 (&gb);
mb->info.video.CSPF = gst_getbits1 (&gb);
mb->info.video.secs_per_frame =
1. / picture_rates[mb->info.video.picture_rate];
mb->info.video.decoding_order = 0;
mb->info.video.group_order = 0;
GST_DEBUG ("mpeg1mux::update_video_info: secs per frame %g",
mb->info.video.secs_per_frame);
} else {
g_print ("mpeg1mux::update_video_info: Invalid MPEG Video header\n");
}
}
while (offset < mb->length - 6) {
if (!have_sync) {
guchar byte = *(data + offset);
/*GST_DEBUG ("mpeg1mux::update_video_info: found #%d at %lu",byte,offset); */
offset++;
/* if it's zero, increment the zero count */
if (byte == 0) {
sync_zeros++;
/*GST_DEBUG ("mpeg1mux::update_video_info: found zero #%d at %lu",sync_zeros,offset-1); */
}
/* if it's a one and we have two previous zeros, we have sync */
else if ((byte == 1) && (sync_zeros >= 2)) {
GST_DEBUG ("mpeg1mux::update_video_info: synced at %lu", offset - 1);
have_sync = TRUE;
sync_zeros = 0;
}
/* if it's anything else, we've lost it completely */
else
sync_zeros = 0;
/* then snag the chunk ID */
} else if (id == 0) {
id = *(data + offset);
GST_DEBUG ("mpeg1mux::update_video_info: got id 0x%02lX", id);
id = (SYNCWORD_START << 8) + id;
switch (id) {
case SEQUENCE_HEADER:
GST_DEBUG ("mpeg1mux::update_video_info: sequence header");
break;
case GROUP_START:
GST_DEBUG ("mpeg1mux::update_video_info: group start");
mb->info.video.group_order = 0;
break;
case PICTURE_START:
/* skip the first access unit */
if (mb->info.video.decoding_order != 0) {
Mpeg1MuxTimecode *tc;
GST_DEBUG ("mpeg1mux::update_video_info: PTS %" G_GUINT64_FORMAT
", DTS %" G_GUINT64_FORMAT ", length %lu",
mb->info.video.current_PTS, mb->info.video.current_DTS,
offset - mb->current_start - 3);
tc = (Mpeg1MuxTimecode *) g_malloc (sizeof (Mpeg1MuxTimecode));
tc->length = offset - mb->current_start - 3;
tc->original_length = tc->length;
tc->frame_type = mb->info.video.current_type;
tc->DTS = mb->info.video.current_DTS;
tc->PTS = mb->info.video.current_PTS;
mb->timecode_list = g_list_append (mb->timecode_list, tc);
if (mb->info.video.decoding_order == 0) {
mb->next_frame_time = tc->DTS;
}
mb->current_start = offset - 3;
}
temp = (*(data + offset + 1) << 8) + *(data + offset + 2);
temporal_reference = (temp & 0xffc0) >> 6;
mb->info.video.current_type = (temp & 0x0038) >> 3;
GST_DEBUG
("mpeg1mux::update_video_info: picture start temporal_ref:%d type:%s Frame",
temporal_reference,
picture_types[mb->info.video.current_type - 1]);
mb->info.video.current_DTS =
mb->info.video.decoding_order * mb->info.video.secs_per_frame *
CLOCKS;
mb->info.video.current_PTS =
(temporal_reference - mb->info.video.group_order + 1 +
mb->info.video.decoding_order) * mb->info.video.secs_per_frame *
CLOCKS;
mb->info.video.decoding_order++;
mb->info.video.group_order++;
offset++;
break;
case SEQUENCE_END:
GST_DEBUG ("mpeg1mux::update_video_info: sequence end");
break;
}
/* prepare for next sync */
offset++;
have_sync = FALSE;
id = 0;
sync_zeros = 0;
}
}
mb->scan_pos = offset;
}
static void
mpeg1mux_buffer_update_audio_info (Mpeg1MuxBuffer * mb)
{
guchar *data = mb->buffer;
gulong offset = mb->scan_pos;
guint32 id = 0;
guint padding_bit;
gst_getbits_t gb;
guint startup_delay = 0;
int layer_index, lsf, samplerate_index, padding;
long bpf;
Mpeg1MuxTimecode *tc;
GST_DEBUG ("mpeg1mux::update_audio_info %lu %lu", mb->base, mb->scan_pos);
if (mb->base == 0 && mb->scan_pos == 0) {
id = GST_READ_UINT32_BE (data);
printf ("MPEG audio id = %08x\n", (unsigned int) id);
if ((id & 0xfff00000) == AUDIO_SYNCWORD << 20) {
/* mpegver = (header >> 19) & 0x3; don't need this for bpf */
layer_index = (id >> 17) & 0x3;
mb->info.audio.layer = 4 - layer_index;
lsf = (id & (1 << 20)) ? ((id & (1 << 19)) ? 0 : 1) : 1;
mb->info.audio.bit_rate =
bitrate_index[lsf][mb->info.audio.layer - 1][((id >> 12) & 0xf)];
samplerate_index = (id >> 10) & 0x3;
padding = (id >> 9) & 0x1;
if (mb->info.audio.layer == 1) {
bpf = mb->info.audio.bit_rate * 12000;
bpf /= frequency[samplerate_index];
bpf = ((bpf + padding) << 2);
} else {
bpf = mb->info.audio.bit_rate * 144000;
bpf /= frequency[samplerate_index];
bpf += padding;
}
mb->info.audio.framesize = bpf;
GST_DEBUG ("mpeg1mux::update_audio_info: samples per second %d",
samplerate_index);
gst_getbits_init (&gb, NULL, NULL);
gst_getbits_newbuf (&gb, data, mb->length);
gst_flushbitsn (&gb, 12);
if (gst_getbits1 (&gb) != 1) {
g_print ("mpeg1mux::update_audio_info: marker bit error\n");
}
gst_flushbitsn (&gb, 2);
mb->info.audio.protection = gst_getbits1 (&gb);
gst_flushbitsn (&gb, 4);
mb->info.audio.frequency = gst_getbits2 (&gb);
padding_bit = gst_getbits1 (&gb);
gst_flushbitsn (&gb, 1);
mb->info.audio.mode = gst_getbits2 (&gb);
mb->info.audio.mode_extension = gst_getbits2 (&gb);
mb->info.audio.copyright = gst_getbits1 (&gb);
mb->info.audio.original_copy = gst_getbits1 (&gb);
mb->info.audio.emphasis = gst_getbits2 (&gb);
GST_DEBUG ("mpeg1mux::update_audio_info: layer %d", mb->info.audio.layer);
GST_DEBUG ("mpeg1mux::update_audio_info: bit_rate %d",
mb->info.audio.bit_rate);
GST_DEBUG ("mpeg1mux::update_audio_info: frequency %d",
mb->info.audio.frequency);
mb->info.audio.samples_per_second =
(double) dfrequency[mb->info.audio.frequency];
GST_DEBUG ("mpeg1mux::update_audio_info: samples per second %g",
mb->info.audio.samples_per_second);
mb->info.audio.decoding_order = 0;
tc = (Mpeg1MuxTimecode *) g_malloc (sizeof (Mpeg1MuxTimecode));
tc->length = mb->info.audio.framesize;
tc->original_length = tc->length;
tc->frame_type = FRAME_TYPE_AUDIO;
mb->info.audio.current_PTS =
mb->info.audio.decoding_order * samples[mb->info.audio.layer] /
mb->info.audio.samples_per_second * 90. + startup_delay;
GST_DEBUG ("mpeg1mux::update_audio_info: PTS %" G_GUINT64_FORMAT
", length %u", mb->info.audio.current_PTS, mb->info.audio.framesize);
tc->PTS = mb->info.audio.current_PTS;
tc->DTS = mb->info.audio.current_PTS;
mb->timecode_list = g_list_append (mb->timecode_list, tc);
mb->next_frame_time = tc->PTS;
mb->info.audio.decoding_order++;
offset += tc->length;
} else {
g_print ("mpeg1mux::update_audio_info: Invalid MPEG Video header\n");
}
}
while (offset < mb->length - 4) {
id = GST_READ_UINT32_BE (data + offset);
/* mpegver = (header >> 19) & 0x3; don't need this for bpf */
layer_index = (id >> 17) & 0x3;
mb->info.audio.layer = 4 - layer_index;
lsf = (id & (1 << 20)) ? ((id & (1 << 19)) ? 0 : 1) : 1;
mb->info.audio.bit_rate =
bitrate_index[lsf][mb->info.audio.layer - 1][((id >> 12) & 0xf)];
samplerate_index = (id >> 10) & 0x3;
padding = (id >> 9) & 0x1;
if (mb->info.audio.layer == 1) {
bpf = mb->info.audio.bit_rate * 12000;
bpf /= frequency[samplerate_index];
bpf = ((bpf + padding) << 2);
} else {
bpf = mb->info.audio.bit_rate * 144000;
bpf /= frequency[samplerate_index];
bpf += padding;
}
tc = (Mpeg1MuxTimecode *) g_malloc (sizeof (Mpeg1MuxTimecode));
tc->length = bpf;
tc->original_length = tc->length;
tc->frame_type = FRAME_TYPE_AUDIO;
mb->current_start = offset + bpf;
mb->info.audio.samples_per_second =
(double) dfrequency[mb->info.audio.frequency];
mb->info.audio.current_PTS =
(mb->info.audio.decoding_order * samples[mb->info.audio.layer]) /
mb->info.audio.samples_per_second * 90.;
tc->DTS = tc->PTS = mb->info.audio.current_PTS;
GST_DEBUG ("mpeg1mux::update_audio_info: PTS %" G_GUINT64_FORMAT ", %"
G_GUINT64_FORMAT " length %lu", mb->info.audio.current_PTS, tc->PTS,
tc->length);
mb->timecode_list = g_list_append (mb->timecode_list, tc);
mb->info.audio.decoding_order++;
offset += tc->length;
}
mb->scan_pos = offset;
}

141
gst/mpeg1sys/buffer.h
View file

@ -1,141 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __BUFFER_H__
#define __BUFFER_H__
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define MPEG1MUX_BUFFER_QUEUED(mb) (g_list_length((mb)->timecode_list))
#define MPEG1MUX_BUFFER_SPACE(mb) ((mb)->length)
#define MPEG1MUX_BUFFER_DATA(mb) ((mb)->buffer)
#define MPEG1MUX_BUFFER_TYPE(mb) ((mb)->buffer)
#define MPEG1MUX_BUFFER_FIRST_TIMECODE(mb) (g_list_first((mb)->timecode_list)->data)
#define BUFFER_TYPE_VIDEO 1
#define BUFFER_TYPE_AUDIO 2
#define FRAME_TYPE_IFRAME 1
#define FRAME_TYPE_BFRAME 2
#define FRAME_TYPE_PFRAME 3
#define FRAME_TYPE_AUDIO 4
typedef struct _Mpeg1MuxBuffer Mpeg1MuxBuffer;
typedef struct _Mpeg1MuxTimecode Mpeg1MuxTimecode;
typedef struct video_struc /* Informationen ueber Video Stream */
{
unsigned int stream_length ;
unsigned int num_sequence ;
unsigned int num_seq_end ;
unsigned int num_pictures ;
unsigned int num_groups ;
unsigned int num_frames[4] ;
unsigned int avg_frames[4] ;
unsigned int horizontal_size;
unsigned int vertical_size ;
unsigned int aspect_ratio ;
unsigned int picture_rate ;
unsigned int bit_rate ;
unsigned int comp_bit_rate ;
unsigned int vbv_buffer_size;
unsigned int CSPF ;
guint64 PTS;
guint64 DTS;
guint64 current_PTS;
guint64 current_DTS;
guchar current_type;
double secs_per_frame;
gulong group_order, decoding_order;
} Video_struc;
typedef struct audio_struc /* Informationen ueber Audio Stream */
{
unsigned int stream_length ;
unsigned int num_syncword ;
unsigned int num_frames [2] ;
unsigned int framesize ;
unsigned int layer ;
unsigned int protection ;
unsigned int bit_rate ;
unsigned int frequency ;
unsigned int mode ;
unsigned int mode_extension ;
unsigned int copyright ;
unsigned int original_copy ;
unsigned int emphasis ;
guint64 PTS;
guint64 current_PTS;
double samples_per_second;
gulong decoding_order;
} Audio_struc;
struct _Mpeg1MuxTimecode {
gulong length;
gulong original_length;
guchar frame_type;
guint64 PTS;
guint64 DTS;
};
struct _Mpeg1MuxBuffer {
unsigned char *buffer;
gulong length;
gulong base;
gulong scan_pos;
gulong last_pos;
gulong current_start;
guchar buffer_type;
guchar stream_id;
gboolean new_frame;
guint64 next_frame_time;
union {
Video_struc video;
Audio_struc audio;
} info;
GList *timecode_list;
GList *queued_list;
};
Mpeg1MuxBuffer *mpeg1mux_buffer_new(guchar type, guchar id);
void mpeg1mux_buffer_queue(Mpeg1MuxBuffer *mb, GstBuffer *buf);
void mpeg1mux_buffer_shrink(Mpeg1MuxBuffer *mb, gulong size);
gulong mpeg1mux_buffer_update_queued(Mpeg1MuxBuffer *mb, guint64 scr);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __BUFFER_H__ */

597
gst/mpeg1sys/gstmpeg1systemencode.c
View file

@ -1,597 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <math.h>
/*#define DEBUG_ENABLED */
#include "gstmpeg1systemencode.h"
#include "main.h"
/* GstMPEG1SystemEncode signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
PROP_0
/* FILL ME */
};
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/mpeg, " "systemstream = (boolean) TRUE")
);
static GstStaticPadTemplate video_sink_factory =
GST_STATIC_PAD_TEMPLATE ("video_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS ("video/mpeg, "
"mpegversion = (int) 1, " "systemstream = (boolean) FALSE")
);
static GstStaticPadTemplate audio_sink_factory =
GST_STATIC_PAD_TEMPLATE ("audio_%u",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS ("audio/mpeg, "
"mpegversion = (int) 1, " "layer = (int) [ 1, 2 ] ")
);
static void gst_system_encode_class_init (GstMPEG1SystemEncodeClass * klass);
static void gst_system_encode_base_init (GstMPEG1SystemEncodeClass * klass);
static void gst_system_encode_init (GstMPEG1SystemEncode * system_encode);
static GstPad *gst_system_encode_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * unused);
static void gst_system_encode_chain (GstPad * pad, GstData * _data);
static void gst_system_encode_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_system_encode_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstElementClass *parent_class = NULL;
/*static guint gst_system_encode_signals[LAST_SIGNAL] = { 0 }; */
GType
gst_mpeg1_system_encode_get_type (void)
{
static GType system_encode_type = 0;
if (!system_encode_type) {
static const GTypeInfo system_encode_info = {
sizeof (GstMPEG1SystemEncodeClass),
(GBaseInitFunc) gst_system_encode_base_init,
NULL,
(GClassInitFunc) gst_system_encode_class_init,
NULL,
NULL,
sizeof (GstMPEG1SystemEncode),
0,
(GInstanceInitFunc) gst_system_encode_init,
NULL
};
system_encode_type =
g_type_register_static (GST_TYPE_ELEMENT, "GstMPEG1SystemEncode",
&system_encode_info, 0);
}
return system_encode_type;
}
static void
gst_system_encode_base_init (GstMPEG1SystemEncodeClass * klass)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_factory));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&audio_sink_factory));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&video_sink_factory));
gst_element_class_set_static_metadata (element_class, "MPEG-1 muxer",
"Codec/Muxer",
"Multiplexes MPEG-1 Streams", "Wim Taymans <wim.taymans@chello.be>");
}
static void
gst_system_encode_class_init (GstMPEG1SystemEncodeClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_peek_parent (klass);
gobject_class->set_property = gst_system_encode_set_property;
gobject_class->get_property = gst_system_encode_get_property;
gstelement_class->request_new_pad = gst_system_encode_request_new_pad;
}
static void
gst_system_encode_init (GstMPEG1SystemEncode * system_encode)
{
system_encode->srcpad =
gst_pad_new_from_static_template (&src_factory, "src");
gst_element_add_pad (GST_ELEMENT (system_encode), system_encode->srcpad);
system_encode->video_buffer = mpeg1mux_buffer_new (BUFFER_TYPE_VIDEO, 0xE0);
system_encode->audio_buffer = mpeg1mux_buffer_new (BUFFER_TYPE_AUDIO, 0xC0);
system_encode->have_setup = FALSE;
system_encode->mta = NULL;
system_encode->packet_size = 2048;
system_encode->lock = g_mutex_new ();
system_encode->current_pack = system_encode->packets_per_pack = 3;
system_encode->video_delay_ms = 0;
system_encode->audio_delay_ms = 0;
system_encode->sectors_delay = 0;
system_encode->startup_delay = ~1;
system_encode->which_streams = 0;
system_encode->num_audio_pads = 0;
system_encode->num_video_pads = 0;
system_encode->pack = g_malloc (sizeof (Pack_struc));
system_encode->sys_header = g_malloc (sizeof (Sys_header_struc));
system_encode->sector = g_malloc (sizeof (Sector_struc));
}
static GstPad *
gst_system_encode_request_new_pad (GstElement * element, GstPadTemplate * templ,
const gchar * unused)
{
GstMPEG1SystemEncode *system_encode;
gchar *name = NULL;
GstPad *newpad;
g_return_val_if_fail (templ != NULL, NULL);
if (templ->direction != GST_PAD_SINK) {
g_warning ("system_encode: request pad that is not a SINK pad\n");
return NULL;
}
system_encode = GST_SYSTEM_ENCODE (element);
if (templ == gst_static_pad_template_get (&audio_sink_factory)) {
name = g_strdup_printf ("audio_%02d", system_encode->num_audio_pads);
g_print ("%s\n", name);
newpad = gst_pad_new_from_template (templ, name);
gst_pad_set_element_private (newpad,
GINT_TO_POINTER (system_encode->num_audio_pads));
system_encode->audio_pad[system_encode->num_audio_pads] = newpad;
system_encode->num_audio_pads++;
system_encode->which_streams |= STREAMS_AUDIO;
} else if (templ == gst_static_pad_template_get (&video_sink_factory)) {
name = g_strdup_printf ("video_%02d", system_encode->num_video_pads);
g_print ("%s\n", name);
newpad = gst_pad_new_from_template (templ, name);
gst_pad_set_element_private (newpad,
GINT_TO_POINTER (system_encode->num_video_pads));
system_encode->video_pad[system_encode->num_video_pads] = newpad;
system_encode->num_video_pads++;
system_encode->which_streams |= STREAMS_VIDEO;
} else {
g_warning ("system_encode: this is not our template!\n");
return NULL;
}
gst_pad_set_chain_function (newpad, gst_system_encode_chain);
gst_element_add_pad (GST_ELEMENT (system_encode), newpad);
return newpad;
}
/* return a list of all the highest prioripty streams */
static GList *
gst_system_encode_pick_streams (GList * mta,
GstMPEG1SystemEncode * system_encode)
{
guint64 lowest = ~1;
GST_DEBUG ("pick_streams: %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT,
system_encode->video_buffer->next_frame_time,
system_encode->audio_buffer->next_frame_time);
if (system_encode->which_streams & STREAMS_VIDEO) {
if (system_encode->video_buffer->next_frame_time <
lowest - system_encode->video_delay) {
lowest = system_encode->video_buffer->next_frame_time;
}
}
if (system_encode->which_streams & STREAMS_AUDIO) {
if (system_encode->audio_buffer->next_frame_time <
lowest - system_encode->audio_delay) {
lowest = system_encode->audio_buffer->next_frame_time;
}
}
if (system_encode->which_streams & STREAMS_VIDEO) {
if (system_encode->video_buffer->next_frame_time == lowest) {
mta = g_list_append (mta, system_encode->video_buffer);
}
}
if (system_encode->which_streams & STREAMS_AUDIO) {
if (system_encode->audio_buffer->next_frame_time == lowest) {
mta = g_list_append (mta, system_encode->audio_buffer);
}
}
return mta;
}
static gboolean
gst_system_encode_have_data (GstMPEG1SystemEncode * system_encode)
{
if (system_encode->which_streams == (STREAMS_VIDEO | STREAMS_AUDIO)) {
if (MPEG1MUX_BUFFER_QUEUED (system_encode->audio_buffer) > 2 &&
MPEG1MUX_BUFFER_SPACE (system_encode->audio_buffer) >
system_encode->packet_size * 2
&& MPEG1MUX_BUFFER_QUEUED (system_encode->video_buffer) > 2
&& MPEG1MUX_BUFFER_SPACE (system_encode->video_buffer) >
system_encode->packet_size * 2) {
return TRUE;
}
}
if (system_encode->which_streams == STREAMS_VIDEO) {
if (MPEG1MUX_BUFFER_QUEUED (system_encode->video_buffer) > 2 &&
MPEG1MUX_BUFFER_SPACE (system_encode->video_buffer) >
system_encode->packet_size * 2) {
return TRUE;
}
}
if (system_encode->which_streams == STREAMS_VIDEO) {
if (MPEG1MUX_BUFFER_QUEUED (system_encode->audio_buffer) > 2 &&
MPEG1MUX_BUFFER_SPACE (system_encode->audio_buffer) >
system_encode->packet_size * 2) {
return TRUE;
}
}
return FALSE;
}
static GList *
gst_system_encode_update_mta (GstMPEG1SystemEncode * system_encode, GList * mta,
gulong size)
{
GList *streams = g_list_first (mta);
Mpeg1MuxBuffer *mb = (Mpeg1MuxBuffer *) streams->data;
GST_DEBUG ("system_encode::multiplex: update mta");
mpeg1mux_buffer_shrink (mb, size);
mta = g_list_remove (mta, mb);
return mta;
}
static void
gst_system_setup_multiplex (GstMPEG1SystemEncode * system_encode)
{
Mpeg1MuxTimecode *video_tc, *audio_tc;
system_encode->audio_buffer_size = 4 * 1024;
system_encode->video_buffer_size = 46 * 1024;
system_encode->bytes_output = 0;
system_encode->min_packet_data =
system_encode->packet_size - PACK_HEADER_SIZE - SYS_HEADER_SIZE -
PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH;
system_encode->max_packet_data =
system_encode->packet_size - PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH;
if (system_encode->which_streams & STREAMS_VIDEO) {
system_encode->video_rate =
system_encode->video_buffer->info.video.bit_rate * 50;
} else
system_encode->video_rate = 0;
if (system_encode->which_streams & STREAMS_AUDIO)
system_encode->audio_rate =
system_encode->audio_buffer->info.audio.bit_rate * 128;
else
system_encode->audio_rate = 0;
system_encode->data_rate =
system_encode->video_rate + system_encode->audio_rate;
system_encode->dmux_rate = ceil ((double) (system_encode->data_rate) *
((double) (system_encode->packet_size) /
(double) (system_encode->min_packet_data) +
((double) (system_encode->packet_size) /
(double) (system_encode->max_packet_data) *
(double) (system_encode->packets_per_pack -
1.))) / (double) (system_encode->packets_per_pack));
system_encode->data_rate = ceil (system_encode->dmux_rate / 50.) * 50;
GST_DEBUG
("system_encode::multiplex: data_rate %u, video_rate: %u, audio_rate: %u",
system_encode->data_rate, system_encode->video_rate,
system_encode->audio_rate);
system_encode->video_delay =
(double) system_encode->video_delay_ms * (double) (CLOCKS / 1000);
system_encode->audio_delay =
(double) system_encode->audio_delay_ms * (double) (CLOCKS / 1000);
system_encode->mux_rate = ceil (system_encode->dmux_rate / 50.);
system_encode->dmux_rate = system_encode->mux_rate * 50.;
video_tc = MPEG1MUX_BUFFER_FIRST_TIMECODE (system_encode->video_buffer);
audio_tc = MPEG1MUX_BUFFER_FIRST_TIMECODE (system_encode->audio_buffer);
GST_DEBUG ("system_encode::video tc %" G_GINT64_FORMAT ", audio tc %"
G_GINT64_FORMAT ":", video_tc->DTS, audio_tc->DTS);
system_encode->delay = ((double) system_encode->sectors_delay +
ceil ((double) video_tc->length /
(double) system_encode->min_packet_data) +
ceil ((double) video_tc->length /
(double) system_encode->min_packet_data)) *
(double) system_encode->packet_size / system_encode->dmux_rate *
(double) CLOCKS;
system_encode->audio_delay += system_encode->delay;
system_encode->video_delay += system_encode->delay;
system_encode->audio_delay = 0;
system_encode->video_delay = 0;
system_encode->delay = 0;
GST_DEBUG ("system_encode::multiplex: delay %g, mux_rate: %lu",
system_encode->delay, system_encode->mux_rate);
}
static void
gst_system_encode_multiplex (GstMPEG1SystemEncode * system_encode)
{
GList *streams;
Mpeg1MuxBuffer *mb = (Mpeg1MuxBuffer *) streams->data;
guchar timestamps;
guchar buffer_scale;
GstBuffer *outbuf;
Pack_struc *pack;
Sys_header_struc *sys_header;
Mpeg1MuxTimecode *tc;
gulong buffer_size, non_scaled_buffer_size, total_queued;
guint64 PTS, DTS;
g_mutex_lock (system_encode->lock);
while (gst_system_encode_have_data (system_encode)) {
GST_DEBUG ("system_encode::multiplex: multiplexing");
if (!system_encode->have_setup) {
gst_system_setup_multiplex (system_encode);
system_encode->have_setup = TRUE;
}
if (system_encode->mta == NULL) {
system_encode->mta =
gst_system_encode_pick_streams (system_encode->mta, system_encode);
}
if (system_encode->mta == NULL)
break;
system_encode->SCR =
(guint64) (system_encode->bytes_output +
LAST_SCR_BYTE_IN_PACK) * CLOCKS / system_encode->dmux_rate;
streams = g_list_first (system_encode->mta);
mb = (Mpeg1MuxBuffer *) streams->data;
if (system_encode->current_pack == system_encode->packets_per_pack) {
create_pack (system_encode->pack, system_encode->SCR,
system_encode->mux_rate);
create_sys_header (system_encode->sys_header, system_encode->mux_rate, 1,
1, 1, 1, 1, 1, AUDIO_STR_0, 0, system_encode->audio_buffer_size / 128,
VIDEO_STR_0, 1, system_encode->video_buffer_size / 1024,
system_encode->which_streams);
system_encode->current_pack = 0;
pack = system_encode->pack;
sys_header = system_encode->sys_header;
} else {
system_encode->current_pack++;
pack = NULL;
sys_header = NULL;
}
tc = MPEG1MUX_BUFFER_FIRST_TIMECODE (mb);
if (mb->new_frame) {
GST_DEBUG ("system_encode::multiplex: new frame");
if (tc->frame_type == FRAME_TYPE_AUDIO
|| tc->frame_type == FRAME_TYPE_IFRAME
|| tc->frame_type == FRAME_TYPE_PFRAME) {
timestamps = TIMESTAMPS_PTS;
} else {
timestamps = TIMESTAMPS_PTS_DTS;
}
} else {
timestamps = TIMESTAMPS_NO;
}
if (tc->frame_type != FRAME_TYPE_AUDIO) {
if (tc->PTS < system_encode->startup_delay)
system_encode->startup_delay = tc->PTS;
}
if (tc->frame_type == FRAME_TYPE_AUDIO) {
buffer_scale = 0;
non_scaled_buffer_size = system_encode->audio_buffer_size;
buffer_size = system_encode->audio_buffer_size / 128;
PTS = tc->PTS + system_encode->audio_delay + system_encode->startup_delay;
DTS = tc->PTS + system_encode->audio_delay + system_encode->startup_delay;
} else {
buffer_scale = 1;
non_scaled_buffer_size = system_encode->video_buffer_size;
buffer_size = system_encode->video_buffer_size / 1024;
PTS = tc->PTS + system_encode->video_delay;
DTS = tc->DTS + system_encode->video_delay;
}
total_queued = mpeg1mux_buffer_update_queued (mb, system_encode->SCR);
if (non_scaled_buffer_size - total_queued >= system_encode->packet_size) {
/* write the pack/packet here */
create_sector (system_encode->sector, pack, sys_header,
system_encode->packet_size,
MPEG1MUX_BUFFER_DATA (mb), mb->stream_id, buffer_scale,
buffer_size, TRUE, PTS, DTS,
timestamps, system_encode->which_streams);
/* update mta */
system_encode->mta =
gst_system_encode_update_mta (system_encode, system_encode->mta,
system_encode->sector->length_of_packet_data);
} else {
/* write a padding packet */
create_sector (system_encode->sector, pack, sys_header,
system_encode->packet_size, NULL, PADDING_STR, 0,
0, FALSE, 0, 0, TIMESTAMPS_NO, system_encode->which_streams);
}
outbuf = gst_buffer_new ();
GST_BUFFER_DATA (outbuf) =
g_malloc (system_encode->sector->length_of_sector);
GST_BUFFER_SIZE (outbuf) = system_encode->sector->length_of_sector;
memcpy (GST_BUFFER_DATA (outbuf), system_encode->sector->buf,
system_encode->sector->length_of_sector);
system_encode->bytes_output += GST_BUFFER_SIZE (outbuf);
gst_pad_push (system_encode->srcpad, GST_DATA (outbuf));
GST_DEBUG ("system_encode::multiplex: writing %02x", mb->stream_id);
}
GST_INFO ("system_encode::multiplex: data left in video buffer %lu\n",
MPEG1MUX_BUFFER_SPACE (system_encode->video_buffer));
GST_INFO ("system_encode::multiplex: data left in audio buffer %lu\n",
MPEG1MUX_BUFFER_SPACE (system_encode->audio_buffer));
g_mutex_unlock (system_encode->lock);
}
static void
gst_system_encode_chain (GstPad * pad, GstData * _data)
{
GstBuffer *buf = GST_BUFFER (_data);
GstMPEG1SystemEncode *system_encode;
guchar *data;
gulong size;
const gchar *padname;
gint channel;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (buf != NULL);
system_encode = GST_SYSTEM_ENCODE (GST_OBJECT_PARENT (pad));
data = GST_BUFFER_DATA (buf);
size = GST_BUFFER_SIZE (buf);
GST_DEBUG ("system_encode::chain: system_encode: have buffer of size %lu",
size);
padname = GST_OBJECT_NAME (pad);
if (strncmp (padname, "audio_", 6) == 0) {
channel = atoi (&padname[6]);
GST_DEBUG
("gst_system_encode_chain: got audio buffer in from audio channel %02d",
channel);
mpeg1mux_buffer_queue (system_encode->audio_buffer, buf);
} else if (strncmp (padname, "video_", 6) == 0) {
channel = atoi (&padname[6]);
GST_DEBUG
("gst_system_encode_chain: got video buffer in from video channel %02d",
channel);
mpeg1mux_buffer_queue (system_encode->video_buffer, buf);
} else {
g_assert_not_reached ();
}
gst_system_encode_multiplex (system_encode);
gst_buffer_unref (buf);
}
static void
gst_system_encode_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstMPEG1SystemEncode *system_encode;
g_return_if_fail (GST_IS_SYSTEM_ENCODE (object));
system_encode = GST_SYSTEM_ENCODE (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_system_encode_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstMPEG1SystemEncode *src;
g_return_if_fail (GST_IS_SYSTEM_ENCODE (object));
src = GST_SYSTEM_ENCODE (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
plugin_init (GstPlugin * plugin)
{
/* this filter needs the getbits functions */
if (!gst_library_load ("gstgetbits"))
return FALSE;
return gst_element_register (plugin, "mpeg1sysenc",
GST_RANK_NONE, GST_TYPE_SYSTEM_ENCODE);
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
mpeg1sysenc,
"MPEG-1 system stream encoder",
plugin_init, VERSION, "GPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)

109
gst/mpeg1sys/gstmpeg1systemencode.h
View file

@ -1,109 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SYSTEM_ENCODE_H__
#define __SYSTEM_ENCODE_H__
#include <gst/gst.h>
#include <gst/getbits/getbits.h>
#include "buffer.h"
#include "main.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define GST_TYPE_SYSTEM_ENCODE \
(gst_mpeg1_system_encode_get_type())
#define GST_SYSTEM_ENCODE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SYSTEM_ENCODE,GstMPEG1SystemEncode))
#define GST_SYSTEM_ENCODE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SYSTEM_ENCODE,GstMPEG1SystemEncodeClass))
#define GST_IS_SYSTEM_ENCODE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SYSTEM_ENCODE))
#define GST_IS_SYSTEM_ENCODE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SYSTEM_ENCODE))
typedef struct _GstMPEG1SystemEncode GstMPEG1SystemEncode;
typedef struct _GstMPEG1SystemEncodeClass GstMPEG1SystemEncodeClass;
struct _GstMPEG1SystemEncode {
GstElement element;
GstPad *srcpad;
gboolean have_setup;
GMutex *lock;
guint num_audio_pads;
guint num_video_pads;
Mpeg1MuxBuffer *audio_buffer;
Mpeg1MuxBuffer *video_buffer;
Pack_struc *pack;
Sys_header_struc *sys_header;
Sector_struc *sector;
guint data_rate, video_rate, audio_rate;
gdouble delay, audio_delay, video_delay;
gdouble clock_cycles;
gulong sectors_delay, video_delay_ms, audio_delay_ms;
gulong startup_delay;
gulong audio_buffer_size;
gulong video_buffer_size;
gulong mux_rate, dmux_rate;
guint64 SCR;
gint which_streams;
gint current_pack;
gulong min_packet_data;
gulong max_packet_data;
gint packets_per_pack;
gulong packet_size;
gulong bytes_output;
GList *mta;
/* stream input pads */
GstPad *private_1_pad[8]; /* up to 8 ac3 audio tracks <grumble> */
GstPad *private_2_pad;
GstPad *video_pad[16];
GstPad *audio_pad[32];
};
struct _GstMPEG1SystemEncodeClass {
GstElementClass parent_class;
};
GType gst_mpeg1_system_encode_get_type(void);
/* multplex.c */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __SYSTEM_ENCODE_H__ */

141
gst/mpeg1sys/main.h
View file

@ -1,141 +0,0 @@
/*************************************************************************
* Generating a MPEG/SYSTEMS *
* MULTIPLEXED VIDEO/AUDIO STREAM *
* from two MPEG source streams *
* Christoph Moar *
* SIEMENS CORPORATE RESEARCH AND DEVELOPMENT ST SN 11 / T SN 6 *
* (C) 1994 1995 *
**************************************************************************
* Restrictions apply. Will not support the whole MPEG/SYSTEM Standard. *
* Basically, will generate Constrained System Parameter Files. *
* Mixes only one audio and/or one video stream. Might be expanded. *
*************************************************************************/
/*************************************************************************
* mplex - MPEG/SYSTEMS multiplexer *
* Copyright (C) 1994 1995 Christoph Moar *
* Siemens ZFE ST SN 11 / T SN 6 *
* *
* moar@informatik.tu-muenchen.de *
* (Christoph Moar) *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software *
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, *
* MA 02110-1301 USA. *
*************************************************************************/
#ifndef __MAIN_H__
#define __MAIN_H__
#include <glib.h>
#define PACK_START 0x000001ba
#define SYS_HEADER_START 0x000001bb
#define ISO11172_END 0x000001b9
#define PACKET_START 0x000001
#define CLOCKS 90000.0 /* System Clock Hertz */
#define AFTER_PACKET_LENGTH 15 /* No of non-data-bytes */
/* following the packet */
/* length field */
#define LAST_SCR_BYTE_IN_PACK 9 /* No of bytes in pack */
/* preceding, and */
/* including, the SCR */
/* The following values for sys_header_length & size are only valid for */
/* System streams consisting of two basic streams. When wrapping around */
/* the system layer on a single video or a single audio stream, those */
/* values get decreased by 3. */
#define SYS_HEADER_LENGTH 12 /* length of Sys Header */
/* after start code and */
/* length field */
#define SYS_HEADER_SIZE 18 /* incl. start code and */
/* length field */
#define PACK_HEADER_SIZE 12
#define PACKET_HEADER_SIZE 6
#define MAX_SECTOR_SIZE 0x20000 /* Max Sektor Groesse */
#define STREAMS_VIDEO 1
#define STREAMS_AUDIO 2
#define STREAMS_BOTH 3
#define AUDIO_STREAMS 0xb8 /* Marker Audio Streams */
#define VIDEO_STREAMS 0xb9 /* Marker Video Streams */
#define AUDIO_STR_0 0xc0 /* Marker Audio Stream0 */
#define VIDEO_STR_0 0xe0 /* Marker Video Stream0 */
#define PADDING_STR 0xbe /* Marker Padding Stream*/
#define ZERO_STUFFING_BYTE 0
#define STUFFING_BYTE 0xff
#define RESERVED_BYTE 0xff
#define TIMESTAMPS_NO 0 /* Flag NO timestamps */
#define TIMESTAMPS_PTS 1 /* Flag PTS timestamp */
#define TIMESTAMPS_PTS_DTS 2 /* Flag BOTH timestamps */
#define MARKER_SCR 2 /* Marker SCR */
#define MARKER_JUST_PTS 2 /* Marker only PTS */
#define MARKER_PTS 3 /* Marker PTS */
#define MARKER_DTS 1 /* Marker DTS */
#define MARKER_NO_TIMESTAMPS 0x0f /* Marker NO timestamps */
#define STATUS_AUDIO_END 0 /* Statusmessage A end */
#define STATUS_VIDEO_END 1 /* Statusmessage V end */
#define STATUS_AUDIO_TIME_OUT 2 /* Statusmessage A out */
#define STATUS_VIDEO_TIME_OUT 3 /* Statusmessage V out */
/*************************************************************************
Typ- und Strukturdefinitionen
*************************************************************************/
typedef struct sector_struc /* A sector, can contain pack, sys header */
/* and packet. */
{ unsigned char buf [MAX_SECTOR_SIZE] ;
unsigned int length_of_sector ;
unsigned int length_of_packet_data ;
guint64 TS ;
} Sector_struc;
typedef struct pack_struc /* Pack Info */
{ unsigned char buf [PACK_HEADER_SIZE];
guint64 SCR;
} Pack_struc;
typedef struct sys_header_struc /* System Header Info */
{ unsigned char buf [SYS_HEADER_SIZE];
} Sys_header_struc;
/*************************************************************************
Funktionsprototypen, keine Argumente, K&R Style
*************************************************************************/
/* systems.c */
void create_sector (Sector_struc *sector, Pack_struc *pack, Sys_header_struc *sys_header,
unsigned int packet_size, unsigned char *inputbuffer, unsigned char type, unsigned char buffer_scale,
unsigned int buffer_size, unsigned char buffers, guint64 PTS, guint64 DTS,
unsigned char timestamps, unsigned int which_streams);
void create_pack (Pack_struc *pack, guint64 SCR, unsigned int mux_rate);
void create_sys_header (Sys_header_struc *sys_header, unsigned int rate_bound, unsigned char audio_bound,
unsigned char fixed, unsigned char CSPS, unsigned char audio_lock, unsigned char video_lock,
unsigned char video_bound, unsigned char stream1, unsigned char buffer1_scale, unsigned int buffer1_size,
unsigned char stream2, unsigned char buffer2_scale, unsigned int buffer2_size, unsigned int which_streams);
#endif

160
gst/mpeg1sys/mpeg1systemencode.vcproj
View file

@ -1,160 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="mpeg1systemencode"
ProjectGUID="{979C216F-0ACF-4956-AE00-055A42D678BA}"
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;mpeg1systemencode_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)/gstmpeg1systemencode.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="../../../gstreamer/win32/Debug;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile="$(OutDir)/mpeg1systemencode.pdb"
SubSystem="2"
OptimizeReferences="2"
ImportLibrary="$(OutDir)/gstmpeg1systemencode.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;mpeg1systemencode_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)/gstmpeg1systemencode.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)/gstmpeg1systemencode.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=".\gstmpeg1systemencode.c">
</File>
<File
RelativePath=".\buffer.c">
</File>
<File
RelativePath=".\systems.c">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath=".\gstmpeg1systemencode.h">
</File>
<File
RelativePath=".\main.h">
</File>
<File
RelativePath=".\buffer.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>

295
gst/mpeg1sys/systems.c
View file

@ -1,295 +0,0 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include "main.h"
static void
buffer_timecode (timecode, marker, buffer)
guint64 timecode;
unsigned char marker;
unsigned char **buffer;
{
unsigned char temp;
temp = (marker << 4) | ((timecode >> 29) & 0x38) |
((timecode >> 29) & 0x6) | 1;
*((*buffer)++) = temp;
temp = (timecode & 0x3fc00000) >> 22;
*((*buffer)++) = temp;
temp = ((timecode & 0x003f8000) >> 14) | 1;
*((*buffer)++) = temp;
temp = (timecode & 0x7f80) >> 7;
*((*buffer)++) = temp;
temp = ((timecode & 0x007f) << 1) | 1;
*((*buffer)++) = temp;
}
/*************************************************************************
creates a complete sector.
Also copies Pack and Sys_Header informations into the
sector buffer, then reads a packet full of data from
the input stream into the sector buffer.
*************************************************************************/
void
create_sector (sector, pack, sys_header,
packet_size, inputbuffer, type,
buffer_scale, buffer_size, buffers, PTS, DTS, timestamps, which_streams)
Sector_struc *sector;
Pack_struc *pack;
Sys_header_struc *sys_header;
unsigned int packet_size;
unsigned char *inputbuffer;
unsigned char type;
unsigned char buffer_scale;
unsigned int buffer_size;
unsigned char buffers;
guint64 PTS;
guint64 DTS;
unsigned char timestamps;
unsigned int which_streams;
{
int i, j, tmp;
unsigned char *index;
unsigned char *size_offset;
/* printf("creating sector\n"); */
index = sector->buf;
sector->length_of_sector = 0;
/* Should we copy Pack Header information ? */
if (pack != NULL) {
i = sizeof (pack->buf);
memcpy (index, pack->buf, i);
index += i;
sector->length_of_sector += i;
}
/* Should we copy System Header information ? */
if (sys_header != NULL) {
i = sizeof (sys_header->buf);
/* only one stream? 3 bytes less in sys header */
if (which_streams != STREAMS_BOTH)
i -= 3;
memcpy (index, sys_header->buf, i);
index += i;
sector->length_of_sector += i;
}
/* write constant packet header data */
*(index++) = (unsigned char) (PACKET_START) >> 16;
*(index++) = (unsigned char) (PACKET_START & 0x00ffff) >> 8;
*(index++) = (unsigned char) (PACKET_START & 0x0000ff);
*(index++) = type;
/* we remember this offset in case we will have to shrink this packet */
size_offset = index;
*(index++) = (unsigned char) ((packet_size - PACKET_HEADER_SIZE) >> 8);
*(index++) = (unsigned char) ((packet_size - PACKET_HEADER_SIZE) & 0xff);
*(index++) = STUFFING_BYTE;
*(index++) = STUFFING_BYTE;
*(index++) = STUFFING_BYTE;
i = 0;
if (!buffers)
i += 2;
if (timestamps == TIMESTAMPS_NO)
i += 9;
else if (timestamps == TIMESTAMPS_PTS)
i += 5;
/* printf("%i stuffing %d\n", i, timestamps); */
for (j = 0; j < i; j++)
*(index++) = STUFFING_BYTE;
/* should we write buffer info ? */
if (buffers) {
*(index++) = (unsigned char) (0x40 |
(buffer_scale << 5) | (buffer_size >> 8));
*(index++) = (unsigned char) (buffer_size & 0xff);
}
/* should we write PTS, PTS & DTS or nothing at all ? */
switch (timestamps) {
case TIMESTAMPS_NO:
*(index++) = MARKER_NO_TIMESTAMPS;
break;
case TIMESTAMPS_PTS:
buffer_timecode (PTS, MARKER_JUST_PTS, &index);
sector->TS = PTS;
break;
case TIMESTAMPS_PTS_DTS:
buffer_timecode (PTS, MARKER_PTS, &index);
buffer_timecode (DTS, MARKER_DTS, &index);
sector->TS = DTS;
break;
}
/* read in packet data */
i = (packet_size - PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH);
if (type == PADDING_STR) {
for (j = 0; j < i; j++)
*(index++) = (unsigned char) STUFFING_BYTE;
tmp = i;
} else {
/*tmp = fread (index, sizeof (unsigned char), i, inputstream); */
memcpy (index, inputbuffer, i);
tmp = i;
index += tmp;
/* if we did not get enough data bytes, shorten the Packet length */
if (tmp != i) {
packet_size -= (i - tmp);
*(size_offset++) =
(unsigned char) ((packet_size - PACKET_HEADER_SIZE) >> 8);
*(size_offset++) =
(unsigned char) ((packet_size - PACKET_HEADER_SIZE) & 0xff);
/* zero byte stuffing in the last Packet of a stream */
/* we don't need this any more, since we shortenend the packet */
/* for (j=tmp; j<i; j++) */
/* *(index++)=(unsigned char) ZERO_STUFFING_BYTE; */
}
}
/* write other struct data */
sector->length_of_sector += packet_size;
sector->length_of_packet_data = tmp;
}
/*************************************************************************
writes specifical pack header information into a buffer
later this will be copied from the sector routine into
the sector buffer
*************************************************************************/
void
create_pack (pack, SCR, mux_rate)
Pack_struc *pack;
unsigned int mux_rate;
guint64 SCR;
{
unsigned char *index;
index = pack->buf;
*(index++) = (unsigned char) ((PACK_START) >> 24);
*(index++) = (unsigned char) ((PACK_START & 0x00ff0000) >> 16);
*(index++) = (unsigned char) ((PACK_START & 0x0000ff00) >> 8);
*(index++) = (unsigned char) (PACK_START & 0x000000ff);
buffer_timecode (SCR, MARKER_SCR, &index);
*(index++) = (unsigned char) (0x80 | (mux_rate >> 15));
*(index++) = (unsigned char) (0xff & (mux_rate >> 7));
*(index++) = (unsigned char) (0x01 | ((mux_rate & 0x7f) << 1));
pack->SCR = SCR;
}
/*************************************************************************
writes specifical system header information into a buffer
later this will be copied from the sector routine into
the sector buffer
*************************************************************************/
void
create_sys_header (sys_header, rate_bound, audio_bound,
fixed, CSPS, audio_lock, video_lock,
video_bound,
stream1, buffer1_scale, buffer1_size,
stream2, buffer2_scale, buffer2_size, which_streams)
Sys_header_struc *sys_header;
unsigned int rate_bound;
unsigned char audio_bound;
unsigned char fixed;
unsigned char CSPS;
unsigned char audio_lock;
unsigned char video_lock;
unsigned char video_bound;
unsigned char stream1;
unsigned char buffer1_scale;
unsigned int buffer1_size;
unsigned char stream2;
unsigned char buffer2_scale;
unsigned int buffer2_size;
unsigned int which_streams;
{
unsigned char *index;
index = sys_header->buf;
/* if we are not using both streams, we should clear some
options here */
if (!(which_streams & STREAMS_AUDIO))
audio_bound = 0;
if (!(which_streams & STREAMS_VIDEO))
video_bound = 0;
*(index++) = (unsigned char) ((SYS_HEADER_START) >> 24);
*(index++) = (unsigned char) ((SYS_HEADER_START & 0x00ff0000) >> 16);
*(index++) = (unsigned char) ((SYS_HEADER_START & 0x0000ff00) >> 8);
*(index++) = (unsigned char) (SYS_HEADER_START & 0x000000ff);
if (which_streams == STREAMS_BOTH) {
*(index++) = (unsigned char) (SYS_HEADER_LENGTH >> 8);
*(index++) = (unsigned char) (SYS_HEADER_LENGTH & 0xff);
} else {
*(index++) = (unsigned char) ((SYS_HEADER_LENGTH - 3) >> 8);
*(index++) = (unsigned char) ((SYS_HEADER_LENGTH - 3) & 0xff);
}
*(index++) = (unsigned char) (0x80 | (rate_bound >> 15));
*(index++) = (unsigned char) (0xff & (rate_bound >> 7));
*(index++) = (unsigned char) (0x01 | ((rate_bound & 0x7f) << 1));
*(index++) = (unsigned char) ((audio_bound << 2) | (fixed << 1) | CSPS);
*(index++) = (unsigned char) ((audio_lock << 7) |
(video_lock << 6) | 0x20 | video_bound);
*(index++) = (unsigned char) RESERVED_BYTE;
if (which_streams & STREAMS_AUDIO) {
*(index++) = stream1;
*(index++) = (unsigned char) (0xc0 |
(buffer1_scale << 5) | (buffer1_size >> 8));
*(index++) = (unsigned char) (buffer1_size & 0xff);
}
if (which_streams & STREAMS_VIDEO) {
*(index++) = stream2;
*(index++) = (unsigned char) (0xc0 |
(buffer2_scale << 5) | (buffer2_size >> 8));
*(index++) = (unsigned char) (buffer2_size & 0xff);
}
}