/*
 *  gstvaapidecoder_vc1.c - VC-1 decoder
 *
 *  Copyright (C) 2011-2013 Intel Corporation
 *    Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2.1
 *  of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301 USA
 */

/**
 * SECTION:gstvaapidecoder_vc1
 * @short_description: VC-1 decoder
 */

#include "sysdeps.h"
#include <gst/codecparsers/gstvc1parser.h>
#include "gstvaapidecoder_vc1.h"
#include "gstvaapidecoder_objects.h"
#include "gstvaapidecoder_dpb.h"
#include "gstvaapidecoder_unit.h"
#include "gstvaapidecoder_priv.h"
#include "gstvaapidisplay_priv.h"

#define DEBUG 1
#include "gstvaapidebug.h"

#define GST_VAAPI_DECODER_VC1_CAST(decoder) \
    ((GstVaapiDecoderVC1 *)(decoder))

typedef struct _GstVaapiDecoderVC1Private GstVaapiDecoderVC1Private;
typedef struct _GstVaapiDecoderVC1Class GstVaapiDecoderVC1Class;

/**
 * GstVaapiDecoderVC1:
 *
 * A decoder based on VC1.
 */
struct _GstVaapiDecoderVC1Private
{
  GstVaapiProfile profile;
  guint width;
  guint height;
  GstVC1SeqHdr seq_hdr;
  GstVC1EntryPointHdr entrypoint_hdr;
  GstVC1FrameHdr frame_hdr;
  GstVC1BitPlanes *bitplanes;
  GstVaapiPicture *current_picture;
  GstVaapiPicture *last_non_b_picture;
  GstVaapiDpb *dpb;
  gint32 next_poc;
  guint8 *rbdu_buffer;
  guint8 rndctrl;
  guint rbdu_buffer_size;
  guint is_opened:1;
  guint has_codec_data:1;
  guint has_entrypoint:1;
  guint size_changed:1;
  guint profile_changed:1;
  guint closed_entry:1;
  guint broken_link:1;
};

/**
 * GstVaapiDecoderVC1:
 *
 * A decoder based on VC1.
 */
struct _GstVaapiDecoderVC1
{
  /*< private > */
  GstVaapiDecoder parent_instance;
  GstVaapiDecoderVC1Private priv;
};

/**
 * GstVaapiDecoderVC1Class:
 *
 * A decoder class based on VC1.
 */
struct _GstVaapiDecoderVC1Class
{
  /*< private > */
  GstVaapiDecoderClass parent_class;
};

G_DEFINE_TYPE (GstVaapiDecoderVC1, gst_vaapi_decoder_vc1,
    GST_TYPE_VAAPI_DECODER);

static GstVaapiDecoderStatus
get_status (GstVC1ParserResult result)
{
  GstVaapiDecoderStatus status;

  switch (result) {
    case GST_VC1_PARSER_OK:
      status = GST_VAAPI_DECODER_STATUS_SUCCESS;
      break;
    case GST_VC1_PARSER_NO_BDU_END:
      status = GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
      break;
    case GST_VC1_PARSER_ERROR:
      status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
      break;
    default:
      status = GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
      break;
  }
  return status;
}

static void
gst_vaapi_decoder_vc1_close (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;

  gst_vaapi_picture_replace (&priv->last_non_b_picture, NULL);
  gst_vaapi_picture_replace (&priv->current_picture, NULL);
  gst_vaapi_dpb_replace (&priv->dpb, NULL);

  if (priv->bitplanes) {
    gst_vc1_bitplanes_free (priv->bitplanes);
    priv->bitplanes = NULL;
  }
  priv->is_opened = FALSE;
}

static gboolean
gst_vaapi_decoder_vc1_open (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;

  gst_vaapi_decoder_vc1_close (decoder);

  priv->dpb = gst_vaapi_dpb_new (2);
  if (!priv->dpb)
    return FALSE;

  priv->bitplanes = gst_vc1_bitplanes_new ();
  if (!priv->bitplanes)
    return FALSE;

  memset (&priv->seq_hdr, 0, sizeof (GstVC1SeqHdr));
  memset (&priv->entrypoint_hdr, 0, sizeof (GstVC1EntryPointHdr));
  memset (&priv->frame_hdr, 0, sizeof (GstVC1FrameHdr));

  return TRUE;
}

static void
gst_vaapi_decoder_vc1_destroy (GstVaapiDecoder * base_decoder)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;

  gst_vaapi_decoder_vc1_close (decoder);

  if (priv->rbdu_buffer) {
    g_clear_pointer (&priv->rbdu_buffer, g_free);
    priv->rbdu_buffer_size = 0;
  }
}

