gstreamer/subprojects/gst-plugins-bad/sys/aja/gstajasrc.cpp

/* GStreamer
 * Copyright (C) 2021 Sebastian Dröge <sebastian@centricular.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 Street, Suite 500,
 * Boston, MA 02110-1335, USA.
 */

/**
 * SECTION:element-ajasrc
 *
 * Source element for [AJA](https://www.aja.com) capture cards.
 *
 * ## Example usage
 *
 * Capture 1080p30 audio/video and display it locally
 *
 * ```sh
 * gst-launch-1.0 ajasrc video-format=1080p-3000 ! ajasrcdemux name=d \
 *     d.video ! queue max-size-bytes=0 max-size-buffers=0
 * max-size-time=1000000000 ! videoconvert ! autovideosink \ d.audio ! queue
 * max-size-bytes=0 max-size-buffers=0 max-size-time=1000000000 ! audioconvert !
 * audioresample ! autoaudiosink
 * ```
 *
 * Capture 1080p30 audio/video and directly output it again on the same card
 *
 * ```sh
 * gst-launch-1.0 ajasrc video-format=1080p-3000 channel=1 input-source=sdi-1
 * audio-system=2 ! ajasrcdemux name=d \
 *     d.video ! queue max-size-bytes=0 max-size-buffers=0
 * max-size-time=1000000000 ! c.video \
 *     d.audio ! queue max-size-bytes=0 max-size-buffers=0
 * max-size-time=1000000000 ! c.audio \ ajasinkcombiner name=c ! ajasink
 * channel=0 reference-source=input-1
 * ```
 *
 * Since: 1.24
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <ajaanc/includes/ancillarydata_cea608_vanc.h>
#include <ajaanc/includes/ancillarydata_cea708.h>
#include <ajaanc/includes/ancillarylist.h>
#include <ajantv2/includes/ntv2rp188.h>
#include <ajantv2/includes/ntv2vpid.h>

#include "gstajacommon.h"
#include "gstajasrc.h"

GST_DEBUG_CATEGORY_STATIC(gst_aja_src_debug);
#define GST_CAT_DEFAULT gst_aja_src_debug

#define DEFAULT_DEVICE_IDENTIFIER ("0")
#define DEFAULT_CHANNEL (::NTV2_CHANNEL1)
#define DEFAULT_VIDEO_FORMAT (GST_AJA_VIDEO_FORMAT_AUTO)
#define DEFAULT_AUDIO_SYSTEM (GST_AJA_AUDIO_SYSTEM_AUTO)
#define DEFAULT_INPUT_SOURCE (GST_AJA_INPUT_SOURCE_AUTO)
#define DEFAULT_SDI_MODE (GST_AJA_SDI_MODE_SINGLE_LINK)
#define DEFAULT_AUDIO_SOURCE (GST_AJA_AUDIO_SOURCE_EMBEDDED)
#define DEFAULT_EMBEDDED_AUDIO_INPUT (GST_AJA_EMBEDDED_AUDIO_INPUT_AUTO)
#define DEFAULT_TIMECODE_INDEX (GST_AJA_TIMECODE_INDEX_VITC)
#define DEFAULT_RP188 (TRUE)
#define DEFAULT_REFERENCE_SOURCE (GST_AJA_REFERENCE_SOURCE_FREERUN)
#define DEFAULT_CLOSED_CAPTION_CAPTURE_MODE \
  (GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_AND_CEA608)
#define DEFAULT_QUEUE_SIZE (16)
#define DEFAULT_START_FRAME (8)
#define DEFAULT_END_FRAME (8)
#define DEFAULT_CAPTURE_CPU_CORE (G_MAXUINT)
#define DEFAULT_ATTACH_ANCILLARY_META (FALSE)

enum {
  PROP_0,
  PROP_DEVICE_IDENTIFIER,
  PROP_CHANNEL,
  PROP_VIDEO_FORMAT,
  PROP_AUDIO_SYSTEM,
  PROP_INPUT_SOURCE,
  PROP_SDI_MODE,
  PROP_AUDIO_SOURCE,
  PROP_EMBEDDED_AUDIO_INPUT,
  PROP_TIMECODE_INDEX,
  PROP_RP188,
  PROP_REFERENCE_SOURCE,
  PROP_CLOSED_CAPTION_CAPTURE_MODE,
  PROP_START_FRAME,
  PROP_END_FRAME,
  PROP_QUEUE_SIZE,
  PROP_CAPTURE_CPU_CORE,
  PROP_SIGNAL,
  PROP_ATTACH_ANCILLARY_META,
};

// Make these plain C structs for usage in GstVecDeque
G_BEGIN_DECLS

typedef enum {
  QUEUE_ITEM_TYPE_DUMMY,
  QUEUE_ITEM_TYPE_FRAME,
  QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
  QUEUE_ITEM_TYPE_ERROR,
  QUEUE_ITEM_TYPE_FRAMES_DROPPED,
} QueueItemType;

typedef struct {
  QueueItemType type;

  union {
    // For DUMMY
    struct {
      gchar dummy;
    } dummy;
    // For FRAME
    struct {
      GstClockTime capture_time;
      GstBuffer *video_buffer;
      GstBuffer *audio_buffer;
      GstBuffer *anc_buffer, *anc_buffer2;
      NTV2_RP188 tc;

      NTV2VideoFormat detected_format;
      guint32 vpid;
    } frame;
    // For SIGNAL_CHANGE
    struct {
      gboolean have_signal;
      NTV2VideoFormat detected_format;
      guint32 vpid;
    } signal_change;
    // For ERROR
    struct {
      GstMessage *msg;
    } error;
    // For FRAMES_DROPPED
    struct {
      gboolean driver_side;
      GstClockTime timestamp_start, timestamp_end;
    } frames_dropped;
  };
} QueueItem;

G_END_DECLS

static void queue_item_clear(QueueItem *item) {
  switch (item->type) {
    case QUEUE_ITEM_TYPE_DUMMY:
      break;
    case QUEUE_ITEM_TYPE_FRAME:
      gst_clear_buffer(&item->frame.video_buffer);
      gst_clear_buffer(&item->frame.audio_buffer);
      gst_clear_buffer(&item->frame.anc_buffer);
      gst_clear_buffer(&item->frame.anc_buffer2);
      item->frame.tc.~NTV2_RP188();
      break;
    case QUEUE_ITEM_TYPE_SIGNAL_CHANGE:
      break;
    case QUEUE_ITEM_TYPE_ERROR:
      gst_clear_message(&item->error.msg);
      break;
    case QUEUE_ITEM_TYPE_FRAMES_DROPPED:
      break;
  }

  item->type = QUEUE_ITEM_TYPE_DUMMY;
}

static void gst_aja_src_set_property(GObject *object, guint property_id,
                                     const GValue *value, GParamSpec *pspec);
static void gst_aja_src_get_property(GObject *object, guint property_id,
                                     GValue *value, GParamSpec *pspec);
static void gst_aja_src_constructed(GObject *object);
static void gst_aja_src_finalize(GObject *object);

static GstCaps *gst_aja_src_get_caps(GstBaseSrc *bsrc, GstCaps *filter);
static gboolean gst_aja_src_query(GstBaseSrc *bsrc, GstQuery *query);
static gboolean gst_aja_src_unlock(GstBaseSrc *bsrc);
static gboolean gst_aja_src_unlock_stop(GstBaseSrc *bsrc);

static GstFlowReturn gst_aja_src_create(GstPushSrc *psrc, GstBuffer **buffer);

static gboolean gst_aja_src_open(GstAjaSrc *src);
static gboolean gst_aja_src_close(GstAjaSrc *src);
static gboolean gst_aja_src_stop(GstAjaSrc *src);

static GstStateChangeReturn gst_aja_src_change_state(GstElement *element,
                                                     GstStateChange transition);
static GstClock *gst_aja_src_provide_clock(GstElement *element);

static void capture_thread_func(AJAThread *thread, void *data);

#define parent_class gst_aja_src_parent_class
G_DEFINE_TYPE(GstAjaSrc, gst_aja_src, GST_TYPE_PUSH_SRC);

static void gst_aja_src_class_init(GstAjaSrcClass *klass) {
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  GstElementClass *element_class = GST_ELEMENT_CLASS(klass);
  GstBaseSrcClass *basesrc_class = GST_BASE_SRC_CLASS(klass);
  GstPushSrcClass *pushsrc_class = GST_PUSH_SRC_CLASS(klass);
  GstCaps *templ_caps;

  gobject_class->set_property = gst_aja_src_set_property;
  gobject_class->get_property = gst_aja_src_get_property;
  gobject_class->constructed = gst_aja_src_constructed;
  gobject_class->finalize = gst_aja_src_finalize;

  g_object_class_install_property(
      gobject_class, PROP_DEVICE_IDENTIFIER,
      g_param_spec_string(
          "device-identifier", "Device identifier",
          "Input device instance to use", DEFAULT_DEVICE_IDENTIFIER,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_CHANNEL,
      g_param_spec_uint(
          "channel", "Channel", "Channel to use", 0, NTV2_MAX_NUM_CHANNELS - 1,
          DEFAULT_CHANNEL,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_VIDEO_FORMAT,
      g_param_spec_enum(
          "video-format", "Video Format", "Video format to use",
          GST_TYPE_AJA_VIDEO_FORMAT, DEFAULT_VIDEO_FORMAT,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_QUEUE_SIZE,
      g_param_spec_uint(
          "queue-size", "Queue Size",
          "Size of internal queue in number of video frames. "
          "Half of this is allocated as device buffers and equal to the "
          "latency.",
          1, G_MAXINT, DEFAULT_QUEUE_SIZE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));

  g_object_class_install_property(
      gobject_class, PROP_START_FRAME,
      g_param_spec_uint(
          "start-frame", "Start Frame",
          "Start frame buffer to be used for capturing (automatically assign "
          "that many frames if same number as end-frame).",
          0, G_MAXINT, DEFAULT_START_FRAME,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));

  g_object_class_install_property(
      gobject_class, PROP_END_FRAME,
      g_param_spec_uint(
          "end-frame", "End Frame",
          "End frame buffer to be used for capturing (automatically assign "
          "that many frames if same number as start-frame).",
          0, G_MAXINT, DEFAULT_END_FRAME,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));

  g_object_class_install_property(
      gobject_class, PROP_AUDIO_SYSTEM,
      g_param_spec_enum(
          "audio-system", "Audio System", "Audio system to use",
          GST_TYPE_AJA_AUDIO_SYSTEM, DEFAULT_AUDIO_SYSTEM,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_INPUT_SOURCE,
      g_param_spec_enum(
          "input-source", "Input Source", "Input source to use",
          GST_TYPE_AJA_INPUT_SOURCE, DEFAULT_INPUT_SOURCE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_SDI_MODE,
      g_param_spec_enum(
          "sdi-input-mode", "SDI Input Mode", "SDI input mode to use",
          GST_TYPE_AJA_SDI_MODE, DEFAULT_SDI_MODE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_AUDIO_SOURCE,
      g_param_spec_enum(
          "audio-source", "Audio Source", "Audio source to use",
          GST_TYPE_AJA_AUDIO_SOURCE, DEFAULT_AUDIO_SOURCE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_EMBEDDED_AUDIO_INPUT,
      g_param_spec_enum(
          "embedded-audio-input", "Embedded Audio Input",
          "Embedded Audio Input to use", GST_TYPE_AJA_EMBEDDED_AUDIO_INPUT,
          DEFAULT_EMBEDDED_AUDIO_INPUT,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_TIMECODE_INDEX,
      g_param_spec_enum(
          "timecode-index", "Timecode Index", "Timecode index to use",
          GST_TYPE_AJA_TIMECODE_INDEX, DEFAULT_TIMECODE_INDEX,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_RP188,
      g_param_spec_boolean(
          "rp188", "RP188", "Enable RP188 timecode retrieval", DEFAULT_RP188,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_REFERENCE_SOURCE,
      g_param_spec_enum(
          "reference-source", "Reference Source", "Reference source to use",
          GST_TYPE_AJA_REFERENCE_SOURCE, DEFAULT_REFERENCE_SOURCE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_CLOSED_CAPTION_CAPTURE_MODE,
      g_param_spec_enum(
          "closed-caption-capture-mode", "Closed Caption Capture Mode",
          "Closed Caption Capture Mode",
          GST_TYPE_AJA_CLOSED_CAPTION_CAPTURE_MODE,
          DEFAULT_CLOSED_CAPTION_CAPTURE_MODE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_CAPTURE_CPU_CORE,
      g_param_spec_uint(
          "capture-cpu-core", "Capture CPU Core",
          "Sets the affinity of the capture thread to this CPU core "
          "(-1=disabled)",
          0, G_MAXUINT, DEFAULT_CAPTURE_CPU_CORE,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  g_object_class_install_property(
      gobject_class, PROP_SIGNAL,
      g_param_spec_boolean(
          "signal", "Input signal available",
          "True if there is a valid input signal available", FALSE,
          (GParamFlags)(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));

  /**
   * GstAjaSrc:attach-ancillary-meta:
   *
   * If set to %TRUE attach any ancillary data as #GstAncillaryMeta on buffers
   *
   * Since: 1.24
   */
  g_object_class_install_property(
      gobject_class, PROP_ATTACH_ANCILLARY_META,
      g_param_spec_boolean(
          "attach-ancillary-meta", "Attach Ancillary Meta",
          "Attach ancillary meta to video frames",
          DEFAULT_ATTACH_ANCILLARY_META,
          (GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
                        G_PARAM_CONSTRUCT)));

  element_class->change_state = GST_DEBUG_FUNCPTR(gst_aja_src_change_state);
  element_class->provide_clock = GST_DEBUG_FUNCPTR(gst_aja_src_provide_clock);

  basesrc_class->get_caps = GST_DEBUG_FUNCPTR(gst_aja_src_get_caps);
  basesrc_class->negotiate = NULL;
  basesrc_class->query = GST_DEBUG_FUNCPTR(gst_aja_src_query);
  basesrc_class->unlock = GST_DEBUG_FUNCPTR(gst_aja_src_unlock);
  basesrc_class->unlock_stop = GST_DEBUG_FUNCPTR(gst_aja_src_unlock_stop);

  pushsrc_class->create = GST_DEBUG_FUNCPTR(gst_aja_src_create);

  templ_caps = gst_ntv2_supported_caps(DEVICE_ID_INVALID);
  gst_element_class_add_pad_template(
      element_class,
      gst_pad_template_new("src", GST_PAD_SRC, GST_PAD_ALWAYS, templ_caps));
  gst_caps_unref(templ_caps);

  gst_element_class_set_static_metadata(
      element_class, "AJA audio/video src", "Audio/Video/Source",
      "Captures audio/video frames with AJA devices",
      "Sebastian Dröge <sebastian@centricular.com>");

  GST_DEBUG_CATEGORY_INIT(gst_aja_src_debug, "ajasrc", 0, "AJA src");
}

