mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-26 18:20:44 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/asfdemux/gstasfmux.c
Steve Lhomme 0f9162395a local include fixes 
Original commit message from CVS:
local include fixes
Fix some 64 bits constants to be glib friendly
issue for a vararg macro with MSVC
2004-07-26 22:11:21 +00:00

1289 lines
38 KiB
C
Raw Blame History

/* ASF muxer plugin for GStreamer
* Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
*
* 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.
*/
/* based on:
* - ffmpeg ASF muxer
* - Owen's GStreamer ASF demuxer ("just reverse it"(tm)?)
* - Some own random bits and bytes and stuffies and more
* - Grolsch (oh, and Heineken) beer
* - Borrelnootjes (and chips, and stuff)
* - Why are you reading this?
*
* "The best code is written when you're drunk.
* You'll just never understand it, too."
* -- truth hurts.
*/
/* stream does NOT work on Windows Media Player (does work on
* other (Linux-based) players, because we do not specify bitrate
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <gst/video/video.h>
/* for audio codec IDs */
#include <gst/riff/riff-ids.h>
#include "asfheaders.h"
#include "gstasfmux.h"
/* elementfactory information */
static GstElementDetails gst_asfmux_details = {
"Asf multiplexer",
"Codec/Muxer",
"Muxes audio and video streams into an asf stream",
"Ronald Bultje <rbultje@ronald.bitfreak.net>",
};
/* AsfMux signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
ARG_0
};
static GstStaticPadTemplate gst_asfmux_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/x-ms-asf")
);
static GstStaticPadTemplate gst_asfmux_videosink_template =
GST_STATIC_PAD_TEMPLATE ("video_%d",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS ("video/x-raw-yuv, "
"format = (fourcc) { YUY2, I420 }, "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-jpeg, "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-divx, "
"divxversion = (int) [ 3, 5 ], "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-xvid, "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-3ivx, "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-msmpeg, "
"msmpegversion = (int) [ 41, 43 ], "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/mpeg, "
"mpegversion = (int) 1,"
"systemstream = (boolean) false,"
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-h263, "
"width = (int) [ 1, MAX], "
"height = (int) [ 1, MAX]; "
"video/x-dv, "
"systemstream = (boolean) false,"
"width = (int) 720,"
"height = (int) { 576, 480 };"
"video/x-huffyuv, "
"width = (int) [ 1, MAX], " "height = (int) [ 1, MAX]")
);
static GstStaticPadTemplate gst_asfmux_audiosink_template =
GST_STATIC_PAD_TEMPLATE ("audio_%d",
GST_PAD_SINK,
GST_PAD_REQUEST,
GST_STATIC_CAPS ("audio/x-raw-int, "
"endianness = (int) LITTLE_ENDIAN, "
"signed = (boolean) { true, false }, "
"width = (int) { 8, 16 }, "
"depth = (int) { 8, 16 }, "
"rate = (int) [ 1000, 96000 ], "
"channels = (int) [ 1, 2]; "
"audio/mpeg, "
"mpegversion = (int) 1, "
"layer = (int) { 1, 3 }, "
"rate = (int) [ 1000, 96000 ], "
"channels = (int) [ 1, 2]; "
"audio/x-vorbis, "
"rate = (int) [ 1000, 96000 ], "
"channels = (int) [ 1, 2]; "
"audio/x-ac3, "
"rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2]")
);
#define GST_ASF_PACKET_SIZE 3200
#define GST_ASF_PACKET_HEADER_SIZE 12
#define GST_ASF_FRAME_HEADER_SIZE 17
static void gst_asfmux_base_init (gpointer g_class);
static void gst_asfmux_class_init (GstAsfMuxClass * klass);
static void gst_asfmux_init (GstAsfMux * asfmux);
static void gst_asfmux_loop (GstElement * element);
static gboolean gst_asfmux_handle_event (GstPad * pad, GstEvent * event);
static GstPad *gst_asfmux_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name);
static GstElementStateReturn gst_asfmux_change_state (GstElement * element);
static GstElementClass *parent_class = NULL;
/*static guint gst_asfmux_signals[LAST_SIGNAL] = { 0 }; */
GType
gst_asfmux_get_type (void)
{
static GType asfmux_type = 0;
if (!asfmux_type) {
static const GTypeInfo asfmux_info = {
sizeof (GstAsfMuxClass),
gst_asfmux_base_init,
NULL,
(GClassInitFunc) gst_asfmux_class_init,
NULL,
NULL,
sizeof (GstAsfMux),
0,
(GInstanceInitFunc) gst_asfmux_init,
};
asfmux_type = g_type_register_static (GST_TYPE_ELEMENT,
"GstAsfMux", &asfmux_info, 0);
}
return asfmux_type;
}
static void
gst_asfmux_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_asfmux_src_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_asfmux_videosink_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_asfmux_audiosink_template));
gst_element_class_set_details (element_class, &gst_asfmux_details);
}
static void
gst_asfmux_class_init (GstAsfMuxClass * klass)
{
GstElementClass *gstelement_class;
gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
gstelement_class->request_new_pad = gst_asfmux_request_new_pad;
gstelement_class->change_state = gst_asfmux_change_state;
}
static const GstEventMask *
gst_asfmux_get_event_masks (GstPad * pad)
{
static const GstEventMask gst_asfmux_sink_event_masks[] = {
{GST_EVENT_EOS, 0},
{0,}
};
return gst_asfmux_sink_event_masks;
}
static void
gst_asfmux_init (GstAsfMux * asfmux)
{
gint n;
asfmux->srcpad =
gst_pad_new_from_template (gst_static_pad_template_get
(&gst_asfmux_src_template), "src");
gst_element_add_pad (GST_ELEMENT (asfmux), asfmux->srcpad);
GST_FLAG_SET (GST_ELEMENT (asfmux), GST_ELEMENT_EVENT_AWARE);
asfmux->num_outputs = asfmux->num_video = asfmux->num_audio = 0;
memset (&asfmux->output, 0, sizeof (asfmux->output));
for (n = 0; n < MAX_ASF_OUTPUTS; n++) {
asfmux->output[n].index = n;
asfmux->output[n].connected = FALSE;
}
asfmux->write_header = TRUE;
asfmux->packet = NULL;
asfmux->num_packets = 0;
asfmux->sequence = 0;
gst_element_set_loop_function (GST_ELEMENT (asfmux), gst_asfmux_loop);
}
static GstPadLinkReturn
gst_asfmux_vidsink_link (GstPad * pad, const GstCaps * caps)
{
GstAsfMux *asfmux;
GstAsfMuxStream *stream = NULL;
GstStructure *structure;
gint n;
const gchar *mimetype;
gint w, h;
gboolean ret;
asfmux = GST_ASFMUX (gst_pad_get_parent (pad));
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].pad == pad) {
stream = &asfmux->output[n];
break;
}
}
g_assert (n < asfmux->num_outputs);
g_assert (stream != NULL);
g_assert (stream->type == ASF_STREAM_VIDEO);
GST_DEBUG ("asfmux: video sinkconnect triggered on %s",
gst_pad_get_name (pad));
structure = gst_caps_get_structure (caps, 0);
/* global */
ret = gst_structure_get_int (structure, "width", &w);
ret &= gst_structure_get_int (structure, "height", &h);
if (!ret)
return GST_PAD_LINK_REFUSED;
stream->header.video.stream.width = w;
stream->header.video.stream.height = h;
stream->header.video.stream.unknown = 2;
stream->header.video.stream.size = 40;
stream->bitrate = 0; /* TODO */
mimetype = gst_structure_get_name (structure);
if (!strcmp (mimetype, "video/x-raw-yuv")) {
guint32 format;
ret = gst_structure_get_fourcc (structure, "format", &format);
if (!ret)
return GST_PAD_LINK_REFUSED;
stream->header.video.format.tag = format;
switch (format) {
case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
stream->header.video.format.depth = 16;
stream->header.video.format.planes = 1;
break;
case GST_MAKE_FOURCC ('I', '4', '2', '0'):
stream->header.video.format.depth = 12;
stream->header.video.format.planes = 3;
break;
}
goto done;
} else {
stream->header.video.format.depth = 24;
stream->header.video.format.planes = 1;
stream->header.video.format.tag = 0;
/* find format */
if (!strcmp (mimetype, "video/x-huffyuv")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('H', 'F', 'Y', 'U');
} else if (!strcmp (mimetype, "video/x-jpeg")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');
} else if (!strcmp (mimetype, "video/x-divx")) {
gint divxversion;
gst_structure_get_int (structure, "divxversion", &divxversion);
switch (divxversion) {
case 3:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('D', 'I', 'V', '3');
break;
case 4:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
break;
case 5:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('D', 'X', '5', '0');
break;
}
} else if (!strcmp (mimetype, "video/x-xvid")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
} else if (!strcmp (mimetype, "video/x-3ivx")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('3', 'I', 'V', '2');
} else if (!strcmp (mimetype, "video/x-msmpeg")) {
gint msmpegversion;
gst_structure_get_int (structure, "msmpegversion", &msmpegversion);
switch (msmpegversion) {
case 41:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('M', 'P', 'G', '4');
break;
case 42:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('M', 'P', '4', '2');
break;
case 43:
stream->header.video.format.tag =
GST_MAKE_FOURCC ('M', 'P', '4', '3');
break;
}
} else if (!strcmp (mimetype, "video/x-dv")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('D', 'V', 'S', 'D');
} else if (!strcmp (mimetype, "video/x-h263")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('H', '2', '6', '3');
} else if (!strcmp (mimetype, "video/mpeg")) {
stream->header.video.format.tag = GST_MAKE_FOURCC ('M', 'P', 'E', 'G');
}
if (!stream->header.video.format.tag) {
return GST_PAD_LINK_REFUSED;
}
goto done;
}
/* return GST_PAD_LINK_REFUSED; */
done:
stream->bitrate = 1024 * 1024;
stream->header.video.format.size = stream->header.video.stream.size;
stream->header.video.format.width = stream->header.video.stream.width;
stream->header.video.format.height = stream->header.video.stream.height;
stream->header.video.format.image_size = stream->header.video.stream.width *
stream->header.video.stream.height;
stream->header.video.format.xpels_meter = 0;
stream->header.video.format.ypels_meter = 0;
stream->header.video.format.num_colors = 0;
stream->header.video.format.imp_colors = 0;
return GST_PAD_LINK_OK;
}
static GstPadLinkReturn
gst_asfmux_audsink_link (GstPad * pad, const GstCaps * caps)
{
GstAsfMux *asfmux;
GstAsfMuxStream *stream = NULL;
gint n;
const gchar *mimetype;
gint rate, channels;
gboolean ret;
GstStructure *structure;
asfmux = GST_ASFMUX (gst_pad_get_parent (pad));
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].pad == pad) {
stream = &asfmux->output[n];
break;
}
}
g_assert (n < asfmux->num_outputs);
g_assert (stream != NULL);
g_assert (stream->type == ASF_STREAM_AUDIO);
GST_DEBUG ("asfmux: audio sink_link triggered on %s", gst_pad_get_name (pad));
structure = gst_caps_get_structure (caps, 0);
/* we want these for all */
ret = gst_structure_get_int (structure, "channels", &channels);
ret &= gst_structure_get_int (structure, "rate", &rate);
if (!ret)
return GST_PAD_LINK_REFUSED;
stream->header.audio.sample_rate = rate;
stream->header.audio.channels = channels;
mimetype = gst_structure_get_name (structure);
if (!strcmp (mimetype, "audio/x-raw-int")) {
gint block, size;
stream->header.audio.codec_tag = GST_RIFF_WAVE_FORMAT_PCM;
gst_structure_get_int (structure, "width", &block);
gst_structure_get_int (structure, "depth", &size);
stream->header.audio.block_align = block;
stream->header.audio.word_size = size;
stream->header.audio.size = 0;
/* set some more info straight */
stream->header.audio.block_align /= 8;
stream->header.audio.block_align *= stream->header.audio.channels;
stream->header.audio.byte_rate = stream->header.audio.block_align *
stream->header.audio.sample_rate;
goto done;
} else {
stream->header.audio.codec_tag = 0;
if (!strcmp (mimetype, "audio/mpeg")) {
gint layer = 3;
gst_structure_get_int (structure, "layer", &layer);
switch (layer) {
case 3:
stream->header.audio.codec_tag = GST_RIFF_WAVE_FORMAT_MPEGL3;
break;
case 1:
case 2:
stream->header.audio.codec_tag = GST_RIFF_WAVE_FORMAT_MPEGL12;
break;
}
} else if (!strcmp (mimetype, "audio/x-vorbis")) {
stream->header.audio.codec_tag = GST_RIFF_WAVE_FORMAT_VORBIS3;
} else if (!strcmp (mimetype, "audio/x-ac3")) {
stream->header.audio.codec_tag = GST_RIFF_WAVE_FORMAT_A52;
}
stream->header.audio.block_align = 1;
stream->header.audio.byte_rate = 8 * 1024;
stream->header.audio.word_size = 16;
stream->header.audio.size = 0;
if (!stream->header.audio.codec_tag) {
return GST_PAD_LINK_REFUSED;
}
goto done;
}
/* return GST_PAD_LINK_REFUSED; */
done:
stream->bitrate = stream->header.audio.byte_rate * 8;
return GST_PAD_LINK_OK;
}
static void
gst_asfmux_pad_link (GstPad * pad, GstPad * peer, gpointer data)
{
GstAsfMux *asfmux;
GstAsfMuxStream *stream = NULL;
gint n;
asfmux = GST_ASFMUX (gst_pad_get_parent (pad));
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].pad == pad) {
stream = &asfmux->output[n];
break;
}
}
g_assert (n < asfmux->num_outputs);
g_assert (stream != NULL);
g_assert (stream->connected == FALSE);
stream->connected = TRUE;
}
static void
gst_asfmux_pad_unlink (GstPad * pad, GstPad * peer, gpointer data)
{
GstAsfMux *asfmux;
GstAsfMuxStream *stream = NULL;
gint n;
asfmux = GST_ASFMUX (gst_pad_get_parent (pad));
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].pad == pad) {
stream = &asfmux->output[n];
break;
}
}
g_assert (n < asfmux->num_outputs);
g_assert (stream != NULL);
g_assert (stream->connected == TRUE);
stream->connected = FALSE;
}
static GstPad *
gst_asfmux_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * req_name)
{
GstAsfMux *asfmux;
GstPad *newpad;
gchar *padname;
GstPadLinkFunction linkfunc;
GstAsfMuxStream *stream;
GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
g_return_val_if_fail (templ != NULL, NULL);
g_return_val_if_fail (templ->direction == GST_PAD_SINK, NULL);
g_return_val_if_fail (GST_IS_ASFMUX (element), NULL);
asfmux = GST_ASFMUX (element);
stream = &asfmux->output[asfmux->num_outputs++];
stream->queue = NULL;
stream->time = 0;
stream->connected = FALSE;
stream->eos = FALSE;
stream->seqnum = 0;
if (templ == gst_element_class_get_pad_template (klass, "audio_%d")) {
padname = g_strdup_printf ("audio_%02d", asfmux->num_audio++);
stream->type = ASF_STREAM_AUDIO;
linkfunc = gst_asfmux_audsink_link;
} else if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {
padname = g_strdup_printf ("video_%02d", asfmux->num_video++);
stream->type = ASF_STREAM_VIDEO;
linkfunc = gst_asfmux_vidsink_link;
} else {
g_warning ("asfmux: this is not our template!\n");
return NULL;
}
newpad = gst_pad_new_from_template (templ, padname);
stream->pad = newpad;
g_free (padname);
g_signal_connect (newpad, "linked",
G_CALLBACK (gst_asfmux_pad_link), (gpointer) asfmux);
g_signal_connect (newpad, "unlinked",
G_CALLBACK (gst_asfmux_pad_unlink), (gpointer) asfmux);
gst_pad_set_link_function (newpad, linkfunc);
gst_element_add_pad (element, newpad);
gst_pad_set_event_function (newpad, gst_asfmux_handle_event);
gst_pad_set_event_mask_function (newpad, gst_asfmux_get_event_masks);
return newpad;
}
/* can we seek? If not, we assume we're streamable */
static gboolean
gst_asfmux_can_seek (GstAsfMux * asfmux)
{
#if 0
const GstEventMask *masks =
gst_pad_get_event_masks (GST_PAD_PEER (asfmux->srcpad));
/* this is for stream or file-storage */
while (masks != NULL && masks->type != 0) {
if (masks->type == GST_EVENT_SEEK) {
return TRUE;
} else {
masks++;
}
}
return FALSE;
#endif
return TRUE;
}
static gboolean
gst_asfmux_is_stream (GstAsfMux * asfmux)
{
/* this is for RTP */
return FALSE; /*!gst_asfmux_can_seek (asfmux) */
}
/* handle events (search) */
static gboolean
gst_asfmux_handle_event (GstPad * pad, GstEvent * event)
{
GstAsfMux *asfmux;
GstEventType type;
gint n;
asfmux = GST_ASFMUX (gst_pad_get_parent (pad));
type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
switch (type) {
case GST_EVENT_EOS:
/* is this allright? */
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].pad == pad) {
asfmux->output[n].eos = TRUE;
break;
}
}
if (n == asfmux->num_outputs) {
g_warning ("Unknown pad for EOS!");
}
break;
default:
break;
}
return TRUE;
}
/* fill the internal queue for each available pad */
static void
gst_asfmux_fill_queue (GstAsfMux * asfmux)
{
GstBuffer *buffer;
gint n;
for (n = 0; n < asfmux->num_outputs; n++) {
GstAsfMuxStream *stream = &asfmux->output[n];
while (stream->queue == NULL &&
stream->pad != NULL &&
stream->connected == TRUE &&
GST_PAD_IS_USABLE (stream->pad) && stream->eos == FALSE) {
buffer = GST_BUFFER (gst_pad_pull (stream->pad));
if (GST_IS_EVENT (buffer)) {
gst_asfmux_handle_event (stream->pad, GST_EVENT (buffer));
} else {
stream->queue = buffer;
}
}
}
}
static guint
gst_asfmux_packet_remaining (GstAsfMux * asfmux)
{
guint position;
if (asfmux->packet != NULL) {
position = GST_BUFFER_SIZE (asfmux->packet);
} else {
position = 0;
}
return GST_ASF_PACKET_SIZE - GST_ASF_PACKET_HEADER_SIZE - 2 - position;
}
static void
gst_asfmux_put_buffer (GstBuffer * packet, guint8 * data, guint length)
{
if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= length) {
guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
memcpy (pos, data, length);
GST_BUFFER_SIZE (packet) += length;
} else {
g_warning ("Buffer too small");
}
}
static void
gst_asfmux_put_byte (GstBuffer * packet, guint8 data)
{
if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
*(guint8 *) pos = data;
GST_BUFFER_SIZE (packet) += 1;
} else {
g_warning ("Buffer too small");
}
}
static void
gst_asfmux_put_le16 (GstBuffer * packet, guint16 data)
{
if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
*(guint16 *) pos = GUINT16_TO_LE (data);
GST_BUFFER_SIZE (packet) += 2;
} else {
g_warning ("Buffer too small");
}
}
static void
gst_asfmux_put_le32 (GstBuffer * packet, guint32 data)
{
if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
*(guint32 *) pos = GUINT32_TO_LE (data);
GST_BUFFER_SIZE (packet) += 4;
} else {
g_warning ("Buffer too small");
}
}
static void
gst_asfmux_put_le64 (GstBuffer * packet, guint64 data)
{
if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
*(guint64 *) pos = GUINT64_TO_LE (data);
GST_BUFFER_SIZE (packet) += 8;
} else {
g_warning ("Buffer too small");
}
}
static void
gst_asfmux_put_time (GstBuffer * packet, guint64 time)
{
gst_asfmux_put_le64 (packet, time + G_GINT64_CONSTANT (116444736000000000));
}
static void
gst_asfmux_put_guid (GstBuffer * packet, ASFGuidHash * hash, guint8 id)
{
gint n = 0;
ASFGuid *guid;
/* find GUID */
while (hash[n].obj_id != id && hash[n].obj_id != ASF_OBJ_UNDEFINED) {
n++;
}
guid = &hash[n].guid;
gst_asfmux_put_le32 (packet, guid->v1);
gst_asfmux_put_le32 (packet, guid->v2);
gst_asfmux_put_le32 (packet, guid->v3);
gst_asfmux_put_le32 (packet, guid->v4);
}
static void
gst_asfmux_put_string (GstBuffer * packet, const gchar * str)
{
gunichar2 *utf16_str = g_utf8_to_utf16 (str, strlen (str), NULL, NULL, NULL);
gint i, len = strlen (str);
/* this is not an off-by-one-bug, we need the terminating /0 too */
for (i = 0; i <= len; i++) {
gst_asfmux_put_le16 (packet, utf16_str[i]);
}
g_free (utf16_str);
}
static void
gst_asfmux_put_flush (GstAsfMux * asfmux)
{
gst_pad_push (asfmux->srcpad, GST_DATA (gst_event_new_flush ()));
}
/* write an asf chunk (only used in streaming case) */
static void
gst_asfmux_put_chunk (GstBuffer * packet,
GstAsfMux * asfmux, guint16 type, guint length, gint flags)
{
gst_asfmux_put_le16 (packet, type);
gst_asfmux_put_le16 (packet, length + 8);
gst_asfmux_put_le32 (packet, asfmux->sequence++);
gst_asfmux_put_le16 (packet, flags);
gst_asfmux_put_le16 (packet, length + 8);
}
static void
gst_asfmux_put_wav_header (GstBuffer * packet, asf_stream_audio * hdr)
{
gst_asfmux_put_le16 (packet, hdr->codec_tag);
gst_asfmux_put_le16 (packet, hdr->channels);
gst_asfmux_put_le32 (packet, hdr->sample_rate);
gst_asfmux_put_le32 (packet, hdr->byte_rate);
gst_asfmux_put_le16 (packet, hdr->block_align);
gst_asfmux_put_le16 (packet, hdr->word_size);
gst_asfmux_put_le16 (packet, hdr->size);
}
static void
gst_asfmux_put_vid_header (GstBuffer * packet, asf_stream_video * hdr)
{
gst_asfmux_put_le32 (packet, hdr->width);
gst_asfmux_put_le32 (packet, hdr->height);
gst_asfmux_put_byte (packet, hdr->unknown);
gst_asfmux_put_le16 (packet, hdr->size);
}
static void
gst_asfmux_put_bmp_header (GstBuffer * packet, asf_stream_video_format * hdr)
{
gst_asfmux_put_le32 (packet, hdr->size);
gst_asfmux_put_le32 (packet, hdr->width);
gst_asfmux_put_le32 (packet, hdr->height);
gst_asfmux_put_le16 (packet, hdr->planes);
gst_asfmux_put_le16 (packet, hdr->depth);
gst_asfmux_put_le32 (packet, hdr->tag);
gst_asfmux_put_le32 (packet, hdr->image_size);
gst_asfmux_put_le32 (packet, hdr->xpels_meter);
gst_asfmux_put_le32 (packet, hdr->ypels_meter);
gst_asfmux_put_le32 (packet, hdr->num_colors);
gst_asfmux_put_le32 (packet, hdr->imp_colors);
}
/* init header */
static guint
gst_asfmux_put_header (GstBuffer * packet, ASFGuidHash * hash, guint8 id)
{
guint pos = GST_BUFFER_SIZE (packet);
gst_asfmux_put_guid (packet, hash, id);
gst_asfmux_put_le64 (packet, 24);
return pos;
}
/* update header size */
static void
gst_asfmux_end_header (GstBuffer * packet, guint pos)
{
guint cur = GST_BUFFER_SIZE (packet);
GST_BUFFER_SIZE (packet) = pos + sizeof (ASFGuid);
gst_asfmux_put_le64 (packet, cur - pos);
GST_BUFFER_SIZE (packet) = cur;
}
static void
gst_asfmux_file_start (GstAsfMux * asfmux, guint64 file_size, guint64 data_size)
{
GstBuffer *header = gst_buffer_new_and_alloc (4096);
guint bitrate;
guint header_offset, header_pos, header_size;
gint n;
guint64 duration;
bitrate = 0;
for (n = 0; n < asfmux->num_outputs; n++) {
GstAsfMuxStream *stream = &asfmux->output[n];
bitrate += stream->bitrate;
}
GST_BUFFER_SIZE (header) = 0;
if (asfmux->packet != NULL) {
duration = GST_BUFFER_DURATION (asfmux->packet) +
GST_BUFFER_TIMESTAMP (asfmux->packet);
} else {
duration = 0;
}
if (gst_asfmux_is_stream (asfmux)) {
/* start of stream (length will be patched later) */
gst_asfmux_put_chunk (header, asfmux, 0x4824, 0, 0xc00);
}
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_HEADER);
/* header length, will be patched after */
gst_asfmux_put_le64 (header, ~0);
/* number of chunks in header */
gst_asfmux_put_le32 (header, 3 + /*has_title + */ asfmux->num_outputs);
gst_asfmux_put_byte (header, 1); /* ??? */
gst_asfmux_put_byte (header, 2); /* ??? */
/* file header */
header_offset = GST_BUFFER_SIZE (header);
header_pos = gst_asfmux_put_header (header, asf_object_guids, ASF_OBJ_FILE);
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_UNDEFINED);
gst_asfmux_put_le64 (header, file_size);
gst_asfmux_put_time (header, 0);
gst_asfmux_put_le64 (header, asfmux->num_packets); /* number of packets */
gst_asfmux_put_le64 (header, duration / (GST_SECOND / 10000000)); /* end time stamp (in 100ns units) */
gst_asfmux_put_le64 (header, duration / (GST_SECOND / 10000000)); /* duration (in 100ns units) */
gst_asfmux_put_le64 (header, 0); /* start time stamp */
gst_asfmux_put_le32 (header, gst_asfmux_can_seek (asfmux) ? 0x02 : 0x01); /* seekable or streamable */
gst_asfmux_put_le32 (header, GST_ASF_PACKET_SIZE); /* packet size */
gst_asfmux_put_le32 (header, GST_ASF_PACKET_SIZE); /* packet size */
gst_asfmux_put_le32 (header, bitrate); /* Nominal data rate in bps */
gst_asfmux_end_header (header, header_pos);
/* unknown headers */
header_pos = gst_asfmux_put_header (header, asf_object_guids, ASF_OBJ_HEAD1);
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_HEAD2);
gst_asfmux_put_le32 (header, 6);
gst_asfmux_put_le16 (header, 0);
gst_asfmux_end_header (header, header_pos);
/* title and other infos */
#if 0
if (has_title) {
header_pos =
gst_asfmux_put_header (header, asf_object_guids, ASF_OBJ_COMMENT);
gst_asfmux_put_le16 (header, 2 * (strlen (title) + 1));
gst_asfmux_put_le16 (header, 2 * (strlen (author) + 1));
gst_asfmux_put_le16 (header, 2 * (strlen (copyright) + 1));
gst_asfmux_put_le16 (header, 2 * (strlen (comment) + 1));
gst_asfmux_put_le16 (header, 0); /* rating */
gst_asfmux_put_string (header, title);
gst_asfmux_put_string (header, author);
gst_asfmux_put_string (header, copyright);
gst_asfmux_put_string (header, comment);
gst_asfmux_end_header (header, header_pos);
}
#endif
/* stream headers */
for (n = 0; n < asfmux->num_outputs; n++) {
GstAsfMuxStream *stream = &asfmux->output[n];
guint obj_size = 0;
stream->seqnum = 0;
header_pos =
gst_asfmux_put_header (header, asf_object_guids, ASF_OBJ_STREAM);
switch (stream->type) {
case ASF_STREAM_AUDIO:
obj_size = 18;
gst_asfmux_put_guid (header, asf_stream_guids, ASF_STREAM_AUDIO);
gst_asfmux_put_guid (header, asf_correction_guids, ASF_CORRECTION_OFF);
break;
case ASF_STREAM_VIDEO:
obj_size = 11 + 40;
gst_asfmux_put_guid (header, asf_stream_guids, ASF_STREAM_VIDEO);
gst_asfmux_put_guid (header, asf_correction_guids, ASF_CORRECTION_OFF);
break;
default:
g_assert (0);
}
gst_asfmux_put_le64 (header, 0); /* offset */
gst_asfmux_put_le32 (header, obj_size); /* wav header len */
gst_asfmux_put_le32 (header, 0); /* additional data len */
gst_asfmux_put_le16 (header, n + 1); /* stream number */
gst_asfmux_put_le32 (header, 0); /* ??? */
switch (stream->type) {
case ASF_STREAM_AUDIO:
gst_asfmux_put_wav_header (header, &stream->header.audio);
break;
case ASF_STREAM_VIDEO:
gst_asfmux_put_vid_header (header, &stream->header.video.stream);
gst_asfmux_put_bmp_header (header, &stream->header.video.format);
break;
}
gst_asfmux_end_header (header, header_pos);
}
/* media comments */
header_pos =
gst_asfmux_put_header (header, asf_object_guids, ASF_OBJ_CODEC_COMMENT);
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_CODEC_COMMENT1);
gst_asfmux_put_le32 (header, asfmux->num_outputs);
for (n = 0; n < asfmux->num_outputs; n++) {
GstAsfMuxStream *stream = &asfmux->output[n];
const char *codec = "Unknown codec";
gst_asfmux_put_le16 (header, stream->index + 1);
/* Isn't this wrong? This is UTF16! */
gst_asfmux_put_le16 (header, strlen (codec) + 1);
gst_asfmux_put_string (header, codec);
gst_asfmux_put_le16 (header, 0); /* no parameters */
/* id */
switch (stream->type) {
case ASF_STREAM_AUDIO:
gst_asfmux_put_le16 (header, 2);
gst_asfmux_put_le16 (header, stream->header.audio.codec_tag);
break;
case ASF_STREAM_VIDEO:
gst_asfmux_put_le16 (header, 4);
gst_asfmux_put_le32 (header, stream->header.video.format.tag);
break;
default:
g_assert (0);
}
}
gst_asfmux_end_header (header, header_pos);
/* patch the header size fields */
header_pos = GST_BUFFER_SIZE (header);
header_size = header_pos - header_offset;
if (gst_asfmux_is_stream (asfmux)) {
header_size += 8 + 30 + 50;
GST_BUFFER_SIZE (header) = header_offset - 10 - 30;
gst_asfmux_put_le16 (header, header_size);
GST_BUFFER_SIZE (header) = header_offset - 2 - 30;
gst_asfmux_put_le16 (header, header_size);
header_size -= 8 + 30 + 50;
}
header_size += 24 + 6;
GST_BUFFER_SIZE (header) = header_offset - 14;
gst_asfmux_put_le64 (header, header_size);
GST_BUFFER_SIZE (header) = header_pos;
/* movie chunk, followed by packets of packet_size */
asfmux->data_offset = GST_BUFFER_SIZE (header);
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_DATA);
gst_asfmux_put_le64 (header, data_size);
gst_asfmux_put_guid (header, asf_object_guids, ASF_OBJ_UNDEFINED);
gst_asfmux_put_le64 (header, asfmux->num_packets); /* nb packets */
gst_asfmux_put_byte (header, 1); /* ??? */
gst_asfmux_put_byte (header, 1); /* ??? */
gst_pad_push (asfmux->srcpad, GST_DATA (header));
asfmux->write_header = FALSE;
}
static void
gst_asfmux_file_stop (GstAsfMux * asfmux)
{
if (gst_asfmux_is_stream (asfmux)) {
/* send EOS chunk */
GstBuffer *footer = gst_buffer_new_and_alloc (16);
GST_BUFFER_SIZE (footer) = 0;
gst_asfmux_put_chunk (footer, asfmux, 0x4524, 0, 0); /* end of stream */
gst_pad_push (asfmux->srcpad, GST_DATA (footer));
} else if (gst_asfmux_can_seek (asfmux)) {
/* rewrite an updated header */
gint64 filesize;
GstFormat fmt = GST_FORMAT_BYTES;
GstEvent *event;
gst_pad_query (asfmux->srcpad, GST_QUERY_POSITION, &fmt, &filesize);
event = gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES, 0);
gst_pad_push (asfmux->srcpad, GST_DATA (event));
gst_asfmux_file_start (asfmux, filesize, filesize - asfmux->data_offset);
event =
gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES, filesize);
gst_pad_push (asfmux->srcpad, GST_DATA (event));
}
gst_asfmux_put_flush (asfmux);
}
static GstBuffer *
gst_asfmux_packet_header (GstAsfMux * asfmux)
{
GstBuffer *packet = asfmux->packet, *header;
guint flags, padsize = gst_asfmux_packet_remaining (asfmux);
header = gst_buffer_new_and_alloc (GST_ASF_PACKET_HEADER_SIZE + 2 + 12);
GST_BUFFER_SIZE (header) = 0;
if (gst_asfmux_is_stream (asfmux)) {
gst_asfmux_put_chunk (header, asfmux, 0x4424, GST_ASF_PACKET_SIZE, 0);
}
gst_asfmux_put_byte (header, 0x82);
gst_asfmux_put_le16 (header, 0);
flags = 0x01; /* nb segments present */
if (padsize > 0) {
if (padsize < 256) {
flags |= 0x08;
} else {
flags |= 0x10;
}
}
gst_asfmux_put_byte (header, flags); /* flags */
gst_asfmux_put_byte (header, 0x5d);
if (flags & 0x10) {
gst_asfmux_put_le16 (header, padsize - 2);
} else if (flags & 0x08) {
gst_asfmux_put_byte (header, padsize - 1);
}
gst_asfmux_put_le32 (header,
GST_BUFFER_TIMESTAMP (packet) / (GST_SECOND / 1000));
gst_asfmux_put_le16 (header,
GST_BUFFER_DURATION (packet) / (GST_SECOND / 1000));
gst_asfmux_put_byte (header, asfmux->packet_frames | 0x80);
return header;
}
static void
gst_asfmux_frame_header (GstAsfMux * asfmux,
GstAsfMuxStream * stream,
guint position, guint length, guint total, guint64 time, gboolean key)
{
/* fill in some values for the packet */
if (!GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (asfmux->packet))) {
GST_BUFFER_TIMESTAMP (asfmux->packet) = time;
}
GST_BUFFER_DURATION (asfmux->packet) =
time - GST_BUFFER_TIMESTAMP (asfmux->packet);
gst_asfmux_put_byte (asfmux->packet, (stream->index + 1) | 0x80); //(key ? 0x80 : 0));
gst_asfmux_put_byte (asfmux->packet, stream->seqnum);
gst_asfmux_put_le32 (asfmux->packet, position);
gst_asfmux_put_byte (asfmux->packet, 0x08);
gst_asfmux_put_le32 (asfmux->packet, total);
gst_asfmux_put_le32 (asfmux->packet, time / (GST_SECOND / 1000)); /* time in ms */
gst_asfmux_put_le16 (asfmux->packet, length);
}
static void
gst_asfmux_frame_buffer (GstAsfMux * asfmux, guint8 * data, guint length)
{
gst_asfmux_put_buffer (asfmux->packet, data, length);
asfmux->packet_frames++;
}
static void
gst_asfmux_packet_flush (GstAsfMux * asfmux)
{
GstBuffer *header, *packet = asfmux->packet;
guint header_size;
/* packet header */
header = gst_asfmux_packet_header (asfmux);
header_size = GST_BUFFER_SIZE (header);
if (!gst_asfmux_can_seek (asfmux)) {
header_size -= 12; /* hack... bah */
}
/* Clear out the padding bytes */
memset (GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet), 0,
GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet));
GST_BUFFER_SIZE (packet) = GST_ASF_PACKET_SIZE - header_size;
/* send packet over */
gst_pad_push (asfmux->srcpad, GST_DATA (header));
gst_pad_push (asfmux->srcpad, GST_DATA (packet));
gst_asfmux_put_flush (asfmux);
asfmux->num_packets++;
asfmux->packet_frames = 0;
/* reset packet */
asfmux->packet = NULL;
}
static void
gst_asfmux_write_buffer (GstAsfMux * asfmux,
GstAsfMuxStream * stream, GstBuffer * buffer)
{
guint position = 0, to_write, size = GST_BUFFER_SIZE (buffer), remaining;
while (position < size) {
remaining = gst_asfmux_packet_remaining (asfmux);
if (remaining <= GST_ASF_FRAME_HEADER_SIZE) {
gst_asfmux_packet_flush (asfmux);
continue;
} else if (remaining >= (GST_ASF_FRAME_HEADER_SIZE + size - position)) {
to_write = size - position;
} else {
to_write = remaining - GST_ASF_FRAME_HEADER_SIZE;
}
if (asfmux->packet == NULL) {
asfmux->packet_frames = 0;
asfmux->packet = gst_buffer_new_and_alloc (GST_ASF_PACKET_SIZE);
GST_BUFFER_SIZE (asfmux->packet) = 0;
}
/* write frame header plus data in this packet */
gst_asfmux_frame_header (asfmux, stream, position, to_write, size,
GST_BUFFER_TIMESTAMP (buffer),
GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_KEY_UNIT));
gst_asfmux_frame_buffer (asfmux, GST_BUFFER_DATA (buffer) + position,
to_write);
position += to_write;
}
stream->seqnum++;
}
/* take the oldest buffer in our internal queue and push-it */
static gboolean
gst_asfmux_do_one_buffer (GstAsfMux * asfmux)
{
gint n, chosen = -1;
/* find the earliest buffer */
for (n = 0; n < asfmux->num_outputs; n++) {
if (asfmux->output[n].queue != NULL) {
if (chosen == -1 ||
GST_BUFFER_TIMESTAMP (asfmux->output[n].queue) <
GST_BUFFER_TIMESTAMP (asfmux->output[chosen].queue)) {
chosen = n;
}
}
}
if (chosen == -1) {
/* simply finish off the file and send EOS */
gst_asfmux_file_stop (asfmux);
gst_pad_push (asfmux->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
gst_element_set_eos (GST_ELEMENT (asfmux));
return FALSE;
}
/* do this buffer */
gst_asfmux_write_buffer (asfmux, &asfmux->output[chosen],
asfmux->output[chosen].queue);
/* update stream info after buffer push */
gst_buffer_unref (asfmux->output[chosen].queue);
asfmux->output[chosen].time =
GST_BUFFER_TIMESTAMP (asfmux->output[chosen].queue);
asfmux->output[chosen].queue = NULL;
return TRUE;
}
static void
gst_asfmux_loop (GstElement * element)
{
GstAsfMux *asfmux;
asfmux = GST_ASFMUX (element);
/* first fill queue (some elements only set caps when
* flowing data), then write header */
gst_asfmux_fill_queue (asfmux);
if (asfmux->write_header == TRUE) {
/* indeed, these are fake values. We need this so that
* players will read the file. Without these fake values,
* the players will mark the file as invalid and stop */
gst_asfmux_file_start (asfmux, 0xFFFFFFFF, 0xFFFFFFFF);
}
gst_asfmux_do_one_buffer (asfmux);
}
static GstElementStateReturn
gst_asfmux_change_state (GstElement * element)
{
GstAsfMux *asfmux;
gint transition = GST_STATE_TRANSITION (element), n;
g_return_val_if_fail (GST_IS_ASFMUX (element), GST_STATE_FAILURE);
asfmux = GST_ASFMUX (element);
switch (transition) {
case GST_STATE_PAUSED_TO_PLAYING:
for (n = 0; n < asfmux->num_outputs; n++) {
asfmux->output[n].eos = FALSE;
}
break;
}
if (GST_ELEMENT_CLASS (parent_class)->change_state)
return GST_ELEMENT_CLASS (parent_class)->change_state (element);
return GST_STATE_SUCCESS;
}
Reference in a new issue View git blame Copy permalink