static gboolean
gst_vaapi_decoder_vc1_create (GstVaapiDecoder * base_decoder)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;

  priv->has_codec_data = priv->has_entrypoint =
      priv->size_changed = priv->profile_changed =
      priv->closed_entry = priv->broken_link = FALSE;

  priv->profile = GST_VAAPI_PROFILE_UNKNOWN;
  priv->rndctrl = 0;
  priv->width = priv->height = 0;
  return TRUE;
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_reset (GstVaapiDecoder * base_decoder)
{
  gst_vaapi_decoder_vc1_destroy (base_decoder);
  gst_vaapi_decoder_vc1_create (base_decoder);
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
ensure_context (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiProfile profiles[2];
  GstVaapiEntrypoint entrypoint = GST_VAAPI_ENTRYPOINT_VLD;
  guint i, n_profiles = 0;
  gboolean reset_context = FALSE;

  if (priv->profile_changed) {
    GST_DEBUG ("profile changed");
    priv->profile_changed = FALSE;
    reset_context = TRUE;

    profiles[n_profiles++] = priv->profile;
    if (priv->profile == GST_VAAPI_PROFILE_VC1_SIMPLE)
      profiles[n_profiles++] = GST_VAAPI_PROFILE_VC1_MAIN;

    for (i = 0; i < n_profiles; i++) {
      if (gst_vaapi_display_has_decoder (GST_VAAPI_DECODER_DISPLAY (decoder),
              profiles[i], entrypoint))
        break;
    }
    if (i == n_profiles)
      return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
    priv->profile = profiles[i];
  }

  if (priv->size_changed) {
    GST_DEBUG ("size changed");
    priv->size_changed = FALSE;
    reset_context = TRUE;
  }

  if (reset_context) {
    GstVaapiContextInfo info;
    /* *INDENT-OFF* */
    info = (GstVaapiContextInfo) {
      .profile = priv->profile,
      .entrypoint = entrypoint,
      .chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420,
      .width = priv->width,
      .height = priv->height,
      .ref_frames = 2,
    };
    /* *INDENT-ON* */

    reset_context =
        gst_vaapi_decoder_ensure_context (GST_VAAPI_DECODER (decoder), &info);
    if (!reset_context)
      return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  }
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
decode_current_picture (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiPicture *const picture = priv->current_picture;

  if (!picture)
    return GST_VAAPI_DECODER_STATUS_SUCCESS;

  if (!gst_vaapi_picture_decode (picture))
    goto error;
  if (GST_VAAPI_PICTURE_IS_COMPLETE (picture)) {
    if (!gst_vaapi_dpb_add (priv->dpb, picture))
      goto error;
    gst_vaapi_picture_replace (&priv->current_picture, NULL);
  }
  return GST_VAAPI_DECODER_STATUS_SUCCESS;

  /* ERRORS */
error:
  {
    /* XXX: fix for cases where first field failed to be decoded */
    gst_vaapi_picture_replace (&priv->current_picture, NULL);
    return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  }
}

static GstVaapiDecoderStatus
decode_sequence (GstVaapiDecoderVC1 * decoder, GstVC1BDU * rbdu,
    GstVC1BDU * ebdu)
{
  GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1AdvancedSeqHdr *const adv_hdr = &seq_hdr->advanced;
  GstVC1SeqStructC *const structc = &seq_hdr->struct_c;
  GstVC1ParserResult result;
  GstVaapiProfile profile;
  guint width, height, fps_n, fps_d, par_n, par_d;

  result = gst_vc1_parse_sequence_header (rbdu->data + rbdu->offset,
      rbdu->size, seq_hdr);
  if (result != GST_VC1_PARSER_OK) {
    GST_ERROR ("failed to parse sequence layer");
    return get_status (result);
  }

  priv->has_entrypoint = FALSE;

  /* Reset POC */
  if (priv->last_non_b_picture) {
    if (priv->last_non_b_picture->poc == priv->next_poc)
      priv->next_poc++;
    gst_vaapi_picture_replace (&priv->last_non_b_picture, NULL);
  }

  /* Validate profile */
  switch (seq_hdr->profile) {
    case GST_VC1_PROFILE_SIMPLE:
    case GST_VC1_PROFILE_MAIN:
    case GST_VC1_PROFILE_ADVANCED:
      break;
    default:
      GST_ERROR ("unsupported profile %d", seq_hdr->profile);
      return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
  }

  fps_n = 0;
  fps_d = 0;
  par_n = 0;
  par_d = 0;
  switch (seq_hdr->profile) {
    case GST_VC1_PROFILE_SIMPLE:
    case GST_VC1_PROFILE_MAIN:
      if (structc->wmvp) {
        fps_n = structc->framerate;
        fps_d = 1;
      }
      break;
    case GST_VC1_PROFILE_ADVANCED:
      fps_n = adv_hdr->fps_n;
      fps_d = adv_hdr->fps_d;
      par_n = adv_hdr->par_n;
      par_d = adv_hdr->par_d;
      break;
    default:
      g_assert (0 && "XXX: we already validated the profile above");
      break;
  }

  if (fps_n && fps_d)
    gst_vaapi_decoder_set_framerate (base_decoder, fps_n, fps_d);

  if (par_n > 0 && par_d > 0)
    gst_vaapi_decoder_set_pixel_aspect_ratio (base_decoder, par_n, par_d);

  width = 0;
  height = 0;
  switch (seq_hdr->profile) {
    case GST_VC1_PROFILE_SIMPLE:
    case GST_VC1_PROFILE_MAIN:
      width = seq_hdr->struct_c.coded_width;
      height = seq_hdr->struct_c.coded_height;
      break;
    case GST_VC1_PROFILE_ADVANCED:
      width = seq_hdr->advanced.max_coded_width;
      height = seq_hdr->advanced.max_coded_height;
      break;
    default:
      g_assert (0 && "XXX: we already validated the profile above");
      break;
  }

  if (priv->width != width) {
    priv->width = width;
    priv->size_changed = TRUE;
  }

  if (priv->height != height) {
    priv->height = height;
    priv->size_changed = TRUE;
  }

  profile = GST_VAAPI_PROFILE_UNKNOWN;
  switch (seq_hdr->profile) {
    case GST_VC1_PROFILE_SIMPLE:
      profile = GST_VAAPI_PROFILE_VC1_SIMPLE;
      break;
    case GST_VC1_PROFILE_MAIN:
      profile = GST_VAAPI_PROFILE_VC1_MAIN;
      break;
    case GST_VC1_PROFILE_ADVANCED:
      profile = GST_VAAPI_PROFILE_VC1_ADVANCED;
      break;
    default:
      g_assert (0 && "XXX: we already validated the profile above");
      break;
  }
  if (priv->profile != profile) {
    priv->profile = profile;
    priv->profile_changed = TRUE;
  }
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
decode_sequence_end (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiDecoderStatus status;

  status = decode_current_picture (decoder);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
    return status;

  gst_vaapi_dpb_flush (priv->dpb);
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
decode_entry_point (GstVaapiDecoderVC1 * decoder, GstVC1BDU * rbdu,
    GstVC1BDU * ebdu)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1EntryPointHdr *const entrypoint_hdr = &priv->entrypoint_hdr;
  GstVC1ParserResult result;

  result = gst_vc1_parse_entry_point_header (rbdu->data + rbdu->offset,
      rbdu->size, entrypoint_hdr, seq_hdr);
  if (result != GST_VC1_PARSER_OK) {
    GST_ERROR ("failed to parse entrypoint layer");
    return get_status (result);
  }

  if (entrypoint_hdr->coded_size_flag) {
    priv->width = entrypoint_hdr->coded_width;
    priv->height = entrypoint_hdr->coded_height;
    priv->size_changed = TRUE;
  }

  priv->has_entrypoint = TRUE;
  priv->closed_entry = entrypoint_hdr->closed_entry;
  priv->broken_link = entrypoint_hdr->broken_link;
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

/* Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */
static guint
get_PTYPE (guint ptype)
{
  switch (ptype) {
    case GST_VC1_PICTURE_TYPE_I:
      return 0;
    case GST_VC1_PICTURE_TYPE_P:
      return 1;
    case GST_VC1_PICTURE_TYPE_B:
      return 2;
    case GST_VC1_PICTURE_TYPE_BI:
      return 3;
  }
  return 4;                     /* skipped P-frame */
}

/* Reconstruct bitstream BFRACTION (7.1.1.14, index into Table-40) */
static guint
get_BFRACTION (guint bfraction)
{
  guint i;

  static const struct
  {
    guint16 index;
    guint16 value;
  }
  bfraction_map[] = {
    {
    0, GST_VC1_BFRACTION_BASIS / 2}, {
    1, GST_VC1_BFRACTION_BASIS / 3}, {
    2, (GST_VC1_BFRACTION_BASIS * 2) / 3}, {
    3, GST_VC1_BFRACTION_BASIS / 4}, {
    4, (GST_VC1_BFRACTION_BASIS * 3) / 4}, {
    5, GST_VC1_BFRACTION_BASIS / 5}, {
    6, (GST_VC1_BFRACTION_BASIS * 2) / 5}, {
    7, (GST_VC1_BFRACTION_BASIS * 3) / 5}, {
    8, (GST_VC1_BFRACTION_BASIS * 4) / 5}, {
    9, GST_VC1_BFRACTION_BASIS / 6}, {
    10, (GST_VC1_BFRACTION_BASIS * 5) / 6}, {
    11, GST_VC1_BFRACTION_BASIS / 7}, {
    12, (GST_VC1_BFRACTION_BASIS * 2) / 7}, {
    13, (GST_VC1_BFRACTION_BASIS * 3) / 7}, {
    14, (GST_VC1_BFRACTION_BASIS * 4) / 7}, {
    15, (GST_VC1_BFRACTION_BASIS * 5) / 7}, {
    16, (GST_VC1_BFRACTION_BASIS * 6) / 7}, {
    17, GST_VC1_BFRACTION_BASIS / 8}, {
    18, (GST_VC1_BFRACTION_BASIS * 3) / 8}, {
    19, (GST_VC1_BFRACTION_BASIS * 5) / 8}, {
    20, (GST_VC1_BFRACTION_BASIS * 7) / 8}, {
    21, GST_VC1_BFRACTION_RESERVED}, {
    22, GST_VC1_BFRACTION_PTYPE_BI}
  };

  if (!bfraction)
    return 0;

  for (i = 0; i < G_N_ELEMENTS (bfraction_map); i++) {
    if (bfraction_map[i].value == bfraction)
      return bfraction_map[i].index;
  }
  return 21;                    /* RESERVED */
}

/* Translate GStreamer MV modes to VA-API */
static guint
get_VAMvModeVC1 (guint mvmode)
{
  switch (mvmode) {
    case GST_VC1_MVMODE_1MV_HPEL_BILINEAR:
      return VAMvMode1MvHalfPelBilinear;
    case GST_VC1_MVMODE_1MV:
      return VAMvMode1Mv;
    case GST_VC1_MVMODE_1MV_HPEL:
      return VAMvMode1MvHalfPel;
    case GST_VC1_MVMODE_MIXED_MV:
      return VAMvModeMixedMv;
    case GST_VC1_MVMODE_INTENSITY_COMP:
      return VAMvModeIntensityCompensation;
  }
  return 0;
}

/* Reconstruct bitstream MVMODE (7.1.1.32) */
static guint
get_MVMODE (GstVC1FrameHdr * frame_hdr)
{
  guint mvmode;

  if (frame_hdr->profile == GST_VC1_PROFILE_ADVANCED)
    mvmode = frame_hdr->pic.advanced.mvmode;
  else
    mvmode = frame_hdr->pic.simple.mvmode;

  if (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_P ||
      frame_hdr->ptype == GST_VC1_PICTURE_TYPE_B)
    return get_VAMvModeVC1 (mvmode);
  return 0;
}

/* Reconstruct bitstream MVMODE2 (7.1.1.33) */
static guint
get_MVMODE2 (GstVC1FrameHdr * frame_hdr)
{
  guint mvmode, mvmode2;

  if (frame_hdr->profile == GST_VC1_PROFILE_ADVANCED) {
    mvmode = frame_hdr->pic.advanced.mvmode;
    mvmode2 = frame_hdr->pic.advanced.mvmode2;
  } else {
    mvmode = frame_hdr->pic.simple.mvmode;
    mvmode2 = frame_hdr->pic.simple.mvmode2;
  }

  if (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_P &&
      mvmode == GST_VC1_MVMODE_INTENSITY_COMP)
    return get_VAMvModeVC1 (mvmode2);
  return 0;
}

static inline int
has_MVTYPEMB_bitplane (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  guint mvmode, mvmode2;

  if (seq_hdr->profile == GST_VC1_PROFILE_ADVANCED) {
    GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;
    if (pic->mvtypemb)
      return 0;
    mvmode = pic->mvmode;
    mvmode2 = pic->mvmode2;
  } else {
    GstVC1PicSimpleMain *const pic = &frame_hdr->pic.simple;
    if (pic->mvtypemb)
      return 0;
    mvmode = pic->mvmode;
    mvmode2 = pic->mvmode2;
  }
  return (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_P &&
      (mvmode == GST_VC1_MVMODE_MIXED_MV ||
          (mvmode == GST_VC1_MVMODE_INTENSITY_COMP &&
              mvmode2 == GST_VC1_MVMODE_MIXED_MV)));
}

static inline int
has_SKIPMB_bitplane (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;

  if (seq_hdr->profile == GST_VC1_PROFILE_ADVANCED) {
    GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;
    if (pic->skipmb)
      return 0;
  } else {
    GstVC1PicSimpleMain *const pic = &frame_hdr->pic.simple;
    if (pic->skipmb)
      return 0;
  }
  return (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_P ||
      frame_hdr->ptype == GST_VC1_PICTURE_TYPE_B);
}

static inline int
has_DIRECTMB_bitplane (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;

  if (seq_hdr->profile == GST_VC1_PROFILE_ADVANCED) {
    GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;
    if (pic->directmb)
      return 0;
  } else {
    GstVC1PicSimpleMain *const pic = &frame_hdr->pic.simple;
    if (pic->directmb)
      return 0;
  }
  return frame_hdr->ptype == GST_VC1_PICTURE_TYPE_B;
}

static inline int
has_ACPRED_bitplane (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;

  if (seq_hdr->profile != GST_VC1_PROFILE_ADVANCED)
    return 0;
  if (pic->acpred)
    return 0;
  return (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_I ||
      frame_hdr->ptype == GST_VC1_PICTURE_TYPE_BI);
}

static inline int
has_OVERFLAGS_bitplane (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1EntryPointHdr *const entrypoint_hdr = &priv->entrypoint_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;

  if (seq_hdr->profile != GST_VC1_PROFILE_ADVANCED)
    return 0;
  if (pic->overflags)
    return 0;
  return ((frame_hdr->ptype == GST_VC1_PICTURE_TYPE_I ||
          frame_hdr->ptype == GST_VC1_PICTURE_TYPE_BI) &&
      (entrypoint_hdr->overlap && frame_hdr->pquant <= 8) &&
      pic->condover == GST_VC1_CONDOVER_SELECT);
}

static inline void
pack_bitplanes (GstVaapiBitPlane * bitplane, guint n,
    const guint8 * bitplanes[3], guint x, guint y, guint stride)
{
  const guint dst_index = n / 2;
  const guint src_index = y * stride + x;
  guint8 v = 0;

  if (bitplanes[0])
    v |= bitplanes[0][src_index];
  if (bitplanes[1])
    v |= bitplanes[1][src_index] << 1;
  if (bitplanes[2])
    v |= bitplanes[2][src_index] << 2;
  bitplane->data[dst_index] = (bitplane->data[dst_index] << 4) | v;
}

static gboolean
fill_picture_structc (GstVaapiDecoderVC1 * decoder, GstVaapiPicture * picture)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  VAPictureParameterBufferVC1 *const pic_param = picture->param;
  GstVC1SeqStructC *const structc = &priv->seq_hdr.struct_c;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1PicSimpleMain *const pic = &frame_hdr->pic.simple;

  /* Fill in VAPictureParameterBufferVC1 (simple/main profile bits) */
  pic_param->sequence_fields.bits.finterpflag = structc->finterpflag;
  pic_param->sequence_fields.bits.multires = structc->multires;
  pic_param->sequence_fields.bits.overlap = structc->overlap;
  pic_param->sequence_fields.bits.syncmarker = structc->syncmarker;
  pic_param->sequence_fields.bits.rangered = structc->rangered;
  pic_param->sequence_fields.bits.max_b_frames = structc->maxbframes;
  pic_param->conditional_overlap_flag = 0;      /* advanced profile only */
  pic_param->fast_uvmc_flag = structc->fastuvmc;
  pic_param->b_picture_fraction = get_BFRACTION (pic->bfraction);
  pic_param->cbp_table = pic->cbptab;
  pic_param->mb_mode_table = 0; /* XXX: interlaced frame */
  pic_param->range_reduction_frame = pic->rangeredfrm;
  pic_param->post_processing = 0;       /* advanced profile only */
  pic_param->picture_resolution_index = pic->respic;
  pic_param->luma_scale = pic->lumscale;
  pic_param->luma_shift = pic->lumshift;
  pic_param->raw_coding.flags.mv_type_mb = pic->mvtypemb;
  pic_param->raw_coding.flags.direct_mb = pic->directmb;
  pic_param->raw_coding.flags.skip_mb = pic->skipmb;
  pic_param->bitplane_present.flags.bp_mv_type_mb =
      has_MVTYPEMB_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_direct_mb =
      has_DIRECTMB_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_skip_mb = has_SKIPMB_bitplane (decoder);
  pic_param->mv_fields.bits.mv_table = pic->mvtab;
  pic_param->mv_fields.bits.extended_mv_flag = structc->extended_mv;
  pic_param->mv_fields.bits.extended_mv_range = pic->mvrange;
  pic_param->transform_fields.bits.variable_sized_transform_flag =
      structc->vstransform;
  pic_param->transform_fields.bits.mb_level_transform_type_flag = pic->ttmbf;
  pic_param->transform_fields.bits.frame_level_transform_type = pic->ttfrm;
  pic_param->transform_fields.bits.transform_ac_codingset_idx2 =
      pic->transacfrm2;

  /* Refer to 8.3.7 Rounding control for Simple and Main Profile  */
  if (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_I ||
      frame_hdr->ptype == GST_VC1_PICTURE_TYPE_BI)
    priv->rndctrl = 1;
  else if (frame_hdr->ptype == GST_VC1_PICTURE_TYPE_P)
    priv->rndctrl ^= 1;

  pic_param->rounding_control = priv->rndctrl;

  return TRUE;
}

static gboolean
fill_picture_advanced (GstVaapiDecoderVC1 * decoder, GstVaapiPicture * picture)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  VAPictureParameterBufferVC1 *const pic_param = picture->param;
  GstVC1AdvancedSeqHdr *const adv_hdr = &priv->seq_hdr.advanced;
  GstVC1EntryPointHdr *const entrypoint_hdr = &priv->entrypoint_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1PicAdvanced *const pic = &frame_hdr->pic.advanced;

  if (!priv->has_entrypoint)
    return FALSE;

  /* Fill in VAPictureParameterBufferVC1 (advanced profile bits) */
  pic_param->sequence_fields.bits.pulldown = adv_hdr->pulldown;
  pic_param->sequence_fields.bits.interlace = adv_hdr->interlace;
  pic_param->sequence_fields.bits.tfcntrflag = adv_hdr->tfcntrflag;
  pic_param->sequence_fields.bits.finterpflag = adv_hdr->finterpflag;
  pic_param->sequence_fields.bits.psf = adv_hdr->psf;
  pic_param->sequence_fields.bits.overlap = entrypoint_hdr->overlap;
  pic_param->entrypoint_fields.bits.broken_link = entrypoint_hdr->broken_link;
  pic_param->entrypoint_fields.bits.closed_entry = entrypoint_hdr->closed_entry;
  pic_param->entrypoint_fields.bits.panscan_flag = entrypoint_hdr->panscan_flag;
  pic_param->entrypoint_fields.bits.loopfilter = entrypoint_hdr->loopfilter;
  pic_param->conditional_overlap_flag = pic->condover;
  pic_param->fast_uvmc_flag = entrypoint_hdr->fastuvmc;
  pic_param->range_mapping_fields.bits.luma_flag =
      entrypoint_hdr->range_mapy_flag;
  pic_param->range_mapping_fields.bits.luma = entrypoint_hdr->range_mapy;
  pic_param->range_mapping_fields.bits.chroma_flag =
      entrypoint_hdr->range_mapuv_flag;
  pic_param->range_mapping_fields.bits.chroma = entrypoint_hdr->range_mapuv;
  pic_param->b_picture_fraction = get_BFRACTION (pic->bfraction);
  pic_param->cbp_table = pic->cbptab;
  pic_param->mb_mode_table = 0; /* XXX: interlaced frame */
  pic_param->range_reduction_frame = 0; /* simple/main profile only */
  pic_param->rounding_control = pic->rndctrl;
  pic_param->post_processing = pic->postproc;
  pic_param->picture_resolution_index = 0;      /* simple/main profile only */
  pic_param->luma_scale = pic->lumscale;
  pic_param->luma_shift = pic->lumshift;
  pic_param->picture_fields.bits.frame_coding_mode = pic->fcm;
  pic_param->picture_fields.bits.top_field_first = pic->tff;
  pic_param->picture_fields.bits.is_first_field = pic->fcm == 0;        /* XXX: interlaced frame */
  pic_param->picture_fields.bits.intensity_compensation =
      pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP;
  pic_param->raw_coding.flags.mv_type_mb = pic->mvtypemb;
  pic_param->raw_coding.flags.direct_mb = pic->directmb;
  pic_param->raw_coding.flags.skip_mb = pic->skipmb;
  pic_param->raw_coding.flags.ac_pred = pic->acpred;
  pic_param->raw_coding.flags.overflags = pic->overflags;
  pic_param->bitplane_present.flags.bp_mv_type_mb =
      has_MVTYPEMB_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_direct_mb =
      has_DIRECTMB_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_skip_mb = has_SKIPMB_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_ac_pred = has_ACPRED_bitplane (decoder);
  pic_param->bitplane_present.flags.bp_overflags =
      has_OVERFLAGS_bitplane (decoder);
  pic_param->reference_fields.bits.reference_distance_flag =
      entrypoint_hdr->refdist_flag;
  pic_param->mv_fields.bits.mv_table = pic->mvtab;
  pic_param->mv_fields.bits.extended_mv_flag = entrypoint_hdr->extended_mv;
  pic_param->mv_fields.bits.extended_mv_range = pic->mvrange;
  pic_param->mv_fields.bits.extended_dmv_flag = entrypoint_hdr->extended_dmv;
  pic_param->pic_quantizer_fields.bits.dquant = entrypoint_hdr->dquant;
  pic_param->pic_quantizer_fields.bits.quantizer = entrypoint_hdr->quantizer;
  pic_param->transform_fields.bits.variable_sized_transform_flag =
      entrypoint_hdr->vstransform;
  pic_param->transform_fields.bits.mb_level_transform_type_flag = pic->ttmbf;
  pic_param->transform_fields.bits.frame_level_transform_type = pic->ttfrm;
  pic_param->transform_fields.bits.transform_ac_codingset_idx2 =
      pic->transacfrm2;
  return TRUE;
}

static gboolean
fill_picture (GstVaapiDecoderVC1 * decoder, GstVaapiPicture * picture)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  VAPictureParameterBufferVC1 *const pic_param = picture->param;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1VopDquant *const vopdquant = &frame_hdr->vopdquant;
  GstVaapiPicture *prev_picture, *next_picture;

  /* Fill in VAPictureParameterBufferVC1 (common fields) */
  pic_param->forward_reference_picture = VA_INVALID_ID;
  pic_param->backward_reference_picture = VA_INVALID_ID;
  pic_param->inloop_decoded_picture = VA_INVALID_ID;
  pic_param->sequence_fields.value = 0;
  pic_param->sequence_fields.bits.profile = seq_hdr->profile;
  pic_param->coded_width = priv->width;
  pic_param->coded_height = priv->height;
  pic_param->entrypoint_fields.value = 0;
  pic_param->range_mapping_fields.value = 0;
  pic_param->picture_fields.value = 0;
  pic_param->picture_fields.bits.picture_type = get_PTYPE (frame_hdr->ptype);
  pic_param->raw_coding.value = 0;
  pic_param->bitplane_present.value = 0;
  pic_param->reference_fields.value = 0;
  pic_param->mv_fields.value = 0;
  pic_param->mv_fields.bits.mv_mode = get_MVMODE (frame_hdr);
  pic_param->mv_fields.bits.mv_mode2 = get_MVMODE2 (frame_hdr);
  pic_param->pic_quantizer_fields.value = 0;
  pic_param->pic_quantizer_fields.bits.half_qp = frame_hdr->halfqp;
  pic_param->pic_quantizer_fields.bits.pic_quantizer_scale = frame_hdr->pquant;
  pic_param->pic_quantizer_fields.bits.pic_quantizer_type =
      frame_hdr->pquantizer;
  pic_param->pic_quantizer_fields.bits.dq_frame = vopdquant->dquantfrm;
  pic_param->pic_quantizer_fields.bits.dq_profile = vopdquant->dqprofile;
  pic_param->pic_quantizer_fields.bits.dq_sb_edge =
      vopdquant->dqprofile ==
      GST_VC1_DQPROFILE_SINGLE_EDGE ? vopdquant->dqbedge : 0;
  pic_param->pic_quantizer_fields.bits.dq_db_edge =
      vopdquant->dqprofile ==
      GST_VC1_DQPROFILE_DOUBLE_EDGES ? vopdquant->dqbedge : 0;
  pic_param->pic_quantizer_fields.bits.dq_binary_level = vopdquant->dqbilevel;
  pic_param->pic_quantizer_fields.bits.alt_pic_quantizer = vopdquant->altpquant;
  pic_param->transform_fields.value = 0;
  pic_param->transform_fields.bits.transform_ac_codingset_idx1 =
      frame_hdr->transacfrm;
  pic_param->transform_fields.bits.intra_transform_dc_table =
      frame_hdr->transdctab;

  if (seq_hdr->profile == GST_VC1_PROFILE_ADVANCED) {
    if (!fill_picture_advanced (decoder, picture))
      return FALSE;
  } else {
    if (!fill_picture_structc (decoder, picture))
      return FALSE;
  }

  gst_vaapi_dpb_get_neighbours (priv->dpb, picture,
      &prev_picture, &next_picture);

  switch (picture->type) {
    case GST_VAAPI_PICTURE_TYPE_B:
      if (next_picture)
        pic_param->backward_reference_picture = next_picture->surface_id;
      if (prev_picture)
        pic_param->forward_reference_picture = prev_picture->surface_id;
      else if (!priv->closed_entry)
        GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_SKIPPED);
      break;
    case GST_VAAPI_PICTURE_TYPE_P:
      if (prev_picture)
        pic_param->forward_reference_picture = prev_picture->surface_id;
      break;
    default:
      break;
  }

  if (pic_param->bitplane_present.value) {
    const guint8 *bitplanes[3];
    guint x, y, n;

    switch (picture->type) {
      case GST_VAAPI_PICTURE_TYPE_P:
        bitplanes[0] = pic_param->bitplane_present.flags.bp_direct_mb ?
            priv->bitplanes->directmb : NULL;
        bitplanes[1] = pic_param->bitplane_present.flags.bp_skip_mb ?
            priv->bitplanes->skipmb : NULL;
        bitplanes[2] = pic_param->bitplane_present.flags.bp_mv_type_mb ?
            priv->bitplanes->mvtypemb : NULL;
        break;
      case GST_VAAPI_PICTURE_TYPE_B:
        bitplanes[0] = pic_param->bitplane_present.flags.bp_direct_mb ?
            priv->bitplanes->directmb : NULL;
        bitplanes[1] = pic_param->bitplane_present.flags.bp_skip_mb ?
            priv->bitplanes->skipmb : NULL;
        bitplanes[2] = NULL;    /* XXX: interlaced frame (FORWARD plane) */
        break;
      case GST_VAAPI_PICTURE_TYPE_BI:
      case GST_VAAPI_PICTURE_TYPE_I:
        bitplanes[0] = NULL;    /* XXX: interlaced frame (FIELDTX plane) */
        bitplanes[1] = pic_param->bitplane_present.flags.bp_ac_pred ?
            priv->bitplanes->acpred : NULL;
        bitplanes[2] = pic_param->bitplane_present.flags.bp_overflags ?
            priv->bitplanes->overflags : NULL;
        break;
      default:
        bitplanes[0] = NULL;
        bitplanes[1] = NULL;
        bitplanes[2] = NULL;
        break;
    }

    picture->bitplane = GST_VAAPI_BITPLANE_NEW (decoder,
        (seq_hdr->mb_width * seq_hdr->mb_height + 1) / 2);
    if (!picture->bitplane)
      return FALSE;

    n = 0;
    for (y = 0; y < seq_hdr->mb_height; y++)
      for (x = 0; x < seq_hdr->mb_width; x++, n++)
        pack_bitplanes (picture->bitplane, n, bitplanes, x, y,
            seq_hdr->mb_stride);
    if (n & 1)                  /* move last nibble to the high order */
      picture->bitplane->data[n / 2] <<= 4;
  }
  return TRUE;
}

