static GstFlowReturn gst_test_reverse_negotiation_sink_render (GstBaseSink * bsink, GstBuffer * buffer) { GstTestReverseNegotiationSink *sink = GST_TEST_REVERSE_NEGOTIATION_SINK (bsink); GstCaps *caps = gst_buffer_get_caps (buffer); GstVideoFormat fmt; gint width, height; fail_unless (caps != NULL); fail_unless (gst_video_format_parse_caps (caps, &fmt, &width, &height)); sink->nbuffers++; /* The third buffer is still in the old size * because the ffmpegcolorspaces can't convert * the frame sizes */ if (sink->nbuffers > 3) { fail_unless_equals_int (width, 512); fail_unless_equals_int (height, 128); } gst_caps_unref (caps); return GST_FLOW_OK; }
QtCamGstSample::QtCamGstSample(GstBuffer *buffer, GstCaps *caps) : d_ptr(new QtCamGstSamplePrivate) { d_ptr->buffer = gst_buffer_ref(buffer); d_ptr->caps = gst_caps_ref(caps); #if GST_CHECK_VERSION(1,0,0) d_ptr->mapped = false; #endif d_ptr->width = -1; d_ptr->height = -1; d_ptr->format = GST_VIDEO_FORMAT_UNKNOWN; #if GST_CHECK_VERSION(1,0,0) GstVideoInfo info; if (!gst_video_info_from_caps (&info, d_ptr->caps)) { qCritical() << "Failed to parse GStreamer caps"; } else { d_ptr->width = info.width; d_ptr->height = info.height; d_ptr->format = info.finfo->format; } #else if (!gst_video_format_parse_caps (d_ptr->caps, &d_ptr->format, &d_ptr->width, &d_ptr->height)) { qCritical() << "Failed to parse GStreamer caps"; } #endif }
// Returns the size of the video IntSize MediaPlayerPrivate::naturalSize() const { if (!hasVideo()) return IntSize(); // TODO: handle possible clean aperture data. See // https://bugzilla.gnome.org/show_bug.cgi?id=596571 // TODO: handle possible transformation matrix. See // https://bugzilla.gnome.org/show_bug.cgi?id=596326 int width = 0, height = 0; if (GstPad* pad = gst_element_get_static_pad(m_videoSink, "sink")) { GstCaps* caps = GST_PAD_CAPS(pad); gfloat pixelAspectRatio; gint pixelAspectRatioNumerator, pixelAspectRatioDenominator; if (!GST_IS_CAPS(caps) || !gst_caps_is_fixed(caps) || !gst_video_format_parse_caps(caps, NULL, &width, &height) || !gst_video_parse_caps_pixel_aspect_ratio(caps, &pixelAspectRatioNumerator, &pixelAspectRatioDenominator)) { gst_object_unref(GST_OBJECT(pad)); return IntSize(); } pixelAspectRatio = (gfloat) pixelAspectRatioNumerator / (gfloat) pixelAspectRatioDenominator; width *= pixelAspectRatio; height /= pixelAspectRatio; gst_object_unref(GST_OBJECT(pad)); } return IntSize(width, height); }
/* Retrieve the video sink's Caps and tell the application about the media size */ static void check_media_size (CustomData *data) { JNIEnv *env = get_jni_env (); GstElement *video_sink; GstPad *video_sink_pad; GstCaps *caps; GstVideoFormat fmt; int width; int height; /* Retrieve the Caps at the entrance of the video sink */ g_object_get (data->pipeline, "video-sink", &video_sink, NULL); video_sink_pad = gst_element_get_static_pad (video_sink, "sink"); caps = gst_pad_get_negotiated_caps (video_sink_pad); if (gst_video_format_parse_caps(caps, &fmt, &width, &height)) { int par_n, par_d; if (gst_video_parse_caps_pixel_aspect_ratio (caps, &par_n, &par_d)) { width = width * par_n / par_d; } GST_DEBUG ("Media size is %dx%d, notifying application", width, height); (*env)->CallVoidMethod (env, data->app, on_media_size_changed_method_id, (jint)width, (jint)height); if ((*env)->ExceptionCheck (env)) { GST_ERROR ("Failed to call Java method"); (*env)->ExceptionClear (env); } } gst_caps_unref(caps); gst_object_unref (video_sink_pad); gst_object_unref(video_sink); }
static GstFlowReturn gst_test_reverse_negotiation_sink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf) { GstTestReverseNegotiationSink *sink = GST_TEST_REVERSE_NEGOTIATION_SINK (bsink); GstVideoFormat fmt; gint width, height; fail_unless (gst_video_format_parse_caps (caps, &fmt, &width, &height)); if (sink->nbuffers < 2) { *buf = gst_buffer_new_and_alloc (gst_video_format_get_size (fmt, width, height)); gst_buffer_set_caps (*buf, caps); } else { gint fps_n, fps_d; fail_unless (gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)); width = 512; height = 128; *buf = gst_buffer_new_and_alloc (gst_video_format_get_size (fmt, width, height)); caps = gst_video_format_new_caps (fmt, width, height, fps_n, fps_d, 1, 1); gst_buffer_set_caps (*buf, caps); gst_caps_unref (caps); } return GST_FLOW_OK; }
gboolean gst_base_video_state_from_caps (GstVideoState * state, GstCaps * caps) { gst_video_format_parse_caps (caps, &state->format, &state->width, &state->height); if (!gst_video_parse_caps_framerate (caps, &state->fps_n, &state->fps_d)) return FALSE; state->par_n = 1; state->par_d = 1; gst_video_parse_caps_pixel_aspect_ratio (caps, &state->par_n, &state->par_d); { GstStructure *structure = gst_caps_get_structure (caps, 0); state->interlaced = FALSE; gst_structure_get_boolean (structure, "interlaced", &state->interlaced); } state->clean_width = state->width; state->clean_height = state->height; state->clean_offset_left = 0; state->clean_offset_top = 0; /* FIXME need better error handling */ return TRUE; }
static gboolean gst_frei0r_mixer_set_caps (GstPad * pad, GstCaps * caps) { GstFrei0rMixer *self = GST_FREI0R_MIXER (gst_pad_get_parent (pad)); gboolean ret = TRUE; gst_caps_replace (&self->caps, caps); if (pad != self->src) ret &= gst_pad_set_caps (self->src, caps); if (pad != self->sink0) ret &= gst_pad_set_caps (self->sink0, caps); if (pad != self->sink1) ret &= gst_pad_set_caps (self->sink1, caps); if (pad != self->sink2 && self->sink2) ret &= gst_pad_set_caps (self->sink2, caps); if (ret) { if (!gst_video_format_parse_caps (caps, &self->fmt, &self->width, &self->height)) { ret = FALSE; goto out; } } out: gst_object_unref (self); return ret; }
gboolean gst_mio_video_device_set_caps (GstMIOVideoDevice * self, GstCaps * caps) { GstVideoFormat format; GstMIOSetFormatCtx ctx = { 0, }; if (gst_video_format_parse_caps (caps, &format, &ctx.width, &ctx.height)) { if (format == GST_VIDEO_FORMAT_UYVY) ctx.format = kCVPixelFormatType_422YpCbCr8; else if (format == GST_VIDEO_FORMAT_YUY2) ctx.format = kCVPixelFormatType_422YpCbCr8Deprecated; else g_assert_not_reached (); } else { GstStructure *s; s = gst_caps_get_structure (caps, 0); g_assert (gst_structure_has_name (s, "image/jpeg")); gst_structure_get_int (s, "width", &ctx.width); gst_structure_get_int (s, "height", &ctx.height); ctx.format = kFigVideoCodecType_JPEG_OpenDML; } gst_video_parse_caps_framerate (caps, &ctx.fps_n, &ctx.fps_d); gst_mio_video_device_formats_foreach (self, gst_mio_video_device_activate_matching_format, &ctx); return ctx.success; }
static gboolean gauss_blur_set_caps (GstBaseTransform * btrans, GstCaps * incaps, GstCaps * outcaps) { GaussBlur *gb = GAUSS_BLUR (btrans); GstStructure *structure; GstVideoFormat format; guint32 n_elems; structure = gst_caps_get_structure (incaps, 0); g_return_val_if_fail (structure != NULL, FALSE); if (!gst_video_format_parse_caps (incaps, &format, &gb->width, &gb->height)) return FALSE; /* get stride */ gb->stride = gst_video_format_get_row_stride (format, 0, gb->width); n_elems = gb->stride * gb->height; gb->tempim = g_malloc (sizeof (gfloat) * n_elems); //gb->smoothedim = g_malloc (sizeof (guint16) * n_elems); return TRUE; }
bool getVideoSizeAndFormatFromCaps(GstCaps* caps, WebCore::IntSize& size, GstVideoFormat& format, int& pixelAspectRatioNumerator, int& pixelAspectRatioDenominator, int& stride) { #ifdef GST_API_VERSION_1 GstVideoInfo info; if (!gst_video_info_from_caps(&info, caps)) return false; format = GST_VIDEO_INFO_FORMAT(&info); size.setWidth(GST_VIDEO_INFO_WIDTH(&info)); size.setHeight(GST_VIDEO_INFO_HEIGHT(&info)); pixelAspectRatioNumerator = GST_VIDEO_INFO_PAR_N(&info); pixelAspectRatioDenominator = GST_VIDEO_INFO_PAR_D(&info); stride = GST_VIDEO_INFO_PLANE_STRIDE(&info, 0); #else gint width, height; if (!GST_IS_CAPS(caps) || !gst_caps_is_fixed(caps) || !gst_video_format_parse_caps(caps, &format, &width, &height) || !gst_video_parse_caps_pixel_aspect_ratio(caps, &pixelAspectRatioNumerator, &pixelAspectRatioDenominator)) return false; size.setWidth(width); size.setHeight(height); stride = size.width() * 4; #endif return true; }
QtCamGstSamplePrivate(GstBuffer *b, GstCaps *c) : buffer(gst_buffer_ref(b)), caps(gst_caps_ref(c)), width(-1), height(-1), format(GST_VIDEO_FORMAT_UNKNOWN) { #if GST_CHECK_VERSION(1,0,0) mapped = false; #endif #if GST_CHECK_VERSION(1,0,0) GstVideoInfo info; if (!gst_video_info_from_caps (&info, caps)) { qCritical() << "Failed to parse GStreamer caps"; } else { width = info.width; height = info.height; format = info.finfo->format; } #else if (!gst_video_format_parse_caps (caps, &format, &width, &height)) { qCritical() << "Failed to parse GStreamer caps"; } #endif }
/* Store the information from the caps that we are interested in. */ void prepare_overlay (GstElement * overlay, GstCaps * caps, gpointer user_data) { ContextInfo *cx=(ContextInfo*) user_data; gst_video_format_parse_caps (caps, NULL, &(cx->ov->width), &(cx->ov->height)); cx->ov->valid = TRUE; cx->ov->xpos = cx->ov->width; }
static gboolean gst_rsvg_overlay_set_caps (GstBaseTransform * btrans, GstCaps * incaps, GstCaps * outcaps) { GstRsvgOverlay *overlay = GST_RSVG_OVERLAY (btrans); return G_LIKELY (gst_video_format_parse_caps (incaps, &overlay->caps_format, &overlay->caps_width, &overlay->caps_height)); }
static gboolean gst_gamma_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps) { GstGamma *gamma = GST_GAMMA (base); GST_DEBUG_OBJECT (gamma, "setting caps: in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT, incaps, outcaps); if (!gst_video_format_parse_caps (incaps, &gamma->format, &gamma->width, &gamma->height)) goto invalid_caps; gamma->size = gst_video_format_get_size (gamma->format, gamma->width, gamma->height); switch (gamma->format) { case GST_VIDEO_FORMAT_I420: case GST_VIDEO_FORMAT_YV12: case GST_VIDEO_FORMAT_Y41B: case GST_VIDEO_FORMAT_Y42B: case GST_VIDEO_FORMAT_Y444: case GST_VIDEO_FORMAT_NV12: case GST_VIDEO_FORMAT_NV21: gamma->process = gst_gamma_planar_yuv_ip; break; case GST_VIDEO_FORMAT_YUY2: case GST_VIDEO_FORMAT_UYVY: case GST_VIDEO_FORMAT_AYUV: case GST_VIDEO_FORMAT_YVYU: gamma->process = gst_gamma_packed_yuv_ip; break; case GST_VIDEO_FORMAT_ARGB: case GST_VIDEO_FORMAT_ABGR: case GST_VIDEO_FORMAT_RGBA: case GST_VIDEO_FORMAT_BGRA: case GST_VIDEO_FORMAT_xRGB: case GST_VIDEO_FORMAT_xBGR: case GST_VIDEO_FORMAT_RGBx: case GST_VIDEO_FORMAT_BGRx: case GST_VIDEO_FORMAT_RGB: case GST_VIDEO_FORMAT_BGR: gamma->process = gst_gamma_packed_rgb_ip; break; default: goto invalid_caps; break; } return TRUE; invalid_caps: GST_ERROR_OBJECT (gamma, "Invalid caps: %" GST_PTR_FORMAT, incaps); return FALSE; }
static gboolean gst_droid_cam_src_vfsrc_setcaps (GstPad * pad, GstCaps * caps) { GstDroidCamSrc *src = GST_DROID_CAM_SRC (GST_OBJECT_PARENT (pad)); GstDroidCamSrcClass *klass = GST_DROID_CAM_SRC_GET_CLASS (src); int width, height; int fps_n, fps_d; int fps; GST_DEBUG_OBJECT (src, "vfsrc setcaps %" GST_PTR_FORMAT, caps); if (!caps || gst_caps_is_empty (caps) || gst_caps_is_any (caps)) { /* We are happy. */ return TRUE; } if (!gst_video_format_parse_caps (caps, NULL, &width, &height)) { GST_ELEMENT_ERROR (src, STREAM, FORMAT, ("Failed to parse caps"), (NULL)); return FALSE; } if (!gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)) { GST_ELEMENT_ERROR (src, STREAM, FORMAT, ("Failed to parse caps framerate"), (NULL)); return FALSE; } if (width == 0 || height == 0) { GST_ELEMENT_ERROR (src, STREAM, FORMAT, ("Invalid dimensions"), (NULL)); return FALSE; } fps = fps_n / fps_d; GST_OBJECT_LOCK (src); camera_params_set_viewfinder_size (src->camera_params, width, height); camera_params_set_viewfinder_fps (src->camera_params, fps); GST_OBJECT_UNLOCK (src); if (klass->set_camera_params (src)) { /* buffer pool needs to know about FPS */ GST_CAMERA_BUFFER_POOL_LOCK (src->pool); /* TODO: Make sure we are not overwriting a previous value. */ src->pool->buffer_duration = gst_util_uint64_scale_int (GST_SECOND, fps_d, fps_n); src->pool->fps_n = fps_n; src->pool->fps_d = fps_d; GST_CAMERA_BUFFER_POOL_UNLOCK (src->pool); return TRUE; } return FALSE; }
/* get notified of caps and plug in the correct process function */ static gboolean gst_video_balance_set_caps (GstBaseTransform * base, GstCaps * incaps, GstCaps * outcaps) { GstVideoBalance *videobalance = GST_VIDEO_BALANCE (base); GST_DEBUG_OBJECT (videobalance, "in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT, incaps, outcaps); videobalance->process = NULL; if (!gst_video_format_parse_caps (incaps, &videobalance->format, &videobalance->width, &videobalance->height)) goto invalid_caps; videobalance->size = gst_video_format_get_size (videobalance->format, videobalance->width, videobalance->height); switch (videobalance->format) { case GST_VIDEO_FORMAT_I420: case GST_VIDEO_FORMAT_YV12: case GST_VIDEO_FORMAT_Y41B: case GST_VIDEO_FORMAT_Y42B: case GST_VIDEO_FORMAT_Y444: videobalance->process = gst_video_balance_planar_yuv; break; case GST_VIDEO_FORMAT_YUY2: case GST_VIDEO_FORMAT_UYVY: case GST_VIDEO_FORMAT_AYUV: case GST_VIDEO_FORMAT_YVYU: videobalance->process = gst_video_balance_packed_yuv; break; case GST_VIDEO_FORMAT_ARGB: case GST_VIDEO_FORMAT_ABGR: case GST_VIDEO_FORMAT_RGBA: case GST_VIDEO_FORMAT_BGRA: case GST_VIDEO_FORMAT_xRGB: case GST_VIDEO_FORMAT_xBGR: case GST_VIDEO_FORMAT_RGBx: case GST_VIDEO_FORMAT_BGRx: case GST_VIDEO_FORMAT_RGB: case GST_VIDEO_FORMAT_BGR: videobalance->process = gst_video_balance_packed_rgb; break; default: break; } return videobalance->process != NULL; invalid_caps: GST_ERROR_OBJECT (videobalance, "Invalid caps: %" GST_PTR_FORMAT, incaps); return FALSE; }
static gboolean gst_retinex_set_caps(GstBaseTransform * btrans, GstCaps * incaps, GstCaps * outcaps) { GstRetinex *retinex = GST_RETINEX (btrans); gint in_width, in_height; gint out_width, out_height; GST_RETINEX_LOCK (retinex); gst_video_format_parse_caps(incaps, &retinex->in_format, &in_width, &in_height); gst_video_format_parse_caps(outcaps, &retinex->out_format, &out_width, &out_height); if (!(retinex->in_format == retinex->out_format) || !(in_width == out_width && in_height == out_height)) { GST_WARNING("Failed to parse caps %" GST_PTR_FORMAT " -> %" GST_PTR_FORMAT, incaps, outcaps); GST_RETINEX_UNLOCK (retinex); return FALSE; } retinex->width = in_width; retinex->height = in_height; GST_INFO("Initialising Retinex..."); const CvSize size = cvSize(retinex->width, retinex->height); GST_WARNING (" width %d, height %d", retinex->width, retinex->height); ////////////////////////////////////////////////////////////////////////////// // allocate image structs in all spaces/////////////////////////////////////// retinex->pFrame = cvCreateImageHeader(size, IPL_DEPTH_8U, 4); retinex->pFrame2 = cvCreateImage(size, IPL_DEPTH_8U, 3); retinex->pFrameA = cvCreateImage(size, IPL_DEPTH_8U, 1); retinex->ch1 = cvCreateImage(size, IPL_DEPTH_8U, 1); retinex->ch2 = cvCreateImage(size, IPL_DEPTH_8U, 1); retinex->ch3 = cvCreateImage(size, IPL_DEPTH_8U, 1); GST_INFO("Retinex initialized."); GST_RETINEX_UNLOCK (retinex); return TRUE; }
static gboolean gst_skin_set_caps(GstBaseTransform * btrans, GstCaps * incaps, GstCaps * outcaps) { GstSkin *skin = GST_SKIN (btrans); gint in_width, in_height; gint out_width, out_height; GST_SKIN_LOCK (skin); gst_video_format_parse_caps(incaps, &skin->in_format, &in_width, &in_height); gst_video_format_parse_caps(outcaps, &skin->out_format, &out_width, &out_height); if (!(skin->in_format == skin->out_format) || !(in_width == out_width && in_height == out_height)) { GST_WARNING("Failed to parse caps %" GST_PTR_FORMAT " -> %" GST_PTR_FORMAT, incaps, outcaps); GST_SKIN_UNLOCK (skin); return FALSE; } skin->width = in_width; skin->height = in_height; GST_INFO("Initialising Skin..."); const CvSize size = cvSize(skin->width, skin->height); GST_WARNING (" width %d, height %d", skin->width, skin->height); ////////////////////////////////////////////////////////////////////////////// // allocate image structs in RGB(A) ////////////////////////////////////////// skin->cvRGBA = cvCreateImageHeader(size, IPL_DEPTH_8U, 4); skin->cvRGB = cvCreateImage(size, IPL_DEPTH_8U, 3); skin->ch1 = cvCreateImage(size, IPL_DEPTH_8U, 1); skin->ch2 = cvCreateImage(size, IPL_DEPTH_8U, 1); skin->ch3 = cvCreateImage(size, IPL_DEPTH_8U, 1); skin->chA = cvCreateImage(size, IPL_DEPTH_8U, 1); GST_INFO("Skin initialized."); GST_SKIN_UNLOCK (skin); return TRUE; }
static gboolean gst_frei0r_filter_set_caps (GstBaseTransform * trans, GstCaps * incaps, GstCaps * outcaps) { GstFrei0rFilter *self = GST_FREI0R_FILTER (trans); GstVideoFormat fmt; if (!gst_video_format_parse_caps (incaps, &fmt, &self->width, &self->height)) return FALSE; return TRUE; }
static gboolean gst_logoinsert_set_caps (GstBaseTransform * base_transform, GstCaps * incaps, GstCaps * outcaps) { GstLogoinsert *li; g_return_val_if_fail (GST_IS_LOGOINSERT (base_transform), GST_FLOW_ERROR); li = GST_LOGOINSERT (base_transform); gst_video_format_parse_caps (incaps, &li->format, &li->width, &li->height); return TRUE; }
static gboolean gst_patchdetect_get_unit_size (GstBaseTransform * trans, GstCaps * caps, guint * size) { int width, height; GstVideoFormat format; gboolean ret; ret = gst_video_format_parse_caps (caps, &format, &width, &height); *size = gst_video_format_get_size (format, width, height); return ret; }
static gboolean gst_retinex_get_unit_size(GstBaseTransform * btrans, GstCaps * caps, guint * size) { GstVideoFormat format; gint width, height; if (!gst_video_format_parse_caps(caps, &format, &width, &height)) return FALSE; *size = gst_video_format_get_size(format, width, height); GST_DEBUG_OBJECT(btrans, "unit size = %d for format %d w %d height %d", *size, format, width, height); return TRUE; }
static gboolean gst_mse_set_caps (GstPad * pad, GstCaps * caps) { GstMSE *fs; fs = GST_MSE (gst_pad_get_parent (pad)); gst_video_format_parse_caps (caps, &fs->format, &fs->width, &fs->height); gst_object_unref (fs); return TRUE; }
static gboolean gst_base_video_decoder_sink_setcaps (GstPad * pad, GstCaps * caps) { GstBaseVideoDecoder *base_video_decoder; GstBaseVideoDecoderClass *base_video_decoder_class; GstStructure *structure; const GValue *codec_data; GstVideoState *state; gboolean ret = TRUE; base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); base_video_decoder_class = GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); GST_DEBUG ("setcaps %" GST_PTR_FORMAT, caps); state = &base_video_decoder->state; if (state->codec_data) { gst_buffer_unref (state->codec_data); } memset (state, 0, sizeof (GstVideoState)); structure = gst_caps_get_structure (caps, 0); gst_video_format_parse_caps (caps, NULL, &state->width, &state->height); gst_video_parse_caps_framerate (caps, &state->fps_n, &state->fps_d); gst_video_parse_caps_pixel_aspect_ratio (caps, &state->par_n, &state->par_d); #if 0 /* requires 0.10.23 */ state->have_interlaced = gst_video_format_parse_caps_interlaced (caps, &state->interlaced); #else state->have_interlaced = gst_structure_get_boolean (structure, "interlaced", &state->interlaced); #endif codec_data = gst_structure_get_value (structure, "codec_data"); if (codec_data && G_VALUE_TYPE (codec_data) == GST_TYPE_BUFFER) { state->codec_data = gst_value_get_buffer (codec_data); } if (base_video_decoder_class->start) { ret = base_video_decoder_class->start (base_video_decoder); } g_object_unref (base_video_decoder); return ret; }
static gboolean gst_base_video_encoder_sink_setcaps (GstPad * pad, GstCaps * caps) { GstBaseVideoEncoder *base_video_encoder; GstBaseVideoEncoderClass *base_video_encoder_class; GstStructure *structure; GstVideoState *state; gboolean ret; base_video_encoder = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad)); base_video_encoder_class = GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder); GST_DEBUG ("setcaps"); state = &GST_BASE_VIDEO_CODEC (base_video_encoder)->state; structure = gst_caps_get_structure (caps, 0); gst_video_format_parse_caps (caps, &state->format, &state->width, &state->height); state->fps_n = 0; state->fps_d = 1; gst_video_parse_caps_framerate (caps, &state->fps_n, &state->fps_d); if (state->fps_d == 0) { state->fps_n = 0; state->fps_d = 1; } state->par_n = 1; state->par_d = 1; gst_video_parse_caps_pixel_aspect_ratio (caps, &state->par_n, &state->par_d); state->have_interlaced = gst_structure_get_boolean (structure, "interlaced", &state->interlaced); state->clean_width = state->width; state->clean_height = state->height; state->clean_offset_left = 0; state->clean_offset_top = 0; ret = base_video_encoder_class->set_format (base_video_encoder, &GST_BASE_VIDEO_CODEC (base_video_encoder)->state); if (ret) { ret = base_video_encoder_class->start (base_video_encoder); } g_object_unref (base_video_encoder); return ret; }
static gboolean gst_video_scale_get_unit_size (GstBaseTransform * trans, GstCaps * caps, guint * size) { GstVideoFormat format; gint width, height; if (!gst_video_format_parse_caps (caps, &format, &width, &height)) return FALSE; *size = gst_video_format_get_size (format, width, height); return TRUE; }
static gboolean gst_decklink_sink_videosink_event (GstPad * pad, GstObject * parent, GstEvent * event) { gboolean res; GstDecklinkSink *decklinksink; decklinksink = GST_DECKLINK_SINK (parent); GST_DEBUG_OBJECT (pad, "event: %" GST_PTR_FORMAT, event); switch (GST_EVENT_TYPE (event)) { /* FIXME: this makes no sense, template caps don't contain v210 */ #if 0 case GST_EVENT_CAPS:{ GstCaps *caps; gst_event_parse_caps (event, &caps); ret = gst_video_format_parse_caps (caps, &format, &width, &height); if (ret) { if (format == GST_VIDEO_FORMAT_v210) { decklinksink->pixel_format = bmdFormat10BitYUV; } else { decklinksink->pixel_format = bmdFormat8BitYUV; } } break; } #endif case GST_EVENT_EOS: /* FIXME: EOS aggregation with audio pad looks wrong */ decklinksink->video_eos = TRUE; decklinksink->video_seqnum = gst_event_get_seqnum (event); { GstMessage *message; message = gst_message_new_eos (GST_OBJECT_CAST (decklinksink)); gst_message_set_seqnum (message, decklinksink->video_seqnum); gst_element_post_message (GST_ELEMENT_CAST (decklinksink), message); } res = gst_pad_event_default (pad, parent, event); break; default: res = gst_pad_event_default (pad, parent, event); break; } return res; }
static gboolean gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps) { GstGLImageSink *glimage_sink; gint width; gint height; gboolean ok; gint fps_n, fps_d; gint par_n, par_d; GstVideoFormat format; GstStructure *structure; gboolean is_gl; GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps); glimage_sink = GST_GLIMAGE_SINK (bsink); structure = gst_caps_get_structure (caps, 0); if (gst_structure_has_name (structure, "video/x-raw-gl")) { is_gl = TRUE; format = GST_VIDEO_FORMAT_UNKNOWN; ok = gst_structure_get_int (structure, "width", &width); ok &= gst_structure_get_int (structure, "height", &height); } else { is_gl = FALSE; ok = gst_video_format_parse_caps (caps, &format, &width, &height); } ok &= gst_video_parse_caps_framerate (caps, &fps_n, &fps_d); ok &= gst_video_parse_caps_pixel_aspect_ratio (caps, &par_n, &par_d); if (!ok) return FALSE; GST_VIDEO_SINK_WIDTH (glimage_sink) = width; GST_VIDEO_SINK_HEIGHT (glimage_sink) = height; glimage_sink->is_gl = is_gl; glimage_sink->format = format; glimage_sink->width = width; glimage_sink->height = height; glimage_sink->fps_n = fps_n; glimage_sink->fps_d = fps_d; glimage_sink->par_n = par_n; glimage_sink->par_d = par_d; if (!glimage_sink->window_id && !glimage_sink->new_window_id) gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (glimage_sink)); return TRUE; }
void GStreamerReader::VideoPreroll() { /* The first video buffer has reached the video sink. Get width and height */ LOG(PR_LOG_DEBUG, ("Video preroll")); GstPad* sinkpad = gst_element_get_pad(GST_ELEMENT(mVideoAppSink), "sink"); GstCaps* caps = gst_pad_get_negotiated_caps(sinkpad); gst_video_format_parse_caps(caps, &mFormat, &mPicture.width, &mPicture.height); GstStructure* structure = gst_caps_get_structure(caps, 0); gst_structure_get_fraction(structure, "framerate", &fpsNum, &fpsDen); NS_ASSERTION(mPicture.width && mPicture.height, "invalid video resolution"); mInfo.mDisplay = nsIntSize(mPicture.width, mPicture.height); mInfo.mHasVideo = true; gst_caps_unref(caps); gst_object_unref(sinkpad); }
static gboolean gst_gdk_pixbuf_overlay_set_caps (GstBaseTransform * trans, GstCaps * incaps, GstCaps * outcaps) { GstGdkPixbufOverlay *overlay = GST_GDK_PIXBUF_OVERLAY (trans); GstVideoFormat video_format; int w, h; if (!gst_video_format_parse_caps (incaps, &video_format, &w, &h)) return FALSE; overlay->format = video_format; overlay->width = w; overlay->height = h; return TRUE; }