static void gst_aja_src_init(GstAjaSrc *self) {
  GST_OBJECT_FLAG_SET(
      self, GST_ELEMENT_FLAG_PROVIDE_CLOCK | GST_ELEMENT_FLAG_REQUIRE_CLOCK);

  g_mutex_init(&self->queue_lock);
  g_cond_init(&self->queue_cond);

  self->device_identifier = g_strdup(DEFAULT_DEVICE_IDENTIFIER);
  self->channel = DEFAULT_CHANNEL;
  self->queue_size = DEFAULT_QUEUE_SIZE;
  self->start_frame = DEFAULT_START_FRAME;
  self->end_frame = DEFAULT_END_FRAME;
  self->video_format_setting = DEFAULT_VIDEO_FORMAT;
  self->audio_system_setting = DEFAULT_AUDIO_SYSTEM;
  self->input_source = DEFAULT_INPUT_SOURCE;
  self->audio_source = DEFAULT_AUDIO_SOURCE;
  self->embedded_audio_input = DEFAULT_EMBEDDED_AUDIO_INPUT;
  self->timecode_index = DEFAULT_TIMECODE_INDEX;
  self->reference_source = DEFAULT_REFERENCE_SOURCE;
  self->closed_caption_capture_mode = DEFAULT_CLOSED_CAPTION_CAPTURE_MODE;
  self->capture_cpu_core = DEFAULT_CAPTURE_CPU_CORE;
  self->attach_ancillary_meta = DEFAULT_ATTACH_ANCILLARY_META;

  self->queue =
      gst_vec_deque_new_for_struct(sizeof(QueueItem), self->queue_size);
  gst_base_src_set_live(GST_BASE_SRC_CAST(self), TRUE);
  gst_base_src_set_format(GST_BASE_SRC_CAST(self), GST_FORMAT_TIME);

  self->video_format = NTV2_FORMAT_UNKNOWN;
}

