mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-04 23:46:43 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/codecparsers/gstmpeg4parser.c

1754 lines
49 KiB
C
Raw Blame History

/* Gstreamer
* Copyright (C) <2011> Intel
* Copyright (C) <2011> Collabora Ltd.
* Copyright (C) <2011> Thibault Saunier <thibault.saunier@collabora.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:gstmpeg4parser
* @title: GstMpeg4Parser
* @short_description: Convenience library for parsing mpeg4 part 2 video
* bitstream.
*
* For more details about the structures, you can refer to the
* specifications: ISO-IEC-14496-2_2004_MPEG4_VISUAL.pdf
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <gst/base/gstbitreader.h>
#include <gst/base/gstbytereader.h>
#include "gstmpeg4parser.h"
#include "parserutils.h"
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT ensure_debug_category()
static GstDebugCategory *
ensure_debug_category (void)
{
static gsize cat_gonce = 0;
if (g_once_init_enter (&cat_gonce)) {
gsize cat_done;
cat_done = (gsize) _gst_debug_category_new ("codecparsers_mpeg4", 0,
"GstMpeg4 codec parsing library");
g_once_init_leave (&cat_gonce, cat_done);
}
return (GstDebugCategory *) cat_gonce;
}
#else
#define ensure_debug_category() /* NOOP */
#endif /* GST_DISABLE_GST_DEBUG */
#define CHECK_MARKER(br) G_STMT_START { \
guint8 marker;\
if (!gst_bit_reader_get_bits_uint8 (br, &marker, 1)) { \
GST_WARNING ("failed to read marker bit"); \
goto failed; \
} else if (!marker) {\
GST_WARNING ("Wrong marker bit"); \
goto failed;\
}\
} G_STMT_END
#define MARKER_UNCHECKED(br) G_STMT_START { \
if (!gst_bit_reader_get_bits_uint8_unchecked (br, 1)) { \
GST_WARNING ("Wrong marker bit"); \
goto failed; \
} \
} G_STMT_END
#define CHECK_REMAINING(br, needed) G_STMT_START { \
if (gst_bit_reader_get_remaining (br) < needed) \
goto failed; \
} G_STMT_END
static const guint8 default_intra_quant_mat[64] = {
8, 17, 18, 19, 21, 23, 25, 27,
17, 18, 19, 21, 23, 25, 27, 28,
20, 21, 22, 23, 24, 26, 28, 30,
21, 22, 23, 24, 26, 28, 30, 32,
22, 23, 24, 26, 28, 30, 32, 35,
23, 24, 26, 28, 30, 32, 35, 38,
25, 26, 28, 30, 32, 35, 38, 41,
27, 28, 30, 32, 35, 38, 41, 45
};
static const guint8 default_non_intra_quant_mat[64] = {
16, 17, 18, 19, 20, 21, 22, 23,
17, 18, 19, 20, 21, 22, 23, 24,
18, 19, 20, 21, 22, 23, 24, 25,
19, 20, 21, 22, 23, 24, 26, 27,
20, 21, 22, 23, 25, 26, 27, 28,
21, 22, 23, 24, 26, 27, 28, 30,
22, 23, 24, 26, 27, 28, 30, 31,
23, 24, 25, 27, 28, 30, 31, 33,
};
static const guint8 mpeg4_zigzag_8x8[64] = {
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34,
27, 20, 13, 6, 7, 14, 21, 28,
35, 42, 49, 56, 57, 50, 43, 36,
29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46,
53, 60, 61, 54, 47, 55, 62, 63
};
static const VLCTable mpeg4_dmv_size_vlc_table[] = {
{0, 0x00, 2},
{1, 0x02, 3},
{2, 0x03, 3},
{3, 0x04, 3},
{4, 0x05, 3},
{5, 0x06, 3},
{6, 0x0e, 4},
{7, 0x1e, 5},
{8, 0x3e, 6},
{9, 0x7e, 7},
{10, 0xfe, 8},
{11, 0x1fe, 9},
{12, 0x3fe, 10},
{13, 0x7fe, 11},
{14, 0xffe, 12}
};
static void
mpeg4_util_par_from_info (guint8 aspect_ratio_info, guint8 * par_width,
guint8 * par_height)
{
switch (aspect_ratio_info) {
case 0x02:
*par_width = 12;
*par_height = 11;
break;
case 0x03:
*par_width = 10;
*par_height = 11;
break;
case 0x04:
*par_width = 16;
*par_height = 11;
break;
case 0x05:
*par_width = 40;
*par_height = 33;
break;
case 0x01:
default:
*par_width = 1;
*par_height = 1;
}
}
static gboolean
parse_quant (GstBitReader * br, guint8 quant_mat[64],
const guint8 default_quant_mat[64], guint8 * load_quant_mat)
{
READ_UINT8 (br, *load_quant_mat, 1);
if (*load_quant_mat) {
guint i;
guint8 val;
val = 1;
for (i = 0; i < 64; i++) {
if (val != 0)
READ_UINT8 (br, val, 8);
if (val == 0) {
if (i == 0)
goto invalid_quant_mat;
quant_mat[mpeg4_zigzag_8x8[i]] = quant_mat[mpeg4_zigzag_8x8[i - 1]];
} else
quant_mat[mpeg4_zigzag_8x8[i]] = val;
}
} else
memcpy (quant_mat, default_quant_mat, 64);
return TRUE;
failed:
GST_WARNING ("failed parsing quant matrix");
return FALSE;
invalid_quant_mat:
GST_WARNING ("the first value should be non zero");
goto failed;
}
static gboolean
parse_signal_type (GstBitReader * br, GstMpeg4VideoSignalType * signal_type)
{
READ_UINT8 (br, signal_type->type, 1);
if (signal_type->type) {
READ_UINT8 (br, signal_type->format, 3);
READ_UINT8 (br, signal_type->range, 1);
READ_UINT8 (br, signal_type->color_description, 1);
if (signal_type->color_description) {
READ_UINT8 (br, signal_type->color_primaries, 8);
READ_UINT8 (br, signal_type->transfer_characteristics, 8);
READ_UINT8 (br, signal_type->matrix_coefficients, 8);
}
}
return TRUE;
failed:
GST_WARNING ("failed parsing \"Video Signal Type\"");
return FALSE;
}
static gboolean
parse_sprite_trajectory (GstBitReader * br,
GstMpeg4SpriteTrajectory * sprite_traj, guint no_of_sprite_warping_points)
{
guint i, length;
for (i = 0; i < no_of_sprite_warping_points; i++) {
if (!decode_vlc (br, &length, mpeg4_dmv_size_vlc_table,
G_N_ELEMENTS (mpeg4_dmv_size_vlc_table)))
goto failed;
if (length)
READ_UINT16 (br, sprite_traj->vop_ref_points[i], length);
CHECK_MARKER (br);
if (!decode_vlc (br, &length, mpeg4_dmv_size_vlc_table,
G_N_ELEMENTS (mpeg4_dmv_size_vlc_table)))
goto failed;
if (length)
READ_UINT16 (br, sprite_traj->sprite_ref_points[i], length);
CHECK_MARKER (br);
}
return TRUE;
failed:
GST_WARNING ("Could not parse the sprite trajectory");
return FALSE;
}
static guint
find_psc (GstByteReader * br)
{
guint psc_pos = -1, psc;
if (!gst_byte_reader_peek_uint24_be (br, &psc))
goto failed;
/* Scan for the picture start code (22 bits - 0x0020) */
while ((gst_byte_reader_get_remaining (br) >= 3)) {
if (gst_byte_reader_peek_uint24_be (br, &psc) &&
((psc & 0xfffffc) == 0x000080)) {
psc_pos = gst_byte_reader_get_pos (br);
break;
} else
gst_byte_reader_skip_unchecked (br, 1);
}
failed:
return psc_pos;
}
static inline guint8
compute_resync_marker_size (const GstMpeg4VideoObjectPlane * vop,
guint32 * pattern, guint32 * mask)
{
guint8 off;
/* FIXME handle the binary only shape case */
switch (vop->coding_type) {
case (GST_MPEG4_I_VOP):
off = 16;
break;
case (GST_MPEG4_S_VOP):
case (GST_MPEG4_P_VOP):
off = 15 + vop->fcode_forward;
break;
case (GST_MPEG4_B_VOP):
off = MAX (15 + MAX (vop->fcode_forward, vop->fcode_backward), 17);
break;
default:
return -1;
}
if (mask && pattern) {
switch (off) {
case 16:
*pattern = 0x00008000;
*mask = 0xffff8000;
break;
case 17:
*pattern = 0x00004000;
*mask = 0xffffc000;
break;
case 18:
*pattern = 0x00002000;
*mask = 0xffffe000;
break;
case 19:
*pattern = 0x00001000;
*mask = 0xfffff000;
break;
case 20:
*pattern = 0x00000800;
*mask = 0xfffff800;
break;
case 21:
*pattern = 0x00000400;
*mask = 0xfffffc00;
break;
case 22:
*pattern = 0x00000200;
*mask = 0xfffffe00;
break;
case 23:
*pattern = 0x00000100;
*mask = 0xffffff00;
break;
}
}
return off + 1; /* Take the following 1 into account */
}
/**
* gst_mpeg4_next_resync:
* @packet: The #GstMpeg4Packet to fill
* @vop: The previously parsed #GstMpeg4VideoObjectPlane
* @offset: offset from which to start the parsing
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data and fills @packet with the information of the next resync packet
* found.
*
* Returns: a #GstMpeg4ParseResult
*/
static GstMpeg4ParseResult
gst_mpeg4_next_resync (GstMpeg4Packet * packet,
const GstMpeg4VideoObjectPlane * vop, const guint8 * data, gsize size,
gboolean first_resync_marker)
{
guint markersize = 0, off1, off2;
guint32 mask = 0xff, pattern = 0xff;
GstByteReader br;
gst_byte_reader_init (&br, data, size);
g_return_val_if_fail (packet != NULL, GST_MPEG4_PARSER_ERROR);
g_return_val_if_fail (vop != NULL, GST_MPEG4_PARSER_ERROR);
markersize = compute_resync_marker_size (vop, &pattern, &mask);
if (first_resync_marker) {
off1 = 0;
} else {
off1 = gst_byte_reader_masked_scan_uint32 (&br, mask, pattern, 0, size);
}
if (off1 == -1)
return GST_MPEG4_PARSER_NO_PACKET;
GST_DEBUG ("Resync code found at %i", off1);
packet->offset = off1;
packet->type = GST_MPEG4_RESYNC;
packet->marker_size = markersize;
off2 = gst_byte_reader_masked_scan_uint32 (&br, mask, pattern,
off1 + 2, size - off1 - 2);
if (off2 == -1)
return GST_MPEG4_PARSER_NO_PACKET_END;
packet->size = off2 - off1;
return GST_MPEG4_PARSER_OK;
}
/********** API **********/
/**
* gst_mpeg4_parse:
* @packet: The #GstMpeg4Packet to fill
* @skip_user_data: %TRUE to skip user data packet %FALSE otherwise
* @vop: The last parsed #GstMpeg4VideoObjectPlane or %NULL if you do
* not need to detect the resync codes.
* @offset: offset from which to start the parsing
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data and fills @packet with the information of the next packet
* found.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse (GstMpeg4Packet * packet, gboolean skip_user_data,
GstMpeg4VideoObjectPlane * vop, const guint8 * data, guint offset,
gsize size)
{
gint off1, off2;
GstByteReader br;
GstMpeg4ParseResult resync_res;
static guint first_resync_marker = TRUE;
gst_byte_reader_init (&br, data, size);
g_return_val_if_fail (packet != NULL, GST_MPEG4_PARSER_ERROR);
if (size - offset <= 4) {
GST_DEBUG ("Can't parse, buffer is to small size %" G_GSIZE_FORMAT
" at offset %d", size, offset);
return GST_MPEG4_PARSER_ERROR;
}
if (vop) {
resync_res =
gst_mpeg4_next_resync (packet, vop, data + offset, size - offset,
first_resync_marker);
first_resync_marker = FALSE;
/* We found a complete slice */
if (resync_res == GST_MPEG4_PARSER_OK)
return resync_res;
else if (resync_res == GST_MPEG4_PARSER_NO_PACKET_END) {
/* It doesn't mean there is no standard packet end, look for it */
off1 = packet->offset;
goto find_end;
} else if (resync_res == GST_MPEG4_PARSER_NO_PACKET)
return resync_res;
} else {
first_resync_marker = TRUE;
}
off1 = gst_byte_reader_masked_scan_uint32 (&br, 0xffffff00, 0x00000100,
offset, size - offset);
if (off1 == -1) {
GST_DEBUG ("No start code prefix in this buffer");
return GST_MPEG4_PARSER_NO_PACKET;
}
/* Recursively skip user data if needed */
if (skip_user_data && data[off1 + 3] == GST_MPEG4_USER_DATA)
/* If we are here, we know no resync code has been found the first time, so we
* don't look for it this time */
return gst_mpeg4_parse (packet, skip_user_data, NULL, data, off1 + 3, size);
packet->offset = off1 + 3;
packet->data = data;
packet->type = (GstMpeg4StartCode) (data[off1 + 3]);
find_end:
if (off1 < size - 4)
off2 = gst_byte_reader_masked_scan_uint32 (&br, 0xffffff00, 0x00000100,
off1 + 4, size - off1 - 4);
else
off2 = -1;
if (off2 == -1) {
GST_DEBUG ("Packet start %d, No end found", off1 + 4);
packet->size = G_MAXUINT;
return GST_MPEG4_PARSER_NO_PACKET_END;
}
if (packet->type == GST_MPEG4_RESYNC) {
packet->size = (gsize) off2 - off1;
} else {
packet->size = (gsize) off2 - off1 - 3;
}
GST_DEBUG ("Complete packet of type %x found at: %d, Size: %" G_GSIZE_FORMAT,
packet->type, packet->offset, packet->size);
return GST_MPEG4_PARSER_OK;
}
/**
* gst_h263_parse:
* @packet: The #GstMpeg4Packet to fill
* @offset: offset from which to start the parsing
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data and fills @packet with the information of the next packet
* found.
*
* Note that the type of the packet is meaningless in this case.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_h263_parse (GstMpeg4Packet * packet,
const guint8 * data, guint offset, gsize size)
{
gint off1, off2;
GstByteReader br;
gst_byte_reader_init (&br, data + offset, size - offset);
g_return_val_if_fail (packet != NULL, GST_MPEG4_PARSER_ERROR);
if (size - offset < 3) {
GST_DEBUG ("Can't parse, buffer is to small size %" G_GSIZE_FORMAT
" at offset %d", size, offset);
return GST_MPEG4_PARSER_ERROR;
}
off1 = find_psc (&br);
if (off1 == -1) {
GST_DEBUG ("No start code prefix in this buffer");
return GST_MPEG4_PARSER_NO_PACKET;
}
packet->offset = off1 + offset;
packet->data = data;
gst_byte_reader_skip_unchecked (&br, 3);
off2 = find_psc (&br);
if (off2 == -1) {
GST_DEBUG ("Packet start %d, No end found", off1);
packet->size = G_MAXUINT;
return GST_MPEG4_PARSER_NO_PACKET_END;
}
packet->size = (gsize) off2 - off1;
GST_DEBUG ("Complete packet found at: %d, Size: %" G_GSIZE_FORMAT,
packet->offset, packet->size);
return GST_MPEG4_PARSER_OK;
}
/**
* gst_mpeg4_parse_visual_object_sequence:
* @vos: The #GstMpeg4VisualObjectSequence structure to fill
* @data: The data to parse, should contain the visual_object_sequence_start_code
* but not the start code prefix
* @size: The size of the @data to parse
*
* Parses @data containing the visual object sequence packet, and fills
* the @vos structure.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse_visual_object_sequence (GstMpeg4VisualObjectSequence * vos,
const guint8 * data, gsize size)
{
guint8 vos_start_code;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (vos != NULL, GST_MPEG4_PARSER_ERROR);
READ_UINT8 (&br, vos_start_code, 8);
if (vos_start_code != GST_MPEG4_VISUAL_OBJ_SEQ_START)
goto wrong_start_code;
READ_UINT8 (&br, vos->profile_and_level_indication, 8);
switch (vos->profile_and_level_indication) {
case 0x01:
vos->profile = GST_MPEG4_PROFILE_SIMPLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x02:
vos->profile = GST_MPEG4_PROFILE_SIMPLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x03:
vos->profile = GST_MPEG4_PROFILE_SIMPLE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0x08:
vos->profile = GST_MPEG4_PROFILE_SIMPLE;
vos->level = GST_MPEG4_LEVEL0;
break;
case 0x10:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_SCALABLE;
vos->level = GST_MPEG4_LEVEL0;
break;
case 0x11:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_SCALABLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x12:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_SCALABLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x21:
vos->profile = GST_MPEG4_PROFILE_CORE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x22:
vos->profile = GST_MPEG4_PROFILE_CORE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x32:
vos->profile = GST_MPEG4_PROFILE_MAIN;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x33:
vos->profile = GST_MPEG4_PROFILE_MAIN;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0x34:
vos->profile = GST_MPEG4_PROFILE_MAIN;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0x42:
vos->profile = GST_MPEG4_PROFILE_N_BIT;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x51:
vos->profile = GST_MPEG4_PROFILE_SCALABLE_TEXTURE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x61:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_FACE_ANIMATION;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x62:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_FACE_ANIMATION;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x63:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_FBA;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x64:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_FBA;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x71:
vos->profile = GST_MPEG4_PROFILE_BASIC_ANIMATED_TEXTURE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x72:
vos->profile = GST_MPEG4_PROFILE_BASIC_ANIMATED_TEXTURE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x81:
vos->profile = GST_MPEG4_PROFILE_HYBRID;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x82:
vos->profile = GST_MPEG4_PROFILE_HYBRID;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x91:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_REALTIME_SIMPLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0x92:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_REALTIME_SIMPLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0x93:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_REALTIME_SIMPLE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0x94:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_REALTIME_SIMPLE;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xa1:
vos->profile = GST_MPEG4_PROFILE_CORE_SCALABLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xa2:
vos->profile = GST_MPEG4_PROFILE_CORE_SCALABLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xa3:
vos->profile = GST_MPEG4_PROFILE_CORE_SCALABLE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xb1:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xb2:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xb3:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xb4:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xc1:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CORE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xc2:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CORE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xc3:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_CORE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xd1:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SCALABLE_TEXTURE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xd2:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SCALABLE_TEXTURE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xd3:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SCALABLE_TEXTURE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xe1:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_STUDIO;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xe2:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_STUDIO;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xe3:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_STUDIO;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xe4:
vos->profile = GST_MPEG4_PROFILE_SIMPLE_STUDIO;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xe5:
vos->profile = GST_MPEG4_PROFILE_CORE_STUDIO;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xe6:
vos->profile = GST_MPEG4_PROFILE_CORE_STUDIO;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xe7:
vos->profile = GST_MPEG4_PROFILE_CORE_STUDIO;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xe8:
vos->profile = GST_MPEG4_PROFILE_CORE_STUDIO;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xf0:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL0;
break;
case 0xf1:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xf2:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xf3:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xf4:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xf5:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL5;
break;
case 0xf7:
vos->profile = GST_MPEG4_PROFILE_ADVANCED_SIMPLE;
vos->level = GST_MPEG4_LEVEL3b;
break;
case 0xf8:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL0;
break;
case 0xf9:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL1;
break;
case 0xfa:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL2;
break;
case 0xfb:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL3;
break;
case 0xfc:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL4;
break;
case 0xfd:
vos->profile = GST_MPEG4_PROFILE_FINE_GRANULARITY_SCALABLE;
vos->level = GST_MPEG4_LEVEL5;
break;
default:
vos->profile = GST_MPEG4_PROFILE_RESERVED;
vos->level = GST_MPEG4_LEVEL_RESERVED;
break;
}
return GST_MPEG4_PARSER_OK;
wrong_start_code:
GST_WARNING ("got buffer with wrong start code");
return GST_MPEG4_PARSER_ERROR;
failed:
GST_WARNING ("failed parsing \"Visual Object\"");
return GST_MPEG4_PARSER_ERROR;
}
/**
* gst_mpeg4_parse_visual_object:
* @vo: The #GstMpeg4VisualObject structure to fill
* @signal_type: The #GstMpeg4VideoSignalType to fill or %NULL
* @data: The data to parse, should contain the vo_start_code
* but not the start code prefix
* @size: The size of the @data to parse
*
* Parses @data containing the visual object packet, and fills
* the @vo structure.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse_visual_object (GstMpeg4VisualObject * vo,
GstMpeg4VideoSignalType * signal_type, const guint8 * data, gsize size)
{
guint8 vo_start_code, type;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (vo != NULL, GST_MPEG4_PARSER_ERROR);
GST_DEBUG ("Parsing visual object");
READ_UINT8 (&br, vo_start_code, 8);
if (vo_start_code != GST_MPEG4_VISUAL_OBJ)
goto wrong_start_code;
/* set default values */
vo->verid = 0x1;
vo->priority = 1;
READ_UINT8 (&br, vo->is_identifier, 1);
if (vo->is_identifier) {
READ_UINT8 (&br, vo->verid, 4);
READ_UINT8 (&br, vo->priority, 3);
}
READ_UINT8 (&br, type, 4);
vo->type = type;
if ((type == GST_MPEG4_VIDEO_ID ||
type == GST_MPEG4_STILL_TEXTURE_ID) && signal_type) {
if (!parse_signal_type (&br, signal_type))
goto failed;
} else if (signal_type) {
signal_type->type = 0;
}
return GST_MPEG4_PARSER_OK;
wrong_start_code:
GST_WARNING ("got buffer with wrong start code");
return GST_MPEG4_PARSER_ERROR;
failed:
GST_WARNING ("failed parsing \"Visual Object\"");
return GST_MPEG4_PARSER_ERROR;
}
/**
* gst_mpeg4_parse_video_object_layer:
* @vol: The #GstMpeg4VideoObjectLayer structure to fill
* @vo: The #GstMpeg4VisualObject currently being parsed or %NULL
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data containing the video object layer packet, and fills
* the @vol structure.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse_video_object_layer (GstMpeg4VideoObjectLayer * vol,
GstMpeg4VisualObject * vo, const guint8 * data, gsize size)
{
guint8 video_object_layer_start_code;
/* Used for enums types */
guint8 tmp;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (vol != NULL, GST_MPEG4_PARSER_ERROR);
GST_DEBUG ("Parsing video object layer");
READ_UINT8 (&br, video_object_layer_start_code, 8);
if (!(video_object_layer_start_code >= GST_MPEG4_VIDEO_LAYER_FIRST &&
video_object_layer_start_code <= GST_MPEG4_VIDEO_LAYER_LAST))
goto wrong_start_code;
/* set default values */
if (vo) {
vol->verid = vo->verid;
vol->priority = vo->priority;
} else {
vol->verid = 1;
vol->priority = 0;
}
vol->low_delay = FALSE;
vol->chroma_format = 1;
vol->vbv_parameters = FALSE;
vol->quant_precision = 5;
vol->bits_per_pixel = 8;
vol->quarter_sample = FALSE;
vol->newpred_enable = FALSE;
vol->interlaced = 0;
vol->width = 0;
vol->height = 0;
READ_UINT8 (&br, vol->random_accessible_vol, 1);
READ_UINT8 (&br, vol->video_object_type_indication, 8);
READ_UINT8 (&br, vol->is_object_layer_identifier, 1);
if (vol->is_object_layer_identifier) {
READ_UINT8 (&br, vol->verid, 4);
READ_UINT8 (&br, vol->priority, 3);
}
READ_UINT8 (&br, tmp, 4);
vol->aspect_ratio_info = tmp;
if (vol->aspect_ratio_info != GST_MPEG4_EXTENDED_PAR) {
mpeg4_util_par_from_info (vol->aspect_ratio_info, &vol->par_width,
&vol->par_height);
} else {
gint v;
READ_UINT8 (&br, vol->par_width, 8);
v = vol->par_width;
CHECK_ALLOWED (v, 1, 255);
READ_UINT8 (&br, vol->par_height, 8);
v = vol->par_height;
CHECK_ALLOWED (v, 1, 255);
}
GST_DEBUG ("Pixel aspect ratio %d/%d", vol->par_width, vol->par_width);
READ_UINT8 (&br, vol->control_parameters, 1);
if (vol->control_parameters) {
guint8 chroma_format;
READ_UINT8 (&br, chroma_format, 2);
vol->chroma_format = chroma_format;
READ_UINT8 (&br, vol->low_delay, 1);
READ_UINT8 (&br, vol->vbv_parameters, 1);
if (vol->vbv_parameters) {
CHECK_REMAINING (&br, 79);
vol->first_half_bitrate =
gst_bit_reader_get_bits_uint16_unchecked (&br, 15);
MARKER_UNCHECKED (&br);
vol->latter_half_bitrate =
gst_bit_reader_get_bits_uint16_unchecked (&br, 15);
MARKER_UNCHECKED (&br);
vol->bit_rate =
(vol->first_half_bitrate << 15) | vol->latter_half_bitrate;
vol->first_half_vbv_buffer_size =
gst_bit_reader_get_bits_uint16_unchecked (&br, 15);
MARKER_UNCHECKED (&br);
vol->latter_half_vbv_buffer_size =
gst_bit_reader_get_bits_uint8_unchecked (&br, 3);
vol->vbv_buffer_size = (vol->first_half_vbv_buffer_size << 15) |
vol->latter_half_vbv_buffer_size;
vol->first_half_vbv_occupancy =
gst_bit_reader_get_bits_uint16_unchecked (&br, 11);
MARKER_UNCHECKED (&br);
vol->latter_half_vbv_occupancy =
gst_bit_reader_get_bits_uint16_unchecked (&br, 15);
MARKER_UNCHECKED (&br);
}
}
READ_UINT8 (&br, tmp, 2);
vol->shape = tmp;
if (vol->shape == GST_MPEG4_GRAYSCALE) {
/* TODO support grayscale shapes, for now we just pass */
/* Something the standard starts to define... */
GST_WARNING ("Grayscale shaped not supported");
goto failed;
}
if (vol->shape == GST_MPEG4_GRAYSCALE && vol->verid != 0x01)
READ_UINT8 (&br, vol->shape_extension, 4);
CHECK_REMAINING (&br, 19);
MARKER_UNCHECKED (&br);
vol->vop_time_increment_resolution =
gst_bit_reader_get_bits_uint16_unchecked (&br, 16);
if (vol->vop_time_increment_resolution < 1) {
GST_WARNING ("value not in allowed range. value: %d, range %d-%d",
vol->vop_time_increment_resolution, 1, G_MAXUINT16);
goto failed;
}
vol->vop_time_increment_bits =
g_bit_storage (vol->vop_time_increment_resolution);
MARKER_UNCHECKED (&br);
vol->fixed_vop_rate = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
if (vol->fixed_vop_rate)
READ_UINT16 (&br, vol->fixed_vop_time_increment,
vol->vop_time_increment_bits);
if (vol->shape != GST_MPEG4_BINARY_ONLY) {
if (vol->shape == GST_MPEG4_RECTANGULAR) {
CHECK_REMAINING (&br, 29);
MARKER_UNCHECKED (&br);
vol->width = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vol->height = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
}
READ_UINT8 (&br, vol->interlaced, 1);
READ_UINT8 (&br, vol->obmc_disable, 1);
if (vol->verid == 0x1)
READ_UINT8 (&br, tmp, 1);
else
READ_UINT8 (&br, tmp, 2);
vol->sprite_enable = tmp;
if (vol->sprite_enable == GST_MPEG4_SPRITE_STATIC ||
vol->sprite_enable == GST_MPEG4_SPRITE_GMG) {
if (vol->sprite_enable == GST_MPEG4_SPRITE_GMG)
CHECK_REMAINING (&br, 9);
else {
CHECK_REMAINING (&br, 65);
vol->sprite_width = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vol->sprite_height = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vol->sprite_left_coordinate =
gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vol->sprite_top_coordinate =
gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
}
vol->no_of_sprite_warping_points =
gst_bit_reader_get_bits_uint8_unchecked (&br, 6);
vol->sprite_warping_accuracy =
gst_bit_reader_get_bits_uint8_unchecked (&br, 2);
vol->sprite_brightness_change =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
if (vol->sprite_enable != GST_MPEG4_SPRITE_GMG)
vol->low_latency_sprite_enable =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
}
if (vol->verid != 0x1 && vol->shape != GST_MPEG4_RECTANGULAR)
READ_UINT8 (&br, vol->sadct_disable, 1);
READ_UINT8 (&br, vol->not_8_bit, 1);
if (vol->not_8_bit) {
READ_UINT8 (&br, vol->quant_precision, 4);
CHECK_ALLOWED (vol->quant_precision, 3, 9);
READ_UINT8 (&br, vol->bits_per_pixel, 4);
CHECK_ALLOWED (vol->bits_per_pixel, 4, 12);
}
if (vol->shape == GST_MPEG4_GRAYSCALE) {
/* We don't actually support it */
READ_UINT8 (&br, vol->no_gray_quant_update, 1);
READ_UINT8 (&br, vol->composition_method, 1);
READ_UINT8 (&br, vol->linear_composition, 1);
}
READ_UINT8 (&br, vol->quant_type, 1);
if (vol->quant_type) {
if (!parse_quant (&br, vol->intra_quant_mat, default_intra_quant_mat,
&vol->load_intra_quant_mat))
goto failed;
if (!parse_quant (&br, vol->non_intra_quant_mat,
default_non_intra_quant_mat, &vol->load_non_intra_quant_mat))
goto failed;
if (vol->shape == GST_MPEG4_GRAYSCALE) {
/* Something the standard starts to define... */
GST_WARNING ("Grayscale shaped not supported");
goto failed;
}
} else {
memset (&vol->intra_quant_mat, 0, 64);
memset (&vol->non_intra_quant_mat, 0, 64);
}
if (vol->verid != 0x1)
READ_UINT8 (&br, vol->quarter_sample, 1);
READ_UINT8 (&br, vol->complexity_estimation_disable, 1);
if (!vol->complexity_estimation_disable) {
guint8 estimation_method;
guint8 estimation_disable;
/* skip unneeded properties */
READ_UINT8 (&br, estimation_method, 2);
if (estimation_method < 2) {
READ_UINT8 (&br, estimation_disable, 1);
if (!estimation_disable)
SKIP (&br, 6);
READ_UINT8 (&br, estimation_disable, 1);
if (!estimation_disable)
SKIP (&br, 4);
CHECK_MARKER (&br);
READ_UINT8 (&br, estimation_disable, 1);
if (!estimation_disable)
SKIP (&br, 4);
READ_UINT8 (&br, estimation_disable, 1);
if (!estimation_disable)
SKIP (&br, 6);
CHECK_MARKER (&br);
if (estimation_method == 1) {
READ_UINT8 (&br, estimation_disable, 1);
if (!estimation_disable)
SKIP (&br, 2);
}
}
}
READ_UINT8 (&br, vol->resync_marker_disable, 1);
READ_UINT8 (&br, vol->data_partitioned, 1);
if (vol->data_partitioned)
READ_UINT8 (&br, vol->reversible_vlc, 1);
if (vol->verid != 0x01) {
READ_UINT8 (&br, vol->newpred_enable, 1);
if (vol->newpred_enable)
/* requested_upstream_message_type and newpred_segment_type */
SKIP (&br, 3);
READ_UINT8 (&br, vol->reduced_resolution_vop_enable, 1);
}
READ_UINT8 (&br, vol->scalability, 1);
if (vol->scalability) {
SKIP (&br, 26); /* Few not needed props */
READ_UINT8 (&br, vol->enhancement_type, 1);
}
/* More unused infos */
} else if (vol->verid != 0x01) {
GST_WARNING ("Binary only shapes not fully supported");
goto failed;
}
/* ... */
return GST_MPEG4_PARSER_OK;
failed:
GST_WARNING ("failed parsing \"Video Object Layer\"");
return GST_MPEG4_PARSER_ERROR;
wrong_start_code:
GST_WARNING ("got buffer with wrong start code");
goto failed;
}
/**
* gst_mpeg4_parse_group_of_vop:
* @gov: The #GstMpeg4GroupOfVOP structure to fill
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data containing the group of video object plane packet, and fills
* the @gov structure.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse_group_of_vop (GstMpeg4GroupOfVOP *
gov, const guint8 * data, gsize size)
{
guint8 gov_start_code;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (gov != NULL, GST_MPEG4_PARSER_ERROR);
READ_UINT8 (&br, gov_start_code, 8);
if (gov_start_code != GST_MPEG4_GROUP_OF_VOP)
goto wrong_start_code;
CHECK_REMAINING (&br, 65);
gov->hours = gst_bit_reader_get_bits_uint8_unchecked (&br, 5);
gov->minutes = gst_bit_reader_get_bits_uint8_unchecked (&br, 6);
/* marker bit */
MARKER_UNCHECKED (&br);
gov->seconds = gst_bit_reader_get_bits_uint8_unchecked (&br, 6);
gov->closed = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
gov->broken_link = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
return GST_MPEG4_PARSER_OK;
failed:
GST_WARNING ("failed parsing \"Group of Video Object Plane\"");
return GST_MPEG4_PARSER_ERROR;
wrong_start_code:
GST_WARNING ("got buffer with wrong start code");
goto failed;
}
/**
* gst_mpeg4_parse_video_object_plane:
* @vop: The #GstMpeg4VideoObjectPlane currently being parsed
* @sprite_trajectory: A #GstMpeg4SpriteTrajectory to fill or %NULL
* @vol: The #GstMpeg4VideoObjectLayer structure to fill
* @data: The data to parse
* @size: The size of the @data to parse
*
* Parses @data containing the video object plane packet, and fills the @vol
* structure.
*
* Returns: a #GstMpeg4ParseResult
*/
GstMpeg4ParseResult
gst_mpeg4_parse_video_object_plane (GstMpeg4VideoObjectPlane * vop,
GstMpeg4SpriteTrajectory * sprite_trajectory,
GstMpeg4VideoObjectLayer * vol, const guint8 * data, gsize size)
{
guint8 vop_start_code, coding_type, modulo_time_base;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (vop != NULL, GST_MPEG4_PARSER_ERROR);
if (vol->shape == GST_MPEG4_BINARY_ONLY) {
/* TODO: implement binary only shapes */
GST_WARNING ("Binary only shapes not supported");
goto failed;
}
READ_UINT8 (&br, vop_start_code, 8);
if (vop_start_code != GST_MPEG4_VIDEO_OBJ_PLANE)
goto wrong_start_code;
/* set default values */
vop->modulo_time_base = 0;
vop->rounding_type = 0;
vop->top_field_first = 1;
vop->alternate_vertical_scan_flag = 0;
vop->fcode_forward = 1;
vop->fcode_backward = 1;
/* Compute macroblock information */
if (vol->interlaced)
vop->mb_height = (2 * (vol->height + 31) / 32);
else
vop->mb_height = (vol->height + 15) / 16;
vop->mb_width = (vol->width + 15) / 16;
vop->mb_num = vop->mb_height * vop->mb_width;
READ_UINT8 (&br, coding_type, 2);
vop->coding_type = coding_type;
READ_UINT8 (&br, modulo_time_base, 1);
while (modulo_time_base) {
vop->modulo_time_base++;
READ_UINT8 (&br, modulo_time_base, 1);
}
CHECK_REMAINING (&br, vol->vop_time_increment_bits + 3);
MARKER_UNCHECKED (&br);
vop->time_increment =
gst_bit_reader_get_bits_uint16_unchecked (&br,
vol->vop_time_increment_bits);
MARKER_UNCHECKED (&br);
vop->coded = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
if (!vop->coded)
return GST_MPEG4_PARSER_OK;
if (vol->newpred_enable) {
guint16 nbbits =
vop->time_increment + 3 < 15 ? vop->time_increment + 3 : 15;
READ_UINT16 (&br, vop->id, nbbits);
READ_UINT8 (&br, vop->id_for_prediction_indication, 1);
if (vop->id_for_prediction_indication) {
/* Would be nice if the standard actually told us... */
READ_UINT16 (&br, vop->id, nbbits);
CHECK_MARKER (&br);
}
}
if (vol->shape != GST_MPEG4_BINARY_ONLY &&
(vop->coding_type == GST_MPEG4_P_VOP ||
(vop->coding_type == GST_MPEG4_S_VOP &&
vol->sprite_enable == GST_MPEG4_SPRITE_GMG)))
READ_UINT8 (&br, vop->rounding_type, 1);
if ((vol->reduced_resolution_vop_enable) &&
(vol->shape == GST_MPEG4_RECTANGULAR ||
(vop->coding_type = GST_MPEG4_P_VOP ||
vop->coding_type == GST_MPEG4_I_VOP)))
READ_UINT8 (&br, vop->reduced_resolution, 1);
if (vol->shape != GST_MPEG4_RECTANGULAR) {
if (vol->sprite_enable == GST_MPEG4_SPRITE_STATIC &&
vop->coding_type == GST_MPEG4_I_VOP) {
CHECK_REMAINING (&br, 55);
vop->width = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vop->height = gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vop->horizontal_mc_spatial_ref =
gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
vop->vertical_mc_spatial_ref =
gst_bit_reader_get_bits_uint16_unchecked (&br, 13);
MARKER_UNCHECKED (&br);
/* Recompute the Macroblock information
* accordingly to the new values */
if (vol->interlaced)
vop->mb_height = (2 * (vol->height + 31) / 32);
else
vop->mb_height = (vol->height + 15) / 16;
vop->mb_width = (vol->width + 15) / 16;
vop->mb_num = vop->mb_height * vop->mb_width;
}
if ((vol->shape != GST_MPEG4_BINARY_ONLY) &&
vol->scalability && vol->enhancement_type)
READ_UINT8 (&br, vop->background_composition, 1);
READ_UINT8 (&br, vop->change_conv_ratio_disable, 1);
READ_UINT8 (&br, vop->constant_alpha, 1);
if (vop->constant_alpha)
READ_UINT8 (&br, vop->constant_alpha_value, 1);
}
if (vol->shape != GST_MPEG4_BINARY_ONLY) {
if (!vol->complexity_estimation_disable) {
GST_WARNING ("Complexity estimation not supported");
goto failed;
}
READ_UINT8 (&br, vop->intra_dc_vlc_thr, 3);
if (vol->interlaced) {
READ_UINT8 (&br, vop->top_field_first, 1);
READ_UINT8 (&br, vop->alternate_vertical_scan_flag, 1);
}
}
if ((vol->sprite_enable == GST_MPEG4_SPRITE_STATIC ||
vol->sprite_enable == GST_MPEG4_SPRITE_GMG) &&
vop->coding_type == GST_MPEG4_S_VOP) {
/* only if @sprite_trajectory is not NULL we parse it */
if (sprite_trajectory && vol->no_of_sprite_warping_points)
parse_sprite_trajectory (&br, sprite_trajectory,
vol->no_of_sprite_warping_points);
if (vol->sprite_brightness_change) {
GST_WARNING ("sprite_brightness_change not supported");
goto failed;
}
if (vol->sprite_enable == GST_MPEG4_SPRITE_STATIC) {
GST_WARNING ("sprite enable static not supported");
goto failed;
}
}
if (vol->shape != GST_MPEG4_BINARY_ONLY) {
READ_UINT16 (&br, vop->quant, vol->quant_precision);
if (vol->shape == GST_MPEG4_GRAYSCALE) {
/* TODO implement grayscale support */
GST_WARNING ("Grayscale shapes no supported");
/* TODO implement me */
goto failed;
}
if (vop->coding_type != GST_MPEG4_I_VOP) {
READ_UINT8 (&br, vop->fcode_forward, 3);
CHECK_ALLOWED (vop->fcode_forward, 1, 7);
}
if (vop->coding_type == GST_MPEG4_B_VOP) {
READ_UINT8 (&br, vop->fcode_backward, 3);
CHECK_ALLOWED (vop->fcode_backward, 1, 7);
}
}
if (!vol->scalability) {
if (vol->shape != GST_MPEG4_RECTANGULAR)
READ_UINT8 (&br, vop->shape_coding_type, 1);
} else {
if (vol->enhancement_type) {
READ_UINT8 (&br, vop->load_backward_shape, 1);
if (vop->load_backward_shape) {
GST_WARNING ("Load backward shape not supported");
goto failed;
}
READ_UINT8 (&br, vop->ref_select_code, 2);
}
}
vop->size = gst_bit_reader_get_pos (&br);
/* More things to possibly parse ... */
return GST_MPEG4_PARSER_OK;
failed:
GST_WARNING ("failed parsing \"Video Object Plane\"");
return GST_MPEG4_PARSER_ERROR;
wrong_start_code:
GST_WARNING ("got buffer with wrong start code");
goto failed;
}
/**
* gst_mpeg4_parse_video_plane_with_short_header:
* @shorthdr: The #GstMpeg4VideoPlaneShortHdr to parse
* @data: The data to parse
* @size: The size of the @data to parse
*/
GstMpeg4ParseResult
gst_mpeg4_parse_video_plane_short_header (GstMpeg4VideoPlaneShortHdr *
shorthdr, const guint8 * data, gsize size)
{
guint8 zero_bits;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (shorthdr != NULL, GST_MPEG4_PARSER_ERROR);
if (gst_bit_reader_get_remaining (&br) < 48)
goto failed;
if (gst_bit_reader_get_bits_uint32_unchecked (&br, 22) != 0x20)
goto failed;
shorthdr->temporal_reference =
gst_bit_reader_get_bits_uint8_unchecked (&br, 8);
CHECK_MARKER (&br);
zero_bits = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
if (zero_bits != 0x00)
goto failed;
shorthdr->split_screen_indicator =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
shorthdr->document_camera_indicator =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
shorthdr->full_picture_freeze_release =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
shorthdr->source_format = gst_bit_reader_get_bits_uint8_unchecked (&br, 3);
/* Set parameters/Table 6-25 */
switch (shorthdr->source_format) {
case 0x01:
shorthdr->vop_width = 128;
shorthdr->vop_height = 96;
shorthdr->num_macroblocks_in_gob = 8;
shorthdr->num_gobs_in_vop = 6;
break;
case 0x02:
shorthdr->vop_width = 176;
shorthdr->vop_height = 144;
shorthdr->num_macroblocks_in_gob = 11;
shorthdr->num_gobs_in_vop = 9;
break;
case 0x03:
shorthdr->vop_width = 352;
shorthdr->vop_height = 288;
shorthdr->num_macroblocks_in_gob = 22;
shorthdr->num_gobs_in_vop = 18;
break;
case 0x04:
shorthdr->vop_width = 704;
shorthdr->vop_height = 576;
shorthdr->num_macroblocks_in_gob = 88;
shorthdr->num_gobs_in_vop = 18;
break;
case 0x05:
shorthdr->vop_width = 1408;
shorthdr->vop_height = 1152;
shorthdr->num_macroblocks_in_gob = 352;
shorthdr->num_gobs_in_vop = 18;
break;
default:
shorthdr->vop_width = 0;
shorthdr->vop_height = 0;
shorthdr->num_macroblocks_in_gob = 0;
shorthdr->num_gobs_in_vop = 0;
}
shorthdr->picture_coding_type =
gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
zero_bits = gst_bit_reader_get_bits_uint8_unchecked (&br, 4);
if (zero_bits != 0x00)
goto failed;
shorthdr->vop_quant = gst_bit_reader_get_bits_uint8_unchecked (&br, 5);
zero_bits = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
if (zero_bits != 0x00)
goto failed;
do {
READ_UINT8 (&br, shorthdr->pei, 1);
if (shorthdr->pei == 1)
READ_UINT8 (&br, shorthdr->psupp, 8);
} while (shorthdr->pei == 1);
shorthdr->size = gst_bit_reader_get_pos (&br);
return GST_MPEG4_PARSER_OK;
failed:
GST_WARNING ("Could not parse the Plane short header");
return GST_MPEG4_PARSER_ERROR;
}
/**
* gst_mpeg4_parse_video_packet_header:
* @videopackethdr: The #GstMpeg4VideoPacketHdr structure to fill
* @vol: The last parsed #GstMpeg4VideoObjectLayer, will be updated
* with the information found during the parsing
* @vop: The last parsed #GstMpeg4VideoObjectPlane, will be updated
* with the information found during the parsing
* @sprite_trajectory: A #GstMpeg4SpriteTrajectory to fill or %NULL
* with the information found during the parsing
* @data: The data to parse, should be set after the resync marker.
* @size: The size of the data to parse
*
* Parsers @data containing the video packet header
* and fills the @videopackethdr structure
*/
GstMpeg4ParseResult
gst_mpeg4_parse_video_packet_header (GstMpeg4VideoPacketHdr * videopackethdr,
GstMpeg4VideoObjectLayer * vol, GstMpeg4VideoObjectPlane * vop,
GstMpeg4SpriteTrajectory * sprite_trajectory, const guint8 * data,
gsize size)
{
guint8 markersize;
GstBitReader br = GST_BIT_READER_INIT (data, size);
g_return_val_if_fail (videopackethdr != NULL, GST_MPEG4_PARSER_ERROR);
g_return_val_if_fail (vol != NULL, GST_MPEG4_PARSER_ERROR);
markersize = compute_resync_marker_size (vop, NULL, NULL);
CHECK_REMAINING (&br, markersize);
if (gst_bit_reader_get_bits_uint32_unchecked (&br, markersize) != 0x01)
goto failed;
if (vol->shape != GST_MPEG4_RECTANGULAR) {
READ_UINT8 (&br, videopackethdr->header_extension_code, 1);
if (vol->sprite_enable == GST_MPEG4_SPRITE_STATIC &&
vop->coding_type == GST_MPEG4_I_VOP) {
CHECK_REMAINING (&br, 56);
U_READ_UINT16 (&br, vop->width, 13);
CHECK_MARKER (&br);
U_READ_UINT16 (&br, vop->height, 13);
CHECK_MARKER (&br);
U_READ_UINT16 (&br, vop->horizontal_mc_spatial_ref, 13);
CHECK_MARKER (&br);
U_READ_UINT16 (&br, vop->vertical_mc_spatial_ref, 13);
CHECK_MARKER (&br);
/* Update macroblock infirmations */
vop->mb_height = (vop->height + 15) / 16;
vop->mb_width = (vop->width + 15) / 16;
vop->mb_num = vop->mb_height * vop->mb_width;
}
}
READ_UINT16 (&br, videopackethdr->macroblock_number,
g_bit_storage (vop->mb_num - 1));
if (vol->shape != GST_MPEG4_BINARY_ONLY)
READ_UINT16 (&br, videopackethdr->quant_scale, vol->quant_precision);
if (vol->shape == GST_MPEG4_RECTANGULAR)
READ_UINT8 (&br, videopackethdr->header_extension_code, 1);
if (videopackethdr->header_extension_code) {
guint timeincr = 0;
guint8 bit = 0, coding_type;
do {
READ_UINT8 (&br, bit, 1);
timeincr++;
} while (bit);
vol->vop_time_increment_bits = timeincr;
CHECK_MARKER (&br);
READ_UINT16 (&br, vop->time_increment, timeincr);
CHECK_MARKER (&br);
READ_UINT8 (&br, coding_type, 2);
vop->coding_type = coding_type;
if (vol->shape != GST_MPEG4_RECTANGULAR) {
READ_UINT8 (&br, vop->change_conv_ratio_disable, 1);
if (vop->coding_type != GST_MPEG4_I_VOP)
READ_UINT8 (&br, vop->shape_coding_type, 1);
}
if (vol->shape != GST_MPEG4_BINARY_ONLY) {
READ_UINT8 (&br, vop->intra_dc_vlc_thr, 3);
if (sprite_trajectory && vol->sprite_enable == GST_MPEG4_SPRITE_GMG &&
vop->coding_type == GST_MPEG4_S_VOP &&
vol->no_of_sprite_warping_points > 0) {
parse_sprite_trajectory (&br, sprite_trajectory,
vol->no_of_sprite_warping_points);
}
if (vol->reduced_resolution_vop_enable &&
vol->shape == GST_MPEG4_RECTANGULAR &&
(vop->coding_type == GST_MPEG4_P_VOP ||
vop->coding_type == GST_MPEG4_I_VOP))
READ_UINT8 (&br, vop->reduced_resolution, 1);
if (vop->coding_type != GST_MPEG4_I_VOP) {
READ_UINT8 (&br, vop->fcode_forward, 3);
CHECK_ALLOWED (vop->fcode_forward, 1, 7);
}
if (vop->coding_type == GST_MPEG4_B_VOP) {
READ_UINT8 (&br, vop->fcode_backward, 3);
CHECK_ALLOWED (vop->fcode_backward, 1, 7);
}
}
}
if (vol->newpred_enable) {
guint16 nbbits =
vol->vop_time_increment_bits + 3 < 15 ? vop->time_increment + 3 : 15;
READ_UINT16 (&br, vop->id, nbbits);
READ_UINT8 (&br, vop->id_for_prediction_indication, 1);
if (vop->id_for_prediction_indication) {
/* Would be nice if the standard actually told us... */
READ_UINT16 (&br, vop->id, nbbits);
CHECK_MARKER (&br);
}
}
videopackethdr->size = gst_bit_reader_get_pos (&br);
failed:
GST_DEBUG ("Failed to parse video packet header");
return GST_MPEG4_PARSER_NO_PACKET;
}
Reference in a new issue View git blame Copy permalink