gst-libs/gst/codecparsers/gstmpeg4parser.c

/* 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
 * @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 complet 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 informations */
  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 informations
       * 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 informations found during the parsing
 * @vop: The last parsed #GstMpeg4VideoObjectPlane, will be updated
 * with the informations found during the parsing
 * @sprite_trajectory: A #GstMpeg4SpriteTrajectory to fill or %NULL
 * with the informations 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;
}