static gboolean gst_dtmf_src_negotiate (GstBaseSrc * basesrc) { GstDTMFSrc *dtmfsrc = GST_DTMF_SRC (basesrc); GstCaps *caps; GstStructure *s; gboolean ret; caps = gst_pad_get_allowed_caps (GST_BASE_SRC_PAD (basesrc)); if (!caps) caps = gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (basesrc))); if (gst_caps_is_empty (caps)) return FALSE; gst_caps_truncate (caps); s = gst_caps_get_structure (caps, 0); gst_structure_fixate_field_nearest_int (s, "rate", DEFAULT_SAMPLE_RATE); if (!gst_structure_get_int (s, "rate", &dtmfsrc->sample_rate)) { GST_ERROR_OBJECT (dtmfsrc, "Could not get rate"); gst_caps_unref (caps); return FALSE; } ret = gst_pad_set_caps (GST_BASE_SRC_PAD (basesrc), caps); gst_caps_unref (caps); return ret; }
static GstCaps * gst_decklink_audio_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter) { GstDecklinkAudioSrc *self = GST_DECKLINK_AUDIO_SRC_CAST (bsrc); GstCaps *caps; // We don't support renegotiation caps = gst_pad_get_current_caps (GST_BASE_SRC_PAD (bsrc)); if (!caps) { GstCaps *channel_filter, *templ; templ = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc)); channel_filter = gst_caps_new_simple ("audio/x-raw", "channels", G_TYPE_INT, self->channels, NULL); caps = gst_caps_intersect (channel_filter, templ); gst_caps_unref (channel_filter); gst_caps_unref (templ); } if (filter) { GstCaps *tmp = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (caps); caps = tmp; } return caps; }
static GstFlowReturn gst_win_inet_src_create (GstPushSrc * pushsrc, GstBuffer ** buffer) { GstWinInetSrc *self = GST_WIN_INET_SRC (pushsrc); GstBaseSrc *basesrc = GST_BASE_SRC (pushsrc); GstBuffer *buf = NULL; GstFlowReturn ret = GST_FLOW_OK; DWORD bytes_read = 0; do { GstCaps *caps = GST_PAD_CAPS (GST_BASE_SRC_PAD (self)); if (self->icy_caps != NULL) caps = self->icy_caps; ret = gst_pad_alloc_buffer (GST_BASE_SRC_PAD (basesrc), self->cur_offset, basesrc->blocksize, caps, &buf); if (G_LIKELY (ret == GST_FLOW_OK)) { if (InternetReadFile (self->url, GST_BUFFER_DATA (buf), basesrc->blocksize, &bytes_read)) { if (bytes_read == 0) { if (self->poll_mode) { if (gst_win_inet_src_open (self)) { gst_buffer_unref (buf); buf = NULL; } else { ret = GST_FLOW_ERROR; } } else { GST_ERROR_OBJECT (self, "short read (eof?)"); ret = GST_FLOW_UNEXPECTED; } } } else { GST_ERROR_OBJECT (self, "InternetReadFile failed: 0x%08lx", GetLastError ()); ret = GST_FLOW_ERROR; } } } while (bytes_read == 0 && ret == GST_FLOW_OK); if (ret == GST_FLOW_OK) { GST_BUFFER_SIZE (buf) = bytes_read; self->cur_offset += bytes_read; *buffer = buf; } else { if (buf != NULL) gst_buffer_unref (buf); } return ret; }
static int gst_dv1394src_iec61883_receive (unsigned char *data, int len, int complete, void *cbdata) { GstDV1394Src *dv1394src = GST_DV1394SRC (cbdata); if (G_UNLIKELY (!GST_PAD_CAPS (GST_BASE_SRC_PAD (dv1394src)))) { GstCaps *caps; unsigned char *p = data; // figure format (NTSC/PAL) if (p[3] & 0x80) { // PAL dv1394src->frame_size = PAL_FRAMESIZE; dv1394src->frame_rate = PAL_FRAMERATE; GST_DEBUG ("PAL data"); caps = gst_caps_new_simple ("video/x-dv", "format", G_TYPE_STRING, "PAL", "systemstream", G_TYPE_BOOLEAN, TRUE, NULL); } else { // NTSC (untested) dv1394src->frame_size = NTSC_FRAMESIZE; dv1394src->frame_rate = NTSC_FRAMERATE; GST_DEBUG ("NTSC data [untested] - please report success/failure to <*****@*****.**>"); caps = gst_caps_new_simple ("video/x-dv", "format", G_TYPE_STRING, "NTSC", "systemstream", G_TYPE_BOOLEAN, TRUE, NULL); } gst_pad_set_caps (GST_BASE_SRC_PAD (dv1394src), caps); gst_caps_unref (caps); } dv1394src->frame = NULL; if (G_LIKELY ((dv1394src->frame_sequence + 1) % (dv1394src->skip + dv1394src->consecutive) < dv1394src->consecutive)) { if (complete && len == dv1394src->frame_size) { guint8 *bufdata; GstBuffer *buf; buf = gst_buffer_new_and_alloc (dv1394src->frame_size); GST_BUFFER_OFFSET (buf) = dv1394src->frame_sequence; bufdata = GST_BUFFER_DATA (buf); memcpy (bufdata, data, len); dv1394src->buf = buf; } } dv1394src->frame_sequence++; return 0; }
static GstFlowReturn gst_neonhttp_src_create (GstPushSrc * psrc, GstBuffer ** outbuf) { GstNeonhttpSrc *src; GstBaseSrc *basesrc; GstFlowReturn ret; gint read; src = GST_NEONHTTP_SRC (psrc); basesrc = GST_BASE_SRC_CAST (psrc); /* The caller should know the number of bytes and not read beyond EOS. */ if (G_UNLIKELY (src->eos)) goto eos; /* Create the buffer. */ ret = gst_pad_alloc_buffer (GST_BASE_SRC_PAD (basesrc), basesrc->segment.last_stop, basesrc->blocksize, src->icy_caps ? src->icy_caps : GST_PAD_CAPS (GST_BASE_SRC_PAD (basesrc)), outbuf); if (G_UNLIKELY (ret != GST_FLOW_OK)) goto done; read = gst_neonhttp_src_request_dispatch (src, *outbuf); if (G_UNLIKELY (read < 0)) goto read_error; GST_LOG_OBJECT (src, "returning %u bytes", GST_BUFFER_SIZE (*outbuf)); done: return ret; /* ERRORS */ eos: { GST_DEBUG_OBJECT (src, "EOS reached"); return GST_FLOW_UNEXPECTED; } read_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not read any bytes (%i, %s)", read, ne_get_error (src->session))); gst_buffer_unref (*outbuf); *outbuf = NULL; return GST_FLOW_ERROR; } }
static GstCaps * gst_data_uri_src_get_caps (GstBaseSrc * basesrc, GstCaps * filter) { GstDataURISrc *src = GST_DATA_URI_SRC (basesrc); GstCaps *caps; GST_OBJECT_LOCK (src); if (gst_pad_has_current_caps (GST_BASE_SRC_PAD (basesrc))) caps = gst_pad_get_current_caps (GST_BASE_SRC_PAD (basesrc)); else caps = gst_caps_new_any (); GST_OBJECT_UNLOCK (src); return caps; }
static void gst_aravis_init (GstAravis *gst_aravis, GstAravisClass *g_class) { GstPad *pad = GST_BASE_SRC_PAD (gst_aravis); gst_pad_set_fixatecaps_function (pad, gst_aravis_fixate_caps); gst_base_src_set_live (GST_BASE_SRC (gst_aravis), TRUE); gst_base_src_set_format (GST_BASE_SRC (gst_aravis), GST_FORMAT_TIME); gst_aravis->camera_name = NULL; gst_aravis->gain = -1; gst_aravis->gain_auto = FALSE; gst_aravis->exposure_time_us = -1; gst_aravis->exposure_auto = FALSE; gst_aravis->offset_x = 0; gst_aravis->offset_y = 0; gst_aravis->h_binning = -1; gst_aravis->v_binning = -1; gst_aravis->packet_resend = TRUE; gst_aravis->payload = 0; gst_aravis->buffer_timeout_us = GST_ARAVIS_BUFFER_TIMEOUT_DEFAULT; gst_aravis->camera = NULL; gst_aravis->stream = NULL; gst_aravis->all_caps = NULL; gst_aravis->fixed_caps = NULL; }
static void gst_multi_file_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiFileSrc *src = GST_MULTI_FILE_SRC (object); switch (prop_id) { case ARG_LOCATION: gst_multi_file_src_set_location (src, g_value_get_string (value)); break; case ARG_INDEX: src->index = g_value_get_int (value); break; case ARG_CAPS: { const GstCaps *caps = gst_value_get_caps (value); GstCaps *new_caps; if (caps == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (caps); } gst_caps_replace (&src->caps, new_caps); gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_audio_test_src_init (GstAudioTestSrc * src, GstAudioTestSrcClass * g_class) { GstPad *pad = GST_BASE_SRC_PAD (src); gst_pad_set_fixatecaps_function (pad, gst_audio_test_src_src_fixate); src->samplerate = 44100; src->format = GST_AUDIO_TEST_SRC_FORMAT_NONE; src->volume = DEFAULT_VOLUME; src->freq = DEFAULT_FREQ; /* we operate in time */ gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME); gst_base_src_set_live (GST_BASE_SRC (src), DEFAULT_IS_LIVE); src->samples_per_buffer = DEFAULT_SAMPLES_PER_BUFFER; src->generate_samples_per_buffer = src->samples_per_buffer; src->timestamp_offset = DEFAULT_TIMESTAMP_OFFSET; src->can_activate_pull = DEFAULT_CAN_ACTIVATE_PULL; src->gen = NULL; src->wave = DEFAULT_WAVE; gst_base_src_set_blocksize (GST_BASE_SRC (src), -1); }
static GstCaps * gst_v4l2src_get_caps (GstBaseSrc * src) { GstV4l2Src *v4l2src = GST_V4L2SRC (src); GstCaps *ret; GSList *walk; GSList *formats; if (!GST_V4L2_IS_OPEN (v4l2src->v4l2object)) { /* FIXME: copy? */ return gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (v4l2src))); } if (v4l2src->probed_caps) return gst_caps_ref (v4l2src->probed_caps); formats = gst_v4l2_object_get_format_list (v4l2src->v4l2object); ret = gst_caps_new_empty (); for (walk = formats; walk; walk = walk->next) { struct v4l2_fmtdesc *format; GstStructure *template;
static void gst_dv1394src_init (GstDV1394Src * dv1394src, GstDV1394SrcClass * klass) { GstPad *srcpad = GST_BASE_SRC_PAD (dv1394src); gst_base_src_set_live (GST_BASE_SRC (dv1394src), TRUE); gst_base_src_set_format (GST_BASE_SRC (dv1394src), GST_FORMAT_TIME); gst_base_src_set_do_timestamp (GST_BASE_SRC (dv1394src), TRUE); gst_pad_use_fixed_caps (srcpad); dv1394src->port = DEFAULT_PORT; dv1394src->channel = DEFAULT_CHANNEL; dv1394src->consecutive = DEFAULT_CONSECUTIVE; dv1394src->skip = DEFAULT_SKIP; dv1394src->drop_incomplete = DEFAULT_DROP_INCOMPLETE; dv1394src->use_avc = DEFAULT_USE_AVC; dv1394src->guid = DEFAULT_GUID; dv1394src->uri = g_strdup_printf ("dv://%d", dv1394src->port); dv1394src->device_name = g_strdup_printf ("Default"); READ_SOCKET (dv1394src) = -1; WRITE_SOCKET (dv1394src) = -1; /* initialized when first header received */ dv1394src->frame_size = 0; dv1394src->buf = NULL; dv1394src->frame = NULL; dv1394src->frame_sequence = 0; dv1394src->provided_clock = gst_1394_clock_new ("dv1394clock"); }
static GstCaps * gst_v4l2src_get_caps (GstBaseSrc * src, GstCaps * filter) { GstV4l2Src *v4l2src; GstV4l2Object *obj; GstCaps *ret; GSList *walk; GSList *formats; v4l2src = GST_V4L2SRC (src); obj = v4l2src->v4l2object; if (!GST_V4L2_IS_OPEN (obj)) { return gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (v4l2src)); } if (v4l2src->probed_caps) return gst_caps_ref (v4l2src->probed_caps); formats = gst_v4l2_object_get_format_list (obj); ret = gst_caps_new_empty (); for (walk = formats; walk; walk = walk->next) { struct v4l2_fmtdesc *format; GstStructure *template;
static GstCaps * gst_dshowvideosrc_get_caps (GstBaseSrc * basesrc, GstCaps * filter) { GstDshowVideoSrc *src = GST_DSHOWVIDEOSRC (basesrc); GstCaps *caps; if (src->caps) { caps = gst_caps_ref (src->caps); } else { caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (src)); } if (caps) { GstCaps *filtcaps; if (filter) { filtcaps = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); } else { filtcaps = gst_caps_ref (caps); } gst_caps_unref (caps); return filtcaps; } return NULL; }
static void gst_multi_file_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMultiFileSrc *src = GST_MULTI_FILE_SRC (object); switch (prop_id) { case PROP_LOCATION: gst_multi_file_src_set_location (src, g_value_get_string (value)); break; case PROP_INDEX: GST_OBJECT_LOCK (src); /* index was really meant to be read-only, but for backwards-compatibility * we set start_index to make it work as it used to */ if (!GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_FLAG_STARTED)) src->start_index = g_value_get_int (value); else src->index = g_value_get_int (value); GST_OBJECT_UNLOCK (src); break; case PROP_START_INDEX: src->start_index = g_value_get_int (value); break; case PROP_STOP_INDEX: src->stop_index = g_value_get_int (value); break; case PROP_CAPS: { GstStructure *st = NULL; const GstCaps *caps = gst_value_get_caps (value); GstCaps *new_caps; if (caps == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (caps); } gst_caps_replace (&src->caps, new_caps); gst_pad_set_caps (GST_BASE_SRC_PAD (src), new_caps); if (new_caps && gst_caps_get_size (new_caps) == 1 && (st = gst_caps_get_structure (new_caps, 0)) && gst_structure_get_fraction (st, "framerate", &src->fps_n, &src->fps_d)) { GST_INFO_OBJECT (src, "Seting framerate to %d/%d", src->fps_n, src->fps_d); } else { src->fps_n = -1; src->fps_d = -1; } } break; case PROP_LOOP: src->loop = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * gst_genicamsrc_get_caps (GstBaseSrc * bsrc, GstCaps * filter) { GstGenicamSrc *src = GST_GENICAM_SRC (bsrc); GstCaps *caps; if (src->hDS == NULL) { caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (src)); } else { caps = gst_caps_copy (src->caps); } GST_DEBUG_OBJECT (src, "The caps before filtering are %" GST_PTR_FORMAT, caps); if (filter && caps) { GstCaps *tmp = gst_caps_intersect (caps, filter); gst_caps_unref (caps); caps = tmp; } GST_DEBUG_OBJECT (src, "The caps after filtering are %" GST_PTR_FORMAT, caps); return caps; }
static GstFlowReturn gst_dc1394_create (GstPushSrc * psrc, GstBuffer ** buffer) { GstDc1394 *src; GstBuffer *outbuf; GstCaps *caps; dc1394video_frame_t *frame[1]; GstFlowReturn res = GST_FLOW_OK; dc1394error_t err; src = GST_DC1394 (psrc); err = dc1394_capture_dequeue (src->camera, DC1394_CAPTURE_POLICY_WAIT, frame); if (err != DC1394_SUCCESS) { GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("failed to dequeue frame"), ("failed to dequeue frame")); goto error; } outbuf = gst_buffer_new_and_alloc (frame[0]->image_bytes); memcpy (GST_BUFFER_MALLOCDATA (outbuf), (guchar *) frame[0]->image, frame[0]->image_bytes * sizeof (guchar)); GST_BUFFER_DATA (outbuf) = GST_BUFFER_MALLOCDATA (outbuf); caps = gst_pad_get_caps (GST_BASE_SRC_PAD (psrc)); gst_buffer_set_caps (outbuf, caps); gst_caps_unref (caps); GST_BUFFER_TIMESTAMP (outbuf) = src->timestamp_offset + src->running_time; if (src->rate_numerator != 0) { GST_BUFFER_DURATION (outbuf) = gst_util_uint64_scale_int (GST_SECOND, src->rate_denominator, src->rate_numerator); } src->n_frames++; if (src->rate_numerator != 0) { src->running_time = gst_util_uint64_scale_int (src->n_frames * GST_SECOND, src->rate_denominator, src->rate_numerator); } if (dc1394_capture_enqueue (src->camera, frame[0]) != DC1394_SUCCESS) { GST_ELEMENT_ERROR (src, RESOURCE, FAILED, ("failed to enqueue frame"), ("failed to enqueue frame")); goto error; } *buffer = outbuf; return res; error: { return GST_FLOW_ERROR; } }
static gboolean gst_dshowvideosrc_push_buffer (guint8 * buffer, guint size, gpointer src_object, GstClockTime duration) { GstDshowVideoSrc *src = GST_DSHOWVIDEOSRC (src_object); GstBuffer *buf = NULL; IPin *pPin = NULL; HRESULT hres = S_FALSE; AM_MEDIA_TYPE *pMediaType = NULL; if (!buffer || size == 0 || !src) { return FALSE; } /* create a new buffer assign to it the clock time as timestamp */ buf = gst_buffer_new_and_alloc (size); GST_BUFFER_SIZE (buf) = size; GstClock *clock = gst_element_get_clock (GST_ELEMENT (src)); GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_DIFF (gst_element_get_base_time (GST_ELEMENT (src)), gst_clock_get_time (clock)); gst_object_unref (clock); GST_BUFFER_DURATION (buf) = duration; if (src->is_rgb) { /* FOR RGB directshow decoder will return bottom-up BITMAP * There is probably a way to get top-bottom video frames from * the decoder... */ gint line = 0; gint stride = size / src->height; for (; line < src->height; line++) { memcpy (GST_BUFFER_DATA (buf) + (line * stride), buffer + (size - ((line + 1) * (stride))), stride); } } else { memcpy (GST_BUFFER_DATA (buf), buffer, size); } GST_DEBUG ("push_buffer => pts %" GST_TIME_FORMAT "duration %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_TIME_ARGS (duration)); /* the negotiate() method already set caps on the source pad */ gst_buffer_set_caps (buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (src))); g_mutex_lock (src->buffer_mutex); if (src->buffer != NULL) gst_buffer_unref (src->buffer); src->buffer = buf; g_cond_signal (src->buffer_cond); g_mutex_unlock (src->buffer_mutex); return TRUE; }
static GstFlowReturn gst_mms_create (GstPushSrc * psrc, GstBuffer ** buf) { GstMMS *mmssrc; guint8 *data; guint blocksize; gint result; mms_off_t offset; *buf = NULL; mmssrc = GST_MMS (psrc); offset = mmsx_get_current_pos (mmssrc->connection); /* Check if a seek perhaps has wrecked our connection */ if (offset == -1) { GST_DEBUG_OBJECT (mmssrc, "connection broken (probably an error during mmsx_seek_time during a convert query) returning FLOW_ERROR"); return GST_FLOW_ERROR; } /* Choose blocksize best for optimum performance */ if (offset == 0) blocksize = mmsx_get_asf_header_len (mmssrc->connection); else blocksize = mmsx_get_asf_packet_len (mmssrc->connection); *buf = gst_buffer_new_and_alloc (blocksize); data = GST_BUFFER_DATA (*buf); GST_BUFFER_SIZE (*buf) = 0; GST_LOG_OBJECT (mmssrc, "reading %d bytes", blocksize); result = mmsx_read (NULL, mmssrc->connection, (char *) data, blocksize); /* EOS? */ if (result == 0) goto eos; GST_BUFFER_OFFSET (*buf) = offset; GST_BUFFER_SIZE (*buf) = result; GST_LOG_OBJECT (mmssrc, "Returning buffer with offset %" G_GINT64_FORMAT " and size %u", GST_BUFFER_OFFSET (*buf), GST_BUFFER_SIZE (*buf)); gst_buffer_set_caps (*buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (mmssrc))); return GST_FLOW_OK; eos: { GST_DEBUG_OBJECT (mmssrc, "EOS"); gst_buffer_unref (*buf); *buf = NULL; return GST_FLOW_UNEXPECTED; } }
static GstCaps * gst_directsound_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter) { GstCaps *caps = NULL; GST_DEBUG_OBJECT (bsrc, "get caps"); caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc)); return caps; }
static GstFlowReturn gst_osx_video_src_create (GstPushSrc * src, GstBuffer ** buf) { GstOSXVideoSrc *self = GST_OSX_VIDEO_SRC (src); ComponentResult err; GstCaps *caps; //GstClock * clock; // ###: we need to sleep between calls to SGIdle. originally, the sleeping // was done using gst_clock_id_wait(), but it turns out that approach // doesn't work well. it has two issues: // 1) every so often, gst_clock_id_wait() will block for a much longer // period of time than requested (upwards of a minute) causing video // to freeze until it finally returns. this seems to happen once // every few minutes, which probably means something like 1 in every // several hundred calls gst_clock_id_wait() does the wrong thing. // 2) even when the gst_clock approach is working properly, it uses // quite a bit of cpu in comparison to a simple usleep(). on one // test machine, using gst_clock_id_wait() caused osxvideosrc to use // nearly 100% cpu, while using usleep() brough the usage to less // than 10%. // // so, for now, we comment out the gst_clock stuff and use usleep. //clock = gst_system_clock_obtain (); do { err = SGIdle (self->seq_grab); if (err != noErr) { GST_ERROR_OBJECT (self, "SGIdle returned %d", (int) err); gst_object_unref (clock); return GST_FLOW_UNEXPECTED; } if (self->buffer == NULL) { /*GstClockID clock_id; clock_id = gst_clock_new_single_shot_id (clock, (GstClockTime) (gst_clock_get_time(clock) + (GST_SECOND / ((float)FRAMERATE * 2)))); gst_clock_id_wait (clock_id, NULL); gst_clock_id_unref (clock_id); */ usleep (1000000 / (FRAMERATE * 2)); } } while (self->buffer == NULL); //gst_object_unref (clock); *buf = self->buffer; self->buffer = NULL; caps = gst_pad_get_caps (GST_BASE_SRC_PAD (src)); gst_buffer_set_caps (*buf, caps); gst_caps_unref (caps); return GST_FLOW_OK; }
static GstFlowReturn oob_source_create (GstPushSrc * src, GstBuffer ** p_buf) { *p_buf = gst_buffer_new (); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_OOB, NULL)); return GST_FLOW_OK; }
static GstCaps * gst_decklink_audio_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter) { GstCaps *caps; // We don't support renegotiation caps = gst_pad_get_current_caps (GST_BASE_SRC_PAD (bsrc)); if (!caps) caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc)); if (filter) { GstCaps *tmp = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (caps); caps = tmp; } return caps; }
static GstFlowReturn gst_inter_sub_src_create (GstBaseSrc * src, guint64 offset, guint size, GstBuffer ** buf) { GstInterSubSrc *intersubsrc = GST_INTER_SUB_SRC (src); GstBuffer *buffer; GST_DEBUG_OBJECT (intersubsrc, "create"); buffer = NULL; g_mutex_lock (intersubsrc->surface->mutex); if (intersubsrc->surface->sub_buffer) { buffer = gst_buffer_ref (intersubsrc->surface->sub_buffer); //intersubsrc->surface->sub_buffer_count++; //if (intersubsrc->surface->sub_buffer_count >= 30) { gst_buffer_unref (intersubsrc->surface->sub_buffer); intersubsrc->surface->sub_buffer = NULL; //} } g_mutex_unlock (intersubsrc->surface->mutex); if (buffer == NULL) { guint8 *data; buffer = gst_buffer_new_and_alloc (1); data = GST_BUFFER_DATA (buffer); data[0] = 0; } buffer = gst_buffer_make_metadata_writable (buffer); GST_BUFFER_TIMESTAMP (buffer) = gst_util_uint64_scale_int (GST_SECOND, intersubsrc->n_frames, intersubsrc->rate); GST_DEBUG_OBJECT (intersubsrc, "create ts %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer))); GST_BUFFER_DURATION (buffer) = gst_util_uint64_scale_int (GST_SECOND, (intersubsrc->n_frames + 1), intersubsrc->rate) - GST_BUFFER_TIMESTAMP (buffer); GST_BUFFER_OFFSET (buffer) = intersubsrc->n_frames; GST_BUFFER_OFFSET_END (buffer) = -1; GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DISCONT); if (intersubsrc->n_frames == 0) { GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT); } gst_buffer_set_caps (buffer, GST_PAD_CAPS (GST_BASE_SRC_PAD (intersubsrc))); intersubsrc->n_frames++; *buf = buffer; return GST_FLOW_OK; }
static GstFlowReturn gst_mms_create (GstPushSrc * psrc, GstBuffer ** buf) { GstMMS *mmssrc; guint8 *data; guint blocksize; gint result; mmssrc = GST_MMS (psrc); GST_OBJECT_LOCK (mmssrc); blocksize = GST_BASE_SRC (mmssrc)->blocksize; GST_OBJECT_UNLOCK (mmssrc); *buf = gst_buffer_new_and_alloc (blocksize); data = GST_BUFFER_DATA (*buf); GST_BUFFER_SIZE (*buf) = 0; GST_LOG_OBJECT (mmssrc, "reading %d bytes", blocksize); if (mmssrc->connection) { result = mms_read (NULL, mmssrc->connection, (char *) data, blocksize); } else { result = mmsh_read (NULL, mmssrc->connection_h, (char *) data, blocksize); } /* EOS? */ if (result == 0) goto eos; if (mmssrc->connection) { GST_BUFFER_OFFSET (*buf) = mms_get_current_pos (mmssrc->connection) - result; } else { GST_BUFFER_OFFSET (*buf) = mmsh_get_current_pos (mmssrc->connection_h) - result; } GST_BUFFER_SIZE (*buf) = result; GST_LOG_OBJECT (mmssrc, "Returning buffer with offset %" G_GINT64_FORMAT " and size %u", GST_BUFFER_OFFSET (*buf), GST_BUFFER_SIZE (*buf)); gst_buffer_set_caps (*buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (mmssrc))); return GST_FLOW_OK; eos: { GST_DEBUG_OBJECT (mmssrc, "EOS"); gst_buffer_unref (*buf); *buf = NULL; return GST_FLOW_UNEXPECTED; } }
static GstCaps * gst_openal_src_getcaps (GstBaseSrc * basesrc, GstCaps * filter) { GstOpenalSrc *openalsrc = GST_OPENAL_SRC (basesrc); GstCaps *caps; ALCdevice *device; device = alcOpenDevice (NULL); if (device == NULL) { GstPad *pad = GST_BASE_SRC_PAD (basesrc); GstCaps *tcaps = gst_pad_get_pad_template_caps (pad); GST_ELEMENT_WARNING (openalsrc, RESOURCE, OPEN_WRITE, ("Could not open temporary device."), GST_ALC_ERROR (device)); caps = gst_caps_copy (tcaps); gst_caps_unref (tcaps); } else if (openalsrc->probed_caps) caps = gst_caps_copy (openalsrc->probed_caps); else { ALCcontext *context = alcCreateContext (device, NULL); if (context) { caps = gst_openal_helper_probe_caps (context); alcDestroyContext (context); } else { GST_ELEMENT_WARNING (openalsrc, RESOURCE, FAILED, ("Could not create temporary context."), GST_ALC_ERROR (device)); caps = NULL; } if (caps && !gst_caps_is_empty (caps)) openalsrc->probed_caps = gst_caps_copy (caps); } if (device != NULL) { if (alcCloseDevice (device) == ALC_FALSE) { GST_ELEMENT_WARNING (openalsrc, RESOURCE, CLOSE, ("Could not close temporary device."), GST_ALC_ERROR (device)); } } if (filter) { GstCaps *intersection; intersection = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); return intersection; } else { return caps; } }
static GstBuffer * gst_ks_video_src_alloc_buffer (guint size, guint alignment, gpointer user_data) { GstKsVideoSrc *self = GST_KS_VIDEO_SRC (user_data); GstBuffer *buf; GstCaps *caps; GstFlowReturn flow_ret; caps = gst_pad_get_negotiated_caps (GST_BASE_SRC_PAD (self)); if (caps == NULL) goto error_no_caps; flow_ret = gst_pad_alloc_buffer (GST_BASE_SRC_PAD (self), 0, size + (alignment - 1), caps, &buf); gst_caps_unref (caps); if (G_UNLIKELY (flow_ret != GST_FLOW_OK)) goto error_alloc_buffer; GST_BUFFER_DATA (buf) = GSIZE_TO_POINTER ((GPOINTER_TO_SIZE (GST_BUFFER_DATA (buf)) + (alignment - 1)) & ~(alignment - 1)); GST_BUFFER_SIZE (buf) = size; return buf; error_no_caps: { GST_ELEMENT_ERROR (self, CORE, NEGOTIATION, ("not negotiated"), ("maybe setcaps failed?")); return NULL; } error_alloc_buffer: { GST_ELEMENT_ERROR (self, CORE, PAD, ("alloc_buffer failed"), (NULL)); return NULL; } }
static gboolean gst_v4l2src_event (GstBaseSrc * src, GstEvent * event) { GST_DEBUG_OBJECT (src, "handle event %" GST_PTR_FORMAT, event); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_RECONFIGURE: gst_pad_check_reconfigure (GST_BASE_SRC_PAD (src)); break; default: break; } return GST_BASE_SRC_CLASS (parent_class)->event (src, event); }
static GstCaps * gst_openni2_src_get_caps (GstBaseSrc * src, GstCaps * filter) { GstOpenni2Src *ni2src; GstCaps *caps; GstVideoInfo info; GstVideoFormat format; ni2src = GST_OPENNI2_SRC (src); GST_OBJECT_LOCK (ni2src); if (ni2src->gst_caps) goto out; // If we are here, we need to compose the caps and return them. if (ni2src->depth->isValid () && ni2src->color->isValid () && ni2src->sourcetype == SOURCETYPE_BOTH && ni2src->colorpixfmt == openni::PIXEL_FORMAT_RGB888) { format = GST_VIDEO_FORMAT_RGBA; } else if (ni2src->depth->isValid () && ni2src->sourcetype == SOURCETYPE_DEPTH) { format = GST_VIDEO_FORMAT_GRAY16_LE; } else if (ni2src->color->isValid () && ni2src->sourcetype == SOURCETYPE_COLOR && ni2src->colorpixfmt == openni::PIXEL_FORMAT_RGB888) { format = GST_VIDEO_FORMAT_RGB; } else { goto out; } gst_video_info_init (&info); gst_video_info_set_format (&info, format, ni2src->width, ni2src->height); info.fps_n = ni2src->fps; info.fps_d = 1; caps = gst_video_info_to_caps (&info); GST_INFO_OBJECT (ni2src, "probed caps: %" GST_PTR_FORMAT, caps); ni2src->gst_caps = caps; out: GST_OBJECT_UNLOCK (ni2src); if (!ni2src->gst_caps) return gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (ni2src)); return (filter) ? gst_caps_intersect_full (filter, ni2src->gst_caps, GST_CAPS_INTERSECT_FIRST) : gst_caps_ref (ni2src->gst_caps); }
static SoupBuffer * gst_soup_http_src_chunk_allocator (SoupMessage * msg, gsize max_len, gpointer user_data) { GstSoupHTTPSrc *src = (GstSoupHTTPSrc *) user_data; GstBaseSrc *basesrc = GST_BASE_SRC_CAST (src); GstBuffer *gstbuf; SoupBuffer *soupbuf; gsize length; GstFlowReturn rc; if (max_len) length = MIN (basesrc->blocksize, max_len); else length = basesrc->blocksize; GST_DEBUG_OBJECT (src, "alloc %" G_GSIZE_FORMAT " bytes <= %" G_GSIZE_FORMAT, length, max_len); rc = gst_pad_alloc_buffer (GST_BASE_SRC_PAD (basesrc), GST_BUFFER_OFFSET_NONE, length, src->src_caps ? src->src_caps : GST_PAD_CAPS (GST_BASE_SRC_PAD (basesrc)), &gstbuf); if (G_UNLIKELY (rc != GST_FLOW_OK)) { /* Failed to allocate buffer. Stall SoupSession and return error code * to create(). */ src->ret = rc; g_main_loop_quit (src->loop); return NULL; } soupbuf = soup_buffer_new_with_owner (GST_BUFFER_DATA (gstbuf), length, gstbuf, gst_soup_http_src_chunk_free); return soupbuf; }
static void gst_video_test_src_init (GstVideoTestSrc * src, GstVideoTestSrcClass * g_class) { GstPad *pad = GST_BASE_SRC_PAD (src); gst_pad_set_fixatecaps_function (pad, gst_video_test_src_src_fixate); gst_video_test_src_set_pattern (src, GST_VIDEO_TEST_SRC_SMPTE); src->timestamp_offset = 0; /* we operate in time */ gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME); gst_base_src_set_live (GST_BASE_SRC (src), FALSE); }