void gst_aja_src_set_property(GObject *object, guint property_id,
                              const GValue *value, GParamSpec *pspec) {
  GstAjaSrc *self = GST_AJA_SRC(object);

  switch (property_id) {
    case PROP_DEVICE_IDENTIFIER:
      g_free(self->device_identifier);
      self->device_identifier = g_value_dup_string(value);
      break;
    case PROP_CHANNEL:
      self->channel = (NTV2Channel)g_value_get_uint(value);
      break;
    case PROP_QUEUE_SIZE:
      self->queue_size = g_value_get_uint(value);
      break;
    case PROP_START_FRAME:
      self->start_frame = g_value_get_uint(value);
      break;
    case PROP_END_FRAME:
      self->end_frame = g_value_get_uint(value);
      break;
    case PROP_VIDEO_FORMAT:
      self->video_format_setting = (GstAjaVideoFormat)g_value_get_enum(value);
      break;
    case PROP_AUDIO_SYSTEM:
      self->audio_system_setting = (GstAjaAudioSystem)g_value_get_enum(value);
      break;
    case PROP_INPUT_SOURCE:
      self->input_source = (GstAjaInputSource)g_value_get_enum(value);
      break;
    case PROP_SDI_MODE:
      self->sdi_mode = (GstAjaSdiMode)g_value_get_enum(value);
      break;
    case PROP_AUDIO_SOURCE:
      self->audio_source = (GstAjaAudioSource)g_value_get_enum(value);
      break;
    case PROP_EMBEDDED_AUDIO_INPUT:
      self->embedded_audio_input =
          (GstAjaEmbeddedAudioInput)g_value_get_enum(value);
      break;
    case PROP_TIMECODE_INDEX:
      self->timecode_index = (GstAjaTimecodeIndex)g_value_get_enum(value);
      break;
    case PROP_RP188:
      self->rp188 = g_value_get_boolean(value);
      break;
    case PROP_REFERENCE_SOURCE:
      self->reference_source = (GstAjaReferenceSource)g_value_get_enum(value);
      break;
    case PROP_CLOSED_CAPTION_CAPTURE_MODE:
      self->closed_caption_capture_mode =
          (GstAjaClosedCaptionCaptureMode)g_value_get_enum(value);
      break;
    case PROP_CAPTURE_CPU_CORE:
      self->capture_cpu_core = g_value_get_uint(value);
      break;
    case PROP_ATTACH_ANCILLARY_META:
      self->attach_ancillary_meta = g_value_get_boolean(value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
      break;
  }
}

void gst_aja_src_get_property(GObject *object, guint property_id, GValue *value,
                              GParamSpec *pspec) {
  GstAjaSrc *self = GST_AJA_SRC(object);

  switch (property_id) {
    case PROP_DEVICE_IDENTIFIER:
      g_value_set_string(value, self->device_identifier);
      break;
    case PROP_CHANNEL:
      g_value_set_uint(value, self->channel);
      break;
    case PROP_QUEUE_SIZE:
      g_value_set_uint(value, self->queue_size);
      break;
    case PROP_START_FRAME:
      g_value_set_uint(value, self->start_frame);
      break;
    case PROP_END_FRAME:
      g_value_set_uint(value, self->end_frame);
      break;
    case PROP_VIDEO_FORMAT:
      g_value_set_enum(value, self->video_format_setting);
      break;
    case PROP_AUDIO_SYSTEM:
      g_value_set_enum(value, self->audio_system_setting);
      break;
    case PROP_INPUT_SOURCE:
      g_value_set_enum(value, self->input_source);
      break;
    case PROP_SDI_MODE:
      g_value_set_enum(value, self->sdi_mode);
      break;
    case PROP_AUDIO_SOURCE:
      g_value_set_enum(value, self->audio_source);
      break;
    case PROP_EMBEDDED_AUDIO_INPUT:
      g_value_set_enum(value, self->embedded_audio_input);
      break;
    case PROP_TIMECODE_INDEX:
      g_value_set_enum(value, self->timecode_index);
      break;
    case PROP_RP188:
      g_value_set_boolean(value, self->rp188);
      break;
    case PROP_REFERENCE_SOURCE:
      g_value_set_enum(value, self->reference_source);
      break;
    case PROP_CLOSED_CAPTION_CAPTURE_MODE:
      g_value_set_enum(value, self->closed_caption_capture_mode);
      break;
    case PROP_CAPTURE_CPU_CORE:
      g_value_set_uint(value, self->capture_cpu_core);
      break;
    case PROP_SIGNAL:
      g_value_set_boolean(value, self->signal);
      break;
    case PROP_ATTACH_ANCILLARY_META:
      g_value_set_boolean(value, self->attach_ancillary_meta);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
      break;
  }
}

void gst_aja_src_constructed(GObject *object) {
  GstAjaSrc *self = GST_AJA_SRC(object);

  G_OBJECT_CLASS(parent_class)->constructed(object);

  gchar *aja_clock_name = g_strdup_printf("ajaclock-%s", GST_OBJECT_NAME(self));
  self->clock =
      GST_CLOCK(g_object_new(GST_TYPE_SYSTEM_CLOCK, "name", aja_clock_name,
                             "clock-type", GST_CLOCK_TYPE_MONOTONIC, NULL));
  g_free(aja_clock_name);
}

void gst_aja_src_finalize(GObject *object) {
  GstAjaSrc *self = GST_AJA_SRC(object);

  g_assert(self->device == NULL);
  g_assert(gst_vec_deque_get_length(self->queue) == 0);
  g_clear_pointer(&self->queue, gst_vec_deque_free);

  gst_clear_object(&self->clock);

  g_mutex_clear(&self->queue_lock);
  g_cond_clear(&self->queue_cond);

  G_OBJECT_CLASS(parent_class)->finalize(object);
}

static gboolean gst_aja_src_open(GstAjaSrc *self) {
  GST_DEBUG_OBJECT(self, "Opening device");

  g_assert(self->device == NULL);

  self->device = gst_aja_ntv2_device_obtain(self->device_identifier);
  if (!self->device) {
    GST_ERROR_OBJECT(self, "Failed to open device");
    return FALSE;
  }

  if (!self->device->device->IsDeviceReady(false)) {
    g_clear_pointer(&self->device, gst_aja_ntv2_device_unref);
    return FALSE;
  }

  self->device->device->SetEveryFrameServices(::NTV2_OEM_TASKS);
  self->device_id = self->device->device->GetDeviceID();

  std::string serial_number;
  if (!self->device->device->GetSerialNumberString(serial_number))
    serial_number = "none";

  GST_DEBUG_OBJECT(self,
                   "Opened device with ID %d at index %d (%s, version %s, "
                   "serial number %s, can do VANC %d)",
                   self->device_id, self->device->device->GetIndexNumber(),
                   self->device->device->GetDisplayName().c_str(),
                   self->device->device->GetDeviceVersionString().c_str(),
                   serial_number.c_str(),
                   ::NTV2DeviceCanDoCustomAnc(self->device_id));

  GST_DEBUG_OBJECT(self,
                   "Using SDK version %d.%d.%d.%d (%s) and driver version %s",
                   AJA_NTV2_SDK_VERSION_MAJOR, AJA_NTV2_SDK_VERSION_MINOR,
                   AJA_NTV2_SDK_VERSION_POINT, AJA_NTV2_SDK_BUILD_NUMBER,
                   AJA_NTV2_SDK_BUILD_DATETIME,
                   self->device->device->GetDriverVersionString().c_str());

  self->device->device->SetMultiFormatMode(true);

  self->allocator = gst_aja_allocator_new(self->device);

  GST_DEBUG_OBJECT(self, "Opened device");

  return TRUE;
}

static gboolean gst_aja_src_close(GstAjaSrc *self) {
  gst_clear_object(&self->allocator);
  g_clear_pointer(&self->device, gst_aja_ntv2_device_unref);
  self->device_id = DEVICE_ID_INVALID;

  GST_DEBUG_OBJECT(self, "Closed device");

  return TRUE;
}

// Must be called with GstAjaNtv2DeviceLocker
static gboolean gst_aja_src_configure(GstAjaSrc *self) {
  GST_DEBUG_OBJECT(self, "Starting");

#define NEEDS_QUAD_MODE(self)                           \
  (self->sdi_mode == GST_AJA_SDI_MODE_QUAD_LINK_SQD ||  \
   self->sdi_mode == GST_AJA_SDI_MODE_QUAD_LINK_TSI ||  \
   (self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 && \
    self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4))

  self->quad_mode = NEEDS_QUAD_MODE(self);

#undef NEEDS_QUAD_MODE

  if (self->quad_mode) {
    if (self->input_source != GST_AJA_INPUT_SOURCE_AUTO &&
        !(self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
          self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4)) {
      GST_ERROR_OBJECT(
          self,
          "Quad modes require usage of the channel's default input source");
      return FALSE;
    }

    if (self->channel != ::NTV2_CHANNEL1 && self->channel != ::NTV2_CHANNEL5) {
      GST_ERROR_OBJECT(self, "Quad modes require channels 1 or 5");
      return FALSE;
    }
  }

  bool had_quad_enabled = false, had_quad_quad_enabled = false;

  // HDMI can also be internally quad mode but it runs on a single channel.
  if (!(self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
        self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4)) {
    if (self->channel < ::NTV2_CHANNEL5) {
      self->device->device->GetQuadFrameEnable(had_quad_enabled,
                                               ::NTV2_CHANNEL1);

      // 12G UHD is also internally considered quad modes but they run on a
      // single channel.
      if (had_quad_enabled && ::NTV2DeviceCanDo12gRouting(self->device_id)) {
        NTV2VideoFormat fmt =
            self->device->device->GetInputVideoFormat(::NTV2_INPUTSOURCE_SDI1);
        if (fmt >= NTV2_FORMAT_FIRST_UHD_TSI_DEF_FORMAT &&
            fmt < NTV2_FORMAT_END_4K_TSI_DEF_FORMATS)
          had_quad_enabled = false;
      }

      self->device->device->GetQuadQuadFrameEnable(had_quad_quad_enabled,
                                                   ::NTV2_CHANNEL1);
    } else {
      self->device->device->GetQuadFrameEnable(had_quad_enabled,
                                               ::NTV2_CHANNEL5);

      // 12G UHD is also internally considered quad modes but they run on a
      // single channel.
      if (had_quad_enabled && ::NTV2DeviceCanDo12gRouting(self->device_id)) {
        NTV2VideoFormat fmt =
            self->device->device->GetInputVideoFormat(::NTV2_INPUTSOURCE_SDI5);
        if (fmt >= NTV2_FORMAT_FIRST_UHD_TSI_DEF_FORMAT &&
            fmt < NTV2_FORMAT_END_4K_TSI_DEF_FORMATS)
          had_quad_enabled = false;
      }

      self->device->device->GetQuadQuadFrameEnable(had_quad_quad_enabled,
                                                   ::NTV2_CHANNEL5);
    }
  }

  // Stop any previously running quad mode, or other configurations on the
  // quad channels
  self->device->device->AutoCirculateStop(self->channel);
  if (self->quad_mode || had_quad_enabled || had_quad_enabled) {
    NTV2Channel quad_channel;

    if (self->channel < ::NTV2_CHANNEL5)
      quad_channel = ::NTV2_CHANNEL1;
    else
      quad_channel = ::NTV2_CHANNEL5;

    for (int i = 0; i < 4; i++) {
      self->device->device->AutoCirculateStop((NTV2Channel)(quad_channel + i));
    }
  }

  if (self->buffer_pool) {
    gst_buffer_pool_set_active(self->buffer_pool, FALSE);
    gst_clear_object(&self->buffer_pool);
  }

  if (self->audio_buffer_pool) {
    gst_buffer_pool_set_active(self->audio_buffer_pool, FALSE);
    gst_clear_object(&self->audio_buffer_pool);
  }

  if (self->anc_buffer_pool) {
    gst_buffer_pool_set_active(self->anc_buffer_pool, FALSE);
    gst_clear_object(&self->anc_buffer_pool);
  }

  NTV2VANCMode vanc_mode;
  NTV2InputSource input_source;
  NTV2OutputCrosspointID input_source_id;
  switch (self->input_source) {
    case GST_AJA_INPUT_SOURCE_AUTO:
      input_source = ::NTV2ChannelToInputSource(self->channel);
      input_source_id = ::GetSDIInputOutputXptFromChannel(self->channel, false);
      vanc_mode = ::NTV2DeviceCanDoCustomAnc(self->device_id)
                      ? ::NTV2_VANCMODE_OFF
                      : ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_ANALOG1:
      input_source = ::NTV2_INPUTSOURCE_ANALOG1;
      input_source_id = ::NTV2_XptAnalogIn;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_HDMI1:
      input_source = ::NTV2_INPUTSOURCE_HDMI1;
      input_source_id = ::NTV2_XptHDMIIn1;
      vanc_mode = ::NTV2_VANCMODE_OFF;
      break;
    case GST_AJA_INPUT_SOURCE_HDMI2:
      input_source = ::NTV2_INPUTSOURCE_HDMI2;
      input_source_id = ::NTV2_XptHDMIIn2;
      vanc_mode = ::NTV2_VANCMODE_OFF;
      break;
    case GST_AJA_INPUT_SOURCE_HDMI3:
      input_source = ::NTV2_INPUTSOURCE_HDMI3;
      input_source_id = ::NTV2_XptHDMIIn3;
      vanc_mode = ::NTV2_VANCMODE_OFF;
      break;
    case GST_AJA_INPUT_SOURCE_HDMI4:
      input_source = ::NTV2_INPUTSOURCE_HDMI4;
      input_source_id = ::NTV2_XptHDMIIn4;
      vanc_mode = ::NTV2_VANCMODE_OFF;
      break;
    case GST_AJA_INPUT_SOURCE_SDI1:
      input_source = ::NTV2_INPUTSOURCE_SDI1;
      input_source_id = ::NTV2_XptSDIIn1;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI2:
      input_source = ::NTV2_INPUTSOURCE_SDI2;
      input_source_id = ::NTV2_XptSDIIn2;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI3:
      input_source = ::NTV2_INPUTSOURCE_SDI3;
      input_source_id = ::NTV2_XptSDIIn3;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI4:
      input_source = ::NTV2_INPUTSOURCE_SDI4;
      input_source_id = ::NTV2_XptSDIIn4;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI5:
      input_source = ::NTV2_INPUTSOURCE_SDI5;
      input_source_id = ::NTV2_XptSDIIn5;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI6:
      input_source = ::NTV2_INPUTSOURCE_SDI6;
      input_source_id = ::NTV2_XptSDIIn6;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI7:
      input_source = ::NTV2_INPUTSOURCE_SDI7;
      input_source_id = ::NTV2_XptSDIIn7;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    case GST_AJA_INPUT_SOURCE_SDI8:
      input_source = ::NTV2_INPUTSOURCE_SDI8;
      input_source_id = ::NTV2_XptSDIIn8;
      vanc_mode = ::NTV2_VANCMODE_TALL;
      break;
    default:
      g_assert_not_reached();
      break;
  }

  self->configured_input_source = input_source;

  self->vanc_mode = vanc_mode;

  if (!self->device->device->EnableChannel(self->channel)) {
    GST_ERROR_OBJECT(self, "Failed to enable channel");
    return FALSE;
  }

  if (self->quad_mode) {
    for (int i = 1; i < 4; i++) {
      if (!self->device->device->EnableChannel(
              (NTV2Channel)(self->channel + i))) {
        GST_ERROR_OBJECT(self, "Failed to enable channel");
        return FALSE;
      }
    }
  }

  self->device->device->EnableInputInterrupt(self->channel);
  self->device->device->SubscribeInputVerticalEvent(self->channel);

  if (self->video_format_setting == GST_AJA_VIDEO_FORMAT_AUTO) {
    self->device->device->WaitForInputVerticalInterrupt(self->channel, 10);
    self->video_format = self->device->device->GetInputVideoFormat(
        self->configured_input_source);
    if (self->video_format == NTV2_FORMAT_UNKNOWN) {
      GST_ERROR_OBJECT(self, "Input video format not detected");
      return TRUE;
    }
    std::string configured_string = NTV2VideoFormatToString(self->video_format);
    GST_DEBUG_OBJECT(self, "Detected input video format %s (%d)",
                     configured_string.c_str(), (int)self->video_format);
  } else {
    self->video_format = gst_ntv2_video_format_from_aja_format(
        self->video_format_setting, self->quad_mode);
  }

  if (self->video_format == NTV2_FORMAT_UNKNOWN) {
    GST_ERROR_OBJECT(self, "Unsupported mode");
    return FALSE;
  }

  if (!::NTV2DeviceCanDoVideoFormat(self->device_id, self->video_format)) {
    GST_ERROR_OBJECT(self, "Device does not support mode %d",
                     (int)self->video_format);
    return FALSE;
  }

  gst_video_info_from_ntv2_video_format(&self->configured_info,
                                        self->video_format);

  if (self->quad_mode) {
    if (self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
        self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4) {
      self->device->device->SetQuadQuadFrameEnable(false, self->channel);
      self->device->device->SetQuadQuadSquaresEnable(false, self->channel);
      self->device->device->Set4kSquaresEnable(true, self->channel);
      self->device->device->SetTsiFrameEnable(true, self->channel);
    } else {
      switch (self->sdi_mode) {
        case GST_AJA_SDI_MODE_SINGLE_LINK:
          g_assert_not_reached();
          break;
        case GST_AJA_SDI_MODE_QUAD_LINK_SQD:
          if (self->configured_info.height > 2160) {
            self->device->device->Set4kSquaresEnable(false, self->channel);
            self->device->device->SetTsiFrameEnable(false, self->channel);
            self->device->device->SetQuadQuadFrameEnable(true, self->channel);
            self->device->device->SetQuadQuadSquaresEnable(true, self->channel);
          } else {
            self->device->device->SetQuadQuadFrameEnable(false, self->channel);
            self->device->device->SetQuadQuadSquaresEnable(false,
                                                           self->channel);
            self->device->device->Set4kSquaresEnable(true, self->channel);
            self->device->device->SetTsiFrameEnable(false, self->channel);
          }
          break;
        case GST_AJA_SDI_MODE_QUAD_LINK_TSI:
          if (self->configured_info.height > 2160) {
            self->device->device->Set4kSquaresEnable(false, self->channel);
            self->device->device->SetTsiFrameEnable(false, self->channel);
            self->device->device->SetQuadQuadFrameEnable(true, self->channel);
            self->device->device->SetQuadQuadSquaresEnable(false,
                                                           self->channel);
          } else {
            self->device->device->SetQuadQuadFrameEnable(false, self->channel);
            self->device->device->SetQuadQuadSquaresEnable(false,
                                                           self->channel);
            self->device->device->Set4kSquaresEnable(false, self->channel);
            self->device->device->SetTsiFrameEnable(true, self->channel);
          }
          break;
      }
    }
  } else if (had_quad_enabled || had_quad_quad_enabled) {
    NTV2Channel quad_channel;

    if (self->channel < ::NTV2_CHANNEL5)
      quad_channel = ::NTV2_CHANNEL1;
    else
      quad_channel = ::NTV2_CHANNEL5;

    self->device->device->Set4kSquaresEnable(false, quad_channel);
    self->device->device->SetTsiFrameEnable(false, quad_channel);
    self->device->device->SetQuadQuadFrameEnable(false, quad_channel);
    self->device->device->SetQuadQuadSquaresEnable(false, quad_channel);
  }

  self->device->device->SetMode(self->channel, NTV2_MODE_CAPTURE, false);
  if (self->quad_mode) {
    for (int i = 1; i < 4; i++)
      self->device->device->SetMode((NTV2Channel)(self->channel + i),
                                    NTV2_MODE_CAPTURE, false);
  }

  std::string configured_string = NTV2VideoFormatToString(self->video_format);
  GST_DEBUG_OBJECT(self, "Configuring video format %s (%d) on channel %d",
                   configured_string.c_str(), (int)self->video_format,
                   (int)self->channel);
  if (!self->device->device->SetVideoFormat(self->video_format, false, false,
                                            self->channel)) {
    GST_DEBUG_OBJECT(
        self, "Failed configuring video format %s (%d) on channel %d",
        configured_string.c_str(), (int)self->video_format, (int)self->channel);
    return FALSE;
  }

  if (!::NTV2DeviceCanDoFrameBufferFormat(self->device_id,
                                          ::NTV2_FBF_10BIT_YCBCR)) {
    GST_ERROR_OBJECT(self, "Device does not support frame buffer format %d",
                     (int)::NTV2_FBF_10BIT_YCBCR);
    return FALSE;
  }

  if (!self->device->device->SetFrameBufferFormat(self->channel,
                                                  ::NTV2_FBF_10BIT_YCBCR)) {
    GST_ERROR_OBJECT(self, "Failed configuring frame buffer format %d",
                     (int)::NTV2_FBF_10BIT_YCBCR);
    return FALSE;
  }

  // FIXME: Workaround for sometimes setting the video format not actually
  // changing the register values. Let's just try again.
  {
    NTV2VideoFormat fmt;
    self->device->device->GetVideoFormat(fmt, self->channel);

    if (fmt != self->video_format) {
      std::string actual_string = NTV2VideoFormatToString(fmt);

      GST_ERROR_OBJECT(self,
                       "Configured video format %s (%d) on channel %d but %s "
                       "(%d) is configured instead, trying again",
                       configured_string.c_str(), (int)self->video_format,
                       (int)self->channel, actual_string.c_str(), (int)fmt);
      self->video_format = ::NTV2_FORMAT_UNKNOWN;
      return TRUE;
    }
  }

  if (self->quad_mode) {
    for (int i = 1; i < 4; i++)
      self->device->device->SetFrameBufferFormat(
          (NTV2Channel)(self->channel + i), ::NTV2_FBF_10BIT_YCBCR);
  }

  self->device->device->DMABufferAutoLock(false, true, 0);

  if (::NTV2DeviceHasBiDirectionalSDI(self->device_id)) {
    self->device->device->SetSDITransmitEnable(self->channel, false);
    if (self->quad_mode) {
      for (int i = 1; i < 4; i++)
        self->device->device->SetSDITransmitEnable(
            (NTV2Channel)(self->channel + i), false);
    }
  }

  // Always use the framebuffer associated with the channel
  NTV2InputCrosspointID framebuffer_id =
      ::GetFrameBufferInputXptFromChannel(self->channel, false);

  const NTV2Standard standard(
      ::GetNTV2StandardFromVideoFormat(self->video_format));
  self->device->device->SetStandard(standard, self->channel);
  if (self->quad_mode) {
    for (int i = 1; i < 4; i++)
      self->device->device->SetStandard(standard,
                                        (NTV2Channel)(self->channel + i));
  }

  const NTV2FrameGeometry geometry =
      ::GetNTV2FrameGeometryFromVideoFormat(self->video_format);

  self->vanc_mode =
      ::HasVANCGeometries(geometry) ? vanc_mode : ::NTV2_VANCMODE_OFF;
  if (self->vanc_mode == ::NTV2_VANCMODE_OFF) {
    self->device->device->SetFrameGeometry(geometry, false, self->channel);

    if (self->quad_mode) {
      for (int i = 1; i < 4; i++) {
        self->device->device->SetFrameGeometry(
            geometry, false, (NTV2Channel)(self->channel + i));
      }
    }
  } else {
    const NTV2FrameGeometry vanc_geometry =
        ::GetVANCFrameGeometry(geometry, self->vanc_mode);

    self->device->device->SetFrameGeometry(vanc_geometry, false, self->channel);

    if (self->quad_mode) {
      for (int i = 1; i < 4; i++) {
        self->device->device->SetFrameGeometry(
            vanc_geometry, false, (NTV2Channel)(self->channel + i));
      }
    }
  }

  CNTV2SignalRouter router;

  // If any channels are currently running, initialize the router with the
  // existing routing setup. Otherwise overwrite the whole routing table.
  {
    bool have_channels_running = false;

    for (NTV2Channel c = ::NTV2_CHANNEL1; c < NTV2_MAX_NUM_CHANNELS;
         c = (NTV2Channel)(c + 1)) {
      AUTOCIRCULATE_STATUS ac_status;

      if (c == self->channel) continue;

      if (self->device->device->AutoCirculateGetStatus(c, ac_status) &&
          !ac_status.IsStopped()) {
        have_channels_running = true;
        break;
      }
    }

    if (have_channels_running) self->device->device->GetRouting(router);
  }

  // Need to remove old routes for the output and framebuffer we're going to
  // use
  NTV2ActualConnections connections = router.GetConnections();

  if (self->quad_mode) {
    if (self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
        self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4) {
      // Need to disconnect the 4 inputs corresponding to this channel from
      // their framebuffers/muxers, and muxers from their framebuffers
      for (auto iter = connections.begin(); iter != connections.end(); iter++) {
        if (iter->first == NTV2_XptFrameBuffer1Input ||
            iter->first == NTV2_XptFrameBuffer1DS2Input ||
            iter->first == NTV2_XptFrameBuffer2Input ||
            iter->first == NTV2_XptFrameBuffer2DS2Input ||
            iter->second == NTV2_Xpt425Mux1AYUV ||
            iter->second == NTV2_Xpt425Mux1BYUV ||
            iter->second == NTV2_Xpt425Mux2AYUV ||
            iter->second == NTV2_Xpt425Mux2BYUV ||
            iter->first == NTV2_Xpt425Mux1AInput ||
            iter->first == NTV2_Xpt425Mux1BInput ||
            iter->first == NTV2_Xpt425Mux2AInput ||
            iter->first == NTV2_Xpt425Mux2BInput ||
            iter->second == NTV2_XptHDMIIn1 ||
            iter->second == NTV2_XptHDMIIn1Q2 ||
            iter->second == NTV2_XptHDMIIn1Q3 ||
            iter->second == NTV2_XptHDMIIn1Q4)
          router.RemoveConnection(iter->first, iter->second);
      }
    } else if (self->channel == NTV2_CHANNEL1) {
      for (auto iter = connections.begin(); iter != connections.end(); iter++) {
        if (iter->first == NTV2_XptFrameBuffer1Input ||
            iter->first == NTV2_XptFrameBuffer1DS2Input ||
            iter->first == NTV2_XptFrameBuffer1DS2Input ||
            iter->first == NTV2_XptFrameBuffer2Input ||
            iter->first == NTV2_XptFrameBuffer2DS2Input ||
            iter->first == NTV2_XptFrameBuffer2DS2Input ||
            iter->second == NTV2_Xpt425Mux1AYUV ||
            iter->second == NTV2_Xpt425Mux1BYUV ||
            iter->second == NTV2_Xpt425Mux2AYUV ||
            iter->second == NTV2_Xpt425Mux2BYUV ||
            iter->first == NTV2_Xpt425Mux1AInput ||
            iter->first == NTV2_Xpt425Mux1BInput ||
            iter->first == NTV2_Xpt425Mux2AInput ||
            iter->first == NTV2_Xpt425Mux2BInput ||
            iter->second == NTV2_XptSDIIn1 || iter->second == NTV2_XptSDIIn2 ||
            iter->second == NTV2_XptSDIIn3 || iter->second == NTV2_XptSDIIn4 ||
            iter->second == NTV2_XptSDIIn1DS2 ||
            iter->second == NTV2_XptSDIIn2DS2 ||
            iter->first == NTV2_XptFrameBuffer1Input ||
            iter->first == NTV2_XptFrameBuffer2Input ||
            iter->first == NTV2_XptFrameBuffer3Input ||
            iter->first == NTV2_XptFrameBuffer4Input)
          router.RemoveConnection(iter->first, iter->second);
      }
    } else if (self->channel == NTV2_CHANNEL5) {
      for (auto iter = connections.begin(); iter != connections.end(); iter++) {
        if (iter->first == NTV2_XptFrameBuffer5Input ||
            iter->first == NTV2_XptFrameBuffer5DS2Input ||
            iter->first == NTV2_XptFrameBuffer5DS2Input ||
            iter->first == NTV2_XptFrameBuffer6Input ||
            iter->first == NTV2_XptFrameBuffer6DS2Input ||
            iter->first == NTV2_XptFrameBuffer6DS2Input ||
            iter->second == NTV2_Xpt425Mux3AYUV ||
            iter->second == NTV2_Xpt425Mux3BYUV ||
            iter->second == NTV2_Xpt425Mux4AYUV ||
            iter->second == NTV2_Xpt425Mux4BYUV ||
            iter->first == NTV2_Xpt425Mux3AInput ||
            iter->first == NTV2_Xpt425Mux3BInput ||
            iter->first == NTV2_Xpt425Mux4AInput ||
            iter->first == NTV2_Xpt425Mux4BInput ||
            iter->second == NTV2_XptSDIIn5 || iter->second == NTV2_XptSDIIn6 ||
            iter->second == NTV2_XptSDIIn7 || iter->second == NTV2_XptSDIIn8 ||
            iter->second == NTV2_XptSDIIn5DS2 ||
            iter->second == NTV2_XptSDIIn6DS2 ||
            iter->first == NTV2_XptFrameBuffer5Input ||
            iter->first == NTV2_XptFrameBuffer6Input ||
            iter->first == NTV2_XptFrameBuffer7Input ||
            iter->first == NTV2_XptFrameBuffer8Input)
          router.RemoveConnection(iter->first, iter->second);
      }
    } else {
      g_assert_not_reached();
    }
  } else {
    // This also removes all connections for any previous quad mode on the
    // corresponding channels.

    NTV2OutputCrosspointID quad_input_source_ids[10];

    if (input_source_id == NTV2_XptSDIIn1 ||
        input_source_id == NTV2_XptSDIIn2 ||
        input_source_id == NTV2_XptSDIIn3 ||
        input_source_id == NTV2_XptSDIIn4) {
      if (had_quad_enabled || had_quad_quad_enabled) {
        quad_input_source_ids[0] = NTV2_XptSDIIn1;
        quad_input_source_ids[1] = NTV2_XptSDIIn2;
        quad_input_source_ids[2] = NTV2_XptSDIIn3;
        quad_input_source_ids[3] = NTV2_XptSDIIn4;
        quad_input_source_ids[4] = NTV2_XptSDIIn1DS2;
        quad_input_source_ids[5] = NTV2_XptSDIIn2DS2;
        quad_input_source_ids[6] = NTV2_Xpt425Mux1AYUV;
        quad_input_source_ids[7] = NTV2_Xpt425Mux1BYUV;
        quad_input_source_ids[8] = NTV2_Xpt425Mux2AYUV;
        quad_input_source_ids[9] = NTV2_Xpt425Mux2BYUV;
      }
    } else if (input_source_id == NTV2_XptSDIIn5 ||
               input_source_id == NTV2_XptSDIIn6 ||
               input_source_id == NTV2_XptSDIIn7 ||
               input_source_id == NTV2_XptSDIIn8) {
      if (had_quad_enabled || had_quad_quad_enabled) {
        quad_input_source_ids[0] = NTV2_XptSDIIn5;
        quad_input_source_ids[1] = NTV2_XptSDIIn6;
        quad_input_source_ids[2] = NTV2_XptSDIIn7;
        quad_input_source_ids[3] = NTV2_XptSDIIn8;
        quad_input_source_ids[4] = NTV2_XptSDIIn5DS2;
        quad_input_source_ids[5] = NTV2_XptSDIIn6DS2;
        quad_input_source_ids[6] = NTV2_Xpt425Mux3AYUV;
        quad_input_source_ids[7] = NTV2_Xpt425Mux3BYUV;
        quad_input_source_ids[8] = NTV2_Xpt425Mux4AYUV;
        quad_input_source_ids[9] = NTV2_Xpt425Mux4BYUV;
      }
    } else {
      g_assert_not_reached();
    }

    for (auto iter = connections.begin(); iter != connections.end(); iter++) {
      if (had_quad_enabled || had_quad_quad_enabled) {
        for (auto quad_input_source_id : quad_input_source_ids) {
          if (iter->second == quad_input_source_id)
            router.RemoveConnection(iter->first, iter->second);
        }
      } else {
        if (iter->first == framebuffer_id || iter->second == input_source_id)
          router.RemoveConnection(iter->first, iter->second);
      }
    }
  }

  if (self->quad_mode) {
    if (self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
        self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4) {
      input_source_id = NTV2_Xpt425Mux1AYUV;
    } else if (self->sdi_mode == GST_AJA_SDI_MODE_QUAD_LINK_TSI &&
               !NTV2_IS_QUAD_QUAD_HFR_VIDEO_FORMAT(self->video_format) &&
               !NTV2_IS_QUAD_QUAD_FORMAT(self->video_format)) {
      if (self->channel == NTV2_CHANNEL1)
        input_source_id = NTV2_Xpt425Mux1AYUV;
      else if (self->channel == NTV2_CHANNEL5)
        input_source_id = NTV2_Xpt425Mux3AYUV;
      else
        g_assert_not_reached();
    }
  }

  GST_DEBUG_OBJECT(self, "Creating connection %d - %d", framebuffer_id,
                   input_source_id);
  router.AddConnection(framebuffer_id, input_source_id);

  if (self->quad_mode) {
    if (self->input_source >= GST_AJA_INPUT_SOURCE_HDMI1 &&
        self->input_source <= GST_AJA_INPUT_SOURCE_HDMI4) {
      router.AddConnection(NTV2_XptFrameBuffer1DS2Input, NTV2_Xpt425Mux1BYUV);
      router.AddConnection(NTV2_XptFrameBuffer2Input, NTV2_Xpt425Mux2AYUV);
      router.AddConnection(NTV2_XptFrameBuffer2DS2Input, NTV2_Xpt425Mux2BYUV);

      router.AddConnection(NTV2_Xpt425Mux1AInput, NTV2_XptHDMIIn1);
      router.AddConnection(NTV2_Xpt425Mux1BInput, NTV2_XptHDMIIn1Q2);
      router.AddConnection(NTV2_Xpt425Mux2AInput, NTV2_XptHDMIIn1Q3);
      router.AddConnection(NTV2_Xpt425Mux2BInput, NTV2_XptHDMIIn1Q4);
    } else {
      if (self->sdi_mode == GST_AJA_SDI_MODE_QUAD_LINK_TSI) {
        if (NTV2_IS_QUAD_QUAD_HFR_VIDEO_FORMAT(self->video_format)) {
          if (self->channel == NTV2_CHANNEL1) {
            router.AddConnection(NTV2_XptFrameBuffer1DS2Input, NTV2_XptSDIIn2);
            router.AddConnection(NTV2_XptFrameBuffer2Input, NTV2_XptSDIIn3);
            router.AddConnection(NTV2_XptFrameBuffer2DS2Input, NTV2_XptSDIIn4);
          } else if (self->channel == NTV2_CHANNEL5) {
            router.AddConnection(NTV2_XptFrameBuffer5DS2Input, NTV2_XptSDIIn6);
            router.AddConnection(NTV2_XptFrameBuffer5Input, NTV2_XptSDIIn7);
            router.AddConnection(NTV2_XptFrameBuffer6DS2Input, NTV2_XptSDIIn8);
          } else {
            g_assert_not_reached();
          }
        } else if (NTV2_IS_QUAD_QUAD_FORMAT(self->video_format)) {
          if (self->channel == NTV2_CHANNEL1) {
            router.AddConnection(NTV2_XptFrameBuffer1DS2Input,
                                 NTV2_XptSDIIn1DS2);
            router.AddConnection(NTV2_XptFrameBuffer2Input, NTV2_XptSDIIn2);
            router.AddConnection(NTV2_XptFrameBuffer2DS2Input,
                                 NTV2_XptSDIIn2DS2);
          } else if (self->channel == NTV2_CHANNEL5) {
            router.AddConnection(NTV2_XptFrameBuffer5DS2Input,
                                 NTV2_XptSDIIn5DS2);
            router.AddConnection(NTV2_XptFrameBuffer5Input, NTV2_XptSDIIn6);
            router.AddConnection(NTV2_XptFrameBuffer6DS2Input,
                                 NTV2_XptSDIIn6DS2);
          } else {
            g_assert_not_reached();
          }
          // FIXME: Need special handling of NTV2_IS_4K_HFR_VIDEO_FORMAT for
          // TSI?
        } else {
          if (self->channel == NTV2_CHANNEL1) {
            router.AddConnection(NTV2_XptFrameBuffer1DS2Input,
                                 NTV2_Xpt425Mux1BYUV);
            router.AddConnection(NTV2_XptFrameBuffer2Input,
                                 NTV2_Xpt425Mux2AYUV);
            router.AddConnection(NTV2_XptFrameBuffer2DS2Input,
                                 NTV2_Xpt425Mux2BYUV);

            router.AddConnection(NTV2_Xpt425Mux1AInput, NTV2_XptSDIIn1);
            router.AddConnection(NTV2_Xpt425Mux1BInput, NTV2_XptSDIIn2);
            router.AddConnection(NTV2_Xpt425Mux2AInput, NTV2_XptSDIIn3);
            router.AddConnection(NTV2_Xpt425Mux2BInput, NTV2_XptSDIIn4);
          } else if (self->channel == NTV2_CHANNEL5) {
            router.AddConnection(NTV2_XptFrameBuffer5DS2Input,
                                 NTV2_Xpt425Mux3BYUV);
            router.AddConnection(NTV2_XptFrameBuffer6Input,
                                 NTV2_Xpt425Mux4AYUV);
            router.AddConnection(NTV2_XptFrameBuffer6DS2Input,
                                 NTV2_Xpt425Mux4BYUV);

            router.AddConnection(NTV2_Xpt425Mux3AInput, NTV2_XptSDIIn5);
            router.AddConnection(NTV2_Xpt425Mux3BInput, NTV2_XptSDIIn6);
            router.AddConnection(NTV2_Xpt425Mux4AInput, NTV2_XptSDIIn7);
            router.AddConnection(NTV2_Xpt425Mux4BInput, NTV2_XptSDIIn8);
          } else {
            g_assert_not_reached();
          }
        }
      } else {
        if (self->channel == NTV2_CHANNEL1) {
          router.AddConnection(NTV2_XptFrameBuffer2Input, NTV2_XptSDIIn2);
          router.AddConnection(NTV2_XptFrameBuffer3Input, NTV2_XptSDIIn3);
          router.AddConnection(NTV2_XptFrameBuffer4Input, NTV2_XptSDIIn4);
        } else if (self->channel == NTV2_CHANNEL5) {
          router.AddConnection(NTV2_XptFrameBuffer6Input, NTV2_XptSDIIn6);
          router.AddConnection(NTV2_XptFrameBuffer7Input, NTV2_XptSDIIn7);
          router.AddConnection(NTV2_XptFrameBuffer8Input, NTV2_XptSDIIn8);
        } else {
          g_assert_not_reached();
        }
      }
    }
  }

  {
    std::stringstream os;
    CNTV2SignalRouter oldRouter;
    self->device->device->GetRouting(oldRouter);
    oldRouter.Print(os);
    GST_DEBUG_OBJECT(self, "Previous routing:\n%s", os.str().c_str());
  }
  self->device->device->ApplySignalRoute(router, true);
  {
    std::stringstream os;
    CNTV2SignalRouter currentRouter;
    self->device->device->GetRouting(currentRouter);
    currentRouter.Print(os);
    GST_DEBUG_OBJECT(self, "New routing:\n%s", os.str().c_str());
  }

  switch (self->audio_system_setting) {
    case GST_AJA_AUDIO_SYSTEM_1:
      self->audio_system = ::NTV2_AUDIOSYSTEM_1;
      break;
    case GST_AJA_AUDIO_SYSTEM_2:
      self->audio_system = ::NTV2_AUDIOSYSTEM_2;
      break;
    case GST_AJA_AUDIO_SYSTEM_3:
      self->audio_system = ::NTV2_AUDIOSYSTEM_3;
      break;
    case GST_AJA_AUDIO_SYSTEM_4:
      self->audio_system = ::NTV2_AUDIOSYSTEM_4;
      break;
    case GST_AJA_AUDIO_SYSTEM_5:
      self->audio_system = ::NTV2_AUDIOSYSTEM_5;
      break;
    case GST_AJA_AUDIO_SYSTEM_6:
      self->audio_system = ::NTV2_AUDIOSYSTEM_6;
      break;
    case GST_AJA_AUDIO_SYSTEM_7:
      self->audio_system = ::NTV2_AUDIOSYSTEM_7;
      break;
    case GST_AJA_AUDIO_SYSTEM_8:
      self->audio_system = ::NTV2_AUDIOSYSTEM_8;
      break;
    case GST_AJA_AUDIO_SYSTEM_AUTO:
      self->audio_system = ::NTV2_AUDIOSYSTEM_1;
      if (::NTV2DeviceGetNumAudioSystems(self->device_id) > 1)
        self->audio_system = ::NTV2ChannelToAudioSystem(self->channel);
      if (!::NTV2DeviceCanDoFrameStore1Display(self->device_id))
        self->audio_system = ::NTV2_AUDIOSYSTEM_1;
      break;
    default:
      g_assert_not_reached();
      break;
  }

  GST_DEBUG_OBJECT(self, "Using audio system %d", self->audio_system);

  NTV2AudioSource audio_source;
  switch (self->audio_source) {
    case GST_AJA_AUDIO_SOURCE_EMBEDDED:
      audio_source = ::NTV2_AUDIO_EMBEDDED;
      break;
    case GST_AJA_AUDIO_SOURCE_AES:
      audio_source = ::NTV2_AUDIO_AES;
      break;
    case GST_AJA_AUDIO_SOURCE_ANALOG:
      audio_source = ::NTV2_AUDIO_ANALOG;
      break;
    case GST_AJA_AUDIO_SOURCE_HDMI:
      audio_source = ::NTV2_AUDIO_HDMI;
      break;
    case GST_AJA_AUDIO_SOURCE_MIC:
      audio_source = ::NTV2_AUDIO_MIC;
      break;
    default:
      g_assert_not_reached();
      break;
  }

  NTV2EmbeddedAudioInput embedded_audio_input;
  switch (self->embedded_audio_input) {
    case GST_AJA_EMBEDDED_AUDIO_INPUT_AUTO:
      embedded_audio_input =
          ::NTV2InputSourceToEmbeddedAudioInput(input_source);
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO1:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_1;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO2:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_2;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO3:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_3;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO4:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_4;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO5:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_5;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO6:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_6;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO7:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_7;
      break;
    case GST_AJA_EMBEDDED_AUDIO_INPUT_VIDEO8:
      embedded_audio_input = ::NTV2_EMBEDDED_AUDIO_INPUT_VIDEO_8;
      break;
    default:
      g_assert_not_reached();
      break;
  }

  self->device->device->SetAudioSystemInputSource(
      self->audio_system, audio_source, embedded_audio_input);
  self->configured_audio_channels =
      ::NTV2DeviceGetMaxAudioChannels(self->device_id);
  self->device->device->SetNumberAudioChannels(self->configured_audio_channels,
                                               self->audio_system);
  self->device->device->SetAudioRate(::NTV2_AUDIO_48K, self->audio_system);
  self->device->device->SetAudioBufferSize(::NTV2_AUDIO_BUFFER_BIG,
                                           self->audio_system);
  self->device->device->SetAudioLoopBack(::NTV2_AUDIO_LOOPBACK_OFF,
                                         self->audio_system);
  self->device->device->SetEmbeddedAudioClock(
      ::NTV2_EMBEDDED_AUDIO_CLOCK_VIDEO_INPUT, self->audio_system);

  NTV2ReferenceSource reference_source;
  switch (self->reference_source) {
    case GST_AJA_REFERENCE_SOURCE_AUTO:
      reference_source = ::NTV2InputSourceToReferenceSource(input_source);
      break;
    case GST_AJA_REFERENCE_SOURCE_EXTERNAL:
      reference_source = ::NTV2_REFERENCE_EXTERNAL;
      break;
    case GST_AJA_REFERENCE_SOURCE_FREERUN:
      reference_source = ::NTV2_REFERENCE_FREERUN;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_1:
      reference_source = ::NTV2_REFERENCE_INPUT1;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_2:
      reference_source = ::NTV2_REFERENCE_INPUT2;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_3:
      reference_source = ::NTV2_REFERENCE_INPUT3;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_4:
      reference_source = ::NTV2_REFERENCE_INPUT4;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_5:
      reference_source = ::NTV2_REFERENCE_INPUT5;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_6:
      reference_source = ::NTV2_REFERENCE_INPUT6;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_7:
      reference_source = ::NTV2_REFERENCE_INPUT7;
      break;
    case GST_AJA_REFERENCE_SOURCE_INPUT_8:
      reference_source = ::NTV2_REFERENCE_INPUT8;
      break;
    default:
      g_assert_not_reached();
      break;
  }
  GST_DEBUG_OBJECT(self, "Configuring reference source %d",
                   (int)reference_source);

  self->device->device->SetReference(reference_source);
  self->device->device->SetLTCInputEnable(true);
  self->device->device->SetRP188SourceFilter(self->channel, 0xff);

  guint video_buffer_size = ::GetVideoActiveSize(
      self->video_format, ::NTV2_FBF_10BIT_YCBCR, self->vanc_mode);

  self->buffer_pool = gst_buffer_pool_new();
  GstStructure *config = gst_buffer_pool_get_config(self->buffer_pool);
  gst_buffer_pool_config_set_params(config, NULL, video_buffer_size,
                                    2 * self->queue_size, 0);
  gst_buffer_pool_config_set_allocator(config, self->allocator, NULL);
  gst_buffer_pool_set_config(self->buffer_pool, config);
  gst_buffer_pool_set_active(self->buffer_pool, TRUE);

  guint audio_buffer_size = 401 * 1024;

  self->audio_buffer_pool = gst_buffer_pool_new();
  config = gst_buffer_pool_get_config(self->audio_buffer_pool);
  gst_buffer_pool_config_set_params(config, NULL, audio_buffer_size,
                                    2 * self->queue_size, 0);
  gst_buffer_pool_config_set_allocator(config, self->allocator, NULL);
  gst_buffer_pool_set_config(self->audio_buffer_pool, config);
  gst_buffer_pool_set_active(self->audio_buffer_pool, TRUE);

  guint anc_buffer_size = 8 * 1024;

  if (self->vanc_mode == ::NTV2_VANCMODE_OFF &&
      ::NTV2DeviceCanDoCustomAnc(self->device_id)) {
    self->anc_buffer_pool = gst_buffer_pool_new();
    config = gst_buffer_pool_get_config(self->anc_buffer_pool);
    gst_buffer_pool_config_set_params(
        config, NULL, anc_buffer_size,
        (self->configured_info.interlace_mode ==
                 GST_VIDEO_INTERLACE_MODE_PROGRESSIVE
             ? 1
             : 2) *
            self->queue_size,
        0);
    gst_buffer_pool_config_set_allocator(config, self->allocator, NULL);
    gst_buffer_pool_set_config(self->anc_buffer_pool, config);
    gst_buffer_pool_set_active(self->anc_buffer_pool, TRUE);
  }

  gst_element_post_message(GST_ELEMENT_CAST(self),
                           gst_message_new_latency(GST_OBJECT_CAST(self)));

  return TRUE;
}

static gboolean gst_aja_src_start(GstAjaSrc *self) {
  GST_DEBUG_OBJECT(self, "Starting");

  self->video_format = NTV2_FORMAT_UNKNOWN;
  self->signal = FALSE;

  self->capture_thread = new AJAThread();
  self->capture_thread->Attach(capture_thread_func, self);
  self->capture_thread->SetPriority(AJA_ThreadPriority_High);
  self->capture_thread->Start();
  g_mutex_lock(&self->queue_lock);
  self->shutdown = FALSE;
  self->playing = FALSE;
  self->flushing = FALSE;
  g_cond_signal(&self->queue_cond);
  g_mutex_unlock(&self->queue_lock);

  return TRUE;
}

static gboolean gst_aja_src_stop(GstAjaSrc *self) {
  QueueItem *item;

  GST_DEBUG_OBJECT(self, "Stopping");

  g_mutex_lock(&self->queue_lock);
  self->shutdown = TRUE;
  self->flushing = TRUE;
  self->playing = FALSE;
  g_cond_signal(&self->queue_cond);
  g_mutex_unlock(&self->queue_lock);

  if (self->capture_thread) {
    self->capture_thread->Stop();
    delete self->capture_thread;
    self->capture_thread = NULL;
  }

  GST_OBJECT_LOCK(self);
  memset(&self->current_info, 0, sizeof(self->current_info));
  memset(&self->configured_info, 0, sizeof(self->configured_info));
  self->configured_audio_channels = 0;
  GST_OBJECT_UNLOCK(self);

  while ((item = (QueueItem *)gst_vec_deque_pop_head_struct(self->queue))) {
    queue_item_clear(item);
  }
  self->queue_num_frames = 0;

  if (self->buffer_pool) {
    gst_buffer_pool_set_active(self->buffer_pool, FALSE);
    gst_clear_object(&self->buffer_pool);
  }

  if (self->audio_buffer_pool) {
    gst_buffer_pool_set_active(self->audio_buffer_pool, FALSE);
    gst_clear_object(&self->audio_buffer_pool);
  }

  if (self->anc_buffer_pool) {
    gst_buffer_pool_set_active(self->anc_buffer_pool, FALSE);
    gst_clear_object(&self->anc_buffer_pool);
  }

  self->video_format = NTV2_FORMAT_UNKNOWN;

  if (self->signal) {
    self->signal = FALSE;
    g_object_notify(G_OBJECT(self), "signal");
  }

  GST_DEBUG_OBJECT(self, "Stopped");

  return TRUE;
}

static GstStateChangeReturn gst_aja_src_change_state(
    GstElement *element, GstStateChange transition) {
  GstAjaSrc *self = GST_AJA_SRC(element);
  GstStateChangeReturn ret;

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      if (!gst_aja_src_open(self)) return GST_STATE_CHANGE_FAILURE;
      break;
    case GST_STATE_CHANGE_READY_TO_PAUSED:
      if (!gst_aja_src_start(self)) return GST_STATE_CHANGE_FAILURE;
      break;
    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
      break;
    default:
      break;
  }

  ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition);
  if (ret == GST_STATE_CHANGE_FAILURE) return ret;

  switch (transition) {
    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
      g_mutex_lock(&self->queue_lock);
      self->playing = FALSE;
      g_cond_signal(&self->queue_cond);
      g_mutex_unlock(&self->queue_lock);
      break;
    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
      g_mutex_lock(&self->queue_lock);
      self->playing = TRUE;
      g_cond_signal(&self->queue_cond);
      g_mutex_unlock(&self->queue_lock);
      break;
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      if (!gst_aja_src_stop(self)) return GST_STATE_CHANGE_FAILURE;
      break;
    case GST_STATE_CHANGE_READY_TO_NULL:
      if (!gst_aja_src_close(self)) return GST_STATE_CHANGE_FAILURE;
      break;
    default:
      break;
  }

  return ret;
}