static GstVaapiDecoderStatus
decode_slice_chunk (GstVaapiDecoderVC1 * decoder, GstVC1BDU * ebdu,
    guint slice_addr, guint header_size)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiPicture *const picture = priv->current_picture;
  GstVaapiSlice *slice;
  VASliceParameterBufferVC1 *slice_param;

  slice = GST_VAAPI_SLICE_NEW (VC1, decoder,
      ebdu->data + ebdu->sc_offset,
      ebdu->size + ebdu->offset - ebdu->sc_offset);
  if (!slice) {
    GST_ERROR ("failed to allocate slice");
    return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
  }
  gst_vaapi_picture_add_slice (picture, slice);

  /* Fill in VASliceParameterBufferVC1 */
  slice_param = slice->param;
  slice_param->macroblock_offset = 8 * (ebdu->offset - ebdu->sc_offset) +
      header_size;
  slice_param->slice_vertical_position = slice_addr;
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
decode_frame (GstVaapiDecoderVC1 * decoder, GstVC1BDU * rbdu, GstVC1BDU * ebdu)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1FrameHdr *const frame_hdr = &priv->frame_hdr;
  GstVC1ParserResult result;
  GstVaapiPicture *const picture = priv->current_picture;

  memset (frame_hdr, 0, sizeof (*frame_hdr));
  result = gst_vc1_parse_frame_header (rbdu->data + rbdu->offset,
      rbdu->size, frame_hdr, &priv->seq_hdr, priv->bitplanes);
  if (result != GST_VC1_PARSER_OK) {
    GST_ERROR ("failed to parse frame layer");
    return get_status (result);
  }

  /* @FIXME: intel-driver cannot handle interlaced frames */
  if (priv->profile == GST_VAAPI_PROFILE_VC1_ADVANCED
      && frame_hdr->pic.advanced.fcm != GST_VC1_FRAME_PROGRESSIVE) {
    GST_ERROR ("interlaced video not supported");
    return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
  }

  switch (frame_hdr->ptype) {
    case GST_VC1_PICTURE_TYPE_I:
      picture->type = GST_VAAPI_PICTURE_TYPE_I;
      GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_REFERENCE);
      break;
    case GST_VC1_PICTURE_TYPE_SKIPPED:
    case GST_VC1_PICTURE_TYPE_P:
      picture->type = GST_VAAPI_PICTURE_TYPE_P;
      GST_VAAPI_PICTURE_FLAG_SET (picture, GST_VAAPI_PICTURE_FLAG_REFERENCE);
      break;
    case GST_VC1_PICTURE_TYPE_B:
      picture->type = GST_VAAPI_PICTURE_TYPE_B;
      break;
    case GST_VC1_PICTURE_TYPE_BI:
      picture->type = GST_VAAPI_PICTURE_TYPE_BI;
      break;
    default:
      GST_ERROR ("unsupported picture type %d", frame_hdr->ptype);
      return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  }

  /* Update presentation time */
  if (GST_VAAPI_PICTURE_IS_REFERENCE (picture)) {
    picture->poc = priv->last_non_b_picture ?
        (priv->last_non_b_picture->poc + 1) : priv->next_poc;
    priv->next_poc = picture->poc + 1;
    gst_vaapi_picture_replace (&priv->last_non_b_picture, picture);
  } else if (!priv->last_non_b_picture)
    picture->poc = priv->next_poc++;
  else {                        /* B or BI */
    picture->poc = priv->last_non_b_picture->poc++;
    priv->next_poc = priv->last_non_b_picture->poc + 1;
  }
  picture->pts = GST_VAAPI_DECODER_CODEC_FRAME (decoder)->pts;

  if (!fill_picture (decoder, picture))
    return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  return decode_slice_chunk (decoder, ebdu, 0, frame_hdr->header_size);
}

