mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-15 04:46:32 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/aja/gstajasink.cpp
Sebastian Dröge 0ef396359c gst: Move GstQueueArray as GstVecDeque to core 
And change lengths and indices from guint to gsize for a more correct type.

Also deprecate GstQueueArray and implement it in terms of GstVecDeque.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6779>
2024-05-06 18:25:42 +00:00

2266 lines
83 KiB
C++
Raw Blame History

/* 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) output cards.
*
* ## Example usage
*
* Output a 1080p2997 test audio/video stream
*
* ```sh
* gst-launch-1.0 videotestsrc pattern=ball ! video/x-raw,format=v210,width=1920,height=1080,framerate=30000/1001,interlace-mode=progressive ! timeoverlay ! timecodestamper ! combiner.video \
* audiotestsrc freq=440 ! audio/x-raw,format=S32LE,rate=48000,channels=16 ! audiobuffersplit output-buffer-duration=1/30 ! combiner.audio \
* ajasinkcombiner name=combiner ! ajasink channel=0
* ```
*
* 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 "gstajacommon.h"
#include "gstajasink.h"
GST_DEBUG_CATEGORY_STATIC(gst_aja_sink_debug);
#define GST_CAT_DEFAULT gst_aja_sink_debug
#define DEFAULT_DEVICE_IDENTIFIER ("0")
#define DEFAULT_CHANNEL (::NTV2_CHANNEL1)
#define DEFAULT_AUDIO_SYSTEM (GST_AJA_AUDIO_SYSTEM_AUTO)
#define DEFAULT_OUTPUT_DESTINATION (GST_AJA_OUTPUT_DESTINATION_AUTO)
#define DEFAULT_SDI_MODE (GST_AJA_SDI_MODE_SINGLE_LINK)
#define DEFAULT_TIMECODE_INDEX (GST_AJA_TIMECODE_INDEX_VITC)
#define DEFAULT_RP188 (TRUE)
#define DEFAULT_REFERENCE_SOURCE (GST_AJA_REFERENCE_SOURCE_AUTO)
#define DEFAULT_CEA608_LINE_NUMBER (12)
#define DEFAULT_CEA708_LINE_NUMBER (12)
#define DEFAULT_QUEUE_SIZE (16)
#define DEFAULT_START_FRAME (0)
#define DEFAULT_END_FRAME (0)
#define DEFAULT_OUTPUT_CPU_CORE (G_MAXUINT)
#define DEFAULT_HANDLE_ANCILLARY_META (FALSE)
enum {
PROP_0,
PROP_DEVICE_IDENTIFIER,
PROP_CHANNEL,
PROP_AUDIO_SYSTEM,
PROP_OUTPUT_DESTINATION,
PROP_SDI_MODE,
PROP_TIMECODE_INDEX,
PROP_RP188,
PROP_REFERENCE_SOURCE,
PROP_CEA608_LINE_NUMBER,
PROP_CEA708_LINE_NUMBER,
PROP_QUEUE_SIZE,
PROP_START_FRAME,
PROP_END_FRAME,
PROP_OUTPUT_CPU_CORE,
PROP_HANDLE_ANCILLARY_META,
};
typedef enum {
QUEUE_ITEM_TYPE_FRAME,
} QueueItemType;
typedef struct {
QueueItemType type;
// For FRAME
GstBuffer *video_buffer;
GstMapInfo video_map;
GstBuffer *audio_buffer;
GstMapInfo audio_map;
NTV2_RP188 tc;
GstBuffer *anc_buffer;
GstMapInfo anc_map;
GstBuffer *anc_buffer2;
GstMapInfo anc_map2;
} QueueItem;
static void gst_aja_sink_set_property(GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec);
static void gst_aja_sink_get_property(GObject *object, guint property_id,
GValue *value, GParamSpec *pspec);
static void gst_aja_sink_finalize(GObject *object);
static gboolean gst_aja_sink_set_caps(GstBaseSink *bsink, GstCaps *caps);
static GstCaps *gst_aja_sink_get_caps(GstBaseSink *bsink, GstCaps *filter);
static gboolean gst_aja_sink_event(GstBaseSink *bsink, GstEvent *event);
static gboolean gst_aja_sink_propose_allocation(GstBaseSink *bsink,
GstQuery *query);
static GstFlowReturn gst_aja_sink_render(GstBaseSink *bsink, GstBuffer *buffer);
static gboolean gst_aja_sink_open(GstAjaSink *sink);
static gboolean gst_aja_sink_close(GstAjaSink *sink);
static gboolean gst_aja_sink_start(GstAjaSink *sink);
static gboolean gst_aja_sink_stop(GstAjaSink *sink);
static GstStateChangeReturn gst_aja_sink_change_state(
GstElement *element, GstStateChange transition);
static void output_thread_func(AJAThread *thread, void *data);
#define parent_class gst_aja_sink_parent_class
G_DEFINE_TYPE(GstAjaSink, gst_aja_sink, GST_TYPE_BASE_SINK);
static void gst_aja_sink_class_init(GstAjaSinkClass *klass) {
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
GstElementClass *element_class = GST_ELEMENT_CLASS(klass);
GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS(klass);
GstCaps *templ_caps;
gobject_class->set_property = gst_aja_sink_set_property;
gobject_class->get_property = gst_aja_sink_get_property;
gobject_class->finalize = gst_aja_sink_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_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 output (auto 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 output (auto 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_OUTPUT_DESTINATION,
g_param_spec_enum(
"output-destination", "Output Destination",
"Output destination to use", GST_TYPE_AJA_OUTPUT_DESTINATION,
DEFAULT_OUTPUT_DESTINATION,
(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-mode", "SDI Mode", "SDI 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_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 transmission", 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_CEA608_LINE_NUMBER,
g_param_spec_uint(
"cea608-line-number", "CEA608 Line Number",
"Sets the line number to use for CEA608 S334-1 Annex A Closed "
"Captions "
"(-1=disabled)",
0, G_MAXUINT, DEFAULT_CEA608_LINE_NUMBER,
(GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT)));
g_object_class_install_property(
gobject_class, PROP_CEA708_LINE_NUMBER,
g_param_spec_uint(
"cea708-line-number", "CEA708 Line Number",
"Sets the line number to use for CEA708 S334-2 Closed Captions "
"(-1=disabled)",
0, G_MAXUINT, DEFAULT_CEA608_LINE_NUMBER,
(GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT)));
g_object_class_install_property(
gobject_class, PROP_OUTPUT_CPU_CORE,
g_param_spec_uint(
"output-cpu-core", "Output CPU Core",
"Sets the affinity of the output thread to this CPU core "
"(-1=disabled)",
0, G_MAXUINT, DEFAULT_OUTPUT_CPU_CORE,
(GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT)));
/**
* GstAjaSink:handle-ancillary-meta:
*
* If set to %TRUE handle any #GstAncillaryMeta present on buffers
*
* Since: 1.24
*/
g_object_class_install_property(
gobject_class, PROP_HANDLE_ANCILLARY_META,
g_param_spec_boolean(
"handle-ancillary-meta", "Handle Ancillary Meta",
"Handle ancillary meta on video frames",
DEFAULT_HANDLE_ANCILLARY_META,
(GParamFlags)(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT)));
element_class->change_state = GST_DEBUG_FUNCPTR(gst_aja_sink_change_state);
basesink_class->set_caps = GST_DEBUG_FUNCPTR(gst_aja_sink_set_caps);
basesink_class->get_caps = GST_DEBUG_FUNCPTR(gst_aja_sink_get_caps);
basesink_class->event = GST_DEBUG_FUNCPTR(gst_aja_sink_event);
basesink_class->propose_allocation =
GST_DEBUG_FUNCPTR(gst_aja_sink_propose_allocation);
basesink_class->render = GST_DEBUG_FUNCPTR(gst_aja_sink_render);
templ_caps = gst_ntv2_supported_caps(DEVICE_ID_INVALID);
gst_element_class_add_pad_template(
element_class,
gst_pad_template_new("sink", GST_PAD_SINK, GST_PAD_ALWAYS, templ_caps));
gst_caps_unref(templ_caps);
gst_element_class_set_static_metadata(
element_class, "AJA audio/video sink", "Audio/Video/Sink",
"Outputs audio/video frames with AJA devices",
"Sebastian Dröge <sebastian@centricular.com>");
GST_DEBUG_CATEGORY_INIT(gst_aja_sink_debug, "ajasink", 0, "AJA sink");
}
static void gst_aja_sink_init(GstAjaSink *self) {
g_mutex_init(&self->queue_lock);
g_cond_init(&self->queue_cond);
g_cond_init(&self->drain_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->audio_system_setting = DEFAULT_AUDIO_SYSTEM;
self->output_destination = DEFAULT_OUTPUT_DESTINATION;
self->timecode_index = DEFAULT_TIMECODE_INDEX;
self->reference_source = DEFAULT_REFERENCE_SOURCE;
self->output_cpu_core = DEFAULT_OUTPUT_CPU_CORE;
self->handle_ancillary_meta = DEFAULT_HANDLE_ANCILLARY_META;
self->queue =
gst_vec_deque_new_for_struct(sizeof(QueueItem), self->queue_size);
}
void gst_aja_sink_set_property(GObject *object, guint property_id,
const GValue *value, GParamSpec *pspec) {
GstAjaSink *self = GST_AJA_SINK(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_AUDIO_SYSTEM:
self->audio_system_setting = (GstAjaAudioSystem)g_value_get_enum(value);
break;
case PROP_OUTPUT_DESTINATION:
self->output_destination =
(GstAjaOutputDestination)g_value_get_enum(value);
break;
case PROP_SDI_MODE:
self->sdi_mode = (GstAjaSdiMode)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_CEA608_LINE_NUMBER:
self->cea608_line_number = g_value_get_uint(value);
break;
case PROP_CEA708_LINE_NUMBER:
self->cea708_line_number = g_value_get_uint(value);
break;
case PROP_OUTPUT_CPU_CORE:
self->output_cpu_core = g_value_get_uint(value);
break;
case PROP_HANDLE_ANCILLARY_META:
self->handle_ancillary_meta = g_value_get_boolean(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
void gst_aja_sink_get_property(GObject *object, guint property_id,
GValue *value, GParamSpec *pspec) {
GstAjaSink *self = GST_AJA_SINK(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_AUDIO_SYSTEM:
g_value_set_enum(value, self->audio_system_setting);
break;
case PROP_OUTPUT_DESTINATION:
g_value_set_enum(value, self->output_destination);
break;
case PROP_SDI_MODE:
g_value_set_enum(value, self->sdi_mode);
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_CEA608_LINE_NUMBER:
g_value_set_uint(value, self->cea608_line_number);
break;
case PROP_CEA708_LINE_NUMBER:
g_value_set_uint(value, self->cea708_line_number);
break;
case PROP_OUTPUT_CPU_CORE:
g_value_set_uint(value, self->output_cpu_core);
break;
case PROP_HANDLE_ANCILLARY_META:
g_value_set_boolean(value, self->handle_ancillary_meta);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
void gst_aja_sink_finalize(GObject *object) {
GstAjaSink *self = GST_AJA_SINK(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);
g_mutex_clear(&self->queue_lock);
g_cond_clear(&self->queue_cond);
g_cond_clear(&self->drain_cond);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
static gboolean gst_aja_sink_open(GstAjaSink *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_sink_close(GstAjaSink *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;
}
static gboolean gst_aja_sink_start(GstAjaSink *self) {
GST_DEBUG_OBJECT(self, "Starting");
self->output_thread = new AJAThread();
self->output_thread->Attach(output_thread_func, self);
self->output_thread->SetPriority(AJA_ThreadPriority_High);
self->output_thread->Start();
g_mutex_lock(&self->queue_lock);
self->shutdown = FALSE;
self->playing = FALSE;
self->eos = FALSE;
g_cond_signal(&self->queue_cond);
g_mutex_unlock(&self->queue_lock);
return TRUE;
}
static gboolean gst_aja_sink_stop(GstAjaSink *self) {
QueueItem *item;
GST_DEBUG_OBJECT(self, "Stopping");
g_mutex_lock(&self->queue_lock);
self->shutdown = TRUE;
self->playing = FALSE;
g_cond_signal(&self->queue_cond);
g_mutex_unlock(&self->queue_lock);
if (self->output_thread) {
self->output_thread->Stop();
delete self->output_thread;
self->output_thread = NULL;
}
GST_OBJECT_LOCK(self);
gst_clear_caps(&self->configured_caps);
self->configured_audio_channels = 0;
GST_OBJECT_UNLOCK(self);
while ((item = (QueueItem *)gst_vec_deque_pop_head_struct(self->queue))) {
if (item->type == QUEUE_ITEM_TYPE_FRAME) {
gst_buffer_unmap(item->video_buffer, &item->video_map);
gst_buffer_unref(item->video_buffer);
if (item->audio_buffer) {
gst_buffer_unmap(item->audio_buffer, &item->audio_map);
gst_buffer_unref(item->audio_buffer);
}
if (item->anc_buffer) {
gst_buffer_unmap(item->anc_buffer, &item->anc_map);
gst_buffer_unref(item->anc_buffer);
}
if (item->anc_buffer2) {
gst_buffer_unmap(item->anc_buffer2, &item->anc_map2);
gst_buffer_unref(item->anc_buffer2);
}
}
}
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);
}
if (self->tc_indexes) {
delete self->tc_indexes;
self->tc_indexes = NULL;
}
GST_DEBUG_OBJECT(self, "Stopped");
return TRUE;
}
static GstStateChangeReturn gst_aja_sink_change_state(
GstElement *element, GstStateChange transition) {
GstAjaSink *self = GST_AJA_SINK(element);
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
if (!gst_aja_sink_open(self)) return GST_STATE_CHANGE_FAILURE;
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (!gst_aja_sink_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_sink_stop(self)) return GST_STATE_CHANGE_FAILURE;
break;
case GST_STATE_CHANGE_READY_TO_NULL:
if (!gst_aja_sink_close(self)) return GST_STATE_CHANGE_FAILURE;
break;
default:
break;
}
return ret;
}
static gboolean gst_aja_sink_set_caps(GstBaseSink *bsink, GstCaps *caps) {
GstAjaSink *self = GST_AJA_SINK(bsink);
const GstStructure *s;
NTV2VideoFormat video_format = ::NTV2_FORMAT_UNKNOWN;
GST_DEBUG_OBJECT(self, "Configuring caps %" GST_PTR_FORMAT, caps);
GST_OBJECT_LOCK(self);
if (self->configured_caps) {
if (!gst_caps_can_intersect(self->configured_caps, caps)) {
GST_DEBUG_OBJECT(self, "Need to reconfigure, waiting for draining");
GST_OBJECT_UNLOCK(self);
g_mutex_lock(&self->queue_lock);
self->draining = TRUE;
g_cond_signal(&self->queue_cond);
while (self->draining && !self->flushing && !self->shutdown) {
g_cond_wait(&self->drain_cond, &self->queue_lock);
}
if (self->flushing || self->shutdown) {
g_mutex_unlock(&self->queue_lock);
GST_DEBUG_OBJECT(self, "Flushing");
return FALSE;
}
g_mutex_unlock(&self->queue_lock);
GST_OBJECT_LOCK(self);
} else {
GST_OBJECT_UNLOCK(self);
GST_DEBUG_OBJECT(self,
"Compatible caps with previous caps, not reconfiguring");
return TRUE;
}
}
if (!gst_video_info_from_caps(&self->configured_info, caps)) {
GST_OBJECT_UNLOCK(self);
GST_FIXME_OBJECT(self, "Failed to parse caps");
return FALSE;
}
self->configured_audio_channels = 0;
s = gst_caps_get_structure(caps, 0);
gst_structure_get_int(s, "audio-channels", &self->configured_audio_channels);
gst_caps_replace(&self->configured_caps, caps);
GST_OBJECT_UNLOCK(self);
bool quad_mode = (self->sdi_mode != GST_AJA_SDI_MODE_SINGLE_LINK);
video_format = gst_ntv2_video_format_from_caps(caps, quad_mode);
if (video_format == NTV2_FORMAT_UNKNOWN) {
GST_ERROR_OBJECT(self, "Unsupported caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
if (quad_mode) {
if (self->output_destination != GST_AJA_OUTPUT_DESTINATION_AUTO) {
GST_ERROR_OBJECT(self,
"Quad modes require usage of the channel's default "
"output destination");
return FALSE;
}
if (self->channel != ::NTV2_CHANNEL1 && self->channel != ::NTV2_CHANNEL5) {
GST_ERROR_OBJECT(self, "Quad modes require channels 1 or 5");
return FALSE;
}
}
self->quad_mode = quad_mode;
self->video_format = video_format;
g_assert(self->device != NULL);
// Make sure to globally lock here as the routing settings and others are
// global shared state
GstAjaNtv2DeviceLocker locker(self->device);
if (!::NTV2DeviceCanDoVideoFormat(self->device_id, video_format)) {
GST_ERROR_OBJECT(self, "Device does not support mode %d",
(int)video_format);
return FALSE;
}
self->device->device->SetMode(self->channel, NTV2_MODE_DISPLAY, false);
if (self->quad_mode) {
for (int i = 1; i < 4; i++)
self->device->device->SetMode((NTV2Channel)(self->channel + i),
NTV2_MODE_DISPLAY, false);
}
GST_DEBUG_OBJECT(self, "Configuring video format %d on channel %d",
(int)video_format, (int)self->channel);
self->device->device->SetVideoFormat(video_format, false, false,
self->channel);
if (self->quad_mode) {
for (int i = 1; i < 4; i++)
self->device->device->SetVideoFormat(video_format, false, false,
(NTV2Channel)(self->channel + i));
}
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;
}
self->device->device->SetFrameBufferFormat(self->channel,
::NTV2_FBF_10BIT_YCBCR);
if (self->quad_mode) {
for (int i = 1; i < 4; i++)
self->device->device->SetFrameBufferFormat(
(NTV2Channel)(self->channel + i), ::NTV2_FBF_10BIT_YCBCR);
}
NTV2ReferenceSource reference_source;
switch (self->reference_source) {
case GST_AJA_REFERENCE_SOURCE_EXTERNAL:
reference_source = ::NTV2_REFERENCE_EXTERNAL;
break;
case GST_AJA_REFERENCE_SOURCE_FREERUN:
case GST_AJA_REFERENCE_SOURCE_AUTO:
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->SetFramePulseReference(reference_source);
self->device->device->DMABufferAutoLock(false, true, 0);
if (::NTV2DeviceHasBiDirectionalSDI(self->device_id))
self->device->device->SetSDITransmitEnable(self->channel, true);
if (self->quad_mode) {
for (int i = 1; i < 4; i++)
self->device->device->SetSDITransmitEnable(
(NTV2Channel)(self->channel + i), true);
}
if (self->configured_audio_channels) {
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);
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->SetSDIOutputAudioSystem(self->channel,
self->audio_system);
self->device->device->SetSDIOutputDS2AudioSystem(self->channel,
self->audio_system);
if (self->quad_mode) {
for (int i = 1; i < 4; i++) {
self->device->device->SetSDIOutputAudioSystem(
(NTV2Channel)(self->channel + i), self->audio_system);
self->device->device->SetSDIOutputDS2AudioSystem(
(NTV2Channel)(self->channel + i), self->audio_system);
}
}
self->device->device->SetAudioLoopBack(::NTV2_AUDIO_LOOPBACK_OFF,
self->audio_system);
} else {
self->audio_system = ::NTV2_AUDIOSYSTEM_INVALID;
}
// Always use the framebuffer associated with the channel
NTV2OutputCrosspointID framebuffer_id =
::GetFrameBufferOutputXptFromChannel(self->channel, false, false);
NTV2VANCMode vanc_mode;
NTV2TCIndex tc_indexes_vitc[2] = {::NTV2_TCINDEX_INVALID,
::NTV2_TCINDEX_INVALID};
NTV2TCIndex tc_index_atc_ltc = ::NTV2_TCINDEX_INVALID;
NTV2InputCrosspointID output_destination_id;
switch (self->output_destination) {
case GST_AJA_OUTPUT_DESTINATION_AUTO:
tc_indexes_vitc[0] =
::NTV2ChannelToTimecodeIndex(self->channel, false, false);
tc_indexes_vitc[1] =
::NTV2ChannelToTimecodeIndex(self->channel, false, true);
tc_index_atc_ltc =
::NTV2ChannelToTimecodeIndex(self->channel, false, true);
output_destination_id = ::GetSDIOutputInputXpt(self->channel, false);
vanc_mode = ::NTV2DeviceCanDoCustomAnc(self->device_id)
? ::NTV2_VANCMODE_OFF
: ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI1:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI1;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI1_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI1_LTC;
output_destination_id = ::NTV2_XptSDIOut1Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI2:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI2;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI2_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI2_LTC;
output_destination_id = ::NTV2_XptSDIOut2Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI3:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI3;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI3_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI3_LTC;
output_destination_id = ::NTV2_XptSDIOut3Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI4:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI4;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI4_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI4_LTC;
output_destination_id = ::NTV2_XptSDIOut4Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI5:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI5;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI5_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI5_LTC;
output_destination_id = ::NTV2_XptSDIOut5Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI6:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI6;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI6_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI6_LTC;
output_destination_id = ::NTV2_XptSDIOut6Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI7:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI7;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI7_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI7_LTC;
output_destination_id = ::NTV2_XptSDIOut7Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_SDI8:
tc_indexes_vitc[0] = ::NTV2_TCINDEX_SDI8;
tc_indexes_vitc[1] = ::NTV2_TCINDEX_SDI8_2;
tc_index_atc_ltc = ::NTV2_TCINDEX_SDI8_LTC;
output_destination_id = ::NTV2_XptSDIOut8Input;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_ANALOG:
output_destination_id = ::NTV2_XptAnalogOutInput;
vanc_mode = ::NTV2_VANCMODE_TALL;
break;
case GST_AJA_OUTPUT_DESTINATION_HDMI:
output_destination_id = ::NTV2_XptHDMIOutInput;
vanc_mode = ::NTV2_VANCMODE_OFF;
break;
default:
g_assert_not_reached();
break;
}
if (!self->tc_indexes) self->tc_indexes = new NTV2TCIndexes;
switch (self->timecode_index) {
case GST_AJA_TIMECODE_INDEX_VITC:
self->tc_indexes->insert(tc_indexes_vitc[0]);
if (self->configured_info.interlace_mode !=
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE)
self->tc_indexes->insert(tc_indexes_vitc[1]);
break;
case GST_AJA_TIMECODE_INDEX_ATC_LTC:
self->tc_indexes->insert(tc_index_atc_ltc);
break;
case GST_AJA_TIMECODE_INDEX_LTC1:
self->tc_indexes->insert(::NTV2_TCINDEX_LTC1);
break;
case GST_AJA_TIMECODE_INDEX_LTC2:
self->tc_indexes->insert(::NTV2_TCINDEX_LTC2);
break;
default:
g_assert_not_reached();
break;
}
const NTV2Standard standard(::GetNTV2StandardFromVideoFormat(video_format));
self->device->device->SetSDIOutputStandard(self->channel, standard);
if (self->quad_mode) {
for (int i = 1; i < 4; i++)
self->device->device->SetSDIOutputStandard(
(NTV2Channel)(self->channel + i), standard);
}
const NTV2FrameGeometry geometry =
::GetNTV2FrameGeometryFromVideoFormat(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);
self->device->device->SetVANCMode(self->vanc_mode, self->channel);
if (self->quad_mode) {
for (int i = 1; i < 4; i++) {
self->device->device->SetFrameGeometry(
geometry, false, (NTV2Channel)(self->channel + i));
self->device->device->SetVANCMode(self->vanc_mode,
(NTV2Channel)(self->channel + i));
}
}
} else {
const NTV2FrameGeometry vanc_geometry =
::GetVANCFrameGeometry(geometry, self->vanc_mode);
self->device->device->SetFrameGeometry(vanc_geometry, false, self->channel);
self->device->device->SetVANCMode(self->vanc_mode, self->channel);
if (self->quad_mode) {
for (int i = 1; i < 4; i++) {
self->device->device->SetFrameGeometry(
vanc_geometry, false, (NTV2Channel)(self->channel + i));
self->device->device->SetVANCMode(self->vanc_mode,
(NTV2Channel)(self->channel + i));
}
}
}
bool had_quad_enabled = false, had_quad_quad_enabled = false;
if (self->channel < ::NTV2_CHANNEL5) {
self->device->device->GetQuadFrameEnable(had_quad_enabled, ::NTV2_CHANNEL1);
self->device->device->GetQuadQuadFrameEnable(had_quad_quad_enabled,
::NTV2_CHANNEL1);
} else {
self->device->device->GetQuadFrameEnable(had_quad_enabled, ::NTV2_CHANNEL5);
self->device->device->GetQuadQuadFrameEnable(had_quad_quad_enabled,
::NTV2_CHANNEL5);
}
if (self->quad_mode) {
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 {
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);
}
NTV2SmpteLineNumber smpte_line_num_info = ::GetSmpteLineNumber(standard);
self->f2_start_line =
(smpte_line_num_info.GetLastLine(
smpte_line_num_info.firstFieldTop ? NTV2_FIELD0 : NTV2_FIELD1) +
1);
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->channel == NTV2_CHANNEL1) {
for (auto iter = connections.begin(); iter != connections.end(); iter++) {
if (iter->first == NTV2_XptSDIOut1Input ||
iter->first == NTV2_XptSDIOut1InputDS2 ||
iter->first == NTV2_XptSDIOut2Input ||
iter->first == NTV2_XptSDIOut2InputDS2 ||
iter->first == NTV2_XptSDIOut3Input ||
iter->first == NTV2_XptSDIOut4Input ||
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_XptFrameBuffer1YUV ||
iter->second == NTV2_XptFrameBuffer2YUV ||
iter->second == NTV2_XptFrameBuffer3YUV ||
iter->second == NTV2_XptFrameBuffer4YUV ||
iter->second == NTV2_XptFrameBuffer1_DS2YUV ||
iter->second == NTV2_XptFrameBuffer2_DS2YUV ||
iter->first == NTV2_XptSDIOut1Input ||
iter->first == NTV2_XptSDIOut2Input ||
iter->first == NTV2_XptSDIOut3Input ||
iter->first == NTV2_XptSDIOut4Input)
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_XptSDIOut5Input ||
iter->first == NTV2_XptSDIOut5InputDS2 ||
iter->first == NTV2_XptSDIOut6Input ||
iter->first == NTV2_XptSDIOut6InputDS2 ||
iter->first == NTV2_XptSDIOut7Input ||
iter->first == NTV2_XptSDIOut8Input ||
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_XptFrameBuffer5YUV ||
iter->second == NTV2_XptFrameBuffer6YUV ||
iter->second == NTV2_XptFrameBuffer7YUV ||
iter->second == NTV2_XptFrameBuffer8YUV ||
iter->second == NTV2_XptFrameBuffer3_DS2YUV ||
iter->second == NTV2_XptFrameBuffer4_DS2YUV ||
iter->second == NTV2_XptFrameBuffer5_DS2YUV ||
iter->second == NTV2_XptFrameBuffer6_DS2YUV ||
iter->first == NTV2_XptSDIOut5Input ||
iter->first == NTV2_XptSDIOut6Input ||
iter->first == NTV2_XptSDIOut7Input ||
iter->first == NTV2_XptSDIOut8Input)
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.
NTV2InputCrosspointID quad_output_source_ids[10];
if (output_destination_id == NTV2_XptSDIOut1Input ||
output_destination_id == NTV2_XptSDIOut2Input ||
output_destination_id == NTV2_XptSDIOut3Input ||
output_destination_id == NTV2_XptSDIOut4Input) {
quad_output_source_ids[0] = NTV2_XptSDIOut1Input;
quad_output_source_ids[1] = NTV2_XptSDIOut2Input;
quad_output_source_ids[2] = NTV2_XptSDIOut3Input;
quad_output_source_ids[3] = NTV2_XptSDIOut4Input;
quad_output_source_ids[4] = NTV2_XptSDIOut1InputDS2;
quad_output_source_ids[5] = NTV2_XptSDIOut2InputDS2;
quad_output_source_ids[6] = NTV2_Xpt425Mux1AInput;
quad_output_source_ids[7] = NTV2_Xpt425Mux1BInput;
quad_output_source_ids[8] = NTV2_Xpt425Mux2AInput;
quad_output_source_ids[9] = NTV2_Xpt425Mux2BInput;
} else if (output_destination_id == NTV2_XptSDIOut5Input ||
output_destination_id == NTV2_XptSDIOut6Input ||
output_destination_id == NTV2_XptSDIOut7Input ||
output_destination_id == NTV2_XptSDIOut8Input) {
quad_output_source_ids[0] = NTV2_XptSDIOut5Input;
quad_output_source_ids[1] = NTV2_XptSDIOut6Input;
quad_output_source_ids[2] = NTV2_XptSDIOut7Input;
quad_output_source_ids[3] = NTV2_XptSDIOut8Input;
quad_output_source_ids[4] = NTV2_XptSDIOut5InputDS2;
quad_output_source_ids[5] = NTV2_XptSDIOut6InputDS2;
quad_output_source_ids[6] = NTV2_Xpt425Mux3AInput;
quad_output_source_ids[7] = NTV2_Xpt425Mux3BInput;
quad_output_source_ids[8] = NTV2_Xpt425Mux4AInput;
quad_output_source_ids[9] = NTV2_Xpt425Mux4BInput;
}
for (auto iter = connections.begin(); iter != connections.end(); iter++) {
if (had_quad_enabled || had_quad_quad_enabled) {
for (auto quad_output_source_id : quad_output_source_ids) {
if (iter->first == quad_output_source_id)
router.RemoveConnection(iter->first, iter->second);
}
} else {
if (iter->first == output_destination_id ||
iter->second == framebuffer_id)
router.RemoveConnection(iter->first, iter->second);
}
}
}
if (self->quad_mode) {
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)
framebuffer_id = NTV2_Xpt425Mux1AYUV;
else if (self->channel == NTV2_CHANNEL5)
framebuffer_id = NTV2_Xpt425Mux3AYUV;
else
g_assert_not_reached();
}
}
GST_DEBUG_OBJECT(self, "Creating connection %d - %d", output_destination_id,
framebuffer_id);
router.AddConnection(output_destination_id, framebuffer_id);
if (self->quad_mode) {
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_XptSDIOut2Input,
NTV2_XptFrameBuffer1_DS2YUV);
router.AddConnection(NTV2_XptSDIOut3Input, NTV2_XptFrameBuffer2YUV);
router.AddConnection(NTV2_XptSDIOut4Input,
NTV2_XptFrameBuffer2_DS2YUV);
} else if (self->channel == NTV2_CHANNEL5) {
router.AddConnection(NTV2_XptSDIOut6Input,
NTV2_XptFrameBuffer3_DS2YUV);
router.AddConnection(NTV2_XptSDIOut7Input, NTV2_XptFrameBuffer4YUV);
router.AddConnection(NTV2_XptSDIOut8Input,
NTV2_XptFrameBuffer4_DS2YUV);
} else {
g_assert_not_reached();
}
} else if (NTV2_IS_QUAD_QUAD_FORMAT(self->video_format)) {
if (self->channel == NTV2_CHANNEL1) {
router.AddConnection(NTV2_XptSDIOut1InputDS2,
NTV2_XptFrameBuffer1_DS2YUV);
router.AddConnection(NTV2_XptSDIOut2Input, NTV2_XptFrameBuffer2YUV);
router.AddConnection(NTV2_XptSDIOut2InputDS2,
NTV2_XptFrameBuffer2_DS2YUV);
} else if (self->channel == NTV2_CHANNEL5) {
router.AddConnection(NTV2_XptSDIOut5InputDS2,
NTV2_XptFrameBuffer3_DS2YUV);
router.AddConnection(NTV2_XptSDIOut6Input, NTV2_XptFrameBuffer4YUV);
router.AddConnection(NTV2_XptSDIOut6InputDS2,
NTV2_XptFrameBuffer4_DS2YUV);
} else {
g_assert_not_reached();
}
} else if (NTV2_IS_4K_HFR_VIDEO_FORMAT(self->video_format)) {
if (self->channel == NTV2_CHANNEL1) {
router.AddConnection(NTV2_XptSDIOut2Input, NTV2_Xpt425Mux1BYUV);
router.AddConnection(NTV2_XptSDIOut3Input, NTV2_Xpt425Mux2AYUV);
router.AddConnection(NTV2_XptSDIOut4Input, NTV2_Xpt425Mux2BYUV);
router.AddConnection(NTV2_Xpt425Mux1AInput, NTV2_XptFrameBuffer1YUV);
router.AddConnection(NTV2_Xpt425Mux1BInput,
NTV2_XptFrameBuffer1_DS2YUV);
router.AddConnection(NTV2_Xpt425Mux2AInput, NTV2_XptFrameBuffer2YUV);
router.AddConnection(NTV2_Xpt425Mux2BInput,
NTV2_XptFrameBuffer2_DS2YUV);
} else if (self->channel == NTV2_CHANNEL5) {
router.AddConnection(NTV2_XptSDIOut6Input, NTV2_Xpt425Mux3BYUV);
router.AddConnection(NTV2_XptSDIOut7Input, NTV2_Xpt425Mux4AYUV);
router.AddConnection(NTV2_XptSDIOut8Input, NTV2_Xpt425Mux4BYUV);
router.AddConnection(NTV2_Xpt425Mux3AInput, NTV2_XptFrameBuffer5YUV);
router.AddConnection(NTV2_Xpt425Mux3BInput,
NTV2_XptFrameBuffer5_DS2YUV);
router.AddConnection(NTV2_Xpt425Mux4AInput, NTV2_XptFrameBuffer6YUV);
router.AddConnection(NTV2_Xpt425Mux4BInput,
NTV2_XptFrameBuffer6_DS2YUV);
} else {
g_assert_not_reached();
}
} else {
if (self->channel == NTV2_CHANNEL1) {
router.AddConnection(NTV2_XptSDIOut1InputDS2, NTV2_Xpt425Mux1BYUV);
router.AddConnection(NTV2_XptSDIOut2Input, NTV2_Xpt425Mux2AYUV);
router.AddConnection(NTV2_XptSDIOut2InputDS2, NTV2_Xpt425Mux2BYUV);
router.AddConnection(NTV2_Xpt425Mux1AInput, NTV2_XptFrameBuffer1YUV);
router.AddConnection(NTV2_Xpt425Mux1BInput,
NTV2_XptFrameBuffer1_DS2YUV);
router.AddConnection(NTV2_Xpt425Mux2AInput, NTV2_XptFrameBuffer2YUV);
router.AddConnection(NTV2_Xpt425Mux2BInput,
NTV2_XptFrameBuffer2_DS2YUV);
} else if (self->channel == NTV2_CHANNEL5) {
router.AddConnection(NTV2_XptSDIOut5InputDS2, NTV2_Xpt425Mux3BYUV);
router.AddConnection(NTV2_XptSDIOut6Input, NTV2_Xpt425Mux4AYUV);
router.AddConnection(NTV2_XptSDIOut6InputDS2, NTV2_Xpt425Mux4BYUV);
router.AddConnection(NTV2_Xpt425Mux3AInput, NTV2_XptFrameBuffer5YUV);
router.AddConnection(NTV2_Xpt425Mux3BInput,
NTV2_XptFrameBuffer5_DS2YUV);
router.AddConnection(NTV2_Xpt425Mux4AInput, NTV2_XptFrameBuffer6YUV);
router.AddConnection(NTV2_Xpt425Mux4BInput,
NTV2_XptFrameBuffer6_DS2YUV);
} else {
g_assert_not_reached();
}
}
} else if (self->sdi_mode == GST_AJA_SDI_MODE_QUAD_LINK_SQD) {
if (self->channel == NTV2_CHANNEL1) {
router.AddConnection(NTV2_XptSDIOut2Input, NTV2_XptFrameBuffer2YUV);
router.AddConnection(NTV2_XptSDIOut3Input, NTV2_XptFrameBuffer3YUV);
router.AddConnection(NTV2_XptSDIOut4Input, NTV2_XptFrameBuffer4YUV);
} else if (self->channel == NTV2_CHANNEL5) {
router.AddConnection(NTV2_XptSDIOut6Input, NTV2_XptFrameBuffer6YUV);
router.AddConnection(NTV2_XptSDIOut7Input, NTV2_XptFrameBuffer7YUV);
router.AddConnection(NTV2_XptSDIOut8Input, NTV2_XptFrameBuffer8YUV);
} 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());
}
return TRUE;
}
static GstCaps *gst_aja_sink_get_caps(GstBaseSink *bsink, GstCaps *filter) {
GstAjaSink *self = GST_AJA_SINK(bsink);
GstCaps *caps;
if (self->device) {
caps = gst_ntv2_supported_caps(self->device_id);
} else {
caps = gst_pad_get_pad_template_caps(GST_BASE_SINK_PAD(self));
}
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_sink_event(GstBaseSink *bsink, GstEvent *event) {
GstAjaSink *self = GST_AJA_SINK(bsink);
switch (GST_EVENT_TYPE(event)) {
case GST_EVENT_EOS: {
GST_DEBUG_OBJECT(self, "Signalling EOS");
g_mutex_lock(&self->queue_lock);
self->eos = TRUE;
g_cond_signal(&self->queue_cond);
g_mutex_unlock(&self->queue_lock);
break;
}
case GST_EVENT_FLUSH_START: {
g_mutex_lock(&self->queue_lock);
self->flushing = TRUE;
self->draining = FALSE;
g_cond_signal(&self->drain_cond);
g_mutex_unlock(&self->queue_lock);
break;
}
case GST_EVENT_FLUSH_STOP: {
QueueItem *item;
g_mutex_lock(&self->queue_lock);
while (
(item = (QueueItem *)gst_vec_deque_pop_head_struct(self->queue))) {
if (item->type == QUEUE_ITEM_TYPE_FRAME) {
gst_buffer_unmap(item->video_buffer, &item->video_map);
gst_buffer_unref(item->video_buffer);
if (item->audio_buffer) {
gst_buffer_unmap(item->audio_buffer, &item->audio_map);
gst_buffer_unref(item->audio_buffer);
}
if (item->anc_buffer) {
gst_buffer_unmap(item->anc_buffer, &item->anc_map);
gst_buffer_unref(item->anc_buffer);
}
if (item->anc_buffer2) {
gst_buffer_unmap(item->anc_buffer2, &item->anc_map2);
gst_buffer_unref(item->anc_buffer2);
}
}
}
g_cond_signal(&self->queue_cond);
self->flushing = FALSE;
g_cond_signal(&self->drain_cond);
g_mutex_unlock(&self->queue_lock);
break;
}
default:
break;
}
return GST_BASE_SINK_CLASS(parent_class)->event(bsink, event);
}
static gboolean gst_aja_sink_propose_allocation(GstBaseSink *bsink,
GstQuery *query) {
GstAjaSink *self = GST_AJA_SINK(bsink);
if (self->allocator && self->vanc_mode == ::NTV2_VANCMODE_OFF) {
GstAllocationParams params;
gst_allocation_params_init(&params);
params.prefix = 0;
params.padding = 0;
params.align = 4095;
gst_query_add_allocation_param(query, self->allocator, &params);
}
return TRUE;
}
static GstFlowReturn gst_aja_sink_render(GstBaseSink *bsink,
GstBuffer *buffer) {
GstAjaSink *self = GST_AJA_SINK(bsink);
GstFlowReturn flow_ret = GST_FLOW_OK;
GstAjaAudioMeta *meta;
GstBuffer *item_buffer = NULL, *item_audio_buffer = NULL;
GstVideoTimeCodeMeta *tc_meta;
QueueItem item = {
.type = QUEUE_ITEM_TYPE_FRAME,
.video_buffer = NULL,
.video_map = GST_MAP_INFO_INIT,
.audio_buffer = NULL,
.audio_map = GST_MAP_INFO_INIT,
.tc = NTV2_RP188(),
.anc_buffer = NULL,
.anc_map = GST_MAP_INFO_INIT,
.anc_buffer2 = NULL,
.anc_map2 = GST_MAP_INFO_INIT,
};
guint video_buffer_size = ::GetVideoActiveSize(
self->video_format, ::NTV2_FBF_10BIT_YCBCR, self->vanc_mode);
NTV2FormatDescriptor format_desc(self->video_format, ::NTV2_FBF_10BIT_YCBCR,
self->vanc_mode);
meta = gst_buffer_get_aja_audio_meta(buffer);
tc_meta = gst_buffer_get_video_time_code_meta(buffer);
if (self->vanc_mode == ::NTV2_VANCMODE_OFF &&
gst_buffer_n_memory(buffer) == 1) {
GstMemory *mem = gst_buffer_peek_memory(buffer, 0);
gsize offset;
if (gst_memory_get_sizes(mem, &offset, NULL) == video_buffer_size &&
offset == 0 &&
strcmp(mem->allocator->mem_type, GST_AJA_ALLOCATOR_MEMTYPE) == 0 &&
GST_AJA_ALLOCATOR(mem->allocator)->device->device->GetIndexNumber() ==
self->device->device->GetIndexNumber()) {
item_buffer = gst_buffer_ref(buffer);
}
}
if (!item_buffer) {
GstVideoFrame in_frame;
GST_DEBUG_OBJECT(self, "Allocating new video buffer");
if (!self->buffer_pool) {
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,
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);
}
if (!gst_video_frame_map(&in_frame, &self->configured_info, buffer,
GST_MAP_READ)) {
GST_ERROR_OBJECT(self, "Failed to map buffer");
return GST_FLOW_ERROR;
}
flow_ret =
gst_buffer_pool_acquire_buffer(self->buffer_pool, &item_buffer, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_video_frame_unmap(&in_frame);
return flow_ret;
}
item.type = QUEUE_ITEM_TYPE_FRAME;
item.video_buffer = item_buffer;
gst_buffer_map(item.video_buffer, &item.video_map, GST_MAP_WRITE);
guint offset =
format_desc.RasterLineToByteOffset(format_desc.GetFirstActiveLine());
guint size = format_desc.GetVisibleRasterBytes();
if (offset != 0)
::SetRasterLinesBlack(::NTV2_FBF_10BIT_YCBCR, item.video_map.data,
format_desc.GetBytesPerRow(),
format_desc.GetFirstActiveLine());
memcpy(item.video_map.data + offset,
GST_VIDEO_FRAME_PLANE_DATA(&in_frame, 0), size);
gst_video_frame_unmap(&in_frame);
} else {
item.type = QUEUE_ITEM_TYPE_FRAME;
item.video_buffer = item_buffer;
gst_buffer_map(item.video_buffer, &item.video_map, GST_MAP_READ);
}
if (meta) {
if (gst_buffer_n_memory(meta->buffer) == 1) {
GstMemory *mem = gst_buffer_peek_memory(meta->buffer, 0);
if (strcmp(mem->allocator->mem_type, GST_AJA_ALLOCATOR_MEMTYPE) == 0 &&
GST_AJA_ALLOCATOR(mem->allocator)->device->device->GetIndexNumber() ==
self->device->device->GetIndexNumber()) {
item_audio_buffer = gst_buffer_ref(meta->buffer);
}
}
if (!item_audio_buffer) {
GstMapInfo audio_map;
GST_DEBUG_OBJECT(self, "Allocating new audio buffer");
if (!self->audio_buffer_pool) {
guint audio_buffer_size = 1UL * 1024UL * 1024UL;
self->audio_buffer_pool = gst_buffer_pool_new();
GstStructure *config =
gst_buffer_pool_get_config(self->audio_buffer_pool);
gst_buffer_pool_config_set_params(config, NULL, audio_buffer_size,
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);
}
flow_ret = gst_buffer_pool_acquire_buffer(self->audio_buffer_pool,
&item_audio_buffer, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_buffer_unmap(item.video_buffer, &item.video_map);
gst_buffer_unref(item.video_buffer);
return flow_ret;
}
gst_buffer_set_size(item_audio_buffer, gst_buffer_get_size(meta->buffer));
gst_buffer_map(meta->buffer, &audio_map, GST_MAP_READ);
gst_buffer_map(item_audio_buffer, &item.audio_map, GST_MAP_READWRITE);
memcpy(item.audio_map.data, audio_map.data, audio_map.size);
gst_buffer_unmap(meta->buffer, &audio_map);
item.audio_buffer = item_audio_buffer;
} else {
gst_buffer_map(item_audio_buffer, &item.audio_map, GST_MAP_READ);
item.audio_buffer = item_audio_buffer;
}
} else {
item.audio_buffer = NULL;
}
if (tc_meta) {
TimecodeFormat tc_format = ::kTCFormatUnknown;
if (tc_meta->tc.config.fps_n == 24 && tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat24fps;
} else if (tc_meta->tc.config.fps_n == 25 &&
tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat25fps;
} else if (tc_meta->tc.config.fps_n == 30 &&
tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat30fps;
} else if (tc_meta->tc.config.fps_n == 30000 &&
tc_meta->tc.config.fps_d == 1001) {
tc_format = kTCFormat30fpsDF;
} else if (tc_meta->tc.config.fps_n == 48 &&
tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat48fps;
} else if (tc_meta->tc.config.fps_n == 50 &&
tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat50fps;
} else if (tc_meta->tc.config.fps_n == 60 &&
tc_meta->tc.config.fps_d == 1) {
tc_format = kTCFormat60fps;
} else if (tc_meta->tc.config.fps_n == 60000 &&
tc_meta->tc.config.fps_d == 1001) {
tc_format = kTCFormat60fpsDF;
}
const CRP188 rp188(tc_meta->tc.frames, tc_meta->tc.seconds,
tc_meta->tc.minutes, tc_meta->tc.hours, tc_format);
rp188.GetRP188Reg(item.tc);
} else {
item.tc.fDBB = 0xffffffff;
}
AJAAncillaryList anc_packet_list;
// TODO: Handle AFD/Bar meta
#if 0
if (bar_meta || afd_meta) {
const uint16_t kF1PktLineNumAFDBAR(11);
const AJAAncillaryDataLocation kAFDBARLocF1(
AJAAncillaryDataLink_A, AJAAncillaryDataVideoStream_Y,
AJAAncillaryDataSpace_VANC, kF1PktLineNumAFDBAR,
AJAAncDataHorizOffset_AnyVanc);
const uint16_t kF2PktLineNumAFDBAR(self->f2_start_line + 11);
const AJAAncillaryDataLocation kAFDBARLocF2(
AJAAncillaryDataLink_A, AJAAncillaryDataVideoStream_Y,
AJAAncillaryDataSpace_VANC, kF2PktLineNumAFDBAR,
AJAAncDataHorizOffset_AnyVanc);
AJAAncillaryData pkt;
pkt.SetFromSMPTE334(NULL, 0, kAFDBARLocF1);
anc_packet_list.AddAncillaryData(pkt);
if (self->configured_info.interlace_mode != GST_VIDEO_INTERLACE_MODE_PROGRESSIVE) {
AJAAncillaryData pkt2;
pkt.SetFromSMPTE334(NULL, 0, kAFDBARLocF2);
anc_packet_list.AddAncillaryData(pkt);
}
}
#endif
GstVideoCaptionMeta *caption_meta;
gpointer iter = NULL;
while (
(caption_meta = (GstVideoCaptionMeta *)gst_buffer_iterate_meta_filtered(
buffer, &iter, GST_VIDEO_CAPTION_META_API_TYPE))) {
if (caption_meta->caption_type == GST_VIDEO_CAPTION_TYPE_CEA708_CDP) {
if (self->cea708_line_number != -1) {
const AJAAncillaryDataLocation kCEA708LocF1(
AJAAncillaryDataLink_A, AJAAncillaryDataVideoStream_Y,
AJAAncillaryDataSpace_VANC, self->cea708_line_number,
AJAAncDataHorizOffset_AnyVanc);
AJAAncillaryData_Cea708 pkt;
pkt.SetDID(AJAAncillaryData_CEA708_DID);
pkt.SetSID(AJAAncillaryData_CEA708_SID);
pkt.SetDataLocation(kCEA708LocF1);
pkt.SetDataCoding(AJAAncillaryDataCoding_Digital);
pkt.SetPayloadData(caption_meta->data, caption_meta->size);
GST_TRACE_OBJECT(
self,
"Adding CEA708 CDP VANC of %" G_GSIZE_FORMAT " bytes at line %u",
pkt.GetPayloadByteCount(), pkt.GetLocationLineNumber());
anc_packet_list.AddAncillaryData(pkt);
}
} else if (caption_meta->caption_type ==
GST_VIDEO_CAPTION_TYPE_CEA608_S334_1A) {
if (self->cea608_line_number != -1) {
const AJAAncillaryDataLocation kCEA608LocF1(
AJAAncillaryDataLink_A, AJAAncillaryDataVideoStream_Y,
AJAAncillaryDataSpace_VANC, self->cea608_line_number,
AJAAncDataHorizOffset_AnyVanc);
AJAAncillaryData_Cea608_Vanc pkt;
pkt.SetDID(AJAAncillaryData_Cea608_Vanc_DID);
pkt.SetSID(AJAAncillaryData_Cea608_Vanc_SID);
pkt.SetDataLocation(kCEA608LocF1);
pkt.SetDataCoding(AJAAncillaryDataCoding_Digital);
pkt.SetPayloadData(caption_meta->data, caption_meta->size);
pkt.ParsePayloadData();
GST_TRACE_OBJECT(
self, "Adding CEA608 VANC of %" G_GSIZE_FORMAT " bytes at line %u",
pkt.GetPayloadByteCount(), pkt.GetLocationLineNumber());
anc_packet_list.AddAncillaryData(pkt);
}
} else {
GST_WARNING_OBJECT(self, "Unhandled caption type %d",
caption_meta->caption_type);
}
}
if (self->handle_ancillary_meta) {
GstAncillaryMeta *anc_meta;
iter = NULL;
while ((anc_meta = (GstAncillaryMeta *)gst_buffer_iterate_meta_filtered(
buffer, &iter, GST_ANCILLARY_META_API_TYPE))) {
const AJAAncillaryDataLocation loc(
AJAAncillaryDataLink_A,
anc_meta->c_not_y_channel ? AJAAncillaryDataChannel_C
: AJAAncillaryDataVideoStream_Y,
AJAAncillaryDataSpace_VANC, anc_meta->line, anc_meta->offset);
AJAAncillaryData pkt;
guint8 data[256];
pkt.SetDID(anc_meta->DID);
pkt.SetSID(anc_meta->SDID_block_number);
pkt.SetDataLocation(loc);
pkt.SetDataCoding(AJAAncillaryDataCoding_Digital);
for (gsize i = 0; i < (anc_meta->data_count & 0xff); i++) {
data[i] = anc_meta->data[i] & 0xff;
}
pkt.SetPayloadData(data, anc_meta->data_count & 0xff);
GST_TRACE_OBJECT(self,
"Adding ANC of %" G_GSIZE_FORMAT " bytes at (%u,%u)",
pkt.GetPayloadByteCount(), pkt.GetLocationLineNumber(),
pkt.GetLocationHorizOffset());
anc_packet_list.AddAncillaryData(pkt);
}
}
if (!anc_packet_list.IsEmpty()) {
if (self->vanc_mode == ::NTV2_VANCMODE_OFF &&
::NTV2DeviceCanDoCustomAnc(self->device_id)) {
if (!self->anc_buffer_pool) {
self->anc_buffer_pool = gst_buffer_pool_new();
GstStructure *config =
gst_buffer_pool_get_config(self->anc_buffer_pool);
gst_buffer_pool_config_set_params(
config, NULL, 8 * 1024,
(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);
}
flow_ret = gst_buffer_pool_acquire_buffer(self->anc_buffer_pool,
&item.anc_buffer, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_buffer_unmap(item.video_buffer, &item.video_map);
gst_buffer_unref(item.video_buffer);
if (item.audio_buffer) {
gst_buffer_unmap(item.audio_buffer, &item.audio_map);
gst_buffer_unref(item.audio_buffer);
}
return flow_ret;
}
gst_buffer_map(item.anc_buffer, &item.anc_map, GST_MAP_READWRITE);
if (self->configured_info.interlace_mode !=
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE) {
flow_ret = gst_buffer_pool_acquire_buffer(self->anc_buffer_pool,
&item.anc_buffer2, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_buffer_unmap(item.video_buffer, &item.video_map);
gst_buffer_unref(item.video_buffer);
if (item.audio_buffer) {
gst_buffer_unmap(item.audio_buffer, &item.audio_map);
gst_buffer_unref(item.audio_buffer);
}
if (item.anc_buffer) {
gst_buffer_unmap(item.anc_buffer, &item.anc_map);
gst_buffer_unref(item.anc_buffer);
}
return flow_ret;
}
gst_buffer_map(item.anc_buffer2, &item.anc_map2, GST_MAP_READWRITE);
}
NTV2_POINTER anc_ptr1(item.anc_map.data, item.anc_map.size);
NTV2_POINTER anc_ptr2(item.anc_map2.data, item.anc_map2.size);
anc_ptr1.Fill(ULWord(0));
anc_ptr2.Fill(ULWord(0));
anc_packet_list.GetTransmitData(anc_ptr1, anc_ptr2,
self->configured_info.interlace_mode !=
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE,
self->f2_start_line);
} else {
NTV2_POINTER ptr(item.video_map.data, item.video_map.size);
anc_packet_list.GetVANCTransmitData(ptr, format_desc);
}
}
g_mutex_lock(&self->queue_lock);
while (gst_vec_deque_get_length(self->queue) >= self->queue_size) {
QueueItem *tmp = (QueueItem *)gst_vec_deque_pop_head_struct(self->queue);
if (tmp->type == QUEUE_ITEM_TYPE_FRAME) {
GST_WARNING_OBJECT(self, "Element queue overrun, dropping old frame");
GstMessage *msg = gst_message_new_qos(
GST_OBJECT_CAST(self), TRUE, GST_CLOCK_TIME_NONE, GST_CLOCK_TIME_NONE,
GST_BUFFER_PTS(tmp->video_buffer),
gst_util_uint64_scale(GST_SECOND, self->configured_info.fps_d,
self->configured_info.fps_n));
gst_element_post_message(GST_ELEMENT_CAST(self), msg);
gst_buffer_unmap(tmp->video_buffer, &tmp->video_map);
gst_buffer_unref(tmp->video_buffer);
if (tmp->audio_buffer) {
gst_buffer_unmap(tmp->audio_buffer, &tmp->audio_map);
gst_buffer_unref(tmp->audio_buffer);
}
if (tmp->anc_buffer) {
gst_buffer_unmap(tmp->anc_buffer, &tmp->anc_map);
gst_buffer_unref(tmp->anc_buffer);
}
if (tmp->anc_buffer2) {
gst_buffer_unmap(tmp->anc_buffer2, &tmp->anc_map2);
gst_buffer_unref(tmp->anc_buffer2);
}
}
}
GST_TRACE_OBJECT(self, "Queuing frame video %p audio %p", item.video_map.data,
item.audio_buffer ? item.audio_map.data : NULL);
gst_vec_deque_push_tail_struct(self->queue, &item);
GST_TRACE_OBJECT(self, "%" G_GSIZE_FORMAT " frames queued",
gst_vec_deque_get_length(self->queue));
g_cond_signal(&self->queue_cond);
g_mutex_unlock(&self->queue_lock);
return flow_ret;
}
static void output_thread_func(AJAThread *thread, void *data) {
GstAjaSink *self = GST_AJA_SINK(data);
GstClock *clock = NULL;
guint64 frames_rendered_start = G_MAXUINT64;
GstClockTime frames_rendered_start_time = GST_CLOCK_TIME_NONE;
guint64 frames_dropped_last = G_MAXUINT64;
AUTOCIRCULATE_TRANSFER transfer;
if (self->output_cpu_core != G_MAXUINT) {
cpu_set_t mask;
pthread_t current_thread = pthread_self();
CPU_ZERO(&mask);
CPU_SET(self->output_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->output_cpu_core);
}
}
g_mutex_lock(&self->queue_lock);
restart:
if (self->draining && gst_vec_deque_get_length(self->queue) == 0) {
GST_DEBUG_OBJECT(self, "Drained");
self->draining = FALSE;
g_cond_signal(&self->drain_cond);
}
GST_DEBUG_OBJECT(self, "Waiting for playing or shutdown");
while ((!self->playing && !self->shutdown) ||
(self->playing &&
gst_vec_deque_get_length(self->queue) < self->queue_size / 2 &&
!self->eos))
g_cond_wait(&self->queue_cond, &self->queue_lock);
if (self->shutdown) {
GST_DEBUG_OBJECT(self, "Shutting down");
g_mutex_unlock(&self->queue_lock);
return;
}
GST_DEBUG_OBJECT(self, "Starting playing");
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);
self->device->device->AutoCirculateStop(self->channel);
if (!self->device->device->EnableChannel(self->channel)) {
GST_ERROR_OBJECT(self, "Failed to enable channel");
g_mutex_lock(&self->queue_lock);
GST_ELEMENT_ERROR(self, STREAM, FAILED, (NULL),
("Failed to configure device"));
goto out;
}
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");
g_mutex_lock(&self->queue_lock);
GST_ELEMENT_ERROR(self, STREAM, FAILED, (NULL),
("Failed to configure device"));
goto out;
}
}
}
self->device->device->EnableOutputInterrupt(self->channel);
self->device->device->SubscribeOutputVerticalEvent(self->channel);
guint16 start_frame = self->start_frame;
guint16 end_frame = self->end_frame;
// If both are the same, try to find queue_size/2 unallocated frames and
// use those.
if (start_frame == end_frame) {
guint16 num_frames = self->queue_size / 2;
gint assigned_start_frame = gst_aja_ntv2_device_find_unallocated_frames(
self->device, self->channel, num_frames);
if (assigned_start_frame == -1) {
GST_ELEMENT_ERROR(self, STREAM, FAILED, (NULL),
("Failed to allocate %u frames", num_frames));
goto out;
}
start_frame = assigned_start_frame;
end_frame = start_frame + num_frames - 1;
}
GST_DEBUG_OBJECT(
self, "Configuring channel %u with start frame %u and end frame %u",
self->channel, start_frame, end_frame);
// Configure render delay based on the framerate and queue size
gst_base_sink_set_render_delay(
GST_BASE_SINK(self),
gst_util_uint64_scale(end_frame - start_frame + 1,
self->configured_info.fps_d * GST_SECOND,
self->configured_info.fps_n));
if (!self->device->device->AutoCirculateInitForOutput(
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)) {
GST_ELEMENT_ERROR(self, STREAM, FAILED, (NULL),
("Failed to initialize autocirculate"));
goto out;
}
self->device->device->AutoCirculateStart(self->channel);
}
gst_clear_object(&clock);
clock = gst_element_get_clock(GST_ELEMENT_CAST(self));
frames_rendered_start = G_MAXUINT64;
frames_rendered_start_time = GST_CLOCK_TIME_NONE;
frames_dropped_last = G_MAXUINT64;
g_mutex_lock(&self->queue_lock);
while (self->playing && !self->shutdown &&
!(self->draining && gst_vec_deque_get_length(self->queue) == 0)) {
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);
// Detect if we were too slow with providing frames and report if that was
// the case together with the amount of frames dropped
if (frames_dropped_last == G_MAXUINT64) {
frames_dropped_last = status.acFramesDropped;
} else if (frames_dropped_last < status.acFramesDropped) {
GST_WARNING_OBJECT(self, "Dropped %" G_GUINT64_FORMAT " frames",
status.acFramesDropped - frames_dropped_last);
GstClockTime timestamp =
gst_util_uint64_scale(status.acFramesProcessed + frames_dropped_last,
self->configured_info.fps_n,
self->configured_info.fps_d * GST_SECOND);
GstClockTime timestamp_end = gst_util_uint64_scale(
status.acFramesProcessed + status.acFramesDropped,
self->configured_info.fps_n,
self->configured_info.fps_d * GST_SECOND);
GstMessage *msg = gst_message_new_qos(
GST_OBJECT_CAST(self), TRUE, GST_CLOCK_TIME_NONE, GST_CLOCK_TIME_NONE,
timestamp, timestamp_end - timestamp);
gst_element_post_message(GST_ELEMENT_CAST(self), msg);
frames_dropped_last = status.acFramesDropped;
}
if (status.GetNumAvailableOutputFrames() > 1) {
QueueItem item, *item_p;
while ((item_p = (QueueItem *)gst_vec_deque_pop_head_struct(
self->queue)) == NULL &&
self->playing && !self->shutdown && !self->draining) {
GST_DEBUG_OBJECT(
self,
"Element queue underrun, waiting for more frames or shutdown");
g_cond_wait(&self->queue_cond, &self->queue_lock);
}
if (!self->playing || self->shutdown || (!item_p && self->draining)) {
if (item_p && item_p->type == QUEUE_ITEM_TYPE_FRAME) {
gst_buffer_unmap(item_p->video_buffer, &item_p->video_map);
gst_buffer_unref(item_p->video_buffer);
if (item_p->audio_buffer) {
gst_buffer_unmap(item_p->audio_buffer, &item_p->audio_map);
gst_buffer_unref(item_p->audio_buffer);
}
if (item_p->anc_buffer) {
gst_buffer_unmap(item_p->anc_buffer, &item_p->anc_map);
gst_buffer_unref(item_p->anc_buffer);
}
if (item_p->anc_buffer2) {
gst_buffer_unmap(item_p->anc_buffer2, &item_p->anc_map2);
gst_buffer_unref(item_p->anc_buffer2);
}
}
break;
}
if (item_p && item_p->type != QUEUE_ITEM_TYPE_FRAME) {
continue;
}
GST_TRACE_OBJECT(self, "%" G_GSIZE_FORMAT " frames queued",
gst_vec_deque_get_length(self->queue));
item = *item_p;
g_mutex_unlock(&self->queue_lock);
GST_TRACE_OBJECT(self,
"Transferring frame: "
"Video %p %" G_GSIZE_FORMAT
" "
"Audio %p %" G_GSIZE_FORMAT,
item.video_map.data, item.video_map.size,
item.audio_buffer ? item.audio_map.data : NULL,
item.audio_buffer ? item.audio_map.size : 0);
// Set timecodes if provided by upstream
if (item.tc.IsValid() && item.tc.fDBB != 0xffffffff && self->tc_indexes) {
NTV2TimeCodes timecodes;
for (const auto &tc_index : *self->tc_indexes) {
timecodes[tc_index] = item.tc;
}
transfer.SetOutputTimeCodes(timecodes);
}
transfer.SetVideoBuffer((ULWord *)item.video_map.data,
item.video_map.size);
transfer.SetAudioBuffer((ULWord *)item.audio_map.data,
item.audio_map.size);
transfer.SetAncBuffers((ULWord *)item.anc_map.data, item.anc_map.size,
(ULWord *)item.anc_map2.data, item.anc_map2.size);
if (!self->device->device->AutoCirculateTransfer(self->channel,
transfer)) {
GST_WARNING_OBJECT(self, "Failed to transfer frame");
}
gst_buffer_unmap(item.video_buffer, &item.video_map);
gst_buffer_unref(item.video_buffer);
if (item.audio_buffer) {
gst_buffer_unmap(item.audio_buffer, &item.audio_map);
gst_buffer_unref(item.audio_buffer);
}
if (item.anc_buffer) {
gst_buffer_unmap(item.anc_buffer, &item.anc_map);
gst_buffer_unref(item.anc_buffer);
}
if (item.anc_buffer2) {
gst_buffer_unmap(item.anc_buffer2, &item.anc_map2);
gst_buffer_unref(item.anc_buffer2);
}
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);
// Trivial drift calculation
//
// TODO: Should probably take averages over a timespan (say 1 minute)
// into a ringbuffer and calculate a linear regression over them
// FIXME: Add some compensation by dropping/duplicating frames as needed
// but make this configurable
if (frames_rendered_start_time == GST_CLOCK_TIME_NONE &&
frame_stamp.acCurrentFrameTime != 0 &&
transfer_status.acFramesProcessed + transfer_status.acFramesDropped >
self->queue_size &&
clock) {
frames_rendered_start =
transfer_status.acFramesProcessed + transfer_status.acFramesDropped;
GstClockTime now_gst = gst_clock_get_time(clock);
GstClockTime now_sys = g_get_real_time() * 1000;
GstClockTime render_time = frame_stamp.acCurrentFrameTime * 100;
if (render_time < now_sys) {
frames_rendered_start_time = now_gst - (now_sys - render_time);
}
}
if (clock && frames_rendered_start_time != GST_CLOCK_TIME_NONE) {
GstClockTime now_gst = gst_clock_get_time(clock);
GstClockTime now_sys = g_get_real_time() * 1000;
GstClockTime render_time = frame_stamp.acCurrentFrameTime * 100;
GstClockTime sys_diff;
if (now_sys > render_time) {
sys_diff = now_sys - render_time;
} else {
sys_diff = 0;
}
GstClockTime diff = now_gst - frames_rendered_start_time;
if (sys_diff < diff) diff -= sys_diff;
guint64 frames_rendered = (transfer_status.acFramesProcessed +
transfer_status.acFramesDropped) -
frames_rendered_start;
guint64 frames_produced =
gst_util_uint64_scale(diff, self->configured_info.fps_n,
self->configured_info.fps_d * GST_SECOND);
gdouble fps_rendered = ((gdouble)frames_rendered * GST_SECOND) / diff;
GST_TRACE_OBJECT(self,
"Frames rendered %" G_GUINT64_FORMAT
", frames produced %" G_GUINT64_FORMAT
", FPS rendered %lf",
frames_rendered, frames_produced, fps_rendered);
}
g_mutex_lock(&self->queue_lock);
} else {
g_mutex_unlock(&self->queue_lock);
self->device->device->WaitForOutputVerticalInterrupt(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->UnsubscribeOutputVerticalEvent(self->channel);
self->device->device->DisableOutputInterrupt(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->draining) && !self->shutdown) goto restart;
g_mutex_unlock(&self->queue_lock);
gst_clear_object(&clock);
GST_DEBUG_OBJECT(self, "Stopped");
}
Reference in a new issue View git blame Copy permalink