static GstClock *gst_aja_src_provide_clock(GstElement *element) {
  GstAjaSrc *self = GST_AJA_SRC(element);

  return GST_CLOCK(gst_object_ref(self->clock));
}

static GstCaps *gst_aja_src_get_caps(GstBaseSrc *bsrc, GstCaps *filter) {
  GstAjaSrc *self = GST_AJA_SRC(bsrc);
  GstCaps *caps;

  if (self->device) {
    caps = gst_ntv2_supported_caps(self->device_id);
  } else {
    caps = gst_pad_get_pad_template_caps(GST_BASE_SRC_PAD(self));
  }

  // Intersect with the configured video format if any to constrain the caps
  // further.
  if (self->video_format_setting != GST_AJA_VIDEO_FORMAT_AUTO) {
    GstCaps *configured_caps =
        gst_aja_video_format_to_caps(self->video_format_setting);

    if (configured_caps) {
      GstCaps *tmp;

      // Remove pixel-aspect-ratio from the configured caps to allow for both
      // widescreen and non-widescreen PAL/NTSC. It's added back by the
      // template caps above when intersecting.
      guint n = gst_caps_get_size(configured_caps);
      for (guint i = 0; i < n; i++) {
        GstStructure *s = gst_caps_get_structure(configured_caps, i);

        gst_structure_remove_fields(s, "pixel-aspect-ratio", NULL);
      }

      tmp = gst_caps_intersect(caps, configured_caps);
      gst_caps_unref(caps);
      gst_caps_unref(configured_caps);
      caps = tmp;
    }
  }

  if (filter) {
    GstCaps *tmp =
        gst_caps_intersect_full(filter, caps, GST_CAPS_INTERSECT_FIRST);
    gst_caps_unref(caps);
    caps = tmp;
  }

  return caps;
}