static GstVaapiDecoderStatus
decode_slice (GstVaapiDecoderVC1 * decoder, GstVC1BDU * rbdu, GstVC1BDU * ebdu)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SliceHdr slice_hdr;
  GstVC1ParserResult result;

  memset (&slice_hdr, 0, sizeof (slice_hdr));
  result = gst_vc1_parse_slice_header (rbdu->data + rbdu->offset,
      rbdu->size, &slice_hdr, &priv->seq_hdr);
  if (result != GST_VC1_PARSER_OK) {
    GST_ERROR ("failed to parse slice layer");
    return get_status (result);
  }
  return decode_slice_chunk (decoder, ebdu, slice_hdr.slice_addr,
      slice_hdr.header_size);
}

static gboolean
decode_rbdu (GstVaapiDecoderVC1 * decoder, GstVC1BDU * rbdu, GstVC1BDU * ebdu)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  guint8 *rbdu_buffer;
  guint i, j, rbdu_buffer_size;

  /* BDU are encapsulated in advanced profile mode only */
  if (priv->profile != GST_VAAPI_PROFILE_VC1_ADVANCED) {
    memcpy (rbdu, ebdu, sizeof (*rbdu));
    return TRUE;
  }

  /* Reallocate unescaped bitstream buffer */
  rbdu_buffer = priv->rbdu_buffer;
  if (!rbdu_buffer || ebdu->size > priv->rbdu_buffer_size) {
    rbdu_buffer = g_realloc (priv->rbdu_buffer, ebdu->size);
    if (!rbdu_buffer)
      return FALSE;
    priv->rbdu_buffer = rbdu_buffer;
    priv->rbdu_buffer_size = ebdu->size;
  }

  /* Unescape bitstream buffer */
  if (ebdu->size < 4) {
    memcpy (rbdu_buffer, ebdu->data + ebdu->offset, ebdu->size);
    rbdu_buffer_size = ebdu->size;
  } else {
    guint8 *const bdu_buffer = ebdu->data + ebdu->offset;
    for (i = 0, j = 0; i < ebdu->size; i++) {
      if (i >= 2 && i < ebdu->size - 1 &&
          bdu_buffer[i - 1] == 0x00 &&
          bdu_buffer[i - 2] == 0x00 &&
          bdu_buffer[i] == 0x03 && bdu_buffer[i + 1] <= 0x03)
        i++;
      rbdu_buffer[j++] = bdu_buffer[i];
    }
    rbdu_buffer_size = j;
  }

  /* Reconstruct RBDU */
  rbdu->type = ebdu->type;
  rbdu->size = rbdu_buffer_size;
  rbdu->sc_offset = 0;
  rbdu->offset = 0;
  rbdu->data = rbdu_buffer;
  return TRUE;
}

