diff options
Diffstat (limited to 'gst/mve')
| -rw-r--r-- | gst/mve/Makefile.am | 20 | ||||
| -rw-r--r-- | gst/mve/TODO | 5 | ||||
| -rw-r--r-- | gst/mve/gstmve.c | 46 | ||||
| -rw-r--r-- | gst/mve/gstmvedemux.c | 1126 | ||||
| -rw-r--r-- | gst/mve/gstmvedemux.h | 104 | ||||
| -rw-r--r-- | gst/mve/gstmvemux.c | 1493 | ||||
| -rw-r--r-- | gst/mve/gstmvemux.h | 120 | ||||
| -rw-r--r-- | gst/mve/mve.h | 62 | ||||
| -rw-r--r-- | gst/mve/mveaudiodec.c | 82 | ||||
| -rw-r--r-- | gst/mve/mveaudioenc.c | 120 | ||||
| -rw-r--r-- | gst/mve/mvevideodec16.c | 849 | ||||
| -rw-r--r-- | gst/mve/mvevideodec8.c | 802 | ||||
| -rw-r--r-- | gst/mve/mvevideoenc16.c | 1649 | ||||
| -rw-r--r-- | gst/mve/mvevideoenc8.c | 1733 |
14 files changed, 8211 insertions, 0 deletions
diff --git a/gst/mve/Makefile.am b/gst/mve/Makefile.am new file mode 100644 index 00000000..3b1a5a4c --- /dev/null +++ b/gst/mve/Makefile.am @@ -0,0 +1,20 @@ +plugin_LTLIBRARIES = libgstmve.la + +libgstmve_la_CFLAGS = $(GST_BASE_CFLAGS) $(GST_CFLAGS) +libgstmve_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) +libgstmve_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +libgstmve_la_SOURCES = \ + gstmve.c \ + gstmvemux.c \ + gstmvedemux.c \ + mveaudiodec.c \ + mvevideodec8.c \ + mvevideodec16.c \ + mveaudioenc.c \ + mvevideoenc8.c \ + mvevideoenc16.c + +noinst_HEADERS = gstmvedemux.h gstmvemux.h mve.h + +EXTRA_DIST = TODO diff --git a/gst/mve/TODO b/gst/mve/TODO new file mode 100644 index 00000000..4384f3e9 --- /dev/null +++ b/gst/mve/TODO @@ -0,0 +1,5 @@ +MVE TODO: + - seeking support + - split out decoders from demuxer into separate elements + - split out encoders from muxer into separate elements + diff --git a/gst/mve/gstmve.c b/gst/mve/gstmve.c new file mode 100644 index 00000000..ae1014b2 --- /dev/null +++ b/gst/mve/gstmve.c @@ -0,0 +1,46 @@ +/* GStreamer plugin for Interplay MVE movie files + * + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + * + * For more information about the Interplay MVE format, visit: + * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include "gstmvedemux.h" +#include "gstmvemux.h" + +static gboolean +mve_plugin_init (GstPlugin * plugin) +{ + + return gst_element_register (plugin, "mvedemux", + GST_RANK_PRIMARY, + GST_TYPE_MVE_DEMUX) && + gst_element_register (plugin, "mvemux", GST_RANK_NONE, GST_TYPE_MVE_MUX); +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "mve", + "Interplay MVE movie format manipulation", + mve_plugin_init, + VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN); diff --git a/gst/mve/gstmvedemux.c b/gst/mve/gstmvedemux.c new file mode 100644 index 00000000..767e730d --- /dev/null +++ b/gst/mve/gstmvedemux.c @@ -0,0 +1,1126 @@ +/* GStreamer demultiplexer plugin for Interplay MVE movie files + * + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + * + * For more information about the Interplay MVE format, visit: + * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <string.h> +#include "gstmvedemux.h" +#include "mve.h" + +GST_DEBUG_CATEGORY_STATIC (mvedemux_debug); +#define GST_CAT_DEFAULT mvedemux_debug + +extern int ipvideo_decode_frame8 (const GstMveDemuxStream * s, + const unsigned char *data, unsigned short len); +extern int ipvideo_decode_frame16 (const GstMveDemuxStream * s, + const unsigned char *data, unsigned short len); + +extern void ipaudio_uncompress (short *buffer, + unsigned short buf_len, const unsigned char *data, unsigned char channels); + +enum MveDemuxState +{ + MVEDEMUX_STATE_INITIAL, /* initial state, header not read */ + MVEDEMUX_STATE_NEXT_CHUNK, /* parsing chunk/segment header */ + MVEDEMUX_STATE_MOVIE, /* reading the stream */ + MVEDEMUX_STATE_SKIP /* skipping chunk */ +}; + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-mve") + ); + +static GstStaticPadTemplate vidsrc_template = GST_STATIC_PAD_TEMPLATE ("video", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("video/x-raw-rgb, " + "width = (int) [ 1, MAX ], " + "height = (int) [ 1, MAX ], " + "framerate = (fraction) [ 0, MAX ], " + "bpp = (int) 16, " + "depth = (int) 15, " + "endianness = (int) BYTE_ORDER, " + "red_mask = (int) 31744, " + "green_mask = (int) 992, " + "blue_mask = (int) 31; " + "video/x-raw-rgb, " + "width = (int) [ 1, MAX ], " + "height = (int) [ 1, MAX ], " + "framerate = (fraction) [ 0, MAX ], " + "bpp = (int) 8, " "depth = (int) 8, " "endianness = (int) BYTE_ORDER") + ); + +static GstStaticPadTemplate audsrc_template = GST_STATIC_PAD_TEMPLATE ("audio", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("audio/x-raw-int, " + "width = (int) 8, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, 2 ], " + "depth = (int) 8, " + "signed = (boolean) false; " + "audio/x-raw-int, " + "width = (int) 16, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, 2 ], " + "depth = (int) 16, " + "signed = (boolean) true, " + "endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }") + ); + +#define MVE_DEFAULT_AUDIO_STREAM 0x01 + +static void gst_mve_demux_class_init (GstMveDemuxClass * klass); +static void gst_mve_demux_base_init (GstMveDemuxClass * klass); +static void gst_mve_demux_init (GstMveDemux * mve); + +#define GST_MVE_SEGMENT_SIZE(data) (GST_READ_UINT16_LE (data)) +#define GST_MVE_SEGMENT_TYPE(data) (GST_READ_UINT8 (data + 2)) +#define GST_MVE_SEGMENT_VERSION(data) (GST_READ_UINT8 (data + 3)) + +static GstElementClass *parent_class = NULL; + +static void +gst_mve_demux_reset (GstMveDemux * mve) +{ + gst_adapter_clear (mve->adapter); + + if (mve->video_stream != NULL) { + if (mve->video_stream->pad) + gst_element_remove_pad (GST_ELEMENT (mve), mve->video_stream->pad); + if (mve->video_stream->caps) + gst_caps_unref (mve->video_stream->caps); + if (mve->video_stream->palette) + gst_buffer_unref (mve->video_stream->palette); + g_free (mve->video_stream->code_map); + if (mve->video_stream->buffer) + gst_buffer_unref (mve->video_stream->buffer); + g_free (mve->video_stream); + mve->video_stream = NULL; + } + + if (mve->audio_stream != NULL) { + if (mve->audio_stream->pad) + gst_element_remove_pad (GST_ELEMENT (mve), mve->audio_stream->pad); + if (mve->audio_stream->caps) + gst_caps_unref (mve->audio_stream->caps); + if (mve->audio_stream->buffer) + gst_buffer_unref (mve->audio_stream->buffer); + g_free (mve->audio_stream); + mve->audio_stream = NULL; + } + + mve->state = MVEDEMUX_STATE_INITIAL; + mve->needed_bytes = MVE_PREAMBLE_SIZE; + mve->frame_duration = GST_CLOCK_TIME_NONE; + + mve->chunk_size = 0; + mve->chunk_offset = 0; +} + +static const GstQueryType * +gst_mve_demux_get_src_query_types (GstPad * pad) +{ + static const GstQueryType src_types[] = { + GST_QUERY_POSITION, + 0 + }; + + return src_types; +} + +static gboolean +gst_mve_demux_handle_src_query (GstPad * pad, GstQuery * query) +{ + gboolean res = FALSE; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_POSITION:{ + GstFormat format; + + gst_query_parse_position (query, &format, NULL); + + /* we only support TIME */ + if (format == GST_FORMAT_TIME) { + GstMveDemuxStream *s = gst_pad_get_element_private (pad); + + if (s != NULL) { + GST_OBJECT_LOCK (s); + gst_query_set_position (query, GST_FORMAT_TIME, s->last_ts); + GST_OBJECT_UNLOCK (s); + res = TRUE; + } + } + break; + } + default: + res = gst_pad_query_default (pad, query); + break; + } + + return res; +} + +static GstStateChangeReturn +gst_mve_demux_change_state (GstElement * element, GstStateChange transition) +{ + GstMveDemux *mve = GST_MVE_DEMUX (element); + + if (GST_ELEMENT_CLASS (parent_class)->change_state) { + GstStateChangeReturn ret; + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + if (ret != GST_STATE_CHANGE_SUCCESS) + return ret; + } + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_mve_demux_reset (mve); + break; + default: + break; + } + + return GST_STATE_CHANGE_SUCCESS; +} + +static gboolean +gst_mve_add_stream (GstMveDemux * mve, GstMveDemuxStream * stream, + GstTagList * list) +{ + GstPadTemplate *templ; + gboolean ret = FALSE; + + if (stream->pad == NULL) { + if (stream == mve->video_stream) { + templ = gst_static_pad_template_get (&vidsrc_template); + stream->pad = gst_pad_new_from_template (templ, "video"); + } else { + templ = gst_static_pad_template_get (&audsrc_template); + stream->pad = gst_pad_new_from_template (templ, "audio"); + } + gst_object_unref (templ); + + gst_pad_set_query_type_function (stream->pad, + GST_DEBUG_FUNCPTR (gst_mve_demux_get_src_query_types)); + gst_pad_set_query_function (stream->pad, + GST_DEBUG_FUNCPTR (gst_mve_demux_handle_src_query)); + gst_pad_set_element_private (stream->pad, stream); + + GST_DEBUG_OBJECT (mve, "adding pad %s", GST_PAD_NAME (stream->pad)); + gst_pad_set_active (stream->pad, TRUE); + gst_element_add_pad (GST_ELEMENT (mve), stream->pad); + ret = TRUE; + } + + GST_DEBUG_OBJECT (mve, "setting caps %" GST_PTR_FORMAT, stream->caps); + gst_pad_set_caps (stream->pad, stream->caps); + + if (list) + gst_element_found_tags_for_pad (GST_ELEMENT (mve), stream->pad, list); + + return ret; +} + +static GstFlowReturn +gst_mve_stream_error (GstMveDemux * mve, guint16 req, guint16 avail) +{ + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("wanted to read %d bytes from stream, %d available", req, avail)); + return GST_FLOW_ERROR; +} + +static GstFlowReturn +gst_mve_buffer_alloc_for_pad (GstMveDemuxStream * stream, + guint32 size, GstBuffer ** buffer) +{ + GstFlowReturn ret = + gst_pad_alloc_buffer_and_set_caps (stream->pad, stream->offset, + size, stream->caps, buffer); + + if (ret == GST_FLOW_OK) + GST_BUFFER_TIMESTAMP (*buffer) = stream->last_ts; + + return ret; +} + +static GstFlowReturn +gst_mve_video_init (GstMveDemux * mve, const guint8 * data) +{ + GST_DEBUG_OBJECT (mve, "init video"); + + if (mve->video_stream == NULL) { + GstMveDemuxStream *stream = g_new0 (GstMveDemuxStream, 1); + + stream->buffer = NULL; + stream->back_buf1 = NULL; + stream->back_buf2 = NULL; + stream->offset = 0; + stream->width = 0; + stream->height = 0; + stream->code_map = NULL; + stream->code_map_avail = FALSE; + stream->palette = NULL; + stream->caps = NULL; + stream->last_ts = GST_CLOCK_TIME_NONE; + mve->video_stream = stream; + } + + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_video_create_buffer (GstMveDemux * mve, guint8 version, + const guint8 * data, guint16 len) +{ + GstBuffer *buf; + guint16 w, h, n, true_color, bpp; + guint required, size; + + GST_DEBUG_OBJECT (mve, "create video buffer"); + + if (mve->video_stream == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("trying to create video buffer for uninitialized stream")); + return GST_FLOW_ERROR; + } + + /* need 4 to 8 more bytes */ + required = (version > 1) ? 8 : (version * 2); + if (len < required) + return gst_mve_stream_error (mve, required, len); + + w = GST_READ_UINT16_LE (data) << 3; + h = GST_READ_UINT16_LE (data + 2) << 3; + + if (version > 0) + n = GST_READ_UINT16_LE (data + 4); + else + n = 1; + + if (version > 1) + true_color = GST_READ_UINT16_LE (data + 6); + else + true_color = 0; + + bpp = (true_color ? 2 : 1); + size = w * h * bpp; + + if (mve->video_stream->buffer != NULL) { + GST_DEBUG_OBJECT (mve, "video buffer already created"); + + if (GST_BUFFER_SIZE (mve->video_stream->buffer) == size * 2) + return GST_FLOW_OK; + + GST_DEBUG_OBJECT (mve, "video buffer size has changed"); + gst_buffer_unref (mve->video_stream->buffer); + } + + GST_DEBUG_OBJECT (mve, + "allocating video buffer, w:%ld, h:%ld, n:%ld, true_color:%ld", w, h, n, + true_color); + + /* we need a buffer to keep the last 2 frames, since those may be + needed for decoding the next one */ + buf = gst_buffer_new_and_alloc (size * 2); + + mve->video_stream->bpp = bpp; + mve->video_stream->width = w; + mve->video_stream->height = h; + mve->video_stream->buffer = buf; + mve->video_stream->back_buf1 = GST_BUFFER_DATA (buf); + mve->video_stream->back_buf2 = mve->video_stream->back_buf1 + size; + mve->video_stream->max_block_offset = (h - 7) * w - 8; + memset (mve->video_stream->back_buf1, 0, size * 2); + + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_video_palette (GstMveDemux * mve, const guint8 * data, guint16 len) +{ + GstBuffer *buf; + guint16 start, count; + const guint8 *pal; + guint32 *pal_ptr; + gint i; + + GST_DEBUG_OBJECT (mve, "video palette"); + + if (mve->video_stream == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("found palette before video stream was initialized")); + return GST_FLOW_ERROR; + } + + /* need 4 more bytes now, more later */ + if (len < 4) + return gst_mve_stream_error (mve, 4, len); + + len -= 4; + + start = GST_READ_UINT16_LE (data); + count = GST_READ_UINT16_LE (data + 2); + GST_DEBUG_OBJECT (mve, "found palette start:%ld, count:%ld", start, count); + + /* need more bytes */ + if (len < count * 3) + return gst_mve_stream_error (mve, count * 3, len); + + /* make sure we don't exceed the buffer */ + if (start + count > MVE_PALETTE_COUNT) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("palette too large for buffer")); + return GST_FLOW_ERROR; + } + + if (mve->video_stream->palette != NULL) { + /* older buffers floating around might still use the old + palette, so make sure we can update it */ + buf = gst_buffer_make_writable (mve->video_stream->palette); + } else { + buf = gst_buffer_new_and_alloc (MVE_PALETTE_COUNT * 4); + memset (GST_BUFFER_DATA (buf), 0, GST_BUFFER_SIZE (buf)); + } + + mve->video_stream->palette = buf; + + pal = data + 4; + pal_ptr = ((guint32 *) GST_BUFFER_DATA (buf)) + start; + for (i = 0; i < count; ++i) { + /* convert from 6-bit VGA to 8-bit palette */ + guint8 r, g, b; + + r = (*pal) << 2; + ++pal; + g = (*pal) << 2; + ++pal; + b = (*pal) << 2; + ++pal; + *pal_ptr = (r << 16) | (g << 8) | (b); + ++pal_ptr; + } + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_video_palette_compressed (GstMveDemux * mve, const guint8 * data, + guint16 len) +{ + guint8 mask; + gint i, j; + guint32 *col; + + GST_DEBUG_OBJECT (mve, "compressed video palette"); + + if (mve->video_stream == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("found palette before video stream was initialized")); + return GST_FLOW_ERROR; + } + + if (mve->video_stream->palette == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("no palette available for modification")); + return GST_FLOW_ERROR; + } + + /* need at least 32 more bytes */ + if (len < 32) + return gst_mve_stream_error (mve, 32, len); + + len -= 32; + + for (i = 0; i < 32; ++i) { + mask = GST_READ_UINT8 (data); + ++data; + + if (mask != 0) { + for (j = 0; j < 8; ++j) { + if (mask & (1 << j)) { + guint8 r, g, b; + + /* need 3 more bytes */ + if (len < 3) + return gst_mve_stream_error (mve, 3, len); + + len -= 3; + + r = (*data) << 2; + ++data; + g = (*data) << 2; + ++data; + b = (*data) << 2; + ++data; + col = + ((guint32 *) GST_BUFFER_DATA (mve->video_stream->palette)) + + i * 8 + j; + *col = (r << 16) | (g << 8) | (b); + } + } + } + } + + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_video_code_map (GstMveDemux * mve, const guint8 * data, guint16 len) +{ + gint min; + + if (mve->video_stream == NULL || mve->video_stream->code_map == NULL) { + GST_WARNING_OBJECT (mve, "video stream not initialized"); + return GST_FLOW_ERROR; + } + + GST_DEBUG_OBJECT (mve, "found code map, size:%ld", len); + + /* decoding is done in 8x8 blocks using 4-bit opcodes */ + min = (mve->video_stream->width * mve->video_stream->height) / (8 * 8 * 2); + + if (len < min) + return gst_mve_stream_error (mve, min, len); + + memcpy (mve->video_stream->code_map, data, min); + mve->video_stream->code_map_avail = TRUE; + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_video_data (GstMveDemux * mve, const guint8 * data, guint16 len, + GstBuffer ** output) +{ + GstFlowReturn ret = GST_FLOW_OK; + gint16 cur_frame, last_frame; + gint16 x_offset, y_offset; + gint16 x_size, y_size; + guint16 flags; + gint dec; + GstBuffer *buf = NULL; + GstMveDemuxStream *s = mve->video_stream; + + GST_LOG_OBJECT (mve, "video data"); + + if (s == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("trying to decode video data before stream was initialized")); + return GST_FLOW_ERROR; + } + + if (GST_CLOCK_TIME_IS_VALID (mve->frame_duration)) { + if (GST_CLOCK_TIME_IS_VALID (s->last_ts)) + s->last_ts += mve->frame_duration; + else + s->last_ts = 0; + } + + if (!s->code_map_avail) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("no code map available for decoding")); + return GST_FLOW_ERROR; + } + + /* need at least 14 more bytes */ + if (len < 14) + return gst_mve_stream_error (mve, 14, len); + + len -= 14; + + cur_frame = GST_READ_UINT16_LE (data); + last_frame = GST_READ_UINT16_LE (data + 2); + x_offset = GST_READ_UINT16_LE (data + 4); + y_offset = GST_READ_UINT16_LE (data + 6); + x_size = GST_READ_UINT16_LE (data + 8); + y_size = GST_READ_UINT16_LE (data + 10); + flags = GST_READ_UINT16_LE (data + 12); + data += 14; + + GST_DEBUG_OBJECT (mve, + "video data hot:%d, cold:%d, xoff:%d, yoff:%d, w:%d, h:%d, flags:%x", + cur_frame, last_frame, x_offset, y_offset, x_size, y_size, flags); + + if (flags & MVE_VIDEO_DELTA_FRAME) { + guint8 *temp = s->back_buf1; + + s->back_buf1 = s->back_buf2; + s->back_buf2 = temp; + } + + ret = gst_mve_buffer_alloc_for_pad (s, s->width * s->height * s->bpp, &buf); + if (ret != GST_FLOW_OK) + return ret; + + if (s->bpp == 2) { + dec = ipvideo_decode_frame16 (s, data, len); + } else { + if (s->palette == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), ("no palette available")); + goto error; + } + + dec = ipvideo_decode_frame8 (s, data, len); + } + if (dec != 0) + goto error; + + memcpy (GST_BUFFER_DATA (buf), s->back_buf1, GST_BUFFER_SIZE (buf)); + GST_BUFFER_DURATION (buf) = mve->frame_duration; + GST_BUFFER_OFFSET_END (buf) = ++s->offset; + + if (s->bpp == 1) { + GstCaps *caps; + + /* set the palette on the outgoing buffer */ + caps = gst_caps_copy (s->caps); + gst_caps_set_simple (caps, + "palette_data", GST_TYPE_BUFFER, s->palette, NULL); + gst_buffer_set_caps (buf, caps); + gst_caps_unref (caps); + } + + *output = buf; + return GST_FLOW_OK; + +error: + gst_buffer_unref (buf); + return GST_FLOW_ERROR; +} + +static GstFlowReturn +gst_mve_audio_init (GstMveDemux * mve, guint8 version, const guint8 * data, + guint16 len) +{ + GstMveDemuxStream *stream; + guint16 flags; + guint32 requested_buffer; + GstTagList *list; + gchar *name; + + GST_DEBUG_OBJECT (mve, "init audio"); + + /* need 8 more bytes */ + if (len < 8) + return gst_mve_stream_error (mve, 8, len); + + if (mve->audio_stream == NULL) { + stream = g_new0 (GstMveDemuxStream, 1); + stream->offset = 0; + stream->last_ts = 0; + mve->audio_stream = stream; + } else { + stream = mve->audio_stream; + gst_caps_unref (stream->caps); + } + + flags = GST_READ_UINT16_LE (data + 2); + stream->sample_rate = GST_READ_UINT16_LE (data + 4); + requested_buffer = GST_READ_UINT32_LE (data + 6); + + /* bit 0: 0 = mono, 1 = stereo */ + stream->n_channels = (flags & MVE_AUDIO_STEREO) + 1; + /* bit 1: 0 = 8 bit, 1 = 16 bit */ + stream->sample_size = (((flags & MVE_AUDIO_16BIT) >> 1) + 1) * 8; + /* bit 2: 0 = uncompressed, 1 = compressed */ + stream->compression = ((version > 0) && (flags & MVE_AUDIO_COMPRESSED)) ? + TRUE : FALSE; + + GST_DEBUG_OBJECT (mve, "audio init, sample_rate:%ld, channels:%ld, " + "bits_per_sample:%ld, compression:%ld, buffer:%ld", + stream->sample_rate, stream->n_channels, + stream->sample_size, stream->compression, requested_buffer); + + stream->caps = gst_caps_from_string ("audio/x-raw-int"); + if (stream->caps == NULL) + return GST_FLOW_ERROR; + + gst_caps_set_simple (stream->caps, + "signed", G_TYPE_BOOLEAN, (stream->sample_size == 8) ? FALSE : TRUE, + "depth", G_TYPE_INT, stream->sample_size, + "width", G_TYPE_INT, stream->sample_size, + "channels", G_TYPE_INT, stream->n_channels, + "rate", G_TYPE_INT, stream->sample_rate, NULL); + if (stream->sample_size > 8) { + /* for uncompressed audio we can simply copy the incoming buffer + which is always in little endian format */ + gst_caps_set_simple (stream->caps, "endianness", G_TYPE_INT, + (stream->compression ? G_BYTE_ORDER : LITTLE_ENDIAN), NULL); + } else if (stream->compression) { + GST_WARNING_OBJECT (mve, + "compression is only supported for 16-bit samples"); + stream->compression = FALSE; + } + + list = gst_tag_list_new (); + name = g_strdup_printf ("Raw %d-bit PCM audio", stream->sample_size); + gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, + GST_TAG_AUDIO_CODEC, name, NULL); + g_free (name); + + if (gst_mve_add_stream (mve, stream, list)) + return gst_pad_push_event (mve->audio_stream->pad, + gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, + 0, GST_CLOCK_TIME_NONE, 0)); + else + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_audio_data (GstMveDemux * mve, guint8 type, const guint8 * data, + guint16 len, GstBuffer ** output) +{ + GstFlowReturn ret; + GstMveDemuxStream *s = mve->audio_stream; + GstBuffer *buf = NULL; + guint16 stream_mask; + guint16 size; + + GST_LOG_OBJECT (mve, "audio data"); + + if (s == NULL) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("trying to queue samples with no audio stream")); + return GST_FLOW_ERROR; + } + + /* need at least 6 more bytes */ + if (len < 6) + return gst_mve_stream_error (mve, 6, len); + + len -= 6; + + stream_mask = GST_READ_UINT16_LE (data + 2); + size = GST_READ_UINT16_LE (data + 4); + data += 6; + + if (stream_mask & MVE_DEFAULT_AUDIO_STREAM) { + guint16 n_samples = size / s->n_channels / (s->sample_size / 8); + GstClockTime duration = (GST_SECOND / s->sample_rate) * n_samples; + + if (type == 8) { + guint16 required = (s->compression ? size / 2 + s->n_channels : size); + + if (len < required) + return gst_mve_stream_error (mve, required, len); + + ret = gst_mve_buffer_alloc_for_pad (s, size, &buf); + + if (ret != GST_FLOW_OK) + return ret; + + if (s->compression) + ipaudio_uncompress ((gint16 *) GST_BUFFER_DATA (buf), size, + data, s->n_channels); + else + memcpy (GST_BUFFER_DATA (buf), data, size); + + GST_BUFFER_DURATION (buf) = duration; + GST_BUFFER_OFFSET_END (buf) = s->offset + n_samples; + + GST_DEBUG_OBJECT (mve, "created audio buffer, size:%ld, stream_mask:%lx", + size, stream_mask); + + *output = buf; + } else { + /* silence - + don't return a buffer but notify downstream there won't be + any data in this chunk */ + if (mve->audio_stream->pad) + gst_pad_push_event (mve->audio_stream->pad, + gst_event_new_new_segment (TRUE, 1.0, GST_FORMAT_TIME, + s->last_ts + duration, GST_CLOCK_TIME_NONE, 0)); + } + + s->offset += n_samples; + s->last_ts += duration; + } else { + /* alternate audio streams not supported. + are there any movies which use them? */ + if (type == 8) + GST_WARNING_OBJECT (mve, "found non-empty alternate audio stream"); + } + + return GST_FLOW_OK; +} + +static GstFlowReturn +gst_mve_timer_create (GstMveDemux * mve, const guint8 * data, guint16 len, + GstBuffer ** buf) +{ + guint32 t_rate; + guint16 t_subdiv; + GstMveDemuxStream *s; + GstTagList *list; + gint rate_nom, rate_den; + + g_return_val_if_fail (mve->video_stream != NULL, GST_FLOW_ERROR); + + /* need 6 more bytes */ + if (len < 6) + return gst_mve_stream_error (mve, 6, len); + + t_rate = GST_READ_UINT32_LE (data); + t_subdiv = GST_READ_UINT16_LE (data + 4); + + GST_DEBUG_OBJECT (mve, "found timer:%ldx%d", t_rate, t_subdiv); + mve->frame_duration = t_rate * t_subdiv * GST_USECOND; + + /* now really start rolling... */ + s = mve->video_stream; + + if ((s->buffer == NULL) || (s->width == 0) || (s->height == 0)) { + GST_ELEMENT_ERROR (mve, STREAM, DECODE, (NULL), + ("missing or invalid create-video-buffer segment (%dx%d)", + s->width, s->height)); + return GST_FLOW_ERROR; + } + + if (s->pad != NULL) { + if (s->caps != NULL) { + gst_caps_unref (s->caps); + s->caps = NULL; + } + if (s->code_map != NULL) { + g_free (s->code_map); + s->code_map = NULL; + } + list = NULL; + } else { + list = gst_tag_list_new (); + gst_tag_list_add (list, GST_TAG_MERGE_REPLACE, + GST_TAG_VIDEO_CODEC, "Raw RGB video", NULL); + } + + s->caps = gst_caps_from_string ("video/x-raw-rgb"); + if (s->caps == NULL) + return GST_FLOW_ERROR; + + rate_nom = GST_SECOND / GST_USECOND; + rate_den = mve->frame_duration / GST_USECOND; + + gst_caps_set_simple (s->caps, + "bpp", G_TYPE_INT, s->bpp * 8, + "depth", G_TYPE_INT, (s->bpp == 1) ? 8 : 15, + "width", G_TYPE_INT, s->width, + "height", G_TYPE_INT, s->height, + "framerate", GST_TYPE_FRACTION, rate_nom, rate_den, + "endianness", G_TYPE_INT, G_BYTE_ORDER, NULL); + if (s->bpp > 1) { + gst_caps_set_simple (s->caps, "red_mask", G_TYPE_INT, 0x7C00, /* 31744 */ + "green_mask", G_TYPE_INT, 0x03E0, /* 992 */ + "blue_mask", G_TYPE_INT, 0x001F, /* 31 */ + NULL); + } + + s->code_map = g_malloc ((s->width * s->height) / (8 * 8 * 2)); + + if (gst_mve_add_stream (mve, s, list)) + return gst_pad_push_event (s->pad, + gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, + 0, GST_CLOCK_TIME_NONE, 0)); + else + return GST_FLOW_OK; +} + +static void +gst_mve_end_chunk (GstMveDemux * mve) +{ + GST_LOG_OBJECT (mve, "end of chunk"); + + if (mve->video_stream != NULL) + mve->video_stream->code_map_avail = FALSE; +} + +/* parse segment */ +static GstFlowReturn +gst_mve_parse_segment (GstMveDemux * mve, GstMveDemuxStream ** stream, + GstBuffer ** send) +{ + GstFlowReturn ret = GST_FLOW_OK; + const guint8 *buffer, *data; + guint8 type, version; + guint16 len; + + buffer = gst_adapter_peek (mve->adapter, mve->needed_bytes); + + type = GST_MVE_SEGMENT_TYPE (buffer); + + /* check whether to handle the segment */ + if (type < 32) { + version = GST_MVE_SEGMENT_VERSION (buffer); + len = GST_MVE_SEGMENT_SIZE (buffer); + data = buffer + 4; + + switch (type) { + + case MVE_OC_END_OF_CHUNK: + gst_mve_end_chunk (mve); + break; + case MVE_OC_CREATE_TIMER: + ret = gst_mve_timer_create (mve, data, len, send); + *stream = mve->audio_stream; + break; + case MVE_OC_AUDIO_BUFFERS: + ret = gst_mve_audio_init (mve, version, data, len); + break; + case MVE_OC_VIDEO_BUFFERS: + ret = gst_mve_video_create_buffer (mve, version, data, len); + break; + case MVE_OC_AUDIO_DATA: + case MVE_OC_AUDIO_SILENCE: + ret = gst_mve_audio_data (mve, type, data, len, send); + *stream = mve->audio_stream; + break; + case MVE_OC_VIDEO_MODE: + ret = gst_mve_video_init (mve, data); + break; + case MVE_OC_PALETTE: + ret = gst_mve_video_palette (mve, data, len); + break; + case MVE_OC_PALETTE_COMPRESSED: + ret = gst_mve_video_palette_compressed (mve, data, len); + break; + case MVE_OC_CODE_MAP: + ret = gst_mve_video_code_map (mve, data, len); + break; + case MVE_OC_VIDEO_DATA: + ret = gst_mve_video_data (mve, data, len, send); + *stream = mve->video_stream; + break; + + case MVE_OC_END_OF_STREAM: + case MVE_OC_PLAY_AUDIO: + case MVE_OC_PLAY_VIDEO: + /* these are chunks we don't need to handle */ + GST_LOG_OBJECT (mve, "ignored segment type:0x%02x, version:0x%02x", + type, version); + break; + case 0x13: /* ??? */ + case 0x14: /* ??? */ + case 0x15: /* ??? */ + /* these are chunks we know exist but we don't care about */ + GST_DEBUG_OBJECT (mve, + "known but unhandled segment type:0x%02x, version:0x%02x", type, + version); + break; + default: + GST_WARNING_OBJECT (mve, + "unhandled segment type:0x%02x, version:0x%02x", type, version); + break; + } + } + + gst_adapter_flush (mve->adapter, mve->needed_bytes); + return ret; +} + +static GstFlowReturn +gst_mve_demux_chain (GstPad * sinkpad, GstBuffer * inbuf) +{ + GstMveDemux *mve = GST_MVE_DEMUX (GST_PAD_PARENT (sinkpad)); + GstFlowReturn ret = GST_FLOW_OK; + + gst_adapter_push (mve->adapter, inbuf); + + GST_DEBUG_OBJECT (mve, "queuing buffer, needed:%ld, available:%ld", + mve->needed_bytes, gst_adapter_available (mve->adapter)); + + while ((gst_adapter_available (mve->adapter) >= mve->needed_bytes) && + (ret == GST_FLOW_OK)) { + GstMveDemuxStream *stream = NULL; + GstBuffer *outbuf = NULL; + + switch (mve->state) { + case MVEDEMUX_STATE_INITIAL: + gst_adapter_flush (mve->adapter, mve->needed_bytes); + + mve->chunk_offset += mve->needed_bytes; + mve->needed_bytes = 4; + mve->state = MVEDEMUX_STATE_NEXT_CHUNK; + break; + + case MVEDEMUX_STATE_NEXT_CHUNK:{ + const guint8 *data; + guint16 size; + + data = gst_adapter_peek (mve->adapter, mve->needed_bytes); + size = GST_MVE_SEGMENT_SIZE (data); + + if (mve->chunk_offset >= mve->chunk_size) { + /* new chunk, flush buffer and proceed with next segment */ + guint16 chunk_type = GST_READ_UINT16_LE (data + 2); + + gst_adapter_flush (mve->adapter, mve->needed_bytes); + mve->chunk_size = size; + mve->chunk_offset = 0; + + if (chunk_type > MVE_CHUNK_END) { + GST_WARNING_OBJECT (mve, + "skipping unknown chunk type 0x%02x of size:%u", chunk_type, + size); + mve->needed_bytes += size; + mve->state = MVEDEMUX_STATE_SKIP; + } else { + GST_DEBUG_OBJECT (mve, "found new chunk type 0x%02x of size:%u", + chunk_type, size); + } + } else if (mve->chunk_offset <= mve->chunk_size) { + /* new segment */ + GST_DEBUG_OBJECT (mve, "found segment type 0x%02x of size:%u", + GST_MVE_SEGMENT_TYPE (data), size); + + mve->needed_bytes += size; + mve->state = MVEDEMUX_STATE_MOVIE; + } + } + break; + + case MVEDEMUX_STATE_MOVIE: + ret = gst_mve_parse_segment (mve, &stream, &outbuf); + + if ((ret == GST_FLOW_OK) && (outbuf != NULL)) { + /* send buffer */ + GST_DEBUG_OBJECT (mve, + "pushing buffer with time %" GST_TIME_FORMAT + " (%ld bytes) on pad %s", + GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)), + GST_BUFFER_SIZE (outbuf), GST_PAD_NAME (stream->pad)); + + ret = gst_pad_push (stream->pad, outbuf); + } + + if (!GST_FLOW_IS_FATAL (ret)) + ret = GST_FLOW_OK; + + /* update current offset */ + mve->chunk_offset += mve->needed_bytes; + + mve->state = MVEDEMUX_STATE_NEXT_CHUNK; + mve->needed_bytes = 4; + break; + + case MVEDEMUX_STATE_SKIP: + mve->chunk_offset += mve->needed_bytes; + gst_adapter_flush (mve->adapter, mve->needed_bytes); + mve->state = MVEDEMUX_STATE_NEXT_CHUNK; + mve->needed_bytes = 4; + break; + + default: + GST_ERROR_OBJECT (mve, "invalid state: %d", mve->state); + break; + } + } + + return ret; +} + +static void +gst_mve_demux_dispose (GObject * obj) +{ + GstMveDemux *mve = GST_MVE_DEMUX (obj); + + if (mve->adapter) { + g_object_unref (mve->adapter); + mve->adapter = NULL; + } + + G_OBJECT_CLASS (parent_class)->dispose (obj); +} + +static void +gst_mve_demux_base_init (GstMveDemuxClass * klass) +{ + static const GstElementDetails mve_demux_details = { + "MVE Demuxer", + "Codec/Demuxer", + "Demultiplex an Interplay movie (MVE) stream into audio and video", + "Jens Granseuer <jensgr@gmx.net>" + }; + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&vidsrc_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&audsrc_template)); + gst_element_class_set_details (element_class, &mve_demux_details); +} + +static void +gst_mve_demux_class_init (GstMveDemuxClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_mve_demux_dispose); + + element_class->change_state = GST_DEBUG_FUNCPTR (gst_mve_demux_change_state); +} + +static void +gst_mve_demux_init (GstMveDemux * mve) +{ + mve->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink"); + gst_pad_set_chain_function (mve->sinkpad, + GST_DEBUG_FUNCPTR (gst_mve_demux_chain)); + gst_element_add_pad (GST_ELEMENT (mve), mve->sinkpad); + + mve->adapter = gst_adapter_new (); + gst_mve_demux_reset (mve); +} + +GType +gst_mve_demux_get_type (void) +{ + static GType plugin_type = 0; + + if (!plugin_type) { + static const GTypeInfo plugin_info = { + sizeof (GstMveDemuxClass), + (GBaseInitFunc) gst_mve_demux_base_init, + NULL, + (GClassInitFunc) gst_mve_demux_class_init, + NULL, + NULL, + sizeof (GstMveDemux), + 0, + (GInstanceInitFunc) gst_mve_demux_init, + }; + + GST_DEBUG_CATEGORY_INIT (mvedemux_debug, "mvedemux", + 0, "Interplay MVE movie demuxer"); + + plugin_type = g_type_register_static (GST_TYPE_ELEMENT, + "GstMveDemux", &plugin_info, 0); + } + return plugin_type; +} diff --git a/gst/mve/gstmvedemux.h b/gst/mve/gstmvedemux.h new file mode 100644 index 00000000..533d0230 --- /dev/null +++ b/gst/mve/gstmvedemux.h @@ -0,0 +1,104 @@ +/* + * GStreamer demultiplexer plugin for Interplay MVE movie files + * + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#ifndef __GST_MVE_DEMUX_H__ +#define __GST_MVE_DEMUX_H__ + +#include <gst/gst.h> +#include <gst/base/gstadapter.h> + +G_BEGIN_DECLS + +#define GST_TYPE_MVE_DEMUX \ + (gst_mve_demux_get_type()) +#define GST_MVE_DEMUX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MVE_DEMUX,GstMveDemux)) +#define GST_MVE_DEMUX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MVE_DEMUX,GstMveDemuxClass)) +#define GST_IS_MVE_DEMUX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MVE_DEMUX)) +#define GST_IS_MVE_DEMUX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MVE_DEMUX)) + +typedef struct _GstMveDemux GstMveDemux; +typedef struct _GstMveDemuxClass GstMveDemuxClass; +typedef struct _GstMveDemuxStream GstMveDemuxStream; + +struct _GstMveDemux +{ + GstElement element; + + GstPad *sinkpad; + + GstMveDemuxStream *video_stream; + GstMveDemuxStream *audio_stream; + + gint state; + + /* time per frame (1/framerate) */ + GstClockTime frame_duration; + + /* push based variables */ + guint16 needed_bytes; + GstAdapter *adapter; + + /* size of current chunk */ + guint32 chunk_size; + /* offset in current chunk */ + guint32 chunk_offset; +}; + +struct _GstMveDemuxClass +{ + GstElementClass parent_class; +}; + +struct _GstMveDemuxStream { + /* shared properties */ + GstCaps *caps; + GstPad *pad; + GstClockTime last_ts; + gint64 offset; + + /* video properties */ + guint16 width; + guint16 height; + guint8 bpp; /* bytes per pixel */ + guint8 *code_map; + gboolean code_map_avail; + guint8 *back_buf1; + guint8 *back_buf2; + guint32 max_block_offset; + GstBuffer *palette; + GstBuffer *buffer; + + /* audio properties */ + guint16 sample_rate; + guint16 n_channels; + guint16 sample_size; + gboolean compression; +}; + +GType gst_mve_demux_get_type (void); + +G_END_DECLS + +#endif /* __GST_MVE_DEMUX_H__ */ diff --git a/gst/mve/gstmvemux.c b/gst/mve/gstmvemux.c new file mode 100644 index 00000000..d66833f1 --- /dev/null +++ b/gst/mve/gstmvemux.c @@ -0,0 +1,1493 @@ +/* Interplay MVE multiplexer plugin for GStreamer + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +/* +gst-launch-0.10 filesrc location=movie.mve ! mvedemux name=d ! + video/x-raw-rgb ! mvemux quick=true name=m ! + filesink location=test.mve d. ! audio/x-raw-int ! m. +*/ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdlib.h> +#include <string.h> + +#include <gst/gst.h> +#include "gstmvemux.h" +#include "mve.h" + +GST_DEBUG_CATEGORY_STATIC (mvemux_debug); +#define GST_CAT_DEFAULT mvemux_debug + +extern GstFlowReturn mve_encode_frame8 (GstMveMux * mve, + GstBuffer * frame, const guint32 * palette, guint16 max_data); +extern GstFlowReturn mve_encode_frame16 (GstMveMux * mve, + GstBuffer * frame, guint16 max_data); +extern gint mve_compress_audio (guint8 * dest, + const guint8 * src, guint16 len, guint8 channels); + +static const char mve_preamble[] = MVE_PREAMBLE; + +enum +{ + ARG_0, + ARG_AUDIO_COMPRESSION, + ARG_VIDEO_QUICK_ENCODING, + ARG_VIDEO_SCREEN_WIDTH, + ARG_VIDEO_SCREEN_HEIGHT +}; + +#define MVE_MUX_DEFAULT_COMPRESSION FALSE +#define MVE_MUX_DEFAULT_SCREEN_WIDTH 640 +#define MVE_MUX_DEFAULT_SCREEN_HEIGHT 480 + +enum MveMuxState +{ + MVE_MUX_STATE_INITIAL, /* initial state */ + MVE_MUX_STATE_CONNECTED, /* linked, caps set, header not written */ + MVE_MUX_STATE_PREBUFFER, /* prebuffering audio data */ + MVE_MUX_STATE_MOVIE, /* writing the movie */ + MVE_MUX_STATE_EOS +}; + +static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/x-mve") + ); + +static GstStaticPadTemplate video_sink_factory = + GST_STATIC_PAD_TEMPLATE ("video", + GST_PAD_SINK, + GST_PAD_REQUEST, + GST_STATIC_CAPS ("video/x-raw-rgb, " + "width = (int) [ 24, 1600 ], " + "height = (int) [ 24, 1200 ], " + "framerate = (fraction) [ 1, MAX ], " + "bpp = (int) 16, " + "depth = (int) 15, " + "endianness = (int) BYTE_ORDER, " + "red_mask = (int) 31744, " + "green_mask = (int) 992, " + "blue_mask = (int) 31; " + "video/x-raw-rgb, " + "bpp = (int) 8, " + "depth = (int) 8, " + "width = (int) [ 24, 1600 ], " + "height = (int) [ 24, 1200 ], " + "framerate = (fraction) [ 1, MAX ], " "endianness = (int) BYTE_ORDER")); + +static GstStaticPadTemplate audio_sink_factory = + GST_STATIC_PAD_TEMPLATE ("audio", + GST_PAD_SINK, + GST_PAD_REQUEST, + GST_STATIC_CAPS ("audio/x-raw-int, " + "width = (int) 8, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, 2 ], " + "depth = (int) 8, " + "signed = (boolean) false; " + "audio/x-raw-int, " + "width = (int) 16, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, 2 ], " + "depth = (int) 16, " + "signed = (boolean) true, " "endianness = (int) BYTE_ORDER")); + +static void gst_mve_mux_base_init (GstMveMuxClass * klass); +static void gst_mve_mux_class_init (GstMveMuxClass * klass); +static void gst_mve_mux_init (GstMveMux * mvemux); + +static GstElementClass *parent_class = NULL; + +static void +gst_mve_mux_reset (GstMveMux * mvemux) +{ + mvemux->state = MVE_MUX_STATE_INITIAL; + mvemux->stream_time = 0; + mvemux->stream_offset = 0; + mvemux->timer = 0; + + mvemux->frame_duration = GST_CLOCK_TIME_NONE; + mvemux->width = 0; + mvemux->height = 0; + mvemux->screen_width = MVE_MUX_DEFAULT_SCREEN_WIDTH; + mvemux->screen_height = MVE_MUX_DEFAULT_SCREEN_HEIGHT; + mvemux->bpp = 0; + mvemux->video_frames = 0; + mvemux->pal_changed = FALSE; + mvemux->pal_first_color = 0; + mvemux->pal_colors = MVE_PALETTE_COUNT; + mvemux->quick_encoding = TRUE; + + mvemux->bps = 0; + mvemux->rate = 0; + mvemux->channels = 0; + mvemux->compression = MVE_MUX_DEFAULT_COMPRESSION; + mvemux->next_ts = 0; + mvemux->max_ts = 0; + mvemux->spf = 0; + mvemux->lead_frames = 0; + mvemux->audio_frames = 0; + + mvemux->chunk_has_palette = FALSE; + mvemux->chunk_has_audio = FALSE; + + mvemux->audio_pad_eos = TRUE; + mvemux->video_pad_eos = TRUE; + + g_free (mvemux->chunk_code_map); + mvemux->chunk_code_map = NULL; + + if (mvemux->chunk_video != NULL) { + g_byte_array_free (mvemux->chunk_video, TRUE); + mvemux->chunk_video = NULL; + } + + if (mvemux->chunk_audio != NULL) { + g_byte_array_free (mvemux->chunk_audio, TRUE); + mvemux->chunk_audio = NULL; + } + + if (mvemux->last_frame != NULL) { + gst_buffer_unref (mvemux->last_frame); + mvemux->last_frame = NULL; + } + + if (mvemux->second_last_frame != NULL) { + gst_buffer_unref (mvemux->second_last_frame); + mvemux->second_last_frame = NULL; + } + + if (mvemux->audio_buffer != NULL) { + g_queue_foreach (mvemux->audio_buffer, (GFunc) gst_mini_object_unref, NULL); + g_queue_free (mvemux->audio_buffer); + } + mvemux->audio_buffer = g_queue_new (); + + if (mvemux->video_buffer != NULL) { + g_queue_foreach (mvemux->video_buffer, (GFunc) gst_mini_object_unref, NULL); + g_queue_free (mvemux->video_buffer); + } + mvemux->video_buffer = g_queue_new (); +} + +static void +gst_mve_mux_pad_link (GstPad * pad, GstPad * peer, gpointer data) +{ + GstMveMux *mvemux = GST_MVE_MUX (data); + + if (pad == mvemux->audiosink) { + mvemux->audio_pad_connected = TRUE; + } else if (pad == mvemux->videosink) { + mvemux->video_pad_connected = TRUE; + } else { + g_assert_not_reached (); + } + + GST_DEBUG_OBJECT (mvemux, "pad '%s' connected", GST_PAD_NAME (pad)); +} + +static void +gst_mve_mux_pad_unlink (GstPad * pad, GstPad * peer, gpointer data) +{ + GstMveMux *mvemux = GST_MVE_MUX (data); + + if (pad == mvemux->audiosink) { + mvemux->audio_pad_connected = FALSE; + } else if (pad == mvemux->videosink) { + mvemux->video_pad_connected = FALSE; + } else { + g_assert_not_reached (); + } + + GST_DEBUG_OBJECT (mvemux, "pad '%s' unlinked", GST_PAD_NAME (pad)); +} + +static void +gst_mve_mux_get_property (GObject * object, + guint prop_id, GValue * value, GParamSpec * pspec) +{ + GstMveMux *mvemux; + + g_return_if_fail (GST_IS_MVE_MUX (object)); + mvemux = GST_MVE_MUX (object); + + switch (prop_id) { + case ARG_AUDIO_COMPRESSION: + g_value_set_boolean (value, mvemux->compression); + break; + case ARG_VIDEO_QUICK_ENCODING: + g_value_set_boolean (value, mvemux->quick_encoding); + break; + case ARG_VIDEO_SCREEN_WIDTH: + g_value_set_uint (value, mvemux->screen_width); + break; + case ARG_VIDEO_SCREEN_HEIGHT: + g_value_set_uint (value, mvemux->screen_height); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_mve_mux_set_property (GObject * object, + guint prop_id, const GValue * value, GParamSpec * pspec) +{ + GstMveMux *mvemux; + + g_return_if_fail (GST_IS_MVE_MUX (object)); + mvemux = GST_MVE_MUX (object); + + switch (prop_id) { + case ARG_AUDIO_COMPRESSION: + mvemux->compression = g_value_get_boolean (value); + break; + case ARG_VIDEO_QUICK_ENCODING: + mvemux->quick_encoding = g_value_get_boolean (value); + break; + case ARG_VIDEO_SCREEN_WIDTH: + mvemux->screen_width = g_value_get_uint (value); + break; + case ARG_VIDEO_SCREEN_HEIGHT: + mvemux->screen_height = g_value_get_uint (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static GstStateChangeReturn +gst_mve_mux_change_state (GstElement * element, GstStateChange transition) +{ + GstMveMux *mvemux; + + g_return_val_if_fail (GST_IS_MVE_MUX (element), GST_STATE_CHANGE_FAILURE); + + mvemux = GST_MVE_MUX (element); + + if (GST_ELEMENT_CLASS (parent_class)->change_state) { + GstStateChangeReturn ret; + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + if (ret != GST_STATE_CHANGE_SUCCESS) + return ret; + } + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_mve_mux_reset (mvemux); + break; + default: + break; + } + + return GST_STATE_CHANGE_SUCCESS; +} + +static const GstBuffer * +gst_mve_mux_palette_from_buffer (GstBuffer * buf) +{ + const GstBuffer *palette = NULL; + GstCaps *caps = GST_BUFFER_CAPS (buf); + + if (caps != NULL) { + GstStructure *str = gst_caps_get_structure (caps, 0); + const GValue *pal = gst_structure_get_value (str, "palette_data"); + + if (pal != NULL) { + palette = gst_value_get_buffer (pal); + if (GST_BUFFER_SIZE (palette) < 256 * 4) + palette = NULL; + } + } + return palette; +} + +static GstFlowReturn +gst_mve_mux_palette_from_current_frame (GstMveMux * mvemux, + const GstBuffer ** pal) +{ + GstBuffer *buf = g_queue_peek_head (mvemux->video_buffer); + + /* get palette from buffer */ + *pal = gst_mve_mux_palette_from_buffer (buf); + if (*pal == NULL) { + GST_ERROR_OBJECT (mvemux, "video buffer has no palette data"); + return GST_FLOW_ERROR; + } + return GST_FLOW_OK; +} + +static void +gst_mve_mux_palette_analyze (GstMveMux * mvemux, const GstBuffer * pal, + guint16 * first, guint16 * last) +{ + guint i; + guint32 *col1; + + col1 = (guint32 *) GST_BUFFER_DATA (pal); + + /* compare current palette against last frame */ + if (mvemux->last_frame == NULL) { + /* ignore 0,0,0 entries but make sure we get + at least one color */ + /* FIXME: is ignoring 0,0,0 safe? possibly depends on player impl */ + for (i = 0; i < MVE_PALETTE_COUNT; ++i) { + if (col1[i] != 0) { + *first = i; + break; + } + } + if (i == MVE_PALETTE_COUNT) { + *first = *last = 0; + } else { + for (i = MVE_PALETTE_COUNT - 1; i >= 0; --i) { + if (col1[i] != 0) { + *last = i; + break; + } + } + } + } else { + const GstBuffer *last_pal; + guint32 *col2; + + last_pal = gst_mve_mux_palette_from_buffer (mvemux->last_frame); + + g_return_if_fail (last_pal != NULL); + + col2 = (guint32 *) GST_BUFFER_DATA (last_pal); + + for (i = 0; i < MVE_PALETTE_COUNT; ++i) { + if (col1[i] != col2[i]) { + *first = i; + break; + } + } + for (i = MVE_PALETTE_COUNT - 1; i >= 0; --i) { + if (col1[i] != col2[i]) { + *last = i; + break; + } + } + } + + GST_DEBUG_OBJECT (mvemux, "palette first:%d, last:%d", *first, *last); +} + +static gboolean +gst_mve_mux_palette_changed (GstMveMux * mvemux, const GstBuffer * pal) +{ + const GstBuffer *last_pal; + + g_return_val_if_fail (mvemux->last_frame != NULL, TRUE); + + last_pal = gst_mve_mux_palette_from_buffer (mvemux->last_frame); + if (last_pal == NULL) + return TRUE; + + return memcmp (GST_BUFFER_DATA (last_pal), GST_BUFFER_DATA (pal), + MVE_PALETTE_COUNT * 4) != 0; +} + +static GstFlowReturn +gst_mve_mux_push_buffer (GstMveMux * mvemux, GstBuffer * buffer) +{ + GST_BUFFER_OFFSET (buffer) = mvemux->stream_offset; + mvemux->stream_offset += GST_BUFFER_SIZE (buffer); + GST_BUFFER_OFFSET_END (buffer) = mvemux->stream_offset; + return gst_pad_push (mvemux->source, buffer); +} + +/* returns TRUE if audio segment is complete */ +static gboolean +gst_mve_mux_audio_data (GstMveMux * mvemux) +{ + gboolean complete = FALSE; + + while (!complete) { + GstBuffer *buf; + GstClockTime buftime; + GstClockTime duration; + GstClockTime t_needed; + gint b_needed; + gint len; + + buf = g_queue_peek_head (mvemux->audio_buffer); + if (buf == NULL) + return (mvemux->audio_pad_eos && mvemux->chunk_audio) || + (mvemux->stream_time + mvemux->frame_duration < mvemux->max_ts); + + buftime = GST_BUFFER_TIMESTAMP (buf); + duration = GST_BUFFER_DURATION (buf); + + /* FIXME: adjust buffer timestamps using segment info */ + + /* assume continuous buffers on invalid time stamps */ + if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (buftime))) + buftime = mvemux->next_ts; + + if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (duration))) + duration = gst_util_uint64_scale_int (mvemux->frame_duration, + GST_BUFFER_SIZE (buf), mvemux->spf); + + if (mvemux->chunk_audio) { + b_needed = mvemux->spf - mvemux->chunk_audio->len; + t_needed = (gint) gst_util_uint64_scale_int (mvemux->frame_duration, + b_needed, mvemux->spf); + } else { + b_needed = mvemux->spf; + t_needed = mvemux->frame_duration; + } + + if (buftime > mvemux->next_ts + t_needed) { + /* future buffer - fill chunk with silence */ + GST_DEBUG_OBJECT (mvemux, "future buffer, inserting silence"); + + /* if we already have a chunk started, fill it + otherwise we'll simply insert a silence chunk */ + if (mvemux->chunk_audio) { + len = mvemux->chunk_audio->len; + g_byte_array_set_size (mvemux->chunk_audio, mvemux->spf); + memset (mvemux->chunk_audio->data + len, 0, mvemux->spf - len); + } + mvemux->next_ts += t_needed; + complete = TRUE; + } else if (buftime + duration <= mvemux->next_ts) { + /* past buffer - drop */ + GST_DEBUG_OBJECT (mvemux, "dropping past buffer"); + g_queue_pop_head (mvemux->audio_buffer); + gst_buffer_unref (buf); + } else { + /* our data starts somewhere in this buffer */ + const guint8 *bufdata = GST_BUFFER_DATA (buf); + gint b_available = GST_BUFFER_SIZE (buf); + gint align = (mvemux->bps / 8) * mvemux->channels - 1; + gint offset; + + if (mvemux->chunk_audio == NULL) + mvemux->chunk_audio = g_byte_array_sized_new (mvemux->spf); + + if (buftime >= mvemux->next_ts) { + /* insert silence as necessary */ + len = mvemux->chunk_audio->len; + offset = (gint) gst_util_uint64_scale_int (mvemux->spf, + buftime - mvemux->next_ts, mvemux->frame_duration); + offset = (offset + align) & ~align; + + if (len < offset) { + g_byte_array_set_size (mvemux->chunk_audio, offset); + memset (mvemux->chunk_audio->data + len, 0, offset - len); + b_needed -= offset - len; + mvemux->next_ts += gst_util_uint64_scale_int (mvemux->frame_duration, + offset - len, mvemux->spf); + } + offset = 0; + } else { + offset = (gint) gst_util_uint64_scale_int (mvemux->spf, + mvemux->next_ts - buftime, mvemux->frame_duration); + offset = (offset + align) & ~align; + } + + g_assert (offset <= b_available); + + bufdata += offset; + b_available -= offset; + if (b_needed > b_available) + b_needed = b_available; + + if (mvemux->bps == 8) { + g_byte_array_append (mvemux->chunk_audio, bufdata, b_needed); + } else { + guint i; + gint16 *sample = (gint16 *) bufdata; + guint8 s[2]; + + len = b_needed / 2; + for (i = 0; i < len; ++i) { + s[0] = (*sample) & 0x00FF; + s[1] = ((*sample) & 0xFF00) >> 8; + g_byte_array_append (mvemux->chunk_audio, s, 2); + ++sample; + } + } + + mvemux->next_ts += gst_util_uint64_scale_int (mvemux->frame_duration, + b_needed, mvemux->spf); + + if (b_available - b_needed == 0) { + /* consumed buffer */ + GST_LOG_OBJECT (mvemux, "popping consumed buffer"); + g_queue_pop_head (mvemux->audio_buffer); + gst_buffer_unref (buf); + } + + complete = (mvemux->chunk_audio->len >= mvemux->spf); + } + + if (mvemux->max_ts < mvemux->next_ts) + mvemux->max_ts = mvemux->next_ts; + } + + return complete; +} + +static GstFlowReturn +gst_mve_mux_start_movie (GstMveMux * mvemux) +{ + GstFlowReturn res; + GstBuffer *buf; + + GST_DEBUG_OBJECT (mvemux, "writing movie preamble"); + + res = gst_pad_alloc_buffer (mvemux->source, 0, + MVE_PREAMBLE_SIZE, GST_PAD_CAPS (mvemux->source), &buf); + + if (res != GST_FLOW_OK) + return res; + + gst_pad_push_event (mvemux->source, + gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0)); + + memcpy (GST_BUFFER_DATA (buf), mve_preamble, MVE_PREAMBLE_SIZE); + return gst_mve_mux_push_buffer (mvemux, buf); +} + +static GstFlowReturn +gst_mve_mux_end_movie (GstMveMux * mvemux) +{ + GstFlowReturn res; + GstBuffer *buf; + guint8 *bufdata; + + GST_DEBUG_OBJECT (mvemux, "writing movie shutdown chunk"); + + res = gst_pad_alloc_buffer (mvemux->source, 0, 16, + GST_PAD_CAPS (mvemux->source), &buf); + + if (res != GST_FLOW_OK) + return res; + + bufdata = GST_BUFFER_DATA (buf); + + GST_WRITE_UINT16_LE (bufdata, 8); /* shutdown chunk */ + GST_WRITE_UINT16_LE (bufdata + 2, MVE_CHUNK_SHUTDOWN); + GST_WRITE_UINT16_LE (bufdata + 4, 0); /* end movie segment */ + bufdata[6] = MVE_OC_END_OF_STREAM; + bufdata[7] = 0; + GST_WRITE_UINT16_LE (bufdata + 8, 0); /* end chunk segment */ + bufdata[10] = MVE_OC_END_OF_CHUNK; + bufdata[11] = 0; + + GST_WRITE_UINT16_LE (bufdata + 12, 0); /* end movie chunk */ + GST_WRITE_UINT16_LE (bufdata + 14, MVE_CHUNK_END); + + return gst_mve_mux_push_buffer (mvemux, buf); +} + +static GstFlowReturn +gst_mve_mux_init_video_chunk (GstMveMux * mvemux, const GstBuffer * pal) +{ + GstFlowReturn res; + GstBuffer *buf; + guint8 *bufdata; + guint16 buf_size; + guint16 first_col = 0, last_col = 0; + guint pal_size = 0; + + GST_DEBUG_OBJECT (mvemux, "init-video chunk w:%d, h:%d, bpp:%d", + mvemux->width, mvemux->height, mvemux->bpp); + + buf_size = 4; /* chunk header */ + buf_size += 4 + 6; /* init video mode segment */ + buf_size += 4 + 8; /* create video buffers segment */ + + if (mvemux->bpp == 8) { + g_return_val_if_fail (pal != NULL, GST_FLOW_ERROR); + + /* install palette segment */ + gst_mve_mux_palette_analyze (mvemux, pal, &first_col, &last_col); + pal_size = (last_col - first_col + 1) * 3; + buf_size += 4 + 4 + pal_size; + } + + buf_size += 4 + 0; /* end chunk segment */ + + res = gst_pad_alloc_buffer (mvemux->source, 0, buf_size, + GST_PAD_CAPS (mvemux->source), &buf); + if (res != GST_FLOW_OK) + return res; + + bufdata = GST_BUFFER_DATA (buf); + + GST_WRITE_UINT16_LE (bufdata, buf_size - 4); + GST_WRITE_UINT16_LE (bufdata + 2, MVE_CHUNK_INIT_VIDEO); + + GST_WRITE_UINT16_LE (bufdata + 4, 6); + bufdata[6] = MVE_OC_VIDEO_MODE; + bufdata[7] = 0; + GST_WRITE_UINT16_LE (bufdata + 8, mvemux->screen_width); /* screen width */ + GST_WRITE_UINT16_LE (bufdata + 10, mvemux->screen_height); /* screen height */ + GST_WRITE_UINT16_LE (bufdata + 12, 0); /* ??? - flags */ + + GST_WRITE_UINT16_LE (bufdata + 14, 8); + bufdata[16] = MVE_OC_VIDEO_BUFFERS; + bufdata[17] = 2; + GST_WRITE_UINT16_LE (bufdata + 18, mvemux->width >> 3); /* buffer width */ + GST_WRITE_UINT16_LE (bufdata + 20, mvemux->height >> 3); /* buffer height */ + GST_WRITE_UINT16_LE (bufdata + 22, 1); /* buffer count */ + GST_WRITE_UINT16_LE (bufdata + 24, (mvemux->bpp >> 3) - 1); /* true color */ + + bufdata += 26; + + if (mvemux->bpp == 8) { + /* TODO: check whether we really need to update the entire palette (or at all) */ + gint i; + guint32 *col; + + GST_DEBUG_OBJECT (mvemux, "installing palette"); + + GST_WRITE_UINT16_LE (bufdata, 4 + pal_size); + bufdata[2] = MVE_OC_PALETTE; + bufdata[3] = 0; + GST_WRITE_UINT16_LE (bufdata + 4, first_col); /* first color index */ + GST_WRITE_UINT16_LE (bufdata + 6, last_col - first_col + 1); /* number of colors */ + + bufdata += 8; + col = (guint32 *) GST_BUFFER_DATA (pal); + for (i = first_col; i <= last_col; ++i) { + /* convert from 8-bit palette to 6-bit VGA */ + guint32 rgb = col[i]; + + (*bufdata) = ((rgb & 0x00FF0000) >> 16) >> 2; + ++bufdata; + (*bufdata) = ((rgb & 0x0000FF00) >> 8) >> 2; + ++bufdata; + (*bufdata) = (rgb & 0x000000FF) >> 2; + ++bufdata; + } + + mvemux->pal_changed = TRUE; + mvemux->pal_first_color = first_col; + mvemux->pal_colors = last_col - first_col + 1; + } + + GST_WRITE_UINT16_LE (bufdata, 0); + bufdata[2] = MVE_OC_END_OF_CHUNK; + bufdata[3] = 0; + + return gst_mve_mux_push_buffer (mvemux, buf); +} + +static GstFlowReturn +gst_mve_mux_init_audio_chunk (GstMveMux * mvemux) +{ + GstFlowReturn res; + GstBuffer *buf; + guint16 buf_size; + guint8 *bufdata; + guint16 flags = 0; + gint align; + + GST_DEBUG_OBJECT (mvemux, + "init-audio chunk rate:%d, chan:%d, bps:%d, comp:%d", mvemux->rate, + mvemux->channels, mvemux->bps, mvemux->compression); + + if (G_UNLIKELY (mvemux->bps == 8 && mvemux->compression)) { + GST_INFO_OBJECT (mvemux, + "compression only supported for 16-bit samples, disabling"); + mvemux->compression = FALSE; + } + + /* calculate sample data per frame */ + align = (mvemux->bps / 8) * mvemux->channels; + mvemux->spf = + (guint16) (gst_util_uint64_scale_int (align * mvemux->rate, + mvemux->frame_duration, GST_SECOND) + align - 1) & ~(align - 1); + + /* prebuffer approx. 1 second of audio data */ + mvemux->lead_frames = align * mvemux->rate / mvemux->spf; + GST_DEBUG_OBJECT (mvemux, "calculated spf:%d, lead frames:%d", + mvemux->spf, mvemux->lead_frames); + + /* chunk header + init video mode segment + end chunk segment */ + buf_size = 4 + (4 + 10) + 4; + + res = gst_pad_alloc_buffer (mvemux->source, 0, buf_size, + GST_PAD_CAPS (mvemux->source), &buf); + if (res != GST_FLOW_OK) + return res; + + bufdata = GST_BUFFER_DATA (buf); + + if (mvemux->channels == 2) + flags |= MVE_AUDIO_STEREO; + if (mvemux->bps == 16) + flags |= MVE_AUDIO_16BIT; + if (mvemux->compression) + flags |= MVE_AUDIO_COMPRESSED; + + GST_WRITE_UINT16_LE (bufdata, buf_size - 4); + GST_WRITE_UINT16_LE (bufdata + 2, MVE_CHUNK_INIT_AUDIO); + + GST_WRITE_UINT16_LE (bufdata + 4, 10); + bufdata[6] = MVE_OC_AUDIO_BUFFERS; + bufdata[7] = 1; + GST_WRITE_UINT16_LE (bufdata + 8, 0); /* ??? */ + GST_WRITE_UINT16_LE (bufdata + 10, flags); /* flags */ + GST_WRITE_UINT16_LE (bufdata + 12, mvemux->rate); /* sample rate */ + GST_WRITE_UINT32_LE (bufdata + 14, /* minimum audio buffer size */ + mvemux->spf * mvemux->lead_frames); + + GST_WRITE_UINT16_LE (bufdata + 18, 0); + bufdata[20] = MVE_OC_END_OF_CHUNK; + bufdata[21] = 0; + + return gst_mve_mux_push_buffer (mvemux, buf); +} + +static guint8 * +gst_mve_mux_write_audio_segments (GstMveMux * mvemux, guint8 * data) +{ + GByteArray *chunk = mvemux->chunk_audio; + guint16 silent_mask; + + GST_LOG_OBJECT (mvemux, "writing audio data"); + + /* audio data */ + if (chunk) { + guint16 len = mvemux->compression ? + chunk->len / 2 + mvemux->channels : chunk->len; + + silent_mask = 0xFFFE; + + GST_WRITE_UINT16_LE (data, 6 + len); + data[2] = MVE_OC_AUDIO_DATA; + data[3] = 0; + GST_WRITE_UINT16_LE (data + 4, mvemux->audio_frames); /* frame number */ + GST_WRITE_UINT16_LE (data + 6, 0x0001); /* stream mask */ + GST_WRITE_UINT16_LE (data + 8, chunk->len); /* (uncompressed) data length */ + data += 10; + + if (mvemux->compression) + mve_compress_audio (data, chunk->data, len, mvemux->channels); + else + memcpy (data, chunk->data, chunk->len); + data += len; + + g_byte_array_free (chunk, TRUE); + mvemux->chunk_audio = NULL; + } else + silent_mask = 0xFFFF; + + /* audio data (silent) */ + GST_WRITE_UINT16_LE (data, 6); + data[2] = MVE_OC_AUDIO_SILENCE; + data[3] = 0; + GST_WRITE_UINT16_LE (data + 4, mvemux->audio_frames++); /* frame number */ + GST_WRITE_UINT16_LE (data + 6, silent_mask); /* stream mask */ + GST_WRITE_UINT16_LE (data + 8, mvemux->spf); /* (imaginary) data length */ + data += 10; + + return data; +} + +static GstFlowReturn +gst_mve_mux_prebuffer_audio_chunk (GstMveMux * mvemux) +{ + GstFlowReturn ret; + GstBuffer *chunk; + guint16 size; + guint8 *data; + + /* calculate chunk size */ + size = 4; /* chunk header */ + + if (mvemux->chunk_audio) { + size += 4 + 6 + /* audio data */ + (mvemux->compression ? + mvemux->chunk_audio->len / 2 + mvemux->channels : + mvemux->chunk_audio->len); + } + size += 4 + 6; /* audio data silent */ + size += 4; /* end chunk */ + + ret = gst_pad_alloc_buffer (mvemux->source, 0, size, + GST_PAD_CAPS (mvemux->source), &chunk); + if (ret != GST_FLOW_OK) + return ret; + + data = GST_BUFFER_DATA (chunk); + + /* assemble chunk */ + GST_WRITE_UINT16_LE (data, size - 4); + GST_WRITE_UINT16_LE (data + 2, MVE_CHUNK_AUDIO_ONLY); + data += 4; + + data = gst_mve_mux_write_audio_segments (mvemux, data); + + /* end chunk */ + GST_WRITE_UINT16_LE (data, 0); + data[2] = MVE_OC_END_OF_CHUNK; + data[3] = 0; + + if (mvemux->audio_frames >= mvemux->lead_frames) + mvemux->state = MVE_MUX_STATE_MOVIE; + + mvemux->stream_time += mvemux->frame_duration; + + GST_DEBUG_OBJECT (mvemux, "pushing audio chunk"); + + return gst_mve_mux_push_buffer (mvemux, chunk); +} + +static GstFlowReturn +gst_mve_mux_push_chunk (GstMveMux * mvemux) +{ + GstFlowReturn ret; + GstBuffer *chunk; + GstBuffer *frame; + guint32 size; + guint16 cm_size = 0; + guint8 *data; + + /* calculate chunk size */ + size = 4; /* chunk header */ + + if (G_UNLIKELY (mvemux->timer == 0)) { + /* we need to insert a timer segment */ + size += 4 + 6; + } + + if (mvemux->audio_pad_connected) { + if (mvemux->chunk_audio) { + size += 4 + 6 + /* audio data */ + (mvemux->compression ? + mvemux->chunk_audio->len / 2 + mvemux->channels : + mvemux->chunk_audio->len); + } + size += 4 + 6; /* audio data silent */ + } + + size += 4 + 6; /* play video */ + size += 4; /* play audio; present even if no audio stream */ + size += 4; /* end chunk */ + + /* we must encode video only after we have the audio side + covered, since only then we can tell what size limit + the video data must adhere to */ + frame = g_queue_pop_head (mvemux->video_buffer); + if (frame != NULL) { + cm_size = (((mvemux->width * mvemux->height) >> 6) + 1) >> 1; + size += 4 + cm_size; /* code map */ + size += 4 + 14; /* video data header */ + + /* make sure frame is writable since the encoder may want to modify it */ + frame = gst_buffer_make_writable (frame); + + if (mvemux->bpp == 8) { + const GstBuffer *pal = gst_mve_mux_palette_from_buffer (frame); + + if (pal == NULL) + ret = GST_FLOW_ERROR; + else + ret = mve_encode_frame8 (mvemux, frame, + (guint32 *) GST_BUFFER_DATA (pal), G_MAXUINT16 - size); + } else + ret = mve_encode_frame16 (mvemux, frame, G_MAXUINT16 - size); + + if (mvemux->second_last_frame != NULL) + gst_buffer_unref (mvemux->second_last_frame); + mvemux->second_last_frame = mvemux->last_frame; + mvemux->last_frame = frame; + + if (ret != GST_FLOW_OK) + return ret; + + size += mvemux->chunk_video->len; + } + + if (size > G_MAXUINT16) { + GST_ELEMENT_ERROR (mvemux, STREAM, ENCODE, (NULL), + ("encoding frame %d failed: maximum block size exceeded (%lu)", + mvemux->video_frames + 1, size)); + return GST_FLOW_ERROR; + } + + ret = gst_pad_alloc_buffer (mvemux->source, 0, size, + GST_PAD_CAPS (mvemux->source), &chunk); + if (ret != GST_FLOW_OK) + return ret; + + data = GST_BUFFER_DATA (chunk); + + /* assemble chunk */ + GST_WRITE_UINT16_LE (data, size - 4); + GST_WRITE_UINT16_LE (data + 2, MVE_CHUNK_VIDEO); + data += 4; + + if (G_UNLIKELY (mvemux->timer == 0)) { + /* insert a timer segment */ + mvemux->timer = mvemux->frame_duration / GST_USECOND / 8; + + GST_WRITE_UINT16_LE (data, 6); + data[2] = MVE_OC_CREATE_TIMER; + data[3] = 0; + GST_WRITE_UINT32_LE (data + 4, mvemux->timer); /* timer rate */ + GST_WRITE_UINT16_LE (data + 8, 8); /* timer subdivision */ + data += 10; + } + + /* code map */ + if (mvemux->chunk_video) { + GST_WRITE_UINT16_LE (data, cm_size); + data[2] = MVE_OC_CODE_MAP; + data[3] = 0; + memcpy (data + 4, mvemux->chunk_code_map, cm_size); + data += 4 + cm_size; + } + + if (mvemux->audio_pad_connected) + data = gst_mve_mux_write_audio_segments (mvemux, data); + + if (mvemux->chunk_video) { + GST_LOG_OBJECT (mvemux, "writing video data"); + + /* video data */ + GST_WRITE_UINT16_LE (data, 14 + mvemux->chunk_video->len); + data[2] = MVE_OC_VIDEO_DATA; + data[3] = 0; + GST_WRITE_UINT16_LE (data + 6, mvemux->video_frames); /* previous frame */ + GST_WRITE_UINT16_LE (data + 4, ++mvemux->video_frames); /* current frame */ + GST_WRITE_UINT16_LE (data + 8, 0); /* x offset */ + GST_WRITE_UINT16_LE (data + 10, 0); /* y offset */ + GST_WRITE_UINT16_LE (data + 12, mvemux->width >> 3); /* buffer width */ + GST_WRITE_UINT16_LE (data + 14, mvemux->height >> 3); /* buffer height */ + GST_WRITE_UINT16_LE (data + 16, /* flags */ + (mvemux->video_frames == 1 ? 0 : MVE_VIDEO_DELTA_FRAME)); + memcpy (data + 18, mvemux->chunk_video->data, mvemux->chunk_video->len); + data += 18 + mvemux->chunk_video->len; + + g_byte_array_free (mvemux->chunk_video, TRUE); + mvemux->chunk_video = NULL; + } + + /* play audio */ + GST_WRITE_UINT16_LE (data, 0); + data[2] = MVE_OC_PLAY_AUDIO; + data[3] = 0; + data += 4; + + /* play video */ + GST_WRITE_UINT16_LE (data, 6); + data[2] = MVE_OC_PLAY_VIDEO; + data[3] = 1; + /* this block is only set to non-zero on palette changes in 8-bit mode */ + if (mvemux->pal_changed) { + GST_WRITE_UINT16_LE (data + 4, mvemux->pal_first_color); /* index of first color */ + GST_WRITE_UINT16_LE (data + 6, mvemux->pal_colors); /* number of colors */ + mvemux->pal_changed = FALSE; + } else { + GST_WRITE_UINT32_LE (data + 4, 0); + } + GST_WRITE_UINT16_LE (data + 8, 0); /* ??? */ + data += 10; + + /* end chunk */ + GST_WRITE_UINT16_LE (data, 0); + data[2] = MVE_OC_END_OF_CHUNK; + data[3] = 0; + + mvemux->chunk_has_palette = FALSE; + mvemux->chunk_has_audio = FALSE; + mvemux->stream_time += mvemux->frame_duration; + + GST_LOG_OBJECT (mvemux, "pushing video chunk"); + + return gst_mve_mux_push_buffer (mvemux, chunk); +} + +static GstFlowReturn +gst_mve_mux_chain (GstPad * sinkpad, GstBuffer * inbuf) +{ + GstMveMux *mvemux = GST_MVE_MUX (GST_PAD_PARENT (sinkpad)); + GstFlowReturn ret = GST_FLOW_OK; + const GstBuffer *palette; + gboolean audio_ok, video_ok; + + /* need to serialize the buffers */ + g_mutex_lock (mvemux->lock); + + if (G_LIKELY (inbuf != NULL)) { /* TODO: see _sink_event... */ + if (sinkpad == mvemux->audiosink) + g_queue_push_tail (mvemux->audio_buffer, inbuf); + else if (sinkpad == mvemux->videosink) + g_queue_push_tail (mvemux->video_buffer, inbuf); + else + g_assert_not_reached (); + } + + /* TODO: this is gross... */ + if (G_UNLIKELY (mvemux->state == MVE_MUX_STATE_INITIAL)) { + GST_DEBUG_OBJECT (mvemux, "waiting for caps"); + goto done; + } + + /* now actually try to mux something */ + if (G_UNLIKELY (mvemux->state == MVE_MUX_STATE_CONNECTED)) { + palette = NULL; + + if (mvemux->bpp == 8) { + /* we need to add palette info to the init chunk */ + if (g_queue_is_empty (mvemux->video_buffer)) + goto done; /* wait for more data */ + + ret = gst_mve_mux_palette_from_current_frame (mvemux, &palette); + if (ret != GST_FLOW_OK) + goto done; + } + + gst_mve_mux_start_movie (mvemux); + gst_mve_mux_init_video_chunk (mvemux, palette); + mvemux->chunk_has_palette = TRUE; + + if (mvemux->audio_pad_connected) { + gst_mve_mux_init_audio_chunk (mvemux); + + mvemux->state = MVE_MUX_STATE_PREBUFFER; + } else + mvemux->state = MVE_MUX_STATE_MOVIE; + } + + while ((mvemux->state == MVE_MUX_STATE_PREBUFFER) && (ret == GST_FLOW_OK) && + gst_mve_mux_audio_data (mvemux)) { + ret = gst_mve_mux_prebuffer_audio_chunk (mvemux); + } + + if (G_LIKELY (mvemux->state >= MVE_MUX_STATE_MOVIE)) { + audio_ok = !mvemux->audio_pad_connected || + !g_queue_is_empty (mvemux->audio_buffer) || + (mvemux->audio_pad_eos && (mvemux->stream_time <= mvemux->max_ts)); + video_ok = !g_queue_is_empty (mvemux->video_buffer) || + (mvemux->video_pad_eos && + (!mvemux->audio_pad_eos || (mvemux->stream_time <= mvemux->max_ts))); + + while ((ret == GST_FLOW_OK) && audio_ok && video_ok) { + + if (!g_queue_is_empty (mvemux->video_buffer)) { + if ((mvemux->bpp == 8) && !mvemux->chunk_has_palette) { + ret = gst_mve_mux_palette_from_current_frame (mvemux, &palette); + if (ret != GST_FLOW_OK) + goto done; + + if (gst_mve_mux_palette_changed (mvemux, palette)) + gst_mve_mux_init_video_chunk (mvemux, palette); + mvemux->chunk_has_palette = TRUE; + } + } + + /* audio data */ + if (mvemux->audio_pad_connected && !mvemux->chunk_has_audio && + gst_mve_mux_audio_data (mvemux)) + mvemux->chunk_has_audio = TRUE; + + if ((!g_queue_is_empty (mvemux->video_buffer) || mvemux->video_pad_eos) && + (mvemux->chunk_has_audio || !mvemux->audio_pad_connected + || mvemux->audio_pad_eos)) { + ret = gst_mve_mux_push_chunk (mvemux); + } + + audio_ok = !mvemux->audio_pad_connected || + !g_queue_is_empty (mvemux->audio_buffer) || + (mvemux->audio_pad_eos && (mvemux->stream_time <= mvemux->max_ts)); + video_ok = !g_queue_is_empty (mvemux->video_buffer) || + (mvemux->video_pad_eos && + (!mvemux->audio_pad_eos || (mvemux->stream_time <= mvemux->max_ts))); + } + } + + if (G_UNLIKELY ((mvemux->state == MVE_MUX_STATE_EOS) && (ret == GST_FLOW_OK))) { + ret = gst_mve_mux_end_movie (mvemux); + gst_pad_push_event (mvemux->source, gst_event_new_eos ()); + } + +done: + g_mutex_unlock (mvemux->lock); + return ret; +} + +static gboolean +gst_mve_mux_sink_event (GstPad * pad, GstEvent * event) +{ + gboolean res = TRUE; + GstMveMux *mvemux = GST_MVE_MUX (GST_PAD_PARENT (pad)); + + GST_DEBUG_OBJECT (mvemux, "got %s event for pad %s", + GST_EVENT_TYPE_NAME (event), GST_PAD_NAME (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS: + if (pad == mvemux->audiosink) { + mvemux->audio_pad_eos = TRUE; + + if (mvemux->state == MVE_MUX_STATE_PREBUFFER) + mvemux->state = MVE_MUX_STATE_MOVIE; + } else if (pad == mvemux->videosink) + mvemux->video_pad_eos = TRUE; + + /* TODO: this is evil */ + if (mvemux->audio_pad_eos && mvemux->video_pad_eos) { + mvemux->state = MVE_MUX_STATE_EOS; + gst_mve_mux_chain (pad, NULL); + } + gst_event_unref (event); + break; + case GST_EVENT_NEWSEGMENT: + if (pad == mvemux->audiosink) { + GstFormat format; + gint64 start; + gboolean update; + + gst_event_parse_new_segment (event, &update, NULL, &format, &start, + NULL, NULL); + if ((format == GST_FORMAT_TIME) && update && (start > mvemux->max_ts)) + mvemux->max_ts = start; + } + gst_event_unref (event); + break; + default: + res = gst_pad_event_default (pad, event); + break; + } + + return res; +} + +static gboolean +gst_mve_mux_vidsink_set_caps (GstPad * pad, GstCaps * vscaps) +{ + GstMveMux *mvemux; + GstStructure *structure; + GstClockTime duration; + const GValue *fps; + gint w, h, bpp; + gboolean ret; + + mvemux = GST_MVE_MUX (GST_PAD_PARENT (pad)); + + GST_DEBUG_OBJECT (mvemux, "video set_caps triggered on %s", + GST_PAD_NAME (pad)); + + structure = gst_caps_get_structure (vscaps, 0); + + ret = gst_structure_get_int (structure, "width", &w); + ret &= gst_structure_get_int (structure, "height", &h); + ret &= gst_structure_get_int (structure, "bpp", &bpp); + fps = gst_structure_get_value (structure, "framerate"); + ret &= (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)); + + duration = gst_util_uint64_scale_int (GST_SECOND, + gst_value_get_fraction_denominator (fps), + gst_value_get_fraction_numerator (fps)); + + if (!ret) + return FALSE; + + /* don't allow changing width, height, bpp, or framerate */ + if (mvemux->state != MVE_MUX_STATE_INITIAL) { + if (mvemux->width != w || mvemux->height != h || + mvemux->bpp != bpp || mvemux->frame_duration != duration) { + GST_ERROR_OBJECT (mvemux, "caps renegotiation not allowed"); + return FALSE; + } + } else { + if (w % 8 != 0 || h % 8 != 0) { + GST_ERROR_OBJECT (mvemux, "width and height must be multiples of 8"); + return FALSE; + } + + mvemux->width = w; + mvemux->height = h; + mvemux->bpp = bpp; + mvemux->frame_duration = duration; + + if (mvemux->screen_width < w) { + GST_INFO_OBJECT (mvemux, "setting suggested screen width to %d", w); + mvemux->screen_width = w; + } + if (mvemux->screen_height < h) { + GST_INFO_OBJECT (mvemux, "setting suggested screen height to %d", h); + mvemux->screen_height = h; + } + + g_free (mvemux->chunk_code_map); + mvemux->chunk_code_map = g_malloc ((((w * h) >> 6) + 1) >> 1); + + /* audio caps already initialized? */ + if (mvemux->bps != 0 || !mvemux->audio_pad_connected) + mvemux->state = MVE_MUX_STATE_CONNECTED; + } + + return TRUE; +} + +static gboolean +gst_mve_mux_audsink_set_caps (GstPad * pad, GstCaps * ascaps) +{ + GstMveMux *mvemux; + GstStructure *structure; + gboolean ret; + gint val; + + mvemux = GST_MVE_MUX (GST_PAD_PARENT (pad)); + + GST_DEBUG_OBJECT (mvemux, "audio set_caps triggered on %s", + GST_PAD_NAME (pad)); + + /* don't allow caps renegotiation for now */ + if (mvemux->state != MVE_MUX_STATE_INITIAL) + return FALSE; + + structure = gst_caps_get_structure (ascaps, 0); + + ret = gst_structure_get_int (structure, "channels", &val); + mvemux->channels = val; + ret &= gst_structure_get_int (structure, "rate", &val); + mvemux->rate = val; + ret &= gst_structure_get_int (structure, "width", &val); + mvemux->bps = val; + + /* video caps already initialized? */ + if (mvemux->bpp != 0) + mvemux->state = MVE_MUX_STATE_CONNECTED; + + return ret; +} + +static GstPad * +gst_mve_mux_request_new_pad (GstElement * element, + GstPadTemplate * templ, const gchar * req_name) +{ + GstMveMux *mvemux = GST_MVE_MUX (element); + GstElementClass *klass = GST_ELEMENT_GET_CLASS (element); + GstPad *pad; + + g_return_val_if_fail (templ != NULL, NULL); + + if (templ->direction != GST_PAD_SINK) { + GST_WARNING_OBJECT (mvemux, "request pad is not a SINK pad"); + return NULL; + } + + if (templ == gst_element_class_get_pad_template (klass, "audio")) { + if (mvemux->audiosink) + return NULL; + + mvemux->audiosink = gst_pad_new_from_template (templ, "audio"); + gst_pad_set_setcaps_function (mvemux->audiosink, + GST_DEBUG_FUNCPTR (gst_mve_mux_audsink_set_caps)); + mvemux->audio_pad_eos = FALSE; + pad = mvemux->audiosink; + } else if (templ == gst_element_class_get_pad_template (klass, "video")) { + if (mvemux->videosink) + return NULL; + + mvemux->videosink = gst_pad_new_from_template (templ, "video"); + gst_pad_set_setcaps_function (mvemux->videosink, + GST_DEBUG_FUNCPTR (gst_mve_mux_vidsink_set_caps)); + mvemux->video_pad_eos = FALSE; + pad = mvemux->videosink; + } else { + g_assert_not_reached (); + } + + gst_pad_set_chain_function (pad, GST_DEBUG_FUNCPTR (gst_mve_mux_chain)); + gst_pad_set_event_function (pad, GST_DEBUG_FUNCPTR (gst_mve_mux_sink_event)); + + g_signal_connect (pad, "linked", G_CALLBACK (gst_mve_mux_pad_link), mvemux); + g_signal_connect (pad, "unlinked", G_CALLBACK (gst_mve_mux_pad_unlink), + mvemux); + + gst_element_add_pad (element, pad); + return pad; +} + +static void +gst_mve_mux_release_pad (GstElement * element, GstPad * pad) +{ + GstMveMux *mvemux = GST_MVE_MUX (element); + + gst_element_remove_pad (element, pad); + + if (pad == mvemux->audiosink) { + mvemux->audiosink = NULL; + mvemux->audio_pad_connected = FALSE; + } else if (pad == mvemux->videosink) { + mvemux->videosink = NULL; + mvemux->video_pad_connected = FALSE; + } +} + +static void +gst_mve_mux_base_init (GstMveMuxClass * klass) +{ + static const GstElementDetails gst_mve_mux_details = + GST_ELEMENT_DETAILS ("MVE Multiplexer", + "Codec/Muxer", + "Muxes audio and video into an MVE stream", + "Jens Granseuer <jensgr@gmx.net>"); + + 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_details (element_class, &gst_mve_mux_details); +} + +static void +gst_mve_mux_finalize (GObject * object) +{ + GstMveMux *mvemux = GST_MVE_MUX (object); + + if (mvemux->lock) { + g_mutex_free (mvemux->lock); + mvemux->lock = NULL; + } + + if (mvemux->audio_buffer) { + g_queue_free (mvemux->audio_buffer); + mvemux->audio_buffer = NULL; + } + + if (mvemux->video_buffer) { + g_queue_free (mvemux->video_buffer); + mvemux->video_buffer = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gst_mve_mux_class_init (GstMveMuxClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = G_OBJECT_CLASS (klass); + gstelement_class = GST_ELEMENT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->finalize = gst_mve_mux_finalize; + + gobject_class->get_property = gst_mve_mux_get_property; + gobject_class->set_property = gst_mve_mux_set_property; + + g_object_class_install_property (gobject_class, ARG_AUDIO_COMPRESSION, + g_param_spec_boolean ("compression", "Audio compression", + "Whether to compress audio data", MVE_MUX_DEFAULT_COMPRESSION, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, ARG_VIDEO_QUICK_ENCODING, + g_param_spec_boolean ("quick", "Quick encoding", + "Whether to disable expensive encoding operations", TRUE, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, ARG_VIDEO_SCREEN_WIDTH, + g_param_spec_uint ("screen-width", "Screen width", + "Suggested screen width", 320, 1600, + MVE_MUX_DEFAULT_SCREEN_WIDTH, G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, ARG_VIDEO_SCREEN_HEIGHT, + g_param_spec_uint ("screen-height", "Screen height", + "Suggested screen height", 200, 1200, + MVE_MUX_DEFAULT_SCREEN_HEIGHT, G_PARAM_READWRITE)); + + gstelement_class->request_new_pad = gst_mve_mux_request_new_pad; + gstelement_class->release_pad = gst_mve_mux_release_pad; + + gstelement_class->change_state = gst_mve_mux_change_state; +} + +static void +gst_mve_mux_init (GstMveMux * mvemux) +{ + GstElementClass *klass = GST_ELEMENT_GET_CLASS (mvemux); + + mvemux->source = + gst_pad_new_from_template (gst_element_class_get_pad_template (klass, + "src"), "src"); + gst_element_add_pad (GST_ELEMENT (mvemux), mvemux->source); + + mvemux->lock = g_mutex_new (); + + mvemux->audiosink = NULL; + mvemux->videosink = NULL; + mvemux->audio_pad_connected = FALSE; + mvemux->video_pad_connected = FALSE; + + /* audio/video metadata initialisation */ + mvemux->last_frame = NULL; + mvemux->second_last_frame = NULL; + mvemux->chunk_code_map = NULL; + mvemux->chunk_video = NULL; + mvemux->chunk_audio = NULL; + mvemux->audio_buffer = NULL; + mvemux->video_buffer = NULL; + + gst_mve_mux_reset (mvemux); +} + +GType +gst_mve_mux_get_type (void) +{ + static GType mvemux_type = 0; + + if (!mvemux_type) { + static const GTypeInfo mvemux_info = { + sizeof (GstMveMuxClass), + (GBaseInitFunc) gst_mve_mux_base_init, + NULL, + (GClassInitFunc) gst_mve_mux_class_init, + NULL, + NULL, + sizeof (GstMveMux), + 0, + (GInstanceInitFunc) gst_mve_mux_init, + }; + + GST_DEBUG_CATEGORY_INIT (mvemux_debug, "mvemux", + 0, "Interplay MVE movie muxer"); + + mvemux_type = + g_type_register_static (GST_TYPE_ELEMENT, "GstMveMux", &mvemux_info, 0); + } + return mvemux_type; +} diff --git a/gst/mve/gstmvemux.h b/gst/mve/gstmvemux.h new file mode 100644 index 00000000..319b2ae4 --- /dev/null +++ b/gst/mve/gstmvemux.h @@ -0,0 +1,120 @@ +/* + * Interplay MVE muxer plugin for GStreamer + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#ifndef __GST_MVE_MUX_H__ +#define __GST_MVE_MUX_H__ + +#include <gst/gst.h> + +G_BEGIN_DECLS + +#define GST_TYPE_MVE_MUX \ + (gst_mve_mux_get_type()) +#define GST_MVE_MUX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MVE_MUX,GstMveMux)) +#define GST_MVE_MUX_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MVE_MUX,GstMveMux)) +#define GST_IS_MVE_MUX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MVE_MUX)) +#define GST_IS_MVE_MUX_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MVE_MUX)) + + +typedef struct _GstMveMux GstMveMux; +typedef struct _GstMveMuxClass GstMveMuxClass; + +struct _GstMveMux { + GstElement element; + GMutex *lock; + + /* pads */ + GstPad *source; + GstPad *videosink; + GstPad *audiosink; + + gboolean audio_pad_connected; + gboolean audio_pad_eos; + gboolean video_pad_connected; + gboolean video_pad_eos; + + guint64 stream_offset; + /* audio stream time, really */ + GstClockTime stream_time; + guint timer; + gint state; + + /* ticks per frame */ + GstClockTime frame_duration; + + /* video stream properties */ + guint16 width, height; + guint16 screen_width, screen_height; + /* bits per pixel */ + guint8 bpp; + /* previous frames */ + GstBuffer *last_frame; + GstBuffer *second_last_frame; + /* number of encoded frames */ + guint16 video_frames; + /* palette handling */ + gboolean pal_changed; + guint16 pal_first_color; + guint16 pal_colors; + /* whether to use expensive opcodes */ + gboolean quick_encoding; + + /* audio stream properties */ + /* bits per sample */ + guint8 bps; + guint32 rate; + guint8 channels; + gboolean compression; + /* current audio stream time */ + GstClockTime next_ts; + /* maximum audio time we know about */ + GstClockTime max_ts; + /* sample bytes per frame */ + guint16 spf; + /* number of frames to use for audio lead-in */ + guint16 lead_frames; + /* number of encoded frames */ + guint16 audio_frames; + + /* current chunk */ + guint8 *chunk_code_map; + GByteArray *chunk_video; + GByteArray *chunk_audio; + gboolean chunk_has_palette; + gboolean chunk_has_audio; + + /* buffers for incoming data */ + GQueue *audio_buffer; + GQueue *video_buffer; +}; + +struct _GstMveMuxClass { + GstElementClass parent_class; +}; + +GType gst_mve_mux_get_type (void); + +G_END_DECLS + +#endif /* __GST_MVE_MUX_H__ */ diff --git a/gst/mve/mve.h b/gst/mve/mve.h new file mode 100644 index 00000000..782289e4 --- /dev/null +++ b/gst/mve/mve.h @@ -0,0 +1,62 @@ +/* + * Interplay MVE movie definitions + * + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#ifndef __MVE_H__ +#define __MVE_H__ + +#define MVE_PREAMBLE "Interplay MVE File\032\000\032\000\000\001\063\021" +#define MVE_PREAMBLE_SIZE 26 + +#define MVE_PALETTE_COUNT 256 + +/* MVE chunk types */ +#define MVE_CHUNK_INIT_AUDIO 0x0000 +#define MVE_CHUNK_AUDIO_ONLY 0x0001 +#define MVE_CHUNK_INIT_VIDEO 0x0002 +#define MVE_CHUNK_VIDEO 0x0003 +#define MVE_CHUNK_SHUTDOWN 0x0004 +#define MVE_CHUNK_END 0x0005 + +/* MVE segment opcodes */ +#define MVE_OC_END_OF_STREAM 0x00 +#define MVE_OC_END_OF_CHUNK 0x01 +#define MVE_OC_CREATE_TIMER 0x02 +#define MVE_OC_AUDIO_BUFFERS 0x03 +#define MVE_OC_PLAY_AUDIO 0x04 +#define MVE_OC_VIDEO_BUFFERS 0x05 +#define MVE_OC_PLAY_VIDEO 0x07 +#define MVE_OC_AUDIO_DATA 0x08 +#define MVE_OC_AUDIO_SILENCE 0x09 +#define MVE_OC_VIDEO_MODE 0x0A +#define MVE_OC_PALETTE 0x0C +#define MVE_OC_PALETTE_COMPRESSED 0x0D +#define MVE_OC_CODE_MAP 0x0F +#define MVE_OC_VIDEO_DATA 0x11 + +/* audio flags */ +#define MVE_AUDIO_STEREO 0x0001 +#define MVE_AUDIO_16BIT 0x0002 +#define MVE_AUDIO_COMPRESSED 0x0004 + +/* video flags */ +#define MVE_VIDEO_DELTA_FRAME 0x0001 + +#endif /* __MVE_H__ */ diff --git a/gst/mve/mveaudiodec.c b/gst/mve/mveaudiodec.c new file mode 100644 index 00000000..0e9ee4e2 --- /dev/null +++ b/gst/mve/mveaudiodec.c @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2003 The ffmpeg Project, Mike Melanson + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Interplay compressed audio codec by Mike Melanson (melanson@pcisys.net) + */ + +#include <gst/gst.h> + +static const short delta_table[256] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 47, 51, 56, 61, + 66, 72, 79, 86, 94, 102, 112, 122, 133, 145, 158, 173, 189, 206, 225, 245, + 267, 292, 318, 348, 379, 414, 452, 493, 538, 587, 640, 699, 763, 832, 908, + 991, + 1081, 1180, 1288, 1405, 1534, 1673, 1826, 1993, 2175, 2373, 2590, 2826, 3084, + 3365, 3672, 4008, + 4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059, 8794, 9597, 10472, 11428, + 12471, 13609, 14851, 16206, + 17685, 19298, 21060, 22981, 25078, 27367, 29864, 32589, -29973, -26728, + -23186, -19322, -15105, -10503, -5481, -1, + 1, 1, 5481, 10503, 15105, 19322, 23186, 26728, 29973, -32589, -29864, -27367, + -25078, -22981, -21060, -19298, + -17685, -16206, -14851, -13609, -12471, -11428, -10472, -9597, -8794, -8059, + -7385, -6767, -6202, -5683, -5208, -4772, + -4373, -4008, -3672, -3365, -3084, -2826, -2590, -2373, -2175, -1993, -1826, + -1673, -1534, -1405, -1288, -1180, + -1081, -991, -908, -832, -763, -699, -640, -587, -538, -493, -452, -414, -379, + -348, -318, -292, + -267, -245, -225, -206, -189, -173, -158, -145, -133, -122, -112, -102, -94, + -86, -79, -72, + -66, -61, -56, -51, -47, -43, -42, -41, -40, -39, -38, -37, -36, -35, -34, + -33, + -32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, + -17, + -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1 +}; + +void +ipaudio_uncompress (short *buffer, unsigned short buf_len, + const unsigned char *data, unsigned char channels) +{ + int i, out = 0; + int predictor[2]; + int channel_number = 0; + + for (i = 0; i < channels; ++i) { + predictor[i] = GST_READ_UINT16_LE (data); + data += 2; + if (predictor[i] & 0x8000) + predictor[i] -= 0x10000; + buffer[out++] = predictor[i]; + } + + /* we count in 16-bit ints, so adjust the buffer size */ + buf_len /= 2; + while (out < buf_len) { + predictor[channel_number] += delta_table[*data++]; + if (predictor[channel_number] < -32768) + predictor[channel_number] = -32768; + else if (predictor[channel_number] > 32767) + predictor[channel_number] = 32767; + buffer[out++] = predictor[channel_number]; + + /* toggle channel */ + channel_number ^= channels - 1; + } +} diff --git a/gst/mve/mveaudioenc.c b/gst/mve/mveaudioenc.c new file mode 100644 index 00000000..1de73753 --- /dev/null +++ b/gst/mve/mveaudioenc.c @@ -0,0 +1,120 @@ +/* + * Interplay MVE audio compressor + * Copyright (C) 2003, 2004 Alexander Belyakov <abel@krasu.ru> + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#include <math.h> +#include <gst/gst.h> + +static const gint32 dec_table[256] = + {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 47, 51, 56, 61,
66, 72, 79, 86, 94, 102, 112, + 122, 133, 145, 158, 173, 189, 206, 225, 245,
267, 292, 318, 348, 379, + 414, 452, 493, 538, 587, 640, 699, 763, 832, 908, 991,
1081, 1180, 1288, + 1405, 1534, 1673, 1826, 1993, 2175, 2373, 2590, 2826, 3084, 3365, 3672, + 4008,
4373, 4772, 5208, 5683, 6202, 6767, 7385, 8059, 8794, 9597, 10472, + 11428, 12471, 13609, 14851, 16206,
17685, 19298, 21060, 22981, 25078, + 27367, 29864, 32589, 35563, 38808, 42350, 46214, 50431, 55033, 60055, + 65535,
1, -65535, -60055, -55033, -50431, -46214, -42350, -38808, -35563, + -32589, -29864, -27367, -25078, -22981, -21060, -19298,
-17685, -16206, + -14851, -13609, -12471, -11428, -10472, -9597, -8794, -8059, -7385, -6767, + -6202, -5683, -5208, -4772,
-4373, -4008, -3672, -3365, -3084, -2826, + -2590, -2373, -2175, -1993, -1826, -1673, -1534, -1405, -1288, -1180, +
-1081, -991, -908, -832, -763, -699, -640, -587, -538, -493, -452, -414, + -379, -348, -318, -292,
-267, -245, -225, -206, -189, -173, -158, -145, + -133, -122, -112, -102, -94, -86, -79, -72,
-66, -61, -56, -51, -47, -43, + -42, -41, -40, -39, -38, -37, -36, -35, -34, -33,
-32, -31, -30, -29, + -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17,
-16, -15, + -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1
+}; + +
+/* This value could be non-optimal. Without knowledge of the value
+ distribution in the real signal, the actual optimum cannot be evaluated.
+ Should be somewhere between 11.458 and 11.542. */
+static const gdouble DPCM_SCALE = 11.5131; +
static gint8 +mve_enc_delta (guint n) +{ + if (n < 44) + return n; + return floor (DPCM_SCALE * log (n)); +} + +gint +mve_compress_audio (guint8 * dest, const guint8 * src, guint16 len, + guint8 channels) +{ + gint16 prev[2], s; + gint delta, real_res; + gint cur_chan; + guint8 v; + + for (cur_chan = 0; cur_chan < channels; ++cur_chan) { + prev[cur_chan] = GST_READ_UINT16_LE (src); + GST_WRITE_UINT16_LE (dest, prev[cur_chan]); + src += 2; + dest += 2; + len -= 2; + } + + cur_chan = 0; + while (len > 0) { + s = GST_READ_UINT16_LE (src); + src += 2; + + delta = s - prev[cur_chan]; +
if (delta >= 0) +
v = mve_enc_delta (delta); +
+ else +
v = 256 - mve_enc_delta (-delta); +
real_res = dec_table[v] + prev[cur_chan]; +
if (real_res < -32768 || real_res > 32767) { +
+ /* correct overflow */
+ /* GST_DEBUG ("co:%d + %d = %d -> new v:%d, dec_table:%d will be %d", + prev[cur_chan], dec_table[v], real_res, + v, dec_table[v], prev[cur_chan]+dec_table[v]); */ + if (s > 0) { +
if (real_res > 32767) + --v; +
} else { +
if (real_res < -32768) + ++v; +
} + + real_res = dec_table[v] + prev[cur_chan]; +
} + + if (G_UNLIKELY (abs (real_res - s) > 32767)) { + GST_ERROR ("sign loss left unfixed in audio stream, deviation:%ld", + real_res - s); + return -1; + } +
*dest++ = v; +
--len; + /* use previous output instead of input. That way output will not go too far from input. */
+ prev[cur_chan] += dec_table[v]; + cur_chan = channels - 1 - cur_chan; +
} + + return 0; +} diff --git a/gst/mve/mvevideodec16.c b/gst/mve/mvevideodec16.c new file mode 100644 index 00000000..8a46a59f --- /dev/null +++ b/gst/mve/mvevideodec16.c @@ -0,0 +1,849 @@ +/* + * Interplay MVE Video Decoder (16 bit) + * Copyright (C) 2003 the ffmpeg project, Mike Melanson + * (C) 2006 Jens Granseuer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * For more information about the Interplay MVE format, visit: + * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt + */ + +#include "gstmvedemux.h" +#include <string.h> + +#define PIXEL(s) GST_READ_UINT16_LE (s) + +#define CHECK_STREAM(l, n) \ + do { \ + if (G_UNLIKELY (*(l) < (n))) { \ + GST_ERROR ("wanted to read %d bytes from stream, %d available", (n), *(l)); \ + return -1; \ + } \ + *(l) -= (n); \ + } while (0) + +/* copy an 8x8 block from the stream to the frame buffer */ +static int +ipvideo_copy_block (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned short *src, int offset) +{ + int i; + int frame_offset; + + frame_offset = frame - (unsigned short *) s->back_buf1 + offset; + + if (G_UNLIKELY (frame_offset < 0)) { + GST_ERROR ("frame offset < 0 (%ld)", frame_offset); + return -1; + } else if (G_UNLIKELY (frame_offset > s->max_block_offset)) { + GST_ERROR ("frame offset above limit (%ld > %ld)", + frame_offset, s->max_block_offset); + return -1; + } + + for (i = 0; i < 8; ++i) { + memcpy (frame, src, 16); + frame += s->width; + src += s->width; + } + + return 0; +} + +static int +ipvideo_decode_0x2 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + unsigned char B; + int x, y; + int offset; + + /* copy block from 2 frames ago using a motion vector */ + CHECK_STREAM (len, 1); + B = *(*data)++; + + if (B < 56) { + x = 8 + (B % 7); + y = B / 7; + } else { + x = -14 + ((B - 56) % 29); + y = 8 + ((B - 56) / 29); + } + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + offset, offset); +} + +static int +ipvideo_decode_0x3 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + unsigned char B; + int x, y; + int offset; + + /* copy 8x8 block from current frame from an up/left block */ + CHECK_STREAM (len, 1); + B = *(*data)++; + + if (B < 56) { + x = -(8 + (B % 7)); + y = -(B / 7); + } else { + x = -(-14 + ((B - 56) % 29)); + y = -(8 + ((B - 56) / 29)); + } + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + offset, offset); +} + +static int +ipvideo_decode_0x4 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char B; + int offset; + + /* copy a block from the previous frame */ + CHECK_STREAM (len, 1); + B = *(*data)++; + x = -8 + (B & 0x0F); + y = -8 + (B >> 4); + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + + ((unsigned short *) s->back_buf2 - (unsigned short *) s->back_buf1) + + offset, offset); +} + +static int +ipvideo_decode_0x5 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + signed char x, y; + int offset; + + /* copy a block from the previous frame using an expanded range */ + CHECK_STREAM (len, 2); + x = (signed char) *(*data)++; + y = (signed char) *(*data)++; + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + + ((unsigned short *) s->back_buf2 - (unsigned short *) s->back_buf1) + + offset, offset); +} + +static int +ipvideo_decode_0x7 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P0, P1; + unsigned int flags; + int bitmask; + + /* 2-color encoding */ + CHECK_STREAM (len, 4 + 2); + P0 = PIXEL (*data); + (*data) += 2; + P1 = PIXEL (*data); + (*data) += 2; + + if (!(P0 & 0x8000)) { + + /* need 8 more bytes from the stream */ + CHECK_STREAM (len, 8 - 2); + + for (y = 0; y < 8; ++y) { + flags = *(*data)++; + for (x = 0x01; x <= 0x80; x <<= 1) { + if (flags & x) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + P0 &= ~0x8000; + + /* need 2 more bytes from the stream */ + + flags = ((*data)[1] << 8) | (*data)[0]; + (*data) += 2; + bitmask = 0x0001; + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, bitmask <<= 1) { + if (flags & bitmask) { + *(frame + x) = P1; + *(frame + x + 1) = P1; + *(frame + s->width + x) = P1; + *(frame + s->width + x + 1) = P1; + } else { + *(frame + x) = P0; + *(frame + x + 1) = P0; + *(frame + s->width + x) = P0; + *(frame + s->width + x + 1) = P0; + } + } + frame += s->width * 2; + } + } + + return 0; +} + +static int +ipvideo_decode_0x8 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P[8]; + unsigned char B[8]; + unsigned int flags = 0; + unsigned int bitmask = 0; + unsigned short P0 = 0, P1 = 0; + int lower_half = 0; + + /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM (len, 6 + 10); + + P[0] = PIXEL (*data); + (*data) += 2; + P[1] = PIXEL (*data); + (*data) += 2; + B[0] = *(*data)++; + B[1] = *(*data)++; + + if (!(P[0] & 0x8000)) { + + /* need 18 more bytes */ + CHECK_STREAM (len, 18 - 10); + + P[2] = PIXEL (*data); + (*data) += 2; + P[3] = PIXEL (*data); + (*data) += 2; + B[2] = *(*data)++; + B[3] = *(*data)++; + P[4] = PIXEL (*data); + (*data) += 2; + P[5] = PIXEL (*data); + (*data) += 2; + B[4] = *(*data)++; + B[5] = *(*data)++; + P[6] = PIXEL (*data); + (*data) += 2; + P[7] = PIXEL (*data); + (*data) += 2; + B[6] = *(*data)++; + B[7] = *(*data)++; + + flags = + ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | + ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) | + ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | + ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); + bitmask = 0x00000001; + lower_half = 0; /* still on top half */ + + for (y = 0; y < 8; ++y) { + + /* time to reload flags? */ + if (y == 4) { + flags = + ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | + ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) | + ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | + ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); + bitmask = 0x00000001; + lower_half = 2; + } + + /* get the pixel values ready for this quadrant */ + P0 = P[lower_half + 0]; + P1 = P[lower_half + 1]; + + for (x = 0; x < 8; ++x, bitmask <<= 1) { + if (x == 4) { + P0 = P[lower_half + 4]; + P1 = P[lower_half + 5]; + } + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + P[0] &= ~0x8000; + + /* need 10 more bytes */ + B[2] = *(*data)++; + B[3] = *(*data)++; + P[2] = PIXEL (*data); + (*data) += 2; + P[3] = PIXEL (*data); + (*data) += 2; + B[4] = *(*data)++; + B[5] = *(*data)++; + B[6] = *(*data)++; + B[7] = *(*data)++; + + if (!(P[2] & 0x8000)) { + /* vertical split; left & right halves are 2-color encoded */ + + flags = + ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | + ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) | + ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | + ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); + bitmask = 0x00000001; + + for (y = 0; y < 8; ++y) { + + /* time to reload flags? */ + if (y == 4) { + flags = + ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | + ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) | + ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | + ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); + bitmask = 0x00000001; + } + + /* get the pixel values ready for this half */ + P0 = P[0]; + P1 = P[1]; + + for (x = 0; x < 8; ++x, bitmask <<= 1) { + if (x == 4) { + P0 = P[2]; + P1 = P[3]; + } + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + /* horizontal split; top & bottom halves are 2-color encoded */ + + P0 = P[0]; + P1 = P[1]; + + for (y = 0; y < 8; ++y) { + + flags = B[y]; + if (y == 4) { + P0 = P[2] & ~0x8000; + P1 = P[3]; + } + + for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) { + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + } + } + + return 0; +} + +static int +ipvideo_decode_0x9 (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P[4]; + unsigned char B[4]; + unsigned int flags = 0; + int shifter = 0; + unsigned short pix; + + /* 4-color encoding */ + CHECK_STREAM (len, 8 + 4); + + P[0] = PIXEL (*data); + (*data) += 2; + P[1] = PIXEL (*data); + (*data) += 2; + P[2] = PIXEL (*data); + (*data) += 2; + P[3] = PIXEL (*data); + (*data) += 2; + + if (!(P[0] & 0x8000) && !(P[2] & 0x8000)) { + + /* 1 of 4 colors for each pixel, need 16 more bytes */ + CHECK_STREAM (len, 16 - 4); + + for (y = 0; y < 8; ++y) { + /* get the next set of 8 2-bit flags */ + flags = ((*data)[1] << 8) | (*data)[0]; + (*data) += 2; + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + *frame++ = P[(flags >> shifter) & 0x03]; + } + frame += s->width - 8; + } + + } else if (!(P[0] & 0x8000) && (P[2] & 0x8000)) { + P[2] &= ~0x8000; + + /* 1 of 4 colors for each 2x2 block, need 4 more bytes */ + + B[0] = *(*data)++; + B[1] = *(*data)++; + B[2] = *(*data)++; + B[3] = *(*data)++; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + x + 1) = pix; + *(frame + s->width + x) = pix; + *(frame + s->width + x + 1) = pix; + } + frame += s->width * 2; + } + + } else if ((P[0] & 0x8000) && !(P[2] & 0x8000)) { + P[0] &= ~0x8000; + + /* 1 of 4 colors for each 2x1 block, need 8 more bytes */ + + CHECK_STREAM (len, 8 - 4); + for (y = 0; y < 8; ++y) { + /* time to reload flags? */ + if ((y == 0) || (y == 4)) { + B[0] = *(*data)++; + B[1] = *(*data)++; + B[2] = *(*data)++; + B[3] = *(*data)++; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + } + for (x = 0; x < 8; x += 2, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + x + 1) = pix; + } + frame += s->width; + } + + } else { + P[0] &= ~0x8000; + P[2] &= ~0x8000; + + /* 1 of 4 colors for each 1x2 block, need 8 more bytes */ + CHECK_STREAM (len, 8 - 4); + + for (y = 0; y < 8; y += 2) { + /* time to reload flags? */ + if ((y == 0) || (y == 4)) { + B[0] = *(*data)++; + B[1] = *(*data)++; + B[2] = *(*data)++; + B[3] = *(*data)++; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + } + for (x = 0; x < 8; ++x, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + s->width + x) = pix; + } + frame += s->width * 2; + } + } + + return 0; +} + +static int +ipvideo_decode_0xa (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P[16]; + unsigned char B[16]; + int flags = 0; + int shifter = 0; + int index; + int split; + int lower_half; + + /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM (len, 8 + 24); + + P[0] = PIXEL (*data); + (*data) += 2; + P[1] = PIXEL (*data); + (*data) += 2; + P[2] = PIXEL (*data); + (*data) += 2; + P[3] = PIXEL (*data); + (*data) += 2; + + if (!(P[0] & 0x8000)) { + + /* 4-color encoding for each quadrant; need 40 more bytes */ + CHECK_STREAM (len, 40 - 24); + + B[0] = *(*data)++; + B[1] = *(*data)++; + B[2] = *(*data)++; + B[3] = *(*data)++; + for (y = 4; y < 16; y += 4) { + for (x = y; x < y + 4; ++x) { + P[x] = PIXEL (*data); + (*data) += 2; + } + for (x = y; x < y + 4; ++x) + B[x] = *(*data)++; + } + + for (y = 0; y < 8; ++y) { + + lower_half = (y >= 4) ? 4 : 0; + flags = (B[y + 8] << 8) | B[y]; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + split = (x >= 4) ? 8 : 0; + index = split + lower_half + ((flags >> shifter) & 0x03); + *frame++ = P[index]; + } + + frame += s->width - 8; + } + + } else { + P[0] &= ~0x8000; + + /* 4-color encoding for either left and right or top and bottom + * halves; need 24 more bytes */ + + memcpy (&B[0], *data, 8); + (*data) += 8; + P[4] = PIXEL (*data); + (*data) += 2; + P[5] = PIXEL (*data); + (*data) += 2; + P[6] = PIXEL (*data); + (*data) += 2; + P[7] = PIXEL (*data); + (*data) += 2; + memcpy (&B[8], *data, 8); + (*data) += 8; + + if (!(P[4] & 0x8000)) { + + /* block is divided into left and right halves */ + for (y = 0; y < 8; ++y) { + + flags = (B[y + 8] << 8) | B[y]; + split = 0; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + if (x == 4) + split = 4; + *frame++ = P[split + ((flags >> shifter) & 0x03)]; + } + + frame += s->width - 8; + } + + } else { + P[4] &= ~0x8000; + + /* block is divided into top and bottom halves */ + split = 0; + for (y = 0; y < 8; ++y) { + + flags = (B[y * 2 + 1] << 8) | B[y * 2]; + if (y == 4) + split = 4; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) + *frame++ = P[split + ((flags >> shifter) & 0x03)]; + + frame += s->width - 8; + } + } + } + + return 0; +} + +static int +ipvideo_decode_0xb (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + + /* 64-color encoding (each pixel in block is a different color) */ + CHECK_STREAM (len, 128); + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + *frame++ = PIXEL (*data); + (*data) += 2; + } + frame += s->width - 8; + } + + return 0; +} + +static int +ipvideo_decode_0xc (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short pix; + + /* 16-color block encoding: each 2x2 block is a different color */ + CHECK_STREAM (len, 32); + + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2) { + pix = PIXEL (*data); + (*data) += 2; + *(frame + x) = pix; + *(frame + x + 1) = pix; + *(frame + s->width + x) = pix; + *(frame + s->width + x + 1) = pix; + } + frame += s->width * 2; + } + + return 0; +} + +static int +ipvideo_decode_0xd (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P[4]; + unsigned char index = 0; + + /* 4-color block encoding: each 4x4 block is a different color */ + CHECK_STREAM (len, 8); + + P[0] = PIXEL (*data); + (*data) += 2; + P[1] = PIXEL (*data); + (*data) += 2; + P[2] = PIXEL (*data); + (*data) += 2; + P[3] = PIXEL (*data); + (*data) += 2; + + for (y = 0; y < 8; ++y) { + if (y < 4) + index = 0; + else + index = 2; + + for (x = 0; x < 8; ++x) { + if (x == 4) + ++index; + *frame++ = P[index]; + } + frame += s->width - 8; + } + + return 0; +} + +static int +ipvideo_decode_0xe (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short pix; + + /* 1-color encoding: the whole block is 1 solid color */ + CHECK_STREAM (len, 2); + + pix = PIXEL (*data); + (*data) += 2; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + *frame++ = pix; + } + frame += s->width - 8; + } + + return 0; +} + +static int +ipvideo_decode_0xf (const GstMveDemuxStream * s, unsigned short *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned short P[2]; + + /* dithered encoding */ + CHECK_STREAM (len, 4); + + P[0] = PIXEL (*data); + (*data) += 2; + P[1] = PIXEL (*data); + (*data) += 2; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x) { + *frame++ = P[y & 1]; + *frame++ = P[(y & 1) ^ 1]; + } + frame += s->width - 8; + } + + return 0; +} + +int +ipvideo_decode_frame16 (const GstMveDemuxStream * s, const unsigned char *data, + unsigned short len) +{ + int rc = 0; + int x, y, xx, yy; + int index = 0; + unsigned short offset; + unsigned char opcode; + unsigned short *frame; + const unsigned char *data2; + unsigned short len2; + + CHECK_STREAM (&len, 2); + + offset = (data[1] << 8) | data[0]; + data2 = data + offset; + len2 = len - offset + 2; + data += 2; + + frame = (unsigned short *) s->back_buf1; + + /* decoding is done in 8x8 blocks */ + xx = s->width >> 3; + yy = s->height >> 3; + + for (y = 0; y < yy; ++y) { + for (x = 0; x < xx; ++x) { + /* decoding map contains 4 bits of information per 8x8 block */ + /* bottom nibble first, then top nibble */ + if (index & 1) + opcode = s->code_map[index >> 1] >> 4; + else + opcode = s->code_map[index >> 1] & 0x0F; + ++index; + + /* GST_DEBUG ("block @ (%3d, %3d): encoding 0x%X, data ptr @ %p", + x, y, opcode, data); */ + + switch (opcode) { + case 0x0: + /* copy a block from the previous frame */ + rc = ipvideo_copy_block (s, frame, frame + + ((unsigned short *) s->back_buf2 - + (unsigned short *) s->back_buf1), 0); + break; + case 0x1: + /* copy block from 2 frames ago; since we switched the back + * buffers we don't actually have to do anything here */ + break; + case 0x2: + rc = ipvideo_decode_0x2 (s, frame, &data2, &len2); + break; + case 0x3: + rc = ipvideo_decode_0x3 (s, frame, &data2, &len2); + break; + case 0x4: + rc = ipvideo_decode_0x4 (s, frame, &data2, &len2); + break; + case 0x5: + rc = ipvideo_decode_0x5 (s, frame, &data, &len); + break; + case 0x6: + /* mystery opcode? skip multiple blocks? */ + GST_WARNING ("encountered unsupported opcode 0x6"); + rc = -1; + break; + case 0x7: + rc = ipvideo_decode_0x7 (s, frame, &data, &len); + break; + case 0x8: + rc = ipvideo_decode_0x8 (s, frame, &data, &len); + break; + case 0x9: + rc = ipvideo_decode_0x9 (s, frame, &data, &len); + break; + case 0xa: + rc = ipvideo_decode_0xa (s, frame, &data, &len); + break; + case 0xb: + rc = ipvideo_decode_0xb (s, frame, &data, &len); + break; + case 0xc: + rc = ipvideo_decode_0xc (s, frame, &data, &len); + break; + case 0xd: + rc = ipvideo_decode_0xd (s, frame, &data, &len); + break; + case 0xe: + rc = ipvideo_decode_0xe (s, frame, &data, &len); + break; + case 0xf: + rc = ipvideo_decode_0xf (s, frame, &data, &len); + break; + } + + if (rc != 0) + return rc; + + frame += 8; + } + frame += 7 * s->width; + } + + return 0; +} diff --git a/gst/mve/mvevideodec8.c b/gst/mve/mvevideodec8.c new file mode 100644 index 00000000..73e9172f --- /dev/null +++ b/gst/mve/mvevideodec8.c @@ -0,0 +1,802 @@ +/* + * Interplay MVE Video Decoder (8 bit) + * Copyright (C) 2003 the ffmpeg project, Mike Melanson + * (C) 2006 Jens Granseuer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * For more information about the Interplay MVE format, visit: + * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt + */ + +#include "gstmvedemux.h" +#include <string.h> + +#define CHECK_STREAM(l, n) \ + do { \ + if (G_UNLIKELY (*(l) < (n))) { \ + GST_ERROR ("wanted to read %d bytes from stream, %d available", (n), *(l)); \ + return -1; \ + } \ + *(l) -= (n); \ + } while (0) + + +/* copy an 8x8 block from the stream to the frame buffer */ +static int +ipvideo_copy_block (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char *src, int offset) +{ + int i; + long frame_offset; + + frame_offset = frame - s->back_buf1 + offset; + + if (G_UNLIKELY (frame_offset < 0)) { + GST_ERROR ("frame offset < 0 (%ld)", frame_offset); + return -1; + } else if (G_UNLIKELY (frame_offset > s->max_block_offset)) { + GST_ERROR ("frame offset above limit (%ld > %ld)", + frame_offset, s->max_block_offset); + return -1; + } + + for (i = 0; i < 8; ++i) { + memcpy (frame, src, 8); + frame += s->width; + src += s->width; + } + + return 0; +} + +static int +ipvideo_decode_0x2 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + unsigned char B; + int x, y; + int offset; + + /* copy block from 2 frames ago using a motion vector */ + CHECK_STREAM (len, 1); + B = *(*data)++; + + if (B < 56) { + x = 8 + (B % 7); + y = B / 7; + } else { + x = -14 + ((B - 56) % 29); + y = 8 + ((B - 56) / 29); + } + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + offset, offset); +} + +static int +ipvideo_decode_0x3 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + unsigned char B; + int x, y; + int offset; + + /* copy 8x8 block from current frame from an up/left block */ + CHECK_STREAM (len, 1); + B = *(*data)++; + + if (B < 56) { + x = -(8 + (B % 7)); + y = -(B / 7); + } else { + x = -(-14 + ((B - 56) % 29)); + y = -(8 + ((B - 56) / 29)); + } + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, frame + offset, offset); +} + +static int +ipvideo_decode_0x4 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + unsigned char B; + int x, y; + int offset; + + /* copy a block from the previous frame */ + CHECK_STREAM (len, 1); + B = *(*data)++; + x = -8 + (B & 0x0F); + y = -8 + (B >> 4); + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, + frame + (s->back_buf2 - s->back_buf1) + offset, offset); +} + +static int +ipvideo_decode_0x5 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + signed char x, y; + int offset; + + /* copy a block from the previous frame using an expanded range */ + CHECK_STREAM (len, 2); + + x = (signed char) *(*data)++; + y = (signed char) *(*data)++; + offset = y * s->width + x; + + return ipvideo_copy_block (s, frame, + frame + (s->back_buf2 - s->back_buf1) + offset, offset); +} + +static int +ipvideo_decode_0x7 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P0, P1; + unsigned int flags; + int bitmask; + + /* 2-color encoding */ + CHECK_STREAM (len, 2 + 2); + + P0 = *(*data)++; + P1 = *(*data)++; + + if (P0 <= P1) { + + /* need 8 more bytes from the stream */ + CHECK_STREAM (len, 8 - 2); + + for (y = 0; y < 8; ++y) { + flags = *(*data)++; + for (x = 0x01; x <= 0x80; x <<= 1) { + if (flags & x) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + + /* need 2 more bytes from the stream */ + flags = ((*data)[1] << 8) | (*data)[0]; + (*data) += 2; + bitmask = 0x0001; + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, bitmask <<= 1) { + if (flags & bitmask) { + *(frame + x) = P1; + *(frame + x + 1) = P1; + *(frame + s->width + x) = P1; + *(frame + s->width + x + 1) = P1; + } else { + *(frame + x) = P0; + *(frame + x + 1) = P0; + *(frame + s->width + x) = P0; + *(frame + s->width + x + 1) = P0; + } + } + frame += s->width * 2; + } + } + + return 0; +} + +static int +ipvideo_decode_0x8 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P[8]; + unsigned char B[8]; + unsigned int flags = 0; + unsigned int bitmask = 0; + unsigned char P0 = 0, P1 = 0; + int lower_half = 0; + + /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM (len, 4 + 8); + + P[0] = (*data)[0]; + P[1] = (*data)[1]; + B[0] = (*data)[2]; + B[1] = (*data)[3]; + (*data) += 4; + + if (P[0] <= P[1]) { + + /* need 12 more bytes */ + CHECK_STREAM (len, 12 - 8); + + P[2] = (*data)[0]; + P[3] = (*data)[1]; + B[2] = (*data)[2]; + B[3] = (*data)[3]; + P[4] = (*data)[4]; + P[5] = (*data)[5]; + B[4] = (*data)[6]; + B[5] = (*data)[7]; + P[6] = (*data)[8]; + P[7] = (*data)[9]; + B[6] = (*data)[10]; + B[7] = (*data)[11]; + (*data) += 12; + + flags = + ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | + ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) | + ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | + ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); + bitmask = 0x00000001; + lower_half = 0; /* still on top half */ + + for (y = 0; y < 8; ++y) { + + /* time to reload flags? */ + if (y == 4) { + flags = + ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | + ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) | + ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | + ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); + bitmask = 0x00000001; + lower_half = 2; + } + + /* get the pixel values ready for this quadrant */ + P0 = P[lower_half + 0]; + P1 = P[lower_half + 1]; + + for (x = 0; x < 8; ++x, bitmask <<= 1) { + if (x == 4) { + P0 = P[lower_half + 4]; + P1 = P[lower_half + 5]; + } + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + + /* need 8 more bytes */ + B[2] = (*data)[0]; + B[3] = (*data)[1]; + P[2] = (*data)[2]; + P[3] = (*data)[3]; + B[4] = (*data)[4]; + B[5] = (*data)[5]; + B[6] = (*data)[6]; + B[7] = (*data)[7]; + (*data) += 8; + + if (P[2] <= P[3]) { + + /* vertical split; left & right halves are 2-color encoded */ + + flags = + ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | + ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) | + ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | + ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); + bitmask = 0x00000001; + + for (y = 0; y < 8; ++y) { + + /* time to reload flags? */ + if (y == 4) { + flags = + ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | + ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) | + ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | + ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); + bitmask = 0x00000001; + } + + /* get the pixel values ready for this half */ + P0 = P[0]; + P1 = P[1]; + + for (x = 0; x < 8; ++x, bitmask <<= 1) { + if (x == 4) { + P0 = P[2]; + P1 = P[3]; + } + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + + } else { + + /* horizontal split; top & bottom halves are 2-color encoded */ + + P0 = P[0]; + P1 = P[1]; + + for (y = 0; y < 8; ++y) { + + flags = B[y]; + if (y == 4) { + P0 = P[2]; + P1 = P[3]; + } + + for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) { + + if (flags & bitmask) + *frame++ = P1; + else + *frame++ = P0; + } + frame += s->width - 8; + } + } + } + + return 0; +} + +static int +ipvideo_decode_0x9 (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P[4]; + unsigned char B[4]; + unsigned long flags = 0; + int shifter = 0; + unsigned char pix; + + /* 4-color encoding */ + CHECK_STREAM (len, 4 + 4); + + P[0] = (*data)[0]; + P[1] = (*data)[1]; + P[2] = (*data)[2]; + P[3] = (*data)[3]; + (*data) += 4; + + if ((P[0] <= P[1]) && (P[2] <= P[3])) { + + /* 1 of 4 colors for each pixel, need 16 more bytes */ + CHECK_STREAM (len, 16 - 4); + + for (y = 0; y < 8; ++y) { + /* get the next set of 8 2-bit flags */ + flags = ((*data)[1] << 8) | (*data)[0]; + (*data) += 2; + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + *frame++ = P[(flags >> shifter) & 0x03]; + } + frame += s->width - 8; + } + + } else if ((P[0] <= P[1]) && (P[2] > P[3])) { + + /* 1 of 4 colors for each 2x2 block, need 4 more bytes */ + B[0] = (*data)[0]; + B[1] = (*data)[1]; + B[2] = (*data)[2]; + B[3] = (*data)[3]; + (*data) += 4; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + x + 1) = pix; + *(frame + s->width + x) = pix; + *(frame + s->width + x + 1) = pix; + } + frame += s->width * 2; + } + + } else if ((P[0] > P[1]) && (P[2] <= P[3])) { + + /* 1 of 4 colors for each 2x1 block, need 8 more bytes */ + CHECK_STREAM (len, 8 - 4); + + for (y = 0; y < 8; ++y) { + /* time to reload flags? */ + if ((y == 0) || (y == 4)) { + B[0] = (*data)[0]; + B[1] = (*data)[1]; + B[2] = (*data)[2]; + B[3] = (*data)[3]; + (*data) += 4; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + } + for (x = 0; x < 8; x += 2, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + x + 1) = pix; + } + frame += s->width; + } + + } else { + + /* 1 of 4 colors for each 1x2 block, need 8 more bytes */ + CHECK_STREAM (len, 8 - 4); + + for (y = 0; y < 8; y += 2) { + /* time to reload flags? */ + if ((y == 0) || (y == 4)) { + B[0] = (*data)[0]; + B[1] = (*data)[1]; + B[2] = (*data)[2]; + B[3] = (*data)[3]; + (*data) += 4; + flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; + shifter = 0; + } + for (x = 0; x < 8; ++x, shifter += 2) { + pix = P[(flags >> shifter) & 0x03]; + *(frame + x) = pix; + *(frame + s->width + x) = pix; + } + frame += s->width * 2; + } + } + + return 0; +} + +static int +ipvideo_decode_0xa (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P[16]; + unsigned char B[16]; + int flags = 0; + int shifter = 0; + int index; + int split; + int lower_half; + + /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM (len, 8 + 16); + + P[0] = (*data)[0]; + P[1] = (*data)[1]; + P[2] = (*data)[2]; + P[3] = (*data)[3]; + B[0] = (*data)[4]; + B[1] = (*data)[5]; + B[2] = (*data)[6]; + B[3] = (*data)[7]; + (*data) += 8; + + if (P[0] <= P[1]) { + + /* 4-color encoding for each quadrant; need 24 more bytes */ + CHECK_STREAM (len, 24 - 16); + + for (y = 4; y < 16; y += 4) { + for (x = y; x < y + 4; ++x) + P[x] = *(*data)++; + for (x = y; x < y + 4; ++x) + B[x] = *(*data)++; + } + + for (y = 0; y < 8; ++y) { + + lower_half = (y >= 4) ? 4 : 0; + flags = (B[y + 8] << 8) | B[y]; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + split = (x >= 4) ? 8 : 0; + index = split + lower_half + ((flags >> shifter) & 0x03); + *frame++ = P[index]; + } + + frame += s->width - 8; + } + + } else { + + /* 4-color encoding for either left and right or top and bottom + * halves; need 16 more bytes */ + + B[4] = (*data)[0]; + B[5] = (*data)[1]; + B[6] = (*data)[2]; + B[7] = (*data)[3]; + P[4] = (*data)[4]; + P[5] = (*data)[5]; + P[6] = (*data)[6]; + P[7] = (*data)[7]; + (*data) += 8; + memcpy (&B[8], *data, 8); + (*data) += 8; + + if (P[4] <= P[5]) { + + /* block is divided into left and right halves */ + for (y = 0; y < 8; ++y) { + + flags = (B[y + 8] << 8) | B[y]; + split = 0; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) { + if (x == 4) + split = 4; + *frame++ = P[split + ((flags >> shifter) & 0x03)]; + } + + frame += s->width - 8; + } + + } else { + + /* block is divided into top and bottom halves */ + split = 0; + for (y = 0; y < 8; ++y) { + + flags = (B[y * 2 + 1] << 8) | B[y * 2]; + if (y == 4) + split = 4; + + for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) + *frame++ = P[split + ((flags >> shifter) & 0x03)]; + + frame += s->width - 8; + } + } + } + + return 0; +} + +static int +ipvideo_decode_0xb (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int y; + + /* 64-color encoding (each pixel in block is a different color) */ + CHECK_STREAM (len, 64); + + for (y = 0; y < 8; ++y) { + memcpy (frame, *data, 8); + frame += s->width; + (*data) += 8; + } + + return 0; +} + +static int +ipvideo_decode_0xc (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char pix; + + /* 16-color block encoding: each 2x2 block is a different color */ + CHECK_STREAM (len, 16); + + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2) { + pix = *(*data)++; + *(frame + x) = pix; + *(frame + x + 1) = pix; + *(frame + s->width + x) = pix; + *(frame + s->width + x + 1) = pix; + } + frame += s->width * 2; + } + + return 0; +} + +static int +ipvideo_decode_0xd (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P[4]; + unsigned char index = 0; + + /* 4-color block encoding: each 4x4 block is a different color */ + CHECK_STREAM (len, 4); + + P[0] = (*data)[0]; + P[1] = (*data)[1]; + P[2] = (*data)[2]; + P[3] = (*data)[3]; + (*data) += 4; + + for (y = 0; y < 8; ++y) { + if (y < 4) + index = 0; + else + index = 2; + + for (x = 0; x < 8; ++x) { + if (x == 4) + ++index; + *frame++ = P[index]; + } + frame += s->width - 8; + } + + return 0; +} + +static int +ipvideo_decode_0xe (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int y; + unsigned char pix; + + /* 1-color encoding: the whole block is 1 solid color */ + CHECK_STREAM (len, 1); + pix = *(*data)++; + + for (y = 0; y < 8; ++y) { + memset (frame, pix, 8); + frame += s->width; + } + + return 0; +} + +static int +ipvideo_decode_0xf (const GstMveDemuxStream * s, unsigned char *frame, + const unsigned char **data, unsigned short *len) +{ + int x, y; + unsigned char P[2]; + + /* dithered encoding */ + CHECK_STREAM (len, 2); + + P[0] = *(*data)++; + P[1] = *(*data)++; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x) { + *frame++ = P[y & 1]; + *frame++ = P[(y & 1) ^ 1]; + } + frame += s->width - 8; + } + + return 0; +} + +int +ipvideo_decode_frame8 (const GstMveDemuxStream * s, const unsigned char *data, + unsigned short len) +{ + int rc = 0; + int x, y, xx, yy; + int index = 0; + unsigned char opcode; + unsigned char *frame; + + frame = s->back_buf1; + + /* decoding is done in 8x8 blocks */ + xx = s->width >> 3; + yy = s->height >> 3; + + for (y = 0; y < yy; ++y) { + for (x = 0; x < xx; ++x) { + /* decoding map contains 4 bits of information per 8x8 block */ + /* bottom nibble first, then top nibble */ + if (index & 1) + opcode = s->code_map[index >> 1] >> 4; + else + opcode = s->code_map[index >> 1] & 0x0F; + ++index; + + /* GST_DEBUG ("block @ (%3d, %3d): encoding 0x%X, data ptr @ %p", + x, y, opcode, data); */ + + switch (opcode) { + case 0x00: + /* copy a block from the previous frame */ + rc = ipvideo_copy_block (s, frame, + frame + (s->back_buf2 - s->back_buf1), 0); + break; + case 0x01: + /* copy block from 2 frames ago; since we switched the back + * buffers we don't actually have to do anything here */ + break; + case 0x02: + rc = ipvideo_decode_0x2 (s, frame, &data, &len); + break; + case 0x03: + rc = ipvideo_decode_0x3 (s, frame, &data, &len); + break; + case 0x04: + rc = ipvideo_decode_0x4 (s, frame, &data, &len); + break; + case 0x05: + rc = ipvideo_decode_0x5 (s, frame, &data, &len); + break; + case 0x06: + /* mystery opcode? skip multiple blocks? */ + GST_WARNING ("encountered unsupported opcode 0x6"); + rc = -1; + break; + case 0x07: + rc = ipvideo_decode_0x7 (s, frame, &data, &len); + break; + case 0x08: + rc = ipvideo_decode_0x8 (s, frame, &data, &len); + break; + case 0x09: + rc = ipvideo_decode_0x9 (s, frame, &data, &len); + break; + case 0x0a: + rc = ipvideo_decode_0xa (s, frame, &data, &len); + break; + case 0x0b: + rc = ipvideo_decode_0xb (s, frame, &data, &len); + break; + case 0x0c: + rc = ipvideo_decode_0xc (s, frame, &data, &len); + break; + case 0x0d: + rc = ipvideo_decode_0xd (s, frame, &data, &len); + break; + case 0x0e: + rc = ipvideo_decode_0xe (s, frame, &data, &len); + break; + case 0x0f: + rc = ipvideo_decode_0xf (s, frame, &data, &len); + break; + } + + if (rc != 0) + return rc; + + frame += 8; + } + frame += 7 * s->width; + } + + return 0; +} diff --git a/gst/mve/mvevideoenc16.c b/gst/mve/mvevideoenc16.c new file mode 100644 index 00000000..4a18389b --- /dev/null +++ b/gst/mve/mvevideoenc16.c @@ -0,0 +1,1649 @@ +/* + * Interplay MVE video encoder (16 bit) + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdlib.h> +#include <string.h> +#include "gstmvemux.h" + +typedef struct _GstMveEncoderData GstMveEncoderData; +typedef struct _GstMveEncoding GstMveEncoding; +typedef struct _GstMveApprox GstMveApprox; +typedef struct _GstMveQuant GstMveQuant; + +#define MVE_RMASK 0x7c00 +#define MVE_GMASK 0x03e0 +#define MVE_BMASK 0x001f +#define MVE_RSHIFT 10 +#define MVE_GSHIFT 5 +#define MVE_BSHIFT 0 + +#define MVE_RVAL(p) (((p) & MVE_RMASK) >> MVE_RSHIFT) +#define MVE_GVAL(p) (((p) & MVE_GMASK) >> MVE_GSHIFT) +#define MVE_BVAL(p) (((p) & MVE_BMASK) >> MVE_BSHIFT) +#define MVE_COL(r,g,b) (((r) << MVE_RSHIFT) | ((g) << MVE_GSHIFT) | ((b) << MVE_BSHIFT)) + +struct _GstMveEncoderData +{ + GstMveMux *mve; + /* current position in frame */ + guint16 x, y; + + /* commonly used quantization results + (2 and 4 colors) for the current block */ + guint16 q2block[64]; + guint16 q2colors[2]; + guint32 q2error; + gboolean q2available; + + guint16 q4block[64]; + guint16 q4colors[4]; + guint32 q4error; + gboolean q4available; +}; + +struct _GstMveEncoding +{ + guint8 opcode; + guint8 size; + guint32 (*approx) (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * res); +}; + +#define MVE_APPROX_MAX_ERROR G_MAXUINT32 + +struct _GstMveApprox +{ + guint32 error; + guint8 type; + guint8 data[128]; /* max 128 bytes encoded per block */ + guint16 block[64]; /* block in final image */ +}; + +struct _GstMveQuant +{ + guint16 col; + guint16 r_total, g_total, b_total; + guint8 r, g, b; + guint8 hits, hits_last; + guint32 max_error; + guint16 max_miss; +}; + +#define mve_median(mve, src) mve_median_sub ((mve), (src), 8, 8, 0) +#define mve_color_dist(c1, c2) \ + mve_color_dist_rgb (MVE_RVAL (c1), MVE_GVAL (c1), MVE_BVAL (c1), \ + MVE_RVAL (c2), MVE_GVAL (c2), MVE_BVAL (c2)); + +/* comparison function for qsort() */ +static int +mve_comp_solution (const void *a, const void *b) +{ + const GArray *aa = *((GArray **) a); + const GArray *bb = *((GArray **) b); + + if (aa->len <= 1) + return G_MAXINT; + else if (bb->len <= 1) + return G_MININT; + else + return g_array_index (aa, GstMveApprox, aa->len - 2).error - + g_array_index (bb, GstMveApprox, bb->len - 2).error; +} + +static inline guint32 +mve_color_dist_rgb (guint8 r1, guint8 g1, guint8 b1, + guint8 r2, guint8 g2, guint8 b2) +{ + /* euclidean distance (minus sqrt) */ + gint dr = r1 - r2; + gint dg = g1 - g2; + gint db = b1 - b2; + + return dr * dr + dg * dg + db * db; +} + +/* compute average color in a sub-block */ +static guint16 +mve_median_sub (const GstMveMux * mve, const guint16 * src, guint w, guint h, + guint n) +{ + guint x, y; + const guint max = w * h, max2 = max >> 1; + guint32 r_total = max2, g_total = max2, b_total = max2; + + src += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * mve->width); + + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + r_total += MVE_RVAL (src[x]); + g_total += MVE_GVAL (src[x]); + b_total += MVE_BVAL (src[x]); + } + src += mve->width; + } + + return MVE_COL (r_total / max, g_total / max, b_total / max); +} + +static void +mve_quant_init (const GstMveMux * mve, GstMveQuant * q, guint n_clusters, + const guint16 * data, guint w, guint h) +{ + guint i; + guint x, y; + guint16 cols[4]; + guint16 val[2]; + + /* init first cluster with lowest (darkest), second with highest (lightest) + color. if we need 4 clusters, fill in first and last color in the block + and hope they make for a good distribution */ + cols[0] = cols[1] = cols[2] = data[0]; + cols[3] = data[(h - 1) * mve->width + w - 1]; + + /* favour red over green and blue */ + val[0] = val[1] = + (MVE_RVAL (data[0]) << 1) + MVE_GVAL (data[0]) + MVE_BVAL (data[0]); + + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + guint16 c = data[x]; + + if ((c != cols[0]) && (c != cols[1])) { + guint v = (MVE_RVAL (c) << 1) + MVE_GVAL (c) + MVE_BVAL (c); + + if (v < val[0]) { + val[0] = v; + cols[0] = c; + } else if (v > val[1]) { + val[1] = v; + cols[1] = c; + } + } + } + data += mve->width; + } + + for (i = 0; i < n_clusters; ++i) { + q[i].col = cols[i]; + q[i].r = MVE_RVAL (cols[i]); + q[i].g = MVE_GVAL (cols[i]); + q[i].b = MVE_BVAL (cols[i]); + q[i].r_total = q[i].g_total = q[i].b_total = 0; + q[i].hits = q[i].hits_last = 0; + q[i].max_error = 0; + q[i].max_miss = 0; + } +} + +static gboolean +mve_quant_update_clusters (GstMveQuant * q, guint n_clusters) +{ + gboolean changed = FALSE; + guint i; + + for (i = 0; i < n_clusters; ++i) { + if (q[i].hits > 0) { + guint16 means = MVE_COL ((q[i].r_total + q[i].hits / 2) / q[i].hits, + (q[i].g_total + q[i].hits / 2) / q[i].hits, + (q[i].b_total + q[i].hits / 2) / q[i].hits); + + if ((means != q[i].col) || (q[i].hits != q[i].hits_last)) + changed = TRUE; + + q[i].col = means; + q[i].r_total = q[i].g_total = q[i].b_total = 0; + } else { + guint j; + guint32 max_err = 0; + GstMveQuant *worst = NULL; + + /* try to replace unused cluster with a better representative */ + for (j = 0; j < n_clusters; ++j) { + if (q[j].max_error > max_err) { + worst = &q[j]; + max_err = worst->max_error; + } + } + if (worst) { + q[i].col = worst->max_miss; + worst->max_error = 0; + changed = TRUE; + } + } + + q[i].r = MVE_RVAL (q[i].col); + q[i].g = MVE_GVAL (q[i].col); + q[i].b = MVE_BVAL (q[i].col); + q[i].hits_last = q[i].hits; + q[i].hits = 0; + } + for (i = 0; i < n_clusters; ++i) { + q[i].max_error = 0; + } + + return changed; +} + +/* quantize a sub-block using a k-means algorithm */ +static guint32 +mve_quantize (const GstMveMux * mve, const guint16 * src, + guint w, guint h, guint n, guint ncols, guint16 * scratch, guint16 * cols) +{ + guint x, y, i; + GstMveQuant q[4]; + const guint16 *data; + guint16 *dest; + guint32 error; + + g_assert (n <= 4 && ncols <= 4); + + src += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * mve->width); + scratch += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * 8); + + mve_quant_init (mve, q, ncols, src, w, h); + + do { + data = src; + dest = scratch; + error = 0; + + /* for each pixel find the closest cluster */ + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + guint16 c = data[x]; + guint8 r = MVE_RVAL (c), g = MVE_GVAL (c), b = MVE_BVAL (c); + guint32 minerr = MVE_APPROX_MAX_ERROR, err; + GstMveQuant *best = NULL; + + for (i = 0; i < ncols; ++i) { + err = mve_color_dist_rgb (r, g, b, q[i].r, q[i].g, q[i].b); + + if (err < minerr) { + minerr = err; + best = &q[i]; + } + } + + ++best->hits; + best->r_total += r; + best->g_total += g; + best->b_total += b; + + if (minerr > best->max_error) { + best->max_error = minerr; + best->max_miss = c; + } + + error += minerr; + dest[x] = best->col; + } + data += mve->width; + dest += 8; + } + } while (mve_quant_update_clusters (q, ncols)); + + /* fill cols array with result colors */ + for (i = 0; i < ncols; ++i) + cols[i] = q[i].col; + + return error; +} + +static guint32 +mve_block_error (const GstMveMux * mve, const guint16 * b1, const guint16 * b2, + guint32 threshold) +{ + /* compute error between two blocks in a frame */ + guint32 e = 0; + guint x, y; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + e += mve_color_dist (*b1, *b2); + + /* using a threshold to return early gives a huge performance bonus */ + if (e >= threshold) + return MVE_APPROX_MAX_ERROR; + ++b1; + ++b2; + } + + b1 += mve->width - 8; + b2 += mve->width - 8; + } + + return e; +} + +static guint32 +mve_block_error_packed (const GstMveMux * mve, const guint16 * block, + const guint16 * scratch) +{ + /* compute error between a block in a frame and a (continuous) scratch pad */ + guint32 e = 0; + guint x, y; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + e += mve_color_dist (block[x], scratch[x]); + } + block += mve->width; + scratch += 8; + } + + return e; +} + +static void +mve_store_block (const GstMveMux * mve, const guint16 * block, + guint16 * scratch) +{ + /* copy block from frame to a (continuous) scratch pad */ + guint y; + + for (y = 0; y < 8; ++y) { + memcpy (scratch, block, 16); + block += mve->width; + scratch += 8; + } +} + +static void +mve_restore_block (const GstMveMux * mve, guint16 * block, + const guint16 * scratch) +{ + /* copy block from scratch pad to frame */ + guint y; + + for (y = 0; y < 8; ++y) { + memcpy (block, scratch, 16); + block += mve->width; + scratch += 8; + } +} + + +static guint32 +mve_try_vector (GstMveEncoderData * enc, const guint16 * src, + const guint16 * frame, gint pn, GstMveApprox * apx) +{ + /* try to locate a similar 8x8 block in the given frame using a motion vector */ + guint i; + gint dx, dy; + gint fx, fy; + guint32 err; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (i = 0; i < 256; ++i) { + if (i < 56) { + dx = 8 + (i % 7); + dy = i / 7; + } else { + dx = -14 + ((i - 56) % 29); + dy = 8 + ((i - 56) / 29); + } + + fx = enc->x + dx * pn; + fy = enc->y + dy * pn; + + if ((fx >= 0) && (fy >= 0) && (fx + 8 <= enc->mve->width) + && (fy + 8 <= enc->mve->height)) { + err = + mve_block_error (enc->mve, src, frame + fy * enc->mve->width + fx, + apx->error); + if (err < apx->error) { + apx->data[0] = i; + mve_store_block (enc->mve, frame + fy * enc->mve->width + fx, + apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x0 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy a block from the last frame (0 bytes) */ + if (enc->mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + mve_store_block (enc->mve, + ((guint16 *) GST_BUFFER_DATA (enc->mve->last_frame)) + + enc->y * enc->mve->width + enc->x, apx->block); + apx->error = mve_block_error_packed (enc->mve, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x1 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy a block from the second to last frame (0 bytes) */ + if (enc->mve->second_last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + mve_store_block (enc->mve, + ((guint16 *) GST_BUFFER_DATA (enc->mve->second_last_frame)) + + enc->y * enc->mve->width + enc->x, apx->block); + apx->error = mve_block_error_packed (enc->mve, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x2 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy block from 2 frames ago using a motion vector (1 byte) */ + if (enc->mve->quick_encoding || enc->mve->second_last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + apx->error = mve_try_vector (enc, src, + (guint16 *) GST_BUFFER_DATA (enc->mve->second_last_frame), 1, apx); + return apx->error; +} + +static guint32 +mve_encode_0x3 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy 8x8 block from current frame from an up/left block (1 byte) */ + if (enc->mve->quick_encoding) + return MVE_APPROX_MAX_ERROR; + + apx->error = mve_try_vector (enc, src, + src - enc->mve->width * enc->y - enc->x, -1, apx); + return apx->error; +} + +static guint32 +mve_encode_0x4 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy a block from previous frame using a motion vector (-8/-8 to +7/+7) (1 byte) */ + const GstMveMux *mve = enc->mve; + guint32 err; + const guint16 *frame; + gint x1, x2, xi, y1, y2, yi; + + if (mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + frame = (guint16 *) GST_BUFFER_DATA (mve->last_frame); + + x1 = enc->x - 8; + x2 = enc->x + 7; + if (x1 < 0) + x1 = 0; + else if (x2 + 8 > mve->width) + x2 = mve->width - 8; + + y1 = enc->y - 8; + y2 = enc->y + 7; + if (y1 < 0) + y1 = 0; + else if (y2 + 8 > mve->height) + y2 = mve->height - 8; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (yi = y1; yi <= y2; ++yi) { + guint yoff = yi * mve->width; + + for (xi = x1; xi <= x2; ++xi) { + err = mve_block_error (mve, src, frame + yoff + xi, apx->error); + if (err < apx->error) { + apx->data[0] = ((xi - enc->x + 8) & 0xF) | ((yi - enc->y + 8) << 4); + mve_store_block (mve, frame + yoff + xi, apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x5 (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* copy a block from previous frame using a motion vector + (-128/-128 to +127/+127) (2 bytes) */ + const GstMveMux *mve = enc->mve; + guint32 err; + const guint16 *frame; + gint x1, x2, xi, y1, y2, yi; + + if (mve->quick_encoding || mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + frame = (guint16 *) GST_BUFFER_DATA (mve->last_frame); + + x1 = enc->x - 128; + x2 = enc->x + 127; + if (x1 < 0) + x1 = 0; + if (x2 + 8 > mve->width) + x2 = mve->width - 8; + + y1 = enc->y - 128; + y2 = enc->y + 127; + if (y1 < 0) + y1 = 0; + if (y2 + 8 > mve->height) + y2 = mve->height - 8; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (yi = y1; yi <= y2; ++yi) { + gint yoff = yi * mve->width; + + for (xi = x1; xi <= x2; ++xi) { + err = mve_block_error (mve, src, frame + yoff + xi, apx->error); + if (err < apx->error) { + apx->data[0] = xi - enc->x; + apx->data[1] = yi - enc->y; + mve_store_block (mve, frame + yoff + xi, apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x7a (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for 2x2 solid blocks (6 bytes) */ + guint16 p[2]; + guint16 mean; + guint32 e1, e2; + guint x, y; + guint8 r[2], g[2], b[2], rb, gb, bb; + guint16 *block = apx->block; + guint16 mask = 0x0001; + guint16 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q2available) { + enc->q2error = + mve_quantize (enc->mve, src, 8, 8, 0, 2, enc->q2block, enc->q2colors); + enc->q2available = TRUE; + } + + /* p[0] & 0x8000 */ + GST_WRITE_UINT16_LE (&apx->data[0], enc->q2colors[0] | 0x8000); + GST_WRITE_UINT16_LE (&apx->data[2], enc->q2colors[1]); + + for (x = 0; x < 2; ++x) { + r[x] = MVE_RVAL (enc->q2colors[x]); + g[x] = MVE_GVAL (enc->q2colors[x]); + b[x] = MVE_BVAL (enc->q2colors[x]); + } + + /* calculate mean colors for each 2x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, mask <<= 1) { + p[0] = src[enc->mve->width]; + p[1] = src[enc->mve->width + 1]; + + rb = (MVE_RVAL (src[0]) + MVE_RVAL (src[1]) + MVE_RVAL (p[0]) + + MVE_RVAL (p[1]) + 2) / 4; + gb = (MVE_GVAL (src[0]) + MVE_GVAL (src[1]) + MVE_GVAL (p[0]) + + MVE_GVAL (p[1]) + 2) / 4; + bb = (MVE_BVAL (src[0]) + MVE_BVAL (src[1]) + MVE_BVAL (p[0]) + + MVE_BVAL (p[1]) + 2) / 4; + + e1 = mve_color_dist_rgb (rb, gb, bb, r[0], g[0], b[0]); + e2 = mve_color_dist_rgb (rb, gb, bb, r[1], g[1], b[1]); + + if (e1 > e2) { + mean = enc->q2colors[1]; + flags |= mask; + } else { + mean = enc->q2colors[0]; + } + + block[0] = block[1] = block[8] = block[9] = mean; + + src += 2; + block += 2; + } + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->data[4] = flags & 0x00FF; + apx->data[5] = (flags & 0xFF00) >> 8; + + apx->error = + mve_block_error_packed (enc->mve, src - enc->mve->width * 8, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x7b (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* generic 2-color encoding (12 bytes) */ + guint x, y; + guint8 *data = apx->data; + guint16 *block = apx->block; + + if (!enc->q2available) { + enc->q2error = + mve_quantize (enc->mve, src, 8, 8, 0, 2, enc->q2block, enc->q2colors); + enc->q2available = TRUE; + } + + memcpy (block, enc->q2block, 128); + + /* !(p[0] & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], enc->q2colors[0] & ~0x8000); + GST_WRITE_UINT16_LE (&data[2], enc->q2colors[1]); + data += 4; + + for (y = 0; y < 8; ++y) { + guint8 flags = 0; + + for (x = 0x01; x <= 0x80; x <<= 1) { + if (*block == enc->q2colors[1]) + flags |= x; + ++block; + } + *data++ = flags; + } + + apx->error = enc->q2error; + return apx->error; +} + +static guint32 +mve_encode_0x8a (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for top and bottom half (16 bytes) */ + guint16 cols[2]; + guint32 flags; + guint i, x, y, shifter; + guint16 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc->mve, src, 8, 4, i, 2, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 & 0x8000 && p2 & 0x8000 */ + GST_WRITE_UINT16_LE (&data[0], cols[0] | 0x8000); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, ++shifter) { + if (block[x] == cols[1]) + flags |= 1 << shifter; + } + block += 8; + } + data[4] = flags & 0x000000FF; + data[5] = (flags & 0x0000FF00) >> 8; + data[6] = (flags & 0x00FF0000) >> 16; + data[7] = (flags & 0xFF000000) >> 24; + data += 8; + } + + return apx->error; +} + +static guint32 +mve_encode_0x8b (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for left and right half (16 bytes) */ + guint16 cols[2]; + guint32 flags; + guint i, x, y, shifter; + guint16 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc->mve, src, 4, 8, i, 2, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 & 0x8000 && !(p2 & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], (cols[0] & ~0x8000) | (0x8000 * (i ^ 1))); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, ++shifter) { + if (block[x] == cols[1]) + flags |= 1 << shifter; + } + block += 8; + } + + data[4] = flags & 0x000000FF; + data[5] = (flags & 0x0000FF00) >> 8; + data[6] = (flags & 0x00FF0000) >> 16; + data[7] = (flags & 0xFF000000) >> 24; + data += 8; + block = apx->block + 4; + } + + return apx->error; +} + +static guint32 +mve_encode_0x8c (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for each 4x4 quadrant (24 bytes) */ + guint16 cols[2]; + guint16 flags; + guint i, x, y, shifter; + guint16 *block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 4; ++i) { + apx->error += + mve_quantize (enc->mve, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1), 2, + apx->block, cols); + + /* !(p0 & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], cols[0] & ~0x8000); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + + block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + flags = 0; + shifter = 0; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, ++shifter) { + if (block[x] == cols[1]) + flags |= 1 << shifter; + } + block += 8; + } + + data[4] = flags & 0x00FF; + data[5] = (flags & 0xFF00) >> 8; + data += 6; + } + + return apx->error; +} + +static guint32 +mve_encode_0x9a (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 2x2 solid blocks (12 bytes) */ + guint16 p[2]; + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint16 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc->mve, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* !(p[0] & 0x8000) && p[2] & 0x8000 */ + GST_WRITE_UINT16_LE (&apx->data[0], enc->q4colors[0] & ~0x8000); + GST_WRITE_UINT16_LE (&apx->data[2], enc->q4colors[1]); + GST_WRITE_UINT16_LE (&apx->data[4], enc->q4colors[2] | 0x8000); + GST_WRITE_UINT16_LE (&apx->data[6], enc->q4colors[3]); + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->q4colors[i]); + g[i] = MVE_GVAL (enc->q4colors[i]); + b[i] = MVE_BVAL (enc->q4colors[i]); + } + + /* calculate mean colors for each 2x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + p[0] = src[enc->mve->width]; + p[1] = src[enc->mve->width + 1]; + + rb = (MVE_RVAL (src[0]) + MVE_RVAL (src[1]) + MVE_RVAL (p[0]) + + MVE_RVAL (p[1]) + 2) / 4; + gb = (MVE_GVAL (src[0]) + MVE_GVAL (src[1]) + MVE_GVAL (p[0]) + + MVE_GVAL (p[1]) + 2) / 4; + bb = (MVE_BVAL (src[0]) + MVE_BVAL (src[1]) + MVE_BVAL (p[0]) + + MVE_BVAL (p[1]) + 2) / 4; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[1] = block[8] = block[9] = enc->q4colors[mean]; + + src += 2; + block += 2; + } + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->data[8] = flags & 0x000000FF; + apx->data[9] = (flags & 0x0000FF00) >> 8; + apx->data[10] = (flags & 0x00FF0000) >> 16; + apx->data[11] = (flags & 0xFF000000) >> 24; + + apx->error = + mve_block_error_packed (enc->mve, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9b (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 2x1 solid blocks (16 bytes) */ + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint8 *data = apx->data; + guint16 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc->mve, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* p[0] & 0x8000 && !(p[2] & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], enc->q4colors[0] | 0x8000); + GST_WRITE_UINT16_LE (&data[2], enc->q4colors[1]); + GST_WRITE_UINT16_LE (&data[4], enc->q4colors[2] & ~0x8000); + GST_WRITE_UINT16_LE (&data[6], enc->q4colors[3]); + data += 8; + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->q4colors[i]); + g[i] = MVE_GVAL (enc->q4colors[i]); + b[i] = MVE_BVAL (enc->q4colors[i]); + } + + /* calculate mean colors for each 2x1 block and map to global colors */ + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + rb = (MVE_RVAL (src[0]) + MVE_RVAL (src[1]) + 1) / 2; + gb = (MVE_GVAL (src[0]) + MVE_GVAL (src[1]) + 1) / 2; + bb = (MVE_BVAL (src[0]) + MVE_BVAL (src[1]) + 1) / 2; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[1] = enc->q4colors[mean]; + + src += 2; + block += 2; + } + + if ((y == 3) || (y == 7)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + + flags = 0; + shifter = 0; + } + + src += enc->mve->width - 8; + } + + apx->error = + mve_block_error_packed (enc->mve, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9c (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 1x2 solid blocks (16 bytes) */ + guint16 p2; + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint8 *data = apx->data; + guint16 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc->mve, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* p[0] & 0x8000 && p[2] & 0x8000 */ + GST_WRITE_UINT16_LE (&data[0], enc->q4colors[0] | 0x8000); + GST_WRITE_UINT16_LE (&data[2], enc->q4colors[1]); + GST_WRITE_UINT16_LE (&data[4], enc->q4colors[2] | 0x8000); + GST_WRITE_UINT16_LE (&data[6], enc->q4colors[3]); + data += 8; + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->q4colors[i]); + g[i] = MVE_GVAL (enc->q4colors[i]); + b[i] = MVE_BVAL (enc->q4colors[i]); + } + + /* calculate mean colors for each 1x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + p2 = src[enc->mve->width]; + rb = (MVE_RVAL (src[0]) + MVE_RVAL (p2) + 1) / 2; + gb = (MVE_GVAL (src[0]) + MVE_GVAL (p2) + 1) / 2; + bb = (MVE_BVAL (src[0]) + MVE_BVAL (p2) + 1) / 2; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[8] = enc->q4colors[mean]; + + ++src; + ++block; + } + + if ((y == 1) || (y == 3)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + + flags = 0; + shifter = 0; + } + + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->error = + mve_block_error_packed (enc->mve, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9d (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* generic 4-color encoding (24 bytes) */ + guint32 flags = 0; + guint shifter = 0; + guint i, x, y; + guint8 *data = apx->data; + guint16 *block = apx->block; + + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc->mve, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + memcpy (block, enc->q4block, 128); + + /* !(p[0] & 0x8000) && !(p[2] & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], enc->q4colors[0] & ~0x8000); + GST_WRITE_UINT16_LE (&data[2], enc->q4colors[1]); + GST_WRITE_UINT16_LE (&data[4], enc->q4colors[2] & ~0x8000); + GST_WRITE_UINT16_LE (&data[6], enc->q4colors[3]); + data += 8; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + + for (i = 0; i < 3; ++i) { + if (*block == enc->q4colors[i]) + break; + } + + flags |= i << shifter; + ++block; + } + + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data += 2; + shifter = 0; + flags = 0; + } + + apx->error = enc->q4error; + return apx->error; +} + +static guint32 +mve_encode_0xaa (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for top and bottom half (32 bytes) */ + guint16 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint16 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc->mve, src, 8, 4, i, 4, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 & 0x8000 && p4 & 0x8000 */ + GST_WRITE_UINT16_LE (&data[0], cols[0] | 0x8000); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + GST_WRITE_UINT16_LE (&data[4], cols[2]); + GST_WRITE_UINT16_LE (&data[6], cols[3]); + data += 8; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == cols[j]) + break; + } + flags |= j << shifter; + } + block += 8; + + if ((y == 1) || (y == 3)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + flags = 0; + shifter = 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0xab (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for left and right half (32 bytes) */ + guint16 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint16 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc->mve, src, 4, 8, i, 4, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 & 0x8000 && !(p4 & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], (cols[0] & ~0x8000) | (0x8000 * (i ^ 1))); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + GST_WRITE_UINT16_LE (&data[4], cols[2]); + GST_WRITE_UINT16_LE (&data[6], cols[3]); + data += 8; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == cols[j]) + break; + } + flags |= j << shifter; + } + block += 8; + + if ((y == 3) || (y == 7)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + flags = 0; + shifter = 0; + } + } + block = apx->block + 4; + } + + return apx->error; +} + +static guint32 +mve_encode_0xac (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for each 4x4 quadrant (48 bytes) */ + guint16 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint16 *block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 4; ++i) { + apx->error += + mve_quantize (enc->mve, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1), 4, + apx->block, cols); + + /* !(p0 & 0x8000) */ + GST_WRITE_UINT16_LE (&data[0], cols[0] & ~0x8000); + GST_WRITE_UINT16_LE (&data[2], cols[1]); + GST_WRITE_UINT16_LE (&data[4], cols[2]); + GST_WRITE_UINT16_LE (&data[6], cols[3]); + + block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + flags = 0; + shifter = 0; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == cols[j]) + break; + } + flags |= j << shifter; + } + block += 8; + } + + data[8] = flags & 0x000000FF; + data[9] = (flags & 0x0000FF00) >> 8; + data[10] = (flags & 0x00FF0000) >> 16; + data[11] = (flags & 0xFF000000) >> 24; + data += 12; + } + + return apx->error; +} + +static guint32 +mve_encode_0xb (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 64-color encoding (each pixel in block is a different color) (128 bytes) */ + guint i; + + apx->error = 0; + + mve_store_block (enc->mve, src, apx->block); + for (i = 0; i < 64; ++i) + GST_WRITE_UINT16_LE (&apx->data[i << 1], apx->block[i]); + + return 0; +} + +static guint32 +mve_encode_0xc (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 16-color block encoding: each 2x2 block is a different color (32 bytes) */ + guint i = 0, x, y; + const guint w = enc->mve->width; + guint16 r, g, b; + + /* calculate median color for each 2x2 block */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x) { + r = MVE_RVAL (src[0]) + MVE_RVAL (src[1]) + + MVE_RVAL (src[w]) + MVE_RVAL (src[w + 1]) + 2; + g = MVE_GVAL (src[0]) + MVE_GVAL (src[1]) + + MVE_GVAL (src[w]) + MVE_GVAL (src[w + 1]) + 2; + b = MVE_BVAL (src[0]) + MVE_BVAL (src[1]) + + MVE_BVAL (src[w]) + MVE_BVAL (src[w + 1]) + 2; + apx->block[i] = apx->block[i + 1] = apx->block[i + 2] = + apx->block[i + 3] = MVE_COL (r >> 2, g >> 2, b >> 2); + GST_WRITE_UINT16_LE (&apx->data[i >> 1], apx->block[i]); + + i += 4; + src += 2; + } + src += (w * 2) - 8; + } + + apx->error = mve_block_error_packed (enc->mve, src - (8 * w), apx->block); + return apx->error; +} + +static guint32 +mve_encode_0xd (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 4-color block encoding: each 4x4 block is a different color (8 bytes) */ + guint i, x, y; + guint16 *block; + + /* calculate median color for each 4x4 block */ + for (i = 0; i < 4; ++i) { + guint16 median = + mve_median_sub (enc->mve, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1)); + + block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x) { + block[x] = median; + } + block += 8; + } + + GST_WRITE_UINT16_LE (&apx->data[i << 1], median); + } + + apx->error = mve_block_error_packed (enc->mve, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0xe (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 1-color encoding: the whole block is 1 solid color (2 bytes) */ + guint i; + guint16 median = mve_median (enc->mve, src); + + for (i = 0; i < 64; ++i) + apx->block[i] = median; + + apx->error = mve_block_error_packed (enc->mve, src, apx->block); + GST_WRITE_UINT16_LE (apx->data, median); + + return apx->error; +} + +static guint32 +mve_encode_0xf (GstMveEncoderData * enc, const guint16 * src, + GstMveApprox * apx) +{ + /* 2 colors dithered encoding (4 bytes) */ + guint i, x, y; + guint32 r[2] = { 0 }, g[2] = { + 0}, b[2] = { + 0}; + guint16 col[2]; + + /* find medians for both colors */ + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; x += 2) { + guint16 p = src[x]; + + r[y & 1] += MVE_RVAL (p); + g[y & 1] += MVE_GVAL (p); + b[y & 1] += MVE_BVAL (p); + + p = src[x + 1]; + r[(y & 1) ^ 1] += MVE_RVAL (p); + g[(y & 1) ^ 1] += MVE_GVAL (p); + b[(y & 1) ^ 1] += MVE_BVAL (p); + } + src += enc->mve->width; + } + col[0] = MVE_COL ((r[0] + 16) / 32, (g[0] + 16) / 32, (b[0] + 16) / 32); + col[1] = MVE_COL ((r[1] + 16) / 32, (g[1] + 16) / 32, (b[1] + 16) / 32); + + /* store block after encoding */ + for (i = 0, y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x) { + apx->block[i++] = col[y & 1]; + apx->block[i++] = col[(y & 1) ^ 1]; + } + } + + GST_WRITE_UINT16_LE (&apx->data[0], col[0]); + GST_WRITE_UINT16_LE (&apx->data[2], col[1]); + apx->error = mve_block_error_packed (enc->mve, + src - (8 * enc->mve->width), apx->block); + return apx->error; +} + +/* all available encodings in the preferred order, + i.e. in ascending encoded size */ +static const GstMveEncoding mve_encodings[] = { + {0x1, 0, mve_encode_0x1}, + {0x0, 0, mve_encode_0x0}, + {0x3, 1, mve_encode_0x3}, + {0x4, 1, mve_encode_0x4}, + {0x2, 1, mve_encode_0x2}, + {0xe, 2, mve_encode_0xe}, + {0x5, 2, mve_encode_0x5}, + {0xf, 4, mve_encode_0xf}, + {0x7, 6, mve_encode_0x7a}, + {0xd, 8, mve_encode_0xd}, + {0x7, 12, mve_encode_0x7b}, + {0x9, 12, mve_encode_0x9a}, + {0x9, 16, mve_encode_0x9b}, + {0x9, 16, mve_encode_0x9c}, + {0x8, 16, mve_encode_0x8a}, + {0x8, 16, mve_encode_0x8b}, + {0x8, 24, mve_encode_0x8c}, + {0x9, 24, mve_encode_0x9d}, + {0xc, 32, mve_encode_0xc}, + {0xa, 32, mve_encode_0xaa}, + {0xa, 32, mve_encode_0xab}, + {0xa, 48, mve_encode_0xac}, + {0xb, 128, mve_encode_0xb} +}; + +static gboolean +mve_reorder_solution (GArray ** solution, guint16 n) +{ + /* do a binary search to find the position to reinsert the modified element */ + /* the block we need to reconsider is always at position 0 */ + /* return TRUE if this block only has 1 encoding left and can be dropped */ + if (mve_comp_solution (&solution[0], &solution[1]) <= 0) + return FALSE; /* already sorted */ + + else if (solution[0]->len <= 1) + /* drop this element from further calculations since we cannot improve here */ + return TRUE; + + else { + /* we know the error value can only get worse, so we can actually start at 1 */ + guint lower = 1; + guint upper = n - 1; + gint cmp; + guint idx = 0; + + while (upper > lower) { + idx = lower + ((upper - lower) / 2); + + cmp = mve_comp_solution (&solution[0], &solution[idx]); + + if (cmp < 0) { + upper = idx; + } else if (cmp > 0) { + lower = ++idx; + } else { + upper = lower = idx; + } + } + + if (idx > 0) { + /* rearrange array members in new order */ + GArray *a = solution[0]; + + memcpy (&solution[0], &solution[1], sizeof (GArray *) * idx); + solution[idx] = a; + } + } + return FALSE; +} + +static guint32 +gst_mve_find_solution (GArray ** approx, guint16 n, guint32 size, guint16 max) +{ + /* build an array of approximations we can shuffle around */ + GstMveApprox *sol_apx; + GArray **solution = g_malloc (sizeof (GArray *) * n); + GArray **current = solution; + + memcpy (solution, approx, sizeof (GArray *) * n); + + qsort (solution, n, sizeof (GArray *), mve_comp_solution); + + do { + /* array is now sorted by error of the next to optimal approximation; + drop optimal approximation for the best block */ + + /* unable to reduce size further */ + if (current[0]->len <= 1) + break; + + sol_apx = &g_array_index (current[0], GstMveApprox, current[0]->len - 1); + size -= mve_encodings[sol_apx->type].size; + g_array_remove_index_fast (current[0], current[0]->len - 1); + sol_apx = &g_array_index (current[0], GstMveApprox, current[0]->len - 1); + size += mve_encodings[sol_apx->type].size; + + if (mve_reorder_solution (current, n)) { + ++current; + --n; + } + } while (size > max); + + g_free (solution); + + return size; +} + +GstFlowReturn +mve_encode_frame16 (GstMveMux * mve, GstBuffer * frame, guint16 max_data) +{ + guint16 *src; + GstFlowReturn ret = GST_FLOW_ERROR; + guint8 *cm = mve->chunk_code_map; + GByteArray *pstream; + GArray **approx; + GstMveApprox apx; + GstMveEncoderData enc; + const guint16 blocks = (mve->width * mve->height) / 64; + guint32 encoded_size = 2; /* two initial bytes for the offset */ + guint i = 0, x, y; + + src = (guint16 *) GST_BUFFER_DATA (frame); + + approx = g_malloc (sizeof (GArray *) * blocks); + + enc.mve = mve; + + for (enc.y = 0; enc.y < mve->height; enc.y += 8) { + for (enc.x = 0; enc.x < mve->width; enc.x += 8) { + guint32 err, last_err = MVE_APPROX_MAX_ERROR; + guint type = 0; + guint best = 0; + + enc.q2available = enc.q4available = FALSE; + approx[i] = g_array_new (FALSE, FALSE, sizeof (GstMveApprox)); + + do { + err = mve_encodings[type].approx (&enc, src, &apx); + + if (err < last_err) { + apx.type = best = type; + g_array_append_val (approx[i], apx); + last_err = err; + } + + ++type; + } while (last_err != 0); + + encoded_size += mve_encodings[best].size; + ++i; + src += 8; + } + src += 7 * mve->width; + } + + /* find best solution with size constraints */ + GST_DEBUG_OBJECT (mve, "encoded frame %u in %ld bytes (lossless)", + mve->video_frames + 1, encoded_size); + +#if 0 + /* FIXME */ + src = (guint16 *) GST_BUFFER_DATA (frame); + for (i = 0, y = 0; y < mve->height; y += 8) { + for (x = 0; x < mve->width; x += 8, ++i) { + GstMveApprox *sol = + &g_array_index (approx[i], GstMveApprox, approx[i]->len - 1); + guint opcode = mve_encodings[sol->type].opcode; + guint j, k; + + if (sol->error > 0) + GST_WARNING_OBJECT (mve, "error is %lu for %d/%d (0x%x)", sol->error, x, + y, opcode); + + for (j = 0; j < 8; ++j) { + guint16 *o = src + j * mve->width; + guint16 *c = sol->block + j * 8; + + if (memcmp (o, c, 16)) { + GST_WARNING_OBJECT (mve, "opcode 0x%x (type %d) at %d/%d, line %d:", + opcode, sol->type, x, y, j + 1); + for (k = 0; k < 8; ++k) { + o = src + k * mve->width; + c = sol->block + k * 8; + GST_WARNING_OBJECT (mve, + "%d should be: %4d %4d %4d %4d %4d %4d %4d %4d", k, o[0], + o[1], o[2], o[3], o[4], o[5], o[6], o[7]); + GST_WARNING_OBJECT (mve, + "%d but is : %4d %4d %4d %4d %4d %4d %4d %4d", k, c[0], + c[1], c[2], c[3], c[4], c[5], c[6], c[7]); + } + } + } + src += 8; + } + src += 7 * mve->width; + } +#endif + + if (encoded_size > max_data) { + encoded_size = + gst_mve_find_solution (approx, blocks, encoded_size, max_data); + if (encoded_size > max_data) { + GST_ERROR_OBJECT (mve, "unable to compress frame to less than %d bytes", + encoded_size); + for (i = 0; i < blocks; ++i) + g_array_free (approx[i], TRUE); + + goto done; + } + GST_DEBUG_OBJECT (mve, "compressed frame %u to %ld bytes (lossy)", + mve->video_frames + 1, encoded_size); + } + + mve->chunk_video = g_byte_array_sized_new (encoded_size); + /* reserve two bytes for the offset pointer we'll fill in later */ + g_byte_array_set_size (mve->chunk_video, 2); + + pstream = g_byte_array_new (); + + /* encode */ + src = (guint16 *) GST_BUFFER_DATA (frame); + for (i = 0, y = 0; y < mve->height; y += 8) { + for (x = 0; x < mve->width; x += 8, ++i) { + GstMveApprox *sol = + &g_array_index (approx[i], GstMveApprox, approx[i]->len - 1); + guint opcode = mve_encodings[sol->type].opcode; + GByteArray *dest; + + if (opcode >= 0x2 && opcode <= 0x4) + dest = pstream; + else + dest = mve->chunk_video; + + g_byte_array_append (dest, sol->data, mve_encodings[sol->type].size); + + if (i & 1) { + *cm |= opcode << 4; + ++cm; + } else + *cm = opcode; + + /* modify the frame to match the image we actually encoded */ + if (sol->error > 0) + mve_restore_block (mve, src, sol->block); + + src += 8; + g_array_free (approx[i], TRUE); + } + src += 7 * mve->width; + } + + /* now update the offset */ + GST_WRITE_UINT16_LE (mve->chunk_video->data, mve->chunk_video->len); + g_byte_array_append (mve->chunk_video, pstream->data, pstream->len); + g_byte_array_free (pstream, TRUE); + + ret = GST_FLOW_OK; + +done: + g_free (approx); + + return ret; +} diff --git a/gst/mve/mvevideoenc8.c b/gst/mve/mvevideoenc8.c new file mode 100644 index 00000000..78e3eb17 --- /dev/null +++ b/gst/mve/mvevideoenc8.c @@ -0,0 +1,1733 @@ +/* + * Interplay MVE video encoder (8 bit) + * Copyright (C) 2006 Jens Granseuer <jensgr@gmx.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. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdlib.h> +#include <string.h> + +#include "mve.h" +#include "gstmvemux.h" + +typedef struct _GstMveEncoderData GstMveEncoderData; +typedef struct _GstMveEncoding GstMveEncoding; +typedef struct _GstMveApprox GstMveApprox; +typedef struct _GstMveQuant GstMveQuant; + +#define MVE_RMASK 0x00ff0000 +#define MVE_GMASK 0x0000ff00 +#define MVE_BMASK 0x000000ff +#define MVE_RSHIFT 16 +#define MVE_GSHIFT 8 +#define MVE_BSHIFT 0 + +#define MVE_RVAL(p) (((p) & MVE_RMASK) >> MVE_RSHIFT) +#define MVE_GVAL(p) (((p) & MVE_GMASK) >> MVE_GSHIFT) +#define MVE_BVAL(p) (((p) & MVE_BMASK) >> MVE_BSHIFT) +#define MVE_COL(r,g,b) (((r) << MVE_RSHIFT) | ((g) << MVE_GSHIFT) | ((b) << MVE_BSHIFT)) + +struct _GstMveEncoderData +{ + GstMveMux *mve; + /* current position in frame */ + guint16 x, y; + + /* palette for current frame */ + const guint32 *palette; + + /* commonly used quantization results + (2 and 4 colors) for the current block */ + guint8 q2block[64]; + guint8 q2colors[2]; + guint32 q2error; + gboolean q2available; + + guint8 q4block[64]; + guint8 q4colors[4]; + guint32 q4error; + gboolean q4available; +}; + +struct _GstMveEncoding +{ + guint8 opcode; + guint8 size; + guint32 (*approx) (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * res); +}; + +#define MVE_APPROX_MAX_ERROR G_MAXUINT32 + +struct _GstMveApprox +{ + guint32 error; + guint8 type; + guint8 data[64]; /* max 64 bytes encoded per block */ + guint8 block[64]; /* block in final image */ +}; + +struct _GstMveQuant +{ + guint32 col; + guint16 r_total, g_total, b_total; + guint8 r, g, b; + guint8 hits, hits_last; + guint32 max_error; + guint32 max_miss; +}; + +#define mve_median(mve, src) mve_median_sub ((mve), (src), 8, 8, 0) +#define mve_color_dist(c1, c2) \ + mve_color_dist_rgb (MVE_RVAL (c1), MVE_GVAL (c1), MVE_BVAL (c1), \ + MVE_RVAL (c2), MVE_GVAL (c2), MVE_BVAL (c2)); +#define mve_color_dist2(c, r, g, b) \ + mve_color_dist_rgb (MVE_RVAL (c), MVE_GVAL (c), MVE_BVAL (c), (r), (g), (b)) + + +/* comparison function for qsort() */ +static int +mve_comp_solution (const void *a, const void *b) +{ + const GArray *aa = *((GArray **) a); + const GArray *bb = *((GArray **) b); + + if (aa->len <= 1) + return G_MAXINT; + else if (bb->len <= 1) + return G_MININT; + else + return g_array_index (aa, GstMveApprox, aa->len - 2).error - + g_array_index (bb, GstMveApprox, bb->len - 2).error; +} + +static inline guint32 +mve_color_dist_rgb (guint8 r1, guint8 g1, guint8 b1, + guint8 r2, guint8 g2, guint8 b2) +{ + /* euclidean distance (minus sqrt) */ + gint dr = r1 - r2; + gint dg = g1 - g2; + gint db = b1 - b2; + + return dr * dr + dg * dg + db * db; +} + +static guint8 +mve_find_pal_color (const guint32 * pal, guint32 col) +{ + /* find the closest matching color in the palette */ + guint i; + guint8 best = 0; + const guint8 r = MVE_RVAL (col), g = MVE_GVAL (col), b = MVE_BVAL (col); + guint32 ebest = MVE_APPROX_MAX_ERROR; + + for (i = 0; i < MVE_PALETTE_COUNT; ++i, ++pal) { + guint32 e = mve_color_dist2 (*pal, r, g, b); + + if (e < ebest) { + ebest = e; + best = i; + + if (ebest == 0) + break; + } + } + + return best; +} + +static guint8 +mve_find_pal_color2 (const guint32 * pal, const guint8 * subset, guint32 col, + guint size) +{ + /* find the closest matching color in the partial indexed palette */ + guint i; + guint8 best = 0; + const guint8 r = MVE_RVAL (col), g = MVE_GVAL (col), b = MVE_BVAL (col); + guint32 ebest = MVE_APPROX_MAX_ERROR; + + for (i = 0; i < size; ++i) { + guint32 e = mve_color_dist2 (pal[subset[i]], r, g, b); + + if (e < ebest) { + ebest = e; + best = subset[i]; + + if (ebest == 0) + break; + } + } + + return best; +} + +static void +mve_map_to_palette (const GstMveEncoderData * enc, const guint8 * colors, + const guint8 * data, guint8 * dest, guint w, guint h, guint ncols) +{ + guint x, y; + + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + dest[x] = + mve_find_pal_color2 (enc->palette, colors, enc->palette[data[x]], + ncols); + } + data += enc->mve->width; + dest += 8; + } +} + +/* compute average color in a sub-block */ +static guint8 +mve_median_sub (const GstMveEncoderData * enc, const guint8 * src, guint w, + guint h, guint n) +{ + guint x, y; + const guint max = w * h, max2 = max >> 1; + guint32 r_total = max2, g_total = max2, b_total = max2; + + src += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * enc->mve->width); + + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + guint32 p = enc->palette[src[x]]; + + r_total += MVE_RVAL (p); + g_total += MVE_GVAL (p); + b_total += MVE_BVAL (p); + } + src += enc->mve->width; + } + + return mve_find_pal_color (enc->palette, + MVE_COL (r_total / max, g_total / max, b_total / max)); +} + +static void +mve_quant_init (const GstMveEncoderData * enc, GstMveQuant * q, + guint n_clusters, const guint8 * data, guint w, guint h) +{ + guint i; + guint x, y; + guint32 cols[4]; + guint16 val[2]; + + /* init first cluster with lowest (darkest), second with highest (lightest) + color. if we need 4 clusters, fill in first and last color in the block + and hope they make for a good distribution */ + cols[0] = cols[1] = cols[2] = enc->palette[data[0]]; + cols[3] = enc->palette[data[(h - 1) * enc->mve->width + w - 1]]; + + /* favour red over green and blue */ + val[0] = val[1] = + (MVE_RVAL (cols[0]) << 1) + MVE_GVAL (cols[0]) + MVE_BVAL (cols[0]); + + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + guint32 c = enc->palette[data[x]]; + + if ((c != cols[0]) && (c != cols[1])) { + guint v = (MVE_RVAL (c) << 1) + MVE_GVAL (c) + MVE_BVAL (c); + + if (v < val[0]) { + val[0] = v; + cols[0] = c; + } else if (v > val[1]) { + val[1] = v; + cols[1] = c; + } + } + } + data += enc->mve->width; + } + + for (i = 0; i < n_clusters; ++i) { + q[i].col = cols[i]; + q[i].r = MVE_RVAL (cols[i]); + q[i].g = MVE_GVAL (cols[i]); + q[i].b = MVE_BVAL (cols[i]); + q[i].r_total = q[i].g_total = q[i].b_total = 0; + q[i].hits = q[i].hits_last = 0; + q[i].max_error = 0; + q[i].max_miss = 0; + } +} + +static gboolean +mve_quant_update_clusters (GstMveQuant * q, guint n_clusters) +{ + gboolean changed = FALSE; + guint i; + + for (i = 0; i < n_clusters; ++i) { + if (q[i].hits > 0) { + guint32 means = MVE_COL ((q[i].r_total + q[i].hits / 2) / q[i].hits, + (q[i].g_total + q[i].hits / 2) / q[i].hits, + (q[i].b_total + q[i].hits / 2) / q[i].hits); + + if ((means != q[i].col) || (q[i].hits != q[i].hits_last)) + changed = TRUE; + + q[i].col = means; + q[i].r_total = q[i].g_total = q[i].b_total = 0; + } else { + guint j; + guint32 max_err = 0; + GstMveQuant *worst = NULL; + + /* try to replace unused cluster with a better representative */ + for (j = 0; j < n_clusters; ++j) { + if (q[j].max_error > max_err) { + worst = &q[j]; + max_err = worst->max_error; + } + } + if (worst) { + q[i].col = worst->max_miss; + worst->max_error = 0; + changed = TRUE; + } + } + + q[i].r = MVE_RVAL (q[i].col); + q[i].g = MVE_GVAL (q[i].col); + q[i].b = MVE_BVAL (q[i].col); + q[i].hits_last = q[i].hits; + q[i].hits = 0; + } + for (i = 0; i < n_clusters; ++i) { + q[i].max_error = 0; + } + + return changed; +} + +/* quantize a sub-block using a k-means algorithm */ +static guint32 +mve_quantize (const GstMveEncoderData * enc, const guint8 * src, + guint w, guint h, guint n, guint ncols, guint8 * dest, guint8 * cols) +{ + guint x, y, i; + GstMveQuant q[4]; + const guint8 *data; + guint32 error; + + g_assert (n <= 4 && ncols <= 4); + + src += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * enc->mve->width); + dest += ((n * w) % 8) + (((n * (8 - h)) / (12 - w)) * h * 8); + + mve_quant_init (enc, q, ncols, src, w, h); + + do { + data = src; + error = 0; + + /* for each pixel find the closest cluster */ + for (y = 0; y < h; ++y) { + for (x = 0; x < w; ++x) { + guint32 c = enc->palette[data[x]]; + guint8 r = MVE_RVAL (c), g = MVE_GVAL (c), b = MVE_BVAL (c); + guint32 minerr = MVE_APPROX_MAX_ERROR, err; + GstMveQuant *best = NULL; + + for (i = 0; i < ncols; ++i) { + err = mve_color_dist_rgb (r, g, b, q[i].r, q[i].g, q[i].b); + + if (err < minerr) { + minerr = err; + best = &q[i]; + } + } + + ++best->hits; + best->r_total += r; + best->g_total += g; + best->b_total += b; + + if (minerr > best->max_error) { + best->max_error = minerr; + best->max_miss = c; + } + + error += minerr; + } + data += enc->mve->width; + } + } while (mve_quant_update_clusters (q, ncols)); + + /* fill cols array with result colors */ + for (i = 0; i < ncols; ++i) + cols[i] = mve_find_pal_color (enc->palette, q[i].col); + + /* make sure we have unique colors in slots 0/1 and 2/3 */ + if (cols[0] == cols[1]) + ++cols[1]; + if ((ncols > 2) && (cols[2] == cols[3])) + ++cols[3]; + + /* generate the resulting quantized block */ + mve_map_to_palette (enc, cols, src, dest, w, h, ncols); + + return error; +} + +static guint32 +mve_block_error (const GstMveEncoderData * enc, const guint8 * b1, + const guint8 * b2, guint32 threshold) +{ + /* compute error between two blocks in a frame */ + guint32 e = 0; + guint x, y; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + e += mve_color_dist (enc->palette[*b1], enc->palette[*b2]); + + /* using a threshold to return early gives a huge performance bonus */ + if (e >= threshold) + return MVE_APPROX_MAX_ERROR; + ++b1; + ++b2; + } + + b1 += enc->mve->width - 8; + b2 += enc->mve->width - 8; + } + + return e; +} + +static guint32 +mve_block_error_packed (const GstMveEncoderData * enc, const guint8 * block, + const guint8 * scratch) +{ + /* compute error between a block in a frame and a (continuous) scratch pad */ + guint32 e = 0; + guint x, y; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + guint32 c1 = enc->palette[block[x]], c2 = enc->palette[scratch[x]]; + + e += mve_color_dist (c1, c2); + } + block += enc->mve->width; + scratch += 8; + } + + return e; +} + +static void +mve_store_block (const GstMveMux * mve, const guint8 * block, guint8 * scratch) +{ + /* copy block from frame to a (continuous) scratch pad */ + guint y; + + for (y = 0; y < 8; ++y) { + memcpy (scratch, block, 8); + block += mve->width; + scratch += 8; + } +} + +static void +mve_restore_block (const GstMveMux * mve, guint8 * block, + const guint8 * scratch) +{ + /* copy block from scratch pad to frame */ + guint y; + + for (y = 0; y < 8; ++y) { + memcpy (block, scratch, 8); + block += mve->width; + scratch += 8; + } +} + + +static guint32 +mve_try_vector (GstMveEncoderData * enc, const guint8 * src, + const guint8 * frame, gint pn, GstMveApprox * apx) +{ + /* try to locate a similar 8x8 block in the given frame using a motion vector */ + guint i; + gint dx, dy; + gint fx, fy; + guint32 err; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (i = 0; i < 256; ++i) { + if (i < 56) { + dx = 8 + (i % 7); + dy = i / 7; + } else { + dx = -14 + ((i - 56) % 29); + dy = 8 + ((i - 56) / 29); + } + + fx = enc->x + dx * pn; + fy = enc->y + dy * pn; + + if ((fx >= 0) && (fy >= 0) && (fx + 8 <= enc->mve->width) + && (fy + 8 <= enc->mve->height)) { + err = + mve_block_error (enc, src, frame + fy * enc->mve->width + fx, + apx->error); + if (err < apx->error) { + apx->data[0] = i; + mve_store_block (enc->mve, frame + fy * enc->mve->width + fx, + apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x0 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy a block from the last frame (0 bytes) */ + if (enc->mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + mve_store_block (enc->mve, + GST_BUFFER_DATA (enc->mve->last_frame) + + enc->y * enc->mve->width + enc->x, apx->block); + apx->error = mve_block_error_packed (enc, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x1 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy a block from the second to last frame (0 bytes) */ + if (enc->mve->second_last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + mve_store_block (enc->mve, + GST_BUFFER_DATA (enc->mve->second_last_frame) + + enc->y * enc->mve->width + enc->x, apx->block); + apx->error = mve_block_error_packed (enc, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x2 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy block from 2 frames ago using a motion vector (1 byte) */ + if (enc->mve->quick_encoding || enc->mve->second_last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + apx->error = mve_try_vector (enc, src, + GST_BUFFER_DATA (enc->mve->second_last_frame), 1, apx); + return apx->error; +} + +static guint32 +mve_encode_0x3 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy 8x8 block from current frame from an up/left block (1 byte) */ + if (enc->mve->quick_encoding) + return MVE_APPROX_MAX_ERROR; + + apx->error = mve_try_vector (enc, src, + src - enc->mve->width * enc->y - enc->x, -1, apx); + return apx->error; +} + + +static guint32 +mve_encode_0x4 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy a block from previous frame using a motion vector (-8/-8 to +7/+7) (1 byte) */ + const GstMveMux *mve = enc->mve; + guint32 err; + const guint8 *frame; + gint x1, x2, xi, y1, y2, yi; + + if (mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + frame = GST_BUFFER_DATA (mve->last_frame); + + x1 = enc->x - 8; + x2 = enc->x + 7; + if (x1 < 0) + x1 = 0; + else if (x2 + 8 > mve->width) + x2 = mve->width - 8; + + y1 = enc->y - 8; + y2 = enc->y + 7; + if (y1 < 0) + y1 = 0; + else if (y2 + 8 > mve->height) + y2 = mve->height - 8; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (yi = y1; yi <= y2; ++yi) { + guint yoff = yi * mve->width; + + for (xi = x1; xi <= x2; ++xi) { + err = mve_block_error (enc, src, frame + yoff + xi, apx->error); + if (err < apx->error) { + apx->data[0] = ((xi - enc->x + 8) & 0xF) | ((yi - enc->y + 8) << 4); + mve_store_block (mve, frame + yoff + xi, apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x5 (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* copy a block from previous frame using a motion vector + (-128/-128 to +127/+127) (2 bytes) */ + const GstMveMux *mve = enc->mve; + guint32 err; + const guint8 *frame; + gint x1, x2, xi, y1, y2, yi; + + if (mve->quick_encoding || mve->last_frame == NULL) + return MVE_APPROX_MAX_ERROR; + + frame = GST_BUFFER_DATA (mve->last_frame); + + x1 = enc->x - 128; + x2 = enc->x + 127; + if (x1 < 0) + x1 = 0; + if (x2 + 8 > mve->width) + x2 = mve->width - 8; + + y1 = enc->y - 128; + y2 = enc->y + 127; + if (y1 < 0) + y1 = 0; + if (y2 + 8 > mve->height) + y2 = mve->height - 8; + + apx->error = MVE_APPROX_MAX_ERROR; + + for (yi = y1; yi <= y2; ++yi) { + gint yoff = yi * mve->width; + + for (xi = x1; xi <= x2; ++xi) { + err = mve_block_error (enc, src, frame + yoff + xi, apx->error); + if (err < apx->error) { + apx->data[0] = xi - enc->x; + apx->data[1] = yi - enc->y; + mve_store_block (mve, frame + yoff + xi, apx->block); + apx->error = err; + if (err == 0) + return 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0x7a (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for 2x2 solid blocks (4 bytes) */ + guint32 pix[4]; + guint8 mean; + guint32 e1, e2; + guint x, y; + guint8 r[2], g[2], b[2], rb, gb, bb; + guint8 *block = apx->block; + guint16 mask = 0x0001; + guint16 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q2available) { + enc->q2error = + mve_quantize (enc, src, 8, 8, 0, 2, enc->q2block, enc->q2colors); + enc->q2available = TRUE; + } + + /* p0 > p1 */ + apx->data[0] = MAX (enc->q2colors[0], enc->q2colors[1]); + apx->data[1] = MIN (enc->q2colors[0], enc->q2colors[1]); + + for (x = 0; x < 2; ++x) { + r[x] = MVE_RVAL (enc->palette[apx->data[x]]); + g[x] = MVE_GVAL (enc->palette[apx->data[x]]); + b[x] = MVE_BVAL (enc->palette[apx->data[x]]); + } + + /* calculate mean colors for each 2x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, mask <<= 1) { + pix[0] = enc->palette[src[0]]; + pix[1] = enc->palette[src[1]]; + pix[2] = enc->palette[src[enc->mve->width]]; + pix[3] = enc->palette[src[enc->mve->width + 1]]; + + rb = (MVE_RVAL (pix[0]) + MVE_RVAL (pix[1]) + MVE_RVAL (pix[2]) + + MVE_RVAL (pix[3]) + 2) / 4; + gb = (MVE_GVAL (pix[0]) + MVE_GVAL (pix[1]) + MVE_GVAL (pix[2]) + + MVE_GVAL (pix[3]) + 2) / 4; + bb = (MVE_BVAL (pix[0]) + MVE_BVAL (pix[1]) + MVE_BVAL (pix[2]) + + MVE_BVAL (pix[3]) + 2) / 4; + + e1 = mve_color_dist_rgb (rb, gb, bb, r[0], g[0], b[0]); + e2 = mve_color_dist_rgb (rb, gb, bb, r[1], g[1], b[1]); + + if (e1 > e2) { + mean = apx->data[1]; + flags |= mask; + } else { + mean = apx->data[0]; + } + + block[0] = block[1] = block[8] = block[9] = mean; + + src += 2; + block += 2; + } + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->data[2] = flags & 0x00FF; + apx->data[3] = (flags & 0xFF00) >> 8; + + apx->error = + mve_block_error_packed (enc, src - enc->mve->width * 8, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x7b (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* generic 2-color encoding (10 bytes) */ + guint x, y; + guint8 *data = apx->data; + guint8 *block = apx->block; + + if (!enc->q2available) { + enc->q2error = + mve_quantize (enc, src, 8, 8, 0, 2, enc->q2block, enc->q2colors); + enc->q2available = TRUE; + } + + memcpy (block, enc->q2block, 64); + + /* p0 <= p1 */ + data[0] = MIN (enc->q2colors[0], enc->q2colors[1]); + data[1] = MAX (enc->q2colors[0], enc->q2colors[1]); + data += 2; + + for (y = 0; y < 8; ++y) { + guint8 flags = 0; + + for (x = 0x01; x <= 0x80; x <<= 1) { + if (*block == apx->data[1]) + flags |= x; + ++block; + } + *data++ = flags; + } + + apx->error = enc->q2error; + return apx->error; +} + +static guint32 +mve_encode_0x8a (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for top and bottom half (12 bytes) */ + guint8 cols[2]; + guint32 flags; + guint i, x, y, shifter; + guint8 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc, src, 8, 4, i, 2, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 > p1 && p2 > p3 */ + data[0] = MAX (cols[0], cols[1]); + data[1] = MIN (cols[0], cols[1]); + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, ++shifter) { + if (block[x] == data[1]) + flags |= 1 << shifter; + } + block += 8; + } + data[2] = flags & 0x000000FF; + data[3] = (flags & 0x0000FF00) >> 8; + data[4] = (flags & 0x00FF0000) >> 16; + data[5] = (flags & 0xFF000000) >> 24; + data += 6; + } + + return apx->error; +} + +static guint32 +mve_encode_0x8b (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for left and right half (12 bytes) */ + guint8 cols[2]; + guint32 flags; + guint i, x, y, shifter; + guint8 *block = apx->block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc, src, 4, 8, i, 2, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 > p1 && p2 <= p3 */ + data[i] = MAX (cols[0], cols[1]); + data[i ^ 1] = MIN (cols[0], cols[1]); + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, ++shifter) { + if (block[x] == data[1]) + flags |= 1 << shifter; + } + block += 8; + } + + data[2] = flags & 0x000000FF; + data[3] = (flags & 0x0000FF00) >> 8; + data[4] = (flags & 0x00FF0000) >> 16; + data[5] = (flags & 0xFF000000) >> 24; + data += 6; + block = apx->block + 4; + } + + return apx->error; +} + +static guint32 +mve_encode_0x8c (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 2-color encoding for each 4x4 quadrant (16 bytes) */ + guint8 cols[2]; + guint16 flags; + guint i, x, y, shifter; + guint8 *block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 4; ++i) { + apx->error += + mve_quantize (enc, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1), 2, + apx->block, cols); + + /* p0 < p1 */ + if (i == 0) { + data[0] = MIN (cols[0], cols[1]); + data[1] = MAX (cols[0], cols[1]); + } else { + data[0] = cols[0]; + data[1] = cols[1]; + } + + block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + flags = 0; + shifter = 0; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, ++shifter) { + if (block[x] == data[1]) + flags |= 1 << shifter; + } + block += 8; + } + + data[2] = flags & 0x00FF; + data[3] = (flags & 0xFF00) >> 8; + data += 4; + } + + return apx->error; +} + +static guint32 +mve_encode_0x9a (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 2x2 solid blocks (8 bytes) */ + guint32 p[4]; + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint8 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* p0 <= p1 && p2 > p3 */ + apx->data[0] = MIN (enc->q4colors[0], enc->q4colors[1]); + apx->data[1] = MAX (enc->q4colors[0], enc->q4colors[1]); + apx->data[2] = MAX (enc->q4colors[2], enc->q4colors[3]); + apx->data[3] = MIN (enc->q4colors[2], enc->q4colors[3]); + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->palette[apx->data[i]]); + g[i] = MVE_GVAL (enc->palette[apx->data[i]]); + b[i] = MVE_BVAL (enc->palette[apx->data[i]]); + } + + /* calculate mean colors for each 2x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + p[0] = enc->palette[src[0]]; + p[1] = enc->palette[src[1]]; + p[2] = enc->palette[src[enc->mve->width]]; + p[3] = enc->palette[src[enc->mve->width + 1]]; + + rb = (MVE_RVAL (p[0]) + MVE_RVAL (p[1]) + MVE_RVAL (p[2]) + + MVE_RVAL (p[3]) + 2) / 4; + gb = (MVE_GVAL (p[0]) + MVE_GVAL (p[1]) + MVE_GVAL (p[2]) + + MVE_GVAL (p[3]) + 2) / 4; + bb = (MVE_BVAL (p[0]) + MVE_BVAL (p[1]) + MVE_BVAL (p[2]) + + MVE_BVAL (p[3]) + 2) / 4; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[1] = block[8] = block[9] = apx->data[mean]; + + src += 2; + block += 2; + } + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->data[4] = flags & 0x000000FF; + apx->data[5] = (flags & 0x0000FF00) >> 8; + apx->data[6] = (flags & 0x00FF0000) >> 16; + apx->data[7] = (flags & 0xFF000000) >> 24; + + apx->error = + mve_block_error_packed (enc, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9b (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 2x1 solid blocks (12 bytes) */ + guint32 p[2]; + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint8 *data = apx->data; + guint8 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* p0 > p1 && p2 <= p3 */ + data[0] = MAX (enc->q4colors[0], enc->q4colors[1]); + data[1] = MIN (enc->q4colors[0], enc->q4colors[1]); + data[2] = MIN (enc->q4colors[2], enc->q4colors[3]); + data[3] = MAX (enc->q4colors[2], enc->q4colors[3]); + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->palette[data[i]]); + g[i] = MVE_GVAL (enc->palette[data[i]]); + b[i] = MVE_BVAL (enc->palette[data[i]]); + } + data += 4; + + /* calculate mean colors for each 2x1 block and map to global colors */ + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + p[0] = enc->palette[src[0]]; + p[1] = enc->palette[src[1]]; + rb = (MVE_RVAL (p[0]) + MVE_RVAL (p[1]) + 1) / 2; + gb = (MVE_GVAL (p[0]) + MVE_GVAL (p[1]) + 1) / 2; + bb = (MVE_BVAL (p[0]) + MVE_BVAL (p[1]) + 1) / 2; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[1] = apx->data[mean]; + + src += 2; + block += 2; + } + + if ((y == 3) || (y == 7)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + + flags = 0; + shifter = 0; + } + + src += enc->mve->width - 8; + } + + apx->error = + mve_block_error_packed (enc, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9c (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for 1x2 solid blocks (12 bytes) */ + guint32 p[2]; + guint32 e, emin; + guint i, x, y, mean = 0; + guint8 r[4], g[4], b[4], rb, gb, bb; + guint8 *data = apx->data; + guint8 *block = apx->block; + guint shifter = 0; + guint32 flags = 0; + + /* calculate mean colors for the entire block */ + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + /* p0 > p1 && p2 > p3 */ + data[0] = MAX (enc->q4colors[0], enc->q4colors[1]); + data[1] = MIN (enc->q4colors[0], enc->q4colors[1]); + data[2] = MAX (enc->q4colors[2], enc->q4colors[3]); + data[3] = MIN (enc->q4colors[2], enc->q4colors[3]); + + for (i = 0; i < 4; ++i) { + r[i] = MVE_RVAL (enc->palette[data[i]]); + g[i] = MVE_GVAL (enc->palette[data[i]]); + b[i] = MVE_BVAL (enc->palette[data[i]]); + } + data += 4; + + /* calculate mean colors for each 1x2 block and map to global colors */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + p[0] = enc->palette[src[0]]; + p[1] = enc->palette[src[enc->mve->width]]; + rb = (MVE_RVAL (p[0]) + MVE_RVAL (p[1]) + 1) / 2; + gb = (MVE_GVAL (p[0]) + MVE_GVAL (p[1]) + 1) / 2; + bb = (MVE_BVAL (p[0]) + MVE_BVAL (p[1]) + 1) / 2; + + emin = MVE_APPROX_MAX_ERROR; + for (i = 0; i < 4; ++i) { + e = mve_color_dist_rgb (rb, gb, bb, r[i], g[i], b[i]); + if (e < emin) { + emin = e; + mean = i; + } + } + + flags |= mean << shifter; + block[0] = block[8] = apx->data[mean]; + + ++src; + ++block; + } + + if ((y == 1) || (y == 3)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + + flags = 0; + shifter = 0; + } + + src += (enc->mve->width * 2) - 8; + block += 8; + } + + apx->error = + mve_block_error_packed (enc, src - 8 * enc->mve->width, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0x9d (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* generic 4-color encoding (20 bytes) */ + guint32 flags = 0; + guint shifter = 0; + guint i, x, y; + guint8 *data = apx->data; + guint8 *block = apx->block; + + if (!enc->q4available) { + enc->q4error = + mve_quantize (enc, src, 8, 8, 0, 4, enc->q4block, enc->q4colors); + enc->q4available = TRUE; + } + + memcpy (block, enc->q4block, 64); + + /* p0 <= p1 && p2 <= p3 */ + data[0] = MIN (enc->q4colors[0], enc->q4colors[1]); + data[1] = MAX (enc->q4colors[0], enc->q4colors[1]); + data[2] = MIN (enc->q4colors[2], enc->q4colors[3]); + data[3] = MAX (enc->q4colors[2], enc->q4colors[3]); + data += 4; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + + for (i = 0; i < 3; ++i) { + if (*block == apx->data[i]) + break; + } + + flags |= i << shifter; + ++block; + } + + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data += 2; + shifter = 0; + flags = 0; + } + + apx->error = enc->q4error; + return apx->error; +} + +static guint32 +mve_encode_0xaa (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for top and bottom half (24 bytes) */ + guint8 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint8 *block = apx->block; + guint8 *data = apx->data; + const guint8 *p; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc, src, 8, 4, i, 4, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 > p1 && p4 > p5 */ + data[0] = MAX (cols[0], cols[1]); + data[1] = MIN (cols[0], cols[1]); + data[2] = cols[2]; + data[3] = cols[3]; + p = data; + data += 4; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 8; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == p[j]) + break; + } + flags |= j << shifter; + } + block += 8; + + if ((y == 1) || (y == 3)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + flags = 0; + shifter = 0; + } + } + } + + return apx->error; +} + +static guint32 +mve_encode_0xab (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for left and right half (24 bytes) */ + guint8 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint8 *block = apx->block; + guint8 *data = apx->data; + const guint8 *p; + + apx->error = 0; + + for (i = 0; i < 2; ++i) { + apx->error += mve_quantize (enc, src, 4, 8, i, 4, apx->block, cols); + + flags = 0; + shifter = 0; + + /* p0 > p1 && p4 <= p5 */ + data[i] = MAX (cols[0], cols[1]); + data[i ^ 1] = MIN (cols[0], cols[1]); + data[2] = cols[2]; + data[3] = cols[3]; + p = data; + data += 4; + + for (y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == p[j]) + break; + } + flags |= j << shifter; + } + block += 8; + + if ((y == 3) || (y == 7)) { + data[0] = flags & 0x000000FF; + data[1] = (flags & 0x0000FF00) >> 8; + data[2] = (flags & 0x00FF0000) >> 16; + data[3] = (flags & 0xFF000000) >> 24; + data += 4; + flags = 0; + shifter = 0; + } + } + block = apx->block + 4; + } + + return apx->error; +} + +static guint32 +mve_encode_0xac (GstMveEncoderData * enc, const guint8 * src, + GstMveApprox * apx) +{ + /* 4-color encoding for each 4x4 quadrant (32 bytes) */ + guint8 cols[4]; + guint32 flags; + guint i, j, x, y, shifter; + guint8 *block; + guint8 *data = apx->data; + + apx->error = 0; + + for (i = 0; i < 4; ++i) { + apx->error += + mve_quantize (enc, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1), 4, + apx->block, cols); + + /* p0 <= p1 */ + data[0] = MIN (cols[0], cols[1]); + data[1] = MAX (cols[0], cols[1]); + data[2] = cols[2]; + data[3] = cols[3]; + + block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + flags = 0; + shifter = 0; + + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x, shifter += 2) { + for (j = 0; j < 3; ++j) { + if (block[x] == data[j]) + break; + } + flags |= j << shifter; + } + block += 8; + } + + data[4] = flags & 0x000000FF; + data[5] = (flags & 0x0000FF00) >> 8; + data[6] = (flags & 0x00FF0000) >> 16; + data[7] = (flags & 0xFF000000) >> 24; + data += 8; + } + + return apx->error; +} + +static guint32 +mve_encode_0xb (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* 64-color encoding (each pixel in block is a different color) (64 bytes) */ + mve_store_block (enc->mve, src, apx->block); + memcpy (apx->data, apx->block, 64); + apx->error = 0; + + return 0; +} + +static guint32 +mve_encode_0xc (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* 16-color block encoding: each 2x2 block is a different color (16 bytes) */ + guint i = 0, x, y; + const guint w = enc->mve->width; + guint16 r, g, b; + + /* calculate median color for each 2x2 block */ + for (y = 0; y < 4; ++y) { + for (x = 0; x < 4; ++x) { + guint32 p = enc->palette[src[0]]; + + r = MVE_RVAL (p) + 2; + g = MVE_GVAL (p) + 2; + b = MVE_BVAL (p) + 2; + + p = enc->palette[src[1]]; + r += MVE_RVAL (p); + g += MVE_GVAL (p); + b += MVE_BVAL (p); + + p = enc->palette[src[w]]; + r += MVE_RVAL (p); + g += MVE_GVAL (p); + b += MVE_BVAL (p); + + p = enc->palette[src[w + 1]]; + r += MVE_RVAL (p); + g += MVE_GVAL (p); + b += MVE_BVAL (p); + + apx->block[i] = apx->block[i + 1] = apx->block[i + 2] = + apx->block[i + 3] = apx->data[i >> 2] = + mve_find_pal_color (enc->palette, MVE_COL (r >> 2, g >> 2, b >> 2)); + + i += 4; + src += 2; + } + src += (w * 2) - 8; + } + + apx->error = mve_block_error_packed (enc, src - (8 * w), apx->block); + return apx->error; +} + +static guint32 +mve_encode_0xd (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* 4-color block encoding: each 4x4 block is a different color (4 bytes) */ + guint i, y; + + /* calculate median color for each 4x4 block */ + for (i = 0; i < 4; ++i) { + guint8 median = + mve_median_sub (enc, src, 4, 4, ((i & 1) << 1) | ((i & 2) >> 1)); + guint8 *block = apx->block + ((i / 2) * 4) + ((i % 2) * 32); + + for (y = 0; y < 4; ++y) { + memset (block, median, 4); + block += 8; + } + + apx->data[i] = median; + } + + apx->error = mve_block_error_packed (enc, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0xe (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* 1-color encoding: the whole block is 1 solid color (1 bytes) */ + guint8 median = mve_median (enc, src); + + memset (apx->block, median, 64); + + apx->data[0] = median; + apx->error = mve_block_error_packed (enc, src, apx->block); + return apx->error; +} + +static guint32 +mve_encode_0xf (GstMveEncoderData * enc, const guint8 * src, GstMveApprox * apx) +{ + /* 2 colors dithered encoding (2 bytes) */ + guint i, x, y; + guint32 r[2] = { 0 }, g[2] = { + 0}, b[2] = { + 0}; + guint8 col[2]; + + /* find medians for both colors */ + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; x += 2) { + guint16 p = src[x]; + + r[y & 1] += MVE_RVAL (p); + g[y & 1] += MVE_GVAL (p); + b[y & 1] += MVE_BVAL (p); + + p = src[x + 1]; + r[(y & 1) ^ 1] += MVE_RVAL (p); + g[(y & 1) ^ 1] += MVE_GVAL (p); + b[(y & 1) ^ 1] += MVE_BVAL (p); + } + src += enc->mve->width; + } + col[0] = mve_find_pal_color (enc->palette, + MVE_COL ((r[0] + 16) / 32, (g[0] + 16) / 32, (b[0] + 16) / 32)); + col[1] = mve_find_pal_color (enc->palette, + MVE_COL ((r[1] + 16) / 32, (g[1] + 16) / 32, (b[1] + 16) / 32)); + + /* store block after encoding */ + for (i = 0, y = 0; y < 8; ++y) { + for (x = 0; x < 4; ++x) { + apx->block[i++] = col[y & 1]; + apx->block[i++] = col[(y & 1) ^ 1]; + } + } + + apx->data[0] = col[0]; + apx->data[1] = col[1]; + apx->error = mve_block_error_packed (enc, + src - (8 * enc->mve->width), apx->block); + return apx->error; +} + +/* all available encodings in the preferred order, + i.e. in ascending encoded size */ +static const GstMveEncoding mve_encodings[] = { + {0x1, 0, mve_encode_0x1}, + {0x0, 0, mve_encode_0x0}, + {0xe, 1, mve_encode_0xe}, + {0x3, 1, mve_encode_0x3}, + {0x4, 1, mve_encode_0x4}, + {0x2, 1, mve_encode_0x2}, + {0xf, 2, mve_encode_0xf}, + {0x5, 2, mve_encode_0x5}, + {0xd, 4, mve_encode_0xd}, + {0x7, 4, mve_encode_0x7a}, + {0x9, 8, mve_encode_0x9a}, + {0x7, 10, mve_encode_0x7b}, + {0x8, 12, mve_encode_0x8a}, + {0x8, 12, mve_encode_0x8b}, + {0x9, 12, mve_encode_0x9b}, + {0x9, 12, mve_encode_0x9c}, + {0xc, 16, mve_encode_0xc}, + {0x8, 16, mve_encode_0x8c}, + {0x9, 20, mve_encode_0x9d}, + {0xa, 24, mve_encode_0xaa}, + {0xa, 24, mve_encode_0xab}, + {0xa, 32, mve_encode_0xac}, + {0xb, 64, mve_encode_0xb} +}; + +static gboolean +mve_reorder_solution (GArray ** solution, guint16 n) +{ + /* do a binary search to find the position to reinsert the modified element */ + /* the block we need to reconsider is always at position 0 */ + /* return TRUE if this block only has 1 encoding left and can be dropped */ + if (mve_comp_solution (&solution[0], &solution[1]) <= 0) + return FALSE; /* already sorted */ + + else if (solution[0]->len <= 1) + /* drop this element from further calculations since we cannot improve here */ + return TRUE; + + else { + /* we know the error value can only get worse, so we can actually start at 1 */ + guint lower = 1; + guint upper = n - 1; + gint cmp; + guint idx = 0; + + while (upper > lower) { + idx = lower + ((upper - lower) / 2); + + cmp = mve_comp_solution (&solution[0], &solution[idx]); + + if (cmp < 0) { + upper = idx; + } else if (cmp > 0) { + lower = ++idx; + } else { + upper = lower = idx; + } + } + + if (idx > 0) { + /* rearrange array members in new order */ + GArray *a = solution[0]; + + memcpy (&solution[0], &solution[1], sizeof (GArray *) * idx); + solution[idx] = a; + } + } + return FALSE; +} + +static guint32 +gst_mve_find_solution (GArray ** approx, guint16 n, guint32 size, guint16 max) +{ + /* build an array of approximations we can shuffle around */ + GstMveApprox *sol_apx; + GArray **solution = g_malloc (sizeof (GArray *) * n); + GArray **current = solution; + + memcpy (solution, approx, sizeof (GArray *) * n); + + qsort (solution, n, sizeof (GArray *), mve_comp_solution); + + do { + /* array is now sorted by error of the next to optimal approximation; + drop optimal approximation for the best block */ + + /* unable to reduce size further */ + if (current[0]->len <= 1) + break; + + sol_apx = &g_array_index (current[0], GstMveApprox, current[0]->len - 1); + size -= mve_encodings[sol_apx->type].size; + g_array_remove_index_fast (current[0], current[0]->len - 1); + sol_apx = &g_array_index (current[0], GstMveApprox, current[0]->len - 1); + size += mve_encodings[sol_apx->type].size; + + if (mve_reorder_solution (current, n)) { + ++current; + --n; + } + } while (size > max); + + g_free (solution); + + return size; +} + +GstFlowReturn +mve_encode_frame8 (GstMveMux * mve, GstBuffer * frame, const guint32 * palette, + guint16 max_data) +{ + guint8 *src; + GstFlowReturn ret = GST_FLOW_ERROR; + guint8 *cm = mve->chunk_code_map; + GArray **approx; + GstMveApprox apx; + GstMveEncoderData enc; + const guint16 blocks = (mve->width * mve->height) / 64; + guint32 encoded_size = 0; + guint i = 0, x, y; + + src = GST_BUFFER_DATA (frame); + + approx = g_malloc (sizeof (GArray *) * blocks); + + enc.mve = mve; + enc.palette = palette; + + for (enc.y = 0; enc.y < mve->height; enc.y += 8) { + for (enc.x = 0; enc.x < mve->width; enc.x += 8) { + guint32 err, last_err = MVE_APPROX_MAX_ERROR; + guint type = 0; + guint best = 0; + + enc.q2available = enc.q4available = FALSE; + approx[i] = g_array_new (FALSE, FALSE, sizeof (GstMveApprox)); + + do { + err = mve_encodings[type].approx (&enc, src, &apx); + + if (err < last_err) { + apx.type = best = type; + g_array_append_val (approx[i], apx); + last_err = err; + } + + ++type; + } while (last_err != 0); + + encoded_size += mve_encodings[best].size; + ++i; + src += 8; + } + src += 7 * mve->width; + } + + /* find best solution with size constraints */ + GST_DEBUG_OBJECT (mve, "encoded frame %u in %ld bytes (lossless)", + mve->video_frames + 1, encoded_size); + +#if 0 + /* FIXME */ + src = GST_BUFFER_DATA (frame); + for (i = 0, y = 0; y < mve->height; y += 8) { + for (x = 0; x < mve->width; x += 8, ++i) { + GstMveApprox *sol = + &g_array_index (approx[i], GstMveApprox, approx[i]->len - 1); + guint opcode = mve_encodings[sol->type].opcode; + guint j, k; + + if (sol->error > 0) + GST_WARNING_OBJECT (mve, "error is %lu for %d/%d (0x%x)", sol->error, x, + y, opcode); + + for (j = 0; j < 8; ++j) { + guint8 *o = src + j * mve->width; + guint8 *c = sol->block + j * 8; + + if (memcmp (o, c, 8)) { + GST_WARNING_OBJECT (mve, "opcode 0x%x (type %d) at %d/%d, line %d:", + opcode, sol->type, x, y, j + 1); + for (k = 0; k < 8; ++k) { + o = src + k * mve->width; + c = sol->block + k * 8; + GST_WARNING_OBJECT (mve, + "%d should be: %4d %4d %4d %4d %4d %4d %4d %4d", k, o[0], + o[1], o[2], o[3], o[4], o[5], o[6], o[7]); + GST_WARNING_OBJECT (mve, + "%d but is : %4d %4d %4d %4d %4d %4d %4d %4d", k, c[0], + c[1], c[2], c[3], c[4], c[5], c[6], c[7]); + } + } + } + src += 8; + } + src += 7 * mve->width; + } +#endif + + if (encoded_size > max_data) { + encoded_size = + gst_mve_find_solution (approx, blocks, encoded_size, max_data); + if (encoded_size > max_data) { + GST_ERROR_OBJECT (mve, "unable to compress frame to less than %d bytes", + encoded_size); + for (i = 0; i < blocks; ++i) + g_array_free (approx[i], TRUE); + + goto done; + } + GST_DEBUG_OBJECT (mve, "compressed frame %u to %ld bytes (lossy)", + mve->video_frames + 1, encoded_size); + } + + mve->chunk_video = g_byte_array_sized_new (encoded_size); + + /* encode */ + src = GST_BUFFER_DATA (frame); + for (i = 0, y = 0; y < mve->height; y += 8) { + for (x = 0; x < mve->width; x += 8, ++i) { + GstMveApprox *sol = + &g_array_index (approx[i], GstMveApprox, approx[i]->len - 1); + guint opcode = mve_encodings[sol->type].opcode; + + g_byte_array_append (mve->chunk_video, sol->data, + mve_encodings[sol->type].size); + + if (i & 1) { + *cm |= opcode << 4; + ++cm; + } else + *cm = opcode; + + /* modify the frame to match the image we actually encoded */ + if (sol->error > 0) + mve_restore_block (mve, src, sol->block); + + src += 8; + g_array_free (approx[i], TRUE); + } + src += 7 * mve->width; + } + + ret = GST_FLOW_OK; + +done: + g_free (approx); + + return ret; +} |