static gboolean gst_aja_src_query(GstBaseSrc *bsrc, GstQuery *query) {
  GstAjaSrc *self = GST_AJA_SRC(bsrc);
  gboolean ret = TRUE;

  switch (GST_QUERY_TYPE(query)) {
    case GST_QUERY_LATENCY: {
      if (self->current_info.finfo &&
          self->current_info.finfo->format != GST_VIDEO_FORMAT_UNKNOWN) {
        GstClockTime min, max;

        min = gst_util_uint64_scale_ceil(
            GST_SECOND, 3 * self->current_info.fps_d, self->current_info.fps_n);
        max = self->queue_size * min;

        gst_query_set_latency(query, TRUE, min, max);
        ret = TRUE;
      } else {
        ret = FALSE;
      }

      return ret;
    }

    default:
      return GST_BASE_SRC_CLASS(parent_class)->query(bsrc, query);
      break;
  }
}

static gboolean gst_aja_src_unlock(GstBaseSrc *bsrc) {
  GstAjaSrc *self = GST_AJA_SRC(bsrc);

  g_mutex_lock(&self->queue_lock);
  self->flushing = TRUE;
  g_cond_signal(&self->queue_cond);
  g_mutex_unlock(&self->queue_lock);

  return TRUE;
}

static gboolean gst_aja_src_unlock_stop(GstBaseSrc *bsrc) {
  GstAjaSrc *self = GST_AJA_SRC(bsrc);

  g_mutex_lock(&self->queue_lock);
  self->flushing = FALSE;
  g_mutex_unlock(&self->queue_lock);

  return TRUE;
}