static GstVaapiDecoderStatus
decode_ebdu (GstVaapiDecoderVC1 * decoder, GstVC1BDU * ebdu)
{
  GstVaapiDecoderStatus status;
  GstVC1BDU rbdu;

  if (!decode_rbdu (decoder, &rbdu, ebdu))
    return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;

  switch (ebdu->type) {
    case GST_VC1_SEQUENCE:
      status = decode_sequence (decoder, &rbdu, ebdu);
      break;
    case GST_VC1_ENTRYPOINT:
      status = decode_entry_point (decoder, &rbdu, ebdu);
      break;
    case GST_VC1_FRAME:
      status = decode_frame (decoder, &rbdu, ebdu);
      break;
    case GST_VC1_SLICE:
      status = decode_slice (decoder, &rbdu, ebdu);
      break;
    case GST_VC1_END_OF_SEQ:
      status = decode_sequence_end (decoder);
      break;
    case GST_VC1_FIELD_USER:
    case GST_VC1_FRAME_USER:
    case GST_VC1_ENTRY_POINT_USER:
    case GST_VC1_SEQUENCE_USER:
      /* Let's just ignore them */
      status = GST_VAAPI_DECODER_STATUS_SUCCESS;
      break;
    default:
      GST_WARNING ("unsupported BDU type %d", ebdu->type);
      status = GST_VAAPI_DECODER_STATUS_ERROR_BITSTREAM_PARSER;
      break;
  }
  return status;
}

