diff --git a/src/gstducatividenc.c b/src/gstducatividenc.c
index 4772a9ac4477239a2d44dd0f4844202e0edae964..9e58cb343cce26a6f924f648bbb80b521980db96 100644 (file)
--- a/src/gstducatividenc.c
+++ b/src/gstducatividenc.c
static void gst_ducati_videnc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
-static gboolean gst_ducati_videnc_set_format (GstBaseVideoEncoder *
- base_video_encoder, GstVideoState * state);
-static gboolean gst_ducati_videnc_start (GstBaseVideoEncoder *
+static gboolean gst_ducati_videnc_set_format (GstVideoEncoder *
+ base_video_encoder, GstVideoCodecState * state);
+static gboolean gst_ducati_videnc_start (GstVideoEncoder * base_video_encoder);
+static gboolean gst_ducati_videnc_stop (GstVideoEncoder * base_video_encoder);
+static GstFlowReturn gst_ducati_videnc_finish (GstVideoEncoder *
base_video_encoder);
-static gboolean gst_ducati_videnc_stop (GstBaseVideoEncoder *
- base_video_encoder);
-static GstFlowReturn gst_ducati_videnc_finish (GstBaseVideoEncoder *
- base_video_encoder);
-static GstFlowReturn gst_ducati_videnc_handle_frame (GstBaseVideoEncoder *
- base_video_encoder, GstVideoFrame * frame);
+static GstFlowReturn gst_ducati_videnc_handle_frame (GstVideoEncoder *
+ base_video_encoder, GstVideoCodecFrame * frame);
static gboolean gst_ducati_videnc_allocate_params_default (GstDucatiVidEnc *
self, gint params_sz, gint dynparams_sz, gint status_sz, gint inargs_sz,
gint outargs_sz);
static gboolean gst_ducati_videnc_is_sync_point_default (GstDucatiVidEnc * enc,
int type);
static gboolean gst_ducati_videnc_configure_default (GstDucatiVidEnc * self);
-static gboolean gst_ducati_videnc_event (GstBaseVideoEncoder * enc,
+static gboolean gst_ducati_videnc_event (GstVideoEncoder * enc,
GstEvent * event);
+static gboolean
+gst_ducati_videnc_propose_allocation (GstVideoEncoder * encoder,
+ GstQuery * query);
+static GstBufferPool *gst_drm_buffer_pool_new (GstCaps * caps, guint size);
-
-GST_BOILERPLATE (GstDucatiVidEnc, gst_ducati_videnc, GstBaseVideoEncoder,
- GST_TYPE_BASE_VIDEO_ENCODER);
-
+#define gst_ducati_videnc_parent_class parent_class
+G_DEFINE_TYPE (GstDucatiVidEnc, gst_ducati_videnc, GST_TYPE_VIDEO_ENCODER);
/* the values for the following enums are taken from the codec */
return type;
}
-static void
-gst_ducati_videnc_base_init (gpointer g_class)
+static GstBufferPool *
+gst_drm_buffer_pool_new (GstCaps * caps, guint size)
{
+ GstAllocator *allocator;
+ GstStructure *conf;
+ GstBufferPool *ret_pool;
+
+ allocator = gst_drm_allocator_get ();
+ if (!allocator) {
+ GST_DEBUG
+ ("Failed to get a DRM bufferpool. Proceeding with default allocator");
+ }
+ ret_pool = gst_buffer_pool_new ();
+ conf = gst_buffer_pool_get_config (GST_BUFFER_POOL (ret_pool));
+ if (conf) {
+ gst_buffer_pool_config_set_params (conf, caps, size, 0, 0);
+ gst_buffer_pool_config_set_allocator (conf, allocator, NULL);
+ gst_buffer_pool_set_config (GST_BUFFER_POOL (ret_pool), conf);
+ }
+
+ if (allocator)
+ gst_object_unref (allocator);
+
+ return ret_pool;
}
+static gboolean
+gst_ducati_videnc_propose_allocation (GstVideoEncoder * encoder,
+ GstQuery * query)
+{
+ GstDucatiVidEnc *self = GST_DUCATIVIDENC (encoder);
+ GstStructure *config;
+ guint size, min_bufs, max_bufs;
+ GstCaps *allowed_sink_caps;
+ GstVideoInfo info;
+
+ if (!self->input_pool) {
+ allowed_sink_caps =
+ gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SINK_PAD (self));
+ if (!allowed_sink_caps) {
+ GST_DEBUG_OBJECT (self, "... but no peer, using template caps");
+ allowed_sink_caps =
+ gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SINK_PAD (self));
+ }
+ GST_DEBUG_OBJECT (self, "chose caps %" GST_PTR_FORMAT, allowed_sink_caps);
+ allowed_sink_caps = gst_caps_truncate (allowed_sink_caps);
+ gst_video_info_from_caps (&info, gst_caps_fixate (allowed_sink_caps));
+ self->input_pool =
+ gst_drm_buffer_pool_new (gst_caps_fixate (allowed_sink_caps),
+ info.size);
+ }
+
+ config = gst_buffer_pool_get_config (self->input_pool);
+ gst_buffer_pool_config_get_params (config, NULL, &size, &min_bufs, &max_bufs);
+
+ gst_query_add_allocation_pool (query, self->input_pool, size, min_bufs,
+ max_bufs);
+ gst_query_add_allocation_param (query, gst_drm_allocator_get (), NULL);
+ gst_structure_free (config);
+
+ return TRUE;
+}
+
+
static void
gst_ducati_videnc_class_init (GstDucatiVidEncClass * klass)
{
GObjectClass *gobject_class;
- GstBaseVideoEncoderClass *basevideoencoder_class;
+ GstVideoEncoderClass *basevideoencoder_class;
gobject_class = G_OBJECT_CLASS (klass);
- basevideoencoder_class = GST_BASE_VIDEO_ENCODER_CLASS (klass);
+ basevideoencoder_class = GST_VIDEO_ENCODER_CLASS (klass);
+ parent_class = g_type_class_peek_parent (klass);
gobject_class->set_property = gst_ducati_videnc_set_property;
gobject_class->get_property = gst_ducati_videnc_get_property;
basevideoencoder_class->finish = GST_DEBUG_FUNCPTR (gst_ducati_videnc_finish);
basevideoencoder_class->handle_frame =
GST_DEBUG_FUNCPTR (gst_ducati_videnc_handle_frame);
- basevideoencoder_class->event = GST_DEBUG_FUNCPTR (gst_ducati_videnc_event);
+
+ basevideoencoder_class->src_event =
+ GST_DEBUG_FUNCPTR (gst_ducati_videnc_event);
+
+ basevideoencoder_class->propose_allocation =
+ GST_DEBUG_FUNCPTR (gst_ducati_videnc_propose_allocation);
klass->allocate_params = gst_ducati_videnc_allocate_params_default;
klass->configure = gst_ducati_videnc_configure_default;
}
static void
-gst_ducati_videnc_init (GstDucatiVidEnc * self, GstDucatiVidEncClass * klass)
+gst_ducati_videnc_init (GstDucatiVidEnc * self)
{
GST_DEBUG ("gst_ducati_videnc_init");
}
static gboolean
-gst_ducati_videnc_set_format (GstBaseVideoEncoder * base_video_encoder,
- GstVideoState * state)
+gst_ducati_videnc_set_format (GstVideoEncoder * base_video_encoder,
+ GstVideoCodecState * state)
{
GstDucatiVidEnc *self = GST_DUCATIVIDENC (base_video_encoder);
+ GstVideoCodecState *output_state;
+ GstCaps *allowed_caps = NULL;
+
+ GST_DEBUG_OBJECT (self, "picking an output format ...");
+ allowed_caps =
+ gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (base_video_encoder));
+ if (!allowed_caps) {
+ GST_DEBUG_OBJECT (self, "... but no peer, using template caps");
+ allowed_caps =
+ gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD
+ (base_video_encoder));
+ }
+ GST_DEBUG_OBJECT (self, "chose caps %" GST_PTR_FORMAT, allowed_caps);
+ allowed_caps = gst_caps_truncate (allowed_caps);
+ GST_DEBUG_OBJECT (self, "allowed caps %" GST_PTR_FORMAT, allowed_caps);
+ output_state = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (self),
+ allowed_caps, state);
+ gst_video_codec_state_unref (output_state);
+
+
+ if (!gst_video_encoder_negotiate (GST_VIDEO_ENCODER (self))) {
+ GST_DEBUG_OBJECT (self, "negotiate failed");
+ return FALSE;
+ }
+
+ if (self->input_state)
+ gst_video_codec_state_unref (self->input_state);
+ self->input_state = gst_video_codec_state_ref (state);
self->configure = TRUE;
return TRUE;
int err;
int i;
int max_out_size = 0;
- const GstVideoState *state;
-
- state = gst_base_video_encoder_get_state (GST_BASE_VIDEO_ENCODER (self));
+ const GstVideoCodecState *state;
+ GstCaps *allowed_sink_caps = NULL;
+ GstCaps *allowed_src_caps = NULL;
+ state = self->input_state;
if (!GST_DUCATIVIDENC_GET_CLASS (self)->configure (self))
return FALSE;
max_out_size = size;
}
- g_assert (self->input_pool == NULL);
- self->input_pool = gst_drm_buffer_pool_new (GST_ELEMENT (self),
- dce_get_fd (), NULL, state->bytes_per_picture);
+ if (!self->input_pool) {
+ GstVideoInfo info;
+ allowed_sink_caps =
+ gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SINK_PAD (self));
+ if (!allowed_sink_caps) {
+ GST_DEBUG_OBJECT (self, "... but no peer, using template caps");
+ allowed_sink_caps =
+ gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SINK_PAD (self));
+ }
+ GST_DEBUG_OBJECT (self, "chose caps %" GST_PTR_FORMAT, allowed_sink_caps);
+ allowed_sink_caps = gst_caps_truncate (allowed_sink_caps);
+ gst_video_info_from_caps (&info, gst_caps_fixate (allowed_sink_caps));
+ self->input_pool =
+ gst_drm_buffer_pool_new (gst_caps_fixate (allowed_sink_caps),
+ info.size);
+ }
+
+
+ gst_buffer_pool_set_active (GST_BUFFER_POOL (self->input_pool), TRUE);
g_assert (self->output_pool == NULL);
- self->output_pool = gst_drm_buffer_pool_new (GST_ELEMENT (self),
- dce_get_fd (), NULL, max_out_size);
+ allowed_src_caps =
+ gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (self));
+ if (!allowed_src_caps) {
+ GST_DEBUG_OBJECT (self, "... but no peer, using template caps");
+ allowed_src_caps =
+ gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (self));
+ }
+ GST_DEBUG_OBJECT (self, "chose caps %" GST_PTR_FORMAT, allowed_src_caps);
+ allowed_src_caps = gst_caps_truncate (allowed_src_caps);
+ self->output_pool =
+ gst_drm_buffer_pool_new (gst_caps_fixate (allowed_src_caps),
+ max_out_size);
+
+ gst_buffer_pool_set_active (GST_BUFFER_POOL (self->output_pool), TRUE);
GST_INFO_OBJECT (self, "configured");
{
VIDENC2_DynamicParams *dynParams;
VIDENC2_Params *params;
- const GstVideoState *state;
+ const GstVideoCodecState *state;
int i;
- state = gst_base_video_encoder_get_state (GST_BASE_VIDEO_ENCODER (self));
+ state = self->input_state;
if (self->rect.w == 0)
- self->rect.w = state->width;
+ self->rect.w = GST_VIDEO_INFO_WIDTH (&state->info);
if (self->rect.h == 0)
- self->rect.h = state->height;
+ self->rect.h = GST_VIDEO_INFO_HEIGHT (&state->info);
params = (VIDENC2_Params *) self->params;
params->encodingPreset = 0x03;
dynParams = (VIDENC2_DynamicParams *) self->dynParams;
dynParams->refFrameRate =
- gst_util_uint64_scale (1000, state->fps_n, state->fps_d);
+ gst_util_uint64_scale (1000, GST_VIDEO_INFO_FPS_N (&state->info),
+ GST_VIDEO_INFO_FPS_D (&state->info));
dynParams->targetFrameRate = dynParams->refFrameRate;
dynParams->inputWidth = self->rect.w;
dynParams->inputHeight = self->rect.h;
static gboolean
-gst_ducati_videnc_start (GstBaseVideoEncoder * base_video_encoder)
+gst_ducati_videnc_start (GstVideoEncoder * base_video_encoder)
{
GstDucatiVidEnc *self = GST_DUCATIVIDENC (base_video_encoder);
}
static gboolean
-gst_ducati_videnc_stop (GstBaseVideoEncoder * base_video_encoder)
+gst_ducati_videnc_stop (GstVideoEncoder * base_video_encoder)
{
GstDucatiVidEnc *self = GST_DUCATIVIDENC (base_video_encoder);
gst_ducati_videnc_close_engine (self);
if (self->input_pool) {
- gst_drm_buffer_pool_destroy (self->input_pool);
+ gst_object_unref (self->input_pool);
self->input_pool = NULL;
}
if (self->output_pool) {
- gst_drm_buffer_pool_destroy (self->output_pool);
+ gst_object_unref (self->output_pool);
self->output_pool = NULL;
}
}
static GstFlowReturn
-gst_ducati_videnc_finish (GstBaseVideoEncoder * base_video_encoder)
+gst_ducati_videnc_finish (GstVideoEncoder * base_video_encoder)
{
GstDucatiVidEnc *self = GST_DUCATIVIDENC (base_video_encoder);
gst_ducati_videnc_buffer_lock (GstDucatiVidEnc * self, GstBuffer * buf)
{
int fd;
- GstDmaBuf *dmabuf = gst_buffer_get_dma_buf (buf);
- if (!dmabuf) {
- GST_ERROR_OBJECT (self, "invalid dmabuf for buf = %p", buf);
+ GstMemory *mem;
+ mem = gst_buffer_peek_memory (buf, 0);
+ if (!gst_is_drm_memory (mem)) {
+ GST_LOG_OBJECT (self, "Not a dmabuf memory");
return -1;
}
- fd = gst_dma_buf_get_fd (dmabuf);
+
+ fd = gst_fd_memory_get_fd (mem);
if (fd < 0) {
GST_ERROR_OBJECT (self, "Invalid dma buf fd %d", fd);
return -1;
gst_ducati_videnc_buffer_unlock (GstDucatiVidEnc * self, GstBuffer * buf)
{
int fd;
- GstDmaBuf *dmabuf = gst_buffer_get_dma_buf (buf);
- if (!dmabuf) {
- GST_ERROR_OBJECT (self, "invalid dmabuf for buf = %p", buf);
+ GstMemory *mem;
+ mem = gst_buffer_peek_memory (buf, 0);
+ if (!gst_is_drm_memory (mem)) {
+ GST_LOG_OBJECT (self, "Not a dmabuf memory");
return;
}
- fd = gst_dma_buf_get_fd (dmabuf);
+ fd = gst_fd_memory_get_fd (mem);
if (fd < 0) {
GST_ERROR_OBJECT (self, "Invalid dma buf fd %d", fd);
return;
}
static GstFlowReturn
-gst_ducati_videnc_handle_frame (GstBaseVideoEncoder * base_video_encoder,
- GstVideoFrame * frame)
+gst_ducati_videnc_handle_frame (GstVideoEncoder * base_video_encoder,
+ GstVideoCodecFrame * frame)
{
GstDucatiVidEnc *self = GST_DUCATIVIDENC (base_video_encoder);
GstBuffer *inbuf, *outbuf;
+ GstBuffer *output_buffer;
int dmabuf_fd_in, dmabuf_fd_out;
XDAS_Int32 err;
- const GstVideoState *state;
+ const GstVideoCodecState *state;
int i;
GstClockTime ts;
GstClockTime t;
+ GstVideoCropMeta *crop;
- state = gst_base_video_encoder_get_state (base_video_encoder);
+ state = self->input_state;
if (G_UNLIKELY (self->configure)) {
if (!gst_ducati_videnc_configure (self)) {
}
}
- inbuf = gst_buffer_ref (frame->sink_buffer);
- ts = GST_BUFFER_TIMESTAMP (inbuf);
+ inbuf = gst_buffer_ref (frame->input_buffer);
+ ts = GST_BUFFER_PTS (inbuf);
have_inbuf:
dmabuf_fd_in = gst_ducati_videnc_buffer_lock (self, inbuf);
if (dmabuf_fd_in < 0) {
+ GstMapInfo info;
+ gboolean mapped;
+
GST_DEBUG_OBJECT (self, "memcpying input");
gst_buffer_unref (inbuf);
- inbuf = GST_BUFFER (gst_drm_buffer_pool_get (self->input_pool, FALSE));
- memcpy (GST_BUFFER_DATA (inbuf), GST_BUFFER_DATA (frame->sink_buffer),
- GST_BUFFER_SIZE (frame->sink_buffer));
- GST_BUFFER_TIMESTAMP (inbuf) = ts;
+
+ gst_buffer_pool_acquire_buffer (self->input_pool, &inbuf, NULL);
+ mapped = gst_buffer_map (frame->input_buffer, &info, GST_MAP_READ);
+ if (mapped) {
+ gst_buffer_fill (inbuf, 0, info.data, info.size);
+ gst_buffer_unmap (frame->input_buffer, &info);
+ }
+
+ GST_BUFFER_PTS (inbuf) = ts;
goto have_inbuf;
}
- outbuf = GST_BUFFER (gst_drm_buffer_pool_get (self->output_pool, FALSE));
+ gst_buffer_pool_acquire_buffer (self->output_pool, &outbuf, NULL);
+
+ crop = gst_buffer_add_video_crop_meta (outbuf);
+ if (crop) {
+ crop->x = 0;
+ crop->y = 0;
+ crop->width = GST_VIDEO_INFO_WIDTH (&state->info);
+ crop->height = GST_VIDEO_INFO_HEIGHT (&state->info);
+ }
dmabuf_fd_out = gst_ducati_videnc_buffer_lock (self, outbuf);
self->inBufs->planeDesc[0].buf = (XDAS_Int8 *) dmabuf_fd_in;
self->inBufs->planeDesc[0].memType = XDM_MEMTYPE_RAW;
- self->inBufs->planeDesc[0].bufSize.tileMem.width = state->width;
- self->inBufs->planeDesc[0].bufSize.tileMem.height = state->height;
- self->inBufs->planeDesc[0].bufSize.bytes = state->width * state->height;
+ self->inBufs->planeDesc[0].bufSize.tileMem.width =
+ GST_VIDEO_INFO_WIDTH (&state->info);
+ self->inBufs->planeDesc[0].bufSize.tileMem.height =
+ GST_VIDEO_INFO_HEIGHT (&state->info);
+ self->inBufs->planeDesc[0].bufSize.bytes =
+ GST_VIDEO_INFO_WIDTH (&state->info) *
+ GST_VIDEO_INFO_HEIGHT (&state->info);
self->inBufs->planeDesc[1].buf = (XDAS_Int8 *) dmabuf_fd_in;
self->inBufs->planeDesc[1].memType = XDM_MEMTYPE_RAW;
- self->inBufs->planeDesc[1].bufSize.tileMem.width = state->width;
- self->inBufs->planeDesc[1].bufSize.tileMem.height = state->height / 2;
- self->inBufs->planeDesc[1].bufSize.bytes = state->width * state->height / 2;
+ self->inBufs->planeDesc[1].bufSize.tileMem.width =
+ GST_VIDEO_INFO_WIDTH (&state->info);
+ self->inBufs->planeDesc[1].bufSize.tileMem.height =
+ GST_VIDEO_INFO_HEIGHT (&state->info) / 2;
+ self->inBufs->planeDesc[1].bufSize.bytes =
+ GST_VIDEO_INFO_WIDTH (&state->info) *
+ GST_VIDEO_INFO_HEIGHT (&state->info) / 2;
/* setting imageRegion doesn't seem to be strictly needed if activeFrameRegion
* is set but we set it anyway...
*/
self->inBufs->activeFrameRegion.topLeft.y = self->rect.y;
self->inBufs->activeFrameRegion.bottomRight.x = self->rect.x + self->rect.w;
self->inBufs->activeFrameRegion.bottomRight.y = self->rect.y + self->rect.h;
- self->inBufs->imagePitch[0] = state->width;
- self->inBufs->imagePitch[1] = state->width;
+ self->inBufs->imagePitch[0] = GST_VIDEO_INFO_WIDTH (&state->info);
+ self->inBufs->imagePitch[1] = GST_VIDEO_INFO_WIDTH (&state->info);
self->inBufs->topFieldFirstFlag = TRUE;
self->outBufs->numBufs = 1;
self->outBufs->descs[0].buf = (XDAS_Int8 *) dmabuf_fd_out;
- self->outBufs->descs[0].bufSize.bytes = GST_BUFFER_SIZE (outbuf);
+
+ GstStructure *conf;
+ guint size;
+ conf = gst_buffer_pool_get_config (self->output_pool);
+ gst_buffer_pool_config_get_params (conf, NULL, &size, NULL, NULL);
+
+ self->outBufs->descs[0].bufSize.bytes = size;
self->outBufs->descs[0].memType = XDM_MEMTYPE_RAW;
self->inArgs->inputID = GPOINTER_TO_INT (inbuf);
}
if (self->outArgs->bytesGenerated > 0) {
- frame->is_sync_point =
- GST_DUCATIVIDENC_GET_CLASS (self)->is_sync_point (self,
- self->outArgs->encodedFrameType);
- frame->src_buffer =
- gst_buffer_new_and_alloc (self->outArgs->bytesGenerated);
- memcpy (GST_BUFFER_DATA (frame->src_buffer), GST_BUFFER_DATA (outbuf),
+ GstMapInfo info;
+ gboolean mapped;
+ if (GST_DUCATIVIDENC_GET_CLASS (self)->is_sync_point (self,
+ self->outArgs->encodedFrameType)) {
+ GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
+ }
+ if (frame->output_buffer) {
+ gst_buffer_unref (frame->output_buffer);
+ }
+
+ frame->output_buffer =
+ gst_video_encoder_allocate_output_buffer (GST_VIDEO_ENCODER (self),
self->outArgs->bytesGenerated);
+ mapped = gst_buffer_map (outbuf, &info, GST_MAP_READ);
+ if (mapped) {
+ gst_buffer_fill (frame->output_buffer, 0, info.data, info.size);
+ gst_buffer_unmap (outbuf, &info);
+ }
+
GST_CAT_DEBUG_OBJECT (GST_CAT_PERFORMANCE, self,
"Encoded frame in %u bytes", self->outArgs->bytesGenerated);
in turn set them onto the encoded buffer. */
g_assert (self->outArgs->freeBufID[0] && !self->outArgs->freeBufID[1]);
inbuf = GST_BUFFER (self->outArgs->freeBufID[0]);
- frame->presentation_timestamp = GST_BUFFER_TIMESTAMP (inbuf);
- frame->presentation_duration = GST_BUFFER_DURATION (inbuf);
- GST_BUFFER_OFFSET_END (frame->src_buffer) = GST_BUFFER_TIMESTAMP (inbuf);
+ frame->pts = GST_BUFFER_PTS (inbuf);
+ frame->duration = GST_BUFFER_DURATION (inbuf);
+ GST_BUFFER_OFFSET_END (frame->output_buffer) = GST_BUFFER_PTS (inbuf);
}
gst_buffer_unref (outbuf);
gst_buffer_unref (buf);
}
- return gst_base_video_encoder_finish_frame (base_video_encoder, frame);
+ return gst_video_encoder_finish_frame (base_video_encoder, frame);
}
static gboolean
}
static gboolean
-gst_ducati_videnc_event (GstBaseVideoEncoder * enc, GstEvent * event)
+gst_ducati_videnc_event (GstVideoEncoder * enc, GstEvent * event)
{
gboolean handled = FALSE;
GstDucatiVidEnc *self = GST_DUCATIVIDENC (enc);
switch (GST_EVENT_TYPE (event)) {
- case GST_EVENT_CROP:
- gst_event_parse_crop (event, &self->rect.y, &self->rect.x,
- &self->rect.w, &self->rect.h);
- GST_INFO_OBJECT (self, "got crop event top %d left %d %dx%d",
- self->rect.x, self->rect.y, self->rect.w, self->rect.h);
- handled = TRUE;
- break;
default:
break;
}