static GstFlowReturn gst_aja_src_create(GstPushSrc *psrc, GstBuffer **buffer) {
  GstAjaSrc *self = GST_AJA_SRC(psrc);
  GstFlowReturn flow_ret = GST_FLOW_OK;
  QueueItem item = {
      .type = QUEUE_ITEM_TYPE_DUMMY,
  };

next_item:
  item.type = QUEUE_ITEM_TYPE_DUMMY;

  g_mutex_lock(&self->queue_lock);
  while (gst_vec_deque_is_empty(self->queue) && !self->flushing) {
    g_cond_wait(&self->queue_cond, &self->queue_lock);
  }

  if (self->flushing) {
    g_mutex_unlock(&self->queue_lock);
    GST_DEBUG_OBJECT(self, "Flushing");
    return GST_FLOW_FLUSHING;
  }

  item = *(QueueItem *)gst_vec_deque_pop_head_struct(self->queue);
  if (item.type == QUEUE_ITEM_TYPE_FRAME) {
    self->queue_num_frames -= 1;
  }
  g_mutex_unlock(&self->queue_lock);

  switch (item.type) {
    case QUEUE_ITEM_TYPE_DUMMY:
      queue_item_clear(&item);
      goto next_item;
    case QUEUE_ITEM_TYPE_SIGNAL_CHANGE:
      // These are already only produced when signal status is changing
      if (item.signal_change.have_signal) {
        GstAjaVideoFormat fmt = gst_aja_video_format_from_ntv2_format(
            item.signal_change.detected_format);
        gchar *format_str = g_enum_to_string(GST_TYPE_AJA_VIDEO_FORMAT, fmt);
        std::string format_string =
            NTV2VideoFormatToString(item.signal_change.detected_format);
        GST_ELEMENT_INFO_WITH_DETAILS(
            GST_ELEMENT(self), RESOURCE, READ, ("Signal recovered"),
            ("Input source detected"),
            ("detected-format", G_TYPE_STRING, format_string.c_str(),
             "gst-aja-format", G_TYPE_STRING, format_str, "vpid", G_TYPE_UINT,
             item.signal_change.vpid, NULL));
        self->signal = TRUE;
        g_object_notify(G_OBJECT(self), "signal");
        g_free(format_str);
      } else if (!item.signal_change.have_signal) {
        if (item.signal_change.detected_format != ::NTV2_FORMAT_UNKNOWN) {
          GstAjaVideoFormat fmt = gst_aja_video_format_from_ntv2_format(
              item.signal_change.detected_format);
          gchar *format_str = g_enum_to_string(GST_TYPE_AJA_VIDEO_FORMAT, fmt);
          std::string format_string =
              NTV2VideoFormatToString(item.signal_change.detected_format);
          GST_ELEMENT_WARNING_WITH_DETAILS(
              GST_ELEMENT(self), RESOURCE, READ, ("Signal lost"),
              ("Input source with different mode %s was detected", format_str),
              ("detected-format", G_TYPE_STRING, format_string.c_str(),
               "gst-aja-format", G_TYPE_STRING, format_str, "vpid", G_TYPE_UINT,
               item.signal_change.vpid, NULL));
          g_free(format_str);
        } else {
          GST_ELEMENT_WARNING(GST_ELEMENT(self), RESOURCE, READ,
                              ("Signal lost"),
                              ("No input source was detected"));
        }
        self->signal = FALSE;
        g_object_notify(G_OBJECT(self), "signal");
      }
      queue_item_clear(&item);
      goto next_item;
    case QUEUE_ITEM_TYPE_ERROR:
      GST_ERROR_OBJECT(self, "Stopping because of error on capture thread");
      gst_element_post_message(GST_ELEMENT(self),
                               (GstMessage *)g_steal_pointer(&item.error.msg));
      queue_item_clear(&item);
      return GST_FLOW_ERROR;
    case QUEUE_ITEM_TYPE_FRAMES_DROPPED:
      GST_WARNING_OBJECT(
          self, "Dropped frames from %" GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
          GST_TIME_ARGS(item.frames_dropped.timestamp_start),
          GST_TIME_ARGS(item.frames_dropped.timestamp_end));
      gst_element_post_message(
          GST_ELEMENT(self),
          gst_message_new_qos(GST_OBJECT_CAST(self), TRUE, GST_CLOCK_TIME_NONE,
                              GST_CLOCK_TIME_NONE,
                              item.frames_dropped.timestamp_start,
                              item.frames_dropped.timestamp_end -
                                  item.frames_dropped.timestamp_start));
      queue_item_clear(&item);
      goto next_item;
    case QUEUE_ITEM_TYPE_FRAME:
      // fall through below
      break;
  }

  g_assert(item.type == QUEUE_ITEM_TYPE_FRAME);

  if (!self->signal) {
    self->signal = TRUE;
    g_object_notify(G_OBJECT(self), "signal");
  }

  *buffer = (GstBuffer *)g_steal_pointer(&item.frame.video_buffer);
  gst_buffer_add_aja_audio_meta(*buffer, item.frame.audio_buffer);
  gst_clear_buffer(&item.frame.audio_buffer);

  if (item.frame.tc.IsValid()) {
    TimecodeFormat tc_format = ::kTCFormatUnknown;
    GstVideoTimeCodeFlags flags = GST_VIDEO_TIME_CODE_FLAGS_NONE;

    if (self->configured_info.fps_n == 24 && self->configured_info.fps_d == 1) {
      tc_format = kTCFormat24fps;
    } else if (self->configured_info.fps_n == 25 &&
               self->configured_info.fps_d == 1) {
      tc_format = kTCFormat25fps;
    } else if (self->configured_info.fps_n == 30 &&
               self->configured_info.fps_d == 1) {
      tc_format = kTCFormat30fps;
    } else if (self->configured_info.fps_n == 30000 &&
               self->configured_info.fps_d == 1001) {
      tc_format = kTCFormat30fpsDF;
      flags =
          (GstVideoTimeCodeFlags)(flags | GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME);
    } else if (self->configured_info.fps_n == 48 &&
               self->configured_info.fps_d == 1) {
      tc_format = kTCFormat48fps;
    } else if (self->configured_info.fps_n == 50 &&
               self->configured_info.fps_d == 1) {
      tc_format = kTCFormat50fps;
    } else if (self->configured_info.fps_n == 60 &&
               self->configured_info.fps_d == 1) {
      tc_format = kTCFormat60fps;
    } else if (self->configured_info.fps_n == 60000 &&
               self->configured_info.fps_d == 1001) {
      tc_format = kTCFormat60fpsDF;
      flags =
          (GstVideoTimeCodeFlags)(flags | GST_VIDEO_TIME_CODE_FLAGS_DROP_FRAME);
    }

    if (self->configured_info.interlace_mode !=
        GST_VIDEO_INTERLACE_MODE_PROGRESSIVE)
      flags =
          (GstVideoTimeCodeFlags)(flags | GST_VIDEO_TIME_CODE_FLAGS_INTERLACED);

    CRP188 rp188(item.frame.tc, tc_format);

    {
      std::stringstream os;
      os << rp188;
      GST_TRACE_OBJECT(self, "Adding timecode %s", os.str().c_str());
    }

    guint hours, minutes, seconds, frames;
    rp188.GetRP188Hrs(hours);
    rp188.GetRP188Mins(minutes);
    rp188.GetRP188Secs(seconds);
    rp188.GetRP188Frms(frames);

    GstVideoTimeCode tc;
    gst_video_time_code_init(&tc, self->configured_info.fps_n,
                             self->configured_info.fps_d, NULL, flags, hours,
                             minutes, seconds, frames, 0);
    gst_buffer_add_video_time_code_meta(*buffer, &tc);
  }

  AJAAncillaryList anc_packets;

  if (item.frame.anc_buffer) {
    GstMapInfo map = GST_MAP_INFO_INIT;
    GstMapInfo map2 = GST_MAP_INFO_INIT;

    gst_buffer_map(item.frame.anc_buffer, &map, GST_MAP_READ);
    if (item.frame.anc_buffer2)
      gst_buffer_map(item.frame.anc_buffer2, &map2, GST_MAP_READ);

    NTV2_POINTER ptr1(map.data, map.size);
    NTV2_POINTER ptr2(map2.data, map2.size);

    AJAAncillaryList::SetFromDeviceAncBuffers(ptr1, ptr2, anc_packets);

    if (item.frame.anc_buffer2) gst_buffer_unmap(item.frame.anc_buffer2, &map2);
    gst_buffer_unmap(item.frame.anc_buffer, &map);
  } else if (self->vanc_mode != ::NTV2_VANCMODE_OFF) {
    GstMapInfo map;

    NTV2FormatDescriptor format_desc(self->video_format, ::NTV2_FBF_10BIT_YCBCR,
                                     self->vanc_mode);

    gst_buffer_map(*buffer, &map, GST_MAP_READ);
    NTV2_POINTER ptr(map.data, map.size);
    AJAAncillaryList::SetFromVANCData(ptr, format_desc, anc_packets);
    gst_buffer_unmap(*buffer, &map);

    guint offset =
        format_desc.RasterLineToByteOffset(format_desc.GetFirstActiveLine());
    guint size = format_desc.GetVisibleRasterBytes();

    gst_buffer_resize(*buffer, offset, size);
  }

  gst_clear_buffer(&item.frame.anc_buffer);
  gst_clear_buffer(&item.frame.anc_buffer2);

  // Not using CountAncillaryDataWithType(AJAAncillaryDataType_Cea708) etc
  // here because for SD it doesn't recognize the packets. It assumes they
  // would only be received on AJAAncillaryDataChannel_Y but for SD it is
  // actually AJAAncillaryDataChannel_Both.
  //
  // See AJA SDK support ticket #4844.
  guint32 n_vanc_packets = anc_packets.CountAncillaryData();

  // Check if we have either CEA608 or CEA708 packets, or both.
  bool have_cea608 = false;
  bool have_cea708 = false;
  for (guint32 i = 0; i < n_vanc_packets; i++) {
    AJAAncillaryData *packet = anc_packets.GetAncillaryDataAtIndex(i);

    if (packet->GetDID() == AJAAncillaryData_Cea608_Vanc_DID &&
        packet->GetSID() == AJAAncillaryData_Cea608_Vanc_SID &&
        packet->GetPayloadData() && packet->GetPayloadByteCount() &&
        AJA_SUCCESS(packet->ParsePayloadData())) {
      GST_TRACE_OBJECT(
          self, "Found CEA608 VANC of %" G_GSIZE_FORMAT " bytes at line %u",
          packet->GetPayloadByteCount(), packet->GetLocationLineNumber());
      have_cea608 = true;
    } else if (packet->GetDID() == AJAAncillaryData_CEA708_DID &&
               packet->GetSID() == AJAAncillaryData_CEA708_SID &&
               packet->GetPayloadData() && packet->GetPayloadByteCount() &&
               AJA_SUCCESS(packet->ParsePayloadData())) {
      GST_TRACE_OBJECT(
          self, "Found CEA708 CDP VANC of %" G_GSIZE_FORMAT " bytes at line %u",
          packet->GetPayloadByteCount(), packet->GetLocationLineNumber());
      have_cea708 = true;
    }
  }

  // Decide based on the closed-caption-capture-mode property and closed
  // caption availability which ones to add as metadata to the output buffer.
  bool want_cea608 =
      have_cea608 &&
      (self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_AND_CEA608 ||
       self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA608_OR_CEA708 ||
       self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA608_ONLY ||
       (!have_cea708 &&
        self->closed_caption_capture_mode ==
            GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_OR_CEA608));

  bool want_cea708 =
      have_cea708 &&
      (self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_AND_CEA608 ||
       self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_OR_CEA608 ||
       self->closed_caption_capture_mode ==
           GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA708_ONLY ||
       (!have_cea608 &&
        self->closed_caption_capture_mode ==
            GST_AJA_CLOSED_CAPTION_CAPTURE_MODE_CEA608_OR_CEA708));

  bool aspect_ratio_flag = false;
  bool have_afd_bar = false;
  for (guint32 i = 0; i < n_vanc_packets; i++) {
    AJAAncillaryData *packet = anc_packets.GetAncillaryDataAtIndex(i);

    if (want_cea608 && packet->GetDID() == AJAAncillaryData_Cea608_Vanc_DID &&
        packet->GetSID() == AJAAncillaryData_Cea608_Vanc_SID &&
        packet->GetPayloadData() && packet->GetPayloadByteCount() &&
        AJA_SUCCESS(packet->ParsePayloadData())) {
      GST_TRACE_OBJECT(
          self, "Adding CEA608 VANC of %" G_GSIZE_FORMAT " bytes at line %u",
          packet->GetPayloadByteCount(), packet->GetLocationLineNumber());
      gst_buffer_add_video_caption_meta(
          *buffer, GST_VIDEO_CAPTION_TYPE_CEA608_S334_1A,
          packet->GetPayloadData(), packet->GetPayloadByteCount());
    } else if (want_cea708 && packet->GetDID() == AJAAncillaryData_CEA708_DID &&
               packet->GetSID() == AJAAncillaryData_CEA708_SID &&
               packet->GetPayloadData() && packet->GetPayloadByteCount() &&
               AJA_SUCCESS(packet->ParsePayloadData())) {
      GST_TRACE_OBJECT(
          self,
          "Adding CEA708 CDP VANC of %" G_GSIZE_FORMAT " bytes at line %u",
          packet->GetPayloadByteCount(), packet->GetLocationLineNumber());
      gst_buffer_add_video_caption_meta(
          *buffer, GST_VIDEO_CAPTION_TYPE_CEA708_CDP, packet->GetPayloadData(),
          packet->GetPayloadByteCount());
    } else if (packet->GetDID() == 0x41 && packet->GetSID() == 0x05 &&
               packet->GetPayloadData() && packet->GetPayloadByteCount() == 8) {
      const guint8 *data = packet->GetPayloadData();

      have_afd_bar = true;
      aspect_ratio_flag = (data[0] >> 2) & 0x1;

      GstVideoAFDValue afd = (GstVideoAFDValue)((data[0] >> 3) & 0xf);
      gboolean is_letterbox = ((data[3] >> 4) & 0x3) == 0;
      guint16 bar1 = GST_READ_UINT16_BE(&data[4]);
      guint16 bar2 = GST_READ_UINT16_BE(&data[6]);

      GST_TRACE_OBJECT(self,
                       "Found AFD/Bar VANC at line %u: AR %u, AFD %u, "
                       "letterbox %u, bar1 %u, bar2 %u",
                       packet->GetLocationLineNumber(), aspect_ratio_flag, afd,
                       is_letterbox, bar1, bar2);

      const NTV2Standard standard(
          ::GetNTV2StandardFromVideoFormat(item.frame.detected_format));
      const NTV2SmpteLineNumber smpte_line_num_info =
          ::GetSmpteLineNumber(standard);
      bool field2 =
          packet->GetLocationLineNumber() >
          smpte_line_num_info.GetLastLine(
              smpte_line_num_info.firstFieldTop ? NTV2_FIELD0 : NTV2_FIELD1);

      gst_buffer_add_video_afd_meta(*buffer, field2 ? 1 : 0,
                                    GST_VIDEO_AFD_SPEC_SMPTE_ST2016_1, afd);
      gst_buffer_add_video_bar_meta(*buffer, field2 ? 1 : 0, is_letterbox, bar1,
                                    bar2);
    }

    // Don't attach other ANC as ancillary meta if not requested to do so.
    if (!self->attach_ancillary_meta) continue;

    // Skip non-SMPTE 291M ancillary data
    if (packet->GetDataCoding() != AJAAncillaryDataCoding_Digital) continue;

    const guint8 *in_data = packet->GetPayloadData();
    guint data_count = packet->GetDC();

    guint16 line_number = packet->GetLocationLineNumber();
    guint16 horiz_offset = packet->GetLocationHorizOffset();

    if (!in_data || data_count == 0) {
      GST_TRACE_OBJECT(self, "ANC %s (%04x) at (%u,%u) has no payload data",
                       packet->IDAsString().c_str(), packet->GetDIDSID(),
                       line_number, horiz_offset);
      continue;
    }

    GST_TRACE_OBJECT(self,
                     "Adding ANC meta for %s (%04x) at (%u,%u) of size %u",
                     packet->IDAsString().c_str(), packet->GetDIDSID(),
                     line_number, horiz_offset, data_count);
    GstAncillaryMeta *anc_meta = gst_buffer_add_ancillary_meta(*buffer);

    anc_meta->c_not_y_channel = packet->IsChromaChannel();
    anc_meta->line = line_number;
    anc_meta->offset = horiz_offset;

    packet->GeneratePayloadData();
    anc_meta->DID = AJAAncillaryData::AddEvenParity(packet->GetDID());
    anc_meta->SDID_block_number =
        AJAAncillaryData::AddEvenParity(packet->GetSID());

    anc_meta->data_count = AJAAncillaryData::AddEvenParity(data_count);

    guint16 *data = g_new(guint16, packet->GetDC());
    for (guint i = 0; i < data_count; i++) {
      data[i] = AJAAncillaryData::AddEvenParity(in_data[i]);
    }
    anc_meta->data = data;

    anc_meta->checksum = packet->Calculate9BitChecksum();
  }

  bool caps_changed = false;

  CNTV2VPID vpid(item.frame.vpid);
  if (vpid.IsValid()) {
    GstVideoInfo info;

    {
      std::stringstream os;
      vpid.Print(os);
      GST_TRACE_OBJECT(self, "Got valid VPID %s", os.str().c_str());
    }

    if (gst_video_info_from_ntv2_video_format(&info,
                                              item.frame.detected_format)) {
      switch (vpid.GetTransferCharacteristics()) {
        default:
        case NTV2_VPID_TC_SDR_TV:
          if (info.height < 720) {
            info.colorimetry.transfer = GST_VIDEO_TRANSFER_BT601;
          } else {
            info.colorimetry.transfer = GST_VIDEO_TRANSFER_BT709;
          }
          break;
        case NTV2_VPID_TC_HLG:
          info.colorimetry.transfer = GST_VIDEO_TRANSFER_ARIB_STD_B67;
          break;
        case NTV2_VPID_TC_PQ:
          info.colorimetry.transfer = GST_VIDEO_TRANSFER_SMPTE2084;
          break;
      }

      switch (vpid.GetColorimetry()) {
        case NTV2_VPID_Color_Rec709:
          info.colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT709;
          info.colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT709;
          break;
        case NTV2_VPID_Color_UHDTV:
          info.colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT2020;
          info.colorimetry.primaries = GST_VIDEO_COLOR_PRIMARIES_BT2020;
          break;
        default:
          // Default handling
          break;
      }

      switch (vpid.GetRGBRange()) {
        case NTV2_VPID_Range_Full:
          info.colorimetry.range = GST_VIDEO_COLOR_RANGE_0_255;
          break;
        case NTV2_VPID_Range_Narrow:
          info.colorimetry.range = GST_VIDEO_COLOR_RANGE_16_235;
          break;
      }

      if (!have_afd_bar && vpid.GetImageAspect16x9()) aspect_ratio_flag = true;

      // Widescreen PAL/NTSC
      if (aspect_ratio_flag && info.height == 486) {
        info.par_n = 40;
        info.par_d = 33;
      } else if (aspect_ratio_flag && info.height == 576) {
        info.par_n = 16;
        info.par_d = 11;
      }

      if (!gst_pad_has_current_caps(GST_BASE_SRC_PAD(self)) ||
          !gst_video_info_is_equal(&info, &self->current_info)) {
        self->current_info = info;
        caps_changed = true;
      }
    }
  } else {
    GstVideoInfo info;

    if (gst_video_info_from_ntv2_video_format(&info,
                                              item.frame.detected_format)) {
      // Widescreen PAL/NTSC
      if (aspect_ratio_flag && info.height == 486) {
        info.par_n = 40;
        info.par_d = 33;
      } else if (aspect_ratio_flag && info.height == 576) {
        info.par_n = 16;
        info.par_d = 11;
      }

      if (!gst_pad_has_current_caps(GST_BASE_SRC_PAD(self)) ||
          !gst_video_info_is_equal(&info, &self->current_info)) {
        self->current_info = info;
        caps_changed = true;
      }
    } else if (!gst_pad_has_current_caps(GST_BASE_SRC_PAD(self))) {
      self->current_info = self->configured_info;

      // Widescreen PAL/NTSC
      if (aspect_ratio_flag && self->current_info.height == 486) {
        self->current_info.par_n = 40;
        self->current_info.par_d = 33;
      } else if (aspect_ratio_flag && self->current_info.height == 576) {
        self->current_info.par_n = 16;
        self->current_info.par_d = 11;
      }

      caps_changed = true;
    }
  }

  if (caps_changed) {
    GstCaps *caps = gst_video_info_to_caps(&self->current_info);
    gst_caps_set_simple(caps, "audio-channels", G_TYPE_INT,
                        self->configured_audio_channels, NULL);
    GST_DEBUG_OBJECT(self, "Configuring caps %" GST_PTR_FORMAT, caps);
    gst_base_src_set_caps(GST_BASE_SRC_CAST(self), caps);
    gst_caps_unref(caps);
  }

  if (self->configured_info.interlace_mode !=
      GST_VIDEO_INTERLACE_MODE_PROGRESSIVE) {
    GST_BUFFER_FLAG_SET(*buffer, GST_VIDEO_BUFFER_FLAG_INTERLACED);
    switch (GST_VIDEO_INFO_FIELD_ORDER(&self->configured_info)) {
      case GST_VIDEO_FIELD_ORDER_TOP_FIELD_FIRST:
        GST_BUFFER_FLAG_SET(*buffer, GST_VIDEO_BUFFER_FLAG_TFF);
      default:
        break;
    }
  }

  queue_item_clear(&item);

  GST_TRACE_OBJECT(self, "Outputting buffer %" GST_PTR_FORMAT, *buffer);

  return flow_ret;
}