static GstVaapiDecoderStatus
decode_buffer (GstVaapiDecoderVC1 * decoder, guchar * buf, guint buf_size)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1BDU ebdu;

  if (priv->has_codec_data) {
    ebdu.type = GST_VC1_FRAME;
    ebdu.sc_offset = 0;
    ebdu.offset = 0;
  } else {
    ebdu.type = buf[3];
    ebdu.sc_offset = 0;
    ebdu.offset = 4;
  }
  ebdu.data = buf;
  ebdu.size = buf_size - ebdu.offset;
  return decode_ebdu (decoder, &ebdu);
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_decode_codec_data (GstVaapiDecoder * base_decoder,
    const guchar * buf, guint buf_size)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVC1SeqHdr *const seq_hdr = &priv->seq_hdr;
  GstVaapiDecoderStatus status;
  GstVC1ParserResult result;
  GstVC1BDU ebdu;
  GstCaps *caps;
  GstStructure *structure;
  guint ofs;
  gint width, height;
  guint32 format;
  gint version;
  const gchar *s;

  priv->has_codec_data = TRUE;

  width = GST_VAAPI_DECODER_WIDTH (decoder);
  height = GST_VAAPI_DECODER_HEIGHT (decoder);
  if (!width || !height) {
    GST_ERROR ("failed to parse size from codec-data");
    return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  }

  caps = GST_VAAPI_DECODER_CODEC_STATE (decoder)->caps;
  structure = gst_caps_get_structure (caps, 0);
  s = gst_structure_get_string (structure, "format");
  if (s && strlen (s) == 4) {
    format = GST_MAKE_FOURCC (s[0], s[1], s[2], s[3]);
  } else {
    /* Try to determine format from "wmvversion" property */
    if (gst_structure_get_int (structure, "wmvversion", &version))
      format = (version >= 1 && version <= 3) ?
          GST_MAKE_FOURCC ('W', 'M', 'V', ('0' + version)) : 0;
    else
      format = 0;
  }
  if (!format) {
    GST_ERROR ("failed to parse profile from codec-data");
    return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC;
  }

  /* WMV3 -- expecting sequence header */
  if (format == GST_MAKE_FOURCC ('W', 'M', 'V', '3')) {
    seq_hdr->struct_c.coded_width = width;
    seq_hdr->struct_c.coded_height = height;
    ebdu.type = GST_VC1_SEQUENCE;
    ebdu.size = buf_size;
    ebdu.sc_offset = 0;
    ebdu.offset = 0;
    ebdu.data = (guint8 *) buf;
    return decode_ebdu (decoder, &ebdu);
  }

  /* WVC1 -- expecting bitstream data units */
  if (format != GST_MAKE_FOURCC ('W', 'V', 'C', '1'))
    return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
  seq_hdr->advanced.max_coded_width = width;
  seq_hdr->advanced.max_coded_height = height;

  ofs = 0;
  do {
    result = gst_vc1_identify_next_bdu (buf + ofs, buf_size - ofs, &ebdu);

    switch (result) {
      case GST_VC1_PARSER_NO_BDU_END:
        /* Assume the EBDU is complete within codec-data bounds */
        ebdu.size = buf_size - ofs - ebdu.offset;
        // fall-through
      case GST_VC1_PARSER_OK:
        status = decode_ebdu (decoder, &ebdu);
        ofs += ebdu.offset + ebdu.size;
        break;
      default:
        status = get_status (result);
        break;
    }
  } while (status == GST_VAAPI_DECODER_STATUS_SUCCESS && ofs < buf_size);
  return status;
}

