mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-08 18:39:54 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/vmnc/vmncdec.c
Vineeth T M 5294a68122 vmncdec: modify wrong packetized mode logic 
packetized mode is being set when framerate is being set
which is not correct. Changing the same by checking the
input segement format. If input segment is in TIME it is
Packetized, and if it is in BYTES it is not.

https://bugzilla.gnome.org/show_bug.cgi?id=736252
2014-09-16 11:24:53 +03:00

945 lines
27 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2007 Michael Smith <msmith@xiph.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/*
* This is a decoder for the VMWare VMnc video codec, which VMWare uses for
* recording * of virtual machine instances.
* It's essentially a serialisation of RFB (the VNC protocol)
* 'FramebufferUpdate' messages, with some special encoding-types for VMnc
* extensions. There's some documentation (with fixes from VMWare employees) at:
* http://wiki.multimedia.cx/index.php?title=VMware_Video
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "vmncdec.h"
#include <string.h>
static gboolean gst_vmnc_dec_reset (GstVideoDecoder * decoder);
static gboolean gst_vmnc_dec_set_format (GstVideoDecoder * decoder,
GstVideoCodecState * state);
static GstFlowReturn gst_vmnc_dec_handle_frame (GstVideoDecoder * decoder,
GstVideoCodecFrame * frame);
static GstFlowReturn gst_vmnc_dec_parse (GstVideoDecoder * decoder,
GstVideoCodecFrame * frame, GstAdapter * adapter, gboolean at_eos);
#define GST_CAT_DEFAULT vmnc_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
#define RFB_GET_UINT32(ptr) GST_READ_UINT32_BE(ptr)
#define RFB_GET_UINT16(ptr) GST_READ_UINT16_BE(ptr)
#define RFB_GET_UINT8(ptr) GST_READ_UINT8(ptr)
enum
{
ARG_0,
};
enum
{
ERROR_INVALID = -1, /* Invalid data in bitstream */
ERROR_INSUFFICIENT_DATA = -2 /* Haven't received enough data yet */
};
static GstStaticPadTemplate vmnc_dec_src_factory =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBx, BGRx, xRGB, xBGR,"
" RGB15, BGR15, RGB16, BGR16, GRAY8 }")));
static GstStaticPadTemplate vmnc_dec_sink_factory =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/x-vmnc, version=(int)1, "
"framerate=(fraction)[0, max], "
"width=(int)[0, max], " "height=(int)[0, max]")
);
G_DEFINE_TYPE (GstVMncDec, gst_vmnc_dec, GST_TYPE_VIDEO_DECODER);
static void
gst_vmnc_dec_class_init (GstVMncDecClass * klass)
{
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
GstVideoDecoderClass *decoder_class = GST_VIDEO_DECODER_CLASS (klass);
decoder_class->start = gst_vmnc_dec_reset;
decoder_class->stop = gst_vmnc_dec_reset;
decoder_class->parse = gst_vmnc_dec_parse;
decoder_class->handle_frame = gst_vmnc_dec_handle_frame;
decoder_class->set_format = gst_vmnc_dec_set_format;
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&vmnc_dec_src_factory));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&vmnc_dec_sink_factory));
gst_element_class_set_static_metadata (gstelement_class, "VMnc video decoder",
"Codec/Decoder/Video",
"Decode VmWare video to raw (RGB) video",
"Michael Smith <msmith@xiph.org>");
GST_DEBUG_CATEGORY_INIT (vmnc_debug, "vmncdec", 0, "VMnc decoder");
}
static void
gst_vmnc_dec_init (GstVMncDec * dec)
{
}
static gboolean
gst_vmnc_dec_reset (GstVideoDecoder * decoder)
{
GstVMncDec *dec = GST_VMNC_DEC (decoder);
g_free (dec->imagedata);
dec->imagedata = NULL;
g_free (dec->cursor.cursordata);
dec->cursor.cursordata = NULL;
g_free (dec->cursor.cursormask);
dec->cursor.cursormask = NULL;
dec->cursor.visible = 0;
dec->have_format = FALSE;
if (dec->input_state)
gst_video_codec_state_unref (dec->input_state);
dec->input_state = NULL;
return TRUE;
}
struct RfbRectangle
{
guint16 x;
guint16 y;
guint16 width;
guint16 height;
gint32 type;
};
/* Rectangle handling functions.
* Return number of bytes consumed, or < 0 on error
*/
typedef int (*rectangle_handler) (GstVMncDec * dec, struct RfbRectangle * rect,
const guint8 * data, int len, gboolean decode);
static int
vmnc_handle_wmvi_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
GstVideoFormat format;
gint bpp, tc;
guint32 redmask, greenmask, bluemask;
guint32 endianness, dataendianness;
GstVideoCodecState *state;
/* A WMVi rectangle has a 16byte payload */
if (len < 16) {
GST_DEBUG_OBJECT (dec, "Bad WMVi rect: too short");
return ERROR_INSUFFICIENT_DATA;
}
/* We only compare 13 bytes; ignoring the 3 padding bytes at the end */
if (dec->have_format && memcmp (data, dec->format.descriptor, 13) == 0) {
/* Nothing changed, so just exit */
return 16;
}
/* Store the whole block for simple comparison later */
memcpy (dec->format.descriptor, data, 16);
if (rect->x != 0 || rect->y != 0) {
GST_WARNING_OBJECT (dec, "Bad WMVi rect: wrong coordinates");
return ERROR_INVALID;
}
bpp = data[0];
dec->format.depth = data[1];
dec->format.big_endian = data[2];
dataendianness = data[2] ? G_BIG_ENDIAN : G_LITTLE_ENDIAN;
tc = data[3];
if (bpp != 8 && bpp != 16 && bpp != 32) {
GST_WARNING_OBJECT (dec, "Bad bpp value: %d", bpp);
return ERROR_INVALID;
}
if (!tc) {
GST_WARNING_OBJECT (dec, "Paletted video not supported");
return ERROR_INVALID;
}
dec->format.bytes_per_pixel = bpp / 8;
dec->format.width = rect->width;
dec->format.height = rect->height;
redmask = (guint32) (RFB_GET_UINT16 (data + 4)) << data[10];
greenmask = (guint32) (RFB_GET_UINT16 (data + 6)) << data[11];
bluemask = (guint32) (RFB_GET_UINT16 (data + 8)) << data[12];
GST_DEBUG_OBJECT (dec, "Red: mask %d, shift %d",
RFB_GET_UINT16 (data + 4), data[10]);
GST_DEBUG_OBJECT (dec, "Green: mask %d, shift %d",
RFB_GET_UINT16 (data + 6), data[11]);
GST_DEBUG_OBJECT (dec, "Blue: mask %d, shift %d",
RFB_GET_UINT16 (data + 8), data[12]);
GST_DEBUG_OBJECT (dec, "BPP: %d. endianness: %s", bpp,
data[2] ? "big" : "little");
/* GStreamer's RGB caps are a bit weird. */
if (bpp == 8) {
endianness = G_BYTE_ORDER; /* Doesn't matter */
} else if (bpp == 16) {
/* We require host-endian. */
endianness = G_BYTE_ORDER;
} else { /* bpp == 32 */
/* We require big endian */
endianness = G_BIG_ENDIAN;
if (endianness != dataendianness) {
redmask = GUINT32_SWAP_LE_BE (redmask);
greenmask = GUINT32_SWAP_LE_BE (greenmask);
bluemask = GUINT32_SWAP_LE_BE (bluemask);
}
}
format = gst_video_format_from_masks (dec->format.depth, bpp, endianness,
redmask, greenmask, bluemask, 0);
GST_DEBUG_OBJECT (dec, "From depth: %d bpp: %u endianess: %s redmask: %X "
"greenmask: %X bluemask: %X got format %s",
dec->format.depth, bpp, endianness == G_BIG_ENDIAN ? "BE" : "LE",
GUINT32_FROM_BE (redmask), GUINT32_FROM_BE (greenmask),
GUINT32_FROM_BE (bluemask),
format == GST_VIDEO_FORMAT_UNKNOWN ? "UNKOWN" :
gst_video_format_to_string (format));
if (format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_WARNING_OBJECT (dec, "Video format unknown to GStreamer");
return ERROR_INVALID;
}
dec->have_format = TRUE;
if (!decode) {
GST_LOG_OBJECT (dec, "Parsing, not setting caps");
return 16;
}
state = gst_video_decoder_set_output_state (GST_VIDEO_DECODER (dec), format,
rect->width, rect->height, dec->input_state);
gst_video_codec_state_unref (state);
g_free (dec->imagedata);
dec->imagedata = g_malloc (dec->format.width * dec->format.height *
dec->format.bytes_per_pixel);
GST_DEBUG_OBJECT (dec, "Allocated image data at %p", dec->imagedata);
dec->format.stride = dec->format.width * dec->format.bytes_per_pixel;
return 16;
}
static void
render_colour_cursor (GstVMncDec * dec, guint8 * data, int x, int y,
int off_x, int off_y, int width, int height)
{
int i, j;
guint8 *dstraw = data + dec->format.stride * y +
dec->format.bytes_per_pixel * x;
guint8 *srcraw = dec->cursor.cursordata +
dec->cursor.width * dec->format.bytes_per_pixel * off_y;
guint8 *maskraw = dec->cursor.cursormask +
dec->cursor.width * dec->format.bytes_per_pixel * off_y;
/* Boundchecking done by caller; this is just the renderer inner loop */
if (dec->format.bytes_per_pixel == 1) {
guint8 *dst = dstraw;
guint8 *src = srcraw;
guint8 *mask = maskraw;
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
dst[j] = (dst[j] & src[j]) ^ mask[j];
}
dst += dec->format.width;
src += dec->cursor.width;
mask += dec->cursor.width;
}
} else if (dec->format.bytes_per_pixel == 2) {
guint16 *dst = (guint16 *) dstraw;
guint16 *src = (guint16 *) srcraw;
guint16 *mask = (guint16 *) maskraw;
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
dst[j] = (dst[j] & src[j]) ^ mask[j];
}
dst += dec->format.width;
src += dec->cursor.width;
mask += dec->cursor.width;
}
} else {
guint32 *dst = (guint32 *) dstraw;
guint32 *src = (guint32 *) srcraw;
guint32 *mask = (guint32 *) maskraw;
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
dst[j] = (dst[j] & src[j]) ^ mask[j];
}
dst += dec->format.width;
src += dec->cursor.width;
mask += dec->cursor.width;
}
}
}
static void
render_cursor (GstVMncDec * dec, guint8 * data)
{
/* First, figure out the portion of the cursor that's on-screen */
/* X,Y of top-left of cursor */
int x = dec->cursor.x - dec->cursor.hot_x;
int y = dec->cursor.y - dec->cursor.hot_y;
/* Width, height of rendered portion of cursor */
int width = dec->cursor.width;
int height = dec->cursor.height;
/* X,Y offset of rendered portion of cursor */
int off_x = 0;
int off_y = 0;
if (x < 0) {
off_x = -x;
width += x;
x = 0;
}
if (x + width > dec->format.width)
width = dec->format.width - x;
if (y < 0) {
off_y = -y;
height += y;
y = 0;
}
if (y + height > dec->format.height)
height = dec->format.height - y;
if (dec->cursor.type == CURSOR_COLOUR) {
render_colour_cursor (dec, data, x, y, off_x, off_y, width, height);
} else {
/* Alpha cursor. */
/* TODO: Implement me! */
GST_WARNING_OBJECT (dec, "Alpha composited cursors not yet implemented");
}
}
static GstFlowReturn
vmnc_fill_buffer (GstVMncDec * dec, GstVideoCodecFrame * frame)
{
GstFlowReturn ret;
GstMapInfo map;
ret =
gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER (dec), frame);
if (ret != GST_FLOW_OK)
return ret;
gst_buffer_map (frame->output_buffer, &map, GST_MAP_READWRITE);
memcpy (map.data, dec->imagedata, map.size);
if (dec->cursor.visible)
render_cursor (dec, map.data);
gst_buffer_unmap (frame->output_buffer, &map);
return GST_FLOW_OK;
}
static int
vmnc_handle_wmvd_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
/* Cursor data. */
int datalen = 2;
int type, size;
if (len < datalen) {
GST_LOG_OBJECT (dec, "Cursor data too short");
return ERROR_INSUFFICIENT_DATA;
}
type = RFB_GET_UINT8 (data);
if (type == CURSOR_COLOUR) {
datalen += rect->width * rect->height * dec->format.bytes_per_pixel * 2;
} else if (type == CURSOR_ALPHA) {
datalen += rect->width * rect->height * 4;
} else {
GST_WARNING_OBJECT (dec, "Unknown cursor type: %d", type);
return ERROR_INVALID;
}
if (len < datalen) {
GST_LOG_OBJECT (dec, "Cursor data too short");
return ERROR_INSUFFICIENT_DATA;
} else if (!decode)
return datalen;
dec->cursor.type = type;
dec->cursor.width = rect->width;
dec->cursor.height = rect->height;
dec->cursor.type = type;
dec->cursor.hot_x = rect->x;
dec->cursor.hot_y = rect->y;
g_free (dec->cursor.cursordata);
g_free (dec->cursor.cursormask);
if (type == 0) {
size = rect->width * rect->height * dec->format.bytes_per_pixel;
dec->cursor.cursordata = g_malloc (size);
dec->cursor.cursormask = g_malloc (size);
memcpy (dec->cursor.cursordata, data + 2, size);
memcpy (dec->cursor.cursormask, data + 2 + size, size);
} else {
dec->cursor.cursordata = g_malloc (rect->width * rect->height * 4);
memcpy (dec->cursor.cursordata, data + 2, rect->width * rect->height * 4);
}
return datalen;
}
static int
vmnc_handle_wmve_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
guint16 flags;
/* Cursor state. */
if (len < 2) {
GST_LOG_OBJECT (dec, "Cursor data too short");
return ERROR_INSUFFICIENT_DATA;
} else if (!decode)
return 2;
flags = RFB_GET_UINT16 (data);
dec->cursor.visible = flags & 0x01;
return 2;
}
static int
vmnc_handle_wmvf_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
/* Cursor position. */
dec->cursor.x = rect->x;
dec->cursor.y = rect->y;
return 0;
}
static int
vmnc_handle_wmvg_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
/* Keyboard stuff; not interesting for playback */
if (len < 10) {
GST_LOG_OBJECT (dec, "Keyboard data too short");
return ERROR_INSUFFICIENT_DATA;
}
return 10;
}
static int
vmnc_handle_wmvh_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
/* More keyboard stuff; not interesting for playback */
if (len < 4) {
GST_LOG_OBJECT (dec, "Keyboard data too short");
return ERROR_INSUFFICIENT_DATA;
}
return 4;
}
static int
vmnc_handle_wmvj_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
/* VM state info, not interesting for playback */
if (len < 2) {
GST_LOG_OBJECT (dec, "VM state data too short");
return ERROR_INSUFFICIENT_DATA;
}
return 2;
}
static void
render_raw_tile (GstVMncDec * dec, const guint8 * data, int x, int y,
int width, int height)
{
int i;
guint8 *dst;
const guint8 *src;
int line;
src = data;
dst = dec->imagedata + dec->format.stride * y +
dec->format.bytes_per_pixel * x;
line = width * dec->format.bytes_per_pixel;
for (i = 0; i < height; i++) {
/* This is wrong-endian currently */
memcpy (dst, src, line);
dst += dec->format.stride;
src += line;
}
}
static void
render_subrect (GstVMncDec * dec, int x, int y, int width,
int height, guint32 colour)
{
/* Crazy inefficient! */
int i, j;
guint8 *dst;
for (i = 0; i < height; i++) {
dst = dec->imagedata + dec->format.stride * (y + i) +
dec->format.bytes_per_pixel * x;
for (j = 0; j < width; j++) {
memcpy (dst, &colour, dec->format.bytes_per_pixel);
dst += dec->format.bytes_per_pixel;
}
}
}
static int
vmnc_handle_raw_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
int datalen = rect->width * rect->height * dec->format.bytes_per_pixel;
if (len < datalen) {
GST_LOG_OBJECT (dec, "Raw data too short");
return ERROR_INSUFFICIENT_DATA;
}
if (decode)
render_raw_tile (dec, data, rect->x, rect->y, rect->width, rect->height);
return datalen;
}
static int
vmnc_handle_copy_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
int src_x, src_y;
guint8 *src, *dst;
int i;
if (len < 4) {
GST_LOG_OBJECT (dec, "Copy data too short");
return ERROR_INSUFFICIENT_DATA;
} else if (!decode)
return 4;
src_x = RFB_GET_UINT16 (data);
src_y = RFB_GET_UINT16 (data + 2);
/* Our destination rectangle is guaranteed in-frame; check this for the source
* rectangle. */
if (src_x + rect->width > dec->format.width ||
src_y + rect->height > dec->format.height) {
GST_WARNING_OBJECT (dec, "Source rectangle out of range");
return ERROR_INVALID;
}
if (src_y > rect->y || src_x > rect->x) {
/* Moving forward */
src = dec->imagedata + dec->format.stride * src_y +
dec->format.bytes_per_pixel * src_x;
dst = dec->imagedata + dec->format.stride * rect->y +
dec->format.bytes_per_pixel * rect->x;
for (i = 0; i < rect->height; i++) {
memmove (dst, src, rect->width * dec->format.bytes_per_pixel);
dst += dec->format.stride;
src += dec->format.stride;
}
} else {
/* Backwards */
src = dec->imagedata + dec->format.stride * (src_y + rect->height - 1) +
dec->format.bytes_per_pixel * src_x;
dst = dec->imagedata + dec->format.stride * (rect->y + rect->height - 1) +
dec->format.bytes_per_pixel * rect->x;
for (i = rect->height; i > 0; i--) {
memmove (dst, src, rect->width * dec->format.bytes_per_pixel);
dst -= dec->format.stride;
src -= dec->format.stride;
}
}
return 4;
}
/* FIXME: data+off might not be properly aligned */
#define READ_PIXEL(pixel, data, off, len) \
if (dec->format.bytes_per_pixel == 1) { \
if (off >= len) \
return ERROR_INSUFFICIENT_DATA; \
pixel = data[off++]; \
} else if (dec->format.bytes_per_pixel == 2) { \
if (off+2 > len) \
return ERROR_INSUFFICIENT_DATA; \
pixel = (*(guint16 *)(data + off)); \
off += 2; \
} else { \
if (off+4 > len) \
return ERROR_INSUFFICIENT_DATA; \
pixel = (*(guint32 *)(data + off)); \
off += 4; \
}
static int
vmnc_handle_hextile_rectangle (GstVMncDec * dec, struct RfbRectangle *rect,
const guint8 * data, int len, gboolean decode)
{
int tilesx = GST_ROUND_UP_16 (rect->width) / 16;
int tilesy = GST_ROUND_UP_16 (rect->height) / 16;
int x, y, z;
int off = 0;
int subrects;
int coloured;
int width, height;
guint32 fg = 0, bg = 0, colour;
guint8 flags;
for (y = 0; y < tilesy; y++) {
if (y == tilesy - 1)
height = rect->height - (tilesy - 1) * 16;
else
height = 16;
for (x = 0; x < tilesx; x++) {
if (x == tilesx - 1)
width = rect->width - (tilesx - 1) * 16;
else
width = 16;
if (off >= len) {
return ERROR_INSUFFICIENT_DATA;
}
flags = data[off++];
if (flags & 0x1) {
if (off + width * height * dec->format.bytes_per_pixel > len) {
return ERROR_INSUFFICIENT_DATA;
}
if (decode)
render_raw_tile (dec, data + off, rect->x + x * 16, rect->y + y * 16,
width, height);
off += width * height * dec->format.bytes_per_pixel;
} else {
if (flags & 0x2) {
READ_PIXEL (bg, data, off, len)
}
if (flags & 0x4) {
READ_PIXEL (fg, data, off, len)
}
subrects = 0;
if (flags & 0x8) {
if (off >= len) {
return ERROR_INSUFFICIENT_DATA;
}
subrects = data[off++];
}
/* Paint background colour on entire tile */
if (decode)
render_subrect (dec, rect->x + x * 16, rect->y + y * 16,
width, height, bg);
coloured = flags & 0x10;
for (z = 0; z < subrects; z++) {
if (coloured) {
READ_PIXEL (colour, data, off, len);
} else
colour = fg;
if (off + 2 > len)
return ERROR_INSUFFICIENT_DATA;
{
int off_x = (data[off] & 0xf0) >> 4;
int off_y = (data[off] & 0x0f);
int w = ((data[off + 1] & 0xf0) >> 4) + 1;
int h = (data[off + 1] & 0x0f) + 1;
off += 2;
/* Ensure we don't have out of bounds coordinates */
if (off_x + w > width || off_y + h > height) {
GST_WARNING_OBJECT (dec, "Subrect out of bounds: %d-%d x %d-%d "
"extends outside %dx%d", off_x, w, off_y, h, width, height);
return ERROR_INVALID;
}
if (decode)
render_subrect (dec, rect->x + x * 16 + off_x,
rect->y + y * 16 + off_y, w, h, colour);
}
}
}
}
}
return off;
}
/* Handle a packet in one of two modes: decode or parse.
* In parse mode, we don't execute any of the decoding, we just do enough to
* figure out how many bytes it contains
*
* Returns: >= 0, the number of bytes consumed
* < 0, packet too short to decode, or error
*/
static int
vmnc_handle_packet (GstVMncDec * dec, const guint8 * data, int len,
gboolean decode)
{
int type;
int offset = 0;
if (len < 4) {
GST_LOG_OBJECT (dec, "Packet too short");
return ERROR_INSUFFICIENT_DATA;
}
type = data[0];
switch (type) {
case 0:
{
int numrect = RFB_GET_UINT16 (data + 2);
int i;
int read;
offset = 4;
for (i = 0; i < numrect; i++) {
struct RfbRectangle r;
rectangle_handler handler;
if (len < offset + 12) {
GST_LOG_OBJECT (dec,
"Packet too short for rectangle header: %d < %d",
len, offset + 12);
return ERROR_INSUFFICIENT_DATA;
}
GST_LOG_OBJECT (dec, "Reading rectangle %d", i);
r.x = RFB_GET_UINT16 (data + offset);
r.y = RFB_GET_UINT16 (data + offset + 2);
r.width = RFB_GET_UINT16 (data + offset + 4);
r.height = RFB_GET_UINT16 (data + offset + 6);
r.type = RFB_GET_UINT32 (data + offset + 8);
if (r.type != TYPE_WMVi) {
/* We must have a WMVi packet to initialise things before we can
* continue */
if (!dec->have_format) {
GST_WARNING_OBJECT (dec, "Received packet without WMVi: %d",
r.type);
return ERROR_INVALID;
}
if (r.x + r.width > dec->format.width ||
r.y + r.height > dec->format.height) {
GST_WARNING_OBJECT (dec, "Rectangle out of range, type %d", r.type);
return ERROR_INVALID;
}
}
switch (r.type) {
case TYPE_WMVd:
handler = vmnc_handle_wmvd_rectangle;
break;
case TYPE_WMVe:
handler = vmnc_handle_wmve_rectangle;
break;
case TYPE_WMVf:
handler = vmnc_handle_wmvf_rectangle;
break;
case TYPE_WMVg:
handler = vmnc_handle_wmvg_rectangle;
break;
case TYPE_WMVh:
handler = vmnc_handle_wmvh_rectangle;
break;
case TYPE_WMVi:
handler = vmnc_handle_wmvi_rectangle;
break;
case TYPE_WMVj:
handler = vmnc_handle_wmvj_rectangle;
break;
case TYPE_RAW:
handler = vmnc_handle_raw_rectangle;
break;
case TYPE_COPY:
handler = vmnc_handle_copy_rectangle;
break;
case TYPE_HEXTILE:
handler = vmnc_handle_hextile_rectangle;
break;
default:
GST_WARNING_OBJECT (dec, "Unknown rectangle type");
return ERROR_INVALID;
}
read = handler (dec, &r, data + offset + 12, len - offset - 12, decode);
if (read < 0) {
GST_DEBUG_OBJECT (dec, "Error calling rectangle handler\n");
return read;
}
offset += 12 + read;
}
break;
}
default:
GST_WARNING_OBJECT (dec, "Packet type unknown: %d", type);
return ERROR_INVALID;
}
return offset;
}
static gboolean
gst_vmnc_dec_set_format (GstVideoDecoder * decoder, GstVideoCodecState * state)
{
GstVMncDec *dec = GST_VMNC_DEC (decoder);
/* We require a format descriptor in-stream, so we ignore the info from the
* container here. We just use the framerate */
if (decoder->input_segment.format == GST_FORMAT_TIME)
gst_video_decoder_set_packetized (decoder, TRUE);
else
gst_video_decoder_set_packetized (decoder, FALSE);
if (dec->input_state)
gst_video_codec_state_unref (dec->input_state);
dec->input_state = gst_video_codec_state_ref (state);
return TRUE;
}
static GstFlowReturn
gst_vmnc_dec_handle_frame (GstVideoDecoder * decoder,
GstVideoCodecFrame * frame)
{
GstVMncDec *dec = GST_VMNC_DEC (decoder);
int res;
GstFlowReturn ret = GST_FLOW_OK;
GstMapInfo map;
if (!gst_buffer_map (frame->input_buffer, &map, GST_MAP_READ))
return GST_FLOW_ERROR;
res = vmnc_handle_packet (dec, map.data, map.size, TRUE);
gst_buffer_unmap (frame->input_buffer, &map);
if (!dec->have_format) {
GST_VIDEO_DECODER_ERROR (decoder, 2, STREAM, DECODE, (NULL),
("Data found before header"), ret);
gst_video_decoder_drop_frame (decoder, frame);
} else if (res < 0) {
ret = GST_FLOW_ERROR;
gst_video_decoder_drop_frame (decoder, frame);
GST_VIDEO_DECODER_ERROR (decoder, 1, STREAM, DECODE, (NULL),
("Couldn't decode packet"), ret);
} else {
GST_LOG_OBJECT (dec, "read %d bytes of %" G_GSIZE_FORMAT, res,
gst_buffer_get_size (frame->input_buffer));
/* inbuf may be NULL; that's ok */
ret = vmnc_fill_buffer (dec, frame);
if (ret == GST_FLOW_OK)
gst_video_decoder_finish_frame (decoder, frame);
else
gst_video_decoder_drop_frame (decoder, frame);
}
return ret;
}
static GstFlowReturn
gst_vmnc_dec_parse (GstVideoDecoder * decoder, GstVideoCodecFrame * frame,
GstAdapter * adapter, gboolean at_eos)
{
GstVMncDec *dec = GST_VMNC_DEC (decoder);
const guint8 *data;
int avail;
int len;
avail = gst_adapter_available (adapter);
data = gst_adapter_map (adapter, avail);
GST_LOG_OBJECT (dec, "Parsing %d bytes", avail);
len = vmnc_handle_packet (dec, data, avail, FALSE);
if (len == ERROR_INSUFFICIENT_DATA) {
GST_LOG_OBJECT (dec, "Not enough data yet");
return GST_VIDEO_DECODER_FLOW_NEED_DATA;
} else if (len < 0) {
GST_ERROR_OBJECT (dec, "Fatal error in bitstream");
return GST_FLOW_ERROR;
} else {
GST_LOG_OBJECT (dec, "Parsed packet: %d bytes", len);
gst_video_decoder_add_to_frame (decoder, len);
return gst_video_decoder_have_frame (decoder);
}
}
static gboolean
plugin_init (GstPlugin * plugin)
{
if (!gst_element_register (plugin, "vmncdec", GST_RANK_PRIMARY,
GST_TYPE_VMNC_DEC))
return FALSE;
return TRUE;
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
vmnc,
"VmWare Video Codec plugins",
plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
Reference in a new issue View git blame Copy permalink