mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
790 lines
19 KiB
Objective-C
790 lines
19 KiB
Objective-C
/*
|
|
* Copyright (C) 2010 Ole André Vadla Ravnås <oravnas@cisco.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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "avfvideosrc.h"
|
|
|
|
#import "bufferfactory.h"
|
|
|
|
#import <AVFoundation/AVFoundation.h>
|
|
#include <gst/video/video.h>
|
|
|
|
#define DEFAULT_DEVICE_INDEX -1
|
|
#define DEFAULT_DO_STATS FALSE
|
|
|
|
#define DEVICE_VIDEO_FORMAT GST_VIDEO_FORMAT_YUY2
|
|
#define DEVICE_YUV_FOURCC "YUY2"
|
|
#define DEVICE_FPS_N 25
|
|
#define DEVICE_FPS_D 1
|
|
|
|
#define BUFFER_QUEUE_SIZE 2
|
|
|
|
GST_DEBUG_CATEGORY (gst_avf_video_src_debug);
|
|
#define GST_CAT_DEFAULT gst_avf_video_src_debug
|
|
|
|
static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS (
|
|
GST_VIDEO_CAPS_YUV (DEVICE_YUV_FOURCC))
|
|
);
|
|
|
|
typedef enum _QueueState {
|
|
NO_BUFFERS = 1,
|
|
HAS_BUFFER_OR_STOP_REQUEST,
|
|
} QueueState;
|
|
|
|
static GstPushSrcClass * parent_class;
|
|
|
|
@interface GstAVFVideoSrcImpl : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate> {
|
|
GstElement *element;
|
|
GstBaseSrc *baseSrc;
|
|
GstPushSrc *pushSrc;
|
|
|
|
gint deviceIndex;
|
|
BOOL doStats;
|
|
|
|
GstAMBufferFactory *bufferFactory;
|
|
AVCaptureSession *session;
|
|
AVCaptureDeviceInput *input;
|
|
AVCaptureVideoDataOutput *output;
|
|
AVCaptureDevice *device;
|
|
|
|
dispatch_queue_t mainQueue;
|
|
dispatch_queue_t workerQueue;
|
|
NSConditionLock *bufQueueLock;
|
|
NSMutableArray *bufQueue;
|
|
BOOL stopRequest;
|
|
|
|
gint width, height;
|
|
GstClockTime duration;
|
|
guint64 offset;
|
|
|
|
GstClockTime lastSampling;
|
|
guint count;
|
|
gint fps;
|
|
}
|
|
|
|
- (id)init;
|
|
- (id)initWithSrc:(GstPushSrc *)src;
|
|
- (void)finalize;
|
|
|
|
@property int deviceIndex;
|
|
@property BOOL doStats;
|
|
@property int fps;
|
|
|
|
- (BOOL)openDevice;
|
|
- (void)closeDevice;
|
|
- (GstCaps *)getCaps;
|
|
- (BOOL)setCaps:(GstCaps *)caps;
|
|
- (BOOL)start;
|
|
- (BOOL)stop;
|
|
- (BOOL)unlock;
|
|
- (BOOL)unlockStop;
|
|
- (BOOL)query:(GstQuery *)query;
|
|
- (GstStateChangeReturn)changeState:(GstStateChange)transition;
|
|
- (GstFlowReturn)create:(GstBuffer **)buf;
|
|
- (void)timestampBuffer:(GstBuffer *)buf;
|
|
- (void)updateStatistics;
|
|
- (void)captureOutput:(AVCaptureOutput *)captureOutput
|
|
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
fromConnection:(AVCaptureConnection *)connection;
|
|
|
|
- (void)waitForMainQueueToDrain;
|
|
- (void)waitForWorkerQueueToDrain;
|
|
- (void)waitForQueueToDrain:(dispatch_queue_t)dispatchQueue;
|
|
|
|
@end
|
|
|
|
@implementation GstAVFVideoSrcImpl
|
|
|
|
- (id)init
|
|
{
|
|
return [self initWithSrc:NULL];
|
|
}
|
|
|
|
- (id)initWithSrc:(GstPushSrc *)src
|
|
{
|
|
if ((self = [super init])) {
|
|
element = GST_ELEMENT_CAST (src);
|
|
baseSrc = GST_BASE_SRC_CAST (src);
|
|
pushSrc = src;
|
|
|
|
deviceIndex = DEFAULT_DEVICE_INDEX;
|
|
|
|
mainQueue = dispatch_get_main_queue ();
|
|
workerQueue =
|
|
dispatch_queue_create ("org.freedesktop.gstreamer.avfvideosrc", NULL);
|
|
|
|
gst_base_src_set_live (baseSrc, TRUE);
|
|
gst_base_src_set_format (baseSrc, GST_FORMAT_TIME);
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)finalize
|
|
{
|
|
mainQueue = NULL;
|
|
dispatch_release (workerQueue);
|
|
workerQueue = NULL;
|
|
|
|
[super finalize];
|
|
}
|
|
|
|
@synthesize deviceIndex, doStats, fps;
|
|
|
|
- (BOOL)openDevice
|
|
{
|
|
BOOL success = NO, *successPtr = &success;
|
|
GError *error;
|
|
|
|
bufferFactory = [[GstAMBufferFactory alloc] initWithError:&error];
|
|
if (bufferFactory == nil) {
|
|
GST_ELEMENT_ERROR (element, RESOURCE, FAILED, ("API error"),
|
|
("%s", error->message));
|
|
g_clear_error (&error);
|
|
return NO;
|
|
}
|
|
|
|
dispatch_async (mainQueue, ^{
|
|
NSString *mediaType = AVMediaTypeVideo;
|
|
NSError *err;
|
|
|
|
if (deviceIndex == -1) {
|
|
device = [AVCaptureDevice defaultDeviceWithMediaType:mediaType];
|
|
if (device == nil) {
|
|
GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND,
|
|
("No video capture devices found"), (NULL));
|
|
return;
|
|
}
|
|
} else {
|
|
NSArray *devices = [AVCaptureDevice devicesWithMediaType:mediaType];
|
|
if (deviceIndex >= [devices count]) {
|
|
GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND,
|
|
("Invalid video capture device index"), (NULL));
|
|
return;
|
|
}
|
|
device = [devices objectAtIndex:deviceIndex];
|
|
}
|
|
g_assert (device != nil);
|
|
[device retain];
|
|
|
|
GST_INFO ("Opening '%s'", [[device localizedName] UTF8String]);
|
|
|
|
input = [AVCaptureDeviceInput deviceInputWithDevice:device
|
|
error:&err];
|
|
if (input == nil) {
|
|
GST_ELEMENT_ERROR (element, RESOURCE, BUSY,
|
|
("Failed to open device: %s",
|
|
[[err localizedDescription] UTF8String]),
|
|
(NULL));
|
|
[device release];
|
|
device = nil;
|
|
return;
|
|
}
|
|
[input retain];
|
|
|
|
output = [[AVCaptureVideoDataOutput alloc] init];
|
|
[output setSampleBufferDelegate:self
|
|
queue:workerQueue];
|
|
output.alwaysDiscardsLateVideoFrames = YES;
|
|
output.minFrameDuration = kCMTimeZero; /* unlimited */
|
|
output.videoSettings = nil; /* device native format */
|
|
|
|
session = [[AVCaptureSession alloc] init];
|
|
[session addInput:input];
|
|
[session addOutput:output];
|
|
|
|
*successPtr = YES;
|
|
});
|
|
[self waitForMainQueueToDrain];
|
|
|
|
if (!success) {
|
|
[bufferFactory release];
|
|
bufferFactory = nil;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
- (void)closeDevice
|
|
{
|
|
dispatch_async (mainQueue, ^{
|
|
g_assert (![session isRunning]);
|
|
|
|
[session removeInput:input];
|
|
[session removeOutput:output];
|
|
|
|
[session release];
|
|
session = nil;
|
|
|
|
[input release];
|
|
input = nil;
|
|
|
|
[output release];
|
|
output = nil;
|
|
|
|
[device release];
|
|
device = nil;
|
|
});
|
|
[self waitForMainQueueToDrain];
|
|
|
|
[bufferFactory release];
|
|
bufferFactory = nil;
|
|
}
|
|
|
|
#define GST_AVF_CAPS_NEW(w, h) \
|
|
(gst_video_format_new_caps (DEVICE_VIDEO_FORMAT, w, h, \
|
|
DEVICE_FPS_N, DEVICE_FPS_D, 1, 1))
|
|
|
|
- (GstCaps *)getCaps
|
|
{
|
|
GstCaps *result;
|
|
|
|
if (session == nil)
|
|
return NULL; /* BaseSrc will return template caps */
|
|
|
|
result = GST_AVF_CAPS_NEW (192, 144);
|
|
if ([session canSetSessionPreset:AVCaptureSessionPresetMedium])
|
|
gst_caps_merge (result, GST_AVF_CAPS_NEW (480, 360));
|
|
if ([session canSetSessionPreset:AVCaptureSessionPreset640x480])
|
|
gst_caps_merge (result, GST_AVF_CAPS_NEW (640, 480));
|
|
if ([session canSetSessionPreset:AVCaptureSessionPreset1280x720])
|
|
gst_caps_merge (result, GST_AVF_CAPS_NEW (1280, 720));
|
|
|
|
return result;
|
|
}
|
|
|
|
- (BOOL)setCaps:(GstCaps *)caps
|
|
{
|
|
GstStructure *s;
|
|
|
|
s = gst_caps_get_structure (caps, 0);
|
|
gst_structure_get_int (s, "width", &width);
|
|
gst_structure_get_int (s, "height", &height);
|
|
|
|
dispatch_async (mainQueue, ^{
|
|
g_assert (![session isRunning]);
|
|
|
|
switch (width) {
|
|
case 192:
|
|
session.sessionPreset = AVCaptureSessionPresetLow;
|
|
break;
|
|
case 480:
|
|
session.sessionPreset = AVCaptureSessionPresetMedium;
|
|
break;
|
|
case 640:
|
|
session.sessionPreset = AVCaptureSessionPreset640x480;
|
|
break;
|
|
case 1280:
|
|
session.sessionPreset = AVCaptureSessionPreset1280x720;
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
[session startRunning];
|
|
});
|
|
[self waitForMainQueueToDrain];
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)start
|
|
{
|
|
bufQueueLock = [[NSConditionLock alloc] initWithCondition:NO_BUFFERS];
|
|
bufQueue = [[NSMutableArray alloc] initWithCapacity:BUFFER_QUEUE_SIZE];
|
|
stopRequest = NO;
|
|
|
|
duration = gst_util_uint64_scale (GST_SECOND, DEVICE_FPS_D, DEVICE_FPS_N);
|
|
offset = 0;
|
|
|
|
lastSampling = GST_CLOCK_TIME_NONE;
|
|
count = 0;
|
|
fps = -1;
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)stop
|
|
{
|
|
dispatch_async (mainQueue, ^{ [session stopRunning]; });
|
|
[self waitForMainQueueToDrain];
|
|
[self waitForWorkerQueueToDrain];
|
|
|
|
[bufQueueLock release];
|
|
bufQueueLock = nil;
|
|
[bufQueue release];
|
|
bufQueue = nil;
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)query:(GstQuery *)query
|
|
{
|
|
BOOL result = NO;
|
|
|
|
if (GST_QUERY_TYPE (query) == GST_QUERY_LATENCY) {
|
|
if (device != nil) {
|
|
GstClockTime min_latency, max_latency;
|
|
|
|
min_latency = max_latency = duration; /* for now */
|
|
result = YES;
|
|
|
|
GST_DEBUG_OBJECT (element, "reporting latency of min %" GST_TIME_FORMAT
|
|
" max %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
|
|
gst_query_set_latency (query, TRUE, min_latency, max_latency);
|
|
}
|
|
} else {
|
|
result = GST_BASE_SRC_CLASS (parent_class)->query (baseSrc, query);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
- (BOOL)unlock
|
|
{
|
|
[bufQueueLock lock];
|
|
stopRequest = YES;
|
|
[bufQueueLock unlockWithCondition:HAS_BUFFER_OR_STOP_REQUEST];
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)unlockStop
|
|
{
|
|
[bufQueueLock lock];
|
|
stopRequest = NO;
|
|
[bufQueueLock unlock];
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (GstStateChangeReturn)changeState:(GstStateChange)transition
|
|
{
|
|
GstStateChangeReturn ret;
|
|
|
|
if (transition == GST_STATE_CHANGE_NULL_TO_READY) {
|
|
if (![self openDevice])
|
|
return GST_STATE_CHANGE_FAILURE;
|
|
}
|
|
|
|
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
|
|
|
|
if (transition == GST_STATE_CHANGE_READY_TO_NULL)
|
|
[self closeDevice];
|
|
|
|
return ret;
|
|
}
|
|
|
|
- (void)captureOutput:(AVCaptureOutput *)captureOutput
|
|
didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
|
|
fromConnection:(AVCaptureConnection *)connection
|
|
{
|
|
[bufQueueLock lock];
|
|
|
|
if (stopRequest) {
|
|
[bufQueueLock unlock];
|
|
return;
|
|
}
|
|
|
|
if ([bufQueue count] == BUFFER_QUEUE_SIZE)
|
|
[bufQueue removeLastObject];
|
|
|
|
[bufQueue insertObject:(id)sampleBuffer
|
|
atIndex:0];
|
|
|
|
[bufQueueLock unlockWithCondition:HAS_BUFFER_OR_STOP_REQUEST];
|
|
}
|
|
|
|
- (GstFlowReturn)create:(GstBuffer **)buf
|
|
{
|
|
CMSampleBufferRef sbuf;
|
|
|
|
[bufQueueLock lockWhenCondition:HAS_BUFFER_OR_STOP_REQUEST];
|
|
if (stopRequest) {
|
|
[bufQueueLock unlock];
|
|
return GST_FLOW_WRONG_STATE;
|
|
}
|
|
|
|
sbuf = (CMSampleBufferRef) [bufQueue lastObject];
|
|
CFRetain (sbuf);
|
|
[bufQueue removeLastObject];
|
|
[bufQueueLock unlockWithCondition:
|
|
([bufQueue count] == 0) ? NO_BUFFERS : HAS_BUFFER_OR_STOP_REQUEST];
|
|
|
|
*buf = [bufferFactory createGstBufferForSampleBuffer:sbuf];
|
|
CFRelease (sbuf);
|
|
|
|
[self timestampBuffer:*buf];
|
|
|
|
if (doStats)
|
|
[self updateStatistics];
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
- (void)timestampBuffer:(GstBuffer *)buf
|
|
{
|
|
GstClock *clock;
|
|
GstClockTime timestamp;
|
|
|
|
GST_OBJECT_LOCK (element);
|
|
clock = GST_ELEMENT_CLOCK (element);
|
|
if (clock != NULL) {
|
|
gst_object_ref (clock);
|
|
timestamp = element->base_time;
|
|
} else {
|
|
timestamp = GST_CLOCK_TIME_NONE;
|
|
}
|
|
GST_OBJECT_UNLOCK (element);
|
|
|
|
if (clock != NULL) {
|
|
timestamp = gst_clock_get_time (clock) - timestamp;
|
|
if (timestamp > duration)
|
|
timestamp -= duration;
|
|
else
|
|
timestamp = 0;
|
|
|
|
gst_object_unref (clock);
|
|
clock = NULL;
|
|
}
|
|
|
|
GST_BUFFER_OFFSET (buf) = offset++;
|
|
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET (buf) + 1;
|
|
GST_BUFFER_TIMESTAMP (buf) = timestamp;
|
|
GST_BUFFER_DURATION (buf) = duration;
|
|
}
|
|
|
|
- (void)updateStatistics
|
|
{
|
|
GstClock *clock;
|
|
|
|
GST_OBJECT_LOCK (element);
|
|
clock = GST_ELEMENT_CLOCK (element);
|
|
if (clock != NULL)
|
|
gst_object_ref (clock);
|
|
GST_OBJECT_UNLOCK (element);
|
|
|
|
if (clock != NULL) {
|
|
GstClockTime now = gst_clock_get_time (clock);
|
|
gst_object_unref (clock);
|
|
|
|
count++;
|
|
|
|
if (GST_CLOCK_TIME_IS_VALID (lastSampling)) {
|
|
if (now - lastSampling >= GST_SECOND) {
|
|
GST_OBJECT_LOCK (element);
|
|
fps = count;
|
|
GST_OBJECT_UNLOCK (element);
|
|
|
|
g_object_notify (G_OBJECT (element), "fps");
|
|
|
|
lastSampling = now;
|
|
count = 0;
|
|
}
|
|
} else {
|
|
lastSampling = now;
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)waitForMainQueueToDrain
|
|
{
|
|
[self waitForQueueToDrain:mainQueue];
|
|
}
|
|
|
|
- (void)waitForWorkerQueueToDrain
|
|
{
|
|
[self waitForQueueToDrain:workerQueue];
|
|
}
|
|
|
|
- (void)waitForQueueToDrain:(dispatch_queue_t)dispatchQueue
|
|
{
|
|
dispatch_sync (dispatchQueue, ^{});
|
|
}
|
|
|
|
@end
|
|
|
|
/*
|
|
* Glue code
|
|
*/
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_DEVICE_INDEX,
|
|
PROP_DO_STATS,
|
|
PROP_FPS
|
|
};
|
|
|
|
GST_BOILERPLATE (GstAVFVideoSrc, gst_avf_video_src, GstPushSrc,
|
|
GST_TYPE_PUSH_SRC);
|
|
|
|
static void gst_avf_video_src_finalize (GObject * obj);
|
|
static void gst_avf_video_src_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec);
|
|
static void gst_avf_video_src_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec);
|
|
static GstStateChangeReturn gst_avf_video_src_change_state (
|
|
GstElement * element, GstStateChange transition);
|
|
static GstCaps * gst_avf_video_src_get_caps (GstBaseSrc * basesrc);
|
|
static gboolean gst_avf_video_src_set_caps (GstBaseSrc * basesrc,
|
|
GstCaps * caps);
|
|
static gboolean gst_avf_video_src_start (GstBaseSrc * basesrc);
|
|
static gboolean gst_avf_video_src_stop (GstBaseSrc * basesrc);
|
|
static gboolean gst_avf_video_src_query (GstBaseSrc * basesrc,
|
|
GstQuery * query);
|
|
static gboolean gst_avf_video_src_unlock (GstBaseSrc * basesrc);
|
|
static gboolean gst_avf_video_src_unlock_stop (GstBaseSrc * basesrc);
|
|
static GstFlowReturn gst_avf_video_src_create (GstPushSrc * pushsrc,
|
|
GstBuffer ** buf);
|
|
|
|
static void
|
|
gst_avf_video_src_base_init (gpointer gclass)
|
|
{
|
|
GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
|
|
|
|
gst_element_class_set_details_simple (element_class,
|
|
"Video Source (AVFoundation)", "Source/Video",
|
|
"Reads frames from an iOS AVFoundation device",
|
|
"Ole André Vadla Ravnås <oravnas@cisco.com>");
|
|
|
|
gst_element_class_add_pad_template (element_class,
|
|
gst_static_pad_template_get (&src_template));
|
|
}
|
|
|
|
static void
|
|
gst_avf_video_src_class_init (GstAVFVideoSrcClass * klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
|
|
GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
|
|
GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass);
|
|
|
|
gobject_class->finalize = gst_avf_video_src_finalize;
|
|
gobject_class->get_property = gst_avf_video_src_get_property;
|
|
gobject_class->set_property = gst_avf_video_src_set_property;
|
|
|
|
gstelement_class->change_state = gst_avf_video_src_change_state;
|
|
|
|
gstbasesrc_class->get_caps = gst_avf_video_src_get_caps;
|
|
gstbasesrc_class->set_caps = gst_avf_video_src_set_caps;
|
|
gstbasesrc_class->start = gst_avf_video_src_start;
|
|
gstbasesrc_class->stop = gst_avf_video_src_stop;
|
|
gstbasesrc_class->query = gst_avf_video_src_query;
|
|
gstbasesrc_class->unlock = gst_avf_video_src_unlock;
|
|
gstbasesrc_class->unlock_stop = gst_avf_video_src_unlock_stop;
|
|
|
|
gstpushsrc_class->create = gst_avf_video_src_create;
|
|
|
|
g_object_class_install_property (gobject_class, PROP_DEVICE_INDEX,
|
|
g_param_spec_int ("device-index", "Device Index",
|
|
"The zero-based device index",
|
|
-1, G_MAXINT, DEFAULT_DEVICE_INDEX,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_class, PROP_DO_STATS,
|
|
g_param_spec_boolean ("do-stats", "Enable statistics",
|
|
"Enable logging of statistics", DEFAULT_DO_STATS,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
g_object_class_install_property (gobject_class, PROP_FPS,
|
|
g_param_spec_int ("fps", "Frames per second",
|
|
"Last measured framerate, if statistics are enabled",
|
|
-1, G_MAXINT, -1, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
GST_DEBUG_CATEGORY_INIT (gst_avf_video_src_debug, "avfvideosrc",
|
|
0, "iOS AVFoundation video source");
|
|
}
|
|
|
|
#define OBJC_CALLOUT_BEGIN() \
|
|
NSAutoreleasePool *pool; \
|
|
\
|
|
pool = [[NSAutoreleasePool alloc] init]
|
|
#define OBJC_CALLOUT_END() \
|
|
[pool release]
|
|
|
|
static void
|
|
gst_avf_video_src_init (GstAVFVideoSrc * src, GstAVFVideoSrcClass * gclass)
|
|
{
|
|
OBJC_CALLOUT_BEGIN ();
|
|
src->impl = [[GstAVFVideoSrcImpl alloc] initWithSrc:GST_PUSH_SRC (src)];
|
|
OBJC_CALLOUT_END ();
|
|
}
|
|
|
|
static void
|
|
gst_avf_video_src_finalize (GObject * obj)
|
|
{
|
|
OBJC_CALLOUT_BEGIN ();
|
|
[GST_AVF_VIDEO_SRC_IMPL (obj) release];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (obj);
|
|
}
|
|
|
|
static void
|
|
gst_avf_video_src_get_property (GObject * object, guint prop_id, GValue * value,
|
|
GParamSpec * pspec)
|
|
{
|
|
GstAVFVideoSrcImpl *impl = GST_AVF_VIDEO_SRC_IMPL (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DEVICE_INDEX:
|
|
g_value_set_int (value, impl.deviceIndex);
|
|
break;
|
|
case PROP_DO_STATS:
|
|
g_value_set_boolean (value, impl.doStats);
|
|
break;
|
|
case PROP_FPS:
|
|
GST_OBJECT_LOCK (object);
|
|
g_value_set_int (value, impl.fps);
|
|
GST_OBJECT_UNLOCK (object);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_avf_video_src_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAVFVideoSrcImpl *impl = GST_AVF_VIDEO_SRC_IMPL (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DEVICE_INDEX:
|
|
impl.deviceIndex = g_value_get_int (value);
|
|
break;
|
|
case PROP_DO_STATS:
|
|
impl.doStats = g_value_get_boolean (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GstStateChangeReturn
|
|
gst_avf_video_src_change_state (GstElement * element, GstStateChange transition)
|
|
{
|
|
GstStateChangeReturn ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (element) changeState: transition];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_avf_video_src_get_caps (GstBaseSrc * basesrc)
|
|
{
|
|
GstCaps *ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) getCaps];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_set_caps (GstBaseSrc * basesrc, GstCaps * caps)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) setCaps:caps];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_start (GstBaseSrc * basesrc)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) start];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_stop (GstBaseSrc * basesrc)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) stop];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_query (GstBaseSrc * basesrc, GstQuery * query)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) query:query];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_unlock (GstBaseSrc * basesrc)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) unlock];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_avf_video_src_unlock_stop (GstBaseSrc * basesrc)
|
|
{
|
|
gboolean ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (basesrc) unlockStop];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_avf_video_src_create (GstPushSrc * pushsrc, GstBuffer ** buf)
|
|
{
|
|
GstFlowReturn ret;
|
|
|
|
OBJC_CALLOUT_BEGIN ();
|
|
ret = [GST_AVF_VIDEO_SRC_IMPL (pushsrc) create: buf];
|
|
OBJC_CALLOUT_END ();
|
|
|
|
return ret;
|
|
}
|