static GstVaapiDecoderStatus
ensure_decoder (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiDecoderStatus status;

  if (!priv->is_opened) {
    priv->is_opened = gst_vaapi_decoder_vc1_open (decoder);
    if (!priv->is_opened)
      return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_CODEC;

    status =
        gst_vaapi_decoder_decode_codec_data (GST_VAAPI_DECODER_CAST (decoder));
    if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
      return status;
  }
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static inline gint
scan_for_start_code (GstAdapter * adapter, guint ofs, guint size, guint32 * scp)
{
  return (gint) gst_adapter_masked_scan_uint32_peek (adapter,
      0xffffff00, 0x00000100, ofs, size, scp);
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_parse (GstVaapiDecoder * base_decoder,
    GstAdapter * adapter, gboolean at_eos, GstVaapiDecoderUnit * unit)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiDecoderStatus status;
  guint8 bdu_type;
  guint size, buf_size, flags = 0;
  gint ofs;

  status = ensure_decoder (decoder);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
    return status;

  size = gst_adapter_available (adapter);

  if (priv->has_codec_data) {
    // Assume demuxer sends out plain frames
    if (size < 1)
      return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
    buf_size = size;
    bdu_type = GST_VC1_FRAME;
  } else {
    if (size < 4)
      return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;

    ofs = scan_for_start_code (adapter, 0, size, NULL);
    if (ofs < 0)
      return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
    gst_adapter_flush (adapter, ofs);
    size -= ofs;

    ofs = G_UNLIKELY (size < 8) ? -1 :
        scan_for_start_code (adapter, 4, size - 4, NULL);
    if (ofs < 0) {
      // Assume the whole packet is present if end-of-stream
      if (!at_eos)
        return GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA;
      ofs = size;
    }
    buf_size = ofs;
    gst_adapter_copy (adapter, &bdu_type, 3, 1);
  }

  unit->size = buf_size;

  /* Check for new picture layer */
  switch (bdu_type) {
    case GST_VC1_END_OF_SEQ:
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_END;
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_STREAM_END;
      break;
    case GST_VC1_SEQUENCE:
    case GST_VC1_ENTRYPOINT:
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
      break;
    case GST_VC1_FRAME:
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_FRAME_START;
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE;
      break;
    case GST_VC1_SLICE:
      flags |= GST_VAAPI_DECODER_UNIT_FLAG_SLICE;
      break;
    case GST_VC1_FIELD:
      /* @FIXME: intel-driver cannot handle interlaced frames */
      GST_ERROR ("interlaced video not supported");
      return GST_VAAPI_DECODER_STATUS_ERROR_UNSUPPORTED_PROFILE;
  }
  GST_VAAPI_DECODER_UNIT_FLAG_SET (unit, flags);
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_decode (GstVaapiDecoder * base_decoder,
    GstVaapiDecoderUnit * unit)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderStatus status;
  GstBuffer *const buffer =
      GST_VAAPI_DECODER_CODEC_FRAME (decoder)->input_buffer;
  GstMapInfo map_info;

  status = ensure_decoder (decoder);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
    return status;

  if (!gst_buffer_map (buffer, &map_info, GST_MAP_READ)) {
    GST_ERROR ("failed to map buffer");
    return GST_VAAPI_DECODER_STATUS_ERROR_UNKNOWN;
  }

  status = decode_buffer (decoder, map_info.data + unit->offset, unit->size);
  gst_buffer_unmap (buffer, &map_info);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
    return status;
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_start_frame (GstVaapiDecoder * base_decoder,
    GstVaapiDecoderUnit * unit)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;
  GstVaapiDecoderStatus status;
  GstVaapiPicture *picture;

  status = ensure_context (decoder);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS) {
    GST_ERROR ("failed to reset context");
    return status;
  }
  status = ensure_decoder (decoder);
  if (status != GST_VAAPI_DECODER_STATUS_SUCCESS)
    return status;

  picture = GST_VAAPI_PICTURE_NEW (VC1, decoder);
  if (!picture) {
    GST_ERROR ("failed to allocate picture");
    return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
  }
  gst_vaapi_picture_replace (&priv->current_picture, picture);
  gst_vaapi_picture_unref (picture);

  /* Update cropping rectangle */
  do {
    GstVC1AdvancedSeqHdr *adv_hdr;
    GstVaapiRectangle crop_rect;

    if (priv->profile != GST_VAAPI_PROFILE_VC1_ADVANCED)
      break;

    adv_hdr = &priv->seq_hdr.advanced;
    if (!adv_hdr->display_ext)
      break;

    crop_rect.x = 0;
    crop_rect.y = 0;
    crop_rect.width = adv_hdr->disp_horiz_size;
    crop_rect.height = adv_hdr->disp_vert_size;
    if (crop_rect.width <= priv->width && crop_rect.height <= priv->height)
      gst_vaapi_picture_set_crop_rect (picture, &crop_rect);
  } while (0);

  if (!gst_vc1_bitplanes_ensure_size (priv->bitplanes, &priv->seq_hdr)) {
    GST_ERROR ("failed to allocate bitplanes");
    return GST_VAAPI_DECODER_STATUS_ERROR_ALLOCATION_FAILED;
  }
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_end_frame (GstVaapiDecoder * base_decoder)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);

  return decode_current_picture (decoder);
}