#define AJA_SRC_ERROR(el, domain, code, text, debug)                        \
  G_STMT_START {                                                            \
    gchar *__txt = _gst_element_error_printf text;                          \
    gchar *__dbg = _gst_element_error_printf debug;                         \
    GstMessage *__msg;                                                      \
    GError *__err;                                                          \
    gchar *__name, *__fmt_dbg;                                              \
    if (__txt) GST_WARNING_OBJECT(el, "error: %s", __txt);                  \
    if (__dbg) GST_WARNING_OBJECT(el, "error: %s", __dbg);                  \
    if (!__txt)                                                             \
      __txt = gst_error_get_message(GST_##domain##_ERROR,                   \
                                    GST_##domain##_ERROR_##code);           \
    __err = g_error_new_literal(GST_##domain##_ERROR,                       \
                                GST_##domain##_ERROR_##code, __txt);        \
    __name = gst_object_get_path_string(GST_OBJECT_CAST(el));               \
    if (__dbg)                                                              \
      __fmt_dbg = g_strdup_printf("%s(%d): %s (): %s:\n%s", __FILE__,       \
                                  __LINE__, GST_FUNCTION, __name, __dbg);   \
    else                                                                    \
      __fmt_dbg = g_strdup_printf("%s(%d): %s (): %s", __FILE__, __LINE__,  \
                                  GST_FUNCTION, __name);                    \
    g_free(__name);                                                         \
    g_free(__dbg);                                                          \
    __msg = gst_message_new_error(GST_OBJECT(el), __err, __fmt_dbg);        \
    QueueItem item = {.type = QUEUE_ITEM_TYPE_ERROR, .error{.msg = __msg}}; \
    gst_vec_deque_push_tail_struct(el->queue, &item);                       \
    g_cond_signal(&el->queue_cond);                                         \
  }                                                                         \
  G_STMT_END;

static void capture_thread_func(AJAThread *thread, void *data) {
  GstAjaSrc *self = GST_AJA_SRC(data);
  GstClock *clock = NULL;
  GstClock *real_time_clock;
  AUTOCIRCULATE_TRANSFER transfer;
  NTV2VideoFormat last_detected_video_format = ::NTV2_FORMAT_UNKNOWN;

  if (self->capture_cpu_core != G_MAXUINT) {
    cpu_set_t mask;
    pthread_t current_thread = pthread_self();

    CPU_ZERO(&mask);
    CPU_SET(self->capture_cpu_core, &mask);

    if (pthread_setaffinity_np(current_thread, sizeof(mask), &mask) != 0) {
      GST_ERROR_OBJECT(self,
                       "Failed to set affinity for current thread to core %u",
                       self->capture_cpu_core);
    }
  }

  // We're getting a system clock for the real-time clock here because
  // g_get_real_time() is less accurate generally.
  real_time_clock = GST_CLOCK(g_object_new(GST_TYPE_SYSTEM_CLOCK, "clock-type",
                                           GST_CLOCK_TYPE_REALTIME, NULL));

  // if we currently have signal
  bool have_signal = true;
  // if the *next* output frame should have the discont flag set
  bool discont = true;
  // if the pipeline clock is the monotonic system clock
  bool clock_is_monotonic_system_clock = false;
  // if the next frame is the first one after autocirculate was started
  bool first_frame_after_start = true;
  // acFrameTime of the last captured frame. Used to detect
  // if a frame is actually missing or the signal changed
  GstClockTime last_frame_time = GST_CLOCK_TIME_NONE;
  // Base time of the first frame after a clock observation reset
  // Internal frame time is calculated from this and the number of frames
  // captured so far.
  GstClockTime first_frame_time = GST_CLOCK_TIME_NONE;
  guint64 num_frames = 0;
  // Number of frames to drop. After signal loss the first few frames
  // often have invalid acFrameTime so we drop them to calculate valid
  // timestamps afterwards
  guint frames_to_drop = 0;
  // Number of vsync iterations without a captured frame. If this becomes too
  // high we assume signal loss.
  guint iterations_without_frame = 0;

  g_mutex_lock(&self->queue_lock);
restart:
  GST_DEBUG_OBJECT(self, "Waiting for playing or shutdown");
  while (!self->playing && !self->shutdown)
    g_cond_wait(&self->queue_cond, &self->queue_lock);
  if (self->shutdown) {
    GST_DEBUG_OBJECT(self, "Shutting down");
    goto out;
  }

  GST_DEBUG_OBJECT(self, "Starting capture");
  g_mutex_unlock(&self->queue_lock);

  gst_clear_object(&clock);
  clock = gst_element_get_clock(GST_ELEMENT_CAST(self));

  clock_is_monotonic_system_clock = false;
  if (G_OBJECT_TYPE(clock) == GST_TYPE_SYSTEM_CLOCK) {
    GstClock *system_clock = gst_system_clock_obtain();

    if (clock == system_clock) {
      GstClockType clock_type;
      g_object_get(clock, "clock-type", &clock_type, NULL);
      clock_is_monotonic_system_clock = clock_type == GST_CLOCK_TYPE_MONOTONIC;
    }
    gst_clear_object(&system_clock);
  }

  // Reset all local state after restart
  have_signal = true;
  discont = true;
  first_frame_after_start = true;
  last_frame_time = GST_CLOCK_TIME_NONE;
  first_frame_time = GST_CLOCK_TIME_NONE;
  num_frames = 0;
  frames_to_drop = 0;
  iterations_without_frame = 0;

  g_mutex_lock(&self->queue_lock);
  self->video_format = ::NTV2_FORMAT_UNKNOWN;

  while (self->playing && !self->shutdown) {
    // If we don't have a video format configured, configure the device now
    // and potentially auto-detect the video format
    if (self->video_format == NTV2_FORMAT_UNKNOWN) {
      // Don't keep queue locked while configuring as this might take a while
      g_mutex_unlock(&self->queue_lock);

      // Make sure to globally lock here as the routing settings and others are
      // global shared state
      GstAjaNtv2DeviceLocker locker(self->device);

      if (!gst_aja_src_configure(self)) {
        g_mutex_lock(&self->queue_lock);
        AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                      ("Failed to configure device"));
        goto out;
      }
      g_mutex_lock(&self->queue_lock);

      if (!self->playing || self->shutdown) goto restart;

      if (self->video_format == ::NTV2_FORMAT_UNKNOWN) {
        GST_DEBUG_OBJECT(self, "No signal, waiting");
        if (have_signal) {
          QueueItem item = {
              .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
              .signal_change = {.have_signal = FALSE,
                                .detected_format = ::NTV2_FORMAT_UNKNOWN,
                                .vpid = 0}};
          gst_vec_deque_push_tail_struct(self->queue, &item);
          g_cond_signal(&self->queue_cond);
          have_signal = false;
        }
        self->device->device->WaitForInputVerticalInterrupt(self->channel);
        continue;
      }

      guint16 start_frame = self->start_frame;
      guint16 end_frame = self->end_frame;

      // If both are set to the same value, try to find that many unallocated
      // frames and use those.
      if (start_frame == end_frame) {
        gint assigned_start_frame = gst_aja_ntv2_device_find_unallocated_frames(
            self->device, self->channel, self->start_frame);

        if (assigned_start_frame == -1) {
          AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                        ("Failed to allocate %u frames", start_frame));
          goto out;
        }

        start_frame = assigned_start_frame;
        end_frame = start_frame + self->start_frame - 1;
      }

      GST_DEBUG_OBJECT(
          self, "Configuring channel %u with start frame %u and end frame %u",
          self->channel, start_frame, end_frame);

      if (!self->device->device->AutoCirculateInitForInput(
              self->channel, 0, self->audio_system,
              (self->rp188 ? AUTOCIRCULATE_WITH_RP188 : 0) |
                  (self->vanc_mode == ::NTV2_VANCMODE_OFF
                       ? AUTOCIRCULATE_WITH_ANC
                       : 0),
              1, start_frame, end_frame)) {
        AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                      ("Failed to initialize autocirculate"));
        goto out;
      }

      self->device->device->AutoCirculateStart(self->channel);
      first_frame_after_start = true;
    }

    // Check for valid signal first
    NTV2VideoFormat current_video_format =
        self->device->device->GetInputVideoFormat(
            self->configured_input_source);

    bool all_quads_equal = true;
    if (self->quad_mode) {
      for (int i = 1; i < 4; i++) {
        NTV2VideoFormat other_video_format =
            self->device->device->GetInputVideoFormat(
                (NTV2InputSource)(self->configured_input_source + i));
        if (other_video_format != current_video_format) {
          std::string current_string =
              NTV2VideoFormatToString(current_video_format);
          std::string other_string =
              NTV2VideoFormatToString(other_video_format);
          GST_DEBUG_OBJECT(
              self,
              "Not all quadrants had the same format in "
              "quad-link-mode: %s (%d) on input 1 vs. %s (%d) on input %d",
              current_string.c_str(), current_video_format,
              other_string.c_str(), other_video_format, i + 1);
          all_quads_equal = false;
          break;
        }
      }
    }

    ULWord vpid_a = 0;
    ULWord vpid_b = 0;
    self->device->device->ReadSDIInVPID(self->channel, vpid_a, vpid_b);

    {
      std::string current_string =
          NTV2VideoFormatToString(current_video_format);
      GST_TRACE_OBJECT(
          self, "Detected input video format %s (%d) with VPID %08x / %08x",
          current_string.c_str(), (int)current_video_format, vpid_a, vpid_b);
    }

    NTV2VideoFormat effective_video_format = self->video_format;
    // Can't call this unconditionally as it also maps e.g. 3840x2160p to 1080p
    if (self->quad_mode) {
      effective_video_format =
          ::GetQuarterSizedVideoFormat(effective_video_format);
    }
    switch (self->video_format) {
      case NTV2_FORMAT_1080psf_2500_2:
        if (current_video_format == NTV2_FORMAT_1080i_5000)
          current_video_format = NTV2_FORMAT_1080psf_2500_2;
        break;
      case NTV2_FORMAT_1080psf_2997_2:
        if (current_video_format == NTV2_FORMAT_1080i_5994)
          current_video_format = NTV2_FORMAT_1080psf_2997_2;
        break;
      case NTV2_FORMAT_1080psf_3000_2:
        if (current_video_format == NTV2_FORMAT_1080i_6000)
          current_video_format = NTV2_FORMAT_1080psf_3000_2;
        break;
      default:
        break;
    }

    if (current_video_format == ::NTV2_FORMAT_UNKNOWN || !all_quads_equal) {
      if (self->video_format_setting == GST_AJA_VIDEO_FORMAT_AUTO)
        self->video_format = NTV2_FORMAT_UNKNOWN;

      GST_DEBUG_OBJECT(self, "No signal, waiting");
      g_mutex_unlock(&self->queue_lock);
      if (have_signal || current_video_format != last_detected_video_format) {
        QueueItem item = {
            .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
            .signal_change = {.have_signal = FALSE,
                              .detected_format = ::NTV2_FORMAT_UNKNOWN,
                              .vpid = 0}};
        last_detected_video_format = ::NTV2_FORMAT_UNKNOWN;
        gst_vec_deque_push_tail_struct(self->queue, &item);
        g_cond_signal(&self->queue_cond);
        have_signal = false;
      }
      self->device->device->WaitForInputVerticalInterrupt(self->channel);
      g_mutex_lock(&self->queue_lock);
      continue;
    } else if (current_video_format != effective_video_format &&
               current_video_format != self->video_format) {
      // Try reconfiguring with the newly detected video format
      if (self->video_format_setting == GST_AJA_VIDEO_FORMAT_AUTO) {
        self->video_format = NTV2_FORMAT_UNKNOWN;
        continue;
      }

      std::string current_string =
          NTV2VideoFormatToString(current_video_format);
      std::string configured_string =
          NTV2VideoFormatToString(self->video_format);
      std::string effective_string =
          NTV2VideoFormatToString(effective_video_format);

      GST_DEBUG_OBJECT(self,
                       "Different input format %s than configured %s "
                       "(effective %s), waiting",
                       current_string.c_str(), configured_string.c_str(),
                       effective_string.c_str());
      g_mutex_unlock(&self->queue_lock);
      if (have_signal || current_video_format != last_detected_video_format) {
        QueueItem item = {
            .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
            .signal_change = {.have_signal = FALSE,
                              .detected_format = current_video_format,
                              .vpid = vpid_a}};
        last_detected_video_format = current_video_format;
        gst_vec_deque_push_tail_struct(self->queue, &item);
        g_cond_signal(&self->queue_cond);
        have_signal = false;
      }
      self->device->device->WaitForInputVerticalInterrupt(self->channel);
      g_mutex_lock(&self->queue_lock);
      continue;
    } else if (have_signal &&
               current_video_format != last_detected_video_format) {
      QueueItem item = {
          .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
          .signal_change = {.have_signal = TRUE,
                            .detected_format = current_video_format,
                            .vpid = vpid_a}};
      last_detected_video_format = current_video_format;
      gst_vec_deque_push_tail_struct(self->queue, &item);
      g_cond_signal(&self->queue_cond);
    }

    AUTOCIRCULATE_STATUS status;

    self->device->device->AutoCirculateGetStatus(self->channel, status);

    GST_TRACE_OBJECT(
        self,
        "State %d "
        "start frame %d "
        "end frame %d "
        "active frame %d "
        "start time %" GST_TIME_FORMAT
        " "
        "current time %" GST_TIME_FORMAT
        " "
        "frames processed %u "
        "frames dropped %u "
        "buffer level %u",
        status.acState, status.acStartFrame, status.acEndFrame,
        status.acActiveFrame, GST_TIME_ARGS(status.acRDTSCStartTime * 100),
        GST_TIME_ARGS(status.acRDTSCCurrentTime * 100),
        status.acFramesProcessed, status.acFramesDropped, status.acBufferLevel);

    if (status.IsRunning() && status.HasAvailableInputFrame()) {
      GstBuffer *video_buffer = NULL;
      GstBuffer *audio_buffer = NULL;
      GstBuffer *anc_buffer = NULL, *anc_buffer2 = NULL;
      GstMapInfo video_map = GST_MAP_INFO_INIT;
      GstMapInfo audio_map = GST_MAP_INFO_INIT;
      GstMapInfo anc_map = GST_MAP_INFO_INIT;
      GstMapInfo anc_map2 = GST_MAP_INFO_INIT;
      AUTOCIRCULATE_TRANSFER transfer;

      if (!have_signal) {
        QueueItem item = {
            .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
            .signal_change = {.have_signal = TRUE,
                              .detected_format = current_video_format,
                              .vpid = vpid_a}};
        gst_vec_deque_push_tail_struct(self->queue, &item);
        g_cond_signal(&self->queue_cond);
        have_signal = true;
        last_frame_time = GST_CLOCK_TIME_NONE;

        // Drop the next frames after signal recovery as the capture times
        // are generally just wrong.
        frames_to_drop = MAX(status.acBufferLevel + 1, 5);
        GST_TRACE_OBJECT(self, "Dropping %u frames after signal recovery",
                         frames_to_drop);
      }

      iterations_without_frame = 0;

      if (gst_buffer_pool_acquire_buffer(self->buffer_pool, &video_buffer,
                                         NULL) != GST_FLOW_OK) {
        AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                      ("Failed to acquire video buffer"));
        break;
      }

      if (gst_buffer_pool_acquire_buffer(self->audio_buffer_pool, &audio_buffer,
                                         NULL) != GST_FLOW_OK) {
        gst_buffer_unref(video_buffer);
        AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                      ("Failed to acquire audio buffer"));
        break;
      }

      if (self->vanc_mode == ::NTV2_VANCMODE_OFF &&
          ::NTV2DeviceCanDoCustomAnc(self->device_id)) {
        if (gst_buffer_pool_acquire_buffer(self->anc_buffer_pool, &anc_buffer,
                                           NULL) != GST_FLOW_OK) {
          gst_buffer_unref(audio_buffer);
          gst_buffer_unref(video_buffer);
          AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                        ("Failed to acquire anc buffer"));
          break;
        }

        if (self->configured_info.interlace_mode !=
            GST_VIDEO_INTERLACE_MODE_PROGRESSIVE) {
          if (gst_buffer_pool_acquire_buffer(
                  self->anc_buffer_pool, &anc_buffer2, NULL) != GST_FLOW_OK) {
            gst_buffer_unref(anc_buffer);
            gst_buffer_unref(audio_buffer);
            gst_buffer_unref(video_buffer);
            AJA_SRC_ERROR(self, STREAM, FAILED, (NULL),
                          ("Failed to acquire anc buffer"));
            break;
          }
        }
      }

      gst_buffer_map(video_buffer, &video_map, GST_MAP_READWRITE);
      gst_buffer_map(audio_buffer, &audio_map, GST_MAP_READWRITE);
      if (anc_buffer) gst_buffer_map(anc_buffer, &anc_map, GST_MAP_READWRITE);
      if (anc_buffer2)
        gst_buffer_map(anc_buffer2, &anc_map2, GST_MAP_READWRITE);

      transfer.acFrameBufferFormat = ::NTV2_FBF_10BIT_YCBCR;

      transfer.SetVideoBuffer((ULWord *)video_map.data, video_map.size);
      transfer.SetAudioBuffer((ULWord *)audio_map.data, audio_map.size);
      transfer.SetAncBuffers((ULWord *)anc_map.data, anc_map.size,
                             (ULWord *)anc_map2.data, anc_map2.size);

      g_mutex_unlock(&self->queue_lock);

      bool transfered = true;
      if (!self->device->device->AutoCirculateTransfer(self->channel,
                                                       transfer)) {
        GST_WARNING_OBJECT(self, "Failed to transfer frame");
        transfered = false;
      }

      if (anc_buffer2) gst_buffer_unmap(anc_buffer2, &anc_map2);
      if (anc_buffer) gst_buffer_unmap(anc_buffer, &anc_map);
      gst_buffer_unmap(audio_buffer, &audio_map);
      gst_buffer_unmap(video_buffer, &video_map);

      g_mutex_lock(&self->queue_lock);

      if (!transfered) {
        gst_clear_buffer(&anc_buffer2);
        gst_clear_buffer(&anc_buffer);
        gst_clear_buffer(&audio_buffer);
        gst_clear_buffer(&video_buffer);
        continue;
      }

      const AUTOCIRCULATE_TRANSFER_STATUS &transfer_status =
          transfer.GetTransferStatus();
      const FRAME_STAMP &frame_stamp = transfer_status.GetFrameStamp();

      GST_TRACE_OBJECT(self,
                       "State %d "
                       "transfer frame %d "
                       "current frame %u "
                       "frame time %" GST_TIME_FORMAT
                       " "
                       "current frame time %" GST_TIME_FORMAT
                       " "
                       "current time %" GST_TIME_FORMAT
                       " "
                       "frames processed %u "
                       "frames dropped %u "
                       "buffer level %u",
                       transfer_status.acState, transfer_status.acTransferFrame,
                       frame_stamp.acCurrentFrame,
                       GST_TIME_ARGS(frame_stamp.acFrameTime * 100),
                       GST_TIME_ARGS(frame_stamp.acCurrentFrameTime * 100),
                       GST_TIME_ARGS(frame_stamp.acCurrentTime * 100),
                       transfer_status.acFramesProcessed,
                       transfer_status.acFramesDropped,
                       transfer_status.acBufferLevel);

      if (frames_to_drop > 0) {
        GST_TRACE_OBJECT(self, "Dropping frame");
        frames_to_drop -= 1;
        gst_clear_buffer(&anc_buffer2);
        gst_clear_buffer(&anc_buffer);
        gst_clear_buffer(&audio_buffer);
        gst_clear_buffer(&video_buffer);
        continue;
      }

      GstClockTime frame_time_real = frame_stamp.acFrameTime * 100;

      // Convert capture time from real-time clock to monotonic clock by
      // sampling both and working with the difference. The monotonic clock is
      // used for all further calculations because it is more reliable.
      GstClockTime now_real_sys = gst_clock_get_time(real_time_clock);
      GstClockTime now_monotonic_sys = gst_clock_get_internal_time(self->clock);
      GstClockTime now_gst = gst_clock_get_time(clock);

      GstClockTime frame_time_monotonic;
      if (now_real_sys > now_monotonic_sys) {
        GstClockTime diff = now_real_sys - now_monotonic_sys;

        if (frame_time_real > diff)
          frame_time_monotonic = frame_time_real - diff;
        else
          frame_time_monotonic = 0;
      } else {
        GstClockTime diff = now_monotonic_sys - now_real_sys;

        frame_time_monotonic = frame_time_real + diff;
      }

      // Detect frame drop: backwards capture time is clearly a problem,
      // otherwise consider a frame being dropped if more than 1.75 frame
      // durations are between two frames
      if (last_frame_time != GST_CLOCK_TIME_NONE) {
        GstClockTime frame_drop_threshold =
            (7 * self->configured_info.fps_d * GST_SECOND) /
            (4 * self->configured_info.fps_n);
        if (last_frame_time >= frame_time_monotonic) {
          GST_ERROR_OBJECT(self, "Frame capture time went backwards");
          last_frame_time = GST_CLOCK_TIME_NONE;
        } else if (frame_time_monotonic - last_frame_time >
                   frame_drop_threshold) {
          GstClockTime timestamp =
              last_frame_time + self->configured_info.fps_d * GST_SECOND /
                                    self->configured_info.fps_n;
          GstClockTime timestamp_end = frame_time_monotonic;

          GST_WARNING_OBJECT(self,
                             "Frame drop of %" GST_TIME_FORMAT " detected",
                             GST_TIME_ARGS(timestamp_end - timestamp));

          QueueItem item = {.type = QUEUE_ITEM_TYPE_FRAMES_DROPPED,
                            .frames_dropped = {.driver_side = TRUE,
                                               .timestamp_start = timestamp,
                                               .timestamp_end = timestamp_end}};
          gst_vec_deque_push_tail_struct(self->queue, &item);
          g_cond_signal(&self->queue_cond);

          last_frame_time = GST_CLOCK_TIME_NONE;
        } else {
          GST_TRACE_OBJECT(
              self, "Time since last frame: %" GST_TIME_FORMAT,
              GST_TIME_ARGS(frame_time_monotonic - last_frame_time));
        }
      }

      GstClockTime frame_src_time;

      // Update clock mapping
      if (first_frame_after_start || last_frame_time == GST_CLOCK_TIME_NONE) {
        GstClockTime internal, external;
        guint64 num, denom;

        // Keep observations if there was only temporary signal loss as the
        // source is either using the same clock as before, or it's different
        // but then our previous configuration would be as good/bad as the
        // local monotonic system clock and over some frames we would converge
        // to the new clock.
        if (first_frame_after_start) {
          // FIXME: Workaround to get rid of all previous observations
          g_object_set(self->clock, "window-size", 32, NULL);
        }

        // Use the monotonic frame time converted back to our clock as base.
        // In the beginning this would be equal to the monotonic clock, at
        // later times this is needed to avoid jumps (possibly backwards!) of
        // the clock time when the framerate changes.
        //
        // We manually adjust with the calibration here because otherwise the
        // clock will clamp it to the last returned clock time, which most
        // likely is in the future.
        gst_clock_get_calibration(self->clock, &internal, &external, &num,
                                  &denom);
        first_frame_time = frame_src_time = gst_clock_adjust_with_calibration(
            NULL, frame_time_monotonic, internal, external, num, denom);

        GST_TRACE_OBJECT(
            self, "Initializing clock with first frame time %" GST_TIME_FORMAT,
            GST_TIME_ARGS(first_frame_time));

        first_frame_after_start = false;
        discont = TRUE;
        num_frames = 0;
      } else {
        gdouble r_squared;

        frame_src_time =
            first_frame_time +
            gst_util_uint64_scale_ceil(num_frames,
                                       self->configured_info.fps_d * GST_SECOND,
                                       self->configured_info.fps_n);

        gst_clock_add_observation(self->clock, frame_time_monotonic,
                                  frame_src_time, &r_squared);
      }

      last_frame_time = frame_time_monotonic;
      num_frames += 1;

      GstClockTime capture_time;
      if (self->clock == clock) {
        // If the pipeline is using our clock then we can directly use the
        // frame counter based time as capture time.
        capture_time = frame_src_time;
      } else {
        GstClockTime internal, external;
        guint64 num, denom;

        // Otherwise convert the frame counter based time to the monotonic
        // clock via our clock, which should give a smoother time than just
        // the raw capture time.
        //
        // We manually adjust with the calibration here because otherwise the
        // clock will clamp it to the last returned clock time, which most
        // likely is in the future.
        gst_clock_get_calibration(self->clock, &internal, &external, &num,
                                  &denom);
        GstClockTime capture_time_monotonic =
            gst_clock_unadjust_with_calibration(NULL, frame_src_time, internal,
                                                external, num, denom);

        if (clock_is_monotonic_system_clock) {
          // If the pipeline is using the monotonic system clock then we can
          // just use this.
          GST_OBJECT_LOCK(clock);
          capture_time = capture_time_monotonic;
          GST_OBJECT_UNLOCK(clock);
        } else {
          // If the pipeline clock is neither the monotonic clock nor the system
          // clock we calculate the difference between the monotonic clock and
          // the pipeline clock and work with that.

          if (now_monotonic_sys > now_gst) {
            GstClockTime diff = now_monotonic_sys - now_gst;

            if (capture_time_monotonic > diff)
              capture_time = capture_time_monotonic - diff;
            else
              capture_time = 0;
          } else {
            GstClockTime diff = now_gst - now_monotonic_sys;

            capture_time = capture_time_monotonic + diff;
          }
        }
      }

      GstClockTime base_time = GST_ELEMENT_CAST(self)->base_time;
      GstClockTime pts = GST_CLOCK_TIME_NONE;
      if (capture_time != GST_CLOCK_TIME_NONE) {
        if (capture_time > base_time)
          pts = capture_time - base_time;
        else
          pts = 0;
      }

      GST_BUFFER_PTS(video_buffer) = pts;
      GST_BUFFER_DURATION(video_buffer) = gst_util_uint64_scale(
          GST_SECOND, self->configured_info.fps_d, self->configured_info.fps_n);
      GST_BUFFER_PTS(audio_buffer) = pts;
      GST_BUFFER_DURATION(audio_buffer) = gst_util_uint64_scale(
          GST_SECOND, self->configured_info.fps_d, self->configured_info.fps_n);

      gst_buffer_set_size(audio_buffer, transfer.GetCapturedAudioByteCount());
      if (anc_buffer)
        gst_buffer_set_size(anc_buffer,
                            transfer.GetCapturedAncByteCount(false));
      if (anc_buffer2)
        gst_buffer_set_size(anc_buffer2,
                            transfer.GetCapturedAncByteCount(true));

      NTV2TCIndex tc_index;
      switch (self->timecode_index) {
        case GST_AJA_TIMECODE_INDEX_VITC:
          tc_index = ::NTV2InputSourceToTimecodeIndex(
              self->configured_input_source, true);
          break;
        case GST_AJA_TIMECODE_INDEX_ATC_LTC:
          tc_index = ::NTV2InputSourceToTimecodeIndex(
              self->configured_input_source, false);
          break;
        case GST_AJA_TIMECODE_INDEX_LTC1:
          tc_index = ::NTV2_TCINDEX_LTC1;
          break;
        case GST_AJA_TIMECODE_INDEX_LTC2:
          tc_index = ::NTV2_TCINDEX_LTC2;
          break;
        default:
          g_assert_not_reached();
          break;
      }

      NTV2_RP188 time_code;
      frame_stamp.GetInputTimeCode(time_code, tc_index);

      while (self->queue_num_frames >= self->queue_size) {
        guint n = gst_vec_deque_get_length(self->queue);

        for (guint i = 0; i < n; i++) {
          QueueItem *tmp =
              (QueueItem *)gst_vec_deque_peek_nth_struct(self->queue, i);
          if (tmp->type == QUEUE_ITEM_TYPE_FRAME) {
            GST_WARNING_OBJECT(self,
                               "Element queue overrun, dropping old frame");

            QueueItem item = {
                .type = QUEUE_ITEM_TYPE_FRAMES_DROPPED,
                .frames_dropped = {
                    .driver_side = FALSE,
                    .timestamp_start = tmp->frame.capture_time,
                    .timestamp_end =
                        tmp->frame.capture_time +
                        gst_util_uint64_scale(GST_SECOND,
                                              self->configured_info.fps_d,
                                              self->configured_info.fps_n)}};
            queue_item_clear(tmp);
            gst_vec_deque_drop_struct(self->queue, i, NULL);
            gst_vec_deque_push_tail_struct(self->queue, &item);
            self->queue_num_frames -= 1;
            discont = true;
            g_cond_signal(&self->queue_cond);
            break;
          }
        }
      }

      if (discont) {
        GST_BUFFER_FLAG_SET(video_buffer, GST_BUFFER_FLAG_DISCONT);
        GST_BUFFER_FLAG_SET(audio_buffer, GST_BUFFER_FLAG_DISCONT);
        discont = false;
      }

      QueueItem item = {
          .type = QUEUE_ITEM_TYPE_FRAME,
          .frame = {.capture_time = capture_time,
                    .video_buffer = video_buffer,
                    .audio_buffer = audio_buffer,
                    .anc_buffer = anc_buffer,
                    .anc_buffer2 = anc_buffer2,
                    .tc = time_code,
                    .detected_format =
                        (self->quad_mode
                             ? ::GetQuadSizedVideoFormat(current_video_format)
                             : current_video_format),
                    .vpid = vpid_a}};

      GST_TRACE_OBJECT(self, "Queuing frame %" GST_TIME_FORMAT,
                       GST_TIME_ARGS(capture_time));
      gst_vec_deque_push_tail_struct(self->queue, &item);
      self->queue_num_frames += 1;
      GST_TRACE_OBJECT(self, "%u frames queued", self->queue_num_frames);
      g_cond_signal(&self->queue_cond);
    } else {
      g_mutex_unlock(&self->queue_lock);

      // If we don't have a frame for 32 iterations (512ms) then consider
      // this as signal loss too even if the driver still reports the
      // expected mode above
      if (have_signal && iterations_without_frame < 32) {
        iterations_without_frame++;
      } else {
        if (have_signal || last_detected_video_format != current_video_format) {
          QueueItem item = {
              .type = QUEUE_ITEM_TYPE_SIGNAL_CHANGE,
              .signal_change = {.have_signal = TRUE,
                                .detected_format = current_video_format,
                                .vpid = vpid_a}};
          last_detected_video_format = current_video_format;
          gst_vec_deque_push_tail_struct(self->queue, &item);
          g_cond_signal(&self->queue_cond);
          have_signal = false;
        }
      }

      self->device->device->WaitForInputVerticalInterrupt(self->channel);

      g_mutex_lock(&self->queue_lock);
    }
  }

out: {
  // Make sure to globally lock here as the routing settings and others are
  // global shared state
  GstAjaNtv2DeviceLocker locker(self->device);

  self->device->device->AutoCirculateStop(self->channel);
  self->device->device->UnsubscribeInputVerticalEvent(self->channel);
  self->device->device->DisableInputInterrupt(self->channel);

  self->device->device->DisableChannel(self->channel);
  if (self->quad_mode) {
    for (int i = 1; i < 4; i++) {
      self->device->device->DisableChannel((NTV2Channel)(self->channel + i));
    }
  }
}

  if (!self->playing && !self->shutdown) goto restart;
  g_mutex_unlock(&self->queue_lock);

  gst_clear_object(&clock);
  gst_clear_object(&real_time_clock);

  GST_DEBUG_OBJECT(self, "Stopped");
}