static GstVaapiDecoderStatus
gst_vaapi_decoder_vc1_flush (GstVaapiDecoder * base_decoder)
{
  GstVaapiDecoderVC1 *const decoder = GST_VAAPI_DECODER_VC1_CAST (base_decoder);
  GstVaapiDecoderVC1Private *const priv = &decoder->priv;

  if (priv->is_opened)
    gst_vaapi_dpb_flush (priv->dpb);
  return GST_VAAPI_DECODER_STATUS_SUCCESS;
}

static void
gst_vaapi_decoder_vc1_finalize (GObject * object)
{
  GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (object);

  gst_vaapi_decoder_vc1_destroy (base_decoder);
  G_OBJECT_CLASS (gst_vaapi_decoder_vc1_parent_class)->finalize (object);
}

static void
gst_vaapi_decoder_vc1_class_init (GstVaapiDecoderVC1Class * klass)
{
  GObjectClass *const object_class = G_OBJECT_CLASS (klass);
  GstVaapiDecoderClass *const decoder_class = GST_VAAPI_DECODER_CLASS (klass);

  object_class->finalize = gst_vaapi_decoder_vc1_finalize;

  decoder_class->reset = gst_vaapi_decoder_vc1_reset;
  decoder_class->parse = gst_vaapi_decoder_vc1_parse;
  decoder_class->decode = gst_vaapi_decoder_vc1_decode;
  decoder_class->start_frame = gst_vaapi_decoder_vc1_start_frame;
  decoder_class->end_frame = gst_vaapi_decoder_vc1_end_frame;
  decoder_class->flush = gst_vaapi_decoder_vc1_flush;

  decoder_class->decode_codec_data = gst_vaapi_decoder_vc1_decode_codec_data;
}

static void
gst_vaapi_decoder_vc1_init (GstVaapiDecoderVC1 * decoder)
{
  GstVaapiDecoder *const base_decoder = GST_VAAPI_DECODER (decoder);

  gst_vaapi_decoder_vc1_create (base_decoder);
}

/**
 * gst_vaapi_decoder_vc1_new:
 * @display: a #GstVaapiDisplay
 * @caps: a #GstCaps holding codec information
 *
 * Creates a new #GstVaapiDecoder for VC-1 decoding.  The @caps can
 * hold extra information like codec-data and pictured coded size.
 *
 * Return value: the newly allocated #GstVaapiDecoder object
 */
GstVaapiDecoder *
gst_vaapi_decoder_vc1_new (GstVaapiDisplay * display, GstCaps * caps)
{
  return g_object_new (GST_TYPE_VAAPI_DECODER_VC1, "display", display,
      "caps", caps, NULL);
}